ESP32-C3 Super Mini

Name: ESP32-C3 Super Mini
Price: 2,85 €

ELECTRONIQUE, PROMO

Deal Score0

2,85 € ~~9,14 €~~ ACHETER SUR ALIEXPRESS

Deal Score0

2,85 € ~~9,14 €~~ ACHETER SUR ALIEXPRESS

Carte de développement ESP32-C3 CORE ESP32 Super Mini carte de développement ESP32 carte de développement WiFi Bluetooth

Lien Aliexpress

Présentation ESP32-C3 Super Mini

ESP32 sur Nozzler

# Inclure "WiFi.h"
void setup(){
Serial. start (115200);
// Définir le WiFi en mode station et déconnecter d'un AP s'il était précédemment connecté
WiFi.mo de(WIFI_STA);
WiFi. déconnexion ();
delay(100);
Serial.println("Setup done");
}
void loop()
{
Serial.println("démarrage du scan");
// WiFi.scanNetworks renverra le nombre de réseaux trouvés
Int n = WiFi.scanNetworks();
Serial.println("scan done");
Si (n = = 0) {
Serial.println("aucun réseau trouvé");
} else {
Serial.print(n);
Serial.println("réseaux trouvés");
Pour (int i = 0; i < n; ++ i) {
// Impression du SSID et du RSSI pour chaque réseau trouvé
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)?"":"*");
delay(10);
}
}
Serial.println("");
// Attendre un peu avant de scanner à nouveau
delay(5000);
}

# Inclure <WiFi.h>
Const char * ssid = "your-ssid"; // votre nom WiFi
Const char * mot de passe = "votre-mot de passe"; // votre mot de passe WiFi
void setup()
{
Serial. start (115200);
delay(10);
// On commence par se connecter à un réseau WiFi
Serial.println();
Serial.println();
Serial.print("Connexion à");
Serial.println(ssid);
WiFi. start (ssid, mot de passe);
Tandis que (WiFi.status() ! = WL_CONNECTÉ) {
delay (500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connecté");
Serial.println("Adresse IP:")
Serial.println(WiFi.localIP());
}
void loop (){
}

# Inclure "WiFi.h"
void setup()
{
Serial. start (115200);
WiFi.softAP("ESP_AP", "123456789");
}
void loop()
{
Serial.print("Nom de l'hôte:");
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("Host mac Address:");
Serial.println(WiFi.softAPmacAddress());
Serial.print("Nombre de connexions hôte:");
Serial.println(WiFi.softAPgetStationNum());
Serial.print("Host Network ID:");
Serial.println(WiFi.softAPNetworkID());
Serial.print("État de l'hôte:");
Serial.println(WiFi.status());
delay(1000);
}

# Inclure <BLEDevice.h>
# Inclure <BLEUtils.h>
# Inclure <BLEScan.h>
# Inclure <BLEAdvertisedDevice.h>
Int scanTime = 5; // En secondes
BLEScan * pBLEScan;
Classe MyAdvertisedDeviceCallbacks: BLEAdvertisedDeviceCallbacks publics {
Void onResult(BLEAdvertisedDevice annoncé par Device) {
Serial.printf("Dispositif annoncé: % s \ n", advertisedDevice.toString().c_str());
}
};
void setup() {
Serial. start (115200);
Serial.println("Numérisation...");
BLEDevice::init("");
PBLEScan = BLEDevice::getScan(); // créer un nouveau scan
PBLEScan->setAdvertisedDeviceCallbacks (nouveau MyAdvertisedDeviceCallbacks());
PBLEScan->setActiveScan(true); // le scan actif utilise plus de puissance, mais obtient des résultats plus rapidement
PBLEScan->setInterval(100);
PBLEScan->setWindow(99); // valeur de setInterval inférieure ou égale
}
void loop() {
// Mettez votre code principal ici, pour exécuter à plusieurs reprises:
BLEScanResults foundDevices = pBLEScan-> démarrer (scanTime, faux);
Serial.print("Appareils trouvés:");
Serial.println(foundDevices.getCount());
Serial.println("Scan fait!");
PBLEScan->clearResults(); // supprimer les résultats du tampon BLEScan pour libérer la mémoire
delay(2000);
}

# Inclure <BLEDevice.h>
# Inclure <BLEUtils.h>
# Inclure <BLEServer.h>
// Voir ce qui suit pour générer des UUID:
// https://www.uuidgenerator.net/
# Définir SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
# Définir CARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
Classe MyCallbacks: BLECharacteristicCallbacks publics {
Void onWrite (BLECaractéristique * pCaractéristique) {
Std::string valeur = pCaractéristique->getValue();
if(valeur. longueur () > 0) {
Serial.println("*********");
Serial.print("Nouvelle valeur:");
for(int i = 0; i < value.length(); i ++)
Serial.print (valeur [i]);
Serial.println();
Serial.println("*********");
}
}
};
voir setup() {
Serial. start (115200);
BLEDevice::init("MyESP32");
BLEServer * pServer = BLEDevice::createServer();
BLEService * pService = pServer->createService(SERVICE_UUID);
BLECharacteristic * pCharacteristic = pService->createCharacteristic (
CARACTÉRISTIC_UUID,
BLECaractéristique::PROPERTY_READ |
BLECaractéristique::PROPERTY_WRITE
);
PCaractéristique->setCallbacks (nouveau MyCallbacks());
PCaractéristique->setValue("Hello World");
PService->start();
BLEAdvertising * pAdvertising = pServer->getAdvertising();
PAdvertising-> démarrer ();
}
void loop() {
// Mettez votre code principal ici, pour exécuter à plusieurs reprises:
delay(2000);
}

Broche numérique

Téléchargez le code sur le tableau et la LED intégrée s’allume chaque seconde.

// Définir la led selon le schéma des broches
Int led = 8;
void setup() {
// Initialisation de la broche numérique comme sortie
PinMode (led, sortie);
}
void loop() {
DigitalWrite (led, HIGH); // allumer la LED
Delay (1000); // attendre une seconde
DigitalWrite (led, LOW); // éteindre la LED
Delay (1000); // attendre une seconde
}

PWM numérique

Téléchargez le code suivant pour voir la LED embarquée diminuer progressivement.

Int ledPin = 8; // LED connectée à la broche numérique 10
void setup () {
// Déclaration de broche LED comme sortie
PinMode (ledPin, SORTIE);
}
void loop() {
// Fondu de min à max par incréments de 5 points:
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue + = 5) {
// Définit la valeur (comprise entre 0 et 255):
AnalogWrite (ledPin, fadeValue);
// Attendez 30 millisecondes pour voir l'effet de gradation
delay(30);
}
// Fondu de max à min par incréments de 5 points:
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {
// Définit la valeur (comprise entre 0 et 255):
AnalogWrite (ledPin, fadeValue);
// Attendez 30 millisecondes pour voir l'effet de gradation
delay(30);
}
}

Broche analogique

Connectez le potentiomètre à la broche A5 et téléchargez le code suivant pour contrôler l’intervalle de clignotement de la LED en tournant le bouton du potentiomètre.

Const int sensorPin = A5;
Const int ledPin = 8;
void setup() {
PinMode (sensorPin, INPUT); // déclare le sensorPin comme INPUT
PinMode (ledPin, OUTPUT); // déclare le ledPin comme SORTIE
}
void loop() 
// Lecture de la valeur depuis le capteur:
Int sensorValue = analogRead(sensorPin);
// Allumer le ledPin
DigitalWrite (ledPin, HIGH);
// Arrêt du programme pour <sensorValue> millisecondes:
delay(sensorValue);
// Éteindre le ledPin:
DigitalWrite (ledPin, LOW);
// Arrêter le programme pour les millisecondes <sensorValue>:
delay(sensorValue);
}

Serial port :

Hardware serial port, there are two hardware serial ports on the board :
USB serial port
UART serial port
By default, USB serial is enabled, which means you can connect the development board to a PC via USC Type-C and turn on the serial monitor on the Arduino IDE to see the data send via serial.

Détails

PaquetSopPersonnaliséOui
Numéro de ModèleESP32Température de fonctionnement1
Puissance de dissipationSuperMini Development BoardTension d’alimentation1
ConditionNouveauTypeRÉGULATEUR DE TENSION
Nom de marqueTENSTAR ROBOTOrigineCN (Origine)

L’ESP32-3C Super Mini est une carte de développement miniature et économique basée sur le microcontrôleur Espressif ESP32-C3. Elle permet de se connecter au Wi-Fi et au Bluetooth (BLE) et se distingue par sa petite taille de 19x24mm.

Caractéristiques principales:

Microcontrôleur: ESP32 C3
CPU: 1 cœur 32 bits
Architecture: RISC-V
Fréquence de fonctionnement: 160 MHz
RAM: 400 Ko
Tension de fonctionnement: 3,3 V
Entrées/sorties: 11+TX-RX
Interfaces: 1 × SPI, 1 × I2C, 1 × UART

Avantages:

Taille compacte: Idéale pour les projets IoT où l’espace est limité
Faible coût: Solution économique pour le développement de prototypes
Wi-Fi et Bluetooth: Connectivité sans fil intégrée
Microcontrôleur puissant: Processeur RISC-V 32 bits pour des performances élevées
Facile à utiliser: Compatible avec l’IDE Arduino et MicroPython

Utilisations possibles:

Domotique: Contrôle d’appareils électriques, surveillance de capteurs
Wearables: Montres intelligentes, bracelets connectés
Robotique: Contrôle de robots, drones
Prototypes IoT: Développement de produits connectés

Laisser un commentaireAnnuler la réponse.

Shopping cart