variable size data sending, spi mode change fix, wb1mmc write start

code/l452_code/Core/Src/ads131.cpp

@@ -10,9 +10,14 @@ void initialize_ads131(SPI_HandleTypeDef *hspi1) {
   uint8_t cmd[6] = {0x00, 0x11, 0x00};
   uint8_t rx_buff[18];
 
-  HAL_SPI_DeInit(hspi1);
-  hspi1->Init.CLKPolarity = SPI_POLARITY_LOW;
-  HAL_SPI_Init(hspi1);
+  while (__HAL_SPI_GET_FLAG(hspi1, SPI_FLAG_BSY));
+  __HAL_SPI_DISABLE(hspi1);
+  
+  MODIFY_REG(hspi1->Instance->CR1,
+             SPI_CR1_CPOL | SPI_CR1_CPHA,
+             SPI_POLARITY_LOW | SPI_PHASE_2EDGE);
+  
+  __HAL_SPI_ENABLE(hspi1);
   
   // reset
   HAL_GPIO_WritePin(GPIOA, ADC_CS_Pin, GPIO_PIN_RESET);
@@ -62,8 +67,6 @@ void initialize_ads131(SPI_HandleTypeDef *hspi1) {
 
 struct packet_adc p_adc;
 
-extern volatile uint16_t tim6_reloads;
-
 void read_ads131(SPI_HandleTypeDef *hspi1) {
   
   if (HAL_GPIO_ReadPin(GPIOA, ADC_DRDY_Pin) != GPIO_PIN_RESET) {
@@ -73,16 +76,22 @@ void read_ads131(SPI_HandleTypeDef *hspi1) {
   uint8_t cmd[6] = {0x0};
   uint8_t rx_buff[16] = {0x0};
 
-  HAL_SPI_DeInit(hspi1);
-  hspi1->Init.CLKPolarity = SPI_POLARITY_LOW;
-  HAL_SPI_Init(hspi1);
+  while (__HAL_SPI_GET_FLAG(hspi1, SPI_FLAG_BSY));
+  __HAL_SPI_DISABLE(hspi1);
+  
+  MODIFY_REG(hspi1->Instance->CR1,
+             SPI_CR1_CPOL | SPI_CR1_CPHA,
+             SPI_POLARITY_LOW | SPI_PHASE_2EDGE);
+  
+  __HAL_SPI_ENABLE(hspi1);
+
   
   HAL_GPIO_WritePin(GPIOA, ADC_CS_Pin, GPIO_PIN_RESET);
   HAL_SPI_TransmitReceive(hspi1, (uint8_t*) cmd, (uint8_t*) rx_buff, 18, HAL_MAX_DELAY);
   HAL_GPIO_WritePin(GPIOA, ADC_CS_Pin, GPIO_PIN_SET);
 
   if (p_adc.index == 0) {
-    p_adc.t = ((uint32_t)tim6_reloads) * (htim6.Init.Period + 1) + TIM6->CNT;
+    p_adc.t = total_tim6();
 
   }
   p_adc.ekg_readings_cnts[p_adc.index] = to_signed_24(&rx_buff[3]);

code/l452_code/Core/Src/buff.cpp

@@ -1,6 +1,32 @@
-//#include "buff.hpp"
+#include "buff.hpp"
 #include <cstdint>
 
-alignas(32) uint8_t databank1[1024];
-alignas(32) uint8_t databank2[1024];
-uint16_t pos = 0;
+void sd_send(uint8_t data[], uint32_t len) {
+  extern bool sd_ready;
+  extern FIL file;
+  if (sd_ready) {
+    UINT bytes_written;
+    FRESULT res = f_write(&file, data, len, &bytes_written);
+    //if (res != FR_OK || bytes_written != db_size)) {}
+  }
+}
+
+void usb_send(uint8_t data[], uint32_t len) {
+  extern bool usb_ready;
+  if (usb_ready) {
+    CDC_Transmit_FS(data, len);
+    usb_ready = false;
+  }
+}
+
+void uart_send(uint8_t data[], uint32_t len) {
+  extern bool wb1mmc_ready;
+  if (wb1mmc_ready) {
+    HAL_UART_Transmit_DMA(&huart1, data, len);
+    wb1mmc_ready = false;
+  }
+}
+
+struct dbl_buff<1024, usb_send> usb_buff;
+struct dbl_buff<1024, uart_send> ble_buff;
+struct dbl_buff<1024, sd_send> sd_buff;

code/l452_code/Core/Src/lsm6dsv.cpp

@@ -4,101 +4,88 @@
 #include "tim.h"
 #include "buff.hpp"
 
-extern volatile uint16_t tim6_reloads;
+extern SPI_HandleTypeDef hspi1;
+
+void send_receive_lsm6dsv(uint8_t *tx_buff, uint8_t *rx_buff, uint32_t len) {
+  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);
+  HAL_SPI_TransmitReceive(&hspi1, tx_buff, rx_buff, len, HAL_MAX_DELAY);
+  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
+}
 
 void initialize_lsm6dsv(SPI_HandleTypeDef *hspi1) {
 
-  uint8_t tx_buff[8] = {0};
-  uint8_t rx_buff[8] = {0};
-  
-  HAL_SPI_DeInit(hspi1);
-  hspi1->Init.CLKPolarity = SPI_POLARITY_HIGH;
-  HAL_SPI_Init(hspi1);
+  uint8_t tx_buff[2] = {0};
+  uint8_t rx_buff[2] = {0};
 
+  while (__HAL_SPI_GET_FLAG(hspi1, SPI_FLAG_BSY));
+  __HAL_SPI_DISABLE(hspi1);
+
+  MODIFY_REG(hspi1->Instance->CR1,
+             SPI_CR1_CPOL | SPI_CR1_CPHA,
+             SPI_POLARITY_HIGH | SPI_PHASE_2EDGE);
+
+  __HAL_SPI_ENABLE(hspi1);
+  
   tx_buff[0] = 0x01; // Reset
   tx_buff[1] = 0x04;
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
-
-  tx_buff[0] = 0x03; // active high pushpull interrupt
-  tx_buff[1] = 0x01; // I2C and I3C disabled
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
-  
-  tx_buff[0] = 0x09; // Set 60Hz data rate for fifo
-  tx_buff[1] = 0b01010101;
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
-
-  tx_buff[0] = 0x0D; // Set drdy based on fifo
-  tx_buff[1] = 0b00111000;
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
-
-  tx_buff[0] = 0x10; // Set 60Hz accelerometer high performance
-  tx_buff[1] = 0b00000101;
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
-
-  tx_buff[0] = 0x11; // Set 60Hz gyro high performance
-  tx_buff[1] = 0b00000101;
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
-
-  // todo: get watermark working
-  tx_buff[0] = 0x07;
-  tx_buff[1] = 21; // 21 samples
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
+  HAL_Delay(100);
 
   tx_buff[0] = 0x0A; // Set bypass mode for fifo
   tx_buff[1] = 0b00000000; // to clear fifo
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
+  
+  tx_buff[0] = 0x03; // active high pushpull interrupt
+  tx_buff[1] = 0x01; // I2C and I3C disabled
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
+  
+  tx_buff[0] = 0x09; // Set 120Hz data rate for fifo
+  tx_buff[1] = 0b01100110;
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
+
+  tx_buff[0] = 0x0D; // Set drdy based on fifo
+  tx_buff[1] = 0b00111000;
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
+
+  tx_buff[0] = 0x10; // Set 120Hz accelerometer high performance
+  tx_buff[1] = 0b00000111;
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
+
+  tx_buff[0] = 0x11; // Set 120Hz gyro high performance
+  tx_buff[1] = 0b00000110;
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
+
+  tx_buff[0] = 0x07;
+  tx_buff[1] = 21; // 21 samples
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
 
   tx_buff[0] = 0x0A; // Set continuous mode for fifo
   tx_buff[1] = 0b00000110;
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);  
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, rx_buff, 2, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
-  HAL_Delay(30);
+  send_receive_lsm6dsv(tx_buff, rx_buff, 2);
 }
 
 struct packet_imu p_imu;
 
 void read_lsm6dsv(SPI_HandleTypeDef *hspi1) {
-  
+
   if (HAL_GPIO_ReadPin(GPIOC, IMU_DRDY_Pin) == GPIO_PIN_RESET) {
     return;
   }
-
-  HAL_SPI_DeInit(hspi1);
-  hspi1->Init.CLKPolarity = SPI_POLARITY_HIGH;
-  HAL_SPI_Init(hspi1);
+  
+  while (__HAL_SPI_GET_FLAG(hspi1, SPI_FLAG_BSY));
+  __HAL_SPI_DISABLE(hspi1);
+  
+  MODIFY_REG(hspi1->Instance->CR1,
+             SPI_CR1_CPOL | SPI_CR1_CPHA,
+             SPI_POLARITY_HIGH | SPI_PHASE_2EDGE);
+  
+  __HAL_SPI_ENABLE(hspi1);
 
   uint8_t tx_buff[141] = {0b10000000 + 0x78}; // FIFO addr
   
   // Watermark set for 21 samples, read 20
   tx_buff[0] = 0b10000000 + 0x78; // FIFO addr
-  p_imu.t = ((uint32_t)tim6_reloads) * (htim6.Init.Period + 1) + TIM6->CNT;
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_RESET);
-  HAL_SPI_TransmitReceive(hspi1, tx_buff, p_imu.data, 141, HAL_MAX_DELAY);
-  HAL_GPIO_WritePin(GPIOC, IMU_CS_Pin, GPIO_PIN_SET);
+  p_imu.t = total_tim6();
+  send_receive_lsm6dsv(tx_buff, p_imu.data, 141);
   write(p_imu);
 }

code/l452_code/Core/Src/main.cpp

@@ -61,6 +61,26 @@
 /* Private variables ---------------------------------------------------------*/
 
 /* USER CODE BEGIN PV */
+volatile bool send_imu_usb = false;
+volatile bool send_imu_ble = false;
+volatile bool send_adc_usb = false;
+volatile bool send_adc_ble = false;
+volatile bool send_ppg_usb = false;
+volatile bool send_ppg_ble = false;
+
+volatile uint16_t adc_value = 0;
+volatile bool adc_ready = false;
+
+volatile bool usb_ready = false;
+volatile bool wb1mmc_ready = false;
+volatile bool print_desc = false;
+volatile bool sd_ready = false;
+
+FATFS fs;
+FIL file;
+FRESULT res;
+
+uint8_t uart_rx_data[1];
 
 /* USER CODE END PV */
 
@@ -73,32 +93,17 @@ void PeriphCommonClock_Config(void);
 
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
-
-volatile bool to_recordVbatt = false;
-volatile bool to_recordTime = false;
-
-volatile uint16_t adc_value = 0;
-volatile uint8_t adc_ready = 0;
-volatile uint16_t tim6_reloads = 0;
-volatile bool usb_ready = false;
-volatile bool wb1mmc_ready = false;
-volatile bool print_desc = false;
-volatile bool sd_ready = false;
-
-FATFS fs;
-FIL file;
-FRESULT res;
-
-uint8_t uart_rx_data[1];
-
 void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
   if (hadc->Instance == ADC1) {
     adc_value = HAL_ADC_GetValue(hadc);
-    adc_ready = 1;
+    adc_ready = true;
   }
 }
 
-// 80MHz clock, 39999 prescaler and 19999 period for 0.1Hz
+volatile bool to_recordVbatt = false;
+volatile bool to_recordTime = false;
+// 80MHz clock, 39999 prescaler and 1999 period
+// 2000Hz TIM6 increment, and 1Hz reloads
 void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
   if (htim->Instance == TIM6) {
     tim6_reloads += 1;
@@ -107,34 +112,63 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
   }
 }
 
-volatile bool to_turn_on_sd = false;
-volatile bool to_turn_off_sd = false;
-void USB_CDC_RxHandler(uint8_t* Buf, uint32_t Len) {
-  if (memcmp(Buf, "R", Len) == 0) {
+volatile bool to_open_sd = false;
+volatile bool to_close_sd = false;
+void comm_handler(uint8_t ch) {
+  switch (ch) {
+    
+  case '1':
+    send_imu_usb = !send_imu_usb;
+    break;
+  case '2':
+    send_imu_ble = !send_imu_ble;
+    break;
+  case '3':
+    send_adc_usb = !send_adc_usb;
+    break;
+  case '4':
+    send_adc_ble = !send_adc_ble;
+    break;
+  case '5':
+    send_ppg_usb = !send_ppg_usb;
+    break;
+  case '6':
+    send_ppg_ble = !send_ppg_ble;
+    break;
+    
+  case 'r':
     usb_ready = true;
-  }
-  if (memcmp(Buf, "S", Len) == 0) {
-    to_turn_off_sd = true;
-  }
-  if (memcmp(Buf, "T", Len) == 0) {
-    to_turn_on_sd = true;
-  }
-  if (memcmp(Buf, "?", Len) == 0) {
+    break;
+  case 'R':
+    wb1mmc_ready = true;
+    break;
+  case 'S':
+    to_close_sd = true;
+    break;
+  case 'T':
+    to_open_sd = true;
+    break;
+  case '?':
     print_desc = true;
+    break;      
+  }
+}
+
+void USB_CDC_RxHandler(uint8_t* Buf, uint32_t Len) {  
+  if (Len == 1) {
+    comm_handler(Buf[0]);
   }
 }
 
 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
-  if (uart_rx_data[0] == 'R') {
-    wb1mmc_ready = true;
-  }
+  comm_handler(uart_rx_data[0]);
   HAL_UART_Receive_DMA(&huart1, uart_rx_data, sizeof(uart_rx_data));
 }
 
 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {}
 
-void turn_on_sd(void) {
-  to_turn_on_sd = false;
+void open_sd(void) {
+  to_open_sd = false;
   if (BSP_SD_IsDetected() != SD_PRESENT) {
     return;
   }
@@ -159,13 +193,14 @@ void turn_on_sd(void) {
   }
 }
 
-void turn_off_sd(void) {
-  to_turn_off_sd = false;
+void close_sd(void) {
+  sd_ready = false;
+  to_close_sd = false;
   if (sd_ready) {
     f_sync(&file);
     f_close(&file);
     res = f_mount(NULL, "", 1);
-    sd_ready = false;
+
   }
 }
 /* USER CODE END 0 */
@@ -214,44 +249,41 @@ int main(void)
   MX_USB_DEVICE_Init();
   MX_FATFS_Init();
   /* USER CODE BEGIN 2 */
-
+  struct packet_vbatt p_vbatt;
+  struct packet_rtc p_rtc;
   /* USER CODE END 2 */
 
   /* Infinite loop */
   /* USER CODE BEGIN WHILE */
   HAL_TIM_Base_Start_IT(&htim6);
-  //HAL_UART_Receive_DMA(&huart1, uart_rx_data, sizeof(uart_rx_data));
-  // For some reason initializing the ads131 first breaks the lsm6dsv gyro readings
-  initialize_lsm6dsv(&hspi1);
-  //initialize_ads131(&hspi1);
-  //initialize_max30101(&hi2c1);
 
+  initialize_lsm6dsv(&hspi1);
+  initialize_ads131(&hspi1);
+  initialize_max30101(&hi2c1);
+  
+  HAL_UART_Receive_DMA(&huart1, uart_rx_data, sizeof(uart_rx_data));
+  usb_buff.last_write = total_tim6();
   while (1)
   {
     read_lsm6dsv(&hspi1);
-    //read_max30101(&hi2c1);
-    //read_ads131(&hspi1);
-    HAL_Delay(1);
-    continue;
-    // if (to_turn_on_sd) {
-    //   turn_on_sd();
-    // }
+    read_ads131(&hspi1);
+    read_max30101(&hi2c1);
 
-    // if (to_turn_off_sd) {
-    //   turn_off_sd();
-    // }
-    // continue;
-    /* USER CODE END WHILE */
+    if (to_open_sd) {
+      open_sd();
+    }
+
+    if (to_close_sd) {
+      close_sd();
+    }
     
-    /* USER CODE BEGIN 3 */
     if (print_desc) {
       data_description(true, false);
       print_desc = false;
     }
 
     if (to_recordTime) {
-      struct packet_rtc p_rtc;
-      p_rtc.t = ((uint32_t)tim6_reloads) * (htim6.Init.Period + 1) + TIM6->CNT;
+      p_rtc.t = total_tim6();
       HAL_RTC_GetTime(&hrtc, &p_rtc.sTime, RTC_FORMAT_BCD);
       HAL_RTC_GetDate(&hrtc, &p_rtc.sDate, RTC_FORMAT_BCD);
       write(p_rtc);
@@ -259,25 +291,24 @@ int main(void)
     }
 
     if (to_recordVbatt) {
-      adc_ready = 0;
+      adc_ready = false;
       HAL_ADC_Start_IT(&hadc1);      
       to_recordVbatt = false;
     }
     
     if (adc_ready) {
-      adc_ready = 0;
-      struct packet_vbatt p_vbatt;
-      p_vbatt.t = ((uint32_t)tim6_reloads) * (htim6.Init.Period + 1) + TIM6->CNT;
-      p_vbatt.vbatt_cnts = HAL_ADC_GetValue(&hadc1);
+      adc_ready = false;
+      p_vbatt.t = total_tim6();
+      p_vbatt.vbatt_cnts = adc_value;
       write(p_vbatt);
     }
 
-    read_ads131(&hspi1);
-    read_lsm6dsv(&hspi1);
-    // HAL_GPIO_WritePin(GPIOB, LED1_Pin|LED2_Pin|LED3_Pin, GPIO_PIN_SET);
-    // HAL_Delay(100);
-    // HAL_GPIO_WritePin(GPIOB, LED1_Pin|LED2_Pin|LED3_Pin, GPIO_PIN_RESET);
-    // HAL_Delay(100);
+    if (usb_ready and total_tim6() - usb_buff.last_write > 4000) {
+      extern dbl_buff<1024, usb_send> usb_buff;
+      extern dbl_buff<1024, uart_send> ble_buff;
+      usb_buff.send();
+      ble_buff.send();
+    }
   }
   /* USER CODE END 3 */
 }

code/l452_code/Core/Src/max30101.cpp

@@ -8,7 +8,6 @@
 #include "packet.hpp"
 #include "buff.hpp"
 
-extern uint16_t tim6_reloads;
 struct packet_spo2 p_spo2;
 uint8_t data[4];
 
@@ -61,7 +60,7 @@ void initialize_max30101(I2C_HandleTypeDef *hi2c1) {
 
 void read_max30101(I2C_HandleTypeDef *hi2c1) {
   if (print_ready) {
-    p_spo2.t = ((uint32_t)tim6_reloads) * (htim6.Init.Period + 1) + TIM6->CNT;
+    p_spo2.t = total_tim6();
     write(p_spo2);
     print_ready = false;
   }

code/l452_code/Core/Src/spi.c

@@ -44,7 +44,7 @@ void MX_SPI1_Init(void)
   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
   hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
   hspi1.Init.NSS = SPI_NSS_SOFT;
-  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
+  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;

code/l452_code/Core/Src/tim.c

@@ -21,7 +21,7 @@
 #include "tim.h"
 
 /* USER CODE BEGIN 0 */
-
+volatile uint16_t tim6_reloads = 0;
 /* USER CODE END 0 */
 
 TIM_HandleTypeDef htim2;