Component Guides

Wiring

Sketch

// LED Blink — turns an LED on and off every second
const int LED_PIN = 13;

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);  // LED on
  delay(1000);
  digitalWrite(LED_PIN, LOW);   // LED off
  delay(1000);
}

How to test in the playground

1. Drag a Resistor (220 Ω) and an LED onto the canvas.
2. Wire: Arduino Pin 13 → Resistor Pin 1 → Resistor Pin 2 → LED Anode (+).
3. Wire: LED Cathode (−) → Arduino GND.
4. Paste the sketch and click Run — the LED should blink once per second.

Wiring

Sketch

// RGB LED — cycles through red → green → blue → white
const int R = 9, G = 10, B = 11;

void setColor(int r, int g, int b) {
  analogWrite(R, r);
  analogWrite(G, g);
  analogWrite(B, b);
}

void setup() {
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);
}

void loop() {
  setColor(255, 0,   0);   delay(800);  // red
  setColor(0,   255, 0);   delay(800);  // green
  setColor(0,   0,   255); delay(800);  // blue
  setColor(255, 255, 255); delay(800);  // white
  setColor(255, 165, 0);   delay(800);  // orange
}

How to test in the playground

1. Drag an RGB LED onto the canvas.
2. Wire R → Pin 9, G → Pin 10, B → Pin 11 (each via a 100 Ω resistor).
3. Wire COM → GND.
4. Paste the sketch and click Run — the LED should cycle through colours.

Wiring

Sketch

// LED Bar Graph — Knight Rider chaser
const int NUM_LEDS = 10;
const int PINS[NUM_LEDS] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

void setup() {
  for (int i = 0; i < NUM_LEDS; i++) {
    pinMode(PINS[i], OUTPUT);
  }
}

void loop() {
  // Sweep forward
  for (int i = 0; i < NUM_LEDS; i++) {
    digitalWrite(PINS[i], HIGH);
    delay(60);
    digitalWrite(PINS[i], LOW);
  }
  // Sweep backward
  for (int i = NUM_LEDS - 2; i > 0; i--) {
    digitalWrite(PINS[i], HIGH);
    delay(60);
    digitalWrite(PINS[i], LOW);
  }
}

How to test in the playground

1. Drag a LED Bar Graph and 10 resistors (220 Ω) onto the canvas.
2. Wire A1 → Resistor → Pin 2, A2 → Resistor → Pin 3, … A10 → Resistor → Pin 11.
3. Tie all cathodes (C1–C10) to GND.
4. Paste the sketch and click Run — a dot chases back and forth.

Wiring

Sketch

// LED Ring — spinning rainbow chase (FastLED)
#include <FastLED.h>

#define NUM_LEDS  16
#define DATA_PIN  6

CRGB leds[NUM_LEDS];

void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(80);
}

void loop() {
  static uint8_t hue = 0;
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i] = CHSV(hue + (i * 256 / NUM_LEDS), 255, 255);
  }
  FastLED.show();
  hue++;
  delay(20);
}

How to test in the playground

1. Drag an LED Ring onto the canvas.
2. Wire VCC → 5V, GND → GND, DIN → Pin 6.
3. Paste the sketch and click Run — a rainbow pattern spins around the ring.

Wiring

Sketch

// Single NeoPixel — colour cycle
#include <Adafruit_NeoPixel.h>

#define PIN   6
#define NUMPIXELS 1

Adafruit_NeoPixel pixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  pixel.begin();
  pixel.setBrightness(100);
}

void loop() {
  uint32_t colors[] = {
    pixel.Color(255, 0,   0),   // red
    pixel.Color(0,   255, 0),   // green
    pixel.Color(0,   0,   255), // blue
    pixel.Color(255, 255, 0),   // yellow
  };
  for (auto c : colors) {
    pixel.setPixelColor(0, c);
    pixel.show();
    delay(600);
  }
}

How to test in the playground

1. Drag a NeoPixel onto the canvas.
2. Wire VDD → 5V, VSS → GND, DIN → Pin 6.
3. Paste the sketch and click Run — the pixel cycles through colours.

Wiring

Sketch

// NeoPixel Matrix 8×8 — diagonal rainbow wave
#include <Adafruit_NeoPixel.h>

#define DATA_PIN   6
#define ROWS       8
#define COLS       8
#define NUMPIXELS  (ROWS * COLS)

Adafruit_NeoPixel matrix(NUMPIXELS, DATA_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  matrix.begin();
  matrix.setBrightness(60);
}

void loop() {
  static uint16_t offset = 0;
  for (int row = 0; row < ROWS; row++) {
    for (int col = 0; col < COLS; col++) {
      uint16_t hue = offset + (uint16_t)(row + col) * 4096;
      uint32_t color = matrix.gamma32(matrix.ColorHSV(hue, 255, 200));
      matrix.setPixelColor(row * COLS + col, color);
    }
  }
  matrix.show();
  offset += 512;
  delay(30);
}

How to test in the playground

1. Drag a NeoPixel Matrix onto the canvas.
2. Wire VCC → 5V, GND → GND, DIN → Pin 6.
3. Paste the sketch (requires Adafruit NeoPixel library) and click Run.
4. A diagonal rainbow wave should scroll across the 8×8 grid.

Wiring

Sketch

// 7-Segment — counts 0 to 9
// Segment order: A  B  C  D  E  F  G
const int SEG[7] = {2, 3, 4, 5, 6, 7, 8};

// Common-cathode digit patterns (1 = segment ON)
const byte DIGITS[10] = {
  0b0111111, // 0
  0b0000110, // 1
  0b1011011, // 2
  0b1001111, // 3
  0b1100110, // 4
  0b1101101, // 5
  0b1111101, // 6
  0b0000111, // 7
  0b1111111, // 8
  0b1101111, // 9
};

void showDigit(int d) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(SEG[i], (DIGITS[d] >> i) & 1);
  }
}

void setup() {
  for (int p : SEG) pinMode(p, OUTPUT);
}

void loop() {
  for (int d = 0; d <= 9; d++) {
    showDigit(d);
    delay(600);
  }
}

How to test in the playground

1. Drag a 7-Segment display onto the canvas.
2. Wire segments A–G to pins 2–8 (each via a 220 Ω resistor).
3. Wire both COM pins to GND.
4. Paste the sketch and click Run — digits 0–9 count up.

Wiring

Sketch

// LCD 1602 — Hello World + uptime counter
#include <LiquidCrystal.h>

// RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Hello, World!");
}

void loop() {
  lcd.setCursor(0, 1);
  lcd.print("Time: ");
  lcd.print(millis() / 1000);
  lcd.print("s  ");
  delay(500);
}

How to test in the playground

1. Drag an LCD 1602 onto the canvas.
2. Follow the wiring table — tie RW to GND and V0 to GND for max contrast.
3. Paste the sketch and click Run — row 1 shows 'Hello, World!', row 2 counts seconds.

Wiring

Sketch

// LCD 2004 — fills all four rows
#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  lcd.begin(20, 4);
  lcd.setCursor(0, 0); lcd.print("Row 0: Hello!");
  lcd.setCursor(0, 1); lcd.print("Row 1: Arduino");
  lcd.setCursor(0, 2); lcd.print("Row 2: LCD 2004");
  lcd.setCursor(0, 3); lcd.print("Row 3: 20 x 4");
}

void loop() {}

How to test in the playground

1. Drag an LCD 2004 onto the canvas.
2. Wire it identically to the LCD 1602 (same 16-pin pinout).
3. Change lcd.begin() to (20, 4) — the library handles the rest.
4. Paste the sketch and click Run — all four rows should display text.

Wiring

Sketch

// ILI9341 TFT — draws coloured shapes
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include <SPI.h>

#define TFT_CS  10
#define TFT_RST  9
#define TFT_DC   8

Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);

void setup() {
  tft.begin();
  tft.setRotation(1);          // landscape
  tft.fillScreen(ILI9341_BLACK);
  tft.fillRect(10, 10, 100, 60, ILI9341_RED);
  tft.fillCircle(200, 100, 40, ILI9341_CYAN);
  tft.setTextColor(ILI9341_WHITE);
  tft.setTextSize(2);
  tft.setCursor(20, 90);
  tft.print("ILI9341!");
}

void loop() {}

How to test in the playground

1. Drag an ILI9341 TFT onto the canvas.
2. Wire SPI pins (MOSI→11, SCK→13, MISO→12) plus CS→10, RST→9, D/C→8.
3. Power from 3.3V (not 5V — the display is not 5V tolerant).
4. Paste the sketch and click Run — a red rectangle, cyan circle, and text appear.

Wiring

Sketch

// SSD1306 OLED — Hello World over I2C
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1  // share Arduino reset pin

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(2);
  display.setCursor(0, 0);
  display.println("Hello!");
  display.setTextSize(1);
  display.println("SSD1306 OLED");
  display.println("128 x 64 pixels");
  display.display();
}

void loop() {}

How to test in the playground

1. Drag an SSD1306 OLED onto the canvas.
2. Wire SDA → A4, SCL → A5, VIN → 3.3V (or 5V), GND → GND.
3. The default I²C address is 0x3C (some modules use 0x3D).
4. Paste the sketch and click Run — 'Hello!' should appear on the screen.

Wiring

Sketch

// Resistor as pull-up — read a button with internal pull-up disabled
// (external 10 kΩ pull-up resistor on Pin 2)
const int BTN = 2;

void setup() {
  pinMode(BTN, INPUT);   // NOT INPUT_PULLUP — we use the external resistor
  Serial.begin(9600);
}

void loop() {
  int state = digitalRead(BTN);
  Serial.println(state == HIGH ? "Released" : "Pressed");
  delay(100);
}

How to test in the playground

1. Drag a Resistor onto the canvas.
2. Set its value attribute (e.g. '220' for 220 Ω, '10000' for 10 kΩ).
3. Connect it in series between the signal source and the load.
4. Paste the sketch and open the Serial Monitor to see button state.

Wiring

Sketch

// Pushbutton — toggle an LED on each press
const int BTN = 2;
const int LED = 13;
bool ledState = false;
bool lastBtn = HIGH;

void setup() {
  pinMode(BTN, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}

void loop() {
  bool btn = digitalRead(BTN);
  if (btn == LOW && lastBtn == HIGH) {  // falling edge = press
    ledState = !ledState;
    digitalWrite(LED, ledState);
    delay(20);  // debounce
  }
  lastBtn = btn;
}

How to test in the playground

1. Drag a Pushbutton onto the canvas.
2. Wire pin 1.l → Pin 2, pin 2.l → GND (the built-in pull-up handles the rest).
3. Also wire Pin 13 → LED → GND via a 220 Ω resistor.
4. Paste the sketch and click Run — press the button to toggle the LED.

Wiring

Sketch

// 6mm Pushbutton — print message on press
const int BTN = 2;

void setup() {
  pinMode(BTN, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println("Press the button!");
}

void loop() {
  if (digitalRead(BTN) == LOW) {
    Serial.println("Button pressed!");
    delay(200);  // simple debounce
  }
}

How to test in the playground

1. Drag a Pushbutton 6mm onto the canvas.
2. Wire 1.l → Pin 2, 2.l → GND.
3. Paste the sketch and open the Serial Monitor — press the button to see the message.

Wiring

Sketch

// Slide Switch — read switch position
const int SW = 4;

void setup() {
  pinMode(SW, INPUT);
  Serial.begin(9600);
}

void loop() {
  int state = digitalRead(SW);
  Serial.println(state == HIGH ? "Switch: ON" : "Switch: OFF");
  delay(300);
}

How to test in the playground

1. Drag a Slide Switch onto the canvas.
2. Wire: Pin 1 → GND, Common (Pin 2) → Pin 4, Pin 3 → 5V.
3. Paste the sketch and open the Serial Monitor.
4. Click the switch on the canvas to toggle it — the Serial Monitor shows the state.

Wiring

Sketch

// DIP Switch 8 — read all 8 switches as a byte
const int PINS[8] = {2, 3, 4, 5, 6, 7, 8, 9};

void setup() {
  for (int p : PINS) pinMode(p, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  byte val = 0;
  for (int i = 0; i < 8; i++) {
    if (digitalRead(PINS[i]) == LOW) {  // LOW = switch closed
      val |= (1 << i);
    }
  }
  Serial.print("DIP = 0b");
  Serial.println(val, BIN);
  delay(200);
}

How to test in the playground

1. Drag a DIP Switch 8 onto the canvas.
2. Wire B pins (1B–8B) to Arduino pins 2–9.
3. Wire all A pins (1A–8A) together to GND.
4. Paste the sketch, open the Serial Monitor, and toggle individual switches.

Wiring

Sketch

// Membrane Keypad — print key to Serial Monitor
#include <Keypad.h>

const byte ROWS = 4, COLS = 4;
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6};
byte colPins[COLS] = {5, 4, 3, 2};

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

void setup() {
  Serial.begin(9600);
}

void loop() {
  char key = keypad.getKey();
  if (key) {
    Serial.print("Key: ");
    Serial.println(key);
  }
}

How to test in the playground

1. Drag a Membrane Keypad onto the canvas.
2. Wire R1–R4 to pins 9, 8, 7, 6 and C1–C4 to pins 5, 4, 3, 2.
3. Paste the sketch (requires the Keypad library) and click Run.
4. Open the Serial Monitor and press keys — each press prints the character.

Wiring

Sketch

// Potentiometer — read value and dim LED via PWM
const int POT = A0;
const int LED = 9;  // PWM pin

void setup() {
  Serial.begin(9600);
}

void loop() {
  int raw = analogRead(POT);          // 0 – 1023
  int brightness = raw / 4;           // 0 – 255 for analogWrite
  analogWrite(LED, brightness);
  Serial.print("Pot: ");
  Serial.print(raw);
  Serial.print("  Brightness: ");
  Serial.println(brightness);
  delay(50);
}

How to test in the playground

1. Drag a Potentiometer and an LED (with 220 Ω resistor) onto the canvas.
2. Wire: GND → GND, VCC → 5V, SIG → A0.
3. Wire LED anode → Pin 9, cathode → GND.
4. Paste the sketch and click Run — rotate the potentiometer to dim the LED.

Wiring

Sketch

// Slide Potentiometer — map position to servo angle
#include <Servo.h>

const int POT = A0;
Servo servo;

void setup() {
  servo.attach(9);
}

void loop() {
  int raw   = analogRead(POT);           // 0 – 1023
  int angle = map(raw, 0, 1023, 0, 180);
  servo.write(angle);
  delay(15);
}

How to test in the playground

1. Drag a Slide Potentiometer and a Servo Motor onto the canvas.
2. Wire: VCC → 5V, SIG → A0, GND → GND.
3. Wire Servo: PWM → Pin 9, V+ → 5V, GND → GND.
4. Paste the sketch and click Run — slide the thumb to move the servo.

Wiring

Sketch

// DHT22 — print temperature and humidity every 2 s
#include <DHT.h>

#define DHTPIN  2
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (isnan(h) || isnan(t)) {
    Serial.println("Sensor error!");
  } else {
    Serial.print("Temp: ");
    Serial.print(t);
    Serial.print(" °C   Humidity: ");
    Serial.print(h);
    Serial.println(" %");
  }
  delay(2000);
}

How to test in the playground

1. Drag a DHT22 onto the canvas.
2. Wire VCC → 5V, GND → GND, SDA → Pin 2.
3. Add a 10 kΩ pull-up resistor between SDA and 5V.
4. Paste the sketch (requires DHT library) and open the Serial Monitor.

Wiring

Sketch

// NTC Temp Sensor — print temperature in °C
const int NTC = A0;
const float SERIES_R = 10000.0;   // 10 kΩ series resistor
const float NOMINAL_R = 10000.0;  // 10 kΩ at 25 °C
const float NOMINAL_T = 25.0;     // °C
const float B_COEFF   = 3950.0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  float raw = analogRead(NTC);
  float r = SERIES_R * (1023.0 / raw - 1.0);
  float steinhart = log(r / NOMINAL_R) / B_COEFF;
  steinhart += 1.0 / (NOMINAL_T + 273.15);
  float tempC = (1.0 / steinhart) - 273.15;

  Serial.print("Temp: ");
  Serial.print(tempC, 1);
  Serial.println(" °C");
  delay(1000);
}

How to test in the playground

1. Drag an NTC Temp Sensor onto the canvas.
2. Wire GND → GND, VCC → 5V, OUT → A0.
3. Paste the sketch and open the Serial Monitor.
4. Click the component in the simulation to adjust the simulated temperature.

Wiring

Sketch

// Photoresistor — react to light level
const int LDR_A = A0;
const int LDR_D = 2;
const int LED   = 13;

void setup() {
  pinMode(LDR_D, INPUT);
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int light = analogRead(LDR_A);         // 0 (dark) – 1023 (bright)
  bool dark  = digitalRead(LDR_D) == LOW; // LOW when below threshold pot

  digitalWrite(LED, dark);               // LED on in the dark

  Serial.print("Light: ");
  Serial.print(light);
  Serial.print("  Dark: ");
  Serial.println(dark ? "yes" : "no");
  delay(200);
}

How to test in the playground

1. Drag a Photoresistor onto the canvas.
2. Wire VCC → 5V, GND → GND, AO → A0.
3. Optionally wire DO → Pin 2 for threshold detection.
4. Paste the sketch — in the simulation you can click and drag the light slider on the component.

Wiring

Sketch

// PIR Motion Sensor — trigger an LED on motion
const int PIR = 2;
const int LED = 13;

void setup() {
  pinMode(PIR, INPUT);
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Waiting for motion...");
}

void loop() {
  if (digitalRead(PIR) == HIGH) {
    digitalWrite(LED, HIGH);
    Serial.println("Motion detected!");
    delay(2000);             // keep LED on for 2 s
  } else {
    digitalWrite(LED, LOW);
  }
}

How to test in the playground

1. Drag a PIR Motion Sensor onto the canvas.
2. Wire VCC → 5V, GND → GND, OUT → Pin 2.
3. Wire LED (with resistor) to Pin 13.
4. Paste the sketch and click Run — in the simulation, click the sensor to trigger motion.

Wiring

Sketch

// HC-SR04 — measure distance and print to Serial Monitor
const int TRIG = 9;
const int ECHO = 10;

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  Serial.begin(9600);
}

float getDistanceCm() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  long duration = pulseIn(ECHO, HIGH);
  return duration * 0.034 / 2.0;  // cm
}

void loop() {
  float dist = getDistanceCm();
  Serial.print("Distance: ");
  Serial.print(dist, 1);
  Serial.println(" cm");
  delay(200);
}

How to test in the playground

1. Drag an HC-SR04 onto the canvas.
2. Wire VCC → 5V, GND → GND, TRIG → Pin 9, ECHO → Pin 10.
3. Paste the sketch and open the Serial Monitor.
4. In the simulation, click and drag the obstacle slider on the sensor to change the distance.

Wiring

Sketch

// Gas Sensor — read analog level and trigger alarm
const int GAS_A = A0;
const int GAS_D = 2;
const int BUZZER = 8;

void setup() {
  pinMode(GAS_D, INPUT);
  pinMode(BUZZER, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int level = analogRead(GAS_A);
  bool alarm = digitalRead(GAS_D) == HIGH;  // HIGH when gas exceeds threshold

  digitalWrite(BUZZER, alarm);

  Serial.print("Gas level: ");
  Serial.print(level);
  Serial.print(alarm ? "  *** ALARM ***" : "  OK");
  Serial.println();
  delay(200);
}

How to test in the playground

1. Drag a Gas Sensor and a Buzzer onto the canvas.
2. Wire VCC → 5V, GND → GND, AOUT → A0, DOUT → Pin 2.
3. Wire Buzzer + → Pin 8, Buzzer − → GND.
4. Paste the sketch and open the Serial Monitor — in the sim, drag the gas slider on the sensor.

Wiring

Sketch

// Analog Joystick — print X, Y and button state
const int JOY_X = A0;
const int JOY_Y = A1;
const int JOY_BTN = 2;

void setup() {
  pinMode(JOY_BTN, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  int x   = analogRead(JOY_X);
  int y   = analogRead(JOY_Y);
  bool btn = digitalRead(JOY_BTN) == LOW;

  Serial.print("X: "); Serial.print(x);
  Serial.print("  Y: "); Serial.print(y);
  Serial.print("  Btn: "); Serial.println(btn ? "pressed" : "released");
  delay(100);
}

How to test in the playground

1. Drag an Analog Joystick onto the canvas.
2. Wire VCC → 5V, GND → GND, HORZ → A0, VERT → A1, SEL → Pin 2.
3. Paste the sketch and open the Serial Monitor.
4. In the simulation, drag the joystick thumb or click it to press the button.

Wiring

Sketch

// MPU-6050 — print accelerometer values over I2C
#include <Wire.h>
#include <MPU6050_light.h>

MPU6050 mpu(Wire);

void setup() {
  Wire.begin();
  Serial.begin(9600);
  byte status = mpu.begin();
  if (status != 0) {
    Serial.print("MPU init failed: "); Serial.println(status);
    while (true);
  }
  Serial.println("Calibrating...");
  mpu.calcOffsets();
  Serial.println("Ready!");
}

void loop() {
  mpu.update();
  Serial.print("Ax: "); Serial.print(mpu.getAccX(), 2);
  Serial.print("  Ay: "); Serial.print(mpu.getAccY(), 2);
  Serial.print("  Az: "); Serial.println(mpu.getAccZ(), 2);
  delay(200);
}

How to test in the playground

1. Drag an MPU-6050 onto the canvas.
2. Wire VCC → 3.3V, GND → GND, SDA → A4, SCL → A5.
3. Paste the sketch (requires MPU6050_light library) and open the Serial Monitor.
4. In the simulation, click the component and adjust the orientation sliders.

Wiring

Sketch

// DS1307 RTC — set time once then read it every second
#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 rtc;

void setup() {
  Wire.begin();
  Serial.begin(9600);
  if (!rtc.begin()) {
    Serial.println("RTC not found!");
    while (true);
  }
  if (!rtc.isrunning()) {
    // Set to compile-time timestamp on first run
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
}

void loop() {
  DateTime now = rtc.now();
  Serial.print(now.year()); Serial.print('-');
  Serial.print(now.month()); Serial.print('-');
  Serial.print(now.day()); Serial.print(' ');
  Serial.print(now.hour()); Serial.print(':');
  Serial.print(now.minute()); Serial.print(':');
  Serial.println(now.second());
  delay(1000);
}

How to test in the playground

1. Drag a DS1307 RTC onto the canvas.
2. Wire GND → GND, 5V → 5V, SDA → A4, SCL → A5.
3. Paste the sketch (requires RTClib) and click Run.
4. The first run sets the time to the compile timestamp — subsequent runs read it back.

Wiring

Sketch

// IR Receiver — print received codes to Serial Monitor
#include <IRremote.hpp>

const int IR_PIN = 11;
IRrecv irrecv(IR_PIN);

void setup() {
  Serial.begin(9600);
  irrecv.enableIRIn();
  Serial.println("Point the remote at the receiver and press a key.");
}

void loop() {
  if (irrecv.decode()) {
    Serial.print("Protocol: ");
    Serial.print(irrecv.decodedIRData.protocol);
    Serial.print("  Code: 0x");
    Serial.println(irrecv.decodedIRData.decodedRawData, HEX);
    irrecv.resume();  // ready for next signal
  }
}

How to test in the playground

1. Drag an IR Receiver and an IR Remote onto the canvas.
2. Wire IR Receiver: GND → GND, VCC → 5V, DAT → Pin 11.
3. Paste the sketch (requires IRremote library) and click Run.
4. Click buttons on the IR Remote in the simulation — codes appear in the Serial Monitor.

Sketch

// IR Remote — no wiring needed on the remote itself.
// Wire the IR Receiver and use this sketch to read remote codes.
// See the IR Receiver guide for the full sketch.

How to test in the playground

1. The IR Remote requires no wiring — it's a simulation-only input device.
2. Drag it onto the canvas alongside an IR Receiver.
3. Run the IR Receiver sketch and click buttons on the remote to see decoded values.

Wiring

Sketch

// KY-040 Encoder — track rotation position and button press
const int CLK = 2;
const int DT  = 3;
const int SW  = 4;

volatile int position = 0;
int lastCLK;

void onCLK() {
  int clk = digitalRead(CLK);
  int dt  = digitalRead(DT);
  if (clk != lastCLK) {
    position += (dt != clk) ? 1 : -1;
    lastCLK = clk;
  }
}

void setup() {
  pinMode(CLK, INPUT);
  pinMode(DT, INPUT);
  pinMode(SW, INPUT_PULLUP);
  lastCLK = digitalRead(CLK);
  attachInterrupt(digitalPinToInterrupt(CLK), onCLK, CHANGE);
  Serial.begin(9600);
}

void loop() {
  static int lastPos = 0;
  if (position != lastPos) {
    Serial.print("Position: ");
    Serial.println(position);
    lastPos = position;
  }
  if (digitalRead(SW) == LOW) {
    Serial.println("Button pressed!");
    delay(200);
  }
}

How to test in the playground

1. Drag a KY-040 Encoder onto the canvas.
2. Wire CLK → Pin 2, DT → Pin 3, SW → Pin 4, VCC → 5V, GND → GND.
3. Paste the sketch and open the Serial Monitor.
4. In the simulation, click the encoder to rotate it or press its button.

Wiring

Sketch

// Buzzer — plays a simple melody
const int BUZZER = 8;

// Frequencies for C4, E4, G4, C5
const int notes[] = {262, 330, 392, 523};
const int durations[] = {300, 300, 300, 600};

void setup() {
  pinMode(BUZZER, OUTPUT);
}

void loop() {
  for (int i = 0; i < 4; i++) {
    tone(BUZZER, notes[i], durations[i]);
    delay(durations[i] + 50);  // slight gap between notes
  }
  noTone(BUZZER);
  delay(800);
}

How to test in the playground

1. Drag a Buzzer onto the canvas.
2. Wire + → Pin 8, − → GND.
3. Paste the sketch and click Run — the buzzer plays a C major arpeggio on repeat.

Wiring

Sketch

// Servo Sweep — moves servo from 0° to 180° and back
#include <Servo.h>

Servo myServo;

void setup() {
  myServo.attach(9);  // Servo signal wire → pin 9
  Serial.begin(9600);
  Serial.println("Servo ready!");
}

void loop() {
  // Sweep from 0° to 180°
  for (int angle = 0; angle <= 180; angle++) {
    myServo.write(angle);
    delay(15);  // ~15ms per degree = ~2.7s full sweep
  }

  // Sweep back from 180° to 0°
  for (int angle = 180; angle >= 0; angle--) {
    myServo.write(angle);
    delay(15);
  }
}

How to test in the playground

1. Drag a Servo Motor onto the canvas.
2. Wire Signal (orange/yellow) → Pin 9, Power (red) → 5V, Ground (brown/black) → GND.
3. Paste the sketch and click Run — the servo sweeps back and forth.

Wiring

Sketch

// Stepper Motor — rotate 360° CW then 360° CCW (using AccelStepper)
#include <AccelStepper.h>

// A4988 driver: STEP → Pin 3, DIR → Pin 4
AccelStepper stepper(AccelStepper::DRIVER, 3, 4);

const int STEPS_PER_REV = 200;

void setup() {
  stepper.setMaxSpeed(400);
  stepper.setAcceleration(200);
  stepper.moveTo(STEPS_PER_REV);  // one full CW rotation
}

void loop() {
  if (stepper.distanceToGo() == 0) {
    stepper.moveTo(-stepper.currentPosition());  // reverse
  }
  stepper.run();
}

How to test in the playground

1. Drag a Stepper Motor onto the canvas. You also need an A4988 driver (add as a custom element if not in palette).
2. Wire A4988 outputs to the stepper coils: OUT1A/1B → A+/A−, OUT2A/2B → B+/B−.
3. Wire Arduino Pin 3 → A4988 STEP, Pin 4 → A4988 DIR.
4. Supply 8–35V to the driver VMOT and logic 5V to VDD.
5. Paste the sketch (requires AccelStepper library) and click Run.

Wiring

Sketch

// Biaxial Stepper — run both axes simultaneously
#include <AccelStepper.h>

AccelStepper axis1(AccelStepper::DRIVER, 3, 4);  // STEP=3, DIR=4
AccelStepper axis2(AccelStepper::DRIVER, 5, 6);  // STEP=5, DIR=6

const int STEPS = 200;

void setup() {
  axis1.setMaxSpeed(300); axis1.setAcceleration(150);
  axis2.setMaxSpeed(300); axis2.setAcceleration(150);
  axis1.moveTo(STEPS);
  axis2.moveTo(-STEPS);  // opposite direction
}

void loop() {
  if (axis1.distanceToGo() == 0) axis1.moveTo(-axis1.currentPosition());
  if (axis2.distanceToGo() == 0) axis2.moveTo(-axis2.currentPosition());
  axis1.run();
  axis2.run();
}

How to test in the playground

1. Drag a Biaxial Stepper onto the canvas — wire each axis to its own A4988 driver.
2. Axis 1 driver: STEP → Pin 3, DIR → Pin 4.
3. Axis 2 driver: STEP → Pin 5, DIR → Pin 6.
4. Paste the sketch (requires AccelStepper) and click Run — both axes rotate in opposite directions.

Wiring

Sketch

// KS2E Relay — click a relay on and off every 2 s
// Wire the coil through a transistor (e.g. 2N2222) or ULN2003
const int RELAY = 7;

void setup() {
  pinMode(RELAY, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(RELAY, HIGH);  // coil energised → NO closes
  Serial.println("Relay ON");
  delay(2000);

  digitalWrite(RELAY, LOW);   // coil off → NO opens
  Serial.println("Relay OFF");
  delay(2000);
}

How to test in the playground

1. Drag a KS2E Relay onto the canvas.
2. Drive COIL1 from Arduino Pin 7 via a NPN transistor (base resistor ~1 kΩ) and a flyback diode.
3. Wire COIL2 to GND, collector to COIL1, emitter to GND.
4. Wire your load between NO1 and the supply, with P1 (COM1) as the switching point.
5. Paste the sketch and click Run — the relay clicks on and off every 2 s.

Wiring

Sketch

// MicroSD Card — log sensor data to a CSV file
#include <SD.h>

const int CS_PIN = 10;
int counter = 0;

void setup() {
  Serial.begin(9600);
  if (!SD.begin(CS_PIN)) {
    Serial.println("SD init failed!");
    return;
  }
  Serial.println("SD card ready.");
  File f = SD.open("data.csv", FILE_WRITE);
  if (f) { f.println("index,value"); f.close(); }
}

void loop() {
  int val = analogRead(A0);
  File f = SD.open("data.csv", FILE_WRITE);
  if (f) {
    f.print(counter++);
    f.print(',');
    f.println(val);
    f.close();
    Serial.print("Logged: "); Serial.println(val);
  }
  delay(1000);
}

How to test in the playground

1. Drag a MicroSD Card onto the canvas.
2. Wire VCC → 5V, GND → GND, CS → Pin 10, MOSI → Pin 11, SCK → Pin 13, MISO → Pin 12.
3. Paste the sketch and click Run — the sketch creates data.csv and appends a new reading every second.
4. Open the Serial Monitor to confirm writes succeed.

Wiring

Sketch

// HX711 Load Cell — print raw and calibrated weight
#include <HX711.h>

const int DOUT = 3;
const int CLK  = 2;

HX711 scale;
const float CALIBRATION = 420.0;  // adjust after calibration

void setup() {
  Serial.begin(9600);
  scale.begin(DOUT, CLK);
  scale.set_scale(CALIBRATION);
  scale.tare();  // reset to zero
  Serial.println("Place weight on scale...");
}

void loop() {
  if (scale.is_ready()) {
    float grams = scale.get_units(5);  // average of 5 readings
    Serial.print("Weight: ");
    Serial.print(grams, 1);
    Serial.println(" g");
  }
  delay(500);
}

How to test in the playground

1. Drag an HX711 onto the canvas.
2. Wire VCC → 5V, GND → GND, DT → Pin 3, SCK → Pin 2.
3. Connect your load cell's four wires to the HX711's E+/E−/A+/A− terminals.
4. Paste the sketch (requires HX711 library), click Run, and open the Serial Monitor.
5. In the simulation, adjust the force slider on the component to simulate weight.