Saltar al contenido principal

Multiplexación de pines con Seeed Studio XIAO ESP32-S3 (Sense)

Seeed Studio XIAO ESP32-S3Seeed Studio XIAO ESP32-S3 SenseSeeed Studio XIAO ESP32-S3 Plus
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

El 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 pueden utilizarse para diversos fines, como comunicarse con otros dispositivos, leer sensores analógicos, controlar LEDs y más. En este tutorial, exploraremos el pinout del XIAO ESP32-S3 y de su placa relacionada, el XIAO ESP32-S3 Sense, y aprenderemos cómo utilizar estos pines para diferentes propósitos. En concreto, cubriremos el uso de 1x UART, 1x lIC, 1x lIS, 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 el XIAO ESP32-S3 Sense, 1x conector B2B (con 2 GPIO adicionales). Al final de este tutorial, tendrás un buen entendimiento del pinout del XIAO ESP32-S3 y serás capaz de utilizarlo eficazmente en tus proyectos.

Primeros pasos​

Visión general del pinout​

Antes de comenzar, revisemos todos los pines que tiene el XIAO ESP32-S3 y sus funciones con el siguiente esquema.

Visión general del hardware​

Antes de empezar con todo, es bastante esencial contar con algunos parámetros básicos del producto. La siguiente tabla proporciona información sobre las características del Seeed Studio XIAO ESP32-S3.

Parte frontal del XIAO ESP32-S3​

Parte trasera del XIAO ESP32-S3​

Mapa de pines

Pin XIAOFunciónPin del chipFunciones alternativasDescripción
5VVBUSEntrada/Salida de alimentación
GND
3V33V3_OUTSalida de alimentación
D0AnalógicoGPIO1TOUCH1GPIO, ADC
D1AnalógicoGPIO2TOUCH2GPIO, ADC
D2AnalógicoGPIO3TOUCH3GPIO, ADC
D3AnalógicoGPIO4TOUCH4GPIO, ADC
D4Analógico, SDAGPIO5TOUCH5GPIO, datos I2C, ADC
D5Analógico, SCLGPIO6TOUCH6GPIO, reloj I2C, ADC
D6TXGPIO43GPIO, transmisión UART
D7RXGPIO44GPIO, recepción UART
D8Analógico, SCKGPIO7TOUCH7GPIO, reloj SPI, ADC
D9Analógico, MISOGPIO8TOUCH8GPIO, datos SPI, ADC
D10Analógico, MOSIGPIO9TOUCH9GPIO, datos SPI, ADC
D11AnalógicoGPIO42TOUCH12GPIO, ADC
D12AnalógicoGPIO41TOUCH13GPIO, ADC
MTDOGPIO40JTAG
MTDIGPIO41JTAG, ADC
MTCKGPIO39JTAG, ADC
MTMSGPIO42JTAG, ADC
ResetCHIP_PU
BootGPIO0Entrar en modo de arranque
U.FL-R-SMT1LNA_INAntena UFL
CHARGE_LEDLED de carga
USER_LEDGPIO21Luz de usuario
precaución

  • 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 distinguir y diferenciarlos.

  • El conector B2B de XIAO ESP32-S3 Plus es compatible con la placa de expansión Wio-SX1262 pero no con la placa de sensor de cámara enchufable.

  • 5V - Esta es la salida de 5V desde el puerto USB. También puedes usarla como entrada de voltaje, 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 5V.

  • 3V3 - Esta es la salida regulada del regulador integrado. Puedes extraer 700mA

  • GND - Tierra de alimentación/datos/señal

A continuación se muestra una visión general de los pines funcionales del XIAO ESP32-S3.

Número de pinDescripción de la función
-- Pines del micrófono PDM --
GPIO 41Datos del micrófono PDM
GPIO 42Reloj del micrófono PDM
-- Pines SPI de la tarjeta MicroSD --
GPIO 21MicroSD SPI CS
D8 / A8 / Qt7 / GPIO7MicroSD SPI SCK
D9 / A9 / Qt8 / GPIO8MicroSD SPI MISO
D10 / A10 / Qt9 / GPIO9MicroSD SPI MOSI
-- Pines de la cámara --
GPIO 10XMCLK
GPIO 11DVP_Y8
GPIO 12DVP_Y7
GPIO 13DVP_PCLK
GPIO 14DVP_Y6
GPIO 15DVP_Y2
GPIO 16DVP_Y5
GPIO 17DVP_Y3
GPIO 18DVP_Y4
GPIO 38DVP_VSYNC
GPIO 39Camera SCL
GPIO 40Camera SDA
GPIO 47DVP_HREF
GPIO 48DVP_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 del XIAO ESP32-S3, ten cuidado al soldar los headers, no pegues pines diferentes entre sí y no pegues soldadura al blindaje u otros componentes. De lo contrario, puede provocar que el XIAO se cortocircuite o no funcione correctamente, y las consecuencias causadas por esto 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 separado en ellos.

Digital​

El XIAO ESP32-S3 tiene hasta 11 pines GPIO normales y 9 pines analógicos. En este ejemplo, utilizaremos el 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-S3Seeed Studio XIAO ESP32-S3 SenseBase de expansión Seeed Studio para XIAO con Grove OLEDGrove - Relay
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

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. Finalmente, conecta 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.

tip

Si quieres utilizar la función digital, entonces debes usar la letra "D" como prefijo del número de pin, como D4, D5. Por el contrario, si quieres utilizar la función analógica de un pin, debes usar la letra "A" como prefijo del número de pin, como A4, A5.

Para la versión Sense​

Para XIAO ESP32-S3 Sense, además de utilizar los 11 pines digitales en XIAO, también puedes utilizar los dos pines en la placa de expansión, que son D11 y D12. Si quieres utilizarlos, 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 por defecto. Si realmente necesitas utilizar 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 utilizando un cuchillo afilado.

precaución

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 distinguir y diferenciar entre ellos.

tip

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 utilizar la función de micrófono, los pines D11 y D12 no se pueden utilizar 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 SenseGrove - Relay
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

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 utilizar. Esto no se repetirá más adelante.

precaución

Para los dos pines adicionales D11 y D12 en el XIAO ESP32-S3 Sense, no hemos definido aún las macros de 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 utilizando los números GPIO, GPIO42 y GPIO41, respectivamente. Presentaremos las definiciones de macros para estos dos pines lo antes posible y, una vez realizada la contribución, podrás usar D/A en las definiciones de pines.

Digital as PWM​

Todos los pines GPIO en XIAO ESP32-S3 soportan salida PWM. Por lo tanto, puedes utilizar 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-S3Seeed Studio XIAO ESP32-S3 SenseSeeed Studio Expansion Base for XIAO with Grove OLEDGrove - Variable Color LED
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

Instala XIAO ESP32-S3 o Sense en la placa de expansión, luego conecta el LED de Color Variable a la interfaz A0/D0 de la placa de expansión usando un cable Grove. Finalmente, conecta el XIAO a tu ordenador mediante un cable USB-C.

Implementación de software​

En este ejemplo, mostraremos 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 utilizados para la comunicación serie, los 9 pines restantes admiten 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.

precaución

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 admiten la funcionalidad ADC. Asegúrate de distinguirlos y diferenciarlos.

Preparación de hardware​

Seeed Studio XIAO ESP32-S3Seeed Studio XIAO ESP32-S3 SenseSeeed Studio Expansion Base for XIAO with Grove OLEDGrove - Oxygen Sensor
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

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, usaremos 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;
}
tip

Si quieres usar la función analógica de un pin, debes usar la letra "A" como prefijo del número de pin, como A4, A5. Por el contrario, si quieres usar la función digital, entonces debes usar la letra "D" como prefijo del 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.

Serie​

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 utilizadas 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 del 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, 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 expuestos por el chip para la comunicación serie.

Función principal que debe incluirse:

  • Serial1.begin(BAUD,SERIAL_8N1,RX_PIN,TX_PIN); -- enalbe Serial1,the function prototype : <Serial.Type>.begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin);
    • baud :baud rate
    • config:Configuration bit
    • rxPin :Receive Pin
    • txPin :Send Pin

Vale la pena señalar que si utilizamos el puerto de pin digital para definir, este lugar debería ser #define RX_PIN D7、#define TX_PIN D6, si utilizamos el puerto de pin GPIO para definir, este lugar debería ser #define RX_PIN 44、#define TX_PIN 43, consulta los diagramas de pines de las diferentes Serie XIAO 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. Luego, puedes 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 de hardware no es suficiente, también puedes utilizar la función de software serial del ESP32 para configurar algunos pines como software serial y así ampliar el número de puertos serie.

Por supuesto, recomendamos utilizar el segundo método de asignar puertos serie de 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 chip de la serie ESP32, si necesitas utilizar el puerto serie por software, debes descargar por separado la biblioteca de puerto serie por software de terceros. Aquí se proporciona una referencia.

Download the Library

tip

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, 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 correctamente.

Luego, a continuación, puedes utilizar el puerto serie por software del ESP32.

precaución

Si tienes instaladas en tu ordenador otras bibliotecas de puerto serie por software, es probable que causen un conflicto, así que por favor compruébalo tú mismo.

#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 de hardware (Serial.begin()) como el puerto serie por software (mySerial.begin()).

En la función loop(), utilizamos 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 de hardware.

También utilizamos la función mySerial.print() para escribir "Hello World!" en el puerto serie por software. Esto enviará los datos desde el XIAO al dispositivo conectado al puerto serie por software.

Finalmente, añadimos una función delay() para esperar un segundo antes de repetir el bucle.

nota

Ten en cuenta que, para utilizar el puerto serie por software en el ESP32-S3, debes seleccionar los pines apropiados para RX y TX que no se utilicen para ningún otro propósito. En este ejemplo, hemos utilizado los pines 9 y 10 para RX y TX, respectivamente.

Otros puertos serie de hardware​

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 utilizamos UART0 ya que se usa para la comunicación serie por USB. Puedes utilizar otros puertos serie de hardware personalizando la asignación del puerto serie de hardware.

// 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 utilizar los puertos serie de hardware D9 y D10 y el puerto serie USB.

Por favor, prepárate con lo siguiente.

Seeed Studio XIAO ESP32-S3Seeed Studio XIAO ESP32-S3 Sense60GHz mmWave Sensor -
Human Resting Breathing
and Heartbeat Module
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

Descarga la biblioteca del sensor a tu ordenador. Y añádela al Arduino IDE.

Descargar las bibliotecas

Aquí queremos analizar la información de los datos de latidos y respiración, luego puedes reescribir tu programa de esta 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.

pir

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-S3Seeed Studio XIAO ESP32-S3 SenseSeeed Studio Expansion Base for XIAO with Grove OLED
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

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 para 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​

Descargar las bibliotecas

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 utilizar 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-S3Seeed Studio XIAO ESP32-S3 SenseGrove - OLED Display 1.12 (SH1107) V3.0 - SPI/IIC
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️
Consigue uno ahora 🖱️

Después de preparar el hardware como se mencionó anteriormente, utiliza cables de puente para conectar la interfaz SPI del XIAO y el OLED. 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 utilizar la interfaz SPI para controlar la pantalla OLED.

Instala la biblioteca u8g2.

Descargar las bibliotecas
#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 utilizados para chip select (cs), data/command (dc) y reset. 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 escritura, mientras que u8g2.nextPage() muestra el contenido actualizado. El bucle do-while garantiza que el contenido se muestre continuamente hasta que el programa se detenga.

En general, este código demuestra cómo utilizar 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 provocar 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 requeridas. 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ónSi 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.
precaución

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!

precaución

Por sentido común, arriba se describe simplemente J3 como una interfaz que enciende o apaga la función de la tarjeta SD, pero esto en realidad no es exacto. La conexión de circuito real se muestra a continuación. Cortar J3 en realidad desconecta las resistencias pull-up de R4 a R6, que es la razón principal por la que la función de la tarjeta SD se deshabilita 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 subir 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 admitir la comunicación USB. Específicamente, estos dos pines son líneas de señal diferencial utilizadas para la transmisión de datos de alta velocidad entre dispositivos USB 2.0 y hosts.

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 se puede utilizar 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 se puede utilizar para los siguientes propósitos:

  1. Depuración: La interfaz JTAG se puede utilizar 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.

  2. Programación de flasheo: A través de la interfaz JTAG, se pueden cargar en el chip ESP32-S3 programas o firmware de depuración.

  3. Lectura del estado de la CPU: La interfaz JTAG se puede utilizar 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 estar causado por este mismo motivo.

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.

PeripheralESP32ESP32-S2ESP32-C3ESP32-S3Comments
ADCYesYesYesYes
BluetoothYesNot SupportedNot SupportedNot SupportedBluetooth Classic
BLEYesNot SupportedYesYes
DACYesYesNot SupportedNot Supported
EthernetYesNot SupportedNot SupportedNot Supported(*)
GPIOYesYesYesYes
Hall SensorYesNot SupportedNot SupportedNot Supported
I2CYesYesYesYes
I2SYesYesYesYes
LEDCYesYesYesYes
Motor PWMNoNot SupportedNot SupportedNot Supported
Pulse CounterNoNoNoNo
RMTYesYesYesYes
SDIONoNoNoNo
SDMMCYesNot SupportedNot SupportedYes
TimerYesYesYesYes
Temp. SensorNot SupportedYesYesYes
TouchYesYesNot SupportedYes
TWAINoNoNoNo
UARTYesYesYesYes
USBNot SupportedYesYesYesESP32-C3 only CDC/JTAG
Wi-FiYesYesYesYes

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 utilizando 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, lo cual no se puede cambiar. Por favor, compréndelo, simplemente está demasiado ansioso por hacerte saber que está funcionando correctamente.

P4: ¿Por qué corté la conexión de J3, pero aún así al probar obtengo los pines D8 y D9 en alto? ¿La escritura en la tarjeta microSD sigue teniendo una probabilidad de éxito?​

En cuanto al diseño de la tarjeta 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 te recomendamos leer y escribir la tarjeta en este caso, ya que puede causar el problema de pérdida de los datos escritos. Mientras que los pines D8 y D9 se pueden modificar 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 para 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.

Loading Comments...