Userland app for distance sensor

examples/sensors/main.c

@@ -2,6 +2,7 @@
 #include <stdio.h>
 
 #include <libtock-sync/sensors/ambient_light.h>
+#include <libtock-sync/sensors/distance.h>
 #include <libtock-sync/sensors/humidity.h>
 #include <libtock-sync/sensors/ninedof.h>
 #include <libtock-sync/sensors/proximity.h>
@@ -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) {

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();
+}

libtock-sync/sensors/distance.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <libtock/sensors/distance.h>
+#include <libtock/tock.h>
+
+#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

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;
+}

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

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];
+}

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 libtock_distance_get_minimum_distance(void);
+
+// Function to get maximum distance
+int libtock_distance_get_maximum_distance(void);
+
+#ifdef __cplusplus
+}
+#endif