#ifndef _LED_H_

#define _LED_H_

#include "stm32f0xx_hal.h"

#include <stdbool.h>

#include <string.h>

typedef enum {

    LED_STATUS = 0,

    LED_CAN,

    LED_ERROR,

} led_name_t;

void led_init(void);

void led_start(led_name_t led);

void led_start_time(led_name_t led, uint16_t time);

void led_update(led_name_t led);

void led_update_all(void);

void led_set(led_name_t led, bool value);

void led_toggle(led_name_t led);

#endif /* _LED_H_ */

}  protocol_message_t;

typedef enum {

    ESTOP = 0x00,

    SILENCE_BUS = 0x01,

    SET_OUTPUT = 0X10,

    GET_DATA = 0x11,

    CONFIG = 0x12,

    CALIBRATE = 0x13,

} protocol_command_t;

typedef enum {

    MASTER = 0x00,

    AIRSENSE = 0x01,

    RELAYDRIVE = 0X02,

    WATERSENSE = 0x03,

    PROTOMODULE = 0x04,

} protocol_device_t;

typedef enum {

    NONE = 0x0000,

    DIGITAL_INPUT = 0x0001,

    FREQ_INPUT = 0x0002,

    ANALOG_INPUT = 0x0003,

    DIGITAL_OUTPUT = 0x0004,

    FREQ_OUTPUT = 0x0005,

    ANALOG_OUTPUT = 0x0006,

    AIR_TEMP = 0x0007,

    AIR_HUMIDITY = 0x0008,

    AIR_PRESSURE = 0x0009,

    AMBIENT_LIGHT = 0x000A,

    WATER_TEMP = 0x000B,

    WATER_LEVEL = 0x000C,

    WATER_CONDUCTIVITY = 0x000D,

    WATER_PH = 0x000E,

    CAN_ID = 0x0100,

    DATA_RATE = 0x0101,

    GPIO = 0x0102,

    LED_BRIGHTNESS = 0x0103,

} protocol_data_key_t;

void protocol_init(protocol_device_t device);

bool protocol_receive_message(CanRxMsgTypeDef* can_message);

bool protocol_send_message(protocol_message_t* message);

bool protocol_process_message(protocol_message_t* message);

bool protocol_send_data(protocol_data_key_t key, uint8_t sensor, float data);

bool protocol_send_test();

#endif //_PROTOCOL_H_

#include "led.h"

#define LED_CYCLE_STATUS 2000

#define LED_CYCLE_CAN 0

#define LED_CYCLE_ERROR 0

uint16_t led_timers[3];

uint16_t led_thresholds[3];

uint16_t led_cycles[3];

void led_init(void)

{

    memset(led_timers, 0, sizeof led_timers);

    memset(led_thresholds, 0, sizeof led_thresholds);

    memset(led_cycles, 0, sizeof led_cycles);

    led_cycles[LED_STATUS] = LED_CYCLE_STATUS;

    led_cycles[LED_CAN] = LED_CYCLE_CAN;

    led_cycles[LED_ERROR] = LED_CYCLE_ERROR;

}

void led_start(led_name_t led)

{

    led_timers[led] = led_cycles[led];

    led_thresholds[led] = led_cycles[led]/2;

}

void led_start_time(led_name_t led, uint16_t time)

{

    if (led_timers[led] == 0)

    {

        led_timers[led] = time;

        led_thresholds[led] = time/2;

    }

}

void led_update(led_name_t led)

{

    if (led_timers[led] > led_thresholds[led])

    {

        led_set(led, 1);

        led_timers[led]--;

    }

    else if (led_timers[led] > 0)

    {

        led_set(led, 0);

        led_timers[led]--;

    }

        led_set(led, 0);

        led_timers[led] = led_cycles[led];

    }

}

void led_update_all(void)

{

    led_update(LED_STATUS);

    led_update(LED_CAN);

    led_update(LED_ERROR);

}

void led_set(led_name_t led, bool value)

{

    gpio_set_led(led, value);

}

void led_toggle(led_name_t led)

{

    gpio_toggle_led(led);

}

__weak bool gpio_set_led(led_name_t led, bool value)

{

    return false;

}

__weak bool gpio_toggle_led(led_name_t led)

{

    return false;

}

#include "protocol.h"

protocol_device_t protocol_device;

flash_settings_t protocol_settings;

void protocol_init(protocol_device_t device)

{

    protocol_device = device;

    flash_restore(&protocol_settings);

    can_init(protocol_settings.val.can_id, DEFAULT_BROADCAST_ID);

}

bool protocol_send_test()

{

    bool result = true;

    can_send_test(protocol_settings.val.can_id | 0x00000001);

    return result;

}

bool protocol_receive_message(CanRxMsgTypeDef* can_message)

{

    bool result = true;

    protocol_message_t message;

    message.command = can_message->Data[0] & 0x80;

    message.id = can_message->Data[0] & 0x7F;

    message.key = (can_message->Data[1] << 8) & can_message->Data[2];

    message.sensor = can_message->Data[3];

    message.data.byte_data[0] = can_message->Data[4];

    message.data.byte_data[1] = can_message->Data[5];

    message.data.byte_data[2] = can_message->Data[6];

    message.data.byte_data[3] = can_message->Data[7];

    protocol_process_message(&message);

    return result;

}

bool protocol_send_message(protocol_message_t* message)

{

    bool result = true;

    uint8_t data[8];

    data[1] = (message->key >> 8) & 0xFF;

    data[2] = (message->key >> 0) & 0xFF;

    data[3] = message->sensor;

    can_send(protocol_settings.val.can_id | 0x00000001, CAN_ID_STD, 8, data);

    return result;

}

bool protocol_process_message(protocol_message_t* message)

{

    bool result = true;

    if (message->command)

    {

        switch(message->id)

        {

            case ESTOP:

                {

                    //call estop weak function

                    result = protocol_estop(message->data.float_data!=0.0f);

                }

                break;

            case SILENCE_BUS:

                {

                    //silence can bus

                    result = can_silence_bus(message->data.float_data!=0.0f);

                }

                break;

            case SET_OUTPUT:

                {

                    //call set output weak function

                    result = protocol_set_output(message);

                }

                break;

            case GET_DATA:

                {

                    //call get data weak function

                    result = protocol_get_data(message);

                }

                break;

            case CONFIG:

                {

                    //call config weak function

                    result = protocol_config(message);

                }

                break;

            default:

                result = false;

                break;

        }