Caméra PANTILT avec ESP32 : 9 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Aujourd'hui, je vais vous présenter le PAN TILT, qui est un appareil qui permet le mouvement d'une caméra pour les directions de haut, de bas et sur les côtés. J'ai moi-même réalisé cet appareil grâce à des pièces imprimées en 3D, à l'aide de deux servos et de l'ESP32, qui permet de contrôler ce mécanisme via le WiFi. Faisons alors des lectures à l'aide des canaux AD de l'ESP32, ainsi qu'un fonctionnement analogique à l'aide du contrôleur LED_PWM. Aussi, nous appliquons le contrôle sur une connexion TCP/IP.

Dans la vidéo, vous pouvez voir que j'ai un ESP32 qui lit les valeurs des deux potentiomètres, qui sont envoyées (via WiFi) à un autre ESP32. Il est connecté aux deux servomoteurs. La caméra se déplace (et est attachée au PAN TILT) dans les directions vers le haut, vers le bas ou latéralement, selon le contrôle que vous effectuez à travers les potentiomètres.

Le lien vers la conception d'impression 3D PAN TILT peut être trouvé ici:

Étape 1: Ressources utilisées

• Plusieurs cavaliers pour la connexion

• Deux nœuds MCU ESP32

• Deux câbles USB pour l'ESP32

• Une webcam pour le contrôle

• Deux potentiomètres de contrôle

• Un protoboard

• Une source pour les servos

Étape 2: NodeMCU ESP32S - Brochage

Étape 3: Périphériques ESP32

Périphériques PWM L'ESP32 dispose de deux périphériques capables de générer des signaux PWM. Ceux-ci incluent le moteur Pulse Width Modulator (MCPWM) conçu pour le contrôle de la puissance et du moteur, et le LED_PWM, développé pour le contrôle de l'intensité des LED. Mais ils peuvent aussi être utilisés de manière générique.

Nous utiliserons le LED_PWM, qui peut générer 16 canaux PWM indépendants avec des périodes et des cycles de travail configurables. Il a jusqu'à 16 bits de résolution.

Étape 4: Commande de servomoteur PWM

La commande du servomoteur est effectuée en ajustant la modulation de largeur d'impulsion d'un carré avec une fréquence spécifique.

Pour le servo utilisé (ainsi que pour la plupart), la fréquence est à 50Hz. De plus, une largeur d'impulsion de 1 à 2 ms détermine la position angulaire du servo.

Nous acheminerons le canal 0 de LED_PWM vers GPIO13 et le canal 1 vers GPIO12, en utilisant ces informations pour effectuer le contrôle.

Étape 5: Capture analogique

Périphérique de conversion analogique-numérique

L'ESP32 possède des convertisseurs analogique-numérique qui peuvent être appliqués dans jusqu'à 18 canaux, mais uniquement dans les GPIO compatibles analogiques.

La tension appliquée ne doit pas dépasser la plage 0 à 3V.

La conversion effectuée ne maintient pas une erreur constante pour toutes les tensions échantillonnées, et tout dépend de la plage configurée. Pour une plage de 150 mV à 2 450 V, un contrôle de comportement est requis pour les applications plus critiques.

Pour la capture, nous utiliserons un potentiomètre de 10k comme diviseur de tension. La capture se fera dans le canal ADC0 et ADC3, accessible par GPIO36 et GPIO39.

Étape 6: Circuit - Serveur et Client

Étape 7: Code source du point d'accès et du serveur

Déclarations

J'inclus la bibliothèque WiFi, et je définis quelques variables.

#include // inclusão da biblioteca WiFi const int freq = 50; //frequência do PWM const int canal_A = 0; //premier canal do controlador LED_PWM const int canal_B = 1; //segundo canal do controlador LED_PWM 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 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 serveur WiFiServer (port); //declaração do objeto servidor IPAddress myIP; //declaração da variável de IP

Installer ()

Ici, nous définissons les broches de sortie. Nous réglons les canaux sur la fréquence souhaitée et définissons la valeur PWM.

void setup(){ pinMode(pin_Atuacao_A, OUTPUT); //définir le pino de atuação A como saída pinMode(pin_Atuacao_B, OUTPUT); //définir sur le pin de l'atuação B como saída ledcSetup(canal_A, freq, resolucao); //Ajuste le canal 0 pour la fréquence de 50 Hz et la résolution de 12 bits ledcSetup(canal_B, freq, resolucao); //Ajuste le canal 1 pour la fréquence de 50 Hz et la résolution de 12 bits ledcAttachPin(pin_Atuacao_A, canal_A); //redirection du canal 0 vers le pin 13 ledcAttachPin(pin_Atuacao_B, canal_B); //redirection du canal 1 vers le pin 12 ledcWrite(canal_A, ciclo_A); //définir la valeur du PWM pour 0 ledcWrite(canal_B, ciclo_B); //définir la valeur du PWM par 0

Nous avons démarré la série, le point d'accès avec le SSID ESP32ap et le mot de passe. Nous obtenons ensuite l'adresse IP du serveur et démarrons le serveur.

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

Boucle ()

Dans Loop, la première chose que nous allons faire est d'instancier le client, de se connecter et de se lier à la variable client. Vérifiez si le client est connecté. Si c'est le cas, nous démarrons la variable qui recevra les données. Tant que la connexion est établie, et si des données sont reçues, nous lisons les caractères de la variable c. Enfin, nous concaténons c dans la variable de données.

void loop() { WiFiClient cliente = server.available(); //se um cliente conectar, associe a variável cliente if (cliente.connected()) { //se 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; //concaténe c na variável dados

Si un caractère de nouvelle ligne est reçu, nous recherchons l'index du caractère ', ' dans la chaîne dans les données. Nous obtenons les sous-chaînes juste avant la virgule, puis nous les convertissons en entier. Nous définissons le PWM des canaux A et B. Nous effaçons la variable.

if (c == '\n') { //se um caracter de nova linha for recebido int virgula = dados.indexOf(', '); //procure pelo índice do caracter ', ' na string em dodos 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(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 } } } }

Si le client se déconnecte, nous confirmons la fin de la connexion. Nous attendons un moment et affichons "Aucun client connecté". Nous attendons ensuite encore une seconde avant de redémarrer.

// cas o cliente se desconecte, confirma o fim da conexão delay (50); // garde un instant cliente.stop(); Serial.println("Nenhum cliente conectado."); // délai de messages (1000); // aguarda um segundo antes de reiniciar }

Étape 8: Code source du client

Déclarations

Nous avons à nouveau inclus la bibliothèque WiFi, cette fois sur le client. De plus, nous définissons les variables.

#include const char* ssid = "ESP32ap"; //SSID do ponto de 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 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

Installer ()

Nous définissons les GPIO en entrée, démarrons la série et nous nous connectons au point d'accès.

void setup(){ pinMode(pin_Leitura_A, INPUT); //définir o GPIO como entrada pinMode(pin_Leitura_B, INPUT); //définir o GPIO como entrée Serial.begin(115200); //inicia une communication sérielle WiFi.begin(ssid, mot de passe); //conecta ao ponto de acesso }

Boucle ()

Dans cette boucle, nous allons nous connecter au serveur, c'est-à-dire à l'autre 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 + "…"); //menagem WiFi.begin(ssid, mot de passe); retard (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 + "…"); // délai de messages (1000); }

Dans cette étape, tout en étant connecté au serveur, nous exécutons les variables pour stocker la lecture de ADC0 et ADC3. De plus, nous avons effectué la lecture de 500 échantillons et fait la moyenne des lectures. Nous avons mappé la lecture pour créer la durée correcte pour le contrôle des servos, et la concaténer et l'envoyer au serveur.

//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 = 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 servedor cliente.println(String(ciclo_A) + ", " + String(ciclo_B)); }

Enfin, s'il n'est pas connecté, nous nous assurons que la connexion est terminée en affichant le message équivalent.

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

Étape 9: Fichiers

Téléchargez les fichiers:

PDF

INO