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 
) à l’aide de l’utilitaire X-CTU.
