PorteServo2BP (comments)

//===============================================================
// Exploration Hardware
// Ouvrir une porte avec un servomoteur
// Ollivier JULLIEN
// Juillet 2020
//===============================================================

//===============================================================
// Ouverture d'une porte avec indicateurs lumineux et sonores
// Commande par deux boutons poussoirs en appui constant
// (ça s'ouvre ou ça se ferme que si on reste appuyé, sinon ça s'arrête)
// Action de la porte par servo FS90
//===============================================================

//===============================================================
// Matériel :
// 2 BP (pour moi 1 DFR0029W et 1 DFR0029B)
// 2 LEDs blanches 5 mm
// 2 LEDs rouges 5 mm
// 1 LED bleue 5 mm
// 1 LED verte 5 mm
// 6 résistances 220 ohm
// 1 buzzer SV12-5
// 1 mini-servomoteur FS90
// 1 Arduino Uno
// Câblage
//===============================================================

//===============================================================
// ATTENTION :
// La porte au repos est ouvert, donc langle Max est l'angle de la porte fermée
// et l'angle Mini est l'angle de la porte ouverte
// rien ne vous oblige à vous y tenir
//===============================================================

#include <Servo.h> // on inclut la bibliothèque de gestion des servomoteurs

Servo maPorte; // on crée "notre servo" qu'on nomme "maPorte"
// Plus exactement :
// en fait on crée une occurence de l'objet Servo défini par la bibliothèque,
// que l'on nomme "maPorte".
// on dira donc, plus simplement, "notre servo".

int rotationServo = 0; // on crée une variable de type int (nombre entier) que l'on nomme "rotationServo"
                       // à qui on attribue la valeur 0

const int rouge = 2; // on crée une constante de type int que l'on nomme "rouge" à qui on
                     // attribue la valeur 2
                     // cette constant nous servira à déterminer la broche de la led rouge 1
                     // ici : la broche n° 2
const int bleu = 3; // on crée une constante de type int que l'on nomme "bleu" à qui on
                    // attribue la valeur 3
                    // cette constant nous servira à déterminer la broche du bouton bleu
                    // ici : la broche n° 3
const int blanc = 4; // on crée une constante de type int que l'on nomme "blanc" à qui on
                     // attribue la valeur 4
                     // cette constant nous servira à déterminer la broche du bouton blanc
                     // ici : la broche n° 4
const int lampe = 5; // on crée une constante de type int que l'on nomme "lampe" à qui on
                     // attribue la valeur 5
                     // cette constant nous servira à déterminer la broche de les leds blanches
                     // ici : la broche n° 5
const int buzzer = 6;// on crée une constante de type int que l'on nomme "buzzer" à qui on
                     // attribue la valeur 6
                     // cette constant nous servira à déterminer la broche du buzzer
                     // ici : la broche n° 6
const int rouge2 = 7;// on crée une constante de type int que l'on nomme "rouge2" à qui on
                     // attribue la valeur 7
                     // cette constant nous servira à déterminer la broche de la led rouge 2
                     // ici : la broche n° 7
const int ok = 8; // on crée une constante de type int que l'on nomme "ok" à qui on
                  // attribue la valeur 8
                  // cette constant nous servira à déterminer la broche de la led verte
                  // ici : la broche n° 8
const int porte = 10; // on crée une constante de type int que l'on nomme "porte" à qui on
                      // attribue la valeur 10
                      // cette constant nous servira à déterminer la broche du servomoteur
                      // ici : la broche n° 10
const int veille = 12;// on crée une constante de type int que l'on nomme "veille" à qui on
                      // attribue la valeur 12
                      // cette constant nous servira à déterminer la broche de la led bleue
                      // ici : la broche n° 12

int evol = 1; // on une variable de type int (nombre entier) que l'on nomme "evol"
              // à qui on attribue la valeur de l'incrémentation
              // de l'angle du servo à chaque tour de loop() ici : 1
long tempo; // on crée une variable de type long (grands chiffre) que l'on nomme "tempo" qui servira
            // de repère temporel pour le clignottement des LEDs rouges
int tempoP = 40; // on crée une variable de type int (nombre entier) que l'on nomme tempoP
                 // à qui on attribue la valeur qui définit
                 // le temps (en millisecondes) entre deux incrémentations
int angleMax = 93; // on crée une variablede type int (nombre entier) que l'on nomme angleMax
                   //à qui on attribue la valeur qui détermine
                   // l'angle maximum d'ouverture de la porte
// pour moi, c'est le mini, désolé : à l'angle Max la porte est fermée)
int angleMini = 3; // on crée une variablede type int (nombre entier) que l'on nomme angleMini
                   // à qui on attribue la valeur qui détermine
                   // l'angle minimum d'ouverture de la porte (porte fermée)
// pour moi, c'est le maxi, désolé : à l'angle Mini la porte est ouvert)
bool etatRouge = true; // on crée une variable de type bool (true ou false) que l'on nomme "etatRouge"
                       // à qui on attribue la valeur de true
                       // qui crée un état initial des LEDs rouges
bool buzzFerme = true; // on crée une variable de type bool (true ou false) que l'on nomme "buzzFerme"
                       // à qui on attribue la valeur de true
                       // qui dit que le buzzer de fermeture a déjà sonné ou pas
bool buzzOuvert = false; // on crée une variable de type bool (true ou false) que l'on nomme "buzzOuvert"
                         // à qui on attribue la valeur de false
                         // qui dit que le buzzer d'ouverture a déja sonné ou pas

//===============================================================

void setup() {
  Serial.begin(9600); // Ouverture de la communication avec le PC (port série) à 9600 baud
  maPorte.attach(porte); // on attribue à "notre servo" la broche de connection
                         // qui a pour valeur la constante porte
                         // donc la broche 10
  pinMode(bleu, INPUT); // on définit la broche du bouton bleu comme une entrée
  pinMode(blanc, INPUT); // on définit la broche du bouton blanc comme une entrée
  pinMode(rouge, OUTPUT); // on définit la broche de la LED rouge1 comme une sortie
  pinMode(rouge2, OUTPUT); // on définit la broche de la LED rouge2 comme une sortie
  pinMode(lampe, OUTPUT); // on définit la broche de la LED lampe comme une sortie
  pinMode(buzzer, OUTPUT); // on définit la broche du buzzer comme une sortie
  pinMode(ok, OUTPUT); // on définit la broche de la LED ok comme une sortie
  pinMode(veille, OUTPUT); // on définit la broche de la LED veille comme une sortie
  rotationServo = angleMax; // on signale que l'angle du servo est angleMax au démarrage
  digitalWrite(lampe, 0); // on eteind la LED lampe
}

//===============================================================

void loop() {

  // début ------------------------------------------------------
  // Action boutons ---------------------------------------------

  // _ Action boutons bleu --------------------------------------
  if (digitalRead(bleu) == true) {            // Quand on enfonce le bouton bleu
    actionBoutBleu ();
  // _ Action boutons blanc -------------------------------------
  } else if (digitalRead(blanc) == true) {            // quand on appuie sur le bouton blanc
    actionBoutBlanc ();
  // _ Pas d'action ---------------------------------------------
  } else {            // quand aucun bouton n'est enfoncé
    rien ();
  }
  // Action boutons ---------------------------------------------
  // fin --------------------------------------------------------

  // début ------------------------------------------------------
  // Blink ------------------------------------------------------
  if ((digitalRead(bleu) == 1 && rotationServo < (angleMax - 2)) || (digitalRead(blanc) == 1 && rotationServo > (angleMini + 2))) { // si
      // ... le bouton bleu est enfoncé et que l'angle du servo est plus petit que angleMax - 2 |ou| que le bouton blanc est enfoncé et
      // que l'angle du servo est plus grand que angleMini + 2
    flashAlt();            // on fait clignoter les leds rouges alternativement si nécessaire (fonction en dessous)
  }
  // Blink ------------------------------------------------------
  // fin --------------------------------------------------------

  // début ------------------------------------------------------
  // Eclairage --------------------------------------------------
  if (rotationServo < (angleMini + 65)) {            //Si le servo à un angle plus petit que l'angle mini + 65
    digitalWrite(lampe, true);            // on allume la lampe (LEDs blanches)
  } else {            // si le servo à un angle plus grand que l'angle mini + 65
    digitalWrite(lampe, false);            // on eteind la lampe
  }
  // Eclairage --------------------------------------------------
  // fin --------------------------------------------------------

  // début ------------------------------------------------------
  // ok ---------------------------------------------------------
  if (rotationServo < (angleMini + 2)) {            // si le servo a un angle plus petit que l'angle mini +2
    allumeOK ();
  } else {            // sinon : si le servo a un angle plus grand que l'angle mini +2
    eteintOK ();
  }
  // ok ---------------------------------------------------------
  // fin --------------------------------------------------------

  // début ------------------------------------------------------
  // veille -----------------------------------------------------
  if (rotationServo > (angleMax - 2)) {            // si le servo a un angle plus grand que l'angle max - 2
    allumeVeilleuse();
  } else {            // sinon, si le servo a un angle plus petit que l'angle max - 2
    eteintVeilleuse();
  }
  // veille -----------------------------------------------------
  // fin --------------------------------------------------------

  // début ------------------------------------------------------
  // Action porte -----------------------------------------------
  actionPorte ();
  // Action porte -----------------------------------------------
  // fin --------------------------------------------------------
}

//===============================================================

void flashAlt() {
  if (millis() - tempo >= 250) {            // si il s'est écoulé 250 ms depuis le dernier repère temporel enregistré
    etatRouge = !etatRouge;            // si etatRouge = true alors il devient false et inversement
    digitalWrite(rouge, etatRouge);            // on envoie à la broche "rouge" (2) la valeur de "etatRouge" (true ou false)
    digitalWrite(rouge2, !etatRouge);            // on envoie à la broche "rouge2" (7) le contraire de la valeur de "etatRouge" (false ou true)
    tempo = millis();            // la valeur du repère temporel "tempo" devient la valeur en ms du temps écoulé depuis le setup()
    tone (buzzer, 329, 100);            // on fait sonner le buzzer (6) pendant 0.1s en Mi (329)
  }
}

void allumeVeilleuse(){
  digitalWrite(veille, true);            // on allume la LED "veilleuse" (LED bleue)
    if (buzzFerme == false) {            // si le buzzer de fermeture n'a pas encore sonné
      delay(150);            // petite pause café de 0.15s pour laisser la porte s'ouvrir complètement
      tone (buzzer, 261, 500);            // premier coup de buzzer de 0.5s (Do) (parfois 262)
      delay(600);            // petite pause café de 0.6s
      tone (buzzer, 261, 700);            // second coup de buzzer de 0.7s (Do) (parfois 262)
      buzzFerme = true;            // on indique que le buzzer de fermeture a (déjà) sonné
    }
}

void eteintVeilleuse(){
  digitalWrite(veille, false);            // on eteind la LED "veilleuse" (LED bleue)
  buzzFerme = false;            // on indique que le buzzer de fermeture n'a pas encore sonné
}

void allumeOK () {
  digitalWrite(ok, true);            // on allume la lampe OK (LED verte)
    if (buzzOuvert == false) {            // si le buzzer d'ouverture n'a pas été activé
      delay(150);            // petite pause café de 0.15s pour laisser la porte se fermer complètement
      tone (buzzer, 493, 75);            // premier coup de buzzer de 0.075s (Si) (parfois 494)
      delay(150);            // petite pause café de 0.15s
      tone (buzzer, 493, 75);            // second coup de buzzer de 0.075s (Si) (parfois 494)
      buzzOuvert = true;            // on indique que le buzzer d'ouverture à (déjà) sonné
    }
}

void eteintOK () {
  digitalWrite(ok, false);            // on éteind la lampe OK (LED verte)
  buzzOuvert = false;            // on indique que le buzzer d'ouverture n'a pas (encore) sonné
}

void actionPorte () {
  maPorte.write(rotationServo);            // ENFIN, pour finir on fait tourner le servo à l'angle obtenu
  delay(tempoP);            // on fait une pause de la valeur de temporistation pour laisser le servo tourner
                            // et temporiser le mouvement de la porte
}

void actionBoutBleu () {
  if (rotationServo < angleMax) {            // Si l'angle du servo est plus petit que l'angle max
    rotationServo += evol;            // on applique une rotation d'un anglle de la valeur de evolP au servo
  }
}

void actionBoutBlanc () {
  if (rotationServo > angleMini) {            // Si l'angle du servo est plus grand que l'angle mini
    rotationServo -= evol;            // on applique une rotation d'un anglle de la valeur de evolP au servo
  }
}

void rien () {
  digitalWrite(rouge, false);            // et on vérifie que les leds clignotantes sont éteintes
  digitalWrite(rouge2, false);
}