Assembly AVR no navegador, em um Arduino Uno simulado
Iniciante
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
Um Arduino Uno é um ATmega328P, e por baixo de cada sketch roda código de máquina AVR: 32 registradores, um byte de flags e instruções que cada uma leva um número conhecido de ciclos de clock. O Mokxi deixa você escrever essa camada diretamente. Adicione uma aba .S ao lado do seu sketch, ou transforme a placa inteira em um projeto de assembly sem nenhum core do Arduino, e aperte Rodar.
Esta página percorre o blink que o editor entrega: o que cada instrução faz, por que PORTB aparece com dois números diferentes e como um loop contado vira exatamente 250 milissegundos. Depois, uma interrupção de timer e o depurador lendo tudo de volta, uma instrução por vez.
O circuito acima é o blink embutido comum, escrito em C. Para rodar a versão em assembly, abra no editor, selecione o Uno e escolha **Blink em assembly** em **Assembly (sem Arduino)** no painel Firmware. Os arquivos da placa viram um único main.S.
Blink em assembly, linha por linha
Nada fica escondido neste programa: sem setup(), sem loop(), sem a interrupção de millis() ao fundo. O código de inicialização zera r1, coloca a pilha no topo da RAM e chama main. Depois disso, cada ciclo que o chip gasta é um que você escreveu. #include <avr/io.h> funciona porque um arquivo .S passa primeiro pelo pré-processador de C, e ele traz os nomes dos registradores e dos bits.
sbi define um bit de um registrador de I/O. O primeiro torna PB5, o pino marcado 13, uma saída. O segundo é o truque que vale conhecer: escrever 1 em um bit de PINB alterna o bit correspondente de PORTB, em uma única instrução de dois ciclos, sem leitura e sem máscara. Depois rcall chama o delay, ret volta e rjmp loop recomeça tudo.
; 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
Os registradores e quais você pode usar
O chip tem 32 registradores gerais, de r0 a r31, cada um de um byte, acessados em um ciclo. A metade superior é especial: ldi, que carrega uma constante, só funciona em r16 a r31, e é por isso que o blink guarda seus contadores em r18, r24 e r25. Escreva ldi r3, 5 e a compilação para com a mensagem ldi works only on r16 to r31, and r3 is not one of them.
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.
| Registrador | O que é | Atenção a |
|---|---|---|
| r0 | O byte de rascunho, `__tmp_reg__`. `lpm` cai aqui por padrão. | O compilador o usa, então nenhum valor sobrevive a uma chamada. |
| r1 | Always zero, `__zero_reg__`. | `mul` escreve em r1:r0, então use `clr r1` depois de um. |
| r2 a r17 | Gerais, mas do chamador. | Faça push e pop se sua função os usar. |
| r16 a r31 | A metade superior. | `ldi`, `cpi`, `subi`, `andi` e `ori` funcionam só aqui. |
| r18 a r27, r30, r31 | Livres dentro da sua função. | Uma função C que você chamar pode bagunçá-los. |
| r24, r26, r28, r30 | Os pares em que `adiw` e `sbiw` funcionam. | r24:r25 também carrega um argumento e resultado de 16 bits. |
| X, Y, Z | r26:r27, r28:r29, r30:r31: os ponteiros. | Só Z lê a flash, com `lpm`. Y é o frame pointer do C. |
| SREG | As flags: I T H S V N Z C. | Definidas por aritmética e comparações, não por `sbi`, `ldi` ou `mov`. |
Endereços de I/O e endereços de dados: por que PORTB é 0x25 e 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().
Se você errar isso, o Mokxi interrompe a compilação antes de qualquer ferramenta rodar, porque do contrário o erro seria montado como um programa que escreve no registrador errado. sbi PORTB, 5 gera PORTB é o endereço de dados 0x25 aqui, e sbi recebe o endereço de E/S dele: escreva _SFR_IO_ADDR(PORTB), que é 0x05. Registradores acima do endereço de E/S 63, como TCCR1B, não têm forma curta nenhuma: use lds e sts.
; 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 deles para 250 ms
Aqui não há delay(), então o atraso é um laço que você conta na mão. O Uno roda a 16 MHz, então um ciclo é 62,5 nanossegundos e 250 milissegundos são 4.000.000 de ciclos. O laço interno do blink tem duas instruções: sbiw r24, 1 leva dois ciclos, e brne inner leva dois quando há desvio. Uma volta são quatro ciclos, 25.000 voltas são 100.000 ciclos, e 40 passagens disso dá os 4.000.000. O laço externo adiciona cerca de 120 ciclos no total, o que são três partes em cem 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.
A versão longa concorda: 160 passagens de um laço de 25.000 voltas são 16.000.000 de ciclos, e micros() coloca isso entre 1.000.000 e 1.015.000 microssegundos. O meio por cento extra é a própria interrupção do Timer 0, a que mantém o millis() funcionando, e um Uno de verdade também perde isso.
| Instrução | Ciclos | No blink |
|---|---|---|
| `ldi` | 1 | Carrega os dois contadores do laço. |
| `sbi`, `cbi` | 2 | Faz PB5 virar saída, depois alterna. |
| `sbiw` | 2 | Tira 1 do contador de 16 bits em r24:r25. |
| `dec` | 1 | Tira 1 do contador externo em r18. |
| `brne` | 2 com desvio, 1 sem | Fecha os dois laços: dois mais dois é a volta de quatro ciclos. |
| `rjmp` | 2 | Volta ao topo do laço principal. |
| `rcall` | 3 | Chama o atraso. |
| `ret` | 4 | Volta dele. |
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Uma interrupção de timer em vez de um laço de atraso
Um laço contado é um bom jeito de aprender ciclos e um jeito ruim de contar tempo, porque o processador não pode fazer mais nada enquanto conta. Abaixo, o Timer 1 roda no modo CTC com o clock dividido por 256, contando 62.500 vezes por segundo, então um valor de comparação de 31.249 acontece a cada meio segundo. OCIE1A em TIMSK1 pede a interrupção e sei permite que interrupções aconteçam.
TIMER1_COMPA_vect é um nome de avr/io.h, e na verdade é __vector_11, a décima primeira entrada da tabela de vetores. Declare-o .global, defina o rótulo, e a tabela do código de inicialização desvia para ele. Todo vetor sem um tratador seu recebe um reti fraco, então uma interrupção perdida retorna em silêncio. Termine com reti, não com ret. Esse tratador cabe em três linhas só porque sbi não muda flags.
; 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
Chamando assembly a partir de um sketch
Você não precisa abrir mão do core do Arduino. Mantenha o sketch.ino, adicione uma aba chamada blink.S, e os dois são compilados e ligados juntos, como o Arduino IDE compila um .S ao lado de um sketch. Serial, millis() e pinMode() continuam 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.
#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
O sketch ao lado
Rode com um LED e um resistor de 220 ohms no pino 13: o monitor serial imprime 1, 2, 3, 4, 5 enquanto o LED alterna a cada 250 milissegundos. Este é o core do Arduino com uma função escrita em assembly. Para poucas instruções, asm volatile inline com restrições tem menos cerimônia, como no sketch de contagem de ciclos acima.
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Observando no depurador
Aqui é onde assembly em um simulador supera assembly numa bancada. Clique na margem ao lado de uma linha da sua aba .S e um breakpoint vai para lá, igual a uma linha de C, porque os números de linha que a compilação registra são os da própria aba. Aperte Rodar e a placa para nele, com o circuito inteiro.
A aba Debug mostra onde parou, os registradores do próprio core com sreg detalhado em suas flags, uma lista de observação para globais, e a Desmontagem: as instruções ao redor do contador de programa, cada linha um endereço, os bytes, a instrução e a linha de origem de onde veio. Pare na linha do sbi da aba acima e a linha lê sbi 0x3, 0x5, que é o que _SFR_IO_ADDR(PINB), PINB5 realmente significava. Passo de instrução roda exatamente uma instrução e redesenha a lista.
Quando não monta, e o que mais roda
Os erros caem na aba e na linha certas com uma frase embaixo. Uma instrução escrita errada diz "lid" is not an AVR instruction e lembra que um rótulo termina em dois-pontos. add r16, 5 é a silenciosa: o montador do LLVM lê como add r16, r5, então o Mokxi para em vez disso com add takes two registers, and 5 is a constant e aponta para subi r16, -5, porque o AVR não tem ADDI.
Assembly aqui não é só coisa de AVR. Uma aba .S ou .s funciona em toda placa que compila, e a Pico e a STM32F411 Black Pill têm os mesmos quatro projetos iniciais em ARM Thumb, onde seu arquivo é o programa inteiro, tabela de vetores e tudo. O Nano e o Pro Mini de 16 MHz são o mesmo chip do Uno. O artigo Writing assembly na central de ajuda, linkado abaixo, é a referência para o resto.
Abra este circuito no editor. Arduino Uno: um LED no pino 13, piscando, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.
Abrir o circuitoPerguntas
Posso mesmo escrever assembly para um Arduino no navegador?
Sim. Adicione uma aba terminada em .S ou .s e ela é montada e ligada com o seu sketch, do jeito que o Arduino IDE compila um. Ou escolha um projeto inicial em "Assembly (no Arduino)" no painel de Firmware da placa e a placa inteira vira um main.S só, sem core do Arduino por baixo.
Qual é a diferença entre um arquivo .S e um arquivo .s?
Um .S maiúsculo passa primeiro pelo pré-processador de C, então #include <avr/io.h> e #define funcionam nele. Um .s minúsculo vai direto para o montador como está escrito.
Por que sbi PORTB, 5 falha se PORTB é o registrador certo?
Num arquivo .S o nome PORTB é o endereço de dados dele, 0x25, como na avr-libc, e sbi quer o endereço de E/S, 0x05. Escreva _SFR_IO_ADDR(PORTB), ou coloque #define __SFR_OFFSET 0 acima do include.
As contagens de ciclos são as mesmas de um chip de verdade?
Sim, para as instruções. O ATmega328P simulado gasta os ciclos que a folha de dados dá a cada uma, então 50 voltas de nop, dec e brne contam 202 no Timer 1 no clock completo.
Posso percorrer o assembly uma instrução por vez?
Sim. Breakpoints funcionam nas linhas de uma aba .S, e a aba Debug mostra as instruções ao redor da parada com a linha de origem de cada uma. Passo de instrução executa exatamente uma delas.
Continuar
Monte isto de verdade
Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.