HydroBot/hydrobot-sharedlibs Changeset - a72d393244e6

Changeset - a72d393244e6

Parent rev.

Child rev.

[Not reviewed]

default

0 4 2

matthewreed - 8 years ago 2017-07-02 20:26:42

Added can buffering and protocol updates

6 files changed with 121 insertions and 12 deletions:

inc/can.h

inc/can_buffer.h

inc/protocol.h

src/can.c

src/can_buffer.c

src/protocol.c

0 comments (0 inline, 0 general)

inc/can.h

➞

Show inline comments

 #ifndef _CAN_H_
 #define _CAN_H_
 #include <stdbool.h>
 #include <string.h>
 #include "stm32f0xx_hal.h"
 #include "config.h"
 #include "led.h"
 #include "protocol.h"
 #include "can_buffer.h"
 extern CAN_HandleTypeDef can_handle;
 void can_init(uint32_t rx_id, uint32_t broadcast_id);
 void can_send_test(uint16_t id);
 bool can_send(uint32_t id, uint32_t ide, uint8_t dlc, uint8_t data[8]);
 void can_set_receive_mask(uint32_t mask);
 void can_set_receive_id(uint32_t id);
 bool can_silence_bus(bool value);
 void can_receive(void);
 void can_process_receive_buffer(void);
 #endif //_CAN_H_

inc/can_buffer.h

➞

Show inline comments

@@ new file 100644 @@
 #ifndef _CAN_BUFFER_H
 #define _CAN_BUFFER_H
 #include <string.h>
 #include "system.h"
 #define CAN_BUFFER_SIZE 8
 typedef enum CanBufferStatus {CAN_BUFFER_OK, CAN_BUFFER_EMPTY, CAN_BUFFER_FULL} CanBufferStatus;
 typedef struct CanBuffer
+{
     volatile CanRxMsgTypeDef data[CAN_BUFFER_SIZE];
     volatile uint8_t head;
     volatile uint8_t tail;
     volatile uint8_t count;
 } CanBuffer;
 void can_buffer_init(volatile CanBuffer *buffer);
 CanBufferStatus can_buffer_add(volatile CanBuffer *buffer, CanRxMsgTypeDef *msg);
 volatile CanRxMsgTypeDef* can_buffer_remove(volatile CanBuffer *buffer);
 bool can_buffer_is_empty(volatile CanBuffer *buffer);
 uint8_t can_buffer_size(volatile CanBuffer *buffer);
 #endif //_CAN_BUFFER_H

inc/protocol.h

➞

Show inline comments

@@ @@ -34,25 +34,25 @@ typedef enum { @@
     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,
+    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,
     GPIO = 0x0102,

src/can.c

➞

Show inline comments

 #include "can.h"
 CAN_HandleTypeDef can_handle;
 CAN_FilterConfTypeDef can_filter;
 CanRxMsgTypeDef can_rx_msg;
 CanTxMsgTypeDef can_tx_msg;
 bool can_silenced;
 uint32_t can_broadcast_id;
 uint32_t can_rx_id;
 volatile CanBuffer can_rx_buffer;
 void can_init(uint32_t rx_id, uint32_t broadcast_id)
+{
     can_handle.Instance = CAN;
     can_handle.pRxMsg = &can_rx_msg;
     can_handle.pTxMsg = &can_tx_msg;
     can_handle.Init.Mode = CAN_MODE_NORMAL;
     can_handle.Init.Prescaler = 6;
     can_handle.Init.SJW = CAN_SJW_1TQ;
     can_handle.Init.BS1 = CAN_BS1_11TQ;
     can_handle.Init.BS2 = CAN_BS2_4TQ;
     can_handle.Init.TTCM = DISABLE;
@@ @@ -34,31 +36,33 @@ void can_init(uint32_t rx_id, uint32_t b @@
     can_filter.FilterMode = CAN_FILTERMODE_IDMASK;
     can_filter.FilterScale = CAN_FILTERSCALE_16BIT;
     uint32_t mask = 0x00000000;
     uint32_t id = 0x00000000;
     can_filter.FilterIdHigh = (id >> 11) & 0xFFFF;
     can_filter.FilterIdLow = (id << 5) & 0xFFFF;
     can_filter.FilterMaskIdHigh = (mask >> 11) & 0xFFFF;
     can_filter.FilterMaskIdLow = (mask << 5) & 0xFFFF;
     can_filter.FilterFIFOAssignment = CAN_FILTER_FIFO0;
     can_filter.FilterActivation = ENABLE;
     HAL_CAN_ConfigFilter(&can_handle, &can_filter);
     HAL_NVIC_SetPriority(CEC_CAN_IRQn, 1, 0);
     HAL_NVIC_EnableIRQ(CEC_CAN_IRQn);
     HAL_CAN_Receive_IT(&can_handle, CAN_FIFO0);
     //HAL_NVIC_SetPriority(CEC_CAN_IRQn, 1, 0);
     //HAL_NVIC_EnableIRQ(CEC_CAN_IRQn);
     //HAL_CAN_Receive_IT(&can_handle, CAN_FIFO0);
     can_silenced = false;
     can_rx_id = rx_id;
     can_broadcast_id = broadcast_id;
     can_buffer_init(&can_rx_buffer);
+}
 void can_send_test(uint16_t id)
+{
     can_handle.pTxMsg->StdId = id;
     can_handle.pTxMsg->IDE = CAN_ID_STD;
     can_handle.pTxMsg->RTR = CAN_RTR_DATA;
     can_handle.pTxMsg->DLC = 4;
     can_handle.pTxMsg->Data[0] = 'T'; //0x54
     can_handle.pTxMsg->Data[1] = 'E'; //0x45
     can_handle.pTxMsg->Data[2] = 'S'; //0x53
     can_handle.pTxMsg->Data[3] = 'T'; //0x54
@@ @@ -111,29 +115,57 @@ void can_set_receive_id(uint32_t id) @@
+}
 bool can_silence_bus(bool value)
+{
     bool result = true;
     can_silenced = value;
     return result;
+}
 void can_receive(void)
+{
     if ((can_handle.Instance->RF0R & CAN_RF0R_FMP0) != 0)
+    {
         HAL_StatusTypeDef status = HAL_CAN_Receive(&can_handle, 0, 0);
         if ((status == HAL_OK) & ((can_handle.pRxMsg->StdId == can_rx_id) | (can_handle.pRxMsg->StdId == can_broadcast_id)))
+        {
             can_buffer_add(&can_rx_buffer, can_handle.pRxMsg);
+        }
         //can_handle.Instance->RF0R |= CAN_RF0R_RFOM0;
         led_blink_once(LED_CAN, 250);
+    }
+}
 void can_process_receive_buffer(void)
+{
     CanRxMsgTypeDef msg;
     uint8_t size = can_buffer_size(&can_rx_buffer);
     for (uint8_t i = 0; i < size; i++)
+    {
         msg = *can_buffer_remove(&can_rx_buffer);
         protocol_receive_message(&msg);
+    }
+}
 void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef* hcan)
+{
     if ((hcan->pRxMsg->StdId == can_rx_id) | (hcan->pRxMsg->StdId == can_broadcast_id))
+    {
-        protocol_receive_message(hcan->pRxMsg);
+        can_buffer_add(&can_rx_buffer, hcan->pRxMsg);
+    }
-    led_blink_once(LED_CAN, 500);
+    led_blink_once(LED_ERROR, 500);
     HAL_CAN_Receive_IT(&can_handle, CAN_FIFO0);
+}
 void HAL_CAN_TxCpltCallback(CAN_HandleTypeDef* hcan) {}
 void HAL_CAN_ErrorCallback(CAN_HandleTypeDef* hcan)
+{
     led_set(LED_ERROR, 1);
+}

src/can_buffer.c

➞

Show inline comments

@@ new file 100644 @@
 #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)
+{
     volatile CanRxMsgTypeDef* msg;
     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;
+}

src/protocol.c

➞

Show inline comments

 #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;
@@ @@ -118,34 +119,42 @@ bool protocol_send_data(protocol_data_ke @@
     message.sensor = sensor;
     message.data.float_data = data;
     result = protocol_send_message(&message);
     return result;
+}
 bool _protocol_config(protocol_message_t* message)
+{
     bool result = false;
     if (message->key == LED_BRIGHTNESS)
     if (message->key == CAN_ID)
+    {
         uint32_t can_id = (uint16_t) message->data.float_data;
         protocol_settings.val.can_id = can_id;
         flash_save(&protocol_settings);
+    }
     else if (message->key == DATA_RATE)
+    {
         uint16_t data_rate = (uint16_t) message->data.float_data;
         protocol_settings.val.data_rate = data_rate * 1000;
         flash_save(&protocol_settings);
+    }
     else if (message->key == LED_BRIGHTNESS)
+    {
         uint8_t brightness = (uint8_t)message->data.float_data;
         result = led_set_brightness(brightness);
         protocol_settings.val.led_brightness = brightness;
+    }
     else if (message->key == DATA_RATE)
+    {
         uint16_t data_rate = (uint16_t) message->data.float_data;
         protocol_settings.val.data_rate = data_rate;
         flash_save(&protocol_settings);
+    }
     else
+    {
         //call config weak function
         result = protocol_config(message);
+    }
     return result;
+}
 __weak bool protocol_estop(bool value)
+{
     return false;

0 comments (0 inline, 0 general)