Module 1: Introduction to FlowLogic 6
Your First Programming Tool
Meet FlowLogic 6, a visual flowchart-based programming tool. Learn to create, edit, connect, and run FlowPrograms using command blocks and decision blocks.
Learning Objectives - Understand what FlowLogic 6 is and how it works as a visual programming tool
- Create, edit, and delete command blocks and connecting lines
- Use decision blocks with YES and NO branches
- Run a FlowProgram and observe its output
- Apply basic computational thinking to solve simple problems
What You'll Learn - What is FlowLogic 6?
- The workspace and command blocks
- Editing and deleting blocks and lines
- Decision blocks and conditional branching
- Running your first FlowProgram
- Understanding algorithm flow
What Is FlowLogic 6?
FlowLogic 6 is a flowchart-based algorithm programming tool designed specifically for learners. Instead of typing lines of code, you build programs visually by placing blocks on a workspace and connecting them with lines. Each block represents an action or a decision, and the connecting lines show the order in which things happen.
This approach is powerful for beginners because it makes the logic of a program visible. You can literally see how data flows from one step to the next, which decisions are made along the way, and what happens when conditions change. Professional programmers call this kind of visual representation a flowchart, and it has been used in software engineering for decades to plan and communicate program logic before writing actual code.
FlowLogic 6 version 3.8 takes this concept and turns it into an interactive tool. You do not just draw flowcharts on paper. You build them on screen, and then you run them. The program executes your flowchart step by step, so you can see immediately whether your logic works or needs fixing. This instant feedback loop is one of the best ways to develop algorithmic thinking.
Think of a task you do every day, like making breakfast. How would you represent the steps of that task as a flowchart using blocks and connecting lines?
The Workspace and Command Blocks
When you open FlowLogic 6, you see a large workspace area where you will build your programs. The workspace is like a blank canvas. You place command blocks onto this canvas, and each block tells the computer to do something specific: display a message, store a value, wait for input, or perform a calculation.
To add a block, you select it from the block menu and place it on the workspace. To connect two blocks, you click on the first block and then click on the second block. FlowLogic 6 draws a line between them, showing that the program should move from the first block to the second.
Each block has a property window where you set its details. For example, a display block needs to know what text to show. A calculation block needs to know which numbers to work with. You open the property window by double-clicking the block, make your changes, and click OK.
Action step: Open FlowLogic 6 and place three command blocks on the workspace. Connect them in sequence, set a property in each, and then trace the flow with your finger from first to last.
Editing: Delete Lines and Blocks
Mistakes are a normal part of building programs, so FlowLogic 6 makes it easy to fix things. Here is how editing works:
To delete a connecting line: Click on the first block (Block 1), then click on the second block (Block 2). While your mouse pointer is on Block 2, right-click and select Delete Line from the pop-up menu. The connection between those two blocks disappears, but the blocks themselves remain.
To delete a block: First, delete all connecting lines going to and from that block. Then right-click on the block itself and select Delete Block from the pop-up menu. The block is removed from the workspace.
To edit a block: Double-click on the block. The property window opens, allowing you to change its settings. Make your adjustments and click OK when done.
These three operations - delete line, delete block, and edit block - are the core editing skills you will use constantly as you build and refine your FlowPrograms.
Do you think the requirement to delete lines before blocks is a good design choice? What problems might arise if FlowLogic 6 let you delete a block without removing its connections first?
Decision Blocks and Conditional Branching
Not all programs follow a straight line from start to finish. Most useful programs need to make decisions. Should the robot turn left or right? Is the temperature too high? Did the user press the button?
In FlowLogic 6, you handle decisions using a special decision block. A decision block contains a condition statement - a question that can be answered YES or NO. For example: Is the sensor value greater than 50?
The decision block requires exactly two connecting lines going out. The first line you connect becomes the YES path - what happens when the condition is true. The second line becomes the NO path - what happens when the condition is false. You connect these lines at your discretion based on what makes sense for your program.
This branching ability is what makes programs intelligent. Without decisions, a program can only do the same thing every time. With decisions, a program can respond differently to different situations - which is exactly what real-world applications need.
What would happen if you built a program with a decision block but only connected the YES path and forgot the NO path? What real-world problems could that kind of omission cause in a control system?
Running Your First FlowProgram
Once you have placed your blocks on the workspace, connected them in the right order, and set the properties for each block, you are ready to run your program. Look for the Run button in the FlowLogic 6 toolbar.
When you click Run, the program starts executing from the first block and follows the connecting lines through each subsequent block. If it reaches a decision block, it evaluates the condition and takes the appropriate YES or NO path. If it reaches a display block, it shows the output. The program continues until it reaches the end or encounters a stop condition.
If something goes wrong - the output is not what you expected, or the program takes the wrong path - do not worry. This is called debugging, and it is a completely normal part of programming. Go back to your blocks, check the property windows, verify your connections, and try again. Every professional programmer spends significant time debugging. The key skill is reading what the program actually did, comparing it to what you wanted it to do, and narrowing down where the difference occurred.
Action step: Run your first FlowProgram, then deliberately introduce a mistake in a block property. Observe what goes wrong, then fix it. Notice how debugging feels different from building.
Computational Thinking
Building FlowPrograms is not just about learning a tool - it develops a way of thinking called computational thinking. This means breaking complex problems into smaller steps, identifying patterns, ignoring irrelevant details, and designing step-by-step solutions.
When you build a FlowProgram, you practise all four pillars of computational thinking:
Decomposition: Breaking a big problem into smaller, manageable parts. For example, building a traffic light system means separately handling the red, yellow, and green sequences.
Pattern recognition: Noticing similarities between problems. Once you know how to blink one LED, you can apply the same pattern to blink any number of LEDs.
Abstraction: Focusing on what matters and ignoring what does not. When programming a buzzer, you focus on frequency and duration, not on how the buzzer physically vibrates.
Algorithm design: Creating a clear, step-by-step procedure that solves the problem every time. Your FlowProgram is literally an algorithm made visible.
These skills transfer far beyond Arduino projects. They apply to any situation where you need to solve problems systematically, whether in engineering, science, business, or everyday life.
Watch video: Computational Thinking
Which of the four pillars of computational thinking do you find most natural to you? How could you apply that strength when planning your very first Arduino project?
Module 2: Console and Virtual Projects
Programming Without Hardware
Build algorithms using console applications and virtual projects. Program a robot maze, traffic lights, and a rocket launcher - all on screen before touching any hardware.
Learning Objectives - Build console applications using command blocks and screen widgets
- Understand the difference between single-loop and continuous-loop algorithms
- Navigate a virtual robot through a maze using flowchart programming
- Control virtual traffic lights and rocket launchers with FlowPrograms
- Use media blocks to add audio to virtual projects
What You'll Learn - Console programming with command blocks
- Screen Console widget for output display
- Virtual Projects: on-screen simulations
- Robot Maze: navigation algorithms
- Traffic Light: controlling virtual outputs
- Rocket Launcher: inputs, outputs, and media
- Single-loop vs continuous-loop programs
Console Programming Basics
Before working with physical hardware, FlowLogic 6 lets you practise programming using console applications. A console application runs entirely on screen - it takes input, processes data, and displays output using text. Think of it as a conversation between you and the computer, conducted through typed messages.
To build a console application, you use the same command blocks you learned in Module 1, but now you focus on blocks that display text, read input, and perform calculations. The Screen Console widget is where your program's output appears. You place it on the workspace alongside your FlowProgram so you can see the results as the program runs.
Console programming teaches you fundamental concepts that apply to every type of programming: storing values in variables, performing calculations, displaying results, and controlling the flow of execution. Master these in the safe, simple environment of the console before moving to more complex projects.
Action step: Build a console application that asks for your name and displays "Hello, [name]!" - this small project will give you hands-on practice with input, variables, and output all in one.
Loops: Single and Continuous
One of the most important concepts in programming is the loop - a section of your program that repeats. Loops are everywhere in real-world applications. A traffic light cycles through red, yellow, and green continuously. A sensor checks the temperature every few seconds. A blinking LED turns on and off repeatedly.
In FlowLogic 6, you create loops by connecting a later block back to an earlier one, forming a circle in your flowchart. There are two main types:
Single loop: The program runs through a sequence once and then proceeds to the next part. For example, turn on an LED, wait one second, turn it off - done. Single loops are useful for one-time actions.
Continuous loop: The program runs through a sequence and then loops back to the beginning, repeating forever (or until you stop it). For example, blink an LED on and off indefinitely. Continuous loops are essential for any system that needs to keep running, like a traffic light or a security alarm.
Understanding when to use each type of loop is a critical programming skill. Ask yourself: does this action need to happen once, or does it need to keep happening? Your answer determines which loop structure to use.
Can you think of three everyday devices that use a continuous loop and three that use a single loop? What clues in the device's behaviour tell you which type it uses?
Virtual Projects: Simulations on Screen
FlowLogic 6 includes a powerful feature called Virtual Projects. These are on-screen simulations with pre-assigned control pins and animations that you can program using virtual command blocks. In other words, you get to control things that look and behave like real hardware - robots, traffic lights, rockets - without needing any physical components.
To start a Virtual Project, select it from the Virtual Project list and place it on the workspace. Each virtual project comes with its own set of virtual input/output pins that correspond to what real hardware would use. When you write to a virtual output pin, the on-screen simulation responds: an LED lights up, a motor moves, a buzzer sounds.
Virtual projects are an excellent stepping stone between pure console programming and real physical computing. They let you practise the same logic and commands you will use with actual Arduino hardware, but in a forgiving environment where there are no wires to connect wrong and no components to damage.
How does practising with a virtual simulation first change the way you feel about moving to real physical hardware? Do you think simulations are a valuable learning step or a distraction from the "real thing"?
Robot Maze Navigation
The Robot Maze is one of the most engaging Virtual Projects. Your task is to construct a FlowProgram that navigates a virtual robot through a maze from start to finish.
Here is how it works:
Step 1: Select Robot Maze from the Virtual Project list.
Step 2: Click Load Maze to load a maze image (such as Rmaze1 or Rmaze2) from the folder.
Step 3: Construct your FlowProgram using movement commands - forward, turn left, turn right - to guide the robot through the maze.
Step 4: Click Run to execute your program and watch the robot move.
Step 5: Click Reset to return the robot to its starting position if you need to try again.
The maze challenge is a brilliant exercise in sequential thinking. You must mentally trace the path, count the steps, and plan each turn before the robot makes it. If the robot hits a wall or goes the wrong way, you go back to your FlowProgram, find the error, and adjust. Each new maze image provides a fresh challenge that tests your growing skills in algorithm design and spatial reasoning.
Action step: Load Rmaze1, trace the robot's path on paper before touching the keyboard, and then build your FlowProgram from that plan. Compare how your paper plan matches (or differs from) your working solution.
Traffic Light and Rocket Launcher
Two more Virtual Projects let you practise increasingly complex programming:
Traffic Light: You develop a FlowProgram to control a virtual traffic light system. Using virtual I/O pins, you turn red, yellow, and green lights on and off in the correct sequence. The basic challenge is getting the standard sequence right: green, yellow, red, and back to green. A more advanced variant asks you to make the yellow light blink before switching - a great exercise in combining loops with timing.
Rocket Launcher: This project introduces you to working with both inputs and outputs. Your FlowProgram controls a virtual rocket launch sequence using counter widgets and data display blocks. You programme a countdown (10, 9, 8... 1, Blastoff!) and trigger the launch animation.
The Rocket Launcher also introduces media blocks. These special blocks let you load and play sound files during your program. For example, you can load a countdown audio file that plays "3, 2, 1" and a blastoff sound effect that plays when the rocket launches. Adding audio transforms a simple visual program into a multimedia experience.
These Virtual Projects build confidence and skills. By the time you move to real hardware in the next modules, you will already understand how to structure programs, control outputs, read inputs, and debug problems.
Which Virtual Project - the Traffic Light or the Rocket Launcher - did you find more interesting to programme, and why? What does your preference tell you about the types of projects you might enjoy building with real hardware?
Module 3: Essential Components
Know Your Hardware
Get hands-on with the Arduino UNO board, breadboard, resistors, LEDs, and jumper wires. Learn how each component works and how to build your first circuits.
Learning Objectives - Identify all components in the Mini Arduino Starter Kit
- Understand the Arduino UNO pin layout including digital, analog, and power pins
- Use a 170-point breadboard for circuit prototyping
- Calculate resistor values using the colour band system
- Build basic LED circuits with correct polarity and resistance
What You'll Learn - What is physical computing?
- Starter kit components overview
- Arduino UNO pins and power sources
- 170-point breadboard layout and connections
- Power sources: USB, battery, and adapter
- Resistor values and the colour band system
- LEDs, jumper wires, and circuit connections
- Testing and debugging with the Control Panel
What Is Physical Computing?
Physical computing means building interactive systems that use software and hardware to sense and respond to the real world. Until now, everything you have programmed existed only on screen - console outputs, virtual robots, simulated traffic lights. Physical computing takes your algorithms into the real world, where they control actual LEDs, read actual sensors, and make actual buzzers sound.
This is a fundamentally different experience from screen-only programming. When you programme a virtual LED to blink, you see a picture change on your monitor. When you programme a real LED to blink, you see light appear in the room you are sitting in. When you programme a virtual buzzer, you hear a sound through your speakers. When you programme a real piezo buzzer, the sound comes from a tiny component sitting on your desk. This tangible connection between code and reality is what makes physical computing so engaging and memorable.
The Arduino UNO is your gateway to physical computing. It is a small, affordable microcontroller board that can read inputs (sensors detecting light, temperature, or proximity) and control outputs (LEDs, buzzers, motors). Your FlowLogic 6 programs will communicate with the Arduino UNO to make all of this happen.
How does the experience of making a real LED light up in front of you feel compared to seeing a virtual LED light up on screen? What does that difference mean to you as a learner?
Your Starter Kit Components
The Mini Arduino Starter Kit contains everything you need to start building physical computing projects. Here is what is inside:
Arduino UNO R3: The brain of your projects. A microcontroller board that runs your programs and connects to components.
USB Cable: Connects the Arduino to your computer for programming and power.
170-Point Breadboard: A small prototyping board where you plug in components and wires to build circuits without soldering.
Jumper Wires: Wires with connector pins at each end for connecting components on the breadboard to the Arduino.
Resistors: 220 ohm, 10K ohm, and 1M ohm - these limit current flow to protect components like LEDs.
LEDs: Red, green, blue, and yellow light-emitting diodes, plus an RGB LED that can produce any colour.
Push Button: A simple switch that your program can detect when pressed.
Piezo Buzzer: A component that produces sound when given an electrical signal.
Sensors: LDR (light sensor), LM35 (temperature sensor), and an ultrasonic sensor for distance detection.
Each component has a specific function, and through the coming modules you will learn to use every single one.
Action step: Lay out every component from your starter kit and try to match each one to its name and function from this section before moving on. Which component are you most curious to use first?
Arduino UNO Pins and Power
The Arduino UNO board has several types of connections, each serving a different purpose:
Digital Input/Output Pins (0-13): These pins can be set to either HIGH (on, sending voltage) or LOW (off, no voltage). You use them to control LEDs, read button presses, and communicate with digital sensors. Pins marked with a tilde (~) also support PWM (Pulse Width Modulation) for analog-like output.
Analog Input Pins (A0-A5): These pins read varying voltage levels, not just on/off. They are used for sensors that produce a range of values, like a light sensor or temperature sensor. The Arduino converts the analog voltage into a number between 0 and 1023.
Power Pins: The board provides 5V and 3.3V output pins to power your components, plus GND (ground) pins to complete circuits.
Powering the Arduino: You can power the board three ways: (1) USB cable from your computer - this also lets you upload programs; (2) a 7-12V power adapter plugged into the barrel jack; (3) a 9V battery with a barrel jack connector. For learning, the USB cable is most convenient because it provides both power and communication.
Look at the Arduino UNO pin diagram. Can you identify three digital pins and two analog pins on your actual board? What does the tilde (~) mark on some digital pins allow you to do that other digital pins cannot?
The 170-Point Breadboard
A breadboard is a reusable prototyping platform that lets you build circuits without soldering. The 170-point breadboard in your kit is compact but powerful enough for all the starter projects.
The breadboard has rows of small holes where you push in component legs and jumper wires. Here is the critical thing to understand about how a breadboard works internally: the holes in each column of the component section are connected vertically on the inside. If you plug two wires into the same column, they are electrically connected even though they look separate on the surface.
The board is divided into two sections by a centre slot. The connections on the left side do not cross over to the right side. This centre slot is designed to straddle integrated circuits and larger components.
When building circuits on the breadboard, always remember: components in the same vertical column are connected. Components in different columns are not connected unless you bridge them with a jumper wire. This simple rule governs every circuit you will build.
Action step: Place two jumper wires in the same breadboard column and use a multimeter or LED test to confirm they are electrically connected. Then try the same in different columns to confirm they are not.
Resistors: Protecting Your Components
A resistor is a component that limits the flow of electrical current. Without resistors, too much current would flow through sensitive components like LEDs, potentially destroying them. Think of a resistor as a narrow section of pipe - water (current) still flows through, but the narrow section controls how much.
Resistors are marked with coloured bands that indicate their value in ohms. Your kit includes three types:
220 ohm (red-red-brown): Used with LEDs. The coloured bands read: Red (2), Red (2), Brown (×10) = 220 ohms. This is the most common resistor you will use.
10K ohm (brown-black-orange): Used as a pull-down resistor with push buttons. The bands read: Brown (1), Black (0), Orange (×1,000) = 10,000 ohms.
1M ohm (brown-black-green): A very high-resistance resistor used in specialized sensor circuits.
When reading a 4-band resistor, ignore the last band (it indicates tolerance, not value). Read the first two bands as digits and the third band as a multiplier. With practice, you will recognise the common values at a glance.
Pick three resistors from your kit and read their colour bands to identify their values before checking the labels. How confident do you feel reading resistor codes, and what would help you remember the colour sequence?
LEDs, Wires, and Your First Circuit
An LED (Light Emitting Diode) converts electrical energy into light. LEDs come in different colours - your kit includes red, green, blue, and yellow - and they all work the same way electrically.
The critical thing about LEDs is polarity: they only work in one direction. Every LED has two legs: the longer leg is the anode (positive, +) and the shorter leg is the cathode (negative, −). If you connect them backwards, the LED simply will not light up (but it also will not be damaged at low voltages).
Jumper wires connect everything together. They have connector pins at each end that plug into the breadboard holes. While jumper wires come in different colours, the colours do not indicate any electrical difference - a red wire works identically to a black one. However, it is good practice to use red for power (positive) and black for ground (negative) to keep your circuits organised and easy to debug.
A basic LED circuit has four components connected in series: Arduino power pin → resistor → LED (anode) → LED (cathode) → ground. Always include the resistor to protect the LED from too much current.
Watch video: LEDs, Wires, and Your First Circuit
What do you think would happen if you built the LED circuit correctly but skipped the resistor? Would you try it to find out, or is it better to trust the theory? Why?
Testing and Debugging Circuits
Before building a complex algorithm for your circuit, always test that your physical components are connected correctly and working. FlowLogic 6 includes a Control Panel tool specifically for this purpose.
The Control Panel lets you manually turn Arduino pins on and off, read sensor values, and check connections without running a FlowProgram. This is essential for debugging. If you build a circuit and your FlowProgram does not produce the expected result, you have two possible sources of error: the program or the circuit. The Control Panel helps you isolate which one by letting you test the circuit independently of the program.
Debugging workflow:
1. Build your circuit on the breadboard
2. Use the Control Panel to test each component individually - turn on each LED, read each sensor
3. If the components respond correctly, the circuit is good and any problem is in your FlowProgram
4. If a component does not respond, check your wiring: correct pins, correct polarity, resistors in place
5. Only after confirming the circuit works, proceed to build and run your FlowProgram
This habit of testing before programming will save you enormous amounts of debugging time. Professional engineers follow the same principle: verify the hardware, then verify the software, never assume both are correct simultaneously.
Action step: Build your first LED circuit, then use the Control Panel to turn it on and off before writing any FlowProgram. Notice how this two-stage approach changes your confidence when you finally run the full program.
Module 4: Digital Input and Output
LEDs, Buzzers, and Buttons
Build real circuits that blink LEDs, simulate a police siren, control traffic lights, mix RGB colours, play music with a buzzer, and respond to button presses.
Learning Objectives - Control LEDs using digital output pins with single and continuous loops
- Build multi-LED circuits for police siren and traffic light simulations
- Mix colours using an RGB LED with both digital and analog write commands
- Generate sound and music using a piezo buzzer with tone commands
- Read push button input and trigger actions based on button state
What You'll Learn - LED ON/OFF with digital write commands
- Blinking LEDs using delay and continuous loops
- Police car siren: two-LED animation with audio
- Traffic light system: three-LED sequence
- RGB LED: digital and analog colour mixing
- Mood lamp creative project
- Piezo buzzer: ON/OFF, pulsating, and tone music
- Push button input and conditional responses
- Panic button project: combining input, output, and audio
LED ON/OFF: Your First Physical Output
Your first physical computing project is beautifully simple: turn an LED on and off using a digital output pin. This single action - sending a HIGH or LOW signal from an Arduino pin - is the foundation of everything that follows.
In FlowLogic 6, you use the Arduino Digital Write command block to control a pin. Setting a pin to HIGH sends voltage through it, which turns the LED on. Setting it to LOW stops the voltage, turning the LED off. Every LED project, no matter how complex, is built from this basic operation.
For a single LED ON/OFF program, you need just two command blocks: one to set the pin HIGH (LED on) and one to set it LOW (LED off). For blinking, you add delay blocks between the on and off commands and wrap the whole sequence in a continuous loop. The delay controls how fast the LED blinks - a short delay creates rapid flashing, a long delay creates slow pulsing.
Before building your FlowProgram, always construct your circuit first and test it with the Control Panel. For a single LED circuit, connect: Arduino digital pin → 220 ohm resistor → LED anode (long leg) → LED cathode (short leg) → GND.
Action step: Write a FlowProgram that blinks an LED at three different speeds - slow, medium, and fast - by changing the delay values. Which speed feels most satisfying to watch, and why did you choose those numbers?
Police Car Siren: Two-LED Animation
The police car siren project takes your LED skills to the next level by controlling two LEDs that alternate rapidly, just like the red and blue lights on a police vehicle.
The circuit uses two LEDs (typically red and blue) connected to two different digital pins, each with its own 220 ohm resistor. The FlowProgram alternates between them: turn LED 1 on and LED 2 off, wait briefly, then turn LED 1 off and LED 2 on, wait briefly, and loop continuously.
The magic of this project is in the timing. By adjusting the delay values and the PulseOUT timing, you can make the LEDs flash in patterns that closely mimic real police car sirens. Short, rapid pulses create an urgent emergency feel. Longer alternating pulses create a cruising patrol car effect.
To make it even more realistic, you can add a media block with a police siren sound file. The combination of flashing lights and siren audio creates an impressive multimedia project that demonstrates how physical outputs and digital media can work together.
Now that you can control two alternating LEDs, what other real-world flashing light system could you simulate? How would you adjust the timing and pattern to make it convincing?
Traffic Light System
A traffic light system is a classic physical computing project because it demonstrates sequential logic - things must happen in a specific order, with specific timing, in a continuous cycle.
Your circuit uses three LEDs: red, yellow (amber), and green, each connected to its own digital pin with a 220 ohm resistor. The FlowProgram follows the standard UK traffic light sequence:
1. Red - Stop (held for several seconds)
2. Red + Yellow - Prepare to go
3. Green - Go (held for several seconds)
4. Yellow only - Prepare to stop
5. Back to Red - cycle repeats
Each phase involves setting specific pins HIGH or LOW. For example, the "Red + Yellow" phase sets the red pin HIGH, the yellow pin HIGH, and the green pin LOW. The challenge variant asks you to make the yellow light blink five times before switching - combining loops within the sequence.
Watch video: Traffic Light System
How would you redesign the traffic light program to handle a pedestrian crossing button that can request a red signal at any point in the cycle? What new blocks would you need to add?
RGB LED: Digital Colour Mixing
An RGB LED is a single component that contains three tiny LEDs inside: Red, Green, and Blue. By controlling each colour independently, you can mix virtually any colour - just like mixing paint, but with light.
The RGB LED in your kit has four legs: one common negative (cathode) and three anodes, one for each colour. Each anode connects to a different Arduino pin through a 220 ohm resistor.
Digital colour mixing uses simple HIGH/LOW commands. With three colours, each either on or off, you get eight possible combinations:
• Red only = Red
• Green only = Green
• Blue only = Blue
• Red + Green = Yellow
• Red + Blue = Magenta
• Green + Blue = Cyan
• Red + Green + Blue = White
• All off = No light
Analog colour mixing uses the Analog Write command block, which sends values from 0 (off) to 255 (full brightness) to PWM-capable pins. This gives you fine control over each colour's intensity, allowing thousands of colour combinations instead of just eight. For example, setting Red to 255, Green to 100, and Blue to 0 produces orange.
The Mood Lamp project takes this further. You build a simple shade using a ping pong ball placed over the RGB LED, then program it to cycle through colours slowly, creating a glowing lamp effect. This is a creative project where the algorithm meets physical design.
What Analog Write values (0-255 for each of R, G, B) would you use to produce your favourite colour? Look up its hex code and convert it - how close can you get?
Piezo Buzzer: Making Sound
The piezo buzzer converts electrical signals into sound. It is a versatile component that can produce simple beeps, pulsating tones, and even music.
The buzzer connects directly to a digital pin and GND - no resistor needed. In FlowLogic 6, you control it using three different approaches:
Digital Write ON/OFF: Setting the pin HIGH turns the buzzer on with a continuous tone. Setting it LOW turns it off. Combined with delays, you get beeping patterns.
PulseOUT: The PulseOUT command sends rapid on-off pulses at a specific frequency, producing different pitch sounds. Higher frequency = higher pitch. Lower frequency = lower pitch.
TONE command: The most musical approach. The TONE block lets you specify a frequency (in Hertz) and duration, producing a precise musical note. By chaining multiple TONE blocks with different frequencies and durations, you can compose simple melodies.
The challenge for this project is to compose a recognisable music theme - perhaps a nursery rhyme or a well-known tune - using a sequence of TONE commands. This exercise connects programming to music theory: every note has a frequency, every rhythm has a duration, and together they form a composition.
Which short melody would you programme into your buzzer first - a nursery rhyme, a game sound, or something original? What does your choice reveal about how you approach creative projects?
Push Button: Reading Input
Until now, all your programs have been output-only - they send signals to LEDs and buzzers but do not receive any information from the outside world. The push button changes this by introducing digital input.
A push button is a simple switch. When you press it, it creates a connection. When you release it, the connection breaks. Your Arduino program reads the button's state using the Digital Read command: the pin reads HIGH when pressed and LOW when released (or vice versa, depending on your wiring).
The button circuit requires a 10K ohm pull-down resistor connected between the button pin and GND. This resistor ensures the pin reads a clean LOW when the button is not pressed. Without it, the pin might float between HIGH and LOW randomly, causing unpredictable behaviour.
Your first button project combines input and output: when the button is pressed, the LED turns on or blinks. When released, the LED turns off. This simple interaction is the foundation of every interactive device - from light switches to keyboards to game controllers.
Action step: Wire the button circuit with the pull-down resistor, then use the Control Panel to read the pin value while pressing and releasing the button repeatedly. Notice the clean HIGH and LOW readings you get.
Panic Button: Combining Everything
The Panic Button project brings together everything from this module: digital input (push button), digital output (LED), sound output (piezo buzzer), and even a media block for Text-to-Speech alerts.
The circuit combines a push button, a red LED, and a piezo buzzer on the breadboard. The FlowProgram uses a decision block to check the button state continuously: when the button is pressed, the program triggers a visual alert (LED flashes rapidly), an audio alarm (buzzer sounds), and optionally a speech alert using a Text-to-Speech media block.
This project demonstrates a critical programming concept: event-driven design. The program does not just execute a fixed sequence. It waits, watches for an event (the button press), and then responds. This is how real-world alarm systems, doorbells, and emergency buttons work.
The challenge is to enhance the alarm with Text-to-Speech, making the system announce "Alert! Alert!" when triggered. This combines physical hardware interaction with multimedia output for a genuinely useful prototype.
Think of a real-world alarm or alert device that you use or encounter regularly. How closely does its behaviour match the event-driven design you just programmed in the Panic Button project?
Module 5: Analog Input and Output
Sensors and Variable Control
Read real-world data from light sensors, potentiometers, and temperature sensors. Use analog values to create smart systems that respond to their environment.
Learning Objectives - Read analog sensor values using analog input pins (A0-A5)
- Store sensor readings in variables for decision-making
- Build a smart light that turns on automatically in darkness using an LDR sensor
- Use analog write to fade an LED based on ambient brightness
- Read temperature data from an LM35 sensor and convert it to Celsius
What You'll Learn - Analog vs digital signals
- LDR light sensor: reading ambient brightness
- Variables: storing sensor data dynamically
- Smart lighting: automatic LED control based on light levels
- Energy-saving LED fading with analog write
- Potentiometer: manual analog input control
- LM35 temperature sensor: reading and converting values
- Heat range detection: multi-LED temperature indicator
Analog vs Digital: A World of Difference
Until now, you have worked with digital signals - values that are either HIGH or LOW, on or off, 1 or 0. Digital is like a light switch: it has exactly two states.
Analog signals are completely different. They represent a continuous range of values, like a dimmer dial that can be set anywhere from fully off to fully bright and every level in between. The real world is mostly analog: temperature varies smoothly, light fades gradually, sound rises and falls continuously.
The Arduino UNO bridges these two worlds. Its analog input pins (A0 through A5) can read varying voltage levels and convert them into a number between 0 and 1023. A reading of 0 means no voltage (0V), and 1023 means full voltage (5V). Everything in between represents a proportional value.
For analog output, the Arduino uses PWM (Pulse Width Modulation) on pins marked with ~. The Analog Write command accepts values from 0 to 255, letting you control brightness, speed, and intensity with fine precision.
Watch video: Analog vs Digital: A World of Difference
Look around your environment right now. Can you identify five things that are "digital" in nature (on/off states) and five things that are "analog" (continuous range)? What pattern do you notice?
LDR Light Sensor: Seeing Brightness
The LDR (Light Dependent Resistor) is your first analog sensor. Its resistance changes based on the amount of light hitting it: more light = less resistance = higher voltage reading, less light = more resistance = lower reading.
To use the LDR, connect it to an analog input pin (typically A0) with a voltage divider circuit using a 10K ohm resistor. Your FlowProgram reads the pin value and stores it in a variable - a named container that holds data your program can use.
For example, you create a variable called vLight and the program continuously reads the analog value from pin A0 into this variable. The value updates dynamically as the light changes - cover the sensor with your palm and the value drops; shine a light on it and the value rises.
The first project uses this sensor for automatic lighting. Your FlowProgram checks the vLight variable with a decision block: if the value is below a threshold (meaning it is dark), turn the LED on. If above the threshold (meaning it is bright), turn the LED off. This is exactly how automatic street lights work - the same logic, the same principle, just scaled down to your desk.
Use the Control Panel to find the right threshold values for your environment. Cover the LDR with your palm to simulate night and note the reading, then expose it to room light and note that reading. Your threshold should be between these two values.
Action step: Use the Control Panel to record the LDR reading in three different lighting conditions - bright sun, indoor light, and covered by your palm. Then set your threshold exactly between the indoor and covered values.
Energy-Saving LED Fading
The automatic on/off light project is clever, but it only has two states: fully on or fully off. Real-world smart lighting is more sophisticated - it adjusts brightness gradually based on how much natural light is available.
The energy-saving LED fading project achieves this by combining analog input (reading the LDR sensor) with analog output (writing a brightness value to an LED on a PWM pin like pin 6).
The Analog Write command accepts values from 0 (LED completely off) to 255 (LED at full brightness). Your program reads the light sensor, calculates the appropriate LED brightness (darker environment = brighter LED, lighter environment = dimmer LED), and writes that value to the LED pin.
This creates a responsive, energy-efficient system. In bright daylight, the LED stays dim or off, saving energy. As it gets darker, the LED gradually brightens to compensate. The transition is smooth and continuous, not an abrupt switch - far more pleasant and practical than a simple on/off system.
This project demonstrates a powerful pattern in physical computing: read a sensor, process the data, and produce a proportional output. This same pattern powers automatic screen brightness on phones, climate control systems in buildings, and adaptive lighting in cars.
Think of a building or room where automatic lighting felt too harsh or too dim when it switched on. How would a proportional fading system like this one have improved that experience?
Potentiometer: Manual Analog Control
A potentiometer (often called a "pot") is a variable resistor with a knob you can turn. It provides analog input that you control manually - turning the knob changes the voltage reading from 0 to 1023, just like the LDR changes with light, but you control the value directly with your fingers.
The potentiometer connects to an analog input pin and provides a smooth range of values as you rotate the knob. Your FlowProgram reads this value and can display it on a Screen Console widget, letting you see the exact number change as you turn the knob.
Potentiometers are useful for any project where you want human control over a variable: adjusting LED brightness manually, setting a threshold value, controlling the speed of a process, or tuning a frequency.
The challenge project connects three potentiometers to control the three channels of an RGB LED. Each potentiometer adjusts one colour (Red, Green, or Blue) from 0 to 255 brightness. By turning the three knobs, you can mix any colour in real time - a physical colour picker that you build and programme yourself. This is a satisfying project because the feedback is immediate and visual: turn a knob, see the colour change.
The three-potentiometer RGB colour mixer gives you a physical colour picker you built yourself. What other device in your home uses a similar "turn a knob to control a value" concept, and could you imagine replacing it with a potentiometer project?
Temperature Sensor: Reading the Environment
The LM35 is an analog temperature sensor that outputs a voltage proportional to the temperature in Celsius. For every degree Celsius, the LM35 outputs 10 millivolts. At 25°C, it outputs 250 millivolts.
Connecting the LM35 is straightforward: the middle pin goes to an analog input (like A0), one outer pin to 5V, and the other to GND. Your FlowProgram reads the analog value and then converts it to Celsius using a simple formula.
The raw analog reading (0-1023) represents a voltage from 0V to 5V. To convert to temperature: multiply the reading by 500, then divide by 1023. This gives you the temperature in degrees Celsius. You can display the result using an Analog Gauge widget for a visual dashboard-like presentation.
The heat range detection project combines the temperature sensor with multiple LEDs to create a visual temperature indicator. You define temperature ranges - for example, below 25°C shows a green LED (comfortable), 25-30°C shows yellow (warm), and above 30°C shows red (hot). The FlowProgram reads the temperature continuously and lights the appropriate LED based on the current reading.
This is a practical prototype for real temperature monitoring systems used in server rooms, greenhouses, and warehouses - the logic is identical, just the scale is different.
Action step: Build the heat range detection project, then hold the LM35 sensor in your hand for 30 seconds. Watch the LED colour change as your body heat warms the sensor. What temperature did your hand register?
Module 6: Data Sensors and Final Projects
Distance Detection and Beyond
Use an ultrasonic proximity sensor to detect distance, build an intrusion detection system, and combine everything you have learned into a complete IoT-style project.
Learning Objectives - Understand how ultrasonic sensors measure distance using sound waves
- Build a proximity detection circuit that triggers LEDs based on distance
- Create an intrusion detection system with visual, audio, and speech alerts
- Combine multiple inputs and outputs in a single integrated project
- Apply the full range of skills from all previous modules
What You'll Learn - How ultrasonic sensors work
- Trigger and echo pins: sending and receiving sound pulses
- Converting echo time to distance in centimetres
- Proximity-based LED control: close vs far detection
- Intrusion detection system design
- Combining sensors, LEDs, buzzers, and speech alerts
- Applying the complete maker workflow
How Ultrasonic Sensors Work
The ultrasonic sensor (also called a sonar sensor) measures distance by sending out a burst of high-frequency sound - too high for human ears to hear - and timing how long it takes for the echo to return after bouncing off an object.
Think of it like shouting across a canyon and timing the echo. If the echo comes back quickly, the cliff is close. If it takes longer, the cliff is far away. The ultrasonic sensor does exactly this, but with sound pulses that repeat many times per second.
The sensor has two main components visible on its face: a transmitter (sends the sound pulse) and a receiver (listens for the echo). On the circuit side, it has four pins:
VCC: Power supply (5V)
Trig: Trigger pin - your program sends a short pulse here to start a measurement
Echo: Echo pin - the sensor sends back a pulse whose length represents the distance
GND: Ground connection
The measurement process works like this: your FlowProgram sends a brief HIGH pulse to the Trigger pin. The sensor emits an ultrasonic burst. When the burst hits an object and bounces back, the Echo pin goes HIGH for a duration proportional to the distance. Your program reads this duration and converts it to centimetres.
The typical detection range is 2 cm to 400 cm, making it suitable for a wide variety of projects from close-range object detection to room-level proximity sensing.
Watch video: How Ultrasonic Sensors Work
Bats use the same echo-timing principle to navigate in complete darkness. Can you think of at least two other technologies - in cars, medicine, or industry - that also measure distance or depth using this idea?
Proximity Detection: Close vs Far
Your first ultrasonic project uses the sensor to control two LEDs based on distance. The concept is simple but powerful: when an object is close (less than a threshold distance), one LED lights up. When the object is far, a different LED lights up.
The circuit connects the ultrasonic sensor to the Arduino along with a green LED and a red LED. Your FlowProgram runs in a continuous loop:
1. Send a trigger pulse to the sensor
2. Read the echo duration
3. Convert the duration to distance in centimetres
4. Use a decision block: if distance is less than 10 cm, turn on the GREEN LED (close) and turn off the RED LED. Otherwise, turn on the RED LED (far) and turn off the GREEN LED
5. Loop back to step 1
This creates a real-time proximity indicator. Move your hand toward the sensor and watch the LEDs change. The green LED acts as a "detected" indicator, and the red LED shows "clear" - just like a parking sensor that beeps when you get close to an obstacle.
You can adjust the threshold distance (10 cm in the example) to suit your project needs. A shorter distance makes the sensor more selective. A longer distance makes it more sensitive to distant objects.
Action step: Test your proximity detector at three different threshold values - 5 cm, 15 cm, and 30 cm. For each setting, describe a real-world application where that specific detection range would be most useful.
Intrusion Detection System
The intrusion detection project is the capstone of this module and arguably the most impressive project in the entire course. It combines the ultrasonic sensor with LEDs, a piezo buzzer, and Text-to-Speech to create a fully functional alarm system.
The circuit includes: ultrasonic sensor (input), green LED (status: clear), red LED (status: alert), and piezo buzzer (alarm sound). The FlowProgram monitors distance continuously:
Normal state (no intrusion): When no object is detected within the alarm range, the green LED stays on and the red LED and buzzer are off. Everything is calm.
Alert state (intrusion detected): When an object enters the alarm zone (closer than the threshold), the program immediately triggers multiple responses: the red LED flashes rapidly, the buzzer sounds an alarm tone, and a Text-to-Speech media block announces an alert message.
This multi-output response demonstrates a key principle in system design: redundancy in alerts. A visual alert (LED) works when you can see it. An audio alert (buzzer) works when you can hear it but might not be looking. A speech alert provides specific information ("Intruder detected in Zone A"). Together, they create a robust alert system.
The project also demonstrates the full maker workflow that you have built across all six modules: plan the algorithm (FlowLogic skills from Modules 1-2), build the circuit (hardware skills from Module 3), control outputs (digital skills from Module 4), read sensor input (analog skills from Module 5), and integrate everything into a complete system.
Now that you have a working intrusion detector, where in your home or school would you place it for the most useful effect? What would you change about its alert behaviour to suit that specific location?
The Complete Maker Journey
Over these six modules, you have travelled from knowing nothing about programming or electronics to building real interactive systems. Let us trace the journey and see how far you have come:
Module 1 - FlowLogic 6: You learned to think in algorithms, build flowcharts, and use decision blocks. These are the thinking skills that underpin everything.
Module 2 - Virtual Projects: You applied those thinking skills to control simulated systems - robots, traffic lights, rockets - building confidence before touching hardware.
Module 3 - Components: You met the physical hardware: Arduino, breadboard, resistors, LEDs, sensors. You learned to build circuits and test them systematically.
Module 4 - Digital I/O: You made real things happen - blinking LEDs, playing music, reading button presses. You experienced the thrill of code controlling the physical world.
Module 5 - Analog I/O: You opened your projects to the environment - sensing light, temperature, and manual input. Your projects became responsive and intelligent.
Module 6 - Data Sensors: You combined everything into integrated systems that sense, decide, and act - the foundation of IoT (Internet of Things) and smart devices.
Each module built on the previous one. The flowchart skills from Module 1 were essential for every project that followed. The circuit skills from Module 3 were needed for every hardware project. The sensor reading patterns from Module 5 enabled the distance detection in Module 6.
You now have the foundational skills to continue exploring: more sensors, more actuators, wireless communication, and more complex projects. The maker journey has no finish line - only the next project waiting to be built.
Looking back at the complete journey from Module 1 to Module 6, what is the one project or moment that surprised you most about what you could build? What do you want to create next with your new maker skills?
