Contrôleur de ventilateur avec une carte Raspberry Pi et des modules Pmods

Dans ce projet, nous utiliserons des modules d'extension Digilent Pmods ainsi qu'une platine Raspberry Pi 4 pour mesurer la température, contrôler la vitesse d'un moteur à courant continu, afficher les données et contrôler l'appareil. 
 



Une platine Digilent Pmod HAT est utilisée pour connecter les modules Pmods à la platine Raspberry Pi 4. Le contrôleur de moteur aura deux modes: un dans lequel la vitesse du moteur change en fonction de la température (dans ce mode, les limites de température pour 0% et 100% de la vitesse du moteur peuvent être réglées sur l'interface utilisateur) et un deuxième mode, dans lequel le moteur tourne à vitesse constante pendant un temps défini, puis il est arrêté pour le même temps (dans ce mode, la vitesse du moteur et le temps sont les paramètres contrôlables par l'utilisateur) . L'interface utilisateur sera utilisée pour changer de mode.

Inventaire nécessaire pour réaliser cette application:

1. Matériel

- Platine Raspberry Pi 4 Model B
- Platine Pmod HAT Adapter
- Module Pmod TC1
- Module Pmod HB3
- Module Pmod KYPD
- Module Pmod OLEDrgb
- Module Pmod TPH2
- Module un moteur 5V DC
- Des câbles MTE
- un petit tournevis (pour fixer les boulons dans les borniers)

2. Logiciel sur Raspberry Pi
 
- Python 3 - il est préinstallé sur le système d'exploitation Raspberry Pi par défaut
- Visual Studio Code - ou tout autre éditeur de texte de votre choix

Description du matériel utilisé:

Platine Pmod HAT: Cette platine possède 5 connecteurs principaux et trois cavaliers. En haut, le connecteur standard Raspberry Pi HAT peut être trouvé. L'adaptateur dispose de trois connecteurs 2x6 Digilent Pmod (JA, JB et JC) et chacun d'eux peut également être utilisé comme deux connecteurs 1x6 Pmod séparés (par exemple, JA peut être séparé en JAA et JAB). Tous les ports Pmod contiennent une masse et une broche 3,3 V pour alimenter le module Pmod qui y sera connecté. En plus de la fonction GPIO (General Purpose Input / Output), vous pouvez utiliser JAA et JBA comme interface SPI, JBB comme interface I2C et JCA comme interface UART. La carte Pmod HAT dispose également d'une prise DC d'entrée 5 V, de cavaliers permettant des résistances de pull-up sur les lignes I2C et d'un cavalier qui permet d'écrire dans la mémoire interne des Pmods.

		Module Pmod OLEDgrb: Le Pmod OLEDrgb est un écran LED RVB organique de 96 x 64 pixels avec une résolution couleur de 16 bits. Le module contient un pilote d'affichage qui communique avec les cartes ou systèmes hôtes via des liaisons SPI et GPIO. Pour ce projet, nous connecterons le module Pmod OLEDrgb aux ports JA ou JB sur l'adaptateur Pmod HAT qui prend en charge la communication SPI.

Module Pmod KYPD: Le module Pmod KYPD dispose de 16 boutons poussoirs fugitifs, disposés en 4 lignes et 4 colonnes. En pilotant les lignes des colonnes à une basse tension de niveau logique une à la fois, les utilisateurs peuvent lire la tension de niveau logique correspondante sur chacune des lignes pour déterminer quel bouton, le cas échéant, est actuellement enfoncé (principe de lecture d'un clavier matricé). L'appareil communique avec Raspberry Pi via GPIO. Nous pouvons le connecter à n'importe quel port du Pmod HAT.

Module Pmod TC1: Le Pmod TC1 contient un fil de thermocouple de type K et un convertisseur thermocouple-numérique à jonction froide. Le fil de thermocouple peut mesurer des températures de -73 ° C à 482 ° C avec une précision de ± 2 ° C et le module renvoie une valeur numérique signée de 14 bits. Le module Pmod TC1 doit être connecté aux ports JAA ou JBA (la partie supérieure des ports JA ou JB) sur le Pmod HAT pour la communication SPI .                                 .

Module Pmod HB3: Le Pmod HB3 est un driver de moteur CC à pont en H, avec une sortie allant jusqu'à 12 V et 2 A. Le module communique avec la carte Raspberry Pi via les GPIO. Il peut être connecté à n'importe quel port de l'adaptateur Pmod HAT. Si un moteur 5 V est utilisé, l'alimentation du moteur peut être fournie par l'une des broches 5 V PW du Raspberry Pi, qui sont capables de produire environ 2 A, lorsque le microcontrôleur a une alimentation appropriée.                                         .

Module Pmod TPH2: Le Pmod TPH2 est un connecteur de test à 12 points. Dans ce projet, il peut être utilisé pour diviser l'un des ports 2x6 Pmod de l' adaptateur Pmod HAT afin que plusieurs Pmods puissent être connectés au même port (à l'aide de câbles MTE).                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .

Platine Raspberry Pi 4: Une carte Raspberry Pi 4 Model B sera utilisée en tant que "cerveau" dans cette application avec le système d'exploitation Raspberry Pi recommandé. Vous pouvez utiliser d'autres modèles et systèmes d'exploitation Raspberry Pi capables d'exécuter Python 3. La présentation détaillée de l'installation et de la configuration du système d'exploitation ne sera détaillée dans notre note d'application .                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .

  


Configuration matérielle:  
 
Les modules Pmod OLEDrgb et Pmod TC1 (avec interface SPI) ne peuvent être connectés qu'à des ports spécifiques sur la platine Pmod HAT. le module Pmod OLEDrgb est connecté au port JA tandis que le module Pmod TC1 ne peut être connecté qu'au port JBA. Le module Pmod KYPD est connecté au port JC et le module Pmod HB3 au port JBB. Le module Pmod TPH2 peut être utilisé pour briser le port JB afin que les deux modules Pmod (TC1 et HB3) puissent être connectés au même port. Connectez le fil du thermocouple et le moteur aux borniers respectifs. Comme mentionné ci-dessous, vous pouvez alimenter le moteur directement à partir de la platine Raspberry Pi. Le fichier Fritzing™ joint montre les connexions à réaliser.
 
 

 

Configuration du logiciel:  
 

Tout d'abord, vous devez activer le port SPI et le port série sur la carte Raspberry Pi. Ouvrez un terminal, puis tapez: sudo raspi-config

 

 
Dans le menu, sélectionnez 3. Options d'interface, puis sélectionnez P4 SPI et activez-le. Sélectionnez à nouveau les options d'interface , puis sélectionnez P6 Serial Port . La première chose qui apparaît, le shell de connexion , peut être laissée désactivée. Il vous suffit d'activer le matériel du port série dans la deuxième invite.
 
 
Ensuite, vous changez la version par défaut de Python en Python 3. Le système d'exploitation Raspberry Pi recommandé est livré avec Python 2 et Python 3 préinstallés. Vérifiez la version Python avec les commandes suivantes:

python --version
python3 --version
 
 


Si Python 3 3.6 est préinstallé ou une version antérieur, vous devez installer une version plus récente via les commandes:
sudo apt-get installer python3.x

où x est le numéro de version. Par exemple, nous utilisons Python 3.7 dans ce projet (car il s'agit de la version préinstallée sur le système d'exploitation Raspberry Pi recommandé). Donc, vous allez taper sudo apt-get install python 3.7


Pour changer la version python par défaut en Python 3, exécutez la commande suivante:
sudo update-alternatives --install / usr / bin / python python / usr / bin / pythonn3 1

Maintenant, Python 3 devrait apparaître comme l'interpréteur par défaut.

La dernière étape consiste à installer les modules requis. Pour cela, tapez simplement les commandes suivantes dans le terminal:
sudo pip installer designspark.pmod

  

Code:  
 
1. fan_controller.py

Le script Python se compose de trois modules: fan_controller.py, keypad.py et display.py. Le fan_controller.py est le module principal. Dans ce module, tout d'abord, nous importons toutes les bibliothèques et modules requis, créons une classe et définissons des variables:
 

1. #!/usr/bin/env python  
2.   
3.   
4. """ 
5. The controller sets the speed of a fan according to temperature (mode 1), 
6. or lets the fan run with a constant speed for a given time (mode 2). 
7. Temperature is measured with Pmod TC1. 
8. The motor is driven by Pmod HB3. 
9. The user interface is realized with Pmod OLEDrgb and Pmod KYPD. 
10. """  
11.   
12. # import necessary modules  
13. from DesignSpark.Pmod.HAT import createPmod  
14. from luma.core.render import canvas  
15. from datetime import datetime, timedelta  
16. import time  
17.   
18. # import own modules  
19. import display  
20. import keypad  
21.   
22. # create objects for each pmod  
23. TC1 = createPmod('TC1', 'JBA')  
24. HB3 = createPmod('HB3', 'JBB')  
25. keypad.KYPD = createPmod('KYPD', 'JC')  # Pmod KYPD and Pmod OLEDrgb are  
26. display.OLED = createPmod('OLEDrgb', 'JA')  # used in separate modules  
27.   
28.   
29. class settings:  
30.     """ this class contains "global variables" """  
31.     TEMP_AVG = 500  # number of temperature measurements to average  
32.     TEMP_MIN = 22.0  # temperature for 0% fan speed  
33.     TEMP_MAX = 35.0  # temperature for 100% fan speed  
34.     TIME_RUN = 15  # number of minutes to run (mode 2)  
35.     CONST_SPEED = 75    # speed in mode 2  
36.     MOTOR_REV = False  # reverse the rotation of the motor  
37.     MODE = 1  # starting mode  

 
Ensuite, les fonctions sont définies. Les quatre fonctions sont action_M1 () , qui règle la vitesse du moteur en fonction de la température mesurée et moyenne, action_M2 () , dont la vitesse du moteur est définie, puis la fonction attend le temps défini (les pressions sur les touches terminent la fonction). La fonction set_param () définit un paramètre et la fonction decode_key () décide quel menu ou sous-menu afficher en appuyant sur une touche.
  
 

1. def action_M1():  
2.   
3.     """ this is done in mode 1 """  
4.     # get average temperature  
5.     average_temp = 0.0  
6.     for _ in range(settings.TEMP_AVG):  
7.         average_temp = average_temp + TC1.readCelcius()  
8.     average_temp = average_temp / settings.TEMP_AVG  
9.   
10.     # calculate the speed from the temperature  
11.     average_temp = average_temp - settings.TEMP_MIN  
12.     max_temp = settings.TEMP_MAX - settings.TEMP_MIN  
13.     if max_temp <= 0:  
14.         max_temp = 1  
15.     speed = 0  
16.     if average_temp > 0:  
17.         speed = average_temp * 100 / max_temp  
18.   
19.     # limit the speed  
20.     if speed > 100:  
21.         speed = 100  
22.     elif speed < 0:  
23.         speed = 0  
24.   
25.     # set the speed of the motor  
26.     if settings.MOTOR_REV:  
27.         HB3.reverse(speed)  
28.     else:  
29.         HB3.forward(speed)  
30.   
31.     # display data  
32.     display.data_M1(average_temp, speed, settings.TEMP_MIN,  
33.                     settings.MODE)  
34.     return  
35.   
36.   
37. def action_M2():  
38.     """ this is done in mode 2 """  
39.     # calculate stop time  
40.     stop_time = datetime.now() + timedelta(minutes=settings.TIME_RUN)  
41.   
42.     # set motor speed  
43.     if settings.MOTOR_REV:  
44.         HB3.reverse(settings.CONST_SPEED)  
45.     else:  
46.         HB3.forward(settings.CONST_SPEED)  
47.   
48.     # wait but check buttons  
49.     try:  
50.         # if the time didn't expire, continue  
51.         while datetime.now() < stop_time:  
52.             # display data in every iteration (the time will change)  
53.             display.data_M2(settings.CONST_SPEED, stop_time -  
54.                             datetime.now(), settings.MODE)  
55.             # check for keypress  
56.             if keypad.KYPD.getKey() != None:  
57.                 raise keypad.KeyPressed  
58.             pass  
59.     # on keypress, stop the motor and exit  
60.     except keypad.KeyPressed:  
61.         HB3.forward(0)  
62.         return  
63.   
64.     # calculate stop time  
65.     stop_time = datetime.now() + timedelta(minutes=settings.TIME_RUN)  
66.   
67.     # stop motor  
68.     HB3.reverse(0)  
69.   
70.     # wait but check buttons  
71.     try:  
72.         # if the time didn't expire, continue  
73.         while datetime.now() < stop_time:  
74.             # display data in every iteration (the time will change)  
75.             display.data_M2(0, stop_time - datetime.now(), settings.MODE)  
76.             # check for keypress  
77.             if keypad.KYPD.getKey() != None:  
78.                 raise keypad.KeyPressed  
79.             pass  
80.     # on keypress, stop the motor and exit  
81.     except keypad.KeyPressed:  
82.         HB3.forward(0)  
83.         return  
84.     return  
85.   
86.   
87. def set_param(text, unit):  
88.     """ get a parameter and display it """  
89.     # display a text to ask for the parameter  
90.     display.require(text)  
91.     # read the parameter  
92.     parameter = keypad.get_param()  
93.     # display the parameter  
94.     display.parameter(text, parameter, unit)  
95.     # wait for a button to exit  
96.     keypad.wait_for_key()  
97.     return parameter  
98.   
99.   
100. def decode_key(stage, key=None):  
101.     """ this is done, when a key is pressed """  
102.     # skip the main menu, if the key was pressed,  
103.     # when a submenu was displayed  
104.     if stage == 0:  
105.         # display the main menu  
106.         display.menu()  
107.         # wait for a keypress  
108.         key = keypad.wait_for_key()  
109.   
110.     # if "A" is pressed in the main menu, or mode 1 submenu  
111.     # was requested  
112.     if key == "A" or stage == 1:  
113.         # set mode to 1  
114.         settings.MODE = 1  
115.         # display submenu for mode 1  
116.         display.menu_M1()  
117.         # wait for a keypress  
118.         key = keypad.wait_for_key()  
119.         # if "C" is pressed in the submenu  
120.         if key == "C":  
121.             # request and set the minimum temperature  
122.             settings.TEMP_MIN = set_param("low temperature limit", "\xb0C")  
123.             # go back to the mode 1 submenu  
124.             decode_key(1)  
125.         # if "D" is pressed in the submenu  
126.         elif key == "D":  
127.             # request and set the minimum temperature  
128.             settings.TEMP_MAX = set_param("high temperature limit", "\xb0C")  
129.             # go back to the mode 1 submenu  
130.             decode_key(1)  
131.         else:  
132.             # go back to the main menu  
133.             decode_key(0)  
134.   
135.     # if "B" is pressed in the main menu, or mode 2 submenu  
136.     # was requested  
137.     elif key == "B" or stage == 2:  
138.         # set mode to 2  
139.         settings.MODE = 2  
140.         # display submenu for mode 2  
141.         display.menu_M2()  
142.         # wait for keypress  
143.         key = keypad.wait_for_key()  
144.         # if "C" is pressed in the submenu  
145.         if key == "C":  
146.             # request and set the speed  
147.             settings.CONST_SPEED = set_param("speed", "%")  
148.             # go back to the mode 2 submenu  
149.             decode_key(2)  
150.         # if "D" is pressed in the submenu  
151.         elif key == "D":  
152.             # request and set the runtime  
153.             settings.TIME_RUN = set_param("nr. of minutes", "min")  
154.             # go back to the mode 2 submenu  
155.             decode_key(2)  
156.         else:  
157.             # go back to the main menu  
158.             decode_key(0)  
159.     return  

 

Maintenant, nous créons le "châssis" du script. Il contient la boucle principale, dans laquelle les pressions sur les touches sont vérifiées. Si aucune touche n'est enfoncée, l'action du mode actuel est exécutée. Si une touche est enfoncée, le moteur est arrêté et la clé est décodée, le menu correspondant est affiché. Lorsque vous quittez le script, un nettoyage approprié est nécessaire.
 

1. # main program  
2.   
3. try:  
4.     # setup  
5.     keypad.KYPD.setKeyMapDefault()  # set default key map  
6.     time.sleep(1)  # wait a second  
7.   
8.     # main loop  
9.     while True:  
10.         # if no key was pressed  
11.         if keypad.get_key() == None:  
12.             # if the mode variable is 1  
13.             if settings.MODE == 1:  
14.                 # call function for mode 1  
15.                 action_M1()  
16.             # if the mode variable is 2  
17.             elif settings.MODE == 2:  
18.                 # call function for mode 2  
19.                 action_M2()  
20.         # if a key was pressed  
21.         else:  
22.             # stop the motor  
23.             HB3.forward(0)  
24.             # decode the key  
25.             decode_key(0)  
26.   
27. except KeyboardInterrupt:  
28.     # exit on ctrl+c  
29.     pass  
30. finally:  
31.     # close opened connections  
32.     TC1.cleanup()  
33.     HB3.cleanup()  
34.     keypad.KYPD.cleanup()  
35.     display.OLED.cleanup()  

 2. keypad.py

Le module est constitué d'un objet vide ( KYPD ) qui est initialisé dans le fan_controller.py, un type d'exception lorsqu'une touche est enfoncée (en mode 2). Il y a 4 fonctions: get_param () définit un nouveau keymap et mappe les lettres à 0 et lit un nombre à deux chiffres sur le clavier; wait_for_key () est la fonction de lecture de clé de blocage et de blocage; get_key () est le lecteur de clé non-bloquant et non-bloquant; debounce () ne renvoie chaque pression qu'une seule fois. Pour renvoyer une pression sur une touche, la touche doit être relâchée et est vérifiée en validant 1000 états consécutifs «Aucun» du clavier.
 

1. """ 
2. This is the module containing keypad control functions 
3. """  
4.   
5. # import necessary modules  
6. from DesignSpark.Pmod.HAT import createPmod  
7.   
8. # the KYPD object is needed in this module,  
9. # but is initialized in the main program  
10. KYPD = None  
11.   
12.   
13. class KeyPressed(Exception):  
14.     """This exception is raised when a key is pressed"""  
15.     pass  
16.   
17.   
18. def get_param():  
19.     """ this function returns a two digit number 
20.     entered on the Pmod KYPD """  
21.     # set a new keymap: letters are mapped to 0  
22.     keyMap = [['1', '2', '3', '0'], ['4', '5', '6', '0'],  
23.               ['7', '8', '9', '0'], ['0', '0', '0', '0']]  
24.     KYPD.setKeyMap(keyMap)  
25.   
26.     # wait for a keypress  
27.     key = wait_for_key()  
28.     # save the first digit  
29.     parameter = int(key) * 10  
30.     # wait for a keypress  
31.     key = wait_for_key()  
32.     # save the second digit  
33.     parameter = parameter + int(key)  
34.   
35.     # restore default keymap  
36.     KYPD.setKeyMapDefault()  
37.     return parameter  
38.   
39.   
40. def wait_for_key():  
41.     """ this function wait until a key is pressed, 
42.     then returns that key"""  
43.     # read keypresses  
44.     key = KYPD.getKey()  
45.     # read keypresses until a key is pressed  
46.     while key == None:  
47.         key = KYPD.getKey()  
48.     # debounce the keypad  
49.     debounce()  
50.     return key  
51.   
52.   
53. def get_key():  
54.     """ this function returns the debounced keypresses 
55.     non-blocking: returns None if nothing was pressed """  
56.     # get keypress  
57.     key = KYPD.getKey()  
58.     # debounce it  
59.     debounce()  
60.     return key  
61.   
62.   
63. def debounce():  
64.     """ this function debounces the keypad 
65.     if 1000 consecutive states of the keypad 
66.     are "None", the keyes are released """  
67.     # enter in a loop  
68.     flag = True  
69.     while flag:  
70.         # set the flag to False  
71.         flag = False  
72.         # inspect 1000 consecutive states of the keypad  
73.         for _ in range(1000):  
74.             # if a key is pressed  
75.             if KYPD.getKey() != None:  
76.                 # restart the debouncing process  
77.                 flag = True  
78.                 break  
79.     return  

3. display.py

Le module d'affichage a un objet vide ( OLED ) qui est initialisé dans le fan_controller.py, et 7 fonctions pour afficher diverses données. Ces fonctions commencent par une ligne, effacent l'écran et dessinent plusieurs lignes de texte.

1. """ 
2.  
3. This is the module containing display control functions 
4. """  
5.   
6. # import necessary modules  
7. from DesignSpark.Pmod.HAT import createPmod  
8. from luma.core.render import canvas  
9.   
10. # the OLED object is needed in this module,  
11. # but is initialized in the main program  
12. OLED = None  
13.   
14.   
15. def require(text):  
16.     """ display a text to require a parameter """  
17.     with canvas(OLED.getDevice()) as draw:  
18.         # clear the screen  
19.         draw.rectangle(OLED.getDevice().bounding_box,  
20.                        outline="black", fill="black")  
21.         # display some text  
22.         draw.text((20, 10), "Enter the", fill="white")  
23.         draw.text((0, 30), text, fill="red")  
24.     return  
25.   
26.   
27. def parameter(text, number, unit):  
28.     """ display a parameter with unit """  
29.     with canvas(OLED.getDevice()) as draw:  
30.         # clear the screen  
31.         draw.rectangle(OLED.getDevice().bounding_box,  
32.                        outline="black", fill="black")  
33.         # display some text  
34.         draw.text((0, 10), text, fill="white")  
35.         draw.text((30, 30), str(number), fill="green")  
36.         draw.text((45, 30), unit, fill="white")  
37.   
38.         draw.text((25, 45), "Exit", fill="yellow")  
39.         draw.text((5, 52), "press any key", fill="yellow")  
40.     return  
41.   
42.   
43. def data_M1(average_temp, speed, min_temp, mode):  
44.     """ display data in mode 1: temperature and speed """  
45.     with canvas(OLED.getDevice()) as draw:  
46.         # clear the screen  
47.         draw.rectangle(OLED.getDevice().bounding_box,  
48.                        outline="black", fill="black")  
49.   
50.         # dislpay the temperature  
51.         draw.text((5, 0), "Temperature: ", fill="white")  
52.         draw.text((15, 10), "%.2f" % (average_temp + min_temp), fill="green")  
53.         draw.text((50, 10), "\xb0" + "C", fill="white")  
54.   
55.         # display the speed  
56.         draw.text((5, 20), "Fan speed: ", fill="white")  
57.         draw.text((15, 30), "%.2f" % speed, fill="green")  
58.         draw.text((50, 30), "%", fill="white")  
59.   
60.         # display current mode  
61.         draw.text((80, 38), "M" + str(mode), fill="red")  
62.   
63.         # display some text  
64.         draw.text((25, 45), "Menu", fill="yellow")  
65.         draw.text((5, 52), "press any key", fill="yellow")  
66.     return  
67.   
68.   
69. def data_M2(speed, time, mode):  
70.     """ display data in mode 2: speed and remaining time left """  
71.     with canvas(OLED.getDevice()) as draw:  
72.         # clear the screen  
73.         draw.rectangle(OLED.getDevice().bounding_box,  
74.                        outline="black", fill="black")  
75.   
76.         # display the speed  
77.         draw.text((5, 0), "Speed: ", fill="white")  
78.         draw.text((15, 10), str(speed), fill="green")  
79.         draw.text((50, 10), "%", fill="white")  
80.   
81.         # display the time left  
82.         draw.text((5, 20), "Time left: ", fill="white")  
83.         _, remainder = divmod(time.seconds, 3600)  
84.         minutes, seconds = divmod(remainder, 60)  
85.         draw.text((15, 30), str(minutes) + ":" + str(seconds), fill="green")  
86.         draw.text((50, 30), "min:s", fill="white")  
87.   
88.         # display the mode  
89.         draw.text((80, 38), "M" + str(mode), fill="red")  
90.   
91.         # display some text  
92.         draw.text((25, 45), "Menu", fill="yellow")  
93.         draw.text((5, 52), "press any key", fill="yellow")  
94.     return  
95.   
96.   
97. def menu():  
98.     """ display the main menu """  
99.     with canvas(OLED.getDevice()) as draw:  
100.         # clear the screen  
101.         draw.rectangle(OLED.getDevice().bounding_box,  
102.                        outline="black", fill="black")  
103.   
104.         # display option for key "A"  
105.         draw.text((5, 0), "Press ", fill="white")  
106.         draw.text((40, 0), "A", fill="green")  
107.         draw.text((20, 10), "for mode ", fill="white")  
108.         draw.text((75, 10), "1", fill="red")  
109.   
110.         # display option for key "B"  
111.         draw.text((5, 25), "Press", fill="white")  
112.         draw.text((40, 25), "B", fill="green")  
113.         draw.text((20, 35), "for mode", fill="white")  
114.         draw.text((75, 35), "2", fill="red")  
115.   
116.         # display some text  
117.         draw.text((25, 45), "Exit", fill="yellow")  
118.         draw.text((5, 52), "press any key", fill="yellow")  
119.     return  
120.   
121.   
122. def menu_M1():  
123.     "display submenu for mode 1"  
124.     with canvas(OLED.getDevice()) as draw:  
125.         # clear the screen  
126.         draw.rectangle(OLED.getDevice().bounding_box,  
127.                        outline="black", fill="black")  
128.   
129.         # display option for key "C"  
130.         draw.text((5, 0), "Press ", fill="white")  
131.         draw.text((40, 0), "C", fill="green")  
132.         draw.text((50, 0), "to set", fill="white")  
133.         draw.text((0, 10), "low temp. limt", fill="red")  
134.   
135.         # display option for key "D"  
136.         draw.text((5, 25), "Press", fill="white")  
137.         draw.text((40, 25), "D", fill="green")  
138.         draw.text((50, 25), "to set", fill="white")  
139.         draw.text((0, 35), "high temp. limt", fill="red")  
140.   
141.         # display some text  
142.         draw.text((25, 45), "Exit", fill="yellow")  
143.         draw.text((5, 52), "press any key", fill="yellow")  
144.     return  
145.   
146.   
147. def menu_M2():  
148.     "display submenu for mode 2"  
149.     with canvas(OLED.getDevice()) as draw:  
150.         # clear the screen  
151.         draw.rectangle(OLED.getDevice().bounding_box,  
152.                        outline="black", fill="black")  
153.   
154.         # display option for key "C"  
155.         draw.text((5, 0), "Press ", fill="white")  
156.         draw.text((40, 0), "C", fill="green")  
157.         draw.text((50, 0), "to set", fill="white")  
158.         draw.text((0, 10), "constant speed", fill="red")  
159.   
160.         # display option for key "D"  
161.         draw.text((5, 25), "Press", fill="white")  
162.         draw.text((40, 25), "D", fill="green")  
163.         draw.text((50, 25), "to set", fill="white")  
164.         draw.text((0, 35), "run time", fill="red")  
165.   
166.         # display some text  
167.         draw.text((25, 45), "Exit", fill="yellow")  
168.         draw.text((5, 52), "press any key", fill="yellow")  
169.     return  

Exécutez le script
Pour exécuter le script, entrez la ligne suivante dans le terminal:
 

1. python /home/pi/path_to_script/fan_controller.py  

  
où path_to_script est le chemin vers le script Python. Assurez-vous que le Raspberry Pi est allumé. Vous pouvez également ajouter la ligne ci-dessus suivie d'une esperluette dans le fichier /etc/rc.local (voir l'image à droite) afin que Python s'exécute lorsque le Raspberry Pi 4 démarre




  

Essai:  

Allumez la carte Raspberry Pi. Si le script ne démarre pas au démarrage, exécutez le script.

Initialement, la vitesse du moteur est réglée en fonction de la température. Appuyez sur n'importe quelle touche pour accéder au menu principal. Dans le menu principal, choisissez le mode 1 (appuyez sur A) ou 2 (appuyez sur B). Lorsque vous êtes dans l'un des modes, vous pouvez régler les paramètres en appuyant sur C ou D. Vous pouvez quitter les menus en appuyant sur n'importe quelle touche (qui n'est pas répertoriée dans le menu ou le sous-menu).

En mode 1, la vitesse du moteur dépend de la température. Les utilisateurs peuvent définir les limites de température pour une vitesse de 0% et 100% à partir du sous-menu.
 




En mode 2, la vitesse du moteur est constante pendant un temps prédéfini (initialement 15 minutes). Ensuite, le moteur s'arrête pendant le même laps de temps. Les utilisateurs peuvent régler la vitesse du moteur et l'heure en mode 2.
 
 

Ressources:  

- Cliquez ci pour télécharger les programmes sources de cette application

- Cliquez ci pour télécharger les schémas de cette application

 
 
Crédit: @ Digilent Inc - Alex wong