Programming UNIHIKER K10 with Arduino IDE

The UNIHIKER K10 is a compact ESP32-S3–based development board designed for rapid prototyping in AI, IoT, and sensor-driven applications.

It integrates a 2.8-inch TFT display, 2 MP camera, microphone, speaker, RGB LED, and onboard sensors for temperature, humidity, light, and motion. Built-in Wi-Fi, Bluetooth, USB-C, microSD support, and Gravity expansion ports provide connectivity.

The board ships with ready-to-use AI functions such as speech and face recognition, and supports programming through MicroPython, Arduino, or graphical IDEs like Mind+.

In this tutorial you will learn how to program the UNIHIKER K10 with the Arduino IDE. However, for some code examples you will need to use Mind+, since sometimes code that is compiled and flashed with the Arduino IDE doesn’t run on the UNIHIKER K10 board.

Overview

Required Parts

For this tutorial you will need only the UNIHIKER K10. You can get it at DFRobot or Amazon, for instance:

UNIHIKER K10

Find at DFRobot

Find at Amazon

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.

Hardware of the UNIHIKER K10

The Unihiker K10 is built around an ESP32-S3 N16R8 module featuring a dual-core 32-bit Xtensa LX7 processor operating at up to 240 MHz. It includes 512 KB of internal SRAM and 16 MB of flash memory, and it supports external storage through a microSD card slot. The picture below shows the front and back of the board:

Wireless Connectivity

The board provides 2.4 GHz Wi-Fi compliant with IEEE 802.11 b/g/n standards and integrates Bluetooth 5.0 with BLE support. This combination allows both networked communication and low-energy, device-to-device connectivity.

Visual, Audio, and User Interaction Hardware

The K10 incorporates a 2.8-inch TFT display with a resolution of 240×320 pixels driven by an ILI9341 controller. It includes a 2-megapixel GC2145 camera module with an approximate 80-degree field of view suited for basic computer-vision tasks.

Audio features include a pair of digital MEMS microphones for voice input and a built-in 2 W speaker driven by an onboard amplifier. The board also contains three addressable WS2812 RGB LEDs for visual feedback.

Environmental and Motion Sensors

The device integrates an AHT20 sensor capable of measuring temperature across roughly –40 °C to +85 °C and humidity across 0 to 100 percent relative humidity. It features an LTR303ALS ambient-light sensor capable of operating across a wide dynamic range from very low light levels to bright outdoor illumination. Motion detection is handled by an SC7A20H three-axis accelerometer that supports selectable measurement ranges up to ±16 g.

I/O Interfaces and Expansion

The K10 offers multiple expansion interfaces including USB-C for power and programming, a microSD slot for removable storage, and a set of Gravity 3-pin and 4-pin connectors that expose digital, analog, I²C, and UART interfaces. The board also has two user programmable buttons, apart from the standard Boot and Reset buttons.

A PH2.0 battery connector supports external battery input, and the edge connector exposes additional GPIO, PWM, ADC, SPI, UART, and I²C lines for broader hardware integration.

Power Characteristics

The board can be powered via USB-C, the dedicated PH2.0 battery connector, or power pins on the edge connector. Internal components and GPIO operate at 3.3-volt logic levels. Power consumption is about 150mA when running Face detection.

Physical Dimensions

The overall size of the Unihiker K10 is approximately 51.6 mm by 83 mm with a thickness of around 11 mm, giving it a compact footprint suitable for handheld, educational, and embedded projects.

Pre-Installed AI and Software Capabilities

The K10 includes several built-in AI features such as face detection, object recognition, QR-code scanning, pet detection, motion detection, and offline voice recognition. These functions run locally using the onboard camera, microphones, and sensors without requiring external compute resources. The device supports programming through MicroPython, Arduino/PlatformIO, and graphical environments such as Mind+.

Built-in Feature	Description / Notes
Face Detection	The K10 can detect human faces locally via its 2 MP camera — useful for projects like access control, presence detection, or simple CV experiments.
Face Recognition	The board can recognize and distinguish previously registered faces (not only detect) for basic face-recognition tasks.
Cat / Dog (Pet) Detection	The K10’s image-AI can identify cats or dogs — enabling pet-recognition demos or pet-monitoring applications.
QR Code Recognition	It can detect and decode QR codes using its camera and pre-loaded vision model.
Motion Detection	The board supports motion-detection via vision (camera) rather than just accelerometer — useful for simple security or activity-sensing tasks.
Custom Image Recognition Models	Users can deploy their own TinyML image-recognition models, enabling custom object detection or classification beyond the built-in ones.
Local (Offline) Speech Recognition	With the onboard microphones and voice-processing model, K10 can recognise speech commands without needing internet connectivity.
Custom Voice Commands	The user can define custom voice commands for voice-controlled projects — useful for voice-driven IoT, interactive projects, or accessibility applications.

Technical Specification

The following table summarizes the technical details of the UNIHIKER K10 board:

Category	Specification
Processor & Memory	ESP32-S3 (dual-core Xtensa LX7 up to 240 MHz), 512 KB SRAM, 16 MB flash
Storage	MicroSD card slot for external storage
Wireless Connectivity	2.4 GHz Wi-Fi (802.11 b/g/n), Bluetooth 5.0 with BLE
Display	2.8-inch TFT LCD, 240 × 320 resolution, ILI9341 driver
Camera	2 MP GC2145 sensor, ~80° field of view
Microphones	Dual digital MEMS microphones
Speaker	2 W integrated speaker with onboard amplifier
LEDs	Three WS2812 addressable RGB LEDs
Environmental Sensors	AHT20 temperature/humidity sensor; LTR303ALS ambient light sensor
Motion Sensor	SC7A20H 3-axis accelerometer (up to ±16 g)
Expansion Ports	Gravity 3-pin and 4-pin connectors; edge connector with GPIO, ADC, PWM, I²C, SPI, UART
Power Options	USB-C, PH2.0 battery input, edge-connector power pins
Power Consumption	150mA
Logic Level	3.3 V
Dimensions	Approximately 51.6 mm × 83 mm × 11 mm
Pre-Installed Features	Built-in AI models, offline speech recognition, camera and sensor utilities

Block Diagram and Schematics

The picture below shows the the block diagram for the UNIHIKER K10 board. Note that the diagram shows the I2C addresses of the hardware components:

Block diagram of the UNIHIKER K10 (source)

For more detailed information have a look at the UNIHIKER K10 Schematic.

Install and Run Mind+ V1.x

In this tutorial we preferably will use the Arduino IDE to program the UNIHIKER K10 board. However, for some programs this currently (Feb 2026) doesn’t work and you need to use the Mind+ programming tool. I there for suggest you install Mind+ before going any further.

Note that there are two major versions of Mind+: V1.x and V2.x. Make sure to download and install version V1.x!

Install Mind+ V1.x

The installation is easy. Go to https://mindplus.cc/en/download.html, download Mind+ V 1.x for your operating system and run the installation software. In this tutorial, I am using Version: V1.8.1 RC3.0 under Windows.

Select Board

Next open the Mind+ application and select the UNIHIKER K10 board. For that click on the “Extensions” button in the lower left corner as shown below:

This opens a new page with boards. Scroll to the end until you find the UNIHIKER K10 board. Click on it and then click on “Back” to go back to the main screen of the Mind+ application:

Connect Unihiker K10

Next connect your Unihiker K10 board with the USB cable to your computer. Then click on the “Connect Device” menu in Mind+ and select “COMxx-UNIHIKER K10” as shown:

The specific COM port will depend on your computer. Make sure no other application is connected to the UNIHIKER K10. For instance, you cannot connect the Arduino IDE and Mind+ in parallel.

Manual Editing and Uploading

Mind+ allows you to create programs graphically by arranging blocks or by manually editing code. We are going to use the Manual Editing functionality. On the right side of the Mind+ IDE you find the tabs “Auto Generate” and “Manual Editing”. Click on on the “Manual Editing” tab to switch to the manual editor as shown here:

Now copy and paste the following code into the Editor and then press the “Upload” button above the editor panel.

#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() {
}

You should see that the code gets compiled and uploaded to the board. It sets the screen color to yellow (0xFFFF00) and prints the text “Makerguides” at line 5. On the Unihiker K10 display you should see the following:

If this works, then congratulations. You can now program the Unihiker K10 with the Mind+ IDE.

Restore device initial settings

If you have issues connecting or flashing the Unihiker K10, it often helps to restore the device settings. Go to the menu and click on “Restore device initial settings” as shown below:

This is especially useful when you upload a program via the Arduino IDE that leave the Unihiker K10 board in an unresponsive state.

In the next section you will learn how to setup the Arduino IDE to program the Unihiker K10.

Install UNIHIKER K10 Board in Arduino IDE

To program the UNIHIKER K10 via the Arduino IDE you first need to install the UNIHIKER K10 board. In this section I will guide you through the required steps.

Start by opening your Arduino IDE and go to “File -> Preferences…” to open the Preferences dialog:

In the Preferences Dialog look for the section “Additional boards manager URLs” and click on the green button in the lower, right corner as shown below:

This will open the list of “Additional boards manager URLs”:

There you need to add the following URL (marked yellow in the above screenshot):

https://downloadcd.dfrobot.com.cn/UNIHIKER/package_unihiker_index.json

As you can see, I have also URLs for ESP8266 and ESP32 boards. Don’t let that confuse you. Just add the URL for the UNIHIKER to the list. The order doesn’t matter.

Install UNIHIKER K10 board

Next, we install the UNIHIKER K10 board. Open the BOARDS MANAGER, enter “unihiker” in the search box and you should see the “UNIHIKER by DFRobot” board:

Click on the INSTALL button and the UNIHIKER K10 board should then be installed. As of Feb 2026 the versions of the UNIHIKER K10 board software is 0.0.3.

Next connect your UNIHIKER K10 board via the USB cable to your computer. The Arduino IDE should recognize it and allow you to select the COM port:

Tools Settings

Finally, we adjust the Settings for the board, which you can find under “Tools”:

You can keep the default settings apart from “USB CDC on Boot”, which you should set to “Enabled” and the model language, which should be “EN” (English).

Code Example: Serial Communication

Before we try any complicated code, let us check that flashing and communication with the board works. Upload the following code to the UNIHIKER K10 board:

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.println("Makerguides");
  delay(2000);
}

Then open the Serial Monitor and you should see the text “Makerguides” printed every two seconds. If not, make sure that your Tools settings and Baud rate (115200) settings are correct. As mentioned, you need “USB CDC on Boot” set to “Enabled”.

This code should work with the Arduino IDE and the Mind+ IDE.

Code Example: Display

The following code tests the display function. It sets the orientation of the screen to 2, the background color of the display to yellow (0xFFFF00) and prints the text “Makerguides” at line 5 in black (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() {
}

In my case this code works when uploaded with the Mind+ IDE but not with the Arduino IDE. In the latter case the code compiles and can be flashed but just doesn’t run on the board. You will find that for all the following code examples that use the display, you need to upload code with Mind+.

For more code examples regarding display programming see the display-showing-text example.

Code Example: Measure Temperature and Humidity

This next code uses the integrated ATH20 sensor to measure the ambient temperature and humidity. The code measures these environmental data every second and displays the values on the display:

// 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);
}

This code works when uploaded via Mind+ but not with the Arduino IDE.

Code Example: Measure Brightness

The UNIHIKER K10 also has an integrated ambient light sensor, the LTR303ALS. The following code example shows you how to measure ambient light intensity (brightness) with this sensor:

// 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);
}

Since we are using the display this code again only works when uploaded via the Mind+ IDE.

Code Example: Play Audio

The following code example demonstrates how to control the speaker of the UNIHIKER K10. It plays a different sequence of tones when button A or button B is pressed:

// 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() {
}

I found that this code works with the Arduino IDE and the Mind+ IDE.

Also have a look at the audio-record-and-play example that shows you how to record audio, store it on the SD card and the play it over the speaker.

Code Example: Accelerometer

In the following code example we use the data from the integrated accelerometer to control the movements of a dot (ball) on the screen. The code draws a green circle, which moves in the direction the board is tilted.

// 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);
}

This code works when uploaded via Mind+ but fails when using the Arduino IDE.

For additional information on the code see the on-board-sensor-accelerate-ball example.

Code Example: Minimal Speech Recognition

This code tests the speech recognition. After saying the wake word “Hi, Telly”, or “Jarvis” the blue LED switches on. If you then say “lights on” the text “ON” will be printed to the Serial monitor. If you say “lights off” the text “OFF” will be printed.

// 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");
  }
}

This code works with the Arduino IDE and Mind+.

Code Example: Control Lights with Speech

In this next example we extend the previous code a bit and switch the RGB LEDs of the board on or off using voice commands. As before, you first have to say the wake word “Hi, Telly”, or “Jarvis” and then can say “lights on” or “lights off” to switch the LEDs on or off.

// 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);
  }
}

This code worked with the Arduino IDE and Mind+.

See the ai-speech-recognition example for more information on the code.

Code Example: Dim Lights with Speech

And finally a last speech recognition example. We extend the previous code to also control the brightness of the LEDs. The code now recognizes the commands “lights on”, “lights off”, “brighter” and “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);
  }  
}

This code works with the Arduino IDE and Mind+.

Code Example: Movement Detection

In this code example we use the on-board camera of the UNIHIKER K10 to detect motion. Whenever an object moves in front of the camera the RGB leds change their color from blue to red:

// 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);
  }
}

This code works only when uploaded with the Mind+ IDE.

See the on-board-sensor-accelerate-ball example for a demo of the code.

Code Example: Face Detection

Finally, we are going to try the face detection capabilities. The code below uses the camera to detect faces. It displays the camera image on the screen and puts a green rectangle (bounding box) around a detected face. It also prints the x, y coordinates and the size of the bounding box (w, h) to the screen:

// 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);
}

This code works only when uploaded with the Mind+ IDE.

See the ai-face-detection example for a demo of the code.

Code Example: Face Recognition

Our last code examples performs face recognition. It allows you to learn and detect specific faces. Point the camera of the board towards a face, wait for the bounding box to appear, and then press the A button of the board to learn this face. The LED turns to green, once a face is learned. Then press the B button to recognize faces. The ID of the recognized face is printed to the screen.

// 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();
  }
}

The board stores the learned face ids in non-volatile memory and therefore remain even after resetting the board. To forget all learned faces you can call the ai.sendFaceCmd(DELETEALL) command. To forget a specific face you can call ai.sendFaceCmd(DELETE, id). See the ai-face-recognition example for a demo of the code.

This code works only when uploaded with the Mind+ IDE.

Troubleshooting: Uploading code with Arduino IDE

As mentioned before, some code example don’t work when uploaded via the Arduino IDE. The code compiles and the upload is successful but UNIHIKER K10 then crashes and becomes unresponsive.

Strangely enough, all code examples work perfectly fine when compiled and uploaded with the Mind+ IDE. So, it is not a hardware issue of the UNIHIKER K10 board but seems to be related to the UNIHIKER K10 core software that is still in Version 0.0.3 as of Feb 2026.

If you upload code using the Arduino IDE and the UNIHIKER K10 board becomes unresponsive, close the Arduino IDE and upload code or flash the firmware using the Mind+ IDE. I found this sort of “resets” the board and it can then be flashed via Arduino IDE again.

Conclusions

In this tutorial you learned how to program the UNIHIKER K10 AI board using the Arduino IDE or the Mind+ IDE. The code examples showed you how to control the display and the LEDs, and how to perform speech and face recognition. For more examples see the WiKi for the UNIHIKER K10. Also have a look at the code reference for the board.

The UNIHIKER K10 makes it very easy to use AI algorithms such as speech recognition and face detection. Especially the speech recognition is easy to program, works offline with low latency and high recognition accuracy. For simple voice control projects this is ideal.

Unfortunately, support for the Arduino IDE and documentation is somewhat lacking. For instance, there is no github repo for the K10 library and the docs are incomplete. Furthermore, speech recognition code could be flashed with Arduino IDE but not the face recognition code. You need to use Mind+ for that.

Compared to similar AI vision boards such as the HUSKYLENS or the HUSKYLENS 2, the UNIHIKER K10 is less powerful and has fewer AI vision models integrated. On the other hand, it does not require a second microcontroller to process the detection results and the overall power consumption is much lower.

Compared to the MaTouch AI ESP32S3 TFT or the DFRobot ESP32-S3 AI Camera, the UNIHIKER K10 comes with a nice library that makes programming AI vision and Speech recognition applications really easy.

If you have any questions feel free to leave them in the comment section.

Happy Tinkering 😉

Stefan Maetschke

Stefan is a professional software developer and researcher. He has worked in robotics, bioinformatics, image/audio processing and education at Siemens, IBM and Google. He specializes in AI and machine learning and has a keen interest in DIY projects involving Arduino and 3D printing.