static BOOL Hal_FlipBUff(USER_UART_HandleTypeDef *pHandle)
{
uint8_t tmp;
tmp = WhichLowBuffer(pHandle);
if(tmp==ERR)
return FALSE;
//disable interrupt
__HAL_UART_DISABLE_IT(&(pHandle->UartHandle), UART_IT_RXNE);
//save low buff to upbuff
pHandle->UpBufferPtr = pBuffTable[tmp];
pHandle->UpBufferCount = pHandle->UartHandle.RxXferSize - pHandle->UartHandle.RxXferCount;
//change the uart state
if(pHandle->UartHandle.State==HAL_UART_STATE_BUSY_TX_RX)
pHandle->UartHandle.State = HAL_UART_STATE_BUSY_TX;
else
pHandle->UartHandle.State = HAL_UART_STATE_READY;
//flip buffer
if(tmp==0)
HAL_UART_Receive_IT(&(pHandle->UartHandle), (uint8_t *)pBuffTable[1], HAL_BUFFER_SIZE);
else
HAL_UART_Receive_IT(&(pHandle->UartHandle), (uint8_t *)pBuffTable[0], HAL_BUFFER_SIZE);
__HAL_UART_ENABLE_IT(&(pHandle->UartHandle), UART_IT_RXNE);
return TRUE;
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(Rx_Data[0] != 59) // 받은 문자가 ';'이 아니면
{
if(Buffer_idx >= MAX_BUFFER_SIZE) // 수신버퍼의 사이즈가 5가 넘으면
{
Buffer_idx = 0; // 버퍼인덱스도 0부터 시작
for(int i = 0; i<MAX_BUFFER_SIZE; i++)
Rx_Buffer[i] = '\0';
}
Rx_Buffer[Buffer_idx] = Rx_Data[0]; // 수신데이터를 버퍼에 처넣음
Buffer_idx++;
HAL_UART_Receive_IT(&huart1, (uint8_t *)Rx_Data, 1); // 다시 받을 준비
}
else // ';'을 받으면
{
char temp[50];
sprintf(temp, "Rx_Data : %c\tBuffer : %s\tBuffer_Idx : %d\n", Rx_Data[0], Rx_Buffer, Buffer_idx);
Buffer_idx = 0; // 버퍼 초기화
for(int i = 0; i<MAX_BUFFER_SIZE; i++)
Rx_Buffer[i] = '\0'; // 버퍼 초기화
HAL_UART_Transmit_IT(&huart1, (uint8_t *)temp, 50);
}
}
/**
* @brief UART error callbacks
* @param huart: UART handle
* @note This example shows a simple way to report transfer error, and you can
* add your own implementation.
* @retval None
*/
void HAL_UART_GPS_ErrorCallback(UART_HandleTypeDef *huart)
{
HAL_UART_GPS_MspDeInit(&UartHandle_gps);
GpsUsartInit();
HAL_UART_GPS_MspInit(&UartHandle_gps);
HAL_UART_Receive_IT(&UartHandle_gps, (u8*)&recv_char_gps, 1);
}
void BSP_UART_Init(void) {
GPIO_InitTypeDef GPIO_InitStruct;
__GPIOD_CLK_ENABLE()
;
__HAL_RCC_USART3_CLK_ENABLE()
;
GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_8;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
UART3_Handle.Instance = USART3;
UART3_Handle.Init.BaudRate = 115200;
UART3_Handle.Init.WordLength = UART_WORDLENGTH_8B;
UART3_Handle.Init.StopBits = UART_STOPBITS_1;
UART3_Handle.Init.Parity = UART_PARITY_NONE;
UART3_Handle.Init.Mode = UART_MODE_TX_RX;
UART3_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UART3_Handle.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&UART3_Handle);
HAL_NVIC_SetPriority(USART3_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(USART3_IRQn);
HAL_UART_Receive_IT(&UART3_Handle, &dato, 1);
}
/**
* @brief UART error callbacks
* @param huart: UART handle
* @note This example shows a simple way to report transfer error, and you can
* add your own implementation.
* @retval None
*/
void HAL_UART_CP15_ErrorCallback(UART_HandleTypeDef *huart)
{
HAL_UART_CP15_MspDeInit(&UartHandle_cp15);
CP15UsartInit();
HAL_UART_CP15_MspInit(&UartHandle_cp15);
HAL_UART_Receive_IT(&UartHandle_cp15, (u8*)&recv_char_cp15, 1);
}
int main(void)
{
// 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_UART4_Init();
// Initializes the Global MSP .
HAL_MspInit();
HAL_UART_MspInit( &huart4 );
__HAL_UART_ENABLE_IT( &huart4, UART_IT_RXNE);
HAL_UART_Receive_IT( &huart4 , string , 154 );
while (1)
{
HAL_GPIO_WritePin( GPIOD , GPIO_PIN_15 , GPIO_PIN_SET );
delay(5000000);
HAL_GPIO_WritePin( GPIOD , GPIO_PIN_15 , GPIO_PIN_RESET );
delay(5000000);
}
}
/* USART1 init function */
void MX_USART1_UART_Init(void)
{
huart1.Instance = USART1;
huart1.Init.BaudRate = 9600;
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;
if(HAL_UART_Init(&huart1) != HAL_OK){
printf("Uart Init Error!\r\n");
while(1);
}
NVIC_SetPriority(USART1_IRQn,0);
NVIC_EnableIRQ(USART1_IRQn);
uart_rev.front = aRxBuffer;
uart_rev.rear = aRxBuffer;
//assign space to receive input
if(HAL_UART_Receive_IT(&huart1,(uint8_t*)aRxBuffer,1) != HAL_OK){
printf("Uart Read Error!\r\n");
}
}
// TODO: Packet RX timeout, buffer full check?
void uartRxCompleteCallback(Client* c)
{
static uint8_t packetCount = 0;
static uint8_t rxState = RX_PACKET_IDLE;
c->rxBuffer[packetCount++] = c->rxByte;
switch (rxState)
{
case RX_PACKET_IDLE:
rxState = RX_PACKET_GOTLENGTH;
break;
case RX_PACKET_GOTLENGTH:
rxState = RX_PACKET_GOTCOMMAND;
break;
case RX_PACKET_GOTCOMMAND:
; // has to be here, otherwise 'deceleration after label' error
uint8_t packetLength = c->rxBuffer[0];
if (packetCount == packetLength + 1) // Got rest of packet
{
packetCount = 0;
// Integrity checking
uint32_t crcRx = c->rxBuffer[packetLength - 3] | (c->rxBuffer[packetLength - 2] << 8)
| (c->rxBuffer[packetLength - 1] << 16) | (c->rxBuffer[packetLength] << 24);
uint32_t crcCode = HAL_CRC_Calculate(c->peripheral_CRC, (uint32_t*)(c->rxBuffer), packetLength - 3);
crcCode ^= 0xffffffff;
if (crcRx == crcCode) // validate packet
{
rxHandlePacket(c, c->rxBuffer);
}
rxState = RX_PACKET_IDLE;
}
break;
}
HAL_UART_Receive_IT(c->peripheral_UART, &c->rxByte, 1);
}
/**
* 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)
{
// TODO: DMA usage is currently ignored
(void) hint;
/* Sanity check arguments */
MBED_ASSERT(obj);
MBED_ASSERT(rx != (void*)0);
MBED_ASSERT(rx_width == 8); // support only 8b width
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
serial_enable_event(obj, SERIAL_EVENT_RX_ALL, 0);
serial_enable_event(obj, event, 1);
// set CharMatch
obj->char_match = char_match;
serial_rx_buffer_set(obj, rx, rx_length, rx_width);
IRQn_Type irq_n = serial_get_irq_n(obj);
NVIC_ClearPendingIRQ(irq_n);
NVIC_DisableIRQ(irq_n);
NVIC_SetPriority(irq_n, 0);
NVIC_SetVector(irq_n, (uint32_t)handler);
NVIC_EnableIRQ(irq_n);
// following HAL function will enable the RXNE interrupt + error interrupts
HAL_UART_Receive_IT(huart, (uint8_t*)rx, rx_length);
}
uint8_t HardwareSerial::read(void) {
if ( rx_buffer_bytes_available < 1 ) return -1;
HAL_NVIC_DisableIRQ(USART6_IRQn);
int next_index = this->rx_buffer_index - this->rx_buffer_bytes_available;
if ( next_index < 0 ) {
next_index += UART_RX_BUFFER_SIZE;
}
this->rx_buffer_bytes_available--;
/* If receive buffer was full, and has been emptied, begin receiving more data now. */
HAL_StatusTypeDef status;
if ( Serial6.rx_buffer_bytes_available == (UART_RX_BUFFER_SIZE-1) ) {
status = HAL_UART_Receive_IT(&huart6, &Serial6.rx_buffer[Serial6.rx_buffer_index], 1);
if ( HAL_OK == status ) {
full_buffer = false;
} else {
failed_posted_read = false;
}
}
HAL_NVIC_EnableIRQ(USART6_IRQn);
return this->rx_buffer[next_index];
}
/** @brief: config uartDebug. here it uses uartPort3
****************************************************************/
void UartDebugConfig0(void) {
UART_HandleTypeDef * huart = calloc(1, sizeof(UART_HandleTypeDef));
REQUIRE(huart != 0);
huartDebugPort = huart;//huartDebugPort must be defined as early as possible bf enable interrupt
rxDebugDataRingBuffer = RingBufferConstructor();
REQUIRE(rxDebugDataRingBuffer != 0);
RingBufferConfig(rxDebugDataRingBuffer, RX_BUFFER_SIZE, sizeof(int8_t));
txDebugDataRingBuffer = RingBufferConstructor();
REQUIRE(txDebugDataRingBuffer != 0);
RingBufferConfig(txDebugDataRingBuffer, TX_BUFFER_SIZE, sizeof(int8_t));
txDebugLengthRingBuffer = RingBufferConstructor();
REQUIRE(txDebugLengthRingBuffer != 0);
RingBufferConfig(txDebugLengthRingBuffer, TX_BUFFER_SIZE, sizeof(int8_t));
#if DEBUGUART_ID == 6
Uart6PortConfig(huart);
#elif DEBUGUART_ID == 1
Uart1PortConfig(huart);
#elif DEBUGUART_ID == 3
Uart3PortConfig(huart);
#elif DEBUGUART_ID == 2
Uart2PortConfig(huart);
#endif
huart->pRxBuffPtr = (uint8_t *) rxMsgBuffer;
huart->pTxBuffPtr = (uint8_t *) txMsgBuffer;
HAL_UART_Receive_IT(huart, (uint8_t *) (huart->pRxBuffPtr), 1);
}
/**
* @brief Rx Transfer completed callback
* @param None
* @retval None
*/
void rs232RxCpltCallback()
{
if (prvRxBuffer1State != BUFFERState_Reading && prvRxBuffer1Count < RX_BUFFER_SIZE)
{
prvRxBuffer1State = BUFFERState_Writing;
prvRxBuffer1[prvRxBuffer1CurrentIndex++] = prvReceivedByte;
prvRxBuffer1Count++;
/* Start the timer which will clear the buffer if it's not already started */
if (xTimerIsTimerActive(prvBuffer1ClearTimer) == pdFALSE)
xTimerStartFromISR(prvBuffer1ClearTimer, NULL);
}
else if (prvRxBuffer2State != BUFFERState_Reading && prvRxBuffer2Count < RX_BUFFER_SIZE)
{
prvRxBuffer2State = BUFFERState_Writing;
prvRxBuffer2[prvRxBuffer2CurrentIndex++] = prvReceivedByte;
prvRxBuffer2Count++;
/* Start the timer which will clear the buffer if it's not already started */
if (xTimerIsTimerActive(prvBuffer2ClearTimer) == pdFALSE)
xTimerStartFromISR(prvBuffer2ClearTimer, NULL);
}
else
{
/* No buffer available, something has gone wrong */
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_3);
}
/* Continue receiving data */
HAL_UART_Receive_IT(&UART_Handle, &prvReceivedByte, 1);
/* Give back the semaphore now that we are done */
xSemaphoreGiveFromISR(xSemaphore, NULL);
}
/**
* @brief CDC_Itf_Init
* Initializes the CDC media low layer
* @param None
* @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
*/
static int8_t CDC_Itf_Init(void)
{
#if 0
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* USART configured as follow:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = No parity
- BaudRate = 115200 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 115200;
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();
}
/*##-2- Put UART peripheral in IT reception process ########################*/
/* Any data received will be stored in "UserTxBuffer" buffer */
if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)UserTxBuffer, 1) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
/*##-3- Configure the TIM Base generation #################################*/
now done in HAL_MspInit
TIM_Config();
#endif
/*##-4- Start the TIM Base generation in interrupt mode ####################*/
/* Start Channel1 */
__HAL_TIM_ENABLE_IT(&TIM3_Handle, TIM_IT_UPDATE);
/*##-5- Set Application Buffers ############################################*/
USBD_CDC_SetTxBuffer(&hUSBDDevice, UserTxBuffer, 0);
USBD_CDC_SetRxBuffer(&hUSBDDevice, UserRxBuffer);
UserRxBufCur = 0;
UserRxBufLen = 0;
/* NOTE: we cannot reset these here, because USBD_CDC_SetInterrupt
* may be called before this init function to set these values.
* This can happen if the USB enumeration occurs after the call to
* USBD_CDC_SetInterrupt.
user_interrupt_char = VCP_CHAR_NONE;
user_interrupt_data = NULL;
*/
return (USBD_OK);
}
void HAL_UARTDebug_RxCpltCallback(UART_HandleTypeDef *huart) {
PushRingBuffer(rxDebugDataRingBuffer, (--(huart->pRxBuffPtr)));
//rearm
HAL_StatusTypeDef ret = HAL_UART_Receive_IT(huart, (uint8_t*) (huart->pRxBuffPtr), 1);
if(ret != HAL_OK){
rearmUartReceiveIT = 1;
}
}
/** @brief: call dma,gpio,uart config
* @details: after call Uart3PortConfig, all the hardware configuration should be set up properly
****************************************************************/
void Uart3PortConfig(UART_HandleTypeDef * huart) {
Uart3GPIOInit();
Uart3NVICInit(huart);
Uart3DMAInit(huart);
Uart3UARTInit(huart);
huart->Instance = USART3;
HAL_UART_Receive_IT(huart, (uint8_t *)(huart->pRxBuffPtr), 1);
}
void Uart2PortConfig(UART_HandleTypeDef* huart) {
huart->Instance = USART2;
Uart2GPIOInit();
Uart2NVICInit(huart);
Uart2DMAInit(huart);
Uart2UARTInit(huart);
HAL_UART_Receive_IT(huart, (uint8_t*) (huart->pRxBuffPtr), 1);
}
int8_t readUserInput(void) {
int8_t retVal = -1;
if(UartReady == SET) {
UartReady = RESET;
retVal = atoi(readBuf);
HAL_UART_Receive_IT(&huart2, (uint8_t*)readBuf, 1);
}
return retVal;
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *UartHandle)
{
HAL_StatusTypeDef status;
Serial6.tx_in_progress = false;
if ( Serial6.receive_request_pending ) {
status = HAL_UART_Receive_IT(&huart6, &Serial6.rx_buffer[Serial6.rx_buffer_index], 1);
if ( status == HAL_OK ) {
Serial6.receive_request_pending = false;
}
}
}
/**
* @brief CDC_Itf_Init
* Initializes the CDC media low layer
* @param None
* @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
*/
static int8_t CDC_Itf_Init(void)
{
#if 0
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* USART configured as follow:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = No parity
- BaudRate = 115200 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 115200;
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)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Put UART peripheral in IT reception process ########################*/
/* Any data received will be stored in "UserTxBuffer" buffer */
if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)UserTxBuffer, 1) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
#endif
/*##-3- Configure the TIM Base generation #################################*/
TIM_Config();
/*##-4- Start the TIM Base generation in interrupt mode ####################*/
/* Start Channel1 */
if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/*##-5- Set Application Buffers ############################################*/
USBD_CDC_SetTxBuffer(&USBD_Device, UserTxBuffer, 0);
USBD_CDC_SetRxBuffer(&USBD_Device, UserRxBuffer);
return (USBD_OK);
}
/*
wrote by fan to build 2 buffer for a uart receive
*/
void HAL_UART_Open(USER_UART_HandleTypeDef* UartHandle, uint8_t* buffer, uint16_t len)
{
buffer = buffer;
len = len;
pBuffTable[0] = HalBufferA;
pBuffTable[1] = HalBufferB;
UartHandle->UpBufferPtr = HalBufferB;
UartHandle->UpBufferCount = 0;
UartHandle->UartHandle.State = HAL_UART_STATE_READY;
HAL_UART_Receive_IT((UART_HandleTypeDef*) &(UartHandle->UartHandle), HalBufferA, HAL_BUFFER_SIZE);
}
void Uart::CallbackInteruption(void *UartHandle)
{
if( 0 == UartHandle)
{
return;
}
RecvCharBuuf[0] = caract[0];
//Retriger de l'IT
//Renvoi le caractere
Send((uint8_t*) RecvCharBuuf, 1,99);
HAL_UART_Receive_IT(&m_huart, caract, 1);
}
/**
* @brief Rx Transfer completed callback
* @param UartHandle: UART handle
* @note This example shows a simple way to report end of DMA Rx transfer, and
* you can add your own implementation.
* @retval None
*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
{
/* Set transmission flag: transfer complete */
uint8_t Count;
UartReady = SET;
for(Count=0;Count<RXBUFFERSIZE;Count++)
CommandToStart[Count]=aRxBuffer[Count];
memset(aRxBuffer,0,RXBUFFERSIZE);
if(HAL_UART_Receive_IT(UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief Rx Transfer completed callback
* @param huart: UART handle
* @retval None
*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
/* Increment Index for buffer writing */
UserTxBufPtrIn++;
/* To avoid buffer overflow */
if(UserTxBufPtrIn == APP_RX_DATA_SIZE)
{
UserTxBufPtrIn = 0;
}
/* Start another reception: provide the buffer pointer with offset and the buffer size */
HAL_UART_Receive_IT(huart, (uint8_t *)(UserTxBuffer + UserTxBufPtrIn), 1);
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
{
if(UartHandle == &application_uart_printf_handle){
application_uart_printf_ready = SET;
} else if(UartHandle == &application_ble_handle){
application_ble_ready = SET;
application_ble_received();
if(HAL_UART_Receive_IT(&application_ble_handle, (uint8_t *)&application_ble_charbuffer, 1) != HAL_OK)
{
Error_Handler();
}
}
}
/** 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)
{
// DMA usage is currently ignored
(void) 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);
UART_HandleTypeDef *handle = &UartHandle[SERIAL_OBJ(index)];
// flush current data + error flags
__HAL_UART_CLEAR_PEFLAG(handle);
#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
MBED_UART_Receive_DMA(handle, (uint8_t*)rx, rx_length);
#else
// following HAL function will enable the RXNE interrupt + error interrupts
HAL_UART_Receive_IT(handle, (uint8_t*)rx, rx_length);
#endif
/* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
__HAL_UART_ENABLE_IT(handle, UART_IT_ERR);
DEBUG_PRINTF("UART%u: Rx: 0=(%u, %u, %u) %x\n", obj->serial.module+1, rx_length, rx_width, char_match, HAL_UART_GetState(handle));
return;
}
void HardwareSerial::begin(uint32_t baud) {
HAL_StatusTypeDef status;
if ( huart6.Init.BaudRate != baud ) {
HAL_UART_DeInit(&huart6);
huart6.Init.BaudRate = baud;
HAL_UART_Init(&huart6);
}
this->tx_in_progress = false;
this->rx_buffer_bytes_available = 0;
this->rx_buffer_index = 0;
receive_request_pending = false;
status = HAL_UART_Receive_IT(&huart6, &this->rx_buffer[this->rx_buffer_index], 1);
}
uart::uart ( void)
{
huart.Instance = USARTx;
huart.Init.BaudRate = 115200;
huart.Init.WordLength = UART_WORDLENGTH_8B;
huart.Init.StopBits = UART_STOPBITS_1;
huart.Init.Parity = UART_PARITY_NONE;
huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart.Init.Mode = UART_MODE_TX_RX;
huart.Init.OverSampling = UART_OVERSAMPLING_16;
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 USART1 clock */
USARTx_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_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
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);
/*##-3- Configure the NVIC for UART ########################################*/
/* NVIC for USARTx */
HAL_NVIC_SetPriority(USARTx_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(USARTx_IRQn);
if( HAL_UART_Init( &huart) != HAL_OK)
asm("bkpt 0");
HAL_StatusTypeDef status;
status=HAL_UART_Receive_IT( &huart, (uint8_t *)0x01, 1); // dummy call to switch RX on
if( status != HAL_OK)
asm("bkpt 0");
}
/**
* @brief Enables the RS232 interface with the current settings
* @param None
* @retval None
*/
static void prvEnableRs232Interface()
{
/* Enable UART clock */
__UART4_CLK_ENABLE();
/* Configure priority and enable interrupt */
HAL_NVIC_SetPriority(UART4_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY, 0);
HAL_NVIC_EnableIRQ(UART4_IRQn);
/* Enable the UART */
HAL_UART_Init(&UART_Handle);
/* If we are in RX mode we should start receiving data */
if (UART_Handle.Init.Mode == UARTMode_RX || UART_Handle.Init.Mode == UARTMode_TX_RX)
HAL_UART_Receive_IT(&UART_Handle, &prvReceivedByte, 1);
}
/**
* Initialize communication with OBC and report boot counter and reset source
* @param boot_cnt
* @return always in ERROR_OK that means no error occurs
*/
adcs_error_status init_obc_communication(uint32_t boot_cnt) {
uint8_t rst_src = 0;
pkt_pool_INIT();
HAL_reset_source(&rst_src);
set_reset_source(rst_src);
// event_boot(rst_src, boot_cnt);
/* Initialize UART2 for OBC */
HAL_UART_Receive_IT(&huart2, adcs_data.obc_uart.uart_buf, UART_BUF_SIZE);
return error_propagation(ERROR_OK);
}
int main(void)
{
/* USER CODE BEGIN 1 */
char ADC_Tx_Data[70];
/* 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_ADC1_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
HAL_UART_Receive_IT(&huart1, (uint8_t *)Rx_Data, 1);
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&ADC_Value, 6);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
HAL_Delay(15);
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_4);
HAL_Delay(15);
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_0);
HAL_Delay(15);
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_1);
HAL_Delay(15);
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_2);
HAL_Delay(15);
sprintf(ADC_Tx_Data,"ADC1:%4d\tADC2:%4d\tADC3:%4d\tADC4:%4d\tADC5:%4d\tADC6:%4d\n\r", ADC_Value[0], ADC_Value[1], ADC_Value[2], ADC_Value[3], ADC_Value[4], ADC_Value[5]);
HAL_UART_Transmit_IT(&huart1, (uint8_t *)ADC_Tx_Data, 70);
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
