#ifndef _FLASH_H_

#define _FLASH_H_

#include "stm32f0xx_hal.h"

#include "stm32f0xx_hal_flash.h"

#include "config.h"

#define PAGE_SIZE ((uint16_t)0x400)

#define END_ADDR 0x08007FFF

typedef union

{

    struct {

        uint32_t can_id;

        uint16_t data_rate;

        uint8_t led_brightness;

    } val;

    uint16_t data[128];

} flash_settings_t;

void flash_save(flash_settings_t* tosave);

void flash_restore(flash_settings_t* tosave);

void flash_load_defaults(flash_settings_t* torestore);

void flash_erase(void);

#endif /* _FLASH_H_ */

    NONE = 0x0000,

    DIGITAL_INPUT = 0x0001,

    FREQ_INPUT = 0x0002,

    ANALOG_INPUT = 0x0003,

    DIGITAL_OUTPUT = 0x0004,

    PWM_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,

    LED_BRIGHTNESS = 0x0102,

    INPUT = 0x0103,

    OUTPUT = 0x0104,

} protocol_data_key_t;

void protocol_init(protocol_device_t device);

flash_settings_t* protocol_get_settings(void);

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();

bool _protocol_config(protocol_message_t* message);

bool protocol_estop(bool value);

bool protocol_set_output(protocol_message_t* message);

bool protocol_get_data(protocol_message_t* message);

bool protocol_config(protocol_message_t* message);

#endif //_PROTOCOL_H_

#include "can_buffer.h"

void can_buffer_init(volatile CanBuffer *buffer)

{

    memset((void*)buffer, 0, sizeof(CanBuffer));

}

CanBufferStatus can_buffer_add(volatile CanBuffer *buffer, CanRxMsgTypeDef *msg)

{

    if ((uint16_t) buffer->count < ((uint16_t) CAN_BUFFER_SIZE)) {

        buffer->data[buffer->head] = *msg;

        buffer->head = (buffer->head + 1) % CAN_BUFFER_SIZE;

        buffer->count++;

        return CAN_BUFFER_OK;

    }

    else {

        return CAN_BUFFER_FULL;

    }

}

volatile CanRxMsgTypeDef* can_buffer_remove(volatile CanBuffer *buffer)

{

    if (buffer->count > 0) {

        msg = &buffer->data[buffer->tail];

        buffer->tail = (buffer->tail + 1) % CAN_BUFFER_SIZE;

        buffer->count--;

    }

    return msg;

}

bool can_buffer_is_empty(volatile CanBuffer *buffer)

{

    return (buffer->count < 1);

}

uint8_t can_buffer_size(volatile CanBuffer *buffer)

{

    return buffer->count;

}

#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);

    led_set_brightness(protocol_settings.val.led_brightness);

    can_init(protocol_settings.val.can_id, DEFAULT_BROADCAST_ID);

}

flash_settings_t* protocol_get_settings(void)

{

    return &protocol_settings;

}

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;