Avviso di fine del supporto: il 7 ottobre 2026, AWS il supporto per. AWS IoT Greengrass Version 1 Dopo il 7 ottobre 2026, non potrai più accedere alle risorse. AWS IoT Greengrass V1 Per ulteriori informazioni, visita [Migrate](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html) from. AWS IoT Greengrass Version 1 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à. # Connettore adattatore di protocollo Modbus-RTU Il [connettore](connectors.md) Modbus-RTU Protocol Adapter raccoglie le informazioni dai dispositivi Modbus RTU che fanno parte del gruppo. AWS IoT Greengrass Questo connettore riceve i parametri per una richiesta Modbus RTU da una funzione Lambda definita dall'utente. Invia la richiesta corrispondente e quindi pubblica la risposta dal dispositivo di destinazione come messaggio MQTT. Questo connettore ha le seguenti versioni. | Versione | ARN | | --- | --- | | 3 | `arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/3` | | 2 | `arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/2` | | 1 | `arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/1` | Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#modbus-protocol-adapter-connector-changelog). ## Requisiti Questo connettore presenta i seguenti requisiti: ------ #### [ Version 3 ] + AWS IoT Greengrass Software principale v1.9.3 o versione successiva. + [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH. **Nota** Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati. ``` sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7 ``` Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass. + Una connessione fisica tra il core e i dispositivi Modbus. AWS IoT Greengrass Il core deve essere fisicamente connesso alla rete RTU Modbus attraverso una porta seriale (ad esempio, una porta USB). + Una [risorsa di dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale Modbus fisica. + Una funzione Lambda definita dall'utente che invia i parametri di richiesta Modbus RTU a questo connettore. I parametri di richiesta devono essere conformi ai modelli previsti e includere gli indirizzi IDs e gli indirizzi dei dispositivi di destinazione sulla rete Modbus RTU. Per ulteriori informazioni, consulta [Dati di input](#modbus-protocol-adapter-connector-data-input). ------ #### [ Versions 1 - 2 ] + AWS IoT Greengrass Software principale v1.7 o successivo. + [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH. + Una connessione fisica tra il AWS IoT Greengrass core e i dispositivi Modbus. Il core deve essere fisicamente connesso alla rete RTU Modbus attraverso una porta seriale (ad esempio, una porta USB). + Una [risorsa di dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale Modbus fisica. + Una funzione Lambda definita dall'utente che invia i parametri di richiesta Modbus RTU a questo connettore. I parametri di richiesta devono essere conformi ai modelli previsti e includere gli indirizzi IDs e gli indirizzi dei dispositivi di destinazione sulla rete Modbus RTU. Per ulteriori informazioni, consulta [Dati di input](#modbus-protocol-adapter-connector-data-input). ------ ## Parametri del connettore Questo connettore supporta i seguenti parametri: `ModbusSerialPort-ResourceId` L'ID della risorsa del dispositivo locale fisico che rappresenta la porta seriale Modbus fisica. Al connettore è concesso l'accesso in lettura e scrittura alla risorsa. Nome visualizzato nella AWS IoT console: risorsa della **porta seriale Modbus** Richiesto: `true` Tipo: `string` Schema valido: `.+` `ModbusSerialPort` Il percorso assoluto della porta seriale Modbus fisica sul dispositivo. Si tratta del percorso di origine specificato per la risorsa del dispositivo locale Modbus. Nome visualizzato nella AWS IoT console: **percorso di origine della risorsa della porta seriale Modbus** Obbligatorio: `true` Tipo: `string` Schema valido: `.+` ### Esempio di creazione di un connettore (AWS CLI) Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore Modbus-RTU Protocol Adapter. ``` aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyModbusRTUProtocolAdapterConnector", "ConnectorArn": "arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/3", "Parameters": { "ModbusSerialPort-ResourceId": "MyLocalModbusSerialPort", "ModbusSerialPort": "/path-to-port" } } ] }' ``` **Nota** La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle). **Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md). **Nota** Dopo aver distribuito il connettore Modbus-RTU Protocol Adapter, puoi utilizzarlo AWS IoT Things Graph per orchestrare le interazioni tra i dispositivi del gruppo. Per ulteriori informazioni, consulta [Modbus](https://docs.aws.amazon.com/thingsgraph/latest/ug/iot-tg-protocols-modbus.html) nella *AWS IoT Things Graph Guida per l'utente*. ## Dati di input Questo connettore accetta i parametri di richiesta Modbus RTU da una funzione Lambda definita dall'utente su un argomento MQTT. I messaggi di input devono essere in formato JSON. **Filtro argomento in sottoscrizione** `modbus/adapter/request` **Proprietà dei messaggi** Il messaggio di richiesta varia in base al tipo di richiesta RTU Modbus che rappresenta. Le seguenti proprietà sono necessarie per tutte le richieste: + Nell'oggetto `request`: + `operation`. Il nome dell'operazione da eseguire. Ad esempio, specificare `"operation": "ReadCoilsRequest"` per leggere i nastri. Questo valore deve essere una stringa Unicode. Per le operazioni supportate, consulta [Richieste e risposte RTU Modbus](#modbus-protocol-adapter-connector-requests-responses). + `device`. Il dispositivo di destinazione della richiesta. Questo valore deve essere compreso tra `0 - 247`. + La proprietà `id`. L'ID della richiesta. Tale valore viene utilizzato per la deduplicazione dei dati e viene restituito come è nella proprietà `id` di tutte le risposte, incluse quelle di errore. Questo valore deve essere una stringa Unicode. Se la richiesta include un campo indirizzo, è necessario specificare il valore come numero intero. Ad esempio `"address": 1`. Gli altri parametri di includere nella richiesta variano a seconda dell'operazione. Tutti i parametri della richiesta sono necessari tranne il CRC, che viene gestito separatamente. Per alcuni esempi, consulta [Richieste e risposte di esempio](#modbus-protocol-adapter-connector-examples). **Esempio di input: richiesta lettura nastri** ``` { "request": { "operation": "ReadCoilsRequest", "device": 1, "address": 1, "count": 1 }, "id": "TestRequest" } ``` ## Dati di output Questo connettore pubblica le risposte nelle richieste RTU Modbus in entrata. **Filtro argomento in sottoscrizione** `modbus/adapter/response` **Proprietà dei messaggi** Il formato del messaggio di risposta varia in base alla richiesta corrispondente e allo stato della risposta. Per alcuni esempi, consulta [Richieste e risposte di esempio](#modbus-protocol-adapter-connector-examples). Una risposta a un'operazione di scrittura è semplicemente un eco della richiesta. Benché non vengano restituite informazioni rilevanti per le risposte in scrittura, è buona prassi controllare lo stato della risposta. Ogni risposta include le seguenti proprietà: + Nell'oggetto `response`: + `status`. Lo stato della richiesta. Lo stato può avere uno dei seguenti valori: + `Success`. La richiesta era valida, è stata inviata alla rete Modbus RTU ed è stata restituita una risposta. + `Exception`. La richiesta era valida, è stata inviata alla rete Modbus RTU ed è stata restituita una risposta di eccezione. Per ulteriori informazioni, consulta [Stato risposta: eccezione](#modbus-protocol-adapter-connector-response-exception). + `No Response`. La richiesta non era valida e il connettore ha rilevato l'errore prima che la richiesta fosse inviata sulla rete Modbus RTU. Per ulteriori informazioni, consulta [Stato risposta: nessuna risposta](#modbus-protocol-adapter-connector-response-noresponse). + `device`. Il dispositivo a cui è stata inviata la richiesta. + `operation`. Il tipo di richiesta che è stata inviata. + `payload`. Il contenuto della risposta che è stato restituito. Se lo `status` è `No Response`, questo oggetto contiene solo una proprietà `error` con la descrizione dell'errore (ad esempio, `"error": "[Input/Output] No Response received from the remote unit"`). + La proprietà `id`. L'ID della richiesta, utilizzato per la deduplicazione dei dati. **Output di esempio: Operazione riuscita** ``` { "response" : { "status" : "success", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 1, "bits": [1] } }, "id" : "TestRequest" } ``` **Esempio di output: Errore** ``` { "response" : { "status" : "fail", "error_message": "Internal Error", "error": "Exception", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 129, "exception_code": 2 } }, "id" : "TestRequest" } ``` Per ulteriori esempi, consulta [Richieste e risposte di esempio](#modbus-protocol-adapter-connector-examples). ## Richieste e risposte RTU Modbus Questo connettore accetta i parametri della richiesta RTU Modbus come [dati di input](#modbus-protocol-adapter-connector-data-input) e pubblica le risposte come [dati di output](#modbus-protocol-adapter-connector-data-output). Sono supportate le seguenti operazioni comuni. | Nome dell'operazione nella richiesta | Codice della funzione in risposta | | --- | --- | | ReadCoilsRequest | 01 | | ReadDiscreteInputsRequest | 02 | | ReadHoldingRegistersRequest | 03 | | ReadInputRegistersRequest | 04 | | WriteSingleCoilRequest | 05 | | WriteSingleRegisterRequest | 06 | | WriteMultipleCoilsRequest | 15 | | WriteMultipleRegistersRequest | 16 | | MaskWriteRegisterRequest | 22 | | ReadWriteMultipleRegistersRequest | 23 | ### Richieste e risposte di esempio Di seguito sono riportate alcune richieste e risposte di esempio per le operazioni supportate. Lettura nastri **Esempio di richiesta:** ``` { "request": { "operation": "ReadCoilsRequest", "device": 1, "address": 1, "count": 1 }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 1, "bits": [1] } }, "id" : "TestRequest" } ``` Lettura di input discreti **Esempio di richiesta:** ``` { "request": { "operation": "ReadDiscreteInputsRequest", "device": 1, "address": 1, "count": 1 }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "ReadDiscreteInputsRequest", "payload": { "function_code": 2, "bits": [1] } }, "id" : "TestRequest" } ``` Lettura registri di sospensione **Esempio di richiesta:** ``` { "request": { "operation": "ReadHoldingRegistersRequest", "device": 1, "address": 1, "count": 1 }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "ReadHoldingRegistersRequest", "payload": { "function_code": 3, "registers": [20,30] } }, "id" : "TestRequest" } ``` Lettura registri di input **Esempio di richiesta:** ``` { "request": { "operation": "ReadInputRegistersRequest", "device": 1, "address": 1, "value": 1 }, "id": "TestRequest" } ``` Scrittura nastro singolo **Esempio di richiesta:** ``` { "request": { "operation": "WriteSingleCoilRequest", "device": 1, "address": 1, "value": 1 }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "WriteSingleCoilRequest", "payload": { "function_code": 5, "address": 1, "value": true } }, "id" : "TestRequest" ``` Scrittura registro singolo **Esempio di richiesta:** ``` { "request": { "operation": "WriteSingleRegisterRequest", "device": 1, "address": 1, "value": 1 }, "id": "TestRequest" } ``` Scrittura di più nastri **Esempio di richiesta:** ``` { "request": { "operation": "WriteMultipleCoilsRequest", "device": 1, "address": 1, "values": [1,0,0,1] }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "WriteMultipleCoilsRequest", "payload": { "function_code": 15, "address": 1, "count": 4 } }, "id" : "TestRequest" } ``` Scrittura di più registri **Esempio di richiesta:** ``` { "request": { "operation": "WriteMultipleRegistersRequest", "device": 1, "address": 1, "values": [20,30,10] }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "WriteMultipleRegistersRequest", "payload": { "function_code": 23, "address": 1, "count": 3 } }, "id" : "TestRequest" } ``` Mascheramento dei registri di scrittura **Esempio di richiesta:** ``` { "request": { "operation": "MaskWriteRegisterRequest", "device": 1, "address": 1, "and_mask": 175, "or_mask": 1 }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "MaskWriteRegisterRequest", "payload": { "function_code": 22, "and_mask": 0, "or_mask": 8 } }, "id" : "TestRequest" } ``` Scrittura/lettura di più registri **Esempio di richiesta:** ``` { "request": { "operation": "ReadWriteMultipleRegistersRequest", "device": 1, "read_address": 1, "read_count": 2, "write_address": 3, "write_registers": [20,30,40] }, "id": "TestRequest" } ``` **Esempio di risposta:** ``` { "response": { "status": "success", "device": 1, "operation": "ReadWriteMultipleRegistersRequest", "payload": { "function_code": 23, "registers": [10,20,10,20] } }, "id" : "TestRequest" } ``` I registri restituiti in questa risposta sono quelli che vengono letti. ### Stato risposta: eccezione Le eccezioni possono verificarsi se il formato della richiesta è valido, ma la richiesta non è stata completata. In questo caso, la risposta contiene le seguenti informazioni: + Il `status` è impostato su `Exception`. + `function_code` è pari al codice della funzione della richiesta \$1 128. + `exception_code` contiene il codice dell'eccezione. Per ulteriori informazioni sull'eccezione , consulta Codici delle eccezioni Modbus. **Esempio:** ``` { "response" : { "status" : "fail", "error_message": "Internal Error", "error": "Exception", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 129, "exception_code": 2 } }, "id" : "TestRequest" } ``` ### Stato risposta: nessuna risposta Questo connettore esegue controlli di convalida sulla richiesta Modbus. Ad esempio, verifica l'eventuale presenza di formati non validi e campi non compilati. Se la convalida ha esito negativo, il connettore non invia la richiesta. Al contrario, restituirà una risposta contenente le seguenti informazioni: + Il `status` è impostato su `No Response`. + `error`Contiene il motivo dell'errore. + `error_message` contiene il messaggio dell'errore. **Esempi:** ``` { "response" : { "status" : "fail", "error_message": "Invalid address field. Expected , got ", "error": "No Response", "device": 1, "operation": "ReadCoilsRequest", "payload": { "error": "Invalid address field. Expected , got " } }, "id" : "TestRequest" } ``` Se la richiesta è destinata a un dispositivo inesistente o se la rete RTU Modbus non funziona, potrebbe venire restituito `ModbusIOException`, che utilizza il formato Nessuna risposta. ``` { "response" : { "status" : "fail", "error_message": "[Input/Output] No Response received from the remote unit", "error": "No Response", "device": 1, "operation": "ReadCoilsRequest", "payload": { "error": "[Input/Output] No Response received from the remote unit" } }, "id" : "TestRequest" } ``` ## Esempio di utilizzo Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore. **Nota** Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7. Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio. 1. Assicurarsi di soddisfare i [requisiti](#modbus-protocol-adapter-connector-req) per il connettore. 1. Crea e pubblica una funzione Lambda che invia dati di input al connettore. Salvare il [codice di esempio](#modbus-protocol-adapter-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias. 1. Configurare il gruppo Greengrass. 1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI). 1. Aggiungi la risorsa del dispositivo locale richiesta e concedi l'accesso in lettura/scrittura alla funzione Lambda. 1. Aggiungere il connettore e configurarne i relativi [parametri](#modbus-protocol-adapter-connector-param). 1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#modbus-protocol-adapter-connector-data-input) e inviare [i dati di output](#modbus-protocol-adapter-connector-data-output) nei filtri degli argomenti supportati. + Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato. + Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console. 1. Distribuisci il gruppo. 1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo. Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi. ### Esempio L'esempio seguente della funzione Lambda invia un messaggio di input al connettore. ``` import greengrasssdk import json TOPIC_REQUEST = 'modbus/adapter/request' # Creating a greengrass core sdk client iot_client = greengrasssdk.client('iot-data') def create_read_coils_request(): request = { "request": { "operation": "ReadCoilsRequest", "device": 1, "address": 1, "count": 1 }, "id": "TestRequest" } return request def publish_basic_request(): iot_client.publish(payload=json.dumps(create_read_coils_request()), topic=TOPIC_REQUEST) publish_basic_request() def lambda_handler(event, context): return ``` ## Licenze Il connettore Modbus-RTU Protocol Adapter include i seguenti software/licenze di terze parti: + [pymodbus](https://github.com/riptideio/pymodbus/blob/master/README.rst)/BSD + [pyserial](https://github.com/pyserial/pyserial)/BSD Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf). ## Changelog La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore. | Versione | Modifiche | | --- | --- | | 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. | | 2 | Arn del connettore aggiornato per Regione AWS il supporto. Registrazione degli errori migliorata. | | 1 | Versione iniziale. | Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions). ## Consulta anche + [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md) + [Nozioni di base sui connettori Greengrass (console)](connectors-console.md) + [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)