Controlla 32 servomotori tramite Wi-Fi utilizzando ESP32 e PCA9685 tramite desktop o telefono cellulare V5

/*
 * Modulo PCA9685 sorgente della libreria originale: https://github.com/adafruit/Adafruit-PWM-Servo-Driver-Library
 * 
 * Questo è il codice Arduino per il controller di servo PCA9685 a 32 canali per controllare 32 motori servo tramite WiFi usando MCU ESP32. Ottieni questo codice e il cablaggio per questo video: http://robojax.com/RJT365
 * 
 * Guarda il video per questo codice: https://youtu.be/bvqfv-FrrLM
 * 
 * Video correlati V4 video di PCA9685 32 Servo con ESP32: https://youtu.be/JFdXB8Za5Os V3 video di PCA9685 come controllare 32 motori servo https://youtu.be/6P21wG7N6t4 V2 Video di PCA9685 3 modi diversi di controllare i motori servo: https://youtu.be/bal2STaoQ1M V1 Video introduzione a PCA9685 per controllare 16 Servo https://youtu.be/y8X9X10Tn1k
 * 
 * Scritto da Ahmad Shamshiri per il canale video Robojax www.Robojax.com Data: 17 febbraio 2020, ad Ajax, Ontario, Canada
 * 
 * oppure fai una donazione utilizzando PayPal http://robojax.com/L/?id=64
 * 
 * Questo codice è "COSÌ COM'È" senza garanzia o responsabilità. Libero di essere utilizzato finché mantieni intatta questa nota.* Questo codice è stato scaricato da Robojax.com Questo programma è software libero: puoi redistribuirlo e/o modificare
 * secondo i termini della GNU General Public License come pubblicata dalla Free Software Foundation, sia nella versione 3 della Licenza, o (a tua scelta) qualsiasi versione successiva.
 * 
 * Questo programma è distribuito con la speranza che sia utile, ma SENZA ALCUNA GARANZIA; senza nemmeno la garanzia implicita di MERCEOLOGIA o ADEGUATEZZA PER UN PARTICOLARE SCOPO. Vedi la GNU General Public License per ulteriori dettagli.
 * 
 * Dovresti aver ricevuto una copia della GNU General Public License insieme a questo programma. Se non l'hai ricevuta, vedi <https://www.gnu.org/licenses/>.
 * /
 * ////////////////////// Impostazioni PCA9685 iniziate
 */
#include <Wire.h>

#include <Adafruit_PWMServoDriver.h>

 // chiamato in questo modo, utilizza l'indirizzo predefinito 0x40
Adafruit_PWMServoDriver board1 = Adafruit_PWMServoDriver(0x40);
Adafruit_PWMServoDriver board2 = Adafruit_PWMServoDriver(0x41);
int maximumServo = 32; // quanti servomotori sono collegati

 // A seconda della marca del tuo servo, la larghezza dell'impulso minimo e massimo può variare, tu
 // voglio che questi siano il più piccoli/grandi possibile senza raggiungere il limite massimo
 // per la portata massima. Dovrai ajustarli secondo necessità per adattarli ai servomotori che
 // !avere
 // Guarda il video V1 per comprendere le due righe sottostanti: http://youtu.be/y8X9X10Tn1k
#define SERVOMIN  125 // questo è il conteggio della lunghezza di impulso 'minima' (su 4096)
#define SERVOMAX  575 // questo è il conteggio della lunghezza massima dell'impulso (su 4096)

int servoAngle =0;
int servoStep = 10;

int stepDelay = 50; // 50 millisecondi
int servoAngleMin =0;
int servoAngleMax = 180;

 // angolo minimo di ciascun servomotore
int allServoMin[]={
      0,    0,    0,    0,    0,    0,    0,    0, // 1 a 8
      0,    0,    0,    0,    0,    0,    0,    0, // 9 a 16
      0,    0,    0,    0,    0,    0,    0,    0, // 17 a 24
      0,    0,    0,    0,    0,    0,    0,    0}; // 25 a 32

 // valore massimo di ciascun servo
int allServoMax[]={
      180,    180,    180,    180,    180,    180,    180,    180, // 1 a 8
      180,    180,    180,    180,    180,    180,    180,    180, // 9 a 16
      180,    180,    180,    180,    180,    180,    180,    180, // 17 a 24
      180,    180,    180,    180,    180,    180,    180,    180}; // 25 a 32

 // posizione iniziale dei servomotori
int allServoPosition[] ={
      0,    0,    0,    0,    0,    0,    0,    0, // 1 a 8
      0,    0,    0,    0,    0,    0,    0,    0, // 9 a 16
      0,    0,    0,    0,    0,    0,    0,    0, // 17 a 24
      0,    0,    0,    0,    0,    0,    0,    0}; // 25 a 32

int servoNumber = 100; // servo per muovere
int buttonPushed =0;
int allServo =0;

void handleServo(); // questo è il prototipo di una funzione definita alla fine di questo codice
int angleToPulse(int ang); // questo è il prototipo di una funzione definita alla fine di questo codice
 // //////////////////////PCA9685 terminato

#include "PCA9684_32Servo_ESP32.h"

#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>

const char *ssid = "Robojax";
const char *password = "YouTube2020";

WebServer server(80);

const int led = 13;



 // ///////////////////////////////////
void handleRoot() {

String HTML_page = pageHeader_p1;

 if(allServo)
 {
 HTML_page.concat("<div class=\"btn\"><a class=\"angleButton colorAll\"  href=\"/servo?do=stop\">Stop Servo</a></div>");

 }else{
 HTML_page.concat("<div class=\"btn\"><a class=\"angleButton colorAll\"  href=\"/servo?do=all\">All Servo</a></div>");
 }

 for (int i=0; i < maximumServo; i++)
 {

  HTML_page.concat("<div class=\"btn\"><a class=\"angleButton colorBtn\"  href=\"/servo?move=");
  HTML_page.concat(i);
  HTML_page.concat("\">SRV ");
  HTML_page.concat(i+1);
  HTML_page.concat(" </a></div>");
 }

 HTML_page.concat("</body>\n</html>");
 server.send(200, "text/html", HTML_page);
}

void handleNotFound() {
  digitalWrite(led, 1);
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";

  for (uint8_t i = 0; i < server.args(); i++) {
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }

  server.send(404, "text/plain", message);
  digitalWrite(led, 0);
}


void setup() {
  board1.begin();
  board2.begin();
  board1.setPWMFreq(60); // I servomotori analogici funzionano con aggiornamenti a ~60 Hz.
  board2.setPWMFreq(60);
 // posizione iniziale di tutti i servomotori
  for(int i=0; i < maximumServo; i++) {
    if(i < 16)
    {
      board1.setPWM(i, 0, angleToPulse(allServoPosition[i]) );
    }else{
      board2.setPWM(i-15, 0, angleToPulse(allServoPosition[i]) );
    }
  } // per fine

    Serial.begin(115200);
    Serial.println("32 channel Servo test!");


 // Controllo servo utilizzando ESP32 di Robojax.com

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("");


 // Aspetta la connessione
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());


  if (MDNS.begin("robojaxESP32")) {
    Serial.print("MDNS responder started at http: // ");
    Serial.println("robojaxESP32");
  }

  server.on("/", handleRoot);
  server.on("/servo", HTTP_GET, handleServo);

  server.onNotFound(handleNotFound);
  server.begin();
  Serial.println("HTTP server started");
}

void loop() {
	server.handleClient();
  if(allServo ){

    for( int angle =servoAngleMin; angle <= servoAngleMax; angle +=servoStep){
      for(int i=0; i<16; i++)
        {

            board2.setPWM(i, 0, angleToPulse(angle) );
            board1.setPWM(i, 0, angleToPulse(angle) );
        }
        delay(stepDelay);
    }

 // robojax PCA9865 controllo servo a 32 canali
  delay(100);

  } // se spinto
  if(false){
  Serial.print("Servo #");
  Serial.print (servoNumber);
  Serial.print(" Angle ");
  Serial.println(allServoPosition[servoNumber]);
  }


  if( buttonPushed && (servoNumber >=0 && servoNumber < maximumServo) ){
    if(servoNumber < 16)
    {
      board1.setPWM(servoNumber, 0, angleToPulse(allServoPosition[servoNumber]) );
    }else{
      board2.setPWM(servoNumber-15, 0, angleToPulse(allServoPosition[servoNumber]) );
    }
  }

   buttonPushed =0;
}



/*
 * handleServo()
 * aggiorna la variabile buttonPushed
 * non restituisce nulla
 * Scritto da Ahmad Shamshiri il 29 dicembre 2019
 * www.Robojax.com
 * http://youTube.com/robojaxTV
 */
void handleServo() {
  if(server.arg("do") == "all" )
  {
    allServo =1;

  }else{
    allServo =0;
  }
   int servoNumberRequested= server.arg("move").toInt();

  if(servoNumberRequested >=0 && servoNumberRequested < maximumServo)
  {

    buttonPushed = 1;
    if(allServoPosition[servoNumberRequested] == allServoMin[servoNumberRequested] ) {
     allServoPosition[servoNumberRequested] = allServoMax[servoNumberRequested];
    }else{
     allServoPosition[servoNumberRequested] = allServoMin[servoNumberRequested];
    }
    servoNumber =servoNumberRequested;
  }

  handleRoot();
} // handleServo() fine


/*
 * angleToPulse(int ang) 
 * ottiene l'angolo in gradi e restituisce la larghezza dell'impulso 
 * stampa anche il valore sul monitor seriale 
 * scritto da Ahmad Shamshiri per Robojax, Robojax.com
 */
int angleToPulse(int ang){
   int pulse = map(ang,0, 180, SERVOMIN,SERVOMAX); // mappa l'angolo da 0 a 180 ai valori minimi e massimi del Servo
 // Angolo: ; ang
 // Serial.print(" impulso: ");Serial.println(pulse);
   return pulse;
}