ESP8266_Treppenlicht/lib/treppe/treppe.cpp

#include "treppe.h"

/*
    - dimmt stufe (0 - 15, PCA9685 outputs) mit linearen ticks
    von idle bis active pwm
    - return false solange gedimmt wird
    - return true bei nächster stufe
*/
bool Treppe::dimm_stufe(uint8_t stufe)
{
  if (fsm_outputs.dimmrichtung == DR_AUFDIMMEN)
    current_pwm += differenz_pwm_pro_tick;
  else
    current_pwm -= differenz_pwm_pro_tick;
  Serial.printf("dimm_stufe %d %f\n", stufe, current_pwm);
  pwmController.setChannelPWM(stufe, static_cast<uint16_t>(current_pwm));

  current_tick++;
  if (current_tick >= ticks_pro_stufe)
    return false;
  return true;
}


/*
    - dimmt treppe (all PCA9685 outputs) mit linearen ticks
    von idle bis active brightness
    - return false solange gedimmt wird
    - return true bei ende
*/
bool Treppe::dimm_treppe()
{
  // needs to be in state machine
  return true;
}


/*
    - nach dem dimmen einer stufe wird die stufe weitergezählt
    - abbruch am ende => anim_beendet = true;
*/
void Treppe::anim_tick()
{
  if (!dimm_stufe(stufe))
  {
    Serial.printf("anim_tick():  stufe: %d, start: %d, ziel: %d, current %f\n",
                  stufe, start_pwm, ziel_pwm, current_pwm);

    if (fsm_outputs.laufrichtung == LR_HOCH)
    {
      if (stufe >= stufen - 1)
      {
        anim_beendet = true;
        return;
      }
      stufe++;
    }
    else
    {
      if (stufe <= 0)
      {
        anim_beendet = true;
        return;
      }
      stufe--;
    }
    current_tick = 0;
    current_pwm = start_pwm;
  }
}

// startbedingunen für animation
void Treppe::start_animation()
{
  anim_beendet = false;

  if (fsm_outputs.laufrichtung == LR_HOCH)
    stufe = 0;
  else
    stufe = stufen - 1;

  if (fsm_outputs.dimmrichtung == DR_AUFDIMMEN)
  {
    start_pwm = idle_pwm_internal;
    ziel_pwm = active_pwm;
  }
  else
  {
    start_pwm = active_pwm;
    ziel_pwm = idle_pwm_internal;
  }

  current_tick = 0;
  current_pwm = start_pwm;
}

void Treppe::print_state_on_change()
{
  static FSMTreppeModelClass::ExtU_FSMTreppe_T last_in;
  static FSMTreppeModelClass::ExtY_FSMTreppe_T last_out;
  if (
      fsm_inputs.anim_beendet != last_in.anim_beendet ||
      fsm_inputs.sensor_oben != last_in.sensor_oben ||
      fsm_inputs.sensor_unten != last_in.sensor_unten ||
      fsm_outputs.dimmrichtung != last_out.dimmrichtung ||
      fsm_outputs.laufrichtung != last_out.laufrichtung ||
      fsm_outputs.status != last_out.status)
  {
    last_in.anim_beendet = fsm_inputs.anim_beendet;
    last_in.sensor_oben = fsm_inputs.sensor_oben;
    last_in.sensor_unten = fsm_inputs.sensor_unten;
    last_out.dimmrichtung = fsm_outputs.dimmrichtung;
    last_out.laufrichtung = fsm_outputs.laufrichtung;
    last_out.status = fsm_outputs.status;

    Serial.printf("FSM IN: s_u: %d, s_o: %d, beendet: %d =>",
                  fsm_inputs.sensor_oben, fsm_inputs.sensor_unten, fsm_inputs.anim_beendet);
    Serial.print(" step => ");
    Serial.printf("OUT: LR: %d DR: %d ST: %d\n",
                  fsm_outputs.laufrichtung, fsm_outputs.dimmrichtung, fsm_outputs.status);
  }
}

bool Treppe::read_sensor(int sensor)
{

  /*
  reads sensors with edge detection
  
  returns true if motion was detected
  returns false if no motion was detected
  returns false if motion was detected, but state did not change back to not detected
  */
  uint8_t pegel = digitalRead(sensor);
  static uint8_t pegel_alt[2] = {0, 0};

  uint8_t index = 0;
  if (sensor == SENSOR_OBEN)
    index = 0;
  else
    index = 1;

  if (pegel == 1 && pegel_alt[index] == 0)
  {
    pegel_alt[index] = pegel;
    return true;
  }
  else
  {
    pegel_alt[index] = pegel;
    return false;
  }
  //return static_cast<bool>(pegel);
}

float Treppe::read_ldr()
{
  /* 
  Reads Illuminance in Lux

  FUTURE USE : show current Illuminance on Webserver in order to calibrate

  Voltage Divider 1 (R13, R14):
  R13 = 220k, R14 = 82k
  V(ADC) = V(in1) * R14/(R13+R14)
  -> V(in1) = V(ADC) * (R13+R14)/R14
  V(ADC) = analogRead(A0)/1023.00
  -> V(in1) = analogRead(A0)/1023.00 * (R13+R14)/R14
            = analogRead(A0) * (R13+R14)/(R14*1023.00)
            = analogRead(A0) * (220k+82k)/(82k*1023.00)
            = analogRead(A0) * 0.0036
  
  Voltage Divider 2 (LDR, R1 || (R13+R14))
  R1 = 47k, R13+R14 = 302k -> R1||(R13+R14) = 40,67k
  Vcc/V(in1) = R(LDR) / (R1||(R13+R14))
  -> R(LDR) = Vcc/V(in1) * (R1||(R13+R14))
  R(LDR) = 3.3V * 40.67k / V(in1)

  Join formulas:

  R(LDR) = 3.3V * 40.67k / (0.0036 * analogRead(A0))
         = 37280.00/analogRead(A0)
  ldr_ohm = R(LDR)

  E(LDR) = 6526.5 * R(LDR)^-2   (see Excel Regression)
  E(LDR) = 6526.5 / (R(LDR)^2)
  ldr_value = E(LDR)
  */
  float ldr_ohm = 37280.00 / analogRead(A0);
  float ldr_value = 6526.6/(ldr_ohm*ldr_ohm);
  return ldr_value;
}

bool Treppe::check_ldr()
{
  static uint8_t active = 0;

#ifdef LDRDEBUG
  Serial.printf("R(LDR) = %f kOhm  %f lux\n", ldr_value, lux);
  return true;
#endif

  // follow up: averaging over many samples?
  float ldr = read_ldr();
  if (ldr < ldr_schwelle)
    active = 1;
  if (ldr > ldr_schwelle + LDR_HYS)
    active = 0;
  activate_idle_pwm(active);
  return active;
}

void Treppe::task()
{
  fsm_inputs.ldr_schwelle = check_ldr();

  fsm_inputs.sensor_oben = read_sensor(SENSOR_OBEN);
  fsm_inputs.sensor_unten = read_sensor(SENSOR_UNTEN);
  fsm_inputs.anim_beendet = static_cast<bool>(anim_beendet);

  FSMTreppe_Obj.setExternalInputs(&fsm_inputs);
  FSMTreppe_Obj.step();
  fsm_outputs = FSMTreppe_Obj.getExternalOutputs();
  print_state_on_change();

  if (fsm_outputs.status > ST_RUHEZUSTAND)
  {
    if (anim_beendet == true &&
        (fsm_outputs.status == ST_AUFDIMMEN_HOCH || 
         fsm_outputs.status == ST_ABDIMMEN_HOCH  ||
         fsm_outputs.status == ST_AUFDIMMEN_RUNTER || 
         fsm_outputs.status == ST_ABDIMMEN_RUNTER)
       )
    {
      start_animation();
    }
    if (!anim_beendet)
      anim_tick();
  }
}

void Treppe::berechne_dimmer()
{
  ticks_pro_stufe = time_per_stair / INT_TIME; // [ms]
  differenz_pwm_pro_tick = (float)(active_pwm - idle_pwm_internal) 
                                / (float)ticks_pro_stufe;

}

void Treppe::setup()
{
  pwmController.resetDevices();
  // Deactive PCA9685 Phase Balancer due to LED Flickering
  // https://github.com/NachtRaveVL/PCA9685-Arduino/issues/15
  // see also lib/PCA9685-Arduin/PCA9685.h:204
  pwmController.init(PCA9685_PhaseBalancer_None);
  //pwmController.init(PCA9685_PhaseBalancer_Linear);
  pwmController.setPWMFrequency(100);
  //pwmController.setAllChannelsPWM(idle_pwm);

  pinMode(A0, INPUT);
  pinMode(SENSOR_OBEN, INPUT);
  pinMode(SENSOR_UNTEN, INPUT);
  pinMode(OE, OUTPUT);
  digitalWrite(OE, 0);

  Serial.printf("differenz_pwm_pro_tick %f\n", differenz_pwm_pro_tick);
  Serial.printf("Treppe: initial parameters: stufen=%d\n", stufen);
}

void Treppe::set_idle_prozent(int prozent) {
  uint16_t new_pwm = active_pwm * prozent / 100;
  set_idle_pwm(new_pwm);
}

void Treppe::set_idle_pwm(uint16_t new_idle_pwm)
{
  if(new_idle_pwm > active_pwm) {
    idle_pwm = active_pwm;
  } else {
    idle_pwm = new_idle_pwm;
  }

  Serial.printf("Treppe: idle_pwm=%d\n", idle_pwm);
  berechne_dimmer();
  activate_idle_pwm(true);
}

void Treppe::activate_idle_pwm(bool active)
{
  static uint16_t last_pwm = 0;

  if (fsm_outputs.status == ST_RUHEZUSTAND || fsm_outputs.status == ST_INAKTIV_LDR)
  {
    idle_pwm_internal = idle_pwm * active;
    if (idle_pwm_internal != last_pwm)
    {
      // Dimming Function for all LEDS ?
      berechne_dimmer();
      pwmController.setAllChannelsPWM(idle_pwm_internal);
      last_pwm = idle_pwm_internal;
    }
  }
}

void Treppe::set_active_pwm(uint16_t _active_pwm)
{
  active_pwm = _active_pwm;
  berechne_dimmer();
  Serial.printf("Treppe: active_pwm=%d\n", active_pwm);
}
void Treppe::set_time_per_stair(uint16_t _time_per_stair)
{
  time_per_stair = _time_per_stair;
  berechne_dimmer();
  Serial.printf("Treppe: time_per_stair=%d\n", time_per_stair);
}