Cámara PANTILT con ESP32: 9 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Hoy, presentaré el PAN TILT, que es un dispositivo que permite el movimiento de una cámara para las direcciones de arriba, abajo y hacia los lados. Yo mismo produje este dispositivo a través de piezas impresas en 3D, utilizando dos servos y el ESP32, que permite controlar este mecanismo a través de WiFi. Entonces tomemos lecturas usando los canales AD del ESP32, así como una operación analógica usando el controlador LED_PWM. Además, aplicamos el control sobre una conexión TCP / IP.

En el video se puede ver que tengo un ESP32 leyendo los valores de los dos potenciómetros, los cuales son enviados (vía WiFi) a otro ESP32. Está conectado a los dos servomotores. La cámara se mueve (y está unida al PAN TILT) hacia arriba, hacia abajo o hacia los lados, dependiendo del control que haga a través de los potenciómetros.

El enlace al diseño de impresión 3D de PAN TILT se puede encontrar aquí:

Paso 1: Recursos utilizados

• Múltiples puentes para conexión

• MCU ESP32 de dos nodos

• Dos cables USB para el ESP32

• Una WebCam para el control

• Dos macetas de control

• Un protoboard

• Una fuente para los servos

Paso 2: NodeMCU ESP32S - Pinout

Paso 3: periféricos ESP32

Periféricos PWM El ESP32 tiene dos periféricos capaces de generar señales PWM. Estos incluyen el motor Modulador de ancho de pulso (MCPWM) diseñado para control de potencia y motor, y el LED_PWM, desarrollado para control de intensidad de LED. Pero también se pueden utilizar de forma genérica.

Usaremos el LED_PWM, que puede generar 16 canales PWM independientes con periodos y ciclos de trabajo configurables. Tiene hasta 16 bits de resolución.

Paso 4: PWM de control de servomotor

El control del servomotor se realiza ajustando la modulación de ancho de pulso de un cuadrado con una frecuencia específica.

Para el servo utilizado (así como para la mayoría), la frecuencia es de 50 Hz. Además, un ancho de pulso de 1 a 2 ms determina la posición angular del servo.

Enrutaremos el canal 0 de LED_PWM a GPIO13 y el canal 1 a GPIO12, utilizando esta información para realizar el control.

Paso 5: captura analógica

Periférico de conversión de analógico a digital

El ESP32 tiene convertidores de analógico a digital que se pueden aplicar en hasta 18 canales, pero solo en GPIO con capacidad analógica.

El voltaje aplicado no debe exceder el rango de 0 a 3V.

La conversión realizada no mantiene un error constante para todos los voltajes muestreados, y todo esto depende del rango configurado. Para un rango de 150 mV a 2, 450 V, se requiere una verificación de comportamiento para aplicaciones más críticas.

Para la captura usaremos un potenciómetro de 10k como divisor de voltaje. La captura se realizará en los canales ADC0 y ADC3, accesibles por GPIO36 y GPIO39.

Paso 6: Circuito: servidor y cliente

Paso 7: código fuente del punto de acceso y el servidor

Declaraciones

Incluyo la librería WiFi y defino algunas variables.

#include // inclusión de la biblioteca WiFi const int freq = 50; // frecuencia de PWM const int canal_A = 0; // primeiro canal do controlador LED_PWM const int canal_B = 1; // segundo canal del controlador LED_PWM const int resolucao = 12; // Resolución usada sin 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 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 de atuação do canal Un servidor WiFiServer (puerto); // declaración del objeto servidor IPAddress myIP; // declaração da variável de IP

Configuración ()

Aquí, definimos los pines de salida. Configuramos los canales a la frecuencia deseada y configuramos el valor PWM.

configuración vacía () {pinMode (pin_Atuacao_A, SALIDA); // 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 (canal_A, freq, resolucao); // Ajustando o canal 0 para frecuencia de 50 Hz y resolución de 12bits ledcSetup (canal_B, freq, resolucao); // Ajustando o canal 1 para frecuencia de 50 Hz y resolución de 12bits ledcAttachPin (pin_Atuacao_A, canal_A); // redireccionando o canal 0 para o pino 13 ledcAttachPin (pin_Atuacao_B, canal_B); // redireccionando o canal 1 para o pino 12 ledcWrite (canal_A, ciclo_A); // definir el valor de PWM para 0 ledcWrite (canal_B, ciclo_B); // definindo o valor do PWM para 0

Iniciamos el serial, el punto de acceso con SSID ESP32ap y contraseña. Luego obtenemos la IP del servidor e iniciamos el servidor.

Serial.begin (115200); // iniciando un Serial Serial.println ("Iniciando ponto de acesso:" + String (ssid)); // mensagem WiFi.softAP (ssid, contraseña); // 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 no para establecer deverá ser o padrão de fábrica) Serial.println ("IP:" + WiFi.localIP ()); // mensagem Serial.println ("Iniciando servidor em:" + String (puerto)); // mensagem server.begin (); // iniciando o servidor}

Círculo ()

En Loop, lo primero que vamos a hacer es crear una instancia del cliente, conectar y vincular a la variable del cliente. Compruebe si el cliente está conectado. Si es así, iniciamos la variable que recibirá los datos. Siempre que se establezca la conexión y si se reciben datos, leemos los caracteres de la variable c. Finalmente, concatenamos c en la variable de datos.

bucle vacío () {Cliente WiFiClient = servidor disponible (); // se um cliente conectar, asociar un cliente variável if (cliente.connected ()) {// se há um cliente conectado String dados = ""; // inicia a 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; // concatene c na variável dados

Si se recibe un carácter de nueva línea, buscamos el índice del carácter ',' en la cadena de datos. Obtenemos las subcadenas hasta justo antes de la coma, y luego las convertimos a enteros. Configuramos el PWM de los canales A y B. Borramos la variable.

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

Si el cliente se desconecta, confirmamos el final de la conexión. Esperamos un momento e imprimimos "Ningún cliente conectado". Luego esperamos otro segundo antes de reiniciar.

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

Paso 8: Código fuente del cliente

Declaraciones

Hemos incluido de nuevo la biblioteca WiFi, esta vez en el cliente. Además, definimos las variables.

#include const char * ssid = "ESP32ap"; // 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 del 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; // Variável que receberá o valor do ciclo do PWM B WiFiClient cliente; // declaração do objeto cliente

Configuración ()

Definimos los GPIO como entrada, iniciamos la serie y nos conectamos al punto de acceso.

configuración vacía () {pinMode (pin_Leitura_A, ENTRADA); // define o GPIO como entrada pinMode (pin_Leitura_B, INPUT); // define o GPIO como entrada Serial.begin (115200); // inicia una comunicación serial WiFi.begin (ssid, contraseña); // conecta ao ponto de acesso}

Círculo ()

En este Loop, nos conectaremos al servidor, es decir, al otro 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, contraseña); retraso (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 + ":" + puerto + "…"); // retraso mensagem (1000); }

En este paso, mientras estamos conectados al servidor, ejecutamos las variables para almacenar la lectura de ADC0 y ADC3. Además, realizamos la lectura de 500 muestras y promediamos las lecturas. Mapeamos la lectura para crear la duración correcta para el control de los servos, y la concatenamos y la enviamos al servidor.

// 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 = mapa (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)); }

Finalmente, si no está conectado, nos aseguramos de que la conexión se haya terminado mostrando el mensaje equivalente.

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

Paso 9: archivos

Descarga los archivos:

PDF

INO