// — Programme Arduino —
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 15/5/2011.

// ——- Licence du code de ce programme —–
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// ——– Que fait ce programme ? ———
 /* Deux servomoteurs connectés à la carte Arduino sont contrôlés
à partir du PC (interface Processing)

Controle par chaine de la forme : servoPan(000) avec 000 = angle en degrés

*/

// — Fonctionnalités utilisées —

// Utilise / fonctionne avec une interface Processing coté PC
// Utilise 2 servomoteurs

// ——– Circuit à réaliser ———

// ******* ATTENTION : il est possible de connecter directement 2 ou 3 servomoteurs sur la carte Arduino
// Connecter un servomoteur PAN sur la broche 8
// Connecter un servomoteur TILT sur la broche 9

// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…

// — Déclaration des constantes —

// — Inclusion des librairies —

#include <Servo.h> // librairie pour servomoteur

// — Déclaration des constantes utiles —
const int APPUI=LOW; // constante pour tester état BP

//— Constantes utilisées avec le servomoteur
const int ANGLE_MIN=0; // angle position MIN en degrés
const int POS_MIN=550; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur
                  // POS_MIN=550 pour ANGLE_MIN=0 avec un futaba S3003

const int ANGLE_MAX=172; // angle position MAX en degrés
int POS_MAX=2400; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur
                  // POS_MAX=2400 pour ANGLE_MAX=172 pour futaba S3003

// pour étalonner un servomoteur, voir la page :
//http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerieDepuisPCPositionServomoteur

// — Déclaration des constantes des broches E/S numériques —

const int broche_servoPan=8; // Constante pour la broche 8
const int broche_servoTilt=9; // Constante pour la broche 8

// — Déclaration des constantes des broches analogiques —

// — Déclaration des variables globales —

 int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
 long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
 long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
 String chaineReception=«  »; // déclare un objet String vide pour reception chaine

  int valeur=0; // variable reception valeur port série

int angleServoPan=90; // variable de position du servo  Pan en degrés
int angleServoTilt=90; // variable de position du servo  Tilt en degrés

int angleServoPan0=90; // variable de la dernière position du servo  Pan en degrés
int angleServoTilt0=90; // variable de la dernière position du servo  Tilt en degrés

int vitesse=10; // variable utilisée pour délai entre 2 lecture port Série

// — Déclaration des objets utiles pour les fonctionnalités utilisées —

//— Création objet servomoteur
Servo mon_servoPan;  // crée un objet servo pour contrôler le servomoteur 1
Servo mon_servoTilt;  // crée un objet servo pour contrôler le servomoteur 2

// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// — ici instructions à exécuter 1 seule fois au démarrage du programme —

// ——- Initialisation fonctionnalités utilisées ——-  

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission

//— Initialisation Servomoteur
mon_servoPan.attach(broche_servoPan);  // attache l’objet servo à la broche de commande du servomoteur Pan
mon_servoTilt.attach(broche_servoTilt);  // attache l’objet servo à la broche de commande du servomoteur Tilt

// ——- Broches en sorties numériques ——-  
 pinMode (broche_servoPan,OUTPUT); // Broche broche_servoPan configurée en sortie
 pinMode (broche_servoTilt,OUTPUT); // Broche broche_servoPan configurée en sortie

// ——- Broches en entrées numériques ——-  

// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-  

// ——- Initialisation des variables utilisées ——-  

// ——- Codes d’initialisation utile ——-  

mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle – plus précis que write()
mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle – plus précis que write()

Serial.println(« Arduino OK »); // debug

delay(200);

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension

void loop(){ // debut de la fonction loop()

//—- code type réception chaine sur le port série —
while (Serial.available()>0) { // tant qu’un octet en réception
        octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

        if (octetReception==10) { // si Octet reçu est le saut de ligne
                Serial.println (« Chaine recue= »+chaineReception); // affiche la chaine recue

                break; // sort de la boucle while
        }
        else { // si le caractère reçu n’est pas un saut de ligne
                chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
        }

} // fin tant que  octet réception

//—– une fois que le saut de ligne est reçu, on sort du While et on se positionne ici

// —- analyse de la chaine recue sur le port Série —-
chaineReception=chaineReception.trim(); // enlève les espaces

//—– gestion servomoteur PAN —-
if (chaineReception.substring(0,9)==« servoPan(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

  Serial.print(« Arduino va executer : « );

  Serial.print(« servoPan(« ); // affiche

  //————- extraction valeur angle servomoteur  —— 3 chiffres

    //—- extraction 1er chiffre
    valeur=chaineReception.charAt(9); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoPan=valeur;

     //—- extraction 2ème chiffre
    valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoPan=angleServoPan*10+valeur;

    //—- extraction 3ème chiffre
    valeur=chaineReception.charAt(11); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoPan=angleServoPan*10+valeur;

  Serial.print(angleServoPan); // affiche

  if (chaineReception.substring(12,13)==« ) ») { // si fermeture parenthèse = instruction valide

    Serial.println(« ) »); // affiche
    Serial.println(« Instruction valide ! »); // affiche

    //—– positionnement du servomoteur —-

    angleServoPan=constrain(angleServoPan,ANGLE_MIN,ANGLE_MAX); // oblige valeur angle Servo
    mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle – plus précis que write()
    //angleServoPan0=angleServoPan; // mémorise dernière valeur angle prise en compte

    //delay(1000); // laisse temps positionnement

    Serial.println(« Servomoteur mis en position »); // affiche

  } // fin si fermeture parenthèse  

} // — fin si reçoit instruction servoPan(000)

//——————— gestion servomoteur Tilt ——————————-

//—– gestion servomoteur TILT —-
if (chaineReception.substring(0,10)==« servoTilt(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

  Serial.print(« Arduino va executer : « );

  Serial.print(« servoTilt(« ); // affiche

  //————- extraction valeur angle servomoteur  —— 3 chiffres

    //—- extraction 1er chiffre
    valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoTilt=valeur;

     //—- extraction 2ème chiffre
    valeur=chaineReception.charAt(11); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoTilt=angleServoTilt*10+valeur;

    //—- extraction 3ème chiffre
    valeur=chaineReception.charAt(12); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoTilt=angleServoTilt*10+valeur;

  Serial.print(angleServoTilt); // affiche

  if (chaineReception.substring(13,14)==« ) ») { // si fermeture parenthèse = instruction valide

    Serial.println(« ) »); // affiche
    Serial.println(« Instruction valide ! »); // affiche

    //—– positionnement du servomoteur —-

    angleServoTilt=constrain(angleServoTilt,ANGLE_MIN,ANGLE_MAX); // oblige valeur angle Servo
    mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle – plus précis que write()
    //angleServoTilt0=angleServoTilt; // mémorise dernière valeur angle prise en compte

    //delay(1000); // laisse temps positionnement

    Serial.println(« Servomoteur mis en position »); // affiche

  } // fin si fermeture parenthèse  

} // — fin si reçoit instruction servoTilt(000)

//—————- gestion vitesse ————————

//—– gestion servomoteur TILT —-
if (chaineReception.substring(0,8)==« Vitesse(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

  Serial.print(« Arduino va executer : « );

  Serial.print(« servoTilt(« ); // affiche

  //————- extraction valeur angle servomoteur  —— 3 chiffres

    //—- extraction 1er chiffre
    valeur=chaineReception.charAt(8); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    vitesse=valeur;

     //—- extraction 2ème chiffre
    valeur=chaineReception.charAt(9); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    vitesse=vitesse*10+valeur;

    //—- extraction 3ème chiffre
    valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    vitesse=vitesse*10+valeur;

  Serial.print(vitesse); // affiche

  if (chaineReception.substring(11,12)==« ) ») { // si fermeture parenthèse = instruction valide

    Serial.println(« ) »); // affiche
    Serial.println(« Instruction valide ! »); // affiche

  } // fin si fermeture parenthèse  

} // — fin si reçoit instruction servoTilt(000)

//————- fin analyse chaine —————

chaineReception=«  »; //RAZ le String de réception

   delay(vitesse*5); // fixe la vitesse de mouvement du servo – entre 2 lecture analogique

//while(1); // stop loop

} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////

// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////

//————- fonction calibrage impulsion servomoteur à partir valeur angle en degrés

int angle(int valeur_angle) {

        int impuls=0;
        impuls=map(valeur_angle,ANGLE_MIN,ANGLE_MAX,POS_MIN, POS_MAX);
        return impuls;  

} // fin fonction impulsion servomoteur

// ////////////////////////// Fin du programme ////////////////////