Arduino Leonardo — Fiche carte

Arduino S.r.lMCU 8-32 bitarduino

⚡ L’essentiel en 60 secondes

mcu — Atmel/Microchip ATmega32U4 (AVR, 8-bit RISC, modified Harvard architecture — see AVR family article); datasheet via Microchip product page.
cpu — single-core AVR RISC, 16 MHz crystal oscillator (build.f_cpu=16000000L).
gpu — none.
memory — Flash 32 KB (4 KB used by the bootloader → 28,672 bytes available for sketches, upload.maximum_size=28672 in boards.txt); SRAM 2.5 KB (2560 B); EEPROM 1 KB.
usb — native full-speed USB 2.0 device on the ATmega32U4 (no USB-serial chip). Enumerates as CDC serial by default (VID 0x2341, PID 0x8036; bootloader PID 0x0036; legacy VID 0x2A03 also present) and can present HID keyboard/mouse/joystick (boards.txt, store FAQ). Connector: micro-USB.
gpio — 20 digital I/O pins @ 5 V, of which 7 PWM (pins 3, 5, 6, 9, 10, 11, 13 — 8-bit PWM via analogWrite) and 12 analog inputs A0–A11 (10-bit ADC; A6–A11 are multiplexed on digital pins 4, 6, 8, 9, 10, 12). Internal pull-ups 20–50 kΩ. Built-in LED on pin 13. - UART: TTL serial on pins 0 (RX) / 1 (TX) via the Serial1 class — the Serial class on Leonardo means USB (CDC), unlike the Uno (store FAQ). - I2C/TWI: pins 2 (SDA), 3 (SCL), Wire library. - SPI: only on the 6-pin ICSP header — not routed to the digital header; shields using SPI without the ICSP connector will not work (store FAQ). - External interrupts: pins 3 (int0), 2 (int1), 0 (int2), 1 (int3), 7 (int4). - No DAC. Pin↔port mapping: ATmega32u4 pin mapping.
Sur cette fiche : 9 tutoriels · 10 codes

L’Arduino Leonardo se distingue au sein de la famille des cartes de développement Arduino par une architecture matérielle qui a marqué un tournant dans l’histoire de la plateforme. Contrairement aux modèles précédents comme l’Uno ou le Due, qui nécessitaient une puce secondaire dédiée à la gestion des communications USB, le Leonardo intègre directement cette fonctionnalité dans son microcontrôleur principal, l’ATmega32u4. Cette intégration native du contrôleur USB au cœur même du processeur permet à la carte de se faire reconnaître par un ordinateur non seulement comme un périphérique série virtuel, mais aussi comme un véritable clavier, une souris ou une manette de jeu. Cette capacité, appelée HID (Human Interface Device), ouvre la voie à des projets d’automatisation avancés, où la carte peut interagir avec le système d’exploitation de l’ordinateur hôte en envoyant des frappes de clavier ou en déplaçant le curseur, tout en maintenant une connexion série pour le débogage. Sur le plan des performances, le Leonardo repose sur un microcontrôleur AVR 8 bits cadencé à 16 MHz. Cette fréquence d’horloge signifie que le processeur exécute 16 millions de cycles élémentaires par seconde, ce qui est largement suffisant pour la majorité des applications de contrôle temps réel, bien que cela reste modeste comparé aux systèmes modernes. La mémoire disponible pour l’utilisateur est de 28,672 octets de Flash, l’espace de stockage permanent où est enregistré le programme, tandis que 2,5 Ko de SRAM sont alloués à la mémoire vive temporaire nécessaire à l’exécution des variables. Il est important de noter que 4 Ko de la mémoire Flash totale de 32 Ko sont réservés au bootloader, un petit programme de démarrage qui permet de charger le code utilisateur via USB sans avoir besoin d’un programmateur externe spécifique.

La connectivité et les entrées/sorties du Leonardo offrent une grande flexibilité, tout en présentant quelques particularités techniques qu’il convient de maîtriser. La carte dispose de 20 broches d’entrées/sorties numériques fonctionnant sous une tension de 5 volts. Parmi celles-ci, sept broches (3, 5, 6, 9, 10, 11 et 13) sont capables de générer un signal PWM (Modulation de Largeur d’Impulsion). Le PWM est une technique qui simule une tension analogique en variant la durée des impulsions numériques, ce qui est idéal pour contrôler la luminosité d’une LED ou la vitesse d’un moteur. Pour les mesures analogiques, douze entrées sont disponibles, convertissant les signaux continus en valeurs numériques sur 10 bits, ce qui offre une résolution de 1024 niveaux. Cependant, une subtilité importante réside dans le fait que les six dernières entrées analogiques (A6 à A11) sont partagées avec certaines broches numériques, ce qui peut prêter à confusion lors de la programmation. Une autre spécificité majeure concerne la communication série. Sur l’Arduino Uno, la commande « Serial » utilise les broches physiques 0 et 1. Sur le Leonardo, « Serial » correspond à la connexion USB, tandis que les broches physiques 0 et 1 sont accessibles via la commande « Serial1 ». Cette distinction est cruciale pour les utilisateurs migrant d’un modèle à l’autre, car une erreur de configuration peut empêcher la communication avec les modules connectés. De plus, le bus SPI, souvent utilisé pour des mémoires rapides ou des écrans, n’est pas routé vers les connecteurs d’extension standards mais uniquement vers l’embase ICSP à six broches, ce qui rend incompatibles certains boucliers (shields) qui ne prévoient pas de connexion via cet emplacement spécifique.

L’alimentation du Leonardo est conçue pour être polyvalente, acceptant une alimentation via le port micro-USB ou via un connecteur jack cylindrique standard. La tension recommandée pour une alimentation externe se situe entre 7 et 12 volts, avec une plage de fonctionnement tolérée allant de 6 à 20 volts. Un régulateur de tension embarqué abaisse cette tension pour fournir les 5 volts nécessaires aux composants et aux capteurs, ainsi qu’un rail de 3,3 volts limité à 50 mA. Il est à noter que la consommation de courant par broche fait l’objet d’une divergence dans la documentation officielle : la page de la boutique indique 40 mA par broche, tandis que les spécifications techniques internes mentionnent 10 mA. En l’absence de confirmation définitive, il est prudent de considérer la valeur la plus basse pour éviter d’endommager le microcontrôleur lors de la conception de circuits sensibles. La carte est protégée contre les surintensités USB par un fusible réarmable, ce qui évite d’endommager le port USB de l’ordinateur en cas de court-circuit. Physiquement, le Leonardo conserve le format classique de l’Uno, avec des dimensions de 68,6 x 53,3 mm, mais présente un espacement non standard de 160 mils entre les broches numériques 7 et 8, ce qui peut empêcher l’insertion de certains boucliers dont les broches sont alignées sur un pas de 100 mils.

Le développement logiciel sur le Leonardo s’appuie sur l’environnement Arduino IDE et le cœur AVR, offrant une compatibilité étendue avec les bibliothèques existantes. Le bootloader utilisé, nommé Caterina, permet une mise à jour du firmware par simple ouverture du port série à une vitesse spécifique, sans nécessiter d’appui sur le bouton de réinitialisation. Cependant, cette facilité d’usage cache un piège classique pour les débutants : si le programme envoyé à la carte entre dans une boucle infinie qui utilise intensivement les fonctions HID (clavier ou souris), la carte peut devenir difficile à reprogrammer car elle inonde l’ordinateur d’événements de frappe ou de mouvement. Pour éviter ce phénomène, il est recommandé de tester le code avec des impressions série avant d’activer les fonctions HID, ou d’ajouter un délai de sécurité au démarrage. La carte est également compatible avec les outils de programmation AVR classiques via l’interface ICSP, permettant aux utilisateurs avancés de s’affranchir du bootloader et de l’environnement Arduino pour utiliser des chaînes d’outils plus bas niveau comme avr-gcc. Enfin, bien que le Leonardo soit un produit actif et largement utilisé, il est essentiel de garder à l’esprit que la date de lancement initiale de janvier 2014, bien que largement rapportée, n’a pas pu être confirmée par une source officielle en ligne lors de la vérification récente, et que le prix actuel de 25,40 euros TTC peut varier selon les distributeurs.

Vue frontale de la carte de développement Arduino Leonardo sur le site officiel du fabricant.Image officielle Arduino S.r.l

Logo officiel de la marque Arduino, représenté sous forme de fichier vectoriel.Wikipedia — Arduino, Public domain

Photographie d'une carte Arduino Duemilanove, illustrant l'historique des produits de la marque.Wikipedia — Arduino, Public domain

Schéma de brochage (pinout)

Schéma de brochage GPIO de la Arduino Leonardo (source Arduino)Arduino — raw.githubusercontent.com

Forum (1 sujet) →

Specs Historique Pour / Contre Experts Projets Ressources Liens Points d’attention Tutoriels Codes

Attr	Specs	vérifié
`mcu`	Atmel/Microchip ATmega32U4 (AVR, 8-bit RISC, modified Harvard architecture — see AVR family article); datasheet via Microchip product page.	✔
`cpu`	single-core AVR RISC, 16 MHz crystal oscillator (build.f_cpu=16000000L).	? non vérifié
`gpu`	none.	? non vérifié
`memory`	Flash 32 KB (4 KB used by the bootloader → 28,672 bytes available for sketches, upload.maximum_size=28672 in boards.txt); SRAM 2.5 KB (2560 B); EEPROM 1 KB.	✔
`usb`	native full-speed USB 2.0 device on the ATmega32U4 (no USB-serial chip). Enumerates as CDC serial by default (VID 0x2341, PID 0x8036; bootloader PID 0x0036; legacy VID 0x2A03 also present) and can present HID keyboard/mouse/joystick (boards.txt, store FAQ). Connector: micro-USB.	✔
`gpio`	20 digital I/O pins @ 5 V, of which 7 PWM (pins 3, 5, 6, 9, 10, 11, 13 — 8-bit PWM via analogWrite) and 12 analog inputs A0–A11 (10-bit ADC; A6–A11 are multiplexed on digital pins 4, 6, 8, 9, 10, 12). Internal pull-ups 20–50 kΩ. Built-in LED on pin 13. - UART: TTL serial on pins 0 (RX) / 1 (TX) via the Serial1 class — the Serial class on Leonardo means USB (CDC), unlike the Uno (store FAQ). - I2C/TWI: pins 2 (SDA), 3 (SCL), Wire library. - SPI: only on the 6-pin ICSP header — not routed to the digital header; shields using SPI without the ICSP connector will not work (store FAQ). - External interrupts: pins 3 (int0), 2 (int1), 0 (int2), 1 (int3), 7 (int4). - No DAC. Pin↔port mapping: ATmega32u4 pin mapping.	✔
`power`	USB or external via barrel jack (2.1 mm, center-positive) or Vin/GND header; auto source selection. Input voltage recommended 7–12 V, limits 6–20 V; 5 V rail from onboard regulator; 3V3 pin max 50 mA; USB protected by a resettable polyfuse (~500 mA trip). A barrel-plug 9 V battery solution is explicitly advertised (docs features).	✔
`per_pin_dc_current`	store says 40 mA per I/O pin; the docs-content tech-specs.yml says 10 mA.	? non vérifié
`mechanicals`	68.6 × 53.3 mm, 20 g; USB connector and power jack extend beyond the PCB; note the non-standard 160 mil spacing between digital pins 7 and 8 (store FAQ).	✔

Fabricant : Arduino S.r.l. (Italie) — page produit de la boutique, page de documentation
Produit : Arduino Leonardo, une carte à microcontrôleur basée sur l'ATmega32u4, au format classique de taille Uno. Ce fut le premier Arduino grand public à utiliser un microcontrôleur doté d'une communication USB intégrée, supprimant le processeur secondaire USB-série utilisé par les générations Uno/Due (page de documentation, présentation boutique).
Année : L'enregistrement produit officiel actuel (releaseDate: 2021-01-04) dans le dépôt docs-content d'Arduino renvoie à la fiche produit/SKU en cours (product.md). Le Leonardo a été lancé à l'origine en janvier 2014.
Prix de lancement :
Statut : Actif / en vente. Référencé sur l'Arduino Store et la documentation au 2026-10-13 ; l'ATmega32u4 lui-même est « In Production » chez Microchip (page produit Microchip).
SKU / variantes : - A000052 et A000057 (avec/sans connecteurs à broches) — SKU listés dans product.md ; la boutique vend le modèle avec headers et le modèle sans headers. - Proches parents sur le même ATmega32u4 : Arduino Micro ; le Leonardo ETH apparaît dans l'archive des cartes retirées d'Arduino (content/retired/01.boards/arduino-leonardo-eth-2-with-poe dans le dépôt docs-content). - De nombreux clones existent (par ex. les cartes de classe « Pro Micro » utilisent la même puce mais une définition de carte différente — sélectionner la bonne entrée de carte dans l'IDE).

＋ Points forts

USB HID natif — la fonctionnalité définition : le Leonardo « peut se comporter comme une souris ou un clavier » vis-à-vis de l'hôte connecté, en plus d'un port série CDC virtuel, car l'ATmega32u4 possède un transceiver USB intégré (boutique, docs). La programmation se fait avec les bibliothèques Keyboard et Mouse (dépôt Keyboard, dépôt Mouse, référence des fonctions USB).
Périphérique composite : clavier/souris/manette + série CDC simultanément ; une classe HID ouverte (HID.cpp dans ArduinoCore-avr libraries/HID) permet des rapports HID personnalisés (par ex. la bibliothèque Arduino Joystick).
Emprequence de shield compatible Uno (avec la réserve du SPI sur ICSP) plus un jack d'alimentation pratique pour une pile 9 V (docs).
Reset logiciel / entrée en bootloader en ouvrant le port COM à 1200 bauds — aucune pression de bouton nécessaire pour les téléversements (FAQ boutique).
Protection contre les surintensités USB via un polyfuse réinitialisable protégeant le port hôte (FAQ boutique).
Matériel libre (open hardware) : conception de référence EAGLE complète et schémas publiés (liens OSH de la boutique, téléchargements docs-content).

− Points faibles

HID débridé : si du code Mouse/Keyboard s'exécute en continu, il déplace le curseur de l'hôte / inonde le clavier de frappes et peut rendre la carte difficile à reprogrammer ; Arduino avertit explicitement de conditionner les appels HID derrière un interrupteur et de tester d'abord avec Serial.print (tech-specs.md).
Danse reset/téléversement : le sketch continue de s'exécuter à chaque rebranchement (le bootloader est sauté à la mise sous tension) ; un sketch qui se bloque ou plante immédiatement peut accaparer le bus USB à chaque démarrage. Récupération : appuyer sur le bouton reset (bootloader actif ~8 s) et téléverser dans cette fenêtre, ou maintenir la carte en reset pendant la connexion (FAQ boutique).
Serial ≠ broches 0/1 : Serial est le CDC USB ; l'UART TTL sur les broches 0/1 correspond à Serial1 — un bug classique de migration depuis l'Uno (FAQ boutique).
SPI uniquement sur ICSP : les shields SPI dépourvus du connecteur ICSP 6 broches ne fonctionnent pas (FAQ boutique).
Numérotation des broches analogiques : A6–A11 mappent sur les broches numériques 4/6/8/9/10/12 avec des numéros de broches Arduino confus/dupliqués dans le core (ArduinoCore-avr issue #187).
Bugs du core USB CDC : blocage de Serial.available avec de petites lectures tamponnées (issue #516) ; serialEvent non déclenché pour le CDC USB (issue #206) ; l'activité du Moniteur série perturbant la sortie LCD parallèle (issue #434).
Broche HWB (hardware boot) non exposée comme broche numérique dans la variante standard (issue #273).
Piège mécanique : écart de 160 mil (et non 100 mil) entre les broches numériques 7 et 8 — les rangées de broches de certains shields ne s'alignent pas (FAQ boutique).
Divergence des spécifications officielles : 10 mA vs 40 mA par broche E/S entre tech-specs.yml et la page boutique (voir la note de SoC & specs).

Retour d'expérience expert expert — expert-arduino
- Petit retour d'experience sur la Leonardo. Le point fort reste le contrôleur ATmega32u4 avec son USB natif, ce qui permet de creer des peripheriques HID (clavier, souris) sans puce supplementaire. C'est très pratique pour les macros ou l'automatisation. En revanche, attention au piege classique lor… — expert-arduino
- Merci pour ce rappel sur le SPI, je me suis fait avoir avec un shield capteur qui ne repondait pas. J'ai cru a un defaut matériel. Par contre, j'ai une question sur le courant par broche. La fiche technique du store indique 40mA par pin I/O, mais je vois souvent la mention 10mA ailleurs (ou dans le… — maker-debutant-05
- Pour le courant, la discrepance existe bel et bien entre les differentes sources officielles. Tant que tu restes en dessous de 20mA par broche, tu es generalement dans le sur avec l'ATmega32u4, mais evite de tirer sur les limites sans vérifier la datasheet du Microchip. Sur un autre point, si tu ut… — bricoleur-avere

Retours et projets de la communauté

Arduino leonardo and USB Host Shield 2.0 forum.arduino.cc
Retours d'utilisation du shield USB Host 2.0 avec une Arduino Leonardo, pièges d'interruptions.
Help with video game controller using rotary encoder on the Arduino Leonardo forum.arduino.cc
Projet de contrôleur de jeu USB réalisé avec un Leonardo et encodeurs rotatifs, suivi communautaire.
Arduino Leonardo / TastaturInput MausInput erkennen und ausführen forum.arduino.cc
Projet en allemand : détection et envoi d'entrées clavier/souris HID avec un Arduino Leonardo.
How wiring: Load Cell ---> AD620 ---> ADS1115 ---> Arduino Leonardo forum.arduino.cc
Câblage détaillé d'une cellule de charge (AD620 + ADS1115) sur Arduino Leonardo, validé par la communauté.

KeyboardSerial / Keyboard built-in examples
KeyboardSerial / Keyboard built-in examples — official IDE examples (File Examples 09.USB Keyboard), e.g. send a keystroke when a button on pin 2 is pressed ; entry point: , sources in the . (unverified au 2026-10-13)
KeyboardAndMouseControl / MouseMove
KeyboardAndMouseControl / MouseMove — official examples driving the host cursor from potentiometers/serial commands (, ). (unverified au 2026-10-13) Game controller / joystick emulation — MHeironimus's widely used (supports the Leonardo's native USB) to build…
Community projects using the Leonardo part
Community projects using the Leonardo part — curated list on Arduino Project Hub: (linked from the official store page). (unverified au 2026-10-13)

HID débridé : si du code Mouse/Keyboard s'exécute en continu, il déplace le curseur de l'hôte / inonde le clavier de frappes et peut rendre la carte difficile à reprogrammer ; Arduino avertit explicitement de conditionner les appels HID derrière un interrupteur et de tester d'abord avec Serial.print (tech-specs.md).
Danse reset/téléversement : le sketch continue de s'exécuter à chaque rebranchement (le bootloader est sauté à la mise sous tension) ; un sketch qui se bloque ou plante immédiatement peut accaparer le bus USB à chaque démarrage. Récupération : appuyer sur le bouton reset (bootloader actif ~8 s) et téléverser dans cette fenêtre, ou maintenir la carte en reset pendant la connexion (FAQ boutique).
Serial ≠ broches 0/1 : Serial est le CDC USB ; l'UART TTL sur les broches 0/1 correspond à Serial1 — un bug classique de migration depuis l'Uno (FAQ boutique).
SPI uniquement sur ICSP : les shields SPI dépourvus du connecteur ICSP 6 broches ne fonctionnent pas (FAQ boutique).
Numérotation des broches analogiques : A6–A11 mappent sur les broches numériques 4/6/8/9/10/12 avec des numéros de broches Arduino confus/dupliqués dans le core (ArduinoCore-avr issue #187).
Bugs du core USB CDC : blocage de Serial.available avec de petites lectures tamponnées (issue #516) ; serialEvent non déclenché pour le CDC USB (issue #206) ; l'activité du Moniteur série perturbant la sortie LCD parallèle (issue #434).
Broche HWB (hardware boot) non exposée comme broche numérique dans la variante standard (issue #273).
Piège mécanique : écart de 160 mil (et non 100 mil) entre les broches numériques 7 et 8 — les rangées de broches de certains shields ne s'alignent pas (FAQ boutique).
Divergence des spécifications officielles : 10 mA vs 40 mA par broche E/S entre tech-specs.yml et la page boutique (voir la note de SoC & specs).

Faire clignoter la LED intégrée (broche 13) debutant Schéma : IMG-leonardo-debutant-1-leonardo-clignotement-led.svg — Carte Arduino Leonardo alimentée par micro-USB, LED intégrée de la broche 13 (PB7) mise en évidence
Bouton et console série : Serial (USB) vs Serial1 (broches 0/1) debutant Schéma : IMG-leonardo-debutant-2-leonardo-bouton-console-serie.svg — Bouton câblé entre la broche 2 et GND sur une Leonardo, moniteur série affiché à l'écran
Lire un capteur analogique : potentiomètre et ADC 10 bits debutant Schéma : IMG-leonardo-debutant-3-leonardo-capteur-analogique.svg — Potentiomètre alimenté en 5V/GND, curseur relié à A0 sur une Leonardo, courbe de valeur à l'écran
Clavier USB : taper du texte avec la bibliothèque Keyboard intermediaire Schéma : IMG-leonardo-intermediaire-4-leonardo-hid-clavier.svg — Leonardo branchée en USB émettant des frappes vers un ordinateur, bouton sur la broche 2, fenêtre de garde de 3 s
Souris USB : déplacer le curseur avec la bibliothèque Mouse intermediaire Schéma : IMG-leonardo-intermediaire-5-leonardo-hid-souris.svg — Leonardo émulant une souris USB : potentiomètre sur A0 pour l'axe X, bouton de clic sur la broche 4, curseur bougeant à l'écran
Asservir un servo moteur avec un potentiomètre (PWM) intermediaire Schéma : IMG-leonardo-intermediaire-6-leonardo-pwm-servo.svg — Leonardo commandant un servo moteur sur la broche PWM 9, potentiomètre sur A0, alimentation externe 5V avec masse commune
Programmer aux registres : interruption Timer/Counter1 avance Schéma : IMG-leonardo-avance-7-leonardo-registres-avr-interruption-timer.svg — Broche PB7 (D13) de l'ATmega32u4 basculée par l'ISR du Timer1 en mode CTC, registre TCCR1B/OCR1A et signal créneau à 1 Hz
Périphérique composite CDC + HID et bootloader Caterina avance Schéma : IMG-leonardo-avance-8-leonardo-cdc-hid-simultanes.svg — Câble USB de la Leonardo se dédoublant en deux flux étiquetés « Clavier HID » et « Port série CDC » entrant dans un ordinateur, avec la timeline du bootloader Caterina (fenêtre 8 s)
Mode power-down et réveil par watchdog (AVR C nu) avance Schéma : IMG-leonardo-avance-9-leonardo-low-power-powerdown-watchdog.svg — Leonardo sur batterie en sommeil profond, puce ATmega32u4 endormie et chiot-chien de garde (watchdog) la réveillant toutes les ~2,1 s

Bibliothèque de code — exemples écrits pour cette carte

clignotante.ino Arduino
Le programme de vérification réflexe : la LED de la broche 13 clignote à 1 Hz. millis() remplace delay() pour garder la boucle libre. Si rien ne clignote, le téléversement ou la sélection de carte es…
bouton-led.ino Arduino
Un bouton câblé vers GND allume la LED 13 pendant l'appui. Le mode INPUT_PULLUP active la résistance interne, et la fenêtre de 30 ms filtre les rebonds mécaniques du contact.
clavier-auto-tape.ino Arduino
Le 32U4 intégrant le contrôleur USB, la bibliothèque Keyboard énumère un clavier HID : l'ordinateur reçoit les caractères comme s'ils étaient tapés. Idéal pour des macros ou la saisie de mots de pass…
souris-cercle.ino Arduino
La bibliothèque Mouse énumère une souris HID relative : Mouse.move déplace le pointeur pixel par pixel. Ouvrez un logiciel de dessin et admirez le cercle tracé tout seul — la démo classique du 32U4.
telecommande-media.ino Arduino
Les touches de consommation (volume, lecture/pause) font partie du HID clavier : deux boutons suffisent pour une télécommande de bureau. Le 32U4 restant aussi port série, on peut débuguer en parallèl…
bouton-clic-souris.ino Arduino
Le bouton se comporte comme le micro-switch d'une souris : Mouse.click envoie l'appui/relâcement du clic gauche. Pratique pour un boîtier de présentation ou un bouton d'urgence physique.
potentiometre-souris.ino Arduino
L'écart du potentiomètre à sa position de repos devient la vitesse du pointeur : la carte joue les tracksball. Le calibrage se fait au démarrage — posez le potentiomètre au centre avant d'alimenter.
telecommande-presentation.ino Arduino
Les flèches directionnelles envoyées en HID pilotent n'importe quel diaporama (PowerPoint, Impress, web). Un boîtier de deux boutons dans la poche remplace une télécommande à 40 €.
saisie-serie-vers-clavier.ino Arduino
Ce pont démontre la double personnalité USB du 32U4 : port série pour l'ordinateur, clavier pour… le même ordinateur. Envoyez du texte au moniteur série, il apparaît dans n'importe quel champ de sais…
buzzer-melodie.ino Arduino
tone() génère un carré à la fréquence demandée sur la broche du buzzer ; deux tableaux décrivent notes (Hz) et durées (temps musicaux). Un buzzer passif (piézo sans oscillateur) est requis pour jouer…

Exemples et dépôts trouvés en ligne

arduino/ArduinoCore-avr github.com
Cœur Arduino officiel pour cartes ATmega AVR (Uno, Mega, Leonardo, Nano, etc.) avec les sketches d’exemples standards.
NicoHood/HID github.com
Bibliothèque USB HID améliorée pour cartes ATmega32U4 (Leonardo, Micro) avec sketches d’exemples complets.
MHeironimus/ArduinoJoystickLibrary github.com
Bibliothèque Joystick Arduino populaire pour cartes ATmega32U4 (Leonardo, Micro) avec exemples de manettes de jeu.
feilipu/Arduino_FreeRTOS_Library github.com
Bibliothèque FreeRTOS avec exemples pour cartes Arduino ATmega (Uno R3, Leonardo, Mega).
AlanChatham/UnoJoy github.com
Firmware transformant un Arduino Uno, Mega ou Leonardo en manette compatible PS3.