ra8_esp_hosted_gpio_edge.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_gpio_internal.h"
#include "ra8_icu_regs.h"
#include "ra8_log.h"
#include "ra8_pin_interface.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#ifdef RA8_OFF_TARGET
#include "ra8_esp_hosted_tx_shim_sync_internal.h"
#else
#include "tx_api.h"
#endif

static const char* const s_tag = "eh_edge";

typedef enum : uint8_t {
  k_ra8_esp_hosted_gpio_edge_low     = 0U, 
  k_ra8_esp_hosted_gpio_edge_high    = 1U, 
  k_ra8_esp_hosted_gpio_edge_one_row = 1U, 
} ra8_esp_hosted_gpio_edge_const_t;

typedef struct ra8_esp_hosted_gpio_edge_row {
  ra8_port_pin_t pin;         
  void (*handler)(void* arg); 
  void*   arg;                
  uint8_t sense;              
  uint8_t last_level;         
  bool    used;               
} ra8_esp_hosted_gpio_edge_row_t;

static ra8_esp_hosted_gpio_edge_row_t s_rows[k_ra8_esp_hosted_gpio_row_max];

static TX_TIMER s_timer;

static bool s_timer_live;

static uint16_t s_poll_ms = (uint16_t)k_ra8_esp_hosted_gpio_poll_ms_default;

static char s_tx_name_eh_edge[] = "eh_edge";
 
RA8_PRIV bool
priv_ra8_esp_hosted_gpio_edge_seen(uint8_t prev_level, uint8_t now_level, uint8_t sense)
{
  if (sense > (uint8_t)k_ra8_icu_irqmd_low) {
    return false;
  }
  if (sense == (uint8_t)k_ra8_icu_irqmd_low) {
    return now_level == (uint8_t)k_ra8_esp_hosted_gpio_edge_low;
  }
  if (prev_level == now_level) {
    return false;
  }
  if (sense == (uint8_t)k_ra8_icu_irqmd_both) {
    return true;
  }
  if (sense == (uint8_t)k_ra8_icu_irqmd_rising) {
    return now_level == (uint8_t)k_ra8_esp_hosted_gpio_edge_high;
  }
  return now_level == (uint8_t)k_ra8_esp_hosted_gpio_edge_low;
}

RA8_INTERNAL
static uint8_t internal_find(ra8_port_pin_t pin)
{
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_gpio_row_max; i++) {
    if (s_rows[i].used && (s_rows[i].pin == pin)) {
      return i;
    }
  }
  return (uint8_t)k_ra8_esp_hosted_gpio_row_max;
}

RA8_INTERNAL
static bool internal_sample(ra8_port_pin_t pin, uint8_t* out_level)
{
  const ra8_pin_interface_t* pin_if = priv_ra8_esp_hosted_gpio_pin_interface();
  ra8_level_t                level  = k_ra8_level_low;
  if (pin_if->read(pin_if->ctx, pin, &level) != k_ra8_ok) {
    return false;
  }
  *out_level = (level == k_ra8_level_high) ? (uint8_t)k_ra8_esp_hosted_gpio_edge_high
                                           : (uint8_t)k_ra8_esp_hosted_gpio_edge_low;
  return true;
}

RA8_INTERNAL
static void internal_timer_expiry(ULONG arg)
{
  (void)arg;
  priv_ra8_esp_hosted_gpio_edge_poll_once();
}

RA8_INTERNAL
static ra8_err_t internal_timer_arm(void)
{
  if (s_timer_live) {
    return k_ra8_ok;
  }
  const ULONG ticks = (ULONG)s_poll_ms;
  const UINT  st    = tx_timer_create(&s_timer,
                                      s_tx_name_eh_edge,
                                      internal_timer_expiry,
                                      (ULONG)0,
                                      ticks,
                                      ticks,
                                      TX_AUTO_ACTIVATE);
  if (st != TX_SUCCESS) {
    ra8_log_error_val(s_tag, "edge timer create failed", (uint32_t)st);
    return k_ra8_err_rtos_error;
  }
  s_timer_live = true;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_timer_disarm(void)
{
  if (!s_timer_live) {
    return k_ra8_ok;
  }
  const UINT st = tx_timer_delete(&s_timer);
  if (st != TX_SUCCESS) {
    ra8_log_error_val(s_tag, "edge timer delete failed", (uint32_t)st);
    return k_ra8_err_rtos_error;
  }
  s_timer_live = false;
  return k_ra8_ok;
}
 
RA8_PRIV uint8_t priv_ra8_esp_hosted_gpio_edge_count(void)
{
  uint8_t count = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_gpio_row_max; i++) {
    if (s_rows[i].used) {
      count = (uint8_t)(count + (uint8_t)k_ra8_esp_hosted_gpio_edge_one_row);
    }
  }
  return count;
}
 
RA8_PRIV ra8_err_t priv_ra8_esp_hosted_gpio_set_edge_poll_ms(uint16_t period_ms)
{
  if (period_ms == 0U) {
    return k_ra8_err_invalid_arg;
  }
  s_poll_ms = period_ms;
  if (!s_timer_live) {
    return k_ra8_ok;
  }
  const ra8_err_t err = internal_timer_disarm();
  return (err == k_ra8_ok) ? internal_timer_arm() : err;
}
 
RA8_PRIV ra8_err_t priv_ra8_esp_hosted_gpio_edge_register(ra8_port_pin_t pin,
                                                          uint8_t        sense,
                                                          void (*handler)(void*),
                                                          void* arg)
{
  if (handler == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (sense > (uint8_t)k_ra8_icu_irqmd_low) {
    return k_ra8_err_invalid_arg;
  }
  if (internal_find(pin) < (uint8_t)k_ra8_esp_hosted_gpio_row_max) {
    return k_ra8_err_exists;
  }
  uint8_t slot = (uint8_t)k_ra8_esp_hosted_gpio_row_max;
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_gpio_row_max; i++) {
    if (!s_rows[i].used) {
      slot = i;
      break;
    }
  }
  if (slot >= (uint8_t)k_ra8_esp_hosted_gpio_row_max) {
    return k_ra8_err_no_mem;
  }
 
  const ra8_err_t err = ra8_gpio_input_init(pin, k_ra8_pull_none);
  if (err != k_ra8_ok) {
    ra8_log_error_val(s_tag, "polled pin input init failed", (uint32_t)err);
    return err;
  }
  uint8_t level = (uint8_t)k_ra8_esp_hosted_gpio_edge_low;
  (void)internal_sample(pin, &level);
 
  s_rows[slot].pin        = pin;
  s_rows[slot].handler    = handler;
  s_rows[slot].arg        = arg;
  s_rows[slot].sense      = sense;
  s_rows[slot].last_level = level;
  s_rows[slot].used       = true;
 
  const ra8_err_t timer_err = internal_timer_arm();
  if (timer_err != k_ra8_ok) {
    s_rows[slot] = (ra8_esp_hosted_gpio_edge_row_t){};
    (void)ra8_gpio_release(pin);
  }
  return timer_err;
}
 
RA8_PRIV ra8_err_t priv_ra8_esp_hosted_gpio_edge_unregister(ra8_port_pin_t pin)
{
  const uint8_t slot = internal_find(pin);
  if (slot >= (uint8_t)k_ra8_esp_hosted_gpio_row_max) {
    return k_ra8_err_not_found;
  }
  s_rows[slot] = (ra8_esp_hosted_gpio_edge_row_t){};
  (void)ra8_gpio_release(pin);
  if (priv_ra8_esp_hosted_gpio_edge_count() != 0U) {
    return k_ra8_ok;
  }
  return internal_timer_disarm();
}
 
RA8_PRIV void priv_ra8_esp_hosted_gpio_edge_poll_once(void)
{
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_gpio_row_max; i++) {
    ra8_esp_hosted_gpio_edge_row_t* row = &s_rows[i];
    uint8_t                         now = (uint8_t)k_ra8_esp_hosted_gpio_edge_low;
    if (row->used && internal_sample(row->pin, &now)) {
      const uint8_t prev = row->last_level;
      row->last_level    = now;
      if (priv_ra8_esp_hosted_gpio_edge_seen(prev, now, row->sense)) {
        row->handler(row->arg);
      }
    }
  }
}