Les fondamentaux sur l'ATTINY: programmation avec Arduino ISP / platine de développement / fusibles

Dans cet article nous allons découvrir les microcontrôleurs Atmel AVR ATTINY  avec notamment le petit ATTINY85. Nous apprendrons comment le programmer avec un Arduino, comment utiliser sa platine de développement low-cost HW-260, comment y injecter le bootloader micronucléus et comment modifier ou réinitialiser les bits de contrôle appelés "fusibles". 


Si vous suivez régulièrement ce blog, vous aurez remarqué que depuis un moment nous essayons d'acquérir les compétences nécessaires pour réaliser nos propres objets connectés sur accu et disposant d'une autonomie de plusieurs mois. Nous avons bien progressé et cette quête du Graal nous a permis de découvrir et d'apprendre beaucoup de choses en électronique. Mais ce que nous avons appris également, c'est que les microcontrôleurs de type ESP8266 qui sont embarqués sur une planche de développement (comme l'ESP-01 ou le NodeMCU), sont assez gourmand en énergie. Nous avons constaté qu'il était difficile d'atteindre l'autonomie de plusieurs mois recherchée avec ce type de circuits. 

En fouillant un peu sur le net, j'ai vu que pas mal de "makers" utilisent un ATTINY pour leurs montages. En me renseignant un peu plus, j'ai compris qu'il s'agit d'une gamme de microcontrôleurs dont la majorité sont tout petits et consomment très peu d'énergie. 

Alors sans réfléchir, je fais quelques recherches sur mes sites marchands préférés, je trouve quelques références et sans bien comprendre ce que j'achète je passe commande de deux ATTINY85 chacun avec sa planche de développement.

Servons nous un whisky, allumons un cigare et regardons ce que ce coup de poker va nous rapporter. 











1 Découverte pas à pas de l'ATtiny85

En général dans mes articles, j'aime bien commencer par un peu de théorie pour comprendre les concepts avant de me lancer dans la pratique. Mais cette fois, étant donné que j'ai déjà commandé et reçu les composants, je suis hyper impatient de me lancer dans un montage. Je vous propose donc d'apprendre avec moi en marchant et de suivre pas à pas mes questionnements, mes difficultés et mes découvertes. 


1.1 C'est quoi un ATtiny ?

Bon, pour quelqu'un qui ne voulait pas faire de théorie, je commence mal avec cette question. Mais ne vous inquiétez pas, cette fois vous n'allez pas avoir la migraine et nous allons aller à l'essentiel. C'est quand même important de savoir de quoi on parle. 

1.1.1 Un MCU Atmel

Les ATtiny sont une famille de microcontrôleurs* AVR** produits par la société Atmel.

*On trouve souvent l'acronyme MCU, qui signifie Multipoint Control Unit, à la place du mot français microcontrôleur. Mais il s'agit de la même chose: MCU = microcontrôleur = 𝜇C   

**AVR est le terme utilisé par Atmel pour désigner le cœur du MCU. Tous les cœurs AVR présentent des caractéristiques identiques que je ne décrirais pas ici mais il y a entre autre une architecture RISC 8bits ou une optimisation pour exécuter les instructions d'un compilateur C. 

Logo Atmel

La famille des micro-contrôleurs AVR se compose de 5 groupes principaux et, parmi ces derniers, on retrouve: les tiny, les mega, les Xmega. 

Les microcontrôleurs tiny sont optimisés pour les applications qui nécessitent des performances, une efficacité énergétique et une facilité d'utilisation dans un petit boîtier. C'est à cette famille que nous allons nous intéresser.

La famille des ATtiny est relativement nombreuse. On y trouve une multitude de modèles avec des caractéristiques différentes. Si vous voulez les comparer tous, vous pouvez vous reporter à la page du wiki dédiée ICI. En ce qui me concerne j'ai surtout entendu parler des ATtiny45 et ATtiny85 qui semblent les plus connus. Ils ont en commun d'avoir 8 broches: 6 GPIO + VIN + GND. En réalité ils font partie d'un groupe dont les modèles sont compatibles et dont la seule différence est la quantité de mémoire: 
  • Attiny25 = Microcontrôleur avec 2 Ko de mémoire programmable
  • Attiny45 = Microcontrôleur avec 4 Ko de mémoire programmable
  • Attiny85 = Microcontrôleur avec 8 Ko de mémoire programmable

J'aurais pu parler aussi de l'ATtiny13 qui dispose de 8 broches également mais seulement 1 Ko de mémoire et d'autres fonctions en moins (I2C, SPI, ...).

1.1.2 Caractéristiques techniques des ATtiny85

Maintenant que nous savons de quoi on parle, regardons de plus près quelques caractéristiques techniques qui vous nous servir pour nos montages.

Les caractéristiques dont je parle dans cet article concernent l'ATtiny85. Mais elles seront en général aussi valables pour les trois modèles 25/45/85. Lorsque ce ne sera pas le cas, si j'ai l'information, je l'indiquerai. 

Alimentation: La tension d’alimentation varie de 2,7 à 5,5 V (de 1,8 à 5,5 V pour les versions avec un V: ATtiny25V/45V/85V).

Nombre de broches: 8 (6 GPIO et 2 pour l'alimentation).

Fréquence: La fréquence maximale est de 20Mhz. Mais elle va dépendre de la tension d'alimentation:

  • De 2,7V à 4,5V la fréquence doit être comprise entre 0 et 10Mhz.
  • De 4,5V à 5,5V la tension "peut" aller jusqu'à 20Mhz. 

Fonctionnalité des broches (pinout):

Voici la représentation des fonctions pour chacune de ces broches:

ATtiny85 pinout

Un autre schéma de brochage extrait du datasheet qui apporte quelques fonctions en plus:

ATtiny85 pinout (extrait du datasheet Atmel)


Autres caractéristiques (Attiny 25/45/85):
  • 2/4/8K octets de Flash Programmable In-System (ISP)
  • 128/256/512 octets EEPROM: Mémoire utilisable dans les programmes qui reste persistante en cas de coupure électrique. 
  • 128/256/512 octets SRAM: mémoire utilisable pour les variables du programme, qui s'efface à chaque coupure électrique.  
  • 6 lignes d'E / S à usage général (appelées port B)
  • 32 registres de travail à usage général
  • Interruptions internes et externes, 
  • Convertisseur Analogique Numérique (CAN ou ADC) à 4 canaux et 10 bits (ADC0 à 3)
  • 3 modes d'économie d'énergie sélectionnables par logiciel. 
  • Le port B* est un port d'E/S bidirectionnel 6 bits avec des résistances de rappel internes (pull-up) (sélectionnées pour chaque bit). Les broches du port B tirées à l'extérieur vers le bas produiront du courant si les résistances de rappel sont activées.
  • La broche de réinitialisation (broche 1) peut également être utilisée comme broche d'E/S (faible).
*Port B est le nom du port de communication du MCU sur lequel sont connectées les broches. C'est pour cette raison que l'on trouve souvent les 6 GPIO nommés: PB0, PB2, ... PB5. 

1.1.3 Conseils pratiques concernant les Attiny 25/45/85

Bien qu'ayant 6 broches GPIO disponibles, l'une d'entre elles, par défaut, est réservée au RESET. Il vaut mieux conserver cette fonction, sauf si vous avez expressément besoin de cette 6ème broche. Notamment pour programmer le MCU avec un programmateur "classique" (un Arduino par exemple) il vous faudra pouvoir effectuer un RESET. Si ce dernier n'est plus utilisable, le MCU ne sera plus programmable (ou alors il faudra passer par un programmeur spécial haute tension).

Si vous souhaitez travailler avec une fréquence au-delà de 10Mhz (jusqu'à 20Mhz), il faudra que la tension d'alimentation soit supérieure à 4,5V (et inférieure à 5,5V).

Pour repérer la broche numéro 1 (PB5 ou RESET) il faut chercher une petite encoche ou un petit rond sur la puce. La broche 1 est celle juste devant ce rond.

1.2 Matériel que j'ai reçu et premières questions

Lorsque je me suis décidé à commander des ATtiny je savais juste qu'il s'agissait de microcontrôleurs petits et économes en énergie. Je ne savais rien des différences entre chaque modèle, je ne savais pas non plus quelles étaient les capacités de chacun et encore moins comment cela se programme. J'avais vu que dans beaucoup de tutos il était question d'ATtiny45 ou 85. N'y connaissant rien, je me suis dit que 85 ça devait être mieux que 45. J'ai donc recherché ce composant sur eBay et le marchand qui était le moins cher proposait 3 choix sur son annonce:

Choix sur l'annonce pour l'ATtiny85

Je pouvais choisir d'acheter le MCU seul, une planche de développement ou alors les deux. Sur la photo, la planche de développement faisait apparaître un socket pour placer l'ATtiny ainsi qu'un port micro USB. Je me suis dit que c'était un bon plan et qu'il suffisait certainement de placer l'ATtiny sur la planche de développement, de raccorder à l'ordinateur en USB et ensuite téléverser le programme depuis l'IDE Arduino comme je le fais avec les ESP8266. Je me suis donc précipité sur cette bonne affaire et j'ai acheté les deux. Mais cela aurait été trop simple!

Voici le matériel que j'ai reçu. J'ai placé la pointe d'un stylo pour vous donner une idée de la petite taille du microcontrôleur. La planche de développement est fournie avec des broches à souder sur le PCB pour pouvoir l'utiliser plus facilement avec des câbles Dupont. 

Matériel commandé ICI.

A peine déballé, je regarde tout ça de près et je me pose quelques questions. La première est de savoir dans quel sens placer le MCU dans le socket ?

Une fois cette réponse trouvée*, je branche sur l'ordinateur et ... rien ... ! Windows m'envoie juste un message "périphérique USB non reconnu".

*En fait il y a un petit rond sur le MCU et une encoche sur le socket de la platine: il faut que ces marques soient du même coté.

Après quelques recherches sur internet je me rends compte que la planche de développement n'a en réalité rien d'une planche de développement. Elle ne permettrait que d'alimenter la puce sauf si un "bootloader" capable de gérer l'USB est déjà présent. En réalité le MCU se programme via un autre équipement compatible qui serait capable jouer le rôle de passerelle pour téléverser le programme. Cet autre équipement s'appelle un ISP et ça pourrait être un Arduino. 



Je ne sais pas vous mais, pour ma part, cela me donne des migraines ... essayons de démystifier tout ça en répondant à des questions simples.

1.2.1 Qu'est-ce qu'une carte de développement?

La question semble peut être triviale, mais je me la suis posée quand j'ai reçu ma commande et je me suis demandé ce que j'avais bien pu acheter! 😭

En réalité, j'aurais plutôt dû me demander : qu'est-ce que j'attendais d'une carte de développement pour microcontrôleur? Et la réponse est que je pensais recevoir une carte, que je pourrais simplement connecter à mon PC en USB et qui me permettrait de téléverser un programme écrit avec l'IDE Arduino directement sur le microcontrôleur.

Pour que cela soit possible, il faut que la carte embarque l'ensemble des fonctionnalités qui lui permettent d'être reconnue par l'ordinateur et de dialoguer avec ce dernier sur le port USB. Ce qui n'est pas le cas de la carte que j'ai reçue. 

A ce propos, je vous invite à relire le passionnant article sur la communication entre un microcontrôleur et un ordinateur ICI.

Il faut aussi que le microcontrôleur présent sur la carte exécute, à son démarrage, un programme spécifique qui lui permette de savoir s'il doit exécuter son programme principal ou alors qu'il se mette en mode "flash" afin de modifier son programme principal.  Ce programme de démarrage s'appelle un bootloader.

Dans mon cas, la carte HW-260 que j'ai commandée correspond à la partie matérielle de toutes ces fonctionnalités mais sans la partie logicielle: pas de gestion de l'USB, pas de bootloader. Pour que je puisse m'en servir comme d'une carte de développement, il va falloir réaliser quelques modifications.

1.2.2 Pourquoi Windows ne reconnait pas ma carte de développement HW-260?

Comme je viens de l'expliquer ci-dessus, ma carte de développement et le MCU Attiny85 que j'ai placé dessus, n'embarquent pas les fonctionnalités nécessaires pour gérer une communication via l'interface USB.
Windows détecte bien un équipement présent sur son port USB mais est incapable d'échanger avec lui pour le reconnaître. Pour que cela soit possible il faudrait donc que :
  1. Côté MCU un programme gérant la communication USB soit installé (bootloader)
  2. Côté PC, le driver capable de gérer la communication avec ce programme soit installé. 
D'après mes recherches, les cartes de développement Digispark sont préprogrammées pour embarquer sur le MCU un bootloader qui saura gérer la communication USB. Par contre il faudra installer les drivers sur le PC (manuel disponible ICI)

1.2.3 Qu'est ce qu'un bootloader?

Un "chargeur de démarrage" est un programme qui s’exécute au démarrage et utilise les fonctionnalités d'auto-modification du flash pour permettre à l'AVR de se programmer lui-même via des données (le programme) chargées à partir d'une source externe. Les chargeurs de démarrage peuvent obtenir leurs données à partir de n'importe quel emplacement dont le plus fréquent est la communication avec un PC via le port série de l'AVR. 

Les bootloader consomment de l'espace de mémoire flash (Micronucleus occupe 2 ko, limitant la taille totale  disponible pour l'application à 6 ko sur un Attiny85). De plus, ils ne peuvent pas changer les fusibles AVR (nous verrons ultérieurement ce que cela signifie). Sur l'Attiny85, si le bootloader est utilisé pour communiquer avec le PC en USB, 2 broches (3 et 4) verront leur utilisation affectée.

Sur un MCU comme notre Attiny, le bootloader va servir à rendre le microcontrôleur compatible avec une carte de développement en permettant la communication en USB avec un ordinateur. En fonction d'un événement particulier, il va exécuter une séquence de reprogrammation à partir de données externes reçues sur les broches data (P3 et P4) correspondantes aux broches DATA de l'USB, ou alors il va exécuter la suite du programme en mémoire. Par exemple, un bootloader pourrait tester l'état électrique d'une broche. Si elle est à un état haut, dans ce cas, le MCU va se reprogrammer.

Les bootloader se trouvent sur Internet en téléchargement, mais on se retrouve face à un problème de "poule et œuf".  Pour flasher l'Attiny depuis la platine de développement il faut un bootloader et pour avoir un bootloader il faut flasher l'Attiny. Nous aurons donc besoin d'un programmeur AVR ISP ou d'acheter un MCU avec bootloader préchargé.

Le bootloader le plus courant est Micronucleus : https://github.com/micronucleus/micronucleus

1.2.4 Quelle est la différence entre la méthode ISP et Bootloader ?

Nota Bene:

→ ISP = "In-System Programming". Cela désigne la possibilité pour un microcontrôleur d'être reprogrammé (flashé) une fois en place, à opposer avec certaines puces qui ne sont programmables qu'une seule fois en usine.
→ AVR = Famille de microcontrôleurs fabriqués par Atmel. Les Attiny font partie de cette famille.

Il existe plusieurs méthodes pour programmer un MCU AVR (JTAG, HVPP,...). Mais nous n'évoquerons dans cet article que la méthode par ISP et/ou bootloader car ce sont les deux seules que nous allons utiliser.



La méthode ISP consiste à utiliser un appareil, appelé "programmeur ISP" qui se connecte d'un coté à un ordinateur en USB et de l'autre à un microcontrôleur. Cet appareil a pour fonction de téléverser le programme compilé sur le PC afin de flasher le MCU. Si vous le souhaitez, vous pouvez vous procurer cet appareil ICI mais nous verrons aussi qu'un arduino peut être transformé en "Programmeur ISP".

La méthode par "bootloader", utilise la fonctionnalité des MCU AVR de s'auto-programmer. Le "bootloader" est un programme qui est présent dans la mémoire du microcontrôleur et qui, en fonction d'un événement particulier, va exécuter une séquence de reprogrammation à partir de données externes, ou alors va exécuter la suite du programme en mémoire.
Par exemple, un bootloader pourrait tester l'état électrique d'une broche. Si elle est à un état haut dans ce cas le MCU va se reprogrammer en prenant le code soit d'une carte mémoire SD jointe, soit attendre sur ses ports de communication les données en provenance d'un ordinateur.

Si vous avez suivi, ou si je me suis bien expliqué, vous allez me dire qu'il y a un problème avec l'Attiny85 et la carte de développement que j'ai reçu. Car nous avons vu que le MCU comme la carte, ne savent pas communiquer en USB (pas d'UART et pas d'interface série ... donc pas de compatibilité avec un protocole USB). Alors comment le bootloader pourra "comprendre" le programme qu'il va recevoir de la part du PC raccordé en USB sur la carte? La réponse est simple: il faudra choisir un bootloader qui prend en charge de manière logicielle une communication sur USB. Et pour que le bootloader et le PC arrivent à se comprendre il va falloir également installer un driver coté PC.

1.2.5 Différentes cartes de développement

Dans le petit mode des Attiny en général et concernant l'Attiny85 en particulier, il existe une carte de développement appelée "Digispark" que l'on compare souvent avec l'Arduino (qui est aussi une carte de développement pour MCU ATMega328). D'après ce que j'ai compris, la "Digispark" est conçue sous licence libre par un groupe qui s'appelle "Digistump". On pourra donc trouver différents fabricants, asiatiques notamment, qui proposent des cartes "Digispark".

Ces cartes fournissent normalement les composants suivants:

  • Un régulateur de tension 5V pour connecter une alimentation externe. 
  • Les résistances et les condensateurs nécessaires au bon fonctionnement du MCU
  • Des broches sur le PCB, qui se connectent facilement avec des câbles Dupont, qui permettent d'accéder aux broches du MCU. 
  • Une connectique USB pour raccorder le PCB à un câble USB ou à une fiche USB d'un ordinateur. Toutefois attention! La présence de cette connectique ne signifie pas que l'USB est géré de manière native par la carte. Certaines cartes ne seront pas reconnues par un ordinateur en USB sans modifications à réaliser. 
  • Le MCU, par exemple l'Attiny85, ou alors un socket (support) pour y insérer celui de votre choix. Il y a deux types de cartes: celles qui proposent le MCU directement soudé sur le PCB. Comme c'est le cas avec l'Arduino nano par exemple. Et celles qui proposent un socket vide. 
N'ayant pas connaissance de tous les types de cartes de développement pour Attiny qui existent, il se peut que cette liste ne soit pas exhaustive et que vous puissiez en trouver d'autres. 

L'avantage des cartes qui intègrent le MCU soudé est que, en général, ce dernier est livré pré-programmé. C'est-à-dire que le bootloader permettant de gérer une connexion USB est déjà chargé dans l'Attiny. Avec les bons drivers sur le PC, ces cartes seront directement reconnues et utilisables avec l'IDE Arduino. Par contre vous ne disposerez que de 6Ko de mémoire pour un Attiny85, au lieu des 8Ko possibles, justement à cause de la présence du bootloader. Un autre inconvénient est que vous ne pourrez pas changer de MCU. Si par exemple vous souhaitez utiliser un Attiny45 il vous faudra une autre carte de développement. Alors qu'une carte de développement livrée avec un socket 8 broches vide, sera compatible avec tout MCU 8 broches. 

Voici quelques exemples de matériel:

Digispark ATtiny85 Kickstarter Micro USB : Prête à être programmée. Bootloader installé. Prévoir l'installation du driver (vidéo en Anglais disponible ICI et le wiki complet ICI). Il y existe un autre modèle mais avec une connectique USB femelle pour être connecté par câble: Digispark ATtiny85.

En ce qui me concerne j'ai acheté cette carte de développement: HW-260. L'avantage c'est qu'elle permet de changer le microcontrôleur car elle est livrée sans MCU, avec uniquement le socket pour le placer. Par contre il faudra installer le bootloader "Micronucléus" en utilisant un programmeur ISP (nous verrons plus loin qu'on peut utiliser un Arduino comme programmeur ISP).

La platine HW-260 permettra d'accéder facilement aux broches de l'Attiny85 mais il faudra jouer du fer à souder. 3 broches supplémentaires (5V/VIN/GND) ont également été ajoutées afin de raccorder une alimentation externe. Le régulateur de tension étant un "78L05" on pourra alimenter avec un courant maximum de 30V (attention toutefois à la dissipation thermique qui sera fonction de l'intensité nécessaire. Dans la réalité je ne me risquerais pas à raccorder la carte avec du 30V). Si la carte est alimentée en USB et également raccordée sur une alimentation externe sur VIN, la sélection de VIN comme source d'alimentation se fait automatiquement.
Normalement il y a une LED interne comme sur les Arduino. Cette dernière est mappée sur la broche 6, ce qui correspond au GPIO P1. 

Ci-dessous vous trouverez les liens sur Amazon pour vous procurer ces cartes et j'ai ajouté également un lien sur un programmeur ISP:


1.3 Conclusion

Nous venons de voir dans le détail ce qu'est l'Attiny, à quoi correspond le matériel que j'ai reçu suite à ma commande "coup de poker" et surtout, les réponses que nous avons apportées aux questions posées, nous ont permis de commencer à connaitre et comprendre le petit monde des MCU AVR.

Nous avons notamment compris qu'avant de pouvoir utiliser notre platine de développement HW-260, nous allons devoir apprendre à programmer l'Attiny en mode ISP afin de téléverser le bootloader "Micronucléus". 

Et pour cela, nous allons utiliser le seul programmeur ISP que j'ai sous la main: un Arduino. 








2 Programmation de l'Attiny85 en mode ISP avec l'Arduino

Avant de finaliser la prise en main de notre platine de développement et de pouvoir programmer l'Attiny en le connectant directement sur l'ordinateur en USB, nous allons apprendre comment flasher le microcontrôleur en utilisant un Arduino. On parlera d'un mode de programmation ISP et l'Arduino sera utilisé en tant que module ou programmateur ISP.

ISP signifie "In-System Programming". Cela désigne la possibilité de programmer un microcontrôleur alors qu'il est déjà en place, plutôt que d'avoir une programmation figée en usine. Ceci implique que le MCU est raccordé à un appareil qui joue le rôle de programmateur et qui fera la passerelle entre le programme compilé sur le PC par l'IDE Arduino et l'Attiny85.

Pour cela nous allons retrouver nos premiers amours : les Arduino.

2.1 Préparation de l'IDE Arduino et tests de fonctionnement


Pour transformer notre Arduino en programmeur ISP il va falloir lui téléverser un sketch spécifique.

Mais avant de faire cela, j'aime bien préparer et tester que tout fonctionne correctement. Je vais donc connecter mon Arduino, configurer l'IDE et ensuite téléverser un petit programme de test qui me permettra de valider que la liaison série entre l'ordinateur et l'Arduino fonctionnent correctement.



Dans mon cas je vais utiliser un Arduino UNO mais cela fonctionne également avec un Arduino Nano. Et je suppose que cela fonctionnera de la même manière avec un Arduino MEGA. Pour les autres modèles, s'il en existe, je ne peux le garantir.

2.1.1 Étapes à suivre 

1/ Ouvrir l'IDE Arduino

2/  S'assurer que le type de carte choisi est bien "Arduino UNO" et que le programmateur est bien sur "ArduinoISP" (ne pas confondre avec "Arduino As ISP" qui sera utilisé ultérieurement).


3/ Raccorder l'Arduino au PC en USB

4/ Identifiez le port COM sur lequel l'Arduino est connecté. Pour cela, allez dans le menu <Outils>/<Port> et assurez vous que le bon port est sélectionné. Ici le port COM4.


5/ Ecrivez le code de votre programme. Je vous laisse le code de mon programme de test un peu plus bas.

6/ Compilez (Bouton "Vérifiez" dans le menu de l'IDE) et téléversez le programme.

7/ Rebootez manuellement l'Arduino

8/ Ouvrez le moniteur série (bouton correspondant à la petite loupe en haut à gauche de l'interface de l'IDE). Vérifiez que vous avez sélectionné la vitesse de communication de l'interface série identique à la vitesse définie dans le programme (dans mon cas j'ai mis 9600 bauds). Dans l'interface série de l'IDE cette vitesse se fixe par un bouton à choix multiple en bas à droite.

Vous devriez vous l'affichage suivant: 


Si c'est le cas, c'est que vous maîtrisez la programmation de votre Arduino et que vous êtes prêt pour la suite.

2.1.2 Programme de test

Comme promis, voici le code du sketch que j'utilise pour tester que mon environnement Arduino est prêt. C'est un programme archi simple et basique. La seule petite particularité est la fonction "softReset". Comme vous pouvez le voir nous avons défini cette fonction comme étant à l'adresse 0 dans la mémoire. L'appel de cette fonction aura donc pour effet de reprendre le déroulement du programme depuis le tout début, comme un reset matériel. 

/*******************************************************************
* Ce programme ne fait qu'afficher un compteur sur la liaison série.
* Il sert à tester que l'environnement de programmation est prêt:
*   - compilation et téléversement d'un sketch.
*   - communication avec la liaison série pour débugger.
*
* Versions :
*   v1 : Création
* (c) acampeaux@gmail.com
********************************************************************/

/*====================================================================
  * Inclusion des librairies externes
 * ==================================================================*/
// Ici aucun #include nécessaire.

/*====================================================================
  * Définition de constantes (#define) et des variables globales
 * ==================================================================*/
String stNomProgramme = "test_fonctionnement_serial";
String stVersion = "v1.0";

//////////////////////////////constantes relatives à la connexion série
// Fixe la vitesse de communication série.
#define SERIAL_BIT_RATE 9600

//////////////////////////////définitions relatives à la boucle loop
//Temps d'attente (en ms) à la fin de la boucle loop avant de recommencer un cycle
#define DELAY_INTER_CYCLES 2000

// Compte le nombre d'itérations
int iNbIteration = 0;

/*====================================================================
  * Fonction softReset(): Permet de faire un reset logiciel
  * - Quand elle est appelée le programme est repris à partir de l'adresse 0
 * ==================================================================*/
void (*softReset) (void) = 0;

/*====================================================================
  * Fonction setup(): executée une fois au démarrage du microcontroleur.
  * - Ouvre la liaison série.
 * ==================================================================*/
void setup() {

  ////////////////////////////////////////////Variables locales au setup
  String stMessageAccueil = "";
  int iCompteur = 0;

  ///////////////////////////////////Initialisation de la liaison série
  Serial.begin(SERIAL_BIT_RATE);

  //Attente initialisation Serial. Après 1s (10 * 100ms) on reset.
  while( !Serial ) {
      delay( 100 );
      iCompteur++;
      if ( iCompteur >= 10 ) softReset();
      }

  //Affiche message initial
  stMessageAccueil = stNomProgramme + " - Version: " + stVersion;
  Serial.println( stMessageAccueil );
  Serial.println( "Serial: OK" );
}

/*====================================================================
  * Fonction loop(): executée en boucle.
  * - Incrémente un compteur.
  * - Affiche le nombre d'itération sur la liaison série.
  * - Attends un délai donné.
 * ==================================================================*/
void loop() {
  ///////////////////////////////////Variables locales a la fonction loop
  String stMessageIteration = "Iteration loop number: ";

  ////////////////////////////////////////////Incrément et affichage
  iNbIteration++;
  stMessageIteration = stMessageIteration + String( iNbIteration );
  Serial.println( stMessageIteration );

  ////////////////////////////////////////////Attente avant nouveau cycle
  delay( DELAY_INTER_CYCLES );
}


2.1.3 Ajout des cartes Attiny à l'IDE Arduino

L'étape suivante va être de s'assurer que l'IDE Arduino dispose bien des composants qui vont lui permettre de compiler un programme pour les cartes Attiny. Pour cela, contrôlez que, dans le menu <Outils>|<Type de carte>, vous pouvez bien sélectionner votre modèle d'Attiny.


ou si vous avez une vieille version de l'IDE: 


Si ce n'est pas le cas, vous avez un problème 😉 mais voici quelques solutions.

Solution 1: La plus simple


Allez dans "Fichier, Préférences, URL de gestionnaire de cartes supplémentaires" et ajoutez la ligne: https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json


Si une autre adresse est déjà présente, ajouter la nouvelle après un saut de ligne. 

Ensuite, revenez dans "Outils, Type de carte" et cliquez sur "Gestionnaire de cartes":


Dans la fenêtre qui s'ouvre, sélectionnez "Tout" dans le menu en haut à gauche, ensuite recherchez "attiny". Lorsque vous aurez trouvé il ne vous restera plus qu'à la sélectionner d'un clic de souris et ensuite d'installer la dernière version. 



Quand vous reviendrez dans le menu de type de cartes, les cartes Attiny devraient apparaître.

Si vous voulez installer d'autres gestionnaires de cartes que les Attiny, vous pourrez trouver une liste à cette URL (http://playground.arduino.cc/Main/ArduinoOnOtherAtmelChips) ou encore sur cette autre URL (https://github.com/arduino/Arduino/wiki/Unofficial-list-of-3rd-party-boards-support-urls). Chacune vous donnera accès à l'adresse d'un fichier "json" pour chaque type de carte, que vous pourrez ajouter dans le gestionnaire de carte comme nous venons de le faire pour les attiny.


Solution 2: Installation manuelle des composants
Cette solution étant la plus compliquée, je ne vais pas en parler plus que ça. Il s'agit de télécharger un fichier zip contenant l'ensemble des éléments que vous allez devoir installer aux bons endroits.
Ce fichier zip se trouve à l'adresse https://code.google.com/archive/p/arduino-tiny/downloads. Prenez la dernière version (0150-0020 à l'heure ou j'écris ces lignes). En fouillant dans ce zip, vous trouverez un fichier README qui vous indiquera pas à pas, mais en Anglais, toute la marche à suivre.
Bon courage ...

2.2 Programmation de l'Attiny avec l'IDE Arduino


Nous ne pouvons pas encore utiliser notre planche de développement HW-260 mais nous sommes désormais prêts pour programmer l'Attiny avec l'IDE Arduino. Et pour valider notre réussite, nous allons réaliser un programme qui fait clignoter une LED. 

2.2.1 Matériel nécessaire

Dans les étapes qui vont suivre, nous allons devoir réaliser quelques montages. Si vous avez besoin de vous procurer du matériel, voici quelques liens qui vous permettront de ne pas vous tromper. 

Un Arduino: Pour ma part je prends souvent des "copies" de la marque Elegoo ou Az-Delivery. Mais si vous êtes un puriste vous pouvez en commander un vrai ICI. Mais si vous n'avez pas encore d'Arduino, peut être n'avez vous pas encore non plus tout le petit matériel nécessaire aux montages électroniques (breadboard, LED, résistances, ...). Dans ce cas, je vous conseille d'acheter un kit complet comme CELUI-CI qui est très complet.

Une breadboard: Pour ce que nous allons faire, choisissez plutôt une 830 points comme ICI. Il vous faudra aussi des câbles Dupont comme ICI. Sinon vous pouvez commander cet ensemble breadboard et câbles ICI.

Des composants électroniques: résistances 100Ω ou 220Ω, LED de différentes couleurs, un condensateur 10 𝜇F. Pour tout ce petit matériel procurez-vous un kit avec le plus de valeurs possibles pour les composants. Ce vous servira à l'avenir. J'ai trouvé CELUI-CI qui me semble très bien. 


Un Attiny85 de type DIP pour pouvoir être utilisé sur une breadboard comme ICI.



2.2.2 Montage

Avant de pouvoir programmer l'Attiny il faut réaliser le montage intégrant le MCU ainsi que l'Arduino. Nous allons placer l'Attiny sur une breadboard et ensuite relier les broches de l'Arduino aux broches de l'Attiny. Je vais vous décrire comment raccorder tout ça. 

Vous noterez également que j'ai placé un condensateur 10 𝜇F directement sur l'Arduino entre le GND et le RESET. Ce condensateur servira à empêcher l'Arduino de rebooter. 

Dans ce montage, j'ai placé une LED rouge pilotée par le GPIO 9 de l'Arduino (avec, bien sur, une résistance en série). Cette LED nous indiquera, en s'allumant et s'éteignant de manière progressive (comme un cœur qui bat), que l'Arduino est bien fonctionnel en mode ISP. 

Pour ne pas se tromper de sens dans les montages et le branchement de l'Attiny, on peut se repérer grâce à un petit rond sur la puce qui marque l'emplacement de la broche RESET (PB5 ou broche 1).


Voici la liste des connexions à réaliser:
  • ATtiny Pin P2 sur Arduino Pin 13 (ou SCK)
  • ATtiny Pin P1 sur Arduino Pin 12 (ou MISO)
  • ATtiny Pin P0 sur Arduino Pin 11 (ou MOSI)
  • ATtiny Reset sur Arduino Pin 10 (ou RESET)
  • Arduino Pin 9 sur anode (+) de la LED.
  • Résistance entre GND et cathode (-) LED
  • Anode condensateur (+) vers RESET Arduino. Ce condensateur va empêcher le reboot de l'Arduino. 
  • Cathode condensateur (-) vers GND Arduino.
Voici un synoptique du montage à réaliser:


Et voici une photo de ce que j'ai réalisé:


2.2.3 Arduino comme programmeur ISP

L'idée est de se servir de l'Arduino comme programmateur ISP. Il va falloir le programmer avec un logiciel qui lui permettra d'assurer cette fonction. Pour ma part, j'utilise un Arduino UNO mais cela fonctionnera aussi bien avec un Arduino Nano.

Étapes à suivre:

0/ Sur une breadboard, réalisez le montage suivant:

  • placez une LED (j'ai pris une rouge mais vous pouvez utiliser une autre couleur)
  • raccordez la broche négative au GND, en passant par une résistance 100Ω
  • raccordez la broche positive au PIN 9 de l'Arduino. 


Ce montage vous permettra de vérifier que le programme s'est bien installé. 

1/ Assurez vous que votre Arduino est connecté, reconnu par l'ordinateur et que votre environnement de programmation est prêt. Pour cela reportez-vous aux consignes du paragraphe précédent.

2/ Dans l'IDE Arduino, ouvrez le croquis ArduinoISP qui se trouve dans "<Fichier><Exemples><11.ArduinoISP>ArduinoISP"



3/ Contrôlez que vous avez les bons paramètres dans "<Outils>"


4/ Téléversez le programme. 

5/ Débranchez/rebranchez ou faites un RESET de l'Arduino. Vous devriez voir la LED rouge qui s’allume et s’éteint progressivement comme un cœur qui bat. Cette LED de contrôle s'appelle "Heartbeat". Si vous le souhaitez, vous pouvez de la même manière raccorder une LED :

  • Error: sur la broche 8 de l'Arduino. Cette dernière s’allumera si un problème est détecté. 
  • Programming: sur la broche 7 de l'Arduino. Elle s'allumera pour indiquer la communication entre l'Arduino et l'Attiny. 

2.2.4 Configuration de l'IDE Arduino en ISP

Avant d'écrire un programme pour Attiny et de pouvoir le téléverser, il va falloir configurer correctement l'IDE Arduino afin que celui-ci comprenne trois choses:

  1. Que le code devra être compilé pour une Attiny
  2. Quelle vitesse de fonctionnement on souhaite lui donner (fréquence)
  3. Que le téléversement vers le MCU devra se faire au travers de l'Arduino qui se comportera comme un programmeur ISP. 
Choisir le type de carte:

Dans l'IDE Arduino allez dans le menu "<Outils><Type de carte>" et choisissez l'Attiny85 (ou le modèle que vous avez). En fonction du gestionnaire de carte que vous avez configuré (cf paragraphe 2.1.3), la sélection pourra être légèrement différente. Soit vous aurez directement le modèle de MCU avec sa fréquence à choisir. Soit vous aurez le type de modèle et ensuite, en revenant dans le menu "<Outils>" vous pourrez choisir la fréquence. Ce qui est important c'est que vous choisissiez bien "internal" comme fréquence. En choisissant "external" le MCU attendrait que vous connectiez une horloge externe et vous ne pourriez plus l'utiliser tant que ce ne serait pas fait.

En fait ce n'est pas totalement vrai. J'ai moi même fait la bêtise de "Graver la séquence d'initialisation" sur une fréquence d'horloge externe. Et effectivement cela a rendu le MCU inopérant. Mais, je vous rassure, il y a tout de même des solutions que je vous expliquerai dans le chapitre dédié à la programmation des fusibles.


Fréquence de fonctionnement:

Par défaut, la fréquence de fonctionnement est à 1Mhz. Si vous souhaitez que la puce fonctionne à 8Mhz ou à 16Mhz, il faudra sélectionner ces valeurs et ensuite les "fixer" dans l'Attiny. Pour ce faire, vous devrez sélectionner le choix "Graver la séquence d'initialisation" dans le menu "Outil". Ceci aura pour effet de modifier des bits de contrôle (qu'on appelle les fusibles) dans le microcontrôleur. Si vous ne gravez pas la séquence d'initialisation, il se peut que l'attiny fonctionne à une fréquence et que votre programme soit compilé pour fonctionner à une autre fréquence. Si c'est le cas, toutes les fonctions relatives au temps et à l'horloge ne seront plus justes. Prenons un exemple. Imaginez que l'Attiny soit configuré pour fonctionner sur son horloge interne à 1Mhz. Il faudra donc 1000 cycles d'horloge pour faire une milliseconde. Si le programme est compilé sur cette base, lorsque la fonction "delay( 1 );" est appelée, le compilateur à traduit cela en quelque chose qui ressemble à "attendre 1000 cycles d'horloge". Par contre, si la fréquence de l'attiny est de 10Mhz, les mille cycle d'horloge vont se faire 10 fois plus vite. Et si le programme est compilé de la même manière, la fonction "delay( 1 );" va durer 0,1 milliseconde au lieu d'une milliseconde. J'espère que c'est clair pour vous ? Moi j'ai eu un peu de mal à comprendre ça et je me suis arraché les cheveux en voyant mes LED clignoter à toute vitesse alors que j'avais demandé un timer de 5 secondes!

Ce qu'il faut retenir c'est que vous devez vous assurer que la fréquence du MCU, qu'on peut fixer en gravant la séquence d'initialisation, est bien la même que la fréquence précisée lors de la compilation et du téléversement du programme. Vous pouvez gravez la séquence d'initialisation autant de fois que vous le souhaitez et donc modifier les paramètres. Par contre, ne vous trompez pas sur le type de fréquence, il faut bien choisir horloge (clock) "interne" (internal) sinon le MCU sera bloqué jusqu'à ce que vous lui fournissiez un signal d'horloge externe. Mais si cela vous arrive de faire une fausse manip, pas de panique, nous verrons plus loin comment nous en sortir.

Sachez que si vous souhaitez utiliser la liaison série logiciel (librairie SoftwarSerial), vous devez fixer la fréquence au moins à 8Mhz. Et si pour utiliser l'Attiny sur une platine de développement connectée en USB au PC, il faudra une fréquence de 16Mhz.

Si au moment de graver la séquence vous avez un message d'erreur de type "Port COM: Accès refusé" c'est que le port COM n'est pas accessible. Vérifiez que le moniteur série n'est pas ouvert. Si c'est le cas, fermez le.  

Choisir Arduino comme programmeur:

Et le dernier paramètre à modifier sera d'indiquer à l'IDE qu'il doit utiliser un Arduino comme ISP. Ce choix se fait par une sélection de "Arduino As ISP" dans le menu "<Outils><Programmeur>". 

Si vous avez bien suivi ces étapes, vous devriez vous retrouver avec une de ces deux séries de paramètres ci-dessous dans le menu "<Outils>":

Menu Outils en fonction du type gestionnaire de carte installé

2.2.5 Injection du programme dans l'Attiny

Nous sommes maintenant prêts pour créer notre premier programme pour Attiny et l'envoyer au MCU en utilisant notre programmeur ISP Arduino. Afin de faire un test simple, j'ai repris le programme d'exemple "Blink" en l'adaptant pour l'Attiny. J'ai remplacé la valeur "LED_BUILTIN" par "LED" et j'ai fixé la valeur à 4 pour correspondre à la broche PB4 de l'Attiny. J'ai choisi PB4 car sur le montage que nous venons de réaliser c'est une des seules deux broches de libre. J'aurais pu également prendre PB3 (mais comme vous le verrez plus tard ça n'aurait pas été une bonne idée car PB3 va être utilisée pour nous sauver la vie grâce à sa fonction CLKI).


Voici le code du programme: 

#define LED 4
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}


Vous pouvez ajouter une résistance (j'ai pris une 1000Ω) et une LED (j'ai pris une verte) placé en série entre le GPIO PB4 du MCU et le GND et ensuite téléversez ce programme depuis l'IDE Arduino. 


Une fois le programme téléversé et la LED verte ajoutée, voici ce que cela donne:

La LED verte clignote avec le programme que nous avons téléversé

Après une petite page de publicité, nous allons nous attaquer à notre platine de développement.







3. Installation de la platine de développement HW-260


Nous voici arrivés à la dernière étape de cette partie de poker. Pour le moment tout c'est plutôt bien passé. Nous avons réussi à comprendre ce qu'est un Attiny, comment il fonctionne et comment le programmer. Il nous reste une dernière main à jouer! Le coup de la platine de développement! Et nous allons faire un quitte ou double! Si ça marche, nous aurons une platine de développement complète et facile à utiliser pour mettre au point nos programmes pour microcontrôleurs Atmel AVR.  Et si cela ne marche pas, nous pourrons jeter les HW-260 et nous nous contenterons de programmer les Attiny avec un Arduino en mode ISP. Mais n'allons pas nous suicider pour autant: les modules HW-260 coûtant moins d'un euro, nous nous en remettrons.


Juste un mot avant de commencer pour répondre à la question du sens dans lequel placer la puce sur son support. Comme vous le voyez ci-dessous, le support présente une petite encoche arrondie sur son coté extérieur. Il faudra faire correspondre le côté où se trouve le petit rond que l'on observe sur la puce avec cette encoche.



3.1 Jouer du fer à souder

Avant de pouvoir utiliser le module HW-260, nous allons devoir souder les broches qui nous permettront de raccorder les pins de l'Attiny que nous placerons sur le socket. 


Les  HW-260 sont livrés avec un plot de 8 broches organisées en 2 rangées de 4. Ce plot sera à souder sur le PCB. Par contre, il n'y a pas les 3 broches destinées à l'alimentation correspondantes à la ligne sur le coté droit de la plaque. Mais quand on joue au poker, il faut de la chance et j'avais acheté il y a quelque temps un lot de barrettes de connexion (comme ICI) et du coup j'ai pu découper une petite ligne de 3 broches sur une barrette mâle-mâle. 



J'ai commencé par souder la ligne de 3 broches puis l'ensemble de 2*4. La soudure est minutieuse mais on y arrive assez facilement. 



Le résultat final est plutôt bien et on obtient le schéma de brochage suivant: 

Schéma de brochage: HW-260 pinout

3.2 Téléverser le noyau Micronucleus dans l'Attiny





Notre platine HW-260 étant prête, avec ses jolies petites broches soudées et sa jolie petite attiny85 placée dans son support nous allons pouvoir nous lancer dans l'installation des tous les logiciels nécessaires. 





Pour information, vous pouvez faire le test, si dans l'état actuel de notre installation vous raccordez la platine à l'ordinateur en USB, vous devriez avoir un message de Windows disant: "Périphérique USB inconnu". Et dans le gestionnaire de périphérique* vous devriez voir quelque chose comme ça:


*Pour accéder au gestionnaire de périphérique je fais: click droit sur <Ce PC> (ou <Ordinateur>) sur le bureau. Puis <Propriétés> et <Gestionnaire de périphérique>.


3.2.1 Rappels de principe

Le principe d'une platine de développement (ou carte de développement) c'est de pouvoir la brancher en USB à un ordinateur et de pouvoir y téléverser un programme directement, sans avoir à passer par un programmeur externe.

Pour qu'une telle fonctionnalité soit possible, on le comprend bien, il faut que cette carte puisse être reconnue par l'ordinateur comme un périphérique USB. Et pour que ce soit possible, il faut que sur la carte il y ait un composant qui dialogue avec un logiciel sur l'ordinateur pour que les deux puissent se reconnaître. A mon avis ils doivent avoir un échange qui ressemble à ça:
       - Composant: "hé ho, je suis un composant USB"
       - Ordinateur : "Ok je te reconnais et je connais ton langage. Donc je te déclare dans ma liste de équipements reconnus".

Malheureusement, sur l'attiny, comme sur la platine HW-260, il n'y a pas de composant qui sait gérer l'USB. Mais l'USB n'est après tout qu'une manière d'envoyer de l'information à partir d’impulsions électriques. Donc lorsqu'on est un microcontrôleur il est tout à fait possible d'émuler un tel composant à partir d'un logiciel. Cela va être un des rôles du bootloader.

Un BootLoader est un code qui s'exécute lorsqu'un microcontrôleur est mis sous tension ou après une réinitialisation. Dans notre cas, nous attendons du bootloader qu'il réalise les actions suivantes;

  1. Se déclarer en tant qu'appareil USB pour pouvoir être reconnu si un ordinateur est connecté.
  2. Si l'ordinateur envois des données* sur l'interface de communication  (USB, SPI, UART) alors les écrire dans la mémoire de programme (flash) du processeur. L'appareil autorise (en activant un bit spécifique dans la configuration de la puce) un mécanisme d'auto-programmation pour télécharger le code de programme par le MCU lui-même.
  3. Lancer l'exécution du programme principal. 
*Le bootloader devra laisser un certain temps à l'ordinateur pour envoyer un programme et s'il ne le fait pas passer directement à l'étape 3. Dans notre cas ce temps est de 5 secondes. 

Pour résumer tout ça: Micronucleus est un bootloader (chargeur de démarrage) conçu pour les microcontrôleurs de la série attiny avec une interface USB minimale. Il permet à l'attiny d'agir comme un périphérique USB. Il réside toujours dans la mémoire flash, utilise les interruptions et reçoit le code utilisateur via USB et le stocke en flash. Il exécute le code utilisateur chargé s'il ne reçoit pas de demande de téléchargement de nouveau code dans les 5 secondes.

3.2.2 Outils pour graver le bootloader Micronucleus

Après ces rappels, nous comprenons pourquoi il nous faut maintenant réussir à graver micronucleus sur notre attiny. La première chose à faire est de le récupérer. Le nom du fichier est t85_default.hex et vous les trouverez en chargeant le ficher zip sur le GitHub associé ICI


Pour ma part j'ai dé-zipé le fichier sur mon bureau pour avoir un dossier nommé "micronucleus-master". Le noyau recherché se trouve sous: C:\Users\alex\Desktop\micronucleus-master\firmware\releases (Pour tous ceux qui ne s'appellent pas alex, la partie en italique sera différente et dépendra de votre environnent 😉). De la même manière, vous verrez que ce répertoire contient d'autres versions du noyau micronucleus destiné à d'autres MCU. Si vous avez un attiny84 vous prendrez t84_default.hex

Maintenant, si il n'y était plus, nous allons replacer notre attiny sur le montage réalisé dans le chapitre précédent, avec l'Arduino qui fonctionne comme programmeur ISP. Le montage doit être fonctionnel et l'Arduino doit être toujours vu connecté sur un port COM. Micronucleus étant un programme binaire, nous n'allons pas pouvoir utiliser l'IDE Arduino pour le téléverser sur l'attiny. L'outil qui devra être utilisé s'appelle AVRDUDE. L'IDE Arduino l'utilise également pour graver les binaires qui ont été compilés. C'est un outil en ligne de commande qui est un véritable casse tête à utiliser. Sans parler du casse tête pour le trouver sur le disque. Je l'ai trouvé dans ce répertoire: 

C:\Users\alex*\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino9\bin
*avec "alex" à remplacer en fonction de votre configuration. 

Vous pouvez l'exécuter en ouvrant une console (tapez cmd dans la barre de recherche W10 ou dans le menu exécuter de Windows7). Et lancer la commande: 

C:\Users\alex\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino9\bin\avrdude.exe -h

Vous devriez voir une liste d'options longue comme le bras s'afficher.
Si vous ne trouvez pas le programme dans le répertoire que je vous indique, lancez une recherche sur "avrdude.exe" dans l'explorateur de fichier sur tout votre disque. 

Je ne vais pas parler plus longtemps d'avrdude car en réalité j'ai trouvé un utilitaire qui s'appelle AVRDUDESS et qui va nous simplifier ... un peu ... la vie.

3.2.3 Utilisation d'AVRDUDESS pour graver Micronucleus

AVRDUDESS n'est qu'une interface graphique qui va simplifier l'usage d'AVRDUDE. Plus d'options complexes à lancer en ligne de commande. Il faudra simplement selectionner ce que l'on souhaite faire avec un système de menus et de boutons et lancer l'exécution. De plus AVRDUDESS s'occupe tout seul de trouver AVRDUDE.

La première chose à faire est de charger et installer le logiciel. Moi je l'ai trouvé ICI. Et n'ayant eu aucun soucis pour l'installer, je n'ai rien de plus à dire sur cette partie.

Avant de lancer le programme assurez vous d'avoir votre Arduino en mode ISP d'installé et avoir bien noté le port COM sur lequel il est.

Lorsque vous lancerez l'application, il vous faudra renseigner les paramètres:
     - Port: Mettez le port COM sur lequel se trouve votre Arduino.
     - Baud: Mettez 19200

Ensuite cliquez sur le bouton <Detect>: l'outil lance la commande avrdude correspondante, que vous aussi pouvez lancer à la main directement en mode console (vous aurez surement l'obligation d'ajouter l'option -C suivi du chemin d'accès au fichier avrdude.conf) si cela vous amuse:
avrdude -u -c stk500v1 -P COM4 -b 19200 -F -p m8 

Normalement vous devriez avoir un résultat du genre: Detected 1e930b = ATtiny85
Et les paramètres de votre MCU devraient se mettre à jour automatiquement (Flash/EEPROM/Modèle de MCU...).

Ensuite cliquez sur le bouton <Read> juste en dessous de la section "Fuses & Lock bits". Ceci aura pour effet de lire la valeur de fusibles de l'attiny. Vous pourrez aussi noter la ligne de commande correspondante avec avrdude et vous amuser à la lancer en mode console.

Les fusibles une série bits, répartis sur 3 octets, qui vont régir des fonctions de bas niveau du microcontrôleur. Vous trouverez plus bas dans cet article un paragraphe complet dédié aux fusibles et surtout à la manière de s'en sortir quand on a fait une fausse manipulation. Pour le moment, vous devez juste savoir que de mauvaises valeurs dans ces bits peuvent rendre l'attiny totalement inaccessible ou impossible à reprogrammer. Nous allons devoir modifier la valeur de ces fusibles pour que le noyau fonctionne. Soyez particulièrement vigilent et si vous vous trompez, pas de panique, rendez vous directement au chapitre suivant!

Ce que vous devriez voir avec AVRDUDESS

Mise à jour des fusibles:
Pour mettre à jour les fusibles il va falloir en connaitre les valeurs. Ce que nous cherchons à faire, c'est 4 choses:

  1. Activer la fonctionnalité "Self Programming" afin que le noyau puisse écrire dans la mémoire flash le programme qu'il recevra depuis la liaison USB
  2. Activer la fonction "Serial program downloading (SPI)" pour autoriser le chargement de programme en SPI sur les broches associées. 
  3. Fixer la fréquence d'horloge à 16Mhz, car c'est nécessaire pour la liaison en USB.
  4. Éventuellement désactiver la fonction BOD, qui ici ne nous servira pas. Vous verrez plus tard à quoi sert cette fonctionnalité. 

Comme toutes ces fonctionnalités sont gérée par des combinaisons de bits réparties sur 3 octets, il est impossible ici d'expliquer comment ça marche. C'est très compliqué et cela fait appel à des notions d'électronique qui dépassent largement le cadre de cet article. Nous allons donc faire simple et utiliser un site qui, propose un outil qui va calculer pour nous ces valeurs. Il suffira d'indiquer notre type de MCU et les fonctionnalités que nous souhaitons activer pour avoir le résultat. Rendez vous donc sur ce site ICI. Et sélectionnez votre MCU.

Ensuite vous tomberez sur une page constituée de 3 sections. Dans la première, nommée <Features> on peut sélectionner les fonctionnalité directement. Par rapport à ce que je vous ai dit précédemment, voici ce qu'il faudra cocher:

Fonctionnalités à activer sur les fusibles 

Finissez en validant sur <Apply feature settings> et rendez vous plus bas dans la page sur la troisième section.

Cette troisième section va donner la valeur hexadécimale des fusibles. Ici nous voyons que :

  • Low (L ou lfuse) = F1
  • High (H ou hfuse) = DF
  • Extended (E ou efuse) = FE

Valeur des fusibles correspondante aux fonctionnalités souhaitée

Vous n'aurez plus qu'a reporter ces valeurs dans les champs correspondants d'AVRDUDESS et le tour est joué. Vous pourrez procéder de deux manières:

  1. Soit vous gravez de suite ces valeurs en cliquant sur le bouton <Write>. Et dans ce cas vous allez voir ARVDUDESS lancer la commande avrdude correspondante. Si tout c'est bien passé les fusibles seront mis à la bonne valeur. 
  2. Soit vous cochez le bouton <Set fuses> et dans ce cas les fusibles seront mis à jour au moment de la programmation. C'est à dire quand nous allons injecter le noyau dans la puce. Pour ma part je préfère avancer pas à pas donc le faire en deux temps. 
Attention de ne pas vous tromper de bouton <Write> ou de modifier la valeur du champ tout en bas de cette section qui s'appel LB, comme Lock bit. Si vous activez LB alors vous ne pourrez plus modifier le MCU. Il faudra faire un effacement total. Bien évidement j'ai fait l'erreur! L'astuce pour faire un erase est de cocher le bouton "Erase Flash en EEPROM" et de lancer la commande <Program!> sans avoir sélectionné de fichiers dans les sections Flash et EEPROM. 

Graver le noyau:
Maintenant nous sommes prêt pour la toute dernière étape de notre histoire de noyau! Vous vous souvenez que nous avions chargé une archive avec les fichiers hex correspondant à notre MCU? Hé bien il va suffire de sélectionner ce fichier dans la barre de la section "Flash", de cliquer sur le bouton de sélection <Write>, de prendre une grande respiration et d'appuyer sur <Go> ou alors sur <Program!> si vous voulez faire la mise à jour des fusibles en même temps.


Si tout c'est bien passé voici ce que vous devriez obtenir. Et pour ceux d'entre vous qui souhaitent utiliser avrdude.exe, voici la ligne de commande:
avrdude -u -c stk500v1 -p t85 -P COM4 -b 19200 -F -U flash:w:"C:\Users\alex\Desktop\micronucleus-master\firmware\releases\t85_default.hex":a

AVRDUDESS vous remercie! 

3.3 Installer le driver Windows


Nous avions vu précédemment qu'en connectant la platine HW-260 à l'ordinateur, ce dernier affichait un message de périphérique USB inconnu. Maintenant que nous venons d'installer le bootloader sur l'attiny et que nous avons placé cette dernière sur la platine, que va t'il se passer si nous refaisons le test de raccordement ? Normalement, vous devriez avoir exactement le même message! Pourquoi me direz vous ? Et je vous répondrai tout simplement parce que tant que le driver sachant dialoguer avec le bootloader ne sera pas installé, ce sera le cas. Vous l'aurez compris, il faut donc que nous installions le bon driver windows. Et ce driver sous Windows s'appelle libusb-win32.

Il y a plusieurs méthodes pour installer ce driver, qui peuvent varier en fonction de votre OS. Normalement si vous êtes sous MAC ou Linux ce paragraphe ne vous concerne pas ces systèmes embarquent un driver (je n'ai pas pu valider cette information ... vous me direz).

Méthode Zadig:

Cette méthode est la plus simple possible car elle consiste uniquement à lancer le logiciel "zadig_2.1.2.exe" qui se trouve dans le dossier que nous avons extrait de l'archive micronucleus (chez moi dans C:\Users\alex\Desktop\micronucleus-master\windows_driver_installer). Il fonctionne avec toutes versions de windows depuis 7 et il va être particulièrement utile avec windows 10 qui est souvent récalcitrant pour installer des drivers non signés. 

Pour l'utiliser: 

  1. Allez dans le dossier et lancez l'application. 
  2. Dans le menu <Device> sélectionnez <Load Preset Device>. 


  3. Une fenêtre s'ouvrira dans le répertoire courant et vous pourrez sélectionner le fichier "micronucleus.cfg". Faites le et cliquez sur <Ouvrir>.
  4. Vous aurez un écran comme ci-dessous et vous n'aurez plus qu'à cliquer sur <Install Driver>.

Pour en savoir un peu plus sur Zadig et l'installation des drivers vous pouvez regarder ICI ou ICI


Méthode Digistump.Drivers: 

Cette méthode est celle que j'ai utilisé mais je ne vous la conseille pas. En fait, au début de mes recherches sur les drivers à installer, je n'avais pas encore connaissance de la méthode avec Zadig et j'ai voulu anticiper en chargeant un package de driver. J'ai donc chargé le fichier ZIP "Digistump.Drivers.zip" qui, une fois dézipé, permet d'accéder aux installeur "DPinst.exe" et "DPinst64.exe". Pour la version windows 64 bits c'est le second qu'il faudra lancer. Si nous êtes en 32 bits ce sera donc le premier. 

Quelle que soit la méthode utilisé, une fois le driver installé, si vous connectez la platine en USB, vous devriez voir ça dans le gestionnaire de périphériques: 


Normalement ça devrait déjà fonctionner. Mais pour une version la plus à jour possible, faites un click droit sur "Digispark Bootloader" et  <Mettre à jour le pilote>. Vous aurez la toute dernière version du driver. 


Vous remarquerez que la carte n'est pas reconnue comme peut l'être un Arduino ou un autre microcontrôleur qui se connecte en USB. En effet, vous ne verrez pas de port COM associé. Ne vous inquiétez pas c'est tout à fait normal. 

3.4 Programmation de l'Attiny sur la platine via l'IDE Arduino


Après toutes ces étapes nous arrivons à la fin du parcours ... la dernière pièce du puzzle: téléverser un programme sur notre platine depuis l'IDE Arduino! Hé bien quand on croit que c'est fini, parfois c'est pas tout à fait fini! Avant de pouvoir écrire du code et appuyer sur le bouton téléverser nous allons devoir passer par encore une étape préparatoire. Allez courage ... nous touchons tout de même au but!

3.4.1 Configuration IDE Arduino pour Digispark

De manière très simplifiée, l'IDE Arduino n'est qu'une interface graphique dont le but est de permettre d'écrire du code, de le compiler avec un compilateur correspondant au type de microcontrôleur à programmer et ensuite d'en téléverser le fichier binaire obtenu dans la mémoire de ce dernier.

Notre carte de développement n'est plus vraiment un attiny puisque nous lui avons ajouté des fonctionnalités spécifiques: une platine avec une connectique USB, un bootloader (micronucleus), ... 

Ce que nous avons construit correspond à la norme d'un projet Open Source de cartes de développement pour attiny qui s'appelle DigiSpark. D'ailleurs vous pouvez trouver dans le commerce des constructeurs qui vendent des cartes DigiSpark toutes faites (comme ICI). En fait ce que nous venons de faire c'est le travail d'un assembleur électronique tel qu'AZ-Delivery. Notre avantage c'est que la puce n'est pas soudé sur la carte et que nous pourrons modifier le bootloader si sa version change. Sans compter le plaisir de nous cultiver comme nous l'avons fait!

Et puisque nous avons créé une carte DigiSpark, il va falloir que nous IDE Arduino puisse la gérer. Nous allons donc devoir lui déclarer cette nouvelle carte.

Pour cela, dans l'IDE Arduino, allez dans le menu <Fichiers><Préferences>.
Dans le fenêtre qui s'affiche, ouvrez la zone de texte des "URL de gestionnaire de cartes supplémentaires" et ajouter une nouvelle ligne contenant: 

http://digistump.com/package_digistump_index.json

Ajout d'une URL dans le gestionnaire de cartes
Ensuite allez dans <Outils> <Type de carte> et ouvrez <Gestionnaire de carte>


Dans le gestionnaire de carte, recherchez "digistump". Normalement vous devriez voir le choix "Digistump AVR Boards by Digistump ...". Selectionnez cette carte et cliquez sur <Installer>


Retournez dans <Outils> <Type de carte> et sélectionnez la carte "Digispark (Defaut - 16.5Mhz)"
Une fois que c'est fait, dans le menu <Programmeur> sélectionnez "Micronucleus". 


Voila c'est terminé, l'IDE Arduino est désormais capable de programmer notre platine de développement ... notre DigiSpark je devrais dire! Testons cela de suite ...

3.4.2 Création et injection d'un sketch pour notre DigiSpark

Notre carte de développement sur la base d'une carte HW-260 fonctionne exactement comme une carte DigiSpark classique. Donc ce que nous allons voir dans ce paragraphe s'appliquera à toutes les cartes DigiSpark. 

Si vous avez bien suivi toutes les étapes précédente comme je l'ai indiqué, vous devriez vous retrouver en ce moment même avec votre IDE configuré et la carte DigiSpark raccordée à votre PC. Une LED rouge fixe devrait être allumée prouvant que la carte est sous tension. Dans le gestionnaire de périphérique vous devriez voir un périphérique "libusb-win32" connecté. Par contre vous ne devriez toujours pas avoir de port COM correspondant au DigiSpark. Et c'est toujours normal. Vous en aurez jamais. En réalité le téléversement du programme sur la carte va se faire différemment que sur un Arduino. Je vous explique. 

Vous vous souvenez que nous avons parlé du fonctionnement du noyau? Nous avions dit que son rôle était d'attendre 5 secondes si on lui injecte un nouveau programme et s'il ne reçoit rien, il lance le programme actuellement dans sa mémoire flash. Retenez également, cela sera utile, que la communication des données entre l'ordinateur et la carte va s'appuyer sur les broches P3 et P4. Donc si le DigiSpark est connecté à l'ordinateur depuis plus de 5 secondes, on peut penser que le bootloader n'attend déjà plus qu'on lui envois un programme et est passé à autre chose. Dans notre cas, ce n'est pas totalement vrai car il n'y a encore jamais eut de programme téléversé dans la mémoire flash, donc le bootloader ne peut qu'attendre. 

Voici la manipulation à réaliser de manière générale pour téléverser un programme: 
  1. Laissez la carte HW-260 déconnectée. 
  2. Ecrivez votre programme et compilez le pour valider qu'il est correct. 
  3. Quand tout est prêt lancez le téléversement du programme en laissant la carte déconnectée!
  4. L'IDE va préparer le téléversement et quand tout sera prêt vous verrez le message suivant: "Plug in device now ..."
  5. Vous avez 60 secondes pour connecter la carte. Dès que vous allez le faire, vous verrez le programme se téléverser et finir par un merci : ">> Micronucleus done. Thank you!" 






Victoire! Nous venons de remporter la partie avec brio et je dirais que c'est une quinte flush royale! 






Avant de passer à un exemple de programme, je voudrais revenir sur un point. Lorsque vous aurez téléversé votre programme et qu'il commencera à s'exécuter, vous verrez le message de windows qui va vous avertir avoir détecté un périphérique USB inconnu. Et vous ne verrez plus votre carte reconnue dans le gestionnaire de périphérique. Par contre, si vous déconnectez et reconnectez la carte, vous verrez qu'elle est bien reconnue et après un petit moment, à nouveau cette perte de connexion. Ce comportement est tout à fait normal et s'explique par le fonctionnement du bootloader. Au moment de la connexion, c'est le bootloader qui s'exécute et il va communiquer sur les ports P3 et P4 avec le PC pour simuler une connexion. Mais juste avant que le bootloader lance le programme principal dans la mémoire flash, pour que ce dernier puisse utiliser les broches P3 et P4 normalement, il va les libérer. A ce moment, Windows va perdre la connexion et ne reconnaîtra plus la carte.

Schéma de brochage: HW-260 pinout

3.4.3 Exemple de code

La platine de développement HW-260 intègre, en plus de la LED de tension, une LED associée à la broche PB1. Comme petit exemple de code, je vous propose de réaliser un montage ultra simple, avec une LED sur la broche PB3. Le sketch que nous allons écrire consistera simplement à faire clignoter cette LED et la LED sur la plaque. L'interet est que vous puissiez voir quand le programme se téléverse qu'il se passe des choses sur la broche PB3 (on aurait aussi pu choisir PB4). 

Voici le montage: 


Voici le code:


#define LED_BUILTIN 1
#define LED_USB 3
#define DELAI 1000

void setup() {
  // initialize digital pin
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(LED_USB, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on (HIGH is the voltage level)
  digitalWrite(LED_USB, HIGH);      // turn the LED on (HIGH is the voltage level)
  delay( DELAI );                   // wait for DELAI
  digitalWrite(LED_BUILTIN, LOW);   // turn the LED off by making the voltage LOW
  digitalWrite(LED_USB, LOW);       // turn the LED off by making the voltage LOW
  delay( DELAI );                   // wait for DELAI (ms)
}


4  Les fusibles


A la base, je n'avais pas prévu d'écrire ce paragraphe. Déjà parce que je ne connaissais pas du tout l’existence de ces fusibles dans les attiny et quand j'ai commencé à creuser un peu et que j'en ai entendu parlé, j'ai pensé que c'était trop avancé pour être abordé dans le cadre d'un article de découverte. Mais parfois nécessité fait loi et ayant fait quelques petites erreur de manipulation en bidouillant sans le savoir ces satanés fusibles, j'ai du approfondir le sujet pour m'en sortir. Du coup, comme je me dis que je ne dois pas être le seul électro bidouilleur qui plante son microcontrôleur avec de fausse manip,  j'ai décidé de prendre mon courage à deux doigts et d'écrire ce chapitre pour partager avec vous quelques astuces concernant les fusibles qui vous sauveront peut être la vie à vous aussi un jour. 

4.1  C'est quoi ces fusibles ?

Disons le sans détours: quand on parle des fusibles de l'attiny ou d'une puce électronique, on ne parle pas de ces machin qui équipent les tableaux électriques pour protéger des surtensions! Dans le monde des microcontrôleurs, les fusibles (fuses in English) sont des bits* qui permettent de configurer des paramètres spécifiques du MCU. 

*Notez que ces bits fonctionnent en logique "0". Ceci signifie que si la valeur est "0", la fonction associée est considérée comme programmée et si le bit est à "1" on considère la fonction non programmée. 

Parmi ces fonctions on retrouve par exemple la vitesse de l'horloge interne ou l'activation/désactivation de fonctions particulières sur certaines broches (comme le RESET sur PB5 de l'attiny85). 

Ces fusibles ont une configuration par défaut que l'on peut changer. Mais normalement une fois que c'est fait, on ne devrait plus avoir besoin d'y revenir, sauf si bien sur on décide d'utiliser la puce pour un usage différent. 

Ensemble les fusibles représentent 3 octets ... donc 24 bits. Chacun de ces octet est identifié par un nom: Low Fuse (lfuse), High Fuse (hfuse) et Extended Fuse (efuse).

Leur valeur est permanente, dans le sens ou elle ne change pas lorsque l'on coupe l'alimentation électrique, mais comme annoncé plus haut, le programmeur peut la changer autant de fois qu'il le souhaite.

4.2 Que faire avec les fusibles ? 


Maintenant que nous savons de quoi on parle quand on parle des fusibles, la question que nous pouvons légitimement nous poser c'est concrètement à quoi ça peut servir? Nous allons donc répondre à cette question et ensuite il ne nous restera plus qu'à étudier par quels moyens on peut modifier la valeur de ces fusibles.

Modifier les fréquences: 

Par défaut, le ATtiny fonctionne à 1 MHz. Sa fréquence interne est configurée à 8 Mhz mais une option de division par 8 est activée. 

Pour faire fonctionner la liaison série avec la bibliothede SoftwareSerial l'attiny devra fonctionner au minimum à 8Mhz. 
Pour pouvoir communiquer en USB avec un ordinateur, la puce devra fonctionner à 16Mhz. 

Avec les fusibles on peut activer/désactiver la division des fréquences. On peut modifier la fréquence interne. On peut sélectionner une source de fréquence externe. 


Paramétrer le BOD (Brown Out Detection):

Le BOD  est une fonctionnalité  qui sert à faire un reset lorsque celui-ci est sous alimenté. Cela permet d'éviter que le processeur fasse n'importe quoi quand sa tension d'alimentation est trop faible.Ce niveau minimum de tension peut être de 1,8V, 2,7V ou 4,3V. 

Mais parfois, il n'y a aucun risque qu'une sous alimentation lui fasse faire n'importe quoi et on préférera désactiver cette fonction pour économiser encore plus d'énergie.

La fonctionnalité BOD se gère au niveau des fusibles.

Fonctionnalité des broches:

Sur les attiny25/45/85 la broche BP5 porte la fonction de RESET externe. C'est à dire qu'une impulsion sur cette broche reset le MCU. Mais comme le nombre de GPIO est limité, pour certaines applications il faudra une broche supplémentaire. Il est possible de désactiver la fonction reset sur BP5 pour faire de cette broche une sixième broche GPIO utilisable.

Mais attention, si vous faites cela, vous ne pourrez plus programmer le microcontroleur normalement avec un Arduino en mode ISP.

La fonction RESET est gérée par les fusibles.


Autres fonctions : 

Auto-programmation, débogage, communication en mode ISP, protection de la mémoire EEPROM et d'autres fonctions sont également configurables uniquement avec les fusibles.


4.3 Comment modifier les fusibles 


Pour finir en beauté ce chapitre sur les fusibles des microcontrôleur AVR, il ne nous reste plus qu'à mettre en oeuvre toutes les connaissances acquises. 

Toutefois j'attire votre attention que modifier les fusibles n'est pas anodin et que le changement de certains paramètres pourrait rendre votre attiny inaccessible de manière normale et plus opérationnel. Si cela vous arrive, pour votre peine vous devrez lire attentivement les solutions que je décrirais ci-dessous. 

Comme nous l'avons vu dans les paragraphes précédents, les valeurs attribuées aux fusibles vont influencer le fonctionnement du microcontrôleur. Mais certaines fonctions nécessitent d'être programmées sur plusieurs bits. Par exemple, pour la fréquence, 4 bits sont nécessaires (CKSEL0 à CKSEL3). Ces 4 bits nous donne donc 16 combinaisons possibles pour fixer la fréquence. Sauf que ces combinaisons ne sont pas facilement interprétables car elles sélectionnent également la source de la fréquence. Dans l'Attiny85 le timer peut-être externe, interne sur la base d'un oscilateur ou interne sur la base d'une source PLL (je ne vous explique pas ce que c'est car c'est trop compliqué). Et en plus, ces 4 bits vont avoir un effet différent en fonction de la valeur d'autres bits. Par exemple SUT0 et SUT1 qui vont fixer un délais de démarrage ou CKDIV8 qui va diviser la fréquence d'un des timers interne par 8. En résumé c'est le BAZARD! Si je vous raconte tout ça, c'est pour dire qu'on ne peut pas activer ou désactiver une fonction de manière simple en changeant la valeur unitaire d'un fusible. Mis à part pour quelques fusibles simples qui fonctionnent de manière unitaire (RSTDISBL par exemple), il faudrait avoir une connaissance approfondie de ce que signifie toutes les combinaisons. Et cette connaissance dépasse largement mes compétences et le cadre de cet article. 

Si malgré tout vous avez envie de vous y plonger, je vous conseille de lire attentivement le datasheet de la puce que vous souhaitez programme. Pour l'attiny vous le trouverez ICI

Mais sans aller jusque là, il existe un moyen plus simple pour calculer les bonnes valeurs des fusibles. 

4.3.1 Calcul de la valeur des fusibles

Le plus simple pour obtenir la valeur des fusibles correspondants à votre modèle de microcontrôleur et aux fonctions que vous souhaitez activer est d'utiliser un "calculateur". Il en existe peut etre plusieurs mais en ce qui me concerne j'ai utilisé celui du site http://www.engbedded.com/. Il est en Anglais mais suffisamment simple pour que même moi je m'y retrouve.

Il fonctionne de la manière suivante: 

1/ Choisir le modèle de microcontrôleur. La liste contient actuellement 141 microcontrôleurs AVR Atmel.

2/ Ensuite vous aurez accès à 3 outils qui vous permettront de calculer la valeur des fusibles.

Le premier de ces outils vous permettra d’obtenir la valeur des fusibles en sélectionnant les fonctions que vous souhaitez activer. Ce qui, il faut l'avouer, est plutot simple. Parmi ces fonctions on retrouve la fréquence d'horloge. A moins que vous utilisiez un timer externe, vous devrez choisir dans la liste parmi les item qui ne commencent pas par EXT. Vous pourez aussi activer "Brown-out Detection" et en choisir le niveau (cette option protège le 𝜇C de faire n'importe quoi en cas d'une chute de tension).
Avec l'item "Reset Disable" vous pourrez désactiver la fonction de reset sur la broche PB5 pour en faire une broche GPIO classique.

Lorsque que vous validerez votre sélection avec <Apply feature settings> l'ensemble de la page va se mettre à jour et les données définies dans cet outils se répercuteront dans l'outil suivant.

Le second outil, est un tableau qui montre les bits de chacun des octets correspondants aux fusibles. Vous pouvez activer ou désactiver chaque bit unitairement. Lorsque vous avez sélectionné une configuration dans l'outil précédent, les valeurs correspondantes des bits viendront se mettre à jour dans ce second outil. Il peut être utile notamment pour affiner une configuration ou alors si vous connaissez précisément les valeurs que vous souhaitez imposer à certains bits. Attention à la logique de ce tableau, car une case cochée signifie que la valeur du bit correspondant est à "0" et non "1". 


Le troisième outil est simplement le résultat des deux précédents. Il affiche la valeur qu'il faudra rentrer dans chacun des fusibles pour activer la configuration que vous venez de définir. Mais il a aussi une autre possibilité. Si vous saisissez la valeur d'un fusible dans une des case, en appuyant sur <Apply values> cela va mettre à jour les champs dans les deux outils différents. Ce qui vous permettra assez facilement de savoir à quoi correspond la configuration du microcontrôleur si vous n'avez que la valeur du fusible. 



Maintenant que nous savons comment avoir la valeur des fusibles, il nous reste à regarder comment nous allons pouvoir les modifier sur la puce.

4.3.2 Méthodes pour modifier les fusibles


Je ne connais pas le nombre d'outils et de méthodes qui existent pour accéder et modifier les fusibles dans le microcontrôleur. Par contre j'en connais 3 différentes qui ont chacune leurs avantages et leurs inconvénients. C'est peut être idiot à dire, mais pour modifier les fusibles il faut pouvoir y accéder. Et pour y accéder on doit passer par un programmeur ISP (on a déjà parlé de ça largement dans le chapitre sur la programmation de l'attiny). Les deux première méthodes vont fonctionner lorsque le microcontrôleur sera accessible normalement par son programmeur. Mais parfois, on fait des erreurs de manipulation et on modifie les fusibles de telle sorte que nous n'avons plus accès au microcontrôleur. Et dans ce cas, la troisième méthode nous permettra de sortir de l'impasse.

Voici ces trois méthodes: 

  1. Méthode 1: A partir de l'IDE Arduino tout simplement. Toutefois cette méthode est limitée car elle ne permet que d'accéder aux fusibles qui gèrent la fréquence et le choix du timer. Dans le paragraphe 2.2.4 nous avions expliqué qu'il fallait sélectionner la fréquence et ensuite la graver. Maintenant que nous avons parlé des fusibles, nous savons concrètement ce que cela signifie. Lors d'un de mes essais, je me suis trompé et choisi un timer externe. J'ai consacré le paragraphe 4.3.3 à cette mésaventure et vous pourrez y trouver quelques détails sur la méthode 1 de modification des fusibles. 

  2. Méthode 2: A partir d'un logiciel spécifique. Et THE logiciel dédié à la programmation des 𝜇C AVR c'est AVRDUDE. Même l'IDE Arduino l'utilise pour transférer les programme binaires. AVRDUDE permet également d'accéder aux fusibles (ça tombe bien) ou de calibrer les oscillateurs internes. En général il fait partie d'une suite logiciel qui permet de créer et téléverser des programmes directement sur un microcontrôleur sans passer par la suite Arduino. La mauvaise nouvelle c'est qu'il s'agit d'un outil en ligne de commande et je vous avoue que même après plusieurs heures à bidouiller j'ai bien du mal à m'y retrouver. Je ne peux pas vous faire un cours sur l'utilisation de ce logiciel car ça pourrait être un article complet. En cherchant sur le net vous trouverez des sites qui expliquent comme l'utiliser. En Anglais ICI. Un manuel, Anglais également ICI. Ou encore un tuto en Français ICI.  Par contre je peux vous donner la ligne de commande qui correspond à la modification des fusibles pour leur donner les valeur: 0xF1/0xDF/0xFF. On suppose que le 𝜇C est programmé avec un Arduino connecté au port COM4. La communication se fera à 19200 bauds. 

    avrdude -u -c stk500v1 -p t85 -P COM4 -b 19200 -F -U lfuse:w:0xF1:m -U hfuse:w:0xDF:m -U efuse:w:0xFF:m
  3. Méthode 2 bis: Sur le même principe qu'AVRDUDE mais en beaucoup plus sympa et facile à utiliser, il y a le logiciel "AVRDUDESS". En fait je pense qu'il ne s'agit que d'une interface graphique qui s'appuye sur AVRDUDE. Elle permet de lire et de graver les fusibles de manière simple et rapide. Pour une fois je vous laisse chercher vous même le liens pour le télécharger ... et puis NON!  

  4. Méthode 3: En utilisant un programmeur AVR haute tension. En Anglais ils disent AVR High Voltage  Programmer. Il s'agit tout simplement d'un Arduino qui va piloter une alimentation de 12V pour reprogrammer les fusibles quand l'AVR n'est plus accessible. Et celui là je l'ai réalisé et il m'a sauvé la vie. Je vous décris le montage, le programme et toutes les bêtises qu'il ne faut pas faire dans le chapitre 4.3.5.
Voila, désormais vous en savez autant que moi sur les méthodes pour modifier les fusibles. Il ne vous reste plus qu'à lire les deux chapitres suivants qui vont vous montrer concrètement mes réalisations. 

4.3.3 Erreur sur le choix de l'horloge interne/externe

L'IDE Arduino permet de modifier la valeur des fusibles associés à l'horloge. Pour se faire il faut aller dans le menu <Outils> et cliquer sur <Graver la séquence d'initialisation>:


Ceci à pour effet de fixer la configuration de l'horloge de l'attiny conformément à la configuration spécifiée dans le champ "<Clock>" du menu <Outils>". Les fusibles correspondant de l'attiny seront "brûlés". Les choix possibles sont la fréquence (1Mhz, 8Mhz, 16Mhz et 20Mhz)* et la source du signal d'horloge (interne ou externe). Si vous choisissez "internal", le MCU va chercher son signal d'horloge sur son propre timer. En choisissant "external" le MCU va attendre de recevoir un signal sur sa broche CLCKI (PB3)*. Et il ne fonctionnera plus tant que ce signal ne sera pas reçu. 

*ces données sont pour un attiny85 mais peuvent être différentes en fonction de votre modèle d'AVR. 

Et si comme votre pote agé (je parle de moi là), vous faites l'erreur de graver la séquence en confondant "internal" et "external", c'est là que les ennuis commence et c'est la misère! 

Déjà vous remarquerez que l'attiny le répond plus, ne fonctionne plus, n'accepte plus de programme en téléversement et même n'accepte plus qu'on lui grave une nouvelle séquence d'initialisation pour rattraper cette bêtise. 

Voici ce que l'IDE Arduino va vous afficher lors d'un essais de téléversement et de gravure de la séquence d'initialisation:



Parmi ces messages d'erreurs on distingue: 
  • avrdude: Device signature = 0x000000 : qui nous indique que le MCU n'est plus reconnu. Ou plutôt que le logiciel avrdude, qui est utilisé par l'IDE Arduino pour accéder aux fusibles, n'a pas réussi à lire la valeur de cette signature. 
  • avrdude: Yikes!  Invalid device signature.
             Double check connections and try again, or use -F to override
             this check.
    :
    qui nous averti qu'il faut vérifier les connections. Comme si on avait besoin de ça!
  • Une erreur est survenue lors du transfert du croquis : echec du téléversement.
Après s'être bien pris la tête à revoir les câblages, à modifier les configurations dans tous les sens, à refaire de nouveaux croquis, force est de constater que rien n'y fait et qu'il va falloir commencer à réfléchir.

Et là on commence à comprendre qu'en changeant la valeur des fusibles, le MCU ne démarre plus car il ne dispose plus du signal d'horloge dont il a besoin pour fonctionner. L'horloge c'est un peu le cœur qui pulse dans le processeur. Sans ces pulsations, rien ne peut se faire. En poussant plus loin la réflexion, on se dit que pour réparer ça il ne peut y avoir que deux solutions:

  1. Soit on donne au MCU le signal d'horloge externe qu'il attend, ce qui va lui permettre de fonctionner et ce qui devrait nous permettre de reprendre la main pour modifier la configuration. 
  2. Soit on arrive à "brûler les fusibles" pour les replacer dans une configuration initiale.
 Hé bien je vous propose que nous étudions ces deux solutions qui pourront vous sauver la vie!

4.3.4 Signal d'horloge externe via l'IDE Arduino


Si comme moi vous avez programmé les fusibles sur un signal d'horloge externe, vous aurez constaté que votre attiny, tout d'un coup ne répond plus. Vous avez beau lancer toutes les commandes possibles depuis l'IDE Arduino ou des programmes spécifiques comme AVRDUDE, l'attiny reste invisible et inaccessible. Ce qui se passe est simple: la programmation des fusibles sur horloge externe à pour effet de désactiver l'horloge interne et de mettre le composant en attente d'un signal externe. Tant que ce signal externe n'est pas reçu, la puce ne fonctionne plus car c'est le signal d'horloge qui rythme le déroulement du logiciel. Et si comme moi vous utilisez un Arduino comme programmeur ISP alors respirez car la solution va être simple. 



La solution est va être de demander à l'Arduino de fournir un signal d'horloge sur une de ses broches. Cette broche pourra être reliée à la broche de signal externe de l'Attiny et ce dernier sera à nouveau accessible. Voyons comment faire. 

Le prérequis est que vous ayez bien suivi (et compris) toutes les étapes du chapitre 2 et que vous ayez votre Arduino avec le sketch "ArduinoISP" ainsi que le montage sur la breadboard avec l'Attiny tel que réalisé dans le paragraphe 2.2.2. 

Nous allons devoir modifier légèrement le code du sketch "ArduinoISP" pour que l'Arduino puisse générer sur sa broche 3 un signal d'horloge de 8Mhz compatible avec l'attiny. 

Pour cela: 

1/ Enlevez le condensateur que nous avions placé sur l'Arduino entre le GND et le RESET. 

2/ Remettez les paramètres de configuration nécessaires pour programmer l'Arduino normalement: 
  • Type de carte: Arduino Uno (si vous utilisez un UNO sinon vous mettez votre modèle).
  • Port: le nom du port COM sur lequel est vu votre Arduino
  • Programmateur: ArduinoISP (ne pas confondre avec "Arduino as ISP").



3/ Chargez le sketch "ArduinoISP" dans l'IDE Arduino,qui se trouve dans "<Fichier><Exemples><11.ArduinoISP>ArduinoISP"


4/ Ajoutez les lignes de code ci-dessous dans la fonction setup(). Pour ma part je les ais ajoutées juste avant l'accolade fermante de la fonction.
pinMode(3,OUTPUT);
TIMSK2=0;
OCR2A=0;
TCCR2A=(1<<COM2B0)+(1<<WGM21);
TCCR2B=(1<<CS20);

5/ Téléversez ce sketch dans l'Arduino. La LED "heartbeat" devrait "battre" à nouveau. Sinon faites un RESET de l'Arduino. 

6/ Sur le montage tel que décrit en 2.2.2 reliez la broche GPIO 3 de l'Arduino à la broche PB3 (qui porte la fonction CLKI comme "Clock Input" je suppose). 

L'attiny devrait à nouveau fonctionner et vous verrez la LED verte clignoter si vous aviez injecté le sketch de test que je vous avais donné. Mais si ce n'est pas le cas, c'est que vous devez à nouveau téléverser le sketch de test.


7/ La dernière étape sera de repasser l'Arduino en mode programmeur ISP. Il faudra replacer le condensateur,  configurer l'IDE pour générer du code pour l'Attiny85 (ou votre modèle), choisir la bonne fréquence d'horloge INTERNE cette fois, et graver la séquence d'initialisation à nouveau, comme décrit en 4.3.3. Quand ce sera fait vous pouvez alors téléverser à nouveau le sketch. Ne le faites pas avant d'avoir gravé la séquence d'initialisation car vous pourriez avoir un programme compilé pour fonctionner à une fréquence qui n'est pas celle du MCU. Et donc des timing qui seraient faussés (fonction delay par exemple). 

Le fil marron fourni un signal d'horloge à l'attiny

Tout devrait être rentré dans l'ordre. Nous voila sauvés.


4.3.5 Création d'un brûleur de fusible "High Voltage AVR Programmer"

Nous venons de voir comment nous sortir d'une erreur de programmation des fusibles quand il s'agissait d'une erreur concernant la source du timer. Mais rassurez vous (😉), il y a d'autres possibilités de bloquer votre attiny avec les fusibles. Par exemple, si vous désactivez la fonction RESET de la broche PB5, vous ne pourrez plus accéder au microcontrôleur avec un programmeur ISP classique. Ni pour téléverser un programme, ni pour modifier les fusibles en utilisant des outils comme AVRDUDE. La seule solution va consister à utiliser la méthode HVSP (High-voltage Serial Programming). Cette méthode consiste à placer l'attiny sous une tension de 12V et avec un Arduino reprogrammer directement la valeur des fusibles. Il n'y a aucune difficultés, il faudra juste avoir un peu de matériel et de patience. 


Matériel nécessaire: 
  • Un Arduino: Pour ma part comme mon UNO était occupé comme programmeur ISP j'ai utilisé un Nano comme ICI, que j'avais en stock. 
  • Une breadboard: Pour ce que nous allons faire, choisissez plutôt une 830 points comme ICI. Il vous faudra aussi des câbles Dupont comme ICI. Sinon vous pouvez commander cet ensemble breadboard et câbles ICI.
  • 6 résistances 1000 Ω et un transistor NPN: Pour le transistor je pense que tout modèle NPN va convenir. J'ai vu le montage réalisé avec un 2N3904 mais moi je n'avais que des S8050 et cela a fonctionné.  Pour tout ce petit matériel procurez vous un kit avec le plus de valeurs possibles pour les composants. Ce vous servira à l'avenir. J'ai trouvé CELUI-CI qui me semble très bien et qui vous apportera les résistances et condensateurs nécessaires pour ce montage. 
  • Une alimentation 12V: Pour ma part j'ai utilisé une ancienne alimentation de PC. Si vous n'avez pas ça sous la main, 8 piles 1,5V (type AA ou AAA) feront l'affaire. 
Réalisation du montage: 

Je vais vous avouer que sur ce coup là, je n'ai pas réinventé la roue! J'ai juste passé des heures de recherche pour trouver un montage suffisamment simple et accessible pour un bidouilleur comme moi. C'est finalement celui sur la page de Wayne Holder (que je ne connais pas mais que je remercie), qui a retenu toute mon attention et que j'ai réussi à réaliser. J'ai constaté que ce montage a également été repris sur une autre page ICI. En voici le schéma:



Et voici chez moi ce que cela a donné: 




Bon vu comme ça on dirait que c'est n'importe quoi mais comme je me suis planté à plusieurs reprise dans la connectique j'ai voulu faire en deux temps entre les résistances et l'attiny. J'aurais pu faire plus simple. 

Programmation de l'Arduino: 

L'étape suivante consiste à programmer l'Arduino. Pour cela on procède de la manière la plus classique du monde, en le raccordant en USB au PC, puis en téléversant le programme depuis l'IDE Arduino. Ce programme étant un peu long, je l'ai ajouté dans la page de mon blog destiné à cet usage. Vous le trouverez ICI mais c'est celui que j'ai repris sur la page de Wayne. 

Utilisation du programmeur HVDC:

Une fois le sketch téléversé, ouvrez le moniteur série de l'IDE Arduino.
Assurez vous que le port COM est le bon.
Configurez la communication série sur 19200 bauds et pas de fin de ligne.
Ensuite envoyez n'importe quel caractère. Cela aura pour effet de lancer le programme et vous aurez quelque chose qui ressemble à l'affichage ci-dessous:


Vous pouvez voir la valeur des fusibles avant et après la mise à jour. Le programme va remettre les valeurs par défaut en détectant tout seul le type d'attiny. Il est compatible avec les modèles ATtiny13/24/25/44/45/84/85.

4.2.6 Quelques liens supplémentaires

Pour conclure cette longue mais très utile partie sur les fusibles, je vous laisse quelques liens qui vous permettront d'aller plus loin si vous en avez envie.

Mise à jour des fusibles avec programmeur HVSP:
https://o0tad0o.wordpress.com/2013/05/19/french-restauration-des-fuses-avr-attiny-avec-un-arduino/
https://sites.google.com/site/wayneholder/attiny-fuse-reset

Montage à partir de deux Attiny. Une qui servira de modèle pour l'autre. Je n'ai pas testé:
https://www.hackster.io/sbinder/attiny85-powered-high-voltage-avr-programmer-3324e1

Modes d'emplois AVRDUDE:
https://www.ladyada.net/learn/avr/avrdude.html
http://nongnu.askapache.com/avrdude/avrdude-doc-6.1.pdf
https://skyduino.wordpress.com/2011/12/02/tutoriel-avrdude-en-ligne-de-commande/


5 Conclusion 

Nous voici arrivés à la fin d'un article qui m'a pris des dizaines (centaines?) d'heures à écrire. En partant de quasiment rien, je suis parvenu à comprendre les fondamentaux de l'attiny et surtout, même dans ce que ce petit composant comporte de plus délicat à gérer: les fusibles. Pour moi, au travers de toutes ces connaissances acquises, c'est un nouveau champ des possibles qui s'ouvre. En effet, la faible consommation de la puce va me permettre de réaliser les projets d’objets connectés autonome dont je rêve depuis un moment. 
De plus, avec la platine de développement low-cost que nous avons mis au point, l'attiny va être d'une simplicité d'utilisation et de programmation quasiment du niveau d'un arduino. 

Je sais que cet article est certainement long et dense pour vous aussi amis lecteurs. Et je sais pertinemment que rares sont ceux qui le liront en entier. Mais en tant que jardinier de mes connaissances, je considère que tout ne peut pas être aussi immédiat et rapide qu'un tuto vidéo sur youtube. Ça vaut parfois la peine de se donner du mal, de creuser, d'avancer progressivement. Et pour tous ceux qui n'ont pas eu le courage de tout lire, et je vous comprends parfaitement, sachez que mon objectif est le partage de mes expériences et de mes connaissances acquises. J'espère simplement que ce que vous aurez trouvé dans cet article vous aura apporté l'information dont vous aviez besoin. 

Pour finir, je vous redonne quelques liens: sur du matériel et sur des pages internet qui m'ont bien aidées. 

5.1 Achats


Philosophie commerciale: Je ne suis pas actionnaire d'Amazon ou d'eBay. Les liens que je vous donne pointent sur du matériel compatible avec mes montages, que je recommande et que j'ai en général acheté moi même. Je choisi du matériel de bon rapport qualité/prix/service (livraison, SAV,...) Si vous faites un achat en passant par un de mes liens, la (minuscule) commission qui me sera versée ne nuira pas aux bénéfices des géant du e-Commerce et m'aidera à investir pour rédiger de nouveaux articles. Et si aucun matériel ne vous intéresse, vous pouvez mettre ce lien https://amzn.to/30xd8Ag dans vos favoris et l'utiliser quand vous aurez besoin de quelque chose sur Amazon.


Un GRAND merci à tous ceux qui ont joué le jeu et ceux d'entre vous qui le joueront



Ci-dessous vous trouverez les liens sur Amazon pour vous procurer des cartes DigiSpark et j'ai ajouté un lien sur un programmeur ISP: 

   


Du matériel, des kits et des composants qui seront essentiels pour réaliser des prototypes et montages: 

   


Quelques liens de matériel qui mettra pas mal de temps pour venir de Chine mais vraiment pas cher:

Des sockets pour attiny: DIP8 Integrated Circuit IC Sockets Adaptor Solder Type BB

Les attiny et les platines low-cost HW-260: ATTINY85 + Micro USB Development Programmer Board HW-260


5.2 Liens

Des wiki sur les microcontrôleurs Atmel AVR:
https://fr.wikipedia.org/wiki/Atmel_AVR
https://en.wikipedia.org/wiki/ATtiny_microcontroller_comparison_chart

Wiki de DigiSpark:
http://digistump.com/wiki/digispark

Toutes les infos techniques sur le site d'Atmel:
https://www.microchip.com/wwwproducts/en/ATtiny85
https://www.microchip.com/ParamChartSearch/chart.aspx?branchID=30047
Cliquer sur "Show ALL Products" sinon cela n'affichera que les nouveautés.

Téléchargement Micronucleus:
https://github.com/micronucleus/micronucleus

Modes d'emplois AVRDUDE:
https://www.ladyada.net/learn/avr/avrdude.html
http://nongnu.askapache.com/avrdude/avrdude-doc-6.1.pdf
https://skyduino.wordpress.com/2011/12/02/tutoriel-avrdude-en-ligne-de-commande/

Téléchargement AVRDUDESS:
https://blog.zakkemble.net/avrdudess-a-gui-for-avrdude/

Mise à jour des fusibles avec programmeur HVSP:
https://o0tad0o.wordpress.com/2013/05/19/french-restauration-des-fuses-avr-attiny-avec-un-arduino/
https://sites.google.com/site/wayneholder/attiny-fuse-reset

Montage à partir de deux Attiny. Une qui servira de modèle pour l'autre. Je n'ai pas testé:
https://www.hackster.io/sbinder/attiny85-powered-high-voltage-avr-programmer-3324e1

Quelques sites qui présentent des réalisations proches:
https://makbit.com/web/firmware/breathing-life-into-digispark-clone-with-attiny-mcu/
https://www.gotronic.fr/pj2-arduino-digispark-fr-1443.pdf

5.3 Soutenez la BlogoCulture

Le plus simplement du monde, si vous avez un achat à faire sur Amazon, accédez au site à partir de ce lien (que vous pouvez ajouter dans vos favoris)https://amzn.to/2weXW1i


Retrouvez la Framboise au Potager sur Facebook dans le groupe "Culture Domotique".


Merci

Commentaires

  1. Superbe article !
    Je comprends maintenant les difficultés à programmer un digispark par rapport à l'arduino as ISP.
    Merci !

    RépondreSupprimer
    Réponses
    1. Bonjour Neutrino,

      Merci pour ce commentaire.

      Je pense que l'article suivant, qui est en cours de préparation, ne sera pas trop mal également. Il va répondre aux questions qui se posent logiquement quand on a compris "les fondamentaux sur l'attiny".

      Mais ne spoilons pas ;-)

      Alexandre


      Supprimer

Enregistrer un commentaire