Programmer un microcontrôleur ATtiny récent (série 0, 1, ou 2) en UPDI, avec ce convertisseur USB basé sur le chip CH340N, en utilisant l’IDE Arduino

Vous souhaitez utiliser des microcontrôleurs ATtiny récents dans vos projets (série 0, 1, ou 2), mais ne savez pas comment les programmer ? Surtout ne vous inquiétez pas ! Car je vous propose de découvrir ici un exemple de « mini programmateur d’ATtiny fait-maison », reposant sur un convertisseur USB/série bien connu : le CH340N. Ainsi, il sera possible de programmer n’importe quel ATtiny de dernière génération, programmable en UPDI 😉

Pour illustrer cela, nous verrons comment programmer un ATtiny à partir de l’IDE Arduino (avec le gestionnaire de carte « megaTinyCore » installé), à l’aide du « mini programmateur » que je vous présente ici (qui est ni plus ni moins qu’un convertisseur USB → UPDI, en fait !), avec un classique programme « blink », écrit en C++. Ça vous dit ? Alors en avant !

Remarque : ce programmateur USB/UPDI n’est utilisable que sur les microcontrôleurs pourvus d’une entrée UPDI, comme par exemple les ATtiny récents (ceux de la série 0 1 ou 2, du style ATtiny202, ATtiny814, ATtiny826, etc). Il ne pourra donc pas être utilisé sur des microcontrôleurs dépourvus de ligne UPDI, tels que les ATtiny plus anciens ATtiny13, ATtiny85, etc. Plus généralement, vous trouverez sur cette page Wikipédia une liste comparative des microcontrôleurs ATtiny, avec leurs caractéristiques et mode de programmation (ISP, UPDI, etc). N’hésitez pas à vous y référer, car c’est très utile, vous verrez !

Comment programmer un ATtiny dernière génération (série 0-1-2) ?

Si vous souhaitez graver un programme dans un ATtiny (microcontrôleur de chez ATmel, désormais racheté par Microchip), alors il vous un outil de programmation (tant au niveau logiciel, que matériel).

Côté logiciel, vous avez le choix entre l’IDE Arduino, Visual Studio Code, ou tout autre environnement de développement adéquat ! Perso, j’utilise Arduino IDE pour écrire et uploader les programmes C++ à destination des ATtiny, mais vous êtes libre de faire autrement 😉

Côté matériel, les ATtiny de dernière génération (c’est à dire ceux de série 0, série 1, ou série 2) se programment nativement via l’UPDI (de l’anglais « Unified Program and Debug Interface ») ; l’UPDI étant accessible sur une broche spécifique de l’ATtiny (souvent confondue avec la broche /RESET, pour info !). Et c’est sur cette broche UPDI qu’il nous faudra brancher un programmateur d’ATtiny, pour programmer le microcontrôleur depuis son PC (le programmateur s’insérant en fait entre son ordi et l’ATtiny à programmer). Du reste, le programmateur en lui-même peut se réduire à un simple convertisseur USB/UDPI, comme c’est le cas ici, avec la carte/projet électronique que je vous propose de découvrir ici !

Si je résume, programmer des ATtiny se fait tout simplement à l’aide :

• d’un logiciel (type VScode ou Arduino IDE, par exemple)
• d’un matériel approprié (d’une carte électronique comme celle présentée ici, par exemple, pour faire le lien entre votre PC et l’ATtiny)

Maintenant que nous avons vu ces généralités, entrons un peu plus dans le détail !

Nota : l’UPDI est un mode de programmation natif pour ATtiny et autres microcontrôleurs, développé par Microchip. À noter que ce mode de programmation ne nécessite pas de bootloader ; ce qui économise pas mal de place mémoire, qui manque d’ailleurs cruellement à nos « petits atTiny » ! Bien entendu, il sera toujours possible d’uploader un bootloader dans vos ATtiny, pour ensuite les programmer d’une autre manière, si l’espace mémoire est suffisant !

Remarque : le « programmateur d’ATtiny » que je vous partage ici n’est pas le seul moyen de programmer un ATtiny. En effet, vous pourriez très bien faire cela en utilisant un Atmel-ICE (comptez pas moins de 150 euros, par contre !), ou en utilisant une carte Arduino + quelques composants autour (ce qui n’est pas vraiment commode en pratique, car les contacts via fils dupont « mobiles » peuvent générer certains défauts de transmission). En fait, ici, je vous propose un exemple de mini carte PCB pour programmer vos ATtiny en toute simplicité, sans avoir à sortir beaucoup d’argent, ni faire de la bidouille 😉

Liste des ATtiny programmables avec ce convertisseur USB → UPDI

Comme vu précédemment, le programmateur d’ATtiny que nous allons voir ici est une passerelle entre la prise USB de votre PC, et la broche UPDI de votre ATtiny. Et pour cela, bien évidemment, il faudra que votre ATtiny dispose d’une telle broche, pour être programmé ainsi ! Mais rassurez-vous, car c’est le cas de tous les ATtiny récents, c’est à dire ceux de la série 0, série 1, et série 2.

Du coup, comment savoir si l’ATtiny qu’on prévoit d’utiliser est bien un de la série 0, 1, ou 2, en pratique ? Eh bien c’est tout simple, car pour cela, il suffit d’examiner sa référence (qui contient le numéro de sa série, au milieu !). Voici une image qui vous aidera à y voir plus clair :

Maintenant que vous savez comment reconnaître un ATtiny de série 0-1-2, voici une liste des ATtiny programmables avec ce convertisseur USB UPDI (non exhaustive) :

• ATtiny de « Série 0 » :
  • ATtiny202 / ATtiny402
  • ATtiny204 / ATtiny404 / ATtiny804 / ATtiny1604
  • ATtiny406 / ATtiny806 / ATtiny1606
  • ATtiny807 / ATtiny1607
• ATtiny de « Série 1 » :
  • ATtiny212 / ATtiny412
  • ATtiny214 / ATtiny414 / ATtiny814 / ATtiny1614
  • ATtiny416 / ATtiny816 / ATtiny1616 / ATtiny3216
  • ATtiny417 / ATtiny817 / ATtiny1617 / ATtiny3217
• ATtiny de « Série 2 » :
  • ATtiny424 / ATtiny824 / ATtiny1624 / ATtiny3224
  • ATtiny426 / ATtiny826 / ATtiny1626 / ATtiny3226
  • ATtiny427 / ATtiny827 / ATtiny1627 / ATtiny3227

Pour plus d’infos sur ces chips, je vous renvoie vers l’excellente page Wikipédia à ce sujet, détaillant les ATtiny des séries 0/1/2, avec leurs principales caractéristiques techniques. N’hésitez pas à y faire un saut, au besoin !

Comment allons nous utiliser ce « programmeur d’ATtiny », en pratique ?

Comme évoqué en ce début d’article, le programmateur d’ATtiny que je vous propose de découvrir ici se placera entre votre ordi, et l’ATtiny à programmer :

• Côté ordi, la connexion se fera sur une simple prise USB
• Coté ATtiny, la connexion se fera via un connecteur 3 broches (Vcc, Updi, Gnd)

Voici ce que ça donne, schématiquement parlant :

À noter que si votre ATtiny à programmer est déjà soudé sur une carte électronique, et que cette carte permet d’accueillir ce connecteur à 3 broches, tout ira pour le mieux ! Par contre, si vous souhaitez programmer un ATtiny « en dehors » de tout PCB, alors il vous faudra un adaptateur amovible de type ZIF (« Zero Insertion Force »), pour accéder à ses broches, pour ne pas avoir à mettre de la soudure sur ses pattes, ni risquer d’endommager ces dernières. Du coup, idéalement, il faudra que la carte électronique « ciblée » dispose d’un connecteur adapté à ce programmateur d’ATtiny, pour faire simple !

À présent, entrons encore plus dans les détails, et voyons l’intérieur-même de ce programmateur d’ATtiny 🙂

Schéma électronique de ce programmateur (autour du convertisseur série CH340N)

Comme évoqué en intro, d’un point de vue matériel, ce « programmateur d’ATtiny » n’est en fait qu’un convertisseur USB / UPDI. Pour faire une telle conversion, nous utiliserons ici la puce CH340N (qui est un convertisseur USB vers UART), à laquelle nous ajouterons quelques composants additionnels (pour finaliser la conversion, de UART vers UPDI). En clair, le montage fera une conversion USB → (UART) → UPDI, afin de pouvoir programmer les ATtiny.

Cela étant vu, voici à présent ce que ça donne, du point de vue schéma électronique :

Au niveau du schéma de ce programmeur d’ATtiny, on retrouve :

• un bloc d’alimentation, qui récupère le +5V provenant de l’entrée USB (en générant au passage une tension complémentaire de 3,3 volts, pour permettre à ce programmateur de pouvoir sortir du +5V ou +3,3V, à destination des ATtiny)
• un bloc « switch de tension de sortie », composé d’un simple interrupteur à glissière, afin de pouvoir choisir entre du 5 volts ou du 3,3 volts en sortie
• un bloc témoin d’alimentation, pour indiquer à l’utilisateur que la carte fournit bel et bien une tension en sortie
• un bloc convertisseur USB → UART, reposant essentiellement sur la puce CH340N (puisqu’il s’agit d’un convertisseur USB/UART)
• un bloc convertisseur UART → UPDI, reposant sur 2 composants seulement, suivant les préconisations partagées par Spence Konde sur GitHub
• un bloc de sortie UPDI, composé d’un simple connecteur à 3 broches (permettant de délivrer du 3,3 ou 5V selon la tension choisie, la ligne de signaux UPDI, et la masse)

Pour ceux que ça intéresse, voici quelques remarques, justifiant l’usage/dimensionnement des composants alentours :

• C1 et C2 (de 10 µF chacun) sont des condensateurs de filtrage (placé en amont et en aval du régulateur 3,3V)
• C3 et C4 (de 100 nF chacun) sont des condensateurs de découplage, pour la puce CH340 N
• R1 (de 10 kohms) est une résistance de limitation de courant pour la LED « sous-tension » ; libre à vous de prendre une valeur de résistance plus faible, afin que la led brille plus fort !
• D1 (une BAT 54) est une diode schottky « ultra rapide », qui, avec la résistance R2 (de 470 ohms), permettent de faire la conversion UART/UPDI, suivant les notes relayées par Spence Konde (cf. lien juste au-dessus)

Du reste, voici la liste de tous les composants utilisés ici, avec un lien si vous souhaitez les acheter, à titre indicatif :

Qté	Désignation	Lien achat
2	Condensateur 10µF / 25V (format CMS, 1206)
2	Condensateur 100nF (format CMS, 1206)
1	Diode schottky ultra-rapide BAT54 GWX (format CMS, SOD-123)
1	LED verte, ou toute autre couleur (format CMS, 1206)
1	Résistance 10K ohms (format CMS, 1206)
1	Résistance 470 ohms (format CMS, 1206)	(idem)
1	Régulateur de tension AMS1117-3.3 (format CMS, SOT223)
1	Puce CH340N (format CMS, SOP-8)
1	Interrupteur à glissière MSS-22D18 (format CMS)
1	Connecteur USB de type A, horizontal 90° (format traversant)
1	Connecteur header/mâle à 3 broches (format traversant)
1	Circuit imprimé PCB (dont vous trouverez, en fin d’article, le fichier Gerber zippé, si vous souhaitez reproduire ce projet à l’identique)	–

Maintenant que nous avons vu ce schéma en détail, passons au circuit imprimé, issu de ce schéma !

Remarque technique : juste pour info, pour ceux que ça intéresse, l’UPDI est ni plus ni moins qu’une interface de communication UART à 1 fil ; elle est très spécifique, et vraiment différente des communications UART habituelles, qui elles, reposent sur 2 fils (RX et TX, pour la réception et la transmission de données).

Partie matérielle : circuit imprimé PCB (soudage fer à souder / air chaud)

Le circuit imprimé (PCB) de ce programmateur d’ATtiny est somme toute assez simple, et de petite taille. En effet, le routage tient sur 2 couches (essentiellement pistes à l’avant et plan de masse à l’arrière), et le PCB en lui-même ne mesure que 4cm de long, sur 2cm de haut environ.

Voici d’ailleurs à quoi il ressemble, avant soudage des composants :

Côté composants, on retrouve :

• 2 composants traversants seulement (le connecteur USB d’alim d’un côté, et le connecteur pinHeader de sortie de l’autre)
• le reste étant des composants montés en surface (CMS)

Côté soudage, libre à vous de le faire au fer à souder (à panne fine), ou au pistolet à air chaud, ou sur plaque chauffante (mais je ne sais pas si cette dernière façon de faire est très professionnelle !). Perso, j’ai procédé de ces 3 façons, afin de vérifier si tout était bon. Je vous partage d’ailleurs si après la version soudée au fer, et celle faite avec la station à air chaud.

Soudage au fer à souder

Particularité de ce circuit imprimé : les pastilles des CMS sont volontairement larges, permettant ainsi de faire les soudures au fer à souder (idéal si vous débutez en électronique, et n’avez qu’un fer à souder sous la main !).

Voici d’ailleurs ce que le soudage au fer à souder a donné, de mon côté :

Comme vous pouvez le remarquer, les soudures sont un peu trop chargées en étain, au niveau des composants CMS (du fait que je n’ai pas pris une panne suffisamment fine, pour ce type de travail). Mais dans l’absolu ce n’est pas important, du moment que tout fonctionne 😉

Pour info, voici le matériel utilisé ici, pour ce faire :

• 1 x fer à souder Kaiweets rapide (65 watts, avec 6 pannes incluses)
• 1 x support de circuit imprimé 360° (rotatif/verrouillable)

Remarque : depuis tout à l’heure, je parle de « soudage », parce que c’est le terme qu’on emploie le plus couramment en électronique-loisir. Mais pour être plus précis, il faut savoir que ce terme n’est pas vraiment approprié, du fait qu’on ne fait pas fusionner les matériaux entre eux (pastilles du PCB et corps des composants électroniques, j’entends). Dans notre cas, il y a un métal d’apport extérieur (composé d’étain) pour « faire coller » les matériaux entre eux. Le bon terme (celui qu’il faudrait employer) est le « brasage », et non le soudage. Mais comme tout le monde parle de « soudure à l’étain », je vais faire de même, afin de ne pas vous perdre 😉

Soudage au pistolet à air chaud (pour les CMS)

Autre méthode utilisée ici : le soudage à l’air chaud (pour la partie CMS uniquement, bien entendu). Pour ce faire, j’ai utilisé de la pâte à braser basse température, et des pinces brucelle pour mettre en place les composants, ainsi qu’une petite station à air chaud, réglable aussi bien en température qu’en vitesse de soufflage.

Bien entendu, les connecteurs USB et pin-header restants ont été soudés au fer à souder, après soudage des CMS au pistolet à air chaud !

Voici ce que ça donne, en images :

Comme vous pouvez le constater, les soudures sont bien plus propres et moins chargées au pistolet à air chaud (comparé à la méthode précédente, où les CMS étaient soudés au fer à souder). À noter que ces soudures CMS auraient encore pu être améliorées, si j’avais utilisé un pochoir (stencil, en anglais), pour appliquer la quantité « optimale » de soudure sous chaque composant ; mais bon, cela coûtant plutôt cher (pour un si petit projet, j’entends), j’ai fait sans !

Pour infos, voici les matériels que j’ai utilisé ici, pour la partie CMS :

• 1 x station à air chaud (avec débit d’air ajustable)
• 1 x pâte à braser basse température (sans plomb / température de fusion = 138 °C)
• 1 x pince à fermeture antistatique (courbée)
• 1 x lot de 3 pinces à ouverture, avec embouts céramiques (ici, lorsque vous « appuyez » sur la pince, elle s’ouvre ; et lorsque vous la relâchez, ce qu’elle tient être ses mâchoires reste serré !)

Bon, en voilà assez pour la partie matérielle ! Alors passons maintenant à la partie logicielle, sans plus attendre !

Partie logicielle : installation du « megatinycore » sur l’IDE Arduino (indispensable)

Pour la programmation des ATtiny, je vous propose d’utiliser l’IDE Arduino. À noter que, nativement, cet environnement de développement intégré (Arduino IDE) ne prend pas en charge les ATtiny. Du coup, il sera nécessaire d’installer une extension arduino supplémentaire, permettant d’ajouter cette prise en charge, afin de pouvoir programmer nos puces ATtiny avec cet IDE.

Ici, nous utiliserons l’extension « megatinycore », car c’est selon moi la plus connue et la plus documentée, concernant la programmation des ATtiny sous Arduino IDE. Bien évidemment, vous n’aurez pas à répéter cette opération d’installation à chaque fois, car une fois fait, votre IDE Arduino l’aura « en mémoire », et sera donc apte à programmer n’importe quel ATtiny, à l’avenir !

Pour ce faire : 3 étapes à suivre, que je vous détaille en suivant ! À suivre dans l’ordre, bien évidemment 😉

Nota : perso, j’utilise la version 1.8.18 de Arduino IDE, sous Windows 10 ; si vous utilisez une autre version d’Arduino IDE ou un autre système d’exploitation, il sera sûrement nécessaire d’adapter ce qui suit.

Étape 1/3 : ajout de l’URL du gestionnaire de carte ATtiny, dans les préférences de l’IDE Arduino

Première étape, somme toute assez simple : ajouter l’URL du « gestionnaire de carte ATtiny », dans vos préférences Arduino. Pour ce faire, il suffit d’ouvrir l’IDE Arduino, puis de cliquer sur le menu Fichier > Préférences. Une fenêtre s’ouvre à l’écran, avec notamment un champ nommé « URL de gestionnaire de cartes supplémentaires ». Dans ce champ, il suffira de copier/coller l’URL suivante : http://drazzy.com/package_drazzy.com_index.json (ou mettre un point virgule et ajouter ce texte à la suite, si vous avez déjà du texte saisi dans cette case).

Voici ce que ça donne, de mon côté :

Il ne reste plus qu’à cliquer sur « OK », pour enregistrer cette URL complémentaire, et valider ces changements.

Étape 2/3 : installation de « megatinycore », depuis le gestionnaire de cartes Arduino

Deuxième étape, installer l’extension « megatinycore », dans le gestionnaire de cartes Arduino. Pour ce faire, il suffit d’aller dans le menu Outils > Type de carte: xxx > Gestionnaire de carte. Visuellement, voici où cela se trouve, sur ma version d’IDE Arduino :

Une fenêtre s’ouvre alors à l’écran, avec un champ de recherche à renseigner. Dans ce champ de recherche, il suffit de taper « megaTinyCore » et d’appuyer sur la touche ENTRÉE de votre clavier, pour lancer la recherche. Une fois fait, le bon package devrait s’afficher à l’écran (au besoin, faire défiler les résultats de la recherche vers le bas, si ce package n’apparaît pas en premier), comme visible ci-après :

Surtout, vérifiez bien qu’il s’agisse de la version réalisée « by Spence Konde », puis cliquez sur « Installer », pour lancer l’installation du package dans Arduino IDE.

Important : cela peut prendre BEAUCOUP de temps, pour télécharger/installer cette extension arduino. Alors soyez patient, et surtout, ne fermez aucune fenêtre 😉

Une fois cet add-on installé, vous devriez voir la mention « INSTALLED », notée à droite du numéro de version de cette extension arduino. Voici ce que ça donne, de mon côté :

À présent, vous pouvez fermer cette fenêtre, afin d’aller vérifier que tous les ATtiny soient bien listés. Pour ce faire, il suffit de re-cliquer sur le menu Outils > Type de carte, et vérifier qu’un menu « megaTinyCore » est désormais bien présent, et qu’à l’intérieur de celui-ci figure bien un sous-menu avec la liste de « familles d’ATtiny » sélectionnables.

Voici un aperçu de ce que j’obtiens, à mon niveau :

À noter que si vous sélectionnez une famille d’ATtiny en particulier, le menu Outils est automatiquement mis à jour, avec tous les paramètres concernant la famille de microcontrôleurs sélectionnés.

Par exemple, si vous sélectionnez les modèles « ATtiny412/402/212/202 », le menu « Chip » en suivant vous permettra de choisir l’un des quatre modèles de cette famille (412, 402, 212, ou 202). Vous aurez également la possibilité de choisir la fréquence de fonctionnement de cette puce, via la ligne-menu en dessous (« Clock ») ; ainsi, vous pourrez cadencer votre µC de 1 à 20 MHz, sur oscillateur interne, externe, ou autre !

Étape 3/3 : sélectionner le programmateur « SerialUPDI »

Enfin, dernière étape, il faudra sélectionner le « bon » programmateur. Ici, afin de pouvoir programmer les ATtiny avec notre convertisseur USB UPDI, il faudra prendre le programmateur « SerialUPDI », sélectionnable dans le menu Outils > Programmateur, comme visible ci-dessous :

À noter qu’il y a ici plusieurs lignes commençant par « SerialUPDI ». Perso, j’ai testé avec succès les programmateurs suivants (les autres entraînant souvent des bugs de communication, dû à la vitesse trop élevée) :

• SerialUPDI – SLOW : 57600 baud (fonctionne de manière « sûre », mais à vitesse quelque peu réduite)
• SerialUPDI – 230400 baud w/write delay, 2.7V+ (fonctionne quasiment toujours, à quelques exceptions près, mais bien plus rapide que le « slow » !)

À vous de faire des essais pour vous ce qui fonctionne le mieux de votre côté, en fonction de votre système d’exploitation et autre !

Voilà ! Nous sommes à présent fin prêt, pour programmer notre premier ATtiny 🙂

Nota 1 : je ne l’ai pas noté ici, mais il faudra bien évidemment sélectionner le « bon » port de communication de votre ATtiny ; dans mon cas, comme visible sur l’image précédente, il s’agit du port COM3. Normalement, il devrait être automatiquement sélectionné ; mais parfois, il faut le faire manuellement …

Nota 2 : je ne vous ai pas détaillé tous les paramètres disponibles pour chaque microcontrôleur (StartupTime, BOD, WDT, PWM, interruptMode, …), au niveau du menu Outils de l’IDE Arduino. Sinon… ça serait trop long ! Du reste, ceux-ci sont plus ou moins « secondaires » ; du coup, si vous débutez, vous pouvez simplement les ignorer, pour l’instant !

Essais de programmation d’ATtiny en UPDI, via ce convertisseur USB CH340N + Arduino IDE

Avant toute programmation d’ATtiny, il faudra d’abord brancher ce convertisseur USB UPDI (seul) sur votre PC, afin que votre ordi puisse installer le bon driver, pour qu’il fonctionne correctement ensuite ! Et après seulement, vous pourrez raccorder votre ATtiny à ce convertisseur (comme schématisé au paragraphe §3).

Branchement 1/2 : Convertisseur USB UPDI ↔ prise USB de l’ordi

Lors du premier branchement de ce convertisseur USB CH340N sur votre PC, il faudra attendre un petit temps d’installation/configuration, avant tout (comme tout branchement de nouveau périphérique USB, en fait !).

Pour ma part, sous Windows 10, un message « Nouveau périphérique détecté » est apparu en bas/à droite de mon bureau ; et au bout de quelques dizaines de secondes, un second message, disant « Périphérique prêt à l’emploi », m’a indiqué que tout était désormais paramétré/configuré, et prêt à être utilisé.

Remarque : si jamais votre ordi ne reconnaît pas la puce CH340N de ce programmateur ATtiny, il faudra manuellement importer les « bons » pilotes/drivers. Vous trouverez une liste des drivers CH340/CH341, sur le site du fabricant WCH, selon si vous travaillez sur Windows, Mac, Linux, ou autre !

Afin de vérifier que le convertisseur soit bien reconnu par son PC, il suffit d’aller dans le Gestionnaire de périphériques Windows, pour voir le présent programmateur (à base de CH340N) dans la liste des ports COM, comme visible ici :

Bien entendu, encore une fois, si vous utilisez une autre version de Windows ou tout autre système d’exploitation, cela se présentera certainement différemment ! Il faudra donc vous adapter … !

Du reste, gardez bien à l’esprit que tout ceci n’apparaîtra que la toute première fois où votre ordi rencontrera ce tout nouveau périphérique (notre convertisseur USB UPDI), car les fois d’après, tout sera déjà configuré, et donc, immédiatement opérationnel.

Branchement 2/2 : Convertisseur USB UPDI ↔ ATtiny à programmer

Maintenant qu’un côté de notre convertisseur USB UPDI est bien connecté (côté USB, à notre ordi), il est à présent nécessaire de le connecter l’autre côté (côté UPDI, à l’ATtiny). Et pour cela, 3 fils suffisent, pour le VCC (3,3 ou 5V), la ligne UPDI, et le GND (la masse).

Pour vous en faire la démo, j’ai pris un ATtiny212 (version CMS / package SOP8), que j’ai soudé sur un support à broche (DIP8) pour l’occasion ; ainsi, j’ai pu l’embrocher sur une breadboard, pour rendre les essais plus faciles. Visuellement, voici à quoi ça ressemble :

Au niveau filaire, pour mieux comprendre, voici comment le câblage est réalisé :

Comme vous le voyez, on retrouve ici :

• l’ATtiny à programmer (avec ses connections Vcc/Gnd/Updi en provenance de notre Convertisseur USB UPDI)
• un condensateur de découplage de 100nF, pour ce microcontrôleur ATtiny212
• et une LED pour tester un basique programme blink (clignotement de led), munie d’une résistance de limitation de courant (1K à 10K ohms, par exemple)

Nota : pour être bien clair ici, l’ATtiny utilisé (un ATtiny212) est un composant CMS, au boîtier format SOP-8 ; il ne peut pas être directement embroché sur une breadboard. J’utilise donc ici un adaptateur PCB, pour faire la « conversion » SOP8 ↔ DIP8, afin réaliser cela, et ainsi, faciliter les tests !

Création d’un programme de test, sous Arduino IDE, pour faire clignoter la LED branchée sur l’ATtiny (programme « Blink »)

Si vous avez l’habitude des programmes Blink, vous ne serez pas surpris par ce qui suit ! À ceci près que, comme il ne s’agit pas d’un Arduino ici, mais d’un ATtiny, le nom des broches diffère quelque peu. Mais vous devriez vite prendre de nouveaux repères, ne vous inquiétez pas !

Ici, comme nous utilisons un ATtiny212, il faut tout d’abord récupérer son brochage, afin d’avoir le « bon » nom des pins. Voici d’ailleurs son brochage (pinout) simplifié :

Si vous reprenez le schéma filaire juste avant, vous verrez qu’on utilise la broche 5 de l’ATtiny212. Avec ce brochage simplifié, vous constatez qu’il s’agit en fait de la pin « PA2 ». Et c’est cette référence là qu’il faudra qu’on mettre dans notre programme de test. En parlant de ce dernier, le voici :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       prg01-TestBlinkATtiny212.ino
  
  Description :   Programme permettant de faire clignoter une LED branchée sur
                  la sortie PA2 (broche 5) d'un ATtiny modèle 212
                  
  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 :       03.10.2024

*/


// Définition de la broche utilisée
#define brocheOuEstBrancheeLaLed    PIN_PA2         // La LED sera branchée sur la sortie PA2 (broche 5) de notre ATtiny 212


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

  // Initialisation de la broche utilisée
  pinMode(brocheOuEstBrancheeLaLed, OUTPUT);
  
}

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

  // Clignotement de la LED, une fois par seconde (soit allumée 500ms / éteinte 500ms)
  digitalWrite(brocheOuEstBrancheeLaLed, HIGH);       // On allume la LED en mettant la sortie de l'ATtiny à l'état haut
  delay(500);
  
  digitalWrite(brocheOuEstBrancheeLaLed, LOW);        // On éteint la LED en mettant la sortie de l'ATtiny à l'état bas
  delay(500);

}

Voilà ! Il ne reste plus qu’à téléverser ce programme dans l’ATtiny212, depuis notre ordi, et à travers notre convertisseur USB/UPDI, pour voir ce que ça donne 🙂

Téléversement du programme depuis l’IDE Arduino, à destination de l’ATtiny, au travers de notre convertisseur USB UPDI

Si notre convertisseur USB/UPDI est bien branché à notre ordi côté USB, et s’il est bien connecté à notre ATtiny212 côté UPDI, alors il ne reste plus qu’à uploader le code précédent, à l’aide d’Arduino IDE ; ceci se faisant au final comme n’importe quel autre programme arduino, en cliquant sur l’icône « Téléverser » de la barre d’outils, ou en appuyant sur les touches « CTRL+U » du clavier.

Voici ce qui s’est affiché en bas de mon IDE Arduino, lorsque j’ai effectué l’upload du programme :

Le croquis utilise 446 octets (21%) de l'espace de stockage de programmes. Le maximum est de 2048 octets.
Les variables globales utilisent 10 octets (7%) de mémoire dynamique, ce qui laisse 118 octets pour les variables locales. Le maximum est de 128 octets.
C:\Users\JEROME\AppData\Local\Arduino15\packages\megaTinyCore\tools\python3\3.7.2-post1/python3 -u C:\Users\JEROME\AppData\Local\Arduino15\packages\megaTinyCore\hardware\megaavr\2.6.10/tools/prog.py -t uart -u COM3 -b 57600 -d attiny212 --fuses 0:0b00000000 2:0x02 6:0x04 7:0x00 8:0x00 -fC:\Users\JEROME\AppData\Local\Temp\arduino_build_451550/prg01-TestBlinkATtiny212.ino.hex -a write -v 
SerialUPDI
UPDI programming for Arduino using a serial adapter
Based on pymcuprog, with significant modifications
By Quentin Bolsee and Spence Konde
Version 1.2.3 - Jan 2022
Using serial port COM3 at 57600 baud.
Target: attiny212
Set fuses: ['0:0b00000000', '2:0x02', '6:0x04', '7:0x00', '8:0x00']
Action: write
File: C:\Users\JEROME\AppData\Local\Temp\arduino_build_451550/prg01-TestBlinkATtiny212.ino.hex
pymcuprog.programmer - INFO - Setting up programming session for 'attiny212'
pymcuprog.deviceinfo.deviceinfo - INFO - Looking for device attiny212
pymcuprog.serialupdi.physical - INFO - Opening port 'COM3' at '57600' baud
pymcuprog.serialupdi.link - INFO - STCS 08 to 0x03
pymcuprog.serialupdi.link - INFO - STCS 06 to 0x02
pymcuprog.serialupdi.link - INFO - LDCS from 0x00
pymcuprog.serialupdi.link - INFO - UPDI init OK
pymcuprog.serialupdi.link - INFO - STCS 06 to 0x02
pymcuprog.serialupdi.link - INFO - Setting UPDI clock to 4 MHz
pymcuprog.serialupdi.link - INFO - STCS 03 to 0x09
pymcuprog.serialupdi.physical - INFO - Switching to '57600' baud
pymcuprog.serialupdi.application - INFO - SIB: 'tinyAVR P:0D:0-3M2 (02.59B14.0)'
pymcuprog.serialupdi.application - INFO - Device family ID: 'tinyAVR'
pymcuprog.serialupdi.application - INFO - NVM interface: 'P:0'
pymcuprog.serialupdi.application - INFO - Debug interface: 'D:0'
pymcuprog.serialupdi.application - INFO - PDI oscillator: '3M2'
pymcuprog.serialupdi.application - INFO - Extra info: '(02.59B14.0)'
pymcuprog.serialupdi.application - INFO - Using 16-bit UPDI
pymcuprog.serialupdi.link - INFO - LDCS from 0x00
pymcuprog.serialupdi.application - INFO - PDI revision = 0x02
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.application - INFO - Entering NVM programming mode
pymcuprog.serialupdi.link - INFO - LDCS from 0x07
pymcuprog.serialupdi.application - INFO - Apply reset
pymcuprog.serialupdi.link - INFO - STCS 59 to 0x08
pymcuprog.serialupdi.application - INFO - Release reset
pymcuprog.serialupdi.link - INFO - STCS 00 to 0x08
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.nvm - INFO - No specific initializer for this provider
Pinging device...
pymcuprog.programmer - INFO - Reading device ID...
pymcuprog.serialupdi.application - INFO - SIB: 'tinyAVR P:0D:0-3M2 (02.59B14.0)'
pymcuprog.serialupdi.application - INFO - Device family ID: 'tinyAVR'
pymcuprog.serialupdi.application - INFO - NVM interface: 'P:0'
pymcuprog.serialupdi.application - INFO - Debug interface: 'D:0'
pymcuprog.serialupdi.application - INFO - PDI oscillator: '3M2'
pymcuprog.serialupdi.application - INFO - Extra info: '(02.59B14.0)'
pymcuprog.serialupdi.application - INFO - Using 16-bit UPDI
pymcuprog.serialupdi.link - INFO - LDCS from 0x00
pymcuprog.serialupdi.application - INFO - PDI revision = 0x02
pymcuprog.serialupdi.link - INFO - LDCS from 0x0B
pymcuprog.serialupdi.application - INFO - Device ID from pyupdi = '1E9121' rev 'C'
pymcuprog.nvm - INFO - Device ID: '1E9121'
pymcuprog.nvm - INFO - Device revision: 'C'
pymcuprog.nvm - INFO - Device serial number: 'b'304e48565151f0323603''
Ping response: 1E9121
Setting fuse 0x0=0x0
Writing literal values...
pymcuprog.programmer - INFO - Write...
pymcuprog.programmer - INFO - Writing 1 bytes of data to fuses...
pymcuprog.programmer - INFO - Write complete.
Verifying literal values...
pymcuprog.programmer - INFO - Reading 1 bytes from fuses...
pymcuprog.programmer - INFO - Verifying...
Action took 0.03s
Setting fuse 0x2=0x2
Writing literal values...
pymcuprog.programmer - INFO - Write...
pymcuprog.programmer - INFO - Writing 1 bytes of data to fuses...
pymcuprog.programmer - INFO - Write complete.
Verifying literal values...
pymcuprog.programmer - INFO - Reading 1 bytes from fuses...
pymcuprog.programmer - INFO - Verifying...
Action took 0.03s
Setting fuse 0x6=0x4
Writing literal values...
pymcuprog.programmer - INFO - Write...
pymcuprog.programmer - INFO - Writing 1 bytes of data to fuses...
pymcuprog.programmer - INFO - Write complete.
Verifying literal values...
pymcuprog.programmer - INFO - Reading 1 bytes from fuses...
pymcuprog.programmer - INFO - Verifying...
Action took 0.03s
Setting fuse 0x7=0x0
Writing literal values...
pymcuprog.programmer - INFO - Write...
pymcuprog.programmer - INFO - Writing 1 bytes of data to fuses...
pymcuprog.programmer - INFO - Write complete.
Verifying literal values...
pymcuprog.programmer - INFO - Reading 1 bytes from fuses...
pymcuprog.programmer - INFO - Verifying...
Action took 0.03s
Setting fuse 0x8=0x0
Writing literal values...
pymcuprog.programmer - INFO - Write...
pymcuprog.programmer - INFO - Writing 1 bytes of data to fuses...
pymcuprog.programmer - INFO - Write complete.
Verifying literal values...
pymcuprog.programmer - INFO - Reading 1 bytes from fuses...
pymcuprog.programmer - INFO - Verifying...
Action took 0.03s
Finished writing fuses.
Chip/Bulk erase,
Memory type eeprom is conditionally erased (depending upon EESAVE fuse setting)
Memory type flash is always erased
Memory type lockbits is always erased
...
pymcuprog.programmer - INFO - Erase...
pymcuprog.serialupdi.nvm - INFO - Chip erase using NVM CTRL
Erased.
Action took 0.00s
Writing from hex file...
Writing flash...
pymcuprog.programmer - INFO - Write...
pymcuprog.programmer - INFO - Writing 446 bytes of data to flash...
[==================================================] 7/7
pymcuprog.programmer - INFO - Write complete.
Action took 0.16s
Verifying...
pymcuprog.programmer - INFO - Reading 446 bytes from flash...
pymcuprog.programmer - INFO - Verifying...
Verify successful. Data in flash matches data in specified hex-file
Action took 0.11s
pymcuprog.serialupdi.application - INFO - Leaving NVM programming mode
pymcuprog.serialupdi.application - INFO - Apply reset
pymcuprog.serialupdi.link - INFO - STCS 59 to 0x08
pymcuprog.serialupdi.application - INFO - Release reset
pymcuprog.serialupdi.link - INFO - STCS 00 to 0x08
pymcuprog.serialupdi.link - INFO - STCS 0C to 0x03
pymcuprog.serialupdi.physical - INFO - Closing port 'COM3'

Vers la fin de ce log, on retrouve une ligne disant « Verify successful. Data in flash matches data in specified hex-file », ce qui signifie que tout s’est bien passé, côté programmation de l’ATtiny ! Maintenant, il ne reste plus qu’à jeter un coup d’œil à la LED branchée sur ce µC, pour voir si elle clignote bien (le fameux « blink »).

Ça y est ! Notre ATtiny est enfin testé, et bien programmé 🙂

Maintenant, libre à vous d’uploader tous les programmes compatibles qui vous plaisent, en faisant bien attention par contre, à ne pas excéder les capacités mémoire programme (FLASH) ou vive (RAM) des ATtiny … Sans quoi, tout risque de dysfonctionner plein pot !

Liste des composants et matériels utilisés + documents de fabrication

Au niveau des composants utilisés dans ce projet de Convertisseur USB UPDI, on retrouve :

• 2 x condensateurs 10 µF 25V, au format 1206 (CMS)
• 2 x condensateurs 100 nF, au format 1206 (CMS)
• 1 x diode schottky rapide BAT54 GWX, au format SOD-123 (CMS)
• 1 x LED verte (ou toute autre couleur !), au format 1206 (CMS)
• 1 x résistance de 10 Kohms, au format 1206 (CMS)
• 1 x résistance de 470 ohms, au format 1206 (CMS)
• 1 x régulateur de tension AMS1117-3.3, au format SOT-223 (CMS)
• 1 x puce CH340N, au format SOP-8 (CMS)
• 1 x interrupteur à glissière MSS22D18, de type DPDT (CMS)
• 1 x connecteur USB-A horizontal, de type mâle traversant 90°
• 1 x connecteur mâle à 3 broches, de type pin Header

Au niveau du matériel utilisé, pour le soudage des différentes versions de PCB, on retrouve :

• une seringue de soudure sans plomb / basse température (fusion à 138 °C), Sn42 Bi58
• un support à souder rotatif à 360°
• un fer à souder Kaiweets KETS02, filaire 65 watts
• une station à air chaud modèle 858D, pour souder au pistolet à air chaud
• une mini table chauffante à souder/dessouder les composants CMS (idéal pour les fainéants comme moi !)

Enfin, au niveau des fichiers de fabrication, voici :

• le schéma électronique du présent montage (format PDF)
• le dossier Gerber pour la reproduction à l’identique de ce PCB (format ZIP)

En espérant n’avoir rien oublié ici !

Convertisseur USB UPDI CH340N : conclusion !

Nous voilà au terme de ce projet de programmateur d’ATtiny en UPDI, qui je l’espère, pourra vous servir autant qu’à moi ! Au passage, il vous aura peut-être fait découvrir le convertisseur série USB/UART modèle CH340N, qui avec ses 8 broches seulement, peut faire des merveilles 😉

Pour une mise en application plus concrète encore de ce convertisseur USB UPDI, je vous partagerai un jour (lorsque je l’aurai fini) un projet d’anneau lumineux à base d’ATtiny212 et de NeoPixels, qui sera programmable à l’aide de ce montage. Pour info, j’ai déjà réalisé le PCB de cet anneau lumineux (comme visible sur la première image du paragraphe 3), mais aucun composant n’est encore soudé dessus, ni le moindre test et vérifications effectués dessus, et aucun programme n’a encore été ébauché ! Alors il me reste du boulot, en attendant !

Sur ce, je vous dis à très vite !
Jérôme.

À découvrir aussi : un programmateur d’ATmega328P, à embrocher sur son Arduino Uno !

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 24/12/2024