WisBlock API V2
AT command parsing and default fPort changes
 |  |  |  |  |
|---|
Ciblage de faible consommation d'énergie, cette bibliothèque Arduino pour les modules de noyau Wisblock sans Rakwire s'occupe de tous les fonctionnalités LORA P2P, Lorawan, BLE, aux fonctionnalités de commande. Vous pouvez vous concentrer sur votre application et laisser le reste à l'API. Il est fabriqué en tant que compagnon de la bibliothèque SX126X-ARDUINO LORAWAN
Cela nécessite de repenser les applications Arduino, car vous n'avez pas de fonction setup() ou loop() . Au lieu de cela, tout est motivé par l'événement. Le MCU dort jusqu'à ce qu'il ait besoin de prendre des mesures. Il peut s'agir d'un événement Lorawan, une commande AT reçue sur le port USB ou un événement d'application, par exemple une interruption provenant d'un capteur.
Cette approche facilite la création d'applications conçues pour une faible utilisation de puissance. Pendant le sommeil, la base de Wisblock + Core Wisblock RAK4631 ne consomme que 40UA.
De plus, l'API propose deux options pour configurer les paramètres LORA P2P / Lorawan sans avoir besoin de les coder dur dans les codes source.
V2 de la bibliothèque a modifié le format de commande AT pour être compatible avec RUI3 aux commandes. Veuillez vérifier le manuel de commande AT pour RUI3 pour les différences.
La version V2 ne prend en charge que le module Core Wisblock Rak4631 sans Rakwireless
La prise en charge des RAK11310 et RAK1200 pourrait être ajoutée à l'avenir
L'API gère tout, à partir de setup() , loop() , de lorawan initialisation, de manipulation des événements de Lorawan, d'initialisation BLE, de traitement des événements BLE à l'interface de commande AT.
REMARQUE!
L'application utilisateur ne doit pas avoir les fonctions setup() et loop() !
L'application utilisateur a deux fonctions d'initialisation, l'une est appelée au début de setup() , l'autre à la toute fin. Les autres fonctions sont des rappels d'événements appelés à partir de loop() . Il est également possible de définir également des événements personnalisés (comme les interruptions d'un capteur).
La lecture du capteur, le contrôle de l'actionneur ou d'autres tâches d'application sont gérées dans l' app_event_handler() . app_event_handler() est appelé fréquemment, le temps entre les appels est défini par l'application. En plus, app_event_handler() est appelé sur des événements personnalisés.
ble_data_handler() est appelé sur des événements BLE (événements BLE UART RX pour l'instant) de loop() . Il peut être utilisé pour implémenter une communication personnalisée sur BLE UART.
REMARQUE!
Cette fonction n'est pas requise sur le RAK11310!
lora_data_handler() est appelé différents événements de Lorawan
graphique TD
A [Boot] -> | Startup | B (configuration)
B -> | 1 | D (setup_app)
D -> b (configuration)
B -> | 2 | E [initialiser Lora et BLE]
E -> b (configuration)
B -> | 3 | G (init_app)
G -> k (configuration terminée)
K -> | Boucle de démarrage | Je (boucle)
Q [événement LORA] -> | Réveillez-vous | J
O [événement de capteur] -> | Réveillez-vous | JP [BLE Event] -> | Réveillez-vous | Jr [à la commande] -> | réveil | JT [TIMER] -> | Réveillez-vous | Ji -> J (dormir)
K -> | Démarrer la minuterie | T
J -> l (app_event_handler)
J -> m (lora_data_handler)
J -> n (ble_data_handler)
J -> S (au gestionnaire de commandes)
L -> u (lecture des capteurs)
M -> V (JOIN, Événements TX et RX)
N -> w (manipuler les commandes)
S -> aa (utilisateur aux commandes)
U -> l
V -> M
W -> n
Aa -> s
L -> J
M -> J
N -> J
S -> J
Toutes les commandes peuvent être trouvées dans le manuel AT-Command , toutes les commandes RUI3 ne sont pas prises en charge. Une liste des commandes disponibles peut être récupérée avec AT? de l'appareil
Deux commandes personnalisées ont été ajoutées à la RUI3 par défaut sur les commandes Set:
Description: Définissez l'intervalle de transmission automatique
Cette commande permet de définir l'intervalle en secondes entre les transmissions de paquets automatiques. S'il est réglé sur 0, la transmission automatique des paquets est désactivée.
| Commande | Paramètre d'entrée | Valeur de retour | Code de retour |
|---|---|---|---|
| ATC + SendInt? | - | ATC+SENDINT: "Get or Set the automatic send interval | OK |
| ATC + SendInt =? | - | <interval in seconds> | OK |
ATC + SendInt = <Input Parameter> | <interval in seconds> | - | OK ou AT_PARAM_ERROR |
Exemples :
ATC+SENDINT?
ATC+SENDINT: Get or Set the automatic send interval
OK
ATC+SENDINT=?
ATC+SENDINT:60
OK
ATC+SENDINT=60
OK
Description: Afficher l'état de l'appareil
Cette commande permet à l'utilisateur d'obtenir l'état actuel de l'appareil.
| Commande | Paramètre d'entrée | Valeur de retour | Code de retour |
|---|---|---|---|
| Statut ATC +? | - | ATC+STATUS: Show LoRaWAN status | OK |
| ATC + Status =? | - | <status> | OK |
Exemples :
ATC+STATUS?
ATC+STATUS: Show LoRaWAN status
OK
// When in LoRaWAN mode:
ATC+STATUS=?
Device status:
RAK4631
Mode LPWAN
Auto join enabled
Network joined
LPWAN status:
Dev EUI AC1F09FFFE09016C
App EUI 70B3D57ED00201E1
App Key 2B84E0B09B68E5CB42176FE753DCEE79
Dev Addr 26021FB4
NWS Key 323D155A000DF335307A16DA0C9DF53F
Apps Key 3F6A66459D5EDCA63CBC4619CD61A11E
OTAA enabled
ADR disabled
Public Network
Dutycycle disabled
Join trials 5
TX Power 0
DR 3
Class 0
Subband 1
Fport 2
Unconfirmed Message
Region AS923-3
Send Frequency 300
// When in LoRa P2P mode:
ATC+STATUS=?
Device status:
RAK4631
Mode P2P
P2P frequency 916000000
P2P TX Power 22
P2P BW 125
P2P SF 7
P2P CR 0
P2P Preamble length 8
P2P Symbol Timeout 0
Send Frequency 300
Description: Paramètres du port
Cette commande permet à l'utilisateur d'accéder et de configurer les paramètres du port.
| Commande | Paramètre d'entrée | Valeur de retour | Code de retour |
|---|---|---|---|
| Port ATC +? | - | AT+PORT=<Port><CR>. Get or Set the Port | OK |
| ATC + port =? | - | 1-223 | D'ACCORD |
ATC + port = <Input Parameter> | 1-223 | - | Ok ou at_param_error |
Exemples :
ATC+PORT?
ATC+PORT: Get or Set the Port=[1..223]
OK
ATC+PORT=?
ATC+PORT:2
OK
ATC+PORT=2
OK
Dos
En commençant par l'API WISBLOCK V1.1.2, les commandes AT peuvent être étendues par l'utilisateur défini sur les commandes. Cette nouvelle implémentation utilise la fonction d'analyseur de l'API WISBLOCK à la fonction de commande. En outre, les commandes personnalisées au niveau des commandes seront répertoriées si l' AT? est utilisé.
REMARQUE! Dans RUI3 Custom AT, les commandes sont appelées avec ATC plutôt qu'AT !
Pour étendre les commandes AT, trois étapes sont nécessaires:
Les commandes personnalisées sont répertoriées dans un tableau avec le format struct atcmd_t. Chaque entrée est composée de la commande AT, le texte d'explication qui est montré lorsque la commande est appelée avec A? et les pointeurs vers les fonctions de requête, exécutent avec des paramètres et exécutent sans paramètres. Voici un exemple pour deux commandes personnalisées:
atcmd_t g_user_at_cmd_list_example[] = {
/* | CMD | AT+CMD? | AT+CMD=? | AT+CMD=value | AT+CMD | Permissions | */
// GNSS commands
{ " +SETVAL " , " Get/Set custom variable " , at_query_value, at_exec_value, NULL , " RW " },
{ " +LIST " , " Show last packet content " , at_query_packet, NULL , NULL , " R " },
};
atcmd_t *g_user_at_cmd_list = g_user_at_cmd_list_example; Remarque 1
La structure des commandes personnalisées AT est étendue pour la compatibilité RUI3. Le code plus ancien écrit pour Wisblock-API v1.x doit être ajusté à cette nouvelle structure.
Remarque 2
Pour les fonctions qui ne sont pas prises en charge par la commande AT, un NULL doit être placé dans le tableau.
Remarque 3
Le nom g_user_at_cmd_list est corrigé et ne peut pas être modifié ou les commandes personnalisées ne sont pas détectées.
Remarque 4
Les autorisations sont données en tant que chaîne. Les entrées valides sont "r" (lire uniquement), "w" (écrire seulement), "RW" (lire et écrire)
Une variable avec le nombre de commandes personnalisées doit être fournie:
/* * Number of user defined AT commands */
uint8_t g_user_at_cmd_num = sizeof (g_user_at_cmd_list_example) / sizeof ( atcmd_t ); REMARQUE
Le nom g_user_at_cmd_num est corrigé et ne peut pas être modifié ou les commandes personnalisées ne sont pas détectées.
Pour chaque commande personnalisée, les commandes de requête et d'exécution doivent être écrites. Les noms de ces fonctions doivent correspondre aux noms de fonction utilisés dans le tableau des commandes personnalisées. La commande EXECUTE reçoit en tant que paramètre la valeur de la commande AT après la valeur = de la valeur.
Les fonctions de requête ( =? ) Ne reçoivent pas et les paramètres et doivent toujours revenir avec 0. Fonctions de requête Enregistrez le résultat de la requête dans le tableau de char global g_at_query_buffer , le tableau a une taille maximale d' ATQUERY_SIZE qui est de 128 caractères.
Exécuter des fonctions avec des paramètres ( =<value> ) Recevoir des valeurs ou des paramètres sous forme de pointeur vers un tableau char. Ce tableau comprend uniquement la valeur ou le paramètre sans la commande AT elle-même. Par exemple, la fonction d'exécution de la fonction ATC+SETDEV=12000 ne recevrait que le 120000 . La valeur ou le paramètre reçu doit être vérifié pour la validité et si la valeur du format ne correspond pas, un AT_ERRNO_PARA_VAL doit être renvoyé. Si la valeur ou le paramètre est correct, la fonction doit retourner 0 .
Exécuter les fonctions sans paramètres sont utilisées pour effectuer une action et renvoyer le succès de l'action en tant que 0 si réussi ou AT_ERRNO_EXEC_FAIL si l'exécution a échoué.
Ces exemples sont utilisés pour définir une variable dans l'application.
/* ******************************************************************* */
// Example AT command to change the value of the variable new_val:
// Query the value AT+SETVAL=?
// Set the value AT+SETVAL=120000
// Second AT command to show last packet content
// Query with AT+LIST=?
/* ******************************************************************* */
int32_t new_val = 3000 ;
/* *
* @brief Returns the current value of the custom variable
*
* @return int always 0
*/
static int at_query_value ()
{
snprintf (g_at_query_buf, ATQUERY_SIZE, " Custom Value: %d " , new_val);
return 0 ;
}
/* *
* @brief Command to set the custom variable
*
* @param str the new value for the variable without the AT part
* @return int 0 if the command was succesfull, 5 if the parameter was wrong
*/
static int at_exec_value ( char *str)
{
new_val = strtol (str, NULL , 0 );
MYLOG ( " APP " , " Value number >>%ld<< " , new_val);
return 0 ;
}
/* *
* @brief Example how to show the last LoRa packet content
*
* @return int always 0
*/
static int at_query_packet ()
{
snprintf (g_at_query_buf, ATQUERY_SIZE, " Packet: %02X%02X%02X%02X " ,
g_lpwan_data. data_flag1 ,
g_lpwan_data. data_flag2 ,
g_lpwan_data. batt_1 ,
g_lpwan_data. batt_2 );
return 0 ;
}
/* *
* @brief List of all available commands with short help and pointer to functions
*
*/
atcmd_t g_user_at_cmd_list_example[] = {
/* | CMD | AT+CMD? | AT+CMD=? | AT+CMD=value | AT+CMD | Permission | */
// GNSS commands
{ " +SETVAL " , " Get/Set custom variable " , at_query_value, at_exec_value, NULL , " RW " },
{ " +LIST " , " Show last packet content " , at_query_packet, NULL , NULL , " R " },
};
atcmd_t *g_user_at_cmd_list = g_user_at_cmd_list_example;
/* * Number of user defined AT commands */
uint8_t g_user_at_cmd_num = sizeof (g_user_at_cmd_list_example) / sizeof ( atcmd_t );Ces cinq exemples expliquent l'utilisation de l'API. Dans tous les exemples, les rappels API et les fonctions supplémentaires (lectures de capteurs, manipulation IRQ, service de localisation GNSS) sont séparées en leurs propres croquis.
Le Wisblock-API-V2 a également été utilisé dans les projets de plateforme suivants:
Lorsqu'il est utilisé avec le RAK4631, la mise à jour du micrologiciel sur BLE est déjà incluse dans la bibliothèque. Les mises à jour du micrologiciel pour le RAK4631 peuvent être effectuées en utilisant la boîte à outils Nordic NRF (disponible pour Android et iOS) ou avec la boîte à outils Wisblock (mon application Android).
Pour la mise à jour, copiez le fichier de mise à jour créé (généralement appelé firmware.zip) dans le dossier .pio / build / {device}, copiez-le sur votre téléphone et utilisez l'une des applications pour mettre à jour le firmware.
Si la mise à jour du firmware via BLE échoue, mettez à jour l'appareil vers le dernier chargeur de démarrage pour le RAK4631 avec la version V0.4.3. Vous pouvez trouver le dernier chargeur de démarrage dans le dépôt de Wisblock
L'API fournit quelques appels à la gestion, pour envoyer le paquet Lorawan, pour envoyer des données UART BLE et déclencher des événements.
void api_set_version(uint16_t sw_1 = 1, uint16_t sw_2 = 0, uint16_t sw_3 = 0);
Cette fonction peut être appelée pour définir la version de l'application. La version de l'application peut être demandée par les commandes. Le numéro de version est construit à partir de trois chiffres:
sw_1 ==> Augmentation majeure de la version sur le changement d'API / non compatible en arrière
sw_2 ==> Augmentation de la version mineure sur la modification de l'API / compatible en arrière
sw_3 ==> augmentation de la version de patch sur BugFix, aucun effet sur l'API
Si api_set_version n'est pas appelé, la version de l'application est par défaut à 1.0.0 .
void api_reset(void);
Effectue une réinitialisation du module Core Wisblock
void api_wake_loop(uint16_t reason);
Ceci est utilisé pour réveiller la boucle avec un événement. La reason doit être définie dans app.h Après l'application Loop Woke, il appellera l' app_event_handler() avec la valeur de reason dans g_task_event_type .
Par exemple, cela peut être utilisé pour réveiller l'appareil à partir de l'interruption d'un capteur d'accéléromètre. Ici, comme exemple, un extrait de l' accelerometer Exemple de code.
Dans accelerometer.ino l'événement est défini. La première définition consiste à régler le signal, la seconde consiste à effacer l'événement après sa gestion.
/* * Define additional events */
# define ACC_TRIGGER 0b1000000000000000
# define N_ACC_TRIGGER 0b0111111111111111 Ensuite, dans lis3dh_acc.ino dans la fonction de rappel d'interruption void acc_int_handler(void) La boucle est réveillée avec le signal ACC_TRIGGER
void acc_int_handler ( void )
{
// Wake up the task to handle it
api_wake_loop (ACC_TRIGGER);
} Et enfin dans accelerometer.ino L'événement est géré dans app_event_handler()
// ACC triggered event
if ((g_task_event_type & ACC_TRIGGER) == ACC_TRIGGER)
{
g_task_event_type &= N_ACC_TRIGGER;
MYLOG ( " APP " , " ACC IRQ wakeup " );
// Reset ACC IRQ register
get_acc_int ();
// Set Status flag, it will trigger sending a packet
g_task_event_type = STATUS;
} void api_log_settings(void);
Cette fonction peut être appelée pour répertorier les paramètres complets du périphérique Wisblock via USB. La sortie ressemble:
Device status:
RAK11310
Auto join enabled
Mode LPWAN
Network joined
Send Frequency 120
LPWAN status:
Dev EUI AC1F09FFFE0142C8
App EUI 70B3D57ED00201E1
App Key 2B84E0B09B68E5CB42176FE753DCEE79
Dev Addr 26021FB4
NWS Key 323D155A000DF335307A16DA0C9DF53F
Apps Key 3F6A66459D5EDCA63CBC4619CD61A11E
OTAA enabled
ADR disabled
Public Network
Dutycycle disabled
Join trials 30
TX Power 0
DR 3
Class 0
Subband 1
Fport 2
Unconfirmed Message
Region AS923-3
LoRa P2P status:
P2P frequency 916000000
P2P TX Power 22
P2P BW 125
P2P SF 7
P2P CR 1
P2P Preamble length 8
P2P Symbol Timeout 0 void api_timer_stop(void)
Arrête la minuterie qui réveille fréquemment le MCU.
void api_timer_restart(uint32_t new_time)
Redémarrez la minuterie avec une nouvelle valeur. La valeur est en millisecondes
void api_read_credentials(void);
void api_set_credentials(void); Si les paramètres LORA P2P doivent être codés en dur (par exemple la fréquence, la bande passante, ...), cela peut être fait dans setup_app() . D'abord, les paramètres enregistrés doivent être lus à partir de Flash avec api_read_credentials(); , alors les paramètres peuvent être modifiés. Après modification, les paramètres doivent être enregistrés avec api_set_credentials() . Comme l'API WISBLOCK vérifie si des modifications doivent être enregistrées, les valeurs modifiées ne seront enregistrées que sur le premier démarrage après avoir clignoté l'application.
Exemple:
// Read credentials from Flash
api_read_credentials ();
// Make changes to the credentials
g_lorawan_settings.p2p_frequency = 916000000 ; // Use 916 MHz to send and receive
g_lorawan_settings.p2p_bandwidth = 0 ; // Bandwidth 125 kHz
g_lorawan_settings.p2p_sf = 7 ; // Spreading Factor 7
g_lorawan_settings.p2p_cr = 1 ; // Coding Rate 4/5
g_lorawan_settings.p2p_preamble_len = 8 ; // Preample Length 8
g_lorawan_settings.p2p_tx_power = 22 ; // TX power 22 dBi
// Save hard coded LoRaWAN settings
api_set_credentials (); Remarque 1
Les paramètres codés en dur doivent être définis dans void setup_app(void) !
Remarque 2
Gardez à l'esprit que les paramètres qui sont modifiés avec cette méthode peuvent être modifiés sur commande ou BLE mais seront réinitialisés après un redémarrage !
api_ble_printf() peut être utilisé pour envoyer des données sur le BLE UART. print , println et printf est pris en charge.
REMARQUE
Cette commande n'est pas disponible sur le RAK11310!
Par défaut, la publicité BLE n'est active que pendant 30 secondes après la mise sous tension / réinitialisation pour réduire la consommation d'énergie. En appelant void restart_advertising(uint16_t timeout); La publicité peut être redémarrée pour les secondes timeout .
REMARQUE
Cette commande n'est pas disponible sur le RAK11310!
lmh_error_status send_lora_packet(uint8_t *data, uint8_t size, uint8_t fport = 0); est utilisé pour envoyer un paquet de données au serveur Lorawan. *data sont un pointeur vers le tampon contenant les données, size est la taille du paquet. Si le FPORT est 0, la structure FPTORDDEFINE dans la structure G_lorawan_Settings est utilisée.
bool send_p2p_packet(uint8_t *data, uint8_t size); est utilisé pour envoyer un paquet de données sur LORA P2P. *data sont un pointeur vers le tampon contenant les données, size est la taille du paquet.
Une fois le cycle TX (y compris les fenêtres RX1 et RX2), le résultat est maintenu dans l'indicateur global g_rx_fin_result , l'événement LORA_TX_FIN est déclenché et le rappel lora_data_handler() est appelé. Dans ce rappel, le résultat peut être vérifié et les mesures nécessaires peuvent être prises.
Cayennelpp est un format conçu par MyDevices pour intégrer les nœuds Lorawan dans leur plate-forme IoT.
La bibliothèque de Cayennelpp étend les types de données disponibles avec plusieurs types de données IPSO non inclus dans l'œuvre originale de Johan Stokking ou de la plupart des fourchettes et des travaux latéraux par d'autres personnes, ces types de données supplémentaires ne sont pas pris en charge par Mydevices Cayenne.
L'API WISBLOCK utilise quelques types de données supplémentaires qui étendent les types de données d'origine et ElectronicCats pour mieux prendre en charge la large gamme des modules de capteur Wisblock.
Pour utiliser les types de données étendus, l'API WISBLOCK inclut déjà le fichier d'en-tête requis.
Pour pouvoir utiliser les fonctions LPP Cayenne, une instance de la classe est requise.
/* * LoRaWAN packet */
WisCayenne g_solution_data ( 255 );Avant d'ajouter des données, le tampon de paquets doit être réinitialisé
// Reset the packet
g_solution_data.reset();La bibliothèque Cayennelpp possède des appels d'API pour les différents types de données pris en charge. Voir l'API Cayennelpp pour plus de détails. En plus de ces appels API, l'API Wisblock leur ajoute 5 autres appels. Ces appels API sont destinés à différents formats GNSS et aux données du capteur de COV:
uint8_t addGNSS_4 ( uint8_t channel, int32_t latitude, int32_t longitude, int32_t altitude);
uint8_t addGNSS_6 ( uint8_t channel, int32_t latitude, int32_t longitude, int32_t altitude);
uint8_t addGNSS_H ( int32_t latitude, int32_t longitude, int16_t altitude, int16_t accuracy, int16_t battery);
uint8_t addGNSS_T ( int32_t latitude, int32_t longitude, int16_t altitude, float accuracy, int8_t sats);
uint8_t addVoc_index ( uint8_t channel, uint32_t voc_index); /* *
* @brief Add GNSS data in Cayenne LPP standard format
*
* @param channel LPP channel
* @param latitude Latitude as read from the GNSS receiver
* @param longitude Longitude as read from the GNSS receiver
* @param altitude Altitude as read from the GNSS receiver
* @return uint8_t bytes added to the data packet
*/
uint8_t WisCayenne::addGNSS_4 ( uint8_t channel, int32_t latitude, int32_t longitude, int32_t altitude) /* *
* @brief Add GNSS data in custom Cayenne LPP format
* Requires changed decoder in LNS and visualization
* Does not work with Cayenne LPP MyDevices
*
* @param channel LPP channel
* @param latitude Latitude as read from the GNSS receiver
* @param longitude Longitude as read from the GNSS receiver
* @param altitude Altitude as read from the GNSS receiver
* @return uint8_t bytes added to the data packet
*/
uint8_t WisCayenne::addGNSS_6 ( uint8_t channel, int32_t latitude, int32_t longitude, int32_t altitude) /* *
* @brief Add GNSS data in Helium Mapper format
*
* @param channel LPP channel
* @param latitude Latitude as read from the GNSS receiver
* @param longitude Longitude as read from the GNSS receiver
* @param altitude Altitude as read from the GNSS receiver
* @param accuracy Accuracy of reading from the GNSS receiver
* @param battery Device battery voltage in V
* @return uint8_t bytes added to the data packet
*/
uint8_t WisCayenne::addGNSS_H ( int32_t latitude, int32_t longitude, int16_t altitude, int16_t accuracy, int16_t battery) /* *
* @brief Add GNSS data in Field Tester format
*
* @param latitude Latitude as read from the GNSS receiver
* @param longitude Longitude as read from the GNSS receiver
* @param altitude Altitude as read from the GNSS receiver
* @param accuracy Accuracy of reading from the GNSS receiver
* @param sats Number of satellites of reading from the GNSS receiver
* @return uint8_t bytes added to the data packet
*/
uint8_t WisCayenne::addGNSS_T ( int32_t latitude, int32_t longitude, int16_t altitude, float accuracy, int8_t sats) /* *
* @brief Add the VOC index
*
* @param channel VOC channel
* @param voc_index VOC index
* @return uint8_t bytes added to the data packet
*/
uint8_t WisCayenne::addVoc_index ( uint8_t channel, uint32_t voc_index) Les paquets de données Cayennelpp sont toujours au format <Channel #><Channel ID><data bytes> .
Pour faciliter les encodeurs de données utilisés dans les serveurs Lorawan et les données d'intégration collectées par les capteurs WISBLOCK ont toujours le même numéro de canal (si ces API sont utilisées). Voici la liste des numéros de canal actuellement attribués, des ID de canal et des modules utilisent la combinaison.
| Données | Canal # | ID de canal | Longueur | Commentaire | Module requis | Nom de champ décodé |
|---|---|---|---|---|---|---|
| Valeur de la batterie | 1 | 116 | 2 octets | 0,01 V MSB non signé | RAK4631 | tension_1 |
| Humidité | 2 | 104 | 1 octet | en% rh | RAK1901 | humidité_2 |
| Température | 3 | 103 | 2 octets | en ° C | RAK1901 | Température_3 |
| Pression barométrique | 4 | 115 | 2 octets | Dans HPA (MBAR) | RAK1902 | baromètre_4 |
| Éclairage | 5 | 101 | 2 octets | 1 lux non signé | RAK1903 | Illuminance_5 |
| Humidité 2 | 6 | 104 | 1 octet | en% rh | RAK1906 | humidité_6 |
| Température 2 | 7 | 103 | 2 octets | en ° C | RAK1906 | Température_7 |
| Pression barométrique 2 | 8 | 115 | 2 octets | Dans HPA (MBAR) | RAK1906 | baromètre_8 |
| Résistance au gaz 2 | 9 | 2 | 2 octets | 0,01 signé (KOHM) | RAK1906 | analog_9 |
| GNSS se tient. résolution | 10 | 136 | 9 octets | 3 octets lon / lat 0,0001 °, 3 octets alt 0,01 mètre | RAK1910, RAK12500 | GPS_10 |
| Résolution améliorée GNSS | 10 | 137 | 11 octets | 4 octets lon / lat 0,000001 °, 3 octets alt 0,01 mètre | RAK1910, RAK12500 | GPS_10 |
| Température du sol | 11 | 103 | 2 octets | en ° C | RAK12023 / RAK12035 | Température_11 |
| Humidité du sol | 12 | 104 | 1 octet | en% rh | RAK12023 / RAK12035 | humidité_12 |
| Humidité du sol cru | 13 | 2 | 2 octets | 0,01 signé | RAK12023 / RAK12035 | analog_in_13 |
| Données du sol valides | 14 | 102 | 1 octet | bool | RAK12023 / RAK12035 | présence_14 |
| Illuminance 2 | 15 | 101 | 2 octets | 1 lux non signé | RAK12010 | Illuminance_15 |
| Voc | 16 | 138 | 2 octets | Index de COV | RAK12047 | voc_16 |
| Gaz MQ2 | 17 | 2 | 2 octets | 0,01 signé | RAK12004 | analog_in_17 |
| Pourcentage de gaz MQ2 | 18 | 120 | 1 octet | 1-100% non signé | RAK12004 | pourcentage_18 |
| Gaz MG812 | 19 | 2 | 2 octets | 0,01 signé | RAK12008 | analog_in_19 |
| Pourcentage de gaz MG812 | 20 | 120 | 1 octet | 1-100% non signé | RAK12008 | pourcentage_20 |
| MQ3 Gas d'alcool | 21 | 2 | 2 octets | 0,01 signé | RAK12009 | analog_in_21 |
| MQ3 Perc de gaz d'alcool. | 22 | 120 | 1 octet | 1-100% non signé | RAK12009 | pourcentage_22 |
| Distance TOF | 23 | 2 | 2 octets | 0,01 signé | RAK12014 | analog_in_23 |
| Données TOF valides | 24 | 102 | 1 octet | bool | RAK12014 | présence_24 |
| Gyro déclenché | 25 | 134 | 6 octets | 2 octets par axe, 0,01 ° / s | RAK12025 | gyromètre_25 |
| Geste détecté | 26 | 0 | 1 octet | 1 octet avec ID de geste | RAK14008 | Digital_in_26 |
| Valeur UVI LTR390 | 27 | 2 | 2 octets | 0,01 signé | RAK12019 | analog_in_27 |
| Valeur UVS LTR390 | 28 | 101 | 2 octets | 1 lux non signé | RAK12019 | Illuminance_28 |
| Courant INA219 | 29 | 2 | 2 octets | 0,01 signé | RAK16000 | analog_29 |
| Tension ina219 | 30 | 2 | 2 octets | 0,01 signé | RAK16000 | analog_30 |
| Puissance ina219 | 31 | 2 | 2 octets | 0,01 signé | RAK16000 | analog_31 |
| Pavé tactile à gauche | 32 | 102 | 1 octet | bool | RAK14002 | présence_32 |
| Pavé tactile | 33 | 102 | 1 octet | bool | RAK14002 | présence_33 |
| Pavé tactile à droite | 34 | 102 | 1 octet | bool | RAK14002 | présence_34 |
| Concentration SCD30 CO2 | 35 | 125 | 2 octets | 1 ppm non signé | RAK12037 | concentration_35 |
| Température SCD30 | 36 | 103 | 2 octets | en ° C | RAK12037 | Température_36 |
| Humidité SCD30 | 37 | 104 | 1 octet | en% rh | RAK12037 | humidité_37 |
| Mlx90632 Tempor de capteur | 38 | 103 | 2 octets | en ° C | RAK12003 | Température_38 |
| Mlx90632 | 39 | 103 | 2 octets | en ° C | RAK12003 | Température_39 |
| Valeur PM 1.0 | 40 | 103 | 2 octets | dans UG / M3 | RAK12003 | voc_40 |
| Valeur PM 2.5 | 41 | 103 | 2 octets | dans UG / M3 | RAK12003 | voc_41 |
| Valeur PM 10 | 42 | 103 | 2 octets | dans UG / M3 | RAK12003 | voc_42 |
| Événement de tremblement de terre | 43 | 102 | 1 octet | bool | RAK12027 | présence_43 |
| Valeur SI tremblement de terre | 44 | 2 | 2 octets | analogique 10 * m / s | RAK12027 | analog_44 |
| Valeur PGA du tremblement de terre | 45 | 2 | 2 octets | analogique 10 * m / s2 | RAK12027 | analog_45 |
| Alerte d'arrêt du tremblement de terre | 46 | 102 | 1 octet | bool | RAK12027 | présence_46 |
| Lpp_channel_eq_collapse | 47 | 102 | 1 octet | bool | RAK12027 | présence_47 |
| Statut de commutateur | 48 | 102 | 1 octet | bool | RAK13011 | présence_48 |
Les ID de canal en cursive sont un format étendu et non pris en charge par des décodeurs de données LPP Cayenne standard.
Une liste complète et mise à jour des formats de données utilisés peut être trouvée dans notre Rakwireless_standardisé_payload
Le repo rakwireless_standardized_payload comprend ainsi un décodeur assorti.
Le code utilisé ici est l'exemple api-test.ino.
Ce sont les incluses et les définitions requises de l'application utilisateur et de l'interface API
Dans cet exemple, nous avons codé en dur les références Lorawan. Il est fortement recommandé de ne pas le faire pour éviter les informations d'identification du nœud dupliqué
Les options alternatives à la configuration des informations d'identification sont
# include < Arduino.h >
/* * Add you required includes after Arduino.h */
# include < Wire.h >
// Debug output set to 0 to disable app debug output
# ifndef MY_DEBUG
# define MY_DEBUG 1
# endif
# ifdef NRF52_SERIES
# if MY_DEBUG > 0
# define MYLOG (tag, ...)
do
{
if (tag)
PRINTF ( " [%s] " , tag);
PRINTF (__VA_ARGS__);
PRINTF ( " n " );
if (g_ble_uart_is_connected)
{
g_ble_uart. printf (__VA_ARGS__);
g_ble_uart. printf ( " n " );
}
} while ( 0 )
# else
# define MYLOG (...)
# endif
# endif
# ifdef ARDUINO_ARCH_RP2040
# if MY_DEBUG > 0
# define MYLOG (tag, ...)
do
{
if (tag)
Serial. printf ( " [%s] " , tag);
Serial. printf (__VA_ARGS__);
Serial. printf ( " n " );
} while ( 0 )
# else
# define MYLOG (...)
# endif
# endif
/* * Include the WisBlock-API-V2 */
# include < WisBlock-API-V2.h > // Click to install library: http://librarymanager/All#WisBlock-API-V2
/* * Define the version of your SW */
# define SW_VERSION_1 1 // major version increase on API change / not backwards compatible
# define SW_VERSION_2 0 // minor version increase on API change / backward compatible
# define SW_VERSION_3 0 // patch version increase on bugfix, no affect on API
/* *
Optional hard-coded LoRaWAN credentials for OTAA and ABP.
It is strongly recommended to avoid duplicated node credentials
Options to setup credentials are
- over USB with AT commands
- over BLE with My nRF52 Toolbox
*/
uint8_t node_device_eui[ 8 ] = { 0x00 , 0x0D , 0x75 , 0xE6 , 0x56 , 0x4D , 0xC1 , 0xF3 };
uint8_t node_app_eui[ 8 ] = { 0x70 , 0xB3 , 0xD5 , 0x7E , 0xD0 , 0x02 , 0x01 , 0xE1 };
uint8_t node_app_key[ 16 ] = { 0x2B , 0x84 , 0xE0 , 0xB0 , 0x9B , 0x68 , 0xE5 , 0xCB , 0x42 , 0x17 , 0x6F , 0xE7 , 0x53 , 0xDC , 0xEE , 0x79 };
uint8_t node_nws_key[ 16 ] = { 0x32 , 0x3D , 0x15 , 0x5A , 0x00 , 0x0D , 0xF3 , 0x35 , 0x30 , 0x7A , 0x16 , 0xDA , 0x0C , 0x9D , 0xF5 , 0x3F };
uint8_t node_apps_key[ 16 ] = { 0x3F , 0x6A , 0x66 , 0x45 , 0x9D , 0x5E , 0xDC , 0xA6 , 0x3C , 0xBC , 0x46 , 0x19 , 0xCD , 0x61 , 0xA1 , 0x1E };Déclaration de certaines fonctions (requise lors de l'utilisation de la plate-forme)
/* * Application function definitions */
void setup_app ( void );
bool init_app ( void );
void app_event_handler ( void );
void ble_data_handler ( void ) __attribute__((weak));
void lora_data_handler ( void );Ici, le nom de l'application est défini sur RAK-Test . Le nom sera étendu avec l'ID de puce unique NRF52. Ce nom est utilisé dans la publicité BLE.
/* * Application stuff */
/* * Set the device name, max length is 10 characters */
char g_ble_dev_name[ 10 ] = " RAK-TEST " ;Certains drapeaux et signaux requis
/* * Flag showing if TX cycle is ongoing */
bool lora_busy = false ;
/* * Send Fail counter * */
uint8_t send_fail = 0 ; Cette fonction est appelée au tout début du démarrage de l'application. Dans cette fonction, tout doit être configuré qui est requis avant que setup() ne soit exécutée. Cela pourrait être par exemple les informations d'identification de Lorawan. Dans cet exemple, nous avons codé en dur les références Lorawan. Il est fortement recommandé de ne pas le faire pour éviter les informations d'identification du nœud dupliqué
Les options alternatives à la configuration des informations d'identification sont
g_enable_ble est défini. Si c'est vrai, l'interface BLE est initialisée. En cas de faux, l'interface BLE n'est pas activée, ce qui peut réduire la consommation d'énergie. void setup_app ( void )
{
Serial. begin ( 115200 );
time_t serial_timeout = millis ();
// On nRF52840 the USB serial is not available immediately
while (!Serial)
{
if (( millis () - serial_timeout) < 5000 )
{
delay ( 100 );
digitalWrite (LED_GREEN, ! digitalRead (LED_GREEN));
}
else
{
break ;
}
}
digitalWrite (LED_GREEN, LOW);
MYLOG ( " APP " , " Setup WisBlock API Example " );
# ifdef NRF52_SERIES
// Enable BLE
g_enable_ble = true ;
# endif
// Set firmware version
api_set_version (SW_VERSION_1, SW_VERSION_2, SW_VERSION_3);
// Optional
// Setup LoRaWAN credentials hard coded
// It is strongly recommended to avoid duplicated node credentials
// Options to setup credentials are
// -over USB with AT commands
// -over BLE with My nRF52 Toolbox
// Read LoRaWAN settings from flash
api_read_credentials ();
// Change LoRaWAN settings
g_lorawan_settings. auto_join = true ; // Flag if node joins automatically after reboot
g_lorawan_settings. otaa_enabled = true ; // Flag for OTAA or ABP
memcpy (g_lorawan_settings. node_device_eui , node_device_eui, 8 ); // OTAA Device EUI MSB
memcpy (g_lorawan_settings. node_app_eui , node_app_eui, 8 ); // OTAA Application EUI MSB
memcpy (g_lorawan_settings. node_app_key , node_app_key, 16 ); // OTAA Application Key MSB
memcpy (g_lorawan_settings. node_nws_key , node_nws_key, 16 ); // ABP Network Session Key MSB
memcpy (g_lorawan_settings. node_apps_key , node_apps_key, 16 ); // ABP Application Session key MSB
g_lorawan_settings. node_dev_addr = 0x26021FB4 ; // ABP Device Address MSB
g_lorawan_settings. send_repeat_time = 120000 ; // Send repeat time in milliseconds: 2 * 60 * 1000 => 2 minutes
g_lorawan_settings. adr_enabled = false ; // Flag for ADR on or off
g_lorawan_settings. public_network = true ; // Flag for public or private network
g_lorawan_settings. duty_cycle_enabled = false ; // Flag to enable duty cycle (validity depends on Region)
g_lorawan_settings. join_trials = 5 ; // Number of join retries
g_lorawan_settings. tx_power = 0 ; // TX power 0 .. 15 (validity depends on Region)
g_lorawan_settings. data_rate = 3 ; // Data rate 0 .. 15 (validity depends on Region)
g_lorawan_settings. lora_class = 0 ; // LoRaWAN class 0: A, 2: C, 1: B is not supported
g_lorawan_settings. subband_channels = 1 ; // Subband channel selection 1 .. 9
g_lorawan_settings. app_port = 2 ; // Data port to send data
g_lorawan_settings. confirmed_msg_enabled = LMH_UNCONFIRMED_MSG; // Flag to enable confirmed messages
g_lorawan_settings. resetRequest = true ; // Command from BLE to reset device
g_lorawan_settings. lora_region = LORAMAC_REGION_AS923_3; // LoRa region
// Save LoRaWAN settings
api_set_credentials ();Cette fonction est appelée après BLE et Lora déjà initialisées. Idéalement, c'est l'endroit pour initialiser des trucs spécifiques aux applications comme les capteurs ou les actionneurs. Dans cet exemple, il n'est pas utilisé
/* *
* @brief Application specific initializations
*
* @return true Initialization success
* @return false Initialization failure
*/
bool init_app ( void )
{
MYLOG ( " APP " , " init_app " );
return true ;
} Ce rappel est appelé sur l'événement de statut . L'événement d'état est déclenché fréquemment, l'heure est définie par send_repeat_time . Il est également déclenché par des événements définis par l'utilisateur. Voir l'exemple RAK1904_Example _ Comment les événements définis par l'utilisateur sont définis. _ Il est important que les drapeaux d'événement soient réinitialisés. À titre d'exemple, l'événement d'état est réinitialisé par cette séquence de code:
if ((g_task_event_type & STATUS) == STATUS)
{
g_task_event_type &= N_STATUS;
...
} L'événement d'état est utilisé pour envoyer des paquets fréquemment en liaison montante au serveur Lorawan.
Dans cet exemple de code, nous redémarrons également la publicité BLE pendant 15 secondes. Sinon, BLE Adverstisting n'est actif que pendant 30 secondes après la mise sous tension / réinitialisation.
void app_event_handler ( void )
{
// Timer triggered event
if ((g_task_event_type & STATUS) == STATUS)
{
g_task_event_type &= N_STATUS;
MYLOG ( " APP " , " Timer wakeup " );
# ifdef NRF52_SERIES
// If BLE is enabled, restart Advertising
if (g_enable_ble)
{
restart_advertising ( 15 );
}
# endif
if (lora_busy)
{
MYLOG ( " APP " , " LoRaWAN TX cycle not finished, skip this event " );
}
else
{
// Dummy packet
uint8_t dummy_packet[] = { 0x10 , 0x00 , 0x00 };
lmh_error_status result = send_lora_packet (dummy_packet, 3 );
switch (result)
{
case LMH_SUCCESS:
MYLOG ( " APP " , " Packet enqueued " );
// Set a flag that TX cycle is running
lora_busy = true ;
break ;
case LMH_BUSY:
MYLOG ( " APP " , " LoRa transceiver is busy " );
break ;
case LMH_ERROR:
MYLOG ( " APP " , " Packet error, too big to send with current DR " );
break ;
}
}
}
} Ce rappel est utilisé pour gérer les données reçues sur le BLE UART. Si vous n'avez pas besoin de fonctionnalité BLE UART, vous pouvez supprimer complètement cette fonction. Dans cet exemple, nous transférons les données UART BLE reçues à l'interprète de commande AT. De cette façon, nous pouvons nous soumettre aux commandes sur le port USB ou sur le port UART BLE.
La communication BLE n'est soutenue que sur le RAK4631. Le RAK11310 n'a pas BLE.
# ifdef NRF52_SERIES
void ble_data_handler ( void )
{
if (g_enable_ble)
{
/* ************************************************************ */
/* ************************************************************ */
// / todo BLE UART data arrived
// / todo or forward them to the AT command interpreter
// / todo parse them here
/* ************************************************************ */
/* ************************************************************ */
if ((g_task_event_type & BLE_DATA) == BLE_DATA)
{
MYLOG ( " AT " , " RECEIVED BLE " );
// BLE UART data arrived
// in this example we forward it to the AT command interpreter
g_task_event_type &= N_BLE_DATA;
while (g_ble_uart. available () > 0 )
{
at_serial_input ( uint8_t (g_ble_uart. read ()));
delay ( 5 );
}
at_serial_input ( uint8_t ( ' n ' ));
}
}
}
# endif Ce rappel est appelé sur trois événements différents:
L'événement LORA_DATA est déclenché si un paquet de liaison descendante du serveur Lorawan ou d'un paquet LORA P2P est arrivé. Dans cet exemple, nous n'analysons pas les données, elles ne sont imprimées que dans le journal et sur BLE UART (si un appareil est connecté)
L'événement LORA_TX_FIN est déclenché après l'envoi d'un paquet de liaison montante, y compris les fenêtres RX1 et RX2. Si des paquets confirmés sont envoyés, l'indicateur global g_rx_fin_result contient le résultat de la transmission confirmée. Si g_rx_fin_result est vrai, le serveur Lorawan a reconnu le paquet de liaison montante en envoyant un ACK . Sinon, le g_rx_fin_result est défini sur False, indiquant que le paquet n'a pas été reçu par le serveur Lorawan (aucune passerelle dans la plage, le paquet a été endommagé dans l'air. Si les paquets non confirmés sont envoyés ou si le mode Lora P2P est utilisé, le drapeau g_rx_fin_result est toujours vrai.
L'événement lora_join_fin est appelé une fois le cycle de demande / jointure d'acceptation / rejet. L'indicateur global g_task_event_type contient le résultat de la demande de jointure. Si c'est vrai, le nœud a rejoint le réseau. Si faux, la jointure n'a pas réussi. Dans ce cas, le cycle de jointure peut être redémarré ou le nœud pourrait signaler une erreur.
void lora_data_handler ( void )
{
// LoRa data handling
if ((g_task_event_type & LORA_DATA) == LORA_DATA)
{
/* ************************************************************ */
/* ************************************************************ */
// / todo LoRa data arrived
// / todo parse them here
/* ************************************************************ */
/* ************************************************************ */
g_task_event_type &= N_LORA_DATA;
MYLOG ( " APP " , " Received package over LoRa " );
char log_buff[g_rx_data_len * 3 ] = { 0 };
uint8_t log_idx = 0 ;
for ( int idx = 0 ; idx < g_rx_data_len; idx++)
{
sprintf (&log_buff[log_idx], " %02X " , g_rx_lora_data[idx]);
log_idx += 3 ;
}
lora_busy = false ;
MYLOG ( " APP " , " %s " , log_buff);
}
// LoRa TX finished handling
if ((g_task_event_type & LORA_TX_FIN) == LORA_TX_FIN)
{
g_task_event_type &= N_LORA_TX_FIN;
MYLOG ( " APP " , " LPWAN TX cycle %s " , g_rx_fin_result ? " finished ACK " : " failed NAK " );
if (!g_rx_fin_result)
{
// Increase fail send counter
send_fail++;
if (send_fail == 10 )
{
// Too many failed sendings, reset node and try to rejoin
delay ( 100 );
sd_nvic_SystemReset ();
}
}
// Clear the LoRa TX flag
lora_busy = false ;
}
// LoRa Join finished handling
if ((g_task_event_type & LORA_JOIN_FIN) == LORA_JOIN_FIN)
{
g_task_event_type &= N_LORA_JOIN_FIN;
if (g_join_result)
{
MYLOG ( " APP " , " Successfully joined network " );
}
else
{
MYLOG ( " APP " , " Join network failed " );
// / todo here join could be restarted.
// lmh_join();
}
}
} Dans Arduino, il n'est pas possible de définir des paramètres dans le fichier .ino qui peuvent contrôler le comportement des bibliothèques incluses. Pour modifier le journal de débogage et l'utilisation de la LED bleue BLE, vous devez ouvrir le fichier WisBlock-API-V2.h dans le dossier Source Libraries.
Pour activer / désactiver le débogage de l'API ( API_LOG() ), ouvrez le fichier WisBlock-API-V2.h dans le dossier source des bibliothèques.
Rechercher
# define API_DEBUG 1dans le fichier.
0 -> No debug output
1 -> API debug output
Pour activer / désactiver le débogage de l'application ( MY_LOG() ), vous pouvez trouver dans les exemples (dans le fichier .ino ou app.h)
# define MY_DEBUG 1dans le fichier.
0 -> No debug output
1 -> Application debug output
Rechercher
# define NO_BLE_LED 1 dans le fichier WisBlock-API-V2
0 -> the blue LED will be used to indicate BLE status
1 -> the blue LED will not used
REMARQUE
RAK11310 n'a pas de BLE et la LED bleue peut être utilisée à d'autres fins.
La sortie de débogage peut être contrôlée par définir dans la plate-forme de plateforme.ini API_DEBUG Contrôles Debug Sortie de l'API Wisblock
0 -> No debug outpuy
1 -> WisBlock API debug output
MY_DEBUG contrôle la sortie de débogage de l'application elle-même
0 -> No debug outpuy
1 -> Application debug output
NO_BLE_LED contrôle l'utilisation de la LED bleue BLE.
0 -> the blue LED will be used to indicate BLE status
1 -> the blue LED will not used
Exemple pour aucune sortie de débogage et aucune LED bleue
build_flags =
- DAPI_DEBUG =0 ; 0 Disable WisBlock API debug output
- DMY_DEBUG =0 ; 0 Disable application debug output
- DNO_BLE_LED =1 ; 1 Disable blue LED as BLE notificatorBibliothèque publiée sous licence MIT
Crédits:
Aux fonctions de commande: Taylor Lee ([email protected])
Code des versions
api_read_credentials()api_set_credentials() enregistre pour flashWisBlock API LoRaWAN au lieu de GNSS
