O HUSKYLENS é um sensor de visão compacto com IA de ponta. Alimentado por um chip AI Kendryte K210 e equipado com um pequeno ecrã IPS de 2,0 polegadas, o dispositivo suporta funções integradas de reconhecimento e rastreamento, como reconhecimento facial, reconhecimento e rastreamento de objetos, deteção de cor e linha, reconhecimento de etiquetas e classificação de objetos.
Novos objetos ou padrões podem ser facilmente aprendidos e a informação sobre os objetos detetados pode ser transferida via interfaces UART ou I2C para microcontroladores comuns como Arduino, ESP32 ou Raspberry Pi.
Neste tutorial, vai aprender como ligar o HUSKYLENS a um Arduino UNO e obter os resultados de deteção para rastreamento de linha e classificação de objetos.
Peças Necessárias
Pode adquirir o HUSKYLENS na DFRobot ou na Amazon através dos links abaixo. Além disso, vai precisar de um microcontrolador. Eu estou a usar um Arduino UNO, mas outras placas Arduino também funcionam bem. O único requisito é suporte para uma interface I2C (ou UART).
HUSKYLENS
Arduino Uno
Cabo USB para Arduino UNO
Conjunto de fios Dupont
Breadboard
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 do HUSKYLENS
No núcleo do módulo HUSKYLENS está um sistema em chip Kendryte K210, que integra um CPU RISC-V dual-core de 64 bits com aceleradores de hardware dedicados para redes neurais convolucionais e processamento de sinais.
Esta arquitetura permite que o dispositivo execute múltiplos algoritmos de visão clássicos e baseados em deep learning inteiramente na borda, sem depender de um host externo para inferência. O K210 inclui vários megabytes de SRAM on-chip usados como buffers de frame e armazenamento intermediário de mapas de características, permitindo processamento em tempo real e mantendo a largura de banda e latência da memória externa baixas.
Modelos de IA
O firmware que corre no K210 expõe sete funções principais de visão computacional: reconhecimento facial, rastreamento de objetos, reconhecimento de objetos, rastreamento de linha, reconhecimento de cor, reconhecimento de etiquetas e classificação de objetos.
Estas funções partilham um pipeline comum de inferência, mas diferem nos estágios de pré-processamento, topologia do modelo e pós-processamento. O resultado é um conjunto de modelos otimizados e pré-ajustados que podem ser alternados em tempo real via interface de utilizador integrada ou comandos seriais, sem necessidade de o utilizador gerir ou implementar modelos manualmente.
Sensor de Imagem e Subsistema de Ecrã
O HUSKYLENS usa um sensor de imagem digital ligado ao K210 através de uma interface de câmara estilo DVP. Dependendo do lote de produção, o módulo de câmara baseia-se num sensor OV2640 ou GC0328, ambos fornecendo saída RGB com obturador rolante adequada para tarefas de visão embutida. A variante OV2640 oferece resolução nativa até 2 megapixels, enquanto o GC0328 é uma opção de menor resolução e custo otimizado.
O módulo integra um LCD IPS de 2,0 polegadas com resolução de 320 × 240 pixels. Este ecrã está fortemente ligado ao pipeline de visão e é usado para mostrar o feed de câmara ao vivo, sobrepor caixas delimitadoras de deteção, IDs e indicadores de confiança, bem como para mostrar nomes de funções e menus de configuração.
A interface do ecrã é controlada diretamente pelo K210, permitindo que o dispositivo apresente uma explicação visual imediata do que os algoritmos de visão estão a detetar, sem qualquer interação com o host.
Alimentação e Características Elétricas
Eletricamente, o HUSKYLENS foi projetado para operar com tensões típicas de 3,3 volts e 5 volts em sistemas embutidos. A faixa de tensão especificada é de 3,3 V a 5,0 V, e tanto o conector Gravity de 4 pinos como o conector micro-USB podem ser usados como entradas de alimentação. Um circuito interno de seleção automática da fonte de energia dá prioridade à entrada USB quando ambas estão conectadas.
Em operação típica de reconhecimento facial com o retroiluminado do LCD ajustado para 80% de brilho e a luz de preenchimento desativada, o módulo consome aproximadamente 320 mA a 3,3 V ou 230 mA a 5,0 V. Este consumo é impulsionado pela operação contínua do acelerador de rede neural do K210 e pelo ecrã ativo.
Interfaces de Comunicação
O HUSKYLENS expõe duas interfaces de comunicação para integração com microcontroladores: UART e I2C. Estas interfaces são encaminhadas para o conector padrão DFRobot Gravity de 4 pinos.
No modo UART, os quatro pinos correspondem a TX, RX, terra e VCC, enquanto no modo I2C correspondem a SDA, SCL, terra e VCC. As duas tabelas seguintes mostram a configuração dos pinos para os modos UART e I2C:
| Num | Etiqueta | Função do Pino | Descrição |
|---|---|---|---|
| 1 | T | TX | Pino TX do HuskyLens |
| 2 | R | RX | Pino RX do HuskyLens |
| 3 | – | GND | Negativo (0V) |
| 4 | + | VCC | Positivo (3,3~5,0V) |
| Num | Etiqueta | Função do Pino | Descrição |
|---|---|---|---|
| 1 | T | SDA | Linha de dados serial |
| 2 | R | SCL | Linha de relógio serial |
| 3 | – | GND | Negativo (0V) |
| 4 | + | VCC | Positivo (3,3~5,0V) |
Ambos os modos de interface suportam o protocolo completo de comandos para configurar algoritmos, disparar operações de aprendizagem e ler resultados de deteção como coordenadas da caixa delimitadora e IDs.
Interface de Utilizador e Controles Integrados
O módulo inclui uma interface local implementada com dois botões físicos e o ecrã integrado. O botão “function” atua principalmente como seletor de modo e controlo de configuração. Quando o utilizador roda ou “gira” este botão para a esquerda ou direita, o firmware percorre as funções de visão disponíveis, atualizando o ecrã para indicar o algoritmo atual.
Uma pressão longa no botão de função abre um menu de parâmetros de segundo nível para a função ativa. Ali pode ajustar parâmetros como sensibilidade, limiares de reconhecimento, definições do LED e opções de aprendizagem multi-objeto sem necessidade de controlador externo.
O botão “learning” está fortemente ligado às rotinas internas de treino de cada algoritmo. Uma pressão curta instrui o dispositivo a aprender o objeto ou cor atualmente centrado sob o mira no ecrã.
Uma pressão longa ativa aprendizagem contínua ao longo de múltiplos frames. Isto permite ao sistema construir um modelo mais robusto perante variações de distância, ângulo ou iluminação. Quando um alvo já aprendido está presente, outra pressão curta pode ser usada para apagar os dados do modelo associado.
Ligando o HUSKYLENS ao Arduino UNO
Pode comunicar com o HUSKYLENS usando o protocolo UART ou I2C. O I2C é mais rápido e permite ligar múltiplos dispositivos ao mesmo barramento. Portanto, vamos usar I2C.
O conector Gravity do HUSKYLENS expõe a interface I2C (SDA(T), SCL(R)) e os pinos de alimentação (VCC(+), GND(-)). A foto abaixo mostra como ligar o HUSKYLENS a um Arduino UNO:
O fio vermelho deve ser ligado ao pino 5V do Arduino, e o fio preto ao GND. O fio verde é o SDA e deve ser ligado ao A4. O fio azul é o SCL e deve ser ligado ao A5 do Arduino.
Note que tem de definir o protocolo de comunicação para I2C nas definições do HUSKYLENS. Vá a “General Settings”, depois “Protocol Type”, selecione “I2C” e guarde as definições conforme mostrado abaixo:
Se precisar de instruções mais detalhadas, leia o manual do HUSKYLENS Wiki.
Instalar a biblioteca HUSKYLENS
Para conseguir obter resultados de deteção do HUSKYLENS, precisamos de instalar a HUSKYLENS Library. Clique em link para descarregar a biblioteca como um ficheiro “HUSKYLENSArduino-master.zip” para o seu computador. Depois descompacte o ficheiro ZIP para extrair o seu conteúdo. Deve ver os seguintes ficheiros na pasta descompactada:
De seguida, precisamos de copiar a pasta “HUSKYLENS” para a pasta “libraries” do Arduino IDE. No Windows, a pasta “libraries” está normalmente localizada em:
C:\Users\<username>\OneDrive\Documents\Arduino\libraries
Como esta pasta já contém bibliotecas instaladas, recomendo que a renomeie temporariamente, por exemplo para “_libraries”, e crie uma nova pasta chamada “libraries”. Assim evita conflitos com as bibliotecas já instaladas e não as perde. Mais tarde pode reverter facilmente esta alteração. A imagem abaixo mostra como deve ficar a sua pasta “Arduino” com as bibliotecas:
Agora podemos copiar a pasta “HUSKYLENS” para a nova pasta “libraries” conforme mostrado abaixo:
A pasta “libraries” pode conter outras bibliotecas, mas para este projeto não precisamos de mais.
Exemplo de Código: Rastreamento de Linha
No primeiro exemplo de código vamos experimentar o algoritmo Line Tracking. Tem a vantagem de não ser necessário treinar o HUSKYLENS para detetar linhas, pois esta função funciona sem aprendizagem.
O código seguinte liga o Arduino ao HUSKYLENS via I2C e imprime os pontos inicial e final dos segmentos de linha detetados. Dê uma vista rápida ao código e depois discutimos os detalhes.
#include "HUSKYLENS.h"
HUSKYLENS huskylens;
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_LINE_TRACKING);
}
void loop() {
static char text[100];
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
sprintf(text, "x=%d, y=%d, w=%d, h=%d",
r.xOrigin, r.yOrigin, r.xTarget, r.yTarget);
Serial.println(text);
delay(1000);
}
}
Importações
Começamos por incluir a biblioteca HUSKYLENS com a diretiva #include "HUSKYLENS.h". Esta importação disponibiliza todas as definições de classes, constantes e rotinas de comunicação necessárias para interagir com a câmara AI HUSKYLENS no sketch.
#include "HUSKYLENS.h"
Note que esta biblioteca atualmente (Dez 2025) não compila para o core ESP32.
Instanciação do Objeto
Após a diretiva include, criamos uma instância global da classe HUSKYLENS. O objeto chamado huskylens mantém o estado interno da interface do dispositivo e expõe a API usada ao longo do programa.
HUSKYLENS huskylens;
Setup
A função setup() inicializa a interface serial da placa, o barramento I2C e o próprio dispositivo HUSKYLENS.
O programa chama Serial.begin(115200) para configurar a saída serial a 115200 baud. De seguida, ativa a comunicação I2C através de Wire.begin(). Depois iniciamos a comunicação com o dispositivo chamando huskylens.begin(Wire). Este método configura o driver interno, define o endereço I2C e verifica se o módulo responde. Se a inicialização falhar, o programa imprime uma mensagem de erro no console serial.
Após a inicialização, selecionamos qual algoritmo de visão incorporado o dispositivo deve executar. Neste exemplo, ativamos o algoritmo de rastreamento de linha usando huskylens.writeAlgorithm(ALGORITHM_LINE_TRACKING).
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_LINE_TRACKING);
}
As constantes para outros algoritmos de IA podem ser encontradas no ficheiro header da biblioteca e são as seguintes:
ALGORITHM_FACE_RECOGNITION ALGORITHM_OBJECT_TRACKING ALGORITHM_OBJECT_RECOGNITION ALGORITHM_LINE_TRACKING ALGORITHM_COLOR_RECOGNITION ALGORITHM_TAG_RECOGNITION ALGORITHM_OBJECT_CLASSIFICATION
Loop
Na função loop() realizamos aquisição contínua de dados do sensor. Um buffer de caracteres estático chamado text é declarado para armazenar mensagens formatadas. Declarar como estático garante que a memória é alocada apenas uma vez.
O sketch envia um pedido de dados ao dispositivo HUSKYLENS chamando huskylens.request(). Este método solicita à câmara que envie o conjunto mais recente de resultados de reconhecimento ou rastreamento.
Após emitir o pedido, entramos num ciclo que continua enquanto o dispositivo reportar resultados disponíveis. Cada iteração obtém um objeto resultado usando huskylens.read(). A estrutura HUSKYLENSResult retornada contém informação geométrica sobre o elemento detetado. No modo de rastreamento de linha, estes valores correspondem à origem central (xOrigin, yOrigin) e ao ponto final ou coordenada alvo (xTarget, yTarget) do segmento de linha detetado.
void loop() {
static char text[100];
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
sprintf(text, "x=%d, y=%d, w=%d, h=%d",
r.xOrigin, r.yOrigin, r.xTarget, r.yTarget);
Serial.println(text);
delay(1000);
}
}
Formatamos estes quatro valores inteiros numa mensagem legível usando sprintf e depois imprimimos no monitor serial. No Monitor Serial deverá ver dados impressos semelhantes à imagem abaixo:
Note que a deteção de linha padrão é bastante frágil e mesmo para uma linha claramente visível não funciona de forma fiável. Pode melhorar a precisão treinando o algoritmo line tracking.
Ângulo da Linha
Muitas vezes queremos saber o ângulo da linha, por exemplo, para controlar a direção de um robô. Aqui está uma função que permite calcular esse ângulo:
float calcAngle(const HUSKYLENSResult &r) {
float dx = (float)r.xTarget - (float)r.xOrigin;
float dy = (float)r.yTarget - (float)r.yOrigin;
float angleRad = atan2(dy, dx);
float angleDeg = angleRad * 180.0 / PI + 90;
return angleDeg;
}
Se a linha estiver reta para a frente, a função retorna um ângulo de 0 graus. Se a linha apontar para a esquerda, o ângulo será negativo, caso contrário positivo. Pode obter e imprimir o ângulo com o seguinte código.
float angle = calcAngle(r); Serial.println(angle);
Na próxima secção realizamos a Classificação de Objetos.
Exemplo de Código: Classificação de Objetos
Para este exemplo, primeiro precisa de deixar o HUSKYLENS aprender dois objetos. Veja as instruções no Wiki da DFRobot para Object Classification para detalhes. Eu usei uma pequena figura do Pai Natal e um carro de brinquedo para treinar o meu HUSKYLENS:
Depois de aprender dois objetos, pode usar o código seguinte para executar a deteção de objetos e imprimir os nomes dos objetos detetados no Monitor Serial:
// (c) www.makerguides.com
#include "HUSKYLENS.h"
const char* names[] = {"", "Santa", "Car"};
HUSKYLENS huskylens;
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION);
huskylens.setCustomName(names[1], 1);
huskylens.setCustomName(names[2], 2);
}
void loop() {
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
Serial.println(names[r.ID]);
delay(1000);
}
}
Importações
Como antes, começamos por incluir a biblioteca HUSKYLENS:
#include "HUSKYLENS.h"
Constantes
De seguida definimos um array constante chamado names. Este array contém etiquetas legíveis que correspondem aos IDs de classificação gerados pelo dispositivo HUSKYLENS. A primeira entrada é uma string vazia porque os IDs de classificação do HUSKYLENS começam em um. O índice um corresponde à string “Santa” e o índice dois a “Car”.
const char* names[] = {"", "Santa", "Car"};
Instanciação do Objeto
Depois criamos o objeto HUSKYLENS chamado huskylens.
HUSKYLENS huskylens;
Setup
Na função setup() inicializamos a comunicação serial, a interface I2C e o sensor HUSKYLENS.
A linha seguinte inicializa o subsistema I2C usando Wire.begin(). A chamada a huskylens.begin(Wire) configura o driver do dispositivo e verifica se o sensor responde no barramento. Se esta inicialização falhar, o programa imprime uma mensagem de erro.
Após estabelecer a comunicação, o programa seleciona o algoritmo de classificação de objetos chamando huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION). Caso contrário, teria de selecionar manualmente o algoritmo de classificação de objetos no HUSKYLENS.
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION);
huskylens.setCustomName(names[1], 1);
huskylens.setCustomName(names[2], 2);
}
As duas linhas seguintes atribuem nomes personalizados aos IDs. A função huskylens.setCustomName(names[1], 1) associa a string “Santa” ao ID de classificação 1. A linha seguinte faz o mesmo para o ID 2, atribuindo o nome “Car”. Estas etiquetas personalizadas são exibidas no ecrã do HUSKYLENS quando um objeto é reconhecido. Veja as imagens abaixo:
Loop
A função loop() trata da obtenção de dados do motor de classificação. Cada iteração começa por pedir os resultados mais recentes ao sensor com a chamada huskylens.request().
O ciclo while subsequente processa todos os resultados atualmente disponíveis. O método huskylens.available() indica se pelo menos uma estrutura de resultado está pronta para ser lida. Se um resultado estiver presente, o sketch obtém-no usando huskylens.read(), que retorna um objeto HUSKYLENSResult.
O campo r.ID contém o ID de classificação atribuído pelo módulo. O programa usa este ID como índice no array names e imprime a etiqueta associada no monitor serial. Segue-se um atraso de um segundo para desacelerar a saída, tornando os resultados impressos mais fáceis de observar.
void loop() {
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
Serial.println(names[r.ID]);
delay(1000);
}
}
O classificador de objetos não retorna uma pontuação de confiança, o que significa que não pode filtrar deteções de baixa confiança. Mesmo que não haja objeto em frente ao HUSKYLENS, o ID da primeira classe é retornado. Consequentemente, o fundo é detetado como “Santa” no meu caso. Vai precisar de treinar uma “classe de fundo” separada para contornar isso.
Note também que o classificador de objetos não retorna informação de localização do objeto (x, y, w, h), o que é diferente dos algoritmos face detection ou object tracking, por exemplo.
Conclusões
Este tutorial mostrou como começar a usar o sensor de visão AI HUSKYLENS. Aprendeu como ligá-lo a um Arduino e como obter resultados de deteção dos algoritmos AI incorporados. Recomendo também que leia o HUSKYLENS Wiki da DFRobot para mais exemplos de código e instruções.
O HUSKYLENS facilita experimentar vários algoritmos de IA como reconhecimento facial, classificação de objetos, rastreamento de objetos, rastreamento de linha e outros. Não é necessário código complexo para treino, no entanto, a precisão da deteção e o número de objetos que podem ser detetados é limitado.
Se precisar de algoritmos de IA mais poderosos e da opção de implementar os seus próprios modelos AI no dispositivo, dê uma vista de olhos ao sucessor do HUSKYLENS, o HUSKYLENS 2. É mais caro e consome mais energia, mas tem uma seleção mais ampla de algoritmos AI com melhor precisão.
Além disso, a biblioteca para comunicar com o HUSKYLENS 2 funciona nas plataformas Arduino e ESP32, enquanto a biblioteca do HUSKYLENS funciona apenas no Arduino.
Tanto o HUSKYLENS como o HUSKYLENS 2 têm a vantagem de poderem executar modelos AI localmente no dispositivo. Não é necessária uma ligação Wi-Fi a um serviço na cloud com latências potencialmente elevadas ou problemas de conexão.
Se tiver alguma dúvida, sinta-se à vontade para deixá-la na secção de comentários.
Boas experiências a criar 😉
