Arduino under the Hood - AVR for Professionals

Explore the GCC compilation flow from source code to executable binary for microcontrollers, covering pre-processor, compiler, and assembler stages, and learn how to upload to an MCU.

Processes the compiler chain by handling directives starting with #, replacing MAX with 5, and showing how #include expands and how to view preprocessed output with gcc -E.

Delve into the GNU compiler collection debugger to identify syntax errors, tracing issues to exact line and column numbers while understanding how pre-processor macros and directives can mislead the debugger.

See how the GNU compiler collection translates pre-processed source code into architecture-dependent instructions, registers, and memory addresses, and how gcc -S outputs assembly mnemonics.

Explore how the GNU assembler converts compiler output into object code in ELF format, using -c, detailing sections like .text, .data, .rodata, .bss, and relocation info, with readelf examples.

The linker, the last step of the compilation flow, turns object code into an executable by resolving printf and embedding code for static linking, producing larger binaries than dynamic builds.

Explore the object copy tool to convert an executable into Intel hex format for embedded systems, detailing the hex file structure, line fields, record types, checksum, and the upload step.

Describe the Arduino upload mechanism using avrdude to load helloWorld into the MCU, covering bootloader reset, memory write, signature check 0x1e950f, and program execution.

Examine the compilation process and its stages, how interrupting flow reveals prior results, and transforming ELF to hex with the uploading mechanism; future sessions cover embedded C and pointers.

Explore C basics for embedded systems, including int8 and memory considerations on Atmega MCUs today. Compare if-else, loops, and functions to optimize readability and execution.

Explore arrays and pointers in embedded memory. Learn how arrays store multiple values, how to dereference pointers and use the address-of operator, and how pointer types affect address arithmetic.

Explore enum, union, and struct in C with the N trick to count enum entries and compare how unions share memory versus the separate memory of structs.

Compare call by value and call by reference using structs, explain memory copy to the stack, pointers, dereferencing, and relevant embedded system and compiler optimizations.

Discover how an ATmega328P MCU communicates with the outside world by examining digitalWrite and pinMode, their memory and clock costs, and the AVR library.

Explore how a pin changes state across the data direction, write, read, and sleep regions, and learn how pinMode, digitalWrite, and digitalRead interact with DDR, PIN, and PORT registers.

Access pins through memory-mapped registers on the ATmega328P using DDRB and PORTB at addresses 0x24 and 0x25, and toggle PB5 with bitwise operations.

Learn how the AVR library simplifies ATmega328P programming with predefined DDRB and PORTB macros and the _BV macro. Replace Arduino delays with _delay_ms to save space and prepare makefile builds.

Learn how makefiles streamline compilation and avrdude uploads for AVR projects, using rules, targets, prerequisites, and recipes with proper tabs and comments.

Design and execute a practical makefile by resolving dependencies, leveraging variables and implicit rules, and providing a clean, reproducible biryani-like final executable.

Explore cross-compiling for the AVR architecture with avr-gcc targeting the ATmega328P on Arduino Uno. Set MCU and clock, enable gc-sections and Wl, and optimize for size to produce compact binaries.

Explore where main resides in the Arduino program, why include directives vanish, and how main.cpp, Arduino.h, and the avr library enable cross-compiling a blinking led with a Makefile.

Learn to upload a blinking LED program to an ATmega328P using avrdude, configure bootloader-based uploads, and understand key avrdude parameters (-V, -F, -P, -c, -b, -U) and port setup.

Master cross-compiling the ATmega MCU with Makefiles and avrdude, ditch the Arduino IDE, and write efficient code for faster execution and longer battery life. Explore hard-to-debug, intermittent bugs.

Explore the classic buffer overflow, its consequences, and how to avoid them, with a focus on memory layout, stack and heap, and return addresses.

learn practical buffer overflow mitigation by avoiding unsafe C library calls, using safe alternatives like strncopy, and applying stack canaries or heap-based canaries with malloc, balancing efficiency in embedded AVR.

Introduce two free books on safe and secure coding standards for C and C++, highlight common mistakes that affect stability and security, and point to a wiki with rule identifiers.

Understand how uninitialized local variables and heap memory can cause bugs, and learn safer memory handling with snprintf versus sprintf, plus validating return values to prevent buffer overflows.

explains how to safely manage memory and avoid dereferencing null pointers in C, covering malloc and free, input_str and c_str checks, and setting freed pointers to null.

Explore how padding in structures affects memory comparisons, contrasting byte-by-byte with element-wise methods. See how packed versus unpacked structures and memory banks influence footprint and access efficiency on ATmega.

Explore buffer overflow risks by ensuring storage space includes the NULL terminator when copying strings. The example highlights an off-by-one error and the need to loop until i < n-1.

Identify and fix dangling pointers by saving the next element before freeing the current one in a linked list, preventing undefined behavior when accessing freed memory.

Explore format string vulnerabilities in printf and scanf usage, showing how swapped parameters can let an unintended pointer reveal memory; fix by simply swapping the two arguments.

Execute shell commands through the C function system and expose security risks from PATH manipulation, tilde expansions, and redefining the $HOME directory.

Discover how pseudorandom number generators rely on seeds to produce sequences, and learn strong-seed methods for AVR systems using time-based seeds, adc readings from floating wires, and hardware sources.

32-bit floats reserve 23 bits for the significand, 1 sign bit, and 8 exponent bits, limiting precision. Avoid using floats as loop counters or precise comparisons; derive values within tolerance.

Explore how buffer overflow can overwrite a stack return address and how to mitigate it, using GDB to inspect state and backtrace faults, with a preview of ATmega timers.

Explore ATmega timers and counters, including TCNT and OCRnA/B, and learn how they count, overflow, and generate waveforms in normal, CTC, and PWM modes.

Explore how timer clocks are configured in AVR microcontrollers, including TCCRnB clock sources, edge detectors, and prescalers, with timer2’s TOSC pins enabling an independent real-time clock.

Learn the normal mode of ATmega timers, where clearing WGM bits in TCCRnA and TCCRnB makes TCNT run to top and overflow. Prescalers determine the slope of the resulting sawtooth.

Explore timer on compare match (CTC) mode with TCNT and OCRnA to reset at a chosen TOP and toggle OCnA for output. Learn timer resolution and how prescaler affects frequencies.

Explore fast PWM on the ATmega, using duty cycle to control LED brightness while the period remains fixed. Learn how TOP, OCR, and COMnx configure the OC pin timing.

Explain phase correct pwm, where the timer counts from top to bottom and the oc pin toggles as tcntn passes ocrnx, highlighting differences from fast pwm for motor control.

Explore phase and frequency correct pwm mode in ATmega328P, where timer1 updates OCR1A at top and OCR1B at bottom to produce a symmetric TCNT1 waveform and avoid glitches.

Compare AVR timer architectures across timer 0, 1, and 2. Understand the input capture unit, ICR, ICP, and edge detection for precise timestamps.

Explore timers in the ATmega328P, their modes, hardware units, clock sources, prescalers, and differences among the timers, and learn how to configure them; appreciate how interrupts reduce CPU load.

Explore how interrupts replace polling by letting the system react to events and use the interrupt vector table, subroutines, volatile data, and nested priorities.

Learn to implement timer1 interrupts in CTC mode on an ATmega328P by configuring prescaler 1024, OCR1A 15624, enabling compare-match interrupts, and calling doSomething() in an ISR to blink an LED.

Declare interrupt service routines and map them to specific interrupts via the interrupt vector table, including TIMER1_OVF_vect. Learn aliasing ISRs, BADISR_vect catch-all, and EMPTY_INTERRUPT, plus activating interrupts.

Activate local interrupts on Timer0 by setting A, B, or overflow in timer mask register, and control interrupts with sei() and cli(), noting I bit in SREG defers when off.

Explore the interrupt vector table as a fixed, hardwired address book routing events like timer 2 unit A compare to the correct ISR, starting at the reset vector address 0.

Examine the interrupt vector table of a blinking led program, map __vector_11 to doSomething and main by disassembling the elf, and note byte versus word addressing for memory optimization.

Explore the volatile attribute and why it matters in embedded systems, using a blinking LED example to show how volatile prevents compiler optimization when interrupts modify a global count.

Explore internal and external interrupts on the ATmega328P, focusing on PCINT pin change interrupts, groups and IVT routing, and edge detection with EICRA for INT0 and INT1.

Learn how AVR interrupt priority works when two interrupts fire together: lower vector numbers win, so timer compare A runs before compare B, with B deferred until A finishes.

Explore how an interrupt saves the program counter, jumps to the ISR via the vector table, deactivates global interrupts, uses RETI, and how ISR_NOBLOCK enables nested interrupts.

Avoid delays and polling in ISRs; start ADC conversion in a timer ISR and rely on an ADC ready interrupt, keeping ISRs short and crisp.

Explore ATmega interrupts: ISR, shared code for multiple sources, empty and BADISR, global enable, volatile, and vector table handling of events; avoid long ISR waits, and preview communications protocols.

Configure the ATmega UART by choosing 5–9 data bits, parity, stop bits, and baud timing, then understand the start bit, idle state, and clock skew implications.

Explore the USART protocol for AVR, highlighting the XCK clock line, omitting start and stop bits, and enabling higher data rates and clock frequencies by eliminating receiver clock synchronization issues.

Examine the parity bit in the atmega avr, covering no, odd, and even parity, its xor-based calculation, error detection, hardware implementation, and CRC as a more advanced option.

Explore duplex, half-duplex, and simplex transmission modes in uart and usart. Learn how the master clocks, idle data, and dummy data influence data flow and timing between MCUs.

Explore how the ATmega UART uses three independent blocks—clock generator, transmitter, and receiver—to enable baud rate control via UBRRn, data shifting through UDRn, and parity generation.

Configure atmega uart/usart via UCSRnA, UCSRnB, and UCSRnC, enabling rx and tx, and setting data bits, parity, and stop bits, while monitoring UDRE, RX complete, and TX complete.

Configure the transfer speed on AVR using UBRR and U2Xn based on the system clock to match baud rates like 9600 and 115200, balancing rounding errors and clock skew.

Program a simple uart on Arduino to turn the onboard led on or off by sending ASCII '1' and '0' at 9600 baud, using blinkingUART.c, a Makefile, and setbaud.h.

Explore UART and USART communication, including start, stop, and parity bits, parity calculation, and duplex modes, then configure UART registers, speeds, and errors, with a look ahead to I2C.

Explore the I2C/TWI two-wire bus on the ATmega328P, connecting EEPROMs, RTCs, and sensors like BH1750 while learning how the protocol handles conflicts and supports multiple devices.

Learn how the I2C bus uses two wires, SDA and SCL, with pull-up resistors enabling master and slave communication. Know practical limits, like short cable length and capacitance constraints.

Explore how a master and a slave exchange data on the I2C bus, using SDA and SCL lines, with clock control and start and stop conditions.

Explore how I2C addressing works, including 7-bit and 10-bit addresses, start and repeated start conditions, and acknowledgments enabling multi-device bus communication.

See how two I2C masters resolve conflicts on the bus, with SDA and SCL signaling and automatic contention handling when address bits differ, causing one master to drop out.

Explore how the ATmega328P I2C/TWI module uses registers and status bits to manage master and slave transfers, and configure bus frequency with TWBR and a prescaler.

Configure an I2C master and slave bus by selecting pull-up sizes (1.5kOhm–2.5kOhm at 100 kHz, 750Ohm at 400 kHz) based on rise time and bus capacitance.

Explore practical i2c master-slave communication on Arduino with Freeduino, using internal pull-ups to drive a slave at address 0x12 and blink the onboard led.

Build a static i2c library for avr by grouping i2c_start and i2c_write into libi2c.a, create header guards, and link with -li2c in your main program.

Learn the I2C bus protocol, including start/stop conditions, addressing, and conflict resolution with multiple masters, and build a software I2C master library.