Aprender

Ensamblador AVR en el navegador, en un Arduino Uno simulado

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un LED en el pin 13, parpadeandoen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
El blink integrado, en C, con un LED y una resistencia de 220 ohms en el pin 13. Ábrelo en el editor y elige Blink en ensamblador para ejecutar el mismo LED desde main.S.

Un Arduino Uno es un ATmega328P, y debajo de cada sketch corre código máquina AVR: 32 registros, un byte de banderas e instrucciones que toman cada una un número conocido de ciclos de reloj. Mokxi te permite escribir esa capa directamente. Agrega una pestaña .S junto a tu sketch, o convierte toda la placa en un proyecto de ensamblador sin núcleo de Arduino, y presiona Ejecutar.

Esta página recorre el blink que te entrega el editor: qué hace cada instrucción, por qué PORTB son dos números distintos, y cómo un bucle contado se convierte en exactamente 250 milisegundos. Después, una interrupción de temporizador, y el depurador leyéndolo instrucción por instrucción.

El circuito de arriba es el blink integrado normal, escrito en C. Para ejecutar la versión en ensamblador, ábrelo en el editor, selecciona el Uno y elige **Blink en ensamblador** bajo **Ensamblador (sin Arduino)** en el panel de Firmware. Los archivos de la placa se convierten en un solo main.S.

Blink en ensamblador, línea por línea

No hay nada oculto bajo este programa: no hay setup(), no hay loop(), no hay interrupción de millis() en segundo plano. El código de arranque limpia r1, coloca la pila al final de la RAM y llama a main. Después de eso, cada ciclo que gasta el chip es uno que tú escribiste. #include <avr/io.h> funciona porque un archivo .S pasa primero por el preprocesador de C, y te da los nombres de registros y bits.

sbi pone en uno un bit de un registro de E/S. El primero hace que PB5, el pin marcado 13, sea una salida. El segundo es el truco que vale la pena conocer: escribir un 1 en un bit de PINB alterna el bit correspondiente de PORTB, en una sola instrucción de dos ciclos, sin lectura y sin máscara. Luego rcall llama al retardo, ret regresa, y rjmp loop vuelve a empezar.

main.S: el blink inicial, tal como te lo entrega el panel de Firmware
; Blink the LED on pin 13 (PB5) every 250 ms, in AVR assembly.
; No Arduino core: the startup code clears r1, puts the stack at RAMEND
; and calls main, as avr-gcc's does.

#include <avr/io.h>

    .section .text
    .global main
main:
    sbi  _SFR_IO_ADDR(DDRB), DDB5     ; PB5 is an output
loop:
    sbi  _SFR_IO_ADDR(PINB), PINB5    ; writing 1 to PINB5 toggles PB5
    rcall delay_250ms
    rjmp loop

; 250 ms at 16 MHz is 4,000,000 cycles: 40 times 100,000.
; The inner loop is 4 cycles a turn (SBIW 2, BRNE 2), 25,000 turns.
delay_250ms:
    ldi  r18, 40
outer:
    ldi  r24, lo8(25000)
    ldi  r25, hi8(25000)
inner:
    sbiw r24, 1
    brne inner
    dec  r18
    brne outer
    ret

Los registros, y cuáles puedes usar

El chip tiene 32 registros de propósito general, r0 a r31, de un byte cada uno, accesibles en un ciclo. La mitad superior es especial: ldi, que carga una constante, funciona solo en r16 a r31, y por eso el blink guarda sus contadores en r18, r24 y r25. Escribe ldi r3, 5 y la compilación se detiene con ldi funciona solo en r16 a r31, y r3 no es uno de ellos.

Two registers are spoken for: r1 must hold zero, because the C compiler assumes it everywhere, and r0 is the scratch byte. Then there is SREG, eight flags set by the last instruction that did arithmetic. sbiw sets Z when its result reaches zero, and brne is simply "branch if Z is clear". sbi and cbi change no flags at all. The debugger spells sreg out as ITHSVNZC, with a dot for each flag that is clear.

Los registros AVR que encuentra un primer programa en ensamblador
RegistroQué esTen cuidado con
r0El byte de trabajo, `__tmp_reg__`. `lpm` llega aquí por defecto.El compilador lo usa, así que ningún valor sobrevive a una llamada.
r1Always zero, `__zero_reg__`.`mul` escribe en r1:r0, así que haz `clr r1` después de uno.
r2 a r17De propósito general, pero del que llama.Guárdalos con push y pop si tu función los usa.
r16 a r31La mitad superior.`ldi`, `cpi`, `subi`, `andi` y `ori` funcionan solo aquí.
r18 a r27, r30, r31Libres dentro de tu función.Una función de C que llames puede sobrescribirlos.
r24, r26, r28, r30Los pares en los que funcionan `adiw` y `sbiw`.r24:r25 también lleva un argumento y resultado de 16 bits.
X, Y, Zr26:r27, r28:r29, r30:r31: los punteros.Solo Z lee la flash, con `lpm`. Y es el puntero de marco de C.
SREGLas banderas: I T H S V N Z C.Las fija la aritmética y las comparaciones, no `sbi`, `ldi` ni `mov`.

Direcciones de E/S y direcciones de datos: por qué PORTB es 0x25 y 0x05

This is the one that costs people an evening. In a .S file, #include <avr/io.h> defines PORTB as its data address, 0x25, which is what lds and sts want. The short instructions, in, out, sbi, cbi, sbic and sbis, want the I/O address instead, which is 32 lower: 0x05. So you wrap the name in _SFR_IO_ADDR().

Si te equivocas, Mokxi detiene la compilación antes de que corra cualquier herramienta, porque de lo contrario el error se ensamblaría en un programa que escribe el registro equivocado. sbi PORTB, 5 da PORTB es aquí la dirección de datos 0x25, y sbi toma su dirección de E/S: escribe _SFR_IO_ADDR(PORTB), que es 0x05. Los registros por encima de la dirección de E/S 63, como TCCR1B, no tienen forma corta: usa lds y sts.

El mismo bit, de tres maneras
; As avr-libc defines them: a name is a data address.
    sbi  _SFR_IO_ADDR(DDRB), DDB5   ; I/O 0x05, bit 5
    lds  r16, PORTB                 ; data 0x25
    sts  PORTB, r16

; Or move every name down to its I/O address, once:
#define __SFR_OFFSET 0
#include <avr/io.h>
    sbi  DDRB, DDB5                 ; now this is right

Contando ciclos: 4,000,000 de ellos para 250 ms

Aquí no hay delay(), así que el retardo es un bucle que cuentas a mano. El Uno corre a 16 MHz, así que un ciclo es 62.5 nanosegundos y 250 milisegundos son 4,000,000 de ciclos. El bucle interno del blink tiene dos instrucciones: sbiw r24, 1 toma dos ciclos, y brne inner toma dos cuando bifurca. Una vuelta son cuatro ciclos, 25,000 vueltas son 100,000 ciclos, y 40 pasadas de eso son los 4,000,000. El bucle externo agrega unas 120 ciclos en total, que es tres partes en cien mil.

The simulator spends the cycles the data sheet gives each instruction, so you can prove this from a sketch. Set Timer 1 to the full clock, so it counts once per CPU cycle, read it, run a known loop, read it again. Fifty turns of nop, dec and brne is 50 times 4 less the one the last brne saves by falling through, which is 199, plus 2 for the lds and 1 for the ldi. It prints 202, every time.

La versión larga concuerda: 160 pasadas de un bucle de 25,000 vueltas son 16,000,000 de ciclos, y micros() lo coloca entre 1,000,000 y 1,015,000 microsegundos. El medio por ciento extra es la propia interrupción del Timer 0, la que mantiene a millis() andando, y un Uno real también lo pierde.

Lo que cuestan las instrucciones del blink en un ATmega328P, en ciclos de reloj
InstrucciónCiclosEn el blink
`ldi`1Carga los dos contadores del bucle.
`sbi`, `cbi`2Hace que PB5 sea una salida, y luego la alterna.
`sbiw`2Le quita 1 al contador de 16 bits en r24:r25.
`dec`1Le quita 1 al contador externo en r18.
`brne`2 tomados, 1 noCierra ambos ciclos: dos más dos son los cuatro ciclos de la vuelta.
`rjmp`2Regresa al inicio del ciclo principal.
`rcall`3Llama al retardo.
`ret`4Regresa de él.
sketch.ino: midiendo un ciclo contra el Timer 1, que imprime 202
void setup() {
  Serial.begin(9600);
  TCCR1A = 0;
  TCCR1B = _BV(CS10);  // clk/1: one count per CPU cycle
  uint8_t start, stop, n;
  noInterrupts();
  asm volatile(
    "lds %[start], %[tcnt]\n\t"
    "ldi %[n], 50\n"
    "1:\n\t"
    "nop\n\t"
    "dec %[n]\n\t"
    "brne 1b\n\t"
    "lds %[stop], %[tcnt]\n\t"
    : [start] "=&r"(start), [stop] "=&r"(stop), [n] "=&d"(n)
    : [tcnt] "i"(&TCNT1L));
  interrupts();
  Serial.println((uint8_t)(stop - start));  // 202
}

void loop() {}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Una interrupción de temporizador en lugar de un ciclo de retardo

Un ciclo contado es una buena forma de aprender los ciclos y una mala forma de llevar el tiempo, porque el procesador no puede hacer nada más mientras cuenta. Abajo, el Timer 1 corre en modo CTC con el reloj dividido entre 256, contando 62,500 veces por segundo, así que un valor de comparación de 31,249 llega cada medio segundo. OCIE1A en TIMSK1 pide la interrupción y sei habilita las interrupciones en general.

TIMER1_COMPA_vect es un nombre de avr/io.h, y en realidad es __vector_11, la undécima entrada de la tabla de vectores. Decláralo .global, define la etiqueta, y la tabla del código de arranque salta a él. Cada vector sin un controlador tuyo recibe un reti débil, así que una interrupción perdida regresa en silencio. Termina con reti, no con ret. Este controlador cabe en tres líneas solo porque sbi no cambia ningún flag.

main.S: el punto de partida con interrupción del Timer
; Timer 1 interrupts twice a second and the handler toggles pin 13 (PB5).
; main only sets the timer up; the LED is all the interrupt's work.

#include <avr/io.h>

    .section .text
    .global main
main:
    sbi  _SFR_IO_ADDR(DDRB), DDB5
    ; CTC mode, clock / 256: 16 MHz / 256 = 62,500 counts a second,
    ; so a compare at 31,249 is every 0.5 s.
    ldi  r16, hi8(31249)
    sts  OCR1AH, r16                  ; high byte first
    ldi  r16, lo8(31249)
    sts  OCR1AL, r16
    clr  r16
    sts  TCCR1A, r16
    ldi  r16, (1 << WGM12) | (1 << CS12)
    sts  TCCR1B, r16
    ldi  r16, (1 << OCIE1A)           ; interrupt on compare match A
    sts  TIMSK1, r16
    sei
idle:
    rjmp idle

; TIMER1_COMPA_vect is __vector_11; the vector table jumps here.
    .global TIMER1_COMPA_vect
TIMER1_COMPA_vect:
    sbi  _SFR_IO_ADDR(PINB), PINB5    ; toggle the LED (SBI changes no flags)
    reti

Llamar a ensamblador desde un sketch

No tienes que renunciar al núcleo de Arduino. Conserva sketch.ino, agrega una pestaña llamada blink.S, y los dos se compilan y se enlazan juntos, tal como el IDE de Arduino compila un .S junto a un sketch. Serial, millis() y pinMode() siguen funcionando.

The join is extern "C", which stops C++ from mangling the name, and the AVR calling convention, which decides where the values are. Arguments arrive in r24, then r22, then r20; a result goes back in r24, or r25:r24 when it is two bytes. r1 must be zero again on return, and r2 to r17, r28 and r29 belong to the caller. It works in both directions: here the sketch calls led_toggle, and led_toggle calls bump, an ordinary C function back in the sketch.

blink.S: una pestaña a la que el sketch llama, y que llama de vuelta al sketch
#include <avr/io.h>

; void led_toggle(void): toggle pin 13, then count it in C.
    .global led_toggle
led_toggle:
    sbi  _SFR_IO_ADDR(PINB), PINB5
    call bump                 ; a C function of the sketch
    ret

El sketch que la acompaña

Ejecútalo con un LED y una resistencia de 220 ohm en el pin 13: el monitor serie imprime 1, 2, 3, 4, 5 mientras el LED cambia de estado cada 250 milisegundos. Esto es el núcleo de Arduino con una función escrita en ensamblador. Para unas pocas instrucciones, asm volatile en línea con restricciones tiene menos ceremonia, como en el sketch contador de ciclos de arriba.

sketch.ino: la otra mitad
extern "C" void led_toggle(void);
extern "C" volatile int bumps;
volatile int bumps = 0;
extern "C" void bump(void) { bumps++; }

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}

void loop() {
  led_toggle();
  Serial.println(bumps);
  delay(250);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Verlo en el depurador

Aquí es donde el ensamblador en un simulador gana al ensamblador en un banco de trabajo. Haz clic en el margen junto a una línea de tu pestaña .S y un punto de interrupción se coloca ahí, igual que en una línea de C, porque los números de línea que registra la compilación son los de la propia pestaña. Presiona Ejecutar y la placa se detiene en él, circuito incluido.

La pestaña Depurar muestra dónde se detuvo, los registros del propio núcleo con sreg desglosado en sus banderas, una lista de observación para las variables globales, y Desensamblador: las instrucciones alrededor del contador de programa, cada fila una dirección, los bytes, la instrucción y la línea del código fuente de la que proviene. Detente en la línea de sbi de la pestaña de arriba y la fila dice sbi 0x3, 0x5, que es lo que _SFR_IO_ADDR(PINB), PINB5 realmente significaba. Paso de instrucción ejecuta exactamente una instrucción y vuelve a dibujar la lista.

Cuando no ensambla, y qué más se ejecuta

Los errores caen en la pestaña y línea correctas con una frase debajo. Una instrucción mal escrita dice "lid" is not an AVR instruction y te recuerda que una etiqueta termina en dos puntos. add r16, 5 es la silenciosa: el ensamblador de LLVM la lee como add r16, r5, así que Mokxi se detiene en cambio con add takes two registers, and 5 is a constant y te sugiere subi r16, -5, porque el AVR no tiene ADDI.

El ensamblador aquí no es solo cosa de AVR. Una pestaña .S o .s funciona en toda placa que compile, y la Pico y la STM32F411 Black Pill tienen los mismos cuatro puntos de partida en ARM Thumb, donde tu archivo es el programa completo, tabla de vectores incluida. El Nano y el Pro Mini de 16 MHz son el mismo chip que el Uno. El artículo Cómo escribir ensamblador del centro de ayuda, enlazado abajo, es la referencia para lo demás.

Abre este circuito en el editor. Arduino Uno: un LED en el pin 13, parpadeando, cableado como corre arriba en esta página. Cambia un componente o un valor y vuelve a ejecutarlo.

Abrir el circuito

Preguntas

¿De verdad puedo escribir ensamblador para un Arduino en el navegador?

Sí. Agrega una pestaña que termine en .S o .s y se ensambla y se enlaza con tu sketch, tal como lo compila el IDE de Arduino. O elige un punto de partida bajo "Assembly (no Arduino)" en el panel de Firmware de la placa y toda la placa se convierte en un solo main.S sin el núcleo de Arduino debajo.

¿Cuál es la diferencia entre un archivo .S y un archivo .s?

Una .S con mayúscula pasa primero por el preprocesador de C, así que #include <avr/io.h> y #define funcionan en ella. Una .s con minúscula va directa al ensamblador tal como está escrita.

¿Por qué falla sbi PORTB, 5 si PORTB es el registro correcto?

En un archivo .S el nombre PORTB es su dirección de datos, 0x25, como en avr-libc, y sbi quiere la dirección de E/S, 0x05. Escribe _SFR_IO_ADDR(PORTB), o pon #define __SFR_OFFSET 0 encima del include.

¿Los conteos de ciclos son los mismos que en un chip real?

Sí, para las instrucciones. El ATmega328P simulado gasta los ciclos que la hoja de datos da a cada una, así que 50 vueltas de nop, dec y brne cuentan 202 en el Timer 1 con el reloj completo.

¿Puedo recorrer el ensamblador una instrucción a la vez?

Sí. Los puntos de interrupción funcionan en las líneas de una pestaña .S, y la pestaña Depurar muestra las instrucciones alrededor de la detención con la línea del código fuente de la que proviene cada una. Paso de instrucción ejecuta exactamente una de ellas.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.