/*..........................................................................*/
QState Tunnel_game_over(Tunnel *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_postEvery(&me->blinkTimeEvt, (QActive *)me,
BSP_TICKS_PER_SEC/2); /* 1/2 sec */
QTimeEvt_postIn(&me->screenTimeEvt, (QActive *)me,
BSP_TICKS_PER_SEC*5); /* 5 sec timeout */
me->blink_ctr = 0;
BSP_drawNString((GAME_SCREEN_WIDTH - 6*9)/2, 0, "Game Over");
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->blinkTimeEvt);
QTimeEvt_disarm(&me->screenTimeEvt);
BSP_updateScore(0); /* update the score on the display */
return Q_HANDLED();
}
case BLINK_TIMEOUT_SIG: {
me->blink_ctr ^= 1; /* toggle the blink couner */
BSP_drawNString((GAME_SCREEN_WIDTH - 6*9)/2, 0,
((me->blink_ctr == 0)
? "Game Over"
: " "));
return Q_HANDLED();
}
case SCREEN_TIMEOUT_SIG: {
return Q_TRAN(&Tunnel_demo);
}
}
return Q_SUPER(&Tunnel_active);
}
/* @(/1/8/23/1/7/5/5) ......................................................*/
static QState QGprs_connected(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7/5/5) */
case Q_ENTRY_SIG: {
me->m_NetState = NET_STATE_CONNECTED;
GPRS_SetNetState(NET_STATE_CONNECTED);
QTimeEvt_postEvery(&me->m_LEDTimer, &me->super, TIMEOUT_LED_CONNECTED);
QTimeEvt_postEvery(&me->m_PingTimer, &me->super, TIMEOUT_PING);
//QTimeEvt_postEvery(&me->m_QueryTimer, &me->super, TIMEOUT_DATAQUERY);
/*
//首次连接网络，发送PING包
TaskEvt *pe = Q_NEW(TaskEvt, NEW_TASKSENDREQ_SIG);
pe->cmd = EVS15_CMD_LOGIN; //命令字=登录
pe->sequence = GeneratePacketSequenceNumber();
QACTIVE_POST(me, (QEvt*)pe, (void*)0);
*/
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_LEDTimer);
QTimeEvt_disarm(&me->m_PingTimer);
//QTimeEvt_disarm(&me->m_QueryTimer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5/0) */
case Q_INIT_SIG: {
status_ = Q_TRAN(&QGprs_Idle);
break;
}
/* @(/1/8/23/1/7/5/5/1) */
case AT_ERROR_SIG: {
status_ = Q_TRAN(&QGprs_connecting);
break;
}
/* @(/1/8/23/1/7/5/5/2) */
case GPRS_SERVER_CONNECTED_SIG: {
//连接状态 = 连接上服务器
me->m_NetState = NET_STATE_SERVERCONNECTED;
GPRS_SetNetState(NET_STATE_SERVERCONNECTED);
//清除“网络不可达”故障
//ClearErrType(NET_CLASS, NET_FAULT_UNREACHABLE);
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QGprs_powerNormalMode);
break;
}
}
return status_;
}
/* @(/1/8/23/1/7/5) ........................................................*/
static QState QGprs_powerNormalMode(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7/5) */
case Q_ENTRY_SIG: {
//复位AT执行序列
me->m_ATStep = 0;
//启动LED闪烁定时器
QTimeEvt_postEvery(&me->m_LEDTimer, &me->super, TIMEOUT_LED_CONNECTING);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
QTimeEvt_disarm(&me->m_LEDTimer);
//关闭状态灯
GPRS_LED_OFF();
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/0) */
case Q_INIT_SIG: {
status_ = Q_TRAN(&QGprs_disconnected);
break;
}
/* @(/1/8/23/1/7/5/1) */
case ACC_OFF_SIG: {
me->m_ACCState = POWEROFF;
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/2) */
case GPRS_LED_TIMEOUT_SIG: {
//static QEvt const query_Evt = {AT_DATAQUERY_SIG, 0, 0};
//QACTIVE_POST(me, (QEvt*)&query_Evt, NULL);
//QACTIVE_POST(me, (QEvt*)Q_NEW(QEvt, AT_DATAQUERY_SIG), (void*)0);
//LED指示灯闪烁
GPRS_FLASH_LED();
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/3) */
case GPRS_PING_TIMEOUT_SIG: {
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QGprs_polling);
break;
}
}
return status_;
}
/*..........................................................................*/
QState Tunnel_demo(Tunnel *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
me->last_mine_x = 0; /* last mine at right edge of the tunnel */
me->last_mine_y = 0;
/* set the tunnel properties... */
me->wall_thickness_top = 0;
me->wall_thickness_bottom = 0;
me->minimal_gap = GAME_SCREEN_HEIGHT - 3;
/* erase the tunnel walls */
memset(l_walls, (uint8_t)0,
(GAME_SCREEN_WIDTH * GAME_SCREEN_HEIGHT/8));
QTimeEvt_postEvery(&me->blinkTimeEvt, (QActive *)me,
BSP_TICKS_PER_SEC/2); /* every 1/2 sec */
QTimeEvt_postIn(&me->screenTimeEvt, (QActive *)me,
BSP_TICKS_PER_SEC*20); /* 20s timeout */
me->blink_ctr = 0; /* init the blink counter */
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->blinkTimeEvt);
QTimeEvt_disarm(&me->screenTimeEvt);
return Q_HANDLED();
}
case BLINK_TIMEOUT_SIG: {
me->blink_ctr ^= 1; /* toggle the blink cunter */
return Q_HANDLED();
}
case SCREEN_TIMEOUT_SIG: {
return Q_TRAN(&Tunnel_screen_saver);
}
case TIME_TICK_SIG: {
Tunnel_advance(me);
if (me->blink_ctr != 0) {
/* add the text bitmap into the frame buffer */
Tunnel_addImageAt(me,
PRESS_BUTTON_BMP,
(GAME_SCREEN_WIDTH - 55)/2,
(GAME_SCREEN_HEIGHT - 8)/2);
}
BSP_drawBitmap(l_frame, GAME_SCREEN_WIDTH, GAME_SCREEN_HEIGHT);
return Q_HANDLED();
}
case PLAYER_TRIGGER_SIG: {
return Q_TRAN(&Tunnel_playing);
}
}
return Q_SUPER(&Tunnel_active);
}
/* @(/1/8/23/1/6/2) ........................................................*/
static QState QGprs_start_finished(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/6/2) */
case Q_ENTRY_SIG: {
/* TERMON 高电平 */
GPIO_ResetBits(GPIOA, GPIOA_GPRS_PWRKEY_);
/* 已开机，稍延时待稳定后执行AT */
QTimeEvt_postIn(&me->m_Timer, &me->super, TIMEOUT_PWRONAFTER_TICKS);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/6/2) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/6/2/0) */
case Q_TIMEOUT_SIG: {
//串口IO重新初始化
GPRS_UartReconfigure();
status_ = Q_TRAN(&QGprs_polling);
break;
}
default: {
status_ = Q_SUPER(&QGprs_startup);
break;
}
}
return status_;
}
/* @(/1/8/23/1/6/3) ........................................................*/
static QState QGprs_start_delay(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/6/3) */
case Q_ENTRY_SIG: {
//先管脚拉低
GPIO_SetBits(GPIOA, GPIOA_GPRS_PWRKEY_);
//低电平拉低1000ms
QTimeEvt_postIn(&me->m_Timer, &me->super, TIMEOUT_PWRONBEFORE_TICKS);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/6/3) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/6/3/0) */
case Q_TIMEOUT_SIG: {
status_ = Q_TRAN(&QGprs_start_finished);
break;
}
default: {
status_ = Q_SUPER(&QGprs_startup);
break;
}
}
return status_;
}
/* @(/1/8/23/1/6/1) ........................................................*/
static QState QGprs_power_on(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/6/1) */
case Q_ENTRY_SIG: {
//模块上电
GPIO_SetBits(GPIOA,GPIOA_CDMA_CTRL_);
/* TERMON 高电平 */
GPIO_ResetBits(GPIOA, GPIOA_GPRS_PWRKEY_);
//保持1S
QTimeEvt_postIn(&me->m_Timer, &me->super, TIMEOUT_PWRON_TICKS);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/6/1) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/6/1/0) */
case Q_TIMEOUT_SIG: {
status_ = Q_TRAN(&QGprs_start_delay);
break;
}
default: {
status_ = Q_SUPER(&QGprs_startup);
break;
}
}
return status_;
}
/* @(/1/8/23/1/7/5/5/3/4) ..................................................*/
static QState QGprs_WaitRet(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7/5/5/3/4) */
case Q_ENTRY_SIG: {
/* 填充待发送数据内容 */
GPRS_FillinTCPIPData(me->m_sendBuf, me->m_SendDataLen);
/* 启动应答计时器 */
QTimeEvt_postIn(&me->m_Timer, (QActive *)me, TIMEOUT_ATSENDRET);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5/3/4) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5/3/4/0) */
case AT_SENDOK_SIG: {
status_ = Q_TRAN(&QGprs_Idle);
break;
}
default: {
status_ = Q_SUPER(&QGprs_TcpSending);
break;
}
}
return status_;
}
QState Philo_eating(Philo * const me, QEvt const * const e) {
QState status;
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_armX(&me->timeEvt, EAT_TIME, 0U); /* one shot */
status = Q_HANDLED();
break;
}
case Q_EXIT_SIG: {
TableEvt *pe;
QTimeEvt_disarm(&me->timeEvt);
pe = Q_NEW(TableEvt, DONE_SIG);
pe->philNum = me->num;
QF_PUBLISH((QEvt *)pe, me);
status = Q_HANDLED();
break;
}
case TIMEOUT_SIG: {
status = Q_TRAN(&Philosopher_thinking);
break;
}
default: {
status = Q_SUPER(&QHsm_top);
break;
}
}
return status;
}
/*..........................................................................*/
QState Tunnel_screen_saver_show(Tunnel *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
uint32_t rnd = random();
/* clear the screen frame buffer */
memset(l_frame, (uint8_t)0,
(GAME_SCREEN_WIDTH * GAME_SCREEN_HEIGHT/8));
Tunnel_addImageAt(me,
PRESS_BUTTON_BMP,
(uint8_t)(rnd % (GAME_SCREEN_WIDTH - 55)),
(int8_t) (rnd % (GAME_SCREEN_HEIGHT - 8)));
BSP_drawBitmap(l_frame, GAME_SCREEN_WIDTH, GAME_SCREEN_HEIGHT);
QTimeEvt_postIn(&me->screenTimeEvt, (QActive *)me,
BSP_TICKS_PER_SEC/3); /* 1/3 sec timeout */
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->screenTimeEvt);
/* clear the screen frame buffer */
memset(l_frame, (uint8_t)0,
(GAME_SCREEN_WIDTH * GAME_SCREEN_HEIGHT/8));
BSP_drawBitmap(l_frame, GAME_SCREEN_WIDTH, GAME_SCREEN_HEIGHT);
return Q_HANDLED();
}
case SCREEN_TIMEOUT_SIG: {
return Q_TRAN(&Tunnel_screen_saver_hide);
}
}
return Q_SUPER(&Tunnel_screen_saver);
}
/* @(/1/8/23/1/8) ..........................................................*/
static QState QGprs_reseting(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/8) */
case Q_ENTRY_SIG: {
//模块上电
GPIO_ResetBits(GPIOA,GPIOA_CDMA_CTRL_);
//先管脚拉低
//GPIO_ResetBits(GPIOA, GPIOA_GPRS_PWRKEY_);
//低电平拉低1000ms
QTimeEvt_postIn(&me->m_Timer, &me->super, TIMEOUT_RESETBEFORE_TICKS);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/8) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/8/0) */
case Q_TIMEOUT_SIG: {
status_ = Q_TRAN(&QGprs_startup);
break;
}
default: {
status_ = Q_SUPER(&QGprs_serving);
break;
}
}
return status_;
}
/* @(/1/8/23/1/7/5/5/3/3) ..................................................*/
static QState QGprs_WaitFillData(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7/5/5/3/3) */
case Q_ENTRY_SIG: {
/* 发送TCPIP前缀字符串[AT^SISC=...] */
GPRS_SendTCPIPPrefix(me->m_SendDataLen);
/* 启动应答计时器 */
QTimeEvt_postIn(&me->m_Timer, (QActive *)me, TIMEOUT_ATTIPS);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5/3/3) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5/3/3/0) */
case AT_FILLDATATIP_SIG: {
status_ = Q_TRAN(&QGprs_WaitRet);
break;
}
default: {
status_ = Q_SUPER(&QGprs_TcpSending);
break;
}
}
return status_;
}
/*${AOs::CLI::SM::main::idle} ..............................................*/
static QState CLI_idle(CLI * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::CLI::SM::main::idle} */
case Q_ENTRY_SIG: {
QTimeEvt_postEvery( &me->rollEvt, (QActive *)me, ROLL_TIME );
Console_printStr("\r\r\n\nPress any key to continue...");
status_ = Q_HANDLED();
break;
}
/* ${AOs::CLI::SM::main::idle} */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->rollEvt);
status_ = Q_HANDLED();
break;
}
/* ${AOs::CLI::SM::main::idle::ROLL} */
case ROLL_SIG: {
Console_printRoll();
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&CLI_main);
break;
}
}
return status_;
}
/*${AOs::FlashMgr::SM::Active::BusyFlash} ..................................*/
static QState FlashMgr_BusyFlash(FlashMgr * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::FlashMgr::SM::Active::BusyFlash} */
case Q_ENTRY_SIG: {
/* Arm the timer so if the message can't be processed for some reason, we can get
* back to idle state. This timer may be re-armed if some messages require more
* time to process than others. */
QTimeEvt_rearm( /* Re-arm timer on entry */
&me->flashTimerEvt,
SEC_TO_TICKS( HL_MAX_TOUT_SEC_FLASH_FW )
);
FLASH_Unlock();/* Always unlock the flash on entry since we'll be doing stuff to it */
/* Reset all the variables that keep track of FW upgrades on entry so they are
* guaranteed to be cleared when we start any new operation */
memset( me->flashSectorsToErase, 0, sizeof(me->flashSectorsToErase) );
me->flashSectorsToEraseIndex = 0;
me->flashSectorsToEraseNum = 0;
me->fwPacketCurr = 0;
me->fwPacketExp = 0;
me->retryCurr = 0;
status_ = Q_HANDLED();
break;
}
/* ${AOs::FlashMgr::SM::Active::BusyFlash} */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->flashTimerEvt); /* Disarm timer on exit */
FLASH_Lock(); /* Always lock the flash on exit */
/* Always send a flash status event to the CommMgr AO with the current error code */
FlashStatusEvt *evt = Q_NEW(FlashStatusEvt, FLASH_OP_DONE_SIG);
evt->errorCode = me->errorCode;
QACTIVE_POST(AO_CommMgr, (QEvt *)(evt), AO_FlashMgr);
status_ = Q_HANDLED();
break;
}
/* ${AOs::FlashMgr::SM::Active::BusyFlash::FLASH_TIMEOUT} */
case FLASH_TIMEOUT_SIG: {
ERR_printf("Timeout trying to process flash request, error: 0x%08x\n", me->errorCode);
status_ = Q_TRAN(&FlashMgr_Idle);
break;
}
/* ${AOs::FlashMgr::SM::Active::BusyFlash::FLASH_ERROR} */
case FLASH_ERROR_SIG: {
ERR_printf("Unable to to process flash request. Error: 0x%08x\n", me->errorCode);
status_ = Q_TRAN(&FlashMgr_Idle);
break;
}
default: {
status_ = Q_SUPER(&FlashMgr_Active);
break;
}
}
return status_;
}
/*${AOs::SerialMgr::SM::Active::Busy} ......................................*/
static QState SerialMgr_Busy(SerialMgr * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::SerialMgr::SM::Active::Busy} */
case Q_ENTRY_SIG: {
/* Post a timer on entry */
QTimeEvt_rearm(
&me->serialTimerEvt,
SEC_TO_TICKS( LL_MAX_TIMEOUT_SERIAL_DMA_BUSY_SEC )
);
/* Start the DMA transfer over serial */
Serial_DMAStartXfer( SERIAL_UART1 );
status_ = Q_HANDLED();
break;
}
/* ${AOs::SerialMgr::SM::Active::Busy} */
case Q_EXIT_SIG: {
QTimeEvt_disarm( &me->serialTimerEvt ); /* Disarm timer on exit */
status_ = Q_HANDLED();
break;
}
/* ${AOs::SerialMgr::SM::Active::Busy::UART_DMA_DONE} */
case UART_DMA_DONE_SIG: {
status_ = Q_TRAN(&SerialMgr_Idle);
break;
}
/* ${AOs::SerialMgr::SM::Active::Busy::UART_DMA_TIMEOUT} */
case UART_DMA_TIMEOUT_SIG: {
err_slow_printf("UART DMA timeout occurred\n");
status_ = Q_TRAN(&SerialMgr_Idle);
break;
}
/* ${AOs::SerialMgr::SM::Active::Busy::UART_DMA_START, ~} */
case UART_DMA_START_SIG: /* intentionally fall through */
case DBG_LOG_SIG: /* intentionally fall through */
case DBG_MENU_SIG: /* intentionally fall through */
case CLI_SEND_DATA_SIG: {
if (QEQueue_getNFree(&me->deferredEvtQueue) > 0) {
/* defer the request - this event will be handled
* when the state machine goes back to Idle state */
QActive_defer((QActive *)me, &me->deferredEvtQueue, e);
} else {
/* notify the request sender that the request was ignored.. */
err_slow_printf("Unable to defer UART_DMA_START request\n");
}
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&SerialMgr_Active);
break;
}
}
return status_;
}
/* @(/1/8/23/1/7/3) ........................................................*/
static QState QGprs_registering(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7/3) */
case Q_ENTRY_SIG: {
//执行注册网络AT指令
GPRS_doRegister();
QTimeEvt_postIn(&me->m_Timer, &me->super, TIMEOUT_ATREG);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/3) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/3/0) */
case AT_OK_SIG: {
if(GPRS_GetRegState())
{
me->m_NetState = NET_STATE_REGISTED;
GPRS_SetNetState(NET_STATE_REGISTED);
}
/* @(/1/8/23/1/7/3/0/0) */
if (GPRS_GetRegState() == 0) {
status_ = Q_HANDLED();
}
/* @(/1/8/23/1/7/3/0/1) */
else {
status_ = Q_TRAN(&QGprs_powerNormalMode);
}
break;
}
/* @(/1/8/23/1/7/3/1) */
case Q_TIMEOUT_SIG: {
me->m_TryTimes++;
/* @(/1/8/23/1/7/3/1/0) */
if (me->m_TryTimes < REGISTER_TRY_MAXTIMES) {
status_ = Q_TRAN(&QGprs_registering);
}
/* @(/1/8/23/1/7/3/1/1) */
else {
TRACE_(QS_USER, NULL, "*** [GPRS] Regging timeout, repower gprs");
status_ = Q_TRAN(&QGprs_reseting);
}
break;
}
default: {
status_ = Q_SUPER(&QGprs_polling);
break;
}
}
return status_;
}
/* @(/1/8/23/1/7) ..........................................................*/
static QState QGprs_polling(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7) */
case Q_ENTRY_SIG: {
QTimeEvt_postEvery(&me->m_retrieveTimer, &me->super, TIMEOUT_RETRIEVE);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_retrieveTimer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/0) */
case Q_INIT_SIG: {
status_ = Q_TRAN(&QGprs_initialing);
break;
}
/* @(/1/8/23/1/7/1) */
case GPRS_RETRIEVE_TIMEOUT_SIG: {
//接收串口提取
GPRS_doRetrieveFrame(0, 0);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/2) */
case AT_DATAREADY_SIG: {
//延迟消息到达提取
me->m_deferedDataReady ++;
#if 0
ATMsgEvt* pe = (ATMsgEvt*)e;
//接收串口提取
GPRS_doRetrieveFrame(pe->begin, pe->end);
#endif
//接收串口提取
//GPRS_doRetrieveFrame(0, 0);
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QGprs_serving);
break;
}
}
return status_;
}
/*${AOs::FlashMgr::SM::Active} .............................................*/
static QState FlashMgr_Active(FlashMgr * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::FlashMgr::SM::Active} */
case Q_ENTRY_SIG: {
/* Arm and disarm*/
QTimeEvt_postIn(
&me->flashTimerEvt,
(QActive *)me,
SEC_TO_TICKS( HL_MAX_TOUT_SEC_FLASH_FW )
);
QTimeEvt_disarm(&me->flashTimerEvt);
QTimeEvt_postIn(
&me->flashOpTimerEvt,
(QActive *)me,
SEC_TO_TICKS( HL_MAX_TOUT_SEC_FLASH_FW )
);
QTimeEvt_disarm(&me->flashOpTimerEvt);
QTimeEvt_postIn(
&me->ramTimerEvt,
(QActive *)me,
SEC_TO_TICKS( HL_MAX_TOUT_SEC_FLASH_FW )
);
QTimeEvt_disarm(&me->ramTimerEvt);
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
/*${AOs::FlashMgr::SM::Active::BusyRam} ....................................*/
static QState FlashMgr_BusyRam(FlashMgr * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::FlashMgr::SM::Active::BusyRam} */
case Q_ENTRY_SIG: {
/* Arm the timer so if the message can't be processed for some reason, we can get
* back to idle state. This timer may be re-armed if some messages require more
* time to process than others. */
QTimeEvt_rearm( /* Re-arm timer on entry */
&me->ramTimerEvt,
SEC_TO_TICKS( HL_MAX_TOUT_SEC_CLI_WAIT_FOR_RAM_TEST )
);
status_ = Q_HANDLED();
break;
}
/* ${AOs::FlashMgr::SM::Active::BusyRam} */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->ramTimerEvt); /* Disarm timer on exit */
/* Always send a flash status event to the CommMgr AO with the current error code */
RamStatusEvt *evt = Q_NEW(RamStatusEvt, RAM_TEST_DONE_SIG);
evt->errorCode = me->errorCode;
evt->test = me->currRamTest;
evt->addr = me->currRamAddr;
QACTIVE_POST(AO_CommMgr, (QEvt *)(evt), AO_FlashMgr);
status_ = Q_HANDLED();
break;
}
/* ${AOs::FlashMgr::SM::Active::BusyRam::RAM_TIMEOUT} */
case RAM_TIMEOUT_SIG: {
ERR_printf(
"Timeout trying to process RAM test request during RAM test %d, error: 0x%08x\n",
me->currRamTest, me->errorCode
);
status_ = Q_TRAN(&FlashMgr_Idle);
break;
}
default: {
status_ = Q_SUPER(&FlashMgr_Active);
break;
}
}
return status_;
}
/*..........................................................................*/
QState Tunnel_screen_saver_hide(Tunnel *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
BSP_displayOff(); /* power down the display */
QTimeEvt_postIn(&me->screenTimeEvt, (QActive *)me,
BSP_TICKS_PER_SEC*3); /* 3s timeout */
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->screenTimeEvt);
BSP_displayOn(); /* power up the display */
return Q_HANDLED();
}
case SCREEN_TIMEOUT_SIG: {
return Q_TRAN(&Tunnel_screen_saver_show);
}
}
return Q_SUPER(&Tunnel_screen_saver);
}
/* @(/1/8/23/1/7/6) ........................................................*/
static QState QGprs_sleepRequest(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7/6) */
case Q_ENTRY_SIG: {
//进入休眠命令
TRACE_(QS_USER, NULL, "[GPRS] Enable MG323 Module entering into Sleep mode...");
GPRS_RequestSleep();
QTimeEvt_postIn(&me->m_Timer, &me->super, TIMEOUT_ATACK);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/6) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/6/0) */
case AT_OK_SIG: {
TRACE_(QS_USER, NULL, "[GPRS] Sleep mode is Done.");
status_ = Q_TRAN(&QGprs_powerSaveMode);
break;
}
/* @(/1/8/23/1/7/6/1) */
case Q_TIMEOUT_SIG: {
status_ = Q_TRAN(&QGprs_sleepRequest);
break;
}
/* @(/1/8/23/1/7/6/2) */
case AT_ERROR_SIG: {
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QGprs_polling);
break;
}
}
return status_;
}
/*..........................................................................*/
QState LwIPMgr_connecting(LwIPMgr *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_postEvery(&me->te_LWIP_SLOW_TICK, (QActive *)me,
BSP_TICKS_PER_SEC / 10U);
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->te_LWIP_SLOW_TICK);
return Q_HANDLED();
}
case LWIP_SLOW_TICK_SIG: {
if (eth_driver_connect()) {
return Q_TRAN(&LwIPMgr_running);
}
return Q_HANDLED();
}
}
return Q_SUPER(&QHsm_top);
}
/*..........................................................................*/
QState AlarmClock_timekeeping(AlarmClock *me, QEvent const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
/* periodic timeout every second */
QTimeEvt_postEvery(&me->timeEvt,
(QActive *)me, BSP_TICKS_PER_SEC);
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->timeEvt);
return Q_HANDLED();
}
case Q_INIT_SIG: {
return Q_TRAN(&AlarmClock_mode24hr);
}
case CLOCK_12H_SIG: {
return Q_TRAN(&AlarmClock_mode12hr);
}
case CLOCK_24H_SIG: {
return Q_TRAN(&AlarmClock_mode24hr);
}
case ALARM_SIG: {
printf("Wake up!!!\n");
return Q_HANDLED();
}
case ALARM_SET_SIG:
case ALARM_ON_SIG:
case ALARM_OFF_SIG: {
/* synchronously dispatch to the orthogonal component */
Alarm_dispatch(&me->alarm, e);
return Q_HANDLED();
}
case TERMINATE_SIG: {
return Q_TRAN(&AlarmClock_final);
}
}
return Q_SUPER(&QHsm_top);
}
/*${AOs::SerialMgr::SM::Active} ............................................*/
static QState SerialMgr_Active(SerialMgr * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::SerialMgr::SM::Active} */
case Q_ENTRY_SIG: {
/* Post a timer and disarm it right away so it can be
* rearmed at any point */
QTimeEvt_postIn(
&me->serialTimerEvt,
(QActive *)me,
SEC_TO_TICKS( LL_MAX_TIMEOUT_SERIAL_DMA_BUSY_SEC )
);
QTimeEvt_disarm(&me->serialTimerEvt);
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
/* @(/1/8/23/1/7/5/5/7) ....................................................*/
static QState QGprs_DataQuering(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/1/7/5/5/7) */
case Q_ENTRY_SIG: {
//发送数据查询指令
GPRS_doQueryData();
/* 启动应答计时器 */
QTimeEvt_postIn(&me->m_Timer, (QActive *)me, TIMEOUT_AT_DATAQUERYRET);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5/7) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/8/23/1/7/5/5/7/0) */
case AT_OK_SIG: {
//逆向提取TCP包
GPRS_doTakeTCPPacketData();
status_ = Q_TRAN(&QGprs_Idle);
break;
}
/* @(/1/8/23/1/7/5/5/7/1) */
case Q_TIMEOUT_SIG: {
status_ = Q_TRAN(&QGprs_Idle);
break;
}
default: {
status_ = Q_SUPER(&QGprs_connected);
break;
}
}
return status_;
}
/*..........................................................................*/
QState AlarmMgr_playing(AlarmMgr *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_postIn(&me->timer, (QActive *)me,
l_alarms[me->curr_alarm].note[me->curr_note].dur);
TIM_PrescalerConfig(TIM3,
l_alarms[me->curr_alarm].note[me->curr_note].freq);
TIM_CounterCmd(TIM3, TIM_START); /* start noise */
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->timer);
return Q_HANDLED();
}
case TIMEOUT_SIG: {
++me->curr_note;
if (me->curr_note == l_alarms[me->curr_alarm].length) {
me->curr_note = 0; /* start over again */
}
return Q_TRAN(&AlarmMgr_playing); /* transition to self */
}
}
return Q_SUPER(&AlarmMgr_on);
}
/*..........................................................................*/
QState LwIPMgr_running(LwIPMgr *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
#if (LWIP_DHCP != 0)
dhcp_start(me->netif); /* start DHCP if configured */
/* NOTE: If LWIP_AUTOIP is configured in lwipopts.h and
* LWIP_DHCP_AUTOIP_COOP is set as well, the DHCP process will
* start AutoIP after DHCP fails for 59 seconds.
*/
#elif (LWIP_AUTOIP != 0)
autoip_start(me->netif); /* start AutoIP if configured */
#endif
QTimeEvt_postEvery(&me->te_LWIP_SLOW_TICK, (QActive *)me,
(LWIP_SLOW_TICK_MS * BSP_TICKS_PER_SEC) / 1000U);
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->te_LWIP_SLOW_TICK);
return Q_HANDLED();
}
case SEND_UDP_SIG: {
if (me->upcb->remote_port != 0U) {
struct pbuf *p = pbuf_new((u8_t *)((TextEvt const *)e)->text,
strlen(((TextEvt const *)e)->text) + 1U);
if (p != (struct pbuf *)0) {
udp_send(me->upcb, p);
pbuf_free(p); /* don't leak the pbuf! */
}
}
return Q_HANDLED();
}
case LWIP_RX_READY_SIG: {
eth_driver_read();
return Q_HANDLED();
}
case LWIP_TX_READY_SIG: {
eth_driver_write();
return Q_HANDLED();
}
case LWIP_SLOW_TICK_SIG: {
/* has IP address changed? */
if (me->ip_addr != me->netif->ip_addr.addr) {
me->ip_addr = me->netif->ip_addr.addr; /* save the IP addr. */
BSP_displyIP(ntohl(me->ip_addr));
}
#if LWIP_TCP
me->tcp_tmr += LWIP_SLOW_TICK_MS;
if (me->tcp_tmr >= TCP_TMR_INTERVAL) {
me->tcp_tmr = 0;
tcp_tmr();
}
#endif
#if LWIP_ARP
me->arp_tmr += LWIP_SLOW_TICK_MS;
if (me->arp_tmr >= ARP_TMR_INTERVAL) {
me->arp_tmr = 0;
etharp_tmr();
}
#endif
#if LWIP_DHCP
me->dhcp_fine_tmr += LWIP_SLOW_TICK_MS;
if (me->dhcp_fine_tmr >= DHCP_FINE_TIMER_MSECS) {
me->dhcp_fine_tmr = 0;
dhcp_fine_tmr();
}
me->dhcp_coarse_tmr += LWIP_SLOW_TICK_MS;
if (me->dhcp_coarse_tmr >= DHCP_COARSE_TIMER_MSECS) {
me->dhcp_coarse_tmr = 0;
dhcp_coarse_tmr();
}
#endif
#if LWIP_AUTOIP
me->auto_ip_tmr += LWIP_SLOW_TICK_MS;
if (me->auto_ip_tmr >= AUTOIP_TMR_INTERVAL) {
me->auto_ip_tmr = 0;
autoip_tmr();
}
#endif
return Q_HANDLED();
}
case LWIP_RX_OVERRUN_SIG: {
LINK_STATS_INC(link.err);
return Q_HANDLED();
}
}
return Q_SUPER(&QHsm_top);
}
/* @(/1/9/3/2) .............................................................*/
static QState QACCDetector_busy(QACCDetector * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/9/3/2) */
case Q_ENTRY_SIG: {
me->m_detectTimes = 0;
//保持1S
QTimeEvt_postEvery(&me->m_Timer, &me->super, TIMEOUT_DETECTING);
status_ = Q_HANDLED();
break;
}
/* @(/1/9/3/2) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/9/3/2/0) */
case Q_TIMEOUT_SIG: {
u8 curState = (u8)GET_ACC_STATE();
me->m_detectTimes++;
/* @(/1/9/3/2/0/0) */
if (curState != me->m_state) {
//状态发生变化，重新开始检测
status_ = Q_TRAN(&QACCDetector_busy);
}
/* @(/1/9/3/2/0/1) */
else {
me->m_state = curState;
/* @(/1/9/3/2/0/1/0) */
if (me->m_detectTimes >= DETECTING_KEPT_AMOUNT) {
static const QEvent acc_on_Evt = {ACC_ON_SIG, 0};
static const QEvent acc_off_Evt = {ACC_OFF_SIG, 0};
TaskEvt *pe;
if(me->m_state == 0)
{
TRACE_(QS_USER, NULL, "[ACC] state = ACC ON");
SetACCState(ACC_ON);
//广播ACC开电消息
QF_publish(&acc_on_Evt, me);
}
else
{
TRACE_(QS_USER, NULL, "[ACC] state = ACC OFF");
SetACCState(ACC_OFF);
//广播ACC关电消息
QF_publish(&acc_off_Evt, me);
}
/*
//上报服务器车辆状态
//1. 00为停车，FE为充电启动；FF为钥匙启动；
pe = Q_NEW(TaskEvt, NEW_TASKSENDREQ_SIG);
pe->cmd = EVS15_CMD_START_STOP_RPT; //命令字
pe->sequence = GeneratePacketSequenceNumber();
pe->ret = (me->m_state == 0) ? STATE_ACCON : STATE_STOP;
QACTIVE_POST(AO_Gprs, (QEvt*)pe, (void*)0);
*/
status_ = Q_TRAN(&QACCDetector_idle);
}
/* @(/1/9/3/2/0/1/1) */
else {
status_ = Q_HANDLED();
}
}
break;
}
/* @(/1/9/3/2/1) */
case ACC_ONCHANGE_SIG: {
//检测过程中收到ACC变化，重新检测
me->m_state = (u8)GET_ACC_STATE();
status_ = Q_TRAN(&QACCDetector_busy);
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
/*..........................................................................*/
QState LwIPMgr_running(LwIPMgr *me, QEvent const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_postEvery(&me->te_LWIP_SLOW_TICK, (QActive *)me,
(LWIP_SLOW_TICK_MS * BSP_TICKS_PER_SEC) / 1000);
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->te_LWIP_SLOW_TICK);
return Q_HANDLED();
}
case SEND_UDP_SIG: {
if (me->upcb->remote_port != (uint16_t)0) {
struct pbuf *p = pbuf_new((u8_t *)((TextEvt const *)e)->text,
strlen(((TextEvt const *)e)->text) + 1);
if (p != (struct pbuf *)0) {
udp_send(me->upcb, p);
printf("Sent: %s\n", ((TextEvt const *)e)->text);
pbuf_free(p); /* don't leak the pbuf! */
}
}
return Q_HANDLED();
}
case LWIP_RX_READY_SIG: {
eth_driver_read();
return Q_HANDLED();
}
case LWIP_TX_READY_SIG: {
eth_driver_write();
return Q_HANDLED();
}
case LWIP_SLOW_TICK_SIG: {
/* has IP address changed? */
if (me->ip_addr != me->netif->ip_addr.addr) {
TextEvt *te;
uint32_t ip_net; /* IP address in the network byte order */
me->ip_addr = me->netif->ip_addr.addr; /* save the IP addr. */
ip_net = ntohl(me->ip_addr);
/* publish the text event to display the new IP address */
te = Q_NEW(TextEvt, DISPLAY_IPADDR_SIG);
snprintf(te->text, Q_DIM(te->text), "%d.%d.%d.%d",
((ip_net) >> 24) & 0xFF,
((ip_net) >> 16) & 0xFF,
((ip_net) >> 8) & 0xFF,
ip_net & 0xFF);
QF_PUBLISH((QEvent *)te, me);
}
#if LWIP_TCP
me->tcp_tmr += LWIP_SLOW_TICK_MS;
if (me->tcp_tmr >= TCP_TMR_INTERVAL) {
me->tcp_tmr = 0;
tcp_tmr();
}
#endif
#if LWIP_ARP
me->arp_tmr += LWIP_SLOW_TICK_MS;
if (me->arp_tmr >= ARP_TMR_INTERVAL) {
me->arp_tmr = 0;
etharp_tmr();
}
#endif
#if LWIP_DHCP
me->dhcp_fine_tmr += LWIP_SLOW_TICK_MS;
if (me->dhcp_fine_tmr >= DHCP_FINE_TIMER_MSECS) {
me->dhcp_fine_tmr = 0;
dhcp_fine_tmr();
}
me->dhcp_coarse_tmr += LWIP_SLOW_TICK_MS;
if (me->dhcp_coarse_tmr >= DHCP_COARSE_TIMER_MSECS) {
me->dhcp_coarse_tmr = 0;
dhcp_coarse_tmr();
}
#endif
#if LWIP_AUTOIP
me->auto_ip_tmr += LWIP_SLOW_TICK_MS;
if (me->auto_ip_tmr >= AUTOIP_TMR_INTERVAL) {
me->auto_ip_tmr = 0;
autoip_tmr();
}
#endif
return Q_HANDLED();
}
case LWIP_RX_OVERRUN_SIG: {
LINK_STATS_INC(link.err);
return Q_HANDLED();
}
}
/* @(/1/7/6/1) .............................................................*/
static QState QCAN_Normal_Mode(QCAN * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/7/6/1) */
case Q_ENTRY_SIG: {
CAN1_PWR_ON();//模块开电
CAN_RECIEVE_ENABLE();//使能接收
me->m_bRecvFrame = 0;
me->m_canfreeTicks = 0;
me->m_ledFlashCnt = 0;
/* 使能秒定时器 */
QTimeEvt_postEvery(&me->m_tickTimer, &me->super, (BSP_TICKS_PER_SEC));
status_ = Q_HANDLED();
break;
}
/* @(/1/7/6/1) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_tickTimer);
status_ = Q_HANDLED();
break;
}
/* @(/1/7/6/1/0) */
case Q_INIT_SIG: {
status_ = Q_TRAN(&QCAN_non_conflicting);
break;
}
/* @(/1/7/6/1/1) */
case PER_SECOND_SIG: {
if(1 == me->m_bRecvFrame)
{
if(me->m_ledFlashCnt++ % 3 == 0) //控制等闪烁，3s
{
CAN_FLASH_LED();
}
me->m_bRecvFrame = 0;
me->m_canfreeTicks = 0;
}
else
{
me->m_canfreeTicks ++;
// if(me->m_canfreeTicks > TIMEOUT_CAN_FREE_SECONDS)
// {
//请求CAN模块休眠
// static const QEvent sleep_Evt = {CAN_RXIDLE_TIMEOUT_SIG, 0};
// QACTIVE_POST(AO_Can, (QEvt*)&sleep_Evt, (void*)0);
CAN_LED_OFF();
// }
}
status_ = Q_HANDLED();
break;
}
/* @(/1/7/6/1/2) */
case CAN_NEWRECVMSG_SIG: {
DATANODE *pNode = CAN_TakeRxMsg();
MP_FreeNode(pNode);
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
