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