sensor.c

Go to the documentation of this file.

#include <sensors/sensor.h>
#include <platform-header.h>
//#include <string.h>
 
struct sensordev sensors[] = {
  { 0, &onewire_init, NULL, &onewire_reading_size, &onewire_run, NULL, "ow1:ds18b20", "temp", "celsius", "centi", 207 },
  { 0, &onewire_init, NULL, &onewire_reading_size, &onewire_run, NULL, "ow2:ds18b20", "temp", "celsius", "centi", 211 },
  { 0, &onewire_init, NULL, &onewire_reading_size, &onewire_run, NULL, "ow3:ds18b20", "temp", "celsius", "centi", 212 },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
  { 0, NULL,          NULL, NULL,                  NULL,         NULL, NULL,          NULL,   NULL,      NULL,    0   },
};
 
typedef struct sensorconfig {
  const struct sensordev *      sensor;         /* pointer to the sensor in question */
  long                          target;         /* where to submit it to */
  int                           readmillis;     /* how many milliseconds between reads */
  int                           submitsecs;     /* how may seconds between submitting results to server */
  int                           max_values;     /* how many values to max read between submits. (buffersize) */
} _sensorconfig;
 
static struct sensorconfig defaultconfig = { NULL, CLOUD_SERVER, 60000, 60, 1 };
static uint8_t inited = 0;
static void sensors_timer_irq();
 
static struct sensorconfig sensorconfigs[15];
 
#define SENSOR_FLAG_ENABLED 0
#define SENSOR_FLAG_ISDUE 1
#define SENSOR_FLAG_DETECTED 2
#define SENSOR_FLAG_PROBED 3
// used new-style if the server activated this sensor
#define SENSOR_FLAG_ACTIVATED 4
// if the sensor was registered by the userapp (so we can dynamically deregister it too)
 
static struct sensorruntime runtime[10];
 
#define SENSOR_TIMER_FREQUENCY 1000
#define SENSOR_TIMER 4
 
static byte irqstatus;
static uint8_t runtime_invalid;
static byte sensorbuf[1000];
static byte sensors_enabled;
 
 
#define isOldStyleEnabled (sensors_enabled & (1 << 0))
#define isNewStyleEnabled (sensors_enabled & (1 << 1))
#define isProbing (sensors_enabled & (1 << 2))
 
static const struct sensorconfig *getconfig(const struct sensordev *sensor) {
  const struct sensorconfig *res;
  int i;
 
  if (sensor == NULL) {
    return NULL;
  }
  res = NULL;
  for (i = 0; i < (sizeof(sensorconfigs) / sizeof(sensorconfigs[0])); i++) {
    res = &sensorconfigs[i];
    if (res->sensor == sensor) {
      return res;
    }
  }
  return &defaultconfig;
}
 
static void add_value(struct sensorruntime *sr, int val);
static void reset_if_needed(struct sensorruntime *sr);
 
static void disable_irq() {
  irqstatus |= 2; // forbid irq
  while (irqstatus & 1) {
    // wait for irq to finish
  }
}
 
static void addflagstr(char *res, int bufsize, byte flags, byte flag, char *truestr, char *falsestr) {
  char *cpy = falsestr;
 
  if (flags & (1 << flag)) {
    cpy = truestr;
  }
  char *xr = res + strlen(res);
 
  strncpy(xr, cpy, 100);
  xr[strlen(cpy)] = ' ';
  xr[strlen(cpy) + 1] = 0;
}
static void sensorflags2str(byte flags, char *res, int bufsize) {
  res[0] = 0;
  addflagstr(res, bufsize, flags, SENSOR_FLAG_ENABLED, "ENABLED", "DISABLED");
  addflagstr(res, bufsize, flags, SENSOR_FLAG_ISDUE, "DUE", "IDLE");
  addflagstr(res, bufsize, flags, SENSOR_FLAG_DETECTED, "DETECTED", "NOT_DETECTED");
  addflagstr(res, bufsize, flags, SENSOR_FLAG_PROBED, "PROBED", "NOT_PROBED");
  addflagstr(res, bufsize, flags, SENSOR_FLAG_ACTIVATED, "ACTIVATED", "NOT_ACTIVATED");
}
 
static void enable_irq() {
  irqstatus &= ~2; // allow irq
}
 
static void enable_sensor(struct sensorruntime *sr) {
  sr->flags |= (1 << SENSOR_FLAG_ENABLED);
}
static void disable_sensor(struct sensorruntime *sr) {
  sr->flags &= ~(1 << SENSOR_FLAG_ENABLED);
}
static void clr_sensor_flag(struct sensorruntime *sr, int flag) {
  sr->flags &= ~(1 << flag);
}
static void set_sensor_flag(struct sensorruntime *sr, int flag) {
  sr->flags |= (1 << flag);
}
static int is_sensor_flag(struct sensorruntime *sr, int flag) {
  return sr->flags & (1 << flag);
}
static void sensor_detected(struct sensorruntime *sr) {
  set_sensor_flag(sr, SENSOR_FLAG_DETECTED);
}
 
 
static void add_value(struct sensorruntime *sr, int value) {
  if (sr->valuesize == 1) {
    sr->buf[sr->bytesinbuf++] = value & 0xFF;
    sr->last_value_uint8 = value & 0xFF;
  } else if (sr->valuesize == 2) {
    sr->buf[sr->bytesinbuf++] = value & 0xFF;
    sr->buf[sr->bytesinbuf++] = (value >> 8) & 0xFF;
    sr->last_value_uint16 = value & 0xFFFF;
  } else if (sr->valuesize == 4) {
    sr->buf[sr->bytesinbuf++] = value & 0xFF;
    sr->buf[sr->bytesinbuf++] = (value >> 8) & 0xFF;
    sr->buf[sr->bytesinbuf++] = (value >> 16) & 0xFF;
    sr->buf[sr->bytesinbuf++] = (value >> 24) & 0xFF;
    sr->last_value_uint32 = value;
  }
  sr->values++;
}
 
static uint32_t get_value(struct sensorruntime *sr, int val) {
  if (val >= sr->values) {
    return 0;
  }
  uint32_t res = 0;
 
  if (sr->valuesize == 1) {
    byte b = sr->buf[val];
    res = b;
  } else if (sr->valuesize == 2) {
    byte b = sr->buf[val * 2 + 1];
    res = b;
    res = res << 8;
    res = res | ((sr->buf[val * 2]) & 0xFF);
  } else if (sr->valuesize == 4) {
    int i;
    res = 0;
    for (i = 0; i < 4; i++) {
      uint32_t b = sr->buf[val * 4 + i];
      res = res | (b << (8 * i));
    }
  }
  return res;
}
static void clear_buf(struct sensorruntime *sr) {
  disable_irq();
  sr->bytesinbuf = 0;
  sr->values = 0;
  enable_irq();
}
 
static void init_runtime(const struct sensordev *sd, struct sensorruntime *sr) {
  memset(sr, 0, sizeof(struct sensorruntime));
  sr->sensor = sd;
  sr->valuesize = (uint16_t)sr->sensor->get_reading_size(sd->sensorindex);
}
 
static int calc_bufsize(struct sensorruntime *sr) {
  const struct sensorconfig *sc;
 
  if (!is_sensor_flag(sr, SENSOR_FLAG_ENABLED)) {
    return 0;
  }
  if (!is_sensor_flag(sr, SENSOR_FLAG_PROBED)) {
    return 0;
  }
  if (!is_sensor_flag(sr, SENSOR_FLAG_ACTIVATED)) {
    return 0;
  }
 
  sc = getconfig(sr->sensor);
  int size = sr->valuesize;
  int vals = (sc->submitsecs * 1000) / sc->readmillis;
 
  if (sc->max_values < vals) {
    vals = sc->max_values;
  }
  int res = vals * size;
 
  // only ever even sizes please.
  if (res & 1) {
    res++;
  }
  return res;
}
 
int update_all_runtimes() {
  const struct sensordev *sd;
  struct sensorruntime *sr;
 
  printf("[sensor] updating runtimes\r\n");
  disable_irq();
  memset(sensorbuf, 0, sizeof(sensorbuf));
  int offset = 0;
  int i;
 
  // go through all known runtimes
  for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
    sr = &runtime[i];
    sd = sr->sensor;
    sr->bufsize = 0;
    sr->buf = NULL;
    if (sd == NULL) {
      continue;
    }
    if ((sd->power_on == NULL) || (sd->get_reading == NULL)) {
      continue;
    }
    int bufsize = calc_bufsize(sr);
    if (bufsize == 0) {
      continue;
    }
    sr->bufsize = bufsize;
    sr->buf = (sensorbuf + offset);
    offset = offset + bufsize;
    if (offset >= sizeof(sensorbuf)) {
      enable_irq();
      printf("At sensor %i, buf overflow: %i\r\n", i, offset);
      for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
        sr = &runtime[i];
        sd = sr->sensor;
        if (sd == NULL) {
          continue;
        }
        if ((sd->power_on == NULL) || (sd->get_reading == NULL)) {
          continue;
        }
        int bufsize = calc_bufsize(sr);
        printf("Sensor %i, bufsize: %i\r\n", i, bufsize);
      }
      return 5;
    }
  }
  enable_irq();
  runtime_invalid = 0;
  return 0;
}
 
static void init_all_runtime() {
  const struct sensordev *sd;
  const struct sensorconfig *sc;
 
  int r;
  int t = 2;
 
  disable_irq();
  memset(runtime, 0, sizeof(runtime));
  memset(sensorbuf, 0, sizeof(sensorbuf));
 
  int offset = 0;
 
  // go through all known sensors and init their runtime
  t = 0;
  r = 0;
  while (((sd = &sensors[t])->power_on) != NULL) {
    t++;
    if (sd->get_reading == NULL) {
      printf("[sensor] Sensor does not support reading a value - sensor skipped.\r\n");
      continue;
    }
    init_runtime(sd, &runtime[r]);
    sc = getconfig(sd);
    int bufsize = calc_bufsize(&runtime[r]);
    printf("[sensor] Sensor %s:\r\n", sd->name);
    printf("[sensor]  read every %i milliseconds\r\n", sc->readmillis);
    printf("[sensor]  submit every %i seconds\r\n", sc->submitsecs);
    printf("[sensor]  one reading is %i bytes\r\n", sd->get_reading_size(sd->sensorindex));
    printf("[sensor]  %i bytes between submits\r\n", bufsize);
    runtime[r].bufsize = bufsize;
    runtime[r].buf = (sensorbuf + offset);
    disable_sensor(&runtime[r]);
    reset_if_needed(&runtime[r]);
 
    offset = offset + bufsize;
    r++;
  }
  enable_irq();
}
 
 
void sensors_init() {
  //printf("[sensor] Sensors disabled in code (timer issues)\r\n");
  //return;
  const struct sensordev *sd;
  int r;
 
  runtime_invalid = 0;
  memset(sensorconfigs, 0, sizeof(sensorconfigs));
  memset(runtime, 0, sizeof(runtime));
  irqstatus = 0;
  // go through all known sensors, power them up and init their runtime
  int t = 0;
 
  r = 0;
  while (((sd = &sensors[t])->power_on) != NULL) {
    t++;
    if (sd->name != NULL) {
      printf("[sensor] Initializing sensor #%i: %s\r\n", t, sd->name);
    } else {
      printf("[sensor] Initializing sensor #%i: [noname]\r\n", t);
    }
    if (sd->get_reading == NULL) {
      printf("[sensor] Sensor does not support reading a value - sensor skipped.\r\n");
      continue;
    }
    sd->power_on(sd->sensorindex);
    r++;
  }
  init_all_runtime();
  // last but not least - enable the timer
  if ((r = mculib_timer_enable_simple(MAIN_MCULIBHANDLE, SENSOR_TIMER, SENSOR_TIMER_FREQUENCY, &sensors_timer_irq))) {
    printf("[sensor] Failed to activate timer %i for TLI4970: %i\r\n", SENSOR_TIMER, r);
    return;
  }
  sensors_enabled = 5; // enable old-style only and set it to probe mode
  inited = 1;
  printf("[sensor] Sensors initialized\r\n");
}
static void reset_if_needed(struct sensorruntime *sr) {
  char buf[100];
  int res;
  const struct sensordev *sd;
 
  sd = sr->sensor;
  if (sd->get_status == NULL) {
    enable_sensor(sr); // we can't check status, assume it's ok
    return;
  }
  sd->get_status(sd->sensorindex, (char *)&buf, sizeof(buf), &res);
  if (res == 0) {
    enable_sensor(sr);
    return;
  }
  disable_sensor(sr);
  printf("[sensor] Status: %i (%s) - resetting\r\n", res, buf);
  if (sd->power_down != NULL) {
    printf("[sensor]   power off\r\n");
    sd->power_down(sd->sensorindex);
    Delay(50);
  }
  if (sd->power_on != NULL) {
    printf("[sensor]   power on\r\n");
    sd->power_on(sd->sensorindex);
    Delay(30);
    printf("[sensor]   power cycle complete\r\n");
  }
  sd->get_status(sd->sensorindex, (char *)&buf, sizeof(buf), &res);
  if (res == 0) {
    enable_sensor(sr);
    return;
  }
}
 
static void send_values(const struct sensorconfig *sc, struct sensorruntime *sr) {
  struct command *com = alloc_command();
  const struct sensordev *sd;
 
  sd = sr->sensor;
  if (com == NULL) {
    printf("[sensor] Cannot send command - no command space available\r\n");
    return;
  }
  command_init(com);
  com->recipient = 0;
  com->target = sc->target;
  com->flags = COMFLAGS_SUCCESS;
  com->com = 22;
  command_add_arg(com, sd->name);
  command_add_arg(com, "1");
  command_add_arg(com, sd->type);
  command_add_arg(com, sd->unit);
  command_add_arg(com, sd->unit_prefix);
  char buf[150];
  int k;
 
  memset(buf, 0, sizeof(buf));
  disable_irq();
  for (k = 0; k < sr->values; k++) {
    if (sr->valuesize < 4) {
      snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X;", get_value(sr, k));
    } else {
      snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%N;", get_value(sr, k));
    }
    if (strlen(buf) >= sizeof(buf)) {
      break;
    }
  }
  enable_irq();
  clear_buf(sr);
  //printf("[sensor] Args: \"%s\"\r\n",buf);
  command_add_arg(com, "%s", buf);
  deliver_command(com, NULL);
}
 
void sensor_info() {
  const struct sensordev *sd;
  struct sensorruntime *sr;
  int i;
 
  char buf[100];
  int status;
 
  printf("[sensor] Sensor info at %i:\r\n", mculib_get_seconds_since_boot());
  printf("[sensor]  timerfrequency: %iHz\r\n", SENSOR_TIMER_FREQUENCY);
  printf("[sensor]  Enabled status: %i\r\n", sensors_enabled);
  char flagstr[100];
 
  for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
    sr = &runtime[i];
    sd = sr->sensor;
    if (sd == NULL) {
      continue;
    }
    snprintf(buf, sizeof(buf), "n/a");
    status = 0;
    if (sd->get_status != NULL) {
      sd->get_status(sd->sensorindex, (char *)&buf, sizeof(buf), &status);
    }
    sensorflags2str(sr->flags, (char *)&flagstr, sizeof(flagstr));
    const struct sensorconfig *sc = getconfig(sd);
    printf("[sensor]   Sensor #%i: %s\r\n", i, sd->name);
    printf("[sensor]     status  : %i (%s)\r\n", status, buf);
    printf("[sensor]     flags   : %i (%s)\r\n", (int)sr->flags, flagstr);
    printf("[sensor]     values  : %i\r\n", (int)sr->values);
    printf("[sensor]     bytes   : %i\r\n", (int)sr->bytesinbuf);
    printf("[sensor]     bufsize : %i\r\n", sr->bufsize);
    printf("[sensor]     maxvals : %i\r\n", sc->max_values);
    printf("[sensor]     runsecs : %i\r\n", (int)sr->runsecs);
    printf("[sensor]     read    : every %i millis\r\n", sc->readmillis);
    pretty_node_to_str(sc->target, buf);
    printf("[sensor]     submit  : every %i secs to %s\r\n", sc->submitsecs, buf);
  }
  printf("[sensor] End sensor info\r\n");
}
 
struct sensorruntime *get_runtime(int idx) {
  struct sensorruntime *sr;
 
  sr = &runtime[idx];
  return sr;
}
 
/*
 * \*brief set the configuration for a given sensor. idx=0..n return 0 if ok
 */
int sensor_update_config(const long nodeid, int idx, const int readmillis, const int submitsec, const int max_values) {
  struct sensorruntime *sr;
  const struct sensordev *sd;
  struct sensorconfig *sc;
  struct sensorconfig *res;
  int i;
 
  if ((readmillis == 0) || (submitsec == 0) || (max_values == 0)) {
    return 1;
  }
  sr = get_runtime(idx);
  if (sr == NULL) {
    printf("[sensor] No such sensor \"%i\"\r\n", idx);
    return 2;
  }
  sd = sr->sensor;
  sc = (struct sensorconfig *)getconfig(sd);
 
  if ((sc == NULL) || (sc == &defaultconfig)) {
    // create new config entry!
    sc = NULL;
    for (i = 0; i < (sizeof(sensorconfigs) / sizeof(sensorconfigs[0])); i++) {
      res = &sensorconfigs[i];
      if (res->sensor == NULL) {
        sc = res;
        break;
      }
    }
    if (sc == NULL) {
      printf("[sensor] No more free sensor config entries.\r\n");
      return 3;
    }
  }
 
  // sc -> pointer to config to be updated to initialized
  sc->sensor = sd;
  sc->target = nodeid;
  sc->readmillis = readmillis;
  sc->submitsecs = submitsec;
  sc->max_values = max_values;
  int r = update_all_runtimes(); // recalculate buffers
 
  if (r != 0) {
    printf("[sensor] failed to update runtime (%i)\r\n", r);
    return r;
  }
  //  init_all_runtime(); // cannot do that, because it will overwrite flags
  return 0;
}
 
int sensor_submit_request(const long nodeid, int idx, const int readmillis, const int submitsec, const int max_values) {
  char buf[100];
 
  pretty_node_to_str(nodeid, buf);
  printf("[sensor] Got request from %s for sensor %i, read every %i millis, submit every %i seconds, maximum values %i\r\n",
         buf,
         idx,
         readmillis,
         submitsec,
         max_values);
  int x = sensor_update_config(nodeid, idx, readmillis, submitsec, max_values);
 
  if (x != 0) {
    printf("[sensor] Sensor request failed: %i\r\n", x);
    return x;
  }
  return 1;
}
void sensors_newstyle() {
  sensors_enabled &= ~(1 << 0);
  sensors_enabled |= (1 << 1);
}
 
void sensors_off() {
  int r;
 
  sensors_enabled &= ~(1 << 0);
  if ((r = mculib_timer_disable(MAIN_MCULIBHANDLE, SENSOR_TIMER)) != 0) {
    printf("[sensor] Failed to disable timer %i: %i\r\n", SENSOR_TIMER, r);
    return;
  }
  printf("[sensor] Sensor timer disabled\r\n");
}
 
struct sensordev *sensor_register(struct sensordev *sensor) {
  sensors_off();
  int t = 0;
 
  int max = sizeof(sensors) / sizeof(struct sensordev);
 
  while ((sensors[t].power_on) != NULL) {
    t++;
    if (t >= max) {
      printf("[sensor] No sensor entry available to register sensor. (max=%i,t=%i)\r\n", max, t);
      return NULL;
    }
  }
  int i;
  byte *source = (void *)sensor;
  byte *target = (void *)&sensors[t];
 
  for (i = 0; i < sizeof(struct sensordev); i++) {
    target[i] = source[i];
  }
  sensors_init();
  if (sensor->name != NULL) {
    printf("[sensor] Sensor %s registered\r\n", sensor->name);
  } else {
    printf("[sensor] extra sensor with no name registered\r\n");
  }
  return &sensors[t];
}
 
static int isDigit(char c) {
  if ((c >= '0') && (c <= '9')) {
    return 1;
  }
  return 0;
}
 
static int parse_numbers(const char *str, int bufcount, int buf[]) {
  int res = 0;
  int i;
  int state = 0;
 
  for (i = 0; i < strlen(str); i++) {
    char c = str[i];
    if (state == 0) {
      if (!isDigit(c)) {
        continue;
      }
      state = 1;
      buf[res++] = atoi(str + i);
    }
    if (state == 1) {
      if (!isDigit(c)) {
        state = 0;
        continue;
      }
    }
  }
  return res;
}
void sensor_run_str(const char *str) {
  struct sensorruntime *sr;
  const struct sensordev *sd;
  int buf[3];
 
  printf("[sensor] Sensor run \"%s\"\r\n", str);
  int r = parse_numbers(str, (sizeof(buf) / sizeof(buf[0])), (int *)&buf);
 
  if (r != 2) {
    printf("[sensor] Need exactly 2 digits [s a] (s=sensor index, a=action]. got %i. Aborted.\r\n", r);
    return;
  }
 
  int sensor = buf[0];
  int action = buf[1];
 
  int ms = (sizeof(runtime) / sizeof(runtime[0]));
 
  if (sensor >= ms) {
    printf("[sensor] Sensor index out of range: %i (0-%i)\r\n", sensor, ms);
    return;
  }
  sr = &runtime[sensor];
  sd = sr->sensor;
  if (sd == NULL) {
    printf("[sensor] No sensor #%i\r\n", sensor);
    return;
  }
  printf("[sensor] Sensor \"%s\": %i\r\n", sd->name, action);
  if (action == 0) {
    printf("[sensor] power_on(): %i\r\n", sd->power_on(sd->sensorindex));
  } else if (action == 1) {
    printf("[sensor] power_down(): %i\r\n", sd->power_down(sd->sensorindex));
  } else if (action == 2) {
    printf("[sensor] get_reading_size() == %i\r\n", sd->get_reading_size(sd->sensorindex));
  } else if (action == 3) {
    byte error = 0;
    printf("[sensor] get_reading() == %i\r\n", sd->get_reading(sd->sensorindex, &error));
  } else if (action == 4) {
    char buf[100];
    int st;
    sd->get_status(sd->sensorindex, (char *)&buf, 100, &st);
    printf("[sensor] get_status() == %s %i\r\n", buf, st);
  } else {
    printf("[sensor] Invalid action (0=pwron,1=pwroff,2=readingsize,3=reading,4=status\r\n");
  }
}
 
int all_sensors_probed() {
  struct sensorruntime *sr;
  int i;
 
  for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
    sr = &runtime[i];
    if (!is_sensor_flag(sr, SENSOR_FLAG_ENABLED)) {
      continue;
    }
    if (!is_sensor_flag(sr, SENSOR_FLAG_PROBED)) {
      return 0;
    }
  }
  return 1;
}
 
 
void sensor_activation(struct sensorruntime *sr, int activation) {
  if (activation) {
    sr->flags |= (1 << SENSOR_FLAG_ACTIVATED);
  } else {
    sr->flags &= ~(1 << SENSOR_FLAG_ACTIVATED);
  }
}
 
/***************************************************************
* functions to probe stuff
***************************************************************/
void sensor_probe() {
  const struct sensordev *sd;
  struct sensorruntime *sr;
 
  int i;
 
  for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
    sr = &runtime[i];
    sd = sr->sensor;
    if (sd == NULL) {
      continue;
    }
    // only probe each sensor once
    if (is_sensor_flag(sr, SENSOR_FLAG_PROBED)) {
      continue;
    }
    if (!is_sensor_flag(sr, SENSOR_FLAG_ENABLED)) {
      disable_irq();
      reset_if_needed(sr);
      enable_irq();
    }
    // if sensor requires IRQ, don't process it here...
    if (sd->cfg_flags & (1 << SENSOR_CONFIG_FLAG_IRQ)) {
      continue;
    }
    byte error = 0;
    clr_sensor_flag(sr, SENSOR_FLAG_DETECTED);
    sd->get_reading(sd->sensorindex, &error);
    if (error == 0) {
      sensor_detected(sr);
    }
    set_sensor_flag(sr, SENSOR_FLAG_PROBED);
    clr_sensor_flag(sr, SENSOR_FLAG_ISDUE);
  }
 
  // check if all are probed, if so, finish probemode
  int done = 1;
 
  for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
    sr = &runtime[i];
    sd = sr->sensor;
    if (sd == NULL) {
      continue;
    }
    if (!is_sensor_flag(sr, SENSOR_FLAG_PROBED)) {
      done = 0;
      break;
    }
  }
  if (done) {
    sensors_enabled &= ~(1 << 2); // stop probing mode.
  }
}
uint8_t sensors_inited() {
  return inited;
}
/***************************************************************
* functions to determine if sensors are due
***************************************************************/
int sensor_loop() {
  if (runtime_invalid) {
    update_all_runtimes();
  }
  if (!sensors_inited()) {
    return 0;
  }
  if (isProbing) {
    sensor_probe();
    return 0;
  }
  const struct sensordev *sd;
  struct sensorruntime *sr;
 
  int i;
  int got_values = 0;
 
  for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
    sr = &runtime[i];
    sd = sr->sensor;
    if (sd == NULL) {
      continue;
    }
 
    const struct sensorconfig *sc = getconfig(sd);
    // if sensor is disabled it might still need resetting!
    if (!is_sensor_flag(sr, SENSOR_FLAG_ENABLED)) {
      if (!mculib_has_time_passed(sc->submitsecs < 30 ? 30 : sc->submitsecs, &sr->runsecs)) {
        continue;
      }
      printf("[sensor] Sensor %s is disabled, resetting it.\r\n", sd->name);
      reset_if_needed(sr);
      continue;
    }
 
    if (is_sensor_flag(sr, SENSOR_FLAG_ISDUE)) {
      set_sensor_flag(sr, SENSOR_FLAG_PROBED);
      byte error = 0;
      int value = sd->get_reading(sd->sensorindex, &error);
      if (error == 0) {
        sensor_detected(sr);
        add_value(sr, value);
      }
      clr_sensor_flag(sr, SENSOR_FLAG_ISDUE);
    }
 
    if (sr->values == 0) {
      continue;
    }
 
    if (!mculib_has_time_passed(sc->submitsecs, &sr->runsecs)) {
      continue;
    }
    printf("[sensor] Sensor %s has %i values ready to submit\r\n", sd->name, sr->values);
    send_values(sc, sr);
    got_values = 1;
    reset_if_needed(sr);
  }
  return got_values;
}
static void sensors_timer_irq() {
  if (irqstatus & 2) {
    return;
  }
 
  if (isProbing) {
    const struct sensordev *sd;
    struct sensorruntime *sr;
    /*  probing - due are _any_ that are not yet probed*/
    int i;
    for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
      sr = &runtime[i];
      sd = sr->sensor;
      if (sd == NULL) {
        continue;
      }
      if (!is_sensor_flag(sr, SENSOR_FLAG_ENABLED)) {
        continue;
      }
      if (is_sensor_flag(sr, SENSOR_FLAG_PROBED)) {
        continue;
      }
      if (is_sensor_flag(sr, SENSOR_FLAG_ISDUE)) {
        continue;
      }
      if (sd->cfg_flags & (1 << SENSOR_CONFIG_FLAG_IRQ)) {
        byte error = 0;
        int value = sd->get_reading(sd->sensorindex, &error);
        if (error == 0) {
          sensor_detected(sr);
          add_value(sr, value);
        }
        set_sensor_flag(sr, SENSOR_FLAG_PROBED);
      }
    }
    return;
  }
 
  /* not probing */
  irqstatus |= 1;
  const struct sensordev *sd;
  struct sensorruntime *sr;
  int i;
 
  for (i = 0; i < (sizeof(runtime) / sizeof(runtime[0])); i++) {
    sr = &runtime[i];
    sd = sr->sensor;
    if (sd == NULL) {
      continue;
    }
    if (!is_sensor_flag(sr, SENSOR_FLAG_ENABLED)) {
      continue;
    }
    if (!isOldStyleEnabled && isNewStyleEnabled) {
      if (!is_sensor_flag(sr, SENSOR_FLAG_ACTIVATED)) {
        continue;
      }
    }
 
    if (is_sensor_flag(sr, SENSOR_FLAG_ISDUE)) {
      continue;
    }
    sr->runctr--;
    if (sr->runctr > 0) {
      continue;
    }
    const struct sensorconfig *sc = getconfig(sd);
    sr->runctr = sc->readmillis;
    if ((sr->buf == NULL) || (sr->bufsize == 0)) {
      runtime_invalid = 1;
      printf("[sensor] attempt to read sensor %i, but no buf (buf=%p,size=%i)\r\n", i, sr->buf, sr->bufsize);
      continue;
    }
    if (sr->valuesize > (sr->bufsize - sr->bytesinbuf)) {
      //printf("[sensor] %s sensor: buf overflow\r\n",sr->sensor->name);
      continue;   // buf is full!
    }
 
    if (sr->values >= sc->max_values) {
      //printf("[sensor] %s sensor: values overflow (%i values, max=%i)\r\n",sr->sensor->name,sr->values,sc->max_values);
      continue;   // read enough values between submits...
    }
    if (sd->cfg_flags & (1 << SENSOR_CONFIG_FLAG_IRQ)) {
      byte error = 0;
      set_sensor_flag(sr, SENSOR_FLAG_PROBED);
      int value = sd->get_reading(sd->sensorindex, &error);
      if (error == 0) {
        sensor_detected(sr);
        add_value(sr, value);
      }
    } else {
      set_sensor_flag(sr, SENSOR_FLAG_ISDUE);
    }
    //printf("[sensor] Value of sensor %s: %i\r\n",sd->name,value);
  }
  irqstatus &= ~1;
}
 
void sensor_deregister(struct sensordev *sensor) {
  sensors_off();
  sensor->power_on = NULL; // without power-on function, it's not a valid sensor
  sensors_init();
}