Arduino Knight Rider LED Chaser: Circuit, Code and Speed Control

The Arduino Knight Rider circuit is a classic LED effect in which a row of LEDs lights up one after another, sweeping from one end to the other and back again, named after the scanner light on the front of KITT, the talking car from the famous 1980s TV series. All you need is an Arduino Uno, 6 or 8 LEDs, a 220 Ω resistor for each LED and a few jumper wires. If the light only flows in one direction and then starts again from the beginning, it's called a running light or LED chaser. Both are classic projects that beginners build right after a traffic light, and they're the most fun way to learn two of the most important tools in programming: arrays and the for loop.

In this guide you'll build the circuit and write the running light code first, then the back-and-forth Knight Rider code. After that you'll set the speed with a potentiometer, add an effect where the LEDs stack up at one end, and run the same effect with millis() without ever blocking the code. In the last sections you'll find how to drive 8 LEDs from just 3 pins with a 74HC595 chip, how to build a Knight Rider with a fading tail from a single pin using WS2812B addressable LEDs, the ESP32 and Raspberry Pi Pico (MicroPython) versions, and fixes for the most common mistakes.

What is the Knight Rider effect, and how is it different from a running light?

In the series, the red light on KITT's front bumper sweeps left and right non-stop like a scanning eye. In electronics this effect is also called a Larson scanner, after the show's producer Glen A. Larson; the eyes of the Cylon robots in his other series, Battlestar Galactica, work the same way. On the real scanner you can see a slowly fading red trail, a tail, behind the lit spot. In a simple LED circuit each LED is either fully on or fully off; to imitate the tail you have to dim the LEDs gradually with PWM. We'll do exactly that later with the WS2812B and the ESP32. The table below summarises the effects you'll code in this article and how many steps one round takes with 8 LEDs.

Parts list and choosing the resistor

An LED doesn't limit its own current, so every LED gets a resistor in series. You find the value with Ohm's law: R = (supply voltage − LED forward voltage) / current. A red LED has a forward voltage of about 2 V, so at 5 V with 220 Ω the current is (5 − 2) / 220 ≈ 13.6 mA. That lights the LED nice and bright and stays below the 20 mA recommended for an Arduino pin. In the stacking effect, when all eight LEDs are on at the same time, the total current is about 109 mA, which is still within the Uno's 200 mA limit for all pins combined. To recognise a 220 Ω resistor by its colour bands, use the resistor colour code tool; for other colours and voltages, try the LED resistor calculator.

Wiring: 8 LEDs and a potentiometer

The long leg (anode) of each LED goes through a resistor to a digital pin on the board, and the short leg (cathode) goes to GND. On a breadboard the tidiest way is to connect the Arduino's GND pin to the blue (−) rail of the breadboard and bring the short legs of all eight LEDs to that rail. Place the LEDs at even spacing from left to right in pin order; that way the order in the code's array matches the physical order of the light. The potentiometer's two outer legs go to 5V and GND, and its middle leg (the wiper) goes to A0. The table below shows the pins used by every sketch in this article; if you're using 6 LEDs, skip the last two LED rows and delete the last two pins from the array in the code. You can see your board's pin layout in the Pinout tool.

Step 1: running light code with an array and a for loop

You could write eight separate pinMode lines and sixteen separate digitalWrite lines for eight LEDs, but the code gets long and changing the number of LEDs becomes a chore. Instead, you put the pin numbers into an array and walk through it with a for loop. The first element of the array is LEDS[0], which is D2; the last is LEDS[7], which is D9. This way the same code works unchanged with 6, 8 or 12 LEDs; you only edit the array. You'll find the basics of arrays and loops explained in more detail in Arduino programming basics.

1// Yürüyen LED: 8 LED sırayla yanar / Running light: 8 LEDs light up one after another
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};             // LED pinleri / LED pins
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);  // dizideki LED sayısı (8) / number of LEDs (8)
4const int BEKLE = 100;                                  // adım süresi (ms) / step time (ms)
5
6void setup() {
7  for (int i = 0; i < LED_SAYISI; i++) {
8    pinMode(LEDS[i], OUTPUT);                           // tüm LED pinleri çıkış / all LED pins as outputs
9  }
10}
11
12void loop() {
13  for (int i = 0; i < LED_SAYISI; i++) {
14    digitalWrite(LEDS[i], HIGH);                        // sıradaki LED'i yak / light the next LED
15    delay(BEKLE);
16    digitalWrite(LEDS[i], LOW);                         // söndür ve devam et / turn it off and move on
17  }
18}

With BEKLE (the step time) at 100 ms the light passes all eight LEDs in 0.8 seconds and starts again right away. Drop it to 30 ms and the flow becomes very fast; raise it to 300 ms and it looks slow, like lamps lighting one by one. To upload the code, select the board and port in the Tools menu and press Upload; if the upload fails, go through the checklist in Arduino code won't upload.

Step 2: Knight Rider (back-and-forth) code

For the Knight Rider effect, the light has to turn around when it reaches the right end. You do this with two loops: the first counts from left to right, the second from right to left. The subtle point here is the end LEDs. If both loops count all the way from 0 to 7 and from 7 to 0, the right-most LED lights once at the end of the forward loop and once again at the start of the backward loop; the light stays twice as long at the ends and the motion looks like it's stuttering. That's why the forward loop stops at 6 and the backward loop at 1. As a result each round takes exactly 14 steps and the light stays at the ends just as long as in the middle. We also moved the three lines that switch an LED on and off into a small function called yakSondur() ("light and turn off"); the code gets both shorter and easier to read.

1// Karaşimşek (Knight Rider): ışık iki uç arasında gidip gelir / light bounces between the two ends
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int BEKLE = 80;                                   // adım süresi (ms) / step time (ms)
5
6void yakSondur(int i) {
7  digitalWrite(LEDS[i], HIGH);
8  delay(BEKLE);
9  digitalWrite(LEDS[i], LOW);
10}
11
12void setup() {
13  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
14}
15
16void loop() {
17  for (int i = 0; i < LED_SAYISI - 1; i++) {           // soldan sağa: 0..6 / left to right: 0..6
18    yakSondur(i);
19  }
20  for (int i = LED_SAYISI - 1; i > 0; i--) {           // sağdan sola: 7..1 / right to left: 7..1
21    yakSondur(i);
22  }
23}

Step 3: speed control with a potentiometer

Instead of changing the code and uploading it again every time you want a different speed, you can use a potentiometer. A potentiometer is a voltage divider: the voltage on the middle leg changes between 0 and 5 V depending on the position of the shaft, and analogRead() turns it into a number between 0 and 1023. map(deger, 0, 1023, 400, 20) converts that number into a step time between 400 and 20 ms; because the range is written in reverse, the higher the reading, the shorter the step and the faster the light. Which way you have to turn the shaft to speed it up depends on which outer leg you connected to 5V; if it feels backwards, swap the two outer wires or swap 400 and 20 in map(). You can read about how a potentiometer works inside in What is a potentiometer?.

1// Hız ayarlı karaşimşek: potansiyometre adım süresini belirler / Speed-adjustable Knight Rider: the pot sets the step time
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = A0;                                     // potansiyometrenin orta bacağı / pot wiper
5
6int adimSuresi() {
7  int deger = analogRead(POT);                          // 0–1023
8  return map(deger, 0, 1023, 400, 20);                  // değer büyüdükçe hızlanır / faster as the value rises
9}
10
11void yakSondur(int i) {
12  digitalWrite(LEDS[i], HIGH);
13  delay(adimSuresi());                                  // her adımda yeniden okunur / read again on every step
14  digitalWrite(LEDS[i], LOW);
15}
16
17void setup() {
18  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
19}
20
21void loop() {
22  for (int i = 0; i < LED_SAYISI - 1; i++) yakSondur(i);   // sağa / to the right
23  for (int i = LED_SAYISI - 1; i > 0; i--) yakSondur(i);   // sola / to the left
24}

In this version the step time is read again for every LED, so the speed changes the moment you turn the shaft. However, while delay() is running the Arduino can't do anything else: even if you turn the shaft in the middle of a slow 400 ms step, the new speed only applies from the next step. For an effect with a few LEDs that's no problem, but once you add a mode button or sensor readings you need to switch to the millis() method from step 5.

Step 4: the stacking effect

In the stacking effect the first light runs all the way to the right and stays lit at the far right. The second light runs too, but this time it stops one place further left; each round the target moves one LED to the left until the whole bar is full. In code you do this with two nested loops: the outer loop counts how many LEDs have stacked up (dolu, "full"), and the inner loop counts how many steps the light runs in this round. The LED that reaches its target (hedef) isn't switched off; the line if (i < hedef) takes care of exactly that. With eight LEDs, filling the whole bar takes 8 + 7 + 6 + ... + 1 = 36 steps.

1// Birikerek dolan efekt: her ışık en boş uca kadar gider ve orada kalır / Stacking effect: each light runs to the last free spot and stays
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int BEKLE = 60;
5
6void setup() {
7  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
8}
9
10void loop() {
11  for (int dolu = 0; dolu < LED_SAYISI; dolu++) {       // dolu: sağda birikmiş LED sayısı / LEDs already stacked on the right
12    int hedef = LED_SAYISI - 1 - dolu;                  // bu turda ışığın duracağı yer / where the light stops this round
13    for (int i = 0; i <= hedef; i++) {
14      digitalWrite(LEDS[i], HIGH);
15      delay(BEKLE);
16      if (i < hedef) digitalWrite(LEDS[i], LOW);        // hedefte yanık kalır / stays lit at the target
17    }
18  }
19  delay(600);                                           // dolu çubuğu göster / show the full bar
20  for (int i = LED_SAYISI - 1; i >= 0; i--) {           // sağdan sola boşalt / empty from right to left
21    digitalWrite(LEDS[i], LOW);
22    delay(BEKLE);
23  }
24  delay(300);
25}

At the end of the sketch the full bar is shown for 0.6 seconds, then the LEDs go out one by one from right to left and the effect starts over. If you want a simpler filling bar, just remove the inner loop and switch the LEDs on in order without ever turning them off; that look is ideal for a charge indicator or a sound level bar. Remember that all eight LEDs are on at the same time in this effect: as long as each LED has its own resistor, the brightness won't drop.

Step 5: non-blocking Knight Rider with millis()

In code that uses delay(), the Arduino freezes for the given time on every step; even if someone presses a button meanwhile, it won't notice. millis(), on the other hand, returns the time in milliseconds since the board was switched on. The logic goes like this: the loop runs constantly, checks every time round whether enough time has passed since the last step, takes just one step if it has, and leaves again immediately. In the code below the Knight Rider and the onboard LED run at the same time as two independent tasks: while the scanner sweeps at the speed set by the potentiometer, the LED on D13 blinks once a second at its own pace. For more on this topic, see Arduino millis() vs delay().

1// millis() ile bekletmesiz karaşimşek + potansiyometre / Non-blocking Knight Rider with millis() + pot
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = A0;
5
6int konum = 0;                     // şu an yanan LED / the LED that is lit now
7int yon = 1;                       // +1 sağa, -1 sola / +1 right, -1 left
8unsigned long sonAdim = 0;         // son adımın zamanı / time of the last step
9unsigned long sonBlink = 0;        // dahili LED için / for the onboard LED
10
11void setup() {
12  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
13  pinMode(LED_BUILTIN, OUTPUT);    // Uno'da D13 / D13 on the Uno
14  digitalWrite(LEDS[konum], HIGH);
15}
16
17void loop() {
18  unsigned long simdi = millis();
19  unsigned long aralik = map(analogRead(POT), 0, 1023, 400, 20);   // adım süresi (ms) / step time (ms)
20
21  // Görev 1: karaşimşek / Task 1: Knight Rider
22  if (simdi - sonAdim >= aralik) {          // taşmaya karşı güvenli / overflow-safe
23    sonAdim = simdi;
24    digitalWrite(LEDS[konum], LOW);
25    konum += yon;
26    if (konum == LED_SAYISI - 1 || konum == 0) yon = -yon;   // uçta yön değiştir / reverse at the ends
27    digitalWrite(LEDS[konum], HIGH);
28  }
29
30  // Görev 2: dahili LED kendi temposunda yanıp söner / Task 2: the onboard LED blinks at its own pace
31  if (simdi - sonBlink >= 500) {
32    sonBlink = simdi;
33    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
34  }
35  // Buraya buton, sensör ya da seri port kodu eklenebilir / button, sensor or serial code can go here
36}

Two details matter here. First, the time variables must be unsigned long; if you use int, the value overflows on the Uno after about 32.7 seconds and the timing breaks: the effect either stops or speeds up out of control. Second, the comparison is done with a subtraction in the form simdi - sonAdim >= aralik (now minus last step, compared with the interval); this method keeps working correctly even when millis() rolls over to zero roughly every 49.7 days. Because we keep the light's position and direction in two variables (konum and yon), there are no loops any more: on every step the position goes up or down by one, and at the ends the direction changes sign.

8 LEDs from 3 pins with a 74HC595

Eight LEDs take up eight of the Uno's pins; once you want to add an LCD, sensors and buttons to your project, you start running out. The 74HC595 shift register drives its eight outputs from just three Arduino pins (data, clock and latch). The state of each LED is one bit of a byte: the expression 1 << i sets only bit i to 1, which lights a single LED. Building patterns with bit operations is easy too: (1 << i) | (0x80 >> i) produces two lights coming in from both ends towards the middle at the same time. By chaining two chips you can also build a 16-LED Knight Rider with the same three pins; chaining, fast driving over SPI and using 7-segment displays are explained step by step in the 74HC595 shift register article.

1// 74HC595 ile 3 pinden 8 LED: karaşimşek ve ortada buluşma / 8 LEDs from 3 pins with a 74HC595: Knight Rider and meet-in-the-middle
2const int DATA_PIN = 11;    // DS (14)
3const int CLOCK_PIN = 13;   // SH_CP (11)
4const int LATCH_PIN = 10;   // ST_CP (12)
5const int POT = A0;
6
7void yaz595(byte desen) {
8  digitalWrite(LATCH_PIN, LOW);
9  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, desen);   // 8 biti gönder / send the 8 bits
10  digitalWrite(LATCH_PIN, HIGH);                    // çıkışlara aktar / copy to the outputs
11}
12
13void setup() {
14  pinMode(DATA_PIN, OUTPUT);
15  pinMode(CLOCK_PIN, OUTPUT);
16  pinMode(LATCH_PIN, OUTPUT);
17  yaz595(0);                                        // açılışta hepsi sönük / all off at startup
18}
19
20void loop() {
21  int bekle = map(analogRead(POT), 0, 1023, 400, 20);
22
23  for (int i = 0; i < 7; i++) { yaz595(1 << i); delay(bekle); }   // Q0 -> Q7
24  for (int i = 7; i > 0; i--) { yaz595(1 << i); delay(bekle); }   // Q7 -> Q0
25
26  for (int i = 0; i < 4; i++) {                     // uçlardan ortaya / from the ends to the middle
27    yaz595((1 << i) | (0x80 >> i));
28    delay(bekle);
29  }
30  for (int i = 3; i >= 0; i--) {                    // ortadan uçlara / from the middle to the ends
31    yaz595((1 << i) | (0x80 >> i));
32    delay(bekle);
33  }
34}

On the 74HC595 outputs 470 Ω is recommended instead of 220 Ω: the total current through the chip's VCC and GND pins shouldn't exceed 70 mA. With 470 Ω about 6.4 mA flows per LED, and even with all eight LEDs on the total stays at 51 mA. In a Knight Rider only one or two LEDs are on at a time anyway, so the LEDs are still clearly visible.

Knight Rider with a fading tail from a single pin with WS2812B

The version that looks most like the real KITT scanner is built with WS2812B addressable LEDs. Each WS2812B has its own driver built in; however long the strip is, you set the colour and brightness of each LED individually over a single data wire. For the tail we keep an array: on every step the brightness of all LEDs is divided by three, and the head LED is set to 255. The LEDs behind it fade quickly through 255, 85, 28, 9, leaving a natural trail behind the light. Use 2 instead of 3 as the divisor and the tail gets longer; use 5 and it gets shorter. To go from 8 to 60 LEDs with the same method, you only need to change NUM_LEDS.

1// WS2812B ile kuyruklu karaşimşek (tek veri pini) / Knight Rider with a fading tail on WS2812B (one data pin)
2#include <Adafruit_NeoPixel.h>
3
4const int DATA_PIN = 6;      // DIN, 330 Ω üzerinden / DIN through 330 Ω
5const int NUM_LEDS = 8;      // şerit ya da çubuktaki LED sayısı / LEDs on the strip or stick
6const int POT = A0;
7
8Adafruit_NeoPixel strip(NUM_LEDS, DATA_PIN, NEO_GRB + NEO_KHZ800);
9
10uint8_t seviye[NUM_LEDS];    // her LED'in kırmızı parlaklığı / red brightness of each LED
11int konum = 0;
12int yon = 1;
13
14void setup() {
15  strip.begin();
16  strip.setBrightness(80);   // 0–255; USB için düşük tut / keep it low on USB power
17  strip.show();              // hepsini söndür / all off
18}
19
20void loop() {
21  for (int i = 0; i < NUM_LEDS; i++) seviye[i] = seviye[i] / 3;   // kuyruk söner / the tail fades
22  seviye[konum] = 255;                                            // baştaki LED tam parlak / the head is full brightness
23
24  for (int i = 0; i < NUM_LEDS; i++) {
25    strip.setPixelColor(i, strip.Color(seviye[i], 0, 0));         // yalnız kırmızı / red only
26  }
27  strip.show();
28
29  konum += yon;
30  if (konum == NUM_LEDS - 1 || konum == 0) yon = -yon;            // uçta yön değiştir / reverse at the ends
31  delay(map(analogRead(POT), 0, 1023, 150, 20));
32}

Knight Rider on the ESP32: a PWM tail on every pin

On the Uno a Knight Rider with a tail is hard to build with ordinary LEDs, because PWM is only available on pins 3, 5, 6, 9, 10 and 11, and our D2–D9 array contains only four of them. On the ESP32, thanks to the LEDC hardware, almost every output pin can generate PWM, and the classic ESP32 has 16 PWM channels. Since analogWrite() works directly in the current ESP32 Arduino core, you can apply the WS2812B tail logic to ordinary LEDs. The pins in the table are safe GPIOs that don't affect booting; the potentiometer connects to GPIO 34 on the ADC1 channel, which reads reliably even with Wi-Fi on, and because the ESP32's ADC is 12-bit the value ranges from 0 to 4095. The ESP32's pins output 3.3 V, so about 6 mA flows through a red LED with 220 Ω; the LEDs look a little dimmer than on the Uno. For setting up the board, see What is the ESP32?.

1// ESP32: her pinde PWM ile kuyruklu karaşimşek / ESP32: Knight Rider with a PWM tail on every pin
2const int LEDS[] = {18, 19, 21, 22, 23, 25, 26, 27};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = 34;                        // ADC1, yalnızca giriş / ADC1, input only
5
6int parlaklik[LED_SAYISI];                 // 0–255
7int konum = 0;
8int yon = 1;
9unsigned long sonAdim = 0;
10
11void setup() {
12  // analogWrite() pini PWM için kendisi hazırlar / analogWrite() sets the pin up for PWM itself
13}
14
15void loop() {
16  unsigned long aralik = map(analogRead(POT), 0, 4095, 400, 20);   // ESP32 ADC 12 bit: 0–4095
17  if (millis() - sonAdim >= aralik) {
18    sonAdim = millis();
19    for (int i = 0; i < LED_SAYISI; i++) parlaklik[i] /= 3;        // kuyruk söner / the tail fades
20    parlaklik[konum] = 255;
21    for (int i = 0; i < LED_SAYISI; i++) analogWrite(LEDS[i], parlaklik[i]);
22    konum += yon;
23    if (konum == LED_SAYISI - 1 || konum == 0) yon = -yon;
24  }
25}

Knight Rider on the Raspberry Pi Pico with MicroPython

On the Raspberry Pi Pico you can write the same effect in a few lines of MicroPython. Keeping the Pin objects in a list does the same job as the array on the Arduino. time.ticks_ms() and time.ticks_diff() are the MicroPython equivalents of millis() and the overflow-safe subtraction. The potentiometer connects to GP26 (ADC0); read_u16() returns a value from 0 to 65535 and the code converts it to 400–20 ms. It's recommended that the total current drawn from all of the Pico's GPIOs stays below 50 mA; that's why we chose 330 Ω in the table: about 4 mA flows per LED, and even with all eight LEDs on the total stays around 32 mA. The BlueGrays Pico Knight Rider project uses 6 LEDs on pins GP9–GP14; if you've built that circuit, just change the PINLER list to [9, 10, 11, 12, 13, 14]. For setup and uploading code with Thonny, see What is the Raspberry Pi Pico?.

1# Raspberry Pi Pico: potansiyometreyle hız ayarlı karaşimşek / Pico: Knight Rider with pot speed control
2from machine import Pin, ADC
3import time
4
5PINLER = [8, 9, 10, 11, 12, 13, 14, 15]        # GP8–GP15
6leds = [Pin(p, Pin.OUT) for p in PINLER]
7pot = ADC(26)                                   # GP26 = ADC0
8
9def adim_suresi():
10    # read_u16: 0–65535 -> 400–20 ms
11    return 400 - pot.read_u16() * 380 // 65535
12
13konum, yon = 0, 1
14leds[konum].on()
15son = time.ticks_ms()
16
17while True:
18    if time.ticks_diff(time.ticks_ms(), son) >= adim_suresi():   # millis() benzeri / like millis()
19        son = time.ticks_ms()
20        leds[konum].off()
21        konum += yon
22        if konum == len(leds) - 1 or konum == 0:
23            yon = -yon                          # uçta yön değiştir / reverse at the ends
24        leds[konum].on()

Every GPIO on the Pico can generate PWM as well; with machine.PWM and a duty_u16() value for each LED you can bring the ESP32's tail effect over to the Pico. If you want to use WS2812B LEDs, MicroPython's built-in neopixel module drives a strip from a single GPIO; however, a WS2812B powered at 5 V doesn't always read the Pico's 3.3 V data signal reliably, so if the colours glitch, add a level shifter in between.

Knight Rider project ideas

• Sound level meter (VU meter): use the loudness measured with a KY-038 sound sensor to decide how many LEDs of the filling bar light up.
• Parking sensor LED bar: light more LEDs as the distance measured with an HC-SR04 shrinks, and flash them all when you get very close.
• Catch-the-light game: while the scanner sweeps quickly, try to press a button exactly when the middle LED is lit; make the step time shorter after every success.
• Automatic night-time decoration: start the effect by itself when an LDR detects that it's getting dark.
• Rear light for a model car or bike: make a red Knight Rider with a tail on a WS2812B stick, and light all LEDs at full brightness when the brake button is pressed.
• Level indicator: show the position of a potentiometer or a battery voltage as a filling bar.
• Bigger displays: take the same logic to a MAX7219 LED matrix or an LED cube.

Common mistakes and how to fix them

The Knight Rider looks simple, but it contains the basic ideas you'll use in every project later on: arrays, loops, analog readings, map(), non-blocking timing, bit operations and addressable LEDs. For your next step, take a look at the Arduino traffic light project or the list of Arduino project ideas. In the BlueGrays app you'll find the running light, Knight Rider and speed-adjustable versions, WS2812B stacking and Knight Rider effects, and the ESP32 running light and Pico Knight Rider projects, each with a step-by-step circuit diagram and ready-to-use code to try on your own board.