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.
Détection de mouvement 3D appliquée à un jeu vidéo
Notre projet [1] consiste en la création d’un système de détection de mouvements 3D appliqué à un jeu vidéo avec le mouvement de la main.
Nous avons constaté que les technologies Kinect sont couteuses et complexes pour beaucoup. Nous avons donc souhaiter dans notre projet, modéliser notre propre système de détection de mouvement. Le montage a ainsi l’avantage d’être facilement réalisable. et nous avons codé un jeu vidéo comme 1ère application de ce système.
Figure 1 – Le projet (interface du jeu vidéo à gauche et montage à droite avec la main d’un joueur)
Pour réaliser le montage [2], on a besoin de :
– 6 résistances : 3 x 220K , 3x10K
– Une carte Arduino
– 3 Pinces Crocodile
– Des files
– 3 Plaques en bois
– Feuilles Aluminium
Figure 2 – Montage physique
Le montage physique consiste en la réalisation du circuit suivant:
PLATE1, PLATE2, PLATE3 correspondent aux plaques de bois couvertes par le papier aluminium et connectées par les pinces crocodiles.
PIN8, PIN9, PIN10 correspondent aux portes de la cartes Arduino.
Nous constituons d’une part la partie création du système de détection de mouvement et d’autre part réalisons la conception et code du jeu vidéo.
Tout d’abord, pour le système de détection de mouvements 3D il faut réaliser le montage physique et électrique. Constitué des plaques de bois et des feuilles d’aluminum, c’est plutôt rapider de réaliser la boite [2]. Nous avons accroché les pinces crocodiles à chacune des plaques avec des files accrochés à ces pinces.
Cela demande un travail plus minutieux pour le montage électrique en effet, nous avions 6 résistances (3 de 220K ohms et 3 de 10K ohms) que nous devions connecter à la carte d’Arduino et aux files connectés à la plaque.
Puis, nous avons codé en Arduino un programme permettant de récupérer les temps de décharge des feuilles d’aluminum selon le mouvement de la main dans la boite en temps réel (temps de réponse de 0,1s). Alors avec un calibrage est réalisé pour faire une analyse des valeurs obtenues en temps réel pour enfin obtenir la positon de la main dans les coordonnées cartésiennes (x, y, z). On a déterminé des valeurs de seuil pour diviser la boite deux parties : une zone haute et une zone basse selon la position de la main.
Ensuite la partie conception du jeu vidéo est réalisée en Python avec le module Pygame. Pour la première application du jeu vidéo , nous voulons un jeu vidéo avec un avatar qui bouge seulement selon un plan horizontal. Le joueur avec sa main peut contrôler la positon verticale de l’avatar qui avance de gauche à droite avec une vitesse qui augmente linéairement.
L’une des plus grosses difficultés est de réaliser la connexion entre les deux parties de notre projet : la carte Arduino qui rend compte des mouvements du joueur et le jeu vidéo. Il est facile de trouver des tutoriels sur internet proposant de coder un script Python permettant d’aller lire les informations sur le port série via lequel la carte Arduino transmet les informations. Cependant dans notre projet nous utilisons aussi une librairie nécessaire pour coder le jeu : Pygame. Il y a une mauvaise interaction entre ces deux parties du code : si une même action peut être réalisée par une frappe de clavier (ceci est un « événement » dans la terminologie Pygame), et par une lecture port série, il y a un conflit et cette dernière s’arrête. La solution (qui nous a pris longtemps à trouver !) tient à simplement supprimer les doublons : une action n’est désormais liée qu’à une seule condition, soit une action sur l’ordinateur, soit un mouvement du joueur. Le simple fait de ne pas proposer deux façons de piloter notre petit Gandalf était donc la meilleure manière de rendre notre
code fonctionnel.
Durant notre projet, nous nous sommes principalement concentrés sur la partie détection. Si à l’avenir un groupe d’élèves souhaiterait continuer le projet, il peut être très facile de ne pas réitérer nos recherches sur cette partie et de l’exploiter directement : le code sera à votre disposition. Il serait donc possible de travailler sur un jeu plus « fin ». En effet, notre système est suffisamment précis pour multiplier les commandes (nous ne proposions que deux positions, haute et basse). L’utilisations de deux modules de détections (un pour chaque main) permettrait de doubler les possibilités de pilotage. Il devient clairement envisageable de piloter un jeu de plateforme. Si le projet vous intéresse et que vous avez des questions, n’hésitez pas à nous joindre !
Vidéo de présentation
Code + explications :
https://github.com/isival/Detection-de-mouvement-3D-appliquee-a-un-jeu-video
Auteurs :
BONAUD Victoire
EL BEJI Sarah
FAVIER Mathis
VALETTE Isidore
Médiation scientifique au collège Kerallan avec Nao le Robot
Sous la supervision de Mathilde Ménoret et Sylvie Kérouedan nous avons, dans le cadre de notre projet de Développement de première année, mené à terme un projet de médiation scientifique auprès d’une classe de cinquième d’un collège local (Kerallan).
Objectif :
L’objectif était de rendre accessible la programmation et la robotique à des enfants qui n’ont pas encore un solide bagage scientifique. Il fallait pour cela vulgariser, voire démystifier, la robotique et la programation, qui passent, à tort, pour difficiles, sinon inaccessibles. Pour cela, nous avions prévu de faire une présentation interactive avec ladite classe de collège. La présentation se devait de mobiliser les élèves, et de les amener à réfléchir pour qu’ils programment, de manière simplifiée, le robot humanoïde Nao.
Aperçu du programme par blocs que nous avions écrit
Déroulement
Dans un premier temps, nous nous sommes familiarisés avec le robot. Pour cela nous avons du apprendre à nous servir de Chorégraphe, le logiciel fourni par le créateur du robot (Aldebaran Robotics), qui permet entre autres de faire de la programmation par blocs.
Après cette phase de prise en main, nous avons entamé une phase de réflexion sur ce que la présentation devant la classe de collège devait contenir. Nous avons donc défini des objectifs pédagogiques précis. Cela s’est traduit par des exercices de niveau progressif, que les élèves allaient devoir résoudre grâce à des cartes représentant les blocs présent dans le logiciel Chorégraphe. Pour introduire ces exercices devant les élèves, nous avons programmé Nao pour qu’il soit capable de se présenter lui-même à l’oral, ainsi que d’expliquer quelques principes sur son fonctionnement mécanique et informatique. En parallèle de la prise de parole de Nao, nous avions préparé un support visuel qui permettait aux élèves de mieux appréhender les différentes parties du robot et ses composants.
Le jour J
Le jour de la présentation, l’important était à notre avis d’être véritablement acteurs de l’enseignement que nous proposions. Nous avions réparti la classe en plusieurs groupes de 4 élèves. Grâce à cela, nous avons pu faire le tour des groupes lors de la résolution des différents exercices, pour expliciter les points qui restaient obscurs, et expliquer des notions plus avancées aux élèves avec des facilités. La phase d’exercices était précédée de phases d’explications des notions algorithmiques de boucle et de conditions. Nous faisions ces explications au tableau, en essayant de prendre des exemples parlants pour les élèves. Chaque exercice était suivi d’une correction, où les élèves pouvaient voir le résultat de leur réflexion s’animer à travers Nao, que nous programmions de manière à effectuer les programmes proposés par les élèves. Lorsqu’une interaction humaine était nécessaire pour tester le robot, les élèves se pressaient pour se porter volontaires et tester grandeur nature le programme qu’ils venaient d’écrire.
Pour plus d’informations, rendez-vous sur notre GitHub : https://github.com/mithridate-lulwat/DEV
Moad Yakoubi, Amine Dassouli, Saïf-Eddine Boukhdir
Élèves ingénieurs généralistes 1A
