int_t fputc(int_t c, FILE *stream) { //Standard output? if(stream == stdout) { //Display current character lcdPutChar(c); //On success, the character written is returned return c; } //Standard error output? else if(stream == stderr) { //Wait for the transmitter to be ready while(UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull) != RESET); //Send character UART_SendData(UART0, c); //Wait for the transfer to complete while(UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull) != RESET); //On success, the character written is returned return c; } //Unknown output? else { //If a writing error occurs, EOF is returned return EOF; } }
int platform_s_uart_recv( unsigned id, s32 timeout ) { if( timeout == 0 ) { // Return data only if already available if( UART_GetFlagStatus( STR9_UART, UART_FLAG_RxFIFOEmpty ) != SET ) return UART_ReceiveData( STR9_UART ); else return -1; } while( UART_GetFlagStatus( STR9_UART, UART_FLAG_RxFIFOEmpty ) == SET ); return UART_ReceiveData( STR9_UART ); }
int platform_s_uart_recv( unsigned id, s32 timeout ) { UART_TypeDef* p_uart = ( UART_TypeDef* )uarts[ id ]; if( timeout == 0 ) { // Return data only if already available if( UART_GetFlagStatus( p_uart, UART_FLAG_RxFIFOEmpty ) != SET ) return UART_ReceiveData( p_uart ); else return -1; } while( UART_GetFlagStatus( p_uart, UART_FLAG_RxFIFOEmpty ) == SET ); return UART_ReceiveData( p_uart ); }
/******************************************************************************* * Function Name : SenderFunc * Description : Sender interrupt handler. * Input : None * Output : None * Return : None *******************************************************************************/ static void SenderFunc(void) { for (; (send_data_pos < send_data_length && (UART_GetFlagStatus (UART, UART_FLAG_TXFF) == RESET)); send_data_pos++) { UART_SendData(UART, SendBuffer[send_data_pos]); } }
void platform_uart_send( unsigned id, u8 data ) { id = id; // while( UART_GetFlagStatus( STR9_UART, UART_FLAG_TxFIFOFull ) == SET ); UART_SendData( STR9_UART, data ); while( UART_GetFlagStatus( STR9_UART, UART_FLAG_TxFIFOFull ) != RESET ); }
void platform_s_uart_send( unsigned id, u8 data ) { UART_TypeDef* p_uart = ( UART_TypeDef* )uarts[ id ]; // while( UART_GetFlagStatus( STR9_UART, UART_FLAG_TxFIFOFull ) == SET ); UART_SendData( p_uart, data ); while( UART_GetFlagStatus( p_uart, UART_FLAG_TxFIFOFull ) != RESET ); }
// ----------------------------------------------------------------------------- static void ReceiveUBloxData(void) { while (!UART_GetFlagStatus(UART0, UART_FLAG_RxFIFOEmpty)) { rx_buffer_head_ = (rx_buffer_head_ + 1) % UBLOX_RX_BUFFER_LENGTH; rx_buffer_[rx_buffer_head_] = UART_ReceiveData(UART0); } }
// ----------------------------------------------------------------------------- // This function sends the contents of buffer to the u-blox device. This // function blocks program execution until the entire buffer is sent. static void UBloxTxBuffer(const uint8_t * buffer, size_t length) { while (length--) { while(UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull)) continue; UART_SendData(UART0, *buffer++); } }
int main() { /*System clock configuration*/ SystemInit(); // *(volatile uint32_t *)(0x41001014) = 0x0060100; //clock setting 48MHz /* CLK OUT Set */ // PAD_AFConfig(PAD_PA,GPIO_Pin_2, PAD_AF2); // PAD Config - CLKOUT used 3nd Function /* UART0 and UART1 configuration*/ UART_StructInit(&UART_InitStructure); /* Configure UART0 */ UART_Init(UART0,&UART_InitStructure); /* Configure UART1 */ UART_Init(UART1,&UART_InitStructure); while(TxCounter < TxBufferSize) { /* Send one byte from UART0 to UART1 */ UART_SendData(UART0,TxBuffer[TxCounter++]); /* Loop until UART0 TX FIFO Register is empty */ while(UART_GetFlagStatus(UART0,UART_FLAG_TXFE) == RESET) { } /* Loop until the UART1 Receive FIFO Register is not empty */ while(UART_GetFlagStatus(UART1,UART_FLAG_RXFE) == SET) { } /* Store the received byte in RxBuffer */ RxBuffer[RxCounter++] = (UART_ReceiveData(UART1) & 0xFF); } /* Check the received data with the send ones */ TransferStatus = Buffercmp(TxBuffer, RxBuffer, TxBufferSize); /* TransferStatus = PASSED, if the data transmitted from USARTy and received by USARTz are the same */ /* TransferStatus = FAILED, if the data transmitted from USARTy and received by USARTz are different */ while(1) { } }
void UART0_IRQHandler(void) { u8 c; // if receive irq (FIFO is over trigger level) or receive timeout irq (FIFO is not empty for longer times) has occured if((UART_GetITStatus(UART0, UART_IT_Receive) != RESET) || (UART_GetITStatus(UART0, UART_IT_ReceiveTimeOut) != RESET) ) { UART_ClearITPendingBit(UART0, UART_IT_Receive); // clear receive interrupt flag UART_ClearITPendingBit(UART0, UART_IT_ReceiveTimeOut); // clear receive timeout interrupt flag // if debug UART is UART0 if (DebugUART == UART0) { // forward received data to the UART1 tx buffer while(UART_GetFlagStatus(UART0, UART_FLAG_RxFIFOEmpty) != SET) { // wait for space in the tx buffer of the UART1 while(UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) == SET) {}; // move the byte from the rx buffer of UART0 to the tx buffer of UART1 UART_SendData(UART1, UART_ReceiveData(UART0)); } } else // UART0 is not the DebugUART (normal operation) { // repeat until no byte is in the RxFIFO while (UART_GetFlagStatus(UART0, UART_FLAG_RxFIFOEmpty) != SET) { c = UART_ReceiveData(UART0); // get byte from rx fifo switch(UART0_Muxer) { case UART0_MKGPS: UBX_RxParser(c); // if connected to GPS forward byte to ubx parser MKProtocol_CollectSerialFrame(&UART0_rx_buffer, c); // ckeck for MK-Frames also break; case UART0_MK3MAG: // ignore any byte send from MK3MAG break; case UART0_UNDEF: default: // ignore the byte from unknown source break; } // eof switch(UART0_Muxer) } // eof while } // eof UART0 is not the DebugUART } // eof receive irq or receive timeout irq }
void UART1_send_byte(uint8_t byte) { UART_SendData(MDR_UART1,byte); time_out_byte = 0; /*while(!UART_GetFlagStatus (MDR_UART1,UART_FLAG_RXFF)) { if( time_out_byte>3) break; } UART_ReceiveData (MDR_UART1); */ while(UART_GetFlagStatus (MDR_UART1,UART_FLAG_BUSY) || !UART_GetFlagStatus (MDR_UART1,UART_FLAG_RXFF)) { // if(time_out_byte>3) // break; } UART_ReceiveData (MDR_UART1); UART_ClearITPendingBit(MDR_UART1,UART_IT_RX); }
int main() { /*System clock configuration*/ SystemInit(); /* UART0 and UART1 configuration*/ UART_StructInit(&UART_InitStructure); /* Configure UART0 */ UART_Init(UART0,&UART_InitStructure); /* Configure UART1 */ UART_Init(UART1,&UART_InitStructure); while(TxCounter < TxBufferSize) { /* Send one byte from UART0 to UART1 */ UART_SendData(UART0,TxBuffer[TxCounter++]); /* Loop until UART0 TX FIFO Register is empty */ while(UART_GetFlagStatus(UART0,UART_FLAG_TXFE) == RESET) { } /* Loop until the UART1 Receive FIFO Register is not empty */ while(UART_GetFlagStatus(UART1,UART_FLAG_RXFE) == SET) { } /* Store the received byte in RxBuffer */ RxBuffer[RxCounter++] = (UART_ReceiveData(UART1) & 0xFF); } /* Check the received data with the send ones */ TransferStatus = Buffercmp(TxBuffer, RxBuffer, TxBufferSize); /* TransferStatus = PASSED, if the data transmitted from USARTy and received by USARTz are the same */ /* TransferStatus = FAILED, if the data transmitted from USARTy and received by USARTz are different */ while(1) { } }
//================================================================================== void UART1_send_byte(uint8_t byte) { UART_SendData(MDR_UART1,byte); //time_out_byte=0; //while(!UART_GetFlagStatus (MDR_UART1,UART_FLAG_RXFF)) //while(UART_GetFlagStatus (MDR_UART1,UART_FLAG_BUSY) || !UART_GetFlagStatus (MDR_UART1,UART_FLAG_RXFF)) while(UART_GetFlagStatus (MDR_UART1,UART_FLAG_BUSY)) { } UART_ReceiveData (MDR_UART1); UART_ClearITPendingBit(MDR_UART1,UART_IT_RX); }
uint8_t UART1_receiv_data(void) { uint8_t rec_data=0; /* Check RXFF flag */ while (UART_GetFlagStatus (MDR_UART1, UART_FLAG_RXFF)!= SET) { __nop(); } rec_data = UART_ReceiveData (MDR_UART1); return rec_data; }
int platform_uart_recv( unsigned id, unsigned timer_id, int timeout ) { timer_data_type tmr_start, tmr_crt; int res; if( timeout == 0 ) { // Return data only if already available if( UART_GetFlagStatus(STR9_UART, UART_FLAG_RxFIFOEmpty) != SET ) return UART_ReceiveData( STR9_UART ); else return -1; } else if( timeout == PLATFORM_UART_INFINITE_TIMEOUT ) { // Wait for data while( UART_GetFlagStatus(STR9_UART, UART_FLAG_RxFIFOEmpty) == SET ); return UART_ReceiveData( STR9_UART ); } else { // Receive char with the specified timeout tmr_start = platform_timer_op( timer_id, PLATFORM_TIMER_OP_START,0 ); while( 1 ) { if( UART_GetFlagStatus(STR9_UART, UART_FLAG_RxFIFOEmpty) != SET ) { res = UART_ReceiveData( STR9_UART ); break; } else res = -1; tmr_crt = platform_timer_op( timer_id, PLATFORM_TIMER_OP_READ, 0 ); if( platform_timer_get_diff_us( timer_id, tmr_crt, tmr_start ) >= timeout ) break; } return res; } }
void INT_UART0_Handler(void) { uint32_t temp_1; if (UART_GetITStatusMasked(MDR_UART0, UART_IT_RX) == SET) { temp_1 = UART_ReceiveData(MDR_UART0); UART_ClearITPendingBit(MDR_UART0, UART_IT_RX); while (UART_GetFlagStatus (MDR_UART0, UART_FLAG_TXFE)!= SET) { } UART_SendData (MDR_UART0,temp_1); } }
int uartEcho() { uartPut("Echo keypress mode:"); do { if((UART_GetFlagStatus(UART0, UART_FLAG_RxFIFOEmpty) != SET)&&(RxCounter < RxBufferSize)) { RxBuffer[RxCounter] = UART0->DR; UART_SendData(UART0, RxBuffer[RxCounter++]); } }while((RxBuffer[RxCounter - 1] != '@')&&(RxBuffer[RxCounter - 1] != '\r')&&(RxCounter != RxBufferSize)); return 1; }
/******************************************************************************* * Function Name : ReceiverFunc * Description : Receiver interrupt handler. * Input : None * Output : None * Return : None *******************************************************************************/ static void ReceiverFunc(void) { uint16_t receive_data; /* Read data from UART */ for (receive_data_length = 0; ((UART_GetFlagStatus(UART, UART_FLAG_RXFE) == RESET) && (receive_data_length < BUFFER_LENGTH)); ) { receive_data = UART_ReceiveData(UART); if (UART_Flags(receive_data) == 0) { ReceiveBuffer[receive_data_length++] = UART_Data(receive_data); } } /* Initiate data portion sending via USB */ USB_CDC_SendData(ReceiveBuffer, receive_data_length); }
void UART1_IRQHandler(void) { uint32_t temp_1; //UARTx_HandlerWork(MDR_UART2); if (UART_GetITStatusMasked(MDR_UART1, UART_IT_RX) == SET) { temp_1 = MDR_UART1->DR; UART_ClearITPendingBit(MDR_UART1, UART_IT_RX); while (UART_GetFlagStatus (MDR_UART1, UART_FLAG_TXFE)!= SET) { } UART_SendData (MDR_UART1,0x44); } }
void TIMER1_IRQHandler(void) { uint32_t temp_2 = 0; if (TIMER_GetITStatus(MDR_TIMER1, TIMER_STATUS_CNT_ARR) == SET) { //TIMER_ClearITPendingBit(MDR_TIMER1, TIMER_STATUS_CNT_ARR); MDR_TIMER1->STATUS &= ~TIMER_STATUS_CNT_ARR; while (UART_GetFlagStatus (MDR_UART1, UART_FLAG_TXFE)!= SET) { } UART_SendData (MDR_UART1,0x35); } }
void UART0_Transmit(void) { u8 tmp_tx; IENABLE; if(DebugUART == UART0) return; // no data output if debug uart is rederected to UART0 // if something has to be send and the txd fifo is not full if((UART0_tx_buffer.Locked == TRUE) && (UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull) == RESET)) { tmp_tx = UART0_tx_buffer.pData[UART0_tx_buffer.Position++]; // read next byte from txd buffer UART_SendData(UART0, tmp_tx); // put character to txd fifo // if terminating character or end of txd buffer reached if((tmp_tx == '\r') || (UART0_tx_buffer.Position == UART0_tx_buffer.Size)) { Buffer_Clear(&UART0_tx_buffer); } } IDISABLE; }
/** * @brief Main program. * @param None * @retval None */ void main ( void ) { uint8_t DataByte = 0x00; static uint8_t ReciveByte = 0x00; /* Enables the HSI clock on PORTD */ RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTD, ENABLE); /* Fill PortInit structure*/ PortInit.PORT_PULL_UP = PORT_PULL_UP_OFF; PortInit.PORT_PULL_DOWN = PORT_PULL_DOWN_OFF; PortInit.PORT_PD_SHM = PORT_PD_SHM_OFF; PortInit.PORT_PD = PORT_PD_DRIVER; PortInit.PORT_GFEN = PORT_GFEN_OFF; PortInit.PORT_FUNC = PORT_FUNC_MAIN; PortInit.PORT_SPEED = PORT_SPEED_MAXFAST; PortInit.PORT_MODE = PORT_MODE_DIGITAL; /* Configure PORTD pins 13 (UART2_TX) as output */ PortInit.PORT_OE = PORT_OE_OUT; PortInit.PORT_Pin = PORT_Pin_13; PORT_Init(MDR_PORTD, &PortInit); /* Configure PORTD pins 14 (UART1_RX) as input */ PortInit.PORT_OE = PORT_OE_IN; PortInit.PORT_Pin = PORT_Pin_14; PORT_Init(MDR_PORTD, &PortInit); /* Select HSI/2 as CPU_CLK source*/ RST_CLK_CPU_PLLconfig(RST_CLK_CPU_PLLsrcHSIdiv2, 0); /* Enables the CPU_CLK clock on UART2 */ RST_CLK_PCLKcmd(RST_CLK_PCLK_UART2, ENABLE); /* Set the HCLK division factor = 1 for UART2*/ UART_BRGInit(MDR_UART2, UART_HCLKdiv1 ); /* Initialize UART_InitStructure */ UART_InitStructure.UART_BaudRate = 9600; UART_InitStructure.UART_WordLength = UART_WordLength8b; UART_InitStructure.UART_StopBits = UART_StopBits2; UART_InitStructure.UART_Parity = UART_Parity_Even; UART_InitStructure.UART_FIFOMode = UART_FIFO_OFF; UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_RXE | UART_HardwareFlowControl_TXE; /* Configure UART2 parameters*/ UART_Init(MDR_UART2, &UART_InitStructure); /* Enables UART2 peripheral */ UART_Cmd(MDR_UART2, ENABLE); while (1) { /* Check TXFE flag */ while (UART_GetFlagStatus(MDR_UART2, UART_FLAG_TXFE) != SET); /* Send Data from UART2 */ UART_SendData(MDR_UART2, DataByte); /* Check RXFF flag */ while (UART_GetFlagStatus(MDR_UART2, UART_FLAG_RXFF) != SET); /* Recive data*/ ReciveByte = UART_ReceiveData(MDR_UART2); /* Increment Data */ DataByte++; } }
int putchar(int c) { while(UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull) != RESET); UART_SendData(UART0, c); return c; }
void pc(const char c) { while (UART_GetFlagStatus(CONSOLE_UART, UART_FLAG_TxFIFOFull)!= RESET) {} UART_SendData(CONSOLE_UART, c); }
/** * @brief Main program. * @param None * @retval None */ int main (void) { uint8_t DataByte=0x01; static uint8_t ReciveByte[16]; uint32_t i; /* Enables the HSI clock on PORTB,PORTD */ RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTB,ENABLE); RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTD,ENABLE); /* Fill PortInit structure*/ PortInit.PORT_PULL_UP = PORT_PULL_UP_OFF; PortInit.PORT_PULL_DOWN = PORT_PULL_DOWN_OFF; PortInit.PORT_PD_SHM = PORT_PD_SHM_OFF; PortInit.PORT_PD = PORT_PD_DRIVER; PortInit.PORT_GFEN = PORT_GFEN_OFF; PortInit.PORT_FUNC = PORT_FUNC_ALTER; PortInit.PORT_SPEED = PORT_SPEED_MAXFAST; PortInit.PORT_MODE = PORT_MODE_DIGITAL; /* Configure PORTB pins 5 (UART1_TX) as output */ PortInit.PORT_OE = PORT_OE_OUT; PortInit.PORT_Pin = PORT_Pin_5; PORT_Init(MDR_PORTB, &PortInit); /* Configure PORTB pins 6 (UART1_RX) as input */ PortInit.PORT_OE = PORT_OE_IN; PortInit.PORT_Pin = PORT_Pin_6; PORT_Init(MDR_PORTB, &PortInit); /* Configure PORTD pins 1 (UART2_TX) as output */ PortInit.PORT_OE = PORT_OE_OUT; PortInit.PORT_Pin = PORT_Pin_1; PORT_Init(MDR_PORTD, &PortInit); /* Configure PORTD pins 0 (UART1_RX) as input */ PortInit.PORT_OE = PORT_OE_IN; PortInit.PORT_Pin = PORT_Pin_0; PORT_Init(MDR_PORTD, &PortInit); /* Select HSI/2 as CPU_CLK source*/ RST_CLK_CPU_PLLconfig (RST_CLK_CPU_PLLsrcHSIdiv2,0); /* Enables the CPU_CLK clock on UART1,UART2 */ RST_CLK_PCLKcmd(RST_CLK_PCLK_UART1, ENABLE); RST_CLK_PCLKcmd(RST_CLK_PCLK_UART2, ENABLE); /* Set the HCLK division factor = 1 for UART1,UART2*/ UART_BRGInit(MDR_UART1, UART_HCLKdiv1); UART_BRGInit(MDR_UART2, UART_HCLKdiv1); /* Initialize UART_InitStructure */ UART_InitStructure.UART_BaudRate = 115000; UART_InitStructure.UART_WordLength = UART_WordLength8b; UART_InitStructure.UART_StopBits = UART_StopBits1; UART_InitStructure.UART_Parity = UART_Parity_No; UART_InitStructure.UART_FIFOMode = UART_FIFO_ON; UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_RXE | UART_HardwareFlowControl_TXE; /* Configure UART1 parameters*/ UART_Init (MDR_UART1,&UART_InitStructure); /* Configure DMA for UART1*/ UART_DMAConfig (MDR_UART1, UART_IT_FIFO_LVL_12words, UART_IT_FIFO_LVL_12words); UART_DMACmd(MDR_UART1, UART_DMA_TXE | UART_DMA_RXE | UART_DMA_ONERR, ENABLE); /* Enables UART1 peripheral */ UART_Cmd(MDR_UART1,ENABLE); /* Configure UART2 parameters*/ UART_Init (MDR_UART2,&UART_InitStructure); /* Configure DMA for UART2*/ UART_DMAConfig (MDR_UART2, UART_IT_FIFO_LVL_12words, UART_IT_FIFO_LVL_12words); UART_DMACmd(MDR_UART2, UART_DMA_TXE | UART_DMA_RXE | UART_DMA_ONERR, ENABLE); /* Enables UART2 peripheral */ UART_Cmd(MDR_UART2,ENABLE); while (1) { /* Check TXFE flag */ while (UART_GetFlagStatus (MDR_UART1, UART_FLAG_TXFE)!= SET) { } /* Send Data from UART1 */ for (i=0;i<16;i++) { UART_SendData (MDR_UART1, (uint16_t)(i+16*DataByte)); } /* Check RXFF flag */ while (UART_GetFlagStatus (MDR_UART2, UART_FLAG_RXFF)!= SET) { } /* Recive data */ for (i=0;i<16;i++) { ReciveByte[i] = UART_ReceiveData (MDR_UART2); } /* Increment Data */ DataByte++; } }