/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_2;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = WaitEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(18,E_OK, result_inst_1);
SCHEDULING_CHECK_INIT(19);
result_inst_2 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(19,E_OK, result_inst_2);
}
void SetupMenu() // Set up menu
{
uint8 i;
while(1)
{
i = GetMenuItem("TERMINAL SETUP","WiFi Setup","ESPUSB Fudge","Scan WiFi","Test Wifi","Exit");
if(i==1) SetupWIFI();
if(i==2) // Open USB in CDC Mode passthough to ESP-01
{
SerialPurge(WIFI_UART);
CLS();
LCDWriteStrAt(0,4, " USB <-> ESP01 ");
LCDWriteStrAt(0,6, " PROGRAMMIING ");
LCDWriteStrAt(0,10," PRESS KEY TO ");
LCDWriteStrAt(0,12," CONTINUE ");
PORTSetPinsDigitalIn(IOPORT_C, BIT_2 );
PPSUnLock; // Unlock PPS (Peripheral Pin Select) to allow PIN Mapping
PPSOutput(4,RPC2,NULL);
PPSLock; // lock PPS
ESP_PGM(0);
WIFI_PWR(1);
i = WaitEvent(9999);
CLS();
WIFI_PWR(0);
ESP_PGM(1);
DelayMs(500);
WIFI_PWR(1);
LCDWriteStrAt(0,4, " USB <-> ESP01 ");
LCDWriteStrAt(0,6, " PASSTHROUGH ");
LCDWriteStrAt(0,10," POWER OFF TO ");
LCDWriteStrAt(0,12," RESUME ");
while(1);
}
if(i==4)
{
if(CheckWIFI()) LCDInform("SUCCESS","Connection OK");
}
if(i==3) { LCDInform("WARNING","Not Implemented"); }
if(i==0 ||i==5) return;
}
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t2_instance(void)
{
StatusType result_inst_1,result_inst_2, result_inst_3;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = ActivateTask(t1);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(2);
result_inst_2 = WaitEvent(Event2);
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(10);
result_inst_3 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK , result_inst_3);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = SetAbsAlarm(Alarm1, 16, 16);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(2);
result_inst_2 = WaitEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(3);
result_inst_3 = SetAbsAlarm(Alarm1, 2, 2);
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OS_STATE , result_inst_3);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t3_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3;
StatusType received_char;
SCHEDULING_CHECK_INIT(2);
result_inst_1 = WaitEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OK, result_inst_1);
SCHEDULING_CHECK_INIT(7);
result_inst_2 = ReceiveMessage(rm_setevent, &received_char);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(7,E_OK, result_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(7,(int)('2'), (int)received_char);
SCHEDULING_CHECK_INIT(8);
result_inst_3 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OK, result_inst_3);
}
void CanFunctionTask(void) {
printf("CanFunctionTask\r\n");
for(;;){
WaitEvent(EVENT_MASK_CanFunctionEvent);
ClearEvent(EVENT_MASK_CanFunctionEvent);
#if !CAN_INTERRUPT
Can_MainFunction_Read();
#endif
Com_MainFunctionRx();
if (ComWrite == true) {
Com_MainFunctionTx();
ComWrite = false;
}
}
}
void StepTask() {
EventMaskType eventMask = 0;
while (1) {
WaitEvent(EVENT_MASK_StepEvent);
GetResource(RES_SCHEDULER);
GetEvent(TASK_ID_StepTask, &eventMask);
ClearEvent(EVENT_MASK_StepEvent);
ReleaseResource(RES_SCHEDULER);
if (eventMask & EVENT_MASK_StepEvent) {
Rte_TesterRunnable();
}
if (eventMask & EVENT_MASK_StepEvent) {
Rte_Logger2Runnable();
}
if (eventMask & EVENT_MASK_StepEvent) {
Rte_LoggerRunnable();
}
}
}
void SleepTask(void)
{
uint32_t i;
for(;;) {
// Alarms every tick
WaitEvent(EVENT_MASK_SLEEP_ALARM_TASK);
ClearEvent(EVENT_MASK_SLEEP_ALARM_TASK);
ticks++;
for(i=0;i<OS_TASK_CNT;i++)
{
if((timeoutlist[i].active == TRUE) && (timeoutlist[i].timeout == ticks))
{
timeoutlist[i].active = FALSE;
SetEvent(i,timeoutlist[i].mask);
}
}
}
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4;
SCHEDULING_CHECK_INIT(8);
result_inst_1 = SetAbsAlarm(Alarm1, 16, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(9);
result_inst_2 = WaitEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(30,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(31);
result_inst_3 = SetEvent(t1, Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(31,E_OK , result_inst_3);
SCHEDULING_CHECK_INIT(32);
result_inst_4 = ChainTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(32,E_OK , result_inst_4);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3;
SCHEDULING_CHECK_STEP(1);
/* Wait Time Frame elapsed */
SCHEDULING_CHECK_INIT(2);
result_inst_1 = SetEvent(t1, t1_event1);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK, result_inst_1);
SCHEDULING_CHECK_INIT(3);
result_inst_2 = WaitEvent(t1_event1);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OK, result_inst_2);
SCHEDULING_CHECK_INIT(4);
result_inst_3 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OK, result_inst_3);
}
void PG_SDLEventSupplier::CombineMouseMotionEvents(SDL_Event* event) {
if ( event->type == SDL_MOUSEMOTION ) {
my_position.x = event->motion.x;
my_position.y = event->motion.y;
SDL_Event nextEvent;
if ( PeepEvent ( &nextEvent ) )
if ( nextEvent.type == SDL_MOUSEMOTION ) {
int motionxrel = event->motion.xrel;
int motionyrel = event->motion.yrel;
// get the event from the queue
WaitEvent( event );
// add the motion distances of the last event
event->motion.xrel += motionxrel;
event->motion.yrel += motionyrel;
my_position.x = event->motion.x;
my_position.y = event->motion.y;
}
}
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t2_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = WaitEvent(Event2);
SCHEDULING_CHECK_AND_EQUAL_INT(5,E_OK, result_inst_1);
SCHEDULING_CHECK_INIT(6);
result_inst_2 = ClearEvent(Event2);
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OK, result_inst_2);
SCHEDULING_CHECK_INIT(7);
result_inst_3 = ActivateTask(t4);
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK, result_inst_3);
SCHEDULING_CHECK_INIT(11);
result_inst_4 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(11,E_OK, result_inst_4);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t2_instance(void)
{
StatusType result_inst_1, result_inst_3, result_inst_4, result_inst_5;
EventMaskType result_inst_2;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = ActivateTask(t1);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OK, result_inst_1);
SCHEDULING_CHECK_INIT(2);
result_inst_3 = GetEvent(t1,&result_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(2, 0 , result_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK, result_inst_3);
SCHEDULING_CHECK_INIT(3);
result_inst_4 = WaitEvent(Event2);
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK, result_inst_4);
SCHEDULING_CHECK_INIT(11);
result_inst_5 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(11,E_OK, result_inst_5);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t2_instance(void)
{
StatusType result_inst_1,result_inst_2,result_inst_3,result_inst_4,result_inst_5;
SCHEDULING_CHECK_INIT(3);
result_inst_1 = ActivateTask(t1);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OS_LIMIT , result_inst_1);
SCHEDULING_CHECK_INIT(4);
result_inst_2 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OS_LIMIT , result_inst_2);
SCHEDULING_CHECK_INIT(5);
result_inst_3 = WaitEvent(Event2);
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK , result_inst_3);
SCHEDULING_CHECK_INIT(11);
result_inst_4 = ChainTask(t1);
SCHEDULING_CHECK_AND_EQUAL_INT(11,E_OS_LIMIT , result_inst_4);
SCHEDULING_CHECK_INIT(12);
result_inst_5 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OK , result_inst_5);
}
void wait(U32 delay)
{
if (ts_timers_count >= TS_MAX_TIMERS)
return;
const U32 timestamp = systick_get_ms() + delay;
U8 index = ts_bin_search(timestamp);
if (index < ts_timers_count && ts_timers[index].timestamp <= timestamp)
++index;
if (ts_timers_count)
for (U8 i = ts_timers_count - 1; i >= index; --i)
ts_timers[i + 1] = ts_timers[i];
ts_timers[index].timestamp = timestamp;
ts_timers[index].task = runtsk;
// TODO: This will not probably work if user declares own timers. Events must be taken by name or passed as parameter.
const EventMaskType timerId = (1UL << runtsk);
ts_timers[index].timer = timerId;
++ts_timers_count;
WaitEvent(timerId);
ClearEvent(timerId);
}
DWORD WINAPI CommMonitor( LPSTR lpData)
{
CommData
SYSTEMTIME SystemTime;
int i, nItemCount, nPackType, nTranType, nDataOff,nResultLen;
BYTE btCalCheckSum, btRxCheckSum;
WORD wSampleNo;
WORD wRSampleNo;
BYTE btResultType;
LPSTR lpPointer;
Init()
nItemCount =0;
ResetOpPointer()
FillDevName()
PurgeComm( hComm, PURGE_RXCLEAR );
SetCommWaitMask(EV_RXFLAG)
while (TRUE)
{
ResetRxPointer()
do
{
GetInQueueLength(dwReadLength)
if(dwReadLength==0 &&dwRxBufferLength==0)
{
WaitEvent(EV_RXFLAG)
GetInQueueLength(dwReadLength)
}
ReadCommBlock(dwReadLength)
if ( dwRxBufferLength>=2)
{
if( (*(lpRxPointer-2)== ETX) )
break;
}
}while(TRUE);
nPackType = lpOpPointer[c_PackTypeOff];
btResultType =0xff;
nItemCount =0;
switch (nPackType)
{
case 'R':
break;
case 'D':
nTranType =lpOpPointer[c_TranTypeOff];
switch (nTranType)
{
case 'B':
break;
case 'E':
if (lpOpPointer[c_TranTypeOff+1]==ETX) break;
default:
GetLocalTime(&SystemTime);
switch (*(lpOpPointer+c_SampleIdOff))
{
case '0':
wSampleNo =StrToInt(lpOpPointer+c_SampleIdOff, c_SampleIDLen+1);
btResultType =c_TypeSample;
break;
case '1':
wSampleNo =StrToInt(lpOpPointer+c_SampleIdOff, c_SampleIDLen+1);
btResultType =c_TypeSample;
break;
case '2':
wSampleNo =StrToInt(lpOpPointer+c_SampleIdOff, c_SampleIDLen+1);
btResultType =c_TypeSample;
break;
case '3':
wSampleNo =StrToInt(lpOpPointer+c_SampleIdOff, c_SampleIDLen+1);
btResultType =c_TypeSample;
break;
case 'Q':
wRSampleNo =StrToInt(lpOpPointer+c_SampleNoOff, c_SampleIDLen);
wSampleNo = wRSampleNo+8100;
btResultType =c_TypeQC;
break;
case 'P':
wRSampleNo =StrToInt(lpOpPointer+c_SampleNoOff, c_SampleIDLen);
wSampleNo = wRSampleNo+6000;
btResultType =c_TypeStat;
break;
case 'E':
wRSampleNo =StrToInt(lpOpPointer+c_SampleNoOff, c_SampleIDLen);
wSampleNo = wRSampleNo+4000;
btResultType =c_TypeEmergency;
break;
case 'U':
wRSampleNo =StrToInt(lpOpPointer+c_SampleNoOff, c_SampleIDLen);
wSampleNo = wRSampleNo+5000;
btResultType =c_TypeUrine;
break;
}
}
if(btResultType != 0xff)
for(nDataOff =c_DataOff; *(lpOpPointer+nDataOff)!=ETX ;)
{
FillSampleID(nItemCount, wSampleNo)
FillItemName(nItemCount, lpOpPointer+nDataOff+c_ItemIDOff, c_ItemIDLen)
DeleZero(lpOpPointer, c_ResultLen)
FillResult(nItemCount, lpPointer ,nResultLen )
FillDate(nItemCount, SystemTime.wYear, SystemTime.wMonth, SystemTime.wDay, SystemTime.wHour)
FillResultType(nItemCount, btResultType)
FillComment(nItemCount, lpOpPointer+nDataOff+c_ErrorCodeOff, c_ErrorCodeLen) //填状态注解
FillErrorCode(nItemCount, c_Reliable)
nItemCount++;
nDataOff+=c_OneDataLen;
}
break;
}
if (nItemCount>0)
{
(*lpResultProcessRoutine)(lpDevice->nDevNO, OutResult, nItemCount);
lpDevice->dwRecordCount+=nItemCount;
}
ResetRxPointer()
PurgeComm( hComm, PURGE_RXCLEAR );
WriteCommChar(ACK)
}
return TRUE;
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
AlarmBaseType AlarmBaseType_inst_1;
EventMaskType EventMaskType_inst_1;
StatusType result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9, result_inst_10, result_inst_11, result_inst_12, result_inst_13, result_inst_14, result_inst_15, result_inst_16, result_inst_17, result_inst_18, result_inst_19;
TaskStateType TaskStateType_inst_1;
TaskType TaskType_inst_1;
TickType TickType_inst_1;
SCHEDULING_CHECK_STEP(1);
SCHEDULING_CHECK_STEP(2);
SuspendAllInterrupts();
SCHEDULING_CHECK_INIT(3);
result_inst_2 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OS_DISABLEDINT, result_inst_2);
SCHEDULING_CHECK_INIT(5);
result_inst_3 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OS_DISABLEDINT, result_inst_3);
SCHEDULING_CHECK_INIT(7);
result_inst_4 = ChainTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OS_DISABLEDINT, result_inst_4);
SCHEDULING_CHECK_INIT(9);
result_inst_5 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OS_DISABLEDINT, result_inst_5);
SCHEDULING_CHECK_INIT(11);
result_inst_6 = GetTaskID(&TaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OS_DISABLEDINT, result_inst_6);
SCHEDULING_CHECK_INIT(13);
result_inst_7 = GetTaskState(t2, &TaskStateType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(14,E_OS_DISABLEDINT, result_inst_7);
SCHEDULING_CHECK_INIT(15);
result_inst_8 = GetResource(Resource1);
SCHEDULING_CHECK_AND_EQUAL_INT(16,E_OS_DISABLEDINT, result_inst_8);
SCHEDULING_CHECK_INIT(17);
result_inst_9 = ReleaseResource(Resource1);
SCHEDULING_CHECK_AND_EQUAL_INT(18,E_OS_DISABLEDINT, result_inst_9);
SCHEDULING_CHECK_INIT(19);
result_inst_10 = SetEvent(t2, Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(20,E_OS_DISABLEDINT, result_inst_10);
SCHEDULING_CHECK_INIT(21);
result_inst_11 = ClearEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(22,E_OS_DISABLEDINT, result_inst_11);
SCHEDULING_CHECK_INIT(23);
result_inst_12 = GetEvent(t2, &EventMaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(24,E_OS_DISABLEDINT, result_inst_12);
SCHEDULING_CHECK_INIT(25);
result_inst_13 = WaitEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(26,E_OS_DISABLEDINT, result_inst_13);
SCHEDULING_CHECK_INIT(27);
result_inst_14 = GetAlarmBase(Alarm1, &AlarmBaseType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(28,E_OS_DISABLEDINT, result_inst_14);
SCHEDULING_CHECK_INIT(29);
result_inst_15 = GetAlarm(Alarm1, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(30,E_OS_DISABLEDINT, result_inst_15);
SCHEDULING_CHECK_INIT(31);
result_inst_16 = SetRelAlarm(Alarm1, 1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(32,E_OS_DISABLEDINT, result_inst_16);
SCHEDULING_CHECK_INIT(33);
result_inst_17 = SetAbsAlarm(Alarm1, 1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(34,E_OS_DISABLEDINT, result_inst_17);
SCHEDULING_CHECK_INIT(35);
result_inst_18 = CancelAlarm(Alarm1);
SCHEDULING_CHECK_AND_EQUAL_INT(36,E_OS_DISABLEDINT, result_inst_18);
SCHEDULING_CHECK_INIT(37);
result_inst_19 = GetActiveApplicationMode();
SCHEDULING_CHECK_AND_EQUAL_INT(38,OSDEFAULTAPPMODE, result_inst_19);
SCHEDULING_CHECK_STEP(39);
ResumeAllInterrupts();
}
DWORD WINAPI CommMonitor( LPSTR lpData)
{
CommData
SYSTEMTIME SystemTime;
int i,nItemCount,nPackLen=0;
BYTE PackFun ;
BOOL OddFlag=FALSE;
LPSTR lpPointer,lptemp1,lptemp2,hRXBuffer=(LPSTR)RxBuffer;
char *p_ACK1="\x10\x31";
char *p_ACK0="\x10\x30";
Init()
ResetOpPointer()
ResetRxPointer()
nItemCount =0;
FillDevName()
SetCommWaitMask(EV_RXFLAG)
PurgeComm( hComm, PURGE_RXCLEAR );
while (TRUE)
{
WaitEvent(EV_RXFLAG)
GetInQueueLength(dwReadLength)
ReadCommBlock(dwReadLength)
lptemp1=strbchrnb(lpRxPointer,'[',1,(int)dwReadLength+5);
PackFun= *(lptemp1+c_FuncNumOff);
{
case '0':
case 'D':
ResetRxPointer()
ResetOpPointer()
continue;
case '1':
if (lptemp1!=lpOpPointer)
{
for (i=0;*hRXBuffer!='[';hRXBuffer++,i++);
memmove(lpOpPointer ,hRXBuffer , (int)(lpRxPointer-hRXBuffer));
lpRxPointer=lpRxPointer-i;
hRXBuffer=(LPSTR)RxBuffer;
}
continue;
case '5':
if ((*lpOpPointer)!='[')
{
for (i=0;*hRXBuffer!='[';hRXBuffer++,i++);
memmove(lpOpPointer ,hRXBuffer , (int)(lpRxPointer-hRXBuffer));
lpRxPointer=lpRxPointer-i;
hRXBuffer=(LPSTR)RxBuffer;
continue;
case '9':
break;
default :
continue;
}
wSampleID =(int)StrToInt(lpOpPointer+7,5);
GetLocalTime(&SystemTime);
lpPointer=strchrnb(lpOpPointer+1,'[',2,70);
while(*(lpPointer+2)=='2')
{
FillSampleID(nItemCount, wSampleID)
lptemp1=strchrnb(lpPointer,',',1,4)+1;
lptemp2=strchrnb(lptemp1,',',1,5);
FillItemName(nItemCount, lptemp1,(lptemp2-lptemp1))
lptemp1=strchrnb(lptemp2+1,',',2,20)+1;
for (;*lptemp1==' ';lptemp1++);
lptemp2=strchrnb(lptemp1,',',1,10);
FillResult(nItemCount,lptemp1,(int)(lptemp2-lptemp1))
FillDate(nItemCount, SystemTime.wYear, SystemTime.wMonth, SystemTime.wDay, SystemTime.wHour)
lpPointer=strchrnb(lptemp2+1,'[',1,40);
nItemCount++;
}
if(nItemCount>0)
{
(*lpResultProcessRoutine)(lpDevice->nDevNO, OutResult, nItemCount);
lpDevice->dwRecordCount+=nItemCount;
}
nItemCount=0;
// nPackLen=0;
ResetRxPointer()
ResetOpPointer()
hRXBuffer=(LPSTR)RxBuffer;
}
return TRUE;
} // end of CommWatchProc()
void WINAPI BeforeSetCommState(DCB *pComDcb)
{
pComDcb->EvtChar ='[';
}
void Dcm_Ex1Receiver(void)
{
WaitEvent(0x01);
ClearEvent(0x01);
ex1SendFC();
}
DWORD WINAPI CommMonitor( LPSTR lpData)
{
//监控串口接收数据，并完成数据格式分析，将结果放入结果队列
int nItemCount,SampleIDLen,nDataOff,nResultLen,iSampleID;
bool bLogFile;
char TempWorkingID[7];
LPSTR lpPointer;
//应答包
char * p_Ack="\x2\x6\x3";
char * p_Nak="\x2\x16\x3";
char * p_IntSessionTXT="\x2I\x20\x3";
char * p_ReleaseMaster="\x2M\x20\x20\x20\x20\x20\x3";
char PackageType;
char SampleID[10];
SYSTEMTIME SystemTime;
CommData
//通信类型1'、1''、2、3、4、5
Init()
ResetOpPointer()
FillDevName()
SetCommWaitMask(EV_RXFLAG)
PurgeComm( hComm, PURGE_RXCLEAR );
memset(lpOpPointer , 0, c_RxBufferLength );
if(NewLogFile("AEROSET.txt"))
{
bLogFile=TRUE;
}
while (TRUE)
{
WaitEvent(EV_RXFLAG)//等待接受数据包
GetInQueueLength(dwReadLength)//分析数据
ReadCommBlock(dwReadLength)
PackageType=*(lpOpPointer+1);//数据包的类型
if(bLogFile)
{
WriteLogData(hLogFile,lpOpPointer,dwReadLength);
}
//校验接收到的数据，若正确，则处理，否则给否定应答。
/*
checksum calculation
*/
/*结果的数据块中可能包含病人信息、ID信息、结果数据等组。*/
PackageType=*(lpOpPointer+1);
switch(PackageType)
{
case 'Q':
WriteCommBlock(p_Ack,3)//肯定应答
//WriteCommChar(ACK)
break;
case 'R':
//结果处理
WriteCommBlock(p_Ack,3)//肯定应答
iSampleID=StrToInt(lpOpPointer+c_SampleIDOff,c_SamlpeIDLen);
itoa(iSampleID,&SampleID[0],10);
SampleIDLen=strlen(SampleID);
TempWorkingID[0]=lpDevice->DevItemType;
if(SampleIDLen>=6)
{
strncpy(&TempWorkingID[1],&SampleID[SampleIDLen-5],5);
}
else
strncpy(&TempWorkingID[6-SampleIDLen],SampleID,SampleIDLen);
TempWorkingID[6]='\0';
GetLocalTime(&SystemTime);
nItemCount=0;
for(nDataOff =c_DataOff; *(lpOpPointer+nDataOff)!=ETB ;)
{
strncpy(OutResult[nItemCount].WorkingID,TempWorkingID,7);
OutResult[nItemCount].ItemNo=nItemCount+1;
lpPointer=lpOpPointer+nDataOff;
DeleSpace(4)
strncpy(OutResult[nItemCount].ItemID,lpPointer,nResultLen);
OutResult[nItemCount].ItemID[nResultLen]='\0';
lpPointer=lpOpPointer+nDataOff+c_ResultOff;
DeleSpace(c_ResultLen )
FillResult(nItemCount, lpPointer ,nResultLen )
FillDate(nItemCount, SystemTime.wYear, SystemTime.wMonth, SystemTime.wDay, SystemTime.wHour,SystemTime.wMinute,SystemTime.wSecond)
nDataOff = nDataOff + c_OneDataLen;
nItemCount++;
}
if(nItemCount>0)
{
(*lpResultProcessRoutine)(lpDevice->nDevNO, OutResult, nItemCount);
lpDevice->dwRecordCount+=nItemCount;
}
//WriteCommChar(ACK)
/// WriteCommBlock(p_Ack,3)//肯定应答
break;
case ACK:
case NAK:
break;
}
ResetRxPointer()
}
if(bLogFile)
{
CloseLogFile(hLogFile);
}
return TRUE;
} // end of CommWatchProc()
/** 走行中の処理 */
SINT Driver::state_driving(void){
//DEBUG_PRINT1("s", "state_driving()");
RobotInfo r_info;
NavInfo n_info;
RobotCmd cmd;
bool ret;
navigator_.Init();
//Position prePos;
//Position now_position;
// F32 r = 41.34; // タイヤの半径 []
// F32 d = 82.6; // 左右のタイヤ間距離 [mm]
// S32 angR = nxt_motor_get_count(1);
// S32 angL = nxt_motor_get_count(2);
// S32 angR_bak;
// S32 angL_bak;
navigator_.Init();
r_info = robot_.GetInfo();
//angR = r_info.rot_encoderR_val;
//angL = r_info.rot_encoderL_val;
n_info = navigator_.GetInfo(r_info);
// 最初のミッションを設定＆初期化
cur_mission_iter_ = this->mission_list_.Begin();
if ( cur_mission_iter_ != this->mission_list_.End() ){
(*cur_mission_iter_)->Init(r_info, n_info);
} else {
this->status_ = STATE_ERROR;
}
this->ClearEventFlag();
SetRelAlarm(Alarm4msec, 1, DRIVE_PERIOD); // ドライブ用Alarmタイマーのセット
// 走行開始
// ステータスが運転中ならループを繰り返す
while(this->status_ == STATE_DRIVING){
//DEBUG_PRINT1("s", (*cur_mission_iter_)->Name());
ClearEvent(EventDrive); // ドライブイベントのクリア
WaitEvent(EventDrive); // ドライブイベント待ち
// タッチセンサON,もしくは転倒情報より走行停止
if ( event_flag_.is_SetEvent(Robot::EVENT_TOUCH_SENSOR_ON) || event_flag_.is_SetEvent(Robot::EVENT_FAIL) ){
status_ = STATE_WAIT_START;
break;
}
// デバッグ用
if ( event_flag_.is_SetEvent(Robot::EVENT_GYRO) ){
// robot_.Beep();
}
if ( event_flag_.is_SetEvent(Robot::EVENT_GYRO2) ){
// robot_.Beep();
}
if ( event_flag_.is_SetEvent(Robot::EVENT_SONAR_SENSOR_ON) ){
// robot_.Beep();
}
r_info = robot_.GetInfo();
n_info = navigator_.GetInfo(r_info);
//prePos = now_position;
//angR_bak = angR;
//angL_bak = angL;
//angR = r_info.rot_encoderR_val;
//angL = r_info.rot_encoderL_val;
//now_position = getPositionEstimation(prePos, angR - angR_bak, angL - angL_bak, r, d);
while(1){
ret = (*cur_mission_iter_)->Run(r_info, n_info, this->event_flag_, cmd);
if ( ret == true ){
robot_.Drive(cmd);
break;
} else if ( ret == false ){
// 次のミッションに遷移
++cur_mission_iter_;
if ( cur_mission_iter_ == mission_list_.End() ){
// ミッションリストがなくなったので終了
// ただし、最後のミッションは倒立したまま停止を続けるはずなので、
// 基本的にこの処理には入らない
this->status_ = STATE_COMPLETE;
break;
} else {
(*cur_mission_iter_)->Init(r_info, n_info);
continue;
}
} else {
// ここに入ることはないはず
this->status_ = STATE_WAIT_START;
break;
}
}
#if 1
// Bluetooth データ送信
if ( this->is_bt_connect_ ){
robot_.BTSend(cmd, r_info, n_info);
//robot_.BTSend(cmd, now_position);
}
#endif
this->ClearEventFlag();
}
robot_.Stop();
this->ClearEventFlag();
CancelAlarm(Alarm4msec); // ドライブ用Alarmタイマーのキャンセル
ClearEvent(EventDrive); // ドライブイベントのクリア
return 0;
}
/** \brief Perform read operation in modbus master
**
** This function start read operation and wait for
** end or return if callback not NULL
**
** \param[in] handler handler modbus master
** \param[in] startAddress starting address to read
** \param[in] quantity of coils/register to read
** \param[out] pData pointer to store data reads
** \param[in] slaveId slave identification number
** \param[in] cbEndComm call back function
** if NULL pointer is passed, this function block until
** end of communication (using MODBUSE).
** if call back is passed, this function return and
** call back will be executed at end of communication
** \return -1 if master is busy or invalid id passed
** 0 successful
** 1 function not supported
** 2 wrong starting address
** 3 wrong quantity
** 4 function error
** 5 the slave not respond
** 6 pdu received wrong
**/
static int8_t ciaaModbus_masterRead(
int32_t hModbusMaster,
uint16_t startAddress,
uint16_t quantity,
void *pData,
uint8_t slaveId,
uint8_t cmd,
modbusMaster_cbEndOfCommType cbEndComm)
{
int8_t ret;
/* check if no command pending and valid slave id */
if ( (ciaaModbus_masterObj[hModbusMaster].cmd == 0) &&
(0 != slaveId) )
{
/* no exception code */
ciaaModbus_masterObj[hModbusMaster].exceptioncode = 0;
/* set start address */
ciaaModbus_masterObj[hModbusMaster].startAddressR = startAddress;
/* set quantity of registers */
ciaaModbus_masterObj[hModbusMaster].quantityR = quantity;
/* set pointer to store data read */
ciaaModbus_masterObj[hModbusMaster].pDataR = pData;
/* set slave id */
ciaaModbus_masterObj[hModbusMaster].slaveId = slaveId;
/* set retry count */
ciaaModbus_masterObj[hModbusMaster].retryCount = ciaaModbus_masterObj[hModbusMaster].retryComm;
/* set task id to set event if blocking operation */
GetTaskID(&ciaaModbus_masterObj[hModbusMaster].taskID);
/* set call back if non-blocking operation */
ciaaModbus_masterObj[hModbusMaster].cbEndComm = cbEndComm;
/* set command to execute */
ciaaModbus_masterObj[hModbusMaster].cmd = cmd;
/* if no callback wait event... */
if (NULL == cbEndComm)
{
/* wait for event */
WaitEvent(MODBUSE);
ClearEvent(MODBUSE);
/* return exception code */
ret = ciaaModbus_masterObj[hModbusMaster].exceptioncode;
}
else
{
/* if non-blocking, return 0 */
ret = 0;
}
}
else
{
/* return -1 if it was not possible execute the function */
ret = -1;
}
return ret;
}
extern int8_t ciaaModbus_masterCmd0x06WriteSingleRegister(
int32_t hModbusMaster,
uint16_t startAddress,
int16_t value,
uint8_t slaveId,
modbusMaster_cbEndOfCommType cbEndComm)
{
int8_t ret;
/* check if no command pending and valid slave id */
if ( (ciaaModbus_masterObj[hModbusMaster].cmd == 0) &&
(0 != slaveId) )
{
/* no exception code */
ciaaModbus_masterObj[hModbusMaster].exceptioncode = 0;
/* set start address */
ciaaModbus_masterObj[hModbusMaster].startAddressW = startAddress;
/* set register value */
ciaaModbus_masterObj[hModbusMaster].dataW = value;
/* set slave id */
ciaaModbus_masterObj[hModbusMaster].slaveId = slaveId;
/* set retry count */
ciaaModbus_masterObj[hModbusMaster].retryCount = ciaaModbus_masterObj[hModbusMaster].retryComm;
/* set task id to set event if blocking operation */
GetTaskID(&ciaaModbus_masterObj[hModbusMaster].taskID);
/* set call back if non-blocking operation */
ciaaModbus_masterObj[hModbusMaster].cbEndComm = cbEndComm;
/* set command to execute */
ciaaModbus_masterObj[hModbusMaster].cmd = CIAA_MODBUS_FCN_WRITE_SINGLE_REGISTER;
/* if no callback wait event... */
if (NULL == cbEndComm)
{
/* wait for event */
WaitEvent(MODBUSE);
ClearEvent(MODBUSE);
/* return exception code */
ret = ciaaModbus_masterObj[hModbusMaster].exceptioncode;
}
else
{
/* if non-blocking, return 0 */
ret = 0;
}
}
else
{
/* return -1 if it was not possible execute the function */
ret = -1;
}
return ret;
}
bool SDLApplication::Update () {
SDL_Event event;
event.type = -1;
#if (!defined (IPHONE) && !defined (EMSCRIPTEN))
if (active && (firstTime || WaitEvent (&event))) {
firstTime = false;
HandleEvent (&event);
event.type = -1;
if (!active)
return active;
#endif
while (SDL_PollEvent (&event)) {
HandleEvent (&event);
event.type = -1;
if (!active)
return active;
}
currentUpdate = SDL_GetTicks ();
#if defined (IPHONE)
if (currentUpdate >= nextUpdate) {
event.type = SDL_USEREVENT;
HandleEvent (&event);
event.type = -1;
}
#elif defined (EMSCRIPTEN)
event.type = SDL_USEREVENT;
HandleEvent (&event);
event.type = -1;
#else
if (currentUpdate >= nextUpdate) {
SDL_RemoveTimer (timerID);
OnTimer (0, 0);
} else if (!timerActive) {
timerActive = true;
timerID = SDL_AddTimer (nextUpdate - currentUpdate, OnTimer, 0);
}
}
#endif
return active;
}
extern int8_t ciaaModbus_masterCmd0x17ReadWriteMultipleRegisters(
int32_t hModbusMaster,
uint16_t startAddressR,
uint16_t quantityR,
int16_t *hrValueR,
uint16_t startAddressW,
uint16_t quantityW,
int16_t *hrValueW,
uint8_t slaveId,
modbusMaster_cbEndOfCommType cbEndComm)
{
int8_t ret;
/* check if no command pending and valid slave id */
if ( (ciaaModbus_masterObj[hModbusMaster].cmd == 0) &&
(0 != slaveId) )
{
/* no exception code */
ciaaModbus_masterObj[hModbusMaster].exceptioncode = 0;
/* set start address */
ciaaModbus_masterObj[hModbusMaster].startAddressR = startAddressR;
ciaaModbus_masterObj[hModbusMaster].startAddressW = startAddressW;
/* set quantity of registers */
ciaaModbus_masterObj[hModbusMaster].quantityR = quantityR;
ciaaModbus_masterObj[hModbusMaster].quantityW = quantityW;
/* set pointer to store data read */
ciaaModbus_masterObj[hModbusMaster].pDataR = hrValueR;
ciaaModbus_masterObj[hModbusMaster].pDataW = hrValueW;
/* set slave id */
ciaaModbus_masterObj[hModbusMaster].slaveId = slaveId;
/* set retry count */
ciaaModbus_masterObj[hModbusMaster].retryCount = ciaaModbus_masterObj[hModbusMaster].retryComm;
/* set task id to set event if blocking operation */
GetTaskID(&ciaaModbus_masterObj[hModbusMaster].taskID);
/* set call back if non-blocking operation */
ciaaModbus_masterObj[hModbusMaster].cbEndComm = cbEndComm;
/* set command to execute */
ciaaModbus_masterObj[hModbusMaster].cmd = CIAA_MODBUS_FCN_READ_WRITE_MULTIPLE_REGISTERS;
/* if no callback wait event... */
if (NULL == cbEndComm)
{
/* wait for event */
WaitEvent(MODBUSE);
ClearEvent(MODBUSE);
/* return exception code */
ret = ciaaModbus_masterObj[hModbusMaster].exceptioncode;
}
else
{
/* if non-blocking, return 0 */
ret = 0;
}
}
else
{
/* return -1 if it was not possible execute the function */
ret = -1;
}
return ret;
}
int SpiderThread::Run(void *param)
{
HANDLE httpNotifyEvent[MAX_SPIDER_THREAD+1];
int waitR=0;
CMyAsyncHttp::HTTP_STATE state;
int idleHttpCount=0;
bool exit=false;
m_InterfaceConfig.Lock();
for(int i=0;i<m_HttpCount;i++)
{
httpNotifyEvent[i]=m_Http[i].m_FinishNotify;
m_Http[i].SetMark(false);
}
httpNotifyEvent[i]=m_EndEvent;
UrlInfo* url=m_MassMem_UrlInfo.AllocMem();
url->iUrl =(char*)param;
m_UrlList.push_back(url);
m_SameRegex=(m_UrlRegex==HTTP_REGEX);
AddHashMap(CUrl::GetUrlHost(url->iUrl),url->iUrl);
while(1)
{
idleHttpCount =0;
for(int i=0;i<m_HttpCount;i++)
{
//检查退出指令
if(WaitEvent(m_EndEvent,0)==0)
{
exit =true;
break;
}
//判断当前连接是否空闲
if(m_Http[i].IsIdle())
{
state =m_Http[i].GetHttpState();
if(state==CMyAsyncHttp::HTTP_FINISH&&m_Http[i].GetCurrentUrl()!="")
{
//http请求正确
int state=m_Http[i].GetStatusCode();
if(state<400)
{
//服务器返回正常
if(state<300)
AnalysisData(&m_Http[i]);
else
RelocateUrl(&m_Http[i]);
}
else
{
ErrorProcess(&m_Http[i]);
}
m_Http[i].SetMark(true);
}
else if(state==CMyAsyncHttp::HTTP_TIMEOUT||state==CMyAsyncHttp::HTTP_STOP)
{
//http请求超时
ErrorProcess(&m_Http[i]);
m_Http[i].SetMark(true);
}
if(GetNextUrl())
{
m_Http[i].SetParentUrl(m_CurrentUrl->iParentUrl);
m_Http[i].Get(m_CurrentUrl->iUrl.GetBuffer());
m_MassMem_UrlInfo.FreeMem(m_CurrentUrl);
m_Http[i].SetMark(false);
printf("url count:%d\n",m_MassMem_UrlInfo.GetAllocCount());
}
else
{
idleHttpCount =0;
for(int i=0;i<m_HttpCount;i++)
{
if(m_Http[i].GetMark())idleHttpCount++;
}
if(idleHttpCount==m_HttpCount)
{
exit =true;
break;
}
}
}
}
if(exit)break;
waitR=::WaitForMultipleObjects(m_HttpCount+1,httpNotifyEvent,false,-1);
if(waitR==m_HttpCount)
break;
}
m_InterfaceConfig.m_SpiderFinish->OnFinish();
ClearUrlList();
return 1;
}
DWORD CSerialEx::ThreadProc (void)
{
// Use overlapped structure
LPOVERLAPPED lpOverlapped = 0;
// Keep looping
do
{
#ifndef SERIAL_NO_OVERLAPPED
// Reset the event handle
::ResetEvent(m_hevtOverlappedWorkerThread);
// Initialize the overlapped structure
OVERLAPPED ovInternal = {0};
ovInternal.hEvent = m_hevtOverlappedWorkerThread;
// Start the WaitEvent (use our own overlapped structure)
if (WaitEvent(&ovInternal) != ERROR_SUCCESS)
return m_lLastError;
// Wait for the overlapped operation to complete
if (::WaitForSingleObject(m_hevtOverlappedWorkerThread,INFINITE) != WAIT_OBJECT_0)
{
// Set the internal error code
m_lLastError = ::GetLastError();
// Issue an error and quit
_RPTF0(_CRT_WARN,"CSerialEx::ThreadProc - Unable to wait until COM event has arrived\n");
return m_lLastError;
}
#else
// Start the WaitEvent (don't need to specify an overlapped structure)
if (WaitEvent() != ERROR_SUCCESS)
return m_lLastError;
#endif
// Wait until one of the events happens
if (!m_fStopping)
{
// Determine the event
EEvent eEvent = GetEventType();
// Obtain the error status during this event
DWORD dwErrors = 0;
if (!::ClearCommError(m_hFile,&dwErrors,0))
{
// Set the internal error code
m_lLastError = ::GetLastError();
// Issue an error and quit
_RPTF0(_CRT_WARN, "CSerialEx::ThreadProc - Unable to obtain COM status\n");
}
// Convert the error
EError eError = EError(dwErrors);
// There was a COMM event, which needs handling. We'll call the
// event handler. We can receive a "zero" event, when the
// mask or event character has been set. We won't pass this
// down to the window.
if (eEvent)
OnEvent(eEvent,eError);
}
}
while (!m_fStopping);
// Bye bye
return 0;
}
//------------------------------------------------------------------------------------------------------------------------------------
//
BOOL SourceCommandLoop( LPRefObj pRefMod, ULONG ulSrcID )
{
LPRefObj pRefSrc = NULL;
char buf[256];
ULONG ulItemID = 0;
UWORD wSel;
BOOL bRet = true;
pRefSrc = GetRefChildPtr_ID( pRefMod, ulSrcID );
if ( pRefSrc == NULL ) {
// Create Source object and RefSrc structure.
if ( AddChild( pRefMod, ulSrcID ) == true ) {
printf("Source object is opened.\n");
} else {
printf("Source object can't be opened.\n");
return false;
}
pRefSrc = GetRefChildPtr_ID( pRefMod, ulSrcID );
}
// Get CameraType
Command_CapGet( pRefSrc->pObject, kNkMAIDCapability_CameraType, kNkMAIDDataType_UnsignedPtr, (NKPARAM)&g_ulCameraType, NULL, NULL );
// command loop
do {
printf( "\nSelect (1-10, 0)\n" );
printf( " 1. Select Item Object 2. Camera settings(1) 3. Camera settings(2)\n" );
printf( " 4. Shooting Menu 5. Custom Menu 6. Async\n" );
printf( " 7. Autofocus 8. Capture 9. TerminateCapture\n" );
printf( "10. PreCapture\n" );
printf( " 0. Exit\n>" );
scanf( "%s", buf );
wSel = atoi( buf );
switch( wSel )
{
case 1:// Children
// Select Item Object
ulItemID = 0;
bRet = SelectItem( pRefSrc, &ulItemID );
if( bRet == true && ulItemID > 0 )
bRet = ItemCommandLoop( pRefSrc, ulItemID );
break;
case 2:// Camera setting 1
bRet = SetUpCamera1( pRefSrc );
break;
case 3:// Camera setting 2
bRet = SetUpCamera2( pRefSrc );
break;
case 4:// Shooting Menu
bRet = SetShootingMenu( pRefSrc );
break;
case 5:// CustomSetting Menu
bRet = SetCustomSettings( pRefSrc );
break;
case 6:// Async
bRet = Command_Async( pRefMod->pObject );
break;
case 7:// AutoFocus
bRet = IssueProcess( pRefSrc, kNkMAIDCapability_AutoFocus );
break;
case 8:// Capture
bRet = IssueProcess( pRefSrc, kNkMAIDCapability_Capture );
Command_Async( pRefSrc->pObject );
break;
case 9:// TerminateCapture
bRet = TerminateCaptureCapability( pRefSrc );
break;
case 10:// PreCapture
bRet = IssueProcess( pRefSrc, kNkMAIDCapability_PreCapture );
break;
default:
wSel = 0;
}
if ( bRet == false ) {
printf( "An Error occured. Enter '0' to exit.\n>" );
scanf( "%s", buf );
bRet = true;
}
WaitEvent();
} while( wSel > 0 );
// Close Source_Object
bRet = RemoveChild( pRefMod, ulSrcID );
return true;
}
inline std_return RTE_Manager_Input_GetValue_Event_In(char *a)
{
WaitEvent(RTE_Manager_Input_GetValue_Event_In_EVENT);
ClearEvent(RTE_Manager_Input_GetValue_Event_In_EVENT);
return 0;
}
