GPS collection moved to dma

WhaleTagRecovery/Core/Inc/Lib Inc/threads.h

@@ -22,7 +22,6 @@
 #include "Recovery Inc/Aprs.h"
 #include "Recovery Inc/FishTracker.h"
 #include "Recovery Inc/GPS.h"
-#include "Sensor Inc/GPSCollection.h"
 #include "Sensor Inc/BatteryMonitoring.h"
 #include "Sensor Inc/RTC.h"
 #include "Comms Inc/PiComms.h"

WhaleTagRecovery/Core/Inc/config.h

@@ -12,7 +12,7 @@
 
 /* COMPILE-TIME CONFIGURATION */
 #define USB_BOOTLOADER_ENABLED 0
-#define BATTERY_MONITOR_ENABLED 0
+#define BATTERY_MONITOR_ENABLED 1
 #define RTC_ENABLED 0
 #define UART_ENABLED 1
 #define HEARTBEAT_ENABLED 1

WhaleTagRecovery/Core/Inc/stm32u5xx_it.h

@@ -52,11 +52,11 @@ void MemManage_Handler(void);
 void BusFault_Handler(void);
 void UsageFault_Handler(void);
 void DebugMon_Handler(void);
+void GPDMA1_Channel0_IRQHandler(void);
 void GPDMA1_Channel1_IRQHandler(void);
 void TIM2_IRQHandler(void);
 void TIM6_IRQHandler(void);
 void USART2_IRQHandler(void);
-void USART3_IRQHandler(void);
 /* USER CODE BEGIN EFP */
 
 /* USER CODE END EFP */

WhaleTagRecovery/Core/Src/Lib Src/state_machine.c

@@ -193,10 +193,7 @@ void state_machine_thread_entry(ULONG thread_input){
 					char comment_buffer[257];
 					size_t len = message->header.length;
 
-					memcpy(comment_buffer, &message->data, len);
-					comment_buffer[len] = '\0';
-
-					//ToDo: implement APRS comment assignment
+					aprs_set_comment(&message->data,  message->header.length);
 					break;
 				}
 

WhaleTagRecovery/Core/Src/Recovery Src/GPS.c

@@ -13,10 +13,9 @@
 #include <string.h>
 #include "Comms Inc/PiComms.h"
 #include "stm32u5xx_hal_uart.h"
+#include "stm32u5xx_hal_uart_ex.h"
 #include "main.h"
 
-//#define GPS_INTERRUPT_DRIVEN
-
 #ifdef GPS_COMM_DEBUG
 #include "Lib Inc/timing.h"
 #endif
@@ -25,30 +24,38 @@
 static void parse_gps_output(GPS_HandleTypeDef* gps, const char* buffer, uint8_t buffer_length);
 
 extern UART_HandleTypeDef huart3;
+extern DMA_HandleTypeDef handle_GPDMA1_Channel0;
+
 
 // === PRIVATE DEFINES ===
 #define NMEA_START_CHAR '$'
 #define NMEA_END_CHAR   '\r'
 #define NMEA_MAX_SIZE   (82)
 
-#define GPS_BUFFER_SIZE (NMEA_MAX_SIZE + 16)
+#define GPS_BUFFER_SIZE (NMEA_MAX_SIZE + 1)
 #define GPS_BUFFER_COUNT (128)
 
 #define GPS_BUFFER_VALID_START (1 << 0)
 
 // === PRIVATE TYPEDEFS ===
+typedef struct {
+	size_t length;
+	uint8_t sentence[GPS_BUFFER_SIZE];
+}NmeaString;
+
 typedef struct {
     uint8_t some;
     size_t value;
 } Option_size_t;
 
 
 // === PRIVATE VARIABLES ===
+uint8_t rx_buffer[16*NMEA_MAX_SIZE];
 TX_EVENT_FLAGS_GROUP gpsBuffer_event_flags_group;
-uint8_t gps_buffer[GPS_BUFFER_COUNT][GPS_BUFFER_SIZE] = {};
-size_t gpsBuffer_write_index = 0;
+ NmeaString gps_buffer[GPS_BUFFER_COUNT] = {};
+volatile size_t gpsBuffer_write_index = 0;
 size_t gpsBuffer_read_index = 0;
-Option_size_t gpsBuffer_newest_index = {.some = 0}; 
+volatile Option_size_t gpsBuffer_newest_index = {.some = 0};
 volatile uint8_t found_start = 0;
 
 // === PRIVATE METHODS ===
@@ -59,11 +66,55 @@ volatile uint8_t found_start = 0;
  * 
  * @param huart 
  */
-void gpsBuffer_UART_RxCpltCallback(UART_HandleTypeDef *huart){
-	if (gps_buffer[gpsBuffer_write_index][0] == NMEA_START_CHAR){
-		found_start = 1;
-//		tx_event_flags_set(&gpsBuffer_event_flags_group, GPS_BUFFER_VALID_START, TX_OR);
+
+
+void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size){
+ //restarts the DMA listening of the UART rx (next 247 bytes)
+	if(huart->Instance == USART3){
+		// seperate messages
+		int nmea_start = -1;
+		int new = 0;
+		for (int i = 0; i < Size; i++){
+			//find sentence start
+			switch(rx_buffer[i]) {
+				case NMEA_START_CHAR:
+					nmea_start = i;
+					break;
+
+				case '\n': /* fallthrough */
+				case '\r':
+					if (nmea_start == -1)
+						break; //sentence end with no start if you reach here
+
+					gps_buffer[gpsBuffer_write_index].length = ((i) - nmea_start);
+					memcpy(&gps_buffer[gpsBuffer_write_index].sentence[0], &rx_buffer[nmea_start], gps_buffer[gpsBuffer_write_index].length);
+					gps_buffer[gpsBuffer_write_index].sentence[gps_buffer[gpsBuffer_write_index].length] = '\0';
+					gpsBuffer_write_index = (gpsBuffer_write_index + 1) % GPS_BUFFER_COUNT;
+					new = 1;
+					//flag thread to process sentence
+					nmea_start = -1;
+					break;
+
+				default:
+					break;
+			}
+		}
+		int remaining = 0;
+		//(nmea_start == -1) => no start found //flush entire buffer
+		//(nmea_start == 0) => sentence too long //flush entire buffer
+		if (nmea_start > 0) {
+			remaining = sizeof(rx_buffer) - nmea_start;
+			memmove(&rx_buffer[0], &rx_buffer[nmea_start], remaining); //shift sentence start to beginning of buffer
+		}
+
+		if(new){
+			tx_event_flags_set(&gpsBuffer_event_flags_group, GPS_BUFFER_VALID_START, TX_OR);
+		}
+
+		HAL_UARTEx_ReceiveToIdle_DMA(&huart3, &rx_buffer[remaining], sizeof(rx_buffer) - remaining); //initiate next transfer
+		__HAL_DMA_DISABLE_IT(&handle_GPDMA1_Channel0,DMA_IT_HT);//we don't want the half done transaction interrupt
 	}
+	return;
 }
 
 /**
@@ -76,8 +127,8 @@ const uint8_t * gpsBuffer_pop_latest(void) {
     if (!gpsBuffer_newest_index.some)
         return NULL;
 
-    const uint8_t *msg_ptr = gps_buffer[gpsBuffer_newest_index.value];
-    gpsBuffer_newest_index.some = 0;
+    const uint8_t *msg_ptr = gps_buffer[gpsBuffer_newest_index.value].sentence;
+    gpsBuffer_newest_index.some = 0; //make newest index as old
     return msg_ptr;
 }
 
@@ -89,76 +140,31 @@ const uint8_t * gpsBuffer_pop_latest(void) {
  */
 void gpsBuffer_thread(ULONG thread_input) {
 #ifndef GPS_COMM_DEBUG 
-#ifdef GPS_INTERRUPT_DRIVEN
-//	tx_event_flags_create(&gpsBuffer_event_flags_group, "GPS Buffer Event Flags");
+	tx_event_flags_create(&gpsBuffer_event_flags_group, "GPS Buffer Event Flags");
 
-	//attach interrupt uart interrupt
-	HAL_UART_RegisterCallback(&huart3, HAL_UART_RX_COMPLETE_CB_ID, gpsBuffer_UART_RxCpltCallback);
-#endif
+	//initiate UART DMA
+	HAL_UARTEx_ReceiveToIdle_DMA(&huart3, rx_buffer, sizeof(rx_buffer));
+	__HAL_DMA_DISABLE_IT(&handle_GPDMA1_Channel0,DMA_IT_HT);//we don't want the half done transaction interrupt
 	while(1) {
-        uint8_t *rx_buffer = gps_buffer[gpsBuffer_write_index];
-        *rx_buffer = 0;
         //wait for gps message start
         ULONG actual_flags = 0;
-#ifndef GPS_INTERRUPT_DRIVEN
-
-        while(*rx_buffer != NMEA_START_CHAR){
-            HAL_UART_Receive(&huart3, rx_buffer, 1, GPS_UART_TIMEOUT); //receive one bit at a time
-        }
-#else
-        found_start = 0;
-        while (!found_start){
-//        while(!(actual_flags & GPS_BUFFER_VALID_START)) {
-            HAL_UART_Receive_IT(&huart3, rx_buffer, 1); //receive one bit at a time
 
-            // Wait for the Interrupt callback to fire and set the flag (telling us what to do further)
-//			tx_event_flags_get(&gpsBuffer_event_flags_group, GPS_BUFFER_VALID_START , TX_OR_CLEAR, &actual_flags, TX_WAIT_FOREVER);
+        tx_event_flags_get(&gpsBuffer_event_flags_group, GPS_BUFFER_VALID_START , TX_OR_CLEAR, &actual_flags, TX_WAIT_FOREVER);
+
+        while(gpsBuffer_read_index != gpsBuffer_write_index){
+			NmeaString *read_sentence = &gps_buffer[gpsBuffer_read_index];
+			//quick validation
+        	if ((memcmp(&read_sentence->sentence[3], "GLL,", 4) == 0)
+        		|| (memcmp(&read_sentence->sentence[3], "GGA,", 4) == 0)
+				|| (memcmp(&read_sentence->sentence[3], "RMC,", 4) == 0)
+        	){
+        		pi_comms_tx_forward_gps(read_sentence->sentence, read_sentence->length);
+				gpsBuffer_newest_index.value = gpsBuffer_read_index;
+				gpsBuffer_newest_index.some = 1;
+        	}
+
+            gpsBuffer_read_index = (gpsBuffer_read_index + 1) % GPS_BUFFER_COUNT;
         }
-        found_start = 0;
-#endif
-
-        //receive until end character
-        size_t char_index = 0;
-        do{
-            char_index++; //advance write head read next byte
-            if (char_index == GPS_BUFFER_SIZE-2) {
-                break;
-            }
-            HAL_UART_Receive(&huart3, &rx_buffer[char_index], 1, GPS_UART_TIMEOUT);
-        } while(rx_buffer[char_index] != NMEA_END_CHAR);
-        char_index++;
-        rx_buffer[char_index] = 0;
-        size_t message_length = char_index + 1;
-
-
-		//only maintain valid messages
-		//check if valid position data type
-        enum minmea_sentence_id sentence_id = minmea_sentence_id((const char *)rx_buffer, false);
-        if ((sentence_id == MINMEA_SENTENCE_RMC)
-            || (sentence_id == MINMEA_SENTENCE_GLL)
-            || (sentence_id == MINMEA_SENTENCE_GGA)
-        ){
-            //advance latest and write head
-            gpsBuffer_newest_index = (Option_size_t){.some = 1, .value = gpsBuffer_write_index};
-
-			size_t next_index = (gpsBuffer_write_index + 1) % GPS_BUFFER_COUNT;
-			if (next_index == gpsBuffer_read_index){
-				//TODO handle overflow condition
-			}
-			gpsBuffer_write_index = next_index;
-
-			//transmit values to pi
-			//Note: Move transmission to it's own thread to not block GPS UART communication
-			gpsBuffer_read_index = (gpsBuffer_read_index + 1) % GPS_BUFFER_COUNT;
-			//forawrd messages
-			pi_comms_tx_forward_gps(rx_buffer, message_length);
-        }
-//        else if ((sentence_id != MINMEA_INVALID)
-//        		&& (sentence_id != MINMEA_UNKNOWN)
-//		){
-//        	//forward, but don't store
-//			pi_comms_tx_forward_gps(rx_buffer, message_length);
-//        }
 	}
 #else
 	// buffer a indexed packet every second
@@ -205,9 +211,6 @@ bool read_gps_data(GPS_HandleTypeDef* gps){
 
 	//parse packet if it exists
 	parse_gps_output(gps, (const char *)latest_message, msg_len);
-	if(gps->is_pos_locked){
-		pi_comms_tx_forward_gps(latest_message, msg_len); //forward packet to pi
-	}
 
 	return true;
 

WhaleTagRecovery/Core/Src/Recovery Src/VHF.c

@@ -29,7 +29,7 @@ static inline HAL_StatusTypeDef __vhf_set_freq(VHF_HandleTypdeDef *vhf){
 	uint8_t transmit_data[SET_PARAMETERS_TRANSMIT_LENGTH + 1];
 	uint8_t response_data[SET_PARAMETERS_RESPONSE_LENGTH];
 
-	sprintf((char *)transmit_data, "AT+DMOSETGROUP=0,%8.4f,%8.4f,0000,0,0000\r\n", vhf->config.tx_freq_MHz, vhf->config.rx_freq_MHz);
+	sprintf((char *)transmit_data, "AT+DMOSETGROUP=0,%8.4f,%8.4f,0000,0,0000\r\n", vhf->config.tx_freq_MHz, vhf->config.rx_freq_MHz); // @suppress("Float formatting support")
 
 	status |= HAL_UART_Transmit(vhf->huart, transmit_data, SET_PARAMETERS_TRANSMIT_LENGTH, HAL_MAX_DELAY);
 	status |= HAL_UART_Receive(vhf->huart,  response_data, SET_PARAMETERS_RESPONSE_LENGTH, 500);

WhaleTagRecovery/Core/Src/main.c

@@ -56,6 +56,7 @@ TIM_HandleTypeDef htim2;
 UART_HandleTypeDef huart4;
 UART_HandleTypeDef huart2;
 UART_HandleTypeDef huart3;
+DMA_HandleTypeDef handle_GPDMA1_Channel0;
 
 /* USER CODE BEGIN PV */
 VHF_HandleTypdeDef vhf = {
@@ -398,6 +399,8 @@ static void MX_GPDMA1_Init(void)
   __HAL_RCC_GPDMA1_CLK_ENABLE();
 
   /* GPDMA1 interrupt Init */
+    HAL_NVIC_SetPriority(GPDMA1_Channel0_IRQn, 0, 0);
+    HAL_NVIC_EnableIRQ(GPDMA1_Channel0_IRQn);
     HAL_NVIC_SetPriority(GPDMA1_Channel1_IRQn, 0, 0);
     HAL_NVIC_EnableIRQ(GPDMA1_Channel1_IRQn);
 
@@ -619,6 +622,8 @@ static void MX_USART3_UART_Init(void)
 
   /* USER CODE END USART3_Init 0 */
 
+  UART_AutonomousModeConfTypeDef sConfigUart3 = {0};
+
   /* USER CODE BEGIN USART3_Init 1 */
 
   /* USER CODE END USART3_Init 1 */
@@ -649,6 +654,15 @@ static void MX_USART3_UART_Init(void)
   {
     Error_Handler();
   }
+  sConfigUart3.AutonomousModeState = UART_AUTONOMOUS_MODE_ENABLE;
+  sConfigUart3.TriggerSelection = UART_GPDMA1_CH0_TCF_TRG;
+  sConfigUart3.TriggerPolarity = UART_TRIG_POLARITY_RISING;
+  sConfigUart3.DataSize = 0;
+  sConfigUart3.IdleFrame = UART_IDLE_FRAME_ENABLE;
+  if (HAL_UARTEx_SetConfigAutonomousMode(&huart3, &sConfigUart3) != HAL_OK)
+  {
+    Error_Handler();
+  }
   /* USER CODE BEGIN USART3_Init 2 */
 
   /* USER CODE END USART3_Init 2 */