Esta es la referencia de ingeniería del modelo: qué implementa, registro por registro, para quienes escriben firmware sobre él. Para usar la placa en el editor, empieza por El Arduino Leonardo y la página de la placa.
El Leonardo es el Arduino cuyo conector USB va directo al microcontrolador. Un componente del kernel (leonardo en crates/parts) envuelve un modelo del SoC ATmega32U4 (crates/atmega32u4) sobre el mismo núcleo AVR que el Uno y el Mega (crates/avr-core). El núcleo se comparte; el chip a su alrededor no. Este documento es el contrato y prevalece sobre cualquier comentario en el código.
El tipo de catálogo es leonardo. Cuando una sección diga "como docs/uno.md", ese documento es el contrato para esa parte.
El único hecho que hace que esta placa sea diferente de todas las demás AVR de aquí: Serial no es un UART. El ATmega32U4 tiene un dispositivo USB de velocidad completa en el chip, el único conector de la placa está cableado a él, y el monitor serie es un endpoint CDC que abre el propio firmware del sketch. Serial1 (la USART real) está en los pines 0 y 1 del header y no llega a nada a menos que algo esté conectado a ella. La sección 3.6 es explícita sobre cuánto del USB se modela, y la respuesta es: el conducto de bytes, y nada por encima de él.
1. Pines de la placa (orden del catálogo)
Vista superior, el conector micro-USB y el conector de barril en el borde izquierdo. La placa mide 68.6 x 53.3 mm y los headers de shield son los de un Uno, agujero por agujero, incluido el espacio de 0.16 pulgadas del Uno entre los dos bloques del header digital.
Fila superior, de izquierda a derecha (18 agujeros): SCL, SDA, AREF, GND, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0.
Fila inferior, de izquierda a derecha (13 agujeros): IOREF, RESET, 3V3, 5V, GNDb, GNDc, VIN, A0 a A5.
Header ICSP, el bloque de 2x3 en el borde derecho, en su propio orden de pines 1 a 6 (6 agujeros): MISO, 5Vb, SCK, MOSI, RESETb, GNDd. En la placa los pines 1, 3 y 5 forman una columna y 2, 4 y 6 la otra.
37 pines. El header ICSP es el único lugar donde un Leonardo saca el SPI: MISO, SCK y MOSI son PB3, PB1 y PB2, los pines 14, 15 y 16 del núcleo, y ningún otro agujero llega a esas patillas. SPI.h (que implementa el bus por software) pone SCK, MISO y MOSI en las patillas del ICSP, 15, 14 y 16, como lo hace la variante leonardo del núcleo de Arduino; SS es 17, que es PB0, el pin de la lámpara RX, y no tiene agujero, así que un sketch usa cualquier pin libre para el chip select. Los pines 11, 12 y 13 no son SPI en esta placa. 5Vb y GNDd son los rieles de 5 V y de tierra, y RESETb es la misma pista que RESET: mantener cualquiera de los dos agujeros en bajo retiene el chip, y el otro lo sigue a través de R_STRAP.
El mapeo de puertos, que es la razón de ser de la tabla de pines de esta placa:
| pines | puerto |
|---|---|
0, 1 |
PD2, PD3 |
2, 3 |
PD1, PD0 |
4 |
PD4 |
5 |
PC6 |
6 |
PD7 |
7 |
PE6 |
8 a 11 |
PB4 a PB7 |
12 |
PD6 |
13 |
PC7 |
A0 a A3 |
PF7 hasta PF4 |
A4, A5 |
PF1, PF0 |
MISO, SCK, MOSI (14, 15, 16, ICSP) |
PB3, PB1, PB2 |
Cinco puertos, B a F. No hay puerto A ni puerto G en este componente. En el encapsulado de 44 pines que usa el Leonardo, el puerto B y el puerto D están completos, el puerto C solo saca PC6 y PC7, el puerto E saca PE2 y PE6, y al puerto F le faltan PF2 y PF3. Una patilla que el encapsulado no tiene nunca maneja nada y devuelve 0.
Eléctrica:
- Cada GPIO maneja push-pull a 5 V a través de
R_STRONG, queda en alta impedancia, o hace pull-up a través de 35 k, exactamente como establece la sección 1 dedocs/uno.md. Una entrada lee alto a 2.5 V; una red en disputa (Desconocido) lee 0, y una flotante lee ruido, como en el Uno (docs/uno.mdsección 1). SCL/SDAbesideAREFare the same two pieces of metal as pins3and2, noA5yA4como en un Uno, porque en este chip el I2C está en el puerto D. Ese es el único lugar donde la huella de shield compartida no coincide con el chip compartido, y es lo que hay que revisar al mover un sketch de una placa a otra. Ambos agujeros de cada par llevan lo que maneja el pin más lo que esté haciendo la red del otro lado, a través deR_STRAP.5VeIOREFentregan 5 V enR_SUPPLY;3V3entrega 3.3 V;GND,GNDbyGNDcentregan 0 V.VINes una entrada que la placa ignora: siempre se alimenta por USB.RESET(yRESETb, la misma pista) lleva una pull-up de 10 k a 5 V. Bajarlo de 2.5 V retiene la CPU en reset; soltarlo es un reset externo, que es lo que reportaMCUSR.AREFsolo se lee, nunca se maneja. Con una referencia interna seleccionada, el pin se deja en paz.- El pin
13tiene el LEDLde la placa a través de 1 k a tierra. A0aA5son pines digitales ordinarios además de entradas analógicas.
2. Mapa de memoria
| flash | 32 KB, 16 K palabras de instrucción, PC de 14 bits |
| SRAM | 2560 bytes en 0x0100 a 0x0AFF, RAMEND = 0x0AFF |
| EEPROM | 1 KB |
| I/O | 0x20 a 0x5F, alcanzados con IN/OUT/SBI/CBI |
| E/S extendida | 0x60 a 0xFF, alcanzados solo con LDS/STS y las cargas por puntero |
No hay RAMPZ ni EIND: 32 KB de flash caben en Z, así que LPM llega a todo y una dirección de retorno son dos bytes. Una imagen sin procesar más grande que la flash se rechaza por nombre.
En una placa real los 4 KB superiores de flash contienen el bootloader USB, que es como se reprograma por el mismo conector por el que habla el sketch. Aquí nada se carga mediante un bootloader (una imagen se coloca en la flash), así que los 32 KB completos están disponibles y firmware/leonardo/link.ld lo dice.
3. Periféricos
Toda dirección de abajo es una dirección del espacio de datos, tal como las ven LDS/STS y un puntero volatile. Todo registro que no se nombre aquí devuelve su valor de reset y cuenta como un acceso perdido.
3.1 Puertos
Cinco puertos, tres registros cada uno, primero PINx luego DDRx luego PORTx, todos en la ventana de E/S baja:
| puerto | PINx |
|---|---|
| B | 0x23 |
| C | 0x26 |
| D | 0x29 |
| E | 0x2C |
| F | 0x2F |
0x20 a 0x22 es donde estaría el puerto A en un componente que lo tuviera, y este no lo tiene: esas tres direcciones son accesos perdidos. El bit 4 PUD de MCUCR (0x55) desactiva todas las pull-up a la vez. Escribir un uno en un bit de PINx alterna el bit de PORTx.
3.2 Temporizador/contador 0
Ocho bits, dos canales de comparación, la tabla de preescalador ordinaria. TCCR0A 0x44, TCCR0B 0x45, TCNT0 0x46, OCR0A 0x47, OCR0B 0x48, TIMSK0 0x6E, TIFR0 0x35, GTCCR 0x43. Todos los modos de onda como los da la sección 3.2 de docs/uno.md. OC0A es PB7 (pin 11) y OC0B es PD0 (pin 3).
3.3 Temporizadores/contadores 1 y 3
Dieciséis bits, dieciséis modos de onda, el mismo bloque de catorce registros dos veces: TCCRnA en la base, luego +1 TCCRnB, +2 TCCRnC, +4 TCNTnL, +5 TCNTnH, +6 ICRnL, +7 ICRnH, +8..+13 OCRnAL hasta OCRnCH. El temporizador 1 está en 0x80 y el temporizador 3 en 0x90. TIMSK1 0x6F, TIMSK3 0x71, TIFR1 0x36, TIFR3 0x38.
El temporizador 3 tiene un canal de comparación. TCCR3A contiene COM3A1:0 y los bits de WGM3 y nada más, OCR3B y OCR3C no son registros, y 0x9A a 0x9D son accesos perdidos. TIMSK3 acepta solo TOIE3, OCIE3A y ICIE3.
OC1A es PB5 (pin 9), OC1B es PB6 (pin 10), OC1C es PB7 (pin 11, compartido con OC0A), y OC3A es PC6 (pin 5). Captura de entrada: ICP1 es PD4, ICP3 es PC7.
Que dos periféricos estén conectados a un mismo pad es cosa del propio componente, y la hoja de datos deja en manos del firmware no habilitar ambos. Aquí, el que conmuta su salida es el dueño del pad, y solo el dueño puede devolverlo.
3.4 Temporizador/contador 4, el de diez bits
Este es el periférico que no es una versión más ancha ni más angosta de algo que exista en un ATmega328P. Diez bits detrás de un byte alto compartido, TOP en un registro en lugar de en un modo, y tres canales de comparación llamados A, B y D. No existe el canal C, porque OCR4C es TOP.
| registro | dirección |
|---|---|
TCNT4 |
0xBE |
TC4H |
0xBF |
TCCR4A |
0xC0 |
TCCR4B |
0xC1 |
TCCR4C |
0xC2 |
TCCR4D |
0xC3 |
TCCR4E |
0xC4 |
OCR4A |
0xCF |
OCR4B |
0xD0 |
OCR4C (TOP) |
0xD1 |
OCR4D |
0xD2 |
DT4 |
0xD4 |
TIMSK4 |
0x72 |
TIFR4 |
0x39 |
Bits de TIFR4 y TIMSK4: TOV4/TOIE4 bit 2, OCF4B/OCIE4B bit 5, OCF4A/OCIE4A bit 6, OCF4D/OCIE4D bit 7. CS43:0 en TCCR4B detiene el contador en 0 y de lo contrario divide entre 2^(n-1), hasta 16384. OCR4C se restablece a 0xFF, y por eso un ciclo útil de ocho bits funciona sin escribir TOP. Todo registro de diez bits pasa por TC4H, que es un latch separado del TEMP de los temporizadores de 16 bits.
Modelado: PWM rápido (WGM41:0 = 0) y PWM con fase y frecuencia corregidas (WGM41:0 = 1), las tres salidas de comparación en OC4A (PC7, pin 13), OC4B (PB6, pin 10) y OC4D (PD7, pin 6), y las cuatro banderas con sus habilitaciones. Un canal necesita su bit PWM4x además de sus bits COM4x; COM4x por sí solo no hace nada.
Not modeled, and this is the list to read before trusting a waveform: the clock is CK, the 16 MHz system clock, which is what PLLFRQ.PINMUX selects at reset. The 48 or 64 MHz PCK path through the PLL is not there. PLLCSR (0x49) and PLLFRQ (0x52) are stored, and PLOCK reads back set once PLLE is set so firmware that waits for a lock does not spin. The complementary outputs (!OC4A, !OC4B, !OC4D), the dead-time generator in DT4, the output-enable bits in TCCR4E, the enhanced-resolution mode, the fault-protection unit and the two PWM6 modes are all absent. COM4x = 1 and COM4x = 2 both behave as non-inverting here, because the complementary output that tells them apart is what is missing.
3.5 USART1
Un USART, y es Serial1. Siete registros desde 0xC8: UCSR1A, +1 UCSR1B, +2 UCSR1C, +3 UCSR1D, +4 UBRR1L, +5 UBRR1H, +6 UDR1. Las posiciones de los bits son las del Uno (docs/uno.md sección 3.4). UCSR1D se guarda y se lee de vuelta como 0; el control de flujo por hardware no está modelado.
Está conectado a sus pines y a nada más: RXD1 es PD2 (pin 0) y TXD1 es PD3 (pin 1). Una trama se transmite a través del pad un bit a la vez (un bit de inicio en bajo, ocho bits de datos con el menos significativo primero, un bit de parada en alto, cada 16 (UBRR + 1) ciclos de CPU, la mitad con U2X1), así que un jumper del pin 1 al pin 0 de verdad transmite un carácter. La recepción muestrea el centro de cada bit, y por eso una velocidad en baudios mal ajustada distorsiona el texto aquí igual que en la mesa real.
TXEN1 toma TXD1 sin importar lo que diga DDRD, y RXEN1 mantiene RXD1 como entrada: esa es la regla de la hoja de datos, y es la razón por la que Serial1.begin() no necesita pinMode.
3.6 El dispositivo USB: un stub que transporta bytes
Este es el punto donde el modelo deliberadamente no es el chip, y importa lo suficiente como para decirlo con claridad.
Modelado, en las direcciones reales: UHWCON 0xD7, USBCON 0xD8, USBSTA 0xD9, USBINT 0xDA, UDCON 0xE0, UDINT 0xE1, UDIEN 0xE2, UDADDR 0xE3, UDFNUML 0xE4, UDFNUMH 0xE5, UEINTX 0xE8, UENUM 0xE9, UERST 0xEA, UECONX 0xEB, UECFG0X 0xEC, UECFG1X 0xED, UESTA0X 0xEE, UESTA1X 0xEF, UEIENX 0xF0, UEDATX 0xF1, UEBCLX 0xF2, UEBCHX 0xF3, UEINT 0xF4. Siete endpoints, del 0 al 6.
Lo que funciona:
USBCON.USBEenciende el controlador; limpiarUDCON.DETACHlo conecta. Hasta que ocurran ambas cosas, cada registroUExse lee como 0 y las escrituras no van a ninguna parte.UENUMselects an endpoint.UECONX.EPENenables it andUECFG0X.EPDIRgives it a direction: set is IN (device to host), clear is OUT.UEINTXse calcula en lugar de guardarse. En un endpoint IN habilitado se leeTXINI | FIFOCON, másRWALmientras el banco de 64 bytes tenga espacio. En un endpoint OUT habilitado se leeRXOUTI | FIFOCON | RWALexactamente mientras el monitor haya enviado algo que nadie ha leído, y 0 en caso contrario.- Writing
UEINTXfollows the AVR USB convention: a bit is cleared by writing a zero to it. ClearingFIFOCONorTXINIon an IN endpoint hands the staged bank to the serial monitor. A bank that reaches 64 bytes goes out on its own. UEDATXmueve bytes: una escritura prepara uno en el endpoint IN seleccionado, una lectura toma uno del endpoint OUT seleccionado.UEBCLXcuenta lo que está preparado o en espera, saturándose en 255.UEINTtiene un bit por cada endpoint con algo pendiente.USBSTAreadsVBUSset andUESTA0XreadsCFGOKset: the board is plugged in and an endpoint this model has is always allocated, because there is no FIFO memory to run out of.
Lo que no está ahí: el host, el bus, el reinicio del bus, los paquetes SETUP, los descriptores, la enumeración, el direccionamiento, el contador de tramas, el inicio de trama de 1 ms, la banca de endpoints, NAK, STALL, el doble búfer y ambas interrupciones USB. USB_GENERAL y USB_ENDPOINT nunca se activan, así que un runtime CDC en este modelo hace sondeo.
Dos consecuencias visibles para un sketch. while (!Serial) {} regresa de inmediato aquí y espera en un escritorio, porque no hay host que enumere el dispositivo. Y un sketch que inspeccione una transferencia de control no tiene nada con qué trabajar.
Keyboard.h, Mouse.h y Joystick.h (firmware/lib, sobre mokxi_hid.h) se compilan y ejecutan aquí igual. Un sketch que incluye una de ellas también enlaza firmware/leonardo/src/usb_hid.c, un miembro de la biblioteca que solo un sketch así incorpora, lo que convierte el dispositivo en uno compuesto: las interfaces CDC como antes, más una interfaz HID con un endpoint IN de interrupción 4 y los descriptores de reporte de todas las bibliotecas unidos, cada uno con su propio ID de reporte (Mouse 1, Keyboard 2, Joystick 3). En una placa eso es lo que el host enumera. Aquí no hay host, así que cada biblioteca imprime en Serial lo que habría enviado, una línea entre corchetes por cambio ([Keyboard] press Ctrl, [Joystick] buttons 0 3 | hat 90 | x 512 y 0). Un sketch sin ninguna de ellas es el dispositivo CDC sencillo, y su salida aquí es la de siempre.
Las bibliotecas escritas para el PluggableUSB del núcleo AVR, MIDIUSB primero, encuentran PluggableUSB.h, USBAPI.h, USBCore.h y USBDesc.h junto a arduino.h (escritos a partir de la especificación USB 2.0 con los nombres del núcleo), así que se compilan y ejecutan sin cambios. MIDIUSB viene integrado (firmware/lib/MIDIUSB.h, con MIDIUSB_Defs.h y pitchToNote.h) en la Leonardo, la Micro y la Pro Micro. PluggableUSB().plug() entrega a un módulo los números de interfaz y de endpoint a continuación de los del puerto CDC, igual que lo haría el núcleo (interfaz 2, endpoint 4 para el primero), pero nada muestra el módulo a un host, ni aquí ni en una placa: sus endpoints nunca se configuran, así que USB_Send() devuelve -1 como el del núcleo antes de la enumeración, USB_Recv() devuelve -1 y USB_Available() es 0. Un sketch de controlador MIDI se ejecuta, y sus notas no llegan a ningún lado: el primer sendMIDI() de MIDIUSB lo dice una vez en el monitor serie ([Mokxi] MIDIUSB: no USB host is simulated, so these MIDI messages go nowhere. ...), y la salida Serial del propio sketch sigue a su alrededor. Ningún panel del editor muestra los mensajes, porque los endpoints de un módulo conectado nunca llegan al motor.
El entorno de ejecución en sí no se limita al stub. firmware/leonardo/src/usb.c es un dispositivo CDC ACM real (endpoint de control 0, un endpoint de notificación 1, bulk OUT 2 y bulk IN 3, los descriptores y el VID y PID del núcleo de Arduino, dirigido por interrupciones, con el toque de 1200 baudios hacia Caterina), y está en cada imagen. Al reiniciarse libera un banco IN vacío en el endpoint 3 y lee FIFOCON de vuelta: el silicio conserva el banco hasta que un host lo lee, y ningún host ha reiniciado siquiera el bus todavía, mientras que este modelo libera de inmediato un banco liberado. Esa única lectura fija el modo para siempre. Aquí el entorno de ejecución conduce el pipe exactamente como se describió arriba y la pila USB se queda inerte; en una placa ejecuta la pila. Un cambio de modelo que mantuviera ocupado un banco liberado pasaría cada sketch de Leonardo a la ruta de hardware, donde Serial no dice nada hasta que un host configura el dispositivo, así que crates/atmega32u4/src/usb.rs tiene una prueba que fija este comportamiento.
3.7 ADC
Diez bits, catorce canales, ADCL 0x78, ADCH 0x79, ADCSRA 0x7A, ADCSRB 0x7B, ADMUX 0x7C, DIDR2 0x7D, DIDR0 0x7E, DIDR1 0x7F. El prescaler, ADSC, ADIF, ADIE, ADATE en modo de ejecución libre y ADLAR se comportan como los describe la sección 3.3 de docs/uno.md; una conversión toma 13 ciclos de reloj del ADC, 25 para la primera tras ADEN.
Dos cosas difieren de un ATmega328P y una de un ATmega2560:
- El selector de canal es de seis bits y su bit más alto,
MUX5, es el bit 5 deADCSRB, not bit 3, which is where an ATmega2560 puts it. - Los canales por encima de siete no son un segundo puerto.
ADC8aADC13son PD4, PD6, PD7, PB4, PB5 y PB6, por lo que A6 a A11 en un Arduino Leonardo también son los pines digitales 4, 12, 6, 8, 9 y 10. Esta placa sacaA0aA5en el header analógico; el resto se alcanza por sus números de pin digitales. - No hay referencia de 1.1 V.
REFS1:0es 0 paraAREF, 1 para AVCC, 3 para los 2.56 V internos, y 2 está reservado. El bandgap de 1.1 V sigue disponible como canal conMUX5:0= 0x1E.
Canal a pad: ADC0 PF0, ADC1 PF1, ADC4 PF4, ADC5 PF5, ADC6 PF6, ADC7 PF7, ADC8 PD4, ADC9 PD6, ADC10 PD7, ADC11 PB4, ADC12 PB5, ADC13 PB6. ADC2 y ADC3 están en el mux y no conectados en este encapsulado; seleccionar uno lee 0. Los canales diferenciales y de ganancia y el sensor de temperatura no están modelados y leen 0.
3.8 Interrupciones externas y de cambio de pin
EICRA 0x69, EICRB 0x6A, EIMSK 0x3D, EIFR 0x3C, PCICR 0x68, PCIFR 0x3B, PCMSK0 0x6B.
Cinco interrupciones externas y tres huecos: INT0 PD0 (pin 3), INT1 PD1 (pin 2), INT2 PD2 (pin 0), INT3 PD3 (pin 1), INT6 PE6 (pin 7). INT4, INT5 y INT7 son espacios reservados sin ningún pin detrás; habilitar uno nunca puede activar nada. Los bits de detección son EICRA para 0 a 3 y EICRB para 4 a 7, dos bits cada uno: 0 nivel bajo, 1 cualquier flanco, 2 de bajada, 3 de subida. Una interrupción de nivel bajo se activa mientras el pin está en bajo y no activa ninguna bandera.
Un solo grupo de cambio de pin, PCINT0, y es todo el puerto B.
3.9 Suspensión y EEPROM
SMCR 0x53 con el bit 0 de SE, y cada modo de suspensión se comporta como idle: el reloj de la CPU se detiene, los periféricos siguen corriendo, y cualquier interrupción habilitada lo despierta. MCUSR 0x54 reporta PORF tras un reinicio por encendido y EXTRF tras mantener el pin de reset. WDTCSR es el watchdog, como el del Uno (docs/uno.md sección 3.8, vector 12), excepto que, como hace el bootloader Caterina, el modelo del chip limpia WDRF y detiene el watchdog tras un reinicio por watchdog, antes de setup(). CLKPR, PRR0, PRR1, OSCCAL, RCCTRL, SPMCSR y GPIOR0..2 se guardan y se leen de vuelta.
La EEPROM es de 1 KB en EECR 0x3F, EEDR 0x40, EEARL 0x41, EEARH 0x42, con EEARH de dos bits de ancho. Una lectura termina al instante; una escritura toma 3.3 ms (26,368 ciclos del oscilador RC de 8 MHz; 1.8 ms en modo de solo borrado o solo escritura), durante los cuales EEPE lee 1, y EERIE activa EE_READY como nivel en cuanto termina.
3.10 Vectores
Cuarenta y tres vectores, a dos palabras de distancia desde la dirección de palabra 0, numerados en orden de prioridad. crates/atmega32u4/src/vectors.rs y firmware/leonardo/include/leonardo.h contienen la tabla; lo que importa aquí es que los espacios 5, 6, 8, 13, 14 y 15 están reservados en esta pieza, y que los dos vectores USB están entre el grupo de cambio de pin y el watchdog, un orden que ningún otro AVR aquí tiene.
Los que usa el entorno de ejecución: INT0..INT3 son 1 a 4, INT6 es 7, PCINT0 es 9, TIMER0_OVF es 23, USART1_RX es 25, ADC es 29, y los cuatro del temporizador 4 son 38 a 41.
4. Canal del host
host_write pone bytes en el endpoint OUT del USB que lee el firmware; host_read toma los bytes que el firmware envió por el endpoint IN. Eso es Serial en un sketch y el monitor serie en la interfaz. Los bytes son UTF-8 en lo que concierne a la interfaz y opacos para el modelo.
Serial1 no está en este canal y nunca lo estará: son dos pines del header.
5. Modelo de tiempo y el componente
Como la sección 5 de docs/uno.md. A 16 MHz, un ciclo dura exactamente 62.5 ns, una porción es de 10 us y exactamente 160 ciclos, y el contador de ciclos se ancla al tiempo del kernel al inicio de cada porción. Dentro de una porción el núcleo avanza una instrucción a la vez, informando al bus el ciclo en que empieza cada instrucción, de modo que un cambio de pin lleva consigo el ciclo que lo causó.
probe es una máscara de bits: 1 en ejecución, 2 en suspensión, 4 el LED L integrado en el pin 13, 8 transmisión USB en los últimos 20 ms, 16 recepción USB. 0 sin programa.
poke: 2 mantiene RESET, 3 lo libera.
6. Firmware (firmware/leonardo/)
Un runtime con forma de Arduino escrito a partir de este documento: setup() y loop(), pinMode, digitalWrite, digitalRead, analogRead, analogWrite, millis, micros, delay, delayMicroseconds, attachInterrupt, Serial y Serial1. Sin núcleo de Arduino, sin avr-libc, sin libc.
Compilado con clang --target=avr -mmcu=atmega32u4, enlazado por ld.lld contra firmware/leonardo/link.ld. Cinco de los archivos del runtime son los del Uno, compilados de nuevo para este componente en lugar de copiados: el formato de números, los auxiliares matemáticos, el floor autónomo y su mitad en ensamblador, y Print. La cadena program del catálogo es elf32 avr atmega32u4.
Pines PWM y sus temporizadores:
| pin | salida | temporizador | frecuencia |
|---|---|---|---|
| 3 | OC0B |
0, PWM rápido | 976.5625 Hz |
| 11 | OC0A |
0, PWM rápido | 976.5625 Hz |
| 13 | OC4A |
4, correcto en fase y frecuencia, TOP = OCR4C |
490.196 Hz |
| 6 | OC4D |
4, correcto en fase y frecuencia, TOP = OCR4C |
490.196 Hz |
| 9 | OC1A |
1, 8 bits correcto en fase | 490.196 Hz |
| 10 | OC1B |
1, 8 bits correcto en fase | 490.196 Hz |
| 5 | OC3A |
3, 8 bits correcto en fase | 490.196 Hz |
Serial es el dispositivo USB en src/usb.c y Serial1 es el USART1. mokxi_init() inicia el dispositivo USB antes que cualquier otra cosa, como lo hace USBDevice.attach() del núcleo de Arduino, de modo que una placa aparece como un puerto serie y recibe el toque de 1200 baudios sin importar si el sketch llama a Serial.begin(). Su espera del PLL está acotada (10 ms; un PLL que nunca se bloquea deja el USB apagado), y el milisegundo que pasa ahí ocurre antes de que arranque el temporizador 0, así que mueve todo lo demás juntos hacia adelante. En una placa, las escrituras por Serial se descartan hasta que el host haya configurado el dispositivo y un programa haya abierto el puerto, un byte espera como máximo 250 ms por un host que no está leyendo, y while (!Serial) espera el DTR, todo como en el núcleo de Arduino. La imagen lleva el VID y PID del Leonardo (0x2341:0x8036) y sus cadenas; el cargador los reescribe para un Micro (0x2341:0x8037) o un Pro Micro (0x1B4F:0x9206) al escribir la placa. La pila cuesta alrededor de 2 KB de flash y una docena de bytes de SRAM.
digitalPinToInterrupt: el pin 3 es 0, el pin 2 es 1, el pin 0 es 2, el pin 1 es 3 y el pin 7 es 4. Cualquier otro valor da -1.
Cuatro ejemplos: blink, button (un interruptor en el pin 7, que es INT6), serial (que imprime por ambos puertos para que la diferencia entre ellos se vea en pantalla) y fade (que controla el pin 13 con el temporizador 4 y el pin 9 con el temporizador 1, de modo que ambos tipos de hardware PWM funcionen a la vez). Cada ejemplo tiene un presupuesto de 8 KB de los 32 KB de flash.
7. Qué no está modelado
SPI, TWI, el comparador analógico, el sensor de temperatura, la sección del bootloader y sus fusibles, el preescalador del reloj, el PLL y el reloj rápido que alimenta al temporizador 4, las salidas complementarias del temporizador 4 y su generador de tiempo muerto, y todo lo que está por encima del conducto de bytes USB listado en la sección 3.6. Esos registros leen su valor de reinicio y cuentan como residuos.
8. De qué está seguro este modelo, y de qué no
Tomado de la hoja de datos y verificado con firmware real. Cada dirección, posición de bit y valor de reseteo de la sección 3 proviene de la hoja de datos del ATmega16U4/ATmega32U4, con numeración del espacio de datos, incluida la ventana de E/S extendida de 0x60 a 0xFF que determina a qué registros pueden llegar IN/OUT y cuáles necesitan sts. Los cinco puertos, los temporizadores 0, 1 y 3, y el temporizador 4 de diez bits con OCR4C como TOP, el USART1, los catorce canales del ADC, INT0 a INT3 y INT6, y el único grupo de cambio de pin son de la hoja de datos. crates/atmega32u4/tests/runtime.rs ejecuta los ELF incluidos blink, serial y fade a través de los puertos, ambos anchos de temporizador y el conducto de bytes USB.
Modelado, pero sin sujeción a los números de la hoja de datos. Comportamientos en lugar de direcciones:
- El controlador de dispositivo USB es un esqueleto que transporta bytes, como dice claramente la sección 3.6. No hay enumeración, ni intercambio de descriptores, ni configuración de endpoints, ni temporización de SOF, ni suspensión ni reanudación, ni reinicio por toque de 1200 baudios.
Seriales un conducto de bytes hacia el canal del host que responde aSerialySerial.dtr()como lo haría un puerto CDC conectado. Así que lo único que hace a un Leonardo un Leonardo (que un sketch pueda bloquearse para siempre esperandowhile (!Serial)) es una decisión que este modelo toma, no un protocolo que ejecuta. - Lo demás es la lista del Uno. El grupo del medio de la sección 7 de
docs/uno.mdaplica sin cambios: un ADC sin errores, un reloj exacto de 16 MHz, tres estados de pad y un umbral con pull-up de 35 kΩ, una alimentación ideal que no puede sufrir un brown-out, un arranque de un microsegundo y una rodaja de 10 us.
Deliberadamente ausentes, como los enumera la sección 7: SPI, TWI, el comparador analógico, el sensor de temperatura, la sección del bootloader y sus fuses, el preescalador del reloj, el PLL y el reloj rápido que alimenta al temporizador 4, las salidas complementarias y el generador de tiempo muerto del temporizador 4, y todo lo que está por encima del canal de bytes USB. Esos registros leen su valor de reinicio y cuentan como sueltos.