ATtiny85 : Programmation avec un Arduino

Introduction :

Les ATtiny sont des microcontrôleurs très intéressants car même s’ils ne sont pas très puissants (enfin certains seulement … comme celui que j’utilise pour cet article), ils ont l’avantage de ne pas être chers, de consommer peu d’énergie et de prendre peu de place.

Ils peuvent être utilisés pour réaliser des capteurs de mesure de la température, de l’hygrométrie ou de toute autre grandeur physico-chimique dans le cadre de l’internet des objets par exemple … Ou plus simplement pour par exemple fabriquer une carte d’anniversaire qui joue de la musique tout en faisant clignoter des LEDs.

Ils sont fabriqués par Atmel (la compagnie qui fabrique aussi les microcontrôleurs ATmega utilisés dans les Arduino).

Cet article montre comment il est possible de programmer facilement un ATtiny85 à l’aide d’un Arduino UNO transformé en programmateur ISP.

NB : ISP signifie « In-System Programming » qui se traduit par programmation in-situ. C’est un procédé permettant de programmer un microcontrôleur (ici l’ATtiny) alors qu’il est déjà en place sur la carte qu’il doit piloter.

Présentation de l’ATttiny85

Les caractéristiques techniques de ce micro-contrôleur sont les suivantes :

Taille de la mémoire Flash	8 Ko (pour stocker les programmes, elle est conservée même lorsque vous coupez l’alimentation)
Mémoire SRAM	512 Octets (Mémoire temporaire permettant de stocker vos variables par exemple. Elle est à la coupure de l’alimentation)
Mémoire EEPROM	512 Octets (Mémoire permettant de stocker des informations qui sont conservées après une coupure de l’alimentation Attention elle possède un nombre limité d’écriture environ 100 000).
Entrées/sorties (I/O)	Jusqu’à 6 I/O numériques PB0 à PB5 (5 en pratique, en effet la broche 1 (PB5) sert aussi au RESET du µC et n’est pas supportée par l’Arduino UNO) Jusqu’à 3 entrées analogiques (Analog input : Broche 7 ADC1, Broche 3 ADC2, Broche 2 ADC3) Jusqu’à 2 sorties en PWM (MLI en français) : Broches 5 et 6
Courant maximal en sortie	40 mA
Courant maximal total	200 mA
Tension d’alimentation	2.7 à 5.5 V
Fréquence d’utilisation	0 à 20 MHz

Photo de l’ATtiny85 :

Le petit rond gravé permet de repérer la broche 1.

Pour plus d’informations sur l’ATtiny85 vous pouvez vous reporter au datasheet du constructeur ICI.

Préparation IDE et programmation Arduino

Préparation IDE

La préparation de l’IDE Arduino en version 1.6.4 est décrite ci-dessous :

Aller dans les préférences et saisir l’URL  suivante :  https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json dans la zone « Additional board URL » en bas de l’écran, puis cliquer sur OK :

Aller ensuite dans le menu « Type de carte » / « Boards Manager », cliquer sur attiny et un bouton « Install » doit apparaître désormais.

Cliquer dessus.

Le message « INSTALLED » doit apparaître à la fin de l’installation comme on peut le voir ci-dessous :

… et dans le menu « Outil » / « Type de carte » il doit désormais y avoir ATtiny… Votre IDE Arduino est donc désormais prêt pour programmer des ATtiny.

Programmation Arduino

Dans le menu « Outil », sélectionner :

• Type de carte : Arduino UNO,
• Indiquer votre port COM.

Ensuite ouvrir le sketch ArduinoISP disponible via les menus dans les exemples et le téléverser dans votre Arduino.

Votre Arduino est désormais capable de programmer des ATtiny85.

Vérification Arduino comme ISP

Avant de passer à une première programmation d’un ATtiny, nous allons tout d’abord vérifier que le programme ArduinoISP est bien installé.

Pour cela, il faut relier les broches E/S numériques de l’Arduino ci-dessous à des LEDs via des résistances d’environ 250 ohms de la manière suivante (voir schéma et photo du montage en bas de page) :

• Broche D7 Arduino > LED bleue
• Broche D8 Arduino > LED rouge
• Broche D9 Arduino > LED verte

Brancher ensuite votre Arduino sur le port USB de votre PC et si tout se passe bien, la LED verte doit s’allumer et s’éteindre progressivement.

Les autres LEDs indiquent servent à indiquer :

• LED bleue : Programmation en cours,
• LED rouge : Erreur.

Débrancher le câble USB.

Connexion de l’ATtiny

Nous allons maintenant voir comment connecter l’ATtiny à programmer à l’Arduino.

Rappel du brochage de l’ATtiny85 :

Pour pouvoir programmer un ATtiny85, il faut connecter MISO, MOSI, SCK, RESET, VCC, et GND de l’Arduino vers l’ATtiny de la manière suivante (voir schéma et photo du montage en bas de page) :

• RESET : Arduino Broche D10 -> ATtiny Reset (Broche 1)
• MOSI   : Arduino Broche D11 -> ATtiny PB0 (Broche 5)
• MISO   : Arduino Broche D12 -> ATtiny PB1 (Broche 6)
• SCK      : Arduino Broche D13 -> ATtiny PB2 (Broche 7)

Ensuite, sur l’Arduino placer un condensateur chimique de 10 uF entre la broche RESET et la masse (GND) en respectant la polarité du condensateur. Le pôle négatif du condensateur est indiqué avec un trait.

Ce condensateur empêche la carte Arduino de faire un RESET et de redémarrer ainsi le bootloader lors des téléversements destinés à l’ATtiny. De cette façon en effet on est sûr que l’IDE Arduino rentre en communication avec le programme ArduinoISP (et non le bootloader) durant le téléversement du croquis qui est destiné à l’ATtiny et pas à l’Arduino qui doit rester chargé avec le programme ArduinoISP 🙂

En complément pour pouvoir tester la programmation de l’ATtiny85 avec notre premier programme de test blink, il faut ajouter une LED ici bleue entre PB4 de l’ATtiny et la masse en série avec une résistance d’environ 250 ohms.

Le schéma final complet est le suivant :

Photo du montage :

Premier test de programmation ATtiny avec l’Arduino

Une fois les connexions réalisées vous pouvez rebrancher votre Arduino sur le port USB de votre PC.

Nous allons maintenant réaliser un programme de test Blink qui permet de faire clignoter une LED et téléverser ce programme dans l’ATtiny à l’aide de l’Arduino comme programmateur ISP puis pour finir  nous réaliserons ensuite un chenillard.

Configuration IDE

Dans le menu « Outil », sélectionner désormais:

• Type de carte : ATtiny,
• Processeur : Attiny85,
• Programmateur : Arduino as ISP.

Configuration complémentaire de l’ATtiny à 8 MHz (optionnel)

Par défaut, l’ATtiny tourne à 1 Mhz. Pour pouvoir utiliser la bibliothèque SoftwareSerial par exemple (si vous en avez le besoin), il faut le programmer pour qu’il tourne à 8 Mhz.

Pour cela, une fois le montage réalisé présenté précédemment, il faut choisir dans le menu « Outil » / « Clock » / « 8Mhz INTERNAL ».

Ensuite sélectionner dans le menu « Outil » « Graver la séquence d’initialisation ».

Le code blink

Le code à saisir dans l’IDE Arduino est le suivant :

/*
  Programme : Blink
  Auteur : PHMARDUINO
  Date : Le 22/01/2020
  Description : Fait clignoter une LED sur un ATtiny85 branchée sur PB4 (broche 3)
 */


// Initialisations
void setup() {
  // Initialise digital pin ATtiny PB4 en sortie.
  pinMode(4, OUTPUT);
}

// Boucle infinie
void loop() {
  digitalWrite(4, HIGH);   // Allume la LED 
  delay(5000);             // Tempo
  digitalWrite(4, LOW);    // Eteint la LED
  delay(5000);             // Tempo
}

Ce code est disponible sous GitHub à l’adresse suivante : https://github.com/phmarduino/arduino/blob/main/attiny85/code/pm_attiny_isp_blink.ino

Le test blink

Brancher votre Arduino sur votre PC et téléverser le programme.

Ça doit fonctionner, la LED bleue reliée à l’ATtiny doit clignoter 🙂

On peut ensuite faire fonctionner l’Attiny85 de manière autonome avec un pile comme dans la photo ci-dessous :

Deuxieme test avec programmation d’un chenillard à quatre LEDs

Le code du chenillard

Saisir le programme ci-dessous dans l’IDE Arduino puis demander son téléversement dans l’ATtiny à l’aide de votre nouveau programmateur d’ATtiny à base d’Aduino 🙂

/*
Chenillard avec un ATTINY 85 programmé en ISP avec un Arduino UNO
Fait le 11 12 2015
 */

#define VERT 0    // La led verte est sur la brohe 0 de l'ATTINY
#define ROUGE 3   // La led rouge est sur la brohe 3 de l'ATTINY
#define BLEU 2    // La led bleue est sur la brohe 2 de l'ATTINY
#define JAUNE 1   // La led jaune est sur la brohe 1 de l'ATTINY

// Initialisation en sortie des pattes et extinction des LEDs
void setup() {
  pinMode(VERT, OUTPUT);
  pinMode(ROUGE, OUTPUT);
  pinMode(BLEU, OUTPUT);
  pinMode(JAUNE, OUTPUT);
  digitalWrite(VERT, LOW); 
  digitalWrite(ROUGE, LOW); 
  digitalWrite(BLEU, LOW); 
  digitalWrite(JAUNE, LOW); 
}

// Boucle d allumage et extinction des LEDs en série                          
void loop() {
  digitalWrite(BLEU, HIGH);   // allumage led bleue
  delay(1000);                // attente une seconde
  digitalWrite(BLEU, LOW);    // extinction de la led bleue
  delay(1000);                // attente une seconde
  
  digitalWrite(JAUNE, HIGH);   
  delay(1000);              
  digitalWrite(JAUNE, LOW);    
  delay(1000);              
  
  digitalWrite(VERT, HIGH);   
  delay(1000);              
  digitalWrite(VERT, LOW);   
  delay(1000);              
  
  digitalWrite(ROUGE, HIGH);   
  delay(1000);              
  digitalWrite(ROUGE, LOW);    
  delay(1000);             
}

Ce code est disponible sous GitHub à l’adresse suivante : https://github.com/phmarduino/arduino/blob/main/attiny85/code/pm_attiny_isp_chenillard.ino

Connexions pour le test du chenillard

Une fois le téléversement du programme dans l’ATtiny terminé, vous pouvez déconnecter l’ATtiny de l’Arduino puis réaliser les connexions des quatre LEDs de la manière suivante pour tester le chenillard :

• PB0 ATtiny (broche 5) : LED verte,
• PB1 ATtiny (broche 6) : LED jaune,
• PB2 ATtiny (broche 7) : LED bleue,
• PB3 ATtiny (broche 2) : LED rouge.

Brancher de plus VCC et GND sur une alimentation (une pile de 4.5 Volt par exemple).

Rappel brochage ATtiny 85 :

Une fois la programmation de l’ATtiny terminée, celui-ci peut bien sur fonctionner de manière complètement autonome, déconnecté de l’Arduino, alimenté avec une simple pile.

Dans le montage ci-dessous, comme je n’avais pas de pile sous la main, l’ATtiny est connecté à l’Arduino juste pour l’alimentation (Fils noir et rouge).

En complément

Les ordres Arduino ne sont pas tous utilisables pour un programme destiné à l’ATtiny. Seuls les ordres Arduino ci-dessous sont disponibles pour les programmes ATtiny :

• pinMode()
• digitalWrite()
• digitalRead()
• analogRead()
• analogWrite()
• shiftOut()
• pulseIn()
• millis()
• micros()
• delay()
• delayMicroseconds()
• SoftwareSerial