Stumped. Bool values from class objects are returning ascending integers?

Question

Lot of code to post because I can't really tell where the issue is. I am trying to run this on an ESP32 chip and am writing the code in vscode with platformio.

The function

  byte _previousPoint(){
      for (byte point = 0; point < maxPoints; point ++){ //loop through active points.
        if (_points[point + 1].getActive() != 1){
          return point;
        }
        else {
          long t1 = point_seconds(point);
          long t2 = point_seconds(point + 1);
          if (t1 <= currentTime){ //If current time is after this point.
            if (t2 > currentTime){ //If current time is less than the next point (it is sandwiched).
              return point;
            }
          }
        }
      }
      return 0;
    }

Is not behaving as I expect. And it seems the cause is that the function

bool getActive(){
  return _active;
}

under the class point is returning not a bool but ascending numbers for each channel. point.getActive() should return a bool value, and that bool value should default to 0 (as it is set in the class definition), which is why this makes no sense. The point that is returning the erroneous values is the last one in the _points[maxPoints] array for each channel, and that value seems to match the channel numbers (for red it is 0, for green it is 1, for blue it is 2, etc.)

If I print the value _active upon running the point.setActive() function it comes out correctly. So something is wrong with "getting" it later.

Here is full code below. Let me know if you need some clarification because I know it's a lot. And thanks for anybody patient enough to help.

#include <Arduino.h>


long currentTime;
long lastUp;
byte totalChannels = 4;
const byte maxPoints = 3;


class point {
  public:
    point(){
    }

    void clear(){
      _active = 0;
      _day = 0;
      _hour = 0;
      _minute = 0;
      _second = 0;
      _intensity = 0;
      _mode = 0;
    }

    bool getActive(){
      return _active;
    }
    uint getDay(){
      return _day;
    }
    byte getHour(){
      return _hour;
    }
    byte getMinute(){
      return _minute;
    }
    byte getSecond(){
      return _second;
    }
    int getIntensity(){
      return _intensity;
    }
    byte getMode(){
      return _mode;
    }

    void setActive(bool active){
      _active = active;
    }

    void setDay(uint day){
      _day = day;
    }

    void setHour(byte hour){
      _hour = hour;
    }

    void setMinute(byte minute){
      _minute = minute;
    }

    void setSecond(byte second){
      _second = second;
    }

    void setIntensity(byte intensity){
      _intensity = intensity;
    }

    void setMode(byte mode){
      _mode = mode;
    }

  private:
    bool _active = 0;
    uint _day = 0;
    byte _hour = 0;
    byte _minute = 0;
    byte _second = 0;
    int _intensity = 0;
    byte _mode = 0;
};

class channel {

  public:
    channel(String color, byte pin){
      this->_color = color;
      this->_pin = pin;
      init();
    };

    void setpoint(byte row, point &newPoint, uint day, byte hour, byte minute, byte second, byte intensity, byte mode){ //edits points (for debug)
      newPoint.setDay(day);
      newPoint.setHour(hour);
      newPoint.setMinute(minute);
      newPoint.setSecond(second);
      newPoint.setIntensity(intensity);
      newPoint.setMode(mode);
      newPoint.setActive(1);
      _points[row] = newPoint;
    }

    bool getPoint(byte point){
      return _points[point + 1].getActive();
    }

    void clearAllPoints(){
      for (byte point = 0; point < maxPoints; point ++ ){
        _points[point].clear();
      }
    }

    void setPin(byte pin){
      _pin = pin;
    }

    byte getPin(){
      return _pin;
    }

    uint getIntensity(){
      byte point1 = _previousPoint();
      byte point2 = _nextPoint(point1);
      byte fade_mode = _points[point1].getMode();
      uint intensity;
      if (point2 != 0){
        if (fade_mode == 0){
        intensity = _interpolate_lin(point1, point2);
        }
        else if (fade_mode == 1){
        intensity = _interpolate_sin(point1, point2);
        } 
      }
      else if (point2 != 1){
        if (fade_mode == 0){
        intensity = _interpolate_lin(point1, point2);
        }
        else if (fade_mode == 1){
        intensity = _interpolate_sin(point1, point2);
        } 
      }
      return intensity;
    }

  private:
    //class attributes
    point _points[maxPoints]; //points maximum of 64 points per channel. 
    byte _pin; //PWM pin output for channel
    String _color; //LED color

    float _interpolate_lin(byte point1, byte point2){
      float idiff = _points[point2].getIntensity() - _points[point1].getIntensity();
      float tdiff = point_seconds(point2) - point_seconds(point1);
      float m;
      if (tdiff != 0){
        m = idiff / tdiff;
      }
      else{
        m = 0;
      }
      float t = currentTime - point_seconds(point1);
      float b = _points[point1].getIntensity();
      //linear equation result
      float i = (m * t) + b;
      return i;
    }

    float _interpolate_sin(byte point1, byte point2){
      float amplitude = _points[point2].getIntensity() - _points[point1].getIntensity();
      float tdiff = point_seconds(point2) - point_seconds(point1);
      float a = (-0.5 * amplitude);
      float b = (2 * PI) / (2 * tdiff);
      float t = (currentTime - point_seconds(point1));
      float d = 0.5 * abs(amplitude);
      //cosine equation result
      float i = (a * cos(b * t)) + d;
      return i;
    }

    byte _previousPoint(){
      for (byte point = 0; point < maxPoints; point ++){ //loop through active points.
        if (_points[point + 1].getActive() != 1){
          return point;
        }
        else {
          long t1 = point_seconds(point);
          long t2 = point_seconds(point + 1);
          if (t1 <= currentTime){ //If current time is after this point.
            if (t2 > currentTime){ //If current time is less than the next point (it is sandwiched).
              return point;
            }
          }
        }
      }
      return 0;
    }

    byte _nextPoint(byte point){
      if (_points[point + 1].getActive() != 1){ //if next point is inactive, previous is last in cycle. Next point is 0.
        return 0;
      }
      else if (_points[point + 1].getActive() == 1){ //if next point is active, return it as _nextPoint.
        return point + 1;
      }
      return 0;
     }  

    long point_seconds(byte point){
      return ((_points[point].getHour() * 3600) + (_points[point].getMinute() * 60) + _points[point].getSecond());
    }     
};

//declaring channels and initializing channel array. 
channel red("red", 0);
channel green("green", 1);
channel blue("blue", 2);
channel royal("royal blue", 3);

channel *channels[] = {
  &red,
  &green,
  &blue,
  &royal
};

void setIntensities(){
  for (byte ch = 0; ch < totalChannels; ch ++){
    channel ledChannel = *channels[ch];
    byte intensity = ledChannel.getIntensity(); 
    ledcWrite(ledChannel.getPin(), intensity);
  }
}

void setup() {
  Serial.begin(9600);
  //set up LED outputs
  ledcAttachPin(12, 0);
  ledcAttachPin(13, 1);
  ledcAttachPin(16, 2);
  ledcSetup(0, 1000, 8);
  ledcSetup(1, 1000, 8);
  ledcSetup(2, 1000, 8);
  //clear all points
  for (byte ch = 0; ch < totalChannels; ch++){
    channel ledChannel = *channels[ch];
    ledChannel.clearAllPoints();
  }
  //Set points for testing purposes
  point red1;
  point red2;
  point red3;

  point green1;
  point green2;
  point green3;

  point blue1;
  point blue2;
  point blue3;

  point royal1;
  point royal2;
  point royal3;

  red.setpoint(0, red1, 0, 0, 0, 0, 0, 0);
  red.setpoint(1, red2, 0, 0, 0, 10, 255, 0);
  red.setpoint(2, red3, 0, 0, 0, 20, 0, 0);

  green.setpoint(0, green1, 0, 0, 0, 10, 0, 0);
  green.setpoint(1, green2, 0, 0, 0, 20, 255, 0);
  green.setpoint(2, green3, 0, 0, 0, 30, 0, 0);

  blue.setpoint(0, blue1, 0, 0, 0, 20, 0, 0);
  blue.setpoint(1, blue2, 0, 0, 0, 30, 255, 0);
  blue.setpoint(2, blue3, 0, 0, 0, 40, 0, 0);

  royal.setpoint(0, royal1, 0, 0, 0, 30, 0, 0);
  royal.setpoint(1, royal2, 0, 0, 0, 40, 255, 0);
  royal.setpoint(2, royal3, 0, 0, 0, 50, 0, 0);

    Serial.print("red: "); // <----------These are to debug. The channels are returning ascending bool values for point 3 (which should all be 0)
  for (byte point = 0; point < 3; point++){
    Serial.print(red.getPoint(point));
  }

  Serial.print(" green: ");
  for (byte point = 0; point < 3; point++){
    Serial.print(green.getPoint(point));
  }
  
  Serial.print(" blue: ");
  for (byte point = 0; point < 3; point++){
    Serial.print(blue.getPoint(point));
  }

  Serial.print(" royal: ");
  for (byte point = 0; point < 3; point++){
    Serial.print(royal.getPoint(point));
  }
}

void loop() {
  
  currentTime = millis() / 1000;
  if (currentTime > lastUp){
    setIntensities();
    lastUp = currentTime;
  }
}

Answer 1

The problem is with your getPoint() method:

bool getPoint(byte point){
      return _points[point + 1].getActive();
    }

You're referencing the array with point + 1 instead of point so when you attempt to read the last item in the array you're actually reading off the end of the array and getting arbitary data.

Just change this to:

bool getPoint(byte point){
      return _points[point].getActive();
    }

You're also doing the same thing on your _previousPoint() method:

  byte _previousPoint(){
      for (byte point = 0; point < maxPoints; point ++){ //loop through active points.
        if (_points[point + 1].getActive() != 1){
          return point;
        }

Again - I think you want to just replace [point + 1] with [point] to go through the list of points and prevent reading past the end of the array.