Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Configurazione del Raspberry Pi e del sensore di umidità Inserire la scheda micro SD nel Raspberry Pi, connettere il monitor, la tastiera, il mouse e, se non si utilizza la rete Wi-Fi, il cavo Ethernet. Non collegare il cavo di alimentazione per il momento. Collegare il cavo jumper JST al sensore di umidità. L'estremità opposta del jumper presenta quattro fili: + Verde: I2C SCL + Bianco: I2C SDA + Rosso: alimentazione (3,5 V) + Nero: terra Tieni il Raspberry Pi con il connettore Ethernet a destra. In questo orientamento, ci sono due file di pin GPIO nella parte superiore. Collega i fili dal sensore di umidità alla fila inferiore di pin nel seguente ordine. Partendo dal pin più a sinistra, collega il rosso (alimentazione), bianco (SDA) e verde (SCL). Salta un pin, quindi collega il file nero (terra). Per ulteriori informazioni, consulta la pagina relativa al [cablaggio per i computer Python](https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/python-circuitpython-test). Collega il cavo di alimentazione al Raspberry Pi e collega l'estremità opposta a una presa di corrente per accenderlo. **Configurare il Raspberry Pi** 1. In **Welcome to Raspberry Pi (Benvenuto in Raspberry Pi)**, scegliere **Next (Avanti)**. 1. Scegliere il paese, la lingua, il fuso orario e il layout della tastiera. Scegli **Next (Successivo)**. 1. Immettere una password per il Raspberry Pi, quindi scegliere **Next (Avanti)**. 1. Scegliere la rete Wi-Fi, quindi scegliere **Next (Avanti)**. Se non si utilizza una rete Wi-Fi, scegliere **Skip (Ignora)**. 1. Scegliere **Next (Avanti)** per verificare la presenza di aggiornamenti software. Al termine degli aggiornamenti, scegliere **Restart (Riavvia)** per riavviare il Raspberry Pi. Dopo l'avvio del Raspberry Pi, abilitare l'interfaccia I2C. 1. Nell'angolo in alto a sinistra del desktop Raspbian, fare clic sull'icona Raspberry, scegliere **Preferences (Preferenze)**, quindi scegliere **Raspberry Pi Configuration (Configurazione Raspberry Pi)**. 1. Nella scheda **Interfaces (Interfacce)**, per **I2C**, scegliere **Enable (Abilita)**. 1. Scegli **OK**. Le librerie per il sensore di umidità Adafruit STEMMA sono state scritte per. CircuitPython Per eseguirle su un Raspberry Pi, è necessario installare la versione più recente di Python 3. 1. Eseguire i comandi seguenti da un prompt dei comandi per aggiornare il software Raspberry Pi: `sudo apt-get update` `sudo apt-get upgrade` 1. Eseguire il comando seguente per aggiornare l'installazione di Python 3: `sudo pip3 install --upgrade setuptools` 1. Eseguire il comando seguente per installare le librerie GPIO di Raspberry Pi: `pip3 install RPI.GPIO` 1. Eseguire il comando seguente per installare le librerie Adafruit Blinka: `pip3 install adafruit-blinka` Per ulteriori informazioni, consulta [Installazione delle CircuitPython librerie su Raspberry](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi) Pi. 1. Eseguire il comando seguente per installare le librerie Adafruit Seesaw: `sudo pip3 install adafruit-circuitpython-seesaw` 1. Esegui il seguente comando per installare AWS IoT Device SDK per Python: `pip3 install AWSIoTPythonSDK` Il Raspberry Pi ora dispone di tutte le librerie necessarie. Crea un file denominato **moistureSensor.py** e copia il seguente codice Python nel file: ``` 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":, # "temp": # } # } # } # 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) ``` Salva il file nella posizione che preferisci. Esegui `moistureSensor.py` dalla riga di comando con i parametri seguenti: endpoint Il tuo endpoint personalizzato AWS IoT . Per ulteriori informazioni, consulta [API REST del servizio Device Shadow](device-shadow-rest-api.md). rootCA Il percorso completo del certificato CA AWS IoT root. cert Il percorso completo del certificato AWS IoT del dispositivo. Chiave Il percorso completo della chiave privata AWS IoT del certificato del dispositivo. thingName Nome dell'oggetto, in questo caso `RaspberryPi`. clientId ID client MQTT. Utilizza `RaspberryPi`. La riga di comando dovrebbe essere simile alla seguente: `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` Prova a toccare il sensore, a inserirlo in una fioriera o a immergerlo in un bicchiere d'acqua per vedere come risponde a vari livelli di umidità. Se necessario, puoi modificare il valore di soglia in `MoistureSensorRule`. Quando la lettura del sensore di umidità scende al di sotto del valore specificato nell'istruzione di query SQL della regola, AWS IoT pubblica un messaggio sull'argomento Amazon SNS. Riceverai un messaggio e-mail contenente i dati relativi all'umidità e alla temperatura. Dopo aver verificato la ricezione dei messaggi e-mail da Amazon SNS, premi **CTRL\+C** per arrestare il programma Python. È improbabile che il programma Python invii un numero di messaggi tale da comportare un addebito, ma è una best practice interrompere il programma al termine delle operazioni.