Mini proiect (52) - Comunicația SPI între două plăci ESP32 - trimiterea valorii de la potențiometru

Publicat de pe

Comunicația SPI între două plăci ESP32 - trimiterea valorii unui potențiometru

Scopul proiectului

  Scopul acestui proiect este de a trimite valoare unui potențiometru prin intermediul interfeței de comunicație SPI între două plăci ESP32.

Descriere

  • Proiectul utilizează două plăci ESP32, una configurată ca master și cealaltă ca slave, pentru a permite comunicarea între ele prin intermediul interfeței SPI (Serial Peripheral Interface).
  • Pe placa master, un potențiometru este conectat la pinul D34. Acest potențiometru este utilizat pentru a regla o valoare analogică (de exemplu, tensiunea) care va fi trimisă plăcii slave prin SPI.
  • Placa slave primește valoarea de la placa master prin SPI și o interpretează ca o valoare analogică relevantă pentru aplicație (de exemplu, în cazul programului va aprinde LED-ul pentru testare).
  • Datele trimise și primite între cele două plăci ESP32 pot fi utilizate pentru a controla sau monitoriza o aplicație specifică, cum ar fi un robot, o platformă de automatizare sau un sistem de feedback.

Funcționalitatea

  1. Placa master citește valoarea potențiometrului la pinul analogic D34 și o trimite plăcii slave prin intermediul SPI.
  2. Placa slave primește valoarea și o interpretează în funcție de necesitățile aplicației.
  3. Datele pot fi folosite pentru a controla sau monitoriza dispozitive sau procese în funcție de distanță sau poziționare.

 ESP32

Plăcile ESP32 sunt platforme de dezvoltare hardware bazate pe cipuri ESP32, care sunt microcontrolere cu WiFi și Bluetooth integrate produse de Espressif Systems. Aceste plăci oferă o serie de caracteristici cheie care le fac foarte populare în dezvoltarea de proiecte IoT (Internet of Things) și în alte aplicații integrate. Iată câteva dintre caracteristicile principale ale unei plăci ESP32:


 

  • Procesor puternic: ESP32 este echipat cu un procesor dual-core Xtensa LX6, care rulează la frecvențe de până la 240 MHz. Aceasta oferă o putere de calcul semnificativă pentru gestionarea unor sarcini complexe.

  • WiFi integrat: ESP32 vine cu un modul WiFi 802.11 b/g/n incorporat, care permite conectarea la rețelele WiFi. Acest lucru deschide posibilități pentru conectivitatea la internet și comunicarea cu alte dispozitive și servicii online.

  • Bluetooth Low Energy (BLE): ESP32 suportă Bluetooth Classic și Bluetooth Low Energy (BLE). Acest lucru permite comunicarea cu dispozitivele Bluetooth, precum și crearea de aplicații IoT cu consum redus de energie.

  • Conectivitate duală: ESP32 poate funcționa simultan pe WiFi și Bluetooth, ceea ce face posibilă dezvoltarea de aplicații care implică atât comunicația locală cât și cea pe internet.

  • GPIO (General-Purpose Input/Output) versatil: ESP32 dispune de o serie de pini GPIO care pot fi configurați pentru diferite funcții, cum ar fi citirea și scrierea semnalelor digitale, comunicarea serială, PWM (modularea lățimii pulsului), etc.

  • Interfață serială (UART, SPI, I2C): ESP32 oferă multiple porturi UART, SPI și I2C, permițând comunicarea cu o varietate de dispozitive și senzori.

  • Memorie generoasă: ESP32 are o memorie flash integrată pentru stocarea programelor și a datelor. Există, de asemenea, o memorie RAM suficientă pentru a gestiona sarcinile și datele în timpul execuției.

  • Securitate îmbunătățită: ESP32 oferă funcționalități de securitate îmbunătățite, inclusiv suport pentru SSL/TLS pentru comunicarea securizată și opțiuni de criptare a datelor.

  • Capabilități de sleep și consum redus de energie: ESP32 are moduri de somn eficiente care permit reducerea consumului de energie, ceea ce îl face potrivit pentru aplicații alimentate cu baterii.

  • Suport pentru dezvoltarea de software: Există o varietate de medii de dezvoltare software pentru ESP32, inclusiv Arduino IDE, PlatformIO, și ESP-IDF (ESP32 IoT Development Framework) dezvoltat de Espressif Systems.

  • Ecosistem vast de biblioteci și comunitate activă: Datorită popularității sale, ESP32 beneficiază de o comunitate activă de dezvoltatori, care a creat o serie de biblioteci și resurse disponibile pentru a facilita dezvoltarea de proiecte.

  • Preț accesibil: ESP32 este o platformă de dezvoltare relativ accesibilă, ceea ce o face atractivă pentru proiecte de buget sau pentru prototipuri.

Aceste caracteristici fac din plăcile ESP32 o opțiune populară pentru dezvoltatorii care doresc să creeze aplicații IoT și proiecte integrate, datorită capacității lor de a oferi conectivitate, putere de calcul și versatilitate la un cost rezonabil.

Potențiometrul

Un potențiometru este un dispozitiv electronic pasiv utilizat pentru a regla nivelul unei tensiuni sau a unei rezistențe într-un circuit electric. Acesta funcționează pe baza principiului variației rezistenței electrice atunci când un contact mișcător este deplasat pe o suprafață rezistivă. Iată cum funcționează un potențiometru:

  • Construcția potențiometrului:
    • Un potențiometru constă în mod obișnuit dintr-un corp cilindric sau rectangular din material izolator (cum ar fi plasticul sau ceramica) cu o suprafață exterioară sau un element rezistiv.
    • Pe suprafața exterioară a potențiometrului este aplicat un strat subțire de material rezistiv, cum ar fi carbon, nichrom sau alte materiale rezistive.
    • Între acest strat rezistiv și un contact mișcător (adesea sub formă de "sârmă" sau "cursor") există un punct de contact care poate fi deplasat în sus sau în jos pe suprafața rezistivă.
       

  • Varierea rezistenței:

    • Mutația cursorului de-a lungul suprafeței rezistive modifică lungimea totală a rezistorului utilizat în circuitul asociat potențiometrului.
    • Cu cât cursorul este mai aproape de un capăt al rezistivului, cu atât rezistența dintre cursor și acel capăt este mai mică, iar cu cât este mai aproape de celălalt capăt, cu atât rezistența este mai mare.
    • Prin urmare, mișcarea cursorului modifică valoarea rezistenței efective între cele două capete ai potențiometrului.

  • Utilizări:

    • Potențiometrele sunt folosite pentru a controla și ajusta o varietate de parametrii într-un circuit electric, cum ar fi volumul unui difuzor, luminozitatea unui ecran sau temperatura unui termostat.
    • Ele sunt folosite în multe aplicații în care trebuie să se facă ajustări manuale ale nivelurilor de tensiune sau curent.

  • Tipuri de potențiometre:

    • Există două tipuri principale de potențiometre: potențiometre rotative (de tipul "knob") și potențiometre liniare (de tipul "slide").
    • Potențiometrele pot fi simple sau pot avea mai multe benzi (de obicei, trei) pentru a oferi multiple căi de acces la variabilele de control.

  • Conexiuni:

    • Potențiometrele pot fi conectate într-o varietate de moduri în circuitele electrice, în funcție de modul în care trebuie să influențeze circuitul. Cele mai comune conexiuni includ utilizarea a trei terminale: unul pentru terminalul de intrare, unul pentru terminalul de ieșire și unul pentru terminalul cursorului.

În esență, potențiometrul este un instrument simplu, dar eficient, care oferă o modalitate de a regla sau controla nivelurile de tensiune sau rezistență într-un circuit electric prin ajustarea poziției unui cursor pe o suprafață rezistivă.

  Conectarea

Conectare pinilor SPI între cele două module ESP32. Conexiunile tipice includ:

  • MOSI (Master Out Slave In) de la un ESP32 la pinul MOSI al celuilalt ESP32.
  • MISO (Master In Slave Out) de la un ESP32 la pinul MISO al celuilalt ESP32.
  • SCK (Serial Clock) de la un ESP32 la pinul SCK al celuilalt ESP32.
  • SS/CS (Slave Select/Chip Select) - Aceasta este linia de selectare a slave-ului. Puteți folosi oricare dintre pinii disponibili, dar asigurați-vă ca setați pinii corect in codul dvs.
  • D23 de la ESP32 se conectează la borna din mijloc a potențiometrului.
  • Borna 1 a potențiometrului se conectează la 5V iar borna 3 la GND

 Componente


Schema electronică/sistem



Cod de test

Master
/*
Florin Simedru
Complete project details at https://blog.automatic-house.ro
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
/*
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[env:esp32doit-devkit-v1]
platform = espressif32
board = esp32doit-devkit-v1
framework = arduino
upload_port = COM12
monitor_port = COM12
monitor_speed = 115200
*/
#include <Arduino.h>
#include <SPI.h>
// Define ALTERNATE_PINS to use non-standard GPIO pins for SPI bus
#ifdef ALTERNATE_PINS
#define HSPI_MISO 26
#define HSPI_MOSI 27
#define HSPI_SCLK 25
#define HSPI_SS 32
#else
#define SPI_MISO MISO
#define SPI_MOSI MOSI
#define SPI_SCLK SCK
#define SPI_SS SS
#endif
void spi_send_command(uint8_t data);
static const int spiClk = 1000000; // 1 MHz
// Potentiometer is connected to GPIO 34 (Analog ADC1_CH6)
const int potPin = 34;
// variable for storing the potentiometer value
int potValue = 0;
// uninitalised pointers to SPI objects
SPIClass *hspi = NULL;
SPIClass *vspi = NULL;
void setup()
{
// initialise instance of the SPIClass attached to HSPI
hspi = new SPIClass(HSPI);
vspi = new SPIClass(VSPI);
// put your setup code here, to run once:
Serial.begin(115200);
Serial.print("MOSI: ");
Serial.println(MOSI);
Serial.print("MISO: ");
Serial.println(MISO);
Serial.print("SCK: ");
Serial.println(SCK);
Serial.print("SS: ");
Serial.println(SS);
// clock miso mosi ss
#ifndef ALTERNATE_PINS
// initialise hspi with default pins
// SCLK = 14, MISO = 12, MOSI = 13, SS = 15
vspi->begin(SPI_SCLK, SPI_MISO, SPI_MOSI, SPI_SS);
#else
// alternatively route through GPIO pins
hspi->begin(HSPI_SCLK, HSPI_MISO, HSPI_MOSI, HSPI_SS); // SCLK, MISO, MOSI, SS
#endif
// set up slave select pins as outputs as the Arduino API
// doesn't handle automatically pulling SS low
pinMode(SPI_SS, OUTPUT); // SPI SS
}
// the loop function runs over and over again until power down or reset
void loop()
{
potValue = analogRead(potPin);
Serial.print("Analog Data: ");
Serial.println(potValue);
uint8_t val = map(potValue, 0,4095, 0, 255);
spi_send_command(val);
delay(100);
}
void spi_send_command(uint8_t data)
{
vspi->beginTransaction(SPISettings(spiClk, MSBFIRST, SPI_MODE0));
digitalWrite(SPI_SS, LOW);
vspi->transfer(data);
Serial.print("SPI Data: ");
Serial.println(data);
digitalWrite(SPI_SS, HIGH);
vspi->endTransaction();
}
view raw ESP_SPI_Master.ino hosted with ❤ by GitHub
Slave
/*
Florin Simedru
Complete project details at https://blog.automatic-house.ro
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
/*
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[env:esp32doit-devkit-v1]
platform = espressif32
board = esp32doit-devkit-v1
framework = arduino
upload_port = COM9
monitor_port = COM9
monitor_speed = 115200
lib_deps = hideakitai/ESP32SPISlave@^0.2.0
*/
#include <ESP32SPISlave.h>
ESP32SPISlave slave;
static constexpr uint32_t BUFFER_SIZE{32};
uint8_t spi_slave_tx_buf[BUFFER_SIZE];
uint8_t spi_slave_rx_buf[BUFFER_SIZE];
#define LED 2
void setup()
{
Serial.begin(115200);
delay(2000);
pinMode(LED, OUTPUT);
// begin() after setting
// HSPI = CS: 15, CLK: 14, MOSI: 13, MISO: 12 -> default
// VSPI = CS: 5, CLK: 18, MOSI: 23, MISO: 19
slave.setDataMode(SPI_MODE0);
//slave.begin();
slave.begin(VSPI); // you can use VSPI like this
// clear buffers
memset(spi_slave_tx_buf, 0, BUFFER_SIZE);
memset(spi_slave_rx_buf, 0, BUFFER_SIZE);
}
void loop()
{
// block until the transaction comes from master
slave.wait(spi_slave_rx_buf, spi_slave_tx_buf, BUFFER_SIZE);
// if transaction has completed from master,
// available() returns size of results of transaction,
// and buffer is automatically updated
char data;
while (slave.available())
{
// show received data
Serial.print("Command Received: ");
Serial.println(spi_slave_rx_buf[0]);
data = spi_slave_rx_buf[0];
slave.pop();
}
if (data == 255)
{
Serial.println("Setting LED active HIGH ");
digitalWrite(LED, HIGH);
}
else if (data == 0)
{
Serial.println("Setting LED active LOW ");
digitalWrite(LED, LOW);
}
Serial.println("");
}
view raw ESP32_SPI_slave.ino hosted with ❤ by GitHub

Rezultat

Documentație proiect

Afiliere eMag:

 Linkurile de la secțiunea "Componente" conțin adresa mea de afiliere la eMag.ro, iar dacă cumperi folosind aceste linkuri vei susține blogul meu. Mulțumesc! 

eMag Genius:
Hai și tu în Genius! Abonează-te la Genius 12 luni și primești beneficii premium și 20 lei card cadou eMAG. Profită acum! eMag Genius

Mulțumesc pentru atenție!

Pentru întrebări și/sau consultanță tehnică vă stau la dispozitie pe blog mai jos în secțiunea de comentarii sau pe email simedruflorin@automatic-house.ro. O zi plăcută tuturor ! 

 Back to top of page


Etichete

Afișați mai multe

Arhiva

Afișați mai multe