main.c

#include "picoRTOS.h"
#include "picoRTOS_device.h"

#include "board.h"

/*
 * Main shared objects
 */
#define STATUS_ALARM      (1 << 3)
#define STATUS_HEATER     (1 << 2)
#define STATUS_FAN        (1 << 1)
#define STATUS_COMPRESSOR (1 << 0)

static struct  {
    /* temp */
    int t_fridge;
    int t_freezer;
    int t_heater;
    /* i/o */
    int knob;
    bool door_opened;
    /* status */
    bool defrost;
    unsigned status;
    unsigned alarm_counter;
} fridge;

static void led_main(void *priv)
{
    picoRTOS_assert_fatal(priv != NULL, return );

    struct gpio *L = (struct gpio*)priv;
    picoRTOS_tick_t ref = picoRTOS_get_tick();

    for (;;) {
        gpio_write(L, false);
        picoRTOS_sleep(PICORTOS_DELAY_MSEC(40ul));
        gpio_write(L, true);
        picoRTOS_sleep(PICORTOS_DELAY_MSEC(40ul));
        gpio_write(L, false);
        picoRTOS_sleep(PICORTOS_DELAY_MSEC(120ul));
        gpio_write(L, true);

        /* until next round */
        picoRTOS_sleep_until(&ref, PICORTOS_DELAY_SEC(1));
    }
}

static void analog_main(void *priv)
{
#define T_FRIDGE_MIN     0
#define T_FREEZER_MIN  -24
#define T_HEATER_MAX     2
#define T_AVG_WEIGHT     3
#define ALARM_THRES     30u
    picoRTOS_assert_fatal(priv != NULL, return );

    struct board *board = (struct board*)priv;
    picoRTOS_tick_t ref = picoRTOS_get_tick();

    int t_fridge = T_FRIDGE_MIN;
    int t_freezer = T_FREEZER_MIN;
    int t_heater = T_FRIDGE_MIN;

    for (;;) {

        int k, d;
        int t0, t1, t2;

        while (adc_read(board->T_FRIDGE, &t0) == -EAGAIN) picoRTOS_postpone();
        while (adc_read(board->T_FREEZER, &t1) == -EAGAIN) picoRTOS_postpone();
        while (adc_read(board->T_HEATER, &t2) == -EAGAIN) picoRTOS_postpone();
        while (adc_read(board->KNOB, &k) == -EAGAIN) picoRTOS_postpone();
        while (adc_read(board->DOOR, &d) == -EAGAIN) picoRTOS_postpone();

        /* average as a filter */
        t_fridge = ((t_fridge * T_AVG_WEIGHT) + t0) / (T_AVG_WEIGHT + 1);
        t_freezer = ((t_freezer * T_AVG_WEIGHT) + t1) / (T_AVG_WEIGHT + 1);
        t_heater = ((t_heater * T_AVG_WEIGHT) + t2) / (T_AVG_WEIGHT + 1);

        /* Main state machine */
        fridge.status = 0;

        if (!fridge.defrost) {
            /* Freezer conditions */
            if (t_freezer > (T_FREEZER_MIN + k) &&
                t_heater > T_FREEZER_MIN)
                fridge.status |= STATUS_COMPRESSOR;

            /* Fridge conditions (only fans) */
            if (t_fridge > (T_FRIDGE_MIN + k))
                fridge.status |= STATUS_FAN;

            /* Heater conditions */
            if (fridge.status == 0 && t_heater > t_freezer)
                /* we have inertia on our side */
                fridge.defrost = true;

        }else{
            /* defrosting */
            fridge.status = STATUS_HEATER;
            /* reached T_HEATER_MAX, end cycle */
            fridge.defrost = (t_heater < T_HEATER_MAX);
        }

        /* Alarm conditions */
        if (fridge.alarm_counter > ALARM_THRES)
            fridge.status |= STATUS_ALARM;

        /* save values */
        fridge.t_fridge = t_fridge;
        fridge.t_freezer = t_freezer;
        fridge.t_heater = t_heater;
        fridge.knob = k;
        fridge.door_opened = (d != 0);

        /* turn light on */
        gpio_write(board->LIGHT, fridge.door_opened);
        if (fridge.door_opened) {
            fridge.status &= ~STATUS_FAN;   /* stop the fan */
            fridge.alarm_counter++;         /* count */
        }else
            fridge.alarm_counter = 0;

        /* until next round */
        picoRTOS_sleep_until(&ref, PICORTOS_DELAY_SEC(1));
    }
}

static void cold_main(void *priv)
{
#define COMPRESSOR_N 6 /* cycles */
    picoRTOS_assert_fatal(priv != NULL, return );

    int compressor_n = 0;
    struct board *board = (struct board*)priv;

    /* default value */
    gpio_write(board->FAN, false);
    gpio_write(board->R_COMPRESSOR, false);

    for (;;) {
        gpio_write(board->FAN, (fridge.status & STATUS_FAN) != 0);
        gpio_write(board->R_HEATER, (fridge.status & STATUS_HEATER) != 0);

        if ((fridge.status & STATUS_COMPRESSOR) != 0)
            compressor_n = COMPRESSOR_N;

        gpio_write(board->R_COMPRESSOR, compressor_n != 0);
        compressor_n -= (compressor_n != 0) ? 1 : 0;

        /* 5s cycles */
        picoRTOS_sleep(PICORTOS_DELAY_SEC(5));
    }
}

static void alarm_main(void *priv)
{
    picoRTOS_assert_fatal(priv != NULL, return );

    struct pwm *BUZZER = (struct pwm*)priv;

    /* default value */
    (void)pwm_set_period(BUZZER, (pwm_period_us_t)200);  /* 5khz */
    (void)pwm_set_duty_cycle(BUZZER, PWM_DUTY_CYCLE_PCENT(50));

    for (;;) {
        if ((fridge.status & STATUS_ALARM) != 0) {
            pwm_start(BUZZER);
            picoRTOS_sleep(PICORTOS_DELAY_MSEC(100ul));
            pwm_stop(BUZZER);
            picoRTOS_sleep(PICORTOS_DELAY_MSEC(100ul));
            pwm_start(BUZZER);
            picoRTOS_sleep(PICORTOS_DELAY_MSEC(250ul));
            pwm_stop(BUZZER);
        }
        /* sleep_until is overkill */
        picoRTOS_sleep(PICORTOS_DELAY_SEC(1));
    }
}

/*
 * Debug
 */
static void print(struct uart *UART, const char *s, size_t len)
{
    size_t sent = 0;

    while (sent != len) {
        int n = uart_write(UART, &s[sent], len - sent);
        if (n < 0) picoRTOS_postpone();
        else sent += n;
    }
}

static void print_celsius(struct uart *UART, int t)
{
    static char str[] = { "xxx, °C" };
    static const char number[] = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
    };

    if (t < 0) {
        str[0] = '-';
        str[1] = number[-t / 10];
        str[2] = number[-t % 10];
    }else{
        str[0] = '+';
        str[1] = number[t / 10];
        str[2] = number[t % 10];
    }

    print(UART, str, sizeof(str) - 1);
}

static void print_digit(struct uart *UART, int d)
{
    char c = '0' + (char)d;

    print(UART, &c, sizeof(c));
}

static void print_bool(struct uart *UART, bool value)
{
    static char str[] = { "[x]" };

    str[1] = (value ? 'x' : ' ');
    print(UART, str, sizeof(str));
}

static void debug_main(void *priv)
{
    picoRTOS_assert_fatal(priv != NULL, return );

    struct uart *TXD = (struct uart*)priv;
    picoRTOS_tick_t ref = picoRTOS_get_tick();

    for (;;) {

        print(TXD, "t0, ", (size_t)4);
        print_celsius(TXD, fridge.t_fridge);
        print(TXD, ", t1, ", (size_t)6);
        print_celsius(TXD, fridge.t_freezer);
        print(TXD, ", t2, ", (size_t)6);
        print_celsius(TXD, fridge.t_heater);
        print(TXD, ", k, ", (size_t)5);
        print_digit(TXD, fridge.knob);
        print(TXD, ", d, ", (size_t)5);
        print_bool(TXD, fridge.door_opened);
        print(TXD, ", c ", (size_t)4);
        print_bool(TXD, (fridge.status & STATUS_COMPRESSOR) != 0);
        print(TXD, ", f ", (size_t)4);
        print_bool(TXD, (fridge.status & STATUS_FAN) != 0);
        print(TXD, ", h ", (size_t)4);
        print_bool(TXD, (fridge.status & STATUS_HEATER) != 0);
        print(TXD, "\n", (size_t)1);

        /* until next round */
        picoRTOS_sleep_until(&ref, PICORTOS_DELAY_SEC(1));
    }
}

int main(void)
{
    static struct board board;

    struct picoRTOS_task task;
    static picoRTOS_stack_t stack0[CONFIG_DEFAULT_STACK_COUNT];
    static picoRTOS_stack_t stack1[CONFIG_DEFAULT_STACK_COUNT];
    static picoRTOS_stack_t stack2[CONFIG_DEFAULT_STACK_COUNT];
    static picoRTOS_stack_t stack3[CONFIG_DEFAULT_STACK_COUNT];
    static picoRTOS_stack_t stack4[CONFIG_DEFAULT_STACK_COUNT];

    picoRTOS_init();
    (void)board_init(&board);

    /* led */
    picoRTOS_task_init(&task, led_main, board.L, stack0, PICORTOS_STACK_COUNT(stack0));
    picoRTOS_add_task(&task, picoRTOS_get_next_available_priority());
    /* analog */
    picoRTOS_task_init(&task, analog_main, &board, stack1, PICORTOS_STACK_COUNT(stack1));
    picoRTOS_add_task(&task, picoRTOS_get_next_available_priority());
    /* cold */
    picoRTOS_task_init(&task, cold_main, &board, stack2, PICORTOS_STACK_COUNT(stack2));
    picoRTOS_add_task(&task, picoRTOS_get_next_available_priority());
    /* alarm */
    picoRTOS_task_init(&task, alarm_main, board.BUZZER, stack3, PICORTOS_STACK_COUNT(stack3));
    picoRTOS_add_task(&task, picoRTOS_get_next_available_priority());
    /* debug */
    picoRTOS_task_init(&task, debug_main, board.TXD, stack4, PICORTOS_STACK_COUNT(stack4));
    picoRTOS_add_task(&task, picoRTOS_get_next_available_priority());

    picoRTOS_start();

    /* not supposed to end there */
    picoRTOS_assert_void(false);
    return 1;
}