Cómo realmente funcionan los arreglos en Arduino/Teensy?

Hola buenas noches estimados. Este es mi primer post.

Antes que nada me gustaría aclarar que, aunque esté programando en Arduino, mi placa es un Teensy 3.1 AMD cortex 96MHz (le instalé el script Teensyduino para poder enlazar la placa con el software). Igualmente les comento que suelo trabajar con OOP (de hecho mi fuerte es C# derivado de C).

Aclarado esto, procedo con mi duda:

Intento desarrollar un núcleo de control en el que se lleven a cabos distintas tareas, siendo las mismas ejecutadas según un orden de prioridad (para ello tendría que elegir una política de planificación, por ahora estoy probando con RM). Mi algoritmo lo diseñé de tal forma que trabaje con clases y objetos, creando una clase base con la información de cada tarea, y una clase de orden superior que me ejecute las tareas. Suena sencillo.

Mi problema radica en que intento trabajar con arreglos de objetos, con llamados a métodos para tener acceso a los atributos (declarados los mismos privados para su protección), y es allí donde el sistema me presenta errores muy, pero muy extraños.

El código correspondiente a una tarea individual:

class tarea {
  private:
    int Cik, Dik, Pik, Fi;
    long Ki;
    float alpha;
    bool listo;
    

  public:
    bool setReady(int prm);
    int getCik();
    int getPik();
    int getDik();
    float getAlpha();
    int getFi();
    bool isReady();
    void dormir(int x);
    void funcion();
    void constructor(int a, int b, int c, float d, int e);
    void borrar();
};

Su método interno getPik() es como sigue:

int tarea::getPik(){
  return Pik;
}

En cuanto a la clase de orden superior, la tengo definida así:

class planificador {
  private:
    int maxT, param[];
    void escalador();

  public:
    void constructor(int x);
    void priorizar(int p);
    void ejecutar();
    void resetear();
    void interrumpir();
    void imprimir();
} plan;

Y declaré un arreglo como variable global con un tope definido:

tarea[] T[tope];

Actualmente realizo pruebas sobre este método:

void planificador::priorizar(int p) {
  for(int i = 0; i< maxT; i++){
    switch(p) {
      case 1: param[i] = Ti[i].getPik(); 
              Serial.println(param[i]);
              delay(1000); 
      case 2: /* Planificador DM */ break;
      case 3: /* Planificador Redu */ break;
      case 4: /* Planificador EDF */ break;
      case 5: /* Planificador LPRMFAE */ break;
    }
  }
}

El problema surge en la línea:

param[i] = Ti[i].getPik();

Ya que, en teoría, el método getPik() debería símplemente mostrar una copia del valor almacenado en la variable Pik, y almacenarlo en pa posición “i” del arreglo param. Sin embargo, en vez de hacer una copia, pareciera que lo que hace es “mover” el valor de esa variable hasta otra. De hecho cuando imprimo el contenido de esos objetos antes y después de la ejecución del método “priorizar”, en la última impresión me aparecen valores raros como 104356789 o algo por el estilo (y según tengo entendido, sería un valor residual en la posición de memoria). Lógicamente veo bien planteado el algoritmo, pero como no estoy acostumbrada a programar en Arduino no sé si su mecánica tiene alguna diferencia con respecto a C/C++/C#, ya que no logro explicarme por qué se destruye el valor si lo que quiero es una copia del mismo.

Entonces, alguien me podría aclarar cuál es el problema? Si la asignación es destructiva… qué podría hacer? Acaso debo crear un respaldo de los datos en el EEPROM?

Saludos.

Al final lo solucioné colocando los arreglos como variables globales. Sin embargo aún me queda la duda del por qué la asignación de elementos entre arreglos se hace de forma destructiva (según mi percepción). Alguien podría favor aclararlo?

No estoy muy ducho en programar objetos en arduino, tal vez diga una burrada, pero si construiste el objeto T[] tarea[] T[tope];

no deberia ser param [ i ] = T[ i ] .getPik();

Saludos.

Eso hice en una de mis pruebas. El problema es que, al hacerlo, sí lleno el arreglo param bien, pero lo que tenía en T se pierde (cuando no debería). Allí está el meollo del asunto.

Creo saber donde esta tu problema, no declaraste un constructor valido

void constructor(int a, int b, int c, float d, int e);

deberías utilizar tarea (int a, int b, int c, float d, int e);

GHN81: pero lo que tenía en T se pierde (cuando no debería). [/quote] Pero en T[ i ] no tienes nada, aunque la notación sea igual a un array, en realidad es un objeto. Si deseas hace operaciones debes definir los operadores en la clase, por ejemplo si deseas asignar a una variable de la forma a=T[1]; debieras declarar en la clase operator unsigned int() * { return (Pik) ; }* Es decir si no encuentra ningún operador devuelva el valor de Pik.

Hola. Hay un par de cosas que me rechinan un poco, aunque igual estoy equivocado yo. Por un lado:

tarea[] T[tope];

¿No debería ser sencillamente así?

tarea T[tope];

Y por otro lado, la declaración dentro de un objeto de un array sin tamaño:     int maxT, param[]; ¿De qué forma inicializas param? Además dices que las dos clases están relacionadas y que una es clase base y otra superior, pero no veo dicha relación por ningún lado. ¿Estás intentando aplicar herencia de clases o algo similar?

De todas formas, lo mejor es que pusieras el código completo o expliques en mayor profundidad qué deseas hacer.