Resource Hub

Microcontroller Trainer

As you integrate the 1st Maker Space Microcontroller Trainer into your STEM curriculum, this hub provides a comprehensive guidebook, hands-on lessons, and a curriculum guide. Everything here is designed to simplify your teaching process and deepen your understanding of the trainer. If you’d like to learn more about the trainer or want to purchase a set for your classroom, click the link below.

Free Instructional Guidebook

This comprehensive guidebook for the 1st Maker Space Microcontroller Trainer provides a comprehensive introduction to the world of Arduino programming for beginners. It guides users through the foundational concepts of microcontrollers, detailing the unique features of the Arduino Uno R4 Minima-compatible MCU Trainer board. The manual offers a step-by-step journey from understanding the hardware components and the Arduino programming language to the vibrant global community of Arduino enthusiasts. It delves into the intricacies of each onboard circuit, explaining their functionalities and applications. With a focus on hands-on learning, the manual includes a series of coding exercises, tutorials in C/C++, and insights into the Arduino IDE.

Interactive Projects

Explore our collection of Arduino projects tailored for the 1st Maker Space Microcontroller Trainer. Each project provides step-by-step guidance and includes ready-to-use code for direct input into the Arduino IDE. From basic LED tasks to advanced sensor activities, enhance your programming skills and harness the full potential of the 1MS Trainer with our interactive hub.

Project 1.00 Blink

In this project, you’ll learn how to blink an LED!

Project 1.01 Blink x2

In this project, you’ll learn how to blink more than one LED!

Project 1.02 Simple LED Chase

In this project, you’ll use all four LEDs to blink a chase pattern!

Project 1.03 Analog Write

In this project, you will learn about a new function called analogWrite!

Project 1.04 Pulse LED

In this project you’ll learn how to use the analogWrite function to create a “pulsing” effect on an LED!

Project 2.00 Serial Printing

In this project, you'll learn how to utilize the Arduino's Serial communication capabilities to print text data to your computer's Serial Monitor!

Project 2.01 Talking to the Board

In this project, you'll learn how to utilize the Arduino's Serial communication capabilities to print text data to your computer's Serial Monitor!

Project 3.00 Read Input

In this project, you'll learn how to read the state of a digital input pin on the Arduino, specifically from a button connected to pin 1, and then print that state to the Serial Monitor!

Project 3.01 Blink an LED with a button

In this project, you'll learn how to control an LED with a button!

Project 3.02 AND Logic

In this project, you'll learn how to use logical AND (&&) to control an LED with two buttons!

Project 3.03 OR Logic

In this project, you'll learn how to use logical OR (||) to control an LED with either button!

Project 3.04 NOT Logic

What if you wanted to turn on an LED when SW1 was NOT pressed? In this project, you'll learn about using NOT logic with a button to turn on LED1 when SW1 is NOT pressed.

Project 4.00 Using the Piezo

In this project, you'll learn how to generate a simple sound using a Piezo buzzer!

Project 4.01 Using Functions

In this project, you'll learn the advantages of organizing your code with the help of functions!

Project 4.02 Generating a Specific Tone

In this project, you'll learn how to generate specific tones with a Piezo buzzer based on the input frequency!

Project 4.03 Adding Duration

In this project, you'll dive deeper into the capabilities of the Piezo buzzer by not only generating specific tones but also controlling the duration!

Project 4.04 There is a library for that

In this project, you'll simplify the process of generating tones with a Piezo buzzer by using the built-in “tone()” function of the Arduino library!

Project 5.00 Using the Neopixels

In this project, you'll learn how to control the onboard NeoPixels using the Adafruit_NeoPixel library!

Project 5.01 Cycling Colors with a Button

In this project, you'll learn how to cycle through different colors on the NeoPixels using a button!

Project 5.02 Using ColorHSV

In this project, you'll learn how to gracefully transition between a spectrum of colors using the onboard NeoPixels with the HSV (Hue, Saturation, Value) color model!

Project 5.03 Individually addressing Neopixels using buttons

In this project, you'll learn how to control the color of each onboard NeoPixel individually using buttons!

Project 5.04 Fading Neopixels Using Buttons

In this project, you'll learn how to gradually adjust the brightness of the onboard Neopixels using buttons!

Project 5.05 Individually Fading Neopixels

In this project we will create a dynamic light display using two Neopixels. The objective is to smoothly transition one Neopixel from off to full brightness while simultaneously dimming the other from full brightness to off, and then reversing this process.

Project 6.00 Using the Potentiometer

In this project, you'll learn how to read the values from a potentiometer and display them using the Serial Monitor!

Project 6.01 Changing Color with the Potentiometer

In this project, you'll harness the power of the potentiometer to change the color of the onboard NeoPixels using the HSV (Hue, Saturation, Value) color model!

Project 7.00 Using the OLED

In this project, you'll learn how to use the OLED display to showcase visual content!

Project 7.01 Writing Text to the Screen

In this code, you'll learn how to display text and numbers on the OLED screen!

Project 7.02 Reaction Game Using OLED

This Arduino sketch is for a reaction game using an OLED display and two buttons (SW1 and SW2)!

Project 7.03 Drawing Shapes with the OLED

We can do more than just text on the OLED. In this project, you'll learn how to draw shapes too!

Project 8.00 Light Sensor

This Arduino sketch reads the light intensity from a light sensor connected to analog pin A2 and prints the values to the serial monitor!

Project 8.01 Max and Min Brightness

This Arduino sketch reads the light intensity from a light sensor connected to analog pin A2 and continuously monitors and updates the maximum and minimum brightness values observed!

Project 8.02 Mapping Light

This Arduino sketch reads the analog value from a light sensor connected to pin A2, maps it to a corresponding brightness level for an LED connected to pin 13 (LED1), and adjusts the LED brightness accordingly!

Project 9.00 Using the Temp Sensor

This Arduino sketch reads the analog value from a temperature sensor connected to analog pin A3 and prints the temperature value (represented by the analog reading) to the serial monitor!

Project 9.01 Getting an Actual Temperature Reading

This Arduino sketch reads the analog value from the temperature sensor connected to analog pin A3 and converts it into actual temperature readings in both Celsius (°C) and Fahrenheit (°F) using functions for reading the temperature and performing the conversion!

Project 9.02 Doing Something Based on Temperature

In this project, you'll learn how to create a dynamic temperature-responsive display using the MC Trainer!

Project 10.00 Decoding IR

This Arduino sketch demonstrates how to use an Infrared (IR) receiver module to receive and decode IR remote control signals!

Project 10.01 Sending IR

In this project, you'll discover how to transmit infrared (IR) data using the MC Trainer and the IRremote library!

Project 11.00 Using the Board as a Mouse

This Arduino sketch demonstrates how to use the MC Trainer board as a mouse input device!

Project 12.00 Using the Board as a Keyboard

This Arduino sketch demonstrates how to use the MC Trainer as a keyboard input device!

Developmental Project 1.00 Vote

In this project, vote using the OLED and buttons.

Developmental Project 2.00 Mind the Dog

The program demonstrates how embedded systems can track time without stopping the program. Instead of using delay(), which pauses execution, it uses the millis() timestamp technique to calculate elapsed time. This allows multiple tasks—timers, display updates, and LED indicators—to run simultaneously.

Developmental Project 3.00 Rock, Paper, Scissors

Students upload and play a program where the Frog board uses buttons (input) and an OLED screen and piezo sounder (outputs) to randomly choose Rock, Paper, or Scissors. They then analyze the code to understand how it works—especially how a state machine controls the game flow (title screen → shuffling animation → result). Students examine how arrays, functions, timing, and randomness are used in the program, and then modify the code (e.g., changing shuffle speed, sounds, or adding features like LEDs or scoring). The lesson concludes with reflection on how hardware and software combine to create interactive systems and how randomness affects game design.

Developmental Project 4.00 Dice

The Dice program lesson teaches students how a microcontroller program works by turning the 1ST Maker Frog into a digital dice roller. Students choose to roll one or two dice using buttons, watch an animated roll with sound effects, and see the final dice values displayed on the OLED screen.

Developmental Project 5.00 Countdown

The Frog Countdown Timer lesson teaches students to program a Frog board (Arduino-based) to work as a countdown timer using buttons and a buzzer. Students learn event-driven programming, button input handling, and state-machine logic while exploring how embedded devices manage timing and user interactions.

Developmental Project 6.00 Reflex

The frog reflex program combines control, timing, input handling, display, and randomness functions to run a reaction-time game.

Developmental Project 7.00 Tic Tac Toe

This program uses an Arduino-based Tic-Tac-Toe game to teach students how programs combine inputs, outputs, logic, and simple AI to create interactive systems.

Developmental Project 8.0 IR and Frog Tag

By experimenting with variables and functions, students will deepen their understanding of how timing, conditionals, and outputs work in an interactive system.

Developmental Project 9.0: Chess Timer

The program centers on a chess timer program built on the 1ST Maker Frog board that simulates a real chess clock using embedded programming concepts. At its core, the program is a finite state machine that manages different game states. It tracks each player’s remaining time using a subtract-elapsed timing method, switches turns based on button release events, and supports features like pause/resume gestures and optional Fischer time increments.

Developmental Project 10.0: Button Battle

The Button Battle program is a two-player reaction/tapping game built on a finite state machine (FSM) with four states: MENU, READY, GO, and RESULT. The main loop uses a switch/case structure to delegate behavior to state-specific handler functions, keeping the logic organized and modular.

Purchase a Set for Your Classroom Today

Curriculum

Full lessons plans for classroom use.

Foundational Lessons

Lesson 1: Normal LED Blink

Objective:
Copy a sketch for the FMT to make an LED light blink.

Lesson 2: Buttons- Read Input

Objective:
FMT is capable of reading analog and digital inputs. In this lesson, we will read a digital input from a button.

Lesson 2.1: Logical Operators

Objective:
Students will be exploring AND logic with Frog Microcontroller Trainer in this lesson.

Lesson 3: Piezo

Objective:
Students will be exploring the Piezo component of the Frog Microcontroller Trainer in this lesson.

Lesson 3.1: Tone Functions

Objective:
Students will be exploring the tone functions of the Frog Microcontroller Trainer in this lesson.

Lesson 4: Neopixel

Objective:
Students will be exploring the Neopixel component of the Frog Microcontroller Trainer in this lesson.

Lesson 5: Potentiometer

Objective:
A potentiometer is a variable resistor. In this lesson, students will locate the potentiometer and measure the electric potential.

Lesson 6: OLED

Objective:
Students will be exploring the OLED component of the Frog Microcontroller Trainer in this lesson.

Lesson 7: Light Sensor

Objective:
Copy a sketch for the FMT to make an LED light blink.

Lesson 8: Temperature Sensor

Objective:
Students will be exploring the temperature sensor component of the Frog Microcontroller Trainer in this lesson.

Lesson 9: Analog Write

Objective:
Students will be exploring the reading of the analog and digital inputs of the Frog Microcontroller Trainer in this lesson.

Lesson 9: Infrared

Objective:
Students will be exploring the Infrared (IR) component of the Frog Microcontroller Trainer in this lesson.

Developmental Lessons

Developmental Lesson 1: Vote

Objective:
The Vote program turns the 1st Maker Space Frog (Arduino UNO R4–based board) into a simple thumbs-up / thumbs-down voting machine. Students press one of two buttons to choose YES or NO. The Frog’s OLED screen shows a large thumbs-up or thumbs-down image, and the NeoPixel “eyes” change color to match the vote (green for YES, red for NO).

Developmental Lesson 2: Mind the Dog

Objective:
Mind the Dog is a middle–high school computer science lesson designed for the 1ST Maker Frog (Uno R4 Minima) platform. The project teaches students key embedded programming concepts by building a device that tracks the elapsed time since two dogs were last taken outside. Each dog has its own timer displayed on an OLED screen, and pressing a button resets the corresponding timer.

Developmental Lesson 3: Rock, Paper, Scissors

Objective:
This program turns the 1st Maker Space Frog board (based on the Arduino UNO R4) into a simple Rock–Paper–Scissors “chooser.” Students use the two on-board buttons to start each round, watch an animation on the OLED screen, and listen to tones played on the piezo sounder. After a short shuffle, the Frog randomly chooses Rock, Paper, or Scissors and displays the result.

Developmental Lesson 4: Dice

Objective:
Students explore how a physical computing device (the 1ST Maker Frog) combines hardware and software to simulate rolling one or two dice. They run the program, observe the hardware behavior, analyze the code structure (variables, control structures, and functions), and then modify the program to add or change features.

Developmental Lesson 5: Countdown

Objective:
Students explore how real-world devices (like microwaves or stopwatches) handle user input and timing, then apply that understanding by testing, modifying, and improving their own program. The lesson emphasizes debugging, user experience (like button timing and grace windows), and the connection between logical code and human interaction

Developmental Lesson 6: Reflex

Objective:
The Reflex Test Frog Activity Pack is a hands-on coding and data lesson where students use a Frog Arduino-based board to play a reaction-time game and analyze how it works. The program displays “Ready” and “Go!” signals, measures how quickly students press the correct button, and detects mistakes (fouls).

Developmental Lesson 7: Tic Tac Toe

Objective:
This lesson uses an Arduino-based Tic-Tac-Toe game to teach students how programs combine inputs, outputs, logic, and simple AI to create interactive systems. Students use a potentiometer and buttons to play against the board, while observing how the program processes input, displays graphics, and makes decisions.

Developmental Lesson 8: IR and Frog Tag Game

Objective:
By experimenting with variables and functions, students will deepen their understanding of how timing, conditionals, and outputs work in an interactive system. The activity encourages playful experimentation and connects programming concepts to real-world behaviors.

Developmental Lesson 9: Chess Timer

Objective:
This lesson teaches students how to design and understand a real-world embedded system by building and analyzing a digital chess clock. Students learn core computer science concepts—like finite state machines, structured data (structs), enums, and non-blocking timing—through a hands-on program that manages player turns, timing, and user input. The lesson blends theory, code walkthrough, and live demonstration, then reinforces learning with guided practice and extension activities.

Developmental Lesson 10: Button Battle

Objective:
This lesson introduces students to embedded programming concepts through a hands-on two-player game called Button Battle. Students learn how the program works using a finite state machine, breaking the game into clear states (menu, ready, play, result) and understanding how transitions occur. The lesson focuses on key concepts like button debouncing, rising-edge detection, non-blocking timing, and modular code structure, showing how these ensure accurate input and smooth gameplay. Students analyze the code, trace how the game runs, and connect software logic to physical hardware (buttons, LEDs, display, sound).

Advanced Lessons

Advanced Lesson 1: Environmental Monitor

Objective:
This lesson guides high school students in building a dual-mode environmental monitor using the 1st Maker Space Frog board. Students write an Arduino program from scratch that reads temperature and light sensors, converts raw analog data into meaningful values, and displays results on an OLED screen. A potentiometer is used as a mode selector to switch between temperature and light readings, while LEDs and NeoPixels provide visual feedback.

Advanced Lesson 2: High-Low

Objective:
This lesson guides high school students in building a High–Low number guessing game using an Arduino-based Maker Frog board. Students write the program from scratch, integrating prior skills like reading inputs (buttons, potentiometer), using random numbers, and controlling outputs (OLED display, NeoPixels, sound).

Advanced Lesson 3: Stopwatch

Objective:
This lesson guides high school students through building a fully functional stopwatch using an Arduino-based 1st Maker Space Frog board. Students apply prior knowledge of buttons, displays, and timing to write a program from scratch that tracks elapsed time, supports start/stop cycles, records a lap, and displays time in a formatted M:SS.T layout.