Le UNIHIKER K10 est une carte de développement compacte basée sur l’ESP32-S3, conçue pour le prototypage rapide dans les applications d’IA, d’IoT et de capteurs.
Elle intègre un écran TFT de 2,8 pouces, une caméra 2 MP, un microphone, un haut-parleur, une LED RGB et des capteurs embarqués pour la température, l’humidité, la lumière et le mouvement. Le Wi-Fi, Bluetooth, USB-C, le support microSD et les ports d’extension Gravity assurent la connectivité.
La carte est livrée avec des fonctions d’IA prêtes à l’emploi telles que la reconnaissance vocale et faciale, et supporte la programmation via MicroPython, Arduino ou des environnements graphiques comme Mind+.
Dans ce tutoriel, vous apprendrez à programmer le UNIHIKER K10 avec l’IDE Arduino. Cependant, pour certains exemples de code, vous devrez utiliser Mind+, car parfois le code compilé et flashé avec l’IDE Arduino ne fonctionne pas sur la carte UNIHIKER K10.
Pièces requises
Pour ce tutoriel, vous aurez uniquement besoin du UNIHIKER K10. Vous pouvez l’acheter chez DFRobot ou Amazon, par exemple :
UNIHIKER K10
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Matériel du UNIHIKER K10
Le Unihiker K10 est construit autour d’un module ESP32-S3 N16R8 avec un processeur dual-core 32 bits Xtensa LX7 fonctionnant jusqu’à 240 MHz. Il comprend 512 Ko de SRAM interne et 16 Mo de mémoire flash, et supporte le stockage externe via un slot microSD. L’image ci-dessous montre le recto et le verso de la carte :
Connectivité sans fil
La carte offre du Wi-Fi 2,4 GHz conforme aux normes IEEE 802.11 b/g/n et intègre le Bluetooth 5.0 avec support BLE. Cette combinaison permet une communication en réseau et une connectivité basse consommation entre appareils.
Matériel visuel, audio et d’interaction utilisateur
Le K10 intègre un écran TFT de 2,8 pouces avec une résolution de 240×320 pixels piloté par un contrôleur ILI9341. Il comprend un module caméra GC2145 de 2 mégapixels avec un champ de vision d’environ 80 degrés, adapté aux tâches basiques de vision par ordinateur.
Les fonctionnalités audio incluent deux microphones MEMS numériques pour l’entrée vocale et un haut-parleur intégré de 2 W piloté par un amplificateur embarqué. La carte contient également trois LED RGB adressables WS2812 pour un retour visuel.
Capteurs environnementaux et de mouvement
L’appareil intègre un AHT20 capable de mesurer la température de –40 °C à +85 °C environ et l’humidité relative de 0 à 100 %. Il dispose d’un capteur LTR303ALS de lumière ambiante capable de fonctionner sur une large plage dynamique, des très faibles niveaux lumineux à une forte luminosité extérieure. La détection de mouvement est assurée par un accéléromètre triaxial SC7A20H avec des plages de mesure sélectionnables jusqu’à ±16 g.
Interfaces d’E/S et extensions
Le K10 propose plusieurs interfaces d’extension, notamment USB-C pour l’alimentation et la programmation, un slot microSD pour le stockage amovible, et des connecteurs Gravity 3 et 4 broches exposant des interfaces numériques, analogiques, I²C et UART. La carte dispose aussi de deux boutons programmables par l’utilisateur, en plus des boutons Boot et Reset standards.
Un connecteur batterie PH2.0 supporte une alimentation externe, et le connecteur latéral expose des lignes GPIO, PWM, ADC, SPI, UART et I²C supplémentaires pour une intégration matérielle plus large.
Caractéristiques d’alimentation
La carte peut être alimentée via USB-C, le connecteur batterie PH2.0 dédié, ou les broches d’alimentation du connecteur latéral. Les composants internes et les GPIO fonctionnent en logique 3,3 volts. La consommation est d’environ 150 mA lors de la détection faciale.
Dimensions physiques
La taille totale du Unihiker K10 est d’environ 51,6 mm par 83 mm avec une épaisseur d’environ 11 mm, offrant un format compact adapté aux projets portables, éducatifs et embarqués.
Fonctionnalités AI et logicielles préinstallées
Le K10 inclut plusieurs fonctions d’IA intégrées telles que la détection de visage, la reconnaissance d’objets, la lecture de QR codes, la détection d’animaux domestiques, la détection de mouvement et la reconnaissance vocale hors ligne. Ces fonctions s’exécutent localement grâce à la caméra, aux microphones et aux capteurs embarqués, sans nécessiter de ressources externes. L’appareil supporte la programmation via MicroPython, Arduino/PlatformIO et des environnements graphiques comme Mind+.
| Fonctionnalité intégrée | Description / Notes |
|---|---|
| Détection de visage | Le K10 peut détecter localement les visages humains via sa caméra 2 MP — utile pour des projets comme le contrôle d’accès, la détection de présence ou des expériences simples de vision par ordinateur. |
| Reconnaissance faciale | La carte peut reconnaître et distinguer des visages enregistrés précédemment (pas seulement détecter) pour des tâches basiques de reconnaissance faciale. |
| Détection de chat / chien (animal domestique) | L’IA d’image du K10 peut identifier chats ou chiens — permettant des démonstrations de reconnaissance d’animaux ou des applications de surveillance d’animaux domestiques. |
| Reconnaissance de QR Code | Elle peut détecter et décoder des QR codes grâce à sa caméra et un modèle de vision préchargé. |
| Détection de mouvement | La carte supporte la détection de mouvement via la vision (caméra) plutôt que seulement l’accéléromètre — utile pour des tâches simples de sécurité ou de détection d’activité. |
| Modèles personnalisés de reconnaissance d’image | Les utilisateurs peuvent déployer leurs propres modèles TinyML de reconnaissance d’image, permettant la détection ou classification d’objets personnalisés au-delà des modèles intégrés. |
| Reconnaissance vocale locale (hors ligne) | Avec les microphones embarqués et le modèle de traitement vocal, le K10 peut reconnaître des commandes vocales sans nécessiter de connexion internet. |
| Commandes vocales personnalisées | L’utilisateur peut définir des commandes vocales personnalisées pour des projets contrôlés par la voix — utile pour l’IoT vocal, les projets interactifs ou les applications d’accessibilité. |
Spécifications techniques
Le tableau suivant résume les détails techniques de la carte UNIHIKER K10 :
| Catégorie | Spécification |
|---|---|
| Processeur & Mémoire | ESP32-S3 (dual-core Xtensa LX7 jusqu’à 240 MHz), 512 Ko SRAM, 16 Mo flash |
| Stockage | Slot microSD pour stockage externe |
| Connectivité sans fil | Wi-Fi 2,4 GHz (802.11 b/g/n), Bluetooth 5.0 avec BLE |
| Écran | Écran TFT LCD 2,8 pouces, résolution 240 × 320, pilote ILI9341 |
| Caméra | Capteur 2 MP GC2145, champ de vision ~80° |
| Microphones | Double microphone MEMS numérique |
| Haut-parleur | Haut-parleur intégré 2 W avec amplificateur embarqué |
| LEDs | Trois LED RGB adressables WS2812 |
| Capteurs environnementaux | Capteur température/humidité AHT20 ; capteur lumière ambiante LTR303ALS |
| Capteur de mouvement | Accéléromètre 3 axes SC7A20H (jusqu’à ±16 g) |
| Ports d’extension | Connecteurs Gravity 3 et 4 broches ; connecteur latéral avec GPIO, ADC, PWM, I²C, SPI, UART |
| Options d’alimentation | USB-C, entrée batterie PH2.0, broches d’alimentation connecteur latéral |
| Consommation électrique | 150 mA |
| Niveau logique | 3,3 V |
| Dimensions | Environ 51,6 mm × 83 mm × 11 mm |
| Fonctionnalités préinstallées | Modèles AI intégrés, reconnaissance vocale hors ligne, utilitaires caméra et capteurs |
Schéma bloc et schémas
L’image ci-dessous montre le schéma bloc de la carte UNIHIKER K10. Notez que le diagramme indique les adresses I2C des composants matériels :
Pour plus d’informations détaillées, consultez le UNIHIKER K10 Schematic.
Installer et lancer Mind+ V1.x
Dans ce tutoriel, nous utiliserons de préférence l’IDE Arduino pour programmer la carte UNIHIKER K10. Cependant, pour certains programmes, cela ne fonctionne pas actuellement (février 2026) et vous devez utiliser l’outil de programmation Mind+. Je vous conseille donc d’installer Mind+ avant d’aller plus loin.
Notez qu’il existe deux versions majeures de Mind+ : V1.x et V2.x. Assurez-vous de télécharger et d’installer la version V1.x !
Installer Mind+ V1.x
L’installation est simple. Rendez-vous sur https://mindplus.cc/en/download.html, téléchargez Mind+ V1.x pour votre système d’exploitation et lancez le programme d’installation. Dans ce tutoriel, j’utilise la version : V1.8.1 RC3.0 sous Windows.
Sélectionner la carte
Ouvrez ensuite l’application Mind+ et sélectionnez la carte UNIHIKER K10. Pour cela, cliquez sur le bouton « Extensions » en bas à gauche comme montré ci-dessous :
Cela ouvre une nouvelle page avec les cartes. Faites défiler jusqu’à trouver la carte UNIHIKER K10. Cliquez dessus puis cliquez sur « Back » pour revenir à l’écran principal de l’application Mind+ :
Connecter Unihiker K10
Connectez ensuite votre carte Unihiker K10 avec le câble USB à votre ordinateur. Puis cliquez sur le menu « Connect Device » dans Mind+ et sélectionnez « COMxx-UNIHIKER K10 » comme montré :
Le port COM spécifique dépendra de votre ordinateur. Assurez-vous qu’aucune autre application n’est connectée au UNIHIKER K10. Par exemple, vous ne pouvez pas connecter simultanément l’IDE Arduino et Mind+.
Édition manuelle et téléversement
Mind+ vous permet de créer des programmes graphiquement en arrangeant des blocs ou en éditant manuellement le code. Nous allons utiliser la fonction d’édition manuelle. Sur la droite de l’IDE Mind+, vous trouverez les onglets « Auto Generate » et « Manual Editing ». Cliquez sur l’onglet « Manual Editing » pour passer à l’éditeur manuel comme montré ici :
Copiez-collez maintenant le code suivant dans l’éditeur puis appuyez sur le bouton « Upload » au-dessus du panneau de l’éditeur.
#include "unihiker_k10.h"
UNIHIKER_K10 k10;
void setup() {
k10.begin();
k10.initScreen(2);
k10.creatCanvas();
k10.setScreenBackground(0xFFFF00);
k10.canvas->canvasText("Makerguides", 5, 0x000000);
k10.canvas->updateCanvas();
}
void loop() {
}
Vous devriez voir le code se compiler et se téléverser sur la carte. Il définit la couleur de l’écran en jaune (0xFFFF00) et affiche le texte « Makerguides » à la ligne 5. Sur l’écran du Unihiker K10, vous devriez voir ceci:
Si cela fonctionne, félicitations. Vous pouvez maintenant programmer le Unihiker K10 avec l’IDE Mind+.
Restaurer les paramètres initiaux de l’appareil
Si vous avez des problèmes de connexion ou de flashage du Unihiker K10, il est souvent utile de restaurer les paramètres de l’appareil. Allez dans le menu et cliquez sur « Restore device initial settings » comme montré ci-dessous :
Ceci est particulièrement utile lorsque vous téléversez un programme via l’IDE Arduino qui laisse la carte Unihiker K10 dans un état non réactif.
Dans la section suivante, vous apprendrez à configurer l’IDE Arduino pour programmer le Unihiker K10.
Installer la carte UNIHIKER K10 dans l’IDE Arduino
Pour programmer le UNIHIKER K10 via l’IDE Arduino, vous devez d’abord installer la carte UNIHIKER K10. Dans cette section, je vous guide à travers les étapes nécessaires.
Commencez par ouvrir votre IDE Arduino et allez dans « File -> Preferences… » pour ouvrir la boîte de dialogue Préférences :
Dans la boîte de dialogue Préférences, cherchez la section « Additional boards manager URLs » et cliquez sur le bouton vert en bas à droite comme montré ci-dessous :
Cela ouvrira la liste des « Additional boards manager URLs » :
Vous devez y ajouter l’URL suivante (marquée en jaune dans la capture d’écran ci-dessus) :
https://downloadcd.dfrobot.com.cn/UNIHIKER/package_unihiker_index.json
Comme vous pouvez le voir, j’ai aussi des URLs pour les cartes ESP8266 et ESP32. Ne vous laissez pas déconcerter. Ajoutez simplement l’URL pour le UNIHIKER à la liste. L’ordre n’a pas d’importance.
Installer la carte UNIHIKER K10
Ensuite, installez la carte UNIHIKER K10. Ouvrez le BOARDS MANAGER, tapez « unihiker » dans la barre de recherche et vous devriez voir la carte « UNIHIKER by DFRobot » :
Cliquez sur le bouton INSTALL et la carte UNIHIKER K10 sera installée. En février 2026, la version du logiciel de la carte UNIHIKER K10 est 0.0.3.
Connectez ensuite votre carte UNIHIKER K10 via le câble USB à votre ordinateur. L’IDE Arduino devrait la reconnaître et vous permettre de sélectionner le port COM :
Paramètres des outils
Enfin, ajustez les paramètres de la carte, que vous trouverez sous « Tools » :
Vous pouvez conserver les paramètres par défaut sauf pour « USB CDC on Boot », que vous devez mettre sur « Enabled », et la langue du modèle, qui doit être « EN » (anglais).
Exemple de code : Communication série
Avant d’essayer un code compliqué, vérifions que le flashage et la communication avec la carte fonctionnent. Téléversez le code suivant sur la carte UNIHIKER K10 :
void setup() {
Serial.begin(115200);
}
void loop() {
Serial.println("Makerguides");
delay(2000);
}
Puis ouvrez le Moniteur Série et vous devriez voir le texte « Makerguides » s’afficher toutes les deux secondes. Sinon, vérifiez que vos paramètres Tools et le débit en bauds (115200) sont corrects. Comme mentionné, « USB CDC on Boot » doit être sur « Enabled ».
Ce code devrait fonctionner avec l’IDE Arduino et l’IDE Mind+.
Exemple de code : Affichage
Le code suivant teste la fonction d’affichage. Il définit l’orientation de l’écran à 2, la couleur de fond à jaune (0xFFFF00) et affiche le texte « Makerguides » à la ligne 5 en noir (0x000000) :
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
UNIHIKER_K10 k10;
void setup() {
k10.begin();
k10.initScreen(2);
k10.creatCanvas();
k10.setScreenBackground(0xFFFF00);
k10.canvas->canvasText("Makerguides", 5, 0x000000);
k10.canvas->updateCanvas();
}
void loop() {
}
Dans mon cas, ce code fonctionne lorsqu’il est téléversé avec l’IDE Mind+ mais pas avec l’IDE Arduino. Dans ce dernier cas, le code compile et peut être flashé mais ne s’exécute pas sur la carte. Vous constaterez que pour tous les exemples de code suivants utilisant l’affichage, vous devez téléverser le code avec Mind+.
Pour plus d’exemples de code concernant la programmation de l’affichage, consultez le display-showing-text exemple.
Exemple de code : Mesurer la température et l’humidité
Le code suivant utilise le capteur intégré ATH20 pour mesurer la température ambiante et l’humidité. Le code mesure ces données environnementales chaque seconde et affiche les valeurs à l’écran :
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
UNIHIKER_K10 k10;
AHT20 aht20;
void setup() {
k10.begin();
k10.initScreen(2);
k10.creatCanvas();
k10.setScreenBackground(0xFFFFFF);
}
void loop() {
float temp = aht20.getData(AHT20::eAHT20TempC);
float hum = aht20.getData(AHT20::eAHT20HumiRH);
k10.canvas->canvasText(String("Temp: ") + String(temp), 1, 0x000000);
k10.canvas->canvasText(String("Hum : ") + String(hum), 2, 0x000000);
k10.canvas->updateCanvas();
delay(1000);
}
Ce code fonctionne lorsqu’il est téléversé via Mind+ mais pas avec l’IDE Arduino.
Exemple de code : Mesurer la luminosité
Le UNIHIKER K10 possède aussi un capteur de lumière ambiante intégré, le LTR303ALS. L’exemple de code suivant montre comment mesurer l’intensité lumineuse ambiante avec ce capteur :
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
UNIHIKER_K10 k10;
void setup() {
k10.begin();
k10.initScreen(2);
k10.creatCanvas();
k10.setScreenBackground(0xFFFFFF);
}
void loop() {
uint16_t als = k10.readALS();
k10.canvas->canvasText(String("Brightness: ") + String(als), 1, 0x000000);
k10.canvas->updateCanvas();
delay(200);
}
Comme nous utilisons l’affichage, ce code ne fonctionne qu’avec un téléversement via l’IDE Mind+.
Exemple de code : Lecture audio
L’exemple de code suivant montre comment contrôler le haut-parleur du UNIHIKER K10. Il joue une séquence de tonalités différente lorsque le bouton A ou le bouton B est pressé :
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
void onButtonAPressed();
void onButtonBPressed();
UNIHIKER_K10 k10;
Music music;
void onButtonAPressed() {
music.playMusic(DADADADUM);
}
void onButtonBPressed() {
music.stopPlayTone();
music.playTone(131, 8000);
music.playTone(131, 8000);
music.playTone(196, 8000);
music.playTone(196, 8000);
music.playTone(220, 8000);
music.playTone(220, 8000);
music.playTone(196, 8000);
}
void setup() {
k10.begin();
k10.buttonA->setPressedCallback(onButtonAPressed);
k10.buttonB->setPressedCallback(onButtonBPressed);
}
void loop() {
}
J’ai constaté que ce code fonctionne avec l’IDE Arduino et l’IDE Mind+.
Jetez aussi un œil au audio-record-and-play exemple qui montre comment enregistrer de l’audio, le stocker sur la carte SD et le lire via le haut-parleur.
Exemple de code : Accéléromètre
Dans l’exemple de code suivant, nous utilisons les données de l’accéléromètre intégré pour contrôler les mouvements d’un point (balle) à l’écran. Le code dessine un cercle vert qui se déplace dans la direction où la carte est inclinée.
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
UNIHIKER_K10 k10;
void setup() {
k10.begin();
k10.initScreen(2);
k10.creatCanvas();
k10.setScreenBackground(0xFFFFFF);
}
void loop() {
static float accx, accy, x, y;
accx = (k10.getAccelerometerX());
accy = (k10.getAccelerometerY());
x = (120 + (accx / 3));
y = (120 + (accy / 3));
k10.canvas->canvasCircle(x, y, 8, 0x00FF00, 0x00FF00, true);
k10.canvas->updateCanvas();
k10.canvas->canvasCircle(x, y, 9, 0xFFFFFF, 0xFFFFFF, true);
}
Ce code fonctionne lorsqu’il est téléversé via Mind+ mais échoue avec l’IDE Arduino.
Pour plus d’informations sur le code, consultez le on-board-sensor-accelerate-ball exemple.
Exemple de code : Reconnaissance vocale minimale
Ce code teste la reconnaissance vocale. Après avoir prononcé le mot d’activation « Hi, Telly » ou « Jarvis », la LED bleue s’allume. Si vous dites ensuite « lights on », le texte « ON » s’affiche dans le moniteur série. Si vous dites « lights off », le texte « OFF » s’affiche.
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "asr.h"
#include "unihiker_k10.h"
#define LIGHTS_ON 1
#define LIGHTS_OFF 2
ASR asr;
UNIHIKER_K10 k10;
void setup() {
Serial.begin(9600);
k10.begin();
asr.asrInit(CONTINUOUS, EN_MODE, 6000);
while (asr._asrState == 0) { delay(100); }
asr.addASRCommand(LIGHTS_ON, "lights on");
asr.addASRCommand(LIGHTS_OFF, "lights off");
}
void loop() {
if (asr.isDetectCmdID(LIGHTS_ON)) {
Serial.println("ON");
}
if (asr.isDetectCmdID(LIGHTS_OFF)) {
Serial.println("OFF");
}
}
Ce code fonctionne avec l’IDE Arduino et Mind+.
Exemple de code : Contrôler les lumières par la voix
Dans cet exemple, nous étendons un peu le code précédent et allumons ou éteignons les LED RGB de la carte avec des commandes vocales. Comme avant, vous devez d’abord dire le mot d’activation « Hi, Telly » ou « Jarvis », puis dire « lights on » ou « lights off » pour allumer ou éteindre les LED.
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "asr.h"
#include "unihiker_k10.h"
#define LIGHTS_ON 1
#define LIGHTS_OFF 2
UNIHIKER_K10 k10;
ASR asr;
void setup() {
k10.begin();
asr.asrInit(CONTINUOUS, EN_MODE, 6000);
while (asr._asrState == 0) { delay(100); }
asr.addASRCommand(LIGHTS_ON, "lights on");
asr.addASRCommand(LIGHTS_OFF, "lights off");
}
void loop() {
if (asr.isDetectCmdID(LIGHTS_ON)) {
k10.rgb->brightness(9);
k10.rgb->write(-1, 0xFFFFFF);
}
if (asr.isDetectCmdID(LIGHTS_OFF)) {
k10.rgb->brightness(0);
k10.rgb->write(-1, 0xFFFFFF);
}
}
Ce code fonctionne avec l’IDE Arduino et Mind+.
Voir le ai-speech-recognition exemple pour plus d’informations sur le code.
Exemple de code : Diminuer la luminosité des lumières par la voix
Enfin, un dernier exemple de reconnaissance vocale. Nous étendons le code précédent pour contrôler aussi la luminosité des LED. Le code reconnaît maintenant les commandes « lights on », « lights off », « brighter » et « darker » :
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "asr.h"
#include "unihiker_k10.h"
#define LIGHTS_ON 1
#define LIGHTS_OFF 2
#define LIGHTS_MORE 3
#define LIGHTS_LESS 4
int brightness = 5;
UNIHIKER_K10 k10;
ASR asr;
void setup() {
k10.begin();
asr.asrInit(CONTINUOUS, EN_MODE, 6000);
while (asr._asrState == 0) { delay(100); }
asr.addASRCommand(LIGHTS_ON, "lights on");
asr.addASRCommand(LIGHTS_OFF, "lights off");
asr.addASRCommand(LIGHTS_MORE, "brighter");
asr.addASRCommand(LIGHTS_LESS, "darker");
}
void loop() {
if (asr.isDetectCmdID(LIGHTS_ON)) {
k10.rgb->brightness(brightness);
k10.rgb->write(-1, 0xFFFFFF);
}
if (asr.isDetectCmdID(LIGHTS_OFF)) {
k10.rgb->brightness(0);
k10.rgb->write(-1, 0xFFFFFF);
}
if (asr.isDetectCmdID(LIGHTS_MORE)) {
brightness = constrain(brightness+1, 1, 9);
k10.rgb->brightness(brightness);
k10.rgb->write(-1, 0xFFFFFF);
}
if (asr.isDetectCmdID(LIGHTS_LESS)) {
brightness = constrain(brightness-1, 1, 9);
k10.rgb->brightness(brightness);
k10.rgb->write(-1, 0xFFFFFF);
}
}
Ce code fonctionne avec l’IDE Arduino et Mind+.
Exemple de code : Détection de mouvement
Dans cet exemple, nous utilisons la caméra embarquée du UNIHIKER K10 pour détecter le mouvement. Chaque fois qu’un objet bouge devant la caméra, les LED RGB changent de couleur, passant du bleu au rouge :
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
#include "AIRecognition.h"
UNIHIKER_K10 k10;
AIRecognition ai;
void setup() {
k10.begin();
k10.initScreen(2);
ai.initAi();
k10.initBgCamerImage();
k10.setBgCamerImage(false);
k10.creatCanvas();
ai.switchAiMode(ai.NoMode);
k10.setBgCamerImage(true);
ai.switchAiMode(ai.Move);
ai.setMotinoThreshold(100);
k10.rgb->write(-1, 0x0000FF);
}
void loop() {
if (ai.isDetectContent(AIRecognition::Move)) {
k10.rgb->write(-1, 0xFF0000);
} else {
k10.rgb->write(-1, 0x0000FF);
}
}
Ce code ne fonctionne que lorsqu’il est téléversé avec l’IDE Mind+.
Voir le on-board-sensor-accelerate-ball exemple pour une démonstration du code.
Exemple de code : Détection de visage
Enfin, nous allons tester les capacités de détection faciale. Le code ci-dessous utilise la caméra pour détecter les visages. Il affiche l’image de la caméra à l’écran et dessine un rectangle vert (boîte englobante) autour d’un visage détecté. Il affiche aussi les coordonnées x, y et la taille de la boîte (w, h) à l’écran :
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
#include "AIRecognition.h"
UNIHIKER_K10 k10;
AIRecognition ai;
void display(char *text, int v, int x, int y) {
k10.canvas->canvasText(String(text) + String(v), x, y, 0xFFFF00,
k10.canvas->eCNAndENFont16, 50, true);
}
void setup() {
k10.begin();
k10.initScreen(2);
ai.initAi();
k10.initBgCamerImage();
k10.setBgCamerImage(false);
k10.creatCanvas();
ai.switchAiMode(ai.NoMode);
k10.setBgCamerImage(true);
ai.switchAiMode(ai.Face);
}
void loop() {
if (ai.isDetectContent(AIRecognition::Face)) {
int h = ai.getFaceData(AIRecognition::Length);
int w = ai.getFaceData(AIRecognition::Width);
int x = ai.getFaceData(AIRecognition::CenterX);
int y = ai.getFaceData(AIRecognition::CenterY);
display("Face H: ", h, 0, 0);
display("Face W: ", w, 0, 20);
display("Face X: ", x, 0, 40);
display("Face Y: ", y, 0, 60);
k10.canvas->updateCanvas();
}
delay(100);
}
Ce code ne fonctionne que lorsqu’il est téléversé avec l’IDE Mind+.
Voir le ai-face-detection exemple pour une démonstration du code.
Exemple de code : Reconnaissance faciale
Notre dernier exemple de code réalise la reconnaissance faciale. Il vous permet d’apprendre et de détecter des visages spécifiques. Pointez la caméra de la carte vers un visage, attendez que la boîte englobante apparaisse, puis appuyez sur le bouton A de la carte pour apprendre ce visage. La LED devient verte une fois le visage appris. Ensuite, appuyez sur le bouton B pour reconnaître les visages. L’ID du visage reconnu s’affiche à l’écran.
// www.makerguides.com
// UNIHIKER K10 core 0.0.3
#include "unihiker_k10.h"
#include "AIRecognition.h"
UNIHIKER_K10 k10;
AIRecognition ai;
void onButtonALearn() {
ai.sendFaceCmd(ENROLL);
k10.rgb->write(-1, 0x00FF00);
}
void onButtonBRecognize() {
ai.sendFaceCmd(RECOGNIZE);
k10.rgb->write(-1, 0x0000FF);
}
void setup() {
k10.begin();
k10.initScreen(2);
ai.initAi();
k10.initBgCamerImage();
k10.setBgCamerImage(false);
k10.creatCanvas();
ai.switchAiMode(ai.NoMode);
k10.buttonA->setPressedCallback(onButtonALearn);
k10.buttonB->setPressedCallback(onButtonBRecognize);
k10.setBgCamerImage(true);
ai.switchAiMode(ai.Face);
}
void loop() {
k10.rgb->write(-1, 0x000000);
if (ai.isRecognized()) {
int fid = ai.getRecognitionID();
k10.canvas->canvasText((String("Face ID: ") + String(fid)), 0, 0,
0x0000FF, k10.canvas->eCNAndENFont24, 50, true);
k10.canvas->updateCanvas();
}
}
La carte stocke les ID des visages appris en mémoire non volatile, ils restent donc même après un reset. Pour oublier tous les visages appris, vous pouvez appeler la commande ai.sendFaceCmd(DELETEALL). Pour oublier un visage spécifique, appelez ai.sendFaceCmd(DELETE, id). Voir le ai-face-recognition exemple pour une démonstration du code.
Ce code ne fonctionne que lorsqu’il est téléversé avec l’IDE Mind+.
Dépannage : Téléversement avec l’IDE Arduino
Comme mentionné, certains exemples de code ne fonctionnent pas lorsqu’ils sont téléversés via l’IDE Arduino. Le code compile et le téléversement réussit, mais le UNIHIKER K10 plante et devient non réactif.
Étrangement, tous les exemples fonctionnent parfaitement lorsqu’ils sont compilés et téléversés avec l’IDE Mind+. Ce n’est donc pas un problème matériel de la carte UNIHIKER K10, mais semble lié au logiciel core du UNIHIKER K10 qui est encore en version 0.0.3 en février 2026.
Si vous téléversez du code avec l’IDE Arduino et que la carte devient non réactive, fermez l’IDE Arduino et téléversez ou flashez le firmware avec l’IDE Mind+. J’ai constaté que cela « réinitialise » la carte et permet ensuite de la flasher à nouveau via l’IDE Arduino.
Conclusions
Dans ce tutoriel, vous avez appris à programmer la carte AI UNIHIKER K10 avec l’IDE Arduino ou l’IDE Mind+. Les exemples de code vous ont montré comment contrôler l’affichage et les LED, et comment réaliser la reconnaissance vocale et faciale. Pour plus d’exemples, consultez le WiKi pour le UNIHIKER K10. Jetez aussi un œil au code reference pour la carte.
Le UNIHIKER K10 facilite grandement l’utilisation d’algorithmes d’IA tels que la reconnaissance vocale et la détection faciale. La reconnaissance vocale est particulièrement simple à programmer, fonctionne hors ligne avec une faible latence et une grande précision. Pour des projets simples de contrôle vocal, c’est idéal.
Malheureusement, le support pour l’IDE Arduino et la documentation est un peu limité. Par exemple, il n’y a pas de dépôt GitHub pour la bibliothèque K10 et la documentation est incomplète. De plus, le code de reconnaissance vocale peut être flashé avec l’IDE Arduino, mais pas celui de reconnaissance faciale. Pour cela, il faut utiliser Mind+.
Comparé à des cartes AI vision similaires comme le HUSKYLENS ou le HUSKYLENS 2, le UNIHIKER K10 est moins puissant et intègre moins de modèles AI vision. En revanche, il ne nécessite pas de second microcontrôleur pour traiter les résultats de détection et sa consommation globale est bien plus faible.
Comparé au MaTouch AI ESP32S3 TFT ou au DFRobot ESP32-S3 AI Camera, le UNIHIKER K10 est livré avec une belle bibliothèque qui facilite vraiment la programmation d’applications de vision AI et de reconnaissance vocale.
Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.
Bon bricolage 😉
