twr_flood_detector.c

#include <twr_flood_detector.h>
 
#define _TWR_FLOOD_DETECTOR_DELAY_RUN 50
 
static void _twr_flood_task_interval(void *param);
 
static void _twr_flood_task_measure(void *param);
 
void twr_flood_detector_init(twr_flood_detector_t *self, twr_flood_detector_type_t type)
{
    memset(self, 0, sizeof(&self));
    self->_type = type;
    self->_task_id_interval = twr_scheduler_register(_twr_flood_task_interval, self, TWR_TICK_INFINITY);
    self->_task_id_measure = twr_scheduler_register(_twr_flood_task_measure, self, _TWR_FLOOD_DETECTOR_DELAY_RUN);
}
 
void twr_flood_detector_set_event_handler(twr_flood_detector_t *self, void (*event_handler)(twr_flood_detector_t *, twr_flood_detector_event_t, void*), void *event_param)
{
    self->_event_handler = event_handler;
    self->_event_param = event_param;
}
 
void twr_flood_detector_set_update_interval(twr_flood_detector_t *self, twr_tick_t interval)
{
    self->_update_interval = interval;
 
    if (self->_update_interval == TWR_TICK_INFINITY)
    {
        twr_scheduler_plan_absolute(self->_task_id_interval, TWR_TICK_INFINITY);
    }
    else
    {
        twr_scheduler_plan_relative(self->_task_id_interval, self->_update_interval);
    }
}
 
bool twr_flood_detector_measure(twr_flood_detector_t *self)
{
    if (self->_measurement_active)
    {
        return false;
    }
 
    self->_measurement_active = true;
 
    twr_scheduler_plan_now(self->_task_id_measure);
 
    return true;
}
 
bool twr_flood_detector_is_alarm(twr_flood_detector_t *self)
{
    return self->_alarm;
}
 
static void _twr_flood_task_interval(void *param)
{
    twr_flood_detector_t *self = (twr_flood_detector_t *) param;
 
    twr_flood_detector_measure(self);
 
    twr_scheduler_plan_current_relative(self->_update_interval);
}
 
static void _twr_flood_task_measure(void *param)
{
    twr_flood_detector_t *self = (twr_flood_detector_t *) param;
 
start:
 
    switch (self->_state)
    {
        case TWR_FLOOD_DETECTOR_STATE_ERROR:
        {
            self->_measurement_active = false;
 
            if (self->_event_handler != NULL)
            {
                self->_event_handler(self, TWR_FLOOD_DETECTOR_EVENT_ERROR, self->_event_param);
            }
 
            self->_state = TWR_FLOOD_DETECTOR_STATE_INITIALIZE;
 
            return;
        }
        case TWR_FLOOD_DETECTOR_STATE_INITIALIZE:
        {
            self->_state = TWR_FLOOD_DETECTOR_STATE_ERROR;
 
            switch (self->_type)
            {
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_A:
                {
                    if (!twr_module_sensor_init())
                    {
                        goto start;
                    }
                    twr_gpio_init(TWR_GPIO_P4);
                    twr_gpio_set_mode(TWR_GPIO_P4, TWR_GPIO_MODE_INPUT);
                    break;
                }
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_B:
                {
                    if (!twr_module_sensor_init())
                    {
                        goto start;
                    }
                    twr_gpio_init(TWR_GPIO_P5);
                    twr_gpio_set_mode(TWR_GPIO_P5, TWR_GPIO_MODE_INPUT);
                    break;
                }
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_C:
                {
                    if (!twr_module_sensor_init())
                    {
                        goto start;
                    }
                    twr_module_sensor_set_vdd(true);
                    twr_gpio_init(TWR_GPIO_P7);
                    twr_gpio_set_mode(TWR_GPIO_P7, TWR_GPIO_MODE_INPUT);
                    break;
                }
                default:
                {
                    goto start;
                }
            }
 
            self->_state = TWR_FLOOD_DETECTOR_STATE_READY;
 
            if (self->_measurement_active)
            {
                twr_scheduler_plan_current_now();
            }
            return;
        }
        case TWR_FLOOD_DETECTOR_STATE_READY:
        {
            self->_state = TWR_FLOOD_DETECTOR_STATE_ERROR;
 
            switch (self->_type)
            {
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_A:
                {
                    if (!twr_module_sensor_set_pull(TWR_MODULE_SENSOR_CHANNEL_A, TWR_MODULE_SENSOR_PULL_UP_4K7))
                    {
                        goto start;
                    }
                    twr_scheduler_plan_current_from_now(5);
                    break;
                }
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_B:
                {
                    if (!twr_module_sensor_set_pull(TWR_MODULE_SENSOR_CHANNEL_B, TWR_MODULE_SENSOR_PULL_UP_4K7))
                    {
                        goto start;
                    }
                    twr_scheduler_plan_current_from_now(5);
                    break;
                }
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_C:
                {
                    twr_scheduler_plan_current_from_now(5);
                    break;
                }
                default:
                {
                    goto start;
                }
            }
 
            self->_state = TWR_FLOOD_DETECTOR_STATE_MEASURE;
            return;
        }
        case TWR_FLOOD_DETECTOR_STATE_MEASURE:
        {
            self->_state = TWR_FLOOD_DETECTOR_STATE_ERROR;
 
            switch (self->_type)
            {
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_A:
                {
                    self->_alarm = twr_gpio_get_input(TWR_GPIO_P4) == 1;
 
                    if (!twr_module_sensor_set_pull(TWR_MODULE_SENSOR_CHANNEL_A, TWR_MODULE_SENSOR_PULL_NONE))
                    {
                        goto start;
                    }
                    break;
                }
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_B:
                {
                    self->_alarm = twr_gpio_get_input(TWR_GPIO_P5) == 1;
 
                    if (!twr_module_sensor_set_pull(TWR_MODULE_SENSOR_CHANNEL_B, TWR_MODULE_SENSOR_PULL_NONE))
                    {
                        goto start;
                    }
                    break;
                }
                case TWR_FLOOD_DETECTOR_TYPE_LD_81_SENSOR_MODULE_CHANNEL_C:
                {
                    self->_alarm = twr_gpio_get_input(TWR_GPIO_P7) == 1;
                    break;
                }
                default:
                {
                    goto start;
                }
            }
            self->_measurement_active = false;
 
            if (self->_event_handler != NULL)
            {
                self->_event_handler(self, TWR_FLOOD_DETECTOR_EVENT_UPDATE, self->_event_param);
            }
 
            self->_state = TWR_FLOOD_DETECTOR_STATE_READY;
 
        }
        default:
            break;
    }
}