Répondre à la discussion
Page 1 sur 2 1 DernièreDernière
Affichage des résultats 1 à 30 sur 48

[Projet] Rendre intelligent un chargeur de batteries au plomb




  1. #1
    Yvan_Delaserge

    [Projet] Rendre intelligent un chargeur de batteries au plomb

    Bonsoir,

    Mon chargeur de batteries de voiture est tombé en panne. Il se compose d'une alimentation à découpage et d'une platine à microcontrôleur permettant d'optimiser le processus de charge.

    Après quelques mesures, je constate que l'alimentation fonctionne bien, mais que la platine à microcontrôleur ne contrôle plus l'alimentation!
    Je voudrais donc essayer de remplacer la platine à microcontrôleur par un Arduino.

    Dans le montage original, la tension fournie par l'alimentation à découpage est contrôlée en agissant sur la diode de l'optocoupleur. Cette dernière est alimentée par la tension secondaire de l'alim à découpage et la platine à microcontrôleur module le courant traversant la diode. Le montage est celui-ci:

    INTERFAR.jpg

    V1 représente la tension de sortie de l'alim (environ 12 V)
    D1 représente la LED de l'optocoupleur
    Pour interfacer mon Arduino avec l'alim à découpage je compte utiliser ce montage. V2 représente la sortie de l'Arduino, modulée en PWM à 450 Hz. ( L'alim à découpage hache quant à elle, à 50 KHz)

    La courbe rouge au-dessus du schéma représente le courant à travers D1.

    Lors de la mise en route de l'alim, on ne doit pas avoir de courant dans la diode, autrement l'alim hoquette, sans arriver à se mettre en route. Dans le montage réel, on a une Zener de 15 V entre la cathode de D et la masse, pour que lors de la mise en route, la tension secondaire de l'alim ne dépasse jamais cette valeur, même en attendant la mise en route de l'Arduino, qui sera alimenté par la sortie de l'alim à découpage. Je n'ai pas représenté cette Zener sur le schéma LTspice.

    Ma question concerne le circuit à utiliser comme interface entre la sortie PWM de l'Arduino et la diode de l'optocoupleur. J'aimerais que le 450 Hz du PWM de l'Arduino ne se retrouve pas à la sortie de l'alim, c'est pourquoi j'ai utilisé un filtre passe-bas, mais la mise au point (empirique) de celui-ci a été plutôt laborieuse.

    Avec ce filtre passe-bas à 5 pôles (!) ça devrait donc marchotter, mais est-ce que l'un d'entre vous aurait l'idée de quelque chose de plus élégant, plus pro, et fonctionnant mieux? Je suis étonné qu'il faille un filtre à 5 pôles. Est-ce que je suis passé à côté de quelque chose?

    Merci d'avance,

    Bien cordialement,

    Yvan

    -----

    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  2. Publicité
  3. #2
    DAUDET78

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par Yvan_Delaserge Voir le message
    Avec ce filtre passe-bas à 5 pôles (!)
    Moi, je vois deux filtres passe bas d'ordre 1 en série .
    L'age n'est pas un handicap .... Encore faut-il arriver jusque là pour le constater !

  4. #3
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Hello Daudet. Je voulais dire qu'un filtre passe-bas à 5 composants me paraissait un peu trop compliqué.

    En fait, après avoir encore un peu réfléchi au problème, je crois que je vais faire comme ça :

    INTERFR1.jpg

    Avec un rapport cyclique de 50 % du signal PWM de l'Arduino, la diode de l'optocoupleur reçoit 13 mA, avec peu de ripple.

    Et avec un rapport cyclique de 95%, 24 mA.

    INTERFR2.jpg

    Et avec un rapport cyclique faible ( 1%) on a un courant nul.

    Le soft de l'Arduino devra commander le rapport cyclique " à l'envers ", c'est-à-dire que plus le rapport cyclique du PWM sera élevé, plus la tension du secondaire de l'alim sera basse.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)


  5. #4
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Bonjour,

    1. Avec ce schéma, le courant dans la led est fortement dépendant du gain du transistor (il lui est quasiment proportionnel). C'est généralement très mal vu : les gains d'une série de NPN portant la même référence ayant une très grande dispersion, la mise au point de la boucle fermée est plus complexe. Câbler le NPN en générateur de courant (tension de base fixée à la tension moyenne de sortie du filtre + résistance d'émetteur idoine) me semble plus raisonnable.
    2. Ton filtre doit apporter une certaine atténuation à la fréquence du PWM (et à ses harmoniques). Il y a pour cela plusieurs solutions techniques, puisque deux degrés de liberté sont à ta disposition : la fréquence de coupure et l'ordre du filtre. Le choix est à faire (notamment) en fonction des performances dynamiques demandées. Dans le doute, je conseillerais plutôt un filtre d'ordre 1 à faible fréquence de coupure : pour peu que le reste du système soit stable en boucle ouverte (i.e. sans feed-back), tu minimises le risque d'ajouter une instabilité en limitant à 90° le déplacement de phase.
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  6. #5
    zibuth27

    Re : Interface entre Arduino et alimentation à découpage

    hello,

    Il n'en reste pas moins qu'on essaye de passer une fonction vaguement linéaire à l'optocoupleur, lequel l'accepte rarement = quel est son type ?

    Il faudrait aussi savoir comment la sortie de l'opto commande la charge de ta batterie !


    saluts

  7. A voir en vidéo sur Futura
  8. #6
    DAUDET78

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par zibuth27 Voir le message
    une fonction vaguement linéaire à l'optocoupleur, lequel l'accepte rarement
    Sa fonction de réponse est corrigée par la contreréaction. C'est comme ça que fonctionnent les alimentations ATX
    L'age n'est pas un handicap .... Encore faut-il arriver jusque là pour le constater !

  9. #7
    zibuth27

    Re : Interface entre Arduino et alimentation à découpage

    hello,

    c'est bien la question ici : comment est relié l'opto? et est-ce en mode linéaire ou digital, quel est la contre-réaction s'il y en a?

  10. Publicité
  11. #8
    DAUDET78

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par zibuth27 Voir le message
    quel est la contre-réaction s'il y en a?
    Il doit probablement mesurer les tension/courant de sortie, qui agit sur le PWM. De toutes les façons, utiliser un µC pour faire ce travail, je ne suis pas d'accord. N'importe quel circuit de contrôle d'alimentation à découpage fait ça cent fois mieux !
    Le µC ne sert qu'a faire la programmation du circuit pour gérer les différentes phases dans le cas d'un chargeur intelligent
    L'age n'est pas un handicap .... Encore faut-il arriver jusque là pour le constater !

  12. #9
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Salut les gars et merci de vos contributions, toujours d'excellent niveau! C'est sympa de pouvoir compter sur vous!

    A l'origine, le chargeur fonctionnait de la manière suivante:



    1) Il contrôle que le branchement soit fait dans le bon sens. Si ce n'est pas le cas, il allume une LED rouge.

    2) Il mesure la tension de la batterie. Si elle est comprise entre 7,5 et 10,5 V, il en déduit qu'elle est complètement déchargée, voire sulfatée . Il essaie de la régénérer en lui appliquant des impulsions de 800 mA, et il mesure entre chaque série d'impulsions si la tension de la batterie a augmenté. Si ce n'est pas le cas, il arrête au bout de quelques essais.

    3) S'il réussit à faire augmenter la tension jusqu'à 10,5 V, il en conclut que la batterie est récupérable et il la charge à un courant constant de 3,8 A.
    Au cas où au départ la tension de la batterie à recharger est entre 10,5 et 12,8 V, il fait pareil: Il la recharge à un courant constant de 3,8 A.

    4) Lorsque la tension qu'il doit appliquer à la batterie pour la recharger à un courant constant de 3,8 A, atteint 12,8 V, il réduit le courant constant à 2 A.

    5) Lorsque la tension qu'il doit appliquer à la batterie pour la recharger à un courant constant de 2 A, atteint 14,1 V, il réduit le courant constant à 800 mA.

    6) Lorsque la tension qu'il doit appliquer à la batterie pour la recharger à un courant constant de 800 mA, atteint 14,4 V, Il en déduit que la batterie est chargée à 100 %. Donc il réduit le courant constant à 100 mA. ( = trickle charge).

    7) Malgré la trickle charge, la batterie se décharge quand même. De temps en temps, il arrête la trickle charge et il mesure la tension de la batterie. Si elle est inférieure à 12,8 V, il retourne au stade 3. Si elle est supérieure ou égale à 12,8 V, il retourne au stade 4.

    Tout ça devrait pouvoir se programmer ( avec l'Arduino) sous la forme d'une machine à états. Et il est toujours possible de prendre le métro en marche: A la mise en route, on mesure la tension de la batterie et on se place dans le stade approprié:

    Branchement à l'envers ou tension < 7,5 V ou tension >14,7 V : stade 1. On allume la led rouge.
    7,5 V à 10,5 V: Stade 2
    10,5 à 12,8: Stade 3
    12,8 à 14,7: Stade 4.


    Le branchement de l'optocoupleur est le suivant:

    OPTOCOUP.gif

    Si le microcontrôleur envoie une tension de 12 V à l'optocoupleur, la tension de sortie de l'alim est de 12 V.

    Le filtre passe-bas que je projette de construire ne servirait qu'à éliminer un peu la composante 450 KHz du PWM fourni par l'Arduino. Mais s'il en reste un peu, ce n'est pas très grave.

    En résumé,
    1) La tension de sortie de l'alim doit être constamment adaptée de manière à obtenir le courant de charge constant, déterminé par le soft selon l'état de la batterie.

    2) Le programme doit constamment ( à chaque boucle) mesurer la tension aux bornes de la batterie ainsi que le courant ( le circuit comporte une résistance en série avec la connexion "moins" vers la batterie).

    3) La tension produite par l'alim est contrôlée par la tension variable appliquée à la diode de l'optocoupleur. On va la produire par une sortie PWM de l'Arduino, lissée par le filtre-passe-bas projeté.
    Dernière modification par Antoane ; 13/10/2015 à 10h09. Motif: Réparation PJ
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  13. #10
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par Antoane Voir le message
    Bonjour,

    1. Avec ce schéma, le courant dans la led est fortement dépendant du gain du transistor (il lui est quasiment proportionnel). C'est généralement très mal vu : les gains d'une série de NPN portant la même référence ayant une très grande dispersion, la mise au point de la boucle fermée est plus complexe. Câbler le NPN en générateur de courant (tension de base fixée à la tension moyenne de sortie du filtre + résistance d'émetteur idoine) me semble plus raisonnable.
    2. Ton filtre doit apporter une certaine atténuation à la fréquence du PWM (et à ses harmoniques). Il y a pour cela plusieurs solutions techniques, puisque deux degrés de liberté sont à ta disposition : la fréquence de coupure et l'ordre du filtre. Le choix est à faire (notamment) en fonction des performances dynamiques demandées. Dans le doute, je conseillerais plutôt un filtre d'ordre 1 à faible fréquence de coupure : pour peu que le reste du système soit stable en boucle ouverte (i.e. sans feed-back), tu minimises le risque d'ajouter une instabilité en limitant à 90° le déplacement de phase.
    OK Antoane, merci pour ce commentaire.

    Il suffirait donc d'insérer une résistance dans l'émetteur comme ceci?

    FPBGENCO.jpg

    J'ai essayé de découpler la résistance d'émetteur avec un 10 uF, mais j'avais davantage de ripple. Je l'ai donc supprimé.

    J'ai pris une valeur de résistance d'émetteur pas trop élevée pour ne pas trop limiter le courant à travers la led de l'optocoupleur.

    En effet, lors des tests de l'alim, j'ai observé qu'en essayant de mettre la cathode de la led à la masse, l'alim fournit un peu moins de 15 V. Et le chargeur doit pouvoir produire au moins 14,4 V pour les phases 5 et 6.

    Dans cette application de chargeur de batterie, on ne va pas avoir de variations subites de la tension que doit fournir l'alim, sauf à la mise en route. Les exigences de performances dynamiques ne vont pas être élevées.

    En l'absence de PWM (si l'Arduino ne se met pas tout de suite en route), la tension de sortie de l'alim ne pourra pas dépasser 15 V, car on a une Zener de cette valeur entre la cathode de la led de l'optocoupleur et la masse.

    Le filtre passe-bas en T (= d'ordre 1?) met une vingtaine de millisecondes avant de commencer à appliquer le signal PWM lissé à l'optocoupleur. Donc l'Arduino aura tout le temps de se mettre en route.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  14. #11
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Je joins le fichier asc du circuit
    Fichiers attachés Fichiers attachés
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  15. #12
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Bonsoir,

    C'est donc le µC qui gère la régulation. Il gère notamment la non-linéarité de la caractéristique de l'opto.
    Le résultat sera assez pitoyable mais, comme tu le notes, c'est ici assez peu critique.

    Citation Envoyé par Yvan_Delaserge Voir le message
    Il suffirait donc d'insérer une résistance dans l'émetteur comme ceci?

    Pièce jointe 294719
    C'est le principe. Q1 travaille alors en émetteur suiveur (collecteur commun) : la tension Vb appliquée sur sa base se retrouve, à un Vbe près, sur son émetteur. Négligeant le courant de base devant celui de collecteur, et supposant que rien d'autre ne limite le courant de collecteur, le courant dans la led vaut alors:
    (Vb-Vbe)/R4~Vb/R4. C'est quasi-linéaire.

    R3 et R2 sont traversée par le courant de base de Q1, on a donc : Vb=<Vp> - (R2+R3)*Ib, avec <Vp> la valeur moyenne du signal PWM en sortie du µC et Ib le courant de base de Q1.

    Conclusions :
    - tu peux prendre R1=0;
    - Il faut prendre R2=0 de manière à avoir Vb aussi proche que possible de <Vp>, et ainsi maximiser la linéarité.
    - Sauf si tu es limité par le point suivant, il faut choisir R4 de telle manière que la plage de variation de <Vp> soit maximisée : R4=(<Vp>max -Vf)/Iled_max (a priori, <Vp>max=V2=5V) ;
    - ce montage est valide si V1 > R4*Iled+Vce_min+Vf, avec Vf la tension de seuil de la diode (~1,2V), Vce_min la tension de Vce minimale pour avoir un bon fonctionnement du NPN (~1V). En première approximation, cela donne un V2>6 ou 7V. Donc c'est ok. On pourrait accepter un V2 plus faible en remarquant que R4*Iled et V2 sont liés, mais ce n'est pas nécessaire ici.

    Pour la limitation à l'allumage : tu peux ajouter une zener de 10V (Vmax-Vcc=15-5) entre V2 et la base de Q1. Y mettre une petite résistance en série (~qq kOhm) ne ferait pas de mal.


    J'ai essayé de découpler la résistance d'émetteur avec un 10 uF, mais j'avais davantage de ripple. Je l'ai donc supprimé.
    Normal : en fixant le potentiel sur l'émetteur, toute variation de la tension sur la base se retrouve directement sur la jonction B-E du NPN. Etant donnée sa caractéristique en exponentielle...
    C'est un ampli en classe A, sans résistance en série avec la capa d'émetteur.
    https://fr.wikipedia.org/wiki/Classe...nique#Classe_A

    Le filtre passe-bas en T (= d'ordre 1?)
    Oui.
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  16. #13
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Superbe, merci Antoane.

    Voici la simu avec les modifications. ça fonctionne bien.

    INTERFPB.gif
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  17. #14
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Bonjour,

    Tu peux aussi forcer la charge au démarrage en mettant le "pied" du condensateur C1 non pas à la masse mais au Vcc.

    Pour assurer que la tension de sortie montera rapidement (quitte à ce qu'il y ai dépassement) dès les premiers coups de PWM, tu peux câbler une diode en série avec un condensateur C0 en parallèle de la résistance R3.
    Ainsi, dès le premier front montant du PWM, la tension de sortie passera à Vcc*1/C1/(1/C1+1/C0).
    Pis une grosse résistance (i.e. >> R3) en parallèle de C0 pour le décharger à la mise hors-tension.
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  18. #15
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Hello Antoane.

    En câblant le condensateur du fpb vers le + de l'alim, je ne constate pas de changement.

    INTERFPB.jpg

    Avec la diode et le condensateur en parallèle avec R3, en effet, le courant à travers la LED augmente dès la mise en route.

    INTERFP2.jpg

    Lors du démarrage, il faut que le courant dans la LED de l'optocoupleur soit nul, de cette manière, le contrôleur ( UC 3844 ) n'est pas freiné et l'alimentation de ce dernier par le circuit bootstrap peut se faire normalement. Il y a un garde-fou qui assure que la tension de sortie de l'alim ne puisse dépasser 15 V: c'est la zener entre la cathode de la LED et la masse. Elle fait circuler du courant dans la LED et l'alim se stabilise vers 15 V.

    Lorsque le signal PWM de l'Arduino intervient, c'est pour faire augmenter le courant à travers la LED, donc pour freiner le UC 3844 et réduire la tension de sortie de l'alim, selon les besoins.

    Il est donc nécessaire pour que tout se passe bien, d'avoir un courant nul dans la diode de l'optocoupleur pendant quelques millisecondes après le démarrage. Si on a du courant dans la LED de l'optocoupleur, l'alim hoquette et ne se met pas en route.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  19. #16
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Je m'aperçois que l'image du message #9 a disparu. La voici de nouveau.
    CHARGEUR.gif
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  20. #17
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par Yvan_Delaserge Voir le message
    En câblant le condensateur du fpb vers le + de l'alim, je ne constate pas de changement.
    => .tran .2 startup

    Sans la diode, le "pied" de C1 est à relier au +5V, sans quoi tu risques de brièvement dépasser le courant dans la led.
    Dans tous les cas, relier le "pied" de C1 au +5V permet d'éviter de transmettre le bruit du 12V à la led. D'un autre côté, en couplant ainsi le 12V avec la base du NPN, tu ajoutes une sorte de stabilisation... Je ne compterais, personnellement, pas dessus.


    Lors du démarrage, il faut que le courant dans la LED de l'optocoupleur soit nul, de cette manière, le contrôleur ( UC 3844 ) n'est pas freiné et l'alimentation de ce dernier par le circuit bootstrap peut se faire normalement. Il y a un garde-fou qui assure que la tension de sortie de l'alim ne puisse dépasser 15 V: c'est la zener entre la cathode de la LED et la masse. Elle fait circuler du courant dans la LED et l'alim se stabilise vers 15 V.

    Lorsque le signal PWM de l'Arduino intervient, c'est pour faire augmenter le courant à travers la LED, donc pour freiner le UC 3844 et réduire la tension de sortie de l'alim, selon les besoins.

    Il est donc nécessaire pour que tout se passe bien, d'avoir un courant nul dans la diode de l'optocoupleur pendant quelques millisecondes après le démarrage. Si on a du courant dans la LED de l'optocoupleur, l'alim hoquette et ne se met pas en route.
    Ce que je propose est donc inutile. Joli, mais inutile

    Je m'aperçois que l'image du message #9 a disparu. La voici de nouveau.
    Désolé, je pensais l'avoir réparée. Moi, je la voie
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  21. #18
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Hello de nouveau.

    Hier j'ai fait quelques mesures sur l'alim à découpage.

    OPTOCOUP.gif

    En particulier en ce qui concerne le courant qui parcourt la LED de l'optocoupleur de l'alimentation à découpage. Je croyais que le courant serait d'une vingtaine de mA. En fait, il est beaucoup plus faible. C'est d'ailleurs pour cette raison que j'ai eu de la peine à obtenir des chiffres ronds pour le voltage. Il aurait fallu un potentiomètre multi-tours!

    Tension de sortie de l'alim à vide (V)............Courant dans la LED (mA)
    9,98 .............................. .........................1,213
    11,07......................... .............................. 1,202
    12,04......................... .............................. 1,197
    13,12......................... .............................. 1,192
    14,10......................... .............................. 1,162

    Et si l'alimentation était chargée, le circuit de commande devrait élargir encore ses pulses, ce qui signifie que le courant dans la led de l'optocoupleur devrait encore diminuer.

    Je suis donc obligé de revoir mon circuit d'interface. Le courant dans la LED ne doit pas aller de zéro à 20 mA, mais varier de quelques microampères autour de 1 mA.

    J'ai pensé au montage suivant:

    INTERFP3.jpg

    qui a l'air de faire ce qu'il faut. On a simplement une résistance qui shunte le transistor qui module le courant à travers la diode de l'optocoupleur, en fonction de la valeur moyenne du signal PWM qui va être produit par l'Arduino.

    Mais au delà de ceci, que penser de ce courant ridiculement bas? L'optocoupleur (type inconnu) ne semble pas en cause, puisque l'alim fonctionne parfaitement.
    Dernière modification par Yvan_Delaserge ; 19/10/2015 à 20h43.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  22. #19
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Bonsoir,
    Citation Envoyé par Yvan_Delaserge Voir le message
    Hier j'ai fait quelques mesures sur l'alim à découpage.

    Pièce jointe 295305

    En particulier en ce qui concerne le courant qui parcourt la LED de l'optocoupleur de l'alimentation à découpage. Je croyais que le courant serait d'une vingtaine de mA. En fait, il est beaucoup plus faible. C'est d'ailleurs pour cette raison que j'ai eu de la peine à obtenir des chiffres ronds pour le voltage. Il aurait fallu un potentiomètre multi-tours!

    Tension de sortie de l'alim à vide (V)............Courant dans la LED (mA)
    9,98 .............................. .........................1,213
    11,07......................... .............................. 1,202
    12,04......................... .............................. 1,197
    13,12......................... .............................. 1,192
    14,10......................... .............................. 1,162

    Et si l'alimentation était chargée, le circuit de commande devrait élargir encore ses pulses, ce qui signifie que le courant dans la led de l'optocoupleur devrait encore diminuer.
    Cela signifie donc que le µC est dans la boucle fermée, en série avec le contrôleur de l'alim à découpage.
    La datasheet du UC3844 : http://www.onsemi.com/pub_link/Collateral/UC3844-D.PDF


    Je suis donc obligé de revoir mon circuit d'interface. Le courant dans la LED ne doit pas aller de zéro à 20 mA, mais varier de quelques microampères autour de 1 mA.
    Plus ou moins : dans le cas idéal, l'amplificateur d'erreur (figure 1 de la datasheet) a un gain infini, et il suffit de faire varier d'une tension infiniment faible la
    tension sur la broche 2 du UC3844 pour faire varier du tout au tout la tension de sortie de l'alim. Dans la pratique, il suffit de faire varier d'une tension très faible la tension sur la broche 2 du UC3844 pour faire varier du tout au tout la tension de sortie de l'alim. Pour faire faiblement varier cette tension, il faut faire faiblement varier le courant dans la led. La valeur exacte de ce courant est néanmoins fonction de nombreux paramètres, dont l'âge des composante et, surtout, la température (de l'opto).

    Mais au delà de ceci, que penser de ce courant ridiculement bas? L'optocoupleur (type inconnu) ne semble pas en cause, puisque l'alim fonctionne parfaitement.
    cf. plus haut pour l'explication sur la faible variation nécessaire.
    Pour la valeur moyenne du courant :
    Soit R la résistance entre l'émeteur de l'opto et la masse : http://forums.futura-sciences.com/at...e-optocoup.gif supposant nul le courant dc circulant dans l'autre résistance d'émetteur. La tension moyenne en entrée du UC... lorsque la régulation fonctionne est égale à 2.5V (fig. 2 de la datasheet), c'est également la tension sur l'émetteur de l'opto. On en déduit donc le courant d'émetteur de l'opto : Ie=2.5/R. Connaissant le CTR=Ie/Iled de l'opto pour cette gamme de courant (~30 à 50% pour un opto de base, éventuellement > 800%), tu en déduis Iled.
    Et voilà.


    Conclusion :
    Si la décision me revenait, je pense que je reprendrais le circuit comme je pensais qu'il était fait :
    fs0.png
    Le µC est sorti de la boucle, il sert plus qu'à générer la tension de consigne. La régulation est assurée par l'AOP et l'ampli. d'erreur interne au UC...
    C2 et R7 ne sont peut-être pas indispensables : il permettent (éventuellement) de stabiliser le circuit.

    On peut cependant se dire que si le montage était sans cet AOP à l'origine, c'est que c'est tout à fait possible. Il faut "juste" que le µC scanne la tension de sortie via son ADC et ajuste dynamiquement le rapport cyclique du PWM pour ajuster la tension de sortie. Le montage tel que tu l'as modifié peut être un bon départ, mais le gain de l'ampli d'erreur me semble élevé, et risque de rendre la régulation acrobatique.
    Dernière modification par Antoane ; 19/10/2015 à 21h36.
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  23. #20
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par Antoane Voir le message
    Bonsoir,

    Cela signifie donc que le µC est dans la boucle fermée, en série avec le contrôleur de l'alim à découpage.
    La datasheet du UC3844 : http://www.onsemi.com/pub_link/Collateral/UC3844-D.PDF
    Hello Antoane et merci de tes commentaires.
    Je n'ai pas été très explicite concernant les mesures effectuées, désolé. Je dois avoir un peu trop la tête dans le guidon avec ce montage!

    Voici l'aspect général:

    ASPCTGEN.jpg



    Le circuit que j'ai utilisé pour les mesures est le suivant:

    MESIOPT.gif

    La connexion qui va normalement vers la petite platine du uC, je l'ai débranchée. Pour faire varier la tension de sortie de l'alim, il suffit de faire varier le courant traversant la LED de l'optocoupleur au moyen du potentiomètre.

    l'amplificateur d'erreur (figure 1 de la datasheet) a un gain infini, et il suffit de faire varier d'une tension infiniment faible la
    tension sur la broche 2 du UC3844 pour faire varier du tout au tout la tension de sortie de l'alim. Dans la pratique, il suffit de faire varier d'une tension très faible la tension sur la broche 2 du UC3844 pour faire varier du tout au tout la tension de sortie de l'alim. Pour faire faiblement varier cette tension, il faut faire faiblement varier le courant dans la led. La valeur exacte de ce courant est néanmoins fonction de nombreux paramètres, dont l'âge des composante et, surtout, la température (de l'opto).
    Oui en effet.
    Si la décision me revenait, je pense que je reprendrais le circuit comme je pensais qu'il était fait :
    Pièce jointe 295316
    Le µC est sorti de la boucle, il sert plus qu'à générer la tension de consigne. La régulation est assurée par l'AOP et l'ampli. d'erreur interne au UC...
    C2 et R7 ne sont peut-être pas indispensables : il permettent (éventuellement) de stabiliser le circuit.

    On peut cependant se dire que si le montage était sans cet AOP à l'origine, c'est que c'est tout à fait possible. Il faut "juste" que le µC scanne la tension de sortie via son ADC et ajuste dynamiquement le rapport cyclique du PWM pour ajuster la tension de sortie. Le montage tel que tu l'as modifié peut être un bon départ, mais le gain de l'ampli d'erreur me semble élevé, et risque de rendre la régulation acrobatique.

    Pour l'instant, je n'ai pas encore démonté la mini-platine du contrôleur, mais j'ai bien l'impression que ça devait bien fonctionner comme tu l'écris.

    PLATINE.jpg

    Les 2 IC de la platine ont été passés au vernis pour que l'on ne puisse pas lire leur identification. Le supposé ampli op se trouve justement du côté de la broche qui sert à donner la consigne concernant la tension de sortie de l'alim.

    Le plus fort, c'est que j'ai effectué une autre série de mesures, pour voir quel est le courant tiré par la platine du uC lorsque l'on fait varier la tension de sortie de l'alim. Le circuit de mesures est le suivant:

    COUDU-UC.jpg

    Je mesure le courant qui circule dans la broche de la platine du uC qui servait à commander le courant dans la LED de l'optocoupleur.

    Tension de sortie de l'alim.......................C ourant tiré par la platine uC
    10 V............................. ........................164 uA
    11 V............................. ........................168 uA
    12 V............................. ........................172 uA
    13 V............................. ........................176 uA
    14 V............................. ........................180 uA

    Deux hypothèses:

    1) Le microcontrôleur essaie bien d'influencer la tension de sortie en faisant varier le courant dans la LED de l'optocoupleur. Il fonctionne encore. Du reste, il gère presque correctement l'affichage.

    2) On mesure davantage de courant parce que la tension qu'on applique augmente (composant grillé, résistance purement ohmique). Mais en divisant U par I, on obtient une résistance qui augmente en rapport direct avec la tension.

    En résumé, je dirais que dans le montage original, le uC est hors de la boucle de régulation. Il ne fait que fixer la valeur de la consigne (= la tension de sortie qu'il désire appliquer à la batterie).

    Le courant dans la LED dépend aussi de la tension de sortie de l'alim. Si elle fait mine de varier, le UC3844, qui se trouve du côté haute tension de l'alim va intervenir rapidement pour rétablir la valeur initiale.

    La panne vient de ce que le courant que la platine uC est capable de faire circuler dans la LED de l'optocoupleur est 10 fois trop faible. Probablement l'étage de sortie de l'ampli op qui a rendu l'âme...

    Quel serait l'avantage de remplacer le transistor en collecteur commun entre le filtre passe-bas (lissant le PWM du uC) et la cathode de la LED de l'optocoupleur, par un ampli op? Une plus grande impédance d'entrée, permettant un meilleur lissage du PWM?
    Mais un transistor ne serait-il pas plus robuste qu'un ampli op? N'oublions pas que c'est probablement l'ampli op le coupable de la panne.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  24. #21
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Et voici le module à microcontrôleur après dessoudage et extraction (oui, il était collé en plus!)

    VEGACHAR.jpg

    Et voici le côté composants:

    VEGACHA2.jpg

    Comme on le soupçonnait, le petit IC est bien un ampli op, et bien connu, puisqu'il s'agit d'un LM 324. Le uC est un Holtek HT46R47

    Il n'y a plus qu'à le remplacer par un Arduino et à écrire le programme.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  25. #22
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Salut à tous,

    J'ai un peu avancé le projet. Voici le programme pour l'Arduino, première version.
    Code:
    int sensorVoltage = A5;    // select the input pin for voltage sense
    int sensorCurrent = A4;    // select the input pin for current sense
    int controlSMPS = 3;    // select the output pin for the control of SMPS
    float tensionMesure = 0.0;  // variable to store the voltage value coming from the sensor
    float courantMesure = 0.0;  // variable to store the current value coming from the sensor
    float tensionConsigne = 0.0;  // variable to store the voltage to be applied to the battery
    float courantConsigne = 0.0;  // variable to store the current to be applied to the battery
    int tensionSMPS = 128; //valeur de départ pour la tension produite par la SMPS
    int heures = 0;  //temps de charge heures
    int minutes = 0;  //temps de charge minutes
    int minuterieDepart = 0;  //minuterie
    int selecteur = 7;   // sélecteur moto-voiture connected to digital pin 7
    int machine=10;
    
    // include the library code:
    #include <LiquidCrystal.h>
    
    // initialize the library with the numbers of the interface pins
    LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
    
    void setup() {
      pinMode(controlSMPS, OUTPUT);   // sets the pin as output
      pinMode(selecteur, INPUT);      // 0 = batt de moto 1 = batt de voiture
      pinMode(sensorVoltage, INPUT);  
      pinMode(sensorCurrent, INPUT);
      // set up the LCD's number of columns and rows:
      lcd.begin(16, 2);
    }
    
    enum {etat0, etat1, etat2, etat3, etat4, etat5, etat6} etat = etat0;
    
    void loop() {
      tensionMesure = analogRead(sensorVoltage) * 0.00488;
      courantMesure = analogRead(sensorCurrent) * 0.00488;
    
      switch (etat)
      {
        case etat0:
        machine=0;
        //détermination du type de batterie
        //si moins de 3.8 V (y compris valeurs négatives = branchement inversé)
        //ou plus de 14,7 V, on est off limits. Le chargeur ne se met pas en route
          if (tensionMesure < 3.8) {etat = etat0; break;}
          if (tensionMesure > 14.7) {etat = etat0; break;}
        // si on est entre 3,8 et 7,3 V, c'est une batterie de 6 V  
          if (tensionMesure >= 3.8 && tensionMesure < 7.3) 
               {etat = etat1; minuterieDepart = millis();break;}
        // si on est entre 7,3 et 14,7 V, c'est une batterie de 12 V  
          if (tensionMesure >=7.3 && tensionMesure <= 14.7 && digitalRead(selecteur) == 0) 
               {etat = etat2; minuterieDepart = millis(); break;}
          if (tensionMesure >=7.3 && tensionMesure <= 14.7 && digitalRead(selecteur) == 1) 
               {etat = etat3; minuterieDepart = millis();break;}
          break;
          
        case etat1:
        machine=1;
        //chargement batterie de 6 V sous courant de 0,80 A
          courantConsigne = 0.80;
          chargeCourantConstant();
          tempsCharge(); //mise à jour du temps de charge
          if (tensionMesure >= 7.3) {etat = etat6; break;}
          break;
          
        case etat2:
        machine=2;
        //chargement batterie de moto sous courant de 0.80 A
          courantConsigne = 0.80;
          chargeCourantConstant();
          tempsCharge(); //mise à jour du temps de charge
          if (tensionMesure >= 14.22) {etat = etat4; break;}
          break;
          
        case etat3:
        machine=3;
        //chargement batterie de voiture sous courant de 3.8 A
          courantConsigne = 3.80;
          chargeCourantConstant();
          tempsCharge(); //mise à jour du temps de charge
          if (tensionMesure >= 14.22) {etat = etat5; break;}
          break;
          
          case etat4:
          machine=4;
        //chargement batterie de moto sous tension constante 14,22 V
          tensionConsigne = 14.22;
          chargeTensionConstante();
          tempsCharge(); //mise à jour du temps de charge
          //si le courant de charge devient inférieur à 20 mA, la charge est terminée
          if (courantMesure < 0.02) {etat = etat0; break;}
          //si la charge dure plus de 10 heures, on arrête la charge
          if (((millis() - minuterieDepart)/36000000) > 10) {etat = etat6; break;}
          break;
          
        case etat5:
        machine=5;
        //chargement batterie de voiture sous tension constante 14,22 V
          tensionConsigne = 14.22;
          chargeTensionConstante();
          tempsCharge(); //mise à jour du temps de charge
          //si le courant de charge devient inférieur à 100 mA, la charge est terminée
          if (courantMesure < 0.10) {etat = etat6; break;}
          //si la charge dure plus de 10 heures, on arrête la charge
          if (((millis() - minuterieDepart)/36000000) > 10) {etat = etat6; break;}
          break;
          
        case etat6:
        machine=6;
        //trickle charge à 70 mA pour batterie voiture
        courantConsigne = 0.07;
        chargeCourantConstant();
        break;
      }
      
      affichage();
    }
    
    //fonction d'affichage sur LCD
    void affichage() {
      lcd.setCursor(0, 0);
      lcd.print(tensionMesure);
      lcd.print(" V   ");
      lcd.print(courantMesure);
      lcd.print(" A");
      // set the cursor to column 0, line 1
      // (note: line 1 is the second row, since counting begins with 0):
      lcd.setCursor(0, 1);
      lcd.print(machine);
      lcd.print("   ");
      lcd.print(heures);
      lcd.print(" h ");
      lcd.print(minutes);
      lcd.print(" min");
      
      delay(10);
    }
    
    void chargeCourantConstant(){
      if (courantMesure < courantConsigne) {tensionSMPS ++;}
      else if (courantMesure > courantConsigne) {tensionSMPS --;}
      analogWrite(controlSMPS, tensionSMPS);
      }
      
    void chargeTensionConstante(){
      if (tensionMesure < tensionConsigne) {tensionSMPS ++;}
      else if (tensionMesure > tensionConsigne) {tensionSMPS --;}
      analogWrite(controlSMPS, tensionSMPS);
      }
      
      void tempsCharge(){
        //calcul du temps total de charge
      minutes = (millis() - minuterieDepart)/60000;
      heures = minutes/60;
      minutes = minutes % heures;
        }
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  26. #23
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Bonsoir,
    Citation Envoyé par Yvan_Delaserge Voir le message
    Quel serait l'avantage de remplacer le transistor en collecteur commun entre le filtre passe-bas (lissant le PWM du uC) et la cathode de la LED de l'optocoupleur, par un ampli op? Une plus grande impédance d'entrée, permettant un meilleur lissage du PWM?
    Mais un transistor ne serait-il pas plus robuste qu'un ampli op? N'oublions pas que c'est probablement l'ampli op le coupable de la panne.
    L'avantage du circuit du post 19 par rapport au post 13 ?
    Dans le 19, le µC dit "je veux que la tension en sortie de l'alim soit de 13V". L'AOP l'entend, mesure la tension de sortie et agit sur l'opto pour que la demande du µC soit comblée. Le µC n'a pas besoin de vérifier la valeur de Vout, il sait qu'elle vaut ce qu'il a demandé (il peut éventuellement le faire, pour détecter un éventuel problème et savoir dans quel type de charge il doit travailler (floating,rapide...)).
    Dans le 13, le µC sait qu'il veut que la tension en sortie de l'alim soit de 13V. Il la mesure et agit directement sur l'opto pour que Vout prenne la bonne valeur.

    Si tu intègres la régulation dans le µC (ce qu'il me semble voir dans ton code : " if (courantMesure < courantConsigne) {tensionSMPS ++;}; else if (courantMesure > courantConsigne) {tensionSMPS --;}) , l'AOP pert effectivement de son intérêt.
    Ton µC régule le courant en jouant sur la tension de consigne. C'est évidement possible, mais risque d'être accrobatique : le courant n'étant limité que par l'impédance parasite du système, une faible variation de la tension engendre une forte variation du courant de charge. Ici, il serait peut-être plus sage de laisser un AOP faire le travail. Mais, à vrai dire, j'en sais trop rien

    Les seuils devraient varier avec la température. T'en est peut-être pas là, mais programmer directement avec des variables au lieu des nombres simplifiera le problème plus tard.
    Dernière modification par Antoane ; 24/10/2015 à 18h42.
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  27. #24
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Et voici le branchement de l'Arduino.
    BRNCHARD.gif

    Je vais réutiliser le circuit du chargeur dont j'ai retiré la platine uC.

    Elle comporte déjà les connexions nécessaires permettant de mesurer le courant fourni à la batterie que l'on est en train de charger. Il s'agit tout simplement de 2 résistances de 2 Ohms en parallèle, placées en série avec la connexion vers le - de la batterie. On aura ainsi une tension de 1 V pour 1 A fourni à la batterie, que l'Arduino pourra facilement lire sur sa broche A4.

    Pour la tension de sortie, il faudra prévoir un diviseur de tension pour la ramener à moins de 5 V, que l'Arduino lira sur sa broche A5.

    J'ai rajouté une troisième entrée (broche 7) permettant de sélectionner un programme de charge à courant réduit pour les batteries de moto.

    Pour ce qui est des sorties, on a tout en haut sur la broche 6, la commande permettant de régler la tension produite par l'alim, comme discuté plus haut dans ce fil.

    Le transfo du chargeur possède deux secondaires: Un pour 12 V, fort courant (2,8 A), un pour 6 V, faible courant (800 mA).
    Le premier est mis en contact avec la sortie du chargeur (les pinces à relier à la batterie) à travers un relais.
    L'alim 6 V quant à elle, est commandée par un transistor.

    Même si par accident les deux étaient activées en même temps, l'alim 6 V est protégée par une diode. Il faudra quand même écrire un programme ne permettant en aucun cas que les deux alims soient connectées simultanément.

    Le chargeur d'origine comporte aussi une troisième alim qui fournit 5 V, à partir de l'enroulement utilisé pour le 12 V, mais avec sa propre diode et son petit condensateur de filtrage. A mon avis elle sert au uC à s'assurer qu'il n'y a pas de surcharge. Si c'était le cas, la tension baisserait et en ce cas, le uC réagirait en se mettant en standby.
    Il y a aussi ce que je crois être une thermistance placée contre les enroulements du transfo. Probablement encore une sécurité. Il serait dommage de ne pas les utiliser. Je vais creuser un peu le sujet.

    Il y a finalement un dernier circuit dont j'ai mis du temps à comprendre l'utilité. En effet, il connecte les 2 bornes de sortie du chargeur au moyen d'une résistance 22 ohms, 2W.

    Après de longues recherches, j'ai trouvé sur le net, un texte d'un brevet, décrivant un procédé de charge d'une batterie. A certaines étapes de ce procédé, on arrête la charge et on fait débiter la batterie par impulsions à travers ladite résistance. Lorsque après un certain nombre d'impulsions, la tension aux bornes de la batterie augmente, on passe à l'étape suivante de la charge.

    Personnellement, je ne comprends pas très bien ce procédé. Je vais rester plus classique.
    1re étape: On charge à courant constant (2,8 A dans le cas d'une batterie de voiture. 600 mA dans le cas d'une batterie de moto)
    Lorsque la tension aux bornes de la batterie atteint 14, 22 V, on passe à la
    2e étape: On reste à cette tension. Le reste de la charge se déroule à tension constante. La charge est interrompue lorsque le courant diminue jusqu'à 100 mA ( 20 mA pour une batterie de moto). Ou lorsque le temps total de charge atteint les 10 heures.
    La 3e étape consiste à maintenir un courant de charge de 70 mA, pour compenser la décharge naturelle de la batterie.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  28. #25
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par Antoane Voir le message
    Bonsoir,
    Hello Antoane,

    L'avantage du circuit du post 19 par rapport au post 13 ?
    Dans le 19, le µC dit "je veux que la tension en sortie de l'alim soit de 13V". L'AOP l'entend, mesure la tension de sortie et agit sur l'opto pour que la demande du µC soit comblée. Le µC n'a pas besoin de vérifier la valeur de Vout, il sait qu'elle vaut ce qu'il a demandé (il peut éventuellement le faire, pour détecter un éventuel problème et savoir dans quel type de charge il doit travailler (floating,rapide...)).
    Dans le 13, le µC sait qu'il veut que la tension en sortie de l'alim soit de 13V. Il la mesure et agit directement sur l'opto pour que Vout prenne la bonne valeur.

    Si tu intègres la régulation dans le µC (ce qu'il me semble voir dans ton code : " if (courantMesure < courantConsigne) {tensionSMPS ++;}; else if (courantMesure > courantConsigne) {tensionSMPS --;}) , l'AOP pert effectivement de son intérêt.
    Ton µC régule le courant en jouant sur la tension de consigne. C'est évidement possible, mais risque d'être accrobatique : le courant n'étant limité que par l'impédance parasite du système, une faible variation de la tension engendre une forte variation du courant de charge. Ici, il serait peut-être plus sage de laisser un AOP faire le travail. Mais, à vrai dire, j'en sais trop rien
    OK, je comprends mieux.

    Les seuils devraient varier avec la température. T'en est peut-être pas là, mais programmer directement avec des variables au lieu des nombres simplifiera le problème plus tard.
    Oui, en effet, selon la température à laquelle se trouve la batterie à charger, les tensions utilisées pour la recharge varient (augmentent si la température baisse).

    Le chargeur d'origine le faisait. Il y avait un programme spécial pour charger la batterie d'un véhicule se trouvant à l'extérieur par temps froid.

    ça serait facilement envisageable de l'ajouter, il faudrait un switch supplémentaire et des états supplémentaires dans la machine à états du soft.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  29. #26
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Citation Envoyé par Antoane Voir le message
    Bonsoir,

    L'avantage du circuit du post 19 par rapport au post 13 ?
    Dans le 19, le µC dit "je veux que la tension en sortie de l'alim soit de 13V". L'AOP l'entend, mesure la tension de sortie et agit sur l'opto pour que la demande du µC soit comblée. Le µC n'a pas besoin de vérifier la valeur de Vout, il sait qu'elle vaut ce qu'il a demandé (il peut éventuellement le faire, pour détecter un éventuel problème et savoir dans quel type de charge il doit travailler (floating,rapide...)).
    Dans le 13, le µC sait qu'il veut que la tension en sortie de l'alim soit de 13V. Il la mesure et agit directement sur l'opto pour que Vout prenne la bonne valeur.

    Si tu intègres la régulation dans le µC (ce qu'il me semble voir dans ton code : " if (courantMesure < courantConsigne) {tensionSMPS ++;}; else if (courantMesure > courantConsigne) {tensionSMPS --;}) , l'AOP pert effectivement de son intérêt.
    Ton µC régule le courant en jouant sur la tension de consigne. C'est évidement possible, mais risque d'être accrobatique : le courant n'étant limité que par l'impédance parasite du système, une faible variation de la tension engendre une forte variation du courant de charge. Ici, il serait peut-être plus sage de laisser un AOP faire le travail. Mais, à vrai dire, j'en sais trop rien

    Les seuils devraient varier avec la température. T'en est peut-être pas là, mais programmer directement avec des variables au lieu des nombres simplifiera le problème plus tard.
    Hello Antoane.

    J'ai refait quelques simu. Le montage à opamp ne semble pas apporter de différence par rapport au montage à transistor.
    L'alim est en fait l'alim à découpage dont il s'agit de stabiliser la tension. Au lieu d'une alim fixe à 12 V, j'ai simulé une alim qui pulse de 10 à 14 V toutes les 10 ms, à partir de 60 ms. On aimerait que le courant dans la led de l'optocoupleur augmente si la tension augmente, et inversement.

    Montage à opamp:
    INTOPAM1.jpg

    En bleu le courant dans la LED. Il ne varie pas avec la tension d'alim (en vert).

    A part ça, un détail intéressant: L'image est floue. C'est parce qu'elle est en JPEG.
    Or, pour qu'elle soit nette, je l'ai uploadée en GIF. Le serveur convertit les images GIF en JPEG!!
    Mais pas toujours! Certaines restent en GIF donc nettes.
    Et parfois elles s'affichent normalement, parfois en miniatures.
    J'avais déjà signalé le fait aux modérateurs, mais en vain. Personne ne semble pouvoir influencer les desseins impénétrables de la GBN (grande boîte noire) du serveur.
    Bref, fin de la digression.

    Le comportement du montage à opamp est le même que celui du montage à transistor:
    INTOPAM2.jpg

    Ici, c'est le courant dans la LED qui est en vert, et la tension d'alim en bleu. On voit que le courant dans la LED ne varie pas, malgré l'instabilité de la tension d'alim.

    En revanche, si j'utilise le montage comportant une résistance qui shunte le transistor, les choses sont plus favorables. On se rappelle que la résistance de shunt était rendue nécessaire par le fait que le courant qui doit circuler dans la LED de l'optocoupleur doit varier légèrement de part et d'autre de 1 mA. Et non varier de 0 à 20 mA. Voir plus haut.

    INTOPAM3.jpg

    On voit que cette fois, toute variation de la tension d'alim se répercute très fortement sur le courant de la LED. C'est bien ce qu'on recherche.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  30. #27
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Bonsoir,
    Ta simulation du montage à aop à un problème : il n'y a pas de contre - réaction dans le montage et pourtant, l.aop n'est pas saturé...

    Dans le montage à npn + résistance, certes le courant varie avec l'alimentation mais rien ne doit que cette variation sera exactement la bonne. Le uC devra de toute façon gérer l'ensemble. Le pincipe pourrait cependant être exploité pour améliorer la réponse dynamique de l'asservissement : en cas d variation brusque de Vout, le courant dans la Led augmente avant même que le uC ai eu le temps de réagir. ... on en est peut être pas encore l'as, d'autant que ça (peut ) complexifier la gestion de l asservissement par le uC.
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  31. #28
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Oui, je trouve aussi bizarre le comportement de cet ampli op. Je vais essayer de changer de modèle. LTspice en met de nombreux à disposition.

    Le montage à ampli op du post #19, sans contre réaction, a un gain très élevé. Or on a déjà un gain très élevé au niveau du comparateur de l'IC régulateur.

    On aura donc dans la boucle de contre-réaction deux fois un gain très élevé: avant et après l'optocoupleur. Est-ce qu'une telle valeur de gain peut avoir des effets secondaires?
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  32. #29
    Antoane

    Re : Interface entre Arduino et alimentation à découpage

    Bonjour,
    Citation Envoyé par Yvan_Delaserge Voir le message
    Le montage à ampli op du post #19, sans contre réaction, a un gain très élevé. Or on a déjà un gain très élevé au niveau du comparateur de l'IC régulateur.
    A peu près n'importe quel single-supply op-amp devrait ici convenir : il suffit de pouvoir sortir qq mA et de mesurer des tensions près des rails d'alim. Un 358 devrait faire l'affaire.

    Citation Envoyé par Yvan_Delaserge Voir le message
    On aura donc dans la boucle de contre-réaction deux fois un gain très élevé: avant et après l'optocoupleur. Est-ce qu'une telle valeur de gain peut avoir des effets secondaires?
    Du gain... et même toute la fonction de transfert : on multiplie ici les trois : AOP, opto et UC (plus, éventuellement celle du µC).
    Ca peut effectivement poser problème. Plusieurs solutions :
    - calculer la fonction de transfert globale et en étudier la stabilité (ou plus généralement le comportement dynamique) ;
    - simuler le montage global et en étudier la stabilité (ou plus généralement le comportement dynamique) ;
    - câbler et espérer que cela n'explosera pas, jouer sur le couple C2-R7 (post19) au besoin.

    Les premières méthodes demandent une connaissance minimale de l'ensemble du montage, que l'on a, me semble-t-il, pas.

    Note qu'utiliser le montage à transistor (post 13) ne résout, de ce côté, rien : la fonction de transfert de l'AOP est à remplacer par celle de l'asservissement implémenté dans le µC.

    Pour la GBN : je ne sais pas. Les images sont, me semble-t-il, affichées en gros lorsqu'il n'y en a qu'une par post, en miniatures sinon.
    Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.

  33. #30
    Yvan_Delaserge

    Re : Interface entre Arduino et alimentation à découpage

    Je me rappelle d'une remarque qu'avait écrite Tropique il y a déjà quelque temps: Il y a un moment où la théorie seule ne permet pas de prédire comment un montage va fonctionner. Il faut passer aux essais.

    J'ai presque fini de mettre le programme au point, je vais le poster bientôt et après, place aux essais, en prenant toutes les précautions nécessaires pour éviter surintensités, surtensions et surchauffes.

    Merci pour le tuyau concernant la GBN. C'est vrai que les miniatures constituent une encombre pour la lecture d'un fil. Je vais tâcher de ne mettre qu'une image par message.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

Sur le même thème :

Page 1 sur 2 1 DernièreDernière

Discussions similaires

  1. Chargeur de batterie au plomb "intelligent"
    Par HAYAC dans le forum Électronique
    Réponses: 24
    Dernier message: 04/08/2017, 06h39
  2. chargeur de batteries à plomb
    Par virioh dans le forum Électronique
    Réponses: 6
    Dernier message: 02/07/2009, 11h18
  3. chargeur batterie au plomb intelligent
    Par tarentulemrjack dans le forum Électronique
    Réponses: 4
    Dernier message: 05/10/2006, 10h28
  4. Chargeur universel de batteries au plomb
    Par skeeter dans le forum Électronique
    Réponses: 30
    Dernier message: 20/08/2006, 10h04
  5. Chargeur de batteries au plomb
    Par Nickyo dans le forum Électronique
    Réponses: 4
    Dernier message: 08/06/2005, 19h19