Multiplexación de pines con Seeed Studio XIAO ESP32-S3 (Sense)
| Seeed Studio XIAO ESP32-S3 | Seeed Studio XIAO ESP32-S3 Sense |
|---|---|
 |  |
La Seeed Studio XIAO ESP32-S3 es una placa de desarrollo potente y versátil que incorpora una variedad de interfaces periféricas y pines GPIO. Estos pines se pueden utilizar para diversos fines, como comunicarse con otros dispositivos, leer sensores analógicos, controlar LEDs y más. En este tutorial, exploraremos el pinout de la XIAO ESP32-S3 y su placa relacionada, la XIAO ESP32-S3 Sense, y aprenderemos cómo utilizar estos pines para diferentes propósitos. En concreto, cubriremos el uso de 1x UART, 1x IIC, 1x IIS, 1x SPI, 11x GPIO (PWM), 9x ADC, 1x LED de usuario, 1x LED de carga, 1x botón de reinicio, 1x botón de arranque y, para la XIAO ESP32-S3 Sense, 1x conector B2B (con 2 GPIO adicionales). Al final de este tutorial, tendrás una buena comprensión del pinout de la XIAO ESP32-S3 y podrás utilizarla de forma eficaz en tus proyectos.
Introducción
Visión general del pinout
Antes de comenzar, revisemos todos los pines que tiene la XIAO ESP32-S3 y sus funciones con el siguiente esquema.
| Diagrama de indicación frontal de XIAO ESP32-S3/XIAO ESP32-S3 Sense |
|---|
 |
| Diagrama de indicación trasera de XIAO ESP32-S3/XIAO ESP32-S3 Sense |
 |
| Lista de pines de XIAO ESP32-S3/XIAO ESP32-S3 Sense |
 |
Aunque la XIAO ESP32-S3 asigna GPIO41 y GPIO42 a los pines A11 y A12, debido a la naturaleza del chip ESP32-S3, los pines A11 y A12 no admiten la funcionalidad ADC. Asegúrate de distinguirlos y diferenciarlos.
-
5V - Esta es la salida de 5 V desde el puerto USB. También puedes usarla como entrada de tensión, pero debes tener algún tipo de diodo (Schottky, de señal, de potencia) entre tu fuente de alimentación externa y este pin, con el ánodo a la batería y el cátodo al pin de 5 V.
-
3V3 - Esta es la salida regulada del regulador integrado. Puedes extraer 700 mA
-
GND - Tierra de alimentación/datos/señal
A continuación se muestra una visión general de los pines funcionales de la XIAO ESP32-S3.
| Número de pin | Descripción de la función |
|---|---|
| -- Pines del micrófono PDM -- | |
| GPIO 41 | Datos del micrófono PDM |
| GPIO 42 | CLK del micrófono PDM |
| -- Pines SPI de la tarjeta MicroSD -- | |
| GPIO 21 | MicroSD SPI CS |
| D8 / A8 / Qt7 / GPIO7 | MicroSD SPI SCK |
| D9 / A9 / Qt8 / GPIO8 | MicroSD SPI MISO |
| D10 / A10 / Qt9 / GPIO9 | MicroSD SPI MOSI |
| -- Pines de la cámara -- | |
| GPIO 10 | XMCLK |
| GPIO 11 | DVP_Y8 |
| GPIO 12 | DVP_Y7 |
| GPIO 13 | DVP_PCLK |
| GPIO 14 | DVP_Y6 |
| GPIO 15 | DVP_Y2 |
| GPIO 16 | DVP_Y5 |
| GPIO 17 | DVP_Y3 |
| GPIO 18 | DVP_Y4 |
| GPIO 38 | DVP_VSYNC |
| GPIO 39 | SCL de la cámara |
| GPIO 40 | SDA de la cámara |
| GPIO 47 | DVP_HREF |
| GPIO 48 | DVP_Y9 |
Soldar el header
Para utilizar las funciones de cada pin según este tutorial, recomendamos soldar los pines de antemano.
Debido al tamaño miniatura de la XIAO ESP32-S3, ten cuidado al soldar los headers, no juntes pines diferentes y no dejes que la soldadura toque el blindaje u otros componentes. De lo contrario, puede provocar que la XIAO se cortocircuite o no funcione correctamente, y las consecuencias derivadas de ello serán asumidas por el usuario.
Si has elegido la versión Sense, ¡enhorabuena! Tendrás dos pines GPIO adicionales. Si planeas utilizarlos, puedes soldar un header independiente en ellos.
Digital
La XIAO ESP32-S3 tiene hasta 11 pines GPIO normales y 9 pines analógicos. En este ejemplo, utilizaremos la XIAO ESP32-S3, la placa de expansión XIAO y un relé para demostrar cómo usar diferentes pines digitales para lectura y escritura.
Preparación de hardware
| Seeed Studio XIAO ESP32-S3 | Seeed Studio XIAO ESP32-S3 Sense | Base de expansión Seeed Studio para XIAO con Grove OLED | Grove - Relay |
|---|---|---|---|
| |  |  |
Instala XIAO ESP32-S3 o Sense en la placa de expansión y conecta el relé a la interfaz A0/D0 de la placa de expansión mediante un cable Grove. Por último, conecta la XIAO al ordenador mediante un cable USB-C.
Implementación de software
En este ejemplo, implementaremos el control del estado de encendido/apagado de un relé utilizando un botón conectado a la placa de expansión XIAO. Cuando se pulsa el botón, el relé se enciende y, cuando se suelta el botón, el relé se apaga.
const int buttonPin = D1; // the number of the pushbutton pin
int buttonState = 0; // variable for reading the pushbutton status
const int relayPin = D0;
void setup() {
// initialize the Relay pin as an output:
pinMode(relayPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT_PULLUP);
}
void loop() {
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed. If it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn Relay on:
digitalWrite(relayPin, HIGH);
} else {
// turn Relay off:
digitalWrite(relayPin, LOW);
}
}
Si todo va bien, después de cargar el programa, deberías ver el siguiente efecto.
Si quieres usar la función digital, entonces debes usar la letra "D" como prefijo para el número de pin, como D4, D5. Por el contrario, si quieres usar la función analógica de un pin, debes usar la letra "A" como prefijo para el número de pin, como A4, A5.
Para la versión Sense
Para XIAO ESP32-S3 Sense, además de usar los 11 pines digitales en XIAO, también puedes usar los dos pines en la placa de expansión, que son D11 y D12. Si quieres usarlos, sigue los pasos a continuación.
Paso 1. Corta la conexión entre J1 y J2
Debido al número limitado de pines en el ESP32-S3, D11 y D12 en la placa de expansión Sense están reservados para el micrófono de forma predeterminada. Si realmente necesitas usar D11 y D12 para otros fines, puedes voltear la placa de expansión Sense y cortar la conexión entre J1 y J2 a lo largo de la línea blanca entre las dos almohadillas de soldadura usando un cuchillo afilado.
Como se puede ver en la imagen, debido a las limitaciones de espacio de XIAO, muchas trazas de cableado son muy compactas. Por lo tanto, al cortar la conexión entre J1 y J2, ten mucho cuidado de no cortar fuera de la línea blanca, ¡de lo contrario puede causar un mal funcionamiento de la placa de desarrollo!
Aunque el XIAO ESP32-S3 asigna GPIO41 y GPIO42 a los pines A11 y A12, debido a la naturaleza del chip ESP32-S3, los pines A11 y A12 no soportan la funcionalidad ADC. Asegúrate de distinguirlos y diferenciarlos.
Después de cortar la conexión entre J1 y J2, la función de micrófono en la placa de expansión ya no estará disponible. Si necesitas usar la función de micrófono, los pines D11 y D12 no se pueden usar simultáneamente. En este caso, puedes soldar por separado las dos almohadillas de J1 y J2 para restaurar la función de micrófono. Como se muestra en la imagen de abajo, suelda por separado las áreas roja y verde.
Para el esquema del circuito real, consulta el siguiente diagrama:
Paso 2. Preparación de hardware
| Seeed Studio XIAO ESP32-S3 Sense | Grove - Relay |
|---|---|
| |
Paso 3. Implementación de software
El siguiente programa conmuta el relé cada 500 milisegundos. Conecta el pin SIG del relé a la interfaz GPIO42 de la placa de expansión.
const int relayPin = 42;
void setup() {
// initialize the Relay pin as an output:
pinMode(relayPin, OUTPUT);
}
void loop() {
// turn Relay on:
digitalWrite(relayPin, HIGH);
delay(500);
// turn Relay off:
digitalWrite(relayPin, LOW);
delay(500);
}
El método anterior también es aplicable a las secciones Digital as PWM y Analog. Solo necesitas modificar los números de pin de la placa de expansión que quieras usar. Esto no se repetirá más adelante.
Para los dos pines adicionales D11 y D12 en el XIAO ESP32-S3 Sense, no hemos definido aún macros para los pines. Es decir, todavía no puedes usar D11/A11 o D12/A12 para controlar estos dos pines, pero puedes controlar estos dos pines usando los números GPIO, GPIO42 y GPIO41, respectivamente. Presentaremos las definiciones de macros para estos dos pines tan pronto como sea posible, y una vez que se complete el envío, entonces podrás usar las definiciones de pin D/A.
Digital como PWM
Todos los pines GPIO en XIAO ESP32-S3 soportan salida PWM. Por lo tanto, puedes usar cualquier pin para sacar PWM para ajustar el brillo de las luces, controlar servos y otras funciones.
Preparación de hardware
| Seeed Studio XIAO ESP32-S3 | Seeed Studio XIAO ESP32-S3 Sense | Seeed Studio Expansion Base for XIAO with Grove OLED | Grove - Variable Color LED |
|---|---|---|---|
| | |  |
Instala XIAO ESP32-S3 o Sense en la placa de expansión, luego conecta el Variable Color LED a la interfaz A0/D0 de la placa de expansión usando un cable Grove. Finalmente, conecta XIAO a tu ordenador mediante un cable USB-C.
Implementación de software
En este ejemplo, demostraremos cómo usar la salida PWM para controlar el brillo de una luz.
int LED_pin = D0; // LED connected to digital pin 10
void setup() {
// declaring LED pin as output
pinMode(LED_pin, OUTPUT);
}
void loop() {
// fade in from min to max in increments of 5 points:
for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) {
// sets the value (range from 0 to 255):
analogWrite(LED_pin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
// fade out from max to min in increments of 5 points:
for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {
// sets the value (range from 0 to 255):
analogWrite(LED_pin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
}
Si el programa se ejecuta correctamente, verás el siguiente efecto de funcionamiento.
Analógico
En XIAO ESP32-S3, entre los 11 pines GPIO integrados, excepto los pines D6 y D7 usados para comunicación serie, los 9 pines restantes soportan la función analógica. Puedes usar estos pines GPIO con funcionalidad analógica para leer valores de sensores que producen señales analógicas, como sensores de oxígeno, sensores de intensidad de luz, etc.
Aunque el XIAO ESP32-S3 asigna GPIO41 y GPIO42 a los pines A11 y A12, debido a la naturaleza del chip ESP32-S3, los pines A11 y A12 no soportan la funcionalidad ADC. Asegúrate de distinguirlos y diferenciarlos.
Preparación de hardware
| Seeed Studio XIAO ESP32-S3 | Seeed Studio XIAO ESP32-S3 Sense | Seeed Studio Expansion Base for XIAO with Grove OLED | Grove - Oxygen Sensor |
|---|---|---|---|
| | |  |
Instala XIAO ESP32-S3 o Sense en la placa de expansión, luego conecta el sensor de oxígeno a la interfaz A0/D0 de la placa de expansión con el cable Grove. Finalmente, conecta el XIAO al ordenador mediante un cable USB-C.
Implementación de software
En el siguiente programa, utilizaremos el método analogRead() para leer el valor analógico del sensor y, usando la interfaz Serial, imprimiremos el resultado del sensor.
// Grove - Gas Sensor(O2) test code
// Note:
// 1. It need about about 5-10 minutes to preheat the sensor
// 2. uncomment the module name you're using
// 3. modify VRefer if needed
// comment useless one
// #define MIX8410
#define O2_W2
#ifdef MIX8410
#define O2_COEFFICIENT 0.21
#elif defined(O2_W2)
#define O2_COEFFICIENT 0.087
#endif
const float VRefer = 3.34; // voltage of adc reference
const int pinAdc = A0;
void setup()
{
// put your setup code here, to run once:
Serial.begin(9600);
Serial.println("Grove - Oxygen Sensor(MIX8410) Test Code...");
}
void loop()
{
// put your main code here, to run repeatedly:
float Vout =0;
Serial.print("Vout =");
Vout = readO2Vout();
Serial.print(Vout);
Serial.print(" V, Concentration of O2 is ");
Serial.println(readConcentration());
delay(500);
}
float readO2Vout()
{
long sum = 0;
for(int i=0; i<32; i++)
{
sum += analogRead(pinAdc);
}
sum >>= 5;
float MeasuredVout = sum * (VRefer / 1023.0);
return MeasuredVout;
}
float readConcentration()
{
// Vout samples are with reference to 3.3V
float MeasuredVout = readO2Vout();
//float Concentration = FmultiMap(MeasuredVout, VoutArray,O2ConArray, 6);
//when its output voltage is 2.0V,
float Concentration = MeasuredVout * O2_COEFFICIENT / 2.0;
float Concentration_Percentage=Concentration*100;
return Concentration_Percentage;
}
Si quieres utilizar la función analógica de un pin, debes usar la letra "A" como prefijo para el número de pin, como A4, A5. Por el contrario, si quieres utilizar la función digital, entonces debes usar la letra "D" como prefijo para el número de pin, como D4, D5.
Después de cargar el programa, abre el monitor serie en Arduino IDE y ajusta la velocidad en baudios a 9600. Espera a que el sensor de oxígeno se caliente y entonces podrás ver el valor preciso de la concentración de oxígeno.
Serial
Al trabajar con Arduino IDE, la comunicación Serial es una parte esencial de muchos proyectos. Para usar Serial en Arduino IDE, primero debes abrir la ventana del monitor serie. Esto se puede hacer haciendo clic en el icono Serial Monitor en la barra de herramientas o presionando la combinación de teclas Ctrl+Shift+M.
Uso general
Algunas de las funciones Serial más utilizadas incluyen:
Serial.begin()-- que inicializa la comunicación a una velocidad en baudios especificada;Serial.print()-- que envía datos al puerto serie en un formato legible;Serial.write()-- que envía datos binarios al puerto serie;Serial.available()-- que comprueba si hay datos disponibles para ser leídos desde el puerto serie;Serial.read()-- que lee un solo byte de datos desde el puerto serie;Serial.flush()-- que espera a que se complete la transmisión de los datos serie salientes.
Al usar estas funciones Serial, puedes enviar y recibir datos entre la placa Arduino y tu ordenador, lo que abre muchas posibilidades para crear proyectos interactivos.
Aquí hay un programa de ejemplo:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}
void loop() {
// send data to the serial port
Serial.println("Hello World!");
// read data from the serial port
if (Serial.available() > 0) {
// read the incoming byte:
char incomingByte = Serial.read();
// print the incoming byte to the serial monitor:
Serial.print("I received: ");
Serial.println(incomingByte);
}
// wait for a second before repeating the loop
delay(1000);
}
En este código, primero inicializamos la comunicación Serial a una velocidad en baudios de 9600 usando la función Serial.begin() en la función setup(). Luego, en la función loop(), usamos la función Serial.print() para enviar "Hello World!" al puerto serie.
También usamos la función Serial.available() para comprobar si hay datos disponibles para ser leídos desde el puerto serie. Si los hay, leemos el byte entrante usando la función Serial.read() y lo almacenamos en una variable llamada incomingByte. Luego usamos las funciones Serial.print() y Serial.println() para imprimir "I received: " seguido del valor de incomingByte en el monitor serie.
Finalmente, añadimos una función delay() para esperar un segundo antes de repetir el bucle. Este código demuestra cómo usar algunas de las funciones Serial más comunes en Arduino IDE para enviar y recibir datos a través del puerto serie.
Después de cargar el programa, abre el monitor serie en Arduino IDE y ajusta la velocidad en baudios a 9600. Verás el siguiente mensaje en el monitor serie, que muestra 'Hello World!' cada segundo. Además, puedes enviar contenido al XIAO ESP32-S3 a través del monitor serie, y XIAO imprimirá cada byte del contenido que envíes.
Uso de Serial1
De acuerdo con los diagramas de pines anteriores de XIAO ESP32-S3 para parámetros específicos, podemos observar que hay un pin TX y un pin RX. Esto es diferente de la comunicación serie estándar, pero el uso también es muy similar, excepto que es necesario añadir algunos parámetros. Así que, a continuación, utilizaremos los pines sacados por el chip para la comunicación serie.
Función principal que debe incluirse:
Serial1.begin(BAUD,SERIAL_8N1,RX_PIN,TX_PIN);-- habilita Serial1, el prototipo de la función es:<Serial.Type>.begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin);baud:velocidad en baudiosconfig:bit de configuraciónrxPin:pin de recepcióntxPin:pin de envío
Cabe destacar que si usamos el puerto de pin digital para definir, este lugar debería ser #define RX_PIN D7、#define TX_PIN D6, si usamos el puerto de pin GPIO para definir, este lugar debería ser #define RX_PIN 44、#define TX_PIN 43, por favor consulta los diagramas de pines de las diferentes XIAO Serie para parámetros específicos.
Aquí hay un programa de ejemplo:
#define RX_PIN D7
#define TX_PIN D6
#define BAUD 115200
void setup() {
Serial1.begin(BAUD,SERIAL_8N1,RX_PIN,TX_PIN);
}
void loop() {
if(Serial1.available() > 0)
{
char incominByte = Serial1.read();
Serial1.print("I received : ");
Serial1.println(incominByte);
}
delay(1000);
}
Después de cargar el programa, abre el monitor serie en Arduino IDE y ajusta la velocidad en baudios a 115200. Entonces podrás enviar el contenido que quieras al XIAO ESP32-S3 a través del monitor serie Serial, y XIAO imprimirá cada byte del contenido que envíes. Aquí, el contenido que introduje es "Hello Everyone", mi gráfico de resultados es el siguiente.
Uso de Software Serial
Si sientes que un puerto serie por hardware no es suficiente, también puedes usar la función de software serial del ESP32 para configurar algunos pines como puerto serie por software y así ampliar el número de puertos serie.
Por supuesto, recomendamos usar el segundo método de asignar puertos serie por hardware, ya que es una característica única del ESP32. Puedes leer más al respecto en la sección Other Hardware Serial.
Para los productos de la serie de chips ESP32, si necesitas usar el puerto serie por software, debes descargar por separado la biblioteca de puerto serie por software de terceros. Aquí se proporciona una referencia.
Actualmente recomendamos la versión 7.0.0 de la biblioteca EspSoftwareSerial. Otras versiones pueden tener distintos grados de problemas que impidan que el puerto serie por software funcione correctamente.
Dado que has descargado la biblioteca en formato zip, abre tu Arduino IDE y 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. Esto significa que la biblioteca se ha instalado correctamente.
A continuación, ya puedes usar el puerto serie por software del ESP32.
Si tienes instaladas en tu ordenador otras bibliotecas de puerto serie por software, es probable que causen un conflicto, así que compruébalo por tu cuenta.
#include <SoftwareSerial.h>
SoftwareSerial mySerial(2, 3); // RX, TX
void setup() {
// initialize serial communication
Serial.begin(9600);
while (!Serial);
// initialize software serial
mySerial.begin(9600);
}
void loop() {
// read data from software serial
if (mySerial.available()) {
char data = mySerial.read();
Serial.print("Received data: ");
Serial.println(data);
}
// write data to software serial
mySerial.print("Hello World!");
// wait for a second before repeating the loop
delay(1000);
}
En este programa, primero incluimos la biblioteca SoftwareSerial.h para usar el puerto serie por software. Luego, creamos un nuevo objeto SoftwareSerial llamado mySerial usando los pines 2 y 3 como RX y TX, respectivamente.
En la función setup(), inicializamos tanto el puerto serie por hardware (Serial.begin()) como el puerto serie por software (mySerial.begin()).
En la función loop(), usamos la función mySerial.available() para comprobar si hay algún dato disponible para ser leído desde el puerto serie por software. Si lo hay, leemos el byte entrante usando la función mySerial.read() y lo almacenamos en una variable llamada data. Luego usamos las funciones Serial.print() y Serial.println() para imprimir "Received data: " seguido del valor de data en el puerto serie por hardware.
También usamos la función mySerial.print() para escribir "Hello World!" en el puerto serie por software. Esto enviará los datos desde la XIAO al dispositivo conectado al puerto serie por software.
Por último, añadimos una función delay() para esperar un segundo antes de repetir el bucle.
Ten en cuenta que, para usar el puerto serie por software en el ESP32-S3, debes seleccionar los pines adecuados para RX y TX que no se utilicen para ningún otro propósito. En este ejemplo, hemos usado los pines 9 y 10 para RX y TX, respectivamente.
Otro hardware serial
El ESP32S3 tiene un total de tres interfaces de comunicación UART, numeradas de 0 a 2, que son UART0, UART1 y UART2. Los pines de estos tres puertos serie no son fijos y se pueden reasignar a cualquier puerto IO.
Por defecto, no usamos UART0 ya que se utiliza para la comunicación serie por USB. Puedes usar otros puertos serie por hardware personalizando el mapeo del hardware serial.
// Need this for the lower level access to set them up.
#include <HardwareSerial.h>
//Define two Serial devices mapped to the two internal UARTs
HardwareSerial MySerial0(0);
HardwareSerial MySerial1(1);
void setup()
{
// For the USB, just use Serial as normal:
Serial.begin(115200);
// Configure MySerial0 on pins TX=D6 and RX=D7 (-1, -1 means use the default)
MySerial0.begin(9600, SERIAL_8N1, -1, -1);
MySerial0.print("MySerial0");
// And configure MySerial1 on pins RX=D9, TX=D10
MySerial1.begin(115200, SERIAL_8N1, D9, D10);
MySerial1.print("MySerial1");
}
void loop()
{
}
A continuación, tomaremos como ejemplo el 60GHz mmWave Sensor - Human Resting Breathing and Heartbeat Module, que está disponible para la venta, y explicaremos cómo usar los puertos serie por hardware D9 y D10 y el puerto serie USB.
Por favor, prepárate con lo siguiente.
| Seeed Studio XIAO ESP32-S3 | Seeed Studio XIAO ESP32-S3 Sense | Sensor mmWave de 60GHz - Módulo de respiración en reposo y latido cardíaco humano |
|---|---|---|
| |  |
Descarga la biblioteca del sensor en tu ordenador y añádela al Arduino IDE.
Aquí queremos analizar la información de los datos de latido cardíaco y respiración, así que puedes reescribir tu programa de la siguiente manera.
#include "Arduino.h"
#include <60ghzbreathheart.h>
#include <HardwareSerial.h>
HardwareSerial MySerial(0); //Create a new HardwareSerial class -- D6/D7
// can also try hardware serial with
BreathHeart_60GHz radar = BreathHeart_60GHz(&MySerial);
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
MySerial.begin(115200, SERIAL_8N1, 9, 10); // at CPU Freq is 40MHz, work half speed of defined.
while(!Serial); //When the serial port is opened, the program starts to execute.
Serial.println("Readly");
// radar.ModeSelect_fuc(1); //1: indicates real-time transmission mode, 2: indicates sleep state mode.
//After setting the mode, if you do not see data returned, you may need to re-power the sensor.
}
void loop()
{
// put your main code here, to run repeatedly:
radar.Breath_Heart(); //Breath and heartbeat information output
if(radar.sensor_report != 0x00){
switch(radar.sensor_report){
case HEARTRATEVAL:
Serial.print("Sensor monitored the current heart rate value is: ");
Serial.println(radar.heart_rate, DEC);
Serial.println("----------------------------");
break;
case HEARTRATEWAVE: //Valid only when real-time data transfer mode is on
Serial.print("The heart rate waveform(Sine wave) -- point 1: ");
Serial.print(radar.heart_point_1);
Serial.print(", point 2 : ");
Serial.print(radar.heart_point_2);
Serial.print(", point 3 : ");
Serial.print(radar.heart_point_3);
Serial.print(", point 4 : ");
Serial.print(radar.heart_point_4);
Serial.print(", point 5 : ");
Serial.println(radar.heart_point_5);
Serial.println("----------------------------");
break;
case BREATHNOR:
Serial.println("Sensor detects current breath rate is normal.");
Serial.println("----------------------------");
break;
case BREATHRAPID:
Serial.println("Sensor detects current breath rate is too fast.");
Serial.println("----------------------------");
break;
case BREATHSLOW:
Serial.println("Sensor detects current breath rate is too slow.");
Serial.println("----------------------------");
break;
case BREATHNONE:
Serial.println("There is no breathing information yet, please wait...");
Serial.println("----------------------------");
break;
case BREATHVAL:
Serial.print("Sensor monitored the current breath rate value is: ");
Serial.println(radar.breath_rate, DEC);
Serial.println("----------------------------");
break;
case BREATHWAVE: //Valid only when real-time data transfer mode is on
Serial.print("The breath rate waveform(Sine wave) -- point 1: ");
Serial.print(radar.breath_point_1);
Serial.print(", point 2 : ");
Serial.print(radar.breath_point_2);
Serial.print(", point 3 : ");
Serial.print(radar.breath_point_3);
Serial.print(", point 4 : ");
Serial.print(radar.breath_point_4);
Serial.print(", point 5 : ");
Serial.println(radar.breath_point_5);
Serial.println("----------------------------");
break;
}
}
delay(200); //Add time delay to avoid program jam
}
Por favor, sube el programa, luego abre el monitor serial y ajusta la velocidad en baudios a 115200.
Si todo va bien, verás mensajes de datos en el monitor serial.
IIC
XIAO ESP32-S3 tiene una interfaz I2C que se puede utilizar para la transmisión y el análisis de datos de muchos sensores, así como para usar algunas pantallas OLED.
Preparación de hardware
| Seeed Studio XIAO ESP32-S3 | Seeed Studio XIAO ESP32-S3 Sense | Seeed Studio Expansion Base for XIAO with Grove OLED |
|---|---|---|
| | |
La pantalla OLED en la placa de expansión XIAO utiliza el protocolo I2C y está conectada a la interfaz I2C de la XIAO a través del circuito I2C de la placa. Por lo tanto, podemos conectar directamente la XIAO a la placa de expansión y programarla para mostrar contenido en la pantalla.
Implementación de software
Este ejemplo introduce cómo usar la pantalla OLED en la Seeed Studio Expansion Base for XIAO ESP32-S3.
Paso 1. Instala la Seeed Studio XIAO ESP32-S3 en la placa de expansión y luego conecta el cable Type-C
Paso 2. Instala la biblioteca u8g2
Paso 3. Copia el código y pégalo en el IDE de Arduino y luego súbelo
#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 without Reset of the Display
void setup(void) {
u8x8.begin();
u8x8.setFlipMode(1); // set number from 1 to 3, the screen word will rotary 180
}
void loop(void) {
u8x8.setFont(u8x8_font_chroma48medium8_r);
u8x8.setCursor(0, 0);
u8x8.print("Hello World!");
}
En las primeras líneas del código, incluimos las bibliotecas necesarias como Arduino.h, U8x8lib.h y Wire.h. La biblioteca U8x8lib.h proporciona funciones para controlar la pantalla OLED, y la biblioteca Wire.h proporciona funciones para la comunicación I2C.
En la función setup(), inicializamos la pantalla OLED usando la función u8x8.begin(). También configuramos el modo de giro de la pantalla usando la función u8x8.setFlipMode() para rotar la pantalla 180 grados.
En la función loop(), configuramos la fuente usando la función u8x8.setFont() y especificamos la posición del cursor en la pantalla usando la función u8x8.setCursor(). Finalmente, usamos la función u8x8.print() para mostrar la cadena "Hello World!" en la pantalla OLED.
Si subes un programa a la XIAO ESP32-S3, verás contenido mostrado en la pantalla OLED de la placa de expansión.
SPI
El chip ESP32-S3 integra múltiples periféricos, incluida una interfaz SPI que se puede usar para conectar dispositivos SPI externos como memorias flash, pantallas, sensores y más. El ESP32-S3 también admite un modo de transferencia SPI de alta velocidad, que puede alcanzar una velocidad máxima de transferencia SPI de 80 MHz, satisfaciendo las necesidades de transferencia de datos de la mayoría de los dispositivos SPI.
Preparación de hardware
| Seeed Studio XIAO ESP32-S3 | Seeed Studio XIAO ESP32-S3 Sense | Grove - OLED Display 1.12 (SH1107) V3.0 - SPI/IIC |
|---|---|---|
| | _V3.0/img/10402050_Main-02.png) |
Después de preparar el hardware como se mencionó anteriormente, utiliza cables de puente para conectar la interfaz SPI de la XIAO y la OLED. Por favor, consulta el siguiente diagrama para el método de cableado.
Implementación de software
A continuación, tomaremos el siguiente programa como ejemplo para introducir cómo usar la interfaz SPI para controlar la pantalla OLED.
Instala la biblioteca u8g2.
#include <Arduino.h>
#include <U8g2lib.h>
#include <SPI.h>
#include <Wire.h>
U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R3, /* cs=*/ D7, /* dc=*/ D4, /* reset=*/ D5);
void setup(void) {
u8g2.begin();
}
void loop(void) {
u8g2.firstPage();
do {
u8g2.setFont(u8g2_font_luBIS08_tf);
u8g2.drawStr(0,24,"Hello Seeed!");
} while ( u8g2.nextPage() );
}
En la función setup(), la clase U8G2_SH1107_128X128_1_4W_HW_SPI se instancia con los argumentos de constructor apropiados que especifican los pines usados para la selección de chip (cs), datos/comando (dc) y reinicio. Luego, se llama a la función u8g2.begin() para inicializar la pantalla.
En la función loop(), la pantalla se actualiza con nuevo contenido utilizando las funciones u8g2.firstPage(), u8g2.setFont() y u8g2.drawStr(). La función u8g2.firstPage() configura el búfer de la pantalla para la escritura, mientras que u8g2.nextPage() muestra el contenido actualizado. El bucle do-while garantiza que el contenido se muestre de forma continua hasta que el programa se detenga.
En general, este código demuestra cómo usar la biblioteca U8g2 para controlar una pantalla OLED y mostrar texto en ella.
Para Sense
Si compraste la versión Sense y necesitas conectarla a la placa de expansión, ten en cuenta que la tarjeta SD de la placa de expansión ocupará los pines SPI, lo que puede hacer que los pines SPI no estén disponibles.
Las interfaces de almohadillas de soldadura proporcionadas en la placa de expansión Sense permiten a los usuarios seleccionar las funciones necesarias. Entre ellas, la función de la almohadilla de soldadura J3 es habilitar la funcionalidad SPI o de la tarjeta SD.
| Si quieres usar los pines SPI / Desactivar la tarjeta SD de la placa de expansión | Si quieres habilitar la tarjeta SD en la placa de expansión / Desactivar los pines SPI |
|---|---|
 |  |
| Corta a lo largo de la línea blanca fina para desconectar la conexión de la almohadilla de soldadura. | Suelda juntas las dos almohadillas de soldadura. |
Como se puede ver en la imagen, debido a las limitaciones de espacio de XIAO, muchas trazas de cableado son muy compactas. Por lo tanto, al cortar la conexión de J3, ten mucho cuidado de no cortar fuera de la línea blanca, ¡de lo contrario puede causar un mal funcionamiento de la placa de desarrollo!
Por razones de simplicidad, arriba se describe J3 simplemente como una interfaz que enciende o apaga la función de la tarjeta SD, pero esto en realidad no es exacto. La conexión real del circuito se muestra a continuación. Cortar J3 en realidad desconecta las resistencias pull-up de R4 a R6, lo cual es la razón principal por la que la función de la tarjeta SD se desactiva mientras que la función SPI se restaura a la normalidad.
Pines táctiles
Además de los pines funcionales comunes mencionados anteriormente, XIAO ESP32-S3/XIAO ESP32-S3 Sense también tiene 9 pines de detección táctil A0A5, A8A10.
Podemos comprobar si un pin ha sido tocado leyendo su valor analógico, lo cual es muy conveniente. El siguiente programa se utiliza para detectar si el pin A5 ha sido tocado.
const int touch_pin = A5;
void setup(void) {
Serial.begin(9600);
}
void loop(void) {
Serial.print("Touch value: ");
Serial.println(analogRead(touch_pin));
delay(1000);
}
Después de cargar el programa, abre el monitor serie y ajusta la velocidad en baudios a 9600. Luego toca el pin A5 y verás que el valor de lectura analógica será significativamente mayor que el valor antes de tocar.
Pines USB
ESP32-S3 es un microcontrolador que integra funcionalidades Wi-Fi y Bluetooth, y sus pines D+ y D- se utilizan para soportar la comunicación USB. En concreto, estos dos pines son líneas de señal diferencial utilizadas para la transmisión de datos de alta velocidad entre dispositivos y hosts USB 2.0.
El pin D+ es la línea de polaridad positiva utilizada para enviar datos, mientras que el pin D- es la línea de polaridad negativa utilizada para enviar datos. Cuando un dispositivo USB se conecta a un host, el host detecta los cambios de voltaje en estos dos pines para determinar el estado de conexión del dispositivo y la velocidad de transmisión. Durante la transmisión de datos, los pines D+ y D- transmiten alternativamente bits de datos y señales de sincronización para lograr una transmisión de datos fiable.
Pines JTAG
La interfaz JTAG (Joint Test Action Group) del ESP32-S3 es una interfaz de depuración y prueba que puede utilizarse para depuración y programación de hardware de muy bajo nivel durante el desarrollo, la depuración y las pruebas. La interfaz JTAG incluye un conjunto de líneas de señal estándar, incluidas líneas de reloj, líneas de entrada de datos, líneas de salida de datos, líneas de selección de modo de prueba, líneas de reloj de modo de prueba, etc.
La interfaz JTAG del ESP32-S3 puede utilizarse para los siguientes propósitos:
-
Depuración: La interfaz JTAG puede utilizarse para depuración y ejecución paso a paso en el chip ESP32-S3 para ayudar a los desarrolladores a encontrar y resolver errores de código.
-
Grabación de programas: A través de la interfaz JTAG, se pueden cargar programas o firmware de depuración en el chip ESP32-S3.
-
Lectura del estado de la CPU: La interfaz JTAG puede utilizarse para leer el estado de la CPU, el contenido de la memoria y los valores de los registros del chip ESP32-S3 para depuración y pruebas.
Cabe señalar que el uso de la interfaz JTAG requiere dispositivos de hardware y herramientas de software dedicados, así como los conocimientos y habilidades profesionales correspondientes. Por lo tanto, en general, la interfaz JTAG solo se utiliza en escenarios específicos como desarrollo, depuración y pruebas. Para los usuarios generales, ya es suficiente utilizar otras funciones e interfaces del ESP32-S3.
Si quieres saber más sobre la depuración JTAG, lee la documentación oficial de ESP32.
Solución de problemas
P1: ¿Por qué obtengo el siguiente error cuando uso el monitor serie?
R: Si encuentras este tipo de error, enciende el interruptor USB CDC On Boot.
Este problema también puede manifestarse como una salida serie vacía en Arduino IDE 2.x, y también puede deberse a esta misma razón.
P2: ¿Qué funciones admite o no admite el ESP-32?
R: A continuación se muestra una lista de funciones admitidas/no admitidas proporcionada por ESP32. A fecha de 10 de abril de 2023.
| Periférico | ESP32 | ESP32-S2 | ESP32-C3 | ESP32-S3 | Comentarios |
|---|---|---|---|---|---|
| ADC | Sí | Sí | Sí | Sí | |
| Bluetooth | Sí | No compatible | No compatible | No compatible | Bluetooth Classic |
| BLE | Sí | No compatible | Sí | Sí | |
| DAC | Sí | Sí | No compatible | No compatible | |
| Ethernet | Sí | No compatible | No compatible | No compatible | (*) |
| GPIO | Sí | Sí | Sí | Sí | |
| Sensor Hall | Sí | No compatible | No compatible | No compatible | |
| I2C | Sí | Sí | Sí | Sí | |
| I2S | Sí | Sí | Sí | Sí | |
| LEDC | Sí | Sí | Sí | Sí | |
| PWM de motor | No | No compatible | No compatible | No compatible | |
| Contador de pulsos | No | No | No | No | |
| RMT | Sí | Sí | Sí | Sí | |
| SDIO | No | No | No | No | |
| SDMMC | Sí | No compatible | No compatible | Sí | |
| Temporizador | Sí | Sí | Sí | Sí | |
| Sensor de temp. | No compatible | Sí | Sí | Sí | |
| Táctil | Sí | Sí | No compatible | Sí | |
| TWAI | No | No | No | No | |
| UART | Sí | Sí | Sí | Sí | |
| USB | No compatible | Sí | Sí | Sí | ESP32-C3 solo CDC/JTAG |
| Wi-Fi | Sí | Sí | Sí | Sí |
P3: ¿Por qué siempre puedo ver el mensaje de depuración del chip en el monitor serie?
R: Puedes intentar desactivar la salida de mensajes de depuración usando el siguiente método, Tool -> Core Debug Level: -> None en el Arduino IDE.
Sin embargo, este método no siempre funciona; de hecho, la información de depuración del ESP32-S3 siempre se imprime desde el puerto serie y esto no se puede cambiar. Por favor, perdónalo, simplemente está demasiado ansioso por hacerte saber que está funcionando correctamente.
P4: ¿Por qué, aunque corté la conexión de J3, sigo midiendo los pines D8 y D9 en alto? ¿La escritura en la tarjeta microSD sigue teniendo probabilidad de éxito?
En términos de diseño de tarjetas SD, el circuito correcto debe tener resistencias de pull‑up para que la tarjeta microSD funcione correctamente. Si descubres que el nivel de los pines y la lectura y escritura de la tarjeta siguen siendo normales después de cortar J3, esto puede ser solo una situación afortunada y no recomendamos que leas y escribas la tarjeta en este caso, ya que puede causar el problema de pérdida de los datos escritos. Mientras tanto, los pines D8 y D9 pueden modificarse de nivel escribiendo nivel bajo después de cortar J3.
Soporte técnico y debate sobre el producto
Gracias por elegir nuestros productos. Estamos aquí para ofrecerte diferentes tipos de soporte y garantizar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para adaptarnos a diferentes preferencias y necesidades.