stateLogic.hpp

Go to the documentation of this file.

#pragma once
 
#include <embedded/digitalSender.hpp>
#include <logic/checkupManager.hpp>
#include <model/structure.hpp>
 
class ASState {
private:
  DigitalSender
      *_digital_sender_;  
  Communicator
      *_communicator_;  
 
public:
  CheckupManager
      _checkup_manager_;        
  State state_{State::AS_OFF};  
 
  explicit ASState(SystemData *system_data, Communicator *communicator,
                   DigitalSender *digital_sender)
      : _digital_sender_(digital_sender),
        _communicator_(communicator),
        _checkup_manager_(system_data) {}
 
  void calculate_state();
};
 
inline void ASState::calculate_state() {
  switch (state_) {
    case State::AS_MANUAL:
      if (_checkup_manager_.should_stay_manual_driving()) break;
 
      DEBUG_PRINT("Entering OFF state from MANUAL");
      DigitalSender::enter_off_state();
 
      state_ = State::AS_OFF;
      break;
 
    case State::AS_OFF:
 
      // If manual driving checkup fails, the car can't be in OFF state, so it goes back to MANUAL
      if (_checkup_manager_.should_stay_manual_driving()) {
        DEBUG_PRINT("Entering MANUAL state from OFF");
        DigitalSender::enter_manual_state();
        state_ = State::AS_MANUAL;
        break;
      }
 
      if (_checkup_manager_.should_stay_off(_digital_sender_)) break;
      if (!_checkup_manager_.should_go_ready_from_off()) break;  // recheck all states
 
      DEBUG_PRINT("Entering READY state from OFF");
      DigitalSender::enter_ready_state();
      state_ = State::AS_READY;
      DEBUG_PRINT("READY state entered...");
      break;
 
    case State::AS_READY:
      if (_checkup_manager_.should_enter_emergency(state_)) {
        DEBUG_PRINT("Entering EMERGENCY state from READY");
        _digital_sender_->enter_emergency_state();
        _checkup_manager_._ebs_sound_timestamp_.reset();
        state_ = State::AS_EMERGENCY;
        break;
      }
      if (_checkup_manager_.should_stay_ready()) {
        break;
      }
 
      DEBUG_PRINT("Entering DRIVING state from READY");
      _digital_sender_->enter_driving_state();
      state_ = State::AS_DRIVING;
      break;
    case State::AS_DRIVING:
      _digital_sender_->blink_led(ASSI_YELLOW_PIN);
 
      if (_checkup_manager_.should_enter_emergency(state_)) {
        DEBUG_PRINT("Entering EMERGENCY state from DRIVING");
        _digital_sender_->enter_emergency_state();
        _checkup_manager_._ebs_sound_timestamp_.reset();
        state_ = State::AS_EMERGENCY;
        break;
      }
      if (_checkup_manager_.should_stay_driving()) break;
 
      DEBUG_PRINT("Entering FINISHED state from DRIVING");
      DigitalSender::enter_finish_state();
      state_ = State::AS_FINISHED;
      break;
    case State::AS_FINISHED:
      if (_checkup_manager_.res_triggered()) {
        DEBUG_PRINT("Entering EMERGENCY state from FINISHED");
 
        _digital_sender_->enter_emergency_state();
        _checkup_manager_._ebs_sound_timestamp_.reset();
        state_ = State::AS_EMERGENCY;
        break;
      }
      if (_checkup_manager_.should_stay_mission_finished()) break;
 
      DEBUG_PRINT("Entering OFF state from FINISHED");
      DigitalSender::enter_off_state();
      _checkup_manager_.reset_checkup_state();
      state_ = State::AS_OFF;
      break;
    case State::AS_EMERGENCY:
      _digital_sender_->blink_led(ASSI_BLUE_PIN);
 
      if (_checkup_manager_.emergency_sequence_complete()) {
        DEBUG_PRINT("Entering OFF state from EMERGENCY");
        DigitalSender::enter_off_state();
        _checkup_manager_.reset_checkup_state();
        state_ = State::AS_OFF;
        break;
      }
      break;
    default:
      break;
  }
}