Charge électronique USB réglable de 0 à 1A, pilotée en PWM par microcontrôleur ATtiny 824

Aujourd’hui, je vous propose de voir ensemble un exemple de charge électronique (avec schéma, explications techniques, et réalisation sur PCB). Et ce sera l’occasion pour moi de vous montrer comment générer un signal PWM sur un ATtiny, tout en affichant les infos sur un écran OLED (monochrome, 128×64 pixels, driver SSD1306), piloté en I²C.

Pour la petite histoire, c’est parce que je voulais tester en charge les alimentations USB lithium-ion 18650 que j’avais précédemment crée, que j’ai conçu cette charge électronique USB, réglable de 0 à 1 ampère. Aussi, je me suis dit qu’il serait intéressant de vous partager tout cela, d’autant plus que cela me permettra de vous montrer quelques calculs de dimensionnement des composants ! Ça vous dit ? Alors en avant !

Remarque : comme vous l’aurez compris, le but de cet article est avant tout éducatif, et non d’essayer de créer quelque chose qui serait moins cher que ce qu’on trouve déjà tout prêt sur le net. C’est pourquoi je vous détaillerais au maximum l’aspect technique (et logiciel) de cette charge électronique PWM. Ainsi, vous pourrez apprendre l’électronique au travers de cette réalisation pratique/concrète, si le cœur vous en dit 😉

Qu’est-ce qu’une charge électronique ? Et à quoi ça sert ?

Une charge électronique est tout simplement un appareil permettant de tirer du courant (« mettre en charge ») sur ce sur quoi elle est branchée. Ici, dans le cas d’une charge électronique USB, c’est sur une prise USB que du courant va être tiré.

Et si on branche des appareils de mesure (voltmètre / oscilloscope) sur l’alimentation USB à tester, alors on pourra vérifier :

• si la source fournissant le +5V USB tient la charge (si sa tension ne s’effondre pas, lorsqu’on tire un certain niveau de courant dessus)
• et éventuellement, s’il n’y a pas trop de parasites qui apparaissent dessus (ondulation résiduelle due à une alim USB à découpage, par exemple)

Le but d’une charge électronique USB est donc de tirer du courant sur une alim USB, afin de pouvoir vérifier si la tension fournie (5V) reste stable ou non, y compris à « pleine » charge.

Dans le cas du projet que je vous partage ici, il s’agit d’une charge électronique :

• pouvant soutirer un courant continu compris entre 0 et 1 ampère (réglable manuellement, avec un simple potentiomètre)
• disposant d’une charge purement résistive (de 5 ohms, pour info, obtenue à partir de 4 résistances de 20 ohms mises en parallèle) ; cela permet de soutirer 1A sous 5V (d’après la formule de la loi d’ohm : U=R*i d’où i = U/R, d’où i = 5V / 5 ohms = 1A, donc)
• pilotée en PWM à une fréquence de 4 kHz (généré par un microcontrôleur ATtiny)
• affichant le courant et la puissance soutirée théorique, sur un afficheur OLED de 0’96 pouces

Nota : on parle de charge « électronique » ici, car il y a effectivement une partie électronique pour piloter le courant soutiré (par opposition à une charge passive, par exemple). On parle même parfois de « charge fictive », car on met « artificiellement » en charge quelque chose, pour effectuer des tests dessus !

Schéma électronique de cette charge électronique USB 1A (pilotée par ATtiny)

Sans plus tarder, entrons directement dans le vif du sujet, et voyons ensemble le schéma de cette charge électronique 5V 1A :

Comme indiqué sur le schéma, on retrouve ici 6 blocs distincts, à savoir :

• le bloc « Alimentation 5V à tester », qui est constitué d’un fusible réarmable 1,5A de chez LittelFuse (polyfuse 1206L150THWR), ainsi qu’un condensateur de filtrage de 10 µF
• le bloc « Charge de 5 ohms », qui comprend en fait 4 résistances de 20 ohms mises en parallèle (pour obtenir 5 ohms, tout en répartissant la chaleur sur ces quatre composants), pilotées en « tout-ou-rien » par un mosfet (A03400A), lui-même piloté en PWM par le microcontrôleur ATtiny (avec une résistance de décharge à la masse de 10 Kohm, et une résistance de limitation de courant de grille de 1 Kohm)
• le bloc « Écran OLED », qui est simplement constitué d’un connecteur 4 broches, où viendra s’embrocher le dit afficheur
• le bloc « Microcontrôleur (ATtiny824) », qui contient le µC en lui-même, accompagné de son condensateur de filtrage de 100nF, et d’un connecteur de programmation UPDI (afin de pouvoir programmer le microcontrôleur à partir du convertisseur USB/UPDI v2 que je vous avais présenté dernièrement)
• le bloc « BP charge ON/OFF », qui contiendra uniquement le bouton poussoir ON/OFF, permettant d’activer ou non la charge électronique
• et le bloc « Pot. rapport cyclique PWM », qui se résume à un potentiomètre linéaire pris entre la masse et le +5V, avec un condensateur de stabilisation de 100 nF en point milieu (et qui permettra d’ajuster le rapport cyclique du signal PWM entre 0 et 100%, pour ainsi pouvoir faire varier la charge de 0 à 1A)

En clair, rien de bien compliqué, quand on analyse bloc par bloc ! Cela étant dit, voyons à présent les raisons de ces choix de composants, sans plus tarder 🙂

Explications techniques (mosfet, résistances de puissance, …)

Pour ceux que ça intéresse, je vous détaille ci-après plusieurs choix techniques que j’ai fait ici, et calculs mathématiques. Bien sûr, si cela ne vous intéresse pas dans l’immédiat, n’hésitez pas à sauter cette partie, et y revenir plus tard au besoin !

Pourquoi avoir 4 résistances de 20 ohms en parallèle, plutôt qu’une seule de 5 ohms ?

En fait, j’ai opté pour 4 résistances au lieu d’une seule afin de répartir la puissance à dissiper. Car oui, il y aura pas mal de puissance (et donc de chaleur) à évacuer (5 watts environ), et donc, il vaut mieux diviser celle-ci sur plusieurs éléments, plutôt qu’un seul !

Bien sûr, on aurait pu mettre encore plus de résistances ici pour encore mieux répartir la puissance à dissiper. Mais côté PCB, je voulais avoir quelque chose de compact (à peu près de la taille de l’écran OLED, en fait), du coup je me suis limité à 4 résistances en parallèle.

Côté thermique, afin d’améliorer l’évacuation de chaleur au niveau de ces résistances (au format CMS, boîtier 2512), j’ai rajouté des petits dissipateurs thermiques, autocollants, collés à même leur corps. Par contre, n’ayant aucune caractéristique sur ces dissipateurs de chaleur (achetés sur Aliexpress), je ne pourrais malheureusement pas faire de calculs thermiques ici.

Cela étant dit, si cette charge électronique est utilisée à pleine puissance (1A sous 5V, soit 5W), ces résistances vont forcément monter en température ! Et comme il s’agit ici de résistances montées en surface (CMS), le PCB va forcément s’échauffer également ; c’est d’ailleurs ce que je vous montrerai au moment des essais, avec la caméra thermique !

Pourquoi avoir opté pour le mosfet AO3400A ?

Pour tout vous dire, beaucoup de mosfets canal-N auraient pu convenir ici. Mais une chose était importante : avoir un Rdson faible (c’est à dire une résistance équivalente, lorsque le transistor est passant, qui soit la plus petite possible). Ainsi, la puissance dissipée par le mosfet sera faible également, et par conséquent, son échauffement sera très limité (du coup, il n’y aura pas besoin de dissipateur thermique à son niveau).

Et justement, c’est une des caractéristiques de l’AO3400A : son Rdson est seulement de 0,03 ohm environ, lorsque piloté sous 5 volts au niveau de la grille. Qui plus est, c’est un modèle plutôt courant et populaire, c’est pourquoi je l’utilise ici 😉

Au passage, le Rdson n’était pas le seul point à considérer ici. En effet, lorsqu’on choisit un mosfet, il faut également prendre d’autres paramètres en compte, comme :

• le courant max supporté au niveau du drain (Idmax) : il est de 5,7A en continu sur l’AO3400A, alors que nous aurons que 1A passant au travers
• la tension max supportée entre drain et source (Vdsmax) : elle est de 30V pour l’AO3400A, alors que nous travaillons sous 5V
• la tension de déclenchement du mosfet via sa grille (Vgsth) : elle est de 1,45V max, alors que nous travaillons en 0V/5V
• et la capacité d’entrée du mosfet (Ciss), car elle peut « limiter » la fréquence max à laquelle on peut piloter le mosfet (voir paragraphe suivant)

Comment a été calculée la résistance de pilotage de la grille du mosfet ?

Au niveau de la grille du mosfet, on retrouve :

• une résistance de 1K (R5) entre le microcontrôleur ATtiny et la grille du mosfet
• une résistance de 10K (R6) entre la grille du mosfet et la masse

Pour info, la résistance R6 n’est qu’une « pull-down », servant à s’assurer que le mosfet soit bien bloqué en l’absence de signal. Nous nous intéresserons donc qu’à la résistance R5, ici.

Du reste, la résistance R5 n’a qu’une fonction : limiter le courant d’appel du mosfet (parce que le microcontrôleur est limité en courant de sortie, et que faire des économies d’énergies n’est pas futile !).

Le saviez-vous ? Un mosfet « consomme » effectivement du courant à chaque activation, dû à sa capacité d’entrée grille-source ; en dehors de ce moment là, le courant de grille est nul, idéalement. Or, si on pilotait la grille d’un mosfet en tout-ou-rien, sans limitation de courant, alors ce condensateur de grille (invisible, mais bien là) induirait des pics de courant à chaque activation. C’est pourquoi on ajoute classiquement une résistance de limitation de courant en amont de la grille, bien que dans l’absolu, la grille ne consomme pas de courant !

Le courant max tirable par la grille sera donc égal à (dans notre cas, avec une résistance de 1K, pilotée en 0V/5V) :

U = R * i (loi d’ohm)
soit U_{pilotage_grille} = R_grille * I_grille
d’où I_grille = U_{pilotage_grille} / R_grille
d’où I_grille = 5V / 1000ohms
d’où I_grille = 0,005 A (soit 5 mA)

Comme le microcontrôleur que nous utilisons ici, un ATtiny824, peut fournir ou tirer jusqu’à 40mA par broche, alors on est bon avec 5mA consommés en pic !

Maintenant, il y a un autre point à considérer. Car du fait de cette résistance de limitation de courant, le condensateur de grille du mosfet va se charger moins vite à chaque activation. Du coup, il faut également vérifier que sa tension soit suffisamment rapidement supérieure à Vgsth (seuil d’activation du mosfet), entre chaque activation/désactivation (sans quoi, le mosfet n’aurait pas le temps de s’enclencher qu’on lui demanderai de se couper !).

Pour vérifier cela, calculons à présent combien de temps va mettre ce condensateur de grille pour atteindre la tension Vgsth (pour faire simple, on noteraVc la tension aux bornes de ce condensateur de grille, Ve la tension de pilotage 5V de la grille, C la valeur de cette capacité de grille, et R la résistance de limitation de courant de grille) :

Vc = Ve * (1 – e^-t/RC)   (formule classique de charge d’un condensateur)
d’où Vc/Ve = 1 – e^-t/RC
d’où e^-t/RC = 1 – Vc/Ve
d’où ln(e^-t/RC) = ln(1 – Vc/Ve)
d’où -t/RC = ln(1 – Vc/Ve)
d’où t = – RC * ln(1 – Vc/Ve)

Dans notre cas, avec R=1000 ohms (résistance R5 du schéma), C=630 pF (valeur Ciss donnée dans le datasheet de l’AO3400A), Ve=5V (la tension de pilotage de grille), et Vc=1,45V (la tension max Vgsth, également issu du datasheet), alors on trouve :

t = – ln (1 – 1,45/5) * (1000 * 0,000000000630)
d’où t = – ln (0,71) * (0,000000630)
d’où t = 0,00000021577 (soit 0,21577 µs ou 215,77 ns)

Cela signifie que la tension Vgsth de 1,45V sera atteinte en 215,77 ns, lorsque pilotée en 5V via une résistance de 1K ohm.

Mais ce temps doit être « le plus petit possible », par rapport au temps de conduction effectif du mosfet. C’est pourquoi on va par exemple appliquer un facteur 10 sur ces « 0,21577 µs », afin que ceux-ci ne représentent que 10 % du temps (montée), en sachant que les 90 % du temps restant seront là pour maintenir le mosfet bloqué.

Ainsi, le temps de conduction avec cette résistance R5 sera de : 10 x 0,21577 µs = 2,1577 µs.

Si maintenant on considère que le signal PWM qui sera envoyé sur la grille aura un rapport cyclique au moins égal à 1% (la plus petite durée d’impulsion sera donc de 2,1577 µs, donc), la période du signal PWM devra alors être au minimum égale à 2,1577 / 0,01 = 215,77 µs.

Enfin, comme la fréquence est l’inverse de la période (f = 1 / T), on peut déduire la fréquence PWM ainsi :

F_{pwm_max} = 1 / T_{pwm_min}
d’où F_{pwm_max} = 1 / 0,00021577
d’où F_{pwm_max} = 4634 Hz (soit 4,634 kHz)

Autrement dit, la fréquence maximal du signal PWM devra être de 4634 Hz, pour que le mosfet soit bien bloqué (90% du temps), même avec un rapport cyclique de 1% seulement. C’est pourquoi une fréquence PWM de 4 kHz a été définie dans le programme ATtiny, ce qui correspond bien à une fréquence inférieure aux 4,634 kHz maximum trouvés ici.

En espérant que toutes mes explications soient claires dans l’ensemble, car à l’écrit, ce n’est pas forcément évident de tout expliquer !

Remarque : je ne l’ai pas précisé ici, mais tous ces calculs concernant l’activation du mosfet via sa grille sont aussi valables pour sa désactivation. Car la résistance de grille permettra également la décharge de la capacité d’entrée du mosfet, quand le microcontrôleur enverra du 0V !

Le saviez-vous ? les fabricants de mosfet ne communiquent généralement pas la valeur de cette capacité de grille. Par contre, ils donnent une valeur de « capacité d’entrée » (notée Ciss sur les datasheet), qui correspond à la somme capacité drain-grille (Cdg) + capacité grille-source (Cgs). Or comme la capacité drain-grille (Cdg) est négligeable par rapport à capacité grille-source (Cgs), on considère que Cgs est sensiblement égale à Ciss. C’est pourquoi nous prenons habituellement Ciss dans nos calculs, pour pouvoir calculer les courants d’appel et fréquence max de pilotage.

Pourquoi avoir choisi un ATtiny824 plutôt qu’un autre modèle ?

Alors là, il y avait plusieurs possibilités (de choix de µC, j’entends). Pour ma part, j’aime bien les ATtiny, surtout ceux de la série 0, 1, ou 2 (les derniers donc, les plus récents).

Bien sûr, il fallait un nombre minimal de broches, pour pouvoir notamment piloter l’écran OLED en i2c (SDA/SCL), recevoir le potentiomètre de réglage PWM, piloter le mosfet, accueillir un bouton START/STOP, et fournir des pins VCC/GND/UPDI. En clair, un µC à 8 broches minimum aurait fait l’affaire (donc n’importe quel ATtiny série 0-1-2, en somme).

Par contre, il faut également une certaine quantité de mémoire programme (flash) et vive (RAM) pour piloter l’écran OLED. Et c’est là où on monte vite « en gamme », si je puis dire, car les ATtiny sont vraiment limités, en terme de quantité de mémoire disponible.

Or, comme vous le verrez un peu plus loin, le programme que je vais vous présenter prendra environ 5,6Ko de mémoire flash, et 123 octets de RAM). C’est pourquoi il fallait à minima un ATtiny modèle 8?4 (le 8 signifiant 8Ko de mémoire flash, et 4 indiquant qu’il s’agit d’un boîtier à 14 broches, en format SOIC). Du coup, un ATtiny804, 814, ou 824 à minima conviendrait (car ils ont tous 8 Ko de mémoire programme, 14 broches, et 512 octets de mémoire RAM pour le 804/814 et 1Ko de RAM pour le 824).

Perso, comme j’avais des ATtiny824 en stock, j’ai tout simplement opté pour ceux-là !

Liste des composants et matériels utilisés

En détail, voici la liste des composants utilisés dans cette charge électronique USB 1A :

Qté	Désignation	Lien achat
1	Résistance 1K (CMS, format 1206)
1	Résistance 10K (CMS, format 1206)	(idem)
4	Résistance 20 ohm 1% 2W (CMS, format 2512)
1	Condensateur 10µF 50V MLCC X7R (CMS, format 1206)
2	Condensateur 100nF 50V MLCC X7R (CMS, format 1206)
1	Mosfet AO3400A (CMS, format SOT-23)
1	Microcontrôleur ATtiny824-SSU (CMS, format SOIC-14)
1	Connecteur USB-A femelle A (modèle traversant)
1	Fusible réarmable 1206L150THWR de chez LittelFuse (CMS, format 1206)
1	Connecteur pinSocket 1×4 broches au pas de 2,54mm (modèle traversant)
1	Connecteur pinSocket 2×3 broches au pas de 2,54mm (modèle traversant)
1	Potentiomètre 10K RV09 (modèle traversant)
1	Bouton poussoir tactile 4 pins SPST (CMS, format 12x12x4,3)
1	Écran OLED 0,96″ I2C SSD1306 (couleur blanc, ou autre)
4	Dissipateur thermique 10x10x10mm (couleur noir, ou autre)
1	Circuit imprimé PCB (dont vous trouverez, en fin d’article, le fichier Gerber zippé, si vous souhaitez reproduire ce projet à l’identique)	–

En espérant n’avoir rien oublié 😉

Partie matérielle : soudage des CMS sur circuit imprimé

Côté circuit imprimé, j’ai opté pour un PCB double face (les composants sur le dessus, et un plan de masse dessous). Voici à quoi il ressemble, d’ailleurs :

Pour le faire fabriquer, le plus simple est de passer par un fabricant de PCB. Vous avez par exemple le fabricant de circuits imprimés PCBWay qui propose ce genre de service, pour un prix vraiment compétitif ! Si cela vous intéresse, vous trouverez un lien vers ce PCB plus bas, dans le paragraphe « Liens utiles et téléchargements ».

Cela étant dit, passons à présent aux composants présents sur ce PCB. En fait, il y en a de 2 types :

• une majorité de CMS, que j’ai soudé à la plaque chauffante réglable en température (40-260°C), avec de la soudure (pâte à braser) basse température
• et des connecteurs traversants, que j’ai simplement soudé au fer à souder traditionnel

Pour les CMS, voici ce que ça donne, en image :

Pour info, pour souder les composants CMS, j’ai simplement appliqué de la pâte à braser sur le PCB, au niveau de chaque pastille/broche de composant, puis ai posé chaque composant au bon endroit, et ai fait chauffer la table, en suivant le profil de chauffe suivant :

• préchauffage : montée en température de la température ambiante jusqu’à 120°C, sur 1 minute environ
• maintien préchauffage : maintien de ces 120°C pendant 1 minute environ
• montée en chauffe : augmentation de la température de chauffe de 120°C à 180/190°C, sur 1 minute environ
• refusion : maintien de ces 180/190°C pendant 30 secondes environ
• et refroidissement : arrêt de la chauffe pour un refroidissement lent/naturel

Nota : pour régler la température de la table chauffante, je fais ça manuellement en appuyant sur les boutons + ou -, tout simplement. Cela permet d’augmenter ou baisser la consigne de température, de 10 en 10 °C sur le modèle de table que j’utilise ; comme la montée en chauffe est régulière et bien répartie, il n’y a pas de brusque variation de température.

Du reste, comme évoqué précédemment, j’ai simplement soudé les composants traversants restants au fer à souder électronique. Puis j’ai collé les 4 dissipateurs thermiques sur les « résistances de puissance », et ai embroché l’écran OLED à sa place ! Voici à quoi ça ressemble de mon côté, montrant chacune de ces étapes :

Cela étant vu, voyons à présent le code C++ du programme ATtiny !

Partie logicielle : code programme ATtiny824 (upload via l’IDE Arduino)

Avant de vous détailler le programme ATtiny en lui-même, il faut que je vous explique comment il sera structuré. En fait, le code est simplement divisé en 2 parties :

• une partie initialisation, comprenant :
  • la définition des broches utilisées sur l’ATtiny (et des pull-up à éventuellement activer)
  • les réglages initiaux du PWM (paramétrage du timer utilisé, TCA0, avec la sortie de forme d’onde WO3)
  • l’initialisation de l’ADC (convertisseur analogique numérique, interne à l’ATtiny)
  • l’initialisation de l’écran OLED (choix de la police de caractère, effaçage de la mémoire tampon, etc)
• une partie loop (répétition d’un bloc de code à l’infini), comprenant :
  • la lecture de l’état du bouton poussoir START/STOP (permettant d’activer ou arrêter la mise en charge électronique), avec enregistrement de l’état (charge électronique active = true ou false)
  • la lecture de l’état du potentiomètre (définissant le rapport cyclique du signal PWM), avec conversion de cette valeur 10 bits (via l’ADC de l’ATtiny) en un rapport cyclique 0 à 100% pour l’affichage, et 0 à valeur max du timer préalablement définie, pour atteindre la fréquence PWM souhaitée
  • et la mise à jour de l’écran OLED en fonction de ce qui a été précédemment relevé

En clair, outre l’initialisation, on va lire l’état du bouton-poussoir START/STOP et la position du potentiomètre, pour générer ou non un signal PWM, avec un affichage clair sur écran OLED !

Bon, trêve de blabla ! Et voyons sans plus tarder ce code/programme ATtiny (écrit sous Arduino IDE, pour ma part) :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_) |  ___| | | |                 (_) |  [_| |__  ___  ___ _  ___  _ __ | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___ |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \ | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__ |\__,_|\___| | |
                                                                                      \_|
  Fichier :       prg-carte-ChargeElectronique5v1a.ino
  
  Description :   Programme permettant de gérer une charge électronique 5V/1A max,
                  à partir d'un ATtiny, avec courant réglable par potentiomètre entre 0 et 100% (1A)

  Important :     Il faudra "régler" la fréquence CPU de l'ATtiny à 8 Mhz/interne, au moment de sa programmation

  Remarques :     - l'alimentation sera prise sur la prise USB-A à charger/tester (ce qui se rajoutera à la charge, même si c'est pas énorme !)
                  - le brochage de l'ATtiny824 est accessible ici :
                    https://github.com/SpenceKonde/megaTinyCore/blob/master/megaavr/extras/ATtiny_x24.md
                  - les labels de l'ATtiny824 pour megaTinyCore sont disponibles ici :
                    https://github.com/SpenceKonde/megaTinyCore/blob/master/megaavr/extras/ioheaders/iotn824.h
                  - megaTinyCore doit être installé sur votre IDE Arduino ; pour plus d'infos, voir ici :
                    https://passionelectronique.fr/convertisseur-usb-updi-ch340n/#partie-logicielle-installation-du-megatinycore-sur-lide-arduino-indispensable
                  - ce projet se veut éducatif avant tout (génération de signal PWM sur ATtiny) ; ne l'utilisez pas de manière prolongée, ou commerciale

  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Licence :       BY-NC-ND 4.0 CC (https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr)
  Créé le :       28.05.2025

*/

// Inclusion des librairies nécessaires
// #include <Wire.h>            // Rien à installer ici, car déjà inclus dans le "megaTinyCore" (nécessaire pour le I2C)
#include <Tiny4kOLED.h>         // Nécessite l'installation de la librairie "Tiny4kOLED" de Stephen Denne (GitHub, pour info : https://github.com/datacute/Tiny4kOLED)

// Définition des broches pilotées manuellement
#define BROCHE_PILOTAGE_MOSFET                    PIN_PA3   // La grille du mosfet permettant de contrôler la charge, entre 0 et 1A, sera reliée à cette broche
#define BROCHE_RECEVANT_BP_START_STOP             PIN_PA5   // Le bouton-poussoir "Start/Stop" sera relié à cette broche (appui = mise à la masse ; il faut donc activer la pull-up interne du µC)
#define BROCHE_RECEVANT_POTENTIOMETRE             PIN_PA7   // Le potentiomètre de réglage PWM (entre 0 et 100%) sera relié à cette broche

// Constantes
#define DELAI_ANTI_REBOND_POUR_BPS                50        // Durée en millisecondes (ms) d'anti-rebond pour le bouton poussoir
#define NBRE_DE_LECTURE_REPETEE_SUR_ADC           10        // Nombre d'échantillons lus à chaque fois, histoire de lisser/moyenner la valeur relevée au niveau du potentiomètre
                                                            // (attention : 1 lecture se fait sur 10 bits, donc une valeur entre 0 et 1023, et on stockera ça plus loin dans
                                                            // une variable 16 bits, pouvant contenir des nombres allant de 0 à 65535 ; ainsi, on ne pourra pas stocker plus
                                                            // de 65536/1024 soit 64 échantillons cumulés, pour en faire une moyenne ensuite) - Valeur : 1 à 64 ici, donc !
// Variables
uint8_t rapportCycliqueSignalPwm;
bool chargeActive;

// Instanciation de l'écran OLED (adresse I2C = 0x3C)
// (on a rien à faire ici, car tout est géré par la librairie Tiny4kOLED ; en fait, il faudra appeller l'objet "oled" dans notre code, pour piloter l'écran oled)


// ========================
// Initialisation programme
// ========================
void setup() {

  // ----------------------------
  // Initialisation des variables
  // ----------------------------
  rapportCycliqueSignalPwm = 0;
  chargeActive = false;


  // ---------------------
  // Initialisation du PWM
  // ---------------------
  // Nota 1 : on va utiliser le compteur TCA0 avec WO3 pour générer un signal PWM sur la pin PA3 (selon datasheet du fabricant)
  // Nota 2 : on va partir sur les paramètres de base suivants :
  //              → on va faire tourner l'ATtiny à 8 MHz (F_CPU)
  //              → on va mettre le prescaler en division d'horloge par 8 (Prescaler)
  //              → on va choisir une fréquence PWM de 4 kHz (F_PWM)
  // Nota 3 : d'après le datasheet, la formule donnant la fréquence PWM est la suivante :
  //              Freq_PWM = F_CPU / (Precaler * (TOP + 1))
  //              d'où TOP = (F_CPU / (Freq_PWM * Prescaler)) - 1
  //              Dans notre cas, on obtient TOP = 249, en décimal
  // Nota 4 : selon le datasheet, toujours :
  //              → W03 (waveform output 3) est raccordé sur PA3
  //              → WO3 est accessible en "split mode" (CTRLD) depuis le timer TCA0 (ce timer 16 bits est divisé en 2, et W03 correspond à la partie 8 bits "haute")
  //              → En split mode, on travaille avec le "haut" des registres (HPER, HCNT, HCMP, ...)
  //              → WO3 correspond en fait à du WO[n+3] ; il utilise donc les registres CMP0, CMP1, CMP2 pour WO3, WO4, et WO5 (respectivement 0 +3, 1 +3, 2 +3)
  //              → WO3 utilise donc HPER (pour la période PWM) et HCMP0 (pour le rapport cyclique), du signal PWM à générer
  TCA0.SPLIT.CTRLD = TCA_SPLIT_SPLITM_bm;                                 // Activation du "Split Mode"
  TCA0.SPLIT.HPER = 249;                                                 // TOP = 249 (pour obtenir une fréquence PWM de 4kHz, comme vu ci-dessus)
  TCA0.SPLIT.HCMP0 = 0;                                                   // Duty cycle initial = 0                         
  TCA0.SPLIT.CTRLB = TCA_SPLIT_HCMP0EN_bm;                                // Activation du comparateur "haut" de CMP0
  TCA0.SPLIT.CTRLA = TCA_SPLIT_CLKSEL_DIV8_gc | TCA_SPLIT_ENABLE_bm;      // Prescaler à 8 (division de fréquence d'horloge CPU) + activation du timer A
  pinMode(BROCHE_PILOTAGE_MOSFET, OUTPUT);                                // Activation de la sortie PA3
                                                                          // Nota : on aurait pu écrire : PORTA.DIR |= PIN3_bm;   (mais ce serait moins parlant !)

  // -----------------------------------------
  // Initialisation bouton-poussoir START/STOP
  // -----------------------------------------
  pinMode(BROCHE_RECEVANT_BP_START_STOP, INPUT_PULLUP);                   // On active la pull-up interne de l'ATtiny (car le BP met à la masse cette entrée, lorsqu'appuyé)


  // ------------------
  // Initialisation ADC
  // ------------------
  analogReference(VDD);                           // Référence interne pour l'ADC de l'ATtiny (https://github.com/SpenceKonde/megaTinyCore/blob/master/megaavr/extras/Ref_Analog.md)
  analogRead(BROCHE_RECEVANT_POTENTIOMETRE);      // Première lecture “dans le vide”, pour initialiser/stabiliser le circuit interne ADC


  // ------------------------------
  // Initialisation de l'écran OLED
  // ------------------------------
  oled.begin();                                   // Envoi de la séquence d'initialisation à l'écran OLED (nota : l'écran reste éteint, à ce stade)
  oled.setFont(FONT6X8);                          // Choix possibles : FONT6X8, FONT8X16, FONT8X16DIGITS, FONT6X8P, FONT8X16P, FONT8X16CAPS, FONT8X16CAPSP
  oled.clear();                                   // Efface la mémoire avant d'allumer l'écran
  oled.on();                                      // Allume l'écran
  oled.switchRenderFrame();                       // Bascule la moitié de la RAM sur laquelle on va écrire, pour qu'elle soit la moitié qui n'est pas affichée actuellement


  // ----------------------------------------------------------------
  // Petite pause avant de passer à la suite (boucle sans fin "loop")
  // ----------------------------------------------------------------
  delay(200);

}


// =================
// Boucle principale
// =================
void loop() {

  lit_et_gere_etat_bouton_poussoir_START_STOP();            // Relève l'état du bouton-poussoir, et agit en conséquence
  lit_potentiometre_et_definit_rapport_cyclique_PWM();      // Relève la valeur du bouton-poussoir, et calcule/fixe le rapport cyclique (PWM duty cycle)
  met_a_jour_ecran_OLED();                                  // Met à jour les données affichées sur l'écran OLED
  delay(50);                                                // Pause délai, avant de reboucler

}



// ======================================================
// Fonction : lit_et_gere_etat_bouton_poussoir_START_STOP
// ======================================================
void lit_et_gere_etat_bouton_poussoir_START_STOP() {

  // Gestion de l'état du bouton Start/Stop
  static bool etat_precedent_bp_start_stop = HIGH;                                  // Mémorisation de l'état précédent (static permet de "mémoriser" la valeur dans cette fonction)
  bool etat_actuel_bp_start_stop = digitalRead(BROCHE_RECEVANT_BP_START_STOP);      // Lecture de l'état actuel

  // Traitement
  if (etat_actuel_bp_start_stop == LOW && etat_precedent_bp_start_stop == HIGH) {   // Bouton-poussoir actif à l'état bas, pour rappel
    chargeActive = !chargeActive;           // "Inversion" de l'état en cours du chargeur (ON ou OFF, si vous préférez)
    delay(DELAI_ANTI_REBOND_POUR_BPS);      // Anti-rebond logiciel, tout ce qu'il y a de plus simple
  }
  etat_precedent_bp_start_stop = etat_actuel_bp_start_stop;

}


// ============================================================
// Fonction : lit_potentiometre_et_definit_rapport_cyclique_PWM
// ============================================================
void lit_potentiometre_et_definit_rapport_cyclique_PWM() {

  // -------------------------------------------------------------
  // Lecture de plusieurs échantillons sur l'ADC (moyenne/lissage)
  // -------------------------------------------------------------
  uint16_t valeur_ADC_10_bits = 0;
  for (uint8_t index_lecture_ADC = 0; index_lecture_ADC < NBRE_DE_LECTURE_REPETEE_SUR_ADC; index_lecture_ADC++) {
    valeur_ADC_10_bits += analogRead(BROCHE_RECEVANT_POTENTIOMETRE);              // Addition des X échantillons pris
  }
  valeur_ADC_10_bits /= NBRE_DE_LECTURE_REPETEE_SUR_ADC;                          // Et division par le nombre d'échantillons pris (X), pour sortir une valeur moyenne

  // --------------------------------------------
  // Calcule du rapport cyclique (en pourcentage)
  // --------------------------------------------
  rapportCycliqueSignalPwm = map(valeur_ADC_10_bits, 0, 1023, 0, 100);            // Passage de 10 bits (0 à 123) à une valeur 8 bits (contrainte entre 0 et 100,
                                                                                  // pour exprimer un pourcentage)

  // -------------------------------------------------------------------------------------------------
  // Met à jour le comparateur du timer, fixant ainsi le rapport cyclique du signal PWM via le timer A
  // -------------------------------------------------------------------------------------------------
  if (chargeActive) {
    // PWM actif
    TCA0.SPLIT.HCMP0 = map(valeur_ADC_10_bits, 0, 1023, 0, TCA0.SPLIT.HPER);        // Contraint la valeur 0~1023 en 0~PER (le PER étant défini plus haut, et
  } else {                                                                          // vaut 249 pour faire du 4 kHz PWM avec prescaler en DIV8 avec F_CPU = 8 MHz)
    // PWM stoppé
    TCA0.SPLIT.HCMP0 = 0;         // Mise à zéro du rapport cyclique, pour arrêter le signal PWM
  }

}


// ================================
// Fonction : met_a_jour_ecran_OLED
// ================================
void met_a_jour_ecran_OLED() {

  // Effaçage de l'écran
  oled.clear();

  // Affichage pourcentage rapport cyclique signal PWM
  oled.setCursor(0, 0);
  oled.print(F("Rapport PWM = "));
  oled.print(rapportCycliqueSignalPwm);
  oled.print(F(" %"));

  // Affichage de l'état de la charge électronique (allumée ou éteinte, pour ainsi dire)
  oled.setCursor(0, 1);
  oled.print(F("Etat = "));
  if (chargeActive)  oled.print(F("ON"));
  if (!chargeActive) oled.print(F("OFF"));

  // Affichage du courant théorique soutiré par cette charge électronique
  oled.setCursor(0, 2);
  oled.print(F("Courant = "));
  if (chargeActive) oled.print((float)rapportCycliqueSignalPwm * 0.01, 2);          // Comme 100% PWM signifie 1A de courant
  if (!chargeActive)  oled.print(F("0.00"));
  oled.print(F(" A"));

  // Affichage de la puissance théorique soutirée par cette charge électronique
  oled.setCursor(0, 3);
  oled.print(F("Puissance = "));
  if (chargeActive) oled.print((float)rapportCycliqueSignalPwm * 0.05, 2);          // Comme 100% PWM signifie 5W de puissance (1 ampère sous 5 volts, pour rappel)
  if (!chargeActive)  oled.print(F("0.00"));
  oled.print(F(" W"));

  // Permute la moitié de la RAM sur laquelle l'écriture a été effectuée, avec celle qui était affichée
  // (remarque : cela équivaut à appeler à la suite switchRenderFrame et switchDisplayFrame)
  oled.switchFrame();

}

Pour que ce soit le plus clair possible, je vous ai mis un maximum de commentaires dans ce programme, afin que vous puissiez comprendre comment est paramétré le timer TCA0 et la sortie d’onde WO3 afin de sortir un beau signal PWM sur la broche PA3 de l’ATtiny ! Si vous souhaitez plus d’infos à ce niveau, n’hésitez pas à consulter le datasheet de l’ATtiny824 (je vous mettrai un lien tout en bas, dans la partie « Liens utiles et téléchargements » de cet article).

Du reste, si vous compilez ce code dans l’IDE Arduino, voici ce que ça donne :

Le croquis utilise 5601 octets (68%) de l'espace de stockage de programmes. Le maximum est de 8192 octets.
Les variables globales utilisent 123 octets (12%) de mémoire dynamique, ce qui laisse 901 octets pour les variables locales. Le maximum est de 1024 octets.

Remarque importante : n’activez surtout pas la charge électronique (en appuyant sur le bouton START/STOP) lorsque celle-ci est alimentée via le programmateur d’ATtiny (convertisseur USB/UPDI), ou via une prise USB qui ne saurait fournir à minima 1A de courant ! Sinon vous risqueriez de tout endommager, avec toutes les conséquences qui s’en suivraient. Donc faites très attention, à ce niveau !

Cela étant dit, passons à présent à la programmation de l’ATtiny, physiquement parlant cette fois-ci !

Upload du programme dans l’ATtiny (en utilisant un convertisseur USB/UPDI)

Alors, pour programmer l’ATtiny824 figurant sur cette carte électronique, il faudra utiliser un convertisseur USB/UPDI pour faire le lien entre votre ordi et ce PCB. Pour ce faire, de mon côté, j’utilise le convertisseur USB→UPDI fait maison, que je vous avais présenté il y a peu. Il se branche très simplement, via le connecteur réservé à cet effet, comme visible ci-dessous (la prise USB du dessus allant vers l’ordi) :

Remarque : je ne l’ai pas précisé ici, mais il faudra bien évidemment retirer temporairement l’écran OLED, le temps de la programmation de l’ATtiny. Pour info, j’ai placé le connecteur de programmation sous l’écran oled pour 2 raisons :
– pour économiser la place sur la carte, en le « cachant » sous l’afficheur OLED
– pour servir de support « anti-casse » à l’écran OLED, en reposant quasiment dessus ; ainsi, si jamais par mégarde vous appuyez sur le devant/bas de l’écran oled, celui-ci aura une chance de ne pas se casser au niveau de son connecteur supérieur, en trouvant appuie sur ce connecteur de programmation ! Tout simplement 😉

Et une fois les branchements faits, il ne restera plus qu’à ouvrir l’IDE Arduino, sélectionner les bons paramètres de programmation (cf. ci-dessous), compiler/uploader le programme !

Pour rappel, il faudra que « megatinycore » soit préalablement installé sur votre ordi. Pour ceux qui ne sauraient pas de quoi je parle, je vous renvoie vers un article où j’explique comment installer megatinycore sur l’IDE Arduino.

Pour info, pour ce projet en particulier (tous sont différents, utilisant des µC ATtiny ou configs différentes), voici les paramètres à sélectionner avant programmation (dans le menu « Outils » de Arduino IDE) :

• Carte : sélectionnez « ATtiny3224/1624/1614/1604/824/814/804/424/414/404/214/204 »
• Port : sélectionnez le port correspondant au convertisseur USB/UPDI, une fois branché sur votre ordi (ce convertisseur est, pour rappel, la carte de programmation visible verticalement, sur la photo précédente) ; dans mon cas, il s’agissait ici du port « COM3 » (ce sera fort probablement différent chez vous)
• Chip : « ATtiny824 » (car c’est ce modèle de microcontrôleur là que nous avons mis en œuvre dans cette charge électronique USB)
• Clock : « 8 MHz internal » (TRÈS IMPORTANT, CAR CELA VA CONDITIONNER LA FRÉQUENCE DU SIGNAL PWM GÉNÉRÉ). Basiquement, on aurait pu sélectionner n’importe quelle autre fréquence interne, comprise entre 1 et 20 MHz ; mais seule la fréquence CPU de 8 MHz est adaptée pour fournir un signal PWM de 4 kHz en sortie, aux vues du code arduino qui a été écrit (en clair : si vous utilisez une fréquence CPU différente, alors la fréquence PWM variera en conséquence)
• Programmeur : « SerialUPDI – Slow : 57600 baud », le convertisseur USB → UPDI étant effectivement un convertisseur série (nota : je vous recommande de programmer à cette vitesse « lente » de 57600 bauds, pour éviter les erreurs de transmission, au moment de l’upload du programme)

Du reste, il vous suffira ensuite de retirer le convertisseur USB-UPDI du pcb de la charge électronique une fois le programme uploadé, et de remettre l’écran OLED en place pour la suite 😉

Dans tous les cas, je le répète : ne mettez surtout pas la charge électronique en route (en appuyant sur le bouton poussoir), si c’est le convertisseur USB/UPDI qui fournit l’énergie à la charge électronique (ou tout autre alim USB, qui ne saurait fournir à minima 1 ampère) ; sinon, vous risquez d’endommager bon nombre de composants, voire pire. Restez donc très vigilant, à ce niveau !

Test de fonctionnement de la charge PWM de 0 à 1A (électrique et thermique)

Tout d’abord, voici comment se présente cette charge électronique USB, lorsqu’on la branche sur un adaptateur secteur (pour info, j’ai pris un vieux chargeur de téléphone 230V/5V, pouvant délivrer jusqu’à 2A) :

On peut déjà observer 2 choses :

• au démarrage, la charge électronique est sur « OFF »  (ce qui fait qu’elle ne consomme aucun courant, ni aucune puissance, tant que vous ne l’aurez pas démarrée, en appuyant sur le bouton « START/STOP » du PCB)
• le « Rapport PWM » correspond au pourcentage de courant que cette charge électronique va tirer, si vous la mettez en route (en sachant qu’à 0% elle consommera 0 ampère, et qu’à 100% elle consommera 1A)

À présent, pour la démarrer, vous devrez :

• sélectionner le pourcentage de charge que vous souhaitez (entre 0 et 100%), via le potentiomètre « PWM 0-100 % » présent sur PCB (comme vous l’aurez compris, cela fera varier de 0 à 100 % du rapport cyclique du signal PWM, et donc de 0 à 1A le courant soutiré)
• et appuyer sur le bouton « START/STOP » figurant sur le PCB, pour activer cette charge électronique

Une fois fait, l’affichage du courant et puissance consommés se fera à l’écran, comme visible ci-dessous (exemples avec charge réglée à 20 et 100%) :

Comme vous pouvez le constater, à 20% nous avons bien 0,2A (soit 1W) de consommation, et à 100%, nous avons bien 1A (soit 5W) soutirés. Le courant et la puissance sont donc bien proportionnels au rapport cyclique PWM choisi, en sachant que le courant max est de 1A sous 5V.

Remarque très importante : ce montage va chauffer, d’autant plus que vous augmenterez la charge. Faites donc très attention à ne pas vous brûler, que ce soit au niveau du PCB ou des dissipateurs thermiques ! Parallèlement, ne laissez pas cette charge électronique allumée trop longtemps, car elle a été conçue à titre éducatif, et n’est donc pas optimisée.

Histoire d’illustrer l’échauffement de cette charge électronique 1A USB, voici des clichés pris lors d’un fonctionnement à pleine puissance, au bout d’une minute ou deux (attention, ça chauffe vite !) :

Vous devinerez je pense les ailettes des dissipateurs thermiques sur la 1ère photo. Cela vous montre à quel point il ne faut pas plaisanter ici, car la température atteint facilement les 80°C. Et sur la 2ème photo, vous apercevez en fait l’arrière du PCB, qui montre à quel point le circuit imprimé va chauffer également (dépassant allègrement les 70°C).

Nota : la caméra thermique utilisée ici est la caméra thermique KTI-W01 de chez Kaiweets (pouvant mesurer de -20°C à +550°C, avec une résolution de 256 x 192 pixels).

Au passage, le fait que le PCB s’échauffe autant n’est pas surprenant, du fait de la « forte » puissance à dissiper au niveau des résistances de puissance, et également du fait que ces résistances de puissances sont des CMS (montés en surface donc), et par conséquence, littéralement plaquées contre le PCB.

Du reste, voici quelques photos prises à l’occasion de mes essais, et montrant ici le signal PWM envoyé sur la grille du mosfet, pilotant les résistances de puissance :

Pour que ce soit le plus clair possible, j’ai augmenté la luminosité « au maximum », pour faire ressortir les données affichées sur l’oscillo. Ici, pour info, vous avez là des photos prises avec des charges respectives de :

• 7 % (soit 0,07A soit 0,35W)
• 22 % (soit 0,22A soit 1,10W)
• et 83 % (soit 0,83A soit 4,15W)

Pour chacun de ces ratio de charge, on constate que le rapport cyclique du signal PWM est bien proportionnel à la charge souhaitée. La fréquence PWM, quant à elle, est bien de 4 kHz, comme définie dans le code (ou presque, car cet oscillo portable n’est pas super précis !).

Liens utiles et téléchargements

Pour ceux que ça intéresse, je vous mets tout d’abord :

• le datasheet de l’ATtiny824 de chez Microchip
• le datasheet du mosfet AO3400A de chez Alpha & Omega

Ainsi, vous pourrez creuser toute la partie timer et PWM, si le cœur vous en dit !

Du reste, voici :

• le schéma électronique complet de cette charge électronique USB 5V/1A (format PDF)
• le lien pour faire fabriquer le PCB, si vous souhaitez le faire réaliser par PCBWay (fabricant de PCB)

POUR FAIRE FABRIQUER CE CIRCUIT IMPRIMÉ :
→ Cliquez sur le lien juste ci-dessus, pour ouvrir ce projet sur PCBWay
→ Cliquez sur « Add to cart », pour ajouter ce projet dans votre panier
→ Attendez 24/48h que les fichiers de ce projet soient vérifiés (PCBWay vous enverra un email une fois la vérification faite, ou sinon, surveillez simplement l’état des éléments dans votre panier)
→ Finalisez votre commande de circuit imprimé (en ajoutant un stencil, si souhaité)

Niveau coût de fabrication, ils sont vraiment bien placés ! Alors ne vous en privez pas !

Charge électronique USB 1A : conclusion !

Vous voici au terme de cet article, vous présentant un exemple de charge électronique USB réglable de 0 à 1A ! J’espère que vous aurez pu apprendre des choses ici (ATtiny, PWM, mosfet, …), et que tout cela puisse vous inspirer !

Pour ma part, cette charge électronique va me permettre de faire des tests de charge sur les alimentations portables avec accus lithium-ion 18650 que j’ai déjà créées, et d’autres à venir, plus élaborées ! Si cela vous intéresse, n’hésitez pas à vous inscrire à la newsletter, pour être averti de la parution des prochains articles 🙂

À très bientôt,
Jérôme.

À découvrir aussi : un anneau lumineux RGB piloté par ATtiny 212/412

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre, chers amis francophones !

(*) Mis à jour le 03/08/2025