https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/Create a prototype smart home and/or healthcare system for a happier, healthier person or home. Take better care of yourself, a friend, or family member’s physical or mental health. Or create a system which can help out around the house.en-USTelligent Community 12https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/m/managed-videos/151876Sat, 03 Oct 2026 09:22:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:34b422d9-de10-46d6-92cd-8f557b293db8Qbithttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57324/palno-slemon-2-2-configuring-and-validatingSat, 03 Oct 2026 09:11:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:087eb976-b34a-427c-8bbf-dda3c2375293QbitHey this is part 2.2 for my projects Palno and Slemon together they both combine make up an accurate sleep tracker and with the power of UNO Q lets you wake up at the right time so you don`t feel tired and exhausted anymore, you can read the past posts from here: #1 Introduction #2.1 Configuring and Validating In this I will be configuring Arduino UNO Q and HLK-LD2410B the mm wave sensor. 1) Arduino UNO Q It comes pre-installed with debian image you don`t have to do anything at first but later you can update if you want and no cmd is required simply a message will pop-up asking you to update to the latest version, I think there is some sort of bug, sometimes when I had already installed the latest version the install the latest version message pop up but it when I click to continue to just take away time and gives that the latest version is already installed. ( If you have updated it make sure if you are also using the arduino IDE for the sketch that you have installed the latest version of the board also if you don`t , somethings will not work as expected. ) Thank you again to Element14 for awarding me the Arduino UNO Q and selecting me as the winner of the Top Tech voices. As you power it up it will show nice boot animation on the led matrix then heart. You can use it as the standalone computer with a USB-C dongle or connect via usb(c) to your computer and use it. If you are using it with computer as I am, Download the App Labs here. First you connect it to the computer then it will show in the app labs ( be patient it could take up to 40s for the Q to boot up.) Then click on it. give it a name then Setup wifi connection so you flash it remotely. Setup a password that will be used when you are working with the terminal interface if you forget it you can change it in setting. also then it will ask for a restart , after you do it then it will again ask to name it but that doesn`t work.( see below), community.element14.com/.../Screen-Recording-2026_2D00_10_2D00_01-171517.mp4 So unlpug the board then replug it again then it will come to the home page. 2) HLK LD2410B mmWave Sensor: The radar module we are using for the motion tracking while sleep. Its pinout is this: Thanks to shabaz! I will not be using the OUT pin because it doesn`t give that much information only occupied/not occupied. This was the most challenging firstly I was not able to find anything usable other then the post from shabaz did some help you can see here. But I wanted more data then that so I scrolled a lot through datasheets and finally get some some useful datasheets not completely the source code but enough information about how does it function and what does it give in uart. This is the code I developed, I had also used AI because it could take me weeks to build. / * 1 State (0=none 1=moving 2=static 3=both) * 2 MovDist_cm * 3 MovEnergy * 4 StaDist_cm * 5 DetDist_cm * 6 MG0 (gate 0 = 0.00–0.75 m) * 7 MG1 (gate 1 = 0.75–1.50 m) * 8 MG2 * 9 MG3 * 10 MG4 * 11 MG5 * 12 MG6 * 13 MG7 * 14 MG8 * 15 SG3 (static gate 3 onwards — SG0/1/2 removed) * 16 SG4 * 17 SG5 * 18 SG6 * 19 SG7 * 20 SG8 * 21 Light (photosensitive 0–255) * 22 OutPin (0=empty 1=occupied) * */ // ──────────────────────── Config ──────────────────────────── #define LD2410_BAUD 256000 // Change to 115200 for LD2410S/D #define DBG_BAUD 115200 #define RX_PIN 16 #define TX_PIN 17 #define PLOT_MS 50 // 20 Hz output — fast like Arduino plotter #define MAX_GATES 9 #define FRAME_BUF_SIZE 128 // ──────────────────── Protocol bytes ──────────────────────── #define DH0 0xF4 #define DH1 0xF3 #define DH2 0xF2 #define DH3 0xF1 #define DF0 0xF8 #define DF1 0xF7 #define DF2 0xF6 #define DF3 0xF5 #define CH0 0xFD #define CH1 0xFC #define CH2 0xFB #define CH3 0xFA #define CF0 0x04 #define CF1 0x03 #define CF2 0x02 #define CF3 0x01 #define CMD_EN_CFG 0x00FF #define CMD_END_CFG 0x00FE #define CMD_EN_ENG 0x0062 #define CMD_CL_ENG 0x0063 #define CMD_RD_VER 0x00A0 #define CMD_RD_PRM 0x0061 #define CMD_SET_DIST 0x0060 #define CMD_SET_SENS 0x0064 #define CMD_RESET 0x00A2 #define CMD_RESTART 0x00A3 // ──────────────────── Global variables ────────────────────── static uint8_t fb[FRAME_BUF_SIZE]; static uint16_t fbi = 0; static uint16_t fexp = 0; static uint16_t fcnt = 0; static uint8_t hi = 0; static uint8_t hb[4]; static bool isDataFrame = false; enum { ST_HDR, ST_LEN, ST_DATA, ST_FOOT } rxSt = ST_HDR; static bool newData = false; static bool streaming = false; // ← starts false; 'n' enables static bool csvMode = false; // Sensor readings — raw, no ceiling applied static uint8_t g_state = 0; static uint16_t g_movDist = 0; // cm static uint16_t g_movEn = 0; // energy (sensor outputs 0-100) static uint16_t g_staDist = 0; // cm static uint16_t g_detDist = 0; // cm static uint8_t g_maxMov = 8; static uint8_t g_maxSta = 8; static uint16_t g_movG[MAX_GATES]; // per-gate motion energy static uint16_t g_staG[MAX_GATES]; // per-gate static energy static uint16_t g_light = 0; static uint8_t g_out = 0; static unsigned long lastPlot = 0; // ──────────────────── Command helpers ──────────────────────── static void sendCmd(uint16_t word, const uint8_t* dat, uint8_t dlen) { uint16_t ilen = 2 + dlen; uint8_t buf[32]; uint8_t i = 0; buf[i++]=CH0; buf[i++]=CH1; buf[i++]=CH2; buf[i++]=CH3; buf[i++]=ilen&0xFF; buf[i++]=ilen>>8; buf[i++]=word&0xFF; buf[i++]=word>>8; for (uint8_t j=0; j >8),0,0 }; enCfg(); sendCmd(CMD_SET_DIST, v, 18); delay(80); endCfg(); } static void cmdSetSens(uint8_t m, uint8_t s) { uint8_t v[18]={ 0x00,0x00,0xFF,0xFF,0,0, 0x01,0x00,m,0,0,0, 0x02,0x00,s,0,0,0 }; enCfg(); sendCmd(CMD_SET_SENS, v, 18); delay(80); endCfg(); } // ──────────────────── Frame parser ─────────────────────────── static bool match4(const uint8_t* a, uint8_t b0,uint8_t b1,uint8_t b2,uint8_t b3){ return a[0]==b0 && a[1]==b1 && a[2]==b2 && a[3]==b3; } static void parseData() { uint16_t ilen = fb[4] | (fb[5] fbi) return; if (!match4(fb+fp, DF0,DF1,DF2,DF3)) return; const uint8_t* d = fb+6; uint8_t dtype = d[0]; if (d[1] != 0xAA) return; g_state = d[2]; g_movDist = (uint16_t)d[3]|((uint16_t)d[4] = 20) { g_maxMov = d[11]; g_maxSta = d[12]; if (g_maxMov >= MAX_GATES) g_maxMov = MAX_GATES-1; if (g_maxSta >= MAX_GATES) g_maxSta = MAX_GATES-1; uint8_t idx = 13; for (uint8_t i=0; i fbi || !match4(fb+fp,CF0,CF1,CF2,CF3)) return; uint16_t ack = fb[6]|(fb[7] =10) Serial.printf("# FW type=%d V%d.%02X\n",fb[10],fb[11],fb[14]); if (ack==0x0161 && st==0 && ilen>=30) { Serial.printf("# Params: maxMov=%d maxSta=%d timeout=%ds\n", fb[11],fb[12], fb[31]|(fb[32] =2) { fexp=fb[4]|((uint16_t)fb[5] FRAME_BUF_SIZE-12){rxSt=ST_HDR;hi=0;fbi=0;fcnt=0;} else {fcnt=0;rxSt=ST_DATA;} } break; case ST_DATA: if (fbi =fexp){fcnt=0;rxSt=ST_FOOT;} break; case ST_FOOT: if (fbi =4){ if (isDataFrame) parseData(); else parseAck(); rxSt=ST_HDR;hi=0;fbi=0;fcnt=0; } break; } } } // ──────────────────── Output ───────────────────────────────── static void printHeader() { char sep = csvMode ? ',' : '\t'; // Engineering mode columns (22 total — cols 5/16/17/18 removed) Serial.print(F("State")); Serial.print(sep); Serial.print(F("MovDist_cm")); Serial.print(sep); Serial.print(F("MovEnergy")); Serial.print(sep); Serial.print(F("StaDist_cm")); Serial.print(sep); Serial.print(F("DetDist_cm")); Serial.print(sep); // Moving gate energies MG0–MG8 for (uint8_t i=0;i = PLOT_MS)) { lastPlot = millis(); newData = false; outputLine(); } } To extract reliable telemetry without dropping bytes, the firmware processes incoming UART data using a non-blocking finite state machine ( ST_HDR, ST_LEN ST_DATA ST_FOOT ). It continuously inspects the serial stream for the radar's signature 4-byte headers— 0xF4 0xF3 0xF2 0xF1 for active data frames and 0xFD 0xFC 0xFB 0xFA for command acknowledgments. Once a valid payload is buffered and verified against its frame footer, parseData() unpacks state flags, target distances, total motion energy, and individual per-gate thresholds directly into global variables. For easier host synchronization, data streaming remains paused on boot until an 'n' command is sent over the Serial Monitor or through a companion Python script. Once triggered, the sketch streams 22 columns of tab-separated or CSV values at 20 Hz (every 50 ms). This output rate is fast enough for smooth real-time plotting while keeping serial overhead low enough to prevent lag during long sleep-monitoring sessions. You can also adjust parameters interactively without reflashing the board. Simple single-character keyboard inputs let you tweak distance gate sensitivities ( 1 through 5 ), query active firmware parameters, or trigger hardware resets on the fly. This setup makes it simple to capture clean signal data for the Arduino Serial Plotter or stream it into external Python scripts for further sleep-stage analysis. This the testing data I captured: community.element14.com/.../ld2410_5F00_recording_5F00_20261002_5F00_194308.mp4 In the next part I will collect data to train the models and understand it to make the suitable algorithm. Thank you for reading !esp32smart home & healthcarehttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57317/vitarf---part-5---matter-over-thread-on-nrf54l15-with-home-assistant/238509Fri, 02 Oct 2026 06:09:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:d9a0b1ae-ef52-4c53-9ca8-635cc019d76farvindsaof course i will..https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57317/vitarf---part-5---matter-over-thread-on-nrf54l15-with-home-assistant/238465Wed, 30 Sep 2026 13:51:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:3fff76ed-20e6-4db7-b1a3-07c9a61d0080embeddedguyFor learning Zephyr, you can contact me.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57315/palno-slemon-2-1-configuring-and-validating/238458Wed, 30 Sep 2026 10:08:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:04d272d3-a82c-4bb0-b7b6-827f2106efb6QbitThanks, I will try to make graph using py, the graph you see is from the Serial Plotter.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/m/managed-videos/151872Wed, 30 Sep 2026 05:17:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:74677725-e559-45d6-b0df-e95671eaaa73arvindsahttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57317/vitarf---part-5---matter-over-thread-on-nrf54l15-with-home-assistantWed, 30 Sep 2026 05:15:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:8dcd4839-cf87-43ed-a3ee-88940f3de94farvindsaRecap: I am building a wireless vitals sensor node (heart rate, SpO₂, temperature) that reports over BLE into Home Assistant as a smart way to keep watch over our loved ones, built up in three phases — DK bring-up, a custom miniaturized nRF52832 PCB, then a Matter over Thread proof of concept. Past Posts VitaRF - Part 1 - The Plan VitaRF - Part 2 - Interface MAX30102 on NRF52 VitaRF - Part 3 - Interfacing MAX30208 on NRF52 VitaRF - Part 4 - Sending Sensor Data to Home Assistant via BLE on NRF52 I still have not started on the PCB design as I had promised. Why? Because I received the nRF54L15 DK as a prize from the How To Build A Smart Home Device With Matter webinar, and the excitement of trying out the new nRF54 eclipsed the responsible side of my brain, which kept shouting: the PCB takes time to manufacture! So I made a compromise - I would put off the PCB design for just one day. In my defense, I have been using the nRF52 series for nearly 10 years and never had a solid reason to buy a development kit for the newer series. community.element14.com/.../unbox_2D00_nrf54l15.mp4 Why Matter over Thread at all BLE broadcasting works as I showed in my previous post, but it is one-way. Matter is the standards-based version of the same idea: any Matter controller can talk to the device, it can be commissioned by scanning a code, and Thread means it sits on a low-power mesh instead of needing to be in BLE range of one particular box. The parts, for this phase: nRF54L15 DK ( Nordic product page ) - the Matter device itself. The sensor node. nRF52840 DK ( Nordic product page ) - not a Matter device at all. It runs OpenThread's "radio co-processor" firmware, which turns it into nothing but an 802.15.4 radio that a computer drives over USB. That is what gives Home Assistant's side a Thread radio. Toolchain: the nRF5 SDK is out Everything so far in this project used the legacy nRF5 SDK 17.1.0. That SDK has no nRF54 support at all - no device headers, no SoftDevice. This part needed the nRF Connect SDK (NCS), which is based on Zephyr. I installed v3.4.1 with Nordic's standalone nrfutil and its sdk-manager . The installation procedure is well documented at https://nrfconnectdocs.nordicsemi.com/ncs/latest/nrf/installation/install_ncs.html . ralphjy commented over at the webinar page that the SDK was nearly 10 GB. I was genuinely shocked when I heard that, and I wished he were joking, as my laptop did not have that much free space. So I had to do this on my desktop, which means I can't do any development on the go. The firmware: two stock samples, no code changes Normally, the first thing I flash to test a toolchain install is Blinky. But how lucky I was to find that there was a matter folder in the samples. It turned out that I did not need to write a single line of code for this post. Both boards run unmodified NCS samples: nRF54L15 DK: nrf/samples/matter/temperature_sensor - Matter over Thread, configured as a sleepy end device nRF52840 DK: nrf/samples/openthread/coprocessor - the RCP (Radio Co-Processor). Its serial link to the host runs at 1,000,000 baud with hardware flow control, which matters later. Check out the samples here: https://github.com/nrfconnect/sdk-nrf/tree/v3.4-branch/samples (Important: use the v3.4 branch.) # run from inside the NCS workspace, through the toolchain launcher west build -p auto -b nrf54l15dk/nrf54l15/cpuapp -d build_54l15_temp_sensor nrf/samples/matter/temperature_sensor west build -p auto -b nrf52840dk/nrf52840 -d build_52840_rcp nrf/samples/openthread/coprocessor west flash -d build_54l15_temp_sensor --dev-id west flash -d build_52840_rcp --dev-id I am using the --dev-id argument only because I had both DKs plugged in at the same time. Using nRF Connect to validate Matter? When I scan with nRF Connect on my phone, the device shows up as MatterTemperature , and its GATT database has exactly three services: Generic Attribute, Generic Access, and an "Unknown Service" with UUID 0xFFF6 . As far as I can tell from the spec, 0xFFF6 is the Matter BLE commissioning service, which means I am on track. The DK also prints its own setup payload on its serial console at boot, which is handy: SetupQRCode: [MT:M1TJ342C00KA0648G00] Manual pairing code: [34970112332] The Thread side To have a Thread network at all, something has to be the border router. I ran the official OpenThread Border Router (OTBR) Docker image on my desktop PC with the nRF52840 DK plugged into it over USB, following the openthread.io Docker guide loosely. The container needed two host settings to forward network traffic: sudo sysctl -w net.ipv6.conf.all.forwarding=1 net.ipv4.ip_forward=1 sudo modprobe ip6_tables ip6table_filter Without the modules the container just dies with Failed to start firewall service . Then: docker run -d --name otbr --restart unless-stopped --network host --privileged --dns=127.0.0.1 \ -v /dev/ttyACM3:/dev/ttyACM3 openthread/otbr:latest \ --radio-url "spinel+hdlc+uart:///dev/ttyACM3?uart-baudrate=1000000&uart-flow-control" \ --backbone-interface eno1 --debug-level 4 /dev/ttyACM3 is the nRF52840 DK's serial port (yours may differ). Then I formed the network: docker exec otbr ot-ctl dataset init new docker exec otbr ot-ctl dataset networkname VitaRF docker exec otbr ot-ctl dataset commit active docker exec otbr ot-ctl ifconfig up docker exec otbr ot-ctl thread start docker exec otbr ot-ctl state # -> leader leader , on channel 14. The Thread network is called VitaRF , because of course it is. Home Assistant side: Matter server and the OTBR integration Post 4's Home Assistant is on the UNO Q. For this phase I ran a second one, in Docker on the same desktop as the border router, so everything talks over localhost . It is Home Assistant Container again, which has no add-on store, so Matter needs its own container - the python-matter-server - that Home Assistant connects to: docker run -d --name matter-server --restart unless-stopped --network host \ --security-opt apparmor=unconfined -v /home/arvind/homeassistant/matter:/data \ ghcr.io/home-assistant-libs/python-matter-server:stable \ --storage-path /data --paa-root-cert-dir /data/credentials --primary-interface eno1 docker run -d --name homeassistant --restart unless-stopped --network host --privileged \ -e TZ=Asia/Kolkata -v /home/arvind/homeassistant/config:/config \ ghcr.io/home-assistant/home-assistant:stable --primary-interface eno1 is there because the Docker bridges on my machine were otherwise confusing the mDNS discovery. During onboarding Home Assistant already noticed there were Matter and Thread things around: Then I added two integrations by hand: Matter, pointed at the server ( ws://localhost:5580/ws ), and Open Thread Border Router, pointed at the OTBR's REST API on http://127.0.0.1:8081 . That second one works with a plain localhost address only because everything shares the host network. Once the OTBR integration is in, the Thread page shows the VitaRF network as the preferred one, with my border router under it: Commissioning from the phone Commissioning goes through the Home Assistant Companion app on my phone: Companion app -> Matter panel -> Add device: Then I scanned the QR code (or use "Set up without QR code" and type the manual pairing code). First error: "requires a Thread border router" After the pairing code the phone said " Your device requires a Thread border router " , even though I had one running. Home Assistant knew about the border router, but the phone did not have the Thread network's credentials. The fix was in the Companion app: Settings -> Companion app -> Troubleshooting -> Sync Thread credentials, which pushes the preferred network from Home Assistant to the phone. It confirms with "Added network from Home Assistant to this device": Second error, and the part I can't fully explain After that, the pairing got further and then stalled on "Checking connectivity to Thread network VitaRF" . The animation kept running for a long time, five minutes or more, and nothing else happened. This is the part I could not resolve just by looking at the phone, so I checked what I could from the computer side: ot-ctl said the border router was leader and its border routing was running. The PC could ping the phone, and the PC could see mDNS from other Wi-Fi devices. Nothing about the phone showed up in the OTBR or Home Assistant logs, so the phone never got as far as talking to the border router. So the network path looked healthy from my side and the phone still hung inside that Google screen, which does not write anything to the Companion app's log (I checked - it logs the handoff and then goes silent until I cancel). I suspected a network issue I was not aware of. My phone is connected to the main router's Wi-Fi, but my desktop reaches the main router via an Ethernet switch and a range extender that bridges the main router's Wi-Fi to the switch. So I tried connecting my phone to my range extender's Wi-Fi while the screen said "Checking connectivity...". I immediately got a different screen: "Insecure connection blocked". My Home Assistant is served over plain http:// on the local network, and the app was refusing to use it there. It offered an "Open settings" button, which led to a "Let us help secure your remote connection" page, where I changed the option from "Most secure" to "Less secure: do not allow this app to know when you're home", and hit Save: After that, it worked. I made two changes, and I don't know which one was the fix. It could be that the phone needed to be on the same side of the extender as my PC for the Thread discovery to work, or it could be that the blocked http connection was what had been silently hanging the earlier attempts, or both. It works "Device connected", then Home Assistant asks where to put it (I picked Living Room), and the device page shows a Matter Temperature Sensor by Nordic Semiconductor ASA, firmware 3.4.1+0, with a temperature reading: That 8.0 C is the sample's simulated ramp, not the room. I also asked the Matter server directly and it reports the node as available, on the VitaRF Thread network, with the value changing over time (I saw it go 3 C, 7 C, then 11 C between checks), so it is updating live. Final notes The path is proven end to end: nRF54L15 (Matter, Thread) -> nRF52840 (RCP) -> OpenThread Border Router -> Matter server -> Home Assistant, commissioned from the phone. Being an absolute novice in Thread, Matter and Home Assistant, I relied quite heavily on Claude to help me bring up the OpenThread Border Router and the kernel + firewall settings it needed. On the coding side, I used the samples as-is. Technically, I learnt very little, but this was more about getting started on my journey into the nRF54. I need to learn Zephyr and how the nRF Connect SDK is organized, and dive deeper into Thread and Matter - a journey that will continue well beyond this design challenge.design challengenordicmatternrf54smart home & healthcarehttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57315/palno-slemon-2-1-configuring-and-validating/238441Tue, 29 Sep 2026 20:24:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:19af158a-86dd-46d1-b145-2bd4d73800b2DABNice update. You might want to use a higher contrast color on your graphs.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57315/palno-slemon-2-1-configuring-and-validatingTue, 29 Sep 2026 16:46:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:b3f227ba-93c4-4312-80a7-76e2110915c0QbitThe Kit (" The upper blue roll is the substitute for the thermal tape. The role on the side is the 3M EM25TP-0050 EMI Absorber. The big box is the Analog Devices MAX30208EVSYS# Evaluation Kit The Little black box is the Analog Devices MAXREFDES117# Reference Design Board") This is the kit, I received it on 23rd but from them I spend time configuring them and in this forum I will show I come up with. And By the way great thanks to Element14 for the swag :) Configuring 1) Analog Devices MAX30208EVSYS# Evaluation Kit : This is the kit: Firstly I tested it with the pre-flashed MAX32630FTHR MCU board, it was surprisingly easy put the MCU in the bottom of the board in J2 and J1, then put the flex ribbon in the J9. If you haven`t altered any caps to switch mode then it will work fine, and If you have messed them a bit. make sure. Caps are put as in the image Then go to https://www.analog.com/en/resources/evaluation-hardware-and-software/evaluation-boards-kits/max30208evsys.html#eb-overview and scroll down to bottom and download the the tool. And open, there is no need to install extra diver. And you will start seeing real time temperature readings Unfortunately the MCU get damaged( while I was testing it with the battery the battery socket had the opposite pins, and there was no diode to protect the internals, I tried my best to find the real damage but nothing was seeming to work, and I decide to leave that for know and else use the Arduino UNO Q as the controller only. ) Using it with our own platform I was not able to find the frimware that come preinstalled in the MCU after spending the whole evening also. But with the I had taken a screenshot of the registered address so I was able to reconstruct the sketch. Else if your are using my code you do not need this to configure it. Wire as shown(using J10): GPIO1/3 -> EMPTY SDA/GPIO2 -> To your MCU`s SDA SCL/GPIO1 -> To your MCU`s SDA VDD/DQ -> 3.3v GND -> GND This is how I implement the addresses. // --- MAX30208 Register Definitions --- #define MAX30208_I2C_ADDR 0x50 // Default address you will get this if you run a i2c scan #define REG_STATUS 0x00 // Status register #define REG_FIFO_DATA 0x08 // FIFO temperature data register #define REG_TEMP_SETUP 0x14 // Temperature setup register (CONVERT_T) #define REG_PART_ID 0xFF // Part ID register (Expected value: 0x30) Reading the data float readTemperature() { // 1. Trigger single-shot conversion (write CONVERT_T bit in reg 0x14) Wire.beginTransmission(MAX30208_I2C_ADDR); Wire.write(REG_TEMP_SETUP); Wire.write(0xC1); if (Wire.endTransmission() != 0) { return -999.0f; // Communication error } // 2. Wait for conversion completion (~15ms typical according to MAX30208 datasheet) delay(20); // 3. Pointer setup to read 2 bytes from FIFO_DATA register (0x08) Wire.beginTransmission(MAX30208_I2C_ADDR); Wire.write(REG_FIFO_DATA); if (Wire.endTransmission(false) != 0) { return -999.0f; } // 4. Request 2 bytes (MSB and LSB) Wire.requestFrom((uint8_t)MAX30208_I2C_ADDR, (uint8_t)2); if (Wire.available() == 2) { uint8_t msb = Wire.read(); uint8_t lsb = Wire.read(); // Reconstruct signed 16-bit 2's complement integer int16_t rawTemp = (int16_t)((msb GND VIN -> 3.3v or 5v ( due to the onboard logic level translator) SCL -> SCL SDA -> SDA INT-> To any gpio you want , I am using 4 the setup Firstly I tried to get raw data out of the sensor. The code: #include // from the i2c scan sensor's address #define MAX30102_ADDR 0x57 // MAX30102 Register Addresses(from the design files) #define REG_INTR_STATUS_1 0x00 #define REG_INTR_STATUS_2 0x01 #define REG_INTR_ENABLE_1 0x02 #define REG_INTR_ENABLE_2 0x03 #define REG_FIFO_WR_PTR 0x04 #define REG_OVF_COUNTER 0x05 #define REG_FIFO_RD_PTR 0x06 #define REG_FIFO_DATA 0x07 #define REG_FIFO_CONFIG 0x08 #define REG_MODE_CONFIG 0x09 #define REG_SPO2_CONFIG 0x0A #define REG_LED1_PA 0x0C #define REG_LED2_PA 0x0D #define REG_PILOT_PA 0x10 //optinal pin for multiple devices #define INT_PIN 4 This section sets up the foundational information the ESP32 needs to talk to the sensor. It includes the Wire.h library, which handles the complex timing of the I2C communication protocol. It defines the sensor's physical address ( 0x57 ), which is like a house number on the I2C bus. Without this, the ESP32 wouldn't know who it's talking to. It also creates human-readable labels for the sensor's internal memory slots (registers). Finally, it assigns the INT_PIN label to GPIO 4, which is the wire that the sensor will use to tap the ESP32 on the shoulder when it has new data ready. I developed this code with help of the design file because I was not able to find the datasheet for the board. // helper function to write to a register void writeRegister(uint8_t reg, uint8_t value) { Wire.beginTransmission(MAX30102_ADDR); Wire.write(reg); Wire.write(value); Wire.endTransmission(); } // helper function to read from a register uint8_t readRegister(uint8_t reg) { Wire.beginTransmission(MAX30102_ADDR); Wire.write(reg); Wire.endTransmission(false); Wire.requestFrom((uint8_t)MAX30102_ADDR, (uint8_t)1); if (Wire.available()) { return Wire.read(); } return 0; } These two functions are shortcuts designed to keep the main code clean. Whenever you want to change a setting on the sensor, the Wire library requires a tedious four-step process of opening a connection, aiming at a register, sending the data, and closing the connection. The writeRegister function wraps those four steps into one simple command. Similarly, readRegister handles the multi-step process of asking the sensor for a piece of information and waiting for it to reply, returning the requested byte of data back to you. void setup() { Serial.begin(115200); Wire.begin(); pinMode(INT_PIN, INPUT); Serial.println("Initializing MAX30102..."); // 1. Reset the sensor writeRegister(REG_MODE_CONFIG, 0x40); delay(100); // 2. Initialize with exact settings from the original driver writeRegister(REG_INTR_ENABLE_1, 0xc0); // ... (other configurations) writeRegister(REG_PILOT_PA, 0x7f); // 3. Clear interrupts to start clean readRegister(REG_INTR_STATUS_1); Serial.println("Setup complete. Waiting for data..."); } The setup block runs exactly once when the ESP32 powers on. It starts the serial connection so you can see the text on your computer, and it boots up the I2C hardware pins. It then sends a specific command ( 0x40 ) to reboot the MAX30102 sensor, wiping away any old, corrupted settings. After the reboot, it fires off a rapid sequence of configurations. These commands turn on the red and infrared LEDs, set the sampling speed to 100 times a second, and adjust the brightness of the LEDs so they can penetrate the skin. Finally, it reads the status register once to clear any leftover alerts, leaving the sensor ready to work. void loop() { // Wait for the interrupt pin to go LOW while (digitalRead(INT_PIN) == HIGH) { // Block until new data is ready } // Clear interrupt status registers so the pin goes back HIGH readRegister(REG_INTR_STATUS_1); readRegister(REG_INTR_STATUS_2); // Read 6 bytes of FIFO data (3 bytes Red, 3 bytes IR) Wire.beginTransmission(MAX30102_ADDR); Wire.write(REG_FIFO_DATA); Wire.endTransmission(false); Wire.requestFrom((uint8_t)MAX30102_ADDR, (uint8_t)6); The loop block runs continuously forever. The very first thing it does is get trapped in a while loop, staring at the INT_PIN . The sensor keeps this pin at 3.3V ( HIGH ) normally, but violently yanks it to 0V ( LOW ) the exact millisecond it finishes taking a light reading. Once the pin drops LOW , the code breaks out of the trap. It immediately reads the status registers to acknowledge the alert, which allows the sensor to release the pin back to 3.3V. Now that the code knows data is ready, it points to the sensor's data storage tank (the FIFO) and formally requests exactly 6 bytes of optical data to be sent over the wire. if (Wire.available() == 6) { uint32_t red_val = 0; uint32_t ir_val = 0; uint32_t temp = 0; // Read Red LED data temp = Wire.read(); temp #include "algorithm.h" #include "max30102.h" #include #define INT_PIN 4 #define LED_PIN 2 uint32_t aun_ir_buffer[100]; //infrared LED sensor data uint32_t aun_red_buffer[100]; //red LED sensor data int32_t n_ir_buffer_length; //data length int32_t n_spo2; //SPO2 value int8_t ch_spo2_valid; //indicator to show if the SPO2 calculation is valid int32_t n_heart_rate; //heart rate value int8_t ch_hr_valid; //indicator to show if the heart rate calculation is valid uint8_t uch_dummy; // the setup routine runs once when you press reset: void setup() { Wire.begin(); maxim_max30102_reset(); //resets the MAX30102 // initialize serial communication at 115200 bits per second: Serial.begin(115200); pinMode(INT_PIN, INPUT); //pin connects to the interrupt output pin of the MAX30102 pinMode(LED_PIN, OUTPUT); delay(1000); maxim_max30102_read_reg(REG_INTR_STATUS_1,&uch_dummy); //Reads/clears the interrupt status register while(Serial.available()==0) //wait until user presses a key { Serial.write(27); // ESC command Serial.print(F("[2J")); // clear screen command Serial.println(F("ESP32")); Serial.println(F("Press any key to start conversion")); delay(1000); } uch_dummy=Serial.read(); maxim_max30102_init(); //initialize the MAX30102 } // the loop routine runs over and over again forever: void loop() { int32_t i; n_ir_buffer_length=100; //buffer length of 100 stores 4 seconds of samples running at 25sps //read the first 100 samples, and determine the signal range for(i=0;i<n_ir_buffer_length;i++) { while(digitalRead(INT_PIN)==1); //wait until the interrupt pin asserts maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i)); //read from MAX30102 FIFO Serial.print(F("red=")); Serial.print(aun_red_buffer[i], DEC); Serial.print(F(", ir=")); Serial.println(aun_ir_buffer[i], DEC); } //calculate heart rate and SpO2 after first 100 samples (first 4 seconds of samples) maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_spo2, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid); //Continuously taking samples from MAX30102. Heart rate and SpO2 are calculated every 1 second while(1) { i=0; //dumping the first 25 sets of samples in the memory and shift the last 75 sets of samples to the top for(i=25;i<100;i++) { aun_red_buffer[i-25]=aun_red_buffer[i]; aun_ir_buffer[i-25]=aun_ir_buffer[i]; } //take 25 sets of samples before calculating the heart rate. for(i=75;i<100;i++) { while(digitalRead(INT_PIN)==1); digitalWrite(LED_PIN, !digitalRead(LED_PIN)); maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i)); //send samples and calculation result to terminal program through UART Serial.print(F("red=")); Serial.print(aun_red_buffer[i], DEC); Serial.print(F(", ir=")); Serial.print(aun_ir_buffer[i], DEC); Serial.print(F(", HR=")); Serial.print(n_heart_rate, DEC); Serial.print(F(", HRvalid=")); Serial.print(ch_hr_valid, DEC); Serial.print(F(", SPO2=")); Serial.print(n_spo2, DEC); Serial.print(F(", SPO2Valid=")); Serial.println(ch_spo2_valid, DEC); } maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_spo2, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid); } } It pulls in standard Arduino libraries along with Maxim's sensor driver and algorithm header files to handle the signal processing math behind calculating SpO2 and pulse rates. When the ESP32 powers on, it sets up the I2C bus, resets the sensor, and prepares the interrupt and LED pins. It holds off on reading data until you press a key in the Serial Monitor, giving you time to open the terminal. Once triggered, it initializes the sensor settings and collects an initial set of 100 samples about 4 seconds worth of red and infrared light readings—to calculate your baseline heart rate and blood oxygen percentage. After that baseline is set, the code enters an infinite loop using a sliding window technique. Every second, it discards the oldest 25 samples, shifts the remaining 75 samples forward, and fills the gap with 25 fresh readings. With every new sample read, it flashes an onboard LED and streams the optical raw values, heart rate, SpO2, and accuracy validity flags back to your serial console. Once the batch of 25 new samples is captured, it reruns the calculation algorithm to keep your vitals updated in real time. These are the readings : ( I tried my best to make keep my finger consistent but there was still a little bit shake, so I was not able to achieve high accuracy, I will improve this in the upcoming posts.) I have tested it on the Esp32 for now but the final version will be with the Arduino UNO Q. And you can checkout https://www.analog.com/media/en/technical-documentation/data-sheets/max30208-ev-sys.pdf for more details. In the next post I will configure the Arduino UNO Q, MM wave radar sensor and the E- ink display and MPU6500(I have added to further enhance my project). Firstly I had decided to finish it in this post only, but I wasted a lot of time resolving the issue with the MAX32630FTHR MCU board, but I still was not able to resolve it. Do you faced the same issue with the MAX32630FTHR MCU board, your help will matter a lot. And at last there is the question, Am I allowed to not use the MAX32630FTHR MCU board or I had to buy new one in order to qualify, because I had damaged it. Thank you for giving your time reading it!esp32maxrefdes117smart home & healthcarehttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57283/edgecare-phase-2---setup-i2c-read-max30100-and-create-vi-in-labview/238380Sat, 26 Sep 2026 10:03:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:f159eb4e-3cab-4457-b88d-cf92f7e4fed2QbitNice update mihaita802003 ! But in my case it worked fine without the pull up resistors.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57301/palno-slemon-1-introduction/238379Sat, 26 Sep 2026 09:58:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:accfce9f-7215-4314-ba2d-2307c32acca1QbitI am not that good at naming so whatever came to my mind I named it: Palm -> Palno and "Sle"ep + "m"ode + "on" -> Slemon.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57295/healthguard-1---experimenting-with-max30208evsys/238378Sat, 26 Sep 2026 07:10:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:a903ad87-c484-4d83-bf6d-64e26dfb423etaifurHi arvindsa , I have identified the problem and solved it. I was able to read the temperature data successfully. The problem is not with the DS2484 IC, but it is related to the flex PCB connector. I opened the flex PCB from the connector and reconnected it carefully. The problem was solved. Even I was able to read both the IC addresses using I2C scanner code and an ESP32 board.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57301/palno-slemon-1-introduction/238377Fri, 25 Sep 2026 17:18:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:bd0b01d1-b0b6-4719-930a-ba2154004afcarvindsaI'd love to know how you came up with the name Palno and Slemonhttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57301/palno-slemon-1-introductionFri, 25 Sep 2026 16:37:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:870af5b6-8556-4eac-bcaa-2f834ff20037QbitThe Project Palno and Slemon is a project designed to solve one of my most exhausting problems and serves as my entry for the Smart Home & Healthcare Challenge. The core issue I am tackling is poor sleep quality. Sleeplessness isn't caused only by a lack of sleep; it is also heavily impacted by the sleep stage in which we wake up. This is why we sometimes feel completely refreshed despite fewer hours of sleep, yet feel exhausted even after sleeping for many hours. While the most accurate way of detecting sleep stages is EEG, it isn't practical for daily personal use. After several days of research, I initially considered using blood oxygen levels and heartbeat tracking. However, realizing this alone wouldn't provide enough accuracy, I decided to also measure body movement using a mmWave radar sensor. Combining all these parameters will allow me to achieve a reasonable degree of accuracy, helping ensure I no longer wake up feeling tired. Additionally, I am integrating a temperature sensor for smart climate control, which will optimize sleep quality even further and support the main goal of this project. Project Architecture Slemon Main Brain: Arduino Uno Q (4GB) (A huge thanks to element14 for selecting me as a Top Tech Voices winner, which allowed me to get this!) Temperature Sensing: MAX30208EVSYS board paired with the MAX32630FTHR microcontroller for precise 0.1°C accuracy. (Thank you for providing this in the kit!) Display: 3.5-inch e-ink display to show information without causing eye strain. Movement Sensing: HLK-LD2410 24GHz mmWave sensor. (Special thanks to @shabaz for the extremely helpful blog post!) Palno Wireless Transfer: ESP32 for compact, low-power data transmission. Biometrics: MAXREFDES117 for precise SpO2 and BPM readings. (Thank you for adding this to the kit as well.) All housed under the protection of 3M EM25TP-0050 EMI Absorber. Implementation Plan Phase 1: Configuring and validating every individual component before system integration. Phase 2: Integrating the components together and writing basic firmware. Phase 3: Sourcing, collecting, and labeling data, then building the algorithm to make the data usable. Phase 4: Training the model and developing the final firmware. Phase 5: System verification and performance validation. Phase 6: Building the enclosure. Phase 7 (Final post with Blog): Building the user interface in both LabVIEW and web interface. The kit has arrived, and I will be posting the configuration and setup post soon. (Sorry this post is rewritten by AI because there was and error coming while posting no matter what I did it was not resolving, but its generated from my original written plan. And because of it I had also not included images.) Thank you for reading! Please let me know if you have any suggestions to make it even better.maxrefdes117e14-smart home & healthcaremax30208evsyshttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57254/vitarf---part-1---the-plan/238373Fri, 25 Sep 2026 14:25:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:2e33281d-4509-4312-8fc8-9e63a03f8112QbitThank you for asking!https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57295/healthguard-1---experimenting-with-max30208evsys/238345Thu, 24 Sep 2026 05:44:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:4bcde1a9-9b49-438f-b2dd-aba717f0e926arvindsataifur try removing the DS2428 (i forgot the number) chip on the interface board. I was trying to run an i2c scanner but nothing. Although my symptoms was that the SCL line was being clamped low.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57295/healthguard-1---experimenting-with-max30208evsysThu, 24 Sep 2026 04:06:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:b4d61703-02eb-4a71-abd1-555231367c48taifurI just received the kit for the Smart Home & Healthcare Design Challenge, which includes the MAX30208 Evaluation Kit. The evaluation system consists of two boards connected through headers: a MAX32630FTHR microcontroller board and a MAX30208 interface board. The EV system also includes a flexible PCB, with the MAX30208 body temperature sensor located at one end of the flex PCB. At first glance, I did not realize that the sensor was mounted directly on the flex PCB. I initially assumed that the flex PCB was simply a connector used to interface with the microcontroller board. However, after reading the user manual carefully, I realized that the MAX30208 sensor itself is mounted on the flex PCB. The MAX32630FTHR comes pre-programmed to interface the sensor module with the PC software. Before proceeding with any modifications or development, I was curious to test the sensor using the provided PC software. So, I downloaded the software from the following link: https://www.analog.com/en/resources/evaluation-hardware-and-software/evaluation-boards-kits/max30208evsys.html#eb-overview and followed the user guide to read the sensor data. After installing the software tool, I ran it and got the following interface. Since I had not yet connected the kit, no device was detected by the software. After connecting the board, the connection status changed, indicating that the board was recognized, but I still could not obtain any temperature data—the temperature sensor was not detected. I checked the jumper configuration and tried changing the jumper positions as a troubleshooting step. However, despite these attempts, I was still unable to get any temperature readings from the sensor. I also checked the SCL and SDA lines and confirmed that both pins are properly pulled high. However, despite verifying the I²C connections, it remains unclear why the temperature sensor is not being detected by the software. In the next step, I will try to connect the sensor board to the Arduino to read the temperature data.e14-smart home & healthcaremax30208evsysmax30208analog devicessmart home & healthcarehttps://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57293/vitarf---part-4---sending-sensor-data-to-home-assistant-via-ble-on-nrf52/238336Wed, 23 Sep 2026 11:03:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:7cc3a032-eabf-4493-9d06-843595c971e6arvindsaThanks. Finally able to put the extra UNOs to work.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57293/vitarf---part-4---sending-sensor-data-to-home-assistant-via-ble-on-nrf52/238335Wed, 23 Sep 2026 10:36:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:6167e321-c96e-46fa-b0c2-ff034bfb45a0embeddedguyGood project, nice post.https://community.element14.com/challenges-projects/design-challenges/smart-home-healthcare-challenge/f/forum/57293/vitarf---part-4---sending-sensor-data-to-home-assistant-via-ble-on-nrf52Wed, 23 Sep 2026 04:51:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:9a69c985-edb4-4c34-a276-e9244a4fdfa6arvindsaRecap: I am building a wireless vitals sensor node (heart rate, SpO₂, temperature) that reports over BLE into Home Assistant as your smart way to keep watch over our loved ones, built up in three phases — DK bring-up, a custom miniaturized nRF52832 PCB, then a Matter over Thread proof of concept. Past Posts VitaRF - Part 1 - The Plan VitaRF - Part 2 - Interface MAX30102 on NRF52 VitaRF - Part 3 - Interfacing MAX30208 on NRF52 In this post, I will be exploring how I paired Home assistant with the BLE beacon data. Post 3 closed with both sensors reading independently on the nRF52832 DK. I wanted to start with PCB Design, But I have to a little more research before it. The obvious next step is BLE into Home Assistant. UNO Q is all the rage now The UNO Q is a Linux-capable board (aarch64, Debian 13 trixie under the hood) with Docker and Docker Compose already on it, so spinning up an Home Assistant Container should be easy, and With Qualcomm investing quite a lot on marketing for Uno Q, I should ride the wave. There's also a practical reason to lean on the UNO Q here rather than my Radxa: I've got a handful of UNO Qs but only one Radxa Q6A, and I'd rather keep that one free for something that actually needs its extra power punch. tech_nickk's Hackster writeup on running Home Assistant on the UNO Q via Docker plus MQTT was good confirmation that UNO Q is up for the job. But instead of a command, I went with a compose file Commands, in order: mkdir -p ~/homeassistant/config cd ~/homeassistant nano docker-compose.yml # docker-compose.yml content below docker compose pull docker compose up -d services: homeassistant: container_name: homeassistant image: ghcr.io/home-assistant/home-assistant:stable volumes: - ./config:/config - /etc/localtime:/etc/localtime:ro - /run/dbus:/run/dbus:ro restart: unless-stopped privileged: true network_mode: host I relied on AI to generate the compose file. Also I saw the first 10minutes of Ultimate Home Assistant Beginner’s Guide! at https://www.youtube.com/watch?v=Z4gvkmJ8q48 . Just enough to get an understanding of the Home assistant. It seemed pretty straightforward to me. network_mode: host and privileged: true apparently is needed in the compose file so that the container gets direct access to the board's onboard Bluetooth adapter. It's importance came to me in hindsight. Once the pull finally finished, docker compose up -d came back in about a second and onboarding started right away - welcome screen, then account setup: Then this, still inside onboarding, before I'd touched any integration settings myself: HA had already found the Bluetooth integration as a compatible device on its own, off the UNO Q's onboard adapter. Perfecto That's Home Assistant installed. Now to give it something real to talk to. One problem was that the disk went from 4.2GB free to 1.6GB free, though memory was only around 800gb. I still have to see the memory usage after some time of usage. I also am pretty sure the linux will soon eat up the remaining 1.6Gb. BTHome instead of a connectable GATT service Home Assistant's Bluetooth integration has built-in, zero-config support for BTHome-formatted advertisements (bthome.io) - it should auto-discovers the device from the broadcast alone, no pairing, no custom integration. I am quite familiar with the nRF5 SDK which has ble_app_hrs example for the standard Bluetooth Heart Rate Service (GATT, UUID 0x180D), which I can simply paste into my existing sensor integration code and flashed it, but Home Assistant core has no built-in integration - that would mean writing a custom HA component just to get the data out of the BLE beacon. Getting the wire format right With no previous experience, I went through the bthome.io/format page. Temperature property existed but not SPO2 or Heart rate, I thought it would be based on GATT services. The Service Data UUID should be 0xFCD2 to be recognized as BTHome Compliant beacon. The temperature object id is 0x02, signed int16, factor 0.01, degrees C. I googled the nativity of the developer of BTHome - Ernst Klamer, He is from Netherlands and hence the SI units of Temperature. HR value will have to go out as BTHome's generic "count" object (0x09, uint8, factor 1, range 0-255) - bpm fits the range exactly I also came across bthome-ble on GitHub and there too in their const.py no heart rate was mentioned. The firmware I simply took the nRF5 SDK's ble_app_beacon example ( examples/ble_peripheral/ble_app_beacon , PCA10040) and swapped the manufacturer-specific-data AD structure for a BTHome service-data AD structure, and add an app_timer driven refresh every 5s. Building the actual BTHome payload is just this - device info byte, then (object id, value) pairs, straight out of the table I checked above: /* BTHome service data payload: device info byte + (object id, value) pairs. */ #define BTHOME_PAYLOAD_LEN (1 + (1 + 2) + (1 + 1)) static uint8_t m_bthome_payload[BTHOME_PAYLOAD_LEN]; static void bthome_payload_encode(void) { uint8_t idx = 0; m_bthome_payload[idx++] = BTHOME_DEVICE_INFO_UNENCRYPTED_V2; m_bthome_payload[idx++] = BTHOME_OBJ_TEMPERATURE; m_bthome_payload[idx++] = (uint8_t) (m_dummy_temp_centidegrees & 0xFF); /* LSB first (little-endian). */ m_bthome_payload[idx++] = (uint8_t) ((m_dummy_temp_centidegrees >> 8) & 0xFF); m_bthome_payload[idx++] = BTHOME_OBJ_COUNT_U8; m_bthome_payload[idx++] = m_dummy_hr_bpm; } And the timer callback that walks the dummy values every 5s and pushes a fresh advertisement: static void dummy_timer_handler(void * p_context) { UNUSED_PARAMETER(p_context); int16_t temp_step = (int16_t) (next_rand() % 21) - 10; /* +/- 0.10 degrees C. */ m_dummy_temp_centidegrees += temp_step; if (m_dummy_temp_centidegrees 3850) m_dummy_temp_centidegrees = 3850; int8_t hr_step = (int8_t) (next_rand() % 5) - 2; /* +/- 2 bpm. */ int16_t new_hr = (int16_t) m_dummy_hr_bpm + hr_step; if (new_hr 110) new_hr = 110; m_dummy_hr_bpm = (uint8_t) new_hr; bthome_payload_encode(); advertising_data_set(false); } next_rand() is a tiny linear congruential generator which is quite fast. I checked the beacon data using nRF Connect on my phone - the live scan on the left, the raw AD structure breakdown on the right, Sweet - Working on the first try. Well, Actually my first try was to send a static value, Only in the next step I added the random generator. VitaRF-Dummy , MAC E2:3E:96:D7:7E:B6 , service data UUID 0xFCD2 , 1000ms advertising interval - matches the firmware source. Three AD structures, exactly as built: Flags ( 0x01 , BR/EDR not supported), Service Data 16-bit UUID ( 0x16 , UUID 0xFCD2 + payload 40 02 56 0E 09 48 ), and Complete Local Name ( 0x09 , "VitaRF-Dummy"). Decoding that payload by hand: 0x40 is the device-info byte, 0x02 56 0E is the temperature object (little-endian 0x0E56 = 3670 = 36.70C), 0x09 48 is the count object ( 0x48 = 72). Matches the firmware's startup constants exactly. It shows up in Home Assistant Settings -> Devices and Services -> Integrations, under Discovered: VitaRF-Dummy 7EB6 under BTHome, sitting right next to the Bluetooth integration that was already configured. Hit Add, and it's a device with real sensor readings: Temperature 36.7C, Count 72. Straight out of the box picked up by the UNO Q's onboard hci0 Left it running for a bit and checked the history graphs afterward, Count on the left and Temperature on the right: The Graph above shows Count (heart Rate) walking 72 down to 56, Temperature walking 36.7C up to 37.4C and then down. Now for a longer 2-hour window: The Values kept changing regularly for the full two hours, no flatlines, no gaps Code The Full code for all the posts till now will be at https://gitlab.com/arvindsa/vitarf-e14 Final notes Home Assistant is running on the Arduino UNO Q with Docker, and a dummy BLE broadcaster on the nRF52832 DK proved the whole path end to end: nRF52832 -> BTHome advertisement -> UNO Q's onboard Bluetooth adapter -> Home Assistant. This was an easy post. With major time went solely to understand the BTHome format.design challengehome assistantnordicnrf52uno qarduinosmart home & healthcarelinux