void playSong(void* pdata)
{
fprintf(lcd, "%c%s", esc, LCD_CLR);
fprintf(lcd, "%c%s%s\n", esc, TOP_LINE, "KEYBOARD MODE");
fprintf(lcd, "%c%s%s\n", esc, BOTTOM_LINE, "KEYBOARD MODE");
while (1)
{
INT8U err;
OSSemPend(songSem,0,&err);
fprintf(lcd, "%c%s", esc, LCD_CLR);
fprintf(lcd, "%c%s%s\n", esc, TOP_LINE, "NOW PLAYING TETRIS THEME A");
fprintf(lcd, "%c%s%s\n", esc, BOTTOM_LINE, "NOW PLAYING TETRIS THEME A");
INT8U value = IORD_ALTERA_AVALON_PIO_DATA(SWITCHES_BASE);
if (value & 1)
{
if (err==OS_ERR_PEVENT_NULL){
printf("PEVENT NULL");
}
if (err==OS_ERR_EVENT_TYPE){
printf("EVENT TYPE");
}
if (err) printf("%d, %d", err, OS_NO_ERR);
int note0[] = { 71,-1,68,69,71,-1,69,67,
64,-1,64,69,72,-1,71,69,
68,-1,-1,69,71,-1,72,-1,
69,-1,64,-1,64,-1,-1,-1,
0,65,-1,69,72,-1,71,69,
67,-1,-1,64,67,-1,65,64,
68,-1,-1,69,71,-1,72,-1,
69,-1,64,-1,64,-1,0,0 };
int note1[] = { 76,-1,76,72,74,-1,72,71,
69,-1,69,72,76,-1,74,72,
71,-1,-1,72,74,-1,76,-1,
72,-1,69,-1,69,-1,-1,-1,
0,74,-1,77,81,-1,79,77,
76,-1,-1,72,76,-1,74,72,
71,-1,-1,72,74,-1,76,-1,
72,-1,69,-1,69,-1,0,0};
int i;
for (i=0;i<64;i++){
if (note0[i] == -1){
//do nothing
}else if (note0[i] == 0){
*note_table[0] = 0;
}else{
*note_table[0] = (120 << 12) | (INT8U) note0[i];
}
if (note1[i] == -1){
//do nothing
}else if (note1[i] == 0){
*note_table[1] = 0;
}else{
*note_table[1] = (120 << 12) | (INT8U) note1[i];
}
OSTimeDlyHMSM(0, 0, 0, 250);
}
for (i=0;i<64;i++){
if (note0[i] == -1){
//do nothing
}else if (note0[i] == 0){
*note_table[0] = 0;
}else{
*note_table[0] = (120 << 12) | (INT8U) note0[i];
}
if (note1[i] == -1){
//do nothing
}else if (note1[i] == 0){
*note_table[1] = 0;
}else{
*note_table[1] = (120 << 12) | (INT8U) note1[i];
}
OSTimeDlyHMSM(0, 0, 0, 250);
}
}
fprintf(lcd, "%c%s", esc, LCD_CLR);
fprintf(lcd, "%c%s%s\n", esc, TOP_LINE, "KEYBOARD MODE");
fprintf(lcd, "%c%s%s\n", esc, BOTTOM_LINE, "KEYBOARD MODE");
OSSemPend(songSem,0,&err);
fprintf(lcd, "%c%s%s\n", esc, TOP_LINE, "NOW PLAYING STAIRWAY TO HEAVEN");
fprintf(lcd, "%c%s%s\n", esc, BOTTOM_LINE, "NOW PLAYING STAIRWAY TO HEAVEN");
if (value & 1)
{
if (err==OS_ERR_PEVENT_NULL){
printf("PEVENT NULL");
}
if (err==OS_ERR_EVENT_TYPE){
printf("EVENT TYPE");
}
if (err) printf("%d, %d", err, OS_NO_ERR);
int note0[] = {0,60,64,69,71,64,60,71,
72,64,60,72,66,62,57,66,
64,60,57,60,-1,64,60,57,
55,57,57,-1,-1,-1,0,0,
0,60,64,69,71,64,60,71,
72,64,60,72,66,62,57,66,
64,60,57,60,-1,64,60,57,
55,57,57,-1,-1,-1,0,0,
-1,52,55,64,66,62,57,65,
64,60,57,64,62,60,-1,-1,
60,55,52,60,67,59,55,67,
57,57,57,-1,-1,-1,0,0};
int note1[] = {57,-1,-1,-1,56,-1,-1,-1,
55,-1,-1,-1,54,-1,-1,-1,
53,-1,-1,-1,-1,-1,-1,-1,
47,45,45,-1,-1,45,53,52,
45,-1,-1,-1,56,-1,-1,-1,
55,-1,-1,-1,54,-1,-1,-1,
53,-1,-1,-1,-1,-1,-1,-1,
47,45,45,-1,-1,-1,45,47,
48,-1,-1,-1,50,-1,-1,-1,
53,-1,-1,-1,45,-1,45,47,
48,-1,-1,-1,43,-1,-1,-1,
50,50,50,-1,-1,-1,0,0};
int i;
for (i=0;i<96;i++){
if (note0[i] == -1){
//do nothing
}else if (note0[i] == 0){
*note_table[0] = 0;
}else{
*note_table[0] = (120 << 12) | (INT8U) note0[i];
}
if (note1[i] == -1){
//do nothing
}else if (note1[i] == 0){
*note_table[1] = 0;
}else{
*note_table[1] = (120 << 12) | (INT8U) note1[i];
}
OSTimeDlyHMSM(0, 0, 0, 600);
}
}
fprintf(lcd, "%c%s", esc, LCD_CLR);
fprintf(lcd, "%c%s%s\n", esc, TOP_LINE, "KEYBOARD MODE");
fprintf(lcd, "%c%s%s\n", esc, BOTTOM_LINE, "KEYBOARD MODE");
}
}
/* 按键按下，写入EEPROM */
void Task_USART1(void *p_arg)
{
(void)p_arg; //'p_arg'没有用到，防止编译器警告
while(1)
{
unsigned char errkey, err;
// u16 i;
// printf("等待A8");
/* car1经过 */
OSSemPend(key_SEM,0,&errkey);
//将car1数据保存至buffer并串口输出
weight = (char*)OSMboxPend(adc_MBOX,0,&err);
save_in_buffer(car1,*weight);
/* 读写EEPROM */
//将I2c_Buf_Write中顺序递增的数据写入EERPOM中
I2C_EE_BufferWrite((u8 *)sendData, EEP_Firstpage, 256);
OSTimeDlyHMSM(0,0,0,500);
/* car2经过 */
OSSemPend(key_SEM,0,&errkey);
//将car1数据保存至buffer并串口输出
weight = (char*)OSMboxPend(adc_MBOX,0,&err);
save_in_buffer(car2,*weight);
/* 读写EEPROM */
//将I2c_Buf_Write中顺序递增的数据写入EERPOM中
I2C_EE_BufferWrite((u8 *)sendData, EEP_Firstpage, 256);
OSTimeDlyHMSM(0,0,0,500);
/* car3经过 */
OSSemPend(key_SEM,0,&errkey);
//将car1数据保存至buffer并串口输出
weight = (char*)OSMboxPend(adc_MBOX,0,&err);
save_in_buffer(car3,*weight);
/* 读写EEPROM */
//将I2c_Buf_Write中顺序递增的数据写入EERPOM中
I2C_EE_BufferWrite((u8 *)sendData, EEP_Firstpage, 256);
OSTimeDlyHMSM(0,0,0,500);
// printf("\n\r读出eeprom的数据\n\r");
//将EEPROM读出数据顺序保持到I2c_Buf_Read中
// I2C_EE_BufferRead(I2c_Buf_Read, EEP_Firstpage, 256);
//将I2c_Buf_Read中的数据通过串口打印
// for (i=0; i<=50; i++)
// {
// printf("%c", I2c_Buf_Read[i]);
// }
// OSTimeDlyHMSM(0,0,0,500);
}
}
void GPSNET_FOTA_Task(void)
{
// task setup
LATITUDE latitude;
LONGITUDE longitude;
INT32U i = 0;
INT32U j = 0;
INT32U endereco_bw;
INT8U type = 0;
INT8U confirma=0;
INT8U error=0;
INT8U nerror=0;
INT8U confirma_rede_error = 0;
INT8U *boot_end_status;
static INT16U linhas;
static INT16U linhas2;
if (OSSemCreate(0,&Confirma) != ALLOC_EVENT_OK)
{
while(1){};
};
if (OSSemCreate(0,&Bootloader_Event) != ALLOC_EVENT_OK)
{
while(1){};
};
if (OSMboxCreate(&Bootloader_end,NULL) != ALLOC_EVENT_OK)
{
while(1){};
}
// task main loop
for (;;)
{
// Wait event from APP layer, no timeout
OSSemPend(Bootloader_Event,0);
// Set target node address
UserEnterCritical();
latitude.x = GPS_X_tmp.int32u;
longitude.y = GPS_Y_tmp.int32u;
UserExitCritical();
linhas = 0;
linhas2 = 0;
endereco_bw = CODE_START;
for(;;)
{
/* loop to read a line of code */
for(i=0;i<VECTOR32_SIZE;i++)
{
// return 32-bit words
data_checksum[i]=Flash_Read(endereco_bw);
bootloader_datal[i] = data_checksum[i];
endereco_bw+=4;
}
linhas++;
j=0;
type = (INT8U)(bootloader_data[2]); // get line type
if(type==7)
{
bootloader_data[15] = (INT8U)((CRC_CODIGO_16>>8) & 0xFF);
bootloader_data[16] = (INT8U)((CRC_CODIGO_16) & 0xFF);
bootloader_data[17] = (INT8U)((CRC_CODIGO_162>>8) & 0xFF);
bootloader_data[18] = (INT8U)((CRC_CODIGO_162) & 0xFF);
endereco_bw = CODE_START;
}
error = 0;
nerror = 0;
confirma_rede_error = 0;
envia_de_novo:
UserEnterCritical();
confirma_rede = 0;
//mensagem = 0;
UserExitCritical();
// send a line of code
i = NetSimpledataXY(UP_ROUTE, &latitude, &longitude, &bootloader_data[0]);
if(i==OK)
{
error = 0;
// wait for send to complete - SIGNAL_TIMEOUT ms
i = OSSemPend (Confirma, SIGNAL_TIMEOUT);
if(confirma_rede == DATA_OK)
{
confirma_rede_error = 0;
linhas2++;
if(type==7)
{
type=0;
endereco_bw = CODE_START;
//UserEnterCritical();
//mensagem = confirma_rede;
//UserExitCritical();
boot_end_status = (INT8U*)'o';
(void)OSMboxPost(Bootloader_end,(void *)boot_end_status);
break;
}
}
else
{
if (confirma_rede == 0)
{
/* timeout of semaphore pend */
confirma_rede_error++;
// DelayTask(100);
if(confirma_rede_error>6)
{
confirma_rede_error = 0;
//UserEnterCritical();
// mensagem = confirma_rede;
//UserExitCritical();
if(Bootloader_ForceStop == 1){ // desiste
Bootloader_ForceStop = 0;
endereco_bw = CODE_START;
boot_end_status = (INT8U*)'f';
(void)OSMboxPost(Bootloader_end,(void *)boot_end_status);
break;
}
}
goto envia_de_novo;
}
endereco_bw = CODE_START;
//UserEnterCritical();
// mensagem = confirma_rede;
//UserExitCritical();
boot_end_status = (INT8U*)'g';
(void)OSMboxPost(Bootloader_end,(void *)boot_end_status);
break;
}
}
else
{
error++;
DelayTask(SIGNAL_TIMEOUT);
if(error==3)
{
DelayTask(RadioWatchdogTimeout + SIGNAL_TIMEOUT); /* wait for a radio reset */
}
if(error>6)
{
error = 0;
//UserEnterCritical();
// mensagem = confirma_rede;
//UserExitCritical();
endereco_bw = CODE_START;
boot_end_status = (INT8U*)'f';
(void)OSMboxPost(Bootloader_end,(void *)boot_end_status);
break;
}
else
{
goto envia_de_novo;
}
}
}
}
/**
* Alarm task that handles sounding the alarm and sending
* out the alerts
*/
void alarmTask(void *data) {
// Error reference
INT8U err;
// Result variables
char *result;
auto char realResult;
// Loop forever
while(1) {
//Read MSG Queue, wait forever for message
result = (char *)OSQPend(msgQueuePtr, 0, &err);
realResult = *result;
// Debug
printf("Alarm Task Run\n");
// Check for zone 1
if(realResult == '0') {
printf("\nZone 1 Tripped!!!!\n");
digOut(ID_BUZZER, ON);
digOut(LED_0_ID, ON);
// Update the current alarm state
OSSemPend(alarmSem, 0, &err);
zone0Alarm = ON;
alarming = ON;
OSSemPost(alarmSem);
// Send the alert
sendEmail(0);
} else if(realResult == '1') {
printf("\nZone 12Tripped!!!!\n");
digOut(ID_BUZZER, ON);
digOut(LED_1_ID, ON);
// Update the current alarm state
OSSemPend(alarmSem, 0, &err);
zone1Alarm = ON;
alarming = ON;
OSSemPost(alarmSem);
// Send the alert
sendEmail(1);
} else if(realResult == '2') {
printf("\nZone 3 Tripped!!!!\n");
digOut(ID_BUZZER, ON);
digOut(LED_2_ID, ON);
// Update the current alarm state
OSSemPend(alarmSem, 0, &err);
zone2Alarm = ON;
alarming = ON;
OSSemPost(alarmSem);
// Send the alert
sendEmail(2);
} else if(realResult == '3') {
printf("\nZone 4 Tripped!!!!\n");
digOut(ID_BUZZER, ON);
digOut(LED_3_ID, ON);
// Update the current alarm state
OSSemPend(alarmSem, 0, &err);
zone3Alarm = ON;
alarming = ON;
OSSemPost(alarmSem);
// Send the alert
sendEmail(3);
}
}
}
/**
\brief Send a frame to the serial API of the SmartMesh IP manager.
A response is expected from the manager if rxPayload!=NULL. In this case, this
function retries transmitting if no response is received after
SERIAL_ACK_TIMEOUT ms. If no response is received after SERIAL_MAX_RETRIES
retries, the function returns RC_WRITE_FAIL.
\param[in] packetType The payload type.
\param[in] txPayload Payload to transmit to the manager.
\param[in] txPayloadLen Number of bytes into the payload to transmit to the
manager.
\param[out] rxPayload Pointer to a buffer to write the received payload into.
manager.
\param[in] rxPayloadMaxLen Maximum number of bytes which fit in the rxPayload
buffer. If the manager responds with more bytes, this function returns
RC_NO_RESOURCES, and no bytes are written to the rxPayload buffer.
\param[out] rxPayloadLen Expected number of bytes returned by the manager.
\return RC_OK if the operation succeeded successfully.
\return RC_NO_RESOURCES if the manager returned a number of bytes different
from rxPayloadLen.
\return RC_WRITE_FAIL if no answer from the manager is received after
SERIAL_MAX_RETRIES retries.
*/
INT8U serial_tx(
INT8U packetType,
INT8U* txPayload,
INT8U txPayloadLen,
INT8U* rxPayload,
INT8U rxPayloadMaxLen,
INT8U* rxPayloadLen
) {
INT8U osErr;
dn_error_t dnErr;
INT8U i;
INT8U len;
INT8U functionReply;
INT8U retryCounter;
INT32U functionReplyLen;
serial_ht* tx_frame;
INT8U returnVal;
// I'm busy sending a DATA packet over serial
OSSemPend(bridge_app_v.serialTxDataAvailable,0,&osErr);
ASSERT(osErr==RC_OK);
// create packet
tx_frame = (serial_ht*)bridge_app_v.uartTxBuffer;
tx_frame->control = 0x00;
tx_frame->packetType = packetType;
tx_frame->seqNum = bridge_app_v.seqNoTx++;
tx_frame->payloadLen = txPayloadLen;
if (txPayload!=NULL) {
memcpy(tx_frame->payload,txPayload,txPayloadLen);
}
len = sizeof(serial_ht)+txPayloadLen;
// store packet details
bridge_app_v.requestPacketType = packetType;
bridge_app_v.responsePayload = rxPayload;
bridge_app_v.responsePayloadMaxLen = rxPayloadMaxLen;
retryCounter = SERIAL_MAX_RETRIES;
while (retryCounter>0) {
#ifdef PRINT_TRACE
dnm_ucli_printf("---TX--> (%d bytes)",len);
for (i=0;i<len;i++) {
dnm_ucli_printf(" %02x",bridge_app_v.uartTxBuffer[i]);
}
dnm_ucli_printf("\r\n");
dnm_ucli_printf(" packetType %d\r\n",tx_frame->packetType);
dnm_ucli_printf(" seqNum %d\r\n",tx_frame->seqNum);
#endif
// send packet
dnErr = dn_sendSyncMsgByType(
bridge_app_v.uartTxBuffer,
len,
DN_MSG_TYPE_UART_TX_CTRL,
(void*)&functionReply,
sizeof(functionReply),
&functionReplyLen
);
ASSERT(functionReplyLen==sizeof(INT8U));
ASSERT(functionReply==DN_ERR_NONE);
// wait for response, if appropriate
if (rxPayload!=NULL) {
// wait for response
OSSemPend(
bridge_app_v.waitForResponseSem,
SERIAL_ACK_TIMEOUT,
&osErr
);
// return appropriate value
switch (osErr) {
case OS_ERR_NONE:
*rxPayloadLen = bridge_app_v.responsePayloadLen;
if (bridge_app_v.responsePayloadLen<=bridge_app_v.responsePayloadMaxLen) {
returnVal = RC_OK;
} else {
returnVal = RC_NO_RESOURCES;
}
retryCounter = 0;
break;
case OS_ERR_TIMEOUT:
dnm_ucli_printf("WARNING: serial API timeout.\r\n");
retryCounter--;
break;
default:
ASSERT(0);
}
} else {
retryCounter = 0;
}
}
// reset packet details
bridge_app_v.requestPacketType = 0x00;
// I'm NOT busy sending a DATA packet over serial
OSSemPost(bridge_app_v.serialTxDataAvailable);
return returnVal;
}
static void DINGOO_LockAudio(_THIS)
{
Uint8 tempError;
OSSemPend(audio_sem, 1000, &tempError);
}
/*
*********************************************************************************************************
* App_TaskMEMS()
*
* Description : This task monitors the state of the push buttons and passes messages to AppTaskUserIF()
*
* Argument(s) : p_arg is the argument passed to 'App_TaskMEMS()' by 'OSTaskCreateExt()'.
*
* Return(s) : none.
*
* Caller(s) : This is a task.
*
* Note(s) : none.
*********************************************************************************************************
*/
void App_TaskMEMS (void *p_arg)
{
INT8U err, FRH, FRM, FRL;
INT16U i;
(void)p_arg;
while (DEF_TRUE) {
while(OSSemAccept(g_sem_mems));
mems_read_instant_flow();
OSSemPend(g_sem_mems, OS_TICKS_PER_SEC, &err);
if(OS_ERR_NONE == err)
{
LED_MEMS_ON();
if(MEMS_FRAME_OK == MEMS_AnalysisFrame((INT8U *)&mems_frame_recv, &mems_frame_stat))
{
switch(mems_frame_stat.cmd)
{
case MEMS_READ_INSTANT_FLOW_CMD:
FRH = mems_frame_recv.data[0];
FRM = mems_frame_recv.data[1];
FRL = mems_frame_recv.data[2];
g_mems_para.instant_flow = (INT32U)FRH * 65536 + (INT32U)FRM * 256 + (INT32U)FRL;
g_mems_para.buf[g_mems_para.index++] = g_mems_para.instant_flow;
if(MAX_FLOW_NUM == g_mems_para.index)
{
g_mems_para.index = 0;
g_mems_para.sum = 0;
for(i = 0; i < MAX_FLOW_NUM; i++)
{
g_mems_para.sum += g_mems_para.buf[i];
}
g_mems_para.average_flow = g_mems_para.sum / MAX_FLOW_NUM;
g_mems_para.cal_flow = g_mems_para.average_flow; //Á÷Á¿Ð£×¼
if((0 != g_mems_para.cal_flow) && (abs((int)g_mems_para.cal_flow - (int)g_mems_para.target_flow) < g_mem_para.mems_debounce_threshold))
{
g_mems_para.inside_count++;
if(g_mems_para.inside_count >= 2)
{
g_mems_para.inside_count = 0;
g_mems_para.outside_count = 5;
g_mems_para.disp_flow = g_mems_para.target_flow;
g_mems_para.disp_flow_int_part = g_mems_para.disp_flow / 1000;
g_mems_para.disp_flow_dec_part = (g_mems_para.disp_flow - (g_mems_para.disp_flow_int_part * 1000)) / 100;
}
break;
}
else
{
g_mems_para.inside_count = 0;
}
if(g_mems_para.outside_count)
{
g_mems_para.outside_count--;
}
else
{
g_mems_para.disp_flow = g_mems_para.cal_flow + 50;
g_mems_para.disp_flow_int_part = g_mems_para.disp_flow / 1000;
g_mems_para.disp_flow_dec_part = (g_mems_para.disp_flow - (g_mems_para.disp_flow_int_part * 1000)) / 100;
}
}
break;
default:
break;
}
}
}
else
{
LED_MEMS_OFF();
}
}
}
//为了提高任务效率，改用事件驱动方式
//
void app_task_obd (void *p_arg)
{
u8 var_uchar;
//Request Supported PIDs from Vehicle, check sae j1979 2002.pdf page 26
u8 determine_pid[]="\x02\x01\x00\x00\x00\x00\x00\x00";
u16 can_id_idx = 0;
u32 can_id ;
CanRxMsg can_rx_msg;
CPU_INT08U os_err;
(void)p_arg;
//can_enquire_determine_pid( );
OSSemPend(sem_obd_task, 0, &os_err);//Wait task manger ask to start
//BKP_DR2, OBD Flag: 15~12:KWP_TYPEDEF
// 11~8:CAN2_TYPEDEF
// 7~4: CAN1_TYPEDEF
// 3~0: OBD_TYPEDEF
//BKP_DR3, can_snd_id index, check app_obd.c
switch ( obd_read_type ) {
case OBD_TYPE_CAN1 ://CAN1
debug_obd("OBD is CAN1 ");
can_id_idx = obd_read_canid_idx ;
if ( !can_id_idx ) {//no CAN send id index
obd_auto_detect( );
can_id_idx = obd_read_canid_idx ;
}
switch ( obd_can1_type ) {
case CAN1_TYPE_STD_250 ://CAN1_TYPE_STD_250
debug_obd("STD 250\r\n");
break;
case CAN1_TYPE_EXT_250 ://CAN1_TYPE_EXT_250
debug_obd("EXT 250\r\n");
break;
case CAN1_TYPE_STD_500 ://CAN1_TYPE_STD_500
debug_obd("STD 500\r\n");
break;
case CAN1_TYPE_EXT_500 ://CAN1_TYPE_EXT_500
debug_obd("EXT 500\r\n");
break;
case CAN1_TYPE_NO_DEFINE ://CAN1 no define
default://maybe error, treat as no define
debug_obd("but type ERR!\r\n");
BKP_WriteBackupRegister(BKP_DR2, 0);//clean all flag, prevent err
BKP_WriteBackupRegister(BKP_DR3, 0);//clean all flag, prevent err
obd_auto_detect( );
can_id_idx = obd_read_canid_idx ;
break;
}
break;
case OBD_TYPE_CAN2 ://CAN2
debug_obd("OBD is CAN2 bus\r\n");
if ( !obd_read_canid_idx ) {//no CAN send id index
obd_auto_detect( );
can_id_idx = obd_read_canid_idx ;
}
break;
case OBD_TYPE_NO_DFN ://no define
default://maybe error, treat as no define
debug_obd("No OBD type\r\n");
BKP_WriteBackupRegister(BKP_DR2, 0);//clean all flag, prevent err
BKP_WriteBackupRegister(BKP_DR3, 0);//clean all flag, prevent err
obd_auto_detect( );
can_id_idx = obd_read_canid_idx ;
break;
}
while ( !can_id_idx ) { //no CAN ID index, err
debug_obd("BK2: %04X BK3: %04X\r\n",BKP_ReadBackupRegister(BKP_DR2),BKP_ReadBackupRegister(BKP_DR3));
debug_obd("can_id_idx = %d\r\n", can_id_idx);
OSSemPend(sem_obd_task, 0, &os_err);
debug_obd("CAN ID index ERR\r\n");
//Report err to server
for ( var_uchar = 0 ; var_uchar < MAX_WARN_MSG ; var_uchar++) {
if ( !my_icar.warn[var_uchar].msg ) { //empty msg
//unsigned int msg;//file name(1 Byte), msg(1 Byte), line(2 B)
my_icar.warn[var_uchar].msg = (F_APP_OBD) << 24 ;
my_icar.warn[var_uchar].msg |= ERR_CAN_ID_IDX << 16 ;//Error CAN ID index
my_icar.warn[var_uchar].msg |= __LINE__ ;
var_uchar = MAX_WARN_MSG ;//end the loop
}
}
obd_auto_detect( );
can_id_idx = obd_read_canid_idx ;
}
//uart3_init( ); //to OBD, K-BUS
while ( !can_enquire_support_pid( ) ) { //update support table ERR
debug_obd("Get CAN PID ERR\r\n");
//Report err to server
for ( var_uchar = 0 ; var_uchar < MAX_WARN_MSG ; var_uchar++) {
if ( !my_icar.warn[var_uchar].msg ) { //empty msg
//unsigned int msg;//file name(1 Byte), msg(1 Byte), line(2 B)
my_icar.warn[var_uchar].msg = (F_APP_OBD) << 24 ;
my_icar.warn[var_uchar].msg |= ERR_CAN_SUP_PID << 16 ;//Error get CAN support PID
my_icar.warn[var_uchar].msg |= __LINE__ ;
var_uchar = MAX_WARN_MSG ;//end the loop
}
}
OSTimeDlyHMSM(0, 0, 30, 0);//wait 30s
}
for ( var_uchar = 0 ; var_uchar <= OBD_MAX_PID ; var_uchar++) {
if ( can_read_pid(var_uchar) ) {//read PID error
debug_obd("Read PID:%d ERR\r\n",var_uchar);
}
else {
debug_obd("Read PID:%d OK\r\n",var_uchar);
}
}
/* Enable Interrupt for receive FIFO 0 and FIFO overflow */
CAN_ITConfig(CAN1,CAN_IT_FMP0 | CAN_IT_FOV0, ENABLE);
/* Enable Interrupt for receive FIFO 1 and FIFO overflow */
CAN_ITConfig(CAN1,CAN_IT_FMP1 | CAN_IT_FOV1, ENABLE);
while ( 1 ) {
//debug_obd("OBD task Pend...\r\n");
OSSemPend(sem_obd_task, 0, &os_err);
if ( !os_err ) {
//CAN TX flag, for test only
if ( my_icar.obd.can_tx_cnt ) {
//send CAD ID: 0x18DB33F1
can_send( can_snd_id[can_id_idx], DAT_FRAME, 8, determine_pid );
//CAN_Transmit(CAN1, &TxMessage);
my_icar.obd.can_tx_cnt--;
}
//execute CMD from app_taskmanager
switch ( my_icar.obd.cmd ) {
case READ_PID ://update support table
debug_obd("CMD is Read ECU pid:%d\r\n",my_icar.obd.pid);
my_icar.obd.cmd = NO_CMD ;
var_uchar = can_read_pid( my_icar.obd.pid );//result in my_icar.obd.rx_buf
if ( var_uchar ) {//read PID error
debug_obd("Read PID err: %d\r\n", var_uchar);
}
else {//get ECU data
//debug_obd("Read PID OK: %d\r\n", var_uchar);
switch ( my_icar.obd.pid ) {
case OBD_PID_ENGINE_RPM:
debug_obd("Read RPM OK.\r\n");
//debug_obd("Rec %d:",rec_len);
//for ( var_uchar = 0 ; var_uchar < rec_len ; var_uchar++ ) {
//printf(" %02X",my_icar.obd.rx_buf[var_uchar]);
//}
printf(", from ID:%08X\r\n", can_id);
break;
default://maybe error
debug_obd("PID err:%d\r\n",my_icar.obd.pid);
break;
}
}
break;
case SPEED ://engine speed
debug_obd("CMD is get engine speed\r\n");
my_icar.obd.cmd = NO_CMD ;
can_send( can_snd_id[can_id_idx], DAT_FRAME, 8, determine_pid );
break;
case NO_CMD ://no define
default://maybe error, treat as NO_CMD
;//debug_obd("No OBD CMD\r\n");
break;
}
//FIFO0 has data, max.: 3 datas
if ( (CAN1->RF0R)&0x03 ) {
CAN_Receive(CAN1,CAN_FIFO0, &can_rx_msg);
if (can_rx_msg.IDE == CAN_ID_STD) {
debug_obd("CAN FIFO_0 rec %d ID: %X\r\n", (CAN1->RF0R)&0x03,can_rx_msg.StdId);
debug_obd("DLC %d :", can_rx_msg.DLC);
//show the data
for ( var_uchar = 0 ; var_uchar < can_rx_msg.DLC ; var_uchar++ ) {
printf(" %02X",can_rx_msg.Data[var_uchar]);
}
printf("\r\n");
}
else {
debug_obd("CAN FIFO_0 rec %d ID: %X %s,%d\r\n", (CAN1->RF0R)&0x03,can_rx_msg.ExtId,\
__FILE__,__LINE__);
debug_obd("DLC %d :", can_rx_msg.DLC);
//show the data
for ( var_uchar = 0 ; var_uchar < can_rx_msg.DLC ; var_uchar++ ) {
printf(" %02X",can_rx_msg.Data[var_uchar]);
}
printf("\r\n");
}
if ( (CAN1->RF0R)&0x03==0 ) { //no data
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);//enable FIFO0 FMP int
}
else { //still has data
OSSemPost( sem_obd_task );//2012/9/26 14:55:33 verify
}
}
//FIFO1 receive unknow CAN ID, then report to server
//FIFO0 has data, max.: 3 datas
if ( (CAN1->RF1R)&0x03 ) {
CAN_Receive(CAN1,CAN_FIFO1, &can_rx_msg);
if (can_rx_msg.IDE == CAN_ID_STD) { //unknow CAN STD ID, report to server
can_id = can_rx_msg.StdId ;
}
else { //unknow CAN EXT ID, report to server
can_id = can_rx_msg.ExtId ;
}
obd_report_unknow_canid( can_id );
debug_obd("Unknow CAN ID: %X FIFO:%d\r\n",can_id,(CAN1->RF1R)&0x03);
if ( (CAN1->RF1R)&0x03==0 ) { //no data
CAN_ITConfig(CAN1,CAN_IT_FMP1, ENABLE);//enable FIFO1 FMP int
}
else { //still has data
OSSemPost( sem_obd_task );//no verify
}
}
}
}
}
/*
* The task 'VehicleTask' updates the current velocity of the vehicle
*/
void VehicleTask(void* pdata)
{
INT8U err, err_tmr_1, err_tmr_start, err_sem;
void* msg;
INT8U* throttle;
INT8S acceleration; /* Value between 40 and -20 (4.0 m/s^2 and -2.0 m/s^2) */
INT8S retardation; /* Value between 20 and -10 (2.0 m/s^2 and -1.0 m/s^2) */
INT16U position = 0; /* Value between 0 and 20000 (0.0 m and 2000.0 m) */
INT16S wind_factor; /* Value between -10 and 20 (2.0 m/s^2 and -1.0 m/s^2) */
Sem_VehicleTask = OSSemCreate(0);
//OSSemPend(Sem_VehicleTask,0,&err_sem);
printf("Vehicle task created!\n");
SWTimer_VehicleTask = OSTmrCreate(0, VEHICLE_PERIOD, OS_TMR_OPT_PERIODIC, Tmr_Callback_Vehicle_Task, (void *)0,"S/W Timer 2",&err_tmr_1);
if(err_tmr_1 == OS_ERR_NONE){
if(DEBUG)
printf("Timer for VECHICLE TASK is created\n");
OSTmrStart(SWTimer_VehicleTask, &err_tmr_start);
if(err_tmr_start == OS_ERR_NONE){
if(DEBUG)
printf("Timer started in VEHICLE TASK \n");
}
else {
printf("Problem starting timer in VEHICLE TASK \n");
}
}
else {
printf("Error while creating Vehicle task timer \n");
if(err_tmr_1 == OS_ERR_TMR_INVALID_DLY)
printf(" Delay INVALID : VEHICLE TASK\n");
}
while(1)
{
// Wait for user inputs
OSSemPend(Sem_SwitchIO_IP , 0, &err_sem);
OSSemPend(Sem_ButtonIO_IP, 0, &err_sem);
if((brake_pedal == on) && (CUR_VELOCITY > 0)){
CUR_VELOCITY = CUR_VELOCITY - 10;
// if(CUR_VELOCITY < -200) // Max value for velocity
//CUR_VELOCITY = -200;
if(DEBUG_IO)
printf("********** Brake brake_pedal : %d ********** \n", CUR_VELOCITY);
}
err = OSMboxPost(Mbox_Velocity, (void *) &CUR_VELOCITY);
if(DEBUG)
printf("Vehicle task Posted MBoxPost_Velocity \n");
if(DEBUG)
printf("SEM ACCESS VEHICLE TASK\n\n");
OSSemPend(Sem_VehicleTask,0,&err_sem);
/* Non-blocking read of mailbox:
- message in mailbox: update throttle
- no message: use old throttle
*/
if(DEBUG)
printf("Vehicle task waiting for MBoxPost_Throttle for 1 unit time \n");
msg = OSMboxPend(Mbox_Throttle, 1, &err);
if (err == OS_NO_ERR)
throttle = (INT8U*) msg;
if(DEBUG)
printf("Vehicle task GOT MBoxPost_Throttle \n");
/* Retardation : Factor of Terrain and Wind Resistance */
if (CUR_VELOCITY > 0)
wind_factor = CUR_VELOCITY * CUR_VELOCITY / 10000 + 1;
else
wind_factor = (-1) * CUR_VELOCITY * CUR_VELOCITY / 10000 + 1;
if (position < 4000)
retardation = wind_factor; // even ground
else if (position < 8000)
retardation = wind_factor + 15; // traveling uphill
else if (position < 12000)
retardation = wind_factor + 25; // traveling steep uphill
else if (position < 16000)
retardation = wind_factor; // even ground
else if (position < 20000)
retardation = wind_factor - 10; //traveling downhill
else
retardation = wind_factor - 5 ; // traveling steep downhill
acceleration = *throttle / 2 - retardation;
position = adjust_position(position, CUR_VELOCITY, acceleration, 300);
CUR_VELOCITY = adjust_velocity(CUR_VELOCITY, acceleration, brake_pedal, 300);
printf("Position: %dm\n", position / 10);
printf("Velocity: %4.1fm/s\n", CUR_VELOCITY /10.0);
printf("Throttle: %dV Time : %d \n\n", *throttle / 10, (int) (alt_timestamp() / (alt_timestamp_freq()/1000)));
alt_timestamp_start();
/*
INT32U stk_size;
err = OSTaskStkChk(16, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used OverLoadDetection : %d \n", stk_size);
err = OSTaskStkChk(14, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used DYNAMIV_UTI : %d \n", stk_size);
err = OSTaskStkChk(12, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used CONTROLTASK: %d \n", stk_size);
err = OSTaskStkChk(10, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used VehicleTask: %d \n", stk_size);
err = OSTaskStkChk(8, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used SwitchIO: %d \n", stk_size);
err = OSTaskStkChk(7, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used ButtonIO: %d \n", stk_size);
err = OSTaskStkChk(6, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used WatchDog: %d \n", stk_size);
err = OSTaskStkChk(5, &stk_data);
stk_size = stk_data.OSUsed;
printf("Stack Used Start Task: %d \n", stk_size);
*/
show_velocity_on_sevenseg((INT8S) (CUR_VELOCITY / 10));
show_active_signals();
show_position(position);
// OSSemPend(Sem_VehicleTask,0,&err_sem);
}
}
void Input_Task(void *parg)
{
u8 err;
u8 OK=0;
u8 buffer[4]={0};
u8 LEN=0;
u8 flag=0;
u16 e=0;
OS_CPU_SR cpu_sr;
(void)parg;
for(;;)
{
OSSemPend(PENIRQ,0,&err);
Exti_Set(0);
OS_ENTER_CRITICAL();
touch.FLAG=Read_XY_2(&touch.AD_X,&touch.AD_Y);
OS_EXIT_CRITICAL();
if(touch.FLAG)
{
Led_On(1);
touch.FLAG=0;
touch.LCD_X=CalcXY(touch.AD_X,0);
touch.LCD_Y=CalcXY(touch.AD_Y,1);
touch.KEY=Get_Key(touch.PID,touch.LCD_X,touch.LCD_Y);
if(touch.KEY<=10)
{
OS_ENTER_CRITICAL();
Set_Color(WHITE,BLACK);
if(touch.KEY==10)
Show_Char('.',cursor.x,cursor.y);
else
{
Show_Dec(touch.KEY,1,cursor.x,cursor.y);
if(LEN<4)
{
buffer[LEN]=touch.KEY;
LEN++;
}
}
if(cursor.x<224)
{
cursor.x+=8;
if(cursor.x>=224)
cursor.x=224;
}
OS_EXIT_CRITICAL();
}
else if(touch.KEY==11)
{
OK++;
if(OK==1)
{
VALUE1=CalcDec(buffer,LEN);
Set_Color(BLACK,GREEN);
Show_String(">>VALUE1:",2,22);
Show_Dec(VALUE1,LEN,82,22);
OS_ENTER_CRITICAL();
LCD_Clear(4,121,232,38,WHITE);
cursor.x=8;
cursor.y=132;
OS_EXIT_CRITICAL();
buffer[0]=0;
buffer[1]=0;
buffer[2]=0;
buffer[3]=0;
LEN=0;
}
else if(OK==2)
{
VALUE2=CalcDec(buffer,LEN);
Set_Color(BLACK,GREEN);
Show_String(">>VALUE2:",2,38);
Show_Dec(VALUE2,LEN,82,38);
OS_ENTER_CRITICAL();
LCD_Clear(4,121,232,38,WHITE);
cursor.x=8;
cursor.y=132;
OS_EXIT_CRITICAL();
buffer[0]=0;
buffer[1]=0;
buffer[2]=0;
buffer[3]=0;
LEN=0;
}
else if(OK==3)
{
VALUE3=CalcDec(buffer,LEN);
Set_Color(BLACK,GREEN);
Show_String(">>VALUE3:",2,54);
Show_Dec(VALUE3,LEN,82,54);
OS_ENTER_CRITICAL();
LCD_Clear(4,121,232,38,WHITE);
cursor.x=8;
cursor.y=132;
OS_EXIT_CRITICAL();
buffer[0]=0;
buffer[1]=0;
buffer[2]=0;
buffer[3]=0;
LEN=0;
}
else if(OK==4)
{
if(VALUE2>0&&VALUE2<=5000)
{
if(VALUE1<VALUE2&&VALUE1>0)
{
if(VALUE3>0&&VALUE3<10000)
{
e=0;
Set_Color(BLACK,GREEN);
Show_String(">>OK!",2,70);
}
else
{
e=1;
}
}
else
{
e=1;
}
}
else
{
e=1;
}
if(e)
{
Set_Color(BLACK,GREEN);
Show_String(">>ERROR!",2,70);
}
}
else if(OK==5)
{
if(!e)
{
OK=0;
OSTaskSuspend(CURSOR_TASK_PRIO);
Show_Main(VALUE1,VALUE2,VALUE3,1);
}
else
{
OK=0;
e=0;
LCD_Clear(2,20,236,100,BLACK);
LCD_DrawEdit(input);
Set_Cursor(8,132);
}
VALUE1=0;
VALUE2=0;
VALUE3=0;
}
else;
}
else if(touch.KEY==12)
{
OS_ENTER_CRITICAL();
if(LEN>0)
{
LEN--;
}
if(cursor.x>=8)
{
LCD_Clear(cursor.x,cursor.y,8,16,WHITE);
cursor.x-=8;
if(cursor.x<8)
{
cursor.x=8;
}
}
OS_EXIT_CRITICAL();
}
else if(touch.KEY==13)
{
if(flag==0)
{
flag=1;
button1.str="stop";
button1.len=4;
button1.line_color=GREEN;
LCD_DrawButton(button1);
OSTaskResume(TIMER_TASK_PRIO);
}
else
{
flag=0;
button1.str="start";
button1.len=5;
button1.line_color=BLACK;
LCD_DrawButton(button1);
OSTaskSuspend(TIMER_TASK_PRIO);
}
}
else if(touch.KEY==14)
{
OSTaskSuspend(TIMER_TASK_PRIO);
Show_KeyMap();
OSTaskResume(CURSOR_TASK_PRIO);
}
else if(touch.KEY==99)//無效輸入
{}
else;
OSTimeDlyHMSM(0,0,0,50);
Led_Off(1);
}
Exti_Set(1);
}
}
void MainTask(void *arg) {
ADI_AFE_DEV_HANDLE hDevice;
int16_t dft_results[DFT_RESULTS_COUNT];
q15_t dft_results_q15[DFT_RESULTS_COUNT];
q31_t dft_results_q31[DFT_RESULTS_COUNT];
q31_t magnitude[DFT_RESULTS_COUNT / 2];
q15_t phase[DFT_RESULTS_COUNT / 2];
fixed32_t magnitude_result[DFT_RESULTS_COUNT / 2 - 1];
fixed32_t phase_result[DFT_RESULTS_COUNT / 2 - 1];
char msg[MSG_MAXLEN];
uint8_t err;
done = 0;
uint16_t pressure_analog;
uint32_t pressure;
nummeasurements = 0;
uint32_t rtcCount;
ADI_I2C_RESULT_TYPE i2cResult;
// Initialize driver.
rtc_Init();
// Calibrate.
rtc_Calibrate();
// Initialize UART.
if (uart_Init()) {
FAIL("ADI_UART_SUCCESS");
}
// Initialize I2C.
i2c_Init(&i2cDevice);
// Initialize flags.
bRtcAlarmFlag = bRtcInterrupt = bWdtInterrupt = false;
// Get the current count.
if (adi_RTC_GetCount(hRTC, &rtcCount)) {
FAIL("adi_RTC_GetCount failed");
}
// Initialize the AFE API.
if (adi_AFE_Init(&hDevice)) {
FAIL("adi_AFE_Init");
}
// AFE power up.
if (adi_AFE_PowerUp(hDevice)) {
FAIL("adi_AFE_PowerUp");
}
// Excitation Channel Power-up.
if (adi_AFE_ExciteChanPowerUp(hDevice)) {
FAIL("adi_AFE_ExciteChanPowerUp");
}
// TIA Channel Calibration.
if (adi_AFE_TiaChanCal(hDevice)) {
FAIL("adi_AFE_TiaChanCal");
}
// Excitation Channel Calibration (Attenuation Enabled).
if (adi_AFE_ExciteChanCalAtten(hDevice)) {
FAIL("adi_AFE_ExciteChanCalAtten");
}
// Update FCW in the sequence.
seq_afe_acmeas2wire[3] = SEQ_MMR_WRITE(REG_AFE_AFE_WG_FCW, FCW);
// Update sine amplitude in the sequence.
seq_afe_acmeas2wire[4] =
SEQ_MMR_WRITE(REG_AFE_AFE_WG_AMPLITUDE, SINE_AMPLITUDE);
// Recalculate CRC in software for the AC measurement, because we changed.
// FCW and sine amplitude settings.
adi_AFE_EnableSoftwareCRC(hDevice, true);
// Perform the impedance measurement.
if (adi_AFE_RunSequence(hDevice, seq_afe_acmeas2wire, (uint16_t *)dft_results,
DFT_RESULTS_COUNT)) {
FAIL("Impedance Measurement");
}
// Set RTC alarm.
printf("rtcCount: %d\r\n", rtcCount);
if (ADI_RTC_SUCCESS != adi_RTC_SetAlarm(hRTC, rtcCount + 120)) {
FAIL("adi_RTC_SetAlarm failed");
}
// Enable RTC alarm.
if (ADI_RTC_SUCCESS != adi_RTC_EnableAlarm(hRTC, true)) {
FAIL("adi_RTC_EnableAlarm failed");
}
// Read the initial impedance.
q31_t magnitudecal;
q15_t phasecal;
convert_dft_results(dft_results, dft_results_q15, dft_results_q31);
arm_cmplx_mag_q31(dft_results_q31, &magnitudecal, 2);
phasecal = arctan(dft_results[1], dft_results[0]);
printf("raw rcal data: %d, %d\r\n", dft_results[1], dft_results[0]);
printf("rcal (magnitude, phase) = (%d, %d)\r\n", magnitudecal, phasecal);
// Create the message queue for communicating between the ISR and this task.
dft_queue = OSQCreate(&dft_queue_msg[0], DFT_QUEUE_SIZE);
// Hook into the DFT interrupt.
if (ADI_AFE_SUCCESS !=
adi_AFE_RegisterAfeCallback(
hDevice, ADI_AFE_INT_GROUP_CAPTURE, AFE_DFT_Callback,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN)) {
FAIL("adi_AFE_RegisterAfeCallback");
}
if (ADI_AFE_SUCCESS !=
adi_AFE_ClearInterruptSource(
hDevice, ADI_AFE_INT_GROUP_CAPTURE,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN)) {
FAIL("adi_AFE_ClearInterruptSource (1)");
}
packed32_t q_result;
void *q_result_void;
OS_Q_DATA q_data;
uint16_t q_size;
bool inflated = false;
while (true) {
// Wait for the user to press the button.
printf("MainTask: waiting for button.\n");
OSSemPend(ux_button_semaphore, 0, &err);
if (err != OS_ERR_NONE) {
FAIL("OSSemPend: MainTask");
}
// TODO: fix bug when pressing button multiple times.
// Have the pump task inflate the cuff.
printf("MainTask: button detected. Resuming pump task.\n");
err = OSTaskResume(TASK_PUMP_PRIO);
if (err != OS_ERR_NONE) {
FAIL("OSTaskResume: MainTask (1)");
}
// Wait a bit.
printf("MainTask: waiting a bit.\n");
err = OSTimeDlyHMSM(0, 0, 1, 0);
if (err != OS_ERR_NONE) {
FAIL("OSTimeDlyHMSM: MainTask (3)");
}
// Enable the DFT interrupt.
printf("MainTask: enabling DFT interrupt.\n");
if (ADI_AFE_SUCCESS !=
adi_AFE_EnableInterruptSource(
hDevice, ADI_AFE_INT_GROUP_CAPTURE,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN, true)) {
FAIL("adi_AFE_EnableInterruptSource");
}
PRINT("START\r\n");
printf("START\r\n");
while (true) {
// Wait on the queue to get DFT data from the ISR (~76 Hz).
//printf("MainTask: pending on DFT queue.\n");
q_result_void = OSQPend(dft_queue, 0, &err);
q_result.pointer = q_result_void;
if (err != OS_ERR_NONE) {
FAIL("OSQPend: dft_queue");
}
OSQQuery(dft_queue, &q_data);
q_size = q_data.OSNMsgs;
// Right after we get this data, get the transducer's value from the
// Arduino.
//printf("MainTask: getting transducer value via I2C.\n");
i2cResult = adi_I2C_MasterReceive(i2cDevice, I2C_PUMP_SLAVE_ADDRESS, 0x0,
ADI_I2C_8_BIT_DATA_ADDRESS_WIDTH,
i2c_rx, 3, false);
if (i2cResult != ADI_I2C_SUCCESS) {
FAIL("adi_I2C_MasterReceive: get pressure from Arduino");
}
// Get the analog pressure value from the Arduino.
if (i2c_rx[0] == ARDUINO_PRESSURE_AVAILABLE
|| i2c_rx[0] == ARDUINO_STILL_INFLATING) {
pressure_analog = i2c_rx[1] | (i2c_rx[2] << 8);
} else {
FAIL("Corrupted or unexpected data from Arduino.");
}
// Convert the analog value to mmHg.
pressure = transducer_to_mmhg(pressure_analog);
//printf("MainTask: got pressure value: %d mmHg.\n", pressure);
// If the pressure is below the threshold, we're done; break the loop.
if (inflated && pressure < LOWEST_PRESSURE_THRESHOLD_MMHG) {
PRINT("END\r\n");
printf("END\r\n");
inflated = false;
break;
} else if (pressure > LOWEST_PRESSURE_THRESHOLD_MMHG * 1.1) {
inflated = true;
}
// Convert DFT results to 1.15 and 1.31 formats.
dft_results[0] = q_result.parts.magnitude;
dft_results[1] = q_result.parts.phase;
convert_dft_results(dft_results, dft_results_q15, dft_results_q31);
// Compute the magnitude using CMSIS.
arm_cmplx_mag_q31(dft_results_q31, magnitude, DFT_RESULTS_COUNT / 2);
// Calculate final magnitude values, calibrated with RCAL.
fixed32_t magnituderesult;
magnituderesult = calculate_magnitude(magnitudecal, magnitude[0]);
q15_t phaseresult;
phaseresult = arctan(dft_results[1], dft_results[0]);
fixed32_t phasecalibrated;
// Calibrate with phase from rcal.
phasecalibrated = calculate_phase(phasecal, phaseresult);
// TODO: dispatch to another thread?
//printf("MainTask: sending data via UART.\n");;
print_PressureMagnitudePhase("", pressure, magnituderesult, phasecalibrated,
q_size);
nummeasurements++;
}
// We're done measuring, for now. Disable the DFT interrupts.
printf("MainTask: disabling DFT interrupts.\n");
if (ADI_AFE_SUCCESS !=
adi_AFE_EnableInterruptSource(
hDevice, ADI_AFE_INT_GROUP_CAPTURE,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN, false)) {
FAIL("adi_AFE_EnableInterruptSource (false)");
}
// Tell the pump task to deflate the cuff.
printf("MainTask: resuming pump task to deflate the cuff.\n");
err = OSTaskResume(TASK_PUMP_PRIO);
if (err != OS_ERR_NONE) {
FAIL("OSTaskResume: MainTask (2)");
}
// Suspend until the pump finishes deflating. We can then go back to
// listening for the user input.
printf("MainTask: suspending to wait for pump task.\n");
err = OSTaskSuspend(OS_PRIO_SELF);
if (err != OS_ERR_NONE) {
FAIL("OSTaskSuspend: MainTask (3)");
}
// Tell the UX that we're done for now.
UX_Disengage();
}
}
int udpRead(u_int ud, void* buf, long len)
{
unsigned char* d;
int rtn;
NBuf* b;
UDP_QUEUE* q;
struct in_addr fromAddr;
UBYTE err;
// TRACE("udpRead(%d,%p,%ld)\n",ud,buf,len);
if (!(udps[ud].flags & FUDP_OPEN)) return -1;
d = (unsigned char*)buf;
rtn = 0;
OSSemPend(udps[ud].sem, 0, &err);
if (udps[ud].head == NULL) {
return -1;
}
fromAddr = udps[ud].theirAddr = udps[ud].head->srcAddr;
udps[ud].theirPort = udps[ud].head->srcPort;
UDPDEBUG(("fromAddr.s_addr = %08X, udps[ud].head->srcAddr.s_addr = %08X\n", fromAddr.s_addr, udps[ud].head->srcAddr.s_addr));
while ((udps[ud].head) && (len) && (fromAddr.s_addr == udps[ud].head->srcAddr.s_addr)) {
// Get next nBuf
b = udps[ud].head->nBuf;
// While we have more buffer to copy out to AND
// We have a queued nBuf
while ((len) && (b)) {
// While we have more buffer space to copy to AND
// nBuf is not empty
// while ((len) && (b->data != &b->body[b->len])) {
while ( (len) && (b->len) ) {
// Copy one byte
*d++ = *b->data++;
b->len--;
len--;
rtn++;
}
// If nBuf is empty
// if (b->data == &b->body[b->len]) {
if (!b->len) {
OS_ENTER_CRITICAL();
b = udps[ud].head->nBuf = nFree(b);
OS_EXIT_CRITICAL();
}
}
// If nBuf was freed (we need another one if any)
if (b == NULL) {
// Get next nBuf in queue
q = udps[ud].head;
OS_ENTER_CRITICAL();
udps[ud].head = q->next;
OS_EXIT_CRITICAL();
free_udp_q(q);
#if ONETASK_SUPPORT > 0
#else
if (udps[ud].head)
OSSemPend(udps[ud].sem, 0, &err);
#endif
} else {
#if ONETASK_SUPPORT > 0
// nBuf was not freed but we have filled our buffer (buf)
return rtn;
#else
OSSemPost(udps[ud].sem);
#endif
}
}
if (udps[ud].head == NULL)
udps[ud].tail = NULL;
return rtn;
}
void GUI_X_Lock(void) {
INT8U err;
OSSemPend(DispSem, 0, &err);
}
void sw_uart_lock(INT8U uart_num)
{
INT8U err;
OSSemPend(sw_uart_sem[uart_num], 0, &err);
}
void ProcessCommand( char c )
{
WavPlayer::wavError ret;
int loopCount;
char key;
switch ( c ) {
case '1':
iprintf("Playing Audio...");
testPlayer.OpenBuffer( nbwav_44k );
testPlayer.Play( &playbackSem );
OSSemPend( &playbackSem, 0 );
iprintf(" Done\r\n");
break;
case '2':
iprintf("Playing Audio...");
testPlayer.OpenBuffer( nbwav_8k );
testPlayer.Play( &playbackSem );
OSSemPend( &playbackSem, 0 );
iprintf(" Done\r\n");
break;
case '3':
iprintf("Playing Audio...");
testPlayer.OpenBuffer( sinewav_440 );
testPlayer.Play( &playbackSem );
OSSemPend( &playbackSem, 0 );
iprintf(" Done\r\n");
break;
case '4':
iprintf("Looping Audio...\r\nPress P to pause, R to resume, any other key to stop...");
testPlayer.OpenBuffer( sinewav_440 );
testPlayer.Loop( 0, &playbackSem );
while (testPlayer.GetState() != WavPlayer::STATE_FINISHED) {
key = getchar();
switch (key) {
case 'P':
case 'p':
testPlayer.Pause();
break;
case 'R':
case 'r':
testPlayer.Resume();
break;
default:
testPlayer.Stop();
break;
}
}
iprintf(" Done\r\n");
break;
#ifdef WAV_PLAYER_FILESYSTEM
case '5':
if (!extFlashOpened) {
setUpFlash();
}
ListDir();
break;
case '6':
if (!extFlashOpened) {
setUpFlash();
}
iprintf("Enter directory name: ");
gets( inputBuf );
iprintf("\r\n");
f_chdir( inputBuf );
ListDir();
break;
case '7':
if (!extFlashOpened) {
setUpFlash();
}
iprintf("Enter file name: ");
gets( inputBuf );
iprintf("\r\n");
ret = testPlayer.OpenFile( inputBuf, wavBuffer, WAV_BUFFER_SIZE );
if ( ret == WavPlayer::ERROR_FILE_SIZE ) {
iprintf("Wav file too big. Increase WAV_BUFFER_SIZE or use smaller file.\r\n");
break;
}
iprintf("Playing Audio...");
testPlayer.Play( &playbackSem );
OSSemPend( &playbackSem, 0 );
iprintf(" Done\r\n");
break;
case '8':
if (!extFlashOpened) {
setUpFlash();
}
iprintf("Enter file name: ");
gets( inputBuf );
iprintf("\r\n");
ret = testPlayer.OpenFile( inputBuf, wavBuffer, WAV_BUFFER_SIZE );
if ( ret == WavPlayer::ERROR_FILE_SIZE ) {
iprintf("Wav file too big. Increase WAV_BUFFER_SIZE or use smaller file.\r\n");
break;
}
iprintf("Enter loop count (0 is infinite): ");
gets( inputBuf );
loopCount = atoi( inputBuf );
iprintf("\r\nLooping Audio...");
if (loopCount) {
testPlayer.Loop( loopCount, &playbackSem );
OSSemPend( &playbackSem, 0 );
}
else {
iprintf("\r\nPress P to pause, R to resume, any other key to stop...");
testPlayer.Loop( loopCount );
while (testPlayer.GetState() != WavPlayer::STATE_FINISHED) {
key = getchar();
switch (key) {
case 'P':
case 'p':
testPlayer.Pause();
break;
case 'R':
case 'r':
testPlayer.Resume();
break;
default:
testPlayer.Stop();
break;
}
}
}
iprintf(" Done\r\n");
break;
#endif /* #ifdef WAV_PLAYER_FILESYSTEM */
case 'p':
case 'P':
if (testPlayer.GetState() == WavPlayer::STATE_FINISHED) {
iprintf("Playing Audio...");
testPlayer.Play( &playbackSem );
OSSemPend( &playbackSem, 0 );
iprintf(" Done\r\n");
}
break;
default:
break;
}
}
void ControlTask(void* pdata)
{
INT8U err, err_tmr_2, err_tmr_start, err_sem;
INT8U throttle = 0; /* Value between 0 and 80, which is interpreted as between 0.0V and 8.0V */
void* msg;
INT16S* current_velocity, diff_velocity;
Sem_ControlTask = OSSemCreate(0);
printf("Control Task created!\n");
SWTimer_ControlTask = OSTmrCreate(0, CONTROL_PERIOD, OS_TMR_OPT_PERIODIC , Tmr_Callback_Control_Task, (void *)0,"S/W Timer 1",&err_tmr_2);
if(err_tmr_2 == OS_ERR_NONE){
if(DEBUG)
printf("Timer for CONTROL TASK is created and Started\n");
OSTmrStart(SWTimer_ControlTask, &err_tmr_start);
}
else {
printf("Error while creating control task timer \n");
if(err_tmr_2 == OS_ERR_TMR_NON_AVAIL)
printf(" OS_ERR_TMR_NON_AVAIL : CONTROL TASK \n");
}
while(1)
{
if(DEBUG)
printf("Control task waiting for MBoxPost_Velocity \n\n");
msg = OSMboxPend(Mbox_Velocity, 0, &err);
current_velocity = (INT16S*) msg;
// Set throttle value if gas pedal is pressed
if((gas_pedal == on) && (engine == on)){
throttle = throttle + 10;
if(throttle > 80)
throttle = 80; // Max value of throttle 0 - 80
if(DEBUG_IO)
printf("********** Acclerate Gas_Pedal : %d **********\n", throttle);
}
else {
throttle = 0;
}
if(engine == off){
throttle = 0;
}
// Check for cruise control
if((cruise_control == on) && (engine == on)){
if(REF_VELOCITY == 0)
REF_VELOCITY = *current_velocity;
if(DEBUG_IO)
printf("********** Cruise control Active ********** REF : %d \n",REF_VELOCITY);
show_target_velocity((INT8U) (REF_VELOCITY/10));
if(*current_velocity > REF_VELOCITY){ // Decrease throttle value
diff_velocity = *current_velocity - REF_VELOCITY;
if(diff_velocity > 15){
throttle = 0;
}
else if(diff_velocity > 10){
throttle = throttle - 30;
}
else {
throttle = throttle - 10;
}
if(throttle <= 0) // Throttle 0-80
throttle = 0;
if(DEBUG_IO)
printf("DEC throttle : %d \n", throttle);
}
else {
diff_velocity = REF_VELOCITY - *current_velocity;
if(diff_velocity > 15){
throttle = 80;
}
else if (diff_velocity > 10){
throttle = throttle + 30;
}
else {
throttle = throttle + 10;
}
if(throttle >= 80)
throttle = 80;
if(DEBUG_IO)
printf("INC throttle : %d \n", throttle);
}
}
else {
//cruise_control = off;
REF_VELOCITY = 0;
IOWR_ALTERA_AVALON_PIO_DATA(DE2_PIO_HEX_HIGH28_BASE,0x0000);
}
err = OSMboxPost(Mbox_Throttle, (void *) &throttle);
if(DEBUG)
printf("MBoxPost_Throttle done by CONTROL TASK \n");
if(DEBUG)
printf("SEM ACCESS CONTROL TASK\n\n");
OSSemPend(Sem_ControlTask, 0, &err_sem);
if(DEBUG)
printf("Control Task in Loop\n");
}
}
//audio task
void AudioTask()
{
OS_STATUS os_status;
UBYTE os_err;
AUDIO_STATUS audio;
USHORT actualflagmask;
GBOOL audioStatus = GFALSE;
U8 tsInput;
U32 rx,wx;
U32 offset;
OSSemPend(driver_sync_sem, 0, &os_err);
/* Do initialisation that requires the OS to be running or interrupts enabled*/
/* None of the Core/Verifier or Application tasks are running */
OSSemPost(driver_sync_sem);
tsInput = GH_BM_getm_ReadEnable_HW_BUF_SEL();
if(tsInput == GD_TSD_2)
offset = GH_BM2_get_BufferSize(GD_TSD_AUDIO_PES);
else
offset = GH_BM1_get_BufferSize(GD_TSD_AUDIO_PES);
while(1)
{
os_status = OSFlagPend(eventflagmask, eventflagtype, 0, &actualflagmask);
//SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask ",actualflagmask,0,0);
if((actualflagmask&AUDIO_FILE_PLAYED) == AUDIO_FILE_PLAYED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask1 ",actualflagmask,0,0);
while(dataIndex < memDataSize)
{
OSTimeDly(50);
GD_TSD_GetBufferPointer(GD_TSD_AUDIO_PES, tsInput, &rx, &wx);
GHA_ResumeFeedData(memDataAddr, memDataSize, &dataIndex, &lastDataIndex, &pesLen, wx, rx-1);
if(rx == 0)
wx =offset;
else
wx =rx-1;
if(tsInput == GD_TSD_2 )
GH_BM2_set_BufferWritePointer(GD_TSD_AUDIO_PES, wx);
else
GH_BM1_set_BufferWritePointer(GD_TSD_AUDIO_PES, wx);
}
if(soundFileFlag == AUDIO_PLAYED)
{
//OSQPostToCore(HDI_PL_AUDIO_FILE_COMPLETED_XT, (void*)&loadcompleted, sizeof(HDI_PL_AUDIO_FILE_COMPLETED_XT));
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 loadcompleted.event_qualifier: ",loadcompleted.event_qualifier,0,0);
}
soundFileFlag = AUDIO_COMPLETED;
GD_AUD_Stop();
GD_AUD_Close();
if(audioStatus == GTRUE)
{
HDIStartAudio();
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)" start audio",0,0,0);
}
}
else if((actualflagmask&AUDIO_FILE_STOPPED) == AUDIO_FILE_STOPPED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask2 ",actualflagmask,0,0);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 loadcompleted.event_qualifier: ",loadcompleted.event_qualifier,0,0);
}
else if((actualflagmask&AUDIO_STATUS_STARTED) == AUDIO_STATUS_STARTED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask3 ",actualflagmask,0,0);
if(audioStatus == GFALSE)
{
audioStatus = GTRUE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_RUNNING;
audio.standard_id = MPEG;
audio.parameters.mpeg_status.layer = aoparameter.audio_state.parameters.mpeg_status.layer;
audio.parameters.mpeg_status.bitrate_index = aoparameter.audio_state.parameters.mpeg_status.bitrate_index;
audio.parameters.mpeg_status.sampling_frequency = aoparameter.audio_state.parameters.mpeg_status.sampling_frequency;
audio.parameters.mpeg_status.mode = aoparameter.audio_state.parameters.mpeg_status.mode;
audio.parameters.mpeg_status.emphasis = aoparameter.audio_state.parameters.mpeg_status.emphasis;
OSTimeDly(30);
HDIGetAudioStatus(&audio);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 aoparameter.change_mask ",aoparameter.change_mask,0,0);
if((aoparameter.audio_state.parameters.mpeg_status.layer!=audio.parameters.mpeg_status.layer)||
(aoparameter.audio_state.parameters.mpeg_status.bitrate_index!=audio.parameters.mpeg_status.bitrate_index)||
(aoparameter.audio_state.parameters.mpeg_status.sampling_frequency!=audio.parameters.mpeg_status.sampling_frequency)||
(aoparameter.audio_state.parameters.mpeg_status.mode!=audio.parameters.mpeg_status.mode)||
(aoparameter.audio_state.parameters.mpeg_status.emphasis!=audio.parameters.mpeg_status.emphasis))
{
aoparameter.change_mask |= 0x04;
aoparameter.audio_state.parameters.mpeg_status.layer = audio.parameters.mpeg_status.layer;
aoparameter.audio_state.parameters.mpeg_status.bitrate_index = audio.parameters.mpeg_status.bitrate_index;
aoparameter.audio_state.parameters.mpeg_status.sampling_frequency = audio.parameters.mpeg_status.sampling_frequency;
aoparameter.audio_state.parameters.mpeg_status.mode = audio.parameters.mpeg_status.mode;
aoparameter.audio_state.parameters.mpeg_status.emphasis = audio.parameters.mpeg_status.emphasis;
}
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
aoparameter.change_mask = 0;
}
else if((actualflagmask&AUDIO_STATUS_STOPPED) == AUDIO_STATUS_STOPPED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask4 ",actualflagmask,0,0);
if(audioStatus == GTRUE)
{
audioStatus = GFALSE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_STOPPED;
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
aoparameter.change_mask = 0;
}
else if((actualflagmask&AUDIO_TUNER_RECONNECTED) == AUDIO_TUNER_RECONNECTED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask5 ",actualflagmask,0,0);
if(audioStatus == GTRUE)
{
audioStatus = GFALSE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_STOPPED;
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
}
else if((actualflagmask&AUDIO_TUNER_REMOVED) == AUDIO_TUNER_REMOVED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask6 ",actualflagmask,0,0);
if(audioStatus == GFALSE)
{
audioStatus = GTRUE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_RUNNING;
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
}
}
}
void ButtonIO(void* pdata)
{
INT8U err_tmr, err_tmr_start, err_sem;
int button_status;
Sem_ButtonIO = OSSemCreate(0);
Sem_ButtonIO_IP = OSSemCreate(0); // For getting user Input
printf("ButtonIO Task created!\n");
SWTimer_ButtonIO = OSTmrCreate(0, ButtonIO_PERIOD, OS_TMR_OPT_PERIODIC , Tmr_Callback_ButtonIO_Task, (void *)0,"ButtonIO",&err_tmr);
if(err_tmr == OS_ERR_NONE){
if(DEBUG)
printf("Timer for ButtonIO is created\n");
OSTmrStart(SWTimer_ButtonIO, &err_tmr_start);
if(err_tmr_start == OS_ERR_NONE){
if(DEBUG)
printf("Timer Started in ButtonIO \n");
}
else {
printf("Problem starting timer in ButtonIO TASK \n");
}
}
else {
printf("Error while creating ButtonIO task timer \n");
if(err_tmr == OS_ERR_TMR_INVALID_OPT)
printf(" OS_ERR_TMR_INVALID_OPT : ButtonIO TASK \n");
}
while(1)
{
if(DEBUG)
printf("ButtonIO task \n");
button_status = buttons_pressed();
if(DEBUG)
printf("Button Status : %d, %x \n",button_status, button_status & 15);
button_status = button_status & 15;
if(button_status & 4) // Brake Pedal pressed
{
brake_pedal = on;
cruise_control = off;
}
else {
brake_pedal = off;
}
if((button_status & 1) && (engine == on)) // Gas Pedal pressed
{
gas_pedal = on;
cruise_control = off;
}
else {
gas_pedal = off;
}
// Cruse Contol pressed
if((button_status & 2) && (top_gear == on) && (CUR_VELOCITY >= Threshold_Velocity_CC) && (gas_pedal == off) && (brake_pedal == off))
{
if(DEBUG_IO)
printf("Cruise control detected -----");
cruise_control = on;
}
OSSemPost(Sem_ButtonIO_IP);
if(DEBUG)
printf("SEM ACCESS ButtonIO TASK\n\n");
OSSemPend(Sem_ButtonIO, 0, &err_sem);
if(DEBUG)
printf("ButtonIO Task in Loop\n");
}
}
/*
*********************************************************************************************************
* Output PWM
*********************************************************************************************************
*
*********************************************************************************************************
*/
void OutputTask(void *p_arg)
{
CPU_TS ts;
OS_ERR err;
CPU_INT16U Commande;
CPU_INT16U value;
CPU_INT16U last_value;
float angle_value;
float angle_Commande;
float PID;
//Flush the first conversion, the data is sometime wrong
OSSemPend(&semADC_Complete,0,OS_OPT_PEND_BLOCKING,&ts,&err);
//Reset the ticks for calculation of the frequency of the PID
OSTimeSet(0,&err);
while (1)
{
//Pend on data ready from the ADC interrupt
OSSemPend(&semADC_Complete,0,OS_OPT_PEND_BLOCKING,&ts,&err);
//Get the ADC value
OSMutexPend(&mutADC,0,OS_OPT_PEND_BLOCKING,&ts,&err);
value = strSemADC.uValue;
OSMutexPost(&mutADC,OS_OPT_POST_NONE,&err);
//Get the Command value from Timer3
OSMutexPend(&mutTMR3,0,OS_OPT_PEND_BLOCKING,&ts,&err);
Commande = Command;
OSMutexPost(&mutTMR3,OS_OPT_POST_NONE,&err);
//Regression Linéaire
angle_value = (value-290.45)/19.12;
angle_Commande = (Commande-600)/10;
//Timestamp Print shows that
//a delay of 50ms is usualy precise on a long period of time so
// there is no need to calculate it software like
//float PIDcal(float setpoint,float actual_position,(TIMESTAMP-LASTTIMESTAMP)*Tick_Period)
//instead we will use a defined value in PID.h for the deltaT
//To see the veracity of this affirmation, simply enable this printf
// printf("TS = %d\n\r", GetTimeStamp());
//According to the usage of the CPU, the delay between calls to this function can change
//Make sure there is enough process to calculate an efficient PID or use the TIMESTAMP-LASTTIMESTAMP
//in PID to make sure deltaT is correct
//Calcul du PID
PID=PIDcal(angle_Commande,angle_value);
//Protection du moteur
//Arret du moteur si on approxime la commande
if(abs(angle_Commande - angle_value) < .8)
TIM1->CCR1=0;
//Réduction de la vitesse si on approxime la commande
else if(abs(angle_Commande - angle_value) < 5)
TIM1->CCR1=(int)(400+150*abs((int)PID));
//Vérification des limites physique du moteur
else if(value-last_value > 0)
{
if(value-(last_value - value) < 500) //Limite atteinte
TIM1->CCR1=500;
else
TIM1->CCR1=(int)(500+700*abs((int)PID)); //Fonctionnement normal
}
else
{
if(2*value-last_value > 3500) //Limite atteinte
TIM1->CCR1=500;
else
TIM1->CCR1=(int)(500+700*abs((int)PID)); //Fonctionnement normal
}
//Determine le sens du moteur
if (PID>0)
TIM1->CCER=0x01;
else
TIM1->CCER=0x04;
}
}
void SwitchIO(void* pdata)
{
INT8U err_tmr, err_tmr_start, err_sem, switch_status;
Sem_SwitchIO = OSSemCreate(0);
Sem_SwitchIO_IP = OSSemCreate(0); // For getting user input
printf("SwitchIO Task created!\n");
SWTimer_SwitchIO = OSTmrCreate(0, SwitchIO_PERIOD, OS_TMR_OPT_PERIODIC , Tmr_Callback_SwitchIO_Task, (void *)0,"SwitchIO",&err_tmr);
if(err_tmr == OS_ERR_NONE){
OSTmrStart(SWTimer_SwitchIO, &err_tmr_start);
if(DEBUG)
printf("Timer for SwitchIO is created and Started \n");
}
else {
printf("Error while creating SwitchIO task timer \n");
if(err_tmr == OS_ERR_TMR_NAME_TOO_LONG)
printf(" OS_ERR_TMR_NAME_TOO_LONG : SwitchIO TASK \n");
}
while(1)
{
if(DEBUG)
printf("SwitchIO task \n");
switch_status = switches_pressed();
if(DEBUG)
printf("Switch Status : %d \n", switch_status);
if(switch_status & 1) // Engine pressed
{
engine = on;
}
else if(CUR_VELOCITY == 0){
engine = off;
}
if(switch_status & 2) // Top Gear pressed
{
top_gear = on;
}
else {
top_gear = off;
cruise_control = off;
}
OSSemPost(Sem_SwitchIO_IP);
if(DEBUG)
printf("SEM ACCESS SwitchIO TASK\n\n");
OSSemPend(Sem_SwitchIO, 0, &err_sem);
if(DEBUG)
printf("SwitchIO Task in Loop\n");
}
}
/**
* This task polls the switches and then
* posts a message to the message queue
* if an alarm needs to be activated
*/
void switchTask(void *data) {
// Error Referene
INT8U err;
// Local zone status
auto int localZone0;
auto int localZone1;
auto int localZone2;
auto int localZone3;
// Local switch state
auto int sw0State;
auto int sw1State;
auto int sw2State;
auto int sw3State;
// Result for message queue
static char result;
// Initialize zones
localZone0 = ON;
localZone1 = ON;
localZone2 = ON;
localZone3 = ON;
// Initialize switch state
sw0State = OFF;
sw1State = OFF;
sw2State = OFF;
sw3State = OFF;
// Loop forever
while(1) {
// Check switches
sw0State = digIn(ID_SWITCH_1);
sw1State = digIn(ID_SWITCH_2);
sw2State = digIn(ID_SWITCH_3);
sw3State = digIn(ID_SWITCH_4);
// Check to see if we have any switches
if(!sw0State || !sw1State || !sw2State || !sw3State ) {
// Take a semaphore and get the current zone states
OSSemPend(zoneSem, 0, &err);
localZone0 = zone0State;
localZone1 = zone1State;
localZone2 = zone2State;
localZone3 = zone3State;
OSSemPost(zoneSem);
// Check to see which zones (if any) have been triggered
if(!sw0State && localZone0 == ON) {
// Msg Queue Zone 0
result = '0';
}
else if(!sw1State && localZone1 == ON) {
// Msg Queue Zone 1
result = '1';
}
else if(!sw2State && localZone2 == ON) {
// Msg Queue Zone 2
result = '2';
}
else if(!sw3State && localZone3 == ON) {
// Msg Queue Zone 3
result = '3';
}
else {
//Nope
result = 'A';
}
// Post the message
printf("Posting alarm message \n");
OSQPost(msgQueuePtr, (void *)&result);
}
// Update Alarm State (in case web bypassed/disarmed)
OSSemPend(alarmSem, 0, &err);
if(alarming == OFF) {
digOut(ID_BUZZER, OFF);
digOut(LED_0_ID, OFF);
digOut(LED_1_ID, OFF);
digOut(LED_2_ID, OFF);
digOut(LED_3_ID, OFF);
}
OSSemPost(alarmSem);
//Done
OSSemPost(switchToHTTP);
// Try to take a semaphore, this will block us
OSSemPend(httpToSwitch, 0, &err);
}
}
/*********************************************************************************************************
** Function name: taskStart
** Descriptions: Start task
** input parameters: *parg
** output parameters: ?
** Returned value: ?
*********************************************************************************************************/
static void TaskStart (void *parg)
{
INT8U err;
UserRS485Send ussend;
(void)parg;
#if OS_TASK_STAT_EN > 0
OSStatInit(); /* Enable statistics */
#endif
/* Init the file system */
optionSaveStruct.masterIP[1]=0xaa;
EEPROM_WriteStruct(optionSaveStruct);
yaffs_start_up();
File_Init();
KeyInit();
KeyQueueHead=OSQCreate(KeyMsg,KEYQSIZE); //创建按键消息队列 在优先级较高的任务中执行
ConfigQueueHead = OSQCreate( ConfigMsg, CONFIGQSIZE );
UploadQueueHead = OSQCreate( UploadMsg, UPLOADQSIZE );
EquipmentTaskSem = OSSemCreate(0);
UartRcvTaskSem = OSSemCreate(1);
sem_tcp_init_done = OSSemCreate(0);
UartSendTaskSem = OSSemCreate(1);
tcpip_init(tcpip_init_done, NULL);
OSSemPend(sem_tcp_init_done, 0, &err);
eth_netif_init(ipConfig);
TCPTest();
err = OSTaskCreate((void (*)(void *)) Equipment_Task,
(void * ) 0,
(OS_STK * )&TaskEquipmentStk[TASK_KEY_STK_SIZE - 1],
(INT8U ) TASK_EQUIPMENT_PRIO ); /* Create Equipment Task */
//printf("Equipment_Task: err = %d\n", err );
err = OSTaskCreate((void (*)(void *)) UartRcv_Task,
(void * ) 0,
(OS_STK * )&TaskUartRcvStk[TASK_KEY_STK_SIZE - 1],
(INT8U ) TASK_UART_RCV_PRIO ); /* Create Equipment Task */
//printf("UartRcv_Task: err = %d\n", err );
err = OSTaskCreate((void (*)(void *)) FileReceive_Task,
(void * ) 0,
(OS_STK * )&TaskFileRcvStk[TASK_FILERCV_STK_SIZE - 1],
(INT8U ) TASK_FILE_RCV_PRIO ); /* Create FileReceive Task */
//printf("FileReceive_Task: err = %d\n", err );
err = OSTaskCreate((void (*)(void *)) hvsftpd_main,
(void * ) 0,
(OS_STK * )&TaskFtpStk[TASK_FTP_STK_SIZE - 1],
(INT8U ) TASK_FTP_PRIO ); /* Create FileReceive Task */
printf(" hvsftpd_Task: err = %d\n", err );
err = OSTaskCreate ((void (*)(void *))Menu_Task,
(void *)0,
(OS_STK *)&Gstk2[MENU_TASK_STK_SIZE-1],
(INT8U )MENU_TASK_PRIO ); /* Create Menu Task */
/* err = OSTaskCreate ((void (*)(void *))Test_Key,
(void *)0,
(OS_STK *)&TestStk[511],
(INT8U )44 ); / Create Menu Task */
App_KeyTaskCreate(); /* Create Task Key */
#if FRMB_DEBUG
ussend.address=0x00;
ussend.ctrl=0x01;
ussend.data[0]=0xaa;
ussend .len=1;
ussend.CRCH=0x00;
ussend.CRCL=0x11;
#else
// err=OSTaskCreate((void (*)(void *))FMB_Task,
// (void *)0,
// (OS_STK *)&FMBStk[FMB_TASK_STK_SIZE-1],
// (INT8U )FMB_TASK_PRIO );
//
// err=OSTaskCreate((void (*)(void *))FMB_Poll_Task,
// (void *)0,
// (OS_STK *)&FMBPollStk[FMB_TASK_STK_SIZE-1],
// (INT8U )FMB_POLL_TASK_PRIO );
#endif
while (1)
{
#if FRMB_DEBUG
RS485Send_Struct(RS485_UART0,&ussend);
RS485Send_Struct(RS485_UART2,&ussend);
RS485Send_Struct(RS485_UART3,&ussend);
RS485Send_Struct(RS485_UART4,&ussend);
#else
#endif
//OSTimeDly(500);
OSTaskSuspend(OS_PRIO_SELF); /* The start task can be pended*/
/* here. ?????????? */
}
}
/**
Function Name : Wave_Start_Playing
Engineer : Gustavo Denardin
Date : 16/06/2011
Parameters : Nothing
Returns : Nothing
Notes :
*/
void Wave_Start_Playing(void)
{
WAVE_BUFFER *WaveInfo;
INT8U *Buff8;
INT16S *Buff16;
INT16U size = 0;
INT8U first = 0;
//_DAC1_Enable();
//Sound_AudioAmplifierTurnOn(); //Turn On the Audio Amplifier
OSSemPost(OpenWave);
for(;;)
{
(void)OSMboxPend(SendWaveBuffer,(void **)&WaveInfo,0);
#if (_VOLUME_CONTROL == 1)
if(SetVolumeLevel == 0) //Mute
{
//Sound_AudioAmplifierStandby(); //Standby the Audio Amplifier
}
else
{
//Sound_AudioAmplifierTurnOn(); //Turn On the Audio Amplifier
//Sound_VolumeControl((INT8U)SetVolumeLevel); //Set Volume level
}
#endif
if (first == 0)
{
first = 1;
//Set sample rate: (8kHz, 11.025kHz, 44.1kHz or 48khz)
Wave_SetSampleRate(WaveInfo->SampleRate);
//Enable timer
Timer2Start();
}
if ((WaveInfo->Size) == 0)
{
break;
}
size = WaveInfo->Size;
if (WaveInfo->BitRate == 16)
{
Buff16 = (INT16S*)WaveInfo->Buff;
}
else if (WaveInfo->BitRate == 8)
{
Buff8 = (INT8U*)WaveInfo->Buff;
}
do
{
OSSemPend(Audio,0);
if (WaveInfo->BitRate == 16)
{
if (vol > 0)
{
DAConvert(((ByteSwap(*Buff16)) >> (4 + (10 - vol))) + 2048);
}else
{
DAConvert(0);
}
Buff16++;
if((WaveInfo->NumChannels) == 2)
{
Buff16++; //Pula o pacote do outro canal
size--;
}
}
else if (WaveInfo->BitRate == 8)
/*
*********************************************************************************************************
* APPLICATION TASK DEFINITIONS
*********************************************************************************************************
*/
static void appTaskCommand(void *pdata) {
uint8_t osStatus;
char command[72];
uint32_t commandLen;
uint32_t i;
uint32_t j;
/* Start the OS ticker -- must be done in the highest priority task */
SysTick_Config(SystemCoreClock / OS_TICKS_PER_SEC);
while ( true ) {
OSSemPend(packetSem, 0, &osStatus);
commandLen = xbee.xbeeNetstring(packetBuf, command);
switch (command[0]) {
case '1': {
led1Flashing = !led1Flashing;
break;
}
case '2': {
led2Flashing = !led2Flashing;
break;
}
case '3': {
led3Flashing = !led3Flashing;
break;
}
case '4': {
led4Flashing = !led4Flashing;
break;
}
case '5': {
break;
}
case '6': {
memset(testMessage, ' ', 60);
testMessage[60] = '\0';
for (i = 1, j = 0; j < commandLen - 1; i += 1, j += 1) {
testMessage[j] = command[i];
}
d->setCursor(2,22);
d->printf("%s", testMessage);
break;
}
case 'R': {
d->fillScreen(RED);
break;
}
case 'G': {
d->fillScreen(GREEN);
break;
}
case 'B': {
d->fillScreen(BLUE);
break;
}
case 'W': {
d->fillScreen(WHITE);
break;
}
default: {
break;
}
}
}
}
static void timerTask(void *data)
{
Timer *thisTimer;
void (* timerHandler)(void *);
void *timerArg;
UBYTE err;
for (;;) {
/* If no ready timers, wait for one. Note that the mutex is just
* to protect the timer queue. Somebody needs to wake us up when
* a timer expires. */
#ifdef OS_DEPENDENT
OSSemPend(mutex, 0, &err);
#endif
thisTimer = timerHead.timerNext;
if ((long)(thisTimer->expiryTime - OSTimeGet()) > 0) {
#ifdef OS_DEPENDENT
OSSemPost(mutex);
(void) OSTaskSuspend(OS_PRIO_SELF);
#endif
#if ONETASK_SUPPORT > 0
// In non multitasking environment - return
// We don't want to loop for ever!
return;
#endif
}
else {
/* If the timer is the sentinal, reset the expiry time to the
* maximum delay. This way the timer interrupt handler doesn't
* need to do a separate test for the timer queue being empty.
*/
if (thisTimer == &timerHead) {
timerHead.expiryTime = OSTimeGet() + MAXJIFFYDELAY;
}
else {
/* Remove the timer from the queue and if it's marked
* as temporary, put it back on the free list. */
thisTimer = timerHead.timerNext;
(timerHead.timerNext = thisTimer->timerNext)->timerPrev = &timerHead;
thisTimer->timerPrev = NULL;
if (thisTimer->timerFlags & TIMERFLAG_TEMP) {
thisTimer->timerNext = timerFree;
timerFree = thisTimer;
}
}
/* Update timer counter - used as activity counter for
* development purposes. */
thisTimer->timerCount++;
/* Get the handler parameters which could change when
* we post the mutex. */
timerHandler = thisTimer->timerHandler;
timerArg = thisTimer->timerArg;
/* Invoke the timer handler. Make sure that we post the mutex
* first so that we don't deadlock if the handler tries to reset
* the timer. */
#ifdef OS_DEPENDENT
OSSemPost(mutex);
#endif
timerHandler(timerArg);
}
}
}
/*
* Main Task
*/
void MainTask(void* pdata) {
// int frameDone = 0; // RC required
printf("Starting Main task...\n");
int16_t avgSensorData[9] = { 0 }; //Order: ACC- GYR - COMP
uint32_t averagedDataDeltaT = 0;
float filteredSensorData[9] = { 0 }; //Order: ACC- GYR - COMP
int16_t rcValues[8];
INT8U os_err = OS_ERR_NONE;
uint8_t data_err = NO_ERR;
struct logData* loggData = malloc(sizeof(struct logData));
while (1) {
//Semaphore for periodic task
OSSemPend(mainTaskSem, 0, &os_err);
//Sensor Test
if (SDM_NEW_DATA_AVAILABLE == 1) {
os_err = getSensorData(avgSensorData, &averagedDataDeltaT);
data_err = filterSensorData(avgSensorData, filteredSensorData, averagedDataDeltaT); //only filter new data
}
if (RC_RECEIVER_NEW_DATA_AVAILABLE == 1 ){
getRCvalues(rcValues); //new rc commands will be copied in local array
printf("THROTTLE: %d\tROLL: %d\tYAW: %d\tPITCH: %d\n", rcValues[RC_THROTTLE_INDEX], rcValues[RC_ROLL_INDEX], rcValues[RC_YAW_INDEX], rcValues[RC_PITCH_INDEX]);
}
//assuming X axis from Filter is PITCH
float pidPITCHMidVal = PIDPitchCalculation(rcValues[RC_PITCH_INDEX], (float) filteredSensorData[EULER_PITCH_INDEX]);
//assuming X axis from Filter is ROLL
float pidROLLMidVal = PIDRollCalculation(rcValues[RC_ROLL_INDEX], (float) filteredSensorData[EULER_ROLL_INDEX]);
//assuming X axis from Filter is YAW
float pidYAWMidVal = PIDYawCalculation(rcValues[RC_YAW_INDEX], (float) filteredSensorData[EULER_YAW_INDEX]);
// printf("PITCH: %f\tROLL: %f\tYAW: %f\n", pidPITCHMidVal, pidROLLMidVal, pidYAWMidVal); //debug print
mapToMotors(rcValues[RC_THROTTLE_INDEX], pidROLLMidVal, pidPITCHMidVal, pidYAWMidVal);
//TODO Copy new Data to Struct for logging
// int i;
// for (i = 0; i < 9; ++i) { //copy logging data to txStruct
// loggData->raw[i] = avgSensorData[i];
// loggData->filter[i] = filteredSensorData[i];
// }
//
// loggData->pid[0] = pidPITCHMidVal;
// loggData->pid[1] = pidROLLMidVal;
// loggData->pid[2] = pidYAWMidVal;
//
// int j;
// for (j = 0; j < 8; ++j) {
// loggData->rawRadio[i] = rcValues[i];
// }
// OSQPost(loggerQsem, (void*) loggData);
}
}
/**
\brief A demo task to show the use of the SPI.
*/
static void spiTask(void* unused) {
INT8U i;
dn_error_t dnErr;
INT8U osErr;
dn_spi_open_args_t spiOpenArgs;
INT8U sendStatus;
INT8U pkBuf[sizeof(loc_sendtoNW_t) + APP_DATA_BUF_SIZE];
loc_sendtoNW_t* pkToSend;
dn_ioctl_spi_transfer_t spiTransfer;
//===== initialize the configuration file
initConfigFile();
//===== initialize packet variables
pkToSend = (loc_sendtoNW_t*)pkBuf;
//===== initialize SPI
// open the SPI device
spiOpenArgs.maxTransactionLenForCPHA_1 = 0;
dnErr = dn_open(
DN_SPI_DEV_ID,
&spiOpenArgs,
sizeof(spiOpenArgs)
);
if ((dnErr < DN_ERR_NONE) && (dnErr != DN_ERR_STATE)) {
dnm_cli_printf("unable to open SPI device, error %d\n\r",dnErr);
}
// initialize spi communication parameters
spiTransfer.txData = spiNetApp_vars.spiTxBuffer;
spiTransfer.rxData = spiNetApp_vars.spiRxBuffer;
spiTransfer.transactionLen = sizeof(spiNetApp_vars.spiTxBuffer);
spiTransfer.numSamples = 1;
spiTransfer.startDelay = 0;
spiTransfer.clockPolarity = DN_SPI_CPOL_0;
spiTransfer.clockPhase = DN_SPI_CPHA_0;
spiTransfer.bitOrder = DN_SPI_MSB_FIRST;
spiTransfer.slaveSelect = DN_SPI_SSn0;
spiTransfer.clockDivider = DN_SPI_CLKDIV_16;
//===== wait for the mote to have joined
OSSemPend(spiNetApp_vars.joinedSem,0,&osErr);
ASSERT(osErr == OS_ERR_NONE);
while(1) { // this is a task, it executes forever
//===== step 1. write over SPI
// set bytes to send
for (i=0;i<sizeof(spiNetApp_vars.spiTxBuffer);i++) {
spiNetApp_vars.spiTxBuffer[i] = i;
}
// send bytes
dnErr = dn_ioctl(
DN_SPI_DEV_ID,
DN_IOCTL_SPI_TRANSFER,
&spiTransfer,
sizeof(spiTransfer)
);
if (dnErr < DN_ERR_NONE) {
dnm_cli_printf("Unable to communicate over SPI, err=%d\r\n",dnErr);
}
//===== step 2. print over CLI
dnm_cli_printf("SPI sent: ");
for (i=0;i<sizeof(spiNetApp_vars.spiTxBuffer);i++) {
dnm_cli_printf(" %02x",spiNetApp_vars.spiTxBuffer[i]);
}
dnm_cli_printf("\r\n");
dnm_cli_printf("SPI received:");
for (i=0;i<sizeof(spiNetApp_vars.spiRxBuffer);i++) {
dnm_cli_printf(" %02x",spiNetApp_vars.spiRxBuffer[i]);
}
dnm_cli_printf("\r\n");
//===== step 3. send data to manager
// fill in packet "header"
// Note: sendto->header is filled in dnm_loc_sendtoCmd
pkToSend->locSendTo.socketId = loc_getSocketId();
pkToSend->locSendTo.destAddr = DN_MGR_IPV6_MULTICAST_ADDR; // IPv6 address
pkToSend->locSendTo.destPort = WKP_SPI_NET;
pkToSend->locSendTo.serviceType = DN_API_SERVICE_TYPE_BW;
pkToSend->locSendTo.priority = DN_API_PRIORITY_MED;
pkToSend->locSendTo.packetId = 0xFFFF;
// fill in the packet payload
memcpy(&pkToSend->locSendTo.payload[0],&spiNetApp_vars.spiRxBuffer[0],APP_DATA_BUF_SIZE);
// send the packet
dnErr = dnm_loc_sendtoCmd(pkToSend, APP_DATA_BUF_SIZE, &sendStatus);
ASSERT (dnErr == DN_ERR_NONE);
//===== step 4. pause until next iteration
// this call blocks the task until the specified timeout expires (in ms)
OSTimeDly(spiNetApp_vars.period);
}
}
void etherLock(void)
{
UBYTE err;
OSSemPend(mutex, 0, &err);
}
/**************************************************
*Clocktask - counts the number of clock cycles like a 12 hour clock
* uses a secflag in order to count a 1 second cycle
Initialize: TimeOfDay
*******************************************************/
static void ClockTask(void *p_arg)
{
INT8U error;
INT8U key;
INT8U keypress;
INT8U err;
(void)p_arg;
FOREVER()
{
DBUG_PORT &= ~PP3;
OSSemPend(SecFlag, 0 ,&err);
DBUG_PORT |= PP3;
TimeOfDay.sec = TimeOfDay.sec + 1;
if(TimeOfDay.sec > 0x3B && TimeOfDay.min < 0x3B && TimeOfDay.hr < 0x0D)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min++;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x0C)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x01;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x01)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x02;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x02)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x03;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x03)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x04;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x04)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x05;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x05)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x06;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x06)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x07;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x07)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x08;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x08)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x09;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x09)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x0A;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x0A)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x0B;
}
else if (TimeOfDay.sec > 0x3B && TimeOfDay.min == 0x3B
&& TimeOfDay.hr == 0x0B)
{
TimeOfDay.sec = 0x00;
TimeOfDay.min = 0x00;
TimeOfDay.hr = 0x0C;
}
else
{
}
}
}
void PCInterfaceTask(void *data)
{
IO_MSG msg;
OSMsg *pci_msg;
UBYTE err;
ULONG task_event;
USHORT timeout = FAST_PEND_TIMEOUT;
#if defined(QCBUILD_HDI) || defined(QCBUILD_NDC)
/* not required by API version as engine.c does this */
/* do not set this task running until after the drivers are away */
OSSemPend(driver_sync_sem, 0, &err);
OSSemPost(driver_sync_sem);
#endif
/*
* Loop forever handling sequence manager requests and attempting
* to read data from RS232 port (PC interface).
*/
for(;;)
{
pci_msg = OSQPend(PCI_EV_QUEUE, timeout, &err);
if (err == OS_TIMEOUT)
{
/* ensure msg is NULL to prevent accidental freeing */
pci_msg = NULL;
task_event = STB_EV_PCI_TIMED_OUT;
}
else
{
task_event = pci_msg->msg_ev;
}
switch (task_event)
{
case SEQ_EV_ESTBLSH_COMMS_LINK:
/* open connection to PC */
OpenConnection();
#ifdef _INC_HELLOWORLD
if (is_link_open)
{
strcpy((char*)msg.byte, "hello world");
msg.size = strlen((char*)msg.byte);
WriteConnection(&msg);
}
#endif
timeout = FAST_PEND_TIMEOUT;
break;
case SEQ_EV_DROP_COMMS_LINK:
/* drop connection to PC (if any) */
CloseConnection();
timeout = SLOW_PEND_TIMEOUT;
break;
case STB_EV_PCI_TIMED_OUT:
default:
/* read data from connection (if open) */
if (is_link_open)
{
if (ReadConnection(&msg))
{
if (msg.size > 0)
{
/* have something */
if (IsEstablishLinkData(&msg))
{
ActionEstablishLinkCommand(&msg);
}
else if (IsUploadData(&msg))
{
ActionUploadData(&msg);
}
else if (IsDownloadData(&msg))
{
ActionDownloadData(&msg);
} /* else invalid message read */
} /* else nothing read */
} /* else read failure occurred */
} /* else no link established */
break;
}
/* free the buffer obtained with OSSemPend */
if (pci_msg != NULL) /* don't free a NULL buffer */
{
#ifndef CLAYMORE
OSFreeMsgBuffer(pci_msg);
#else
OSFreeMsgBuffer(PCI_EV_QUEUE,pci_msg);
#endif
}
}
TOUCH(data); /* remove compilation warning */
}
