HUSKYLENS 2 K230 AI Vision Sensor

HUSKYLENS 2 detects, learns and recognizes faces, showing IDs, names and confidence, with RGB light feedback, adjustable thresholds, multi-face acceleration, and model export/import for cloning setups.

HUSKYLENS 2's Object Recognition feature identifies 80 types of objects, providing confidence scores and allowing parameter customization. The article guides users on utilizing this feature effectively, setting parameters, and managing models for precise object identification.

HUSKYLENS 2 learns one object, tracks it across angles and distance, lets you tune threshold, name display, reset, and export or import models between devices for quick deployment.

This guide explores the HUSKYLENS 2 color recognition function, detailing how to use, learn, and recognize colors, adjust parameters like color tolerance and area thresholds, export and import models for enhanced detection and tracking, and set custom names for recognized colors.

HUSKYLENS 2 classifies objects into 1000 AI categories, showing labels and confidence, like a smart camera that learns IDs, tunes thresholds, and can export or import models between devices.

The article provides a detailed walkthrough of the HUSKYLENS 2 self-learning classifier function, explaining how to capture, learn, and recognize objects from multiple angles, and covering essential parameter settings and model management.

Instance segmentation on HUSKYLENS 2 labels each object with a precise colored mask and ID, like outlining items with digital stickers, while adjustable thresholds, naming, reset, and model export/import make multi-device vision projects easier to tune and share.

HUSKYLENS 2 detects palms with 21 keypoints, learns multi-angle gestures, tunes detection, recognition and NMS thresholds, manages IDs and names, and supports model export/import for quick duplication across devices.

Pose recognition on HUSKYLENS 2 detects humans via 17 keypoints, learns multi‑angle poses, tunes detection, recognition and NMS thresholds, and lets you name, forget, export or import pose models like copying presets between devices.

HUSKYLENS 2 LPR detects, learns and tracks license plates, like a smart camera that can store IDs, name plates, tune detection thresholds and export or import models between devices.

Optical Character Recognition lets HUSKYLENS 2 detect text in images and learn, name, export or import recognized character IDs via adjustable detection and recognition thresholds.

The article explains the HUSKYLENS 2 line tracking function, which detects lines by color contrast, marking them for visual tracking, and offers a guide on using this feature effectively.

The article offers a detailed look at HUSKYLENS 2's Face Emotion Recognition function, covering how it detects seven specific emotions, guides users through setup and operation, and provides insights into parameter adjustments for optimizing recognition performance.

Eye Gaze on HUSKYLENS 2 detects human gaze angles and directions with tunable thresholds and model import/export, like giving the camera eyes that learn where people look

HUSKYLENS 2 Orientation Detection tracks face roll, yaw, pitch in 3D, learns poses as IDs, tunes detection, recognition and NMS thresholds, and lets you name, reset, export and import models across devices.

The article details HUSKYLENS 2's capability to recognize AprilTag labels, providing insights into setup and usage. It explains how to select tag recognition functions, observe detection effects, learn and name tags, and adjust parameters. It also covers exporting and importing models to facilitate tag recognition across devices.

HUSKYLENS 2 detects, learns, names, and tracks QR codes, lets you manage IDs, toggle name display, reset or export/import models between devices, and offers Arduino, micro:bit, and UNIHIKER coding examples.

HUSKYLENS 2 barcode mode detects, learns, names, exports and imports barcode IDs, like a smart camera that remembers product codes.

HUSKYLENS 2 fall detection spots fallen people, draws ID1 boxes, lets you tune detection and NMS thresholds, reset, and export or import models between devices via USB for quick deployment.

HUSKYLENS 2 works with Arduino, UNIHIKER, micro:bit and Raspberry Pi, using IDEs like Arduino IDE, Mind+, MakeCode and Python IDLE, and returns basic vision data plus extra keypoints for advanced controllers.

This article offers a comprehensive guide on how to wire the HUSKYLENS 2 Power Board with various controllers, ensuring stable performance through correct cable connections and providing a step-by-step process for integrating with common controllers like Arduino.

This is a programming tutorial document for Arduino main controller combined with HUSKYLENS 2. It introduces the hardware and software platforms, wiring diagrams, and related libraries required for use.Install Arduino IDE, connect HUSKYLENS 2 to DFRduino UNO via I2C, power by USB-C, then add the DFRobot HUSKYLENS V2 library

This is a tutorial introducing programming for face recognition using an Arduino paired with HUSKYLENS 2.Face recognition on HUSKYLENS 2 is a smart camera mode that streams face ID, name and position data over I2C or UART in real time, like a digital ruler that measures and locks onto one face for stable tracking in Arduino robotics

HUSKYLENS 2 object recognition turns camera detections into Arduino-readable IDs, counts, and positions, like giving a robot eyes that talk. Two I2C examples show how to read total objects, nearest-to-center label, first detection, and filter or track ID1 targets with cached coordinates.

Object tracking on HUSKYLENS 2 lets Arduino read an object’s ID, name, center coordinates, width and height via UART. It’s like giving your robot a label and position for each item it sees, so you can align the camera, box-select a target, then continuously print tracking data from the cached center result in the loop.

This tutorial covers programming the color recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 color recognition reads block IDs, count and coordinates via Arduino UART, like a smart camera tagging each colored region.

HUSKYLENS 2 self-learning classifier for Arduino lets the camera learn custom objects and later recognize them, like labeling photos automatically. Using the example code, it switches to the self-learning algorithm, reads recognition results, and prints each object’s ID and name to the Serial Monitor, defaulting to “Object” if no name is set.

This tutorial covers programming the instance segmentation function with Arduino and HUSKYLENS 2.HUSKYLENS instance segmentation reads object IDs, center coordinates, size, and counts, like giving each detected item a labeled box for Arduino projects.

This tutorial covers programming the hand recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 hand recognition detects gestures and streams their ID, count, position and size via Arduino serial, like turning hand poses into real-time data for interactive projects

This tutorial covers programming the pose recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 uses Arduino to learn and recognize human poses, then streams each pose’s ID, name, size, and center coordinates via serial, like turning your camera into a real‑time posture sensor.

This tutorial covers programming the license plate recognitionfunction with Arduino and HUSKYLENS 2.License plate recognition reads plate count and nearest ID; it’s like a smart camera that labels every plate in view and streams ID, text and position via UART for learned IDs

This tutorial covers programming the optical character recognition function with Arduino and HUSKYLENS 2.OCR on HUSKYLENS 2 reads centered text blocks, like a spotlight, and Arduino code prints each block’s ID, content, position and size via serial

This tutorial covers programming the line tracking function with Arduino and HUSKYLENS 2.HUSKYLENS 2 line tracking logs path X/Y, angle, length and upcoming branch data via Arduino Serial, like a smart map reader.

This tutorial covers programming the face emotion recognition function with Arduino and HUSKYLENS 2.Face emotion recognition on HUSKYLENS 2 counts seven preset moods, like a smart mirror reading faces in real time, then prints each label and total via Arduino serial output.

This tutorial covers programming the tag recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 on Arduino detects AprilTags, then counts tags, reads ID, content and center coordinates, and prints them via serial, like a barcode scanner for vision projects

This tutorial covers programming the QR code recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 on Arduino reads QR codes like scanning labels, reporting count, ID, content and center coordinates, and can filter and print data for a specific learned ID via Serial Monitor.

This tutorial covers programming the QR code recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 barcode mode detects, counts, and serial-prints each tag’s ID, content, size, and center coordinates, like a smart camera that also logs detailed barcode metadata for Arduino projects.

This document is a MindPlus graphical programming tutorial for Arduino main controller and HUSKYLENS 2, introducing hardware and software platforms, wiring diagrams and relevant libraries.

This tutorial covers graphical programming of face recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 detects faces, counts them, and streams ID, name, position, size via MindPlus blocks, like tagging people in a smart camera view

This tutorial covers graphical programming of object recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 object recognition blocks let MindPlus read IDs, count targets, and get each object’s position and size, like labeling items in a live video feed for easy coding control

This tutorial covers graphical programming of object tracking function with Arduino and HUSKYLENS 2.HUSKYLENS 2 object tracking outputs ID, name, X Y position and box size via serial, like giving each target a labeled bounding box; Mind+ blocks read one frame of data and check if a trackable target exists.

This tutorial covers graphical programming of color recognition function with Arduino and HUSKYLENS 2.HUSKYLENS 2 color recognition blocks in MindPlus detect, label and track learned or unlearned color blocks, like a smart camera that counts colored stickers and reports their IDs, positions, sizes and totals via Arduino serial data.

This tutorial covers graphical programming of the self-learning classification function with Arduino and HUSKYLENS 2.HUSKYLENS 2 self-learning classifier lets you train custom objects, then recognize them and read their ID and name via Mind+ blocks, like tagging items so the camera remembers and reports each label accurately.

Instance segmentation on HUSKYLENS 2 lets it detect and outline multiple objects in real time and stream structured data like IDs and positions to code. It’s like giving the camera a smart highlighter that tracks every object for kids’ AI robot projects.

HUSKYLENS 2 hand recognition reads, counts and labels gestures via Mind+ serial data, like a smart camera tagging each hand pose in view. It detects any framed gesture, assigns learned IDs or 0, and lets users query specific IDs for presence, count, name and X/Y/size of each target gesture.

How to use HUSKYLENS 2 pose recognition in Mind+: upload the sample program, enter pose learning on the touchscreen, record different body poses and let the camera assign IDs, then read serial pose data with blocks to trigger games, robots or counters; it’s like turning your camera into a live gesture radar for STEM classrooms and maker spaces.

HUSKYLENS 2 license recognition reads, counts and filters plates, like a smart camera that tags each plate with ID and position data. It detects plates in frame, outputs ID 0 for unlearned ones and the learned ID for trained plates, then sends ID, name, content, size and center coordinates via serial. Blocks let users check if any plate exists, get the nearest plate, count all plates, or query only plates with a specific ID and index when multiple identical IDs appear.

HUSKYLENS 2 OCR blocks let Mind+ users detect, count and read on screen text like labeling moving name tags, it’s like a smart highlighter that only reads the word closest to the crosshair and streams its ID, content and position via serial data for kid friendly AI vision projects

HUSKYLENS 2 line tracking reads route length, angle and XY data, like a smart ruler following a drawn road, and reports branches, nearest line features and total line count for code control

HUSKYLENS 2 face emotion recognition reads seven preset emotions, like a smart mirror counting moods in real time, and Mind+ blocks let users detect, locate, count and filter expressions by ID for STEM projects

HUSKYLENS 2 tag mode reads AprilTag IDs, content and position, then streams data via serial. It’s like a smart barcode scanner that also counts how many tags are in view, distinguishes learned (ID>0) and unlearned (ID 0) tags, and lets Mind+ blocks check, count and query tags by ID or by the one nearest the crosshair.

HUSKYLENS 2 QR blocks let Mind+ read QR IDs, text and position, like giving Arduino a visual barcode scanner. It’s like a smart camera that locks onto the nearest code, counts all visible codes, filters by specific ID, and streams each tag’s decoded content and coordinates via serial.

HUSKYLENS 2 barcode blocks detect, count and output ID, content and position data, like a smart camera reading labels on packages. It recognizes the barcode nearest the crosshair, distinguishes learned IDs from ID 0 unlearned codes, counts all barcodes in view and lets users query specific IDs via Mind+ serial output.

MakeCode with micro:bit and HUSKYLENS 2 is like a visual LEGO lab: assemble boards, cables, and firmware, then add the huskylensv2 extension in MakeCode to start kid‑friendly AI vision projects.

HuskyLens 2 face recognition lets micro:bit read IDs, names, counts and feature coordinates; it’s like giving your robot eyes that also report precise positions for each learned or detected face.

Object recognition on HuskyLens 2 lets micro:bit read IDs, names, positions and counts for any detected or learned object, like a smart camera ruler. It’s like giving your robot eyes that also report coordinates and statistics.

HuskyLens 2 object tracking lets you learn a target, draw a box, then continuously detect and follow it, streaming ID, name, center X/Y, width and height over serial to micro:bit. It’s like giving your camera a tag that it keeps locked on wherever it moves.

Color recognition on HuskyLens 2 tracks color blocks and streams IDs, names, XY, width and height to micro:bit via serial. It’s like a smart color counter that also measures size and position so kids can build games, sorting projects and interactive displays.

HuskyLens 2 object classification lets micro:bit projects detect up to 1000 categories and output each object’s name via serial, like a smart labeler for everything in view. It’s like giving your camera flashcards so it can instantly tell you what it sees.

Self-learning classification lets HuskyLens 2 learn custom objects and report ID, name and status via micro:bit, like teaching a camera flashcards. It's like training a pet to recognize different toys by name.

Instance segmentation on HuskyLens 2 with micro:bit lets you detect multiple objects, read their ID, label, position, size and counts via serial, like turning the camera into a live object spreadsheet for kids’ AI projects.

HuskyLens 2 hand recognition lets micro:bit read gesture counts, IDs and positions; it’s like turning your hand into a programmable remote. The system outputs center-closest gesture, nth gesture and rich keypoint data for wrist and fingers, and blocks help check presence, total detected, total learned and per-ID statistics.

HuskyLens 2 license plate recognition reads plate ID, text and position and streams them to micro:bit via blocks. It’s like a smart camera counting and labeling every car plate in view, including closest, nth or same‑ID plates.

HuskyLens 2 pose recognition lets micro:bit read how many poses are on screen and detailed data for each pose. It’s like turning every person into a labeled stick figure with coordinates. You can get total detected and learned poses, the center-closest pose, or the nth pose with a given ID, including box size and joint positions such as eyes, shoulders, elbows, wrists, hips, knees and ankles.

Optical character recognition on HuskyLens 2 detects on‑screen text blocks and streams their ID, content and position data via micro:bit, like giving each word a GPS tag. It lets users count blocks, check if specific IDs or license plates appear, and read size and coordinates of the closest or selected target for kid‑friendly AI vision projects.

HuskyLens 2 line tracking lets micro:bit read line length, angle, X/Y vector and intersection branches; it’s like giving your robot road markings it can measure and follow precisely.

HuskyLens 2 reads seven preset emotions and streams IDs and positions to micro:bit, like a mood sensor for faces, enabling counts, closest emotion selection, and detailed data per target.

Tag recognition on HuskyLens 2 detects AprilTag IDs, content and position and streams them via micro:bit, it’s like giving the camera labeled markers it can count, sort and track in real time

HuskyLens 2 QR recognition streams ID, content and position data to micro:bit; it’s like giving your board eyes to count, track and filter multiple QR codes by index or ID in real time.

Barcode recognition on HuskyLens 2 lets micro:bit read, count and locate barcodes on screen, like giving your robot eyes for labels, exposing ID, text, position, size and confidence for each detected or learned code.

Connect micro:bit and HUSKYLENS 2, then open Mind+, select micro:bit, download and load the HUSKYLENS 2 extension to start visual projects using graphical programming.

HUSKYLENS 2 face recognition lets you count, track and identify faces with IDs, names and precise coordinates, like a smart people counter for STEM projects. It's like a digital seating chart that knows who sits where, logging total faces, learned faces and per‑ID details in real time.

HUSKYLENS 2 object recognition reads IDs, names and positions for up to 80 categories, like giving each item a digital name tag in view, and lets you count total objects, check learned vs unlearned ones, and query data for any specified ID in the frame.

HUSKYLENS 2 object tracking lets you select a target with a bounding box, then upload a Mind+ program to read ID, name, center X/Y, width and height in real time, like giving each object a labeled GPS dot on screen.

HUSKYLENS 2 color recognition tracks learned or raw color blocks, like a smart camera counting and locating colored stickers on a board, and returns IDs, names, coordinates, size, totals, and per‑ID statistics for any specified block in view.

HUSKYLENS 2 self-learning classifier lets you scan, label, and re-detect objects with IDs and names, like teaching a camera flashcards. After uploading the example program and training an object, the module frames it on screen, outputs name, ID, and confidence, and uses blocks to check if a specific object is seen and to read its stored data, using fixed model IDs independent of learning order.

Instance segmentation on HUSKYLENS 2 recognizes and outlines up to 80 object categories, then lets your code read each instance’s ID, name, center coordinates, width, height and counts. It’s like giving every object on screen its own labeled bounding box so you can track totals, learned IDs, and specific targets in real time.

HUSKYLENS 2 hand recognition reads, counts and tracks learned or unlearned gestures by ID and coordinates, like a smart camera tagging every hand pose in view.

HUSKYLENS 2 pose recognition detects human bodies, assigns IDs, and returns coordinates and size for each pose; it’s like a smart camera that tags every joint on a person and lets your program query total detected bodies, learned pose count, whether a specific ID is in view, and detailed data for the closest or N‑th pose by index.

HUSKYLENS 2 license plate recognition reads plate text, ID, size, center coordinates and counts learned or unlearned plates in view, like a smart camera tracking multiple tags in real time.

HUSKYLENS 2 Optical Char Recognition detects all text regions but only decodes the block under the crosshair, returning ID, name, content, position and size; it can also count total blocks, query by ID, and check whether specific learned text appears on screen, like a smart camera that tags and tracks printed words.

HUSKYLENS 2 line tracking measures line length, angle, X/Y components and branches. It’s like a smart ruler that follows drawn paths and reports geometry data for each detected line or branch.

HUSKYLENS 2 face emotion recognition reads seven preset emotions and outputs IDs, names, counts and box coordinates in each frame, like a smart camera that tags every mood it sees.

HUSKYLENS 2 reads AprilTag IDs, position and size to drive robots; it’s like giving your camera barcodes that encode commands and coordinates.

HuskyLens 2 QR blocks detect, count and read QR tags; it’s like giving your camera a spreadsheet that logs each code’s ID, content, position and size in real time

HUSKYLENS 2 barcode blocks let you detect, count and query barcodes in view, returning ID, learned status, position and content. It’s like giving your robot eyes to read product labels. You can check if any barcode exists, get the nearest one, total detected, total learned, and filter or iterate by a specific ID, even when several barcodes share that same ID.

Install Arduino IDE, add the UNIHIKER K10 SDK URL in Preferences, then install the K10 board and HUSKYLENS2 library; it’s like wiring and configuring a smart AI lab on a single teaching-friendly board.

HuskyLens 2 face recognition lets UNIHIKER K10 count faces, track center and first IDs, and read detailed keypoints and per‑ID stats; it’s like giving your microcontroller a smart camera that reports who is where in real time.

HuskyLens 2 object recognition lets UNIHIKER K10 display total detected targets, center object name, first object ID, and, for a chosen ID, its count and coordinates in the image; it’s like giving your microcontroller a live, labeled map of everything the camera sees.

HUSKYLENS 2 tracks a boxed object and streams ID, name, x y center, width and height to the UNIHIKER K10 screen, like a live HUD overlay for object motion.

Use UNIHIKER K10 with Huskylens 2 to detect color blocks, display center ID, total count, first ID, and query specific learned colors by ID, name and coordinates, like tagging colored stickers in a camera view.

Self-learning classifier lets Huskylens 2 remember objects and then display their ID and name on the UNIHIKER K10 screen, like a smart camera that labels what it sees.

HUSKYLENS 2 instance segmentation lets UNIHIKER K10 display object count, center ID, coordinates and per‑ID stats, like a smart camera tagging each item on screen.

HUSKYLENS 2 hand recognition reads gesture count, IDs and detailed keypoints to drive UNIHIKER K10 display; it’s like a smart camera tracking every finger joint in real time.

HuskyLens 2 pose recognition tracks humans like a smart motion camera, using Arduino code to count poses, read IDs, and output detailed keypoint coordinates to the UNIHIKER K10 screen for real‑time interactive projects

License plate recognition on HUSKYLENS 2 reads plate IDs, text, size and center coordinates and shows them on the UNIHIKER K10 display, like a smart camera overlaying live labels on each car plate so you can debug results in real time

This HuskyLens 2 OCR demo counts detected text blocks, then shows the center block’s ID, content, coordinates, and size on a UNIHIKER K10 screen in real time, like a smart viewfinder for text.

HUSKYLENS 2 tracks lines like a GPS, measuring route length, angle, X/Y offsets and junction branch count, then UNIHIKER K10 displays these values in real time.

Face emotion recognition on UNIHIKER K10 uses HUSKYLENS 2 to detect seven preset emotions, count them in the camera feed, and display IDs, names, totals and coordinates on the screen, like a real-time mood dashboard.

HUSKYLENS 2 reads AprilTag IDs, content and position, then UNIHIKER K10 displays center tag info, total tags, and per‑ID details like count, text and coordinates, like a live tag scanner dashboard

HUSKYLENS 2 reads QR codes like scanning nametags, returning ID, content, position and size so Arduino can count codes, check specific IDs and display details on the UNIHIKER K10 screen.

HuskyLens 2 barcode mode reads IDs, content and positions, then UNIHIKER K10 shows counts and details on screen. It’s like a smart camera that scans product barcodes and instantly lists how many were seen and where they are in the image.

MindPlus with UNIHIKER K10 and HUSKYLENS 2 lets students quickly build AI and IoT projects; it’s like a plug-and-play smart lab on your desk.

HuskyLens 2 face blocks detect, count and label faces; it’s like giving each face a numbered tag so your project can track IDs, positions and learned names in real time.

HuskyLens 2 object recognition blocks let Mind+ users count, identify, and track up to 80 learned objects on screen, including ID, name, position, size, and presence. It’s like giving your project smart eyes that report what they see in real time.

HUSKYLENS 2 object tracking blocks output each detected target’s ID, name, center XY, width and height in real time, like giving every object a digital label on screen. It can check if a trackable target exists in the current frame and fetch data for the object closest to the crosshair.

HUSKYLENS 2 color recognition reads learned and unknown color blocks, returning IDs, count, and position data. It’s like a smart camera that tags colored objects so Mind+ projects can detect, count, and track specific colors in the frame.

HUSKYLENS 2 object classification lets the camera learn items, then on each scan detect them, judge if a specific object is present, and read its pre-assigned ID, custom name, and confidence, like a smart labeler for real-world objects.

HuskyLens 2 instance segmentation tracks each object like labeled boxes, reporting class, ID, position, size, counts, and nearest or specific learned instances for UNIHIKER K10-MindPlus projects.

HuskyLens 2 hand recognition detect, count, and label hand poses, then expose rich keypoint data for wrists and fingers. It’s like giving the camera a map of every hand in view, with IDs for learned gestures and 0 for unknown ones.

HuskyLens 2 pose blocks detect bodies, assign IDs, and output rich keypoint coordinates for eyes, nose, shoulders, elbows, hips, knees, and ankles. It’s like a visual ruler that tracks learned and unlearned poses by ID and index.

HUSKYLENS 2 license plate recognition blocks let Mind+ users detect plates, count learned and unlearned IDs, and read position and content data, like a smart camera tagging every car in view.

HuskyLens 2 OCR detects on‑screen text blocks, returns ID, content and position, and offers blocks to count, filter and query learned or specific IDs, like tagging each word with coordinates.

HUSKYLENS 2 line tracking reads line length, angle, X/Y and branch count; it’s like a smart map that reports every turn to your robot.

HUSKYLENS 2 detects seven preset facial emotions and returns IDs, names, confidence, counts, and coordinates in real time, like a mood-aware camera viewfinder. It’s like giving your project eyes that understand basic feelings.

HuskyLens 2 gives UNIHIKER K10 smart eyes, detecting AprilTags in Mind+ and reporting each tag’s ID, content, position, size, totals, and the tag nearest the crosshair or matching a selected ID in real time.

HUSKYLENS 2 QR blocks let Mind+ users detect, count and filter QR codes by ID, then read name, content, size and center coordinates in each frame; it’s like giving your robot eyes plus a label reader so it can react to specific tags.

HuskyLens 2 barcode blocks let Mind+ read, count and filter barcodes by ID, content and position; it’s like giving your robot eyes to sort printed codes and trigger different actions in UNIHIKER projects.

Mind+ with UNIHIKER M10 and HUSKYLENS 2 lets students quickly build AI vision projects by wiring, powering and loading libraries in Python modes. It’s like assembling smart LEGO that can see and think. Connect PC–UNIHIKER–HUSKYLENS via Type‑C and PH2.0 cable, then in Mind+ 2.0 or 1.8 switch to Python (or Python Block) mode, open Extension, install and load the UNIHIKER M10 controller library and the HUSKYLENS 2 AI Camera library, update HUSKYLENS firmware to the latest version, and finally enter the code editor or any Python IDE to start coding visual recognition.

Face recognition on HuskyLens 2 lets you count faces, read IDs, and track key feature coordinates in real time, like a smart attendance camera. It’s like a visual spreadsheet that logs who is in frame and where their eyes, mouth, and nose are positioned.

HuskyLens 2 object recognition reads counts, IDs and positions, like a smart camera HUD overlaying stats on each object in view. It recognizes up to 80 preset categories, then via Python and Mind+ you can display total objects, learned ID range, center object ID and first object ID in real time. For a specific ID, the example shows how to check if it appears, read its name, count all similar targets and get the first one’s X/Y center plus bounding box width and height, turning raw vision into structured data for interactive STEM projects.

HUSKYLENS 2 object tracking returns ID, name, center XY, width and height in real time. It’s like a smart tape measure that follows one chosen item in view. Using the Python example, you initialize the board, switch to ALGORITHM_OBJECT_TRACKING, then loop to read cached center results and display object ID, label, coordinates and size on the Unihiker GUI after framing the target in Mind+.

Color recognition on HUSKYLENS 2 lets you count, label and locate colored blocks in view. It’s like giving the camera colored stickers and asking it how many it sees and where they are. The examples show how to read total and learned blocks, center or first IDs, and per‑color counts, names and coordinates via Python APIs.

Object classification on HUSKYLENS 2 lets you recognize learned objects and directly read their ID and name via code. It’s like a smart labeler that tags what the camera sees. Using the I2C API, you initialize the board, switch to the object classification algorithm, then loop to fetch results and display the current object’s classID and name on the GUI while confidence is only visible on-screen, not accessible in code.

Self-learning classifier lets HUSKYLENS 2 learn objects and later auto recognize them by ID and name in real time, like a camera that remembers faces. It’s like giving the sensor flashcards it can read back on screen.

Instance segmentation on HuskyLens 2 lets you detect object classes, draw their outlines, and read per‑instance data like ID, name, center X/Y, width, and height in real time. It’s like giving the camera sticky notes that label each object separately. Sample Python code shows how to count all instances, find the one closest to the image center, and display its coordinates, and another example focuses on a specific learned ID, returning how many similar instances are in view and the exact position of a chosen one.

Hand gesture recognition on HuskyLens 2 reads gesture IDs, counts, and coordinates in real time. It’s like a smart camera that tracks each finger joint as you move your hand. Using Python APIs, you can query center gestures, wrist and fingertip keypoints, and filter by learned ID for interactive projects

Pose recognition on HuskyLens 2 reads learned and unlearned human poses, counts bodies, and returns pose IDs plus keypoint coordinates. It’s like giving the camera a digital skeleton map so projects can track noses, shoulders, knees, and named poses in real time.

HuskyLens 2 license plate recognition reads plate IDs, text, size and center coordinates, like a smart camera counting cars at a gate, and with UNIHIKER it displays total plates, learned IDs, center plate info, and data for specific ID plates including count, content and position.

Optical character recognition on HUSKYLENS 2 lets you detect, frame, and read a single crosshair‑targeted text block in real time. It’s like a smart magnifying glass that only reads the word you point at. Using the OCR algorithm and the sample Python script, the camera counts all visible text blocks, then reports the nearest block’s ID, name, content, center coordinates, width, and height to the M10 display. Unlearned text blocks output ID 0, while learned blocks return the same ID shown on the HUSKYLENS screen, and only the crosshair text content is recognized and rendered at the top left of the frame.

HUSKYLENS 2 line tracking reads line angle, length, and XY components in real time, like a GPS for drawn paths. It’s like watching a map app trace every turn on a road. Using the Python example with UNIHIKER, the camera detects intersections, counts branches counterclockwise, and prints each branch’s coordinates so robots can follow or choose routes precisely.

Face emotion recognition on HUSKYLENS 2 lets you instantly detect seven preset emotions and stream their IDs and counts to UNIHIKER, like a smart mirror that reads mood in real time

HuskyLens 2 tag recognition reads AprilTag IDs, content and positions. It’s like giving your robot a barcode scanner for visual tags. Code examples show how to switch the tag algorithm, count all tags, list learned IDs, get the center tag ID, and query specific tags by ID, content and XY center coordinates.

HuskyLens 2 QR example shows how to read QR count, learned IDs and per‑code content, size and center coordinates via Python on UNIHIKER. It’s like a smart camera that tags each QR in view, letting you query specific IDs, count duplicates and track their positions in real time.

Barcode recognition reads count, ID, content, and position, like a smart scanner showing what and where each code is; HuskyLens 2 uses Python APIs to list all barcodes in view or query specific IDs, returning center coordinates, width, height, and text for multiple codes

Custom-trained model on HUSKYLENS 2 lets UNIHIKER M10 read object IDs, names and coordinates in real time; it’s like giving your camera a custom label-reading brain. Users deploy a Product Recognition model, press A to learn objects and assign IDs, then use Python APIs such as getCachedResultNum, getCachedCenterResult and getCachedIndexResultByID to count total and learned targets, find the center object and query specific IDs, including multiple instances with the same label.

Mind+ with UNIHIKER M10 and HUSKYLENS 2 lets students quickly wire devices, install controller libraries, and start Python or block-based AI vision projects; it’s like plugging smart bricks together to build interactive lessons

Face recognition blocks let HuskyLens 2 detect, count, and label faces in real time, then stream rich coordinate data to Mind+. It’s like giving your camera a smart attendance sheet that tracks who is in frame and where every key facial feature is positioned.

HuskyLens 2 object recognition blocks let Mind+ projects detect, count and locate learned objects in up to 80 categories in real time. It’s like giving your camera a label-reading assistant that reports IDs, names, positions and sizes so students can build interactive, vision-driven STEM activities with minimal coding.

HUSKYLENS 2 object tracking blocks capture an object’s ID, name, center XY, width and height in real time; it’s like a smart tape measure that follows one chosen item. In Mind+ you run the sample, frame a target, then use blocks to check if a trackable object exists and read data for the one nearest the crosshair.

HUSKYLENS 2 color recognition blocks let Mind+ users detect, count and locate learned and unknown color blocks in real time. It’s like a smart highlighter that boxes each color, reports IDs, positions and sizes, and returns stats for specific colors or the block nearest the crosshair.

HUSKYLENS 2 object classification lets Mind+ projects detect learned items and read their fixed IDs and names in real time. It’s like giving your camera flashcards so it can say which card it sees. After training, run the sample code, scan the scene once to get recognition results, check whether a specific object is present, and retrieve its pre-assigned ID and label while confidence remains only on-screen.

HUSKYLENS 2 self-learning classifier lets you train it once and auto-recognize objects later with ID, name and confidence; it’s like giving the camera flashcards so it remembers each item. Mind+ blocks fetch one result, check if a learned object appears, and read its ID/name in order.

Instance segmentation blocks let HuskyLens 2 learn objects, then count, locate and identify each instance by ID, name and bounding box data. It’s like giving every object its own label so robots can track them. Users can check if a target appears, get the nearest instance, total instance count, learned class count and per‑ID statistics for precise vision projects.

HuskyLens 2 gesture blocks detect hands, count gestures, and read IDs, positions and keypoints. It’s like a camera that tags each finger joint in real time so kids can map motions to code, check if specific gestures appear, and retrieve learned or unlearned gesture data by ID.

Pose recognition blocks let HuskyLens 2 detect, learn and track human poses in real time. It’s like a smart camera that tags each body and joint with coordinates so code can react. Users can count bodies, check if a specific pose ID appears, and read detailed keypoints for faces and limbs.

HuskyLens 2 license plate blocks let Mind+ projects detect, count and track plates by ID, position and content. It’s like a smart camera that tags each plate with an ID and coordinates so UNIHIKER M10 apps can read nearest, specific or learned plates.

HUSKYLENS 2 optical char recognition finds, frames and reads text blocks in view, then outputs ID, name, content and position data. It’s like a smart magnifier that labels every word you point at. Mind+ example code counts all detected text areas, focuses on the block nearest the crosshair, and shows its text at the top left. Blocks let users check if any text exists, get total text count, fetch data by index or ID, count blocks with the same ID, and query how many texts have been learned, supporting classroom projects and precise STEM experiments.

Line tracking blocks let HUSKYLENS 2 detect line paths, measure length, angle and XY components, and count branches at intersections. It’s like a map reader that outputs each road’s direction. UNIHIKER M10 displays whether lines exist, the nearest line’s data, total line count and selected branch info.

Face emotion recognition on HUSKYLENS 2 lets Mind+ projects detect and count seven preset emotions and read their IDs, names and positions in real time. It’s like a smart camera that tags each face with a mood label. Blocks cover checking if any target emotion appears, counting all expressions in the frame, returning data for the one closest to the crosshair, and querying total or per‑ID counts and coordinates, even when multiple identical emotions are present.

HuskyLens 2 AprilTag blocks let Mind+ programs detect tags, count them, and read ID, content and position in real time. It’s like giving your robot QR-code vision so it can know which tag it sees, where it is on screen, and whether specific learned IDs appear or how many duplicates exist.

HuskyLens 2 QR blocks let Mind+ read, count and filter QR codes in view, like sorting labeled boxes on a shelf; you can detect any tag, get total and learned counts, then query closest or specific IDs for position, size and decoded content.

HuskyLens 2 barcode blocks let Mind+ users read how many barcodes are in view, check if any exist, and get each code’s ID, content, size and center coordinates. It’s like giving the camera a shopping scanner brain so kids can track specific IDs, count repeated tags, and pull detailed data for coding projects.

HUSKYLENS 2 lets you deploy custom object detection models, then programmatically read each target’s ID, name, position and size, count learned or visible objects, and query specific IDs, like a smart visual database in your project.

Download Huskylens2 firmware img, install Zadig driver and K230 burning tool, flash and reboot, then update Huskylens libraries in Mind+, MakeCode, Arduino, Raspberry Pi

Xiaozhi AI turns HUSKYLENS 2 into a voice‑controlled vision hub, like giving your camera a smart assistant that can switch models, learn objects, describe scenes, run multiple recognizers in parallel, manage parameters and device settings, all triggered hands‑free with “Hi Husky” and a one‑time online binding

This guide instructs users on deploying custom-trained visual recognition models in HUSKYLENS 2, covering both code-free methods using Mind+ AI tools and Python-based YOLO model training techniques, ensuring an updated firmware for successful deployment.

HUSKYLENS 2 MCP lets Gemini in Cherry Studio remotely manage vision apps, read recognition, schedule tasks and trigger photos, like turning the camera into a smart assistant

Tap Camera, switch modes, press Button‑A to shoot photos or videos; double‑press to screenshot, like using a phone, with files auto‑saved in photo or screenshot folders

HUSKYLENS 2 streams video via WebRTC or RTSP, like turning its AI camera into a live USB or WiFi webcam, after installing the RNDIS driver, enabling Video Streaming, then viewing the IP or RTSP URL in a browser or VLC.