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

// ——- 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 ? ———
 /* Teste la rotation des moteurs.  */

// — Fonctionnalités utilisées —

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

// /////////////////////////////// 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 —

// — Déclaration des constantes utiles —

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

const int vitesseMotA=3; // Constante pour la broche 3
const int sensMotA=12; // Constante pour la broche 12
const int freinMotA=9; // Constante pour la broche 9
const int intensiteMotA=A0; // intensité du moteur 0

const int vitesseMotB=11; // Constante pour la broche 11
const int sensMotB=13; // Constante pour la broche 13
const int freinMotB=8; // Constante pour la broche 8
const int intensiteMotB=A1; // intensité du moteur 1

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

//const int Voie[6]={0,1,2,3,4,5}; //declaration constante de broche analogique

// — Déclaration des variables globales —

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

// ////////////////////////// 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);

// ——- Broches en sorties numériques ——-  
 pinMode (vitesseMotA,OUTPUT); // Broche vitesseMotA configurée en sortie
 pinMode (freinMotA,OUTPUT); // Broche freinMotA configurée en sortie
 pinMode (vitesseMotB,OUTPUT); // Broche vitesseMotB configurée en sortie
 pinMode (sensMotA,OUTPUT); // Broche sensMotA configurée en sortie
 pinMode (sensMotB,OUTPUT); // Broche senMotB 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 ——-  
digitalWrite(vitesseMotA,LOW); // a l’arret
digitalWrite(sensMotA,LOW);
digitalWrite(freinMotA,LOW); // frein off

digitalWrite(vitesseMotB,LOW); // à l’arret
digitalWrite(sensMotB,LOW);  
digitalWrite(freinMotB,LOW); // frein off

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

//—— test initial du moteur A —-
//- sens 1
digitalWrite(sensMotA,LOW); // sens 1
digitalWrite(vitesseMotA, HIGH); // vitesse maximale
delay(2000); // 2 secondes
digitalWrite(vitesseMotA, LOW); // vitesse maximale

//- sens 2
digitalWrite(sensMotA,HIGH); // sens 2
digitalWrite(vitesseMotA, HIGH); // vitesse maximale
delay(1000); // 2 secondes
Serial.println(analogRead(intensiteMotA));
delay(1000); // 2 secondes
digitalWrite(vitesseMotA, LOW); // vitesse maximale

//—— test initial du moteur B —-
//- sens 1
digitalWrite(sensMotB,LOW); // sens 1
digitalWrite(vitesseMotB, HIGH); // vitesse maximale
delay(2000); // 2 secondes
digitalWrite(vitesseMotB, LOW); // vitesse maximale

//- sens 2
digitalWrite(sensMotB,HIGH); // sens 2
digitalWrite(vitesseMotB, HIGH); // vitesse maximale
delay(1000); // 2 secondes
Serial.println(analogRead(intensiteMotB));
delay(1000); // 2 secondes
digitalWrite(vitesseMotB, LOW); // vitesse maximale

//—- test vitesse variable moteur A —

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotA,i); // PWM croissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotA));

}

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotA,255–i); // PWM décroissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotA));
}

//—- test vitesse variable moteur B —

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotB,i); // PWM croissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotB));

}

for (int i=0; i<=255; i++) {
  analogWrite(vitesseMotB,255–i); // PWM décroissant
  delay(50); // pause
  Serial.println(analogRead(intensiteMotB));

}

while(1); // stop loop

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