Problem with multidimensional array data asignation

Hello,
I’m a mechanical engineer student (programming is not my area) who is trying to make a conveyer belt that will eliminate certain bottles of it by identifying their color.
For that i’m using the TCS3200 color sensor and an arduino DUE.

I was reading information about the sensor here and downloaded a library for it but it didn’t work with the DUE.

So, i have to calibrate the sensor. For that im reading the sensor data with this function:

void lecturaColores (void) //Funcion que voy a llamar para hacer la lectura de las componentes RGB del cubo acutal
{
  //Lectura componente ROJA
  //Seteo de pines para leer rojo
  digitalWrite(sensorS2,LOW);
  digitalWrite(sensorS3,LOW);
  //Lectura del sensor y asignacion del valor
  compRoja=pulseIn(sensorOUT,LOW); //Lee el tiempo del semiciclo bajo

  //Lectura componente Verde
  //Seteo de pines para leer verde
  digitalWrite(sensorS2,HIGH);
  digitalWrite(sensorS3,HIGH);
  //Lectura del sensor y asignacion del valor
  compVerde=pulseIn(sensorOUT,LOW); //Lee el tiempo del semiciclo bajo


   //Lectura componente Azul
  //Seteo de pines para leer azul
  digitalWrite(sensorS2,LOW);
  digitalWrite(sensorS3,HIGH);
  //Lectura del sensor y asignacion del valor
  compAzul=pulseIn(sensorOUT,LOW); //Lee el tiempo del semiciclo bajo
    
}

Then, i have 3 cubes. 1 white, 1 red and 1 green. The white one (blanco in spanish) is the OK color, the others must be eliminated from the belt. But i have to calibrate them as well.

For the porpouse of this question i will only show the white cube calibration.
I’m making multidimensional arrays to storage the data for each RGB component of each cube.
And then I want to use that data to make a control chart X-S to eliminate values that are not in range with the color readings.

void calibracion(void) //Funcion para calibrar el sensor
{
   //Variables para la calibracion
   int cuboBlanco=0;
   int cuboRojo=0;
   int cuboVerde=0;
   const int m=3; //m es la cantidad de muestras, las fijo en 3
   int j=0; //j es la cant de observaciones en una muestra "m", que luego llamo n para clarificar

   //Inicio los contadores para indexear dentro de la matriz y arrays
   int mm=0; //Acordarse que la primera posicion del indexeo debe ser [0] y la ultima un numero menos de la cantidad de elementos "m"
   int nn=0;


   //Variables para los limites de control grafico X-S
   int indexeador=0;
   float a3=0;
   float b4=0;
   float c4=0;
   /*
   * Los vectores los defino hasta 25 observaciones (pero desde 10), 
   * si son mas aplico la formula para obtener los valores de A3 y B4
   */
   float vectorA3[16]={0.975,0.927,0.886,0.85,0.817,0.789,0.763,0.739,0.718,0.698,0.680,0.663,0.647,0.633,0.619,0.606};
   float vectorB4[16]={1.716,1.679,1.646,1.618,1.594,1.572,1.552,1.534,1.518,1.503,1.49,1.477,1.466,1.455,1.445,1.435};

   //Límites de control, límite superior de control(LSC), límite inferior de control (LIC). La línea media de control (LMC) es la media de las medias
   float LSCcompRoja=0;
   float LICcompRoja=0;
   float LSCcompVerde=0;
   float LICcompVerde=0;
   float LSCcompAzul=0;
   float LICcompAzul=0;
   
   
   while(contadorCalibracion<duracionCalibracion) //uso para contar cuantas observaciones realizo en el timepo de muestra
    {
      j++;
      Serial.print("Inicializando");
      Serial.print('\n');
    }

    contadorCalibracion=0; //reestablezco el valor
    const int n=j; //Fijo la constante n para usarla en los arrays

    
    /*
     * m= Cantidad de muestras
     * n= Cantidad de observaciones en la muestra mi
     */
    
    //Inicio las matrices donde guardo las muestras, las filas son la cantidad de muestras y las columnas la cantidad de obs en cada muestra
    float matrizMuestrascompRoja[m][n];
    float matrizMuestrascompVerde[m][n];
    float matrizMuestrascompAzul[m][n];
    
    //Defino vectores de SumacompXi y SumacompSi las cuales son la suma de las observaciones en cada muestra.
    //Para luego calcular la media de cada muestra y luego la sumatoria de dichas medias.
    float vectorSumacompRojaXi[m][1]; //Vector para la suma de cada componente, lo hago traspuesto para que qeude en concordancia con la matriz de datos
    float vectorSumacompRojaSi[m][1];
    float vectorSumacompVerdeXi[m][1];
    float vectorSumacompVerdeSi[m][1];
    float vectorSumacompAzulXi[m][1];
    float vectorSumacompAzulSi[m][1];

    float vectorMediasXiRoja[m][1]; //Vector para la media de cada muestra, como el vector suma/cant de obs.
    float vectorMediasXiVerde[m][1];
    float vectorMediasXiAzul[m][1];

    float vectorDesvSiRoja[m][1]; //Vector para la desviacion de cada muestra
    float vectorDesvSiVerde[m][1];
    float vectorDesvSiAzul[m][1];

    //Defino la Media de la Media y la Desviacion estandar promedio como escalares, a la vez que tambien defino la suma para obtener dichas variables
    float sumatotMediascompRoja=0;
    float sumatotMediascompVerde=0;
    float sumatotMediascompAzul=0;

    float sumatotDesvcompRoja=0;
    float sumatotDesvcompVerde=0;
    float sumatotDesvcompAzul=0;
    
    float mediaMediacompRoja=0;
    float mediaMediacompVerde=0;
    float mediaMediacompAzul=0;

    float desvPromcompRoja=0;
    float desvPromcompVerde=0;
    float desvPromcompAzul=0;
    
    //Calibración cubo Blanco
    
    //Pregunto si inicio la calibración del cubo
    while(estadoPulsadorSI==0)
      {
        Serial.print("Iniciar calibración del cubo blanco?");
        Serial.print('\n');
      }
     if(estadoPulsadorSI==1) //Si pulso botón SI, entonces inicio la calibración
      {
        cuboBlanco=1;
        contadorCalibracion=0;
        estadoPulsadorSI=0; //Reseteo el valor del estado del pulsador SI
      }

    while(cuboBlanco==1)
    {
       while(contadorCalibracion<duracionCalibracion && mm<=m-1)
              {
                Serial.print("Calibrando cubo blanco, adquiriendo muestra");
                Serial.print('\n');
                //Llamado de las funciones para leer el color
                lecturaColores();
                matrizMuestrascompRoja[mm][nn]=compRoja; //mm esta iniciado en 1, por lo cual guarda el valor en la primera posición cuando le resto 1
                matrizMuestrascompVerde[mm][nn]=compVerde;
                matrizMuestrascompAzul[mm][nn]=compAzul;
                nn++;
              }
         nn=0; //Reestablezco el valor de la cant de obs.

         Serial.print("ContadorCalibracion:  ");
         Serial.print(contadorCalibracion);
         Serial.print('\n');
         Serial.print("Duracion de calibracion:  ");
         Serial.print(duracionCalibracion);
         Serial.print('\n');
         Serial.print("Contador n:  ");
         Serial.print(n);
         Serial.print('\n');
         Serial.print("Contador mm:  ");
         Serial.print(mm);
         Serial.print('\n');
         Serial.print("Contador nn:  ");
         Serial.print(n);
         Serial.print('\n');

         
         //Pausa para preguntar cuando adquirir la nueva muestra, mientras no se pulse el botón SI y mientras mm no sea igual a m=3
         if(mm<m-1) //Entra cuando es cero, y cuando es uno. Pasa mm a 1 y a 2 respectivamente nada mas
          {
            while(estadoPulsadorSI==0)
              {
                Serial.print("Presionar botón SI para iniciar nueva muestra del cubo blanco");
                Serial.print('\n');
              }
            if(estadoPulsadorSI==1) //Si pulso boton SI, entonces vuelvo a leer el blanco
              {
                cuboBlanco=1;
                mm++; //Sumo uno a la cantidad de muestras
                contadorCalibracion=0;
                estadoPulsadorSI=0; //Reseteo el valor del estado del pulsador SI
              }
          }
         else if(mm>=m-1) //Termina la calibración del cubo blanco
          {
            cuboBlanco=0;
            mm=0; //Reestablezco el valor
            contadorCalibracion=0;//Reestablezco el valor
          }
    }

The problem is that the first 71 values or so in the first row of the matrix are ok, but afer that i get this:
0
-2147483648.0000
0
-2147483648.0000
2147483647.0000

and so on.

I don’t know anything about c++, I’m familiar with Matlab thats why im making a matrix.
The error has something to do with the memory that the arrays is taking? Or I’m not indexing properly?
How do I fix it?

Edit 1: I forgot to mention that the counter “nn” in this case is 241.
Edit 2: The function calibracion() dont finish there it uses the data on the matrix to calculate X and S of the sample, but the problem is that the matrix is already wrong, so i didn’t post everything.

Thanks.

You forgot to post your code.

Here is the rest of the code sorry. The 2 functions that are in the previuos post are in this code but it wont let me post in one.

#include<RTTamm.h>

//Definicion de pines del sensor
#define sensorS0 2 // S0 y S1 son los que definen la escala de la frecuencia que se va a utilizar 0%,2%,20% o 100% dependiendo de la combinaciion entre ellos 2
#define sensorS1 3
#define sensorS2 4 // S2 y S3 son los que definen el color que se quiere leer
#define sensorS3 5
#define sensorOE 6 // Se utiliza para habilitar fo, se activa en estado bajo
#define sensorOUT 7

//Definicion de intervalos para evitar rebote de pulsadores, estados y definicion de pines de los pulsadores
unsigned long previoMillis=0;
unsigned long intervaloRebote=300; //En mili segundos
#define pulsadorSI 9
#define pulsadorNO 10
int estadoPulsadorSI=0;
int estadoPulsadorNO=0;



//Inicio de los contadores y flags
int duracionCalibracion=0; //tiempo que tardara cada muestra
int contadorCalibracion=0;
int contadorActuacion=0;
volatile uint32_t FLAG_RTT=0;


//Estados de funcionamiento de la maquina
int estadoCalibracion=1; //Inicio en uno
int estadoOK=0;
int estadoParada=0;


//Inicializo las componentes RGB del color en cero, luego le asigno la frecuencia leida por el sensor
float compRoja=0;  
float compVerde=0;
float compAzul=0;

//Inicializo los limetes de las componentes RGB
float mayorRoja=0;
float menorRoja=100000;
float mayorVerde=0;
float menorVerde=100000;
float mayorAzul=0;
float menorAzul=100000;

//Inicializo los limites de cada componente RGB para cada cubo
//Cubo blanco
float limsupRojaBlanco=0;
float liminfRojaBlanco=0;
float limsupVerdeBlanco=0;
float liminfVerdeBlanco=0;
float limsupAzulBlanco=0;
float liminfAzulBlanco=0;

//Inicializo los errores entre lecturas para luego verificar el condicional
float errorCompRojaBlanco=0;
float errorCompVerdeBlanco=0;
float errorCompAzulBlanco=0;
float errorCompRojaRojo=0;
float errorCompVerdeRojo=0;
float errorCompAzulRojo=0;
float errorCompRojaVerde=0;
float errorCompVerdeVerde=0;
float errorCompAzulVerde=0;

//Cubo Rojo
float limsupRojaRojo=0;
float liminfRojaRojo=0;
float limsupVerdeRojo=0;
float liminfVerdeRojo=0;
float limsupAzulRojo=0;
float liminfAzulRojo=0;

//Cubo Verde
float limsupRojaVerde=0;
float liminfRojaVerde=0;
float limsupVerdeVerde=0;
float liminfVerdeVerde=0;
float limsupAzulVerde=0;
float liminfAzulVerde=0;

//Variables para el sensor
float colorLeido=0;


//Pines de LEDS solo para la prueba
#define pinLedBlanco 11
#define pinLedRojo 12
#define pinLedVerde 13

void setup() {
  //Definicion de los pines de leds solo para la prueba luego sacalo
  pinMode(pinLedBlanco,OUTPUT);
  digitalWrite(pinLedBlanco,LOW);
  pinMode(pinLedRojo,OUTPUT);
  digitalWrite(pinLedRojo,LOW);
  pinMode(pinLedVerde,OUTPUT);
  digitalWrite(pinLedVerde,LOW);
  
  
  
  //Definicion de los pines de los pulsadores SI y NO como interrupciones
  attachInterrupt(pulsadorSI,handler_pulsadorSI,RISING);
  attachInterrupt(pulsadorNO,handler_pulsadorNO,RISING);
  
  //Sensor de color
  //Pines
  pinMode(sensorS0,OUTPUT);
  pinMode(sensorS1,OUTPUT);
  pinMode(sensorS2,OUTPUT);
  pinMode(sensorS3,OUTPUT);
  pinMode(sensorOE,OUTPUT);
  digitalWrite(sensorOE,LOW); //Me aseguro que este en estado bajo, es decir activado
  pinMode(sensorOUT,INPUT);

  //Escala de frecuencia
  /*
   * S0 |  S1 | Escala
   * L  |  L  |   Power Down
   * L  |  H  |   2%
   * H  |  L  |   20%
   * H  |  H  |   100%
   */
  // Seteo la escala de frecuencia al 20%, ya que es la que mejores resultados arroja.
  digitalWrite(sensorS0,HIGH);
  digitalWrite(sensorS1,LOW);
  


  //Configuracion tiempo del RTT en ms
  configuraRTT(100);
  duracionCalibracion=30; //La duracion de calibracion, es cuantas veces entra el contador de RTT en este caso 30*100ms=3s
  

  //Inicializacion del puerto serie
  Serial.begin(9600);



}

void loop() {

  //Analizo los estados para saber en cual me encuentro y deacuerdo a ello ejecutar el programa
  if(estadoCalibracion==1)
  {
    calibracion(); 
  }

void RTT_Handler()
{
contadorCalibracion++; //Contador para determinar el tiempo que le quiero dar a la calibracion
contadorActuacion++; //Contador para determinar el tiempo que quiero que tarde en actuar el piston luego de la lectura del sensor

restableceRTT();
}




void handler_pulsadorSI (void)
{
  static unsigned long tiempo_desde_ultimaInterrupcionSI=0;
  unsigned long interrupt_timeSI = millis();
  if (interrupt_timeSI - tiempo_desde_ultimaInterrupcionSI > intervaloRebote) 
  {
    estadoPulsadorSI=1;
    estadoPulsadorNO=0;
  }
  tiempo_desde_ultimaInterrupcionSI = interrupt_timeSI;
}

void handler_pulsadorNO (void)
{
  static unsigned long tiempo_desde_ultimaInterrupcionNO=0;
  unsigned long interrupt_timeNO = millis();
  if (interrupt_timeNO - tiempo_desde_ultimaInterrupcionNO > intervaloRebote) 
  {
    estadoPulsadorNO=1;
    estadoPulsadorSI=0;
  }
  tiempo_desde_ultimaInterrupcionNO = interrupt_timeNO;
}

Library Manager doesn't have any libraries with RTT in the name or description. Where did you get the library?

johnwasser:
Library Manager doesn't have any libraries with RTT in the name or description. Where did you get the library?

Its a custom library that was provided at the university where I study, it's a real time timer (RTT) to avoid using the delay.