Actualités Projets

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

Snakes. Why did it has to be snakes?

Envoyé par le 30 Jan 2016 dans À la une, Portfolio, Projets | 0 commentaire

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.

 

softwareSerial

La communication entre manette et la carte de la matrice.

 

 

controller

Le pseudo-MakeyMakey à l’aide d’une carte Arduino Uno

 

 

connecticsLedMatrix connecticsLedMatrix2

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

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

                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

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.

Arduino en série

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

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

 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.

 

12001_862689680510641_7642264639741332596_n

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.

 

12642531_862689570510652_7640177781821668528_nmontage carte Arduino, matrice des boutons et breadboards

phase  montage: carte Arduino, matrice boutons poussoir et les breadboards

Sauvons l’iceberg

Envoyé par le 20 Jan 2016 dans Projets | 0 commentaire

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

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

BLANCHARD Elisa
DE VERE CAMINO Tommy
LECROISEY Clara
LIN Jifa
MOGABURE Clémence
NAMMOUR Fadi

 

logo mission morse

 

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.

(suite…)

Conception, fabrication d’une fraiseuse à commande numérique

Envoyé par le 4 Nov 2015 dans À la une, Portfolio, Projets | 0 commentaire

Conception, fabrication d’une fraiseuse à commande numérique


Depuis déjà quelques années, je souhaitais construire une machine multiaxes pour la commande numérique. Avec l’arrivée des imprimantes 3D dans le domaine des makers et du grand public, des projets open source ont vu le jour et il est devenu de plus en plus aisé de construire de toutes pièces ou en kit ce genre de matériel.

N’ayant pour expérience que celle acquise au FabLab de Telecom Bretagne, je partais d’une faible connaissance des machines multiaxes et en construire une demandais quand même quelques bases. Fin juillet 2015, le site hackaday publie un article sur la réalisation de [joekutz] : desktop sized CNC from hardware store : http://hackaday.com/2015/07/22/desktop-cnc-from-hardware-parts-really-makes-the-cut/. Ce post me donne alors l’envie de développer ma propre machine à commande numérique. Je peux alors profiter du retour d’expérience de [joekutz] pour me lancer dans l’aventure !


Réflexions sur la conception de la CNC

Je commence mon apprentissage par le visionnage des vidéos proposé par l’auteur. Plusieurs critères sont importants dans la réalisation de ce type de machine : la précision et la stabilité des éléments mobiles sont bien entendu les facteurs significatifs de la réalisation. [Joekutz] propose l’utilisation de coulisses de tiroir pour réaliser les guides des translations d’axes. J’ai également opté pour cette solution, certes coûteuse mais d’une rigidité plus qu’efficace lorsqu’on choisit les bonnes glissières. En effet, en fonction de la charge supporté par un tiroir, une glissière peut être composée d’une cage comportant jusqu’à 2 x 8 billes de roulement. Afin d’éviter un jeu excessif des parties mobiles, je choisi d’utiliser deux de ces coulisses par axe. D’autres solutions étaient également envisageables, notamment l’utilisation de stubs en acier rapide, ainsi que de roulements colinéaires mais dans un souci de facilité de conception j’ai choisi la première approche.

J’adopte également une bonne partie des éléments électromécaniques proposés par l’auteur de l’article, en particulier les moteurs NEMA17 pas à pas et les contrôleurs Big Easy Stepper Motor Driver, tous deux faciles à trouver sur les sites de vente en ligne habituels. C’est décidé, ma machine à commande numérique sera à plateau mobile, axe Z fixe en X et Y. Concernant le logiciel au cœur de la machine, j’ai découvert le fabuleux projet GRBL : https://github.com/grbl/grbl/wiki open source et dédié au contrôle des machines multiaxes. En quelques mots, GRBL se télécharge sur un Arduino Uno correctement câblé aux différents contrôleurs et actionneurs de la machine pour agir comme passerelle entre la réception des commandes envoyées par le PC et les moteurs. C’est un programme qui exploite au maximum les capacités de la carte et qui implémente des réglages utilisateur, des interruptions fin de course, la possibilité de travailler en métrique ISO ou Impériale, etc.


Développement de la maquette électromécanique

J’ai commandé toutes les pièces de la machine d’un coup afin de travailler sur mon projet sans délais entre deux fabrications. Une fois chaque élément reçu, j’ai cherché à développer un prototype de démonstration pour vérifier que le logiciel GRBL, dans sa version de base – uniquement avec les contrôleurs et les moteurs, échangeait correctement avec le matériel et l’ordinateur. J’ai ainsi construit un prototype avec la carte Arduino, les Big Easy Drivers et les NEMA17, l’alimentation à découpage et le convertisseur DC-DC. Une fois la démo montée, j’ai pu vérifier que chaque moteur répondait à la commande envoyée depuis le PC avec le langage Gcode. Pour éviter d’envoyer à la main chaque commande, j’ai téléchargé l’application GRBL Controler qui me permet de commander la machine depuis l’interface graphique.

prototype


Conception et fabrication de la machine

Une fois le fonctionnement de GRBL démontré sur la maquette, j’ai entamé la construction des parties mécaniques de la machine. Pour la structure de la machine j’ai choisi d’utiliser des panneaux de médium sous forme de chutes pour des contraintes de budget. Ce type de bois n’est pas optimal mais il a cependant l’avantage de se présenter sous forme de planches plus rigide que le contreplaqué de même épaisseur. J’ai donc acheté des chutes de MDF de 16 à 18 mm d’épaisseur. La base de la machine se compose de deux panneaux de 350 * 350 mm vissés entre eux. Dans la configuration adoptée, la base fixe indéniablement la taille maximale de traversée du plateau mobile en X et en Y. On disposera d’une surface au maximum 4 fois inférieure à la taille de la base, soit 350/2 * 350/2 mm.

Je monte ensuite ce qui devient l’axe X sur la base. Il se compose de deux glissières avec cage à roulements pour le guidage, d’une tige filetée de diamètre 8 mm pour l’avance linéique, ainsi qu’un roulement guide pour l’effort dans le sens de l’axe et le moteur pas à pas. Je commence par monter l’embase des glissières, préalablement découpées à 200 mm. Elles sont espacées de 100 mm et doivent être parfaitement parallèles pour éviter les efforts latéraux sur les billes. Pour faire, je commence par contraindre un seul côté des glissières à l’aide de vis à bois serrées. Cela me permet dans un premier temps de régler l’angle nul entre les deux bases avec un réglet. Dans un second temps, j’utilise un pied à coulisse numérique pour mesurer l’écart relatif de part et d’autre de la base des coulisses. Une fois que le réglage est fait, j’obtiens moins de 5/100 mm d’écart entre les deux extrémités. Pour ne pas perdre cette précision lors du vissage des extrémités opposées, je forme un guide de foret avec un pointeau puis je réalise un trou guide d’1.5 mm de diamètre pour y mettre les vis à bois. Les deux glissières sont alors parallèles.

Je passe ensuite à l’installation du plateau de l’axe X sur la partie supérieure des glissières. J’ai rencontré plusieurs problèmes sur cette partie. Premièrement, je ne pouvais plus utiliser de vis à bois car l’épaisseur du plateau était trop faible pour les serrer suffisamment. J’ai donc opté pour des boulons de diamètre 3 mm ainsi que de rondelles de taille similaire. Afin de ne pas dépasser l’épaisseur du plateau d’axe, j’ai creusé l’intérieur du plateau avec une fraise de 15 mm. Deuxième problème : comment aligner les glissières sur le plateau ? Pour cela, j’ai d’abord essayé de fixer les pièces avec de la colle chaude. Echec. La colle adhère très bien au bois, mais ne tiens pas sur le métal, même en le limant. La colle à bois fût la solution à ce problème. Les coulisses installées, il reste à monter la tige filetée, le roulement, le moteur et l’écrou d’axe. Le support du roulement à billes est réalisé avec deux rondelles acier de 40 mm, avec 3 trous espacés de 120 °. C’est la bague extérieure du roulement qui est retenue par les rondelles, ces dernières sont montées sur la base de la machine avec des renvoi d’angle en acier. La tige filetée est ensuite serrée sur la cage intérieure du roulement par deux écrous M8. Cette partie assure une grande rigidité dans le sens de l’axe. Le moteur pas à pas est quant à lui monté sur une plaque rigide en acier, elle-même vissée sur la tranche du la base de la machine. Un raccord souple est utilisé pour relier la tige filetée de 8 mm à l’arbre 5 mm du moteur. Enfin, le guide mécanique du plateau X est réalisé via deux écrous papillon tête- bêche, percés et vissés.

L’axe Y est ensuite réalisé de la même manière, avec pour contraintes supplémentaires l’épaisseur de tranche plus faible pour la plaque moteur, moins de place pour le roulement à bille et le besoin indispensable d’être parfaitement d’équerre avec l’axe X. Le plateau mobile monté sur la cascade des deux axes est muni d’un support « sacrificiel » qu’il sera possible de remplacer s’il s’abime à cause de fausses manipulations.

deux premiers axes

Je m’attaque ensuite à la construction de l’axe verticale. Plusieurs éléments sont à prendre en compte : l’ensemble monté doit être parfaitement rigide (suffisamment fixé à la base), l’axe Z doit être piloté comme les deux axes horizontaux et le plateau doit bien sûr être mobile. Le support est construit avec les mêmes panneaux de médium, et l’axe utilise les glissières métalliques de tiroir. Comme pour les deux axes précédents, je commence par monter la base des glissières sur le support puis je contraints le reste sur la partie mobile. Le moteur pas à pas est ensuite fixé grâce à un déport collé sur le support. L’ensemble tige filetée plus guide mécanique et raccord souple est monté de la même manière que précédemment. Le tout est ensuite solidarisé à la base de la machine à l’aide de 4 morceaux de profilé carré de 20 mm en aluminium.

20150825_081827

Il reste ensuite les interrupteurs de fin de course, utilisés à la fois pour éviter que le plateau ne sorte de sa zone de fonctionnement et pour réaliser le « homing », un mécanisme qui permet de réactualiser les positions absolues de la machine. Dans une optique de recyclage, j’utilise des interrupteurs « simple position » soudés sur un morceau de plaquette pré percée puis visée sur un renvoi en L métallique. Lorsque le plateau ou l’axe Z part en butée, une tête de vis force le contact sur l’interrupteur et GRBL coupe toute activité des moteurs pas à pas. Dans le cas du homing, le logiciel force les axes à partir en butée d’origine ce qui permet de définir la position [X0 Y0 Z0] de la machine.

Pour l’outil de fraisage, je dispose d’une Dremel like peu utilisée (et de piètre qualité, je la changerai plus tard…) qui est tout indiquée pour le travail. L’outil sera donc installé sur l’axe Z de la machine, tangent au plateau mobile.

20150901_182340

Pour cela, je réalise 2 supports en bois qui viendront pincer la mini perceuse. J’ai d’abord dessiné les dimensions de la pièce avec un outil de DAO/CAO puis j’ai reporté le résultat sur de morceaux de medium. Le reste n’était qu’une affaire de découpe avec la scie à araser pour les lignes droite et la scie à chantourner (à la main) pour les courbes et la découpe intérieure. Deux perçages extérieurs permettent de fixer le support et un perçage sur la partie flexible permet de serrer l’étau autour du corps de la perceuse. Je voulais également pouvoir changer l’outil sur la CNC, ce qui m’a poussé à fixer les supports sur une plaque intermédiaire, elle-même fixée à l’axe Z. Je peux alors retirer la plaque avec les supports dessus, et en ajouter une nouvelle avec de nouveaux outils (une buse d’imprimante 3D ? ;-).

C’est terminé pour la construction ! Je peux enfin tester le matériel :

fraisage plexy 20150901_222455 fraisage pcb

Retour d’expérience

Après avoir construit cette machine, il y a quelques points que j’aimerai soulever. Tout d’abord, l’utilisation du bois comme matière première de construction n’est vraiment pas optimal. Sans forcément parler de contraintes mécaniques, je pense plutôt à l’usinage de certaines matières qui nécessitent une lubrification. J’ai été confronté à l’usinage de verre synthétique de type Polyglass et dérivés qui, contrairement au Plexyglass, est fait de polypropylène. Cette matière est compliquée à usiner car le polypropylène fond et colle sur l’outil s’il n’est pas correctement refroidi. C’est un problème récurrent, même dans les secteurs industriels. Après, la machine ici fabriquée était plus un « proof of concept » qu’un modèle final pour vente. L’utilisation d’aluminium plutôt que du bois aurait astronomiquement augmenté le prix et la complexité de la fabrication.

Ensuite, deux problèmes en un, lorsque j’ai câblé les interrupteurs de fin de course pour la première fois, ceux-ci fonctionnaient très bien. J’ai ensuite essayé d’usiner un bout de circuit imprimé et à chaque démarrage du processus de fraisage, la machine s’arrêtait brusquement. Après de nombreuses minutes de recherches, le problème venait de la mini perceuse qui génère une quantité astronomique d’impulsions électriques (moteur à charbons) à cause des étincelles. Les perturbations remontaient sur les câbles non blindés des interrupteurs de fin de course et causaient des interruptions sur le microcontrôleur. Une fois les interrupteurs débranchés, le cycle retournait à la normale. Je devrais donc par la suite changer les fils de connexion par des câbles blindés, et si possible changer la perceuse par un moteur brushless dédié au fraisage.

Enfin, quelques problèmes de dimensionnement. J’ai construit cette machine sans réellement connaître à l’avance les dimensions, la façon dont tout allait s’ordonnancer. Avec du recul, le plateau mobile n’est pas une solution très efficace car la base de la machine doit être au moins 4 fois supérieure. Or, avec une base de 35 cm x 35 cm, j’obtiens un plateau de surface inférieure à 14 cm x 14 cm. Cette limitation vient des raccords souples sur les moteurs pas à pas et de la taille des plateaux. L’axe Z quant à lui est monté beaucoup trop bas sur la machine, ce qui empêche de travailler avec des pièces de hauteur supérieure à 4 cm. Pour une prochaine machine à commande numérique, je fabriquerai un plateau fixe muni d’un axe Z capable de se déplacer latéralement. La surface min devra alors être de 1 m x 1 m.

Quelques points positifs pour conclure, cette machine a quand même été construite en un temps raisonnable (2 semaines) pour un total d’environ 120 h. Le prix final de la CNC s’élève à 200 € en comptant les outils spécialement achetés pour l’occasion. Les tests n’auraient jamais été réalisés aussi rapidement sans le logiciel open source GRBL. C’est une machine qui fonctionne très bien pour ce qu’on lui demande de faire, et parfaitement en accord avec les pratiques Do It Yourself.


Melvin PROST

Agrégateur flux RSS

Envoyé par le 14 Oct 2015 dans Blog, Portfolio, Projets | 0 commentaire

Ce projet a été réalisé dans de cadre d’une validation du mooc « La fabrication numérique ».
Après avoir suivi la formation en ligne, j’ai conçu un projet d’agrégateur RSS avec Arduino.
Jeremy Sfez

Présentation du projet

Le dispositif récupère les informations sur le flux RSS de « Googles news ». Après avoir parsé le flux (bibliothèque « TextFinder »), il affiche le premier titre sur un l’écran LCD 2×16. Quand l’utilisateur appui sur le bouton, le titre suivant est affiché.

N’ayant pas à ma disposition de carte ethernet, le téléchargement du flux RSS est fait par script python. Le programme communique directement avec le dispositif sur le port série grâce la bibliothèque « serial ».

 

Présentation du dispositif

Photo du dispositif 1

Le dispositif attend le xml de google news

Photo du dispositif 2

Le dispositif affiche un des titres de l’actualité

 

Présentation de l’algorithme

Présentation de l'algorithme

Algorithme flux RSS

 

Matériel utilisé

  • 1 cartes Arduino Uno
  • 1 écran LCD 2×16
  • 1 breadboard
  • 1 bouton
  • 1 résistance de 560 Ohms
  • potentiomètre de 10 kOhms (pour régler le contraste de l’écran)
  • fils de connexions

 

Schéma du montage

Schéma flux RSS

Schéma du montage

 

Code Arduino
//Bibliothèques
#include <LiquidCrystal.h>
#include <TextFinder.h>

LiquidCrystal lcd(12, 11, 4, 5, 6, 7); //Variables pour ecran LCD
TextFinder finder(Serial); //Variables pour parser le XML
char actualite[5][320];
int nbrArticlesRecu;
int nbrArticlesMax=5;
int t[] = {0, 0, 0, 0, 0};
int tmp = 0;
int numArticle = 0;
int cursor = 0;
int nbrAppelAffichage = 0;
//Variables pour le bouton
const int buttonPin = 2;
int buttonState = 0;
int lastButtonState = 0;
void setup() {
  // delay(2000);
  Serial.begin(115200);
  nbrArticlesRecu=0; //Initialisation parseur
  nbrAppelAffichage=0;
  pinMode(buttonPin, INPUT); //Initialise bouton comme input
 
  //Initialise ecran LCD
  lcd.begin(16, 2); 
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Download news...");
  lcd.setCursor(0,1);
  lcd.print("Launch file .py");
  Serial.println("Debut du programme");
}
void loop(){
  if(nbrArticlesRecu<nbrArticlesMax){ // Récupération du flux RSS google news
    // Le XML est parcouru pour récupérer les titres des articles à une 
   if((t[nbrArticlesRecu]=finder.getString("<item><title>","</title>",actualite[nbrArticlesRecu],320))>0){
     nbrArticlesRecu=nbrArticlesRecu+1; 
   }
   delay(50);
  }
  else{
    afficherMessage2(actualite[numArticle], t[numArticle], nbrAppelAffichage);
    nbrAppelAffichage++;
    delay(4000);
    buttonState = digitalRead(buttonPin);
    if (buttonState != lastButtonState) {
      if (buttonState == HIGH) {
        numArticle=(numArticle+1)%nbrArticlesMax;
        nbrAppelAffichage=0;
        Serial.println(" bouton ");
      }
      delay(50);
    }
    lastButtonState = buttonState;
  }
}
void afficherMessage2(char* message, int taille, int numAppel){
  int nombreEcran = (taille-1)/32 + 1;
  // Serial.println(numAppel);
  int choixEcran = numAppel%nombreEcran;
  int pointeurMsg = choixEcran*32;
  for(int i=0;i<16;i++){
    lcd.setCursor(i,0);
    if(pointeurMsg+i<taille) lcd.print(message[pointeurMsg+i]);
    else lcd.print(" ");
    lcd.setCursor(i,1);
    if(pointeurMsg+16+i<taille) lcd.print(message[pointeurMsg+16+i]);
    else lcd.print(" ");
  }
}

 

Code Python
#!/usr/bin/python

import serial
import unicodedata
import urllib2

ser = serial.Serial(‘/dev/tty.usbmodem1411’, 115200);

# Recuperation du flux rss google news
data = urllib2.urlopen(« http://news.google.fr/?output=rss »).read();
# Overture d’un fichier tampon
f = open(‘Flux RSS.txt’, ‘r+’);

# Ecriture dans le fichier des donnes recu
f.write(data);

s1 = unicode(data,’utf-8′);
data = unicodedata.normalize(‘NFD’, s1).encode(‘ascii’, ‘ignore’);
data = data.replace(« ‘ », »‘ »);
ser.write(data);