Merge pull request #488 from alistair23/alistair/rainfall

Support reading rainfall from the kernel

Author: ppannuto

examples/sensors/main.c

@@ -6,6 +6,7 @@
 #include <libtock-sync/sensors/moisture.h>
 #include <libtock-sync/sensors/ninedof.h>
 #include <libtock-sync/sensors/proximity.h>
+#include <libtock-sync/sensors/rainfall.h>
 #include <libtock-sync/sensors/sound_pressure.h>
 #include <libtock-sync/sensors/temperature.h>
 #include <libtock-sync/services/alarm.h>
@@ -22,13 +23,15 @@ static bool ninedof_gyro   = false;
 static bool proximity      = false;
 static bool sound_pressure = false;
 static bool moisture       = false;
+static bool rainfall       = 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 mois = 0;
+  uint32_t rain = 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;
@@ -45,6 +48,7 @@ static void alarm_cb(__attribute__ ((unused)) uint32_t now,
   if (proximity)      libtocksync_proximity_read(&prox_reading);
   if (sound_pressure) libtocksync_sound_pressure_read(&sound_pressure_reading);
   if (moisture)       libtocksync_moisture_read(&mois);
+  if (rainfall)       libtocksync_rainfall_read(&rain, 1);
 
   if (light)          printf("Amb. Light: Light Intensity: %d\n", lite);
   if (temperature)    printf("Temperature:                 %d deg C\n", temp/100);
@@ -55,6 +59,7 @@ static void alarm_cb(__attribute__ ((unused)) uint32_t now,
   if (proximity)      printf("Proximity:                   %u\n", prox_reading);
   if (sound_pressure) printf("Sound Pressure:              %u\n", sound_pressure_reading);
   if (moisture)       printf("Moisture:                    %d%%\n", mois/100);
+  if (rainfall)       printf("Rainfall:                    %lumm\n", rain / 1000);
 
   /* *INDENT-ON* */
 
@@ -74,6 +79,7 @@ int main(void) {
   proximity      = libtock_proximity_exists();
   sound_pressure = libtock_sound_pressure_exists();
   moisture       = libtock_moisture_exists();
+  rainfall       = libtock_rainfall_exists();
   /* *INDENT-ON* */
 
   if (ninedof) {
@@ -93,6 +99,7 @@ int main(void) {
   if (proximity)      printf("[Sensors]   Sampling Proximity sensor.\n");
   if (sound_pressure) printf("[Sensors]   Sampling Sound Pressure sensor.\n");
   if (moisture)       printf("[Sensors]   Sampling Moisture sensor.\n");
+  if (rainfall)       printf("[Sensors]   Sampling Rainfall sensor.\n");
   /* *INDENT-ON* */
 
   if (sound_pressure) {

libtock-sync/sensors/rainfall.c

@@ -0,0 +1,32 @@
+#include "rainfall.h"
+
+typedef struct {
+  uint32_t rainfall;
+  returncode_t ret;
+  bool fired;
+} rainfall_result_t;
+
+static rainfall_result_t result = {.fired = false};
+
+// callback for synchronous reads
+static void rainfall_callback(returncode_t ret, uint32_t rainfall) {
+  result.rainfall = rainfall;
+  result.ret      = ret;
+  result.fired    = true;
+}
+
+returncode_t libtocksync_rainfall_read(uint32_t* rainfall, int hours) {
+  returncode_t err;
+
+  result.fired = false;
+
+  err = libtock_rainfall_read(rainfall_callback, hours);
+  if (err != RETURNCODE_SUCCESS) return err;
+
+  yield_for(&result.fired);
+  if (result.ret != RETURNCODE_SUCCESS) return result.ret;
+
+  *rainfall = result.rainfall;
+
+  return RETURNCODE_SUCCESS;
+}

libtock-sync/sensors/rainfall.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <libtock/sensors/rainfall.h>
+#include <libtock/tock.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Read the rainfall sensor synchronously.
+//
+// ## Arguments
+//
+// - `rainfall`: Set to the ums of rainfall in the specified number of hours.
+// - `hours`: The number of hours to get the rainfall data from. 1 to 24
+//            hours are valid values.
+//
+// ## Return Value
+//
+// A returncode indicating whether the sensor read was completed successfully.
+returncode_t libtocksync_rainfall_read(uint32_t* rainfall, int hours);
+
+#ifdef __cplusplus
+}
+#endif

libtock/sensors/rainfall.c

@@ -0,0 +1,18 @@
+#include "rainfall.h"
+
+static void rainfall_upcall(int status,
+                            int rainfall,
+                            __attribute__ ((unused)) int unused2, void* opaque) {
+  libtock_rainfall_callback cb = (libtock_rainfall_callback) opaque;
+  cb(status, rainfall);
+}
+
+returncode_t libtock_rainfall_read(libtock_rainfall_callback cb, int hours) {
+  returncode_t err;
+
+  err = libtock_rainfall_set_upcall(rainfall_upcall, cb);
+  if (err != RETURNCODE_SUCCESS) return err;
+
+  err = libtock_rainfall_command_read(hours);
+  return err;
+}

libtock/sensors/rainfall.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../tock.h"
+#include "syscalls/rainfall_syscalls.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Function signature for rainfall data callback.
+//
+// - `arg1` (`int`): Returncode indicating status from sampling the sensor.
+// - `arg2` (`uint32_t`): the number of um of rain in the time period specified
+typedef void (*libtock_rainfall_callback)(returncode_t, uint32_t);
+
+// Start a rainfall measurement. The reading will be provided via the callback.
+returncode_t libtock_rainfall_read(libtock_rainfall_callback cb, int hours);
+
+#ifdef __cplusplus
+}
+#endif

libtock/sensors/syscalls/rainfall_syscalls.c

@@ -0,0 +1,15 @@
+#include "rainfall_syscalls.h"
+
+bool libtock_rainfall_exists(void) {
+  return driver_exists(DRIVER_NUM_RAINFALL);
+}
+
+returncode_t libtock_rainfall_set_upcall(subscribe_upcall callback, void* opaque) {
+  subscribe_return_t sval = subscribe(DRIVER_NUM_RAINFALL, 0, callback, opaque);
+  return tock_subscribe_return_to_returncode(sval);
+}
+
+returncode_t libtock_rainfall_command_read(int hours) {
+  syscall_return_t rval = command(DRIVER_NUM_RAINFALL, 1, hours, 0);
+  return tock_command_return_novalue_to_returncode(rval);
+}

libtock/sensors/syscalls/rainfall_syscalls.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "../../tock.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DRIVER_NUM_RAINFALL 0x6000B
+
+// Check if the rainfall driver is installed.
+bool libtock_rainfall_exists(void);
+
+// Configure the upcall for when the reading is ready.
+returncode_t libtock_rainfall_set_upcall(subscribe_upcall callback, void* opaque);
+
+// Read the sensor.
+returncode_t libtock_rainfall_command_read(int hours);
+
+#ifdef __cplusplus
+}
+#endif