diff --git a/arduino/arduino-ide.md b/arduino/arduino-ide.md
index 9ccab43..b5acb31 100644
--- a/arduino/arduino-ide.md
+++ b/arduino/arduino-ide.md
@@ -19,6 +19,10 @@ usetocbot: true
{:toc}
---
+
+**Figure.** Coming up: by the end of this lesson, you'll have the Arduino IDE installed and configured, with a new sketch open showing the `setup()` and `loop()` functions ready to program your board.
+{: .fs-1 }
+
The Arduino IDE (Integrated Development Environment) is where you'll write, compile, and upload code to your Arduino board. This page walks through downloading, installing, and configuring the IDE so you're ready to start programming.
## Download and install the Arduino IDE
diff --git a/arduino/rgb-led-fade.md b/arduino/rgb-led-fade.md
index b3b2bb6..a4ccf4d 100644
--- a/arduino/rgb-led-fade.md
+++ b/arduino/rgb-led-fade.md
@@ -21,6 +21,12 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** Where we're headed: an RGB LED smoothly crossfading through the color wheel, driven by `analogWrite()` and the HSL color space on an Arduino Uno.
+{: .fs-1 }
+
In this lesson, you will learn how to fade between RGB colors using [`analogWrite`](https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/), how to use the [HSL colorspace](https://en.wikipedia.org/wiki/HSL_and_HSV) to more easily (and independently) control hue and brightness, and how to use and load local `C/C++` libraries.
---
diff --git a/arduino/tone.md b/arduino/tone.md
index 822d4ff..c5f74dc 100644
--- a/arduino/tone.md
+++ b/arduino/tone.md
@@ -21,7 +21,11 @@ usetocbot: true
{:toc}
---
-
+
+**Video.** A preview of what we'll build: the Imperial March from Star Wars played on a piezo buzzer with the `tone()` function, with the built-in LED flashing in time with each note.
+{: .fs-1 }
So far, every output we've produced has been visual—turning LEDs on, off, fading, and blinking. In this lesson, we'll add a completely new output modality: **sound!** Using a piezo buzzer and the Arduino [`tone()`](https://www.arduino.cc/reference/en/language/functions/advanced-io/tone/) function, we'll learn how to play individual notes, scales, and even melodies.
diff --git a/communication/p5js-serial-io.md b/communication/p5js-serial-io.md
index 902e370..cd8b7c6 100644
--- a/communication/p5js-serial-io.md
+++ b/communication/p5js-serial-io.md
@@ -20,6 +20,12 @@ usetocbot: true
{:toc}
---
+
+**Video.** A preview of what we'll build: **DisplayShapeBidirectional**, where p5.js buttons *and* physical Arduino buttons control a shape shared between the browser canvas and the OLED display. ([live page](http://makeabilitylab.github.io/p5js/WebSerial/p5js/DisplayShapeBidirectional), [code](https://github.com/makeabilitylab/p5js/tree/main/WebSerial/p5js/DisplayShapeBidirectional))
+{: .fs-1 }
+
OK, now we're really rolling! We learned about [serial communication](serial-intro.md), then how to use serial in our browsers ([Web Serial!](web-serial.md)), and then how to do this with [p5.js](p5js-serial.md). And we've already made some cool proof-of-concept demos.
Let's take this growing knowledge and momentum to create slightly more sophisticated programs. First, we'll cover the case of using p5.js to control something on our Arduino (`Computer → Arduino`). Then we'll introduce bidirectional communication (`Computer ↔ Arduino`) where the computer and Arduino work together to create a holistic interactive experience. 🎮
diff --git a/communication/p5js-serial.md b/communication/p5js-serial.md
index bd03b94..0e0e99c 100644
--- a/communication/p5js-serial.md
+++ b/communication/p5js-serial.md
@@ -20,6 +20,12 @@ usetocbot: true
{:toc}
---
+
+**Video.** Where we're headed: **GraphIn**, a p5.js sketch that graphs live Arduino sensor data in the browser in real time (here, from a potentiometer). ([live page](https://makeabilitylab.github.io/p5js/WebSerial/p5js/GraphIn/), [code](https://github.com/makeabilitylab/p5js/tree/main/WebSerial/p5js/GraphIn))
+{: .fs-1 }
+
We've only started to scratch the surface of what's possible when combining Arduino with computers. In this lesson (and the next), we're going to use a creative coding tool called [p5.js](https://p5js.org/) to help demonstrate this potential. It should be fun! 🎨
{: .note }
diff --git a/communication/serial-intro.md b/communication/serial-intro.md
index 1c3f9ee..b77b365 100644
--- a/communication/serial-intro.md
+++ b/communication/serial-intro.md
@@ -20,6 +20,12 @@ usetocbot: true
{:toc}
---
+
+**Video.** Serial communication in action—the focus of this lesson: text typed into the Arduino IDE [Serial Monitor](../arduino/serial-print.md) is sent to an Arduino, shown on an [OLED](../advancedio/oled.md), and echoed back.
+{: .fs-1 }
+
Devices need to communicate. Sensors talk to microcontrollers. Microcontrollers talk to computers. Computers talk to the Internet. And beyond! Many different protocols have been created to support device-to-device communication—from [Ethernet](https://en.wikipedia.org/wiki/Ethernet) and [Zigbee](https://en.wikipedia.org/wiki/Zigbee) to WiFi and Bluetooth. In this lesson, we will focus on **asynchronous serial communication**, specifically TTL serial (Transistor-Transistor Logic Serial)—an enduring standard that has prevailed since the beginning of personal computers and is what the [Arduino Serial library](https://www.arduino.cc/reference/en/language/functions/communication/serial/) uses.
Unlike other popular serial communication protocols like [I2C](https://learn.sparkfun.com/tutorials/i2c/all) and [SPI](https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi/all), TTL serial is *asynchronous*, which means it does not rely on a shared clock signal (precisely timed voltage pulses) paired with its data lines. This has the benefit of fewer wires but does result in a bit of communication overhead for each transmitted "packet" or data frame.
diff --git a/communication/web-serial.md b/communication/web-serial.md
index 057d838..31176f9 100644
--- a/communication/web-serial.md
+++ b/communication/web-serial.md
@@ -20,6 +20,12 @@ usetocbot: true
{:toc}
---
+
+**Video.** By the end of this lesson, you'll build apps like **SliderOut**—dimming an Arduino's LED from a browser slider, straight over USB via the Web Serial API. ([live page](https://makeabilitylab.github.io/p5js/WebSerial/Basic/SliderOut), [code](https://github.com/makeabilitylab/p5js/tree/main/WebSerial/Basic/SliderOut))
+{: .fs-1 }
+
In our [previous lesson](serial-intro.md), we learned about asynchronous serial communication, Arduino's [Serial library](https://www.arduino.cc/reference/en/language/functions/communication/serial/), and how to write programs—using [Serial Monitor](../arduino/serial-print.md), the command line, and [Python](https://www.python.org/)—to send data to an Arduino.
In this lesson, we'll apply that knowledge to a new and exciting context: **the web browser!** Using the [Web Serial API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Serial_API), we'll build simple web apps that communicate directly with an Arduino over USB—no drivers, no native installs, just HTML, JavaScript, and a serial cable. 🌐
diff --git a/cpx/analog-input.md b/cpx/analog-input.md
index 77560d2..c0e669e 100644
--- a/cpx/analog-input.md
+++ b/cpx/analog-input.md
@@ -19,16 +19,18 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** In this lesson, we'll connect *external* analog sensors to the CPX—potentiometers, FSRs, flex sensors, and even a lo-fi slide potentiometer made from paper and a pencil.
+{: .fs-1 }
+
In Lesson 8, we move beyond working with internal sensors on the CPX (light 💡, microphone 🔊, accelerometer 🍎) and show how to connect external sensors using **analog input**.
## Lesson 8.1: Overview of Analog Input
In this lesson, we introduce **analog input** on the Circuit Playground Express (CPX) primarily focusing on variable resistive sensors like rotary potentiometers, slide potentiometers, force-sensitive resistors (FSRs), flex sensors (Nintendo Power Glove!), softpot position sensors, and more!
-
-
-
-
### Code
- [Graphing Analog Input](https://makecode.com/_TbV5Tx22rdTh). Graphs the A1 value between 0-1023 in console and uses onboard NeoPixels as a graph
diff --git a/cpx/button-piano.md b/cpx/button-piano.md
index cc405d9..893be8c 100644
--- a/cpx/button-piano.md
+++ b/cpx/button-piano.md
@@ -19,6 +19,12 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** A preview of what we'll build: a Button Piano in MakeCode that plays tones and lights NeoPixels from the CPX's built-in A and B buttons. [Full code](https://makecode.com/_EyqF3g3xb6Cy).
+{: .fs-1 }
+
In this lesson, we will make our first interactive CPX program in MakeCode—a simple Button Piano—which makes sounds when we press the CPX's built-in buttons.
-## Video Tutorial
-
-
-
-
-
-**Video.** Creating a button piano. Here's [the full code](https://makecode.com/_EyqF3g3xb6Cy) and a [link to the video on YouTube](https://youtu.be/wCSWP6PhNvY).
-{: .fs-1 }
-
## Code
Here's the final [code](https://makecode.com/_EyqF3g3xb6Cy). Right-click on the code below and select "Open link in a new tab" to open it directly in the MakeCode editor.
diff --git a/cpx/capacitive-touch.md b/cpx/capacitive-touch.md
index 8e36d64..66b85c7 100644
--- a/cpx/capacitive-touch.md
+++ b/cpx/capacitive-touch.md
@@ -19,16 +19,18 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** In this lesson, we'll explore capacitive touch sensing on the CPX—building a touch "piano," visualizing raw capacitance and touch-threshold values, and calibrating touch sensitivity.
+{: .fs-1 }
+
In Lesson 5 in our CPX series, we will learn how to use capacitive touch sensing. This is a multi-part series starting with an introduction to capacitive sensing.
## Lesson 5.1: Intro to Capacitive Touch on the CPX
In this lesson, we will first introduce the concept of capacitive sensing before building a simple capacitive touch "piano." We will then show how to visualize the raw capacitance values and capacitance touch threshold values, which are used to trigger capacitance events. Third, we cover how to use both auto-calibration and manual calibration to change the capacitance touch threshold before building a capacitive-responsive instrument (similar to [Lesson 4: Light-Responsive Instrument](sensor-instrument.md)).
-
-
-
-
### Lesson 5.1 Code
Here is a link to the programs we built in Lesson 5.1.
diff --git a/cpx/cpx-keyboard.md b/cpx/cpx-keyboard.md
index 230790a..2d447e4 100644
--- a/cpx/cpx-keyboard.md
+++ b/cpx/cpx-keyboard.md
@@ -19,6 +19,12 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** Coming up: the CPX as a programmable USB keyboard built in MakeCode—from simple A and B button presses to a media-controller keyboard and even an accelerometer keyboard.
+{: .fs-1 }
+
In Lesson 6 of our CPX series, we will learn how to use the CPX as a programmable keyboard. We'll begin by making the A and B buttons into keyboard presses and then create increasingly fun and interesting keyboards, including a media controller keyboard (Lesson 6.2) and an accelerometer-based keyboard (Lesson 6.3).
{: .note }
@@ -28,10 +34,6 @@ Note: there is some overlapping content with [Lesson 5.3: Making a Capacitive Ke
In this lesson, we will show how to use the CPX as a programmable keyboard
-
-
-
-
### Lesson 6.1 Code
Here's a link to the MakeCode we wrote in this lesson:
diff --git a/cpx/cpx-mouse.md b/cpx/cpx-mouse.md
index 8f14fa3..7c55042 100644
--- a/cpx/cpx-mouse.md
+++ b/cpx/cpx-mouse.md
@@ -19,16 +19,18 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** The CPX working as a USB mouse, which we'll build in this lesson—first nudging the cursor with the A and B buttons, then steering it continuously by tilting the board.
+{: .fs-1 }
+
In Lesson 7 of our CPX series, we will learn how to use the CPX as a programmable mouse. We'll begin by making a discrete mouse that shifts the mouse cursor by small amounts with button A and B presses before building a more complex accelerometer-based mouse with continuous input.
## Lesson 7.1: Making a Programmable Mouse
In this lesson, we will show how to use the CPX as a programmable mouse.
-
+**Video.** By the end of this lesson, you'll wire external buttons to the CPX—and understand the floating-pin problem and how pull-up and pull-down resistors solve it.
+{: .fs-1 }
+
In Lesson 9, we continue exploring how to hook up and use external electronics with our CPX. In Lesson 8, we worked with analog input—which converts voltage signals from 0 - 3.3V to 0 - 1023. In Lesson 9, we'll work with **digital input**, which converts voltage input signals to either ON (1) or OFF (0). This is useful for components like buttons.
## Lesson 8.1: Overview of Digital Input
In this lesson, we learn about _what_ is **digital input** and _how_ to use it on the Circuit Playground Express (CPX). We begin similarly to our [analog input lessons](analog-input.md): introducing the 3.3V, GND, and A1 CPX connection pads and showing how the **digital read** function responds to different input voltages (e.g., 3.3V, GND).
-
-
-
-
## Lesson 8.2: Hooking up Buttons to the CPX & Why Pull-down Resistors?
In this video, we introduce a solution to the "floating pin" problem using pull-down resistors and hook up our first button to the CPX.
diff --git a/cpx/makecode.md b/cpx/makecode.md
index f4f5977..09db229 100644
--- a/cpx/makecode.md
+++ b/cpx/makecode.md
@@ -19,16 +19,16 @@ usetocbot: true
{:toc}
---
-In this lesson, we will make our first MakeCode+CPX program—called Blinky—which will play a sound effect at the start and then repeatedly flash lights. As we build, we will learn about the MakeCode programming environment, the simulator, and how to load our program on to the CPX.
-
-## The MakeCode Programming Environment
-
-**Video.** Rapidly creating a full program with MakeCode: a simple rainbow animation. [Code link](https://makecode.com/_8uY3D8Fc8A5t).
+**Video.** A taste of MakeCode—the block editor we'll use all lesson—here building a quick rainbow NeoPixel animation just by dragging blocks. [Code link](https://makecode.com/_8uY3D8Fc8A5t).
{: .fs-1 }
+In this lesson, we will make our first MakeCode+CPX program—called Blinky—which will play a sound effect at the start and then repeatedly flash lights. As we build, we will learn about the MakeCode programming environment, the simulator, and how to load our program on to the CPX.
+
+## The MakeCode Programming Environment
+
MakeCode is a visual programming language—like [Scratch](https://scratch.mit.edu/)—built on [Blockly](https://developers.google.com/blockly). As the video above shows, to program the CPX, you simply drag-and-drop "puzzle pieces." We call these pieces *blocks.* As you fit blocks together, you can create interactive programs!
diff --git a/cpx/sensor-instrument.md b/cpx/sensor-instrument.md
index 6fa06e6..a7e08b0 100644
--- a/cpx/sensor-instrument.md
+++ b/cpx/sensor-instrument.md
@@ -19,19 +19,16 @@ usetocbot: true
{:toc}
---
-In this lesson, we will build on our last lesson—the [Button Piano](button-piano.md)—to make an interactive instrument that translates light levels into sound and light. It won't sound great but it will sound fun!
-
-
-
-## Video Tutorial
-
-
+
-
-**Video.** Creating a light sensor instrument. Here's [the full code](https://makecode.com/_drYKXH5UeV1r) and a [link to the video on YouTube](https://youtu.be/RlEPQqyQGEk).
+**Video.** Where we're headed: a light-level instrument that turns light readings into sound and color using the CPX's onboard light sensor, speaker, and NeoPixels. [Full code](https://makecode.com/_drYKXH5UeV1r).
{: .fs-1 }
+In this lesson, we will build on our last lesson—the [Button Piano](button-piano.md)—to make an interactive instrument that translates light levels into sound and light. It won't sound great but it will sound fun!
+
+
+
## Code
Here's the final [code](https://makecode.com/_2dVi02gquH6h). Right-click on the code below and select "Open link in a new tab" to open it in the MakeCode editor.
diff --git a/electronics/electricity-basics.md b/electronics/electricity-basics.md
index c7bae5c..610fe38 100644
--- a/electronics/electricity-basics.md
+++ b/electronics/electricity-basics.md
@@ -20,6 +20,12 @@ usetocbot: true
{:toc}
---
+
+**Video.** Where we're headed: this lesson uses intuitive water analogies—like this water tank, where a higher water level (voltage) pushes more water (current) out the bottom—to build up the three foundational concepts of voltage, current, and resistance.
+{: .fs-1 }
+
In this lesson, we are going to learn about three key electricity concepts, **current**, **voltage**, and **resistance**, which form the foundation of electronics and circuits. We will also use an online circuit simulator to play with basic components and advance understanding.
But first—what is a circuit? A **circuit** is a closed loop that provides a path for electric current to flow. At minimum, a circuit requires a voltage source (*e.g.,* a battery), a conductive path (*e.g.,* wires), and a load (*e.g.,* a light bulb or resistor) that does useful work. If the loop is broken at any point, current cannot flow and we call it an "open circuit" (more on this [later](#what-is-an-open-circuit)).
diff --git a/electronics/ohms-law.md b/electronics/ohms-law.md
index 0a34e63..8a0b1b0 100644
--- a/electronics/ohms-law.md
+++ b/electronics/ohms-law.md
@@ -20,6 +20,10 @@ usetocbot: true
{:toc}
---
+
+**Figure.** Coming up: Ohm's Law ($$I = \frac{V}{R}$$) ties voltage, current, and resistance together—and, as we'll see, it's the electrical twin of Poiseuille's Law for water flowing through a pipe.
+{: .fs-1 }
+
In this lesson, we will learn about **Ohm's Law**, one of the most important empirical laws in electrical circuits that describes how *current*, *voltage*, and *resistance* relate together. While Ohm's Law is incredibly useful in analyzing and understanding how circuits work, like many "laws", it is not always obeyed (particularly for what are called "non-ohmic" devices like LEDs or other diodes—which we will explore in [Lesson 6: LEDs](leds.md)).
For now, on to Georg Ohm's Law!
diff --git a/electronics/schematics.md b/electronics/schematics.md
index f1ecd2d..f962aba 100644
--- a/electronics/schematics.md
+++ b/electronics/schematics.md
@@ -20,6 +20,10 @@ usetocbot: true
{:toc}
---
+
+**Figure.** A preview of what we'll build: by the end of this lesson, you'll be able to read and draw circuit schematics using standardized component symbols like these—the visual language of electronics.
+{: .fs-1 }
+
Before going any further, it's useful to introduce [**circuit schematics**](https://en.wikipedia.org/wiki/Circuit_diagram), which are diagrammatic abstractions of circuits—this will allow us to "speak" about and describe circuits **visually**.
Unlike the more realistic pictorials that we have used thus far (*e.g.,* like [this](assets/videos/ElectronFlowVsConventionalCurrent_PhetSimulation_ByJonFroehlich.mp4) or [this](assets/videos/WaterCircuitAnalogy_Trimmed_ByJonFroehlich.mp4)), circuit schematics are the [*lingua franca*](https://learning.oreilly.com/library/view/practical-electronics-components/9781449373221/app02.html) of electronics—they are compact, standardized, visual representations of circuits. You'll find them in electronic datasheets, CAD layout software, and circuit analysis.
diff --git a/esp32/iot.md b/esp32/iot.md
index e337e89..298450a 100644
--- a/esp32/iot.md
+++ b/esp32/iot.md
@@ -19,6 +19,12 @@ nav_order: 7
{:toc}
---
+
+
+
+**Video.** A preview of what we'll build: an ESP32 reading a photoresistor and streaming the light level to an Adafruit IO dashboard that updates live over WiFi. Make sure your sound is on.
+{: .fs-1 }
+
{: .warning }
> This lesson is in draft form. There is missing circuit diagrams, images, videos, and other content.
diff --git a/esp32/led-blink.md b/esp32/led-blink.md
index 109a7dc..f392974 100644
--- a/esp32/led-blink.md
+++ b/esp32/led-blink.md
@@ -20,6 +20,12 @@ nav_order: 2
{:toc}
---
+
+**Video.** By the end of this lesson, you'll have your ESP32 blinking on its own—starting with the onboard red LED shown here, then an external LED, the Wokwi simulator, and the colorful onboard NeoPixel.
+{: .fs-1 }
+
In this lesson, we'll write our first ESP32 program: blinking an LED! If you've completed the Arduino [Blink lesson](../arduino/led-blink.md), you'll find that the code is *identical*—the beauty of the Arduino ecosystem. The challenge here is getting comfortable with the new board's pin layout and the 3.3V operating voltage.
We'll start with the **onboard LED** (no wiring required!), then move to an **external LED circuit**, try it in the **Wokwi simulator**, and finish with a fun bonus: blinking the **onboard NeoPixel** in any color you want. 🌈
@@ -77,14 +83,6 @@ Upload this sketch and open the **Serial Monitor** at **115200 baud**. You shoul
{: .warning }
> **Native USB gotcha (ESP32-S3):** Because the ESP32-S3 uses native USB (not a separate USB-to-UART chip like the Uno's ATmega16U2 or the Huzzah32's CP2104), the serial port will **temporarily disappear** if the board crashes, resets, or enters deep sleep. If your Serial Monitor disconnects unexpectedly, just press the **Reset** button and reopen it. This is normal behavior for native USB—it's the same with the Arduino Leonardo.
-### Workbench video blinking built-in LED
-
-
-**Video.** A workbench video of blinking the built-in LED on the Adafruit ESP32-S3.
-{: .fs-1 }
-
## Part 2: Blink an external LED
Now let's connect an external LED—this is where you'll practice reading the pin diagram and wiring up a real circuit (again, mirroring our [Blink lesson](../arduino/led-blink.md) in the "Intro to Arduino" series).
diff --git a/esp32/tone.md b/esp32/tone.md
index d7028dc..ff981e9 100644
--- a/esp32/tone.md
+++ b/esp32/tone.md
@@ -19,6 +19,12 @@ nav_order: 5
{:toc}
---
+
+
+
+**Video.** A taste of what's ahead: an ESP32 playing a C major scale on a passive piezo buzzer. By the end of this lesson you'll be playing scales, melodies, and even the Imperial March. Make sure your sound is on.
+{: .fs-1 }
+
-
-
So far, every output we've produced in the ESP32 module has been visual—turning LEDs on, off, fading, and reading analog input. In this lesson, we'll add a completely new output modality: **sound!** Using a piezo buzzer and the `tone()` function, we'll learn how to play individual notes, scales, and even melodies on the ESP32.
If you completed our [Intro to Arduino tone lesson](../arduino/tone.md), you'll be happy to know that `tone()` and `noTone()` now work on the ESP32 in **Arduino core v3.x**—the code is nearly identical! But we'll also explore the ESP32's more powerful alternative: the **LEDC tone functions** (`ledcWriteTone` and `ledcWriteNote`), which give you additional control and work directly with the same PWM hardware we used in [Lesson 3](led-fade.md).
diff --git a/sensors/hall-effect.md b/sensors/hall-effect.md
index 842edf5..d06ddd0 100644
--- a/sensors/hall-effect.md
+++ b/sensors/hall-effect.md
@@ -19,6 +19,12 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** Where we're headed: an Arduino-driven "magical magnetic LED brightener" that smoothly fades an LED up and down as you move a magnet past a DRV5055 Hall effect sensor.
+{: .fs-1 }
+
In this lesson, you will learn about two types of magnetic sensors: Hall effect sensors and reed switches. You will then use a [DRV5055](http://www.ti.com/lit/ds/symlink/drv5055.pdf) Hall effect sensor to build a simple auto-brightening LED circuit first without and then with a microcontroller.
## Introduction
diff --git a/sensors/photoresistors.md b/sensors/photoresistors.md
index 87acc94..1f55467 100644
--- a/sensors/photoresistors.md
+++ b/sensors/photoresistors.md
@@ -19,6 +19,12 @@ usetocbot: true
{:toc}
---
+
+
+
+**Video.** By the end of this lesson, you'll have built an Arduino auto-on nightlight that brightens an LED as the room around it gets darker, all driven by a humble photoresistor.
+{: .fs-1 }
+
In this lesson, you'll learn about [photoresistors](https://en.wikipedia.org/wiki/Photoresistor) and how to use them with and without microcontrollers.
## Photoresistors