|
|
@@ -88,12 +88,30 @@ static void MX_USART1_UART_Init(void);
|
|
|
|
|
|
/* Private user code ---------------------------------------------------------*/
|
|
|
/* USER CODE BEGIN 0 */
|
|
|
+
|
|
|
+typedef struct {
|
|
|
+ uint8_t payload[PAYLOAD_SIZE];
|
|
|
+ uint8_t length;
|
|
|
+} rx_packet_t;
|
|
|
+
|
|
|
#define MAX_SYSTICK 0xFFFFFFFF
|
|
|
-uint8_t data[BUFF_SIZE]; // tmp read buffer
|
|
|
+
|
|
|
+uint8_t rx_ring_buffer[BUFF_SIZE];
|
|
|
uint8_t *dataUART; // pointee for rx_buffer
|
|
|
-volatile uint8_t dataL;
|
|
|
-volatile uint8_t dataI;
|
|
|
+
|
|
|
+rx_packet_t packet_fifo[FIFO_DEPTH];
|
|
|
+volatile uint8_t fifo_head = 0; // index pre zápis (z UARTu)
|
|
|
+volatile uint8_t fifo_tail = 0; // index pre čítanie (do nBus)
|
|
|
+volatile uint8_t fifo_count = 0; // počet nespracovaných paketov vo FIFO
|
|
|
+
|
|
|
+// UART DMA related variables
|
|
|
volatile uint32_t uart_timeout = MAX_SYSTICK;
|
|
|
+volatile uint16_t rx_read_pos = 0; // DAM UART CIRCULAR - tail
|
|
|
+volatile uint8_t msg_len = 0;
|
|
|
+volatile uint8_t msg_idx = 0;
|
|
|
+
|
|
|
+ProtocolState state = STATE_WAIT_LEN;
|
|
|
+
|
|
|
|
|
|
#if MODULE == MODULE_IMU || MODULE == MODULE_DMP
|
|
|
volatile uint8_t icm_data_ready = 0;
|
|
|
@@ -111,13 +129,12 @@ inline void uart_send(uint8_t *data, int n)
|
|
|
inline void uart_receive(uint8_t *dataNBUS, int n)
|
|
|
{
|
|
|
dataUART = dataNBUS;
|
|
|
- dataL = 0;
|
|
|
- dataI = 0;
|
|
|
- data[0] = 0;
|
|
|
+ rx_ring_buffer[0] = 0;
|
|
|
uart_timeout = HAL_GetTick();
|
|
|
- HAL_UARTEx_ReceiveToIdle_DMA(&huart1, data, n);
|
|
|
+ HAL_UART_Receive_DMA(&huart1, rx_ring_buffer, n);
|
|
|
}
|
|
|
|
|
|
+
|
|
|
inline void led_on(){
|
|
|
HAL_GPIO_WritePin(LD3_GPIO_Port, LD3_Pin, GPIO_PIN_SET);
|
|
|
}
|
|
|
@@ -134,71 +151,120 @@ inline void app_delay(uint8_t ms){
|
|
|
HAL_Delay(ms);
|
|
|
}
|
|
|
|
|
|
+static uint8_t Parse_Protocol_Byte(uint8_t b) {
|
|
|
+ uint8_t packet_finished = 0;
|
|
|
+
|
|
|
+ // Timeout reset logic
|
|
|
+ if (state != STATE_WAIT_LEN) {
|
|
|
+ if ((HAL_GetTick() - uart_timeout) > NBUS_UART_FRAME_TIMEOUT){
|
|
|
+ state = STATE_WAIT_LEN;
|
|
|
+ msg_len = 0;
|
|
|
+ msg_idx = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (state) {
|
|
|
+ case STATE_WAIT_LEN:
|
|
|
+ // Validácia dĺžky
|
|
|
+ if (b > 3 && b < PAYLOAD_SIZE) {
|
|
|
+ msg_len = b;
|
|
|
+ msg_idx = 0;
|
|
|
+ state = STATE_PAYLOAD;
|
|
|
+ uart_timeout = HAL_GetTick();
|
|
|
+
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case STATE_PAYLOAD:
|
|
|
+ // Zapisujeme do hlavy FIFO namiesto priamo do dataUART
|
|
|
+ packet_fifo[fifo_head].payload[msg_idx++] = b;
|
|
|
+ uart_timeout = HAL_GetTick();
|
|
|
+ //led_toggle();
|
|
|
+ //HAL_GPIO_TogglePin(SPI_SS_GPIO_Port, SPI_SS_Pin);
|
|
|
+ if (msg_idx >= msg_len) { // Koniec paketu
|
|
|
+ packet_fifo[fifo_head].length = msg_len;
|
|
|
+
|
|
|
+
|
|
|
+ // Posunieme hlavu FIFO, ak máme miesto
|
|
|
+ if (fifo_count < FIFO_DEPTH) {
|
|
|
+ fifo_head = (fifo_head + 1) % FIFO_DEPTH;
|
|
|
+ fifo_count++;
|
|
|
+ } else {
|
|
|
+ // FIFO je plné - tu by sa dal riešiť error handling
|
|
|
+ // (momentálne sa nový paket zahodí, resp. prepíše aktuálny head)
|
|
|
+ }
|
|
|
+
|
|
|
+ state = STATE_WAIT_LEN;
|
|
|
+ packet_finished = 1;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return packet_finished;
|
|
|
+}
|
|
|
+
|
|
|
+static void Process_UART_RingBuffer(void) {
|
|
|
+ uint16_t rx_dma_pos = BUFF_SIZE - __HAL_DMA_GET_COUNTER(huart1.hdmarx);
|
|
|
+
|
|
|
+ // Spracuj všetky dostupné bajty z DMA a nalož pakety do FIFO
|
|
|
+ while (rx_read_pos != rx_dma_pos) {
|
|
|
+ uint8_t byte = rx_ring_buffer[rx_read_pos];
|
|
|
+ rx_read_pos++;
|
|
|
+ if (rx_read_pos >= BUFF_SIZE) {
|
|
|
+ rx_read_pos = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Funkcia už automaticky rieši zápis do FIFO
|
|
|
+ Parse_Protocol_Byte(byte);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+uint8_t nbus_fifo_pull(uint8_t *dest_buffer, uint8_t *out_len) {
|
|
|
+
|
|
|
+ if (fifo_count == 0) {
|
|
|
+ return 0; // FIFO je prázdne
|
|
|
+ }
|
|
|
+ // Prekopírujeme dáta a dĺžku
|
|
|
+ *out_len = packet_fifo[fifo_tail].length;
|
|
|
+ memcpy(dest_buffer, packet_fifo[fifo_tail].payload, *out_len);
|
|
|
+
|
|
|
+ // Posunieme tail a znížime počítadlo nespracovaných paketov
|
|
|
+ fifo_tail = (fifo_tail + 1) % FIFO_DEPTH;
|
|
|
+ fifo_count--;
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
static inline uint8_t loop_callback(nBusStateCallbackType_t state_check) {
|
|
|
-// traba kontrolovat kazdu stav (state_check) zvmlast. Moznost doplnit dalsie kontroly
|
|
|
+// treba kontrolovat kazdy stav (state_check) zvlast. Moznost doplnit dalsie kontroly
|
|
|
if (state_check == CallbackType_SENSOR) {
|
|
|
#if MODULE == MODULE_IMU || MODULE == MODULE_DMP
|
|
|
if(icm_data_ready == 1){
|
|
|
icm_data_ready = 0;
|
|
|
- return 1; // interrupt from external sensor: data ready
|
|
|
+ return 1; // TEMPORARY ALWAYS ENABLE STATE. interrupt from external sensor: data ready
|
|
|
}
|
|
|
#endif
|
|
|
-
|
|
|
- return 0;
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
if (state_check == CallbackType_UART) {
|
|
|
- // timemout: 1 - 2 ms
|
|
|
- if(HAL_GetTick() - 1 > uart_timeout) {
|
|
|
- dataL = 0;
|
|
|
- dataI = 0;
|
|
|
- data[0] = 0;
|
|
|
- uart_timeout = MAX_SYSTICK;
|
|
|
-// led_off();
|
|
|
- HAL_UARTEx_ReceiveToIdle_DMA(&huart1, data, BUFF_SIZE);
|
|
|
- return 1; // UART receive timeout
|
|
|
- }
|
|
|
- return 0;
|
|
|
+ Process_UART_RingBuffer();
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// Application callbacks
|
|
|
-void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size){
|
|
|
- HAL_UARTEx_ReceiveToIdle_DMA(huart, data, BUFF_SIZE);
|
|
|
- uint8_t copy_offset = 0;
|
|
|
- if (dataL == 0) {
|
|
|
- uart_timeout = HAL_GetTick();
|
|
|
- dataL = data[0];
|
|
|
- dataI = 0;
|
|
|
- if (Size == 1) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- Size--;
|
|
|
- copy_offset = 1;
|
|
|
- }
|
|
|
-
|
|
|
- memcpy(&dataUART[dataI], &data[copy_offset], Size);
|
|
|
-
|
|
|
- dataI += Size;
|
|
|
- if(dataI >= dataL){
|
|
|
- nbus_cb_UART_RX(dataI);
|
|
|
- dataL=0;
|
|
|
- dataI=0;
|
|
|
- data[0]=0;
|
|
|
- uart_timeout = MAX_SYSTICK;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart){
|
|
|
- HAL_UARTEx_ReceiveToIdle_DMA(huart, data, BUFF_SIZE);
|
|
|
+ uart_timeout = MAX_SYSTICK;
|
|
|
+ HAL_UART_Receive_DMA(huart, rx_ring_buffer, BUFF_SIZE);
|
|
|
}
|
|
|
|
|
|
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
|
|
|
#if MODULE == MODULE_IMU || MODULE == MODULE_DMP
|
|
|
- icm_data_ready = 1;
|
|
|
+ if (GPIO_Pin == SPI_INT_Pin) {
|
|
|
+ icm_data_ready = 1;
|
|
|
+ }
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
@@ -239,8 +305,6 @@ int main(void)
|
|
|
MX_SPI1_Init();
|
|
|
MX_USART1_UART_Init();
|
|
|
/* USER CODE BEGIN 2 */
|
|
|
- dataI=0;
|
|
|
- dataL=0;
|
|
|
|
|
|
#ifdef MODULE_INIT_IP_ADC
|
|
|
MX_ADC_Init();
|
|
|
@@ -263,6 +327,7 @@ int main(void)
|
|
|
led_toggle,
|
|
|
app_delay,
|
|
|
loop_callback,
|
|
|
+ nbus_fifo_pull,
|
|
|
};
|
|
|
|
|
|
#if MODULE_MASTER == 1
|
|
|
@@ -275,7 +340,6 @@ int main(void)
|
|
|
#endif
|
|
|
|
|
|
#if MODULE == MODULE_DMP
|
|
|
-
|
|
|
nbus_init(getImuDriver(), &hw_platform);
|
|
|
nbus_init_app(NULL, NULL);
|
|
|
#endif
|
|
|
@@ -300,9 +364,10 @@ int main(void)
|
|
|
config.mag.mode = mag_mode_power_down;
|
|
|
|
|
|
nbus_init(getImuDriver(), &hw_platform);
|
|
|
- nbus_init_app(&hspi1, &config);
|
|
|
+ nbus_init_app(NULL, NULL);
|
|
|
#endif
|
|
|
|
|
|
+
|
|
|
nBus_MemoryDriver memory_ec20 = {
|
|
|
DS28EC20_init,
|
|
|
DS28EC20_readData4B,
|
|
|
@@ -315,7 +380,6 @@ int main(void)
|
|
|
|
|
|
memory_ec20.init(ONE_WIRE_GPIO_Port, ONE_WIRE_Pin);
|
|
|
nbus_init_memory_driver(&memory_ec20);
|
|
|
-
|
|
|
nbus_stack();
|
|
|
|
|
|
/* USER CODE END 2 */
|
