Set de dezvoltare Nordic nrf52 - măsurarea temperaturii și umidității folosind Bluetooth cu energie redusă

Cu benzi de fitness, ceasuri inteligente și alte dispozitive purtabile, din ce în ce mai populară utilizarea Bluetooth 5 / Bluetooth Low Energystandardele de comunicare sunt adoptate pe scară largă. BLE ne ajută să schimbăm date pe o distanță scurtă, cu foarte puțină energie, ceea ce este foarte important pentru dispozitivele cu baterii, cum ar fi dispozitivele portabile. De asemenea, ne ajută să configurăm rețele fără fir BLE mesh, această caracteristică este utilă pentru dispozitivele de automatizare a locuințelor în care mai multe dispozitive trebuie să comunice între ele într-un mediu închis. Am folosit deja BLE cu Raspberry Pi și BLE cu ESP32 pentru a efectua câteva funcții de bază BLE. Inginerii experimentează cu BLE pentru a proiecta dispozitive wireless portabile care să funcționeze mult timp pe baterii mici și există mai multe kituri de dezvoltare disponibile pentru a lucra cu BLE. În recenzia noastră recentă despre Arduino Nano 33, am observat, de asemenea, că placa are nRF52840 cu capacități BLE.

În acest tutorial, vom explora o altă placă de dezvoltare interesantă și populară numită nRF52 DK pentru a măsura temperatura și umiditatea folosind BLE. În mod implicit, BLE Environment Sensing Profiles acceptă o gamă largă de parametri de mediu, dar acest tutorial este limitat doar la valorile de temperatură și umiditate. Această soluție se conectează cu un Smartphone prin Bluetooth cu energie redusă și oferă o actualizare frecventă a parametrilor de mediu, adică Temperatură, Umiditate. Vom folosi senzorul DHT1 și măsurarea temperaturii se va face cu o rezoluție de 0,01 grade Celsius, iar măsurarea umidității se va face cu o rezoluție de 0,01 la sută.

Kitul de dezvoltare nRF52:

nRF52DK este o platformă completă de prototipare pentru aplicația Bluetooth de consum redus de energie și 2,4 GHz Wireless Internet of Things. Kitul de dezvoltare acceptă diverse lanțuri de instrumente nordice standard, cum ar fi open-source, GCC și medii comerciale de dezvoltare integrată, cum ar fi Keil, IAR și Segger Embedded Studio, etc. Nordic oferă, de asemenea, un kit de dezvoltare software complet pentru nRF52, care include suport complet pentru nRF52DK.

nRF52DK este alimentat cu microcontrolerul ARM Cortex-M4F nRF52832, care este integrat 512Kbyte de memorie Flash și 64 Kbyte de SRAM. nRF52DK are un Debugger integrat Segger J-Link On Board, care oferă o depanare mai ușoară și mai rapidă fără dispozitive de depanare jtag externe / suplimentare. De asemenea, include conectorul compatibil Arduino Uno Rev3, care acceptă interfața intrărilor analogice și digitale cu microprocesorul și include, de asemenea, protocoale standard de comunicații precum, I2C (Circuit inter-integrat), SPI (interfață periferică serială) și UART (receptor și transmițător asincron universal). Acest kit de dezvoltare este proiectat cu o antenă PCB integrată încorporată care asigură comunicații fără fir cu rază scurtă de acțiune utilizând Bluetooth Low Energy pentru conectarea cu Smart Phone, laptopuri și tablete.

Segger Embedded Studio

Pentru a programa placa de dezvoltare, vom folosi Segger Embedded Studio cu nRF52. Segger Embedded Studio este un puternic mediu de dezvoltare integrat C / C ++ (IDE), destinat special dezvoltării sistemelor încorporate. Aceasta oferă o soluție completă all-in-one care conține tot ce este necesar pentru programarea, dezvoltarea și depanarea C încorporate. Aceasta include un flux de lucru complet pentru programarea și dezvoltarea sistemelor încorporate, prezentat cu management de proiect, editor, depanator care acceptă dispozitive ARM Cortex. Acest IDE puternic și ușor de utilizat este complet gratuit pentru clienții nordici cu licență completă, fără restricții privind dimensiunea codului. IDE-ul poate fi descărcat de pe linkul de mai jos,

Descărcați Segger Embedded Studio

DHT11 cu nRF52DK

DHT11 este un senzor complet de temperatură și umiditate cu o componentă de măsurare a umidității de tip rezistiv și un component de măsurare a temperaturii de tip NTC. Oferă o calitate excelentă, răspuns mai rapid și rentabilitate. În mod implicit, toți senzorii DHT11 sunt calibrați în laborator, ceea ce duce la o precizie și fiabilitate extremă. Comunică utilizând sistemul de interfață serială cu un singur fir și alte specificații sunt prezentate mai jos

Specificațiile DHT11:

• Gama de umiditate: 20 - 90% RH
• Interval de temperatură: 0 - 50 grade celsius
• Precizia umidității: ± 5 ％ RH
• Precizia temperaturii: ± 2 ℃

Diagrama de sincronizare a DHT11:

Citirea datelor de la senzorul DHT11 este relativ simplă folosind diagrama de sincronizare prezentată mai sus. Procedura este similară cu orice controler și am folosit deja acest senzor cu alte platforme de dezvoltare precum

• Senzor DHT11 cu Raspberry Pi
• Senzor DHT11 cu PIC16F877A
• Senzor DHT11 cu STM32F103C8
• Senzor DHT11 cu NodeMCU

Pentru a interfața senzorul de temperatură și umiditate DHT11 cu kitul de dezvoltare nRF52, urmați schema de conectare dată mai jos.

Folosesc un modul conector pentru a conecta senzorul la placa mea, așa că setarea mea finală arată astfel

Diagrama de flux pentru comunicarea cu DHT11:

Diagrama de mai jos explică fluxul logic al programului pe care îl vom folosi pentru a comunica între nRF52DK și DHT11

Format date:

Cum să lucrați cu Bluetooth Low Energy (BLE)?

Pentru a înțelege cum să utilizați caracteristica BLE, trebuie să înțelegem câteva terminologii de bază care sunt explicate mai jos, puteți citi și articolul ESP32 BLE pentru a afla mai multe despre BLE

Profil de acces generic (GAP)

Profilul de acces generic deține responsabilitatea completă a stabilirii conexiunii pentru comunicarea între dispozitivele periferice BLE și dispozitive centrale. GAP oferă, de asemenea, diverse proceduri, inclusiv scanarea / descoperirea dispozitivelor, stabilirea conexiunilor link-layer, terminarea link-ului, handshaking-ul caracteristicilor de securitate și configurarea completă a dispozitivului. GAP funcționează în următoarele stări ale dispozitivului

Statele GAP	Descriere
Așteptare	Starea inițială a dispozitivului la resetare
Agent de publicitate	Publicitate pe dispozitiv cu date care ajută la scanarea inițiatorului
Scanner	Primește și trimite solicitarea de scanare către agentul de publicitate
Iniţiator	Trimite o cerere de conexiune pentru a stabili un link
Stapan de sclavi	La conexiune, dispozitivul ca sclav dacă este agent de publicitate, master dacă este inițiator

Stratul de profil de atribut generic (GATT)

GATT reprezintă abrevierea pentru Generic Attribute Profile Layer, este responsabil pentru comunicarea datelor între două dispozitive BLE (periferice și centrale). Comunicarea datelor se caracterizează sub formă de caracteristici, care comunică și stochează datele. Dispozitivul BLE joacă două roluri diferite pentru comunicarea dispozitivului prezentate mai jos,

1. GATT Server conține informațiile despre caracteristici care vor fi utilizate pentru citire și scriere. În tutorialul nostru, senzorul DHT11 și dev. kitul este serverul nostru GATT.
2. Clientul GATT citește și scrie datele de la / pe serverul GATT. Smartphone-ul este un client GATT care citește și scrie datele pe placa senzorului nostru.

Bluetooth SIG

Bluetooth Special Interest Group (SIG) este organizația de standarde care monitorizează dezvoltarea standardelor Bluetooth și licențierea tehnologiilor Bluetooth. Grupul SIG nu produce și nu vinde produse Bluetooth. Acesta definește specificațiile și standardizarea Bluetooth. Acestea definesc identificatorul unic pentru profilul Bluetooth cu consum redus de energie și caracteristicile respective. Specificațiile profilului GATT pot fi găsite la linkul de mai jos

Specificațiile profilului GATT

Pe baza specificațiilor GATT date în linkul de mai sus, am colectat identificatorii unici necesari pentru proiectul nostru, care sunt tabelați mai jos.

Profil / Caracteristici	UUID
GAP (acces generic)	0x1800
GATT (Atribut generic)	0x1801
ESS (Environment Sensing)	0x181A
Temperatura	0x2A6E
Umiditate	0x2A6F

Diagrama de servicii / caracteristici BLE

UUID-uri BLE

UUID	Valoare de 16 biți	UUID pe 128 biți
Serviciul ESS	0x181A	0000181A-0000-0000-0000-00000000000
Temp Char	0x2A6E	00002A6E-0000-0000-0000-00000000000
Umiditate Char	0x2A6F	00002A6F-0000-0000-0000-00000000000

Caracteristicile temperaturii

Proprietate	Descriere
Unitate	Grad Celsius cu o rezoluție de 0,01 grade
Format	sint16
UUID	0x2A6E
Componentă zecimală	2
Citit	Obligatoriu

Caracteristicile umidității

Proprietate	Descriere
Unitate	Procent cu o rezoluție de 0,01 la sută
Format	uint16
UUID	0x2A6F
Componentă zecimală	2
Citit	Obligatoriu

Explicația programului nRF52 BLE

Vom folosi SDK nRF5 pentru a programa kitul nostru de dezvoltare nRF52. nRF5 SDK este un kit complet de dezvoltare software integrat cu numeroase profiluri Bluetooth Low Energy, Serializator GATT și suport pentru driver pentru toate perifericele de pe SoC-urile nRF5. Acest SDK îi ajută pe dezvoltatori să construiască aplicații Bluetooth complete, sigure și sigure, cu consum redus de energie, cu seria de microcontrolere nRF52 și nRF51. Programul complet poate fi descărcat de aici, explicația codului este următoarea.

Configurați pinul DATA DHT11 ca intrare la nrf52 cu activarea pull up. Starea pinului ar trebui să fie ridicată pentru a confirma că nRF52 oferă PULLUP adecvat pentru pinul de date DHT11

/ * setat la intrare și verificați dacă semnalul este tras în sus * / Data_SetInput (); DelayUSec (50); if (Data_GetVal () == 0) {return DHT11_NO_PULLUP; }

Generați semnalul START de la microcontrolerul nRF52 și verificați semnalul de confirmare.

/ * trimite semnal de pornire * / Data_SetOutput (); Data_ClrVal (); DelayMSec (20); / * menține semnalul scăzut timp de cel puțin 18 ms * / Data_SetInput (); DelayUSec (50); / * verificați semnalul de confirmare * / dacă (Data_GetVal ()! = 0) {/ * semnalul trebuie tras jos de senzor * / return DHT11_NO_ACK_0; } / * așteptați maxim 100 us pentru semnalul ack de la senzor * / cntr = 18; while (Data_GetVal () == 0) {/ * așteptați până când semnalul crește * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_1; / * semnalul ar trebui să fie activat pentru ACK aici * /}} / * așteptați până când acesta coboară din nou, sfârșitul secvenței ack * / cntr = 18; while (Data_GetVal ()! = 0) {/ * așteptați până când semnalul coboară * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_0; / * semnalul ar trebui să fie din nou la zero aici * /}}

Acum citiți cei 40 de biți de date care conțin 2 octeți de temperatură, 2 octeți de umiditate și 1 octet de sumă de control.

/ * citiți acum datele de 40 biți * / i = 0; date = 0; loopBits = 40; faceți {cntr = 11; / * wait max 55 us * / while (Data_GetVal () == 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_0; }} cntr = 15; / * așteptați max 75 us * / while (Data_GetVal ()! = 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_1; }} date << = 1; / * următorul bit de date * / if (cntr <10) {/ * semnal de date înalt> 30 us ==> bit de date 1 * / date - = 1; } if ((loopBits & 0x7) == 1) {/ * următorul octet * / buffer = data; i ++; date = 0; }} while (- loopBits! = 0);

Validați datele cu ajutorul Checksum.

/ * test CRC * / if ((uint8_t) (buffer + buffer + buffer + buffer)! = buffer) {return DHT11_BAD_CRC; }

Manipulați și păstrați temperatura și umiditatea

/ * stochează valorile datelor pentru apelant * / umiditate = ((int) buffer) * 100 + buffer; temperature = ((int) tampon) * 100 + tampon;

Inițializați serviciul nRF5 SDK Logger. SDR nRF52 este prezentat cu o interfață de control a înregistrării numită nrf_log și folosește backend-ul implicit pentru înregistrarea informațiilor. Backend-ul implicit va fi un port serial. Aici inițializăm atât interfața de control nrf_log, cât și backend- urile implicite nrf_log .

ret_code_t err_code = NRF_LOG_INIT (NULL); APP_ERROR_CHECK (cod_error); NRF_LOG_DEFAULT_BACKENDS_INIT ();

nRF52 SDK are funcționalitate de temporizare a aplicațiilor. Modulul de timer al aplicației permite crearea mai multor instanțe de timer pe baza perifericului RTC1. Aici inițializăm modulul de temporizare a aplicației nRF5. În această soluție, sunt utilizate două temporizatoare de aplicații și un interval de actualizare a datelor.

ret_code_t err_code = app_timer_init (); APP_ERROR_CHECK (cod_error);

nRF52 SDK are modulul complet de gestionare a energiei, deoarece dispozitivele BLE trebuie să funcționeze mai multe luni pe o baterie cu celule monede. Gestionarea energiei joacă un rol vital în aplicațiile BLE. Modulul de gestionare a energiei nRF52 se descurcă complet la fel. Aici inițializăm modulul Power Management al SDK nRF5

ret_code_t eroare_cod; err_code = nrf_pwr_mgmt_init (); APP_ERROR_CHECK (cod_error);

nRF52 SDK are un fișier hexagonal de firmware pentru dispozitivul Nordic Soft încorporat, care are stiva centrală și periferică Bluetooth cu energie redusă. Această stivă de protocol înalt calificată include GATT, GAP, ATT, SM, L2CAP și Link Layer. Aici urmărim secvența de inițializare, care a inițializat nRF5 BLE Radio Stack (Nordic Soft Device)

ret_code_t eroare_cod; cod_error = nrf_sdh_enable_request (); APP_ERROR_CHECK (cod_error); // Configurați stiva BLE utilizând setările implicite. // Obțineți adresa de pornire a RAM a aplicației. uint32_t ram_start = 0; cod_error = nrf_sdh_ble_default_cfg_set (APP_BLE_CONN_CFG_TAG, & ram_start); APP_ERROR_CHECK (cod_error); // Activați stiva BLE. err_code = nrf_sdh_ble_enable (& ram_start); APP_ERROR_CHECK (cod_error); // Înregistrați un handler pentru evenimente BLE. NRF_SDH_BLE_OBSERVER (m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);

GAP este responsabil pentru scanarea / descoperirea dispozitivelor, stabilirea legăturilor, terminarea legăturilor, inițierea caracteristicilor de securitate și configurare. GAP a prezentat parametrii cheie de conexiune, cum ar fi intervalul de conexiune, latența sclavului, expirarea timpului de supraveghere etc. Inițializarea parametrilor de conexiune a profilului de acces generic.

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 (cod_error); 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; cod_error = sd_ble_gap_ppcp_set (& gap_conn_params); APP_ERROR_CHECK (cod_error);

GATT este responsabil pentru comunicarea datelor între dispozitivele periferice BLE și centrale. Modulul GATT nRF52 este util pentru negocierea și urmărirea dimensiunii maxime ATT_MTU. Aici inițializăm modulul de atribut generic SDR nRF52, ret_code_t err_code = nrf_ble_gatt_init (& m_gatt, NULL); APP_ERROR_CHECK (cod_error);

GATT comunică date sub formă de servicii și caracteristici. Aici inițializăm serviciile de detectare a mediului GATT, care includ inițializarea caracteristicilor precum temperatura și umiditatea.

ret_code_terr_code; nrf_ble_qwr_init_t qwr_init = {0}; // Inițializați modulul de scriere în coadă. qwr_init.error_handler = nrf_qwr_error_handler; err_code = nrf_ble_qwr_init (& m_qwr, & qwr_init); APP_ERROR_CHECK (cod_error); m_ess.notif_write_handler = ble_ess_notif_write_handler; cod_error = ble_ess_init (& m_ess); APP_ERROR_CHECK (cod_error);

Publicitatea joacă un rol vital în mediul de aplicații BLE. pachetele includ informații despre tipul de adresă, tipul de publicitate, datele de publicitate, datele specifice producătorului dispozitivului și datele de răspuns la scanare. SDK nRF52 prezentat cu un modul de publicitate. Aici facem inițializarea modulului de publicitate cu parametrii.

ret_code_terr_code; ble_advdata_t advdata; ble_advdata_t srdata; ble_uuid_t adv_uuids = {{ESS_UUID_SERVICE, BLE_UUID_TYPE_BLE}}; // Construiți și setați date publicitare. memset (& advdata, 0, sizeof (advdata)); advdata.name_type = BLE_ADVDATA_FULL_NAME; advdata.include_appearance = adevărat; 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 (cod_error); err_code = ble_advdata_encode (& srdata, m_adv_data.scan_rsp_data.p_data, & m_adv_data.scan_rsp_data.len); APP_ERROR_CHECK (cod_error); ble_gap_adv_params_t adv_params; // Setați parametrii de publicitate. 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; cod_error = sd_ble_gap_adv_set_configure (& m_adv_handle, & m_adv_data și & adv_params); APP_ERROR_CHECK (cod_error);

Conexiunea BLE va fi tratată și monitorizată cu diferiți parametri de conexiune, cum ar fi prima întârziere de actualizare a parametrilor de conexiune, următoarele întârzieri consecutive, numărul actualizărilor, funcția de apelare a gestionării evenimentelor de conexiune și gestionarea evenimentelor de apelare a erorii de conexiune. Aici facem parametrii de inițializare a stabilirii conexiunii BLE și un handler de evenimente de apel invers pentru evenimente de conexiune și evenimente de eroare.

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 (cod_error);

După finalizarea inițializării sistemului, aici începem cu publicitatea numelui dispozitivului BLE și a informațiilor despre capacitate. De aici, acest periferic poate fi văzut pe lista de scanare Ble a smartphone-ului.

ret_code_terr_code; cod_error = sd_ble_gap_adv_start (m_adv_handle, APP_BLE_CONN_CFG_TAG); APP_ERROR_CHECK (cod_error);

Bucla principală rulează în interval de 2 secunde, citește temperatura și umiditatea și actualizările la un dispozitiv inteligent conectat folosind fie citire, fie notificare

pentru (;;) { uint16_t temperatură, umiditate; DHTxx_ErrorCode dhtErrCode; idle_state_handle (); if (updtmrexp) { dhtErrCode = DHTxx_Read (& temperatura, & umiditatea); if (dhtErrCode == DHT11_OK) { NRF_LOG_INFO ("Temperatură:% d Umiditate:% d \ n", temperatură, umiditate); if (temp_notif_enabled) { ble_ess_notify_temp (m_conn_handle, & m_ess, temperature); } else { ble_ess_update_temp (& m_ess, temperatura); } if (humid_notif_enabled) { ble_ess_notify_humid (m_conn_handle, & m_ess, umiditate); } else { ble_ess_update_humid (& m_ess, umiditate); } } updtmrexp = false; } }

Testarea programului nostru folosind nRF Connect

nRF Connect este un puternic instrument Bluetooth cu consum redus de energie, care permite scanarea și explorarea perifericelor compatibile BLE. nRF Connect pentru mobil acceptă o gamă largă de profiluri standard adoptate de Bluetooth SIG. Ne putem verifica programul utilizând acest lucru, după instalarea aplicației, putem asocia placa nRF52 cu telefonul nostru prin scanarea dispozitivelor BLE din aplicație. În interiorul atributului de detectare a mediului, putem observa că valorile de temperatură și umiditate se actualizează așa cum se arată în imaginile de mai jos.

Hariharan Veerappan este un consultant independent cu mai mult de 15 ani de experiență în dezvoltarea produselor integrate. Oferă servicii de consultanță în dezvoltarea firmware-ului / Linux încorporat, oferă, de asemenea, instruire corporativă și online. Hariharan deține o diplomă de licență în inginerie în disciplina Inginerie electronică și comunicații, prin articolele și tutoriale sale împărtășește experiența și gândurile sale cititorilor Circuit Digest.