Beginner-friendly on the surface. Register-level underneath.

01 · Design Philosophy

Why ArduLite exists

The Arduino Core is friendly, but its abstractions — digitalWrite's pin lookup table, String's heap churn, delay()'s Timer0 dependency — cost cycles and bytes you don't always get to see. ArduLite is what you get if you rebuild the beginner-friendly vocabulary on nothing but avr-libc, and refuse anything that isn't zero-cost.

Goals

Explicit non-goals

ArduLite 1.x/2.x is scoped deliberately narrow. It does not attempt to support ESP8266, ESP32, STM32 or RP2040, and it does not ship WiFi, Bluetooth, Ethernet, MQTT, HTTP, OTA, or an RTOS. Those belong to separate projects built for those chips — bolting them onto an AVR-only, no-heap framework would break every guarantee above.

02 · Setup

Installation

Arduino IDE — via Library Manager (easiest)

1. Open the Arduino IDE, then go to Sketch → Include Library → Manage Libraries… (or press Ctrl+Shift+I).
2. Search for ArduLite in the Library Manager search box.
3. Click Install on the ArduLite entry by Ajang Rahmat.
4. Select Arduino Uno, Arduino Nano, or Arduino Mega 2560 under Tools → Board — ArduLite only targets these three.
5. Include the master header in your sketch: #include <ArduLite.h>.

Arduino IDE — manual install

1. Download the latest release archive from github.com/ArduLite/ArduLite.
2. Extract it and rename the folder to ArduLite if needed, then place it inside your Arduino libraries directory (Documents/Arduino/libraries on most systems).
3. Restart the Arduino IDE so it re-scans the libraries folder.
4. Select your board and include ArduLite.h, same as above.

PlatformIO

Add it as a library dependency from the command line — PlatformIO fetches it straight from the GitHub repository, no manual copying needed.

# from inside your PlatformIO project folder
pio pkg install --library "https://github.com/ArduLite/ArduLite.git"

# or, for an older PlatformIO CLI version:
pio lib install "https://github.com/ArduLite/ArduLite.git"

Or add it directly to platformio.ini and let PlatformIO install it on the next build:

[env:uno]
platform = atmelavr
board = uno
framework = arduino
lib_deps =
    https://github.com/ArduLite/ArduLite.git

; ArduLite does not need the Arduino framework at runtime, but PlatformIO's
; "arduino" framework is the simplest way to get an avr-gcc toolchain wired up.

Then run pio run to build, or pio run -t upload to build and flash.

03 · First Sketch

Quick Start

Three progressively richer examples: a blink, a PWM fade, and a sensor-driven brightness loop — the same three examples from the project README, shown here with a line-by-line breakdown.

1. Blink

#include <ArduLite.h>

int main() {
    Digital led(13, OUT);

    forever() {
        led.on();
        wait(1000);
        led.off();
        wait(1000);
    }
}

Digital led(13, OUT) configures pin 13 as an output once, at construction. forever() expands to while(1). wait(1000) blocks for 1000 ms using a calibrated _delay_loop_2 — no Timer0, no millis() dependency.

2. PWM fade

#include <ArduLite.h>

int main() {
    PWM led(9);

    forever() {
        for (uint8_t i = 0; i < 255; i++) { led.write(i); wait(5); }
        for (uint8_t i = 255; i > 0; i--) { led.write(i); wait(5); }
    }
}

3. Sensor-driven brightness

#include <ArduLite.h>

int main() {
    PWM led(9);
    Analog sensor(A0);

    forever() {
        int sensorValue = sensor.read();
        float brightness = sensorValue * (255.0 / 1023.0);
        led.write(brightness);
    }
}

All three sketches are in examples/, importable directly from File → Examples → ArduLite in the Arduino IDE.

04 · Core Concepts

The zero-overhead model

Two techniques make this possible almost everywhere in ArduLite:

1. always_inline + compile-time constant pins

Every pin-facing helper (digitalWriteHigh, digitalTogglePin, ...) is marked __attribute__((always_inline)). Without it, GCC would leave the call as a real function at -Os, and the pin number would stop being a compile-time constant — forcing a runtime bit-shift to compute (1 << pin). With the attribute, and a literal pin like Digital led(13, OUT), the entire register lookup folds away and one method call becomes one AVR instruction.

2. Hardware toggle instead of read-modify-write

toggle() exploits a real AVR feature: writing a logic 1 to a bit in the PINx register flips that bit of PORTx, leaving every other bit untouched — 2 cycles, no read-modify-write race. Older chips without this feature (ATmega8/16/32) automatically fall back to PORTx ^= mask.

Timer & resource map

ArduLite is careful never to let two modules fight over the same hardware timer. Know this map before combining modules in one sketch.

Core header — ArduLite.h

The master header is intentionally small. It defines short integer aliases, the forever() macro, and the two blocking-wait functions, then pulls in only Digital, Analog, PWM and Utils. Everything else is opt-in.

05 · GPIO Reference

Digital

src/ArduLiteDigital.h

Digital pin control with true zero-cost abstraction. Holds a single byte of RAM (the pin number) and nothing else — every method is always_inline.

#include <ArduLite.h>

int main() {
    Digital button(2, IN);
    Digital led(13, OUT);
    button.pullUp();   // button wired to GND, no external resistor needed

    forever() {
        if (!button.read()) {   // active-low: pressed == LOW
            led.toggle();
            wait(300);          // crude debounce
        }
    }
}

Analog

src/ArduLiteAnalog.h / .cpp

10-bit ADC reads through the AVR's built-in analog-to-digital converter. Arduino-style A0–A15 pin constants are defined automatically if not already present.

Analog sensor(A0);
sensor.setPrescaler(16);   // faster reads, slightly less accurate

int raw = sensor.read();      // 0 - 1023

PWM

src/ArduLitePWM.h / .cpp

Hardware PWM output using each chip's fast-PWM timer channels directly (Timer0/1/2/3/4 depending on pin and board) — no analogWrite(), no software bit-banging.

PWM led(9);
led.write(128);   // ~50% brightness
led.write(0);     // off, pin forced LOW

Pulse

src/ArduLitePulse.h

Measures pulse width in microseconds via Timer1, equivalent to Arduino's pulseIn() but implemented directly on the register.

Pulse input(7);

forever() {
    unsigned long width = input.read();  // microseconds, 0 = timeout
}

06 · Timing Reference

Time, Timer & Stopwatch

src/ArduLiteTime.h

ArduLite never defines millis(), micros() or delay() as free functions — that vocabulary lives inside objects (time.millis()) so it can never collide with the Arduino Core. Timer2 is the single 1 ms tick source shared by everything in this file, plus Button and Interrupt debounce.

07 · Components Reference

LED

src/ArduLiteLED.h

A semantic wrapper around Digital for LEDs, with common-anode (active-low) support.

LED led(13);
led.blink(500, 5);   // blink 5 times, 500 ms on/off

Button

src/ArduLiteButton.h

Time-based debounce with edge detection, for a button that connects the pin to GND (active-low) with the internal pull-up enabled automatically.

Button btn(2);

forever() {
    if (btn.pressed())   { /* fires exactly once per press */ }
    if (btn.isPressed()) { /* true the whole time it's held  */ }
}

Relay

src/ArduLiteRelay.h

Controls a relay module, defaulting to active-low (the common wiring on cheap relay boards, where a LOW signal energizes the coil).

Relay lamp(7);   // active-low module, the common case
lamp.on();
wait(1000);
lamp.off();

Buzzer

src/ArduLiteBuzzer.h

Drives an active buzzer — one that sounds continuously when given HIGH, as opposed to a passive buzzer that needs a driven frequency.

Buzzer buz(8);
buz.beep(200);   // sounds for 200 ms

Servo

src/ArduLiteServo.h

Generates a standard 50 Hz hobby-servo signal (1.0–2.0 ms pulse) via Timer1's Fast PWM mode 14, with zero extra interrupts and zero heap.

Servo servo;
servo.attach(9);

forever() {
    for (uint8_t ang = 0; ang <= 180; ang++) { servo.write(ang); wait(15); }
    for (uint8_t ang = 180; ang > 0; ang--) { servo.write(ang); wait(15); }
}

Ultrasonic

src/ArduLiteUltrasonic.h

Driver for the HC-SR04 distance sensor: emits a 10 µs trigger pulse, then measures how long the echo line stays HIGH. Distance follows cm = time(µs) / 58.

Ultrasonic ultra(7, 6);   // trig pin 7, echo pin 6

forever() {
    float cm = ultra.distanceCm();
}

08 · Communication Reference

UART

src/ArduLiteUART.h

Interrupt-driven serial with type-safe overloads for every AVR integer and float type, plus non-blocking line receive via callback. Global instances are ready to use out of the box.

uart.begin(9600);
uart.sendLine("I2C Scanner ArduLite");

if (i2c.probe(addr)) {
    uart.send("Device found at 0x");
    uart.send(addr, 16);   // address in hex
    uart.sendLine("");
}

#include <ArduLite.h>
#include <ArduLiteLED.h>
#include <ArduLiteUART.h>

LED led(13);

bool strEqual(const char *a, const char *b) {
    while (*a && *a == *b) { a++; b++; }
    return *a == *b;
}

void onData(const char *line) {   // called from the RX ISR on every full line
    if (strEqual(line, "on"))     led.on();
    else if (strEqual(line, "off"))  led.off();
    else if (strEqual(line, "toggle")) led.toggle();
}

int main() {
    uart.begin(9600, onData);
    forever() { }   // main loop can stay empty — RX is fully interrupt-driven
}

I2C

src/ArduLiteI2C.h

Direct TWI (Two-Wire Interface) hardware driver — no software bit-banging. A ready-to-use global instance i2c is provided.

i2c.begin();

for (uint8_t addr = 1; addr < 128; addr++) {
    if (i2c.probe(addr)) {
        uart.send("Device found at 0x");
        uart.send(addr, 16);
        uart.sendLine("");
    }
}

SPI

src/ArduLiteSPI.h

Master-mode driver on the AVR's hardware SPI registers (SPCR/SPSR/SPDR). MOSI, SCK and MISO are handled automatically; the chip-select pin is deliberately not managed by this module, so you choose it freely through Digital.

Digital cs(10, OUT);   // our chosen SS/CS pin, held HIGH
cs.on();
spi.begin();

cs.off();                                 // select slave
uint8_t reply = spi.transfer(0x42);    // send and receive at once
cs.on();                                  // release slave

09 · Interrupts Reference

Interrupt (external)

src/ArduLiteInterrupt.h

Wraps AVR's two true external-interrupt lines (INT0/INT1), with optional built-in debounce timed off the Timer2 tick.

volatile uint16_t pressCount = 0;
void onPress() { pressCount++; }

int main() {
    uart.begin(9600);
    Interrupt button(2, onPress, 3, 50);  // pin 2, RISING, 50 ms debounce

    forever() {
        // pressCount keeps incrementing in the background even while busy
    }
}

PinChange

src/ArduLitePinChange.h

Pin Change Interrupts fire on almost any digital pin — unlike the two dedicated external-interrupt lines above. Ideal for encoders, flow sensors, and revolution counters.

volatile uint32_t pulses = 0;
void countPulse() { pulses++; }

int main() {
    PinChange counter(6, countPulse, PinChangeMode::RISING);
    forever() { /* pulses keeps growing via ISR */ }
}

TimerInterrupt

src/ArduLiteTimerInterrupt.h

A scheduler for periodic callbacks that keep their rhythm even while the main loop is busy — the interrupt-driven counterpart to the polling Timer class. Runs on Timer2's COMPB unit, a separate compare channel from the 1 ms tick in ArduLiteTime.h, so the two never fight over one vector.

Digital led(13, OUT);
void blink() { led.toggle(); }

int main() {
    createTimer(500, blink);   // calls blink() every 500 ms, automatically
    forever() { }                // free to do other work — blink keeps its rhythm
}

10 · Storage & Utilities

EEPROM

src/ArduLiteEEPROM.h

A concise wrapper around avr/eeprom.h for data that survives power loss. A ready-to-use global instance eeprom is provided.

const uint16_t ADDR_COUNT = 0;

int main() {
    uart.begin(9600);
    uint32_t boots = eeprom.readUInt32(ADDR_COUNT) + 1;
    eeprom.updateUInt32(ADDR_COUNT, boots);   // endurance-friendly write

    uart.send("Powered on "); uart.send(boots); uart.sendLine(" times.");
    forever() { }
}

Utils

src/ArduLiteUtils.h / .cpp

Bit manipulation, math, pseudo-random numbers, and low-level board-aware pin register helpers — all zero-cost, mostly constexpr.

int raw = sensor.read();                         // 0-1023
long angle = scaleMap(raw, 0, 1023, 0, 180);   // re-scale like Arduino's map()
angle = constrainFast(angle, 0L, 180L);

randomSeed(time.micros());
uint16_t dice = randomRange(1, 6);

11 · Appendix

Supported boards & pin map

Version 1.x/2.x scope is intentionally three boards. Everything in this document — Digital, PWM, Servo, PinChange, SPI, I2C — auto-selects the correct register set for whichever of these is targeted at compile time.

ArduLite vs. the Arduino Core

Examples index

All 21 example sketches ship in examples/ and are importable from File → Examples → ArduLite.

Design rules (project conventions)

ArduLite's internal docs/rules.md spells out the constraints every module in this reference follows — useful context if you're extending the library yourself.

License & authorship

ArduLite is released under the MIT License, © 2025 Ajang Rahmat.

Created by Ajang Rahmat — Robot Class, PT AViSha Inovasi Indonesia.
Source: github.com/ArduLite/ArduLite

12 · For Beginners

Frequently asked questions

New to Arduino or embedded C++? Start here.