Placa de Desenvolvimento TENSTAR ROBOT ESP32-C3 – WiFi e Bluetooth SuperMini

#incluem "WiFi.h"

configuração vazada ()

{

Serial.begin(115200);

WiFi.softAP("ESP_AP", "123456789");

}

loop vazio ()

{

Serial.print("Nome do host:");

Serial.println(WiFi.softAPgetHostname());

Serial.print (“Host IP:");

Serial.println(WiFi.softAPIP());

Serial.print (“Host IPV6:");

Serial.println(WiFi.softAPIPv6());

Serial.print (“Host SSID:");

Serial.println(WiFi.SSID());

Serial.print (“Host Broadcast IP:");

Serial.println(WiFi.softAPBroadcastIP());

Serial.print (“Endereço do host mac:");

Serial.println(WiFi.softAPmacAddress());

Serial.print (“Número de conexões de host:");

Serial.println(WiFi.softAPgetStationNum());

Serial.print (“ID de rede host:");

Serial.println(WiFi.softAPNetworkID());

Serial.print (“Status do host:");

Serial.println(WiFi.status());

atraso (1000);

}

#incluem

#incluem

#incluem

#incluem

int scanTime = 5; //Em segundos

BLEScan* pBLEScan;

classe MyAdvertisedDeviceCallback: público BLEAdvertisedDeviceCallback {

nulo emResultado(BLEAdvertisedDevice anunciadoDevice) {

Serial.printf(“Dispositivo Advertised: %s /n”, anunciadoDevice.toString().c_str());

}

};

configuração clara() {

Serial.begin(115200);

Serial.println(""Scan...");

Dispositivo BLED::init("");

pBLEScan = BLEDevice::getScan(); //crear uma nova digitalização

pBLEScan->setAdvertisedDeviceCallback(novo MyAdvertisedDeviceCallback());

pBLEScan->setActiveScan(verdadeiro); //a varredura ativa usa mais potência, mas obtém resultados mais rapidamente

pBLEScan->setIntervalo (100);

pBLEScan->setWindow(99); // conjunto menor ou igualValor de intervalo

}

loop vazio() {

// coloque seu código principal aqui, para executar repetidamente:

BLEScanResults encontradosDispositivos = pBLEScan->start(scanTime, falso);

Serial.print("Dispositivos encontrados: ");

Serial.println(contradoDispositivos.getCount());

Serial.println("Escanização feita!");

pBLEScan->clearResults(); // excluir resultados do buffer BLEScan para liberar memória

atraso (2000);

}

#incluem

#incluem

#incluem

// Veja o seguinte para gerar UUIDs:

//https://www.uuidgenerator.net/

#definir SERVIÇO_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"

#definir CHARACTERÍSTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

classe MyCallbacks: público BLOCaracterísticasCallback {

vazio emWrite(BLECaracterística *pCaracterística) {

std::valor de corda = pCaracterística->getValue();

se (valor.comprimento () > 0) {

Serial.println(""*********);

Serial.print("Novo valor: ");

para (int i = 0; i < valor.comprimento(); i++)

Serial.print (valor[i]);

Serial.println();

Serial.println(""*********);

}

}

};

configuração clara() {

Serial.begin(115200);

BLEDevice::init(MyESP32"");

BLEServer *pServer = BLEDevice::createServer();

BLEService *pService = pServer->createService(SERVICE_UUID);

BLECaracterística *pCaracterística = pServiço->criarCaracterística(

CARACTERÍSTICA_UUID,

BLECaracterística::PROPERTY_READ|

BLECaracterística::PROPERTY_WRITE

);

pCaracterística->setCallback (novos MyCallback());

pCaracterística->setValor(“Olá Mundo”);

pService->start();

BLEAdvertising *pPublicidade = pServer->getAdvertising();

pPublicidade->start();

}

loop vazio() {

// coloque seu código principal aqui, para executar repetidamente:

atraso (2000);

}

Pino digital

Carregue o código para a placa e o LED integrado acenderá a cada segundo.

// definir led de acordo com o diagrama dos pinos

int led = 8;

configuração clara() {

// inicializa o LED do pino digital como uma saída

modo pin (led, SAÍDA);

}

loop vazio() {

digitalWrite (led, ALTO); // acende o LED

atraso(1000); //espere um segundo

digitalWrite (led, BAIXO); // desligue o LED

atraso(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

configuração clara() {

// declarando o pino LED como saída

pinMode (ledPin, SAÍDA);

}

loop vazio() {

// desaparece de min ao máximo em incrementos de 5 pontos:

para (int desvanecimValor = 0; desvanecimValor <= 255; desvanecimValor += 5) {

// define o valor (faixa de 0 a 255):

analógicoWrite (ledPin, fadeValue);

//espere 30 milissegundos para ver o efeito de escurecimento

atraso (30);

}

// desaparece de max para min em incrementos de 5 pontos:

para (int desvanecimValor = 255; desvanecimValor >= 0; desvanecimValor -= 5) {

// define o valor (faixa de 0 a 255):

analógicoWrite (ledPin, fadeValue);

//espere 30 milissegundos para ver o efeito de escurecimento

atraso (30);

}

}

Pino analógico

Conecte o potenciômetro ao pino A5 e carregue o seguinte código para controlar o intervalo de piscar do LED girando o botão do potenciômetro.

const int sensorPin = A5;

const int ledPin = 8;

configuração clara() {

pinMode (sensorPin, ENTRADA); // declarar o sensorPin como uma ENTRADA

pinMode (ledPin, SAÍDA); // declarar o ledPin como uma SAÍDA

}

loop vazio() {

// leia o valor do sensor:

int sensorValue = analógicoRead(sensorPin);

// ligue o ledPin

digitalWrite (ledPin, ALTO);

// pare o programa para milissegundos:

atraso (valor do sensor);

// desligue o ledPin:

digitalWrite (ledPin, BAIXO);

// pare o programa para milissegundos:

atraso (valor do sensor);

}