Nordic nrf52 ontwikkelkit - meten van temperatuur en vochtigheid met bluetooth low energy

Met fitnessbanden, smartwatches en andere draagbare apparaten die steeds populairder worden, wordt het gebruik van Bluetooth 5 / Bluetooth Low Energycommunicatiestandaarden worden op grote schaal toegepast. BLE helpt ons om gegevens over een korte afstand uit te wisselen met heel weinig stroom, wat erg cruciaal is voor op batterijen werkende apparaten zoals wearables. Het helpt ons ook om draadloze BLE mesh-netwerken op te zetten, deze functie is handig voor domotica-apparaten waarbij meerdere apparaten met elkaar moeten communiceren in een gesloten omgeving. We hebben BLE al gebruikt met Raspberry Pi en BLE met ESP32 om enkele basis BLE-functies uit te voeren. Ingenieurs experimenteren met BLE om draagbare draadloze apparaten te ontwerpen die lang op kleine batterijen kunnen werken, en er zijn meerdere ontwikkelkits beschikbaar om met BLE te werken. In onze recente recensie over Arduino Nano 33 hebben we ook opgemerkt dat het bord nRF52840 heeft met BLE-mogelijkheden.

In deze tutorial zullen we een ander opwindend en populair ontwikkelbord verkennen, de nRF52 DK, om temperatuur en vochtigheid te meten met BLE. Standaard ondersteunt BLE Environment Sensing Profiles een breed scala aan omgevingsparameters, maar deze tutorial is alleen beperkt tot temperatuur- en vochtigheidswaarden. Deze oplossing maakt verbinding met een smartphone via Bluetooth low energy en biedt een regelmatige update van de omgevingsparameters, zoals temperatuur en vochtigheid. We gaan de DHT1 sensor gebruiken en de temperatuurmeting gebeurt met een resolutie van 0,01 graden Celsius en de vochtigheidsmeting met een resolutie van 0,01 procent.

nRF52-ontwikkelingskit:

nRF52DK is een compleet prototype-platform voor Bluetooth Low Energy en 2,4 GHz Wireless Internet of Things-applicatie. De ontwikkelingskit ondersteunt verschillende standaard Nordic Toolchains zoals open-source, GCC en commerciële geïntegreerde ontwikkelomgevingen zoals Keil, IAR en Segger Embedded Studio, enz. Nordic biedt ook een volwaardige softwareontwikkelingskit voor nRF52, die volledige ondersteuning voor nRF52DK omvat.

nRF52DK wordt aangedreven met nRF52832 ARM Cortex-M4F Microcontroller, die is geïntegreerd 512 KB Flash Memor en 64 KB SRAM. De nRF52DK heeft een geïntegreerde Segger J-Link On Board debugger, die een gemakkelijkere en snellere debugging mogelijk maakt zonder externe / extra jtag debug-apparaten. Het bevat ook de Arduino Uno Rev3-compatibele connector, dat de interface van de analoge en digitale ingangen met de microprocessor ondersteunt en het bevat ook standaard communicatieprotocollen zoals I2C (Inter-Integrated Circuit), SPI (Serial Peripheral Interface) en UART (Universal Asynchronous Receiver and Transmitter). Deze ontwikkelkit is ontworpen met een geïntegreerde, ingebouwde PCB-antenne die draadloze communicatie op korte afstand biedt met behulp van Bluetooth Low Energy voor verbinding met smartphones, laptops en tablets.

Segger Embedded Studio

Om het ontwikkelbord te programmeren, zullen we de Segger Embedded Studio met nRF52 gebruiken. Segger Embedded Studio is een krachtige C / C ++ geïntegreerde ontwikkelomgeving (IDE) specifiek gericht op de ontwikkeling van embedded systemen. Dit biedt een complete alles-in-één oplossing die alles bevat wat nodig is voor embedded C-programmering, ontwikkeling en foutopsporing. Dit omvat een complete workflow voor het programmeren en ontwikkelen van embedded systemen, uitgerust met projectbeheer, editor, debugger die ARM Cortex-apparaten ondersteunt. Deze krachtige en gebruiksvriendelijke IDE is volledig gratis voor Scandinavische klanten met een volledige licentie zonder enige beperking van de codegrootte. De IDE kan worden gedownload via de onderstaande link,

Download Segger Embedded Studio

DHT11 met nRF52DK

De DHT11 is een complete temperatuur- en vochtigheidssensor met een weerstandscomponent voor vochtigheidsmeting en een component voor temperatuurmeting van het NTC-type. Het biedt uitstekende kwaliteit, snellere respons en kosteneffectiviteit. Standaard worden alle DHT11-sensoren in het laboratorium gekalibreerd, wat leidt tot extreme nauwkeurigheid en betrouwbaarheid. Het communiceert via het Single-Wire Serial Interface-systeem en andere specificaties worden hieronder gegeven

Specificaties van DHT11:

• Vochtigheidsbereik: 20 - 90% RV
• Temperatuurbereik: 0 - 50 graden celsius
• Vochtigheidsnauwkeurigheid: ± 5 ％ RV
• Temperatuurnauwkeurigheid: ± 2 ℃

Timingdiagram van DHT11:

Het lezen van de gegevens van de DHT11-sensor is relatief eenvoudig met behulp van het bovenstaande timingdiagram. De procedure is vergelijkbaar met elke controller en we hebben deze sensor al gebruikt met andere ontwikkelplatforms zoals

• DHT11-sensor met Raspberry Pi
• DHT11-sensor met PIC16F877A
• DHT11-sensor met STM32F103C8
• DHT11-sensor met NodeMCU

Volg het onderstaande aansluitschema om de DHT11 temperatuur- en vochtigheidssensor te koppelen aan de nRF52 Development Kit.

Ik gebruik een aansluitmodule om de sensor op mijn bord aan te sluiten, dus mijn uiteindelijke opstelling ziet er zo uit

Stroomschema voor communicatie met DHT11:

Het onderstaande stroomschema legt de logische stroom van het programma uit die we zullen gebruiken om te communiceren tussen nRF52DK en DHT11

Data formaat:

Hoe te werken met Bluetooth Low Energy (BLE)?

Om te begrijpen hoe u de BLE-functie gebruikt, moeten we enkele basisterminologieën begrijpen die hieronder worden uitgelegd.U kunt ook het ESP32 BLE-artikel lezen om meer te weten over BLE

Generic Access Profile (GAP)

Generic Access Profile draagt ​​de volledige verantwoordelijkheid voor het tot stand brengen van de verbinding voor communicatie tussen BLE-randapparatuur en centrale apparaten. GAP biedt ook verschillende procedures, waaronder het scannen / opsporen van apparaten, het tot stand brengen van verbindingen tussen de laag, het beëindigen van een verbinding, handshaking van beveiligingsfuncties en een volwaardige apparaatconfiguratie. GAP werkt in de volgende apparaatstatussen

GAP-staten	Omschrijving
Stand-by	Initiële status van apparaat bij reset
Adverteerder	Apparaatreclame met gegevens die helpen bij het scannen van de initiator
Scanner	Ontvangt het scanverzoek en stuurt het naar de adverteerder
Initiator	Verzendt een verbindingsverzoek om een ​​verbinding tot stand te brengen
Slavenmeester	Bij verbinding, apparaat als slaaf als adverteerder, meester als initiator

Generic Attribute Profile Layer (GATT)

GATT staat voor Generic Attribute Profile Layer, het is verantwoordelijk voor datacommunicatie tussen twee BLE-apparaten (Peripheral & Central). Datacommunicatie kenmerkt zich in de vorm van kenmerken die de data communiceren en opslaan. BLE-apparaat speelt twee verschillende rollen voor de apparaatcommunicatie die hieronder wordt gegeven,

1. GATT Server bevat de karakteristieke informatie die zal worden gebruikt om te lezen en te schrijven. In onze tutorial zijn de DHT11-sensor en de dev. de kit is onze GATT-server.
2. GATT Client leest en schrijft de gegevens van / naar de GATT Server. De smartphone is een GATT-client die de gegevens leest en naar ons sensorbord schrijft.

Bluetooth SIG

Bluetooth Special Interest Group (SIG) is de normalisatieorganisatie die toezicht houdt op de ontwikkeling van Bluetooth-standaarden en de licenties voor Bluetooth-technologieën. De SIG-groep produceert of verkoopt geen Bluetooth-producten. Het definieert de Bluetooth-specificatie en standaardisatie. Ze definiëren de unieke identificatie voor het Bluetooth-profiel met laag energieverbruik en de bijbehorende kenmerken. De specificaties van het GATT-profiel zijn te vinden op de onderstaande link

GATT-profielspecificaties

Op basis van de GATT-specificatie die in de bovenstaande link wordt gegeven, hebben we de unieke identificatiegegevens verzameld die nodig zijn voor ons project, die hieronder worden weergegeven.

Profiel / kenmerken	UUID
GAP (generieke toegang)	0x1800
GATT (algemeen kenmerk)	0x1801
ESS (omgevingsdetectie)	0x181A
Temperatuur	0x2A6E
Vochtigheid	0x2A6F

BLE Service / karakteristiek diagram

BLE UUID's

UUID	16 bit waarde	128 bit UUID
ESS-service	0x181A	0000181A-0000-0000-0000-00000000000
Temp Char	0x2A6E	00002A6E-0000-0000-0000-00000000000
Vochtigheid Char	0x2A6F	00002A6F-0000-0000-0000-00000000000

Temperatuurkenmerken

Eigendom	Omschrijving
Eenheid	Graad Celsius met een resolutie van 0,01 graden
Formaat	sint16
UUID	0x2A6E
Decimale exponent	2
Lezen	Verplicht

Vochtigheidskenmerken

Eigendom	Omschrijving
Eenheid	Percentage met een resolutie van 0,01 procent
Formaat	uint16
UUID	0x2A6F
Decimale exponent	2
Lezen	Verplicht

nRF52 BLE-programma-uitleg

We zullen de nRF5 SDK gebruiken om onze nRF52 Development Kit te programmeren. nRF5 SDK is een complete softwareontwikkelingskit geïntegreerd met tal van Bluetooth Low Energy-profielen, GATT Serializer en driverondersteuning voor alle randapparatuur op SoC's uit de nRF5-serie. Deze SDK helpt ontwikkelaars om volledig functionele, betrouwbare en veilige Bluetooth-toepassingen met laag energieverbruik te bouwen met de nRF52- en nRF51-serie microcontrollers. Het volledige programma kan vanaf hier worden gedownload, de code-uitleg is als volgt.

Configureer de DHT11 DATA-pin als invoer op nrf52 met pull-up inschakelen. De pinstatus moet hoog zijn om te bevestigen dat nRF52 de juiste PULLUP biedt voor de DHT11-datapin

/ * ingesteld op invoer en controleer of het signaal wordt opgehaald * / Data_SetInput (); DelayUSec (50); if (Data_GetVal () == 0) {return DHT11_NO_PULLUP; }

Genereer een START-signaal van de nRF52 Microcontroller en controleer op een bevestigingssignaal.

/ * stuur startsignaal * / Data_SetOutput (); Data_ClrVal (); DelayMSec (20); / * houd het signaal minimaal 18 ms laag * / Data_SetInput (); DelayUSec (50); / * controleer op bevestigingssignaal * / if (Data_GetVal ()! = 0) {/ * signaal moet laag worden getrokken door de sensor * / return DHT11_NO_ACK_0; } / * wacht max 100 ons op het ack-signaal van de sensor * / cntr = 18; while (Data_GetVal () == 0) {/ * wacht tot het signaal omhoog gaat * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_1; / * signaal zou hier voor de ACK moeten zijn * /}} / * wacht tot het weer naar beneden gaat, einde van ack-reeks * / cntr = 18; while (Data_GetVal ()! = 0) {/ * wacht tot het signaal wegvalt * / DelayUSec (5); if (--cntr == 0) {return DHT11_NO_ACK_0; / * signaal zou hier weer nul moeten zijn * /}}

Lees nu de 40 bits aan gegevens die 2 bytes aan temperatuur, 2 bytes aan vochtigheid en 1 byte aan checksum bevatten.

/ * lees nu de 40 bit data * / i = 0; gegevens = 0; loopBits = 40; do {cntr = 11; / * wacht max 55 ons * / while (Data_GetVal () == 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_0; }} cntr = 15; / * wacht max 75 ons * / while (Data_GetVal ()! = 0) {DelayUSec (5); if (--cntr == 0) {return DHT11_NO_DATA_1; }} gegevens << = 1; / * volgende databit * / if (cntr <10) {/ * datasignaal hoog> 30 us ==> databit 1 * / data - = 1; } if ((loopBits & 0x7) == 1) {/ * next byte * / buffer = data; i ++; gegevens = 0; }} while (- loopBits! = 0);

Valideer de gegevens met behulp van Checksum.

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

Manipuleer en bewaar de temperatuur en vochtigheid

/ * gegevenswaarden opslaan voor beller * / vochtigheid = ((int) buffer) * 100 + buffer; temperatuur = ((int) buffer) * 100 + buffer;

Initialiseer de nRF5 SDK Logger-service. nRF52 SDK is uitgerust met een logboekregistratie-interface genaamd nrf_log en gebruikt de standaard backend voor het loggen van de informatie. De standaard backend is een seriële poort. Hier initialiseren we zowel de nrf_log besturingsinterface als de nrf_log standaard backends.

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

nRF52 SDK heeft applicatie-timerfunctionaliteit. De applicatie-timermodule maakt het mogelijk om meerdere timerinstanties te maken op basis van RTC1-randapparatuur. Hier initialiseren we de nRF5-applicatietimermodule. In deze oplossing worden twee applicatietimers gebruikt voor een gegevensupdate-interval.

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

De nRF52 SDK heeft de volledige energiebeheermodule, aangezien BLE-apparaten meerdere maanden op een knoopcelbatterij moeten werken. Energiebeheer speelt een cruciale rol in BLE-toepassingen. De nRF52-energiebeheermodule verwerkt volledig hetzelfde. Hier initialiseren we de Power Management-module van nRF5 SDK

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

De nRF52 SDK heeft een ingebouwd hex-bestand van de Nordic Soft Device-firmware, dat beschikt over Bluetooth low energy centrale en perifere stack. Deze hooggekwalificeerde protocolstack omvat GATT, GAP, ATT, SM, L2CAP en Link Layer. Hier volgen we de initialisatiesequentie, die nRF5 BLE Radio Stack (Nordic Soft Device) geïnitialiseerd

ret_code_t err_code; err_code = nrf_sdh_enable_request (); APP_ERROR_CHECK (err_code); // Configureer de BLE-stack met de standaardinstellingen. // Haal het startadres van het toepassings-RAM op. 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); // Schakel BLE-stack in. err_code = nrf_sdh_ble_enable (& ram_start); APP_ERROR_CHECK (err_code); // Registreer een handler voor BLE-evenementen. NRF_SDH_BLE_OBSERVER (m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);

GAP is verantwoordelijk voor het scannen / ontdekken van apparaten, het tot stand brengen van verbindingen, het beëindigen van de verbinding, het initiëren van beveiligingsfuncties en de configuratie. GAP is uitgerust met belangrijke verbindingsparameters zoals verbindingsinterval, slaaflatentie, supervisietime-out, enz. Hiermee initialiseert u de verbindingsparameters van het Generic Access Profile

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 is verantwoordelijk voor datacommunicatie tussen BLE-randapparatuur en centrale apparaten. De nRF52 GATT-module is handig voor het onderhandelen over en het bijhouden van de maximale ATT_MTU-grootte. Hier initialiseren we de nRF52 SDK Generic Attribute Module, ret_code_t err_code = nrf_ble_gatt_init (& m_gatt, NULL); APP_ERROR_CHECK (err_code);

GATT doet datacommunicatie in de vorm van diensten en kenmerken. Hier initialiseren we de GATT-omgevingsdetectiediensten, waaronder de initialisatie van kenmerken zoals temperatuur en vochtigheid.

ret_code_terr_code; nrf_ble_qwr_init_t qwr_init = {0}; // Initialiseer in wachtrij geplaatste schrijfmodule. 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);

Adverteren speelt een cruciale rol in de BLE-applicatieomgeving. pakketten bevatten informatie over het adrestype, het advertentietype, advertentiegegevens, apparaatfabrikantspecifieke gegevens en scanresponsgegevens. nRF52 SDK uitgerust met een advertentiemodule. Hier doen we de initialisatie van de advertentiemodule met de parameters.

ret_code_terr_code; ble_advdata_t advdata; ble_advdata_t srdata; ble_uuid_t adv_uuids = {{ESS_UUID_SERVICE, BLE_UUID_TYPE_BLE}}; // Bouw en stel advertentiegegevens in. 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; // Stel advertentieparameters in. 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);

De BLE-verbinding wordt afgehandeld en bewaakt met verschillende verbindingsparameters, zoals de updatevertraging van de eerste verbindingsparameters, de volgende opeenvolgende vertragingen, het aantal updates, de callback-functie voor de afhandeling van de verbindingsgebeurtenis en de gebeurtenishandler voor het terugbellen van verbindingsfouten. Hier doen we initialisatie BLE-verbindingsparameters en een callback-gebeurtenishandler voor verbindingsgebeurtenissen en foutgebeurtenissen.

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

Nadat de initialisatie van het systeem is voltooid, beginnen we hier met het adverteren van de BLE-apparaatnaam en capaciteitsinformatie. Vanaf hier is dit randapparaat te zien via de Ble-scanlijst van de 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);

De hoofdlus loopt over een interval van 2 seconden, leest de temperatuur en vochtigheid af en wordt bijgewerkt naar een aangesloten smart-apparaat met behulp van lezen of notificatie

voor (;;) { uint16_t temperatuur, vochtigheid; DHTxx_ErrorCode dhtErrCode; idle_state_handle (); if (updtmrexp) { dhtErrCode = DHTxx_Read (& temperatuur & vochtigheid); if (dhtErrCode == DHT11_OK) { NRF_LOG_INFO ("Temperatuur:% d Vochtigheid:% d \ n", temperatuur, vochtigheid); if (temp_notif_enabled) { ble_ess_notify_temp (m_conn_handle, & m_ess, temperatuur); } anders { ble_ess_update_temp (& m_ess, temperatuur); } if (humid_notif_enabled) { ble_ess_notify_humid (m_conn_handle, & m_ess, vochtigheid); } anders { ble_ess_update_humid (& m_ess, vochtigheid); } } updtmrexp = false; } }

Ons programma testen met nRF Connect

nRF Connect is een krachtige Bluetooth-tool met laag energieverbruik waarmee u de BLE-randapparatuur kunt scannen en verkennen. nRF Connect voor mobiel ondersteunt een breed scala van door Bluetooth SIG goedgekeurde standaardprofielen. We kunnen ons programma verifiëren door dit te gebruiken, nadat we de app hebben geïnstalleerd, kunnen we het nRF52-bord met onze telefoon koppelen door te scannen naar BLE-apparaten in de app. Binnen het kenmerk Omgevingsdetectie kunnen we zien dat de temperatuur- en vochtigheidswaarden worden bijgewerkt, zoals weergegeven in de onderstaande afbeeldingen.

Hariharan Veerappan is een onafhankelijke consultant met meer dan 15 jaar ervaring in embedded productontwikkeling. Hij biedt adviesdiensten op het gebied van embedded firmware / Linux-ontwikkeling, hij geeft ook bedrijfs- en online trainingen. Hariharan heeft een Bachelor of Engineering in de discipline Electronics & Communication Engineering, door middel van zijn artikelen en tutorials deelt hij zijn ervaringen en gedachten met de lezers van Circuit Digest.