In this chapter, we will demonstrate how to create a kernel module for a ranging sensor (such as an ultrasonic sensor) on a Linux-based embedded system. The ranging sensor is commonly used to measure distances by emitting sound waves and measuring the time it takes for the echo to return. We will build a kernel module that interacts with the sensor hardware, retrieves the distance measurement, and provides an interface for user-space applications to read the sensor data. This chapter will walk through the steps of writing the kernel module, compiling it, and interacting with it from user space.

For this example, we'll assume that we're working with a commonly used ultrasonic sensor, such as the HC-SR04 sensor, which has:
● Trigger Pin: Sends a pulse to start the measurement.
● Echo Pin: Receives the echo signal and measures the time taken.

The formula to calculate the distance is based on the speed of sound:
Distance = (Time * Speed of Sound) / 2
Where:
● Time is the duration for which the echo pulse is received.
● Speed of Sound is approximately 343 meters per second at room temperature.
In this demo, the kernel module will interact with the sensor's GPIO pins, measure the time for the echo to return, and calculate the distance. The user can then retrieve this data from user space.

Our kernel module will:
1. Initialize the GPIO pins (trigger and echo).
2. Generate a pulse to trigger the sensor.
3. Measure the echo pulse duration.
4. Calculate the distance based on the time of flight.
5. Provide an interface to read the distance from user space using device files.

The following is an example of a kernel module that interacts with the ranging sensor and exposes the distance data to user space:
Step 1: Include Necessary Headers

include

include

include

include

include

include

include

define TRIGGER_PIN 17 // GPIO pin for trigger

define ECHO_PIN 27 // GPIO pin for echo

define DEVICE_NAME "ranging_sensor"

// Variables to store device data
static int distance = 0;
static int major_number;

Step 2: Initialize the GPIO pins and Sensor
The module initialization function will configure the GPIO pins and set them up for reading the sensor data.

To measure the distance, the module will send a trigger pulse and wait for the echo response. The gpio_get_value() function will be used to read the state of the echo pin.

static int measure_distance(void) {
int duration;
unsigned long start_time, end_time;
// Send a 10us pulse to the Trigger Pin
gpio_set_value(TRIGGER_PIN, 1);
udelay(10); // 10 microseconds
gpio_set_value(TRIGGER_PIN, 0);
// Wait for the Echo Pin to go high (indicating signal return)
start_time = jiffies;
while (gpio_get_value(ECHO_PIN) == 0) {...}
}

The module exposes the distance through a device file. The read() system call is overridden to return the measured distance.

static ssize_t device_read(struct file file, char __user buffer, size_t len, loff_t *offset) {
char dist_str[10];
int ret;
// Measure the distance
if (measure_distance() < 0) {...}
}

When the module is removed, we need to free the GPIO pins and unregister the device.

static void __exit sensor_exit(void) {
unregister_chrdev(major_number, DEVICE_NAME); // Unregister device
gpio_free(TRIGGER_PIN); // Free Trigger Pin
gpio_free(ECHO_PIN); // Free Echo Pin
printk(KERN_INFO "Ranging Sensor Kernel Module: Unloaded\n");}

To compile the kernel module, create a Makefile in the same directory as your source file (sensor.c).
Makefile:
obj-m += sensor.o
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
Run the following command to build the module:
make

Once the module is compiled into a .ko file, you can load and unload the kernel module using the following commands:
Load the Module:
sudo insmod sensor.ko
1. Check Kernel Logs:
dmesg | tail
2. Access the Distance via Device File:
Create a device file to interact with the module:
sudo mknod /dev/ranging_sensor c 0
3. Read the Distance:
cat /dev/ranging_sensor
4. Unload the Module:
sudo rmmod sensor

In this demo, we've created a simple kernel module for an ultrasonic ranging sensor. This kernel module interacts with hardware GPIO pins to trigger the sensor, measure the echo pulse duration, and calculate the distance. It provides an interface for user-space applications to read the distance data via a device file. This example demonstrates how to write kernel modules that interact with hardware in Linux, and how to provide user-space applications with access to kernel-level functionality.