Optical links enabled

OZE_Main/Core/Inc/node-red-config.h

@@ -24,6 +24,8 @@
 #define BROKER_IP "192.168.3.34"
 #define MQTT_PORT 1883
 
+#define MEASURMENTS_SCHEDULER_INTERVAL_MS 1000
+
 //#define USER_MOCKS
 
 #endif /* INC_NODE_RED_CONFIG_H_ */

OZE_Main/Core/Inc/stm32h7xx_it.h

@@ -53,10 +53,14 @@ void BusFault_Handler(void);
 void UsageFault_Handler(void);
 void DebugMon_Handler(void);
 void RCC_IRQHandler(void);
+void USART1_IRQHandler(void);
+void USART2_IRQHandler(void);
+void USART3_IRQHandler(void);
 void TIM6_DAC_IRQHandler(void);
 void ETH_IRQHandler(void);
 void DMA2_Stream6_IRQHandler(void);
 void DMA2_Stream7_IRQHandler(void);
+void USART6_IRQHandler(void);
 void UART8_IRQHandler(void);
 /* USER CODE BEGIN EFP */
 

OZE_Main/Core/Inc/uart_tasks.h

@@ -15,9 +15,21 @@
 
 #include "main.h"
 #include "serial_protocol.h"
-
-#define UART8_RX_BUFF_SIZE 256
-#define UART8_TX_BUFF_SIZE 256
+#include "measurements.h"
+
+#define UART_RX_BUFF_SIZE 256
+#define UART_TX_BUFF_SIZE 256
+
+#define UART1_RX_BUFF_SIZE UART_RX_BUFF_SIZE
+#define UART1_TX_BUFF_SIZE UART_TX_BUFF_SIZE
+#define UART2_RX_BUFF_SIZE UART_RX_BUFF_SIZE
+#define UART2_TX_BUFF_SIZE UART_TX_BUFF_SIZE
+#define UART3_RX_BUFF_SIZE UART_RX_BUFF_SIZE
+#define UART3_TX_BUFF_SIZE UART_TX_BUFF_SIZE
+#define UART6_RX_BUFF_SIZE UART_RX_BUFF_SIZE
+#define UART6_TX_BUFF_SIZE UART_TX_BUFF_SIZE
+#define UART8_RX_BUFF_SIZE UART_RX_BUFF_SIZE
+#define UART8_TX_BUFF_SIZE UART_TX_BUFF_SIZE
 #define INPUT_DATA_BUFF_SIZE UART8_RX_BUFF_SIZE
 #define OUTPUT_DATA_BUFF_SIZE 128
 
@@ -51,9 +63,6 @@ struct _UartTaskData {
     osThreadId_t uartRecieveTaskHandle;
     osThreadId_t uartTransmitTaskHandle;
     osMutexId_t rxDataBufferMutex;
-#if 0
-    osMessageQueueId_t processDataQueue;
-#endif
     MessageBufferHandle_t processRxDataMsgBuffer;
     ProcessDataCallbackFunc processDataCb;
     osMessageQueueId_t *sendCmdToSlaveQueue;
@@ -63,9 +72,20 @@ struct _UartTaskData {
 
 typedef struct _UartTaskData UartTaskData;
 
+extern RESMeasurements resMeasurements[SLAVES_COUNT];
+extern SesnorsInfo sensorsInfo[SLAVES_COUNT];
+extern uint32_t slaveLastSeen[SLAVES_COUNT];
+extern osMutexId_t resMeasurementsMutex;
+extern osMutexId_t sensorsInfoMutex;
+
+extern UartTaskData uart1TaskData; // Board 1
+extern UartTaskData uart3TaskData; // Board 2
+extern UartTaskData uart6TaskData; // Board 3
+extern UartTaskData uart2TaskData; // Board 4
+extern UartTaskData uart8TaskData; // Debug
 
-void Uart8TasksInit (void);
-void Uart8ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFrameData);
+void UartTasksInit(void);
+void UartTaskCreate (UartTaskData* uartTaskData);
 
 void UartRxTask (void* argument);
 void UartTxTask (void* argument);

OZE_Main/Core/Src/main.c

@@ -50,6 +50,10 @@ CRC_HandleTypeDef hcrc;
 RNG_HandleTypeDef hrng;
 
 UART_HandleTypeDef huart8;
+UART_HandleTypeDef huart1;
+UART_HandleTypeDef huart2;
+UART_HandleTypeDef huart3;
+UART_HandleTypeDef huart6;
 DMA_HandleTypeDef hdma_uart8_rx;
 DMA_HandleTypeDef hdma_uart8_tx;
 
@@ -72,6 +76,10 @@ static void MX_DMA_Init(void);
 static void MX_UART8_Init(void);
 static void MX_CRC_Init(void);
 static void MX_RNG_Init(void);
+static void MX_USART1_UART_Init(void);
+static void MX_USART2_UART_Init(void);
+static void MX_USART3_UART_Init(void);
+static void MX_USART6_UART_Init(void);
 void StartDefaultTask(void *argument);
 
 /* USER CODE BEGIN PFP */
@@ -130,6 +138,10 @@ int main(void)
   MX_UART8_Init();
   MX_CRC_Init();
   MX_RNG_Init();
+  MX_USART1_UART_Init();
+  MX_USART2_UART_Init();
+  MX_USART3_UART_Init();
+  MX_USART6_UART_Init();
   /* USER CODE BEGIN 2 */
 
 //  HAL_DMA_RegisterCallback(&hdma_uart8_rx, HAL_DMA_XFER_CPLT_CB_ID, dmaCallback);
@@ -140,6 +152,8 @@ int main(void)
 
   /* USER CODE BEGIN RTOS_MUTEX */
   /* add mutexes, ... */
+  resMeasurementsMutex = osMutexNew (NULL);
+  sensorsInfoMutex     = osMutexNew (NULL);
   /* USER CODE END RTOS_MUTEX */
 
   /* USER CODE BEGIN RTOS_SEMAPHORES */
@@ -161,7 +175,8 @@ int main(void)
   /* USER CODE BEGIN RTOS_THREADS */
   /* add threads, ... */
   mqtt_cli_init();
-  Uart8TasksInit();
+//  Uart8TasksInit();
+  UartTasksInit();
 #ifdef USER_MOCKS
   MockMeasurmetsTaskInit();
 #else
@@ -358,6 +373,202 @@ static void MX_UART8_Init(void)
 }
 
 /**
+  * @brief USART1 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_USART1_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART1_Init 0 */
+
+  /* USER CODE END USART1_Init 0 */
+
+  /* USER CODE BEGIN USART1_Init 1 */
+
+  /* USER CODE END USART1_Init 1 */
+  huart1.Instance = USART1;
+  huart1.Init.BaudRate = 115200;
+  huart1.Init.WordLength = UART_WORDLENGTH_8B;
+  huart1.Init.StopBits = UART_STOPBITS_1;
+  huart1.Init.Parity = UART_PARITY_NONE;
+  huart1.Init.Mode = UART_MODE_TX_RX;
+  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
+  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
+  huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
+  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXINVERT_INIT;
+  huart1.AdvancedInit.RxPinLevelInvert = UART_ADVFEATURE_RXINV_ENABLE;
+  if (HAL_UART_Init(&huart1) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART1_Init 2 */
+
+  /* USER CODE END USART1_Init 2 */
+
+}
+
+/**
+  * @brief USART2 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_USART2_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART2_Init 0 */
+
+  /* USER CODE END USART2_Init 0 */
+
+  /* USER CODE BEGIN USART2_Init 1 */
+
+  /* USER CODE END USART2_Init 1 */
+  huart2.Instance = USART2;
+  huart2.Init.BaudRate = 115200;
+  huart2.Init.WordLength = UART_WORDLENGTH_8B;
+  huart2.Init.StopBits = UART_STOPBITS_1;
+  huart2.Init.Parity = UART_PARITY_NONE;
+  huart2.Init.Mode = UART_MODE_TX_RX;
+  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
+  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
+  huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
+  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXINVERT_INIT;
+  huart2.AdvancedInit.RxPinLevelInvert = UART_ADVFEATURE_RXINV_ENABLE;
+  if (HAL_UART_Init(&huart2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetTxFifoThreshold(&huart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetRxFifoThreshold(&huart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_DisableFifoMode(&huart2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART2_Init 2 */
+
+  /* USER CODE END USART2_Init 2 */
+
+}
+
+/**
+  * @brief USART3 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_USART3_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART3_Init 0 */
+
+  /* USER CODE END USART3_Init 0 */
+
+  /* USER CODE BEGIN USART3_Init 1 */
+
+  /* USER CODE END USART3_Init 1 */
+  huart3.Instance = USART3;
+  huart3.Init.BaudRate = 115200;
+  huart3.Init.WordLength = UART_WORDLENGTH_8B;
+  huart3.Init.StopBits = UART_STOPBITS_1;
+  huart3.Init.Parity = UART_PARITY_NONE;
+  huart3.Init.Mode = UART_MODE_TX_RX;
+  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
+  huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
+  huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1;
+  huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXINVERT_INIT;
+  huart3.AdvancedInit.RxPinLevelInvert = UART_ADVFEATURE_RXINV_ENABLE;
+  if (HAL_UART_Init(&huart3) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetTxFifoThreshold(&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetRxFifoThreshold(&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_DisableFifoMode(&huart3) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART3_Init 2 */
+
+  /* USER CODE END USART3_Init 2 */
+
+}
+
+/**
+  * @brief USART6 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_USART6_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART6_Init 0 */
+
+  /* USER CODE END USART6_Init 0 */
+
+  /* USER CODE BEGIN USART6_Init 1 */
+
+  /* USER CODE END USART6_Init 1 */
+  huart6.Instance = USART6;
+  huart6.Init.BaudRate = 115200;
+  huart6.Init.WordLength = UART_WORDLENGTH_8B;
+  huart6.Init.StopBits = UART_STOPBITS_1;
+  huart6.Init.Parity = UART_PARITY_NONE;
+  huart6.Init.Mode = UART_MODE_TX_RX;
+  huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart6.Init.OverSampling = UART_OVERSAMPLING_16;
+  huart6.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
+  huart6.Init.ClockPrescaler = UART_PRESCALER_DIV1;
+  huart6.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXINVERT_INIT;
+  huart6.AdvancedInit.RxPinLevelInvert = UART_ADVFEATURE_RXINV_ENABLE;
+  if (HAL_UART_Init(&huart6) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetTxFifoThreshold(&huart6, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetRxFifoThreshold(&huart6, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_DisableFifoMode(&huart6) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART6_Init 2 */
+
+  /* USER CODE END USART6_Init 2 */
+
+}
+
+/**
   * Enable DMA controller clock
   */
 static void MX_DMA_Init(void)
@@ -392,10 +603,10 @@ static void MX_GPIO_Init(void)
   __HAL_RCC_GPIOC_CLK_ENABLE();
   __HAL_RCC_GPIOA_CLK_ENABLE();
   __HAL_RCC_GPIOB_CLK_ENABLE();
+  __HAL_RCC_GPIOD_CLK_ENABLE();
   __HAL_RCC_GPIOE_CLK_ENABLE();
 
 /* USER CODE BEGIN MX_GPIO_Init_2 */
-  __HAL_RCC_GPIOE_CLK_ENABLE();
   GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_PULLUP;
@@ -405,6 +616,16 @@ static void MX_GPIO_Init(void)
   HAL_Delay(100);
   HAL_GPIO_WritePin(GPIOE, GPIO_PIN_14, GPIO_PIN_SET);
   HAL_GPIO_WritePin(GPIOE, GPIO_PIN_15, GPIO_PIN_SET);
+
+//  	GPIO_InitStruct.Pin = GPIO_PIN_14;
+//	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+//	GPIO_InitStruct.Pull = GPIO_PULLUP;
+//	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+//	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+//	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
+//	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
+//	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
+//	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
 /* USER CODE END MX_GPIO_Init_2 */
 }
 

OZE_Main/Core/Src/mqtt_client.c

@@ -24,18 +24,6 @@
 
 #define MQTT_BUFSIZE	1024
 
-//RESMeasurements resMeasurements[SLAVES_COUNT] = { 0 };
-//SesnorsInfo sensorsInfo[SLAVES_COUNT]         = { 0 };
-//uint32_t slaveLastSeen[SLAVES_COUNT] = { 0 };
-//osMutexId_t resMeasurementsMutex;
-//osMutexId_t sensorsInfoMutex;
-
-extern RESMeasurements resMeasurements[SLAVES_COUNT];
-extern SesnorsInfo sensorsInfo[SLAVES_COUNT];
-extern uint32_t slaveLastSeen[SLAVES_COUNT];
-extern osMutexId_t resMeasurementsMutex;
-extern osMutexId_t sensorsInfoMutex;
-
 char* const subscribeTopicNames[SLAVES_COUNT] = { "Set/1", "Set/2", "Set/3", "Set/4" };
 #define MAX_COMMANDS_IN_MQTT_PAYLOAD 6
 char* const topicCommands[MAX_COMMANDS_IN_MQTT_PAYLOAD] = {"fanSpeed", "motorXon", "motorYon", "diode", "motorXMaxCurrent", "motorYMaxCurrent"};
@@ -114,9 +102,6 @@ void MqttClientPubTask (void* argument) {
     uint8_t boardNumber      = 0;
     MQTTMessage message;
 
-    resMeasurementsMutex = osMutexNew (NULL);
-    sensorsInfoMutex     = osMutexNew (NULL);
-
     while (1) {
         if (mqttClient.isconnected) {
             if (is_link_up ()) {

OZE_Main/Core/Src/stm32h7xx_hal_msp.c

@@ -269,6 +269,154 @@ void HAL_UART_MspInit(UART_HandleTypeDef* huart)
 
   /* USER CODE END UART8_MspInit 1 */
   }
+  else if(huart->Instance==USART1)
+  {
+  /* USER CODE BEGIN USART1_MspInit 0 */
+
+  /* USER CODE END USART1_MspInit 0 */
+
+  /** Initializes the peripherals clock
+  */
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART1;
+    PeriphClkInitStruct.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
+    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    /* Peripheral clock enable */
+    __HAL_RCC_USART1_CLK_ENABLE();
+
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+    /**USART1 GPIO Configuration
+    PB14     ------> USART1_TX
+    PB15     ------> USART1_RX
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF4_USART1;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+    /* USART1 interrupt Init */
+    HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(USART1_IRQn);
+  /* USER CODE BEGIN USART1_MspInit 1 */
+
+  /* USER CODE END USART1_MspInit 1 */
+  }
+  else if(huart->Instance==USART2)
+  {
+  /* USER CODE BEGIN USART2_MspInit 0 */
+
+  /* USER CODE END USART2_MspInit 0 */
+
+  /** Initializes the peripherals clock
+  */
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART2;
+    PeriphClkInitStruct.Usart234578ClockSelection = RCC_USART234578CLKSOURCE_D2PCLK1;
+    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    /* Peripheral clock enable */
+    __HAL_RCC_USART2_CLK_ENABLE();
+
+    __HAL_RCC_GPIOD_CLK_ENABLE();
+    /**USART2 GPIO Configuration
+    PD5     ------> USART2_TX
+    PD6     ------> USART2_RX
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
+    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
+
+    /* USART2 interrupt Init */
+    HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(USART2_IRQn);
+  /* USER CODE BEGIN USART2_MspInit 1 */
+
+  /* USER CODE END USART2_MspInit 1 */
+  }
+  else if(huart->Instance==USART3)
+  {
+  /* USER CODE BEGIN USART3_MspInit 0 */
+
+  /* USER CODE END USART3_MspInit 0 */
+
+  /** Initializes the peripherals clock
+  */
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART3;
+    PeriphClkInitStruct.Usart234578ClockSelection = RCC_USART234578CLKSOURCE_D2PCLK1;
+    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    /* Peripheral clock enable */
+    __HAL_RCC_USART3_CLK_ENABLE();
+
+    __HAL_RCC_GPIOD_CLK_ENABLE();
+    /**USART3 GPIO Configuration
+    PD8     ------> USART3_TX
+    PD9     ------> USART3_RX
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
+    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
+
+    /* USART3 interrupt Init */
+    HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(USART3_IRQn);
+  /* USER CODE BEGIN USART3_MspInit 1 */
+
+  /* USER CODE END USART3_MspInit 1 */
+  }
+  else if(huart->Instance==USART6)
+  {
+  /* USER CODE BEGIN USART6_MspInit 0 */
+
+  /* USER CODE END USART6_MspInit 0 */
+
+  /** Initializes the peripherals clock
+  */
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART6;
+    PeriphClkInitStruct.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
+    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    /* Peripheral clock enable */
+    __HAL_RCC_USART6_CLK_ENABLE();
+
+    __HAL_RCC_GPIOC_CLK_ENABLE();
+    /**USART6 GPIO Configuration
+    PC6     ------> USART6_TX
+    PC7     ------> USART6_RX
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF7_USART6;
+    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
+    /* USART6 interrupt Init */
+    HAL_NVIC_SetPriority(USART6_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(USART6_IRQn);
+  /* USER CODE BEGIN USART6_MspInit 1 */
+
+  /* USER CODE END USART6_MspInit 1 */
+  }
 
 }
 
@@ -304,6 +452,86 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
 
   /* USER CODE END UART8_MspDeInit 1 */
   }
+  else if(huart->Instance==USART1)
+  {
+  /* USER CODE BEGIN USART1_MspDeInit 0 */
+
+  /* USER CODE END USART1_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_USART1_CLK_DISABLE();
+
+    /**USART1 GPIO Configuration
+    PB14     ------> USART1_TX
+    PB15     ------> USART1_RX
+    */
+    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_14|GPIO_PIN_15);
+
+    /* USART1 interrupt DeInit */
+    HAL_NVIC_DisableIRQ(USART1_IRQn);
+  /* USER CODE BEGIN USART1_MspDeInit 1 */
+
+  /* USER CODE END USART1_MspDeInit 1 */
+  }
+  else if(huart->Instance==USART2)
+  {
+  /* USER CODE BEGIN USART2_MspDeInit 0 */
+
+  /* USER CODE END USART2_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_USART2_CLK_DISABLE();
+
+    /**USART2 GPIO Configuration
+    PD5     ------> USART2_TX
+    PD6     ------> USART2_RX
+    */
+    HAL_GPIO_DeInit(GPIOD, GPIO_PIN_5|GPIO_PIN_6);
+
+    /* USART2 interrupt DeInit */
+    HAL_NVIC_DisableIRQ(USART2_IRQn);
+  /* USER CODE BEGIN USART2_MspDeInit 1 */
+
+  /* USER CODE END USART2_MspDeInit 1 */
+  }
+  else if(huart->Instance==USART3)
+  {
+  /* USER CODE BEGIN USART3_MspDeInit 0 */
+
+  /* USER CODE END USART3_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_USART3_CLK_DISABLE();
+
+    /**USART3 GPIO Configuration
+    PD8     ------> USART3_TX
+    PD9     ------> USART3_RX
+    */
+    HAL_GPIO_DeInit(GPIOD, GPIO_PIN_8|GPIO_PIN_9);
+
+    /* USART3 interrupt DeInit */
+    HAL_NVIC_DisableIRQ(USART3_IRQn);
+  /* USER CODE BEGIN USART3_MspDeInit 1 */
+
+  /* USER CODE END USART3_MspDeInit 1 */
+  }
+  else if(huart->Instance==USART6)
+  {
+  /* USER CODE BEGIN USART6_MspDeInit 0 */
+
+  /* USER CODE END USART6_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_USART6_CLK_DISABLE();
+
+    /**USART6 GPIO Configuration
+    PC6     ------> USART6_TX
+    PC7     ------> USART6_RX
+    */
+    HAL_GPIO_DeInit(GPIOC, GPIO_PIN_6|GPIO_PIN_7);
+
+    /* USART6 interrupt DeInit */
+    HAL_NVIC_DisableIRQ(USART6_IRQn);
+  /* USER CODE BEGIN USART6_MspDeInit 1 */
+
+  /* USER CODE END USART6_MspDeInit 1 */
+  }
 
 }
 

OZE_Main/Core/Src/stm32h7xx_it.c

@@ -59,6 +59,10 @@ extern ETH_HandleTypeDef heth;
 extern DMA_HandleTypeDef hdma_uart8_rx;
 extern DMA_HandleTypeDef hdma_uart8_tx;
 extern UART_HandleTypeDef huart8;
+extern UART_HandleTypeDef huart1;
+extern UART_HandleTypeDef huart2;
+extern UART_HandleTypeDef huart3;
+extern UART_HandleTypeDef huart6;
 extern TIM_HandleTypeDef htim6;
 
 /* USER CODE BEGIN EV */
@@ -178,6 +182,48 @@ void RCC_IRQHandler(void)
 }
 
 /**
+  * @brief This function handles USART1 global interrupt.
+  */
+void USART1_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART1_IRQn 0 */
+
+  /* USER CODE END USART1_IRQn 0 */
+  HAL_UART_IRQHandler(&huart1);
+  /* USER CODE BEGIN USART1_IRQn 1 */
+
+  /* USER CODE END USART1_IRQn 1 */
+}
+
+/**
+  * @brief This function handles USART2 global interrupt.
+  */
+void USART2_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART2_IRQn 0 */
+
+  /* USER CODE END USART2_IRQn 0 */
+  HAL_UART_IRQHandler(&huart2);
+  /* USER CODE BEGIN USART2_IRQn 1 */
+
+  /* USER CODE END USART2_IRQn 1 */
+}
+
+/**
+  * @brief This function handles USART3 global interrupt.
+  */
+void USART3_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART3_IRQn 0 */
+
+  /* USER CODE END USART3_IRQn 0 */
+  HAL_UART_IRQHandler(&huart3);
+  /* USER CODE BEGIN USART3_IRQn 1 */
+
+  /* USER CODE END USART3_IRQn 1 */
+}
+
+/**
   * @brief This function handles TIM6 global interrupt, DAC1_CH1 and DAC1_CH2 underrun error interrupts.
   */
 void TIM6_DAC_IRQHandler(void)
@@ -234,6 +280,20 @@ void DMA2_Stream7_IRQHandler(void)
 }
 
 /**
+  * @brief This function handles USART6 global interrupt.
+  */
+void USART6_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART6_IRQn 0 */
+
+  /* USER CODE END USART6_IRQn 0 */
+  HAL_UART_IRQHandler(&huart6);
+  /* USER CODE BEGIN USART6_IRQn 1 */
+
+  /* USER CODE END USART6_IRQn 1 */
+}
+
+/**
   * @brief This function handles UART8 global interrupt.
   */
 void UART8_IRQHandler(void)

OZE_Main/Core/Src/uart_tasks.c

@@ -12,29 +12,41 @@
 #include <string.h>
 
 #include "interprocess_data.h"
-#include "measurements.h"
 #include "mock_tasks.h"
 #include "uart_tasks.h"
 
 enum SerialReceiverStates { srWaitForHeader, srCheckCrc, srRecieveData, srExecuteCmd, srFail, srFinish, srLast };
 
-// osThreadId_t uart8RecieveTaskHandle;
-// osThreadId_t uart8TransmitTaskHandle;
-//  osSemaphoreDef_t uart8RxSemaphoreDef;
-//  osSemaphoreId_t uart8RxSemaphore = NULL;
-
-// osMessageQueueId_t uart8DecodedFrameDataTaskQueue;
-// osMessageQueueId_t uart8SendCmdToSlaveQueue;
-
+extern UART_HandleTypeDef huart1;
+extern UART_HandleTypeDef huart2;
+extern UART_HandleTypeDef huart3;
+extern UART_HandleTypeDef huart6;
 extern UART_HandleTypeDef huart8;
 extern DMA_HandleTypeDef hdma_uart8_rx;
 extern CRC_HandleTypeDef hcrc;
 
+uint8_t uart1RxBuffer[UART1_RX_BUFF_SIZE]        = { 0 };
+uint8_t uart1TxBuffer[UART1_TX_BUFF_SIZE]        = { 0 };
+uint8_t uart1TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
+
+uint8_t uart2RxBuffer[UART2_RX_BUFF_SIZE]        = { 0 };
+uint8_t uart2TxBuffer[UART2_TX_BUFF_SIZE]        = { 0 };
+uint8_t uart2TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
+
+uint8_t uart3RxBuffer[UART3_RX_BUFF_SIZE]        = { 0 };
+uint8_t uart3TxBuffer[UART3_TX_BUFF_SIZE]        = { 0 };
+uint8_t uart3TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
+
+uint8_t uart6RxBuffer[UART6_RX_BUFF_SIZE]        = { 0 };
+uint8_t uart6TxBuffer[UART6_TX_BUFF_SIZE]        = { 0 };
+uint8_t uart6TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
+
 uint8_t uart8RxBuffer[UART8_RX_BUFF_SIZE]        = { 0 };
 uint8_t uart8TxBuffer[UART8_TX_BUFF_SIZE]        = { 0 };
 uint8_t uart8TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
 
-uint8_t boardToUartNumberMap[SLAVES_COUNT] = { /*1*/ 8, 3, 6, 2 };
+//uint8_t boardToUartNumberMap[SLAVES_COUNT] = { 8, 3, 6, 2 };
+uint8_t boardToUartNumberMap[SLAVES_COUNT] = { 1, 3, 6, 2 };
 
 UartTaskData uart1TaskData = { 0 }; // Board 1
 UartTaskData uart3TaskData = { 0 }; // Board 2
@@ -42,17 +54,12 @@ UartTaskData uart6TaskData = { 0 }; // Board 3
 UartTaskData uart2TaskData = { 0 }; // Board 4
 UartTaskData uart8TaskData = { 0 }; // Debug
 
-UartTaskData* uartTasks[] = { &uart8TaskData, NULL };
+//UartTaskData* uartTasks[] = { &uart8TaskData, &uart3TaskData, &uart6TaskData, &uart2TaskData, NULL, };
+UartTaskData* uartTasks[] = { &uart1TaskData, &uart3TaskData, &uart6TaskData, &uart2TaskData, NULL, };
 
 uint8_t outputDataBuffer[OUTPUT_DATA_BUFF_SIZE];
 uint16_t outputDataBufferPos = 0;
 
-
-//extern uint32_t slaveLastSeen[SLAVES_COUNT];
-//extern RESMeasurements resMeasurements[SLAVES_COUNT];
-//extern SesnorsInfo sensorsInfo[SLAVES_COUNT];
-//extern osMutexId_t resMeasurementsMutex;
-//extern osMutexId_t sensorsInfoMutex;
 RESMeasurements resMeasurements[SLAVES_COUNT] = { 0 };
 SesnorsInfo sensorsInfo[SLAVES_COUNT]         = { 0 };
 uint32_t slaveLastSeen[SLAVES_COUNT] = { 0 };
@@ -61,49 +68,82 @@ osMutexId_t sensorsInfoMutex;
 
 extern RNG_HandleTypeDef hrng;
 
+void UartTasksInit (void) {
+    uart1TaskData.uartRxBuffer    = uart1RxBuffer;
+    uart1TaskData.uartRxBufferLen = UART1_RX_BUFF_SIZE;
+    uart1TaskData.uartTxBuffer    = uart1TxBuffer;
+    uart1TaskData.uartRxBufferLen = UART1_TX_BUFF_SIZE;
+    uart1TaskData.frameData       = uart1TaskFrameData;
+    uart1TaskData.frameDataLen    = UART1_RX_BUFF_SIZE;
+    uart1TaskData.huart           = &huart1;
+    uart1TaskData.uartNumber      = 1;
+
+    uart2TaskData.uartRxBuffer    = uart2RxBuffer;
+    uart2TaskData.uartRxBufferLen = UART2_RX_BUFF_SIZE;
+    uart2TaskData.uartTxBuffer    = uart2TxBuffer;
+    uart2TaskData.uartRxBufferLen = UART2_TX_BUFF_SIZE;
+    uart2TaskData.frameData       = uart2TaskFrameData;
+    uart2TaskData.frameDataLen    = UART2_RX_BUFF_SIZE;
+    uart2TaskData.huart           = &huart2;
+    uart2TaskData.uartNumber      = 2;
+
+    uart3TaskData.uartRxBuffer    = uart3RxBuffer;
+    uart3TaskData.uartRxBufferLen = UART3_RX_BUFF_SIZE;
+    uart3TaskData.uartTxBuffer    = uart3TxBuffer;
+    uart3TaskData.uartRxBufferLen = UART3_TX_BUFF_SIZE;
+    uart3TaskData.frameData       = uart3TaskFrameData;
+    uart3TaskData.frameDataLen    = UART3_RX_BUFF_SIZE;
+    uart3TaskData.huart           = &huart3;
+    uart3TaskData.uartNumber      = 3;
+
+    uart6TaskData.uartRxBuffer    = uart6RxBuffer;
+    uart6TaskData.uartRxBufferLen = UART6_RX_BUFF_SIZE;
+    uart6TaskData.uartTxBuffer    = uart6TxBuffer;
+    uart6TaskData.uartRxBufferLen = UART6_TX_BUFF_SIZE;
+    uart6TaskData.frameData       = uart6TaskFrameData;
+    uart6TaskData.frameDataLen    = UART6_RX_BUFF_SIZE;
+    uart6TaskData.huart           = &huart6;
+    uart6TaskData.uartNumber      = 6;
+
+    uart8TaskData.uartRxBuffer    = uart8RxBuffer;
+    uart8TaskData.uartRxBufferLen = UART8_RX_BUFF_SIZE;
+    uart8TaskData.uartTxBuffer    = uart8TxBuffer;
+    uart8TaskData.uartRxBufferLen = UART8_TX_BUFF_SIZE;
+    uart8TaskData.frameData       = uart8TaskFrameData;
+    uart8TaskData.frameDataLen    = UART8_RX_BUFF_SIZE;
+    uart8TaskData.huart           = &huart8;
+    uart8TaskData.uartNumber      = 8;
+
+    UartTaskCreate (&uart1TaskData);
+    UartTaskCreate (&uart2TaskData);
+    UartTaskCreate (&uart3TaskData);
+    UartTaskCreate (&uart6TaskData);
+    UartTaskCreate (&uart8TaskData);
+}
 
-void Uart8TasksInit (void) {
+void UartTaskCreate (UartTaskData* uartTaskData) {
     osThreadAttr_t osThreadAttrRxUart = { 0 };
     osThreadAttr_t osThreadAttrTxUart = { 0 };
-#if 0
-	osMessageQueueAttr_t uartRxMsgQueueAttr = { 0 };
-	uartRxMsgQueueAttr.name = "uart8RxMsgQueue";
-	uart8DecodedFrameDataTaskQueue = osMessageQueueNew(4, sizeof(SerialProtocolFrameData), &uartRxMsgQueueAttr);
-	uart8TaskData.processDataQueue = uart8DecodedFrameDataTaskQueue;
-#else
-//    uart8TaskData.processDataQueue = NULL;
-#endif
 
-	uart8TaskData.processRxDataMsgBuffer = xMessageBufferCreate( INPUT_DATA_BUFF_SIZE );
-//    uart8TaskData.processDataCb = Uart8ReceivedDataProcessCallback;
-    uart8TaskData.processDataCb = NULL;
+    uartTaskData->processRxDataMsgBuffer = xMessageBufferCreate (INPUT_DATA_BUFF_SIZE);
+    uartTaskData->processDataCb          = NULL;
 
-    osThreadAttrRxUart.name       = "os_thread_uart8_rx";
+    //    osThreadAttrRxUart.name       = "os_thread_uart1_rx";
     osThreadAttrRxUart.stack_size = configMINIMAL_STACK_SIZE * 2;
     osThreadAttrRxUart.priority   = (osPriority_t)osPriorityHigh;
 
-    //	uart8RxSemaphoreDef.name = "uart8RxSemaphore";
-    //	uart8RxSemaphore = osSemaphoreNew(1, 1, NULL);
 
-    uart8TaskData.uartRxBuffer          = uart8RxBuffer;
-    uart8TaskData.uartRxBufferLen       = UART8_RX_BUFF_SIZE;
-    uart8TaskData.uartTxBuffer          = uart8TxBuffer;
-    uart8TaskData.uartRxBufferLen       = UART8_TX_BUFF_SIZE;
-    uart8TaskData.frameData             = uart8TaskFrameData;
-    uart8TaskData.frameDataLen          = UART8_RX_BUFF_SIZE;
-    uart8TaskData.huart                 = &huart8;
-    uart8TaskData.uartNumber            = 8;
-    uart8TaskData.uartRecieveTaskHandle = osThreadNew (UartRxTask, &uart8TaskData, &osThreadAttrRxUart);
+    uartTaskData->uartRecieveTaskHandle = osThreadNew (UartRxTask, uartTaskData, &osThreadAttrRxUart);
 
 
     osMessageQueueAttr_t uartTxMsgQueueAttr = { 0 };
-    uartTxMsgQueueAttr.name                 = "uart8TxMsgQueue";
-    uart8TaskData.sendCmdToSlaveQueue       = osMessageQueueNew (16, sizeof (InterProcessData), &uartTxMsgQueueAttr);
+    //    uartTxMsgQueueAttr.name                 = "uart1TxMsgQueue";
+    uartTaskData->sendCmdToSlaveQueue = osMessageQueueNew (16, sizeof (InterProcessData), &uartTxMsgQueueAttr);
 
-    osThreadAttrTxUart.name              = "os_thread_uart8_tx";
+    //    osThreadAttrTxUart.name              = "os_thread_uart1_tx";
     osThreadAttrTxUart.stack_size        = configMINIMAL_STACK_SIZE * 4;
     osThreadAttrTxUart.priority          = (osPriority_t)osPriorityNormal;
-    uart8TaskData.uartTransmitTaskHandle = osThreadNew (UartTxTask, &uart8TaskData, &osThreadAttrTxUart);
+    uartTaskData->uartTransmitTaskHandle = osThreadNew (UartTxTask, uartTaskData, &osThreadAttrTxUart);
 }
 
 void HAL_UART_RxCpltCallback (UART_HandleTypeDef* huart) {
@@ -111,7 +151,15 @@ void HAL_UART_RxCpltCallback (UART_HandleTypeDef* huart) {
 }
 
 void HAL_UARTEx_RxEventCallback (UART_HandleTypeDef* huart, uint16_t Size) {
-    if (huart->Instance == UART8) {
+    if (huart->Instance == USART1) {
+        HandleUartRxCallback (&uart1TaskData, huart, Size);
+    } else if (huart->Instance == USART2) {
+        HandleUartRxCallback (&uart2TaskData, huart, Size);
+    } else if (huart->Instance == USART3) {
+        HandleUartRxCallback (&uart3TaskData, huart, Size);
+    } else if (huart->Instance == USART6) {
+        HandleUartRxCallback (&uart6TaskData, huart, Size);
+    } else if (huart->Instance == UART8) {
         HandleUartRxCallback (&uart8TaskData, huart, Size);
     }
 }
@@ -233,15 +281,11 @@ void UartRxTask (void* argument) {
                 }
                 break;
             case srExecuteCmd:
-                if (/*(uartTaskData->processDataQueue != NULL) || */(uartTaskData->processDataCb != NULL) || (uartTaskData->processRxDataMsgBuffer != NULL)) {
+                if ((uartTaskData->processDataCb != NULL) || (uartTaskData->processRxDataMsgBuffer != NULL)) {
                     osMutexAcquire (uartTaskData->rxDataBufferMutex, osWaitForever);
                     memcpy (spFrameData.dataBuffer, &(uartTaskData->frameData[FRAME_HEADER_LENGTH]), spFrameData.frameHeader.frameDataLength);
                     osMutexRelease (uartTaskData->rxDataBufferMutex);
                 }
-
-//                if (uartTaskData->processDataQueue != NULL) {
-//                    osMessageQueuePut (uartTaskData->processDataQueue, &spFrameData, 0, osWaitForever);
-//                }
                 if (uartTaskData->processRxDataMsgBuffer != NULL) {
                     if(xMessageBufferSend (uartTaskData->processRxDataMsgBuffer, &spFrameData, sizeof (SerialProtocolFrameHeader) + spFrameData.frameHeader.frameDataLength, pdMS_TO_TICKS (200)) == pdFALSE)
                     {
@@ -257,22 +301,22 @@ void UartRxTask (void* argument) {
             case srFail:
                 dataToSend = 0;
                 if ((frameTimeout == pdTRUE) && (frameBytesCount > 2)) {
-                    dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spTimeout, NULL, 0);
+                    dataToSend = PrepareRespFrame (uartTaskData->uartTxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spTimeout, NULL, 0);
 #if UART_TASK_LOGS
                     printf ("Uart%d: RX data receiver timeout!\n", uartTaskData->uartNumber);
 #endif
                 } else if (!crcPass) {
-                    dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spCrcFail, NULL, 0);
+                    dataToSend = PrepareRespFrame (uartTaskData->uartTxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spCrcFail, NULL, 0);
 #if UART_TASK_LOGS
                     printf ("Uart%d: Frame CRC FAIL\n", uartTaskData->uartNumber);
 #endif
                 }
                 else
                 {
-                	dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spInternalError, NULL, 0);
+                	dataToSend = PrepareRespFrame (uartTaskData->uartTxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spInternalError, NULL, 0);
                 }
                 if (dataToSend > 0) {
-                    HAL_UART_Transmit_IT (&huart8, uart8TxBuffer, dataToSend);
+                    HAL_UART_Transmit_IT (uartTaskData->huart, uartTaskData->uartTxBuffer, dataToSend);
                 }
 #if UART_TASK_LOGS
                 printf ("Uart%d: TX bytes sent: %d\n", dataToSend, uartTaskData->uartNumber);
@@ -295,33 +339,6 @@ void UartRxTask (void* argument) {
     }
 }
 
-void Uart8ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFrameData) {
-    UartTaskData* uartTaskData = (UartTaskData*)arg;
-    uint16_t dataToSend        = 0;
-    switch (spFrameData->frameHeader.frameCommand) {
-    case spGetElectricalMeasurments:
-        float slaveVoltage = 48.0 + rndflt (0.5);
-        slaveVoltage = 48.0 + rndflt (1);
-        WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &slaveVoltage, sizeof (float));
-        WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &slaveVoltage, sizeof (float));
-        slaveVoltage = 47.5 + rndflt (0.5);
-        WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &slaveVoltage, sizeof (float));
-        break;
-    case spGetSensorMeasurments: break;
-    default: break;
-    }
-    if (outputDataBufferPos > 0) {
-        dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData->frameHeader.frameId, spFrameData->frameHeader.frameCommand, spOK, outputDataBuffer, outputDataBufferPos);
-    }
-    if (dataToSend > 0) {
-        //        HAL_UART_Transmit_DMA(&huart8, uart8TxBuffer, dataToSend);
-        HAL_UART_Transmit_IT (uartTaskData->huart, uart8TxBuffer, dataToSend);
-    }
-#if UART_TASK_LOGS
-    printf ("Uart%d: TX bytes sent: %d\n", uartTaskData->uartNumber, dataToSend);
-#endif
-}
-
 void ReadMeasSetFromBuffer(uint8_t* buff, uint16_t* buffPos, float* dataSet)
 {
 	for(uint8_t i = 0; i < 3; i++)
@@ -365,8 +382,8 @@ void UartTxTask (void* argument) {
             default: continue; break;
             }
 
-            bytesToSend = PrepareReqFrame (uart8TxBuffer, frameId, frameCommand, outputDataBuffer, outputDataBufferPos);
-            HAL_UART_Transmit_IT (uartTaskData->huart, uart8TxBuffer, bytesToSend);
+            bytesToSend = PrepareReqFrame (uartTaskData->uartTxBuffer, frameId, frameCommand, outputDataBuffer, outputDataBufferPos);
+            HAL_UART_Transmit_IT (uartTaskData->huart, uartTaskData->uartTxBuffer, bytesToSend);
             bytesInMsg = xMessageBufferReceive (uartTaskData->processRxDataMsgBuffer, &frameData, INPUT_DATA_BUFF_SIZE, pdMS_TO_TICKS (1000));
         	for(boardNumber = 0; boardNumber < SLAVES_COUNT; boardNumber++)
         	{
@@ -472,6 +489,6 @@ void MeasurmentsReqSchedulerTask (void* argument) {
             }
             ptr++;
         }
-        osDelay (pdMS_TO_TICKS (1000));
+        osDelay (pdMS_TO_TICKS (MEASURMENTS_SCHEDULER_INTERVAL_MS));
     }
 }

OZE_Main/LWIP/Target/ethernetif.c

@@ -676,6 +676,7 @@ void HAL_ETH_MspInit(ETH_HandleTypeDef* ethHandle)
     PC5     ------> ETH_RXD1
     PB0     ------> ETH_RXD2
     PB1     ------> ETH_RXD3
+    PB10     ------> ETH_RX_ER
     PB11     ------> ETH_TX_EN
     PB12     ------> ETH_TXD0
     PB13     ------> ETH_TXD1
@@ -705,6 +706,13 @@ void HAL_ETH_MspInit(ETH_HandleTypeDef* ethHandle)
     GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
+    GPIO_InitStruct.Pin = GPIO_PIN_10;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
     /* Peripheral interrupt init */
     HAL_NVIC_SetPriority(ETH_IRQn, 5, 0);
     HAL_NVIC_EnableIRQ(ETH_IRQn);

OZE_Sensor/.cproject

@@ -181,4 +181,5 @@
 			<autodiscovery enabled="false" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
 	</storageModule>
+	<storageModule moduleId="refreshScope"/>
 </cproject>

OZE_Sensor/Core/Inc/stm32h7xx_it.h

@@ -53,6 +53,7 @@ void BusFault_Handler(void);
 void UsageFault_Handler(void);
 void DebugMon_Handler(void);
 void RCC_IRQHandler(void);
+void USART1_IRQHandler(void);
 void TIM6_DAC_IRQHandler(void);
 void DMA2_Stream6_IRQHandler(void);
 void DMA2_Stream7_IRQHandler(void);

OZE_Sensor/Core/Inc/uart_tasks.h

@@ -16,8 +16,13 @@
 #include "main.h"
 #include "serial_protocol.h"
 
-#define UART8_RX_BUFF_SIZE 256
-#define UART8_TX_BUFF_SIZE 256
+#define UART_RX_BUFF_SIZE 256
+#define UART_TX_BUFF_SIZE 256
+
+#define UART1_RX_BUFF_SIZE UART_RX_BUFF_SIZE
+#define UART1_TX_BUFF_SIZE UART_TX_BUFF_SIZE
+#define UART8_RX_BUFF_SIZE UART_RX_BUFF_SIZE
+#define UART8_TX_BUFF_SIZE UART_TX_BUFF_SIZE
 #define INPUT_DATA_BUFF_SIZE UART8_RX_BUFF_SIZE
 #define OUTPUT_DATA_BUFF_SIZE 128
 
@@ -63,8 +68,11 @@ struct _UartTaskData {
 
 typedef struct _UartTaskData UartTaskData;
 
-
 void Uart8TasksInit (void);
+void UartTasksInit(void);
+void UartTaskCreate (UartTaskData* uartTaskData);
+
+void Uart1ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFrameData);
 void Uart8ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFrameData);
 
 void UartRxTask (void* argument);

OZE_Sensor/Core/Src/main.c

@@ -49,6 +49,7 @@ CRC_HandleTypeDef hcrc;
 RNG_HandleTypeDef hrng;
 
 UART_HandleTypeDef huart8;
+UART_HandleTypeDef huart1;
 DMA_HandleTypeDef hdma_uart8_rx;
 DMA_HandleTypeDef hdma_uart8_tx;
 
@@ -71,6 +72,7 @@ static void MX_DMA_Init(void);
 static void MX_UART8_Init(void);
 static void MX_CRC_Init(void);
 static void MX_RNG_Init(void);
+static void MX_USART1_UART_Init(void);
 void StartDefaultTask(void *argument);
 
 /* USER CODE BEGIN PFP */
@@ -126,6 +128,7 @@ int main(void)
   MX_UART8_Init();
   MX_CRC_Init();
   MX_RNG_Init();
+  MX_USART1_UART_Init();
   /* USER CODE BEGIN 2 */
 
   /* USER CODE END 2 */
@@ -155,7 +158,8 @@ int main(void)
 
   /* USER CODE BEGIN RTOS_THREADS */
   /* add threads, ... */
-  Uart8TasksInit();
+//  Uart8TasksInit();
+  UartTasksInit();
 #ifdef USER_MOCKS
   MockMeasurmetsTaskInit();
 #else
@@ -351,6 +355,55 @@ static void MX_UART8_Init(void)
 }
 
 /**
+  * @brief USART1 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_USART1_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART1_Init 0 */
+
+  /* USER CODE END USART1_Init 0 */
+
+  /* USER CODE BEGIN USART1_Init 1 */
+
+  /* USER CODE END USART1_Init 1 */
+  huart1.Instance = USART1;
+  huart1.Init.BaudRate = 115200;
+  huart1.Init.WordLength = UART_WORDLENGTH_8B;
+  huart1.Init.StopBits = UART_STOPBITS_1;
+  huart1.Init.Parity = UART_PARITY_NONE;
+  huart1.Init.Mode = UART_MODE_TX_RX;
+  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
+  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
+  huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
+  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXINVERT_INIT;
+  huart1.AdvancedInit.RxPinLevelInvert = UART_ADVFEATURE_RXINV_ENABLE;
+  if (HAL_UART_Init(&huart1) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART1_Init 2 */
+
+  /* USER CODE END USART1_Init 2 */
+
+}
+
+/**
   * Enable DMA controller clock
   */
 static void MX_DMA_Init(void)
@@ -382,8 +435,8 @@ static void MX_GPIO_Init(void)
 
   /* GPIO Ports Clock Enable */
   __HAL_RCC_GPIOH_CLK_ENABLE();
-  __HAL_RCC_GPIOA_CLK_ENABLE();
   __HAL_RCC_GPIOB_CLK_ENABLE();
+  __HAL_RCC_GPIOA_CLK_ENABLE();
   __HAL_RCC_GPIOE_CLK_ENABLE();
 
   /*Configure GPIO pin : PB8 */

OZE_Sensor/Core/Src/stm32h7xx_hal_msp.c

@@ -269,6 +269,43 @@ void HAL_UART_MspInit(UART_HandleTypeDef* huart)
 
   /* USER CODE END UART8_MspInit 1 */
   }
+  else if(huart->Instance==USART1)
+  {
+  /* USER CODE BEGIN USART1_MspInit 0 */
+
+  /* USER CODE END USART1_MspInit 0 */
+
+  /** Initializes the peripherals clock
+  */
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART1;
+    PeriphClkInitStruct.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
+    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    /* Peripheral clock enable */
+    __HAL_RCC_USART1_CLK_ENABLE();
+
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+    /**USART1 GPIO Configuration
+    PB14     ------> USART1_TX
+    PB15     ------> USART1_RX
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+    GPIO_InitStruct.Alternate = GPIO_AF4_USART1;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+    /* USART1 interrupt Init */
+    HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(USART1_IRQn);
+  /* USER CODE BEGIN USART1_MspInit 1 */
+
+  /* USER CODE END USART1_MspInit 1 */
+  }
 
 }
 
@@ -304,6 +341,26 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
 
   /* USER CODE END UART8_MspDeInit 1 */
   }
+  else if(huart->Instance==USART1)
+  {
+  /* USER CODE BEGIN USART1_MspDeInit 0 */
+
+  /* USER CODE END USART1_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_USART1_CLK_DISABLE();
+
+    /**USART1 GPIO Configuration
+    PB14     ------> USART1_TX
+    PB15     ------> USART1_RX
+    */
+    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_14|GPIO_PIN_15);
+
+    /* USART1 interrupt DeInit */
+    HAL_NVIC_DisableIRQ(USART1_IRQn);
+  /* USER CODE BEGIN USART1_MspDeInit 1 */
+
+  /* USER CODE END USART1_MspDeInit 1 */
+  }
 
 }
 

OZE_Sensor/Core/Src/stm32h7xx_it.c

@@ -58,6 +58,7 @@
 extern DMA_HandleTypeDef hdma_uart8_rx;
 extern DMA_HandleTypeDef hdma_uart8_tx;
 extern UART_HandleTypeDef huart8;
+extern UART_HandleTypeDef huart1;
 extern TIM_HandleTypeDef htim6;
 
 /* USER CODE BEGIN EV */
@@ -176,6 +177,20 @@ void RCC_IRQHandler(void)
 }
 
 /**
+  * @brief This function handles USART1 global interrupt.
+  */
+void USART1_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART1_IRQn 0 */
+
+  /* USER CODE END USART1_IRQn 0 */
+  HAL_UART_IRQHandler(&huart1);
+  /* USER CODE BEGIN USART1_IRQn 1 */
+
+  /* USER CODE END USART1_IRQn 1 */
+}
+
+/**
   * @brief This function handles TIM6 global interrupt, DAC1_CH1 and DAC1_CH2 underrun error interrupts.
   */
 void TIM6_DAC_IRQHandler(void)

OZE_Sensor/Core/Src/uart_tasks.c

@@ -26,10 +26,15 @@ enum SerialReceiverStates { srWaitForHeader, srCheckCrc, srRecieveData, srExecut
 // osMessageQueueId_t uart8DecodedFrameDataTaskQueue;
 // osMessageQueueId_t uart8SendCmdToSlaveQueue;
 
+extern UART_HandleTypeDef huart1;
 extern UART_HandleTypeDef huart8;
 extern DMA_HandleTypeDef hdma_uart8_rx;
 extern CRC_HandleTypeDef hcrc;
 
+uint8_t uart1RxBuffer[UART1_RX_BUFF_SIZE]        = { 0 };
+uint8_t uart1TxBuffer[UART1_TX_BUFF_SIZE]        = { 0 };
+uint8_t uart1TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
+
 uint8_t uart8RxBuffer[UART8_RX_BUFF_SIZE]        = { 0 };
 uint8_t uart8TxBuffer[UART8_TX_BUFF_SIZE]        = { 0 };
 uint8_t uart8TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
@@ -61,6 +66,48 @@ osMutexId_t sensorsInfoMutex;
 
 extern RNG_HandleTypeDef hrng;
 
+void UartTasksInit(void) {
+  uart1TaskData.uartRxBuffer = uart1RxBuffer;
+  uart1TaskData.uartRxBufferLen = UART1_RX_BUFF_SIZE;
+  uart1TaskData.uartTxBuffer = uart1TxBuffer;
+  uart1TaskData.uartRxBufferLen = UART1_TX_BUFF_SIZE;
+  uart1TaskData.frameData = uart1TaskFrameData;
+  uart1TaskData.frameDataLen = UART1_RX_BUFF_SIZE;
+  uart1TaskData.huart = &huart1;
+  uart1TaskData.uartNumber = 1;
+  uart1TaskData.processDataCb = Uart1ReceivedDataProcessCallback;
+  uart1TaskData.processRxDataMsgBuffer = NULL;
+
+//  uart8TaskData.uartRxBuffer = uart8RxBuffer;
+//  uart8TaskData.uartRxBufferLen = UART8_RX_BUFF_SIZE;
+//  uart8TaskData.uartTxBuffer = uart8TxBuffer;
+//  uart8TaskData.uartRxBufferLen = UART8_TX_BUFF_SIZE;
+//  uart8TaskData.frameData = uart8TaskFrameData;
+//  uart8TaskData.frameDataLen = UART8_RX_BUFF_SIZE;
+//  uart8TaskData.huart = &huart8;
+//  uart8TaskData.uartNumber = 8;
+//  uart8TaskData.processDataCb = Uart8ReceivedDataProcessCallback;
+//  uart8TaskData.processRxDataMsgBuffer = NULL;
+
+  UartTaskCreate(&uart1TaskData);
+//  UartTaskCreate(&uart8TaskData);
+}
+
+void UartTaskCreate (UartTaskData* uartTaskData) {
+    osThreadAttr_t osThreadAttrRxUart = { 0 };
+//    osThreadAttr_t osThreadAttrTxUart = { 0 };
+
+    osThreadAttrRxUart.stack_size = configMINIMAL_STACK_SIZE * 2;
+    osThreadAttrRxUart.priority   = (osPriority_t)osPriorityHigh;
+    uartTaskData->uartRecieveTaskHandle = osThreadNew (UartRxTask, uartTaskData, &osThreadAttrRxUart);
+
+//    osMessageQueueAttr_t uartTxMsgQueueAttr = { 0 };
+//    uartTaskData->sendCmdToSlaveQueue = osMessageQueueNew (16, sizeof (InterProcessData), &uartTxMsgQueueAttr);
+
+//    osThreadAttrTxUart.stack_size        = configMINIMAL_STACK_SIZE * 4;
+//    osThreadAttrTxUart.priority          = (osPriority_t)osPriorityNormal;
+//    uartTaskData->uartTransmitTaskHandle = osThreadNew (UartTxTask, uartTaskData, &osThreadAttrTxUart);
+}
 
 void Uart8TasksInit (void) {
     osThreadAttr_t osThreadAttrRxUart = { 0 };
@@ -110,10 +157,12 @@ void HAL_UART_RxCpltCallback (UART_HandleTypeDef* huart) {
     //	osSemaphoreRelease(uart8RxSemaphore);
 }
 
-void HAL_UARTEx_RxEventCallback (UART_HandleTypeDef* huart, uint16_t Size) {
-    if (huart->Instance == UART8) {
-        HandleUartRxCallback (&uart8TaskData, huart, Size);
-    }
+void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t Size) {
+  if (huart->Instance == USART1) {
+    HandleUartRxCallback(&uart1TaskData, huart, Size);
+  } else if (huart->Instance == UART8) {
+    HandleUartRxCallback(&uart8TaskData, huart, Size);
+  }
 }
 
 void HAL_UART_TxCpltCallback (UART_HandleTypeDef* huart) {
@@ -254,22 +303,22 @@ void UartRxTask (void* argument) {
             case srFail:
                 dataToSend = 0;
                 if ((frameTimeout == pdTRUE) && (frameBytesCount > 2)) {
-                    dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spTimeout, NULL, 0);
+                    dataToSend = PrepareRespFrame (uartTaskData->uartTxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spTimeout, NULL, 0);
 #if UART_TASK_LOGS
                     printf ("Uart%d: RX data receiver timeout!\n", uartTaskData->uartNumber);
 #endif
                 } else if (!crcPass) {
-                    dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spCrcFail, NULL, 0);
+                    dataToSend = PrepareRespFrame (uartTaskData->uartTxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spCrcFail, NULL, 0);
 #if UART_TASK_LOGS
                     printf ("Uart%d: Frame CRC FAIL\n", uartTaskData->uartNumber);
 #endif
                 }
                 else
                 {
-                	dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spInternalError, NULL, 0);
+                	dataToSend = PrepareRespFrame (uartTaskData->uartTxBuffer, spFrameData.frameHeader.frameId, spFrameData.frameHeader.frameCommand, spInternalError, NULL, 0);
                 }
                 if (dataToSend > 0) {
-                    HAL_UART_Transmit_IT (&huart8, uart8TxBuffer, dataToSend);
+                    HAL_UART_Transmit_IT (uartTaskData->huart, uartTaskData->uartTxBuffer, dataToSend);
                 }
 #if UART_TASK_LOGS
                 printf ("Uart%d: TX bytes sent: %d\n", dataToSend, uartTaskData->uartNumber);
@@ -292,7 +341,12 @@ void UartRxTask (void* argument) {
     }
 }
 
-void Uart8ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFrameData) {
+void Uart8ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFrameData)
+{
+	Uart1ReceivedDataProcessCallback(arg, spFrameData);
+}
+
+void Uart1ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFrameData) {
     UartTaskData* uartTaskData = (UartTaskData*)arg;
     uint16_t dataToSend        = 0;
     outputDataBufferPos = 0;
@@ -349,10 +403,10 @@ void Uart8ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFra
     default: break;
     }
     if (outputDataBufferPos > 0) {
-        dataToSend = PrepareRespFrame (uart8TxBuffer, spFrameData->frameHeader.frameId, spFrameData->frameHeader.frameCommand, spOK, outputDataBuffer, outputDataBufferPos);
+        dataToSend = PrepareRespFrame (uartTaskData->uartTxBuffer, spFrameData->frameHeader.frameId, spFrameData->frameHeader.frameCommand, spOK, outputDataBuffer, outputDataBufferPos);
     }
     if (dataToSend > 0) {
-        HAL_UART_Transmit_IT (uartTaskData->huart, uart8TxBuffer, dataToSend);
+        HAL_UART_Transmit_IT (uartTaskData->huart, uartTaskData->uartTxBuffer, dataToSend);
     }
 #if UART_TASK_LOGS
     printf ("Uart%d: TX bytes sent: %d\n", uartTaskData->uartNumber, dataToSend);

OZE_Sensor/OZE_Sensor.ioc

@@ -75,6 +75,7 @@ Mcu.CPN=STM32H742VIT6
 Mcu.Family=STM32H7
 Mcu.IP0=CORTEX_M7
 Mcu.IP1=CRC
+Mcu.IP10=USART1
 Mcu.IP2=DEBUG
 Mcu.IP3=DMA
 Mcu.IP4=FREERTOS
@@ -83,21 +84,23 @@ Mcu.IP6=RCC
 Mcu.IP7=RNG
 Mcu.IP8=SYS
 Mcu.IP9=UART8
-Mcu.IPNb=10
+Mcu.IPNb=11
 Mcu.Name=STM32H742V(G-I)Tx
 Mcu.Package=LQFP100
 Mcu.Pin0=PH0-OSC_IN (PH0)
 Mcu.Pin1=PH1-OSC_OUT (PH1)
-Mcu.Pin10=VP_SYS_VS_tim6
-Mcu.Pin2=PA13 (JTMS/SWDIO)
-Mcu.Pin3=PA14 (JTCK/SWCLK)
-Mcu.Pin4=PB8
-Mcu.Pin5=PE0
-Mcu.Pin6=PE1
-Mcu.Pin7=VP_CRC_VS_CRC
-Mcu.Pin8=VP_FREERTOS_VS_CMSIS_V2
-Mcu.Pin9=VP_RNG_VS_RNG
-Mcu.PinsNb=11
+Mcu.Pin10=VP_FREERTOS_VS_CMSIS_V2
+Mcu.Pin11=VP_RNG_VS_RNG
+Mcu.Pin12=VP_SYS_VS_tim6
+Mcu.Pin2=PB14
+Mcu.Pin3=PB15
+Mcu.Pin4=PA13 (JTMS/SWDIO)
+Mcu.Pin5=PA14 (JTCK/SWCLK)
+Mcu.Pin6=PB8
+Mcu.Pin7=PE0
+Mcu.Pin8=PE1
+Mcu.Pin9=VP_CRC_VS_CRC
+Mcu.PinsNb=13
 Mcu.ThirdPartyNb=0
 Mcu.UserConstants=
 Mcu.UserName=STM32H742VITx
@@ -123,11 +126,16 @@ NVIC.TIM6_DAC_IRQn=true\:15\:0\:false\:false\:true\:false\:false\:true\:true
 NVIC.TimeBase=TIM6_DAC_IRQn
 NVIC.TimeBaseIP=TIM6
 NVIC.UART8_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
+NVIC.USART1_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
 NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false\:false
 PA13\ (JTMS/SWDIO).Mode=Serial_Wire
 PA13\ (JTMS/SWDIO).Signal=DEBUG_JTMS-SWDIO
 PA14\ (JTCK/SWCLK).Mode=Serial_Wire
 PA14\ (JTCK/SWCLK).Signal=DEBUG_JTCK-SWCLK
+PB14.Mode=Asynchronous
+PB14.Signal=USART1_TX
+PB15.Mode=Asynchronous
+PB15.Signal=USART1_RX
 PB8.GPIOParameters=GPIO_Speed
 PB8.GPIO_Speed=GPIO_SPEED_FREQ_VERY_HIGH
 PB8.Locked=true
@@ -171,7 +179,7 @@ ProjectManager.ToolChainLocation=
 ProjectManager.UAScriptAfterPath=
 ProjectManager.UAScriptBeforePath=
 ProjectManager.UnderRoot=true
-ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_DMA_Init-DMA-false-HAL-true,4-MX_UART8_Init-UART8-false-HAL-true,5-MX_LWIP_Init-LWIP-false-HAL-false,6-MX_CRC_Init-CRC-false-HAL-true,7-MX_RNG_Init-RNG-false-HAL-true,0-MX_CORTEX_M7_Init-CORTEX_M7-false-HAL-true
+ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_DMA_Init-DMA-false-HAL-true,4-MX_UART8_Init-UART8-false-HAL-true,5-MX_CRC_Init-CRC-false-HAL-true,6-MX_RNG_Init-RNG-false-HAL-true,7-MX_USART1_UART_Init-USART1-false-HAL-true,0-MX_CORTEX_M7_Init-CORTEX_M7-false-HAL-true
 RCC.ADCFreq_Value=130000000
 RCC.AHB12Freq_Value=200000000
 RCC.AHB4Freq_Value=200000000
@@ -250,6 +258,10 @@ RCC.VCO3OutputFreq_Value=260000000
 RCC.VCOInput1Freq_Value=5000000
 RCC.VCOInput2Freq_Value=5000000
 RCC.VCOInput3Freq_Value=5000000
+USART1.IPParameters=VirtualMode-Asynchronous,TxPinLevelInvertParam,RxPinLevelInvertParam
+USART1.RxPinLevelInvertParam=ADVFEATURE_RXINV_ENABLE
+USART1.TxPinLevelInvertParam=ADVFEATURE_TXINV_DISABLE
+USART1.VirtualMode-Asynchronous=VM_ASYNC
 VP_CRC_VS_CRC.Mode=CRC_Activate
 VP_CRC_VS_CRC.Signal=CRC_VS_CRC
 VP_FREERTOS_VS_CMSIS_V2.Mode=CMSIS_V2