• Première étape
  • Matériel et accessoires ; GPIO
  • Projets
  • Logiciel
    • Serveur Web
  • Arduino & ESP8266
  • Automatisation de la maison
  • Sonstiges
    • News
Facebook Twitter YouTube
Tutorials for Raspberry Pi Tutorials for Raspberry Pi
  • Matériel et accessoires ; GPIO
  • Projets
  • Logiciel
  • Serveur Web
  • Première étape
  • Automatisation de la maison
  • Anglais
  • Allemand
Tutorials for Raspberry Pi Tutorials for Raspberry Pi
Home»Projets»Fabriquez votre propre serre automatique Raspberry Pi

Fabriquez votre propre serre automatique Raspberry Pi

Facebook Twitter LinkedIn Tumblr Email Reddit
Tomaten beim wachsen zusehen, ohne großartig eingreifen zu müssen geht mit einem automatisiertem Gewächshaus.
Share
Facebook Twitter LinkedIn Email Tumblr Reddit Telegram WhatsApp

Dans un nombre de villes croissant, la tendance est à la production de fruits et légumes biologiques ou même autoproduits. Le temps consacré à l’entretien des plantes est peut-être une cause dissuasive. C’est pourquoi ce projet consiste à créer une serre Raspberry Pi automatisée, qui réduit le travail au minimum.

Grâce à l’arrosage, l’aération et l’exposition automatiques, seule la récolte doit être effectuée manuellement à la fin. Toutes les actions (comme l’irrigation) sont contrôlées par des capteurs afin de fournir un résultat optimal. Grâce à sa faible consommation d’espace (environ 1/2 m²), il convient également au balcon urbain.

 

Liste d’achats

Les plantes à faible croissance sont particulièrement adaptées à la serre automatique Raspberry Pi.

Comme la serre Raspberry Pi doit fonctionner de manière aussi autonome que possible, tout ce qui est nécessaire doit être automatisé. Par conséquent, de nombreux accessoires sont nécessaires. Pour un balcon, il est préférable d’utiliser les accessoires suivants :

  • Cadre froid, par exemple 100×60 cm
  • Boîtes à fleurs
  • Raspberry Pi
  • Alimentation 12V 2a
  • Adaptateur jack d’alimentation ADC
  • Pompe submersible 12V / pompe à eau pour l’étang
  • Seau de 10L ou 20L avec couvercle
  • quelques tuyaux de 7mm (1.5-2m)
  • Module RTC DS1307
  • MCP3008 ADC
  • Divers capteurs d’humidité du sol (30-40 cm chacun)
  • Servomoteur
  • Capteur de lumière
  • Résistance 10kΩ
  • LED 12V
  • Relais Reed (min 2)
  • Boîtier étanche (ou équivalent).
  • Ruban d’isolation
  • Câble jumper
  • Mini Breadboard (ou perfboard pour la soudure)
  • Semences (les meilleures plantes à faible croissance : )
    • Tomates (Balconi Rouge)
    • Laitue
    • radis
    • Si vous connaissez d’autres variétés, je serais heureux de recevoir un commentaire.
  • Terreau + éventuels engrais

J’utilise deux des pompes à eau, car j’ai semé dans deux jardinières. Vous pouvez varier le nombre de capteurs pour l’humidité du sol.

Bien sûr, vous pouvez adapter les pièces à votre projet. Si vous avez un cadre froid / une serre plus grande, par exemple, vous pouvez ajuster / optimiser le code ci-dessous pour vos besoins.

Si vous voulez utiliser les GPIOs ci-dessous pour l’alimentation électrique, vous aurez également besoin de ceci :

  • Régulateur L7805
  • Condensateur 2x 10μF
  • optimale : résistance 470Ω.
  • optimale : LED verte
Contenus
  • Installation des bibliothèques requises
  • Alimentation via GPIOs
  • Composants
    • Préparation
    • Régler l’heure
    • Ajustez la luminosité
    • Arrosage automatique
    • Ventilation
    • Boîtier et montage étanches
  • Activation de la serre Raspberry Pi
  • Extensions possibles

 

Installation des bibliothèques requises

Il est préférable de prendre un Raspbian Jessie fraîchement installé et d’ouvrir un terminal (par exemple via SSH). Tout d’abord, nous mettons tout à jour et installons quelques paquets :

sudo apt-get update --yes && sudo apt-get upgrade --yes
sudo apt-get install build-essential python-dev python-pip python-smbus python-openssl git --yes

Le processus peut prendre un certain temps. Vous pouvez commencer à construire le foyer.

Entrez à présent sudo raspi-config et sélectionnez « Interfacing Options » -> « SPI » et activez-le. Même chose avec « I2C ». Redémarrez.

Nous installons ensuite les bibliothèques nécessaires.

  • SpiDev:
    git clone https://github.com/doceme/py-spidev
    cd py-spidev
    sudo python setup.py install
    cd ..
  • Adafruits Library pour les DHT11 / DHT22 (alternativement et directement à partir de GitHub):
    sudo pip install adafruit_python_dht

Alimentation via GPIOs

En principe, vous avez deux façons de connecter le Raspberry Pi à l’alimentation. La première option est généralement le port Micro USB. L’inconvénient, cependant, est que vous avez normalement besoin de deux prises.

C’est pourquoi je montre d’abord comment alimenter le Raspberry Pi par les GPIOs

. La prudence est requise, car une tension trop élevée peut détruire le Pi ! Si vous ne vous sentez pas en sécurité, choisissez l’alimentation par câble USB..

Le régulateur de tension L7805 ( fiche technique ) peut réduire les tensions de 7 à 25V à 5V. Cependant, deux condensateurs sont encore nécessaires. La connexion est la suivante :

Raspberry Pi Greenhouse L7805 Steckplatine

Avant de le connecter au Raspberry Pi, vous pouvez mesurer la tension avec un multimètre.

Les détails peuvent être trouvés ici.

 

Serre Raspberry Pi – Composants

Premièrement, vous pouvez suivre chaque étape et ainsi développer le code du programme ou, comme décrit à la fin du tutoriel, télécharger le code du dépôt Github et l’ajuster ensuite.

Ce tutoriel doit être aussi personnalisable que possible, car chacun a d’autres conditions. C’est pourquoi la partie suivante est divisée en différentes sections individuelles. Ainsi, si vous souhaitez omettre certains composants (par exemple, pas d’horloge en temps réel ou pas d’éclairage), vous pouvez omettre cette partie ou l’adapter en conséquence.

Mais d’abord, les réglages des GPIOs etc. Dans un nouveau dossier

(mkdir Raspberry-Pi-Greenhouse && cd Raspberry-Pi-Greenhouse) nous créons un fichier (sudo nano greenhouse.py) avec le contenu suivant:

Python
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import RPi.GPIO as GPIO
import Adafruit_DHT
from MCP3008 import MCP3008
import SDL_DS1307
import time
 
##################################################################
##################### CUSTOMIZEABLE SETTINGS #####################
##################################################################
SETTINGS = {
    "LIGHT_GPIO":       17,                     # GPIO Number (BCM) for the Relay
    "LIGHT_FROM":       10,                     # from which time the light can be turned on (hour)
    "LIGHT_UNTIL":      20,                     # until which time (hour)
    "LIGHT_CHANNEL":    0,                      # of MCP3008
    "LIGHT_THRESHOLD":  500,                    # if the analog Threshold is below any of those, the light will turn on
    "DHT_GPIO":         27,                     # GPIO Number (BCM) of the DHT Sensor
    "DHT_SENSOR":       Adafruit_DHT.DHT22,     # DHT11 or DHT22
    "TEMP_THRESHOLD":   23.0,                   # in Celcius. Above this value, the window will be opened by the servo
    "SERVO_GPIO":       22,                     # GPIO Number (BCM), which opens the window
    "SERVO_OPEN_ANGLE": 90.0,                   # degree, how much the servo will open the window
    "PLANTS": [
        {
            "NAME":                 "Tomaten",
            "MOISTURE_CHANNELS":    [1, 2],     # of MCP3008
            "MOISTURE_THRESHOLD":   450,        # if the average analog value of all sensors is above of this threshold, the Pump will turn on
            "WATER_PUMP_GPIO":      23,         # GPIO Number (BCM) for the Relais
            "WATERING_TIME":        10,         # Seconds, how long the pump should be turned on
        },
        {
            "NAME":                 "Salat",
            "MOISTURE_CHANNELS":    [3, 4],
            "MOISTURE_THRESHOLD":   450,
            "WATER_PUMP_GPIO":      24,
            "WATERING_TIME":        12,
        },
    ]
}
##################################################################
################# END OF CUSTOMIZEABLE SETTINGS ##################
##################################################################
 

Si vous voulez d’autres GPIO ou d’autres paramètres, vous pouvez les ajuster ici.

Dans les sections suivantes, nous étendons les fonctions (si vous le souhaitez). Vous pouvez trouver le pinout des GPIOs dans cette image.

 

Préparation de la serre Raspberry Pi

Avant d’installer les composants électroniques, il faut construire le cadre froid. Vous pouvez y placer 2 ou 3 grands jardinières (en fonction de leur taille). Vous pouvez y mettre de jeunes plantes ou des graines. Faites attention aux instructions figurant sur l’emballage.

En outre, il est nécessaire de fertiliser le sol. Si vous voulez, vous pouvez aussi prendre du compost spécial tomates ou légumes, qui contient plus de minéraux.

 

Régler l’heure

Si le Pi redémarre (par exemple après une panne de courant), il ne connaît pas l’heure et la date actuelles, s’il n’y a pas de connexion Internet. Par conséquent, les modules d’horloge en temps réel, qui ont une batterie, sont utilisés pour enregistrer la date et l’heure de façon permanente. Cette étape est facultative et peut être omise s’il existe une connexion Internet permanente.

Il est important que les deux résistances (R2 et R3) soient retirées du Tiny RTC (modules I2c) avec un fer à souder. Typiquement, ces modules renvoient des signaux de 5V, ce qui est trop pour le Raspberry Pi. Alternativement, vous pouvez utiliser un TTL 3.3V-5V.

Commençons par la connexion:

Module RTC Raspberry Pi
SCL GPIO 3 / SCL (Broche 5)
SDA GPIO 2 / SDA (Broche 3)
VCC / 5V 5V ( Broche 2 ou Broche 4)
GND GND (broche 6) ou toute autre broche GND

Raspberry Pi RTC Real Time Clock Aufbau

Premièrement, nous chargeons le script requis :

wget https://raw.githubusercontent.com/tutRPi/Raspberry-Pi-Greenhouse/master/SDL_DS1307.py

Nous réglons ensuite l’heure et le fuseau horaire corrects:

sudo raspi-config

Sous le menu « Localization Options », vous pouvez définir votre fuseau horaire. Vous pouvez ensuite utiliser la date pour vérifier si l’heure est correcte. Ouvrez ensuite la console Python (sudo python) et entrez ce qui suit pour régler l’heure du RTC :

import SDL_DS1307
ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68)
ds1307.write_now()
exit()

Cela permet de sauvegarder l’heure actuelle.

Maintenant nous pouvons étendre notre script actuel (sudo nano greenhouse.py):

Python
66
67
68
69
70
71
72
def readTime():
    try:
        ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68)
        return ds1307.read_datetime()
    except:
        # alternative: return the system-time:
        return datetime.datetime.utcnow()

Sauvegardez avec CTRL + O.

 

Ajuster la luminosité

Raspberry Pi MCP3008 Pinout
Sur le côté gauche du MCP3008 se trouvent les 8 canaux qui peuvent lire des valeurs analogiques.

Pour que les plantes reçoivent suffisamment de lumière même pendant les jours de nuages, nous prolongeons la serre par une LED lumineuse de ~20 cm. Vous pouvez également utiliser une bande de LED (résistante à l’eau) et l’utiliser comme éclairage supplémentaire. Cependant, l’éclairage artificiel ne s’allume que lorsqu’il fait nuit. C’est pourquoi nous utilisons un capteur de lumière, qui émet une valeur de luminosité analogique, que nous pouvons lire avec un ADC MCP3008.

Il existe également des modules de capteurs de lumière qui fournissent déjà une valeur numérique, indiquant si la valeur de luminosité est supérieure ou inférieure à une valeur seuil. Si vous voulez l’utiliser, vous devez ajuster légèrement le code.

Le circuit intégré MCP3008 possède 8 entrées sur lesquelles des signaux analogiques peuvent être lus. Tout d’abord, nous connectons tout :

Raspberry Pi MCP3008
Broche 1 (3.3V) Broche 16 (VDD)
Broche 1 (3.3V) Broche 15 (VREF)
Broche 6 (GND) Broche 14 (AGND)
Broche 23 (SCLK) Broche 13 (CLK)
Broche 21 (MISO) Broche 12 (DOUT)
Broche 19 (MOSI) Broche 11 (DIN)
Broche 24 (CE0) Broche 10 (CS/SHDN)
Broche 6 (GND) Broche 9 (DGND)

Un des 8 canaux est utilisé pour le capteur de lumière (canal 0). Nous le connectons via une résistance pull-up comme indiqué sur la figure. Nous connectons également le relais (VCC à 5V, GND à GND et, par exemple, IN1 à GPIO17). Si vous alimentez le Raspberrry Pi via le L7805, vous pouvez également y prélever directement la tension de 5V.

De l’autre côté du relais, la borne positive de la connexion 12V est connectée à la borne centrale et la connexion (+) à la LED à l’extrémité inférieure. Le GND de la bande de LED est également connecté au GND de la prise.

D’abord nous chargeons un fichier avec une classe Python pour le MCP3008, que nous pouvons intégrer :

wget https://raw.githubusercontent.com/tutRPi/Raspberry-Pi-Greenhouse/master/MCP3008.py

A présent, nous élargissons à nouveau le code :

Python
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def checkLight():
    timestamp = readTime()
    
    
    if SETTINGS["LIGHT_FROM"] <= timestamp.hour <= SETTINGS["LIGHT_UNTIL"]:
        # check light sensors
        adc = MCP3008()
        # read 10 times to avoid measuring errors
        value = 0
        for i in range(10):
            value += adc.read( channel = SETTINGS["LIGHT_CHANNEL"] )
        value /= 10.0
        
        if value <= SETTINGS["LIGHT_THRESHOLD"]:
            # turn light on
            GPIO.setup(SETTINGS["LIGHT_GPIO"], GPIO.OUT, initial=GPIO.LOW) # Relay LOW = ON
        else:
            # turn light off
            GPIO.setup(SETTINGS["LIGHT_GPIO"], GPIO.OUT, initial=GPIO.HIGH)
    else:
        # turn light off
        GPIO.setup(SETTINGS["LIGHT_GPIO"], GPIO.OUT, initial=GPIO.HIGH)

 

 

Arrosage automatique

Petite pompe 12V pour l’irrigation des plantes.

L’irrigation par l’humidité du sol est l’élément central de la serre. Pour cela, nous avons besoin des pompes submersibles, d’un tuyau et d’un relais pour chaque pompe. Les capteurs d’humidité sont lus par le MCP3008 connecté précédemment.

Comme ces minipompes fonctionnent également avec 12V, des relais sont également nécessaires. Dans mon cas, j’ai deux pompes (une par jardinière). Si vous en utilisez plus de 3, vous devriez choisir une carte relais avec plus de canaux.

D’abord, nous attachons le tuyau à la pompe. A côté du jardinière, je mets un seau d’eau (voir les images à la fin). Le tuyau doit être assez long pour aller de ce seau jusqu’à l’extrémité de la jardinière. J’ai scellé l’extrémité du tuyau avec de la colle chaude et j’ai percé des petits trous dans le tuyau tous les 10-15 cm. Comme la pression augmente grâce à la pompe, les trous doivent être très petits. J’ai utilisé une épaisseur de foret de 1-2mm.

Puis j’ai attaché le tuyau au bord de la jardinière. De l’autre côté d’un trou, j’ai placé un capteur d’humidité du sol. Ensuite, on calcule l’humidité moyenne du sol et on décide de verser ou non. Les broches analogiques des capteurs d’humidité du sol sont connectées au MCP3008. Une piste conductrice mène à GND via une résistance de 10 k ohm.

Si vous utilisez plus de 7 capteurs, vous avez besoin d’un autre MCP3008 ADC (la première place est réservée au capteur de lumière). De plus, chaque capteur est alimenté par les 3.3V du Raspberry Pi :

Les GPIO qui contrôlent les relais peuvent également être définis dans les paramètres au début du fichier. Pour mes deux pompes, ce sont les GPIO 23 et 24.

Voici le code correspondant :

Python
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def wateringPlants():
    # read moisture
    adc = MCP3008()
    for plantObject in SETTINGS["PLANTS"]:
        value = 0
        for ch in plantObject["MOISTURE_CHANNELS"]:
            # read 10 times to avoid measuring errors
            v = 0
            for i in range(10):
                v += adc.read( channel = ch )
            v /= 10.0
            value += v
        
        value /= float(len(plantObject["MOISTURE_CHANNELS"]))
        
        if value > plantObject["MOISTURE_THRESHOLD"]:
            # turn pump on for some seconds
            GPIO.setup(plantObject["WATER_PUMP_GPIO"], GPIO.OUT, initial=GPIO.LOW)
            time.sleep(plantObject["WATERING_TIME"])
            GPIO.output(plantObject["WATER_PUMP_GPIO"], GPIO.HIGH)

 

Ventilation

Selon le foyer ou la serre, il y a plusieurs fenêtres ouvrables. Pour un lit précoce, il n’y en a généralement pas plus de deux. Pour ouvrir une fenêtre, j’utilise un servo avec un long bâton en bois attaché à l’axe. Dans l’état initial, l’angle doit être de 0°. Si vous n’êtes pas sûr, vous devriez régler le servo une fois par script sur 0° et ensuite l’attacher :

Le servo est fixé à l’intérieur avec du ruban adhésif double face résistant.

La valeur de la température est utilisée à des fins de contrôle. Pour cela, nous devons encore connecter le capteur de température DHT11 au GPIO 27, tandis que le servo moteur est connecté au GPIO 22. Comme le moteur a probablement besoin de plus de 3.3V (voir la fiche technique, si vous n’êtes pas sûr), nous le connectons à la tension de 5V :

J’ai le capteur DHT simplement fixé au boîtier étanche (point suivant). Pour modifier la température à laquelle la trappe doit être ouverte, vous pouvez modifier les paramètres initiaux.

En outre, le code doit être étendu :

Python
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def checkWindow():
    # read remperature
    humidity, temperature = Adafruit_DHT.read_retry(SETTINGS["DHT_SENSOR"], SETTINGS["DHT_GPIO"])
    
    GPIO.setup(SETTINGS["SERVO_GPIO"], GPIO.OUT)
    pwm = GPIO.PWM(SETTINGS["SERVO_GPIO"], 50)
    
    if temperature > SETTINGS["TEMP_THRESHOLD"]:
        # open window
        angle = float(SETTINGS["SERVO_OPEN_ANGLE"]) / 20.0 + 2.5
        pwm.start(angle)
    else:
        # close window
        pwm.start(2.5)
    # save current
    time.sleep(2)
    pwm.ChangeDutyCycle(0)

Si vous avez des problèmes pour lire (« ImportError: No module named Raspberry_Pi_Driver« ), ce post peut vous aider. Alternativement, vous pouvez aussi utiliser GPIO 4, qui est toujours libre dans mon câblage.

 

Boîtier et montage étanches

Dans la dernière étape du montage, nous emballons les éléments de commande importants dans un boîtier étanche. Le Raspberry Pi ainsi que les relais et tout ce qui est sensible à l’eau doivent se trouver à l’intérieur. J’ai percé un trou sur le côté inférieur et tous les câbles qui doivent y entrer ou en sortir.

En outre, les composants peuvent être soudés à une grille de trous une fois que tout a été testé.

Au minimum, l’électronique et les connexions potentiellement dangereuses doivent être maintenues à l’abri de l’eau. Il est préférable de choisir un endroit couvert.

 

Activation de la serre Raspberry Pi

A présent que nous avons connecté et installé tous les composants, faisons en sorte que tout fonctionne automatiquement. Pour ce faire, nous étendons le script en appelant les fonctions créées en séquence :

Python
138
139
140
141
142
143
144
145
146
147
148
149
if __name__ == '__main__':
    try:
        GPIO.setwarnings(False)
        GPIO.setmode(GPIO.BCM)
 
        # execute functions
        checkLight()
        wateringPlants()
        checkWindow()
    except:
        GPIO.cleanup()
 

Au fait : Si vous voulez télécharger tous les fichiers en une fois, vous pouvez le faire via ma bibliothèque GitHub :

git clone https://github.com/tutRPi/Raspberry-Pi-Greenhouse

Le script doit être appelé automatiquement toutes les 10 minutes, nous utilisons donc Cron :

crontab -e

Ici, nous ajoutons une ligne à la fin, qui invoque notre script toutes les 10 minutes :

*/10 *    * * *   sudo python /home/pi/Raspberry-Pi-Greenhouse/greenhouse.py > /dev/null 2>&1

Avec CTRL + O on sauvegarde et on retourne au terminal avec CTRL + X.
A propos : Vous pouvez trouver le chemin absolu d’un répertoire avec cd puis en entrant pwd.

Maintenant, vous n’avez rien d’autre à faire que d’attendre. Pour économiser de l’énergie, vous pouvez désactiver le wifi et les autres services inutiles.

 

Extensions possibles de la serre Raspberry Pi

Même s’il y a déjà beaucoup de choses disponibles, vous pouvez certainement en ajouter. Je propose les points suivants, dont je peux également mettre en œuvre l’un ou l’autre si nécessaire. Si vous avez des idées, n’hésitez pas à laisser un commentaire.

  • Niveau d’eau : Bien que nous irriguions les plantes automatiquement, nous devons cependant verser de l’eau dans le seau. Avec une mesure du niveau de remplissage, nous pourrions envoyer un message par exemple par l’application Telegram dès que l’eau doit être remplie. Il est également possible d’installer un témoin lumineux (LED).
  • Mesurer l’humidité : Le capteur DHT11 ou DHT22 peut mesurer l’humidité en plus de la température. Cependant, nous ne l’utilisons pas pour l’instant. Il serait concevable d’amener l’humidité à un certain niveau à l’aide de pulvérisateurs d’eau. Cela dépend bien sûr des plantes.
  • Chaleur : il peut parfois faire plus froid, surtout au printemps ou en automne. Afin de créer des conditions optimales pour les plantes, on peut également chauffer l’air de la serre..
  • Refroidir activement : Jusqu’à présent, nous ne refroidissons que passivement (ouverture / fermeture de la fenêtre). Grâce à un ventilateur, nous pourrions également refroidir activement à des températures élevées.
  • Écran LCD : En outre, nous pouvons également utiliser un écran LCD afin de voir les données actuelles sur un écran..

PS : Nous vous invitons à nous envoyer des photos de votre serre ou serre automatique Raspberry Pi.

En vedette Humidité du sol Lumière MCP3008 Relais relais à lames servo servomoteur temperatur température de mesure
Share. Facebook Twitter Pinterest LinkedIn Tumblr Email
Previous ArticleConfiguration du Wi-Fi et du Bluetooth du Raspberry Pi 4
Next Article ESP32 Cam Livestream Tutorial – Camera Module for the ESP8266

Related Posts

Enregistrer les données des capteurs Raspberry Pi avec ThingSpeak et les analyser

Construire un capteur de porte / fenêtre Raspberry Pi avec Reed Relais

Utiliser Raspberry Pi comme récepteur radio (autoradio FM, PC de voiture)

MCP3008 : Lire des signaux analogiques sur le Raspberry Pi

Un commentaire

  1. mary on 15. décembre 2022 10:15

    Bonjour,
    Je vois votre site web http://www.raspberrypi-tutorials.fr et c’est impressionnant. Je me demande si des options publicitaires telles que la publication d’invités, le contenu publicitaire sont disponibles sur votre site ?
    Quel est le prix si nous voulons faire de la publicité sur votre site ?
    À votre santé
    Mary com

    Reply

Leave A Reply Cancel Reply

Communication sans fil entre les Raspberry Pi via le courtier/client MQTT

Construisez votre propre boussole Raspberry Pi (HMC5883L)

Contrôle de moteur Stepper Raspberry Pi avec L293D / ULN2003A

Contrôlez les prises sans fil Raspberry Pi (433MHz) – Tutoriel

Utiliser un joystick sur le Raspberry Pi (avec MCP3008)

Pulsation de Raspberry Pi / Mesure du pouls

ABONNEZ-VOUS MAINTENANT
Et recevez de nouveaux tutoriels dans votre boîte de réception.
Cliquez ici pour soumettre!

Merci!

Nous vous contacterons bientôt.

Tutorials for Raspberry Pi
Facebook Twitter YouTube
  • Politique de confidentialité
  • Conditions de service & Politique sur les cookies

Type above and press Enter to search. Press Esc to cancel.