/****************************************************************************
* Name : USBInterfaceTransmitTask *
* *
* Inputs : None *
* Outputs : None *
* Returns : None *
* *
* Description : This is a Transmit Task which handles all the USB *
* Transmissions. *
* 1. It pends on the event for start of USB transmission *
* 2. It calls the USB stack functions to Transmit the data *
* on USB PHY and wait (block) till the Transmission *
* completes or Timeout or error event. *
* 3. On completetion of transmission it resets teh USB *
* interface layer states to RX_ENB to receive new geni *
* Request. *
* *
*****************************************************************************
*/
void USBInterfaceTransmitTask(void)
{
GF_UINT32 telegram_length = 0;
GF_UINT32 packet_length = 0;
GF_UINT32 tx_index = 0;
/* USB Buffer (FU) Enable. After this register setting HOST can detect
the USBFU. Also Attach the USB to the USB PHY. */
GENI_USBSIGCTRL = 0x000C;
GENI_GPMODE1 |= 0x0030;
GENI_GPDATA0 &= 0xFBFF;
while (1)
{
/* Wait for transmit start event */
OS_WaitEvent(USB_TXSETUP_EVENT);
usb_int_state = TX_START;
usb_tx_index = 0;
while (usb_int_state != TX_DONE)
{
SendTxByte(USB_CH_NO);
}
/* Obtain total length */
telegram_length = usb_tx_index;
for (tx_index = 0; tx_index < telegram_length; tx_index += 64)
{
packet_length = telegram_length - tx_index;
packet_length = (packet_length > 64) ? 64 : packet_length;
usb_tx_idle_active = FALSE;
usb_tx_idle_cnt = usb_tx_idle_cnt_reset_value * 2; // restart Idle countdown
usb_tx_idle_active = TRUE;
USB_CDC_WriteTimed(&cdc_tx_buff_p[tx_index], packet_length, USB_TX_WAIT_TIME);
}
}
}
void TestTask2(void)
{
uint32_t ts,te;
uint32_t i,j;
uint16_t t;
while(1)
{
switch(testcase)
{
case 0:
// Task Priority
assert(testvar ==2);
testvar++;
break;
case 1:
// Timer / Wait
OS_WaitTicks(OSALMTest2, 2);
t=50;
OS_GetTicks(&i); // get time
OS_WaitTicks(OSALMTest2, t);
OS_GetTicks(&j); // get time
assert(j-i == t); // waited time was correct
break;
case 2:
// WaitEvent
// SetEvent
break;
case 3:
// MutexGet
// MutexRelease
// two cases:
// 1:mutex is occupied by higher prio
WasteOfTime(10);
OS_MutexGet(0);
testvar = 7;
WasteOfTime(50);
assert(testvar == 7);
OS_MutexRelease(0);
OS_SetEvent(OSTestTskID1,1<<1);
// 2:mutex is occupied
OS_MutexGet(0);
testvar = 4;
WasteOfTime(50);
assert(testvar == 4);
OS_MutexRelease(0);
break;
case 4:
// QueueIn
// QueueOut
break;
case 5:
// SetAlarm
// WaitAlarm
OS_GetTicks(&ts);
OS_WaitAlarm(OSALMTest2);
OS_GetTicks(&te);
assert(te-ts == 44);
break;
case 6:
// Event with timeout
break;
case 7:
// long queue
break;
default:
break;
}
OS_WaitEvent(1<<7);
}// while(1)
}
void TestTask1(void)
{
uint8_t ret,i;
uint32_t ts,te;
uint8_t v;
uint16_t t=25;
uint32_t ti,tj;
while(1)
{
switch(testcase)
{
case 0:
// Task Priority
assert(testvar ==1);
testvar++;
break;
case 1:
OS_WaitTicks(OSALMTest1, 1);
// Timer / Wait
OS_GetTicks(&ti); // get time
OS_WaitTicks(OSALMTest1, t);
OS_GetTicks(&tj); // get time
assert(tj-ti == t); // waited time was correct
break;
case 2:
// WaitEvent
// SetEvent
// wait for A, then A occurs
testvar=1;
OS_WaitEvent(1<<0);
testvar=2;
// A occurs, then wait for A
WasteOfTime(50);
assert(testvar==3);
OS_WaitEvent(1<<0);
testvar=4;
// wait for more events, one occurs, then the other
ret = OS_WaitEvent(1<<1 | 1<<2);
testvar=5;
assert(ret == (1<<2));
testvar=6;
ret = OS_WaitEvent(1<<1 | 1<<2);
testvar=7;
assert(ret == (1<<1));
testvar=8;
// wait for less events
break;
case 3:
// MutexGet
// MutexRelease
// two cases:
// 1:mutex is free
OS_MutexGet(0);
WasteOfTime(50);
testvar = 1;
OS_WaitTicks(OSALMTest1, 50);
assert(testvar == 1);
OS_MutexRelease(0);
OS_WaitEvent(1<<1);
// 2:mutex is occupied by lower prio
OS_WaitTicks(OSALMTest1, 50);
OS_MutexGet(0);
testvar = 3;
WasteOfTime(50);
assert(testvar == 3);
OS_MutexRelease(0);
break;
case 4:
// QueueIn
// QueueOut
TestQ.read = 13; // tweak the queue to a "used" state
TestQ.write =13;
ret = OS_QueueOut(&TestQ,&v); // q empty at start
assert(ret == 1);
OS_WaitEvent(1<<6);
for (i=0;i<20;i++) // forward
{
ret = OS_QueueOut(&TestQ,&v);
assert(v==i);
assert(ret ==0);
}
// Q empty
ret = OS_QueueOut(&TestQ,&v);
//assert(v==i);
assert(ret ==1);
OS_WaitEvent(1<<6);
for (i=20;i>0;i--) // backward
{
ret = OS_QueueOut(&TestQ,&v);
assert(v==i);
assert(ret ==0);
}
// Q empty
ret = OS_QueueOut(&TestQ,&v);
assert(ret ==1);
//OS_WaitEvent(1<<6);
break;
case 5:
// SetAlarm
// WaitAlarm
OS_GetTicks(&ts);
OS_WaitAlarm(OSALMTest1);
OS_GetTicks(&te);
assert(te-ts == 53);
break;
case 6:
// Event with timeout
ret = OS_WaitEventTimeout(1<<3,OSALMTest1, 30);
assert(ret == 1<<3); // no timeout, it was the event.
OS_GetTicks(&ti); // get time
ret = OS_WaitEventTimeout(1<<3,OSALMTest1, t); // wait for the event, which never comes...
assert(ret == 0); // timeout recoginzed
OS_GetTicks(&tj); // get time
assert(tj-ti == t); // waited time was correct
break;
case 7:
// long queue
break;
default:
break;
}
OS_WaitEvent(1<<7);
}// while(1)
}
void GUI_X_WaitEvent(void) {
_pGUITask = OS_GetpCurrentTask();
OS_WaitEvent(1);
}
