- Kit di sviluppo nRF52:
- Segger Embedded Studio
- DHT11 con nRF52DK
- Come lavorare con Bluetooth Low Energy (BLE)?
- Diagramma delle caratteristiche / del servizio BLE
- nRF52 BLE Spiegazione del programma
- Testare il nostro programma utilizzando nRF Connect
Con i cinturini fitness, gli smartwatch e altri dispositivi indossabili sta diventando sempre più popolare l'uso di Bluetooth 5 / Bluetooth Low Energygli standard di comunicazione sono ampiamente adottati. BLE ci aiuta a scambiare dati a breve distanza con pochissima potenza, il che è molto cruciale per i dispositivi a batteria come i dispositivi indossabili. Ci aiuta anche a configurare reti mesh BLE wireless, questa funzione è utile per i dispositivi di automazione domestica in cui più dispositivi devono comunicare tra loro in un ambiente chiuso. Abbiamo già utilizzato BLE con Raspberry Pi e BLE con ESP32 per eseguire alcune funzioni BLE di base. Gli ingegneri stanno sperimentando BLE per progettare dispositivi wireless portatili che possano funzionare a lungo con piccole batterie e sono disponibili più kit di sviluppo per lavorare con BLE. Nella nostra recente recensione su Arduino Nano 33, abbiamo anche notato che la scheda ha nRF52840 con funzionalità BLE.
In questo tutorial, esploreremo un'altra scheda di sviluppo entusiasmante e popolare chiamata nRF52 DK per misurare la temperatura e l'umidità utilizzando BLE. Per impostazione predefinita, i profili di rilevamento dell'ambiente BLE supportano un'ampia gamma di parametri ambientali, ma questo tutorial è limitato solo ai valori di temperatura e umidità. Questa soluzione si connette con uno Smartphone tramite Bluetooth low energy e fornisce un aggiornamento frequente sui parametri ambientali ovvero Temperatura, Umidità. Useremo il sensore DHT1 e la misurazione della temperatura verrà eseguita con una risoluzione di 0,01 gradi Celsius e la misurazione dell'umidità con una risoluzione dello 0,01 percento.
Kit di sviluppo nRF52:
nRF52DK è una piattaforma di prototipazione completa per applicazioni Bluetooth Low Energy e Wireless Internet of Things a 2,4 GHz. Il kit di sviluppo supporta vari standard Nordic Toolchain come open-source, GCC e ambienti di sviluppo integrati commerciali come Keil, IAR e Segger Embedded Studio, ecc. Nordic fornisce anche un kit di sviluppo software completo per nRF52, che include il supporto completo per nRF52DK.
nRF52DK è alimentato dal microcontrollore ARM Cortex-M4F nRF52832, che è integrato da 512 Kbyte di Memoria Flash e 64 Kbyte di SRAM. nRF52DK ha un debugger integrato Segger J-Link On Board, che fornisce un debug più semplice e veloce senza dispositivi di debug jtag esterni / aggiuntivi. Include anche il connettore compatibile con Arduino Uno Rev3, che supporta l'interfacciamento degli ingressi analogici e digitali con il microprocessore e include anche protocolli di comunicazione standard come I2C (Inter-Integrated Circuit), SPI (Serial Peripheral Interface) e UART (Universal Asynchronous Receiver and Transmitter). Questo kit di sviluppo è progettato con un'antenna PCB integrata che fornisce comunicazioni wireless a corto raggio utilizzando Bluetooth Low Energy per il collegamento con smartphone, laptop e tablet.
Segger Embedded Studio
Per programmare la scheda di sviluppo, utilizzeremo Segger Embedded Studio con nRF52. Segger Embedded Studio è un potente ambiente di sviluppo integrato (IDE) C / C ++ mirato specificamente allo sviluppo di sistemi embedded. Ciò fornisce una soluzione all-in-one completa contenente tutto il necessario per la programmazione, lo sviluppo e il debug in C embedded. Ciò include il flusso di lavoro completo per la programmazione e lo sviluppo di sistemi embedded, caratterizzato da gestione del progetto, editor, debugger che supporta i dispositivi ARM Cortex. Questo IDE potente e facile da usare è completamente gratuito per i clienti nordici con licenza completa senza restrizioni sulla dimensione del codice. L'IDE può essere scaricato dal collegamento fornito di seguito,
Scarica Segger Embedded Studio
DHT11 con nRF52DK
DHT11 è un sensore di temperatura e umidità completo con un componente di misurazione dell'umidità di tipo resistivo e un componente di misurazione della temperatura di tipo NTC. Offre una qualità eccellente, una risposta più rapida e un rapporto costo-efficacia. Per impostazione predefinita, tutti i sensori DHT11 sono calibrati in laboratorio, il che porta a un'estrema precisione e affidabilità. Comunica utilizzando il sistema di interfaccia seriale a filo singolo e altre specifiche sono fornite di seguito
Specifiche di DHT11:
- Gamma di umidità: 20-90% di umidità relativa
- Intervallo di temperatura: 0-50 gradi Celsius
- Precisione dell'umidità: ± 5 ％ RH
- Precisione della temperatura: ± 2 ℃
Diagramma dei tempi di DHT11:
La lettura dei dati dal sensore DHT11 è relativamente semplice utilizzando il diagramma temporale mostrato sopra. La procedura è simile a qualsiasi controller e abbiamo già utilizzato questo sensore con altre piattaforme di sviluppo come
- Sensore DHT11 con Raspberry Pi
- Sensore DHT11 con PIC16F877A
- Sensore DHT11 con STM32F103C8
- Sensore DHT11 con NodeMCU
Per interfacciare il sensore di temperatura e umidità DHT11 con il kit di sviluppo nRF52, seguire lo schema di collegamento riportato di seguito.
Sto usando un modulo connettore per collegare il sensore alla mia scheda, quindi la mia configurazione finale è simile a questa
Diagramma di flusso per la comunicazione con DHT11:
Il diagramma di flusso seguente spiega il flusso logico del programma che useremo per comunicare tra nRF52DK e DHT11
Formato dei dati:
Come lavorare con Bluetooth Low Energy (BLE)?
Per capire come utilizzare la funzione BLE, dobbiamo comprendere alcune terminologie di base spiegate di seguito, puoi anche leggere l'articolo ESP32 BLE per saperne di più su BLE
Profilo di accesso generico (GAP)
Generic Access Profile detiene la completa responsabilità di stabilire la connessione per la comunicazione tra la periferica BLE e i dispositivi centrali. GAP fornisce anche varie procedure tra cui scansione / rilevamento dei dispositivi, creazione di connessioni a livello di collegamento, terminazione del collegamento, handshake delle funzioni di sicurezza e configurazione del dispositivo a tutti gli effetti. GAP funziona nei seguenti stati del dispositivo
|
Stati GAP |
Descrizione |
|
Pausa |
Stato iniziale del dispositivo al ripristino |
|
Inserzionista |
Pubblicità del dispositivo con dati che aiutano la scansione dell'iniziatore |
|
Scanner |
Riceve e invia la richiesta di scansione all'inserzionista |
|
Iniziatore |
Invia una richiesta di connessione per stabilire un collegamento |
|
Slave / Master |
Alla connessione, dispositivo come slave se inserzionista, master se iniziatore |
Generic Attribute Profile Layer (GATT)
GATT è l'acronimo di Generic Attribute Profile Layer, è responsabile della comunicazione dati tra due dispositivi BLE (periferico e centrale). La comunicazione dei dati è caratterizzata sotto forma di caratteristiche, che comunicano e memorizzano i dati. Il dispositivo BLE svolge due ruoli diversi per la comunicazione del dispositivo indicati di seguito,
- Il server GATT contiene le informazioni sulle caratteristiche che verranno utilizzate per leggere e scrivere. Nel nostro tutorial, il sensore DHT11 e il dev. il kit è il nostro server GATT.
- Il client GATT legge e scrive i dati da / sul server GATT. Lo smartphone è un client GATT che legge e scrive i dati nella nostra scheda sensore.
Bluetooth SIG
Bluetooth Special Interest Group (SIG) è l'organizzazione di standard che monitora lo sviluppo degli standard Bluetooth e la concessione in licenza delle tecnologie Bluetooth. Il gruppo SIG non produce né vende prodotti Bluetooth. Definisce la specifica e la standardizzazione Bluetooth. Definiscono l' identificatore univoco per il profilo Bluetooth a basso consumo energetico e le rispettive caratteristiche. Le specifiche del profilo GATT sono disponibili al collegamento sottostante
Specifiche del profilo GATT
Sulla base delle specifiche GATT fornite nel collegamento sopra, abbiamo raccolto gli identificatori univoci richiesti per il nostro progetto che sono tabulati di seguito.
|
Profilo / caratteristiche |
UUID |
|
GAP (accesso generico) |
0x1800 |
|
GATT (attributo generico) |
0x1801 |
|
ESS (Environment Sensing) |
0x181A |
|
Temperatura |
0x2A6E |
|
Umidità |
0x2A6F |
Diagramma delle caratteristiche / del servizio BLE
BLE UUID
|
UUID |
Valore a 16 bit |
UUID a 128 bit |
|
Servizio ESS |
0x181A |
0000181A-0000-0000-0000-00000000000 |
|
Temp Char |
0x2A6E |
00002A6E-0000-0000-0000-00000000000 |
|
Umidità Char |
0x2A6F |
00002A6F-0000-0000-0000-00000000000 |
Caratteristiche della temperatura
|
Proprietà |
Descrizione |
|
Unità |
Grado Celsius con una risoluzione di 0,01 gradi |
|
Formato |
sint16 |
|
UUID |
0x2A6E |
|
Esponente decimale |
2 |
|
Leggere |
Obbligatorio |
Caratteristiche di umidità
|
Proprietà |
Descrizione |
|
Unità |
Percentuale con una risoluzione dello 0,01 percento |
|
Formato |
uint16 |
|
UUID |
0x2A6F |
|
Esponente decimale |
2 |
|
Leggere |
Obbligatorio |
nRF52 BLE Spiegazione del programma
Useremo l' SDK nRF5 per programmare il nostro kit di sviluppo nRF52. nRF5 SDK è un kit di sviluppo software completo integrato con numerosi profili Bluetooth Low Energy, serializzatore GATT e supporto driver per tutte le periferiche sui SoC della serie nRF5. Questo SDK aiuta gli sviluppatori a creare applicazioni Bluetooth a basso consumo complete, affidabili e sicure con le serie di microcontrollori nRF52 e nRF51. Il programma completo può essere scaricato da qui, la spiegazione del codice è la seguente.
Configurare il pin DHT11 DATA come input su nrf52 con pull up enable. Lo stato del pin dovrebbe essere alto per confermare che nRF52 fornisce il PULLUP corretto per il pin dati DHT11
/ * impostato su input e controlla se il segnale viene richiamato * / Data_SetInput (); DelayUSec (50); if (Data_GetVal () == 0) {return DHT11_NO_PULLUP; }
Genera il segnale START dal microcontrollore nRF52 e controlla il segnale di riconoscimento.
/ * invia il segnale di avvio * / Data_SetOutput (); Data_ClrVal (); DelayMSec (20); / * mantiene il segnale basso per almeno 18 ms * / Data_SetInput (); DelayUSec (50); / * controlla il segnale di riconoscimento * / if (Data_GetVal ()! = 0) {/ * il segnale deve essere abbassato dal sensore * / return DHT11_NO_ACK_0; } / * aspetta max 100 us per il segnale di riconoscimento dal sensore * / cntr = 18; while (Data_GetVal () == 0) {/ * aspetta che il segnale salga * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_1; / * il segnale dovrebbe essere attivo per l'ACK qui * /}} / * aspetta finché non scende di nuovo, fine della sequenza ack * / cntr = 18; while (Data_GetVal ()! = 0) {/ * aspetta che il segnale si interrompa * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_0; / * il segnale dovrebbe essere nuovamente a zero qui * /}}
Ora leggi i 40 bit di dati che contengono 2 byte di temperatura, 2 byte di umidità e 1 byte di un checksum.
/ * ora legge i dati a 40 bit * / i = 0; dati = 0; loopBits = 40; fare {cntr = 11; / * aspetta max 55 us * / while (Data_GetVal () == 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_0; }} cntr = 15; / * aspetta max 75 us * / while (Data_GetVal ()! = 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_1; }} dati << = 1; / * bit di dati successivo * / if (cntr <10) {/ * segnale dati alto> 30 us ==> bit di dati 1 * / data - = 1; } if ((loopBits & 0x7) == 1) {/ * prossimo byte * / buffer = data; i ++; dati = 0; }} while (- loopBits! = 0);
Convalida i dati con l'aiuto di Checksum.
/ * test CRC * / if ((uint8_t) (buffer + buffer + buffer + buffer)! = buffer) {return DHT11_BAD_CRC; }
Manipola e conserva la temperatura e l'umidità
/ * memorizza i valori dei dati per il chiamante * / umidità = ((int) buffer) * 100 + buffer; temperatura = ((int) buffer) * 100 + buffer;
Inizializza il servizio nRF5 SDK Logger. nRF52 SDK è dotato di un'interfaccia di controllo della registrazione chiamata nrf_log e utilizza il backend predefinito per la registrazione delle informazioni. Il backend predefinito sarà una porta seriale. Qui inizializziamo sia nrf_log interfaccia di controllo e nrf_log backend predefinito pure.
ret_code_t err_code = NRF_LOG_INIT (NULL); APP_ERROR_CHECK (err_code); NRF_LOG_DEFAULT_BACKENDS_INIT ();
nRF52 SDK ha funzionalità di timer dell'applicazione. Il modulo timer dell'applicazione consente di creare più istanze timer basate sulla periferica RTC1. Qui inizializziamo il modulo timer dell'applicazione nRF5. In questa soluzione, vengono utilizzati due timer dell'applicazione e l'intervallo di aggiornamento dei dati.
ret_code_t err_code = app_timer_init (); APP_ERROR_CHECK (err_code);
nRF52 SDK ha il modulo completo di gestione dell'alimentazione poiché i dispositivi BLE devono funzionare per più mesi con una batteria a bottone. La gestione dell'alimentazione gioca un ruolo fondamentale nelle applicazioni BLE. Il modulo di gestione dell'alimentazione nRF52 gestisce completamente lo stesso. Qui inizializziamo il modulo di gestione dell'alimentazione di nRF5 SDK
ret_code_t err_code; err_code = nrf_pwr_mgmt_init (); APP_ERROR_CHECK (err_code);
nRF52 SDK ha un file esadecimale del firmware Nordic Soft Device integrato, che presenta uno stack centrale e periferico Bluetooth a basso consumo energetico. Questo stack di protocolli altamente qualificato include GATT, GAP, ATT, SM, L2CAP e Link Layer. Qui seguiamo la sequenza di inizializzazione, quella Stack radio BLE nRF5 inizializzato (Nordic Soft Device)
ret_code_t err_code; err_code = nrf_sdh_enable_request (); APP_ERROR_CHECK (err_code); // Configura lo stack BLE utilizzando le impostazioni predefinite. // Recupera l'indirizzo iniziale della RAM dell'applicazione. uint32_t ram_start = 0; err_code = nrf_sdh_ble_default_cfg_set (APP_BLE_CONN_CFG_TAG, & ram_start); APP_ERROR_CHECK (err_code); // Abilita lo stack BLE. err_code = nrf_sdh_ble_enable (& ram_start); APP_ERROR_CHECK (err_code); // Registra un gestore per gli eventi BLE. NRF_SDH_BLE_OBSERVER (m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
GAP è responsabile della scansione / individuazione del dispositivo, creazione di collegamenti, terminazione di collegamenti, avvio di funzioni di sicurezza e configurazione. GAP è dotato di parametri di connessione chiave come intervallo di connessione, latenza slave, timeout di supervisione, ecc. Con la presente inizializzazione dei parametri di connessione del profilo di accesso generico
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 (err_code); 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 (err_code);
GATT è responsabile della comunicazione dei dati tra le periferiche BLE e i dispositivi centrali. Il modulo nRF52 GATT è utile per negoziare e tenere traccia della dimensione massima ATT_MTU. Qui inizializziamo il modulo di attributo generico SDK nRF52, ret_code_t err_code = nrf_ble_gatt_init (& m_gatt, NULL); APP_ERROR_CHECK (err_code);
GATT effettua comunicazioni di dati sotto forma di servizi e caratteristiche. Qui inizializziamo i servizi di rilevamento dell'ambiente GATT, che include l'inizializzazione di caratteristiche come temperatura e umidità.
ret_code_terr_code; nrf_ble_qwr_init_t qwr_init = {0}; // Inizializza il modulo di scrittura in coda. qwr_init.error_handler = nrf_qwr_error_handler; err_code = nrf_ble_qwr_init (& m_qwr, & qwr_init); APP_ERROR_CHECK (err_code); m_ess.notif_write_handler = ble_ess_notif_write_handler; err_code = ble_ess_init (& m_ess); APP_ERROR_CHECK (err_code);
La pubblicità gioca un ruolo fondamentale nell'ambiente dell'applicazione BLE. i pacchetti includono le informazioni sul tipo di indirizzo, il tipo di pubblicità, i dati pubblicitari, i dati specifici del produttore del dispositivo e i dati di risposta della scansione. nRF52 SDK dotato di un modulo pubblicitario. Qui eseguiamo l'inizializzazione del modulo pubblicitario con i parametri.
ret_code_terr_code; ble_advdata_t advdata; ble_advdata_t srdata; ble_uuid_t adv_uuids = {{ESS_UUID_SERVICE, BLE_UUID_TYPE_BLE}}; // Crea e imposta i dati pubblicitari. 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 (err_code); err_code = ble_advdata_encode (& srdata, m_adv_data.scan_rsp_data.p_data, & m_adv_data.scan_rsp_data.len); APP_ERROR_CHECK (err_code); ble_gap_adv_params_t adv_params; // Imposta i parametri pubblicitari. 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 (err_code);
La connessione BLE verrà gestita e monitorata con vari parametri di connessione come il primo ritardo di aggiornamento dei parametri di connessione, i successivi ritardi consecutivi, il conteggio degli aggiornamenti, la funzione di richiamata del gestore eventi di connessione e il gestore di eventi di richiamata degli errori di connessione. Qui eseguiamo l'inizializzazione dei parametri di creazione della connessione BLE e un gestore eventi di callback per eventi di connessione ed eventi di errore.
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 (err_code);
Dopo il completamento dell'inizializzazione del sistema, qui iniziamo con la pubblicità del nome del dispositivo BLE e delle informazioni sulla capacità. Da qui, questa periferica può essere visualizzata tramite l'elenco Ble scan dello smartphone.
ret_code_terr_code; err_code = sd_ble_gap_adv_start (m_adv_handle, APP_BLE_CONN_CFG_TAG); APP_ERROR_CHECK (err_code);
Il ciclo principale viene eseguito per un intervallo di 2 secondi, legge la temperatura e l'umidità e si aggiorna su un dispositivo smart connesso utilizzando la lettura o la notifica
per (;;) { uint16_t temperatura, umidità; DHTxx_ErrorCode dhtErrCode; idle_state_handle (); if (updtmrexp) { dhtErrCode = DHTxx_Read (& temperature, & umidità); if (dhtErrCode == DHT11_OK) { NRF_LOG_INFO ("Temperatura:% d Umidità:% d \ n", temperatura, umidità); if (temp_notif_enabled) { ble_ess_notify_temp (m_conn_handle, & m_ess, temperature); } altro { ble_ess_update_temp (& m_ess, temperature); } if (humid_notif_enabled) { ble_ess_notify_humid (m_conn_handle, & m_ess, umidità); } altro { ble_ess_update_humid (& m_ess, umidità); } } updtmrexp = false; } }
Testare il nostro programma utilizzando nRF Connect
nRF Connect è un potente strumento Bluetooth a basso consumo energetico che consente di scansionare ed esplorare le periferiche abilitate BLE. nRF Connect per dispositivi mobili supporta un'ampia gamma di profili standard adottati da Bluetooth SIG. Possiamo verificare il nostro programma usando questo, dopo aver installato l'app possiamo accoppiare la scheda nRF52 con il nostro telefono scansionando i dispositivi BLE sull'app. All'interno dell'attributo Rilevamento ambientale, possiamo notare che i valori di temperatura e umidità vengono aggiornati come mostrato nelle immagini sottostanti.
Hariharan Veerappan è un consulente indipendente con più di 15 anni di esperienza nello sviluppo di prodotti embedded. Fornisce servizi di consulenza nello sviluppo di firmware embedded / Linux, fornisce anche formazione aziendale e online. Hariharan ha una laurea in Ingegneria nella disciplina dell'ingegneria elettronica e delle comunicazioni, attraverso i suoi articoli e tutorial condivide la sua esperienza e le sue riflessioni con i lettori di Circuit Digest.