Wikidebrouillard - Contributions de l’utilisateur [fr]

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 174047.png

2023-10-03T15:41:12Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_174047

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_174047

POCL Parapluie - ESP32 Micropython

2023-10-03T15:37:06Z

Andréa Bardinet :

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Tutoriel pour apprendre à créer son POCL parapluie connecté à la météo.
|Disciplines scientifiques=Computing, Physics
|Difficulty=Easy
|Duration=30
|Duration-type=minute(s)
|Tags=esp32, micropython, dblocadata
}}
{{Introduction
|Introduction=Ce tutoriel a pour objectif la création d'un petit parapluie connecté à la météo. Quand il pleut à un endroit donné dans le monde, le parapluie s'ouvre automatiquement et se referme une fois la pluie passée.
}}
{{Materials
|Tuto_Attachments={{Tuto Attachments}}
|ExternalAttachmentsLinks={{ExternalAttachmentsLinks}}
}}
{{Tuto Step
|Step_Title=DBLOCADATA
|Step_Content=Rendez-vous sur dblocadata

⚠️ Ouvre cette page depuis Google Chrome ou Microsoft Edge.

[https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=78 https://dblocadata.debrouillonet.org/BIPES/ui/]

⚠️ Attention, ton ESP32 doit avoir été flashé avec micropython !

Tutoriel pour le faire : [[Installation de micropython]]

Et si tu veux en savoir plus sur la plateforme :

[[Group:Formation DBLOCADATA]]

 
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-38-10.png
}}
{{Tuto Step
|Step_Title=Trouver le programme dans BIPES
|Step_Content=Connecte ton microcontrôleur à DBLOCADATA. Pour cela branche ton ESP32 à ton ordinateur, puis clique sur le bouton ''prise'' en haut à gauche ( comme sur la photo ).

Ensuite sélectionne ta carte dans le menu qui apparait.

Dans le menu à droite, va dans la section '''Exemples''' et sélectionne '''POCL Parapluie'''.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_173135.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_161703.png
}}
{{Tuto Step
|Step_Title=Renseigner le programme
|Step_Content=Il y a 3 variables à éditer dans le programme :

'''api_key''' : Ta clé d'API OpenWeatherMap (tu dois te créer un compte sur openweathermap.org)

'''lat''' : La latitude du lieu à observer.

'''long''' : La longitude du lieu à observer.

Tu peux trouver les coordonnées d'une ville sur ce site : https://www.latlong.net/

Ensuite, dans le menu de droite, va dans '''Actionneurs -> Servo Moteur''' et clique sur '''Install Servo library.'''

 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_162222.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_171512.png
}}
{{Tuto Step
|Step_Title=Connecter l'ESP à internet
|Step_Content=Dans l'onglet '''Fichiers''', actualise les fichiers du microcontrôleur en appuyant sur l'icon ( comme indiqué sur la photo ), puis va dans le fichier '''boot.py'''.

Insère le code suivant en remplaçant les informations par ton réseau wifi.
Sauvegarde le fichier (en haut a gauche '''Save)''' <syntaxhighlight lang="python3">
import network
import time

sta_if = network.WLAN(network.STA_IF); sta_if.active(True)
sta_if.scan()
sta_if.connect('Nom_wifi','MDP_wifi')
print("Waiting for Wifi connection")
while not sta_if.isconnected(): time.sleep(1)
print("Connected")
</syntaxhighlight> 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_164011.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_173601.png
}}
{{Tuto Step
|Step_Title=Brancher le servo-moteur à l'ESP
|Step_Content=Le servo possède 3 fils.

'''Rouge''' : Le + (VIN sur la carte)

'''Marron''' : La masse ( GND sur la carte)

'''Orange''' : Le pin d'information; Il y a plusieurs placements possibles, ici nous prenons le pin 26.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_IMG-0064.jpg
}}
{{Tuto Step
|Step_Title=Exécuter le programme
|Step_Content=Appuyes sur le bouton 'Play' en haut à gauche.

Tu peux regarder le résultat de la requête depuis la console ( dans le menu de navigation )
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163302.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163430.png
|Step_Picture_02=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163635.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 173601.png

2023-10-03T15:36:42Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_173601

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_173601

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 173135.png

2023-10-03T15:33:00Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_173135

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_173135

POCL Parapluie - ESP32 Micropython

2023-10-03T15:22:05Z

Andréa Bardinet :

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Tutoriel pour apprendre à créer son POCL parapluie connecté à la météo.
|Disciplines scientifiques=Computing, Physics
|Difficulty=Easy
|Duration=30
|Duration-type=minute(s)
|Tags=esp32, micropython, dblocadata
}}
{{Introduction
|Introduction=Ce tutoriel a pour objectif la création d'un petit parapluie connecté à la météo. Quand il pleut à un endroit donné dans le monde, le parapluie s'ouvre automatiquement et se referme une fois la pluie passée.
}}
{{Materials
|Tuto_Attachments={{Tuto Attachments}}
|ExternalAttachmentsLinks={{ExternalAttachmentsLinks}}
}}
{{Tuto Step
|Step_Title=DBLOCADATA
|Step_Content=Rendez-vous sur dblocadata !

[https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=78 https://dblocadata.debrouillonet.org/BIPES/ui/]

Pour apprendre à utiliser la plateforme :

[[Group:Formation DBLOCADATA]]

Attention, ton ESP32 doit avoir été flashé avec micropython !

Tutoriel pour le faire : [[Installation de micropython]]

 
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-38-10.png
}}
{{Tuto Step
|Step_Title=Trouver le programme dans BIPES
|Step_Content=Connecte ton microcontrôleur à DBLOCADATA.

Dans le menu à droite, va dans la section '''Exemples''' et sélectionne '''POCL Parapluie'''.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_161703.png
}}
{{Tuto Step
|Step_Title=Renseigner le programme
|Step_Content=Il y a 3 variables à éditer dans le programme :

'''api_key''' : Ta clé d'API OpenWeatherMap (tu dois te créer un compte sur openweathermap.org)

'''lat''' : La latitude du lieu à observer.

'''long''' : La longitude du lieu à observer.

Tu peux trouver les coordonnées d'une ville sur ce site : latlong.net

Ensuite, dans le menu de droite, va dans '''Actionneurs -> Servo Moteur''' et clique sur '''Install Servo library.'''

 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_162222.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_171512.png
}}
{{Tuto Step
|Step_Title=Connecter l'ESP à internet
|Step_Content=Dans l'onglet '''Fichiers''', actualise les fichiers du microcontrôleur puis va dans le fichier '''boot.py'''.

Insère le code suivant en remplaçant les informations par ton réseau wifi.
Sauvegarde le fichier (en haut a gauche '''Save)''' <syntaxhighlight lang="python3">
import network
import time

sta_if = network.WLAN(network.STA_IF); sta_if.active(True)
sta_if.scan()
sta_if.connect('Nom_wifi','MDP_wifi')
print("Waiting for Wifi connection")
while not sta_if.isconnected(): time.sleep(1)
print("Connected")
</syntaxhighlight> 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_164011.png
}}
{{Tuto Step
|Step_Title=Brancher le servo-moteur à l'ESP
|Step_Content=Le servo possède 3 fils.

'''Rouge''' : Le + (VIN sur la carte)

'''Marron''' : La masse ( GND sur la carte)

'''Orange''' : Le pin d'information; Il y a plusieurs placements possibles, ici nous prenons le pin 26.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_IMG-0064.jpg
}}
{{Tuto Step
|Step_Title=Exécuter le programme
|Step_Content=Appuyes sur le bouton 'Play' en haut à gauche.

Tu peux regarder le résultat de la requête depuis la console ( dans le menu de navigation )
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163302.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163430.png
|Step_Picture_02=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163635.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 171512.png

2023-10-03T15:15:31Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_171512

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_171512

POCL Parapluie - ESP32 Micropython

2023-10-03T14:45:14Z

Andréa Bardinet :

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Tutoriel pour apprendre à créer son POCL parapluie connecté à la météo.
|Disciplines scientifiques=Computing, Physics
|Difficulty=Easy
|Duration=30
|Duration-type=minute(s)
|Tags=esp32, micropython, dblocadata
}}
{{Introduction
|Introduction=Ce tutoriel a pour objectif la création d'un petit parapluie connecté à la météo. Quand il pleut à un endroit donné dans le monde, le parapluie s'ouvre automatiquement et se referme une fois la pluie passée.
}}
{{Materials
|Tuto_Attachments={{Tuto Attachments}}
|ExternalAttachmentsLinks={{ExternalAttachmentsLinks}}
}}
{{Tuto Step
|Step_Title=DBLOCADATA
|Step_Content=Rendez-vous sur dblocadata !

[https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=78 https://dblocadata.debrouillonet.org/BIPES/ui/]

Pour apprendre à utiliser la plateforme :

[[Group:Formation DBLOCADATA]]

Attention, ton ESP32 doit avoir été flashé avec micropython !

Tutoriel pour le faire : [[Installation de micropython]]

 
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-38-10.png
}}
{{Tuto Step
|Step_Title=Trouver le programme dans BIPES
|Step_Content=Connecte ton microcontrôleur à DBLOCADATA.

Dans le menu à droite, va dans la section '''Exemples''' et sélectionne '''POCL Parapluie'''.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_161703.png
}}
{{Tuto Step
|Step_Title=Renseigner le programme
|Step_Content=Il y a 3 variables à éditer dans le programme :

'''api_key''' : Ta clé d'API OpenWeatherMap (tu dois te créer un compte sur openweathermap.org)

'''lat''' : La latitude du lieu à observer.

'''long''' : La longitude du lieu à observer.

Tu peux trouver les coordonnées d'une ville sur ce site : latlong.net

 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_162222.png
}}
{{Tuto Step
|Step_Title=Connecter l'ESP à internet
|Step_Content=Dans l'onglet '''Fichiers''', actualise les fichiers du microcontrôleur puis va dans le fichier '''boot.py'''.

Insère le code suivant en remplaçant les informations par ton réseau wifi.
 <syntaxhighlight lang="python3">
import network
import time

sta_if = network.WLAN(network.STA_IF); sta_if.active(True)
sta_if.scan()
sta_if.connect('Nom_wifi','MDP_wifi')
print("Waiting for Wifi connection")
while not sta_if.isconnected(): time.sleep(1)
print("Connected")
</syntaxhighlight> 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_164011.png
}}
{{Tuto Step
|Step_Title=Brancher le servo-moteur à l'ESP
|Step_Content=Le servo possède 3 fils.

'''Rouge''' : Le + (VIN sur la carte)

'''Marron''' : La masse ( GND sur la carte)

'''Orange''' : Le pin d'information; Il y a plusieurs placements possibles, ici nous prenons le pin 26.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_IMG-0064.jpg
}}
{{Tuto Step
|Step_Title=Exécuter le programme
|Step_Content=Appuyes sur le bouton 'Play' en haut à gauche.

Tu peux regarder le résultat de la requête depuis la console ( dans le menu de navigation )
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163302.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163430.png
|Step_Picture_02=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163635.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

POCL Parapluie - ESP32 Micropython

2023-10-03T14:42:55Z

Andréa Bardinet : Page créée avec « {{Tuto Details |Licences=Attribution (CC-BY) |Description=Tutoriel pour apprendre a créer son POCL parapluie connecté à la météo. |Disciplines scientifiques=Computing... »

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Tutoriel pour apprendre a créer son POCL parapluie connecté à la météo.
|Disciplines scientifiques=Computing, Physics
|Difficulty=Easy
|Duration=30
|Duration-type=minute(s)
|Tags=esp32, micropython, dblocadata
}}
{{Introduction
|Introduction=Ce tutoriel a pour objectif la création d'un petit parapluie connecté à la météo. Quand il pleut a un endroit donné dans le monde, le parapluie s'ouvre automatiquement, et se referme un fois la pluie passée.
}}
{{Materials
|Tuto_Attachments={{Tuto Attachments}}
|ExternalAttachmentsLinks={{ExternalAttachmentsLinks}}
}}
{{Tuto Step
|Step_Title=DBLOCADATA
|Step_Content=Rendez-vous sur dblocadata !

[https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=78 https://dblocadata.debrouillonet.org/BIPES/ui/]

Pour apprendre à utiliser la plateforme :

[[Group:Formation DBLOCADATA]]

Attention, ton ESP32 doit avoir été flashé avec micropython !

Tutoriel pour le faire : [[Installation de micropython]]

 
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-38-10.png
}}
{{Tuto Step
|Step_Title=Trouver le programme dans BIPES
|Step_Content=Connecte ton microcontrôleur a DBLOCADATA.

Dans le menu à droite, va dans la section '''Exemples''' et sélectionne '''POCL Parapluie'''.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_161703.png
}}
{{Tuto Step
|Step_Title=Renseigner le programme
|Step_Content=Il y a 3 variables à éditer dans le programme :

'''api_key''' : Ta clé d'API OpenWeatherMap (tu dois te créer un compte sur openweathermap.org)

'''lat''' : La latitude du lieu à observer.

'''long''' : La longitude du lieu à observer.

Tu peux trouver les coordonnées d'une ville sur ce site : latlong.net

 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_162222.png
}}
{{Tuto Step
|Step_Title=Connecter l'ESP à internet
|Step_Content=Dans l'onglet '''Fichiers''', actualise les fichiers du microcontrôleur puis va dans le fichier '''boot.py'''.

Insère le code suivant en remplaçant les informations par ton réseau wifi.
 <syntaxhighlight lang="python3">
import network
import time

sta_if = network.WLAN(network.STA_IF); sta_if.active(True)
sta_if.scan()
sta_if.connect('Nom_wifi','MDP_wifi')
print("Waiting for Wifi connection")
while not sta_if.isconnected(): time.sleep(1)
print("Connected")
</syntaxhighlight> 
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_164011.png
}}
{{Tuto Step
|Step_Title=Brancher le servo-moteur à l'ESP
|Step_Content=Le servo possède 3 fils.

'''Rouge''' : Le + (VIN sur la carte)

'''Marron''' : La masse ( GND sur la carte)

'''Orange''' : Le pin d'information; Il y a plusieurs placement possibles, ici nous prenons le pin 26.
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_IMG-0064.jpg
}}
{{Tuto Step
|Step_Title=Exécuter le programme
|Step_Content=Appuyer sur le bouton 'Play' en haut à gauche.

Vous pouvez regarder le résultat de la requête depuis la console ( dans le menu de navigation )
|Step_Picture_00=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163302.png
|Step_Picture_01=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163430.png
|Step_Picture_02=POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163635.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 164011.png

2023-10-03T14:40:21Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_164011

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_164011

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 163635.png

2023-10-03T14:36:47Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163635

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163635

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 163430.png

2023-10-03T14:34:43Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163430

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163430

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 163302.png

2023-10-03T14:33:58Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163302

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_163302

Fichier:POCL Parapluie - ESP32 Micropython IMG-0064.jpg

2023-10-03T14:30:58Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_IMG-0064

POCL_Parapluie_-_ESP32_Micropython_IMG-0064

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 162222.png

2023-10-03T14:22:31Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_162222

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_162222

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 161703.png

2023-10-03T14:17:18Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_161703

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_161703

Fichier:POCL Parapluie - ESP32 Micropython Capture d cran 2023-10-03 154908.png

2023-10-03T13:50:37Z

Andréa Bardinet : POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_154908

POCL_Parapluie_-_ESP32_Micropython_Capture_d_cran_2023-10-03_154908

Présentation de DBLOCADATA

2023-09-14T15:36:17Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-38-10.png
|Licences=Attribution (CC-BY)
|Description=Découverte de la plateforme DBLOCADATA.
|Disciplines scientifiques=Arduino, Computing, Electricity
|Difficulty=Easy
|Duration=5
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu auras un aperçu des différentes fonctionnalités de la plateforme.

Lien : https://dblocadata.debrouillonet.org
}}
{{Materials}}
{{Tuto Step
|Step_Title=Accueil
|Step_Content=La page d'accueil te donne accès aux différentes sections du site. Tu peux aussi y installer micropython sur ton microcontrôleur (uniquement sur les navigateurs Google Chrome ou Microsoft Edge).
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-39-12.png
}}
{{Tuto Step
|Step_Title=BIPES
|Step_Content=BIPES est un IDE (environnement de développement) disponible sur navigateur permettant de programmer des microcontrôleurs.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_bipes.png
}}
{{Tuto Step
|Step_Title=Connecter son microcontrôleur
|Step_Content=Tu peux connecter ton microcontrôleur à BIPES par USB ou en Wifi. Pour la connexion wifi, il faut configurer ton microcontrôleur, nous verrons cela dans une prochaine séance.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-44-13.png
}}
{{Tuto Step
|Step_Title=Ajouter des blocs
|Step_Content=La sidebar à gauche te permet d'ajouter des blocs de programmation. Les blocs sont triés par catégorie. Des exemples sont aussi fournis.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-44-131.png
}}
{{Tuto Step
|Step_Title=Console
|Step_Content=La console permet d'afficher les informations textuelles que ton microcontrôleur renvoie. Cela permet de voir les erreurs lorsque que tu debug un programme.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-54-55.png
}}
{{Tuto Step
|Step_Title=Fichiers
|Step_Content=Les fichiers sont divisés en 2 sections. Ceux stockés sur le microcontrôleur et ceux présents localement dans votre navigateur.

Les blocs sont transformés en code qui est stocké dans le fichier '''''code.bipes.py'''''
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-12-07.png
}}
{{Tuto Step
|Step_Title=Broches
|Step_Content=Image du microcontrôleur avec les informations nécessaires sur les différents pins.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-13-03.png
}}
{{Tuto Step
|Step_Title=Freeboard
|Step_Content=Freeboard est l'outil de visualisation des données. Il te permet de créer facilement une interface avec des graphiques et du texte.

Tu peux enregistrer ton databoard et le partager.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-16-00.png
}}
{{Tuto Step
|Step_Title=EasyMQTT
|Step_Content=EasyMQTT affiche les différentes sources de données qui sont récupérées sur ton compte.

Ces sources de données sont ensuite accessibles dans freeboard.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-17-42.png
}}
{{Tuto Step
|Step_Title=Partage et communauté
|Step_Content=Tu peux enregistrer tes programmes et les rendre publiques.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-20-41.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Communication entre ESP

2023-05-17T09:13:23Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Communication_entre_ESP_espnow.png
|Licences=Attribution (CC-BY)
|Description=Fait communiquer des ESP32 entre eux.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=10
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Pour faire communiquer les ESP entre eux, nous allons utiliser le protocole ESPNow.

Ce protocole est simple, voici son fonctionnement :

 

*On enregistre un ou plusieurs destinataires. Leurs identifiants sont leur [https://fr.wikipedia.org/wiki/Adresse_MAC adresse mac].
*On envoie un message à un destinataire en particulier, ou a tous ceux enregistrés.

 {{Info|Ce protocole utilise les ondes Wifi, la porté est donc limité.}}{{Info|Les blocs se trouvent dans l'onglet DBLOCADATA --> espnow.}} 
}}
{{Materials}}
{{Tuto Step
|Step_Title=Récupérer l'adresse mac
|Step_Content=Pour récupérer l'adresse mac de ton microcontrôleur exécute cette commande dans la console :
 <syntaxhighlight lang="python3">
import network ; import ubinascii ;
ubinascii.hexlify(network.WLAN().config('mac'),':').decode()
</syntaxhighlight>L'adresse mac sera affichée entre guillemets.

Tu peux aussi utiliser le bloc '''Récupérer l'adresse MAC'''.
|Step_Picture_00=Communication_entre_ESP_Capture_d_cran_du_2023-03-27_15-29-39.png
}}
{{Tuto Step
|Step_Title=Envoyer un message
|Step_Content=Premièrement, tu dois enregistrer un ou plusieurs destinataires.

Utilise le bloc '''Enregistrer un destinataire''' et renseigne l'adresse MAC du microcontrôleur à qui tu veux envoyer le message.

Ensuite, tu peux envoyer un message à tous les destinataires enregistrés avec le bloc '''Envoyer un message à tous les destinataires'''.
|Step_Picture_00=Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-11-51.png
|Step_Picture_01=Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-12-16.png
}}
{{Tuto Step
|Step_Title=Récéption d'un message
|Step_Content=Le bloc '''Quand message reçu''' faire te permet de regarder périodiquement si un message a été reçu et d'exécuter ensuite le code de ton choix.

Ce bloc te fournit 2 variables : '''host''' et '''msg'''.

'''Host''' contient l'adresse mac de l'expéditeur.

'''Msg''' contient le message reçu.

 
|Step_Picture_00=Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-11-10.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Communication entre ESP Capture d cran du 2023-05-17 11-12-16.png

2023-05-17T09:12:44Z

Andréa Bardinet : Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-12-16

Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-12-16

Fichier:Communication entre ESP Capture d cran du 2023-05-17 11-11-51.png

2023-05-17T09:11:58Z

Andréa Bardinet : Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-11-51

Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-11-51

Fichier:Communication entre ESP Capture d cran du 2023-05-17 11-11-10.png

2023-05-17T09:11:19Z

Andréa Bardinet : Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-11-10

Communication_entre_ESP_Capture_d_cran_du_2023-05-17_11-11-10

Envoyer et afficher des données sur DBLOCADATA

2023-04-25T14:50:01Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-03-30_14-25-09.png
|Licences=Attribution (CC-BY)
|Description=Découvre comment envoyer et afficher des données sur la plateforme DBLOCADATA.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=15
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu vas apprendre à envoyer les données que capte ton microcontrôleur.

Pour cela, nous allons utiliser ce programme :

<nowiki>https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=29</nowiki>

Il génère de fausses données que nous allons ensuite envoyer.
}}
{{Materials
|ItemList={{ItemList
|Item=ESP32
}}
}}
{{Tuto Step
|Step_Title=Se connecter à Internet
|Step_Content=Pour envoyer les données, le microcontrôleur doit être connecté à Internet.

Pour cela, utilise le bloc Connexion au réseau wifi. Mets le tout au début de ton programme.

 {{Info|Ici, nous mettons le bloc de connexion dans le même fichier que le reste de programme. Il est aussi possible de mettre ce bloc dans le fichier boot.py pour que le microcontrôleur se connecte au démarrage.}} 
}}
{{Tuto Step
|Step_Title=Envoyer des données
|Step_Content=L'envoi de donné se fait avec le protocole MQTT.

Le protocole est simple et ne nécessite que peu d'informations pour fonctionner :

*Un identifiant de session (déjà renseigné pour toi dans le bloc)
*Un sujet : le nom de la donnée que tu envoies (ex: température dans le salon)
*La donnée à envoyer

Pour commencer, démarre ta session MQTT. Place le bloc EasyMQTT Démarrer après ta connexion à Internet.

Maintenant que la session est démarré, tu peux envoyer des données avec le bloc EasyMQTT publier les données

Place ce bloc dans la boucle pour envoyer des données périodiquement.

 {{Warning|Ne change pas ton identifiant de session, il est directement lié à ton compte DBLOCADATA.}} 
|Step_Picture_00=Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-44-30.png
}}
{{Tuto Step
|Step_Title=Afficher les données
|Step_Content=Dans un premier, il faut vérifier que les données arrivent bien sur notre site. Pour cela, va dans la barre de navigation, section EasyMQTT.

Normalement, tu devrais voir les données sur un graphique. Si ce n'est pas le cas, vérifie que :

 

* Ton programme est bien en cours d'exécution 😜
* Le microcontrôleur est bien connecté à Internet.
* Tu as bien mis des données à envoyer dans ton bloc.

Si tu vois les données, alors tu peux passer à la partie suivante.

 
|Step_Picture_00=Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-46-01.png
}}
{{Tuto Step
|Step_Title=Freeboard
|Step_Content=Freeboard est l'interface qui te permet de visualiser les données avec différents styles de graphique.

Dans la barre de navigation, va dans l'onglet Freeboard.

Tu vas devoir ajouter une source de donnée. Appuie sur le bouton Ajouter en dessous du texte Sources de données.

 

* Le type : BIPES EasyMQTT
* Le nom : à toi de choisir un nom qui correspond
* Le topic : ici, mets le nom que tu as donné à ton sujet dans le bloc de publication.

Tu vas ensuite ajouter un graphique pour voir la donnée.

Clic sur Ajouter un panneau, puis, dans le panneau qui est apparu, appuie sur le bouton ➕.

Choisis le type Gauge (je te laisse découvrir les autres 😉)

Dans value choisis, clic sur ➕Source de donnée et ensuite :

Nom de ton '''''sujet --> result --> 0 --> data'''''

Et voilà, tu sais maintenant comment envoyer des données et les afficher, bravo ! 🏆
|Step_Picture_00=Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-48-19.png
|Step_Picture_01=Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-49-43.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Envoyer et afficher des donn es sur DBLOCADATA Capture d cran du 2023-04-25 16-49-43.png

2023-04-25T14:49:49Z

Andréa Bardinet : Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-49-43

Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-49-43

Fichier:Envoyer et afficher des donn es sur DBLOCADATA Capture d cran du 2023-04-25 16-48-19.png

2023-04-25T14:48:29Z

Andréa Bardinet : Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-48-19

Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-48-19

Fichier:Envoyer et afficher des donn es sur DBLOCADATA Capture d cran du 2023-04-25 16-46-01.png

2023-04-25T14:46:15Z

Andréa Bardinet : Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-46-01

Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-46-01

Fichier:Envoyer et afficher des donn es sur DBLOCADATA Capture d cran du 2023-04-25 16-44-30.png

2023-04-25T14:45:13Z

Andréa Bardinet : Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-44-30

Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-04-25_16-44-30

Communication entre ESP

2023-04-25T08:45:21Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Communication_entre_ESP_espnow.png
|Licences=Attribution (CC-BY)
|Description=Fait communiquer des ESP32 entre eux.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=10
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Pour faire communiquer les ESP entre eux, nous allons utiliser le protocole ESPNow.

Ce protocole est simple, voici son fonctionnement :

 

* On enregistre un ou plusieurs destinataires. Leurs identifiants sont leur [https://fr.wikipedia.org/wiki/Adresse_MAC adresse madresse macac].
* On envoie un message à un destinataire en particulier, ou a tous ceux enregistrés.

 {{Info|Ce protocole utilise les ondes Wifi, la porté est donc limité.}}{{Info|Les blocs se trouvent dans l'onglet DEBLOCADATA --> espnow.}} 
}}
{{Materials}}
{{Tuto Step
|Step_Title=Récupérer l'adresse mac
|Step_Content=Pour récupérer l'adresse mac de ton microcontrôleur exécute cette commande dans la console :
 <syntaxhighlight lang="python3">
import network ; import ubinascii ;
ubinascii.hexlify(network.WLAN().config('mac'),':').decode()
</syntaxhighlight>L'adresse mac sera affichée entre guillemets.

Tu peux aussi utiliser le bloc '''Récupérer l'adresse MAC'''.
|Step_Picture_00=Communication_entre_ESP_Capture_d_cran_du_2023-03-27_15-29-39.png
}}
{{Tuto Step
|Step_Title=Envoyer un message
|Step_Content=Premièrement, tu dois enregistrer un ou plusieurs destinataires.

Utilise le bloc '''Enregistrer un destinataire''' et renseigne l'adresse MAC du microcontrôleur à qui tu veux envoyer le message.

Ensuite, tu peux envoyer un message à tous les destinataires enregistrés avec le bloc '''Envoyer un message à tous les destinataires'''.
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Communication entre ESP espnow.png

2023-04-25T08:41:47Z

Andréa Bardinet : Communication_entre_ESP_espnow

Communication_entre_ESP_espnow

Installation de micropython

2023-04-25T08:36:09Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Installation_de_micropython_Micropython-logo-1287508634.png
|Licences=Attribution (CC-BY)
|Description=Découvre comment installer micropython sur ton microcontrôleur.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=5
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=⚠️ Cela fonctionne uniquement sur Google Chrome et Microsoft Edge.

Rendez-vous en bas de la page d'accueil :

<nowiki>https://dblocadata.debrouillonet.org/~test/#flash</nowiki>
}}
{{Materials}}
{{Tuto Step
|Step_Title=Installation
|Step_Content=Connecte le microcontrôleur à ton ordinateur.

Choisis quelle version de micropython tu veux installer :

Si ton microcontrôleur est un M5Stick choisis sa version correspondante. Tu auras ainsi des bibliothèques supplémentaires pour exploiter au mieux ta carte.
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Installation de micropython Micropython-logo-1287508634.png

2023-04-25T08:35:37Z

Andréa Bardinet : Installation_de_micropython_Micropython-logo-1287508634

Installation_de_micropython_Micropython-logo-1287508634

Utilisation d'un capteur

2023-04-25T08:32:35Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Utilisation_d_un_capteur_dblocadata.jpg
|Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","version":"3.5.0","originX":"left","originY":"top","left":-66,"top":-54,"width":3972,"height":1680,"fill":"rgb(0,0,0)","stroke":null,"strokeWidth":0,"strokeDashArray":null,"strokeLineCap":"butt","strokeDashOffset":0,"strokeLineJoin":"miter","strokeMiterLimit":4,"scaleX":0.18,"scaleY":0.18,"angle":0,"flipX":false,"flipY":false,"opacity":1,"shadow":null,"visible":true,"clipTo":null,"backgroundColor":"","fillRule":"nonzero","paintFirst":"fill","globalCompositeOperation":"source-over","transformMatrix":null,"skewX":0,"skewY":0,"crossOrigin":"","cropX":0,"cropY":0,"src":"https://www.wikidebrouillard.org/images/f/fe/Utilisation_d_un_capteur_dblocadata.jpg","filters":[]}],"height":253.55329949238578,"width":600}
|Licences=Attribution (CC-BY)
|Description=Mesurer des données à l'aide d'un ESP32.
|Disciplines scientifiques=Arduino, Computing, Electricity
|Difficulty=Easy
|Duration=15
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu vas écrire ton 1er programme. L'objectif est de connecter le microcontrôleur à un capteur de température.

Cela permettra de mesurer la température et de l'afficher dans la console.
}}
{{Materials
|ItemList={{ItemList
|Item=ESP32
}}{{ItemList
|Item=Capteur d'humidité-Température DHT22
}}{{ItemList
|Item=Fil électrique
}}
|Prerequisites={{Prerequisites
|Prerequisites=Présentation de DBLOCADATA
}}{{Prerequisites
|Prerequisites=Installation de micropython
}}
}}
{{Tuto Step
|Step_Title=Branchements
|Step_Content=Ton capteur DHT possède 3 entrées/sorties.

*Le courant ( + ou vdd )
*La masse ( - ou gnd )
*Le pin d'information ( out )

Relie le courant et la masse à leurs équivalents sur le microcontrôleur.

Pour le pin d'information tu as plusieurs choix possible, cela dépend de ton microcontrôleur .

Dans ce tutoriel on utilisera le pin 33.

 
|Step_Picture_00=Utilisation_d_un_capteur_Capture_d_cran_du_2023-04-25_10-21-21.png
}}
{{Tuto Step
|Step_Title=Programme
|Step_Content=Dans un premier temps, il nous faut initialiser le capteur. Pour cela direction la sidebar, dans l'onglet '''Capteurs''' '''->''' '''Temperature et Humidité''', ajoute le bloc '''Démarrer le capteur DHT'''.

L'objectif, ensuite, est de mesurer et d'afficher la température toutes les 5 secondes. Pour cela, tu dois effectuer une boucle.

Dans la sidebar, onglet '''Boucles''', ajoute le bloc '''Répéter tant que'''.

Puis dans l'onglet '''Logique''', ajoute le bloc '''vrai''' dans la condition de la boucle.

Tu as désormais ta boucle de prête. Il te reste encore à récupérer les données du capteur, les afficher et ajouter un délai de 5 secondes.

À partir de maintenant, je te laisse chercher les blocs dans la sidebar 😉

Ajoute le bloc '''mettre à jour DHT11/22''' dans la boucle.

Pour afficher les données, utilise le bloc '''afficher'''.

Pour récupérer les données, utilise le bloc '''récupérer DHT11/22 température'''

 {{Warning|Attention ce bloc te renvoie un nombre, cependant, le bloc afficher ne prend que des chaînes de caractères en entrée. Il te faut donc convertir la temperature avant de l'afficher. Le bloc to_str fait exactement ça !}}

Enfin, il faut ajouter un délais dans ta boucle pour ménager le microcontrôleur. Le bloc `delais` permet d'attendre un nombre de seconde défini.

Bravo tu as maintenant ton programme 🏆
}}
{{Tuto Step
|Step_Title=Voir les données
|Step_Content=Si tu as bien suivi les étapes précédentes, ton programme doit maintenant ressembler à l'image ci-contre.

Maintenant tu peux executer le programme et voir le resultat dans la console.
|Step_Picture_00=Utilisation_d_un_capteur_Capture_d_cran_du_2023-03-27_14-38-30.png
}}
{{Notes
|Observations=Dans la console, tu verras s'afficher la temperature que mesure le capteur DHT.
|Avertissement=Vérifies tes branchements.

Vérifies dans ton code que les pins que tu renseignes correspondent à tes branchements.
}}
{{Tuto Status
|Complete=Draft
}}

Utilisation d'un capteur

2023-04-25T08:24:32Z

Andréa Bardinet :

Fichier:Utilisation d un capteur Capture d cran du 2023-04-25 10-21-21.png

2023-04-25T08:22:32Z

Andréa Bardinet : Utilisation_d_un_capteur_Capture_d_cran_du_2023-04-25_10-21-21

Utilisation_d_un_capteur_Capture_d_cran_du_2023-04-25_10-21-21

Fichier:Utilisation d un capteur dblocadata.jpg

2023-04-25T08:07:03Z

Andréa Bardinet : Utilisation_d_un_capteur_dblocadata

Utilisation_d_un_capteur_dblocadata

Envoyer et afficher des données sur DBLOCADATA

2023-03-30T12:26:51Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-03-30_14-25-09.png
|Licences=Attribution (CC-BY)
|Description=Découvre comment envoyer et afficher des données sur la plateforme DBLOCADATA.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=15
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu vas apprendre à envoyer les données que capte ton microcontrôleur.

Pour cela, nous allons utiliser ce programme :

<nowiki>https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=29</nowiki>

Il génère de fausses données que nous allons ensuite envoyer.
}}
{{Materials
|ItemList={{ItemList
|Item=ESP32
}}
}}
{{Tuto Step
|Step_Title=Se connecter à Internet
|Step_Content=Pour envoyer les données, le microcontrôleur doit être connecté à Internet.

Pour cela, utilise le bloc Connexion au réseau wifi. Mets le tout au début de ton programme.

 {{Info|Ici, nous mettons le bloc de connexion dans le même fichier que le reste de programme. Il est aussi possible de mettre ce bloc dans le fichier boot.py pour que le microcontrôleur se connecte au démarrage.}} 
}}
{{Tuto Step
|Step_Title=Envoyer des données
|Step_Content=L'envoi de donné se fait avec le protocole MQTT.

Le protocole est simple et ne nécessite que peu d'informations pour fonctionner :

*Un identifiant de session (déjà renseigné pour toi dans le bloc)
*Un sujet : le nom de la donnée que tu envoies (ex: température dans le salon)
*La donnée à envoyer

Pour commencer, démarre ta session MQTT. Place le bloc EasyMQTT Démarrer après ta connexion à Internet.

Maintenant que la session est démarré, tu peux envoyer des données avec le bloc EasyMQTT publier les données

Place ce bloc dans la boucle pour envoyer des données périodiquement.

 {{Warning|Ne change pas ton identifiant de session, il est directement lié à ton compte DBLOCADATA.}} 
}}
{{Tuto Step
|Step_Title=Afficher les données
|Step_Content=Dans un premier, il faut vérifier que les données arrivent bien sur notre site. Pour cela, va dans la barre de navigation, section EasyMQTT.

Normalement, tu devrais voir les données sur un graphique. Si ce n'est pas le cas, vérifie que :

 

* Ton programme est bien en cours d'exécution 😜
* Le microcontrôleur est bien connecté à Internet.
* Tu as bien mis des données à envoyer dans ton bloc.

Si tu vois les données, alors tu peux passer à la partie suivante.

 
}}
{{Tuto Step
|Step_Title=Freeboard
|Step_Content=Freeboard est l'interface qui te permet de visualiser les données avec différents styles de graphique.

Dans la barre de navigation, va dans l'onglet Freeboard.

Tu vas devoir ajouter une source de donnée. Appuie sur le bouton Ajouter en dessous du texte Sources de données.

 

* Le type : BIPES EasyMQTT
* Le nom : à toi de choisir un nom qui correspond
* Le topic : ici, mets le nom que tu as donné à ton sujet dans le bloc de publication.

Tu vas ensuite ajouter un graphique pour voir la donnée.

Clic sur Ajouter un panneau, puis, dans le panneau qui est apparu, appuie sur le bouton ➕.

Choisis le type Gauge (je te laisse découvrir les autres 😉)

Dans value choisis, clic sur ➕Source de donnée et ensuite :

Nom de ton '''''sujet --> result --> 0 --> data'''''

Et voilà, tu sais maintenant comment envoyer des données et les afficher, bravo ! 🏆
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Envoyer et afficher des donn es sur DBLOCADATA Capture d cran du 2023-03-30 14-25-09.png

2023-03-30T12:26:00Z

Andréa Bardinet : Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-03-30_14-25-09

Envoyer_et_afficher_des_donn_es_sur_DBLOCADATA_Capture_d_cran_du_2023-03-30_14-25-09

Utilisation d'un capteur

2023-03-30T12:15:24Z

Andréa Bardinet :

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Mesurer des données à l'aide d'un ESP32.
|Disciplines scientifiques=Arduino, Computing, Electricity
|Difficulty=Easy
|Duration=15
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu vas écrire ton 1er programme. L'objectif est de connecter le microcontrôleur à un capteur de température.

Cela permettra de mesurer la température et de l'afficher dans la console.
}}
{{Materials
|ItemList={{ItemList
|Item=ESP32
}}{{ItemList
|Item=Capteur d'humidité-Température DHT22
}}{{ItemList
|Item=Fil électrique
}}
|Prerequisites={{Prerequisites
|Prerequisites=Présentation de DBLOCADATA
}}{{Prerequisites
|Prerequisites=Installation de micropython
}}
}}
{{Tuto Step
|Step_Title=Branchements
|Step_Content=Ton capteur DHT possède 3 entrées/sorties.

*Le courant ( + ou vdd )
*La masse ( - ou gnd )
*Le pin d'information ( out )

Relie le courant et la masse à leurs équivalents sur le microcontrôleur.

Pour le pin d'information tu as plusieurs choix possible, cela dépend de ton microcontrôleur .

Dans ce tutoriel on utilisera le pin 33.

 
}}
{{Tuto Step
|Step_Title=Programme
|Step_Content=Dans un premier temps, il nous faut initialiser le capteur. Pour cela direction la sidebar, dans l'onglet '''Capteurs''' '''->''' '''Temperature et Humidité''', ajoute le bloc '''Démarrer le capteur DHT'''.

L'objectif, ensuite, est de mesurer et d'afficher la température toutes les 5 secondes. Pour cela, tu dois effectuer une boucle.

Dans la sidebar, onglet '''Boucles''', ajoute le bloc '''Répéter tant que'''.

Puis dans l'onglet '''Logique''', ajoute le bloc '''vrai''' dans la condition de la boucle.

Tu as désormais ta boucle de prête. Il te reste encore à récupérer les données du capteur, les afficher et ajouter un délai de 5 secondes.

À partir de maintenant, je te laisse chercher les blocs dans la sidebar 😉

Ajoute le bloc '''mettre à jour DHT11/22''' dans la boucle.

Pour afficher les données, utilise le bloc '''afficher'''.

Pour récupérer les données, utilise le bloc '''récupérer DHT11/22 température'''

 {{Warning|Attention ce bloc te renvoie un nombre, cependant, le bloc afficher ne prend que des chaînes de caractères en entrée. Il te faut donc convertir la temperature avant de l'afficher. Le bloc to_str fait exactement ça !}}

Enfin, il faut ajouter un délais dans ta boucle pour ménager le microcontrôleur. Le bloc `delais` permet d'attendre un nombre de seconde défini.

Bravo tu as maintenant ton programme 🏆
}}
{{Tuto Step
|Step_Title=Voir les données
|Step_Content=Si tu as bien suivi les étapes précédentes, ton programme doit maintenant ressembler à l'image ci-contre.

Maintenant tu peux executer le programme et voir le resultat dans la console.
|Step_Picture_00=Utilisation_d_un_capteur_Capture_d_cran_du_2023-03-27_14-38-30.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Installation de micropython

2023-03-30T12:10:59Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Installation_de_micropython_Mlogo_138wh.png
|Licences=Attribution (CC-BY)
|Description=Découvre comment installer micropython sur ton microcontrôleur.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=5
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=⚠️ Cela fonctionne uniquement sur Google Chrome et Microsoft Edge.

Rendez-vous en bas de la page d'accueil :

<nowiki>https://dblocadata.debrouillonet.org/~test/#flash</nowiki>
}}
{{Materials}}
{{Tuto Step
|Step_Title=Installation
|Step_Content=Connecte le microcontrôleur à ton ordinateur.

Choisis quelle version de micropython tu veux installer :

Si ton microcontrôleur est un M5Stick choisis sa version correspondante. Tu auras ainsi des bibliothèques supplémentaires pour exploiter au mieux ta carte.
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Installation de micropython Mlogo 138wh.png

2023-03-30T12:09:47Z

Andréa Bardinet : Installation_de_micropython_Mlogo_138wh

Installation_de_micropython_Mlogo_138wh

Communication entre ESP

2023-03-27T13:30:32Z

Andréa Bardinet : Page créée avec « {{Tuto Details |Licences=Attribution (CC-BY) |Description=Fait communiquer des ESP32 entre eux. |Disciplines scientifiques=Arduino, Computing |Difficulty=Easy |Duration=10... »

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Fait communiquer des ESP32 entre eux.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=10
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Pour faire communiquer les ESP entre eux, nous allons utiliser le protocole ESPNow.

Ce protocole est simple, voici son fonctionnement :

 

* On enregistre un ou plusieurs destinataires. Leurs identifiants sont leur [https://fr.wikipedia.org/wiki/Adresse_MAC adresse madresse macac].
* On envoie un message à un destinataire en particulier, ou a tous ceux enregistrés.

 {{Info|Ce protocole utilise les ondes Wifi, la porté est donc limité.}}{{Info|Les blocs se trouvent dans l'onglet DEBLOCADATA --> espnow.}} 
}}
{{Materials}}
{{Tuto Step
|Step_Title=Récupérer l'adresse mac
|Step_Content=Pour récupérer l'adresse mac de ton microcontrôleur exécute cette commande dans la console :
 <syntaxhighlight lang="python3">
import network ; import ubinascii ;
ubinascii.hexlify(network.WLAN().config('mac'),':').decode()
</syntaxhighlight>L'adresse mac sera affichée entre guillemets.

Tu peux aussi utiliser le bloc '''Récupérer l'adresse MAC'''.
|Step_Picture_00=Communication_entre_ESP_Capture_d_cran_du_2023-03-27_15-29-39.png
}}
{{Tuto Step
|Step_Title=Envoyer un message
|Step_Content=Premièrement, tu dois enregistrer un ou plusieurs destinataires.

Utilise le bloc '''Enregistrer un destinataire''' et renseigne l'adresse MAC du microcontrôleur à qui tu veux envoyer le message.

Ensuite, tu peux envoyer un message à tous les destinataires enregistrés avec le bloc '''Envoyer un message à tous les destinataires'''.
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Communication entre ESP Capture d cran du 2023-03-27 15-29-39.png

2023-03-27T13:29:47Z

Andréa Bardinet : Communication_entre_ESP_Capture_d_cran_du_2023-03-27_15-29-39

Communication_entre_ESP_Capture_d_cran_du_2023-03-27_15-29-39

Afficher des données sur l'écran du M5Stick

2023-03-27T13:19:36Z

Andréa Bardinet : Page créée avec « {{Tuto Details |Licences=Attribution (CC-BY) |Description=Apprend à afficher des données sur l'écran d'un M5Stick |Disciplines scientifiques=Arduino, Computing |Difficu... »

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Apprend à afficher des données sur l'écran d'un M5Stick
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=10
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Le microcontrôleur M5Stick possède un écran. Cela va nous permettre d'afficher les donnés que l'on capte.

Nous allons partir de ce programme :

https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=29

 {{Warning|Il faut que tu aies installé la version micropython pour m5stick présente sur notre site (Sinon il te manquera des bibliothèques pour utiliser l'écran.

Sinon il te manquera des bibliothèques pour utiliser l'écran.}} 
}}
{{Materials}}
{{Tuto Step
|Step_Title=Créer un texte
|Step_Content=Pour créer un chaîne de caractère avec du texte et une variable, utilise le bloc Créer un texte avec.
}}
{{Tuto Step
|Step_Title=Afficher le texte
|Step_Content=Pour afficher ton texte, va dans la section DBLOCADATA -> Écran. Ensuite, choisis une des fonctions affiche texte.
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Envoyer et afficher des données sur DBLOCADATA

2023-03-27T13:06:13Z

Andréa Bardinet : Page créée avec « {{Tuto Details |Licences=Attribution (CC-BY) |Description=Découvre comment envoyer et afficher des données sur la plateforme DBLOCADATA. |Disciplines scientifiques=Ardui... »

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Découvre comment envoyer et afficher des données sur la plateforme DBLOCADATA.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=15
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu vas apprendre à envoyer les données que capte ton microcontrôleur.

Pour cela, nous allons utiliser ce programme :

<nowiki>https://dblocadata.debrouillonet.org/~test/BIPES/ui/?idw=29</nowiki>

Il génère de fausses données que nous allons ensuite envoyer.
}}
{{Materials
|ItemList={{ItemList
|Item=ESP32
}}
}}
{{Tuto Step
|Step_Title=Se connecter à Internet
|Step_Content=Pour envoyer les données, le microcontrôleur doit être connecté à Internet.

Pour cela, utilise le bloc Connexion au réseau wifi. Mets le tout au début de ton programme.

 {{Info|Ici, nous mettons le bloc de connexion dans le même fichier que le reste de programme. Il est aussi possible de mettre ce bloc dans le fichier boot.py pour que le microcontrôleur se connecte au démarrage.}} 
}}
{{Tuto Step
|Step_Title=Envoyer des données
|Step_Content=L'envoi de donné se fait avec le protocole MQTT.

Le protocole est simple et ne nécessite que peu d'informations pour fonctionner :

* Un identifiant de session (déjà renseigné pour toi dans le bloc)
* Un sujet : le nom de la donnée que tu envoies (ex: température dans le salon)
* La donnée à envoyer

Pour commencer, démarre ta session MQTT. Place le bloc EasyMQTT Démarrer après ta connexion à Internet.

Maintenant que la session est démarré, tu peux envoyer des données avec le bloc EasyMQTT publier les données

Place ce bloc dans la boucle pour envoyer des données périodiquement.

 {{Warning|Ne change pas ton identifiant de session, il est directement lié à ton compte DBLOCADATA.}} 
}}
{{Tuto Step
|Step_Title=Afficher les données
|Step_Content=Dans un premier, il faut vérifier que les données arrivent bien sur notre site. Pour cela, va dans la barre de navigation, section EasyMQTT.

Normalement, tu devrais voir les données sur un graphique. Si ce n'est pas le cas, vérifie que :

 

* Ton programme est bien en cours d'exécution 😜
* Le microcontrôleur est bien connecté à Internet.
* Tu as bien mis des données à envoyer dans ton bloc.

Si tu vois les données, alors tu peux passer à la partie suivante.

 
}}
{{Tuto Step
|Step_Title=Freeboard
|Step_Content=Freeboard est l'interface qui te permet de visualiser les données avec différents styles de graphique.

Dans la barre de navigation, va dans l'onglet Freeboard.

Tu vas devoir ajouter une source de donnée. Appuie sur le bouton Ajouter en dessous du texte Sources de données.

 

* Le type : BIPES EasyMQTT
* Le nom : à toi de choisir un nom qui correspond
* Le topic : ici, mets le nom que tu as donné à ton sujet dans le bloc de publication.

Tu vas ensuite ajouter un graphique pour voir la donnée.

Clic sur Ajouter un panneau, puis, dans le panneau qui est apparu, appuie sur le bouton ➕.

Choisis le type Gauge (je te laisse découvrir les autres 😉)

Dans value choisis, clic sur ➕Source de donnée et ensuite :

Nom de ton '''''sujet --> result --> 0 --> data'''''

Et voilà, tu sais maintenant comment envoyer des données et les afficher, bravo ! 🏆
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Utilisation d'un capteur

2023-03-27T12:40:16Z

Andréa Bardinet :

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Mesurer des données à l'aide d'un ESP32.
|Disciplines scientifiques=Arduino, Computing, Electricity
|Difficulty=Easy
|Duration=15
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu vas écrire ton 1er programme. L'objectif est de connecter le microcontrôleur à un capteur de température.

Cela permettra de mesurer la température et de l'afficher dans la console.
}}
{{Materials
|ItemList={{ItemList
|Item=ESP32
}}{{ItemList
|Item=Capteur d'humidité-Température DHT22
}}{{ItemList
|Item=Fil électrique
}}
|Prerequisites={{Prerequisites
|Prerequisites=Présentation de DBLOCADATA
}}{{Prerequisites
|Prerequisites=Installation de micropython
}}
}}
{{Tuto Step
|Step_Title=Branchements
|Step_Content=Ton capteur DHT possède 3 entrées/sorties.

*Le courant ( + ou vdd )
*La masse ( - ou gnd )
*Le pin d'information ( out )

Relie le courant et la masse à leurs équivalents sur le microcontrôleur.

Pour le pin d'information tu as plusieurs choix possible, cela dépend de ton microcontrôleur .

Dans ce tutoriel on utilisera le pin 33.

 
}}
{{Tuto Step
|Step_Title=Programme
|Step_Content=Dans un premier temps, il nous faut initialiser le capteur. Pour cela direction la sidebar, dans l'onglet '''Capteurs''' '''->''' '''Temperature et Humidité''', ajoute le bloc '''Démarrer le capteur DHT'''.

L'objectif, ensuite, est de mesurer et d'afficher la température toutes les 5 secondes. Pour cela, tu dois effectuer une boucle.

Dans la sidebar, onglet '''Boucles''', ajoute le bloc '''Répéter tant que'''.

Puis dans l'onglet '''Logique''', ajoute le bloc '''vrai''' dans la condition de la boucle.

Tu as désormais ta boucle de prête. Il te reste encore à récupérer les données du capteur, les afficher et ajouter un délai de 5 secondes.

À partir de maintenant, je te laisse chercher les blocs dans la sidebar 😉

Ajoute le bloc '''mettre à jour DHT11/22''' dans la boucle.

Pour afficher les données, utilise le bloc '''afficher'''.

Pour récupérer les données, utilise le bloc '''récupérer DHT11/22 température'''

 {{Warning|Attention ce bloc te renvoie un nombre, cependant, le bloc `afficher` ne prend que des chaînes de caractères en entrée. Il te faut donc convertir la temperature avant de l'afficher. Le bloc `to str` fait exactement ça !}}

Enfin, il faut ajouter un délais dans ta boucle pour ménager le microcontrôleur. Le bloc `delais` permet d'attendre un nombre de seconde défini.

Bravo tu as maintenant ton programme 🏆
}}
{{Tuto Step
|Step_Title=Voir les données
|Step_Content=Si tu as bien suivi les étapes précédentes, ton programme doit maintenant ressembler à l'image ci-contre.

Maintenant tu peux executer le programme et voir le resultat dans la console.
|Step_Picture_00=Utilisation_d_un_capteur_Capture_d_cran_du_2023-03-27_14-38-30.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Utilisation d'un capteur

2023-03-27T12:39:01Z

Andréa Bardinet : Page créée avec « {{Tuto Details |Licences=Attribution (CC-BY) |Description=Mesurer des données à l'aide d'un ESP32. |Disciplines scientifiques=Arduino, Computing, Electricity |Difficulty... »

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Mesurer des données à l'aide d'un ESP32.
|Disciplines scientifiques=Arduino, Computing, Electricity
|Difficulty=Easy
|Duration=15
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu vas écrire ton 1er programme. L'objectif est de connecter le microcontrôleur à un capteur de température.

Cela permettra de mesurer la température et de l'afficher dans la console.
}}
{{Materials
|ItemList={{ItemList
|Item=ESP32
}}{{ItemList
|Item=Capteur d'humidité-Température DHT22
}}{{ItemList
|Item=Fil électrique
}}
|Prerequisites={{Prerequisites
|Prerequisites=Présentation de DBLOCADATA
}}{{Prerequisites
|Prerequisites=Installation de micropython
}}
}}
{{Tuto Step
|Step_Title=Branchements
|Step_Content=Ton capteur DHT possède 3 entrées/sorties.

*Le courant ( + ou vdd )
*La masse ( - ou gnd )
*Le pin d'information ( out )

Relie le courant et la masse à leurs équivalents sur le microcontrôleur.

Pour le pin d'information tu as plusieurs choix possible, cela dépend de ton microcontrôleur .

Dans ce tutoriel on utilisera le pin 33.

 
}}
{{Tuto Step
|Step_Title=Programme
|Step_Content=Dans un premier temps, il nous faut initialiser le capteur. Pour cela direction la sidebar, dans l'onglet '''Capteurs''' '''->''' '''Temperature et Humidité''', ajoute le bloc '''Démarrer le capteur DHT'''.

L'objectif, ensuite, est de mesurer et d'afficher la température toutes les 5 secondes. Pour cela, tu dois effectuer une boucle.

Dans la sidebar, onglet '''Boucles''', ajoute le bloc '''Répéter tant que'''.

Puis dans l'onglet '''Logique''', ajoute le bloc '''vrai''' dans la condition de la boucle.

Tu as désormais ta boucle de prête. Il te reste encore à récupérer les données du capteur, les afficher et ajouter un délai de 5 secondes.

À partir de maintenant, je te laisse chercher les blocs dans la sidebar 😉

Ajoute le bloc '''mettre à jour DHT11/22''' dans la boucle.

Pour afficher les données, utilise le bloc '''afficher'''.

Pour récupérer les données, utilise le bloc '''récupérer DHT11/22 température'''

 {{Warning|Attention ce bloc te renvoie un nombre, cependant, le bloc `afficher` ne prend que des chaînes de caractères en entrée. Il te faut donc convertir la temperature avant de l'afficher. Le bloc `to str` fait exactement ça !}}

Enfin, il faut ajouter un délais dans ta boucle pour ménager le microcontrôleur. Le bloc `delais` permet d'attendre un nombre de seconde défini.

Bravo tu as maintenant ton programme 🏆
}}
{{Tuto Step
|Step_Title=Voir les données
|Step_Content=Si tu as bien suivi les étapes précédentes, ton programme doit maintenant ressembler à l'image ci-contre.

Maintenant tu peux executer le programme et voir le resultat dans la console.
|Step_Picture_00=Utilisation_d_un_capteur_Capture_d_cran_du_2023-03-27_14-38-30.png
}}
{{Tuto Step
|Step_Title=Voir les données
|Step_Content=Si tu as bien suivi les étapes précédentes, ton programme doit maintenant ressembler à l'image ci-contre.

Maintenant tu peux executer le programme et voir le resultat dans la console.
|Step_Picture_00=Utilisation_d_un_capteur_Capture_d_cran_du_2023-03-27_14-38-30.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Utilisation d un capteur Capture d cran du 2023-03-27 14-38-30.png

2023-03-27T12:38:40Z

Andréa Bardinet : Utilisation_d_un_capteur_Capture_d_cran_du_2023-03-27_14-38-30

Utilisation_d_un_capteur_Capture_d_cran_du_2023-03-27_14-38-30

Installation de micropython

2023-03-27T08:32:01Z

Andréa Bardinet : Page créée avec « {{Tuto Details |Licences=Attribution (CC-BY) |Description=Découvre comment installer micropython sur ton microcontrôleur. |Disciplines scientifiques=Arduino, Computing |... »

{{Tuto Details
|Licences=Attribution (CC-BY)
|Description=Découvre comment installer micropython sur ton microcontrôleur.
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Easy
|Duration=5
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=⚠️ Cela fonctionne uniquement sur Google Chrome et Microsoft Edge.

Rendez-vous en bas de la page d'accueil :

<nowiki>https://dblocadata.debrouillonet.org/~test/#flash</nowiki>

Connecte le microcontrôleur à votre ordinateur.

Choisis quelle version de micropython tu veux installer :

Si ton microcontrôleur est un M5Stick choisis sa version correspondante. Tu auras ainsi des bibliothèques supplémentaires pour exploiter au mieux ta carte.
}}
{{Materials}}
{{Tuto Step}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Présentation de DBLOCADATA

2023-03-27T08:24:52Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-38-10.png
|Licences=Attribution (CC-BY)
|Description=Découverte de la plateforme DEBLOCADATA.
|Disciplines scientifiques=Arduino, Computing, Electricity
|Difficulty=Easy
|Duration=5
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu auras un aperçu des différentes fonctionnalités de la plateforme.

Lien : https://dblocadata.debrouillonet.org
}}
{{Materials}}
{{Tuto Step
|Step_Title=Accueil
|Step_Content=La page d'accueil te donne accès aux différentes sections du site. Tu peux aussi y installer micropython sur ton microcontrôleur (uniquement sur les navigateurs Google Chrome ou Microsoft Edge).
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-39-12.png
}}
{{Tuto Step
|Step_Title=BIPES
|Step_Content=BIPES est un IDE (environnement de développement) disponible sur navigateur permettant de programmer des microcontrôleurs.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_bipes.png
}}
{{Tuto Step
|Step_Title=Connecter son microcontrôleur
|Step_Content=Tu peux connecter ton microcontrôleur à BIPES par USB ou en Wifi. Pour la connexion wifi, il faut configurer ton microcontrôleur, nous verrons cela dans une prochaine séance.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-44-13.png
}}
{{Tuto Step
|Step_Title=Ajouter des blocs
|Step_Content=La sidebar à gauche te permet d'ajouter des blocs de programmation. Les blocs sont triés par catégorie. Des exemples sont aussi fournis.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-44-131.png
}}
{{Tuto Step
|Step_Title=Console
|Step_Content=La console permet d'afficher les informations textuelles que ton microcontrôleur renvoie. Cela permet de voir les erreurs lorsque que tu debug un programme.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-54-55.png
}}
{{Tuto Step
|Step_Title=Fichiers
|Step_Content=Les fichiers sont divisés en 2 sections. Ceux stockés sur le microcontrôleur et ceux présents localement dans votre navigateur.

Les blocs sont transformés en code qui est stocké dans le fichier '''''code.bipes.py'''''
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-12-07.png
}}
{{Tuto Step
|Step_Title=Broches
|Step_Content=Image du microcontrôleur avec les informations nécessaires sur les différents pins.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-13-03.png
}}
{{Tuto Step
|Step_Title=Freeboard
|Step_Content=Freeboard est l'outil de visualisation des données. Il te permet de créer facilement une interface avec des graphiques et du texte.

Tu peux enregistrer ton databoard et le partager.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-16-00.png
}}
{{Tuto Step
|Step_Title=EasyMQTT
|Step_Content=EasyMQTT affiche les différentes sources de données qui sont récupérées sur ton compte.

Ces sources de données sont ensuite accessibles dans freeboard.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-17-42.png
}}
{{Tuto Step
|Step_Title=Partage et communauté
|Step_Content=Tu peux enregistrer tes programmes et les rendre publiques.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-20-41.png
}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Présentation de DBLOCADATA

2023-03-27T08:24:01Z

Andréa Bardinet :

{{Tuto Details
|Main_Picture=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-38-10.png
|Licences=Attribution (CC-BY)
|Description=Découverte de la plateforme DEBLOCADATA.
|Disciplines scientifiques=Arduino, Computing, Electricity
|Difficulty=Easy
|Duration=5
|Duration-type=minute(s)
}}
{{Introduction
|Introduction=Dans cette séance, tu auras un aperçu des différentes fonctionnalités de la plateforme.

Lien : https://dblocadata.debrouillonet.org
}}
{{Materials}}
{{Tuto Step
|Step_Title=Accueil
|Step_Content=La page d'accueil te donne accès aux différentes sections du site. Tu peux aussi y installer micropython sur ton microcontrôleur (uniquement sur les navigateurs Google Chrome ou Microsoft Edge).
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-39-12.png
}}
{{Tuto Step
|Step_Title=BIPES
|Step_Content=BIPES est un IDE (environnement de développement) disponible sur navigateur permettant de programmer des microcontrôleurs.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_bipes.png
}}
{{Tuto Step
|Step_Title=Connecter son microcontrôleur
|Step_Content=Tu peux connecter ton microcontrôleur à BIPES par USB ou en Wifi. Pour la connexion wifi, il faut configurer ton microcontrôleur, nous verrons cela dans une prochaine séance.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-44-13.png
}}
{{Tuto Step
|Step_Title=Ajouter des blocs
|Step_Content=La sidebar à gauche te permet d'ajouter des blocs de programmation. Les blocs sont triés par catégorie. Des exemples sont aussi fournis.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-44-131.png
}}
{{Tuto Step
|Step_Title=Console
|Step_Content=La console permet d'afficher les informations textuelles que ton microcontrôleur renvoie. Cela permet de voir les erreurs lorsque que tu debug un programme.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-24_16-54-55.png
}}
{{Tuto Step
|Step_Title=Fichiers
|Step_Content=Les fichiers sont divisés en 2 sections. Ceux stockés sur le microcontrôleur et ceux présents localement dans votre navigateur.

Les blocs sont transformés en code qui est stocké dans le fichier '''''code.bipes.py'''''
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-12-07.png
}}
{{Tuto Step
|Step_Title=Broches
|Step_Content=Image du microcontrôleur avec les informations nécessaires sur les différents pins.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-13-03.png
}}
{{Tuto Step
|Step_Title=Freeboard
|Step_Content=Freeboard est l'outil de visualisation des données. Il te permet de créer facilement une interface avec des graphiques et du texte.

Tu peux enregistrer ton databoard et le partager.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-16-00.png
}}
{{Tuto Step
|Step_Title=EasyMQTT
|Step_Content=EasyMQTT affiche les différentes sources de données qui sont récupérées sur ton compte.

Ces sources de données sont ensuite accessibles dans freeboard.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-17-42.png
}}
{{Tuto Step
|Step_Title=Partage et communauté
|Step_Content=Tu peux enregistrer tes programmes et les rendre publiques.
|Step_Picture_00=Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-20-41.png
}}
{{Tuto Step}}
{{Notes}}
{{Tuto Status
|Complete=Draft
}}

Fichier:Pr sentation de DBLOCADATA Capture d cran du 2023-03-27 10-20-41.png

2023-03-27T08:22:20Z

Andréa Bardinet : Andréa Bardinet a téléversé une nouvelle version de Fichier:Pr sentation de DBLOCADATA Capture d cran du 2023-03-27 10-20-41.png

Pr_sentation_de_DBLOCADATA_Capture_d_cran_du_2023-03-27_10-20-41