Arduino Serial print changes behavior of program undesireably

Question

I'm using a loop counter, declared in a header:

int loop_counter = 0;

I use this counter to trigger an event every so often. I used to use a modulo for this same type of behavior, but I simplified it so it's easier to work with (it still results in the same behavior)

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

    //Serial.println("hey");

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

All is well and good, until I try communicating with Serial by uncommenting the //Serial.println("hey"); ("hey" in this example because, to me, this behavior is absurd).

This results in loop_counter never triggering the do_something_important(); section of code. I tried declaring loop_counter as volatile, that didn't change anything. I tried Serial.print ing loop_counter, and I was also getting odd behavior (it would freeze the loop). Serial.println("hey"); works in the sense that in the Serial monitor I get plenty of "hey", (i.e. quickly a lot more than 100 "heys", the number of iterations at which the other section of code should trigger)

What could possibly be causing the usage of Serial, with data that is not (as far as I can tell) tied to loop_counter completely prevent it from working properly?

EDIT: Here is the part of the main file that ended up posing the problem (well, contributing the most to it (using too much memory)):

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

Here is "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;
short led_matrix[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];
    #endif

Some more information: - I'm using an Uno (ATMega328)

Answer 1

I also had a similar problem to this, and am very sure that yours is also out of stack space related. Try shrinking the code as much as possible.

In my case code would sometimes run when I had a serial message in it, but then it would seem to not run when I did not. I also had a case where sending serial messages would cause the arduino to reset endlessly.

I was also using an arduino328. Likely you should reduce the size of your array if you have any to the smallest size that is acceptable.

Answer 2

Does your code initialise the serial port? Eg.

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

Failing to do this could result in a crash on first use of the serial.

Answer 3

Maybe you're running out of memory? All strings you print with Serial.print("something") take place in SRAM, equal to the number of characters of that string + 1 for the \0 terminator. It is possible to run out of memory even if your sketch's compiled size is much smaller than the Arduino flash memory, because SRAM is only 2048 bytes for Atmega328 and 1024 bytes for Atmega 168. I had a similar problem, which I solved by shortening all texts and removing unnecessary debug messages.

Answer 4

You have not shown the code that initializes the variable "loop_counter". Is that outside the loop() routine?

Do you possibly have that declared in a way that it is adjacent to another memory storage area that is operating outside its declared size and this tromping on the loop_counter variable?

Answer 5

I don't see in your code where you're calling loop(). It also doesn't look like you're using loop_counter outside that function. Is there a reason you're declaring it global? I'm assuming it's because you want it to retain it's value in between calls. You could do this with a static local variable instead.

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

That should make sure that no other external functions can stomp on it. You should always declare your variables in the smallest scope possible to avoid unwanted behavior.

If that doesn't work, you will need to really analyze your memory usage. Check this EE.SE Q&A for various sample code to do this within an Arduino.

Answer 6

The Arduino software serial library uses interrupts. (see "softwareSerial.cpp, .h"). You may have an issue where the ISR is "stepping" on the main code (or vice- versa). Try using interlock flags, so that the code waits while the print operations complete.

Answer 7

At one point some time ago I had the impression of having the same problem. Back then, I solved it by adding a delay (1) in front or after the serial.println. That was with Arduino 0022 on Linux. Not sure which board it was, probably a Boarduino serial. Cant reproduce it either.

Currently, it works for me on a boarduino USB with Arduino 1.01 on 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!");
    }      
}