Skyduino:~#
Articles
arduino, Corrigé, programmation, projet

[DIY + arduino] Alimentation d’atelier DIY – partie 2

Posté par ⋅ ⋅ 37 Commentaires
Classé dans  , ,

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 :
https://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 :

P1060038

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 :

diy_alim_voltage

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 :

diy_alim_current

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 :

diy_alim_signals

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 :

diy_alim_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 :

diy_alim_leds

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 :

diy_alim_button

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 :

diy_alim_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 :

diy_alim_temp

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 :

P1060041

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

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

P1060043

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

P1060044

La base de la « carte mère » :

P1060046

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

P1060049

(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 :

P1060051

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 :

P1060080

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

P1060083

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.

P1060085

P1060087

(la colle chaude c’est la vie !)

P1060089

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.

P1060092

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

P1060094

Annexe, le capteur de température :

P1060126

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 :

P1060096

Test des leds :

P1060101

Test de l’écran lcd :

P1060102

Test des capteurs de courant :

P1060107

—

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 😉

Discussion

37 réflexions sur “[DIY + arduino] Alimentation d’atelier DIY – partie 2”

  1. excellent, comme d’habitude et comme tous tes articles que je garde précieusement !

    Publié par sscapa | 28 février 2013, 19 h 04 min

  2. Premier article sur la modification d’une alim de PC aussi poussé ! +1

    Mais personnellement, j’aurais mis la sonde de température sur ton radiateur de ton alimentation qui sont, pour moi, plus à même de refléter la surchauffe de ton alim en cas de défaillance… Parce que tes capteurs de courant ne doivent pas beaucoup chauffer à mon avis (je n’ai pas lu la doc)… Qu’en penses-tu ?

    Publié par titi@ | 28 février 2013, 20 h 49 min

    • Il y a déjà un capteur de température sur l’alimentation elle même.
      Et les capteurs de courant chaufferons bien plus vite que l’alim en cas de problème 😉

      Publié par skywodd | 1 mars 2013, 19 h 38 min

  3. Sympa!
    Je m’attendais à voir apparaître des limitateurs de courant… peut-être dans la V3? (celle où apparaîtra le easter egg)
    Pour ton boîtier, il ne te reste plus qu’à monter une imprimante 3D 🙂

    Publié par sebecam2000 | 1 mars 2013, 10 h 00 min

  4. quel logiciel est-ce que tu utilises pour la simulation de tes circuits?

    Publié par sebecam2000 | 1 mars 2013, 13 h 55 min

  5. Bonsoir, question bête, où est ce que tu trouve des plaques, celle de la « carte mère » ?
    Je n’ai pas du chercher aux bons endroits, c’est le format parfait pour l’arduino mini.

    Publié par blakk-olifant (@blakkolifant) | 1 mars 2013, 22 h 46 min

  6. J’ai lu à différent endroit qu’une résistance de 5ohm 10W était nécessaire sur le +5V de l’alim pour stabiliser la tension du +12V et pour éviter que l’alim tourne à vide ce qui n’est apparemment pas bon.
    Qu’en penses-tu ?
    Une telle résistance sera t-elle nécessaire dans ton projet ?

    source :
    http://jumperone.com/2011/06/atx-power-supply-tutorial/
    http://fire-diy.servhome.org/article-13.html
    http://www.revopowaaa.com/t3934-faire-son-alim-12v-avec-une-alim-pc-atx-at

    Publié par BugsByte | 4 avril 2013, 22 h 07 min

  7. salut cher camarade ,

    mon projet est une ampérmétre numérique a base de PIC16f877 ,

    je veut utilisé le capteur ACS712 jai bien lu le datasheet….

    je n’arrive pas a trouvé un raisonnemnt logic pour ecrire un programme sur mikroC qu me permet de donner l’ampérage du secteur …

    Publié par lamine | 23 avril 2013, 14 h 45 min

  8. merci pour ça mon ami normalement mon probléme et résolue par ce que je n’est pas su trouvé une relation qui tiendra compte de loffset 2.5V image de 0A , et la je crois que c bien expliqué merci (pr ma version c 100mv/a),

    mnt je v essai de voir avec mikroc merci bcp

    Publié par lamine | 24 avril 2013, 1 h 57 min

  9. salut cher ami ,
    jai enfin écrit le programme sur MikroC la simulation sur isis marche super bien , mais je voulais savoir une chose que je n’arrive pas a saisir , d’après le datasheet le capteur pressente plusieurs type de montage selon le besoin , pour mon cas je veut juste mesurer l’ampérage des secteurs max 10 A , est ce que je doit suivre un des schéma ou il suffit seulement de connecter le capteur avec les capacités de filtrage » » » » »comme c indiqué dans la 1er page du data » » » pour son bon fonctionnement , ensuite raccordé deux sondes sur IP+ et IP- pour faire la mesure …

    Publié par lamine | 27 avril 2013, 14 h 27 min

  10. ici c mon programme il marche super bien , par contre pour l’affichage je le veut sur deux chiffres aprés la virgule est ce que quelqu’un a une idée !

    @ skywodd : si j’utilise ce schema est ce que je dois changé mon programme ???

    //program

    // LCD module connections
    sbit LCD_RS at RB2_bit;
    sbit LCD_EN at RB3_bit;
    sbit LCD_D4 at RB4_bit;
    sbit LCD_D5 at RB5_bit;
    sbit LCD_D6 at RB6_bit;
    sbit LCD_D7 at RB7_bit;

    sbit LCD_RS_Direction at TRISB2_bit;
    sbit LCD_EN_Direction at TRISB3_bit;
    sbit LCD_D4_Direction at TRISB4_bit;
    sbit LCD_D5_Direction at TRISB5_bit;
    sbit LCD_D6_Direction at TRISB6_bit;
    sbit LCD_D7_Direction at TRISB7_bit;

    unsigned amper_unit;

    short amper_out ;
    char res[5];

    void main(){

    TRISA = 0xFF;
    TRISB = 0 ;

    Lcd_Init();

    Lcd_Cmd(_LCD_CLEAR);
    Lcd_Cmd(_LCD_CURSOR_OFF);
    Lcd_Out(1,4, »AMPERMETRE »);

    Lcd_Out(2,1, »amp : « );

    while (1) {
    amper_unit = ADC_read(0);
    amper_out = ((0.049*amper_unit)-25) ;
    Delay_ms(1);
    shortToStr(amper_out,res);
    Lcd_Out(2,10,res);
    Lcd_Chr_Cp(‘A’);

    }
    }

    Publié par lamine | 28 avril 2013, 22 h 46 min

  11. Merci beaucoup pour cet article, c’est le premier (deuxième j’ai la la partie 1) de tes articles que je lis, c’est vraiment sympa !

    Publié par Viproz | 17 Mai 2013, 18 h 17 min

  12. Salut, et merci pour ce tuto, cependant, je n’ai pas tout à fait compris votre câblage au niveau des capteurs de courants, auriez-vous de plus amples informations à fournir ? (votre schéma : ils sont câblés en parallèle avec seulement la sortie pour l’info allant vers l’arduino qui diffère pour chacun, vous dites dans votre vidéo : les repiquer sur le pont résistif … il n’y a pas les possibles 30A qui doivent traverser ce capteur, pourquoi le repiquer sur le pont servant à l’arduino pour mesurer la tension ?, et le fait qu’il n’y est qu’un seul câble qui relie le bornier du capteur ne m’aide pas)
    merci

    Publié par Pro_inf | 21 avril 2014, 10 h 34 min

    • ps : ce tuto était plaisant à lire il y a 3 jours, que je m’en suis fait un film (remplacer* vidéo par photo bien entendu), le passage suspect : « 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. »
      merci

      Publié par Pro_inf | 21 avril 2014, 10 h 38 min

    • Moi aussi je n’ai pas réussi à mesurer le courant avec ces capteurs.
      Si vous trouvez la solution, je suis preneur.

      Publié par BugsByte | 21 avril 2014, 10 h 38 min

      • Le capteur de courant se met en série avec la charge et le capteur de tension en parallèle.
        Vu que les masses des deux circuits (alim et contrôleur) sont communes en piquant un câble dans un des borniers j’ai la tension dans la branche du circuit et le courant via la boucle alim-capteur-charge-masse.

        Publié par skywodd | 21 avril 2014, 15 h 04 min

    • Ok, je pense avoir saisi, merci de votre réponse

      ps : Est-il possible d’obtenir votre code final, afin que je puisse m’inspirer de certaines fonctionnalités ?
      merci

      Publié par Pro_inf | 21 avril 2014, 15 h 14 min

      • C’est con à dire mais j’ai jamais eu le temps de faire le code final …
        J’avais prévu de faire un circuit complet avec les capteurs intégrés sur une même carte mais à cause de divers problème de temps libre je n’ai jamais pu finir le schéma.

        Publié par skywodd | 21 avril 2014, 15 h 19 min

      • ok je ferai sans dans ce cas =)

        Je compte faire à peu près comme vous mis à part que je remplacerai l’écran lcd par un oled, et ajouterai 2 petits relais (NO) pour mes 2 résistances de charge (2 rails obligent) qui se déclencheront après la stabilisation des tensions (pas sûr, je vais peut être les fermer direct au dem) et qui se couperont lorsqu’une forte intensité sera tirée, ce qui évitera de les faire chauffer pour rien.

        merci en attendant

        Publié par Pro_inf | 21 avril 2014, 15 h 46 min

  13. Bonjour,
    Super articles (partie 1 et 2), que j’avais lu il y a quelques temps, et je me demandais si il y aura une partie 3 en prévision ou pas car je suis tombé tout à fait par hasard sur cet article (https://skyduino.wordpress.com/2013/05/24/des-news-et-plein-de-bonnes-choses/) qui date d’environ un an, qui mentionne une éventuelle 3éme partie pour ce projet (fort intéressant soit dit en passant) et comme je ne connais pas grand chose en programmation j’avais bon espoir pour le code final de ce super projet.
    Sinon un grand merci pour tout ce que tu nous apporte et le temps passé à nous instruire.
    En espérant que tu trouve le temps pour finaliser ce projet d’alimentation DIY, je te souhaite une bonne continuation.
    Cdlt,
    Seb.

    Publié par Seb DIEZ | 25 avril 2014, 10 h 49 min

  14. Bon, et bien tant pis

    Publié par Seb DIEZ | 24 août 2014, 7 h 42 min

    • On est beaucoup à souhaiter cette 3ème partie mais notre ami, Skywood, a d’autres priorités.
      On ne peut pas lui en vouloir : il fait ça sur son temps libre.

      Si quelqu’un a un lien pour un projet équivalent aussi complet, je suis preneur.

      Personnellement, je n’arrive pas à mettre en oeuvre les capteurs de courant.
      Si quelqu’un a des infos sur ce sujet qu’il n’hésite pas.

      Bidouillez bien !

      Publié par BugsByte | 25 août 2014, 9 h 01 min

      • Je prévois de reprendre le projet mais en le remettant au gout du jour (tension variable, sécurité intégrée, afficheur graphique, etc.).
        L’idée finale c’est de faire une carte toute prête ou à monter soi même pour transformer une alimentation ATX en alimentation d’atelier.
        Mais ça va prendre pas mal de temps avant d’être au point (je veux une qualité « produit fini » sur ce projet).

        Publié par Skywodd | 3 septembre 2014, 19 h 20 min

      • Génial !
        J’attends avec impatience ce nouveau projet de remplacement.

        Merci d’avance Skywood.

        Publié par BugsByte | 4 septembre 2014, 9 h 44 min

      • c’est cool, moi aussi j’attends avec impatience !

        Publié par Pro_inf | 4 septembre 2014, 12 h 18 min

  15. Salut, j’ai une petite question quant au bouton power pour l’alim :

    pour l’allumer, j’ai pensé à initialiser le pin en entrée et lire pour détecter le bp,
    mais une fois appuyer, il faut passer le pin en sortie et en high pour faire l’auto-maintient

    comment faire dans ce cas pour l’arrêt, pour détecter le bp alors que le pin est utilisé en sortie ?
    merci

    Publié par Pro_inf | 13 décembre 2014, 22 h 57 min

Skyduino devient Carnet du Maker

Le site Carnet du Maker remplace désormais le blog Skyduino pour tout ce qui touche à l'Arduino, l'informatique et au DIY.