1. Introduction

L’adage « la seule limite à la création est l’imagination » n’a jamais été aussi trompeur que lorsque l’on en est à ses débuts en informatique. C’est du moins ce que je me suis dit après quatre semaines de travail acharné lors de la création du S.A.F.E. Né au sein du cours complémentaire d’informatique le but de ce projet était à la base simple. Il s’agissait une grue pouvant se déplacer sur trois axes avec la possibilité de soulever des objets légers polarisés en utilisant le plus possibles des éléments de récupération. Bien que dans l’absolu, le système à fonctionnement électromagnétique ait plusieurs applications, l’idée de départ était qu’il serve de base à de futurs projets. Dans l’ensemble conception du projet est une réussite. En effet, malgré les tonnes de difficultés rencontrées au cours du développement la machine fait, au final, ce qu’on lui demande. Ce billet servira à décrire toutes les étapes du développement, relatera les différents problèmes et en présentera les limitations.

2. Matériel

Ci dessous ce trouve la liste du matériel utilisé lors de la conception du modèle. Cependant beaucoup d'éléments sont des objets de récupération et ne se trouvent donc pas dans le commerce. De plus on se concentrera sur les pièces électroniques et laissera de coté certaines pièces génériques de la partie mécanique.

2.1 Mécanique

  • Set de pièces LEGO (récupérées sur différents jouets)
  • 8x Roues LEGO (récupérées sur différents jouets)
  • Planches en bois de dimensions diverses (planches de récupération à dimensions diverses)
  • Soutiens en bois (50cm, récupéré)
  • 4x Rails en aluminium (50cm)
  • Châssis de soutien en métal (récupéré)
  • Fil de fer (récupéré)
  • Vis de dimensions diverses

2.2 Electronique

  • Raspberry Pi 3 (Model B)
  • Adafruit DC & Stepper Motor HAT for Raspberry Pi
  • Adafruit MCP3008 Analog/Digital Converter
  • Analog PS2 Joystick
  • 3x DC Motors 9V (récupérés du LEGO NXT)
  • Adafruit TIP120 Darlington Transistor
  • Electroaimant 12V DC
  • Interrupteur ON/OFF & LEDs
  • Breadboard
  • Câbles & Résistances
  • Allimentation 9V (Pile 9V en l’occurrence)
  • Alimentation 12V (récupéré)

3. Méthode

Ce projet étant plutôt imposant, il était difficile de l’aborder sans le diviser en parties moins conséquentes. De ce fait, j’ai divisé la tâche en trois ; le côté purement mécanique où il s’agira de construire l’artefact imaginé, le côté électronique où les composants sont reliés entres eux à grand renfort de câbles et pour finir la partie logicielle où il s’agira d’écrire le code indispensable au fonctionnement de l’engin.

3.1 Mécanique

Cette partie purement physique du projet s’avéra moins difficile que prévu à mettre en œuvre. Il fut cependant nécessaire de bien réfléchir aux différentes options s’offrant à moi. Lorsque le projet n’en était encore qu’à ses balbutiements, les premières idées étaient la traction par poulies où encore à pression hydraulique. Elles furent cependant bien vite abandonnées au profit d’un système a roues ; beaucoup plus stable et impliquant moins de forces de tensions. La construction de l’artefact est elle même divisée en trois : Le char gérant le Switch ainsi que l’axe X, le châssis transversal et le socle. Ces éléments furent construis dans cet ordre afin de minimiser les imprécisions. L’ensemble est fait presque entièrement d’éléments de récupération. Le centre du système étant les DC moteurs LEGOS NXT, le choix des pièces LEGOS pour la transmission et le châssis du char est tout naturel.

3.1.1 Char Axe X et Switch

Cette voiturette postée au sommet de l’artefact est entièrement construite en LEGOS. A la base se situe le DC moteur de l’axe X avec une transmission directe sur les roues motrices. Pour faire contrepoids le second DC moteur se situe symétriquement sur les roues non actionnées laissant un espace au centre pour l’électroaimant. Celui ci est simplement attaché à une poulie reliée au moteur par un fil de fer. Une « barrière se situe au dessus pour éviter au câbles de s’emmêler. Char_Axe_X___Switch.jpg

3.1.2 Châssis Transversal Axe Y

Ce châssis est la deuxième partie amovible du projet. La transmission et le soutien des roues est fait en briques LEGO tandis que les rails en aluminium sont fixés à un socle en métal lui même vissé au LEGOs. Le moteur est accroché au rails grâce à de l’adhésif double faces. La transmission du moteur fait toute la longueur de l’objet et est malheureusement un peu tordue, il était en effet compliqué de faire autrement. La largeur entre les rails est la taille déterminée par l’espacement des roues du char et la longueur de l’objet est fixée à 50 cm. Chassis_transversal_Axe_Y.jpg

3.1.3 Socle

La dernière partie est un socle haut de 15cm et large de 50cmx50cm sur lequel se déplacera le châssis. Celui est simplement fait de deux tréteaux sur lesquels sont fixés deux planches de 15cmx50cm ainsi qu’une plaque de 50cmx50cm. On fixera des rails au sommet pour permettre au système de rouler sans accros. Socle.jpg

Avec ces trois parties on dispose d’un artefact qui peut se déplacer sur tout un plan et d’un électroaimant pouvant se positionner à n’import quel point du volume du cube. Il ne restera qu’à actionner les différents éléments.

3.2 Electronique

Ce point fut, de loin, le plus complexe à réaliser avec des difficultés allant du choix des pièces aux problèmes de connexion où à la longueur des câbles. J’ai divisé cette partie en plusieurs étapes encore une fois pour simplifier la réalisation. Premièrement il y a l’implémentation du Joystick analogique et de la puce MCP3008. Ensuite le DC/Stepper Motors HAT et sa connexion aux moteurs et pour finir l’électroaimant et son interrupteur.

3.2.1 Joystick Analogique & Puce MCP3008

Le joystick analogique qui permettra de contrôler les moteurs est particulièrement intéressant car ses potentiomètres permettent de lire l’intensité de la pression exercée par le doigt. Des lors il devient possible de régler dynamiquement la vitesse de l’engin. Cependant le Raspberry Pi ne dispose pas d’entrées analogiques sur son GPIO. C’est ici qu’entre en jeu la puce MCP3008 qui servira à convertir les données analogiques en données digitales. Il est intéressant de savoir que cette puce est compatible au protocole SPI bien que celui ci ne sera pas utilisé ici. Le Joystick et la puce seront connectés comme suit au Raspberry selon la documentation mise à disposition sur internet. La résistance permet d’enlever le grain dans les valeurs obtenues. Joystick_Analogique___Puce_MCP3008.jpg

3.2.2 DC/Sepper Motor HAT & DC Motors

Le câblage des moteurs fut une question compliquée à régler. Premièrement, ils nécessitent une tension de 9V et donc sont impossible de connecter en l’état au raspberry, il est nécessaire d’utiliser un driver. Ensuite, à quoi bon avoir un Joystick analogique si la vitesse du système ne varie pas. La première idée fut de connecter ses moteurs à des DC Motors drivers classiques que l’on relierait au GPIO. Cependant je me suis vite aperçu que le nombre de pins disponible sur le GPIO viendrait à manquer. Heureusement le HAT d’adafruit est venu à mon secours. Non seulement le protocole I2C permet de lui allouer une adresse et de n’utiliser que 2 pins sur le GPIO mais il possède aussi une puce PWM permettant de gérer la vitesse des moteurs et sa propre entrée de courant allant jusqu'à 12V parfait pour y brancher l’alimentation. La prochaine étape fut de brancher les moteurs au HAT. Des DC Motors classiques n’auraient pas posés de problèmes malheureusement les moteurs NXT LEGO se branchent avec des câbles à six entrées type téléphonique. Heureusement, LEGO fournit les schematics de ses moteurs NXT. Après avoir dénudé les câbles d’un coté, on branchera le blanc et le noir au HAT. DC_Stepper_HAT___DC_Motors.jpg

3.2.3 Electroaimant & Interrupteur

La dernière partie à câbler est l’électroaimant ainsi que l’interrupteur l’actionnant. Pour l’interrupteur, rien de plus simple, il est simplement relié au courant et à une pin du GPIO en entrée pour connaître son état. L’électroaimant ne peut, lui pas être connecté directement au courant. En effet, la bête reçoit 12V ce qui ferait griller le raspberry en un rien de temps. C’est pour cela qu’on le connectera au tip120 transistor capable de subir une telle décharge. Une pin du GPIO est utilisée pour contrôler l’activation de l’aimant. Attention l’électroaimant a un sens de connexion, se tromper risque de le surchauffer. Electroaimant___Interrupteur.jpg

L’ensemble du câblage permet d’être plutôt économique en terme de pins utilisées. Cependant je conseille prévoir des câbles de connectiques long pour la connexion au moteurs et à l’aimant afin d’éviter les mauvaises surprises au démarrage et être retenu par des câbles trop courts. Avant de commencer à s’amuser avec l’engin, il ne restera plus qu’à le programmer.

3.3 Logiciel

La programmation du S.A.F.E fut la partie la plus facile du projet. Premièrement les librairies mises à disposition par les différents constructeurs de pièces détachées aident beaucoup de plus le projet étant essentiellement électronique, le code était des plus simple. Il a fallut télécharger les librairies Adafruit_MCP3008_Python_Library ainsi que Adafruit_Motor_HAT_Python_Library sur GITHUB puis les installer avant de pouvoir commencer le programme. Le code étant pourvu de commentaires explicites il sera simplement affiché ici mais pas décrit.

#!/usr/bin/python
#
#S.A.F.E Script V1.0
#
#Disclaimer:
#Avant de lancer le code installer les libraires
#Adafruit_MotorHAT
#Adafruit_MCP3008

#Importer les librairies que le code utilisera
import RPi.GPIO as GPIO  
from Adafruit_MotorHAT import Adafruit_MotorHAT, Adafruit_DCMotor
import time
import atexit
import time
import Adafruit_GPIO.SPI as SPI
import Adafruit_MCP3008

#Set l adresse I2C (par default 0x60)
motorHat = Adafruit_MotorHAT(addr=0x60)

#Methode de stop moteur lors de l arret du programme
#Necessaire sinon les moteurs tournent en continu une fois le programme stoppe
def turnOffMotors():
    motorHat.getMotor(1).run(Adafruit_MotorHAT.RELEASE)
    motorHat.getMotor(2).run(Adafruit_MotorHAT.RELEASE)
    motorHat.getMotor(3).run(Adafruit_MotorHAT.RELEASE)
    motorHat.getMotor(4).run(Adafruit_MotorHAT.RELEASE)

atexit.register(turnOffMotors)

##Variables
#PINS GPIO
Button=17
Electro=16

#Boolean dans le code 
On=False
Down=True
SwitchOn=False

#PINS Software SLI pour le MCP3008
CLK  = 21
MISO = 19
MOSI = 18
CS   = 20

#Set le Joystick Analogique avec pour sorties les PINS Software SLI
Joystick = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)

#X, Y, Switch Motors
xAxisMotor=motorHat.getMotor(1)
yAxisMotor=motorHat.getMotor(2)
SwitchMotor=motorHat.getMotor(3)

#GPIO PINS
GPIO.setup(Button, GPIO.IN)
GPIO.setup(Electro, GPIO.OUT)

#On reset les moteurs avant le debut au cas ou
xAxisMotor.run(Adafruit_MotorHAT.RELEASE)
yAxisMotor.run(Adafruit_MotorHAT.RELEASE)
SwitchMotor.run(Adafruit_MotorHAT.RELEASE)

##Code
while (True):
#On recupere la valeur du Joystick pour la transformer en vitesse moteur
#Pour enlever le grain on divise par 10
#75 est la vitesse maximum set pour plus de precision
 SwitchJoyValue=Joystick.read_adc(0)
 xMotorSpeed=(((Joystick.read_adc(1)/10)-51)*75)/51
 yMotorSpeed=(((Joystick.read_adc(2)/10)-51)*75)/51

#La vitesse du moteur est reglee dynamiquement en fonction du Joystick
#Moteur X
 if xMotorSpeed>=0:
  xAxisMotor.run(Adafruit_MotorHAT.FORWARD)
  xAxisMotor.setSpeed(xMotorSpeed)
 else:
  xAxisMotor.run(Adafruit_MotorHAT.BACKWARD)
  xAxisMotor.setSpeed(-xMotorSpeed)

#Moteur Y
 if yMotorSpeed>=0:
  yAxisMotor.run(Adafruit_MotorHAT.FORWARD)
  yAxisMotor.setSpeed(yMotorSpeed)
 else:
  yAxisMotor.run(Adafruit_MotorHAT.BACKWARD)
  yAxisMotor.setSpeed(-yMotorSpeed)

#Switch, necessite 3 etats; arret, montee, descente
#On utilise un systeme de conditions 
 if SwitchJoyValue>1000 and SwitchOn==True:
 #Descente, Montee
  Down=not Down
 #Allume, Etteint
  SwitchOn=not SwitchOn 
  time.sleep(0.2)
 elif SwitchJoyValue>1000 and SwitchOn==False:
  SwitchOn=not SwitchOn
  time.sleep(0.2)
 elif SwitchOn==True and Down==True:
  SwitchMotor.run(Adafruit_MotorHAT.FORWARD)
  SwitchMotor.setSpeed(50)
 elif SwitchOn==True and Down==False:
  SwitchMotor.run(Adafruit_MotorHAT.BACKWARD)
  SwitchMotor.setSpeed(50)
 elif SwitchOn==False:
  SwitchMotor.run(Adafruit_MotorHAT.FORWARD) 
  SwitchMotor.setSpeed(0)
 
##Electroaimant
#On recupere l'information de l'interupteur pour lancer l'aimant
 pressed = GPIO.input(Button)
 if pressed==0:
  On= not On
  time.sleep(0.5) 
 if On==True:
  GPIO.output(Electro, GPIO.HIGH)
 else:
  GPIO.output(Electro, GPIO.LOW)

4. Résultats

Le projet est dans l’ensemble une réussite, toutes les fonctions ont pu être intégré à temps et aussi bien individuellement qu’ensemble, chacun des composants fonctionne. Il reste cependant toujours des éléments à améliorer ou des paramètres à implanter mais au final le S.A.F.E fait ce pourquoi il à été pensé à la base, déplacer des objets magnétisés d’un point A à un point B. Voici une petite vidéo de démonstration du fonctionnement de l’artefact.

5. Discussion

Dans l’absolu, les problèmes rencontrés furent plutôt nombreux allant des problèmes techniques attendus au départ comme la construction d’un système stable ou le câblage d’autant de composants à des problèmes totalement inattendus comme la longueur des câbles ou le nombre de pins disponible sur le raspberry.

5.1 Problèmes

Chacun de ces problème nécessitèrent des solutions qui elle même entrainèrent parfois de nouveaux problèmes créant des cercles vicieux avec pour seule solution, repenser le concept depuis zéro. Par exemple le système de descente de l’aimant fut totalement repensé en cours de route. En effet, il était prévu qu’un tube de plastique soit descendu grâce à des roues dentées mais après plusieurs essais catastrophiques j’ai opté pour un fil enroulé, technique beaucoup plus sure. De plus les problèmes sont souvent masqués et il n’est pas rare qu’il faille revoir un à un les branchement et debuger une à une les lignes de codes avant de s’apercevoir que l’alimentation n’était pas branchée mais quelle joie lorsque tout à coup le déclic se fait et un à un les composants commencent à fonctionner.

5.2 Améliorations

Si je pouvais améliorer la machine ou en construire une version plus élaborée, mon regard se tournerait vers la partie mécanique. En effet, c’est ici que subsiste le plus de problèmes. Le premier étant le trop grand nombre d’imprécision fait au cours des mesures et de la construction ce qui à pour effet de déséquilibrer légèrement le système. De plus, de puissants Stepper Motors seraient bien plus précis et permettrai d’appliquer l’idée de base qui consistait à donner les directions à l’engin au moyen de coordonnées. De plus, il serait intéressant de réfléchir à un autre procédé pour faire descendre l’aimant. Le fait d’utiliser des matériaux récupérés et d’avoir une contrainte temporelle fut une autre source de stress qu’il fallut gérer mais cela a permis d’avoir une machine plus ou moins fonctionnelle pour moins de 50.- ce qui n’est pas négligeable.

6. Conclusion

Le projet ce conclu sur une belle réussite personnelle puisqu’après quatres semaines le S.A.F.E fonctionne. Bien sur cette réussite est teintée de quelques regrets quant à la conception et au manque de temps mais le but de départ a été atteint. On notera qu'il à parfois fallut trouver quelques combines pour outrepasser les nombreux problèmes. Au final malgré les nombreuses restrictions qui se posaient des le départ, on peut affirmer sans mentir que "l'imagination est la seule limite à la création".