Bonjour tout le monde !

Aujourd’hui j’ai le plaisir de publier la seconde partie de mon projet d’alimentation d’atelier DIY.
Pour ceux qui n’auraient pas suivi la première partie est disponible ici :
http://skyduino.wordpress.com/2012/09/04/bricolage-partie-1-alimentation-datelier-diy-a-partir/

Certains points ont évolué depuis la rédaction de cette première partie, en particulier concernant le schéma du montage que j’ai du entièrement revoir.
Trêve de bavardages, voici venu l’heure du DIY

–

Le matériel :

Pour la réalisation de la carte mère j’ai utilisé :
1x carte arduino pro mini
1x écran LCD compatible HD44780
3x capteurs de courant ACS712
2x protoboards 3x7cm
3x prises banane (rouge)
3x prises banane (noir)
3x leds rouge 5mm
2x leds verte 5mm
1x buzzer
1x résistance de 100 ohms
3x résistance de 10K
5x résistances de 330 ohms
1x condensateur de 100µF
1x potentiomètre de 47K
1x capteur LM35 (optionnel)
+ des connecteurs tulipes mâles et femelles
+ des fils de câblages

Remarque : sur la photo vous pouvez voir un écran "POWERTIP PC1602-H", j’ai du changer d’écran après coup suite à un problème technique (j’en parlerai plus tard).

–

Le câblage :

Le montage est constitué de plusieurs parties qui une fois assemblées forment le montage final.

Les capteurs de tension :

Une des fonctionnalités de base d’une alimentation c’est de fournir un retour sur la tension réel en sortie.

Pour ceux faire j’ai utilisé 3 ponts diviseurs de tension, abaissant les 3 tensions de sortie de l’alimentation à un maximum de 5V pouvant être mesuré par la suite par l’arduino.
Les sorties +3v3 et +5v de l’alimentation sont mesurées au travers d’un pont diviseurs 1/2 pouvant donc accepter 10v maximum en entrée (j’ai vu large "au cas où").
La sortie +12v est mesuré au travers d’un pont diviseur 1/4 pouvant donc accepter 20v en entrée.

Les capteurs de courant :

Une autre fonctionnalité bien pratique pour une alimentation c’est de fournir une mesure du courant consommé sur chaque sortie.
Dans mon cas j’ai utilisé trois capteurs de courant intégrés du fabricant Alegro facilement disponible en breakout sur ebay ou dealExtreme : le ACS712.
Comme je ne sait pas encore très bien dans quelle fourchette de courant je vais me situer j’ai choisi de taper haut, j’ai donc pris une version x30A avec un maximum mesurable de 30A.
(autant dire qu’avec 30A j’ai de la marge)

Datasheet du ACS712-30A : http://www.allegromicro.com/~/Media/Files/Datasheets/ACS712-Datasheet.ashx

Les signaux de contrôle de l’alimentation :

Pour pouvoir fonctionner correctement mon système à besoin de deux signaux reliés à l’alimentation d’ordinateur qui me sert de source de tension.

Un PSU d’ordinateur (= une alimentation à haut rendement) ce contrôle via deux signaux :
- PSU_ON (entrant, actif à l’état bas)
- POWER_OK (sortant, actif à l’état haut)
Ce sont tout les deux des signaux TTL, si PSU_ON est mis à GND l’alimentation démarre, de même quand POWER_OK passe à 5v cela signifie que la tension de sortie est stabilisé.

Vous remarquerez que j’ai mis la led du signal PSU_ON à l’envers (actuellement elle s’allume quand l’alimentation est arrêté).
Une fois le montage fini et testé je ferai une petite modification afin qu’elle s’allume quand PSU_ON = 0v, mais pour le moment je garde la configuration du schéma.

L’écran LCD :

Pour l’affichage j’ai pris un écran LCD 16×2 compatible HD44780, du classique disponible dans n’importe quelle boutique d’électronique.

J’ai cependant fait les frais d’une petite erreur d’inattention lors de ma commande !
J’avais commandé à l’origine un écran de la marque POWERTIP de référence : "PC1602-H".
Grosse boulette !

Le suffixe "-H" dans la référence signifie qu’il s’agit d’un écran pour une utilisation assujetti à de fortes températures (plein soleil, fours, …).
En dessous de 60° l’écran est totalement vierge, au dessus, miracle il est parfaitement lisible …
Pour pouvoir l’utiliser dans des applications "classique" (à 20-25°) il faut envoyer une tension négative dans la broche VO (contraste).
Dans mon cas cela n’était absolument pas envisageable …
J’ai donc du changer d’écran, au final j’ai pris un écran lcd 16×2 qui traînait dans un tiroir.

Les leds de statut :

Mon alimentation DIY a une petite fonctionnalité bonus : chaque sortie est géré indépendamment.
Ainsi j’ai prévu 3 leds rouges qui s’allumeront pour prévenir d’une surcharge imminente sur une sortie.
Cela me permettra de savoir quelle sortie pose problème si l’alimentation se coupe par sécurité.

Le bouton start / stop / restart :

Pour l’allumage / arrêt / redémarrage de l’alimentation j’ai prévu un unique bouton.
Ainsi pour démarrer l’alimentation il suffira de presser le bouton, de même pour l’éteindre.
Et dans le cas où l’alimentation se couperait par sécurité il suffirait de presser ce même bouton pour redémarrer l’alimentation.

Afin d’éviter tout problème côté arduino j’ai inclus un anti-rebond matériel au niveau du bouton.
L’anti-rebond se résume à un condensateur de 100µF en parallèle de l’interrupteur, soit un anti-rebond de ~100ms (T = RxC, R = 10000, C = 10E-6 soit T = 0.1).

Le buzzer :

Une bonne alimentation (surtout DIY !) se doit d’avoir un buzzer
C’est pourquoi j’ai prévu dans mon montage un buzzer avec une résistance de limitation de courant de 100 ohms.

Ce buzzer aura pour but d’alerter d’une coupure de l’alimentation, d’une surcharge ou de la stabilisation des tensions de sortie.
Ce sera aussi une bonne occasion d’inclure un "easter eggs" dans le code arduino

Le capteur de température :

Après avoir fini mon montage je me suis rendu compte qu’il me restait une entrée analogique de libre …
Cela aurait été dommage de la laisser tel quelle, c’est pourquoi j’ai ajouté un capteur de température analogique LM35 au montage.
Celui ci permettra de surveiller la température des capteurs de courant qui risque de chauffer avec de fortes charges sur les sorties.

–

Montage sans câbles :

Voici quelques photos prisent durant le montage avant la mise en place des différents câbles.

La "carte mère", vue côté buzzer :

(le potentiomètre sur la gauche est celui de l’écran lcd)

La "carte mère", vue côté capteurs de courant :

Les différents morceaux constituant la "carte mère" :

La base de la "carte mère" :

Le support déporté pour l’écran lcd et les leds :

(il s’agit de la première version, avant que je découvre le problème de l’écran lcd)

–

Petite parenthèse concernant l’écran lcd :

Comme je vous le disait l’écran d’origine posait problème de part son alimentation négative pour le contraste.
Dans la première version de mon montage l’écran venait s’enficher dans un connecteur dédié comme vous pouvez le voir sur la photo.

C’était propre, mais bon … tant pis.
Refaire une commande pour prendre le même écran en version standard m’aurait coûté trop chère (surtout en frais de port), j’ai donc sacrifié mon montage "propre" au profit d’un montage fonctionnel.

–

Montage fini avec les câbles :

Ça fait tout de suite beaucoup moins propre je vous l’accorde.

Vous remarquerez que les broches A6 et A7 (disponibles uniquement dans la version CMS de l’ATmega328p) sont derrière le bouton reset, de même que A4 / A5 sont situés juste à coté du régulateur.
J’ai du jouer du cutter pour couper une piste reliée sur A5, cette version chinoise de l’arduino pro mini intégrant des résistances de pull-up pour l’I2C qui venaient fausser mes mesures analogiques.

(la colle chaude c’est la vie !)

Astuce : les capteurs de courants que j’ai utilisé avaient déjà des borniers de base.
J’ai donc juste mis un câble pour "piquer" la tension au niveau du capteur de courant et l’injecter dans les ponts diviseurs mesurant la tension des sorties.

Voici un exemple très parlant de l’expression : "cacher la merde sous le tapis"

Annexe, le capteur de température :

Comme je l’ai déjà dit j’ai ajouté un capteur de température LM35 au circuit.
Celui ci sera monté à terme sur une petite lame de métal qui recouvrira les trois capteurs de courant (avec de la patte thermique pour faire la liaison).
Cela permettra de dissiper la chaleur émise par les capteurs tout en la mesurant.

–

Premier essai du hardware :

Histoire de tester sommairement mon montage j’ai réalisé un petit code de test :

#include <LiquidCrystal.h>

/* Pin mapping */
static const byte LED_PIN[3] = {
  11, 12, 13
};
static const byte VOLTAGE_SENSOR_PIN[3] = {
  A0, A1, A2
};
static const byte CURRENT_SENSOR_PIN[3] = {
  A3, A6, A7
};
static const byte BUTTON_PIN = 2;
static const byte POWER_OK_PIN = 3;
static const byte PSU_ON_PIN = 4;
static const byte BUZZER_PIN = A4;
static const byte TEMP_PIN = A5;

/* LCD mapping */
LiquidCrystal lcd(10, 9, 8, 7, 6, 5);

/* PSU state */
static byte PSU_state;

void setup() {

  /* Setup pins */
  for(byte i = 0; i < 3; ++i) {
    pinMode(LED_PIN[i], OUTPUT);
    pinMode(VOLTAGE_SENSOR_PIN[i], INPUT);
    pinMode(CURRENT_SENSOR_PIN[i], INPUT);
  }
  pinMode(BUTTON_PIN, INPUT);
  pinMode(POWER_OK_PIN, INPUT);
  pinMode(PSU_ON_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  /* PSU_ON and button signals interrupt setup */
  attachInterrupt(0, buttonPressCallback, FALLING);
  attachInterrupt(1, powerOkCallback, CHANGE);

  /* Serial setup */
  Serial.begin(115200);

  /* LCD setup */
  lcd.begin(16, 2);

  /* Get current PSU state */
  PSU_state = digitalRead(POWER_OK_PIN);

  /* Test code */
  lcd.print("Hello World !");
  digitalWrite(LED_PIN[0], HIGH);
  digitalWrite(LED_PIN[1], HIGH);
  digitalWrite(LED_PIN[2], HIGH);
  tone(BUZZER_PIN, 440, 500);
}

void loop() {

  /* Test code */
  for(byte i = 0; i < 3; ++i) {
    Serial.print(i);
    Serial.print(": ");
    Serial.print(analogRead(VOLTAGE_SENSOR_PIN[i]));
    Serial.print(" , ");
    Serial.println(analogRead(CURRENT_SENSOR_PIN[i]));
  }

  static byte s = LOW;
  digitalWrite(PSU_ON_PIN, (s = !s));
  
  delay(500);
}

void buttonPressCallback() {

  /* Test code */
  tone(BUZZER_PIN, 440, 500);
}

void powerOkCallback() {

}

Il est vraiment basique mais il m’as permis de tester grossièrement chaque partie du montage et de concevoir un squelette de code pour la suite.

Test de la carte arduino :

Test des leds :

Test de l’écran lcd :

Test des capteurs de courant :

–

La suite ?

Il me reste encore à réaliser un boitier pour le montage, de même qu’une jolie façade (sérigraphié ça serait top).
Ensuite il me faudra faire le code est finir le câblage des prises banane et des sorties de l’alimentation.
J’ai encore du boulot pour un petit moment

Bon bidouillage et bon WE à tous

Classé dans:arduino, Corrigé, programmation, projet Tagged: diy, hack, madeinfr

Bonjour tout le monde !

Pour notre projet tutoré à l’IUT nous avions besoin d’un dock micro usb OTG (je ne rentre pas dans les détails du projet en lui même ce serait trop long à expliquer).
On trouve plein de câble micro usb OTG dans le commerce, souvent en import direct de chine, le tout pour moins de 10$ voir moins.

Un câble "du commerce" c’est bien mais le problème c’est que ça prend de la place, qu’il soit coudé à 90° ou non !
Pour notre projet nous avions plutôt besoin d’un dock "low profil" avec un connecteur micro usb câblé en OTG qu’un simple câble coudé.
Après des heures de recherche sur ebay, dealExtreme & co le constat est sans appel, ça n’existe pas en "tout fait" …

Du coup, ni une ni deux, une commande de connecteur chez farnell, un petit typon sous Ares et voila ce que cela donne en image

–

Le connecteur :

J’ai choisi d’utiliser des connecteurs micro usb traversant miniature SANS "bouclier" de métal autour du connecteur afin d’éviter que le dock ne soit trop dur à brancher / débrancher.
Pour ceux qui veulent la référence ce sont des ZX20-B-5S disponibles chez farnell pour un prix dérisoire.

Aussi par miniature, j’entends "vraiment" miniature, le bout de pince que vous pouvez apercevoir sur la photo fait en réalité 2mm, ça vous donne une idée de la taille globale du connecteur.

–

Mon "environnement de travail" :

Bon j’avoue c’est pas très "pro" comme environnement de travail

–

1er étape : le pré-câblage du connecteur :

Comme les broches du connecteur ne font qu’un millimètre de long je ne pouvais pas les souder directement sur un morceau de pcb.
L’astuce des câbles OTG "du commerce" utilisant ce genre de connecteur est d’insérer un pcb très fin entre les deux rangées de broches et de souder le connecteur directement dessus.

Le problème c’est qu’ils nous faillaient un dock, soit un connecteur perpendiculaire au câble.
J’ai résolu le problème en soudant des fils de cuivre émaillés très fin à chaque broche du connecteur, fils qui seront soudés par la suite sur le pcb.

Gros plan sur les soudures, ça m’a pris une bonne demi-heure pour tout souder et vérifier que les soudures étaient bonnes.

–

2iéme étape : le pcb :

Ce que vous voyez là c’est ma cuisine … on a vu mieux comme atelier gravure …

Le typon a été réalisé sous Ares, puis transféré sur la plaque de cuivre au moyen d’une imprimante laser et de la célèbre méthode du "transfert de toner".
Pour la gravure en elle même je suis resté sur la solution "classique" du perchlorure de fer.

Le pcb âpres 8 minutes de gravure à ~38°C, à ce stade il est prêt à être rincé.

Le pcb rincé avec le toner encore présent sur les pistes de cuivre.

–

3iéme étape : l’assemblage :

Vous remarquerez le magnifique effet miroir … c’est pas grave pour ce typon mais la prochaine fois je ferais plus attention.

Petite particularité de mon câble USB OTG, celui ci est destiné à être "pluggé" dans une carte arduino !
Les cartes arduino possédant un connecteur USB-B mâle (ou femelle je me rappelle jamais …) j’ai donc massacré deux câbles usb-a / usb-b pour faire mon câblage.

Voila ce que ça donne une fois le câble (la partie usb-b) soudé sur le pcb, avec en plus un petit strap pour tenir le câble solidement en place.

–

Les câbles OTG, trucs et astuces :

Quand j’ai voulu tester mon câble OTG pour la première fois rien ne c’est passé … rien de chez rien, quedal, niét, nada !

J’avais pourtant fait le test avec une clef usb (formaté en FAT) et l’application "usb otg helper" pour android, censée fonctionner parfaitement … mais sans succès.

L’astuce est vraiment conne, mais une fois qu’on la connait tout marche tout de suite beaucoup mieux !

Vous voyez la broche "sense" (aussi appelait "ID") ?
Si elle est flottante c’est un câble normal, si elle est reliée à GND c’est un câble OTG.

La différence est mince mais le résultat totalement différent !

On voit clairement les deux fils GND et ID reliés ensemble sur cette photo.

Et bien sûr une fois les deux broches reliées tout marche parfaitement :

Pour les curieux ceci est ma clef usb "d’installation linux", avec mon wallpaper, mon script d’installation apt-get, un log u-boot (qui sort de je ne sais où) et une image openWRT que je garde de côté pour mon eeepc.

À noter aussi que le galaxy S3 n’est pas à moi mais à l’IUT … je n’ai pas le budget pour m’acheter un téléphone à +450€ (j’ai un HTC HD2 flashé sous android 4.1 ça me suffit largement ).

–

Fabrication du dock :

Histoire de faire un truc "solide" j’ai collé le connecteur avec de la résine epoxy (tube avec deux composants à mélanger).
Mes essais avec de la colle cyanoacrylate n’ont pas été concluant, c’était trop cassant.

Vous remarquerez le fait que le strap qui maintient le câble usb est volontairement fondu sur la gaine du câble pour éviter que celui ci ne bouge dans le futur.

–

4iéme étape : soudure des fils :

Tous d’abord les fils ont été coupés à la bonne longueur :

Puis avec une bonne "lampe loupe" et un fer à souder bien chaud ça donne ça :

Remarque : oui j’ai complétement raté le centrage de mon perçage sur la 1er plaque …
Remarque 2 : les fils sont émaillés donc aucun risque de court-circuit

–

Fignolages :

La colle chaude c’est la vie ! Je le répéterai jamais assez : bénis soit l’inventeur de la colle chaude !

–

Résultat final :

(le deuxième câble est identique au premier )

Je peux vous garantir que vous trouverez jamais un connecteur micro USB OTG aussi DIY que celui là
Le cout total s’élève à 3.5€ (pcb et colle exclut) par dock, soit pas grand chose au final.

Bon bidouillage et bon WE à tous

Classé dans:arduino, programmation, projet Tagged: diy, madeinfr

Pour ceux qui aurait raté les épisodes précédents, Bleuette est un robot hexapode (3 paires de pattes) entièrement libre (logiciel, plan, etc...) réalisable avec une imprimante 3D ou dans une moindre mesure et de la patience en découpant les pièces dans du Plexiglas.

Concernant la carte fille, je viens d'arriver au bout de son routage et je vais lancer sa fabrication d'ici peu, les caractéristiques de cette carte sont les suivantes :

• Génération de la tension de fonctionnement pour l'Arduino
• Pilotage des 12 servos de pattes + 2 supplémentaires
• Contrôle de la tension de la batterie
• Surveillance du courant consommé par les servos

Voici le schéma de principe (cliquez pour agrandir) :

Et le PCB (cliquez pour agrandir) :

Tous les documents nécessaires à sa fabrication sont sur GitHub par ici https://github.com/hugokernel/Bleuette.

Concernant la mécanique, c'est presque prêt, encore quelques pièces à imprimer et je pourrai passer à l'assemblage final !

5 semaines après la commande, un transporteur m’amène un lourd carton (10kg) venu des Pays Bas : ça y est, j’ai reçu mon UltiMaker.

Légèrement en avance d’ailleurs car ils m’avaient annoncé 6 semaines de délai, je crois avoir été chanceux car je n’avais pas commandé de bobine de plastique supplémentaire et une semaine auparavant, un courriel de Ultimaker annonçait qu’il était en rupture de certain coloris de PLA et proposait, pour ceux en ayant commandé en plus, de remplir un formulaire, afin de choisir des couleurs de remplacement pour éviter d’attendre trop longtemps, du coup, j'ai dû être traiter légèrement en avance...

Carton ouvert, découverte du contenu :

Tout est bien rangés, chaque sachet possède un autocollant avec sa référence et son nom, tout est dans du papier bulle...
Tout, hmmm, presque tout, jusqu’à ce que j’arrive au fond du carton, là, sont posés les plaques de bois (du bouleau, très solide et rigide) découpés au laser, ces dernières sont enfoncées toute au même niveau, conséquences d’un impact extérieur que je n’avais pas vu au premier abord sur le carton mais qui est bien visible... Les plaques étant emballées elles aussi dans du papier bulle mais directement en contact avec le carton trop petit, une chute, un envoi de livreur un peu brutal et paf le bouleau, comme vous le voyez sur les photos, c’est assez localisé, ça n’empêchera pas beaucoup le montage...

La blessure la plus importante est celle-ci oû le choc à explosé le bois et bouché les trous permettant la fixation des planches entre elle...

Je réquisitionne une grande table, étale le contenu du carton sur celle-ci et c’est parti...

Aucun plan papier fourni, c’est pas plus mal, tout est disponible en ligne, en anglais, illustré de photos, ils indiquent 6 à 20h de travail...

Première étape, le caisson avec ces foutus passe cable qui m'ont fait tourné en bourrique...

Tout se monte sans encombre jusqu’au drame :

Il se sont trompés en me livrant une poulie avec le mauvais diamètre interne (les 2 de droites devraient être identiques avec un diamètre inférieur), arggg, la casse durant le transport, une poulie inutilisable, je me voyais mal attendre...
Par chance, j’avais une entretoise dont le diamère externe correspond au diamètre interne de la poulie, un petit usinage pour que son diamètre interne s’adapte à l’axe du moteur et voilà... ouf !!

L’assemblage de la tête d’extrusion est plutôt délicat mais se fait sans trop de problème.

Le montage s’est poursuivi jusqu’à la plateforme de l’axe Z, il faut faire rentrer en force des roulements linéaires dans des planches de bois pour former un sandwich, les jeux sont plus que limite et j’ai dû m’y prendre à plusieurs fois afin d’avoir quelque chose d’à peu près correct, comprenez : quelque chose de droit.
Heureusement, ils ont prévus le coup et le jeu est rattrapable par un système de réglage à vis / ressort...

Enfin, vient le moment de relier électriquement tous les éléments, fin de course, moteur, élément de chauffe, puis l'allumage :

Tout à fonctionné du premier coup sauf une erreur sur la carte qui indique la connection pour le capteur de fin de course droit alors que c’est le gauche, une inversion et tout roule...

Maintenant, le branchement à un ordinateur, est-ce plug and play ?
Oui, Ultimaker reconnu immédiatement (c’est une carte Arduino pour l’intelligence de la bête, j'avais déjà installer les pilote FTDI), j’ai pu envoyer des ordres pour piloter les moteur X, Y, Z, c’est très réactif et la vitesse impressionnante...

Au moment au j'écris ces lignes, je n'ai pas encore pu tester à fond l'animal donc, je n'aurai pas de retour à faire sur son utilisation, hormis le souci dans le transport (prévoir un carton plus grand) et l'erreur de poulie (la personne du contrôle ne devait pas être réveillée), le kit est de bonne qualité et je comprends mieux le prix, c'est vraiment bien étudié au niveau de l'assemblage, on retrouve des pièces en métal de très grande précision, la carte électronique est très bien réalisé, la partie puissance est totalement ventilé, bref, c'est du sérieux...