/* Interrupt routine for example_uart */
static void App_Interrupt_Test(void)
{
uint8_t isExit = 0, userInput;
int len;
App_Interrupt_Init();
/* Print out uart interrupt menu */
Print_Menu_Interrupt(LPC_UART);
while (!isExit) {
len = 0;
while (len == 0) {
len = Chip_UART_ReadRB(LPC_UART, &rxring, &userInput, 1);
}
if (userInput == '1') {
Chip_UART_SendRB(LPC_UART, &txring, (uint8_t *) &uart_interrupt_menu1[0], sizeof(uart_interrupt_menu1));
}
else if (userInput == '2') {
Chip_UART_SendRB(LPC_UART, &txring, (uint8_t *) &uart_interrupt_menu2[0], sizeof(uart_interrupt_menu2));
}
else if (userInput == '3') {
Chip_UART_SendRB(LPC_UART, &txring, (uint8_t *) &uart_interrupt_menu3[0], sizeof(uart_interrupt_menu3));
}
else if (userInput == '4') {
Chip_UART_SendRB(LPC_UART, &txring, (uint8_t *) &uart_interrupt_menu4[0], sizeof(uart_interrupt_menu4));
}
else if (( userInput == 'x') || ( userInput == 'X') ) {
isExit = 1;
}
}
App_Interrupt_DeInit();
}
/**
* @brief Main UART program body
* @return Always returns 1
*/
int main(void)
{
uint8_t key;
int bytes;
SystemCoreClockUpdate();
Board_Init();
Board_UART_Init(LPC_UARTX);
Board_LED_Set(0, false);
/* Setup UART for 115.2K8N1 */
Chip_UART_Init(LPC_UARTX);
Chip_UART_SetBaud(LPC_UARTX, 115200);
Chip_UART_ConfigData(LPC_UARTX, (UART_LCR_WLEN8 | UART_LCR_SBS_1BIT));
Chip_UART_SetupFIFOS(LPC_UARTX, (UART_FCR_FIFO_EN | UART_FCR_TRG_LEV2));
Chip_UART_TXEnable(LPC_UARTX);
/* Before using the ring buffers, initialize them using the ring
buffer init function */
RingBuffer_Init(&rxring, rxbuff, 1, UART_RRB_SIZE);
RingBuffer_Init(&txring, txbuff, 1, UART_SRB_SIZE);
/* Reset and enable FIFOs, FIFO trigger level 3 (14 chars) */
Chip_UART_SetupFIFOS(LPC_UARTX, (UART_FCR_FIFO_EN | UART_FCR_RX_RS |
UART_FCR_TX_RS | UART_FCR_TRG_LEV3));
/* Enable receive data and line status interrupt */
Chip_UART_IntEnable(LPC_UARTX, (UART_IER_RBRINT | UART_IER_RLSINT));
/* preemption = 1, sub-priority = 1 */
NVIC_SetPriority(UARTx_IRQn, 1);
NVIC_EnableIRQ(UARTx_IRQn);
/* Send initial messages */
Chip_UART_SendRB(LPC_UARTX, &txring, inst1, sizeof(inst1) - 1);
Chip_UART_SendRB(LPC_UARTX, &txring, inst2, sizeof(inst2) - 1);
/* Poll the receive ring buffer for the ESC (ASCII 27) key */
key = 0;
while (key != 27) {
bytes = Chip_UART_ReadRB(LPC_UARTX, &rxring, &key, 1);
if (bytes > 0) {
/* Wrap value back around */
if (Chip_UART_SendRB(LPC_UARTX, &txring, (const uint8_t *) &key, 1) != 1) {
Board_LED_Toggle(0);/* Toggle LED if the TX FIFO is full */
}
}
}
/* DeInitialize UART0 peripheral */
NVIC_DisableIRQ(UARTx_IRQn);
Chip_UART_DeInit(LPC_UARTX);
return 1;
}
/* Read data from uart */
uint32_t UART_Read(uint8_t *pBuf, uint32_t buf_len)
{
uint16_t cnt = 0;
if(pBuf)
{
cnt = Chip_UART_ReadRB(LPC_USART, &uart_rxrb, pBuf, buf_len);
}
return cnt;
}
/* Read data from uart */
uint32_t uart_read(uint8_t *pbuf, uint32_t buf_len)
{
uint16_t cnt = 0;
uint8_t h1 = 0;
uint8_t h2 = 0;
Chip_UART_ReadRB(LPC_USART, &uart_rxrb, &h1, 1);
if (h1 != AVAM_H1)
return 0;
Chip_UART_ReadRB(LPC_USART, &uart_rxrb, &h2, 1);
if (h2 != AVAM_H2)
return 0;
if (pbuf) {
pbuf[0] = h1;
pbuf[1] = h2;
pbuf += 2;
cnt = Chip_UART_ReadRB(LPC_USART, &uart_rxrb, pbuf, (buf_len - 2));
}
return cnt + 2;
}
void skynetbase_gps_receive_data(void) {
char c;
int bytes = Chip_UART_ReadRB(GPS_UART, &rxring, &c, 1);
if (bytes < 1) return;
if (c == '$') { // beginning
gpsoutpos = 0;
}
else if (c == '*' && gpsoutpos > 0) { // ending, for now ignore checksum
gpsout[gpsoutpos] = 0;
skynetbase_gps_received_data(gpsout, gpsoutpos);
return;
}
gpsout[gpsoutpos++] = c;
}
int uartRecv(ciaaUART_e nUART, void * data, int datalen)
{
uartData_t * u = &(uarts[nUART]);
return Chip_UART_ReadRB(u->uart, u->rrb, data, datalen);
}
int UART_read(void *data, int bytes)
{
return Chip_UART_ReadRB(LPC_USART, &rxring, data, bytes);
}
static void uart_to_ether(uint8_t sock)
{
struct __network_info *net = (struct __network_info *)get_S2E_Packet_pointer()->network_info;
uint8_t sock_state, snd_flag = 0, mask_bit = 0;
uint16_t len = 0;
int ret, uart_read_len = sizeof(g_send_buf);
if(RingBuffer_IsEmpty(&rxring))
return;
/* Serial Trigger Process */
if((trigger_state != TRIG_STATE_NONE) && (trigger_state != TRIG_STATE_READY))
return;
/* UART Packing Size Check */
if(net->packing_size)
mask_bit |= 0x01;
if(RingBuffer_GetCount(&rxring) < net->packing_size)
snd_flag |= 0x01;
else {
if(net->packing_size)
uart_read_len = net->packing_size;
}
/* Nagle Timer Process */
if(net->packing_time)
mask_bit |= 0x02;
if(!nagle_flag && net->packing_time)
snd_flag |= 0x02;
/* Seperator Process */
if(net->packing_delimiter_length) {
mask_bit |= 0x04;
if(!(ret = RingBuffer_SerachPattern(&rxring, 0, net->packing_delimiter, net->packing_delimiter_length)))
snd_flag |= 0x04;
else {
if(!(mask_bit & 0x01) || (snd_flag & 0x01) || (ret + net->packing_data_appendix < net->packing_size)) {
uart_read_len = ret + net->packing_data_appendix;
if(RingBuffer_GetCount(&rxring) < uart_read_len)
snd_flag |= 0x04;
}
}
}
//printf("snd_flag = %02x / mask_bit = %02x\r\n", snd_flag, mask_bit);
if(mask_bit != 0) // mask_bit : Enable Uart Packing Condition bit
if((snd_flag & mask_bit) == mask_bit)
return;
/* Serial Trigger Process */
if(trigger_state == TRIG_STATE_READY)
if(ready_cnt != RingBuffer_GetCount(&rxring))
return;
getsockopt(sock, SO_STATUS, &sock_state);
if(sock_state != SOCK_UDP && sock_state != SOCK_ESTABLISHED)
return;
/* Data Transfer */
len = Chip_UART_ReadRB(UART_DATA, &rxring, &g_send_buf, uart_read_len);
if(len < 0) {
//printf("uart recv error\r\n");
return;
}
uart_recv_cnt += len;
pattern_offset = 0;
if(sock_state == SOCK_UDP) {
uint8_t remote_ip[4];
memcpy(remote_ip, net->remote_ip, sizeof(remote_ip));
ret = sendto(sock, g_send_buf, len, remote_ip, net->remote_port);
if(ret != len) {
//printf("sendto error\r\n");
return;
}
ether_send_cnt += len;
} else if(sock_state == SOCK_ESTABLISHED) {
ret = send(sock, g_send_buf, len);
if(ret != len) {
//printf("send error\r\n");
return;
}
ether_send_cnt += len;
}
nagle_flag = nagle_time = uart_recv_count = 0;
}
/**
* @brief Main UART program body
* @return Always returns 1
*/
int main(void)
{
uint8_t key;
int bytes;
SystemCoreClockUpdate();
Board_Init();
Init_UART_PinMux();
Board_LED_Set(0, false);
/* Before setting up the UART, the global UART clock for USARTS 1-4
must first be setup. This requires setting the UART divider and
the UART base clock rate to 16x the maximum UART rate for all
UARTs. */
#if defined(USE_INTEGER_CLOCK)
/* Use main clock rate as base for UART baud rate divider */
Chip_Clock_SetUARTBaseClockRate(Chip_Clock_GetMainClockRate(), false);
#else
/* Use 128x expected UART baud rate for fractional baud mode. */
Chip_Clock_SetUARTBaseClockRate((115200 * 128), true);
#endif
/* Setup UART */
Chip_UART_Init(LPC_USART);
Chip_UART_ConfigData(LPC_USART, UART_CFG_DATALEN_8 | UART_CFG_PARITY_NONE | UART_CFG_STOPLEN_1);
Chip_UART_SetBaud(LPC_USART, UART_TEST_DEFAULT_BAUDRATE);
/* Optional for low clock rates only: Chip_UART_SetBaudWithRTC32K(LPC_USART, 300); */
Chip_UART_Enable(LPC_USART);
Chip_UART_TXEnable(LPC_USART);
/* Before using the ring buffers, initialize them using the ring
buffer init function */
RingBuffer_Init(&rxring, rxbuff, 1, UART_RB_SIZE);
RingBuffer_Init(&txring, txbuff, 1, UART_RB_SIZE);
/* Enable receive data and line status interrupt */
Chip_UART_IntEnable(LPC_USART, UART_INTEN_RXRDY);
Chip_UART_IntDisable(LPC_USART, UART_INTEN_TXRDY); /* May not be needed */
/* Enable UART interrupt */
NVIC_EnableIRQ(LPC_IRQNUM);
/* Initial message sent using blocking method to prevent ring
buffer overflow */
Chip_UART_SendBlocking(LPC_USART, inst1, sizeof(inst1) - 1);
Chip_UART_SendRB(LPC_USART, &txring, inst2, sizeof(inst2) - 1);
/* Poll the receive ring buffer for the ESC (ASCII 27) key */
key = 0;
while (key != 27) {
bytes = Chip_UART_ReadRB(LPC_USART, &rxring, &key, 1);
if (bytes > 0) {
/* Wrap value back around */
if (Chip_UART_SendRB(LPC_USART, &txring, (const uint8_t *) &key, 1) != 1) {
Board_LED_Toggle(0);/* Toggle LED if the TX FIFO is full */
}
}
}
/* DeInitialize UART peripheral */
NVIC_DisableIRQ(LPC_IRQNUM);
Chip_UART_DeInit(LPC_USART);
return 1;
}
