The Full Lesson Plan
The 15-session plan, ready to print.
Free for parents and teachers.
The 15-session plan, ready to print.
Free for parents and teachers.
A course where the result comes before the theory: in every session the teams wire real parts, type real C++ code - and leave with something that works. Concepts (algorithm, microcontroller, analog, binary) arrive exactly when they’re needed, and not a moment before. The course is built for a full classroom: 20-30 students, in fixed teams of 4-5, with one instructor and a projected screen.
The classroom currency is the chip - a team point recorded in a table on the board:
There are no printed code sheets in this course. The instructor projects their screen onto the board, writes and runs everything live - and the teams type along on the team computer. The typing itself is the learning: a typo that breaks compilation is an excellent C++ lesson. Every session follows the same four-step path:
| Time | Phase | What Happens |
|---|---|---|
| 00-05 | Opening | Curiosity hook: a question, a quick experiment, or a real-life object tied to today’s concept. |
| 05-13 | Projected Demo | The instructor wires and codes live on the screen. One new concept - no more. |
| 13-35 | Building in Teams | The heart of the session. The instructor circulates among the 6-7 stations, pointing and asking - not touching. |
| 35-42 | Stage Moment | Each team demos for 30-60 seconds. Applause is a must. |
| 42-45 | Wrap-up and Cleanup | A teaser sentence for the next session + organized teardown by the kit map. |
| Big idea | Enters in session |
|---|---|
| How a computer works · What a microcontroller is | 1 |
| What an algorithm is · What C++ is and what compiling means | 2 |
| Logic and conditions · Input → Decision → Output | 3 |
| Analog vs. digital · Sensors | 4, 8 |
| Functions · Libraries · Protocols (I2C, SPI) | 6, 7, 11 |
| Bits, bytes, and binary - how a computer remembers | 12 |
| Product engineering: spec → build → testing | 13-15 |
Never fix wiring or code for the team. Point, ask “What does this LED need in order to light up?” - and let them do it. An achievement that belongs to them stays with them.
Manage the time so even the slowest team leaves with something that works. A working two-light traffic light beats a perfect one that never got finished.
When something doesn’t work, say out loud: “Great, we have a bug!” and model systematic debugging: isolate → print to the Serial Monitor → change one thing at a time. The class learns that a fault is a stage, not an end.
In a team of 4-5 everyone has a role: wirer, coder, navigator, tester, presenter - and they rotate every session. That way no student just watches, and no one takes over.
45 minutes = one new idea. Everything else is practice of what’s already there. If you’re unsure whether to add an explanation - don’t.
“What happens if we increase the number?” beats “The number determines the time.” Prediction → experiment → conclusion: the scientific method in miniature.
In 45 minutes there is no dead moment. Use a visible timer for the session phases and announce transitions: “5 more minutes until we go on stage!”
Every team presents in every session, even if the result is partial. Present in CHIPS language: what we built, what was hard, what we’ll improve. Applause - always.
Low voltage only (USB and batteries). The iron rules: never connect to wall power · wire only when USB is unplugged · keep drinks away from the table. Safety is a habit, not a scare tactic.
One raised hand = everyone stops and looks at the screen. Parts are handed out ahead of time in team boxes; spares stay with the instructor only. Biggest noise risk: the buzzers - they play only when the winner signals.
The kit identification map - for each part: what it looks like, what it does, and when you’ll meet it. This is the page to open when you pick up an unfamiliar part, and it’s also the storage order: every part returns to its own compartment at the end of the session. One kit per team (6-7 kits per class) + an instructor kit for demos.
| # | Session | Today’s Result | New concepts |
|---|---|---|---|
| 0 | Equipment Prep For the instructor, before the kids arrive | Every computer installed, recognized, and blinking | IDE, driver, CH340 |
| 1 | Launch Pad | Development environment installed + first blink on a real board | Microcontroller, IDE, driver |
| 2 | The Kingdom on the Board | Working LED-resistor circuit on a breadboard | Circuit, algorithm, C++ |
| 3 | A Real Traffic Light | Traffic light with a pedestrian button | Digital input, if/else |
| 4 | The Analog World | Dimmer + automatic night light | analogRead, PWM, map |
| 5 | Making Noise | Button piano + class performance | Frequency, tone() |
| 6 | The Color Lamp | Mood lamp with a signature color | RGB, functions, for |
| 7 | The Screen Talks | Digital name tag on an LCD | I2C, libraries, addresses |
| 8 | Weather Station | Live temperature and humidity gauge on the screen | Sensors, float variables |
| 9 | Machines That Move | Servo controlled by a joystick | Motors, angles, Servo.h |
| 10 | The Vault | Code vault: keypad + screen + servo + buzzer | Strings, integration |
| 11 | The Magic Card | Access control with RFID | UID, SPI, permissions |
| 12 | Drawing with Light | Pixel art and animation on a matrix | Bit, byte, binary |
| 13 | Final Project · Planning | Full spec + first part wired | Spec, prototype |
| 14 | Final Project · Building | A project that passes the acceptance test | Debugging, testing, MVP |
| 15 | CHIPS Showcase Night | Live demo for parents + certificates | Pitch, reflection |
Fundamentals: development environment, first circuits, digital and analog input. Building confidence and hands-on skills.
A chain of products: sound, color, screen, sensors, motors, a vault, RFID, and a matrix - a new skill every week.
Final project on the theme “Technology That Helps People” - from planning to a showcase night in front of the parents.
| 00-03 | Why This Comes First | A computer that isn’t ready when the kids arrive costs 10 minutes of every future session - and those 10 minutes drain away the excitement. The mission of this session: every computer reaches Session 1 already blinking. |
| 03-10 | Installing Arduino IDE 2 | From the USB drive (no dependence on school internet): run the matching installer - .exe on Windows, .dmg on Mac. Windows: Next, Next, Finish, and approve every “Install this driver software anyway” prompt that pops up. Mac: after installing, on first launch you’ll usually be asked for permission under System Settings ← Privacy & Security - click Allow there. |
| 10-20 | Board Driver - CH340 | Our boards are Arduino-compatible (not the official brand) and use a CH340 communication chip instead of the official one - perfectly fine, they just need their own driver. Plug a board in over USB and check Device Manager (Windows): under Ports (COM & LPT), do you see USB-SERIAL CH340 (COM5)? Great, you’re done. A yellow exclamation mark under Other devices? Run CH341SER.EXE from the drive, click INSTALL, unplug the board and plug it back in, then check Device Manager again. On Mac: it usually recognizes the board right away; if not, it needs manual approval, as in the previous step. |
| 20-28 | Choosing Board and Port | Tools ← Board ← Arduino Uno (if it isn’t listed, first install the Arduino AVR Boards package through Board Manager in the same menu). Then Tools ← Port - choose exactly the COM port we identified in the previous step. These two choices are the most common source of upload errors - always check them first. |
| 28-36 | The First Blink | Open File ← Examples ← 01.Basics ← Blink. Click ✓ (Verify) to make sure the code compiles without errors, then → (Upload). During upload, the TX/RX LEDs on the board blink fast - that’s normal. A few seconds later, the L LED on the board blinks. That’s the moment to take a photo and mark ✔ for this computer. |
| 36-42 | Know the Screen | Four areas every team will recognize from the first session: the code area (center), the ✓ Compile and → Upload buttons (top left), the status bar that reports “Done compiling” / “Done uploading” or an error (bottom), and the black console that prints details (very bottom). The magnifying-glass icon at the top right opens the Serial Monitor - we’ll need it in Session 4. |
| 42-45 | Final Checklist | For every computer arriving at Session 1: IDE installed ✔ · board recognized in Device Manager ✔ · Blink uploaded and running ✔ · USB cable marked as data-capable (not charge-only) ✔. Keep 1-2 spare boards + cables that have been tested and work - a computer that gets stuck mid-session is a disruption, not a teachable moment. |
| IDE | The software where you write code and send it to the board. |
| Driver | A small program that teaches the computer to talk to the board. |
| CH340 | The communication chip in our compatible boards - needs a separate driver from the official brand. |
| Device Manager | A Windows tool that shows which USB devices the computer detects, and on which port. |
| COM Port | The virtual “socket” through which the computer recognizes the board. |
| Compile | Translating the code we wrote into the chip’s machine language, before uploading. |
| Upload | Sending the translated program from the computer to the board. |
| Phase | Status |
|---|---|
| Arduino IDE 2 installed | ☐ |
| Board connected, recognized in Device Manager | ☐ |
| CH340 driver installed (if needed) | ☐ |
| Board: Arduino Uno selected | ☐ |
| Port: correct COMx selected | ☐ |
| Blink uploaded and actually running | ☐ |
| USB cable marked “data-capable” | ☐ |
void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED_BUILTIN, HIGH); delay(500); digitalWrite(LED_BUILTIN, LOW); delay(500); }
| 00-06 | Opening | Hold up the board: “This is a whole computer - for the price of a burrito.” Three minutes on how a computer works: processor (thinks) · memory (remembers) · input/output (senses and responds). A microcontroller is exactly that, squeezed onto a single chip - and it’s in the microwave, the kettle, the air conditioner, and the remote. Today we learn to command it. |
| 06-14 | Guided Installation | The instructor projects their screen and performs each step themselves - and every team (one computer per team) mirrors it step by step: install Arduino IDE 2 from the file on the USB drive (no dependence on school internet). Windows: Next, Next, Finish; approve the USB component installation. Together on the projected screen, identify: the code area, ✓ Compile, → Upload, and the console at the bottom. |
| 14-24 | The Board Driver | Connect the board over USB. Our boards are Arduino-compatible (CH340 communication chip) - perfectly fine, they just need their own driver. Check Device Manager under Ports: do you see USB-SERIAL CH340 (COM5)? Great. Yellow exclamation mark? Run CH341SER.EXE from the drive (INSTALL), then unplug and reconnect. On Mac: it usually works right away. |
| 24-38 | The First Blink | Choose Tools ← Board ← Arduino Uno and Tools ← Port → the COM port we identified. Open File ← Examples ← Basics ← Blink and click →. A few seconds later, the L LED on the board blinks! Now change the two delay numbers to create a personal “blink signature,” and upload again. Every team that succeeds earns the first chip on the board. |
| 38-43 | Stage Moment | “LED choir”: line up all the boards in a row, and each team says which rhythm they chose and why. Challenge question for the class: where else is a microcontroller hiding in your home? (Hint: more than ten.) |
| 43-45 | Wrap-up and Cleanup | Unplug gently, coil the cable, put the board back in the box. Teaser: “Today the board blinked on its own. Next week we’ll build it a circuit of our own - with our hands.” |
| Microcontroller | A tiny computer on a single chip: processor, memory, and input/output - without a screen or keyboard. |
| Development Environment IDE | The software where you write code and send it to the board. |
| Driver | A small program that teaches the computer to talk to the board. |
| Sketch | What a program is called in Arduino. |
| Compile | Translating our code into the chip’s machine language. |
| Upload | Sending the program from the computer to the board. |
| Port | The “socket” through which the computer recognizes the board. |
| Part / Pin | Pin |
|---|---|
| Arduino IDE 2 + CH341SER on the USB drive | ✔ |
| Install permissions on the computers | ✔ |
| A working USB cable for every team | ✔ |
| Board: Arduino Uno | ✔ |
| Port: COMx / usbserial | ✔ |
void loop() { digitalWrite(LED_BUILTIN, HIGH); delay(200); // my rhythm digitalWrite(LED_BUILTIN, LOW); delay(800); }
| 00-05 | Opening | “Human robot” game: a student directs the instructor to make a sandwich with precise instructions - and the instructor carries out every vague instruction literally. Takeaway: a computer does exactly what it’s told. That’s an algorithm, and when we write it in a language the chip understands - that’s C++. |
| 05-13 | Demo | The breadboard secret: hold one up and show (in a picture or an open model) the metal strips - every row of 5 holes is connected inside; the + and − rails run along the length. The LED: long leg to plus. The resistor: no direction, but without it the LED burns out - it’s the current’s “traffic cop.” |
| 13-33 | Build | Step 1: a circuit with no code - 5V → resistor → LED → GND. Lit up? Victory photo and a chip. Step 2: move the wire from 5V to pin 8, load the code - and now the code lights the LED. Step 3: change the rhythm, and whoever finishes early adds a second LED on another pin. |
| 33-41 | Stage Moment | Each team demonstrates and says one sentence: “The LED is on because...” A short story: the transistor (1956 Nobel Prize) and the blue LED (2014) - the inventions that make screens and computers possible. |
| 41-45 | Wrap-up and Cleanup | Take everything apart by the kit map - every part goes back to its own compartment. Teaser: “Our circuit is dumb: it’s always on. Next week we’ll give it a button - and it will start to listen.” |
| Electric circuit | A closed loop that current can flow around - from + to −. |
| Breadboard | An experiment board: rows of holes connected inside, no soldering. |
| Resistor | A part that limits current - the LED’s bodyguard. |
| Polarity | An LED has a direction: long leg + (anode), short leg − (cathode). |
| Algorithm | A list of precise instructions carried out in order. |
| C++ | The programming language used to write for Arduino - a language of real engineers. |
| Part / Pin | Pin |
|---|---|
| LED - long leg (+) | D8 |
| LED - short leg (−) | Resistor |
| Resistor - other side | GND |
| (Step 1: instead of D8) | 5V |
void setup() { pinMode(8, OUTPUT); } void loop() { digitalWrite(8, HIGH); delay(300); digitalWrite(8, LOW); delay(300); }
| 00-05 | Opening | “Who programmed the traffic light near your house?” - somebody did! Quick quiz: what’s the order of the colors? (green → yellow → red → green). Today we’re the city engineers. |
| 05-12 | Demo | Until today the board only talked. Today it listens: a button closes a circuit, and the code reads it with digitalRead. Demonstrate wiring a button straddling the breadboard’s center channel + a 10kΩ resistor to GND (without it the input “floats” and goes haywire). Then three lines of if - and the class sees a printout in the console on every press. |
| 12-35 | Build | Step 1: three LEDs on pins 2/3/4, an automatic traffic light on a fixed cycle. Step 2: add a button on pin 7 and a condition - a press switches from green to yellow, to red with crossing time, and back. Step 3: calibrate the timing like a real traffic light. Teams swap roles: wirer and programmer. |
| 35-42 | Stage Moment | Act out “crossing the street”: one student is the pedestrian, another presses the button. Stage question: what would happen without the yellow? (Hint: screeching brakes.) |
| 42-45 | Wrap-up and Cleanup | Teaser: “The button only knows yes/no. Next week we’ll meet parts that can say how much - and we’ll control light brightness like a dimmer in a living room.” |
| Input | Information that comes into the board from the world - a press, light, temperature. |
| Output | What the board does in the world - lights up, buzzes, moves. |
| HIGH / LOW | The only two words in the digital world: voltage / no voltage. |
| Condition if / else | “If X happens - do Y, otherwise - Z.” The heart of every program. |
| Variable | A named box that stores a value, such as the button’s state. |
| Pull-down | A resistor that holds the input at a clear LOW when the button isn’t pressed. |
| Part / Pin | Pin |
|---|---|
| Green LED (+ through resistor) | D2 |
| Yellow LED (+ through resistor) | D3 |
| Red LED (+ through resistor) | D4 |
| Push button - pin A | 5V |
| Push button - pin B | D7 |
| D7 → 10kΩ resistor | GND |
if (digitalRead(7) == HIGH) { green(LOW); yellow(HIGH); delay(1000); yellow(LOW); red(HIGH); delay(5000); // crossing time red(LOW); green(HIGH); }
| 00-05 | Opening | Quick poll: which things at home are “how much” and not “yes/no”? (Volume, air conditioner, screen brightness, faucet.) Our button only knows two words. Today we teach the board to count up to 1023. |
| 05-13 | Demo | Connect a potentiometer to A0, open the Serial Monitor - and turn: the numbers run live on the screen. Then the light sensor: cover it with your hand and the number plummets. One slide on PWM: “The board blinks 490 times a second - your eye does the averaging.” |
| 13-35 | Build | Step 1: dimmer - potentiometer on A0, LED on pin 9(~), three lines with map. Step 2: swap the potentiometer for a light sensor + 10kΩ resistor (voltage divider) - night light: dark = bright light. Step 3: calibrate the threshold with the Serial Monitor - each team finds its own classroom’s number. |
| 35-42 | Stage Moment | “Mood mode”: turn off the classroom lights - each table lights up on its own, gradually. Each team shares the threshold value it found and why it differs from table to table (distance from the window!). |
| 42-45 | Wrap-up and Cleanup | Teaser: “We controlled light. Next week the board starts making noise - we’re building instruments.” |
| Analog | A continuous signal with infinite values - how much, not just yes/no. |
| ADC | The on-chip converter that turns voltage into a number from 0 to 1023. |
| PWM | Blinking so fast the eye sees dimming - that’s how we “invent” an analog output. |
| map() | A function that stretches one range onto another (1023 → 255). |
| Serial Monitor | A window where the board prints what it “feels” - debugging tool #1. |
| Sensor | A part that converts a physical phenomenon (light, heat) into an electrical signal. |
| Part / Pin | Pin |
|---|---|
| Potentiometer - outer pins | 5V · GND |
| Potentiometer - middle pin | A0 |
| LED (+ through resistor) | D9 (~) |
| LDR - pin A | 5V |
| LDR - pin B + 10kΩ resistor to GND | A0 |
int v = analogRead(A0); // 0-1023 Serial.println(v); int b = map(v, 0,1023, 0,255); analogWrite(9, b); // PWM
| 00-05 | Opening | The instructor plays three frequencies on the buzzer - low, medium, high. “What changed?” Together you arrive at the word frequency. Trivia: a dog hears up to 45,000Hz, we hear up to 20,000 - play 15,000Hz and enjoy seeing who can still hear it. |
| 05-12 | Demo | Buzzer wiring (+ to pin 8, − to GND) and two commands: tone / noTone. Note frequency table on the board: C=262, D=294, E=330, F=349, G=392. Demo “Mary Had a Little Lamb” in six lines of code. |
| 12-33 | Build | Step 1: auto scale - the buzzer plays C-D-E in a loop. Step 2: connect 3 buttons (pins 2/3/4) - each button is a note: a piano is born. Step 3: each team gets a part in the class song and practices its section. |
| 33-42 | Stage Moment | The orchestra: the instructor conducts, each team plays its part in turn - “like a choir made of boards.” Try twice, film the second take. It’s the video parents love to get most. |
| 42-45 | Wrap-up and Cleanup | Teaser: “Today we controlled sound. Next week we’ll control color - every color in the world from three lights.” |
| Frequency | How many vibrations per second. Measured in hertz (Hz). |
| Hertz | The unit of frequency: 262Hz = the note C. |
| Passive Buzzer | A tiny speaker that plays any frequency sent to it. |
| tone() | The command that vibrates the buzzer at the frequency we choose. |
| Array | A list of values in one box - for example, all the melody’s frequencies. |
| Timing | Music is frequency + time: which note, and for how long. |
| Part / Pin | Pin |
|---|---|
| Buzzer + | D8 |
| Buzzer − | GND |
| Button 1 / 2 / 3 | D2 · D3 · D4 |
| Each button → 10kΩ resistor | GND |
if (digitalRead(2)==HIGH) tone(8, 262); // C else if (digitalRead(3)==HIGH) tone(8, 294); // D else noTone(8);
| 00-05 | Opening | Get close to the screen with a drop of water or a phone camera: you can see red, green and blue dots! Every picture you’ve ever seen on a screen is three colors at different intensities. Today we build one giant pixel. |
| 05-12 | Demo | Our ready-made RGB module has 4 labeled pins R·G·B·− (the resistors are already on the module - an advantage over a single LED). Demo: (255,0,0) red, (255,120,0) orange, (255,0,255) purple, (255,255,255) white. The class guesses each combination before you run it. |
| 12-35 | Build | Step 1: wire to pins 9/10/11 and write our first function - setColor. Step 2: each team finds its “signature color” by experimenting with values. Step 3: gradual fade with for - a breath from blue to purple. Step 4 (optional): the potentiometer turns the color through the whole rainbow. |
| 35-42 | Stage Moment | Lights off: class color party - each team shows its signature color and its effect, and the class guesses the recipe (a lot of red? a little blue?). |
| 42-45 | Wrap-up and Cleanup | Teaser: “Until now it was all light and sound. Next week the board starts talking to us in words - a real screen.” |
| RGB | Red, green, blue: the three primary colors of light. |
| Channel | A separate control line for each color - each channel has its own intensity. |
| Function | A package of code with a name that you can call again and again. |
| Parameter | The values passed to a function - setColor(255,0,0). |
| for loop | A loop that counts - perfect for gradual color transitions. |
| (255,0,0) Color Value | The trio of intensities that defines a color. White = everything at maximum. |
| Part / Pin | Pin |
|---|---|
| Module R | D9 (~) |
| Module G | D10 (~) |
| Module B | D11 (~) |
| Module − | GND |
| Potentiometer middle pin (optional) | A0 |
void setColor(int r,int g,int b){ analogWrite(9, r); analogWrite(10, g); analogWrite(11, b); } // breathing fade: for(int i=0;i<255;i++){ setColor(0, 0, i); delay(8); }
| 00-05 | Opening | “A computer screen takes dozens of wires. We’ll connect a screen with four.” How? Like in class: everyone on the same line, everyone has a name, and you speak only when someone calls on you. That’s I2C - and in a moment we’ll see it work. |
| 05-14 | Demo | Wire together: GND·VCC·SDA·SCL to GND·5V·A4·A5. Install the library: Library Manager → search LiquidCrystal I2C ← Install. Four lines of code - and “Hello, class!” on the screen. If the screen is blank: turn the contrast screw on the back, and check address 0x27/0x3F. |
| 14-35 | Build | Step 1: digital name tag - name on line 1, nickname or text emoticon on line 2. Step 2: live text - a running seconds counter with lcd.setCursor. Step 3: connect the potentiometer to A0 and show its value on the screen in real time - the screen becomes a measuring tool. |
| 35-42 | Stage Moment | Name tag round: each team shows its screen. Quick class challenge: who can make the text “run” from side to side? (Hint: loop + setCursor + delay.) |
| 42-45 | Wrap-up and Cleanup | Teaser: “We have a screen. Next week we’ll connect a temperature sensor to it - and we’ll have a real weather station.” |
| LCD | Liquid crystal display - 2 lines of 16 characters. |
| I2C | A smart protocol: many parts on just two data wires. |
| SDA / SCL | The two I2C wires: data and clock. |
| Address | The number that identifies each part on the line - ours is 0x27. |
| Library | Ready-made code that engineers wrote before us - you import it and use it. |
| Protocol | An agreed-upon language between parts - like conversation rules in class. |
| Part / Pin | Pin |
|---|---|
| LCD GND | GND |
| LCD VCC | 5V |
| LCD SDA | A4 |
| LCD SCL | A5 |
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
void setup(){
lcd.init(); lcd.backlight();
lcd.print("SHALOM KITA!");
lcd.setCursor(0,1);
lcd.print("CHIPS 2026");
}| 00-05 | Opening | “How many degrees is it in the classroom right now?” Collect guesses on the board - at the end of the session we’ll know who was right. How does an air conditioner know when to stop? It has exactly what we’re about to connect. |
| 05-13 | Demo | Two temperature sensors in the kit: the blue DHT11 (digital, also gives humidity, needs a library) and the black LM35 (analog, simple: 10mV per degree Celsius). Demo both on the Serial Monitor; continue with whatever is in your kits. Demo trick: hold the sensor in your fingers - and the number climbs live. |
| 13-35 | Build | Step 1: read the temperature to the Serial Monitor. Step 2: connect the LCD from the previous session - TEMP: 26.5C on line 1, HUM: 45% on line 2. Step 3: compare tables - why is it warmer by the window? Step 4: alert - above a threshold the class sets, the screen shows HOT and a red LED turns on. |
| 35-42 | Stage Moment | The class heat map: each team reads out its measurement, draw the temperature differences between the corners on the board - and check who guessed closest at the start. Short discussion: where would you put the air conditioner’s sensor? |
| 42-45 | Wrap-up and Cleanup | Teaser: “The board can already see, hear and feel. Next week it starts to move - motors.” |
| DHT11 | A digital sensor that measures temperature and humidity together. |
| Humidity | How much water vapor is in the air, as a percentage. |
| float | A variable for numbers with a decimal point - 26.5. |
| Sampling | One measurement. We measure again and again at a steady rate. |
| Average | Several samples together = a stable reading with no jumps. |
| Calibration | Comparing to a real thermometer and correcting a constant offset. |
| Part / Pin | Pin |
|---|---|
| DHT11 - VCC · DATA · GND | 5V · D2 · GND |
| (or) LM35 - left·middle·right | 5V · A0 · GND |
| LCD | Same as session 7 |
#include <DHT.h> DHT dht(2, DHT11); void loop(){ float t = dht.readTemperature(); float h = dht.readHumidity(); lcd.setCursor(0,0); lcd.print("TEMP: "); lcd.print(t); delay(2000); // DHT is slow }
| 00-05 | Opening | Quick round: which things at home move by themselves? (Garage door, fan, printer, vacuum.) Behind every movement - a motor and a microcontroller. Three motor families in a minute, and two of them are in our kit. |
| 05-13 | Demo | Servo wires: brown=GND, red=5V, orange=signal to pin 6. Three lines with Servo.h - and the arm jumps to 0°, 90°, 180°. Tape a paper arrow to the arm: suddenly it’s a clock hand, a gate, or a pointing hand. The joystick: just two potentiometers (A0, A1) - you already know them from session 4! |
| 13-35 | Build | Step 1: a servo dancing between angles with delay. Step 2: connect the joystick and use map to turn 0-1023 into 0-180 - the arm follows your hand. Step 3: mechanical assembly - an arrow, flag or cardboard barrier on the arm. Step 4 (optional): pressing the joystick (SW) returns it to center. |
| 35-42 | Stage Moment | Precision contest: the instructor calls out an angle - teams aim with the joystick without a protractor, and check with the code who’s closest. Question for the class: where else would you put a servo? (Write the answers down - they’re ideas for the Final Project.) |
| 42-45 | Wrap-up and Cleanup | Disconnect the servo gently - never turn it by hand! Teaser: “Next week we lock this up: a safe with a secret code that only those who know it can open.” |
| Servo | A motor that turns to an exact angle between 0° and 180° and holds it. |
| DC Motor | Spins fast and free - fans and wheels. |
| Stepper Motor | Moves in precise steps - 3D printers. |
| Angle | The position you send the servo to: s.write(90). |
| Joystick | Two potentiometers in one stick - X and Y axes. |
| Servo.h | The built-in library that controls the servo for us. |
| Part / Pin | Pin |
|---|---|
| Servo brown / red / orange | GND · 5V · D6 |
| Joystick VRx | A0 |
| Joystick VRy | A1 |
| Joystick +5V · GND | 5V · GND |
#include <Servo.h> Servo s; void setup(){ s.attach(6); } void loop(){ int x = analogRead(A0); int a = map(x,0,1023,0,180); s.write(a); delay(15); }
| 00-05 | Opening | “Who has a code for the front door or their phone?” - everyone. How does the device know the code is right? And how do 16 keys talk over only 8 wires? Do the math on the board: 4 rows × 4 columns. Clever. |
| 05-13 | Demo | Connect the keypad ribbon to pins 9-2 (in order!), add the Keypad library, and run a demo: every key pressed is printed to the Serial Monitor. Then the magic: compare the sequence to "1234" - and the Serial Monitor answers OPEN or NO. |
| 13-35 | Build | Step 1: read keys and show asterisks on the LCD (like an ATM). Step 2: compare to the password - correct: rising tone + OPEN; wrong: low tone + error counter. Step 3: connect a servo as the lock on pin 11~ (the keypad took 9-2!) - the right password turns it 90°. Step 4: each team picks a new password and hides it. |
| 35-42 | Stage Moment | Safe Heist: each team tries to crack another team’s safe in three attempts. One-minute discussion: how many combinations does a 4-digit code have? (10,000!) And why does a phone lock after a few wrong tries? |
| 42-45 | Wrap-up and Cleanup | Teaser: “You can guess a code. Next week we’ll open the lock with a magic card - without typing anything.” |
| Matrix | A grid of rows and columns - 16 keys on 8 wires. |
| Scanning | The board checks row by row which key is pressed, thousands of times a second. |
| String | A sequence of characters - our password is a string. |
| Comparison | Checking whether the input exactly matches the saved password. |
| Security | What happens after 3 wrong tries? Who knows the code? |
| User Experience UX | Asterisks, sounds, and feedback - how the product feels. |
| Part / Pin | Pin |
|---|---|
| Keypad - 8 ribbon pins | D9…D2 |
| LCD | A4 · A5 |
| Servo - signal | D11~ |
| Buzzer + | D12 |
char key = pad.getKey(); if (key) { input += key; lcd.print("*"); } if (input.length()==4) { if (input=="1234") open(); else wrong(); input = ""; }
| 00-05 | Opening | Hold up a Clipper card or a gym key fob: “How does this work without a battery?!” Opening experiment: pass the card near the instructor’s reader - and the Serial Monitor prints a number. Every card in the class has a different number. That’s the UID. |
| 05-13 | Demo | The physics in a minute: the reader sends out a radio wave, the coil inside the card harvests electricity from it and answers with its number. Guided demo wiring (7 wires, VCC to 3.3V only!), the MFRC522 library, and the DumpInfo sketch - every card that comes close is printed to the Serial Monitor. |
| 13-35 | Build | Step 1: read the UID and print it. Step 2: each team copies the UID of its own card into the code - condition: known card = green LED + rising tone; stranger = red + buzz. Step 3: add the key fob as a second user. Step 4 (optional): a servo as a barrier that opens for the right card. |
| 35-42 | Stage Moment | Penetration test: teams try to get in with each other’s cards - the systems recognize and reject them. A short, responsible discussion: where this shows up in our lives (transit cards, doors, hotels), and why cloning a tag is a sensitive topic. |
| 42-45 | Wrap-up and Cleanup | Teaser: “We have one more cool display in the kit - 64 LEDs in one square. Next week we draw with light.” |
| RFID | Identification by radio waves - the card answers when asked up close. |
| UID | The unique number burned into every card and tag - like a fingerprint. |
| Induction | The reader sends out energy, the card’s coil picks it up - that’s why there’s no battery. |
| SPI | A fast protocol on a few wires - I2C’s big brother. |
| 3.3V | Our reader runs on 3.3V only! 5V damages it. |
| Authorization | The decision of who gets in - the allowlist in our code. |
| Part / Pin | Pin |
|---|---|
| RC522 VCC | 3.3V (!) |
| RST · GND | D9 · GND |
| SDA(SS) · SCK | D10 · D13 |
| MOSI · MISO | D11 · D12 |
| Green / red LED | D2 · D3 |
if (rfid.PICC_IsNewCardPresent() && rfid.PICC_ReadCardSerial()) { String id = readUID(); if (id == myCard) { ok(); // green + sound } else deny(); }
| 00-05 | Opening | Whiteboard game: draw an 8×8 grid, and students “turn on” squares to make a heart. Then the lightbulb moment: every row is just a sequence of 0s and 1s - that’s exactly how a computer remembers every picture you’ve ever seen. |
| 05-13 | Demo | Meet the matrix (with a driver module - only 3-5 wires; without one, we use a 74HC595 and demonstrate the idea in an instructor demo). Show a ready-made smiley, then change one bit in the code - and one eye winks. The class sees that a picture = numbers. |
| 13-35 | Build | Step 1: upload the ready-made smiley. Step 2: each team gets an 8×8 pixel-art sheet, draws a character (spaceship? heart? letter?) and translates it into eight bytes. Step 3: type it in and display it. Step 4: a second frame + switching between them in a loop = animation: a beating heart, a waving alien. |
| 35-42 | Stage Moment | Pixel Gallery: lights off, and each team shows its creation. The class guesses what they see - then you reveal the eight numbers behind the picture. |
| 42-45 | Wrap-up and Cleanup | Teaser: “We’ve learned all the building blocks. From next week - we only build: the Final Project kicks off, and you are the chief engineers.” |
| Bit | The smallest unit in a computer: 0 or 1 - off or on. |
| Byte | 8 bits together - exactly one row of our matrix. |
| Binary | The way computers count: only 0 and 1. |
| B01100110 B-Notation | This is how you write a byte in code - every digit is an LED in the row. |
| Frame | One picture. Animation = frames swapping fast. |
| Shift Register | A chip that expands 3 pins to control 8 lines (74HC595). |
| Part / Pin | Pin |
|---|---|
| Matrix VCC · GND | 5V · GND |
| DIN · CS · CLK (module) | D11 · D10 · D13 |
| (Alternative: via 74HC595) | D8 · D11 · D12 |
byte smile[8] = { B00111100, B01000010, B10100101, B10000001, B10100101, B10011001, B01000010, B00111100 }; // each row = one byte
| 00-06 | Opening | Inspiration question on the board: “Who in your world has a hard time with something - and how could our parts help them?” Recall the list of ideas collected during the Servo and RFID sessions. The theme: technology that helps people. |
| 06-16 | The Challenge Menu | Go over six ready-made projects (on the next page) - for each: what you build, who it helps, and which parts. A team that wants an original idea is welcome, provided it passes the constraints (see the constraints box). The instructor confirms feasibility with one question: “Which part can we build today?” |
| 16-35 | Spec + Kickoff | Each team fills in a CHIPS Project Sheet: the product sentence (“Our ___ helps ___ by ___”) · a drawn algorithm input → decision → output · a parts list · a wiring sketch. Once the instructor signs off, the team opens a kit and wires the first part. |
| 35-42 | Stage Moment | 30-second pitch for each team: what you’re building, for whom, and what will already work next week. The class gives each team one challenging question - like a real investor panel. |
| 42-45 | Wrap-up and Cleanup | The instructor photographs the project sheets (backup!). Teaser: “From this moment there are no lessons - there’s a studio. Bring your energy.” |
| Specification | A document that defines exactly what the product does - before you build it. |
| Prototype | A first version that works - not pretty, but real. |
| Milestone | A measurable checkpoint: “By the end of the session the sensor reads.” |
| Roles | Wirer · programmer · tester · presenter - rotating every session. |
| Constraints | The limits that protect us: up to 3 main parts, a one-minute demo. |
| RTC Real-Time Clock | A clock chip with a battery - remembers the time even when powered off. |
| Part / Pin | Pin |
|---|---|
| Main parts per team | Up to 3 |
| At least one input + one output | Required |
| A clear “demo moment” | ≤ 60 sec |
| No heavy parts / no water near electricity | Required |
| Kit parts only | Required |
Six ready-made projects for teams to choose from in Session 13 - all meet the feasibility constraints, and all use kit parts not yet fully used in the sessions. A team with an original idea is welcome to propose it, provided it also meets the constraints: up to 3 main parts, at least one input + one output, and a demo moment of up to 60 seconds.
| Session | Exit goal |
|---|---|
| 13 | Signed spec + the first part reads/responds. |
| 14 | A full demo that passes the CHIPS acceptance test. |
| 15 | A live presentation in front of an audience + certificates. |
| 00-05 | Opening | Status minute: each team says one sentence - what works, what’s stuck, today’s goal. The instructor writes it on the board and notes the two teams that will need the most help. |
| 05-30 | Build Sprint | Free work at stations; the instructor circulates with the three-step debugging method: 1) Isolate - test the part alone in minimal code; 2) Print - Serial.println at every node; 3) Swap - one part/wire/pin at a time. No fixing it for the kids - point and ask. |
| 30-38 | Testing Checklist | Stop everything. Each team runs the CHIPS Acceptance Test (framed box) on another team’s project - outside testers, just like in industry. Every item that passes = a signature; every item that fails = a task card for the fix. |
| 38-43 | Fixes and Stage Moment | Fix the critical findings. Lightning round: each team demos the project’s “wow moment” in 20 seconds - an early dress rehearsal. |
| 43-45 | Wrap-up and Cleanup | Projects are stored wired on a tray with the team name - do not take them apart! Teaser: “Next week: morning rehearsals, then Showcase Night in front of an audience. Practice your opening line.” |
| Debugging | Finding faults with a method: isolate → hypothesize → test. |
| Part-by-part test Unit Test | Test each part on its own before connecting everything. |
| Extreme case Edge Case | What happens at the extreme? Press it twice? Unplug it in the middle? |
| Reliability Stability | Works once = luck. Ten times in a row = a product. |
| Improvement cycle Iteration | Version → test → improve → repeat. That’s how everything gets built. |
| MVP | The minimal version that works - that comes first, extras come after. |
| Part / Pin | Pin |
|---|---|
| Works 3 times in a row | ☐ |
| Extreme input doesn’t crash it | ☐ |
| USB unplug/replug - recovers on its own | ☐ |
| Every team can explain every line | ☐ |
| Demo moment ≤ 60 seconds | ☐ |
// At every suspect node: Serial.print("sensor="); Serial.println(v); // See the truth in the Serial Monitor, // don’t guess.
| 00-10 | Dress Rehearsal | Final round of stations: each team runs the demo twice in a row and practices the opening line (“Our ___ helps ___”). The instructor goes around with the Stage checklist: who holds, who talks, who operates. |
| 10-15 | Setting Up the Space | Turn the classroom into a gallery: display tables, LED matrices showing signs, LCD screens with the team name, 9V batteries for anyone far from an outlet. Parents and guests come in. |
| 15-35 | Project Showcase | Gallery walk: guests move between stations, and each team presents again and again - pitch, demo, questions. The instructor circulates, takes photos, and makes sure every team gets an audience. There is no single stage - there are ten small stages, and everyone’s a star. |
| 35-42 | Certificate Ceremony | Everyone gathers. Each student is called by name, receives a CHIPS certificate, and says one sentence: “The coolest thing I built / learned.” Applause for every single one - yes, every one. |
| 42-45 | Closing and What’s Next | Group photo with the projects. A word about what’s next: the next CHIPS tracks, and an invitation to build at home. Closing line: “You walked in as students - you’re leaving as engineers.” |
| Live demo | A live demonstration. The rule: show first, explain after. |
| Product story Pitch | The product’s story in 60 seconds: problem → solution → demo. |
| Looking back Reflection | A look back: what I learned, what was hard, what I discovered about myself. |
| Project record Portfolio | Documentation of my projects - the base for the next journey. |
| Alumni network Community | CHIPS alumni - whoever built once, builds again. |
| Problem solver Engineer | Someone who sees a problem and builds a solution for it. In other words - you. |
| Part / Pin | Pin |
|---|---|
| Printed certificates + correct names | ✔ |
| Charged 9V batteries for every station | ✔ |
| Backup: photos/video of every project | ✔ |
| CHIPS signage + photo spot | ✔ |
| Photo permission from parents | ✔ |
| Microcontroller | A whole computer on a single chip - no screen or keyboard. |
| Development Environment IDE | The software where you write, compile, and upload code. |
| Driver | Translates between the computer and the board (in our kits: CH340). |
| Program Sketch | An Arduino program: the setup and loop functions. |
| Compile | Translating C++ into the chip’s machine language. |
| Port | The address the computer uses to recognize the board. |
| Algorithm | A list of exact instructions in order. |
| C++ | The course’s programming language - a real industrial language. |
| Input / Output | What goes into the board / what the board does in the world. |
| HIGH / LOW | The two states of the digital world: voltage / no voltage. |
| Condition if/else | “If X, do Y, otherwise Z.” |
| Variable | A named box that stores a value. |
| Analog | A continuous signal: how much, not just yes/no. |
| PWM | Flickering so fast it looks like dimming - an “analog” output. |
| map() | Stretching one range of values onto another. |
| Serial Monitor | A window where the board prints what it senses. |
| Sensor | Converts a physical phenomenon into an electrical signal. |
| Frequency | Vibrations per second (Hz); sets the pitch of a sound. |
| Function | A named bundle of code you can reuse. |
| for loop | A loop that counts - for transitions and fades. |
| I2C | Many parts on 2 data wires, told apart by address. |
| Library | Ready-made code from engineers - import it and use it. |
| String | A sequence of characters, such as a password. |
| UID | The unique number of each RFID card. |
| SPI | A fast communication protocol over several wires. |
| Binary digit / Byte Bit/Byte | 0 or 1 / eight bits - one matrix row. |
| Binary | The way computers count: only 0 and 1. |
| Debugging | Troubleshooting by method: isolate, print, swap. |
| Specification | What the product does - written down before you build. |
| MVP | The minimal version that works; it comes first. |
| Board not recognized by the computer | USB cable (suspect #1!) → a different port → CH340 driver installed? → Device Manager under Ports. |
| avrdude error on upload | Tools ← Board: Arduino Uno · Tools ← Port: the right COM · unplug and replug. |
| LED won’t light | Leg orientation → resistor in the same row → pin number in code = pin in wiring → loose wire. |
| Button/sensor goes “haywire” | Missing 10kΩ resistor to GND - the input is floating. Add it and test again. |
| LCD is lit but blank | Contrast screw on the back → address 0x27/0x3F with the I2C Scanner. |
| Servo jitters / board resets | Common GND for everything → good-quality USB cable → in the project: 9V battery. |
| Code runs but “nothing happens” | Serial.println at every node - the Serial Monitor shows where the truth stops. |
| Sensor reading jumps around | Average of 5 samples + a short delay - a stable reading. |
The whole course runs on real hardware and the Arduino IDE - that’s the way. But sometimes a quarter hour is left at the end of a session, a class has no kits, or a student wants to keep going at home without a board. That’s exactly what the browser-based bonus environment is for: chips.arduinostudio.com - an online Arduino simulator with ready-made tasks, no install and no account.