Fotocamera PANTILT con ESP32: 9 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Oggi presenterò il PAN TILT, che è un dispositivo che consente il movimento di una telecamera per le direzioni su, giù e ai lati. Io stesso ho prodotto questo dispositivo attraverso parti stampate in 3D, utilizzando due servi e l'ESP32, che consente di controllare questo meccanismo tramite WiFi. Prendiamo quindi le letture utilizzando i canali AD dell'ESP32, nonché un'operazione analogica utilizzando il controller LED_PWM. Inoltre, applichiamo il controllo su una connessione TCP/IP.

Nel video si vede che ho un ESP32 che legge i valori dei due potenziometri, che vengono inviati (via WiFi) ad un altro ESP32. È collegato ai due servomotori. La telecamera si muove (ed è attaccata al PAN TILT) nelle direzioni di su, giù o lateralmente, a seconda del controllo che fai attraverso i vasi.

Il collegamento al progetto di stampa 3D PAN TILT può essere trovato qui:

Passaggio 1: risorse utilizzate

• Ponticelli multipli per il collegamento

• Due nodi MCU ESP32s

• Due cavi USB per ESP32

• Una webcam per il controllo

• Due pentole di controllo

• Una scheda prototipi

• Una fonte per i servi

Passaggio 2: NodeMCU ESP32S - Pinout

Passaggio 3: periferiche ESP32

Periferiche PWM L'ESP32 ha due periferiche in grado di generare segnali PWM. Questi includono il motore Pulse Width Modulator (MCPWM) progettato per il controllo della potenza e del motore e il LED_PWM, sviluppato per il controllo dell'intensità dei LED. Ma possono essere usati anche in modo generico.

Utilizzeremo il LED_PWM, che può generare 16 canali PWM indipendenti con periodi e cicli di lavoro configurabili. Ha fino a 16 bit di risoluzione.

Passaggio 4: controllo del servomotore PWM

Il controllo del servomotore viene eseguito regolando la modulazione di larghezza di impulso di un quadrato con frequenza specifica.

Per il servo utilizzato (così come per la maggior parte), la frequenza è a 50Hz. Inoltre, un'ampiezza da 1 a 2 ms di lunghezza dell'impulso determina la posizione angolare del servo.

Indirizzeremo il canale 0 di LED_PWM a GPIO13 e il canale 1 a GPIO12, utilizzando queste informazioni per eseguire il controllo.

Passaggio 5: acquisizione analogica

Periferica di conversione da analogico a digitale

L'ESP32 ha convertitori analogico-digitale che possono essere applicati in un massimo di 18 canali, ma solo in GPIO abilitati per l'analogico.

La tensione applicata non deve superare la gamma da 0 a 3V.

La conversione effettuata non mantiene un errore costante per tutte le tensioni campionate, e tutto questo dipende dal range configurato. Per un intervallo di 150 mV a 2, 450 V, è necessario un controllo del comportamento per le applicazioni più critiche.

Per la cattura utilizzeremo un potenziometro da 10k come divisore di tensione. La cattura verrà effettuata nel canale ADC0 e ADC3, accessibile da GPIO36 e GPIO39.

Passaggio 6: Circuito - Server e client

Passaggio 7: codice sorgente del punto di accesso e del server

Dichiarazioni

Includo la libreria WiFi e definisco alcune variabili.

#include // inclusão da biblioteca WiFi const int freq = 50; //frequenza do PWM const int canal_A = 0; //primeiro canal do controlador LED_PWM const int canal_B = 1; //segundo canal do controlador LED_PWM const int resolucao = 12; //Risoluzione dell'uso senza controllo LED_PWM const int pin_Atuacao_A = 13; //Pino para onde o canal 0 será redirecionado const int pin_Atuacao_B = 12; //Pino para onde o canal 1 será redirecionado const char* ssid = "ESP32ap"; //constante com o SSID do WiFi do ponto de acesso ESP32 const char* password = "12345678"; //senha para confirmação de conexão no ponto de acesso const int port = 2; //porta na qual o servidor receberá as conexões int ciclo_A = 0; //variável que receberá o ciclo de atuação do canal A int ciclo_B = 0; //variável que receberá o ciclo di attuação do canal A WiFiServer server(port); //dichiarazione dell'oggetto del server IPAddress myIP; //dichiarazione della variazione di IP

Impostare ()

Qui, definiamo i pin di uscita. Impostiamo i canali sulla frequenza desiderata e impostiamo il valore PWM.

void setup(){ pinMode(pin_Atuacao_A, OUTPUT); //definindo o pino de atuação A come saída pinMode(pin_Atuacao_B, OUTPUT); //definindo o pino de atuação B come saída ledcSetup(canal_A, freq, resolucao); //Regolazione del canale 0 per frequenza di 50 Hz e risoluzione di 12 bit ledcSetup(canal_B, freq, resolucao); //Regolazione del canale 1 per frequenza di 50 Hz e risoluzione di 12 bit ledcAttachPin(pin_Atuacao_A, canal_A); //redirecionando o canal 0 para o pino 13 ledcAttachPin(pin_Atuacao_B, canal_B); //redirecionando o canal 1 para o pino 12 ledcWrite(canal_A, ciclo_A); //definindo o valor do PWM para 0 ledcWrite(canal_B, ciclo_B); //definindo o valor do PWM para 0

Abbiamo avviato il seriale, il punto di accesso con SSID ESP32ap e la password. Quindi otteniamo l'IP del server e avviamo il server.

Serial.begin(115200); //iniciando a Serial Serial.println("Iniciando ponto de acesso: " + String(ssid)); //mensagem WiFi.softAP (ssid, password); //iniciando o ponto de acesso com SSID ESP32ap e senha 12345678 Serial.println("Obtendo IP"); //mensagem mioIP = WiFi.softAPIP (); //ottenere l'IP del server (come se non fosse configurato deverá ser o padrão de fábrica) Serial.println("IP: " + WiFi.localIP()); //mensagem Serial.println("Iniziando il servizio em: " + String(port)); //mensagem server.begin(); //iniciando o servidor }

Ciclo continuo ()

In Loop, la prima cosa che faremo è istanziare il client, connettendoci e legando alla variabile client. Controlla se il client è connesso. In tal caso, avviamo la variabile che riceverà i dati. Finché la connessione è stabilita e se vengono ricevuti dati, leggiamo i caratteri per la variabile c. Infine, concateniamo c nella variabile data.

void loop() { WiFiClient cliente = server.available(); //se um cliente conectar, associe a variável cliente if (cliente.connected()) { //se há um cliente conectado String dados = ""; //inicia a variável que receberá os dados Serial.println("Cliente connesso."); //mensagem while (cliente.connected()) { //enquanto a conexão estivor stabelecida if (cliente.available()) { //e se hover dados a receber char c = cliente.read(); //leia os caracteres para a variável c dados = dados + c; //concatene c na variável dados

Se viene ricevuto un carattere di nuova riga, cerchiamo l'indice del carattere ', ' nella stringa nei dati. Otteniamo le sottostringhe fino a poco prima della virgola, quindi le convertiamo in interi. Impostiamo il PWM dei canali A e B. Cancelliamo la variabile.

if (c == '\n') { //se um caracter de nova linha for recebido int virgula = dados.indexOf(', '); //procure pelo índice do caracter ', ' su una stringa in dados ciclo_A = (dados.substring(0, virgula)).toInt(); //obtenha una sottostringa prima della modifica e converta per intero ciclo_B = dados.substring(virgula + 1, dados.length()).toInt();//obtenha una sottostringa per intero e converta per intero ledcWrite(canal_A, ciclo_A); //Ajusta o PWM do canal A ledcWrite(canal_B, ciclo_B); //Ajusta o PWM do canal B dados = ""; //Limpa a variável } } } }

Se il client si disconnette, confermiamo la fine della connessione. Aspettiamo un attimo e stampiamo "Nessun client connesso". Aspettiamo quindi un altro secondo prima di riavviare.

// caso o cliente se desconecte, confirma o fim da conexão delay(50); //aguarda um momento cliente.stop(); Serial.println("Nenhum cliente connesso."); //mensagem delay(1000); //aguarda um segundo antes de reiciar }

Passaggio 8: codice sorgente del cliente

Dichiarazioni

Abbiamo incluso di nuovo la libreria WiFi, questa volta sul client. Inoltre, definiamo le variabili.

#include const char* ssid = "ESP32ap"; //SSID fa il punto di accesso ESP32 const char* password = "12345678"; //Senha para acessar o ponto de acesso const uint16_t port = 2; //Porta de escuta do servidor const char * host = "192.168.4.1"; //endereço IP do servidor const int pin_Leitura_A = 36; //GPIO de leitura do ADC0 const int pin_Leitura_B = 39; //GPIO di misura in ADC3 int ciclo_A = 0; //variável que receberá o valor do ciclo do PWM A int ciclo_B = 0; //Variável que receberá o valor do ciclo do PWM B WiFiClient cliente; //dichiarazione dell'oggetto cliente

Impostare ()

Definiamo i GPIO come input, avviamo la seriale e ci colleghiamo all'access point.

void setup(){ pinMode(pin_Leitura_A, INPUT); //define o GPIO come entrada pinMode(pin_Leitura_B, INPUT); //define o GPIO come entrada Serial.begin(115200); //inicia a comunicação serial WiFi.begin(ssid, password); //conecta ao ponto de acesso }

Ciclo continuo ()

In questo Loop, ci collegheremo al server, ovvero all'altro ESP.

void loop(){ //se non connesso a un punto di accesso, tenta se conectar while (WiFi.status() != WL_CONNECTED) { Serial.println(String(millis()) + " - Conectando no WiFi " + ssid + "…"); //mensagem WiFi.begin(ssid, password); ritardo (2000); } Serial.println(String(millis()) + " - Collegamento…"); //mensagem //se non connesso ao servidor, tenta se conectar while (!cliente.connect(host, port)) { Serial.println(String(millis()) + " - Conectando no Servidor " + host + ":" + porta + "…"); //mensagem delay(1000); }

In questo passaggio, mentre siamo connessi al server, eseguiamo le variabili per memorizzare la lettura di ADC0 e ADC3. Inoltre, abbiamo eseguito la lettura di 500 campioni e fatto la media delle letture. Abbiamo mappato la lettura per creare la durata corretta per il controllo dei servi, e concatenarla e inviarla al server.

//enquanto estiver conectado ao servidor while (cliente.connected()) { int leitura_A = 0; //variável para armazenar a leitura do ADC0 int leitura_B = 0; //variável para armazenar a leitura do ADC3 int amostras = 500; //número de amostras int contador = 0; //contador de amostras while (contador < amostras) { //acumua várias leituras leitura_A = leitura_A + analogRead(pin_Leitura_A); leitura_B = leitura_B + analogRead(pin_Leitura_B); contattore++; } leitura_A = leitura_A / amostras; //media das leituras leitura_B = leitura_B / amostras; ciclo_A = map(leitura_A, 0, 4095, 140, 490); //mapeia a leitura para criar a duração correta para controle do servo ciclo_B = map(leitura_B, 0, 4095, 140, 490); //mapeia a leitura para criar a duração correta para controle do servo //concatena e envia para o servidor cliente.println(String(ciclo_A) + ", " + String(ciclo_B)); }

Infine, se non connesso, ci assicuriamo che la connessione sia stata terminata visualizzando il messaggio equivalente.

//se não coonectado, garante que a conexão foi finalzada cliente.stop(); Serial.println(String(millis()) + " - cliente desconectado…"); // messaggio }

Passaggio 9: file

Scarica i file:

PDF

IO NO