Moore machine with two states (red and green), initialised in the red state. Looped arrows indicate idle non-transition.<\/figcaption><\/figure><\/div>\n\n\n\nThe machine starts in the red-light state. It remains there, unless the button is pressed. Then, it instantly switches to green (a pedestrian’s dream) where it remains until the button is pressed again.<\/p>\n\n\n\n
This behaviour can be implemented by putting a simple switch case<\/kbd> statement in the main loop()<\/kbd> and implementing a state variable:<\/p>\n\n\n\n\/\/ States\nenum states{ ST_R,\n ST_G\n }\n\nvoid setState(bool red, bool green) {\n digitalWrite(LED_RED, red ? HIGH : LOW);\n digitalWrite(LED_GREEN, green ? HIGH : LOW);\n}\n\nvoid setRed() { setState(true, false); }\nvoid setGreen() { setState(false, true); }\n\nvoid loop() {\n switch(machineState) {\n case ST_R:\n \/\/ Serial.write(\"State: Red\");\n setRed();\n break;\n case ST_G:\n \/\/ Serial.write(\"State: Green\");\n setGreen();\n break;\n}<\/code><\/pre>\n\n\n\nWhy use this enum<\/kbd> thingy, you say? You could just use an int and call your states 0, 1, 2<\/kbd>, etc., you say? Yes, you could also sign up for the biannual global brainfuck contest.<\/p>\n\n\n\nBut, hey, wait, there are no transitions!<\/p>\n\n\n\n
Exactly! For that purpose I’ll use an interrupt.<\/p>\n\n\n\nJust add one more function:<\/p>\n\n\n\n
void ISR_ButtonToggle() {\n Serial.write(\"BUUUUTTON!\\n\");\n if(machineState == ST_R) {\n machineState = ST_G;\n } else if (machineState == ST_G) {\n machineState = ST_R;\n }\n}<\/code><\/pre>\n\n\n\nAnd don’t forget to actually bind the interrupt function in setup()<\/kbd>:<\/p>\n\n\n\nattachInterrupt(digitalPinToInterrupt(BUTTON), ISR_ButtonToggle, FALLING);<\/code><\/pre>\n\n\n\nNow that’s a simple and pretty useless traffic light (well, I still like that I can switch it to green at will, this really should be the default pedestrian crossing light!).<\/p>\n\n\n\n
But it is easy to extend. You want a yellow state? Add a yellow state ST_Y<\/kbd> to your state machine (the switch case<\/kbd> statement). Or you want it to show yellow before switching from green to red? Add a yellow-before-red state ST_Y_R<\/kbd>. Or you really like to let people wait? Add a wait state. Oh, and of course you can call your states whatever you want.<\/p>\n\n\n\nHere is my full implementation of a non-pedestrian red-yellow-green traffic light as it is stated in the German traffic rules:<\/p>\n\n\n\n
From red to green, with wait periods, go throughRed<\/li> Red+Yellow (yes, red+yellow, yellow meaning “get ready” and red meaning “not too fast, it’s still red, Freundchen!”)<\/li> Green<\/li><\/ul><\/li> From green to red, with wait periods, go throughGreen<\/li> Yellow (yes, only yellow. The meaning is disputed. Reasonable people say it means “Prepare to stop, if you can’t make it in time, it’s okay.” while idiots say it means “STEP ON THE GAS!”)<\/li> Red (This is also sometimes disputed, I won’t go into this.)<\/li><\/ul><\/li><\/ul>\n\n\n\n#include <Arduino.h>\n\n#define BAUDRATE 9600\n#define BUTTON DD2\n#define LED_RED DD3\n#define LED_YELLOW DD4\n#define LED_GREEN DD5\n\n\/\/ Transition delays\n#define BLINK_WAIT 7\n#define DELAY_R_RY 250\n#define DELAY_RY_G 250\n#define DELAY_G_Y 250\n#define DELAY_Y_R 250\n#define DELAY_R_G 250\n#define DELAY_G_R 250\n\n\/\/ States\nenum states{ ST_R,\n ST_RY,\n ST_G,\n ST_Y,\n WAIT_R_RY,\n WAIT_RY_G,\n WAIT_G_Y,\n WAIT_Y_R,\n WAIT_G_R,\n WAIT_R_G };\n\nstates machineState = ST_R;\nbool builtin_led = false;\n\nvoid setState(bool red, bool yellow, bool green) {\n digitalWrite(LED_RED, red ? HIGH : LOW);\n digitalWrite(LED_YELLOW, yellow ? HIGH : LOW);\n digitalWrite(LED_GREEN, green ? HIGH : LOW);\n}\n\nvoid setRed() { setState(true, false, false); }\nvoid setRedYellow() { setState(true, true, false); }\nvoid setYellow() { setState(false, true, false); }\nvoid setGreen() { setState(false, false, true); }\n\nvoid blinkDelay(int delay_ms) {\n for(int i=0; i<BLINK_WAIT; i++){\n delay(delay_ms);\n digitalWrite(LED_BUILTIN, builtin_led);\n Serial.write(\".\");\n builtin_led = !builtin_led;\n }\n Serial.write(\"\\n\");\n}\n\nvoid ISR_ButtonToggle() {\n Serial.write(\"BUUUUTTON!\\n\");\n if(machineState == ST_R) {\n machineState = WAIT_R_RY;\n } else if (machineState == ST_G) {\n machineState = WAIT_G_Y;\n }\n}\n\nvoid setup() {\n pinMode(LED_BUILTIN, OUTPUT);\n pinMode(LED_RED, OUTPUT);\n pinMode(LED_YELLOW, OUTPUT);\n pinMode(LED_GREEN, OUTPUT);\n digitalWrite(LED_BUILTIN, LOW);\n digitalWrite(LED_RED, LOW);\n digitalWrite(LED_YELLOW, LOW);\n digitalWrite(LED_GREEN, LOW);\n pinMode(BUTTON, INPUT);\n\n attachInterrupt(digitalPinToInterrupt(BUTTON), ISR_ButtonToggle, FALLING);\n\n Serial.begin(BAUDRATE);\n Serial.write(\"Ready.\\n\");\n}\n\nvoid loop() {\n switch(machineState) {\n case ST_R:\n \/\/ Serial.write(\"State: Red\");\n setRed();\n break;\n case ST_G:\n \/\/ Serial.write(\"State: Green\");\n setGreen();\n break;\n case WAIT_R_RY:\n Serial.write(\"Wait: Red->RedYellow\\n\");\n blinkDelay(DELAY_R_RY);\n machineState = ST_RY;\n break;\n case ST_RY:\n setRedYellow();\n machineState = WAIT_RY_G;\n break;\n case WAIT_RY_G:\n Serial.write(\"Wait: RedYellow->Green\\n\");\n blinkDelay(DELAY_RY_G);\n machineState = ST_G;\n break;\n case WAIT_G_Y:\n Serial.write(\"Wait: Green->Yellow\\n\");\n blinkDelay(DELAY_G_Y);\n machineState = ST_Y;\n break;\n case ST_Y:\n setYellow();\n machineState = WAIT_Y_R;\n break;\n case WAIT_Y_R:\n Serial.write(\"Wait: Yellow->Red\\n\");\n blinkDelay(DELAY_Y_R);\n machineState = ST_R;\n break;\n case WAIT_R_G:\n Serial.write(\"Wait: Red->Green\\n\");\n blinkDelay(DELAY_R_G);\n machineState = ST_G;\n break;\n case WAIT_G_R:\n Serial.write(\"Wait: Green->Red\");\n blinkDelay(DELAY_G_R);\n machineState = ST_R;\n break;\n default:\n Serial.write(\"Woops...\\n\");\n machineState = ST_R;\n }\n}<\/code><\/pre>\n\n\n\nIs this the best way to write this? Hell, no! Is it even a good tutorial? You tell me. I think it’s fairly simple and shows some evenly common concepts:<\/p>\n\n\n\n
Using IO pins<\/li> Wiring LEDs without burning them or the output pin<\/li> Wiring a button*<\/li> Using #define<\/kbd> statements to make code more readable and lives more easy<\/li>Using some abstraction (setState(), setRed()<\/kbd>, etc.)<\/li>Using a state machine as an extensible concept<\/li> Using an interrupt (Why use an interrupt? Because it interrupts your code exactly when the button is pressed. It makes your little circuit very responsive and – at least in this example – it is even easier to write.)<\/li><\/ul>\n\n\n\n*) You may encounter a problem that goes by the name “bouncing” (or in the beautiful German language “prellen”). That’s when your button press toggles multiple interrupts in a row. Try putting a capacitor in parallel with the resistor, or as a bad software hack, add a 5\u00a0ms delay (delay(5);<\/kbd>) to the end of your interrupt function.<\/p>\n\n\n\nAnyways: My girl loves it. Ha! You thought she’d be a boy because it was a traffic light. Shame on you!<\/p>\n","protected":false},"excerpt":{"rendered":"
My kid likes traffic lights. So I decided to quickly build one. I started off on a breadboard with a bunch of components: 3 \u00d7 LEDs (red, amber, green) 3 \u00d7 470 \u03a9 Resistors (only had two, so the third are actually 2 1 k\u03a9 in parallel) 1 \u00d7 10 k\u03a9 Resistor 1 \u00d7 Pushbutton Switch 1 \u00d7…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"footnotes":""},"categories":[1],"tags":[14,15],"class_list":["post-109","post","type-post","status-publish","format-standard","hentry","category-uncategorized","tag-arduino","tag-electronics"],"_links":{"self":[{"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/posts\/109","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/comments?post=109"}],"version-history":[{"count":24,"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/posts\/109\/revisions"}],"predecessor-version":[{"id":138,"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/posts\/109\/revisions\/138"}],"wp:attachment":[{"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/media?parent=109"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/categories?post=109"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/bowfinger.de\/blog\/wp-json\/wp\/v2\/tags?post=109"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![\"\"](\"https:\/\/bowfinger.de\/blog\/wp-content\/uploads\/2021\/05\/moore-machine-1-2.svg\")
![\"\"\/](\"https:\/\/media.giphy.com\/media\/9VeY7dXlDaCQg\/giphy.gif\")
<\/figure>\n\n\n\n