/**
* @brief GetOut_Self
* @param None
* @retval None
*/
static uint8_t UsartSendPacked(uint8_t* data, uint8_t wlen, uint8_t rlen)
{
static uint8_t tx_data[10];
static uint8_t rx_timeout_cnt = 0;
if(rx_complite || rx_timeout_cnt >= 10) {
rx_timeout_cnt = rx_complite = 0;
HAL_UART_DMAStop(&huart1);
tx_data[0] = 0x5B;
tx_data[1] = wlen;
tx_data[wlen+3] = tx_data[0] + tx_data[1];
for (uint8_t i = 0; i < wlen; i++) {
tx_data[i+2] = data[i];
tx_data[wlen+2] += data[i];
}
HAL_UART_Transmit_DMA(&huart1, (uint8_t*)tx_data, wlen+3);
HAL_UART_Receive_DMA(&huart1, (uint8_t*)rx_rdata, rlen);
return 1;
}
else {
rx_timeout_cnt++;
}
return 0;
}
/* Downlink DMA 4 (port-to-memory) setup */
void DownlinkDMA4_Setup(UART_HandleTypeDef* huart, uint8_t num, uint8_t start)
{
/* UART RX DMA (DMA2 Ch3) */
if (huart->Instance == USART1) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART1_RX);
} else if (huart->Instance == USART2) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART2_RX);
} else if (huart->Instance == USART3) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART3_RX);
} else if (huart->Instance == USART4) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART4_RX);
} else if (huart->Instance == USART5) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART5_RX);
} else if (huart->Instance == USART6) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART6_RX);
} else if (huart->Instance == USART7) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART7_RX);
} else if (huart->Instance == USART8) {
__HAL_DMA2_REMAP(HAL_DMA2_CH3_USART8_RX);
}
__HAL_LINKDMA(huart,hdmarx,downlinkDMA4);
/* Setup streaming baudrate */
huart->Init.BaudRate = 3000000;
HAL_UART_Init(huart);
/* DMA interrupt init */
HAL_NVIC_SetPriority(DMA1_Ch4_7_DMA2_Ch3_5_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Ch4_7_DMA2_Ch3_5_IRQn);
/* Start DMA stream */
HAL_UART_Receive_DMA(huart, (uint8_t *)&dataBuffer+start, num);
}
int uart_dma_init(void)
{
tx_idx_dma = 0;
tx_idx_write = 0;
rx_idx_in = 0;
rx_idx_out = 0;
rx_full = 0;
/* start the dma must be configured in circular mode */
return HAL_UART_Receive_DMA(&huart1, (uint8_t*)rx_dma_buffer, 2) != HAL_OK;
}
/* USER CODE BEGIN 1 */
void UART_SetDMA(void)
{
if(HAL_UART_Receive_DMA(&huart1,RecBuffer,BUFFER_SIZE) == HAL_OK)
{
printf("Info:Com1 OK\n");
}
else
{
printf("Error:Com1 NG\n");
}
}
void uart_recv_bytes(drv_uart_T *uart, uint8_T *buf, uint32_T n)
{
while(uart_rx_locked(uart)); /* 等待上一次接收完成 */
uart_rx_lock(uart); /* 锁住资源 */
if(HAL_UART_Receive_DMA(&uart->handle, buf, n)!= HAL_OK)
{
/* 出错 */
while(TRUE);
}
}
/**
* @brief 串口DMA接收完成中断的回调函�?
* @note 每次解包完成后会重置DMA，所以只有当串口有错误发生才会触发此回调
* @param None
* @retval None
*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
printf("Error:Com1 overflow,please check serial port\n");
if(HAL_UART_Receive_DMA(&huart1,RecBuffer,BUFFER_SIZE) == HAL_OK)
{
printf("Info:Restart Com1\n");
}
else
{
printf("Error:Com1 NG\n");
}
}
char cGetChar( void )
{
uint8_t cInputChar;
if( xSemaphoreTake( xDEBUGbusMutex, cmdMAX_MUTEX_WAIT ) == pdPASS ) {
HAL_UART_Receive_DMA(&BOOT_UART,&cInputChar,1);
xSemaphoreGive( xDEBUGbusMutex ); // вернём
xSemaphoreTake( xNewDataSemaphore, portMAX_DELAY ); // если не приняли ни одного байта, то захватываем семафор информирующий о приёме новых данных и ждем от прерывания инфы
}
return cInputChar;
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_USART2_UART_Init();
MX_USART3_UART_Init();
MX_TIM3_Init();
/* USER CODE BEGIN 2 */
HAL_TIM_Base_Start_IT(&htim3);
HAL_UART_Transmit_DMA(&huart3,g_cUart3_Buff,BUFFSIZE);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
HAL_UART_Receive_DMA(&huart3,g_cUart3_Buff,BUFFSIZE);
//HAL_UART_Transmit_IT(&huart3,g_cUart3_Buff,5);
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/** Begin asynchronous RX transfer (enable interrupt for data collecting)
* The used buffer is specified in the serial object - rx_buff
*
* @param obj The serial object
* @param rx The buffer for sending
* @param rx_length The number of words to transmit
* @param rx_width The bit width of buffer word
* @param handler The serial handler
* @param event The logical OR of events to be registered
* @param handler The serial handler
* @param char_match A character in range 0-254 to be matched
* @param hint A suggestion for how to use DMA with this transfer
*/
void serial_rx_asynch(serial_t *obj, void *rx, size_t rx_length, uint8_t rx_width, uint32_t handler, uint32_t event, uint8_t char_match, DMAUsage hint)
{
/* Sanity check arguments */
MBED_ASSERT(obj);
MBED_ASSERT(rx != (void*)0);
MBED_ASSERT(rx_width == 8); // support only 8b width
h_serial_rx_enable_event(obj, SERIAL_EVENT_RX_ALL, 0);
h_serial_rx_enable_event(obj, event, 1);
// set CharMatch
if (char_match != SERIAL_RESERVED_CHAR_MATCH) {
obj->char_match = char_match;
}
h_serial_rx_buffer_set(obj, rx, rx_length, rx_width);
IRQn_Type irqn = h_serial_get_irq_index(obj);
NVIC_ClearPendingIRQ(irqn);
NVIC_DisableIRQ(irqn);
NVIC_SetPriority(irqn, 0);
NVIC_SetVector(irqn, (uint32_t)handler);
NVIC_EnableIRQ(irqn);
UartHandle.Instance = (USART_TypeDef *)SERIAL_OBJ(uart);
// flush current data + error flags
__HAL_UART_CLEAR_PEFLAG(&UartHandle);
#if DEVICE_SERIAL_ASYNCH_DMA
// Enable DMA interrupt
irqn = h_serial_rx_get_irqdma_index(obj);
NVIC_ClearPendingIRQ(irqn);
NVIC_DisableIRQ(irqn);
NVIC_SetPriority(irqn, 1);
NVIC_SetVector(irqn, (uint32_t)handler);
NVIC_EnableIRQ(irqn);
// following HAL function will program and enable the DMA transfer
HAL_UART_Receive_DMA(&UartHandle, (uint8_t*)rx, rx_length);
#else
// following HAL function will enable the RXNE interrupt + error interrupts
HAL_UART_Receive_IT(&UartHandle, (uint8_t*)rx, rx_length);
#endif
/* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_ERR);
return;
}
int main(void)
{
/* USER CODE BEGIN 1 */
uint8_t Data;
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
/* USER CODE BEGIN 2 */
BSP_UART_Init(115200);
/* Receive data on UART 6 */
HAL_UART_Receive_DMA(&huart6,&Data,1);
trace_printf("Hello\n");
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
if(UartReady == 1)
{
HAL_UART_Transmit_DMA(&huart6,&Data,1);
UartReady = 0;
}
}
/* USER CODE END 3 */
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
rxString[rxindex] = rxBuffer;
if(rxBuffer == '\n')
{
executeSerialCommand(rxString, rxindex);
rxindex = 0;
int iter = 0;
for (iter = 0; iter < 100; iter++){ rxString[iter] = '\000'; } /* Clear out the string to avoid reevaluating data */
}
else{
rxindex++;
if(rxindex > 100){rxindex = 0;}
}
HAL_UART_Receive_DMA(&huart1, &rxBuffer, 1);
}
void initSerial()
{
__DMA2_CLK_ENABLE();
HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
huart1.Instance = USART1;
huart1.Init.BaudRate = BAUDRATE;
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;
HAL_UART_Init(&huart1);
sendSerialString("[OK] Serial started..\n");
/* Start the receiver */
HAL_UART_Receive_DMA(&huart1, &rxBuffer, 1);
}
/* Main serial init function. Run this before sending any serial */
void initSerial()
{
/* Init UART */
huart1.Instance = USART1;
huart1.Init.BaudRate = BAUDRATE;
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;
HAL_UART_Init(&huart1);
/* Print OK */
print("\r\n[OK] Serial started");
/* Start the receiver */
__HAL_UART_FLUSH_DRREGISTER(&huart1);
HAL_UART_Receive_DMA(&huart1, &rxBuffer, 1);
}
/**
* @brief This function handles USART2 global interrupt.
*/
void USART2_IRQHandler(void)
{
/* USER CODE BEGIN USART2_IRQn 0 */
uint32_t tmp_flag = 0;
tmp_flag = __HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE);
if((tmp_flag != RESET))
{
__HAL_UART_CLEAR_IDLEFLAG(&huart2);
huart2.Instance->ISR; //读取寄存器，清理相应标志位
huart2.Instance->TDR; //读取寄存器，清理相应标志位
HAL_UART_DMAStop(&huart2);
dma_state = HAL_UART_Receive_DMA(&huart2,uart2_recv_buf,BUFFER_SIZE);
}
/* USER CODE END USART2_IRQn 0 */
HAL_UART_IRQHandler(&huart2);
/* USER CODE BEGIN USART2_IRQn 1 */
/* USER CODE END USART2_IRQn 1 */
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_USART2_UART_Init();
/* USER CODE BEGIN 2 */
char *msg = "Nucleo-64 ISR-UART-DMA Fun!\n\r";
HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), 0xFFFF);
HAL_UART_Receive_DMA(&huart2, &rxBuffer, 1);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief It's LOW-LEVEL usart receive initialization function.
* The DMA will be used to receive data.
* @param huart:Which usart port used to receive data
* @retval null
*/
static void USART_Start_Receive_DMA(UART_HandleTypeDef *huart)
{
HAL_UART_Receive_DMA(huart, (uint8_t*)uart_buf, MAX_DEPTH_UART1_BUF);
/*!< Enable the Idle interrupt.
Attention: REMEMBER to add IDLE Interrupt handler to stm324xx_it.c.
[...] The Idle ISR code is following
uint32_t tmp1, tmp2;
tmp1 = __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE);
tmp2 = __HAL_UART_GET_IT_SOURCE(&huart1, UART_IT_IDLE);
if((tmp1 != RESET) && (tmp2 != RESET))
{
__HAL_UART_CLEAR_IDLEFLAG(&huart1);
My_HAL_UART_IdleCallback(&huart1);
}
[...]
*/
__HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
}
/**
* Initialize the UART to communicate with the Skywire modem.
*/
void
skywire_init() {
/* Configure the UART for the Skywire modem. */
__HAL_RCC_USART1_CLK_ENABLE();
skywire.huart.Instance = USART1;
skywire.huart.State = HAL_UART_STATE_RESET;
skywire.huart.Init.BaudRate = 115200;
skywire.huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
skywire.huart.Init.Mode = UART_MODE_TX_RX;
skywire.huart.Init.WordLength = UART_WORDLENGTH_8B;
skywire.huart.Init.Parity = UART_PARITY_NONE;
skywire.huart.Init.StopBits = UART_STOPBITS_1;
skywire.huart.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&skywire.huart);
/* Configure a DMA channel to service the UART. */
__HAL_RCC_DMA2_CLK_ENABLE();
skywire.hdma.Instance = DMA2_Stream5;
skywire.hdma.State = HAL_DMA_STATE_RESET;
skywire.hdma.Init.Channel = DMA_CHANNEL_4;
skywire.hdma.Init.Direction = DMA_PERIPH_TO_MEMORY;
skywire.hdma.Init.PeriphInc = DMA_PINC_DISABLE;
skywire.hdma.Init.MemInc = DMA_MINC_ENABLE;
skywire.hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
skywire.hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
skywire.hdma.Init.Mode = DMA_CIRCULAR;
skywire.hdma.Init.Priority = DMA_PRIORITY_LOW;
skywire.hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
skywire.hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
skywire.hdma.Init.MemBurst = DMA_MBURST_SINGLE;
skywire.hdma.Init.PeriphBurst = DMA_PBURST_SINGLE;
HAL_DMA_Init(&skywire.hdma);
__HAL_LINKDMA(&skywire.huart, hdmarx, skywire.hdma);
/* Start the receive process. */
HAL_UART_Receive_DMA(&skywire.huart, skywire.rx_buffer, skywire.rx_length);
}
/* Uplink DMA 2 (port-to-port) setup */
void UplinkDMA2_Setup(UART_HandleTypeDef* huartSrc, UART_HandleTypeDef* huartDst)
{
/* UART RX DMA (DMA1 Ch3) */
if (huartSrc->Instance == USART1) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART1_RX);
} else if (huartSrc->Instance == USART2) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART2_RX);
} else if (huartSrc->Instance == USART3) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART3_RX);
} else if (huartSrc->Instance == USART4) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART4_RX);
} else if (huartSrc->Instance == USART5) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART5_RX);
} else if (huartSrc->Instance == USART6) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART6_RX);
} else if (huartSrc->Instance == USART7) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART7_RX);
} else if (huartSrc->Instance == USART8) {
__HAL_DMA1_REMAP(HAL_DMA1_CH3_USART8_RX);
}
__HAL_LINKDMA(huartSrc,hdmarx,uplinkDMA2);
/* Setup streaming baudrate */
huartSrc->Init.BaudRate = 3000000;
HAL_UART_Init(huartSrc);
huartDst->Init.BaudRate = 3000000;
HAL_UART_Init(huartDst);
/* DMA interrupt init */
HAL_NVIC_SetPriority(DMA1_Ch2_3_DMA2_Ch1_2_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Ch2_3_DMA2_Ch1_2_IRQn);
/* Start DMA stream */
huartSrc->State = HAL_UART_STATE_READY;
HAL_UART_Receive_DMA(huartSrc, (uint8_t *)(&(huartDst->Instance->TDR)), 1);
}
int main(void)
{
HAL_Init();
/* Configure the system clock to 64 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/*##-1- Configure the UART peripheral ######################################*/
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
if (HAL_UART_Init(&UartHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
if (HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)&UartHandle.Instance->DR, 1) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F0xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED1, LED2 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART configured as follows:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = ODD parity
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_ODD;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
if (HAL_UART_Init(&UartHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Start the transmission process #####################################*/
/* User start transmission data through "TxBuffer" buffer */
if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aTxBuffer, TXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Put UART peripheral in reception process ###########################*/
/* Any data received will be stored in "RxBuffer" buffer : the number max of
data received is 10 */
if (HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
/*##-4- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
{
}
/*##-5- Send the received Buffer ###########################################*/
if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-6- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
{
}
/* Infinite loop */
while (1)
{
}
}
void uart2_start(UART_HandleTypeDef *huart) {
huart2 = huart;
__HAL_UART_FLUSH_DRREGISTER(huart);
HAL_UART_Receive_DMA(huart, &uart2_rx_byte, 1);
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F3xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 72 MHz */
SystemClock_Config();
/* Configure LED5, LED6, LED4 and LED3 */
BSP_LED_Init(LED5);
BSP_LED_Init(LED6);
BSP_LED_Init(LED4);
BSP_LED_Init(LED3);
#ifdef TRANSMITTER_BOARD
/* Configure User push-button in Interrupt mode */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* Wait for User push-button press before starting the Communication.
In the meantime, LED6 is blinking */
while(UserButtonStatus == 0)
{
/* Toggle LED6*/
BSP_LED_Toggle(LED6);
HAL_Delay(100);
}
BSP_LED_Off(LED6);
#endif
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART configured as follows:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = None
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if(HAL_UART_DeInit(&UartHandle) != HAL_OK)
{
Error_Handler();
}
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
Error_Handler();
}
#ifdef TRANSMITTER_BOARD
/* The board sends the message and expects to receive it back */
/* DMA is programmed for reception before starting the transmission, in order to
be sure DMA Rx is ready when board 2 will start transmitting */
/*##-2- Program the Reception process #####################################*/
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
Error_Handler();
}
/*##-3- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
Error_Handler();
}
/*##-4- Wait for the end of the transfer ###################################*/
while (UartReady != SET)
{
}
/* Reset transmission flag */
UartReady = RESET;
#else
/* The board receives the message and sends it back */
/*##-2- Put UART peripheral in reception process ###########################*/
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* While waiting for message to come from the other board, LED6 is
blinking according to the following pattern: a double flash every half-second */
while (UartReady != SET)
{
BSP_LED_On(LED6);
HAL_Delay(100);
BSP_LED_Off(LED6);
HAL_Delay(100);
BSP_LED_On(LED6);
HAL_Delay(100);
BSP_LED_Off(LED6);
HAL_Delay(500);
}
/* Reset transmission flag */
UartReady = RESET;
BSP_LED_Off(LED6);
/*##-4- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
Error_Handler();
}
#endif /* TRANSMITTER_BOARD */
/*##-5- Wait for the end of the transfer ###################################*/
while (UartReady != SET)
{
}
/* Reset transmission flag */
UartReady = RESET;
/*##-6- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
{
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
static void ComPort_Config(USBD_CDC_HandleTypeDef *hcdc)
{
if (hcdc->UartHandle.State != HAL_UART_STATE_RESET)
if (HAL_UART_DeInit(&hcdc->UartHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* set the Stop bit */
switch (hcdc->LineCoding.format)
{
case 0:
hcdc->UartHandle.Init.StopBits = UART_STOPBITS_1;
break;
case 2:
hcdc->UartHandle.Init.StopBits = UART_STOPBITS_2;
break;
default:
hcdc->UartHandle.Init.StopBits = UART_STOPBITS_1;
break;
}
/* set the parity bit*/
switch (hcdc->LineCoding.paritytype)
{
case 0:
hcdc->UartHandle.Init.Parity = UART_PARITY_NONE;
break;
case 1:
hcdc->UartHandle.Init.Parity = UART_PARITY_ODD;
break;
case 2:
hcdc->UartHandle.Init.Parity = UART_PARITY_EVEN;
break;
default:
hcdc->UartHandle.Init.Parity = UART_PARITY_NONE;
break;
}
/*set the data type : only 8bits and 9bits is supported */
switch (hcdc->LineCoding.datatype)
{
case 0x07:
/* With this configuration a parity (Even or Odd) must be set */
hcdc->UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
break;
case 0x08:
if(hcdc->UartHandle.Init.Parity == UART_PARITY_NONE)
{
hcdc->UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
}
else
{
hcdc->UartHandle.Init.WordLength = UART_WORDLENGTH_9B;
}
break;
default:
hcdc->UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
break;
}
hcdc->UartHandle.Init.BaudRate = hcdc->LineCoding.bitrate;
hcdc->UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
hcdc->UartHandle.Init.Mode = UART_MODE_TX_RX;
if(HAL_UART_Init(&hcdc->UartHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Start reception */
HAL_UART_Receive_DMA(&hcdc->UartHandle, (uint8_t *)(hcdc->InboundBuffer), INBOUND_BUFFER_SIZE);
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 168 MHz */
SystemClock_Config();
/* Configure LED1, LED2 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART1 configured as follow:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = ODD parity
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_ODD;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Start the transmission process #####################################*/
/* User start transmission data through "TxBuffer" buffer */
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE)!= HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Put UART peripheral in reception process ###########################*/
/* Any data received will be stored in "RxBuffer" buffer : the number max of
data received is 10 */
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
/*##-4- Wait for the end of the transfer ###################################*/
while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
{
}
/*##-5- Send the received Buffer ###########################################*/
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aRxBuffer, RXBUFFERSIZE)!= HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-6- Wait for the end of the transfer ###################################*/
while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
{
}
/*##-7- Send the End Message ###############################################*/
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE)!= HAL_OK)
{
/* Turn LED3 on: Transfer error in transmission process */
BSP_LED_On(LED3);
while(1)
{
}
}
/*##-8- Wait for the end of the transfer ###################################*/
while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
{
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED3, LED4, LED5 and LED6 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
BSP_LED_Init(LED6);
/* Configure the system clock to 100 MHz */
SystemClock_Config();
#ifdef TRANSMITTER_BOARD
/* Configure USER Button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wait for USER Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) == RESET)
{
/* Toggle LED3 waiting for user to press button */
BSP_LED_Toggle(LED3);
HAL_Delay(40);
}
/* Wait for USER Button to be release before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) == SET)
{
}
/* Turn LED3 off */
BSP_LED_Off(LED3);
#endif /* TRANSMITTER_BOARD */
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART1 configured as follow:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = None
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
Error_Handler();
}
#ifdef TRANSMITTER_BOARD
/* The board sends the message and expects to receive it back */
/* DMA is programmed for reception before starting the transmission, in order to
be sure DMA Rx is ready when board 2 will start transmitting */
/*##-2- Program the Reception process #####################################*/
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
Error_Handler();
}
/*##-3- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
Error_Handler();
}
/*##-4- Wait for the end of the transfer ###################################*/
while (UartReady != SET)
{
}
/* Reset transmission flag */
UartReady = RESET;
#else
/* The board receives the message and sends it back */
/*##-2- Put UART peripheral in reception process ###########################*/
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* While waiting for message to come from the other board, LED2 is
blinking according to the following pattern: a double flash every half-second */
while (UartReady != SET)
{
BSP_LED_On(LED3);
HAL_Delay(100);
BSP_LED_Off(LED3);
HAL_Delay(100);
BSP_LED_On(LED3);
HAL_Delay(100);
BSP_LED_Off(LED3);
HAL_Delay(500);
}
/* Reset transmission flag */
UartReady = RESET;
BSP_LED_Off(LED3);
/* Reset transmission flag */
UartReady = RESET;
/*##-4- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
Error_Handler();
}
#endif /* TRANSMITTER_BOARD */
/*##-5- Wait for the end of the transfer ###################################*/
while (UartReady != SET)
{
}
/* Reset transmission flag */
UartReady = RESET;
/*##-6- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
{
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_USART1_UART_Init();
MX_USART2_UART_Init();
MX_SPI1_Init();
/* USER CODE BEGIN 2 */
/* 硬件初始化开始 */
// USART_printf( &BSP_USART_PRINT, "开始硬件初始化!\n");
/* 初始化输出 */
ControlOut_Init( );
/* 初始化控制模式 */
ModeControl_Init( );
/* 初始化主控模块 */
DataProcess_Init( );
/*启动循环接收DMA*/
HAL_UART_Receive_DMA(&BSP_USART_SENSOR, (uint8_t*)&gUSART1_RX_TMP, 1);
/* 硬件初始化结束 */
// USART_printf( &BSP_USART_PRINT, "硬件初始化结束 !\n");
/* USER CODE END 2 */
/* USER CODE BEGIN RTOS_MUTEX */
/* add mutexes, ... */
/* USER CODE END RTOS_MUTEX */
/* USER CODE BEGIN RTOS_SEMAPHORES */
/* add semaphores, ... */
/* USER CODE END RTOS_SEMAPHORES */
/* USER CODE BEGIN RTOS_TIMERS */
/* start timers, add new ones, ... */
/* USER CODE END RTOS_TIMERS */
/* Create the thread(s) */
/* definition and creation of MainTask */
osThreadDef(MainTask, StartMainTask, osPriorityBelowNormal, 0, 128);
MainTaskHandle = osThreadCreate(osThread(MainTask), NULL);
/* definition and creation of DataParseTask */
osThreadDef(DataParseTask, StartDataParseTask, osPriorityNormal, 0, 160);
DataParseTaskHandle = osThreadCreate(osThread(DataParseTask), NULL);
/* definition and creation of DataProcessTask */
osThreadDef(DataProcessTask, StartDataProcessTask, osPriorityAboveNormal, 0, 256);
DataProcessTaskHandle = osThreadCreate(osThread(DataProcessTask), NULL);
/* definition and creation of DataOutTask */
osThreadDef(DataOutTask, StartDataOutTask, osPriorityHigh, 0, 160);
DataOutTaskHandle = osThreadCreate(osThread(DataOutTask), NULL);
/* definition and creation of PrintTask */
osThreadDef(PrintTask, StartPrintTask, osPriorityBelowNormal, 0, 128);
PrintTaskHandle = osThreadCreate(osThread(PrintTask), NULL);
/* USER CODE BEGIN RTOS_THREADS */
/* add threads, ... */
/* USER CODE END RTOS_THREADS */
/* Create the queue(s) */
/* definition and creation of ReceiveDataQueue */
osMessageQDef(ReceiveDataQueue, 128, uint8_t);
ReceiveDataQueueHandle = osMessageCreate(osMessageQ(ReceiveDataQueue), NULL);
/* definition and creation of PrintQueues */
osMessageQDef(PrintQueues, 512, uint8_t);
PrintQueuesHandle = osMessageCreate(osMessageQ(PrintQueues), NULL);
/* USER CODE BEGIN RTOS_QUEUES */
/* add queues, ... */
/* 创建传感器采集值邮箱 */
gSenorDataMail = osMailCreate(osMailQ(gSenorDataMail), NULL);
/* 创建处理结果输出邮箱 */
gControlDataMail = osMailCreate(osMailQ(gSenorDataMail), NULL);
/* USER CODE END RTOS_QUEUES */
/* Start scheduler */
osKernelStart();
/* We should never get here as control is now taken by the scheduler */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief Configure the USART
* @retval None
*/
void USARTConfig(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
/*##-1- Enable peripherals and GPIO Clocks #################################*/
/* Enable GPIO TX/RX clock */
USARTx_TX_GPIO_CLK_ENABLE();
USARTx_RX_GPIO_CLK_ENABLE();
/* Enable USART2 clock */
USARTx_CLK_ENABLE();
/* Enable DMA1 clock */
DMAx_CLK_ENABLE();
/*##-2- Configure peripheral GPIO ##########################################*/
/* UART TX GPIO pin configuration */
GPIO_InitStruct.Pin = USARTx_TX_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
#if ((defined (USE_STM32F4XX_NUCLEO)) || (defined (USE_STM32L0XX_NUCLEO)))
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
#endif
#if (defined (USE_STM32L1XX_NUCLEO))
GPIO_InitStruct.Speed = GPIO_SPEED_MEDIUM;
#endif
GPIO_InitStruct.Alternate = USARTx_TX_AF;
HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct);
/* UART RX GPIO pin configuration */
GPIO_InitStruct.Pin = USARTx_RX_PIN;
GPIO_InitStruct.Alternate = USARTx_RX_AF;
HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct);
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = Usart_BaudRate;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
// Error_Handler();
while(1);
}
USART_DMA_Configuration();
UartHandle.pRxBuffPtr = (uint8_t*)UART_RxBuffer;
UartHandle.RxXferSize = UART_RxBufferSize;
UartHandle.ErrorCode = HAL_UART_ERROR_NONE;
/* Enable the DMA transfer for the receiver request by setting the DMAR bit
in the UART CR3 register */
HAL_UART_Receive_DMA(&UartHandle, (uint8_t*)UART_RxBuffer, UART_RxBufferSize);
}
/**
* @brief Настройка UART-интерфейса на ожидание следующей порции данных
*/
void WaitNextByteFromUART(UART_HandleTypeDef *huart)
{
//Ожидаем следующий
HAL_UART_Receive_DMA(huart,pUARTRxBuf,1);
}
/**
* @brief Receives an amount of data in non blocking mode.
* @param huart: pointer to a UART_HandleTypeDef structure that contains
* the configuration information for the specified UART module.
* @param p_data: Pointer to data buffer
* @param size: Amount of data to be received
*/
void read_uart_noblocking(UART_HandleTypeDef *huart, uint8_t *p_data, uint16_t size)
{
HAL_UART_Receive_DMA(huart, p_data, size);
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
#ifdef TRANSMITTER_BOARD
GPIO_InitTypeDef GPIO_InitStruct;
#endif
/* STM32F0xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
#ifdef TRANSMITTER_BOARD
/* Configure PA.12 (Arduino D2) as input with External interrupt */
GPIO_InitStruct.Pin = GPIO_PIN_12;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
/* Enable GPIOA clock */
__HAL_RCC_GPIOA_CLK_ENABLE();
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Enable and set PA.12 (Arduino D2) EXTI Interrupt to the lowest priority */
NVIC_SetPriority((IRQn_Type)(EXTI4_15_IRQn), 0x03);
HAL_NVIC_EnableIRQ((IRQn_Type)(EXTI4_15_IRQn));
/* Wait for the user to set GPIOA to GND before starting the Communication.
In the meantime, LED3 is blinking */
while(VirtualUserButtonStatus == 0)
{
/* Toggle LED3*/
BSP_LED_Toggle(LED3);
HAL_Delay(100);
}
BSP_LED_Off(LED3);
#endif
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART configured as follows:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = None
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if(HAL_UART_DeInit(&UartHandle) != HAL_OK)
{
Error_Handler();
}
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
Error_Handler();
}
#ifdef TRANSMITTER_BOARD
/* The board sends the message and expects to receive it back */
/* DMA is programmed for reception before starting the transmission, in order to
be sure DMA Rx is ready when board 2 will start transmitting */
/*##-2- Program the Reception process #####################################*/
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
Error_Handler();
}
/*##-3- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
Error_Handler();
}
/*##-4- Wait for the end of the transfer ###################################*/
while (UartReady != SET)
{
}
/* Reset transmission flag */
UartReady = RESET;
#else
/* The board receives the message and sends it back */
/*##-2- Put UART peripheral in reception process ###########################*/
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* While waiting for message to come from the other board, LED3 is
blinking according to the following pattern: a double flash every half-second */
while (UartReady != SET)
{
BSP_LED_On(LED3);
HAL_Delay(100);
BSP_LED_Off(LED3);
HAL_Delay(100);
BSP_LED_On(LED3);
HAL_Delay(100);
BSP_LED_Off(LED3);
HAL_Delay(500);
}
/* Reset transmission flag */
UartReady = RESET;
BSP_LED_Off(LED3);
/*##-4- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
Error_Handler();
}
#endif /* TRANSMITTER_BOARD */
/*##-5- Wait for the end of the transfer ###################################*/
while (UartReady != SET)
{
}
/* Reset transmission flag */
UartReady = RESET;
/*##-6- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
{
Error_Handler();
}
/* Turn on LED3 if test passes then enter infinite loop */
BSP_LED_On(LED3);
/* Infinite loop */
while (1)
{
}
}
