This walkthrough will demonstrate how you can use the EdgePi to automatically turn on a fan when room temperature gets too high.
¶ What you'll need
- Any EdgePi model (learn how to setup)
- Thermocouple probe for temperature monitoring
- 3.3-24V DC powered fan
¶ How it works
Your EdgePi will be connected to a thermocouple and a DC fan. The thermocouple will continuously monitor the room temperature. The EdgePi will turn on a DC fan when the thermocouple detects a temperature that is higher than a predetermined threshold. Once the room temperature dips a few degrees below the threshold temperature, the fan will turn off.
¶ Connecting the hardware
- Connecting the fan:
a. Attach the positive wire into any of the A/D output ports and the negative wire into a GND port.
b. This walkthrough will use ports A/D output port 5 and GND port 3. - Connecting the thermocouple probe:
a. Attach the thermocouple probe using the correct TC ports (29,30).
Ensure the polarity is correct when attaching the thermocouple. Please refer to the labelling on the EdgePi.
¶ Creating the program with Python
All the code required for this project can be found on the project's GitHub repository.
¶ Opening a project in VsCode
- Setup VsCode and remote SSH into your EdgePi. See how.
- Open a project environment in VsCode:
a. Create a project folder in your desired directory.
b. Its best to use a virtual environment for any project you do. To install the virtual environment package, insert the following command into the terminal:
$ sudo apt-get install python3-venv
c. Create a venv within your project folder by using the following command:
$ python -m venv venv
d. Activate the venv with the following command:
$ source venv/bin/activate - Install the EdgePi SDK:
a. Install the SDK with the following:
$ python3 -m pip install edgepi-python-sdk
b. Full documentation for the SDK can be found here. - For a more in-depth tutorial in setting up the venv and installing the SDK, see here.
¶ Reading temperature with the thermocouple
Let's first test a continuous temperature reading program. Refer to the test_temp_reads.py file on the GitHub repository under sandbox.
- Import the necessary modules
import time
from edgepi.tc.edgepi_tc import EdgePiTC
from edgepi.tc.tc_constants import ConvMode
- Initialize thermocouple and configure it to measure temperature continuously
# initialize thermocouple
edgepi_tc = EdgePiTC()
# set thermocouple to measure temperature continuously
edgepi_tc.set_config(conversion_mode=ConvMode.AUTO)
- Set a max temperature condition. Because we are reading room temperature, it shouldn't be something too high. Nonetheless, ensure the threshold you enter is within your thermocouple's type range.
- Initialize a room temperature variable. Because temperature readings from the TC module return as a tuple (cold junction, linearized temperature), you will want use tuple unpacking.
# set thermocouple to measure temperature continuously
edgepi_tc.set_config(conversion_mode=ConvMode.AUTO)
MAX_TEMP = 28
_,room_temp = edgepi_tc.read_temperatures()
- From here we can create a loop that continuously reads temperature every second while the room temperature is less than the max temperature. Once the condition is met, we will exit the loop and print a message notifying us that room temperature is too high. We can also now revert the sampling configuration back to single.
# sample temperature readings until room temp exceeds max temp
while room_temp < MAX_TEMP:
time.sleep(1) # wait 1 second between samples
_,room_temp = edgepi_tc.read_temperatures()
print(room_temp)
print("TOO HOT! Time to cool down!")
# stop continuous measurements once you're done sampling
edgepi_tc.set_config(conversion_mode=ConvMode.SINGLE)
- Run the file and test that it works. Cover the thermocouple with your fingers to make the temperature rise faster.
Congrats! You now understand the first main concept of the program
¶ Powering the fan
There are two solutions to power the fan. The first demonstration will use analogue output using the DAC module. The second will utilize digital output and the DOUT module.
¶ Powering the fan with analogue out
If you are using a low powered fan (this guide uses a 12V fan), this solution will work fine. It is preferrable to use digital out as you will be able to output higher voltages. For the sake of expirementation, consider following this solution. Refer to the test_dac_fan.py file on the GitHub repository under sandbox.
- Import the necessary modules.
from edgepi.dac.dac_constants import DACChannel as Ch
from edgepi.dac.edgepi_dac import EdgePiDAC
- Initialize DAC and turn on gain so that we can reach a higher voltage output. When gain is off, voltage output ranges from 0-5V and when when gain is on it ranges from 0-10V.
# initialize DAC
edgepi_dac = EdgePiDAC()
# setting DAC range 0-10V
edgepi_dac.set_dac_gain(True)
- Write voltage to the correct output pin.
- Read the DAC state to ensure everything works correctly.
# write voltage value of 10 V to analog out pin number 4
edgepi_dac.write_voltage(Ch.AOUT4, 10)
# read state of DAC output 4
code, voltage, gain = edgepi_dac.get_state(Ch.AOUT4, True, True, True)
print(code,voltage,gain)
The port on the EdgePi is different from the output channel number. In our case, we used port 5 and A/D output pin number 4. Ensure you read the labelling on the EdgePi correctly.
- Run the file and test that your fan powers on.
- To turn off the fan, write a voltage value of 0V to the corresponding pin and rerun the file or use
edgepi_dac.reset()at the end of your code.
.reset()can be overkill as it resets all the analogue output pins
¶ Powering the fan using digital output
Refer to the test_dout_fan.py file on the GitHub repository under sandbox.
- Import the necessary modules.
from edgepi.gpio.gpio_constants import GpioPins
from edgepi.digital_output.edgepi_digital_output import EdgePiDigitalOutput
- Create a new digital output instance.
# initialize DOUT
edgepi_dout = EdgePiDigitalOutput()
- Set the GpioPin corresponding to the digital output pin to output direction.
# set GpioPin 4 to OUT direction
edgepi_dout.digital_output_direction(GpioPins.DOUT4, False)
- Set the corresponding GpioPin state to High/On.
# set Gpiopin 4 to High/on
edgepi_dout.digital_output_state(GpioPins.DOUT4, True)
- Run your python file and test that your fan turns on.
- To turn off your fan, change the output state to
Falseand rerun your python file.
Congrats! You now understand the second main concept of the program.
¶ Putting it all together
Whether you used DAC or DOUT to power your fan, the final solution should look similar. Refer to the dac_solution.py and dout_solution.py files on GitHub respectively.
- The first thing we should do is import all the neccessary modules needed into our main project file.
import time
from edgepi.gpio.gpio_constants import GpioPins
from edgepi.digital_output.edgepi_digital_output import EdgePiDigitalOutput
from edgepi.tc.edgepi_tc import EdgePiTC
from edgepi.tc.tc_constants import ConvMode
- Next we create new thermocouple and digital output instances and configure the thermocouple so that it can sample temperatures continuously.
# Initialize new Thermocouple and DOUT
edgepi_tc = EdgePiTC()
edgepi_dout = EdgePiDigitalOutput()
# set thermocouple to measure temperature continuously
edgepi_tc.set_config(conversion_mode=ConvMode.AUTO)
- Next we should initialize the necessary variables for our program. We need a variable to store our maximum temperature threshold, a variable to set a hysteresis to finish the cooling process and a variable to store current room temperatures. We also want a variable to check if the fan is on or off.
# set max temp condition
MAX_TEMP = 28
# set hysteresis for turning off fan
FINISH_TEMP = MAX_TEMP - 4
# Check if fan is off/on
FAN_STATE = False
- The next step is to create a main a loop that continually samples room temperature and checks our temperature conditions. We can start by sampling the room temperature.
RUN = True
while RUN:
# wait 1 second between samples
time.sleep(1)
# read cold-junction and linearized thermocouple temperatures
_, room_temp = edgepi_tc.read_temperatures()
# print room temperature
print(f"{room_temp} degrees Celsius")
- Next we check if room temperature exceeds the maximum temperature threshold. If it does, we will turn on the fan if it hasn't already been turned on.
# turn on fan if room temp exceeds max temp and fan hasn't already been turned on
if room_temp > MAX_TEMP and not FAN_STATE:
print("TOO HOT! Time to cool down!")
# setting GpioPin 4 to output direction
edgepi_dout.digital_output_direction(GpioPins.DOUT4, False)
# setting GpioPin 4 to High/On
edgepi_dout.digital_output_state(GpioPins.DOUT4, True)
# turn fan state on
FAN_STATE = True
- Now we check if the room temperature has dropped down a few degrees from out maximum threshold. If it has we can turn off the fan.
if room_temp < FINISH_TEMP and FAN_STATE:
print("Finished Cooling!")
# setting GpioPin 4 to Low/Off
edgepi_dout.digital_output_state(GpioPins.DOUT4, False)
# turn fan state off
FAN_STATE = False
Congrats! You should have a fully functional automatic fan system!
.gif)
¶ Conclusion
Congrats on completing this simple EdgePi project! You should now understand the basics of connecting hardware to your EdgePi and interacting with it using the SDK.