Il est 8h00, la vie s’éveille
Projet Intersemestre
Nom du projet : Il est 8h00, la vie s’éveille .
Date : Du 22 au 31 janvier
Equipe projet :
- ANIN Arthus : cycle ingénieur 2ème année de à IMT Atlantique
- BRIAND Thibaut : cycle ingénieur 1ère année de à IMT Atlantique
- BADOUAL Oriane : Étudiante en 3eme année de Design à EESAB
- LE GOFF Nina : Étudiante en 3eme année de Design à EESAB
- METONY Wendy : Étudiante en 3eme année de Design à EESAB
Encadrants :
-
- KEROUEDAN Sylvie
- MASSON Julien
1. Contexte
L’IMT Atlantique abrite un espace appelé centre vie, lieu de rassemblement du personnel éducatif (enseignant, élèves) pour des occasions diverses(échange, lieu de travail, de détente). Ce cadre abrite également un petit jardin qui manque de lumière suffisante les soirs compte tenu d’une grande ouverture vitrée qui longe ce lieu.
Dans le cadre des inter semestres, une collaboration entre étudiants de l’IMT Atlantique et de l’Ecole Européenne Supérieure d’Art de Brest (EESAB) nous a amené à réaliser un projet pour redonner un nouveau souffle au jardin du centre vie.
2. Notre solution
Notre projet se base sur la trame des troncs de palmiers. L’objectif est d’interagir avec le public via une application qui contrôle le changement de couleur et d’intensité des lumières. Le public pourra ainsi installer une ambiance à son goût. Ces troncs lumineux sont des indicateurs du changement d’heure par un signal visuel et non sonore.
3. Réalisation
Hardware : le matériel
- Carte arduino Uno
- Un émetteur/récepteur bluetooth : module HC-05 pour la connectivité
- RTC DS1307 pour gérer l’heure
- 5 neopixels
- des fils de connexions
- 5 troncs d’arbres de différentes tailles faits en bois
- Un téléphone muni d’un système android
Software
- Notre application a été réalisée avec le logiciel gratuit en ligne MIT App Inventor 2 compatible avec le système android. Vous avez accès à notre application simple d’utilisation et ergonomique à cet lien : https://drive.google.com/open?id=1pv_5nOzewn7OibB0hHEhaC8WzzuiRAVh
Après ouverture de l’application, l’utilisateur se connecte au bluetooth. Une fois connecté, il choisi un arbre puis le commande (choix de la couleur du neopixel et de la luminosité, l’éteindre si c’est allumé).
- Le traitement de l’information envoyée par l’application est assuré par un programme écrit en C par le logiciel arduino et téléversé dans la carte arduino.
capture de l’application
4. Design
L’inspiration est venue du graphisme relevé sur les troncs de palmier, nous avons voulu retranscrire cela par un sentiments de légèreté et de module.
Nous avons commencé par modéliser des formes sur 3DSMAX ensuite on les a passé sur 123D Make et on les a travaillé de façon à obtenir le nombre de tranches(ou slices) qui nous convenait, tout deux des logiciels de modélisation AUTODESK
Ensuite le graphisme est né des relevés photographique de matières végétales présentes sur le lieu. Nous lui avons donné du caractères et des lignes contemporaines que l’on a gravé et ce travail a été conçu à la pyrogravure, découpe laser du Fab lab, sur des planches de peuplier de 5mm. Puis imbriqué tel un puzzle, un montage très simple et harmonieux laissant passer la lumiere prévu à ce luminaire.
5. Résultats
6. Coût du projet
| Quantité | Prix (unitaire) en euros | |
| Carte arduino Uno | 1 | 2,76 |
| RTC DS1307 | 1 | 10,74 |
| Bluetooth HC-05 | 1 | 2,42 |
| Neopixels 12 leds | 5 | 8,60 |
| Breadboard | 1 | 1,39 |
| Total | 60,31 |
7. Fichiers utiles
Lien vers le programme .aia de l’application android :
https://drive.google.com/open?id=1zpxS6wvlx3yWOZG31MBj7-GqvZHjLfny
Lien vers le programme .apk de l’application android :
https://drive.google.com/open?id=1pv_5nOzewn7OibB0hHEhaC8WzzuiRAVh
Lien vers le programme arduino :
https://drive.google.com/open?id=1Eyngcppy3NboJPgeTZrq_Qa4Czcq1Wym
Bois souple
Voici quelques expérimentations pour rendre le bois souple.
A l’aide de différents motifs découpés à la découpeuse laser, répétés plus ou moins de fois sur une surface, nous pouvons donner une certaine souplesse au bois: c’est ce qu’on appelle la technique du lattice hinge (traduction française: charnière en treillis). Cette technique est inspirée du kerfing (de l’anglais kerf qui signifie entailles/traits de scie).
» Le kerfing est une technique à l’origine pratiquée par les luthiers pour cintrer le bois à froid. Il s’agit de réaliser des rainures dans le sens perpendiculaire au bois, pour l’affiner localement et lui prêter une plus grande souplesse. «
Pour l’instant nous avons réalisé ces essais sur deux types de bois : du medium 3mm et du contreplaqué peuplier 3 mm. Nous nous sommes aperçu que certain motifs fonction mieux sur le medium que sur le contreplaqué, et inversement. Les échantillons sont tous présents au fablab. Nous allons poursuivre les tests sur du pmma et sur d’autres épaisseurs.
Réalisation d’une maison à serrures type Montessori
En surfant sur le net, j’ai trouvé des jouets pour bébés utilisant des vraies serrures qui m’ont semblé bien plus pertinents que les jouets tout en plastique. On les trouve communément sous le terme de maison à serrures Montessori.
J’avais bien envie d’en réaliser une par moi-même. Après avoir parcouru le Web, j’ai décidé de partir sur un format « tableau à serrures » plutôt que maison, et j’ai choisi le thème de la grange pour pouvoir mettre derrière chaque porte une photo d’un animal de la ferme (que j’ai récupéré d’un livre cartonné pour enfant).
J’ai fait un dessin sous inskape et voici ce que cela donne :
Planche 1 : dessin de l’avant
Planche 2 : Arrière
Je l’ai mis aux dimensions de la découpe laser que je vais utiliser à savoir environ 45 cm de haut et 30 cm de large. Je vais utiliser du contreplaqué de peuplier de 5mm d’épaisseur et il y aura une face avant et une face arrière ce qui me permet d’utiliser des vis pour fixer les charnières et les différentes serrures et d’avoir un tableau plus solide.
Premier essai :
Je fais le premier essai avec la planche arrière car c’est le dessin le plus simple. Pour la découpe laser, en noir elle grave et en rouge elle découpe, mais il faut choisir les bons paramètres Puissance vs Vitesse. Je profite des tests faits par ma collègue Solène Geffroy lors de l’élaboration d’un gabarit de découpe.
Pour la coupe, je mets P=90 et V=2
Pour avoir l’effet « grange en bois » je me dis qu’il faut une gravure assez forte et je mets 60 pour la puissance et 20 pour la vitesse sur la couleur noire. Il s’avère que c’était un mauvais choix : la gravure est super longue et trop profonde. J’obtiens quand même une première mouture de mon projet.
Pour l’avant je vais faire autrement :
Couleur noire : P=20 et V=90, c’est un peu léger en gravure mais ça va vite (si je recommence je mettrais plutôt P=40 et V=40 pour avoir un peu plus de profondeur creusée dans le bois)
Quelques images de la découpe laser
J’obtiens 2 parties face avant et arrière, mais pour pouvoir mettre les serrures diverses, il me faut un peu de profondeur, je prends du médium MDF 10mm que je découpe également à la découpe laser (celle à laquelle j’ai accès demande plusieurs passes pour réussir la découpe et avec une petite meuleuse dremel j’enlève les zones très noircies par la laser)
Peinture, fixation arrière + médium + devant puis positionnement charnières et des différentes serrures :
- verrou à poussoir (en bas à droite)
- serrure à clef (en bas à gauche)
- entrebâilleur de porte (au milieu à gauche)
- crochet à levier (au milieu à droite)
- crochet contrevent (en haut)
Après la peinture (indiquée rouge sur le pot) je trouve que c’est un peu trop rose fluo, j’atténue ce fluo en mettant une couleur différente pour chaque porte.
Derrière chacune des portes il y a un animal de la ferme découpé dans un vieux livre pour enfant.
Il ne reste plus qu’à mettre les portes, les serrures (je rajoute un contrefort derrière les portes pour assurer le vissage). Quelques photos des différentes étapes.
Et voici la grange au final
Il ne reste plus qu’à espérer que le petit Maël qui va recevoir cette maison s’amusera beaucoup à découvrir et à s’approprier les différents mécanismes.
Développement d’une lampe à messages et envoi de texto en Light Fidelity (LIFI)
Développement d’une lampe à messages et envoi de texto en Light Fidelity (LIFI) par Adrien Clotteau, Serigne Diouf et Stanislas Evain.
Le Wi-Fi, protocole de communication sans fil propagé par ondes radio, peut être complété par le Li-Fi. Ce dernier utilise la lumière comme support de propagation en utilisant des LED de puissance, modulées à très hautes fréquences.
Le but de ce projet est de réaliser un démonstrateur de télégraphe optique automatique utilisant le principe du LIFI. Notre objectif est de transmettre un message SMS d’un téléphone à un autre via un système constitué d’un émetteur et d’un récepteur qui communiquent par voie optique. Nous avons ajouté cette fonctionnalité à un objet existant, une lampe torche, tout en conservant sa fonction première.
Une application Android capable de gérer l’émission et la réception des messages fait le lien avec notre télégraphe via Bluetooth (elle joue le rôle d’interface homme machine). Dans chaque lampe, une carte Arduino met en forme le message à l’émission et module la lumière. Le même Arduino fait le travail inverse à la réception (démodulation et mise en forme) sur le principe de l’alternat. La performance du lien optique repose sur le choix d’un couple émetteur/récepteur qui offre la meilleure fiabilité : des diodes de forte puissances infrarouge (IR) à l’émission et un détecteur optimisé pour l’IR à la réception.
L’émetteur du prototype est composé de 8 LED visibles ne servant qu’à la fonction éclairage de la lampe torche et de 3 LED IR reliées à une carte Arduino, pour la transmission. L’utilisateur rentre une séquence de caractères via l’application Android. Le message est envoyé à l’Arduino qui convertit le message sous forme binaire (en ASCII) et l’envoie sous la forme de signaux IR modulés. Un « 1 » correspond à 400 µs en état HIGH et à 200 µs en LOW. Un « 0 » correspond à 200 µs HIGH et 400 µs LOW. Cette forme de modulation a été choisie pour profiter des performances du détecteur.
La partie réceptrice du prototype est composée d’un capteur IR qui détecte le signal optique émis et l’envoie vers la carte Arduino sous la forme d’un courant à deux niveaux. L’Arduino démodule le signal reçu, le convertit en bit puis en chaîne de caractère et envoie le message à l’Android en sortie par liaison Bluetooth.
La dernière partie du projet consiste en sa miniaturisation. Le circuit doit tenir dans une lampe torche. Les composant utilisés ont été sélectionnés pour être les plus petits possibles (par exemple, utilisation d’une carte bluno beetle pour l’Arduino et le module Bluetooth, utilisation de shields pour diminuer la taille du montage fonctionnel).
Programme Arduino des systèmes émetteurs et récepteurs
Code
}
}
//############################################# ENCODAGE ############################################################################################ void encodage(){
while(moduleBT.available()) // tant que le module Bluetooth est en train de recevoir des donnees,
{
delay(3); // attend qu’il finisse de tout recevoir
String caractere = String(moduleBT.read(), BIN); //transforme chaque caractère du message grace à son code ASCII en binaire
while (caractere.length()<8) // tant que le caractere codé en binaire ne fait pas 8 bits,
{caractere=String(0)+caractere;} // alors compléter avec des ‘0’ au début pour qu’il fasse 8 bits=un octet
Serial.println(caractere);
//############################################ EMISSION #############################################################################################
void emission(){
if (messageEncode.length() >0) // s’il y a un message binaire pret à envoyer sur le canal optique,
{
messageEncode = String(« 11111111 »)+messageEncode+String(« 0000 »);
Serial.println(messageEncode);
int smsLength=messageEncode.length();
int index=0;
while (index<smsLength){ // parcourir la chaine binaire
if(messageEncode[index] == ‘1’) //A chaque fois que je tombe sur un bit à ‘1’,
{digitalWrite(ledSortie, HIGH); // alors j’allume la lumière IR pendant 400 microsecondes
delayMicroseconds(400);
digitalWrite(ledSortie, LOW); // puis je l’éteins pendant 200 microsecondes
delayMicroseconds(200);
}
if (messageEncode[index] == ‘0’){//A chaque fois que je tombe sur un bit à ‘0’,
digitalWrite(ledSortie, HIGH);// alors j’allume la lumière IR pendant 200 microsecondes
delayMicroseconds(200);
digitalWrite(ledSortie, LOW);// puis je l’éteins pendant 400 microsecondes
delayMicroseconds(400);
}
index++ ;
}
//########################## DECODAGE avec la lecture des registres #######################################################
void decodage(){
unsigned char nbreCaractere=0;
byte messageDecode[141]; // buffer où je stocke le message provenant du canal optique une fois qu’il est décodé, il doit etre au max de 140 caracteres
if (PIND & B00001000){ //si mon capteur détecte un signal IR,
//Serial.print(« signal détecté pour la premiere fois »);
//unsigned char nbreCaractere=0; //compteur du nombre de bits décodés
Serial.println(« ToutAzéroRegistre »);
//unsigned long PrevLOW=800;
while (nbreCaractere<141){ // tant que le message n’excede pas 140 caracteres,
char caractere=0;
char indexCaractere=0;
//Serial.println(« new octet »);
while (indexCaractere<8){
if (PIND & B00001000){// s il y a un front montant,
unsigned long timeLOW=0; //temps au bout duquel on ne detecte pas de lumiere IR
unsigned long timeHIGH=0; //temps au bout duquel on detecte de la lumiere IR
if (PIND & B00001000){ //si on detecte,
while(PIND & B00001000){
timeHIGH++;
}//prendre un chronometre pour le temps d’allumage}if (!(PIND & B00001000)){ // si on ne detecte pas,
while (!(PIND & B00001000) && (timeLOW<3000) ){
timeLOW++;
}//prendre un chronometre pour le temps d’extinction
}
char BIT= (timeLOW<timeHIGH); //decider du bit décodé en fonction des temps d allumage et d’extinction
//Serial.print(byte(BIT));
caractere=(caractere<<1)+BIT; // ajouter le bit décodé a l octet
indexCaractere++; //passer au bit suivant
}
else{ //si on ne detecte pas un front montant, c’est à dire pas de bit en transmission dans la canal optique
indexCaractere=8; // alors arrete le decodage bit a bit (et sortir de la boucle)
//Serial.println(« je sors octet »);
}
}
//Serial.println(« je sors caractere »);
if (byte(caractere)>0){
messageDecode[nbreCaractere]=byte(caractere);
nbreCaractere++;}
else{nbreCaractere=141;}
//Serial.println(byte(nbreCaractere));
Serial.print(caractere);
}
Serial.println(« sortie finale »);
}
if ( byte(nbreCaractere)>0)
Serial.print(« sortie finale finale »);
}
Développement d’un robot pour apprendre à programmer
Par Alexandre GRANGIER, Maxime Mazouffre, Pierre Hamoir et Ahmed Kamoun
Contexte
Dans le cadre de la réforme des programmes d’enseignement en France, l’initiation à la programmation a pris plus d’importance et l’appréhension de la pensée scientifique et devenue un objectif de l’école. Ceci nécessite un certain matériel dédié.
En grande distribution, on trouve différents modèles de robots destinés à apprendre la pensée algorithmique aux enfants de différents niveaux tels que le Bee-Bot [1] le Cubetto [2] ou le Thymio [3].
Aussi sympathiques qu’ils soient, ces robots restent à coût élevé ce qui ne permet pas leur utilisation en classe. L’objectif du projet est donc de créer un prototype de robot évolutif en utilisant le matériel du Fablab de l’école qui soit à coût raisonnable et qui permet ensuite la fabrication de plusieurs robots qui seront utilisés à différents niveaux de l’enseignement.
Matériel utilisé
En plus du médium 3mm qui nous a servi à découper la structure du robot, nous avons utilisé le matériel suivant :
• 1 carte Arduino UNO
• 1 ARDUINO MOTOR SHIELD R3
• 2 moteurs
• 2 roues
• 6 boutons
• 1 bille à roulement libre
• 1 batterie rechargeable
• 2 LEDs
• Des fils de connexion
Conception du robot
Nous présentons dans cette partie la manière dont nous avons construit notre robot, et c’est ce qui sera transmis aux écoles souhaitant le construire elles-mêmes sous forme de mode d’emploi détaillé transmis sur une clé USB contenant par ailleurs les pièces à découper nécessaires au format .dxf pour pouvoir les concevoir à la découpeuse laser.
Une fois les pièces imprimées, l’assemblage du squelette est assez simple et intuitif. Dans un souci de clarté, nous avons donné un nom spécifique à chaque pièce, cela facilitant grandement la compréhension du mode d’emploi (voir figure 11).
Figure 11
Nous avons commencé par insérer les arches 1 et les arches 2 dans les fentes de la plateforme 2 prévues à cet effet, en faisant bien attention à alterner les arches 1 et les arches 2, et en commençant par mettre une arche 1 dans la fente la plus proche du trou rectangulaire qui accueillera plus tard la batterie (figure 12).
Nous avons ensuite passé le cercle central dans les fentes des arches en le passant par le dessus (figure 12).
Figures 12 et 13
Nous avons finalement ajouté la plateforme 3 pour verrouiller le tout (figure 13). Avant de coller le squelette à la plateforme 1, nous y avons ajouté les composants. Nous avons commencé par les roues pour lesquelles il suffisait d’utiliser les fentes de la plateforme 1 (figure15), puis la bille stabilisatrice donc la hauteur peut être ajustée (figure 16), et enfin la carte arduino et le shield que nous avons vissés (figure 17).
Figures 15, 16 et 17
Pour terminer, nous avons fixé la batterie en la glissant dans le trou qui lui est destiné sur la plateforme 2, et nous avons fixé les boutons sur la plateforme 3 et les soudant directement aux fils les reliant à la carte arduino (figure 18). Nous avons finalement associé les deux parties que sont la plateforme principale (plateforme 1) et le squelette (plateformes 2 et 3 et arches) en les collant avec de la colle à bois (figure 19).
Figures 18 et 19
Modes de fonctionnement du robot
a)Transmission de commande
Dans un premier temps, le robot peut être utilisé avec des boutons. Pour cela, il a été nécessaire d’utiliser six différentes actions élémentaires pour pouvoir permettre une totale mobilité :
– Avant
– Arrière
– Rotation Droite
– Rotation Gauche
– Annuler
– Démarrer
Le SHIELD Arduino utilisé, le DK Electronics v1.0 (Figure 1), bloquant l’accès aux différents pins de la carte, il a fallu utiliser les ports analogiques (A0-A5) en mode tout ou rien pour pouvoir réaliser le montage.
Cependant, n’utilisant que deux moteurs, nous avons pu enlever du système un microcontrôleur (à droite sur la Figure 1) pour pouvoir libérer certains pins de commande afin d’ajouter des fonctionnalités au robot.
L’utilisation de l’utilisation d’un encodage pour la commande à effectuer posant problèmes nous avons opté pour une liste de longueur fixe, en effet une limitation de 10 mouvements était imposée par le format (long) des entiers en Arduino. Nous avons choisi de laisser jusqu’à 30 mouvements pour éviter d’utiliser trop de mémoire et de trop utiliser la batterie
Lorsque que le robot est construit, il faut effectuer des tests pour savoir quelles valeurs rentrer. Lors du projet Dec, nous avons utilisé le même matériel et nous avons constaté que dans la pratique, nous devions ajuster la fonction pour chaque voiture. Par exemple, si le moteur droite subit plus de frottements que le gauche, il faut augmente la vitesse de celui-ci.
b)Application
En plus de la possibilité de pilotage du robot grâce aux boutons, les enfants pourront aussi le piloter utilisant une application Android prévue pour cet usage (Figure 2). L’application présente les six boutons présents sur le robot et permet les mêmes fonctionnalités. Figure 2 : interface de l’application
L’application enregistre le choix de mouvements de l’utilisateur dans leur succession. L’envoi de l’information par Bluetooth ne se fait qu’au moment où l’utilisateur appuie sur le bouton Start. Le dernier bouton Reset est conçu pour réinitialiser le robot.
c)Ardublock
Afin de permettre à des classes plus élevé d’utiliser le robot, nous laissons la possibilité de brancher un câble USB directement sur la carte Arduino.
Ainsi ces élèves pourront coder directement le comportement qu’ils veulent que le robot adopte juste en programmant directement le comportement des moteurs, donnant une plus grande flexibilité aux mouvements possible du robot, et permettant l’intégration dans l’algorithme des boucles ou des tests
Un capteur infrarouge suiveur de ligne ou un capteur ultrason pourront être ajoutés dans le robot à la demande du client offrant de nouvelles fonctionnalités, pour aller plus loin dans l’apprentissage de la programmation.
La programmation étant assez compliqué pour des élèves de primaire, elle est faite au moyen d’Ardublock (Figure 3), une interface simplifié de programmation Arduino.
Un algorithme reprenant le code initial du fonctionnement du robot sera mis a disposition à titre d’exemple, pour introduire les élèves au fonctionnement d’Ardublock (les limitations du logiciel ne permettant pas de capture d’écran correcte, il n ‘apparaît pas dans cet article).
Sound Of Silence
La musique est un plaisir inaccessible aux personnes sourdes, néanmoins, ils peuvent la ressentir, la vivre, essentiellement à travers les basses fréquences qui vibrent dans leurs corps. Mais cela reste limité et ne permet pas aux sourds de ressentir toutes les nuances de la musique. Cette barrière crée un sentiment de frustration et de mise à l’écart, notamment lors des festivals de musique.
Le projet Sound Of Silence a pour but de remédier à cette limite et d’offrir la possibilité de vivre l’expérience musicale aux personnes sourdes. De plus, ce projet se place dans un cadre plus global, celui d’une recherche mondiale pour améliorer l’expérience sensorielle. Plusieurs produits qui transmettent la musique par voie tactile ont été lancés dans le marché, mais à des prix exorbitants, un facteur qui a motivé le groupe pour réaliser un prototype nouveau simple et accessible pour tous.
La problématique de ce projet est alors venue naturellement : comment transmettre dans un gilet les couleurs et nuances de la musique aux sourds, en exploitant les autres sens, qui souvent, s’avèrent plus développés ?
Le but étant de produire un vêtement confortable, discret et efficace, doté de composants électroniques capables de retranscrire les éléments du son qui définissent le caractère unique et remarquable de chaque musique, c’est-à-dire les intensités, les fréquences, les harmonies ou encore le rythme afin de permettre une expérience musicale comparable à une écoute « auditive ».
Le projet Sound Of Silence est le fruit d’une mise en commun de compétences en ingénieries et en design, en effet il fut réalisé par un groupe de six étudiants : quatre étudiants de l’IMT Atlantique Bretagne Pays de la Loire (IMTA) en première année formation ingénieur généraliste, et de deux étudiantes de l’EESAB en troisième année. De plus ce projet est réalisé sous l’encadrement de deux enseignants-chercheurs de l’IMTA qui ont accompagné le groupe d’étudiants tout au long des phases de recherche, de conception, de développement et de test du projet.
- Baddaje Dina (IMT Atlantique)
- Hizem Feyza (IMT Atlantique)
- Bourgeois Pierre (IMT Atlantique)
- Murat Gaspard (IMT Atlantique)
- Privé Lisa (EESAB)
- Le Boulaire Delphine (EESAB)
Le premier choix technique à effectuer concerne l’entrée de la musique. Pour se faire nous avons choisi de récupérer le son en temps réels grâce à un micro, ce moyen est adapté pour une utilisation du gilet lors de performances live. Il est aussi possible de brancher le gilet directement à une source musicale (smartphone ou autre) à l’aide d’une prise jack.
Le deuxième choix technique fut le moyen de retranscrire le son pour être transmis à l’utilisateur. Nous avons choisi d’utiliser des moteurs à vibrations pour une transmission tactile et des LEDs pour une transmission visuelle, le but étant de simuler deux sens différents afin de rapprocher au maximum le ressentis de la musique à l’utilisateur.
Pour pouvoir gérer les entrées et sorties de notre prototype et pour faire le traitement de son nécessaire nous avons utilisé une carte Raspberry pi 3. Mais comme ce micro ordinateur ne possède pas de carte son nous avons utilisé une carte son externe pour pouvoir enregistrer la musique.
Nous avons développé un programme python qui permet d’enregistrer le son pendant une durée T et le stocke dans une variable temporaire dans un premier temps. Ensuite ce programme effectue une transformé de Fourier grâce à la fonction fft du module scipy (bibliothèque Python). Nous obtenons ainsi le spectre du fragment musicale que l’en partage en quatre bandes de fréquences. Puis le programme effectue une moyenne sur chaque bandes, cette méthode permet d’approximer la transformée de Fourrier afin de ramener le signal en temporel. Les valeurs obtenues sont normalisées et ramenées entre 0 et 100 pour contrôler les moteurs et entre 0 et 255 pour contrôler les LEDs, dans ce cas chaque couleur correspond à une bande de fréquences.
Bibliothèques python utilisées :
- Enregistrement et traitement du son : Time, SciPy
- Gestion des moteurs : RPI.GPIO
- Gestion des LEDs : Adafruit neopixel
Côté design, nous avons choisi de réaliser le prototype en deux parties : Le premier bloc constitue le gilet qui contient tous les moteurs et les LEDs. Le deuxième bloc est composé d’une Rasberry, d’une Breadboard avec trois hacheurs, et de deux batteries. Ce bloc hardware est intégré dans un petit sac articulé avec des pièces de bois (découpé à la découpeuse laser) qui forme plusieurs étages: chaque étage contient un des éléments électroniques précédent. L’utilisateur du prototype placera sur son dos ce sac et pourra l’enlever à son gré. Ce choix a été fait pour éviter d’encombrer le gilet d’un côté, mais aussi par mesure de sécurité. En effet, tous les composants électroniques utilisés chauffent et ne doivent pas être en contact direct avec du tissu; de plus, cela permet de les isoler en partie des conditions extérieures et de l’humidité.
Ainsi, tous les fils de chaque partie convergent vers un connecteur 20 points HE10 femelle, l’utilisateur devra brancher le connecteur du gilet avec celui du sac pour utiliser le gilet. Le programme Python s’exécutera automatiquement après le branchement.
Nous avons effectué une recherche pour pouvoir identifier les parties du corps les plus sensibles à chaque type de fréquences et nous avons choisi de simuler le ventre avec les vibrations relatives aux basses fréquences, les omoplates avec les vibrations relatives aux hautes fréquences et le bas du dos avec les vibrations relatives aux moyennes fréquences.
Nous avons également choisi de mettre des couleurs particulières à chaque fréquence dominante, pour consolider les sensations de hautes fréquences avec des couleurs froides comme le bleu et le violet et les basses fréquences avec des couleurs plus chaudes comme le rouge et le jaune.
L’utilisateur devra brancher les deux connecteurs afin de lier les deux parties du prototype, alimenter la carte Raspberry, et brancher un micro ou une source musicale. Après quelque seconde (temps de démarrage d’un ordinateur) le programme sera lancer automatiquement et l’utilisateur pourra ressentir les moteurs et voir les LEDs.
Inventaire du matériel utilisé :
- Raspberry pi 3.
- Carte son Dust mini 09627.
- 10 minis moteurs à vibrations plats.
- 2 circuits intégrés L293D.
- 6 LEDs RGB neopixels.
- 1 circuit intégré 74AHCT125.
- 2 batteries 5V.
- Une Breadboard.
- Des fils.
- Une plaque de bois 7mm.
- Du tissu type Lycra.
- Deux sangles.
Finalement, ce prototype apporte une nouvelle solution pour ressentir la musique. Cette solution reste néanmoins à développer correctement avec du matériels plus performants et nous permet de croire au développement futur d’un gilet musicale accessible et utilisable par tous.
Contribution au projet Drone Crazyflie 2.0
Prise en main et amélioration du kit Crazyflie 2.0
Les drones représentent un potentiel d’application et d’innovation très vastes. C’est pourquoi nous avons décidé, dans le cadre du projet S2 Dev, de nous intéresser à ceux-ci et en particulier à la découverte et à l’amélioration d’un kit open source : Crazyflie 2.0 et de son drone.
Le drone du kit Crazyflie 2.0 par Bitcraze
Client python original avec le flight tab d’ouvert
Ce kit contient donc un petit drone à monter de 9 cm² de surface et pesant 27 g mais aussi un client pour ordinateur (sous forme d’une machine virtuelle) et d’un client Android avec des fonctionnalités déjà programmées !
Client Android de base
La découverte et la prise en main du kit se sont correctement déroulées et nous avons eu l’ambition d’améliorer, d’automatiser voire de rajouter certaines fonctionnalités des clients python et android. Nous avons par exemple ajouté un mode de décollage automatique, de reproduction d’actions préenregistrées et un mode de réalisation de figures suivant un tracé dessiné par un utilisateur.
Mais nous nous sommes heurtés à des problèmes techniques causées par des casses lors de tests et des problèmes liés à la recharge de la batterie. En conséquence nous avons élaboré, à l’aide des plans du circuit déjà existant, un chargeur externe pour la batterie. Nous avons en plus, grâce aux outils et machines disponibles au TéléFab comme l’imprimante 3D, réalisé une cage de protection intégrant les supports moteurs pour le drone et aussi une boîte pour le chargeur.
Circuit de chargeur dans son boîtier
Un looping réalisé entièrement par le mode de pilotage automatique
Utilisation du client Python
Bracelets RFID
Bracelets RFID
Par MORSLI Omar, DURVILLE Jean-Baptiste, RUBIN Clément, GOURRAT Agathe.
Contexte
Dans le cadre du projet développement (réalisé au deuxième semestre) de l’école, notre équipe à eu l’idée de mettre au point un moyen de contrôler les entrées et sorties de personnes lors d’événements rassemblant du monde. Pour cela nous avons cherché à développer des bracelets utilisant la technologie RFID – ou identification par ondes radio – qui permettent de contrôler les personnes passant les issues de secours tout en simplifiant l’accès aux services de l’événement (comme l’achat d’un repas à un stand).
Principe
Les bracelets ont pour principale caractéristique d’utiliser la transmission longue portée qui permet de détecter le mouvement des personnes traversant les portiques situés aux sorties. Ils fonctionnent aussi en courte portée afin de permettre les paiements et autres applications annexes. La subtilité réside dans l’apparition d’interférences avec la manipulation de ces deux modes de transmission qu’il faut prendre en compte lors de la conception du système globale. Dans un premier temps, il faut dimensionner les antennes longues portée et les réaliser afin de les utiliser ensuite dans les expérience pour valider le dimensionnement.
Système global pour contrôler les courte et longue portée.
Réalisations
Pour réaliser les antennes longue portée, il faut d’abord simuler l’antenne et son rayonnement à l’aide de logiciels spécialisés (ici ADS et MoMentum). On obtient ainsi les dimensions de l’antennes qui permettent de les construire.
-
Dimensionnement des antennes grâce à une simulation par ADS
Dans le cadre de ce projet, nous n’étions pas limités par des contraintes de dimensions, donc nous pouvions choisir entre une antenne patch à une fente ou à deux fentes. Cette dernière, fournit une meilleure directivité et est plus performante qu’une antenne à une fente – court-circuitée sur un de ses côtés -. D’autre part, nous avons souhaité réaliser une antenne à deux polarisations, il faut donc que celle-ci soit symétrique. Ainsi, elle doit être carrée et ne pas posséder de court-circuit. Nous avons donc sélectionné une antenne patch rayonnant à travers deux fentes pour chaque polarisation.
A partir des valeurs de la fréquence de travail (868 MHz) et la permittivité électrique relative du diélectrique (égale 1), nous avons déterminé la longueur d’onde (?=?/?) et la longueur de l’antenne (?=?/?).
Maintenant que nous disposons des dimensions théoriques (largeur = longueur, antenne carré), nous souhaitons affiner ces calculs à travers ADS. C’est ce logiciel qui nous a permis de trouver des valeurs un peu plus précises pour le dimensionnement, surtout en termes d’adaptation. Le but étant d’avoir un maximum de puissance transmise à l’antenne sans retour. Nous avons utilisé le principe du « tuning » sur Lp (longueur du patch) et sur Lsonde (position de la sonde selon la longueur) sur le modèle de l’antenne patch classique pour avoir un coefficient de réflexion (S11) minimal à la fréquence de travail.
La dernière étape, consiste à déterminer les performances en rayonnement de cette antenne. C’est pour cela que nous avons procédé à une description plus précise à l’aide d’une analyse électromagnétique.
En effet, le modèle préalablement retenu ne permettait pas de remonter aux informations relatives au rayonnement. Nous avons donc utilisé l’application ADS/MoMentum, dédiée à ce type de simulation, qui permet en particulier d’étudier les performances réelles du rayonnement (gain, polarisation), mais aussi la distribution des courants dans le patch.
S11 en fonction de la fréquence et abaque de Smith de l’antenne (on peut observer la fenêtre de « tuning » à gauche de l’écran)
-
Réalisation d’une antenne longue portée
Une fois ce dimensionnement réalisé, les dimensions de l’antenne sont connues ce qui facilite sa construction.
Cette fabrication nécessite de la mousse d’air (ici d’épaisseur 3 mm), qui agit comme isolant, une plaque de cuivre et du scotch métallique, qui permettront de faire le résonateur.
Tout d’abord nous avons positionné la sonde sur le plan de masse (cuivre) puis nous avons découper deux carrés de mousse avec les dimensions calculées pour avoir une isolation de 6mm et enfin nous avons recouvert la mousse du scotch. Un test effectué à l’aide d’un analyseur de spectre a permis de connaître le minimum de réflexion S11. De nouveaux découpages peuvent être nécessaires pour arriver à adapter l’antenne à la fréquence de travail (ici 868MHz). Il faut que le coefficient à cette fréquence soit le plus bas possible, notre antenne atteint -22,5 dB à 866 MHz ce qui est acceptable.
Antenne et analyseur de spectre
Expériences et Résultats
Maintenant que les antennes longues portée sont réalisées, nous allons effectuer des expériences afin de valider les critères de l’étude (portée, détection de mouvement,…)
Tout d’abord pour valider la portée maximale de l’antenne, on détermine son gain en espace libre grâce à la formule de Friis. Ensuite, pour déterminer sa portée réelle dans un environnement commun, on fait la même expérience avec l’antenne et un badge RFID qui permet d’avoir les différents gains du système. Grâce aux données recueillies, on évalue le seuil (distance) à partir duquel la puissance est insuffisante pour être détectée. Cette dernière expérience est ensuite réalisée pour différents angles de l’antenne afin de s’assurer que le gain reste suffisant malgré une légère orientation de l’antenne.
On détermine ensuite la capacité du système à analyser les mouvements d’entrée et de sortie à l’aide de 2 antennes, d’abord côte-à-côte puis l’une en face de l’autre. On évalue ainsi l’influence du positionnement ce qui permettra de savoir combien d’antennes utilisées dans les portiques et comment les positionner. On pourra déterminer, grâce au temps de retard d’une antenne à l’autre, le mouvement d’une personne traversant le portique. Grâce au positionnement face-à-face, plus de personnes peuvent être détectées car moins d’obstacles bloquent la transmission badge-antenne.
Enfin, on détermine le nombre maximal de personnes perçues simultanément avec un positionnement optimal des antennes (déterminé avec l’expérience précédente).
Ces expériences sont en cours de développement à cause d’un problème au niveau du lecteur d’antennes.
Conclusion
Nous avons pu réaliser les antennes longue portée qui fonctionnent à la fréquence 866-868 MHz et qui pourront être utilisée dans les portiques pour détecter des personnes. Il faudrait pouvoir connecter deux antennes de chaque côté du portique pour pouvoir détecter toutes les personnes qui passent à travers le portique avec le minimum d’erreur et analyser leur mouvement (entrée-sortie).
Rénovation de maquettes didactiques
Rénovation de maquettes didactiques
Par Jean-Baptiste GARDEL, Lionel SOME et Cheng ZHEN
Contexte
Nous avons eu à rénover dans le cadre de notre projet de développement S2, trois maquettes appartenant au collège Saint-Pol Roux de Brest. Ces trois anciennes maquettes représentent une maison (la Domotique), un ascenseur et un convoyeur-trieur. Les outils de programmation de ces maquettes étant devenus obsolètes, le collège a décidé de les rénover et d’intégrer une carte Arduino afin d’enseigner la programmation à ses élèves.
Figure 1: La Domotique à droite et l’Ascenseur à gauche
Figure 2: La maquette Convoyeur-trieur
Matériel utilisé
En plus des maquettes nous avons utilisé le matériel suivant :
- 3 cartes Arduino ;
- 3 prises Jack ;
- 3 connecteurs femelles de type HE10 2*13 pôles.
Compétences requises
Pour mener à bien ce projet, il faut pouvoir appliquer des connaissances dans une situation nouvelle, pouvoir concevoir, réaliser une solution technique, la tester puis la valider. Il s’agit d’une rétro-ingénierie ou rétro conception et cela s’apparente à la reprise des différentes étapes d’un cycle de conception d’un produit.
Réalisation
Après quelques recherches sur internet, nous avons trouvé un document présentant la rénovation de la maquette convoyeur-trieur effectuée par un professeur de technologie, Didier Dumas (http://technojolie.fr/moodle/pluginfile.php/54/mod_page/content/7/Rehabilitation%20maquette%20Convoyeur%20Trieur.pdf)
Cela nous a permis d’entrer dans le bain assez rapidement et de comprendre la façon dont les anciens composants et nouveaux ont été mis en correspondance.
En effet, les documentations techniques des maquettes n’étaient pas toutes disponibles, ce qui rendait le travail encore plus délicat. La première étape d’une réhabilitation de matériel (reverse engineering) étant l’appropriation de ce dernier, disposer uniquement d’anciennes disquettes inutilisables et sans documentation technique comme c’était le cas pour les maquettes, ne facilitait pas le travail.
Ce document nous a donc été d’un grand apport pour débuter notre projet.
Notre rénovation s’est faite en trois étapes :
- Le repérage des entrées/sorties
Étape indispensable pour réaliser le branchement des cartes Arduino, nous avons pu dans un premier temps réaliser le montage de la maquette convoyeur-trieur (à l’aide du document susmentionné) afin de nous assurer que nous étions sur la bonne voie.
Pour les deux autres maquettes, nous avons décidé dans un premier temps d’utiliser un multimètre afin de retrouver le composant auquel était rattaché un fil en recherchant un court-circuit. Cette méthode n’était pas particulièrement pratique et a été vite abandonnée pour une autre qui s’est avérée plus pratique. Cette dernière a consisté à effectuer les branchements sur une carte Arduino puis à envoyer du courant sur chacune des entrées/sorties pour voir le résultat obtenu et ainsi attribuer à chaque broche l’élément de la maquette correspondant. C’est cette méthode que nous avons privilégié jusqu’à la fin du repérage de toutes les entrées/sorties.
Figure 3: La maquette Domotique
Figure 4: Attribution des pins de la maquette Domotique
- Codage des scénarios
La deuxième étape a consisté en la réalisation de scénarios permettant le pilotage des maquettes et adaptés à l’apprentissage au collège. Nous avons pour cela repris les scénarios de base décrits dans les documentations d’origine dont nous disposions et nous les avons complétés.
La première étape fût le codage en C++ des actions simples pour vérifier que les branchements étaient bons puis un enchaînement d’actions plus compliquées. L’étape suivante fût la traduction du code C++ en code par blocs (ArduBlock) plus facile à comprendre pour de jeunes programmeurs. Des codes de difficultés croissants ont ainsi été produits. Les codes fournis aux professeurs du collège Saint Pol-Roux sont divers de par les niveaux de difficultés croissants proposés.
Lesdits scénarios sont décrits dans la fiche technique de chaque maquette que nous avons réalisée.
- Rédaction des fiches techniques
Il est essentiel de se rappeler que ces maquettes étaient destinées à être utilisées par un enseignant, il nous a donc semblé nécessaire de fournir en plus du code ArduBlock permettant de faire fonctionner les maquettes, une fiche technique et pédagogique qui comprend une description de la maquette, les branchements à réaliser sur la carte Arduino et les scénarios sous forme d’exercices pour les élèves. Selon la maquette, il peut aussi y avoir des branchements à effectuer qui différent selon le scenario choisi. Cette fiche permet donc pour chaque maquette une prise en main rapide.
En parallèle de tout cela et au fur et à mesure que nous avancions dans le projet, nous avons réalisé quelques modifications afin d’améliorer le fonctionnement des maquettes :
- Nous avons remplacé les anciens cordons d’alimentation des anciennes interfaces de programmation par des prises Jack pour l’alimentation des cartes Arduino. Cela permet à la carte Arduino de piloter plus facilement les moteurs des maquettes Ascenseur et Convoyeur-trieur et d’utiliser les maquettes sans avoir à brancher la carte Arduino à un ordinateur.
- Nous avons créer un moyen d’identifier les mallettes contenant les maquettes (autocollants).
C’est ainsi que nous sommes parvenus à la rénovation des maquettes. Le tableau ci-après résume les différences entre les maquettes avant et après réhabilitation.
Figure 5: Différences avant et après rénovation des maquettes
Contribution au projet InMoov in Brest
Qui n’a jamais rêvé de construire son propre robot ? Avec le projet libre et communautaire InMoov, la construction d’un robot humanoïde n’a jamais été aussi simple. En effet, ce projet, initié par Gaël Langevin, designer français, vise à la réalisation d’un modèle de robot humanoïde formé de pièces imprimables en 3D dans une imprimante de dimensions standards (12cm*12cm*12cm). Toutes les pièces sont accessibles en ligne et un guide de montage est même fourni ! (Attention, ce projet est TRÈS chronophage !)
Ainsi, dans le cadre de la réplique de ce robot réalisée à Brest par les fablabs de la ville et centralisé à l’Openfactory, le fablab de l’UBO, une équipe de volontaires de l’IMT Atlantique a relevé le challenge de construire l’avant-bras et la main droite de ce robot, tout en y implémentant des fonctionnalités sympathiques (préemption, réalisation de signes, contrôle à distance via une application Android, …).
Avant-bras robotisé du projet InMoov
Avant-bras d’InMoov
Toutes les pièces utilisées ont été imprimées au Téléfab en PLA selon les modèles trouvés sur le site inmoov.fr. Le tout fonctionne grâce à cinq servomoteurs HK15298 (doigts) et un servomoteur MG996R (poignet) contrôlés par une Arduino Mega. Une application Android de commande à distance (via bluetooth) a été réalisée en Java.
Application Android de commande de l’avant-bras d’InMoov
