예제 #1
0
int main() {
	test_changeState();
	memset(visited, 0, sizeof(visited));
	visited[0] = 1;
	visited[STATE_NUM - 1] = 1;
	memset(visitedFrom, 0, sizeof(visitedFrom));
	visitedFrom[0] = 0;
	visitedFrom[STATE_NUM - 1] = STATE_NUM - 1;
	enqueueState(0);
	enqueueState(STATE_NUM - 1);
	int state;
	int nextState;
	int i;
	while(0 <= (state = dequeueState())) {
		for(i = 0; i < 16; i++) {
			nextState = changeState(state, i);
			// printf("%d %04X\n", nextState, nextState);
			if(visited[nextState] == 0) {
				visited[nextState]++;
				visitedFrom[nextState] = state;
				enqueueState(nextState);
			}
		}
	}
	int c;
	char stateIn[13];

	while(1) {
		scanf("%s", stateIn);
		c = toInt(stateIn);
		if(c == -1)
			break;
		printToPath(c);
	}

}
예제 #2
0
    void
    BasicDeviceDriver::updateStateMachine(void)
    {
      switch (dequeueState())
      {
        // Wait for activation.
        case SM_IDLE:
          break;

          // Begin activation sequence.
        case SM_ACT_BEGIN:
          setEntityState(IMC::EntityState::ESTA_NORMAL, Status::CODE_ACTIVATING);
          m_wdog.setTop(getActivationTime());
          queueState(SM_ACT_POWER_ON);
          break;

          // Turn power on.
        case SM_ACT_POWER_ON:
          turnPowerOn();
          queueState(SM_ACT_POWER_WAIT);
          break;

          // Wait for power to be on.
        case SM_ACT_POWER_WAIT:
          if (isPowered())
          {
            m_power_on_timer.setTop(m_post_power_on_delay);
            queueState(SM_ACT_DEV_WAIT);
          }

          if (m_wdog.overflow())
          {
            failActivation(DTR("failed to turn power on"));
            queueState(SM_IDLE);
          }
          break;

          // Connect to device.
        case SM_ACT_DEV_WAIT:
          if (m_wdog.overflow())
          {
            failActivation(DTR("failed to connect to device"));
            queueState(SM_IDLE);
          }
          else if (m_power_on_timer.overflow())
          {
            if (connect())
              queueState(SM_ACT_DEV_SYNC);
          }

          break;

          // Synchronize with device.
        case SM_ACT_DEV_SYNC:
          if (m_wdog.overflow())
          {
            failActivation(DTR("failed to synchronize with device"));
            queueState(SM_IDLE);
          }
          else
          {
            if (synchronize())
              queueState(SM_ACT_LOG_REQUEST);
          }
          break;

          // Request log name.
        case SM_ACT_LOG_REQUEST:
          if (m_wdog.overflow())
          {
            failActivation(DTR("failed to request current log name"));
            queueState(SM_IDLE);
          }
          else
          {
            closeLog();
            requestLogName();
            queueState(SM_ACT_LOG_WAIT);
          }
          break;

          // Wait for log name.
        case SM_ACT_LOG_WAIT:
          if (m_wdog.overflow())
          {
            failActivation(DTR("failed to retrieve current log name"));
            queueState(SM_IDLE);
          }
          else
          {
            if (m_log_opened)
              queueState(SM_ACT_DONE);
          }
          break;

          // Activation procedure is complete.
        case SM_ACT_DONE:
          activate();
          queueState(SM_ACT_SAMPLE);
          break;

          // Read samples.
        case SM_ACT_SAMPLE:
          readSample();
          break;

          // Start deactivation procedure.
        case SM_DEACT_BEGIN:
          setEntityState(IMC::EntityState::ESTA_NORMAL, Status::CODE_DEACTIVATING);
          m_wdog.setTop(getDeactivationTime());
          queueState(SM_DEACT_DISCONNECT);
          break;

          // Gracefully disconnect from device.
        case SM_DEACT_DISCONNECT:
          disconnect();
          closeLog();

          m_power_off_timer.setTop(m_power_off_delay);

          queueState(SM_DEACT_POWER_OFF);
          break;

          // Turn power off.
        case SM_DEACT_POWER_OFF:
          if (m_power_off_timer.overflow() || m_wdog.overflow())
          {
            turnPowerOff();
            queueState(SM_DEACT_POWER_WAIT);
          }
          break;

          // Wait for power to be turned off.
        case SM_DEACT_POWER_WAIT:
          if (!isPowered())
            queueState(SM_DEACT_DONE);
          break;

          // Deactivation is complete.
        case SM_DEACT_DONE:
          deactivate();
          queueState(SM_IDLE);
          break;
      }
    }