La impresión en serie de Arduino cambia el comportamiento del programa de forma no deseada

Question

Estoy usando un contador de bucle, declarado en una cabecera:

int loop_counter = 0;

Utilizo este contador para activar un evento cada cierto tiempo. Solía usar un módulo para este mismo tipo de comportamiento, pero lo simplifiqué para que sea más fácil trabajar con él (sigue dando como resultado el mismo comportamiento)

void loop() {
    if(loop_counter > 100) loop_counter = 0;
    else loop_counter++;

    //Serial.println("hey");

    if(loop_counter == 0) {
         //do_something_important();
    }      
}

Todo va bien, hasta que intento comunicarme con Serial descomentando el //Serial.println("hey"); ( "hey" en este ejemplo porque, para mí, este comportamiento es absurdo).

Esto da lugar a loop_counter Nunca se activa el do_something_important(); sección de código. He probado a declarar loop_counter como volatile eso no cambió nada. Intenté Serial.print en loop_counter Y también estaba obteniendo un comportamiento impar (se congelaba el bucle). Serial.println("hey"); funciona en el sentido de que en el monitor Serial obtengo un montón de "hey", (es decir, rápidamente mucho más de 100 "heys", el número de iteraciones en el que la otra sección de código debe disparar)

¿Qué podría estar causando el uso de Serial con datos que no están (hasta donde yo sé) vinculados a loop_counter ¿Impedir por completo que funcione correctamente?

EDITAR : Aquí está la parte del archivo principal que terminó planteando el problema (bueno, contribuyendo al máximo a él (usando demasiada memoria)):

void display_state() {
  int i,j,index=0;
  short alive[256][2];

 for(i=0;i<num_rows;i++) { 
   for(j=0;j<num_cols;j++) {
     if(led_matrix[i][j]==1) { 
       alive[index][0]=i;
       alive[index][1]=j;
       index++;
     }
   }
 }
 alive[index][0]=NULL; //Null-terminate.
 alive[index][1]=NULL;

 //383 is a great number
 for(int idx=0;idx < index; idx++) {
   display(alive[idx][0],alive[idx][1]);
   delayMicroseconds(283);
 }
}

Aquí está "letters.h":

    #ifndef _MY_LETTERS_H
    #define _MY_LETTERS_H

Algo más de información: - Estoy usando un Uno (ATMega328)

Answer 1

¿Su código inicializa el puerto serie? Ej.

void setup()
{
    Serial.begin(9600);
}

Si no se hace esto, podría producirse un fallo en el primer uso de la serie.

Answer 2

¿Quizás te estás quedando sin memoria? Todas las cadenas que imprimes con Serial.print("algo") tienen lugar en la SRAM, igual al número de caracteres de esa cadena + 1 para el \0 terminador. Es posible quedarse sin memoria incluso si el tamaño compilado de tu sketch es mucho menor que la memoria flash del Arduino, porque la SRAM es de sólo 2048 bytes para el Atmega328 y 1024 bytes para el Atmega 168. Yo tuve un problema similar, que resolví acortando todos los textos y eliminando los mensajes de depuración innecesarios.

Answer 3

Yo también tuve un problema similar a este, y estoy muy seguro de que el tuyo también está relacionado con el espacio de la pila. Intenta reducir el código lo máximo posible.

En mi caso el código a veces se ejecutaba cuando tenía un mensaje serial, pero luego parecía no ejecutarse cuando no lo tenía. También tuve un caso en el que el envío de mensajes en serie hacía que el arduino se reiniciara sin parar.

También estaba usando un arduino328. Probablemente deberías reducir el tamaño de tu matriz si tienes alguna al tamaño más pequeño que sea aceptable.

Answer 4

No has mostrado el código que inicializa la variable "loop_counter". ¿Es eso fuera del bucle() ¿Rutina?

¿Es posible que haya declarado que es adyacente a otra área de almacenamiento de memoria que está operando fuera de su tamaño declarado y este tromping en la variable loop_counter?

Answer 5

No veo en tu código dónde estás llamando a loop() . Tampoco parece que estés usando loop_counter fuera de esa función. ¿Hay alguna razón por la que lo declaras global? Supongo que es porque quieres que conserve su valor entre llamadas. Usted podría hacer esto con un variable local estática en su lugar.

void loop() {
    static int loop_counter = 0;

    if(loop_counter > 100)
    {
        loop_counter = 0;
    }
    else
    {
        loop_counter++;
    }

    Serial.println("hey");

    if(loop_counter == 0)
    {
         //do_something_important();
    }      
}

Eso debería asegurar que ninguna otra función externa pueda pisotearla. Siempre debes declarar tus variables en el ámbito más pequeño posible para evitar comportamientos no deseados.

Si eso no funciona, tendrá que analizar realmente el uso de la memoria. Compruebe esta pregunta de EE.SE para ver varios ejemplos de código para hacer esto dentro de un Arduino.