digitalReceiver.hpp

Go to the documentation of this file.

// ReSharper disable CppMemberFunctionMayBeConst
#pragma once
 
#include <Bounce2.h>
 
#include <model/hardwareData.hpp>
#include <model/structure.hpp>
 
#include "debugUtils.hpp"
#include "hardwareSettings.hpp"
#include "metro.h"
#include "utils.hpp"
 
struct SimulateTSMSActivate {
private:
  unsigned long timer_ = 0;
  int state = 0;
 
public:
  bool activate_shit(bool tsms_activated) {
    switch (state) {
      case 0: {
        if (millis() - timer_ > 10000) {
          state = 1;
          timer_ = millis();
        }
        return true & tsms_activated;
        break;
      }
      case 1: {
        if (millis() - timer_ > 50) {
          timer_ = millis();
          state = 0;
        }
        return false;
      }
    }
  }
};
 
class DigitalReceiver {
  SimulateTSMSActivate sim;
  unsigned long tsms_timer_ = 0;
 
public:
  inline static uint32_t last_wheel_pulse_rl =
      0;  // Timestamp of the last pulse for left wheel RPM calculation
  inline static uint32_t second_to_last_wheel_pulse_rl = 0;  // Timestamp of the second to last
                                                             // pulse for left wheel RPM calculation
  inline static uint32_t last_wheel_pulse_rr =
      0;  // Timestamp of the last pulse for right wheel RPM calculation
  inline static uint32_t second_to_last_wheel_pulse_rr =
      0;  // Timestamp of the second to last pulse for right
          // wheel RPM calculation
 
  void digital_reads();
 
  DigitalReceiver(SystemData* system_data) : system_data_(system_data) {
    pinMode(SDC_TSMS_STATE_PIN, INPUT);
    pinMode(AMI, INPUT);
    pinMode(ASMS_IN_PIN, INPUT);
    pinMode(EBS_SENSOR2, INPUT);
    pinMode(EBS_SENSOR1, INPUT);
 
    pinMode(RL_WSS, INPUT);
    pinMode(RR_WSS, INPUT);
    pinMode(BRAKE_SENSOR, INPUT);
    pinMode(SOC, INPUT);
    pinMode(ATS, INPUT);
    pinMode(WD_READY, INPUT);
    pinMode(WD_SDC_RELAY, INPUT);
    pinMode(ASATS, INPUT);
 
    attachInterrupt(
        digitalPinToInterrupt(RR_WSS),
        []() {
          second_to_last_wheel_pulse_rr = last_wheel_pulse_rr;
          last_wheel_pulse_rr = micros();
        },
        RISING);
    attachInterrupt(
        digitalPinToInterrupt(RL_WSS),
        []() {
          second_to_last_wheel_pulse_rl = last_wheel_pulse_rl;
          last_wheel_pulse_rl = micros();
        },
        RISING);
  }
 
private:
  SystemData* system_data_;  
 
  std::deque<int> brake_readings;                 
  unsigned int asms_change_counter_ = 0;          
  unsigned int aats_change_counter_ = 0;          
  unsigned int sdc_change_counter_ = 0;           
  unsigned int pneumatic_change_counter_ = 0;     
  unsigned int mission_change_counter_ = 0;       
  unsigned int sdc_tsms_change_counter_ = 0;      
  unsigned int ats_change_counter_ = 0;           
  unsigned int wd_ready_change_counter_ = 0;      
  Mission last_tried_mission_ = Mission::MANUAL;  
 
  void read_pneumatic_line();
 
  void read_mission();
 
  void read_asms_switch();
  void read_asats_state();
 
  void read_wheel_speed_sensors();
 
  void read_tsms_sdc();
 
  void read_brake_sensor();
 
  void read_soc();
 
  void read_ats();
 
  void read_watchdog_ready();
 
  void read_rpm();
};
 
inline void DigitalReceiver::digital_reads() {
  read_pneumatic_line();
  read_mission();
  read_asms_switch();
  read_asats_state();
  read_soc();
  read_brake_sensor();
  read_ats();
  read_tsms_sdc();
  read_watchdog_ready();
  read_rpm();
}
 
inline void DigitalReceiver::read_soc() {
  const int raw_value = analogRead(SOC);
  int mapped_value = map(raw_value, 0, ADC_MAX_VALUE, 0, SOC_PERCENT_MAX);
  mapped_value = constrain(mapped_value, 0, SOC_PERCENT_MAX);  // constrain to 0-100, just in case
  system_data_->hardware_data_.soc_ = static_cast<uint8_t>(mapped_value);
}
 
inline void DigitalReceiver::read_tsms_sdc() {
  bool is_sdc_closed = digitalRead(SDC_TSMS_STATE_PIN);  // low when sdc/bspd open
  // is_sdc_closed = this->sim.activate_shit(is_sdc_closed);
  debounce(is_sdc_closed, system_data_->hardware_data_.tsms_sdc_closed_,
           this->sdc_tsms_change_counter_, 1000);
  // DEBUG_PRINT_VAR(is_sdc_closed);
  // DEBUG_PRINT_VAR(system_data_->hardware_data_.tsms_sdc_closed_);
}
inline void DigitalReceiver::read_brake_sensor() {
  int hydraulic_pressure = analogRead(BRAKE_SENSOR);
  insert_value_queue(hydraulic_pressure, brake_readings, 10);
  system_data_->hardware_data_._hydraulic_line_pressure = average_queue(brake_readings);
}
inline void DigitalReceiver::read_pneumatic_line() {
  bool pneumatic1 = digitalRead(EBS_SENSOR2);
  bool pneumatic2 = digitalRead(EBS_SENSOR1);
 
  system_data_->hardware_data_.pneumatic_line_pressure_1_ = pneumatic1;
  system_data_->hardware_data_.pneumatic_line_pressure_2_ = pneumatic2;
  bool latest_pneumatic_pressure = pneumatic1 && pneumatic2;
  // print values
  //  DEBUG_PRINT_VAR(latest_pneumatic_pressure);
  //  DEBUG_PRINT_VAR(system_data_->hardware_data_.pneumatic_line_pressure_);
  //  DEBUG_PRINT_VAR(pneumatic1);
  //  DEBUG_PRINT_VAR(pneumatic2);
 
  debounce(latest_pneumatic_pressure, system_data_->hardware_data_.pneumatic_line_pressure_,
           pneumatic_change_counter_);
}
 
inline void DigitalReceiver::read_mission() {
  int raw_value = analogRead(AMI);
  int contrained_value = constrain(raw_value, 0, 600);
  int mapped_value;
  // int mapped_value = map(constrain(raw_value, 0, ADC_MAX_VALUE), 0, ADC_MAX_VALUE, 0,
  //                        MAX_MISSION);  // constrain just in case
  if (contrained_value < 60) {
    mapped_value = 0;  // Manual
  } else if (contrained_value < 220) {
    mapped_value = 1;  // Acceleration
  } else if (contrained_value < 330) {
    mapped_value = 2;  // Skidpad
  } else if (contrained_value < 420) {
    mapped_value = 3;  // Autocross
  } else if (contrained_value < 475) {
    mapped_value = 4;  // Trackdrive
  } else if (contrained_value < 540) {
    mapped_value = 5;  // EBS Test
  } else {
    mapped_value = 6;  // Inspection
  }
 
  Mission latest_mission = static_cast<Mission>(mapped_value);
  if ((latest_mission == system_data_->mission_) && (latest_mission == last_tried_mission_)) {
    mission_change_counter_ = 0;
  } else {
    mission_change_counter_++;
  }
  this->last_tried_mission_ = latest_mission;
  if (mission_change_counter_ >= CHANGE_COUNTER_LIMIT) {
    system_data_->mission_ = latest_mission;
    mission_change_counter_ = 0;
  }
}
 
inline void DigitalReceiver::read_asms_switch() {
  bool latest_asms_status = digitalRead(ASMS_IN_PIN);
  debounce(latest_asms_status, system_data_->hardware_data_.asms_on_, asms_change_counter_, 1000);
}
 
inline void DigitalReceiver::read_asats_state() {
  bool asats_pressed = !digitalRead(ASATS) && system_data_->hardware_data_.asms_on_;
  debounce(asats_pressed, system_data_->hardware_data_.asats_pressed_, aats_change_counter_);
}
 
inline void DigitalReceiver::read_ats() {
  bool ats_pressed = digitalRead(ATS);
  // DEBUG_PRINT_VAR(ats_pressed);
  debounce(ats_pressed, system_data_->hardware_data_.ats_pressed_, ats_change_counter_);
}
 
inline void DigitalReceiver::read_watchdog_ready() {
  bool wd_ready = digitalRead(WD_READY);
  debounce(wd_ready, system_data_->hardware_data_.wd_ready_, wd_ready_change_counter_);
}
 
inline void DigitalReceiver::read_rpm() {
  unsigned long time_interval_rr = (last_wheel_pulse_rr - second_to_last_wheel_pulse_rr);
  unsigned long time_interval_rl = (last_wheel_pulse_rl - second_to_last_wheel_pulse_rl);
  if (micros() - last_wheel_pulse_rr > LIMIT_RPM_INTERVAL) {
    system_data_->hardware_data_._right_wheel_rpm = 0.0;
  } else {
    system_data_->hardware_data_._right_wheel_rpm =
        1 / (time_interval_rr * MICRO_TO_SECONDS * PULSES_PER_ROTATION) * SECONDS_IN_MINUTE;
  }
  if (micros() - last_wheel_pulse_rl > LIMIT_RPM_INTERVAL) {
    system_data_->hardware_data_._left_wheel_rpm = 0.0;
  } else {
    system_data_->hardware_data_._left_wheel_rpm =
        1 / (time_interval_rl * MICRO_TO_SECONDS * PULSES_PER_ROTATION) * SECONDS_IN_MINUTE;
  }
}