Skip to main content

Resumen de Software Soportado

Hay dos métodos para habilitar el Módulo Grove Vision AI V2:

Comenzar sin código con SenseCraft AI ​

En esta sección, te guiaremos a través del uso de SenseCraft AI Model Assistant para desplegar rápidamente y observar resultados, sin código y sin otras placas de desarrollo:

¿Qué es SenseCraft AI? ​

SenseCraft AI permite a los usuarios desplegar sin esfuerzo una vasta biblioteca de modelos de IA disponibles públicamente en sus dispositivos edge:

  • reComputer (NVIDIA Jetson)
  • Placa Seeed Studio XIAO S3
  • Módulos Vision AI, y más

Proporciona una experiencia fluida y fácil de usar, permitiéndote desplegar modelos de IA públicos directamente en tus dispositivos edge con solo unos pocos clics.

Aprende Más 📕

Incluye:

  • Servicio de software Model Assistant
  • Servicio de software Device Workspace

En esta sección, usaremos "Model Assistant" aquí para habilitar el módulo. Combinado con el empoderamiento de SenseCraft AI Model Assistant, puedes fácilmente subir una amplia variedad de modelos co-creados y observar directamente los resultados.

Comenzando con SenseCraft AI Model Assistant ​

Ahora comenzaremos rápidamente con los módulos usando SenseCraft AI, y esto solo requerirá el módulo únicamente.

Paso 1. Elegir modelo​

Primero, necesitamos abrir la página principal de SenseCraft AI Model Assistant.

Ir a SenseCraft AI

Elige el modelo que quieres desplegar y haz clic en él.

Puedes ver la descripción de este modelo aquí y si te conviene, haz clic en el botón Deploy Model en el lado derecho.

Paso 2. Conectar el módulo y subir un modelo adecuado​

Por favor usa un cable tipo Type-C para conectar Grove Vision AI V2 a tu computadora y luego haz clic en el botón Connect.

Haz clic en el botón Confirm. En la esquina superior izquierda de esta página, puedes seleccionar USB Single Serial. Luego haz clic en el botón Connect.

Por favor permanece en esta página por 1-2 minutos hasta que el modelo se suba exitosamente. Ten en cuenta que cambiar a otra pestaña de página durante este proceso puede resultar en una subida no exitosa (nuestro equipo está trabajando activamente en resolver este problema, y será arreglado pronto).

Paso 3. Observaciones​

Una vez que el modelo se suba exitosamente, podrás ver la transmisión en vivo desde la cámara Grove Vision AI V2 en la Vista Previa de la izquierda.


Podemos ver que en las Configuraciones de Vista Previa en el lado izquierdo, hay dos opciones de configuración que pueden cambiarse para optimizar la precisión de reconocimiento del modelo.

  • Confidence: Confidence se refiere al nivel de certeza o probabilidad asignado por un modelo a sus predicciones.
  • IoU: IoU se usa para evaluar la precisión de las cajas delimitadoras predichas comparadas con las cajas delimitadoras verdaderas.
tip
  • Confidence: Esto te dice qué tan seguro está el modelo de visión por computadora sobre su predicción. Piénsalo como un porcentaje: mayor confianza significa que el modelo está más seguro.
  • IoU (Intersection over Union): Esto mide cuánta superposición hay entre dos cajas. Imagina que dibujaste una caja alrededor de un objeto en una imagen, y el modelo también dibujó una caja. IoU te dice qué tan bien coinciden tus cajas. Mayor IoU significa que las cajas están más cerca una de la otra.

En este punto, has terminado de cargar el modelo y observar los resultados.

Programación en Arduino conectando con la placa Seeed Studio XIAO ​

Introducción a la Biblioteca de Arduino ​

tip

Si esta es tu primera vez usando Arduino, te recomendamos encarecidamente que consultes Comenzando con Arduino.

Descargar la Biblioteca

Grove Vision AI utiliza el chip WiseEye2 HX6538, el procesamiento de imágenes y la inferencia del modelo se procesan localmente en Grove Vision AI, y luego el resultado se envía a XIAO a través de IIC o UART, por lo que el propósito principal de esta biblioteca es procesar el flujo de datos de Grove Vision AI, y no involucra inferencia de modelos o procesamiento de imágenes. Así que el propósito principal de esta biblioteca es procesar el flujo de datos de Grove Vision AI, sin involucrar inferencia de modelos o procesamiento de imágenes.

El Grove Vision AI se comunica con el XIAO a través del IIC, y la dirección IIC del dispositivo es 0x62. La transferencia de información de imágenes es a través del puerto serie USB.

Función​

Antes de comenzar a desarrollar un sketch, veamos las funciones disponibles de la biblioteca.

  • bool begin(TwoWire *wire = &Wire, uint16_t address = I2C_ADDRESS, uint32_t wait_delay = 2, uint32_t clock = 400000) —— Inicializar Grove Vision AI V2.

    Parámetros de Entrada:

    • TwoWire *wire —— Este puntero apunta a un objeto TwoWire, típicamente usado para comunicarse con dispositivos I2C.
    • uint16_t address —— Esta es la dirección del dispositivo I2C que identifica el dispositivo particular conectado al bus I2C.
    • uint32_t wait_delay —— El retraso (en milisegundos) a esperar por una respuesta antes de enviar un comando.
    • uint32_t clock —— Esta es la velocidad de reloj del bus I2C (en Hz).

    Retorno: True o False. El éxito de la inicialización es true, el fallo de la inicialización es false.

  • int invoke(int times = 1, bool filter = 0, bool show = 0) —— Usado para enviar comandos INVOKE al Grove Vision AI V2 para permitir que el Grove Vision AI comience a llamar modelos, inferencia y reconocimiento.

    Parámetros de Entrada:

    • int times —— El número de Invoke.
    • fileter —— Significa que la respuesta del evento solo se enviará si el último resultado es diferente del resultado anterior (comparado por geometría y puntuación).
    • bool show —— Significa que la respuesta del evento solo se enviará si el último resultado es diferente del resultado anterior (comparado por geometría y puntuación).
note

Para más información sobre las definiciones de protocolo de Grove Vision AI, puedes leer la documentación del protocolo.

Retorno: CMD_OK o CMD_ETIMEDOUT. Retorna CMD_OK si el modelo se habilitó exitosamente, de lo contrario retorna CMD_ETIMEDOUT.

  • int available() —— Verificar cuántos bytes de datos están disponibles para leer desde el dispositivo conectado a través del IIC.

    Parámetros de Entrada: Ninguno.

    Retorno: El número de bytes de datos que se pueden leer desde el dispositivo.

  • int read(char *data, int length) —— Lee datos del Grove Vision AI a través de la interfaz IIC. El propósito de la función es poblar el arreglo apuntado por el puntero de datos proporcionado con los datos leídos.

    Parámetros de Entrada:

    • char *data —— Un arreglo para almacenar datos.
    • int length —— La longitud de los datos a ser leídos.

    Retorno: La longitud de los datos a ser leídos.

  • int write(const char *data, int length) —— Escribe datos al dispositivo especificado a través de la interfaz I2C.

    Parámetros de Entrada:

    • const char *data —— El contenido de los datos a ser escritos.
    • int length —— La longitud de los datos a ser escritos.

    Retorno: La longitud de los datos a ser escritos.

  • std::vector<boxes_t> &boxes() { return _boxes; } —— Envía los resultados en forma de una caja.

typedef struct
{
    uint16_t x;      // Horizontal coordinates of the centre of the box
    uint16_t y;      // Vertical coordinates of the centre of the box
    uint16_t w;      // Width of the identification box
    uint16_t h;      // Height of the identification box
    uint8_t score;   // Confidence in identifying as target
    uint8_t target;  // Target
} boxes_t;
  • std::vector<classes_t> &classes() { return _classes; } —— Devuelve los resultados como categorías.
typedef struct
{
    uint8_t target;  // Target
    uint8_t score;   // Confidence in identifying as target
} classes_t;
  • std::vector<point_t> &points() { return _points; } —— Devuelve el resultado como un punto.
typedef struct
{
    uint16_t x;      // Horizontal coordinates of the identification point
    uint16_t y;      // Vertical coordinates of identification point
    uint16_t z;      // Relative depth coordinates of the identification point
    uint8_t score;   // Confidence in identifying as target
    uint8_t target;  // Target
} point_t;
note

La coordenada de profundidad aquí es relativa, no significa que Grove Vision AI tenga habilitada una cámara de profundidad, sino que el algoritmo calcula una coordenada de profundidad relativa que es válida en algunos modelos (por ejemplo, modelos face-3d).

  • perf_t &perf() { return _perf; } —— Tiempo de procesamiento de imagen e inferencia.
typedef struct
{
    uint16_t prepocess;   // Pre-processing time
    uint16_t inference;   // inference time
    uint16_t postprocess; // Post-processing time
} perf_t;
note

Las salidas no siempre proporcionan información que identifique cajas y puntos, dependiendo del modelo.

Instalación​

Dado que has descargado la biblioteca zip, abre tu Arduino IDE, haz clic en Sketch > Include Library > Add .ZIP Library. Elige el archivo zip que acabas de descargar, y si la biblioteca se instala correctamente, verás Library added to your libraries en la ventana de notificación. Lo que significa que la biblioteca se ha instalado exitosamente.

Primeros Pasos con Seeed Studio XIAO ​

Si quieres obtener un prototipo de un sensor con capacidades de visión artificial, entonces podrías considerar añadir un XIAO. Usando XIAO y Grove Vision AI V2, puedes usar el modelo que desees y desplegarlo rápidamente en tu área de aplicación.

Preliminar​

Paso 1. Materiales Requeridos

En este tutorial, usaremos el XIAO ESP32S3 como ejemplo para introducir el uso de programas Arduino. Por lo tanto, te recomendamos preparar el siguiente hardware.

Seeed Studio XIAO ESP32S3Grove Vision AI V2Módulo de Cámara OV5647-62 FOV
para Raspberry Pi 3B+4B
Consigue Uno Ahora 🖱️
Consigue Uno Ahora 🖱️
Consigue Uno Ahora 🖱️

Luego necesitas conectar el XIAO y el Grove Vision AI V2 a través de la fila de pines (o usar la placa de expansión y la interfaz Grove).

caution

Ten en cuenta la dirección de la conexión, el conector Type-C del Grove Vision AI debe estar en la misma dirección que el conector Type-C del XIAO.

Paso 2. Inicia la aplicación Arduino.

Descargar Arduino IDE

Paso 3. Selecciona tu modelo de placa de desarrollo y añádelo al Arduino IDE.

tip

A continuación se muestra una lista de placas compatibles para el ejemplo del Grove Vision AI V2, puedes elegir la placa que desees usar para completar el siguiente ejemplo. En este tutorial, se usará XIAO ESP32S3 como ejemplo.

  • Si quieres usar Seeed Studio XIAO SAMD21 para las rutinas posteriores, consulta este tutorial para terminar de añadirlo.

  • Si quieres usar Seeed Studio XIAO RP2040 para las rutinas posteriores, consulta este tutorial para terminar de añadirlo.

  • Si quieres usar Seeed Studio XIAO nRF52840 para las rutinas posteriores, consulta este tutorial para terminar de añadirlo.

  • Si quieres usar Seeed Studio XIAO ESP32C3 para las rutinas posteriores, consulta este tutorial para terminar de añadirlo.

  • Si quieres usar Seeed Studio XIAO ESP32S3 para las rutinas posteriores, consulta este tutorial para terminar de añadirlo.

  • Si quieres usar Seeeduino V4.3 para las rutinas posteriores, consulta este tutorial para terminar de añadirlo.

Paso 4. Instala la librería ArduinoJSON.

Ve al menú Sketch, luego selecciona Include Library > Manage Libraries.... Esto abrirá el Administrador de Librerías. En la barra de búsqueda en la parte superior del Administrador de Librerías, escribe ArduinoJSON. Los resultados de búsqueda mostrarán la librería ArduinoJSON. Habrá un botón Install junto a la librería. Haz clic en el botón Install. El Arduino IDE descargará e instalará automáticamente la librería en tu entorno de desarrollo Arduino.

Demo 1. Usar XIAO para obtener resultados de reconocimiento​

El siguiente procedimiento es un ejemplo simple para ayudarte a obtener y analizar la información de reconocimiento reportada por el Grove Vision AI V2.

#include <Seeed_Arduino_SSCMA.h>

SSCMA AI;

void setup()
{
    AI.begin();
    Serial.begin(9600);
}

void loop()
{
    if (!AI.invoke())
    {
        Serial.println("invoke success");
        Serial.print("perf: prepocess=");
        Serial.print(AI.perf().prepocess);
        Serial.print(", inference=");
        Serial.print(AI.perf().inference);
        Serial.print(", postpocess=");
        Serial.println(AI.perf().postprocess);

        for (int i = 0; i < AI.boxes().size(); i++)
        {
            Serial.print("Box[");
            Serial.print(i);
            Serial.print("] target=");
            Serial.print(AI.boxes()[i].target);
            Serial.print(", score=");
            Serial.print(AI.boxes()[i].score);
            Serial.print(", x=");
            Serial.print(AI.boxes()[i].x);
            Serial.print(", y=");
            Serial.print(AI.boxes()[i].y);
            Serial.print(", w=");
            Serial.print(AI.boxes()[i].w);
            Serial.print(", h=");
            Serial.println(AI.boxes()[i].h);
        }
        for (int i = 0; i < AI.classes().size(); i++)
        {
            Serial.print("Class[");
            Serial.print(i);
            Serial.print("] target=");
            Serial.print(AI.classes()[i].target);
            Serial.print(", score=");
            Serial.println(AI.classes()[i].score);
        }
        for (int i = 0; i < AI.points().size(); i++)
        {
            Serial.print("Point[");
            Serial.print(i);
            Serial.print("] target=");
            Serial.print(AI.points()[i].target);
            Serial.print(", score=");
            Serial.print(AI.points()[i].score);
            Serial.print(", x=");
            Serial.print(AI.points()[i].x);
            Serial.print(", y=");
            Serial.println(AI.points()[i].y);
        }
    }
}
Explicación del procedimiento​

Este sketch de Arduino utiliza la biblioteca Seeed_Arduino_SSCMA para interactuar con el Módulo Grove Vision AI V2. En la función setup(), se inicializa el módulo AI y se inicia la comunicación serie.

La función loop() llama repetidamente al método invoke() para realizar inferencia utilizando los algoritmos integrados del Módulo Grove Vision AI V2. Tras una inferencia exitosa, el sketch imprime métricas de rendimiento en el monitor serie, incluyendo tiempos de preprocesamiento, inferencia y postprocesamiento.

El sketch procesa e imprime información detallada sobre los resultados de la inferencia, incluyendo:

  • Cajas delimitadoras (boxes()) que identifican las ubicaciones y dimensiones de objetos detectados en forma de coordenadas x e y, ancho y alto.
  • Clasificaciones (classes()) que identifican las categorías de objetos detectados junto con sus puntuaciones de confianza.
  • Puntos (points()) que representan características específicas o puntos clave de objetos detectados, junto con sus coordenadas x e y y puntuaciones de confianza.

Estos resultados proporcionan información sobre los objetos detectados por el módulo AI, sus posiciones, tamaños y el nivel de confianza de cada detección o clasificación. La salida se imprime en el monitor serie para análisis adicional o depuración.

Efecto​

Seguimos utilizando el modelo de Detección de Gestos. Después de haber subido la aplicación, por favor abre el monitor serie y establece la velocidad de baudios del monitor serie a 9600. Por favor prepara tu "piedra-papel-tijeras" y apúntalo al área de reconocimiento de la cámara, y el monitor serie mostrará el resultado del reconocimiento.

Demo 2. Enviar comandos de control vía XIAO​

El Grove Vision AI V2 soporta comunicación vía el protocolo UART, y utilizando el protocolo integrado, es posible operar el chip Himax WE2 del Grove Vision AI V2. El siguiente programa de ejemplo muestra cómo usar el XIAO para comunicarse con el Grove Vision AI V2 a través del puerto serie.

#include <Arduino.h>
#include <Wire.h>

#include <Seeed_Arduino_SSCMA.h>

SSCMA AI;

void setup()
{
    // put your setup code here, to run once:
    Wire.begin();
    Serial.begin(115200);
    while (!Serial)
        delay(1000);

    Serial.println("Proxy start");
}

char buf[512];
void loop()
{
    int s_len = Serial.available();
    if (s_len)
    {
        int len = Serial.readBytes((char *)buf, s_len);
        AI.write(buf, len);
    }
    int t_len = AI.available();
    if (t_len)
    {
        if (t_len > 512)
        {
            t_len = 512;
        }

        AI.read(buf, t_len);
        Serial.write(buf, t_len);
    }
}
Explicación del procedimiento​

Este sketch de Arduino establece una interfaz de comunicación entre la consola serie y el módulo Grove Vision AI V2, utilizando el Marco de Aprendizaje Automático de Seeed Studio SSCMA. El sketch está diseñado para pasar datos hacia y desde el módulo Grove Vision AI V2 a través de comandos serie.

Aquí está la descripción modificada del sketch:

En la función setup():

  • El protocolo de comunicación I2C se inicializa con Wire.begin(), permitiendo la comunicación con el módulo Grove Vision AI V2.
  • La comunicación serie se configura a una velocidad de baudios de 115200.
  • El sketch espera a que la conexión serie esté activa antes de mostrar "Proxy start" en el monitor serie, indicando que el canal de comunicación proxy está listo.

En la función loop():

  • El sketch verifica los datos serie entrantes usando Serial.available(). Si hay datos, los lee en un buffer llamado buf.
  • Los datos recopilados en el buffer se envían luego al módulo Grove Vision AI V2 usando el método AI.write().
  • A continuación, el sketch verifica si el módulo Grove Vision AI V2 tiene algún dato para enviar de vuelta usando AI.available().
  • Si el módulo Grove Vision AI V2 ha enviado datos, el sketch lee estos datos en el buffer buf con AI.read(), asegurándose de que los datos no excedan el tamaño del buffer de 512 bytes.
  • Finalmente, los datos recibidos del módulo Grove Vision AI V2 se transmiten de vuelta a la consola serie usando Serial.write(), completando la comunicación bidireccional entre la interfaz serie y el módulo de visión AI.

Esta configuración permite la comunicación interactiva con el módulo Grove Vision AI V2, habilitando a los usuarios para enviar instrucciones y recibir datos del módulo a través de una conexión serie.

Recursos​

Solución de problemas​

P1: ¿Por qué no puedo ver el resultado reconocido en el puerto después de cargar exitosamente el código del Demo1 usando XIAO ESP32C3?​

Si estás usando Arduino IDE versión 1.xx, por favor vuelve a abrir el monitor serie después de presionar Reset en C3 para ver el resultado. Si estás usando Arduino versión 2.xx, el mensaje se actualizará en el monitor serie después de presionar el botón Reset.

Soporte Técnico y Discusión de Productos​

¡Gracias por elegir nuestros productos! Estamos aquí para proporcionarte diferentes tipos de soporte para asegurar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para atender diferentes preferencias y necesidades.

Loading Comments...