(AT) Mega Enigma, a 2560 Pro Mini Enigma Simulator

Description

Have been wanting for a while to make an Enigma Machine simulator using 16 segment displays, leds for the lampfield and pushbuttons for the keys, Problem was, did not know about a compact Arduino development board with sufficient IO to support all those devices. The 2560 Pro Mini changed that.

The goal of this project is to make a small full featured enigma simulator kit that's easy to put together and uses a minumum of parts.

Project Logs

Collapse logs

What's the most efficient way to print things

Arduino Enigma • 10/10/2019 at 04:06 • 0 comments

We are at a stage of the project where things are getting standardized and optimized. The program needs to print a space every once in a while to separate groups of characters, as well as send the CR LF sequence to start printing things in a new line. We are curious what is the best way to do that.

Let's start by saying that the most efficient way to print strings is to wrap them in the F("") macro. This keeps the string in PROGMEM, otherwise the string is stored in PROGMEM, then at runtime it is copied to precious RAM before printing and it is possible to run out of RAM if the sketch uses a lots of strings.

Example:

Serial.print(F("HELLO WORLD"));  // DO THIS, 18 bytes code, 0 bytes ram

don't do this:

Serial.print("HELLO WORLD"); // DON'T DO THIS, 26 bytes code, 12 bytes ram

Now, what what is the most efficient way to print a single space to separate two characters printed elsewhere? How about a newline / CR LF sequence?

The sketch below was created to test different ways to print a space and a new line in between the A and B letters.

First a very basic sketch was created and compiled. The program size and ram usage were recorded.

void testSerialSpace()     /*xls*/
{
  Serial.begin(9600);
  Serial.print(F("A"));
  Serial.print(F("B"));
}

void setup()
{
  testSerialSpace();
}

void loop()
{
}

Then different ways to print a space and a new line were added, one at a time and the memory usage was obtained by subtracting it from the baseline program.

The moral of the story is that the most efficient way to print a space is simply:

Serial.print(F(" ")); // adds 8 bytes code, 0 ram

Things got a little more surprising in the newline department.

The obvious and wrong choice would be to print an empty string using the F("") macro.

Serial.println(F("")); // adds 26 bytes code and 4 bytes ram

But this added a whopping 26 bytes of code and 4 bytes of ram. Not sure why.

After trying different combinations the most efficient way to send a newline is to do a regular print, not a println and send a hex escaped string with the CR LF sequence

Serial.print(F("\x0d\x0a"));    // adds 10 bytes code and 0 bytes ram

This result was a little unexpected. but now we know.

The full results are listed below, ranking from most efficient to least efficient. The strings printed without F("") are at the bottom of the list, with the absolute worst ways to send a single new line clocking at 40 bytes of code and 4 bytes of RAM.

//
// moral of the story:
// to print a space, use Serial.print(F(" "));
// to print a newline, use Serial.print(F("\x0d\x0a"));
//
//  Only prints AB
//  Sketch uses 1,794 bytes (0%) of program storage space. Maximum is 253,952 bytes.
//  Global variables use 182 bytes (2%) of dynamic memory, leaving 8,010 bytes for local variables. Maximum is 8,192 bytes.
//
//  Serial.print(F("HELLO WORLD"));
//  Sketch uses 1,812 bytes (0%) of program storage space. Maximum is 253,952 bytes.
//  Global variables use 182 bytes (2%) of dynamic memory, leaving 8,010 bytes for local variables. Maximum is 8,192 bytes.
//
//  Serial.print("HELLO WORLD");
//  Sketch uses 1,820 bytes (0%) of program storage space. Maximum is 253,952 bytes.
//  Global variables use 194 bytes (2%) of dynamic memory, leaving 7,998 bytes for local variables. Maximum is 8,192 bytes.
//
//  Serial.print(F(" "));
//  Sketch uses 1,802 bytes (0%) of program storage space. Maximum is 253,952 bytes.
//  Global variables use 182 bytes (2%) of dynamic memory, leaving 8,010 bytes for local variables. Maximum is 8,192 bytes.
//
//  Serial.print(F("\x0d\x0a"));
//  Sketch uses 1,804 bytes (0%) of program storage space. Maximum is 253,952 bytes.
//  Global variables use 182 bytes (2%) of dynamic memory, leaving 8,010 bytes for local variables. Maximum is 8,192 bytes.
//
//  Serial.print(" ");
//  Sketch uses 1,810 bytes (0%) of program storage space. Maximum is 253,952 bytes.
//  Global variables use 184 bytes (2%) of dynamic memory, leaving 8,008 bytes for local variables. Maximum is 8,192 bytes.
//
// Serial.print(...