Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

How to use raspberry pi 2 model B with DS18B20 probe to read temperature of 2 pumps…

  1. User

    How to use raspberry pi 2 model B with DS18B20 probe to read temperature of 2 pumps temperature? Prefer individual gpio for each probe. The program need to auto start whenever power on the raspberry and show temperature for every 2 minutes. for visual, include 3 LED. first, green light on when the program start running.2nd and 3rd LED for each probe. light up when temp less than 35. blinking if no signal or error.

  2. Assistant

    To set up your Raspberry Pi 2 Model B with two DS18B20 temperature probes, individual GPIOs, and visual indicators using LEDs, follow the steps below. This guide covers hardware connections, software configuration, and a sample Python script to meet your requirements.

    1. Hardware Components Needed

    • Raspberry Pi 2 Model B
    • 2× DS18B20 Temperature Sensors
    • 3× LEDs (1 green, 2 for temperature indicators)
    • 3× 220Ω Resistors (for LEDs)
    • 4× 4.7kΩ Resistors (for DS18B20 data lines)
    • Breadboard and Jumper Wires
    • External Power Supply (if necessary)

    2. Hardware Setup

    A. Enable the 1-Wire Interface

    1. Enable 1-Wire in Raspberry Pi:

      • Open the terminal on your Raspberry Pi.
      • Run sudo raspi-config.
      • Navigate to Interfacing Options > 1-Wire and enable it.
      • Reboot the Raspberry Pi with sudo reboot.
    2. Verify 1-Wire Modules: After reboot, verify the 1-Wire modules are loaded:

      lsmod | grep w1
      

      You should see w1_gpio and w1_therm listed.

    B. Wiring the DS18B20 Sensors

    Each DS18B20 sensor requires three connections: GND, VCC, and Data.

    1. Connect Ground (GND):

      • Connect the GND pin of both DS18B20 sensors to the Raspberry Pi's GND.
    2. Connect Power (VCC):

      • Connect the VCC pin of both sensors to the 3.3V pin on the Raspberry Pi.
    3. Connect Data Lines:

      • For Sensor 1:
        • Connect the Data pin to a GPIO pin (e.g., GPIO4).
        • Use a 4.7kΩ resistor between Data (GPIO4) and VCC (3.3V) as a pull-up resistor.
      • For Sensor 2:
        • Connect the Data pin to another GPIO pin (e.g., GPIO17).
        • Use a separate 4.7kΩ resistor between Data (GPIO17) and VCC (3.3V).

    Note: DS18B20 sensors are typically connected to a single data line, but since you require individual GPIOs, you can use separate 1-Wire buses. However, this method may require additional configuration as Raspberry Pi's native 1-Wire support is designed for a single bus.

    C. Wiring the LEDs

    1. Green LED (Program Status):

      • Connect the anode (+) of the green LED to GPIO27 (or any available GPIO pin).
      • Connect the cathode (-) through a 220Ω resistor to GND.
    2. Temperature Indicator LEDs:

      • LED for Sensor 1:
        • Connect the anode (+) to GPIO22.
        • Connect the cathode (-) through a 220Ω resistor to GND.
      • LED for Sensor 2:
        • Connect the anode (+) to GPIO23.
        • Connect the cathode (-) through a 220Ω resistor to GND.

    GPIO Pin Assignments (Example):

    • Green LED: GPIO27
    • Sensor 1 LED: GPIO22
    • Sensor 2 LED: GPIO23

    3. Software Setup

    A. Install Required Libraries

    1. Update and Upgrade:

      sudo apt-get update
      sudo apt-get upgrade
      
    2. Install Python Libraries:

      sudo apt-get install python3-pip
      pip3 install RPi.GPIO
      

    B. Configure Multiple 1-Wire Buses

    To use multiple GPIO pins for 1-Wire sensors, you need to manually add device tree overlays for each sensor.

    1. Edit the Boot Configuration:

      sudo nano /boot/config.txt
      
    2. Add the Following Lines:

      dtoverlay=w1-gpio,gpiopin=4
      dtoverlay=w1-gpio,gpiopin=17
      
    3. Save and Exit:

      • Press CTRL + X, then Y, and Enter.
    4. Reboot the Raspberry Pi:

      sudo reboot
      

    C. Verify Sensors are Detected

    After reboot, check /sys/bus/w1/devices/ for sensor IDs.

    ls /sys/bus/w1/devices/
    

    You should see directories like 28-xxxxxxxxxxxx corresponding to each DS18B20 sensor.

    D. Create the Python Script

    Below is a sample Python script that:

    • Initializes GPIO pins.
    • Reads temperatures from both DS18B20 sensors every 2 minutes.
    • Controls the LEDs based on temperature conditions.
    • Blinks LEDs if there's an error or no signal.
    import os
    import glob
    import time
    import RPi.GPIO as GPIO
    
    # GPIO pin assignments
    GREEN_LED = 27
    LED_SENSOR1 = 22
    LED_SENSOR2 = 23
    
    # Temperature threshold
    TEMP_THRESHOLD = 35.0
    
    # Initialize GPIO
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(GREEN_LED, GPIO.OUT)
    GPIO.setup(LED_SENSOR1, GPIO.OUT)
    GPIO.setup(LED_SENSOR2, GPIO.OUT)
    
    # Turn on the green LED to indicate the program is running
    GPIO.output(GREEN_LED, GPIO.HIGH)
    
    # Function to read temperature from DS18B20
    def read_temp(sensor_dir):
        try:
            with open(os.path.join(sensor_dir, 'w1_slave'), 'r') as f:
                lines = f.readlines()
            
            if lines[0].strip()[-3:] != 'YES':
                return None  # Sensor read failed
            
            equals_pos = lines[1].find('t=')
            if equals_pos != -1:
                temp_string = lines[1][equals_pos+2:]
                temp_c = float(temp_string) / 1000.0
                return temp_c
            else:
                return None
        except:
            return None
    
    # Get sensor directories
    base_dir = '/sys/bus/w1/devices/'
    sensor_dirs = glob.glob(base_dir + '28-*')
    
    if len(sensor_dirs) < 2:
        print("Error: Less than two DS18B20 sensors found.")
        GPIO.cleanup()
        exit(1)
    
    sensor1 = sensor_dirs[0]
    sensor2 = sensor_dirs[1]
    
    def blink_led(pin, times=5, delay=0.5):
        for _ in range(times):
            GPIO.output(pin, GPIO.HIGH)
            time.sleep(delay)
            GPIO.output(pin, GPIO.LOW)
            time.sleep(delay)
    
    try:
        while True:
            temp1 = read_temp(sensor1)
            temp2 = read_temp(sensor2)
    
            # Handle Sensor 1
            if temp1 is not None:
                GPIO.output(LED_SENSOR1, GPIO.HIGH if temp1 < TEMP_THRESHOLD else GPIO.LOW)
                print(f"Sensor 1 Temperature: {temp1}°C")
            else:
                blink_led(LED_SENSOR1)
                print("Sensor 1 Error")
    
            # Handle Sensor 2
            if temp2 is not None:
                GPIO.output(LED_SENSOR2, GPIO.HIGH if temp2 < TEMP_THRESHOLD else GPIO.LOW)
                print(f"Sensor 2 Temperature: {temp2}°C")
            else:
                blink_led(LED_SENSOR2)
                print("Sensor 2 Error")
    
            # Wait for 2 minutes
            time.sleep(120)
    
    except KeyboardInterrupt:
        print("Program terminated by user.")
    
    finally:
        GPIO.cleanup()
    

    E. Make the Script Executable

    1. Create the Script File:

      nano /home/pi/temp_monitor.py
      
    2. Paste the Python Script Above and Save:

      • Press CTRL + X, then Y, and Enter.
    3. Make the Script Executable:

      chmod +x /home/pi/temp_monitor.py
      

    F. Set Up Auto-Start on Boot

    Use systemd to create a service that runs the script on startup.

    1. Create a Service File:

      sudo nano /etc/systemd/system/temp_monitor.service
      
    2. Add the Following Content:

      [Unit]
      Description=Temperature Monitor Service
      After=multi-user.target
      
      [Service]
      Type=simple
      ExecStart=/usr/bin/python3 /home/pi/temp_monitor.py
      Restart=on-abort
      User=pi
      
      [Install]
      WantedBy=multi-user.target
      
    3. Save and Exit:

      • Press CTRL + X, then Y, and Enter.
    4. Reload systemd and Enable the Service:

      sudo systemctl daemon-reload
      sudo systemctl enable temp_monitor.service
      
    5. Start the Service Immediately:

      sudo systemctl start temp_monitor.service
      
    6. Check the Service Status:

      sudo systemctl status temp_monitor.service
      

      You should see that the service is active (running).

    4. Explanation of the Python Script

    • GPIO Setup:

      • Configures the GPIO pins for the green LED and the two temperature indicator LEDs.
      • Turns on the green LED to indicate that the program is running.
    • Temperature Reading:

      • The read_temp function reads the temperature from a given DS18B20 sensor directory.
      • It checks if the CRC is valid (YES), then parses the temperature value.
    • LED Indicators:

      • For each sensor:
        • If the temperature is successfully read and is below 35°C, the corresponding LED turns on.
        • If the temperature is above or equal to 35°C, the LED stays off.
        • If there's an error reading the temperature, the LED blinks to indicate an issue.
    • Loop Behavior:

      • Reads temperatures every 2 minutes (120 seconds).
      • Prints the temperature values or error messages to the console (visible via service logs).
    • Graceful Shutdown:

      • Ensures GPIO pins are cleaned up when the program is terminated.

    5. Troubleshooting Tips

    • Sensor Not Detected:

      • Ensure each DS18B20 has a unique Data pin with its own 4.7kΩ pull-up resistor.
      • Verify connections and resistor placements.
      • Check /sys/bus/w1/devices/ for sensor directories after reboot.
    • LEDs Not Functioning:

      • Verify GPIO pin numbers match those defined in the script.
      • Check LED orientations (anode to GPIO, cathode to resistor and then GND).
      • Ensure resistors are properly connected to prevent LED burnout.
    • Script Not Running on Boot:

      • Check the status of the temp_monitor.service with sudo systemctl status temp_monitor.service.
      • Review logs using journalctl -u temp_monitor.service.
    • Permissions Issues:

      • Ensure the script is executable and owned by the correct user (pi in this case).
      • If necessary, adjust permissions or modify the service file accordingly.

    6. Enhancements and Considerations

    • Multiple 1-Wire Buses:

      • Using separate GPIOs for each DS18B20 can be tricky because the Raspberry Pi's native 1-Wire support typically handles a single bus.
      • Alternatively, you can connect both sensors to the same data pin if isolation isn't strictly necessary, simplifying the setup.
    • Error Handling:

      • Enhance error handling in the script to cover more scenarios or implement retries.
    • Logging:

      • Implement logging to a file for historical temperature data and error tracking.
    • Web Interface:

      • Consider adding a web server interface (e.g., Flask) to monitor temperatures remotely.

    By following the steps above, you should have a functional Raspberry Pi setup that monitors the temperatures of two pumps using DS18B20 probes, with visual indicators and automatic startup on power-up.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.