Placas

O Arduino Leonardo

O Arduino cuja porta USB vai direto para o chip: um ATmega32U4 a 16 MHz, com Serial no USB e Serial1 uma porta própria nos pinos 0 e 1.

A visão geral, com exemplos rodando, está na página da placa e O modelo do Arduino Leonardo (todos os registradores).

O que é

Um ATmega32U4 em seu encapsulamento de 44 pinos, no mesmo core AVR do Uno, com 32 KB de flash, 2560 bytes de SRAM e 1 KB de EEPROM. Os registradores estão nos endereços reais, então um sketch compilado aqui roda na placa em cima da sua mesa. A página de referência é O modelo do Arduino Leonardo.

A placa tem 68,6 por 53,3 mm (o contorno de um Uno com precisão de um décimo de milímetro), e os conectores de shield coincidem furo a furo com os de um Uno. Como um Uno, ela não encaixa numa protoboard: ligue-a com jumpers a partir dos conectores.

Serial é o USB

Essa é a coisa a entender sobre uma Leonardo, e a coisa que surpreende quem chega de um Uno.

Num Uno um segundo chip converte o USB em UART, e Serial é a USART0 do microcontrolador. Numa Leonardo não há segundo chip: o dispositivo USB está no próprio ATmega32U4, e Serial é um endpoint CDC que o firmware do próprio sketch abre. Serial1 é a USART de verdade, e sai nos pinos 0 e 1 do conector.

Então, no editor:

  • O que você imprime em Serial aparece no monitor serial.
  • O que você imprime em Serial1 sai pelo pino 1 como bits. Ligue-o a alguma coisa (pino 0, um osciloscópio, outra placa) ou ele não chega a lugar nenhum.

O programa pronto de Serial imprime nos dois, então a diferença aparece na tela.

O Mokxi modela o USB como um canal de bytes nos registradores reais do endpoint: o suficiente para uma porta serial, e nada além disso. Não há enumeração, descritores nem host, então while (!Serial) {} retorna imediatamente aqui e espera numa mesa.

Keyboard.h, Mouse.h e Joystick.h compilam e rodam. Sem um computador do outro lado do cabo, cada tecla, movimento ou mudança de botão é impresso no monitor serial como uma linha ([Keyboard] press Ctrl). Na placa sobre a sua mesa o mesmo programa é um teclado, mouse ou controle de videogame USB de verdade.

O programa que o Mokxi compila carrega um dispositivo USB serial real para a placa sobre a sua mesa. Enviado para uma Leonardo, uma Micro ou uma Pro Micro, ele aparece como uma porta serial, Serial chega ao monitor serial da IDE do Arduino ou a qualquer terminal, while (!Serial) espera alguém abrir a porta, e o Upload pode reiniciá-lo no bootloader do mesmo jeito que a IDE do Arduino faz.

Pins

Vinte nos conectores de shield e três no conector ICSP, numerados do jeito que a serigrafia e o core do Arduino os numeram:

  • 0 a 13 ao longo do conector digital, com o LED L no 13.
  • A0 a A5 na parte de baixo.
  • 14, 15 e 16 no conector ICSP: MISO, SCK e MOSI (abaixo).
  • A6 a A11 são segundos nomes dos pinos digitais 4, 12, 6, 8, 9 e 10, porque neste chip o ADC alcança as portas B e D além da porta F.

Sete pinos fazem PWM por hardware com analogWrite: 3, 5, 6, 9, 10, 11 e 13.

SDA e SCL são os pinos 2 e 3, e não A4 e A5 como num Uno. Os dois furos ao lado de AREF são o mesmo metal que os pinos 3 e 2. Esse é o único lugar onde o formato de shield compartilhado não corresponde ao chip compartilhado, e é a primeira coisa a conferir quando um sketch muda de placa.

O SPI está só no conector ICSP, o bloco de pads 2x3 na borda direita, como na placa real. Seus pads MISO, SCK e MOSI são os pinos 14, 15 e 16, e os outros três pads são um segundo 5V, RESET e GND. Os pinos 11, 12 e 13 não são SPI numa Leonardo, então um módulo SPI ligado neles como num Uno não responde: mova seus três fios de barramento para os pads do ICSP.

Um timer que nenhum outro aqui tem

O timer 4 deste chip tem dez bits de largura, seu TOP é um registrador e não um modo, e seus canais de comparação são A, B e D. Não existe canal C, porque OCR4C é o TOP. Ele controla os pinos 6 e 13.

analogWrite hides all of that, so the sketch looks ordinary. The built-in Fade program puts an LED on pin 13 and another on pin 9, which is an ordinary 16-bit timer, so both kinds of PWM hardware are running at once: 976 Hz on 13 and 490 Hz on 9.

Interrupts

Cinco pinos têm interrupção externa: 3, 2, 0, 1 e 7. O pino 7 é o interessante. Ele é o INT6, o único que esta placa expõe que não está entre os quatro primeiros pinos, e o programa pronto Button o usa.

Passe um pino pela digitalPinToInterrupt() e a attachInterrupt() cuida do resto, como na placa real.

Bibliotecas do Arduino

Um tutorial que inclua Servo.h, Wire.h, SPI.h, EEPROM.h, LiquidCrystal_I2C.h, Adafruit_GFX.h com Adafruit_SSD1306.h e DHT.h compila aqui como está. Cada uma é um cabeçalho próprio do Mokxi sob o nome upstream, escrito sobre os drivers dos componentes da caixa de componentes, e nada disso é o código da biblioteca upstream.

  • O Wire.begin() coloca o barramento I2C em 2 (SDA) e 3 (SCL).
  • O SPI.begin() coloca o barramento SPI no conector ICSP: SCK é 15, MISO 14 e MOSI 16. O SS é 17, o pino do LED RX, que não tem pad, então dê ao chip select do módulo qualquer pino livre.
  • O EEPROM.h usa o próprio 1 KB de EEPROM do chip, através de seus registradores reais. Ele mantém o que você escreveu através de um aperto no reset da placa, e um novo Rodar o inicia apagado, cada byte 255, porque um Rodar é uma placa nova.
  • A Adafruit_NeoPixel.h controla uma fita WS2812. O bit é cronometrado em assembly AVR, como toda biblioteca NeoPixel para AVR faz, e a 16 MHz cada nível alto cai dentro da janela do data sheet. As interrupções ficam desligadas enquanto um quadro é enviado, então o millis() perde um tick a cada milissegundo que uma fita longa leva para enviar, como na bancada. As cores ocupam três bytes por LED dos 2560 bytes de RAM do chip.

O editor de código e a compilação lista o que cada uma cobre e como difere da biblioteca upstream.

The firmware

Quatro programas prontos: Blink, Button, Serial e Fade.

O código-fonte de um sketch de Uno normalmente compila para o Leonardo. Um ELF compilado para o Uno não roda nele: chip diferente, mapa de registradores diferente, tabela de vetores diferente. Compile para o Leonardo e ele roda.

O que não é modelado

A pilha USB acima do canal de bytes: Keyboard, Mouse e Joystick imprimem seus relatórios no monitor serial em vez de chegar a um computador. O Serial daqui é um canal de bytes sem protocolo por baixo: sem enumeração, sem descritores, sem configuração de endpoints, sem suspend nem resume e sem o reset por toque de 1200 baud, então aquilo que faz um Leonardo ser um Leonardo (um sketch esperando while (!Serial)) é uma decisão que este modelo toma, e não um handshake que ele executa.

SPI, TWI/I2C, o comparador analógico, o sensor de temperatura e o PLL que faria o timer 4 rodar acima de 16 MHz. Shields não são componentes físicos aqui; ligue o mesmo circuito na protoboard. O Leonardo ETH não é modelado. O Micro e o Pro Micro têm o mesmo chip em outros pinouts, e estão na caixa de componentes como placas próprias.

Os endereços são os do data sheet e nenhum foi inventado; as aproximações são de comportamento, e a seção 8 de o modelo do Arduino Leonardo detalha cada uma delas. As três que aparecem na bancada: o ADC não tem erro nenhum (sem sample-and-hold, sem não linearidade, sem ruído, sem offset), então um divisor lê sempre a mesma contagem onde um real oscila; o cristal de 16 MHz é exato, sem deriva nem jitter; e o trilho de 5 V é uma fonte ideal que não sofre queda, então um circuito que derrubaria uma placa real roda limpo aqui.