Raspberry Pi 500+ : test, caractéristiques et avis sur le nouveau mini-PC

Violence

Avec le Raspberry Pi 500+, la fondation Raspberry Pi franchit une nouvelle étape : un véritable ordinateur tout-en-un qui associe la puissance d’un Raspberry Pi 5 à un clavier mécanique rétroéclairé. Doté de 16 Go de RAM, d’un SSD NVMe de 256 Go et d’une connectique complète, il se positionne comme une alternative compacte et abordable aux mini-PC traditionnels. Dans cet article, nous vous proposons de découvrir ensemble son déballage, sa mise en route, ses entrailles et les possibilités offertes par son clavier RGB.

Raspberry Pi 500+ : premières impressions et déballage

Le Raspberry Pi 500+ est enfin arrivé ! Vous découvrez ci-dessus la toute premières image de son emballage ! La boîte met en avant le design de l’appareil : un clavier mécanique compact et élégant, qui intègre toute la puissance d’un Raspberry Pi 5.

La face arrière de ce Raspberry Pi 500 Plus figure sur un des côtés de l’emballage, pas trop de surprise ici.

Sur la face arrière, les caractéristiques principales sont bien mises en évidence : processeur ARM Cortex-A76, 16 Go de RAM LPDDR4x, un SSD NVMe de 256 Go pré-installé, la connectivité complète (Wi-Fi, Bluetooth, Gigabit Ethernet) et bien sûr un clavier rétroéclairé programmable LED par LED.

Le plaisir du déballage

À l’ouverture, on découvre directement le Raspberry Pi 500+ soigneusement calé dans son coffret. Le clavier blanc, aux touches profilées, inspire tout de suite confiance par sa finition. Un petit compartiment (en haut à droite) contient les accessoires livrés ave le Pi 500+.

Les accessoires fournis

Dans la boîte, deux petits outils attirent l’attention. La pièce noire est un extracteur de touches : elle permet de retirer facilement les cabochons (keycaps) du clavier mécanique afin de les remplacer ou de les nettoyer. La pièce blanche, quant à elle, est destinée à l’ouverture du boîtier. Elle fait office de levier pour déclipser la coque supérieure sans risque d’endommager les fixations. La fondation a prévu que les utilisateurs puissent accéder facilement à l’intérieur de la machine (notamment au SSD NVMe de 256 Go installé en interne). Cet outil agit comme un levier pour déclipser proprement la coque supérieure sans abîmer les fixations plastiques. Ces deux accessoires montrent bien la volonté de la fondation de rendre le Raspberry Pi 500+ personnalisable et facilement réparable.

Une première prise en main prometteuse

Dès le premier contact, le Pi500+ se distingue par sa construction solide et son ergonomie : tout est intégré dans un seul châssis, ce qui en fait une véritable machine prête à l’emploi. Le design rappelle un ordinateur personnel complet, mais dans le format compact cher à la fondation Raspberry Pi. Les anciennes versions pesaient moins de 400 grammes, ici on dépasse les 600 grammes et franchement on sent bien la différence !

Raspberry Pi 500+ : démontage des touches et clavier rétroéclairé RGB

Utilisez l’outil fourni pour enlever les cabochons des touches.

Grâce à l’outil extracteur fourni, il est très simple de retirer une touche du clavier du Raspberry Pi 500+.

Une fois le cabochon ôté, on distingue parfaitement l’interrupteur mécanique.

Les LEDs RVB sont sous les touches, ici en bleu

Et ici du blanc et du rouge.

Ce choix technique permet d’offrir à la fois la sensation d’un vrai clavier mécanique, avec un retour tactile franc, et une personnalisation visuelle avancée. Chaque touche peut en effet être rétroéclairée indépendamment, avec une large palette de couleurs. Sur les photos ci-dessus, vous apercevez plusieurs exemples de touches retirées et l’éclairage individuel bleu, blanc ou rouge, qui confirme la programmation « touche par touche ».

Un tel niveau de finition place le Pi500+ au-dessus de la simple carte SBC : c’est désormais un ordinateur complet, ergonomique et personnalisable.

Mise en route et configuration du Raspberry Pi 500+

La première mise sous tension du Raspberry Pi 500+ est très simple. Une fois l’alimentation branchée en USB-C, l’appareil démarre automatiquement sur le SSD NVMe de 256 Go pré-installé avec Raspberry Pi OS. Vous n’avez donc pas besoin d’insérer de carte microSD : tout est prêt à fonctionner dès la sortie de la boîte.

L’assistant de configuration vous guide pas à pas : choix de la langue, du clavier et du fuseau horaire, puis connexion au réseau Wi-Fi. En quelques minutes, vous obtenez un bureau fonctionnel, entièrement basé sur Raspberry Pi OS, et prêt pour vos projets de développement, vos activités multimédia ou votre usage quotidien.

Le gain en rapidité par rapport à une installation sur carte microSD est immédiat : le système démarre en une quinzaine de secondes, et l’ouverture des applications est fluide grâce à la mémoire LPDDR4x de 16 Go.

Avec cette approche, le Raspberry Pi 500+ se rapproche d’un véritable PC personnel, sans configuration complexe ni étapes supplémentaires.

Démarrer directement le Pi 500+ sur le SSD NVMe

Par défaut, le Raspberry Pi 500+ vérifie d’abord la présence d’une carte microSD avant de lancer le système. Si vous utilisez uniquement le SSD NVMe intégré, cette étape intermédiaire n’est pas nécessaire et rallonge le temps de démarrage. En configurant l’amorçage direct sur le SSD, vous gagnez en rapidité : le Pi500+ démarre alors en environ 15 à 18 secondes, sans attente inutile.

Accès au menu principal de raspi-config
Depuis un terminal, lancez la commande sudo raspi-config pour ouvrir l’outil de configuration.

Accéder aux options avancées de démarrage
Dans le menu, choisissez Advanced Options, puis l’entrée A4 Boot Order qui permet de définir l’ordre de priorité des périphériques de démarrage.

Choisir l’ordre de démarrage
Plusieurs options sont proposées. Sélectionnez B2 NVMe/USB Boot afin que le Raspberry Pi 500+ démarre en priorité sur son SSD NVMe interne avant de tester l’USB ou la carte SD.

Confirmation du choix
Un écran confirme que le NVMe/USB est défini comme périphérique de démarrage par défaut. Validez avec OK.

Redémarrage du système
Pour que la modification soit prise en compte, redémarrez immédiatement le Raspberry Pi 500+ en choisissant Oui.

En configurant le Raspberry Pi 500+ pour démarrer directement sur son SSD NVMe, vous optimisez à la fois la vitesse et la simplicité d’utilisation. Plus besoin de laisser une carte microSD insérée en permanence : l’ordinateur se comporte comme un véritable PC, prêt à fonctionner dès l’allumage. Cette petite modification de l’ordre de démarrage vous fera gagner de précieuses secondes à chaque mise sous tension.

Et si l’on regardait sous le capot ?

Une fois la configuration logicielle terminée, il est tentant d’aller voir ce que le Raspberry Pi 500+ cache à l’intérieur. La fondation a prévu un outil spécial pour ouvrir facilement le boîtier, sans risque d’endommager les fixations. Voyons ensemble les entrailles de cette nouvelle machine, avec son SSD NVMe intégré et son architecture compacte.

Le Pi 500 + que j’ai reçu de la Fondation est en QWERTY, c’est la version que j’ai reçue pour ce test. Il s’accompagne de la souris officielle Raspberry Pi.

La touche « Cmd » est ici marquée du logo Raspberry Pi : un clin d’œil au design des claviers Apple, adapté à l’univers Pi ?

De profil, on distingue clairement les interrupteurs mécaniques sous chaque touche, avec un design compact mais robuste. La touche « Espace » a un switch central et deux guides situés à chaque extrémité de la touche.

La connectique arrière comprend trois ports USB (dont deux en USB 3.0), un lecteur microSD, un port USB-C pour l’alimentation et deux sorties micro-HDMI capables de gérer la 4K.

À gauche du port Ethernet Gigabit, on retrouve l’accès au fameux connecteur GPIO 40 broches. Protégé par un cache, il reste disponible pour tous les projets de bidouille chers à la communauté Raspberry Pi et aux makers.

Le dessous du Pi 500+ révèle cinq vis à retirer (repérées ici en bleu). Une fois ces vis enlevées, il faut utiliser l’outil blanc fourni, pour déclipser délicatement la coque.

En soulevant le capot, on découvre le circuit imprimé du clavier mécanique. Chaque touche est équipée de son interrupteur et de sa LED RGB. Le clavier est relié par une nappe plate à la carte principale.

Sous le clavier, un large et épais blindage métallique protège et refroidit la carte mère. On distingue le SSD NVMe fixé sur la droite.

Autre élément clé découvert lors du démontage : le SSD NVMe de 256 Go (au format 2230), fourni et installé d’origine avec Raspberry Pi OS par la fondation Raspberry Pi. Ce choix marque un tournant important par rapport aux générations précédentes, qui reposaient presque exclusivement sur des cartes microSD pour le stockage principal.

Avec ce support :

Vous bénéficiez de performances bien supérieures : le démarrage de Raspberry Pi OS s’effectue en 15 à 18 secondes seulement, et l’ouverture des applications est nettement plus fluide.
La fiabilité est renforcée : contrairement aux microSD sujettes à l’usure rapide, un SSD NVMe offre une meilleure endurance pour une utilisation quotidienne.
La fondation propose un SSD badgé Raspberry Pi, optimisé et pré-installé avec le système officiel, ce qui simplifie grandement la mise en route.
La présence de ce SSD démontre la volonté de Raspberry Pi de rapprocher le Pi 500+ d’un véritable ordinateur personnel, prêt à l’emploi et pensé pour durer.

Le connecteur interne accepte les formats NVMe jusqu’au 2280, ce qui ouvre la porte à une extension de capacité jusqu’à 1 ou 2 To selon vos besoins. Vous pouvez ainsi transformer le Pi 500+ en véritable mini-PC de bureau, capable de stocker confortablement projets, médias et environnements de développement.

Le démontage du Raspberry Pi 500+ révèle une puce bien connue : le RP2-B2, une évolution du microcontrôleur RP2040 lancé en 2021 avec le Raspberry Pi Pico.Le RP2040 a marqué un tournant pour la fondation : c’est le premier microcontrôleur maison, conçu et produit sous contrôle direct de Raspberry Pi. Avec lui, la Fondation ne dépend plus uniquement de fournisseurs tiers et maîtrise ainsi toute la chaîne, du design à la production, pour garantir une disponibilité et une flexibilité optimales.

Côté technique, on retrouve :

Dual-Core Arm Cortex-M0+ jusqu’à 133 MHz
264 Ko de SRAM organisés en six banques indépendantes
Interfaces multiples : 2× UART, 2× SPI, 2× I²C, 16 canaux PWM
8 machines d’états PIO pour émuler presque n’importe quel protocole
USB 1.1 avec mode hôte et périphérique
Drag & Drop via USB pour une programmation facile
Large plage d’alimentation (1,8 à 5,5 V) et modes basse consommation

Ce composant équipe le Raspberry Pi Pico et sa famille, mais aussi désormais des produits plus ambitieux comme le Pi 500+, où il prend en charge des fonctions spécifiques telles que la gestion du clavier mécanique et des LEDs RGB.

En intégrant ce microcontrôleur « maison » dans ses propres produits, la fondation maîtrise l’ensemble de l’écosystème matériel et logiciel, tout en assurant une continuité et une indépendance technologique stratégique.

Sous la plaque de dissipation, un pad thermique assure le transfert de chaleur entre le microprocesseur et le blindage métallique.

Un autre détail de conception : une mousse conductrice placée entre la plaque et la carte électronique (sur la prise Ethernet), destinée à améliorer la mise à la masse et à limiter les vibrations.

La carte mère du Pi 500+ enfin dégagée : processeur quad-core Cortex-A76, RAM LPDDR4x soudée, SSD NVMe, connectique arrière et GPIO sont visibles dans un agencement compact et propre.

Au cœur du Pi500+, le SoC Broadcom BCM2712 (sous blindage métallique) accompagné du southbridge RP1 développé par la Fondation Raspberry Pi. En haut, la RAM 16 Go Micron LPDDR4X soudée directement sur la carte. Le composant à droite marqué BOURNS SM51625L est un réseau de protections ESD (ElectroStatic Discharge). Son rôle : protéger les lignes sensibles (comme l’Ethernet, l’USB ou le HDMI) contre les surtensions et les décharges électrostatiques. C’est typiquement une barrière qui absorbe les pics de tension avant qu’ils n’endommagent les circuits du SoC ou du RP1.

Zoom sur le trio principal : processeur Broadcom, puce RP1 (qui gère USB, GPIO, PCIe, etc.) et la mémoire LPDDR4X. C’est le cœur du Pi 500+.

La zone près du port Ethernet montre l’empreinte prévue pour un PoE (Power over Ethernet), non peuplée ici. Raspberry Pi a donc anticipé une éventuelle évolution ou un modèle dédié.

Le composant Renesas dédié à la gestion de l’alimentation (PMIC). Il assure la distribution des tensions nécessaires à l’ensemble du système.

Sur cette photo, on distingue le module radio Wi-Fi / Bluetooth soudé sur la carte du Raspberry Pi 500+. C’est le Raspberry Pi RP1 radio module, blindé sous un capot métallique sérigraphié.
Il assure la connectivité Wi-Fi 5 (802.11ac) et Bluetooth 5.0/5.2, avec les certifications nécessaires (FCC, CE, etc.).

Un connecteur marqué BATTERY : il est certainement destiné à une pile de sauvegarde RTC (horloge temps réel). Cela permet de conserver l’heure même sans alimentation. Je n’ai pas encore pu le tester, je le ferai dès que j’aurai plus d’infos.

La sérigraphie révèle qu’il s’agit d’une carte Raspberry Pi 500 R4 (PVT), millésime 2024. PVT signifie Production Validation Test : une version de pré-série réservée aux partenaires et testeurs. J’ai donc eu la chance de recevoir un exemplaire avant la mise en production finale, afin de valider et documenter ses fonctionnalités pour la préparation de cet article.

Mise en service du clavier du Raspberry Pi 500 +

Installation rapide – Raspberry Pi 500+

Copiez les paquets .deb sur votre Pi 500+.
Ouvrez un terminal dans ce dossier (touche F4 depuis le Bureau).
Installez et mettez à jour le firmware :

sudo apt install ./rpi-keyboard-fw-update\_1.0\_all.deb
sudo rpi-keyboard-fw-update

Installez l’outil de configuration :

sudo apt install ./rpi-keyboard-config\_1.0\_all.deb

Premiers pas avec les LED

# Activer un effet rouge uni
rpi-keyboard-config effect "Solid Color" --hue 0 --sat 255
# Passer à un pinwheel rapide
rpi-keyboard-config effect "Cycle Pinwheel" --speed 200
# Changer de préréglage avec Fn+F4

Votre premier préréglage personnalisé (30 s)

# Définir le préréglage 0 en vert
rpi-keyboard-config preset set 0 "Solid Color" --hue 85 --sat 255
# Activer le préréglage
rpi-keyboard-config preset index 0

Vous pourrez ensuite le rappeler à tout moment avec Fn+F4

Raspberry Pi 500+: Un clavier lumineux

La doc complète : RPi Keyboard Config

RPi Keyboard Config est une bibliothèque Python et un outil en ligne de commande pour configurer les claviers Raspberry Pi, incluant la personnalisation du keymap et le contrôle des LED RGB.

Claviers pris en charge

Raspberry Pi 500 (USB VID: 2e8a, PID: 0010)
Raspberry Pi 500+ (USB VID: 2e8a, PID: 0011)

Fonctionnalités

Configuration du keymap : réaffectez des keycodes à n’importe quelle position.
Contrôle des LED RGB : pilotage LED par LED (500+).
Effets : effets intégrés (couleur unie, dégradé, pinwheel, heatmap, réactif, etc.).
Presets : modifiez les préréglages parcourus avec <kbd>Fn</kbd>+<kbd>F4</kbd>.
Surveillance des touches : visualisez les pressions de touches.
Démos : jeu Flappy Bird et motif aléatoire sur les LED (500+).

Installation

Installez le paquet depuis les dépôts :

sudo apt install rpi-keyboard-config

Les règles udev sont installées automatiquement.

Firmware du clavier

Le clavier doit disposer du firmware à jour. Mettez à jour avec :

sudo rpi-keyboard-fw-update

Code source : github.com/raspberrypi/keyboard-firmware

Utilisation en ligne de commande

Informations de base

# Afficher les infos clavier
rpi-keyboard-config info
# Afficher les infos avec plan ASCII
rpi-keyboard-config info --ascii
# Version de firmware uniquement
rpi-keyboard-config get-version

Configuration du keymap

Les mappages peuvent être modifiés dynamiquement via rpi-keyboard-config key ou via vial.rocks. (Utilisez Chrome)

# Obtenir le keycode d'une position (ligne, colonne)
rpi-keyboard-config key get &lt;row&gt; &lt;col&gt; [--layer &lt;layer&gt;]
# Définir le keycode d'une position
rpi-keyboard-config key set &lt;row&gt; &lt;col&gt; &lt;keycode&gt; [--layer &lt;layer&gt;]
# Lister tous les keycodes d'une couche
rpi-keyboard-config key get-all [--layer &lt;layer&gt;]
# Exemples
rpi-keyboard-config key get 2 3
rpi-keyboard-config key set 2 3 KC_A
rpi-keyboard-config key get-all
# Rétablir le keymap par défaut
rpi-keyboard-config reset-keymap

Verrouillage / Déverrouillage du clavier

Requis pour certaines opérations (ex. monitoring des touches). Voir docs Vial.

# Déverrouiller
rpi-keyboard-config unlock
# Verrouiller<br><br>rpi-keyboard-config lock

Touches de déblocage

Lorsque le système vous demande d’appuyer sur les touches de déblocage,
il s’agit des touches suivantes :

ESC  
ENTER

Appuyez simultanément sur ESC puis ENTER pour poursuivre la procédure.

Surveillance des touches

Note : nécessite le déverrouillage préalable.

# Surveiller les pressions de touches
rpi-keyboard-config key watch [--layer &lt;layer&gt;] [--no-leds] [--exit-key &lt;key&gt;]
# Exemples
rpi-keyboard-config key watch
rpi-keyboard-config key watch --no-leds

Contrôle des LED (Raspberry Pi 500+)

Teinte et luminosité globales

Raccourcis par défaut :

Fn+F3/Fn+Shift+F3 pour la teinte,
Fn+F6/Fn+F5 pour la luminosité.

# Teinte globale (0-255)
rpi-keyboard-config hue
rpi-keyboard-config hue 85
# Luminosité globale (0-255)
rpi-keyboard-config brightness
rpi-keyboard-config brightness 255

Effets RGB

Les effets temporaires restent actifs jusqu’à extinction/reboot ou appui sur <kbd>Fn</kbd>+<kbd>F4</kbd>. Les presets sont restaurés au redémarrage. L’effet direct temporaire est stocké à l’index 7 (non cyclable).

# Effet courant
rpi-keyboard-config effect
# Définir un effet (+ paramètres optionnels)
rpi-keyboard-config effect &lt;effet&gt; [--hue &lt;0-255&gt;] [--sat &lt;0-255&gt;] [--speed &lt;0-255&gt;]
# Lister les effets disponibles
rpi-keyboard-config list-effects
# Exemples
rpi-keyboard-config effect "Solid Color" --hue 0 --sat 255
rpi-keyboard-config effect "Cycle Pinwheel" --speed 200
rpi-keyboard-config effect "Typing Heatmap"

Remarque : la composante valeur (V de HSV) dépend de la luminosité globale. Certains effets peuvent ignorer teinte/saturation.

Presets RGB

Les presets se parcourent avec Fn+F4.
Le preset précédemment affiché est restauré au démarrage.

# Index du preset courant
rpi-keyboard-config preset index
# Définir l'index du preset courant
rpi-keyboard-config preset index &lt;0-7&gt;
# Lire la configuration d'un preset
rpi-keyboard-config preset get [index]
rpi-keyboard-config preset get 2
# Définir la configuration d'un preset
rpi-keyboard-config preset set &lt;index&gt; [effect] [--hue &lt;0-255&gt;] [--sat &lt;0-255&gt;] [--speed &lt;0-255&gt;] [--startup-animation &lt;animation&gt;]
# Revenir au preset enregistré (utile après un effet temporaire)
rpi-keyboard-config preset revert
# Exemples
rpi-keyboard-config preset set 0 "Solid Color" --hue 0 --sat 255
rpi-keyboard-config preset set 3 "Cycle Pinwheel" --speed 150
rpi-keyboard-config preset set 2 --hue 85 --sat 255
rpi-keyboard-config preset index 2
# Ne boucler que sur les 3 premiers presets
rpi-keyboard-config preset set 3 skip
# Définir l'animation de démarrage
rpi-keyboard-config preset set 0 "Solid Color" --startup-animation "START\_ANIM\_W\_FADE\_SAT"

Animations de démarrage disponibles

Nom	Description
START_ANIM_NONE	Aucune animation
START_ANIM_B_NO_FADE	Animation de démarrage, extinction des LED, puis preset
START_ANIM_B_FADE_VAL	Comme ci-dessus, puis fondu en luminosité croissante vers le preset
START_ANIM_W_NO_FADE	Animation de démarrage, LEDs blanches, puis preset
START_ANIM_W_FADE_SAT	Comme ci-dessus, puis fondu avec saturation croissante

Opérations LED (mode direct)

Si le preset courant n’est pas le mode LED direct, un effet LED direct temporaire est appliqué.

# Effacer toutes les LED
rpi-keyboard-config leds clear
# Définir une couleur globale (plusieurs formats)
rpi-keyboard-config leds set --colour red
rpi-keyboard-config leds set --colour "128,255,255" # HSV
rpi-keyboard-config leds set --colour "#FF0000" # Hex RGB
rpi-keyboard-config leds set --colour "rgb(255,0,0)" # RGB
# États LED courants
rpi-keyboard-config leds get
# États LED sauvegardés (EEPROM)
rpi-keyboard-config leds get-saved
# Sauvegarder / recharger la conf LED
rpi-keyboard-config leds save<br><br>rpi-keyboard-config leds load

Contrôle LED individuel

# Par index
rpi-keyboard-config led set &lt;index&gt; --colour &lt;couleur&gt;
# Par position matrice (ligne,colonne)
rpi-keyboard-config led set &lt;row&gt;,&lt;col&gt; --colour &lt;couleur&gt;
# Exemples
rpi-keyboard-config led set 5 --colour blue
rpi-keyboard-config led set 2,3 --colour green
rpi-keyboard-config led set 10 --colour "170,255,255"

Réinitialisations

# Réinitialiser presets et LEDs directes
rpi-keyboard-config reset-presets
# Réinitialiser le keymap par défaut
rpi-keyboard-config reset-keymap

Formats de couleur acceptés

Noms : red, green, blue, yellow, cyan, magenta, white, orange, purple, pink
HSV (par défaut) : 128,255,255 (teinte, saturation, valeur)
Hex RGB : #FF0000
RGB explicite : rgb(255,0,0) (avec le préfixe rgb())

Liste des keycodes QMK

# Lister tous les keycodes
rpi-keyboard-config list-keycodes
# Filtrer par catégorie
rpi-keyboard-config list-keycodes --category basic
rpi-keyboard-config list-keycodes --category modifiers
# Rechercher par nom (insensible à la casse)
rpi-keyboard-config list-keycodes --filter "slash"

Démos et jeux

# Flappy Bird sur les LED (500+)
rpi-keyboard-config game
# Motif LED aléatoire (500+)
rpi-keyboard-config random-leds

Utilisation de la bibliothèque Python

Initialisation

from RPiKeyboardConfig import RPiKeyboardConfig
# Initialiser le clavier
keyboard = RPiKeyboardConfig()

Informations clavier

# Modèle et variante
print(f"Model: {keyboard.model}") # "PI500" ou "PI500PLUS"
print(f"Variant: {keyboard.variant}") # "ISO", "ANSI" ou "JIS" 
# Version de firmware
version = keyboard.get\_firmware\_version()
print(f"Firmware: {version[0]}.{version[1]}.{version[2]}")
# Plan ASCII du keymap (couche 0)
ascii\_map = keyboard.get\_ascii\_keycode\_map(layer=0)<br><br>print(ascii\_map)

Keymap en Python

# Lire un keycode
keycode = keyboard.get\_keycode(matrix=[2, 3], layer=0)
print(f"Key at [2,3]: {keycode}")
# Écrire un keycode (ex. 'A')
keyboard.set\_keycode(matrix=[2, 3], layer=0, keycode=4)
# Lister toutes les touches
all\_keynames = keyboard.get\_all\_keynames(layer=0)
for data in all\_keynames:
 pos = data['position']
 print(f"Key r{pos[0]} c{pos[1]}: {data['keycode']} -&gt; {data['name']}")
# Réinitialiser le keymap
keyboard.reset\_keymap()

Déverrouillage & monitoring

# Statut de sécurité<br><br>unlocked, unlock\_in\_progress, unlock\_keys = keyboard.get\_unlock\_status()
if not unlocked:
print("Unlocking keyboard...")
keyboard.unlock()
# État de la matrice (touches pressées)
if unlocked: 
active\_keys = keyboard.get\_switch\_matrix\_state()
print(f"Pressed: {active\_keys}")
# Verrouiller
keyboard.lock()

LED en Python (500+)

Opérations de base

# Basculer en mode LED direct
keyboard.set\_led\_direct\_effect()
# Par index (HSV: H,S,V)
keyboard.set\_led\_by\_idx(idx=5, colour=(0, 255, 255)) # Rouge
keyboard.set\_led\_by\_idx(idx=6, colour=(85, 255, 255)) # Vert
keyboard.set\_led\_by\_idx(idx=7, colour=(170, 255, 255)) # Cyan
# Par position matrice
keyboard.set\_led\_by\_matrix(matrix=[2, 3], colour=(42, 255, 255)) # Orange
# Envoyer les mises à jour au clavier
keyboard.send\_leds()
# Effacer toutes les LED
keyboard.rgb\_clear()

Opérations avancées

# États LED courants
current\_leds = keyboard.get\_current\_direct\_leds()
for i, (h, s, v) in enumerate(current\_leds):
print(f"LED {i}: HSV({h}, {s}, {v})")
# Informations individuelles
led\_info = keyboard.get\_led\_info(idx=5)
print(f"LED 5: {led\_info}")
# Toutes les LED (config)
all\_leds = keyboard.get\_leds()
for led in all\_leds:
print(f"LED {led.idx}: matrix={led.matrix}, colour={led.colour}")
# Sauvegarder / charger en EEPROM
keyboard.save\_direct\_leds()
keyboard.load\_direct\_leds()
# Lire les LED sauvegardées
saved\_leds = keyboard.get\_saved\_direct\_leds()

Teinte et luminosité globales (Python)

# Teinte globale
current\_hue = keyboard.get\_hue()
keyboard.set\_hue(85)
# Luminosité globale
current\_brightness = keyboard.get\_brightness()
keyboard.set\_brightness(128)

Effets & presets (Python)

# Effets pris en charge &amp; effet courant
effects = keyboard.get_supported_effects()
current_effect = keyboard.get_current_effect()
 
# Créer / appliquer un preset
from RPiKeyboardConfig.keyboard import Preset
from RPiKeyboardConfig.effects import get_vial_effect_id
 
solid_effect_id = get_vial_effect_id("solid color")
red_preset = Preset(
    effect=solid_effect_id,
    speed=128,
    hue=0,        # Rouge
    sat=255,      # Saturation max
    val=255,      # Luminosité max
    fixed_hue=True,
    startup_animation="START_ANIM_B_FADE_VAL"
)
 
keyboard.set_preset(0, red_preset)
keyboard.set_current_preset_index(0, save_index=True)
 
# Lire / revenir au preset
preset = keyboard.get_preset(0)
keyboard.revert_to_saved_preset()
 
# Reset presets &amp; LEDs directes
keyboard.reset_presets_and_direct_leds()

Référence QMK

La bibliothèque supporte les keycodes QMK standard. Listez-les via la commande ci-dessus, ou consultez la documentation QMK : docs.qmk.fm/#/keycodes.

Un exemple : le drapeau Français

#!/usr/bin/env python3
# ============================================================
# Nom      : clavier_drapeau_francais.py
# Version  : 1.0.3
# Auteur   : framboise314
# Licence  : MIT
# Objet    : Afficher le drapeau français (bleu-blanc-rouge)
#            en trois bandes verticales 1/3 - 1/3 - 1/3
# Matériel : Raspberry Pi 500+ (LED RGB intégrées)
# Dépend   : rpi-keyboard-config (lib Python incluse)
# ============================================================

from RPiKeyboardConfig import RPiKeyboardConfig

# ---- Couleurs HSV (H,S,V) ----
BLEU  = (170, 255, 255)
BLANC = (0,   0,   255)
ROUGE = (0,   255, 255)

def initialiser_clavier():
    """Retourne un objet clavier prêt pour le mode LED direct."""
    clavier = RPiKeyboardConfig()
    clavier.set_led_direct_effect()
    return clavier

def lire_matrice_leds(clavier):
    """Récupère la liste des LED avec leurs positions matrice."""
    return clavier.get_leds()

def bornes_colonnes(leds):
    """Renvoie la colonne min et max du clavier."""
    cols = [led.matrix[1] for led in leds]
    return min(cols), max(cols)

def couleur_pour_colonne(col, col_min, col_max):
    """Retourne la couleur selon la bande verticale (BLEU | BLANC | ROUGE)."""
    etendue = col_max - col_min + 1
    tiers = etendue / 3.0
    idx = (col - col_min) + 0.0001  # évite les bords ambigus
    if idx &lt; tiers:
        return BLEU
    elif idx &lt; 2 * tiers:
        return BLANC
    else:
        return ROUGE

def appliquer_drapeau(clavier, luminosite=None, sauvegarder=False):
    """Applique le drapeau français sur les LEDs."""
    leds = lire_matrice_leds(clavier)
    col_min, col_max = bornes_colonnes(leds)

    if luminosite is not None:
        clavier.set_brightness(int(luminosite))

    for led in leds:
        col = led.matrix[1]
        couleur = couleur_pour_colonne(col, col_min, col_max)
        clavier.set_led_by_idx(idx=led.idx, colour=couleur)

    clavier.send_leds()

    if sauvegarder:
        clavier.save_direct_leds()

def main():
    # Réglez ici si besoin
    luminosite_globale = 255   # 0..255 (None pour ne pas toucher)

    clavier = initialiser_clavier()
    appliquer_drapeau(
        clavier,
        luminosite=luminosite_globale,
        sauvegarder=sauvegarde_eeprom
    )
    print("Drapeau français appliqué (BLEU | BLANC | ROUGE).")

if __name__ == "__main__":
    main()

Afficher la matrice (ASCII) directement en ligne de commande

rpi-keyboard-config info --ascii

Ça imprime le layout du clavier sous forme de « matrice » ASCII.

Lister tous les keycodes (par position matrice), au besoin avec la couche :

rpi-keyboard-config key get-all # couche 0 par défaut
rpi-keyboard-config key get-all --layer 1 # exemple autre couche

Vidéo

Conclusion

Le Raspberry Pi 500+ n’est pas un simple gadget pour passionnés : c’est un véritable mini-PC complet, pensé pour offrir confort d’utilisation et fiabilité au quotidien. Certains pourront juger son prix relativement élevé par rapport aux Raspberry Pi traditionnels. Pourtant, il faut rappeler que cette machine intègre d’origine 16 Go de RAM LPDDR4x et un SSD NVMe de 256 Go, deux composants qui transforment radicalement l’expérience utilisateur.

Face à de nombreux mini-PC du marché, parfois séduisants mais souvent limités (voir l’analyse des inconvénients sur Neozone), le Pi 500+ a l’avantage d’une conception maîtrisée de bout en bout par la Fondation Raspberry Pi. Vous profitez ainsi d’un produit pensé pour durer, parfaitement documenté, et soutenu par une vaste communauté.

En définitive, le Raspberry Pi 500+ s’adresse à celles et ceux qui recherchent un mini-ordinateur robuste, évolutif et immédiatement opérationnel, sans compromis sur la mémoire ou le stockage.

En deux mots

Oui, le prix du Raspberry Pi 500+ peut sembler élevé face à certains mini-PC x86.
Mais il se justifie si vous visez des usages makers :

le GPIO accessible, l’intégration fluide avec Linux,
le format tout-en-un avec clavier mécanique,
une **excellente efficacité énergétique **pour un fonctionnement continu.

En revanche, pour des besoins de jeux vidéo récents, de virtualisation lourde ou de rendu 3D intensif, un mini-PC/PC x86 plus puissant restera plus adapté.

Acheter le Pi500+ chez Kubii :

Pi500+ seul 204€ : https://www.kubii.com/fr/4822-raspberry-pi-500-plus.html
Pi500+ version kit 225€ : https://www.kubii.com/fr/4823-kit-raspberry-pi-500-plus.html

– Sources : Changer le SSD, intervenir sur le clavier - Notice officielle du Pi500+ - https://docs.qmk.fm/keycodes

https://www.framboise314.fr/raspberry-pi-500-plus-16go-nvme/

Planète Warez

Light

Dim

Dark