Lundi, août 15 2011

Une Borne d'Arcade maison -3-

Suite de l'étude précédente :
>>Sommaire ici !<<

Méthode N°1

[validée sur Ubuntu 10.04LTS]

Introduction :

On va s'intéresser brièvement aux différences entre Téléviseur et Moniteur informatique cathodique.

  • Un téléviseur PAL affiche 25 images par secondes en 625 lignes horizontales, balayées à 15,625kHz par un point lumineux en deux temps : les lignes impaires puis les lignes paires, donc 50 demi-images qu'on dit entrelacées à 50Hz.

La résolution réelle maximale de l'image atteint 720 points de large × 576 lignes de haut. (noté 576i)

  • L'écran informatique affiche des images progressives (images complètes, pas d'entrelacement), fabriquées par une synchro verticale + une horizontale à des résolutions et des fréquences très élevées, permettant de travailler agréablement à faible distance de l'écran.

Par exemple mon tube 17 pouces IIyama A705MT indique comme caractéristiques une plage de Synchro Horizontale de 30 à 86kHz et Verticale de 50 à 180Hz permettant d'afficher par exemple 1024 points x 768 points @85Hz.
L'écran informatique est donc désigné 30kHz.

Ce qu'il fallait démontrer, c'est que la carte graphique de l'ordinateur est conçue pour sortir ces 30kHz, ce qui la rend en l'état, incompatible avec les téléviseurs 15kHz.
Battu ? On abandonne ?
Meuhh non, Xorg est là, paramétrable à souhait !

1 - L'adaptateur Péritel/VGA :

Moyennant une adaptation, on va exploiter les signaux Rouge, Vert, Bleu et les Synchro sortants de la prise VGA de la carte vidéo à destination de l'entrée péritel du TV, Xorg s'occupant de balancer cela en 15kHz.
L'adaptateur doit faire correspondre ces N° de pattes :

      Prise VGA                —        Prise Péritel

Pin N°1: Vidéo Rouge           —     Pin N°15: Rouge
Pin N°2: Vidéo Vert            —     Pin N°11: Vert
Pin N°3: Vidéo Bleu            —     Pin N°7:  Bleu
Pin N°6: Retour rouge          —     Pin N°13: Masse Rouge
Pin N°7: Retour vert           —     Pin N°9:  Masse Verte
Pin N°8: Retour bleu           —     Pin N°5:  Masse Bleue
Pin N°9: +5 V                  —     Pin N°8:  SWITCH
Pin N°10: Masse                —     Pin N°17: Masse Synchro
Pin N°13: HSync et N°14: VSync —     Pin N°20: Synchro.

Ajouter une résistance de 75 Ohms entre la Pin 8 et 16 de la prise péritel, permet, grâce au 5V en provenance de la carte vidéo, de basculer le TV en RVB sur l'entrée AV.

dsc07537.jpg

dsc07536.jpg dsc07535.jpg

Plus d'informations sur la page AdvanceMAME




2 - Paramétrage d'Xorg pour le TV :

  • Sur Ubuntu 10.04LTS, la carte vidéo ATI Radeon 9200 est automatiquement exploitée par un pilote libre, donc rien à installer.

Cela fait aussi quelques temps que le fichier de configuration /etc/X11/xorg.conf n'est plus utilisé pour la configuration du pilote par le système, mais il peut toujours être utilisé par nous autres humains, pour amender la configuration par défaut et ainsi adapter l'affichage à nos besoins.

Ainsi on va devoir y spécifier les sections élémentaires que sont Section "Device", Section "Monitor", et Section "Screen", avec des modificateurs pour l'utilisation du Téléviseur :

### spécifie un nom de carte vidéo (à définir) et le nom du pilote.
Section "Device"
    Identifier  "ATI"
    Driver      "radeon"
EndSection

### spécifie le nom de l'appareil (à définir), les fréquences de balayage et de synchro du TV, ainsi que le modeline 15kHz.
Section "Monitor"
        Identifier   "TV"
## Idéalement ces valeurs  :
#    HorizSync    15.625
#    VertRefresh  50.0
## mais on peut mettre une plage plus souple pour s'adapter au modèle de TV dont on dispose :
        HorizSync    15.0 - 20.0
        VertRefresh  50.0 - 60.0
## le modeline TV @15kHz
    # 720x576x50.00 @ 15.625kHz
    Modeline "720x288x50.08"  13.875000  720 744 808 888  288 293 296 312  -HSync -VSync
EndSection

### Rappel des noms précédents et du mode dans lequel on veut fonctionner.
Section "Screen"
    Identifier "Default Screen"
    Device     "ATI"
    Monitor    "TV"
    DefaultDepth     24
    SubSection "Display"
    Depth     24
    Modes    "720x288x50.08"
    EndSubSection
EndSection


  • Pour calculer le modeline, j'ai utilisé lrmc, un petit soft réservé à cet usage !

- Télécharger et extraire les sources de lrmc, puis se rendre à l'emplacement des sources :

cd /home/makoto/Download/lrmc-0.9.2

- Configurer les sources :

./configure

- Fabriquer le binaire :

make

- Installer le binaire :

sudo make install

- Générer un packet .deb d'installation (optionnel, je l'ai fait pour le mettre à disposition en annexes[1])

sudo checkinstall


Ainsi, La commande suivante va générer le modeline pour une image 720x576@50Hz PAL :

lrmc 720 576 50 -pal

Il suffit alors de copier le résultat dans xorg.conf, comme on viens de le voir.

  • Cependant, la résolution que donne ce modeline n'est pas entrelacée mais progressive.

En effet, j'aurais dû utiliser cette commande :

lrmc 720 576 60 -pal -i

Qui donne :

# 720x576x60.00 @ 15.625kHz
Modeline "720x576x25.00" 13.875000 720 744 808 888 576 586 592 625 -HSync -VSync interlace

Mais elle ne fonctionne pas.
La différence essentielle, c'est qu'en entrelacé j'aurais dû avoir réellement 720x576, alors que je me retrouve avec 720x288 en progressif.
Après quelques recherches, il s'avère simplement que le pilote libre radeon n'est pas capable de générer un signal entrelacé à la sortie de la carte vidéo…
À défaut de tester avec le pilote propriétaire, je verrais ce qu'il en est pour les cartes nVidia.

Vous l'aurez compris, il y a pas mal d'essais à faire avant de trouver le modeline qui fonctionnera le mieux avec le couple téléviseur et carte graphique en cause.
Mais attention, DANGER !!

  • Chaque essais infructueux est un risque d'endommager le téléviseur qui n'est pas prévu pour supporter des fréquences hors normes, il faut donc être très bref lors des tests, si aucune image ne s'affiche.
  • Chose importante également, une fois ce fichier xorg.conf mis en place IL NE FAUT PAS allumer le TV durant le démarrage de l'ordinateur, ni tenter de passer en console tty.

Et oui, la carte vidéo continue d'envoyer du 30kHz en permanence, et donc durant le boot de l'ordi ou en tty… Ce n'est qu'une fois qu'X est lancé que du 15kHz est envoyé.

  • Et vice-versa, quand X est lancé, il ne faut pas brancher de moniteur informatique.

Vu comme ça, ça complique un peu les tests, mais Ubuntu est une chose bien faite et on va pouvoir modifier la configuration d'xorg grâce à un second ordinateur via ssh ou en partage de bureau à distance.

3 - Installation d'AdvanceMAME :

Sur la page de téléchargement, prendre la dernière version des sources d'AdvanceMAME en date (11/01/2009)
- Extraire les sources et se rendre à leurs emplacements :

cd /home/makoto/Download/AdvanceMame/advancemame-0.106.1

Le fichier BUILD nous indique de quoi on aura besoin, à savoir les compilateur suivants :

- GNU gcc C/C++ 3.2.3 or 3.3.4 (or newer)
- GNU make 3.79.1 (or newer)

Et les sources des logiciels suivant :

- NASM 0.98.33 (or newer) [edit : suite à des pb de son et d'affichage, ne pas mettre ce composant]
- SVGALIB 1.9.14 (or newer)
- SDL 1.2.4 (or newer)
- S-Lang 1.4.3 (or newer)
- ncurses 5.4 (or newer)
- FreeType 2.1.7 (or newer)
- zlib 1.1.4 (or newer)
- expat 1.95.6 (or newer)

J'ai donc ajouté libsdl1.2-dev, libslang2-dev, libncurses5-dev, libfreetype6-dev, zlib1g-dev et libexpat1-dev.

sudo apt-get install libsdl1.2-dev libslang2-dev libncurses5-dev libfreetype6-dev zlib1g-dev libexpat1-dev

À noter que la version de libsvga1-dev, est incompatible avec AdvanceMAME, mais on s'en passera.
S'il manque certains éléments, des fonctionnalités d'AdvanceMAME ne fonctionneront pas; ici, l'affichage des jeux par le driver SVGA ne fonctionnera pas, mais heureusement SDL prendra la relève.

Quand tout est prêt on peut lancer :

./configure

À la fin, un résumé des opérations est affiché, indiquant si toutes les dépendances indiquées par BUILD sont satisfaites. Si tel n'est pas le cas, il est temps d'y remédier en cherchant et ajoutant via synaptic, les versions DEV, par exemple libsdl1.2-dev si sdl n'est pas indiqué en face de Video, Sound, Keyboard, Joystick et Mouse.
puis relancer ./configure jusqu'à obtenir quelque chose de quasi parfait, comme ça :

== Host ==
Environment : i686-pc-linux-gnu
Endianess : little
Bits : 32
Assembler for Pentium : no
Assembler MIPS3 emulator for Pentium : no

== Drivers/Libraries ==
Video : fb slang ncurses sdl
Sound : alsa oss sdl
Keyboard : sdl raw event
Joystick : sdl raw event
Mouse : sdl raw event
Misc : zlib expat pthread freetype2

== Compiler ==
CC : gcc
CXX : g++
CFLAGS : -march=native -O2 -fomit-frame-pointer -fno-merge-constants -Wall -Wno-sign-compare -Wno-unused
LDFLAGS : -s

== Configuration ==
Emulator : mame
Debugger : no

Bien, il ne devrait plus y avoir d'obstacle au bon déroulement des prochaines opérations, on peut donc fabriquer le binaire :

make

Puis l'installer :

sudo make install



4 - Installation d'AdvanceMENU :


Une fois les deux logiciels installés, on retrouve les binaires dans /usr/local/bin :

advmame - The AdvanceMAME emulator.
advmenu
advcfg - The automatic video configurator.
advv - The manual video configurator and tester.
advm - The mouse tester.
advk - The keyboard tester.
advs - The sound tester.
advj - The joystick tester.


Il est temps de jouer : !!


Au premier lancement de l'émulateur,

advmame

Le fichier de configuration est crée

Creating a standard configuration file...
Configuration file `/home/makoto/.advance/advmame.rc' created with all the default options.

The default rom search path is `/home/makoto/.advance/rom:/usr/local/share/advance/rom'.
You can change it using the `dir_rom' option in the configuration file.

Idem, au premier lancement du menu,

advmenu

Le fichier de configuration est crée

Creating a standard configuration file...
Adding emulator `advmame'...
Configuration file `/home/makoto/.advance/advmenu.rc' created with all the default options.

Ce sont ces fichiers advmame.rc et advmenu.rc qui vont être édités manuellement pour peaufiner les réglages.
Tout est documenté dans de dossier /usr/local/share/doc/advance ou depuis les sources /home/makoto/Download/AdvanceMame/advancemame-0.106.1/doc ou encore, sur le site du projet AdvanceMAME.

  • advmame.rc

device_sound sdl [car je n'avais pas de son dans les jeux]
device_video auto [en fait c'est sdl qui est utilisé, donc on pourrait le forcer]
display_resize no [pas besoin d'étirer l'image, puisqu'ils sont lancés dans leurs résolutions natives]
display_resizeeffect no [idem]
display_rgbeffect none [on veut se rapprocher du rendu Arcade, donc besoin de rien]

  • advmenu.rc

device_sound sdl [car advmenu freezait sans raison]
sound_backgroud_loop none [pour virer le mp3 de feu qui crépite tiré de DukeNukem3D]
device_joystick auto [pour se passer du clavier lors de la sélection et lancement des jeux]
device_video_output fullscreen [pour lancer advmenu en plein écran]

Bref, pour jouer il suffit de copier des jeux dans le dossier /home/makoto/.advance/rom, puis de taper :

advmame NomDuJeux

Ou alors, pour accéder au menu graphique, suffit de lancer la commande :

advmenu

Ou de créer un lanceur sur le bureau.

Conclusions : !!

  • Cette solution est simple et rapide à mettre en place.
  • On peut tout à fait jouer sur son écran l'ordi en sautant l'étape de modif d'Xorg.
  • N'importe quelle manette USB fait l'affaire, pas testé de manette sur le port Midi.
  • À savoir ! Le pilote libre ATI ne gère pas l'entrelacé, donc aucun modelines entrelacés ne sera reconnu par X. Le pilote propriétaire ATI Catalyst ne supporte plus les cartes radeon 9200, rien ne sert de s'escrimer à l'installer, ça ne fonctionnera pas !
  • Lors de la mise en place dans une borne, il faudra ajouter un circuit électronique pour protéger l'écran TV du 30kHz envoyé par la carte vidéo lors des phases de démarrage et d'arrêt de la borne.
  • À savoir qu'une solution similaire existe sous Windows® avec soft15kHz.


À suivre…

Note

[1] voir ci-dessous

Mercredi, août 10 2011

Une Borne d'Arcade maison -2-

Suite de l'épisode précédent :
J'ai commencé par rassembler le matériel dont je dispose pour faire un banc test et lancer des expérimentations.
Mais je ne vais pas les détailler ici, histoire d'éviter d'embrouiller les esprits.
C'est dommage, car c'est dans ces moments là qu'on apprend le plus… Je vais donc m'efforcer de faire ressortir les éléments importants.

Pour la durée des tests, la carte mère est simplement posée sur la table avec un disque dur, un lecteur CD-Rom, un écran VGA et un écran Télé, le tout à évaluer avec 3 cartes vidéos.

  • Carte mère : ABIT-IT7
  • Processeur : Pentium4 @2.4GHz
  • Mémoire : 1Gio de ram pour la durée de la mise au point, une quantité finale à déterminer.
  • Cartes vidéos:

- Nvidia GeForce 6200
- Nvidia GeForce 2 MX400
- ATI Radeon 9200 Pro (RV 280)
- Matrox G450
Un câble VGA muni d'un adaptateur bidouillé permet de relier la carte vidéo au télé.
dsc07527.jpg
Grâce au wiki très bien fait traitant des Front-Ends MAME (couche logicielle pour accroitre les capacités techniques de MAME) le choix de l'émulateur s'est rapidement précisé pour AdvanceMAME !

En effet, c'est le seul qui soit capable de gérer et basculer automatiquement l'affichage des jeux dans leurs résolutions natives sur un écran TV, via la sortie VGA d'une carte Vidéo standard et d'être utilisé sans clavier ni souris.

(À savoir qu'il existe une carte ArcadeVGA au bios bidouillé pour fonctionner directement sur un Moniteur Arcade)

De mes expérimentations, 4 méthodes intéressantes suivant le niveau de maitrise qu'on désire, ressortent du lot :

  1. Installer un GNU/Linux standard (avec interface graphique X), modifier Xorg dans une résolution acceptée par le TV, compiler, installer et lancer AdvanceMAME, jouer.
  2. Installer un GNU/Linux minimal (sans interface graphique X), compiler, configurer et lancer AdvanceMAME, jouer.
  3. Modifier et installer AdvanceCD, jouer.
  4. Modifier et installer AdvanceCD au niveau des sources pour mise à jour d'advmame 0.92.1>>0.106.1, advmenu-2.4.6>>2.5.0… voire du kernel et des driver fb… grosses modifs en profondeur.


État des tests réalisés avec la carte ATI 9200 :

- La méthode N°1, fonctionne sur une Ubuntu 10.04LTS, détails et tuto dans le prochain billet.

- La méthode N°2, fonctionne dans certaines conditions, grosse déception par rapport à l'utilisation d'un écran TV, détails et tuto dans le prochain billet.

- Surprise ! Méthode N°1+2, découvert cette solution hybride en cours de route… détails et tuto dans ce billet.

- La méthode N°3, fonctionne pour peu qu'on adapte la config du CD bootable au niveau de la résolution d'écran… Prévu pour un écran d'Arcade CGA, on pourra le configurer pour un écran d'ordinateur CRT. C'est bien documenté par l'auteur, un fichier texte à éditer. En fait l'AdvanceCD fonctionne avec le driver Frame Buffer, se référer à la méthode N°2 pour plus de détails.

- La méthode N°4, s'adresse à celui qui voudra bénéficier de la dernière version d'AdvanceMAME sur l'AdvanceCD voire du dernier MAME.
En effet, La version d'AdvanceMAME (0.92.1) compilée dans l'AdvanceCD n'est pas la plus récente (0.106.1) (ce qui influe sur le nombre de jeux supportés)… d'autant plus que le projet AdvanceMAME semble arrêté, ce qui de toute manière fait d'AdvanceMAME un soft très ancien par rapport au MAME original.
Je ne voudrais pas m'avancer dans les bêtises, mais peut-être est t-il possible, via les sources, de mettre à jour MAME dans AdvanceMAME (probable et complexe), et également les drivers vidéo et le noyaux Linux (possible et complexe).

Bref à force de fouiller, les découvertes laissent entrevoir des trucs intéressants, mais il faut vraiment que je me fixe des limites car je suis un peu parti dans tous les sens et le simple fait d'écrire ces conclusions me recadre assez pour structurer ma démarche et avancer vers quelque chose qui fonctionne.

À suivre…

Dimanche, août 7 2011

Une Borne d'Arcade maison -1-

Après le stick d'arcade, et puis les émissions GameCenter aidant, des idées, des envies germent petit à petit, et on regarde alors différemment le vieux Téléviseur cathodique et l'ancienne carte mère de PC qui trainent…
Et on se dit… et si… je me lançais dans la fabrication de ce genre l'engin ?
Les mauvaises langues diront « pourquoi tu te fait chier ? t'as qu'a en acheter une…»
Oui mais ou serait le fun dans ce cas ? La satisfaction de l'achat ne durant qu'un instant, comme un mirage pour l'accomplissement de soi.
Alors que rêver, imaginer, s'informer, trouver des solutions pour concevoir tout depuis presque rien est si gratifiant et restera gravé dans la mémoire comme une expérience enrichissante, tout ça…
Et puis je m'amuserais autant à bidouiller une borne maison qu'à jouer des jeux dessus.

« Alors quoi que c'est que la MAME Cabinet », comme disent les Anglo-Saxons ?
On connait déjà le principe de l'émulateur de jeux vidéo, un logiciel capable de simuler le fonctionnement d'une machine, afin de faire tourner des copies de jeux.
Et bien MAME, pour « Multiple Arcade Machine Emulator » est un émulateur qui à la particularité, d'émuler plusieurs types de machines d'arcade, simplifiant alors grandement les choses…

Liste des composants envisagés pour l'élaboration de la borne :

bornemame.png La partie informatique :

  • 1 carte Mère,
  • 1 Processeur,
  • 1 peu de mémoire RAM,
  • 1 carte Graphique,
  • 1 carte Son,
  • 1 Disque Dur,
  • 1 Alimentation,
  • 1 Système d'exploitation configuré pour fonctionner sur un Télé,
  • 1 Émulateur.

La partie Mécanique :

  • 1 Borne, à fabriquer en bois.
  • 1 Téléviseur cathodique assez gros.
  • 2 Joystick USB.

À partir de là, une recherche en amenant une autre, une solution débloquant le point suivant, on va pouvoir étudier le détail de la conception.

Mais ça c'est une affaire à suivre !

Jeudi, juillet 14 2011

DIY – Faire son panneau solaire maison

Après vous avoir présenté il y a quelques temps déjà mes premiers pas avec des cellules solaires photovoltaiques, il était grand temps de passer aux choses sérieuses !Aujourd’hui, je vous présente la réalisation de mon panneau solaire 36 cellules, soit environ 60W.

Panneau photovoltaique maison

Panneau photovoltaique maison

La première étape consiste à construire la structure du panneau. Mon objectif étant de réaliser un panneau « low-cost », la structure sera entièrement réalisée en bois, pas d’aluminium contrairement aux réalisations professionnelles. Je vais donc construire un cadre en contreplaqué, dans lequel viendront s’encastrer 2 planches de medium 5mm sur lesquelles seront collées les cellules. L’avantage de cette construction est de limiter les déformations liées aux changements de température et d’humidité.

Plan de construction du panneau

Plan de construction du panneau

Les rebords sont réalisés à l’aide de tasseaux de pin de 10mm, vissés sur la planche principale. Une fois la construction achevée, j’ai passé 2 couches de peinture blanche, et 2 couches de vernis marin sur l’ensemble de la structure ainsi que sur les 2 panneaux de médium.

La structure du panneau solaire avant peinture

La structure du panneau solaire avant peinture

La structure sera recouverte à la fin par un panneau de plexyglass de 2mm, afin de protéger les cellules des intempéries. L’épaisseur n’a pas d’importance ici car la structure apporte la rigidité nécéssaire, et le 2mm reviens nettement moins cher ;)

Vient ensuite la partie un poil plus « pénible » : la soudure de 2 fils d’alu (plat de 2mm) sur la face avant de chacune des 36 cellules…. Si vous avez lu mes précédentes péripéties, vous vous souviendrez que ce n’est pas une vraie partie de plaisir, mais avec un peu d’habitude, ça finit par aller assez bien. L’astuce qui change tout : mettre un peu de soudure sur la zone blanche du panneau (argent) : ça adhère bien à cet endrois, et du coups vos soudures tiendront à coups sûr.

On met de la soudure sur le "fil" blanc

On met de la soudure sur le "fil" blanc

On soude le plat d'aluminium

On soude le plat d'aluminium

 

 

 

 

 

 

 

 

 

 

Concernant la longueur des plats d’alu : pour être tranquille, vous devez souder au moins 3cm sur la surface de la cellule, et ils doivent dépasser d’au moins la largeur d’une autre cellule, ce qui nous fait environ 10cm en tout.

Une fois toutes les cellules soudées, il va falloir les relier entre elles, avec un espacement assez cohérent si on veux garder un aspect assez esthétique. Si vous avez des croix de carreleur, vous pouvez les utiliser, mais dans mon cas, comme je n’en avais pas, j’ai tracé mes emplacements au crayon sur les plaques de médium, ce qui permet de bien visualiser l’emplacement des cellules.

Le tracé de l'emplacement des cellules

Le tracé de l'emplacement des cellules

Vient ensuite le moment de relier ensemble toutes les cellules. L’objectif ici est d’obtenir une tension utilisable pour charger une batterie. Chaque cellule produit 0.5v, en relient les 36 cellules en série, j’obtiens donc une tension de 18v, ce qui correspond à ce dont j’ai besoin pour charger ma batterie, magique non ? :)

Relier les cellules en série revient donc à souder les fils d’alus qui viennent du dessus d’une cellule sous une aute cellule.

Connection des cellules en série

Connection des cellules en série

 

Cellules photovoltaiques en série

Cellules photovoltaiques en série

Une rangée de cellules en cours de connection

Une rangée de cellules en cours de connection

 

 

 

 

 

 

 

 

 

 

 

Les fils d’alu seront soudés sur les petits carrés d’argent (les carrés blanc au dos des cellules). Une fois une rangée complété, il faut coller les cellules au panneau de medium. Pour ce faire, j’utilise de la colle néoprène (qui reste souple même après séchage), et je les colles par un point central. Attention, il est important de ne faire qu’un point central, et de ne pas encoller plusieurs endroit de la cellule. Avec la dilatation dûe à l’augmentation de la chaleur, la cellule casserais immanquablement  !

On colle les cellules par un point central

On colle les cellules par un point central

Un premier demi-panneau de terminé

Un premier demi-panneau de terminé

Les rangées de cellules seront reliées entre elles grâce à un plat d’alu de 5mm.

Le plat d'aluminium pour relier deux rangées

Le plat d'aluminium pour relier deux rangées

Une fois toutes les rangées reliées entre elles, il ne reste plus qu’à passer à l’assemblage final :)

Le panneau en phase final d'assemblage

Le panneau en phase final d'assemblage

2 – 3 petites choses à faire encore, et il sera entièrement terminé ! Premièrement, ajouter une diode. On pourrais l’ajouter à l’extérieur du panneau, mais j’avais de la place à l’intérieur, et les diodes sont plus performantes quand la température augmente, donc l’intérieur du panneau semble tout indiqué… Il faut ensuite percer le fond du panneau, de manière à faire sortir les cables de racordement (faire un noeud juste avant  le trou, pour éviter l’arrachement accidentel)

La diode (sous le scotch) et la sortie du cable de raccordement

La diode (sous le scotch) et la sortie du cable de raccordement

Et voilà, un beau panneau fait maison terminé :) il ne reste plus qu’à attendre un beau soleil pour tester sa puissance ! (mais j’ai déjà mes 18v aux bornes…. et même un peu plus ;) )

Panneau photovoltaique maison

Et voilà le résultat :)

Dimanche, juin 26 2011

DIY – Micro insoleuse boite de cigare

Bon, vous allez me dire, pour quoi faire une nouvelle insoleuse, alors que j’en ai déjà une… (d’abord, j’en ai déjà 2 ;) )
Et bien tout simplement que j’ai essayé d’en faire une qui tenais le minimum de place possible. Comme j’utilise essentiellement Eagle en version gratuite pour faire mes circuits, je suis limité à 8x10cm, donc une insoleuse A4 est surdimentionnée.
J’avais justement dans mes tiroirs une boite à cigare, dont les dimentions internent étaient justement de 8×9,5cm, ce qui correspond très bien à mon besoin.
Et comme je vais bientôt vous proposer un service de réalisation de circuits (PCB), une insoleuse de plus ne fera pas de mal ;)

La boite à cigare

La boite à cigare

Vous l’aurez compris, à ces dimentions là, impossible de mettre un néon, je vais utiliser des leds. J’ai donc commandé un lot de 100 leds, directement de Honk-Kong à un prix imbattable, et j’ai soudé ça sur une plaque d’essai. Le 38 Leds sont en parallèle, alimentées par un 7805 (j’avais un peu peur qu’il chaufe trop, mais finalement, les leds ne consomment pas tant que ça ;) )

La micro insoleuse ouverte

La micro insoleuse ouverte

Pour que la lumière soit bien homogène, j’ai récupéré les différents films situés dans un vieil écran plat qui ne fonctionnais plus. J’ai utilisé un premier fil semblable à une lentille de fresnel polarisé, et un second film translucide. Je les ai posé directement sur les leds.
Ensuite, J’ai collé 2 petites baguettes à 1,5cm du fond de la boite (elle fait 1,7cm de profondeur), ce qui permet de maintenir une petite vitre de 2mm d’épaisseur et de pouvoir fermer le couvercle. Comme le couvercle est légèrement souple, celà permet de plaquer la plaque présensibilisée sur le transparent.

Prêt à insoler

Prêt à insoler

Et voilà ! Ah si, l’alimentation se fait avec une pile 9v connectée à l’extérieur. J’ai prévu d’y ajouter une petite minuterie, mais je dois d’abord faire les calages, histoire de connaitre les temps d’insolation !

L'insoleuse en fonctionnement

L'insoleuse en fonctionnement

Mercredi, juin 15 2011

Joystick Super Nintendo -1-

dsc07495.jpg Un joystick d'arcade USB c'est bien, mais pour jouer sur d'autres consoles, comment faire ?

Suite à ma première expérience concluante de conception sur microcontrôleur (µC), je pense que je peux me lancer et tenter de réaliser un « joystick Super Nintendo » à base de µC ATmega.

Étant donné qu'ils est simple, pourquoi s'embêter à pondre un programme alors qu'il suffirait de copier le circuit électronique à base de CD4021 contenu dans la manette Super Nintendo ??
dsc07497.jpg
Voire même de faire le barbare comme certains font, en sacrifiant une manette pour y souder des fils et la raccorder directement aux joystick…

Et bien car je prévois de fusionner ce nouveau programme avec celui du joystick USB.
Et même avec de futurs programmes, rendant ainsi le joystick compatible : PC, Super Nintendo, PC Engine, Playstation 1,2 et 3.

Mais voyons déjà l'étude du

Protocole de communication de la manette Super Nintendo :

dsc06197.jpg dsc06191.jpg Une fois la manette démontée, on va regarder à l'oscilloscope les signaux qui transitent dans les fils de la manette, donc en se branchant sur le connecteur CN1.

connecteur.png dsc07486.jpg

Côté connectique avec la console, ces 5 fils se répartissent ainsi :

- L'alimentation 5 Volt,
- et la masse.

- Les signaux Clock,
- Latch,
- et Serial Data.






Pour l'occasion j'ai donc ressorti l'oscilloscope poussiéreux de son étagère… mais vu comme ça, c'est pas très parlant…




J'ai donc pris le temps de relever les chronogrammes, en respectant le code couleur :

snes-oscillo-latch.png snes-oscillo-clock.png snes-oscillo-data02.png

Interprétation :

Chaque fois que le signal Lacth émis par la console est activé, l'état des boutons de la manette est chargé en mémoire pour être ensuite transmis en sortie sur le signal Serial Data, c'est à dire que l'état de chaque bouton est sérialisé sur cette sortie en suivant les impulsions l'horloge Clock.

Ceci se répète toutes les 16,8 ms, soit presque 60Hz… Compte tenu du fait que ma console fonctionne en 60Hz , sinon j'imagine que cela ce passerait en 50Hz.

La courbe SERIAL DATA représente ce qu'il se passe lorsque le bouton R est enfoncé, un état bas qui dure 12µs, situé à la 12ième impulsion d'horloge.
Les pointillés récapitulent l'emplacement sur la courbe de tous les autres boutons.

«yapluka»… établir un schéma de câblage et écrire un programme qui réalise le signal SERIAL DATA en fonction des signaux CLOCK et LATCH.

À suivre…

Mardi, juin 7 2011

AVR Stargate Atlantis

Il y a 3 ans (déjà!) je réalisais la maquette de la porte des étoiles d'Atlantis, intégrant des leds bleues pilotées par un circuit électronique de ma conception

Vous pouvez voir le résultat dans la galerie qui lui est réservée.

Le circuit électronique, aussi simple soit-il a été conçu avec les méthodes «old school» que je connaissais, qui paraitront peut-être déjà archaïques aux élèves électroniciens du moment, qui étudient ce genre de truc pour la forme, mais se concentrent désormais sur l'étude et la programmation des microcontrôleurs (µC).
Et comme j'en causais lors de la réalisation du Joystick USB, il serait temps que je tâte un peu du µC… Ce simple jeux de lumière semble être une bonne l'occasion d'apprendre à programmer un µC.



QFTIF ?

(Que Faut-il Faire ?)
sgatlantist.gif Comme sur l'animation, il s'agit d'allumer successivement les 7 chevrons de la porte des étoiles (les chevrons 8 et 9 s'allumant en même temps que le N°7) puis d'attendre quelques secondes, pour tout éteindre et recommencer à l'infini.

Après étude de la documentation du µC ATMEGA (voir en annexes), j'ai choisi d'utiliser le PortD.
Ce port 8 bits, est donc constitué des 8 broches N°2, N°3, N°4, N°5, N°6, N°11, N°12, N°13.
La broche N°2 correspondant au bit de poids faible PD0 qui peut prendre la valeur 0 (le courant ne passe pas) ou 1 (le courant passe), et ainsi de suite jusqu'à la broche N°13 PD7.
En programmation, il sera possible de charger des mots de 8 bits sur le PortD.

Par exemple, si on veut que le courant passe sur les broches N°3, N°4 et N°11, c'est à dire les bits PD1, PD2 et PD5, on va charger le mot « 00100110 » sur le PortD
Écrit autrement ça donne :

PD7 PD6 PD5 PD4 PD3 PD2 PD1 PD0
 0   0   1   0   0   1   1   0

Ainsi, on peut établir ce schéma :

SCHEMA

Et avec notre exemple : 00100110 sur le PortD, on aura allumé les LEDS N°2, N°3 et N°6

On va maintenant pouvoir établir le programme !

Démarche Algorithmique :

  1. Configurer le port D en sortie.
  2. Début de la boucle :
  3. Charger le port D de manière à allumer la LED 1.
  4. Attendre 1 seconde.
  5. Charger le port D de manière à allumer la LED 2, tout en laissant allumé la LED 1.
  6. Attendre 1 seconde.
  7. Charger le port D de manière à allumer la LED 3, tout en laissant allumées les LED 1 et 2.
  8. Attendre 1 seconde.
  9. Charger le port D de manière à allumer la LED 4, tout en laissant allumées les LED 1, 2 et 3.
  10. Attendre 1 seconde.
  11. Charger le port D de manière à allumer la LED 5, tout en laissant allumées les LED 1, 2,3 et 4.
  12. Attendre 1 seconde.
  13. Charger le port D de manière à allumer la LED 6, tout en laissant allumées les LED 1, 2,3,4 et 5.
  14. Attendre 1 seconde.
  15. Charger le port D de manière à allumer les LED 7, 8, et 9, tout en laissant allumées les LED 1, 2,3,4,5 et 6.
  16. Attendre 8 secondes.
  17. Charger le port D de manière à éteindre toutes des LEDs.
  18. Attendre 3 secondes.
  19. Fin de la boucle, recommencer…


Programme en C :

Après avoir rassemblé mes notions de langage C et potassé des tutos, voici ce que j'ai écrit : (mon premier logiciel libre ^^)

/* AVR Stargate Atlantis */

#include <avr/io.h>		// appelle la bibliothèque des entrée/sorties
#include <util/delay.h>		// appelle la bibliothèque pour définir _delay_ms() 

int main(void)
{
	DDRD = 0xFF;			// PORTD en sortie
	while (1)			// Début de la boucle
    {
		PORTD = 0b00000001;	// allumer la LED de PD0
		_delay_ms (1000);	// attendre 1 seconde
		PORTD = 0b00000011;	// allumer les LED de PD0+PD1
		_delay_ms (1000);	// attendre 1 seconde
		PORTD = 0b00000111;	// allumer les LED de PD0+PD1+PD2
		_delay_ms (1000);	// attendre 1 seconde
		PORTD = 0b00001111;	// allumer les LED de PD0+PD1+PD2+PD3
		_delay_ms (1000);	// attendre 1 seconde
		PORTD = 0b00011111;	// allumer les LED de PD0+PD1+PD2+PD3+PD4
		_delay_ms (1000);	// attendre 1 seconde
		PORTD = 0b00111111;	// allumer les LED de PD0+PD1+PD2+PD3+PD4+PD5
		_delay_ms (1000);	// attendre 1 seconde
		PORTD = 0b01111111;	// allumer les LED de PD0+PD1+PD2+PD3+PD4+PD5+PD6
		_delay_ms (8000);	// attendre 8 secondes
		PORTD = 0b00000000;	// éteindre toutes les LEDs
		_delay_ms (3000);	// attendre 3 secondes
	}	
	return 0;			// fin du programme
}

Il suffit d'écrire ça dans un fichier texte qu'on nome Stargate.c.

Explications de texte supplémentaire :

  • On charge le fichier d'en tête util/delay.h qui contient des routines qui forcent le processeur à attendre simplement en laissant passer les cycles machine sans rien faire d'utile.
  • La fonction _delay_ms laisse s'écouler le temps spécifié en millisecondes en comptant les cycles d'horloge du processeur.


Le «Makefile» :

Le programme Stargate.c se compile avec le Makefile (fournit en annexes), contenu dans le même répertoire.
Avant de lancer la compilation, il faudra modifier quelques directives de celui-ci pour l'adapter à la situation.

MCU = atmega8, indique le type de µC.
F_CPU = 1000000, pour la fréquence du processeur.
TARGET = Stargate, Le nom du fichier de sortie (sans l'extension), doit être identique au nom du fichier .c.

Ainsi ce fichier tout fait pourra servir à d'autre projet !

Compilation :

On a besoin du logiciel gcc-avr installable par la commande :

sudo apt-get install gcc-avr avr-libc binutils-avr

Puis il suffit de se placer dans le répertoire contenant le fichier .c et le makefile et de lancer la commande :

make

Ce qui crée le fichier Stargate.hex.

Les Bits fusibles :

Si le µC est neuf, on ne va pas toucher à la configuration des bits fusibles.
Sinon, il faudra lui remettre les valeurs par défaut, incluant notamment la prise en compte de l'oscillateur interne @1Mhz :

Sont désactivés (=1 attention, logique inverse) : CKSEL0, SUT1, BODEN, BODLEVEL, BOOTRST, ESAVE, CKOPT, WDTON, RSTDISBL
Sont activés (=0 attention, logique inverse): CKSEL1, CKSEL2, CKSEL3, SUT0, BOOTSZ0, BOOTSZ1,SPIEN

En binaire, les LOW Byte Fuses sont notés ainsi :

BODLEVEL|BODEN|SUT1|SUT0|CKSEL3|CKSEL2|CKSEL1|CKSEL0
    1   |  1  |  1 |  0 |   0  |   0  |   0  |   1

Les HIGH Byte Fuses :

RSTDISBL|WDTON|SPIEN|CKOPT|ESAVE|BOOTSZ1|BOOTSZ0|BOOTRST
    1   |  1  |  0  |  1  |  1  |   0   |   0   |   1

Pour programmer ça avec avrdude, on a besoin de ces valeurs en hexadécimal, chose très facile, sinon voici des explications de la conversion binare/hexa en vidéo ici
Ce qui donne E1 pour les LOW Byte Fuses et D9 pour les HIGH Byte Fuses.

On peut aussi utiliser une calculatrice pour AVR comme celle-ci http://www.engbedded.com/fusecalc/

Réalisation du montage sur plaquette d'essai et Programmation du µC :

Si besoin donc, les bits fusibles doivent recevoir les valeurs 0xe1 en LOW Byte et 0xd9 en HIGH Byte.
On fait cela avec la commande suivante :

sudo avrdude -p atmega8 -P /dev/parport0 -c stk200 -Uhfuse:w:0xd9 :m -Ulfuse:w:0xe1:m


Pour programmer le fichier HEX dans la mémoire flash : (plus d'info ici)

sudo avrdude -p atmega8 -P /dev/parport0 -c stk200 -Uflash:w:/chemin vers le fichier/Stargate.hex

Dés la fin le la programmation, l'animation commence :


Réalisation du typon pour le circuit imprimé grâce à kicad :

J'ai routé le circuit pour m'amuser car je n'ai pas l'intention de le réaliser, mais je vous laisse le projet kicad [1] et la vue 3D.
Stargate-Serigr_Cmp.png Stargate-Dessous.png
AVR-Stargate3D03.png
AVR-Stargate3D01.png AVR-Stargate3D04.png

Note

[1] en annexe

Dimanche, mai 29 2011

CNC, tests de précision

Maintenant que je dispose du petit palpeur pour l’axe des Z, je me lance dans une série de tests de précision de la machine. Notamment un test concernant l’axe des Z. L’axe est monté et descendu 150 fois pour mesurer l’éventuelle dérive de position.

Voilà le morceau de G-CODE utilisé.

G21   (mm)
F80    (probe speed)
(PROBEOPEN probe_point.txt)
#1=0 (counter)
#2=150 (number of points)

O1 while [#1 lt #2]
G0Z2
G38.2Z-10
#1=[#1+1]
O1 endwhile
G0Z2
(PROBECLOSE)
M2

Ainsi que le bout de programme gnuplot pour mettre tout ça en image.

set terminal png size 800,800
set output "point.png"
set title "Vérification des mesures sur un point"
#set xrange [0:5]
#set yrange [-2:2]
plot 'probe_point.txt' using 3  with lines

Et voilà le résultat:

Regardez bien l’échelle, on est au centième de millimètre… pas trop mal pour du DIY ;-)

- page 1 de 12