Hackaday.io Hackaday.io
Projects
Recently Updated Most Likes Newest Project Lists
Discover Contests Courses Stack
More
Courses Tutorials Events Hackerspaces Profiles Hackaday.com Tindie Marketplace
Sign up Log in
Close
0%
0%

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

A minimalist 139x171x50mm Enigma Machine Simulator with working plugboard using an ATmega 2560 Pro Mini and a custom PCB.

Arduino EnigmaArduino Enigma
Following Follow project
Liked Like project

Become a Hackaday.io member

Not a member? You should Sign Up.

Already have an account? Log In.

Sign up with Github
Sign up with Twitter
OR
Forgot your password?

Just one more thing

To make the experience fit your profile, pick a username and tell us what interests you.

Pick an awesome username
hackaday.io/
Your profile's URL: hackaday.io/username. Max 25 alphanumeric characters.
Pick a few interests
Projects that share your interests
People that share your interests

We found and based on your interests.

Choose more interests.

OK, I'm done! Skip
Join this project
Similar projects worth following
5.3k views
0 comments
34 followers
32 likes
  • Description
  • Details
  • Files 2
    • View all
  • Components 0
  • Logs 25
    • View all
  • Instructions 0
  • Discussion 0
  • Hackaday Prize 2019
View Gallery
5.3k
0
34
32

Team (1)

  • Arduino EnigmaArduino Enigma

Join this project's team
  • Project Blog
  • GitLab Page
hardware
ongoing project
2019hackadayprize

This project is submitted for

  • Hackaday Prize 2019

This project was created on 05/13/2019 and last updated 4 months ago.

Starting from
$500.00
Buy on Tindie
ArduinoEnigma has 105 orders / 10 reviews
Ships from United States of America

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.

Files

aa-battery-system-ponoko.svg

All the pieces needed to add an AA battery compartment to a laser cut enclosure.

svg+xml - 808.48 kB - 01/14/2020 at 01:42

Download

aaa-battery-system-ponoko.svg

All the pieces needed to add an AAA battery compartment to a laser cut enclosure

svg+xml - 798.00 kB - 01/14/2020 at 01:42

Download

Project Logs
Collapse logs

  • UHR Switch for MegaEnigma

    Arduino Enigma • 10/31/2020 at 14:50 • 0 comments

    An external UHR Switch attachment has been developed for Mega Enigma

    UHRSwitch page:

    https://arduinoenigma.blogspot.com/p/uhrswitch-uhr-switch-for-megaenigma.html

    BOM:

    https://arduinoenigma.blogspot.com/2020/10/uhr-switch-bill-of-materials-bom.html

    Theory of Operation:

    https://arduinoenigma.blogspot.com/2020/05/designing-uhr-switch-for-arduino-based.html

  • What could this be???

    Arduino Enigma • 07/13/2020 at 17:07 • 1 comment

  • The whole family

    Arduino Enigma • 05/25/2020 at 22:55 • 0 comments

    And finally, here is a picture of completed units:

    Enigma Uno:

    https://www.tindie.com/products/arduinoenigma/arduino-enigma-i-m3-m4-machine-simulator-w-case/

    NanoEnigma:

    https://www.ebay.com/itm/114230592101

    PicoEnigma:

    https://www.ebay.com/itm/114219267074

    https://www.tindie.com/products/arduinoenigma/picoenigma-a-universal-enigma-machine-simulator/

  • This project has been shrunk to 88x98mm

    Arduino Enigma • 03/29/2020 at 04:00 • 0 comments

    Introducing PicoEnigma. 

    Runs the same Universal Enigma Machine Simulator as MegaEnigma, but with a slightly changed IO Layer owing to its 14 segment displays.

    https://arduinoenigma.blogspot.com/p/picoenigma.html

  • A new little something

    Arduino Enigma • 02/26/2020 at 06:02 • 0 comments

    https://www.instagram.com/p/B85ozf_n5kQ/

  • Putting Batteries Inside a Laser Cut Enclosure

    Arduino Enigma • 01/14/2020 at 05:16 • 0 comments

    To put batteries inside a laser cut enclosure, one has to think in 3D using 2D:

    The pictures in this article will show how:

    https://arduinoenigma.blogspot.com/2020/01/how-to-put-battery-compartment-inside.html

    And now that there is a built in battery compartment, then the question of how long will it run on batteries becomes more important.

    The following article shows a method of measuring run-time by writing timing checkpoints to EEPROM, no external components needed.

    https://arduinoenigma.blogspot.com/2020/01/measuring-battery-run-time-by-writing.html

  • How to use Sketchup to design complex PCB shapes for Fritzing

    Arduino Enigma • 10/26/2019 at 17:40 • 0 comments

    https://arduinoenigma.blogspot.com/2019/10/get-your-head-out-of-clouds-and-design.html

  • Added menu to edit UKWD

    Arduino Enigma • 10/22/2019 at 04:38 • 0 comments

    This simulator already had 5 UKWD rewirable reflectors, 4 were available to be used with the M3 machine, the other with the KD. The D reflector wiring can be changed in the field. The 5 reflectors included are examples of known wirings used at some point in time.A mechanism was needed to change the actual wiring of the reflector in this simulator.

    Adding an item now to the menu system is easier than developing it from scratch. It is just a matter of inserting an item in the existing menu system. The UKWD sub menu has two special features, it is skipped if the currently selected machine did not have a D reflector, and the user cannot leave that menu until the pairs specified are correct.

    Read more here:

    https://arduinoenigma.blogspot.com/2019/10/ukwd-added-to-mega-enigma-universal.html

  • 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(...
    Read more »

  • RC1 (release candidate 1)

    Arduino Enigma • 10/03/2019 at 05:34 • 0 comments

    Feature complete and code complete.  No apparent glitches. Testing time...

    https://gitlab.com/arduinoenigma/megaenigma

    http://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v25_en.html

View all 25 project logs

Enjoy this project?

Share

Discussions

Log In/Sign up to comment

Become a Hackaday.io Member

Create an account to leave a comment. Already have an account? Log In.

Sign up with Github
Sign up with Twitter
OR

Similar Projects

BASIC interpreter for the Arduino. Inspired by the Woz's Integer BASIC.
Project Owner Contributor

blinkyBasic

Bob BurnsBob Burns

ATtiny84-based gamed of life on 8x8 LED matrix with manual setup of 1st generation.
Project Owner Contributor

Conway's Game of Life on ATtiny84

Jean-François PoilpretJean-François Poilpret

An iambic paddle controller for sending Morse code.
Project Owner Contributor

1Keyer

Mark VandeWetteringMark VandeWettering

Pavapro is tiny programmer you can bring anywhere. You can load binary file into it and bring/use it as you wish. And a bit more than that.
Project Owner Contributor

Pavapro - portable AVR programmer

jaromir.sukubajaromir.sukuba

Does this project spark your interest?

Become a member to follow this project and never miss any updates

Going up?

About Us Contact Hackaday.io Give Feedback Terms of Use Privacy Policy Hackaday API

© 2021 Hackaday

Yes, delete it Cancel

Report project as inappropriate

You are about to report the project "(AT) Mega Enigma, a 2560 Pro Mini Enigma Simulator", please tell us the reason.

Send message

Your application has been submitted.

Remove Member

Are you sure you want to remove yourself as a member for this project?

Project owner will be notified upon removal.