/**
* 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;
}
