Created November 12, 2023

5 ways to bork your Zephyr project (with nRF7002 DK)!

"Getting into Zephyr can take quite a lot of time" - I really felt that. This amateur saga shows first few steps in learning nRF7002 DK.

Things used in this project

Hardware components

Nordic Semiconductor nRF7002 Development Kit

DHT11 Temperature & Humidity Sensor (3 pins)

Seeed Studio Grove - OLED Display 0.66" (SSD1306)- IIC - 3.3V/5V

1.8 inch SPI TFT Display ST7735

SparkFun Logic Level Converter - Bi-Directional

Software apps and online services

Nordic Semiconductor nRF Connect SDK

Story

tl;dr

Zephyr is tough, video is out eventually here.

Hardware pitch

"Explore opportunities where navigation, mobility, and communication can be made more efficient or provide assistance to the elderly, disabled, or children."

This simple sentence in contest overview was the main source of inspiration for my project idea and hardware application for "Make it Matter!". One major shared issue unites two of the three target populations: loneliness.

Social isolation is now well-known to significantly increase a person's risk of premature death from all causes. What is worse, loneliness disproportionately affects elderly people and those living with disabilities - the very individuals that may struggle to combat loneliness without external help.

Loneliness is a tough problem to solve. People across the globe have tried numerous approaches, including some ingenious robots and AI-driven gadgets to substitute for human connections. However, I believe nothing can replace interactions with those you love and care about. Instead of looking for a complex solution, I pitched a simple concept that does not re-invent the wheel - it simply reminds you to push it.

nRF7002 DK is the brain of this project. It's role is simple - to be as invisible as possible. Connected to some environmental sensors, it is given a very simple role - to monitor the environment and look for important cues in an elderly or disabled person's home. The information will be converted and sent to the carer, highlighting some crucial information about their dependant's wellbeing and giving a reason or two to get in touch and check-up on them.

Long story short, this seemingly simple solution to a complex problem was one of the 100 pitches that got awarded free hardware. After receiving an SMS from DHL, I couldn't wait to get my hands on the nRF7002 DK, and in a few hours I was setting up my IDE.

Zephyr applications are complex

The first few steps are easy. nRF Connect SDK Fundamentals guides you through VSC plugin installation and shows how to run some simple examples. Blinky and Matter Lightbulb samples all work like a charm, giving you a false impression that the rest of this journey will be smoother than your speedometer arrow going up on an autobahn.

Disillusionment caught up with me the moment I tried interfacing external modules with my new nRF7002 DK. Before digging out my ST7735r display and some jumper wires, I opened the display driver sample, hit the "Build" button... and got a build error. After a few hours on Google and kind help from contest's Discord channel, I realised two crucial things:

1. Any hardware you use has to be defined in a separate Devicetree overlay file, including most of the on-board hardware.

2. There is little-to-no guidance online that shows what exactly this overlay file should include.

In contrast with convenient and simple #include from Arduino IDE, overlay files can require fairly specific detail that you need to dig out of 150-page product manuals (or said Arduino libraries, if you are lazy like me). Overlays can also end up rather complex, with no clear way of understanding which of the variables you find in Zephyr docs need definitions, unless you are lucky enough to find one of the scarce examples online or have support from an expert.

Here is the final overlay for my display that resulted in a successful build with display sample. The overlay file needs to be placed in a /boards folder inside your application (/display/boards). Its name has to be identical to the name of the board in build configuration, e.g. nrf7002dk_nrf5340_cpuapp.overlay:

// Display sample overlay for st7735r
&spi2 {
    status = "okay";
    pinctrl-0 = <&spi2_default>;
    pinctrl-names = "default";
    cs-gpios = <&gpio0 18 GPIO_ACTIVE_LOW>;

    st7735r: st7735r@0 {
        compatible = "sitronix,st7735r";
        spi-max-frequency = <20000000>;
        reg = <0>;
        cmd-data-gpios = <&gpio0 19 GPIO_ACTIVE_LOW>;
        reset-gpios = <&gpio0 11 GPIO_ACTIVE_LOW>;
        width = <160>;
        height = <128>;
        x-offset = <0>;
        y-offset = <0>;
        madctl = <0x60>;
        colmod = <0x55>;
        vmctr1 = <0x0e>;
        pwctr1 = [a2 02 84];
        pwctr2 = [c5];
        pwctr3 = [0a 00];
        pwctr4 = [8a 2a];
        pwctr5 = [8a ee];
        frmctr1 = [01 2c 2d];
        frmctr2 = [01 2c 2d];
        frmctr3 = [01 2c 2d 01 2c 2d];
        gamctrp1 = [02 1c 07 12 37 32 29 2d 29 25 2b 39 00 01 03 10];
        gamctrn1 = [03 1d 07 06 2e 2c 29 2d 2e 2e 37 3f 00 00 02 10];
    };
};

// Define pins used for SPI
&pinctrl {
    spi2_default: spi2_default {
    group1 {
        psels = <NRF_PSEL(SPIM_SCK, 0, 17)>,
        <NRF_PSEL(SPIM_MOSI, 0, 13)>,
        <NRF_PSEL(SPIM_MISO, 0, 14)>;
        };
    };
};
    
/ {
    chosen {
        zephyr,display = &st7735r;
    };
};

Invisible modules

Successful is, however, a relative term. After I flashed the build and connected the wires, my display did absolutely nothing. Well, technically, the backlight did light up when connected to 5V, but that does not need a microcontroller. The script successfully fetched my device from the device tree, but the board simply did not establish a connection with the display.

After checking my pin assignment and wiring, I decided to change my strategy and try something less complex. DHT temperature sensor sample looked simple enough. I wired my DHT11 module in, loaded the sample, tweaked the overlay, and... nothing!

// DHT sample overlay for DHT11
/ {
    dht11 {
        compatible = "aosong,dht";
        status = "okay";
        label = "DHT11";
        dio-gpios = <&gpio0 27 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>;
    };
};

Adding an insult to the injury, it took me less than 10 minutes to run an equivalent example on an ESP8266-based board. But, after a quick vent on Discord, I found a new hope: logic level shifters.

Episode IV: Logic Levels

nRF7002 DK runs on 1.8V logic. Both ST7735r display and DHT11 temperature sensor run on 3-5.5V, which means that they may not be getting enough "juice" to run properly. With elevated spirits, I added some 4-channel logic level converters to my cart and reached out for my debit card.

A couple of days later my parcel arrives. I try connecting DHT11 via the logic level shifter, and... nothing. It is still as invisible as before. The same goes for the ST7735r display. This is the part where I would love to shift the narrative and uncover the obvious rookie mistake that prevented everything from working. Unfortunately, at the time of this write-up, I still have no clue.

If you are a Zephyr pro, please share your wisdom in the comments - I still hope to finish this project and use nRF7002 DK for future Matter ideas.

Stage 5: Acceptance

While I was waiting on my level shifters parcel, I also found an online example of using lvgl with an SSD1306 display, and decided to quickly appropriate it to my needs. With a few tweaks to the sample overlay file (see attachments), I uploaded it to my nRF7002 DK and started wiring the SDA and SCL lines.

To my surprise, it failed in a completely new and exciting way:

1 / 2 • Serial terminal error log suggesting issues with memory allocation.

Now, this is something completely new. Obviously, logic level shifter did not magically fix this problem either. However, after an hour or two online, I did find the culprit - memory allocation. This time, a third file is introduced into the mix: proj.config. After allocating additional memory inside the configuration file (CONFIG_HEAP_MEM_POOL_SIZE=16384 & CONFIG_MAIN_STACK_SIZE=4096), magic almost happened but in a fairly bugged way.

CONFIG_I2C=y
CONFIG_SSD1306=y
CONFIG_SSD1306_SH1106_COMPATIBLE=n
CONFIG_STDOUT_CONSOLE=y

CONFIG_BOOT_BANNER=n
CONFIG_HEAP_MEM_POOL_SIZE=16384
CONFIG_MAIN_STACK_SIZE=4096
CONFIG_BT_RX_STACK_SIZE=4096

CONFIG_DISPLAY=y
CONFIG_CHARACTER_FRAMEBUFFER=y
CONFIG_SHELL=y
CONFIG_CHARACTER_FRAMEBUFFER_SHELL=y

CONFIG_LOG=y
CONFIG_CFB_LOG_LEVEL_DBG=y

CONFIG_LVGL=y

Unfortunately, I did not have time to properly troubleshoot this last issue before the contest deadline. Once again, any advice and hints on what went wrong are highly appreciated!

In the meantime, I will go brew myself a coffee, recover my morale, and try again.

Thanks for giving this a read and stay nerdy.
Seeya!

// Display sample overlay for st7735r
&spi2 {
  status = "okay";
  pinctrl-0 = <&spi2_default>;
  pinctrl-names = "default";
  cs-gpios = <&gpio0 18 GPIO_ACTIVE_LOW>;

  st7735r: st7735r@0 {
    compatible = "sitronix,st7735r";
    spi-max-frequency = <20000000>;
    reg = <0>;
    cmd-data-gpios = <&gpio0 19 GPIO_ACTIVE_LOW>;
    reset-gpios = <&gpio0 11 GPIO_ACTIVE_LOW>;
    width = <160>;
    height = <128>;
    x-offset = <0>;
    y-offset = <0>;
    madctl = <0x60>;
    colmod = <0x55>;
    vmctr1 = <0x0e>;
    pwctr1 = [a2 02 84];
    pwctr2 = [c5];
    pwctr3 = [0a 00];
    pwctr4 = [8a 2a];
    pwctr5 = [8a ee];
    frmctr1 = [01 2c 2d];
    frmctr2 = [01 2c 2d];
    frmctr3 = [01 2c 2d 01 2c 2d];
    gamctrp1 = [02 1c 07 12 37 32 29 2d 29 25 2b 39 00 01 03 10];
    gamctrn1 = [03 1d 07 06 2e 2c 29 2d 2e 2e 37 3f 00 00 02 10];
  };
};

&pinctrl {
  spi2_default: spi2_default {
    group1 {
      psels = <NRF_PSEL(SPIM_SCK, 0, 17)>,
      <NRF_PSEL(SPIM_MOSI, 0, 13)>,
      <NRF_PSEL(SPIM_MISO, 0, 14)>;
    };
  };
};
    
/ {
    chosen {
        zephyr,display = &st7735r;
    };
};

/*
 * Copyright (c) 2019 Jan Van Winkel <jan.van_winkel@dxplore.eu>
 *
 * Based on ST7789V sample:
 * Copyright (c) 2019 Marc Reilly
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(sample, LOG_LEVEL_INF);

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/display.h>

#ifdef CONFIG_ARCH_POSIX
#include "posix_board_if.h"
#endif

enum corner {
	TOP_LEFT,
	TOP_RIGHT,
	BOTTOM_RIGHT,
	BOTTOM_LEFT
};

typedef void (*fill_buffer)(enum corner corner, uint8_t grey, uint8_t *buf,
			    size_t buf_size);


#ifdef CONFIG_ARCH_POSIX
static void posix_exit_main(int exit_code)
{
#if CONFIG_TEST
	if (exit_code == 0) {
		LOG_INF("PROJECT EXECUTION SUCCESSFUL");
	} else {
		LOG_INF("PROJECT EXECUTION FAILED");
	}
#endif
	posix_exit(exit_code);
}
#endif

static void fill_buffer_argb8888(enum corner corner, uint8_t grey, uint8_t *buf,
				 size_t buf_size)
{
	uint32_t color = 0;

	switch (corner) {
	case TOP_LEFT:
		color = 0x00FF0000u;
		break;
	case TOP_RIGHT:
		color = 0x0000FF00u;
		break;
	case BOTTOM_RIGHT:
		color = 0x000000FFu;
		break;
	case BOTTOM_LEFT:
		color = grey << 16 | grey << 8 | grey;
		break;
	}

	for (size_t idx = 0; idx < buf_size; idx += 4) {
		*((uint32_t *)(buf + idx)) = color;
	}
}

static void fill_buffer_rgb888(enum corner corner, uint8_t grey, uint8_t *buf,
			       size_t buf_size)
{
	uint32_t color = 0;

	switch (corner) {
	case TOP_LEFT:
		color = 0x00FF0000u;
		break;
	case TOP_RIGHT:
		color = 0x0000FF00u;
		break;
	case BOTTOM_RIGHT:
		color = 0x000000FFu;
		break;
	case BOTTOM_LEFT:
		color = grey << 16 | grey << 8 | grey;
		break;
	}

	for (size_t idx = 0; idx < buf_size; idx += 3) {
		*(buf + idx + 0) = color >> 16;
		*(buf + idx + 1) = color >> 8;
		*(buf + idx + 2) = color >> 0;
	}
}

static uint16_t get_rgb565_color(enum corner corner, uint8_t grey)
{
	uint16_t color = 0;
	uint16_t grey_5bit;

	switch (corner) {
	case TOP_LEFT:
		color = 0xF800u;
		break;
	case TOP_RIGHT:
		color = 0x07E0u;
		break;
	case BOTTOM_RIGHT:
		color = 0x001Fu;
		break;
	case BOTTOM_LEFT:
		grey_5bit = grey & 0x1Fu;
		/* shift the green an extra bit, it has 6 bits */
		color = grey_5bit << 11 | grey_5bit << (5 + 1) | grey_5bit;
		break;
	}
	return color;
}

static void fill_buffer_rgb565(enum corner corner, uint8_t grey, uint8_t *buf,
			       size_t buf_size)
{
	uint16_t color = get_rgb565_color(corner, grey);

	for (size_t idx = 0; idx < buf_size; idx += 2) {
		*(buf + idx + 0) = (color >> 8) & 0xFFu;
		*(buf + idx + 1) = (color >> 0) & 0xFFu;
	}
}

static void fill_buffer_bgr565(enum corner corner, uint8_t grey, uint8_t *buf,
			       size_t buf_size)
{
	uint16_t color = get_rgb565_color(corner, grey);

	for (size_t idx = 0; idx < buf_size; idx += 2) {
		*(uint16_t *)(buf + idx) = color;
	}
}

static void fill_buffer_mono(enum corner corner, uint8_t grey, uint8_t *buf,
			     size_t buf_size)
{
	uint16_t color;

	switch (corner) {
	case BOTTOM_LEFT:
		color = (grey & 0x01u) ? 0xFFu : 0x00u;
		break;
	default:
		color = 0;
		break;
	}

	memset(buf, color, buf_size);
}

int main(void)
{
	size_t x;
	size_t y;
	size_t rect_w;
	size_t rect_h;
	size_t h_step;
	size_t scale;
	size_t grey_count;
	uint8_t *buf;
	int32_t grey_scale_sleep;
	const struct device *display_dev;
	struct display_capabilities capabilities;
	struct display_buffer_descriptor buf_desc;
	size_t buf_size = 0;
	fill_buffer fill_buffer_fnc = NULL;

	display_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_display));
	if (!device_is_ready(display_dev)) {
		LOG_ERR("Device %s not found. Aborting sample.",
			display_dev->name);
#ifdef CONFIG_ARCH_POSIX
		posix_exit_main(1);
#else
		return 0;
#endif
	}

	LOG_INF("Display sample for %s", display_dev->name);
	display_get_capabilities(display_dev, &capabilities);

	if (capabilities.screen_info & SCREEN_INFO_MONO_VTILED) {
		rect_w = 16;
		rect_h = 8;
	} else {
		rect_w = 2;
		rect_h = 1;
	}

	h_step = rect_h;
	scale = (capabilities.x_resolution / 8) / rect_h;

	rect_w *= scale;
	rect_h *= scale;

	if (capabilities.screen_info & SCREEN_INFO_EPD) {
		grey_scale_sleep = 10000;
	} else {
		grey_scale_sleep = 100;
	}

	buf_size = rect_w * rect_h;

	if (buf_size < (capabilities.x_resolution * h_step)) {
		buf_size = capabilities.x_resolution * h_step;
	}

	switch (capabilities.current_pixel_format) {
	case PIXEL_FORMAT_ARGB_8888:
		fill_buffer_fnc = fill_buffer_argb8888;
		buf_size *= 4;
		break;
	case PIXEL_FORMAT_RGB_888:
		fill_buffer_fnc = fill_buffer_rgb888;
		buf_size *= 3;
		break;
	case PIXEL_FORMAT_RGB_565:
		fill_buffer_fnc = fill_buffer_rgb565;
		buf_size *= 2;
		break;
	case PIXEL_FORMAT_BGR_565:
		fill_buffer_fnc = fill_buffer_bgr565;
		buf_size *= 2;
		break;
	case PIXEL_FORMAT_MONO01:
	case PIXEL_FORMAT_MONO10:
		fill_buffer_fnc = fill_buffer_mono;
		buf_size /= 8;
		break;
	default:
		LOG_ERR("Unsupported pixel format. Aborting sample.");
#ifdef CONFIG_ARCH_POSIX
		posix_exit_main(1);
#else
		return 0;
#endif
	}

	buf = k_malloc(buf_size);

	if (buf == NULL) {
		LOG_ERR("Could not allocate memory. Aborting sample.");
#ifdef CONFIG_ARCH_POSIX
		posix_exit_main(1);
#else
		return 0;
#endif
	}

	(void)memset(buf, 0xFFu, buf_size);

	buf_desc.buf_size = buf_size;
	buf_desc.pitch = capabilities.x_resolution;
	buf_desc.width = capabilities.x_resolution;
	buf_desc.height = h_step;

	for (int idx = 0; idx < capabilities.y_resolution; idx += h_step) {
		display_write(display_dev, 0, idx, &buf_desc, buf);
	}

	buf_desc.pitch = rect_w;
	buf_desc.width = rect_w;
	buf_desc.height = rect_h;

	fill_buffer_fnc(TOP_LEFT, 0, buf, buf_size);
	x = 0;
	y = 0;
	display_write(display_dev, x, y, &buf_desc, buf);

	fill_buffer_fnc(TOP_RIGHT, 0, buf, buf_size);
	x = capabilities.x_resolution - rect_w;
	y = 0;
	display_write(display_dev, x, y, &buf_desc, buf);

	fill_buffer_fnc(BOTTOM_RIGHT, 0, buf, buf_size);
	x = capabilities.x_resolution - rect_w;
	y = capabilities.y_resolution - rect_h;
	display_write(display_dev, x, y, &buf_desc, buf);

	display_blanking_off(display_dev);

	grey_count = 0;
	x = 0;
	y = capabilities.y_resolution - rect_h;

	while (1) {
		fill_buffer_fnc(BOTTOM_LEFT, grey_count, buf, buf_size);
		display_write(display_dev, x, y, &buf_desc, buf);
		++grey_count;
		k_msleep(grey_scale_sleep);
#if CONFIG_TEST
		if (grey_count >= 1024) {
			break;
		}
#endif
	}

#ifdef CONFIG_ARCH_POSIX
	posix_exit_main(0);
#endif
	return 0;
}

/*
 * Copyright (c) 2019 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <stdio.h>

#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(app, LOG_LEVEL_DBG);

int main(void)
{
	
	const struct device *const dht11 = DEVICE_DT_GET_ONE(aosong_dht);

	if (!device_is_ready(dht11)) {
		printf("Device %s is not ready\n", dht11->name);
		return 0;
	}
	
	while (true) {
		int rc = sensor_sample_fetch(dht11);

		if (rc != 0) {
			LOG_DBG("Sensor fetch failed: %d\n", rc);
			break;
		}

		struct sensor_value temperature;
		struct sensor_value humidity;

		rc = sensor_channel_get(dht11, SENSOR_CHAN_AMBIENT_TEMP,
					&temperature);
		if (rc == 0) {
			rc = sensor_channel_get(dht11, SENSOR_CHAN_HUMIDITY,
						&humidity);
		}
		if (rc != 0) {
			printf("get failed: %d\n", rc);
			break;
		}

		printf("[%s]: %.1f Cel ; %.1f %%RH\n",
		       sensor_value_to_double(&temperature),
		       sensor_value_to_double(&humidity));
		k_sleep(K_SECONDS(2));
	}
	LOG_DBG("Check 2");
	return 0;
}

&pinctrl {
  i2c1_default: i2c1_default {
    group1 {
      psels = <NRF_PSEL(TWIM_SDA, 1, 2)>, // GPIO P1.2
       <NRF_PSEL(TWIM_SCL, 1, 3)>;     // GPIO P1.3
    };
  };

  i2c1_sleep: i2c1_sleep {
    group1 {
      psels = <NRF_PSEL(TWIM_SDA, 1, 2)>, // GPIO P1.2
        <NRF_PSEL(TWIM_SCL, 1, 3)>;     // GPIO P1.3
      low-power-enable;
    };
  };
};

arduino_i2c: &i2c1 {
	compatible = "nordic,nrf-twim";
	status = "okay";
	clock-frequency = <I2C_BITRATE_FAST>;
  zephyr,concat-buf-size = <4096>;

  ssd1306: ssd1306@3c {
    compatible = "solomon,ssd1306fb";
    reg = <0x3c>; //0x3c is the i2c address of the SSD1306 aIC.
    width = <128>;
    height = <64>;
    segment-offset = <0>;
    page-offset = <0>;
    display-offset = <0>;
    multiplex-ratio = <63>;
    segment-remap;
    com-invdir;
    com-sequential;
    prechargep = <0x22>;
  };
};

/*
 * Copyright (c) 2018 Jan Van Winkel <jan.van_winkel@dxplore.eu>
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/display.h>
#include <zephyr/drivers/gpio.h>
#include <lvgl.h>
#include <stdio.h>
#include <string.h>
#include <zephyr/kernel.h>

#define LOG_LEVEL CONFIG_LOG_DEFAULT_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(app);

static uint32_t count;

#ifdef CONFIG_GPIO
static struct gpio_dt_spec button_gpio = GPIO_DT_SPEC_GET_OR(
		DT_ALIAS(sw0), gpios, {0});
static struct gpio_callback button_callback;

static void button_isr_callback(const struct device *port,
				struct gpio_callback *cb,
				uint32_t pins)
{
	ARG_UNUSED(port);
	ARG_UNUSED(cb);
	ARG_UNUSED(pins);

	count = 0;
}
#endif

int main(void)
{
	int err;
	char count_str[11] = {0};
	const struct device *display_dev;
	lv_obj_t *hello_world_label;
	lv_obj_t *count_label;

	LOG_DBG("Check 1");

	display_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_display));
	if (!device_is_ready(display_dev)) {
		LOG_ERR("Device not ready, aborting test");
		return 0;
	}

#ifdef CONFIG_GPIO
	if (device_is_ready(button_gpio.port)) {
		err = gpio_pin_configure_dt(&button_gpio, GPIO_INPUT);
		if (err) {
			LOG_ERR("failed to configure button gpio: %d", err);
			return 0;
		}

		gpio_init_callback(&button_callback, button_isr_callback,
				   BIT(button_gpio.pin));

		err = gpio_add_callback(button_gpio.port, &button_callback);
		if (err) {
			LOG_ERR("failed to add button callback: %d", err);
			return 0;
		}

		err = gpio_pin_interrupt_configure_dt(&button_gpio,
						      GPIO_INT_EDGE_TO_ACTIVE);
		if (err) {
			LOG_ERR("failed to enable button callback: %d", err);
			return 0;
		}
	}
#endif

	if (IS_ENABLED(CONFIG_LV_Z_POINTER_KSCAN)) {
		lv_obj_t *hello_world_button;

		hello_world_button = lv_btn_create(lv_scr_act());
		lv_obj_align(hello_world_button, LV_ALIGN_CENTER, 0, 0);
		hello_world_label = lv_label_create(hello_world_button);
	} else {
		hello_world_label = lv_label_create(lv_scr_act());
	}

	lv_label_set_text(hello_world_label, "Hello world!");
	lv_obj_align(hello_world_label, LV_ALIGN_CENTER, 0, 0);

	count_label = lv_label_create(lv_scr_act());
	lv_obj_align(count_label, LV_ALIGN_BOTTOM_MID, 0, 0);

	lv_task_handler();
	display_blanking_off(display_dev);

	while (1) {
		if ((count % 100) == 0U) {
			sprintf(count_str, "%d", count/100U);
			lv_label_set_text(count_label, count_str);
		}
		lv_task_handler();
		++count;
		k_sleep(K_MSEC(10));
	}
}

Credits

Tommy Bianco

5 projects • 2 followers

A biologist procrastinating

5 ways to bork your Zephyr project (with nRF7002 DK)!

Things used in this project

Hardware components

Software apps and online services

Story

tl;dr

Hardware pitch

Zephyr applications are complex

Invisible modules

Episode IV: Logic Levels

Stage 5: Acceptance

Code

DeviceTree Overlay for ST7735r

main.c for ST7735r

DeviceTree Overlay for DHT11

main.c for DHT11

DeviceTree Overlay for SSD1306 128x64

proj.config for SSD1306

main.c for SDD1306

Credits

Tommy Bianco

Comments

Embed the widget on your own site

5 ways to bork your Zephyr project (with nRF7002 DK)!

5 ways to bork your Zephyr project (with nRF7002 DK)!

Things used in this project

Hardware components

Software apps and online services

Story

tl;dr

Hardware pitch

Zephyr applications are complex

Invisible modules

Episode IV: Logic Levels

Stage 5: Acceptance

Code

DeviceTree Overlay for ST7735r

main.c for ST7735r

DeviceTree Overlay for DHT11

main.c for DHT11

DeviceTree Overlay for SSD1306 128x64

proj.config for SSD1306

main.c for SDD1306

Credits

Tommy Bianco

Comments