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 Serial Stream **avvertimento** Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md). Il [connettore](connectors.md) Serial Stream legge e scrive su una porta seriale di un dispositivo principale. AWS IoT Greengrass Questo connettore supporta due modalità di funzionamento: + **Read-On-Demand**. Riceve richieste di lettura e scrittura su argomenti MQTT e pubblica la risposta dell'operazione di lettura o lo stato dell'operazione di scrittura. + **Polling-Read**. Effettua letture dalla porta seriale a intervalli regolari. Questa modalità supporta anche Read-On-Demand le richieste. **Nota** Le richieste di lettura possono avere una lunghezza massima di 63994 byte. Le richieste di scrittura possono avere una lunghezza massima dei dati di 128000 byte. Questo connettore ha le seguenti versioni. | Versione | ARN | | --- | --- | | 3 | `arn:aws:greengrass:region::/connectors/SerialStream/versions/3` | | 2 | `arn:aws:greengrass:region::/connectors/SerialStream/versions/2` | | 1 | `arn:aws:greengrass:region::/connectors/SerialStream/versions/1` | Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#serial-stream-connector-changelog). ## Requisiti Questo connettore presenta i seguenti requisiti: ------ #### [ Version 3 ] + AWS IoT Greengrass Software principale v1.9.3 o successivo. + [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 [risorsa del dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale di destinazione. **Nota** Prima di distribuire il connettore, ti consigliamo di configurare la porta seriale e di verificare che sia possibile effettuarvi operazioni di lettura e scrittura. ------ #### [ 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 [risorsa del dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale di destinazione. **Nota** Prima di distribuire il connettore, ti consigliamo di configurare la porta seriale e di verificare che sia possibile effettuarvi operazioni di lettura e scrittura. ------ ## Parametri del connettore Questo connettore fornisce i seguenti parametri: `BaudRate` La velocità in baud della connessione seriale. Nome visualizzato nella AWS IoT console: **baud rate** Obbligatorio: `true` Tipo: `string` Valori validi: `110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 56000, 57600, 115200, 230400` Schema valido: `^110$|^300$|^600$|^1200$|^2400$|^4800$|^9600$|^14400$|^19200$|^28800$|^38400$|^56000$|^57600$|^115200$|^230400$` `Timeout` Il timeout (in secondi) di un'operazione di lettura. Nome visualizzato nella AWS IoT console: **Timeout** Obbligatorio: `true` Tipo: `string` Valori validi: `1 - 59` Schema valido: `^([1-9]|[1-5][0-9])$` `SerialPort` Il percorso assoluto della porta seriale fisica sul dispositivo. Si tratta del percorso di origine specificato per la risorsa del dispositivo locale. Nome visualizzato nella AWS IoT console: **porta seriale** Obbligatorio: `true` Tipo: `string` Schema valido: `[/a-zA-Z0-9_-]+` `SerialPort-ResourceId` L'ID della risorsa del dispositivo locale fisico che rappresenta la porta seriale fisica. Al connettore è concesso l'accesso in lettura e scrittura alla risorsa. Nome visualizzato nella AWS IoT console: **risorsa della porta seriale** Richiesto: `true` Tipo: `string` Schema valido: `[a-zA-Z0-9_-]+` `PollingRead` Imposta la modalità di lettura: Polling-Read o. Read-On-Demand + Per la modalità Polling-Read, specificare `true`. In questa modalità, sono obbligatorie le proprietà `PollingInterval`, `PollingReadType` e `PollingReadLength`. + Per la Read-On-Demand modalità, specificare. `false` In questa modalità, il tipo e i valori di lunghezza sono specificati nella richiesta di lettura. Nome visualizzato nella AWS IoT console: **modalità di lettura** Obbligatorio: `true` Tipo: `string` Valori validi: `true, false` Schema valido: `^([Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$` `PollingReadLength` La lunghezza dei dati (in byte) da leggere in ciascuna operazione di lettura di polling. Si applica solo quando si utilizza la modalità Polling-Read. Nome visualizzato nella AWS IoT console: lunghezza della **lettura del sondaggio** Obbligatorio: `false`. Questa proprietà è obbligatoria quando `PollingRead` è `true`. Tipo: `string` Modello valido: `^(|[1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-2][0-9]{3}|63[0-8][0-9]{2}|639[0-8][0-9]|6399[0-4])$` `PollingReadInterval` L'intervallo di tempo (in secondi) in cui il avviene la lettura di polling. Si applica solo quando si utilizza la modalità Polling-Read. Nome visualizzato nella AWS IoT console: Intervallo di **lettura dei sondaggi** Obbligatorio: `false`. Questa proprietà è obbligatoria quando `PollingRead` è `true`. Tipo: `string` Valori validi: 1 - 999 Modello valido: `^(|[1-9]|[1-9][0-9]|[1-9][0-9][0-9])$` `PollingReadType` Il tipo di dati letto dal thread di polling. Si applica solo quando si utilizza la modalità Polling-Read. Nome visualizzato nella AWS IoT console: tipo di **lettura del sondaggio** Obbligatorio: `false`. Questa proprietà è obbligatoria quando `PollingRead` è `true`. Tipo: `string` Valori validi: `ascii, hex` Modello valido: `^(|[Aa][Ss][Cc][Ii][Ii]|[Hh][Ee][Xx])$` `RtsCts` Indica se abilitare o meno il controllo del flusso RTS/CTS. Il valore predefinito è `false`. Per ulteriori informazioni, consulta [RTS, CTS e RTR](https://en.wikipedia.org/wiki/RS-232#RTS,_CTS,_and_RTR). Nome visualizzato nella AWS IoT console: controllo del flusso **RTS/CTS** Obbligatorio: `false` Tipo: `string` Valori validi: `true, false` Schema valido: `^(|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$` `XonXoff` Indica se abilitare o meno il controllo del flusso del software. Il valore predefinito è `false`. Per ulteriori informazioni, consulta [Controllo del flusso software](https://en.wikipedia.org/wiki/Software_flow_control). Nome visualizzato nella AWS IoT console: **Software flow control** Obbligatorio: `false` Tipo: `string` Valori validi: `true, false` Schema valido: `^(|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$` `Parity` La parità della porta seriale. Il valore predefinito è `N`. Per ulteriori informazioni, consulta [Parità](https://en.wikipedia.org/wiki/Serial_port#Parity). Nome visualizzato nella AWS IoT console: **parità della porta seriale** Obbligatorio: `false` Tipo: `string` Valori validi: `N, E, O, S, M` Schema valido: `^(|[NEOSMneosm])$` ### Esempio di creazione di un connettore (AWS CLI) Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore Serial Stream. Configura il connettore per la modalità Polling-Read. ``` aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MySerialStreamConnector", "ConnectorArn": "arn:aws:greengrass:region::/connectors/SerialStream/versions/3", "Parameters": { "BaudRate" : "9600", "Timeout" : "25", "SerialPort" : "/dev/serial1", "SerialPort-ResourceId" : "my-serial-port-resource", "PollingRead" : "true", "PollingReadLength" : "30", "PollingReadInterval" : "30", "PollingReadType" : "hex" } } ] }' ``` 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). ## Dati di input Questo connettore accetta richieste di lettura o scrittura per porte seriali su due argomenti MQTT. I messaggi di input devono essere in formato JSON. + Richieste di lettura nell'argomento `serial/+/read/#`. + Richieste di scrittura nell'argomento `serial/+/write/#`. Per pubblicare in questi argomenti, sostituire il carattere jolly `+` con il nome oggetto del core e il carattere jolly `#` con il percorso della porta seriale. Per esempio: ``` serial/core-thing-name/read/dev/serial-port ``` **Filtro di argomenti:** `serial/+/read/#` Utilizza questo argomento per inviare richieste di lettura on demand a un pin seriale. Le richieste di lettura possono avere una lunghezza massima di 63994 byte. **Proprietà dei messaggi** `readLength` La lunghezza dei dati da leggere dalla porta seriale. Obbligatorio: `true` Tipo: `string` Schema valido: `^[1-9][0-9]*$` `type` Il tipo di dati da leggere. Richiesto: `true` Tipo: `string` Valori validi: `ascii, hex` Schema valido: `(?i)^(ascii|hex)$` `id` Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output. Richiesto: `false` Tipo: `string` Schema valido: `.+` **Input di esempio** ``` { "readLength": "30", "type": "ascii", "id": "abc123" } ``` **Filtro di argomenti:** `serial/+/write/#` Utilizza questo argomento per inviare richieste di scrittura a un pin seriale. Le richieste di scrittura possono avere una lunghezza massima dei dati di 128000 byte. **Proprietà dei messaggi** `data` La stringa da scrivere nella porta seriale. Richiesto: `true` Tipo: `string` Schema valido: `^[1-9][0-9]*$` `type` Il tipo di dati da leggere. Richiesto: `true` Tipo: `string` Valori validi: `ascii, hex` Schema valido: `^(ascii|hex|ASCII|HEX)$` `id` Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output. Richiesto: `false` Tipo: `string` Schema valido: `.+` **Input di esempio: richiesta ASCII** ``` { "data": "random serial data", "type": "ascii", "id": "abc123" } ``` **Input di esempio: richiesta esadecimale** ``` { "data": "base64 encoded data", "type": "hex", "id": "abc123" } ``` ## Dati di output Il connettore pubblica i dati di output in due argomenti: + Le informazioni sullo stato del connettore nell'argomento `serial/+/status/#`. + Le risposte delle richieste di lettura nell'argomento `serial/+/read_response/#`. Durante la pubblicazione in questo argomento, il connettore sostituisce il carattere jolly `+` con il nome oggetto del core e il carattere jolly `#` con il percorso della porta seriale. Per esempio: ``` serial/core-thing-name/status/dev/serial-port ``` **Filtro di argomenti:** `serial/+/status/#` Utilizza questo argomento per ascoltare lo stato delle richieste di lettura e scrittura. Se la richiesta include una proprietà `id`, verrà restituita nella risposta. **Output di esempio: Operazione riuscita** ``` { "response": { "status": "success" }, "id": "abc123" } ``` **Esempio di output: Errore** Una risposta di errore include la proprietà `error_message` che descrive l'errore o il timeout riscontrato durante l'esecuzione dell'operazione di lettura o scrittura. ``` { "response": { "status": "fail", "error_message": "Could not write to port" }, "id": "abc123" } ``` **Filtro di argomenti:** `serial/+/read_response/#` Utilizza questo argomento per ricevere risposta dei dati da un'operazione di lettura. I dati della risposta hanno la codifica Base64 se il tipo è `hex`. **Output di esempio** ``` { "data": "output of serial read operation" "id": "abc123" } ``` ## 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](#serial-stream-connector-req) per il connettore. 1. Crea e pubblica una funzione Lambda che invia dati di input al connettore. Salvare il [codice di esempio](#serial-stream-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](#serial-stream-connector-param). 1. Aggiungere sottoscrizioni al gruppo che consentono al connettore di ricevere [i dati di input](#serial-stream-connector-data-input) e inviare i [dati di output](#serial-stream-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 = 'serial/CORE_THING_NAME/write/dev/serial1' # Creating a greengrass core sdk client iot_client = greengrasssdk.client('iot-data') def create_serial_stream_request(): request = { "data": "TEST", "type": "ascii", "id": "abc123" } return request def publish_basic_request(): iot_client.publish(payload=json.dumps(create_serial_stream_request()), topic=TOPIC_REQUEST) publish_basic_request() def lambda_handler(event, context): return ``` ## Licenze Il connettore Serial Stream include i seguenti software/licenze di terze parti: + [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. | | 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)