int platform_s_uart_recv( unsigned id, timer_data_type timeout )
{
u8 buffer;
if( timeout == 0 )
{
if ( UART_Receive(uart[ id ], &buffer, 1, NONE_BLOCKING) == 0 )
return -1;
else
return ( int )buffer;
}
UART_Receive(uart[ id ], &buffer, 1, BLOCKING);
return ( int )buffer;
}
void UART_IntReceive(int which_port)
{
uint8_t tmpc;
uint32_t rLen;
LPC_UART_TypeDef *UARTx;
UARTx=(LPC_UART_TypeDef *)uartDrvDataArray[which_port].reg_base;
while(1){
// Call UART read function in UART driver
rLen = UART_Receive(UARTx, &tmpc, 1, NONE_BLOCKING);
// If data received
if (rLen){
#if 0
/* Check if buffer is more space
* If no more space, remaining character will be trimmed out
*/
if (!__BUF_IS_FULL(rb.rx_head,rb.rx_tail)){
rb.rx[rb.rx_head] = tmpc;
__BUF_INCR(rb.rx_head);
}
#else
uartDrvDataArray[which_port].cb_rcv(&tmpc,rLen);
#endif
}
// no more data
else {
break;
}
}
}
/**
* @brief This function is used to get connection with finger print device
* @param[in] none
* @return connection status
*/
uint8_t BSP_FP_Connect(void)
{
uint8_t i,DataBuf[25]={0},RxBuf[25]={0};
DataBuf[0]=0x7E;
DataBuf[4]=0x01; //command stream to fingerprint
DataBuf[24]=0x01; //0x7e,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
UART_Transmit(&DataBuf,25,10);
UART_Receive(&RxBuf,25,100);
/**
*RxBuf[4]==0x01 : Received command must be same as transmitted command
*RxBuf[8]==0x01 : Stands for successful execution of transmitted command
*If not executed successfully RxBuf[8] is used to determine error status
*/
if((RxBuf[4] == 0x01) && (RxBuf[8] == 0x01))
{
return(RESULT_SUCCEEDED);
}
else
{
return(RxBuf[8]);
}
}
/*************************************************************
Function: uint32_t UARTReceive(LPC_UART_TypeDef *UARTPort, uint8_t *rxbuf, uint32_t buflen)
Description: UART数据接收函数，读取UART FIFO中数据
Calls: UART_Receive
Called By: UARTx_IRQHandler
Input: UARTPort 指定UART端口
buflen 暂未使用
Output: rxbuf 指定接收缓冲区
Return: 接收到的数据长度
Others: 无
*************************************************************/
uint32_t UARTReceive ( LPC_UART_TypeDef *UARTPort, uint8_t *rxbuf, uint32_t buflen )
{
uint8_t tmpc;
uint32_t rLen, bytes;
bytes = 0 ;
while ( 1 )
{
// Call UART read function in UART driver
rLen = UART_Receive ( UARTPort, &tmpc, 1, NONE_BLOCKING );
// If data received
if ( rLen )
{
*rxbuf = tmpc;
rxbuf++;
bytes++;
}
// no more data
else
{
break;
}
}
return bytes;
}
//发生接收中断时调用，基本上是发生8字节中断后调用，或者超时后调用
void UART_IntReceive(void)
{
uint8_t rlen;//接收数据的长度
uint8_t chars[16];
uint8_t index = 0;
//接收一个字符
rlen = UART_Receive((LPC_UART_TypeDef *)_LPC_UART,chars,16,NONE_BLOCKING);
for(index=0;index<rlen;index++)
{
//my_printf("%d ",chars[index]);
if(! ISBufFull(&bufSerialRec))
{
//如果缓冲区未满
BufPush(&bufSerialRec,chars[index]);
}
//获得包结束位
if(chars[index] == PACKET_EOI)
{
//UART_Send((LPC_UART_TypeDef *)_LPC_UART,chars,index,BLOCKING);
if(!ISBufEmpty(&bufSerialRec))
{
OSSemPost(semSerialCommand);
}
}
}
}
uint8_t BSP_FP_DeleteAll(void)
{
uint8_t DataBuf[25]={0},RxBuf[25]={0};
DataBuf[0]=0x7e;
DataBuf[4]=0x23; //command stream to fingerprint
DataBuf[24]=0x23; //0x7e,0,0,0,0x37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x37
UART_Transmit(&DataBuf,25,10); //send command
UART_Receive(&RxBuf,25,5000); //receive acknoledgement
/**
*RxBuf[4]==0x23 : Received command must be same as transmitted command
*RxBuf[8]==0x01 : Stands for successful execution of transmitted command
*If not executed successfully RxBuf[8] is used to determine error status
*/
if((RxBuf[4] == 0x23) && (RxBuf[8] == 0x01))
{
return(RESULT_SUCCEEDED);
}
else
{
return(RxBuf[8]);
}
}
void tempinit() {
UART_Receive(&TempUart, UartRom, 8);
UART_ClearFlag(&TempUart,
(XMC_UART_CH_STATUS_FLAG_RECEIVER_START_INDICATION
| XMC_UART_CH_STATUS_FLAG_ALTERNATIVE_RECEIVE_INDICATION));
UART_TransmitWord(&TempUart, 6); //startet übertragung vom arduino
}
// Function __readc() / __sys_readc
//
// Called by bottom level of scanf routine within RedLib C library to read
// a character. With the default semihosting stub, this would read the character
// from the debugger console window (which acts as stdin). But this version reads
// the character from the LPC1768/RDB1768 UART.
int __sys_readc (void)
{
/*-- UARTGetChar --*/
uint8_t tmp = 0;
UART_Receive(DEBUG_UART_PORT, &tmp, 1, BLOCKING);
return (int) tmp;
}
/********************************************************************//**
* @brief UART receive function (ring buffer used)
* @param[in] None
* @return None
*********************************************************************/
static void UART_IntReceive(void)
{
uint8_t tmpc;
uint32_t rLen;
while (1)
{
// Call UART read function in UART driver
rLen = UART_Receive(TEST_UART, &tmpc, 1, NONE_BLOCKING);
// If data received
if (rLen)
{
/* Check if buffer is more space
* If no more space, remaining character will be trimmed out
*/
if (!__BUF_IS_FULL(rb.rx_head,rb.rx_tail))
{
rb.rx[rb.rx_head] = tmpc;
__BUF_INCR(rb.rx_head);
}
}
// no more data
else
{
break;
}
}
}
/*-----------------------------------------------------------------------------
* Receive Call-back dispatch for UART driver
*-----------------------------------------------------------------------------*/
void UartRxCallBack(void)
{
uint8_t tmpc, len;
len = UART_Receive(UARTInfo.pUart, &tmpc, 1, NONE_BLOCKING);
if ((!__BUF_FULL(BufRx)) && len) {
__BUF_WR(BufRx, tmpc);
}
}
uint8_t comm_get2(int name){
(void)name; /* avoid warning */
uint8_t buffer[2], len;
while (len == 0){
len = UART_Receive(LPC_UART0, buffer, sizeof(buffer), NONE_BLOCKING);
}
return buffer;// buffer;
}
uint8_t comm_gets(void){
uint8_t buffer[100];
uint32_t len;
while (len == 0){
len = UART_Receive(LPC_UART0, buffer, sizeof(buffer), NONE_BLOCKING);
}
return buffer;
}
uint8_t BSP_FP_List(uint8_t *database, uint8_t *count)
{
uint8_t DataBuf[25]={0},RxBuf[25]={0},XtraBuf[998]={0},i,t;
DataBuf[0]=0x7E;
DataBuf[4]=0x30; //command stream to fingerprint
DataBuf[24]=0x30; //0x7e,0,0,0,0x12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x12
UART_Transmit(&DataBuf,25,10); //send command
UART_Receive(&RxBuf,25,5000); //receive acknowledgment
UART_Receive(&XtraBuf,(RxBuf[16]+4),5000); //receive acknowledgment
*count=0;
for(i=0;i<100;i++)
database[i]=0;
if(RxBuf[16]>8)
{
for(i=4;i<(RxBuf[16]);i+=10)
{
t=((XtraBuf[i+2]-0x30)*10+(XtraBuf[i+3]-0x30));
database[t]=1; //storing database.
*count=*count+1;
}
}
/**
*RxBuf[4]==0x30 : Received command must be same as transmitted command
*RxBuf[8]==0x01 : Stands for successful execution of transmitted command
*If not executed successfully RxBuf[8] is used to determine error status
*/
if((RxBuf[4] == 0x30) && (RxBuf[8] == 0x01))
{
return(RESULT_SUCCEEDED);
}
else
{
return(RxBuf[8]);
}
}
void uartTask(void *data)
{
data = data;
while (1) {
uint32_t bytes_received;
uint8_t c;
bytes_received = UART_Receive(LPC_UART, &c, 1, NONE_BLOCKING);
if (bytes_received > 0) {
HandleInputChar(c);
}
}
}
void handleReceiveInterrupt() {
while(!QUEUE_FULL(uint8_t, &listener.serial->receiveQueue)) {
uint8_t byte;
uint32_t received = UART_Receive(UART1_DEVICE, &byte, 1, NONE_BLOCKING);
if(received > 0) {
QUEUE_PUSH(uint8_t, &listener.serial->receiveQueue, byte);
if(QUEUE_FULL(uint8_t, &listener.serial->receiveQueue)) {
pauseReceive();
}
} else {
break;
}
}
}
void GPS_print()
{
// Print the UART output straight to the terminal screen
char receive;
while(1){
// For all time
receive = UART_Receive();
if (receive > 0){
usb_serial_putchar(receive);
// Send it back to the computer to print in the console
}
}
}
uint8_t comm_get(void){
#if 0
// xprintf("%s{\n",__func__);
uint8_t tmp = 0;
UART_Receive(LPC_UART0, &tmp, 1, BLOCKING);
return(tmp);
#endif
#if 1
uint8_t buffer[1], len;
while (len == 0){
len = UARTReceive(LPC_UART0, buffer, 1);
}
UART_LINE_LEN=0;
UART_LINE[0]='\0';
return buffer;
#endif
}
void UART_Main()
{
if(UART->RxGO)
{
UART->RxGO=0;
UART_Receive();
setSegmentDisplayNumber(UART->RxData[5]);
RCIE=1;
}
else
{
if(UART->TxGO)
{
UART->TxGO=0;
UART_Transmit();
}
}
}
uint8_t BSP_FP_Delete(uint8_t *id)
{
uint8_t checksum= 0xc0,DataBuf[25]={0},RxBuf[25]={0};
int8_t i=0;
DataBuf[0]=0x7E;
DataBuf[4]=0x22;
DataBuf[16]=0x0A; //command stream to fingerprint
DataBuf[24]=0x2C; //0x7e,0,0,0,0x22,0,0,0,0,0,0,0,0,0,0,0,0x0a,0,0,0,0,0,0,0,0x2c
UART_Transmit(&DataBuf,25,10);
for(i=3;i>=0;i--)
{
uprintf("%c",id[i]); //send ascii value of id no. digit by digit
checksum+=id[i] - 0x30;
}
for(i=0;i<9;i++)
{
uprintf("%c",0x0); //send command
}
uprintf("%c",checksum); //send checksum
UART_Receive(&RxBuf,25,5000); //receive acknowledgment
/**
*RxBuf[4]==0x22 : Received command must be same as transmitted command
*RxBuf[8]==0x01 : Stands for successful execution of transmitted command
*If not executed successfully RxBuf[8] is used to determine error status
*/
if((RxBuf[4] == 0x22) && (RxBuf[8] == 0x01))
{
return(RESULT_SUCCEEDED);
}
else
{
return(RxBuf[8]);
}
}
/********************************************************************//**
* @brief UART receive function (ring buffer used)
* @param[in] None
* @return None
*********************************************************************/
void UART1_IntReceive(void)
{
uint8_t tmpc;
uint32_t rLen;
while (1){
// Call UART read function in UART driver
rLen = UART_Receive((LPC_UART_TypeDef *)LPC_UART1, &tmpc, 1, NONE_BLOCKING);
// If data received
if (rLen){
/* If buffer will be full and RTS is driven manually,
* RTS pin should be forced into INACTIVE state
*/
#if (AUTO_RTS_CTS_USE == 0)
if (__BUF_WILL_FULL(rb.rx_head, rb.rx_tail))
{
if (RTS_State == ACTIVE)
{
// Disable request to send through RTS line
UART_FullModemForcePinState(LPC_UART1, UART1_MODEM_PIN_RTS, \
INACTIVE);
RTS_State = INACTIVE;
}
}
#endif
/* Check if buffer is more space
* If no more space, remaining character will be trimmed out
*/
if (!__BUF_IS_FULL(rb.rx_head,rb.rx_tail)){
rb.rx[rb.rx_head] = tmpc;
__BUF_INCR(rb.rx_head);
}
}
// no more data
else {
break;
}
}
}
void TurnOnRelays()
{
unsigned char T = 0;
// wait for command input
while (!(T))
{
T = UART_Receive();
}
if(T == '4')
PORTB = PORTB | 0b00000001;
else if(T == '3')
PORTB = PORTB | 0b00000010;
else if(T == '2')
PORTB = PORTB | 0b00000100;
else if(T == '1')
PORTB = PORTB | 0b00001000;
EvaluateStatus(FORCE_UPDATE);
}
int _UARTSendandReceive(uint8_t * args)
{
int n;
uint8_t * arg_ptr;
uint8_t txbuf[13], rxbuf[18];
uint32_t txbuflen=13, rxbuflen=18, length;
for(n=0;n<txbuflen;n++)
{
if ((arg_ptr = (uint8_t *) strtok(NULL, " ")) == NULL) return 1;
txbuf[n] = (uint8_t) strtoul((char *) arg_ptr, NULL, 16);
}
UART_Send((LPC_UART_TypeDef*) LPC_UART1, txbuf, txbuflen, BLOCKING);
//Reception
length = UART_Receive((LPC_UART_TypeDef*) LPC_UART1, rxbuf, rxbuflen, NONE_BLOCKING);
sprintf((char *) str, "%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x\r\n", rxbuf[0], rxbuf[1], rxbuf[2], rxbuf[3], rxbuf[4], rxbuf[5],rxbuf[6], rxbuf[7], rxbuf[8], rxbuf[9], rxbuf[10], rxbuf[11], rxbuf[12], rxbuf[13], rxbuf[14], rxbuf[15], rxbuf[16], rxbuf[17]);
writeUSBOutString(str);
return 0;
}
void GPS_parse(struct GPS_info_struct *GPS_data)
{
//declare variables
char receive, rec_G, rec_P;
char rec_1, rec_2, rec_3;
int8_t RMC_check = -1;
int8_t VTG_check = -1;
while(1) // we want to continue to receive data until we are happy with what we have
{
// switch LED on to indicate we are in loop
PORTB |= (1 << 2);
// continue to receive data until we are at the start of a NMEA sentence (with $)
receive = UART_Receive();
if((receive > 0) && receive == '$')
{
// The first two characters should be GP, if this is not true continue to cycle data
rec_G = UART_Receive();
rec_P = UART_Receive();
if((rec_G == 'G') && (rec_P == 'P'))
{
// Now receive the next three characters - this will tell us what data we are now receiving
rec_1 = UART_Receive();
rec_2 = UART_Receive();
rec_3 = UART_Receive();
if((rec_1 == 'R') && (rec_2 == 'M') && (rec_3 == 'C'))
RMC_check = GPS_RMC(GPS_data); // This contains recommended core minimum data
else if((rec_1 == 'V') && (rec_2 == 'T') && (rec_3 == 'G'))
VTG_check = GPS_VTG(GPS_data); // This contains speed and course information
// else if((rec_1 == 'G') && (rec_2 == 'G') && (rec_3 == 'A')) // This contains altitude as well as RMC information - not required for this project
// else if((rec_1 == 'G') && (rec_2 == 'S') && (rec_3 == 'A')) // This contains sattelite information - not required for project
// else if((rec_1 == 'G') && (rec_2 == 'S') && (rec_3 == 'V')) // More sattelite information, again note required for project
// else if((rec_1 == 'G') && (rec_2 == 'L') && (rec_3 == 'L')) // Repeat of long/lat/time - already aquired with RMC
// else // not recognised loop
if(RMC_check == 0 && VTG_check == 0) // we are happy with the data to send out
{
PORTB &= ~(1 << 2);
break;
}
}
}
}
}
// determine command by header character
void AcceptCommands()
{
unsigned char Temp = 0;
// wait for command input
while (!(Temp))
{
Temp = UART_Receive();
EvaluateStatus(UPDATE_ONLY_ON_CHANGE);
}
// process command input by inspecting header character
if (Temp == '?')
{
EvaluateStatus(FORCE_UPDATE);
}
else if (Temp == '=')
{
ControlRelays();
}
else if (Temp == '+')
{
TurnOnRelays();
}
else if (Temp == '-')
{
TurnOffRelays();
}
else if (Temp == 'v')
{
PrintWelcome();
}
else
{
// unknown command
PrintError();
}
}
void UART0_IRQHandler(void)
{
uint8_t tmpc;
uint32_t tmp, tmp1;
tmp = ((LPC_UART0->IIR) & UART_IIR_BITMASK) & UART_IIR_INTID_MASK;
if (tmp == UART_IIR_INTID_RLS) // Receive Line Status
{
tmp1 = UART_GetLineStatus(UART_0);// Check line status
tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE | UART_LSR_BI | UART_LSR_RXFE);// Mask out the Receive Ready and Transmit Holding empty status
}
if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)) // Receive Data Available or Character time-out
{
UART_Receive(UART_0, &tmpc, 1, NONE_BLOCKING);
if(tmpc >= GUI_KEY_MENU && tmpc <= GUI_KEY_PGDOWN)
{
isKeyTrigged = 1;
switch(tmpc)
{
case GUI_KEY_TRACE_ENABLE:
break;
case GUI_KEY_TRACE_DISABLE:
break;
default:
GUI_StoreKeyMsg(tmpc, 1);
break;
}
}
else if(tmpc >= 0x80 && tmpc <(0x80+21))
{
GUI_StoreKeyMsg(GUI_KEY_RELEASE, 1);
}
else
{
}
}
}
void CheckMasterCommand(void)
{
uint16 CRC=0;
pDataIn = UART_Receive(&SizeIn);
if (pDataIn != NULL)
{
pDataOut = UART_GetSendBuf();
pDataOut[0] = UART_SA_CHAR;
if(ProcessMasterCommand(pDataIn, SizeIn, pDataOut+1, &SizeOut) )
{
CRC = CalcCRC16(&pDataOut[1], SizeOut);
SizeOut++;
pDataOut[SizeOut++] = CRC & 0xFF;
pDataOut[SizeOut++] = CRC >> 8;
UART_SendAnswer(SizeOut);
}
/********************************************************************//**
* @brief UART receive function (ring buffer used)
* @param[in] None
* @return None
*********************************************************************/
void UART_IntReceive(void)
{
uint8_t tmpc;
uint32_t rLen;
/*
if(RX_TOG)
GPIO_SetValue(LED_3_PORT, LED_3_BIT);
else
GPIO_ClearValue(LED_3_PORT, LED_3_BIT);
RX_TOG=!RX_TOG;
*/
while(1){
// Call UART read function in UART driver
rLen = UART_Receive((LPC_UART_TypeDef *)LPC_UART0, &tmpc, 1, NONE_BLOCKING);
// If data received
if (rLen){
UART_LINE[UART_LINE_LEN++]=tmpc;
if((tmpc=='\r')||(tmpc=='\n')){
LINE_READY = 1;
UART_LINE[UART_LINE_LEN-1]='\0';
UART_LINE_LEN=0;
}
/* Check if buffer is more space
* If no more space, remaining character will be trimmed out
*/
if (!__BUF_IS_FULL(rb.rx_head,rb.rx_tail)){
rb.rx[rb.rx_head] = tmpc;
__BUF_INCR(rb.rx_head);
}
}
// no more data
else {
break;
}
}
}
uint32_t serialRecv(uint8_t* rxbuf, uint32_t len) {
return(UART_Receive(LPC_UART3, rxbuf, len, BLOCKING));
}
uint32_t board_uart_recv(uint8_t *p_buffer, uint32_t length)
{
return UART_Receive((LPC_USARTn_Type*) LPC_USART0, p_buffer, length, BLOCKING);
}
/*********************************************************************//**
* @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;
}
