/********************************************************************//** * @brief UART transmit function (ring buffer used) * @param[in] None * @return None *********************************************************************/ void UART1_IntTransmit(void) { // Disable THRE interrupt UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART_INTCFG_THRE, DISABLE); /* Wait for FIFO buffer empty, transfer UART_TX_FIFO_SIZE bytes * of data or break whenever ring buffers are empty */ /* Wait until THR empty */ while (UART_CheckBusy((LPC_UART_TypeDef *)LPC_UART1) == SET); while (!__BUF_IS_EMPTY(rb.tx_head,rb.tx_tail)) { /* Move a piece of data into the transmit FIFO */ if (UART_Send((LPC_UART_TypeDef *)LPC_UART1, (uint8_t *)&rb.tx[rb.tx_tail], \ 1, NONE_BLOCKING)){ /* Update transmit ring FIFO tail pointer */ __BUF_INCR(rb.tx_tail); } else { break; } } /* If there is no more data to send, disable the transmit interrupt - else enable it or keep it enabled */ if (__BUF_IS_EMPTY(rb.tx_head, rb.tx_tail)) { UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART_INTCFG_THRE, DISABLE); // Reset Tx Interrupt state TxIntStat = RESET; } else{ // Set Tx Interrupt state TxIntStat = SET; UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART_INTCFG_THRE, ENABLE); } }
void GPS_Stop(void) { //Disable GPS interrupt UART_IntConfig(UART_3, UART_INTCFG_RBR, DISABLE); UART_IntConfig(UART_3, UART_INTCFG_RLS, DISABLE); //Disable GPS wake-from-sleep NVIC_DisableIRQ(UART3_IRQn); //Turn off GPS via GPIO //GPS enable pin is p5[4] //GPIO_SetDir(5, 1<<4, GPIO_DIRECTION_OUTPUT); //LPC_GPIO5->CLR = 1<<4; GPS_Sleep(); //Set state to GPS off (redundant, but do it anyway) gpsActive = 0; gpsData.valid = 0; //Disable GPS UART TX //UART_TxCmd(UART_3, DISABLE); //Turn off GPS UART //CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART3, DISABLE); return; }
/*********************************************************************//** * @brief UART read function for interrupt mode (using ring buffers) * @param[in] UARTPort Selected UART peripheral used to send data, * should be UART0 * @param[out] rxbuf Pointer to Received buffer * @param[in] buflen Length of Received buffer * @return Number of bytes actually read from the ring buffer **********************************************************************/ uint32_t UARTReceive(LPC_UART_TypeDef *UARTPort, uint8_t *rxbuf, uint8_t buflen) { uint8_t *data = (uint8_t *) rxbuf; uint32_t bytes = 0; /* Temporarily lock out UART receive interrupts during this read so the UART receive interrupt won't cause problems with the index values */ UART_IntConfig(UARTPort, UART_INTCFG_RBR, DISABLE); /* Loop until receive buffer ring is empty or until max_bytes expires */ while ((buflen > 0) && (!(__BUF_IS_EMPTY(rb.rx_head, rb.rx_tail)))) { /* Read data from ring buffer into user buffer */ *data = rb.rx[rb.rx_tail]; data++; /* Update tail pointer */ __BUF_INCR(rb.rx_tail); /* Increment data count and decrement buffer size count */ bytes++; buflen--; } /* Re-enable UART interrupts */ UART_IntConfig(UARTPort, UART_INTCFG_RBR, ENABLE); return bytes; }
void USART_Init(void) { UART_CFG_Type UARTConfigStruct; UART_FIFO_CFG_Type UARTFIFOConfigStruct; PINSEL_ConfigPin(0,2,1); PINSEL_ConfigPin(0,3,1); UART_ConfigStructInit(&UARTConfigStruct); UART_Init(USART_ID, &UARTConfigStruct); UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); #if USART_FIFO_LEVEL == 1 UARTFIFOConfigStruct.FIFO_Level = UART_FIFO_TRGLEV0; #elif USART_FIFO_LEVEL == 4 UARTFIFOConfigStruct.FIFO_Level = UART_FIFO_TRGLEV1; #elif USART_FIFO_LEVEL == 8 UARTFIFOConfigStruct.FIFO_Level = UART_FIFO_TRGLEV2; #elif USART_FIFO_LEVEL == 14 UARTFIFOConfigStruct.FIFO_Level = UART_FIFO_TRGLEV3; #endif UART_FIFOConfig(USART_ID, &UARTFIFOConfigStruct); UART_TxCmd(USART_ID, ENABLE); UART_IntConfig(USART_ID, UART_INTCFG_RBR, ENABLE); UART_IntConfig(USART_ID, UART_INTCFG_RLS, ENABLE); UART_IntConfig(USART_ID, UART_INTCFG_THRE, ENABLE); NVIC_SetPriority(USART_IRQ, ((0x01<<3)|0x01)); NVIC_EnableIRQ(USART_IRQ); }
/* *@描述:初始化串口 *@参数:void *@返回:无 */ void InitUart(void) { // UART Configuration structure variable UART_CFG_Type UARTConfigStruct; // UART FIFO configuration Struct variable UART_FIFO_CFG_Type UARTFIFOConfigStruct; // Pin configuration for UART0 PINSEL_CFG_Type PinCfg; /* * Initialize UART pin connect */ PinCfg.OpenDrain = UARTOpendrain; PinCfg.Pinmode = UARTPinMode; PinCfg.Portnum = UARTPortTX; PinCfg.Pinnum = UARTPinTX; PinCfg.Funcnum = UARTFuncTX; PINSEL_ConfigPin(&PinCfg); PinCfg.Portnum = UARTPortRX; PinCfg.Pinnum = UARTPinRX; PinCfg.Funcnum = UARTFuncRX; PINSEL_ConfigPin(&PinCfg); /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); // Re-configure baudrate to 57600bps UARTConfigStruct.Baud_rate = 57600; // Initialize UART peripheral with given to corresponding parameter UART_Init((LPC_UART_TypeDef *)_LPC_UART, &UARTConfigStruct); /* Initialize FIFOConfigStruct to default state: * - FIFO_DMAMode = DISABLE * - FIFO_Level = UART_FIFO_TRGLEV0 * - FIFO_ResetRxBuf = ENABLE * - FIFO_ResetTxBuf = ENABLE * - FIFO_State = ENABLE */ UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); UARTFIFOConfigStruct.FIFO_Level = UART_FIFO_TRGLEV3;//8 character // Initialize FIFO for UART0 peripheral UART_FIFOConfig((LPC_UART_TypeDef *)_LPC_UART, &UARTFIFOConfigStruct); // Enable UART Transmit UART_TxCmd((LPC_UART_TypeDef *)_LPC_UART, ENABLE); /* Enable UART Rx interrupt */ UART_IntConfig((LPC_UART_TypeDef *)_LPC_UART, UART_INTCFG_RBR, ENABLE); /* Enable UART line status interrupt */ UART_IntConfig((LPC_UART_TypeDef *)_LPC_UART, UART_INTCFG_RLS, DISABLE); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(_UART_IRQ, ((0x01<<3)|0x01)); /* Enable Interrupt for UART channel */ NVIC_EnableIRQ(_UART_IRQ); BufInit(&bufSerialRec); }
void configureInterrupts() { UART_IntConfig(UART1_DEVICE, UART_INTCFG_RBR, ENABLE); UART_IntConfig(UART1_DEVICE, UART_INTCFG_RLS, ENABLE); enableTransmitInterrupt(); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(UART1_IRQn, ((0x01<<3)|0x01)); NVIC_EnableIRQ(UART1_IRQn); }
/*********************************************************************//** * @brief Client Hardware Initialize * @param[in] None * @return None ***********************************************************************/ void ClientHardwareInit(void) { // UART Configuration structure variable UART_CFG_Type uart_config; // UART FIFO Configuration Struct variable UART_FIFO_CFG_Type uart_fifo; // Pin configuration for UART0 PINSEL_CFG_Type pin; // Initialize UART0 pin connect pin.Funcnum = PINSEL_FUNC_1; pin.OpenDrain = PINSEL_PINMODE_OPENDRAIN; pin.Pinmode = PINSEL_PINMODE_PULLUP; pin.Pinnum = PINSEL_PIN_2; pin.Portnum = PINSEL_PORT_0; PINSEL_ConfigPin(&pin); pin.Pinnum = PINSEL_PIN_3; PINSEL_ConfigPin(&pin); // Initialize UART Configration parameter structure to default state: // Baudrate = 9600bps // 8 data bit // 1 stop bit // None parity UART_ConfigStructInit(&uart_config); // Set baudrate to 115200 */ uart_config.Baud_rate = 115200; // Initialize UART0 peripheral with give to corresponding parameter */ UART_Init((LPC_UART_TypeDef *)LPC_UART0, &uart_config); // Initialize FIFOConfigStruct to default state: // - FIFO_DMAMode = DISABLE // - FIFO_Level = UART_FIFO_TRGLEV0 // - FIFO_ResetRxBuf = ENABLE // - FIFO_ResetTxBuf = ENABLE // - FIFO_State = ENABLE UART_FIFOConfigStructInit(&uart_fifo); // Initialize FIFO for UART0 peripheral UART_FIFOConfig((LPC_UART_TypeDef *)LPC_UART0, &uart_fifo); // Enable UART Transmit UART_TxCmd((LPC_UART_TypeDef *)LPC_UART0, ENABLE); // Enable UART Rx interrupt UART_IntConfig((LPC_UART_TypeDef *)LPC_UART0, UART_INTCFG_RBR, ENABLE); // Enable UART line status interrupt UART_IntConfig((LPC_UART_TypeDef *)LPC_UART0, UART_INTCFG_RLS, ENABLE); // preemption = 1, sub-priority = 1 NVIC_SetPriority(UART0_IRQn, ((0x01 << 3) | 0x01)); // Enable Interrupt for UART0 channel NVIC_EnableIRQ(UART0_IRQn); }
void xl_UART_Config(unsigned char port) { UART_CFG_Type UARTConfigStruct; UART_FIFO_CFG_Type UARTFIFOConfigStruct; UART_ConfigStructInit(&UARTConfigStruct); UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); switch(port) { case 0: PINSEL_ConfigPin(0,2,1); PINSEL_ConfigPin(0,3,1); UARTConfigStruct.Baud_rate = 115200; UART_Init( (UART_ID_Type)port, &UARTConfigStruct ); UART_FIFOConfig( (UART_ID_Type)port, &UARTFIFOConfigStruct ); UART_TxCmd( (UART_ID_Type)port, ENABLE ); UART_IntConfig(UART_0, UART_INTCFG_RBR, ENABLE); UART_IntConfig(UART_0, UART_INTCFG_RLS, ENABLE); NVIC_SetPriority(UART0_IRQn, ((0x02<<3)|0x02)); NVIC_EnableIRQ(UART0_IRQn); break; case 2: PINSEL_ConfigPin(0,10,1); PINSEL_ConfigPin(0,11,1); /** */ PINSEL_ConfigPin(1, 19, 6); UARTConfigStruct.Baud_rate = 9600; UART_Init( (UART_ID_Type)port, &UARTConfigStruct ); LPC_UART2->RS485CTRL = 0x31; LPC_UART2->RS485DLY = 0x10; UART_FIFOConfig( (UART_ID_Type)port, &UARTFIFOConfigStruct ); UART_TxCmd( (UART_ID_Type)port, ENABLE ); UART_IntConfig(UART_2, UART_INTCFG_RBR, ENABLE); UART_IntConfig(UART_2, UART_INTCFG_RLS, ENABLE); // NVIC_SetPriority(UART2_IRQn, ((0x02<<3)|0x03)); NVIC_DisableIRQ(UART2_IRQn); break; default: break; } }
/* Auto flow control does work, but it turns the serial write functions into * blocking functions, which drags USB down. Instead we handle it manually so we * can make them asynchronous and let USB run at full speed. */ void configureFlowControl() { if (UART_FullModemGetStatus(LPC_UART1) & UART1_MODEM_STAT_CTS) { // Enable UART Transmit UART_TxCmd(UART1_DEVICE, ENABLE); } // Enable Modem status interrupt UART_IntConfig(UART1_DEVICE, UART1_INTCFG_MS, ENABLE); // Enable CTS1 signal transition interrupt UART_IntConfig(UART1_DEVICE, UART1_INTCFG_CTS, ENABLE); resumeReceive(); }
void serial_init(uint32_t baud_rate) { UART_CFG_Type UART_config; UART_FIFO_CFG_Type UART_fifo_config; PINSEL_CFG_Type pin_config; // Configure TXD and RXD Pins pin_config.OpenDrain = PINSEL_PINMODE_NORMAL; pin_config.Pinmode = PINSEL_PINMODE_PULLUP; pin_config.Funcnum = UART_TXD_FUNC; pin_config.Portnum = UART_TXD_PORT; pin_config.Pinnum = UART_TXD_PIN; PINSEL_ConfigPin(&pin_config); pin_config.Funcnum = UART_RXD_FUNC; pin_config.Portnum = UART_RXD_PORT; pin_config.Pinnum = UART_RXD_PIN; PINSEL_ConfigPin(&pin_config); #pragma message "BT TXD on Pin : P" STRING(UART_TXD_PORT) "_" STRING(UART_TXD_PIN) #pragma message "BT RXD on Pin : P" STRING(UART_RXD_PORT) "_" STRING(UART_RXD_PIN) // Configure UART UART_config.Baud_rate = baud_rate; UART_config.Databits = UART_DATABIT_8; UART_config.Parity = UART_PARITY_NONE; UART_config.Stopbits = UART_STOPBIT_1; UART_Init((LPC_UART_TypeDef *)UART_PORT, &UART_config); // Configure FIFO UART_fifo_config.FIFO_DMAMode = DISABLE; UART_fifo_config.FIFO_Level = UART_FIFO_TRGLEV0; UART_fifo_config.FIFO_ResetRxBuf = ENABLE; UART_fifo_config.FIFO_ResetTxBuf = ENABLE; UART_FIFOConfig((LPC_UART_TypeDef *)UART_PORT, &UART_fifo_config); // Enable UART Transmit UART_TxCmd((LPC_UART_TypeDef *)UART_PORT, ENABLE); // Enable UART interrupts UART_IntConfig((LPC_UART_TypeDef *)UART_PORT, UART_INTCFG_RLS, ENABLE); UART_IntConfig((LPC_UART_TypeDef *)UART_PORT, UART_INTCFG_RBR, ENABLE); UART_IntConfig((LPC_UART_TypeDef *)UART_PORT, UART_INTCFG_THRE, ENABLE); // preemption = 1, sub-priority = 1 NVIC_SetPriority(UARTx_IRQn, ((0x01 << 3) | 0x01)); // Enable Interrupt for UART NVIC_EnableIRQ(UARTx_IRQn); }
void uart3_init(const uint32_t BaudRate, const bool DoubleSpeed) { UART_CFG_Type UARTConfigStruct; PINSEL_CFG_Type PinCfg; PinCfg.Portnum = UART3_PORTNUM; PinCfg.Pinnum = UART3_RX_PINNUM; PinCfg.Funcnum = UART3_FUNCNUM; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PINSEL_ConfigPin(&PinCfg); // leave TX3 untouched, we are currently using TX3 as i/o! //PinCfg.Pinnum = UART3_TX_PINNUM; //PINSEL_ConfigPin(&PinCfg); /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); // Re-configure baudrate UARTConfigStruct.Baud_rate = BaudRate; // Initialize DEBUG_UART_PORT peripheral with given to corresponding parameter UART_Init((LPC_UART_TypeDef *)FPGA_UART3_PORT, &UARTConfigStruct); // Enable UART Transmit //UART_TxCmd((LPC_UART_TypeDef *)FPGA_UART3_PORT, ENABLE); UART_IntConfig((LPC_UART_TypeDef *)FPGA_UART3_PORT, UART_INTCFG_RBR, ENABLE); NVIC_EnableIRQ(UART3_IRQn); }
void initSystemBasics(void) { uint8_t success[]="Smart Outlet Project\r\n"; uint8_t error[]="Smart Outlet Project\r\n"; UART_CFG_Type UART_ConfigStruct; UART_ConfigStruct.Baud_rate = 115200; UART_ConfigStruct.Parity = UART_PARITY_NONE; UART_ConfigStruct.Databits = UART_DATABIT_8; UART_ConfigStruct.Stopbits = UART_STOPBIT_1; UART_Init(LPC_UART0, &UART_ConfigStruct); UART_IntConfig(LPC_UART0, UART_INTCFG_RBR, ENABLE); xQueueInput = xQueueCreate(SIZE_QUEUE, sizeof(uint8_t)); xQueueOutput = xQueueCreate(SIZE_QUEUE, sizeof(uint8_t)); #ifdef DEBUG_MODE if(xQueueInput == 0 && xQueueOutput == 0) { UART_Send(LPC_UART0, error, strlen(error), NONE_BLOCKING); } else { UART_Send(LPC_UART0, success, strlen(success), NONE_BLOCKING); } #endif GPIO_SetDir(RELAY_PORT_NUM, RELAY_BIT_VALUE, 1); GPIO_SetValue(RELAY_PORT_NUM, RELAY_BIT_VALUE); ADC_Init(LPC_ADC, 1000); // TODO - Check if 1000 means 1kHz. Should it be only "1" }
/********************************************************************************************************* ** Function name: uartInit ** Descriptions: 串口初始化,设置为8位数据位,1位停止位,无奇偶校验,波特率为115200 ** input parameters: 无 ** output parameters: 无 ** Returned value: 无 *********************************************************************************************************/ void UART0Init (void) { UART_CFG_Type UART_ConfigStruct_Test; UART_FIFO_CFG_Type FIFOCfg_Test; UART_INT_Type UARTIntCfg_Test; GPIO_PinselConfig(RXD0,1); GPIO_PinselConfig(TXD0,1); GPIO_PinselConfig(EN_485_0,0); WriteEN_485_0(0); UART_ConfigStruct_Test.Baud_rate = UART0_BPS; UART_ConfigStruct_Test.Databits = UART_DATABIT_8; UART_ConfigStruct_Test.Parity = UART_PARITY_NONE; UART_ConfigStruct_Test.Stopbits = UART_STOPBIT_1; UART_Init((LPC_UART_TypeDef *)LPC_UART0,(UART_CFG_Type *)&UART_ConfigStruct_Test); UART_TxCmd((LPC_UART_TypeDef *)LPC_UART0,ENABLE); FIFOCfg_Test.FIFO_DMAMode = DISABLE; FIFOCfg_Test.FIFO_Level = UART_FIFO_TRGLEV2; FIFOCfg_Test.FIFO_ResetRxBuf = ENABLE; FIFOCfg_Test.FIFO_ResetTxBuf = ENABLE; UART_FIFOConfig((LPC_UART_TypeDef *)LPC_UART0, (UART_FIFO_CFG_Type *)&FIFOCfg_Test); UARTIntCfg_Test = UART_INTCFG_RBR; UART_IntConfig((LPC_UART_TypeDef *)LPC_UART0, UARTIntCfg_Test,ENABLE); InitFIFO((stcFIFO *)&sUART0RecFIFO,UART0RecBuf,sizeof(UART0RecBuf)); NVIC_EnableIRQ(UART0_IRQn); NVIC_SetPriority(UART0_IRQn, UART0_IRQn); }
void uart0_shutdown(void) { puts(""); UART_CFG_Type UARTConfigStruct; PINSEL_CFG_Type PinCfg; PinCfg.Portnum = UART0_PORTNUM; PinCfg.Pinnum = UART0_TX_PINNUM; PinCfg.Funcnum = 0; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = UART0_RX_PINNUM; PINSEL_ConfigPin(&PinCfg); GPIO_SetDir(UART0_PORTNUM, (1<<UART0_TX_PINNUM), 1); GPIO_SetValue(UART0_PORTNUM, (1<<UART0_TX_PINNUM)); UART_TxCmd((LPC_UART_TypeDef *)CONSOLE_UART_PORT, DISABLE); UART_IntConfig((LPC_UART_TypeDef *)CONSOLE_UART_PORT, UART_INTCFG_RBR, DISABLE); NVIC_DisableIRQ(UART0_IRQn); }
/*********************************************************************//** * @brief UART read function for interrupt mode (using ring buffers) * @param[in] UARTPort Selected UART peripheral used to send data, * should be UART1. * @param[out] rxbuf Pointer to Received buffer * @param[in] buflen Length of Received buffer * @return Number of bytes actually read from the ring buffer **********************************************************************/ uint32_t UARTReceive(LPC_UART_TypeDef *UARTPort, uint8_t *rxbuf, uint8_t buflen) { uint8_t *data = (uint8_t *) rxbuf; uint32_t bytes = 0; /* Temporarily lock out UART receive interrupts during this read so the UART receive interrupt won't cause problems with the index values */ UART_IntConfig(UARTPort, UART_INTCFG_RBR, DISABLE); /* Loop until receive buffer ring is empty or until max_bytes expires */ while ((buflen > 0) && (!(__BUF_IS_EMPTY(rb.rx_head, rb.rx_tail)))) { /* Read data from ring buffer into user buffer */ *data = rb.rx[rb.rx_tail]; data++; /* Update tail pointer */ __BUF_INCR(rb.rx_tail); /* Increment data count and decrement buffer size count */ bytes++; buflen--; #if (AUTO_RTS_CTS_USE == 0) /* In case of driving RTS manually, this pin should be * release into ACTIVE state if buffer is free */ if (RTS_State == INACTIVE) { if (!__BUF_WILL_FULL(rb.rx_head, rb.rx_tail)) { // Disable request to send through RTS line UART_FullModemForcePinState(LPC_UART1, UART1_MODEM_PIN_RTS, \ ACTIVE); RTS_State = ACTIVE; } } #endif } /* Re-enable UART interrupts */ UART_IntConfig(UARTPort, UART_INTCFG_RBR, ENABLE); return bytes; }
void sio_init(void) { //LPC_USART_3 PINSEL_CFG_Type PinSelCfg; UART_CFG_Type UartCFG_Struct; UART_FIFO_CFG_Type UART_FIFO_CFG_Struct; // P4_28 PinSelCfg.Portnum = PINSEL_PORT_4; PinSelCfg.Pinnum = PINSEL_PIN_28; PinSelCfg.Funcnum = PINSEL_FUNC_3; PinSelCfg.OpenDrain = PINSEL_PINMODE_NORMAL; PinSelCfg.Pinmode = PINSEL_PINMODE_PULLUP; PINSEL_ConfigPin(&PinSelCfg); // P4_29 PinSelCfg.Pinnum = PINSEL_PIN_29; PINSEL_ConfigPin(&PinSelCfg); uartDataToSend.currPtr = 0; uartDataToSend.lastPtr = 0; /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UartCFG_Struct); /* Set Baudrate to 115200 */ UartCFG_Struct.Baud_rate = 115200; /* Initialize UART3 peripheral with given to corresponding parameter */ UART_Init(SERIAL_USART, &UartCFG_Struct); /* Initialize FIFOConfigStruct to default state: * - FIFO_DMAMode = DISABLE * - FIFO_Level = UART_FIFO_TRGLEV0 * - FIFO_ResetRxBuf = ENABLE * - FIFO_ResetTxBuf = ENABLE * - FIFO_State = ENABLE */ UART_FIFOConfigStructInit(&UART_FIFO_CFG_Struct); /* Initialize FIFO for UART3 peripheral */ UART_FIFOConfig(SERIAL_USART, &UART_FIFO_CFG_Struct); /* Enable UART Transmit */ UART_TxCmd(SERIAL_USART, ENABLE); UART_IntConfig(SERIAL_USART, UART_INTCFG_THRE, ENABLE); NVIC_SetPriorityGrouping(UART3_PriorGrup); NVIC_SetPriority(UART3_IRQn, UART3_Prior); NVIC_EnableIRQ(UART3_IRQn); }
/*********************************************************************//** * @brief UART transmit function for interrupt mode (using ring buffers) * @param[in] UARTPort Selected UART peripheral used to send data, * should be UART0 * @param[out] txbuf Pointer to Transmit buffer * @param[in] buflen Length of Transmit buffer * @return Number of bytes actually sent to the ring buffer **********************************************************************/ static uint32_t UARTSend(LPC_UART_TypeDef *UARTPort, uint8_t txbuf[], uint8_t buflen) { uint8_t* data = &txbuf[0]; uint32_t bytes = 0; /* Temporarily lock out UART transmit interrupts during this read so the UART transmit interrupt won't cause problems with the index values */ UART_IntConfig(UARTPort, UART_INTCFG_THRE, DISABLE); /* Loop until transmit run buffer is full or until n_bytes expires */ while ((buflen > 0) && (!__BUF_IS_FULL(rb.tx_head, rb.tx_tail))) { /* Write data from buffer into ring buffer */ rb.tx[rb.tx_head] = *data; data++; /* Increment head pointer */ __BUF_INCR(rb.tx_head); /* Increment data count and decrement buffer size count */ bytes++; buflen--; } /* * Check if current Tx interrupt enable is reset, * that means the Tx interrupt must be re-enabled * due to call UART_IntTransmit() function to trigger * this interrupt type */ if (TxIntStat == RESET) { UART_IntTransmit(); } /* * Otherwise, re-enables Tx Interrupt */ else { UART_IntConfig(UARTPort, UART_INTCFG_THRE, ENABLE); } return bytes; }
/*********************************************************************//** * @brief UART0 interrupt handler sub-routine * @param None * @return None **********************************************************************/ void UART0_IRQHandler(void) { // Call Standard UART 0 interrupt handler uint32_t intsrc, tmp, tmp1; /* Determine the interrupt source */ intsrc = UART_GetIntId(LPC_UART0); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if (tmp == UART_IIR_INTID_RLS){ // Check line status tmp1 = UART_GetLineStatus(LPC_UART0); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { while(tmp1){ ; //implement error handling here } } } intsrc &= (UART_IIR_ABEO_INT | UART_IIR_ABTO_INT); // Check if End of auto-baudrate interrupt or Auto baudrate time out if (intsrc){ // Clear interrupt pending if(intsrc & UART_IIR_ABEO_INT) UART_ABClearIntPending(LPC_UART0, UART_AUTOBAUD_INTSTAT_ABEO); if (intsrc & UART_IIR_ABTO_INT) UART_ABClearIntPending(LPC_UART0, UART_AUTOBAUD_INTSTAT_ABTO); if (Synchronous == RESET) { /* Interrupt caused by End of auto-baud */ if (intsrc & UART_AUTOBAUD_INTSTAT_ABEO){ // Disable AB interrupt UART_IntConfig(LPC_UART0, UART_INTCFG_ABEO, DISABLE); // Set Sync flag Synchronous = SET; } /* Auto-Baudrate Time-Out interrupt (not implemented) */ if (intsrc & UART_AUTOBAUD_INTSTAT_ABTO) { /* Just clear this bit - Add your code here */ UART_ABClearIntPending(LPC_UART0, UART_AUTOBAUD_INTSTAT_ABTO); } } } }
/*----------------------------------------------------------------------------- * Transmit Call-back dispatch for UART driver *-----------------------------------------------------------------------------*/ void UartTxCallBack(void) { uint8_t tmpc; if (!__BUF_EMPTY(BufTx)) { tmpc = __BUF_RD(BufTx); UART_Send(UARTInfo.pUart, &tmpc, 1, BLOCKING); TxRestart = 0; } else { /* disable TX interrupt if nothing to send */ UART_IntConfig(UARTInfo.pUart, UART_INTCFG_THRE, DISABLE); TxRestart = 1; } }
static void uart3_init(rt_uint32_t baudrate) { PINSEL_CFG_Type PinSelCfgType; UART_CFG_Type UartCfgType; UART_FIFO_CFG_Type UartFIFOCfgType; //pin config //TXD PinSelCfgType.Portnum = PINSEL_PORT_0; PinSelCfgType.Pinnum = PINSEL_PIN_0; PinSelCfgType.Funcnum = PINSEL_FUNC_2; PinSelCfgType.Pinmode = PINSEL_PINMODE_PULLUP; PinSelCfgType.OpenDrain = PINSEL_PINMODE_NORMAL; PINSEL_ConfigPin(&PinSelCfgType); //RXD PinSelCfgType.Portnum = PINSEL_PORT_0; PinSelCfgType.Pinnum = PINSEL_PIN_1; PinSelCfgType.Funcnum = PINSEL_FUNC_2; PinSelCfgType.Pinmode = PINSEL_PINMODE_TRISTATE; PinSelCfgType.OpenDrain = PINSEL_PINMODE_NORMAL; PINSEL_ConfigPin(&PinSelCfgType); //init UartCfgType.Baud_rate = baudrate; UartCfgType.Parity = UART_PARITY_NONE; UartCfgType.Databits = UART_DATABIT_8; UartCfgType.Stopbits = UART_STOPBIT_1; UART_Init(LPC_DEV_UART, &UartCfgType); //FIFO UartFIFOCfgType.FIFO_ResetRxBuf = ENABLE; UartFIFOCfgType.FIFO_ResetTxBuf = ENABLE; UartFIFOCfgType.FIFO_DMAMode = DISABLE; UartFIFOCfgType.FIFO_Level = UART_FIFO_TRGLEV2; UART_FIFOConfig(LPC_DEV_UART, &UartFIFOCfgType); //int UART_IntConfig(LPC_DEV_UART, UART_INTCFG_RBR, ENABLE); //enable UART_TxCmd(LPC_DEV_UART, ENABLE); }
void SER_Init(uint32_t baudrate) { UART_CFG_Type UART_ConfigStruct; UART_FIFO_CFG_Type UART_FIFOInitStruct; UART_ConfigStruct.Baud_rate = baudrate; UART_ConfigStruct.Parity = UART_PARITY_NONE; UART_ConfigStruct.Stopbits = UART_STOPBIT_1; UART_ConfigStruct.Databits = UART_DATABIT_8; UART_Init(LPC_UART0, &UART_ConfigStruct); //Init UART0 with parameters, defined above UART_TxCmd(LPC_UART0, ENABLE); //Enable transmission on UART TxD pin UART_FIFOConfigStructInit(&UART_FIFOInitStruct); //Fills each UART_FIFOInitStruct member with its default value UART_FIFOConfig(LPC_UART0, &UART_FIFOInitStruct); //Configure FIFO function on UART0 peripheral UART_IntConfig(LPC_UART0,UART_INTCFG_RBR,ENABLE); //Enable UART0 RBR Interrupt NVIC_EnableIRQ(UART0_IRQn); //Enable UART0 Interrupts }
void vMBMasterPortClose(void) { /******************DISABLE the uart NVIC *******************/ NVIC_DisableIRQ(UART0_IRQn); NVIC_DisableIRQ(UART2_IRQn); NVIC_DisableIRQ(UART3_IRQn); NVIC_DisableIRQ(UART4_IRQn); /*****************DISABLE the uartrx exit********************/ UART_IntConfig(UART_0, UART_INTCFG_RBR, DISABLE); UART_IntConfig(UART_2, UART_INTCFG_RBR, DISABLE); UART_IntConfig(UART_3, UART_INTCFG_RBR, DISABLE); UART_IntConfig(UART_4, UART_INTCFG_RBR, DISABLE); /*******************Enable the uart line exit***************/ UART_IntConfig(UART_0, UART_INTCFG_RLS, DISABLE); UART_IntConfig(UART_2, UART_INTCFG_RLS, DISABLE); UART_IntConfig(UART_3, UART_INTCFG_RLS, DISABLE); UART_IntConfig(UART_4, UART_INTCFG_RLS, DISABLE); UART_RS485ReceiverCmd(UART_0,DISABLE); UART_RS485ReceiverCmd(UART_2,DISABLE); UART_RS485ReceiverCmd(UART_3,DISABLE); UART_RS485ReceiverCmd(UART_4,DISABLE); /*******************Uart DISABLE****************************/ UART_TxCmd(LPC_UART0,DISABLE); UART_TxCmd(LPC_UART2,DISABLE); UART_TxCmd(LPC_UART3,DISABLE); UART_TxCmd((LPC_UART_TypeDef *)LPC_UART4,DISABLE); // USART_ITConfig(USART2, USART_IT_TXE | USART_IT_RXNE, DISABLE); // USART_Cmd(USART2, DISABLE); }
/*---------------------------------------------------------------------------- Serial Device "LPC17xx" initialize *----------------------------------------------------------------------------*/ static int UartDev_Init (void) { int i; if (UARTInfo.State != _STATE_UNKNOWN_) { return (-1); /* Device initialized */ } ConfigureUart (&UART_DEV.Cfg); ConfigurePins (); /* Re-configure the UART pins */ __BUF_RESET(BufTx); /* reset transmit buffer */ __BUF_RESET(BufRx); /* reset receive buffer */ TxRestart = 1; UARTInfo.State = _STATE_INITIALIZED_; UART_TxCmd (UARTInfo.pUart, ENABLE); /* TX, RX enable */ for (i = 0; i < 800; i++); /* eleminate schmierzeichen */ /* Setting up callback function for UART driver */ // Receive callback UART_SetupCbs(UARTInfo.pUart, 0, (void *)UartRxCallBack); // Transmit callback UART_SetupCbs(UARTInfo.pUart, 1, (void *)UartTxCallBack); /* Enable Rx Interrrupt in UART peripheral */ UART_IntConfig(UARTInfo.pUart, UART_INTCFG_RBR, ENABLE); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(UARTInfo.UARTIRQn, ((0x01<<3)|0x01)); NVIC_EnableIRQ(UARTInfo.UARTIRQn); /* enable Interrupt */ return(0); /* success */ }
static void UART_FullModemConfig(void) { PINSEL_CFG_Type PinSelectConfigStruct; UART_CFG_Type UARTConfigStruct; UART_FIFO_CFG_Type UARTFIFOConfigStruct; //GSM_RXD_PIN PinSelectConfigStruct.Funcnum = PINSEL_FUNC_2; PinSelectConfigStruct.OpenDrain = PINSEL_PINMODE_NORMAL; PinSelectConfigStruct.Pinmode = PINSEL_PINMODE_PULLUP; PinSelectConfigStruct.Pinnum = gsmRxdPin; PinSelectConfigStruct.Portnum = GPIO2; PINSEL_ConfigPin(&PinSelectConfigStruct); //GSM_TXD_PIN PinSelectConfigStruct.Pinnum = gsmTxdPin; PINSEL_ConfigPin(&PinSelectConfigStruct); //GSM_CTS_PIN PinSelectConfigStruct.Pinnum = gsmCtsPin; PINSEL_ConfigPin(&PinSelectConfigStruct); //GSM_DCD_PIN PinSelectConfigStruct.Pinnum = gsmDcdPin; PINSEL_ConfigPin(&PinSelectConfigStruct); //GSM_DTR_PIN PinSelectConfigStruct.Pinnum = gsmDtrPin; PINSEL_ConfigPin(&PinSelectConfigStruct); //GSM_RI_PIN PinSelectConfigStruct.Pinnum = gsmRiPin; PINSEL_ConfigPin(&PinSelectConfigStruct); //GSM_RTS_PIN PinSelectConfigStruct.Pinnum = gsmRtsPin; PINSEL_ConfigPin(&PinSelectConfigStruct); /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); /* Set Baudrate */ UARTConfigStruct.Baud_rate = 9600; /* Initialize UART0 peripheral with given to corresponding parameter */ UART_Init(UARTx, &UARTConfigStruct); /* Initialize FIFOConfigStruct to default state: * - FIFO_DMAMode = DISABLE * - FIFO_Level = UART_FIFO_TRGLEV0 * - FIFO_ResetRxBuf = ENABLE * - FIFO_ResetTxBuf = ENABLE * - FIFO_State = ENABLE */ UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); /* Initialize FIFO for UART1 peripheral */ UART_FIFOConfig(UARTx, &UARTFIFOConfigStruct); UART_FullModemConfigMode(LPC_UART1, UART1_MODEM_MODE_AUTO_CTS, ENABLE); UART_FullModemConfigMode(LPC_UART1, UART1_MODEM_MODE_AUTO_RTS, ENABLE); //UART_FullModemForcePinState(LPC_UART1, UART1_MODEM_PIN_RTS, ACTIVE); /* Enable UART Transmit */ UART_TxCmd( UARTx, ENABLE); UART_IntConfig(UARTx, UART_INTCFG_RBR , ENABLE); //UART_IntConfig(UARTx, UART1_INTCFG_MS, ENABLE); UART_FullModemForcePinState(LPC_UART1, UART1_MODEM_PIN_DTR, ACTIVE); }
int comm_init(int which_port,int baudrate,FUNC_CB_COMM_RCV cb_rcv) { // UART Configuration structure variable UART_CFG_Type UARTConfigStruct; // UART FIFO configuration Struct variable UART_FIFO_CFG_Type UARTFIFOConfigStruct; #if 0 uint32_t idx, len; __IO FlagStatus exitflag; uint8_t buffer[10]; #endif #if 0 #if (UART_TEST_NUM == 0) /* * Initialize UART0 pin connect * P0.2: U0_TXD * P0.3: U0_RXD */ PINSEL_ConfigPin(0,2,1); PINSEL_ConfigPin(0,3,1); #elif (UART_TEST_NUM == 1) /* * Initialize UART1 pin connect * P3.16: U1_TXD * P3.17: U1_RXD */ PINSEL_ConfigPin(3,16,3); PINSEL_ConfigPin(3,17,3); #elif (UART_TEST_NUM == 2) /* * Initialize UART2 pin connect * P0.10: U2_TXD * P0.11: U2_RXD */ PINSEL_ConfigPin(0,10,1); PINSEL_ConfigPin(0,11,1); #endif #else if (which_port == 0){ /* * Initialize UART0 pin connect * P0.2: U0_TXD * P0.3: U0_RXD */ PINSEL_ConfigPin(0,2,1); PINSEL_ConfigPin(0,3,1); }else if(which_port == 1){ /* * Initialize UART1 pin connect * P3.16: U1_TXD * P3.17: U1_RXD */ PINSEL_ConfigPin(0, 15, 1); PINSEL_ConfigPin(0, 16, 1); }else if(which_port == 2){ /* * Initialize UART2 pin connect * P0.10: U2_TXD * P0.11: U2_RXD */ PINSEL_ConfigPin(0,10,1); PINSEL_ConfigPin(0,11,1); } #endif /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct,115200); // Initialize UART0 peripheral with given to corresponding parameter UART_Init((LPC_UART_TypeDef *)uartDrvDataArray[which_port].reg_base, &UARTConfigStruct); /* Initialize FIFOConfigStruct to default state: * - FIFO_DMAMode = DISABLE * - FIFO_Level = UART_FIFO_TRGLEV0 * - FIFO_ResetRxBuf = ENABLE * - FIFO_ResetTxBuf = ENABLE * - FIFO_State = ENABLE */ UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); // Initialize FIFO for UART0 peripheral UART_FIFOConfig((LPC_UART_TypeDef *)uartDrvDataArray[which_port].reg_base, &UARTFIFOConfigStruct); // Enable UART Transmit UART_TxCmd((LPC_UART_TypeDef *)uartDrvDataArray[which_port].reg_base, ENABLE); /* Enable UART Rx interrupt */ UART_IntConfig((LPC_UART_TypeDef *)uartDrvDataArray[which_port].reg_base, UART_INTCFG_RBR, ENABLE); /* Enable UART line status interrupt */ UART_IntConfig((LPC_UART_TypeDef *)uartDrvDataArray[which_port].reg_base, UART_INTCFG_RLS, ENABLE); /* * Do not enable transmit interrupt here, since it is handled by * UART_Send() function, just to reset Tx Interrupt state for the * first time */ // TxIntStat = RESET; #if 0 // Reset ring buf head and tail idx __BUF_RESET(rb.rx_head); __BUF_RESET(rb.rx_tail); __BUF_RESET(rb.tx_head); __BUF_RESET(rb.tx_tail); #endif /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(uartDrvDataArray[which_port].irqn, ((0x01<<3)|0x01)); /* Enable Interrupt for UART0 channel */ NVIC_EnableIRQ(uartDrvDataArray[which_port].irqn); if(cb_rcv){ uartDrvDataArray[which_port].cb_rcv=cb_rcv; } return 0; }
/*********************************************************************//** * @brief c_entry: Main UART-RS485 program body * @param[in] None * @return int **********************************************************************/ int c_entry(void) { // UART Configuration structure variable UART_CFG_Type UARTConfigStruct; // UART FIFO configuration Struct variable UART_FIFO_CFG_Type UARTFIFOConfigStruct; // Pin configuration PINSEL_CFG_Type PinCfg; // RS485 configuration UART1_RS485_CTRLCFG_Type rs485cfg; uint32_t idx, len; uint8_t buffer[10]; uint32_t tmp; // UART0 section ---------------------------------------------------- /* * Initialize UART0 pin connect */ PinCfg.Funcnum = 1; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PinCfg.Pinnum = 2; PinCfg.Portnum = 0; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 3; PINSEL_ConfigPin(&PinCfg); /* Initialize UART Configuration parameter structure to default state: * Baudrate = 115200 bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); UARTConfigStruct.Baud_rate = 115200; // Initialize UART0 peripheral with given to corresponding parameter UART_Init(LPC_UART0, &UARTConfigStruct); /* Initialize FIFOConfigStruct to default state: * - FIFO_DMAMode = DISABLE * - FIFO_Level = UART_FIFO_TRGLEV0 * - FIFO_ResetRxBuf = ENABLE * - FIFO_ResetTxBuf = ENABLE * - FIFO_State = ENABLE */ UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); // Initialize FIFO for UART0 peripheral UART_FIFOConfig(LPC_UART0, &UARTFIFOConfigStruct); // Enable UART Transmit UART_TxCmd(LPC_UART0, ENABLE); // print welcome screen print_menu(); // UART1 - RS485 section ------------------------------------------------- /* * Initialize UART1 pin connect */ PinCfg.Funcnum = 2; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; // TXD1 - P2.0 PinCfg.Pinnum = 0; PinCfg.Portnum = 2; PINSEL_ConfigPin(&PinCfg); // RXD1 - P2.1 PinCfg.Pinnum = 1; PINSEL_ConfigPin(&PinCfg); // DTR1 - P2.5 PinCfg.Pinnum = 5; PINSEL_ConfigPin(&PinCfg); /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600 bps * 8 data bit * 1 Stop bit * Parity: None * Note: Parity will be enabled later in UART_RS485Config() function. */ UART_ConfigStructInit(&UARTConfigStruct); // Initialize UART0 peripheral with given to corresponding parameter UART_Init((LPC_UART_TypeDef *)LPC_UART1, &UARTConfigStruct); /* Initialize FIFOConfigStruct to default state: * - FIFO_DMAMode = DISABLE * - FIFO_Level = UART_FIFO_TRGLEV0 * - FIFO_ResetRxBuf = ENABLE * - FIFO_ResetTxBuf = ENABLE * - FIFO_State = ENABLE */ UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); // Initialize FIFO for UART0 peripheral UART_FIFOConfig((LPC_UART_TypeDef *)LPC_UART1, &UARTFIFOConfigStruct); // Configure RS485 /* * - Auto Direction in Tx/Rx driving is enabled * - Direction control pin is set to DTR1 * - Direction control pole is set to "1" that means direction pin * will drive to high state before transmit data. * - Multidrop mode is enable * - Auto detect address is disabled * - Receive state is enable */ rs485cfg.AutoDirCtrl_State = ENABLE; rs485cfg.DirCtrlPin = UART1_RS485_DIRCTRL_DTR; rs485cfg.DirCtrlPol_Level = SET; rs485cfg.DelayValue = 50; rs485cfg.NormalMultiDropMode_State = ENABLE; #if AUTO_SLVADDR_DETECT rs485cfg.AutoAddrDetect_State = ENABLE; rs485cfg.MatchAddrValue = SLAVE_ADDR; #else rs485cfg.AutoAddrDetect_State = DISABLE; #endif #if RECEIVER_ALWAYS_EN rs485cfg.Rx_State = ENABLE; #else rs485cfg.Rx_State = DISABLE; #endif UART_RS485Config(LPC_UART1, &rs485cfg); /* Enable UART Rx interrupt */ UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART_INTCFG_RBR, ENABLE); /* Enable UART line status interrupt */ UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART_INTCFG_RLS, ENABLE); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(UART1_IRQn, ((0x01<<3)|0x01)); /* Enable Interrupt for UART0 channel */ NVIC_EnableIRQ(UART1_IRQn); // Enable UART Transmit UART_TxCmd((LPC_UART_TypeDef *)LPC_UART1, ENABLE); // for testing... while (1){ len = 0; while (len == 0) { len = UARTReceive((LPC_UART_TypeDef *)LPC_UART1, buffer, sizeof(buffer)); } /* Got some data */ idx = 0; while (idx < len) { if (buffer[idx] == 13){ for (tmp = 0; tmp < 1000000; tmp++); UART_RS485SendData(LPC_UART1, ack_msg, sizeof(ack_msg)); UART_Send(LPC_UART0, nextline, sizeof(nextline), BLOCKING); UART_RS485SendData(LPC_UART1, &terminator, 1); } else { /* Echo it back */ UART_Send(LPC_UART0, &buffer[idx], 1, BLOCKING); } idx++; } } return 1; }
// // //lecture - UART - uart specific ioctl commands are processed by this method - for instance, // for using hw interrupts or changing speed of operation // // // portBASE_TYPE FreeRTOS_UART_ioctl( Peripheral_Descriptor_t pxPeripheral, uint32_t ulRequest, void *pvValue ) { Peripheral_Control_t * const pxPeripheralControl = ( Peripheral_Control_t * const ) pxPeripheral; UART_CFG_Type xUARTConfig; uint32_t ulValue = ( uint32_t ) pvValue; const int8_t cPeripheralNumber = diGET_PERIPHERAL_NUMBER( ( ( Peripheral_Control_t * const ) pxPeripheral ) ); LPC_UART_TypeDef * pxUART = ( LPC_UART_TypeDef * ) diGET_PERIPHERAL_BASE_ADDRESS( ( ( Peripheral_Control_t * const ) pxPeripheral ) ); portBASE_TYPE xReturn = pdPASS; /* Sanity check the array index. */ configASSERT( cPeripheralNumber < ( int8_t ) ( sizeof( xIRQ ) / sizeof( IRQn_Type ) ) ); taskENTER_CRITICAL(); { switch( ulRequest ) { // // // //lecture - UART - for hw specific details, refer to chapter 14 // lpc17xx user-manual for UART3 specific settings // UART - Tx interrupts and Rx interrupts are enabled here // UART - we may introduce another set of IOCTL commands that will enable Tx and Rx // interrupts separately ?? // UART - some parts of ioctl commands' implementations are incomplete - ?? // // case ioctlUSE_INTERRUPTS : if( ulValue == pdFALSE ) { NVIC_DisableIRQ( xIRQ[ cPeripheralNumber ] ); } else { /* Enable the Rx and Tx interrupt. */ UART_IntConfig( pxUART, UART_INTCFG_RBR, ENABLE ); UART_IntConfig( pxUART, UART_INTCFG_THRE, ENABLE ); /* Enable the interrupt and set its priority to the minimum interrupt priority. A separate command can be issued to raise the priority if desired. */ NVIC_SetPriority( xIRQ[ cPeripheralNumber ], configMIN_LIBRARY_INTERRUPT_PRIORITY ); NVIC_EnableIRQ( xIRQ[ cPeripheralNumber ] ); /* If the Rx is configured to use interrupts, remember the transfer control structure that should be used. A reference to the Tx transfer control structure is taken when a write() operation is actually performed. */ pxRxTransferControlStructs[ cPeripheralNumber ] = pxPeripheralControl->pxRxControl; } break; case ioctlSET_SPEED : /* Set up the default UART configuration. */ xUARTConfig.Baud_rate = ulValue; xUARTConfig.Databits = UART_DATABIT_8; xUARTConfig.Parity = UART_PARITY_NONE; xUARTConfig.Stopbits = UART_STOPBIT_1; UART_Init( pxUART, &xUARTConfig ); break; // // //lecture - UART - need to follow the rules of interrupt management and interrupt safe // methods / apis // case ioctlSET_INTERRUPT_PRIORITY : /* The ISR uses ISR safe FreeRTOS API functions, so the priority being set must be lower than (ie numerically larger than) configMAX_LIBRARY_INTERRUPT_PRIORITY. */ configASSERT( ulValue >= configMAX_LIBRARY_INTERRUPT_PRIORITY ); NVIC_SetPriority( xIRQ[ cPeripheralNumber ], ulValue ); break; default : xReturn = pdFAIL; break; } } taskEXIT_CRITICAL(); return xReturn; }
size_t FreeRTOS_UART_read( Peripheral_Descriptor_t const pxPeripheral, void * const pvBuffer, const size_t xBytes ) { Peripheral_Control_t * const pxPeripheralControl = ( Peripheral_Control_t * const ) pxPeripheral; size_t xReturn = 0U; LPC_UART_TypeDef * const pxUART = ( LPC_UART_TypeDef * const ) diGET_PERIPHERAL_BASE_ADDRESS( ( ( Peripheral_Control_t * const ) pxPeripheral ) ); // //lecture - UART - rx transfer structure is NULL for rx polling mode // in the case of i2c, this is different - refer to i2c related code // if( diGET_RX_TRANSFER_STRUCT( pxPeripheralControl ) == NULL ) { #if ioconfigUSE_UART_POLLED_RX == 1 { /* No FreeRTOS objects exist to allow reception without blocking the task, so just receive by polling. No semaphore or queue is used here, so the application must ensure only one task attempts to make a polling read at a time. */ xReturn = UART_Receive( pxUART, pvBuffer, xBytes, NONE_BLOCKING ); } #endif /* ioconfigUSE_UART_POLLED_RX */ } else { /* Sanity check the array index. */ configASSERT( diGET_PERIPHERAL_NUMBER( pxPeripheralControl ) < ( int8_t ) ( sizeof( xIRQ ) / sizeof( IRQn_Type ) ) ); switch( diGET_RX_TRANSFER_TYPE( pxPeripheralControl ) ) { case ioctlUSE_CIRCULAR_BUFFER_RX : #if ioconfigUSE_UART_CIRCULAR_BUFFER_RX == 1 { /* There is nothing to prevent multiple tasks attempting to read the circular buffer at any one time. The implementation of the circular buffer uses a semaphore to indicate when new data is available, and the semaphore will ensure that only the highest priority task that is attempting a read will actually receive bytes. */ ioutilsRECEIVE_CHARS_FROM_CIRCULAR_BUFFER ( pxPeripheralControl, UART_IntConfig( pxUART, UART_INTCFG_RBR, DISABLE ), /* Disable peripheral. */ UART_IntConfig( pxUART, UART_INTCFG_RBR, ENABLE ), /* Enable peripheral. */ ( ( uint8_t * ) pvBuffer ), /* Data destination. */ xBytes, /* Bytes to read. */ xReturn /* Number of bytes read. */ ); } #endif /* ioconfigUSE_UART_CIRCULAR_BUFFER_RX */ break; case ioctlUSE_CHARACTER_QUEUE_RX : #if ioconfigUSE_UART_RX_CHAR_QUEUE == 1 { /* The queue allows multiple tasks to attempt to read bytes, but ensures only the highest priority of these tasks will actually receive bytes. If two tasks of equal priority attempt to read simultaneously, then the application must ensure mutual exclusion, as time slicing could result in the string being received being partially received by each task. */ xReturn = xIOUtilsReceiveCharsFromRxQueue( pxPeripheralControl, ( uint8_t * ) pvBuffer, xBytes ); } #endif /* ioconfigUSE_UART_RX_CHAR_QUEUE */ break; default : /* Other methods can be implemented here. */ configASSERT( xReturn ); /* Prevent compiler warnings when the configuration is set such that the following parameters are not used. */ ( void ) pvBuffer; ( void ) xBytes; ( void ) pxUART; break; } } return xReturn; }
/*********************************************************************//** * @brief Main UART testing example sub-routine * Print welcome screen first, then press any key to have it * read in from the terminal and returned back to the terminal. * - Press ESC to exit * - Press 'r' to print welcome screen menu again **********************************************************************/ int c_entry(void) { // UART Configuration structure variable UART_CFG_Type UARTConfigStruct; // UART FIFO configuration Struct variable UART_FIFO_CFG_Type UARTFIFOConfigStruct; // Pin configuration for UART0 PINSEL_CFG_Type PinCfg; uint32_t idx, len; __IO FlagStatus exitflag; uint8_t buffer[10]; // DeInit NVIC and SCBNVIC NVIC_DeInit(); NVIC_SCBDeInit(); /* Configure the NVIC Preemption Priority Bits: * two (2) bits of preemption priority, six (6) bits of sub-priority. * Since the Number of Bits used for Priority Levels is five (5), so the * actual bit number of sub-priority is three (3) */ NVIC_SetPriorityGrouping(0x05); // Set Vector table offset value #if (__RAM_MODE__==1) NVIC_SetVTOR(0x10000000); #else NVIC_SetVTOR(0x00000000); #endif /* * Initialize UART1 pin connect */ PinCfg.Funcnum = 1; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PinCfg.Portnum = 0; for (idx = 15; idx <= 22; idx++){ PinCfg.Pinnum = idx; PINSEL_ConfigPin(&PinCfg); } /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); // Initialize UART1 peripheral with given to corresponding parameter UART_Init((LPC_UART_TypeDef *)LPC_UART1, &UARTConfigStruct); /* Initialize FIFOConfigStruct to default state: * - FIFO_DMAMode = DISABLE * - FIFO_Level = UART_FIFO_TRGLEV0 * - FIFO_ResetRxBuf = ENABLE * - FIFO_ResetTxBuf = ENABLE * - FIFO_State = ENABLE */ UART_FIFOConfigStructInit(&UARTFIFOConfigStruct); // Initialize FIFO for UART1 peripheral UART_FIFOConfig((LPC_UART_TypeDef *)LPC_UART1, &UARTFIFOConfigStruct); #if (AUTO_RTS_CTS_USE==0) /* * Determine current state of CTS pin to enable Tx * activity */ if (UART_FullModemGetStatus(LPC_UART1) & UART1_MODEM_STAT_CTS) { // Enable UART Transmit UART_TxCmd((LPC_UART_TypeDef *)LPC_UART1, ENABLE); } #else // Enable UART Transmit UART_TxCmd((UART_TypeDef *)UART1, ENABLE); #endif // Reset ring buf head and tail idx __BUF_RESET(rb.rx_head); __BUF_RESET(rb.rx_tail); __BUF_RESET(rb.tx_head); __BUF_RESET(rb.tx_tail); #if AUTO_RTS_CTS_USE UART_FullModemConfigMode(UART1, UART1_MODEM_MODE_AUTO_RTS, ENABLE); UART_FullModemConfigMode(UART1, UART1_MODEM_MODE_AUTO_CTS, ENABLE); #else // Enable Modem status interrupt UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART1_INTCFG_MS, ENABLE); // Enable CTS1 signal transition interrupt UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART1_INTCFG_CTS, ENABLE); // Modem Status interrupt call back UART_SetupCbs((LPC_UART_TypeDef *)LPC_UART1, 4, (void *)UART1_ModemCallBack); // Force RTS pin state to ACTIVE UART_FullModemForcePinState(LPC_UART1, UART1_MODEM_PIN_RTS, ACTIVE); //RESET RTS State flag RTS_State = ACTIVE; #endif // Setup callback --------------- // Receive callback UART_SetupCbs((LPC_UART_TypeDef *)LPC_UART1, 0, (void *)UART1_IntReceive); // Transmit callback UART_SetupCbs((LPC_UART_TypeDef *)LPC_UART1, 1, (void *)UART1_IntTransmit); // Line Status Error callback UART_SetupCbs((LPC_UART_TypeDef *)LPC_UART1, 3, (void *)UART1_IntErr); /* Enable UART Rx interrupt */ UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART_INTCFG_RBR, ENABLE); /* Enable UART line status interrupt */ UART_IntConfig((LPC_UART_TypeDef *)LPC_UART1, UART_INTCFG_RLS, ENABLE); /* * Do not enable transmit interrupt here, since it is handled by * UART_Send() function, just to reset Tx Interrupt state for the * first time */ TxIntStat = RESET; /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(UART1_IRQn, ((0x01<<3)|0x01)); /* Enable Interrupt for UART1 channel */ NVIC_EnableIRQ(UART1_IRQn); // print welcome screen print_menu(); // reset exit flag exitflag = RESET; /* Read some data from the buffer */ while (exitflag == RESET) { len = 0; while (len == 0) { len = UARTReceive((LPC_UART_TypeDef *)LPC_UART1, buffer, sizeof(buffer)); } /* Got some data */ idx = 0; while (idx < len) { if (buffer[idx] == 27) { /* ESC key, set exit flag */ UARTSend((LPC_UART_TypeDef *)LPC_UART1, menu3, sizeof(menu3)); exitflag = SET; } else if (buffer[idx] == 'r') { print_menu(); } else { /* Echo it back */ UARTSend((LPC_UART_TypeDef *)LPC_UART1, &buffer[idx], 1); } idx++; } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy((LPC_UART_TypeDef *)LPC_UART1) == SET); // DeInitialize UART1 peripheral UART_DeInit((LPC_UART_TypeDef *)LPC_UART1); /* Loop forever */ while(1); return 1; }
/************************************************************* Function: void UartInit(uint8_t num,uint32_t baudrate,uint8_t parity) Description: 串口初始化函数用于初始化RS232及RS485 将UART配置为中断接收,DMA发送,RS485自动切换方向 Calls: Called By: main() Input: num 串口号0、1、2 baudrate 波特率 parity 校验方式 Output: 无 Return: 无 Others: 无 *************************************************************/ void UartInit ( uint8_t num, uint32_t baudrate, uint8_t parity ) { // uint32_t idx; // RS485 configuration UART1_RS485_CTRLCFG_Type rs485cfg; // UART Configuration structure variable UART_CFG_Type UARTConfigStruct; // UART FIFO configuration Struct variable UART_FIFO_CFG_Type UARTFIFOConfigStruct; GPDMA_Channel_CFG_Type GPDMACfg; UART_ConfigStructInit ( &UARTConfigStruct ); UARTConfigStruct.Baud_rate = baudrate; UARTConfigStruct.Parity = parity; UART_FIFOConfigStructInit ( &UARTFIFOConfigStruct ); // Enable DMA mode in UART UARTFIFOConfigStruct.FIFO_DMAMode = ENABLE; // Destination memory - don't care GPDMACfgTx.DstMemAddr = 0; // Transfer width - don't care GPDMACfgTx.TransferWidth = 0; // Transfer type GPDMACfgTx.TransferType = GPDMA_TRANSFERTYPE_M2P; // Source connection - don't care GPDMACfgTx.SrcConn = 0; // Linker List Item - unused GPDMACfgTx.DMALLI = 0; rs485cfg.AutoDirCtrl_State = ENABLE; rs485cfg.DirCtrlPol_Level = SET; rs485cfg.DelayValue = 50; rs485cfg.NormalMultiDropMode_State = ENABLE; rs485cfg.AutoAddrDetect_State = DISABLE; rs485cfg.Rx_State = ENABLE; if ( num == 0 ) { //PINSEL_ConfigPin(0,2,1); //UART0 //PINSEL_ConfigPin(0,3,1); //UART0 PINSEL_ConfigPin ( 0, 25, 0x03 ); PINSEL_ConfigPin ( 0, 26, 0xb3 ); // Initalize UART0 peripheral with given to corresponding parameter UART_Init ( RS232_UART, &UARTConfigStruct ); // Initialize FIFO for UART0 peripheral UART_FIFOConfig ( RS232_UART, &UARTFIFOConfigStruct ); // Enable UART Transmit UART_TxCmd ( RS232_UART, ENABLE ); // channel 0 GPDMACfgTx.ChannelNum = 0; // Source memory GPDMACfgTx.SrcMemAddr = ( uint32_t ) &RS232Tx.Buff; // Transfer size GPDMACfgTx.TransferSize = sizeof ( RS232Tx.Buff ); // Destination connection GPDMACfgTx.DstConn = RS232_TX_PIN; RS232Tx.Flag = 0; RS232_Err = 0; UART_IntConfig ( RS232_UART, UART_INTCFG_RBR, ENABLE ); UART_IntConfig ( RS232_UART, UART_INTCFG_RLS, ENABLE ); NVIC_SetPriority ( RS232_IRQN, ( ( 0x01 << 3 ) | 0x01 ) ); NVIC_EnableIRQ ( RS232_IRQN ); RS232Rx.Flag = 0 ; RS232Rx.Len = 0 ; RS232Rx.Idx = 0 ; } if ( num == 1 ) { PINSEL_ConfigPin ( 2, 0, 2 ); PINSEL_ConfigPin ( 2, 1, 2 ); PINSEL_ConfigPin ( 2, 5, 2 ); //U1_DTR rs485cfg.DirCtrlPin = UART1_RS485_DIRCTRL_DTR; UART_Init ( ( LPC_UART_TypeDef * ) LPC_UART1, &UARTConfigStruct ); UART_FIFOConfig ( ( LPC_UART_TypeDef * ) LPC_UART1, &UARTFIFOConfigStruct ); UART_RS485Config ( ( LPC_UART_TypeDef * ) LPC_UART1, &rs485cfg ); // Enable UART Transmit UART_TxCmd ( ( LPC_UART_TypeDef * ) LPC_UART1, ENABLE ); GPDMACfgTx.ChannelNum = 1; // Source memory GPDMACfgTx.SrcMemAddr = ( uint32_t ) &RS485Tx1.Buff; // Transfer size GPDMACfgTx.TransferSize = sizeof ( RS485Tx1.Buff ); // Destination connection GPDMACfgTx.DstConn = GPDMA_CONN_UART1_Tx; /* Reset terminal counter */ RS485Tx1.Flag = 0; /* Reset Error counter */ RS4851_Err = 0; /* Enable UART Rx interrupt */ UART_IntConfig ( ( LPC_UART_TypeDef * ) LPC_UART1, UART_INTCFG_RBR, ENABLE ); /* Enable UART line status interrupt */ UART_IntConfig ( ( LPC_UART_TypeDef * ) LPC_UART1, UART_INTCFG_RLS, ENABLE ); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority ( UART1_IRQn, ( ( 0x01 << 3 ) | 0x01 ) ); /* Enable Interrupt for UART0 channel */ NVIC_EnableIRQ ( UART1_IRQn ); } if ( num == 2 ) { PINSEL_ConfigPin ( 2, 8, 2 ); PINSEL_ConfigPin ( 2, 9, 2 ); PINSEL_ConfigPin ( 2, 6, 4 ); //U2_OE UART_Init ( LPC_UART2, &UARTConfigStruct ); UART_FIFOConfig ( LPC_UART2, &UARTFIFOConfigStruct ); UART_RS485Config ( ( LPC_UART_TypeDef * ) LPC_UART2, &rs485cfg ); // Enable UART Transmit UART_TxCmd ( LPC_UART2, ENABLE ); GPDMACfgTx.ChannelNum = 2; // Source memory GPDMACfgTx.SrcMemAddr = ( uint32_t ) &RS485Tx2.Buff; // Transfer size GPDMACfgTx.TransferSize = sizeof ( RS485Tx2.Buff ); // Destination connection GPDMACfgTx.DstConn = GPDMA_CONN_UART2_Tx; /* Reset terminal counter */ RS485Tx2.Flag = 0; /* Reset Error counter */ RS4852_Err = 0; /* Enable UART Rx interrupt */ UART_IntConfig ( LPC_UART2, UART_INTCFG_RBR, ENABLE ); /* Enable UART line status interrupt */ UART_IntConfig ( LPC_UART2, UART_INTCFG_RLS, ENABLE ); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority ( UART2_IRQn, ( ( 0x01 << 3 ) | 0x01 ) ); /* Enable Interrupt for UART0 channel */ NVIC_EnableIRQ ( UART2_IRQn ); } /* Initialize GPDMA controller */ GPDMA_Init(); /* Setting GPDMA interrupt */ // Disable interrupt for DMA NVIC_DisableIRQ ( DMA_IRQn ); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority ( DMA_IRQn, ( ( 0x01 << 3 ) | 0x01 ) ); // Setup channel with given parameter GPDMA_Setup ( &GPDMACfgTx ); // Enable interrupt for DMA NVIC_EnableIRQ ( DMA_IRQn ); // Enable GPDMA channel 0 //GPDMA_ChannelCmd(0, ENABLE); CRC_Init ( CRC_POLY_CRC16 ); }