Premiers montages

/**
 * Utilisation d'un bouton poussoir comme bascule d'état.
 * Le bouton poussoir va commander l'allumage d'une LED.
 */

#define LED 11
#define BOUTON 2

#define REBOND 50

unsigned long rebond_bouton ;
int           lecture_bouton,
              lecture_precedente ;
bool          etat ;

/** Gestion du bouton poussoir.
 * Pour éviter les rebonds la lecture n'est faite que toutes
 * les REBOND ms.
 * Pour éviter les changements d'état non désirés quand le bouton
 * reste enfoncé, on utilise un mécanisme de détection
 * des fronts descendants.
 */
void lire_bouton()
{
  if ( (millis() - rebond_bouton) > REBOND ) {
    rebond_bouton = millis() ;
    lecture_bouton = digitalRead(BOUTON) ;
    if ( lecture_bouton != lecture_precedente ) {
      if ( lecture_bouton == LOW ) {
        etat = !etat ;
      }
      lecture_precedente = lecture_bouton ;
    }
  }
} 

void setup()
{
  // La LED étant branchée au +5V,
  // on positionne la sortie à HIGH pour l'éteindre.
  pinMode(LED, OUTPUT) ;
  digitalWrite(LED, HIGH) ;

  /* Le bouton fait tomber le signal quand
   * il est actionné. Il faut donc que le signal
   * soit à HIGH au repos. On saura qu'il a été actionné
   * si on lit la valeur LOW sur le port correspondant.
   */
  pinMode(BOUTON, INPUT_PULLUP) ;

  rebond_bouton = millis() ;

  lire_bouton() ;
}

void loop()
{
  // Lecture de l'état du bouton
  lire_bouton() ;

  // Modification de l'état de la LED
  if ( etat ) {
    digitalWrite(LED, LOW) ;
  } else {
    digitalWrite(LED, HIGH) ;
  }
}

/**
 * Faire pulser une LED.
 * La luminosité de la LED va varier avec le temps.
 * De l'état complètement éteint, elle va
 * passer par plusieurs étapes pour arriver à un
 * état complètement allumé et inversement.
 * Le fonctionnement du pulse est toujours commandé par
 * le bouton poussoir.
 */

#define POT A4

#define LED 11
#define BOUTON 2

#define REBOND 50
#define DELTA_PULSE 1

unsigned int  seuil ;
unsigned long rebond_bouton,
              pulse_led_delai;
int           lecture_bouton,
              lecture_precedente,
              pulse_led_valeur,
              pulse_direction ;
bool          etat ;

/** Gestion du bouton poussoir.
 * Pour éviter les rebonds la lecture n'est faite que toutes
 * les REBOND ms.
 * Pour éviter les changements d'état non désirés quand le bouton
 * reste enfoncé, on utilise un mécanisme de détection
 * des fronts descendants.
 */
void lire_bouton()
{
  if ( (millis() - rebond_bouton) > REBOND ) {
    rebond_bouton = millis() ;
    lecture_bouton = digitalRead(BOUTON) ;
    if ( lecture_bouton != lecture_precedente ) {
      if ( lecture_bouton == LOW ) {
        etat = !etat ;
      }
      lecture_precedente = lecture_bouton ;
    }
  }
}

/** Une étape de pulse.
 * La fonction est appelée plus ou moins fréquemment
 * selon la vitesse de pulse que l'on désire obtenir.
 */
void pulse_LED_step()
{
  pulse_led_valeur += pulse_direction * DELTA_PULSE ;
  if ( pulse_led_valeur >= 255 || pulse_led_valeur <= 0 ) {
    pulse_direction = -1 * pulse_direction ;
    if ( pulse_led_valeur <= 0 ) {
      pulse_led_valeur = 0 ;
    } else {
      pulse_led_valeur = 255 ;
    }
  }
  analogWrite(LED, pulse_led_valeur) ;
}

/** Fonction de lecture du seuil.
 * En fonction du type de dispositif employé pour
 * fixer le seuil, on pourra adapter le comportement
 * de cette fonction, tant que son prototype reste le même.
 */
int lire_seuil()
{
  return analogRead(POT) ;
}


void setup()
{
  // La LED étant branchée au +5V,
  // on positionne la sortie à HIGH pour l'éteindre.
  pinMode(LED, OUTPUT) ;
  digitalWrite(LED, HIGH) ;

  // Le bouton fait tomber le signal quand
  // il est actionné. Il faut donc que le signal
  // soit à HIGH au repos. On saura qu'il a été actionné
  // si on lit la valeur LOW sur le port correspondant.
  pinMode(BOUTON, INPUT_PULLUP) ;

  rebond_bouton = millis() ;
  pulse_led_delai = micros() ;
  pulse_led_valeur = 0 ;
  pulse_direction = 1 ;
  
  lire_bouton() ;
}

void loop()
{
  // Lecture de la valeur du potentiomètre
  seuil = lire_seuil() ;
  
  // Lecture de l'état du bouton
  lire_bouton() ;

  // Modification de l'état de la LED
  if ( etat ) {
    if ( (micros() - pulse_led_delai) > seuil ) {
      pulse_led_delai = micros() ;
      pulse_LED_step() ;
    }
  } else {
    digitalWrite(LED, HIGH) ;
  }
}

/**
 * 
 */

#define TEMP A3
#define POT A4

#define LED 11
#define BOUTON 2

#define REBOND 50

unsigned int temperature,
             seuil,
             rebond_bouton,
             pulse_led ;
int          lecture_bouton,
             lecture_precedente ;
bool         etat ;

/** Gestion du bouton poussoir.
 * Pour éviter les rebonds la lecture n'est faite que toutes
 * les REBOND ms.
 * Pour éviter les changements d'état non désirés quand le bouton
 * reste enfoncé, on utilise un mécanisme de détection
 * des fronts descendants.
 */
void lire_bouton()
{
  if ( (millis() - rebond_bouton) > REBOND ) {
    rebond_bouton = millis() ;
    lecture_bouton = digitalRead(BOUTON) ;
    if ( lecture_bouton != lecture_precedente ) {
      if ( lecture_bouton == LOW ) {
        etat = !etat ;
      }
      lecture_precedente = lecture_bouton ;
    }
  }
} 

/** Pilotage de la LED.
 * Si la température dépasse le seuil fixé par le
 * potentiomètre, la LED est allumée à pleine puissance.
 * Sinon, sa luminosité dépend de l'écart entre le seuil
 * et la température.
 */
void pilote_LED()
{
  if ( temperature > seuil ) {
    digitalWrite(LED, LOW) ;
  } else if ( temperature < 0.95*seuil ) {
    analogWrite(LED, (int)(255./1023.*(seuil-temperature))) ;
  } 
}

/** Fonction de lecture de la température.
 * En fonction du capteur employé, on pourra changer
 * le comportement de cette fonction, tant que son
 * prototype reste le même.
 */
int lire_temperature()
{
  return analogRead(TEMP) ;
}

/** Fonction de lecture du seuil.
 * En fonction du type de dispositif employé pour
 * fixer le seuil, on pourra adapter le comportement
 * de cette fonction, tant que son prototype reste le même.
 */
int lire_seuil()
{
  return analogRead(POT) ;
}


void setup()
{
  // La LED étant branchée au +5V,
  // on positionne la sortie à HIGH pour l'éteindre.
  pinMode(LED, OUTPUT) ;
  digitalWrite(LED, HIGH) ;

  // Le bouton fait tomber le signal quand
  // il est actionné. Il faut donc que le signal
  // soit à HIGH au repos. On saura qu'il a été actionné
  // si on lit la valeur LOW sur le port correspondant.
  pinMode(BOUTON, INPUT_PULLUP) ;

  rebond_bouton = pulse_led = millis() ;

  lire_bouton() ;
}

void loop()
{
  // La lecture des valeurs de seuil et
  // de température se fait tout le temps.
  temperature = lire_temperature() ;
  seuil = lire_seuil() ;

  // Lecture de l'état du bouton
  lire_bouton() ;

  // Modification de l'état de la LED
  if ( etat ) {
    pilote_LED() ;
  } else {
    digitalWrite(LED, HIGH) ;
  }
}