Tutoriel de connexion Eduroam sur Raspberry Pi 3
- Version: 1.0
- Date: 28/06/2019
- Auteur: Martín Andrés Pérez
- Contact: martin-andres.perez@imt-altantique.net / martinandres.perez@gmail.com
Dans les universités d’ingénieurs, il est de plus en plus fréquent que des projets soient réalisés sur Raspberry Pi. Aujourd’hui, démarrer ces projets hors ligne est un problème.
Ici à l’IMT, connecter une Raspberry à Internet dépend beaucoup de l’utilisation du réseau Eduroam. Sur la page web d’Eduroam CAT(link) est disponible un installateur qui configure automatiquement le réseau, vous n’avez qu’à indiquer le nom de l’université où vous voulez faire la connexion. C’est la solution la plus simple, mais elle n’a pas fonctionné.
De cette façon, la connexion au réseau Eduroam est devenue un casse-tête et je vais partager avec vous la solution à ce problème. Pour terminer, je vais vous montrer comment j’ai trouvé cette solution.
Étapes à suivre pour se connecter à Eduroam à l’IMT
- Allumer le Raspberry Pi
- Modifier le fichier interfaces:
- Ouvrir le fichier interfaces:
sudo leafpad /etc/network/interfaces - Remplacer le contenu par celui de ce document (link)
- Sauvegarder
- Ouvrir le fichier interfaces:
- Modifier wpa_supplicant.conf:
- Ouvrir le fichier wpa_supplicant.conf:
sudo leafpad /etc/wpa_supplicant/wpa_supplicant.conf - Ajoutez ces lignes au fichier. Remplacez l’identité et le mot de passe par vos identifiants:
network={
ssid="eduroam"
key_mgmt=WPA-EAP
pairwise=CCMP
eap=PEAP TTLS
identity="YOUR-IDENTITY"
anonymous_identity="anonymous@imta.fr"
password="YOUR-PASSWORD"
phase1="peaplabel=0"
phase2="auth=MSCHAPV2"
priority=999
} - Sauvegarder
- Ouvrir le fichier wpa_supplicant.conf:
- Redémarrer et profiter d’Internet
Comment j’ai trouvé la solution
J’ai cherché plusieurs tutoriels sur Internet mais aucun d’entre eux n’a fonctionné pour moi. Les tutoriels CamiGEM2016[1] sur les Instructables et JAN KÜSTER sur leur propre site[2] m’ont aidé à comprendre le processus.
D’autre part, j’ai téléchargé l’installateur proposé par Eduroam CAT. Ce programme d’installation est en fait un fichier Python qui contient tous les paramètres qui doivent aller dans le fichier wpa_supplicant.conf. Donc, pour trouver la solution, j’ai dû analyser le code de python, trouver les paramètres nécessaires et voilà !
Références
- [1] “Access Eduroam on a Raspberry Pi (in Cambridge)” by CamiGEM2016 , https://www.instructables.com/id/Access-Eduroam-on-a-Raspberry-Pi-in-Cambridge/
- [2] “Connecting Raspberry PI to Eduroam using WPA Supplicant” by Jan Küster , https://jankuester.com/connecting-raspberry-pi-to-eduroam-using-wpa-supplicant/
Apprendre à programmer avec Cubetto
Bonjour,
Nous sommes une équipe de trois étudiants en première année à IMT Atlantique.
Notre projet s’inscrit dans le cadre de l’UE Codev (Projet de première année) et consiste en l’élaboration d’un robot de type Cubetto (Figure2) qui est un jeu pour enfant initiant à la programmation, qui se compose d’un petit robot accompagné d’une tablette pour le diriger et d’un tapis de jeu.
L’objectif de notre projet est donc de reproduire le robot Cubetto à moindre coût.
Figure1: Robot Produit Figure 2: Cubetto original
Il s’agit pour l’enfant d’amener son robot d’un point A à un point B et pour cela, il
doit placer sur la tablette l’ensemble des instructions qu’il souhaite donner au robot qui sont représentées par des jetons indiquant chacun une direction(avancer, tourner à droite, tourner à gauche).
Une fois l’ensemble des instructions placées sur la tableau, l’enfant appuie sur le bouton pour transmettre les informations au robot. (Figure 3)
Nous avons choisi une vitesse relativement lente de déplacement, pour assurer
la compréhension de l’enfant.
Après avoir choisi les différentes fonctionnalités en fonction de notre contrainte de budget, nous nous sommes attelés à la fabrication des différents éléments qui constitue ce jeu: le robot, les pièces de déplacement et le boîtier de commande.
Figure3: Boîtier de commande
Pour la partie traitement de données et communication, nous avons utilisé des cartes Arduino et le module WiFi ESP8266 (1Carte Arduino Mega, 2 Cartes Wemos mini).
Nos choix pour le design ont pour but d’assurer la robustesse du jeu et ont été inspiré du robot Cubetto. Pour la reconnaissance des pièces, partie essentielle du jeu, nous avons associé à chaque pièce un mouvement et une valeur de résistance (Figure4) puis dans la tablette, un pont diviseur de tension est utilisé pour lire cette valeur (Figure5 ).
Figure4: Jeton avec résistance à l’intérieur
Figure5: Montage pour la reconnaissance des jetons
Enfin, pour visualiser l’impact de notre projet, nous nous sommes rendus à l’amicale laïque de Plouzané le 26 Juin 2019 pour présenter les différents projets de première année.
En guise de conclusion, nous sommes convaincus que notre projet a pu aider les enfants à développer leur pensée logique voire même à se familiariser avec l’esprit de la programmation.
Ce projet a été réalisé a l’aide du wikidebrouillard où un projet similaire a été développé. Vous y trouverez les montages et des explications détaillées.
:http://www.wikidebrouillard.org/index.php?title=Tableau_de_bord_%C3%A0_programmation_Tangible
Pour télécharger les codes utilisés (Arduino Mega+ ESP Wemos): https://cloud.imt-atlantique.fr/index.php/s/QNLstXWsa7mRJZd/download
LEPORINI Marie, EL MALKI Hatim, BEC Thomas
Projet Codev (N°15) Cubetto
Robotique avec NAO pour la médiation scientifique.
Bonjour,
nous sommes étudiants en première année à l’IMT Atlantique. Dans le cadre d’un projet de première année, nous avons été amené à réaliser une action de médiation scientifique avec le robot NAO dont est propriétaire l’éc
ole.
Comme vous l’aurez compris, notre projet vise à rendre plus attrayante la robotique et la programmation auprès des plus jeunes. Pour cela, nous utilisons le robot humanoïde NAO qui permet de sensibiliser les enfants de primaire à la robotique. Ce robot a la faculté de reconnaître les voix et les visages, de danser et de parler, ce qui permet une grande créativité lors de la programmation.
Pour pouvoir réaliser une petite représentation, nous avons d’abord dû prendre en main le logiciel Chorégraphe qui permet de programmer le robot NAO. Puis, nous avons créé une chorégraphie ainsi qu’une petite interaction sous forme de questions-réponses. Nous avons également choisi d’apprendre à NAO à jouer à pierre-feuille-ciseaux.
Une fois toutes ces applications programmées, nous nous sommes rendus à l’amicale laïque de Plouzané le 26 juin 2019. Avec trois autres groupes, nous avons réalisé une représentation auprès d’élèves allant du CP au CM2.
Il semble que les enfants aient apprécié la représentation de l’ensemble des groupes ! Nous sommes en tous cas satisfait d’avoir pu travailler sur ce projet ! Nous avons mis en lien notre code ce qui peut simplifier le travail de certaines personnes souhaitant reprendre le projet: LIEN VERS LE CODE
Participants : Ludivine LECLERC, Brice ROBERT, Aymeric SCHWEITZER.
Réalisation d’une lampe favorisant l’endormissement par biofeedback
Bonjour à tous !
Nous sommes un groupe de 3 étudiants ayant réalisé un projet durant 4 mois.
L’objectif de ce projet était de développer un objet permettant de maximiser la probabilité de succès d’endormissement ou de relaxation de l’utilisateur. Cet objet doit lui permettre de gagner du temps de sommeil en diminuant le temps mis pour se relaxer et s’endormir.
Cette technologie est déjà présente sur le marché sous le nom de lampe Dodow. Son principe est le suivant : posée à côté du lit, elle diffuse de la lumière bleue qui s’intensifie et s’atténue régulièrement, et de façon imperceptible, de plus en plus lentement. Tel un métronome lumineux, elle ralentit le flux des pensées de l’utilisateur dont le seul rôle est d’essayer de faire coïncider les fluctuations de la lampe et sa respiration. Cependant, elle n’est pas forcément optimisée car la luminosité de la lampe fluctue de la même manière quel que soit l’individu, quel que soit son niveau de relaxation. Elle agit donc de la même manière que la personne soit initialement très calme ou alors très stressée.
Ainsi, l’objectif de ce projet était plus précisément de développer une technologie de relaxation adaptée à tout type d’individu à partir du modèle de la lampe Dodow.
Il fallait donc développer une lampe dont la luminosité peut fluctuer en fonction de la fréquence cardiaque dans un délai imparti.
Cette lampe est composée de trois modes de fonctionnement : mode “capteur cardiaque”, mode “manuel”, et mode “sans réglages”.
Le mode “capteur cardiaque” est le mode clé du projet : durant un délai imparti, la fluctuation de la luminosité de la lampe s’adapte à la fréquence cardiaque de l’utilisateur grâce à un capteur.
Le mode “manuel” permet de régler la fluctuation initiale de la luminosité de la lampe. Ensuite, la fluctuation varie automatiquement durant le délai imparti.
Le mode “sans réglages” est un mode semblable au fonctionnement de la lampe Dodow : le rythme de fluctuation de la luminosité est préréglé. La luminosité fluctue ensuite automatiquement durant le délai imparti.
Cette lampe dispose de trois types de boutons. Le premier est un switch, il permet d’allumer ou d’éteindre notre lampe. Le deuxième est un bouton poussoir, il permet de changer le mode d’utilisation. A la mise en route de la lampe, aucun mode n’est défini mais la lampe dispose de trois boutons poussoirs. Chacun d’entre eux permet de mettre en route l’un des modes d’utilisation. Enfin, le dernier bouton est un Slider, il permet de régler le rythme de fluctuation de la luminosité lorsque l’on est dans le mode manuel.
Cette lampe a été développée sous Arduino, vous pourrez donc retrouver le code utilisé ainsi que nos livrables et une vidéo de démonstration dans ce cloud : https://cloud.imt-atlantique.fr/index.php/s/wCQaxKnciQFAGYi
L’équipe Codev n°16 : Matthias LE JALLE, Louise DEBUSSCHER et Mathura CHANDRAKUMAR
Développement d’une borne d’arcade
Bonjour à tous !
Nous avons aujourd’hui le plaisir de vous présenter la construction d’une borne d’arcade. C’est un projet que nous avons mené dans le cadre du Codev (projet Conception et Développement) en 1ère année du cursus ingénieur d’IMT Atlantique.
Commençons par regarder cette petite vidéo qui en quelques secondes vous montre le système en pleine utilisation par un des groupes d’enfants de l’Amicale Laïque de Plouzané à qui nous avons fait la démonstration.
Si cela vous intéresse d’en savoir un petit peu plus sur la construction de cette borne d’arcade, poursuivez votre lecture.
Résumé :
Alors que fait cette borne ? Et bien en plus de la structure et des jeux qu’elle fait fonctionner, nous voulions lui apporter des caractéristiques supplémentaires et ainsi créer un objet original et divertissant.
La première fonctionnalité qui la rend unique est la détection de badge. Le joueur peut avec n’importe quel badge RFID se connecter à la borne d’arcade et avoir son propre compte ! Nous pouvons donc nous connecter avec le badge de l’école. La seconde fonctionnalité découle alors de la première : avoir un compte personnel oui, mais où vont nos données ? Nous avons décidé de stocker toutes les données des joueurs sur une base de données SQL. Ainsi dès qu’un jeu se termine, les scores sont directement envoyés, les classements se mettent à jour, les statistiques s’affinent. Et pour voir tout cela, nous avons finalement développé un site internet via HTML, CSS et PHP. Nous avons eu la chance d’être hébergés par le RESEL (Réseau des Elèves). Nous pouvions alors en nous connectant via shh et avec un FTP comme Filezilla créer le site où tous les joueurs se retrouveraient pour découvrir leurs performances ainsi que celles de leurs camarades. A l’heure actuelle, vous pouvez encore vous connecter sur https://arcade.codev.resel.fr/ nous espérons que cela restera encore possible pour les années futures. Le cas échéant, merci d’apporter une modification à ce papier afin d’adresser correctement notre site.
Commençons par vous donner quelques photos de la conception purement matérielle de la borne :
Tout d’abord, voyons le plan que nous avons dessiné pour conceptualiser le système :
Voyons maintenant quelques étapes de la construction :
Et le résultat est là comme vous avez pu le constater sur la vidéo de présentation.
Pour les plus curieux, on poursuit avec la partie électronique à l’intérieur de la borne !
On y retrouve de nombreux éléments :
- Les deux cartes qui centralisent les connections des 2 joysticks et des 15 boutons
- Un hub USB pour gérer tous nos périphériques
- Deux cartes Arduino, une pour executer les codes de RFID… et l’autre pour le côté esthétique avec les nombreuses animations lumineuses qu’elle contient.
- Une carte mère et un écran, récupérés sur un ordinateur qui devait finir à la casse !
Finissons par aborder la communication entre les différents éléments de la borne. Voyons tout d’abord quel est le petit diagramme SQL que nous utilisons pour structurer notre base de données :
Conclusion : Voilà, la présentation de notre borne d’arcade touche à sa fin, nous espérons que vous aurez pu comprendre son fonctionnement. Comme promis, vous pouvez retrouver tous les codes utilisés, notre rapport détaillé et quelques vidéos de démonstration sur notre espace cloud dont le lien de téléchargement est le suivant : https://cloud.imt-atlantique.fr/index.php/s/8jxarR2xwoFzRgT/download
Allez ensuite dans le dossier Telefab et trouvez votre bonheur 🙂
Merci d’avoir pris le temps de nous lire.
Thomas Claudet pour l’équipe Codev (Julien Aboudaram, Matthias Prevost, Julien Lantrin, Thomas Claudet).
Système d’arrosage automatique
Nous sommes deux étudiant à l’IUT (Institut Universitaire de Technologie) et nous avons fait notre stage de fin d’étude à l’IMT Atlantique au sein de Fablab.
nos objectifs du stage :
- créer des fiches techniques pour plusieurs capteurs utilisés dans le projet.
- réaliser un système d’arrosage automatique.
- contrôler le système à distance.
Création du fiche techniques:
Nous avons reçu un colis qui contient « smart plant care Kit »et deux capteurs supplémentaires d’humidité de terre.
Pour voir le contenu du kit, voici le manuel : http://wiki.seeedstudio.com/Grove_Smart_Plant_Care_Kit/
nous avons tout d’abord créé une fiche technique pour chaque capteur d’humidité de terre (un capteur Grove, GoTronic et DFRobot).
chaque fiche contient les spécifications électroniques, le branchement du capteur sur la carte Arduino UNO et un exemple simple de code.
Le but était de comparait les trois capteurs d’humidité de terre pour choisir le meilleur et de comprendre la fonctionnalité de chaque capteur.
Installation du système:
Ensuite nous avons commencé l’installation d’un système d’arrosage automatique tout d’abord par la création d’une fiche technique pour chaque capteur de système (cliquer ici pour accéder aux fiches techniques).
Exemple: le branchement de capteur humidité de terre
Puis nous avons testé un démo code fournit par Arduino (cliquer ici pour voir le démo code) pour vérifier le bon fonctionnent du système et pour bien comprendre l’algorithme de ce code et afin de créer notre propre code qui respecte les meilleures conditions d’arrosage.
Avant de commencer l’écriture de notre propre code nous avons fait une recherche sur les meilleures conditions d’arrosage pour garder plante en état parfait.
les conditions optimales pour arroser une plante :
• La majorité des plantes doit être uniformément humide, donc elle dépend d’un arrosage régulier.
• Il vaut mieux arroser rarement qu’arroser souvent mais avec peu d’eau.
• Il vaut mieux arroser tard le soir au lieu d’arroser tôt le matin, car l’eau s’évapore moins pendant le soir qu’en pleine journée.
• Il faut garder les feuilles sèches, car des feuilles mouillées devienne en générale des feuilles malades.
• If faut arroser de manière ciblée ce qui signifie que la quantité exacte d’eau atteint les racines.
• Il vaut mieux arroser autant que nécessaire et peu que possible, cela se fait grâce à un système d’arrosage automatique.
Description de l’algorithme du programme:
Un arrosage automatique sera effectué lorsque les mesures nécessaires pour l’arrosage tombent sous un seuil prédéfini respectant la météo autour du système
pour cela nous avons défini les seuils suivants (en considérant que le système sera installé à Brest) :
• Humidité de terre inférieure à 60%
• Humidité de l’air inférieure à 95%
• Température inférieure à 24 °C
• Indice UV inférieur à 2
Cliquer ici pour accéder à notre code.
Contrôle du système à distance:
Notre étape suivante était de créer une application pour faire la connexion entre le système d’arrosage et un portable de système Android afin de contrôler l’arrosage manuellement (l’application a été créé sous « MIT App Inventor 2 ».
La connexion entre le portable et le système d’arrosage se fait grâce au module Bluetooth « HC-05 », Ce module permet d’envoyer les commandes vers le système d’arrosage et de recevoir les mesures venant de ce système et les transmettre vers le portable.(cliquer ici pour accéder à l’application )
Finalement voici une photo de notre produit final.
Voir le manuel pour plus de détails sur le branchement final du système.
Nous avons réussi à créer une fiche technique pour chaque capteur et installer un système d’arrosage automatique contrôlé par téléphone via Bluetooth.
Réalisé par:
Ali Alkhathami & Khaled Alhowas
Fiches techniques: Capteur Humidité de Terre
Le Fablab possède différents capteurs d’humidité de terre. Ce sont des capteurs analogiques et peuvent tous être alimentés en 3.5V ou 5V.
-
Condition Min Max Unité Tension 3,3 5 V Courant 0 35 mA Valeur de sortie Le capteur dans un sol sec 0 300 Le capteur dans un sol mouillé 300 700 Le capteur dans l’eau 700 950
le branchement de capteur humidité de terre
Code d'Exemple pour afficher la valeur d'humidité
int MoisturePin = A1;
int MoistureValue = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
// read the value from the Moistur sensor:
MoistureValue = analogRead(MoisturePin);
Serial.print("Moisture = " );
Serial.println(MoistureValue);
delay(1000);
}
Math Escape Room
Développement d’un jeu de type « Escape Room » par Lucas Bonmarin, Hélène Couret, Maximiliano Hill et Maher Ouali.
Résumé
Pour faciliter l’apprentissage des mathématiques, nous avons développé une application d’« Escape Room » qui permet : aux élèves de répondre à des énigmes pour s’échapper virtuellement de la maquette, aux enseignants de gérer les énigmes. Enfin l’application interagit aussi avec les autres éléments du jeu.
Contexte
Afin de rendre plus ludique l’apprentissage de leur matière, les professeurs du collège Saint-Pol de Roux à Brest nous ont demandé de concevoir une application de type « Escape Room » permettant de répondre à des énigmes mathématiques pour s’échapper d’une maquette domotique.
Architecture de l’application
Afin de réaliser ce jeu, nous nous sommes servis d’une application Android qui permet aux élèves de répondre aux énigmes pour avancer dans le jeu, aux enseignants de gérer les énigmes et enfin qui exécute les liens avec les autres éléments du jeu. En effet, cette application est reliée par Bluetooth à la maquette domotique et également au serveur qui accueille la base de données formée des énigmes.
Notre projet est donc composé de trois parties distinctes :
– l’application Android,
– la base de données qui stocke les énigmes et
– la maquette domotique.
Architecture
Base de données
La base de données stocke les énigmes. Elle contient une seule table appelé “énigmes”. Ces énigmes sont stockées sous la forme de files qui contiennent 4 colonnes :
– la question,
– la réponse correcte et
– deux réponses fausses.
Serveur WEB
Le serveur web dynamique prend en charge les requêtes client-serveur grâce au Daemon http (apache). Les scripts php interprètent ensuite les demandes des clients et les traduit.
Protocole Arduino
Le protocole de communication conçu spécialement pour ce projet permet de transmettre chaque tâche de l’application à la maquette de manière unique et fiable.
Maquette
Maquette domotique
La maquette est équipée d’actionneurs et de capteurs. Elle rend l’application interactive grâce à l’allumage de LED, l’ouverture d’un portail ou l’appui sur un buzzer.
5 LEDs
5 résistances d’environ 200 ohms (pour protéger les LEDs)
4 boutons poussoirs
1 buzzer
1 photo-résistance
Conclusion
L’application est fonctionnelle et la maquette aussi. Cependant, nous n’avons pas pu rencontrer les professeurs du collège Saint-Pol de Roux donc le projet pourrait être amélioré au cours de l’année prochaine pour pouvoir leur présenter.
Réalisation d’une brodeuse numérique à partir d’une machine à coudre
Le but de ce projet est de créer un module sur une machine à coudre afin de la transformer en brodeuse numérique. Ce module peut s’ajouter et s’enlever de la machine afin qu’elle puisse garder sa fonction première. Notre travail a donc premièrement été de construire la partie physique du module.
figure 1 : module final
Le tambour, qui permet de tendre le tissu à broder, est relié à un rail denté. Celui-ci est entraîné en translation par un moteur relié à un pignon. Les trois autres pignons permettent au rail de tenir sa trajectoire. Les pignons et le rail reposent sur une plateforme en bois qui est la partie supérieure d’un boîtier.
figure 2 : boîtier et tiges métalliques
Deux tiges métalliques passant dans des roulements à billes traversent ce boîtier. Une courroie est reliée au moteur et permet le déplacement selon la direction perpendiculaire à celle du rail denté. Ce système est contraint à beaucoup moins de frottement que celui à base de rouages et d’une crémaillère en bois, il est donc plus facile pour le moteur d’entraîner le boîtier. Le boîtier abrite la carte Arduino qui est reliée aux moteurs.
La seconde partie du projet a été de convertir une image numérique en commandes pour les moteurs. Nous avons tout d’abord téléversé sur la carte Arduino un code qui permet d’interpréter un G-code, et donc de transformer ce Gcode en commande de rotation des moteurs. Ce code est commun à n’importe quel motif à broder. Il nous a alors fallu convertir le motif à broder en G-code et envoyer ce code à la carte Arduino. Nous pouvons faire cette conversion à l’aide du logiciel Inkscape. Pour ce faire, un certain nombre d’étapes sont à suivre :
- Il faut effectuer une symétrie centrale sur l’image du motif à broder, car le G-code obtenu est celui dans le cas où l’aiguille de la machine à coudre se déplace, or dans notre cas c’est le module qui se déplace tandis que l’aiguille garde une position fixe.
- Il faut choisir des « Points d’orientation », c’est-à-dire fixer un repère sur l’image afin de s’assurer que les déplacements vont s’effectuer dans le sens voulu et à partir du point de départ voulu. Ils servent aussi à gérer les différentes transformations de l’image (symétrie, translations, etc…).
- Une fois cette étape réalisée, Inkscape possède l’outil « Objet en chemin » qui permet de préparer l’utilisation de Gcodetools en posant le chemin à suivre.
- Enfin il faut utiliser « Chemins vers G-code » qui convertit effectivement le chemin calculé en la suite de commandes voulues. Des flèches indiquent le chemin tracé.
Un logiciel permet ensuite d’envoyer le fichier vers la carte Arduino, et les moteurs réagissent instantanément aux commandes reçues.
Elodie Derringer, Charles Rivière et Alexandre Ly
Code téléversé sur la carte Arduino
#code pour une découpeuse laser, l'axe z ne sert à rien.
#include <Servo.h>
#include <AFMotor.h>
#define LINE_BUFFER_LENGTH 512
char STEP = MICROSTEP ;
// Servo position for Up and Down
const int penZUp = 115;
const int penZDown = 83;
// Servo on PWM pin 10
const int penServoPin =10 ;
// Should be right for DVD steppers, but is not too important here
const int stepsPerRevolution = 200;
// create servo object to control a servo
Servo penServo;
// Initialize steppers for X- and Y-axis using this Arduino pins for the L293D H-bridge
AF_Stepper myStepperY(stepsPerRevolution,2);
AF_Stepper myStepperX(stepsPerRevolution,1);
/* Structures, global variables */
struct point {
float x;
float y;
float z;
};
// Current position of plothead
struct point actuatorPos;
// Drawing settings, should be OK
float StepInc = 1;
int StepDelay = 0;
int LineDelay =0;
int penDelay = 50;
// Motor steps to go 1 millimeter.
// Use test sketch to go 100 steps. Measure the length of line.
// Calculate steps per mm. Enter here.
float StepsPerMillimeterX = 100.0;
float StepsPerMillimeterY = 100.0;
// Drawing robot limits, in mm
// OK to start with. Could go up to 50 mm if calibrated well.
float Xmin = 0;
float Xmax = 40;
float Ymin = 0;
float Ymax = 40;
float Zmin = 0;
float Zmax = 1;
float Xpos = Xmin;
float Ypos = Ymin;
float Zpos = Zmax;
// Set to true to get debug output.
boolean verbose = false;
// Needs to interpret
// G1 for moving
// G4 P300 (wait 150ms)
// M300 S30 (pen down)
// M300 S50 (pen up)
// Discard anything with a (
// Discard any other command!
/**********************
* void setup() - Initialisations
***********************/
void setup() {
// Setup
Serial.begin( 9600 );
penServo.attach(penServoPin);
penServo.write(penZUp);
delay(100);
// Decrease if necessary
myStepperX.setSpeed(1000);
myStepperY.setSpeed(1000);
// Set & move to initial default position
// TBD
// Notifications!!!
Serial.println("Mini CNC Plotter alive and kicking!");
Serial.print("X range is from ");
Serial.print(Xmin);
Serial.print(" to ");
Serial.print(Xmax);
Serial.println(" mm.");
Serial.print("Y range is from ");
Serial.print(Ymin);
Serial.print(" to ");
Serial.print(Ymax);
Serial.println(" mm.");
}
/**********************
* void loop() - Main loop
***********************/
void loop()
{
delay(100);
char line[ LINE_BUFFER_LENGTH ];
char c;
int lineIndex;
bool lineIsComment, lineSemiColon;
lineIndex = 0;
lineSemiColon = false;
lineIsComment = false;
while (1) {
// Serial reception - Mostly from Grbl, added semicolon support
while ( Serial.available()>0 ) {
c = Serial.read();
if (( c == '\n') || (c == '\r') ) { // End of line reached
if ( lineIndex > 0 ) { // Line is complete. Then execute!
line[ lineIndex ] = '\0'; // Terminate string
if (verbose) {
Serial.print( "Received : ");
Serial.println( line );
}
processIncomingLine( line, lineIndex );
lineIndex = 0;
}
else {
// Empty or comment line. Skip block.
}
lineIsComment = false;
lineSemiColon = false;
Serial.println("ok");
}
else {
if ( (lineIsComment) || (lineSemiColon) ) { // Throw away all comment characters
if ( c == ')' ) lineIsComment = false; // End of comment. Resume line.
}
else {
if ( c <= ' ' ) { // Throw away whitepace and control characters
}
else if ( c == '/' ) { // Block delete not supported. Ignore character.
}
else if ( c == '(' ) { // Enable comments flag and ignore all characters until ')' or EOL.
lineIsComment = true;
}
else if ( c == ';' ) {
lineSemiColon = true;
}
else if ( lineIndex >= LINE_BUFFER_LENGTH-1 ) {
Serial.println( "ERROR - lineBuffer overflow" );
lineIsComment = false;
lineSemiColon = false;
}
else if ( c >= 'a' && c <= 'z' ) { // Upcase lowercase
line[ lineIndex++ ] = c-'a'+'A';
}
else {
line[ lineIndex++ ] = c;
}
}
}
}
}
}
void processIncomingLine( char* line, int charNB ) {
int currentIndex = 0;
char buffer[ 64 ]; // Hope that 64 is enough for 1 parameter
struct point newPos;
newPos.x = 0.0;
newPos.y = 0.0;
// Needs to interpret
// G1 for moving
// G4 P300 (wait 150ms)
// G1 X60 Y30
// G1 X30 Y50
// M300 S30 (pen down)
// M300 S50 (pen up)
// Discard anything with a (
// Discard any other command!
while( currentIndex < charNB ) {
switch ( line[ currentIndex++ ] ) { // Select command, if any
case 'U':
penUp();
break;
case 'D':
penDown();
break;
case 'G':
buffer[0] = line[ currentIndex++ ]; // /!\ Dirty - Only works with 2 digit commands
// buffer[1] = line[ currentIndex++ ];
// buffer[2] = '\0';
buffer[1] = '\0';
switch ( atoi( buffer ) ){ // Select G command
case 0: // G00 & G01 - Movement or fast movement. Same here
case 1:
// /!\ Dirty - Suppose that X is before Y
char* indexX = strchr( line+currentIndex, 'X' ); // Get X/Y position in the string (if any)
char* indexY = strchr( line+currentIndex, 'Y' );
if ( indexY <= 0 ) {
newPos.x = atof( indexX + 1);
newPos.y = actuatorPos.y;
}
else if ( indexX <= 0 ) {
newPos.y = atof( indexY + 1);
newPos.x = actuatorPos.x;
}
else {
newPos.y = atof( indexY + 1);
indexY = '\0';
newPos.x = atof( indexX + 1);
}
drawLine(newPos.x, newPos.y );
// Serial.println("ok");
actuatorPos.x = newPos.x;
actuatorPos.y = newPos.y;
break;
}
break;
case 'M':
buffer[0] = line[ currentIndex++ ]; // /!\ Dirty - Only works with 3 digit commands
buffer[1] = line[ currentIndex++ ];
buffer[2] = line[ currentIndex++ ];
buffer[3] = '\0';
switch ( atoi( buffer ) ){
case 300:
{
char* indexS = strchr( line+currentIndex, 'S' );
float Spos = atof( indexS + 1);
// Serial.println("ok");
if (Spos == 30) {
penDown();
}
if (Spos == 50) {
penUp();
}
break;
}
case 114: // M114 - Repport position
Serial.print( "Absolute position : X = " );
Serial.print( actuatorPos.x );
Serial.print( " - Y = " );
Serial.println( actuatorPos.y );
break;
default:
Serial.print( "Command not recognized : M");
Serial.println( buffer );
}
}
}
}
/*********************************
* Draw a line from (x0;y0) to (x1;y1).
* int (x1;y1) : Starting coordinates
* int (x2;y2) : Ending coordinates
**********************************/
void drawLine(float x1, float y1) {
if (verbose)
{
Serial.print("fx1, fy1: ");
Serial.print(x1);
Serial.print(",");
Serial.print(y1);
Serial.println("");
}
// Bring instructions within limits
if (x1 >= Xmax) {
x1 = Xmax;
}
if (x1 <= Xmin) {
x1 = Xmin;
}
if (y1 >= Ymax) {
y1 = Ymax;
}
if (y1 <= Ymin) {
y1 = Ymin;
}
if (verbose)
{
Serial.print("Xpos, Ypos: ");
Serial.print(Xpos);
Serial.print(",");
Serial.print(Ypos);
Serial.println("");
}
if (verbose)
{
Serial.print("x1, y1: ");
Serial.print(x1);
Serial.print(",");
Serial.print(y1);
Serial.println("");
}
// Convert coordinates to steps
x1 = (int)(x1*StepsPerMillimeterX);
y1 = (int)(y1*StepsPerMillimeterY);
float x0 = Xpos;
float y0 = Ypos;
// Let's find out the change for the coordinates
long dx = abs(x1-x0);
long dy = abs(y1-y0);
int sx = x0<x1 ? StepInc : -StepInc;
int sy = y0<y1 ? StepInc : -StepInc;
long i;
long over = 0;
if (dx > dy) {
for (i=0; i<dx; ++i) {
myStepperX.onestep(sx,STEP);
over+=dy;
if (over>=dx) {
over-=dx;
myStepperY.onestep(sy,STEP);
}
delay(StepDelay);
}
}
else {
for (i=0; i<dy; ++i) {
myStepperY.onestep(sy,STEP);
over+=dx;
if (over>=dy) {
over-=dy;
myStepperX.onestep(sx,STEP);
}
delay(StepDelay);
}
}
if (verbose)
{
Serial.print("dx, dy:");
Serial.print(dx);
Serial.print(",");
Serial.print(dy);
Serial.println("");
}
if (verbose)
{
Serial.print("Going to (");
Serial.print(x0);
Serial.print(",");
Serial.print(y0);
Serial.println(")");
}
// Delay before any next lines are submitted
delay(LineDelay);
// Update the positions
Xpos = x1;
Ypos = y1;
}
// Raises pen
void penUp() {
penServo.write(penZUp);
delay(penDelay);
Zpos=Zmax;
digitalWrite(15, LOW);
digitalWrite(16, HIGH);
if (verbose) {
Serial.println("Pen up!");
}
}
// Lowers pen
void penDown() {
penServo.write(penZDown);
delay(penDelay);
Zpos=Zmin;
digitalWrite(15, HIGH);
digitalWrite(16, LOW);
if (verbose) {
Serial.println("Pen down.");
}
}
Réparation et remise en fonctionnement d’imprimantes 3D
Dans le contexte du projet développement du deuxième semestre de la formation d’ingénieur généraliste d’IMT Atlantique, nous avons réparé puis remis en fonctionnement deux imprimantes 3D.
Imprimantes 3D – Projet DEV – FIG S2
Ces imprimantes, commandées par la mairie de Brest, seront installées dans des lieux publiques et à destination du grand public. Ainsi il faut qu’elles soient simples d’utilisation et facilement réparables par un personnel qualifié. Elles ont fait l’objet d’une première tentative de montage il y a plusieurs années, au Fablab de l’école, mais celui-ci n’a jamais été finalisé. Depuis, elles ont été entreposées dans un coin du Fablab, et ont souffert de pillage, les utilisateurs se servant dans ses composants pour leurs activités. Notre projet se place donc dans la lignée de ce qui a été fait précédemment sur ces machines.
Les imprimantes ayant été commandées par la ville de Brest, la mairie est le client du projet. Cependant le Fablab de l’école, et ses responsables, ont été nos interlocuteurs durant le déroulé du projet. Ainsi c’est avec eux que nous avons pu définir dans un premier temps un cahier des charges. Ce document nous a permis de définir clairement les tâches à accomplir.
Nous avons commencé par démonter les deux imprimantes, afin de ne garder que leur ossature. Un inventaire détaillé des pièces présentes à pu être ainsi fait. En parallèle de cette tâche, dès qu’une pièce électronique était jugée défectueuse, nous la réparions, en utilisant le plus possible le matériel déjà existant. Une fois ces deux tâches terminées, nous nous sommes attaqués au remontage d’une première imprimante. Lors de celui-ci, nous nous sommes aperçus que les pièces supportant les moteurs souffraient d’un défaut d’impression conduisant à une déformation de celles-ci. Nous avons donc décidé de les réimprimer en utilisant les imprimantes 3D du Fablab. Cette partie a été la plus longue car nous avons été confrontés à de nombreux problèmes techniques qui nous ont empêchés d’imprimer correctement ces pièces. Nous avons donc décidé de contacter des connaissances à l’EESAB, l’UBO et aux Petits Débrouillards, afin de savoir de leur demander de l’aide sur l’impression de nos pièces. En parallèle, nous avons décidé de remonter entièrement une imprimante avec les pièces défaillantes, dans la mesure du possible, en attendant de pouvoir résoudre nos problèmes. La seconde imprimante a été remontée depuis le début, ossature comprise, afin de permettre la prise de photos pour la documentation que nous avons fourni.
Une vidéo à été réalisée lors du test de l’imprimante remontée. Elle est disponible ici : test_imprimante_3D.
Nous nous sommes de plus engagés à rédiger un manuel. Celui-ci a pour but de permettre le montage et la réparation des imprimantes. Nous sommes entre-temps tombés sur une page de wiki suffisamment complète, détaillant pas à pas les étapes du montage pour la version 2.5 des imprimantes Foldarap. Cette page de wiki est disponible sur le site du wikifab. Notre manuel de montage renvoie donc vers cette dernière page. Le reste de son contenu consiste en un inventaire complet des pièces nécessaires aux montage de l’imprimante RepRap FoldaRap 2.5, celui-ci se découpant en deux sous-parties : un inventaire des composants regroupés par catégories et un inventaire sectionné selon les différentes parties de l’imprimante. Les deux sous-inventaires avaient été rédigés en anglais pour être compréhensibles par tous les membres de l’équipe. Seul le deuxième, l’inventaire par parties, a été traduit en français dans sa quasi-totalité. Le reste du document est composé de méthodes que nous avons mises en œuvre lors du montage et de la réparation des imprimantes. Nous les avons pensé utiles pour toute personne novice dans l’utilisation des outils que nous avons pu employer.
