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

También tuve un problema similar a este, y estoy muy seguro de que el tuyo tampoco está relacionado con el espacio de pila. Intente reducir el código tanto como sea posible.

En mi caso, el código a veces se ejecutaba cuando tenía un mensaje serial, pero parece que no se ejecuta cuando no lo hice. También tuve un caso en el que enviar mensajes en serie causaría que el arduino se reiniciara sin cesar.

También estaba usando un arduino328. Probablemente debería reducir el tamaño de su matriz si tiene alguno al tamaño más pequeño que sea aceptable.

¿Tu código inicializa el puerto serie? Por ejemplo.

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

Si no lo hace, podría producirse un bloqueo al utilizar por primera vez la serie.

¿Quizás te estás quedando sin memoria? Todas las cadenas que imprime con Serial.print ("algo") tienen lugar en la SRAM, igual al número de caracteres de esa cadena + 1 para el terminador \ 0. Es posible que se quede sin memoria incluso si el tamaño compilado de su boceto es mucho más pequeño que la memoria flash de Arduino, ya que SRAM solo tiene 2048 bytes para Atmega328 y 1024 bytes para Atmega 168. Tuve un problema similar, que resolví acortando todo Textos y eliminación de mensajes de depuración innecesarios.

No ha mostrado el código que inicializa la variable "loop_counter". ¿Está eso fuera de la rutina loop () ?

¿Es posible que haya declarado eso de manera que sea adyacente a otra área de almacenamiento de memoria que esté operando fuera de su tamaño declarado y que esté pisando la variable loop_counter?

No veo en tu código a dónde llamas 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 quiere que retenga su valor entre llamadas. Podría hacer esto con una variable local estática .

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 pisotearlo. Siempre debe declarar sus 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. Verifique este EE.SE Q & A para varios ejemplos de código para hacer esto dentro de un Arduino.

La biblioteca serial del software Arduino usa interrupciones. (vea "softwareSerial.cpp, .h"). Es posible que tenga un problema en el que el ISR esté "pisando" el código principal (o viceversa). Intente usar indicadores de bloqueo, de modo que el código espere mientras se completan las operaciones de impresión.

Hace un tiempo, hace un tiempo tuve la impresión de tener el mismo problema. En aquel entonces, lo resolví agregando un retraso (1) delante o después del serial.println. Eso fue con Arduino 0022 en Linux. No estoy seguro de qué placa era, probablemente una serie de Boarduino. Tampoco puedo reproducirlo.

Actualmente, me funciona en un dispositivo USB con Arduino 1.01 en Windows:

int loop_counter = 0;
int led = 13;

void setup() {
  Serial.begin(9600);
  pinMode(led, OUTPUT);}

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

    Serial.println(loop_counter);

    if(loop_counter == 0) {
      Serial.println("hey hey orange, hey hey!");
    }      
}