Planet Arduino

Si vous vous intéressez aux bobines Tesla, ou à tout autre montage tournant autour de la haute tension, vous avez dû être confronté à un moment ou un autre à la réalisation d’une bobine, voir, d’une bobine de grande longueur. Assez rapidement dans ce cas, on se rend compte qu’il vaut mieux être deux : un qui gère la rotation de la bobine, et l’autre qui gère l’avance du fil. Seulement voilà, on n’a pas toujours 2 mains supplémentaires de disponibles. On se contente donc souvent d’une vitesse de rotation (très) lente, de manière à pouvoir gérer l’avance du fil avec les mains, et tout arrêter en cas de soucis en cours de bobinage.  L’inconvénient de cette méthode est que lorsque ça se passe bien, on est limité à cette fameuse vitesse lente, alors qu’on pourrais gagner beaucoup de temps en accélérant.
L’idée, pour améliorer tout ça est d’utiliser un contrôle supplémentaire pour la vitesse de rotation, à savoir une pédale, comme pour les machines à coudre. Bon, n’ayant pas trouvé de pédale de machine à coudre, je m’en suis fabriqué une, qui était dès le début prévue pour ce genre d’usages.

Sans assistance, ce genre de bobine tourne vite au cauchemar

Voulant faire des essais de slayer exciter, j’avais donc besoin d’une bobine de bonne longueur, ce qui était l’occasion rêvée pour tester mon concept jusqu’au bout. Bon, comme le titre le laisse penser, j’ai fait ça à l’arrach, avec premiers outils qui me tombaient sous la main. Ca permet de tester le système avant de passer à une réalisation plus pérenne.  La pédale est équipée d’un potentiomètre, dont la valeur est lue par un arduino. L’entraînement de la bobine se fait avec un moteur pas à pas, piloté par un driver pololu. La bobine de fil est montée sur un dévidoir d’étain.

Concernant le fonctionnement, le moteur accélère lorsqu’on appuie sur la pédale, et s’arrête lorsqu’on relâche complètement. L’avantage, c’est que ça permet de se repositionner de temps en temps, et de prendre une pose si besoin. (Le point de colle visible sur la vidéo ci-dessous est justement là pour bloquer le fil lors d’une pose). La vitesse de rotation est gérée en augmentant/diminuant le délai entre chaque pulse envoyée au module pololu.
Au final, j’ai trouvé ça très pratique, la bobine en question aura été réalisée en moins d’un quart d’heure, là où il m’aurais fallu certainement une bonne heure sans assistance, avec en plus une qualité probablement moindre.

Ceux qui me suivent depuis un petit moment déjà auront remarqué qu’il ne s’agit pas là de mon premier coups d’essai. Mon précédent compteur geiger fonctionnait bien, mais j’avais envie (besoin) d’avoir une info un peu plus précise que ce que peuvent apporter une série de « bip-bip » plus ou moins rapprochés. C’était également pour moi l’occasion de ne plus seulement survoler l’aspect fonctionnel de la chose, mais faire en sorte d’avoir une mesure cohérente, en rapport avec les specs précises du tube utilisé un SBM-20 (СБМ-20), un grand classique.

Pour ce montage, le but étant la mesure, hors de question donc de me contenter d’une tension « à peu près » comme pour le montage précédent. Et comme j’ai également besoin de remonter des infos plus précises, passage (quasi) obligé par un écran LCD, et donc un microcontrolleur. Cependant, je trouvais que l’information « analogique » gardait un certain intérêt (instantanée), et un petit coté « ambiance » pour le bi-bip.

La nouvelle version du compteur geiger.

Le montage comporte donc parties distinctes :

• L’alimentation haute tension, qui délivrera 400V (et pas plus )
• Le tube geiger qui fera la détection
• Le microcontrolleur qui comptera le nombre d’impulsions et affichera la mesure sur l’écran LCD
• Un mini circuit audio, piloté par l’arduino, qui donnera les pulses audio.

La partie alimentation, est un montage élévateur simple, à base de NE555, mosfet et inductance. Il s’alimente entre 9 et 12v et permet d’obtenir une tension supérieure aux 400v requis (dans les 480v). Un condensateur 600v est placé en sortie afin de lisser la tension, et de parer aux pics de consommation induits par le tube lorsqu’il est en présence de matériaux très radioactifs. La tension est ensuite limitée a 400v via deux diodes zener de 200V en série.Lors de mes premiers tests, je n’avais pas mis les zener, et le tube était en état de saturation quasi-permanente, faussant ainsi toute mesure.

A la sortie du tube, le signal est récupéré par un optocoupleur, afin de transmettre l’information au microcontrolleur sans les parasites qui vont avec. Une petite subtilité ici, une LED est placée en parallèle de l’optocoupleur, elle m’a servis lors de la mise au point notamment, afin de m’assurer que les taux mesurés étaient bien identiques des 2 cotés de l’optocoupleur.

La partie microcontrolleur est assurée par un Arduino très fortement dépouillé Je n’ai gardé que l’Atmega328p, le quartz et les condensateurs… La programmation peut se faire ultérieurement en connectant un adaptateur usb2serial à l’emplacement prévu. Je n’ai pas prévu de connecteur ICSP, il est donc impératif d’utiliser des Atmega avec un bootloader préchargé.
Le comptage des impulsions se fait en comptant non pas les fronts montants, mais les fronts descendants. En effet, le comptage des fronts montants était trop soumis aux perturbations de l’alimentation HT à proximité, alors qu’avec les fronts descendants, plus de soucis. Le pullup interne de l’arduino est donc activé, lorsque l’optocoupleur devient passant, la tension à la borne de l’arduino devient nulle. Le comptage se fait en utilisant une interruption matérielle, qui incrémente un compteur, en parallèle de l’incrémentation d’un timer.

Schéma dosimètre, cliquez pour télécharger le PDF

Comme indiqué précédemment, la pulse audio est envoyée par l’arduino, plutôt qu’en prise directe. Deux intérêts à cela : pas de perturbation de la mesure du fait de problèmes d’impédances, et ça me permet un debug plus facile en comparant cette sortie à l’état de la led placée en parallèle de l’optocoupleur.

Les prochaines étapes : le faire étalonner par un copain qui bosse au CEA, histoire de valider la mesure, et ressortir un joli PCB qui va bien pour une jolie mise en boîtier. Bref, vous l’aurez compris, une version 3 est sur les rails, mais les modifications seront essentiellement cosmétiques.

Pour finir, une petite vidéo du montage en fonctionnement :

Le code source du programme :  Dosimetre.pde

Et oui, les entrées/sorties, on n’en a jamais assez. En l’occurrence, pour ce projet, j’avais besoin d’avoir une douzaine de capteurs analogiques (des capteurs de force résistifs), et de pouvoir logger les valeurs sur une carte microSD.

Je me suis dit que tant qu’à faire, j’allais essayer de faire ça de manière à être le plus polyvalent possible, histoire que ça puisse servir dans d’autres projets.C’est à partir de ce cahier des charges que je suis parvenu à la réalisation de ce shield, qui offre la possibilité de lire (ou d’écrire) sur 32 entrées analogiques, plus 5 E/S numériques (plus les 4 entrées analogiques encore dispo sur l’arduino)

MultiplexShield, le circuit

Comme vous pouvez le voir sur le circuit ci-dessus, 16 broches (8 sur le premier circuit, 8 sur le second) sont disponibles pour lire des valeurs analogiques à partir de capteurs résistifs (les petites résistances CMS servent à faire un pont diviseur de tension). Les 16 autres broches, permettent de lire/écrire des informations numériques (possible aussi avec les précédentes, sous réserve d’enlever les résistances CMS). L’idée de cet agencement est de n’avoir que les deux fils du capteur à brancher sur la carte.
Concernant les cartes microSD, j’ai préféré maximiser mes chances : j’ai prévu un connecteur pour les adaptateurs type Adafruit (qui embarquent le système de régulation de voltage nécessaire), et pour les BreackOutBoard Sparkfun, qui eux ne comprennent que le slot microSD.

Multiplex Shield le schéma. (cliquez pour agrandir)

L’accès aux cartes microSD se fait en utilisant les fonctions SPI matérielles de l’Arduino, histoire de maximiser les performances.
Comme le montrent les photos, il y a eu quelques ratés au niveau du schéma initial (le schéma publié est corrigé), certaines broches avaient été laissées flottantes (toujours vérifier 2 fois sont schéma avant de faire faire un circuit !). Bon, c’est pas dramatique, quelques bouts de fils et c’est réparé, mais bon, c’est pas super esthétique.

Les raccommodages…

Au niveau de l’utilisation de ce shield, c’est plutôt facile : chaque circuit est rattaché à une broche analogique. Lorsqu’on lit la valeur d’une de ces deux broches, on lit en fait la valeur de l’entrée sélectionnée du multiplexeur. Et comment on sélectionne l’entrée ? Bah tout simplement en envoyant au multiplexeur le code binaire correspondant à la broche. Je m’explique : pour se piloter, le CD4067 utilise 4 broche (10, 11, 14 et 13, pour respectivement A, B, C et D). Vous voulez lire la broche 7 ? Et bien, mettez A à 1, B à 1, C à 1 et D à 0 (0111 en binaire, ce qui nous donne 7), tout simplement.
Difficile de faire plus simple non ?

Un petit exemple de code : Lecture multiplexée, enregistrement sur SD

C’est un projet au long cours que je vous présente ici. Fabien avais besoin d’une petite fraiseuse pour usiner des PCB maison, de mon coté, je me demandais à quel point il était possible de miniaturiser ce type d’outils, et d’en réduire les coûts.
Le declic : Le déclic lui à eu lieu suite à une formation à l’utilisation d’une découpeuse laser. En effet, cette machine permettait d’atteindre une précision remarquable lors de la découpe, ainsi que de faire des angles droits sans les problèmes d’arrondis habituels lors des découpes à la fraiseuse. Là, en voyant ça, ça a fait tilt : c’est comme ça qu’il fallais fabriquer cette fraiseuse ! Pour tout dire, je n’en ai pas dormis de la nuit, commençant déjà à imaginer les plans. D’ailleur, au bout d’un moment, j’ai finit par me relever, histoire d’aller dessiner tout ça et pouvoir enfin me libérer l’esprit (3h du matin quand même ^^)
Le lendemain, je soumet mes plans à Fabien, qui est tout de suite séduit par l’idée :
Construire une micro fraiseuse, entièrement en contreplaqué emboîté, d’une surface inférieure à une feuille A4 de manière à pouvoir tenir facilement sur un bureau, et étant capable d’usiner des circuits au format europe (10x16cm).

Commence alors un gros travail de dessin industriel, à base de logiciel libre (librecad). Le procédé de découpe laser nous autorise à ne dessiner que les découpes, donc simplement en 2d. Après une première version sortie, on se rend rapidement compte que tout ne peut pas être anticipé facilement, et que si l’on continue simplement en 2D, on risque de devoir sortir beaucoup de prototypes avant d’arriver à une version correcte. Nous avons donc utilisé SolidWorks, uniquement pour faire l’assemblage de nos pièces, et ainsi valider les différentes jointures.

L’assemblage virtuel

Le premier prototype sorti nous avais enchanté par la qualité de la découpe : C’était beau, c’était pro ! Malheureusement pour nous, le second résultat était déjà nettement moins réjouissant. En fait, sous la dénomination « contreplaqué » une grosse quantité de variantes, dans les plaquages, les colles, et les remplissages. Et en achetant le meme bois, chez le même fournisseur, nous avons eu la malchance de tomber sur deux séries différentes, avec un rendu complètement différent. Là où la première se découpait bien, avec des bords nets, la secondes brûlait, et nos assemblages se transformaient en petits tas de charbons. A force de recherches, on a fini par comprendre qu’il fallait du contreplaqué « tout okoumé », c’est à dire dont l’âme est également en okoumé, et non pas en peuplier comme c’est souvent le cas.

Le deuxième prototype, on vois les traces de brûlé.

Concernant la partie mécanique, étant donné qu’elle est destinée au fraisage de pcb, peu d’efforts seront nécessaires, inutile donc de partir sur de gros moteurs. Nous avons donc utilisé des moteurs Nema11, qui offrent un couple largement suffisant pour une taille ridicule.

Le moteur nema11

Les guidages linéaires se font via des douilles à bille glissant sur des stubs acier, l’entraînement est lui réalisé via une vis trapézoïdale.

La vis trapézoïdale et son écrou

Maintenant qu’on a les différentes pièces découpées, et qu’on a les différentes parties mécaniques, on peut commencer l’assemblage.

L’axe des X

L’axe des X

Une vue d’ensemble

Reste maintenant à voir ce que ça donne, une fois motorisé.

On remet ça pour l’axe de Y, toujours selon le même procédé, ainsi que l’axe des Z. Comme on est du genre un peu impatient, on a fait un premier essai, avec uniquement l’axe X + Y, et en remplaçant la fraise par un stylo. Autant dire qu’on est plutôt satisfait de ce premier résultat

Premier tracé sans l’axe des Z

Concernant le pilotage de la CNC à proprement parler, on utilise une carte Arduino Uno, sur lequel est installé Grbl (pour l’interprétation du gcode). La partie puissance est confiée à 3 modules pololu A4988, le tout refroidit par un ventilateur de PC (on n’a pas mis de radiateur sur les pololu, et on va en avoir besoin).

La fraiseuse assemblée

Vue d’ensemble avec l’électronique

Le fraisage à proprement parler sera confié à un moteur de mini-perceuse pour lequel je disposais des bons accouplements d’arbre, avec un mandrin de serrage. Malheureusement, il était assez ancien, et on sentait au fur et à mesure de nos tests que la fin approchais. Il a finalement finit par rendre l’âme, et nous avons du trouver une autre solution. Nous l’avons remplacé par un moteur du même type, un peu plus petit, malheureusement l’arbre n’était pas au même diamètre. Heureusement, Fabien a réussi à nous bricoler un couplage à partir du système Dremel.

Premiers essais de fraisage

Malheureusement pour nous, tout n’est pas allé comme sur des roulettes. Premier problème rencontré, l’Arduino se plante en plein milieu d’usinage (cf la photo du dessus). Quelques recherches plus tard, on trouve la cause (et donc la solution), sur certain déplacements (les 3 axes en même temps), notre alim ne suit plus. On met une alim plus puissance, et ça roule
En revanche, un autre problème plus bloquant se profile : les vibrations. En effet, le moteur utilisé n’est pas vraiment prévu pour cet usage, et vibre énormément. Pas sur son support, mais l’axe à l’intérieur de sa cage. Résultat, les premiers traits se passent bien, mais le temps aidant, on se retrouve à usiner un trait de 3mm d’épaisseur avec une fraise de 0.1mm
En revanche la structure en bois nous a convaincu : elle est suffisamment rigide pour que l’usinage se passe bien, et en cas de fausse manip (plantage de fraise à cause d’un mauvais zéro par exemple), l’ensemble plie, mais ne casse pas !

Où en est-on aujourd’hui ?
Le problème des vibrations n’est malheureusement toujours pas résolu. On cherche une solution permettant de coupler un axe moteur qui soit fiable, peu coûteuse, et qui limite au maximum les vibrations. De la meme manière, on recherche un type de moteur (un spindle), dont la taille soit adapté à notre fraiseuse, et surtout à un prix raisonnable. On en a en effet trouvé, mais à 500€, ce qui correspond au prix de la fraiseuse complète. Si des fois vous avez des idées, vous êtes les bienvenus !

Edit : toutes les photos et vidéos du projet sont disponible ici

Et oui, c’est à la mode en ce moment
Rappelez vous, donc, je m’était acheté une petite fraiseuse cnc afin de pouvoir tirer facilement des pcbs, et pouvoir réaliser diverses petites pièces. J’étais un peu sceptique sur la qualité de la chose vu son prix, mais avais été plutôt agréablement surpris… Ce qui ne l’a pas empêchée de tomber en panne au bout de quelques temps ! En cause : le spindle (moteur de broche) qui était un moteur à charbon, et les charbons ont finis par s’user.  Je les ai changés une première fois, mais face à la vitesse d’usure des nouveaux, je me suis dit qu’il allais falloir trouver autre chose !

Le coupable : La broche d'origine

L’idée, vous l’aurez compris, est de passer sur une broche de type brushless. Bien sûr, il est tout à fait possible de trouver dans le commerce des ensembles de spindle brushless tout fait… Mais qui coûtent le prix d’une fraiseuse neuve, voir plus cher !
Compte tenu des matériaux que j’usine, et vu que la puissance du précédent spindle m’était suffisante (300w), je suis partis sur un moteur de puissance équivalente en brushless, chose qu’il est assez facile de trouver dans le modélisme, pour des tarifs très modestes. (On trouve même des moteurs de puissance monstrueuse pour des coûts ridicules). Idéalement, j’aurais même voulu prendre un peu plus gros, mais…. La première grosse difficulté est vite rencontrée : comment alimenter tout ça ?
En effet, les moteurs de modélismes sont prévus pour être alimentés  par des batteries type LiPo largement capables de débiter des dizaines d’ampères, pour une tension d’environ 12v. les moteurs ne sont donc pas vraiment prévus pour fonctionner à des tensions trop importante (souvent 24v, rarement beaucoup plus). Pour une utilisation de longue durée, il faut donc trouver une alimentation capable de fournir la puissance nécessaire pendant toute la durée de fonctionnement. Et là, on se rend compte que ça coûte vite un bras aussi !
En gros, jusqu’à 300w, ça reste raisonnable, mais au delà, aïe aïe aïe…

Alimentation à découpage 300W

Du coups, forcément ça limite le choix des moteurs. Je suis donc resté sur mon idée de départ, à savoir un moteur brushless de 300W 15000trs/min , son controleur qui va bien, et une alimentation à découpage 12v 300W de chez Vellman qui m’aura coûté moins de 50€. Au final, la facture s’elève à moins de 150€, ce qui reste très raisonnable.

Reste ensuite à fixer tout ça sur ma fraiseuse. En effet, sur le spindle d’origine, l’arbre moteur tourne à l’intérieur de la cage, alors que le moteur brushless est lui à cage tournante, la fixation se fait par dessous. Il faut donc construire une nouvelle pièce de support.

La modélisation 3D sous Heekscad

L’idée est de reprendre les trous de fixation d’origine, tout en laissant le moteur à la même hauteur que la broche d’origine. Il faut aussi que la pièce soit assez rigide pour résister aux efforts. J’envisage d’imprimer la pièce en PLA, qui devrait être suffisamment solide pour tenir.

Las, les premiers essais ne sont pas concluants du tout… (mais alors pas du tout du tout !). En fait le plastique est solide, mais pas assez rigide du tout, et l’ensemble entre en vibration dès que je dépasse un certain nombre de tours/minutes. Résultat, ma gravure fait 2mm de large au lieu de 0,1mm !

Il faut donc trouver quelque chose de plus rigide…. Comme j’ai la possibilité d’utiliser une imprimate Z-corp (imprimante 3D à poudre, type plâtre), je fais une tentative avec ce matériaux. Il y a un léger mieux, mais ce n’est toujours pas ça. La solution viendra finalement de faire usiner la pièce en aluminium  (merci à Alain de Ginova)

Heureusement, là, plus de vibrations ! Du coups, je me rend compte que la pièce que j’avais designé à l’origine pour du plastique se révèle être carrément « mastoc », et j’aurais pu très largement réduire certaines épaisseurs.

Concernant le contrôle du moteur brushless, je suis partis sur une solution simple pour le moment : un contrôleur de modélisme, qui se pilote comme un servomoteur, piloté par un arduino. 2 boutons poussoirs permettent d’augmenter ou diminuer la vitesse de rotation.
Un des trucs « marrant » du montage, c’est qu’à l’origine, je partait dans l’idée de faire un module d’alimentation pour l’arduino, avant de me rendre compte que l’arduino était auto-alimenté par les câbles venant du contrôleur. Bref, j’avoue que je suis pas vraiment sûr que ce soit prévu pour, mais comme c’est du temporaire ça ira très bien en attendant une version définitive, vu que ça fonctionne comme ça

Petit ps à l’attention de ceux qui attentaient un pcb, il me reste quelques tests à réaliser, et je vais pouvoir m’y remettre, désolé pour l’attente.

Et beh, s’il y a bien un montage qui m’a fait c…. a mis du temps à être au point, c’est bien celui-là ! Souvenez-vous, la première version date de là : Horloge binaire partie 1

C’est à ce genre d’occasion qu’on se rend compte qu’entre un prototype qui fonctionne, et une version finalisée reprenant les différentes contraintes (espace disponible, coût, concommation, etc…) il y a beaucoup de travail.

L’idée est donc d’avoir un shield arduino permettant de piloter un panneau de LED de manière à afficher l’heure en binaire : La colonne de droite affiche les unités des secondes sur 4 led, la suivante les dizaines sur 3 leds, la suivante les unités des minutes, etc…
Les contraintes techniques étaient « simples » : toute l’électronique doit tenir sur la taille d’un shield pour Arduino Uno, l’affichage étant quand à lui déporté sur un autre circuit. Le montage ne doit pas consommer de manière excessive car il peut être amené à fonctionner sur pile, et l’heure ne doit pas connaitre une trop grande dérive.

Il a finalement fallu que je reparte à zero par rapport à la version précédente, le circuit étant très difficilement routable sur les dimentions d’un shield, et la dérive temps un poil trop importante au final (mais raisonnable tout de même, c’est surtout l’encombrement du circuit qui a joué).

Cliquer pour télécharger le schéma en PDF

La base temps à 1Hz faite par un quartz et un diviseur de fréquence a été remplacé par un MAX1302 de chez maxim, avec son quartz, ce qui fait déjà un sérieux gain de place.
L’affichage des LEDs est géré comme s’il s’agissait d’une matrice de LED, par multiplexage : un 74HC595 envoi les 8bits de chaque ligne (seuls 6 sont utilisés en réalité), le choix des lignes se fait via les 4 transistors. Les valeurs des résistances est de 220 ohms pour chaque.
Les transistors et le HC595 arrivent sur des barrettes sécables, permettant de relier le shield au panneau de LED via un cable souple de 10 fils  (14 si vous déportez les boutons de réglage en façade)

Cliquer pour télécharger le typon en PDF

Placement des composants horloge binaire

Pour la façade, comme je l’ai dit, les LEDs seront en matrice, le schéma n’est donc pas très compliqué, et le typon non plus :

schema façade horloge binaire RTC

Cliquer pour télécharger le typon en PDF

Pour la réalisation de la façade, seules les cathodes sont soudés au circuit, les anodes sont pliées en surface et reliées entre elles (les pistes rouges sur l’image ci-dessus)

La gestion de l’horloge et de l’affichage se fait ensuite par un petit programme arduino. Si vous regardez le code de près, vous constaterez quelques « bidouilles » logicielles pour remédier aux contraintes techniques : les colonnes ne sont pas dans l’ordre logique du 74HC595, mais inversées 2 par 2, pour des facilités de routage.

Horloge_binaire_code_source

Et voilà le résultat :

Horloge binaire : le résultat

(La feuille est là simplement pour pouvoir prendre les LEDs en photo sans effets de halo dans l’objectif…)
Et pour ceux qui veulent un petit apperçu du fonctionnement, voici la vidéo !

Vidéo Horloge binaire

Et oui, ça fait partis des nouveautés : j’ai démarré une activité de fabrication de circuit imprimé !
Bon, c’est pas tout a fait une vraie activité dans le sens où elle est loin de m’occuper à temps plein aujourd’hui, mais voilà, disons qu’il faut bien débuter… d’autant que d’autres surprises viendront….

Pour faire simple, si vous cherchez quelqu’un pour vous sortir quelques prototypes de PCB, je vous ai réalisé une page vous permettant de calculer les coûts et de passer commande. Il n’y a pas de minimum de commande, (ni de maximum, mais bon, pour de grosses séries, autant le dire tout de suite, ça sera moins cher en chine (mais je serais plus réactif pour les délais serrés))

En espérant que ça vous plaira : Fabrication PCB

Hier j’ai reçu un petit shield LCD couleur pour mon Arduino que j’avais commandé. Il s’agit d’un modèle avec un écran nokia de 128x128pixels, et 3 boutons en façade.

Shield LCD pour Arduino

Comme je suis quelqu’un d’assez impatient, j’ai voulu tester au plus vite ce petit joujou . Déjà, point assez agréable, quelqu’un a déjà fourni un travail remarquable et une librairie toute prête permet d’effectuer les affichages de base (pixel, ligne, rectangle, texte, etc…). Vous pourrez la trouver ici.

Mes premières impressions tout d’abord : bah ça reste un écran d’ancienne génération de téléphone portable, avec les défauts qui vont avec : très mauvais rendu des couleurs, angle de vision particulièrement limité, et vitesse…. euhhhh…. lente
Mais bon, pour le prix, ça reste un petit affichage tout à fait correct, et on arrive a faire des petites choses marrantes avec.
Le positionnement des boutons m’as fait penser à une manette de jeux, avec gauche/droite et tir…. ce qui m’a donné envie d’essayer de faire un petit space invader, histoire de voire quelles performances je pouvais tirer d’un arduino pour ce type d’applications.
Au passage, un grand merci à Julien qui m’a permis d’améliorer ma compréhension de la programmation objet, et grâce à qui le code fourni est un peu plus propre (J’ai pas encore tout nettoyé, mais promis la v2 sera plus propre )

Space invader sur arduino

Le jeu est jouable, aves les ennemis qui bougent et la détection des collisions qui est fonctionnelle. Par contre il manque l’affichage des scores et quelques détails….
A priori, l’arduino arrive à gérér ça sans trop ramer, ce qui permet d’envisager quelques petites améliorations.

Le code source du projet

Ps : le code source est libre (domaine public)

Oui, je sais, ça faisait longtemps que je n’avais pas présenté de schéma. Et pour cause : je me bat avec celui-ci depuis presque 1 mois ! Au point que j’ai décidé de vous le publier en 2 parties
Rassurez vous, la partie que je vais vous présenter est tout à fait fonctionnelle, mais je voulais vous présenter un joli projet fini, sous la forme d’un shield Arduino, (et éventuellement vous proposer un kit), mais je galère pas mal avec les prototypes…. (encore une fois, je me rend compte qu’il ne faut pas négliger les caractéristiques physiques des composants )

Bref, voici donc une horloge à LED binaire fonctionnant avec un arduino

Horloge binaire - prototype

Pour ceux qui ne connaissent pas les horloges binaires, il s’agit de représenter les heures – minutes – secondes sous leurs équivalents en binaire, ce qui permet d’afficher l’heure grace à une rangée de LED.  Concernant l’affichage, il y a deux écoles : soit on affiche directement la conversion binaire pour chaque membre de l’heure, par exemple pour 10:00:45, on afficherais 101101 (soit 45 en binaire) pour les secondes, soit on décompose pour chaque membre les dizaines des unités, ce qui donnerais pour l’exemple précédent 100 et 101 (soit respectivement 4 et 5). C’est cette dernière méthode que j’ai choisi car elle permet de lire l’heure un peu plus simplement.

Je voulais une horloge relativement fiable, je ne me suis donc pas basé sur l’horloge interne de l’arduino, mais plutôt sur une base de temps externe à 1Hz, à base de quartz d’horlogerie.

Schéma horloge binaire

R1 = 1Mo
R2 = 220Ko
C1 et c2 = 39pf
C3 = 100pf
Q1 = 32,768 KHz

Voici pour la partie matérielle, je vous met également les sources de mon code Arduino :

Code source horloge binaire

Alors voilà, j’avoue, j’ai craqué…
Après de long moments d’hésitations, je me suis acheté un kit Arduino, celui de chez Makersched. Ben finalement, mon seul regret est de ne pas avoir craqué plus tôt

En effet, l’Arduino est un petit bijou, et avec mes pauvres connaissances en électronique, j’ai réussi en quelques minutes à faire tout un tas de petits montages qui restaient jusque là hors de ma portée.
Du coups, toute une liste de projets s’ouvrent à moi, le plus dur va être de choisir par lequel commencer et ne pas m’éparpiller
- Voiture RC autonome
- Drone hélicopter quadrirotor
- Drone Planeur
- Robot bipède
- CNC 2d, découpe laser
- CNC 3d, fraiseuse
- Ecosphère marine et terrestre autosurveillée et autogérée
- Télécomande RC

Bien évidement, les projets seront décris ici au fur et à mesure de leur avancement !