From d410dc73a219b8e94f1ec786a25c860b87455349 Mon Sep 17 00:00:00 2001 From: cristianaprecup Date: Mon, 5 Aug 2024 15:30:49 +0300 Subject: [PATCH 1/2] distance sensor test --- examples/sensors/main.c | 14 +++++++ libtock-sync/sensors/distance.c | 41 ++++++++++++++++++++ libtock-sync/sensors/distance.h | 38 ++++++++++++++++++ libtock/sensors/distance.c | 20 ++++++++++ libtock/sensors/distance.h | 21 ++++++++++ libtock/sensors/syscalls/distance_syscalls.c | 23 +++++++++++ libtock/sensors/syscalls/distance_syscalls.h | 34 ++++++++++++++++ 7 files changed, 191 insertions(+) create mode 100644 libtock-sync/sensors/distance.c create mode 100644 libtock-sync/sensors/distance.h create mode 100644 libtock/sensors/distance.c create mode 100644 libtock/sensors/distance.h create mode 100644 libtock/sensors/syscalls/distance_syscalls.c create mode 100644 libtock/sensors/syscalls/distance_syscalls.h diff --git a/examples/sensors/main.c b/examples/sensors/main.c index f674dba38..ade6ebe0c 100644 --- a/examples/sensors/main.c +++ b/examples/sensors/main.c @@ -8,6 +8,7 @@ #include #include #include +#include #include static libtock_alarm_t alarm; @@ -20,12 +21,15 @@ static bool ninedof_mag = false; static bool ninedof_gyro = false; static bool proximity = false; static bool sound_pressure = false; +static bool distance = false; + static void alarm_cb(__attribute__ ((unused)) uint32_t now, __attribute__ ((unused)) uint32_t scheduled, __attribute__ ((unused)) void* opaque) { int lite = 0; int temp = 0; int humi = 0; + int dist = 0; int ninedof_accel_x = 0, ninedof_accel_y = 0, ninedof_accel_z = 0; int ninedof_magneto_x = 0, ninedof_magneto_y = 0, ninedof_magneto_z = 0; int ninedof_gyro_x = 0, ninedof_gyro_y = 0, ninedof_gyro_z = 0; @@ -41,6 +45,7 @@ static void alarm_cb(__attribute__ ((unused)) uint32_t now, if (ninedof_gyro) libtocksync_ninedof_read_gyroscope(&ninedof_gyro_x, &ninedof_gyro_y, &ninedof_gyro_z); if (proximity) libtocksync_proximity_read(&prox_reading); if (sound_pressure) libtocksync_sound_pressure_read(&sound_pressure_reading); + if (distance) libtocksync_distance_read(&dist); if (light) printf("Amb. Light: Light Intensity: %d\n", lite); if (temperature) printf("Temperature: %d deg C\n", temp/100); @@ -50,6 +55,7 @@ static void alarm_cb(__attribute__ ((unused)) uint32_t now, if (ninedof_gyro) printf("Gyro: X: %d Y: %d Z: %d\n", ninedof_gyro_x, ninedof_gyro_y, ninedof_gyro_z); if (proximity) printf("Proximity: %u\n", prox_reading); if (sound_pressure) printf("Sound Pressure: %u\n", sound_pressure_reading); + if (distance) printf("Distance: %d mm\n", dist); /* *INDENT-ON* */ @@ -68,8 +74,15 @@ int main(void) { ninedof = libtock_ninedof_exists(); proximity = libtock_proximity_exists(); sound_pressure = libtock_sound_pressure_exists(); + distance = libtock_distance_exists(); /* *INDENT-ON* */ + if (distance) { + int min_distance = libtocksync_distance_get_minimum_distance(); + int max_distance = libtocksync_distance_get_maximum_distance(); + printf("[Sensors] Distance sensor: Min = %d mm, Max = %d mm\n", min_distance, max_distance); + } + if (ninedof) { int buffer; ninedof_accel = (libtocksync_ninedof_read_accelerometer(&buffer, &buffer, &buffer) == RETURNCODE_SUCCESS); @@ -86,6 +99,7 @@ int main(void) { if (ninedof_gyro) printf("[Sensors] Sampling Gyroscope.\n"); if (proximity) printf("[Sensors] Sampling Proximity sensor.\n"); if (sound_pressure) printf("[Sensors] Sampling Sound Pressure sensor.\n"); + if (distance) printf("[Sensors] Sampling Distance sensor.\n"); /* *INDENT-ON* */ if (sound_pressure) { diff --git a/libtock-sync/sensors/distance.c b/libtock-sync/sensors/distance.c new file mode 100644 index 000000000..d7cff58c3 --- /dev/null +++ b/libtock-sync/sensors/distance.c @@ -0,0 +1,41 @@ +#include "distance.h" + +struct data { + bool fired; + int dist; + returncode_t result; +}; + +static struct data result = { .fired = false }; + +static void dist_cb(returncode_t ret, int distance) { + result.dist = distance; + result.fired = true; + result.result = ret; +} + +returncode_t libtocksync_distance_read(int* distance) { + returncode_t err; + result.fired = false; + + err = libtock_distance_read(dist_cb); + if (err != RETURNCODE_SUCCESS) return err; + + // Wait for the callback. + yield_for(&result.fired); + if (result.result != RETURNCODE_SUCCESS) return result.result; + + *distance = result.dist; + + return RETURNCODE_SUCCESS; +} + +// Function to get minimum distance +int libtocksync_distance_get_minimum_distance(void) { + return libtock_distance_get_minimum_distance(); +} + +// Function to get maximum distance +int libtocksync_distance_get_maximum_distance(void) { + return libtock_distance_get_maximum_distance(); +} diff --git a/libtock-sync/sensors/distance.h b/libtock-sync/sensors/distance.h new file mode 100644 index 000000000..33275700f --- /dev/null +++ b/libtock-sync/sensors/distance.h @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Read the distance sensor synchronously. +// +// ## Arguments +// +// - `distance`: Set to the distance value in millimeters. +// +// ## Return Value +// +// A returncode indicating whether the distance read was completed +// successfully. +returncode_t libtocksync_distance_read(int* distance); + +// Get the minimum measurable distance. +// +// ## Return Value +// +// The minimum measurable distance in millimeters. +int libtocksync_distance_get_minimum_distance(void); + +// Get the maximum measurable distance. +// +// ## Return Value +// +// The maximum measurable distance in millimeters. +int libtocksync_distance_get_maximum_distance(void); + +#ifdef __cplusplus +} +#endif diff --git a/libtock/sensors/distance.c b/libtock/sensors/distance.c new file mode 100644 index 000000000..edabd38b3 --- /dev/null +++ b/libtock/sensors/distance.c @@ -0,0 +1,20 @@ +#include "distance.h" + +// Internal upcall for passing to the syscall driver. +static void distance_upcall(int dist, + __attribute__ ((unused)) int unused, + __attribute__ ((unused)) int unused1, + void* opaque) { + libtock_distance_callback cb = (libtock_distance_callback) opaque; + cb(RETURNCODE_SUCCESS, dist); +} + +returncode_t libtock_distance_read(libtock_distance_callback cb) { + returncode_t ret; + + ret = libtock_distance_set_upcall(distance_upcall, cb); + if (ret != RETURNCODE_SUCCESS) return ret; + + ret = libtock_distance_command_read(); + return ret; +} diff --git a/libtock/sensors/distance.h b/libtock/sensors/distance.h new file mode 100644 index 000000000..af6d62364 --- /dev/null +++ b/libtock/sensors/distance.h @@ -0,0 +1,21 @@ +#pragma once + +#include "../tock.h" +#include "syscalls/distance_syscalls.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Function signature for distance data callback. +// +// - `arg1` (`returncode_t`): Status from sampling the sensor. +// - `arg2` (`int`): Distance reading in milimeters. +typedef void (*libtock_distance_callback)(returncode_t, int); + +// Initiate a reading measurement and return results via the `cb`. +returncode_t libtock_distance_read(libtock_distance_callback cb); + +#ifdef __cplusplus +} +#endif diff --git a/libtock/sensors/syscalls/distance_syscalls.c b/libtock/sensors/syscalls/distance_syscalls.c new file mode 100644 index 000000000..5edfbd5de --- /dev/null +++ b/libtock/sensors/syscalls/distance_syscalls.c @@ -0,0 +1,23 @@ +#include "distance_syscalls.h" + +bool libtock_distance_exists(void) { + return driver_exists(DRIVER_NUM_DISTANCE); +} + +returncode_t libtock_distance_set_upcall(subscribe_upcall callback, void* opaque) { + subscribe_return_t sval = subscribe(DRIVER_NUM_DISTANCE, 0, callback, opaque); + return tock_subscribe_return_to_returncode(sval); +} + +returncode_t libtock_distance_command_read(void) { + syscall_return_t cval = command(DRIVER_NUM_DISTANCE, 1, 0, 0); + return tock_command_return_novalue_to_returncode(cval); +} + +int libtock_distance_get_minimum_distance(void) { + return command(DRIVER_NUM_DISTANCE, 2, 0, 0).data[0]; +} + +int libtock_distance_get_maximum_distance(void) { + return command(DRIVER_NUM_DISTANCE, 3, 0, 0).data[0]; +} \ No newline at end of file diff --git a/libtock/sensors/syscalls/distance_syscalls.h b/libtock/sensors/syscalls/distance_syscalls.h new file mode 100644 index 000000000..21d57597c --- /dev/null +++ b/libtock/sensors/syscalls/distance_syscalls.h @@ -0,0 +1,34 @@ +#pragma once + +#include "../../tock.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define DRIVER_NUM_DISTANCE 0x60009 + +// Check if distance sensor exists. +bool libtock_distance_exists(void); + +// units: disntance in millimeters. + +// Set the callback function to be called when the distance measurement is +// finished. +// +// callback - pointer to function to be called +// opaque - pointer to data provided to the callback +returncode_t libtock_distance_set_upcall(subscribe_upcall callback, void* opaque); + +// Initiate an ambient distance measurement. +returncode_t libtock_distance_command_read(void); + +// Function to get minimum distance +int libtocksync_distance_get_minimum_distance(void); + +// Function to get maximum distance +int libtocksync_distance_get_maximum_distance(void); + +#ifdef __cplusplus +} +#endif From 20330405161bfff71778bc4c2784d14a9ab05f03 Mon Sep 17 00:00:00 2001 From: cristianaprecup Date: Thu, 15 Aug 2024 15:57:49 +0300 Subject: [PATCH 2/2] reformat code --- examples/sensors/main.c | 2 +- libtock-sync/sensors/distance.c | 4 ++-- libtock/sensors/distance.c | 6 +++--- libtock/sensors/syscalls/distance_syscalls.h | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/sensors/main.c b/examples/sensors/main.c index ade6ebe0c..00e2e99ee 100644 --- a/examples/sensors/main.c +++ b/examples/sensors/main.c @@ -2,13 +2,13 @@ #include #include +#include #include #include #include #include #include #include -#include #include static libtock_alarm_t alarm; diff --git a/libtock-sync/sensors/distance.c b/libtock-sync/sensors/distance.c index d7cff58c3..72ee23993 100644 --- a/libtock-sync/sensors/distance.c +++ b/libtock-sync/sensors/distance.c @@ -29,8 +29,8 @@ returncode_t libtocksync_distance_read(int* distance) { return RETURNCODE_SUCCESS; } - -// Function to get minimum distance + +// Function to get minimum distance int libtocksync_distance_get_minimum_distance(void) { return libtock_distance_get_minimum_distance(); } diff --git a/libtock/sensors/distance.c b/libtock/sensors/distance.c index edabd38b3..08cc79ef1 100644 --- a/libtock/sensors/distance.c +++ b/libtock/sensors/distance.c @@ -2,9 +2,9 @@ // Internal upcall for passing to the syscall driver. static void distance_upcall(int dist, - __attribute__ ((unused)) int unused, - __attribute__ ((unused)) int unused1, - void* opaque) { + __attribute__ ((unused)) int unused, + __attribute__ ((unused)) int unused1, + void* opaque) { libtock_distance_callback cb = (libtock_distance_callback) opaque; cb(RETURNCODE_SUCCESS, dist); } diff --git a/libtock/sensors/syscalls/distance_syscalls.h b/libtock/sensors/syscalls/distance_syscalls.h index 21d57597c..75387d919 100644 --- a/libtock/sensors/syscalls/distance_syscalls.h +++ b/libtock/sensors/syscalls/distance_syscalls.h @@ -24,10 +24,10 @@ returncode_t libtock_distance_set_upcall(subscribe_upcall callback, void* opaque returncode_t libtock_distance_command_read(void); // Function to get minimum distance -int libtocksync_distance_get_minimum_distance(void); +int libtock_distance_get_minimum_distance(void); // Function to get maximum distance -int libtocksync_distance_get_maximum_distance(void); +int libtock_distance_get_maximum_distance(void); #ifdef __cplusplus }