Actualités Projets

Co-Opération

Envoyé par hdarchis le 20 Juin 2016 dans Projets, Formation | 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.

Les interrupteurs

Le second problème que nous avons rencontré est celui de gérer les 18 interrupteurs que sont les plaques numérotées sans pour autant surcharger l’Arduino, qui n’a pas assez d’entrées. Nous avons penser résoudre ce problème en utilisant dans un premier temps des registres à décalage. Ceux ci permettent de prendre des entrées en parallèles pour en faire une seule sortie en série. Ce dispositif n’utilise que 4 pins quelque soit le nombre d’entrées en parallèles. Grâce à ces registres, nous avons pu relier les 18 plaques à un seul Arduino, néanmoins plusieurs problèmes sont apparu lors de l’implémentation finale. Tout d’abord l’alimentation des trois registres à décalages était assez important et nous ne pouvions plus utiliser notre prototype en l’alimentant via le port USB d’un ordinateur. Ensuite il y avait un très grand nombre de fils entre les estrades et la stèle, 36 en tout, Cela rendait le prototype très confus, il était compliqué de brancher correctement les plaques à la stèle. Finalement cela ne fonctionnait pas surement à cause d’une erreur dans la soudure, confuse elle aussi à cause de tous les fils s’entremêlant.

Nous avons décider de trouver une nouvelle solution. Nous avons alors conçu un deux convertisseurs numériques analogiques simili R-2R grâce à des ponts de résistances. Ceux-ci se trouvent en sortie de chaque estrade et permettent de faire passer le nombre de fils entre les estrades et la stèle de 36 à 6. Cela rend aussi beaucoup plus facile le suivi de l’information, et réduit drastiquement la consommation de notre prototype. Le seul changement sur la carte Arduino est que l’on utiliser plus les pin numériques de celle-ci comme avec les registres à décalages mais les pins analogiques.

Les plaques de pression

Les plaques de pression envoient un signal jusqu’à la carte Arduino quand un des joueurs marchent dessus. Nous avions une contrainte supplémentaire des designers à propos de ces plaques, il fallait avoir possibilité de ranger l’estrade. Dans un premier temps nous voulions utiliser la déformation des plaques sous le poids du joueur grâce à des matériaux piézoélectriques mais nous avons finalement abandonner cette idée. Nous avons alors découpé de manière individuelle chaque plaque et fait un cadre de mousse, nous utilisons alors l’affaissement de la plaque et plus sa déformation. Pour transmettre le signal nous avons d’abord essayé avec un capteur de force, cela fonctionnait bien mais le prix de ce genre de capteur est trop élevé pour l’usage que l’on voulait en faire et nous nous somme rabattu sur du ruban adhésif aluminium. On pose de ce ruban conducteur en dessous de la plaque et sur un morceau de bois, on soude des fils sur ces bouts de ruban. Ainsi quand un joueur marchera sur une plaque les rubans conducteurs rentreront en contact fermant alors le circuit.

II-Ateliers éducatifs

Pour initier les enfants aux rudiment de l’électronique et de l’électronique nous avons développer des ateliers éducatifs, ces ateliers sont accompagné de fiches techniques pour que n’importe quel enseignant puisse les mettre en place. Enfin ces ateliers ont pour but final de concevoir une petite calculatrice.

Les ateliers

Nous ne disposons que de quatre séances d’une heure chacune avec les élèves de primaire. Cependant, nous avons divisé notre initiation à l’électronique et l’informatique en six ateliers plus une réalisation finale. Ainsi, la première séance est une séquence d’introduction au projet, et est également l’occasion de présenter son déroulement. Puis lors de la deuxième session, la classe est divisée en trois groupes, chaque groupe s’occupant d’un atelier découverte. Ensuite, durant la troisième séance, chacun de ces trois groupes travaille sur la conception d’une partie de la calculatrice.

Enfin, la dernière heure est consacrée à l’intégration des trois parties constituant la calculatrice pour obtenir un appareil fonctionnel. Pour ce faire, les élèves doivent, collectivement, travailler sur l’intégration des différentes parties, tout en expliquant aux personnes des différents groupes l’essentiel de ce qu’ils ont appris.

Encadrement des élèves

Les élèves de primaire sont divisés en trois groupes à chaque séance, chacun traitant un atelier. Pour chaque groupe, il y a au moins un encadrant, que ce soit un enseignant ou un membre du projet, pour accompagner les élèves dans leurs réflexions et les aider à tirer les notions que l’atelier leur permet d’acquérir.

A la fin de chaque séance, les élèves doivent faire une mise au point de leur apprentissage afin que l’ensemble du groupe bénéficie de l‘atelier.

Réalisation finale : la calculatrice

Après avoir pris connaissance des notions de base en électronique et en informatique, durant les deux premières séances, les élèves, divisés en groupe, doivent, durant la troisième séance, mettre en œuvre leurs acquis pour réaliser une partie de la calculatrice avec le matériel à leur disposition. Ils ont ainsi à opter pour une des différentes solutions possibles pour faire le travail demandé dans la partie qui les concerne. Plus concrètement, le premier groupe doit choisir les composants qu’il utilise pour construire le pavé numérique de la calculatrice, le deuxième groupe doit trouver un système de transmission de données commode et le troisième groupe a à implémenter un programme qui permet d’effectuer les opérations de base, c.à.d. l’addition, la soustraction, la multiplication et la division.

Tout au long de ce projet, les élèves sont amenés à justifier la pertinence de leurs choix auprès des encadrants.

Résumé des ateliers

Voici un résumé des différents ateliers, des activitées mises en places, des durées indicatives des ces ateliers et du support et matériel nécessaire pour faire ces ateliers.

Projet développement: L’escalier musical

Envoyé par tpetitje le 20 Juin 2016 dans Projets, Formation | 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.

L’escalier musical

L’objectif est de favoriser l’utilisation de l’escalier traditionnel au détriment de l’escalier mécanique, afin de promouvoir l’activité physique dans notre société. L’aspect fatiguant des escaliers traditionnels est remplacé par un aspect ludique grâce à la musique, ce qui favorise son utilisation.

Matériel utilisé

• 1 Raspberry Pi B
• 3 cartes Arduino UNO
• 2 émetteurs radio FS1000A (433 MHz)
• 1 récepteur radio XY-MK-5V
• 4 modules de détection US-HC-SR04
• 1 lecteur de tag RFID RC522

Fonctionnement

L’élément prépondérant de l’escalier musical est la détection de l’usager. Pour se faire, nous utilisons les modules de détection ultrason US-HC-SR04 qui, grâce au principe d’émission-réflexion des ondes ultrasonores fournissent en continu la distance entre le capteur et un obstacle. Lorsque personne ne passe, cet obstacle est le mur opposé, et lorsqu’un obstacle se situe à une distance inférieure à un seuil, il s’agit de la jambe d’un passant et il faut donc émettre un son.

Cette tâche incombe à un Raspberry Pi modèle B qui, grâce au programme Python présenté en Annexe, émet un son lorsqu’il reçoit l’information correspondant à une marche.

Cette information transite entre le capteur ultrason et le Raspberry Pi par ondes radio grâce aux émetteurs FS1000A et au récepteur XY-MK-5V. Nous utilisons pour cela la librairie VirtualWire.

Les émetteurs sont chacun branchés à une carte Arduino UNO, où sont également branchés deux modules de détection. Ainsi, chaque émetteur transmet les informations correspondant à deux capteurs. Celles-ci sont récupérées par le récepteur XY-MK-5V, branché à une carte Arduino UNO, elle-même reliée au Raspberry Pi. Le code des cartes Arduino UNO émettrice et réceptrice est présentée en Annexe.

De plus, un lecteur de tag RFID est relié à la carte Arduino UNO réceptrice, afin de permettre aux membres de Télécom Bretagne de changer l’instrument joué grâce à leur badge. Les librairies SPI et MFRC522 sont utilisées pour cette tâche.

Le schéma suivant illustre le principe de fonctionnement de l’escalier:

Annexe

Code Python implémenté à exécuter par le Raspberry Pi:

#serial est une bibliothèque qui permet la lecture des données provenant du port série

#pygame est une bibliothèqye dont le module mixer permet de jouer des fichiers .mp3

import serial, pygame.mixer

 

#initialisation du mixer

pygame.mixer.init()

 

#initialisation de la connexion série

ser=serial.Serial(‘/dev/ttyACM1’,9600)

 

#la boucle sera exécutée à l’infini

while 1:

#on récuppère la valeur provenant du port série

newIncome = ser.readline()

 

# si c’est un instrument, on défini la variable instrument comme l’instrument correspondant

if newIncome==‘piano\r\n’:

instrument = ‘piano’

 

if newIncome==‘trompette\r\n’:

instrument = ‘trompette’

 

if newIncome==‘coeur\r\n’:

instrument = ‘coeur’

 

if newIncome==‘batterie\r\n’:

instrument = ‘batterie’

 

if newIncome==‘piano2\r\n’:

instrument = ‘piano2’

 

#si c’est une note de musique, on la joue grâce au module pygame.mixer

#les notes sont contenues dans un dossier dont le nom correspond à l’instrument dont elles sont issues

if newIncome== ‘A\r\n’ :

pygame.mixer.music.load(‘/home/pi/Music/%s/la.mp3’+instrument)

pygame.mixer.music.play(loops=0, start =0.1)

 

elif newIncome == ‘B\r\n’:

pygame.mixer.music.load(‘/home/pi/Music/%s/si.mp3’+instrument)

pygame.mixer.music.play(loops=0, start =0.1)

 

elif newIncome == ‘C\r\n’ :

pygame.mixer.music.load(‘/home/pi/Music/%s/do.mp3’+instrument)

pygame.mixer.music.play(loops=0, start =0.1)

 

elif newIncome ==‘D\r\n’:

pygame.mixer.music.load(‘/home/pi/Music/%s/re.mp3’+instrument)

pygame.mixer.music.play(loops=0, start =0.1)

 

elif newIncome == ‘E\r\n’ :

pygame.mixer.music.load(‘/home/pi/Music/%s/mi.mp3’+instrument)

pygame.mixer.music.play(loops=0, start =0.1)

 

elif newIncome == ‘F\r\n’ :

pygame.mixer.music.load(‘/home/pi/Music/%s/fa.mp3’+instrument)

pygame.mixer.music.play(loops=0,start = 0.1)

 

elif newIncome == ‘G\r\n’:

pygame.mixer.music.load(‘/home/pi/Music/%s/sol.mp3’+instrument)

pygame.mixer.music.play(loops=0,start = 0.1)

 

elif newIncome == ‘c\r\n’:

pygame.mixer.music.play(‘/home/pi/Music/%s/DO.mp3’+instrument)

pygame.mixer.music.play(loops=0,start = 0.1)

Code de la carte Arduino UNO émettrice:

include <VirtualWire.h>

/* virtualWire est une librairie libre de droit permettant l’utilisation

des modules de transmission-réception radio*/

 

// initialisation des pins

int trig1 = 12;

int echo1 = 11;

int trig3=8;

int echo3=7;

 

// instanciation des variables utiles

long lecture_echo1;

long cm1;

long lecture_echo3;

long cm3;

 

//messages qui seront envoyés, à changer d’une carte à l’autre (msgStringD et msgStringE par exemple pour envoyer D et E)

String msgStringG;

String msgStringF;

 

void setup(){

// paramétrage des capteurs

pinMode(trig1, OUTPUT);

digitalWrite(trig1, LOW);

pinMode(echo1, INPUT);

pinMode(trig3, OUTPUT);

digitalWrite(trig3, LOW);

pinMode(echo3, INPUT);

 

//initialisation de la communication via le port série (USB)

Serial.begin(9600);

Serial.println(« setup transmitter 1 « );

 

//initialisation de la communication par radio

vw_setup(2000);

vw_set_tx_pin(2);

}

 

//code qui sera répété indéfiniment

void loop(){

 

// récupération de la distance cm1 du capteur 1 à l’obstacle

digitalWrite(trig1, HIGH);

delayMicroseconds(10);

digitalWrite(trig1, LOW);

lecture_echo1 = pulseIn(echo1, HIGH);

cm1 = lecture_echo1 / 58;

 

// récupération de la distance du capteur 3 à l’obstacle

digitalWrite(trig3,HIGH);

delayMicroseconds(10);

digitalWrite(trig3,LOW);

lecture_echo3=pulseIn(echo3,HIGH);

cm3 = lecture_echo3 / 58;

 

/* si la distance de l’obstacle au capteur est inférieure à 115cm et que c’est la première fois que l’obstacle

est detecté, on envoie l’information correspondant au capteur */

if( cm1 < 115 && msgStringF != « F » && cm1 != 0 ){

//traitement des données

msgStringF = « F »; /*ces valeurs seront à changer en cas de changement de carte*/

const char* msg = msgStringF.c_str();

 

// envoi des données par radio

vw_send((uint8_t *)msg,strlen(msg));

Serial.println(« envoyé »);

}

 

// sinon, on réinitialise les valeurs

elseif( cm1 >= 115){

msgStringF = « 0 »;

}

 

// le principe est identique pour le second capteur

if(cm3 < 115 && msgStringG != « G » && cm3!= 0){

msgStringG = « G »;

const char* msg = msgStringG.c_str();

vw_send((uint8_t *)msg,strlen(msg));

Serial.println(« envoyé »);

}

elseif( cm3 >= 115 ){

msgStringG = « 0 »;

}

 

delay(200);

}

Code de la carte Arduino UNO réceptrice:

#include <VirtualWire.h>

 

/*

* SPI et MFRC522 sont deux bibliothèques qui permettent la gestion

* du lecteur RFID

*/

#include <SPI.h>

#include <MFRC522.h>

 

//configuration des pins du lecteur RFID

#define RST_PIN         9

#define SS_PIN          10

 

//on créer une instance MFRC522

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance.

 

// instanciation et déclaration des variables utiles par la suite

String instruments[]={« piano », « trompette », « batterie »,« coeur »,« piano2 »};

int i = 0;

char ASCII[128];

 

void setup(){

// on créer un tableau de 128 char correspondant à 128 caractères du code ASCII

for(int i = 0; i<33 ; i++){

ASCII[i]= ‘ ‘;

}

 

ASCII[47]= ‘/’;

ASCII[58]= ‘:’;

ASCII[59]= ‘;’;

ASCII[60]= ‘<‘;

ASCII[61]= ‘=’;

ASCII[62]= ‘>’;

ASCII[63]= ‘?’;

ASCII[64]= ‘@’;

ASCII[65]= ‘A’;

ASCII[66]= ‘B’;

ASCII[67]= ‘C’;

ASCII[68]= ‘D’;

ASCII[69]= ‘E’;

ASCII[70]= ‘F’;

ASCII[71]= ‘G’;

ASCII[72]= ‘H’;

ASCII[91]= ‘[‘;

ASCII[92]= ‘ ‘;

ASCII[93]= ‘]’;

ASCII[94]= ‘^’;

ASCII[95]= ‘_’;

ASCII[96]= ‘ ‘;

ASCII[97]= ‘a’;

ASCII[98]= ‘b’;

ASCII[99]= ‘c’;

ASCII[100]= ‘d’;

ASCII[101]= ‘e’;

ASCII[102]= ‘f’;

ASCII[103]= ‘g’;

ASCII[104]= ‘h’;

ASCII[123]= ‘{‘;

ASCII[124]= ‘|’;

ASCII[125]= ‘}’;

ASCII[126]= ‘~’;

ASCII[127]= ‘ ‘;

 

// initialisation de la communication en série (USB)

Serial.begin(9600);

Serial.println(« setup reciever »);

 

// initialisation du récepteur radio

vw_setup(2000);

vw_set_rx_pin(2);

vw_rx_start();

 

//initialisation du lecteur RFID

SPI.begin();

mfrc522.PCD_Init();

}

 

void loop(){

 

//définition de la variable dans laquelle sera stocké le message reçu

uint8_t buf[VW_MAX_MESSAGE_LEN];

 

// longueur du message maximal pouvant être reçu

uint8_t buflen = VW_MAX_MESSAGE_LEN;

 

// si une carte est présente, on pioche dans la liste des instruments et on transmet cette information via le port série

if( mfrc522.PICC_IsNewCardPresent()){

Serial.println(instruments[i%5]);

i++;

}

 

// si réception du message, on le lit et on le transmet via le port série

if(vw_get_message(buf,&buflen))

{

int i;

// Message with a good checksum received, dump HEX

for(i = 0; i < buflen; i++)

{

Serial.println(ASCII[buf[i]]);

}

 

}

 

}

Mission Morse

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

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

Notre projet dans le cadre de l’intersemestre « Fablab et design » est la création d’un jeu de communication en morse pour enfants. Le principe est simple : un premier enfant reçoit des combinaisons de caractères que l’autre enfant lui envoie, en morse, avec des messages lumineux et sonores. Ces combinaisons déterminent chaque pièce, leur position et leur orientation et permettent à l’enfant d’assembler des pièces dans une forme donnée. Une fois toutes les pièces correctement assemblées, les enfants reçoivent un message sur un écran LCD accompagné de signaux sonores et lumineux.

(suite…)

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

Envoyé par Melvin le 4 Nov 2015 dans Projets, À la une | 1 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.

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.

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.

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.

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 :

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 jsfez le 14 Oct 2015 dans Projets, Blog | 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

Le dispositif attend le xml de google news

Le dispositif affiche un des titres de l’actualité

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

Présentation du Fablab Ecodesign lab de Montreuil

Envoyé par jsfez le 7 Oct 2015 dans Blog | 1 commentaire

L’écodesign fablab est un espace de 102m2 situé au dernier étage de l’usine verticale Mozinor. Ce lieu héberge un cinquantaine d’entreprises qui génèrent 3000 tonnes par an de déchets bois, plastiques et divers matériaux. Le fablab récupère ces matériaux et les machines obsolètes et les mets à disposition des adhérents.

L’écodesign fablab est un espace de travail ou les makers peuvent créer et échanger. Les adhérents  sont architectes, designers, ébénistes et des makers amateurs.

On peut y réaliser du mobilier ou luminaires, réparer des objets, concevoir des projets, des maquettes ou des prototypes et mener des projets en équipes. Les mots d’ordre sont apprendre créer et partager.

Les adhérents sont accompagnés depuis la conception jusqu’à la réalisation.

On y trouve les machines suivantes :

• Imprimante 3D
• Découpeuse à fil chaud
• Fraiseuse numérique
• Machine à coudre professionnelle
• Poste C.A.O.

Et biens d’autres… (notamment pour travailler le bois).

Comme dans la plupart des fablab, ici le l’open source et le partage sont mis à l’honneur.

Merci a Philippe Schiesser, Président de l’Apedec (association de l’écodesign et de l’éco-conception), qui m’a ouvert les portes du fablab, et présenté l’espace de coworking.

Réparation du dispositif d’entrée de coulisseaux de grand-voile pour Neraki

Envoyé par Sylvie le 11 Août 2015 dans Projets, À la une | 1 commentaire

article rédigé par Paul Friedel

Depuis une dizaine d’année le dispositif d’insertion des coulisseaux de guindant de grand-
voile dans la gorge du mât de Neraki (Feeling 326) était défectueux. D’origine dans ce mât Francespar (repris par Sparcraft), le matériau polymère avait un peu durci mais surtout les efforts imposés lorsque l’on prenait un ris sans sortir les coulisseaux se traduisaient dans une direction non prévue par le fabricant. Ces efforts ont conduit à une rupture de la cage dans laquelle se meut le levier d’insertion.
Dans les premières années, j’ai fait des réparations à base de tissu de verre polymérisé. J’ai tenté de reconstruire les parties disparues de la cage mais sans succès. Les fabricants de gréement contactés m’ont assuré que ces pièces n’existaient plus chez les fabricants.

En 2012 lors d’un démâtage, le désarmement de la voile a conduit à une rupture de la partie mobile au niveau de l’axe de rotation. Dès lors la pièce devenait  radicalement  inutilisable,  aucune  colle  ne  permettant  de  tenir  les  efforts  imposés par cette rotation sous la pression de la mousse qui repousse la partie mobile en position alignée  à  la  gorge  de  mât  après  introduction  des  coulisseaux.  J’ai  donc  dû  me  passer  de cette  pièce pendant  deux  ans  et  gérer  le  maintien  des  coulisseaux  dans  le  mât  avec  un Sandow.

Figure 1 : Cage d’origine dans son état actuel

Figure 2 : Partie mobile d’origine dans son état actuel, axe recollé.

En 2011 Télécom Bretagne s’est procurée une imprimante 3D d’entrée de gamme pour le fablab. Intéressé à tester les nouveaux moyens de production, j’ai donc pensé utile de tracer les plans des deux pièces du dispositif avant de les envoyer au Téléfab pour un test de fabrication.

Ceci m’a permis de découvrir les impressionnantes possibilités de l’outil gratuit Sketchup de Google pour les tracés 3D de pièces relativement précises et complexes. En revanche les essais  effectués  sur  l’imprimante  par  Sylvie  Kerouedan  ont  montré  les  limites  de  nos capacités. L’imprimante de l’école ne permettait pas de faire de parties en porte-à-faux. Par ailleurs le matériau d’impression n’avait très probablement ni la résistance mécanique ni la précision  d’impression  nécessaires  pour  une  pièce  de  gréement  (non  soumis  en  temps
normal à des efforts importants néanmoins).

Figure  3 :  Plan  3D  sous  Sketchup  de  la  pièce  :  cage,  mobile  et  assemblage  des  deux.  Plan
établi sur un relèvement de mesures de la pièce dégradée et une extrapolation pour la partie
manquante.

Ce  n’est qu’en  découvrant  le robot  humanoïde  imprimé  en  Chine  sous commande  de  Mai Nguyen  que  j’ai  pris  conscience  des  possibilités  réelles  d’une  impression  3D  de  qualité professionnelle.  Ayant  rencontré  David  Pliquet  à  la  Cantine  et  surtout  aux  Fabriques  du Ponant, il m’a semblé intéressant de chercher une solution en passant par un professionnel de l’impression 3D, la société E-Mage-In 3D créée par David Pliquet.
Pour un coût très raisonnable pour un prototype (à voir en production de série) la société E-Mage-In 3D a produit un premier exemplaire à base d’un polyméthyl métacrylate, Verowhite dont les caractéristiques sont données dans la fiche technique.

Figure 4 : premier prototype produit par E-Mage-In 3D sur plans personnels

Au  premier  essai  de  montage, force  a  été  de  constater que  les  cotes  étaient  trop  serrées d’un demi millimètre en particulier pour la « pince » de la cage dans sa partie haute (à droite sur  la  figure  ci-dessus).  J’ai  usiné  la  pièce  pour  faire  disparaître  le  plateau  supérieur  en espérant qu’elle rentrerait dans le logement. Las, tout le plateau supérieur était dessiné un peu  trop  bas  par  rapport  à  la  partie  interne  et  en  forçant  pour  insérer  la  pièce  dans  le logement prévu du mât, la paroi latérale a cassé comme du verre. Le mobile en revanche semble   suffisamment   compact   pour   tenir   les   efforts   qui   lui   sont   imposés   pendant
l’introduction.
Très gentiment, David Pliquet a proposé de refaire une impression de cage avec un matériau plus  résistant.  J’ai  repris  le  dessin  en rehaussant  le  plateau  de  0,3mm  et  en renforçant  la pente pour tenir compte de la rotondité du mât. J’ai aussi amélioré le dessin qui laissait voir des  « vides »  par  endroit  (qui  ne  semblent  pas  gêner  pour  l’impression !).  Davis  Pliquet  a refait une impression avec un matériau « plus chargé ». Le résultat est très intéressant : le matériau bien que plus rugueux en surface a une certaine élasticité que ne démontre pas le PMMA de départ. Moyennant quelques ajustements nécessaires : le double triangle arrondi (visible sur la Figure 4 en bas à gauche) est trop long de 0,7mm ; la partie haute du plateau (à  droite)  et  le  plan  incliné  du  haut  doivent  encore  avoir  0,1mm  ou  0,2mm  d’écartement supplémentaire et surtout arrondi pour la partie plan incliné ; enfin le jonc rajouté (non visible sur  les  photographies)  pour  caler  la  mousse  encollée  sur  le  fond  de  la  cage  est  trop proéminente du fait que j’ai dessiné le renfort inférieur de la partie mobile en plein plutôt que deux  jonc  partant  de  l’axe  et  longeant  les  bords  de  la  partie mobile.

J’ai pu faire tous ces petits ajustements avec mon outil Dremel sur  place  au  ponton.  Le  résultat  est  une  insertion  parfaite  de l’ensemble.  Il  faut  forcer  un  peu  pour  insérer  et  la  cage  et  le mobile au fond de la cage comme c’était le cas avant dans le système d’origine.

Reste   à   tester   le   fonctionnement   du   système,   la   facilité d’introduction  des  coulisseaux  que  je  n’ai  pas  encore  eu  le temps  de  tester  ainsi  que  l’usure  avec  le  temps  et  les intempéries.
Mais la conclusion à de stade est que l’impression 3D permet de  faire  des  pièces  mécaniques  résistantes  et  usinables.  Je suis à ce stade, extrêmement satisfait de cet essai.

à suivre…

Projet 63 : L’éolienne Savonius

Envoyé par vberthel le 25 Juin 2015 dans Projets, Formation | 0 commentaire

Résumé :

Pour pouvoir utiliser une éolienne sur le campus, il est d’abord indispensable de se procurer les droits administratifs nécessaires pour la pose d’un tel système et d’être vigilant aux contraintes qui nous sont imposées. Les matériaux de récupération nécessaires à la construction ont été collectés depuis de diverses sources : casse automobile, Emmaüs, LeBonCoin, port de commerce de Brest, “Guyot environnement”… La construction de l’éolienne est menée à terme et est capable de tourner à 2 tours/seconde et de délivrer une tension correcte. Cependant, il reste des voies d’amélioration, notamment en ce qui concerne la solidité du bâti et le système de réduction.

Éolienne Savonius

Liste des matériaux de récupération utilisés pour la construction :

– Roulement arrière de voiture

– Dispositif de rotation du tambour d’une machine à laver

– Un bidon bleu de 120L

– Deux pans de placard

– 4 tringles à rideaux

– Deux planches de bois

– Un moteur (fonctionnant en génératrice)

– Une poutre métallique

– Un set de vis

Moteur FabLab utilisé (appartient au club robotique)

Pré-conception de l’éolienne :

Nous avons tout d’abord effectué une modélisation CAO de l’éolienne sous SolidWorks, qui a été le fil directeur de la conception de l’éolienne.

Modélisation CAO de l’éolienne

Étapes de la construction :

Dans un premier temps, nous avons fixé les pales de l’éolienne (les deux demi-bidons de 1m20 de hauteur) entre deux plaques de bois que l’on a usinées de manière circulaire. Cette pièce représente le corps des pales, la partie tournante de l’éolienne.

Nicolas visse les pales

Ensuite, nous avons fixé le réceptacle du roulement du haut de l’éolienne sur la planche des pales. Le roulement du haut, appartenant au bâti, repose sur cette pièce. Il faut par la suite fixer le roulement du haut à la planche du bâti de l’éolienne.

Nicolas visse les roulements

Il nous a fallu ensuite concevoir le système de roulement du bas. Pour cela, nous avons superposé deux planches de bois circulaires à l’aide de portions de poutres de bois, pour des raisons d’architecture : les pales ne doivent pas entrer en contact avec le boîtier du moteur ! Sur la planche supérieure, nous avons fixé le réceptacle du roulement du bas.

Plateau élévateur des pales

Nous avons découpé le panneau en bois de protection, très robuste, pour soutenir l’éolienne. C’est au travers de cette planche que l’on a fixé le système de roulement de machine à laver, comportant aussi le système poulie-courroie.

Système de roulement du bas

Nicolas scie les planches

Système poulie-courroie de l’éolienne

Enfin, nous assemblons le tout et fixons les tringles à rideaux pour soutenir l’éolienne et solidariser le bâti. L’éolienne est sur pied !

Jinhai et Nathan, victorieux face au fruit d’un dur labeur

Conclusion :

Après avoir effectué une étude préalable sur l’éolienne que nous allions construire, nous avons recherché les matériaux de récupération dont nous avions besoin pour l’édification de l’éolienne. Suite à cela, nous avons débuté la
construction l’éolienne en se basant sur sa version CAO. L’éolienne est fonctionnelle et est capable de délivrer une tension de 10V environ, pour une vitesse de rotation de 1 tour/seconde. Néanmoins, il reste des pistes d’améliorations qui pourraient être explorées dans le cadre d’un autre projet, notamment au niveau de la solidité du bâti, de la génératrice et du système de réduction. On peut aussi envisager la conception d’une application permettant de visualiser la vitesse de rotation de l’éolienne en temps réel, comme nous l’avions souhaité initialement, en espérant que notre travail suscitera le désir d’un autre groupe de projet de poursuivre et d’approfondir la conception totale de notre éolienne !

Projet 5 : Un système de surveillance à distance de la spiruline

Envoyé par ldeleuze le 25 Juin 2015 dans Projets, Formation | 2 commentaires

Résumé :

Afin de faciliter la supervision de la culture de la spiruline, nous avons développé un système de capteurs mesurant la température, la luminosité et l’humidité de la serre ainsi que la température, la turbidité et le pH de l’eau des bassins de culture. Il permet de récupérer et de stocker ces mesures et de les afficher sur un écran grâce à un site web.

Objectifs :

Pour simplifier la surveillance de la culture nous nous proposons de :

• Faciliter le remplissage du journal de bord pour le spirulinier.

• Automatiser le relevé des mesures.

• Permettre la supervision à distance de la culture.

• Avoir un budget inférieur à 250 €.

Développement technique :

Comme on peut le voir sur le schéma de la figure 1, notre système est décomposable en quatre sous parties :

– Un regroupement de 5 capteurs lié à un premier Arduino afin de collecter les données environnementales ;

– Une communication sans fil via une liaison radio pour permettre une certaine mobilité des capteurs ;

– Une base de données qui stocke toutes les mesures réalisées par les capteurs depuis leur mise en service ;

– Un site web permettant la consultation et l’édition du journal de bord du spirulinier ainsi que la visualisation graphique de l’évolution des mesures au cours du temps.

• Un système de 5 capteurs :

Un capteur de température et d’humidité. Sa référence est RHT03 (DHT22). Il existe de nombreux tutoriels sur internet qui nous permettent de bien apprendre à l’utiliser. Il est cependant nécessaire d’installer la bibliothèque DHT.

Un capteur de température étanche dont la référence est DS18B20.

Une sonde pour mesurer le pH de référence Smecatronix DF028.

Un capteur de luminosité TSL2561. Nous avons réussi comme précédemment à trouver des montages et des codes pour les faire fonctionner. Si nécessaire, il faut aussi installer la bibliothèque pour le capteur.

Enfin, nous avons associé tous les capteurs. Nous avons également rassemblé les différents codes pour faire fonctionner notre système sur l’Arduino.

Notre principal défi a été de créer par nous même un capteur de turbidité. La difficulté réside dans le fait que ce capteur n’existe pas pour le moment. Mme Ménard nous a montré comment elle évaluait la turbidité avec un disque de Secchi. Cette mesure n’est pas très précise, elle est faite pour évaluer en gros la turbidité. C’est pourquoi pour ce capteur nous avons décidé d’utiliser une photorésistance plutôt qu’un capteur de luminosité plus précis. Face à cette photorésistance nous avons fixé une LED qui s’allume à intervalle régulier quand la photorésistance prend des valeurs. La structure ainsi créé est étanchéifiée grâce à du film plastique. On la place alors dans le bassin. Plus l’eau est trouble plus elle absorbe la lumière donc plus la valeur renvoyée par la photorésistance. On peut ainsi estimer la turbidité de l’eau.

• Une transmission radio :

Notre cliente souhaite une communication sans fil entre les capteurs collectant les résultats des mesures et le lieu où ceux-ci sont stockés puis analysés. Pour ce faire, nous avons opté pour l’utilisation d’une liaison radio. Nous travaillons avec les modules radio FS1000A/XY-FST RF, émetteur et récepteur, utilisant la fréquence 433 MHz (cf figure 6). Ceux-ci sont peu chers et facile d’utilisation.

Nous avons utilisé la librairie VirtualWire, disponible en téléchargement libre sur internet, où les fonctions prennent en compte cette faille et introduisent de la redondance dans leur code. Par précaution, nous avons introduit dans notre propre code une méthode semblable à celle du bit de parité. En effet, lorsque le transmetteur envoie des données, il envoie également leur somme. Le récepteur, quant à lui, reçoit les données, en fait la somme et compare celle-ci à la somme reçue (celle qui a été envoyé par l’émetteur). Si les sommes sont différentes, c’est qu’il y a probablement eu une erreur dans la transmission donc le récepteur refuse les données. Elles ne seront pas enregistrées dans la base de données. Cependant, cette méthode ne nous permet pas d’identifier l’erreur ni de la corriger. Elle peut donc être améliorée.

• Une base de données persistante :

Pour récupérer les données reçues par l’Arduino et les mettre dans une base de données, nous avons utilisé le langage de programmation Python. En effet, son utilisation est simple et les ressources sont nombreuses sur internet pour nous aider à implémenter un code nous permettant de récupérer les informations sur l’ordinateur, de les afficher et de les placer dans une base de données MySQL . Notre base de données est composées de tuples (lignes) et d’attributs (colonnes) permettant d’enregistrer et de retrouver aisément l’information recherchée par l’utilisateur c’est-à-dire le spirulinier. On utilise phpMyAdmin pour visualiser rapidement l’état de notre base de données (Figure 2). Il nous permet également de la modifier sans avoir à écrire de requêtes SQL comme décrite précédemment. Ceci simplifie le processus. En outre, il possède un outil d’importation et d’exportation des tables qui nous permettra par la suite d’accéder à notre base de données sur Internet lorsque nous mettrons notre site en ligne.

Figure 2: Capture d’écran de notre base de données

• Un site web :

Pour créer notre site web, nous utilisons le langage PHP. Cependant, le PHP ne permet pas de gérer le contenu de la page web autrement dit sa mise en page. On leur associe alors généralement le langage CSS pour combler cette lacune (Figure 3).

Nous avons besoin d’un site web dynamique qui doit afficher de nouvelles données toutes les heures. Les principaux outils que nous utilisons sont donc :

– le serveur web Apache ;

– le programme PHP qui permet au serveur web d’exécuter des pages PHP ;

– la navigateur qui affiche la page sous forme de fichier HTML.

Figure 3 : Capture d’écran de l’affichage du journal de bord sur notre site web

Perspective d’amélioration :

• Intégrer d’autres capteurs au dispositif existant (couleur, niveau d’eau…).

• Ajouter un Système d’alerte.

• Créer une nouvelle fonction d’actions directes sur le milieu (régulation à distances des paramètres).

Fichier zip des codes utilisés :

Code_Arduino+Python

Projet 11 – De bonnes vagues pour le surf

Envoyé par acallige le 24 Juin 2015 dans Projets, Formation | 0 commentaire

Ce projet a été réalisé dans le cadre d’un projet développement S2 2015 par Jordan Alcaraz, Thomas Abraham, Abdelakrim Bahouss, Alice Calliger sous la supervision de Sylvie Kerouedan et Fabio Tony Braz.

Résumé :
Ces dernières années, l’industrie du surf s’est associée à la technologie pour faciliter l’activité des surfeurs. C’est dans cette même logique que s’inscrit notre projet développement. Il consiste en la conception d’un objet permettant la visualisation de la hauteur et la fréquence des vagues selon les spots. L’objet est destiné aux surfeurs et doit ainsi leur facilité la recherche d’un spot optimal pour surfer.

Outils :

• une carte Intel Galileo
• un câble Ethernet
• un câble USB
• une imprimante 3D
• un ruban à LEDs
• une trentaine de LEDS RGB
• un cadre
• un miroir de la même taille que le cadre
• un film teinté
• un fer à souder, des fils, des planches de bois, des clous, une scie, de la colle

But :

Construire un objet qui permet de visualiser la hauteur et la fréquence des vagues selon le spot sélectionné par l’utilisateur en temps réel.

Contraintes du projet :

La principale contrainte a été d’utiliser une carte Intel Galileo.

Il fallait pouvoir brancher l’objet avec un câble Ethernet et répondre à des critères esthétiques et de fiabilité.

Principe technique :

Notre objet utilise une carte Intel Galileo pour récupérer les données relatives aux spots. Celle-ci se connecte à internet par câble Ethernet, récupère les données affichées sur une page Web codée en PHP, stocke et traite les données, permettant ainsi d’allumer les LEDs en fonction de la hauteur et la fréquence des vagues récupérées. Le choix du  spot se fait à l’aide d’un bouton poussoir. L’actualisation des données se fait tous les 20 clignotements.

Objet réalisé :

Un cadre contenant un miroir et un film teinté, un ruban à LEDs sur le pourtour et des LEDS sur un support en forme de vague imprimé à l’imprimante 3D permet de créer l’illusion d’une profondeur. En effet, selon la hauteur de vagues récupérées, on modifie la couleur des LEDs. De 0 à 2 m, les LEDs s’allument en vert, de 2m à 4m les LEDs sont bleus et au-dessus de 4m elles sont rouges. De plus, la fréquence des LEDs correspond à la fréquence des vagues récupérées sur le site internet. L’utilisateur peut choisir un spot sur 3 spots définis par le constructeur en cliquant sur le bouton poussoire, l’affichage du spot choisi est réalisé à l’aide de LEDs. En effet, la LEDs placée au-dessus du spot s’allume s’il est sélectionné.

Nous avons du utiliser des LEDs discretes RGB car le ruban à LEDs utilisé n’était pas compatible avec la carte Intel Galileo. De plus, la visualisation des vagues se fait à l’aide d’une échelle de couleurs et non d’une échelle d’intensité car les variations de cette dernière étaient peu visibles.

Améliorations possibles :

Notre projet possède néanmoins des pistes d’amélioration :

• laisser le choix à l’utilisateur entre une connexion  Ethernet et Wifi
• permettre à l’utilisateur de visualiser les données d’un plus grand nombre de spots.