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": {} }
Generate a diagram.json code for ESP32 HTTP server
/* ESP32 HTTP IoT Server Example for Wokwi.com https://wokwi.com/projects/320964045035274834 To test, you need the Wokwi IoT Gateway, as explained here: https://docs.wokwi.com/guides/esp32-wifi#the-private-gateway Then start the simulation, and open http://localhost:9080 in another browser tab. Note that the IoT Gateway requires a Wokwi Club subscription. To purchase a Wokwi Club subscription, go to https://wokwi.com/club */ #include <WiFi.h> #include <WiFiClient.h> #include <WebServer.h> #include <uri/UriBraces.h> #define WIFI_SSID "Wokwi-GUEST" #define WIFI_PASSWORD "" // Defining the WiFi channel speeds up the connection: #define WIFI_CHANNEL 6 WebServer server(80); const int LED1 = 26; const int LED2 = 27; bool led1State = false; bool led2State = false; void sendHtml() { String response = R"( <!DOCTYPE html><html> <head> <title>ESP32 Web Server Demo</title> <meta name="viewport" content="width=device-width, initial-scale=1"> <style> html { font-family: sans-serif; text-align: center; } body { display: inline-flex; flex-direction: column; } h1 { margin-bottom: 1.2em; } h2 { margin: 0; } div { display: grid; grid-template-columns: 1fr 1fr; grid-template-rows: auto auto; grid-auto-flow: column; grid-gap: 1em; } .btn { background-color: #5B5; border: none; color: #fff; padding: 0.5em 1em; font-size: 2em; text-decoration: none } .btn.OFF { background-color: #333; } </style> </head> <body> <h1>ESP32 Web Server</h1> <div> <h2>LED 1</h2> <a href="/toggle/1" class="btn LED1_TEXT">LED1_TEXT</a> <h2>LED 2</h2> <a href="/toggle/2" class="btn LED2_TEXT">LED2_TEXT</a> </div> </body> </html> )"; response.replace("LED1_TEXT", led1State ? "ON" : "OFF"); response.replace("LED2_TEXT", led2State ? "ON" : "OFF"); server.send(200, "text/html", response); } void setup(void) { Serial.begin(115200); pinMode(LED1, OUTPUT); pinMode(LED2, OUTPUT); WiFi.begin(WIFI_SSID, WIFI_PASSWORD, WIFI_CHANNEL); Serial.print("Connecting to WiFi "); Serial.print(WIFI_SSID); // Wait for connection while (WiFi.status() != WL_CONNECTED) { delay(100); Serial.print("."); } Serial.println(" Connected!"); Serial.print("IP address: "); Serial.println(WiFi.localIP()); server.on("/", sendHtml); server.on(UriBraces("/toggle/{}"), []() { String led = server.pathArg(0); Serial.print("Toggle LED #"); Serial.println(led); switch (led.toInt()) { case 1: led1State = !led1State; digitalWrite(LED1, led1State); break; case 2: led2State = !led2State; digitalWrite(LED2, led2State); break; } sendHtml(); }); server.begin(); Serial.println("HTTP server started"); } void loop(void) { server.handleClient(); delay(2); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 0, "left": -4.76, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 109.55, "left": -76.8, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "r2", "top": 119.15, "left": -76.8, "attrs": { "value": "1000" } }, { "type": "wokwi-led", "id": "led1", "top": 34.8, "left": -111.4, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led2", "top": 63.6, "left": -140.2, "attrs": { "color": "green" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "r1:1", "led1:A", "green", [ "v0.07", "h-10" ] ], [ "r2:1", "led2:A", "green", [ "h-38.4", "v-19.2" ] ], [ "esp:GND.1", "led2:C", "black", [ "h0" ] ], [ "esp:GND.1", "led1:C", "black", [ "h0" ] ], [ "esp:26", "r1:2", "green", [ "h0" ] ], [ "r2:2", "esp:27", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for ESP32 joke machine
/* ESP32 HTTPClient Jokes API Example https://wokwi.com/projects/342032431249883731 Copyright (C) 2022, Uri Shaked */ #include <WiFi.h> #include <HTTPClient.h> #include <ArduinoJson.h> #include <Adafruit_GFX.h> #include <Adafruit_ILI9341.h> const char* ssid = "Wokwi-GUEST"; const char* password = ""; #define BTN_PIN 5 #define TFT_DC 2 #define TFT_CS 15 Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC); const String url = "https://v2.jokeapi.dev/joke/Programming"; String getJoke() { HTTPClient http; http.useHTTP10(true); http.begin(url); http.GET(); String result = http.getString(); DynamicJsonDocument doc(2048); DeserializationError error = deserializeJson(doc, result); // Test if parsing succeeds. if (error) { Serial.print("deserializeJson() failed: "); Serial.println(error.c_str()); return "<error>"; } String type = doc["type"].as<String>(); String joke = doc["joke"].as<String>(); String setup = doc["setup"].as<String>(); String delivery = doc["delivery"].as<String>(); http.end(); return type.equals("single") ? joke : setup + " " + delivery; } void nextJoke() { tft.setTextColor(ILI9341_WHITE); tft.println("\nLoading joke..."); String joke = getJoke(); tft.setTextColor(ILI9341_GREEN); tft.println(joke); } void setup() { pinMode(BTN_PIN, INPUT_PULLUP); WiFi.begin(ssid, password, 6); tft.begin(); tft.setRotation(1); tft.setTextColor(ILI9341_WHITE); tft.setTextSize(2); tft.print("Connecting to WiFi"); while (WiFi.status() != WL_CONNECTED) { delay(100); tft.print("."); } tft.print("\nOK! IP="); tft.println(WiFi.localIP()); nextJoke(); } void loop() { if (digitalRead(BTN_PIN) == LOW) { tft.fillScreen(ILI9341_BLACK); tft.setCursor(0, 0); nextJoke(); } delay(100); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 96, "left": -158.36, "attrs": { "fastTLS": "1" } }, { "type": "wokwi-ili9341", "id": "lcd1", "top": 34.2, "left": 88.1, "rotate": 90, "attrs": {} }, { "type": "wokwi-pushbutton", "id": "btn1", "top": 294.2, "left": 144, "attrs": { "color": "green", "label": "New joke" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "lcd1:GND", "esp:GND.2", "black", [ "h-19.2", "v91.54" ] ], [ "lcd1:RST", "esp:4", "purple", [ "h-48", "v67.2" ] ], [ "lcd1:D/C", "esp:2", "#8f4814", [ "h-28.8", "v44.14" ] ], [ "lcd1:SCK", "esp:18", "gray", [ "v-0.01", "h-48", "v-19.2" ] ], [ "lcd1:MISO", "esp:19", "orange", [ "h-67.2", "v-9.61", "h0", "v-19.2" ] ], [ "lcd1:MOSI", "esp:23", "green", [ "h-38.4", "v-67.31" ] ], [ "esp:5V", "lcd1:VCC", "red", [ "h-21.83", "v-206.3", "h201.6", "v48.5" ] ], [ "lcd1:CS", "esp:15", "violet", [ "h-57.6", "v105.6" ] ], [ "esp:GND.2", "btn1:2.l", "black", [ "h76.8", "v201.4" ] ], [ "esp:5", "btn1:1.l", "green", [ "h19.2", "v96" ] ] ], "dependencies": {} }
Generate a diagram.json code for oled display with esp32 using micropython
from machine import Pin, I2C import ssd1306 # ESP32 Pin assignment i2c = I2C(0, scl=Pin(22), sda=Pin(21)) oled_width = 128 oled_height = 64 oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c) oled.text('Hello, Wokwi!', 10, 10) oled.show()
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 9.6, "left": -100.76, "attrs": { "env": "micropython-20231005-v1.21.0" } }, { "type": "board-ssd1306", "id": "oled1", "top": 99.14, "left": 57.83, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "oled1:SCL", "esp:22", "green", [ "v0" ] ], [ "oled1:SDA", "esp:21", "blue", [ "v-19.2", "h-124.73" ] ], [ "oled1:GND", "esp:GND.2", "black", [ "v-67.2", "h-96" ] ], [ "oled1:VCC", "esp:3V3", "red", [ "v-28.8", "h0.15", "v-76.8", "h-201.75" ] ] ], "dependencies": {} }
Generate a diagram.json code for micro-python MQTT weather logger with ESP32
import network import time from machine import Pin import dht import ujson from umqtt.simple import MQTTClient # MQTT Server Parameters MQTT_CLIENT_ID = "micropython-weather-demo" MQTT_BROKER = "broker.mqttdashboard.com" MQTT_USER = "" MQTT_PASSWORD = "" MQTT_TOPIC = "wokwi-weather" sensor = dht.DHT22(Pin(15)) print("Connecting to WiFi", end="") sta_if = network.WLAN(network.STA_IF) sta_if.active(True) sta_if.connect('Wokwi-GUEST', '') while not sta_if.isconnected(): print(".", end="") time.sleep(0.1) print(" Connected!") print("Connecting to MQTT server... ", end="") client = MQTTClient(MQTT_CLIENT_ID, MQTT_BROKER, user=MQTT_USER, password=MQTT_PASSWORD) client.connect() print("Connected!") prev_weather = "" while True: print("Measuring weather conditions... ", end="") sensor.measure() message = ujson.dumps({ "temp": sensor.temperature(), "humidity": sensor.humidity(), }) if message != prev_weather: print("Updated!") print("Reporting to MQTT topic {}: {}".format(MQTT_TOPIC, message)) client.publish(MQTT_TOPIC, message) prev_weather = message else: print("No change") time.sleep(1)
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": -37.58, "left": -96.37, "attrs": {} }, { "type": "wokwi-dht22", "id": "dht1", "top": -32.2, "left": 40.16, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "dht1:VCC", "esp:3V3", "red", [ "v109.3", "h-170.36", "v-200.78" ] ], [ "dht1:SDA", "esp:15", "green", [ "v0" ] ], [ "dht1:GND", "esp:GND.1", "black", [ "v99.7", "h-189.56", "v-66.38" ] ] ], "dependencies": {} }
Generate a diagram.json code for simon says esp32-c3
#include "pitches.h" /* Define pin numbers for LEDs, buttons and speaker: */ const uint8_t buttonPins[] = {0, 1, 2, 3}; const uint8_t ledPins[] = {8, 7, 6, 5}; #define SPEAKER_PIN 10 // These are connected to 74HC595 shift register (used to show game score): const int LATCH_PIN = 18; // 74HC595 pin 12 const int DATA_PIN = 19; // 74HC595 pin 14 const int CLOCK_PIN = 9; // 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 4 is floating (disconnected): randomSeed(analogRead(4)); } /* 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(6); } } 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-buzzer", "id": "buzzer", "top": 21.6, "left": 126.6, "attrs": { "volume": "0.1" } }, { "type": "wokwi-led", "id": "led-red", "top": 6, "left": 3.8, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led-green", "top": 73.2, "left": 3.8, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led-blue", "top": 6, "left": 272.6, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led-yellow", "top": 73.2, "left": 272.6, "attrs": { "color": "yellow" } }, { "type": "wokwi-pushbutton", "id": "btn-red", "top": 6.2, "left": 48, "attrs": { "color": "red", "key": "1", "label": "1" } }, { "type": "wokwi-pushbutton", "id": "btn-green", "top": 73.4, "left": 48, "attrs": { "color": "green", "key": "2", "label": "2" } }, { "type": "wokwi-pushbutton", "id": "btn-blue", "top": 6.2, "left": 201.6, "attrs": { "color": "blue", "key": "3", "label": "3" } }, { "type": "wokwi-pushbutton", "id": "btn-yellow", "top": 73.4, "left": 201.6, "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": {} }, { "type": "board-esp32-c3-devkitm-1", "id": "esp", "top": 136.02, "left": 120.9, "rotate": 90, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 196.8, "left": 9.05, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r2", "top": 235.2, "left": -0.55, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r3", "top": 235.2, "left": 268.25, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r4", "top": 196.8, "left": 277.85, "rotate": 90, "attrs": { "value": "220" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "esp:GND.1", "buzzer:1", "black", [ "v-9.6", "h-19.2", "v-38.4", "h-57.6" ] ], [ "esp:0", "btn-yellow:1.l", "gold", [ "v-38.4", "h42", "v-48" ] ], [ "esp:GND.1", "btn-yellow:2.r", "black", [ "v-9.6", "h48", "v-57.8" ] ], [ "esp:1", "btn-blue:1.l", "blue", [ "v-43.2", "h47.6", "v-110.4" ] ], [ "esp:GND.1", "btn-blue:2.r", "black", [ "v-9.6", "h48", "v-125" ] ], [ "esp:3", "btn-green:2.r", "green", [ "v-19.2", "h-72", "v-48.2" ] ], [ "esp:GND.1", "btn-green:1.l", "black", [ "v-9.6", "h-188.4", "v-76.8" ] ], [ "esp:2", "btn-red:2.r", "orange", [ "v-24", "h-76.8", "v-110.6" ] ], [ "esp:GND.1", "btn-red:1.l", "black", [ "v-9.6", "h-188.4", "v-144" ] ], [ "esp:10", "buzzer:2", "purple", [ "v-57.6", "h29.2" ] ], [ "esp:GND.1", "led-yellow:C", "black", [ "v-9.6", "h48", "v-44", "h9.2" ] ], [ "esp:GND.1", "led-blue:C", "black", [ "v-9.6", "h48", "v-111.2", "h9.2" ] ], [ "esp:GND.1", "led-green:C", "black", [ "v-9.6", "h-220.8", "v-48" ] ], [ "esp:GND.1", "led-red:C", "black", [ "v-9.6", "h-220.8", "v-115.2" ] ], [ "esp:3V3.1", "sr1:VCC", "red", [ "v-19.2", "h96", "v67.2", "h115.2" ] ], [ "esp:9", "sr1:SHCP", "gray", [ "v21.58", "h192" ] ], [ "esp:18", "sr1:STCP", "purple", [ "v26.38", "h278.4" ] ], [ "esp:19", "sr1:DS", "blue", [ "v31.18", "h307.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" ] ], [ "esp:GND.1", "sr1:GND", "black", [ "v-9.6", "h134.4" ] ], [ "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" ] ], [ "esp:6", "r1:2", "orange", [ "v7.18", "h-115.2" ] ], [ "r1:1", "led-red:A", "orange", [ "v-105.6", "h-9.6" ] ], [ "esp:5", "r2:2", "green", [ "v11.98", "h-115.2" ] ], [ "r2:1", "led-green:A", "green", [ "h0" ] ], [ "r3:2", "esp:8", "gold", [ "v3.6", "h-115.2" ] ], [ "r3:1", "led-yellow:A", "gold", [ "h0" ] ], [ "r4:2", "esp:7", "blue", [ "v46.8", "h-144" ] ], [ "r4:1", "led-blue:A", "blue", [ "v-105.6", "h-9.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for esp32-c3 alarm clock
#include <Keypad.h> #include "Clock.h" #include "Weather.h" #include <WiFi.h> #include <HTTPClient.h> #include <ArduinoJson.h> #include <LiquidCrystal_I2C.h> #define I2C_ADDR 0x27 #define LCD_COLUMNS 16 #define LCD_LINES 2 uint8_t state; unsigned long clockTimer; unsigned long weatherAPItimer; unsigned long weatherDisplayTimer; const char* password = ""; const char* ssid = "Wokwi-GUEST"; uint8_t valIndex; uint8_t cursorPos; char entered_value [6]; const uint8_t ROWS = 4; const uint8_t COLS = 4; char keys[ROWS][COLS] = { { '1', '2', '3', 'A' }, { '4', '5', '6', 'B' }, { '7', '8', '9', 'C' }, { '*', '0', '#', 'D' } }; uint8_t colPins[COLS] = { 1, 0, 3, 2 }; uint8_t rowPins[ROWS] = { 4, 5, 6, 7 }; LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES); Clock rtc(&lcd); Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS); void enterTime() { state = 1; memset(&entered_value[0], 0, sizeof(entered_value)); cursorPos = 0; valIndex = 0; lcd.clear(); lcd.setCursor(0, 0); lcd.print("Set clock then "); lcd.setCursor(0, 1); lcd.print("press # to save."); delay(3000); lcd.clear(); } void enterAlarm() { state = 2; memset(&entered_value[0], 0, sizeof(entered_value)); cursorPos = 0; valIndex = 0; lcd.clear(); lcd.setCursor(0, 0); lcd.print("Enter alarm time"); lcd.setCursor(0, 1); lcd.print("press # to save."); delay(3000); lcd.clear(); } void nextChar(char key) { if (valIndex < 6) { entered_value[valIndex] = key; lcd.setCursor(0, 0); lcd.print(entered_value); cursorPos++; valIndex++; } } void eraseChar() { if (valIndex > 0 ) { valIndex--; cursorPos--; entered_value[valIndex] = '\0'; lcd.setCursor(cursorPos, 0); lcd.print(' '); lcd.setCursor(cursorPos, 0); } } void keyPadState0() { char key = keypad.getKey(); switch(key) { case 'A': enterAlarm(); break; case 'C': enterTime(); break; case '#': rtc.silence(); break; case '*': rtc.addToSnooze(); break; } } void keyPadState1() { char key = keypad.getKey(); switch(key) { case '#': rtc.setTime(entered_value); state = 0; break; case '*': eraseChar(); break; default: if (isDigit(key)) { nextChar(key); } break; } } void keyPadState2() { char key = keypad.getKey(); switch(key) { case '#': rtc.setAlarm(entered_value); state = 0; break; case '*': eraseChar(); break; default: if (isDigit(key)) { nextChar(key); } break; } } void getInput() { switch (state) { case 0: keyPadState0(); break; case 1: keyPadState1(); break; case 2: keyPadState2(); break; } } void setup() { pinMode(8, OUTPUT); pinMode(10, OUTPUT); Wire.begin(18, 19); lcd.init(); lcd.backlight(); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { lcd.print("."); delay(1000); } lcd.clear(); if (!rtc.setTimeFromAPI()) { char t [] = __TIME__; char compileTime [] = { t[0], t[1], t[3], t[4], t[6], t[7] }; rtc.setTime(compileTime); } getWeather(lcd); printWeather(lcd); } void loop() { if (state == 0) { unsigned long millisNow = millis(); if (millisNow - clockTimer >= 1000) { clockTimer = millisNow; rtc.updateClock(); } if (millisNow - weatherDisplayTimer >= 10000) { weatherDisplayTimer = millisNow; printWeather(lcd); } if (millisNow - weatherAPItimer >= 3600000) { weatherAPItimer = millisNow; getWeather(lcd); } } getInput(); }
{ "version": 1, "author": "Maverick", "editor": "wokwi", "parts": [ { "type": "board-esp32-c3-devkitm-1", "id": "esp", "top": -454.69, "left": 262.1, "rotate": 90, "attrs": {} }, { "type": "wokwi-membrane-keypad", "id": "keypad1", "top": -824.35, "left": 162.4, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": -444.26, "left": 414.36, "attrs": { "pins": "i2c" } }, { "type": "wokwi-buzzer", "id": "bz1", "top": -479.95, "left": 71.13, "rotate": 270, "attrs": { "volume": "0.1" } }, { "type": "wokwi-led", "id": "led1", "top": -380.49, "left": 88.44, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": -250.19, "left": 181.17, "rotate": 180, "attrs": { "value": "220" } }, { "type": "wokwi-text", "id": "A", "top": -772.62, "left": 404.66, "attrs": { "text": "<------- Set Alarm" } }, { "type": "wokwi-text", "id": "C", "top": -666.01, "left": 405.29, "attrs": { "text": "<------- Set Clock" } }, { "type": "wokwi-text", "id": "|1", "top": -578.59, "left": 322.96, "attrs": { "text": "|" } }, { "type": "wokwi-text", "id": "^1", "top": -581.3, "left": 321.71, "attrs": { "text": "^" } }, { "type": "wokwi-text", "id": "#", "top": -572.97, "left": 326.2, "attrs": { "text": "------------------------------ Submit / Silence Alarm" } }, { "type": "wokwi-text", "id": "*", "top": -572.62, "left": 22.16, "attrs": { "text": "Erase / Snooze-----------------" } }, { "type": "wokwi-text", "id": "^2", "top": -580.39, "left": 206.9, "attrs": { "text": "^" } }, { "type": "wokwi-text", "id": "|2", "top": -579.17, "left": 208.11, "attrs": { "text": "|" } } ], "connections": [ [ "esp:1", "keypad1:C1", "cyan", [ "v-18.48", "h15.7" ] ], [ "esp:0", "keypad1:C2", "yellow", [ "v-9.6", "h10.51" ] ], [ "esp:3", "keypad1:C3", "limegreen", [ "v-9.59", "h-13.05" ] ], [ "esp:2", "keypad1:C4", "magenta", [ "v-18.48", "h-12.9" ] ], [ "esp:4", "keypad1:R1", "#8f4814", [ "v7.96", "h-84.23", "v-144.63", "h71.03" ] ], [ "esp:5", "keypad1:R2", "orange", [ "v14.55", "h-87.01", "v-144.5", "h74.21" ] ], [ "esp:6", "keypad1:R3", "green", [ "v20.84", "h-89.17", "v-143.71", "h76.27" ] ], [ "esp:7", "keypad1:R4", "purple", [ "v27.13", "h-91.33", "v-143.27", "h78.33" ] ], [ "lcd1:GND", "esp:GND.1", "black", [ "h-11.48", "v-27.23", "h-35.28" ] ], [ "lcd1:VCC", "esp:3V3.1", "red", [ "h-18.59", "v-30.7", "h-37.77" ] ], [ "lcd1:SCL", "esp:19", "limegreen", [ "h-10.71", "v117.57", "h-160.66", "v-62.9" ] ], [ "lcd1:SDA", "esp:18", "cyan", [ "h-19.02", "v119.09", "h-142.94" ] ], [ "led1:A", "esp:8", "gray", [ "v80.81", "h210.16" ] ], [ "led1:C", "r1:2", "black", [ "v93.24", "h119.4" ] ], [ "esp:GND.8", "r1:1", "black", [ "v0" ] ], [ "esp:10", "bz1:2", "white", [ "v-19.85", "h-127.94" ] ], [ "bz1:1", "esp:GND.4", "black", [ "h7.46", "v-0.31", "h107.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for ESP32-S2
void setup() { // put your setup code here, to run once: Serial.begin(115200); Serial.println("Hello, ESP32-S2!"); } void loop() { // put your main code here, to run repeatedly: delay(10); // this speeds up the simulation }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "id": "esp", "type": "board-esp32-s2-devkitm-1" } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "" ], [ "esp:RX", "$serialMonitor:TX", "" ] ] }
Generate a diagram.json code for ESP32-S3
void setup() { // put your setup code here, to run once: Serial.begin(115200); Serial.println("Hello, ESP32-S3!"); } void loop() { // put your main code here, to run repeatedly: delay(10); // this speeds up the simulation }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "id": "esp", "type": "board-esp32-s3-devkitc-1" } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "" ], [ "esp:RX", "$serialMonitor:TX", "" ] ] }
Generate a diagram.json code for ESP32-C3
void setup() { // put your setup code here, to run once: Serial.begin(115200); Serial.println("Hello, ESP32-C3!"); } void loop() { // put your main code here, to run repeatedly: delay(10); // this speeds up the simulation }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "id": "esp", "type": "board-esp32-c3-devkitm-1" } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "" ], [ "esp:RX", "$serialMonitor:TX", "" ] ] }
Generate a diagram.json code for ESP32-C6
void setup() { // put your setup code here, to run once: Serial.begin(115200); Serial.println("Hello, ESP32-C6!"); } void loop() { // put your main code here, to run repeatedly: delay(10); // this speeds up the simulation }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "id": "esp", "type": "board-esp32-c6-devkitc-1" } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "" ], [ "esp:RX", "$serialMonitor:TX", "" ] ] }
Generate a diagram.json code for ESP32-H2
void setup() { // put your setup code here, to run once: Serial.begin(115200); Serial.println("Hello, ESP32-H2!"); } void loop() { // put your main code here, to run repeatedly: delay(10); // this speeds up the simulation }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "id": "esp", "type": "board-esp32-h2-devkitm-1" } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "" ], [ "esp:RX", "$serialMonitor:TX", "" ] ] }
Generate a diagram.json code for ESP32-S3-box3
/* ESP32-S3-BOX + Adafruit_ILI9341 Example https://wokwi.com/projects/399780007361137665 */ #include "SPI.h" #include "Adafruit_GFX.h" #include "Adafruit_ILI9341.h" #define TFT_DC 4 #define TFT_CS 5 #define TFT_MOSI 6 #define TFT_CLK 7 #define TFT_CTRL 45 #define TFT_RST 48 Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST); void setup() { Serial.begin(115200); Serial.println("Welcome to Wokwi, ESP32-S3-BOX-3"); pinMode(TFT_CTRL, OUTPUT); digitalWrite(TFT_CTRL, HIGH); tft.begin(); // Configure the direction of the display const uint8_t mode = 0xc8; tft.sendCommand(ILI9341_MADCTL, &mode, 1); tft.setCursor(88, 60); tft.setTextColor(ILI9341_RED); tft.setTextSize(3); tft.println("S3-BOX-3"); } const uint32_t colors[] = { ILI9341_GREEN, ILI9341_CYAN, ILI9341_MAGENTA, ILI9341_YELLOW, }; uint8_t colorIndex = 0; void loop() { tft.setTextSize(2); tft.setCursor(36, 106); tft.setTextColor(colors[colorIndex++ % 4]); tft.println("Welcome to Wokwi!"); delay(250); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-esp32-s3-box-3", "id": "esp32", "top": -24.91, "left": -388.54, "attrs": { "psramSize": "16", "flashSize": "16" } } ], "connections": [ [ "$serialMonitor:RX", "esp32:G14", "", [] ], [ "$serialMonitor:TX", "esp32:G11", "", [] ] ], "dependencies": {} }
Generate a diagram.json code for core-s3
#include "SPI.h" #include "Adafruit_GFX.h" #include "Adafruit_ILI9341.h" #define TFT_DC 35 #define TFT_CS 3 #define TFT_MOSI 37 #define TFT_CLK 36 Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK); void setup() { Serial.begin(115200); Serial.println("Welcome to Wokwi, CORE-S3"); tft.begin(); // Configure the direction of the display const uint8_t mode = 0xc8; tft.sendCommand(ILI9341_MADCTL, &mode, 1); tft.setCursor(88, 60); tft.setTextColor(ILI9341_RED); tft.setTextSize(3); tft.println("CORE-S3"); } const uint32_t colors[] = { ILI9341_GREEN, ILI9341_CYAN, ILI9341_MAGENTA, ILI9341_YELLOW, }; uint8_t colorIndex = 0; void loop() { tft.setTextSize(2); tft.setCursor(36, 106); tft.setTextColor(colors[colorIndex++ % 4]); tft.println("Welcome to Wokwi!"); delay(250); }
{ "version": 1, "author": "Ambitious maker", "editor": "wokwi", "parts": [ { "type": "board-m5stack-core-s3", "id": "board", "top": -179.23, "left": -62.59, "attrs": { "serialInterface": "USB_SERIAL_JTAG" } } ], "connections": [ [ "$serialMonitor:RX", "board:G43", "", [] ], [ "$serialMonitor:TX", "board:G44", "", [] ] ], "dependencies": {} }
Generate a diagram.json code for RGB LED sequence using XIOA-ESP32-C3
void setup() { Serial.begin(115200); pinMode(D2, OUTPUT); pinMode(D3, OUTPUT); pinMode(D4, OUTPUT); Serial.println(""); Serial.println("Hello, XIAO ESP32-C3!"); Serial.println("Welcome to Wokwi :-)"); } void loop() { Serial.println("Red"); digitalWrite(D2, HIGH); delay(500); digitalWrite(D2, LOW); Serial.println("Green"); digitalWrite(D3, HIGH); delay(500); digitalWrite(D3, LOW); Serial.println("Blue"); digitalWrite(D4, HIGH); delay(500); digitalWrite(D4, LOW); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-xiao-esp32-c3", "id": "esp", "top": 38.97, "left": 13.78, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 6, "left": -73, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": 147.95, "left": -57.6, "attrs": { "value": "1000" } }, { "type": "wokwi-led", "id": "led2", "top": 15.6, "left": -101.8, "attrs": { "color": "green" } }, { "type": "wokwi-resistor", "id": "r2", "top": 167.15, "left": -57.6, "attrs": { "value": "1000" } }, { "type": "wokwi-junction", "id": "j1", "top": 148.8, "left": 24, "attrs": {} }, { "type": "wokwi-led", "id": "led3", "top": 25.2, "left": -130.6, "attrs": { "color": "blue" } }, { "type": "wokwi-resistor", "id": "r3", "top": 186.35, "left": -57.6, "attrs": { "value": "1000" } } ], "connections": [ [ "esp:D2", "led1:A", "green", [ "h0" ] ], [ "led1:C", "r1:1", "black", [ "v0" ] ], [ "esp:D3", "led2:A", "green", [ "h0" ] ], [ "led2:C", "r2:1", "black", [ "v0" ] ], [ "r2:2", "j1:J", "black", [ "v0", "h27.6" ] ], [ "j1:J", "r1:2", "black", [ "v0" ] ], [ "esp:GND", "j1:J", "black", [ "h19.82", "v86.4" ] ], [ "led3:A", "esp:D4", "green", [ "v0" ] ], [ "led3:C", "r3:1", "black", [ "v0" ] ], [ "j1:J", "r3:2", "black", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for RGB LED sequence with XIAO-ESP32-C6
void setup() { Serial.begin(115200); pinMode(D2, OUTPUT); pinMode(D3, OUTPUT); pinMode(D4, OUTPUT); Serial.println(""); Serial.println("Hello, XIAO ESP32-C6!"); Serial.println("Welcome to Wokwi :-)"); } void loop() { Serial.println("Red"); digitalWrite(D2, HIGH); delay(500); digitalWrite(D2, LOW); Serial.println("Green"); digitalWrite(D3, HIGH); delay(500); digitalWrite(D3, LOW); Serial.println("Blue"); digitalWrite(D4, HIGH); delay(500); digitalWrite(D4, LOW); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-xiao-esp32-c6", "id": "esp", "top": 38.97, "left": 13.78, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 6, "left": -73, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": 147.95, "left": -57.6, "attrs": { "value": "1000" } }, { "type": "wokwi-led", "id": "led2", "top": 15.6, "left": -101.8, "attrs": { "color": "green" } }, { "type": "wokwi-resistor", "id": "r2", "top": 167.15, "left": -57.6, "attrs": { "value": "1000" } }, { "type": "wokwi-junction", "id": "j1", "top": 148.8, "left": 24, "attrs": {} }, { "type": "wokwi-led", "id": "led3", "top": 25.2, "left": -130.6, "attrs": { "color": "blue" } }, { "type": "wokwi-resistor", "id": "r3", "top": 186.35, "left": -57.6, "attrs": { "value": "1000" } } ], "connections": [ [ "esp:D2", "led1:A", "green", [ "h0" ] ], [ "led1:C", "r1:1", "black", [ "v0" ] ], [ "esp:D3", "led2:A", "green", [ "h0" ] ], [ "led2:C", "r2:1", "black", [ "v0" ] ], [ "r2:2", "j1:J", "black", [ "v0", "h27.6" ] ], [ "j1:J", "r1:2", "black", [ "v0" ] ], [ "esp:GND", "j1:J", "black", [ "h19.82", "v86.4" ] ], [ "led3:A", "esp:D4", "green", [ "v0" ] ], [ "led3:C", "r3:1", "black", [ "v0" ] ], [ "j1:J", "r3:2", "black", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for RGB LED sequence with XIOA-ESP32-S3
void setup() { Serial.begin(115200); pinMode(D2, OUTPUT); pinMode(D3, OUTPUT); pinMode(D4, OUTPUT); Serial.println(""); Serial.println("Hello, XIAO ESP32-S3!"); Serial.println("Welcome to Wokwi :-)"); } void loop() { Serial.println("Red"); digitalWrite(D2, HIGH); delay(500); digitalWrite(D2, LOW); Serial.println("Green"); digitalWrite(D3, HIGH); delay(500); digitalWrite(D3, LOW); Serial.println("Blue"); digitalWrite(D4, HIGH); delay(500); digitalWrite(D4, LOW); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-xiao-esp32-s3", "id": "esp", "top": 38.97, "left": 13.78, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 6, "left": -73, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": 147.95, "left": -57.6, "attrs": { "value": "1000" } }, { "type": "wokwi-led", "id": "led2", "top": 15.6, "left": -101.8, "attrs": { "color": "green" } }, { "type": "wokwi-resistor", "id": "r2", "top": 167.15, "left": -57.6, "attrs": { "value": "1000" } }, { "type": "wokwi-junction", "id": "j1", "top": 148.8, "left": 24, "attrs": {} }, { "type": "wokwi-led", "id": "led3", "top": 25.2, "left": -130.6, "attrs": { "color": "blue" } }, { "type": "wokwi-resistor", "id": "r3", "top": 186.35, "left": -57.6, "attrs": { "value": "1000" } } ], "connections": [ [ "esp:D2", "led1:A", "green", [ "h0" ] ], [ "led1:C", "r1:1", "black", [ "v0" ] ], [ "esp:D3", "led2:A", "green", [ "h0" ] ], [ "led2:C", "r2:1", "black", [ "v0" ] ], [ "r2:2", "j1:J", "black", [ "v0", "h27.6" ] ], [ "j1:J", "r1:2", "black", [ "v0" ] ], [ "esp:GND", "j1:J", "black", [ "h19.82", "v86.4" ] ], [ "led3:A", "esp:D4", "green", [ "v0" ] ], [ "led3:C", "r3:1", "black", [ "v0" ] ], [ "j1:J", "r3:2", "black", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for ESP32 wifi
#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": "Carl B", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb2", "top": 198.6, "left": -35.6, "attrs": {} }, { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 219.14, "left": 32.5, "rotate": 90, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "esp:GND.2", "bb2:bn.25", "black", [ "v38.4", "h144", "v-19.2" ] ], [ "esp:3V3", "bb2:bp.25", "red", [ "v0.15", "h134.4", "v105.6" ] ], [ "esp:12", "bb2:7t.d", "", [ "$bb" ] ], [ "esp:13", "bb2:5t.d", "", [ "$bb" ] ], [ "esp:14", "bb2:8t.d", "", [ "$bb" ] ], [ "esp:25", "bb2:11t.d", "", [ "$bb" ] ], [ "esp:26", "bb2:10t.d", "", [ "$bb" ] ], [ "esp:27", "bb2:9t.d", "", [ "$bb" ] ], [ "esp:32", "bb2:13t.d", "", [ "$bb" ] ], [ "esp:33", "bb2:12t.d", "", [ "$bb" ] ], [ "esp:34", "bb2:15t.d", "", [ "$bb" ] ], [ "esp:35", "bb2:14t.d", "", [ "$bb" ] ], [ "esp:3V3", "bb2:19t.d", "", [ "$bb" ] ], [ "esp:EN", "bb2:18t.d", "", [ "$bb" ] ], [ "esp:VP", "bb2:17t.d", "", [ "$bb" ] ], [ "esp:VN", "bb2:16t.d", "", [ "$bb" ] ], [ "esp:GND.1", "bb2:6t.d", "", [ "$bb" ] ], [ "esp:D2", "bb2:4t.d", "", [ "$bb" ] ], [ "esp:D3", "bb2:3t.d", "", [ "$bb" ] ], [ "esp:CMD", "bb2:2t.d", "", [ "$bb" ] ], [ "esp:5V", "bb2:1t.d", "", [ "$bb" ] ] ], "dependencies": {} }
Generate a diagram.json code for ultrasonic distance measurement using LED indicators(ESP32)
// Define GPIO pins for Ultrasonic Sensor and LED #define TRIG_PIN 12 // GPIO for Trig pin #define ECHO_PIN 14 // GPIO for Echo pin #define RED_LED 27 #define YELLOW_LED 26 #define GREEN_LED 25 void setup() { // Set GPIO pins pinMode(TRIG_PIN, OUTPUT); pinMode(ECHO_PIN, INPUT); pinMode(RED_LED, OUTPUT); pinMode(YELLOW_LED, OUTPUT); pinMode(GREEN_LED, OUTPUT); // Start Serial Monitor Serial.begin(115200); } void loop() { // Measure distance float distance = measureDistance(); // Display distance on Serial Monitor Serial.print("Distance: "); Serial.print(distance); Serial.println(" cm"); // Check distance if (distance < 100) { digitalWrite(GREEN_LED, HIGH); // Turn on LED } else { digitalWrite(GREEN_LED, LOW); // Turn off LED } if (distance > 100) { digitalWrite(YELLOW_LED, HIGH); } else { digitalWrite(YELLOW_LED, LOW); } if (distance > 202) { digitalWrite(RED_LED, HIGH); } else { digitalWrite(RED_LED, LOW); } delay(500); // Delay for 500 milliseconds } // Function to measure distance float measureDistance() { // Send Trig signal digitalWrite(TRIG_PIN, LOW); delayMicroseconds(2); digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10); digitalWrite(TRIG_PIN, LOW); // Read Echo time long duration = pulseIn(ECHO_PIN, HIGH); // Calculate distance (unit: centimeters) float distance = duration * 0.034 / 2; return distance; }
{ "version": 1, "author": "KAMONPHOB WONGPAN", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -70.2, "left": -150.8, "attrs": {} }, { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 103.94, "left": -92.3, "rotate": 90, "attrs": {} }, { "type": "wokwi-hc-sr04", "id": "ultrasonic1", "top": -94.5, "left": -138.5, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -42, "left": 71, "attrs": { "color": "yellow" } }, { "type": "wokwi-led", "id": "led2", "top": -42, "left": 42.2, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led3", "top": -42, "left": 99.8, "attrs": { "color": "green" } }, { "type": "wokwi-resistor", "id": "r1", "top": 33.6, "left": 37.85, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r2", "top": 33.6, "left": 66.65, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r3", "top": 33.6, "left": 95.45, "rotate": 90, "attrs": { "value": "220" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "ultrasonic1:VCC", "bb1:bp.4", "red", [ "v28.8", "h-19.2" ] ], [ "bb1:bp.1", "esp:5V", "green", [ "v-0.9", "h-17.6" ] ], [ "bb1:bn.1", "esp:GND.1", "black", [ "v27.5", "h30.4" ] ], [ "bb1:8t.e", "esp:12", "orange", [ "v124.8", "h-19.2" ] ], [ "bb1:9t.e", "esp:14", "gold", [ "v124.8", "h-19.2" ] ], [ "bb1:10t.e", "bb1:bn.6", "purple", [ "v0" ] ], [ "bb1:tn.16", "bb1:20t.a", "green", [ "v0" ] ], [ "bb1:tn.19", "bb1:23t.a", "green", [ "v0" ] ], [ "bb1:tn.21", "bb1:26t.a", "green", [ "v0" ] ], [ "r1:2", "esp:27", "red", [ "h-96", "v85.2", "h-28.8" ] ], [ "r3:2", "esp:25", "green", [ "h0", "v85.2", "h-153.6" ] ], [ "bb1:tn.25", "esp:GND.2", "black", [ "v-0.1", "h49.6", "v297.6" ] ], [ "r2:2", "esp:26", "gold", [ "v8.4", "h-76.8", "v69.6", "h-67.2", "v16.65" ] ], [ "ultrasonic1:VCC", "bb1:7t.c", "", [ "$bb" ] ], [ "ultrasonic1:TRIG", "bb1:8t.c", "", [ "$bb" ] ], [ "ultrasonic1:ECHO", "bb1:9t.c", "", [ "$bb" ] ], [ "ultrasonic1:GND", "bb1:10t.c", "", [ "$bb" ] ], [ "led1:A", "bb1:24t.c", "", [ "$bb" ] ], [ "led1:C", "bb1:23t.c", "", [ "$bb" ] ], [ "led2:A", "bb1:21t.c", "", [ "$bb" ] ], [ "led2:C", "bb1:20t.c", "", [ "$bb" ] ], [ "led3:A", "bb1:27t.c", "", [ "$bb" ] ], [ "led3:C", "bb1:26t.c", "", [ "$bb" ] ], [ "r1:1", "bb1:21t.d", "", [ "$bb" ] ], [ "r1:2", "bb1:21b.h", "", [ "$bb" ] ], [ "r2:1", "bb1:24t.d", "", [ "$bb" ] ], [ "r2:2", "bb1:24b.h", "", [ "$bb" ] ], [ "r3:1", "bb1:27t.d", "", [ "$bb" ] ], [ "r3:2", "bb1:27b.h", "", [ "$bb" ] ] ], "dependencies": {} }
Generate a diagram.json code for Temperature and Humidity using DHT11 with ESP32
#include "DHT.h" #include <Wire.h> #include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #define R_LED 26 #define B_LED 25 #define DHTPIN 19 #define DHTTYPE DHT22 #define SCREEN_WIDTH 128 #define SCREEN_HEIGHT 64 #define OLED_RESET -1 DHT dht(DHTPIN, DHTTYPE); Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); void setup() { Serial.begin(9600); pinMode(R_LED, OUTPUT); digitalWrite(R_LED, LOW); pinMode(B_LED, OUTPUT); digitalWrite(B_LED, LOW); dht.begin(); display.begin(SSD1306_SWITCHCAPVCC, 0x3c); display.clearDisplay(); display.setTextSize(1); display.setTextColor(WHITE); display.setCursor(0,0); display.println(" OLED 0.96 TESTER"); display.display(); } void loop() { delay(1000); float h = dht.readHumidity(); float t = dht.readTemperature(); if (isnan(h) || isnan(t)) { Serial.println(F("Failed to read from DHT sensor!")); return; } display.clearDisplay(); display.setCursor(0,2); display.print("Temp : "); display.print(String(t)); display.print(" %"); display.setCursor(0,12); display.print("Humid : "); display.print(String(h)); display.print(" *C"); display.display(); if(t > 50){ digitalWrite(R_LED, HIGH); }else if(h > 50){ digitalWrite(B_LED, HIGH); }else if (t < 49){ digitalWrite(R_LED, LOW); }else if (h < 49){ digitalWrite(B_LED, LOW); } }
{ "version": 1, "author": "ADITHEP TONGRUENG", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -147, "left": -160.4, "attrs": {} }, { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 76.8, "left": -52.76, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -118.8, "left": -82.6, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led2", "top": -118.8, "left": -121, "attrs": { "color": "red" } }, { "type": "wokwi-dht22", "id": "dht1", "top": -143.7, "left": 42.6, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": -43.2, "left": -86.95, "rotate": 90, "attrs": { "value": "470" } }, { "type": "wokwi-resistor", "id": "r2", "top": -43.2, "left": -125.35, "rotate": 90, "attrs": { "value": "470" } }, { "type": "wokwi-resistor", "id": "r3", "top": -14.95, "left": 8.2, "rotate": 180, "attrs": { "value": "4700" } }, { "type": "board-ssd1306", "id": "oled1", "top": 166.34, "left": 115.43, "attrs": { "i2cAddress": "0x3c" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "bb1:21b.g", "bb1:16b.g", "green", [ "v0" ] ], [ "bb1:16b.j", "bb1:bp.13", "red", [ "v0" ] ], [ "esp:GND.2", "bb1:bn.25", "black", [ "v0", "h96" ] ], [ "esp:3V3", "bb1:bp.1", "red", [ "h-95.85", "v-38.4" ] ], [ "bb1:4t.e", "bb1:bn.3", "black", [ "v0" ] ], [ "bb1:8t.e", "bb1:bn.6", "black", [ "v0" ] ], [ "bb1:22b.j", "esp:19", "blue", [ "v163.2", "h-9.6" ] ], [ "oled1:GND", "bb1:bn.22", "black", [ "v-28.8", "h-28.8" ] ], [ "oled1:VCC", "bb1:bp.21", "red", [ "v-76.8", "h-57.45" ] ], [ "esp:22", "oled1:SCL", "cyan", [ "h0" ] ], [ "esp:21", "oled1:SDA", "magenta", [ "h134.4" ] ], [ "esp:26", "bb1:5b.j", "green", [ "h0" ] ], [ "esp:25", "bb1:9b.j", "green", [ "v0", "h-28.65", "v-163.2", "h19.2" ] ], [ "bb1:24b.j", "bb1:bn.20", "black", [ "v0" ] ], [ "led2:A", "bb1:5t.c", "", [ "$bb" ] ], [ "led2:C", "bb1:4t.c", "", [ "$bb" ] ], [ "dht1:VCC", "bb1:21b.f", "", [ "$bb" ] ], [ "dht1:SDA", "bb1:22b.f", "", [ "$bb" ] ], [ "dht1:NC", "bb1:23b.f", "", [ "$bb" ] ], [ "dht1:GND", "bb1:24b.f", "", [ "$bb" ] ], [ "r1:1", "bb1:9t.d", "", [ "$bb" ] ], [ "r1:2", "bb1:9b.h", "", [ "$bb" ] ], [ "r2:1", "bb1:5t.d", "", [ "$bb" ] ], [ "r2:2", "bb1:5b.h", "", [ "$bb" ] ], [ "r3:1", "bb1:22b.h", "", [ "$bb" ] ], [ "r3:2", "bb1:16b.h", "", [ "$bb" ] ], [ "led1:A", "bb1:9t.c", "", [ "$bb" ] ], [ "led1:C", "bb1:8t.c", "", [ "$bb" ] ] ], "dependencies": {} }
Generate a diagram.json code for Ultrasoni distamce measurement using ESP32
#include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x27, 16, 2); #define TRIG_PIN 26 #define ECHO_PIN 25 float duration_us, distance_cm; void setup(){ lcd.init(); lcd.backlight(); pinMode(TRIG_PIN, OUTPUT); pinMode(ECHO_PIN, INPUT); } void loop() { digitalWrite(TRIG_PIN, HIGH ); delayMicroseconds(10); digitalWrite(TRIG_PIN, LOW); duration_us = pulseIn(ECHO_PIN, HIGH); distance_cm = 0.017* duration_us; lcd.clear(); lcd.setCursor(0, 0); lcd.print("Distance:"); lcd.print(distance_cm); delay(500); }
{ "version": 1, "author": "manlika Phunut", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": -9.6, "left": -4.76, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": -80, "left": 149.6, "attrs": { "pins": "i2c" } }, { "type": "wokwi-hc-sr04", "id": "ultrasonic1", "top": -56.1, "left": -215.3, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "ultrasonic1:VCC", "esp:5V", "red", [ "v0" ] ], [ "lcd1:VCC", "esp:5V", "red", [ "h-9.6", "v268.9", "h-153.6", "v-38.4" ] ], [ "lcd1:GND", "esp:GND.2", "black", [ "h0" ] ], [ "ultrasonic1:GND", "esp:GND.1", "black", [ "v0" ] ], [ "ultrasonic1:TRIG", "esp:26", "blue", [ "v0" ] ], [ "ultrasonic1:ECHO", "esp:25", "purple", [ "v0" ] ], [ "lcd1:SDA", "esp:21", "yellow", [ "h-38.4", "v96.2" ] ], [ "lcd1:SCL", "esp:22", "magenta", [ "h-48", "v57.9" ] ] ], "dependencies": {} }
Generate a diagram.json code for 8-bit counter
#include <Arduino.h> const int buttonPin = 14; // GPIO pin for button const int ledPin1 = 26; // GPIO pin for first LED const int ledPin2 = 25; // GPIO pin for second LED const int ledPin3 = 33; // GPIO pin for third LED int buttonState = 0; // variable for reading the button status int lastButtonState = 0; // previous button state int clickCount = 0; // variable to count button clicks unsigned long lastDebounceTime = 0; // the last time the output pin was toggled unsigned long debounceDelay = 0; // the debounce time; increase if the output flickers void setup() { pinMode(buttonPin, INPUT); pinMode(ledPin1, OUTPUT); pinMode(ledPin2, OUTPUT); pinMode(ledPin3, OUTPUT); Serial.begin(115200); } void loop() { int reading = digitalRead(buttonPin); if (reading != lastButtonState) { lastDebounceTime = millis(); // reset the debouncing timer } if ((millis() - lastDebounceTime) > debounceDelay) { if (reading != buttonState) { buttonState = reading; if (buttonState == HIGH) { clickCount = (clickCount + 1) % 8; // increment and wrap click count Serial.println(clickCount); updateLEDs(); // immediately update the LEDs } } } lastButtonState = reading; } void updateLEDs() { // Reset all LEDs to LOW digitalWrite(ledPin1, LOW); digitalWrite(ledPin2, LOW); digitalWrite(ledPin3, LOW); // Update LEDs based on click count switch (clickCount) { case 1: digitalWrite(ledPin3, HIGH); break; case 2: digitalWrite(ledPin2, HIGH); break; case 3: digitalWrite(ledPin2, HIGH); digitalWrite(ledPin3, HIGH); break; case 4: digitalWrite(ledPin1, HIGH); break; case 5: digitalWrite(ledPin1, HIGH); digitalWrite(ledPin3, HIGH); break; case 6: digitalWrite(ledPin1, HIGH); digitalWrite(ledPin2, HIGH); break; case 7: digitalWrite(ledPin1, HIGH); digitalWrite(ledPin2, HIGH); digitalWrite(ledPin3, HIGH); break; } }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": -38.4, "left": 72.04, "attrs": {} }, { "type": "wokwi-pushbutton", "id": "btn1", "top": -13, "left": -182.4, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led1", "top": -99.6, "left": -101.8, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -99.6, "left": -63.4, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led3", "top": -99.6, "left": -25, "attrs": { "color": "red" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "btn1:2.r", "esp:GND.1", "green", [ "h67.4", "v77" ] ], [ "esp:GND.3", "led1:C", "black", [ "h19.2", "v153.6", "h0", "v-9.6", "h-278.4" ] ], [ "esp:GND.3", "led2:C", "black", [ "h19.2", "v144", "h-240" ] ], [ "esp:GND.3", "led3:C", "black", [ "h28.8", "v144", "h-211.2" ] ], [ "esp:14", "btn1:1.r", "green", [ "h-172.65", "v-96", "h-19.2" ] ], [ "esp:26", "led1:A", "green", [ "h-153.45", "v0" ] ], [ "esp:25", "led2:A", "green", [ "v0", "h-143.85" ] ], [ "esp:33", "led3:A", "green", [ "h-76.65", "v-9.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for ESP32 base IoT system
#include <WiFi.h> #include <PubSubClient.h> // WiFi credentials const char* ssid = "Wokwi-GUEST"; const char* password = ""; // MQTT server details const char* mqttServer = "broker.hivemq.com"; int mqttPort = 1883; const char* mqttUser = ""; const char* mqttPassword = ""; const char* mqttClientID = "ESP32Client"; const char* topic = "DEIOT/room/3395498B"; // Create WiFi and MQTT client objects WiFiClient wifiClient; PubSubClient client(wifiClient); // Define GPIO pins for LEDs and analog input const int ledPin = 32; const int yellowLedPin = 22; const int analogPin = 12; // Timing variables for LED blinking and analog reading long previousMillisR = 0; int intervalR = 1000; long previousMillisAnalog = 0; int intervalAnalog = 2000; void setup() { // Set GPIO pins as outputs pinMode(ledPin, OUTPUT); pinMode(yellowLedPin, OUTPUT); // Start Serial Monitor Serial.begin(115200); // Connect to WiFi setupWiFi(); // Set MQTT server and callback function client.setServer(mqttServer, mqttPort); client.setCallback(mqttCallback); // Connect to MQTT broker while (!client.connected()) { if (client.connect(mqttClientID)) { Serial.println("Connected to MQTT Broker!"); } else { Serial.print("MQTT connection failed. State: "); Serial.println(client.state()); delay(2000); } } } void loop() { long currentMillis = millis(); // Blink LED at regular intervals if (currentMillis - previousMillisR >= intervalR) { previousMillisR = currentMillis; digitalWrite(ledPin, !digitalRead(ledPin)); } // Read analog value and publish to MQTT at regular intervals if (currentMillis - previousMillisAnalog >= intervalAnalog) { previousMillisAnalog = currentMillis; int analogValue = analogRead(analogPin); Serial.print("Analog Value from pin "); Serial.print(analogPin); Serial.print(": "); Serial.println(analogValue); String payload = String(analogValue); if (client.publish(topic, payload.c_str())) { Serial.println("Published to MQTT"); } else { Serial.println("Failed to publish to MQTT"); } } // Handle MQTT client loop client.loop(); } void setupWiFi() { Serial.println("Connecting to WiFi..."); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.print("."); } Serial.println(); Serial.print("Connected to WiFi with IP: "); Serial.println(WiFi.localIP()); } void mqttCallback(char* topic, byte* payload, unsigned int length) { String message = ""; for (int i = 0; i < length; i++) { message += (char)payload[i]; } Serial.print("Message received on topic "); Serial.print(topic); Serial.print(": "); Serial.println(message); int receivedValue = message.toInt(); if (receivedValue < 1000) { digitalWrite(yellowLedPin, HIGH); Serial.println("yellow LED ON: Value is less than 1000"); } else { digitalWrite(yellowLedPin, LOW); Serial.println("yellow LED OFF: Value is greater than or equal to 1000"); } }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 57.6, "left": 91.24, "attrs": {} }, { "type": "wokwi-led", "id": "led2", "top": -22.8, "left": -130.6, "attrs": { "color": "red" } }, { "type": "wokwi-potentiometer", "id": "pot1", "top": -20.5, "left": -48.2, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 15.6, "left": 263, "attrs": { "color": "yellow" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "led2:A", "esp:32", "green", [ "v0" ] ], [ "led2:C", "esp:GND.1", "black", [ "v0" ] ], [ "pot1:SIG", "esp:12", "green", [ "v105.6", "h-0.4", "v38.4" ] ], [ "esp:GND.2", "pot1:GND", "black", [ "v-48", "h-134.4", "v28.8", "h-67.2" ] ], [ "pot1:VCC", "esp:3V3", "red", [ "v0" ] ], [ "led1:C", "esp:22", "green", [ "v0" ] ], [ "esp:GND.2", "led1:A", "black", [ "v0", "h96" ] ] ], "dependencies": {} }
Generate a diagram.json code for Smart energy monitoring system using ESP32
#include <WiFi.h> #include <HTTPClient.h> #include <Wire.h> #include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #define SCREEN_WIDTH 128 // OLED width, in pixels #define SCREEN_HEIGHT 64 // OLED height, in pixels // OLED display object connected to I2C Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire); // WiFi credentials const char* ssid = "Wokwi-GUEST"; const char* password = ""; // ThingSpeak API information const char* server = "https://api.thingspeak.com"; const char* apiKey = "CDJEFTTGRAFUMV67"; // Replace with your ThingSpeak Write API Key void setup() { Serial.begin(115200); if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { Serial.println(F("SSD1306 allocation failed")); for (;;); } display.clearDisplay(); display.setTextColor(WHITE); WiFi.begin(ssid, password); Serial.print("Connecting to WiFi"); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.print("."); } Serial.println("\nWiFi connected!"); } void sendDataToThingSpeak() { if (WiFi.status() == WL_CONNECTED) { HTTPClient http; String url = String(server) + "/update?api_key=" + apiKey; http.begin(url); int httpCode = http.GET(); if (httpCode > 0) { Serial.println("Data sent to ThingSpeak successfully!"); } else { Serial.print("Error sending data: "); Serial.println(http.errorToString(httpCode).c_str()); } http.end(); } else { Serial.println("WiFi not connected! Unable to send data."); } } void loop() { static unsigned long lastSendTime = 0; if (millis() - lastSendTime >= 10000) { // Send data every 10 seconds sendDataToThingSpeak(); lastSendTime = millis(); } display.clearDisplay(); display.setTextSize(1); display.setCursor(0, 0); display.print("Sending data..."); display.display(); }
{ "version": 1, "author": "Faiz Jefri", "editor": "wokwi", "parts": [ { "type": "wokwi-esp32-devkit-v1", "id": "esp", "top": -33.7, "left": 14.2, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": -43.2, "left": 249.05, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r2", "top": 43.2, "left": 249.05, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "board-ssd1306", "id": "oled1", "top": -131.26, "left": 345.83, "attrs": { "i2cAddress": "0x3c" } }, { "type": "wokwi-resistor", "id": "r3", "top": 3.95, "left": 316.8, "attrs": { "value": "100" } }, { "type": "wokwi-potentiometer", "id": "pot1", "top": -106.9, "left": -173, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot2", "top": 200.3, "left": -192.2, "attrs": {} } ], "connections": [ [ "esp:TX0", "$serialMonitor:RX", "", [] ], [ "esp:RX0", "$serialMonitor:TX", "", [] ], [ "r2:2", "esp:3V3", "red", [ "v46.8", "h-162.9" ] ], [ "r1:1", "esp:GND.1", "green", [ "h-57.6", "v105.6" ] ], [ "r2:1", "r1:2", "black", [ "h0" ] ], [ "oled1:SCL", "esp:D22", "black", [ "h-162.9", "v57.9" ] ], [ "oled1:SDA", "esp:D21", "black", [ "h-259.13", "v86.8" ] ], [ "r3:1", "r1:2", "black", [ "v0", "h-28.8" ] ], [ "pot1:VCC", "esp:VIN", "red", [ "v0" ] ], [ "pot1:GND", "esp:GND.2", "green", [ "v0" ] ], [ "pot2:VCC", "esp:VIN", "red", [ "v0" ] ], [ "pot2:GND", "esp:GND.2", "green", [ "v0" ] ], [ "pot1:SIG", "esp:D34", "black", [ "v0" ] ], [ "pot2:SIG", "esp:D35", "black", [ "v-124.8", "h-0.4", "v-38.4" ] ], [ "oled1:VCC", "esp:VIN", "red", [ "v-9.6", "h76.95", "v316.8", "h-451.2" ] ], [ "oled1:GND", "esp:GND.1", "green", [ "v-19.2", "h96", "v268.8" ] ], [ "esp:VP", "r3:2", "red", [ "h-19.2", "v-86.7", "h326.4", "v76.8", "h48" ] ] ], "dependencies": {} }
Generate a diagram.json code for ESP32 based dual core system
#include <Arduino.h> // Task handles for the two tasks TaskHandle_t Task1; TaskHandle_t Task2; // GPIO pins for the two 7-segment displays const int seg1Pins[] = {2, 4, 5, 18, 19, 21, 22}; const int seg2Pins[] = {23, 25, 26, 27, 14, 12, 13}; // Binary codes for digits 0-9 for 7-segment display const byte digitCodes[] = { 0b00111111, // 0 0b00000110, // 1 0b01011011, // 2 0b01001111, // 3 0b01100110, // 4 0b01101101, // 5 0b01111101, // 6 0b00000111, // 7 0b01111111, // 8 0b01101111 // 9 }; void setup() { Serial.begin(115200); // Set all segment pins as outputs for (int i = 0; i < 7; i++) { pinMode(seg1Pins[i], OUTPUT); pinMode(seg2Pins[i], OUTPUT); } // Create Task1 on core 0 xTaskCreatePinnedToCore( Task1code, // Function to implement the task "Task1", // Name of the task 10000, // Stack size in words NULL, // Task input parameter 1, // Priority of the task &Task1, // Task handle 0 // Core where the task should run ); delay(500); // Create Task2 on core 1 xTaskCreatePinnedToCore( Task2code, // Function to implement the task "Task2", // Name of the task 10000, // Stack size in words NULL, // Task input parameter 1, // Priority of the task &Task2, // Task handle 1 // Core where the task should run ); delay(500); } // Function to display a number on a 7-segment display void displayNumber(const int *pins, int number) { byte code = digitCodes[number]; for (int i = 0; i < 7; i++) { digitalWrite(pins[i], (code >> i) & 0x01); } } // Task1 code: Counts from 1 to 9 on the first 7-segment display void Task1code(void *pvParameters) { Serial.print("Task1 core: "); Serial.println(xPortGetCoreID()); int count = 1; for (;;) { displayNumber(seg1Pins, count); count++; if (count > 9) count = 1; delay(1500); // Delay for 1.5 seconds } } // Task2 code: Counts from 9 to 1 on the second 7-segment display void Task2code(void *pvParameters) { Serial.print("Task2 core: "); Serial.println(xPortGetCoreID()); int count = 9; for (;;) { displayNumber(seg2Pins, count); count--; if (count < 1) count = 9; delay(500); // Delay for 0.5 seconds } } void loop() { // Empty loop as tasks are running independently }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": -9.6, "left": 24.04, "attrs": {} }, { "type": "wokwi-7segment", "id": "sevseg1", "top": 81.78, "left": 225.88, "attrs": { "common": "cathode" } }, { "type": "wokwi-7segment", "id": "sevseg2", "top": 100.98, "left": -129.32, "attrs": { "common": "cathode" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "sevseg1:B", "esp:4", "green", [ "v-8.76", "h-57.6", "v67.2", "h0" ] ], [ "sevseg1:A", "esp:2", "green", [ "v-18.36", "h-57.6", "v96" ] ], [ "sevseg1:C", "esp:5", "green", [ "v19.2", "h28.8", "v-115.2", "h-67.2", "v57.6" ] ], [ "sevseg1:D", "esp:18", "green", [ "v19.2", "h-48", "v-67.2" ] ], [ "sevseg1:E", "esp:19", "green", [ "v28.8", "h-48", "v-86.4" ] ], [ "sevseg1:F", "esp:21", "green", [ "v-37.56", "h-67.2", "v38.4" ] ], [ "sevseg1:G", "esp:22", "green", [ "v-47.16", "h-76.8", "v9.6" ] ], [ "sevseg1:COM.1", "esp:GND.3", "green", [ "h0", "v38.4", "h-96", "v-105.6" ] ], [ "sevseg2:A", "esp:23", "green", [ "v-143.16", "h230.4", "v67.2" ] ], [ "sevseg2:B", "esp:25", "green", [ "v0" ] ], [ "sevseg2:C", "esp:26", "green", [ "v19.2", "h19.2", "v-76.8" ] ], [ "sevseg2:D", "esp:27", "green", [ "v28.8", "h48", "v-76.8" ] ], [ "sevseg2:E", "esp:14", "green", [ "v38.4", "h67.2", "v-76.8" ] ], [ "sevseg2:F", "esp:12", "green", [ "v-18.36", "h67.2", "v57.6" ] ], [ "sevseg2:G", "esp:13", "green", [ "v0.84", "h-19.2", "v115.2", "h96", "v-57.6" ] ], [ "sevseg2:COM.1", "esp:GND.1", "green", [ "h0", "v9.6", "h86.4", "v-28.8" ] ] ], "dependencies": {} }
Generate a diagram.json code for temperature measurement using NTC sensor(ESP32)
const int tempPin = 14; #include <LiquidCrystal.h> LiquidCrystal lcd(18, 5, 17, 16, 4, 0); void setup() { Serial.begin(115200); Serial.println("Hello"); lcd.begin(16, 2); //lcd.print("ADC Example"); delay(1000); } void loop() { int adc = analogRead(tempPin); const float BETA = 3950.0; // should match the Beta Coefficient of the thermistor float temp = 1 / (log(1 / (4096.0 / adc - 1)) / BETA + 1.0 / 298.15) - 273.15; lcd.clear(); lcd.setCursor(0, 0); lcd.print("temp: "); lcd.println(String(temp)+char(223)+"C"); delay(2000); }
{ "version": 1, "author": "NAGA NANDHINI P", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 67.2, "left": -23.96, "attrs": {} }, { "type": "wokwi-ntc-temperature-sensor", "id": "ntc1", "top": 117.8, "left": -202.2, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": -92.57, "left": 35.2, "attrs": {} }, { "type": "wokwi-vcc", "id": "vcc1", "top": 67.96, "left": 220.8, "attrs": {} }, { "type": "wokwi-gnd", "id": "gnd1", "top": 76.8, "left": 95.4, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "lcd1:RS", "esp:18", "green", [ "v134.4", "h-18.9" ] ], [ "lcd1:E", "esp:5", "green", [ "v144", "h-38.4" ] ], [ "esp:0", "lcd1:D7", "green", [ "h115.2", "v-182.4" ] ], [ "lcd1:D6", "esp:4", "green", [ "v172.8", "h-105.4" ] ], [ "lcd1:D5", "esp:16", "green", [ "v163.2", "h-95.9" ] ], [ "lcd1:D4", "esp:17", "green", [ "v153.6", "h-86.4" ] ], [ "lcd1:RW", "lcd1:K", "green", [ "v19.2", "h105.5" ] ], [ "lcd1:RW", "gnd1:GND", "black", [ "v38.4", "h-0.1" ] ], [ "lcd1:A", "vcc1:VCC", "red", [ "v57.6", "h28.7" ] ], [ "ntc1:OUT", "esp:14", "green", [ "h28.8", "v38.3" ] ], [ "ntc1:GND", "esp:GND.1", "black", [ "h19.2", "v76.8", "h28.65" ] ], [ "ntc1:VCC", "esp:3V3", "red", [ "h28.8", "v-57.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for Automatic light intensity control using LDR (ESP32)
const int ldrPin = 34; // GPIO pin for LDR const int ledPin = 32; // GPIO pin for LED void setup() { Serial.begin(115200); pinMode(ldrPin, INPUT); pinMode(ledPin, OUTPUT); } void loop() { int ldrValue = analogRead(ldrPin); // Read the LDR value Serial.print("LDR Value: "); Serial.println(ldrValue); // Map the LDR value to a PWM value (0-255) int ledBrightness = map(ldrValue, 0, 4095, 0, 255); analogWrite(ledPin, ledBrightness); // Set the LED brightness delay(100); // Delay for a short period }
{ "version": 1, "author": "Vigneshwaran", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -22.2, "left": 12.4, "attrs": {} }, { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": -19.2, "left": -110.36, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -3.6, "left": 42.2, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": 72, "left": 37.85, "rotate": 90, "attrs": { "value": "330" } }, { "type": "wokwi-photoresistor-sensor", "id": "ldr1", "top": 204.8, "left": 0.8, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "esp:4", "bb1:4b.i", "green", [ "h76.8" ] ], [ "esp:GND.2", "bb1:3t.c", "red", [ "v0", "h19.2", "v38.4" ] ], [ "esp:15", "bb1:bp.3", "green", [ "v0" ] ], [ "bb1:bp.3", "ldr1:AO", "green", [ "v37.5", "h136", "v48" ] ], [ "led1:A", "bb1:4t.b", "", [ "$bb" ] ], [ "led1:C", "bb1:3t.b", "", [ "$bb" ] ], [ "r1:1", "bb1:4t.c", "", [ "$bb" ] ], [ "r1:2", "bb1:4b.g", "", [ "$bb" ] ], [ "esp:GND.2", "ldr1:GND", "black", [ "v0", "h57.6", "v182.4", "h163.2", "v38.4" ] ], [ "esp:5V", "ldr1:VCC", "red", [ "h-28.65", "v19.2", "h326.4", "v19.2" ] ] ], "dependencies": {} }
Generate a diagram.json code for drawing game using a MAX7219 LED Dot Matrix
#include <MD_MAX72xx.h> #define MAX_DEVICES 2 const int maxX = MAX_DEVICES * 8 - 1; const int maxY = 7; #define CLK_PIN 13 #define DATA_PIN 11 #define CS_PIN 10 #define VERT_PIN A0 #define HORZ_PIN A1 #define SEL_PIN 2 MD_MAX72XX mx = MD_MAX72XX(MD_MAX72XX::PAROLA_HW, CS_PIN, MAX_DEVICES); int x = 0; int y = 0; void setup() { mx.begin(); mx.control(MD_MAX72XX::INTENSITY, MAX_INTENSITY / 2); mx.clear(); pinMode(VERT_PIN, INPUT); pinMode(HORZ_PIN, INPUT); pinMode(SEL_PIN, INPUT_PULLUP); } // the loop function runs over and over again forever void loop() { int horz = analogRead(HORZ_PIN); int vert = analogRead(VERT_PIN); if (vert < 300) { y = min(y + 1, maxY); } if (vert > 700) { y = max(y - 1, 0); } if (horz > 700) { x = min(x + 1, maxX); } if (horz < 300) { x = max(x - 1, 0); } if (digitalRead(SEL_PIN) == LOW) { mx.clear(); } mx.setPoint(y, x, true); mx.update(); delay(100); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 120, "left": 20, "attrs": {} }, { "type": "wokwi-analog-joystick", "id": "joystick1", "top": -9.72, "left": 264.35, "attrs": {} }, { "type": "wokwi-max7219-matrix", "id": "matrix1", "top": 9.03, "left": 52.86, "attrs": { "chain": "2" } } ], "connections": [ [ "joystick1:HORZ", "uno:A1", "green", [ "v0", "*", "v12" ] ], [ "joystick1:VERT", "uno:A0", "purple", [ "v0", "*", "v16" ] ], [ "joystick1:SEL", "uno:2", "blue", [ "v0", "*", "v-12" ] ], [ "joystick1:GND", "uno:GND.3", "black", [ "v0", "*", "v20" ] ], [ "joystick1:VCC", "uno:5V", "red", [ "v0", "*", "v24" ] ], [ "matrix1:CS", "uno:10", "blue", [ "h8", "*", "v-24" ] ], [ "matrix1:DIN", "uno:11", "green", [ "h12", "*", "v-20" ] ], [ "matrix1:CLK", "uno:13", "orange", [ "h4", "*", "v-28" ] ], [ "matrix1:GND", "uno:GND.1", "black", [ "h16", "*", "v-12" ] ], [ "joystick1:VCC", "matrix1:V+", "red", [ "v7.04", "h-38.02", "v-84.67" ] ] ] }
Generate a diagram.json code for LED control using STM32
#include "main.h" ADC_HandleTypeDef hadc1; // ADC handle structure for ADC1 void SystemClock_Config(void); static void MX_GPIO_Init(void); static void MX_ADC1_Init(void); int main(void) { int adcResult; // Variable to store ADC conversion result HAL_Init(); // Initialize the HAL library and reset peripherals SystemClock_Config(); // Configure the system clock MX_GPIO_Init(); // Initialize GPIO pins MX_ADC1_Init(); // Initialize ADC1 while (1) { HAL_ADC_Start(&hadc1); // Start ADC conversion HAL_ADC_PollForConversion(&hadc1, 100); // Wait for ADC conversion to complete with a timeout of 100ms adcResult = HAL_ADC_GetValue(&hadc1); // Get the ADC conversion result HAL_ADC_Stop(&hadc1); // Stop the ADC conversion if (adcResult < 2048) // Check if the ADC result is below the threshold (mid-range for 12-bit ADC) HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, RESET); // Turn off the LED connected to PA5 else HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, SET); // Turn on the LED connected to PA5 } } void SystemClock_Config(void) { RCC_OscInitTypeDef RCC_OscInitStruct = {0}; // Structure to configure the oscillator RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; // Structure to configure the clock tree __HAL_FLASH_SET_LATENCY(FLASH_LATENCY_1); // Set flash latency for 1 wait state RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI; // Use HSI oscillator RCC_OscInitStruct.HSIState = RCC_HSI_ON; // Enable HSI oscillator RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1; // Set HSI division factor to 1 RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; // Default HSI calibration if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) { Error_Handler(); // Handle configuration error } RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1; // Enable clocks for HCLK, SYSCLK, and PCLK1 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI; // Use HSI as the system clock source RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1; // No division for SYSCLK RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV1; // No division for AHB RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV1; // No division for APB1 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) { Error_Handler(); // Handle configuration error } } static void MX_ADC1_Init(void) { ADC_ChannelConfTypeDef sConfig = {0}; // Structure to configure ADC channels hadc1.Instance = ADC1; // Set the ADC instance to ADC1 hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; // ADC clock prescaler hadc1.Init.Resolution = ADC_RESOLUTION_12B; // 12-bit resolution hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; // Right-aligned data hadc1.Init.ScanConvMode = ADC_SCAN_SEQ_FIXED; // Fixed sequence scanning mode hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV; // End of conversion flag after each conversion hadc1.Init.LowPowerAutoWait = DISABLE; // Disable low power auto wait hadc1.Init.LowPowerAutoPowerOff = DISABLE; // Disable low power auto power-off hadc1.Init.ContinuousConvMode = DISABLE; // Single conversion mode hadc1.Init.NbrOfConversion = 1; // One conversion at a time hadc1.Init.DiscontinuousConvMode = DISABLE; // Disable discontinuous mode hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START; // Start conversion via software hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; // No external trigger edge hadc1.Init.DMAContinuousRequests = DISABLE; // Disable continuous DMA requests hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED; // Preserve data in case of overrun hadc1.Init.SamplingTimeCommon1 = ADC_SAMPLETIME_1CYCLE_5; // Sampling time of 1.5 ADC clock cycles hadc1.Init.OversamplingMode = DISABLE; // Disable oversampling hadc1.Init.TriggerFrequencyMode = ADC_TRIGGER_FREQ_HIGH; // High trigger frequency mode if (HAL_ADC_Init(&hadc1) != HAL_OK) { Error_Handler(); // Handle initialization error } sConfig.Channel = ADC_CHANNEL_0; // Select channel 0 sConfig.Rank = ADC_RANK_CHANNEL_NUMBER; // Rank the channel by number if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) { Error_Handler(); // Handle configuration error } } static void MX_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; // Structure to configure GPIO pins __HAL_RCC_GPIOA_CLK_ENABLE(); // Enable clock for GPIO port A HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET); // Set PA5 to low (LED off) GPIO_InitStruct.Pin = GPIO_PIN_5; // Configure PA5 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // Set mode to push-pull output GPIO_InitStruct.Pull = GPIO_NOPULL; // No internal pull-up or pull-down resistor GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; // Set output speed to low HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); // Initialize PA5 with the configuration } void Error_Handler(void) { __disable_irq(); // Disable interrupts while (1) // Infinite loop to indicate error { } }
{ "version": 1, "author": "COD", "editor": "wokwi", "parts": [ { "type": "board-st-nucleo-c031c6", "id": "nucleo", "top": 0.83, "left": -0.98, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 102, "left": 349.4, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": 167.15, "left": 288, "attrs": { "value": "1000" } }, { "type": "wokwi-potentiometer", "id": "pot1", "top": 161.9, "left": -115.4, "attrs": {} } ], "connections": [ [ "$serialMonitor:TX", "nucleo:PA3", "", [] ], [ "$serialMonitor:RX", "nucleo:PA2", "", [] ], [ "nucleo:3V3.2", "pot1:VCC", "green", [ "h-66.75", "v57.6", "h-37.6" ] ], [ "pot1:GND", "nucleo:PA14", "black", [ "v19.2", "h-48", "v-96", "h96", "v9.6" ] ], [ "nucleo:A0", "pot1:SIG", "gold", [ "h-47.55", "v9.6", "h-67.2" ] ], [ "nucleo:PA5", "r1:1", "green", [ "h0" ] ], [ "r1:2", "led1:A", "green", [ "v0", "h27.6" ] ], [ "nucleo:GND.9", "led1:C", "black", [ "h0" ] ] ], "dependencies": {} }
Generate a diagram.json code for Traffic light using Raspberry pi pico
#define RED 1 #define YELLOW 5 #define GREEN 9 void setup() { pinMode(RED, OUTPUT); pinMode(YELLOW, OUTPUT); pinMode(GREEN, OUTPUT); } void loop() { digitalWrite(GREEN, HIGH); delay(3000); digitalWrite(GREEN, LOW); digitalWrite(YELLOW, HIGH); delay(500); digitalWrite(YELLOW, LOW); digitalWrite(RED, HIGH); delay(2000); digitalWrite(YELLOW, HIGH); delay(500); digitalWrite(YELLOW, LOW); digitalWrite(RED, LOW); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 20, "left": 60, "attrs": { "env": "arduino-community" } }, { "type": "wokwi-led", "id": "led1", "top": 3, "left": 0, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": 48, "left": 0, "attrs": { "color": "yellow" } }, { "type": "wokwi-led", "id": "led3", "top": 98, "left": 0, "attrs": { "color": "green" } } ], "connections": [ [ "pico:GND.1", "led1:C", "black", [] ], [ "pico:GP1", "led1:A", "blue", [] ], [ "pico:GND.2", "led2:C", "black", [] ], [ "pico:GP5", "led2:A", "blue", [] ], [ "pico:GND.3", "led3:C", "black", [] ], [ "pico:GP9", "led3:A", "blue", [] ], [ "$serialMonitor:RX", "pico:GP0", "", [] ] ] }
Generate a diagram.json code for LCD using Pi Pico
// LCD1602 and Pi Pico! #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 10, 9, 8, 7); void setup() { lcd.begin(16, 2); lcd.print("Hello World!"); lcd.setCursor(2, 1); lcd.print("> Pi Pico <"); } void loop() { delay(1); // Adding a delay() here speeds up the simulation }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 123.67, "left": 135.97, "rotate": 90, "hide": false, "attrs": { "env": "arduino-community" } }, { "type": "wokwi-lcd1602", "id": "lcd", "top": -17.85, "left": 22.03, "rotate": 0, "hide": false, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 114.8, "left": 226.31, "rotate": 0, "hide": false, "attrs": { "value": "220" } } ], "connections": [ [ "pico:GND.1", "lcd:VSS", "black", [ "v-51", "*", "h0", "v18" ] ], [ "pico:GND.1", "lcd:K", "black", [ "v-51", "*", "h0", "v18" ] ], [ "pico:GND.1", "lcd:RW", "black", [ "v-51", "*", "h0", "v18" ] ], [ "pico:VSYS", "lcd:VDD", "red", [ "v16", "h-16" ] ], [ "pico:VSYS", "r1:2", "red", [ "v16", "h0" ] ], [ "r1:1", "lcd:A", "pink", [] ], [ "pico:GP12", "lcd:RS", "blue", [ "v-16", "*", "h0", "v20" ] ], [ "pico:GP11", "lcd:E", "purple", [ "v-20", "*", "h0", "v20" ] ], [ "pico:GP10", "lcd:D4", "green", [ "v-24", "*", "h0", "v20" ] ], [ "pico:GP9", "lcd:D5", "brown", [ "v-28", "*", "h0", "v20" ] ], [ "pico:GP8", "lcd:D6", "gold", [ "v-32", "*", "h0", "v20" ] ], [ "pico:GP7", "lcd:D7", "gray", [ "v-36", "*", "h0", "v20" ] ] ] }
Generate a diagram.json code for Buzzer alaram using Pi Pico
# Project objective: To test a passive buzzer to play an alarm sound at one second interval # if passive buzzer is used, import the Speaker class from picozero from picozero import Speaker from time import sleep # creating a Speaker object speaker = Speaker(15) # continuously beep at 1 sec interval while the board has power # note: a passive buzzer can also be used to play different tones while True: speaker.on() sleep(1) speaker.off() sleep(1)
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -3, "left": -112.4, "attrs": {} }, { "type": "wokwi-pi-pico", "id": "pico", "top": 0.9, "left": -38.65, "rotate": 270, "attrs": { "env": "micropython-20220618-v1.19.1" } }, { "type": "wokwi-buzzer", "id": "bz1", "top": 31.2, "left": 117, "attrs": { "volume": "0.1" } } ], "connections": [ [ "bb1:3b.j", "bb1:bn.2", "black", [ "v0" ] ], [ "bb1:25b.h", "bb1:bn.20", "black", [ "v0" ] ], [ "bb1:26b.j", "bb1:20b.j", "green", [ "v0" ] ], [ "pico:GP0", "bb1:1b.h", "", [ "$bb" ] ], [ "pico:GP1", "bb1:2b.h", "", [ "$bb" ] ], [ "pico:GND.1", "bb1:3b.h", "", [ "$bb" ] ], [ "pico:GP2", "bb1:4b.h", "", [ "$bb" ] ], [ "pico:GP3", "bb1:5b.h", "", [ "$bb" ] ], [ "pico:GP4", "bb1:6b.h", "", [ "$bb" ] ], [ "pico:GP5", "bb1:7b.h", "", [ "$bb" ] ], [ "pico:GND.2", "bb1:8b.h", "", [ "$bb" ] ], [ "pico:GP6", "bb1:9b.h", "", [ "$bb" ] ], [ "pico:GP7", "bb1:10b.h", "", [ "$bb" ] ], [ "pico:GP8", "bb1:11b.h", "", [ "$bb" ] ], [ "pico:GP9", "bb1:12b.h", "", [ "$bb" ] ], [ "pico:GND.3", "bb1:13b.h", "", [ "$bb" ] ], [ "pico:GP10", "bb1:14b.h", "", [ "$bb" ] ], [ "pico:GP11", "bb1:15b.h", "", [ "$bb" ] ], [ "pico:GP12", "bb1:16b.h", "", [ "$bb" ] ], [ "pico:GP13", "bb1:17b.h", "", [ "$bb" ] ], [ "pico:GND.4", "bb1:18b.h", "", [ "$bb" ] ], [ "pico:GP14", "bb1:19b.h", "", [ "$bb" ] ], [ "pico:GP15", "bb1:20b.h", "", [ "$bb" ] ], [ "pico:GP16", "bb1:20t.c", "", [ "$bb" ] ], [ "pico:GP17", "bb1:19t.c", "", [ "$bb" ] ], [ "pico:GND.5", "bb1:18t.c", "", [ "$bb" ] ], [ "pico:GP18", "bb1:17t.c", "", [ "$bb" ] ], [ "pico:GP19", "bb1:16t.c", "", [ "$bb" ] ], [ "pico:GP20", "bb1:15t.c", "", [ "$bb" ] ], [ "pico:GP21", "bb1:14t.c", "", [ "$bb" ] ], [ "pico:GND.6", "bb1:13t.c", "", [ "$bb" ] ], [ "pico:GP22", "bb1:12t.c", "", [ "$bb" ] ], [ "pico:RUN", "bb1:11t.c", "", [ "$bb" ] ], [ "pico:GP26", "bb1:10t.c", "", [ "$bb" ] ], [ "pico:GP27", "bb1:9t.c", "", [ "$bb" ] ], [ "pico:GND.7", "bb1:8t.c", "", [ "$bb" ] ], [ "pico:GP28", "bb1:7t.c", "", [ "$bb" ] ], [ "pico:ADC_VREF", "bb1:6t.c", "", [ "$bb" ] ], [ "pico:3V3", "bb1:5t.c", "", [ "$bb" ] ], [ "pico:3V3_EN", "bb1:4t.c", "", [ "$bb" ] ], [ "pico:GND.8", "bb1:3t.c", "", [ "$bb" ] ], [ "pico:VSYS", "bb1:2t.c", "", [ "$bb" ] ], [ "pico:VBUS", "bb1:1t.c", "", [ "$bb" ] ], [ "bz1:1", "bb1:25b.f", "", [ "$bb" ] ], [ "bz1:2", "bb1:26b.f", "", [ "$bb" ] ] ], "dependencies": {} }
Generate a diagram.json code for Stepper motor control using Raspberry Pi Pico
// Raspberry Pi Pico + Stepper Motor Example #define DIR_PIN 2 #define STEP_PIN 3 void setup() { pinMode(STEP_PIN, OUTPUT); pinMode(DIR_PIN, OUTPUT); digitalWrite(STEP_PIN, LOW); } void loop() { // Move 200 steps (one rotation) CW over one second digitalWrite(DIR_PIN, HIGH); for (int i = 0; i < 200; i++) { digitalWrite(STEP_PIN, HIGH); digitalWrite(STEP_PIN, LOW); delay(5); // 5 ms * 200 = 1 second } delay(500); // Wait half a second // Move 200 steps (one rotation) CCW over 400 millis digitalWrite(DIR_PIN, LOW); for (int i = 0; i < 200; i++) { digitalWrite(STEP_PIN, HIGH); digitalWrite(STEP_PIN, LOW); delay(2); // 2 ms * 200 = 0.4 seconds } delay(1000); // Wait another second }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 63.95, "left": 86.4, "attrs": {} }, { "type": "wokwi-a4988", "id": "drv1", "top": 91.4, "left": 226, "rotate": 270, "attrs": {} }, { "type": "wokwi-stepper-motor", "id": "stepper1", "top": -179.4, "left": 141.6, "attrs": { "display": "angle" } } ], "connections": [ [ "drv1:1B", "stepper1:B-", "black", [ "v0" ] ], [ "drv1:1A", "stepper1:B+", "green", [ "v0" ] ], [ "stepper1:A+", "drv1:2A", "blue", [ "v0" ] ], [ "stepper1:A-", "drv1:2B", "red", [ "v0" ] ], [ "drv1:SLEEP", "drv1:RESET", "green", [ "v15.92", "h-9.9" ] ], [ "drv1:STEP", "pico:GP3", "orange", [ "v130.8", "h-203.87", "v-163.2" ] ], [ "drv1:DIR", "pico:GP2", "violet", [ "v140.4", "h-223.07", "v-182.4" ] ], [ "drv1:GND.2", "pico:GND.8", "black", [ "v0" ] ], [ "pico:VBUS", "drv1:VDD", "red", [ "h0" ] ] ] }
Generate a diagram.json code for Mini piano using raspberry pi pico
#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); } delay(10); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 183.54, "left": 67.92, "rotate": 90, "attrs": { "env": "arduino-community" } }, { "type": "wokwi-buzzer", "id": "buzzer", "top": 208.42, "left": 382.39, "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": [ [ "pico:GND.1", "buzzer:1", "black", [ "v-12", "*", "h-15" ] ], [ "pico:GP12", "btn1:1.r", "red", [ "v-8", "*", "v46" ] ], [ "pico:GND.1", "btn1:2.r", "black", [ "v-12", "*", "h6" ] ], [ "pico:GP11", "btn2:1.r", "orange", [ "v-4", "*", "v40" ] ], [ "pico:GND.1", "btn2:2.r", "black", [ "v-12", "*", "h6" ] ], [ "pico:GP10", "btn3:1.r", "yellow", [ "v0", "*", "v28" ] ], [ "pico:GND.1", "btn3:2.r", "black", [ "v-12", "*", "h-6" ] ], [ "pico:GP9", "btn4:1.r", "green", [ "v-36", "*", "v20" ] ], [ "pico:GND.1", "btn4:2.r", "black", [ "v-12", "*", "h-6" ] ], [ "pico:GP8", "buzzer:2", "gold", [ "v-32", "*", "h-10" ] ], [ "pico:GP7", "btn5:1.r", "cyan", [ "v-24", "*", "h0" ] ], [ "pico:GND.1", "btn5:2.r", "black", [ "v-12", "*", "h-15", "v4" ] ], [ "pico:GP6", "btn6:1.r", "blue", [ "v-24", "*", "h0" ] ], [ "pico:GND.1", "btn6:2.r", "black", [ "v-12", "*", "h-10", "v4" ] ], [ "pico:GP5", "btn7:1.r", "purple", [ "v-20", "*", "h0" ] ], [ "pico:GND.1", "btn7:2.r", "black", [ "v-12", "*", "h-8", "v4" ] ], [ "pico:GP4", "btn8:1.r", "red", [ "v-16", "*", "h0" ] ], [ "pico:GND.1", "btn8:2.r", "black", [ "v-12", "*", "h-8", "v4" ] ] ] }
Generate a diagram.json code for 4 digit timer using raspberry pi pico
#include "segment.pio.h" uint8_t digits[] = { 0b11000000, // 0 0b11111001, // 1 0b10100100, // 2 0b10110000, // 3 0b10011001, // 4 0b10010010, // 5 0b10000010, // 6 0b11111000, // 7 0b10000000, // 8 0b10011000, // 9 }; const uint8_t first_segment_pin = 2; const uint8_t first_digit_pin = 10; void setup() { Serial1.begin(115200); Serial1.println("Raspberry Pi Pico PIO 7-Segment Example"); // Load the PIO program and initialize the machine auto offset = pio_add_program(pio0, &segment_program); segment_program_init(pio0, 0, offset, first_segment_pin, first_digit_pin); } void displayNumber(uint value) { pio_sm_put(pio0, 0, digits[value / 1000 % 10] << 24 | digits[value / 100 % 10] << 16 | digits[value / 10 % 10] << 8 | digits[value % 10] ); } int i = 0; void loop() { displayNumber(i++); delay(200); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 65.16, "left": -27.77, "rotate": 90, "hide": false, "attrs": { "env": "arduino-community" } }, { "type": "wokwi-7segment", "id": "sevseg1", "top": -21.97, "left": -85.69, "rotate": 0, "hide": false, "attrs": { "digits": "4" } } ], "connections": [ [ "pico:GP0", "$serialMonitor:RX", "", [] ], [ "pico:GP1", "$serialMonitor:TX", "", [] ], [ "sevseg1:A", "pico:GP2", "green", [ "v-21", "h145", "v115", "h-68" ] ], [ "sevseg1:B", "pico:GP3", "green", [ "v-15", "h100", "v103", "h-65" ] ], [ "sevseg1:C", "pico:GP4", "green", [ "v16", "h37" ] ], [ "sevseg1:D", "pico:GP5", "green", [ "v22", "h53" ] ], [ "sevseg1:E", "pico:GP6", "green", [ "v32", "h42" ] ], [ "sevseg1:F", "pico:GP7", "green", [ "v-13", "h-96", "v116", "h104" ] ], [ "sevseg1:G", "pico:GP8", "green", [ "v11", "h1" ] ], [ "sevseg1:DP", "pico:GP9", "green", [ "v7", "h-3" ] ], [ "sevseg1:DIG1", "pico:GP10", "blue", [ "v-19", "h-84", "v128", "h81" ] ], [ "sevseg1:DIG2", "pico:GP11", "blue", [ "v-28", "h-121", "v144", "h80" ] ], [ "sevseg1:DIG3", "pico:GP12", "blue", [ "v-39", "h-139", "v162", "h79" ] ], [ "sevseg1:DIG4", "pico:GP13", "blue", [ "v66", "h-82" ] ] ] }
Generate a diagram.json code for Pico keyboard with LED
#include <Keypad.h> const uint8_t LEDS = 12; const uint8_t ROWS = 4; const uint8_t COLS = 4; char keys[ROWS][COLS] = { { '1', '2', '3', 'A' }, { '4', '5', '6', 'B' }, { '7', '8', '9', 'C' }, { '*', '0', '#', 'D' } }; // Pins connected to LED1, LED2, LED3, ...LED12 uint8_t ledPins[LEDS] = { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 28, 27 }; uint8_t rowPins[ROWS] = { 26, 22, 21, 20 }; // Pins connected to R1, R2, R3, R4 uint8_t colPins[COLS] = { 19, 18, 17, 16 }; // Pins connected to C1, C2, C3, C4 Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS); void setup() { for (uint8_t l = 0; l < LEDS; l++) { pinMode(ledPins[l], OUTPUT); digitalWrite(ledPins[l], LOW); } } void loop() { char key = keypad.getKey(); if (key != NO_KEY) { switch (key) { case '1': digitalWrite(ledPins[0], HIGH); break; case '2': digitalWrite(ledPins[1], HIGH); break; case '3': digitalWrite(ledPins[2], HIGH); break; case '4': digitalWrite(ledPins[3], HIGH); break; case '5': digitalWrite(ledPins[4], HIGH); break; case '6': digitalWrite(ledPins[5], HIGH); break; case '7': digitalWrite(ledPins[6], HIGH); break; case '8': digitalWrite(ledPins[7], HIGH); break; case '9': for (uint8_t l = 0; l < 8; l++) { digitalWrite(ledPins[l], HIGH); } break; case '0': for (uint8_t l = 0; l < 8; l++) { digitalWrite(ledPins[l], LOW); } break; case 'A': digitalWrite(ledPins[8], HIGH); break; case 'B': digitalWrite(ledPins[9], HIGH); break; case 'C': digitalWrite(ledPins[10], HIGH); break; case 'D': digitalWrite(ledPins[11], HIGH); break; case '*': for (uint8_t l = 8; l < 12; l++) { digitalWrite(ledPins[l], HIGH); } break; case '#': for (uint8_t l = 8; l < 12; l++) { digitalWrite(ledPins[l], LOW); } break; } } delay(10); }
{ "version": 1, "author": "Anderson Costa", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 118, "left": 348, "rotate": 90, "attrs": {} }, { "type": "wokwi-resistor", "id": "rp1", "top": 349.55, "left": 19.2, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "rp2", "top": 368.75, "left": 19.2, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "rp3", "top": 426.35, "left": 19.2, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "rp4", "top": 397.55, "left": 19.2, "attrs": { "value": "1000" } }, { "type": "wokwi-membrane-keypad", "id": "keypad1", "top": -30.8, "left": -13.6, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 20, "left": 420, "attrs": { "color": "blue", "label": "8" } }, { "type": "wokwi-resistor", "id": "r1", "top": 90, "left": 415, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led2", "top": 20, "left": 400, "attrs": { "color": "blue", "label": "7" } }, { "type": "wokwi-resistor", "id": "r2", "top": 90, "left": 395, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led3", "top": 20, "left": 380, "attrs": { "color": "blue", "label": "6" } }, { "type": "wokwi-resistor", "id": "r3", "top": 90, "left": 375, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led4", "top": 20, "left": 360, "attrs": { "color": "blue", "label": "5" } }, { "type": "wokwi-resistor", "id": "r4", "top": 90, "left": 355, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led5", "top": 20, "left": 340, "attrs": { "color": "blue", "label": "4" } }, { "type": "wokwi-resistor", "id": "r5", "top": 90, "left": 335, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led6", "top": 20, "left": 320, "attrs": { "color": "blue", "label": "3" } }, { "type": "wokwi-resistor", "id": "r6", "top": 90, "left": 315, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led7", "top": 20, "left": 300, "attrs": { "color": "blue", "label": "2" } }, { "type": "wokwi-resistor", "id": "r7", "top": 90, "left": 295, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led8", "top": 20, "left": 280, "attrs": { "color": "blue", "label": "1" } }, { "type": "wokwi-resistor", "id": "r8", "top": 90, "left": 275, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led9", "top": 20, "left": 440, "attrs": { "color": "red", "label": "A" } }, { "type": "wokwi-resistor", "id": "r9", "top": 90, "left": 435, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led10", "top": 20, "left": 460, "attrs": { "color": "red", "label": "B" } }, { "type": "wokwi-resistor", "id": "r10", "top": 90, "left": 455, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led11", "top": 20, "left": 480, "attrs": { "color": "red", "label": "C" } }, { "type": "wokwi-resistor", "id": "r11", "top": 90, "left": 475, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-led", "id": "led12", "top": 20, "left": 500, "attrs": { "color": "red", "label": "D" } }, { "type": "wokwi-resistor", "id": "r12", "top": 90, "left": 495, "rotate": 90, "attrs": { "value": "220" } } ], "connections": [ [ "pico:GP0", "$serialMonitor:RX", "", [] ], [ "pico:GP1", "$serialMonitor:TX", "", [] ], [ "keypad1:C4", "pico:GP16", "green", [ "v15", "h132" ] ], [ "keypad1:C3", "pico:GP17", "green", [ "v25", "h182" ] ], [ "keypad1:C2", "pico:GP18", "green", [ "v35", "h204" ] ], [ "keypad1:C1", "pico:GP19", "green", [ "v45", "h222" ] ], [ "keypad1:R4", "pico:GP20", "green", [ "v55", "h240" ] ], [ "keypad1:R3", "pico:GP21", "green", [ "v65", "h260" ] ], [ "keypad1:R2", "pico:GP22", "green", [ "v75", "h286" ] ], [ "keypad1:R1", "pico:GP26", "green", [ "v85", "h299" ] ], [ "r1:1", "led1:A", "green", [ "h0" ] ], [ "r2:1", "led2:A", "green", [ "h0" ] ], [ "r3:1", "led3:A", "green", [ "h0" ] ], [ "r4:1", "led4:A", "green", [ "h0" ] ], [ "r5:1", "led5:A", "green", [ "h0" ] ], [ "r6:1", "led6:A", "green", [ "h0" ] ], [ "r7:1", "led7:A", "green", [ "h0" ] ], [ "r8:1", "led8:A", "green", [ "h0" ] ], [ "pico:GND.4", "led8:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led7:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led6:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led5:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led4:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led3:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led2:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led1:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led9:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led10:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led11:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GND.4", "led12:C", "black", [ "v-25", "h-22", "v-77", "h6" ] ], [ "pico:GP4", "r1:2", "green", [ "v-28", "h10", "v-20" ] ], [ "pico:GP5", "r2:2", "green", [ "v-36", "h8" ] ], [ "pico:GP6", "r3:2", "green", [ "v-26", "h7" ] ], [ "pico:GP7", "r4:2", "green", [ "v-36", "h-3" ] ], [ "pico:GP8", "r5:2", "green", [ "v-33", "h-13" ] ], [ "pico:GP9", "r6:2", "green", [ "v-23", "h-14", "v-11", "h-10" ] ], [ "pico:GP10", "r7:2", "green", [ "v-22", "h-16", "v-9" ] ], [ "pico:GP11", "r8:2", "green", [ "v-12", "h-17", "v-24", "h-18" ] ], [ "r9:1", "led9:A", "green", [ "h0" ] ], [ "r10:1", "led10:A", "green", [ "h0" ] ], [ "r11:1", "led11:A", "green", [ "h0" ] ], [ "r12:1", "led12:A", "green", [ "h0" ] ], [ "pico:GP3", "r9:2", "green", [ "v-20", "h10", "v-20", "h20", "v-13" ] ], [ "pico:GP2", "r10:2", "green", [ "v-15", "h20", "v-15", "h20", "v-22" ] ], [ "pico:GP27", "r12:2", "green", [ "v165", "h152" ] ], [ "pico:GP28", "r11:2", "green", [ "v155", "h104" ] ], [ "rp1:2", "keypad1:R1", "green", [ "h8.4", "v-48" ] ], [ "rp2:2", "keypad1:R2", "green", [ "h18", "v-67.2" ] ], [ "rp4:2", "keypad1:R3", "green", [ "h27.6", "v-96" ] ], [ "rp3:2", "keypad1:R4", "green", [ "h37.2", "v-124.8" ] ], [ "rp1:1", "rp2:1", "red", [ "v0" ] ], [ "rp2:1", "rp4:1", "red", [ "v0" ] ], [ "rp4:1", "rp3:1", "red", [ "v0" ] ], [ "rp3:1", "pico:3V3", "red", [ "v19.2", "h417.15" ] ] ], "dependencies": {} }
Generate a diagram.json code for LED blink using raspberry pi pico
from machine import Pin from utime import sleep print("Hello, Pi Pico!") led = Pin(5, Pin.OUT) while True: led.toggle() sleep(0.5)
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 0, "left": 0, "rotate": 0, "hide": false, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -2.67, "left": -65.33, "rotate": 0, "hide": false, "attrs": { "color": "red" } } ], "connections": [ [ "pico:GP0", "$serialMonitor:RX", "", [] ], [ "pico:GP1", "$serialMonitor:TX", "", [] ], [ "pico:GP5", "led1:A", "green", [ "h0" ] ], [ "pico:GND.2", "led1:C", "black", [ "h0" ] ] ] }
Generate a diagram.json code for 7 segment diaplay using raspberry pi pico
#include <stdio.h> #include "pico/stdlib.h" #include "hardware/gpio.h" /* Our 7 Segment display has pins as follows: --A-- F B --G-- E C --D-- By default we are allocating GPIO 2 to segment A, 3 to B etc. So, connect GPIO 2 to pin A on the 7 segment LED display etc. Don't forget the appropriate resistors, best to use one for each segment! Connect button so that pressing the switch connects the GPIO 9 (default) to ground (pull down) */ #define FIRST_GPIO 2 #define BUTTON_GPIO (FIRST_GPIO+7) // This array converts a number 0-9 to a bit pattern to send to the GPIOs int bits[10] = { 0x3f, // 0 0x06, // 1 0x5b, // 2 0x4f, // 3 0x66, // 4 0x6d, // 5 0x7d, // 6 0x07, // 7 0x7f, // 8 0x67 // 9 }; /// \tag::hello_gpio[] int main() { stdio_init_all(); printf("Hello, 7segment - press button to count down!\n"); // We could use gpio_set_dir_out_masked() here for (int gpio = FIRST_GPIO; gpio < FIRST_GPIO + 7; gpio++) { gpio_init(gpio); gpio_set_dir(gpio, GPIO_OUT); // Our bitmap above has a bit set where we need an LED on, BUT, we are pulling low to light // so invert our output gpio_set_outover(gpio, GPIO_OVERRIDE_INVERT); } gpio_init(BUTTON_GPIO); gpio_set_dir(BUTTON_GPIO, GPIO_IN); // We are using the button to pull down to 0v when pressed, so ensure that when // unpressed, it uses internal pull ups. Otherwise when unpressed, the input will // be floating. gpio_pull_up(BUTTON_GPIO); int val = 0; while (true) { // Count upwards or downwards depending on button input // We are pulling down on switch active, so invert the get to make // a press count downwards if (!gpio_get(BUTTON_GPIO)) { if (val == 9) { val = 0; } else { val++; } } else if (val == 0) { val = 9; } else { val--; } // We are starting with GPIO 2, our bitmap starts at bit 0 so shift to start at 2. int32_t mask = bits[val] << FIRST_GPIO; // Set all our GPIOs in one go! // If something else is using GPIO, we might want to use gpio_put_masked() gpio_set_mask(mask); sleep_ms(250); gpio_clr_mask(mask); } } /// \end::hello_gpio[]
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 67.9, "left": 132.45, "rotate": 90, "attrs": { "builder": "pico-sdk" } }, { "type": "wokwi-7segment", "id": "sevseg1", "top": 14.58, "left": 158.68, "attrs": { "common": "anode" } }, { "type": "wokwi-slide-switch", "id": "sw1", "top": 62, "left": 99.1, "attrs": {} } ], "connections": [ [ "pico:GP0", "$serialMonitor:RX", "", [] ], [ "pico:GP2", "sevseg1:A", "green", [ "v-135", "h-40" ] ], [ "pico:GP3", "sevseg1:B", "green", [ "v-128", "h-21" ] ], [ "pico:GP4", "sevseg1:C", "green", [ "v-33", "h-21" ] ], [ "pico:GP5", "sevseg1:D", "green", [ "v-28", "h-2" ] ], [ "pico:GP6", "sevseg1:E", "green", [ "v-18", "h-20" ] ], [ "pico:GP7", "sevseg1:F", "green", [ "v-14", "h-22", "v-108", "h21" ] ], [ "pico:GP8", "sevseg1:G", "green", [ "v-10", "h-17", "v-123", "h14" ] ], [ "pico:GP9", "sw1:3", "blue", [ "v-6", "h-17", "v-29" ] ], [ "sw1:2", "pico:GND.4", "black", [ "v12", "h-18" ] ], [ "pico:VSYS", "sevseg1:COM.2", "red", [ "v8", "h37", "v-242", "h-5" ] ] ], "dependencies": {} }
Generate a diagram.json code for neopixel ring using Pi pico
import time from neopixel import Neopixel pixels = Neopixel(17, 0, 6, "GRB") colors = [ (0xb6, 0xe4, 0x30), (0x42, 0xd1, 0xe0), ] pixel_index = 0 color_index = 0 while True: pixels.set_pixel(pixel_index, colors[color_index]) pixels.show() #print(pixel_index, colors[color_index]) pixel_index += 1 if pixel_index == 16: pixel_index = 0 color_index = (color_index + 1) % 2 time.sleep(0.1)
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 80.37, "left": 2.96, "attrs": { "env": "micropython-20210902-v1.17" } }, { "type": "wokwi-led-ring", "id": "ring1", "top": 3.2, "left": -177.15, "attrs": { "pixels": "16" } } ], "connections": [ [ "pico:GP6", "ring1:DIN", "green", [ "h0" ] ], [ "ring1:VCC", "pico:3V3", "red", [ "v128.24", "h238.19", "v-147.43" ] ], [ "ring1:GND", "pico:GND.3", "black", [ "v0" ] ] ] }
Generate a diagram.json code for SSD1306 timer with micropython
from machine import Pin, I2C from ssd1306 import SSD1306_I2C import framebuf, sys import utime pix_res_x = 128 pix_res_y = 64 def init_i2c(scl_pin, sda_pin): # Initialize I2C device i2c_dev = I2C(1, scl=Pin(scl_pin), sda=Pin(sda_pin), freq=200000) i2c_addr = [hex(ii) for ii in i2c_dev.scan()] if not i2c_addr: print('No I2C Display Found') sys.exit() else: print("I2C Address : {}".format(i2c_addr[0])) print("I2C Configuration: {}".format(i2c_dev)) return i2c_dev def display_logo(oled): # Display the Raspberry Pi logo on the OLED buffer = bytearray(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|?\x00\x01\x86@\x80\x01\x01\x80\x80\x01\x11\x88\x80\x01\x05\xa0\x80\x00\x83\xc1\x00\x00C\xe3\x00\x00~\xfc\x00\x00L'\x00\x00\x9c\x11\x00\x00\xbf\xfd\x00\x00\xe1\x87\x00\x01\xc1\x83\x80\x02A\x82@\x02A\x82@\x02\xc1\xc2@\x02\xf6>\xc0\x01\xfc=\x80\x01\x18\x18\x80\x01\x88\x10\x80\x00\x8c!\x00\x00\x87\xf1\x00\x00\x7f\xf6\x00\x008\x1c\x00\x00\x0c \x00\x00\x03\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00") fb = framebuf.FrameBuffer(buffer, 32, 32, framebuf.MONO_HLSB) oled.fill(0) oled.blit(fb, 96, 0) oled.show() def display_text(oled): # Display text on the OLED oled.text("Raspberry Pi", 5, 5) oled.text("Pico", 5, 15) oled.show() def display_anima(oled): # Display a simple timer animation on the OLED start_time = utime.ticks_ms() while True: elapsed_time = (utime.ticks_diff(utime.ticks_ms(), start_time) // 1000) + 1 # Clear the specific line by drawing a filled black rectangle oled.fill_rect(5, 40, oled.width - 5, 8, 0) oled.text("Timer:", 5, 30) oled.text(str(elapsed_time) + " sec", 5, 40) oled.show() utime.sleep_ms(1000) def main(): i2c_dev = init_i2c(scl_pin=27, sda_pin=26) oled = SSD1306_I2C(pix_res_x, pix_res_y, i2c_dev) display_logo(oled) display_text(oled) display_anima(oled) if __name__ == '__main__': main()
{ "version": 1, "author": "Anderson Costa", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-mini", "id": "bb1", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-pi-pico", "id": "pico", "top": 112, "left": 50, "rotate": 270, "attrs": { "env": "micropython-20220618-v1.19.1" } }, { "type": "board-ssd1306", "id": "oled1", "top": 60, "left": 80, "attrs": {} } ], "connections": [ [ "bb1:2b.f", "bb1:2t.e", "black", [ "v0" ] ], [ "bb1:3b.f", "bb1:3t.e", "red", [ "v0" ] ], [ "bb1:4b.f", "bb1:4t.e", "purple", [ "v0" ] ], [ "bb1:5b.f", "bb1:5t.e", "orange", [ "v0" ] ], [ "bb1:2t.d", "bb1:12t.d", "black", [ "v0" ] ], [ "bb1:3t.c", "bb1:13t.c", "red", [ "v0" ] ], [ "bb1:4t.b", "bb1:14t.b", "purple", [ "v0" ] ], [ "bb1:5t.a", "bb1:15t.a", "orange", [ "v0" ] ], [ "bb1:12t.e", "oled1:GND", "black", [ "v0" ] ], [ "bb1:13t.e", "oled1:VCC", "red", [ "v0" ] ], [ "bb1:14t.e", "oled1:SCL", "purple", [ "v0" ] ], [ "bb1:15t.e", "oled1:SDA", "orange", [ "v0" ] ], [ "pico:9", "bb1:4b.j", "purple", [ "v0" ] ], [ "pico:8", "bb1:5b.j", "orange", [ "v0" ] ], [ "bb1:2t.a", "bb1:17t.a", "black", [ "v-7.93", "h144" ] ], [ "bb1:15t.d", "bb1:16t.d", "orange", [ "v0" ] ], [ "pico:3V3_EN", "bb1:3b.j", "red", [ "v0" ] ], [ "pico:GND.8", "bb1:2b.j", "black", [ "v0" ] ], [ "pico:GP27", "bb1:4b.j", "purple", [ "v-15", "h-38.25" ] ], [ "pico:GP26", "bb1:5b.j", "orange", [ "v-25", "h-36.92" ] ] ], "dependencies": {} }
Generate a diagram.json code for servo control based on temperture using Pico
from machine import Pin, I2C, ADC, PWM import time from ssd1306 import SSD1306_I2C import dht # LED Configuration LED_PIN = 25 # Built-in LED for Raspberry Pi Pico led = Pin(LED_PIN, Pin.OUT) # LDR Configuration LDR_PIN = 26 # ADC pin for LDR ldr = ADC(LDR_PIN) LDR_THRESHOLD = 30 # Simulated light level threshold at 30 # DHT Sensor Configuration DHT_PIN = 0 # GPIO pin connected to DHT22 dht_sensor = dht.DHT22(Pin(DHT_PIN)) # Shared variables for temperature and humidity temperature = None humidity = None last_temperature = None # Track last temperature servo_swept = False # Flag to indicate if the servo has swept # OLED Display Configuration WIDTH = 128 # Display width HEIGHT = 64 # Display height i2c = I2C(0, scl=Pin(17), sda=Pin(16), freq=400000) # I2C configuration display = SSD1306_I2C(WIDTH, HEIGHT, i2c) # Initialize OLED display # PIR Sensor Configuration PIR_PIN = 2 pir = Pin(PIR_PIN, Pin.IN) # Servo motor configuration SERVO_PIN = 20 # GPIO pin connected to the servo's PWM signal servo = PWM(Pin(SERVO_PIN)) servo.freq(50) # Set PWM frequency to 50Hz (standard for servos) def set_servo_angle(angle): """Moves the servo to the specified angle.""" if 0 <= angle <= 360: # Convert angle (0-360) to duty cycle (1000-9000 for 1ms to 2ms pulse) duty = int(1000 + (angle / 360) * 8000) servo.duty_u16(duty) def read_ldr(): """Reads the LDR value from the ADC pin.""" return ldr.read_u16() def read_sensor_data(): """Reads temperature and humidity from the DHT sensor.""" global temperature, humidity try: dht_sensor.measure() temperature = dht_sensor.temperature() humidity = dht_sensor.humidity() except OSError as e: print(f"Failed to read from DHT sensor: {e}") temperature = None humidity = None def update_display(temp, hum, ldr_value, pir): """Updates the OLED display with temperature, Lux, and humidity data.""" display.fill(0) # Clear the display display.text("Sensor Readings:", 0, 0) # Display temperature and humidity if temp is not None and hum is not None: display.text(f"Temp: {temp:.2f}C", 0, 16) display.text(f"Humidity: {hum:.2f}%", 0, 32) else: display.text("Sensor Error!", 0, 16) # Display PIR status if pir.value() == 0: display.text("No intruders", 0, 48) else: display.text("Intruders detected", 0, 48) # Display LDR value display.text(f"LDR: {ldr_value}", 0, 56) # Render the updated display display.show() while True: read_sensor_data() # Read data from DHT22 ldr_value = read_ldr() # Read LDR value update_display(temperature, humidity, ldr_value, pir) # Update the OLED display time.sleep(2) # Wait before the next reading # LDR Control new = (381445 / ldr_value) if new < LDR_THRESHOLD: # Low light condition led.value(1) # Turn LED ON else: # Bright light condition led.value(0) # Turn LED OFF # PIR Sensor (Motion) if pir.value() == 0: # No motion detected time.sleep(0.5) else: # Motion detected time.sleep(0.5) # Servo Control based on temperature if temperature != last_temperature: # Check if temperature has changed last_temperature = temperature # Update last temperature servo_swept = False # Reset the sweep flag if not servo_swept: # Only move servo if it hasn't swept if temperature >= 30: for angle in range(0, 361, 10): # Sweep from 0° to 360° set_servo_angle(angle) time.sleep(0.1) servo_swept = True # Set flag to indicate sweeping is done else: for angle in range(360, -1, -10): # Sweep from 360° to 0° set_servo_angle(angle) time.sleep(0.1) servo_swept = True # Set flag to indicate sweeping is done
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 25.65, "left": 3.6, "attrs": { "env": "micropython-20231227-v1.22.0" } }, { "type": "wokwi-dht22", "id": "dht1", "top": -86.1, "left": -91.8, "attrs": { "temperature": "-40", "humidity": "80.5" } }, { "type": "board-ssd1306", "id": "oled1", "top": 118.34, "left": 345.83, "attrs": { "i2cAddress": "0x3c" } }, { "type": "wokwi-photoresistor-sensor", "id": "ldr1", "top": -131.2, "left": -28, "attrs": {} }, { "type": "wokwi-pir-motion-sensor", "id": "pir1", "top": -44, "left": -208.98, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -3.6, "left": -274.6, "attrs": { "color": "red" } }, { "type": "wokwi-servo", "id": "servo1", "top": -126.8, "left": 268.8, "attrs": {} } ], "connections": [ [ "dht1:VCC", "pico:3V3", "red", [ "v0" ] ], [ "dht1:SDA", "pico:GP0", "green", [ "v0" ] ], [ "dht1:GND", "pico:GND.1", "black", [ "v0" ] ], [ "oled1:VCC", "pico:3V3", "red", [ "v0" ] ], [ "oled1:SCL", "pico:GP17", "magenta", [ "v-57.6", "h-210.9", "v144" ] ], [ "oled1:SDA", "pico:GP16", "green", [ "v-28.8", "h-211.13", "v124.8" ] ], [ "oled1:GND", "pico:GND.6", "black", [ "v-38.4", "h-201.6", "v67.2" ] ], [ "ldr1:VCC", "pico:3V3", "red", [ "h28.8", "v163.2" ] ], [ "pico:GP15", "ldr1:DO", "yellow", [ "v9.6", "h144", "v-325.8" ] ], [ "pico:GP26", "ldr1:AO", "green", [ "h68.4", "v-210.5" ] ], [ "ldr1:GND", "pico:GND.6", "black", [ "h19.2", "v249.2", "h-87.6" ] ], [ "pir1:VCC", "pico:3V3", "red", [ "v0" ] ], [ "pir1:GND", "pico:GND.1", "black", [ "v0" ] ], [ "pir1:OUT", "pico:GP2", "green", [ "v0" ] ], [ "led1:C", "pico:GND.1", "black", [ "v19.2", "h269.2" ] ], [ "led1:A", "pico:GP4", "green", [ "v0" ] ], [ "servo1:GND", "pico:GND.8", "black", [ "h-76.8", "v115.2" ] ], [ "servo1:V+", "pico:3V3", "red", [ "h-67.2", "v124.9" ] ], [ "servo1:PWM", "pico:GP20", "cyan", [ "h-57.6", "v211.4" ] ] ], "dependencies": {} }
Generate a diagram.json code for keyboard input using pi pico
import rp2 from rp2 import PIO from machine import Pin from time import sleep # ------ # # sevseg # # ------ # @rp2.asm_pio(set_init=[PIO.IN_HIGH]*4) def keypad(): wrap_target() set(y, 0) # 0 label("1") mov(isr, null) # 1 set(pindirs, 1) # 2 in_(pins, 4) # 3 set(pindirs, 2) # 4 in_(pins, 4) # 5 set(pindirs, 4) # 6 in_(pins, 4) # 7 set(pindirs, 8) # 8 in_(pins, 4) # 9 mov(x, isr) # 10 jmp(x_not_y, "13") # 11 jmp("1") # 12 label("13") push(block) # 13 irq(0) mov(y, x) # 14 jmp("1") # 15 wrap() for i in range(10, 14): Pin(i, Pin.IN, Pin.PULL_DOWN) key_names = "*7410852#963DCBA" def oninput(machine): keys = machine.get() while machine.rx_fifo(): keys = machine.get() pressed = [] for i in range(len(key_names)): if (keys & (1 << i)): pressed.append(key_names[i]) print("Keys changed! pressed keys:", pressed) sm = rp2.StateMachine(0, keypad, freq=2000, in_base=Pin(10, Pin.IN, Pin.PULL_DOWN), set_base=Pin(6)) sm.active(1) sm.irq(oninput) print("Please press any key on the keypad, or press Ctrl+C to enter REPL.") while True: sleep(0.1)
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": 200.57, "left": -42.52, "rotate": 90, "attrs": {} }, { "type": "wokwi-membrane-keypad", "id": "keypad1", "top": -126.8, "left": -157.6, "attrs": {} } ], "connections": [ [ "pico:GP6", "keypad1:C4", "blue", [ "v-8", "h0" ] ], [ "pico:GP7", "keypad1:C3", "blue", [ "v-12", "h0" ] ], [ "pico:GP8", "keypad1:C2", "blue", [ "v-16", "h0" ] ], [ "pico:GP9", "keypad1:C1", "blue", [ "v-20", "h0" ] ], [ "pico:GP10", "keypad1:R4", "purple", [ "v-24", "h0" ] ], [ "pico:GP11", "keypad1:R3", "purple", [ "v-28", "h0" ] ], [ "pico:GP12", "keypad1:R2", "purple", [ "v-32", "h0" ] ], [ "pico:GP13", "keypad1:R1", "purple", [ "v-36", "h0" ] ] ], "dependencies": {} }
Generate a diagram.json code for LCD diplay with IR remote
#include <IRremote.h> #include <LiquidCrystal.h> #define PIN_RECEIVER 2 // Signal Pin of IR receiver IRrecv receiver(PIN_RECEIVER); LiquidCrystal lcd(12, 11, 10, 9, 8, 7); void setup() { lcd.begin(16, 2); lcd.print("<press a button>"); receiver.enableIRIn(); // Start the receiver } void loop() { // Checks received an IR signal if (receiver.decode()) { translateIR(); receiver.resume(); // Receive the next value } } void lcdPrint(char* text) { lcd.clear(); lcd.setCursor(0, 0); lcd.print("button pressed:"); lcd.setCursor(0, 1); lcd.print(text); lcd.print(" code: "); lcd.print(receiver.decodedIRData.command); } void translateIR() { // Takes command based on IR code received switch (receiver.decodedIRData.command) { case 162: lcdPrint("POWER"); break; case 226: lcdPrint("MENU"); break; case 34: lcdPrint("TEST"); break; case 2: lcdPrint("PLUS"); break; case 194: lcdPrint("BACK"); break; case 224: lcdPrint("PREV."); break; case 168: lcdPrint("PLAY"); break; case 144: lcdPrint("NEXT"); break; case 104: lcdPrint("num: 0"); break; case 152: lcdPrint("MINUS"); break; case 176: lcdPrint("key: C"); break; case 48: lcdPrint("num: 1"); break; case 24: lcdPrint("num: 2"); break; case 122: lcdPrint("num: 3"); break; case 16: lcdPrint("num: 4"); break; case 56: lcdPrint("num: 5"); break; case 90: lcdPrint("num: 6"); break; case 66: lcdPrint("num: 7"); break; case 74: lcdPrint("num: 8"); break; case 82: lcdPrint("num: 9"); break; default: lcd.clear(); lcd.print(receiver.decodedIRData.command); lcd.print(" other button"); } }
{ "version": 1, "author": "Anderson Costa", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": 210, "left": 245, "rotate": 0, "hide": false, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd", "top": 25, "left": 235, "rotate": 0, "hide": false, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 160, "left": 450, "rotate": 0, "hide": false, "attrs": { "value": "220" } }, { "type": "wokwi-ir-receiver", "id": "ir", "top": 185, "left": 450, "rotate": 0, "hide": false, "attrs": { "color": "green" } }, { "type": "wokwi-ir-remote", "id": "remote1", "top": 20, "left": 70, "rotate": 0, "hide": false, "attrs": {} } ], "connections": [ [ "nano:GND.2", "ds1307:GND", "black", [ "v20", "*", "v0" ] ], [ "nano:5V", "ds1307:5V", "red", [ "v8", "*", "h-25", "v0" ] ], [ "nano:GND.1", "lcd:VSS", "black", [ "v12", "*", "h-30", "v18" ] ], [ "nano:GND.1", "lcd:K", "black", [ "v12", "*", "h-174", "v18" ] ], [ "nano:GND.1", "lcd:RW", "black", [ "v12", "*", "h-68", "v18" ] ], [ "nano:5V", "lcd:VDD", "red", [ "v8", "*", "h-35", "v22" ] ], [ "nano:5V", "r1:2", "red", [ "v8", "h166", "v-112", "h50" ] ], [ "nano:12", "lcd:RS", "orange", [ "v-32", "*", "h0", "v20" ] ], [ "nano:11", "lcd:E", "purple", [ "v-28", "*", "h0", "v20" ] ], [ "nano:10", "lcd:D4", "green", [ "v-24", "*", "h0", "v20" ] ], [ "nano:9", "lcd:D5", "brown", [ "v-20", "*", "h0", "v20" ] ], [ "nano:8", "lcd:D6", "gold", [ "v-16", "*", "h0", "v20" ] ], [ "nano:7", "lcd:D7", "gray", [ "v-12", "*", "h0", "v20" ] ], [ "nano:A4", "ds1307:SDA", "orange", [ "v16", "*", "h-20" ] ], [ "nano:A5", "ds1307:SCL", "purple", [ "v20", "*", "h-15" ] ], [ "r1:1", "lcd:A", "red", [] ], [ "nano:GND.1", "ir:GND", "black", [ "v12", "h0" ] ], [ "nano:5V", "ir:VCC", "red", [ "v0", "h0", "v8", "h0" ] ], [ "nano:2", "ir:DAT", "green", [ "v-8", "h84", "v-26", "h72", "v92" ] ] ] }
Generate a diagram.json code for Motion detection using PIR sensor and arduino uno
/* PIR sensor tester */ int ledPin = 13; // choose the pin for the LED int inputPin = 2; // choose the input pin (for PIR sensor) int pirState = LOW; // we start, assuming no motion detected int val = 0; // variable for reading the pin status void setup() { pinMode(ledPin, OUTPUT); // declare LED as output pinMode(inputPin, INPUT); // declare sensor as input Serial.begin(9600); } void loop() { val = digitalRead(inputPin); // read input value if (val == HIGH) { // check if the input is HIGH digitalWrite(ledPin, HIGH); // turn LED ON if (pirState == LOW) { // we have just turned on Serial.println("Motion detected!"); // We only want to print on the output change, not state pirState = HIGH; } } else { digitalWrite(ledPin, LOW); // turn LED OFF if (pirState == HIGH) { // we have just turned of Serial.println("Motion ended!"); // We only want to print on the output change, not state pirState = LOW; } } }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 98.67, "left": -98.67, "attrs": {} }, { "type": "wokwi-pir-motion-sensor", "id": "pir1", "top": -42, "left": 25.81, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -9, "left": -32.67, "attrs": { "color": "red" } } ], "connections": [ [ "pir1:VCC", "uno:5V", "red", [ "v19", "h-175", "v261", "h181" ] ], [ "pir1:OUT", "uno:2", "green", [ "v37", "h68" ] ], [ "uno:13", "led1:A", "green", [ "v-62", "h-47" ] ], [ "uno:GND.1", "led1:C", "black", [ "v-54", "h-33" ] ], [ "pir1:GND", "uno:GND.1", "black", [ "v31", "*", "v-28" ] ] ] }
Generate a diagram.json code for potentiometer value plotter
void setup() { Serial.begin(115200); pinMode(A0, INPUT); } void loop() { int value = analogRead(A0); Serial.println(value); delay(100); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot1", "top": 200.3, "left": 201.4, "attrs": {} } ], "connections": [ [ "pot1:GND", "uno:GND.2", "black", [ "v13", "h-40" ] ], [ "pot1:SIG", "uno:A0", "green", [ "v14", "h49", "v-90", "h-66" ] ], [ "uno:VIN", "pot1:VCC", "red", [ "v20", "h76", "v79", "h-33" ] ] ], "serialMonitor": { "display": "plotter" }, "dependencies": {} }
Generate a diagram.json code for Light intensity measuring using LDR and arduino uno
#include <LiquidCrystal_I2C.h> #define LDR_PIN 2 // LDR Characteristics const float GAMMA = 0.7; const float RL10 = 50; LiquidCrystal_I2C lcd(0x27, 20, 4); void setup() { pinMode(LDR_PIN, INPUT); lcd.init(); lcd.backlight(); } void loop() { int analogValue = analogRead(A0); float voltage = analogValue / 1024. * 5; float resistance = 2000 * voltage / (1 - voltage / 5); float lux = pow(RL10 * 1e3 * pow(10, GAMMA) / resistance, (1 / GAMMA)); lcd.setCursor(2, 0); lcd.print("Room: "); if (lux > 50) { lcd.print("Light!"); } else { lcd.print("Dark "); } lcd.setCursor(0, 1); lcd.print("Lux: "); lcd.print(lux); lcd.print(" "); delay(100); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 20, "left": 20, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd", "top": 242, "left": 50, "attrs": { "pins": "i2c" } }, { "type": "wokwi-photoresistor-sensor", "id": "ldr1", "top": -62.39, "left": 70.26, "attrs": {} } ], "connections": [ [ "uno:GND.2", "lcd:GND", "black", [ "v14", "*", "h-20" ] ], [ "uno:5V", "lcd:VCC", "red", [ "v18", "*", "h-16" ] ], [ "uno:A4", "lcd:SDA", "green", [ "v22", "*", "h-12" ] ], [ "uno:A5", "lcd:SCL", "blue", [ "v26", "*", "h-8" ] ], [ "uno:GND.1", "ldr1:GND", "black", [ "v-18", "h138", "v-44" ] ], [ "ldr1:VCC", "uno:5V", "red", [ "h92", "v276", "h-145" ] ], [ "ldr1:AO", "uno:A0", "orange", [ "h69", "v241", "h-84" ] ] ] }
Generate a diagram.json code for arduino qr code generator
// Arduino QR Code Generator // Author: Tomas Hubelbauer #include <LedControl.h> // https://github.com/wayoda/LedControl #include <qrcode.h> // https://github.com/ricmoo/QRCode int size = 6; int side = size * 8; QRCode qrcode; // DIN, CLK, CS LedControl ledControls[] = { LedControl(0, 1, 2, size), LedControl(3, 4, 5, size), LedControl(6, 7, 8, size), LedControl(9, 10, 11, size), LedControl(A0, A1, A2, size), LedControl(A3, A4, A5, size), }; int main() { int version = 1; uint8_t qrcodeData[qrcode_getBufferSize(version)]; qrcode_initText(&qrcode, qrcodeData, version, ECC_LOW, "HUBELBAUER.NET"); int scale = 2; int shift = (side - (qrcode.size * scale)) / 2; for (int y = shift; y < side; y++) { for (int x = shift; x < side; x++) { int index = y / 8; int address = size - 1 - (x / 8); int row = y % 8; int column = 7 - (x % 8); // Turn out of bounds dots off to make sure they don't stay on bool state = false; if (x >= shift && x < shift + (qrcode.size * scale) && y >= shift && y < shift + (qrcode.size * scale)) { state = qrcode_getModule(&qrcode, (x - shift) / scale, (y - shift) / scale); } ledControls[index].setLed(address, row, column, state); } } }
{ "version": 1, "author": "Tomas Hubelbauer, Koepel", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "u", "top": 33.94, "left": 793.3, "rotate": 90, "attrs": {} }, { "type": "wokwi-max7219-matrix", "id": "1", "top": 0, "left": 260, "attrs": { "chain": "6", "color": "white" } }, { "type": "wokwi-max7219-matrix", "id": "2", "top": 75, "left": 260, "attrs": { "chain": "6", "color": "white" } }, { "type": "wokwi-max7219-matrix", "id": "3", "top": 150, "left": 260, "attrs": { "chain": "6", "color": "white" } }, { "type": "wokwi-max7219-matrix", "id": "4", "top": 225, "left": 260, "attrs": { "chain": "6", "color": "white" } }, { "type": "wokwi-max7219-matrix", "id": "5", "top": 300, "left": 260, "attrs": { "chain": "6", "color": "white" } }, { "type": "wokwi-max7219-matrix", "id": "6", "top": 375, "left": 260, "attrs": { "chain": "6", "color": "white" } } ], "connections": [ [ "u:GND.2", "1:GND", "black", [ "*", "h6" ] ], [ "u:5V", "1:V+", "red", [ "*", "h12" ] ], [ "u:0", "1:DIN", "orange", [ "h20", "v25", "*", "h54" ] ], [ "u:1", "1:CLK", "blue", [ "h23", "v38", "*", "h18" ] ], [ "u:2", "1:CS", "green", [ "h26", "v51", "*", "h36" ] ], [ "u:GND.2", "2:GND", "black", [ "*", "h6" ] ], [ "u:5V", "2:V+", "red", [ "*", "h12" ] ], [ "u:3", "2:DIN", "orange", [ "h29", "v64", "*", "h57" ] ], [ "u:4", "2:CLK", "blue", [ "h32", "v77", "*", "h21" ] ], [ "u:5", "2:CS", "green", [ "h35", "v90", "*", "h39" ] ], [ "u:GND.2", "3:GND", "black", [ "*", "h6" ] ], [ "u:5V", "3:V+", "red", [ "*", "h12" ] ], [ "u:6", "3:DIN", "orange", [ "h38", "v103", "*", "h60" ] ], [ "u:7", "3:CLK", "blue", [ "h41", "v116", "*", "h24" ] ], [ "u:8", "3:CS", "green", [ "h44", "v136", "*", "h42" ] ], [ "u:GND.2", "4:GND", "black", [ "*", "h6" ] ], [ "u:5V", "4:V+", "red", [ "*", "h12" ] ], [ "u:9", "4:DIN", "orange", [ "h47", "v149", "*", "h63" ] ], [ "u:10", "4:CLK", "blue", [ "h50", "v162", "*", "h27" ] ], [ "u:11", "4:CS", "green", [ "h53", "v175", "*", "h45" ] ], [ "u:GND.2", "5:GND", "black", [ "*", "h6" ] ], [ "u:5V", "5:V+", "red", [ "*", "h12" ] ], [ "u:A0", "5:DIN", "orange", [ "*", "h66" ] ], [ "u:A1", "5:CLK", "blue", [ "*", "h30" ] ], [ "u:A2", "5:CS", "green", [ "*", "h48" ] ], [ "u:GND.2", "6:GND", "black", [ "*", "h6" ] ], [ "u:5V", "6:V+", "red", [ "*", "h12" ] ], [ "u:A3", "6:DIN", "orange", [ "*", "h69" ] ], [ "u:A4", "6:CLK", "blue", [ "*", "h33" ] ], [ "u:A5", "6:CS", "green", [ "*", "h51" ] ] ], "serialMonitor": { "display": "never" } }
Generate a diagram.json code for volume controller using arduino
#include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #include <Fonts/FreeSansBold9pt7b.h> #include <Fonts/Picopixel.h> #define ENCODER_CLK 2 #define ENCODER_DT 3 #define ENCODER_SW 4 uint8_t volume = 50; uint8_t bass = 25; uint8_t treble = 66; typedef enum { SET_VOLUME, SET_BASS, SET_TREBLE, } Mode; Mode mode = SET_VOLUME; Adafruit_SSD1306 display(128, 64, &Wire, -1); void nextMode() { switch (mode) { case SET_VOLUME: mode = SET_BASS; break; case SET_BASS: mode = SET_TREBLE; break; case SET_TREBLE: mode = SET_VOLUME; break; } } void updateValue(int delta) { switch (mode) { case SET_VOLUME: volume = constrain(volume + delta, 0, 100); break; case SET_BASS: bass = constrain(bass + delta, 0, 100); break; case SET_TREBLE: treble = constrain(treble + delta, 0, 100); break; } } void updateDisplay() { display.clearDisplay(); display.setFont(); display.setTextColor(1); display.setCursor(42, 2); display.print("Volume"); display.drawRoundRect(10, 12, 102, 9, 2, WHITE); display.fillRect(11, 13, volume, 7, WHITE); if (mode == SET_VOLUME) { display.setCursor(32, 2); display.print(">"); } display.setCursor(48, 22); display.print("Bass"); display.drawRoundRect(10, 32, 102, 9, 2, WHITE); display.fillRect(11, 33, bass, 7, WHITE); if (mode == SET_BASS) { display.setCursor(38, 22); display.print(">"); } display.setCursor(42, 42); display.print("Treble"); display.drawRoundRect(10, 52, 102, 9, 2, WHITE); display.fillRect(11, 53, treble, 7, WHITE); if (mode == SET_TREBLE) { display.setCursor(32, 42); display.print(">"); } display.display(); } void setup() { display.begin(SSD1306_SWITCHCAPVCC, 0x3C); pinMode(ENCODER_CLK, INPUT); pinMode(ENCODER_DT, INPUT); pinMode(ENCODER_SW, INPUT_PULLUP); updateDisplay(); } long int modeLastChanged = 0; int prevClk = HIGH; void loop() { if (digitalRead(ENCODER_SW) == LOW && millis() - modeLastChanged > 300) { modeLastChanged = millis(); nextMode(); updateDisplay(); } int clk = digitalRead(ENCODER_CLK); if (clk != prevClk && clk == LOW) { int dt = digitalRead(ENCODER_DT); int delta = dt == HIGH ? 5 : -5; updateValue(delta); updateDisplay(); } prevClk = clk; }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "uno", "top": -35.94, "left": 26.96, "attrs": {} }, { "type": "wokwi-ky-040", "id": "encoder1", "top": -143.6, "left": 60.34, "attrs": {} }, { "type": "wokwi-ssd1306", "id": "oled1", "top": 63.82, "left": 69.64, "attrs": {} } ], "connections": [ [ "uno:GND.1", "oled1:GND", "black", [ "v19", "h5" ] ], [ "uno:VIN", "oled1:VIN", "red", [ "v24", "h-15" ] ], [ "oled1:DATA", "uno:A4", "orange", [ "v-34", "h10" ] ], [ "oled1:CLK", "uno:A5", "blue", [ "v-30", "h5" ] ], [ "encoder1:CLK", "uno:2", "purple", [ "h42", "v85", "h-76" ] ], [ "encoder1:DT", "uno:3", "green", [ "h33", "v71", "h-73" ] ], [ "encoder1:SW", "uno:4", "gray", [ "h26", "v57", "h-75" ] ], [ "encoder1:VCC", "uno:VIN", "red", [ "h55", "v149", "h-28" ] ], [ "encoder1:GND", "uno:GND.2", "black", [ "h18", "v32", "h-43" ] ] ] }
Generate a diagram.json code for Date and time reader using ds1307 and arduino uno
#include "RTClib.h" RTC_DS1307 rtc; char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; void setup () { Serial.begin(115200); if (! rtc.begin()) { Serial.println("Couldn't find RTC"); Serial.flush(); abort(); } } void loop () { DateTime now = rtc.now(); Serial.print("Current time: "); Serial.print(now.year(), DEC); Serial.print('/'); Serial.print(now.month(), DEC); Serial.print('/'); Serial.print(now.day(), DEC); Serial.print(" ("); Serial.print(daysOfTheWeek[now.dayOfTheWeek()]); Serial.print(") "); Serial.print(now.hour(), DEC); Serial.print(':'); Serial.print(now.minute(), DEC); Serial.print(':'); Serial.print(now.second(), DEC); Serial.println(); Serial.println(); delay(3000); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "id": "uno", "type": "wokwi-arduino-uno", "top": 0, "left": 20 }, { "id": "ds1307", "type": "wokwi-ds1307", "top": 250, "left": 220 } ], "connections": [ ["uno:GND.2", "ds1307:GND", "black", ["v20", "*", "v0"]], ["uno:5V", "ds1307:5V", "red", ["v0"]], ["uno:A4", "ds1307:SDA", "green", ["v16", "h0", "*", "h-34"]], ["uno:A5", "ds1307:SCL", "orange", ["v20", "*", "h-30"]] ] }
Generate a diagram.json code for Parking sensor using hc-sr04 and arduino uno
// I simulate lighting efects on parking sensor lamp // It should be a led ring lamp in a garage changing // color and flashing by distance. //Project link in the description :) // Direction Color State // power-up white steady // >400 green rotating slowly // 200-400 green rotating faster // 100-200 yellow --||-- // 50-100 red fast rotation // 50-20 red flashing // <20 red/blue flashing // 3rd approach: rotating and changing palette // it is too demanding on calculation resources // When I saw it finished, I realised it would be easier with FadeToBlackBy() // but it is more flexible. #include <FastLED.h> #define TRIG_PIN A3 #define ECHO_PIN A2 #define LED_PIN 8 #define NUM_LEDS 16 #define BRIGHTNESS 255 #define LED_TYPE WS2812 #define COLOR_ORDER GRB CRGB leds[NUM_LEDS]; #define UPDATES_FREQ 100 // per second #define MEASURE_FREQ 2 // per second #define DISTANCE_MAX 400 // cm #define DISTANCE_MIN 0 // cm CRGBPalette16 currentPalette; TBlendType currentBlending; CRGB rgb; extern const TProgmemPalette16 mySemaphorePalette_p PROGMEM; /*** * *** * ***/ void setup() { delay(2000); pinMode(TRIG_PIN, OUTPUT); pinMode(ECHO_PIN, INPUT); // Serial.begin(9600); FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS); // .setCorrection( TypicalLEDStrip ); FastLED.setBrightness( BRIGHTNESS ); currentPalette = mySemaphorePalette_p; currentBlending = LINEARBLEND; // blank FillColorDelay( CRGB::Yellow, 1000); // Serial.println(" [BEGIN] "); // blank FillColorDelay( CRGB::Black, 1000); } /* * * * ****/ void loop() { static unsigned int distance = 10; static uint8_t colorIndex; static byte offset = 0; static unsigned int offset_delay = 100; // rotation speed static unsigned long lastOffsetTime = 0; // last rotation change static unsigned long lastMeasureTime = 0; // last use of HC-SR04 sensor static unsigned long lastPrintTime = 0; // last Serial.print time // distance is 200-1500 // ROTATION SPEED should change 20-1 rotation per second offset_delay = map( distance, 20, 400, 20, 100); if ( millis() - lastOffsetTime >= offset_delay ) { offset = (offset < NUM_LEDS - 1 ? offset + 1 : 0); // increment position lastOffsetTime = millis(); } // Measure two times per second if (millis() - lastMeasureTime >= 1000 / MEASURE_FREQ) { distance = get_distance(); colorIndex = map(distance, DISTANCE_MIN, DISTANCE_MAX, 0, 240); // update palette newGradientPaletteByDistance(distance); lastMeasureTime = millis(); } if ( distance > 30 ) { FillLEDsFromPalette( offset ); } else if ( offset % 2 == 0 ) { FillColorDelay(CRGB::Blue,200); // fill_solid( leds, NUM_LEDS, CRGB::Blue); } else { FillColorDelay(CRGB::Red,200); // fill_solid( leds, NUM_LEDS, CRGB::Red); } // Print only for debugging // if (millis() - lastPrintTime >= 2000) { // Serial.print(" [ distance: "); Serial.print(distance, DEC); // Serial.print("mm o_delay: "); Serial.print(offset_delay, DEC); // Serial.print(" index: "); Serial.print(colorIndex, DEC); // Serial.println(" ] "); // lastPrintTime = millis(); // } FastLED.show(); FastLED.delay(1000 / UPDATES_FREQ); } // Get color mapped by distance and create gradient palette based by this color void newGradientPaletteByDistance(int distance) { uint8_t xyz[12]; // Needs to be 4 times however many colors are being used. // 3 colors = 12, 4 colors = 16, etc. CRGB rgb; rgb = ColorFromPalette( mySemaphorePalette_p, map(distance, DISTANCE_MIN, DISTANCE_MAX, 0, 240), BRIGHTNESS, currentBlending); // index xyz[0] = 0; xyz[1] = rgb.r; xyz[2] = rgb.g; xyz[3] = rgb.b; // anchor of first color - must be zero xyz[4] = 40; xyz[5] = rgb.r; xyz[6] = rgb.g; xyz[7] = rgb.b; xyz[8] = 255; xyz[9] = 0; xyz[10] = 0; xyz[11] = 0; // anchor of last color - must be 255 currentPalette.loadDynamicGradientPalette(xyz); } // fill FastLED leds[] strip/ring with colors void FillLEDsFromPalette( byte offset) { //fill_solid( leds, NUM_LEDS, 0); // One gradient for ( int i = 0; i < NUM_LEDS; i++) { leds[ i ] = ColorFromPalette( currentPalette, (i+offset) * 255 / (NUM_LEDS - 1), BRIGHTNESS, currentBlending); } // Two gradients // for ( int i = 0; i < NUM_LEDS/2; i++) { // leds[ i ] = ColorFromPalette( currentPalette, (i+offset) * 255 / (NUM_LEDS/2 - 1), BRIGHTNESS, currentBlending); // leds[ i+(NUM_LEDS/2) ] = leds[i]; // } } // Fill all leds with one color and wait duration ms void FillColorDelay ( CRGB color, unsigned long duration ) { fill_solid( leds, NUM_LEDS, color); FastLED.show(); FastLED.delay(duration); } // This example shows how to set up a static color palette // which is stored in PROGMEM (flash), which is almost always more // plentiful than RAM. A static PROGMEM palette like this // takes up 64 bytes of flash. const TProgmemPalette16 mySemaphorePalette_p PROGMEM = { CRGB::Magenta, CRGB::Red, CRGB::Red, CRGB::Red, CRGB::Orange, CRGB::Orange, CRGB::Orange, CRGB::Orange, CRGB::Yellow, CRGB::Yellow, CRGB::Yellow, CRGB::Green, CRGB::Green, CRGB::Green, CRGB::Green, CRGB::White }; // get distance number 0-400 cm // use TRIG_PIN and ECHO_PIN of HC-SR04 sensor int get_distance() { static int distance; uint16_t duration = 0; uint32_t interval = 0; digitalWrite(TRIG_PIN, LOW); delayMicroseconds(5); digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10); digitalWrite(TRIG_PIN, LOW); // Read time of the trig and echo pins duration = pulseIn(ECHO_PIN, HIGH); // Calculates the distance distance = (duration / 2) / 29; return distance; // centimeters }
{ "version": 1, "author": "stevesigma", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": 187.29, "left": 177.88, "rotate": 180, "hide": false, "attrs": {} }, { "type": "wokwi-hc-sr04", "id": "sonar", "top": 61.25, "left": 190.94, "rotate": 0, "hide": false, "attrs": { "distance": "400" } }, { "type": "wokwi-led-ring", "id": "ring", "top": 57.34, "left": 32.62, "rotate": 0, "hide": false, "attrs": { "pixels": "16", "background": "black" } } ], "connections": [ [ "nano:5V", "sonar:VCC", "red", [ "*", "v20" ] ], [ "nano:GND.2", "sonar:GND", "black", [ "v20", "h130", "*", "v5" ] ], [ "nano:A2", "sonar:ECHO", "orange", [ "*" ] ], [ "nano:A3", "sonar:TRIG", "white", [ "*" ] ], [ "nano:GND.2", "ring:GND", "black", [ "v20", "h-133", "*", "*" ] ], [ "nano:8", "ring:DIN", "green", [ "v10", "h-180", "*" ] ], [ "nano:5V", "ring:VCC", "red", [ "v-20", "h-50", "v70", "h-70", "*" ] ] ] }
Generate a diagram.json code for digital weight scale using hx711 load cell and arduino uno
#include "HX711_ADC.h" #include <LiquidCrystal_I2C.h> HX711_ADC LoadCell(9, 8); LiquidCrystal_I2C lcd(0x27,16,2); const int buzzer = 11; int button1 = 2; int button2 = 3; int button3 = 4; int button4 = 5; int taree = 6; int num = 1; int buttonState = 0; int buttonState1 = 0; float alarm1 = 0; float alarm2 = 0; float z1 = 28.3495; unsigned long prevTime1 = millis(); unsigned long prevTime2 = millis(); long Time1 = 3000; long Time2 = 1000; void setup() { pinMode (button1, INPUT_PULLUP); pinMode (button2, INPUT_PULLUP); pinMode (button3, INPUT_PULLUP); pinMode (button4, INPUT_PULLUP); pinMode(buzzer, OUTPUT); pinMode (taree, INPUT_PULLUP); Serial.begin(9600); lcd.init(); lcd.backlight(); lcd.clear(); lcd.setCursor(1, 0); lcd.print("Weighing Scale"); lcd.setCursor(3, 1); lcd.print("With Alarm"); delay(2500); lcd.clear(); delay(150); lcd.setCursor(3, 0); lcd.print("Taring"); delay(200); lcd.setCursor(9, 0); lcd.print("."); delay(200); lcd.setCursor(10, 0); lcd.print("."); delay(200); lcd.setCursor(11, 0); lcd.print("."); delay(200); lcd.setCursor(12, 0); lcd.print("."); delay(200); delay(1000); lcd.clear(); LoadCell.begin(); LoadCell.start(1000); LoadCell.setCalFactor(0.42); } void loop() { unsigned long currentTime = millis(); static unsigned long currentTime1 = millis(); LoadCell.update(); float i = LoadCell.getData(); float z = i/28.3495; if(digitalRead(button3) == LOW){ alarm1=0; alarm2=0; lcd.clear();} buttonState = digitalRead(button2); buttonState1 = digitalRead(button1); if(buttonState == 0) currentTime1 = millis(); if(buttonState1 == 0) currentTime1 = millis(); switch(num){ case 1: { if(millis() - currentTime1 >= 4000) // else { num = 1; } else num = num; break; } case 2: { if(digitalRead(button1) == LOW){alarm1 = alarm1+1; delay(75);} else if(digitalRead(button2) == LOW){alarm1 = alarm1-1; delay(75);} if(digitalRead(button3) == LOW) alarm1=0; lcd.setCursor(1, 0); lcd.print("Set for Gram"); lcd.setCursor(0, 1); // set cursor to secon row lcd.print(alarm1, 0); // print out the retrieved value to the second row lcd.print("g "); alarm2 = alarm1/z1; lcd.setCursor(9, 1); lcd.print(alarm2, 1); lcd.print("oz "); if(millis() - currentTime1 >= 8000) { num = 1; lcd.clear(); lcd.setCursor(1, 0); lcd.print("Weighing Scale"); delay(500); lcd.clear();} else num = num; break;} case 3: { if(digitalRead(button1) == LOW){alarm2 = alarm2+1; delay(75);} else if(digitalRead(button2) == LOW){alarm2 = alarm2-1; delay(75);} lcd.setCursor(1, 0); lcd.print("Set for Ounce"); lcd.setCursor(0, 1); // set cursor to secon row lcd.print(alarm1, 0); // print out the retrieved value to the second row lcd.print("g "); alarm1 = alarm2 * z1; lcd.setCursor(9, 1); lcd.print(alarm2, 1); lcd.print("oz "); if(digitalRead(button3) == LOW) alarm2=0; if(millis() - currentTime1 >= 4000) // else { num = 1; lcd.clear(); lcd.setCursor(1, 0); lcd.print("Weighing Scale"); delay(500); lcd.clear();} else num = num; break;} } if (digitalRead (taree) == LOW) { lcd.clear(); lcd.setCursor(3, 0); lcd.print("Taring"); delay(200); lcd.setCursor(9, 0); lcd.print("."); delay(200); lcd.setCursor(10, 0); lcd.print("."); delay(200); lcd.setCursor(11, 0); lcd.print("."); delay(200); lcd.setCursor(12, 0); lcd.print("."); delay(200); delay(500); LoadCell.start(1000); lcd.setCursor(0, 0); lcd.print(" "); lcd.clear(); } if (digitalRead (button4) == LOW){{if(num>2) num = 1; else num++; currentTime1 = millis(); delay (300); lcd.clear(); delay (300); } if (num==3) { lcd.setCursor(1, 0); lcd.print("Set for Ounce"); delay(500); lcd.clear();} else if (num==2) {lcd.setCursor(1, 0); lcd.print("Set for Gram"); delay(500); lcd.clear();} else if (num==1) { lcd.setCursor(1, 0); lcd.print("Weighing Scale"); delay(500); lcd.clear();} } if(currentTime - prevTime1 > Time1){ if(i>alarm1 && alarm1>0 ) { noTone(buzzer); delay(300); tone(buzzer,250); delay(300); noTone(buzzer); delay(300); tone(buzzer,450); delay(300); noTone(buzzer); delay(300);} prevTime1 = currentTime; } if(i<-0.9){i==i;} else if(-0.9<i && i<0.1){i=0;} if(currentTime - prevTime2 > Time2){ if (i>=3000 && num<4) { lcd.clear(); delay(500); num=4; }else if(num==4 && i<3000){ num=1; lcd.clear(); delay(1000); } if(num==1){ lcd.setCursor(1, 0); lcd.print("Weighing Scale"); lcd.setCursor(0,1); lcd.print(i, 0); lcd.print("g "); lcd.setCursor(9,1); lcd.print(z, 1); lcd.print("oz ");} prevTime2 = currentTime; if(num==4){ lcd.setCursor(0, 0); lcd.print(" Over Loaded "); delay(500); lcd.clear(); delay(500);} } Serial.print(currentTime); Serial.print(" "); Serial.print(millis()); Serial.print(" "); Serial.print(prevTime2); Serial.println(" "); }
{ "version": 1, "author": "Justine matic013", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-buzzer", "id": "bz1", "top": -182.77, "left": 85.42, "attrs": { "volume": "0.1" } }, { "type": "wokwi-hx711", "id": "hx7", "top": 124.2, "left": 310.51, "attrs": { "type": "3kg" } }, { "type": "wokwi-pushbutton", "id": "btn1", "top": -124.43, "left": 235.69, "attrs": { "color": "blue", "label": "Up", "key": "1" } }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": -327.87, "left": 97.48, "attrs": { "pins": "i2c" } }, { "type": "wokwi-pushbutton", "id": "btn2", "top": -120.37, "left": 322.72, "attrs": { "color": "blue", "label": "Down", "key": "2" } }, { "type": "wokwi-pushbutton", "id": "btn3", "top": -118.96, "left": 410.54, "attrs": { "color": "green", "label": "Reset/Stop", "key": "3" } }, { "type": "wokwi-pushbutton", "id": "btn4", "top": -116.38, "left": 503.88, "attrs": { "color": "red", "label": "Mode", "key": "4" } }, { "type": "wokwi-pushbutton", "id": "btn5", "top": -117.37, "left": 592.34, "attrs": { "color": "grey", "label": "Tare", "key": "5" } } ], "connections": [ [ "bz1:2", "uno:11", "red", [ "v36.27", "h27.43" ] ], [ "uno:GND.2", "lcd1:GND", "black", [ "v41.96", "h-177.57", "v-195.25" ] ], [ "uno:A4", "lcd1:SDA", "green", [ "v69.2", "h-243.29", "v-195.81" ] ], [ "uno:A5", "lcd1:SCL", "blue", [ "v85.1", "h-246.54", "v-22.7" ] ], [ "btn2:1.r", "uno:3", "orange", [ "v69.56", "h-5.39" ] ], [ "btn1:2.l", "btn2:2.l", "black", [ "h3.66", "v36.06", "h88.44" ] ], [ "btn2:2.l", "btn3:2.l", "black", [ "h0.56", "v37.88", "h106.82" ] ], [ "btn3:1.r", "uno:4", "gold", [ "v78.15", "h-273.08" ] ], [ "lcd1:VCC", "uno:5V", "red", [ "h-104.11", "v536.86", "h16.59" ] ], [ "btn3:2.l", "btn4:2.l", "black", [ "h-0.06", "v35.76", "h104.2" ] ], [ "btn4:1.r", "uno:5", "blue", [ "v88.49", "h-361.09" ] ], [ "uno:GND.1", "bz1:1", "black", [ "v0" ] ], [ "btn1:1.l", "uno:2", "green", [ "h0" ] ], [ "uno:GND.1", "btn1:2.l", "black", [ "v0" ] ], [ "hx7:GND", "uno:GND.2", "black", [ "h0" ] ], [ "hx7:VCC", "uno:5V", "red", [ "h0" ] ], [ "btn4:2.l", "btn5:2.l", "black", [ "h-0.19", "v32.47", "h88.22" ] ], [ "hx7:DT", "uno:9", "green", [ "h0" ] ], [ "uno:8", "hx7:SCK", "green", [ "v0" ] ], [ "uno:6", "btn5:1.r", "green", [ "v-36.51", "h460.24", "v-82.43" ] ] ] }
Generate a diagram.json code for LED bar with potentiometer and arduino uno
const int analogPin = A0; // the pin that the potentiometer is attached to const int ledCount = 10; // the number of LEDs in the bar graph int ledPins[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; // an array of pin numbers to which LEDs are attached void setup() { // loop over the pin array and set them all to output: for (int thisLed = 0; thisLed < ledCount; thisLed++) { pinMode(ledPins[thisLed], OUTPUT); } } void loop() { // read the potentiometer: int sensorReading = analogRead(analogPin); // map the result to a range from 0 to the number of LEDs: int ledLevel = map(sensorReading, 0, 1023, 0, ledCount); // loop over the LED array: for (int thisLed = 0; thisLed < ledCount; thisLed++) { // if the array element's index is less than ledLevel, // turn the pin for this element on: if (thisLed < ledLevel) { digitalWrite(ledPins[thisLed], HIGH); } // turn off all pins higher than the ledLevel: else { digitalWrite(ledPins[thisLed], LOW); } } }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 209.75, "left": -189.97, "rotate": 90, "attrs": {} }, { "type": "wokwi-led-bar-graph", "id": "bargraph1", "top": 313.04, "left": 127.68, "attrs": { "color": "lime" } }, { "type": "wokwi-resistor", "id": "r1", "top": 309, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r2", "top": 319, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r3", "top": 328, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r4", "top": 337, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r5", "top": 347, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r6", "top": 357, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r7", "top": 366, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r8", "top": 376, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r9", "top": 385, "left": 190, "attrs": {} }, { "type": "wokwi-resistor", "id": "r10", "top": 395, "left": 190, "attrs": {} }, { "type": "wokwi-slide-potentiometer", "id": "pot1", "top": 266.78, "left": -337.42, "rotate": 270, "attrs": { "travelLength": "30" } } ], "connections": [ [ "bargraph1:A10", "uno:2", "green", [ "h-28", "v31" ] ], [ "bargraph1:A9", "uno:3", "green", [ "h-38", "v31" ] ], [ "bargraph1:A8", "uno:4", "green", [ "h-47", "v31" ] ], [ "bargraph1:A7", "uno:5", "green", [ "h-57", "v31" ] ], [ "bargraph1:A6", "uno:6", "green", [ "h-67", "v31" ] ], [ "bargraph1:A5", "uno:7", "green", [ "h-76", "v31" ] ], [ "bargraph1:A4", "uno:8", "green", [ "h0" ] ], [ "bargraph1:A3", "uno:9", "green", [ "h0" ] ], [ "bargraph1:A2", "uno:10", "green", [ "h0" ] ], [ "bargraph1:A1", "uno:11", "green", [ "h0" ] ], [ "r1:1", "bargraph1:C1", "green", [ "v0" ] ], [ "r2:1", "bargraph1:C2", "green", [ "v0" ] ], [ "r3:1", "bargraph1:C3", "green", [ "v0" ] ], [ "r4:1", "bargraph1:C4", "green", [ "v0" ] ], [ "r5:1", "bargraph1:C5", "green", [ "v0" ] ], [ "r6:1", "bargraph1:C6", "green", [ "v0" ] ], [ "r7:1", "bargraph1:C7", "green", [ "v0" ] ], [ "r8:1", "bargraph1:C8", "green", [ "v0" ] ], [ "r9:1", "bargraph1:C9", "green", [ "v0" ] ], [ "r10:1", "bargraph1:C10", "green", [ "v0" ] ], [ "r10:2", "r9:2", "black", [ "v0" ] ], [ "r8:2", "r9:2", "black", [ "v0" ] ], [ "r8:2", "r7:2", "black", [ "v0" ] ], [ "r7:2", "r6:2", "black", [ "v0" ] ], [ "r6:2", "r5:2", "black", [ "v0" ] ], [ "r5:2", "r4:2", "black", [ "v0" ] ], [ "r4:2", "r3:2", "black", [ "v0" ] ], [ "r3:2", "r2:2", "black", [ "v0" ] ], [ "r2:2", "r1:2", "black", [ "v0" ] ], [ "uno:GND.1", "r1:2", "black", [ "h0" ] ], [ "pot1:GND", "uno:GND.2", "black", [ "v-14", "h72", "v139" ] ], [ "pot1:SIG", "uno:A0", "green", [ "v14", "h51", "v-59" ] ], [ "uno:VIN", "pot1:VCC", "red", [ "h-48", "v72", "h-61" ] ] ] }
Generate a diagram.json code for MPU6050 with arduino uno for 6 axis accel and gyro sensor
// originally by Andy Sloane for the Arduboy // https://www.a1k0n.net/2017/02/01/arduboy-teapot.html #include <Wire.h> #include "Tiny4kOLED.h" #include <avr/pgmspace.h> #include "draw.h" #include "sincos.h" #include "vec.h" #include "teapot.h" const int MPU_addr = 0x68; // I2C address of the MPU-6050 uint8_t screen_[1024]; int32_t angle_A_ = 0, angle_B_ = 0, angle_C_ = -16384; int16_t scale_ = 1024 + 500; uint16_t frame_ = 0; static Vec216 verts[mesh_NVERTS]; // rotated, projected screen space vertices void setup(void) { Wire.begin(); oled.begin(128, 64, sizeof(tiny4koled_init_128x64br), tiny4koled_init_128x64br); // Initialize the MPU-6050 and test if it is connected. Wire.beginTransmission( MPU_addr); Wire.write( 0x6B); // PWR_MGMT_1 register Wire.write( 0); // set to zero (wakes up the MPU-6050) auto error = Wire.endTransmission(); } void ReadInput() { static bool manual_control = false; Wire.beginTransmission( MPU_addr); Wire.write( 0x43); // starting with register 0x43 (GYRO_XOUT_H) Wire.endTransmission( false); Wire.requestFrom( MPU_addr, 6); // request a total of 6 bytes int16_t gx = Wire.read()<<8 | Wire.read(); // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L) int16_t gy = Wire.read()<<8 | Wire.read(); // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L) int16_t gz = Wire.read()<<8 | Wire.read(); // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L) if (gx || gy || gz) { manual_control = true; angle_A_ += gx / 16; angle_B_ += gy / 16; angle_C_ += gz / 16; } if (!manual_control) { angle_A_ += 499; angle_B_ += 331; angle_C_ += 229; } } // down-convert signed 1.10 precision to signed 0.7 precision // (scaling down from -1024..1024 to -127..127) static int8_t RescaleR(int16_t x) { return ((uint32_t) x*127 + 512) >> 10; } void DrawObject() { // construct rotation matrix int16_t cA, sA, cB, sB, cC, sC; GetSinCos((angle_A_ >> 6) & 1023, &sA, &cA); GetSinCos((angle_B_ >> 6) & 1023, &sB, &cB); GetSinCos((angle_C_ >> 6) & 1023, &sC, &cC); // rotate about X axis by C, then Y axis by B, then Z axis by A // [ cA*cB, cB*sA, sB] // R = [-cA*sB*sC - cC*sA, cA*cC - sA*sB*sC, cB*sC] // [-cA*cC*sB + sA*sC, -cA*sC - cC*sA*sB, cB*cC] // local coordinate frame given rotation values // spend some time up front to get an accurate rotation matrix before // rounding to 0.7 fixed point // the 32-bit math is only done once per frame, and then we can do // all the per-vertex stuff in 8-bit math Mat338 rotation_matrix(Vec38( RescaleR((int32_t) cA*cB >> 10), RescaleR((int32_t) cB*sA >> 10), RescaleR(sB)), Vec38( RescaleR(((int32_t) -cA*sB*sC >> 10) - (int32_t) cC*sA >> 10), RescaleR((int32_t) cA*cC - ((int32_t) sA*sB*sC >> 10) >> 10), RescaleR((int32_t) cB*sC >> 10)), Vec38( RescaleR(((int32_t) -cA*cC*sB >> 10) + (int32_t) sA*sC >> 10), RescaleR((int32_t) -cA*sC - ((int32_t) cC*sA*sB >> 10) >> 10), RescaleR((int32_t) cB*cC >> 10))); int8_t sortaxis = 0, sortaxisz = rotation_matrix.z.x; if (abs(rotation_matrix.z.y) > abs(sortaxisz)) { sortaxis = 1; sortaxisz = rotation_matrix.z.y; } if (abs(rotation_matrix.z.z) > abs(sortaxisz)) { sortaxis = 2; sortaxisz = rotation_matrix.z.z; } rotation_matrix.RotateAndProject(mesh_vertices, mesh_NVERTS, scale_, verts); // rotate and project all vertices /* { Vec216 *vertptr = verts; for (uint16_t j = 0; j < 3*mesh_NVERTS; j += 3) { Vec38 obj_vert( pgm_read_byte_near(mesh_vertices + j), pgm_read_byte_near(mesh_vertices + j + 1), pgm_read_byte_near(mesh_vertices + j + 2)); Vec38 world_vert( Fx.dot(obj_vert), Fy.dot(obj_vert), Fz.dot(obj_vert)); world_vert.project(scale_, vertptr++); } } */ // back-face cull and sort faces for (uint16_t i = 0; i < mesh_NFACES; i++) { uint16_t jf = i; // use face sort order depending on which axis is most facing toward camera if (sortaxisz < 0) { jf = mesh_NFACES - 1 - i; } if (sortaxis == 1) { jf = pgm_read_byte_near(mesh_ysort_faces + jf); } else if (sortaxis == 2) { jf = pgm_read_byte_near(mesh_zsort_faces + jf); } jf *= 3; uint8_t fa = pgm_read_byte_near(mesh_faces + jf), fb = pgm_read_byte_near(mesh_faces + jf + 1), fc = pgm_read_byte_near(mesh_faces + jf + 2); Vec216 sa = verts[fb] - verts[fa]; Vec216 sb = verts[fc] - verts[fa]; if ((int32_t) sa.x * sb.y > (int32_t) sa.y * sb.x) { // check winding order continue; // back-facing } int8_t illum = rotation_matrix.CalcIllumination(mesh_normals + jf); uint8_t pat[4]; GetDitherPattern(illum, pat); FillTriangle( verts[fa].x, verts[fa].y, verts[fb].x, verts[fb].y, verts[fc].x, verts[fc].y, pat, screen_); } } class Stars { static const int kNumStars = 30; uint16_t wyhash16_x; private: // https://github.com/littleli/go-wyhash16/blob/master/wyhash16.go uint32_t hash16(uint32_t input, uint32_t key) { uint32_t hash = input * key; return ((hash >> 16) ^ hash) & 0xFFFF; } uint16_t wyhash16() { wyhash16_x += 0xfc15; return hash16(wyhash16_x, 0x2ab); } public: void Draw() { wyhash16_x = 0xabcd; // reseed our private PRNG for (uint8_t i = 0; i < kNumStars; i++) { uint16_t randval = wyhash16(); uint8_t xpos = randval ^ (randval >> 8); uint8_t ypos = (randval >> 8) & 63; uint8_t xspeed = 1 + ((randval + (randval >> 13)) & 7); uint16_t page = (ypos >> 3) << 7; uint8_t mask = 1 << (ypos & 7); uint8_t x = xpos - xspeed * frame_; x >>= 1; screen_[page + x] |= mask; } } }; Stars stars_; void loop(void) { memset(screen_, 0, 1024); stars_.Draw(); ReadInput(); DrawObject(); uint8_t *addr = screen_; for (uint8_t y = 0; y < 8; y++) { oled.setCursor(0, y); oled.startData(); for (uint8_t i = 0; i < 128; i++) oled.sendData(*addr++); oled.endData(); } frame_++; }
{ "version": 1, "author": "Andy Sloane (a1kon)", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 30, "left": 134.67, "rotate": 90, "attrs": {} }, { "type": "wokwi-mpu6050", "id": "mpu", "top": 170, "left": 25, "rotate": 270, "attrs": {} }, { "type": "wokwi-ssd1306", "id": "oled1", "top": 267.02, "left": 28.5, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 190, "left": 110, "rotate": 90, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r2", "top": 190, "left": 90, "rotate": 90, "attrs": { "value": "10000" } } ], "connections": [ [ "uno:5V", "mpu:VCC", "red", [ "h-157", "v9" ] ], [ "uno:5V", "r1:1", "red", [ "h0" ] ], [ "uno:5V", "r2:1", "red", [ "h0" ] ], [ "uno:A4", "r2:2", "LimeGreen", [ "h0" ] ], [ "uno:A4", "oled1:DATA", "LimeGreen", [ "h-79", "v9", "h-3" ] ], [ "uno:A4", "mpu:SDA", "LimeGreen", [ "h-79", "v9", "h-78", "v-4" ] ], [ "uno:A5", "r1:2", "Gold", [ "h0" ] ], [ "uno:A5", "oled1:CLK", "Gold", [ "h-70", "v9", "h-1" ] ], [ "uno:A5", "mpu:SCL", "Gold", [ "h-70", "v9", "h-96", "v-60" ] ], [ "uno:5V", "oled1:VIN", "red", [ "h-16", "v106", "h-20" ] ], [ "uno:GND.2", "oled1:GND", "black", [ "h-23", "v92", "h-29" ] ], [ "uno:GND.2", "mpu:GND", "black", [ "h-23", "v-15", "h-140", "v26" ] ] ] }
Generate a diagram.json code for TM1637 thermometer in pi pico
import machine import random import time import tm1637 display = tm1637.TM1637(clk=machine.Pin(16), dio=machine.Pin(17)) display.scroll("Pico Thermometer", delay=200) time.sleep(1) display.show(' ') time.sleep(1) temp = random.randrange(10,15) while True: temp = random.randrange(10,25) display.temperature(temp) time.sleep(10)
{ "version": 1, "author": "Luc Volders", "editor": "wokwi", "parts": [ { "type": "wokwi-pi-pico", "id": "pico", "top": -9.33, "left": 28, "attrs": { "env": "micropython-20220117-v1.18" } }, { "type": "wokwi-tm1637-7segment", "id": "sevseg1", "top": -127.03, "left": -124.63, "attrs": { "color": "red" } } ], "connections": [ [ "sevseg1:CLK", "pico:GP16", "green", [ "h70.12", "v350.78" ] ], [ "sevseg1:DIO", "pico:GP17", "green", [ "h76.12", "v331.58" ] ], [ "sevseg1:GND", "pico:GND.8", "black", [ "h104.12", "v158.78" ] ], [ "sevseg1:VCC", "pico:VBUS", "red", [ "h90.78", "v149.18" ] ] ] }
Generate a diagram.json code for Auto room light using arduno nano
// **** Students name - Auto Room light #include "oled.h" //load the oled with Adafruit_SSD1306.h library void setup() { setup_oled(); // Start the OLED Display } void loop() { SW_check(); //this function does something after checking A0 low OLED_PRINT("All OFF "); digitalWrite(2, LOW); digitalWrite(3, LOW); sdelay(300); //off for 0.3 sec OLED_PRINT("2 ON "); digitalWrite(2, HIGH); digitalWrite(3, LOW); sdelay(200); //blip for 0.2 sec } void SW_check() { if (digitalRead(A0) == LOW) { OLED_PRINT("RUNNING "); digitalWrite(2, HIGH); digitalWrite(3, HIGH); sdelay(3000); } }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": -148.8, "left": -269.3, "attrs": {} }, { "type": "board-ssd1306", "id": "oled1", "top": -150.46, "left": -57.37, "attrs": { "i2cAddress": "0x3c" } }, { "type": "wokwi-gnd", "id": "gnd2", "top": -192, "left": -58.2, "attrs": {} }, { "type": "wokwi-pushbutton", "id": "btn1", "top": -32.2, "left": -336, "attrs": { "color": "yellow" } }, { "type": "wokwi-gnd", "id": "gnd3", "top": 67.2, "left": -250.2, "attrs": {} }, { "type": "wokwi-vcc", "id": "vcc1", "top": -229.64, "left": -28.8, "attrs": {} }, { "type": "wokwi-gnd", "id": "gnd1", "top": -201.6, "left": -298.2, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -253.2, "left": -217, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -253.2, "left": -178.6, "attrs": { "color": "cyan" } } ], "connections": [ [ "oled1:SCL", "nano:A5", "green", [ "v-28.8", "h77.1", "v124.8", "h-393.6" ] ], [ "oled1:SDA", "nano:A4", "green", [ "v-19.2", "h57.67", "v105.6", "h-393.6" ] ], [ "nano:A0", "btn1:1.r", "green", [ "v19.2", "h-38.4" ] ], [ "oled1:VCC", "vcc1:VCC", "red", [ "v0" ] ], [ "oled1:GND", "gnd2:GND", "black", [ "v-67.2" ] ], [ "btn1:2.r", "gnd3:GND", "green", [ "h0" ] ], [ "led2:A", "nano:2", "green", [ "v0" ] ], [ "led1:A", "nano:3", "green", [ "v28.8", "h28.8" ] ], [ "gnd1:GND", "led1:C", "black", [ "v0" ] ], [ "led2:C", "gnd1:GND", "green", [ "v9.6", "h0.4" ] ] ], "dependencies": {} }
Generate a diagram.json code for Temperature and humitity measurement
#include <DHT.h> #include <LiquidCrystal_I2C.h> //Pin definitions for the Thermostat components. #define DHTPIN 2 #define DHTTYPE DHT22 #define RELAY_PIN 8 #define RED_PIN 9 #define GREEN_PIN 10 #define BLUE_PIN 11 #define INCREASE_BTN 3 #define DECREASE_BTN 4 //Libraries used for the thermostat project. DHT dht(DHTPIN, DHTTYPE); LiquidCrystal_I2C lcd(0x27, 16, 2); //These variable will be used to control the temperature and humidity levels in the thermostat. float currentTemp = 25.0; float targetTemp = 25.0; float humidity = 50.0; //Initializaing the Serial monitor, DHT Sensor and LCD. void setup() { Serial.begin(9600); dht.begin(); lcd.init(); lcd.backlight(); //Set the LED pins as output and button pins as input. pinMode(RELAY_PIN, OUTPUT); pinMode(RED_PIN, OUTPUT); pinMode(GREEN_PIN, OUTPUT); pinMode(BLUE_PIN, OUTPUT); pinMode(INCREASE_BTN, INPUT_PULLUP); pinMode(DECREASE_BTN, INPUT_PULLUP); // Start with green LED setLEDColor(0, 255, 0); } void loop() { readSensor(); checkButtons(); updateLCD(); controlRelay(); updateLED(); delay(100); } void readSensor() { float newTemp = dht.readTemperature(); float newHumidity = dht.readHumidity(); if (!isnan(newTemp) && !isnan(newHumidity)) { currentTemp = newTemp; humidity = newHumidity; } } //Controlling the temperature based on the buttons. Buttons upon being pressed, can alter the temperature. void checkButtons() { if (digitalRead(INCREASE_BTN) == LOW) { targetTemp += 1; delay(200); // Debounce } if (digitalRead(DECREASE_BTN) == LOW) { targetTemp -= 1; delay(200); // Debounce } } //Display the temperature and humidity level readings on the LCD we've used. void updateLCD() { lcd.clear(); lcd.setCursor(0, 0); lcd.print("Temp: "); lcd.print(currentTemp, 1); lcd.print("C "); lcd.print(targetTemp, 1); lcd.print("C"); lcd.setCursor(0, 1); lcd.print("Humidity: "); lcd.print(humidity, 1); lcd.print("%"); } //Controlling the relay according to the temperature. If the set temp.> room temp. then the relay turns on the heating. If the set temp.< room temp. then the relay turns off the heating. void controlRelay() { if (currentTemp < targetTemp) { digitalWrite(RELAY_PIN, HIGH); // Turn on heating } else { digitalWrite(RELAY_PIN, LOW); // Turn off heating } } //Changing the color of the LED based on the temperature. If the set temp.> current temp. then led turns red. If set temp.< current temp. then led turns blue. If set temp.= current temp. then led turns green. void updateLED() { if (currentTemp < targetTemp) { setLEDColor(0, 0, 255); // Blue } else if (currentTemp > targetTemp) { setLEDColor(255, 0, 0); // Red } else { setLEDColor(0, 255, 0); // Green } } void setLEDColor(int red, int green, int blue) { analogWrite(RED_PIN, red); analogWrite(GREEN_PIN, green); analogWrite(BLUE_PIN, blue); }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard", "id": "bb1", "top": -31.8, "left": 319.6, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "uno", "top": 288.6, "left": 393, "attrs": {} }, { "type": "wokwi-rgb-led", "id": "rgb1", "top": -5.6, "left": 711.5, "attrs": { "common": "cathode" } }, { "type": "wokwi-dht22", "id": "dht1", "top": -28.5, "left": 589.8, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 90.65, "left": 555.4, "rotate": 180, "attrs": { "value": "10000" } }, { "type": "wokwi-pushbutton", "id": "btn1", "top": 28.2, "left": 435, "rotate": 90, "attrs": { "color": "red" } }, { "type": "wokwi-pushbutton", "id": "btn2", "top": 28.2, "left": 329.4, "rotate": 90, "attrs": { "color": "blue" } }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": 227.2, "left": 831.2, "attrs": { "pins": "i2c" } }, { "type": "wokwi-resistor", "id": "r2", "top": 81.6, "left": 690.65, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r3", "top": 81.6, "left": 709.85, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r4", "top": 81.6, "left": 719.45, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r5", "top": 90.35, "left": 374.4, "attrs": { "value": "10000" } }, { "type": "wokwi-resistor", "id": "r6", "top": 90.35, "left": 480, "attrs": { "value": "10000" } }, { "type": "wokwi-relay-module", "id": "relay1", "top": 240.2, "left": 220.8, "attrs": {} } ], "connections": [ [ "uno:5V", "bb1:bp.1", "red", [ "v47.9", "h-188.2" ] ], [ "uno:GND.3", "bb1:bn.1", "black", [ "v76.7", "h-206.4" ] ], [ "bb1:23b.h", "bb1:28b.h", "red", [ "v0" ] ], [ "bb1:23b.i", "bb1:bp.18", "red", [ "v0" ] ], [ "bb1:31b.i", "bb1:bn.25", "black", [ "v0" ] ], [ "lcd1:SDA", "uno:A4", "cyan", [ "h-38.4", "v221", "h-157.8" ] ], [ "lcd1:SCL", "uno:A5", "magenta", [ "h-19.2", "v441.9" ] ], [ "lcd1:GND", "bb1:bn.37", "black", [ "h0" ] ], [ "lcd1:VCC", "bb1:bp.37", "red", [ "h-67.2", "v-114.2" ] ], [ "bb1:4b.h", "bb1:bn.2", "black", [ "v0" ] ], [ "bb1:15b.h", "bb1:bn.11", "black", [ "v0" ] ], [ "bb1:13b.g", "uno:3", "red", [ "v144", "h153.6" ] ], [ "bb1:29b.h", "uno:2", "yellow", [ "v96", "h9.6" ] ], [ "bb1:41t.e", "bb1:bn.33", "black", [ "v0" ] ], [ "bb1:2b.g", "uno:4", "blue", [ "v105.6", "h230.4" ] ], [ "relay1:VCC", "bb1:bp.6", "red", [ "h-19.2", "v-38.4", "h230.4" ] ], [ "relay1:IN", "uno:8", "white", [ "h-38.4", "v67", "h384" ] ], [ "relay1:GND", "bb1:bn.6", "black", [ "h-19.2", "v47.6", "h211.2" ] ], [ "bb1:40b.j", "uno:11", "red", [ "v134.4", "h-134.4" ] ], [ "bb1:42b.j", "uno:10", "limegreen", [ "v144", "h-182.4" ] ], [ "bb1:43b.j", "uno:9", "cyan", [ "v153.6", "h-192" ] ], [ "rgb1:R", "bb1:40t.c", "", [ "$bb" ] ], [ "rgb1:COM", "bb1:41t.d", "", [ "$bb" ] ], [ "rgb1:G", "bb1:42t.c", "", [ "$bb" ] ], [ "rgb1:B", "bb1:43t.c", "", [ "$bb" ] ], [ "dht1:VCC", "bb1:28b.f", "", [ "$bb" ] ], [ "dht1:SDA", "bb1:29b.f", "", [ "$bb" ] ], [ "dht1:NC", "bb1:30b.f", "", [ "$bb" ] ], [ "dht1:GND", "bb1:31b.f", "", [ "$bb" ] ], [ "r1:1", "bb1:29b.g", "", [ "$bb" ] ], [ "r1:2", "bb1:23b.g", "", [ "$bb" ] ], [ "btn1:1.l", "bb1:15t.a", "", [ "$bb" ] ], [ "btn1:2.l", "bb1:13t.a", "", [ "$bb" ] ], [ "btn1:1.r", "bb1:15b.f", "", [ "$bb" ] ], [ "btn1:2.r", "bb1:13b.f", "", [ "$bb" ] ], [ "btn2:1.l", "bb1:4t.a", "", [ "$bb" ] ], [ "btn2:2.l", "bb1:2t.a", "", [ "$bb" ] ], [ "btn2:1.r", "bb1:4b.f", "", [ "$bb" ] ], [ "btn2:2.r", "bb1:2b.f", "", [ "$bb" ] ], [ "r2:1", "bb1:40t.e", "", [ "$bb" ] ], [ "r2:2", "bb1:40b.i", "", [ "$bb" ] ], [ "r3:1", "bb1:42t.e", "", [ "$bb" ] ], [ "r3:2", "bb1:42b.i", "", [ "$bb" ] ], [ "r4:1", "bb1:43t.e", "", [ "$bb" ] ], [ "r4:2", "bb1:43b.i", "", [ "$bb" ] ], [ "r5:1", "bb1:4b.g", "", [ "$bb" ] ], [ "r5:2", "bb1:10b.g", "", [ "$bb" ] ], [ "r6:1", "bb1:15b.g", "", [ "$bb" ] ], [ "r6:2", "bb1:21b.g", "", [ "$bb" ] ] ], "dependencies": {} }
Generate a diagram.json code for Telephone dialer using buzzr with arduino-nano
// Arduino Phone Dialer. // Uses the pulse dialing method to dial a phone number. int offtimer = 60; // The higher the number, the slower the timing. int ontimer = 30; uint8_t phone_number[] = {1,2,3,4,5,6,7,8,9,0}; // the phone number to dial //int number_length = 9; // the number of digits in the phone number (i.e. the length of the array) int out=13; // the output pin to the pulsing relay int didthis=0; uint8_t DebugModeSerial = 1; //DTMF-------------------------- #include "Tone.h" Tone freq1; Tone freq2; const int DTMF_freq1[] = { 1336, 1209, 1336, 1477, 1209, 1336, 1477, 1209, 1336, 1477 }; const int DTMF_freq2[] = { 941, 697, 697, 697, 770, 770, 770, 852, 852, 852 }; //DTMF-------------------------- void setup(){ Serial.begin(115200); pinMode(out, OUTPUT); // define pin as output. freq1.begin(3); freq2.begin(4); } void loop(){ if(didthis == 0){ digitalWrite(out, HIGH); // turn on the relay to establish a connection to the phone (i.e. plugging in the phone) delay (1000); //uint8_t Phone_number[] = {1,2,3,4,5,6,7,8,9,0}; Pulse_Dialer(phone_number,sizeof(phone_number)); } didthis=1; digitalWrite(out, HIGH); // turn the relay ON to keep the phone on the line and wait for the other end to ring. DTMF_Dialing(); } void Pulse_Dialer(uint8_t phone_number[],uint8_t Phone_Len){ for(int count=0; count<Phone_Len; count++){ delay (1000); // delay after every number dialed uint8_t Digit = phone_number[count]; if(Digit == 0){Digit = 10;} if(DebugModeSerial){ Serial.print("DigitCount "); Serial.print(count); Serial.print(" Digit "); Serial.print(Digit); } for(int digit=0; digit<Digit; digit++){ if(DebugModeSerial){ Serial.print(" LOW "); } digitalWrite(out, LOW); // turn the relay OFF delay(offtimer); // wait for a while digitalWrite(out, HIGH); // turn the relay ON delay(ontimer); // wait for a while } if(DebugModeSerial){ Serial.println(" End "); } } if(DebugModeSerial){ Serial.println(" End Pulse_Dialer"); } } void playDTMF(uint8_t number, long duration){ freq1.play(DTMF_freq1[number], duration); freq2.play(DTMF_freq2[number], duration); } void DTMF_Dialing(){ int i; uint8_t phone_number[] = {2,0,4};//{ 8, 6, 7, 5, 3, 0 ,9 }; for(i=0; i<sizeof(phone_number); i ++){ Serial.print(phone_number[i], 10); Serial.print(' '); playDTMF(phone_number[i], 500); delay(600); } Serial.println(); delay(4000); }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 82.8, "left": 61.8, "attrs": { "color": "blue", "flip": "1" } }, { "type": "wokwi-resistor", "id": "r1", "top": 100.8, "left": -11.15, "rotate": 90, "attrs": { "value": "100" } }, { "type": "wokwi-resistor", "id": "r2", "top": -53.3, "left": 56.55, "rotate": 90, "attrs": { "value": "1000" } }, { "type": "wokwi-resistor", "id": "r3", "top": -52.3, "left": 75.75, "rotate": 90, "attrs": { "value": "1000" } }, { "type": "wokwi-buzzer", "id": "bz1", "top": -170.4, "left": 49.8, "attrs": { "volume": "0.1" } }, { "type": "wokwi-buzzer", "id": "bz2", "top": -170.4, "left": 165, "attrs": { "volume": "0.1" } } ], "connections": [ [ "bz1:1", "nano:GND.2", "black", [ "h48", "v91.2" ] ], [ "r2:1", "bz1:2", "green", [ "h0" ] ], [ "r1:2", "led1:A", "green", [ "h0" ] ], [ "led1:C", "nano:GND.1", "black", [ "h57.2", "v-62.4" ] ], [ "bz1:1", "bz2:1", "black", [ "v0" ] ], [ "r2:2", "nano:4", "green", [ "v8.4", "h10.1" ] ], [ "bz2:2", "r3:1", "green", [ "v0" ] ], [ "r3:2", "nano:3", "green", [ "h0" ] ], [ "r1:1", "nano:13", "green", [ "h0" ] ] ], "dependencies": {} }
Generate a diagram.json code for Automatic light using PIR sensor and arduino-uno
const byte LED_TINO = A1; const byte SENSOR_TINO = A0; boolean pir_Value = 0; void setup() { pinMode(LED_TINO, OUTPUT); pinMode(SENSOR_TINO, INPUT); Serial.begin(9600); Serial.println("Tugas 2: Septiandi Budi Triantino"); delay(3000); } void loop() { pir_Value = digitalRead(SENSOR_TINO); digitalWrite(LED_TINO, pir_Value); Serial.println("Sensor Value:" + (String)pir_Value); if (pir_Value) { digitalWrite(LED_TINO, HIGH); } else { digitalWrite(LED_TINO, LOW); } delay(1000); }
{ "version": 1, "author": "Ajang Rahmat", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": -18.6, "left": -67.8, "attrs": {} }, { "type": "wokwi-pir-motion-sensor", "id": "pir1", "top": 71.2, "left": 232.62, "attrs": {} }, { "type": "wokwi-relay-module", "id": "relay1", "top": 230.6, "left": 201.6, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 73.2, "left": 339.8, "attrs": { "color": "yellow" } }, { "type": "wokwi-vcc", "id": "vcc1", "top": 19.96, "left": 384, "attrs": {} }, { "type": "wokwi-gnd", "id": "gnd1", "top": 307.2, "left": 354.6, "attrs": {} }, { "type": "wokwi-gnd", "id": "gnd2", "top": 307.2, "left": 162.6, "attrs": {} }, { "type": "wokwi-gnd", "id": "gnd3", "top": 240, "left": 37.8, "attrs": {} } ], "connections": [ [ "uno:5V", "pir1:VCC", "red", [ "v38.3", "h224.6" ] ], [ "uno:GND.2", "pir1:GND", "black", [ "v28.7", "h253.5" ] ], [ "uno:A0", "pir1:OUT", "green", [ "v19.1", "h195.8" ] ], [ "relay1:IN", "uno:A1", "yellow", [ "h0" ] ], [ "relay1:VCC", "uno:5V", "red", [ "h0" ] ], [ "vcc1:VCC", "led1:A", "red", [ "v0" ] ], [ "gnd1:GND", "relay1:NO", "black", [ "v0" ] ], [ "relay1:COM", "led1:C", "black", [ "h0" ] ], [ "relay1:GND", "gnd2:GND", "black", [ "h0" ] ], [ "uno:GND.2", "gnd3:GND", "black", [ "v28.7", "h-53.7" ] ] ], "dependencies": {} }
Generate a diagram.json code for Hybrid solar pump control using ESP-32
#include <SPI.h> #include<EEPROM.h> #include "RTClib.h" #include <Wire.h> #include <LiquidCrystal_I2C.h> #include <PID_v1.h> LiquidCrystal_I2C lcd(0x27, 20, 4); #define AVG_NUM 10 #define offsetVoltage 2.5 // for ACS712 sensor #define Sensitivity 0.066 // 66mV/A for ACS712-30A variant #define Sensitivity1 0.04 // 40mV/A for ACS758 -50A variant #define PV_volt_pin 34 // defining the analog pin ADC1_CH6 to read solar panel Voltage #define PV_current_pin 35 //defining the Analog pin ADC1_CH7 to measure solar current #define bat_volt_pin 32 //defining the analog pin ADC1_CH4 to read battery voltage #define bat_current_pin 33 //defining the Analog pin ADC1_CH5 to measure battery current #define inv_volt_pin 25 //defining the Analog pin ADC2_CH8 to measure inverter input volt #define inv_current_pin 26 //defining the Analog pin ADC2_CH9 to measure inverter input current #define load_volt_pin 12 //defining the Analog pin ADC2_CH5 to measure DC load output volt #define load_current_pin 27 //defining the Analog pin ADC2_CH7 to measure DC load output current #define pwm_pin 14 //PWM Pin GPIO14 conncet to MOsfet Driver #define DCload_pin 13 // Defining DC load control pin GPIO 13 to drive MOSFET Q2 #define BULK_CHRARGE_SP 14.4 #define FLOAT_CHARGE_SP 13.5 #define Charge_Restart_SP 13.2 #define MIN_SOLAR_VOLT 10 #define LVD 11.5 #define LVR 12.5 #define ABSORPTION_LIMIT 3600000 // 1 hour in milliseconds #define NIGHT_TIME 3600000 // 1 hour in milliseconds #define CHARGER_RESTART_TIME 600000 // 10 mins in milliseconds #define EVENING_TIME 300000 // 5mins in milliseconds #define MORNING_TIME 180000 // 3mins in milliseconds #define DCLOAD_VOLT_SP 12.3 #define gradDetect 26.3157894373 // Gradient for SoC Detect #define Vb_FULL_SCALE 13.8 //SoC 100% Baterai 13.8 Volt const int PWM_CHANNEL = 0; // ESP32 has 16 channels which can generate 16 independent waveforms const int PWM_FREQ = 980.39; // Recall that Arduino Uno is ~490 Hz. Official ESP32 example uses 5,000Hz const int PWM_RESOLUTION = 8; // We'll use same resolution as Uno (8 bits, 0-255) but ESP32 can go up to 16 bits // The max duty cycle value based on PWM resolution (will be 255 if resolution is 8 bits) const int MAX_DUTY_CYCLE = (int)(pow(2, PWM_RESOLUTION) - 1); const int DELAY_MS = 4; // delay between fade increments float PV_volt=0; // solar panel voltage float PV_current=0; // solar panel current float bat_volt=0; // Battery voltage float bat_current=0; //Battery current (Charge pr Discharge) float inv_volt=0; // Inverter voltage input float inv_current=0; // Inverter current input float load_volt=0; // DC Load current float load_current=0; // DC Load current float PV_watts=0; //PV Watt float PV_wattHours=0; //PV Watt Hours-Calculate float load_watts=0; //DC Load watt float pwm_duty=0; // PWM Duty Cycle (0 to 255) float pwm_dutyDC=0; // PWM Duty Cycle (0 to 255) float bulk_charge_sp=0; // Bulk charging set point float float_charge_sp=0; // Float charging set point int load_status; // 0-off, 1- on const int bat_type = 1; //Flooded=0,AGM=1 int celsius=36; int temp_change=0; float temp_val=0; int disp,dcloadstate; unsigned long last_time=0; unsigned long current_time=0; unsigned long absorption_time; // to keep track of today's time in absorption state unsigned long charger_millis; // to keep track of time for charger unsigned long restart_time; unsigned long load_millis; int mode =1; float SoC_Detect = 0; float temp_SoC_Detect =0; float SoCCorr_k_1 =0; float SoC_VB=0; int SOC_VB_Temp =0; float bat_volt_k_1 =0; float persen1; int persen; //***************************PID Controller*********************************** double Sp, input_val, u; PID myPID(&input_val, &u, &Sp,2,5,1, DIRECT); //Kp= 2 , Ki= 5 and Kd=1 enum charger_state {off, bulk,absorption,Float} charger_state ; ///////////////////////DECLARATION OF ALL BIT MAP ARRAY FOR FONTS//////////////////////////////////////////////////////////////// //-------------------------------------------------------------------------------------------------------------------------- byte solar[8] = //icon for solar panel { 0b11111,0b10101,0b11111,0b10101,0b11111,0b10101,0b11111,0b00000 }; byte battery[8] = //icon for battery { 0b01110,0b11011,0b10001,0b10001,0b10001,0b10001,0b10001,0b11111 }; byte charge[8] = // icon for battery charge { 0b01010,0b11111,0b10001,0b10001,0b10001,0b01110,0b00100,0b00100, }; byte not_charge[8]= { 0b00000,0b10001,0b01010,0b00100,0b01010,0b10001,0b00000,0b00000, }; byte temp[8] = //icon for termometer { 0b00100,0b01010,0b01010,0b01110,0b01110,0b11111,0b11111,0b01110 }; byte energy[8] = // icon for power { 0b00010,0b00100,0b01000,0b11111,0b00010,0b00100,0b01000,0b00000 }; byte PWM[8] = { B11101, B10101, B10101, B10101, B10101, B10101, B10101, B10111 }; //**************SoC Detect************************************************* float SOC_Detect() { SoC_Detect = (gradDetect*(bat_volt - 10.0)); return SoC_Detect; } void SoC_Estimator(float SOCCOOR_K_1, float BAT_VOLT_K_1, float BAT_VOLT,float *SOC_VB) { *SOC_VB = SOCCOOR_K_1 + ((BAT_VOLT - BAT_VOLT_K_1)/(Vb_FULL_SCALE - BAT_VOLT_K_1 )*(100 - SOCCOOR_K_1)); } void INIT(int DCloadstate) { //**********************Raw 0 (SOLAR INDICATOR)*********************** lcd.setCursor(0, 0); //(Kolom, Baris) lcd.print("SOL"); lcd.createChar(0, solar); lcd.setCursor(4, 0); //(Kolom, Baris) lcd.write(0); lcd.setCursor(0, 1); //(Kolom, Baris) lcd.print(PV_volt,1); lcd.setCursor(4, 1); //(Kolom, Baris) lcd.print('V'); lcd.setCursor(0, 2); //(Kolom, Baris) lcd.print(PV_current,1); lcd.setCursor(4, 2); //(Kolom, Baris) lcd.print('A'); lcd.setCursor(0, 3); //(Kolom, Baris) lcd.print(PV_watts); lcd.setCursor(4, 3); //(Kolom, Baris) lcd.print('W'); //*******************Raw 1 (BATTERAI INDICATOR)******************************************** lcd.setCursor(7, 0); //(Kolom, Baris) lcd.print("BAT"); lcd.createChar(1, battery); lcd.setCursor(11, 0); //(Kolom, Baris) lcd.write(1); lcd.setCursor(7, 1); //(Kolom, Baris) lcd.print(bat_volt,1); lcd.setCursor(11, 1); //(Kolom, Baris) lcd.print('V'); lcd.setCursor(7, 2); //(Kolom, Baris) lcd.print(bat_current,1); lcd.setCursor(11, 2); //(Kolom, Baris) lcd.print('A'); lcd.createChar(2, charge); lcd.setCursor(7, 3); //(Kolom, Baris) lcd.write(2); if(disp == 0) { lcd.createChar(3, not_charge); //menampilkan ke Display kondisi sedang tidak melakukan charging lcd.setCursor(8, 3); //(Kolom, Baris) lcd.write(3); } else if(disp == 1) { lcd.setCursor(8, 3); //(Kolom, Baris) lcd.print('B'); //menampilkan ke Display kondisi charging mode Bulk Charging } else if(disp == 2) { lcd.setCursor(8, 3); //(Kolom, Baris) lcd.print('A'); //menampilkan ke Display kondisi charging mode Float Charging } else if(disp == 3) { lcd.setCursor(8, 3); //(Kolom, Baris) lcd.print('F'); //menampilkan ke Display kondisi charging mode absorption Charging } if(SOC_VB_Temp == 0) { lcd.setCursor(9, 3); //(Kolom, Baris) lcd.print(' '); } else { lcd.setCursor(9, 3); //(Kolom, Baris) lcd.print(SOC_VB_Temp); } lcd.setCursor(11, 3); //(Kolom, Baris) lcd.print("%"); //*******************Raw 12 (PWM INDICATOR)******************************************** lcd.setCursor(14, 0); //(Kolom, Baris) lcd.print("PWM"); lcd.createChar(6, PWM); lcd.setCursor(18, 0); //(Kolom, Baris) lcd.write(6); lcd.setCursor(15, 1); //(Kolom, Baris) lcd.print(persen); // satuan pwm_duty dalam persen lcd.print("% "); lcd.setCursor(13, 2); //(Kolom, Baris) lcd.print("LOAD DC"); // satuan pwm_duty dalam persen if(DCloadstate == 0) { lcd.setCursor(15, 3); //(Kolom, Baris) lcd.print("OFF"); // satuan pwm_duty dalam persen } else if(DCloadstate == 1) { lcd.setCursor(15, 3); //(Kolom, Baris) lcd.print("ON "); // satuan pwm_duty dalam persen } } int read_adc(int channel){ int sum = 0; int temp; int i; for (i=0; i<AVG_NUM; i++) { // loop through reading raw adc values AVG_NUM number of times temp = analogRead(channel); // read the input pin sum += temp; // store sum for averaging delayMicroseconds(50); // pauses for 50 microseconds } return(sum / AVG_NUM); // divide sum by AVG_NUM to get average and return it } void Initial_setpoint() { PV_volt= read_adc(PV_volt_pin)*0.0048828*(37.5/7.5); PV_current = ((read_adc(PV_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); PV_watts = PV_current * PV_volt; bat_volt= read_adc(bat_volt_pin)*0.0048828*(37.5/7.5); bat_current = ((read_adc(bat_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); inv_volt= read_adc(inv_volt_pin)*0.0048828*(37.5/7.5); inv_current = ((read_adc(inv_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity1 ); load_volt= read_adc(load_volt_pin)*0.0048828*(37.5/7.5); load_current = ((read_adc(load_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); load_watts = load_current * load_volt; if (PV_current <0 || PV_watts < 0) { PV_current = 0; PV_watts = 0; } if (bat_current <0) { bat_current = 0; } if (load_current <0 || load_watts < 0) { load_current = 0; load_watts = 0; } temp_change =celsius-25.0; // 25deg cel is taken as standard room temperature ( STC) // for floaded battery if (bat_type == 0) { bulk_charge_sp =BULK_CHRARGE_SP-(0.020*temp_change) ; float_charge_sp=FLOAT_CHARGE_SP-(0.020*temp_change) ; } // for AGM battery // set point is lowered to avoid excess gassing else { bulk_charge_sp =(BULK_CHRARGE_SP-0.2)-(0.020*temp_change) ; float_charge_sp=(FLOAT_CHARGE_SP-0.2)-(0.020*temp_change) ; } } void Run_charge() { PV_volt= read_adc(PV_volt_pin)*0.0048828*(37.5/7.5); PV_current = ((read_adc(PV_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); PV_watts = PV_current * PV_volt; bat_volt= read_adc(bat_volt_pin)*0.0048828*(37.5/7.5); bat_current = ((read_adc(bat_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); inv_volt= read_adc(inv_volt_pin)*0.0048828*(37.5/7.5); inv_current = ((read_adc(inv_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity1 ); load_volt= read_adc(load_volt_pin)*0.0048828*(37.5/7.5); load_current = ((read_adc(load_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); load_watts = load_current * load_volt; if (PV_current <0 || PV_watts < 0) { PV_current = 0; PV_watts = 0; } if (bat_current <0) { bat_current = 0; } if (load_current <0 || load_watts < 0) { load_current = 0; load_watts = 0; } temp_SoC_Detect = SOC_Detect(); if(temp_SoC_Detect < 0) { temp_SoC_Detect = 0; } current_time = millis(); if(current_time - last_time >= 1000) { bat_volt_k_1 = bat_volt; SoCCorr_k_1 = temp_SoC_Detect; last_time = current_time; } SoC_Estimator(SoCCorr_k_1,bat_volt_k_1,bat_volt,&SoC_VB); SOC_VB_Temp = (int) SoC_VB; if(SOC_VB_Temp > 99) { SOC_VB_Temp = 99; } if(SOC_VB_Temp < 0) { SOC_VB_Temp = 0; } temp_change =celsius-25.0; // 25deg cel is taken as standard room temperature ( STC) // for floaded battery if (bat_type == 0) { bulk_charge_sp =BULK_CHRARGE_SP-(0.020*temp_change) ; float_charge_sp=FLOAT_CHARGE_SP-(0.020*temp_change) ; } // for AGM battery // set point is lowered to avoid excess gassing else { bulk_charge_sp =(BULK_CHRARGE_SP-0.2)-(0.020*temp_change) ; float_charge_sp=(FLOAT_CHARGE_SP-0.2)-(0.020*temp_change) ; } switch (charger_state) { case off : if (( bat_volt < float_charge_sp) && (PV_volt > (bat_volt + 0.5) )){ charger_millis = millis() ; charger_state = bulk ; } else if ( ( bat_volt > float_charge_sp) && (PV_volt > (bat_volt + 0.5)) && (absorption_time > ABSORPTION_LIMIT)){ charger_millis = millis() ; restart_time = 0 ; charger_state = Float ; } else { disp=0; absorption_time = 0; pwm_duty = 0; persen1=(pwm_duty/255)*100; persen = (int) persen1; analogWrite(pwm_pin, pwm_duty); } break; // end of case off condition // During this stage the MOSFET is fully on by setting the duty cycle to 100% // Constant Current Charging case bulk : if (PV_volt < bat_volt ){ charger_millis = millis(); charger_state = off; disp=0; } else if ((bat_volt > bulk_charge_sp) && (PV_volt > (bat_volt + 0.5)) && (absorption_time < ABSORPTION_LIMIT)){ charger_millis = millis(); charger_state = absorption; disp=2; } else if ((bat_volt > float_charge_sp) && (PV_volt > (bat_volt + 0.5)) && (absorption_time > ABSORPTION_LIMIT)){ charger_millis = millis(); restart_time = 0; charger_state = Float; disp=3; } else{ disp=1; pwm_duty = 255; persen1=(pwm_duty/255)*100; persen = (int) persen1; //ledcWrite(pwm_pin, pwm_duty); //generate PWM from GPIO 14 @ 100% duty // MOSFET Q1 is ON analogWrite(pwm_pin, pwm_duty); if( bat_volt > bulk_charge_sp ) { charger_state = absorption; disp=2; } } break; // end of case bulk condition // During this stage the MOSFET is partially on by setting the duty cycle to between 0% and 100% // Constant voltage case absorption : if (PV_volt < bat_volt){ charger_millis = millis(); charger_state = off; disp=0; } else if ((bat_volt > float_charge_sp) && (PV_volt > (bat_volt + 0.5)) && (absorption_time > ABSORPTION_LIMIT)){ charger_millis = millis(); charger_state = Float; disp=3; } else{ // increment absorption timer and test for duration in absorption state absorption_time = absorption_time + millis() - charger_millis ; charger_millis = millis(); disp=2; input_val = bat_volt; Sp = bulk_charge_sp; myPID.Compute(); // Compute PID Output pwm_duty = u*5 ; // Output = kp * error + ki * errSum + kd * dErr if(pwm_duty < 0) { pwm_duty=0; } if(pwm_duty >255) { pwm_duty=255; } persen1=(pwm_duty/255)*100; persen = (int) persen1; //ledcWrite(pwm_pin, pwm_duty); analogWrite(pwm_pin, pwm_duty); } break; // end of case absorption condition // During this stage the MOSFET is partially on by setting the duty cycle between 0% and 100% // Constant Voltage Charging case Float : if (PV_volt < bat_volt){ charger_millis = millis(); charger_state = off; disp=0; } else if ((bat_volt < Charge_Restart_SP) && (PV_volt > (bat_volt + 0.5) ) && (restart_time > CHARGER_RESTART_TIME)){ charger_millis = millis(); charger_state = bulk; disp=1; } else if ((bat_volt >float_charge_sp) && (PV_volt > (bat_volt + 0.5) ) && ( absorption_time < ABSORPTION_LIMIT)){ charger_millis = millis(); charger_state = absorption; disp=2; } else { disp=3; if (bat_volt > float_charge_sp) { pwm_duty--; if(pwm_duty <0) { pwm_duty=0; } persen1=(pwm_duty/255)*100; persen = (int) persen1; analogWrite(pwm_pin, pwm_duty); } else { pwm_duty = 12.75; // setting duty cycle = 5% for trickle charge persen1=(pwm_duty/255)*100; persen = (int) persen1; analogWrite(pwm_pin, pwm_duty); //generate PWM from D3 @ 5% duty // Q1 is driving @ 5% duty cycle } if (bat_volt < Charge_Restart_SP) { restart_time = restart_time + millis() - charger_millis ; charger_millis = millis(); } } break; // end of case float condition } } void DCLoad_Control() { PV_volt= read_adc(PV_volt_pin)*0.0048828*(37.5/7.5); PV_current = ((read_adc(PV_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); PV_watts = PV_current * PV_volt; bat_volt= read_adc(bat_volt_pin)*0.0048828*(37.5/7.5); load_volt= read_adc(load_volt_pin)*0.0048828*(37.5/7.5); load_current = ((read_adc(load_current_pin)*0.0048828 - offsetVoltage)/ Sensitivity ); load_watts = load_current * load_volt; if (PV_current <0 || PV_watts < 0) { PV_current = 0; PV_watts = 0; } if (bat_current <0) { bat_current = 0; } if (load_current <0 || load_watts < 0) { load_current = 0; load_watts = 0; } if ((PV_volt < 8.0) && (bat_volt > LVD)) { //DC Load Control Voltage for Constant Voltage in 12V if(load_volt > DCLOAD_VOLT_SP) { pwm_dutyDC--; pwm_dutyDC = constrain(pwm_dutyDC,0,254); } else { pwm_dutyDC++; pwm_dutyDC = constrain(pwm_dutyDC,0,254); } analogWrite(DCload_pin, pwm_dutyDC); //load will turn on during evening dcloadstate =1; } else if ((PV_volt < 8.0) && (bat_volt < LVD)) { pwm_dutyDC = 0; analogWrite(DCload_pin, pwm_dutyDC); // load will turn off during morning dcloadstate =0; } else if (PV_volt > MIN_SOLAR_VOLT) { pwm_dutyDC = 0; analogWrite(DCload_pin, pwm_dutyDC); // load will turn off during morning dcloadstate =0; } else if((bat_volt < LVD) || (load_watts > 60)) { pwm_dutyDC = 0; analogWrite(DCload_pin, pwm_dutyDC); // load will turn off during morning dcloadstate =0; } } void setup() { // put your setup code here, to run once: Serial.begin(115200); Serial.println("Hello, ESP32!"); analogReadResolution(10); pinMode(pwm_pin, OUTPUT); pinMode(DCload_pin, OUTPUT); // Sets up a channel (0-15), a PWM duty cycle frequency, and a PWM resolution (1 - 16 bits) // ledcSetup(uint8_t channel, double freq, uint8_t resolution_bits); // ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION); // // ledcAttachPin(uint8_t pin, uint8_t channel); // ledcAttachPin(pwm_pin, PWM_CHANNEL); lcd.init(); lcd.backlight(); lcd.setCursor(0,0); lcd.print("*******************"); lcd.setCursor(0,1); lcd.print(" SOLAR PUMP "); lcd.setCursor(0,2); lcd.print(" CONTROLLER V00 "); lcd.setCursor(0,3); lcd.print("*******************"); delay(1000); lcd.clear(); input_val = 12; Sp= 14.5; //turn the PID on myPID.SetMode(AUTOMATIC); Initial_setpoint(); INIT(dcloadstate); } void loop() { // put your main code here, to run repeatedly: delay(10); // this speeds up the simulation Run_charge(); INIT(dcloadstate); DCLoad_Control(); Serial.print(pwm_duty); Serial.print("; "); Serial.print(disp); Serial.print("; "); Serial.print(persen1); Serial.print("; "); Serial.print(load_volt); Serial.print("; "); Serial.print(pwm_dutyDC); Serial.print("\n"); }
{ "version": 1, "author": "Ilmirrizki Imaduddin", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 76.8, "left": -23.96, "attrs": {} }, { "type": "wokwi-lcd2004", "id": "lcd1", "top": -118.4, "left": -61.6, "attrs": { "pins": "i2c" } }, { "type": "wokwi-potentiometer", "id": "pot1", "top": -58.9, "left": -384.2, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot2", "top": 37.1, "left": -384.2, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot3", "top": 142.7, "left": -384.2, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot4", "top": 248.3, "left": -384.2, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot5", "top": 411.5, "left": -384.2, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot6", "top": 507.5, "left": -384.2, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot7", "top": 603.5, "left": -384.2, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot8", "top": 709.1, "left": -384.2, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 188.4, "left": 138.2, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": 283.2, "left": 133.85, "rotate": 90, "attrs": { "value": "330" } }, { "type": "wokwi-led", "id": "led2", "top": 399.6, "left": 23, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r2", "top": 475.2, "left": 18.65, "rotate": 90, "attrs": { "value": "330" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "lcd1:SCL", "esp:22", "green", [ "h-48", "v125.1", "h211.2", "v57.6" ] ], [ "esp:21", "lcd1:SDA", "green", [ "h57.6", "v-76.8", "h-220.8", "v-144", "h9.6" ] ], [ "lcd1:GND", "esp:GND.1", "black", [ "h-67.2", "v28.8" ] ], [ "lcd1:VCC", "esp:5V", "red", [ "h-86.4", "v48.1" ] ], [ "pot1:GND", "pot2:GND", "black", [ "v0", "h-38.4", "v115.2", "h38.4" ] ], [ "pot2:GND", "pot3:GND", "black", [ "v28.8", "h-48", "v96", "h48" ] ], [ "pot3:GND", "pot4:GND", "black", [ "v19.2", "h-48", "v105.6", "h48" ] ], [ "pot4:GND", "pot5:GND", "black", [ "v19.2", "h-48", "v163.2", "h48" ] ], [ "pot5:GND", "pot6:GND", "black", [ "v19.2", "h-48", "v96", "h48" ] ], [ "pot6:GND", "pot7:GND", "black", [ "v19.2", "h-48", "v96", "h48" ] ], [ "pot1:VCC", "pot2:VCC", "red", [ "v19.2", "h37.6", "v96", "h-38.4" ] ], [ "pot2:VCC", "pot3:VCC", "red", [ "v19.2", "h37.6", "v105.6", "h-38.4" ] ], [ "pot3:VCC", "pot4:VCC", "red", [ "v19.2", "h37.6", "v105.6", "h-38.4", "v-19.2" ] ], [ "pot4:VCC", "pot5:VCC", "red", [ "v19.2", "h37.6", "v163.2", "h-38.4" ] ], [ "pot5:VCC", "pot6:VCC", "red", [ "v19.2", "h37.6", "v96", "h-38.4" ] ], [ "pot6:VCC", "pot7:VCC", "red", [ "v19.2", "h37.6", "v96", "h-38.4" ] ], [ "pot1:SIG", "esp:34", "green", [ "v28.8", "h182", "v96" ] ], [ "pot2:SIG", "esp:35", "green", [ "v28.8", "h86", "v9.6" ] ], [ "pot3:SIG", "esp:32", "green", [ "v28.8", "h182", "v-76.8" ] ], [ "pot4:SIG", "esp:33", "green", [ "v38.4", "h182", "v-182.4" ] ], [ "pot5:SIG", "esp:25", "green", [ "v28.8", "h182", "v-307.2" ] ], [ "pot6:SIG", "esp:26", "green", [ "v19.2", "h182", "v-297.6" ] ], [ "pot7:GND", "pot8:GND", "black", [ "v19.2", "h-48", "v115.2", "h48", "v-9.6" ] ], [ "pot7:VCC", "pot8:VCC", "red", [ "v19.2", "h37.6", "v115.2", "h-38.4" ] ], [ "esp:GND.3", "led1:C", "black", [ "h67.2", "v86.4", "h9.6" ] ], [ "led1:A", "r1:1", "green", [ "v0" ] ], [ "r1:2", "esp:13", "green", [ "h-211.2", "v-78" ] ], [ "led2:C", "esp:GND.1", "green", [ "v0", "h-114.8", "v-211.2" ] ], [ "led2:A", "r2:1", "green", [ "v0" ] ], [ "r2:2", "esp:14", "green", [ "h-105.6", "v-298.8" ] ], [ "pot7:SIG", "esp:12", "green", [ "v38.4", "h210.8", "v-489.6", "h48" ] ], [ "pot8:SIG", "esp:27", "green", [ "v38.4", "h249.2", "v-28.8" ] ] ], "dependencies": {} }
Generate a diagram.json code for servo control using ESP-32
#include <ESP32MCPWM.h> ESP32MCPWM motorController; void setup() { Serial.begin(115200); // Attach servo to GPIO pin 5 motorController.attachServo(5); // Set initial angle to 0 degrees motorController.setServoAngle(0); delay(2000); // Rotate servo to 90 degrees motorController.setServoAngle(90); delay(2000); // Rotate servo to 180 degrees motorController.setServoAngle(180); delay(2000); // Return servo to 0 degrees motorController.setServoAngle(0); } void loop() { // Add your loop logic here }
{ "version": 1, "author": "Asep Oman Somantri", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-servo", "id": "servo1", "top": 46, "left": 182.4, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "servo1:GND", "esp:GND.1", "black", [ "h-28.8", "v124.8", "h-182.4", "v-76.8", "h9.6" ] ], [ "esp:5V", "servo1:V+", "red", [ "h-23.81", "v38.4", "h0", "v0", "h182.4", "v-124.8" ] ], [ "esp:5", "servo1:PWM", "green", [ "h0" ] ] ], "dependencies": {} }
Generate a diagram.json code for Gas Leak and Fire Outbreak Monitoring System
#include <Wire.h> #include <LiquidCrystal_I2C.h> #include <WiFi.h> #include "Adafruit_MQTT.h" #include "Adafruit_MQTT_Client.h" #define WIFI_SSID "Wokwi-GUEST" #define WIFI_PASSWORD "" #define AIO_SERVER "io.adafruit.com" #define AIO_SERVERPORT 1883 #define AIO_USERNAME "AbhinavAce" #define AIO_KEY "aio_cXhx00DLUv05w7NRa4eeeJ3bXCT2" WiFiClient client; Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY); Adafruit_MQTT_Publish sector1_status = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/sensor data"); LiquidCrystal_I2C lcd(0x27, 16, 2); int gas=34; int heat=32; int led=2; #define gas_leak 500 #define fire_break 700 void connectWiFi() { Serial.print("Connecting to WiFi..."); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println("Connected!"); } void connectMQTT() { while (!mqtt.connected()) { Serial.print("Connecting to MQTT..."); if (mqtt.connect()) { Serial.println("Connected!"); } else { delay(2000); } } } void setup() { Serial.begin(115200); lcd.init(); lcd.backlight(); lcd.setCursor(0, 0); lcd.print("Initializing..."); // Initialize WiFi and MQTT connectWiFi(); connectMQTT(); lcd.setCursor(0, 1); lcd.print("System Ready"); delay(2000); lcd.clear(); pinMode(gas,INPUT); pinMode(heat,INPUT); pinMode(led,OUTPUT); } void loop() { if (!mqtt.connected()) { connectMQTT();} mqtt.processPackets(10000); mqtt.ping(); int gas1=analogRead(gas); int heat1=analogRead(heat); bool gasLeak1=gas1>gas_leak; bool fire1=heat1<fire_break; if (gasLeak1 && fire1){ digitalWrite(led, HIGH); lcd.setCursor(0, 0); lcd.print("Danger in Sec 1"); sector1_status.publish("Gas + Fire"); } else if (gasLeak1){ digitalWrite(led, HIGH); lcd.setCursor(0, 0); lcd.print("Gas Leak Sec 1"); sector1_status.publish("Gas Leak"); } else if (fire1){ lcd.setCursor(0, 0); lcd.print("Fire in Sec 1"); sector1_status.publish("Fire"); } else{ lcd.setCursor(0, 0); lcd.print("Sec 1: Stable"); sector1_status.publish("Stable"); } delay(1000); }
{ "version": 1, "author": "Abhinavendra A R", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 96, "left": 33.64, "attrs": {} }, { "type": "wokwi-lcd1602", "id": "lcd1", "top": -128, "left": 178.4, "attrs": { "pins": "i2c" } }, { "type": "wokwi-ntc-temperature-sensor", "id": "ntc1", "top": -103, "left": -173.4, "attrs": {} }, { "type": "chip-gas-sensor", "id": "chip1", "top": -162.18, "left": 4.8, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -224.4, "left": -111.4, "attrs": { "color": "red" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "lcd1:SDA", "esp:21", "green", [ "h-38.4", "v249.8" ] ], [ "lcd1:SCL", "esp:22", "green", [ "h-19.2", "v9.9" ] ], [ "esp:GND.2", "lcd1:GND", "black", [ "v0" ] ], [ "esp:3V3", "lcd1:VCC", "red", [ "h0.15", "v-211.2" ] ], [ "esp:3V3", "ntc1:VCC", "red", [ "h-38.25", "v-192" ] ], [ "ntc1:GND", "esp:GND.2", "black", [ "h0" ] ], [ "ntc1:OUT", "esp:32", "yellow", [ "h9.6", "v230.3" ] ], [ "chip1:VCC", "esp:3V3", "red", [ "h-28.8", "v249.6" ] ], [ "chip1:GND", "esp:GND.2", "black", [ "h-19.2", "v230.4", "h144" ] ], [ "chip1:A0", "esp:34", "yellow", [ "h-19.2", "v278.4" ] ], [ "led1:C", "chip1:GND", "black", [ "v0" ] ], [ "led1:A", "esp:2", "green", [ "v76.8", "h105.6", "v76.8", "h163.2", "v182.4" ] ] ], "dependencies": {} }
Generate a diagram.json code for Dot matrix display clock with temperature info
#include <MD_Parola.h> #include <MD_MAX72xx.h> #include <DHT.h> #include <SPI.h> #include <Wire.h> #include "Font7Seg.h" // Define the number of devices we have in the chain and the hardware interface // NOTE: These pin numbers will probably not work with your hardware and may // need to be adapted #define HARDWARE_TYPE MD_MAX72XX::PAROLA_HW #define MAX_DEVICES 4 // Define the number of displays connected #define CLK_PIN 13 // CLK or SCK #define DATA_PIN 11 // DATA or MOSI #define CS_PIN 10 // CS or SS #define SPEED_TIME 75 // Speed of the transition #define PAUSE_TIME 0 #define MAX_MESG 20 // These are for the clock #define DS1307_ADDRESS 0x68 // These are for the temperature #define DHTPIN 2 #define DHTTYPE DHT22 #define TIMEDHT 1000 // Global variables uint8_t wday, mday, month, year; uint8_t hours, minutes, seconds; char szTime[9]; // mm:ss\0 char szMesg[MAX_MESG + 1] = ""; float humidity, celsius, fahrenheit; uint8_t degC[] = { 6, 3, 3, 56, 68, 68, 68 }; // Deg C uint8_t degF[] = { 6, 3, 3, 124, 20, 20, 4 }; // Deg F uint8_t clear = 0x00; uint32_t timerDHT = TIMEDHT; DHT dht(DHTPIN, DHTTYPE); // Hardware SPI connection MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES); void beginDS1307() { // Read the values ​​(date and time) of the DS1307 module Wire.beginTransmission(DS1307_ADDRESS); Wire.write(clear); Wire.endTransmission(); Wire.requestFrom(DS1307_ADDRESS, 0x07); seconds = bcdToDec(Wire.read()); minutes = bcdToDec(Wire.read()); hours = bcdToDec(Wire.read() & 0xff); wday = bcdToDec(Wire.read()); mday = bcdToDec(Wire.read()); month = bcdToDec(Wire.read()); year = bcdToDec(Wire.read()); } uint8_t decToBcd(uint8_t value) { return ((value / 10 * 16) + (value % 10)); } uint8_t bcdToDec(uint8_t value) { return ((value / 16 * 10) + (value % 16)); } // Code for reading clock time void getTime(char *psz, bool f = true) { sprintf(psz, "%02d%c%02d", hours, (f ? ':' : ' '), minutes); } // Code for reading clock date void getDate(char *psz) { char szBuf[10]; sprintf(psz, "%d %s %04d", mday , mon2str(month, szBuf, sizeof(szBuf) - 1), (year + 2000)); } // Code for get Temperature void getTemperature() { // Wait for a time between measurements if ((millis() - timerDHT) > TIMEDHT) { // Update the timer timerDHT = millis(); // Reading temperature or humidity takes about 250 milliseconds! // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor) humidity = dht.readHumidity(); // Read temperature as Celsius (the default) celsius = dht.readTemperature(); // Read temperature as Fahrenheit (isFahrenheit = true) fahrenheit = dht.readTemperature(true); // Check if any reads failed and exit early (to try again) if (isnan(humidity) || isnan(celsius) || isnan(fahrenheit)) { Serial.println("Failed to read from DHT sensor!"); return; } } } // Get a label from PROGMEM into a char array char *mon2str(uint8_t mon, char *psz, uint8_t len) { static const __FlashStringHelper* str[] = { F("Jan"), F("Feb"), F("Mar"), F("Apr"), F("May"), F("Jun"), F("Jul"), F("Aug"), F("Sep"), F("Oct"), F("Nov"), F("Dec") }; strncpy_P(psz, (const char PROGMEM *)str[mon - 1], len); psz[len] = '\0'; return (psz); } char *dow2str(uint8_t code, char *psz, uint8_t len) { static const __FlashStringHelper* str[] = { F("Sunday"), F("Monday"), F("Tuesday"), F("Wednesday"), F("Thursday"), F("Friday"), F("Saturday") }; strncpy_P(psz, (const char PROGMEM *)str[code - 1], len); psz[len] = '\0'; return (psz); } void setup(void) { Wire.begin(); P.begin(2); P.setInvert(false); P.setZone(0, MAX_DEVICES - 4, MAX_DEVICES - 1); P.setZone(1, MAX_DEVICES - 4, MAX_DEVICES - 1); P.displayZoneText(1, szTime, PA_CENTER, SPEED_TIME, PAUSE_TIME, PA_PRINT, PA_NO_EFFECT); P.displayZoneText(0, szMesg, PA_CENTER, SPEED_TIME, 0, PA_PRINT , PA_NO_EFFECT); P.addChar('$', degC); P.addChar('&', degF); dht.begin(); } void loop(void) { static uint32_t lastTime = 0; // Memory (ms) static uint8_t display = 0; // Current display mode static bool flasher = false; // Seconds passing flasher beginDS1307(); getTemperature(); P.displayAnimate(); if (P.getZoneStatus(0)) { switch (display) { case 0: // Temperature deg Celsius P.setPause(0, 1000); P.setTextEffect(0, PA_SCROLL_LEFT, PA_SCROLL_UP); display++; dtostrf(celsius, 3, 1, szMesg); strcat(szMesg, "$"); break; case 1: // Temperature deg Fahrenheit P.setTextEffect(0, PA_SCROLL_UP, PA_SCROLL_DOWN); display++; dtostrf(fahrenheit, 3, 1, szMesg); strcat(szMesg, "&"); break; case 2: // Humidity P.setTextEffect(0, PA_SCROLL_DOWN, PA_SCROLL_LEFT); display++; dtostrf(humidity, 3, 0, szMesg); strcat(szMesg, "%UR"); break; case 3: // Clock P.setFont(0, numeric7Seg); P.setTextEffect(0, PA_PRINT, PA_NO_EFFECT); P.setPause(0, 0); if ((millis() - lastTime) >= 1000) { lastTime = millis(); getTime(szMesg, flasher); flasher = !flasher; } if ((seconds == 00) && (seconds <= 30)) { display++; P.setTextEffect(0, PA_PRINT, PA_WIPE_CURSOR); } break; case 4: // Day of week P.setFont(0, nullptr); P.setTextEffect(0, PA_SCROLL_LEFT, PA_SCROLL_LEFT); display++; dow2str(wday, szMesg, MAX_MESG); break; default: // Calendar P.setTextEffect(0, PA_SCROLL_LEFT, PA_SCROLL_LEFT); display = 0; getDate(szMesg); break; } P.displayReset(0); // Rest zone zero } }
{ "version": 1, "author": "Uri Shaked, Anderson Costa", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 120, "left": 80, "attrs": {} }, { "type": "wokwi-max7219-matrix", "id": "m1", "top": 20, "left": 115, "attrs": { "chain": "4" } }, { "type": "wokwi-ds1307", "id": "ds1307", "top": 254.03, "left": 380, "attrs": {} }, { "type": "wokwi-dht22", "id": "dht", "top": 122.35, "left": 398.34, "attrs": { "color": "red" } } ], "connections": [ [ "uno:GND.1", "m1:GND", "black", [ "v-12", "*", "h30" ] ], [ "uno:10", "m1:CS", "green", [ "v-24", "*", "h22" ] ], [ "uno:11", "m1:DIN", "orange", [ "v-20", "*", "h26" ] ], [ "uno:13", "m1:CLK", "blue", [ "v-16", "*", "h18" ] ], [ "uno:GND.3", "ds1307:GND", "black", [ "v20", "*", "h-30" ] ], [ "uno:5V", "ds1307:5V", "red", [ "v35", "*", "h-15" ] ], [ "uno:A4", "ds1307:SDA", "orange", [ "v30", "*", "h-20" ] ], [ "uno:A5", "ds1307:SCL", "purple", [ "v25", "*", "h-25" ] ], [ "uno:2", "dht:SDA", "yellow", [ "v0", "h0", "*", "h-50", "v5" ] ], [ "uno:5V", "m1:V+", "red", [ "v35.21", "h247.23", "v-310.74" ] ], [ "uno:5V", "dht:VCC", "red", [ "v35.11", "h247.22", "v-95.82", "h-80.12" ] ], [ "uno:GND.3", "dht:GND", "black", [ "v20.24", "h101.02", "v-85", "h89.21" ] ] ] }
Generate a diagram.json code for NLSF595 Arduino Shift Register
const int dataPin = 2; /* SI */ const int clockPin = 3; /* SCK */ const int latchPin = 4; /* RCK */ void setup() { pinMode(dataPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(latchPin, OUTPUT); } void sendData(uint8_t pattern) { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, pattern); digitalWrite(latchPin, HIGH); } void loop() { // Red sendData(0b11011011); delay(500); // Green sendData(0b10110111); delay(500); // Purple sendData(0b01001011); delay(500); }
{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 183.33, "left": -51.33, "attrs": {} }, { "type": "wokwi-nlsf595", "id": "sr1", "top": 102.5, "left": 182.16, "rotate": 90, "attrs": {} }, { "type": "wokwi-rgb-led", "id": "rgb1", "top": -20, "left": 3.34, "attrs": {} }, { "type": "wokwi-rgb-led", "id": "rgb2", "top": -20, "left": 101.33, "attrs": {} }, { "type": "wokwi-resistor", "id": "r1", "top": 75.34, "left": -18.67, "rotate": 90, "attrs": {} }, { "type": "wokwi-resistor", "id": "r2", "top": 75.34, "left": 0, "rotate": 90, "attrs": {} }, { "type": "wokwi-resistor", "id": "r3", "top": 75.33, "left": 17.34, "rotate": 90, "attrs": {} }, { "type": "wokwi-resistor", "id": "r4", "top": 70, "left": 79.34, "rotate": 90, "attrs": {} }, { "type": "wokwi-resistor", "id": "r5", "top": 69.33, "left": 98, "rotate": 90, "attrs": {} }, { "type": "wokwi-resistor", "id": "r6", "top": 68.66, "left": 114.67, "rotate": 90, "attrs": {} } ], "connections": [ [ "sr1:GND", "uno:GND.1", "black", [ "h0" ] ], [ "sr1:VCC", "uno:5V", "red", [ "h30", "v323", "h-156" ] ], [ "sr1:SI", "uno:2", "blue", [ "h16", "v70", "h-68" ] ], [ "uno:GND.1", "sr1:OE", "black", [ "v-22", "h184", "v-52" ] ], [ "sr1:RCK", "uno:4", "gray", [ "h4", "v38", "h-66" ] ], [ "r3:1", "rgb1:B", "blue", [ "h0" ] ], [ "r2:1", "rgb1:G", "green", [ "h0" ] ], [ "rgb1:R", "r1:1", "brown", [ "v0" ] ], [ "rgb2:R", "r4:1", "brown", [ "v0" ] ], [ "rgb2:G", "r5:1", "green", [ "v0" ] ], [ "rgb2:B", "r6:1", "blue", [ "v0" ] ], [ "sr1:QA", "r6:2", "blue", [ "h10.86", "v-27.16", "h-88.61", "v44.05" ] ], [ "sr1:QC", "r4:2", "brown", [ "h-36.66", "v25.24", "h-57.6" ] ], [ "sr1:QB", "r5:2", "green", [ "h-41.46", "v30.04", "h-33.6" ] ], [ "sr1:QD", "r3:2", "blue", [ "h-31.86", "v20.44", "h-124.8" ] ], [ "sr1:QE", "r2:2", "green", [ "h-22.26", "v15.64", "h-148.8" ] ], [ "sr1:QF", "r1:2", "brown", [ "h-17.46", "v10.84", "h-172.8" ] ], [ "rgb2:COM", "rgb1:COM", "red", [ "v9", "h-97.75" ] ], [ "uno:5V", "rgb1:COM", "red", [ "v19.59", "h-164.65", "v-351", "h77.65" ] ], [ "sr1:SCK", "uno:3", "purple", [ "h8.28", "v33", "h-67.15" ] ] ] }
Generate a diagram.json code for LED with switch using arduino-uno
//int buttonPin = 2; // Button connected to pin 2 int ledPin = 13; // LED connected to pin 13 //int buttonState = 0; void setup() { pinMode(2, INPUT_PULLUP); // Set the button pin as input. pinMode(ledPin, OUTPUT); // Set the LED pin as output. } void loop() { digitalRead(2); // Read the button state. if (digitalRead(2) == LOW) { // If the button is pressed digitalWrite(ledPin, HIGH); // Turn on the LED. } else { digitalWrite(ledPin, LOW); // Turn off the LED. } }
{ "version": 1, "author": "Yuvaraj s", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-pushbutton-6mm", "id": "btn1", "top": -69.4, "left": 240, "attrs": { "color": "green" } }, { "type": "wokwi-resistor", "id": "r1", "top": -63.25, "left": 144, "attrs": { "value": "1000" } }, { "type": "wokwi-led", "id": "led1", "top": -99.6, "left": 90.2, "attrs": { "color": "red" } } ], "connections": [ [ "led1:A", "r1:1", "green", [ "v0" ] ], [ "r1:2", "uno:13", "green", [ "v38.4", "h-78" ] ], [ "btn1:2.l", "uno:2", "green", [ "h0" ] ], [ "led1:C", "uno:GND.1", "green", [ "v48", "h10" ] ], [ "btn1:1.r", "uno:GND.1", "green", [ "v-48", "h-181.6", "v96" ] ] ], "dependencies": {} }
Generate a diagram.json code for multi-colour LED
void setup() { pinMode(4, OUTPUT);//กำหนดขา 4 เป็น OUTPUT pinMode(5, OUTPUT);//กำหนดขา 5 เป็น OUTPUT pinMode(6, OUTPUT);//กำหนดขา 6 เป็น OUTPUT pinMode(7, OUTPUT);//กำหนดขา 7 เป็น OUTPUT pinMode(8, OUTPUT);//กำหนดขา 8 เป็น OUTPUT pinMode(9, OUTPUT);//กำหนดขา 9 เป็น OUTPUT pinMode(10, OUTPUT);//กำหนดขา 10 เป็น OUTPUT pinMode(11, OUTPUT);//กำหนดขา 11 เป็น OUTPUT pinMode(12, OUTPUT);//กำหนดขา 12 เป็น OUTPUT pinMode(13, OUTPUT);//กำหนดขา 13 เป็น OUTPUT } void loop() { digitalWrite(13, HIGH); digitalWrite(13, LOW); digitalWrite(4, HIGH); digitalWrite(4, LOW); delay(300); digitalWrite(12, HIGH); digitalWrite(12, LOW); digitalWrite(5, HIGH); digitalWrite(5, LOW); delay(300); digitalWrite(11, HIGH); digitalWrite(11, LOW); digitalWrite(6, HIGH); digitalWrite(6, LOW); delay(300); digitalWrite(10, HIGH); digitalWrite(10, LOW); digitalWrite(7, HIGH); digitalWrite(7, LOW); delay(300); digitalWrite(9, HIGH); digitalWrite(9, LOW); digitalWrite(8, HIGH); digitalWrite(8, LOW); delay(300); digitalWrite(9, HIGH); digitalWrite(9, LOW); digitalWrite(8, HIGH); digitalWrite(8, LOW); digitalWrite(10, HIGH); digitalWrite(10, LOW); digitalWrite(7, HIGH); digitalWrite(7, LOW); delay(300); digitalWrite(11, HIGH); digitalWrite(11, LOW); digitalWrite(6, HIGH); digitalWrite(6, LOW); delay(300); digitalWrite(12, HIGH); digitalWrite(12, LOW); digitalWrite(5, HIGH); digitalWrite(5, LOW); delay(300); digitalWrite(13, HIGH); digitalWrite(13, LOW); digitalWrite(4, HIGH); digitalWrite(4, LOW); delay(300); }
{ "version": 1, "author": "ศุภชัย ยามี", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 183, "left": -0.6, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -42, "left": -140.2, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -42, "left": -53.8, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led3", "top": -42, "left": 71, "attrs": { "color": "yellow" } }, { "type": "wokwi-led", "id": "led4", "top": -42, "left": 13.4, "attrs": { "color": "blue" } }, { "type": "wokwi-led", "id": "led5", "top": -51.6, "left": 119, "attrs": { "color": "orange" } }, { "type": "wokwi-led", "id": "led6", "top": -42, "left": 224.6, "attrs": { "color": "purple" } }, { "type": "wokwi-led", "id": "led7", "top": -42, "left": 349.4, "attrs": { "color": "limegreen" } }, { "type": "wokwi-led", "id": "led8", "top": -42, "left": 176.6, "attrs": { "color": "white" } }, { "type": "wokwi-led", "id": "led9", "top": -42, "left": 282.2, "attrs": { "color": "magenta" } }, { "type": "wokwi-led", "id": "led10", "top": -42, "left": 397.4, "attrs": { "color": "cyan" } }, { "type": "wokwi-resistor", "id": "r1", "top": 61, "left": -144.85, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r2", "top": 80.2, "left": 373.55, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r3", "top": 70.6, "left": 335.15, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r4", "top": 51.4, "left": 277.55, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r5", "top": 51.4, "left": 210.35, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r6", "top": 41.8, "left": 171.95, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r7", "top": 51.4, "left": 114.35, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r8", "top": 61, "left": 66.35, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r9", "top": 61, "left": 18.35, "rotate": 270, "attrs": { "value": "220000" } }, { "type": "wokwi-resistor", "id": "r10", "top": 70.6, "left": -58.45, "rotate": 270, "attrs": { "value": "220000" } } ], "connections": [ [ "led2:C", "uno:GND.1", "green", [ "v28.8", "h115.6" ] ], [ "led4:C", "uno:GND.1", "green", [ "v19.2", "h86.8" ] ], [ "led3:C", "uno:GND.1", "green", [ "v48", "h58" ] ], [ "led5:C", "uno:GND.1", "green", [ "v153.6", "h-19.1" ] ], [ "led8:C", "uno:GND.1", "green", [ "v153.6", "h-57.5" ] ], [ "led6:C", "uno:GND.1", "green", [ "v28.8", "h-28.4" ] ], [ "led9:C", "uno:GND.1", "green", [ "v38.4", "h-57.2" ] ], [ "led7:C", "uno:GND.1", "green", [ "v28.8", "h-86" ] ], [ "led10:C", "uno:GND.1", "green", [ "v48", "h-105.2" ] ], [ "led1:A", "r1:2", "green", [ "v0" ] ], [ "led2:A", "r10:2", "green", [ "v0" ] ], [ "led4:A", "r9:2", "green", [ "v0" ] ], [ "led3:A", "r8:2", "green", [ "v0" ] ], [ "led5:A", "r7:2", "green", [ "v0" ] ], [ "led8:A", "r6:2", "green", [ "v0" ] ], [ "led6:A", "r5:2", "green", [ "v0" ] ], [ "led9:A", "r4:2", "green", [ "v0" ] ], [ "led7:A", "r3:2", "green", [ "v0" ] ], [ "led10:A", "r2:2", "green", [ "v0" ] ], [ "led1:C", "uno:GND.1", "green", [ "v19.2", "h-18.8", "v134.4", "h144" ] ], [ "r1:1", "uno:13", "green", [ "h0", "v28.8", "h134.4" ] ], [ "r10:1", "uno:12", "green", [ "h0", "v38.4", "h105.6" ] ], [ "r9:1", "uno:11", "green", [ "h0", "v28.8", "h86.4" ] ], [ "r8:1", "uno:10", "green", [ "h0", "v38.4", "h67.2" ] ], [ "r7:1", "uno:9", "green", [ "h0", "v38.4", "h48" ] ], [ "r6:1", "uno:8", "green", [ "h9.6", "v38.4", "h19.2" ] ], [ "r5:1", "uno:7", "green", [ "h0" ] ], [ "r4:1", "uno:6", "green", [ "h0" ] ], [ "r3:1", "uno:5", "green", [ "h0" ] ], [ "r2:1", "uno:4", "green", [ "h0" ] ] ], "dependencies": {} }
Generate a diagram.json code for four road junction traffic light using arduino-uno
int red1 = 13; int yellow1 = 12; int green1 = 11; int red2 = 10; int yellow2 = 9; int green2 = 8; int red3 =5; int yellow3 =6; int green3 = 7; int red4 =2; int yellow4=3; int green4=4 ; void setup() { // put your setup code here, to run once: //1 pinMode(red1, OUTPUT); pinMode(yellow1, OUTPUT); pinMode(green1, OUTPUT); //2 pinMode(red2, OUTPUT); pinMode(yellow2, OUTPUT); pinMode(green2, OUTPUT); //3 pinMode(red3, OUTPUT); pinMode(yellow3, OUTPUT); pinMode(green3, OUTPUT); //4 pinMode(red4, OUTPUT); pinMode(yellow4, OUTPUT); pinMode(green4, OUTPUT); } void loop() { // put your main code here, to run repeatedly: digitalWrite(green1, HIGH); digitalWrite(yellow1,LOW); digitalWrite(red1,LOW); delay(5000); digitalWrite(green1, LOW); digitalWrite(yellow1, HIGH); digitalWrite(red1,LOW); delay(2000); digitalWrite(green1, LOW); digitalWrite(yellow1, LOW); digitalWrite(red1,HIGH); delay(3000); //2 digitalWrite(green2, HIGH); digitalWrite(yellow2,LOW); digitalWrite(red2,LOW); delay(5000); digitalWrite(green2, LOW); digitalWrite(yellow2, HIGH); digitalWrite(red2,LOW); delay(2000); digitalWrite(green2, LOW); digitalWrite(yellow2, LOW); digitalWrite(red2,HIGH); delay(3000); //3 digitalWrite(green3, HIGH); digitalWrite(yellow3,LOW); digitalWrite(red3,LOW); delay(5000); digitalWrite(green3, LOW); digitalWrite(yellow3, HIGH); digitalWrite(red3,LOW); delay(2000); digitalWrite(green3, LOW); digitalWrite(yellow3, LOW); digitalWrite(red3,HIGH); delay(3000); //4 digitalWrite(green4, HIGH); digitalWrite(yellow4,LOW); digitalWrite(red4,LOW); delay(5000); digitalWrite(green3, LOW); digitalWrite(yellow4, HIGH); digitalWrite(red4,LOW); delay(2000); digitalWrite(green4, LOW); digitalWrite(yellow4, LOW); digitalWrite(red4,HIGH); delay(3000); }
{ "version": 1, "author": "Doungkmon Namyhong", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-mini", "id": "bb1", "top": 104.2, "left": -472.8, "attrs": {} }, { "type": "wokwi-breadboard-mini", "id": "bb2", "top": 469, "left": 36, "attrs": {} }, { "type": "wokwi-breadboard-mini", "id": "bb3", "top": 104.2, "left": 439.2, "attrs": {} }, { "type": "wokwi-breadboard-mini", "id": "bb4", "top": -203, "left": -12, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "uno", "top": 87, "left": -77.4, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": 82.8, "left": 493.4, "attrs": { "color": "yellow" } }, { "type": "wokwi-led", "id": "led2", "top": 447.6, "left": 99.8, "attrs": { "color": "yellow" } }, { "type": "wokwi-led", "id": "led3", "top": 447.6, "left": 128.6, "attrs": { "color": "limegreen" } }, { "type": "wokwi-led", "id": "led4", "top": 82.8, "left": -447.4, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led5", "top": 82.8, "left": -418.6, "attrs": { "color": "yellow" } }, { "type": "wokwi-led", "id": "led6", "top": 82.8, "left": -389.8, "attrs": { "color": "limegreen" } }, { "type": "wokwi-led", "id": "led7", "top": -224.4, "left": 23, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led8", "top": 447.6, "left": 71, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led9", "top": -224.4, "left": 51.8, "attrs": { "color": "yellow" } }, { "type": "wokwi-led", "id": "led10", "top": -224.4, "left": 80.6, "attrs": { "color": "limegreen" } }, { "type": "wokwi-led", "id": "led11", "top": 82.8, "left": 531.8, "attrs": { "color": "limegreen" } }, { "type": "wokwi-led", "id": "led12", "top": 82.8, "left": 455, "attrs": { "color": "red" } }, { "type": "wokwi-resistor", "id": "r1", "top": 148.8, "left": -451.75, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r2", "top": 148.8, "left": -422.95, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r3", "top": 148.8, "left": -394.15, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r4", "top": 513.6, "left": 124.25, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r5", "top": 513.6, "left": 66.65, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r6", "top": 513.6, "left": 95.45, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r7", "top": 148.8, "left": 450.65, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r8", "top": 148.8, "left": 489.05, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r9", "top": 148.8, "left": 527.45, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r10", "top": -158.4, "left": 76.25, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r11", "top": -158.4, "left": 47.45, "rotate": 90, "attrs": { "value": "220" } }, { "type": "wokwi-resistor", "id": "r12", "top": -158.4, "left": 18.65, "rotate": 90, "attrs": { "value": "220" } } ], "connections": [ [ "uno:13", "r7:2", "red", [ "v-86.4", "h-66.8" ] ], [ "uno:12", "r8:2", "gold", [ "v-96", "h-37.9" ] ], [ "uno:11", "r9:2", "green", [ "v-96", "h-9" ] ], [ "uno:10", "r5:2", "red", [ "v-48", "h192.7", "v192", "h134.4" ] ], [ "uno:9", "r6:2", "gold", [ "v-28.8", "h173.6", "v192", "h182.4" ] ], [ "uno:8", "r4:2", "green", [ "v-19.2", "h144.4", "v192", "h230.4" ] ], [ "uno:5", "r1:2", "red", [ "v278.4", "h90.2", "v220.8", "h-192" ] ], [ "uno:6", "bb1:8b.g", "gold", [ "v288", "h90.1", "v201.6", "h-163.2" ] ], [ "bb1:8b.g", "r2:2", "gold", [ "v0" ] ], [ "uno:7", "r3:2", "green", [ "v297.6", "h90", "v172.8", "h-124.8" ] ], [ "uno:2", "r12:2", "red", [ "v-19.2", "h-351.1", "v182.4", "h-172.8" ] ], [ "uno:3", "r11:2", "gold", [ "v-38.4", "h-360.8", "v192", "h-124.8" ] ], [ "uno:4", "r10:2", "green", [ "v-57.6", "h-370.5", "v201.6", "h-76.8" ] ], [ "uno:GND.1", "led12:C", "black", [ "v-76.8", "h-66.9" ] ], [ "uno:GND.1", "led1:C", "black", [ "v-76.8", "h-28.5" ] ], [ "uno:GND.1", "led11:C", "black", [ "v-76.8", "h19.5" ] ], [ "uno:GND.1", "led8:C", "black", [ "v-67.2", "h240.3", "v201.6", "h115.2" ] ], [ "uno:GND.1", "led2:C", "black", [ "v-67.2", "h240.3", "v201.6", "h144" ] ], [ "uno:GND.1", "led3:C", "black", [ "v-67.2", "h240.3", "v201.6", "h172.8" ] ], [ "uno:GND.1", "led4:C", "black", [ "v278.4", "h-18.9" ] ], [ "uno:GND.1", "led5:C", "black", [ "v259.2", "h-441.7" ] ], [ "uno:GND.1", "led6:C", "black", [ "v288", "h38.7" ] ], [ "uno:GND.1", "led7:C", "black", [ "v-57.6", "h-412.5" ] ], [ "uno:GND.1", "led9:C", "black", [ "v-57.6", "h-383.7" ] ], [ "uno:GND.1", "led10:C", "black", [ "v-57.6", "h-345.3" ] ], [ "led1:A", "bb3:8t.b", "", [ "$bb" ] ], [ "led1:C", "bb3:7t.b", "", [ "$bb" ] ], [ "led11:A", "bb3:12t.b", "", [ "$bb" ] ], [ "led11:C", "bb3:11t.b", "", [ "$bb" ] ], [ "led12:A", "bb3:4t.b", "", [ "$bb" ] ], [ "led12:C", "bb3:3t.b", "", [ "$bb" ] ], [ "r7:1", "bb3:4t.b", "", [ "$bb" ] ], [ "r7:2", "bb3:4b.f", "", [ "$bb" ] ], [ "r8:1", "bb3:8t.b", "", [ "$bb" ] ], [ "r8:2", "bb3:8b.f", "", [ "$bb" ] ], [ "r9:1", "bb3:12t.b", "", [ "$bb" ] ], [ "r9:2", "bb3:12b.f", "", [ "$bb" ] ], [ "led2:A", "bb2:9t.b", "", [ "$bb" ] ], [ "led2:C", "bb2:8t.b", "", [ "$bb" ] ], [ "led3:A", "bb2:12t.b", "", [ "$bb" ] ], [ "led3:C", "bb2:11t.b", "", [ "$bb" ] ], [ "led8:A", "bb2:6t.b", "", [ "$bb" ] ], [ "led8:C", "bb2:5t.b", "", [ "$bb" ] ], [ "r4:1", "bb2:12t.b", "", [ "$bb" ] ], [ "r4:2", "bb2:12b.f", "", [ "$bb" ] ], [ "r5:1", "bb2:6t.b", "", [ "$bb" ] ], [ "r5:2", "bb2:6b.f", "", [ "$bb" ] ], [ "r6:1", "bb2:9t.b", "", [ "$bb" ] ], [ "r6:2", "bb2:9b.f", "", [ "$bb" ] ], [ "led7:A", "bb4:6t.b", "", [ "$bb" ] ], [ "led7:C", "bb4:5t.b", "", [ "$bb" ] ], [ "led9:A", "bb4:9t.b", "", [ "$bb" ] ], [ "led9:C", "bb4:8t.b", "", [ "$bb" ] ], [ "led10:A", "bb4:12t.b", "", [ "$bb" ] ], [ "led10:C", "bb4:11t.b", "", [ "$bb" ] ], [ "r10:1", "bb4:12t.b", "", [ "$bb" ] ], [ "r10:2", "bb4:12b.f", "", [ "$bb" ] ], [ "r11:1", "bb4:9t.b", "", [ "$bb" ] ], [ "r11:2", "bb4:9b.f", "", [ "$bb" ] ], [ "r12:1", "bb4:6t.b", "", [ "$bb" ] ], [ "r12:2", "bb4:6b.f", "", [ "$bb" ] ], [ "led4:A", "bb1:5t.b", "", [ "$bb" ] ], [ "led4:C", "bb1:4t.b", "", [ "$bb" ] ], [ "led5:A", "bb1:8t.b", "", [ "$bb" ] ], [ "led5:C", "bb1:7t.b", "", [ "$bb" ] ], [ "led6:A", "bb1:11t.b", "", [ "$bb" ] ], [ "led6:C", "bb1:10t.b", "", [ "$bb" ] ], [ "r1:1", "bb1:5t.b", "", [ "$bb" ] ], [ "r1:2", "bb1:5b.f", "", [ "$bb" ] ], [ "r2:1", "bb1:8t.b", "", [ "$bb" ] ], [ "r2:2", "bb1:8b.f", "", [ "$bb" ] ], [ "r3:1", "bb1:11t.b", "", [ "$bb" ] ], [ "r3:2", "bb1:11b.f", "", [ "$bb" ] ] ], "dependencies": {} }
Generate a diagram.json code for motion detection alarm using PIR sensor,esp-32,buzzer
#include <Arduino.h> const int pirPin = 14; // PIR Motion Sensor connected to GPIO 14 const int buzzerPin = 13; // Buzzer connected to GPIO 13 void setup() { pinMode(pirPin, INPUT); pinMode(buzzerPin, OUTPUT); Serial.begin(115200); } void loop() { int pirState = digitalRead(pirPin); if (pirState == HIGH) { Serial.println("Motion Detected!"); tone(buzzerPin, 1000, 500); // Sound the buzzer for 500 milliseconds } else { noTone(buzzerPin); } delay(1000); // Delay for 1 second to avoid false triggers }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-mini", "id": "bb1", "top": 94.6, "left": 122.4, "attrs": {} }, { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 9.6, "left": -23.96, "attrs": {} }, { "type": "wokwi-buzzer", "id": "bz1", "top": -45.6, "left": 117, "attrs": { "volume": "0.1" } }, { "type": "wokwi-pir-motion-sensor", "id": "pir1", "top": -15.2, "left": -180.18, "attrs": {} } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "bz1:2", "esp:13", "green", [ "v0" ] ], [ "bz1:1", "bb1:1t.d", "black", [ "v0" ] ], [ "pir1:VCC", "esp:3V3", "red", [ "v0" ] ], [ "pir1:GND", "bb1:1t.c", "black", [ "v0" ] ], [ "pir1:OUT", "esp:14", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for water level indicator using arduino-uno
const int sensorPin = A0; const int ledPins[] = {2, 3, 4, 5, 6}; const int numLeds = 5; void setup() { for (int i = 0; i < numLeds; i++) { pinMode(ledPins[i], OUTPUT); } Serial.begin(9600); } void loop() { int sensorValue = analogRead(sensorPin); int ledValue = map(sensorValue, 0, 1023, 0, numLeds); for (int i = 0; i < numLeds; i++) { digitalWrite(ledPins[i], i < ledValue ? HIGH : LOW); } Serial.println(sensorValue); delay(1000); }
{ "version": 1, "author": "Anonymous maker", "editor": "wokwi", "parts": [ { "type": "wokwi-breadboard-half", "id": "bb1", "top": -41.4, "left": -64.4, "attrs": {} }, { "type": "wokwi-arduino-uno", "id": "uno", "top": 125.4, "left": -48.6, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -51.6, "left": 61.4, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": -51.6, "left": 90.2, "attrs": { "color": "orange" } }, { "type": "wokwi-led", "id": "led3", "top": -51.6, "left": 119, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led4", "top": -51.6, "left": 176.6, "attrs": { "color": "white" } }, { "type": "wokwi-led", "id": "led5", "top": -51.6, "left": 147.8, "attrs": { "color": "cyan" } }, { "type": "chip-water-level-sensor", "id": "chip1", "top": 356.22, "left": 33.6, "attrs": {} } ], "connections": [ [ "led4:A", "uno:2", "green", [ "v67.2", "h-13.7" ] ], [ "led5:A", "uno:3", "green", [ "h9.6", "v144" ] ], [ "led3:A", "uno:4", "green", [ "v76.8", "h24.9" ] ], [ "led2:A", "uno:5", "green", [ "v86.4", "h9.6" ] ], [ "led1:A", "uno:6", "green", [ "v96", "h9.6" ] ], [ "led1:C", "bb1:4t.a", "black", [ "v0" ] ], [ "led2:C", "bb1:4t.b", "black", [ "v0" ] ], [ "led3:C", "bb1:4t.c", "black", [ "v0" ] ], [ "led5:C", "bb1:4t.d", "black", [ "v0" ] ], [ "led4:C", "bb1:4t.e", "black", [ "v0" ] ], [ "bb1:4t.e", "uno:GND.1", "black", [ "v0" ] ], [ "chip1:VCC", "uno:5V", "red", [ "h0" ] ], [ "chip1:GND", "uno:GND.2", "black", [ "h0" ] ], [ "chip1:OUT", "uno:A0", "green", [ "v0" ] ] ], "dependencies": {} } { "name": "water-level-sensor", "author": "", "pins": [ "VCC", "GND", "OUT" ], "controls": [] }
Generate a diagram.json code for Flame Detection System using IR Sensor, Buzzer, Arduino Nano
const int flameSensorPin = 2; const int buzzerPin = 3; void setup() { pinMode(flameSensorPin, INPUT); pinMode(buzzerPin, OUTPUT); Serial.begin(9600); } void loop() { int flameValue = digitalRead(flameSensorPin); if (flameValue == HIGH) { Serial.println("Flame detected!"); tone(buzzerPin, 1000, 500); // Sound the buzzer for 500 milliseconds } else { Serial.println("No flame detected."); } delay(1000); // Check every second }
{ "version": 1, "author": "Vigneshwaran", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": -4.8, "left": -0.5, "attrs": {} }, { "type": "wokwi-ir-receiver", "id": "ir1", "top": -106.95, "left": 27.02, "attrs": {} }, { "type": "wokwi-buzzer", "id": "bz1", "top": 50.4, "left": 136.2, "attrs": { "volume": "0.1" } } ], "connections": [ [ "ir1:VCC", "nano:5V", "red", [ "v0" ] ], [ "ir1:GND", "nano:GND.1", "black", [ "v96", "h96" ] ], [ "ir1:DAT", "nano:2", "green", [ "h57.6", "v24" ] ], [ "bz1:1", "nano:GND.2", "black", [ "h-28.8", "v-153.6" ] ], [ "bz1:2", "nano:3", "yellow", [ "v19.2", "h-58", "v-153.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for Sound reactive LED ring
#include <Adafruit_NeoPixel.h> #define PIN 6 // Pin connected to the Data In of the NeoPixel ring #define NUMPIXELS 16 // Number of LEDs in the ring #define SOUND_SENSOR A0 // Analog pin connected to the sound sensor Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); void setup() { pixels.begin(); // Initialize the NeoPixel library Serial.begin(9600); } void loop() { int soundLevel = analogRead(SOUND_SENSOR); // Read the sound level from the sensor int brightness = map(soundLevel, 0, 1023, 0, 255); // Map the sound level to a brightness value // Set the brightness for each LED in the ring for (int i = 0; i < NUMPIXELS; i++) { pixels.setPixelColor(i, pixels.Color(0, 0, brightness)); // Blue color, adjust RGB values as needed } pixels.show(); // Update the LEDs to show the new colors Serial.println(soundLevel); // Print the sound level to the Serial Monitor delay(50); // Small delay to avoid rapid changes }
{ "version": 1, "author": "Vigneshwaran", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-nano", "id": "nano", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-small-sound-sensor", "id": "", "top": -107, "left": 48, "attrs": { "color": "red" } }, { "type": "wokwi-led-ring", "id": "ring1", "top": 77.44, "left": 20.39, "attrs": { "pixels": "16" } } ], "connections": [ [ ":DOUT", "nano:5V", "red", [ "v28.1", "h67.2", "v100.8" ] ], [ ":GND", "nano:GND.2", "black", [ "h0" ] ], [ ":AOUT", "nano:A0", "green", [ "h-9.6", "v76.8", "h10.1" ] ], [ "ring1:GND", "nano:GND.1", "black", [ "v0" ] ], [ "ring1:VCC", "nano:5V", "red", [ "v0" ] ], [ "ring1:DIN", "nano:6", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for Keypad Door Lock using arduino-uno,servo and membrane-keypad
include <Keypad.h> #include <Servo.h> const byte ROWS = 4; // Four rows const byte COLS = 4; // Four columns char keys[ROWS][COLS] = { {'1', '2', '3', 'A'}, {'4', '5', '6', 'B'}, {'7', '8', '9', 'C'}, {'*', '0', '#', 'D'} }; byte rowPins[ROWS] = {2, 3, 4, 5}; // Connect to the row pinouts of the keypad byte colPins[COLS] = {6, 7, 8, 9}; // Connect to the column pinouts of the keypad Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS); Servo myServo; const String password = "1234"; String inputPassword; void setup() { Serial.begin(9600); myServo.attach(10); // Servo connected to pin D10 myServo.write(0); // Lock position Serial.println("Enter Password:"); } void loop() { char key = keypad.getKey(); if (key) { Serial.print(key); if (key == '#') { if (inputPassword == password) { Serial.println("\nAccess Granted"); myServo.write(90); // Unlock position delay(5000); // Keep the door unlocked for 5 seconds myServo.write(0); // Lock position } else { Serial.println("\nAccess Denied"); } inputPassword = ""; // Clear the input password } else { inputPassword += key; // Append the key to the input password } } }
{ "version": 1, "author": "", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-uno", "id": "uno", "top": 115.8, "left": -10.2, "attrs": {} }, { "type": "wokwi-membrane-keypad", "id": "keypad1", "top": -309.2, "left": 34.4, "attrs": {} }, { "type": "wokwi-servo", "id": "servo1", "top": 26.8, "left": -201.6, "attrs": {} } ], "connections": [ [ "keypad1:R1", "uno:2", "green", [ "v57.6", "h96" ] ], [ "keypad1:R2", "uno:3", "green", [ "v67.2", "h76.4" ] ], [ "keypad1:R3", "uno:4", "green", [ "v76.8", "h57.3" ] ], [ "keypad1:R4", "uno:5", "green", [ "v86.4", "h28.6" ] ], [ "keypad1:C1", "uno:6", "green", [ "v0" ] ], [ "keypad1:C2", "uno:7", "green", [ "v0" ] ], [ "keypad1:C3", "uno:8", "green", [ "v0" ] ], [ "keypad1:C4", "uno:9", "green", [ "v0" ] ], [ "servo1:GND", "uno:GND.2", "black", [ "h-67.2", "v230.5" ] ], [ "servo1:V+", "uno:5V", "red", [ "h-48", "v57.5", "h399.4" ] ], [ "servo1:PWM", "uno:10", "orange", [ "h-19.2", "v67.4", "h345.6" ] ] ], "dependencies": {} }
Generate a diagram.json code for Temperature data logger using dht-22,arduino-mega,micro-sd-card
#include <SPI.h> #include <SD.h> #include <dht.h> // DHT22 Pin #define DHTPIN 2 dht DHT; // SD Card Module CS Pin #define SD_CS_PIN 53 void setup() { Serial.begin(9600); DHT.begin(); if (!SD.begin(SD_CS_PIN)) { Serial.println("SD Card initialization failed!"); return; } Serial.println("SD Card initialized successfully!"); } void loop() { delay(2000); // Read every 2 seconds float humidity = DHT.readHumidity(); float temperature = DHT.readTemperature(); if (isnan(humidity) || isnan(temperature)) { Serial.println("Failed to read from DHT sensor!"); return; } String dataString = String(humidity) + "," + String(temperature); File dataFile = SD.open("datalog.txt", FILE_WRITE); if (dataFile) { dataFile.println(dataString); dataFile.close(); Serial.println("Data logged to SD card!"); } else { Serial.println("Error opening datalog.txt"); } }
{ "version": 1, "author": "", "editor": "wokwi", "parts": [ { "type": "wokwi-arduino-mega", "id": "mega", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-dht22", "id": "dht1", "top": -143.7, "left": 186.6, "attrs": {} }, { "type": "wokwi-microsd-card", "id": "sd1", "top": -114.97, "left": 9.67, "attrs": {} } ], "connections": [ [ "dht1:VCC", "mega:5V", "red", [ "v163.2", "h-38.4" ] ], [ "dht1:GND", "mega:GND.2", "black", [ "v182.4", "h-57.6" ] ], [ "dht1:SDA", "mega:2", "green", [ "v0" ] ], [ "sd1:VCC", "mega:5V", "red", [ "h0" ] ], [ "sd1:GND", "mega:GND.3", "black", [ "h0" ] ], [ "sd1:DO", "mega:50", "green", [ "h0" ] ], [ "sd1:DI", "mega:51", "green", [ "h0" ] ], [ "sd1:CS", "mega:53", "green", [ "h307.2", "v211.26" ] ], [ "sd1:CD", "mega:GND.3", "green", [ "h57.6", "v326.4", "h38.4" ] ], [ "sd1:SCK", "mega:52", "green", [ "h259.2", "v239.99" ] ] ], "dependencies": {} }
Generate a diagram.json code for Remote controlled RGB LED
#include <IRremote.h> const int IR_PIN = 14; const int RED_PIN = 2; const int GREEN_PIN = 3; const int BLUE_PIN = 4; IRrecv irrecv(IR_PIN); decode_results results; void setup() { irrecv.enableIRIn(); // Start the receiver pinMode(RED_PIN, OUTPUT); pinMode(GREEN_PIN, OUTPUT); pinMode(BLUE_PIN, OUTPUT); } void loop() { if (irrecv.decode(&results)) { switch (results.value) { case 0xFF30CF: digitalWrite(RED_PIN, HIGH); digitalWrite(GREEN_PIN, LOW); digitalWrite(BLUE_PIN, LOW); break; case 0xFF18E7: digitalWrite(RED_PIN, LOW); digitalWrite(GREEN_PIN, HIGH); digitalWrite(BLUE_PIN, LOW); break; case 0xFF7A85: digitalWrite(RED_PIN, LOW); digitalWrite(GREEN_PIN, LOW); digitalWrite(BLUE_PIN, HIGH); break; default: digitalWrite(RED_PIN, LOW); digitalWrite(GREEN_PIN, LOW); digitalWrite(BLUE_PIN, LOW); break; } irrecv.resume(); // Receive the next value } }
{ "version": 1, "author": "", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": -19.2, "left": 120.04, "attrs": {} }, { "type": "wokwi-ir-receiver", "id": "ir1", "top": -68.55, "left": -1.78, "attrs": {} }, { "type": "wokwi-ir-remote", "id": "remote1", "top": 105.6, "left": -192, "attrs": {} }, { "type": "wokwi-rgb-led", "id": "rgb1", "top": -120.8, "left": 106.7, "attrs": { "common": "cathode" } }, { "type": "wokwi-resistor", "id": "r1", "top": 81.6, "left": 57.05, "rotate": 90, "attrs": { "value": "220" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "r1:1", "rgb1:COM", "black", [ "h0", "v-163.2" ] ], [ "r1:2", "esp:GND.1", "black", [ "h0", "v18" ] ], [ "rgb1:G", "esp:D3", "green", [ "v0" ] ], [ "rgb1:R", "esp:D2", "red", [ "v0" ] ], [ "rgb1:B", "esp:4", "blue", [ "v0" ] ], [ "ir1:VCC", "esp:3V3", "red", [ "v0" ] ], [ "ir1:GND", "esp:GND.1", "black", [ "v0" ] ], [ "ir1:DAT", "esp:14", "green", [ "v0" ] ] ], "dependencies": {} }
Generate a diagram.json code for Tilt sensor alarm usng esp-32
#include <Arduino.h> const int tiltSensorPin = 4; // GPIO pin connected to the tilt switch const int buzzerPin = 13; // GPIO pin connected to the buzzer void setup() { pinMode(tiltSensorPin, INPUT_PULLUP); // Set tilt switch pin as input with pull-up resistor pinMode(buzzerPin, OUTPUT); // Set buzzer pin as output Serial.begin(115200); } void loop() { int sensorValue = digitalRead(tiltSensorPin); if (sensorValue == HIGH) { // Tilt detected, turn on buzzer digitalWrite(buzzerPin, HIGH); Serial.println("Tilt detected! Buzzer ON."); } else { // No tilt, turn off buzzer digitalWrite(buzzerPin, LOW); Serial.println("No tilt detected. Buzzer OFF."); } delay(100); // Short delay to avoid rapid changes }
{ "version": 1, "author": "Ananoymous maker", "editor": "wokwi", "parts": [ { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 0, "left": 0, "attrs": {} }, { "type": "wokwi-buzzer", "id": "bz1", "top": -64.8, "left": -123, "attrs": { "volume": "0.1" } }, { "type": "wokwi-tilt-switch", "id": "btn1", "top": -114, "left": -11.2, "attrs": { "color": "green" } } ], "connections": [ [ "esp:TX", "$serialMonitor:RX", "", [] ], [ "esp:RX", "$serialMonitor:TX", "", [] ], [ "bz1:2", "esp:13", "red", [ "v0" ] ], [ "bz1:1", "esp:GND.1", "black", [ "v134.4", "h96" ] ], [ "btn1:GND", "esp:GND.3", "black", [ "h38.4", "v182.4" ] ], [ "btn1:VCC", "esp:3V3", "red", [ "h19.2", "v76.6", "h-105.6", "v38.4" ] ], [ "btn1:OUT", "esp:4", "green", [ "h48", "v220.5" ] ] ], "dependencies": {} }