A impressão serial do Arduino altera o comportamento do programa de maneira indesejável

Estou usando um contador de loop, declarado em um cabeçalho:

int loop_counter = 0;

Eu uso esse contador para acionar um evento de vez em quando. Eu costumava usar um módulo para esse mesmo tipo de comportamento, mas simplifiquei para facilitar o trabalho (ainda resulta no mesmo comportamento)

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

    //Serial.println("hey");

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

Tudo está bem, até que eu tente me comunicar Serialdescomentando o //Serial.println("hey"); ( "hey"neste exemplo, porque, para mim, esse comportamento é absurdo).

Isso resulta em loop_counternunca acionar a do_something_important();seção do código. Eu tentei declarar loop_countercomo volatile, isso não muda nada. Tentei Serial.printing loop_counter, e eu também estava ficando comportamento estranho (ele iria congelar o loop). Serial.println("hey");funciona no sentido de que, no monitor serial, recebo bastante "ei", (ou seja, rapidamente, muito mais do que 100 "ei", o número de iterações nas quais a outra seção do código deve ser acionada)

O que poderia estar causando o uso de Serial, com dados que não estão (até onde eu saiba) vinculados para loop_counterimpedir completamente que funcionem corretamente?

EDIT : Aqui está a parte do arquivo principal que acabou apresentando o problema (bem, contribuindo mais para ele (usando muita memória)):

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);
 }
}

Aqui está "letters.h":

    #ifndef _MY_LETTERS_H
    #define _MY_LETTERS_H


#define nrows 4
#define ncols 4

#define num_rows 16
#define num_cols 16

#define MAX_WORD_LENGTH 16
#define NUMBER_OF_CHARACTERS 26

#include <stdlib.h>


int loop_counter = 0 ; led_matrix curto [ num_rows ] [ num_cols ]; 


const short letter_a [ nrows ] [ ncols ] = {{ 0 , 1 , 1 , 0 }, { 1 , 0 , 0 , 1 }, { 1 , 1 , 1 , 1 }, { 1 , 0 , 0 , 1 } }; const short letter_b [ nrows ] [ ncols ] = {{ 1 ,   
                    
                    
                    
   0 , 0 , 0 }, { 1 , 1 , 1 , 0 }, { 1 , 0 , 1 , 0 }, { 1 , 1 , 1 , 0 }}; const short letter_c [ nrows ] [ ncols ] = {{ 0 , 1 , 1 , 1 }, { 1 , 0 , 0 , 0 }, { 1 ,
   0 , 0 , 0 }, { 0 , 1 , 1 , 1 }}; const short letter_t [ nrows ] [ ncols ] = {{ 1 , 1 , 1 , 1 }, { 0 , 1 , 0 , 0 }, { 0 , 1 , 0 , 0 }, { 0 , 1 , 0 , 0 } };
    


typedef struct letter_node { const short * data ; 
  letter_node * next ; int x ; int y ; } letter_node ; 
    
  
  


letter_node aa = {&letter_a[0][0],NULL,1,1};
letter_node bb = {&letter_b[0][0],NULL,1,1};
letter_node cc = {&letter_c[0][0],NULL,1,1};
letter_node tt = {&letter_t[0][0], NULL , 1 , 1 };


letter_node letter_map [ NUMBER_OF_CHARACTERS ]; #fim se
    

Mais algumas informações: - Estou usando um Uno (ATMega328)

Eu também tive um problema semelhante a isso e tenho certeza de que o seu também está sem espaço em pilha. Tente reduzir o código o máximo possível.

No meu caso, o código algumas vezes era executado quando eu tinha uma mensagem serial, mas depois parecia não ser executado quando não era. Também tive um caso em que o envio de mensagens seriais faria com que o arduino fosse redefinido infinitamente.

Eu também estava usando um arduino328. Provavelmente, você deve reduzir o tamanho da sua matriz, se tiver algum tamanho aceitável.

Seu código inicializa a porta serial? Por exemplo.

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

Não fazer isso pode resultar em uma falha no primeiro uso da série.

Talvez você esteja ficando sem memória? Todas as seqüências impressas com Serial.print ("something") ocorrem na SRAM, igual ao número de caracteres dessa sequência + 1 para o terminador \ 0. É possível ficar sem memória mesmo que o tamanho compilado do seu esboço seja muito menor que a memória flash do Arduino, porque a SRAM tem apenas 2048 bytes para o Atmega328 e 1024 bytes para o Atmega 168. Eu tive um problema semelhante, que resolvi encurtando tudo textos e remover mensagens de depuração desnecessárias.

Você não mostrou o código que inicializa a variável "loop_counter". Isso está fora da rotina loop () ?

Você pode declarar isso de maneira que seja adjacente a outra área de armazenamento de memória que esteja operando fora do tamanho declarado e esta pisando na variável loop_counter?

Não vejo no seu código para onde você está ligando loop(). Também não parece que você esteja usando loop_counterfora dessa função. Existe uma razão para você declarar global? Presumo que seja porque você deseja que ele retenha seu valor entre as chamadas. Você poderia fazer isso com uma variável 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();
    }      
}

Isso deve garantir que nenhuma outra função externa possa pisar nela. Você sempre deve declarar suas variáveis ​​no menor escopo possível para evitar comportamentos indesejados.

Se isso não funcionar, você precisará realmente analisar seu uso de memória. Verifique estas perguntas e respostas do EE.SE para obter vários códigos de amostra para fazer isso em um Arduino.

A biblioteca serial do software Arduino usa interrupções. (consulte "softwareSerial.cpp, .h"). Você pode ter um problema em que o ISR está "pisando" no código principal (ou vice-versa). Tente usar sinalizadores de intertravamento, para que o código aguarde enquanto as operações de impressão são concluídas.

A certa altura, tive a impressão de ter o mesmo problema. Naquela época, resolvi adicionando um atraso (1) na frente ou depois do serial.println. Isso foi com o Arduino 0022 no Linux. Não tenho certeza de qual placa era, provavelmente uma série do Boarduino. Também não é possível reproduzi-lo.

Atualmente, ele funciona para mim em um boarduino USB com Arduino 1.01 no 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!");
    }      
}