Projet de tourelle d’Airsoft
Dans le cadre de l’inter-semestre «Fablab ou comment concevoir à peu près tout…» j’ai souhaité réaliser un projet sur un sujet qui me passionne: l’ Airsoft. Tout d’abord, l’ Airsoft est un jeu de rôle mêlant stratégie et tactique qui ressemble au Paintball, et dans lequel les joueurs utilisent des répliques d’armes à feu qui tirent des billes en plastique de 6mm de diamètre. Je me suis donc penché sur l’élaboration d’une tourelle d’ Airsoft, un genre de drone fixe. Durant la semaine d’intersemestre, j’ai réalisé une commande d’un moteur à courant continue à distance grâce à des Arduino. Ce moteur devait servir à assurer la rotation autour de l’axe vertical.
Matériel Nécéssaire:
- 2 Arduinos UNO
- 2 shield XBee
- 1 joystick
- 1 breadboard
- 1 pont en H LMD18200
- 1 moteur à courant continue
- 1 batterie 9V
Montage Électronique:
- La manette:
- Le contrôleur
Le pont en H:
Le fonctionnement:
La manette capte la position des deux axes du joystick et du bouton intégré. Il envoie ensuite ces informations via le module XBee. Par contre il n’est possible de n’envoyer que des variable au format d’un CHAR id est sur un octet. Il faut donc adapter l’information au préalable. La manette envoie aussi un symbole ( 255) entre chaque cycle afin d’assurer la synchronisation. Il faut bien sûr s’assurer que ce symbole n’est jamais utilisé à d’autres fins.
Le contrôleur met le pin correspondant à l’entrée direction du pont en H au niveau haut ou bas en fonction de l’information reçue. Ensuite il applique une tension analogique sur l’entrée » PWB input » qui est fonction de la position du joystick. (J’ai eu quelques bug que je n’ai pas eu le temps de corriger sur ce montage, il est possible qu’il faille envoyer un signal créneau en faisant varier le rapport cyclique en fonction de la position du joystick pour que ça marche mieux.)
La partie Mécanique:
Ce projet contient aussi une partie mécanique. La propulsion des billes devait se faire à l’aide de pièces récupérée sur une vielle réplique électrique. J’ai réalisé la structure de la tourelle en bois.
J’ai aussi commencé à réaliser des modèles 3D sous Solidworks pour assurer la mobilité autour de l’axe vertical. Il s’agit d’un rail qui va guider des roue et d’une crémaillère. Ces pièces sont destinées à être imprimées par l’imprimante 3D du Téléfab.
Suite du projet:
L’objectif final du projet est de réaliser une tourelle autonome qui pourra être guidée à distance via un smartphone. Disposant d’un Raspberry Pi, je compte refaire la partie logicielle en Python en utilisant les connecteurs GPIO du Raspberry. Il me faudra ensuite réaliser l’interface Android pour guider la tourelle. Je compte aussi mettre une webcam afin de renvoyer la vidéo sur le smartphone. Il faut aussi que je finalise les différentes pièces sous Solidworks, que je les imprimes et que je monte le tout. Enfin il me restera encore beaucoup de boulot pour automatiser le tout. Donc si ça vous intéresse de contribuer au projet, n’hésitez pas! 😉
LED’s draw !
Quand un Smartphone et un Arduino dessinent ensemble
« LED’s draw ! » est un projet mené durant la première semaine d’intersemestres « FabLab » (du 21 janvier au 1er février 2013), en collaboration avec l’intersemestre « Bootcamp ». Le projet a été mené par Gaëtan FAYON et Etienne LOUBOUTIN pour la partie « matérielle » du projet, et par Victor DUBOIS et François GUÉGAN pour la partie logicielle (application Smartphone).
« LED’s draw ! » permet de dessiner une image sur son Smartphone (Android) et de l’envoyer sur une matrice à LED 32×16. La matrice reproduit alors l’image à l’identique.
Pour réaliser ce projet, le matériel suivant a dû être utilisé :
- un Arduino UNO ;
- un Arduino MEGA ADK ;
- une matrice à LED (32×16) ;
- un Smartphone (Android) ;
- un environnement de développement JAVA-Android.
Veuillez également vous rendre à cette page (http://developer.android.com/tools/adk/adk.html) pour bien configurer les deux parties du montage (la partie Arduino et la partie Android) pour pouvoir les faire communiquer de la meilleure des manières possibles.
Schéma du montage électronique
Pour développer ce projet, nous avons tout d’abord songer à utiliser une liaison Bluetooth entre le Smartphone et un Arduino BT-V06. Seulement, nous n’avons absolument pas réussi à faire fonctionner ce dernier (de nombreux mystères semblent être à résoudre de ce côté-là : faire fonctionner ce composant se révèle être issu d’un facteur chance assez incroyable). Nous avons alors essayer de faire fonctionner un autre module Bluetooth, le RFM70, sans toutefois plus de succès. Il y a donc moyen d’améliorer le système mis au point en essayant de faire fonctionner ces différents modules de manière convenable.
Au final, le montage réalisé correspond à celui-ci :
A la vue de ce schéma, une question simple doit se poser : pourquoi avoir utiliser deux Arduino (un UNO et un MEGA ADK, soit un pour gérer l’affichage des donnée sur la matrice et un autre pour gérer le flux de donner arrivant du portable) alors que l’Arduino MEGA ADK possède à priori assez de pins pour gérer cela tout seul. Cependant, celui utilisé semblait avoir un problème pour alimenter correctement la matrice à LED en 5V. Nous sommes donc passer par un Arduino UNO pour le faire. Pour faire la liaison entre les deux Arduino, nous avons réalisé un pont I2C, en reliant la pin COM/SDA20 (respectivement COM/SCL21) de l’Arduino MEGA ADK à la pin ANALOG/A4 (respectivement ANALOG/A5) de l’Arduino UNO.
Principe du codage (côté Arduino)
Voici le principe général du projet, informatiquement parlant :
Pour faire simple, l’Arduino MEGA ADK doit gérer ce qui vient du port USB hôte (relié au Smartphone de l’utilisateur). Il reçoit trois données principales : la couleur de la LED à allumer, ses coordonnées et l’intensité de la LED. La couleur est codée sur un octet : 00000000 pour aucune couleur, 00000001 pour la couleur verte, 00000010 pour la couleur rouge et 00000011 pour la couleur orange. On utilise un octet et non deux bits pour la simplicité du protocole, sachant que l’on reçoit les données du Smartphone par octets obligatoirement via le protocole USB, il faudrait sinon dépaqueter chacun des octets. Pour les coordonnées, on sépare l’axe X et l’axe Y : chacun est codé sur un octet et varie soit entre 0 et 15 soit entre 0 et 31 (on utilise une matrice à LED 32×16). L’intensité est également codé sur un octet et varie entre 0 et 15.
L’Arduino MEGA ADK transmet ensuite ces informations à l’Arduino UNO via I2C, et l’Arduino UNO réoriente ces données vers la matrice à LED, en branchant tout ces composants comme il l’est indiqué sur le schéma de montage précédent. Il faut prêter attention à bien connecter les pins de la matrice à LED de manière convenable avec les pins de l’Arduino UNO. Le meilleur moyen de ne pas se tromper et d’utiliser un branchement à base de détrompeur, que vous pouvez créer vous-même si vous avez les composants nécéssaires. Dans tous les cas, si vous respecter les branchements donnés sur le schéma, il n’y aura aucun soucis (d’autant plus que le nom des pins est donné au dos de la matrice à LED).
Au niveau codage, il n’y a rien de bien compliqué, une fois les bonnes librairies téléchargées. Vous pouvez télécharger librement les codes :
- Codes pour l’Arduino MEGA ADK ;
- Codes pour l’Arduino UNO ;
- Librairies pour les compilations des codes (à insérer dans votre répertoire principale de codage) : pour la matrice, pour l’Arduino MEGA ADK et pour la liaison USB.
Principe du codage (côté Android)
Le codage de la partie Android du projet nécessite quant à elle d’être plutôt à l’aise avec la programmation JAVA et des bases solides au niveau de la programmation Android. Pour vous former, n’hésitez pas à consulter les nombreux tutoriels existant sur Internet : à chaque problème existe une recherche Google adéquate !
Pour débuter, je vous propose de commencer par l’excellent tutoriel disponible à cette adresse : http://nbenbourahla.developpez.com/tutoriels/android/introduction-programmation-android/.
Pour en revenir à notre application en elle-même, cette application permet :
- d’enregistrer ou charger (via un mot clé et une commande vocale) une configuration de la grille ;
- d’allumer/éteindre une LED, ou une ligne/colonne entière ;
- d’établir le choix de la couleur pour chaque LED ;
- mélanger la grille en secouant le Smartphone.
Pour approfondir sur le thème de la commande vocale, il suffira par exemple que l’utilisateur dise le mot « maison », pour qu’un dessin de maison s’affiche à la fois sur le Smartphone et sur la matrice à LED. On peut également sélectionner la couleur par commande vocale.
Au niveau de l’interface proposé, voilà ce que nous avons réussi à avoir pour le moment :
Le code de cette application Android contient de nombreuses classes, pour télécharger les codes sources, cliquez sur les liens suivants :
Pour télécharger directement l’application, il est nécessaire de se rendre sur ce site : http://codecamp2013.pbworks.com/w/page/62944320/applis2013.
Perspectives d’amélioration
Actuellement, la connexion entre le Smartphone et la matrice à LED se fait via une connexion filaire USB. Le premier objectif est donc de passer en sans-fil (Bluetooth ou Wi-Fi). Afin de donner tout son sens au projet. Les nombreux problèmes que nous avons eu pour gérer les différents modules Bluetooth nous ont conduit à utiliser une connexion filaire. Cependant, si vous arrivez à dompter l’Arduino BT-V06, vous pourrez supprimer l’Arduino MEGA ADK de la chaîne de transmission (ce qui réduira par la même occasion l’encombrement du système). En effet, vous pourrez dès lors uploader votre code sur l’Arduino BT-V06 via votre ordinateur (si ce dernier est équipé d’un module Bluetooth) et en même temps utilisé cet Arduino comme récepteur des informations envoyés par le Smartphone. Pour les plus curieux d’entre vous, un tutoriel pour s’initier à la manipulation de cet Arduino ce trouve ici : http://www.pobot.org/Arduino-BT.html. Il faudra également mettre à jour le code Android pour que les données qui sont envoyées à l’Arduino le soient par Bluetooth et non par USB.
Une autre amélioration possible est d’ajouter du côté de la matrice à LED un capteur de luminosité pour ajuster automatiquement l’intensité des couleurs en fonction de la luminosité ambiante (il faudra alors s’équiper d’une photorésistance et suivre notamment le tutoriel disponible ici à la cinquième étape).
Documentation complémentaire
- Documentation interne pour la création de l’environnement de liaison entre l’Arduino MEGA ACK et le Smartphone : [COMING SOON]
- Documentation relative à la prise en main de l’Arduino BT-V06 : http://arduino.cc/en/Guide/ArduinoBT ;
- Documentation pour la réalisation d’une liaison Bluetooth entre un microcontrôleur et un Smartphone sous Android : http://nononux.free.fr/index.php?page=elec-brico-bluetooth-android-microcontroleur ;
- Documentation relative à la connexion I2C : http://arduino.cc/forum/index.php/topic,32645.0.html et http://www.arduino.cc/en/Reference/Wire.
Comment faire un « Makey Makey » avec un Arduino
Vous connaissez le Makey Makey ? Si non, allez vite ici : www.makeymakey.com
Si vous avez envie d’en reproduire le principe, rien de plus simple. Avec un Arduino, il est aussi possible de déclencher des événements en giflant quelqu’un, par exemple. Il suffit d’une entrée ADC sur l’Arduino, et de brancher dessus une résistance d’une dizaine de MΩ en « pull-up » (c’est-à-dire entre l’entrée et la tension d’alim). Ensuite, en connectant quelque chose à l’entrée ainsi modifiée, le signal sera exploitable sur le logiciel. Attention, il faut que ce quelque chose soit relié à la masse via une résistance de quelques dizaines de MΩ au maximum. Si la résistance est trop grande, on peut augmenter la résistance du « pull-up » pour augmenter la plage de détection de l’événement.
Design d’un émetteur infrarouge
Pour concevoir une télécommande à courte portée, le plus simple est d’utiliser la technologie infrarouge. Cependant, si les composants sont faciles à trouver et peu chers, il faut prendre quelques précautions pour les utiliser, notamment pour l’émetteur.
En effet, on ne peut pas envoyer une information numérique telle qu’elle directement à une diode infrarouge. Les ondes infrarouges seraient atténuées trop rapidement et la portée de notre émetteur sera très faible. Il faut donc moduler l’information. C’est pour cela que tous les récepteurs du commerce intègrent un démodulateur et ne détectent l’information que sur une certaine fréquence. Ainsi, même si le récepteur et l’émetteur sont tout près, une information non modulée ne parviendra pas au récepteur.
Il existe pourtant une façon très simple de faire un modulateur pour une diode infrarouge. On va utiliser un NE555, composant de base pour tous les montages nécessitant une horloge ou un élément gérant le temps. Ce composant va nous générer un signal créneau de 38kHz, la fréquence porteuse de la plupart des commandes infrarouges. Il suffit ensuite de brancher la diode infrarouge sur sa sortie, et un transistor 2N2222 entre la diode et la masse pour envoyer l’information à moduler. Voici un schéma du montage :
Ainsi il est possible de communiquer via infrarouge avec la plupart des récepteurs existants.
Bien entendu, il est aussi possible de changer la fréquence du signal généré par le NE555, pour une autre application par exemple. Pour cela il suffit de changer la valeur des résistances du montage en fonction des équations données dans la datasheet du composant.
Multiplexage d’ADC sur Arduino
Les cartes Arduino sont idéales pour s’initier à la programmation, ou bien réaliser simplement de petits projets d’électronique. Elles disposent d’I/O numériques, de sorties numériques PWM ainsi que d’entrées analogiques, les ADCs. Cependant, dans certains cas, la carte étudiée n’a pas un nombre suffisant d’entrées ou de sorties. Au lieu de monter en gamme de matériel ou tout simplement de doubler le microcontrôleur, nous allons voir qu’il est possible de contourner ce problème. Pour le prix d’une sortie numérique du microcontôleur, nous pourrons doubler le nombre d’entrées analogiques.
Par exemple, supposons que nous avons besoin de 32 entrées analogiques alors qu’au maximum, les cartes Arduino n’en proposent que 16. Nous allons utiliser des multiplexeurs externes 1:2 afin de pouvoir connecter 2 informations analogiques sur une seule entrée ADC de l’Arduino. Il faut donc un multiplexeur par ADC dans notre cas. Les entrées de commande des multiplexeurs ont juste besoin d’être reliées ensemble sur une sortie numérique du microcontrôleur. Voici un schéma de la réalisation hardware :
Au niveau software, pour scanner les entrées, on va procéder 16 par 16. On fixe d’abord une valeur pour la commande des multiplexeurs, puis on scanne les 16 entrées qui sont disponibles. Il suffit ensuite de changer la commande des multiplexeurs et de scanner encore les 16 ADCs. On a alors parcouru les 32 entrées. Voici le code correspondant au multiplexage d’une entrée :
int sensorPin = A0; // sélectionne l'ADC
int muxPin = 22; // sélectionne le pin de commande des mux
int sensorValue = 0; // variable pour stocker la valeur de l'ADC
int mux = 0;
void setup() {
pinMode(muxPin, OUTPUT);
}
void loop() {
sensorValue = analogRead(sensorPin); // on lit l'ADC
if(mux==0){
// commandes pour la première entrée
}
else{
// commandes pour la seconde entrée
}
mux = 1 - mux; // on change d'état le pin de commande mux
digitalWrite(muxPin, mux);
delay(10);
}
L’opération est bien entendu 2 fois plus longue que pour 16 entrées, mais ce temps peut être négligeable selon l’application. Il est aussi possible de multiplier les entrées analogiques par 3 ou 4 en utilisant des multiplexeurs 1:3 ou 1:4, mais le temps de scan sera multiplié d’autant.
