ArduLearn uses interactive simulators and camera-proctored tests. They work best on a large screen with a mouse or trackpad and a webcam. On a phone, some parts will be small and harder to use.
For the best experience, open this link on a computer in Chrome, Edge or Firefox.
If you continue on a phone, use landscape mode and allow camera access for the tests.
Best viewed on a large screen. The simulators and tests are easier to use on a desktop or laptop.
Learner 0% complete
ADMINProgress is not recorded while you are signed in as admin.
Scholaritte · 5-day certificate course · Electronics & embedded systems
Arduino from first blink to connected device: electronics, code and real troubleshooting.
Learn the electronics behind every circuit, write Arduino C++ that never blocks, read sensors, drive LEDs, servos and motors, talk over Serial, I²C and SPI, take the Uno apart in 3D, and finish with a low-power ESP32 IoT design. Built from the official Arduino documentation, the ATmega328P and ESP32 datasheets, and university electronics teaching.
15 sessions over 5 days15 narrated video lessons16 simulators & labs1 3D board teardown1 free-build Maker Lab: wire & program6 troubleshooting challenges20 + 30 question pre/post-tests
UNO · A0 → ~9analogWrite(9, analogRead(A0) / 4) · demo modelLIVE MODEL
After your payment is verified, Scholaritte sends you an access code. Use the email ID you registered with.
New learner
Pay, then register
Pay the fee by UPI, then register with the transaction reference. Your access code follows once the payment is verified.
Programme
Five days, one logical line
Electricity and the board first, then programming and digital I/O, then analog signals, PWM and sensors, then motors, communication buses and interrupts, and finally project engineering, troubleshooting and IoT. Every session has a narrated video lesson, theory, a simulator or practice task and two questions, and unlocks the next one. Each new day opens 24 hours after you start Day 1 (Day 2), 48 hours (Day 3) and so on.
Who it is for
Engineering and polytechnic students (ECE, EEE, biomedical, mechatronics, computer science), teachers, hobbyists and anyone starting in embedded systems. No prior coding or electronics is assumed.
What you will be able to do
Design safe circuits, write non-blocking sketches, read sensors accurately, drive motors, connect I²C/SPI/UART modules, budget power and debug a failing project methodically.
Certificate
Pass the camera-proctored post-test (pass mark shown in the course) to download a verifiable certificate.
One last check
Are these details correct?
Name on your certificate
Email ID for your access code and login
These cannot be changed after you register. If anything is wrong, go back and fix it now.
Day 1 · 09:00
Pre-test
20 questions20 minutesCamera-proctoredNot graded for the certificate
The pre-test measures what you already know, so you can see how far you travel in five days. It does not count toward your certificate.
Before you begin: sit facing your camera in good light, keep your phone out of sight, close other tabs and stay alone in frame. The proctor runs in your browser: it checks that one face is present and looking at the screen, counts tab switches, and uses a small YOLO object-detection model to look for a phone. No video is uploaded; only counts are recorded.
Day 1 · Session 1
The Arduino ecosystem
09:45–11:00Boards · IDE · microcontrollersLab: board selector
Video lesson
Arduino began in 2005 at the Interaction Design Institute Ivrea in Italy as a cheap, simple board that design students could program without an electronics degree. Because the hardware designs, the IDE and the core libraries are open source, it grew into the world’s most widely used platform for learning embedded systems, prototyping products and building research instruments.
Three things make up the ecosystem: the boards (a microcontroller plus power, USB and headers), the software (the Arduino IDE or Arduino Cloud editor, a C++ compiler and the bootloader), and the libraries and community (drivers for thousands of sensors, displays and modules).
Choosing a board
Board
Processor
Memory
I/O & extras
Logic level
Uno R3
ATmega328P, 8-bit AVR, 16 MHz
32 KB flash · 2 KB SRAM · 1 KB EEPROM
14 digital (6 PWM), 6 analog, 1 UART
5 V
Nano
ATmega328P, 16 MHz
Same as Uno
Same pins in a 45 × 18 mm breadboard package (8 analog)
5 V
Mega 2560
ATmega2560, 16 MHz
256 KB flash · 8 KB SRAM
54 digital (15 PWM), 16 analog, 4 UARTs
5 V
Leonardo / Micro
ATmega32U4, 16 MHz
32 KB flash · 2.5 KB SRAM
Native USB: can act as a keyboard or mouse (HID)
5 V
Uno R4 Minima / WiFi
Renesas RA4M1, Arm Cortex-M4, 48 MHz
256 KB flash · 32 KB SRAM
Uno form factor, 12-bit DAC, CAN; WiFi model adds an ESP32-S3 and LED matrix
5 V
ESP32 boards
Dual-core Xtensa LX6, up to 240 MHz
≈ 520 KB SRAM · 4 MB flash typical
Wi-Fi + Bluetooth, touch pins, 12-bit ADC, deep sleep
3.3 V
Microcontroller or single-board computer? A microcontroller (Arduino, ESP32) runs one program directly on the hardware, starts in milliseconds, has precise timing and runs for months on batteries. A single-board computer such as a Raspberry Pi runs Linux: great for cameras, AI and web servers, but it boots slowly, needs far more power and cannot guarantee microsecond timing.
Where Arduino is used
Education
Labs in schools, polytechnics and universities worldwide; a common platform for final-year projects.
Prototyping
Engineers prove a product idea in days before designing a custom PCB.
Research instruments
Data loggers, lab automation, environmental and biomedical sensing rigs.
Industry & IoT
Arduino Pro and ESP32 modules in monitoring, building automation and agriculture.
Do it: choose the right board
Pick the best board for each project. All six must be right.
Based on: Arduino documentation (docs.arduino.cc) board pages; Microchip ATmega328P/2560/32U4 and Espressif ESP32 datasheets; Banzi & Shiloh, Getting Started with Arduino.
Day 1 · Session 2
Electricity for makers: V, I, R & power
11:00–13:00Ohm’s law · LEDs · breadboardsLab: LED resistor lab
Video lesson
The equations you will use every day
V = I × ROhm’s law. 5 V across 220 Ω drives 22.7 mA.
P = V × I = I² × RPower. Most small resistors are rated ¼ W (250 mW). A 220 Ω resistor carrying 15 mA dissipates about 50 mW.
R = (Vsupply − Vf) ÷ ILEDLED series resistor. Red/yellow Vf ≈ 1.8–2.2 V; green ≈ 2.0–3.0 V; blue/white ≈ 2.9–3.3 V.
Vout = Vin × R2 ÷ (R1 + R2)Voltage divider (Session 7 uses it for sensors).
Limits you must respect on an Uno
Per pin
Design for ≤ 20 mA. The datasheet’s 40 mA is an absolute maximum, not an operating point.
Whole chip
About 200 mA total through the ATmega328P’s supply pins.
5 V from USB
A 500 mA polyfuse protects the computer. Motors and LED strips need their own supply.
3.3 V pin
About 50 mA on the Uno R3: enough for a sensor, not a radio module.
Safety. Arduino work is low voltage, but lithium batteries, mains adapters and motor supplies can still burn or shock. Never connect mains wiring to a breadboard, never short a Li-ion cell, and disconnect power before rewiring.
Reading resistors and using a breadboard
Band colours
Value
Typical use
Red · Red · Brown
220 Ω
LED on 5 V
Brown · Black · Red
1 kΩ
Transistor base, LED on 3.3 V (dim)
Brown · Black · Orange
10 kΩ
Pull-up / pull-down, dividers
Yellow · Violet · Red
4.7 kΩ
I²C pull-ups
On a breadboard each short row of five holes is connected; the long side rails carry power and ground. Integrated circuits and push-buttons straddle the centre gap.
Do it: LED resistor lab
Pick the supply, LED colour and resistor. Watch the current, the resistor power and the pin status. Complete the four tasks.
Based on: Horowitz & Hill, The Art of Electronics; MIT OCW 6.002 Circuits and Electronics; Microchip ATmega328P datasheet (DC characteristics).
Day 1 · Session 3
Inside the Uno: 3D board teardown
14:00–16:00Reverse engineering · pin mapLab: 3D teardown
Video lesson
Reverse engineering is the disciplined way to learn from a mature design: observe it working, identify each part, explain what it does and ask why it is there. The Uno R3 is ideal because its schematic is published. The 3D model below is schematic: positions and proportions follow the real board, but details are simplified.
3D teardown
Drag to rotate, scroll to zoom, use the slider to explode the board. Click every part (or its tag) to read its function, design notes and typical failures. Press “Run” to see the L, TX and RX LEDs work.
Uno R3 pin map
Pins
Main role
Also
D0 (RX), D1 (TX)
Hardware UART, shared with USB
Keep free while uploading
D2, D3
External interrupts INT0, INT1
D3 is PWM
~3, ~5, ~6, ~9, ~10, ~11
PWM (analogWrite)
5/6 at ≈ 980 Hz; the rest ≈ 490 Hz
D10–D13
SPI: SS, MOSI, MISO, SCK
D13 drives the on-board L LED
A0–A5
10-bit analog inputs
Digital pins 14–19; A4 = SDA, A5 = SCL (I²C)
AREF, IOREF
External ADC reference; I/O voltage for shields
Never exceed 5 V on AREF
VIN, 5V, 3.3V, GND
Power in/out
Do not back-feed 5 V while USB is connected
Teardown worksheet
Subsystem
Question to answer
Answer
Power
What protects the PC’s USB port?
A resettable polyfuse (≈ 500 mA)
Upload
How can code be loaded without a programmer?
The 16U2 USB-serial bridge plus the bootloader in the 328P
Serviceability
What if the microcontroller is damaged?
The DIP-28 chip is socketed and replaceable; ICSP can burn a new bootloader
Design reuse
How do shields fit every Uno?
The header spacing and pin order are a de-facto standard
Based on: Arduino Uno Rev3 schematic and datasheet (docs.arduino.cc, CC BY-SA); Microchip ATmega328P and ATmega16U2 datasheets.
// Blink: the "hello world" of embedded systems
const int LED = 13; // the on-board L LED
void setup() {
pinMode(LED, OUTPUT); // runs once after reset
Serial.begin(9600); // open the serial port
Serial.println(F("Ready")); // F() keeps the text in flash
}
void loop() { // runs forever
digitalWrite(LED, HIGH);
delay(500);
digitalWrite(LED, LOW);
delay(500);
}
Compile
The IDE runs avr-gcc (or arm-gcc / xtensa-gcc for R4 and ESP32), links the Arduino core and libraries, and produces a binary.
Upload
The board is reset, the bootloader listens for a moment and writes the new program into flash.
Run
setup() once, then loop() forever. The Serial Monitor and Plotter show what the program is doing.
Data types on an 8-bit Uno
Type
Size
Range
Use for
bool
1 byte
true / false
Flags, states
byte / uint8_t
1 byte
0 … 255
PWM values, small counters
int
2 bytes
−32 768 … 32 767
Pin numbers, ADC readings
unsigned long
4 bytes
0 … 4 294 967 295
Time from millis() and micros()
float
4 bytes
≈ 6–7 significant digits
Calculated physical values (slow on AVR)
char[] / String
varies
text
Prefer fixed char arrays on boards with 2 KB SRAM
Note: on 32-bit boards (Uno R4, ESP32) an int is 4 bytes. Use int16_t, uint32_t and friends when the size matters.
Practice: predict the output
Read each snippet, then choose what the Serial Monitor shows. You get one try per snippet.
Based on: Arduino Language Reference; Simon Monk, Programming Arduino; Microchip AVR-GCC documentation.
const unsigned long INTERVAL_A = 200, INTERVAL_B = 700;
unsigned long lastA = 0, lastB = 0;
void loop() {
unsigned long now = millis();
if (now - lastA >= INTERVAL_A) { lastA = now; digitalWrite(LED_A, !digitalRead(LED_A)); }
if (now - lastB >= INTERVAL_B) { lastB = now; digitalWrite(LED_B, !digitalRead(LED_B)); }
readButton(); // runs thousands of times per second
}
millis()
Milliseconds since reset, as an unsigned long. Rolls over after ≈ 49.7 days.
micros()
Microseconds (4 µs resolution on a 16 MHz Uno). Rolls over after ≈ 71.6 minutes.
Always subtract
now − last ≥ interval is rollover-safe. now > last + interval is not.
When delay() is fine
Short waits in setup(), or a few µs with delayMicroseconds() for sensor timing.
Do it: delay() versus millis()
Compare the two styles. Press the button while the LEDs blink and see who notices. Complete the four tasks.
Based on: Arduino built-in example BlinkWithoutDelay; Arduino reference for millis() and micros(); Adafruit "Multi-tasking the Arduino".
count = Vin ÷ Vref × 102310-bit ADC on the Uno: 0–1023. With a 5 V reference, one step ≈ 4.88 mV. A conversion takes ≈ 100 µs.
Vin = count × Vref ÷ 1023Convert back to volts in your sketch: float v = analogRead(A0) * 5.0 / 1023.0;
Vout = Vin × R2 ÷ (R1 + R2)Divider. For a resistive sensor, choose the fixed resistor near the geometric middle of the sensor’s range for the widest span.
References and accuracy
DEFAULT
The 5 V supply. Any change in the USB voltage shifts every reading.
INTERNAL (1.1 V)
Stable band-gap reference for small signals such as an LM35 (1.1 mV per step ≈ 0.1 °C).
EXTERNAL
Voltage on AREF (≤ 5 V). Call analogReference(EXTERNAL) before the first analogRead.
Other boards
ESP32 and Uno R4 have 12-bit (0–4095) ADCs; ESP32 inputs are 3.3 V maximum and slightly non-linear.
Never exceed the supply. A voltage above 5 V (3.3 V on ESP32) on an analog pin can destroy the input. Use a divider for batteries and anything above the logic level.
Do it: ADC bench
Switch between a potentiometer, an LDR divider and a 12 V battery divider. Change the reference. Complete the four tasks.
Based on: ATmega328P datasheet (ADC chapter); Arduino reference for analogRead() and analogReference(); MIT OCW 6.002.
duty = value ÷ 255 · Vavg = duty × 5 VanalogWrite(pin, 0–255) on pins 3, 5, 6, 9, 10, 11. The pin is always fully on or fully off; the load or your eye averages it.
Timer
Pins
Default PWM
Also used by
Timer0 (8-bit)
5, 6
≈ 980 Hz
millis(), micros(), delay(): do not reconfigure
Timer1 (16-bit)
9, 10
≈ 490 Hz
Servo library (disables PWM on 9 and 10)
Timer2 (8-bit)
3, 11
≈ 490 Hz
tone()
Servos
#include <Servo.h>
Servo s;
void setup() { s.attach(3); } // any digital pin
void loop() { s.write(90); } // 0–180° → 544–2400 µs pulses at 50 Hz
// s.writeMicroseconds(1500) gives finer control
Power servos separately. A small SG90 can draw 500–700 mA when it starts or stalls: enough to reset an Uno powered from USB. Use a separate 5 V supply and join the grounds.
Do it: PWM scope
Choose a pin, set the value, attach the Servo library and set the servo pulse. Complete the four tasks.
Based on: ATmega328P datasheet (Timer/Counter chapters); Arduino reference for analogWrite() and the Servo library.
Day 3 · Session 9
Sensors, signals & calibration
14:00–16:00Ultrasonic · temperature · calibrationLab: sensor bench
Video lesson
Common sensors and how to read them
Sensor
Measures
Output
Read with
HC-SR04
Distance 2–400 cm
Echo pulse width
10 µs trigger, pulseIn(ECHO, HIGH); cm ≈ µs ÷ 58
LM35 / TMP36
Temperature
10 mV/°C (TMP36: 500 mV offset)
analogRead, preferably with the 1.1 V reference
DHT11 / DHT22
Temperature + humidity
Single-wire digital
DHT library; read at most every 2 s
BME280
Temperature, humidity, pressure
I²C / SPI
Adafruit or SparkFun library
MPU-6050
Acceleration + rotation
I²C (0x68)
Library; filter or fuse the data
LDR, thermistor, FSR
Light, temperature, force
Resistance
Voltage divider + analogRead
Getting trustworthy numbers
Calibrate
Two known reference points give gain and offset: true = (raw − raw₀) × (ref₁ − ref₀) ÷ (raw₁ − raw₀) + ref₀.
Filter
Average several samples, or use a median filter to reject spikes. Faster response needs fewer samples.
Respect timing
Some sensors need warm-up or a minimum interval; read the datasheet’s timing diagram.
Check plausibility
Reject impossible values (e.g. 0 cm or 85 °C from a room sensor) and report a fault instead of a number.
Practice: sensor bench
Convert raw readings into physical values. Use “New numbers” to practise more.
Based on: HC-SR04, LM35 (Texas Instruments), DHT22 and Bosch BME280 datasheets; Arduino Project Hub sensor tutorials.
Logic-level N-MOSFET (e.g. IRLZ44N) or NPN + base resistor
Flyback diode across the motor; 10 kΩ gate pull-down
DC motor, both directions
H-bridge: TB6612FNG, DRV8833, L298N
L298N is bipolar and loses ≈ 2 V; MOSFET bridges run cooler
Relay
Relay module (transistor + diode built in)
Check whether the input is active LOW
Unipolar stepper (28BYJ-48)
ULN2003 darlington array
≈ 2048 steps per output revolution (geared)
Bipolar stepper (NEMA 17)
A4988, DRV8825, TMC2209
Set the current limit; 200 full steps/rev; microstepping
Hobby servo
None: signal pin + separate 5 V
Servo library
Three habits that prevent most motor problems: a separate motor supply, a common ground, and decoupling (100 nF across the motor plus a large electrolytic across the supply).
H-bridge truth table (L298N / TB6612-style inputs)
IN1
IN2
Switches on
Result
HIGH
LOW
S1 + S4
Forward (speed = PWM on EN)
LOW
HIGH
S2 + S3
Reverse
LOW
LOW
none
Coast
HIGH
HIGH
both low sides (driver dependent)
Brake
Do it: H-bridge bench
Operate a discrete H-bridge switch by switch. Choose the supply and protection. Complete the five tasks.
Based on: STMicroelectronics L298, Toshiba TB6612FNG, Allegro A4988 and Infineon IRLZ44N datasheets; Horowitz & Hill, The Art of Electronics (inductive loads).
An I²C scanner sketch lists every address that answers: the fastest wiring check there is.
Mind the logic level
3.3 V modules need level shifting from a 5 V Uno (except I²C modules with built-in shifters).
Do it: protocol bench
Decode a UART frame by eye, work out a character time and identify devices on an I²C bus.
Based on: NXP UM10204 I²C-bus specification; ATmega328P datasheet (USART, TWI, SPI); Arduino Wire and SPI library references; SparkFun serial and I²C tutorials.
Day 4 · Session 12
Interrupts, state machines & low power
14:00–16:00ISRs · switch/case · sleepLabs: traffic light · battery life
Video lesson
Interrupts done right
volatile unsigned long pulses = 0; // shared with the ISR
void countPulse() { pulses++; } // short: no Serial, no delay
void setup() {
pinMode(2, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(2), countPulse, FALLING);
}
void loop() {
noInterrupts(); unsigned long n = pulses; interrupts(); // atomic copy
Serial.println(n);
}
Good uses
Rotary encoders, flow-meter or RPM pulses, wake-up from sleep, very short events.
Avoid
Reading a button that a 20 ms poll handles fine; long work inside the ISR.
Practice: traffic-light state machine
Describe the behaviour as states, durations and transitions. The sketch is generated as you type.
Low power
Iavg = (Iawake × tawake + Isleep × tsleep) ÷ T · life ≈ capacity × 0.85 ÷ IavgThe 0.85 factor allows for battery ageing, temperature and self-discharge.
An ATmega328P in power-down draws well under 1 µA, but an Uno board keeps drawing tens of mA through its regulator, USB chip and power LED. Battery nodes use a bare chip, a modified Pro Mini, or an ESP32 in deep sleep (≈ 10 µA).
Based on: Arduino reference for attachInterrupt(); ATmega328P datasheet (interrupts, sleep modes, power-reduction register); Nick Gammon’s power-saving notes.
Day 5 · Session 13
Project engineering & power budget
09:00–11:00Requirements · BOM · powerLab: power budget
Video lesson
From idea to working build
Requirements: what it must do, accuracy, update rate, run time, environment, cost.
Block diagram: power, controller, sensors, actuators, communication, user interface.
Parts and BOM: choose parts with clear datasheets and libraries; list quantity, supplier and cost.
Power budget: add typical and peak currents; pick a supply with ≥ 25% margin.
Pin plan: assign pins by capability (PWM, interrupts, I²C, SPI, analog) before wiring.
Build in stages: one block at a time, each with its own small test sketch.
Integrate and test: against every requirement; keep a test log.
Powering a project
Source
Into
Good for
Watch out
USB 5 V
USB socket
Development, light loads
≈ 500 mA polyfuse limit
5 V adapter
5V pin / module rail
Motors, servos, LED strips with the board
Bypasses the regulator: must be a clean, regulated 5 V
7–12 V adapter
Barrel jack / VIN
Board only
Linear regulator heat = (Vin − 5) × I
Li-ion + boost / buck
5V or 3.3V rail
Portable devices
Protection circuit, charger, low-voltage cut-off
Build it: Maker Lab
Now build real circuits. In the Maker Lab you pick parts, wire them to the Uno and program them. Complete the four builds (blink, button, potentiometer dimmer, ultrasonic distance) to finish this session. The lab stays open from the top bar for your own projects.
Do it: power budget
Pick the parts the specification needs, size the supply and check the regulator heat.
Based on: Arduino Uno Rev3 power documentation; engineering design-process guidance from university capstone courses; component datasheets.
Day 5 · Session 14
Troubleshooting lab
11:00–13:00Decisions under time pressure6 challenges
Video lesson
Six real faults from student labs and maker benches: uploads that fail, boards that reset, phantom button presses, blank displays, firmware that dies after a day and garbled serial data. Each has three decisions with a 40-second clock. Pass at least five of the six to complete the session.
Fault-finding checklist
Power
Is the ON LED lit? Measure 5 V and 3.3 V. Does it brown out under load?
Ground
Do all modules and supplies share GND?
Wiring
Compare against the schematic, pin by pin. Check breadboard rails that are split in the middle.
Software
Right board and port? Matching baud? Print the values and the code path.
Challenges
Based on: Arduino Help Center troubleshooting articles; Arduino Forum common-problem threads; teaching-lab fault logs.
#include <WiFi.h>
#include <PubSubClient.h>
#include "secrets.h" // WIFI_SSID, WIFI_PASS, MQTT_HOST: never commit this file
WiFiClient net; PubSubClient mqtt(net);
void setup() {
WiFi.begin(WIFI_SSID, WIFI_PASS);
while (WiFi.status() != WL_CONNECTED) delay(200);
mqtt.setServer(MQTT_HOST, 1883);
}
void loop() {
if (!mqtt.connected()) mqtt.connect("lab-node-1");
mqtt.loop();
static unsigned long last = 0;
if (millis() - last >= 10000) { last = millis();
mqtt.publish("lab/room1/temp", String(readTemp(), 1).c_str()); }
}
From prototype to product
Hardware
Breadboard → perfboard → PCB (KiCad). Add reverse-polarity, over-current and ESD protection; choose connectors that lock.
Firmware
Version control (Git), a watchdog, logging, configuration outside the code and an over-the-air (OTA) update plan.
Compliance
EMC and safety testing (e.g. CE / FCC; BIS and WPC approvals in India for radio products); RoHS materials.
Security
Unique credentials, encrypted connections (TLS), no secrets in public repositories, secure update channels.
Do it: bring-up plan + capstone design review
Order the bring-up steps for an ESP32 solar weather node, then pass the design review.
Based on: Espressif Arduino-ESP32 documentation; OASIS MQTT 5.0; ETSI EN 303 645 consumer IoT security baseline; KiCad documentation.
Day 5 · 15:30
Post-test
30 questions40 minutesCamera-proctoredPass mark 70%
The post-test covers all fifteen sessions. You get your score, a topic breakdown and an explanation for every question. The same proctoring rules apply as in the pre-test.
Day 5 · Results
Results and certificate
References and further reading
Pre-test
Question 1 of 20
20:00
ArduLearn · Maker Lab
Pick parts, wire them, program the Uno
A free-build bench. Add sensors and outputs from the tray, connect each part pin to a board pin, write a sketch in Arduino C++ and press Upload & run. Buttons, knobs and sliders on the parts change the real-world inputs while your code runs. Load an example to start, then change it. Supported: pinMode, digitalRead/Write, analogRead/Write, delay, millis, Serial, map, tone, pulseIn, Servo and your own functions. Simulator differences: numbers behave like float (7 / 2 gives 3.5) and a missing semicolon is usually tolerated, so keep the habits of real C++.