Placa de Expansión para XIAO

Descripción general

Una potente placa de expansión funcional para Seeed Studio XIAO, con un tamaño de solo la mitad del Raspberry Pi 4. Permite crear prototipos y proyectos de manera fácil y rápida. Con sus ricos periféricos, que incluyen OLED, RTC, memoria expandible, zumbador pasivo, botón RESET/Usuario, conector para servomotor de 5V, múltiples interfaces de datos... podrás explorar posibilidades infinitas con Seeed Studio XIAO. Circuitpython también es totalmente compatible con esta placa.

Debido al formato de XIAO de Seeed Studio, todas las placas XIAO de Seeed Studio son compatibles tanto con Grove Shield para XIAO de Seeed Studio como con Placa de Expansión Seeed Studio para XIAO. Existe una pequeña diferencia entre los pines, y con la referencia al Pinout, es fácil de gestionar.

La Seeed Studio XIAO SAMD21, la Seeed Studio XIAO RP2040 y la Seeed Studio XIAO nRF52840 son compatibles con la Placa de Expansión Seeed Studio para XIAO.

Consigue uno ahora 🖱️

Características

Prototipado rápido: Depuración y reinicio fáciles con el botón RESET y el pin SWD dirigido a un conector hembra.
Periféricos ricos: Pantalla OLED, RTC, espacio de memoria expandible, zumbador pasivo, botón de usuario, chip de gestión de batería integrado.
No se necesita soldadura: Todos los pines están dirigidos. Conectores Grove de fácil conexión y uso, que soportan múltiples protocolos de datos, incluyendo IIC, UART, y Analog/Digital.
Compatibilidad con Circuit Python: Totalmente compatible con Circuit Python. El slot para tarjeta microSD permite ampliar el espacio de memoria, lo que posibilita asignar más bibliotecas necesarias para prototipos y proyectos.
Tamaño mini: Compacta y elegante, con un tamaño de solo la mitad del Raspberry Pi 4, especialmente adecuada para proyectos que requieren un tamaño reducido.

Especificación

Artículo	Valor
Voltaje de funcionamiento	5V / 3.7V Lithium Battery
Corriente de carga	460mA (Max)
Precisión del temporizador RTC	± 1.5S/DAY(25°C)
Batería RTC	CR1220
Display	0.96" OLED display
Memoria expandible	MicroSD card
Interface Grove	Grove IIC2, Grove UART1, A0/D0 Grove*1
Otros equipos externos	Buzzer pasivo, botón, conector 5V para servo

Aplicaciones

Depuración SWD
Prototipado rápido
Visualización de datos
Proyecto de tamaño reducido

Lista de piezas

Elemento	Cantidad
Seeed Studio Expansion Base para XIAO	*1

note

Este producto no incluye Seeed Studio XIAO ni la batería. Seeed Studio XIAO está constantemente introduciendo nuevos productos. Para estar al tanto de los últimos desarrollos de productos en esta serie, visita la página principal de la serie XIAO.

Empezando

Materiales requeridos

Seeed Studio XIAO SAMD21 (Pre-soldado)	Seeed Studio Expansion Base for XIAO

Consigue uno ahora	Consigue uno ahora

Descripción general del hardware

Hay una ranura externa para tarjeta MicroSD y un soporte para batería RTC. La tarjeta MicroSD se utiliza principalmente para guardar y ejecutar el archivo python.py. El RTC (reloj en tiempo real) se usa para realizar un seguimiento de la hora actual y puede programarse para ejecutar acciones en un momento específico.

Diagrama de Pinout

Descripción de los pines del encabezado externo para el Grove-Shield para Seeed Studio XIAO.

Uso de la Placa de Expansión

Conexión

Coloca la Seeed Studio XIAO SAMD21 sobre la placa de expansión, el LED verde de la Seeed Studio XIAO SAMD21 debería encenderse.

note

Por favor, conecta primero la Seeed Studio XIAO en la placa de expansión, luego conecta el cable Type-C. Recuerda insertar la Seeed Studio XIAO en el centro de los dos conectores de cabezal hembra, de lo contrario, podrías dañar tanto la XIAO de Seeed Studio como la placa de expansión.

Uso de la batería

La Seeed Studio Expansion Base for XIAO puede alimentarse mediante una batería, por lo que si realizas alguna demostración que requiera moverla, la batería te ayudará a resolver el problema de suministro de energía. Al conectar la batería, ten cuidado con los ánodos positivo y negativo, sigue la imagen para conectar la batería correctamente y evitar dañar la placa.

Además, la placa carga la batería cuando conectas el cable de la batería y el cable tipo-C, y enciendes el interruptor.

Como muestra la imagen a continuación, si el LED parpadea, significa que la batería no está cargando o que la placa no está conectada a la batería. Si el LED permanece encendido, significa que la batería se está cargando.

Módulos en la placa de expansión

La placa de expansión incluye una gran cantidad de periféricos:

Pantalla OLED: Visualización de datos sin necesidad de conectarse al PC, lo que permite una depuración más eficiente y la creación de aplicaciones como un hub de sensores, sistema de monitoreo de datos, etc.
Botón RESET: Olvídate de los cables de puente y los cortocircuitos, con un solo clic puedes reiniciar el sistema.
Depuración SWD: El pin SWD está disponible en un header macho, lo que facilita la conexión del depurador y la carga del firmware.
RTC de alta precisión: Reloj de tiempo real de alta precisión con batería de respaldo, manteniendo la hora exacta incluso cuando se apaga la alimentación principal.
Memoria expandible: Con una ranura para tarjeta MicroSD en la parte posterior, ya no tienes que preocuparte por el límite de memoria al agregar bibliotecas y usar Circuit Python.
Botón de usuario: Además del botón RESET, también incluye otro botón definido por el usuario.
Buzzer pasivo: Puedes cambiar la frecuencia PWM para generar diferentes sonidos de pitido y crear "música de buzzer".
Conectores Grove: Todos los pines están disponibles, con conectores Grove plug-and-play que soportan protocolos de datos comunes (Grove IIC2, Grove UART1, A0/D0 Grove*1).
Carga de batería Lipo: Conector estándar JST2.0mm para batería Lipo y sistema de gestión de baterías, soportando tanto la alimentación por USB como por batería Lipo, y permitiendo recargar la batería de manera fácil.
Conector para servomotor de 5V: Salida de 5V disponible en header macho para la conexión de servos y sensores de 5V.

Display OLED

Este ejemplo introduce cómo usar la pantalla OLED en la Seeed Studio Expansion Base para XIAO.

Paso 1. Instala el Seeed Studio XIAO SAMD21 en la placa de expansión y luego conecta el cable Type-C.

Paso 2. Instala la biblioteca u8g2, esta es la guía cómo instalar la biblioteca.

Paso 3. Copia el código y pégalo en el IDE de Arduino, luego cárgalo.

Código OLED

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

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // OLEDs sin Reset de la pantalla

void setup(void) {
  u8x8.begin();
  u8x8.setFlipMode(1);   // establece un número de 1 a 3, la palabra en la pantalla girará 180 grados
}

void loop(void) {
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 0);
  u8x8.print("Hello World!");
}

Control de LED por botón de usuario

Este ejemplo muestra cómo usar el botón en la placa de expansión Seeed Studio para XIAO para controlar el LED en el Seeed Studio XIAO SAMD21.

Paso 1. Instala el Seeed Studio XIAO SAMD21 en la placa de expansión y luego conecta el cable Type-C.

Paso 2. Abre el IDE de Arduino, copia el código y pégalo en el IDE de Arduino, luego cárgalo.

Código

const int buttonPin = 1;     // el número del pin del botón
int buttonState = 0;         // variable para leer el estado del botón

void setup() {
  // inicializar el pin del LED como salida:
  pinMode(LED_BUILTIN, OUTPUT);
  // inicializar el pin del botón como entrada:
  pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
  // leer el estado del valor del botón:
  buttonState = digitalRead(buttonPin);

  // verificar si el botón está presionado. Si lo está, el estado del botón es HIGH:
  if (buttonState == HIGH) {
    // encender el LED:
    digitalWrite(LED_BUILTIN, HIGH);
  } else {
    // apagar el LED:
    digitalWrite(LED_BUILTIN, LOW);
  }
}

Buzzer

El buzzer está conectado por defecto al pin A3. Si deseas eliminar la función del buzzer, simplemente sigue la imagen a continuación y corta la línea.

Reproducir canción con Buzzer pasivo

Este ejemplo utiliza el buzzer en la placa de expansión Seeed Studio para XIAO para reproducir "Feliz Cumpleaños".

Paso 1. Instala el Seeed Studio XIAO SAMD21 en la placa de expansión y luego conecta el cable Type-C.

Paso 2. Abre el IDE de Arduino, copia el código y pégalo en el IDE de Arduino, luego cárgalo.

Código

int speakerPin = D3;
int length = 28; // el número de notas
char notes[] = "GGAGcB GGAGdc GGxecBA yyecdc";
int beats[] = { 2, 2, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 16 };
int tempo = 150;
void playTone(int tone, int duration) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}

void playNote(char note, int duration) {
  char names[] = {'C', 'D', 'E', 'F', 'G', 'A', 'B',
                  'c', 'd', 'e', 'f', 'g', 'a', 'b',
                  'x', 'y'
                 };
  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014,
                  956,  834,  765,  593,  468,  346,  224,
                  655 , 715
                };
  int SPEE = 5;

  // Reproducir el tono correspondiente al nombre de la nota

  for (int i = 0; i < 16; i++) {
    if (names[i] == note) {
      int newduration = duration / SPEE;
      playTone(tones[i], newduration);
    }
  }
}

void setup() {
  pinMode(speakerPin, OUTPUT);
}

void loop() {
  for (int i = 0; i < length; i++) {
    if (notes[i] == ' ') {
      delay(beats[i] * tempo); // descansar
    } else {
      playNote(notes[i], beats[i] * tempo);
    }
    // Pausa entre notas
    delay(tempo);
  }
}

Control de Servo mediante Sensor de Ángulo Rotatorio

Este ejemplo utiliza un sensor de ángulo rotatorio para controlar el servo a través de los puertos de integración en la placa de expansión Seeed Studio para XIAO.

Paso 1. Instala el Seeed Studio XIAO SAMD21 en la placa de expansión y luego conecta el cable Type-C.

Paso 2. Conecta el cable del servo al puerto I2C y el sensor de ángulo rotatorio al puerto D0.

Paso 3. Abre el IDE de Arduino, copia el código y pégalo en el IDE de Arduino, luego cárgalo.

tip

Si tu placa de desarrollo es XIAO ESP32 Series. Antes de ejecutar el siguiente código, primero debes instalar la biblioteca ESP32Servo en Arduino Library Manager y luego cambiar el siguiente código de #include <Servo.h> a #include <ESP32Servo.h>.

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

#define ROTARY_ANGLE_SENSOR A0
#define ADC_REF 3 // voltaje de referencia del ADC es 3v. Si el Vcc está encendido en el Seeeduino
#define GROVE_VCC 3 // VCC de la interfaz Grove normalmente es 3v
#define FULL_ANGLE 300 // el valor completo del ángulo rotatorio es 300 grados

Servo myservo;  // crear un objeto servo para controlar un servo
// se pueden crear doce objetos servo en la mayoría de las placas

int pos = 0;    // variable para almacenar la posición del servo

void setup() {
  Serial.begin(9600);
  pinMode(ROTARY_ANGLE_SENSOR, INPUT);
  myservo.attach(5);  // conecta el servo al pin 5
}

void loop() {

  float voltage;
  int sensor_value = analogRead(ROTARY_ANGLE_SENSOR);
  voltage = (float)sensor_value * ADC_REF / 1023;
  float degrees = (voltage * FULL_ANGLE) / GROVE_VCC;
  Serial.println("El ángulo entre la marca y la posición inicial:");
  Serial.println(degrees);
  delay(50);
  myservo.write(degrees);
}

Display del reloj RTC

Este ejemplo utiliza el RTC para mostrar el reloj en el OLED.

Paso 1. Instala el Seeed Studio XIAO SAMD21 en la placa de expansión y luego conecta el cable Type-C.

Paso 2. Instala las bibliotecas u8g2 y PCF8563, esta es la guía cómo instalar la biblioteca.

Paso 3. Copia el código y pégalo en el IDE de Arduino, luego cárgalo.

#include <Arduino.h>
#include <U8x8lib.h>
#include <PCF8563.h>
PCF8563 pcf;
#include <Wire.h>

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // OLEDs sin reiniciar el Display

void setup() {
  Serial.begin(115200);
  u8x8.begin();
  u8x8.setFlipMode(1);
  Wire.begin();
  pcf.init();//Inicializar el reloj
  pcf.stopClock();//detener el reloj
  pcf.setYear(20);//establecer año
  pcf.setMonth(10);//establecer mes
  pcf.setDay(23);//establecer día
  pcf.setHour(17);//establecer hora
  pcf.setMinut(33);//establecer minutero
  pcf.setSecond(0);//establecer segundero
  pcf.startClock();//Iniciar el reloj
}

void loop() {
  Time nowTime = pcf.getTime();//Obtenga hora actual
  u8x8.setFont(u8x8_font_chroma48medium8_r);   // Elija una fuente adecuada
  u8x8.setCursor(0, 0);
  u8x8.print(nowTime.day);
  u8x8.print("/");
  u8x8.print(nowTime.month);
  u8x8.print("/");
  u8x8.print("20");
  u8x8.print(nowTime.year);
  u8x8.setCursor(0, 1);
  u8x8.print(nowTime.hour);
  u8x8.print(":");
  u8x8.print(nowTime.minute);
  u8x8.print(":");
  u8x8.println(nowTime.second);
  delay(1000);
}

Función de tarjeta SD

Para el XIAO SAMD21, XIAO RP2040, XIAO ESP32C3 y XIAO ESP32S3, no necesitas instalar una biblioteca separada para la tarjeta SD de terceros. Este procedimiento a continuación es aplicable a estos XIAOs.

tip

El circuito de la placa de expansión está diseñado de manera que el pin CS del slot de la tarjeta SD esté conectado al pin D2 del XIAO.

#include <SPI.h>
#include <SD.h>
#include "FS.h"

File myFile;

void setup() {
  // Abre la comunicación serial y espera a que el puerto se abra:
  Serial.begin(115200);
  while(!Serial);              // Ejecutar después de encender el monitor serial
  delay(500);

  Serial.print("Inicializando tarjeta SD...");

  pinMode(D2, OUTPUT);          // Modifica los pines aquí para ajustarlos a los pines CS de la tarjeta SD que estás utilizando.
  if (!SD.begin(D2)) {
    Serial.println("¡fallo en la inicialización!");
    return;
  }
  Serial.println("inicialización completada.");

  // abre el archivo. Ten en cuenta que solo se puede abrir un archivo a la vez,
  // por lo que debes cerrar este antes de abrir otro.
  myFile = SD.open("/test.txt", FILE_WRITE);          // La ruta para leer y escribir archivos debe comenzar con "/"

  // si el archivo se abrió correctamente, escribe en él:
  if (myFile) {
    Serial.print("Escribiendo en test.txt...");
    myFile.println("prueba 1, 2, 3.");
    // cierra el archivo:
    myFile.close();
    Serial.println("listo.");
  } else {
    // si el archivo no se abre, imprime un error:
    Serial.println("error al abrir test.txt");
  }

  // vuelve a abrir el archivo para leerlo:
  myFile = SD.open("/test.txt");                       // La ruta para leer y escribir archivos debe comenzar con "/"
  if (myFile) {
    Serial.println("test.txt:");

    // lee del archivo hasta que no quede más contenido:
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    // cierra el archivo:
    myFile.close();
  } else {
    // si el archivo no se abre, imprime un error:
    Serial.println("error al abrir test.txt");
  }
}

void loop() {
  // no ocurre nada después de la configuración
}

Si estás utilizando la serie XIAO nRF52840, es posible que necesites descargar la biblioteca SdFat por separado para poder utilizar la función de tarjeta SD.

#include <SPI.h>
#include "SdFat.h"
SdFat SD;

#define SD_CS_PIN D2
File myFile;

void setup() {
  // Abre la comunicación serial y espera a que el puerto se abra:
  Serial.begin(9600);
  while (!Serial) {
    ; // espera a que el puerto serial se conecte. Necesario solo para puertos USB nativos
  }

  Serial.print("Inicializando tarjeta SD...");

  if (!SD.begin(SD_CS_PIN)) {
    Serial.println("¡fallo en la inicialización!");
    return;
  }
  Serial.println("inicialización completada.");

  // abre el archivo. Ten en cuenta que solo se puede abrir un archivo a la vez,
  // por lo que debes cerrar este antes de abrir otro.
  myFile = SD.open("/test.txt", FILE_WRITE);

  // si el archivo se abrió correctamente, escribe en él:
  if (myFile) {
    Serial.print("Escribiendo en test.txt...");
    myFile.println("prueba 1, 2, 3.");
    // cierra el archivo:
    myFile.close();
    Serial.println("listo.");
  } else {
    // si el archivo no se abre, imprime un error:
    Serial.println("error al abrir test.txt");
  }

  // vuelve a abrir el archivo para leerlo:
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("test.txt:");

    // lee del archivo hasta que no quede más contenido:
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    // cierra el archivo:
    myFile.close();
  } else {
    // si el archivo no se abre, imprime un error:
    Serial.println("error al abrir test.txt");
  }
}

void loop() {
  // no ocurre nada después de la configuración
}

Carcasa de acrílico para Seeed Studio Expansion Base para XIAO

Hicimos esta caja de acrílico para proteger la placa de expansión Seeed Studio para XIAO, estos son los componentes de la caja de acrílico.

En comparación con el Grove Shield para Seeed Studio XIAO, la Seeed Studio Expansion Base para XIAO agrega muchos módulos útiles para los usuarios.

Esta caja de acrílico es fácil de armar y también puede darle un aspecto más ordenado al conjunto.

CircuitPython en Seeed Studio XIAO SAMD21 con placa de expansión

Esta wiki introduce cómo instalar y ejecutar el CircuitPython oficial de Adafruit Industries en la placa de desarrollo Seeed Studio XIAO SAMD21.

CircuitPython es un lenguaje de programación diseñado para simplificar la experimentación y el aprendizaje de la programación en placas de microcontrolador de bajo costo. Hace que comenzar sea más fácil que nunca, sin necesidad de descargas previas de escritorio. Una vez que configures tu placa, abre cualquier editor de texto y comienza a editar el código. Para más información, consulta aquí.

Instalación de CircuitPython

Paso 1. Instala el Seeed Studio XIAO SAMD21 en la placa de expansión y luego conecta el cable Type-C.

Paso 2. Descarga el bootloader oficial de CircuitPython para Seeed Studio XIAO SAMD21 desde aquí. Un archivo .uf2, que se almacenará en la carpeta de descargas de tu PC.

Paso 3. Ingresa al modo DFU (Device Firmware Update) presionando rápidamente el botón de reinicio dos veces en la Seeed Studio Expansion Base para XIAO. Luego, tu PC debería reconocer la unidad "Arduino".

Paso 4. Debería aparecer una unidad externa llamada Arduino en tu PC. Arrastra los archivos .uf2 de CircuitPython descargados a la unidad Arduino.

Paso 5. Una vez cargado el bootloader de CircuitPython, desconecta el USB Type-C y vuelve a conectarlo. Debería aparecer una nueva unidad externa llamada CIRCUITPY.

Paso 6. ¡Ahora, CircuitPython está cargado en el Seeed Studio XIAO SAMD21! Lo único que necesitas hacer es escribir tu programa en Python y nombrarlo main.py, luego arrástralo a la unidad CIRCUITPY.

Ejemplo de CircuitPython: Blink

Aquí tienes un ejemplo simple para introducir cómo usar CircuitPython en el Seeed Studio XIAO.

Paso 1. Crea un archivo de texto llamado main en la unidad CIRCUITPY.

note

El nombre main puede ser uno de los siguientes: code.txt, code.py, main.py, main.txt. Hay más detalles sobre este comportamiento.

Paso 2. Usa REPL para obtener los pines del LED naranja. Para más detalles sobre REPL, consulta ¡Bienvenido a CircuitPython!. Para usar REPL, primero necesitas conectarte a la consola serial. Una vez establecida la conexión, presiona CTRL+C dos veces para ingresar al modo de edición. Luego, copia el siguiente código e ingrésalo respectivamente.

>>> import board
>>> dir(board)

Verás una lista de todos los pines de tu placa que están disponibles para usar en tu código. Cada placa puede variar ligeramente dependiendo de la cantidad de pines disponibles.

¿Ves YELLOW_LED_INVERTED? ¡Ese es el pin que usaste para hacer parpadear el LED naranja!

Paso 3 Pega el código en el archivo main y guárdalo. Verás el LED naranja parpadeando en la placa Seeed Studio XIAO SAMD21

Código

import time
import board
from digitalio import DigitalInOut, Direction

led = DigitalInOut(board.YELLOW_LED_INVERTED)
led.direction = Direction.OUTPUT

while True:
    led.value = True
    time.sleep(1)
    led.value = False
    time.sleep(1)

Tarjeta MicroSD para CircuitPython

La Seeed Studio XIAO SAMD21 tiene aproximadamente 40 KB de memoria flash incorporada, pero puede que no tenga suficiente espacio para almacenar archivos de código Python de gran tamaño. Afortunadamente, la placa de expansión Seeed Studio XIAO SAMD21 tiene incorporado un puerto para tarjeta MicroSD para ampliar el espacio de almacenamiento. Puedes seguir estas instrucciones para aprender cómo ejecutar CircuitPython desde la tarjeta MicroSD.

note

El sistema de formato de la tarjeta MicroSD debe ser FAT o exFAT. Si utilizas otro formato de sistema de la tarjeta MicroSD, esto causará que la tarjeta no sea reconocida.

Paso 1. Prepara una tarjeta microSD para conectar a la placa de expansión Seeed Studio XIAO SAMD21.

Paso 2. Supongamos que aún no has descargado el archivo de CircuitPython, por favor consulta el capítulo de Instalación de CircuitPython.

Paso 3. Descarga lib, descomprime el archivo y luego reemplázalo con la nueva biblioteca en CIRCUITPY.

Paso 4. Descarga el archivo main.py en la unidad CIRCUITPY.

El código de main.py

import sd
f = open("/sd/hello.txt", "r")   ## read the file from SD card
print(f.read())

Paso 5. Descarga el archivo sd.py en la unidad CIRCUITPY.

El código de sd.py

import os
import adafruit_sdcard
import board
import busio
import digitalio
import storage
import sys

# Connect to the card and mount the filesystem for Seeed Studio XIAO .
spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
cs = digitalio.DigitalInOut(board.D2)
sdcard = adafruit_sdcard.SDCard(spi, cs)
vfs = storage.VfsFat(sdcard)
storage.mount(vfs, "/sd")
sys.path.append("/sd")
sys.path.append("/sd/lib")  ## switch to the path to SD card

Ejemplo de Buzzer

Este ejemplo es para probar el buzzer ejecutando el archivo buzzer.py desde la tarjeta MicroSD.

Paso 1. Solo tienes que pegar el archivo buzzer.py en la tarjeta MicroSD.

Paso 2. Abre el archivo main.py en la unidad CIRCUITPY.

Paso 3. Agrega import buzzer en el archivo main.py.

Cuando termines todos los pasos, el buzzer funcionará. Si deseas ejecutar otros archivos Python en la tarjeta MicroSD, sigue el ejemplo.

note

Si quieres volver al modo Arduino, solo necesitas cargar cualquier programa en el Arduino IDE.

Demostración

Proyecto 1 - Ventilador controlado a distancia

Visión general

Esta wiki introduce cómo hacer un mini ventilador para colocar en tu habitación y mantenerla fresca.

Características

Ventilador de oscilación automática

Componentes requeridos

Conexión de hardware

Por favor, sigue el mismo esquema de colores para conectar cada sensor en la placa. Conecta el cable del ventilador Grove a D0, el cable del servo Grove a I2C y el cable del receptor IR Grove a D7.

Instrucciones para Arduino

Paso 1. Sigue la imagen de conexión y conecta todos los sensores a la placa.

Paso 2. Instala la biblioteca Arduino-IRremote. Aquí tienes una guía sobre cómo instalar la biblioteca.

Paso 3. Copia el código en el Arduino IDE y cárgalo en la placa.

Paso 4. Coloca el ventilador en una posición segura y presiona el botón para asegurarte de que funciona correctamente.

Código

#include <IRremote.h>
#include <Servo.h>

Servo myservo;  // create servo object to control a servo
int RECV_PIN = 7; // set pin 2 as IR control

IRrecv irrecv(RECV_PIN);

decode_results results;

int pos = 90;    // variable to store the servo position
int fanPin = 0;  // set D6 as control switch
int fanState = LOW;
int IO = 0;

void setup()
{
  Serial.begin(9600);
  Serial.println("Enabling IRin");  // remind enabling IR
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
  myservo.attach(5);  // attaches the servo on pin 2 to the servo object
  pinMode(fanPin, OUTPUT);

}

void loop() {
  if (irrecv.decode(&results)) { //checking IR signal
    if (results.value == 2155829415) {    // Power off/on
      IO++;
      if (IO % 2 == 0) {
        fanState = HIGH;
        digitalWrite(fanPin, fanState);
        delay(100);
      }
      else {
        fanState = LOW;
        digitalWrite(fanPin, fanState);
        delay(100);
      }
    }

    if (results.value == 2155821255 ) {    // fan swing to left
      for (pos; pos <= 89; pos += 1) { // goes from 0 degrees to 90 degrees
        // in steps of 1 degree
        myservo.write(pos);              // tell servo to go to position in variable 'pos'

        delay(40);                       // waits 15ms for the servo to reach the position
        if (irrecv.decode(&results)) {
          irrecv.resume();
          if (results.value == 2155870215)
            break;
        }
      }
    }

    if (results.value == 2155870215 ) {    // fan swing to right
      for (pos; pos >= 1; pos -= 1) { // goes from 90 degrees to 0 degrees
        myservo.write(pos);              // tell servo to go to position in variable 'pos'
        delay(40);                       // waits 15ms for the servo to reach the position

        if (irrecv.decode(&results)) {
          irrecv.resume();
          if (results.value == 2155821255)
            break;
        }
      }
    }
    Serial.println(pos);
    Serial.println(results.value, HEX);
    Serial.println(results.value);
    irrecv.resume();                    //recive next intrustion
  }
  delay(100);
}

Proyecto 2 - Coche controlado a distancia

Visión general

Esta wiki introduce cómo hacer un coche controlado a distancia.

Características

Coche de tamaño mini, fácil de maniobrar en caminos estrechos.

Componentes requeridos

Conexión de hardware

Sigue el mismo esquema de colores para conectar cada sensor en la placa. Conecta el cable del sensor IR Grove a D0 y el cable del Mini Motor Driver Grove a I2C.

Instrucciones para Arduino

Paso 1. Sigue la imagen de conexión y conecta todos los sensores a la placa.

Paso 2. Descarga el Arduino IDE.

Paso 3. Instala las bibliotecas Arduino-IRremote y Motor Driver. Aquí tienes una guía sobre cómo instalar la biblioteca.

Paso 4. Copia el código en el Arduino IDE y cárgalo en la placa.

Código

#include <Arduino.h>
#include <U8g2lib.h>
#include <IRremote.h>
#include <SparkFunMiniMoto.h>  // Include the MiniMoto library
// Create two MiniMoto instances, with different address settings.
MiniMoto motor0(0xC4); // A1 = 1, A0 = clear
MiniMoto motor1(0xC0); // A1 = 1, A0 = 1 (default)

#define FAULTn  1     // Pin used for fault detection.

int RECV_PIN = 0; // set pin 2 as IR control
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup() {
  Serial.begin(9600);
  Serial.println("Enabling IRin");  // remind enabling IR
  irrecv.enableIRIn(); // Start the receiver
  pinMode(FAULTn, INPUT);
}

void loop() {
  if (irrecv.decode(&results)) { //checking IR signal
    if (results.value == 2155862055) {
      //Forward  2155862055
      motor0.drive(-600);
      motor1.drive(600);
      delayUntil(20);
    }
    if (results.value == 2155813095) {
      //Brake   2155813095
      motor0.brake();
      motor1.brake();
      delay(100);
    }
    if (results.value == 2155823295) {
      //backward  2155823295
      motor0.drive(600);
      motor1.drive(-600);
      delayUntil(20);
    }
    if (results.value == 2155829415) {
      //Stop  2155829415
      motor0.stop();
      motor1.stop();
      delay(100);
    }
    if (results.value == 2155821255) {
      //turn right   2155821255
      motor0.drive(600);
      motor1.drive(600);
      delayUntil(20);
    }
    if (results.value == 2155837575) {
      //turn left    2155837575
      motor0.drive(-600);
      motor1.drive(-600);
      delayUntil(20);
    }
    irrecv.resume();                    //recive next intrustion

  }
  delay(100);
}

void delayUntil(unsigned long elapsedTime) {
  unsigned long startTime = millis();
  while (startTime + elapsedTime > millis()) {
    if (digitalRead(FAULTn) == LOW) {
      byte result = motor0.getFault();
      result = motor1.getFault();
    }
  }
}

Proyecto 3 - Desbloqueo de caja del tesoro con huella dactilar - Seeed Studio XIAO

Visión general

Esta caja puede almacenar tus objetos importantes sin que tengas que preocuparte de que alguien más los tome. La caja cuenta con una función de huella dactilar para proteger tus pertenencias. Si la autorización de la huella dactilar falla, el zumbador activará una alarma y el anillo LED se iluminará en rojo. Solo las huellas registradas previamente podrán desbloquear la caja. Cuando la autenticación sea exitosa, el anillo LED se iluminará en verde.

Características

Fácil registro de huellas dactilares.
El anillo LED indica el estado del bloqueo.
La pantalla OLED muestra la información actual.
El zumbador indica si la huella ha sido autorizada o no.

Componentes requeridos

Conexión de hardware

Conecta cada módulo a la placa según la imagen de referencia. Conecta el módulo de huella dactilar al puerto UART de la placa de expansión XIAO y el servo al puerto D0.

Ten en cuenta que el anillo NeoPixel está conectado directamente a los pines de la placa de desarrollo XIAO mediante tres cables de diferentes colores: conecta el pin DIN del anillo NeoPixel con el cable amarillo al pin D1 de la XIAO, conecta el pin VIN del anillo NeoPixel con el cable rojo al pin 3V3 de la XIAO y conecta el pin GND del anillo NeoPixel con el cable negro al pin GND de la XIAO.

Instrucciones para Arduino

Paso 1. Sigue la imagen de conexión para conectar todos los sensores a la placa.

Paso 2. Descarga el Arduino IDE.

Paso 3. Instala las bibliotecas u8g2, Servo, Seeed_Arduino_KCT202 y Seeed_LED_Ring. Aquí tienes una guía sobre cómo instalar una biblioteca.

Paso 4. Copia el código en el Arduino IDE y súbelo a la placa.

Demostración

Registrar tu huella digital
La pantalla mostrará un mensaje indicando que se está grabando la huella. Solo necesitas colocar tu dedo en el sensor, el programa analizará tu huella y completará el registro.

Autorización de identidad (verificación exitosa)

La pantalla mostrará "Please verify". Debes colocar tu dedo en el sensor de huellas dactilares y, si la verificación es exitosa, el anillo LED cambiará a color verde.

Autorización de identidad (verificación fallida)

Si otra persona coloca su dedo en el sensor, el anillo LED cambiará a color rojo y la pantalla mostrará "Identity deny", mientras que la alarma se activará.

Código

#include <Servo.h>
#include <Arduino.h>
#include <U8x8lib.h>
#include "ATSerial.h"
#include "Protocol.h"
#include "KCT202.h"
#include "Adafruit_NeoPixel.h"

#define PIXEL_PIN    2    // Digital IO pin connected to the NeoPixels.
#define PIXEL_COUNT 24
#define debug SerialUSB
#define uart  Serial1
FingerPrint_KCT202<Uart, Serial_> kct202;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

Servo myservo;

Protocol_oprt oprt;
uint8_t err_code = 0;
uint8_t param[10];
uint32_t param_len;
int pos = 0;
const int buttonPin = 1;
int buttonState = 0;
int BuzzerPin = A3;

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);

void setup(void) {
  Serial.begin(115200);
  strip.setBrightness(255);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
  colorWipe(strip.Color(125, 0, 125), 50);
  u8x8.begin();
  u8x8.setFlipMode(0);
  debug.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(BuzzerPin, OUTPUT);
  kct202.begin(uart, debug);
  myservo.attach(0);
  myservo.write(0);
  kct202.autoRegisterFingerPrint(1, 4, LED_OFF_AFTER_GET_GRAGH | PRETREATMENT_GRAGH | NOT_RET_FOR_EVERY_STEP | OVERRIDE_CURR_FINGER_PRINT);

  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 3);
  u8x8.print("finger recording");
  if (0 == kct202.getRegisterResponAndparse()) {
    debug.println("Register ok!");
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 3);
    u8x8.print("    be ready    ");
    delay(500);
    colorWipe(strip.Color(0, 125, 125), 50);
    u8x8.setCursor(0, 3);
    u8x8.print("   *** 3 ***    ");
    delay(500);
    u8x8.setCursor(0, 3);
    u8x8.print("   *** 2 ***    ");
    delay(500);
    u8x8.setCursor(0, 3);
    u8x8.print("   *** 1 ***    ");
    delay(500);
    u8x8.setCursor(0, 3);
    u8x8.print("   Registered");
    delay(800);
  }
}

void loop(void) {
  uint16_t finger_num = 0;

  kct202.autoVerifyFingerPrint(CHECK_ALL_FINGER_TEMP,
                               LED_OFF_AFTER_GET_GRAGH | PRETREATMENT_GRAGH | NOT_RET_FOR_EVERY_STEP);
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 3);
  u8x8.print(" Please verify  ");

  if (0 == kct202.getVerifyResponAndparse(finger_num)) {
    debug.println("Verify ok!");
    debug.print("Your finger temp id = ");
    debug.println(finger_num, HEX);
    colorWipe(strip.Color(0, 255, 30), 50);
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 3);
    u8x8.print("Identity comfirm");
    delay(800);

    analogWrite(BuzzerPin, 128);
    delay(100);
    analogWrite(BuzzerPin, 0);
    delay(100);
    analogWrite(BuzzerPin, 128);
    delay(100);
    analogWrite(BuzzerPin, 0);
    delay(100);

    for (pos = 0; pos <= 90; pos += 1) {
      myservo.write(pos);
      delay(15);
    }
    while (1) {
      //      pinMode(buttonPin, INPUT);
      buttonState = digitalRead(buttonPin);
      u8x8.setFont(u8x8_font_chroma48medium8_r);
      u8x8.setCursor(0, 3);
      u8x8.print("Please close    ");
      Serial.println(pos);
      Serial.println(buttonState);
      if (buttonState == LOW && pos == 91) {
        for (pos = 91; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
          u8x8.setFont(u8x8_font_chroma48medium8_r);
          u8x8.setCursor(0, 3);
          u8x8.print("Lock closing    ");
          myservo.write(pos);              // tell servo to go to position in variable 'pos'
          delay(15);                       // waits 15ms for the servo to reach the position
        }
        colorWipe(strip.Color(255, 0, 0), 50);
        break;
      }
    }
  }

  else {
    colorWipe(strip.Color(255, 0, 0), 50);
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 3);
    u8x8.print(" Identity deny ");
    //    myservo.write(0);
    delay(200);

  analogWrite(BuzzerPin, 250);
  delay(2000);
    analogWrite(BuzzerPin, 0);
  delay(100);

    u8x8.setCursor(0, 3);
    u8x8.print("  Please retry  ");
    delay(1500);
  }
}

void colorWipe(uint32_t c, uint8_t wait) {
  for (uint16_t i = 0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(70);
  }
}

Proyecto 4 - Seeed Studio Expansion Base para XIAO - mjolnir

Resumen

Este martillo simula el Mjolnir. Necesitarás registrar tu huella digital en el dispositivo para convertirte en su maestro. El martillo requiere un imán para adherirse al módulo Grove - electromagneto, y solo cuando su maestro desbloquee el dispositivo mediante huella digital, el martillo podrá ser retirado.

Componentes requeridos

Conexión del hardware

Conecta la placa de expansión y los módulos requeridos utilizando cables Grove. Conecta el módulo Grove electromagnético al puerto D0 y el módulo de huellas dactilares al puerto I2C.

Instrucciones para Arduino

Paso 1. Sigue la imagen de conexión para conectar todos los sensores en la placa.

Paso 2. Descarga el IDE de Arduino.

Paso 3. Instala las bibliotecas u8g2 y Seeed_Arduino_KCT202. Aquí está la guía cómo instalar la biblioteca.

Paso 4. Copia el código en el IDE de Arduino y luego súbelo a la placa.

Código

#include <U8x8lib.h>
#include "ATSerial.h"
#include "Protocol.h"
#include "KCT202.h"

#define debug SerialUSB
#define uart  Serial1
FingerPrint_KCT202<Uart, Serial_> kct202;

Protocol_oprt oprt;
uint8_t err_code = 0;
uint8_t param[10];
uint32_t param_len;

int Electromagnet = 0;

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);

// the setup routine runs once when you press reset:
void setup() {
  // initialize the digital pin as an output.

  u8x8.begin();
  u8x8.setFlipMode(0);
  debug.begin(115200);
  pinMode(Electromagnet, OUTPUT);
  digitalWrite(Electromagnet, HIGH);  // turn the Electromagnet on (HIGH is the voltage level)
  kct202.begin(uart, debug);
  kct202.autoRegisterFingerPrint(1, 4, LED_OFF_AFTER_GET_GRAGH | PRETREATMENT_GRAGH | NOT_RET_FOR_EVERY_STEP | OVERRIDE_CURR_FINGER_PRINT);
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 3);
  u8x8.print("finger recording");
  if (0 == kct202.getRegisterResponAndparse()) {
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 3);
    u8x8.print("    be ready    ");
    delay(500);
    u8x8.setCursor(0, 3);
    u8x8.print("   *** 3 ***    ");
    delay(500);
    u8x8.setCursor(0, 3);
    u8x8.print("   *** 2 ***    ");
    delay(500);
    u8x8.setCursor(0, 3);
    u8x8.print("   *** 1 ***    ");
    delay(500);
    u8x8.setCursor(0, 3);
    u8x8.print("   Registered");
    delay(800);
  }

}

  // the loop routine runs over and over again forever:
  void loop() {

    uint16_t finger_num = 0;
    kct202.autoVerifyFingerPrint(CHECK_ALL_FINGER_TEMP, LED_OFF_AFTER_GET_GRAGH | PRETREATMENT_GRAGH | NOT_RET_FOR_EVERY_STEP);
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 3);
    u8x8.print(" Please verify  ");

    if (0 == kct202.getVerifyResponAndparse(finger_num)) {
      u8x8.setFont(u8x8_font_chroma48medium8_r);
      u8x8.setCursor(0, 3);
      u8x8.print("Identity comfirm");
      delay(800);
      digitalWrite(Electromagnet, LOW);  // turn the Electromagnet on (HIGH is the voltage level)
      delay(5000);
      digitalWrite(Electromagnet, HIGH);
    }

    else {
      u8x8.setFont(u8x8_font_chroma48medium8_r);
      u8x8.setCursor(0, 3);
      u8x8.print(" Identity deny ");
      //    myservo.write(0);
      delay(200);

      u8x8.setCursor(0, 3);
      u8x8.print("  Please retry  ");
      delay(1500);
      digitalWrite(Electromagnet, HIGH);  // turn the Electromagnet on (HIGH is the voltage level)

    }
  }

Proyecto 5 - Hub de Sensor de Calidad del Aire - Seeed Studio Expansion Base para XIAO

Visión general

Este es un dispositivo de detección de ambiente para recolectar PM2.5, PM10, temperatura, humedad, CO2 y partículas de polvo a través del Grove - Sensor Láser PM2.5, el Grove - Sensor de CO2, Temperatura y Humedad y el Grove - Sensor de polvo, respectivamente.

Componentes requeridos

Conexión de Hardware

Conecta cada sensor como se muestra en el diagrama. Conecta el sensor de CO2 y el sensor PM2.5 a dos puertos I2C respectivamente, y conecta el sensor de polvo al puerto UART.

Instrucciones para Arduino

Paso 1. Sigue el diagrama de conexión para conectar todos los sensores en la placa.

Paso 2. Descarga el IDE de Arduino.

Paso 3. Instala las bibliotecas u8g2, Seeed_PM2_5_sensor_HM3301 y Seeed_SCD30, esta es la guía cómo instalar la biblioteca.

Paso 4. Copia el código en el IDE de Arduino y luego súbelo.

Código

#include <Arduino.h>
#include <U8x8lib.h>
#include <Seeed_HM330X.h>
#include "SCD30.h"

#define SERIAL_OUTPUT SerialUSB
#define SERIAL SerialUSB

int pin = 7;
unsigned long duration;
unsigned long starttime;
unsigned long sampletime_ms = 5000;//sampe 30s ;
unsigned long lowpulseoccupancy = 0;
float ratio = 0;
float concentration = 0;

const int buttonPin = 1;
int buttonState = 0;
int memu = 0;

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
HM330X sensor;
uint8_t buf[30];

const char* str[] = {"sensor num: ", "PM1.0 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
                     "PM2.5 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
                     "PM10 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
                     "PM1.0 concentration(Atmospheric environment,unit:ug/m3): ",
                     "PM2.5 concentration(Atmospheric environment,unit:ug/m3): ",
                     "PM10 concentration(Atmospheric environment,unit:ug/m3): ",
                    };


///////////////////////////////////////////////////////////////////
//PM2.5 concentration(Atmospheric environment,unit:ug/m3): value
///////////////////////////////////////////////////////////////////
HM330XErrorCode print_result(const char* str, uint16_t value) {
  if (NULL == str) {
    return ERROR_PARAM;
  }
  //  SERIAL_OUTPUT.print(str);
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 0);
  u8x8.print("PM2.5: ");
  u8x8.setCursor(7, 0);
  u8x8.print(value);
  u8x8.setCursor(11, 0);
  u8x8.print("ug/m");
  Serial.println(value);
  return NO_ERROR;
}

HM330XErrorCode print_result_1(const char* str, uint16_t value) {
  if (NULL == str) {
    return ERROR_PARAM;
  }
  //  SERIAL_OUTPUT.print(str);
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 0);
  u8x8.print("PM10: ");
  u8x8.setCursor(7, 0);
  u8x8.print(value);
  u8x8.setCursor(11, 0);
  u8x8.print("ug/m");
  Serial.println(value);
  return NO_ERROR;
}

/*parse buf with 29 uint8_t-data*/
HM330XErrorCode parse_result(uint8_t* data) {
  uint16_t value = 0;
  if (NULL == data) {
    return ERROR_PARAM;
  }
  value = (uint16_t) data[6 * 2] << 8 | data[6 * 2 + 1];
  print_result(str[6 - 1], value);
  return NO_ERROR;
}


HM330XErrorCode parse_result2(uint8_t* data) {
  uint16_t value = 0;
  if (NULL == data) {
    return ERROR_PARAM;
  }
  value = (uint16_t) data[7 * 2] << 8 | data[7 * 2 + 1];
  print_result_1(str[7 - 1], value);
  return NO_ERROR;
}

////////////////////////////////////////////////////////////////////

/*30s*/
void setup() {
  Serial.begin(115200);
  Wire.begin();
  u8x8.begin();
  u8x8.setFlipMode(0);
  scd30.initialize();
  pinMode(pin, INPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  starttime = millis();//get the current time;

}

void loop() {
  float result[3] = {0};
  duration = pulseIn(pin, LOW);
  lowpulseoccupancy = lowpulseoccupancy + duration;

  buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {
    memu++;
    delay(15);
    if (memu == 2) {
      memu = 0;
    }
  }
  Serial.println(memu);

  if (scd30.isAvailable() && memu == 0) {
    scd30.getCarbonDioxideConcentration(result);
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 3);
    u8x8.print("CO2: ");
    u8x8.setCursor(5, 3);
    u8x8.print(result[0]);
    u8x8.setCursor(12, 3);
    u8x8.print("pmm");
    delay(1000);
  }

  if (sensor.read_sensor_value(buf, 29) && memu == 0) {
    SERIAL_OUTPUT.println("HM330X read result failed!!!");
  }
  if(memu == 0){
  parse_result(buf);
  }

  if ((millis() - starttime) > sampletime_ms  && memu == 0) {
    ratio = lowpulseoccupancy / (sampletime_ms * 10.0); // Integer percentage 0=>100
    concentration = 1.1 * pow(ratio, 3) - 3.8 * pow(ratio, 2) + 520 * ratio + 0.62; // using spec sheet curve

    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 6);
    u8x8.print("Dust: ");

    u8x8.setCursor(6, 6);
    u8x8.print(concentration);

    u8x8.setCursor(12, 6);
    u8x8.print("pcs");

    //    Serial.println(concentration);
    lowpulseoccupancy = 0;
    starttime = millis();
  }



  if (scd30.isAvailable() && memu == 1) {
    scd30.getCarbonDioxideConcentration(result);
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 3);
    u8x8.print("Temp: ");
    u8x8.setCursor(6, 3);
    u8x8.print(result[1]);
    u8x8.setCursor(10, 3);
    u8x8.print(" C   ");

    u8x8.setCursor(0, 6);
    u8x8.print("Humi: ");
    u8x8.setCursor(5, 6);
    u8x8.print(result[2]);
    u8x8.setCursor(8, 6);
    u8x8.print("  %     ");

    delay(1000);
  }

  if (sensor.read_sensor_value(buf, 29) && memu == 1) {
    SERIAL_OUTPUT.println("HM330X read result failed!!!");
  }
  if(memu == 1){
  parse_result2(buf);
  }
}

Proyecto 6 - Seeed Studio Expansion Base para XIAO - Frecuencia Cardíaca

Descripción general

Este proyecto simple y económico está basado en la Seeed Studio Expansion Base para XIAO para reportar la frecuencia cardíaca. El dispositivo utilizado tiene una interfaz I2C de dos cables, por lo que mantiene el cableado al mínimo.

Componentes requeridos

Conexión de Hardware

Como se muestra en la figura a continuación, conecta el sensor de frecuencia cardíaca a la interfaz I2C de la placa de expansión XIAO.

Instrucciones para Arduino

Paso 1. Sigue el diagrama de conexión para conectar todos los sensores en la placa.

Paso 2. Descarga el IDE de Arduino.

Paso 3. Instala la biblioteca u8g2, esta es la guía cómo instalar la biblioteca.

Paso 4. Copia el código en el IDE de Arduino y luego súbelo.

Código

#include <Arduino.h>
#include <U8x8lib.h>

#include <Wire.h>

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);

void setup() {
  Serial.begin(9600);
  Serial.println("heart rate sensor:");

  u8x8.begin();
  u8x8.setFlipMode(1);
  Wire.begin();
}
void loop() {
  Wire.requestFrom(0xA0 >> 1, 1);    // request 1 bytes from slave device
  while (Wire.available()) {         // slave may send less than requested
    unsigned char c = Wire.read();   // receive heart rate value (a byte)
    u8x8.setFont(u8x8_font_chroma48medium8_r);
//    u8x8.setCursor(0, 3);
//    u8x8.print("blood detecting ");
//    delay(10000);

    u8x8.setCursor(0, 3);
    u8x8.print("HeartRate: ");
    u8x8.setCursor(10, 3);
    u8x8.print(c);
    u8x8.setCursor(13, 3);
    u8x8.print("bpm");
    Serial.println(c);

  }
  delay(500);
}

Recursos

[PDF]ETA1038
[PDF]ETA3410
[PDF]ETA6003
[PDF]PCF8563T
[PDF]Seeed Studio Expansion Base for XIAO_v1.0_SCH_200824
[SCH]Seeed Studio Expansion Base for XIAO_v1.0_200824
[BRD]Seeed Studio Expansion Base for XIAO_v1.0_200824

Preguntas Frecuentes

P1: ¿El PMIC en la placa de expansión XIAO proporciona energía en los pines de 5V?

El PMIC no proporciona energía; los 5V se toman directamente del USB. La corriente disponible en el pin de 5V es equivalente a la corriente que proporciona la conexión USB.

Soporte Técnico y Discusión sobre el Producto

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

Descripción general​

Características​

Especificación​

Aplicaciones​

Lista de piezas​

Empezando​

Materiales requeridos​

Descripción general del hardware​

Diagrama de Pinout​

Uso de la Placa de Expansión​

Conexión​

Uso de la batería​

Módulos en la placa de expansión​

Display OLED​

Control de LED por botón de usuario​

Buzzer​

Reproducir canción con Buzzer pasivo​

Control de Servo mediante Sensor de Ángulo Rotatorio​

Display del reloj RTC​

Función de tarjeta SD​

Carcasa de acrílico para Seeed Studio Expansion Base para XIAO​

CircuitPython en Seeed Studio XIAO SAMD21 con placa de expansión​

Instalación de CircuitPython​

Ejemplo de CircuitPython: Blink​

Tarjeta MicroSD para CircuitPython​

Demostración​

Proyecto 1 - Ventilador controlado a distancia​

Proyecto 2 - Coche controlado a distancia​

Proyecto 3 - Desbloqueo de caja del tesoro con huella dactilar - Seeed Studio XIAO​

Instrucciones para Arduino​

Demostración​

Proyecto 4 - Seeed Studio Expansion Base para XIAO - mjolnir​

Proyecto 6 - Seeed Studio Expansion Base para XIAO - Frecuencia Cardíaca​

Recursos​

Preguntas Frecuentes​

P1: ¿El PMIC en la placa de expansión XIAO proporciona energía en los pines de 5V?​

Soporte Técnico y Discusión sobre el Producto​

Descripción general

Características

Especificación

Aplicaciones

Lista de piezas

Empezando

Materiales requeridos

Descripción general del hardware

Diagrama de Pinout

Uso de la Placa de Expansión

Conexión

Uso de la batería

Módulos en la placa de expansión

Display OLED

Control de LED por botón de usuario

Buzzer

Reproducir canción con Buzzer pasivo

Control de Servo mediante Sensor de Ángulo Rotatorio

Display del reloj RTC

Función de tarjeta SD

Carcasa de acrílico para Seeed Studio Expansion Base para XIAO

CircuitPython en Seeed Studio XIAO SAMD21 con placa de expansión

Instalación de CircuitPython

Ejemplo de CircuitPython: Blink

Tarjeta MicroSD para CircuitPython

Demostración

Proyecto 1 - Ventilador controlado a distancia

Proyecto 2 - Coche controlado a distancia

Proyecto 3 - Desbloqueo de caja del tesoro con huella dactilar - Seeed Studio XIAO

Instrucciones para Arduino

Demostración

Proyecto 4 - Seeed Studio Expansion Base para XIAO - mjolnir

Proyecto 6 - Seeed Studio Expansion Base para XIAO - Frecuencia Cardíaca

Recursos

Preguntas Frecuentes

P1: ¿El PMIC en la placa de expansión XIAO proporciona energía en los pines de 5V?

Soporte Técnico y Discusión sobre el Producto