Passerelle.infini: Totem

Les petites créatures sensorielles

L'historique

L'idée est de réaliser des petites créatures sensorielles en utilisant les sens. En premier abord, la vue et le toucher !

Recherche de surprises, d'inattendu et de fun. L'objet va produire quelque chose de nouveau quand il sera manipulé. Un jeu de manipulation d'objets: seul mais aussi plusieurs objets assemblés.

En bref des créatures vivantes qui nous emportent dans le monde de nos sens.

Les objectifs

Découvrir ou redécouvrir un langage, avec nos sens. Pouvoir manipuler les objets (se donner le droit) Créer tout seul ou à plusieurs. Apporter de la vie, du fun

Le public

Tous le monde est concerné, des enfants aux séniors, chacun peut découvrir de nouvelles expériences en accueillant ses émotions. Les familles ou les structures d'accueil pourront utiliser ces oeuvres.

Les créatures

CUBE

Code CUBE

  1 /////////////////////
  2 //  CUBE   //
  3 /////////////////////
  4 // CUBE est un cube interactif générateur de sons.
  5 // Il a été réalisée dans le cadre du hackathon "Passerelle.infini" les 24 & 25 février 2022
  6 // Le hackathon "Passerelle.infini" est organisé par le Centre d'Art Passerelle, Les petits débrouillards
  7 // Avec la participation de Tyfenn Leluc - designeuse et Thibault Beugin formateur
  8 
  9 // Le programme est inspiré du programme "Basic demo for accelerometer readings" de Adafruit MPU6050
 10 /*
 11 
 12                                      BROCHAGE
 13                                 _________________
 14                                /     D1 mini     \
 15                            -  |[ ]RST        TX[ ]| -
 16                            -  |[ ]A0  -GPIO  RX[ ]| -
 17                               |[ ]D0-16    5-D1[X]| - SCL MPU6050
 18                 RX MP3-TF-16P |[X]D5-14    4-D2[X]| - SDA MPU6050
 19 resistance 1K - TX MP3-TF-16P |[X]D6-12    0-D3[ ]| - Bouton Poussoir
 20                            -  |[ ]D7-13    2-D4[ ]| LED_BUILTIN
 21                            -  |[ ]D8-15     GND[X]| - GND (MPU6050, MP3-TF-16P)
 22                            -  |[ ]3V3 .      5V[X]| - MPU6050, MP3-TF-16P
 23                               |       +---+       |
 24                               |_______|USB|_______|
 25 
 26 
 27                                +-------\_/--------+
 28                            +5V |[X] MP3-TF-16P [ ]|
 29             resistance 1K - TX |[X]            [ ]|
 30                             RX |[X] __________ [ ]|
 31                                |[ ]|          |[ ]|
 32                                |[ ]|   CARTE  |[ ]|
 33                   Haut-Parleur |[X]|    SD    |[ ]|
 34                            GND |[X]|          |[ ]|
 35                   Haut-Parleur |[X]|          |[ ]|
 36                                |___|__________|___|
 37                                
 38 
 39 
 40                                 _________________
 41                                |     MPU6050   ()|
 42                            +5V |[X]VCC           |
 43                            GND |[X]GND         G |
 44                             D1 |[X]SCL   ___   Y |
 45                             D2 |[X]SDA  |   |  | |
 46                                |[ ]XCA  |___|  5 |
 47                                |[ ]XCL .       2 |
 48                                |[ ]ADO      Y  1 |
 49                                |[ ]INT  ->X |    |
 50                                |_______________()|  
 51                                
 52 
 53 Matériel :
 54 - des fils dupont.
 55 - un Wemos D1 mini
 56 - un lecteur MP3 MP3-TF-16P
 57 - une carte SD microSD
 58 - un shield batterie 18650
 59 - une batterie 18650
 60 - un cable USB
 61 - un capteur gyroscopique GY-521 MPU6050
 62 
 63    ___
 64  / ___ \
 65 |_|   | |
 66      /_/ 
 67      _   ___   _ 
 68     |_| |___|_| |_
 69          ___|_   _|
 70         |___| |_|
 71 Les petits Débrouillards - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 72 Antony Le Goïc-Auffret 25 février 2022
 73 */
 74 
 75 
 76 #include <Adafruit_MPU6050.h>
 77 #include <Adafruit_Sensor.h>
 78 #include <Wire.h>
 79 #include "Arduino.h"
 80 #include "SoftwareSerial.h"
 81 #include "DFRobotDFPlayerMini.h"
 82 
 83 #define poussoir D3 // broche du bouton poussoir
 84 
 85 // D6 est le RX du ESP8266, connecte au TX du MP3-TF-16P
 86 // D5 est le TX du ESP8266, connecte au RX du MP3-TF-16P
 87 SoftwareSerial mySoftwareSerial(14, 12); // RX, TX
 88 DFRobotDFPlayerMini myDFPlayer;
 89 
 90 int antirebond = 150 // durée du délai anti-rebond pour le poussoir
 91 
 92 Adafruit_MPU6050 mpu;
 93 
 94 float X;
 95 float Y;
 96 float Z;
 97 
 98 int son = 0;
 99 
100 void initialisation(){
101   Serial.println();
102   Serial.println(F("TCUBE"));
103   Serial.println(F("Initialisation du lecteur mp3 ... (peut prendre 3 a 5 secondes)"));
104 
105   if (!myDFPlayer.begin(mySoftwareSerial)) {  // utilise softwareSerial pour communiquer avec le MP3-TF-16P.
106     Serial.println(F("Incapable de demarrer:"));
107     Serial.println(F("1. Verifiez les connexions!"));
108     Serial.println(F("2. Inserez la carte SD!"));
109     while (true);
110   }
111   Serial.println(F("CUBE est prêt !"));
112 
113   myDFPlayer.setTimeOut(500); // place la communication serie time out 500ms
114   myDFPlayer.volume(26);      // regle le volume (de 0 a 30).
115   myDFPlayer.play(1);         // joue le premier fichier son.
116 }
117 
118 void setup(void) {
119   mySoftwareSerial.begin(9600);
120   Serial.begin(115200);
121   
122   while (!Serial)
123     delay(10); // will pause Zero, Leonardo, etc until serial console opens
124 
125   Serial.println("Démarrage de CUBE");
126 
127   // Try to initialize!
128   if (!mpu.begin()) {
129     Serial.println("Je n'arrive pas trouver le gyroscope MPU6050 ");
130     while (1) {
131       delay(10);
132     }
133   }
134   Serial.println("MPU6050 trouvé !");
135 
136   mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
137   Serial.print("Accelerometer range set to: ");
138   switch (mpu.getAccelerometerRange()) {
139   case MPU6050_RANGE_2_G:
140     Serial.println("+-2G");
141     break;
142   case MPU6050_RANGE_4_G:
143     Serial.println("+-4G");
144     break;
145   case MPU6050_RANGE_8_G:
146     Serial.println("+-8G");
147     break;
148   case MPU6050_RANGE_16_G:
149     Serial.println("+-16G");
150     break;
151   }
152   mpu.setGyroRange(MPU6050_RANGE_500_DEG);
153   Serial.print("Gyro range set to: ");
154   switch (mpu.getGyroRange()) {
155   case MPU6050_RANGE_250_DEG:
156     Serial.println("+- 250 deg/s");
157     break;
158   case MPU6050_RANGE_500_DEG:
159     Serial.println("+- 500 deg/s");
160     break;
161   case MPU6050_RANGE_1000_DEG:
162     Serial.println("+- 1000 deg/s");
163     break;
164   case MPU6050_RANGE_2000_DEG:
165     Serial.println("+- 2000 deg/s");
166     break;
167   }
168 
169   mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
170   Serial.print("Filter bandwidth set to: ");
171   switch (mpu.getFilterBandwidth()) {
172   case MPU6050_BAND_260_HZ:
173     Serial.println("260 Hz");
174     break;
175   case MPU6050_BAND_184_HZ:
176     Serial.println("184 Hz");
177     break;
178   case MPU6050_BAND_94_HZ:
179     Serial.println("94 Hz");
180     break;
181   case MPU6050_BAND_44_HZ:
182     Serial.println("44 Hz");
183     break;
184   case MPU6050_BAND_21_HZ:
185     Serial.println("21 Hz");
186     break;
187   case MPU6050_BAND_10_HZ:
188     Serial.println("10 Hz");
189     break;
190   case MPU6050_BAND_5_HZ:
191     Serial.println("5 Hz");
192     break;
193   }
194 
195   Serial.println("");
196   delay(100);
197 
198   initialisation();
199 
200   pinMode (poussoir, INPUT_PULLUP);  // active la resistance de pull-up interne
201 
202 }
203 
204 void loop() {
205 
206   /* récupère les information du capteur gyroscopique */
207   sensors_event_t a, g, temp;
208   mpu.getEvent(&a, &g, &temp);
209 
210   X = a.acceleration.x;
211   Y = a.acceleration.y;
212   Z = a.acceleration.z;
213   
214   /* on écrit les valeurs sur le moniteur série */
215   Serial.print("Acceleration X: ");
216   Serial.print(X);
217   Serial.print(", Y: ");
218   Serial.print(Y);
219   Serial.print(", Z: ");
220   Serial.print(Z);
221   Serial.println(" m/s^2");
222 
223   Serial.println("");
224   delay(500);
225 // déclanchement X
226   if ((abs(X)>8) & (abs(Y)<8) &(abs(Z)<8)) {
227     son = 1;
228     Serial.print("son = ");
229     Serial.println(son);
230     myDFPlayer.play(son);         // joue le fichier son.
231   }
232 // déclanchement Y
233     if ((abs(X)<8) & (abs(Y)>8) &(abs(Z)<8)) {
234     son = 2;
235     Serial.print("son = ");
236     Serial.println(son);
237     myDFPlayer.play(son);         // joue le fichier son.
238   }
239 // déclanchement Z
240     if ((abs(X)<8) & (abs(Y)<8) &(abs(Z)>8)) {
241     son = 3;
242     Serial.print("son = ");
243     Serial.println(son);
244     myDFPlayer.play(son);         // joue le fichier son.
245   }
246 
247     if ( digitalRead(poussoir) == LOW ) { // lorqu'on appuie sur le bouton
248     delay(antirebond);
249     Serial.println("Appuis Bouton");      // info sur le moniteur serie
250     son = 4;
251     Serial.print("son = ");
252     Serial.println(son);
253     myDFPlayer.play(son);                 //joue le son
254   }
255 }

TOUFFU

Code TOUFFU

  1  
  2 ///////////////
  3 //  TOUFFU   //
  4 ///////////////
  5 // TOUFFU est une créature réalisée dans le cadre du hackathon "Passerelle.infini" les 24 & 25 février 2022.
  6 // Le hackathon "Passerelle.infini" est organisé par le Centre d'Art Passerelle, Les petits débrouillards.
  7 // Avec la participation de Tyfenn Leluc - designeuse et Thibault Beugin formateur.
  8 
  9 // Ce programme est inspiré du petit bot, un programme pédagogique 
 10 // des petits débrouillards ?=+ pour gérer le robot "Petit Bot" 
 11 // Voir sur http://wikidebrouillard.org/index.php?title=Petit_Bot_un_robot_controlable_en_Wifi
 12 // Ce programme est inspire de : http://www.esp8266.com/viewtopic.php?f=29&t=6419#sthash.gd1tJhwU.dpuf
 13 // Sous licence CC-By-Sa - Les petits débrouillards.
 14 
 15 ////////////////////////////////////////////////////////////////////////////////
 16 //                           /!\   ATTENTION   /!\                            //
 17 //        Le code n'est pas terminé, il faut ajouter la gestion du HC-SR04    //
 18 //                                                                            //
 19 ////////////////////////////////////////////////////////////////////////////////
 20 /*
 21  *                                      D1 mini
 22                                      BROCHAGE                            
 23                                 _________________                        
 24                                /     D1 mini     \                       
 25                               |[ ]RST        TX[ ]|                   
 26                               |[ ]A0  -GPIO  RX[ ]|                    
 27                 TRIG  HC-SR04 |[X]D0-16    5-D1[X]| SCL - servogauche                  
 28                 ECHO  HC-SR04 |[X]D5-14    4-D2[X]| SDA - servodroit               
 29                               |[ ]D6-12    0-D3[ ]|               
 30                               |[ ]D7-13    2-D4[ ]| LED_BUILTIN          
 31                               |[ ]D8-15     GND[X]|             
 32                               |[ ]3V3 .      5V[X]|          
 33                               |       +---+       |                     
 34                               |_______|USB|_______|   
 35 
 36                             _________________________
 37                            |   ___     (__)    ___   |
 38                            | //   \\ HC-SR04 //   \\ |
 39                            ||(     )|       |(     )||
 40                            | \\___//         \\___// |
 41                            |    VCC TRIG ECHO GND    |
 42                            |------[X][X][X][X]-------|   
 43                                       |  |
 44                                      D0  D5
 45 
 46 Matériel :
 47 - des fils dupont.
 48 - un shield petit bot
 49 - un Wemos D1 mini
 50 - 2 servo à rotation continue
 51 - un capteur de distance HC-SR04
 52 - un shield batterie 18650
 53 - une batterie 18650
 54 - un cable USB
 55 
 56 Schéma de l'Arduino en ASCII-ART CC-By http://busyducks.com/ascii-art-arduinos
 57 Sous licence CC-By-Sa (http://creativecommons.org/licenses/by-nc-sa/3.0/)
 58 */
 59 /*
 60    ___
 61  / ___ \
 62 |_|   | |
 63      /_/ 
 64      _   ___   _ 
 65     |_| |___|_| |_
 66          ___|_   _|
 67         |___| |_|
 68 Les petits Débrouillards - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 69 Antony Le Goïc-Auffret 25 février 2022
 70 */
 71 
 72 // on appelle la bibliothèque qui gère le Wemos D1 mini
 73 #include <ESP8266WiFi.h> 
 74 
 75 // Gestion du Wifi
 76 #include <ESP8266WebServer.h>
 77 #include <DNSServer.h>
 78 #include <ESP8266mDNS.h>
 79 #include <WiFiClient.h> 
 80 
 81 //  Definition du WiFi 
 82 const char *nomDuReseau = "TOUFFU";     // Nom du réseau wifi du petit bot
 83 const char *motDePasse = "";    // Mot de passe du réseau wifi du petit bot
 84 // ATTENTION - le mot de passe doit faire soit 0 caractères soit 8 ou plus sinon
 85 // La configuration de votre réseau wifi ne se fera pas (ni mot de passe, ni nom de réseau !).
 86 //création du monServeur
 87 ESP8266WebServer monServeur(80);               // Création de l'objet monServeur
 88 
 89 //Gestion des servomoteurs
 90 #include <Servo.h>   //appel de la bibliothèque qui gère les servomoteurs
 91 // création des servomoteurs 
 92 Servo servogauche;   // Nom du servo qui gère la première roue
 93 Servo servodroit;    // Seconde roue
 94 
 95 //déclaration des Variables
 96 //int --- en cours 
 97 int val = -1; // Val nous sert à stocker la commande de l'utilisateur (stop, avance, ...).
 98 
 99 void setup(){
100   delay(1000);
101   Serial.begin(9600); // Ouvre une connexion série pour monitorer le fonctionnement du code quand on reste branché a l'ordinateur
102   Serial.println();
103   Serial.println();  
104   configDuWifi();
105   servodroit.detach();  // Place les servos hors tension
106   servogauche.detach(); 
107   pinMode(LED_BUILTIN, OUTPUT);    //met la led du Wemos en sortie
108   digitalWrite(LED_BUILTIN, LOW);  //met la led du Wemos sur le niveau bas ce qui l'allume.
109 }
110 
111 void loop(){
112     val = -1;
113     monServeur.handleClient();
114 }
115 
116 ///////////////////////GESTION DES INSTRUCTIONS///////////////////////////
117 void GestionDesClics() {
118   monServeur.on("/avance", HTTP_GET, []() {
119   val = 1;
120   Serial.println("avance");    
121   redactionPageWeb();
122   });
123 
124   monServeur.on("/recule", HTTP_GET, []() {
125   val = 2;
126   Serial.println("recule");
127   redactionPageWeb();
128   });
129 
130   monServeur.on("/droite", HTTP_GET, []() {
131   val = 4;
132   Serial.println("droite");
133   redactionPageWeb();
134   });
135   
136   monServeur.on("/gauche", HTTP_GET, []() {
137   val = 3;
138   Serial.println("gauche");
139   redactionPageWeb();
140   });
141 
142   monServeur.on("/stop", HTTP_GET, []() {
143   val = 0;
144   Serial.println("stop");
145   redactionPageWeb();
146   });
147   
148   monServeur.on("/", HTTP_GET, []() {
149   val = -1;
150   redactionPageWeb();
151   });
152 
153 }
154 
155 ///////////////////////////LA PAGE WEB DE CONROLE DU PETIT BOT/////////////////////////////////////////
156 void redactionPageWeb(){
157   // Prépare la page web de réponse (le code HTML sera écrit dans la chaine de caractère "pageWeb").
158   String pageWeb = "<!DOCTYPE HTML>\r\n";
159   pageWeb += "<html>\r\n";
160   pageWeb += "<center>";    //On ouvre la balise qui va centrer les boutons
161   pageWeb += "<h1 style=\"font-size:300%;\"\> Le petit bot ";
162   pageWeb += "<style type=\"text/css\">  body { color: #212121; background-color: #CC0C59 } </style>";
163 
164   // On finalise l'écriture de la page Web et on donne les instructions aux servos
165   pageWeb += instruction(val); // pour cela on appelle la fonction "instruction"
166 
167   // On termine l'écriture de la page Web
168   pageWeb += "</h1>";
169   pageWeb += "<br>"; //aller à la ligne
170   pageWeb += "<br>"; //aller à la ligne
171   pageWeb += "<a href=\"/stop\"\"><button style=\"font-size:200%; width: 18%; background-color:#0CCC16; border-radius: 12px\"\>Stop </button></a>\r\n";      // créer un bouton "Stop", qui envoie sur l'URL /stop
172   pageWeb += "<a href=\"/avance\"\"><button style=\"font-size:200%; width: 18%; background-color:#0CCC16; border-radius: 12px\"\>Avance </button></a>\r\n";  // créer un bouton "Avance"...
173   pageWeb += "<a href=\"/recule\"\"><button style=\"font-size:200%; width: 18%; background-color:#0CCC16; border-radius: 12px\"\>Recule </button></a>\r\n";
174   pageWeb += "<a href=\"/droite\"\"><button style=\"font-size:200%; width: 18%; background-color:#0CCC16; border-radius: 12px\"\>Droite </button></a>\r\n";
175   pageWeb += "<a href=\"/gauche\"\"><button style=\"font-size:200%; width: 18%; background-color:#0CCC16; border-radius: 12px\"\>Gauche </button></a><br />\r\n";
176   pageWeb += "</center>"; // tout est centré sur la page
177   pageWeb += "</html>\n"; //Fin de la page Web
178 
179   // On envoie la page web
180   monServeur.send(200, "text/html", pageWeb);
181   delay(1);
182 }
183 
184 ///////////////////INSTRUCTIONS/////////////////////////////////////////////////////////
185 String instruction(int valeur){ //Cette fonction traite les instructions qui sont reçues
186   int gauche;                           // Variable dont la valeur 180 ou 0 fera tourner le servo gauche dans un sens ou l'autre
187   int droite;                           // Idem pour le servo droit
188   String completePage;                  // Déclaration de la chaine de caractère qui sera renvoyée par cette fonction pour compléter la page web 
189   switch(valeur){                       // En fonction de la variable valeur on va donner un ordre aux servos 
190     case 0 :                            // et un texte à la chaine de caractère "completePage"
191     completePage = " est a l&rsquo;arr&ecirc;t ";
192     droite = 90;
193     gauche = 90;
194     break;
195     case 1 :
196     completePage = " avance ";
197     droite = 180;
198     gauche = 0;
199     break;
200     case 2 :
201     completePage = " recule ";
202     droite = 0;
203     gauche = 180;
204     break;
205     case 3 :
206     completePage = " tourne a gauche ";
207     droite = 180;
208     gauche = 180;
209     break;
210     case 4 :
211     completePage = " tourne a droite ";
212     droite = 0;
213     gauche = 0;
214     break;
215     // que faire du cas ou val = -1 ? marquer ici ce qui doit être fait.
216   }
217   servogauche.attach(5);     // Broche D1
218   servodroit.attach(4);      // Broche D2
219   servogauche.write(gauche); 
220   servodroit.write(droite);
221   return completePage;        // on renvoie la chaine de caractère pour compléter la page web
222 }
223 ////////////////////////CONFIGURATION WIFI///////////////////////////////////////////////
224 void configDuWifi(){  // Fonction de configuratio du Wifi
225   WiFi.mode(WIFI_AP); // le wemos est en mode "Point d'Accès" (il déploie un réseau wifi)
226   WiFi.softAP(nomDuReseau, motDePasse, 2); // on démarre le "Point d'Accès".
227   MDNS.begin(nomDuReseau);                 // gérer les DNS ce qui rendra votre petit bot accessible
228   MDNS.addService("http", "tcp", 80);      // via http://nomDuReseau.local
229   IPAddress monIP = WiFi.softAPIP();       // on récupère l'adresse IP du petit Bot
230   Serial.print("Adresse IP de ce Point d'Accès : ");
231   Serial.println(monIP);                   // on l'écrit sur le moniteur série
232   GestionDesClics();
233   monServeur.begin();                      //Démarrage du monServeur
234   Serial.println("Serveur HTTP démarré");
235   return;                                  // on retourne à l'endroit ou la fonction a été appelée.
236 }

Nénuphar

Le nénuphar est basé sur une forme pre-existante : https://www.instructables.com/Blooming-Marvelous-Flower-Lamp/ A nécessité près de 20h d'impression 3D (beaucoup de pièces) à partir des fichiers 3D trouvés ici : https://www.thingiverse.com/thing:1805365