Auteur/autrice : admin0

SUITE DU TUTO — AJOUTER LE BOUTON RESET ROBOT
Objectif

Ajouter un bouton qui envoie une requête vers :
```
https://sti2d.latelier22.fr/fiber/api/reset
```
Quand on appuie sur ce bouton :
- l’application envoie un POST
- le serveur répond
- la réponse s’affiche dans LabelPos
1) Dans Designer, ajouter les composants

A. Ajouter le bouton

Dans User Interface :
- ajoute un Button
- nom : BtnReset
Mettre :
- Text = RESET ROBOT
B. Ajouter un composant Web

Dans Connectivity :
- ajoute un Web
- nom : WebReset
2) Créer le bloc du clic sur le bouton

Ajoute ce bloc :
```
when BtnReset.Click
do
```
3) Dans BtnReset.Click, mettre l’adresse

Dans ce bloc, mets :
```
set WebReset.Url to "https://sti2d.latelier22.fr/fiber/api/reset"
```
4) Envoyer la requête

Toujours dans le même bloc, ajoute :
```
call WebReset.PostText
    text ""
```
5) Bloc complet BtnReset.Click

Ton bloc doit être :
```
when BtnReset.Click
do
    set WebReset.Url to "https://sti2d.latelier22.fr/fiber/api/reset"
    call WebReset.PostText
        text ""
```
6) Créer le bloc de réponse du serveur

Ajoute ce bloc :
```
when WebReset.GotText
    url responseCode responseType responseContent
do
```
7) Afficher la réponse du serveur

Dans WebReset.GotText, mets :
```
set LabelPos.Text to join
    "RESET HTTP "
    responseCode
    "\n"
    responseContent
```
8) Bloc complet WebReset.GotText

Ton bloc doit être :
```
when WebReset.GotText
    url responseCode responseType responseContent
do
    set LabelPos.Text to join
        "RESET HTTP "
        responseCode
        "\n"
        responseContent
```
9) Résultat attendu

Quand on clique sur RESET ROBOT :
1. l’application appelle :
```
https://sti2d.latelier22.fr/fiber/api/reset
```
1. elle envoie un POST
2. la réponse du serveur s’affiche dans LabelPos
10) Ordre exact des étapes

Fais-les dans cet ordre :
1. ajouter BtnReset
2. ajouter WebReset
3. créer when BtnReset.Click
4. créer when WebReset.GotText
11) Si ça ne marche pas

Vérifier :
- que BtnReset existe bien
- que WebReset existe bien
- que l’URL est exactement :
```
https://sti2d.latelier22.fr/fiber/api/reset
```
- que le bloc WebReset.GotText existe
12) Résumé très court à ajouter au document

Bloc 8 : ajouter un bouton RESET ROBOT

On souhaite maintenant ajouter un bouton permettant d’envoyer une commande de réinitialisation au robot.

Composants à ajouter

Dans le Designer, ajouter :
- un bouton BtnReset
- un composant WebReset
Fonctionnement

Quand on clique sur le bouton :
- l’application envoie un POST à l’adresse :
```
https://sti2d.latelier22.fr/fiber/api/reset
```
- la réponse du serveur est affichée dans LabelPos
13) Les 3 boutons / actions de l’appli à ce stade

Ton appli sait maintenant :
- afficher ta position GPS
- afficher la position du robot
- envoyer APPEL ROBOT
- envoyer RESET ROBOT
avril 30, 2026
SUITE DU TUTO — AJOUTER LE BOUTON APPEL ROBOT
Objectif

Quand on appuie sur le bouton :
- l’application envoie la position du téléphone au serveur
- le serveur reçoit :
```
{"x":48.1762,"y":-2.7520}
```
Adresse utilisée :
```
https://sti2d.latelier22.fr/fiber/api/call-robot
```
1) Dans Designer, ajouter les composants

A. Ajouter le bouton

Dans User Interface :
- ajoute un Button
- nom : BtnAppel
Mettre :
- Text = APPEL ROBOT
B. Ajouter un Notifier

Dans User Interface :
- ajoute un Notifier
- nom : Notifier1
C. Ajouter un Web

Dans Connectivity :
- ajoute un Web
- nom : Web1
2) Vérifier les variables globales

Dans Blocks, il faut avoir au minimum :
```
initialize global lat to 0
initialize global lon to 0
initialize global hasFix to false
```
Si elles n’existent pas, crée-les.

3) Modifier le bloc GPS

Dans ton bloc :
```
when LocationSensor1.PositionChanged
```
ajoute ces 3 lignes si elles n’y sont pas déjà :
```
set global lat to get Latitude
set global lon to get Longitude
set global hasFix to true
```
Résultat attendu du bloc GPS

Ton bloc doit contenir au moins :
```
when LocationSensor1.PositionChanged
    Latitude Longitude Altitude speed
do
    set global lat to get Latitude
    set global lon to get Longitude
    set global hasFix to true

    set Marker1.Latitude to get Latitude
    set Marker1.Longitude to get Longitude
```
4) Créer le bloc du clic sur le bouton

Ajoute ce bloc :
```
when BtnAppel.Click
do
```
5) Dans BtnAppel.Click, tester si le GPS est prêt

Dans ce bloc, mets :
```
if not get global hasFix
then
    call Notifier1.ShowAlert
        notice "GPS pas prêt"
else
    call Notifier1.ShowChooseDialog
        message join
            "Appeler le robot ?"
            "\nlat = "
            get global lat
            "\nlon = "
            get global lon
        title "CONFIRMATION"
        button1Text "OUI"
        button2Text "NON"
        cancelable true
```
6) Créer le bloc après la boîte de dialogue

Ajoute ce bloc :
```
when Notifier1.AfterChoosing
    choice
do
```
7) Dans Notifier1.AfterChoosing, tester si on a cliqué sur OUI

Mets :
```
if get choice = "OUI"
then
```
8) Dans le then, mettre l’adresse du serveur

Ajoute :
```
set Web1.Url to "https://sti2d.latelier22.fr/fiber/api/call-robot"
```
9) Ajouter les headers

Ajoute ensuite :
```
set Web1.RequestHeaders to make a list
    make a list "Content-Type" "application/json"
    make a list "Connection" "Keep-Alive"
```
10) Envoyer les coordonnées

Méthode simple à faire comme sur ton image

Ajoute :
```
call Web1.PostText
    text make a dictionary
        key "x" value get global lat
        key "y" value get global lon
```
11) Bloc complet Notifier1.AfterChoosing

Au final, ton bloc doit être :
```
when Notifier1.AfterChoosing
    choice
do
    if get choice = "OUI"
    then
        set Web1.Url to "https://sti2d.latelier22.fr/fiber/api/call-robot"

        set Web1.RequestHeaders to make a list
            make a list "Content-Type" "application/json"
            make a list "Connection" "Keep-Alive"

        call Web1.PostText
            text make a dictionary
                key "x" value get global lat
                key "y" value get global lon
```
12) Créer le bloc de réponse du serveur

Ajoute ce bloc :
```
when Web1.GotText
    url responseCode responseType responseContent
do
```
13) Dans Web1.GotText, afficher la réponse

Mets :
```
set LabelPos.Text to join
    "Réponse serveur : "
    responseCode
    "\n"
    responseContent
```
14) Résultat attendu

Quand on clique sur APPEL ROBOT :
1. l’application vérifie si le GPS est prêt
2. une boîte de confirmation s’ouvre
3. si on clique sur OUI
4. l’application envoie :
```
{"x": latitude, "y": longitude}
```
1. la réponse du serveur s’affiche dans LabelPos
15) Ordre exact des blocs à ajouter

Fais-les dans cet ordre :
1. ajouter BtnAppel
2. ajouter Notifier1
3. ajouter Web1
4. vérifier les variables globales lat, lon, hasFix
5. modifier LocationSensor1.PositionChanged
6. créer when BtnAppel.Click
7. créer when Notifier1.AfterChoosing
8. créer when Web1.GotText
16) Si rien ne se passe

Vérifier
- que BtnAppel existe bien
- que Notifier1 existe bien
- que Web1 existe bien
- que global hasFix passe à true
- que global lat et global lon sont bien mis à jour
17) Si tu veux le texte exact à mettre dans ton document

Bloc 7 : ajouter un bouton d’appel du robot

On souhaite maintenant ajouter un bouton permettant d’envoyer la position du téléphone au serveur.

Composants à ajouter

Dans le Designer, ajouter :
- un bouton BtnAppel
- un composant Notifier1
- un composant Web1
Fonctionnement

Quand on clique sur le bouton :
- l’application vérifie que le GPS est prêt,
- elle demande une confirmation,
- si l’utilisateur clique sur OUI,
- elle envoie la position du téléphone à l’adresse :
```
https://sti2d.latelier22.fr/fiber/api/call-robot
```
Les coordonnées envoyées sont :
- x pour la latitude
- y pour la longitude
Réponse attendue

La réponse du serveur est affichée dans le label de position.

SUITE DU TUTO — AJOUTER LE BOUTON RESET ROBOT
avril 30, 2026
SUITE DU TUTO — AJOUTER LE ROBOT ET VOIR LES 2 MARQUEURS
- ajouter le marqueur du robot
- voir toujours les 2 marqueurs
- sans blabla
On part des de ton appli actuelle avec :
- Map1
- Marker1 = téléphone
- LabelPos
- BtnSend
- TxtJson
- LocationSensor1
1) Dans Designer, ajouter 2 composants

A. Ajouter le marqueur du robot

Dans Maps :
- ajoute un Marker
- renomme-le : MarkerRobot
B. Ajouter le composant Web

Dans Connectivity :
- ajoute un Web
- renomme-le : WebRobot
C. Ajouter une horloge

Dans Sensors :
- ajoute un Clock
- renomme-le : ClockRobot
2) Régler les propriétés

MarkerRobot
- Visible = false
ClockRobot
- TimerEnabled = true
- TimerInterval = 2000
Cela veut dire :
- toutes les 2 secondes
- l’application demandera la position du robot
3) Créer les variables globales

Va dans Blocks et ajoute ces variables :
```
initialize global myLat to 0
initialize global myLon to 0
initialize global robotLat to 0
initialize global robotLon to 0
initialize global hasRobot to false
initialize global decodedRobot to 0
initialize global robotData to 0
```
4) Modifier le bloc Screen1.Initialize

Tu as déjà un bloc when Screen1.Initialize.

Ajoute dedans :
```
set WebRobot.Url to "https://sti2d.latelier22.fr/fiber/api/robot-last"
set MarkerRobot.Visible to false
```
Ton bloc ressemble maintenant à ça :
```
when Screen1.Initialize
do
    set Map1.ZoomLevel to 16
    set Map1.CenterFromString to "48.1762740,-2.7520210"
    set LabelPos.Text to "Position : en attente du GPS"
    set WebRobot.Url to "https://sti2d.latelier22.fr/fiber/api/robot-last"
    set MarkerRobot.Visible to false
```
5) Créer une procédure pour centrer la carte entre les 2 marqueurs

Dans Procedures :
- crée une procédure
- nom : UpdateMapCenter
6) Dans UpdateMapCenter, mettre les blocs suivants

Dans cette procédure, mets :
```
if get global hasRobot
then
    set Map1.CenterFromString to join
        ((get global myLat + get global robotLat) / 2)
        ","
        ((get global myLon + get global robotLon) / 2)

    set Map1.ZoomLevel to 16
else
    set Map1.CenterFromString to join
        get global myLat
        ","
        get global myLon

    set Map1.ZoomLevel to 18
```
7) À quoi sert cette procédure

Elle fait ceci :
- si le robot est connu → la carte se centre au milieu des 2
- sinon → la carte reste centrée sur le téléphone
Important :
quand les 2 existent, on met ZoomLevel = 16
pour avoir les 2 marqueurs visibles

8) Modifier le bloc LocationSensor1.PositionChanged

Dans ton bloc actuel :
```
when LocationSensor1.PositionChanged
```
ajoute d’abord ces 2 lignes :
```
set global myLat to get Latitude
set global myLon to get Longitude
```
Ensuite garde :
```
set Marker1.Latitude to get Latitude
set Marker1.Longitude to get Longitude
```
Puis supprime les lignes qui mettaientt directement :
```
set Map1.CenterFromString to ...
et
set Map1.ZoomLevel to 18
```
et remplace-la par :
```
call UpdateMapCenter
```
Puis garde :
```
set LabelPos.Text to join get Latitude "," get Longitude
```
9) Ton bloc LocationSensor1.PositionChanged doit devenir
```
when LocationSensor1.PositionChanged
    Latitude Longitude Altitude speed
do
    set global myLat to get Latitude
    set global myLon to get Longitude

    set Marker1.Latitude to get Latitude
    set Marker1.Longitude to get Longitude

    call UpdateMapCenter

    set LabelPos.Text to join
        "Moi : "
        get Latitude
        ", "
        get Longitude
```
10) Créer le bloc pour demander la position du robot

Ajoute ce bloc :
```
when ClockRobot.Timer
do
    call WebRobot.Get
```
11) Créer le bloc WebRobot.GotText

Ajoute ce bloc :
```
when WebRobot.GotText
    url responseCode responseType responseContent
do
```
12) Dans WebRobot.GotText, décoder le JSON

Dans ce bloc, mets d’abord :
```
set global decodedRobot to call WebRobot.JsonTextDecodeWithDictionaries
    responseContent
```
13) Vérifier que la réponse est bonne

Juste après, ajoute :
```
if get value for key "ok"
   in dictionary get global decodedRobot
   or if not found false
then
```
14) Récupérer l’objet robot

Dans le then, ajoute :
```
set global robotData to get value for key "robot"
    in dictionary get global decodedRobot
    or if not found 0
```
15) Lire la latitude et la longitude du robot

Toujours dans le then, ajoute :
```
set global robotLat to get value for key "x"
    in dictionary get global robotData
    or if not found 0

set global robotLon to get value for key "y"
    in dictionary get global robotData
    or if not found 0
```
16) Déplacer le marqueur robot

Toujours dans le then, ajoute :
```
set MarkerRobot.Latitude to get global robotLat
set MarkerRobot.Longitude to get global robotLon
set MarkerRobot.Visible to true
set global hasRobot to true
```
17) Recentrer la carte pour voir les 2 marqueurs

Toujours dans le then, ajoute :
```
call UpdateMapCenter
```
18) Bloc complet WebRobot.GotText

Au final, ton bloc doit ressembler à ceci :
```
when WebRobot.GotText
    url responseCode responseType responseContent
do
    set global decodedRobot to call WebRobot.JsonTextDecodeWithDictionaries
        responseContent

    if get value for key "ok"
       in dictionary get global decodedRobot
       or if not found false
    then
        set global robotData to get value for key "robot"
            in dictionary get global decodedRobot
            or if not found 0

        set global robotLat to get value for key "x"
            in dictionary get global robotData
            or if not found 0

        set global robotLon to get value for key "y"
            in dictionary get global robotData
            or if not found 0

        set MarkerRobot.Latitude to get global robotLat
        set MarkerRobot.Longitude to get global robotLon
        set MarkerRobot.Visible to true
        set global hasRobot to true

        call UpdateMapCenter
```
19) Ce qu’il faut changer dans ton appli

Avant

Tu recentrais la carte seulement sur le téléphone

Maintenant

Tu centres la carte :
- sur le téléphone si le robot n’est pas encore connu
- au milieu entre téléphone et robot si le robot est connu
C’est ça qui permet de voir les 2 marqueurs

20) Très important

Ne fais plus ça

Dans LocationSensor1.PositionChanged, ne mets plus :
```
set Map1.ZoomLevel to 18
set Map1.CenterFromString to ...
```
sinon la carte reviendra toujours sur toi, et on ne verra pas le robot.

Fais ça à la place

Dans LocationSensor1.PositionChanged, mets juste :
```
call UpdateMapCenter
```
21) Résultat attendu

Quand l’appli tourne :
1. Marker1 affiche ta position
2. ClockRobot appelle l’API toutes les 2 secondes
3. MarkerRobot apparaît quand la position robot arrive
4. la carte se centre entre les 2
5. les 2 marqueurs restent visibles
22) Adresse à mettre

Dans Screen1.Initialize, l’adresse est :
```
https://sti2d.latelier22.fr/fiber/api/robot-last
```
23) Résumé ultra court

Ajouter :
- MarkerRobot
- WebRobot
- ClockRobot
Créer les variables :
- myLat
- myLon
- robotLat
- robotLon
- hasRobot
- decodedRobot
- robotData
Créer la procédure :
- UpdateMapCenter
Ajouter les blocs :
- when ClockRobot.Timer
- when WebRobot.GotText
Modifier :
- when Screen1.Initialize
- when LocationSensor1.PositionChanged
24) Si tu veux que ça marche du premier coup

Fais les étapes dans cet ordre exact :
1. ajouter MarkerRobot
2. ajouter WebRobot
3. ajouter ClockRobot
4. régler ClockRobot
5. créer les variables globales
6. compléter Screen1.Initialize
7. créer la procédure UpdateMapCenter
8. modifier LocationSensor1.PositionChanged
9. créer ClockRobot.Timer
10. créer WebRobot.GotText
SUITE DU TUTO — AJOUTER LE BOUTON APPEL ROBOT
avril 30, 2026
Tuto start and stop PAC
Voici un tuto pas à pas, très concret, pour ajouter START / STOP dans votre appli App Inventor.

On part de ce que vous avez déjà :
- Web1 lit https://proxy-automate.latelier22.fr/api.php
- Clock1 relit régulièrement
- LabelEtatPac affiche l’état
- vous avez déjà global etat_pac
On va juste ajouter :
- un bouton ButtonStart
- un bouton ButtonStop
- un composant Web2 pour envoyer les commandes
Étape 1 — Ajouter les composants dans le Designer

Dans App Inventor, allez dans Designer.

Ajoutez :
1. un bouton nommé ButtonStart
  - texte : START
2. un bouton nommé ButtonStop
  - texte : STOP
3. un composant Web nommé Web2
Vous gardez :
- Web1
- Clock1
- LabelEtatPac
- LabelMot
Étape 2 — Régler l’URL du composant de commande

Toujours dans le Designer, ou dans les blocs ensuite :
- Web1 servira à lire l’état
- Web2 servira à envoyer START / STOP
L’URL de commande est :
```
https://proxy-automate.latelier22.fr/control.php
```
Étape 3 — Dans Screen1.Initialize

Dans les blocs, ouvrez :
```
when Screen1.Initialize
```
Vous avez déjà un bloc qui met l’URL de Web1.

Ajoutez maintenant, juste dessous :
```
set Web2.Url to "https://proxy-automate.latelier22.fr/control.php"
```
Ajoutez aussi :
```
set ButtonStart.Visible to false
set ButtonStop.Visible to false
call Web1.Get
```
Donc au final, dans Screen1.Initialize, vous devez avoir l’idée suivante :
```
when Screen1.Initialize
  set Web1.Url to "https://proxy-automate.latelier22.fr/api.php"
  set Web2.Url to "https://proxy-automate.latelier22.fr/control.php"
  set ButtonStart.Visible to false
  set ButtonStop.Visible to false
  call Web1.Get
```
Étape 4 — Laisser le timer relire l’état

Dans votre bloc :
```
when Clock1.Timer
```
gardez simplement :
```
call Web1.Get
```
Le Clock1 sert juste à relire l’état de la PAC.

Donc :
```
when Clock1.Timer
  call Web1.Get
```
Étape 5 — Dans Web1.GotText, lire etat_pac

Vous avez déjà ce bloc.
Dedans, vous faites déjà :
- décoder le JSON
- stocker global data
- lire debit_eau_l_h
- lire etat_pac
Gardez ça.

La ligne importante est celle-ci :
```
set global etat_pac to get value for key "etat_pac" in dictionary get global data
```
Puis vous faites déjà :
```
set LabelEtatPac.Text to get global etat_pac
```
Ça, il faut le garder.

Étape 6 — Ajouter la logique d’affichage START / STOP

Toujours dans Web1.GotText, juste après :
```
set LabelEtatPac.Text to get global etat_pac
```
ajoutez un bloc if then else.

La règle est :

si global etat_pac = "Marche"

alors :
```
set ButtonStart.Visible to false
set ButtonStop.Visible to true
```
sinon

alors :
```
set ButtonStart.Visible to true
set ButtonStop.Visible to false
```
Donc dans App Inventor, ça donne l’idée suivante :
```
if get global etat_pac = "Marche"
then
   set ButtonStart.Visible to false
   set ButtonStop.Visible to true
else
   set ButtonStart.Visible to true
   set ButtonStop.Visible to false
```
Étape 7 — Créer le bloc du bouton START

Ajoutez un nouveau bloc :
```
when ButtonStart.Click
```
À l’intérieur, mettez :
```
call Web2.PostText "action=start"
```
Donc :
```
when ButtonStart.Click
  call Web2.PostText "action=start"
```
Ce bloc envoie la commande START au proxy.

Étape 8 — Créer le bloc du bouton STOP

Ajoutez un nouveau bloc :
```
when ButtonStop.Click
```
À l’intérieur, mettez :
```
call Web2.PostText "action=stop"
```
Donc :
```
when ButtonStop.Click
  call Web2.PostText "action=stop"
```
Ce bloc envoie la commande STOP au proxy.

Étape 9 — Ajouter le retour après commande

Ajoutez un nouveau bloc :
```
when Web2.GotText
```
À l’intérieur, mettez un test :

si responseCode = 200

alors :
```
call Web1.Get
```
sinon

alors :
```
set LabelMot.Text to "Erreur commande"
```
Donc :
```
when Web2.GotText
  if get responseCode = 200
  then
     call Web1.Get
  else
     set LabelMot.Text to "Erreur commande"
```
Le but est simple :
- on clique sur START ou STOP
- la commande est envoyée
- dès que le serveur répond, on relit l’état réel avec Web1.Get
Étape 10 — Résultat attendu

Si la PAC est arrêtée

api.php renvoie :
```
etat_pac = "Arret"
```
Alors l’appli doit afficher :
- ButtonStart.Visible = true
- ButtonStop.Visible = false
Si la PAC est en marche

api.php renvoie :
```
etat_pac = "Marche"
```
Alors l’appli doit afficher :
- ButtonStart.Visible = false
- ButtonStop.Visible = true
Étape 11 — Ce que l’appli envoie exactement

Quand on clique sur START

elle envoie :
```
action=start
```
à :
```
https://proxy-automate.latelier22.fr/control.php
```
Quand on clique sur STOP

elle envoie :
```
action=stop
```
à :
```
https://proxy-automate.latelier22.fr/control.php
```
Étape 12 — Ce que l’appli reçoit

Quand elle lit l’état avec Web1.Get

elle lit :
```
{
  "ok": true,
  "etat_pac": "Marche"
}
```
ou :
```
{
  "ok": true,
  "etat_pac": "Arret"
}
```
Dans votre appli, vous utilisez seulement :
- etat_pac
Étape 13 — Résumé ultra simple

Au démarrage
- Web1.Get
Si etat_pac = "Marche"
- cacher START
- montrer STOP
Si etat_pac = "Arret"
- montrer START
- cacher STOP
Si on clique START
- envoyer action=start
- relire l’état
Si on clique STOP
- envoyer action=stop
- relire l’état
Étape 14 — Les 4 blocs finaux à avoir

1. Screen1.Initialize
```
set Web1.Url to "https://proxy-automate.latelier22.fr/api.php"
set Web2.Url to "https://proxy-automate.latelier22.fr/control.php"
set ButtonStart.Visible to false
set ButtonStop.Visible to false
call Web1.Get
```
2. Clock1.Timer
```
call Web1.Get
```
3. ButtonStart.Click
```
call Web2.PostText "action=start"
```
4. ButtonStop.Click
```
call Web2.PostText "action=stop"
```
5. Web2.GotText
```
if responseCode = 200
   call Web1.Get
else
   set LabelMot.Text to "Erreur commande"
```
6. Dans Web1.GotText

Après avoir récupéré etat_pac :
```
if get global etat_pac = "Marche"
   set ButtonStart.Visible to false
   set ButtonStop.Visible to true
else
   set ButtonStart.Visible to true
   set ButtonStop.Visible to false
```
Étape 15 — Ce qu’il faut vérifier si ça ne marche pas
1. Web2.Url doit être :
```
https://proxy-automate.latelier22.fr/control.php
```
1. ButtonStart.Click doit envoyer exactement :
```
action=start
```
1. ButtonStop.Click doit envoyer exactement :
```
action=stop
```
1. Web1.GotText doit bien lire :
```
etat_pac
```
avec cette clé exacte.
avril 28, 2026
SNT 2ndeD Groupe 2: Application mobile

Liste des élèves

Tuto débutant MIT App Inventor

avril 27, 2026

Appli cardioMove Appel robot et reset

TUTO PAS À PAS – APPLI CARTE + GPS + APPEL ROBOT + RESET

1) Créer le projet

Ouvre MIT App Inventor.
Clique sur Create Apps.
Clique sur Start new project.
Nom du projet : CardioMoveRobot

2) Dans Designer : ajouter les composants

2.1 Composants visibles

Ajoute ces composants dans Screen1 :

A. Une carte

Dans Maps :

Map
renomme-la : Map1

B. Marqueur téléphone

Dans Maps :

Marker
renomme-le : MarkerMe

C. Marqueur robot

Dans Maps :

Marker
renomme-le : MarkerRobot

D. Titre

Dans User Interface :

Label
renomme-le : LabelTitle

E. Statut

Dans User Interface :

Label
renomme-le : LabelStatus

F. Bouton appel

Dans User Interface :

Button
renomme-le : ButtonAppel

G. Bouton reset

Dans User Interface :

Button
renomme-le : ButtonReset

2.2 Composants non visibles

Ajoute :

Sensors

LocationSensor
renomme : LocationSensor1

Connectivity

Web
renomme : Web1
Web
renomme : WebRobot
Web
renomme : WebReset

Sensors

Clock
renomme : Clock1
Clock
renomme : ClockRobot

User Interface

Notifier
renomme : Notifier1

3) Régler les propriétés dans Designer

3.1 Screen1

Sélectionne Screen1 :

AlignHorizontal = Center
Scrollable = false

3.2 Map1

Sélectionne Map1 :

Width = Fill parent
Height = 300 pixels
ZoomLevel = 15

3.3 MarkerRobot

Sélectionne MarkerRobot :

Visible = false

3.4 LabelTitle

Sélectionne LabelTitle :

Text = URGENCE - Appel CardioMove
Width = Fill parent
TextAlignment = Center
FontSize = 18

3.5 LabelStatus

Sélectionne LabelStatus :

Text = GPS : en attente
Width = Fill parent
TextAlignment = Center

3.6 ButtonAppel

Sélectionne ButtonAppel :

Text = 🚨 APPEL ROBOT
Width = Fill parent
Height = 70 pixels
FontSize = 24
Enabled = false

3.7 ButtonReset

Sélectionne ButtonReset :

Text = RESET ROBOT

3.8 Clock1

Sélectionne Clock1 :

TimerEnabled = true
TimerInterval = 500

3.9 ClockRobot

Sélectionne ClockRobot :

TimerEnabled = true
TimerInterval = 2000

Va dans Blocks.

4) Créer les variables globales

Crée ces 5 variables :

initialize global lat to 0
initialize global lon to 0
initialize global hasFix to false
initialize global decoded to 0
initialize global robotList to 0

5) Initialisation de l’écran

Ajoute ce bloc :

when Screen1.Initialize
do
    set WebRobot.Url to "https://sti2d.latelier22.fr/fiber/api/robot-last"

6) Bloc GPS : récupérer la position du téléphone

Ajoute ce bloc :

when LocationSensor1.LocationChanged
    latitude longitude altitude speed
do
    set global lat to get latitude
    set global lon to get longitude    set MarkerMe.Latitude to get latitude
    set MarkerMe.Longitude to get longitude    set Map1.CenterFromString to join get latitude "," get longitude
    set Map1.ZoomLevel to 18    set global hasFix to true    set LabelStatus.Text to join
        "GPS OK\nlat="
        get latitude
        "\nlon="
        get longitude

7) Activer le bouton seulement si le GPS est prêt

Ajoute ce bloc :

when Clock1.Timer
do
    if get global hasFix = true
    then
        set ButtonAppel.Enabled to true
    else
        set ButtonAppel.Enabled to false

8) Quand on clique sur APPEL ROBOT

Ajoute ce bloc :

when ButtonAppel.Click
do
    if not get global hasFix
    then
        call Notifier1.ShowAlert
            notice "GPS pas prêt"
    else
        call Notifier1.ShowChooseDialog
            message join
                "GPS OK\nlat="
                get global lat
                "\nlon="
                get global lon
            title "CONFIRMATION"
            button1Text "OUI"
            button2Text "NON"
            cancelable true

9) Après la boîte de dialogue : envoyer les coordonnées

Ajoute ce bloc :

when Notifier1.AfterChoosing
    choice
do
    if get choice = "OUI"
    then
        set Web1.Url to "https://sti2d.latelier22.fr/fiber/api/call-robot"        set Web1.RequestHeaders to make a list
            make a list "Content-Type" "application/json"
            make a list "Connection" "Keep-Alive"        call Web1.PostText
            text call Web1.JsonTextEncode
                valueToEncode make a dictionary
                    key "x" value get global lat
                    key "y" value get global lon

10) Lire la réponse après l’appel robot

Ajoute ce bloc :

when Web1.GotText
    url responseCode responseType responseContent
do
    set LabelStatus.Text to join
        "Réponse serveur : code="
        get responseCode
        "\ncontenu="
        get responseContent

11) Lire automatiquement la position du robot

Ajoute ce bloc :

when ClockRobot.Timer
do
    call WebRobot.Get

12) Décoder le JSON du robot et placer le marqueur

Ajoute ce bloc :

when WebRobot.GotText
    url responseCode responseType responseContent
do
    set global decoded to call WebRobot.JsonTextDecodeWithDictionaries
        jsonText get responseContent    if get value for key "ok"
        in dictionary get global decoded
        or if not found false
    then
        set global robotList to get value for key "robot"
            in dictionary get global decoded
            or if not found create empty dictionary        set MarkerRobot.Visible to true        set MarkerRobot.Latitude to get value for key "x"
            in dictionary get global robotList
            or if not found 0        set MarkerRobot.Longitude to get value for key "y"
            in dictionary get global robotList
            or if not found 0
    else
        set LabelStatus.Text to "Robot : pas de position"

13) Bouton RESET ROBOT

Ajoute ce bloc :

when ButtonReset.Click
do
    set WebReset.Url to "https://sti2d.latelier22.fr/fiber/api/reset"
    call WebReset.PostText
        text ""

14) Réponse après RESET

Ajoute ce bloc :

when WebReset.GotText
    url responseCode responseType responseContent
do
    set LabelStatus.Text to join
        "RESET HTTP "
        get responseCode
        " : "
        get responseContent

15) Résultat attendu

Quand tu lances l’appli :

la carte s’affiche
le téléphone récupère son GPS
MarkerMe se place sur la carte
le bouton APPEL ROBOT s’active
si tu cliques dessus, une confirmation s’ouvre
si tu choisis OUI, l’appli envoie :

{"x": latitude, "y": longitude}

toutes les 2 secondes, l’appli lit /robot-last
MarkerRobot se met à la position du robot
le bouton RESET ROBOT envoie un POST vers /reset

16) Les 3 URL à recopier exactement

Appel robot

https://sti2d.latelier22.fr/fiber/api/call-robot

Position robot

https://sti2d.latelier22.fr/fiber/api/robot-last

Reset robot

https://sti2d.latelier22.fr/fiber/api/reset

17) Si ça ne marche pas

Le bouton APPEL ROBOT reste grisé

Vérifie que ce bloc existe bien :

when LocationSensor1.LocationChanged
    ...
    set global hasFix to true

Le robot n’apparaît pas

Vérifie :

WebRobot.Url
ClockRobot.TimerEnabled = true
MarkerRobot.Visible passe à true
les clés "x" et "y" sont bien lues

Erreur d’envoi JSON

Dans Web1.PostText, il faut bien utiliser :

call Web1.JsonTextEncode

et pas envoyer le dictionnaire brut.

18) Ordre exact des blocs à faire

Fais-les dans cet ordre :

variables globales
Screen1.Initialize
LocationSensor1.LocationChanged
Clock1.Timer
ButtonAppel.Click
Notifier1.AfterChoosing
Web1.GotText
ClockRobot.Timer
WebRobot.GotText
ButtonReset.Click
WebReset.GotText

19) Noms exacts des composants

Recopie bien ces noms :

Map1
MarkerMe
MarkerRobot
LabelTitle
LabelStatus
ButtonAppel
ButtonReset
LocationSensor1
Web1
WebRobot
WebReset
Clock1
ClockRobot
Notifier1

20) Le plus important

Les blocs sont en anglais, donc tu dois retrouver exactement :

when LocationSensor1.LocationChanged
when Clock1.Timer
when ButtonAppel.Click
when Notifier1.AfterChoosing
when Web1.GotText
when ClockRobot.Timer
when WebRobot.GotText
when ButtonReset.Click
when WebReset.GotText

avril 9, 2026

Tuto débutant MIT App Inventor
Afficher sa position GPS sur une carte

Objectif

Créer une application qui permet de :
- voir une carte,
- récupérer la position du téléphone,
- afficher la latitude et la longitude,
- placer un marqueur sur la carte,
- afficher un texte JSON quand on appuie sur un bouton.
Exemple de JSON attendu :
```
{"lat":48.1762,"lon":-2.7520}
```
1. Consigne importante avant de commencer

Pour les essais en classe :
- éviter les binômes avec 2 iPhone,
- prendre de préférence au moins un téléphone Android par binôme.
Dans cette activité, on considère que les essais avec iPhone peuvent poser problème.
Donc, si possible :
- 1 Android + 1 autre téléphone, ou
- 1 Android seul.
Si le test par QR code ne fonctionne pas sur Android, on pourra installer l’APK.

2. Ce qu’il faut créer dans le Designer

Dans MIT App Inventor, créer un projet.

https://appinventor.mit.edu

vous pouvez créer un compte avec google (gmail)

Sur Screen1, ajouter les composants suivants.

Composants visibles
- Map → nom : Map1
- Marker → nom : Marker1
- Label → nom : LabelPos
- Button → nom : BtnSend
- TextBox → nom : TxtJson
Composant non visible
- LocationSensor → nom : LocationSensor1
3. Réglages simples dans le Designer

Map1
- largeur : Fill parent
- hauteur : environ 40 % ou 50 % de l’écran
LabelPos

Mettre par exemple :
- texte : Position : en attente du GPS
BtnSend

Mettre :
- texte : Envoyer ma géoloc
TxtJson

Mettre :
- texte vide
- largeur : Fill parent
- cocher MultiLine si possible
4. Principe de l’application

L’application fonctionnera ainsi :

Au démarrage
- on affiche une carte centrée sur une position de départ,
- on indique qu’on attend le GPS.
Quand le GPS trouve la position
- le marqueur se place sur la carte,
- la carte se recentre,
- les coordonnées s’affichent.
Quand on clique sur le bouton
- on affiche un JSON dans la zone de texte.
5. Les blocs à faire

Bloc 1 : au démarrage de l’écran

Créer le bloc :

quand Screen1.Initialize

À l’intérieur, mettre :
- mettre Map1.ZoomLevel à 16
- mettre Map1.CenterFromString à "48.1762740,-2.7520210"
- mettre LabelPos.Text à "Position : en attente du GPS"
À quoi ça sert ?

Ce bloc prépare l’écran :
- la carte s’ouvre,
- elle est centrée sur une position de départ,
- le message d’attente s’affiche.
Bloc 2 : quand la position change

Créer le bloc :

quand LocationSensor1.PositionChanged

avec les paramètres :
- Latitude
- Longitude
- Altitude
- vitesse
À l’intérieur, mettre :
- mettre Marker1.Latitude à obtenir Latitude
- mettre Marker1.Longitude à obtenir Longitude
- mettre Map1.CenterFromString à join (obtenir Latitude) (",") (obtenir Longitude)
- mettre Map1.ZoomLevel à 18
- mettre LabelPos.Text à join ("Latitude : ") (obtenir Latitude) (" | Longitude : ") (obtenir Longitude)
À quoi ça sert ?

Ce bloc s’exécute dès que le téléphone connaît la position.

Il permet de :
- déplacer le marqueur,
- recentrer la carte,
- zoomer,
- afficher les coordonnées.
Bloc 3 : quand on clique sur le bouton

Créer le bloc :

quand BtnSend.Click

À l’intérieur, mettre :
- mettre TxtJson.Text à join
  - {"lat":
  - LocationSensor1.Latitude
  - ,"lon":
  - LocationSensor1.Longitude
  - }
Très important

Ici, ne pas mettre de \.

Il faut obtenir :
```
{"lat":48.1762,"lon":-2.7520}
```
Il ne faut pas obtenir :
```
{\"lat\":48.1762,\"lon\":-2.7520}
```
Les \ ne servent pas ici.
Ils rendent juste l’affichage plus mauvais.

6. Résultat attendu

Quand l’application fonctionne :
- la carte s’affiche,
- le GPS trouve la position,
- le marqueur se déplace,
- le texte des coordonnées change,
- le bouton affiche le JSON dans TxtJson.
7. Test de l’application

Méthode 1 : test avec QR code

Sur le téléphone :
- ouvrir MIT AI2 Companion,
- scanner le QR code affiché par App Inventor.
Méthode 2 : si le QR code ne marche pas

Sur Android :
- installer l’APK de l’application,
- puis tester directement sur le téléphone.
8. Que faire si ça ne marche pas ?

La carte s’affiche mais pas la position

Vérifier :
- que le GPS du téléphone est activé,
- que l’autorisation de localisation est acceptée,
- qu’on est dans un endroit où le téléphone capte bien.
Les coordonnées ne changent pas

Vérifier le bloc :
- quand LocationSensor1.PositionChanged
Le JSON affiche des \

Cela veut dire qu’ils ont été écrits dans le texte.
Il faut les supprimer.

Rien ne se passe avec le bouton

Vérifier le bloc :
- quand BtnSend.Click
9. Version très simple à donner aux élèves

Travail demandé

Créer une application qui :
1. affiche une carte,
2. récupère la position GPS,
3. affiche latitude et longitude,
4. place un marqueur,
5. affiche un JSON quand on appuie sur le bouton.
JSON attendu
```
{"lat":valeur,"lon":valeur}
```
SUITE DU TUTO — AJOUTER LE ROBOT ET VOIR LES 2 MARQUEURS
avril 9, 2026
NEW : Appli PAC 2 écrans
. Objectif

Créer une application MIT App Inventor qui :
1. lit les données depuis :
```
https://proxy-automate.latelier22.fr/api.php
```
1. affiche :
- temperatures -> entree_evaporateur
- temperatures -> sortie_evaporateur
1. affiche le schéma de fonctionnement
2. permet d’ouvrir un deuxième écran pour voir le JSON
2. Ce que l’API renvoie

L’API renvoie un JSON de ce type :
```
{
  "ok": true,
  "src": "https://automate.latelier22.fr/",
  "ts": "2026-03-03T13:48:56+00:00",
  "temperatures": {
    "entree_evaporateur": 19.3,
    "sortie_evaporateur": 19.8
  },
  "debit_eau_l_h": 56.88208
}
```
Nous allons lire seulement :
- temperatures -> entree_evaporateur
- temperatures -> sortie_evaporateur
3. Organisation générale du projet

Tu vas créer :
- Screen1 : écran principal
- ScreenJson : écran pour voir le JSON
4. DESIGNER — Screen1

Sur Screen1, placer les composants comme dans ta capture.

A. Composants visibles

1) Un VerticalArrangement

Il servira à organiser les éléments verticalement.

2) Une première ligne pour la température d’entrée

Ajouter un HorizontalArrangement contenant :
- Label1
  - texte : Température entrée évaporateur
- LabelTempEvapIn
  - texte : T °C
3) Une image du schéma

Ajouter un composant Image
- nom : ImageSchema
- importer l’image dans Media
- choisir cette image comme image du composant
4) Une deuxième ligne pour la température de sortie

Ajouter un autre HorizontalArrangement contenant :
- Label2
  - texte : Température sortie évaporateur
- LabelTempEvapOut
  - texte : T °C
5) Une zone de texte

Ajouter un TextBox
- nom : TextJson
- texte initial : Code réponse
- MultiLine = true
Cette zone servira ici à afficher au moins une information de debug.

6) Un bouton

Ajouter un Button
- nom : Button1
- texte : VOIR JSON
B. Composants non visibles

Ajouter en bas :

1) Web
- nom : Web1
2) Clock
- nom : Clock1
Propriétés :
- TimerEnabled = true
- TimerInterval = 5000
Cela permettra de relire les données toutes les 5 secondes.

5. DESIGNER — ScreenJson

Créer un deuxième écran :
- cliquer sur Add Screen
- nom : ScreenJson
Sur cet écran, ajouter :

A. Une zone de texte
- composant : TextBox
- nom : TextBox1
- MultiLine = true
- Width = Fill parent
- Height = Fill parent ou assez grande
B. Un bouton retour
- composant : Button1
- texte : Retour
6. BLOCKS — Variables globales sur Screen1

Dans Screen1, créer les variables suivantes :
```
initialize global temperaturesDict to ""
initialize global tempsPair to create empty list
initialize global data to ""
initialize global tempEvapIn to ""
```
Même si certaines ne servent plus vraiment, tu peux les laisser comme dans ton montage.

7. BLOCKS — Screen1.Initialize

Dans Screen1, créer ce bloc :
```
when Screen1.Initialize
```
À l’intérieur, mettre :
1. set Web1.Url to
```
https://proxy-automate.latelier22.fr/api.php
```
1. call Web1.Get
Ainsi, l’application lit les données dès le démarrage.

8. BLOCKS — Clock1.Timer

Créer :
```
when Clock1.Timer
```
À l’intérieur :
```
call Web1.Get
```
Ainsi, les données sont rafraîchies toutes les 5 secondes.

9. BLOCKS — lecture des données dans Web1.GotText

Créer :
```
when Web1.GotText
```
Ce bloc fournit :
- url
- responseCode
- responseType
- responseContent
Étape 1 : vérifier que la réponse est bonne

Ajouter un if then else avec :
```
if get responseCode = 200
```
⚠️ 200 doit être un nombre bleu.

Étape 2 : dans le THEN, décoder le JSON

Ajouter :
```
set global data to
call Web1.JsonTextDecodeWithDictionaries
    get responseContent
```
Cela transforme le texte JSON en dictionnaire exploitable.

Étape 3 : afficher une info dans TextJson

Dans ton exemple, tu affiches :
```
set TextJson.Text to get responseCode
```
Tu peux garder exactement cela si tu veux reproduire ta capture.

Donc ajouter :
```
set TextJson.Text to get responseCode
```
Étape 4 : afficher la température entrée évaporateur

Ajouter :
```
set LabelTempEvapIn.Text to
join
   get value at key path
      make a list
         "temperatures"
         "entree_evaporateur"
      in dictionary get global data
      or if not found ""
   " °C"
```
Important

Dans make a list, il faut exactement :
1. "temperatures"
2. "entree_evaporateur"
Étape 5 : afficher la température sortie évaporateur

Ajouter :
```
set LabelTempEvapOut.Text to
join
   get value at key path
      make a list
         "temperatures"
         "sortie_evaporateur"
      in dictionary get global data
      or if not found ""
   " °C"
```
Important

Dans make a list, il faut exactement :
1. "temperatures"
2. "sortie_evaporateur"
Étape 6 : dans le ELSE

Si la réponse n’est pas bonne :
```
set TextJson.Text to "Erreur API"
```
10. BLOCKS — bouton VOIR JSON sur Screen1

Créer :
```
when Button1.Click
```
À l’intérieur :
```
open another screen with start value
```
- screenName = "ScreenJson"
- startValue = get global data
Important

Dans ta capture, tu passes get global data.
Si ton App Inventor accepte cela, garde-le ainsi.

Mais si cela pose problème, utilise plutôt :
```
startValue = TextJson.Text
```
ou mieux encore :
```
startValue = get responseContent
```
Mais pour coller à ton montage, on garde ici :
```
get global data
```
11. BLOCKS — ScreenJson.Initialize

Dans ScreenJson, créer :
```
when ScreenJson.Initialize
```
À l’intérieur :
```
set TextBox1.Text to get start value
```
Cela affiche ce qui a été transmis par Screen1.

12. BLOCKS — bouton retour dans ScreenJson

Dans ScreenJson, pour le bouton retour :
```
when Button1.Click
```
À l’intérieur :
```
open another screen
```
avec :
```
Screen1
```
13. Résultat attendu

Sur Screen1

Tu obtiens :
- température entrée évaporateur affichée
- température sortie évaporateur affichée
- image du schéma
- une petite zone texte
- bouton VOIR JSON
Sur ScreenJson

Tu obtiens :
- le contenu transmis par Screen1
- un bouton retour
14. Résumé des blocs principaux

Screen1.Initialize
```
set Web1.Url to "https://proxy-automate.latelier22.fr/api.php"
call Web1.Get
```
Clock1.Timer
```
call Web1.Get
```
Web1.GotText
```
if responseCode = 200 then
    set global data to JsonTextDecodeWithDictionaries(responseContent)
    set TextJson.Text to responseCode
    set LabelTempEvapIn.Text to value at key path ["temperatures","entree_evaporateur"] + " °C"
    set LabelTempEvapOut.Text to value at key path ["temperatures","sortie_evaporateur"] + " °C"
else
    set TextJson.Text to "Erreur API"
```
Button1.Click sur Screen1
```
open another screen with start value
screenName = "ScreenJson"
startValue = get global data
```
ScreenJson.Initialize
```
set TextBox1.Text to get start value
```
Button1.Click sur ScreenJson
```
open another screen "Screen1"
```
15. Erreurs fréquentes

1) Mauvais nom de clé

Il faut écrire exactement :
- "temperatures"
- "entree_evaporateur"
- "sortie_evaporateur"
⚠️ pas temperature sans s.

2) Mauvais type pour 200

Il faut un nombre bleu :
```
200
```
pas un texte rose "200".

3) Oubli de responseContent

Dans :
```
JsonTextDecodeWithDictionaries
```
il faut mettre :
```
get responseContent
```
4) Le JSON ne s’affiche pas bien dans ScreenJson

Si get global data ne passe pas bien entre les écrans, alors envoie plutôt le texte JSON brut.

Dans ce cas, dans Web1.GotText, ajoute :
```
set TextJson.Text to get responseContent
```
et dans le bouton VOIR JSON :
```
startValue = TextJson.Text
```
C’est souvent plus simple pour les élèves.

16. Version conseillée pour les élèves

Pour éviter les problèmes entre écrans, je conseille :

Dans Web1.GotText

mettre :
```
set TextJson.Text to get responseContent
```
au lieu de responseCode

Puis dans le bouton VOIR JSON

mettre :
```
open another screen with start value
screenName = "ScreenJson"
startValue = TextJson.Text
```
Ainsi, l’écran JSON affichera vraiment le JSON complet.

17. Ce que les élèves doivent comprendre

L’application :
1. appelle une API
2. reçoit un JSON
3. le décode
4. lit les bonnes clés
5. affiche les températures
6. peut montrer le JSON sur un autre écran
avril 7, 2026
Appli Géolocalisation -> Robot
MIT App Inventor (débutants), pas à pas, pour :
1. afficher une carte
2. afficher ta position (point + coordonnées)
3. bouton “Envoyer ma géoloc au robot”
  ➡️ pour l’instant, on n’envoie rien : on affiche juste le JSON qui serait envoyé.
1) DESIGNER (à faire tranquillement)

A) Créer le projet
- Create new project → nom : GeoRobot
B) Ajouter les composants visibles
1. Map → nom : Map1
  (Catégorie “Maps”)
2. Label → nom : LabelPos
  - Text : Position : --
  - FontSize : 16
3. Button → nom : BtnSend
  - Text : Envoyer ma géoloc
4. TextBox → nom : TxtJson
  - Text : vide
  - ✅ MultiLine = true
  - ✅ Width = Fill parent
  - ✅ Height = 120 px (ou plus)
  - (Optionnel) Enabled = false (pour juste afficher)
C) Ajouter les composants non visibles
1. LocationSensor → nom : LocationSensor1
  - TimeInterval : 1000 (1 seconde)
  - DistanceInterval : 1 (1 mètre)
2. (Optionnel mais pratique) Notifier → Notifier1
3. (Optionnel pour plus tard) Web → Web1 (pour envoyer au robot plus tard)
D) Ajouter un marqueur (point sur la carte)
- Dans “Maps”, ajoute Marker → nom : Marker1
  - (il peut être “dans” Map1 dans l’arborescence)
2) BLOCKS (la logique)

A) Au démarrage : préparer la carte

when Screen1.Initialize
1. Zoom par défaut
- set Map1.ZoomLevel to 16
1. Centre par défaut
- set Map1.CenterFromString to "48.0000,-2.0000"
  (ou une autre ville si tu veux)
1. Texte
- set LabelPos.Text to "Position : en attente du GPS"
✅ Voilà : la carte s’ouvre déjà sur un endroit, même sans GPS.

B) Quand le GPS donne une position : afficher sur la carte

Bloc à utiliser (il existe chez toi) :

when LocationSensor1.LocationChanged (latitude, longitude, altitude, speed)
(les paramètres peuvent varier, mais tu as au moins latitude/longitude)

À l’intérieur, mets dans cet ordre :
1. Déplacer le point (Marker1)
- set Marker1.Latitude to get latitude
- set Marker1.Longitude to get longitude
1. Centrer la carte sur toi
- set Map1.CenterFromString to join get latitude "," get longitude
⚠️ IMPORTANT : il faut la virgule entre les deux.
1. Zoomer près de toi
- set Map1.ZoomLevel to 18
1. Afficher les coordonnées
- set LabelPos.Text to join "Position : " get latitude " , " get longitude
✅ Résultat : la carte se centre automatiquement sur toi + zoom + point rouge.

C) Bouton “Envoyer ma géoloc” : afficher le JSON (sans envoyer)

Bloc :

when BtnSend.Click
1. (Optionnel mais conseillé) Si GPS pas prêt :
- if LocationSensor1.Latitude = 0
  → call Notifier1.ShowAlert "GPS pas prêt (attends)"
Sinon (dans le else), fabriquer le JSON :
1. Mettre dans TxtJson.Text
- set TxtJson.Text to join
  - "{"
  - "\"lat\":"
  - LocationSensor1.Latitude
  - ","
  - "\"lon\":"
  - LocationSensor1.Longitude
  - "}"
✅ Exemple affiché :
```
{"lat":48.12345,"lon":-2.45678}
```
1. (Optionnel) message
- call Notifier1.ShowAlert "JSON prêt (non envoyé)"
D) (Optionnel) Mise à jour automatique du JSON

Si tu veux que le JSON se mette à jour tout seul à chaque déplacement, tu peux aussi ajouter dans LocationChanged :
- set TxtJson.Text to ... (le même join)
Mais pour les débutants, c’est mieux uniquement au clic.

Résultat final attendu
- Carte centrée et zoomée sur ta position
- Marker1 sur toi
- LabelPos affiche les coordonnées
- Bouton affiche le JSON dans TxtJson
mars 5, 2026
Activité N°3: Puissance solaire reçue

Inclianaison des faisceaux lumineux et surface éclairée

https://www.geogebra.org/classic/YyRwjmx7

Inclinaison des faisceaux lumineux en fonction de la latitude et de la période de l’année

https://www.geogebra.org/classic/PuSKjRbu

mars 4, 2026

Auteur/autrice : admin0

SUITE DU TUTO — AJOUTER LE BOUTON RESET ROBOT

Objectif

1) Dans Designer, ajouter les composants

A. Ajouter le bouton

B. Ajouter un composant Web

2) Créer le bloc du clic sur le bouton

3) Dans BtnReset.Click, mettre l’adresse

4) Envoyer la requête

5) Bloc complet BtnReset.Click

6) Créer le bloc de réponse du serveur

7) Afficher la réponse du serveur

8) Bloc complet WebReset.GotText

9) Résultat attendu

10) Ordre exact des étapes

11) Si ça ne marche pas

12) Résumé très court à ajouter au document

Bloc 8 : ajouter un bouton RESET ROBOT

Composants à ajouter

Fonctionnement

13) Les 3 boutons / actions de l’appli à ce stade

SUITE DU TUTO — AJOUTER LE BOUTON APPEL ROBOT

Objectif

1) Dans Designer, ajouter les composants

A. Ajouter le bouton

B. Ajouter un Notifier

C. Ajouter un Web

2) Vérifier les variables globales

3) Modifier le bloc GPS

Résultat attendu du bloc GPS

4) Créer le bloc du clic sur le bouton

5) Dans BtnAppel.Click, tester si le GPS est prêt

6) Créer le bloc après la boîte de dialogue

7) Dans Notifier1.AfterChoosing, tester si on a cliqué sur OUI

8) Dans le then, mettre l’adresse du serveur

9) Ajouter les headers

10) Envoyer les coordonnées

Méthode simple à faire comme sur ton image

11) Bloc complet Notifier1.AfterChoosing

12) Créer le bloc de réponse du serveur

13) Dans Web1.GotText, afficher la réponse

14) Résultat attendu

15) Ordre exact des blocs à ajouter

16) Si rien ne se passe

Vérifier

17) Si tu veux le texte exact à mettre dans ton document

Bloc 7 : ajouter un bouton d’appel du robot

Composants à ajouter

Fonctionnement

Réponse attendue

SUITE DU TUTO — AJOUTER LE ROBOT ET VOIR LES 2 MARQUEURS

1) Dans Designer, ajouter 2 composants

A. Ajouter le marqueur du robot

B. Ajouter le composant Web

C. Ajouter une horloge

2) Régler les propriétés

MarkerRobot

ClockRobot

3) Créer les variables globales

4) Modifier le bloc Screen1.Initialize

5) Créer une procédure pour centrer la carte entre les 2 marqueurs

6) Dans UpdateMapCenter, mettre les blocs suivants

7) À quoi sert cette procédure

8) Modifier le bloc LocationSensor1.PositionChanged

9) Ton bloc LocationSensor1.PositionChanged doit devenir

10) Créer le bloc pour demander la position du robot

11) Créer le bloc WebRobot.GotText

12) Dans WebRobot.GotText, décoder le JSON

13) Vérifier que la réponse est bonne

14) Récupérer l’objet robot

15) Lire la latitude et la longitude du robot

16) Déplacer le marqueur robot

17) Recentrer la carte pour voir les 2 marqueurs

18) Bloc complet WebRobot.GotText

19) Ce qu’il faut changer dans ton appli

Avant

Maintenant

20) Très important

Ne fais plus ça

Fais ça à la place

3) Dans `BtnReset.Click`, mettre l’adresse

5) Bloc complet `BtnReset.Click`

8) Bloc complet `WebReset.GotText`

5) Dans `BtnAppel.Click`, tester si le GPS est prêt

7) Dans `Notifier1.AfterChoosing`, tester si on a cliqué sur OUI

8) Dans le `then`, mettre l’adresse du serveur

11) Bloc complet `Notifier1.AfterChoosing`

13) Dans `Web1.GotText`, afficher la réponse

`MarkerRobot`

`ClockRobot`

4) Modifier le bloc `Screen1.Initialize`

6) Dans `UpdateMapCenter`, mettre les blocs suivants

8) Modifier le bloc `LocationSensor1.PositionChanged`

9) Ton bloc `LocationSensor1.PositionChanged` doit devenir

11) Créer le bloc `WebRobot.GotText`

12) Dans `WebRobot.GotText`, décoder le JSON

18) Bloc complet `WebRobot.GotText`

Étape 3 — Dans `Screen1.Initialize`

Étape 5 — Dans `Web1.GotText`, lire `etat_pac`

si `global etat_pac = "Marche"`

si `responseCode = 200`

Quand elle lit l’état avec `Web1.Get`

Si `etat_pac = "Marche"`

Si `etat_pac = "Arret"`

1. `Screen1.Initialize`

2. `Clock1.Timer`

3. `ButtonStart.Click`

4. `ButtonStop.Click`

5. `Web2.GotText`

6. Dans `Web1.GotText`