Communiquer par la lumière
Le Li-Fi est une technologie récente basée sur la lumière visible qui risque de connaître un véritable essor pendant les prochaines décennies. Notre projet a pour but de faire découvrir au grand public ce qu’est le Li-Fi.
Pour ce faire nous avons construit un prototype capable de transmettre de l’information grâce à la lumière. Ce système qui comprend un récepteur et un émetteur est capable de transmettre des messages textes.
L’émetteur est composé d’une LED alimentée par un ordinateur et reliée à une carte Arduino. L’utilisateur rentre une phrase qu’il veut transmettre sur l’ordinateur, le code implémenté sur la carte Arduino se charge de coder le message et de moduler l’amplitude du signal électrique reçu par la LED pour émettre ce code.
Le récepteur est composé de deux parties. Une partie composée d’une photorésistance, d’un résistor et d’un amplificateur est chargée de récupérer l’amplitude du signal lumineux ambiant. Ce système est relié à une carte Arduino qui peut extraire et traduire le message binaire contenu dans le signal lumineux.
La fréquence de fonctionnement de notre système est de deux Hertz. Ceci peut être vu comme un inconvénient du aux limitations introduites par la photorésistance. En réalité, il renforce l’aspect ludique de notre projet car l’utilisateur peut voir les alternances LED allumée/éteinte et comprend ainsi comment l’information est codée.
code :
int led = 13;
int t=500;
char message[]= »SALUT COMMENT CA VA ?? »;
void setup() {
pinMode(led, OUTPUT);
}
void lireMessage(char lettre){
if(lettre==’A’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’B’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’C’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’D’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’E’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’F’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’G’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’H’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’I’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’J’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’K’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’L’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’M’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’N’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’O’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’P’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’Q’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’R’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’S’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’T’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’U’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’V’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’W’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’X’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’Y’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’Z’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’`’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’,’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’.’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’ ‘){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’?’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’!’){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’1′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’2′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’3′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’4′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’5′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’6′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’7′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
if(lettre==’8′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’9′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
}
if(lettre==’0′){
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
digitalWrite(led, LOW);delay(t);
}
}
void loop() {
int i;
for(i=0 ; i< strlen(message); i++){
lireMessage(message[i]);
}
digitalWrite(led, LOW);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, HIGH);delay(t);
digitalWrite(led, LOW);delay(t);
//lireMessage(‘A’);
}
code récepteur :
Co-Opération
Description
Dans le cadre de l’intersemestre Fablab et Design avec L’EESAB, nous avions réaliser un prototype en groupe ( double binôme, l’un de Telecom Bretagne, l’autre de l’EESAB). Nous avons décidé de poursuivre ce projet pour le projet développement. Ce projet a pour thème le numérique à l’école.
Ce projet se divise en deux partie : La réalisation d’un jeu éducatif Co-Opération, et le développement d’ateliers éducatifs pour des enfants du cycle 3 ayant pour but de les initier à l’informatique et à l’électronique.
I-Co-Opération
But du Projet
Ce projet est une activité ludique et éducative pour apprendre les tables de multiplication. C’est un jeu qui se joue à deux, en coopération. Il se présente sous la forme de deux estrades recouvertes d’un tapis,ces dalles sont découpées en 9 cases et forment un pavé numérique d’un mètre carré, et d’une stèle comportant en son sein une carte arduino ainsi que deux afficheurs composées de LEDs adressables. Le but du jeu est de retrouver les facteurs d’un produit donné. En effet, l’écran affiche un nombre correspondant à un produit de deux chiffres, et les élèves doivent se concerter pour retrouver via leur tapis le nombre affiché (par exemple: 56 s’affiche à l’écran et l’un des enfants doit se mettre sur le 8, l’autre sur le 7). Pour cela, ils doivent se tenir debout sur les cases du pavé numériques adéquates.
Ces estrades sont sensibles à la pression appliquée sur les cases numérotées, permettant ainsi la détection d’une réponse de l’enfant. Une fois les deux enfants sur leur case, un délai d’une seconde s’écoule avant que la réponse ne soit validée ou infirmée.
Du point de vue esthétique développé par les étudiantes de l’EESAB, la recherche tourne autour de l’aspect graphique du tapis et de la stèle. Les formes vives et attractives sont importantes pour l’enfant. Aussi il est décidé que le mouvement de l’enfant est primordial dans le jeu. Ainsi il devient acteur de son apprentissage.
Solutions Techniques
Affichage
Dans notre système nous devons afficher le produit que les élèves doivent trouver, le score et indiquer si une réponse est bonne ou mauvaise. Pour cela nous avons utiliser des Néopixels. Ces LEDs adressables sont une bonne solution car on peut les mettre en série et les contrôler une à une ce qui permet d’utiliser très peu de pins de l’Arduino et de facilement afficher des chiffres. Le constructeur mettant à disposition une bibliothèque pour pouvoir facilement les contrôler. L’autre avantage de ces LEDs est qu’elles sont RGB, dans le cadre de notre projet cela nous permet de valider ou non la réponse d’un élève en changeant la couleur du produit. Il passera au orange pour une mauvaise réponse et au bleu pour une bonne réponse.
Les interrupteurs
Le second problème que nous avons rencontré est celui de gérer les 18 interrupteurs que sont les plaques numérotées sans pour autant surcharger l’Arduino, qui n’a pas assez d’entrées. Nous avons penser résoudre ce problème en utilisant dans un premier temps des registres à décalage. Ceux ci permettent de prendre des entrées en parallèles pour en faire une seule sortie en série. Ce dispositif n’utilise que 4 pins quelque soit le nombre d’entrées en parallèles. Grâce à ces registres, nous avons pu relier les 18 plaques à un seul Arduino, néanmoins plusieurs problèmes sont apparu lors de l’implémentation finale. Tout d’abord l’alimentation des trois registres à décalages était assez important et nous ne pouvions plus utiliser notre prototype en l’alimentant via le port USB d’un ordinateur. Ensuite il y avait un très grand nombre de fils entre les estrades et la stèle, 36 en tout, Cela rendait le prototype très confus, il était compliqué de brancher correctement les plaques à la stèle. Finalement cela ne fonctionnait pas surement à cause d’une erreur dans la soudure, confuse elle aussi à cause de tous les fils s’entremêlant.
Nous avons décider de trouver une nouvelle solution. Nous avons alors conçu un deux convertisseurs numériques analogiques simili R-2R grâce à des ponts de résistances. Ceux-ci se trouvent en sortie de chaque estrade et permettent de faire passer le nombre de fils entre les estrades et la stèle de 36 à 6. Cela rend aussi beaucoup plus facile le suivi de l’information, et réduit drastiquement la consommation de notre prototype. Le seul changement sur la carte Arduino est que l’on utiliser plus les pin numériques de celle-ci comme avec les registres à décalages mais les pins analogiques.
Les plaques de pression
Les plaques de pression envoient un signal jusqu’à la carte Arduino quand un des joueurs marchent dessus. Nous avions une contrainte supplémentaire des designers à propos de ces plaques, il fallait avoir possibilité de ranger l’estrade. Dans un premier temps nous voulions utiliser la déformation des plaques sous le poids du joueur grâce à des matériaux piézoélectriques mais nous avons finalement abandonner cette idée. Nous avons alors découpé de manière individuelle chaque plaque et fait un cadre de mousse, nous utilisons alors l’affaissement de la plaque et plus sa déformation. Pour transmettre le signal nous avons d’abord essayé avec un capteur de force, cela fonctionnait bien mais le prix de ce genre de capteur est trop élevé pour l’usage que l’on voulait en faire et nous nous somme rabattu sur du ruban adhésif aluminium. On pose de ce ruban conducteur en dessous de la plaque et sur un morceau de bois, on soude des fils sur ces bouts de ruban. Ainsi quand un joueur marchera sur une plaque les rubans conducteurs rentreront en contact fermant alors le circuit.
II-Ateliers éducatifs
Pour initier les enfants aux rudiment de l’électronique et de l’électronique nous avons développer des ateliers éducatifs, ces ateliers sont accompagné de fiches techniques pour que n’importe quel enseignant puisse les mettre en place. Enfin ces ateliers ont pour but final de concevoir une petite calculatrice.
Les ateliers
Nous ne disposons que de quatre séances d’une heure chacune avec les élèves de primaire. Cependant, nous avons divisé notre initiation à l’électronique et l’informatique en six ateliers plus une réalisation finale. Ainsi, la première séance est une séquence d’introduction au projet, et est également l’occasion de présenter son déroulement. Puis lors de la deuxième session, la classe est divisée en trois groupes, chaque groupe s’occupant d’un atelier découverte. Ensuite, durant la troisième séance, chacun de ces trois groupes travaille sur la conception d’une partie de la calculatrice.
Enfin, la dernière heure est consacrée à l’intégration des trois parties constituant la calculatrice pour obtenir un appareil fonctionnel. Pour ce faire, les élèves doivent, collectivement, travailler sur l’intégration des différentes parties, tout en expliquant aux personnes des différents groupes l’essentiel de ce qu’ils ont appris.
Encadrement des élèves
Les élèves de primaire sont divisés en trois groupes à chaque séance, chacun traitant un atelier. Pour chaque groupe, il y a au moins un encadrant, que ce soit un enseignant ou un membre du projet, pour accompagner les élèves dans leurs réflexions et les aider à tirer les notions que l’atelier leur permet d’acquérir.
A la fin de chaque séance, les élèves doivent faire une mise au point de leur apprentissage afin que l’ensemble du groupe bénéficie de l‘atelier.
Réalisation finale : la calculatrice
Après avoir pris connaissance des notions de base en électronique et en informatique, durant les deux premières séances, les élèves, divisés en groupe, doivent, durant la troisième séance, mettre en œuvre leurs acquis pour réaliser une partie de la calculatrice avec le matériel à leur disposition. Ils ont ainsi à opter pour une des différentes solutions possibles pour faire le travail demandé dans la partie qui les concerne. Plus concrètement, le premier groupe doit choisir les composants qu’il utilise pour construire le pavé numérique de la calculatrice, le deuxième groupe doit trouver un système de transmission de données commode et le troisième groupe a à implémenter un programme qui permet d’effectuer les opérations de base, c.à.d. l’addition, la soustraction, la multiplication et la division.
Tout au long de ce projet, les élèves sont amenés à justifier la pertinence de leurs choix auprès des encadrants.
Résumé des ateliers
Voici un résumé des différents ateliers, des activitées mises en places, des durées indicatives des ces ateliers et du support et matériel nécessaire pour faire ces ateliers.
Projet développement: L’escalier musical
Description
Dans le cadre du projet développement, nous avons réaliser un dispositif à installer sur un escalier, dispositif qui émet des notes de musique lorsqu’une personne emprunte l’escalier.
L’escalier musical
L’objectif est de favoriser l’utilisation de l’escalier traditionnel au détriment de l’escalier mécanique, afin de promouvoir l’activité physique dans notre société. L’aspect fatiguant des escaliers traditionnels est remplacé par un aspect ludique grâce à la musique, ce qui favorise son utilisation.
Matériel utilisé
- 1 Raspberry Pi B
- 3 cartes Arduino UNO
- 2 émetteurs radio FS1000A (433 MHz)
- 1 récepteur radio XY-MK-5V
- 4 modules de détection US-HC-SR04
- 1 lecteur de tag RFID RC522
Fonctionnement
L’élément prépondérant de l’escalier musical est la détection de l’usager. Pour se faire, nous utilisons les modules de détection ultrason US-HC-SR04 qui, grâce au principe d’émission-réflexion des ondes ultrasonores fournissent en continu la distance entre le capteur et un obstacle. Lorsque personne ne passe, cet obstacle est le mur opposé, et lorsqu’un obstacle se situe à une distance inférieure à un seuil, il s’agit de la jambe d’un passant et il faut donc émettre un son.
Cette tâche incombe à un Raspberry Pi modèle B qui, grâce au programme Python présenté en Annexe, émet un son lorsqu’il reçoit l’information correspondant à une marche.
Cette information transite entre le capteur ultrason et le Raspberry Pi par ondes radio grâce aux émetteurs FS1000A et au récepteur XY-MK-5V. Nous utilisons pour cela la librairie VirtualWire.
Les émetteurs sont chacun branchés à une carte Arduino UNO, où sont également branchés deux modules de détection. Ainsi, chaque émetteur transmet les informations correspondant à deux capteurs. Celles-ci sont récupérées par le récepteur XY-MK-5V, branché à une carte Arduino UNO, elle-même reliée au Raspberry Pi. Le code des cartes Arduino UNO émettrice et réceptrice est présentée en Annexe.
De plus, un lecteur de tag RFID est relié à la carte Arduino UNO réceptrice, afin de permettre aux membres de Télécom Bretagne de changer l’instrument joué grâce à leur badge. Les librairies SPI et MFRC522 sont utilisées pour cette tâche.
Le schéma suivant illustre le principe de fonctionnement de l’escalier:
Annexe
Code Python implémenté à exécuter par le Raspberry Pi:
#serial est une bibliothèque qui permet la lecture des données provenant du port série
#pygame est une bibliothèqye dont le module mixer permet de jouer des fichiers .mp3
import serial, pygame.mixer
#initialisation du mixer
pygame.mixer.init()
#initialisation de la connexion série
ser=serial.Serial(‘/dev/ttyACM1’,9600)
#la boucle sera exécutée à l’infini
while 1:
#on récuppère la valeur provenant du port série
newIncome = ser.readline()
# si c’est un instrument, on défini la variable instrument comme l’instrument correspondant
if newIncome==‘piano\r\n’:
instrument = ‘piano’
if newIncome==‘trompette\r\n’:
instrument = ‘trompette’
if newIncome==‘coeur\r\n’:
instrument = ‘coeur’
if newIncome==‘batterie\r\n’:
instrument = ‘batterie’
if newIncome==‘piano2\r\n’:
instrument = ‘piano2’
#si c’est une note de musique, on la joue grâce au module pygame.mixer
#les notes sont contenues dans un dossier dont le nom correspond à l’instrument dont elles sont issues
if newIncome== ‘A\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/la.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘B\r\n’:
pygame.mixer.music.load(‘/home/pi/Music/%s/si.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘C\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/do.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome ==‘D\r\n’:
pygame.mixer.music.load(‘/home/pi/Music/%s/re.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘E\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/mi.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘F\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/fa.mp3’+instrument)
pygame.mixer.music.play(loops=0,start = 0.1)
elif newIncome == ‘G\r\n’:
pygame.mixer.music.load(‘/home/pi/Music/%s/sol.mp3’+instrument)
pygame.mixer.music.play(loops=0,start = 0.1)
elif newIncome == ‘c\r\n’:
pygame.mixer.music.play(‘/home/pi/Music/%s/DO.mp3’+instrument)
pygame.mixer.music.play(loops=0,start = 0.1)
Code de la carte Arduino UNO émettrice:
include <VirtualWire.h>
/* virtualWire est une librairie libre de droit permettant l’utilisation
des modules de transmission-réception radio*/
// initialisation des pins
int trig1 = 12;
int echo1 = 11;
int trig3=8;
int echo3=7;
// instanciation des variables utiles
long lecture_echo1;
long cm1;
long lecture_echo3;
long cm3;
//messages qui seront envoyés, à changer d’une carte à l’autre (msgStringD et msgStringE par exemple pour envoyer D et E)
String msgStringG;
String msgStringF;
void setup(){
// paramétrage des capteurs
pinMode(trig1, OUTPUT);
digitalWrite(trig1, LOW);
pinMode(echo1, INPUT);
pinMode(trig3, OUTPUT);
digitalWrite(trig3, LOW);
pinMode(echo3, INPUT);
//initialisation de la communication via le port série (USB)
Serial.begin(9600);
Serial.println(« setup transmitter 1 « );
//initialisation de la communication par radio
vw_setup(2000);
vw_set_tx_pin(2);
}
//code qui sera répété indéfiniment
void loop(){
// récupération de la distance cm1 du capteur 1 à l’obstacle
digitalWrite(trig1, HIGH);
delayMicroseconds(10);
digitalWrite(trig1, LOW);
lecture_echo1 = pulseIn(echo1, HIGH);
cm1 = lecture_echo1 / 58;
// récupération de la distance du capteur 3 à l’obstacle
digitalWrite(trig3,HIGH);
delayMicroseconds(10);
digitalWrite(trig3,LOW);
lecture_echo3=pulseIn(echo3,HIGH);
cm3 = lecture_echo3 / 58;
/* si la distance de l’obstacle au capteur est inférieure à 115cm et que c’est la première fois que l’obstacle
est detecté, on envoie l’information correspondant au capteur */
if( cm1 < 115 && msgStringF != « F » && cm1 != 0 ){
//traitement des données
msgStringF = « F »; /*ces valeurs seront à changer en cas de changement de carte*/
const char* msg = msgStringF.c_str();
// envoi des données par radio
vw_send((uint8_t *)msg,strlen(msg));
Serial.println(« envoyé »);
}
// sinon, on réinitialise les valeurs
elseif( cm1 >= 115){
msgStringF = « 0 »;
}
// le principe est identique pour le second capteur
if(cm3 < 115 && msgStringG != « G » && cm3!= 0){
msgStringG = « G »;
const char* msg = msgStringG.c_str();
vw_send((uint8_t *)msg,strlen(msg));
Serial.println(« envoyé »);
}
elseif( cm3 >= 115 ){
msgStringG = « 0 »;
}
delay(200);
}
Code de la carte Arduino UNO réceptrice:
#include <VirtualWire.h>
/*
* SPI et MFRC522 sont deux bibliothèques qui permettent la gestion
* du lecteur RFID
*/
#include <SPI.h>
#include <MFRC522.h>
//configuration des pins du lecteur RFID
#define RST_PIN 9
#define SS_PIN 10
//on créer une instance MFRC522
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
// instanciation et déclaration des variables utiles par la suite
String instruments[]={« piano », « trompette », « batterie »,« coeur »,« piano2 »};
int i = 0;
char ASCII[128];
void setup(){
// on créer un tableau de 128 char correspondant à 128 caractères du code ASCII
for(int i = 0; i<33 ; i++){
ASCII[i]= ‘ ‘;
}
ASCII[47]= ‘/’;
ASCII[58]= ‘:’;
ASCII[59]= ‘;’;
ASCII[60]= ‘<‘;
ASCII[61]= ‘=’;
ASCII[62]= ‘>’;
ASCII[63]= ‘?’;
ASCII[64]= ‘@’;
ASCII[65]= ‘A’;
ASCII[66]= ‘B’;
ASCII[67]= ‘C’;
ASCII[68]= ‘D’;
ASCII[69]= ‘E’;
ASCII[70]= ‘F’;
ASCII[71]= ‘G’;
ASCII[72]= ‘H’;
ASCII[91]= ‘[‘;
ASCII[92]= ‘ ‘;
ASCII[93]= ‘]’;
ASCII[94]= ‘^’;
ASCII[95]= ‘_’;
ASCII[96]= ‘ ‘;
ASCII[97]= ‘a’;
ASCII[98]= ‘b’;
ASCII[99]= ‘c’;
ASCII[100]= ‘d’;
ASCII[101]= ‘e’;
ASCII[102]= ‘f’;
ASCII[103]= ‘g’;
ASCII[104]= ‘h’;
ASCII[123]= ‘{‘;
ASCII[124]= ‘|’;
ASCII[125]= ‘}’;
ASCII[126]= ‘~’;
ASCII[127]= ‘ ‘;
// initialisation de la communication en série (USB)
Serial.begin(9600);
Serial.println(« setup reciever »);
// initialisation du récepteur radio
vw_setup(2000);
vw_set_rx_pin(2);
vw_rx_start();
//initialisation du lecteur RFID
SPI.begin();
mfrc522.PCD_Init();
}
void loop(){
//définition de la variable dans laquelle sera stocké le message reçu
uint8_t buf[VW_MAX_MESSAGE_LEN];
// longueur du message maximal pouvant être reçu
uint8_t buflen = VW_MAX_MESSAGE_LEN;
// si une carte est présente, on pioche dans la liste des instruments et on transmet cette information via le port série
if( mfrc522.PICC_IsNewCardPresent()){
Serial.println(instruments[i%5]);
i++;
}
// si réception du message, on le lit et on le transmet via le port série
if(vw_get_message(buf,&buflen))
{
int i;
// Message with a good checksum received, dump HEX
for(i = 0; i < buflen; i++)
{
Serial.println(ASCII[buf[i]]);
}
}
}
Sauvons l’iceberg
This project, in partnership with the European School of Arts of Britain (l’Ecole Européenne Supérieure d’Arts de Bretagne – EESAB), was carried out under the 2016 Inter-semester FabLab Telecom Bretagne. The group consisted of Maxime BEAU, Lucie MANDRAS, Van Duong NGUYEN, Farah BRAITEH and Change YEE LEONG
Description of the project
This project introduces the concept of “Global Warming” to primary school students in a model that helps them understand the effect of climate changes on icebergs.
Global warming is the gradual increase in the average temperature of the Earth’s atmosphere, a change that is believed to be permanently changing the Earth’s climate, resulting in the melting of icebergs. Since this change is considered as a great humanitarian crisis of our time, it is important to explain the phenomenon of global warming and simulate it in a model. So, students can see how icebergs melt as a result.
Necessary material
To construct the model, the following equipment are needed:
- 1 Arduino
- 4 continous servo 3 SM-S4303R
- 3 photoresistors
- Textile, PVC
- Wood
Overview
Firstly, three groups of rectangle will be placed under the textile representing the iceberg. A motor is then placed under each group of tubes to either lift the tubes up or set them down. The tubes under the textile, aka the iceberg, will rise to a certain level depending on the intensity of light detected by the photo sensors. Each motor is affected by one photo sensor.
Secondly, a lamp will be used for testing. This lamp emits light, so it represents the increase of temperature in real life. As the light intensity increases, aka the global temperature, the photo sensor will detect a higher light intensity, and the motors will move to set the tubes down, aka the iceberg. By this, the student can understand that the icebergs are melting when the temperature is increasing.
When the lamp is switched off, less light will be detected, and the motors will rotate in the opposite direction to lift the tubes upward. This is important for testing purposes in order to set the model back to its original state, and in cases when the teacher wants to repeat the experiment. Furthermore, the student can understand that when there is no increase in the temperature, the icebergs will remain intact.
The switch will change the state of the lamp: ON/OFF, and the Arduino will control the circuit.
Implementation
The mechanical system is basically a rack and pinon lifting system. We use the pinion of SM-S4303R and use the 3D printer to print the corresponding rack
The rack is attached to the platform of iceberg model, which will lift up/down the iceberg model.
The 3 light sensors is set to detect different source of light, the environment/room, and 2 lamps.
As the light sensors detect enough light intensity (pre-set in the embedded code after experimented), the LED will be lighted up. The system is controlled via an Arduino UNO board.
Product
The product of the project is shown in the figure below:
Annexe
Ardruino code:
#include <Servo.h>
Servo myservo1; // create servo object to control a servo
Servo myservo2;
Servo myservo3;
// twelve servo objects can be created on most boardsconst int servo1Up = 30;
const int servo1Down = 150;
const int servo2Up = 150;
const int servo2Down = 20;
const int servo3Up = 150;
const int servo3Down = 30;
const int countThresh = 4;
const int thresh1 = 700;
const int thresh2 = 800;
const int thresh3 = 800;
const int delayTimeUp = 700;
const int delayTimeDown = 500;
const int ledPin = 13;
const int luminosityPin1 = A0;
const int luminosityPin2 = A1;
const int luminosityPin3 = A2;
int pos = 0; // variable to store the servo position
int count1 = 0;
int count2 = 0;
int count3 = 0;
void setup() {
myservo1.attach(9); // attaches the servo on pin 9 to the servo object
myservo2.attach(10);
myservo3.attach(11);
// Initialise la communication avec l’ordinateur
Serial.begin(9600);
// Indique que la broche de la LED est une sortie
pinMode(ledPin, OUTPUT);}
void loop() {
int sensorValue1 =0;
int sensorValue2 =0;
int sensorValue3 =0;
sensorValue1 = analogRead(luminosityPin1);
sensorValue2 = analogRead(luminosityPin2);
sensorValue3 = analogRead(luminosityPin3);
Serial.print(« photo capture1: « );
Serial.print(sensorValue1);
Serial.print(« photo capture2: « );
Serial.print(sensorValue2);
Serial.print(« photo capture3: « );
Serial.print(sensorValue3);
Serial.print(« count: « );
Serial.print(count2);
Serial.print(« \n »);
if ((sensorValue2 > thresh2) && (count2 < countThresh))
{
myservo2.write(servo2Up);
delay(delayTimeUp);
count2 = count2 + 1;
myservo2.write(95);
delay(500);
};
if ((sensorValue2 < thresh2) && (count2 > 0))
{
myservo2.write(servo2Down);
delay(delayTimeDown);
count2 = count2 – 1;
myservo2.write(96);
delay(500);
} ;if ((sensorValue3 > thresh3) && (count3 < countThresh))
{
myservo3.write(servo3Up);
delay(delayTimeUp);
count3 = count3 + 1;
myservo3.write(95);
delay(500);
};
if ((sensorValue3 < thresh3) && (count3 > 0))
{
myservo3.write(servo3Down);
delay(delayTimeDown);
count3 = count3 – 1;
myservo3.write(96);
delay(500);
} ;if ((sensorValue1 > thresh1) && (count1 < countThresh))
{
myservo1.write(servo1Up);
delay(delayTimeUp);
count1 = count1 + 1;
myservo1.write(89);
delay(500);
};
if ((sensorValue1 < thresh1) && (count1 > 0))
{
myservo1.write(servo1Down);
delay(delayTimeDown);
count1 = count1 – 1;
myservo1.write(89);
delay(500);
} ;
}
Noï: La balance à additions
Dans le cadre de l’intersemestre en partenariat avec l’Ecole Européenne Supérieure d’Arts de Bretagne (EESAB), nous devions développer un objet connecté pédagogique pour les enfants.
Nous avons décidé de construire une pyramide capable de générer un nombre aléatoire et, à l’aide de palets qui posséderaient chacun une valeur comprise entre 1 et 9, l’élève les ajouteraient afin d’atteindre le nombre demandé.
Pour ce faire il a fallu utiliser un afficheur deux digits TLG367 accompagné de deux circuits intégrés permettant de convertir un numéro entre 0 et 9 codé sur 4 bits en signaux adapté pour l’afficheur. Pour gérer cela, et surtout afin de minimiser le nombre de sortie utilisées sur la carte arduino il a fallu utilisé un registre à décalage afin d’implémenter les circuits intégrés.
Voici la fonction qui permet de générer un nombre aléatoire et de l’envoyer sur l’afficheur:
int generaterandomnumber ()
{
digitalWrite(RST,LOW);
delay(10);
digitalWrite(RST,HIGH);
int x = (int) random(10,45);
//int x = (int) randomSeed(analogRead(A0));
int dizx = (int) x/10;
int unitx = x-dizx*10;
for (int i=0;i<4;i++)
{
digitalWrite (mult,digital_tab[dizx][i]);
delay(1);
digitalWrite (clk,1);
delay(1);
digitalWrite (clk,0);
}
for (int j=0;j<4;j++)
{
digitalWrite (mult,digital_tab[unitx][j]);
delay(1);
digitalWrite (clk,1);
delay(1);
digitalWrite (clk,0);
}
return x;
}
Il étais important de faire un reset au début sans quoi l’afficheur risquais de ne pas allumer certaines branches à cause de signaux parasites résiduels.
L’autre difficulté toujours pas résolue, fut le capteur de poids (photo ci dessous). En effet ce capteur possède donc quatre fils ce qui implique une récupération de la tension de variation entre deux d’entre eux, seulement la tension de variation est très faible (quelques mV à peine) ce qui n’est pas suffisant pour arduino (pas de 4.1 mV à peu près) il fallait donc en plus de récupérer la tension, l’amplifier. Mais nous n’avons pas réussi à amplifier les variations, seul l’offset s’amplifiais.
Ce projet a été une très bonne expérience et bien qu’il ne soit pas complètement fini pour l’instant il a été très instructif et formateur. La dimension du travail mixte entre les deux groupes (télécom Bretagne & l’EESAB) fut très différent de ce qu’on a l’habitude de faire à Télécom pour notre plus grand bonheur !!
Snakes. Why did it has to be snakes?
Pour concocter la recette de la soupe aux caillloux, il vous faudra:
i) Une matrice de LEDs Sure electronics 11151-114V120 16*32
ii) Deux cartes Arduino Uno
iii) Trois fois rien.
iv) Quatre résistances de 1MΩ
v) Un bouquet (final) de fils de toutes les couleurs.
La communication série entre la manette maître et la carte Arduino associée à la matrice de LEDs est assurée par la librairie SoftwareSerial.
De plus, la manette simule le fonctionnement d’un MakeyMakey (cf http://telefab.fr/2013/01/08/comment-faire-un-makey-makey-avec-un-arduino/)
Voici quelques schémas de fonctionnement et de connectique pour vous épauler dans la tâche.
La communication entre manette et la carte de la matrice.
Le pseudo-MakeyMakey à l’aide d’une carte Arduino Uno
Comment connecter la matrice de LEDs?
Les codes Arduino ainsi que les librairies nécessaires sont dénichables ici : https://github.com/Wyllich/SnakeGame-Arduino-LedMatrix-/tree/master
Wyllich
Calendrier météo interactif : MétéoRoom
Ce projet, en partenariat avec l’Ecole Européenne Supérieure d’Arts de Bretagne, a été réalisé dans le cadre de l’inter-semestre 2016 au FabLab de Télécom Bretagne. Le groupe était composé de Ludovic AZEVANE, Alicia LE ROUX, Léna MARI, Clara CATANESE, Amélie GAUTREAU.
Descriptif du projet
Le but du projet est de proposer un tableau interactif sur lequel des enfants auraient la possibilité de positionner de petits panneaux en bois. Ceux-ci portent les inscriptions des jours, mois, années, ainsi que les différentes saisons et la météo. Les panneaux « météos » sont reconnus par le support de base grâce à des tags et un lecteur RFID. Ceci engendre une réaction sur un mini-théâtre : à chaque panneau « météo » correspond un ou plusieurs rideaux spécifiques qui vont se dérouler ou s’enrouler.
Prototype du calendrier météo
Matériel nécessaire
- 2 cartes Arduino Uno
- 5 servomoteurs
- 5 microrupteurs
- Lecteur de tag RFID RC522
- Tags RFID
- Panneaux de bois
- Crochets
Description du fonctionnement général
Pour réaliser le prototype, on utilise 2 cartes Arduino Uno. La première, « le maître », est destinée à la lecture et à l’identification des différents panneaux météo à l’aide du lecteur de tags RFID. La seconde carte, « l’esclave », gère l’ensemble des 5 servomoteurs ainsi que les 5 microrupteurs.
Fonctionnement du lecteur RFID
Branchement du lecteur RFID sur la carte Arduino Uno
Pour permettre la communication entre la carte Arduino et le lecteur RFID, nous avons utilisé la librairie AddicoreRFID.
C’est grâce à ce système que le système reconnaît les différents panneaux « météo », et que les rideaux sont ouverts ou fermés en fonction de ceux-ci.
Mise en série de deux Arduino
Pour réaliser la connexion entre les deux cartes Arduino, nous avons utilisé le protocole I2C (Inter Integrated Circuit). Ce protocole permet de faire parvenir les informations, et plus exactement l’identification des différents tags RFID, vers l’Arduino pilotant les moteurs. La librairie Wire permet de communiquer avec ce protocole.
Branchement en série des deux cartes Arduino
Branchement des servomoteurs
Pour contrôler les 5 servomoteurs, nous avons utilisé la librairie Servo. Pour alimenter l’ensemble des moteurs, nous avons ajouté une alimentation externe de 5V.
KiTo
Descriptif du projet
Notre projet s’inscrit dans le cadre de l’intersemestre FABLAB & DESIGN en partenariat avec l’Ecole des Beaux Arts de Brest ( EESAB). Le groupe était composé de cinq membres, dont deux élèves de Telecom Bretagne ( Toufik Amarouch, AIT SIDI ALI EL Mahdi ) et trois de l’EESAB ( Théo Desprez , Ziran Lin et Mohamed Ait Oual). Le thème général du projet était l’intégration du numérique dans l’école primaire, alors on a été appelé à créer un jeu ludique pour les enfants en introduisant le côté « numérique ».
KITO, Notre objet interactif, aide à développer les capacités de mémorisation chez les enfants. Il s’agit d’une boîte en bois avec un design spécial choisi par l’équipe, faisant apparaitre à gauche un petit écran sous forme d’une matrice de LEDs (de 7*5) et à droite un ensemble de trous et des petits bâtonnets à la disposition de l’enfant.
la forme finale du jeu réalisé
Le jeu est assez simple, il consiste à afficher des caractères ou des formes sur l’écran pendant une durée de 10 secondes puis laisser à l’enfant une durée de 1 minute max ( variable) pour reproduire son schéma sur le cadre des trous qui ont la même disposition que les LEDs, en appuyant à l’aide des bâtonnets sur les boutons ( un bouton en dessous de chaque trou), après avoir fait correctement son schéma, une LED verte s’allume pour le lui confirmer qu’il a bien réalisé la tâche.
Matériel électronique nécessaire
-Carte arduino Mega 2560
-matrice de LEDs (7*5)
-2 breadboards
– 4 registres de décalage SN74HC165N
-35 boutons poussoirs (montés sur une plaque sous forme de matrice)
-35 résistances 10kOhm (pour la matrice des boutons poussoirs)
-LED
-Fils
Niveau technique
Ce projet était une occasion pour mettre en œuvre ses compétences dans différents domaines et surtout en ce que concerne l’aspect coopératif du travail et la recherche des solutions technique.
Le problème principal, que nous avons rencontré, était d’imaginer une façon simple et interactive pour entrer les données de l’enfant : reproduire le caractère. A cet égard, nous avons pensé à des boutons à appuyer. Alors, puisque on ne disposait pas d’une matrice des boutons poussoir pour l’acquisition, nous avons créé la nôtre (la soudure était bien sûr présente). Chaque bouton doit être lié à sa résistance pour éviter les courts-circuits par la suite. Le principe est que chaque bouton contrôle une led, le but ici n’était pas d’allumer la led une fois on clique sur le bouton, mais plutôt changer l’état de la led de manière analogique, et mémoriser l’état sur la carte Arduino pour faire la comparaison du caractère saisi par l’enfant, après qu’il a fini d’appuyer avec les bâtonnets, et le caractère affiché au début.
Le deuxième défi était de gérer les câblages entre l’Arduino Mega, le breadboard et la matrice des boutons poussoir. Pour cela, l’utilisation des registres de décalage, pour lier les deux derniers, était nécessaire et bien sûr efficace, elle nous aussi a facilité la tâche au niveau de la programmation.
phase montage: carte Arduino, matrice boutons poussoir et les breadboards
Sauvons l’iceberg
This project introduces the concept of “Global Warming” to primary school students in a model that helps them understand the effect of climate changes on icebergs.
Global warming is the gradual increase in the average temperature of the Earth’s atmosphere, a change that is believed to be permanently changing the Earth’s climate, resulting in the melting of icebergs. Since this change is considered as a great humanitarian crisis of our time, it is important to explain the phenomenon of global warming and simulate it in a model. So, students can see how icebergs melt as a result.
To construct the model, the following equipment are needed:
• lamp
• switch (BJT)
• 3 photo sensors
• 3 SV motors
• One Arduino
• Wooden Textile
• Small plastic tubes (around 9)
Firstly, three groups of plastic tubes will be placed under the wooden textile representing the iceberg. A motor is then placed under each group of tubes to either lift the tubes up or set them down. The tubes under the wooden textile, aka the iceberg, will rise to a certain level depending on the intensity of light detected by the photo sensors. Each motor is affected by one photo sensor.
Secondly, a lamp will be used for testing. This lamp emits light, so it represents the increase of temperature in real life. As the light intensity increases, aka the global temperature, the photo sensor will detect a higher light intensity, and the motors will move to set the tubes down, aka the iceberg. By this, the student can understand that the icebergs are melting when the temperature is increasing.
When the lamp is switched off, less light will be detected, and the motors will rotate in the opposite direction to lift the tubes upward. This is important for testing purposes in order to set the model back to its original state, and in cases when the teacher wants to repeat the experiment. Furthermore, the student can understand that when there is no increase in the temperature, the icebergs will remain intact.
The switch will change the state of the lamp: ON/OFF, and the Arduino will control the circuit.
Mission Morse
BLANCHARD Elisa
DE VERE CAMINO Tommy
LECROISEY Clara
LIN Jifa
MOGABURE Clémence
NAMMOUR Fadi
Notre projet dans le cadre de l’intersemestre « Fablab et design » est la création d’un jeu de communication en morse pour enfants. Le principe est simple : un premier enfant reçoit des combinaisons de caractères que l’autre enfant lui envoie, en morse, avec des messages lumineux et sonores. Ces combinaisons déterminent chaque pièce, leur position et leur orientation et permettent à l’enfant d’assembler des pièces dans une forme donnée. Une fois toutes les pièces correctement assemblées, les enfants reçoivent un message sur un écran LCD accompagné de signaux sonores et lumineux.
