PANTILT-Kamera mit ESP32 - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Heute stelle ich den PAN TILT vor, ein Gerät, das die Bewegung einer Kamera für die Richtungen nach oben, unten und zur Seite ermöglicht. Ich selbst habe dieses Gerät durch 3D-gedruckte Teile hergestellt, unter Verwendung von zwei Servos und dem ESP32, der es ermöglicht, diesen Mechanismus über WiFi zu steuern. Lassen Sie uns dann Messwerte über die AD-Kanäle des ESP32 sowie einen analogen Betrieb mit dem Controller LED_PWM vornehmen. Außerdem wenden wir die Kontrolle über eine TCP/IP-Verbindung an.

Im Video sehen Sie, dass ich einen ESP32 habe, der die Werte der beiden Potentiometer ausliest, die (über WiFi) an einen anderen ESP32 gesendet werden. Es ist mit den beiden Servomotoren verbunden. Die Kamera bewegt sich (und ist am PAN TILT) in die Richtungen nach oben, unten oder seitwärts, abhängig von der Steuerung, die Sie durch die Töpfe vornehmen.

Den Link zum PAN TILT 3D-Druckdesign finden Sie hier:

Schritt 1: Verwendete Ressourcen

• Mehrere Jumper für den Anschluss

• Zwei-Knoten-MCU ESP32s

• Zwei USB-Kabel für den ESP32

• Eine WebCam zur Kontrolle

• Zwei Kontrolltöpfe

• Ein Protoboard

• Eine Quelle für die Servos

Schritt 2: NodeMCU ESP32S - Pinbelegung

Schritt 3: ESP32-Peripheriegeräte

PWM-Peripheriegeräte Der ESP32 verfügt über zwei Peripheriegeräte, die PWM-Signale erzeugen können. Dazu gehören der Pulse Width Modulator (MCPWM)-Engine, der für die Leistungs- und Motorsteuerung entwickelt wurde, und der LED_PWM, der für die LED-Intensitätssteuerung entwickelt wurde. Sie können aber auch generisch verwendet werden.

Wir verwenden den LED_PWM, der 16 unabhängige PWM-Kanäle mit konfigurierbaren Perioden und Arbeitszyklen generieren kann. Es hat eine Auflösung von bis zu 16 Bit.

Schritt 4: Servomotorsteuerung PWM

Die Servomotorsteuerung erfolgt durch Einstellen der Pulsweitenmodulation eines Rechtecks mit einer bestimmten Frequenz.

Für das verwendete Servo (wie auch für die meisten) liegt die Frequenz bei 50 Hz. Außerdem bestimmt eine Impulsbreite von 1 bis 2 ms die Winkelposition des Servos.

Wir leiten Kanal 0 von LED_PWM an GPIO13 und Kanal 1 an GPIO12 und verwenden diese Informationen, um die Steuerung durchzuführen.

Schritt 5: Analoge Aufnahme

Analog-Digital-Umwandlungs-Peripheriegerät

Der ESP32 verfügt über Analog-Digital-Wandler, die in bis zu 18 Kanälen eingesetzt werden können, jedoch nur in analog-fähigen GPIOs.

Die angelegte Spannung darf den Bereich von 0 bis 3V nicht überschreiten.

Die durchgeführte Konvertierung hält nicht für alle abgetasteten Spannungen einen konstanten Fehler aufrecht, und dies hängt alles vom konfigurierten Bereich ab. Für einen Bereich von 150 mV bei 2.450 V ist bei kritischeren Anwendungen eine Verhaltensprüfung erforderlich.

Für die Erfassung verwenden wir ein Potentiometer von 10k als Spannungsteiler. Die Erfassung erfolgt in den Kanälen ADC0 und ADC3, auf die über GPIO36 und GPIO39 zugegriffen werden kann.

Schritt 6: Circuit - Server und Client

Schritt 7: Quellcode des Access Points und Servers

Aussagen

Ich schließe die WiFi-Bibliothek ein und definiere einige Variablen.

#include // Inklusion der Biblioteca WiFi const int freq = 50; // Frequenz tun 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; // Auflösung ohne Steuerung 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"; //constant com o SSID do WiFi tun Ponto de Accesso 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 Kanal A int ciclo_B = 0; //variável que receberá o ciclo de atuação do canal Ein WiFiServer-Server (Port); //Deklaration des Zielservers IPAddress myIP; //declaração da variável de IP

Aufstellen ()

Hier definieren wir die Ausgangspins. Wir stellen die Kanäle auf die gewünschte Frequenz ein und stellen den PWM-Wert ein.

Void setup () {pinMode (pin_Atuacao_A, AUSGANG); // Definindo oder pino de atuação A como saída pinMode (pin_Atuacao_B, OUTPUT); //definindo oder pino de atuação B como saída ledcSetup(canal_A, freq, resolucao); // Einstellung des Kanals 0 für 50 Hz-Frequenz und 12-Bit-Auflösung ledcSetup (Kanal_B, Frequenz, Auflösung); // Einstellung des Kanals 1 für Frequenz von 50 Hz und Auflösung von 12 Bit ledcAttachPin (pin_Atuacao_A, canal_A); //redirectionando o canal 0 para o pino 13 ledcAttachPin (pin_Atuacao_B, canal_B); //redirectionando 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

Wir haben die Seriell, den Zugangspunkt mit der SSID ESP32ap und dem Passwort gestartet. Wir bekommen dann die IP des Servers und starten den Server.

Serial.begin(115200); // iniciando eine Serial Serial.println ("Iniciando ponto de acesso: " + String (ssid)); // mensagem WiFi.softAP (ssid, passwort); // iniciando oder ponto de acesso com SSID ESP32ap und senha 12345678 Serial.println ("Obtendo IP"); // mensagem myIP = WiFi.softAPIP (); // Obtendo o IP do servidor (como não foi configurado deverá ser or padrão de fábrica) Serial.println ("IP: " + WiFi.localIP()); // mensagem Serial.println ("Iniciando servidor em: " + String (Port)); //mensagem server.begin(); //iniciando oder servidor}

Schleife ()

In Loop werden wir als erstes den Client instanziieren, eine Verbindung herstellen und an die Clientvariable binden. Überprüfen Sie, ob der Client verbunden ist. Wenn ja, starten wir die Variable, die die Daten empfängt. Solange die Verbindung besteht und Daten empfangen werden, lesen wir die Zeichen für die Variable c. Schließlich verketten wir c in der Datenvariablen.

Void Schleife () { WiFiClient-Client = server.available (); //Sehen Sie einen Kundenanschluss, vereinigen Sie einen anderen Kunden if (cliente.connected()) { //Sehen Sie einen Kundenanschluss an String dados = ""; // Initiale eine Variável que Receberá os dados Serial.println ("Cliente conectado."); //Mensagem while (cliente.connected()) { //enquanto a conexão estiver estabelecida if (cliente.available()) { //e se houver dados a receber char c = cliente.read(); //leia os caracteres para a variável c dados = dados + c; // verketten c na variável dados

Wenn ein Newline-Zeichen empfangen wird, suchen wir den Index des Zeichens ', ' im String in den Daten. Wir erhalten die Teilstrings bis kurz vor dem Komma und konvertieren sie dann in Integer. Wir stellen die PWM der Kanäle A und B ein. Wir löschen die Variable.

if (c == '\n') {//se um caracter de nova linha für recebido int virgula = dados.indexOf(', '); // pelo beschaffen índice do caracter ', ' na string em dados ciclo_A = (dados.substring(0, virgula)).toInt(); //obtenha eine Teilzeichenfolge antes da vírgula e converta para inteiro ciclo_B = dados.substring(virgula + 1, dados.length()).toInt();//obtenha eine Teilzeichenfolge após a vírgula e converta para inteiro ledcWrite(canal_A, ciclo_A); // Ajusta o PWM tun Kanal A ledcWrite (canal_B, ciclo_B); // Ajusta o PWM tun Kanal B dados = ""; //Limpa a variável } } } }

Wenn der Client die Verbindung trennt, bestätigen wir das Ende der Verbindung. Wir warten einen Moment und drucken "Kein Client verbunden". Wir warten dann noch eine Sekunde, bevor wir neu starten.

// caso o cliente se desconecte, Confirma o Fim da conexão delay(50); //aguarda um momento cliente.stop(); Serial.println ("Nenhum cliente conectado."); // Mensagem-Verzögerung (1000); //aguarda um segundo antes de reiniciar}

Schritt 8: Kundenquellcode

Aussagen

Wir haben die WiFi-Bibliothek wieder aufgenommen, diesmal auf dem Client. Außerdem definieren wir die Variablen.

#include const char* ssid = "ESP32ap"; //SSID ponto de acesso 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 tun ADC0 const int pin_Leitura_B = 39; // GPIO de leitura tun 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-Client; //declaração do objeto cliente

Aufstellen ()

Wir definieren die GPIOs als Eingang, starten die Serielle und verbinden uns mit dem Access Point.

Void setup () {pinMode (pin_Leitura_A, INPUT); // GPIO-Como-Entrada definieren PinMode (pin_Leitura_B, INPUT); // GPIO-Como-Entrada definieren Serial.begin (115200); //Initiiere eine serielle WiFi.begin(ssid, password); //conecta ao ponto de acesso}

Schleife ()

In dieser Schleife verbinden wir uns mit dem Server, also dem anderen ESP.

Void loop () {//se não conectado ao ponto de acesso, tenta se conectar while (WiFi.status () != WL_CONNECTED) { Serial.println (String (millis ()) + " - Conectando no WiFi " + ssid + „…“); // mensagem WiFi.begin (ssid, passwort); Verzögerung (2000); } Serial.println (String (millis ()) + " - Conectado …"); // mensagem // se não conectado ao servidor, tenta se conectar while (!cliente.connect (host, port)) { Serial.println (String (millis ()) + " - Conectando no Servidor " + host + ":" + Port + "…"); // Mensagem-Verzögerung (1000); }

In diesem Schritt führen wir, während wir mit dem Server verbunden sind, die Variablen aus, um den Messwert von ADC0 und ADC3 zu speichern. Außerdem führten wir die Ablesung von 500 Proben durch und bildeten den Durchschnitt der Ablesungen. Wir haben die Lesung gemappt, um die richtige Dauer für die Steuerung der Servos zu erstellen, zu verketten und an den Server zu senden.

// 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; //Anzahl der 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); Kontador++; } 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 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)); }

Wenn keine Verbindung besteht, stellen wir schließlich sicher, dass die Verbindung beendet wurde, indem wir die entsprechende Meldung anzeigen.

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

Schritt 9: Dateien

Laden Sie die Dateien herunter:

PDF

INO