Configuration de votre Raspberry Pi et du capteur d'humidité

Insérez votre carte micro SD dans le Raspberry Pi, connectez votre écran, votre clavier, votre souris et, si vous n'utilisez pas le Wi-Fi, un câble Ethernet. Ne connectez pas encore le câble d'alimentation.

Connectez le câble jumper JST au capteur d'humidité. L'autre côté du jumper a quatre câbles :

Vert : I2C SCL
Blanc : I2C SDA
Rouge : alimentation (3,5 V)
Black : terre

Maintenez la carte Raspberry Pi enfoncée avec la prise Ethernet sur la droite. Dans cette orientation, il y a deux lignes de broches GPIO en haut. Connectez les câbles du capteur d'humidité à la ligne inférieure de broches dans l'ordre suivant. À partir du connecteur le plus à gauche, connectez rouge (alimentation), blanc (SDA) et vert (SCL). Ignorez une broche, puis connectez le fil noir (terre). Pour plus d'informations, consultez Câblage informatique Python.

Attachez le câble d'alimentation au Raspberry Pi et branchez l'autre extrémité à une prise murale pour l'allumer.

Configuration de votre Raspberry Pi

Sur Welcome to Raspberry Pi (Bienvenue dans Raspberry Pi), choisissez Next (Suivant).
Choisissez votre pays, votre langue, votre fuseau horaire et votre disposition du clavier. Choisissez Suivant.
Saisissez un mot de passe pour votre Raspberry Pi, puis choisissez Next (Suivant).
Choisissez votre réseau Wi-Fi, puis choisissez Next (Suivant). Si vous n'utilisez pas de réseau Wi-Fi, choisissez Skip (Ignorer).
Choisissez Next (Suivant) pour rechercher les mises à jour logicielles. Lorsque les mises à jour sont terminées, choisissez Restart (Redémarrer) pour redémarrer votre Raspberry Pi.

Une fois que votre Raspberry Pi a démarré, activez l'interface I2C.

Dans le coin supérieur gauche du bureau Raspbian, cliquez sur l'icône Raspberry, choisissez Preferences (Préférences), puis Raspberry Pi Configuration (Configuration du Raspberry Pi).
Sous l'onglet Interfaces pour I2C, choisissez Enable (Activer).
Choisissez OK.

Les bibliothèques du capteur d'humidité Adafruit STEMMA ont été écrites pour. CircuitPython Pour les exécuter sur un Raspberry Pi, vous devez installer la dernière version de Python 3.

Exécutez les commandes suivantes à partir d'une invite de commande pour mettre à jour votre logiciel Raspberry Pi :

sudo apt-get update

sudo apt-get upgrade
Exécutez la commande suivante pour mettre à jour votre installation Python 3 :

sudo pip3 install --upgrade setuptools
Exécutez la commande suivante pour installer les bibliothèques GPIO Raspberry Pi :

pip3 install RPI.GPIO
Exécutez la commande suivante pour installer les bibliothèques Adafruit Blinka :

pip3 install adafruit-blinka

Pour plus d'informations, consultez Installation de CircuitPython bibliothèques sur le Raspberry Pi.
Exécutez la commande suivante pour installer les bibliothèques Adafruit Seesaw :

sudo pip3 install adafruit-circuitpython-seesaw
Exécutez la commande suivante pour installer le AWS IoT Device SDK pour Python :

pip3 install AWSIoTPythonSDK

Votre Raspberry Pi dispose désormais de toutes les bibliothèques requises. Créez un fichier appelé moistureSensor.py et copiez le code Python suivant dans le fichier :



from adafruit_seesaw.seesaw import Seesaw
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA

import logging
import time
import json
import argparse
import busio

# Shadow JSON schema:
#
# {
#   "state": {
#       "desired":{
#           "moisture":<INT VALUE>,
#           "temp":<INT VALUE>            
#       }
#   }
# }

# Function called when a shadow is updated
def customShadowCallback_Update(payload, responseStatus, token):

    # Display status and data from update request
    if responseStatus == "timeout":
        print("Update request " + token + " time out!")

    if responseStatus == "accepted":
        payloadDict = json.loads(payload)
        print("~~~~~~~~~~~~~~~~~~~~~~~")
        print("Update request with token: " + token + " accepted!")
        print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
        print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
        print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")

    if responseStatus == "rejected":
        print("Update request " + token + " rejected!")

# Function called when a shadow is deleted
def customShadowCallback_Delete(payload, responseStatus, token):

     # Display status and data from delete request
    if responseStatus == "timeout":
        print("Delete request " + token + " time out!")

    if responseStatus == "accepted":
        print("~~~~~~~~~~~~~~~~~~~~~~~")
        print("Delete request with token: " + token + " accepted!")
        print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")

    if responseStatus == "rejected":
        print("Delete request " + token + " rejected!")


# Read in command-line parameters
def parseArgs():

    parser = argparse.ArgumentParser()
    parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host", help="Your device data endpoint")
    parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
    parser.add_argument("-c", "--cert", action="store", dest="certificatePath", help="Certificate file path")
    parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private key file path")
    parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port number override")
    parser.add_argument("-n", "--thingName", action="store", dest="thingName", default="Bot", help="Targeted thing name")
    parser.add_argument("-id", "--clientId", action="store", dest="clientId", default="basicShadowUpdater", help="Targeted client id")

    args = parser.parse_args()
    return args


# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():

    logger = logging.getLogger("AWSIoTPythonSDK.core")
    logger.setLevel(logging.DEBUG)
    streamHandler = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    streamHandler.setFormatter(formatter)
    logger.addHandler(streamHandler)


# Parse command line arguments
args = parseArgs()

if not args.certificatePath or not args.privateKeyPath:
    parser.error("Missing credentials for authentication.")
    exit(2)

# If no --port argument is passed, default to 8883
if not args.port: 
    args.port = 8883


# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath, args.certificatePath)

# AWSIoTMQTTShadowClient connection configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec

# Initialize Raspberry Pi's I2C interface
i2c_bus = busio.I2C(SCL, SDA)

# Intialize SeeSaw, Adafruit's Circuit Python library
ss = Seesaw(i2c_bus, addr=0x36)

# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()

# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName, True)

# Delete current shadow JSON doc
deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)

# Read data from moisture sensor and update shadow
while True:

    # read moisture level through capacitive touch pad
    moistureLevel = ss.moisture_read()

    # read temperature from the temperature sensor
    temp = ss.get_temp()

    # Display moisture and temp readings
    print("Moisture Level: {}".format(moistureLevel))
    print("Temperature: {}".format(temp))
    
    # Create message payload
    payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}

    # Update shadow
    deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
    time.sleep(1)

Enregistrez le fichier dans un emplacement où vous le trouverez. Sur la ligne de commande, tapez moistureSensor.py avec les paramètres suivants :

point de terminaison: Votre point de AWS IoT terminaison personnalisé. Pour de plus amples informations, veuillez consulter Device Shadow REST API.
rootCA: Le chemin complet vers votre certificat CA AWS IoT racine.
cert: Le chemin complet vers le certificat de votre AWS IoT appareil.
clé: Le chemin complet vers la clé privée du certificat de votre AWS IoT appareil.
thingName: Votre nom d'objet (dans ce cas, RaspberryPi).
clientId: ID du client MQTT. Utilisez RaspberryPi.

La ligne de commande doit se présenter comme suit :

python3 moistureSensor.py --endpoint your-endpoint --rootCA ~/certs/AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi

Essayez de toucher le capteur, de le placer dans un pot ou de le placer dans un verre d'eau pour voir comment le capteur réagit à différents niveaux d'humidité. Si nécessaire, vous pouvez modifier la valeur de seuil dans MoistureSensorRule. Lorsque la valeur du capteur d'humidité est inférieure à la valeur spécifiée dans l'instruction de requête SQL de votre règle, AWS IoT un message est publié dans la rubrique Amazon SNS. Vous devez recevoir un e-mail contenant les données relatives à l'humidité et à la température.

Une fois que vous avez vérifié la réception des e-mails provenant de , appuyez sur CTRL+C pour arrêter le programme Python. Il est peu probable que le programme Python envoie suffisamment de messages pour générer des frais, mais il est recommandé d'arrêter le programme une fois que vous avez terminé.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Étape 4 : créer une AWS IoT règle pour envoyer un e-mail

Connect à AWS IoT Core