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) |
|
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 :
bonjour
j’ai suivi exactements vos conseils pour progammer l’attiny 85 j’ai controler a plusieurs reprises mes branchements mis le condo etc , je ne peut pas televerser le programme j’ai toujours un message d’erreur de televersement du type » avrdude: stk500_recv(): programmer is not repeponding
avrdude: stk500_getsync() attempt 1 of 10 :not is sync: resp=0*03″
10 fois
et » Problème de téléversement vers la carte »
j’avais deja graver la sequence d’initialisation il y a plusieurs annees sur les memes attiny que je reprends maintenant que je suis en retraite » j’ai beaucoup plus de temps « et cela fonctionnait tres bien entre temps j’ai changer du materiel st passe a windows10 mais là impossible
j’ai pourtant televerser le programme « ArduinoISP » a l’arduino dans un 1er temps
brancher le type de carte sur »ATtiny25/45/85″
puis Processeur »ATtiny85″
puis clock « internal 8 MHz
verifier le port « com3″qui correspond bien dans le panneau de configuration windows10
puis programmateur « Arduino as ISP »
j’ai également suivi le même processus avec la derniers version d’arnuino 1.8.1 du j’ai retrograder a la version 1.6.4 pour essai
je vous remercie d’avance pour votre aide
J’aimeJ’aime
Bonjour. Merci pour votre commentaire. J’ai ajouté dans l’article des informations permettant de vérifier le bon fonctionnement de l’Arduino comme programmateur ISP après le chargement du sketch. En espérant que cela pourra vous aider.
J’aimeJ’aime
Il a un bug avec windows 10 pour la programmation à l’aide de ArduinoISP. Par contre il y a une parade facile à mettre en oeuvre. Dans le répertoire de l’exécutable Arduino, rechercher le fichier programmers.txt (Sur mon ordinateur il se retrouve dans le dossier: C:\Program Files (x86)\Arduino\hardware\arduino\avr . Copier ce fichier sur le bureau. Ensuite modifier ce fichier à l’aide de notepad (Ou autre éditeur de texte). Ajouter à la fin du fichier le bloc de code suivant:
arduinopleo.name=Arduino as ISP (leonardo)
arduinopleo.communication=serial
arduinopleo.protocol=arduino
arduinopleo.speed=19200
arduinopleo.program.protocol=arduino
arduinopleo.program.speed=19200
arduinopleo.program.tool=avrdude
arduinopleo.program.extra_params=-P{serial.port} -b{program.speed}
Lors de la programmation de l’atTiny. Aller dans outils->Programmateur et choississez Arduino as ISP (leonardo).
Le truc de cette manip est de changer le protocol de programmation de arvdude à serial (arduiopleo.communication).
Avec cette manip j’ai pu rammener à la vie un arduino micro et un Arduino Leonardo qui ne voulait plus démarrer.
Bonne chance
J’aimeJ’aime
Petit oubli.
Replacer le fichier programmers.txt à son endroit d’origine. Windows devrait vous demander une autorisation pour écraser le fichier. La raison pourquoi je copie ce fichier sur le bureau est que windows 10 ne nous permet pas de modifier un fichier dans les répertoires System.
J’aimeJ’aime
Bonjour Martin, Merci pour ces commentaires et les informations pour les utilisateurs de Windows 10 🙂
J’aimeJ’aime
Bonjour, j’ai un petit souci au moment du téléversement du sketch ArduinoISP , dans la fenêtre débug il m’écrit : ‘serial’ was not declared in this scop Je suis pas un grand cador en programmation donc je me permet de venir vers vous merci
J’aimeJ’aime
C’est Serial et non serial
J’aimeJ’aime
Désolé c’est bon j’ai compris , en fait il faut téléverser le sketch ArduinoISP avant de renommer le type de carte en ATTINY 85 comme c’est le cas pour moi . vraiment je suis confus milles excuses 😉
J’aimeJ’aime
Bonjour, il n’y a pas de souci. La démarche est un peu complexe, l’ATtiny étant programmé avec le programme utilisateur après avoir été lui même programmé comme programmateur via un PC 🙂
J’aimeAimé par 1 personne
Bonsoir, même problème que roger muller (Win 8.1) >
avrdude: stk500_recv(): programmer is not responding
J’aimeJ’aime
Hi there! This is my first visit to your blog!
We are a collection of volunteers and starting a new project in a community in the same
niche. Your blog provided us beneficial information to work on. You have done a wonderful job!
J’aimeJ’aime
Super tuto, ça a marché du 1er coup. Attention dans le programme test1 pour blink, patte 3 et brancher enuite sur l’Attiny (pin 3) , c’est la pin 2.
J’aimeJ’aime
Merci pour les commentaires. Il y avait effectivement une coquille et je n’étais pas forcément très clair sur l’utilisation des broches. Du coup j’ai revu les dénominations pour me rapprocher de la doc officielle.
J’aimeJ’aime
Bonjour, merci pour votre travail cependant j’ai un problème à l’étape de gravure de la séquence d’initialisation. j ai le message ci-dessous
Arduino : 1.8.10 (Windows 10), Carte : « ATtiny25/45/85, ATtiny85, Internal 8 MHz »
C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude -CC:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf -v -v -v -v -pattiny85 -carduino -PCOM4 -b19200 -e -Uefuse:w:0xff:m -Uhfuse:w:0xdf:m -Ulfuse:w:0xe2:m
avrdude: Version 6.3-20190619
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is « C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf »
Using Port : COM4
Using Programmer : arduino
Overriding Baud Rate : 19200
avrdude: ser_open(): can’t open device « \\.\COM4 »: Le fichier sp�cifi� est introuvable.
avrdude done. Thank you.
Erreur lors de la gravure de la séquence d’initialisation.
Je suis sous windows 10, j’ai tenté la manip de Martin roberge mais ai toujours le meme resultat.
Je suis preneur d’un coup de main.
Merci
J’aimeJ’aime
Bonjour,
Merci pour votre commentaire.
A priori au vu de la log il y a à minima un souci avec le choix du programmateur (-carduino) car il devrait être renseigné pour l’ATtiny.
Je pense donc qu’il faudrait refaire un essai en renseignant bien dans l’IDE Arduino les paramètres suivants :
Dans le menu « Outil », sélectionner désormais:
Type de carte : ATtiny,
Processeurr : Attiny85,
Programmateur : Arduino as ISP.
En espérant que cela règle bien le problème 🙂
J’aimeJ’aime
Bonjour, j’ai un montage avec un attiby85 et un capteur de tepérature DS18B20, mais il consomme énormément, L apile 9V (avec un regulateur 5V) se vide en 3 jours !!!! Le code utilise bien les sleep_mode(), avez-vous une idée ??? Merci d’avance
J’aimeJ’aime
Bonjour, effectivement ce n’est pas normal du tout … est-ce que vous pourriez me transmettre votre code et le montage pour que j’analyse le problème SVP ?
J’aimeJ’aime
Nickel ! merci pour cette page qui me permet mon premier « hello world » avec un ATtiny85
J’aimeJ’aime
Merci pour ce montage. Je vais pouvoir progresser grâce à vous.
Cordialement.
J’aimeJ’aime
Merci pour votre commentaire. Bon courage.
J’aimeJ’aime
Bonjour,
Merci pour ce tuto génialissime.
j’ai suivi avec attention tous les points de ce tuto, y compris le patch sur programmers.txt. rien à faire, j’ai toujours le même message ; « Une erreur est survenue lors du transfert du croquis
avrdude: Yikes! Invalid device signature. Double check connections and try again, or use -F to override this check. » j’ai tout re-controlé 20 fois les cablages, recommandé des puces à des commerçants différents, refait les manip….impossible.
si qq’un pouvait m’aider, j’apprécierais.
J’aimeJ’aime
Bonjour,
j’ai le même problème aussi.
Merci
J’aimeJ’aime
Je me suis fait aider par un pro.
En fait dans le sketch arduinoISP, à la ligne 81 il faut enlever les barres de commentaires.
Et là, ça marche
J’aimeJ’aime
bonjour j’ai un problème lors de la gravure d’initialisation,
Arduino : 1.8.13 (Windows Store 1.8.42.0) (Windows 10), Carte : « ATtiny25/45/85, ATtiny85, Internal 8 MHz »
C:\Program Files\WindowsApps\ArduinoLLC.ArduinoIDE_1.8.42.0_x86__mdqgnx93n4wtt\hardware\tools\avr/bin/avrdude -CC:\Program Files\WindowsApps\ArduinoLLC.ArduinoIDE_1.8.42.0_x86__mdqgnx93n4wtt\hardware\tools\avr/etc/avrdude.conf -v -v -v -v -pattiny85 -cstk500v1 -PCOM3 -b19200 -e -Uefuse:w:0xff:m -Uhfuse:w:0xdf:m -Ulfuse:w:0xe2:m
avrdude: Version 6.3-20190619
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is « C:\Program Files\WindowsApps\ArduinoLLC.ArduinoIDE_1.8.42.0_x86__mdqgnx93n4wtt\hardware\tools\avr/etc/avrdude.conf »
Using Port : COM3
Using Programmer : stk500v1
Overriding Baud Rate : 19200
avrdude: Send: 0 [30] [20]
avrdude: Send: 0 [30] [20]
avrdude: Send: 0 [30] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [10]
AVR Part : ATtiny85
Chip Erase delay : 400000 us
PAGEL : P00
BS2 : P00
RESET disposition : possible i/o
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
eeprom 65 12 4 0 no 512 4 0 4000 4500 0xff 0xff
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
flash 65 6 32 0 yes 8192 64 128 30000 30000 0xff 0xff
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
lock 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
lfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
hfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
efuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
———– —- —– —– —- —— —— —- —— —– —– ———
calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00
Programmer Type : STK500
Description : Atmel STK500 Version 1.x firmware
avrdude: Send: A [41] . [80] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [02]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [81] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [01]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [82] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [12]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [98] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
Hardware Version: 2
Firmware Version: 1.18
Topcard : Unknown
avrdude: Send: A [41] . [84] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [85] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [86] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [87] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [89] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
Vtarget : 0.0 V
Varef : 0.0 V
Oscillator : Off
SCK period : 0.1 us
avrdude: Send: A [41] . [81] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [01]
avrdude: Recv: . [10]
avrdude: Send: A [41] . [82] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [12]
avrdude: Recv: . [10]
avrdude: Send: B [42] . [14] . [00] . [00] . [01] . [01] . [01] . [01] . [03] . [ff] . [ff] . [ff] . [ff] . [00] @ [40] . [02] . [00] . [00] . [00] [20] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [10]
avrdude: PAGEL and BS2 signals not defined in the configuration file for part ATtiny85, using dummy values
avrdude: Send: E [45] . [05] . [04] . [d7] . [a0] . [01] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [10]
avrdude: Send: P [50] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [10]
avrdude: AVR device initialized and ready to accept instructions
Reading | avrdude: Send: V [56] 0 [30] . [00] . [00] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
avrdude: Send: V [56] 0 [30] . [00] . [01] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
################avrdude: Send: V [56] 0 [30] . [00] . [02] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
################################## | 100% 0.02s
avrdude: Device signature = 0x000000 (retrying)
Reading | avrdude: Send: V [56] 0 [30] . [00] . [00] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
avrdude: Send: V [56] 0 [30] . [00] . [01] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
################avrdude: Send: V [56] 0 [30] . [00] . [02] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
################################## | 100% 0.02s
avrdude: Device signature = 0x000000 (retrying)
Reading | avrdude: Send: V [56] 0 [30] . [00] . [00] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
avrdude: Send: V [56] 0 [30] . [00] . [01] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
Erreur lors de la gravure de la séquence d’initialisation.
################avrdude: Send: V [56] 0 [30] . [00] . [02] . [00] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [00]
avrdude: Recv: . [10]
################################## | 100% 0.03s
avrdude: Device signature = 0x000000
avrdude: Yikes! Invalid device signature.
Double check connections and try again, or use -F to override
this check.
avrdude: Send: Q [51] [20]
avrdude: Recv: . [14]
avrdude: Recv: . [10]
avrdude done. Thank you.
J’aimeJ’aime
Bonjour, j’ai fais votre carte de programmation sur un support de circuit imprime.
Juste savoir si le programmateur est compatible Attiny 13 ??? merci
J’aimeJ’aime