[Serie Docker Pi]Come utilizzare il modulo IoT Node (A) su Raspberry Pi: 18 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Che cos'è il modulo IoT Node (A)?

IoT Node (A) è uno dei moduli della serie Docker Pi.

Nodo IOT (A) = GPS/BDS + GSM + Lora.

I2C controlla direttamente Lora, invia e riceve dati, controlla il modulo GSM/GPS/BDS tramite SC16IS752, la scheda madre necessita solo del supporto I2C.

Supporta Raspberry Pi e altri prodotti simili.

Forniture

1x Raspberry Pi 2B/3B/3B+/4B/3A+/Zero/Zero W

1x prodotto della serie Docker Pi: modulo IoT Node(A)

1x scheda TF di classe 10 da 16 GB

1x alimentatore 5V/2,5A (5V@3A per Pi 4B)

Passaggio 1: Caratteristiche

• Serie Docker Pi
• Programmabile
• Controllo diretto (senza programmazione)
• Estendere i pin GPIO
• Supporto GPS/BDS
• Supporto GSM
• Supporto Lora
• Può impilare con un'altra scheda Stack
• Indipendente dall'hardware della scheda madre (richiede il supporto I2C)

Passaggio 2: Passaggio 1: conoscere la scheda IoT (A)

IoT Node (A) è uno dei moduli della serie Docker Pi.

Nodo IOT (A) = GPS/BDS + GSM + Lora.

I2C controlla direttamente Lora, invia e riceve dati, controlla il modulo GSM/GPS/BDS tramite SC16IS752, la scheda madre necessita solo del supporto I2C. Supporta Raspberry Pi e altri prodotti simili.

Quindi puoi creare un dispositivo di comunicazione di medio raggio usando due di essi.

e inoltre puoi localizzare la posizione del tuo dispositivo utilizzando il modulo GPS a bordo.

Inserire una scheda SIM, diventerà una stazione trasmittente tramite messaggio SMS.

Passaggio 3: Passaggio 2: come assemblarlo

È molto facile da assemblare grazie al suo design "HAT", basta metterlo sul tuo raspberry pi e collegarlo tramite pin GPIO, come un "cappello" su raspberry pi, in modo da non dover aggiungere la massa filo.

Passaggio 4: Passaggio 3: collegare l'antenna

Ci sono 3 pezzi di antenna per questo modulo IoT (A), uno di questi è per il modulo loar, è un'antenna di tipo SMA e uno di questi è buono per il tuo GPS, è un'antenna quadrata con porta IPX. e l'ultimo è per il modulo SIM (A9G), è una piccola antenna che ha una porta IPX. collega l'antenna e monta il cappello sul tuo Raspberry Pi.

Come assemblare Montare la scheda Iot Node(A) su Raspberry Pi

Collega GPS antana e Lora antana alla porta IPX.

• E1：GPS-ANTANA-IPX
• E3：LoRa-ANTANA-IPX

Avvita l'antana GPRS sulla porta SMA.

Passaggio 5: Passaggio 4: Ambiente del sistema operativo e configurazioni software

In questo passaggio, devi fare queste cose:

1. Scarica l'ultimo file immagine da: www.raspberrypi.org/downloads

2. Decomprimilo.

3. Visualizza la tua scheda TF con l'ultima immagine tramite lo strumento di incisione

4. Modificare il file /boot/config.txt e aggiungere questo paragrafo.

dtoverlay=sc16is752-i2c

5. Sostituisce il file /boot/overlay/sc16is752-i2c.dtbo con questo file:

wiki.52pi.com/index.php/File:Sc16is752-i2c…

PS: ricorda di decomprimerlo e metterlo nella cartella /boot/overlay/ e sostituire quello vecchio.

6. Riavvia il tuo Raspberry Pi.

Passaggio 6: Passaggio 5: configurazione di I2C (Raspberry Pi)

Esegui sudo raspi-config e segui le istruzioni per installare il supporto i2c per il core ARM e il kernel linux Vai a Opzioni di interfaccia

Passaggio 7: Passaggio 6: conoscere le informazioni sul registro

Sezione GPRS

Basso consumo energetico, corrente di sospensione in standby <1mA2.

Supporta GSM/GPRS quattro bande di frequenza, incluse 850, 900, 1800, 1900MHZ

GPRS Classe 10

Supporta il servizio dati GPRS, velocità dati massima, download 85,6 Kbps, caricamento 42,8 Kbps

Supporta i comandi standard GSM07.07, 07.05 AT e accedi alla porta seriale tramite la conversione dell'interfaccia I2C

I comandi AT supportano le porte di comando AT e TCP/IP standard

Sezione GPSSupporto posizionamento giunto BDS/GPS

Supporta A-GPS, A-BDS

Supporta la scheda SIM standard

Sezione LORA Distanza di trasmissione: 500 metri (parametri RF: 0x50 @ China City)

Supporta i metodi di modulazione FSK, GFSK, MSK, GMSK, LoRaTM e OOK

Sensibilità del ricevitore ultra elevata fino a -141 dBm

Supporta il rilevamento del preambolo

Motore a pacchetti con CRC, fino a 256 byte

Indicatore ricetrasmettitore LORA

Easy TX/RX di Docker Pi

Passaggio 8:

Modulo A9G

Il modulo A9G offre due porte seriali.

Utilizzare il bridge I2C UART per la comunicazione.

Nome del modulo della porta seriale

• /dev/ttySC0 GSM
• /dev/ttySC1 GPS/BDS

Registrati Mappa

• Registro Indirizzo Funzione Valore
• 0x01 LORA_TX1 Buffer TX Lora 1 - Dati utente
• 0x02 LORA_TX2 Buffer TX Lora 2 - Dati utente
• 0x03 LORA_TX3 Lora TX Buffer 3 - Dati utente
• 0x04 LORA_TX4 Lora TX Buffer 4 - Dati utente
• 0x05 LORA_TX5 Lora TX Buffer 5 - Dati utente
• 0x06 LORA_TX6 Buffer TX Lora 6 - Dati utente
• 0x07 LORA_TX7 Lora TX Buffer 7 - Dati utente
• 0x08 LORA_TX8 Buffer TX Lora 8 - Dati utente
• 0x09 LORA_TX9 Lora TX Buffer 9 - Dati utente
• 0x0a LORA_TX10 Lora TX Buffer 10 - Dati utente
• 0x0b LORA_TX11 Lora TX Buffer 11 - Dati utente
• 0x0c LORA_TX12 Buffer TX Lora 12 - Dati utente
• 0x0d LORA_TX13 Buffer TX Lora 13 - Dati utente
• 0x0e LORA_TX14 Buffer TX Lora 14 - Dati utente
• 0x0f LORA_TX15 Buffer TX Lora 15 - Dati utente
• 0x10 LORA_TX16 Buffer TX Lora 16 - Dati utente
• 0x11 LORA_RX1 Lora RX Buffer 1 - Dati utente
• 0x12 LORA_RX2 Lora RX Buffer 2 - Dati utente
• 0x13 LORA_RX3 Lora RX Buffer 3 - Dati utente
• 0x14 LORA_RX4 Lora RX Buffer 4 - Dati utente
• 0x15 LORA_RX5 Lora RX Buffer 5 - Dati utente
• 0x16 LORA_RX6 Lora RX Buffer 6 - Dati utente
• 0x17 LORA_RX7 Lora RX Buffer 7 - Dati utente
• 0x18 LORA_RX8 Lora RX Buffer 8 - Dati utente
• 0x19 LORA_RX9 Lora RX Buffer 9 - Dati utente
• 0x1a LORA_RX10 Lora RX Buffer 10 - Dati utente
• 0x1b LORA_RX11 Lora RX Buffer 11 - Dati utente
• 0x1c LORA_RX12 Lora RX Buffer 12 - Dati utente
• 0x1d LORA_RX13 Lora RX Buffer 13 - Dati utente
• 0x1e LORA_RX14 Lora RX Buffer 14 - Dati utente
• 0x1f LORA_RX15 Buffer RX Lora 15 - Dati utente
• 0x20 LORA_RX16 Lora RX Buffer 16 - Dati utente
• 0x01 - 0x10 Solo scrittura.
• 0x11 - 0x20 Sola lettura.

Passaggio 9: Istruzioni:

L_SET (Solo scrittura)

• Scrivi 1 per impostare i parametri da 0x22 al modulo LORA.
• Scrivi 0 non ha effetto

G_RESET(Solo scrittura)

• Scrivi 1 per ripristinare il modulo A9G
• Scrivi 0 non ha effetto

L_RXNE(Lettura e scrittura)

• Scrivi 1 causa errore
• Scrivi 0 per cancellare
• Leggi 1 significa che i dati sono stati ricevuti, per favore ottieni i dati dal registro 0x11 - 0x20.
• Leggi 0 significa nessun dato disponibile ora.

L_SET (Solo scrittura)

• Scrivi 1 per inviare i dati, inserisci i dati nel registro 0x01 - 0x10 prima di inviare.
• Scrivi 0 non ha effetto

Passaggio 10: come utilizzare il modulo GPS con Gpsd (Raspberry Pi)

Come utilizzare il modulo GPS con gpsd (Raspberry Pi)

Innanzitutto, sostituisci /boot/overlays/sc16is752-i2c.dtbo e assicurati che I2C funzioni correttamente.

• Sostituisci sc16is752-i2c.dtbo
• Configurazione di I2C
• Installa gli strumenti gpsd.

Apri un terminale e digita questo comando:

sudo apt install gpsd gpsd-clients

Modifica il file /etc/default/gpsd e aggiungi i seguenti parametri:

• DISPOSITIVI="/dev/ttySC1"
• GPSD_OPTIONS="-F /var/run/gpsd.sock"

Immettere il comando i2cset -y 1 0x16 0x23 0x40 per ripristinare il modulo GPRS.

Script Python per GPS aperto:

import serialimport os import time # Riavvia il servizio gpsd. os.system("sudo systemctl restart gpsd.socket") # Apri la porta seriale ser = serial. Serial('/dev/ttySC0', 115200) i = 0 if ser.isOpen == False: ser.open() try: print("Attiva GPS…") while True: ser.write(str.encode("AT+GPS=1\r")) size = ser.inWaiting() if size != 0: ticks = time.time() response = ser.read(size) gps = str(response, encoding="utf-8") if(gps.find("OK") != -1): os.system("sudo cgps -s") exit() else: i = i + 1 print("Waiting GPS Enable, Se il tempo è troppo lungo, prova all'aperto:" + str(i)) ser.flushInput() time.sleep(1) tranne KeyboardInterrupt: ser.flushInput() ser.close()

Salvalo ed eseguilo:

python3 GPS.py

Passaggio 11: come utilizzare il modulo GPS con C (Raspberry Pi)

Installa gli strumenti gpsd

sudo apt-get install libgps-dev

Crea il codice sorgente e chiamalo "gps.c"

#include #include #include

#includere

#includere

intero principale()

{ int rc; struttura timeval tv; struttura gps_data_t gps_data; if ((rc = gps_open("localhost", "2947", &gps_data)) == -1) { printf("code: %d, reason: %s\n", rc, gps_errstr(rc)); restituisce EXIT_FAILURE; } gps_stream(&gps_data, WATCH_ENABLE | WATCH_JSON, NULL);

mentre (1)

{ /* attendi 2 secondi per ricevere i dati */ if (gps_waiting(&gps_data, 2000000)) { /* leggi i dati */ if ((rc = gps_read(&gps_data)) == -1) { printf("si è verificato un errore durante la lettura dati gps codice: %d, motivo: %s\n", rc, gps_errstr(rc)); } else { /* Visualizza i dati dal ricevitore GPS. */ if ((gps_data.status == STATUS_FIX) && (gps_data.fix.mode == MODE_2D || gps_data.fix.mode == MODE_3D) && !isnan(gps_data.fix.latitude) && !isnan(gps_data.fix.longitudine)) { /* gettimeofday(&tv, NULL); EDIT: tv.tv_sec non è in realtà il timestamp! */

printf("latitudine: %f, longitudine: %f, velocità: %f, timestamp: %lf\n", gps_data.fix.latitude, gps_data.fix.longitude, gps_data.fix.speed, gps_data.fix.time);

//EDIT: Sostituito tv.tv_sec con gps_data.fix.time } else { printf("nessun dato GPS disponibile\n"); } } } dormi (3); } /* Quando hai finito… */ gps_stream(&gps_data, WATCH_DISABLE, NULL); gps_close(&gps_data); restituire EXIT_SUCCESS; }

Passaggio 12: compilalo

Compilare!

gcc gps.c -lm -lgps -o gps

Eseguilo!

./GPS

Passaggio 13: come utilizzare il modulo GPS con Python (Raspberry Pi)

Si consiglia di eseguire il codice seguente utilizzando Python 3 e installare la libreria gpsd-py3 e GPS 2D/3D Fix:

importa gpsd

# Connettiti al gpsd locale

gpsd.connect()

# Ottieni posizione GPS

pacchetto = gpsd.get_current()

# Vedi i documenti in linea per GpsResponse per i dati disponibili

print(pacchetto.posizione())

Passaggio 14: come utilizzare il modulo GSM con PPPd (Raspberry Pi)

A) Innanzitutto, sostituisci /boot/overlays/sc16is752-i2c.dtbo e assicurati che I2C funzioni correttamente.

• Sostituisci sc16is752-i2c.dtbo
• Configurazione di I2C

B) Immettere il comando i2cset -y 1 0x16 0x23 0x40 per ripristinare il modulo GPRS.

Dopo aver eseguito il comando, è necessario attendere un po', circa 10 secondi

È inoltre possibile utilizzare il seguente metodo per ripristinare.

C) Immettere il comando

sudo apt install ppp

per installare gli strumenti ppp.

D) Copia /etc/ppp/peers/provider in /etc/ppp/peers/gprs

E) Modifica /etc/ppp/peers/gprs

• Riga 10: Consultare il provider di servizi per l'utente (Esempio: cmnet).
• Riga 15: Consultare il provider di servizi per l'apn (Esempio: cmnet).
• Riga 18 - Riga 24: Impostazione consigliata

F) Modifica /etc/chatscripts/gprs (Cambia la riga 34 con la riga 35, il numero di chiamata può essere NON *99#)

G) Immettere il comando sudo pppd call gprs per dial-up.

H) Controlla la configurazione del tuo ppp dal tuo ISP.

I) Immettere il comando ping -I ppp0 8.8.8.8 testare la rete (se Internet è disponibile e la tabella di routing è corretta)

J) Si prega di mantenere il segnale GSM buono, altrimenti accadrà quanto segue.

Passaggio 15: come diagnosticare il mio modulo GSM (Raspberry Pi)

Si consiglia di eseguire il codice seguente utilizzando Python 3 e installare la libreria smbus:

import serialimport time import smbus import operator import os

print("In attesa di inizializzazione…")

bus = smbus. SMBus(1)

bus.write_byte_data(0x16, 0x23, 0x40)

ser = serial. Serial('/dev/ttySC0', 115200)

se ser.isOpen == Falso:

ser.open() try: print('-'*60) print("Inizializzazione modulo GPRS A9G.") print("Connessione GSM…") time.sleep(3) i = 0 while True: ser.write(str.encode("AT+CCID\r")) size = ser.inWaiting() if size != 0: ticks = time.time() response = ser.read(size) ccid = str(response, encoding="utf -8") print(ccid) else: i = i + 1 ser.flushInput() time.sleep(1) tranne KeyboardInterrupt: ser.close()

Esegui lo script di test, in base ai risultati dell'implementazione, possiamo diagnosticare il modulo GSM. Ad esempio, il seguente ritorno, errore CME ERROR 53 ci dice Potenza non buona. Codice CME = Errori relativi all'apparecchiatura GSM

Naturalmente, lo script ha anche una funzione di ripristino. Se è possibile visualizzare correttamente il CCID, il ripristino è completo.

Passaggio 16: come utilizzare Lora TX e RX con C (Raspberry Pi)

Si consiglia di eseguire il codice seguente utilizzando Python 3 e installare la libreria smbus.

Deve essere trasferito tra i due IOT Node(A). Il contenuto inviato da solo non può essere ricevuto da solo. Si prega di salvarlo come script py per l'esecuzione.

Come inviare: dopo aver inserito i dati nel registro 0x01 - 0x10, impostare il bit L_TX per avviare l'invio dei dati.

import timeimport smbus import os import sys

bus = smbus. SMBus(1)

Tentativo:

data_list = [170, 85, 165, 90] # scrive i dati nel registro e poi i dati verranno inviati. per index in range(1, len(data_list) + 1): bus.write_byte_data(0x16, index, data_list[index - 1]) print("LORA invia dati a %d register %d data" %(index, data_list[index - 1])) bus.write_byte_data(0x16, 0x23, 0x01) eccetto KeyboardInterrupt: sys.exit()

How to Send Receive:Check L_RXNE bit, Se impostato, sono arrivati nuovi dati, questo flag deve essere cancellato manualmente

import timeimport smbus import os import sys

bus = smbus. SMBus(1)

recv_data =

Tentativo:

if bus.read_byte_data(0x16, 0x23) & 0x02: # cancella manualmente L_RXNE bus.write_byte_data(0x16, 0x23, 0x00) register_list = [0x11, 0x12, 0x13, 0x14] # legge i dati per l'indice nell'intervallo (0x11, len(register_list) + 0x11): recv_data.append(bus.read_byte_data(0x16, register_list[index - 0x11]))

print("Dati ricevuti:")

print(recv_data) else: print("Nessun dato ricevuto ancora~") tranne KeyboardInterrupt: sys.exit()

Passaggio 17: descrizione speciale della larghezza di banda I2C

Il limite della velocità I2C è 400kHz, a causa del protocollo I2C, quindi la larghezza di banda effettiva del singolo dispositivo è inferiore a 320 kbps, la larghezza di banda effettiva del multi dispositivo è inferiore a 160 kbps. Il limite della velocità del ponte I2C UART è 115200 bps. Quando GPS e GSM funzionano allo stesso tempo, la larghezza di banda I2C è insufficiente, perché 115,2 kbps * 2 = 230,4 kbps, quindi alcuni dati saranno in overflow. La riduzione della velocità di trasmissione della comunicazione GPS e GSM può migliorare la carenza di larghezza di banda di comunicazione. L'impilamento di altri moduli DockerPi potrebbe richiedere larghezza di banda I2C extra. Di solito, la velocità dei dati di rete è lenta, quindi la larghezza di banda GSM non è piena, quindi non ci sono problemi di overflow.

Passaggio 18: finito

Spero che vi piaccia e che ce la farete.

Potete trovare qui:

Amazon

Luce notturna: https://www.amazon.com/GeeekPi-Night-Light-WS2812-Raspberry/dp/B07LCG2S5S Scheda relè a 4 canali: https://www.amazon.co.uk/dp/B07MV1TJGR?ref=myi_title_dp Scheda di alimentazione ：https://www.amazon.co.uk/dp/B07TD595VS?ref=myi_title_dp IoT Node（A）：https://www.amazon.co.uk/dp/B07TY15M1C HUB sensore: https://www. amazon.co.uk/dp/B07TZD8B61 torre di ghiaccio: