int main2(void){
FIFO_Init(); // initializes a FIFO that holds 6 elements
for(;;){
Status[0] = FIFO_Get(&GetData[0]); // should fail, empty
Status[1] = FIFO_Put(1); // should succeed, 1
Status[2] = FIFO_Put(2); // should succeed, 1 2
Status[3] = FIFO_Put(3); // should succeed, 1 2 3
Status[4] = FIFO_Put(4); // should succeed, 1 2 3 4
Status[5] = FIFO_Put(5); // should succeed, 1 2 3 4 5
Status[6] = FIFO_Put(6); // should succeed, 1 2 3 4 5 6
Status[7] = FIFO_Put(7); // should fail, 1 2 3 4 5 6
Status[8] = FIFO_Get(&GetData[1]); // should succeed, 2 3 4 5 6
Status[9] = FIFO_Get(&GetData[2]); // should succeed, 3 4 5 6
Status[10] = FIFO_Put(7); // should succeed, 3 4 5 6 7
Status[11] = FIFO_Put(8); // should succeed, 3 4 5 6 7 8
Status[12] = FIFO_Put(9); // should fail, 3 4 5 6 7 8
Status[13] = FIFO_Get(&GetData[3]); // should succeed, 4 5 6 7 8
Status[14] = FIFO_Get(&GetData[4]); // should succeed, 5 6 7 8
Status[15] = FIFO_Get(&GetData[5]); // should succeed, 6 7 8
Status[16] = FIFO_Get(&GetData[6]); // should succeed, 7 8
Status[17] = FIFO_Get(&GetData[7]); // should succeed, 8
Status[18] = FIFO_Get(&GetData[8]); // should succeed, empty
Status[19] = FIFO_Get(&GetData[9]); // should fail, empty
}
}
static void TestCase_StaticMemory(void)
{
FIFO_t MyFifo;
int ret = 0;
T MyT_A, MyT_B, MyT_C;
T MyT;
MyT.sex = 0;
MyT.addr = 0;
MyT.tel = 0;
MyT_A.sex = 1;
MyT_A.addr = 1;
MyT_A.tel = 1;
MyT_B.sex = 2;
MyT_B.addr = 2;
MyT_B.tel = 2;
MyT_C.sex = 3;
MyT_C.addr = 3;
MyT_C.tel = 3;
FIFO_Init(&MyFifo, FIFO_Pool, sizeof(T), ELE_CNT);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
FIFO_Put(&MyFifo, &MyT_A);
FIFO_Put(&MyFifo, &MyT_B);
FIFO_Put(&MyFifo, &MyT_C);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
FIFO_Get(&MyFifo, &MyT);
FIFO_Get(&MyFifo, &MyT);
FIFO_Get(&MyFifo, &MyT);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
FIFO_Put(&MyFifo, &MyT_A);
FIFO_Put(&MyFifo, &MyT_B);
FIFO_Put(&MyFifo, &MyT_C);
ret = FIFO_Flush(&MyFifo);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
}
int main(void){
int useless =0;
int a,b,c;
DisableInterrupts();
PLL_Init(); // 50 MHz I think?
LCD_Open();
ADC_InitSWTriggerSeq3(3);
SysTick_Init();
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOG; // activate port G
useless = 1;
useless =0;
GPIO_PORTG_DIR_R |= 0x04; // make PG2 out (built-in LED)
GPIO_PORTG_AFSEL_R &= ~0x04; // disable alt func on PG2
GPIO_PORTG_DEN_R |= 0x04; // enable digital I/O on PG2
PG2 = 0; // turn off LED
UART_Init();
ADC_Init();
LCD_Clear();
EnableInterrupts();
while(1)
{
if((FIFO_Get() !=1) && getmail==0x2)
{
int i;
int sendme;
flag =0;
//FIFO_Get();
LCD_GoTo(0);
for(i = 0; i <5; i++)
{
FIFO_Get();
sendme = getmail;
LCD_OutChar( sendme);
}
LCD_GoTo(20);
LCD_OutChar(99);
LCD_OutChar(109);
FIFO_Get();
FIFO_Get(); // these two gets just take the blank space and the Stop 0x03 off the FIFO
}
}
}
// Event dispatcher for IV Curve tracer
void IV_Process(void)
{
IV_EVENT_T evt;
if (FIFO_Get(&iv_tracer.events.super, &evt) == FIFO_NOERROR)
FSM_Dispatch (&iv_tracer.super, &evt.super);
}
// return NULL data if data is not available
VOID *ITaskQ_ReadNoBlock( ITaskQ *pThis )
{
VOID *pVal;
Mutex_Lock(&pThis->oLock);
pVal = FIFO_Get(&pThis->oQ);
Mutex_Unlock(&pThis->oLock);
return pVal;
}
void DGBU_INT_handler (void) {
interruptStatus = AT91C_BASE_DBGU->DBGU_CSR;
if(interruptFromTrasmitterRecieved()){
if(FIFO_Get(&fifo, &c) != FIFO_ERROR){
AT91C_BASE_DBGU->DBGU_THR = c;
}else{
turnOffInterrupts();
}
}
AT91C_BASE_AIC->AIC_ICCR = 1 << AT91C_ID_SYS;
}
/****************************************************************************
* DESCRIPTION: Checks for data on the receive UART, and handles errors
* RETURN: none
* ALGORITHM: none
* NOTES: none
*****************************************************************************/
bool RS485_Check_UART_Data(
volatile struct mstp_port_struct_t * mstp_port)
{
/* check for data */
if (!FIFO_Empty(&FIFO_Rx)) {
mstp_port->DataRegister = FIFO_Get(&FIFO_Rx);
mstp_port->DataAvailable = TRUE;
}
return (!FIFO_Empty(&FIFO_Rx));
}
VOID *ITaskQ_Read( ITaskQ *pThis )
{
VOID *pVal;
Mutex_Lock(&pThis->oLock);
pVal = FIFO_Get(&pThis->oQ);
while( pVal == NULL )
{
Mutex_Unlock(&pThis->oLock);
Signal_Pend(pThis->pRead);
Mutex_Lock(&pThis->oLock);
pVal = FIFO_Get(&pThis->oQ);
}
Mutex_Unlock(&pThis->oLock);
return pVal;
}
int main(void){
TExaS_Init();
ADC_Init(); // turn on ADC, set channel to 1
ST7735_InitR(INITR_REDTAB);
PortF_Init();
SysTick_Init(); // This makes things work
UART1_Init();
FIFO_Init();
unsigned char data;
while(1){
while(data != 0x02){
FIFO_Get(&data); // Look for new data byte
}
ST7735_SetCursor(0,0);
for(int i = 0; i<5; i++){ // Print next 5 elements
FIFO_Get(&data);
ST7735_OutChar(data);
}
ST7735_OutString(" cm"); // Print units
}
}
bool rs485_byte_available(
uint8_t * data_register)
{
bool data_available = false; /* return value */
if (!FIFO_Empty(&Receive_Buffer)) {
led_on(LED_1);
*data_register = FIFO_Get(&Receive_Buffer);
data_available = true;
led_off_delay(LED_1, 10);
}
return data_available;
}
/****************************************************************************
* DESCRIPTION: Return true if data is available
* RETURN: true if data is available, with the data in the parameter set
* ALGORITHM: none
* NOTES: none
*****************************************************************************/
bool RS485_DataAvailable(uint8_t * data_register,uint8_t port)
{
bool DataAvailable = false;
if(port == 0)
{
if (!FIFO_Empty(&Receive_Buffer0)) {
if (data_register) {
*data_register = FIFO_Get(&Receive_Buffer0);
}
// timer_elapsed_start(&Silence_Timer);
DataAvailable = true;
}
}
return DataAvailable;
}
/*!RDRF set, data is accepted and does into RxFIFO;TDRE is set, data retrieved into TxFIFO,and sent out*/
void UART_Poll(void)
{
uint8_t RDRF; /*!< a 8 bit RDRF*/
uint8_t TDRE; /*!< a 8 bit RDRF*/
/*make RDRF equal to 00X00000, (XXXXXXXX&00100000 = 00X00000)*/
RDRF = (UART2_S1 & RDRFSET);
/*if 00X00000=00100000,RDRF set, data is put into &RxFIFO*/
if(RDRF == RDRFSET)
FIFO_Put(&RxFIFO, UART2_D);
/*make TDRE equal to X0000000, (XXXXXXXX&10000000 = X0000000)*/
TDRE = (UART2_S1 & TDRESET);
/*if X0000000=10000000,TDRE set, data is taken out of &TxFIFO*/
if(TDRE == TDRESET)
FIFO_Get(&TxFIFO, (uint8_t *)&UART2_D);
}
/*************************************************************************
* DESCRIPTION: Return true if a byte is available
* RETURN: true if a byte is available, with the byte in the parameter
* NOTES: none
**************************************************************************/
bool rs485_byte_available(
uint8_t * data_register)
{
bool data_available = false; /* return value */
if (!FIFO_Empty(&Receive_Buffer)) {
if (data_register) {
*data_register = FIFO_Get(&Receive_Buffer);
}
timer_elapsed_start(&Silence_Timer);
data_available = true;
led_rx_on_interval(10);
}
return data_available;
}
void __attribute__ ((interrupt)) UART_ISR(void)
{
uint8_t RDRF; /*!< a 8 bit RDRF*/
uint8_t TDRE; /*!< a 8 bit RDRF*/
/*make RDRF equal to 00X00000, (XXXXXXXX&00100000 = 00X00000)*/
RDRF = (UART2_S1 & RDRFSET);
/*if 00X00000=00100000,RDRF set, data is put into &RxFIFO*/
if(RDRF == RDRFSET)
FIFO_Put(&RxFIFO, UART2_D);
/*make TDRE equal to X0000000, (XXXXXXXX&10000000 = X0000000)*/
TDRE = (UART2_S1 & TDRESET);
/*if X0000000=10000000,TDRE set, data is taken out of &TxFIFO*/
if(TDRE == TDRESET)
{
if(!FIFO_Get(&TxFIFO, (uint8_t *)&UART2_D)) /*if error*/
UART2_C2 &= ~UART_C2_TIE_MASK; /*disable transmitter interrupt*/
}
}
/* *************************************************************************
DESCRIPTION: Transmits a byte using the UART out the RS485 port
RETURN: none
ALGORITHM: none
NOTES: none
*************************************************************************** */
void RS485_Interrupt_Tx(
void)
{
if (!FIFO_Empty(&FIFO_Tx)) {
TXREG2 = FIFO_Get(&FIFO_Tx);
} else {
/* wait for the USART to be empty */
while (!TXSTA2bits.TRMT);
/* disable this interrupt */
PIE3bits.TX2IE = 0;
/* enable the receiver */
RS485_TX_ENABLE = 0;
RS485_RX_DISABLE = 0;
/* enable the this interrupt */
PIE3bits.RC2IE = 1;
RCSTA2bits.CREN = 1;
}
}
void USART_Echo(void *p_arg)
{
OS_ERR err;
uint32_t recv_length;
(void)p_arg;
USART_SetRecvByteDoneISR(onRecvByteDone);
USART_SetRecvTimeoutISR(onRecvTimeout);
USART_SetSendDoneISR(onSendDone);
while(1)
{
OSTaskSemPend(0, OS_OPT_PEND_BLOCKING, (void*)0, &err);
recv_length = FIFO_Length(&USART_FIFO);
recv_length = FIFO_Get(&USART_FIFO, recv_buffer, recv_length);
USART_Send(recv_buffer, recv_length);
}
}
static void at_fifo_check(void *arg)
{
static uint8_t wait_response_tick = 0;
if(s_module_status == MODULE_START)
{
send_at_command("AT\r\n");
}
else if(MODULE_INIT ==s_module_status|| MODULE_INIT_DONE == s_module_status)
{
if ((NULL == s_current_at_command))
{
if ((!FIFO_isEmpty(&s_at_fifo)) &&(s_at_status == ATC_RSP_FINISH))
{
s_current_at_command = (struct at_cmd_entity*)mymalloc(sizeof(struct at_cmd_entity));
if (FIFO_Get(&s_at_fifo, s_current_at_command->at_name, s_current_at_command->at_cmd))
{
s_at_status = ATC_RSP_WAIT;
send_at_command(s_current_at_command->at_cmd);
}
}
else
{
printf("fifo is empty or the previous at command not complete!\n");
}
}
else
{
printf("the at command is in sending!\n");
if(wait_response_tick > AT_MAX_RESPONSE_TIME)
{
printf("the at command sending is timeout!\n");
}
wait_response_tick++;
}
}
}
uint8_t UARTA0_Receive()
{
return FIFO_Get(&UARTA0_rx_buffer);
}
BOOL UART_InChar(uint8_t * const dataPtr)
{
/*!take out the data from RxFIFO into UART_InChar one by one*/
return FIFO_Get(&RxFIFO,dataPtr);
}
