Rohan Dey

modules directory

Contains our custom device driver; it can contain other device drivers or modules also. This directory will be provided to the CMake generator to include it in the build.

• sensor_sim directory – contains the source files for our custom device driver. Explanation of the driver source code is provided below.
• zephyr directory – contains a module.yml file which tells the build system to include the modules directory in the build. The zephyr/module.yml is a mandatory file
• CMakeLists.txt – adds the list of sub directories to the upper level CMakeLists.txt
• Kconfig – includes the Kconfig file available in the sub directories.

1. Define the driver compatible

The driver’s compatible must be defined in the source file. This must match the compatible declared in the device tree binding, i.e. compatible: rdt,sensor_sim. The commas should be changed to underscores.

#define DT_DRV_COMPAT rdt_sensor_sim

2. Declare the config and data structures

Two structures should be declared (a) config, (b) data. These contain the variables needed for the device driver to work

struct sensor_sim_config {

};

struct sensor_sim_data {
	int sensor_attr;
	uint32_t sensor_val;
};

3. Define the init function

Each zephyr driver must have an init function. The init function is automatically called by the kernel during system boot. This function should ideally check the status of the hardware device and return a success or failure code accordingly. If this function returns a failure code, then the driver will not be registered with the Kernel and the application will not be able to call its APIs. Here we are returning 0 as a success code.

static int sensor_sim_init(const struct device *dev)
{
	ARG_UNUSED(dev);
	int ret = 0;

	LOG_INF("sensor_sim_init");

	return ret;
}

4. Define the driver API and its functions

Here we are using the sensor driver API interface, hence we are defining the sample fetch and sample get function pointers. When an application calls the sample fetch and sample get functions through the sensing API, these functions sensor_sim_sample_fetch and sensor_sim_sample_get will get called

static const struct sensor_driver_api sensor_sim_driver_api = {
	.sample_fetch = sensor_sim_sample_fetch,
	.channel_get = sensor_sim_channel_get,
};

If you don’t want to use the sensor driver API interface, you can also define a custom set of APIs to interact with the driver. This is beyond the scope of this article, so let’s proceed with the senor API.

5. Finally add the driver to the Zephyr kernel

Now we can add the above variables to the kernel though the DEVICE_DT_INST_DEFINE macro. This MACRO creates a device object from a devicetree node identifier and sets it up for boot time initialization. Here we need to create 2 variables for the config and data structures. Since there can be multiple instances for the same driver as in our case (see the native_posix.overlay file) we use the MACRO DT_INST_FOREACH_STATUS_OKAY which iterates for each of the nodes and calls DEVICE_DT_DEFINE through DEVICE_DT_INST_DEFINE to create the device object. See the documentation for DEVICE_DT_DEFINE for description on the parameters.

#define DEVICE_INSTANCE(inst) \
\
const static struct sensor_sim_config sensor_sim_##inst##_cfg;\
\
static struct sensor_sim_data sensor_sim_##inst##_drvdata = { \
		.sensor_attr = DT_PROP(DT_DRV_INST(inst),sim_attr), \
}; \
\
DEVICE_DT_INST_DEFINE(inst,						\
		sensor_sim_init,								\
		device_pm_control_nop,							\
		&sensor_sim_##inst##_drvdata,					\
		&sensor_sim_##inst##_cfg,						\
		POST_KERNEL, CONFIG_SENSOR_SIM_INIT_PRIORITY,	\
		&sensor_sim_driver_api);

DT_INST_FOREACH_STATUS_OKAY(DEVICE_INSTANCE);

That’s it. Now our application can call the custom driver.

6. Call the driver functions though Zephyr’s sensing APIs

 The below code is self-explanatory.

const struct device* sim_dev1 = DEVICE_DT_GET(DT_NODELABEL(sensor_sim1));
	if (sim_dev1 == NULL) {
		LOG_ERR("device sensor_sim1 not found");
		return -1;
	}

	const struct device* sim_dev2 = DEVICE_DT_GET(DT_NODELABEL(sensor_sim2));
	if (sim_dev2 == NULL) {
		LOG_ERR("device sensor_sim2 not found");
		return -1;
	}

	struct sensor_value val;

	while (1) {
		sensor_sample_fetch_chan(sim_dev1, SENSOR_CHAN_AMBIENT_TEMP);
		sensor_channel_get(sim_dev1, SENSOR_CHAN_AMBIENT_TEMP, &val);
		LOG_INF("sim1 val = %d\n", val.val1);

		sensor_sample_fetch_chan(sim_dev2, SENSOR_CHAN_AMBIENT_TEMP);
		sensor_channel_get(sim_dev2, SENSOR_CHAN_AMBIENT_TEMP, &val);
		LOG_INF("sim2 val = %d\n", val.val1);

		k_sleep(K_MSEC(1000));
	}