/** * Function send via UART characters terminating * data sending to modem. */ static void GSM_TerminateDataSending(void) { while(UART_CheckBusy(UARTx)); UART_SendByte(UARTx, 0x1A); while(UART_CheckBusy(UARTx)); UART_SendByte(UARTx, 0x0D); while(UART_CheckBusy(UARTx)); UART_SendByte(UARTx, 0x0A); while(UART_CheckBusy(UARTx)); }
static uint32_t GSM_SerialSendString(uint8_t* ptr ) { uint32_t nrOfBytesSend; nrOfBytesSend = UART_Send(UARTx, ptr, buffLength(ptr), BLOCKING); while(UART_CheckBusy(UARTx)); return nrOfBytesSend; }
/********************************************************************//** * @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); } }
/* With ARM and GHS toolsets, the entry point is main() - this will allow the linker to generate wrapper code to setup stacks, allocate heap area, and initialize and copy code and data segments. For GNU toolsets, the entry point is through __start() in the crt0_gnu.asm file, and that startup code will setup stacks and data */ int main(void) { uchar buffer,buf[10]; System_Init(); // print welcome screen print_menu(LPC_UART0); print_menu(LPC_UART2); /* Read some data from the buffer */ while (1) { buffer = getche(LPC_UART0); /* Got some data */ if (EscFlag) { UART_Send(LPC_UART2, menu3, sizeof(menu3), BLOCKING); break; } if (buffer == 'r') { print_menu(LPC_UART2); get_line(LPC_UART0,buf,6); printf(LPC_UART2,buf); } else { /* Echo it back */ UART_SendByte((LPC_UART_TypeDef *)LPC_UART2, buffer); } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy(LPC_UART0) == SET); while (UART_CheckBusy(LPC_UART2) == SET); // DeInitialize UART0 peripheral UART_DeInit(LPC_UART0); UART_DeInit(LPC_UART2); /* Loop forever */ while(1); return 1; }
void GSM_SendSMS(uint8_t* number, uint8_t* data) { //NVIC_DisableIRQ(UART1_IRQn); GSM_SerialSendString("AT+CMGF=1\r"); delay_ms(100);//while(!OKFlag); GSM_SerialSendString("at+CMGS=\""); GSM_SerialSendString(number); GSM_SerialSendString("\"\r"); promptReceived=0; //while(!sendDataFlag); promptReceived=0; GSM_SerialSendString(data); while(UART_CheckBusy(UARTx)); UART_SendByte(UARTx, 0x1A); while(UART_CheckBusy(UARTx)); UART_SendByte(UARTx, 0x0D); while(UART_CheckBusy(UARTx)); UART_SendByte(UARTx, 0x0A); NVIC_EnableIRQ(UART1_IRQn); }
void handleTransmitInterrupt() { disableTransmitInterrupt(); if(CTS_STATE == INACTIVE) { return; } while(UART_CheckBusy(UART1_DEVICE) == SET); while(!QUEUE_EMPTY(uint8_t, &listener.serial->sendQueue)) { uint8_t byte = QUEUE_PEEK(uint8_t, &listener.serial->sendQueue); if(UART_Send(UART1_DEVICE, &byte, 1, NONE_BLOCKING)) { QUEUE_POP(uint8_t, &listener.serial->sendQueue); } else { break; } } if(QUEUE_EMPTY(uint8_t, &listener.serial->sendQueue)) { disableTransmitInterrupt(); } else { enableTransmitInterrupt(); } }
/*********************************************************************//** * @brief c_entry: Main UART 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 for UART0 PINSEL_CFG_Type PinCfg; uint32_t idx, len; __IO FlagStatus exitflag; uint8_t buffer[10]; /* * 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 = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); // Initialize UART0 peripheral with given to corresponding parameter UART_Init((LPC_UART_TypeDef *)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_UART_TypeDef *)LPC_UART0, &UARTFIFOConfigStruct); // 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); /* * 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; // 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); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(UART0_IRQn, ((0x01<<3)|0x01)); /* Enable Interrupt for UART0 channel */ NVIC_EnableIRQ(UART0_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_UART0, 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_UART0, menu3, sizeof(menu3)); exitflag = SET; } else if (buffer[idx] == 'r') { print_menu(); } else { /* Echo it back */ UARTSend((LPC_UART_TypeDef *)LPC_UART0, &buffer[idx], 1); } idx++; } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy((LPC_UART_TypeDef *)LPC_UART0)); // DeInitialize UART0 peripheral UART_DeInit((LPC_UART_TypeDef *)LPC_UART0); /* Loop forever */ while(1); return 1; }
/*********************************************************************//** * @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 #if (UART_PORT == 0) /* * 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); #endif #if (UART_PORT == 1) /* * Initialize UART1 pin connect */ PinCfg.Funcnum = 2; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PinCfg.Pinnum = 0; PinCfg.Portnum = 2; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 1; PINSEL_ConfigPin(&PinCfg); #endif /* Initialize UART Configuration parameter structure to default state: * Baudrate = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); // Initialize UART0 peripheral with given to corresponding parameter UART_Init(TEST_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); // Initialize FIFO for UART0 peripheral UART_FIFOConfig(TEST_UART, &UARTFIFOConfigStruct); // Enable UART Transmit UART_TxCmd(TEST_UART, ENABLE); // 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 = UART_Receive(TEST_UART, buffer, sizeof(buffer), NONE_BLOCKING); } /* Got some data */ idx = 0; while (idx < len) { if (buffer[idx] == 27) { /* ESC key, set exit flag */ UART_Send(TEST_UART, menu3, sizeof(menu3), BLOCKING); exitflag = SET; } else if (buffer[idx] == 'r') { print_menu(); } else { /* Echo it back */ UART_Send(TEST_UART, &buffer[idx], 1, BLOCKING); } idx++; } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy(TEST_UART) == SET); // DeInitialize UART0 peripheral UART_DeInit(TEST_UART); /* Loop forever */ while(1); return 1; }
/*********************************************************************//** * @brief c_entry: Main UART 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; uint32_t idx, len; __IO FlagStatus exitflag; uint8_t buffer[10]; /* * Initialize UART1 pin connect */ PINSEL_ConfigPin(0, 15, 1);//UART1 - TXD PINSEL_ConfigPin(0, 16, 1);//UART1 - RXD PINSEL_ConfigPin(0, 17, 1);//UART1 - CTS PINSEL_ConfigPin(0, 22, 1);//UART1 - RTS /* Initialize UART Configuration parameter structure to default state: * Baudrate = 115200bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); // Initialize UART0 peripheral with given to corresponding parameter UART_Init(TEST_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); // Initialize FIFO for UART0 peripheral UART_FIFOConfig(TEST_UART, &UARTFIFOConfigStruct); // Configure UART1 hardware flow control RTS/CTS UART_FullModemForcePinState(TEST_UART,UART1_MODEM_PIN_RTS,ACTIVE); // Enable UART Transmit UART_TxCmd(TEST_UART, ENABLE); // 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 = UART_Receive(TEST_UART, buffer, sizeof(buffer), NONE_BLOCKING); } /* Got some data */ idx = 0; while (idx < len) { if (buffer[idx] == 27) { /* ESC key, set exit flag */ UART_Send(TEST_UART, menu2, sizeof(menu2), BLOCKING); exitflag = SET; } else if (buffer[idx] == 'r') { print_menu(); } else { /* Echo it back */ UART_Send(TEST_UART, &buffer[idx], 1, BLOCKING); } idx++; } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy(TEST_UART) == SET); // DeInitialize UART0 peripheral UART_DeInit(TEST_UART); /* Loop forever */ while(1); }
size_t FreeRTOS_UART_write( Peripheral_Descriptor_t const pxPeripheral, const void *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 ) ); int8_t cPeripheralNumber; // //lecture - UART - tx transfer control structure is NULL for tx polling mode - // in the case of i2c, this is not NULL - refer to i2c code more details !!! // // if( diGET_TX_TRANSFER_STRUCT( pxPeripheralControl ) == NULL ) { #if ioconfigUSE_UART_POLLED_TX == 1 { /* No FreeRTOS objects exist to allow transmission without blocking the task, so just send out by polling. No semaphore or queue is used here, so the application must ensure only one task attempts to make a polling write at a time. */ xReturn = UART_Send( pxUART, ( uint8_t * ) pvBuffer, ( size_t ) xBytes, BLOCKING ); /* The UART is set to polling mode, so may as well poll the busy bit too. Change to interrupt driven mode to avoid wasting CPU time here. */ while( UART_CheckBusy( pxUART ) != RESET ); } #endif /* ioconfigUSE_UART_POLLED_TX */ } else { /* Remember which transfer control structure is being used. The Tx interrupt will use this to continue to write data to the Tx FIFO/UART until the length member of the structure reaches zero. */ cPeripheralNumber = diGET_PERIPHERAL_NUMBER( pxPeripheralControl ); pxTxTransferControlStructs[ cPeripheralNumber ] = diGET_TX_TRANSFER_STRUCT( pxPeripheralControl ); switch( diGET_TX_TRANSFER_TYPE( pxPeripheralControl ) ) { case ioctlUSE_ZERO_COPY_TX : #if ioconfigUSE_UART_ZERO_COPY_TX == 1 { /* The implementation of the zero copy write uses a semaphore to indicate whether a write is complete (and so the buffer being written free again) or not. The semantics of using a zero copy write dictate that a zero copy write can only be attempted by a task, once the semaphore has been successfully obtained by that task. This ensure that only one task can perform a zero copy write at any one time. Ensure the semaphore is not currently available, if this function has been called without it being obtained first then it is an error. */ configASSERT( xIOUtilsGetZeroCopyWriteMutex( pxPeripheralControl, ioctlOBTAIN_WRITE_MUTEX, 0U ) == 0 ); xReturn = xBytes; ioutilsINITIATE_ZERO_COPY_TX ( pxPeripheralControl, UART_TxCmd( pxUART, DISABLE ), /* Disable peripheral function. */ UART_TxCmd( pxUART, ENABLE ), /* Enable peripheral function. */ prvFillFifoFromBuffer( pxUART, ( uint8_t ** ) &( pvBuffer ), xBytes ), /* Write to peripheral function. */ pvBuffer, /* Data source. */ xReturn /* Number of bytes to be written. This will get set to zero if the write mutex is not held. */ ); } #endif /* ioconfigUSE_UART_ZERO_COPY_TX */ break; case ioctlUSE_CHARACTER_QUEUE_TX : #if ioconfigUSE_UART_TX_CHAR_QUEUE == 1 { /* The queue allows multiple tasks to attempt to write bytes, but ensures only the highest priority of these tasks will actually succeed. If two tasks of equal priority attempt to write simultaneously, then the application must ensure mutual exclusion, as time slicing could result in the strings being sent to the queue being interleaved. */ ioutilsBLOCKING_SEND_CHARS_TO_TX_QUEUE ( pxPeripheralControl, ( pxUART->LSR & uartTX_BUSY_MASK ) == uartTX_BUSY_MASK, /* Peripheral busy condition. */ pxUART->THR = ucChar, /* Peripheral write function. */ ( ( uint8_t * ) pvBuffer ), /* Data source. */ xBytes, /* Number of bytes to be written. */ xReturn ); } #endif /* ioconfigUSE_UART_TX_CHAR_QUEUE */ break; default : /* Other methods can be implemented here. For now set the stored transfer structure back to NULL as nothing is being sent. */ configASSERT( xReturn ); pxTxTransferControlStructs[ cPeripheralNumber ] = NULL; /* 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; }
/*********************************************************************//** * @brief c_entry: Main UART 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 for UART0 PINSEL_CFG_Type PinCfg; // Auto baudrate configuration structure UART_AB_CFG_Type ABConfig; uint32_t idx, len; __IO FlagStatus exitflag; uint8_t buffer[10]; /* * 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 = 9600bps * 8 data bit * 1 Stop bit * None parity */ UART_ConfigStructInit(&UARTConfigStruct); /* Initialize UART0 peripheral with given to corresponding parameter * in this case, don't care the baudrate value UART initialized * since this will be determine when running auto baudrate */ 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); /* Enable UART End of Auto baudrate interrupt */ UART_IntConfig(LPC_UART0, UART_INTCFG_ABEO, ENABLE); /* Enable UART Auto baudrate timeout interrupt */ UART_IntConfig(LPC_UART0, UART_INTCFG_ABTO, ENABLE); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(UART0_IRQn, ((0x01<<3)|0x01)); /* Enable Interrupt for UART0 channel */ NVIC_EnableIRQ(UART0_IRQn); /* ---------------------- Auto baud rate section ----------------------- */ // Reset Synchronous flag for auto-baudrate mode Synchronous = RESET; // Configure Auto baud rate mode ABConfig.ABMode = UART_AUTOBAUD_MODE0; ABConfig.AutoRestart = ENABLE; // Start auto baudrate mode UART_ABCmd(LPC_UART0, &ABConfig, ENABLE); print_menu(); /* Loop until auto baudrate mode complete */ while (Synchronous == RESET); // Print status of auto baudrate UART_Send(LPC_UART0, syncmenu, sizeof(syncmenu), BLOCKING); /* ---------------------- End of Auto baud rate section ----------------------- */ // 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 = UART_Receive(LPC_UART0, buffer, sizeof(buffer), NONE_BLOCKING); } /* Got some data */ idx = 0; while (idx < len) { if (buffer[idx] == 27) { /* ESC key, set exit flag */ UART_Send(LPC_UART0, menu3, sizeof(menu3), BLOCKING); exitflag = SET; } else if (buffer[idx] == 'r') { print_menu(); } else { /* Echo it back */ UART_Send(LPC_UART0, &buffer[idx], 1, BLOCKING); } idx++; } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy(LPC_UART0) == SET); // DeInitialize UART0 peripheral UART_DeInit(LPC_UART0); /* Loop forever */ while(1); return 1; }
/*********************************************************************//** * @brief c_entry: Main program body * @param[in] None * @return int **********************************************************************/ int c_entry(void) { uint8_t tmpchar[2] = {0, 0}; __IO FlagStatus exitflag; PINSEL_CFG_Type PinCfg; I2C_M_SETUP_Type transferCfg; uint8_t SC16IS_RegStat; #if (USEDI2CDEV == 0) /* Disable I2C0 interrupt */ NVIC_DisableIRQ(I2C0_IRQn); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(I2C0_IRQn, ((0x01<<3)|0x01)); #elif (USEDI2CDEV == 2) /* Disable I2C2 interrupt */ NVIC_DisableIRQ(I2C2_IRQn); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(I2C2_IRQn, ((0x01<<3)|0x01)); #endif /* Initialize debug via UART0 * – 115200bps * – 8 data bit * – No parity * – 1 stop bit * – No flow control */ debug_frmwrk_init(); // print welcome screen print_menu(); /* * Init I2C pin connect */ PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; #if (USEDI2CDEV == 0) PinCfg.Funcnum = 1; PinCfg.Pinnum = 27; PinCfg.Portnum = 0; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 28; PINSEL_ConfigPin(&PinCfg); #elif (USEDI2CDEV == 2) PinCfg.Funcnum = 2; PinCfg.Pinnum = 10; PinCfg.Portnum = 0; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 11; PINSEL_ConfigPin(&PinCfg); #endif /* I2C block ------------------------------------------------------------------- */ // Initialize I2C peripheral I2C_Init(I2CDEV, 100000); /* Enable I2C1 operation */ I2C_Cmd(I2CDEV, ENABLE); // test complete = RESET; transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = NULL; transferCfg.tx_length = 0; transferCfg.rx_data = &SC16IS_RegStat; transferCfg.rx_length = 1; transferCfg.retransmissions_max = 2; I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_INTERRUPT); while (complete == RESET); /* Configure SC16IS750 ---------------------------------------------------------- */ /* First, send some command to reset SC16IS740 chip via I2C bus interface */ complete = RESET; transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = (uint8_t *)iocon_cfg; transferCfg.tx_length = sizeof(iocon_cfg); transferCfg.rx_data = NULL; transferCfg.rx_length = 0; transferCfg.retransmissions_max = 2; I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_INTERRUPT); while (complete == RESET); complete = RESET; transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = (uint8_t *)iodir_cfg; transferCfg.tx_length = sizeof(iodir_cfg); transferCfg.rx_data = NULL; transferCfg.rx_length = 0; transferCfg.retransmissions_max = 2; I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_INTERRUPT); while (complete == RESET); complete = RESET; transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = (uint8_t *)iostate_cfg_0; transferCfg.tx_length = sizeof(iostate_cfg_0); transferCfg.rx_data = NULL; transferCfg.rx_length = 0; transferCfg.retransmissions_max = 2; I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_INTERRUPT); while (complete == RESET); /* Validate value of SC16IS750 register ------------------------------------------ */ /* This section will dump out value of register that set through I2C bus */ complete = RESET; transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = NULL; //(uint8_t *)iocon_cfg; transferCfg.tx_length = 0;//1; transferCfg.rx_data = &SC16IS_RegStat; transferCfg.rx_length = 1; transferCfg.retransmissions_max = 2; I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_INTERRUPT); while (complete == RESET); complete = RESET; transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = (uint8_t *)iodir_cfg; transferCfg.tx_length = 1; transferCfg.rx_data = &SC16IS_RegStat; transferCfg.rx_length = 1; transferCfg.retransmissions_max = 2; I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_INTERRUPT); while (complete == RESET); complete = RESET; transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = (uint8_t *)iostate_cfg_0; transferCfg.tx_length = 1; transferCfg.rx_data = &SC16IS_RegStat; transferCfg.rx_length = 1; transferCfg.retransmissions_max = 2; I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_INTERRUPT); while (complete == RESET); // Reset exit flag exitflag = RESET; /* Read some data from the buffer */ while (exitflag == RESET){ while((tmpchar[0] = _DG) == 0); if (tmpchar[0] == 27){ /* ESC key, set exit flag */ _DBG_(menu2); exitflag = SET; } else if (tmpchar[0] == 'r'){ print_menu(); } else{ if (tmpchar[0] == '1'){ // LEDs are ON now... transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = (uint8_t *)iostate_cfg_0; transferCfg.tx_length = sizeof(iostate_cfg_0); transferCfg.rx_data = NULL; transferCfg.rx_length = 0; transferCfg.retransmissions_max = 2; if (I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_POLLING) \ == ERROR){ Error_Loop(transferCfg.status); } } else if (tmpchar[0] == '2') { // LEDs are OFF now... transferCfg.sl_addr7bit = SLVADDR; transferCfg.tx_data = (uint8_t *)iostate_cfg_1; transferCfg.tx_length = sizeof(iostate_cfg_1); transferCfg.rx_data = NULL; transferCfg.rx_length = 0; transferCfg.retransmissions_max = 2; if (I2C_MasterTransferData(I2CDEV, &transferCfg, I2C_TRANSFER_POLLING) \ == ERROR){ Error_Loop(transferCfg.status); } } /* Then Echo it back */ _DBG_(tmpchar); } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy(LPC_UART0) == SET); // DeInitialize UART0 peripheral UART_DeInit(LPC_UART0); I2C_DeInit(I2CDEV); /* Loop forever */ while(1); return 1; }
int comm_txbusy(void) { return ( UART_CheckBusy(TEST_UART) == SET ) ? 1 : 0; }
/*********************************************************************//** * @brief c_entry: Main SSP program body * @param[in] None * @return int **********************************************************************/ int c_entry(void) { uint8_t tmpchar[2] = {0, 0}; PINSEL_CFG_Type PinCfg; __IO FlagStatus exitflag; /* * Initialize SPI pin connect * P0.15 - SCK * P0.16 - SSEL - used as GPIO * P0.17 - MISO * P0.18 - MOSI */ PinCfg.Funcnum = 2; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PinCfg.Portnum = 0; PinCfg.Pinnum = 15; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 17; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 18; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 16; PinCfg.Funcnum = 0; PINSEL_ConfigPin(&PinCfg); /* Initialize debug via UART0 * – 115200bps * – 8 data bit * – No parity * – 1 stop bit * – No flow control */ debug_frmwrk_init(); // print welcome screen print_menu(); // initialize SSP configuration structure to default SSP_ConfigStructInit(&SSP_ConfigStruct); // Initialize SSP peripheral with parameter given in structure above SSP_Init(LPC_SSP0, &SSP_ConfigStruct); // Initialize /CS pin to GPIO function CS_Init(); // Enable SSP peripheral SSP_Cmd(LPC_SSP0, ENABLE); /* preemption = 1, sub-priority = 1 */ NVIC_SetPriority(SSP0_IRQn, ((0x01<<3)|0x01)); /* Enable SSP0 interrupt */ NVIC_EnableIRQ(SSP0_IRQn); /* First, send some command to reset SC16IS740 chip via SSP bus interface * note driver /CS pin to low state before transferring by CS_Enable() function */ complete = RESET; CS_Force(0); xferConfig.tx_data = iocon_cfg; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iocon_cfg); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_INTERRUPT); while (complete == RESET); CS_Force(1); complete = RESET; CS_Force(0); xferConfig.tx_data = iodir_cfg; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iodir_cfg); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_INTERRUPT); while (complete == RESET); CS_Force(1); // Reset exit flag exitflag = RESET; /* Read some data from the buffer */ while (exitflag == RESET) { while((tmpchar[0] = _DG) == 0); if (tmpchar[0] == 27){ /* ESC key, set exit flag */ _DBG_(menu2); exitflag = SET; } else if (tmpchar[0] == 'r'){ print_menu(); } else { if (tmpchar[0] == '1') { // LEDs are ON now... CS_Force(0); xferConfig.tx_data = iostate_on; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iostate_on); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_POLLING); CS_Force(1); } else if (tmpchar[0] == '2') { // LEDs are OFF now... CS_Force(0); xferConfig.tx_data = iostate_off; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iostate_off); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_POLLING); CS_Force(1); } /* Then Echo it back */ _DBG_(tmpchar); } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy(LPC_UART0) == SET ); // DeInitialize UART0 peripheral UART_DeInit(LPC_UART0); /* Loop forever */ while(1); return 1; }
void vGpsTask(void *pvParameters) { delay_ms(100); GpsInitialization(); //UART_Send(LPC_UART0, "$PMTK314,0,0,0,5,0,0,0,0,1,1,1,1,1,1,1,1,1*2C\r\n", 47, BLOCKING ); //UART_Send(LPC_UART0,(uint8_t *) "$PMTK314,0,0,0,5,5,5,0,0,1,1,1,1,1,1,1,1,1*2C\r\n", 47, BLOCKING ); UART_Send(LPC_UART0,(uint8_t *) "$PMTK314,1,1,1,1,1,5,0,0,0,0,0,0,0,0,0,0,0,0,0*2C\r\n",52, BLOCKING); //UART_Send(LPC_UART0,(uint8_t *) "$PMTK000*32\r\n",13, BLOCKING); UART_Send(LPC_UART0,(uint8_t *) "$PMTK101*32\r\n",13, BLOCKING); while(UART_CheckBusy(LPC_UART0)); NVIC_EnableIRQ(UART0_IRQn); while(1) { gpsSetProcessingBuffer(-1); if(xSemaphoreTake(xSemaphoreGPS,portMAX_DELAY) == pdTRUE) { gpsSetProcessingBuffer(0); gps_tokenize_input(); char *token_msgid = gps_getToken(0); if( strcmp(token_msgid, "$GPGGA") == 0) { //$GPGGA,081604.000,5204.8543,N,02101.6233,E,1,8,1.06,96.7,M,39.3,M,,*66 //$GPGGA,082316.000,5204.8526,N,02101.6227,E,1,8,1.04,93.9,M,39.3,M,,*6C //$GPGGA,083352.000,5205.1129,N,02102.3054,E,2,9,0.99,107.4,M,39.3,M,0000,0000*58 asm("nop"); // if(checkFixPresence()!=0) // { // parseGgaMessage(); // } } else if (strcmp(token_msgid, "$GPRMC")==0) { //$GPRMC,081253.000,A,5204.8527,N,02101.6226,E,0.04,0.00,210214,,,A*6A //$GPRMC,082223.000,A,5204.8527,N,02101.6234,E,0.33,175.46,210214,,,A*68 char *test = gps_getToken(2); if(test[0] == 'V') { asm("nop"); } else if (test[0] == 'A') { asm("nop"); } } else if (strncmp(token_msgid, "GPGSA", 5)==0) { // GSA - SATELITES AVAILVLE //$GPGSA,A,3,20,31,17,11,01,,,,,,,,1.80,1.54,0.93*06 //$GPGSA,A,3,20,31D*0C\r\n asm("nop"); } else if (strncmp(token_msgid, "GPVTG", 5) == 0) { //$GPVTG,71.41,T,,M,0.06,N,0.10,K,A*09\r\n // 10 km/h //$GPVTG,70.02,T,,M,8.04,N,14.90,K,A*38\r\n // 25 km/h //$GPVTG,248.73,T,,M,12.53,N,23.23,K,D*37 asm("nop"); } else if (strncmp(token_msgid, "GPGSV", 5) == 0) { // GSV - Satelistes in view // $GPGSV,4,1,13,20,76,279,46,01,62,169,45,32,61,082,44,23,40,210,48*7F // $GPGSV,2,1,08,20,71,276,26,01,67,172,40,11,37,173,31,31,32,091,*79 char *test = getFieldPtr(3); if (strncmp(test, "00", 2)!= 0) { asm("nop"); } } else if (strncmp(token_msgid, "PMTK011",7)==0) { asm("nop"); } else if (strncmp(token_msgid, "PMTK010", 7)==0) { asm("nop"); } else { asm("nop"); } } // vTaskDelay(1000/portTICK_RATE_MS); } }
void HandleInputChar(char c) { int i; int result; result = PROTO_HandleInputCharacter(c); if (result == RESULT_ERROR) { UART_PrintString(kErrorResponse); } else if( result == RESULT_ACCEPT ) { const ProtocolHandler *handler = PROTO_GetCurrentHandler(); if (handler) { switch (handler->id) { case PROTO_ID_DEFAULT: UART_PrintString(kOkResponse); UART_PrintString(kNewLine); break; case PROTO_ID_SYS: if (PROTO_SYS_GetCommand() == PROTO_SYS_COMMAND_RESET) { UART_PrintString(kOkResponse); while(UART_CheckBusy(LPC_UART) != RESET); NVIC_SystemReset(); } else if (PROTO_SYS_GetCommand() == PROTO_SYS_COMMAND_VERSION) { PrintVersionString(UART_WriteChar); } else { UART_PrintString(kNotAvailableResponse); } UART_PrintString(kNewLine); break; /* case COMMAND_BACKLITE: UART_PrintString( "+BL\r\n" ); backlite_power = PROTO_GetBacklitePower(); break; */ case PROTO_ID_SPI: if (0 && PROTO_SPI_GetAction() == PROTO_SPI_ACTION_READ) { int len = PROTO_SPI_GetLength(); func_printf_nofloat(UART_WriteChar, "%02X:", len); for (i = 0; i < len; i++) { uint8_t b; b = SPI_ReadByte(); func_printf_nofloat(UART_WriteChar, " %02X", b); } } else if (PROTO_SPI_GetAction() == PROTO_SPI_ACTION_WRITE) { uint8_t *data = PROTO_SPI_GetData(); int len = PROTO_SPI_GetLength(); SPI_Write(data, len); UART_PrintString(kOkResponse); } else { UART_PrintString(kNotAvailableResponse); } UART_PrintString(kNewLine); break; case PROTO_ID_RFID: if (PROTO_RF_GetAction() == PROTO_RF_ACTION_READ) { int len = PROTO_RF_GetLength(); func_printf_nofloat(UART_WriteChar, "%02X:", len); for (i = 0; i < len; i++) { int addr = PROTO_RF_GetAddress(); uint8_t b; if (PROTO_RF_GetMode() == PROTO_RF_MODE_INCREMENT_ADDRESS) addr += i; if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_PORT) b = CL632_SpiReadByte(addr); else if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_MEMORY) CL632_ReadE2(addr, &b, 1); func_printf_nofloat(UART_WriteChar, " %02X", b); } } else if (PROTO_RF_GetAction() == PROTO_RF_ACTION_WRITE) { int addr = PROTO_RF_GetAddress(); uint8_t *data = PROTO_RF_GetData(); int len = PROTO_RF_GetLength(); int same_address = PROTO_RF_GetMode() == PROTO_RF_MODE_SAME_ADDRESS; if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_PORT) { CL632_SpiWrite(addr, same_address, data, len); } else if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_MEMORY) { CL632_WriteE2(addr, data, len); } UART_PrintString(kOkResponse); } else { UART_PrintString(kNotAvailableResponse); } UART_PrintString(kNewLine); break; case PROTO_ID_RGB: switch (PROTO_RGB_GetCommand()) { case PROTO_RGB_COMMAND_CAPABILITIES: UART_PrintString("RGB,TRAN"); break; case PROTO_RGB_COMMAND_PRINT_SEQUENCE: UART_PrintString("S"); for (i = 0; i < SEQ_GetSequenceLength(); i++) { const COMMAND *cmd = &(SEQ_GetSequence()[i]); func_printf_nofloat(UART_WriteChar, " L%d#%02X%02X%02X", cmd->interval, cmd->color.red, cmd->color.green, cmd->color.blue); } break; case PROTO_RGB_COMMAND_SET_SEQUENCE: SEQ_SetSequence(PROTO_RGB_GetSequence(), PROTO_RGB_GetSequenceLength()); UART_PrintString(kOkResponse); break; default: UART_PrintString(kNotAvailableResponse); break; } UART_PrintString(kNewLine); break; } } } }
/*********************************************************************//** * @brief c_entry: Main UART-FULLMODEM 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 for UART1 PINSEL_CFG_Type PinCfg; uint32_t idx, len; __IO FlagStatus exitflag; uint8_t buffer[10]; /* * Initialize UART1 pin connect * If using MCB1700 eval board, assign pin P2.0 - P2.7 * If using IAR 1768 KS board, assign pin P0.7 - P0.15 */ #ifdef MCB_LPC_1768 PinCfg.Funcnum = 2; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PinCfg.Portnum = 2; for (idx = 0; idx <= 7; idx++){ PinCfg.Pinnum = idx; PINSEL_ConfigPin(&PinCfg); } #elif defined(IAR_LPC_1768) PinCfg.Funcnum = 1; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PinCfg.Portnum = 0; for (idx = 15; idx <= 22; idx++){ PinCfg.Pinnum = idx; PINSEL_ConfigPin(&PinCfg); } #endif /* 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((LPC_UART_TypeDef *)LPC_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(LPC_UART1, UART1_MODEM_MODE_AUTO_RTS, ENABLE); UART_FullModemConfigMode(LPC_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); // Force RTS pin state to ACTIVE UART_FullModemForcePinState(LPC_UART1, UART1_MODEM_PIN_RTS, ACTIVE); //RESET RTS State flag RTS_State = ACTIVE; #endif /* 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; }
/*********************************************************************//** * @brief Main SSP program body **********************************************************************/ int c_entry(void) { uint8_t tmpchar[2] = {0, 0}; PINSEL_CFG_Type PinCfg; __IO FlagStatus exitflag; SSP_DATA_SETUP_Type xferConfig; // 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 SPI pin connect * P0.15 - SCK * P0.16 - SSEL - used as GPIO * P0.17 - MISO * P0.18 - MOSI */ PinCfg.Funcnum = 2; PinCfg.OpenDrain = 0; PinCfg.Pinmode = 0; PinCfg.Portnum = 0; PinCfg.Pinnum = 15; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 17; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 18; PINSEL_ConfigPin(&PinCfg); PinCfg.Pinnum = 16; PinCfg.Funcnum = 0; PINSEL_ConfigPin(&PinCfg); /* * Initialize debug via UART */ debug_frmwrk_init(); // print welcome screen print_menu(); // initialize SSP configuration structure to default SSP_ConfigStructInit(&SSP_ConfigStruct); // Initialize SSP peripheral with parameter given in structure above SSP_Init(LPC_SSP0, &SSP_ConfigStruct); // Initialize /CS pin to GPIO function CS_Init(); // Enable SSP peripheral SSP_Cmd(LPC_SSP0, ENABLE); /* First, send some command to reset SC16IS740 chip via SSP bus interface * note driver /CS pin to low state before transferring by CS_Enable() function */ CS_Force(0); xferConfig.tx_data = iocon_cfg; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iocon_cfg); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_POLLING); CS_Force(1); CS_Force(0); xferConfig.tx_data = iodir_cfg; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iodir_cfg); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_POLLING); CS_Force(1); // Reset exit flag exitflag = RESET; /* Read some data from the buffer */ while (exitflag == RESET) { while((tmpchar[0] = _DG) == 0); if (tmpchar[0] == 27){ /* ESC key, set exit flag */ _DBG_(menu2); exitflag = SET; } else if (tmpchar[0] == 'r'){ print_menu(); } else { if (tmpchar[0] == '1') { // LEDs are ON now... CS_Force(0); xferConfig.tx_data = iostate_on; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iostate_on); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_POLLING); CS_Force(1); } else if (tmpchar[0] == '2') { // LEDs are OFF now... CS_Force(0); xferConfig.tx_data = iostate_off; xferConfig.rx_data = sspreadbuf; xferConfig.length = sizeof (iostate_off); SSP_ReadWrite(LPC_SSP0, &xferConfig, SSP_TRANSFER_POLLING); CS_Force(1); } /* Then Echo it back */ _DBG_(tmpchar); } } // wait for current transmission complete - THR must be empty while (UART_CheckBusy(LPC_UART0) == SET); // DeInitialize UART0 peripheral UART_DeInit(LPC_UART0); /* Loop forever */ while(1); return 1; }