static QState button_down(struct Button *me)
{
switch (Q_SIG(me)) {
case Q_ENTRY_SIG:
post((QActive*)(&ui), me->press_signal, 0);
return Q_HANDLED();
case BUTTON_PRESSED_SIGNAL:
me->counter ++;
if (me->counter == 32) {
return Q_TRAN(button_long);
} else {
return Q_HANDLED();
}
case Q_EXIT_SIG:
post((QActive*)(&ui), me->release_signal, 0);
return Q_HANDLED();
}
return Q_SUPER(button_maybe_down);
}
/*..........................................................................*/
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);
}
/*..........................................................................*/
QState Philo_thinking(Philo *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_postIn(&me->timeEvt, (QActive *)me, THINK_TIME);
return Q_HANDLED();
}
case TIMEOUT_SIG: {
BSP_busyDelay();
return Q_TRAN(&Philo_hungry);
}
case EAT_SIG: /* intentionally fall-through */
case DONE_SIG: {
/* EAT or DONE must be for other Philos than this one */
Q_ASSERT(((TableEvt const *)e)->philoNum != PHILO_ID(me));
return Q_HANDLED();
}
}
return Q_SUPER(&QHsm_top);
}
//............................................................................
QState Philo::thinking(Philo *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
me->m_timeEvt.postIn(me, THINK_TIME);
return Q_HANDLED();
}
case TIMEOUT_SIG: {
BSP_busyDelay();
return Q_TRAN(&Philo::hungry);
}
case EAT_SIG: // intentionally fall-through
case DONE_SIG: {
// EAT or DONE must be for other Philos than this one
Q_ASSERT(((TableEvt const *)e)->philoNum != PHILO_ID(me));
return Q_HANDLED();
}
}
return Q_SUPER(&QHsm::top);
}
// active / idle
QP::QState vca_manager::idle ( vca_manager * const me, QP::QEvt const * const e )
{
QP::QState status;
switch ( e->sig )
{
case Q_ENTRY_SIG:
{
status = Q_HANDLED();
break;
}
default:
status = Q_SUPER ( &vca_manager::active );
break;
}
return status;
}
/*${AOs::FlashMgr::SM::Active::BusyRam::DataBusTest} .......................*/
static QState FlashMgr_DataBusTest(FlashMgr * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::FlashMgr::SM::Active::BusyRam::DataBusTest} */
case Q_ENTRY_SIG: {
me->currRamTest = _DC3_RAM_TEST_DATA_BUS;
me->currRamAddr = 0;
me->errorCode = ERR_SDRAM_DATA_BUS_TEST_TIMEOUT;
QEvt *evt = Q_NEW(QEvt, RAM_OP_START_SIG);
QACTIVE_POST(AO_FlashMgr, (QEvt *)(evt), AO_FlashMgr);
status_ = Q_HANDLED();
break;
}
/* ${AOs::FlashMgr::SM::Active::BusyRam::DataBusTest::RAM_OP_START} */
case RAM_OP_START_SIG: {
me->currRamTest = _DC3_RAM_TEST_DATA_BUS;
me->currRamAddr = SDRAM_testDataBus( 0 );
/* ${AOs::FlashMgr::SM::Active::BusyRam::DataBusTest::RAM_OP_START::[Error?]} */
if (0 != me->currRamAddr) {
me->errorCode = ERR_SDRAM_DATA_BUS;
ERR_printf(
"RAM data bus test failed at addr: 0x%08x on pattern: 0x%08x. Error: 0x%08x\n",
SDRAM_BANK_ADDR + 0, me->currRamAddr, me->errorCode
);
status_ = Q_TRAN(&FlashMgr_Idle);
}
/* ${AOs::FlashMgr::SM::Active::BusyRam::DataBusTest::RAM_OP_START::[else]} */
else {
DBG_printf("No RAM Data bus error found.\n");
status_ = Q_TRAN(&FlashMgr_AddrBusTest);
}
break;
}
default: {
status_ = Q_SUPER(&FlashMgr_BusyRam);
break;
}
}
return status_;
}
/*${AOs::FlashMgr::SM::Active::BusyRam::DeviceTest} ........................*/
static QState FlashMgr_DeviceTest(FlashMgr * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* ${AOs::FlashMgr::SM::Active::BusyRam::DeviceTest} */
case Q_ENTRY_SIG: {
me->currRamTest = _DC3_RAM_TEST_DEV_INT;
me->currRamAddr = 0;
me->errorCode = ERR_SDRAM_DEVICE_INTEGRITY_TEST_TIMEOUT;
QEvt *evt = Q_NEW(QEvt, RAM_OP_START_SIG);
QACTIVE_POST(AO_FlashMgr, (QEvt *)(evt), AO_FlashMgr);
status_ = Q_HANDLED();
break;
}
/* ${AOs::FlashMgr::SM::Active::BusyRam::DeviceTest::RAM_OP_START} */
case RAM_OP_START_SIG: {
me->currRamAddr = SDRAM_testDevice(0, RAM_TEST_BLOCK_SIZE );
/* ${AOs::FlashMgr::SM::Active::BusyRam::DeviceTest::RAM_OP_START::[Error?]} */
if (0 != me->currRamAddr) {
me->errorCode = ERR_SDRAM_DEVICE_INTEGRITY;
ERR_printf(
"RAM device bus test failed at addr: 0x%08x. Error: 0x%08x\n",
me->currRamAddr, me->errorCode
);
status_ = Q_TRAN(&FlashMgr_Idle);
}
/* ${AOs::FlashMgr::SM::Active::BusyRam::DeviceTest::RAM_OP_START::[else]} */
else {
me->errorCode = ERR_NONE;
DBG_printf("No RAM device errors found.\n");
status_ = Q_TRAN(&FlashMgr_Idle);
}
break;
}
default: {
status_ = Q_SUPER(&FlashMgr_BusyRam);
break;
}
}
return status_;
}
// $(AOs::Commands::Statechart::focus_move) ..................................
QState Commands::focus_move(Commands *me, QEvent const *e) {
switch (e->sig) {
// @(/2/4/4/2)
case Q_ENTRY_SIG: {
//Notify(PSTR("AO_Commands: Focus Move Entry\r\n"));
uint16_t ptp_error;
if((ptp_error = Eos.MoveFocus(me->fstep_cmd)) != PTP_RC_OK) { //one step towards the camera
PTPTRACE2("AO_Commands: Focus Step failed", ptp_error);
AO_Lights->postFIFO(Q_NEW(QEvent, LED_ERROR_SIG));
}
if(me->fstep_cmd == NSTEP) {
--me->focus_position;
}
else {
++me->focus_position;
}
me->cmd_delay.disarm();
me->cmd_delay.postIn(me, FM_CMD_DELAY);
return Q_HANDLED();
}
// @(/2/4/4/2)
case Q_EXIT_SIG: {
//Notify(PSTR("AO_Commands: Focus Move Exit\r\n"));
return Q_HANDLED();
}
// @(/2/4/4/2/0)
case CMD_DELAY_SIG: {
//Notify(PSTR("AO_Commands: Focus Move: CMD_DELAY_SIG\r\n"));
FocusMovedEvt *fme = Q_NEW( FocusMovedEvt, FOCUS_MOVED_SIG );
fme->focus_position = me->focus_position;
AO_Lights->postFIFO(Q_NEW(QEvent, LED_WORKING_SIG));
AO_Camera->postFIFO( fme );
return Q_TRAN(&Commands::idle);
}
}
return Q_SUPER(&QHsm::top);
}
/*..........................................................................*/
static QState ToastOven_heating(ToastOven * const me, QEvt const * const e) {
QState status;
switch (e->sig) {
case Q_ENTRY_SIG: {
printf("heater-On;");
status = Q_HANDLED();
break;
}
case Q_EXIT_SIG: {
printf("heater-Off;");
status = Q_HANDLED();
break;
}
default: {
status = Q_SUPER(&ToastOven_doorClosed);
break;
}
}
return status;
}
static QState mmi_show_msg(struct mmi_ao *me)
{
switch (Q_SIG(me)) {
case Q_ENTRY_SIG:
QActive_arm((QActive *) me, TICKS(Q_PAR(me) * 1000));
return Q_HANDLED();
case Q_EXIT_SIG:
QActive_disarm((QActive *) me);
return Q_HANDLED();
case Q_TIMEOUT_SIG:
return Q_TRAN(mmi_navigate);
case SIG_KEY_PRESS:
if (Q_PAR(me) == KEY_ENTER) {
return Q_TRAN(mmi_navigate);
}
return Q_HANDLED();;
}
return Q_SUPER(&QHsm_top);
}
static QState Tag_Fault(Tag * const me) {
QState status;
switch (Q_SIG(me))
{
case Q_ENTRY_SIG:
{
printf("fault\r\n");
status = Q_HANDLED();
break;
}
default:
{
status = Q_SUPER(&QHsm_top);
break;
}
}
return status;
}
/* @(/1/8/23/2/1) ..........................................................*/
static QState QGprs_sleep(QGprs * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/8/23/2/1/0) */
case GPRS_COMMINGSMS_SIG: {
status_ = Q_TRAN(&QGprs_sleep_SMSHandling);
break;
}
/* @(/1/8/23/2/1/1) */
case GPRS_COMMINGCALL_SIG: {
status_ = Q_TRAN(&QGprs_sleep_PhoneCalling);
break;
}
default: {
status_ = Q_SUPER(&QGprs_powerSaveMode);
break;
}
}
return status_;
}
/*..........................................................................*/
QState Calc_result(Calc * const me, QEvt const * const e) {
QState status;
switch (e->sig) {
case Q_ENTRY_SIG: {
BSP_message("result-ENTRY;");
status = Q_HANDLED();
break;
}
case Q_EXIT_SIG: {
BSP_message("result-EXIT;");
status = Q_HANDLED();
break;
}
default: {
status = Q_SUPER(&Calc_ready);
break;
}
}
return status;
}
/* @(/1/6/0/1) .............................................................*/
static QState QTTS_normal(QTTS * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/6/0/1/0) */
case TTS_READMSG_SIG: {
status_ = Q_HANDLED();
break;
}
/* @(/1/6/0/1/1) */
case ACC_OFF_SIG: {
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
/*..........................................................................*/
QState Sensor_busy(Sensor *me) {
switch (Q_SIG(me)) {
case Q_ENTRY_SIG: {
printf("-> busy\n");
return Q_HANDLED();
}
case Q_TIMEOUT_SIG: {
/* timeout in 1/2 second */
QActive_arm((QActive *)me, BSP_TICKS_PER_SEC/2);
++me->procCtr;
printf("process %3d\n", me->procCtr);
if ((me->procCtr & 0x1) == 0) { /* modulo 2 */
return Q_TRAN(&Sensor_idle);
}
return Q_HANDLED();
}
}
return Q_SUPER(&Sensor_processing);
}
QState Philo_eating(Philo * const me, QEvt const * const e) {
TableEvt *pe;
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_armX(&me->timeEvt, EAT_TIME, 0U); /* one shot */
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->timeEvt);
pe = Q_NEW(TableEvt, DONE_SIG);
pe->philNum = me->num;
QF_PUBLISH((QEvt *)pe, me);
return Q_HANDLED();
}
case TIMEOUT_SIG: {
return Q_TRAN(&Philosopher_thinking);
}
}
return Q_SUPER(&QHsm_top);
}
static QState uiMenuMaybeSettime(struct UI *me)
{
switch (Q_SIG(me)) {
case Q_ENTRY_SIG:
lcd_buttons(LCD_BUTTONS_ENTER_DOWN_CANCEL);
lcd_showstring("SETTIME");
return Q_HANDLED();
case BUTTON_ENTER_PRESS_SIGNAL:
ACTION();
me->settime = *gettimep();
return Q_TRAN(uiMenuSettimeYears);
case BUTTON_UP_PRESS_SIGNAL:
ACTION();
return Q_HANDLED();
case BUTTON_DOWN_PRESS_SIGNAL:
ACTION();
return Q_TRAN(uiMenuMaybeCalibrate);
}
return Q_SUPER(uiMenu);
}
static QState uiRun(struct UI *me)
{
switch (Q_SIG(me)) {
case Q_ENTRY_SIG:
lcd_buttons(LCD_BUTTONS_ENTER_UP_DOWN);
show_temperature(me->ti);
show_time(gettimep());
return Q_HANDLED();
case BUTTON_ENTER_PRESS_SIGNAL:
return Q_TRAN(uiMenuMaybeSettime);
case BUTTON_UP_PRESS_SIGNAL:
return Q_TRAN(uiShowMax);
case BUTTON_DOWN_PRESS_SIGNAL:
return Q_TRAN(uiShowMin);
case CURRENT_TEMPERATURE_SIGNAL:
me->ti = (int16_t) Q_PAR(me);
show_temperature(me->ti);
}
return Q_SUPER(uiTop);
}
/* @(/1/0/1/2/1) ...........................................................*/
static QState LPJ_Dimm(LPJ * const me, QEvent const * const e) {
QState status;
switch (e->sig) {
/* @(/1/0/1/2/1) */
case Q_ENTRY_SIG: {
/* Dimm(me->dimm); */
//printf("LPJ_Dimm");
periksaPIR();
status = Q_HANDLED();
break;
}
/* @(/1/0/1/2/1/0) */
case reportBefore_SIG: {
me->before =((reportEvt const *)e)->presence;
if(me->before == ADA) status = Q_TRAN(&LPJ_NodeBefore);
else status = Q_HANDLED();
break;
}
/* @(/1/0/1/2/1/1) */
case PIRIntr_SIG: {
me->pir = ((pirEvt const *)e)->pir;
//kirimReport((me->pir)+4);
if(me->pir == ADA) status = Q_TRAN(&LPJ_OnTheNode);
else status = Q_HANDLED();
break;
}
case TickTime_SIG: {
if(me->dimm < 3500) {
me->dimm +=20;
Dimm(me->dimm);
}
// periksaLux();
status = Q_HANDLED();
}
default: {
status = Q_SUPER(&LPJ_On);
break;
}
}
return status;
}
QP::QState Txr::playBack(Txr * const me, QP::QEvt const * const e) {
QP::QState status_;
switch (e->sig) {
case Q_ENTRY_SIG:
{
ENC_GREEN_LED_ON();
ENC_RED_LED_ON();
me->mPacket.mode = PLAYBACK_MODE;
me->mPacket.position = me->mCurPos;
me->mVelocityManager.Init(50); // init at 50% speed
status_ = Q_HANDLED();
break;
}
case Q_EXIT_SIG:
{
me->mVelocityManager.SetAllLEDsOff();
status_ = Q_HANDLED();
break;
}
case SEND_TIMEOUT_SIG:
{
me->UpdatePositionPlayBack(me);
status_ = Q_HANDLED();
break;
}
case POSITION_BUTTON_SIG:
{
int buttonNum = ((PositionButtonEvt*)e)->ButtonNum;
Q_REQUIRE(buttonNum < NUM_POSITION_BUTTONS);
me->mCurPos = me->mSavedPositions[buttonNum];
status_ = Q_HANDLED();
break;
}
default:
{
status_ = Q_SUPER(&calibrated);
break;
}
}
return status_;
}
/* @(/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_;
}
// @(/1/0/3/1/3) .............................................................
QP::QState Pelican::pedsEnabled(Pelican * const me, QP::QEvt const * const e) {
QP::QState status_;
switch (e->sig) {
// @(/1/0/3/1/3)
case Q_EXIT_SIG: {
BSP_signalPeds(PEDS_DONT_WALK);
status_ = Q_HANDLED();
break;
}
// @(/1/0/3/1/3/0)
case Q_INIT_SIG: {
status_ = Q_TRAN(&Pelican::pedsWalk);
break;
}
default: {
status_ = Q_SUPER(&Pelican::operational);
break;
}
}
return status_;
}
// @(/1/0/3/1/2/1/3) .........................................................
QP::QState Pelican::carsGreenPedWait(Pelican * const me, QP::QEvt const * const e) {
QP::QState status_;
switch (e->sig) {
// @(/1/0/3/1/2/1/3)
case Q_ENTRY_SIG: {
BSP_showState("carsGreenPedWait");
status_ = Q_HANDLED();
break;
}
// @(/1/0/3/1/2/1/3/0)
case TIMEOUT_SIG: {
status_ = Q_TRAN(&Pelican::carsYellow);
break;
}
default: {
status_ = Q_SUPER(&Pelican::carsGreen);
break;
}
}
return status_;
}
// @(/1/0/3/1/2) .............................................................
QP::QState Pelican::carsEnabled(Pelican * const me, QP::QEvt const * const e) {
QP::QState status_;
switch (e->sig) {
// @(/1/0/3/1/2)
case Q_EXIT_SIG: {
BSP_signalCars(CARS_RED);
status_ = Q_HANDLED();
break;
}
// @(/1/0/3/1/2/0)
case Q_INIT_SIG: {
status_ = Q_TRAN(&Pelican::carsGreen);
break;
}
default: {
status_ = Q_SUPER(&Pelican::operational);
break;
}
}
return status_;
}
//............................................................................
QState QHsmTst::s211(QHsmTst *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
BSP_display("s211-ENTRY;");
return Q_HANDLED();
}
case Q_EXIT_SIG: {
BSP_display("s211-EXIT;");
return Q_HANDLED();
}
case D_SIG: {
BSP_display("s211-D;");
return Q_TRAN(&QHsmTst::s21);
}
case H_SIG: {
BSP_display("s211-H;");
return Q_TRAN(&QHsmTst::s);
}
}
return Q_SUPER(&QHsmTst::s21);
}
/*${AOs::Blinky::SM::on} ...................................................*/
static QState Blinky_on(Blinky * const me) {
QState status_;
switch (Q_SIG(me)) {
/*${AOs::Blinky::SM::on} */
case Q_ENTRY_SIG: {
BSP_ledOn();
status_ = Q_HANDLED();
break;
}
/*${AOs::Blinky::SM::on::Q_TIMEOUT} */
case Q_TIMEOUT_SIG: {
status_ = Q_TRAN(&Blinky_off);
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
static QState uiShowMaxOrMin(struct UI *me)
{
switch (Q_SIG(me)) {
case Q_ENTRY_SIG:
lcd_buttons(LCD_BUTTON_CANCEL|LCD_BUTTON_UP|LCD_BUTTON_DOWN);
BSP_fast_timer_1(TRUE);
lcd_showdigits(" ");
lcd_colon(0);
return Q_HANDLED();
case TIME_SIGNAL:
/* Ignore time updates so we don't display anything on the time
digits while we're displaying a max or min. */
return Q_HANDLED();
case BUTTON_CANCEL_PRESS_SIGNAL:
return Q_TRAN(uiRun);
case Q_EXIT_SIG:
BSP_fast_timer_1(FALSE);
return Q_HANDLED();
}
return Q_SUPER(uiTop);
}
static QState uiMenuCalibratePause(struct UI *me)
{
switch (Q_SIG(me)) {
case Q_ENTRY_SIG:
/* Process any event that will cause an exit out of calibration
mode that we got while we were away doing the ADC
processing. */
recall(me);
/* Read the temperature fairly often. We only wait for 5/32
seconds here. We must wait for more than one tick so that
the recorder, which has a lower priority, gets a chance to
process its own ticks before ours and hence get the ADC when
required. */
QActive_armX((QActive*)me, 1, 5);
return Q_HANDLED();
case Q_TIMEOUT1_SIG:
me->temperatureWaits = 0;
return Q_TRAN(uiMenuCalibrateTemperatureStart);
}
return Q_SUPER(uiMenuCalibrate);
}
/*..........................................................................*/
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);
}
/*${components::aoGrinder::SM::settling} ...................................*/
static QState aoGrinder_settling(aoGrinder * const me) {
QState status_;
switch (Q_SIG(me)) {
/* ${components::aoGrinder::SM::settling} */
case Q_ENTRY_SIG: {
QActive_arm((QActive *)me, GRINDER_SETTLING_TIME);
status_ = Q_HANDLED();
break;
}
/* ${components::aoGrinder::SM::settling::Q_TIMEOUT} */
case Q_TIMEOUT_SIG: {
status_ = Q_TRAN(&aoGrinder_done);
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
