Je vous ai présenté dans un premier article la carte LSM100A de SNOC pour le Raspberry Pi. J’ai également testé la carte embarquant le même module LSM100A, cette fois pour le Raspberry Pi PICO. J’ai programmé le premier module en Python, celui-ci sera programmé en microPython. Les deux cartes envoient les données vers TTN (The Things Network) via la Gateway (Passerelle) d’Elecrow dont je vous ai parlé le mois dernier.

Carte  Hat PICOLPWAN LoRa et SigFox de SNOC avec LSM100A

Déballage du matériel

Pour le déballage des cartes, je vous renvoie à l’article précédent. Ici je vais parler de la mise en œuvre de cette carte Hat PICOLPWAN de SNOC.

Cette carte est livrée avec l’antenne 868MHz, l’adaptateur U-FL vers SMA et les deux connecteurs à souder de chaque côté du module.

Le module créé par SNOC embarque un module LSM100A déjà vu dans l’article précédent. Ici la carte est adaptée à un Raspberry Pi PICO.

Schéma et implantation de la carte

La carte occupe une partie des GPIO, les autres restent libres pour connecter des capteurs.

Peu de composants annexes puisque le module regroupe tout ce qui est nécessaire. Quelques condensateurs de découplage et la prise U-FL.

Montage de la carte

Pour le montage de la carte j’ai choisi de mettre la carte LSM100A au dessus du Raspberry Pi PICO. Ici, j’ai mis les connecteurs en place sur le PICO. Il est aussi possible de la monter sous la carte, si vous avez un Raspberry Pi avec le connecteur monté dessous. Dans ce cas il faudra monter les connecteurs de la carte SNOC au dessus de la carte LSM100A.

Dans un deuxième temps j’ai posé la carte SNOC sur les connecteurs, puis réalisé les soudures (oui je sais brasures) pour solidariser les connecteurs à la carte.

Les soudures sont faites, on peut monter la carte sur le PICO.

Et enfin connecter l’antenne. Comme pour tous les modules comportant un émetteur, il faut éviter de mettre sous tension sans avoir au préalable connecté l’antenne. Lors du passage en émission, si l’antenne est absente, l’énergie ne peut pas se dissiper et on risque de détruite l’étage de sortie de l’émetteur. De même si l’antenne n’est pas adaptée. Par exemple, si les antennes se ressemblent, une antenne WiFi prévue pour le 2,4 GHz ou le 5 GHz n’est pas utilisable avec ce matériel, ou alors elle fournira des résultats lamentables.

Programme de test

Le test consiste à envoyer des valeurs fixes vers TTN. Il faut d’abord configurer la carte. J’ai laissé tous les print qui m’ont permis de suivre les opérations.

# Importer les bibliothèques serial et time
from machine import Pin, UART 
import time
import sys

# Créer un objet serial avec les paramètres du port uart
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
uart.init(bits=8, parity=None, stop=1)

# Port d'envoi
port = b"1"
# Accusé de réception
ack = b"1"

led = Pin("LED", Pin.OUT)

# Définir les octets à envoyer
data = b"\x55\xAA"

# Définir l'intervalle d'envoi en secondes
interval = 30

# Définir les paramètres OTAA
dev_eui = "70:B3:xx:xx:xx:xx:4F:40" # à remplacer par votre valeur
app_eui = "01:01:01:01:01:01:01:01" # à remplacer par votre valeur
app_key = "5E:xx:CC:xx:3A:xx:xx:xx:xx:xx:xx:xx:xx:0F:08:22" # à remplacer par votre valeur
net_key = "5E:xx:CC:xx:3A:xx:xx:xx:xx:xx:xx:xx:xx:0F:08:22" # à remplacer par votre valeur

# Définir une fonction qui teste la réponse de la carte
def check_response(resp):
    # Si la réponse contient "OK"
    if b"OK" in resp:
        # Retourner True
        return True
    # Sinon
    else:
        # Afficher un message d'erreur
        print("La commande AT a échoué.")
        # Retourner False
        return False

# Vérifier que la carte est bien alimentée
uart.write(b"AT\r\n")
time.sleep(1)
# Attendre la réponse
resp = uart.read()
data = resp.decode()
print("Cde AT : ", data)
# Tester la réponse
if not check_response(resp):
    # Arrêter le programme
    sys.exit()

# Passer en mode LoRa
uart.write(b"AT+MODE=1\r\n")
time.sleep(10)
# Attendre la réponse
resp = uart.read()
print("Cde AT+MODE : ", resp.decode())

#× Configurer en bande EU 868MHz
uart.write(b"AT+BAND=5\r\n")
time.sleep(5)
# Attendre la réponse
resp = uart.read()
print("Cde AT+BAND : ", resp.decode())


# Configurer les paramètres OTAA
uart.write(b"AT+DEUI=" + dev_eui + b"\r\n")
time.sleep(2)
resp = uart.read()
print("DEUI : ", resp.decode())

uart.write(b"AT+APPEUI=" + app_eui + b"\r\n")
time.sleep(2)
resp = uart.read()
print("APPEUI : ", resp.decode())

uart.write(b"AT+APPKEY=" + app_key + b"\r\n")
time.sleep(2)
resp = uart.read()
print("APPKEY : ", resp.decode())

uart.write(b"AT+NWKKEY=" + net_key + b"\r\n")
time.sleep(2)
resp = uart.read()
print("NWKKEY : ", resp.decode())

# Joindre la carte
uart.write(b"AT+JOIN=1\r\n")
time.sleep(15)
resp = uart.read()
data = resp.decode()
print("JOINED ! : ", data)

# Boucle infinie
try:
    while True:
        # Envoyer les octets sur le port serial
        chaine = b"AA55"
        cmd = b"AT+SEND=1:1:" + chaine + b"\n\r"
        uart.write(cmd)

        print("Envoi : ", cmd)
        time.sleep(5)
        # Attendre la réponse
        resp = uart.read()
        print(resp.decode())
       # Attendre l'intervalle
        time.sleep(interval)
except KeyboardInterrupt:
    # Sortir du programme par CTRL C
    print("Programme interrompu par l'utilisateur.")
    sys.exit()

Ça fonctionne, il faut envoyer des valeurs réelles vers TTN, j’ai choisi d’envoyer la température de du CPU du RP2040. En plus pour savoir si le programme fonctionne, j’ai fait clignoter la LED ce qui rassure sur la « vie » du programme.

Envoi de données réelles vers TTN

# Créé par framboise314
# Le 12 février 2024
# Version 1.2
# ----------------------------------------------------
# Envoyer la température CPU du PICO sur la console TTN
# ====================================================
# Température pico d'après
# https://www.upesy.fr/blogs/tutorials/micropython-raspberry-pi-pico-adc-usage-measure-voltage
# ====================================================
# Importer les bibliothèques serial et time


from machine import Pin, UART, ADC
import time
import sys

# Créer un objet serial avec les paramètres du port uart
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
uart.init(bits=8, parity=None, stop=1)

# Port d'envoi
port = b"1"
# Accusé de réception
ack = b"1"

led = Pin(25, Pin.OUT)

# Définir les octets à envoyer
data = b"\x55\xAA"

# Définir l'intervalle d'envoi en secondes
interval = 30

# Faire clignoter la LED pour montrer que le prog fonctionne et attend
def attend (temps) :
    t = 0
    while t < temps:
        led.value(1) # on allume
        time.sleep(0.05)  # on attend 
        led.value(0) # on éteint
        time.sleep(0.1) # on attend 
        led.value(1) # on allume
        time.sleep(0.05)  # on attend 
        led.value(0) # on éteint
        time.sleep(0.3)
        t = t+ 0.5


# Définir les paramètres OTAA
dev_eui = "70:B3:D5:7E:D0:06:4F:40" # à remplacer par votre valeur
app_eui = "01:01:01:01:01:01:01:01" # à remplacer par votre valeur
app_key = "5E:AD:CC:7F:3A:F2:D7:B0:B3:F2:C4:C6:26:0F:08:22" # à remplacer par votre valeur
net_key = "5E:AD:CC:7F:3A:F2:D7:B0:B3:F2:C4:C6:26:0F:08:22" # à remplacer par votre valeur

# Définir une fonction qui teste la réponse de la carte
def check_response(resp):
    # Si la réponse contient "OK"
    if b"OK" in resp:
        # Retourner True
        return True
    # Sinon
    else:
        # Afficher un message d'erreur
        print("La commande AT a échoué.")
        # Retourner False
        return False

# Vérifier que la carte est bien alimentée
uart.write(b"AT\r\n")
attend(1)
# Attendre la réponse
resp = uart.read()
data = resp.decode()
print("Cde AT : ", data)
# Tester la réponse
if not check_response(resp):
    # Arrêter le programme
    sys.exit()

# Passer en mode LoRa
uart.write(b"AT+MODE=1\r\n")
attend(10)
# Attendre la réponse
resp = uart.read()
print("Cde AT+MODE : ", resp.decode())

#× Configurer en bande EU 868MHz
uart.write(b"AT+BAND=5\r\n")
attend(5)
# Attendre la réponse
resp = uart.read()
print("Cde AT+BAND : ", resp.decode())


# Configurer les paramètres OTAA
uart.write(b"AT+DEUI=" + dev_eui + b"\r\n")
attend(2)
resp = uart.read()
print("DEUI : ", resp.decode())

uart.write(b"AT+APPEUI=" + app_eui + b"\r\n")
attend(2)
resp = uart.read()
print("APPEUI : ", resp.decode())

uart.write(b"AT+APPKEY=" + app_key + b"\r\n")
attend(2)
resp = uart.read()
print("APPKEY : ", resp.decode())

uart.write(b"AT+NWKKEY=" + net_key + b"\r\n")
attend(2)
resp = uart.read()
print("NWKKEY : ", resp.decode())

# Joindre la carte
uart.write(b"AT+JOIN=1\r\n")
attend(15)
resp = uart.read()
data = resp.decode()
print("JOINED ! : ", data)

# Boucle infinie
try:
    while True:
        # Mesurer la température
        capteur_temperature = ADC(4)
        adc_volt = capteur_temperature.read_u16() * 3.3 /65535
        # Calcul température d'après la formule qui est dans la doc du RP2040
        cpu_temp = 27 -(adc_volt -0.706)/0.001721        
        print ("Température : " , cpu_temp)
        entier_str = '{}'.format(int(cpu_temp))
        print ("Valeur entière température : ", entier_str)
        decimale = int((cpu_temp-int(cpu_temp))*100)
        print ("Valeur de la décimale : ", decimale)
        decimale_str = '{}'.format(decimale)
        # Si on n'a qu'un chiffre, on ajoute un 0 devant
        if len(decimale_str) == 1:
            decimale_str = "0" + decimale_str
        print ("Température reconstituée : ", entier_str + "." + decimale_str)    
        # Envoyer les octets sur le port serial
        chaine = entier_str + decimale_str
        cmd = b"AT+SEND=1:1:" + chaine + b"\n\r"
        uart.write(cmd)

        print("Envoi : ", cmd)
        attend(5)
        # Attendre la réponse
        resp = uart.read()
        print(resp.decode())
       # Attendre l'intervalle
        attend(interval)
except KeyboardInterrupt:
    # Sortir du programme par CTRL C
    print("Programme interrompu par l'utilisateur.")
    sys.exit()

Le programme fonctionne et envoie bien les données vers TTN

Conclusion

La carte fonctionne de la même manière que le LSM100A sur le Raspberry Pi. Il faut simplement adapter le programme à microPython pour le Raspberry Pi PICO. C’est une ouverture vers la réalisation d’objets connectés peu chers, comme une station météo sur une parcelle de vigne, la surveillance d’une ruche…
Si vous avez l’occasion d’utiliser ce matériel, n’hésitez pas à nous envoyer une présentation, des photos qui seront ajoutées à l’article.

Sources

Kit LoRa/Sigfox LSM100A Raspberry Pi

: 34,68 €

Kit LoRa/Sigfox LSM100A Raspberry Pi PICO : 27,48 €

Toute la documentation en ligne

https://support.seongji.co.kr/lora-main-2-2/

https://support.seongji.co.kr/sigfox-product/

https://github.com/Support-SJI/LSM100A