TUTO CHDK /ARDUINO pour contrôle DU zoom et du déclenchement d’un s95

Slt à tous !!! Photographe et passionné par la technique, je ne pouvais pas passer à côté de la photographie aérienne … Je me suis donc acheté un petit f450 avec une petite nacelle et une gopro … Mais plus adaptée à la vidéo j’en ai vite vu les limites … J’ai donc recherché un bon compact qui puisse être soulevé par mon quadriptére avec une bonne qualité d’image, et me suis arrêté sur le petit s95. Voulant aller plus loin et pouvoir déclencher, zoomer via la radiocommande et aillant déjà utilisé le hack chdk pour les appareils Canon, je me lance dans l’aventure … J’ai passé des heures sur différents forums… Et maintenant, tout fonctionne. Je vais essayer de regrouper ici un maximum d’infos en reprenant tout depuis le début : Ce que je veux : Déclencher (interrupteur) et Zoomer/dezoomer (potentiomètre) depuis ma radiocommande (futaba T8FG)

1-Je configure la voie 6 de ma radio sur un l’interrupteur nommé HS (mais il marche)

Qu'est ce qui sort de mon récepteur ? Je branche mon oscilloscope sur la voie 6 de mon récepteur pour voir ce qu’il se passe :

Cable servo Futaba:

interrupteur à 0 oscilo à 5 milliseconde:

Interrupteur à 0 oscilo à 500 microseconde:

Je mesure une largeur d’impulsion de 1.1ms inter à 0.

interrupteur à 1 et oscilo à 5 milliseconde:

interrupteur à 1 oscilo à 500 microseconde:

Je mesure une largeur d’impulsion de 1.9ms inter à 1.

Je me branche maintenant sur la voie 8 de mon récepteur correspondant au potentiomètre (RD) de ma radio, et là, même comportement :

0% : 1.0 ms 50% : 1.5 ms 100% : 1.9 ms Tout va pour le mieux dans le meilleur des mondes Je vais donc mesurer ces impulsions avec une carte arduino et renvoyer l'info sur le port USB de monS95 qui sera interprétée par le hach CHDK MAIS NON , ces impulsions ne sont pas suffisamment précises. Pour mesurer ces impulsions, le plus simple est d'utiliser une carte (avec microcontroleur), j'ai choisi l'arduino

L'Arduino c'est QUOI ?

La carte arduino c'est koi ... : Imaginons que l'on puisse dire à sa machine à laver : (sorties arduino) - Tu mets 3 litres d'eau - tu tournes le tambour 3 fois à droite puis 1 fois à gauche - tu chauffes à 60° - tu lâches de l'adoucissant dans 15 min Mais on peut aussi poser des questions : (entrées arduino) - combien de kg dans le tambour ? - Quelle est la température extérieure ? - WHO’s on first? C’est donc une sorte de petit ordinateur qui tient sur une petite carte électronique. Cette carte comporte des entrées, des sorties et un cerveau qui permet de faire des calculs très rapidement. Et avec ça on peut faire multitudes d’application.

Restons sur l’exemple Machine à laver : mini machine à laver v0.01 contrôlée par carte arduino.

Les entrées : - Mesure du poids du linge (capteur de poids, balance) E3 - Choix du programme (interrupteurs/programmateur)E2 - Mesure du niveau d’eau (capteur de niveau/ Pressostat)E5 - Mesure de la température (thermomètre)E4 - Mesure de vitesse de rotation (tachymètre)E1

Les sorties : - Bloquer la porte (électroaimant)S3 - Remplissage de la machine (électrovanne)S2 - Chauffage de l’eau (résistance)S1 - Rotation du tambour (moteur)S5 - Vidanger la machine (pompe)S4

Ce que va faire la carte le cerveau, le microcontrôleur de l’arduino (suivant le programme choisi par interrupteur sur notre machine à laver) : - Bloquer la porte (sortie) - Prendre l’information (entrée) poids du linge donnée par la balance. - Prendre l’information (entrée) choix du programme donnée par l’interrupteur rotatif. - Calculer suivant le programme choisi et le poids du linge la quantité d’eau nécessaire dans le tambour (microcontrôleur) - Ouvrir l’électrovanne (sortie) d’arrivée d’eau. - Surveiller le niveau d’eau avec le capteur de niveau (entrée) - Doser la lessive/adoucissant suivant le poids grâce à une pompe (sortie) - Mettre en route le moteur (sortie) - Alimenter la pompe de vidange (sortie) pour évacuer l’eau. - Calculer la vitesse maximale pour l’essorage que pourra supporter la machine suivant le poids du linge mouillé (microcontrôleur) - Mettre en route le moteur (sortie) - Arrêter la machine après un temps X Et comment lui dire tout ça à notre petite carte ? En lui balançant dans son petit port usb ce qu’elle doit faire : 1 Mets à 1 la sortie S3 = Alimente l’électroaimant pour bloquer la porte 2 Prends l’information « poids » qui est sur l’entrée E3 = Pèse le linge 3 Prends l’information « Mode » sur l’entrée E2 = Regarde le programme choisi 4 Si le « poids » est plus petit que 1.5 kg alors « remplissage eau » = 5 litres Si le « poids » est plus grand que 3 kg alors « remplissage eau » = 8 Litres Si le « poids » est plus grand que 4.5 kg alors « remplissage eau » = 12 Litres 5 Si Le « mode » est 1 alors « temps de lavage » = 30 min Si Le « mode » est 2 alors « temps de lavage » = 60 min 6 Mets la sortie S2 à 1 = Ouvre l’électrovanne est laisse passer l’eau. 7 Surveille L’entrée E5 = Regarde le niveau de l’eau Si E5 est égal ou supérieur à la valeur « remplissage d’eau » de la ligne 4 alors mets la sortie S2 à 0 = ferme l’électrovanne = coupe l’arrivée d’eau Sinon retourne à la ligne 7 8 Mets la sortie s5 à 1 = alimente le moteur = fait tourner le tambour 9 Fais une pause de « temps de lavage » définit ligne 5 10 Mets la sortie s5 à 0 = coupe le moteur 11 Mets à 0 la sortie S3 = coupe l’électroaimant pour débloquer la porte

Mais cette carte ne parle pas comme nous et comprends plutôt ça :

//Exemple machine à laver arduino //3.5 kg de linge et programme 2 choisi //défini les positions sur la carte des entrées ou des sorties int electroaimant = 1; // l'électroaimant est sur la broche 1 int moteur = 2;// le moteur est sur la broche 2 int electrovanne = 3; // l'électrovanne est sur la broche 3 int poids = 4;// la mesure du poids est sur la broche 4 int niveau_eau = 5;// le niveau d'eau est sur la broche 5 int mode = 6; // l'interrupteur mode est sur la broche 6 // Initialisation des differentes variables int val_poids=0; int remplissage_eau=3; int temps_de_lavage=0; int niv_eau=0; int val_mode=1; void setup() { // definition si entrées ou sorties pinMode(electroaimant, OUTPUT); // La broche électroaimant (1) est une sortie pinMode(poids, INPUT); // La broche poids (2) est une entrée pinMode(mode, INPUT); // La broche mode (3) est une entrée pinMode(electrovanne, OUTPUT); // La broche électrovanne (4) est une sortie pinMode(niveau_eau, INPUT); // La broche niveau_eau (5) est une entrée pinMode(moteur, OUTPUT); // La broche moteur (6) est une sortie } //Programme principal void loop(){ digitalWrite(electroaimant, HIGH); // ferme la porte val_poids = digitalRead(poids); // relève le poids val_mode = digitalRead(mode); // relève le mode choisi // défini la quantité d'eau nécessaire suivant le poids if (val_poids > 1.5) {remplissage_eau = 5;}; // si poids est plus grand que 1.5 alors la variable "remplissage_eau=5" if (val_poids > 3) {remplissage_eau = 8 ; }; // si poids est plus grand que 3 alors la variable "remplissage_eau=8" if (val_poids > 4.5) {remplissage_eau = 12 };// si poids est plus grand que 4.5 alors la variable "remplissage_eau=12" //Défini le temps que doit tourner la machine suivant le mode de lavage choisi if (mode = 1) { temps_de_lavage=30;}; // si le mode choisi est égal à 1 alors la variable "temps_de_lavage=30" if (mode = 2) {temps_de_lavage=60; }; // si le mode choisi est égal à 2 alors la variable "temps_de_lavage=60" // Rempli le tambour de la bonne quantité d'eau while (digitalRead(niveau_eau) < remplissage_eau){// Tant que le niveau d'eau est plus petit que la variable remplissage_eau (8L dans notre exemple) digitalWrite(electrovanne, HIGH); }; //Alors ouvre l'électrovanne et rempli le tambour digitalWrite(electrovanne, LOW);// Ferme l'électrovanne //Fait tourner le tambour pendant le temps correspondant au mode de lavage choisi digitalWrite(moteur, HIGH);// Alimente le moteur delay (temps_de_lavage*60000); // pendant 60 min dans notre exemple "delay (1000)=1s" digitalWrite(moteur, LOW); // Coupe le moteur digitalWrite(electroaimant, LOW); // Ouvre le loquet de la porte // Et là vous prenez 8 litres d'eau sur vos godasses vu qu'il n'y a pas de gestion de vidange ... }

En savoir plus sur cette petite carte : http://www.arduino.cc/fr/

Mais nous ne sommes pas sur le forum de Darty …

Revenons à notre projet pour notre drone. Ce que la carte Arduino doit faire : Mesurer la taille des impulsions sur les voies 6 et 8 du récepteur de ma radiocommande et renvoyer une commande de zoom ou de déclenchement à mon appareil photo. Mesurer la taille des impulsions : Par bonheur une instruction existe et ne sert qu’à ça c’est Tatatin :PulseIn ( http://arduino.cc/fr/Main/PulseIn ) En gros, cette instruction mesure la taille d’une impulsion à partir d’un front montant ou descendant.

// Test de l'instruction PulseIn sur une voie de récepteur de radiocommande // Le fil Data de la voie8 est connecté sur l'entrée/sortie 2 de l'arduino // potentiomètre (RD) de ma radio à 50%(milieu) int mesure_voie8; //déclaration de la variable void setup() { pinMode(2, INPUT); // La broche 2 de l'arduino est une entrée Serial.begin(9600); //initialise le port série de l'arduino afin d'envoyer des info via son port usb } void loop() { mesure_voie8 = pulseIn(2, HIGH); //mesure la taille des impulsions entrant dans la broche 2 à partir de leur front montant Serial.println(mesure_voie8); // Ecrit cette valeur sur le moniteur série du logiciel arduino delay (500); // Faits une pause d'une 1/2 seconde }

Et voiloux le résultat :

Comme nous pouvons le voir nous sommes loin d’une grande précision …

Donc pour le zoom, et le déclenchement l’idée est d’envoyer à l’appareil photo des informations représentatives de la position du potentiomètre ou de l’interrupteur (donc de différentes longueurs d'impulsions reçues par le récepteur) et que cet appareil photo l’interprète comme une des positions du zoom ou un ordre de déclenchement grâce au chdk. Au niveau câblage c'est simple:

Le CHDK c'est QUOI ?

Je vais vous épargner le contrôle d’un fer à repasser via chdk Qu’est-ce qu’un appareil photo :

Un boitier avec des boutons, des lentilles, de l’électronique (avec un microcontrôleur comme pour notre carte arduino) et un programme qui gère le tout (comme pour notre carte arduino). Mais dans un appareil photographique numérique, ce programme est inconnu et n’est surtout pas modifiable !!!

Et ba Si !!!

Des ptis gars ont réussi à entrer dans les compact canon et y insérer un programmes alternatifs (chdk) pour modifier/améliorer/ajouter des fonctions et surtout, c’est ce qui nous intéresse ici, pouvoir réaliser des petits programmes (scipt) pour faire différentes actions à la suite des autres (commande de l’autofocus, de l’exposition, du zoom, des boutons etc.) Ex : Tu zoom à 0, tu fais un autofocus tu exposes à -1, tu shoot, tu exposes à 0, tu shoot, tu exposes à +1, tu shoot, tu zoom à 5 etc. Je ne vais pas développer ici son installation sur votre appareil, mais vous renvoie vers le site officiel : http://chdk.wikia.com/wiki/CHDK En french : http://chdk.wikia.com/wiki/French/CHDK_en_bref Et pour notre application, à quoi le chdk va servir ? A interpréter une information venant de la carte arduino et de changer le niveau de zoom ou à déclencher en conséquent. Et comment parler à notre petit appareil canon ? Depuis quelque temps, une nouvelle possibilité s’offre à nous pour communiquer avec l’appareil photo en passant directement par le port usb(11) de celui-ci. Dans le script cette fonction est : « get_usb_power » Cette fonction surveille le port USB (usb+ et -) et mesure la taille d’une impulsion appliquer sur celui-ci à partir de son front montant un peu comme la mesure de la carte arduino) Plus d'infos ici : http://chdk.wikia.com/wiki/USB_Remote

Pour activer le mode télécommande allez dans le menu chdk :

Scripting parameters.

Remote parameters.

Et cocher enable remote.

Pour tester un petit programme simple qui va prendre une photo et mesurer le temps qu'un câble usb/mini usb est branché d'un coté sur votre pc et de l'autre sur votre appareil.

a=0 do rem mets dans la variable "a" le temps pendant lequel le port usb est alimenté a=get_usb_power rem A partir du moment ou "a" est > 0 until a>0 rem prends une photo shoot rem affiche la taille sur l'écran de l'appareil photo print "taille=", a

Pour tester la précision de du chdk sur la mesure d’impulsion je réalise un ptit programme pour l’arduino qui envoie en boucle sur le port USB de mon appareil une impulsion de 200ms toute les secondes.

Citer

void setup() { pinMode(5, OUTPUT); Serial.begin(9600); } void loop() { digitalWrite(5,HIGH); delay(200); digitalWrite(5,LOW); }

Et un programme CHDK qui mesure et affiche l’impulsion reçue.

a=0 :debut a=0 do a=get_usb_power until a>0 print "taille=", a goto "debut"

Et voilà le résultat :

Pour une même valeur envoyée de 200ms on peut avoir un résultat de 14,15 ou 16 ... Bonjour la précision ... Il va donc falloir ruser ... Je me souviens de mes vieux cours d’électronique … Bit de start et bit de Stop … En fait on envoie une impulsion d’une certaine taille (ex :200ms/bit de Start ) pour dire à l’appareil photo que le message que l’on envoie commence, l’appareil photo prend les informations (ici on va compter des impulsions de 50ms) et pour dire que le message est fini on envoie un bit de Stop (une impulsion de 120ms) En gros l’appareil surveille la présence d’une impulsion de 200ms (bit de Start) dès qu’elle est détectée il compte le nombre d’impulsions de 50ms envoyées et s’arrête de compter seulement s’ il détecte une impulsion de 120ms (bit de Stop) Et le nombre d’impulsion compté correspondra au niveau de zoom ou à un ordre de déclenchement. Programmes Voici donc la partie programme arduino qui envoie un bit de start, un nombre d'impulsion correspondant à la valeur du potentiomètre ou de l’interrupteur de déclenchement et enfin un bit de stop :

//2013-daniel wambach - www.macrogoutte.com - tarrinos@free.fr // commande du zoom et du déclenchement d'un appareil photo (canon s95) via chdk int mesure_voie6; // voie pour la mesure du zoom int mesure_voie8; // voie pour le déclenchement de l'appareil photo int niveau_zoom; // initialisation de la variable "niveau_zoom" int exniveau_zoom; // initialisation de la variable "exniveau_zoom" int i; // initialisation de la variable "i" int t; // initialisation de la variable "t" void setup() { // choix des entrée d2 et d3 de l'arduino pinMode(2, INPUT); // La broche 2 de l'arduino est une entrée ( surveille voie 8 ) pinMode(3, INPUT); // La broche 3 de l'arduino est une entrée( surveille voie 6 ) pinMode(5, OUTPUT); // La broche 5 de l'arduino est une sortie( vers appareil photo ) Serial.begin(9600); // Communique avec le port série à une vitesse de 9600 }

void loop() { debut: // mesure l'interrupteur dédié au déclenchement sur ma radiocommande mesure_voie8 = pulseIn(2, HIGH); // Mesure la taille de l'impulsion sur la voie 8 if (mesure_voie8>1500){ // Si la taille de cette impulsion est supérieur à 1500 alors : digitalWrite(5,HIGH); // commence une impulsion sur la broche 5 (front montant) delay(300); // Pendant 300 ms digitalWrite(5,LOW); // arrête cette impulsion (front descendant) delay (100); // faits une pause de 100 ms } // mesure le potentiomètre dédié au zoom sur ma radiocommande delay (500); mesure_voie6 = pulseIn(3, HIGH);// Mesure la taille de l'impulsion sur la voie 6 delay (10); Serial.print("mesure_voie6="); // Ecris sur le port série "mesure_voie6=" Serial.println(mesure_voie6); // Ecris sur le port série la valeur mesurée sur la voie 6 // Donne le niveau de zoom suivant les largeurs des impulsions mesurées sur le récepteur voie 6 // J'ai affiné ces chiffres en testant différentes positions de mon potentiomètre cranté // Mais en gros si on à 1ms pour un zoom à 10(téléobjectif) et 2ms pour un zoom à 0(grand angle) // 2ms-1ms = 1ms; 1ms/10 = 100 micro/sec // donc sans affiner : zoom1=1900; zoom2=1800; zoom3=1700 etc. // Mais à vous de mieux régler ... Pour moi ça donne: if (mesure_voie6<1936) niveau_zoom=1; // Si la valeur mesurée sur la voie 6 est supérieure à 1936 alors zoom=1 if (mesure_voie6<1863) niveau_zoom=2; // Si la valeur mesurée sur la voie 6 est supérieure à 1863alors zoom=2 if (mesure_voie6<1765) niveau_zoom=3; // Si la valeur mesurée sur la voie 6 est supérieure à 1765 alors zoom=3 if (mesure_voie6<1681) niveau_zoom=4; // Si la valeur mesurée sur la voie 6 est supérieure à 1681 alors zoom=4 if (mesure_voie6<1602) niveau_zoom=5; // Si la valeur mesurée sur la voie 6 est supérieure à 1602 alors zoom=5 if (mesure_voie6<1518) niveau_zoom=6; // Si la valeur mesurée sur la voie 6 est supérieure à 1518 alors zoom=6 if (mesure_voie6<1443) niveau_zoom=7; // Si la valeur mesurée sur la voie 6 est supérieure à 1443 alors zoom=7 if (mesure_voie6<1359) niveau_zoom=8; // Si la valeur mesurée sur la voie 6 est supérieure à 1359 alors zoom=8 if (mesure_voie6<1274) niveau_zoom=9; // Si la valeur mesurée sur la voie 6 est supérieure à 1274 alors zoom=9 if (mesure_voie6<1191) niveau_zoom=10;// Si la valeur mesurée sur la voie 6 est supérieure à 1191 alors zoom=10 Serial.print("niveau_zoom");// Ecris sur le port série "niveau_zoom=" Serial.println(niveau_zoom);// Ecris sur le port série la valeur de "niveau_zoom" if (exniveau_zoom==niveau_zoom) { goto debut; // si il n'y a pas de changement, retourne au début du script exniveau_zoom = niveau_zoom; // bit de start pour dire à l'appareil photo qu'il peut commencer à compter le nombre d'impulsion correspondant au niveau de zoom digitalWrite(5,HIGH); // Mets la broche 5 à 1 (commence l'impulsion(front montant)) delay(200); // Pendant 200ms "bit de start" digitalWrite(5,LOW); // Mets la broche 5 à 0 (arrête l'impulsion(front descendant)) delay (100); // une pause de 100ms // Envoie un nombre d'impulsion correspondant au niveau du zoom i=0; while (i<niveau_zoom){ // Tant que le nombre d'impulsion n'est pas envoyé recommence i=i+1; digitalWrite(5,HIGH);// commence une impulsion sur la broche 5 (front montant) delay(50);// Pendant 50 ms digitalWrite(5,LOW);// arréte cette impulsion (front descendant) delay (100); // une pause de 100ms } // bit de stop pour dire à l'appareil photo qu'il peut arrêter de compter digitalWrite(5,HIGH); // commence une impulsion sur la broche 5 (front montant) delay(120); //// Pendant 120ms "bit de stop" digitalWrite(5,LOW); //arrête cette impulsion (front descendant) delay (100);// une pause de 100ms }

Regardons ce qui sort maintenant de l'arduino sur la sortie d5 : Pour le potentiomètre à 0 :

Et pour le potentiomètre à mi-course :

Et ba moi je dis : Bravo arduino

Passons au script chdk qui devra interprété ce signal:

rem déclaration des variables rem a pour la mesure d'une impulsion a=0 rem d pour le compteur d’impulsion d=0 rem prends une photo (ça me sert à voir si le script est bien lancé) shoot rem fait une pause d'une seconde sleep 1000 rem sous-programme début :debut rem si y a une impulsion alors mesure la do a=get_usb_power until a>0 rem si la l'impulsion mesurée est plus grande que 24 alors va à la ligne (sous-programme) shoot du script if a>24 then goto"shoot" rem si l'impulsion mesurée est plus grande que 15 alors va à la ligne (sous-programme) compte du script if a>15 then goto "compte" rem sinon retourne à la ligne début du programme goto "debut" rem sous-programme compte :compte rem si il y a une impulsion alors mesure la do a=get_usb_power until a>0 rem si la valeur mesurée est comprise entre 8 et 15 (bit de stop) va au sous programme zoom if a>8 and a<15 then goto"zoom" rem compteur d'impulsion=compteur d'impulsion + 1 d=d+1 rem retourne au sous-programme compte goto "compte" rem sous-programme zoom :zoom rem affiche sur l['écran de l'appareil photo (d) le niveau du zoom correspondant au nombre d'impulsion mesurée -1 print"zoom=", d-1 rem demande à l'appareil photo de faire un zoom à d-1 set_zoom d-1 rem rem et les variables à 0 a=0 d=0 rem retourne à la ligne debut goto "debut" rem sous-programme shoot :shoot rem demande à l'appareil photo de faire une photo shoot rem retourne à la ligne debut goto "debut"

Le connecteur USB11 Canon (saloperie de connecteur) Je décline toute responsabilité en cas d'incident, d'accident, de dommages, ou de préjudice physique ou moral, causés sur une tierce personne, un animal, ou sur du matériel. Ça s’est dit … Ne scotchez jamais de hamster sur votre drone

Pour faire fonctionner ce montage, un simple câble mini USB fonctionne. Pour une très grande partie des câbles USB standard on coupe le câble au niveau de la grosse prise USB, on dénude, le fil rouge c’est le (+) et le fil noir c’est le (-) … On branche le (+) sur la sortie 5 de l’arduino, le (-) sur la masse de l’arduino et les impulsions envoyées par l’arduino seront facilement interprétées par le programme chdk de l’appareil photo. OUI MAIS …. La Vidéo ? C’est bien de commander le zoom et le déclenchement via notre radiocommande, mais avec un retour vidéo c’est encore mieux ! La prise usb11 n’existe pas encore, oui c’est dur à entendre … Mais il existe des prises normalement pour mobile HTC compatible :

Comme vous pouvez le constater, ce n’est pas bien gros …Si vous n’êtes pas habitué à souder, laisser tomber … Il faut en premier lieux enlever l’entourage métallique de cette petite prise HTC (sinon ça ne rentre pas dans le Canon), pour ma part j’ai utilisé ma dremelle, ensuite pas de café, pas de musique trop violente et avec un bon fer à souder muni de sa panne la plus fine on soude des fils fins suivant ce schéma :

J’ai fait quelques vols avec ce connecteur, mais il tient mal, il gigote, ça ne fait vraiment pas sérieux … J’ai donc acheté par la suite : http://www.kapshop.com/p281/CR-Camera-11-pin-USB+A/V-Combo-Cable-for-Canon/product_info.html Que j’ai renforcé, et là, c’est nickel ! Voilà, je pense avoir tout dit et donné une bonne première approche des mondes arduino et chdk. Le programme est encore lent et il arrive de temps en temps que le zoom ne soit pas celui demandé, mais pour une application photographique où j’ai le temps, c’est pour moi 100% fonctionnel. Bien sûr, rien n’est fermé, je suis loin d’être un bon programmeur, je suis juste un bidouilleur. Alors si vous arrivez à arranger mon code pour régler les lenteurs et petits problèmes, je ferai évoluer les versions des 2 programmes. De plus les informations envoyées par l’arduino servent dans mon exemple à commander le zoom, mais rien n’empêche de commander tout autre chose avec le chdk (exposition, vitesse, couleur etc.) On peut vraiment agir sur toutes les fonctions de l’appareil photo. Si une partie du tuto n’est pas assez détaillée, si vous rencontrez des problèmes, si vous trouvez des erreurs n’hésitez pas à me le dire en message perso. Voilà, depuis des années je parcours le web pour des infos sur de l’électronique, de la programmation, de la bidouille en tout genre. J’espère par ce tuto payer une partie de ma dette … A vous . Dan, J’allais oublier la vidéo : http://www.youtube.com/watch?v=qel3CSywEiE