Hi everyone, I would like to share with the community an educational reflection on programming and microcontroller architecture. The Arduino ecosystem is extraordinary because it allows anyone to get a project up and running in minutes, thanks to the abstraction of C++. However, this high level of abstraction completely hides the hardware layer. Many beginners end up seeing microcontrollers as a "magic box" or a mysterious intelligence. In reality, any MCU is just a collection of logic circuits, switches, and bits. To address this, I have been working on a purely educational simulator/tool focused on using pure Assembly (ASM) specifically for the ATmega328P. I want to be very clear: the goal is not to study every single MCU architecture or learn Assembly for every chip on the market. Instead, the purpose is to use the ATmega328P and its Assembly as a specific, concrete tool to gain a generic, universal understanding of what happens inside any microcontroller. Today, the core concept of a "register" is completely hidden from students, which I believe hurts their general understanding of computing. Seeing how an LED on pin 13 turns on simply by changing a single bit in the register 5 strips away the mystery. Using Assembly just once as a learning exercise helps to: Reveal the mechanical, physical nature of hardware that is common to all microcontrollers. Understand how registers, variables, and physical pins actually interact at a logical level. Provide a solid, clear conceptual foundation before moving back to high-level code. This is a strictly educational, non-commercial idea, born solely out of a love for teaching digital electronics. It is meant to complement Arduino's excellent C++ tools, not replace them. What do you think about using this specific example to teach a generic, foundational concept of microcontrollers to beginners? If anyone is interested in the tool I developed for this, I would be happy to share more details. .org 0 rjmp init .org 0x60 init: sbi 5,5 loop: rjmp loop When a user click link https://costycnc.github.io/avr-compiler-js/?code=arduino-forum/ledon/led-faint.asm, a new window opens with the tool, and the ASM code is automatically assembled into a ready-to-use HEX file. The user only needs to click the "Upload" button, select the serial port, and see the on-board LED light up instantly on their Arduino board! [Test avr asm code directly from web #costycnc #asm #assembler #uploader] Best regards to everyone, Boboaca Costel / Costycnc

[image] westfw: [image] GolamMostafa: If Reset button or WDT reset or BOD reset happens, there is no internal initializaton Incorrect. Reset button and WDT reset (and anything else labeled "reset" in the datasheet) all do the internal initialization. By "internal initialization", I have wanted to mean -- After power-up, the tasks that the MCU does before vectoring at location 0x0000. For example: After power-up reset, does the PORF flag of MCUSR register become HIGH before the MCU vectors at location 0x0000?

AVR CPU Core 7.1 Overview ... All user programs must initialize the SP in the Reset routine (before subroutines or interrupts are executed).

[image] GolamMostafa: Say, after working for 10 minutes, the SP = 0x08FB due calling of two nested SUR at which point I have willingly pressed the Hardware Reset Button. The MCU will restartr from location 0x0000, Will theSP be intialized back to 0x08FF? Yes. On the ATmega328x. Not so for ALL AVRs, which is why most of the examples and HLL startup code set it explicitly... Here, you can try it yourself: /* * Check if SP is set to end of RAM by RESET button, * by putting code very early in initialization that * saves the value... */ void savesp (void) __attribute__ ((naked)) // no function prolog __attribute__((section (".init0"))) // execute before anything else __attribute__((used)); // don't eliminate during link void savesp (void) { GPIOR0 = SPL; // Save SP in the GPIO registers, GPIOR1 = SPH; // which aren't affected, subsequently. } void setup() { volatile char buffer[10]; // allocate some stack space Serial.begin(115200); Serial.print("Initial SPL Value= 0x"); // retrieve and print our initial SP Serial.print(GPIOR1, HEX); Serial.println(GPIOR0, HEX); for (int i = 0; i < 9; i++) { buffer[i] = Serial.read(); // make sure our local variables PORTB = buffer[i]; // are not removed by optimization } Serial.print("Current SPL="); // print the current SP Serial.print(SPH, HEX); Serial.println(SPL, HEX); Serial.println("Waiting for reset"); } void loop() {} the startup code assembles to this, lest there be doubts: Disassembly of section .text: 00000000 : 0: 0c 94 35 00 jmp 0x6a ; 0x6a 4: 0c 94 61 00 jmp 0xc2 ; 0xc2 8: 0c 94 61 00 jmp 0xc2 ; 0xc2 : : 0000006a : void savesp (void) __attribute__ ((naked)) // no function prolog __attribute__((section (".init0"))) // execute before anything else __attribute__((used)); // don't eliminate during link void savesp (void) { GPIOR0 = SPL; // Save SP in the GPIO registers, 6a: 8d b7 in r24, 0x3d ; 61 6c: 8e bb out 0x1e, r24 ; 30 GPIOR1 = SPH; // which aren't affected, subsequently. 6e: 8e b7 in r24, 0x3e ; 62 70: 8a bd out 0x2a, r24 ; 42 ;; the rest is the "standard" startup code: 72: 11 24 eor r1, r1 74: 1f be out 0x3f, r1 ; 63 76: cf ef ldi r28, 0xFF ; and this is where the normal 78: d8 e0 ldi r29, 0x08 ; startup code sets the 7a: de bf out 0x3e, r29 ; stack pointer. 7c: cd bf out 0x3d, r28 ; 0000007e : 7e: 11 e0 ldi r17, 0x01 ; 1 80: a0 e0 ldi r26, 0x00 ; 0 :

[image] GolamMostafa: Fine! RAMEND = 0x08FF for 328P So, afer power-up reset, the initial values for spl and sph registers are: 0xFF and 0x08. Keep in mind that if the bootloader doesn't restore the Stack Pointer to its default value after using it, the MCU can crash during nested calls or interrupts. Furthermore, there are many fake chips, LGT8F328P clones, or remarketed factory scraps circulating on the market that do not behave exactly like a genuine ATmega328P. Therefore, before simply answering 'Yes' or 'No', it really depends on what specific MCU hardware you actually have in your hands. keep in mind that if bootloader none quel standard che penso che salva stack coretto a a fine usa stack e non lo rimete a valore initiale can crash anche circola tanta roba fake, LGT8F328P o scarti rimarcati che non sono atmega 328,cioe per rispondere con si e no dipende dire anche che mcu have a mano

[image] stitech: Don't copy Arduino, think for youself. Already i create tutorial examples Timer1 and Usart interrupt here: [image][Education] Demystifying Microcontroller TIMER: Using ATmega328P and Assembly to Understand Registers Here is how you write it in AVR Assembly: .org 0x0000 rjmp setup ; Reset Handler jumping to initialization .org 0x001A ; Timer1 Overflow Interrupt Vector rjmp overflow .org 0x60 setup: sbi 4,5 ; Set PB5 as output (DDRB = 0x04) ldi r16, 0x01 ; Load bit TOIE1 (Timer1 Overflow Interrupt Enable) sts 0x6F, r16 ; Write to TIMSK1 to activate the interrupt ldi r16, 5 ; Set Timer1 prescaler to 1024 sts 0x81, r16 ; Write to TCCR1B sei ; Enable Global Interrupts (Set I-flag) loop: rjmp loop ; The CPU is now completely free to process other tasks! overflow: sbi 3,5 ; Atomic toggle of the D13 LED via PINB (Address 0x03, bit 5) reti ; Return from interrupt Now, let's test the code! Click this link: https://costycnc.github.io/avr-compiler-js/?code=arduino-forum/timer1-int.txt and the site will open with the code already pre-loaded and compiled. Just click one button from 'Upload to:' section, select the correct port, click connect, and the code will be uploaded automatically to your Arduino. [image][Education] Demystifying Microcontroller USART: Using ATmega328P and Assembly to Understand Registers Inside costycnc, the microcontrollor compares the received character with 'A'. If it matches, it toggles the D13 LED. At the end of the routine, we must use the reti instruction to allow the main program to resume its execution. .org 0x0000 jmp RESET .org 0x0024 ; USART RX Complete Interrupt vector jmp costycnc .org 0x0060 RESET: sbi 0x04, 5 ; DDRB: Set PB5 as output ; 1. Configure Baud Rate to 9600 (for 16MHz clock) ldi r16, 103 sts 0xC4, r16 ; Write to UBRR0L ; 2. Configure UCSR0C: 8 data bits, 1 stop bit, no parity ldi r16, 0b00000110 ; Set UCSZ01 and UCSZ00 bits sts 0xC2, r16 ; Write to UCSR0C ; 3. Enable Receiver and RX Interrupt ldi r16, 0b10010000 ; Set RXCIE0 and RXEN0 bits sts 0xC1, r16 ; Write to UCSR0B sei ; Enable global interrupts loop: rjmp loop costycnc: lds r18, 0xC6 ; Read byte from UDR0 cpi r18, 'A' ; Is it 'A'? brne jos sbi 3,5 ; Toggle PB5 (Built-in LED) on match jos: reti Now, let's test the code! Click this link: Avr Assembly Arduino Nano and the site will open with the code already pre-loaded and compiled. Just click one button from 'Upload to:' section, select the correct port, click connect, and the code will be uploaded automatically to your Arduino.

[image] GolamMostafa: Quiz: to @costycnc What is the advantage of polled interrupt over vectored interrupt? Hi GolamMostafa, I wanted to circle back to your quiz about polled vs vectored interrupts and apologize for dismissing it too quickly in my previous post. To be completely honest, at that moment I hadn’t fully connected a crucial point that I realize now: you were absolutely right to raise this question in the context of the ATmega328P, especially when considering how the Arduino framework handles things. Even though the ATmega328P silicon is 100% vectored at the hardware level, the Arduino core chooses to simulate a polled interrupt system via software (think about how it manages PCINT or the underlying logic of attachInterrupt()). This is done intentionally to make things user-friendly and to simplify the development process for everyday users. However, under the hood, the compiler generates extra assembly lines (such as push, pop, and the indirect icall) to handle this flexibility. Your question actually provides an excellent pedagogical lesson: it perfectly highlights the engineering trade-off between software ease-of-use and raw hardware efficiency. While Arduino makes programming significantly easier for everyone, a raw ISR written directly in pure assembly remains the go-to solution when native, microsecond-level speed is critical. Thank you for raising this point—it is a fantastic insight into how software abstractions work! Best regards, costycnc

Yes and in another section it states that SP is initialized to RAMEND at reset, so it shouldn't be necessary to do it programmatically. I agree that the prudent way to handle it is to initialize in the reset routine.

[image] costycnc: Even though the ATmega328P silicon is 100% vectored at the hardware level, the Arduino core chooses to simulate a polled interrupt system via software Actually, this polling happens only after a Pin Change Interrupt. All 8 pins of a port will trigger the same interrupt vector (if enabled). The software needs to determine which pin did trigger the interrupt.

[image] GolamMostafa: bitSet(SREG, 7); //strange: bitSet(SREG, I); does not work bitSet(SREG, SREG_I) will work. Use of #define makes the compiler replace one text with another text. If the text-to-be-replaced is not unique enough, unexpected things may happen.

[image] GolamMostafa: What is the advantage of polled interrupt over vectored interrupt? Polling and interrupts are different approaches for the same problem. If polling is used, the main program needs to examine whether or not conditions are met for every possible case, meaning that a lot of execution time is lost just to do this. Vectored interrupts save execution time and the accompanying delays, but is only possible if the hardware is present. 'polled interrupt' is a contradictio in terminis.

[Education] Demystifying Microcontrollers: Using ATmega328P and Assembly to Understand Registers

Projects General Guidance

Topic		Replies	Views
[Education] Demystifying Microcontroller PORTB: Using ATmega328P and Assembly to Understand Registers Education	157	2137	July 19, 2026
The Ghost in the Compiler: Why your Arduino code disappears (An Assembly Visual Proof) Programming	156	1968	July 3, 2026
[Education] Demystifying Microcontroller USART: Using ATmega328P and Assembly to Understand Registers Education	88	1305	July 24, 2026
Demystifying Microcontrollers: Stack, CALL Instructions, Local Variables and Hex Notation General Discussion	182	2626	October 11, 2026
[Education] Demystifying Microcontroller TIMER: Using ATmega328P and Assembly to Understand Registers Education	69	1117	August 25, 2026

[Education] Demystifying Microcontrollers: Using ATmega328P and Assembly to Understand Registers

Related topics