Dataset Viewer
Auto-converted to Parquet
instruction
stringlengths
40
100
input
stringlengths
136
25.5k
output
stringlengths
207
10.3k
Generate a diagram.json code for Simon says game
#include "pitches.h" /* Constants - define pin numbers for LEDs, buttons and speaker, and also the game tones: */ const uint8_t ledPins[] = {9, 10, 11, 12}; const uint8_t buttonPins[] = {2, 3, 4, 5}; #define SPEAKER_PIN 8 // These are connected to 74HC595 shift register (used to show game score): const int LATCH_PIN = A1; // 74HC595 pin 12 const int DATA_PIN = A0; // 74HC595pin 14 const int CLOCK_PIN = A2; // 74HC595 pin 11 #define MAX_GAME_LENGTH 100 const int gameTones[] = { NOTE_G3, NOTE_C4, NOTE_E4, NOTE_G5}; /* Global variables - store the game state */ uint8_t gameSequence[MAX_GAME_LENGTH] = {0}; uint8_t gameIndex = 0; /** Set up the Arduino board and initialize Serial communication */ void setup() { Serial.begin(9600); for (byte i = 0; i < 4; i++) { pinMode(ledPins[i], OUTPUT); pinMode(buttonPins[i], INPUT_PULLUP); } pinMode(SPEAKER_PIN, OUTPUT); pinMode(LATCH_PIN, OUTPUT); pinMode(CLOCK_PIN, OUTPUT); pinMode(DATA_PIN, OUTPUT); // The following line primes the random number generator. // It assumes pin A3 is floating (disconnected): randomSeed(analogRead(A3)); } /* Digit table for the 7-segment display */ const uint8_t digitTable[] = { 0b11000000, 0b11111001, 0b10100100, 0b10110000, 0b10011001, 0b10010010, 0b10000010, 0b11111000, 0b10000000, 0b10010000, }; const uint8_t DASH = 0b10111111; void sendScore(uint8_t high, uint8_t low) { digitalWrite(LATCH_PIN, LOW); shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, low); shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, high); digitalWrite(LATCH_PIN, HIGH); } void displayScore() { int high = gameIndex % 100 / 10; int low = gameIndex % 10; sendScore(high ? digitTable[high] : 0xff, digitTable[low]); } /** Lights the given LED and plays a suitable tone */ void lightLedAndPlayTone(byte ledIndex) { digitalWrite(ledPins[ledIndex], HIGH); tone(SPEAKER_PIN, gameTones[ledIndex]); delay(300); digitalWrite(ledPins[ledIndex], LOW); noTone(SPEAKER_PIN); } /** Plays the current sequence of notes that the user has to repeat */ void playSequence() { for (int i = 0; i < gameIndex; i++) { byte currentLed = gameSequence[i]; lightLedAndPlayTone(currentLed); delay(50); } } /** Waits until the user pressed one of the buttons, and returns the index of that button */ byte readButtons() { while (true) { for (byte i = 0; i < 4; i++) { byte buttonPin = buttonPins[i]; if (digitalRead(buttonPin) == LOW) { return i; } } delay(1); } } /** Play the game over sequence, and report the game score */ void gameOver() { Serial.print("Game over! your score: "); Serial.println(gameIndex - 1); gameIndex = 0; delay(200); // Play a Wah-Wah-Wah-Wah sound tone(SPEAKER_PIN, NOTE_DS5); delay(300); tone(SPEAKER_PIN, NOTE_D5); delay(300); tone(SPEAKER_PIN, NOTE_CS5); delay(300); for (byte i = 0; i < 10; i++) { for (int pitch = -10; pitch <= 10; pitch++) { tone(SPEAKER_PIN, NOTE_C5 + pitch); delay(5); } } noTone(SPEAKER_PIN); sendScore(DASH, DASH); delay(500); } /** Get the user's input and compare it with the expected sequence. */ bool checkUserSequence() { for (int i = 0; i < gameIndex; i++) { byte expectedButton = gameSequence[i]; byte actualButton = readButtons(); lightLedAndPlayTone(actualButton); if (expectedButton != actualButton) { return false; } } return true; } /** Plays a hooray sound whenever the user finishes a level */ void playLevelUpSound() { tone(SPEAKER_PIN, NOTE_E4); delay(150); tone(SPEAKER_PIN, NOTE_G4); delay(150); tone(SPEAKER_PIN, NOTE_E5); delay(150); tone(SPEAKER_PIN, NOTE_C5); delay(150); tone(SPEAKER_PIN, NOTE_D5); delay(150); tone(SPEAKER_PIN, NOTE_G5); delay(150); noTone(SPEAKER_PIN); } /** The main game loop */ void loop() { displayScore(); // Add a random color to the end of the sequence gameSequence[gameIndex] = random(0, 4); gameIndex++; if (gameIndex >= MAX_GAME_LENGTH) { gameIndex = MAX_GAME_LENGTH - 1; } playSequence(); if (!checkUserSequence()) { gameOver(); } delay(300); if (gameIndex > 0) { playLevelUpSound(); delay(300); } }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 183, "left": 18.6, "attrs": {} }, { "type": "wokwi-buzzer", "id": "buzzer", "top": 16, "left": 124, "attrs": { "volume": "0.1" } }, { "type": "wokwi-led", "id": "led-red", "top": 10, "left": 6, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led-green", "top": 73, "left": 6, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led-blue", "top": 10, "left": 270, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led-yellow", "top": 73, "left": 270, "attrs": { "color": "yellow" } }, { "type": "wokwi-pushbutton", "id": "btn-red", "top": 10, "left": 46, "attrs": { "color": "red", "key": "1", "label": "1" } }, { "type": "wokwi-pushbutton", "id": "btn-green", "top": 76, "left": 46, "attrs": { "color": "green", "key": "2", "label": "2" } }, { "type": "wokwi-pushbutton", "id": "btn-blue", "top": 10, "left": 200, "attrs": { "color": "blue", "key": "3", "label": "3" } }, { "type": "wokwi-pushbutton", "id": "btn-yellow", "top": 76, "left": 200, "attrs": { "color": "yellow", "key": "4", "label": "4" } }, { "type": "wokwi-74hc595", "id": "sr1", "top": 171.8, "left": 361.16, "rotate": 180, "attrs": {} }, { "type": "wokwi-74hc595", "id": "sr2", "top": 171.8, "left": 457.16, "rotate": 180, "attrs": {} }, { "type": "wokwi-7segment", "id": "sevseg1", "top": 47.16, "left": 379.48, "attrs": {} }, { "type": "wokwi-7segment", "id": "sevseg2", "top": 47.16, "left": 446.68, "attrs": {} } ], "connections": [ [ "uno:GND.1", "buzzer:1", "black", [ "v-12", "*", "h0" ] ], [ "uno:2", "btn-yellow:1.l", "gold", [ "v-48", "*", "h-6" ] ], [ "uno:GND.1", "btn-yellow:2.r", "black", [ "v-12", "*", "h6" ] ], [ "uno:3", "btn-blue:1.l", "blue", [ "v-44", "*", "h-10" ] ], [ "uno:GND.1", "btn-blue:2.r", "black", [ "v-12", "*", "h6" ] ], [ "uno:4", "btn-green:2.r", "green", [ "v-40", "*", "h6" ] ], [ "uno:GND.1", "btn-green:1.l", "black", [ "v-12", "*", "h-6" ] ], [ "uno:5", "btn-red:2.r", "orange", [ "v-36", "*", "h10" ] ], [ "uno:GND.1", "btn-red:1.l", "black", [ "v-12", "*", "h-6" ] ], [ "uno:8", "buzzer:2", "purple", [ "v-32", "*", "h0" ] ], [ "uno:9", "led-yellow:A", "gold", [ "v-28", "*", "h0" ] ], [ "uno:GND.1", "led-yellow:C", "black", [ "v-12", "*", "h-15", "v4" ] ], [ "uno:10", "led-blue:A", "blue", [ "v-24", "*", "h8" ] ], [ "uno:GND.1", "led-blue:C", "black", [ "v-12", "*", "h-15", "v4" ] ], [ "uno:11", "led-green:A", "green", [ "v-20", "*", "h0" ] ], [ "uno:GND.1", "led-green:C", "black", [ "v-12", "*", "h-8", "v4" ] ], [ "uno:12", "led-red:A", "orange", [ "v-16", "*", "h6" ] ], [ "uno:GND.1", "led-red:C", "black", [ "v-12", "*", "h-8", "v4" ] ], [ "uno:5V", "sr1:VCC", "red", [ "v57.5", "h253.4" ] ], [ "uno:A2", "sr1:SHCP", "gray", [ "v19.1", "h138.4" ] ], [ "uno:A1", "sr1:STCP", "purple", [ "v28.7", "h157.5" ] ], [ "uno:A0", "sr1:DS", "blue", [ "v38.3", "h186.2" ] ], [ "sr1:SHCP", "sr2:SHCP", "gray", [ "v47", "h106.12" ] ], [ "sr1:STCP", "sr2:STCP", "purple", [ "v37.4", "h96.52" ] ], [ "sr1:Q7S", "sr2:DS", "blue", [ "h0.52", "v56.6", "h144" ] ], [ "sr1:VCC", "sr1:MR", "red", [ "v17", "h-57.6" ] ], [ "sr1:VCC", "sr2:MR", "red", [ "v17", "h38.4" ] ], [ "sr1:VCC", "sr2:VCC", "red", [ "v17", "h96" ] ], [ "sr1:OE", "sr2:OE", "black", [ "v26.6", "h96" ] ], [ "sr1:MR", "sevseg1:COM.1", "red", [ "v17", "h-57.6", "v-96", "h76.8" ] ], [ "sevseg1:COM.1", "sevseg2:COM.1", "red", [ "h0", "v9.6", "h57.6" ] ], [ "sr2:Q0", "sevseg2:A", "green", [ "v7.4", "h28.8", "v-182.4", "h-67.2" ] ], [ "sr2:Q1", "sevseg2:B", "green", [ "v0", "h9.6", "v-134.4", "h-48" ] ], [ "sr2:Q2", "sevseg2:C", "green", [ "v-38.4", "h-38.4" ] ], [ "sr2:Q3", "sevseg2:D", "green", [ "v-33.6", "h-33.6", "v-9.6", "h-14.4" ] ], [ "sr2:Q4", "sevseg2:E", "green", [ "v-28.8", "h-28.8", "v-9.6", "h-14.4" ] ], [ "sr2:Q5", "sevseg2:F", "green", [ "v-24", "h-24", "v-9.6", "h-24", "v-110.4", "h19.2" ] ], [ "sr2:Q6", "sevseg2:G", "green", [ "v-19.2", "h-43.2", "v-115.2", "h14.4" ] ], [ "sr1:GND", "sr2:GND", "black", [ "v-9.6", "h96" ] ], [ "sr1:Q1", "sevseg1:B", "green", [ "v-134.4", "h-19.2" ] ], [ "sr1:Q2", "sevseg1:C", "green", [ "v-38.4", "h-19.2" ] ], [ "sr1:Q3", "sevseg1:D", "green", [ "v-33.6", "h-24" ] ], [ "sr1:Q4", "sevseg1:E", "green", [ "v-28.8", "h-28.8" ] ], [ "uno:GND.3", "sr1:GND", "black", [ "v47.9", "h157.6", "v-259.2", "h9.6" ] ], [ "sr1:GND", "sr1:OE", "black", [ "v-9.6", "h-9.6", "v67.2", "h172.8" ] ], [ "sr1:Q0", "sevseg1:A", "green", [ "v65", "h-76.8", "v-240", "h57.6" ] ], [ "sr1:Q5", "sevseg1:F", "green", [ "v-24", "h-19.2", "v-110.4", "h19.2" ] ], [ "sr1:Q6", "sevseg1:G", "green", [ "v-19.2", "h-14.4", "v-110.4", "h14.4" ] ] ] }
Generate a diagram.json code for servos dancing
#include <Servo.h> #define NUM_SERVOS 32 Servo myServo[NUM_SERVOS]; void setup() { // Attach pins from the Arduino Mega board to the Servo objects. // Starting from pin 22, there happen to be exactly 32 pins on the double row pins. for( int i=0; i<NUM_SERVOS; i++) { myServo[i].attach( i + 22); // pin 22 up to 53 is 32 pins } } void loop() { // Sequence one. // All servo motor are set to a random angle. for( int a=0; a<15; a++) { for( int i=0; i<NUM_SERVOS; i++) { myServo[i].write( random( 0, 181)); delay( 2); } delay( 150); } // Sequence two. // All servo motors move with the same angle. for( int i=0; i<NUM_SERVOS; i++) { myServo[i].write( 0); // set to begin position (horn is rotated left) } delay( 1000); // wait to let the viewer get used to it for( int a=0; a<3; a++) { for( int r=0; r<=180; r++) // move horns to the right { for( int i=0; i<NUM_SERVOS; i++) { myServo[i].write( r); } delay( 6); } for( int r=180; r>=0; r--) { for( int i=0; i<NUM_SERVOS; i++) // move horns to the left { myServo[i].write( r); } delay( 6); } } // Sequence three. // A rotating wave. for( int a=0; a<6; a++) { for( int i=0; i<NUM_SERVOS; i++) { for( int j=0; j<NUM_SERVOS; j++) { // Calculate distance to active servo int d = j - i; if( d < 0) d = -d; if( d > (NUM_SERVOS / 2)) d = NUM_SERVOS - d; int angle = 90 - (10 * d); if( angle < 0) angle = 0; myServo[j].write( angle); } delay(40); } } // Sequence four. // A "compass" // Start by pointing upwards int pointer = NUM_SERVOS * 3 / 4; showPointer( pointer); delay( 1000); // let the viewer get used to new pattern for( int i=0; i<5; i++) { showPointer( --pointer); delay( 150); } delay( 200); for( int i=0; i<9; i++) { showPointer( ++pointer); delay( 150); } delay( 200); for( int i=0; i<5; i++) { showPointer( --pointer); delay( 150); } delay( 200); for( int i=0; i<4; i++) { showPointer( ++pointer); delay( 150); } delay( 160); for( int i=0; i<2; i++) { showPointer( --pointer); delay( 150); } delay( 80); for( int i=0; i<1; i++) { showPointer( ++pointer); delay( 150); } delay( 2000); } // This function makes a "pointer" with the servos. // It is used to create the "compass". // The parameter 's' is the servo motor that has the pointer. // It is allowed that 's' is below zero or larger than the numbers of servo motors. void showPointer( int s) { int pointerA = s % NUM_SERVOS; // Using the '%' (remainder) for valid number int pointerB = (s + 1) % NUM_SERVOS; // pointer is made with the next servo motor int tailA = (s + 16) % NUM_SERVOS; int tailB = (s + 17) % NUM_SERVOS; // make pointer with servo motor s and s+1. myServo[pointerA].write(180-56); myServo[pointerB].write(56); // make tail with servo motor s+16 and s+17. myServo[tailA].write(95); myServo[tailB].write(85); // Set servos right of pointer int n = (NUM_SERVOS / 2) - 2; int start = pointerB + 1; for( int i=0; i<n; i++) { int j = (start + i) % NUM_SERVOS; myServo[j].write( 2); } // Set servos left of pointer start = tailB + 1; for( int i=0; i<n; i++) { int j = (start + i) % NUM_SERVOS; myServo[j].write( 178); } } // The function GenerateDiagram() can be used to generate // the diagram.json file for Wokwi. // To use it, call it from the setup() function, and the // serial output can be copied into the diagram.json file. void GenerateDiagram() { Serial.begin(115200); Serial.print( "{\n"); Serial.print( " \"version\": 1,\n"); Serial.print( " \"author\": \"Generated\",\n"); Serial.print( " \"editor\": \"wokwi\",\n"); Serial.print( " \"parts\": [\n"); Serial.print( " {\n"); Serial.print( " \"type\": \"wokwi-arduino-mega\",\n"); Serial.print( " \"id\": \"mega\",\n"); Serial.print( " \"top\": 270,\n"); Serial.print( " \"left\": 185,\n"); Serial.print( " \"attrs\": {}\n"); Serial.print( " },\n"); // Put the servo motor in reverse order in the diagram.json // I think that is visually better. // The horn now overlaps the next servo when the horn moves to the right. for( int i=NUM_SERVOS-1; i>=0; i--) { float rotate = float( i) * (360.0 / float( NUM_SERVOS)); float rad = rotate / 360.0 * 2.0 * M_PI; float top = (300.0 * sin( rad)) + 300.0; float left = (300.0 * cos( rad)) + 300.0; Serial.print( " {\n"); Serial.print( " \"type\": \"wokwi-servo\",\n"); Serial.print( " \"id\": \"servo"); Serial.print( i); Serial.print( "\",\n"); Serial.print( " \"top\": "); Serial.print( top); Serial.print( ",\n"); Serial.print( " \"left\": "); Serial.print( left); Serial.print( ",\n"); Serial.print( " \"rotate\": "); Serial.print( rotate); Serial.print( ",\n"); Serial.print( " \"attrs\": { \"hornColor\": \"Red\" }\n"); Serial.print( " }"); if( i != 0) Serial.print( ","); Serial.print( "\n"); } Serial.print( " ],\n"); Serial.print( " \"connections\": [\n"); for( int i=0; i<NUM_SERVOS; i++) { int j = i + 1; if( j == NUM_SERVOS) j = 0; Serial.print( " [ \"servo"); Serial.print( i); Serial.print( ":V+\", \"servo"); Serial.print( j); Serial.print( ":V+\", \"Red\", [] ],\n"); Serial.print( " [ \"servo"); Serial.print( i); Serial.print( ":GND\", \"servo"); Serial.print( j); Serial.print( ":GND\", \"Black\", [] ],\n"); Serial.print( " [ \"mega:"); Serial.print( i + 22); Serial.print( "\", \"servo"); Serial.print( i); Serial.print( ":PWM\", \"Green\", [ ] ],\n"); } Serial.print( " [ \"mega:GND.2\", \"servo9:GND\", \"Black\", [ ] ],\n"); Serial.print( " [ \"mega:5V\", \"servo9:V+\", \"Red\", [ ] ]\n"); Serial.print( " ]\n"); Serial.print( "}\n"); }
{ "version": 1, "author": "Generated", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-mega", "id": "mega", "top": 270, "left": 185, "attrs": {} }, { "type": "wokwi-servo", "id": "servo31", "top": 241.47, "left": 594.24, "rotate": 348.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo30", "top": 185.19, "left": 577.16, "rotate": 337.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo29", "top": 133.33, "left": 549.44, "rotate": 326.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo28", "top": 87.87, "left": 512.13, "rotate": 315.00, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo27", "top": 50.56, "left": 466.67, "rotate": 303.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo26", "top": 22.84, "left": 414.81, "rotate": 292.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo25", "top": 5.76, "left": 358.53, "rotate": 281.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo24", "top": 0.00, "left": 300.00, "rotate": 270.00, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo23", "top": 5.76, "left": 241.47, "rotate": 258.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo22", "top": 22.84, "left": 185.20, "rotate": 247.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo21", "top": 50.56, "left": 133.33, "rotate": 236.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo20", "top": 87.87, "left": 87.87, "rotate": 225.00, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo19", "top": 133.33, "left": 50.56, "rotate": 213.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo18", "top": 185.19, "left": 22.84, "rotate": 202.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo17", "top": 241.47, "left": 5.76, "rotate": 191.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo16", "top": 300.00, "left": 0.00, "rotate": 180.00, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo15", "top": 358.53, "left": 5.76, "rotate": 168.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo14", "top": 414.80, "left": 22.84, "rotate": 157.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo13", "top": 466.67, "left": 50.56, "rotate": 146.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo12", "top": 512.13, "left": 87.87, "rotate": 135.00, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo11", "top": 549.44, "left": 133.33, "rotate": 123.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo10", "top": 577.16, "left": 185.19, "rotate": 112.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo9", "top": 594.24, "left": 241.47, "rotate": 101.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo8", "top": 600.00, "left": 300.00, "rotate": 90.00, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo7", "top": 594.24, "left": 358.53, "rotate": 78.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo6", "top": 577.16, "left": 414.81, "rotate": 67.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo5", "top": 549.44, "left": 466.67, "rotate": 56.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo4", "top": 512.13, "left": 512.13, "rotate": 45.00, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo3", "top": 466.67, "left": 549.44, "rotate": 33.75, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo2", "top": 414.81, "left": 577.16, "rotate": 22.50, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo1", "top": 358.53, "left": 594.24, "rotate": 11.25, "attrs": { "hornColor": "Red" } }, { "type": "wokwi-servo", "id": "servo0", "top": 300.00, "left": 600.00, "rotate": 0.00, "attrs": { "hornColor": "Red" } } ], "connections": [ [ "servo0:V+", "servo1:V+", "Red", [] ], [ "servo0:GND", "servo1:GND", "Black", [] ], [ "mega:22", "servo0:PWM", "Green", [ ] ], [ "servo1:V+", "servo2:V+", "Red", [] ], [ "servo1:GND", "servo2:GND", "Black", [] ], [ "mega:23", "servo1:PWM", "Green", [ ] ], [ "servo2:V+", "servo3:V+", "Red", [] ], [ "servo2:GND", "servo3:GND", "Black", [] ], [ "mega:24", "servo2:PWM", "Green", [ ] ], [ "servo3:V+", "servo4:V+", "Red", [] ], [ "servo3:GND", "servo4:GND", "Black", [] ], [ "mega:25", "servo3:PWM", "Green", [ ] ], [ "servo4:V+", "servo5:V+", "Red", [] ], [ "servo4:GND", "servo5:GND", "Black", [] ], [ "mega:26", "servo4:PWM", "Green", [ ] ], [ "servo5:V+", "servo6:V+", "Red", [] ], [ "servo5:GND", "servo6:GND", "Black", [] ], [ "mega:27", "servo5:PWM", "Green", [ ] ], [ "servo6:V+", "servo7:V+", "Red", [] ], [ "servo6:GND", "servo7:GND", "Black", [] ], [ "mega:28", "servo6:PWM", "Green", [ ] ], [ "servo7:V+", "servo8:V+", "Red", [] ], [ "servo7:GND", "servo8:GND", "Black", [] ], [ "mega:29", "servo7:PWM", "Green", [ ] ], [ "servo8:V+", "servo9:V+", "Red", [] ], [ "servo8:GND", "servo9:GND", "Black", [] ], [ "mega:30", "servo8:PWM", "Green", [ ] ], [ "servo9:V+", "servo10:V+", "Red", [] ], [ "servo9:GND", "servo10:GND", "Black", [] ], [ "mega:31", "servo9:PWM", "Green", [ ] ], [ "servo10:V+", "servo11:V+", "Red", [] ], [ "servo10:GND", "servo11:GND", "Black", [] ], [ "mega:32", "servo10:PWM", "Green", [ ] ], [ "servo11:V+", "servo12:V+", "Red", [] ], [ "servo11:GND", "servo12:GND", "Black", [] ], [ "mega:33", "servo11:PWM", "Green", [ ] ], [ "servo12:V+", "servo13:V+", "Red", [] ], [ "servo12:GND", "servo13:GND", "Black", [] ], [ "mega:34", "servo12:PWM", "Green", [ ] ], [ "servo13:V+", "servo14:V+", "Red", [] ], [ "servo13:GND", "servo14:GND", "Black", [] ], [ "mega:35", "servo13:PWM", "Green", [ ] ], [ "servo14:V+", "servo15:V+", "Red", [] ], [ "servo14:GND", "servo15:GND", "Black", [] ], [ "mega:36", "servo14:PWM", "Green", [ ] ], [ "servo15:V+", "servo16:V+", "Red", [] ], [ "servo15:GND", "servo16:GND", "Black", [] ], [ "mega:37", "servo15:PWM", "Green", [ ] ], [ "servo16:V+", "servo17:V+", "Red", [] ], [ "servo16:GND", "servo17:GND", "Black", [] ], [ "mega:38", "servo16:PWM", "Green", [ ] ], [ "servo17:V+", "servo18:V+", "Red", [] ], [ "servo17:GND", "servo18:GND", "Black", [] ], [ "mega:39", "servo17:PWM", "Green", [ ] ], [ "servo18:V+", "servo19:V+", "Red", [] ], [ "servo18:GND", "servo19:GND", "Black", [] ], [ "mega:40", "servo18:PWM", "Green", [ ] ], [ "servo19:V+", "servo20:V+", "Red", [] ], [ "servo19:GND", "servo20:GND", "Black", [] ], [ "mega:41", "servo19:PWM", "Green", [ ] ], [ "servo20:V+", "servo21:V+", "Red", [] ], [ "servo20:GND", "servo21:GND", "Black", [] ], [ "mega:42", "servo20:PWM", "Green", [ ] ], [ "servo21:V+", "servo22:V+", "Red", [] ], [ "servo21:GND", "servo22:GND", "Black", [] ], [ "mega:43", "servo21:PWM", "Green", [ ] ], [ "servo22:V+", "servo23:V+", "Red", [] ], [ "servo22:GND", "servo23:GND", "Black", [] ], [ "mega:44", "servo22:PWM", "Green", [ ] ], [ "servo23:V+", "servo24:V+", "Red", [] ], [ "servo23:GND", "servo24:GND", "Black", [] ], [ "mega:45", "servo23:PWM", "Green", [ ] ], [ "servo24:V+", "servo25:V+", "Red", [] ], [ "servo24:GND", "servo25:GND", "Black", [] ], [ "mega:46", "servo24:PWM", "Green", [ ] ], [ "servo25:V+", "servo26:V+", "Red", [] ], [ "servo25:GND", "servo26:GND", "Black", [] ], [ "mega:47", "servo25:PWM", "Green", [ ] ], [ "servo26:V+", "servo27:V+", "Red", [] ], [ "servo26:GND", "servo27:GND", "Black", [] ], [ "mega:48", "servo26:PWM", "Green", [ ] ], [ "servo27:V+", "servo28:V+", "Red", [] ], [ "servo27:GND", "servo28:GND", "Black", [] ], [ "mega:49", "servo27:PWM", "Green", [ ] ], [ "servo28:V+", "servo29:V+", "Red", [] ], [ "servo28:GND", "servo29:GND", "Black", [] ], [ "mega:50", "servo28:PWM", "Green", [ ] ], [ "servo29:V+", "servo30:V+", "Red", [] ], [ "servo29:GND", "servo30:GND", "Black", [] ], [ "mega:51", "servo29:PWM", "Green", [ ] ], [ "servo30:V+", "servo31:V+", "Red", [] ], [ "servo30:GND", "servo31:GND", "Black", [] ], [ "mega:52", "servo30:PWM", "Green", [ ] ], [ "servo31:V+", "servo0:V+", "Red", [] ], [ "servo31:GND", "servo0:GND", "Black", [] ], [ "mega:53", "servo31:PWM", "Green", [ ] ], [ "mega:GND.2", "servo9:GND", "Black", [ ] ], [ "mega:5V", "servo9:V+", "Red", [ ] ] ] }
Generate a diagram.json code for LED matrix tunnel
// This version uses bit-banged SPI. // If you see tearing (jagged edges on the circles) try the version // which uses AVR's hardware SPI peripheral: // https://wokwi.com/arduino/projects/318868939929027156 #define CLK 13 #define DIN 11 #define CS 10 #define X_SEGMENTS 4 #define Y_SEGMENTS 4 #define NUM_SEGMENTS (X_SEGMENTS * Y_SEGMENTS) // a framebuffer to hold the state of the entire matrix of LEDs // laid out in raster order, with (0, 0) at the top-left byte fb[8 * NUM_SEGMENTS]; void shiftAll(byte send_to_address, byte send_this_data) { digitalWrite(CS, LOW); for (int i = 0; i < NUM_SEGMENTS; i++) { shiftOut(DIN, CLK, MSBFIRST, send_to_address); shiftOut(DIN, CLK, MSBFIRST, send_this_data); } digitalWrite(CS, HIGH); } void setup() { Serial.begin(115200); pinMode(CLK, OUTPUT); pinMode(DIN, OUTPUT); pinMode(CS, OUTPUT); // Setup each MAX7219 shiftAll(0x0f, 0x00); //display test register - test mode off shiftAll(0x0b, 0x07); //scan limit register - display digits 0 thru 7 shiftAll(0x0c, 0x01); //shutdown register - normal operation shiftAll(0x0a, 0x0f); //intensity register - max brightness shiftAll(0x09, 0x00); //decode mode register - No decode } void loop() { static int16_t sx1 = 15 << 8, sx2 = sx1, sy1, sy2; sx1 = sx1 - (sy1 >> 6); sy1 = sy1 + (sx1 >> 6); sx2 = sx2 - (sy2 >> 5); sy2 = sy2 + (sx2 >> 5); static byte travel = 0; travel--; byte *dst = fb; byte output = 0; int8_t x_offset = (sx1 >> 8) - X_SEGMENTS * 4; int8_t y_offset = (sx2 >> 8) - Y_SEGMENTS * 4; uint8_t screenx, screeny, xroot, yroot; uint16_t xsumsquares, ysumsquares, xnextsquare, ynextsquare; int8_t x, y; // offset the origin in screen space x = x_offset; y = y_offset; ysumsquares = x_offset * x_offset + y * y; yroot = int(sqrtf(ysumsquares)); ynextsquare = yroot*yroot; // Quadrant II (top-left) screeny = Y_SEGMENTS * 8; while (y < 0 && screeny) { x = x_offset; screenx = X_SEGMENTS * 8; xsumsquares = ysumsquares; xroot = yroot; if (x < 0) { xnextsquare = xroot * xroot; while (x < 0 && screenx) { screenx--; output <<= 1; output |= ((xroot + travel) & 8) >> 3; if (!(screenx & 7)) *dst++ = output; xsumsquares += 2 * x++ + 1; if (xsumsquares < xnextsquare) xnextsquare -= 2 * xroot-- - 1; } } // Quadrant I (top right) if (screenx) { xnextsquare = (xroot + 1) * (xroot + 1); while (screenx) { screenx--; output <<= 1; output |= ((xroot + travel) & 8) >> 3; if (!(screenx & 7)) *dst++ = output; xsumsquares += 2 * x++ + 1; if (xsumsquares >= xnextsquare) xnextsquare += 2 * ++xroot + 1; } } ysumsquares += 2 * y++ + 1; if (ysumsquares < ynextsquare) ynextsquare -= 2 * yroot-- - 1; screeny--; } // Quadrant III (bottom left) ynextsquare = (yroot + 1) * (yroot + 1); while (screeny) { x = x_offset; screenx = X_SEGMENTS * 8; xsumsquares = ysumsquares; xroot = yroot; if (x < 0) { xnextsquare = xroot * xroot; while (x < 0 && screenx) { screenx--; output <<= 1; output |= ((xroot + travel) & 8) >> 3; if (!(screenx & 7)) *dst++ = output; xsumsquares += 2 * x++ + 1; if (xsumsquares < xnextsquare) xnextsquare -= 2 * xroot-- - 1; } } // Quadrant IV (bottom right) if (screenx) { xnextsquare = (xroot + 1) * (xroot + 1); while (screenx--) { output <<= 1; output |= ((xroot + travel) & 8) >> 3; if (!(screenx & 7)) *dst++ = output; xsumsquares += 2 * x++ + 1; if (xsumsquares >= xnextsquare) xnextsquare += 2 * ++xroot + 1; } } ysumsquares += 2 * y++ + 1; if (ysumsquares >= ynextsquare) ynextsquare += 2 * ++yroot + 1; screeny--; } show(); } void set_pixel(uint8_t x, uint8_t y, uint8_t mode) { byte *addr = &fb[x / 8 + y * X_SEGMENTS]; byte mask = 128 >> (x % 8); switch (mode) { case 0: // clear pixel *addr &= ~mask; break; case 1: // plot pixel *addr |= mask; break; case 2: // XOR pixel *addr ^= mask; break; } } void safe_pixel(uint8_t x, uint8_t y, uint8_t mode) { if ((x >= X_SEGMENTS * 8) || (y >= Y_SEGMENTS * 8)) return; set_pixel(x, y, mode); } // turn off every LED in the framebuffer void clear() { byte *addr = fb; for (byte i = 0; i < 8 * NUM_SEGMENTS; i++) *addr++ = 0; } // send the raster order framebuffer in the correct order // for the boustrophedon layout of daisy-chained MAX7219s void show() { for (byte row = 0; row < 8; row++) { digitalWrite(CS, LOW); byte segment = NUM_SEGMENTS; while (segment--) { byte x = segment % X_SEGMENTS; byte y = segment / X_SEGMENTS * 8; byte addr = (row + y) * X_SEGMENTS; if (segment & X_SEGMENTS) { // odd rows of segments shiftOut(DIN, CLK, MSBFIRST, 8 - row); shiftOut(DIN, CLK, LSBFIRST, fb[addr + x]); } else { // even rows of segments shiftOut(DIN, CLK, MSBFIRST, 1 + row); shiftOut(DIN, CLK, MSBFIRST, fb[addr - x + X_SEGMENTS - 1]); } } digitalWrite(CS, HIGH); } }
{ "version": 1, "author": "sutaburosu", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-mega", "id": "mega", "top": -177.58, "left": 252.33, "rotate": 90, "attrs": {} }, { "type": "wokwi-max7219-matrix", "id": "matrix1", "top": -126.7, "left": -79.5, "attrs": { "chain": "4", "layout": "fc16" } }, { "type": "wokwi-max7219-matrix", "id": "matrix2", "top": -52.5, "left": -79.5, "rotate": 180, "attrs": { "chain": "4", "layout": "fc16" } }, { "type": "wokwi-max7219-matrix", "id": "matrix3", "top": 22.46, "left": -78.96, "attrs": { "chain": "4", "layout": "fc16" } }, { "type": "wokwi-max7219-matrix", "id": "matrix4", "top": 96.8, "left": -79.5, "rotate": 180, "attrs": { "chain": "4", "layout": "fc16" } } ], "connections": [ [ "matrix1:GND.2", "matrix2:GND", "black", [ "h-47.8", "v89.07" ] ], [ "matrix1:DOUT", "matrix2:DIN", "blue", [ "h-38.2", "v69.87" ] ], [ "matrix1:CS.2", "matrix2:CS", "green", [ "h-28.6", "v50.67" ] ], [ "matrix1:CLK.2", "matrix2:CLK", "orange", [ "h-19", "v31.47" ] ], [ "matrix2:CLK.2", "matrix3:CLK", "orange", [ "h58.3", "v110.3" ] ], [ "matrix2:CS.2", "matrix3:CS", "green", [ "h48.7", "v91.1" ] ], [ "matrix2:DOUT", "matrix3:DIN", "blue", [ "h39.1", "v71.9" ] ], [ "matrix2:GND.2", "matrix3:GND", "black", [ "h29.5", "v52.7" ] ], [ "matrix3:V+", "matrix2:V+.2", "red", [ "h19.2", "v-31.46" ] ], [ "matrix2:V+", "matrix1:V+.2", "red", [ "h-56.74", "v-110.5" ] ], [ "matrix4:V+", "matrix3:V+.2", "red", [ "h-56.74", "v-115.8" ] ], [ "matrix3:GND.2", "matrix4:GND", "black", [ "h-47.84", "v93.34" ] ], [ "matrix4:DIN", "matrix3:DOUT", "blue", [ "h-37.54", "v-67.8" ] ], [ "matrix4:CS", "matrix3:CS.2", "green", [ "h-27.94", "v-58.2" ] ], [ "matrix4:CLK", "matrix3:CLK.2", "orange", [ "h-18.34", "v-39" ] ], [ "mega:5V", "matrix1:V+", "red", [ "h-33.66", "v-77.39" ] ], [ "mega:GND.2", "matrix1:GND", "black", [ "h-42.41", "v-79.48" ] ], [ "mega:11", "matrix1:DIN", "blue", [ "h20.97", "v249.88", "h-211.2", "v-211.2" ] ], [ "mega:10", "matrix1:CS", "green", [ "h30.57", "v249.98", "h-230.4", "v-220.8" ] ], [ "mega:13", "matrix1:CLK", "orange", [ "h40.17", "v288.08", "h-249.6", "v-220.8" ] ] ] }
Generate a diagram.json code for mini piano
#include "pitches.h" #define SPEAKER_PIN 8 const uint8_t buttonPins[] = { 12, 11, 10, 9, 7, 6, 5, 4 }; const int buttonTones[] = { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 }; const int numTones = sizeof(buttonPins) / sizeof(buttonPins[0]); void setup() { for (uint8_t i = 0; i < numTones; i++) { pinMode(buttonPins[i], INPUT_PULLUP); } pinMode(SPEAKER_PIN, OUTPUT); } void loop() { int pitch = 0; for (uint8_t i = 0; i < numTones; i++) { if (digitalRead(buttonPins[i]) == LOW) { pitch = buttonTones[i]; } } if (pitch) { tone(SPEAKER_PIN, pitch); } else { noTone(SPEAKER_PIN); } }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 185, "left": 71, "attrs": {} }, { "type": "wokwi-buzzer", "id": "buzzer", "top": 220, "left": 380, "rotate": 90, "attrs": { "volume": "0.2" } }, { "type": "wokwi-pushbutton", "id": "btn1", "top": 70, "left": 0, "rotate": 90, "attrs": { "color": "red", "key": "1" } }, { "type": "wokwi-pushbutton", "id": "btn2", "top": 70, "left": 50, "rotate": 90, "attrs": { "color": "orange", "key": "2" } }, { "type": "wokwi-pushbutton", "id": "btn3", "top": 70, "left": 100, "rotate": 90, "attrs": { "color": "yellow", "key": "3" } }, { "type": "wokwi-pushbutton", "id": "btn4", "top": 70, "left": 150, "rotate": 90, "attrs": { "color": "green", "key": "4" } }, { "type": "wokwi-pushbutton", "id": "btn5", "top": 70, "left": 200, "rotate": 90, "attrs": { "color": "cyan", "key": "5" } }, { "type": "wokwi-pushbutton", "id": "btn6", "top": 70, "left": 250, "rotate": 90, "attrs": { "color": "blue", "key": "6" } }, { "type": "wokwi-pushbutton", "id": "btn7", "top": 70, "left": 300, "rotate": 90, "attrs": { "color": "purple", "key": "7" } }, { "type": "wokwi-pushbutton", "id": "btn8", "top": 70, "left": 350, "rotate": 90, "attrs": { "color": "red", "key": "8" } } ], "connections": [ [ "uno:GND.1", "buzzer:1", "black", [ "v-16", "*", "h-18" ] ], [ "uno:8", "buzzer:2", "gold", [ "v-24", "*", "h-10" ] ], [ "uno:12", "btn1:1.r", "red", [ "v-24", "h0" ] ], [ "uno:GND.1", "btn1:2.r", "black", [ "v-16", "h0" ] ], [ "uno:11", "btn2:1.r", "orange", [ "v-32", "h0" ] ], [ "uno:GND.1", "btn2:2.r", "black", [ "v-16", "h0" ] ], [ "uno:10", "btn3:1.r", "yellow", [ "v-38", "h0" ] ], [ "uno:GND.1", "btn3:2.r", "black", [ "v-16", "h0" ] ], [ "uno:9", "btn4:1.r", "green", [ "v-46", "h20" ] ], [ "uno:GND.1", "btn4:2.r", "black", [ "v-16", "h0" ] ], [ "uno:7", "btn5:1.r", "cyan", [ "v-56", "h0" ] ], [ "uno:GND.1", "btn5:2.r", "black", [ "v-16", "h0" ] ], [ "uno:6", "btn6:1.r", "blue", [ "v-48", "h0" ] ], [ "uno:GND.1", "btn6:2.r", "black", [ "v-16", "h0" ] ], [ "uno:5", "btn7:1.r", "purple", [ "v-40", "h0" ] ], [ "uno:GND.1", "btn7:2.r", "black", [ "v-16", "h0" ] ], [ "uno:4", "btn8:1.r", "red", [ "v-32", "h0" ] ], [ "uno:GND.1", "btn8:2.r", "black", [ "v-16", "h0" ] ] ] }
Generate a diagram.json code for alarm clock with RTC
/** Arduino Digital Alarm Clock Copyright (C) 2020, Uri Shaked. Released under the MIT License. */ #include <SevSeg.h> #include "Button.h" #include "AlarmTone.h" #include "Clock.h" #include "config.h" const int COLON_PIN = 13; const int SPEAKER_PIN = A3; Button hourButton(A0); Button minuteButton(A1); Button alarmButton(A2); AlarmTone alarmTone; Clock clock; SevSeg sevseg; enum DisplayState { DisplayClock, DisplayAlarmStatus, DisplayAlarmTime, DisplayAlarmActive, DisplaySnooze, }; DisplayState displayState = DisplayClock; long lastStateChange = 0; void changeDisplayState(DisplayState newValue) { displayState = newValue; lastStateChange = millis(); } long millisSinceStateChange() { return millis() - lastStateChange; } void setColon(bool value) { digitalWrite(COLON_PIN, value ? LOW : HIGH); } void displayTime() { DateTime now = clock.now(); bool blinkState = now.second() % 2 == 0; sevseg.setNumber(now.hour() * 100 + now.minute()); setColon(blinkState); } void clockState() { displayTime(); if (alarmButton.read() == Button::RELEASED && clock.alarmActive()) { // Read alarmButton has_changed() to clear its state alarmButton.has_changed(); changeDisplayState(DisplayAlarmActive); return; } if (hourButton.pressed()) { clock.incrementHour(); } if (minuteButton.pressed()) { clock.incrementMinute(); } if (alarmButton.pressed()) { clock.toggleAlarm(); changeDisplayState(DisplayAlarmStatus); } } void alarmStatusState() { setColon(false); sevseg.setChars(clock.alarmEnabled() ? " on" : " off"); if (millisSinceStateChange() > ALARM_STATUS_DISPLAY_TIME) { changeDisplayState(clock.alarmEnabled() ? DisplayAlarmTime : DisplayClock); return; } } void alarmTimeState() { DateTime alarm = clock.alarmTime(); sevseg.setNumber(alarm.hour() * 100 + alarm.minute(), -1); if (millisSinceStateChange() > ALARM_HOUR_DISPLAY_TIME || alarmButton.pressed()) { changeDisplayState(DisplayClock); return; } if (hourButton.pressed()) { clock.incrementAlarmHour(); lastStateChange = millis(); } if (minuteButton.pressed()) { clock.incrementAlarmMinute(); lastStateChange = millis(); } if (alarmButton.pressed()) { changeDisplayState(DisplayClock); } } void alarmState() { displayTime(); if (alarmButton.read() == Button::RELEASED) { alarmTone.play(); } if (alarmButton.pressed()) { alarmTone.stop(); } if (alarmButton.released()) { alarmTone.stop(); bool longPress = alarmButton.repeat_count() > 0; if (longPress) { clock.stopAlarm(); changeDisplayState(DisplayClock); } else { clock.snooze(); changeDisplayState(DisplaySnooze); } } } void snoozeState() { sevseg.setChars("****"); if (millisSinceStateChange() > SNOOZE_DISPLAY_TIME) { changeDisplayState(DisplayClock); return; } } void setup() { Serial.begin(115200); clock.begin(); hourButton.begin(); hourButton.set_repeat(500, 200); minuteButton.begin(); minuteButton.set_repeat(500, 200); alarmButton.begin(); alarmButton.set_repeat(1000, -1); alarmTone.begin(SPEAKER_PIN); pinMode(COLON_PIN, OUTPUT); byte digits = 4; byte digitPins[] = {2, 3, 4, 5}; byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12}; bool resistorsOnSegments = false; bool updateWithDelays = false; bool leadingZeros = true; bool disableDecPoint = true; sevseg.begin(DISPLAY_TYPE, digits, digitPins, segmentPins, resistorsOnSegments, updateWithDelays, leadingZeros, disableDecPoint); sevseg.setBrightness(90); } void loop() { sevseg.refreshDisplay(); switch (displayState) { case DisplayClock: clockState(); break; case DisplayAlarmStatus: alarmStatusState(); break; case DisplayAlarmTime: alarmTimeState(); break; case DisplayAlarmActive: alarmState(); break; case DisplaySnooze: snoozeState(); break; } }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-7segment", "id": "7segment", "top": -29.04, "left": 330.64, "rotate": 0, "hide": false, "attrs": { "commonPin": "anode", "digits": "4", "colon": "1" } }, { "type": "wokwi-buzzer", "id": "buzzer1", "top": 190.17, "left": 466.82, "rotate": 90, "hide": false, "attrs": {} }, { "type": "wokwi-pushbutton", "id": "pushbutton1", "top": 110, "left": 300, "rotate": 0, "hide": false, "attrs": { "label": "Hours", "color": "green" } }, { "type": "wokwi-pushbutton", "id": "pushbutton2", "top": 110, "left": 380, "rotate": 0, "hide": false, "attrs": { "label": "Minutes", "color": "green" } }, { "type": "wokwi-pushbutton", "id": "pushbutton3", "top": 110, "left": 460, "rotate": 0, "hide": false, "attrs": { "label": "Alarm" } }, { "type": "wokwi-ds1307", "id": "ds1307", "top": 235.82, "left": 283.79, "rotate": 0, "hide": false, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "arduino", "top": 0, "left": 0, "rotate": 0, "hide": false, "attrs": {} } ], "connections": [ [ "7segment:DIG1", "arduino:2", "gold", [ "v-20", "h0" ] ], [ "7segment:DIG2", "arduino:3", "green", [ "v-24", "h0" ] ], [ "7segment:DIG3", "arduino:4", "orange", [ "v-28", "h0" ] ], [ "7segment:DIG4", "arduino:5", "purple", [ "v28", "h-150", "*", "v-16" ] ], [ "7segment:A", "arduino:6", "gray", [ "v-16", "h0" ] ], [ "7segment:B", "arduino:7", "purple", [ "v-36", "h0" ] ], [ "7segment:C", "arduino:8", "blue", ["v20", "h-120", "*", "v-20"] ], [ "7segment:D", "arduino:9", "cyan", [ "v16", "h-94", "*", "v-24" ] ], [ "7segment:E", "arduino:10", "green", ["v12", "h-80", "*", "v-28"] ], [ "7segment:F", "arduino:11", "brown", [ "v-40", "h0" ] ], [ "7segment:G", "arduino:12", "orange", ["v24", "h-134", "*", "v-32"] ], [ "7segment:CLN", "arduino:13", "cyan", [ "v-44", "h0" ] ], [ "7segment:COM", "arduino:5V", "red", [ "v300", "h0" ] ], [ "buzzer1:1", "arduino:GND.2", "black", [] ], [ "buzzer1:2", "arduino:A3", "orange", [] ], [ "pushbutton1:1.l", "arduino:A0", "green", [ "h-4", "v0", "*", "v20" ] ], [ "pushbutton1:2.l", "arduino:GND.2", "black", [ "*", "v34" ] ], [ "pushbutton2:1.l", "arduino:A1", "gray", [ "h-4", "v0", "*", "v24" ] ], [ "pushbutton2:2.l", "arduino:GND.2", "black", [ "*", "v34" ] ], [ "pushbutton3:1.l", "arduino:A2", "purple", [ "h-4", "v0", "*", "v28" ] ], [ "pushbutton3:2.l", "arduino:GND.2", "black", [ "*", "v34" ] ], [ "ds1307:GND", "arduino:GND.2", "black", [] ], [ "ds1307:5V", "arduino:5V", "red", [] ], [ "ds1307:SDA", "arduino:A4", "blue", [] ], [ "ds1307:SCL", "arduino:A5", "gold", [] ] ] }
Generate a diagram.json code for electronic safe
/** Arduino Electronic Safe Copyright (C) 2020, Uri Shaked. Released under the MIT License. */ #include <LiquidCrystal.h> #include <Keypad.h> #include <Servo.h> #include "SafeState.h" #include "icons.h" /* Locking mechanism definitions */ #define SERVO_PIN 6 #define SERVO_LOCK_POS 20 #define SERVO_UNLOCK_POS 90 Servo lockServo; /* Display */ LiquidCrystal lcd(12, 11, 10, 9, 8, 7); /* Keypad setup */ const byte KEYPAD_ROWS = 4; const byte KEYPAD_COLS = 4; byte rowPins[KEYPAD_ROWS] = {5, 4, 3, 2}; byte colPins[KEYPAD_COLS] = {A3, A2, A1, A0}; char keys[KEYPAD_ROWS][KEYPAD_COLS] = { {'1', '2', '3', 'A'}, {'4', '5', '6', 'B'}, {'7', '8', '9', 'C'}, {'*', '0', '#', 'D'} }; Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, KEYPAD_ROWS, KEYPAD_COLS); /* SafeState stores the secret code in EEPROM */ SafeState safeState; void lock() { lockServo.write(SERVO_LOCK_POS); safeState.lock(); } void unlock() { lockServo.write(SERVO_UNLOCK_POS); } void showStartupMessage() { lcd.setCursor(4, 0); lcd.print("Welcome!"); delay(1000); lcd.setCursor(0, 2); String message = "ArduinoSafe v1.0"; for (byte i = 0; i < message.length(); i++) { lcd.print(message[i]); delay(100); } delay(500); } String inputSecretCode() { lcd.setCursor(5, 1); lcd.print("[____]"); lcd.setCursor(6, 1); String result = ""; while (result.length() < 4) { char key = keypad.getKey(); if (key >= '0' && key <= '9') { lcd.print('*'); result += key; } } return result; } void showWaitScreen(int delayMillis) { lcd.setCursor(2, 1); lcd.print("[..........]"); lcd.setCursor(3, 1); for (byte i = 0; i < 10; i++) { delay(delayMillis); lcd.print("="); } } bool setNewCode() { lcd.clear(); lcd.setCursor(0, 0); lcd.print("Enter new code:"); String newCode = inputSecretCode(); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Confirm new code"); String confirmCode = inputSecretCode(); if (newCode.equals(confirmCode)) { safeState.setCode(newCode); return true; } else { lcd.clear(); lcd.setCursor(1, 0); lcd.print("Code mismatch"); lcd.setCursor(0, 1); lcd.print("Safe not locked!"); delay(2000); return false; } } void showUnlockMessage() { lcd.clear(); lcd.setCursor(0, 0); lcd.write(ICON_UNLOCKED_CHAR); lcd.setCursor(4, 0); lcd.print("Unlocked!"); lcd.setCursor(15, 0); lcd.write(ICON_UNLOCKED_CHAR); delay(1000); } void safeUnlockedLogic() { lcd.clear(); lcd.setCursor(0, 0); lcd.write(ICON_UNLOCKED_CHAR); lcd.setCursor(2, 0); lcd.print(" # to lock"); lcd.setCursor(15, 0); lcd.write(ICON_UNLOCKED_CHAR); bool newCodeNeeded = true; if (safeState.hasCode()) { lcd.setCursor(0, 1); lcd.print(" A = new code"); newCodeNeeded = false; } auto key = keypad.getKey(); while (key != 'A' && key != '#') { key = keypad.getKey(); } bool readyToLock = true; if (key == 'A' || newCodeNeeded) { readyToLock = setNewCode(); } if (readyToLock) { lcd.clear(); lcd.setCursor(5, 0); lcd.write(ICON_UNLOCKED_CHAR); lcd.print(" "); lcd.write(ICON_RIGHT_ARROW); lcd.print(" "); lcd.write(ICON_LOCKED_CHAR); safeState.lock(); lock(); showWaitScreen(100); } } void safeLockedLogic() { lcd.clear(); lcd.setCursor(0, 0); lcd.write(ICON_LOCKED_CHAR); lcd.print(" Safe Locked! "); lcd.write(ICON_LOCKED_CHAR); String userCode = inputSecretCode(); bool unlockedSuccessfully = safeState.unlock(userCode); showWaitScreen(200); if (unlockedSuccessfully) { showUnlockMessage(); unlock(); } else { lcd.clear(); lcd.setCursor(0, 0); lcd.print("Access Denied!"); showWaitScreen(1000); } } void setup() { lcd.begin(16, 2); init_icons(lcd); lockServo.attach(SERVO_PIN); /* Make sure the physical lock is sync with the EEPROM state */ Serial.begin(115200); if (safeState.locked()) { lock(); } else { unlock(); } showStartupMessage(); } void loop() { if (safeState.locked()) { safeLockedLogic(); } else { safeUnlockedLogic(); } }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "id": "uno", "type": "wokwi-arduino-uno", "top": 200, "left": 20 }, { "id": "keypad", "type": "wokwi-membrane-keypad", "left": 360, "top": 140 }, { "id": "servo", "type": "wokwi-servo", "left": 400, "top": 20, "attrs": { "hornColor": "black" } }, { "id": "lcd", "type": "wokwi-lcd1602", "top": 8, "left": 20 }, { "id": "r1", "type": "wokwi-resistor", "top": 140, "left": 220, "attrs": { "value": "220" } } ], "connections": [ ["uno:GND.1", "lcd:VSS", "black", ["v-51", "*", "h0", "v18"]], ["uno:GND.1", "lcd:K", "black", ["v-51", "*", "h0", "v18"]], ["uno:GND.1", "lcd:RW", "black", ["v-51", "*", "h0", "v18"]], ["uno:5V", "lcd:VDD", "red", ["v16", "h-16"]], ["uno:5V", "r1:2", "red", ["v16", "h-118", "v-244", "h50"]], ["r1:1", "lcd:A", "pink", []], ["uno:12", "lcd:RS", "blue", ["v-16", "*", "h0", "v20"]], ["uno:11", "lcd:E", "purple", ["v-20", "*", "h0", "v20"]], ["uno:10", "lcd:D4", "green", ["v-24", "*", "h0", "v20"]], ["uno:9", "lcd:D5", "brown", ["v-28", "*", "h0", "v20"]], ["uno:8", "lcd:D6", "gold", ["v-32", "*", "h0", "v20"]], ["uno:7", "lcd:D7", "gray", ["v-36", "*", "h0", "v20"]], ["uno:6", "servo:PWM", "orange", ["v-40", "*", "h0", "h-52"]], ["uno:5V", "servo:V+", "red", ["v16", "h-118", "v-244", "*", "h-56"]], ["uno:GND.1", "servo:GND", "black", ["v-46", "*", "v88", "h-60"]], ["uno:A3", "keypad:C1", "brown", ["v116", "*", "h0", "v0"]], ["uno:A2", "keypad:C2", "gray", ["v120", "*", "h0", "v0"]], ["uno:A1", "keypad:C3", "orange", ["v124", "*", "h0", "v0"]], ["uno:A0", "keypad:C4", "pink", ["v128", "*", "h0", "v0"]], ["uno:5", "keypad:R1", "blue", ["v-34", "h96", "*", "v12"]], ["uno:4", "keypad:R2", "green", ["v-30", "h80", "*", "v16"]], ["uno:3", "keypad:R3", "purple", ["v-26", "h64", "*", "v20"]], ["uno:2", "keypad:R4", "gold", ["v-22", "h48", "*", "v24"]] ] }
Generate a diagram.json code for nano pong
/* A simple Pong game. https://notabug.org/Maverick/WokwiPong Based on Arduino Pong by eholk https://github.com/eholk/Arduino-Pong */ #include <SPI.h> #include <Wire.h> #include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #define UP_BUTTON 2 #define DOWN_BUTTON 3 const unsigned long PADDLE_RATE = 64; const unsigned long BALL_RATE = 16; const uint8_t PADDLE_HEIGHT = 12; const uint8_t SCORE_LIMIT = 9; Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &Wire); bool game_over, win; uint8_t player_score, mcu_score; uint8_t ball_x = 53, ball_y = 26; uint8_t ball_dir_x = 1, ball_dir_y = 1; unsigned long ball_update; unsigned long paddle_update; const uint8_t MCU_X = 12; uint8_t mcu_y = 16; const uint8_t PLAYER_X = 115; uint8_t player_y = 16; void setup() { display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // Display the splash screen (we're legally required to do so) display.display(); unsigned long start = millis(); pinMode(UP_BUTTON, INPUT_PULLUP); pinMode(DOWN_BUTTON, INPUT_PULLUP); display.clearDisplay(); drawCourt(); while(millis() - start < 2000); display.display(); ball_update = millis(); paddle_update = ball_update; } void loop() { bool update_needed = false; unsigned long time = millis(); static bool up_state = false; static bool down_state = false; up_state |= (digitalRead(UP_BUTTON) == LOW); down_state |= (digitalRead(DOWN_BUTTON) == LOW); if(time > ball_update) { uint8_t new_x = ball_x + ball_dir_x; uint8_t new_y = ball_y + ball_dir_y; // Check if we hit the vertical walls if(new_x == 0 || new_x == 127) { ball_dir_x = -ball_dir_x; new_x += ball_dir_x + ball_dir_x; if (new_x < 64) { player_scoreTone(); player_score++; } else { mcu_scoreTone(); mcu_score++; } if (player_score == SCORE_LIMIT || mcu_score == SCORE_LIMIT) { win = player_score > mcu_score; game_over = true; } } // Check if we hit the horizontal walls. if(new_y == 0 || new_y == 53) { wallTone(); ball_dir_y = -ball_dir_y; new_y += ball_dir_y + ball_dir_y; } // Check if we hit the CPU paddle if(new_x == MCU_X && new_y >= mcu_y && new_y <= mcu_y + PADDLE_HEIGHT) { mcuPaddleTone(); ball_dir_x = -ball_dir_x; new_x += ball_dir_x + ball_dir_x; } // Check if we hit the player paddle if(new_x == PLAYER_X && new_y >= player_y && new_y <= player_y + PADDLE_HEIGHT) { playerPaddleTone(); ball_dir_x = -ball_dir_x; new_x += ball_dir_x + ball_dir_x; } display.drawPixel(ball_x, ball_y, BLACK); display.drawPixel(new_x, new_y, WHITE); ball_x = new_x; ball_y = new_y; ball_update += BALL_RATE; update_needed = true; } if(time > paddle_update) { paddle_update += PADDLE_RATE; // CPU paddle display.drawFastVLine(MCU_X, mcu_y, PADDLE_HEIGHT, BLACK); const uint8_t half_paddle = PADDLE_HEIGHT >> 1; if(mcu_y + half_paddle > ball_y) { int8_t dir = ball_x > MCU_X ? -1 : 1; mcu_y += dir; } if(mcu_y + half_paddle < ball_y) { int8_t dir = ball_x > MCU_X ? 1 : -1; mcu_y += dir; } if(mcu_y < 1) { mcu_y = 1; } if(mcu_y + PADDLE_HEIGHT > 53) { mcu_y = 53 - PADDLE_HEIGHT; } // Player paddle display.drawFastVLine(MCU_X, mcu_y, PADDLE_HEIGHT, WHITE); display.drawFastVLine(PLAYER_X, player_y, PADDLE_HEIGHT, BLACK); if(up_state) { player_y -= 1; } if(down_state) { player_y += 1; } up_state = down_state = false; if(player_y < 1) { player_y = 1; } if(player_y + PADDLE_HEIGHT > 53) { player_y = 53 - PADDLE_HEIGHT; } display.drawFastVLine(PLAYER_X, player_y, PADDLE_HEIGHT, WHITE); update_needed = true; } if(update_needed) { if (game_over) { const char* text = win ? "YOU WIN!!" : "YOU LOSE!"; display.clearDisplay(); display.setCursor(40, 28); display.print(text); display.display(); delay(5000); display.clearDisplay(); ball_x = 53; ball_y = 26; ball_dir_x = 1; ball_dir_y = 1; mcu_y = 16; player_y = 16; mcu_score = 0; player_score = 0; game_over = false; drawCourt(); } display.setTextColor(WHITE, BLACK); display.setCursor(0, 56); display.print(mcu_score); display.setCursor(122, 56); display.print(player_score); display.display(); } } void playerPaddleTone() { tone(11, 250, 25); delay(25); noTone(11); } void mcuPaddleTone() { tone(11, 225, 25); delay(25); noTone(11); } void wallTone() { tone(11, 200, 25); delay(25); noTone(11); } void player_scoreTone() { tone(11, 200, 25); delay(50); noTone(11); delay(25); tone(11, 250, 25); delay(25); noTone(11); } void mcu_scoreTone() { tone(11, 250, 25); delay(25); noTone(11); delay(25); tone(11, 200, 25); delay(25); noTone(11); } void drawCourt() { display.drawRect(0, 0, 128, 54, WHITE); }
{ "version": 1, "author": "Maverick", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": 0, "left": 0, "attrs": {} }, { "type": "board-ssd1306", "id": "oled1", "top": 89.5, "left": 19.05, "attrs": {} }, { "type": "wokwi-pushbutton", "id": "btn1", "top": 87.7, "left": 136.24, "attrs": { "color": "green", "key": "ArrowUp" } }, { "type": "wokwi-pushbutton", "id": "btn2", "top": 134.3, "left": 135.54, "attrs": { "color": "green", "key": "ArrowDown" } }, { "type": "wokwi-buzzer", "id": "bz1", "top": -103.22, "left": 59.98, "attrs": { "volume": "0.1" } }, { "type": "wokwi-resistor", "id": "r1", "top": -22.03, "left": 29.82, "attrs": { "value": "1000" } } ], "connections": [ [ "nano:A4", "oled1:SDA", "gold", [ "v0" ] ], [ "oled1:SCL", "nano:A5", "cyan", [ "v-20.36", "h20.38" ] ], [ "oled1:VCC", "nano:3.3V", "red", [ "v-20.07", "h-37.37" ] ], [ "oled1:GND", "nano:GND.1", "black", [ "v-12.82", "h87.28" ] ], [ "btn1:2.l", "btn2:2.l", "black", [ "h-6.06", "v46.8" ] ], [ "btn1:2.l", "nano:GND.1", "black", [ "h-6.51", "v-36.84", "h14.77" ] ], [ "btn1:1.r", "nano:2", "black", [ "h13.06", "v-114.15", "h-100.6" ] ], [ "btn2:1.r", "nano:3", "black", [ "v-0.29", "h14.22", "v-160.46", "h-110.66" ] ], [ "bz1:2", "r1:2", "red", [ "v0" ] ], [ "r1:1", "nano:11", "red", [ "h-0.55", "v50.86" ] ], [ "bz1:1", "nano:GND.2", "black", [ "h34.91", "v64.63" ] ] ] }
Generate a diagram.json code for touch lcd breakout game
#include <SD.h> #include <adafruit_1947_Obj.h> #include <screen.h> #include "ourOSObj.h" ourOSObj ourOS; void setup() { Serial.begin(57600); // Fire up serial for debugging. if (!initScreen(ADAFRUIT_1947,ADA_1947_SHIELD_CS,PORTRAIT)) { // Init screen. Serial.println("NO SCREEN!"); // Screen init failed. Tell user. Serial.flush(); // Make sure the message gets out. while(true); // Lock the process here. } if (!SD.begin(ADA_1947_SHIELD_SDCS)) { // With icons, we now MUST have an SD card. Serial.println("NO SD CARD!"); // Tell user we have no SD card. Serial.flush(); // Make sure the message gets out. while(true); // Lock the process here. } ourEventMgr.begin(); // Startup our event manager. ourOS.begin(); // Boot OS manager. nextPanel = breakoutApp; // <<-- URISH LOOK HERE!! } void loop() { // During loop.. idle(); // Idlers get their time. ourOS.loop(); // ourOS gets time to pass on to the current panel. }
{ "version": 1, "author": "Jim Lee", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-mega", "id": "mega", "top": 272.86, "left": -34.52, "attrs": { "__fakeRamSize": "65000" } }, { "type": "board-ili9341-cap-touch", "id": "lcd1", "top": -149.52, "left": 75.06, "attrs": {} }, { "type": "wokwi-microsd-card", "id": "sd1", "top": 39.23, "left": 395.41, "rotate": 90, "attrs": {} }, { "type": "wokwi-buzzer", "id": "bz1", "top": 481.7, "left": 153.47, "attrs": { "volume": "0.025" } } ], "connections": [ [ "mega:GND.1", "lcd1:GND", "black", [ "v-53", "h-5" ] ], [ "mega:52", "lcd1:SCK", "white", [ "v-54", "h19" ] ], [ "mega:50", "lcd1:MISO", "green", [ "v-43", "h35" ] ], [ "mega:51", "lcd1:MOSI", "blue", [ "v0", "h-197", "v-226", "h112" ] ], [ "mega:53", "lcd1:D/C", "yellow", [ "v-67", "h-28" ] ], [ "mega:5V", "lcd1:VCC", "red", [ "v26", "h-197", "v-226", "h112" ] ], [ "mega:10", "lcd1:CS", "red", [ "v-90", "h-31" ] ], [ "mega:20", "lcd1:SDA", "blue", [ "v24" ] ], [ "mega:52", "sd1:SCK", "white", [ "v-54", "h19" ] ], [ "mega:50", "sd1:DO", "green", [ "v-43", "h35" ] ], [ "mega:53", "sd1:CD", "yellow", [ "v-67", "h-28" ] ], [ "mega:4", "sd1:CS", "green", [ "v-87", "h63" ] ], [ "mega:5V", "sd1:VCC", "red", [ "v26.06", "h273", "v-325.06", "h27.3" ] ], [ "mega:GND.1", "sd1:GND", "black", [ "v-53", "h152" ] ], [ "mega:51", "sd1:DI", "blue", [ "v-2.49", "h31.94", "v-286.49", "h50.95" ] ], [ "mega:21", "lcd1:SCL", "white", [ "v-120.21", "h-4.54" ] ], [ "mega:GND.2", "bz1:1", "black", [ "v0" ] ], [ "mega:14", "bz1:2", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for dino game
// A simple T-rex Run game based on the 30DLIS kit // Developed by Ishani and Arijit Sengupta // Required libraries #include <U8glib.h> #include "TM1637Display.h" // HW Pins required #define SW 3 // RotaryEncoder SW Pin #define DT 4 // RotaryEncoder DT Pin #define CLK 2 // RotaryEncoder CLK Pin // Define the display connections pins: #define DCLK 6 #define DIO 5 // pin 10 drives the buzzer #define buzzer 10 // In Addition, this sketch uses the I2C Pins for the U8G Panel // A1+A2 // Create display object of type TM1637Display // The display shows the current score TM1637Display OurDisplay = TM1637Display(DCLK, DIO); // Create array that turns all segments off: const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00}; // 0xff is a hexidecimal number whose binary // representation is all zeros // Create the oled display object - this shows gameplay // and welcome/win/loss messages U8GLIB_SH1106_128X64 My_u8g_Panel(U8G_I2C_OPT_NONE); // I2C / TWI /* For documentation on u8glib functions: https://github.com/olikraus/u8glib/wiki/userreference */ // Sounds we use for the hit effects #define jumpSound 700 #define blahSound 125 #define speedSound 1000 #define DBOUNCE 180 // Game states #define gameStart 0 #define gameEnd 1 #define gamePlaying 2 volatile int gameStatus = gameStart; // PRE-SAVED BITMAP CONSTANTS //20 x 21 static unsigned char dinoJump [] U8G_PROGMEM = { 0x00, 0xFC, 0x07, 0x00, 0xFE, 0x07, 0x00, 0xEE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x07, 0x06, 0xFF, 0x03, 0xC3, 0xFF, 0x00, 0xE7, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x3F, 0x00, 0xFE, 0x3F, 0x00, 0xFC, 0x1F, 0x00, 0xF8, 0x1F, 0x00, 0xF0, 0x1F, 0x00, 0xF0, 0x0E, 0x00, 0x60, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x1E, 0x00, }; //20 x 21 static unsigned char dinoLeft [] U8G_PROGMEM = { 0x00, 0xFC, 0x07, 0x00, 0xFE, 0x07, 0x00, 0xEE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0x7E, 0x08, 0x00, 0x7E, 0x00, 0x06, 0xFF, 0x03, 0x87, 0x3F, 0x00, 0xE7, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x3F, 0x00, 0xFE, 0x3F, 0x00, 0xFC, 0x1F, 0x00, 0xF8, 0x1F, 0x00, 0xF0, 0x1F, 0x00, 0xE0, 0x1E, 0x00, 0x60, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, }; //20 x 21 static unsigned char dinoRight [] U8G_PROGMEM = { 0x00, 0xFC, 0x07, 0x00, 0xEE, 0x07, 0x00, 0xE6, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0x7C, 0x00, 0x06, 0xFF, 0x03, 0xC3, 0xFF, 0x00, 0xE7, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x3F, 0x00, 0xFE, 0x3F, 0x00, 0xFC, 0x1F, 0x00, 0xF8, 0x1F, 0x00, 0xF0, 0x1F, 0x00, 0xF0, 0x0F, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x1E, 0x00, }; //shape 0: 39 x 12 static unsigned char cloud [] U8G_PROGMEM = { 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xBE, 0x03, 0x00, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x80, 0x01, 0x04, 0x00, 0x00, 0x40, 0x00, 0x1C, 0x00, 0x00, 0x40, 0x00, 0xE4, 0x03, 0x00, 0x18, 0x00, 0x00, 0x02, 0xE0, 0x0F, 0x00, 0x00, 0x0E, 0x30, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x40, 0x03, 0xFF, 0xFF, 0xFF, 0x7F, }; //shape 1: 10 x 20 static unsigned char oneCactus [] U8G_PROGMEM = { 0x30, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x01, 0xFB, 0x03, 0xFF, 0x03, 0xFF, 0x03, 0xFF, 0x03, 0xFF, 0x03, 0xFF, 0x03, 0xFF, 0x01, 0xFE, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x00, 0x00, }; //shape 2: 20 x 20 static unsigned char twoCactus [] U8G_PROGMEM = { 0x30, 0xC0, 0x00, 0x38, 0xE0, 0x00, 0x38, 0xE8, 0x00, 0x38, 0xEC, 0x00, 0x38, 0xED, 0x04, 0xBB, 0xED, 0x0E, 0xBB, 0xED, 0x0E, 0xBB, 0xFD, 0x0E, 0xBB, 0xFD, 0x0E, 0xBB, 0xF9, 0x0E, 0xFF, 0xF1, 0x0F, 0xFF, 0xE0, 0x07, 0x7E, 0xE0, 0x01, 0x38, 0xE0, 0x00, 0x38, 0xE0, 0x00, 0x38, 0xE0, 0x00, 0x38, 0xE0, 0x00, 0x38, 0xE0, 0x00, 0x38, 0xE0, 0x00, 0x00, 0x00, 0x00, }; //shape 3: 20 x 20 static unsigned char threeCactus [] U8G_PROGMEM = { 0x00, 0xC0, 0x00, 0x18, 0xC0, 0x01, 0x18, 0xC0, 0x01, 0x58, 0xD8, 0x01, 0x58, 0xFC, 0x01, 0x58, 0xFC, 0x0F, 0x78, 0xDC, 0x0F, 0x7F, 0xFC, 0x0F, 0x3B, 0xFD, 0x0D, 0x1B, 0xF9, 0x0C, 0x5B, 0xF5, 0x0F, 0x5B, 0xC5, 0x07, 0x5F, 0xE7, 0x03, 0xDE, 0xE7, 0x01, 0xD8, 0xC3, 0x01, 0x98, 0xC1, 0x01, 0x18, 0xC1, 0x01, 0x18, 0xC1, 0x01, 0x18, 0xE1, 0x01, 0x00, 0x00, 0x00, }; //shape 4: 6 x 12 static unsigned char oneCactusSmall [] U8G_PROGMEM = { 0x0C, 0x0C, 0x3C, 0x3D, 0x2D, 0x3D, 0x1D, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, }; //shape 5: 12 x 12 static unsigned char twoCactusSmall [] U8G_PROGMEM = { 0x0C, 0x03, 0x0C, 0x03, 0x6C, 0x0B, 0x6D, 0x0B, 0x6D, 0x0B, 0xBD, 0x0B, 0x1F, 0x0F, 0x0E, 0x03, 0x0C, 0x03, 0x0C, 0x03, 0x0C, 0x03, 0x0C, 0x03, }; //shape 6: 17 x 12 static unsigned char threeCactusSmall [] U8G_PROGMEM = { 0x04, 0x41, 0x00, 0x0C, 0x61, 0x00, 0xFC, 0x79, 0x01, 0xFD, 0x7D, 0x01, 0x7D, 0x6D, 0x01, 0x7D, 0x7D, 0x01, 0xCF, 0xE5, 0x01, 0xCE, 0x67, 0x00, 0x8C, 0x67, 0x00, 0x0C, 0x63, 0x00, 0x0C, 0x61, 0x00, 0x0C, 0x61, 0x00, }; static unsigned char dinoBlah [] U8G_PROGMEM = { 0x00, 0xFC, 0x07, 0x00, 0xFE, 0x07, 0x00, 0xC6, 0x0F, 0x00, 0xC6, 0x0F, 0x00, 0xCE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x06, 0xFF, 0x03, 0x87, 0x7F, 0x00, 0xE7, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x3F, 0x00, 0xFE, 0x3F, 0x00, 0xFC, 0x1F, 0x00, 0xF8, 0x1F, 0x00, 0xF0, 0x1F, 0x00, 0xF0, 0x0E, 0x00, 0x60, 0x0E, 0x00, 0x60, 0x0E, 0x00, 0xE0, 0x1E, 0x00, }; static unsigned char gameOver [] U8G_PROGMEM = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x02, 0x0C, 0x0C, 0x3E, 0x00, 0x78, 0x60, 0x30, 0x7C, 0xF0, 0x01, 0x0C, 0x01, 0x07, 0x14, 0x0A, 0x02, 0x00, 0x84, 0x40, 0x10, 0x04, 0x10, 0x02, 0x04, 0x00, 0x05, 0x14, 0x0A, 0x02, 0x00, 0x02, 0x41, 0x10, 0x04, 0x10, 0x02, 0x04, 0x00, 0x05, 0x14, 0x0A, 0x02, 0x00, 0x02, 0xC1, 0x18, 0x04, 0x10, 0x02, 0xC4, 0x81, 0x0D, 0x34, 0x0B, 0x3E, 0x00, 0x02, 0x81, 0x08, 0x7C, 0xF0, 0x01, 0x04, 0x81, 0x08, 0x24, 0x09, 0x02, 0x00, 0x02, 0x81, 0x0D, 0x04, 0x10, 0x01, 0x04, 0x81, 0x0F, 0x64, 0x09, 0x02, 0x00, 0x02, 0x01, 0x05, 0x04, 0x10, 0x02, 0x0C, 0xC1, 0x18, 0xC4, 0x08, 0x02, 0x00, 0x84, 0x00, 0x05, 0x04, 0x10, 0x02, 0xF8, 0x41, 0x10, 0xC4, 0x08, 0x3E, 0x00, 0x78, 0x00, 0x07, 0x7C, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; // Other Game attributes // various variables int currentStateCLK; int lastStateCLK; int MyScore = 0; int dinoMove = 0; volatile int jumping = 0; int cloudx = 128; int obstacles [2] = {1, 4}; int obstaclex [2] = {128, 200}; int speed = 8; unsigned long startTime = millis(), curTime; int lastBeep = 0; // Display the score on the 7seg display void ShowScore () { if (gameStatus == gamePlaying) { curTime = millis (); MyScore = (curTime - startTime) * speed / 1000; OurDisplay.showNumberDecEx(MyScore); if (MyScore / 100 > lastBeep) { tone (buzzer, 1000, 100); delay (150); tone (buzzer, 1250, 100); lastBeep = MyScore / 100; } } } void StartStopGame () { static unsigned long last_interrupt = 0; if (millis() - last_interrupt > DBOUNCE) { if (gameStatus == gamePlaying) { if (jumping == 0) { jumping = 1; tone (buzzer, jumpSound, 100); } } else if (gameStatus == gameStart) gameStatus = gamePlaying; else gameStatus = gameStart; } last_interrupt = millis(); //note the last time the ISR was called } void resetGame () { MyScore = 0; startTime = millis(); obstaclex[0] = 128; obstaclex [1] = 200; dinoMove = 0; } void setup() { OurDisplay.setBrightness(7); OurDisplay.clear(); resetGame(); ShowScore (); pinMode(CLK, INPUT); pinMode(DT, INPUT); pinMode(SW, INPUT_PULLUP); pinMode(buzzer, OUTPUT); attachInterrupt(digitalPinToInterrupt(SW), StartStopGame, FALLING); } // ************************************************ void loop(void) { ShowScore(); My_u8g_Panel.firstPage(); do { draw(); } while ( My_u8g_Panel.nextPage() ); if (gameStatus == gamePlaying) { moveDino(); moveCloud(); moveObstacles(); } } void moveDino () { if (jumping == 0) dinoMove = (dinoMove + 1) % 3; else { if (jumping == 1) { dinoMove = dinoMove + 8; if (dinoMove > 32) jumping = 2; } else { dinoMove = dinoMove - 8; if (dinoMove < 8) { jumping = 0; dinoMove = 0; } } } checkCollision (); } void moveCloud () { cloudx --; if (cloudx < -38) cloudx = 128; } void moveObstacles() { int obx = obstaclex [0]; obx = obx - speed; if (obx < -20) { obstaclex[0] = obstaclex[1]; obstaclex[1] = obstaclex[0] + random(80, 125); obstacles[0] = obstacles[1]; obstacles[1] = random (1, 6); } else { obstaclex[0] = obx; obstaclex[1] -= speed; } } // ************************************************ void draw(void) { u8g_prepare(); if (gameStatus == gamePlaying) { drawDino (); drawShape (0, cloudx); drawObsticles (); } else if (gameStatus == gameStart) { My_u8g_Panel.drawStr( 0, 10, "Welcome to"); My_u8g_Panel.drawStr( 10, 30, "Dino!!"); My_u8g_Panel.drawStr( 0, 50, "Push to begin"); resetGame(); ShowScore(); } else { My_u8g_Panel.drawXBMP( 14, 12, 100, 15, gameOver); drawDino (); drawShape (0, cloudx); drawObsticles (); } } void drawDino (void) { if (gameStatus == gameEnd) { My_u8g_Panel.drawXBMP( 0, 43 - dinoMove, 20, 21, dinoBlah); return; } switch (dinoMove) { case -1: My_u8g_Panel.drawXBMP( 0, 43, 20, 21, dinoBlah); break; case 0: My_u8g_Panel.drawXBMP( 0, 43, 20, 21, dinoJump); break; case 1: My_u8g_Panel.drawXBMP( 0, 43, 20, 21, dinoLeft); break; case 2: My_u8g_Panel.drawXBMP( 0, 43, 20, 21, dinoRight); break; default: My_u8g_Panel.drawXBMP( 0, 43 - dinoMove, 20, 21, dinoJump); break; } } void drawShape (int shape, int x) { switch (shape) { case 0: My_u8g_Panel.drawXBMP( x, 5, 39, 12, cloud); break; case 1: My_u8g_Panel.drawXBMP( x, 44, 10, 20, oneCactus); break; case 2: My_u8g_Panel.drawXBMP( x, 44, 20, 20, twoCactus); break; case 3: My_u8g_Panel.drawXBMP( x, 44, 20, 20, threeCactus); break; case 4: My_u8g_Panel.drawXBMP( x, 52, 6, 12, oneCactusSmall); break; case 5: My_u8g_Panel.drawXBMP( x, 52, 12, 12, twoCactusSmall); break; case 6: My_u8g_Panel.drawXBMP( x, 52, 17, 12, threeCactusSmall); break; } } void checkCollision () { int obx = obstaclex [0]; int obw, obh; switch (obstacles[0]) { case 0: obw = 39; obh = 10; break; case 1: obw = 10; obh = 20; break; case 2: obw = 17; obh = 20; break; case 3: obw = 17; obh = 20; break; case 4: obw = 6; obh = 12; break; case 5: obw = 12; obh = 12; break; case 6: obw = 17; obh = 12; break; } if (obx > 15 || obx + obw < 5 || dinoMove > obh - 3) {} else { gameStatus = gameEnd; tone (buzzer, 125, 100); delay(150); tone (buzzer, 125, 100); } } void drawObsticles () { drawShape (obstacles[0], obstaclex[0]); drawShape (obstacles[1], obstaclex[1]); } void u8g_prepare(void) { My_u8g_Panel.setFont(u8g_font_6x10); My_u8g_Panel.setFontRefHeightExtendedText(); My_u8g_Panel.setDefaultForegroundColor(); My_u8g_Panel.setFontPosTop(); }
{ "version": 1, "author": "Ami Sung", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 90.93, "left": -190.84, "attrs": {} }, { "type": "board-ssd1306", "id": "oled1", "top": 121.27, "left": 158.38, "attrs": {} }, { "type": "wokwi-ky-040", "id": "encoder1", "top": 268.93, "left": 115.97, "attrs": {} }, { "type": "wokwi-buzzer", "id": "bz1", "top": -41.84, "left": 252.89, "attrs": { "volume": "0.1" } }, { "type": "wokwi-tm1637-7segment", "id": "sevseg1", "top": -44.94, "left": 37.09, "attrs": { "color": "red" } } ], "connections": [ [ "sevseg1:VCC", "uno:5V", "red", [ "h29.56", "v70.22", "h-142.27", "v268.59", "h-125.71" ] ], [ "encoder1:VCC", "uno:5V", "red", [ "h21.09", "v71.64", "h-283.92" ] ], [ "oled1:VCC", "uno:5V", "red", [ "v-37.85", "h-100.73", "v260", "h-135.52" ] ], [ "sevseg1:GND", "uno:GND.1", "black", [ "h-1.1", "v38.55", "h-286.37" ] ], [ "bz1:1", "uno:GND.1", "black", [ "v16.61", "h-356.06" ] ], [ "oled1:GND", "uno:GND.3", "black", [ "v-22.52", "h-102.93", "v205.43", "h-95.66" ] ], [ "encoder1:GND", "uno:GND.2", "black", [ "h14.96", "v51.4", "h-263.68" ] ], [ "encoder1:SW", "uno:3", "gray", [ "h14.47", "v-73.42", "h-102.32", "v-157.92", "h-97.87" ] ], [ "encoder1:DT", "uno:4", "gold", [ "h5.58", "v-54.93", "h-100.09", "v-148.29", "h-110.47" ] ], [ "encoder1:CLK", "uno:2", "orange", [ "h-1.1", "v-35.79", "h-103.06", "v-143.84" ] ], [ "bz1:2", "uno:10", "purple", [ "v15.53", "h50.01", "v-147.54", "h-370.71" ] ], [ "sevseg1:DIO", "uno:5", "green", [ "h28.05", "v-57.18", "h-218.72" ] ], [ "sevseg1:CLK", "uno:6", "green", [ "h18.41", "v-56.48", "h-224.65" ] ], [ "oled1:SCL", "uno:A5", "blue", [ "v-34.37", "h57.64", "v303.38", "h-198.32" ] ], [ "oled1:SDA", "uno:A4", "green", [ "v-23.17", "h61.03", "v300.18", "h-229.18" ] ] ] }
Generate a diagram.json code for Four LED blink series
int led5=5; int led6=6; int led7=7; int led8=8; void setup() { pinMode(led5,OUTPUT); pinMode(led6,OUTPUT); pinMode(led7,OUTPUT); pinMode(led8,OUTPUT); Serial.begin(9600); } void loop() { digitalWrite(led5,HIGH); digitalWrite(led6,LOW); digitalWrite(led7,LOW); digitalWrite(led8,LOW); delay(500); digitalWrite(led5,LOW); digitalWrite(led6,HIGH); digitalWrite(led7,LOW); digitalWrite(led8,LOW); delay(500); digitalWrite(led5,LOW); digitalWrite(led6,LOW); digitalWrite(led7,HIGH); digitalWrite(led8, LOW); delay(500); digitalWrite(led5, LOW); digitalWrite(led6, LOW); digitalWrite(led7, LOW); digitalWrite(led8, HIGH); delay(500); }
{ "version": 1, "author": "salwa nafisya9.3", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 106.2, "left": 18.6, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -42, "left": 263, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -42, "left": 157.4, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led3", "top": -42, "left": 61.4, "attrs": { "color": "purple" } }, { "type": "wokwi-led", "id": "led4", "top": -42, "left": -34.6, "attrs": { "color": "green" } } ], "connections": [ [ "led1:A", "uno:8", "green", [ "v76.8", "h-96" ] ], [ "led2:A", "uno:7", "green", [ "v67.2", "h9.6" ] ], [ "led3:A", "uno:6", "green", [ "v57.6", "h124.8" ] ], [ "led4:A", "uno:5", "green", [ "v48", "h230.4" ] ], [ "led3:C", "uno:GND.1", "green", [ "v86.4", "h58" ] ], [ "led4:C", "uno:GND.1", "green", [ "v76.8", "h154", "v28.8" ] ], [ "led2:C", "uno:GND.1", "green", [ "v76.8", "h-38" ] ], [ "led1:C", "uno:GND.1", "green", [ "v86.4", "h-143.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for test Arduino
int TIME_INTERVAL = 0; bool isReady = false; void setup() { // put your setup code here, to run once: pinMode(13, OUTPUT); } void loop() { // put your main code here, to run repeatedly: TIME_INTERVAL++; digitalWrite(13, LOW); if(TIME_INTERVAL == 500) { isReady = true; TIME_INTERVAL = 0; } else { return; } if(isReady == true) { digitalWrite(13, HIGH); isReady = false; } }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0.6, "left": 9, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -70.8, "left": 109.4, "attrs": { "color": "red" } } ], "connections": [ [ "uno:13", "led1:C", "green", [ "v0" ] ], [ "led1:A", "uno:8", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for SUP_LCD
#include <Arduino.h> #include "timer_System.h" #include "inps_manager.h" #include "asciitohex.h" #define VIEW_MENU 1 #define INC_MENU 2 #define DEC_MENU 3 const int KEY_MENU = 7; const int KEY_INC = 8; const int KEY_DEC = 9; const int DIGIT_1 = 6; const int DIGIT_2 = 5; const int DIGIT_3 = 4;const int DATA_SPI = 12; const int CLOCK_SPI = 11; const int LOAD_SPI = 10; uint8_t count = 16; typedef union _MENU_DEVICE { uint8_t value; struct { unsigned edit:2; unsigned param_sel:3; unsigned peram_edit:1; unsigned blinK_dsp:1; unsigned extend:1; }flags; }MENU_DEVICE; MENU_DEVICE info_menu; const uint16_t thresoldLow[3] = {85, 125, 5}; const uint16_t thresoldHigh[3] = {115, 140, 300}; uint16_t thresoldValue[3] = {100, 140, 20}; uint16_t paramToView[3] = {0}; void checkInputKeys(void); void vProcessKeys(uint8_t sel); void decimal_to_bcd(uint16_t decimal); void SetTimer1() { cli(); //stop interrupts //set timer1 interrupt at 120Hz TCCR1A = 0;// set entire TCCR1A register to 0 TCCR1B = 0;// same for TCCR1B TCNT1 = 0;//initialize counter value to 0 // set compare match register for 60hz increments OCR1A = 10000; // = (16*10^6) / (120 * 8) - 1 (must be <65536) //60Hz 16683 // turn on CTC mode TCCR1B |= (1 << WGM12); // Set CS10 and CS12 bits for 1024 prescaler //TCCR1B |= (1 << CS12) | (1 << CS10); // Set CS11 bit for 8 prescaler TCCR1B |= (1 << CS11); // enable timer compare interrupt TIMSK1 |= (1 << OCIE1A); sei(); //allow interrupts } ISR(TIMER1_COMPA_vect) { flagTickBase = 1; TimersSys_Tick(); inpManager_Refresh(); } void setup() { SetTimer1(); TimersSys_Init(); // Inicializa la estructuras de los 4 timers del sistema, en el header de la libreria TimersSys_Start(0, 10); // Inicializa 0 de TimerSys, de calibración 100 ms TimersSys_Start(1, 25); // Inicializa 1 de TimersSys: 250ms (25 * Tick de TMR2(10ms)) TimersSys_Start(2, 3); // Inicializa 2 de TimersSys: 30ms (3 * Tick de TMR2(10ms)) TimersSys_Start(3, 50); // Inicializa 2 de TimersSys: 30ms (3 * Tick de TMR2(10ms)) inpsManager_Init(); inpsManager_Cfg(0, KEY_MENU, INPUT_PULLUP); inpsManager_Cfg(1, KEY_INC, INPUT_PULLUP); inpsManager_Cfg(2, KEY_DEC, INPUT_PULLUP); Serial.begin(115200); // put your setup code here, to run once: /*pinMode(KEY_MENU, INPUT_PULLUP); pinMode(KEY_INC, INPUT_PULLUP);*/ pinMode(DIGIT_1, OUTPUT); pinMode(DIGIT_2, OUTPUT); pinMode(DIGIT_3, OUTPUT); pinMode(LOAD_SPI, OUTPUT); pinMode(CLOCK_SPI, OUTPUT); pinMode(DATA_SPI, OUTPUT); digitalWrite(DIGIT_1, HIGH); digitalWrite(DIGIT_2, HIGH); digitalWrite(DIGIT_3, HIGH); info_menu.value = 0; } void loop() { if (TIMERSYS_CHECK_EVENT(0)) // 100 ms { TIMERSYS_CLEAR_EVENT(0); checkInputKeys( ); } //llevar esta a 50 ms if (TIMERSYS_CHECK_EVENT(1)) // 250 ms { TIMERSYS_CLEAR_EVENT(1); } if (TIMERSYS_CHECK_EVENT(2)) //30ms { TIMERSYS_CLEAR_EVENT(2); if(++count >= 3) { count = 0; } if(info_menu.flags.edit == 0) { decimal_to_bcd(120); digitSelect(count, SevenSegmentASCII[paramToView[count]]); } else if(info_menu.flags.edit == 1) { digitSelect(count, MenutoDisplay[info_menu.flags.param_sel - 1][count]); } else if(info_menu.flags.edit == 2) { decimal_to_bcd(thresoldValue[info_menu.flags.param_sel - 1]); digitSelect(count, SevenSegmentASCII[paramToView[count]]); } } if (TIMERSYS_CHECK_EVENT(3)) //500s { TIMERSYS_CLEAR_EVENT(3); if(info_menu.flags.blinK_dsp == 0) { info_menu.flags.blinK_dsp = 1; } else { info_menu.flags.blinK_dsp = 0; } } } void checkInputKeys( ) { if(inpsInfo[0].b.change == 1) { inpsInfo[0].b.change = 0; if(!GET_INP_STATE(0)) { vProcessKeys(VIEW_MENU); } } if(inpsInfo[1].b.change == 1) { inpsInfo[1].b.change = 0; if(!GET_INP_STATE(1)) { vProcessKeys(INC_MENU); //Serial.println("INC"); } } if(inpsInfo[2].b.change == 1) { inpsInfo[2].b.change = 0; if(!GET_INP_STATE(2)) { vProcessKeys(DEC_MENU); //Serial.println("DEC"); } } } void digitSelect(uint8_t select, uint8_t value) { digitalWrite(DIGIT_1, HIGH); digitalWrite(DIGIT_2, HIGH); digitalWrite(DIGIT_3, HIGH); if(info_menu.flags.blinK_dsp == 1 && info_menu.flags.edit == 2) { return; } digitalWrite(LOAD_SPI, LOW); shiftOut(DATA_SPI, CLOCK_SPI, MSBFIRST, value); digitalWrite(LOAD_SPI, HIGH); switch(select) { case 0: digitalWrite(DIGIT_3, LOW); break; case 1: digitalWrite(DIGIT_2, LOW); break; case 2: digitalWrite(DIGIT_1, LOW); break; default: return; } } void vProcessKeys(uint8_t sel) { if(sel == VIEW_MENU) { if(info_menu.flags.edit == 0) { info_menu.flags.edit = 1; info_menu.flags.param_sel = 1; } else if(info_menu.flags.edit == 1) { info_menu.flags.edit = 2; } else { info_menu.flags.edit = 0; } return; } if(sel == INC_MENU) { if(info_menu.flags.edit == 1) { if(++info_menu.flags.param_sel > 3) { info_menu.flags.param_sel = 0; info_menu.flags.edit = 0; } } else if(info_menu.flags.edit == 2) { if(++thresoldValue[info_menu.flags.param_sel -1] > thresoldHigh[info_menu.flags.param_sel -1]) { thresoldValue[info_menu.flags.param_sel -1] = thresoldLow[info_menu.flags.param_sel -1]; } } } if(sel == DEC_MENU) { if(info_menu.flags.edit == 2) { if(--thresoldValue[info_menu.flags.param_sel -1] < thresoldLow[info_menu.flags.param_sel -1]) { thresoldValue[info_menu.flags.param_sel -1] = thresoldHigh[info_menu.flags.param_sel -1]; } } } } // Función para convertir decimal a BCD sin usar divisiones void decimal_to_bcd(uint16_t decimal) { // Limitar el rango a 0-999 if (decimal > 999) decimal = 999; ///uint8_t hundreds = 0, tens = 0, units = 0; paramToView[2] = paramToView[1] = paramToView[0] = 16; // Calcular centenas (resta iterativa) while (decimal >= 100) { decimal -= 100; paramToView[2]++; } // Calcular decenas (resta iterativa) while (decimal >= 10) { decimal -= 10; paramToView[1]++; } // El restante son las unidades paramToView[0] += decimal; ///uint16_t bcd = (hundreds << 8) | (tens << 4) | units; ///return bcd; }
{ "version": 1, "author": "Mauricio Bautista", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": 120, "left": 28.3, "attrs": {} }, { "type": "wokwi-7segment", "id": "sevseg1", "top": -109.38, "left": -104.76, "attrs": { "digits": "3", "colon": "", "common": "cathode" } }, { "type": "wokwi-pushbutton-6mm", "id": "btn1", "top": 113, "left": 249.6, "attrs": { "color": "green" } }, { "type": "wokwi-pushbutton-6mm", "id": "btn2", "top": 141.8, "left": 249.6, "attrs": { "color": "green" } }, { "type": "wokwi-74hc595", "id": "sr1", "top": -30, "left": 178.24, "attrs": {} }, { "type": "wokwi-gnd", "id": "gnd1", "top": -134.4, "left": 306.6, "attrs": {} }, { "type": "wokwi-pushbutton-6mm", "id": "btn3", "top": 84.2, "left": 249.6, "attrs": { "color": "green" } } ], "connections": [ [ "nano:GND.1", "btn2:2.r", "black", [ "v28.8", "h153.6", "v-76.8" ] ], [ "nano:GND.1", "btn1:2.r", "black", [ "v28.8", "h153.6", "v-115.2" ] ], [ "nano:8", "btn1:1.l", "green", [ "v-38.4", "h153.6", "v28.8" ] ], [ "nano:7", "btn2:1.l", "green", [ "v-28.8", "h134.4", "v48" ] ], [ "sr1:Q0", "sevseg1:A", "green", [ "v-114", "h-220.8" ] ], [ "sr1:Q1", "sevseg1:B", "green", [ "v9.6", "h-19.2", "v-144", "h-153.6", "v28.8" ] ], [ "sevseg1:C", "sr1:Q2", "green", [ "v56.76", "h9.6" ] ], [ "sr1:Q3", "sevseg1:D", "green", [ "v28.8", "h-211.2" ] ], [ "sevseg1:E", "sr1:Q4", "green", [ "v75.96", "h240.01" ] ], [ "sevseg1:F", "sr1:Q5", "green", [ "v-48", "h172.8", "v201.6", "h57.6" ] ], [ "sevseg1:G", "sr1:Q6", "green", [ "v95.16", "h230.4" ] ], [ "sr1:Q7", "sevseg1:DP", "green", [ "v67.2", "h-249.6" ] ], [ "sr1:GND", "sr1:OE", "black", [ "v9.6", "h28.8", "v-67.2", "h-67.2" ] ], [ "gnd1:GND", "sr1:GND", "black", [ "v-19.2", "h-38.4", "v163.2", "h-28.8" ] ], [ "nano:GND.1", "gnd1:GND", "black", [ "v28.8", "h153.6", "v-220.8", "h57.6", "v-48" ] ], [ "nano:5V", "sr1:VCC", "red", [ "v38.4", "h182.4", "v-288", "h-134.4" ] ], [ "nano:5V", "sr1:MR", "red", [ "v38.4", "h182.4", "v-268.8", "h-96" ] ], [ "nano:10", "sr1:STCP", "yellow", [ "v-124.8", "h57.6", "v-76.8", "h48" ] ], [ "nano:11", "sr1:SHCP", "yellow", [ "v-134.4", "h57.6", "v-76.8", "h115.2" ] ], [ "sevseg1:DIG1", "nano:6", "blue", [ "v-38.4", "h-76.79", "v249.6", "h220.8" ] ], [ "nano:5", "sevseg1:DIG2", "blue", [ "v-28.8", "h-240", "v-220.8", "h115.2" ] ], [ "nano:4", "sevseg1:DIG3", "blue", [ "v-38.4", "h-259.2", "v-249.6", "h134.4" ] ], [ "nano:3", "sevseg1:DIG4", "blue", [ "v-48", "h-115.2" ] ], [ "nano:12", "sr1:DS", "yellow", [ "v-144", "h57.6", "v-28.8", "h96" ] ], [ "nano:GND.1", "btn3:2.r", "black", [ "v28.8", "h153.6", "v-105.6" ] ], [ "nano:9", "btn3:1.l", "green", [ "v-48", "h163.2" ] ] ], "dependencies": {} }
Generate a diagram.json code for temperature control system using arduino
#include <Wire.h> #include <LiquidCrystal_I2C.h> #include <OneWire.h> #include <DallasTemperature.h> #include <RTClib.h> #include <Encoder.h> // Pin Definitions #define BLUE 7 // Start indecator Blue LED #define RED 12 // Holding high temp indecator Red LED #define YELOW 8 // Holding LOW temp indecator Yelow LED #define DS18B20_PIN 2 // DS18B20 connected to digital pin 2 #define RELAY_PIN 6 // Relay to control the heater #define STOP_BUTTON_PIN 9 // Stop button #define ENCODER_PIN_A 3 // Rotary encoder A #define ENCODER_PIN_B 4 // Rotary encoder B #define ENCODER_BUTTON 5 // Rotary encoder button // Initialize LCD (I2C address 0x27 for a 20x4 display) LiquidCrystal_I2C lcd(0x27, 20, 4); // Initialize OneWire and DS18B20 OneWire oneWire(DS18B20_PIN); DallasTemperature sensors(&oneWire); // Initialize RTC RTC_DS1307 rtc; // Initialize rotary encoder Encoder encoder(ENCODER_PIN_A, ENCODER_PIN_B); // Variables float currentTemperature = 0.0; float highTemp = 0.0; // Default high temperature float lowTemp = 0.0; // Default low temperature int holdTime = 0; // Default hold time in minutes bool heatingStarted = false; bool holdTimeTracking = false; bool lowTempTracking = false; bool heating = false; bool tempering = false; bool keep_low_temp = false; DateTime holdStartTime; DateTime lowTempStartTime; // Button State Tracking for Debouncing bool lastEncoderButtonState = HIGH; bool lastStopButtonState = HIGH; // Encoder menu states int state = 0; // 0 = Set High Temp, 1 = Set Hold Time, 2 = Set Low Temp, 3 = Ready to Start void setup() { // Initialize serial monitor Serial.begin(9600); // Initialize LCD lcd.init(); lcd.backlight(); // Initialize DS18B20 sensors.begin(); // Initialize RTC if (!rtc.begin()) { lcd.setCursor(0, 0); lcd.print("RTC Not Found!"); while (1); } if (!rtc.isrunning()) { rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Set to compile time } // Initialize pins pinMode(RED, OUTPUT); pinMode(YELOW, OUTPUT); pinMode(RELAY_PIN, OUTPUT); pinMode(STOP_BUTTON_PIN, INPUT_PULLUP); pinMode(ENCODER_BUTTON, INPUT_PULLUP); // Ensure heater is off at startup digitalWrite(RELAY_PIN, LOW); // Welcome Message lcd.setCursor(6, 1); lcd.print("STARTING"); lcd.setCursor(7, 2); lcd.print("SYSTEM"); delay(2000); lcd.clear(); } void loop() { // Request temperature from DS18B20 sensors.requestTemperatures(); currentTemperature = sensors.getTempCByIndex(0); // Read rotary encoder position long encoderPosition = encoder.read() / 4; // Read buttons bool encoderButtonPressed = digitalRead(ENCODER_BUTTON) == LOW; bool stopButtonPressed = digitalRead(STOP_BUTTON_PIN) == LOW; // Handle encoder button press if (encoderButtonPressed && lastEncoderButtonState == HIGH) { delay(50); // Debounce delay if (digitalRead(ENCODER_BUTTON) == LOW) { state = (state + 1) % 4; // Cycle through menu states encoder.write(0); // Reset encoder position lcd.clear(); } } lastEncoderButtonState = encoderButtonPressed; // Handle stop button press if (stopButtonPressed && lastStopButtonState == HIGH) { delay(50); // Debounce delay if (digitalRead(STOP_BUTTON_PIN) == LOW) { heatingStarted = false; holdTimeTracking = false; lowTempTracking = false; digitalWrite(RELAY_PIN, LOW); // Turn off heater lcd.clear(); lcd.setCursor(2, 0); lcd.print("Process Stopped"); lcd.setCursor(6, 1); lcd.print("Restart"); lcd.setCursor(6, 2); lcd.print("......."); delay(200); lcd.clear(); return; // Exit loop to ensure heating is off } } lastStopButtonState = stopButtonPressed; // Update LCD updateLCD(encoderPosition); // Start heating process if in "Ready to Start" state if (state == 3 && !heatingStarted) { heatingStarted = true; heating = true; lcd.clear(); lcd.setCursor(7, 1); lcd.print("Start"); lcd.setCursor(6, 2); lcd.print("Heating.... "); delay(3000); lcd.clear(); digitalWrite(RELAY_PIN, HIGH); // Turn on heater lcd.setCursor(0, 2); lcd.print("Go to High "); } // Control heating and time tracking if (heatingStarted) { controlHeating(); } delay(50); // Short delay for stability } void updateLCD(long encoderPosition) { lcd.setCursor(4, 0); lcd.print("Temp: "); lcd.print(currentTemperature); lcd.print(" C "); if (state == 0) { // Set High Temperature highTemp = constrain(0 + encoderPosition * 5, 0, 400); // Adjust high temperature lcd.setCursor(0, 2); lcd.print("Set High Temp:"); lcd.setCursor(0, 3); //lcd.print("High Temp: "); lcd.print(highTemp); lcd.print(" C "); } else if (state == 1) { // Set Hold Time holdTime = constrain(1 + encoderPosition , 0, 240); // Adjust hold time lcd.setCursor(0, 2); lcd.print("Set Hold Time: "); lcd.setCursor(0, 3); //lcd.print("Hold Time: "); if(holdTime>60) { lcd.print(holdTime/60); lcd.print("h "); lcd.print(holdTime%60); lcd.print("min"); } else { lcd.print(holdTime); lcd.print(" min "); } } else if (state == 2) { // Set Low Temperature lowTemp = constrain(0 + encoderPosition * 5, 0, highTemp - 1); // Adjust low temperature lcd.setCursor(0, 2); lcd.print("Set Low Temp:"); lcd.setCursor(0, 3); //lcd.print("Low Temp: "); lcd.print(lowTemp); lcd.print(" C "); } else if (state == 3) { // Ready to Start lcd.setCursor(0, 1); lcd.print("Starting "); } } void controlHeating() { if(heating && currentTemperature < highTemp) { //continue heating to high temperature } else if(heating && currentTemperature >= (highTemp+1)) { heating = false; tempering = true; digitalWrite(RELAY_PIN, LOW); // Turn off heater lcd.setCursor(0, 2); lcd.print("Reached High "); holdStartTime = rtc.now(); // Start hold time tracking holdTimeTracking = true; digitalWrite(RED, HIGH); } else if(tempering) { DateTime now = rtc.now(); TimeSpan elapsed = now - holdStartTime; if(elapsed.minutes() >= holdTime) { digitalWrite(RELAY_PIN, LOW); // Turn off heater holdTimeTracking = false; digitalWrite(RED, LOW); tempering = false; keep_low_temp = true; lcd.setCursor(0, 3); lcd.print("Time Over H "); } else { lcd.setCursor(0, 3); lcd.print("Hold H temp: "); lcd.print(elapsed.minutes()); lcd.print("m "); lcd.print(elapsed.seconds()); lcd.print("s "); if(currentTemperature >= (highTemp+1)) { digitalWrite(RELAY_PIN, LOW); // Turn off heater } else if(currentTemperature < (highTemp-1)) { digitalWrite(RELAY_PIN, HIGH); // Turn on heater } } } else if(keep_low_temp) { if(currentTemperature>(lowTemp-3) && currentTemperature<(lowTemp+3) && !lowTempTracking) { lowTempTracking = true; digitalWrite(YELOW, HIGH); holdStartTime = rtc.now(); // Start hold time tracking (Low) } else if(lowTempTracking) { DateTime now = rtc.now(); TimeSpan elapsed = now - holdStartTime; lcd.setCursor(0, 3); lcd.print("Hold L temp: "); lcd.print(elapsed.minutes()); lcd.print("m "); lcd.print(elapsed.seconds()); lcd.print("s "); if(currentTemperature >= (lowTemp+1)) { digitalWrite(RELAY_PIN, LOW); // Turn off heater } else if(currentTemperature < (lowTemp-1)) { digitalWrite(RELAY_PIN, HIGH); // Turn on heater } } } }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} }, { "type": "board-ds18b20", "id": "temp1", "top": 75.67, "left": -159.12, "attrs": {} }, { "type": "wokwi-lcd2004", "id": "lcd1", "top": 6.4, "left": 322.4, "attrs": { "pins": "i2c" } }, { "type": "wokwi-ky-040", "id": "encoder1", "top": -151.9, "left": -144.8, "attrs": {} }, { "type": "wokwi-relay-module", "id": "relay1", "top": -163, "left": 460.8, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 73.2, "left": 723.8, "attrs": { "color": "limegreen" } }, { "type": "wokwi-resistor", "id": "r2", "top": -15.8, "left": 728.75, "rotate": 270, "attrs": { "value": "450000" } }, { "type": "wokwi-pushbutton", "id": "btn2", "top": 227, "left": 576, "attrs": { "color": "red", "key": "2" } }, { "type": "wokwi-ds1307", "id": "rtc1", "top": 359.4, "left": 268.9, "attrs": {} }, { "type": "wokwi-microsd-card", "id": "sd1", "top": 355.43, "left": -86.33, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 167.15, "left": -124.8, "attrs": { "value": "5000" } }, { "type": "wokwi-led", "id": "led2", "top": 140.4, "left": 752.6, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led3", "top": 140.4, "left": 791, "attrs": { "color": "orange" } }, { "type": "wokwi-led", "id": "led4", "top": -70.8, "left": 320.6, "attrs": { "color": "blue" } }, { "type": "wokwi-resistor", "id": "r3", "top": 216, "left": 748.25, "rotate": 90, "attrs": { "value": "450000" } }, { "type": "wokwi-resistor", "id": "r4", "top": 216, "left": 786.65, "rotate": 90, "attrs": { "value": "450000" } }, { "type": "wokwi-resistor", "id": "r5", "top": -53.35, "left": 382.6, "rotate": 180, "attrs": { "value": "450000" } } ], "connections": [ [ "temp1:VCC", "uno:5V", "red", [ "v124.8", "h294.4" ] ], [ "uno:GND.2", "temp1:GND", "black", [ "v38.9", "h-236.7" ] ], [ "lcd1:GND", "uno:GND.1", "black", [ "h-48", "v-67.2", "h-163.2" ] ], [ "lcd1:VCC", "uno:5V", "red", [ "h-48", "v172.9", "h-124.8" ] ], [ "lcd1:SDA", "uno:A4", "green", [ "h-38.4", "v182.6", "h-38.4" ] ], [ "lcd1:SCL", "uno:A5", "green", [ "h-19.2", "v182.7", "h-38.4" ] ], [ "encoder1:GND", "uno:GND.1", "black", [ "h0" ] ], [ "encoder1:VCC", "uno:5V", "red", [ "h48", "v58", "h-28.8", "v278.4", "h172.8" ] ], [ "encoder1:SW", "uno:5", "green", [ "h0" ] ], [ "relay1:VCC", "uno:5V", "red", [ "h-163.2", "v412.8", "h-137.6" ] ], [ "relay1:GND", "uno:GND.1", "black", [ "h-201.6", "v86", "h-124.8" ] ], [ "relay1:COM", "led1:C", "green", [ "h49.2", "v46.6", "h96", "v201.6" ] ], [ "r2:1", "led1:A", "green", [ "v0" ] ], [ "relay1:NO", "uno:GND.1", "green", [ "h30", "v55.8", "h-489.6", "v9.6" ] ], [ "relay1:IN", "uno:6", "green", [ "h0" ] ], [ "rtc1:5V", "uno:5V", "red", [ "h0" ] ], [ "rtc1:GND", "uno:GND.2", "black", [ "h0" ] ], [ "rtc1:SDA", "uno:A4", "green", [ "h0" ] ], [ "rtc1:SCL", "uno:A5", "green", [ "h0" ] ], [ "btn2:1.r", "uno:9", "green", [ "v0", "h57.8", "v-259.2", "h-537.6" ] ], [ "temp1:DQ", "uno:2", "green", [ "v19.2", "h86.4", "v-182.4", "h307.2" ] ], [ "r1:1", "temp1:DQ", "green", [ "v-19.2", "h-19.2" ] ], [ "r1:2", "temp1:VCC", "green", [ "v0" ] ], [ "uno:3", "encoder1:DT", "green", [ "v0" ] ], [ "uno:4", "encoder1:CLK", "green", [ "v0" ] ], [ "uno:GND.3", "btn2:2.l", "black", [ "v0" ] ], [ "led2:A", "r3:1", "green", [ "v0" ] ], [ "r3:2", "uno:12", "green", [ "h0", "v27.6", "h-460.8", "v-364.8", "h-153.6" ] ], [ "led2:C", "uno:GND.3", "green", [ "v86.4", "h-95.6", "v38.4", "h-9.6" ] ], [ "r4:1", "led3:A", "green", [ "h0" ] ], [ "led3:C", "led2:C", "green", [ "v9.6", "h-18.8", "v-48", "h-28.8", "v38.4" ] ], [ "r4:2", "uno:8", "green", [ "h0", "v75.6", "h-844.8", "v-403.2", "h211.2" ] ], [ "led4:C", "uno:7", "green", [ "v0", "h-9.2", "v-48", "h-134.4" ] ], [ "r5:2", "led4:A", "green", [ "v0", "h-8.4", "v19.2" ] ], [ "r5:1", "lcd1:VCC", "green", [ "v0", "h9.6", "v19.2", "h-67.2", "v28.8", "h-96", "v48" ] ], [ "relay1:VCC", "r2:2", "red", [ "h-9.6", "v-28.8", "h182.4", "v67.2", "h124.8" ] ] ], "dependencies": {} }
Generate a diagram.json code for Gost28147
#include <Arduino.h> // Default S-Box (GOST 28147-89 standard) uint8_t S_BOX[8][16] = { {4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3}, {14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9}, {5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11}, {7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3}, {6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2}, {4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14}, {13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12}, {1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12} }; // R function with S-Box substitution uint32_t R(uint32_t x) { uint32_t result = 0; for (int i = 0; i < 8; i++) { uint8_t part = (x >> (4 * (7 - i))) & 0xF; result |= ((uint32_t)S_BOX[i][part]) << (4 * (7 - i)); } result = (result << 11) | (result >> (32 - 11)); return result; } // Encrypt a single block (64 bits) void gost_encrypt(uint32_t *block, uint32_t *key) { uint32_t n1 = block[0]; uint32_t n2 = block[1]; for (int i = 0; i < 24; i++) { uint32_t temp = n1; n1 = n2 ^ R(n1 + key[i % 8]); n2 = temp; } for (int i = 7; i >= 0; i--) { uint32_t temp = n1; n1 = n2 ^ R(n1 + key[i]); n2 = temp; } block[0] = n1; block[1] = n2; } // Decrypt a single block (64 bits) void gost_decrypt(uint32_t *block, uint32_t *key) { uint32_t n1 = block[1]; uint32_t n2 = block[0]; for (int i = 0; i < 8; i++) { uint32_t temp = n1; n1 = n2 ^ R(n1 + key[i]); n2 = temp; } for (int i = 23; i >= 0; i--) { uint32_t temp = n1; n1 = n2 ^ R(n1 + key[i % 8]); n2 = temp; } block[0] = n2; block[1] = n1; } // Add PKCS#7 padding void add_padding(uint8_t *data, size_t &length) { size_t padding = 8 - (length % 8); for (size_t i = 0; i < padding; i++) { data[length + i] = padding; } length += padding; } // Remove PKCS#7 padding void remove_padding(uint8_t *data, size_t &length) { uint8_t padding = data[length - 1]; if (padding > 0 && padding <= 8) { length -= padding; } } void gost_encrypt_with_padding(uint8_t *data, size_t &length, uint32_t *key) { // To‘ldirish qo‘shish add_padding(data, length); // Har bir blokni shifrlash for (size_t i = 0; i < length; i += 8) { gost_encrypt((uint32_t *)&data[i], key); } } void gost_decrypt_with_padding(uint8_t *data, size_t &length, uint32_t *key) { // Har bir blokni deshifrlash for (size_t i = 0; i < length; i += 8) { gost_decrypt((uint32_t *)&data[i], key); } // To‘ldirishni olib tashlash remove_padding(data, length); } void setup() { Serial.begin(9600); } void loop() { if (Serial.available() > 0) { String command = Serial.readStringUntil('\n'); String inputData = command.substring(8); size_t length = inputData.length(); uint8_t data[1024]; inputData.getBytes(data, sizeof(data)); uint32_t key[8] = {0x12345678, 0x23456789, 0x34567890, 0x45678901, 0x56789012, 0x67890123, 0x78901234, 0x89012345}; if (command.startsWith("ENCRYPT:")) { gost_encrypt_with_padding(data, length, key); for (size_t i = 0; i < length; i++) { if(data[i] < 16){ Serial.print("0"); Serial.print(data[i], HEX); }else{ Serial.print(data[i], HEX); } } } else if (command.startsWith("DECRYPT:")) { size_t length1 = length / 2; // Har ikkita HEX belgidan bitta byte hosil bo'ladi uint8_t data[length1]; // uint8_t massiv // HEX dan uint8_t ga o'zgartirish for (size_t i = 0; i < length1; i++) { String byteString = inputData.substring(i * 2, i * 2 + 2); // 2 ta HEX belgi olish data[i] = (uint8_t) strtoul(byteString.c_str(), NULL, 16); // HEX ni uint8_t ga aylantirish } gost_decrypt_with_padding(data, length1, key); for (size_t i = 0; i < length1; i++) { Serial.print((char)data[i]); } } else { Serial.println("Unknown command!"); } } }
{ "version": 1, "author": "Programmer GPT", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} } ], "connections": [], "dependencies": {} }
Generate a diagram.json code for Three LED blink in series
#define RED_LED 7 #define GREEN_LED 6 #define BLUE_LED 5 void setup() { pinMode(RED_LED, OUTPUT); pinMode(GREEN_LED, OUTPUT); pinMode(BLUE_LED, OUTPUT); } void loop() { digitalWrite(RED_LED, HIGH); digitalWrite(GREEN_LED, LOW); digitalWrite(BLUE_LED, LOW); delay(1000); digitalWrite(RED_LED, LOW); digitalWrite(GREEN_LED, HIGH); digitalWrite(BLUE_LED, LOW); delay(1000); digitalWrite(RED_LED, LOW); digitalWrite(GREEN_LED, LOW); digitalWrite(BLUE_LED, HIGH); delay(1000); }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -12.6, "left": 300.4, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "uno", "top": 0.6, "left": 37.8, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -3.6, "left": 339.8, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -3.6, "left": 435.8, "attrs": { "color": "limegreen" } }, { "type": "wokwi-led", "id": "led3", "top": -3.6, "left": 531.8, "attrs": { "color": "blue" } }, { "type": "wokwi-resistor", "id": "r1", "top": 81.6, "left": 335.45, "rotate": 90, "attrs": { "value": "0" } }, { "type": "wokwi-resistor", "id": "r2", "top": 81.6, "left": 431.45, "rotate": 90, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "r3", "top": 81.6, "left": 527.45, "rotate": 90, "attrs": { "value": "1000" } } ], "connections": [ [ "led1:C", "bb1:4t.b", "green", [ "v9.6", "h0.4" ] ], [ "led2:C", "bb1:14t.b", "green", [ "v9.6", "h0.4" ] ], [ "led2:A", "bb1:15t.b", "green", [ "v9.6" ] ], [ "led3:C", "bb1:24t.b", "green", [ "v9.6", "h0.4" ] ], [ "led3:A", "bb1:25t.b", "green", [ "v9.6" ] ], [ "led1:A", "bb1:5t.a", "", [ "$bb" ] ], [ "led1:C", "bb1:4t.a", "", [ "$bb" ] ], [ "led2:A", "bb1:15t.a", "", [ "$bb" ] ], [ "led2:C", "bb1:14t.a", "", [ "$bb" ] ], [ "led3:A", "bb1:25t.a", "", [ "$bb" ] ], [ "led3:C", "bb1:24t.a", "", [ "$bb" ] ], [ "bb1:5t.b", "led1:A", "green", [ "v0" ] ], [ "r1:1", "bb1:5t.c", "", [ "$bb" ] ], [ "r1:2", "bb1:5b.g", "", [ "$bb" ] ], [ "r2:1", "bb1:15t.c", "", [ "$bb" ] ], [ "r2:2", "bb1:15b.g", "", [ "$bb" ] ], [ "r3:1", "bb1:25t.c", "", [ "$bb" ] ], [ "r3:2", "bb1:25b.g", "", [ "$bb" ] ], [ "r1:2", "uno:7", "red", [ "h-38.4", "v-164.4", "h-105.6", "v19.2" ] ], [ "r2:2", "uno:6", "green", [ "h19.2", "v-174", "h-240", "v38.4" ] ], [ "r3:2", "uno:5", "blue", [ "h19.2", "v-202.8", "h0", "v0", "h-316.8", "v67.2" ] ], [ "bb1:4t.d", "bb1:bn.3", "purple", [ "v115.2" ] ], [ "bb1:14t.d", "bb1:bn.11", "purple", [ "v115.2" ] ], [ "bb1:24t.d", "bb1:bn.20", "purple", [ "v115.2" ] ], [ "bb1:bp.1", "uno:5V", "red", [ "v47.1", "h-132.8" ] ], [ "bb1:bn.2", "uno:GND.3", "green", [ "v27.5", "h-123.2" ] ] ], "dependencies": {} }
Generate a diagram.json code for piano using arduino
#include "pitches.h" #define SPEAKER_PIN 8 const uint8_t buttonPins[]={12,11,10,9,8,7,6,5,4}; const int buttonTones[]={ NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 }; const int numTones= sizeof(buttonPins) / sizeof (buttonPins[0]); void setup() { int pitch=0;// put your setup code here, to run once: for (uint8_t i=0; i< numTones;i++){ pinMode(buttonPins[i], INPUT_PULLUP); } pinMode(SPEAKER_PIN, OUTPUT); } void loop() { int pitch=0; for (uint8_t i=0; i < numTones; i++){ if (digitalRead(buttonPins[i])== LOW){ pitch = buttonTones[i]; } } if (pitch) { tone(SPEAKER_PIN, pitch); } else { tone(SPEAKER_PIN,0); } }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-buzzer", "id": "bz1", "top": -55.2, "left": 366.6, "attrs": { "volume": "0.1" } }, { "type": "wokwi-pushbutton", "id": "btn2", "top": -96.1, "left": 233.9, "rotate": 90, "attrs": { "color": "yellow" } }, { "type": "wokwi-pushbutton", "id": "btn3", "top": -105.7, "left": 185.9, "rotate": 90, "attrs": { "color": "yellow" } }, { "type": "wokwi-pushbutton", "id": "btn4", "top": -105.7, "left": 137.9, "rotate": 90, "attrs": { "color": "green", "bounce": "1" } }, { "type": "wokwi-pushbutton", "id": "btn5", "top": -115.3, "left": 89.9, "rotate": 90, "attrs": { "color": "blue" } }, { "type": "wokwi-pushbutton", "id": "btn8", "top": -115.3, "left": -63.7, "rotate": 90, "attrs": { "color": "red" } }, { "type": "wokwi-pushbutton", "id": "btn1", "top": -96.1, "left": 291.5, "rotate": 90, "attrs": { "color": "red" } }, { "type": "wokwi-pushbutton", "id": "btn6", "top": -124.9, "left": -6.1, "rotate": 90, "attrs": { "color": "blue" } }, { "type": "wokwi-pushbutton", "id": "btn7", "top": -144.1, "left": 41.9, "rotate": 90, "attrs": { "color": "blue" } } ], "connections": [ [ "btn1:1.r", "uno:4", "red", [ "v0" ] ], [ "btn2:1.r", "uno:5", "orange", [ "v0" ] ], [ "btn3:1.r", "uno:6", "gold", [ "v0" ] ], [ "btn5:1.r", "uno:9", "cyan", [ "v0" ] ], [ "btn8:1.r", "uno:12", "red", [ "v0" ] ], [ "uno:GND.1", "btn5:2.r", "black", [ "v-76.2", "h-0.3" ] ], [ "uno:GND.1", "btn7:2.r", "black", [ "v0" ] ], [ "uno:GND.1", "btn6:2.r", "black", [ "v0" ] ], [ "uno:GND.1", "btn8:2.r", "black", [ "v0" ] ], [ "uno:GND.1", "btn4:2.r", "black", [ "v0" ] ], [ "uno:GND.1", "btn3:2.r", "black", [ "v0" ] ], [ "uno:GND.1", "btn2:2.r", "black", [ "v0" ] ], [ "uno:GND.1", "btn1:2.r", "black", [ "v0" ] ], [ "btn6:1.r", "uno:11", "purple", [ "v0" ] ], [ "btn7:1.r", "uno:10", "blue", [ "v0" ] ], [ "uno:GND.1", "bz1:1", "black", [ "v0" ] ], [ "bz1:2", "uno:8", "green", [ "v0" ] ], [ "uno:7", "btn4:1.r", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for sequential LED tower
void setup() { pinMode(10, OUTPUT); pinMode(9, OUTPUT); pinMode(8, OUTPUT); pinMode(7, OUTPUT); pinMode(6, OUTPUT); pinMode(5, OUTPUT); pinMode(4, OUTPUT); pinMode(3, OUTPUT); pinMode(2, INPUT_PULLUP); // put your setup code here, to run once: } void loop() { int pb1=digitalRead(2); if(pb1==LOW) { digitalWrite(4, HIGH); digitalWrite(10, HIGH); delay(250); digitalWrite(4, LOW); digitalWrite(10, LOW); digitalWrite(3, HIGH); digitalWrite(9, HIGH); delay(250); digitalWrite(3, LOW); digitalWrite(9, LOW); digitalWrite(6, HIGH); digitalWrite(8, HIGH); delay(250); digitalWrite(6, LOW); digitalWrite(8, LOW); digitalWrite(5, HIGH); digitalWrite(7, HIGH); delay(250); digitalWrite(5, LOW); digitalWrite(7, LOW); digitalWrite(10, HIGH); digitalWrite(9, HIGH); delay(250); digitalWrite(10, LOW); digitalWrite(9, LOW); digitalWrite(8, HIGH); digitalWrite(7, HIGH); delay(250); digitalWrite(8, LOW); digitalWrite(7, LOW); digitalWrite(6, HIGH); digitalWrite(5, HIGH); delay(250); digitalWrite(6, LOW); digitalWrite(5, LOW); digitalWrite(4, HIGH); digitalWrite(3, HIGH); delay(250); digitalWrite(4, LOW); digitalWrite(3, LOW); digitalWrite(3, HIGH); digitalWrite(4, HIGH); delay(250); digitalWrite(3, LOW); digitalWrite(4, LOW); digitalWrite(5, HIGH); digitalWrite(6, HIGH); delay(250); digitalWrite(5, LOW); digitalWrite(6, LOW); digitalWrite(7, HIGH); digitalWrite(8, HIGH); delay(250); digitalWrite(7, LOW); digitalWrite(8, LOW); digitalWrite(9, HIGH); digitalWrite(10, HIGH); delay(250); digitalWrite(9, LOW); digitalWrite(10, LOW); } // put your main code here, to run repeatedly: }
{ "version": 1, "author": "Mas Wan", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0.6, "left": -0.6, "attrs": {} }, { "type": "wokwi-pushbutton", "id": "btn1", "top": -61, "left": 19.2, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led1", "top": -118.8, "left": 128.6, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -118.8, "left": 176.6, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led3", "top": -214.8, "left": 128.6, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led4", "top": -166.8, "left": 128.6, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led5", "top": -214.8, "left": 176.6, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led6", "top": -166.8, "left": 176.6, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led7", "top": -262.8, "left": 128.6, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led8", "top": -262.8, "left": 176.6, "attrs": { "color": "red" } } ], "connections": [ [ "uno:GND.1", "btn1:2.r", "limegreen", [ "v0" ] ], [ "uno:2", "btn1:1.r", "green", [ "v0" ] ], [ "uno:GND.1", "led1:C", "black", [ "v0" ] ], [ "uno:GND.1", "led2:C", "limegreen", [ "v0" ] ], [ "uno:3", "led1:A", "red", [ "v0" ] ], [ "uno:4", "led2:A", "blue", [ "v0" ] ], [ "uno:5", "led6:A", "red", [ "v0" ] ], [ "uno:6", "led4:A", "blue", [ "v0" ] ], [ "uno:GND.1", "led4:C", "black", [ "v0" ] ], [ "uno:GND.1", "led6:C", "limegreen", [ "v0" ] ], [ "uno:7", "led3:A", "red", [ "v0" ] ], [ "uno:8", "led5:A", "blue", [ "v0" ] ], [ "uno:GND.1", "led3:C", "black", [ "v0" ] ], [ "uno:GND.1", "led5:C", "limegreen", [ "v0" ] ], [ "uno:9", "led8:A", "red", [ "v0" ] ], [ "uno:10", "led7:A", "blue", [ "v0" ] ], [ "uno:GND.1", "led7:C", "black", [ "v0" ] ], [ "uno:GND.1", "led8:C", "limegreen", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for modern turn lights motorcycles using arduino
//Modern turn lights v.3.1.0 for scooters and motorcycles with arduino and ws2812b - by Fedaceag Ionut ( Youtube - Think small, build big! ) #include <FastLED.h> //FastLed library version 3.2.1 - https://github.com/FastLED/FastLED/wiki/Overview or http://fastled.io/ with NEOPIXEL or WS2812B #define NUM_STRIPS 4 // number of small led strips #define NUM_LEDS_PART_A 20 // number of leds for the big strip - should be the at least the number of leds from the small strips multiply by tree (in this case the minimum should be 10 x 3 = 30 leds) #define NUM_LEDS_PART_B 4 // number of leds for the small strips CRGB ledsA[NUM_LEDS_PART_A]; CRGB ledsB[NUM_STRIPS][NUM_LEDS_PART_B]; //input pins const int buttonPinL = 2; // turn left const int buttonPinR = 3; // turn right const int buttonPinEng = 4; // engine on to start day lights const int buttonPinKnightRider = 5; // knight rider lights const int buttonPinBrake = 6; // brake lights const int buttonPinTailLights = 7; // tail lights int halfOfLeds = (NUM_LEDS_PART_A/2); int buttonStateL = 0; int buttonStateR = 0; int engineOn = 0; int maxBrtN = 0; int KnightRiderState = 0; int KnightRiderToOff = 0; int Brake = 0; int TailLights = 0; int leftLeds = 0; int rightLeds = 0; int tailLeft = halfOfLeds-1; int tailLeftSmall = 0; int tailRight = halfOfLeds; int tailRightSmall = 0; int brakeToOffL = 0; int brakeToOffR = 0; int stateLT = 0; int stateRT = 0; uint8_t gBrtL = 0; uint8_t gBrtR = 0; int TailOn = 0; unsigned long turnColor = 0xff6a00; //turn signal color int showSignalBigStrip = 1; // show the signal on the big led strip 0 = no | 1 = yes int showTailBrakeSmalStrip = 1; // show tail and brake lights on small strips 0 = no | 1 = yes int maxBrt = 254; // maxim brightness day lights - from 0 to 254 int maxBrtNight = 100; // maxim brightness day lights with tail lights on - from 0 to 254 int maxBrtBrake = 254; // maxim brightness Brake lights - from 0 to 254 int maxBrtTailLights = 70; // maxim brightness tail lights - from 0 to 254 uint8_t gHue = 0; // knight rider color int knightRiderRainbow = 0; // knight rider rainbow effect 0 = no | 1 = yes int knightRiderOvrDayL = 1; // knight rider override day lights 0 = no | 1 = yes int knightRiderSpeed = 45; // speed for knight rider lights int knightRiderTail = 12; // tail effect for knight rider lights int delayTurnLedAnim = 8; //delay of each led in turn light animation int delayTurnLedOff = 250; //delay from animation to black (is used twice) int delayLedToDayLight = 500; //delay from animation to day light on int tailDelay = 6; //delay for animation tail lights on or off int nrAnimAfterOff = 3; //number of animations for a single impulse unsigned long currentMillis = 0; unsigned long previousMillis = 0; void setup() { Serial.begin(115200); pinMode(buttonPinL, INPUT); pinMode(buttonPinR, INPUT); pinMode(buttonPinEng, INPUT); pinMode(buttonPinKnightRider, INPUT); pinMode(buttonPinBrake, INPUT); pinMode(buttonPinTailLights, INPUT); FastLED.addLeds<NEOPIXEL, 13>(ledsA, NUM_LEDS_PART_A); //big led strip rear turn signals, brake light, tail lights FastLED.addLeds<NEOPIXEL, 12>(ledsB[0], NUM_LEDS_PART_B); //led strip rear left turn signals FastLED.addLeds<NEOPIXEL, 11>(ledsB[1], NUM_LEDS_PART_B); //led strip rear right turn signals FastLED.addLeds<NEOPIXEL, 10>(ledsB[2], NUM_LEDS_PART_B); //led strip front left turn signals FastLED.addLeds<NEOPIXEL, 9>(ledsB[3], NUM_LEDS_PART_B); //led strip front right turn signals attachInterrupt(digitalPinToInterrupt(buttonPinL),btnPressL,RISING); // we use interrupt for instant reaction of turn lights attachInterrupt(digitalPinToInterrupt(buttonPinR),btnPressR,RISING); // we use interrupt for instant reaction of turn lights fill_solid(ledsA, NUM_LEDS_PART_A, CRGB::Black); // some led strips are all on at power on, so let's power them off at boot fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black); // some led strips are all on at power on, so let's power them off at boot fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black); // some led strips are all on at power on, so let's power them off at boot fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black); // some led strips are all on at power on, so let's power them off at boot fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black); // some led strips are all on at power on, so let's power them off at boot FastLED.show(); } void loop() { // read the input state buttonStateL = digitalRead(buttonPinL); buttonStateR = digitalRead(buttonPinR); engineOn = digitalRead(buttonPinEng); KnightRiderState = digitalRead(buttonPinKnightRider); Serial.print(buttonStateL); Serial.print(", "); Serial.print(buttonStateR); Serial.print(", "); Serial.print(engineOn); Serial.print(", "); Serial.println(KnightRiderState); //function for hazard lights if(stateLT != 0 && stateRT != 0){ leftLeds = NUM_LEDS_PART_B-1; rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B; for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) { if(showSignalBigStrip == 1){ ledsA[leftLeds] = turnColor; ledsA[rightLeds] = turnColor; } ledsB[0][dot] = turnColor; ledsB[1][dot] = turnColor; ledsB[2][dot] = turnColor; ledsB[3][dot] = turnColor; FastLED.show(); //delay(delayTurnLedAnim); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedAnim >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } leftLeds--; rightLeds++; } //delay(delayTurnLedOff); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedOff >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } if(showSignalBigStrip == 1){ leftLeds = NUM_LEDS_PART_B-1; for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) { ledsA[leftLeds] = 0x000000; leftLeds--; } rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B; for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) { ledsA[rightLeds] = 0x000000; rightLeds++; } } fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black); FastLED.show(); //delay(delayTurnLedOff); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedOff >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } buttonStateL = digitalRead(buttonPinL); buttonStateR = digitalRead(buttonPinR); if(buttonStateL != HIGH || buttonStateR != HIGH){ if(buttonStateL == HIGH){ stateLT = 1; }else{ stateLT = 0; gBrtL = 0; } if(buttonStateR == HIGH){ stateRT = 1; }else{ stateRT = 0; gBrtR = 0; } if(buttonStateL != HIGH && buttonStateR != HIGH){ //delay(delayLedToDayLight); currentMillis = previousMillis = millis(); while(previousMillis + delayLedToDayLight >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } leftLeds = NUM_LEDS_PART_B-1; rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B; if(showSignalBigStrip == 1){ tailLeft = NUM_LEDS_PART_B; tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B; }else{ tailLeft = halfOfLeds-1; tailRight = halfOfLeds; } } } //function for left turn lights }else if(stateLT != 0){ if(KnightRiderState == HIGH){ fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black); } leftLeds = NUM_LEDS_PART_B-1; for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) { if(showSignalBigStrip == 1){ ledsA[leftLeds] = turnColor; } ledsB[0][dot] = turnColor; ledsB[2][dot] = turnColor; FastLED.show(); //delay(delayTurnLedAnim); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedAnim >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } leftLeds--; } //delay(delayTurnLedOff); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedOff >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } leftLeds = NUM_LEDS_PART_B-1; for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) { if(showSignalBigStrip == 1){ ledsA[leftLeds] = 0x000000; } ledsB[0][dot] = 0x000000; ledsB[2][dot] = 0x000000; leftLeds--; } FastLED.show(); //delay(delayTurnLedOff); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedOff >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } stateLT++; if(stateLT >= nrAnimAfterOff && buttonStateL != HIGH){ stateLT = 0; gBrtL = 0; //delay(delayLedToDayLight); currentMillis = previousMillis = millis(); while(previousMillis + delayLedToDayLight >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } leftLeds = NUM_LEDS_PART_B-1; if(showSignalBigStrip == 1){ tailLeft = NUM_LEDS_PART_B; tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B; }else{ tailLeft = halfOfLeds-1; tailRight = halfOfLeds; } } //function for right turn lights }else if(stateRT != 0){ if(KnightRiderState == HIGH){ fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black); } rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B; for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) { if(showSignalBigStrip == 1){ ledsA[rightLeds] = turnColor; } ledsB[1][dot] = turnColor; ledsB[3][dot] = turnColor; FastLED.show(); //delay(delayTurnLedAnim); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedAnim >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } rightLeds++; } //delay(delayTurnLedOff); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedOff >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B; for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) { if(showSignalBigStrip == 1){ ledsA[rightLeds] = 0x000000; } ledsB[1][dot] = 0x000000; ledsB[3][dot] = 0x000000; rightLeds++; } FastLED.show(); //delay(delayTurnLedOff); currentMillis = previousMillis = millis(); while(previousMillis + delayTurnLedOff >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } stateRT++; if(stateRT >= nrAnimAfterOff && buttonStateR != HIGH){ stateRT = 0; gBrtR = 0; //delay(delayLedToDayLight); currentMillis = previousMillis = millis(); while(previousMillis + delayLedToDayLight >= currentMillis){ TailAndBrake(); FastLED.show(); currentMillis = millis(); } rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B; if(showSignalBigStrip == 1){ tailLeft = NUM_LEDS_PART_B; tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B; }else{ tailLeft = halfOfLeds-1; tailRight = halfOfLeds; } } //function for kight rider and day lights }else{ if(knightRiderOvrDayL == 1 && KnightRiderState == HIGH && engineOn == HIGH){ engineOn = LOW; } if(TailLights == HIGH && engineOn == HIGH){ maxBrtN = maxBrtNight; }else{ maxBrtN = maxBrt; } if(stateLT == 0 && engineOn == HIGH){ if(gBrtL <= maxBrtN){ EVERY_N_MILLISECONDS( 1 ) { gBrtL++; } fill_solid( ledsB[2], NUM_LEDS_PART_B, CHSV(0,0,gBrtL)); }else if(gBrtL >= maxBrtN){ EVERY_N_MILLISECONDS( 1 ) { gBrtL--; } fill_solid( ledsB[2], NUM_LEDS_PART_B, CHSV(0,0,gBrtL)); } }else{ if(gBrtL > 0){ EVERY_N_MILLISECONDS( 1 ) { gBrtL--; } fill_solid( ledsB[2], NUM_LEDS_PART_B, CHSV(0,0,gBrtL)); } } if(stateRT == 0 && engineOn == HIGH){ if(gBrtR <= maxBrtN){ EVERY_N_MILLISECONDS( 1 ) { gBrtR++; } fill_solid( ledsB[3], NUM_LEDS_PART_B, CHSV(0,0,gBrtR)); }else if(gBrtR >= maxBrtN){ EVERY_N_MILLISECONDS( 1 ) { gBrtR--; } fill_solid( ledsB[3], NUM_LEDS_PART_B, CHSV(0,0,gBrtR)); } }else{ if(gBrtR > 0){ EVERY_N_MILLISECONDS( 1 ) { gBrtR--; } fill_solid( ledsB[3], NUM_LEDS_PART_B, CHSV(0,0,gBrtR)); } } if(KnightRiderState == HIGH && engineOn == LOW){ if(knightRiderRainbow == 1){ EVERY_N_MILLISECONDS( 20 ) { gHue++; } } fadeToBlackBy( ledsB[0], NUM_LEDS_PART_B, knightRiderTail); fadeToBlackBy( ledsB[1], NUM_LEDS_PART_B, knightRiderTail); fadeToBlackBy( ledsB[2], NUM_LEDS_PART_B, knightRiderTail); fadeToBlackBy( ledsB[3], NUM_LEDS_PART_B, knightRiderTail); int pos = beatsin16( knightRiderSpeed, 0, NUM_LEDS_PART_B-1 ); ledsB[0][pos] += CHSV( gHue, 255, 192); ledsB[1][pos] += CHSV( gHue, 255, 192); ledsB[2][pos] += CHSV( gHue, 255, 192); ledsB[3][pos] += CHSV( gHue, 255, 192); KnightRiderToOff = 1; }else{ if(KnightRiderToOff == 1){ fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black); fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black); if(showSignalBigStrip == 1){ tailLeft = NUM_LEDS_PART_B; tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B; }else{ tailLeft = halfOfLeds-1; tailRight = halfOfLeds; } KnightRiderToOff = 0; } } TailAndBrake(); FastLED.show(); } } //function for Brake lights, tail lights void TailAndBrake(){ Brake = digitalRead(buttonPinBrake); TailLights = digitalRead(buttonPinTailLights); if(TailLights == HIGH && Brake == LOW){ if(stateLT == 0 && stateRT == 0){ if(tailLeft >= 0){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailLeft]=CHSV(0,255,maxBrtTailLights); if(showTailBrakeSmalStrip == 1 && tailLeft < NUM_LEDS_PART_B){ tailLeftSmall = map(tailLeft,NUM_LEDS_PART_B-1,0,0,NUM_LEDS_PART_B-1); ledsB[0][tailLeftSmall]=CHSV(0,255,maxBrtTailLights); } tailLeft--; } } if(tailRight < NUM_LEDS_PART_A){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailRight]=CHSV(0,255,maxBrtTailLights); if(showTailBrakeSmalStrip == 1 && tailRight > NUM_LEDS_PART_A-NUM_LEDS_PART_B-1){ tailRightSmall = map(tailRight,NUM_LEDS_PART_A-NUM_LEDS_PART_B-1,NUM_LEDS_PART_A-1,0,NUM_LEDS_PART_B-1); ledsB[1][tailRightSmall]=CHSV(0,255,maxBrtTailLights); } tailRight++; } } }else if(stateLT != 0 && stateRT != 0){ if(showSignalBigStrip == 1){ if(tailLeft >= NUM_LEDS_PART_B){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailLeft]=CHSV(0,255,maxBrtTailLights); tailLeft--; } } if(tailRight < NUM_LEDS_PART_A-NUM_LEDS_PART_B){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailRight]=CHSV(0,255,maxBrtTailLights); tailRight++; } } }else{ if(tailLeft >= 0){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailLeft]=CHSV(0,255,maxBrtTailLights); tailLeft--; } } if(tailRight < NUM_LEDS_PART_A){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailRight]=CHSV(0,255,maxBrtTailLights); tailRight++; } } } }else{ if(stateLT != 0){ if(showSignalBigStrip == 1){ if(tailLeft >= NUM_LEDS_PART_B){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailLeft]=CHSV(0,255,maxBrtTailLights); tailLeft--; } } }else{ if(tailLeft >= 0){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailLeft]=CHSV(0,255,maxBrtTailLights); tailLeft--; } } } if(tailRight < NUM_LEDS_PART_A){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailRight]=CHSV(0,255,maxBrtTailLights); if(showTailBrakeSmalStrip == 1 && tailRight > NUM_LEDS_PART_A-NUM_LEDS_PART_B-1){ tailRightSmall = map(tailRight,NUM_LEDS_PART_A-NUM_LEDS_PART_B-1,NUM_LEDS_PART_A-1,0,NUM_LEDS_PART_B-1); ledsB[1][tailRightSmall]=CHSV(0,255,maxBrtTailLights); } tailRight++; } } } if(stateRT != 0){ if(tailLeft >= 0){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailLeft]=CHSV(0,255,maxBrtTailLights); if(showTailBrakeSmalStrip == 1 && tailLeft < NUM_LEDS_PART_B){ tailLeftSmall = map(tailLeft,NUM_LEDS_PART_B-1,0,0,NUM_LEDS_PART_B-1); ledsB[0][tailLeftSmall]=CHSV(0,255,maxBrtTailLights); } tailLeft--; } } if(showSignalBigStrip == 1){ if(tailRight < NUM_LEDS_PART_A-NUM_LEDS_PART_B){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailRight]=CHSV(0,255,maxBrtTailLights); tailRight++; } } }else{ if(tailRight < NUM_LEDS_PART_A){ EVERY_N_MILLISECONDS( tailDelay ) { ledsA[tailRight]=CHSV(0,255,maxBrtTailLights); tailRight++; } } } } } }else if(Brake == HIGH){ if(stateLT == 0 && stateRT == 0){ fill_solid( ledsA, NUM_LEDS_PART_A, CHSV(0,255,maxBrtBrake)); if(showTailBrakeSmalStrip == 1){ fill_solid( ledsB[0], NUM_LEDS_PART_B, CHSV(0,255,maxBrtBrake)); fill_solid( ledsB[1], NUM_LEDS_PART_B, CHSV(0,255,maxBrtBrake)); } }else if(stateLT != 0 && stateRT != 0){ if(showSignalBigStrip == 1){ for(int i = NUM_LEDS_PART_B; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } for(int i = halfOfLeds; i < NUM_LEDS_PART_A-NUM_LEDS_PART_B; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } }else{ for(int i = 0; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } for(int i = halfOfLeds; i < NUM_LEDS_PART_A; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } } }else{ if(stateLT != 0){ if(showSignalBigStrip == 1){ for(int i = NUM_LEDS_PART_B; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } for(int i = halfOfLeds; i < NUM_LEDS_PART_A; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } }else{ for(int i = 0; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } for(int i = halfOfLeds; i < NUM_LEDS_PART_A; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } } if(showTailBrakeSmalStrip == 1){ fill_solid( ledsB[1], NUM_LEDS_PART_B, CHSV(0,255,maxBrtBrake)); } } if(stateRT != 0){ if(showSignalBigStrip == 1){ for(int i = halfOfLeds; i < NUM_LEDS_PART_A-NUM_LEDS_PART_B; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } for(int i = 0; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } }else{ for(int i = halfOfLeds; i < NUM_LEDS_PART_A; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } for(int i = 0; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,255,maxBrtBrake); } } if(showTailBrakeSmalStrip == 1){ fill_solid( ledsB[0], NUM_LEDS_PART_B, CHSV(0,255,maxBrtBrake)); } } } tailLeft = halfOfLeds-1; tailRight = halfOfLeds; brakeToOffL = 1; brakeToOffR = 1; }else{ if(tailLeft < halfOfLeds-1){ EVERY_N_MILLISECONDS( tailDelay ) { tailLeft++; ledsA[tailLeft]=CHSV(0,0,0); if(showTailBrakeSmalStrip == 1 && tailLeft < NUM_LEDS_PART_B){ tailLeftSmall = map(tailLeft,NUM_LEDS_PART_B-1,0,0,NUM_LEDS_PART_B-1); ledsB[0][tailLeftSmall]=CHSV(0,0,0); } } }else{ if(stateLT != 0){ if(brakeToOffL == 1){ if(showSignalBigStrip == 1){ for(int i = NUM_LEDS_PART_B; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,0,0); } }else{ for(int i = 0; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,0,0); } } brakeToOffL = 0; } }else{ for(int i = 0; i < halfOfLeds; i++){ ledsA[i] = CHSV(0,0,0); } if(KnightRiderState == LOW){ fill_solid( ledsB[0], NUM_LEDS_PART_B, CHSV(0,0,0)); } } } if(tailRight > halfOfLeds){ EVERY_N_MILLISECONDS( tailDelay ) { tailRight--; ledsA[tailRight]=CHSV(0,0,0); if(showTailBrakeSmalStrip == 1 && tailRight > NUM_LEDS_PART_A-NUM_LEDS_PART_B-1){ tailRightSmall = map(tailRight,NUM_LEDS_PART_A-NUM_LEDS_PART_B-1,NUM_LEDS_PART_A-1,0,NUM_LEDS_PART_B-1); ledsB[1][tailRightSmall]=CHSV(0,0,0); } } }else{ if(stateRT != 0){ if(brakeToOffR == 1){ if(showSignalBigStrip == 1){ for(int i = halfOfLeds; i < NUM_LEDS_PART_A-NUM_LEDS_PART_B; i++){ ledsA[i] = CHSV(0,0,0); } }else{ for(int i = halfOfLeds; i < NUM_LEDS_PART_A; i++){ ledsA[i] = CHSV(0,0,0); } } brakeToOffR = 0; } }else{ for(int i = halfOfLeds; i < halfOfLeds*2; i++){ ledsA[i] = CHSV(0,0,0); } if(KnightRiderState == LOW){ fill_solid( ledsB[1], NUM_LEDS_PART_B, CHSV(0,0,0)); } } } } } //function for left signal interrupt void btnPressL(){ stateLT = 1; for(int nr = 0; nr < 1500; nr++) { buttonStateR = digitalRead(buttonPinR); if(buttonStateR == 1){ stateRT = 1; } } } //function for right signal interrupt void btnPressR(){ stateRT = 1; for(int nr = 0; nr < 1500; nr++) { buttonStateL = digitalRead(buttonPinL); if(buttonStateL == 1){ stateLT = 1; } } }
{ "version": 1, "author": "Usama Shafiq", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -214.2, "left": 156.4, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "uno", "top": 0.6, "left": -0.6, "attrs": {} }, { "type": "wokwi-led-ring", "id": "ring1", "top": -513.02, "left": 27.56, "attrs": { "pixels": "20" } }, { "type": "wokwi-led-ring", "id": "ring3", "top": -339.96, "left": -68.31, "attrs": { "pixels": "4" } }, { "type": "wokwi-led-ring", "id": "ring4", "top": -330.36, "left": 210.09, "attrs": { "pixels": "4" } }, { "type": "wokwi-led-ring", "id": "ring5", "top": -368.76, "left": 152.49, "attrs": { "pixels": "4" } }, { "type": "wokwi-resistor", "id": "r1", "top": -52.8, "left": 201.05, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r2", "top": -52.8, "left": 191.45, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r3", "top": -52.8, "left": 181.85, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r4", "top": -52.8, "left": 172.25, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r5", "top": -52.8, "left": 162.65, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r6", "top": -52.8, "left": 153.05, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-dip-switch-8", "id": "sw1", "top": -147.3, "left": 174.3, "attrs": {} }, { "type": "wokwi-resistor", "id": "r7", "top": -24, "left": 133.85, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r8", "top": -24, "left": 124.25, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r9", "top": -24, "left": 114.65, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r10", "top": -24, "left": 105.05, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r11", "top": -24, "left": 95.45, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led-ring", "id": "ring2", "top": -378.36, "left": -10.71, "attrs": { "pixels": "4" } }, { "type": "wokwi-vcc", "id": "vcc1", "top": -373.64, "left": 326.4, "attrs": {} } ], "connections": [ [ "uno:2", "bb1:6b.g", "magenta", [ "v0" ] ], [ "uno:3", "bb1:5b.g", "gray", [ "v0" ] ], [ "uno:4", "bb1:4b.g", "limegreen", [ "v0" ] ], [ "uno:5", "bb1:3b.g", "cyan", [ "v0" ] ], [ "uno:6", "bb1:2b.g", "yellow", [ "v0" ] ], [ "uno:7", "bb1:1b.g", "purple", [ "v0" ] ], [ "r6:2", "r5:2", "green", [ "h0" ] ], [ "bb1:tp.1", "bb1:1t.a", "red", [ "v0.3", "h-8" ] ], [ "bb1:2t.b", "bb1:1t.b", "green", [ "v0" ] ], [ "bb1:3t.a", "bb1:2t.a", "green", [ "v0" ] ], [ "bb1:3t.b", "bb1:4t.b", "green", [ "v0" ] ], [ "bb1:4t.a", "bb1:5t.a", "green", [ "v0" ] ], [ "bb1:5t.b", "bb1:6t.b", "green", [ "v0" ] ], [ "uno:GND.2", "bb1:bn.25", "black", [ "v19.1", "h128.7" ] ], [ "uno:5V", "bb1:bp.24", "red", [ "v28.7", "h109.4" ] ], [ "ring5:DIN", "r7:1", "violet", [ "v48", "h-28.8" ] ], [ "ring2:DIN", "r8:1", "gold", [ "v57.6", "h115.2" ] ], [ "ring4:DIN", "r9:1", "gray", [ "v19.2", "h-76.8" ] ], [ "ring3:DIN", "r10:1", "orange", [ "v28.8", "h144" ] ], [ "ring1:DIN", "r11:1", "blue", [ "v0" ] ], [ "bb1:tp.25", "bb1:bp.25", "red", [ "v0.3", "h40", "v172.8" ] ], [ "bb1:tn.25", "bb1:bn.25", "black", [ "v-0.1", "h49.6", "v192" ] ], [ "r1:1", "bb1:6b.h", "", [ "$bb" ] ], [ "r1:2", "bb1:bn.5", "", [ "$bb" ] ], [ "r2:1", "bb1:5b.h", "", [ "$bb" ] ], [ "r2:2", "bb1:bn.4", "", [ "$bb" ] ], [ "r3:1", "bb1:4b.h", "", [ "$bb" ] ], [ "r3:2", "bb1:bn.3", "", [ "$bb" ] ], [ "r4:1", "bb1:3b.h", "", [ "$bb" ] ], [ "r4:2", "bb1:bn.2", "", [ "$bb" ] ], [ "r5:1", "bb1:2b.h", "", [ "$bb" ] ], [ "r5:2", "bb1:bn.1", "", [ "$bb" ] ], [ "r6:1", "bb1:1b.h", "", [ "$bb" ] ], [ "sw1:1a", "bb1:1b.f", "", [ "$bb" ] ], [ "sw1:2a", "bb1:2b.f", "", [ "$bb" ] ], [ "sw1:3a", "bb1:3b.f", "", [ "$bb" ] ], [ "sw1:4a", "bb1:4b.f", "", [ "$bb" ] ], [ "sw1:5a", "bb1:5b.f", "", [ "$bb" ] ], [ "sw1:6a", "bb1:6b.f", "", [ "$bb" ] ], [ "sw1:7a", "bb1:7b.f", "", [ "$bb" ] ], [ "sw1:8a", "bb1:8b.f", "", [ "$bb" ] ], [ "sw1:8b", "bb1:8t.c", "", [ "$bb" ] ], [ "sw1:7b", "bb1:7t.c", "", [ "$bb" ] ], [ "sw1:6b", "bb1:6t.c", "", [ "$bb" ] ], [ "sw1:5b", "bb1:5t.c", "", [ "$bb" ] ], [ "sw1:4b", "bb1:4t.c", "", [ "$bb" ] ], [ "sw1:3b", "bb1:3t.c", "", [ "$bb" ] ], [ "sw1:2b", "bb1:2t.c", "", [ "$bb" ] ], [ "sw1:1b", "bb1:1t.c", "", [ "$bb" ] ], [ "ring4:GND", "bb1:tn.5", "black", [ "v0" ] ], [ "ring5:GND", "ring4:GND", "black", [ "v0" ] ], [ "ring1:GND", "ring5:GND", "black", [ "v0" ] ], [ "ring2:GND", "ring4:GND", "black", [ "v0" ] ], [ "ring3:GND", "bb1:tn.1", "black", [ "v0" ] ], [ "ring4:VCC", "vcc1:VCC", "red", [ "v9.6", "h67.2" ] ], [ "ring5:VCC", "ring4:VCC", "red", [ "v67.2", "h28.8" ] ], [ "ring1:VCC", "ring5:VCC", "red", [ "v67.2", "h67.2" ] ], [ "ring2:VCC", "ring1:VCC", "red", [ "v38.4", "h76.8" ] ], [ "ring3:VCC", "ring2:VCC", "red", [ "v19.2", "h48" ] ] ], "dependencies": {} }
Generate a diagram.json code for LED sequence
void setup() { pinMode(13, OUTPUT); pinMode(7, OUTPUT); pinMode(1, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(2000); digitalWrite(7, HIGH); delay(2000); digitalWrite(1, HIGH); delay(1000); digitalWrite(13, LOW); digitalWrite(7, LOW); digitalWrite(1, LOW); delay(1000); }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -90, "left": 99.8, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -99.6, "left": 138.2, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led3", "top": -109.2, "left": 186.2, "attrs": { "color": "yellow" } } ], "connections": [ [ "led1:C", "uno:GND.1", "green", [ "v0" ] ], [ "led1:A", "uno:13", "green", [ "v9.6", "h0", "v9.6" ] ], [ "led2:C", "led1:C", "green", [ "v9.6", "h-38" ] ], [ "led2:A", "uno:7", "green", [ "v0" ] ], [ "led3:C", "led2:C", "green", [ "v0" ] ], [ "led3:A", "uno:4", "green", [ "v0" ] ], [ "uno:4", "uno:1", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for window control using arduino
#include <Arduino.h> #include "Button.h" #include "ServoMotor.h" #include "Potentiometer.h" #include "MsgService.h" #include "Lcd.h" #define button_pin 2 #define pot_pin A0 #define servo_pin 10 int lastPercentage = 0; int percentage = 0; int temperature = 0; Button* btn; ServoMotor* window; Potentiometer* potentiometer; Lcd* lcd; enum {automatic, manual} state ; void setup() { // put your setup code here, to run once: MsgService.init(); btn = new Button(button_pin); window = new ServoMotor(servo_pin); potentiometer = new Potentiometer(pot_pin); lcd = new Lcd(0x27,20,4); lcd->init(); window->openPercentage(0); state = automatic; lcd->setCursorTo(3,0); lcd->print("state:Automatic"); Serial.println("Hello Friend!"); } void loop() { // put your main code here, to run repeatedly: bool buttonIsPressed = btn->isPressed(); if(MsgService.isMsgAvailable()){ Msg* msg = MsgService.receiveMsg(); String tag = msg->getContent().substring(0,1); String value = msg->getContent().substring(2); if(tag == "T"){ temperature = value.toInt(); }else if(tag == "S"){ if(value == "automatic"){ state = automatic; }else if(value == "manual"){ state = manual; }else{ lcd->print("State is not set properly"); } }else if(tag == "P"){ percentage = value.toInt(); }else{ Serial.println("I didn't understand!"); } } switch(state){ case automatic: lcd->updateState("Automatic"); lcd->updatePercentage(percentage); MsgService.sendMsg("S:automatic"); if(buttonIsPressed){ state = manual; }else{ lcd->setCursorTo(0, 2); lcd->print(" "); if(percentage != lastPercentage){ lastPercentage = percentage; lcd->updatePercentage(lastPercentage); window->openPercentage(lastPercentage); } } break; case manual: if(buttonIsPressed){ state = automatic; lcd->clearScreen(); }else{ lcd->updateState("Manual"); lcd->updatePercentage(lastPercentage); lcd->updateTemp(temperature); MsgService.sendMsg("S:manual"); int potPercentage = potentiometer->percentageValue(); if(potPercentage != lastPercentage){ lastPercentage = potPercentage; lcd->updatePercentage(lastPercentage); window->openPercentage(lastPercentage); String percentMsg = "P:" + String(lastPercentage); MsgService.sendMsg(percentMsg); } } } delay(200); }
{ "version": 1, "author": "Keni Tafili", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -60.6, "left": 146.8, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "uno", "top": -57, "left": -231, "attrs": {} }, { "type": "wokwi-servo", "id": "servo1", "top": -194, "left": 96, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot1", "top": -174.1, "left": 374.2, "attrs": {} }, { "type": "wokwi-lcd2004", "id": "lcd1", "top": 198.4, "left": 149.6, "attrs": { "pins": "i2c" } }, { "type": "wokwi-pushbutton-6mm", "id": "btn1", "top": 29.3, "left": 339.5, "rotate": 90, "attrs": { "color": "green" } }, { "type": "wokwi-resistor", "id": "r1", "top": 100.8, "left": 335.45, "rotate": 90, "attrs": { "value": "10000" } } ], "connections": [ [ "uno:GND.2", "bb1:bn.1", "black", [ "v28.7", "h243.9" ] ], [ "uno:5V", "bb1:bp.1", "red", [ "v47.9", "h243.8", "v-57.6" ] ], [ "bb1:bp.15", "bb1:19b.j", "red", [ "v0" ] ], [ "bb1:21t.a", "uno:2", "gold", [ "v-9.6", "h-297.6" ] ], [ "servo1:PWM", "uno:10", "green", [ "h0" ] ], [ "servo1:V+", "bb1:bp.3", "purple", [ "h-38.4", "v48.1", "h144", "v9.6" ] ], [ "servo1:GND", "bb1:bn.2", "black", [ "h-57.6", "v76.8", "h153.6" ] ], [ "pot1:GND", "bb1:bn.21", "black", [ "v0" ] ], [ "pot1:VCC", "bb1:bp.24", "red", [ "v0" ] ], [ "pot1:SIG", "uno:A0", "green", [ "v297.6", "h-436.2" ] ], [ "lcd1:GND", "bb1:bn.4", "black", [ "h-28.8", "v-57.6", "h86.4" ] ], [ "lcd1:VCC", "bb1:bp.5", "red", [ "h-19.2", "v-86.3", "h86.4", "v-27.9" ] ], [ "lcd1:SDA", "uno:A4", "orange", [ "h-134.4", "v-28.6" ] ], [ "lcd1:SCL", "uno:A5", "blue", [ "h-115.2", "v9.9" ] ], [ "btn1:1.l", "bb1:21t.e", "", [ "$bb" ] ], [ "btn1:2.l", "bb1:19t.e", "", [ "$bb" ] ], [ "btn1:1.r", "bb1:21b.f", "", [ "$bb" ] ], [ "btn1:2.r", "bb1:19b.f", "", [ "$bb" ] ], [ "r1:1", "bb1:21b.h", "", [ "$bb" ] ], [ "r1:2", "bb1:bn.17", "", [ "$bb" ] ] ], "dependencies": {} }
Generate a diagram.json code for Simple LED blink using arduino
int led = 11; void setup() { pinMode(led, OUTPUT); } void loop() { digitalWrite(led, HIGH); delay(1000); digitalWrite(led, LOW); delay(1000); }
{ "version": 1, "author": "Julian Manders-Jones", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard", "id": "bb1", "top": 93, "left": 70, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "uno", "top": -124.2, "left": 354.6, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 164.8, "left": 589.8, "rotate": 180, "attrs": { "color": "red", "flip": "" } }, { "type": "wokwi-resistor", "id": "r1", "top": 147.95, "left": 499.2, "attrs": { "value": "1000" } } ], "connections": [ [ "bb1:55t.a", "bb1:tn.45", "green", [ "v0" ] ], [ "bb1:54t.c", "bb1:49t.c", "green", [ "v0" ] ], [ "uno:11", "bb1:43t.a", "gold", [ "v0" ] ], [ "r1:1", "bb1:43t.b", "", [ "$bb" ] ], [ "r1:2", "bb1:49t.b", "", [ "$bb" ] ], [ "led1:A", "bb1:54t.d", "", [ "$bb" ] ], [ "led1:C", "bb1:55t.d", "", [ "$bb" ] ], [ "uno:GND.3", "bb1:tn.38", "black", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for relay control
int i = 0; void setup() { pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(4, INPUT_PULLUP); pinMode(5, INPUT_PULLUP); pinMode(6, INPUT_PULLUP); } void loop() { if (digitalRead(4) == 0) { digitalWrite(2, HIGH); } else if (digitalRead(5) == 0) { digitalWrite(2, HIGH); digitalWrite(3, HIGH); } else if (digitalRead(6) == 0) { digitalWrite(3, HIGH); } delay(50); }
{ "version": 1, "author": "Барсук Иванов", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": 4.8, "left": -58.1, "attrs": {} }, { "type": "wokwi-relay-module", "id": "relay1", "top": -86.2, "left": 96, "attrs": {} }, { "type": "wokwi-relay-module", "id": "relay2", "top": 105.8, "left": 96, "attrs": {} }, { "type": "wokwi-pushbutton-6mm", "id": "btn1", "top": -98.2, "left": -124.8, "attrs": { "color": "green", "key": "(" } }, { "type": "wokwi-pushbutton-6mm", "id": "btn2", "top": -98.2, "left": -86.4, "attrs": { "color": "red" } }, { "type": "wokwi-pushbutton-6mm", "id": "btn3", "top": -98.2, "left": -48, "attrs": { "color": "green" } }, { "type": "wokwi-vcc", "id": "vcc1", "top": -133.64, "left": 249.6, "attrs": {} }, { "type": "wokwi-junction", "id": "j1", "top": -72, "left": 350.4, "attrs": {} }, { "type": "wokwi-junction", "id": "j2", "top": 120, "left": 350.4, "attrs": {} } ], "connections": [ [ "relay1:GND", "nano:GND.2", "black", [ "h0" ] ], [ "relay1:IN", "nano:2", "green", [ "h-38.4", "v9.4" ] ], [ "nano:GND.1", "relay2:GND", "black", [ "v67.2" ] ], [ "relay2:IN", "nano:3", "green", [ "h-163.2", "v-163.4", "h115.2" ] ], [ "relay2:VCC", "nano:5V", "red", [ "h0" ] ], [ "relay1:VCC", "relay2:VCC", "red", [ "h-19.2", "v57.6", "h38.4", "v86.4", "h-19.2" ] ], [ "relay1:COM", "relay2:COM", "black", [ "h39.6", "v190.6" ] ], [ "relay2:GND", "relay2:COM", "black", [ "h-19.2", "v47.6", "h172.8", "v-48" ] ], [ "btn2:1.r", "btn3:1.r", "black", [ "v-9.6", "h39.2" ] ], [ "btn1:1.r", "btn2:1.r", "black", [ "v-9.6", "h39.2" ] ], [ "btn3:1.r", "nano:GND.2", "black", [ "v-9.6", "h87.2" ] ], [ "btn3:2.r", "nano:4", "green", [ "h0" ] ], [ "btn2:2.r", "nano:5", "green", [ "h0.8", "v10", "h86.4" ] ], [ "btn1:2.r", "nano:6", "green", [ "h0.8", "v19.6", "h115.2" ] ], [ "relay1:NO", "vcc1:VCC", "red", [ "h0" ] ], [ "relay2:NO", "vcc1:VCC", "red", [ "h49.2", "v-193.8" ] ], [ "relay2:NC", "j2:J", "orange", [ "v-1.2", "h145.2" ] ], [ "j1:J", "relay1:NC", "orange", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for Traffic light control
int Knop = A3; int RED_LED = A0; int GREEN_LED = A2; int YELLOW_LED = A1; typedef enum {Rood, Groen, Geel} states; static states state = Rood; // Constante voor de duur van geel const int geelDuur = 4000; int geelStartTijd = 0; // Tijd in milliseconden voor geel void setup() { pinMode(Knop, INPUT_PULLUP); pinMode(RED_LED, OUTPUT); pinMode(GREEN_LED, OUTPUT); pinMode(YELLOW_LED, OUTPUT); // Zet beginwaarden voor LEDs digitalWrite(RED_LED, HIGH); // Start met rood aan digitalWrite(GREEN_LED, LOW); digitalWrite(YELLOW_LED, LOW); } void loop() { // Lees de waarde van de knop int knopStatus = digitalRead(Knop); switch (state) { case Rood: if (knopStatus == LOW) { // Knop ingedrukt (LOW vanwege INPUT_PULLUP) state = Groen; digitalWrite(RED_LED, LOW); digitalWrite(GREEN_LED, HIGH); digitalWrite(YELLOW_LED, LOW); } break; case Groen: if (knopStatus == HIGH) { // Knop losgelaten state = Geel; geelStartTijd = millis(); // Sla de huidige tijd op digitalWrite(RED_LED, LOW); digitalWrite(GREEN_LED, LOW); digitalWrite(YELLOW_LED, HIGH); } break; case Geel: // Controleer of de huidige tijd 3 seconden na geelStartTijd is if ((millis() - geelStartTijd) >= geelDuur) { state = Rood; digitalWrite(RED_LED, HIGH); digitalWrite(GREEN_LED, LOW); digitalWrite(YELLOW_LED, LOW); } break; } }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": -105, "left": -0.6, "attrs": {} }, { "type": "wokwi-rgb-led", "id": "rgb1", "top": 90.4, "left": -114.1, "attrs": { "common": "cathode" } }, { "type": "wokwi-rgb-led", "id": "rgb2", "top": 157.6, "left": -114.1, "attrs": { "common": "cathode" } }, { "type": "wokwi-rgb-led", "id": "rgb3", "top": 224.8, "left": -114.1, "attrs": { "common": "cathode" } }, { "type": "wokwi-slide-switch", "id": "sw1", "top": 167.6, "left": -6.5, "attrs": { "bounce": "0", "value": "0" } } ], "connections": [ [ "sw1:2", "uno:A3", "green", [ "v19.2", "h192.1" ] ], [ "sw1:3", "uno:5V", "red", [ "v9.6", "h134.6" ] ], [ "uno:GND.2", "sw1:1", "black", [ "v143.9", "h-159.3" ] ], [ "rgb1:COM", "rgb2:COM", "black", [ "v-0.4", "h-28.7", "v67.2" ] ], [ "rgb2:COM", "rgb3:COM", "black", [ "v-0.4", "h-28.7", "v67.2" ] ], [ "uno:GND.3", "rgb1:COM", "black", [ "v220.7", "h-303.2", "v-163.2" ] ], [ "rgb1:R", "uno:A0", "red", [ "v19.2", "h316.8" ] ], [ "rgb3:G", "uno:A2", "green", [ "v28.8", "h308.5" ] ], [ "rgb2:R", "uno:A1", "gold", [ "v19.2", "h76.8", "v38.4", "h240" ] ], [ "rgb2:G", "uno:A1", "gold", [ "v9.6", "h68.5", "v38.4", "h220.8" ] ] ], "dependencies": {} }
Generate a diagram.json code for motor control
#include <LiquidCrystal.h> #define thermocouple A2 #define PRIV 13 #define ENTER 12 #define Next 11 #define Limit 10 #define Heater 8 #define stepPin A4 #define dirPin A3 //Temperature initialization int Temperature = 0; int SetTemperature = 300; int adc_val; byte ShowTemp = 0; byte HeaterCond=0; //Motor initialization byte Speed = 2; byte TestSpeed = 2; byte TestSpeedCond=0; int MotorSpeed = 10; unsigned long previousMillisM = 0; byte Motorcondi = 0; byte MotorStart = 0; //Button initialization byte ButtonNumber = 0; unsigned long previousMillisBtn = 0; byte intervalBtn = 200; byte ActiveBtn = 1; byte BtnCondi = 0; //Action initialization byte Windwos = 0; const int rs = 2, en = 3, d4 = 4, d5 = 5, d6 = 6, d7 = 7; LiquidCrystal lcd(rs, en, d4, d5, d6, d7); void setup() { Serial.begin(9600); lcd.begin(16, 2); pinMode(thermocouple, INPUT); pinMode(PRIV, INPUT); pinMode(ENTER, INPUT); pinMode(Next, INPUT); pinMode(Limit, INPUT); pinMode(Heater, OUTPUT); lcd.setCursor(0, 0); lcd.print("Negs Electronics"); lcd.setCursor(0, 1); lcd.print("Tel:- 0951754711"); delay(3000); lcd.setCursor(0, 0); lcd.print(" "); lcd.setCursor(0, 1); lcd.print(" "); LcdDisplay(1); } void loop() { Button(); Action(); Temps(); Motor(); /* lcd.setCursor(0, 1); lcd.print(ButtonNumber); if(ButtonNumber==1){ Temperature=Temperature+1; ButtonNumber=0; ActiveBtn=0; } lcd.setCursor(0, 0); lcd.print(Temperature); */ } void Action() { if (Windwos == 1) { if (ButtonNumber == 2) { LcdDisplay(4); ButtonNumber = 0; } else if (ButtonNumber == 3) { LcdDisplay(2); ButtonNumber = 0; } } else if (Windwos == 4) { if (ButtonNumber == 2) { LcdDisplay(1); ButtonNumber = 0; } } else if (Windwos == 2) { if (ButtonNumber == 1) { LcdDisplay(1); ButtonNumber = 0; } else if (ButtonNumber == 2) { LcdDisplay(5); ButtonNumber = 0; } else if (ButtonNumber == 3) { LcdDisplay(3); ButtonNumber = 0; } } else if (Windwos == 5) { if (ButtonNumber == 2) { LcdDisplay(2); ButtonNumber = 0; }else if (ButtonNumber == 1) { TestSpeed=TestSpeed>0? TestSpeed-1:TestSpeed; ButtonNumber = 0; }else if (ButtonNumber == 3) { TestSpeed=TestSpeed<10? TestSpeed+1:TestSpeed; ButtonNumber = 0; } } else if (Windwos == 3) { if (ButtonNumber == 1) { LcdDisplay(2); ButtonNumber = 0; } else if (ButtonNumber == 2) { LcdDisplay(6); ButtonNumber = 0; } else if (ButtonNumber == 3) { LcdDisplay(7); ButtonNumber = 0; } } else if (Windwos == 6) { if (ButtonNumber == 2) { LcdDisplay(3); ButtonNumber = 0; } else if (ButtonNumber == 1) { Speed=Speed>0? Speed-1:Speed; ButtonNumber = 0; }else if (ButtonNumber == 3) { Speed=Speed<10? Speed+1:Speed; ButtonNumber = 0; } } else if (Windwos == 7) { if (ButtonNumber == 1) { LcdDisplay(3); ButtonNumber = 0; } else if (ButtonNumber == 2) { LcdDisplay(8); ButtonNumber = 0; } } else if (Windwos == 8) { if (ButtonNumber == 2) { LcdDisplay(7); ButtonNumber = 0; }else if (ButtonNumber == 1) { SetTemperature=SetTemperature>100? SetTemperature-1:SetTemperature; ButtonNumber = 0; }else if (ButtonNumber == 3) { SetTemperature=SetTemperature<500? SetTemperature+1:SetTemperature; ButtonNumber = 0; } } } void Button() { timeBtn(); if (BtnCondi) { BtnCondi = !BtnCondi; ButtonNumber = digitalRead(Next) == 1 ? 3 : ButtonNumber; ButtonNumber = digitalRead(ENTER) == 1 ? 2 : ButtonNumber; ButtonNumber = digitalRead(PRIV) == 1 ? 1 : ButtonNumber; ButtonNumber = digitalRead(Limit) == 1 ? 4 : ButtonNumber; } } void LcdDisplay(byte Condi) { switch (Condi) { case 1: lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("=>Start "); lcd.setCursor(0, 1); lcd.print(" Test Motor "); Windwos = 1; ShowTemp=0; HeaterCond=0; break; case 2: lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("=>Test Motor "); lcd.setCursor(0, 1); lcd.print(" Speed Setting "); Windwos = 2; TestSpeedCond=0; MotorStart=0; break; case 3: lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("=>Speed Setting "); lcd.setCursor(0, 1); lcd.print(" Themp Setting "); Windwos = 3; TestSpeedCond=0; MotorStart=0; break; case 4: lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("<=Stop "); lcd.setCursor(0, 1); lcd.print("Sped="); lcd.setCursor(5, 1); lcd.print(Speed); lcd.setCursor(7, 1); lcd.print(" Temp="); lcd.setCursor(13, 1); lcd.print(Temperature); ShowTemp = 1; HeaterCond=1; Windwos = 4; break; case 5: lcd.setCursor(0, 1); lcd.print(" "); lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("<=Test Motor "); lcd.setCursor(0, 1); lcd.print("Speed = "); lcd.setCursor(8, 1); lcd.print(TestSpeed); Windwos = 5; TestSpeedCond=1; MotorStart=1; break; case 6: lcd.setCursor(0, 1); lcd.print(" "); lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("<=Speed Setting "); lcd.setCursor(0, 1); lcd.print("Speed = "); lcd.setCursor(8, 1); lcd.print(Speed); Windwos = 6; TestSpeedCond=2; MotorStart=1; break; case 7: lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("=>Themp Setting "); lcd.setCursor(0, 1); lcd.print(" "); Windwos = 7; ShowTemp = 0; break; case 8: lcd.setCursor(0, 0); //lcd.print(" "); lcd.print("<=Themp Setting "); lcd.setCursor(0, 1); lcd.print("Temperatur="); lcd.setCursor(11, 1); lcd.print(SetTemperature); Windwos = 8; ShowTemp = 2; break; } } void timeBtn() { unsigned long currentMillisBtn = millis(); if (currentMillisBtn - previousMillisBtn >= intervalBtn) { previousMillisBtn = currentMillisBtn; BtnCondi = BtnCondi == 0 ? 1 : 0; ActiveBtn = 1; } } void Temps() { adc_val = analogRead(thermocouple); Temperature = (((adc_val * 4.88) - 0.0027) / 10.0); if (ShowTemp == 1) { lcd.setCursor(13, 1); lcd.print(Temperature); } else if (ShowTemp == 2) { lcd.setCursor(11, 1); lcd.print(SetTemperature); } if(HeaterCond){ if(SetTemperature>=Temperature){ digitalWrite(Heater,true); MotorStart=0; }else{ digitalWrite(Heater,LOW); MotorStart=1; } }else{ digitalWrite(Heater,LOW); if(Windwos==1){ MotorStart=0; } } } void Motor(){ if(TestSpeedCond==1){ lcd.setCursor(8, 1); lcd.print(TestSpeed); if(TestSpeed==9){ lcd.setCursor(9, 1); lcd.print(" "); } } else if(TestSpeedCond==2){ lcd.setCursor(8, 1); lcd.print(Speed); if(Speed==9){ lcd.setCursor(9, 1); lcd.print(" "); } } if (MotorStart) { timeMotor(); digitalWrite(dirPin, HIGH); if (Motorcondi == 0) { digitalWrite(stepPin, HIGH); } else { digitalWrite(stepPin, LOW); } } } void timeMotor() { if (Windwos == 6 || Windwos == 4) { MotorSpeed = Speed; } else if (Windwos == 5) { MotorSpeed = TestSpeed; } unsigned long currentMillisM = micros(); if (currentMillisM - previousMillisM >= MotorSpeed * 99) { previousMillisM = currentMillisM; Motorcondi = Motorcondi == 0 ? 1 : 0; } }
{ "version": 1, "author": "negs electronics", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 106.2, "left": -39, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": -82.97, "left": 25.6, "attrs": {} }, { "type": "wokwi-pushbutton", "id": "btn1", "top": 83, "left": 297.6, "attrs": { "color": "green", "key": "1" } }, { "type": "wokwi-pushbutton", "id": "btn2", "top": 140.6, "left": 297.6, "attrs": { "color": "blue", "key": "2" } }, { "type": "wokwi-pushbutton", "id": "btn3", "top": 198.2, "left": 297.6, "attrs": { "color": "green", "key": "3" } }, { "type": "wokwi-resistor", "id": "r1", "top": 282.35, "left": 326.4, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "r2", "top": 301.55, "left": 326.4, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "r3", "top": 320.75, "left": 326.4, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "r4", "top": 254.4, "left": -106.15, "rotate": 90, "attrs": { "value": "1000" } }, { "type": "wokwi-pushbutton", "id": "btn4", "top": 159.8, "left": -153.6, "attrs": { "color": "green", "bounce": "1", "key": "4" } }, { "type": "wokwi-led", "id": "led1", "top": 246, "left": 253.4, "attrs": { "color": "red" } }, { "type": "wokwi-a4988", "id": "drv1", "top": 523.2, "left": 292.8, "attrs": {} }, { "type": "wokwi-stepper-motor", "id": "stepper1", "top": 349.21, "left": 374.83, "attrs": { "size": "17" } }, { "type": "wokwi-resistor", "id": "r5", "top": 311.15, "left": 230.4, "attrs": { "value": "1000" } }, { "type": "wokwi-potentiometer", "id": "pot1", "top": -30.1, "left": 345.4, "attrs": {} }, { "type": "wokwi-resistor", "id": "r6", "top": 493.55, "left": 134.4, "attrs": { "value": "1000" } } ], "connections": [ [ "lcd1:RS", "uno:2", "green", [ "v38.4", "h101.8" ] ], [ "lcd1:E", "uno:3", "green", [ "v28.8", "h72.8" ] ], [ "lcd1:D4", "uno:4", "green", [ "v19.2", "h9.6" ] ], [ "lcd1:D5", "uno:5", "green", [ "v0" ] ], [ "lcd1:D6", "uno:6", "green", [ "v9.6", "h-28.6", "v9.6" ] ], [ "lcd1:D7", "uno:7", "green", [ "v19.2", "h0.3" ] ], [ "lcd1:RW", "uno:GND.1", "green", [ "v38.4", "h-19.3" ] ], [ "btn3:2.r", "btn2:2.r", "green", [ "h38.6", "v-57.4" ] ], [ "btn1:2.r", "btn2:2.r", "green", [ "h38.6", "v57.8" ] ], [ "uno:5V", "btn3:2.r", "red", [ "v47.9", "h253.4" ] ], [ "uno:GND.2", "r3:1", "black", [ "v0" ] ], [ "r3:1", "r2:1", "green", [ "v0" ] ], [ "r1:1", "r2:1", "green", [ "v0" ] ], [ "btn3:1.r", "r1:2", "green", [ "v0", "h48.2", "v76.8" ] ], [ "btn2:1.r", "r2:2", "green", [ "v0", "h67.4", "v153.6" ] ], [ "btn1:1.r", "r3:2", "green", [ "v0", "h96.2", "v220.8" ] ], [ "uno:13", "btn1:1.r", "magenta", [ "v-57.6", "h154" ] ], [ "uno:12", "btn2:1.r", "yellow", [ "v-48", "h182.9", "v57.6", "h96" ] ], [ "uno:11", "btn3:1.r", "purple", [ "v-28.8", "h163.8", "v96", "h105.6" ] ], [ "btn4:1.r", "uno:10", "green", [ "v0" ] ], [ "uno:GND.3", "r4:2", "black", [ "v0" ] ], [ "r4:1", "btn4:1.r", "green", [ "h28.8", "v-57.6", "h-38.4" ] ], [ "uno:5V", "btn4:2.r", "red", [ "v47.9", "h-207.4", "v-144", "h19.2", "v-19.2" ] ], [ "drv1:2B", "stepper1:A-", "green", [ "h0" ] ], [ "drv1:2A", "stepper1:A+", "green", [ "h0" ] ], [ "stepper1:B+", "drv1:1A", "green", [ "v0" ] ], [ "drv1:1B", "stepper1:B-", "green", [ "h0" ] ], [ "drv1:RESET", "drv1:SLEEP", "green", [ "h-28.8", "v9.6" ] ], [ "drv1:STEP", "uno:A4", "green", [ "h-19.2", "v-240", "h-76.8" ] ], [ "drv1:DIR", "uno:A3", "green", [ "h-57.6", "v-259.2", "h-57.6" ] ], [ "drv1:VDD", "uno:5V", "green", [ "h-38.25", "v-211.12", "h-211.2" ] ], [ "uno:8", "led1:A", "green", [ "v-19.2", "h125.2", "v201.6", "h28.8" ] ], [ "r5:2", "led1:C", "green", [ "v-9.6", "h-30" ] ], [ "r5:1", "uno:GND.3", "green", [ "v0", "h-86.4", "v-19.2" ] ], [ "pot1:GND", "uno:GND.2", "black", [ "v0" ] ], [ "pot1:VCC", "uno:5V", "red", [ "v0" ] ], [ "pot1:SIG", "uno:A2", "green", [ "v38.4", "h86" ] ], [ "r6:1", "pot1:SIG", "green", [ "v0", "h-19.2" ] ], [ "r6:2", "pot1:GND", "green", [ "v-28.8", "h-97.2", "v-9.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for inbuilt LED blink
int led = 13; void setup() { pinMode(led,OUTPUT); } void loop() { digitalWrite(led,HIGH); delay(500); digitalWrite(led,LOW); delay(500); }
{ "version": 1, "author": "8.9 Fikri nur Fauzi Siswanto", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0.6, "left": -0.6, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -42, "left": 99.8, "attrs": { "color": "red" } } ], "connections": [ [ "led1:C", "uno:GND.1", "green", [ "v0" ] ], [ "led1:A", "uno:13", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for wifi scanning using ESP32
/* ESP32 WiFi Scanning example */ #include "WiFi.h" void setup() { Serial.begin(115200); Serial.println("Initializing WiFi..."); WiFi.mode(WIFI_STA); Serial.println("Setup done!"); } void loop() { Serial.println("Scanning..."); // WiFi.scanNetworks will return the number of networks found int n = WiFi.scanNetworks(); Serial.println("Scan done!"); if (n == 0) { Serial.println("No networks found."); } else { Serial.println(); Serial.print(n); Serial.println(" networks found"); for (int i = 0; i < n; ++i) { // Print SSID and RSSI for each network found Serial.print(i + 1); Serial.print(": "); Serial.print(WiFi.SSID(i)); Serial.print(" ("); Serial.print(WiFi.RSSI(i)); Serial.print(")"); Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*"); delay(10); } } Serial.println(""); // Wait a bit before scanning again delay(5000); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 0, "left": 0, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ] ] }
Generate a diagram.json code for NTP clock
// Learn about the ESP32 WiFi simulation in // https://docs.wokwi.com/guides/esp32-wifi #include <WiFi.h> #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C LCD = LiquidCrystal_I2C(0x27, 16, 2); #define NTP_SERVER "pool.ntp.org" #define UTC_OFFSET 0 #define UTC_OFFSET_DST 0 void spinner() { static int8_t counter = 0; const char* glyphs = "\xa1\xa5\xdb"; LCD.setCursor(15, 1); LCD.print(glyphs[counter++]); if (counter == strlen(glyphs)) { counter = 0; } } void printLocalTime() { struct tm timeinfo; if (!getLocalTime(&timeinfo)) { LCD.setCursor(0, 1); LCD.println("Connection Err"); return; } LCD.setCursor(8, 0); LCD.println(&timeinfo, "%H:%M:%S"); LCD.setCursor(0, 1); LCD.println(&timeinfo, "%d/%m/%Y %Z"); } void setup() { Serial.begin(115200); LCD.init(); LCD.backlight(); LCD.setCursor(0, 0); LCD.print("Connecting to "); LCD.setCursor(0, 1); LCD.print("WiFi "); WiFi.begin("Wokwi-GUEST", "", 6); while (WiFi.status() != WL_CONNECTED) { delay(250); spinner(); } Serial.println(""); Serial.println("WiFi connected"); Serial.print("IP address: "); Serial.println(WiFi.localIP()); LCD.clear(); LCD.setCursor(0, 0); LCD.println("Online"); LCD.setCursor(0, 1); LCD.println("Updating time..."); configTime(UTC_OFFSET, UTC_OFFSET_DST, NTP_SERVER); } void loop() { printLocalTime(); delay(250); }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": -76.8, "left": 43.24, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": -70.4, "left": 188, "attrs": { "pins": "i2c" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "lcd1:SDA", "esp:21", "green", [ "v-4.49", "h-28.8", "v23.89" ] ], [ "lcd1:GND", "esp:GND.2", "black", [ "h-16.67", "v162.78" ] ], [ "lcd1:VCC", "esp:3V3", "red", [ "h-9.6", "v-57.5", "h-134.55" ] ], [ "lcd1:SCL", "esp:22", "purple", [ "h-19.2", "v-18.9" ] ] ], "dependencies": {} }
End of preview. Expand in Data Studio
README.md exists but content is empty.
Downloads last month
51