Fulgence Bienvenüe

Blog

  • Appli cardioMove Appel robot et reset

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

    1) Créer le projet

    1. Ouvre MIT App Inventor.
    2. Clique sur Create Apps.
    3. Clique sur Start new project.
    4. 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 :

    1. la carte s’affiche
    2. le téléphone récupère son GPS
    3. MarkerMe se place sur la carte
    4. le bouton APPEL ROBOT s’active
    5. si tu cliques dessus, une confirmation s’ouvre
    6. si tu choisis OUI, l’appli envoie :
    {"x": latitude, "y": longitude}
    1. toutes les 2 secondes, l’appli lit /robot-last
    2. MarkerRobot se met à la position du robot
    3. 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 :

    1. variables globales
    2. Screen1.Initialize
    3. LocationSensor1.LocationChanged
    4. Clock1.Timer
    5. ButtonAppel.Click
    6. Notifier1.AfterChoosing
    7. Web1.GotText
    8. ClockRobot.Timer
    9. WebRobot.GotText
    10. ButtonReset.Click
    11. 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

  • 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.

    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}

  • 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

  • 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

  • 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

  • 2e appli

    TUTO ÉLÈVES — DUPLIQUER LE PROJET ET MODIFIER POUR AFFICHER LE DÉBIT D’EAU

    Objectif

    Repartir d’un projet qui marche déjà, puis changer :

    • l’URL
    • la clé à afficher

    1) Dupliquer le projet

    1. Dans MIT App Inventor : Projects
    2. Cliquer sur My Projects
    3. Trouver votre projet MotAleatoire (ou le nom de votre projet “Mot”)
    4. Cliquer sur More actions (les 3 points / menu)
    5. Choisir Copy project
    6. Nommer la copie : DebitEau

    ✅ Vous avez maintenant le même projet, mais pour le débit.

    2) Modifier l’écran (Designer)

    Dans Designer :

    A) Modifier le bouton

    • Cliquer sur BtnMot
    • Changer son texte en : Lire le débit
    • (Optionnel) Renommer le bouton : BtnDebit
      👉 Si vous renommez, il faudra retrouver les blocs correspondants.

    B) Modifier le label

    • Cliquer sur LabelMot
    • Changer son texte en : --
    • (Optionnel) Renommer : LabelDebit

    👉 Pour aller vite : ne renommez pas les composants, changez juste le texte.

    3) Modifier l’URL de l’API (Blocks)

    Aller dans Blocks.

    Dans :

    when Screen1.Initialize

    Remplacer l’URL :

    ✅ Ancienne :
    https://trouve-mot.fr/api/random

    ✅ Nouvelle :
    https://proxy-automate.latelier22.fr/api.php

    4) Modifier CE QU’ON AFFICHE (Blocks)

    Dans le projet “Mot”, on affichait :

    • clé "name" (dans l’objet)

    Ici, on veut afficher :

    • clé "debit_eau_l_h" (directement dans data)

    Dans when Web1.GotText → dans le then

    Vous gardez la ligne qui décode le JSON :

    ✅ Garder :

    • set global data to JsonTextDecodeWithDictionaries(responseContent)

    Ensuite, vous changez la partie “mot”.

    A) Supprimer les blocs inutiles

    Supprimez :

    • la ligne set global obj to select list item ...
    • la ligne set global mot to get value for key "name" ...
    • la ligne set LabelMot.Text to get global mot

    B) Remplacer par UNE SEULE ligne

    Ajoutez :

    set LabelMot.Text to

    • join
      • get value for key "debit_eau_l_h" in dictionary (get global data) or if not found "--"
      • " L/h"

    ✅ Ça affichera par exemple : 56.88208 L/h

    5) Vérification rapide

    Cliquez sur le bouton :

    • si tout va bien : un nombre apparaît + L/h
    • sinon : le label affiche “Erreur API”

    6) (Optionnel) Arrondir à 2 décimales (plus propre)

    Remplacez l’affichage par :

    • join (format as decimal debit 2) " L/h"

    (Je te donne la version exacte en blocs si tu veux l’ajouter.)

    Résumé ultra simple

    1. Copier le projet
    2. Changer l’URL
    3. Supprimer “obj” et “name”
    4. Afficher "debit_eau_l_h" + " L/h"

  • Ma première appli mobile

    TUTO MIT APP INVENTOR — “Mot au hasard”

    Objectif

    Quand on clique sur Nouveau mot, l’appli appelle l’API :

    https://trouve-mot.fr/api/random

    et affiche le champ name (ex : “flèche”) dans un Label.

    1) DESIGNER (écran de gauche)

    A. Créer les composants

    Glisser-déposer sur l’écran :

    1. Button
      • Rename : BtnMot
      • Text : Nouveau mot
    2. Label
      • Rename : LabelMot
      • Text : Appuie sur le bouton
      • FontSize : 28 (ou 30)
    3. Web (non visible)
      • Rename : Web1

    2) BLOCKS (écran de droite)

    A. Créer 3 variables globales

    Menu Variables → prendre initialize global name to et renommer :

    1. initialize global mot to ""
    2. initialize global data to create empty list
      • (bloc Lists → create empty list)
    3. initialize global obj to ""

    3) Mettre l’adresse de l’API au démarrage

    Menu Screen1 → bloc :

    when Screen1.Initialize do

    À l’intérieur :

    • set Web1.Url to "https://trouve-mot.fr/api/random"

    ✅ Important : on ne met PAS Web1.Get ici.

    4) Quand on clique sur le bouton : appeler l’API

    Menu BtnMot → bloc :

    when BtnMot.Click do

    À l’intérieur :

    1. set LabelMot.Text to "..." (chargement)
    2. call Web1.Get

    5) Quand l’API répond : extraire le mot

    Menu Web1 → bloc :

    when Web1.GotText (url, responseCode, responseType, responseContent) do

    A. Vérifier que c’est OK

    Mettre :

    if get responseCode = 200 then

    ⚠️ 200 doit être un nombre (bloc bleu), pas “200” en texte.

    B. Dans le THEN, mettre ces 4 lignes

    1) Décoder le JSON

    Menu Web1 :

    • set global data to
      • call Web1.JsonTextDecodeWithDictionaries
        • get responseContent

    ✅ Le JSON reçu est une liste (ça commence par [)

    2) Prendre le 1er élément de la liste

    Menu Lists :

    • set global obj to
      • select list item
        • list = get global data
        • index = 1

    3) Récupérer la clé « name »

    Menu Dictionaries :

    • set global mot to
      • get value for key
        • key = "name"
        • in dictionary = get global obj
        • or if not found = ""

    4) Afficher dans le label

    • set LabelMot.Text to get global mot

    C. Dans le ELSE (si erreur)

    • set LabelMot.Text to "Erreur API"

    ✅ Résultat attendu

    Quand on clique sur Nouveau mot :

    • Le label passe à ... (chargement)
    • Puis affiche un mot (ex : flèche)

  • schéma pompe a chaleur

  • Schéma pompe à chaleur

    Noa Lubin

  • thème_n°3_-_chapitre_1_-_activité_2_-_a_la_surface_du_soleil.

    thème_n°3_-_chapitre_1_-_activité_3_-_puissance_solaireTélécharger

    Doc réponse

    CORRIGÉ

    🌍 Problématique

    Pourquoi observe-t-on des températures différentes entre l’équateur et les pôles ?

    👉 La cause principale est la variation de la puissance solaire reçue en fonction de la latitude.

    1️⃣ Influence de la latitude sur la température

    Les trois villes étudiées sont :

    • Dakar (~14° N)
    • Copenhague (~55° N)
    • Nuuk (~64° N)

    🔎 Températures maximales (lecture graphique)

    • Dakar : ≈ 28 °C
    • Copenhague : ≈ 17 °C
    • Nuuk : ≈ 7 °C

    ✅ Conclusion :
    Plus la latitude augmente (on se rapproche des pôles), plus la température maximale diminue.

    2️⃣ Températures moyennes annuelles

    📍 Dakar

    Moyenne calculée à partir du tableau (page 1) :Tˉ≈25°C\bar{T} \approx 25°CTˉ≈25°C

    📍 Copenhague

    Moyenne graphique ≈ 8 °C

    📍 Nuuk

    Moyenne graphique ≈ –2 °C

    ✅ Conclusion :
    Plus la latitude est élevée, plus la température moyenne annuelle est faible.

    3️⃣ Rôle de l’angle des rayons solaires (Doc.2 et Doc.3)

    À l’équinoxe de printemps :

    • À l’équateur : rayons verticaux
    • Aux latitudes élevées : rayons plus inclinés

    Quand les rayons sont inclinés :

    • L’énergie se répartit sur une surface plus grande
    • Donc la puissance reçue par m² diminue

    4️⃣ Formule de la puissance solaire reçue

    La puissance reçue par m² dépend de l’angle d’incidence :PR=PE×cos⁡(α)P_R = P_E \times \cos(\alpha)PR​=PE​×cos(α)

    avec :

    • PE=1000 W.m−2P_E = 1000 \, W.m^{-2}PE​=1000W.m−2
    • α\alphaα = angle entre le rayon lumineux et la verticale

    5️⃣ Calcul de la puissance reçue à l’équinoxe

    Angles donnés (Doc.3) :

    • Dakar (14°)

    PR=1000×cos⁡(14°)≈970 W.m−2P_R = 1000 \times \cos(14°) \approx 970 \, W.m^{-2}PR​=1000×cos(14°)≈970W.m−2

    • Copenhague (55°)

    PR=1000×cos⁡(55°)≈570 W.m−2P_R = 1000 \times \cos(55°) \approx 570 \, W.m^{-2}PR​=1000×cos(55°)≈570W.m−2

    • Nuuk (64°)

    PR=1000×cos⁡(64°)≈440 W.m−2P_R = 1000 \times \cos(64°) \approx 440 \, W.m^{-2}PR​=1000×cos(64°)≈440W.m−2

    🎯 Conclusion générale

    ✔ Plus la latitude augmente :
    → Les rayons solaires sont plus inclinés
    → L’énergie est répartie sur une surface plus grande
    → La puissance reçue par m² diminue
    → La température moyenne diminue

    🌞 Conclusion scientifique finale

    Les différences de température entre l’équateur et les pôles s’expliquent principalement par la variation de l’angle d’incidence des rayons solaires avec la latitude, ce qui modifie la puissance solaire reçue par mètre carré.