/*
 * Source de la bibliothèque originale du module PCA9685 : https://github.com/adafruit/Adafruit-PWM-Servo-Driver-Library
 * 
 * Voici le code Arduino pour le contrôleur de servo à 32 canaux PCA9685
 * pour contrôler 32 moteurs servo via WiFi en utilisant un MCU ESP32.
 * Obtenez ce code et le câblage pour cette vidéo : http://robojax.com/RJT365
 * 
 * Regardez la vidéo pour ce code : https://youtu.be/bvqfv-FrrLM
 * 
 * Vidéos associées
 * Vidéo V4 du PCA9685 32 Servo avec ESP32 : https://youtu.be/JFdXB8Za5Os
 * Vidéo V3 du PCA9685 comment contrôler 32 moteurs servo https://youtu.be/6P21wG7N6t4
 * Vidéo V2 du PCA9685 3 manières différentes de contrôler des moteurs servo : https://youtu.be/bal2STaoQ1M
 * Vidéo V1 introduction au PCA9685 pour contrôler 16 Servo https://youtu.be/y8X9X10Tn1k
 * 
 * Écrit par Ahmad Shamshiri pour la chaîne vidéo Robojax www.Robojax.com
 * Date : 17 février 2020, à Ajax, Ontario, Canada
 * 
 * ou faites un don via PayPal http://robojax.com/L/?id=64
 * 
 * Ce code est "EN L'ÉTAT" sans garantie ni responsabilité. Libre d'être utilisé tant que vous gardez cette note intacte.*
 * Ce code a été téléchargé depuis Robojax.com
 * Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier
 * selon les termes de la Licence Publique Générale GNU telle que publiée par
 * la Free Software Foundation, soit la version 3 de la Licence, ou
 * (à votre choix) toute version ultérieure.
 * 
 * Ce programme est distribué dans l'espoir qu'il sera utile,
 * mais SANS AUCUNE GARANTIE ; sans même la garantie implicite de
 * COMMERCIALISATION ou D'ADAPTATION À UN USAGE PARTICULIER. Voir la
 * Licence Publique Générale GNU pour plus de détails.
 * 
 * Vous devriez avoir reçu une copie de la Licence Publique Générale GNU
 * avec ce programme. Sinon, consultez <https://www.gnu.org/licenses/>.
 * /
 * ////////////////////// paramètres PCA9685 démarrés
 */
#include <Wire.h>

#include <Adafruit_PWMServoDriver.h>

 // s'appelant ainsi, il utilise l'adresse par défaut 0x40
Adafruit_PWMServoDriver board1 = Adafruit_PWMServoDriver(0x40);
Adafruit_PWMServoDriver board2 = Adafruit_PWMServoDriver(0x41);
int maximumServo = 32; // combien de servos sont connectés

 // Selon la marque de votre servo, la largeur d'impulsion minimale et maximale peut varier, vous
 // je veux que ceux-ci soient aussi petits/grands que possible sans atteindre le point de non-retour
 // pour une portée maximale. Vous devrez les ajuster si nécessaire pour correspondre aux servos que vous
 // avoir !
 // Regardez la vidéo V1 pour comprendre les deux lignes ci-dessous : http://youtu.be/y8X9X10Tn1k
#define SERVOMIN  125 // c'est le nombre de longueur d'impulsion 'minimum' (sur 4096)
#define SERVOMAX  575 // c'est le nombre de longueur de pulse 'maximum' (sur 4096)

int servoAngle =0;
int servoStep = 10;

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

 // angle minimum de chaque servomoteur
int allServoMin[]={
      0,    0,    0,    0,    0,    0,    0,    0, // 1 à 8
      0,    0,    0,    0,    0,    0,    0,    0, // 9 à 16
      0,    0,    0,    0,    0,    0,    0,    0, // 17 à 24
      0,    0,    0,    0,    0,    0,    0,    0}; // 25 à 32

 // valeur maximale de chaque servo
int allServoMax[]={
      180,    180,    180,    180,    180,    180,    180,    180, // 1 à 8
      180,    180,    180,    180,    180,    180,    180,    180, // 9 à 16
      180,    180,    180,    180,    180,    180,    180,    180, // 17 à 24
      180,    180,    180,    180,    180,    180,    180,    180}; // 25 à 32

 // position initiale des servos
int allServoPosition[] ={
      0,    0,    0,    0,    0,    0,    0,    0, // 1 à 8
      0,    0,    0,    0,    0,    0,    0,    0, // 9 à 16
      0,    0,    0,    0,    0,    0,    0,    0, // 17 à 24
      0,    0,    0,    0,    0,    0,    0,    0}; // 25 à 32

int servoNumber = 100; // servo à déplacer
int buttonPushed =0;
int allServo =0;

void handleServo(); // c'est le prototype de la fonction définie à la fin de ce code
int angleToPulse(int ang); // c'est le prototype de la fonction définie à la fin de ce code
 // //////////////////////PCA9685 terminé

#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); // Les servos analogiques fonctionnent avec des mises à jour d'environ 60 Hz.
  board2.setPWMFreq(60);
 // position initiale de tous les servos
  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]) );
    }
  } // pour la fin

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


 // Contrôle de servomoteur avec ESP32 de Robojax.com

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


 // Attendez la connexion
  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 contrôle de servomoteurs 32 canaux
  delay(100);

  } // si poussé
  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()  
 * met à jour la variable buttonPushed  
 * ne retourne rien  
 * Écrit par Ahmad Shamshiri le 29 décembre 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() fin


/*
 * angleToPulse(int ang)  
 * obtient l'angle en degrés et renvoie la largeur d'impulsion  
 * imprime également la valeur sur le moniteur série  
 * écrit par Ahmad Shamshiri pour Robojax, Robojax.com
 */
int angleToPulse(int ang){
   int pulse = map(ang,0, 180, SERVOMIN,SERVOMAX); // mapper l'angle de 0 à 180 sur Servo min et Servo max
 // Angle : ;Serial.print(ang);
 // Serial.print(" impulsion : ");Serial.println(pulse);
   return pulse;
}