Machine Translated by Google

Introdução do produto: O
ESP32 C3 SuperMini é uma mini placa de desenvolvimento baseada no chip de modo hdual Espressif ESP32-C3 WiFi/
Bluetoot. O ESP32-C3 é uma CPU RISC-V de 32 bits que contém a FPU (unidade de ponto flutuante) para operações de
precisão única de 32 bits com poderoso poder de computação. Possui excelente desempenho F e suporta protocolos
IEEE 802.11b /g/n WiFi e Bluetooth 5 (LE). A placa vem com uma antena externa para aumentar a intensidade do sinal
para aplicações sem fio. Ele também possui um formato pequeno e delicado combinado com um design de montagem em
superfície unilateral. Ele é equipado com uma variedade de interfaces, com 11 E/S digitais que podem ser usados
como pinos PWM e 4 E/S analógicos que podem ser usados como pinos ADC. Suporta quatro interfaces seriais: UART,
I2C e SPI. O placar também possui um pequeno botão de reset e um botão de modo de boot loader.

Combinado com os recursos acima, o ESP32C3SuperMini é posicionado como uma mini placa de desenvolvimento
iot de alto desempenho, baixo consumo de energia e econômica para aplicações iot de baixa potência e
aplicações vestíveis sem fio.

Parâmetro do produto: 1.
CPU poderosa: ESP32-C3, processador single-core RISC-V de 32 bits, rodando até 160 MHz. WiFi: protocolo
802.11b/g/n, 2,4 GHz, modo de estação de suporte, modo SoftAP, SoftAP + Modo estação, modo híbrido 3. Bluetooth:
Bluetooth 5.0
4.Consumo de energia ultrabaixo:
consumo de energia em sono profundo de cerca de 43uA 5.Recursos ricos da placa: 400KB
SRAM, 384KB ROM integrado 4Mflash.
6.Modelo de chip: ESP32C3FN4
7.Tamanho ultrapequeno: formato clássico tão pequeno quanto o polegar (22,52x18mm), adequado para
wearables e
pequenos projetos 8.Recursos de segurança confiáveis: Aceleradores de hardware de criptografia que suportam
AES-128/256, hashing, RSA, HMAC, assinaturas digitais
e inicialização segura 9. Interface rica: 1x12C, 1xSPI, 2xUART, 11xGPIO (PWM),
4xADC 0. Componentes de um lado, design de montagem
em superfície 11 Luz azul LED integrada: pino GPIO8
Machine Translated by Google
 Machine Translated by Google
Fonte de alimentação externa:
Se for necessária fonte de alimentação externa, basta conectar o nível + da fonte de alimentação externa
na posição de 5V.GND conecta ao terminal negativo. (Suporte para fonte de alimentação 3,3 - 6V). Lembre-se
que ao conectar a fonte de alimentação externa, você não poderá acessar o USB. USB e fonte de alimentação
externa só podem escolher uma.

Ao soldar, tome cuidado para não causar curto-circuito nos eletrodos

positivo e negativo, caso contrário poderá queimar a bateria e o equipamento.

Antena Wi-Fi

Configuração de hardware
Você precisa preparar o seguinte: 1x ESP32

C3 SuperMini 1 x computador

1x cabo de dados

USB tipo C Alguns cabos USB só

podem fornecer energia, não transmitir dados.

Certifique-se de que seu cabo USB possa transferir dados.

Machine Translated by Google

Configuração de software
Etapa 1. Baixe e instale a versão mais recente do IDE com base no seu sistema operacional.

Etapa 2. Inicie o aplicativo IDE Etapa 3.

Adicione o pacote da placa ESP32 ao IDE Navegue até
Arquivo -› Preferências e preencha o "URL do gerenciador de placas adicionais" usando o seguinte URL: https://

raw.githubusercontent.com/ espressif/arduino-esp32/gh-pages/package_esp32_index.json

Navegue até Ferramentas > Quadro > Gerenciador de Quadros... Digite a palavra-chave "esp32" na caixa de pesquisa,
selecione a versão mais recente do esp32 e instale-a.
Machine Translated by Google
Navegue até Ferramentas > Placa de desenvolvimento > ESP32 e selecione Módulo de desenvolvimento ESP32C3.
A lista de painéis é um pouco longa e você precisa rolar até o final para acessá-la.

Navegue até "Ferramentas" > Porta e selecione o nome da porta serial do ESP32 C3 SuperMini ao qual você está se
conectando. Pode ser COM3 ou posterior (COM1 e COM2 geralmente são reservados para portas seriais
de hardware)

LED piscando
Copie o código a seguir no IDE

//define o led de acordo com o diagrama de pinos

liderado = 8;

void setup() { //

inicializa o led do pino digital como saída

pinMode(led, SAÍDA); }

loop vazio() {

digitalWrite(led, ALTO); //liga o LED delay(1000);

// espere um segundo

digitalWrite(led, BAIXO); //desliga o LED delay(1000); }

// espere um segundo

Após o upload, você verá o LED piscando na placa com um atraso de 1 segundo entre cada piscada.
Machine Translated by Google
Perguntas frequentes

A porta COM não pode ser reconhecida no IDE

Entre no modo de download: Método 1: Pressione e segure BOOT para ligar.

2: Pressione e segure o botão BOOT do ESP32C3,

pressione o botão RESET, solte o botão RESET e, em seguida, solte o botão BOOT. Então o ESP32C3 irá

entre no modo de download. (Cada conexão precisa entrar novamente no modo de download, às vezes pressione uma vez, a porta

a instabilidade será desconectada, você pode julgar pelo som de identificação da porta)

O programa não será executado após o upload

Após o upload ser bem-sucedido, você precisa pressionar o botão Redefinir para executar o upload.

A porta serial ESP32 C3 SuperMini não pode imprimir

Defina USB CDC On Boot na barra de ferramentas como Ativado

Função Wi-Fi
Conecte o ESP32C3SuperMini ao seu computador usando um cabo de dados USB tipo C

Digitalize redes WiFi (modo estação)

Usaremos o ESP32C3SueprMini para escanear as redes WiFi disponíveis ao seu redor. Aqui, a placa será configurada em s

modo de operação (STA)

1. Copie e cole o seguinte código no IDE #include "WiFi.h" void setup()

{ Serial.begin(115200);

// Defina o WiFi para o modo estação e desconecte de um AP se ele estiver conectado anteriormente
WiFi.mode(WIFI_STA);
WiFi.disconnect();
atraso(100);
Serial.println("Configuração

concluída"); }

void loop() { Serial.println("início da verificação");

// WiFi.scanNetworks retornará o número de redes encontradas

int n = WiFi.scanNetworks();

Serial.println("digitalização concluída");

se (n ==0) {

Serial.println("nenhuma rede encontrada"); }

else
{Serial.print(n);

Serial.println("redes encontradas"); for (int i

= 0; i < n; ++i) { // Imprime SSID

e RSSI para cada rede encontrada
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));Serial.print(")");
Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*"); atraso(10);} }

Serial.println(""); //
Espere um pouco antes de digitalizar
novamente delay(5000);}
Machine Translated by Google
2. Carregue o código e ligue o monitor serial para iniciar a varredura da rede WiFi

Conecte-se à rede WiFi 1. Copie e cole

o seguinte código no IDE
#include <WiFi.h>
const char* ssid = "seu-ssid"; //seu nome WiFi const char*
senha = "sua-senha"; //sua senha WiFivoid setup()
{ Serial.begin(115200);

atraso(10); // Começamos
conectando
a uma rede WiFi Serial.println(); Serial.println();

Serial.print("Conectando a ");
Serial.println(ssid);
WiFi.begin(ssid, senha); enquanto
(WiFi.status()! = WL_CONNECTED) { atraso (500);
Serial.print("."); }

Serial.println("");
Serial.println("WiFi conectado");
Serial.println("Endereço IP: ");
Serial.println(WiFi.localIP()); } loop

vazio() { }

2. Carregue o código e ligue o monitor serial para verificar se a placa de desenvolvimento

está conectada ao WiF | rede
Machine Translated by Google
Ponto de acesso Wi-Fi
Neste exemplo, usaremos o ESP32C3SuperMini como um ponto de acesso WiFi ao qual outros dispositivos
podem se conectar. Isso é semelhante à função de ponto de acesso WiFi do seu telefone.
1. Copie e cole o seguinte código no IDE
#include "WiFi.h" void
setup()

{ Serial.begin(115200);
WiFi.softAP("ESP_AP", "123456789"); } void

loop()

{ Serial.print("Nome do host:");
Serial.println(WiFi.softAPgetHostname());
Serial.print("IP do host:");
Serial.println(WiFi.softAPIP());
Serial.print("Host IPV6:");
Serial.println(WiFi.softAPIPv6());
Serial.print("SSID do host:");
Serial.println(WiFi.SSID());
Serial.print("IP de transmissão do host:");
Serial.println(WiFi.softAPBroadcastIP());
Serial.print("Endereço MAC do host:");
Serial.println(WiFi.softAPmacAddress());
Serial.print("Número de conexões de host:");
Serial.println(WiFi.softAPgetStationNum());
Serial.print("ID da rede host:");
Serial.println(WiFi.softAPNetworkID());
Serial.print("Status do Host:");
Serial.println(WiFi.status());atraso(1000); }

2. Carregue o código e ligue o monitor serial para verificar mais detalhes sobre o ponto de acesso WiFi
Machine Translated by Google
Função Bluetooth Conecte o
ESP32C3SuperMini ao seu computador por meio de um cabo USB tipo C Faça a

varredura do Bluetooth
Usaremos o ESP32C3SueprMini para procurar dispositivos Bluetooth disponíveis ao seu redor
1. Copie e cole o seguinte código no IDE

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h> int
scanTime = 5; //Em segundos
BLEScan* pBLEScan; class
MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {void onResult(BLEAdvertisedDevice promotedDevice)
{Serial.printf("Dispositivo anunciado: %s \n", promotedDevice.toString().c_str()); } }; void configuração()

{Serial.begin(115200);
Serial.println("Digitalizando...");
BLEDevice::init("");
pBLEScan = BLEDevice::getScan(); //cria nova varredura pBLEScan-
>setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks()); pBLEScan->setActiveScan(true); //
a varredura ativa consome mais energia, mas obtém resultados mais rapidamente pBLEScan-
>setInterval(100); pBLEScan-
>setWindow(99); // valor setInterval menor ou igual } void loop() { // coloque

seu código
principal aqui, para executar repetidamente:
BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
Serial.print("Dispositivos encontrados:
"); Serial.println(foundDevices.getCount());
Serial.println("Digitalização
concluída!"); pBLEScan->clearResults(); // exclui resultados do buffer BLEScan para liberar memória
delay(2000); }

2. Carregue o código e ligue o monitor serial para iniciar a varredura de dispositivos Bluetooth
 Machine Translated by Google
Como servidor Bluetooth Neste
exemplo, usaremos o ESP32C3SuperMini como servidor Bluetooth. Aqui usaremos um smartp
hone para pesquisar a placa ESP32C3SuperMini e enviar uma string para exibição no
monitor serial 1. Copie e cole o seguinte código no IDE
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
// Veja o seguinte para gerar UUIDs: / https://
www.uuidgenerator.net/ #define
SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b" #define
CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8" class
costas : public BLECharacteristicCallbacks { void
onWrite(BLECharacteristic *pCharacteristic)
{ std::string value = pCharacteristic->getValue();
if (value.length() > 0)
{ Serial.println("*********");
Serial.print("Novo valor: ");
for (int i = 0; i < valor.comprimento(); i++)
Serial.print(valor[i]);
Serial.println();
Serial.println("*********"); } } };

void
configuração()
{Serial.begin(115200);
BLEDevice::init("MeuESP32"); BLEServer *pServer
= BLEDevice::createServer(); BLEService *pService = pServer-
>createService(SERVICE_UUID); BLECharacteristic *pCharacteristic =
pService-
>createCharacteristic( CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |

BLECharacteristic::PROPERTY_WRITE );
pCharacteristic->setCallbacks(new
MyCallbacks());
pCharacteristic->setValue("Olá Mundo"); pService->start();
BLEAdvertising

*pAdvertising
= pServer->getAdvertising(); pPublicidade-
>start(); }
void loop() { // coloque seu código principal aqui, para executar repetidamente: delay(2000); }
Machine Translated by Google
2. Carregue o código e abra o monitor serial 3.
Baixe e instale o aplicativo LightBlue em seu smartphone 4.
Ligue o Bluetooth do telefone, coloque o telefone próximo ao ESP32C3SuperMini, escaneie o
dispositivo e conecte o dispositivo MyESP32

5. Abra o aplicativo LightBlue e clique na guia Bonded 6.

Clique em CONNECT ao lado de MyESP32

7. Clique na parte inferior onde Legível, Gravável são exibidos

8. No menu suspenso Formato de dados, selecione String UTF-8
Machine Translated by Google

9. Digite "Olá" em "VALORES ESCRITOS" e clique em "ESCREVER"

:) Você verá a string de texto "Hello" no monitor serial do IDE

Machine Translated by Google

ChatGPT
Podemos usar o ESP32 Supermini para fazer algumas aplicações no ChatGPT.
Por exemplo, podemos configurar nossa própria página de perguntas e respostas do ChatGPT usando o SuperMini.

Nesta página você pode inserir sua dúvida, o ESP32C3SuperMini irá gravar sua dúvida, e utilizando o método de

chamada API fornecido pelo OpenAl, utilizando HTTP Client para enviar um comando de solicitação, obter a resposta

do ChatGPT e imprimi-la na porta serial.

As etapas são as seguintes:

Conecte o ESP32C3SuperMini à rede Construindo páginas da web

incorporadas Envie perguntas através da

página da web integrada Obtenha respostas do ChatGPT

Se estiver interessado, você pode

pesquisar materiais relacionados.

Uso de alfinete
O ESP32C3SuperMini possui várias interfaces. Existem 11 I/OS digitais que podem ser usados como PWM

pinos e 4 entradas analógicas que podem ser usadas como pinos ADC. Ele suporta quatro interfaces de comunicação serial, como UART, I2C,

SPI e 12S. Este artigo irá ajudá-lo a entender essas interfaces e implementá-las em seu próximo projeto!

Sobre o pino A0A5, GPIOOGPIO10 (010) e o início de D, aqui para explicar, a placa-mãe padrão apenas o início do GPIO é 010,

20, 21, o pino A0 ~ A5 é um problema de mapeamento, para facilitar ao usuário informar o a função deste pino é pino analógico ou

pino digital. Quando o Arduino seleciona o tipo de placa de desenvolvimento e seleciona o módulo ESP32C3 Dev, você pode fazer referência

ao seu mapa de pinos. O

O mapa de pinos é mostrado abaixo:

Machine Translated by Google
Pino digital
Carregue o código na placa e o LED integrado acenderá a cada segundo.
// define o led de acordo com o diagrama
de pinos int led = 8;void
setup() { // inicializa o led do pino digital
como uma saída

pinMode(led, OUTPUT); } void loop() {digitalWrite(led,

HIGH); //liga o LED delay(1000); //
espera por um segundo digitalWrite(led,
LOW); //desliga o LED
delay(1000); // espere um segundo }

PWM digital
Carregue o código a seguir para ver o LED integrado escurecer gradualmente.

int ledPin = 8; // LED conectado ao pino digital 10

void setup()
{ // declarando o pino do LED
como saída pinMode(ledPin,

OUTPUT); }
void loop() { // fade in do mínimo ao máximo em
incrementos de 5 pontos: for (int fadeValue = 0 ; fadeValue <=
255; fadeValue += 5) { // define o valor
(intervalo de 0 a 255) :
analogWrite(ledPin, fadeValue); // espere 30

milissegundos para ver o efeito de escurecimento

delay(30); } // fade out do máximo ao mínimo em incrementos de
5 pontos: for (int fadeValue = 255 ;
fadeValue >= 0; fadeValue -= 5)
{ // define o valor (intervalo de 0 a 255): analogWrite(ledPin,
fadeValor); //

espere 30 milissegundos para ver o efeito de escurecimento delay(30); } }

Pino analógico
Conecte o potenciômetro ao pino A5 e carregue o seguinte código para controlar o intervalo de
intermitência do LED girando o botão do potenciômetro.
Machine Translated by Google

const int sensorPin = A5; const int

ledPin = 8; void setup()

{ pinMode(sensorPin,

INPUT); //declara o sensorPin como um INPUT pinMode(ledPin, OUTPUT); // declara o ledPin

como uma SAÍDA } void loop() { // lê o valor do sensor: int sensorValue = analogRead(sensorPin);

//liga o ledPin

digitalWrite(ledPin, ALTO); // interrompe

o programa por <sensorValue> milissegundos: delay(sensorValue); // desliga

o ledPin: digitalWrite(ledPin,
LOW); // interrompe o

programa por <sensorValue>

milissegundos: delay(sensorValue); }

Porta serial
Porta serial de hardware, existem duas portas seriais de hardware na placa: Porta
serial USB Porta
serial ART Por
padrão, a serial USB está habilitada, o que significa que você pode conectar a placa de desenvolvimento a um PC via USB
Type-C e ligar o monitor serial no Arduino IDE para ver os dados enviados via serial.

Porém, se quiser usar ART como porta serial, você precisará conectar o pino 20 como pino TX

e o pino 21 como um pino RX usando um adaptador serial USB.

Além disso, você precisa definir USB CDC On Boot como desativado no IDE do Arduino.
Machine Translated by Google

Porta serial de software

Se quiser usar mais portas seriais, você precisará usar a biblioteca SoftwareSerial para criar portas
seriais flexíveis

Conexão I2C de ESP32 C3 Supermini e 0,96 OLED

1. Abra o Arduino IDE e navegue até Sketch -› Incluir Biblioteca-›Gerenciar Bibliotecas...

2. Pesquise u8g2 e instale-o 3.
Carregue o código para exibir a string de texto no display OLED