- Kit de développement nRF52:
- Studio intégré Segger
- DHT11 avec nRF52DK
- Comment travailler avec Bluetooth Low Energy (BLE)?
- Schéma de service / caractéristiques BLE
- Explication du programme nRF52 BLE
- Tester notre programme à l'aide de nRF Connect
Avec les bandes de fitness, les montres intelligentes et autres appareils portables de plus en plus populaires, l'utilisation de Bluetooth 5 / Bluetooth Low Energyles normes de communication sont largement adoptées. BLE nous aide à échanger des données sur une courte distance avec très peu d'énergie, ce qui est très crucial pour les appareils fonctionnant sur batterie comme les appareils portables. Cela nous aide également à configurer des réseaux maillés BLE sans fil, cette fonctionnalité est pratique pour les appareils domotiques où plusieurs appareils doivent communiquer entre eux dans un environnement fermé. Nous avons déjà utilisé BLE avec Raspberry Pi et BLE avec ESP32 pour exécuter certaines fonctions BLE de base. Les ingénieurs expérimentent le BLE pour concevoir des appareils sans fil portables qui peuvent fonctionner pendant longtemps avec de petites batteries et plusieurs kits de développement sont disponibles pour fonctionner avec BLE. Dans notre récente revue sur Arduino Nano 33, nous avons également remarqué que la carte avait nRF52840 avec des capacités BLE.
Dans ce didacticiel, nous explorerons une autre carte de développement passionnante et populaire appelée nRF52 DK pour mesurer la température et l'humidité à l'aide de BLE. Par défaut, les profils de détection d'environnement BLE prennent en charge un large éventail de paramètres environnementaux, mais ce didacticiel se limite uniquement aux valeurs de température et d'humidité. Cette solution se connecte à un Smartphone via Bluetooth basse consommation et fournit une mise à jour fréquente concernant les paramètres environnementaux à savoir la température, l'humidité. Nous utiliserons le capteur DHT1 et la mesure de la température sera effectuée avec une résolution de 0,01 degré Celsius et la mesure de l'humidité sera effectuée avec une résolution de 0,01%.
Kit de développement nRF52:
nRF52DK est une plate-forme de prototypage complète pour l'application Bluetooth Low Energy et Internet des objets sans fil 2,4 GHz. Le kit de développement prend en charge diverses chaînes d'outils nordiques standard telles que les environnements de développement intégrés open-source, GCC et commerciaux tels que Keil, IAR et Segger Embedded Studio, etc.
Le nRF52DK est alimenté par le microcontrôleur ARM Cortex-M4F nRF52832, qui est intégré 512 Ko de mémoire Flash et 64 Ko de SRAM. Le nRF52DK dispose d'un débogueur Segger J-Link On Board intégré, qui permet un débogage plus facile et plus rapide sans périphériques de débogage jtag externes / supplémentaires. Il comprend également le connecteur compatible Arduino Uno Rev3, qui prend en charge l'interfaçage des entrées analogiques et numériques avec le microprocesseur et comprend également des protocoles de communication standard tels que I2C (Circuit Inter-Integrated), SPI (Serial Peripheral Interface) et UART (Universal Asynchronous Receiver and Transmitter). Ce kit de développement est conçu avec une antenne PCB intégrée qui fournit une communication sans fil à courte portée à l'aide de Bluetooth Low Energy pour la connexion avec un téléphone intelligent, des ordinateurs portables et des tablettes.
Studio intégré Segger
Pour programmer la carte de développement, nous utiliserons le Segger Embedded Studio avec nRF52. Segger Embedded Studio est un puissant environnement de développement intégré (IDE) C / C ++ spécialement conçu pour le développement de systèmes embarqués. Cela fournit une solution tout-en-un complète contenant tout le nécessaire pour la programmation, le développement et le débogage C embarqués. Cela inclut un flux de travail complet pour la programmation et le développement de systèmes embarqués, avec gestion de projet, éditeur, débogueur prenant en charge les appareils ARM Cortex. Cet IDE puissant et facile à utiliser est entièrement gratuit pour les clients nordiques avec une licence complète sans aucune restriction de taille de code. L'IDE peut être téléchargé à partir du lien ci-dessous,
Télécharger Segger Embedded Studio
DHT11 avec nRF52DK
Le DHT11 est un capteur de température et d'humidité complet avec un composant de mesure d'humidité de type résistif et un composant de mesure de température de type NTC. Il offre une excellente qualité, une réponse plus rapide et une rentabilité. Par défaut, tous les capteurs DHT11 sont étalonnés en laboratoire, ce qui conduit à une précision et une fiabilité extrêmes. Il communique en utilisant le système d'interface série à un seul fil et d'autres spécifications sont données ci-dessous
Spécifications de DHT11:
- Plage d'humidité: 20-90% HR
- Plage de température: 0 à 50 degrés Celsius
- Précision d'humidité: ± 5 ％ RH
- Précision de la température: ± 2 ℃
Diagramme de synchronisation du DHT11:
La lecture des données du capteur DHT11 est relativement simple en utilisant le chronogramme illustré ci-dessus. La procédure est similaire à n'importe quel contrôleur et nous avons déjà utilisé ce capteur avec d'autres plates-formes de développement comme
- Capteur DHT11 avec Raspberry Pi
- Capteur DHT11 avec PIC16F877A
- Capteur DHT11 avec STM32F103C8
- Capteur DHT11 avec NodeMCU
Pour interfacer le capteur de température et d'humidité DHT11 avec le kit de développement nRF52, suivez le schéma de connexion ci-dessous.
J'utilise un module de connecteur pour connecter le capteur à ma carte, donc ma configuration finale ressemble à ceci
Organigramme de communication avec DHT11:
L'organigramme ci-dessous explique le flux logique du programme que nous utiliserons pour communiquer entre nRF52DK et DHT11
Format des données:
Comment travailler avec Bluetooth Low Energy (BLE)?
Afin de comprendre comment utiliser la fonctionnalité BLE, nous devons comprendre quelques terminologies de base qui sont expliquées ci-dessous, vous pouvez également lire l'article ESP32 BLE pour en savoir plus sur BLE
Profil d'accès générique (GAP)
Generic Access Profile assume l'entière responsabilité d'établir la connexion pour la communication entre le périphérique BLE et les appareils centraux. GAP fournit également diverses procédures, y compris l'analyse / découverte des périphériques, l'établissement de la connexion de la couche liaison, la terminaison de la liaison, la négociation des fonctions de sécurité et la configuration complète des périphériques. GAP fonctionne dans les états de périphérique suivants
|
États GAP |
La description |
|
Etre prêt |
État initial de l'appareil lors de la réinitialisation |
|
Annonceur |
Publicité de l'appareil avec des données facilitant l'analyse des initiateurs |
|
Scanner |
Reçoit et envoie la demande de scan à l'annonceur |
|
Initiateur |
Envoie une demande de connexion pour établir un lien |
|
Esclave / Maître |
A la connexion, appareil comme esclave si annonceur, maître si initiateur |
Couche de profil d'attribut générique (GATT)
GATT est l'abréviation de Generic Attribute Profile Layer, il est responsable de la communication de données entre deux périphériques BLE (périphérique et central). La communication de données est caractérisée sous la forme de caractéristiques, qui communiquent et stockent les données. L'appareil BLE joue deux rôles différents pour la communication de l'appareil ci-dessous,
- GATT Server contient les informations sur les caractéristiques qui seront utilisées pour la lecture et l'écriture. Dans notre tutoriel, le capteur DHT11 et le dev. le kit est notre serveur GATT.
- Le client GATT lit et écrit les données depuis / vers le serveur GATT. Le smartphone est un client GATT qui lit et écrit les données dans notre carte de capteur.
Bluetooth SIG
Bluetooth Special Interest Group (SIG) est l'organisation de normalisation qui surveille le développement des normes Bluetooth et l'octroi de licences pour les technologies Bluetooth. Le groupe SIG ne produit ni ne vend aucun produit Bluetooth. Il définit la spécification et la normalisation Bluetooth. Ils définissent l' identifiant unique du profil basse énergie Bluetooth et ses caractéristiques respectives. Les spécifications du profil GATT sont disponibles sur le lien ci-dessous
Spécifications du profil GATT
Sur la base des spécifications du GATT fournies dans le lien ci-dessus, nous avons rassemblé les identifiants uniques requis pour notre projet, qui sont présentés ci-dessous.
|
Profil / Caractéristiques |
UUID |
|
GAP (accès générique) |
0x1800 |
|
GATT (attribut générique) |
0x1801 |
|
ESS (détection de l'environnement) |
0x181A |
|
Température |
0x2A6E |
|
Humidité |
0x2A6F |
Schéma de service / caractéristiques BLE
UUID BLE
|
UUID |
Valeur 16 bits |
UUID 128 bits |
|
Service ESS |
0x181A |
0000181A-0000-0000-0000-00000000000 |
|
Temp Char |
0x2A6E |
00002A6E-0000-0000-0000-00000000000 |
|
Humidité Char |
0x2A6F |
00002A6F-0000-0000-0000-00000000000 |
Caractéristiques de température
|
Propriété |
La description |
|
Unité |
Degré Celsius avec une résolution de 0,01 degré |
|
Format |
sint16 |
|
UUID |
0x2A6E |
|
Exposant décimal |
2 |
|
Lis |
Obligatoire |
Caractéristiques d'humidité
|
Propriété |
La description |
|
Unité |
Pourcentage avec une résolution de 0,01% |
|
Format |
uint16 |
|
UUID |
0x2A6F |
|
Exposant décimal |
2 |
|
Lis |
Obligatoire |
Explication du programme nRF52 BLE
Nous utiliserons le SDK nRF5 pour programmer notre kit de développement nRF52. nRF5 SDK est un kit de développement logiciel complet intégré avec de nombreux profils Bluetooth Low Energy, un sérialiseur GATT et un support de pilote pour tous les périphériques des SoC de la série nRF5. Ce SDK aide les développeurs à créer des applications Bluetooth basse consommation complètes, fiables et sécurisées avec les séries de microcontrôleurs nRF52 et nRF51. Le programme complet peut être téléchargé à partir d'ici, l'explication du code est la suivante.
Configurez la broche de données DHT11 comme entrée sur nrf52 avec la validation de pull up. L'état de la broche doit être élevé pour confirmer que nRF52 fournit le PULLUP approprié pour la broche de données DHT11
/ * mis à input et vérifie si le signal est tiré vers le haut * / Data_SetInput (); DelayUSec (50); if (Data_GetVal () == 0) {return DHT11_NO_PULLUP; }
Générez le signal START du microcontrôleur nRF52 et vérifiez le signal d'acquittement.
/ * envoyer le signal de démarrage * / Data_SetOutput (); Data_ClrVal (); DelayMSec (20); / * garder le signal bas pendant au moins 18 ms * / Data_SetInput (); DelayUSec (50); / * vérifier le signal d'acquittement * / if (Data_GetVal ()! = 0) {/ * le signal doit être tiré vers le bas par le capteur * / return DHT11_NO_ACK_0; } / * attendre 100 us au maximum pour le signal d'acquittement du capteur * / cntr = 18; while (Data_GetVal () == 0) {/ * attend que le signal monte * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_1; / * le signal devrait être en place pour l'ACK ici * /}} / * attendre jusqu'à ce qu'il redescende, fin de la séquence d'acquittement * / cntr = 18; while (Data_GetVal ()! = 0) {/ * attend que le signal diminue * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_0; / * le signal devrait être à nouveau à zéro ici * /}}
Maintenant, lisez les 40 bits de données qui contiennent 2 octets de température, 2 octets d'humidité et 1 octet de somme de contrôle.
/ * lit maintenant les données 40 bits * / i = 0; données = 0; loopBits = 40; faire {cntr = 11; / * attendre max 55 us * / while (Data_GetVal () == 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_0; }} cntr = 15; / * attendre max 75 us * / while (Data_GetVal ()! = 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_1; }} données << = 1; / * bit de données suivant * / if (cntr <10) {/ * signal de données haut> 30 us ==> bit de données 1 * / data - = 1; } if ((loopBits & 0x7) == 1) {/ * octet suivant * / buffer = data; i ++; données = 0; }} while (- loopBits! = 0);
Validez les données à l'aide de Checksum.
/ * test CRC * / if ((uint8_t) (buffer + buffer + buffer + buffer)! = buffer) {return DHT11_BAD_CRC; }
Manipulez et stockez la température et l'humidité
/ * stocker les valeurs de données pour l'appelant * / humidité = ((int) buffer) * 100 + buffer; température = ((int) tampon) * 100 + tampon;
Initialisez le service nRF5 SDK Logger. nRF52 SDK est présenté avec une interface de contrôle de journalisation appelée nrf_log et utilise le backend par défaut pour la journalisation des informations. Le backend par défaut sera un port série. Ici, nous initialisons à la fois nrf_log interface de contrôle et nrf_log backends par défaut ainsi.
ret_code_t err_code = NRF_LOG_INIT (NULL); APP_ERROR_CHECK (code d'erreur); NRF_LOG_DEFAULT_BACKENDS_INIT ();
nRF52 SDK a une fonctionnalité de minuterie d'application. Le module de minuterie d'application permet de créer plusieurs instances de minuterie basées sur le périphérique RTC1. Ici, nous initialisons le module de minuterie d'application nRF5. Dans cette solution, deux minuteries d'application sont utilisées pour un intervalle de mise à jour des données.
ret_code_t err_code = app_timer_init (); APP_ERROR_CHECK (code d'erreur);
nRF52 SDK dispose du module de gestion de l'alimentation complet, car les appareils BLE doivent fonctionner pendant plusieurs mois sur une pile bouton. La gestion de l'alimentation joue un rôle essentiel dans les applications BLE. Le module de gestion de l'alimentation nRF52 gère complètement la même chose. Ici, nous initialisons le module de gestion de l'alimentation du SDK nRF5
ret_code_t err_code; err_code = nrf_pwr_mgmt_init (); APP_ERROR_CHECK (code d'erreur);
nRF52 SDK a un fichier hexadécimal du micrologiciel de l'appareil Nordic Soft intégré, qui comprend une pile centrale et périphérique Bluetooth basse consommation. Cette pile de protocoles hautement qualifiée comprend GATT, GAP, ATT, SM, L2CAP et Link Layer. Nous suivons ici la séquence d'initialisation, cette pile radio initialisée nRF5 BLE (Nordic Soft Device)
ret_code_t err_code; err_code = nrf_sdh_enable_request (); APP_ERROR_CHECK (code d'erreur); // Configurez la pile BLE en utilisant les paramètres par défaut. // Récupère l'adresse de début de la RAM de l'application. uint32_t ram_start = 0; err_code = nrf_sdh_ble_default_cfg_set (APP_BLE_CONN_CFG_TAG, & ram_start); APP_ERROR_CHECK (code d'erreur); // Activer la pile BLE. err_code = nrf_sdh_ble_enable (& ram_start); APP_ERROR_CHECK (code d'erreur); // Enregistre un gestionnaire pour les événements BLE. NRF_SDH_BLE_OBSERVER (m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
GAP est responsable de l'analyse / découverte des périphériques, de l'établissement des liens, de la terminaison des liens, du lancement des fonctions de sécurité et de la configuration. GAP a présenté des paramètres de connexion clés tels que l'intervalle de connexion, la latence de l'esclave, le délai de supervision, etc. Initialisation des paramètres de connexion du profil d'accès générique
ret_code_terr_code; ble_gap_conn_params_tgap_conn_params; ble_gap_conn_sec_mode_t sec_mode; BLE_GAP_CONN_SEC_MODE_SET_OPEN (& sec_mode); err_code = sd_ble_gap_device_name_set (& sec_mode, (const uint8_t *) DEVICE_NAME, strlen (DEVICE_NAME)); APP_ERROR_CHECK (code d'erreur); memset (& gap_conn_params, 0, sizeof (gap_conn_params)); gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL; gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL; gap_conn_params.slave_latency = SLAVE_LATENCY; gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT; err_code = sd_ble_gap_ppcp_set (& gap_conn_params); APP_ERROR_CHECK (code d'erreur);
Le GATT est responsable de la communication de données entre les périphériques BLE et les appareils centraux. Le module nRF52 GATT est utile pour la négociation et le suivi de la taille ATT_MTU maximale. Ici, nous initialisons le module d'attributs génériques du SDK nRF52, ret_code_t err_code = nrf_ble_gatt_init (& m_gatt, NULL); APP_ERROR_CHECK (code d'erreur);
Le GATT communique des données sous forme de services et de caractéristiques. Ici, nous initialisons les services de détection de l'environnement du GATT, ce qui inclut l'initialisation de caractéristiques telles que la température et l'humidité.
ret_code_terr_code; nrf_ble_qwr_init_t qwr_init = {0}; // Initialise le module d'écriture en file d'attente. qwr_init.error_handler = nrf_qwr_error_handler; err_code = nrf_ble_qwr_init (& m_qwr, & qwr_init); APP_ERROR_CHECK (code d'erreur); m_ess.notif_write_handler = ble_ess_notif_write_handler; err_code = ble_ess_init (& m_ess); APP_ERROR_CHECK (code d'erreur);
La publicité joue un rôle essentiel dans l'environnement d'application BLE. les paquets incluent les informations sur le type d'adresse, le type de publicité, les données publicitaires, les données spécifiques au fabricant de l'appareil et les données de réponse d'analyse. SDK nRF52 avec un module publicitaire. Ici, nous effectuons l'initialisation du module publicitaire avec les paramètres.
ret_code_terr_code; ble_advdata_t advdata; ble_advdata_t srdata; ble_uuid_t adv_uuids = {{ESS_UUID_SERVICE, BLE_UUID_TYPE_BLE}}; // Créer et définir des données publicitaires. memset (& advdata, 0, sizeof (advdata)); advdata.name_type = BLE_ADVDATA_FULL_NAME; advdata.include_appearance = true; advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE; memset (& srdata, 0, sizeof (srdata)); srdata.uuids_complete.uuid_cnt = sizeof (adv_uuids) / sizeof (adv_uuids); srdata.uuids_complete.p_uuids = adv_uuids; err_code = ble_advdata_encode (& advdata, m_adv_data.adv_data.p_data, & m_adv_data.adv_data.len); APP_ERROR_CHECK (code d'erreur); err_code = ble_advdata_encode (& srdata, m_adv_data.scan_rsp_data.p_data, & m_adv_data.scan_rsp_data.len); APP_ERROR_CHECK (code d'erreur); ble_gap_adv_params_t adv_params; // Définit les paramètres publicitaires. memset (& adv_params, 0, sizeof (adv_params)); adv_params.primary_phy = BLE_GAP_PHY_1MBPS; adv_params.duration = APP_ADV_DURATION; adv_params.properties.type = BLE_GAP_ADV_TYPE_CONNECTABLE_SCANNABLE_UNDIRECTED; adv_params.p_peer_addr = NULL; adv_params.filter_policy = BLE_GAP_ADV_FP_ANY; adv_params.interval = APP_ADV_INTERVAL; err_code = sd_ble_gap_adv_set_configure (& m_adv_handle, & m_adv_data, & adv_params); APP_ERROR_CHECK (code d'erreur);
La connexion BLE sera gérée et surveillée avec divers paramètres de connexion comme le premier délai de mise à jour des paramètres de connexion, les prochains délais consécutifs, le nombre de mises à jour, la fonction de rappel du gestionnaire d'événements de connexion et le gestionnaire d'événements de rappel d'erreur de connexion. Ici, nous faisons l'initialisation des paramètres d'établissement de connexion BLE et un gestionnaire d'événements de rappel pour les événements de connexion et les événements d'erreur.
ret_code_terr_code; ble_conn_params_init_t cp_init; memset (& cp_init, 0, sizeof (cp_init)); cp_init.p_conn_params = NULL; cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY; cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY; cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT; t_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID; cp_init.disconnect_on_fail = false; cp_init.evt_handler = on_conn_params_evt; cp_init.error_handler = conn_params_error_handler; err_code = ble_conn_params_init (& cp_init); APP_ERROR_CHECK (code d'erreur);
Une fois l'initialisation du système terminée, nous commençons ici par annoncer le nom du périphérique BLE et les informations de capacité. De là, ce périphérique peut être vu sur la liste d'analyse Ble du smartphone.
ret_code_terr_code; err_code = sd_ble_gap_adv_start (m_adv_handle, APP_BLE_CONN_CFG_TAG); APP_ERROR_CHECK (code d'erreur);
La boucle principale s'exécute sur l'intervalle de 2 secondes, lit la température et l'humidité et met à jour un appareil intelligent connecté à l'aide de la lecture ou de la notification
pour (;;) { uint16_t température, humidité; DHTxx_ErrorCode dhtErrCode; idle_state_handle (); if (updtmrexp) { dhtErrCode = DHTxx_Read (& température, & humidité); if (dhtErrCode == DHT11_OK) { NRF_LOG_INFO ("Température:% d Humidité:% d \ n", température, humidité); if (temp_notif_enabled) { ble_ess_notify_temp (m_conn_handle, & m_ess, température); } else { ble_ess_update_temp (& m_ess, température); } if (humid_notif_enabled) { ble_ess_notify_humid (m_conn_handle, & m_ess, humidité); } else { ble_ess_update_humid (& m_ess, humidité); } } updtmrexp = false; } }
Tester notre programme à l'aide de nRF Connect
nRF Connect est un puissant outil Bluetooth à faible consommation d'énergie qui permet de scanner et d'explorer les périphériques compatibles BLE. nRF Connect pour mobile prend en charge une large gamme de profils standard adoptés par Bluetooth SIG. Nous pouvons vérifier notre programme en utilisant ceci, après avoir installé l'application, nous pouvons coupler la carte nRF52 avec notre téléphone en recherchant les appareils BLE sur l'application. À l'intérieur de l'attribut de détection environnementale, nous pouvons remarquer que les valeurs de température et d'humidité sont mises à jour comme indiqué dans les images ci-dessous.
Hariharan Veerappan est un consultant indépendant ayant plus de 15 ans d'expérience dans le développement de produits embarqués. Il fournit des services de conseil en développement de micrologiciels embarqués / Linux, il fournit également des formations en entreprise et en ligne. Hariharan est titulaire d'un baccalauréat en génie dans la discipline de l'ingénierie électronique et de la communication, à travers ses articles et tutoriels, il partage son expérience et ses réflexions avec les lecteurs de Circuit Digest.