Schéma

Code du circuit :

int buzzer = 8;

int boutonPlus = A0;
int boutonMoins = A1;
int boutonAlarme = A2;

int frequence = 400;

bool ancienEtatPlus = LOW;
bool ancienEtatMoins = LOW;

void setup()
{
  pinMode(buzzer, OUTPUT);

  pinMode(boutonPlus, INPUT);
  pinMode(boutonMoins, INPUT);
  pinMode(boutonAlarme, INPUT);

  pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
  bool etatPlus = digitalRead(boutonPlus);
  bool etatMoins = digitalRead(boutonMoins);
  bool etatAlarme = digitalRead(boutonAlarme);

  // ===== BOUTON 1 : PLUS AIGU =====
  if (etatPlus == HIGH && ancienEtatPlus == LOW)
  {
    frequence += 100;

    if (frequence > 2000)
    {
      frequence = 2000;
    }

    tone(buzzer, frequence, 50);

    digitalWrite(LED_BUILTIN, HIGH);
    delay(5);
    digitalWrite(LED_BUILTIN, LOW);
  }

  // ===== BOUTON 2 : PLUS GRAVE =====
  if (etatMoins == HIGH && ancienEtatMoins == LOW)
  {
    frequence -= 100;

    if (frequence < 100)
    {
      frequence = 100;
    }

    tone(buzzer, frequence, 50);

    digitalWrite(LED_BUILTIN, HIGH);
    delay(5);
    digitalWrite(LED_BUILTIN, LOW);
  }

  // ===== BOUTON 3 : ALARME NUCLEAIRE =====
  if (etatAlarme == HIGH)
  {
    // montée + descente ultra rapide
    for (int i = 0; i < 3; i++)
    {
      // montée
      for (int f = 600; f <= 1800; f += 25)
      {
        tone(buzzer, f);
        digitalWrite(LED_BUILTIN, HIGH);
        delay(1);

        if (digitalRead(boutonAlarme) == LOW)
        {
          noTone(buzzer);
          digitalWrite(LED_BUILTIN, LOW);
          return;
        }
      }

      // descente
      for (int f = 1800; f >= 600; f -= 25)
      {
        tone(buzzer, f);
        digitalWrite(LED_BUILTIN, LOW);
        delay(1);

        if (digitalRead(boutonAlarme) == LOW)
        {
          noTone(buzzer);
          digitalWrite(LED_BUILTIN, LOW);
          return;
        }
      }
    }
  }
  else
  {
    noTone(buzzer);
    digitalWrite(LED_BUILTIN, LOW);
  }

  ancienEtatPlus = etatPlus;
  ancienEtatMoins = etatMoins;

  delay(1);
}

Explication du programme Arduino (ligne par ligne)

---

int buzzer = 8;

➡️ Définit la broche 8 de l’Arduino comme sortie pour le buzzer (haut-parleur).

---

int boutonPlus = A0;

➡️ Le bouton connecté à A0 sert à augmenter la fréquence du son (son plus aigu).

---

int boutonMoins = A1;

➡️ Le bouton connecté à A1 sert à diminuer la fréquence du son (son plus grave).

---

int boutonAlarme = A2;

➡️ Le bouton connecté à A2 sert à activer ou désactiver l’alarme.

---

int frequence = 400;

➡️ Définit la fréquence de départ du son (400 Hz).

---

bool ancienPlus = HIGH;

➡️ Stocke l’ancien état du bouton plus pour détecter un nouvel appui.

---

bool ancienMoins = HIGH;

➡️ Stocke l’ancien état du bouton moins pour détecter un nouvel appui.

---

bool alarmeActive = false;

➡️ Variable qui indique si l’alarme est activée ou non.

---

⚙️ setup()

void setup()

➡️ Fonction exécutée une seule fois au démarrage de l’Arduino.

---

pinMode(buzzer, OUTPUT);

➡️ Configure le buzzer en sortie pour produire du son.

---

pinMode(boutonPlus, INPUT_PULLUP);

➡️ Configure le bouton A0 en entrée avec résistance interne (INPUT_PULLUP).

---

pinMode(boutonMoins, INPUT_PULLUP);

➡️ Configure le bouton A1 en entrée avec résistance interne.

---

pinMode(boutonAlarme, INPUT_PULLUP);

➡️ Configure le bouton A2 en entrée avec résistance interne.

---

pinMode(LED_BUILTIN, OUTPUT);

➡️ Configure la LED intégrée de l’Arduino comme sortie.

---

🔁 loop()

void loop()

➡️ Fonction qui s’exécute en boucle infinie.

---

bool plus = digitalRead(boutonPlus);

➡️ Lit l’état actuel du bouton plus (appuyé ou non).

---

bool moins = digitalRead(boutonMoins);

➡️ Lit l’état actuel du bouton moins.

---

bool alarme = digitalRead(boutonAlarme);

➡️ Lit l’état du bouton alarme.

---

🚨 Gestion de l’alarme

if (alarme == LOW && alarmeActive == false)

➡️ Si on appuie sur le bouton alarme et qu’elle est désactivée.

---

alarmeActive = true;

➡️ Active l’alarme.

---

else if (alarme == LOW && alarmeActive == true)

➡️ Si on réappuie sur le bouton alarme.

---

alarmeActive = false;

➡️ Désactive l’alarme.

---

🚨 Mode alarme

int f = 600 + (millis() % 1200);

➡️ Crée une variation automatique de fréquence pour faire une sirène.

---

tone(buzzer, f);

➡️ Produit le son du buzzer avec la fréquence calculée.

---

digitalWrite(LED_BUILTIN, millis() % 100 < 50);

➡️ Fait clignoter la LED comme un gyrophare.

---

🔼 Bouton plus (aigu)

if (plus == LOW && ancienPlus == HIGH)

➡️ Détecte un nouvel appui sur le bouton A0.

---

frequence += 100;

➡️ Augmente la fréquence (son plus aigu).

---

tone(buzzer, frequence);

➡️ Joue le son avec la nouvelle fréquence.

---

🔽 Bouton moins (grave)

if (moins == LOW && ancienMoins == HIGH)

➡️ Détecte un nouvel appui sur le bouton A1.

---

frequence -= 100;

➡️ Diminue la fréquence (son plus grave).

---

tone(buzzer, frequence);

➡️ Joue le son modifié.

---

🔊 Maintien du son

tone(buzzer, frequence);

➡️ Maintient le son actif en continu même sans appuyer.

---

🔁 Mise à jour des états

ancienPlus = plus;

➡️ Sauvegarde l’état actuel du bouton plus.

---

ancienMoins = moins;

➡️ Sauvegarde l’état du bouton moins.

---

⏱️ Pause

delay(10);

➡️ Petite pause pour stabiliser le programme.

je vais vous présenter mon installation et mon programme.

ici on a l’installation de la carte Arduino, d ‘une LED et de sa résistance, de trois bouton et du buzzer avec sa résistance pour émettre le son.

Ici on a le début du code qui nous permet d augmenter dans les aigus et descendre dans les graves pour savoir si la vitesse à augmenter ou diminuer.

Ce bout de code nous permet d’avoir un point mort.

code :

int buzzer = 8;

int boutonPlus = A0;
int boutonMoins = A1;
int boutonAlarme = A2;

int frequence = 400;

bool ancienEtatPlus = LOW;
bool ancienEtatMoins = LOW;
bool ancienEtatAlarme = LOW;

void setup()
{
  pinMode(buzzer, OUTPUT);
  
  pinMode(boutonPlus, INPUT);
  pinMode(boutonMoins, INPUT);
  pinMode(boutonAlarme, INPUT);
  
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
  bool etatPlus = digitalRead(boutonPlus);
  bool etatMoins = digitalRead(boutonMoins);
  bool etatAlarme = digitalRead(boutonAlarme);
  
  // ===== BOUTON 1 =====
  // son plus aigue
if (etatPlus == HIGH && ancienEtatPlus == LOW)
{
  frequence = frequence + 100;
  
  if (frequence > 2000)
  {
    frequence = 2000;
  }
  
  tone(buzzer, frequence, 200);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(50);
  digitalWrite(LED_BUILTIN, LOW);
}
  

  // ===== BOUTON 2 =====
  // son plus grave
if (etatMoins == HIGH && ancienEtatMoins == LOW)
{
  frequence = frequence - 100;
  
  if (frequence < 100)
  {
    frequence = 100;
  }
  
  tone(buzzer, frequence, 200);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(50);
  digitalWrite(LED_BUILTIN, LOW);
}
  
  

  // ===== BOUTON 3 =====
  // alarme
if (etatAlarme == HIGH && ancienEtatAlarme == LOW)
{
  for (int i = 0; i < 5; i++)
  {
    tone(buzzer, frequence, 1000);
    digitalWrite(LED_BUILTIN, HIGH);
    delay(150);
    
    tone(buzzer, frequence, 400);
    digitalWrite(LED_BUILTIN, LOW);
    delay(50);
  }
  
  noTone(buzzer);
  
}
  
ancienEtatPlus = etatPlus;
ancienEtatMoins = etatMoins;
ancienEtatAlarme = etatAlarme;
  
delay(50);
  
}

1. Déclaration des variables

int buzzer = 8;

Cette ligne indique que le buzzer est connecté à la broche numérique 8 de l’arduino.

int boutonPlus = A0;

int boutonMoins = A1;

int boutonAlarme = A2;

Ces lignes définissent les broches utilisées pour les trois boutons poussoirs :

• A0 = bouton pour augmenter le son
• A1 = bouton pour diminuer le son
• A2 = bouton pour activer l’alarme

int frequence = 400;

La variable fréquence contient la fréquence du son du buzzer en Hertz (Hz);

Au départ, elle vaut 400 Hz

2. Variables des anciens états

Circuit:

Code de mon circuit :

int buzzer = 8;

int boutonPlus = A0;
int boutonMoins = A1;
int boutonAlarme = A2;

int frequence = 400;

bool ancienEtatPlus = LOW;
bool ancienEtatMoins = LOW;
bool ancienEtatAlarme = LOW;

void setup()
{
pinMode(buzzer, OUTPUT);

pinMode(boutonPlus, INPUT);
pinMode(boutonMoins, INPUT);
pinMode(boutonAlarme, INPUT);

pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
bool etatPlus = digitalRead(boutonPlus);
bool etatMoins = digitalRead(boutonMoins);
bool etatAlarme = digitalRead(boutonAlarme);

// ===== BOUTON 1 =====
// son plus aigu
if (etatPlus == HIGH && ancienEtatPlus == LOW)
{
frequence = frequence + 100;

if (frequence > 2000)
{
  frequence = 2000;
}

tone(buzzer, frequence, 200);

digitalWrite(LED_BUILTIN, HIGH);
delay(50);
digitalWrite(LED_BUILTIN, LOW);

}

// ===== BOUTON 2 =====
// son plus grave
if (etatMoins == HIGH && ancienEtatMoins == LOW)
{
frequence = frequence – 100;

if (frequence < 100) // Limite basse pour éviter les fréquences négatives
{
  frequence = 100;
}

tone(buzzer, frequence, 200);

digitalWrite(LED_BUILTIN, HIGH);
delay(50);
digitalWrite(LED_BUILTIN, LOW);

}

// Mise à jour des anciens états pour le prochain tour de boucle
ancienEtatPlus = etatPlus;
ancienEtatMoins = etatMoins;
ancienEtatAlarme = etatAlarme;
}

Explication du code

Voici l’explication ligne par ligne de votre code Arduino. Pour que ce soit plus simple à comprendre, je l’ai découpé par sections logiques.

---

1. Déclaration des composants (Broches)

Ces lignes associent un nom compréhensible au numéro de la prise (broche/pin) de l’Arduino où est branché chaque composant.

• int buzzer = 8; Indique que le buzzer est branché sur la broche numérique 8.
• int boutonPlus = A0;Indique que le bouton pour augmenter le son est branché sur la broche analogique A0.
• int boutonMoins = A1; Indique que le bouton pour baisser le son est branché sur la broche analogique A1.
• int boutonAlarme = A2; Indique qu’un troisième bouton (alarme) est branché sur la broche analogique A2.

---

2. Variables de configuration et d’état

Ces lignes permettent à l’Arduino de garder des informations en mémoire (la fréquence du son et si on a déjà appuyé sur les boutons).

• int frequence = 400; Crée une variable pour stocker la hauteur du son (en Hertz). Elle démarre à 400 Hz.
• bool ancienEtatPlus = LOW;
• bool ancienEtatMoins = LOW;
• bool ancienEtatAlarme = LOW;Ces trois lignes servent à mémoriser l’état précédent de chaque bouton (au repos : LOW). Cela permettra au programme de détecter le moment précis où vous appuyez sur le bouton, et d’éviter que le son ne s’emballe si vous laissez votre doigt posé dessus.

---

3. La configuration initiale (void setup)

Cette section s’exécute une seule fois au démarrage de l’Arduino pour configurer le rôle de chaque broche (entrée ou sortie).

• void setup() {Ouvre la fonction de configuration.
• pinMode(buzzer, OUTPUT); Configure la broche du buzzer en SORTIE (l’Arduino va lui envoyer de l’électricité pour faire du bruit).
• pinMode(boutonPlus, INPUT);
• pinMode(boutonMoins, INPUT);
• pinMode(boutonAlarme, INPUT); Configurent les broches des boutons en ENTRÉE (l’Arduino « écoute » si de l’électricité arrive quand on appuie dessus).
• pinMode(LED_BUILTIN, OUTPUT); Configure la petite LED directement intégrée sur la carte Arduino en SORTIE pour pouvoir l’allumer.
• }À quoi ça sert : Ferme la fonction de configuration.

---

4. La boucle principale (void loop)

Cette partie s’exécute en boucle et à l’infini tant que l’Arduino est allumé.

• void loop() {Ouvre la boucle principale du programme.

Lecture de l’état actuel des boutons

• bool etatPlus = digitalRead(boutonPlus);
• bool etatMoins = digitalRead(boutonMoins);
• bool etatAlarme = digitalRead(boutonAlarme); L’Arduino regarde en temps réel si un bouton est enfoncé (HIGH) ou relâché (LOW), et stocke cette réponse instantanée dans trois nouvelles variables (etat...).

Action du Bouton 1 (Augmenter le son)

• // ===== BOUTON 1 ===== et // son plus aigu Ce sont des commentaires pour l’humain, l’Arduino les ignore.
• if (etatPlus == HIGH && ancienEtatPlus == LOW) { C’est la condition magique : « Si le bouton est appuyé MAINTENANT (HIGH) ET qu’il était relâché juste AVANT (LOW) ». Cela permet de ne déclencher l’action qu’une seule fois par clic.
• frequence = frequence + 100;Augmente la valeur de la fréquence de 100 Hz (le son sera plus aigu).
• if (frequence > 2000) { frequence = 2000; } Sécurité : si la fréquence dépasse 2000 Hz, on la bloque à 2000 Hz pour que ça ne devienne pas trop strident ou inaudible.
• tone(buzzer, frequence, 200); Fait sonner le buzzer à la fréquence calculée pendant une durée de 200 millisecondes.
• digitalWrite(LED_BUILTIN, HIGH); Allume la LED de la carte Arduino pour faire un retour visuel.
• delay(50); Met le programme en pause pendant 50 millisecondes.
• digitalWrite(LED_BUILTIN, LOW);Éteint la LED de la carte.
• }À quoi ça sert : Ferme le bloc d’action du bouton 1.

---

5. Fin du code (Ajouts pour la logique)

• // ===== BOUTON 2 ===== Début de la zone pour programmer le bouton qui baisse le son (la logique est identique au bouton 1, mais en faisant - 100).
• ancienEtatPlus = etatPlus;
• ancienEtatMoins = etatMoins;
• ancienEtatAlarme = etatAlarme;Juste avant de recommencer la boucle, on dit à l’Arduino : « L’état actuel devient maintenant l’ancien état ». C’est ce qui permet de savoir ce qu’il s’est passé au tour précédent.
• } Ferme la boucle principale (loop). Le programme repart immédiatement à la ligne 24.

[int frequence = 500;] cette ligne sert a : -crée une variable appelée frequence

-stocke la fréquence du son

-démarre à 500 Hz

[bool ancienA0 = LOW;
bool ancienA1 = LOW;

bool ancienA2 = LOW;] cette ligne sert a : -détecter et éviter des répétitions trop rapides

[pinMode(A0, INPUT);] cette ligne sert a : -configure la broche A0

-en entrée (INPUT)

-pour lire le bouton 1

[pinMode(A1, INPUT);] cette ligne sert a : -configure la broche A0

-en entrée (INPUT)

-pour lire le bouton 2

[pinMode(A2, INPUT);] cette ligne sert a : -configure le bouton obstacle

[pinMode(8, OUTPUT);] cette ligne sert a : -configure la pin 8 en sortie

-pour envoyer le son au buzzer

[bool etatA0 = digitalRead(A0);] cette ligne sert a : -lire l’état du bouton A0

[bool etatA1 = digitalRead(A1);] cette ligne sert a : -lire l’état du bouton A1

[bool etatA2 = digitalRead(A2);] cette ligne sert a : -lire l’état du bouton A2

[if (etatA0 == HIGH && ancienA0 == LOW)] Cette condition signifie : -ET il ne l’était pas avant

-le bouton est appuyé maintenant

[frequence = frequence + 100;] cette ligne sert a : -augmente la fréquence de 100 Hz

-le son devient plus aigu

[if (frequence > 2000)] cette ligne sert a : -vérifie si le son devient trop aigu

[frequence = 2000;] cette ligne sert a : -bloque la fréquence maximum à 2000 Hz

[tone(8, frequence, 200);] cette ligne sert a : -Jouer un son

-pendant 200 ms

-sur la pin 8

-avec la fréquence choisie

[frequence = frequence – 100;] cette ligne sert a : -diminue la fréquence

-le son devient plus grave

[if (frequence < 100)] cette ligne sert a : -vérifie si le son est trop grave

[noTone(8);] cette ligne sert a : -arrête complètement le buzzer

[frequence = 100;] cette ligne sert a : -empêche la fréquence de descendre sous 100 Hz

[else] cette ligne sert a : -le son continue normalement

[tone(8, frequence, 200);] cette ligne sert a : -jouer le nouveau son grave

[if (etatA2 == HIGH && ancienA2 == LOW)] cette ligne sert a : -détecté un nouvel appui sur le bouton obstacle

[noTone(8);] cette ligne sert a : -coupé immédiatement le son précédent

[tone(8, 2500, 1000);] cette ligne sert a : -émettre le sons de l’alarme

[ancienA0 = etatA0;
ancienA1 = etatA1;

ancienA2 = etatA2;] cette ligne sert a : -mémorise l’état actuel des boutons

-pour comparer au prochain tour

[delay(10);] cette ligne sert a : -attendre 10 millisecondes

Etape 1 : changement son en fonction de la vitesse

Appuie sur BP1 pour accélérer

BP2 pour ralentire et reculer

Code Arduino

int buzzer = 3;

int BP1 = 2; // augmente le niveau
int BP2 = 4; // diminue le niveau

int niveau = 0; // de 0 à 9

int frequences[10] = {
150, 220, 300, 400, 500,
650, 800, 1000, 1300, 1600
};

void setup() {
pinMode(buzzer, OUTPUT);

pinMode(BP1, INPUT_PULLUP);
pinMode(BP2, INPUT_PULLUP);
}

void loop() {

if (digitalRead(BP1) == LOW) {
niveau++;

if (niveau > 9) {
  niveau = 9;
}

delay(250);

}

if (digitalRead(BP2) == LOW) {
niveau–;

if (niveau < 0) {
  niveau = 0;
}

delay(250);

}

if (niveau == 0) {
noTone(buzzer);
} else {
tone(buzzer, frequences[niveau]);
}
}

Animation tension d’une corde

https://physique.ostralo.net/corde_guitare

Cours complété:

sim_id	label	role	password	api_token
default	ADMIN	admin	5njbmEKqLqe4	b8394264cb074bbc7b4a4902677581e07c61edc848c4c7ed
eleve01	ELEVE01	student	mWphvci7P3	07d2c641ab02bf918098a28197614d29e6b771c70a2572c7
eleve02	ELEVE02	student	CAcJnUnf4S	e6be08d289a6f99290109a6942c56b1ac5f1edf94b957fd7
eleve03	ELEVE03	student	Jur9QJdsFD	cc5fd0fe1c9f8f86fa6b7fc05f9127d4d77ce03869d78dab
eleve04	ELEVE04	student	6DcZGtr2Xu	022fd9bfe706ada0a52f8ce151f242c25acdd3a2f9f42e6a
eleve05	ELEVE05	student	sdYcZoSewC	d3777b7ae09a2022078ca7c832360dfe71d4aab29e40b675
eleve06	ELEVE06	student	LhXPz2PC5x	62d13086e91430f88006cb7b45f3cc47e42c079639eba926
eleve07	ELEVE07	student	CMsQ6f9bTH	e54f3be163919a4b92496356fb170884f34aa8f35f6d404f
eleve08	ELEVE08	student	wNYEMQAVNZ	9c18d0e1c6b3bc3a11d8c249b677786344dc2c95443b57e5
eleve09	ELEVE09	student	mi2CJ9tqxt	2bd8edfa2b938fa871afa20eb0b6203d9720c64eac442dd3
eleve10	ELEVE10	student	ZZKcQeTPbr	0075073aa5c93c2a4c3cb73fedd6fd9f5f05fd618bc43a23

Accès web

Voir sa PAC dans le navigateur

Ouvrir :

https://proxy-automate.latelier22.fr/pac.php?sim=eleveXX

Exemple :

https://proxy-automate.latelier22.fr/pac.php?sim=eleve03

Se connecter pour piloter sa PAC

Lien vers les mots de passe et les tokens (jetons pour connexion API)
https://www.fulgence-bienvenue.fr/2026/05/11/mots-de-passe-pac/

Ouvrir :

https://proxy-automate.latelier22.fr/login.php?sim=eleveXX&redirect=/pac.php?sim=eleveXX

Exemple :

https://proxy-automate.latelier22.fr/login.php?sim=eleve03&redirect=/pac.php?sim=eleve03

Après connexion, l’élève revient sur sa PAC.

Lire l’état brut en JSON

Ouvrir :

https://proxy-automate.latelier22.fr/api.php?sim=eleveXX

---

Commandes curl Windows

Remplacer :

• eleveXX par votre identifiant
• TOKEN_ELEVE_XX par votre token

Lire l’état

curl "https://proxy-automate.latelier22.fr/api.php?sim=eleveXX"

START

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: TOKEN_ELEVE_XX" -d "action=start&sim=eleveXX"

STOP

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: TOKEN_ELEVE_XX" -d "action=stop&sim=eleveXX"

Consigne +

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: TOKEN_ELEVE_XX" -d "action=sp_plus&sim=eleveXX"

Consigne –

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: TOKEN_ELEVE_XX" -d "action=sp_minus&sim=eleveXX"

Mettre une consigne directe à 22.5

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: TOKEN_ELEVE_XX" -d "action=set_setpoint&setpoint=22.5&sim=eleveXX"

Mettre la température ambiante à 18

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: TOKEN_ELEVE_XX" -d "action=set_ambient&ambient_temp=18&sim=eleveXX"

RESET

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: TOKEN_ELEVE_XX" -d "action=reset&sim=eleveXX"

Exemple réel pour eleve10

Lire

curl "https://proxy-automate.latelier22.fr/api.php?sim=eleve10"

START

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: 0075073aa5c93c2a4c3cb73fedd6fd9f5f05fd618bc43a23" -d "action=start&sim=eleve10"

STOP

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: 0075073aa5c93c2a4c3cb73fedd6fd9f5f05fd618bc43a23" -d "action=stop&sim=eleve10"

RESET

curl -X POST "https://proxy-automate.latelier22.fr/control.php" -H "Content-Type: application/x-www-form-urlencoded" -H "X-Api-Token: 0075073aa5c93c2a4c3cb73fedd6fd9f5f05fd618bc43a23" -d "action=reset&sim=eleve10"

A faire

Modifier votre application mobile

Ajouter 2 boutons PLUS et MOINS pour augmenter / diminuer la consigne de température de la PAC

il faudra ajouter votre token, sinon vous ne serez pas autorisé à commander la PAC à distance….

App Inventor — LED Bluetooth — anglais

1. Elements à mettre et à nommer

Dans User Interface

Élément à glisser	Renommer en	Text
ListPicker	ListPicker_BT	Connect Bluetooth
Button	Button_ON	ON
Button	Button_OFF	OFF
Label	Label_Status	Not connected

---

Dans Connectivity

Élément à glisser	Renommer en
BluetoothClient	BluetoothClient1

---

2. Blocks

Cliquer sur Blocks.

---

3. Bloc connexion : liste Bluetooth

Cliquer sur ListPicker_BT.

Prendre :

when ListPicker_BT.BeforePicking

Ajouter :

set ListPicker_BT.Elements to BluetoothClient1.AddressesAndNames

Bloc complet :

when ListPicker_BT.BeforePicking
do set ListPicker_BT.Elements to BluetoothClient1.AddressesAndNames

---

4. Bloc connexion : choisir HC-05

Cliquer sur ListPicker_BT.

Prendre :

when ListPicker_BT.AfterPicking

Ajouter :

call BluetoothClient1.Connect address ListPicker_BT.Selection

Ajouter :

set Label_Status.Text to "Connected"

Bloc complet :

when ListPicker_BT.AfterPicking
do call BluetoothClient1.Connect address ListPicker_BT.Selection
   set Label_Status.Text to "Connected"

---

5. Bloc bouton ON

Cliquer sur Button_ON.

Prendre :

when Button_ON.Click

Ajouter :

if BluetoothClient1.IsConnected
then call BluetoothClient1.SendText text "1"

Bloc complet :

when Button_ON.Click
do if BluetoothClient1.IsConnected
   then call BluetoothClient1.SendText text "1"

---

6. Bloc bouton OFF

Cliquer sur Button_OFF.

Prendre :

when Button_OFF.Click

Ajouter :

if BluetoothClient1.IsConnected
then call BluetoothClient1.SendText text "0"

Bloc complet :

when Button_OFF.Click
do if BluetoothClient1.IsConnected
   then call BluetoothClient1.SendText text "0"

---

7. Résultat

ON  → envoie 1 → LED allumée
OFF → envoie 0 → LED éteinte