Actualités Projets

Construction d’imprimantes 3D : la carte électronique

Envoyé par le 26 Jan 2017 dans À la une, Projets | 0 commentaire

Ce mardi, nous avons continué l’atelier de la semaine dernière. Nous n’arrivions pas à contrôler correctement l’imprimante A car certains moteurs fonctionnaient de manière inversée. Nous avons donc décidé de reflasher la carte pour changer les réglages.

La carte minitronics est compatible avec l’IDE Arduino. Le guide de construction indique le lien vers le dépôt Github qui contient le firmware (attention, nous avons la version 2.5 de la Foldarap). Il n’y a presque rien à changer, à part la fréquence de fonctionnement du port série dans un define. Par contre, il faut configurer l’IDE Arduino pour la carte Minitronics, en suivant les explications ici (à faire à la main, il y a un lien vers une version preconfigurée, mais on est forcé de s’inscrire).

Une fois la carte flashée, l’imprimante marche parfaitement. Malheureusement nous avons trop chauffé le filament qui s’est bloqué, il va donc falloir faire un peu de démontage pour nettoyer tout ça.

La suite dans 2 semaines

Exceptionnellement, aucun atelier n’est prévu la semaine prochaine. Le prochain atelier aura lieu mardi 7 février à 18h30. Et on fera marcher au moins une imprimante !

Atelier construction d’imprimantes 3D

Envoyé par le 17 Jan 2017 dans Projets | 0 commentaire

Au Téléfab, on a récupéré deux imprimantes 3D Foldarap en cours de construction, venant des Fabriques du Ponant. On en a profité pour faire ce soir un atelier pour essayer de les faire marcher. Voici l’état des lieux

Imprimante A

Une première imprimante 3D est quasiment terminée. Tout est monté et assemblé, mais l’imprimante ne marche pas.

On a trouvé un soucis avec la carte : impossible de communiquer en utilisant Pronterface. Ça vaudrait le coût de tenter de reflasher la carte pour voir si elle peut ressusciter.

Après avoir remplacé la carte, tous les actionneurs semblent marcher. Mais certains axes sont inversés, et on dirait aussi que les end points sont lus à l’envers (activé quand ils le sont pas). Il va donc falloir vérifier les branchements et voir ce qu’on peut corriger en logiciel.

Imprimante B

La deuxième imprimante est bien moins avancée. Elle est en partie montée et des choses sont à démonter car elles ont été faites à l’envers.

On a aussi découvert que le support de la tête d’impression est cassé. On a donc lancé l’impression d’une nouvelle pièce. Ça nous a permis de retrouver les sources des pièces 3D (rechercher github dans le guide d’assemblage).

La suite mardi prochain

On continuera mardi prochain à partir de 18h30. Venez nous aider !

Robot Scribe

Envoyé par le 21 Juin 2016 dans À la une, Portfolio, Projets | 1 commentaire

Dans le cadre de notre projet développement S2, nous devions concevoir un robot capable d’écrire des caractères avec un stylo, facile à utiliser et à moindre coût.
Nous avons pour cela décidé de construire un robot commandé par une application Android qui envoie par Bluetooth les caractères à écrire.
Notre robot est constitué d’un moteur et un train d’imprimante récupérés sur une vieille imprimante, 3 servomoteurs, une carte Arduino, une carte Ardumoto et des pièces pour relier le tout, imprimées à l’aide d’une imprimante 3D. Les pièces imprimées sont : les broches (qui constituent le bras du robot et qui servent à tenir le stylo) et la plate-forme pour relier le train d’imprimante et le bras. Le train d’imprimante va servir à translater le montage lorsqu’on a fini d’écrire un caractère. Deux des servomoteurs sont utilisés pour contrôler les broches qui tiennent le stylo et le troisième sert à soulever la plate-forme lorsque l’on veut déplacer le crayon sans écrire.

13396615_290379581305988_1911664267_o

Le principe de notre robot consiste donc à envoyer des caractères en Bluetooth à partir de l’application et d’effectuer un traitement avec un code Arduino en fonction de la lettre reçue. À La réception d’un caractère, nous allons donc baisser le crayon, écrire le lettre reçue, lever le crayon et déplacer le dispositif avec le train d’imprimante pour écrire la prochaine lettre.
Cependant, les lettres écrites avec le robot sont très grandes car les servomoteurs ne sont pas assez précis donc on ne peut pas écrire des lettres de la taille de lettres manuscrites. Pour améliorer notre robot il faudrait donc utiliser des servomoteurs plus précis.

 

Code Arduino

#include <Servo.h>
#include <string.h>

Servo myservo1; //servo de gauche
Servo myservo2; //servo de droite
Servo myservo3; //servo qui soulève le crayon
#include <SoftwareSerial.h>

double pi = 3.141592654;

int bluetoothTx = 0;  // on branche le TX du bluetooth à la broche 0 de l’arduino
int bluetoothRx = 1;  // on branche le RX du bluetooth à la broche 1 de l’arduino

double distance = 9;
double angle_depart1 = 180;
double angle_depart2 = 90;
double l1 = 10;
double l2 = 12.5;

SoftwareSerial bluetooth(bluetoothTx, bluetoothRx);

#define CW  0
#define CCW 1
#define MOTOR_A 0

// constantes utilisées par Ardumoto : ne pas les changer!
const byte PWMA = 3;  // la broche 3 est utilisée pour la puissance du moteur du train d’imprimante
const byte DIRA = 12; // la broche 12 est utilisée pour la direction

void setup() {
Serial.begin(9600);  // Begin the serial monitor at 9600bps
//Setup bluetooth
delay(100);  // Short delay, wait for the Mate to send back CMD
bluetooth.begin(9600);  // Start bluetooth serial at 9600

//Setup servo
myservo1.attach(5);  // attaches the servo on pin 9 to the servo object
myservo2.attach(9);
myservo3.attach(2);
Serial.println(« initialisation »);
myservo1.write(0);
myservo2.write(0);
myservo3.write(0);

//Setup Ardumoto
setupArdumoto();
stopArdumoto();
}

void loop()
{
if (bluetooth.available()) // A la réception d’un caractère
{
char text = (char)bluetooth.read();
Serial.print(« text = « );Serial.println(text);
bluetooth.print(text);
myservo3.write(20);
ecrire(text);
myservo3.write(20);
myservo1.write(0);
myservo2.write(0);

driveArdumoto(CCW, 150); // On translate le moteur
delay(100);             // pendant 100 ms
stopArdumoto();         // et on le stoppe

}
}

void ecrire(char lettre)
{
if (lettre == ‘a’){
aller_en(-5.5,7);
myservo3.write(0);
aller_en(0,15.5);
aller_en(5.5,7);
aller_en(2.5,11.5);
aller_en(-2.5,11.5);
}
if (lettre == ‘b’){
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
aller_en(-5,12);
aller_en(5,12);
aller_en(-5,12);
aller_en(-5,7);
}
if (lettre == ‘c’){
aller_en(-5,7);
myservo3.write(0);
aller_en(5,7);
aller_en(5,17);
aller_en(-5,17);
}
if (lettre == ‘d’){
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
aller_en(-5,7);
}
if (lettre == ‘e’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(5,7);
aller_en(5,17);
aller_en(-5,17);
myservo3.write(20);
aller_en(5,12);
myservo3.write(0);
aller_en(-5,12);
}
if (lettre == ‘f’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
myservo3.write(20);
aller_en(5,12);
myservo3.write(0);
aller_en(-5,12);
}
if (lettre == ‘g’) {
aller_en(-5,17);
myservo3.write(0);
aller_en(5,17);
aller_en(5,7);
aller_en(-5,7);
aller_en(-5,12);
aller_en(0,12);
}
if (lettre == ‘h’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(-5,17);
myservo3.write(20);
aller_en(-5,12);
myservo3.write(0);
aller_en(5,12);
myservo3.write(20);
aller_en(5,7);
myservo3.write(0);
}
if (lettre == ‘i’) {
aller_en(0,7);
myservo3.write(0);
aller_en(0,17);
}
if (lettre == ‘j’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(0,7);
aller_en(0,17);
}
if (lettre == ‘k’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
myservo3.write(20);
aller_en(5,12);
myservo3.write(0);
aller_en(-5,17);
myservo3.write(20);
aller_en(5,12);
myservo3.write(0);
aller_en(-5,7);
}
if (lettre == ‘l’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(5,7);
aller_en(5,17);
}
if (lettre == ‘m’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(-5,17);
aller_en(0,12);
aller_en(5,17);
aller_en(5,7);
}
if (lettre == ‘n’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,7);
aller_en(-5,17);
}
if (lettre == ‘o’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
aller_en(-5,7);
}
if (lettre == ‘p’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
aller_en(-5,12);
aller_en(5,12);
}
if (lettre == ‘q’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
aller_en(-5,7);
myservo3.write(20);
aller_en(0,12);
myservo3.write(0);
aller_en(-10,2);
}
if (lettre == ‘r’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
aller_en(-5,12);
aller_en(5,12);
aller_en(5,7);
}
if (lettre == ‘s’) {
aller_en(5,7);
myservo3.write(0);
aller_en(-5,7);
aller_en(-5,12);
aller_en(5,12);
aller_en(5,17);
aller_en(-5,17);
}
if (lettre == ‘t’) {
aller_en(0,7);
myservo3.write(0);
aller_en(0,17);
myservo3.write(20);
aller_en(5,17);
myservo3.write(0);
aller_en(-5,17);
}
if (lettre == ‘u’) {
aller_en(5,17);
myservo3.write(0);
aller_en(5,7);
aller_en(-5,7);
aller_en(-5,17);
}
if (lettre == ‘v’) {
aller_en(5,17);
myservo3.write(0);
aller_en(0,7);
aller_en(-5,17);
}
if (lettre == ‘w’) {
aller_en(5,17);
myservo3.write(0);
aller_en(2.5,7);
aller_en(0,12);
aller_en(-2.5,7);
aller_en(-5,17);
}
if (lettre == ‘x’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(5,17);
myservo3.write(20);
aller_en(-5,17);
myservo3.write(0);
aller_en(5,7);
}
if (lettre == ‘y’) {
aller_en(0,7);
myservo3.write(0);
aller_en(0,12);
aller_en(-5,17);
myservo3.write(20);
aller_en(0,12);
myservo3.write(0);
aller_en(5,17);
}
if (lettre == ‘z’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(5,7);
aller_en(-5,17);
aller_en(5,17);
}
if (lettre == ‘0’) {
aller_en(5,7);
myservo3.write(0);
aller_en(5,17);
aller_en(-5,17);
aller_en(-5,7);
}
if (lettre == ‘1’) {
aller_en(0,7);
myservo3.write(0);
aller_en(0,17);
aller_en(-5,12);
}
if (lettre == ‘2’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(5,7);
aller_en(-5,12);
aller_en(-5,17);
aller_en(5,17);
aller_en(5,12);
}
if (lettre == ‘3’) {
aller_en(5,7);
myservo3.write(0);
aller_en(-5,7);
aller_en(-5,12);
aller_en(5,12);
myservo3.write(20);
aller_en(-5,12);
myservo3.write(0);
aller_en(-5,17);
aller_en(5,17);
}
if (lettre == ‘4’) {
aller_en(0,7);
myservo3.write(0);
aller_en(0,17);
aller_en(5,12);
aller_en(-5,12);
}
if (lettre == ‘5’) {
aller_en(5,12);
myservo3.write(0);
aller_en(5,7);
aller_en(-5,7);
aller_en(-5,12);
aller_en(5,17);
aller_en(-5,17);
}
if (lettre == ‘6’) {
aller_en(-5,17);
myservo3.write(0);
aller_en(5,17);
aller_en(5,7);
aller_en(-5,7);
aller_en(-5,12);
aller_en(5,12);
}
if (lettre == ‘7’) {
aller_en(5,7);
myservo3.write(0);
aller_en(-5,17);
aller_en(5,17);
}
if (lettre == ‘8’) {
aller_en(-5,7);
myservo3.write(0);
aller_en(5,7);
aller_en(5,12);
aller_en(-5,12);
aller_en(-5,17);
aller_en(5,17);
aller_en(5,12);
aller_en(-5,12);
aller_en(-5,7);
}
if (lettre == ‘9’) {
aller_en(5,7);
myservo3.write(0);
aller_en(-5,7);
aller_en(-5,17);
aller_en(5,17);
aller_en(5,12);
aller_en(-5,12);
}
else{
Serial.println(« mauvais caractère »);
bluetooth.print(« mauvais caractère »);
}
}

double angle1(double alpha){
double resultat = angle_depart1 – alpha;
return resultat;
}

double angle2(double alpha){
double resultat = angle_depart2 – alpha;
return resultat;
}

void aller_en(double x,double y){
double gamma1 = (atan2(y,x+distance/2))*(180/pi);
double c1 = sqrt(y*y + (x+distance/2)*(x+distance/2));
double truc = (l1*l1 + c1*c1 – l2*l2)/(2*l1*c1);
double beta1 = (180/pi)*acos(truc);
double alpha1 = beta1 + gamma1;
double gamma2 = (atan2(y,x-distance/2))*(180/pi);
double c2 = sqrt(y*y + (x-distance/2)*(x-distance/2));
double beta2 = (acos((l1*l1 + c2*c2 – l2*l2)/(2*l1*c2)))*(180/pi);
double alpha2 = gamma2 – beta2;
Serial.print(« le servo de gauche va a « );Serial.print(alpha1);Serial.println( » degrés »);
myservo1.write(angle1(alpha1));
Serial.print(« le servo de droite va a « );Serial.print(alpha2);Serial.println( » degrés »);
myservo2.write(angle2(alpha2));
delay(1000);
}

// driveArdumoto drives ‘motor’ in ‘dir’ direction at ‘spd’ speed
void driveArdumoto(byte dir, byte spd)
{
digitalWrite(DIRA, dir);
analogWrite(PWMA, spd);
}

// stopArdumoto makes a motor stop
void stopArdumoto()
{
driveArdumoto(0, 0);
}

// setupArdumoto initialize all pins
void setupArdumoto()
{
// All pins should be setup as outputs:
pinMode(PWMA, OUTPUT);
pinMode(DIRA, OUTPUT);

// Initialize all pins as low:
digitalWrite(PWMA, LOW);
digitalWrite(DIRA, LOW);
}

Projet développement :Braille pour grimpeur

Envoyé par le 21 Juin 2016 dans À la une, Portfolio, Projets | 0 commentaire

BEDETTI Corto

BLANCHARD Elisa

MASSOT Guillemette

 

Le but de notre projet développement est de faciliter la pratique de l’escalade pour les personnes déficientes visuelles. Afin de leur permettre d’avoir une première appréhension des prises pour une voie donnée, nous avons réalisé une maquette 3D représentant leur position et leurs formes.

Dans un premier temps, nous nous sommes intéressés aux moyens à mettre en œuvre pour acquérir les données sur les prises, c’est-à-dire leur position, leur couleur ainsi que leur forme. Nous avons réalisé des traitements sur l’image 2D grâce à un programme Python, afin de ne garder que les prises d’une même couleur.

 

Pour que ce traitement soit plus précis, en évitant par exemple les erreurs dues aux traces laissées par d’anciennes prises ; nous avons rajouté une correction manuelle, pour ajouter ou supprimer des prises. Nous avons ainsi obtenu une image contenant uniquement les prises d’une même couleur, c’est-à-dire les prises formant une voie d’escalade.

Image obtenue après traitement de la voir bleue

Image obtenue après traitement de la voir bleue

Suppression d'une prise parasite

Suppression manuelle d’une prise parasite

 

La voie ainsi reconstruite, nous avons converti l’image en un fichier compatible avec l’imprimante 3D, et avons distingué les prises du fond en faisant varier l’épaisseur d’impression.

Maquette 3D de la voie bleue

Maquette 3D de la voie bleue

Enfin nous avons réalisé une interface permettant de reproduire automatiquement le même traitement en se basant sur une photo. Une fois la photo chargée dans l’interface, l’utilisateur sélectionne une prise. L’interface distingue ensuite automatiquement toutes les prises de cette couleur pour reconstituer la voie. L’interface est accompagnée d’une fiche d’explication donnant quelques conseils concernant l’acquisition des données, afin d’avoir un traitement optimal.

L’interface nous permet de récupérer les données RGB (triplet de couleur) d’un point sélectionné sur la prise. On définit ensuite un seuil de tolérance, ainsi on ne conserve que les pixels dont les données RGB appartiennent à l’intervalle [valeur initiale – seuil; valeur initiale + seuil]. On ajoute une bande sur l’image pour que les personnes déficientes visuelles puissent repérer le haut de la maquette.

L’interface manuelle permet d’ajouter ou de supprimer des prises. Le programme rajoute un carré respectivement de la couleur de la voie ou noir à l’endroit où l’on clique.

Lien pour les codes : https://github.com/GuillemetteMassot/Interface

Projet Ligne Bleue

Envoyé par le 21 Juin 2016 dans À la une, Portfolio, Projets | 0 commentaire

Ce projet a été réalisé dans le cadre du projet développement, qui a eu lieu lors du second semestre.

 

Descriptif du projet :

En 1680, la ville de Brest a été fortifiée. Les remparts ont été entièrement démolis après-guerre, mais il est possible de deviner leurs formes en observant une carte de la ville. Gwenaëlle Magadur, artiste peintre plasticienne, propose donc à la ville de redessiner leurs formes et en juin 2000, une ligne bleue est tracée à même le sol. Notre projet consiste en la réalisation d’une application Android qui doit permettre à un utilisateur de visualiser du contenu visuel et textuel, une photographie et un poème par exemple. En lançant l’application, l’utilisateur se verra proposer une balade dans le vieux Brest.

 

Cadre de travail :

Nous avons choisi de travailler sur une carte de la ville de Brest sur laquelle nous avons modélisé la ligne bleue par un trait fin de la même couleur. En raison de l’intégration des services Google, nous avons décidé de travailler avec une carte GoogleMap. Afin de signaler la présence de contenu, des marqueurs interactifs ont été déposés le long de la ligne. Lorsque que l’utilisateur clique sur un marqueur, il sera redirigé vers le contenu correspondant.

 

 

Séquence d’utilisation :

Premièrement, l’utilisateur démarre l’application, il accède à la page d’accueil. Lorsqu’il clique sur Accéder à la carte, il arrive sur le layout de la 2ème figure, enfin il sélectionne un marqueur en cliquant dessus et accède au layout de la dernière activité, la SwipeActivity. Cette activité présente une photo statique en haut de l’écran et un texte scrollable en dessous : au glissement de doigt vertical, le texte défile sous l’image sans modifier celle-ci. Lors d’un glissement horizontal, les entités image et texte changent.

 

dev1

 

 

Stockage des données :

Nous stockons le contenu multimédia dans un serveur web et identifions les caractéristiques de ce contenu dans une base de données.  Lorsque l’application Android souhaite accéder à un certain contenu multimédia, elle transfère donc au serveur web une clé. Cette clé est transmise à la base de données, qui identifie quelle image le serveur web doit envoyer au client Android.

 

 

Ce qui reste à améliorer :

Plusieurs évolutions restent envisageables. L’application pourrait guider l’utilisateur jusqu’à la ligne bleue, grâce à un itinéraire fourni par Google. Il serait également possible que les utilisateurs laissent leurs avis sur l’application ou déposent du contenu eux-mêmes, éventuellement validé par l’artiste avant d’être mis à la disposition de tous. Enfin, il pourrait être intéressant de créer une interface d’ajout de contenu pour l’artiste, afin de faciliter l’entrée de données qui se fait actuellement directement dans la base de données.

Communiquer par la lumière

Envoyé par le 21 Juin 2016 dans À la une, Portfolio, Projets | 0 commentaire

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.20160607_231755Sans titrecode :

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

Envoyé par le 20 Juin 2016 dans À la une, Applications Android, Portfolio, Projets | 0 commentaire

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.

IMG_20160127_103626

 

 

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.

IMG_20160128_175641

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.

Résumé atelier

Projet développement: L’escalier musical

Envoyé par le 20 Juin 2016 dans À la une, Portfolio, Projets | 0 commentaire

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.

 

Photo escalier musicalL’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:

Schéma 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

Envoyé par le 11 Fév 2016 dans À la une, Portfolio, Projets | 0 commentaire

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.

WP_20160129_13_13_35_Pro

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

Capture

The rack is attached to the platform of iceberg model, which will lift up/down the iceberg model.

Untitled

The 3 light sensors is set to detect different source of light, the environment/room, and 2 lamps.

Untitled

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:

Untitled

 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 boards

const 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);
} ;
}

(suite…)

Noï: La balance à additions

Envoyé par le 11 Fév 2016 dans À la une, Blog, Portfolio, Projets | 0 commentaire

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 !!