PANTILT -kamera met ESP32: 9 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Vandag bied ek die PAN TILT aan, 'n toestel wat 'n kamera in staat stel om op, af en na die kante te beweeg. Ek self het hierdie toestel vervaardig deur middel van 3D -gedrukte dele, met behulp van twee servo's en die ESP32, wat dit moontlik maak om hierdie meganisme via WiFi te beheer. Laat ons dan metings neem met behulp van die AD -kanale van die ESP32, sowel as 'n analoog werking met behulp van die kontroleerder LED_PWM. Ons pas ook die beheer oor 'n TCP / IP -verbinding toe.

In die video kan u sien dat ek 'n ESP32 het wat die waardes van die twee potensiometers lees, wat (via WiFi) na 'n ander ESP32 gestuur word. Dit is gekoppel aan die twee servomotors. Die kamera beweeg (en word aan die PAN TILT geheg) in die rigtings op, af of sywaarts, afhangende van die beheer wat u deur die potte maak.

Die skakel na die PAN TILT 3D -drukontwerp kan hier gevind word:

Stap 1: Hulpbronne gebruik

• Meervoudige springers vir aansluiting

• Twee Node MCU ESP32s

• Twee USB -kabels vir die ESP32

• 'n Webcam vir beheer

• Twee kontrolepotte

• 'n Protobord

• 'n Bron vir die servo's

Stap 2: NodeMCU ESP32S - Pinout

Stap 3: ESP32 randapparatuur

PWM randapparatuur Die ESP32 het twee randapparatuur wat PWM seine kan genereer. Dit sluit in die Pulse Width Modulator (MCPWM) -enjin wat ontwerp is vir krag- en motorbeheer, en die LED_PWM, wat ontwikkel is vir LED -intensiteitsbeheer. Maar hulle kan ook op 'n generiese manier gebruik word.

Ons sal die LED_PWM gebruik, wat 16 onafhanklike PWM -kanale kan genereer met instelbare periodes en werksiklusse. Dit het tot 16 bisse resolusie.

Stap 4: Servomotorbeheer PWM

Die servomotorbeheer word uitgevoer deur die polswydte -modulasie van 'n vierkant met 'n spesifieke frekwensie aan te pas.

Vir die servo wat gebruik word (sowel as vir die meeste), is die frekwensie by 50Hz. 'N Breedte van 1 tot 2ms polslengte bepaal ook die hoekposisie van die servo.

Ons stuur kanaal 0 van LED_PWM na GPIO13, en kanaal 1 na GPIO12, deur hierdie inligting te gebruik om die beheer uit te voer.

Stap 5: Analoog vaslê

Periodieke analoog na digitale omskakeling

Die ESP32 het analoog-na-digitale omsetters wat in tot 18 kanale toegepas kan word, maar slegs in analoog-geaktiveerde GPIO's.

Die toegepaste spanning mag nie die 0 tot 3V -reeks oorskry nie.

Die uitgevoerde omskakeling handhaaf nie 'n konstante fout vir alle spannings wat bemonster word nie, en dit hang alles af van die gekonfigureerde reeks. Vir 'n reikwydte van 150mV by 2, 450V, is 'n gedragskontrole nodig vir meer kritieke toepassings.

Vir die opname gebruik ons 'n potensiometer van 10k as 'n spanningsverdeler. Die opname sal gedoen word in kanaal ADC0 en ADC3, toeganklik deur GPIO36 en GPIO39.

Stap 6: Kringloop - bediener en kliënt

Stap 7: Bronkode van die toegangspunt en bediener

Verklarings

Ek sluit die WiFi -biblioteek in en ek definieer 'n paar veranderlikes.

#include // inclusão da biblioteca WiFi const int freq = 50; // frequência do PWM const int canal_A = 0; // primeiro kanaal doen beheer van LED_PWM const int kanaal_B = 1; // 'n kanaal om die LED_PWM -beheer te beheer, const int resolucao = 12; // Resolução usado no controlador 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 of SSID to WiFi do ponto de acesso ESP32 const char* password = "12345678"; // senha para confirmmaçã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; // 'n variabele kanaal kan 'n WiFi -bediener bedien (poort); // declaração do objeto servidor IPAddress myIP; // declaração da variável de IP

Stel op ()

Hier definieer ons die uitvoerpenne. Ons stel die kanale op die gewenste frekwensie en stel die PWM -waarde in.

ongeldige opstelling () {pinMode (pin_Atuacao_A, OUTPUT); // definindo o pino de atuação A como saída pinMode (pin_Atuacao_B, OUTPUT); // definindo o pino de atuação B como saída ledcSetup (kanaal_A, frekwensie, resolucao); // Ajustando o canal 0 para frequência de 50 Hz e resolução de 12bits ledcSetup (canal_B, freq, resolucao); // Ajustando o canal 1 para frequência de 50 Hz e resolução de 12bits ledcAttachPin (pin_Atuacao_A, canal_A); // herverwysing van kanaal 0 vir 13 portefeulje (pin_Atuacao_B, kanaal_B); // herverwysing van kanaal 1 vir 12 ledcWrite (kanaal_A, ciclo_A); // definieer ons waarde vir PWM vir 0 ledcWrite (kanaal_B, ciclo_B); // definieer ons waarde vir PWM by 0

Ons het die reeks, toegangspunt begin met SSID ESP32ap en wagwoord. Ons kry dan die IP van die bediener en begin die bediener.

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

Lus ()

In Loop is die eerste ding wat ons gaan doen om die kliënt te instansieer, aan te sluit en te bind aan die veranderlike van die kliënt. Kyk of die kliënt gekoppel is. As dit die geval is, begin ons die veranderlike wat die data sal ontvang. Solank die verbinding tot stand kom en as data ontvang word, lees ons die karakters vir die veranderlike c. Laastens verbind ons c in die data veranderlike.

void lus () {WiFiClient cliente = server.available (); // se um cliente conectar, associe a variável cliente if (cliente.connected ()) {// se há um cliente conectado String dados = ""; // inisia a variável que receberá os dados Serial.println ("Cliente conectado."); // mensagem terwyl (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; // versoenbare gegewens

As 'n nuwe lyn karakter ontvang word, soek ons na die indeks van die karakter ',' in die string in die data. Ons kry die substraatjies tot net voor die komma, en omskakel dit dan na 'n heelgetal. Ons stel die PWM van kanale A en B. Ons maak die veranderlike skoon.

if (c == '\ n') {// se um caracter de nova linha for recebido int virgula = dados.indexOf (','); // verkry 'n spesifieke karakter vir 'n string met dados ciclo_A = (dados.substring (0, virgula)). toInt (); // obtenha a substring até antes da vírgula e converta para inteiro ciclo_B = dados.substring (virgula + 1, dados.length ()). toInt (); // obtenha a substring após a vírgula e converta para inteiro ledcWrite (kanaal_A, ciclo_A); // Ajusta o PWM doen kanaal A ledcWrite (kanaal_B, ciclo_B); // Ajusta o PWM doen kanaal B dados = ""; // Limpa a variável}}}}

As die kliënt ontkoppel, bevestig ons die einde van die verbinding. Ons wag 'n oomblik en druk 'Geen kliënt gekoppel' nie. Ons wag dan nog 'n sekonde voordat ons weer begin.

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

Stap 8: Kliënt se bronkode

Verklarings

Ons het weer die WiFi -biblioteek ingesluit, hierdie keer op die kliënt. Ons definieer ook die veranderlikes.

#sluit const char* ssid = "ESP32ap" in; // SSID do 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 do ADC0 const int pin_Leitura_B = 39; // GPIO de leitura do ADC3 int ciclo_A = 0; // variável que receberá o valor do ciclo do PWM A int ciclo_B = 0; // Verskeie voorbeelde van waarde vir PWM B WiFiClient -klante; // declaração do objeto cliente

Stel op ()

Ons definieer die GPIO's as invoer, begin die reeks en maak verbinding met die toegangspunt.

ongeldige opstelling () {pinMode (pin_Leitura_A, INPUT); // definieer die GPIO van pinMode (pin_Leitura_B, INPUT); // definieer o GPIO como entrada Serial.begin (115200); // inisia a comunicação serial WiFi.begin (ssid, password); // conecta ao ponto de acesso}

Lus ()

In hierdie lus maak ons verbinding met die bediener, wat die ander ESP beteken.

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, wagwoord); vertraging (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 + ":" + poort + "…"); // mensagem vertraging (1000); }

In hierdie stap, terwyl ons aan die bediener gekoppel is, voer ons die veranderlikes uit om die lesing van ADC0 en ADC3 te stoor. Ons het ook 500 monsters gelees en die gemiddelde was gemiddeld. Ons het die lesing in kaart gebring om die korrekte tydsduur vir die beheer van die servo's te skep, en dit aanmekaar te sit en na die bediener te stuur.

// 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); contador ++; } leitura_A = leitura_A / amostras; // média das leituras leitura_B = leitura_B /amostras; ciclo_A = kaart (leitura_A, 0, 4095, 140, 490); // mapeia a leitura para criar a duração correta para control do servo ciclo_B = kaart (leitura_B, 0, 4095, 140, 490); // mapeia a leitura para criar a duração correta para control do servo // concatena e envia para o servidor cliente.println (String (ciclo_A) + "," + String (ciclo_B)); }

Ten slotte, as ons nie gekoppel is nie, verseker ons dat die verbinding beëindig is deur die ekwivalente boodskap te vertoon.

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

Stap 9: lêers

Laai die lêers af:

PDF

EK NEE