LOCODUINO

Le microcontrôleur ATtiny45

Le microcontrôleur ATtiny45 (1)

Présentation du microcontrôleur

.
Par : Christian

DIFFICULTÉ :

Certaines applications pour un réseau de trains miniatures ne requièrent pas toute la puissance d’un module Arduino/Genuino Uno et on peut trouver dommage de monopoliser un tel module pour si peu. La solution est de les confier à un microcontrôleur moins puissant, donc moins coûteux. Cette série d’articles vous présente le microcontrôleur ATtiny45 du constructeur Atmel et ses possibilités dans le domaine du modélisme ferroviaire.

On peut se demander pourquoi un site consacré aux modules Arduino parle d’un simple composant électronique ? Simplement parce que l’ATtiny45 est de la même famille de microcontrôleurs que celui qui équipe les modules Arduino/Genuino Uno et est programmable avec le logiciel Arduino.

Possibilités de l’ATtiny45

Ce microcontrôleur se présente sous la forme d’un boîtier à 8 broches, comme le montre la figure 1. C’est effectivement très peu mais les broches sont multiplexées, ce qui signifie qu’elles servent à plusieurs choses à la fois. La figure 1 donne les possibilités de chaque broche, mais il est inutile de tout retenir maintenant. Nous allons décrire les principales fonctions des broches.

ATtiny45
ATtiny45

La tension d’alimentation varie de 2,7 à 5,5 V (de 1,8 à 5,5 V pour la version ATtiny45V). Une simple pile de 4,5 V suffit donc pour l’alimenter. Le plus de l’alimentation est connecté à la broche 8 et le moins à la broche 4, soit deux broches diagonalement opposées comme c’est souvent le cas pour un circuit intégré.

L’ATtiny45 dispose de 6 lignes d’entrées-sorties, organisées en un PORT d’entrée-sortie appelé PORT B. Ces 6 lignes sont numérotées de 0 à 5 (on commence toujours par 0 en informatique) et on écrit PB0:5 pour parler des lignes 0 à 5 du PORT B qui sont respectivement sur les broches 5, 6, 7, 2, 3 et 1.

Six broches d’E/S (entrée-sortie) et deux broches pour alimenter le microcontrôleur, nous arrivons au total des 8 broches du boîtier. Ce µC (microcontrôleur) peut donc servir pour des applications qui ne requièrent que 6 lignes d’E/S. Pourtant, dans les applications que cette série d’articles proposera, nous nous limiterons à 5 lignes d’E/S seulement. En effet, la broche 1 sert aussi au RESET du µC (voir figure 1) et ce RESET peut être utile pour certaines applications, et en tout cas, il est indispensable pour la programmation du µC avec un module Arduino Uno comme nous le verrons ultérieurement. Retenons simplement que notre µC nous offre deux broches pour l’alimenter, 5 lignes d’E/S et une broche de RESET et si cela vous paraît peu, vous serez étonné de voir tout ce qu’on peut faire tout de même.

Maintenant que nous avons décrit comment exploiter ses broches, voyons maintenant le reste de ses possibilités. Sa fréquence d’horloge utilisable dépend de la tension d’alimentation ; s’il est alimenté en 5 V, la fréquence d’horloge peut aller de 0 à 20 MHz. La mémoire de programme est de 4 kilo-octets, la mémoire SRAM (Static Random Access Memory) est de 256 octets tout comme la mémoire EEPROM (Electrical Erasable Programmable Read Only Memory). Cela peut paraître peu mais c’est largement suffisant pour de petites applications. Ces chiffres sont à diviser par 2 si vous optez pour le petit frère ATtiny25 et à multiplier par 2 si vous choisissez le grand frère ATtiny85. Lorsque nous parlons de l’ATtiny45, nous parlons en fait de la famille ATtiny25/45/85 puisque les propriétés sont les mêmes en dehors de l’espace mémoire plus ou moins étendu.

Ce microcontrôleur est capable de produire de la PWM, dispose de timers, d’un convertisseur analogique-numérique sur 10 bits, de sources d’interruption externes et internes, un oscillateur interne calibré et un port SPI/I2C pour communiquer et qui incidemment permet aussi de le programmer.

Comme vous le voyez, ce petit microcontrôleur est tout de même un concentré de technologie et ce serait bien dommage de s’en passer, d’autant que son prix est inférieur à 1,50 € (en 2016).

Développement d’une application pour un réseau de train

Nous allons voir dans ce paragraphe, comment développer une application à base d’ATtiny, en donnant les grands principes généraux ; la suite de cette série d’articles présentera bien entendu des exemples concrets dont la réalisation sera décrite de A jusqu’à Z.

Phase 1 : on commence par évaluer les ressources nécessaires pour voir si cela tient dans les possibilités d’un ATtiny. N’oublions pas que nous sommes limités à 5 lignes d’E/S. Prenons par exemple les feux tricolores de carrefour routier, application qui a été décrite dans l’article Feux tricolores. Un carrefour est constitué de quatre feux tricolores et chaque feu possède trois ampoules (vert, orange, rouge). Cela ne donne pas 12 ampoules pour autant car les feux d’une même route sont allumés en même temps ; en fait, il nous reste 6 ampoules à gérer, ce qui est trop puisque nous n’avons que 5 lignes de sortie. Comment faire ? Nous pouvons considérer que lorsqu’un feu est au vert, le feu de la route perpendiculaire est au rouge ; ceci permet de réaliser nos feux avec seulement 3 sorties, mais dans ce cas, nous ne pouvons pas introduire la temporisation du chauffard dont on parlait dans l’article Feux tricolores. Ce n’est pas si grave car les feux tricolores construits avec des circuits intégrés classiques ne le permettent pas non plus (voir le chapitre 11 du cours d’électronique donné dans l’article Démarrer en électronique). Il y a bien entendu une autre solution : utiliser deux µC ATtiny et les faire travailler ensemble, chaque µC gérant les deux feux d’une même route du carrefour. Cela permet de réintroduire la temporisation du chauffard et ainsi de gagner en réalisme. Prenons un autre exemple, celui d’un passage à niveau non gardé dont on veut faire clignoter les feux rouges à l’approche d’un train. Une sortie pour faire clignoter deux DEL rouges et deux entrées reliées à des ILS pour détecter l’approche du train et son éloignement, cela donne 3 lignes d’E/S ce qui tient tout à fait dans un ATtiny.

Phase 2 : il faut mettre au point le montage sur une platine d’essai en remplaçant l’ATtiny par un module Arduino/Genuino Uno. En effet, celui-ci est plus facile à programmer grâce à son câble USB et il opère comme un µC ATtiny qui serait alimenté en 5 V ; on peut donc choisir les meilleures valeurs de composants, et écrire le programme pour le tester.

Phase 3 : lorsque le programme fonctionne, il faut l’adapter à un ATtiny dont les lignes d’E/S sont comprises entre 0 et 4 alors que vous avez peut-être utilisées d’autres numéros avec votre module Uno. Lorsque c’est fait, il reste à programmer la puce ATtiny et cela se fait avec un module Arduino/Genuino Uno, une platine d’essai et quelques câbles de liaison.

Phase 4 : une fois l’ATtiny programmé, le montage de l’application est réalisé à nouveau sur une platine d’essai, cette fois avec la puce et les composants définitifs autour afin de tester le fonctionnement avant de réaliser le montage définitif où les composants sont soudés soit sur un circuit imprimé, soit sur une plaque à bandes cuivrées (veroboard par exemple).

Dans cette procédure, nous avons utilisé le module Uno à deux reprises : pour la mise au point de l’application et de son programme, et pour programmer l’ATtiny. Cela nous ramène à un environnement connu, celui de l’IDE des modules Arduino et la programmation de l’application se fait directement dans le « langage » d’Arduino que vous commencez à connaître. Pour autant, toutes les fonctions ne seront peut-être pas utilisables avec un µC ATtiny mais cela vaut la peine d’essayer. Tout ce que vous risquez est que cela ne fonctionne pas une fois le programme téléversé dans le µC ATtiny, mais ce n’est pas important puisque ce dernier peut être reprogrammé à nouveau.

Architecture du microcontrôleur ATtiny45

Pour comprendre pourquoi une application mise au point avec un module Uno peut fonctionner avec un ATtiny45, il faut s’intéresser un peu à l’architecture des deux microcontrôleurs, l’ATtiny45 et l’ATmega328P qui équipe les modules Arduino/Genuino Uno. Nous allons voir qu’il y a de fortes similitudes et tant mieux pour nous car dans certains cas, nous aurons de bonnes chances que l’application fonctionne avec l’ATtiny alors que dans d’autres cas, nous saurons à l’avance que ce n’est même pas la peine d’essayer. L’étude de ce paragraphe est donc fortement conseillée si vous voulez comprendre ce que vous pouvez faire.

Il est bien évident que les deux µC n’ont pas les mêmes possibilités, l’un étant plus puissant que l’autre. L’ATtiny45 offre 6 lignes d’E/S alors que l’ATmega328P en offre 23. Peut-être allez-vous réagir : comment cela 23 ? Un module Uno dispose de 14 E/S digitales et 6 analogiques, donc 20 au total. Où sont passées les trois autres ? C’est un choix technologique qui a été fait dès la conception du module Uno. La figure 2 montre la correspondance entre les broches du µC ATmega328P et les connecteurs du module Uno.

Figure 2
Figure 2
Correspondance entre broches du µC ATmega328P et module Uno

La broche PC6 sert au RESET du module Uno (tout comme nous avons fait le choix de ne pas utiliser la broche PB5 de notre ATtiny et de la réserver au RESET). De même, les broches PB6 et PB7 (broches 9 et 10 du µC ATmega328P) servent à implanter un cristal de quartz pour que la fréquence de travail du module soit exactement calibrée. Cela revient donc à avoir un PORT B limité à 6 lignes sur un module Uno, forte similitude avec notre ATtiny45 !

La capacité mémoire est très différente entre les deux microcontrôleurs. L’ATmega328P dispose d’une mémoire flash de 32 kilo-octets accueillant le programme, alors que l’ATtiny45 est limité à 4 kilo-octets de mémoire flash (2 k pour l’ATtiny25 et 8 k pour l’ATtiny85). C’est bien entendu très peu, mais généralement suffisant pour de petites applications spécialisées à une seule tâche. De même, la mémoire SRAM permettant de stocker des variables est de 2 k sur l’ATmega328P alors qu’elle n’est que de 256 octets sur l’ATtiny45 (128 sur l’ATtiny25 et 512 sur l’ATtiny85). Cette capacité est en rapport avec la longueur de la mémoire flash : dans tous les cas un seizième, tout en gardant bien à l’esprit que ces deux mémoires (flash pour le programme et SRAM pour les variables) sont distinctes (architecture Harvard, c’est-à-dire avec des mémoires et des bus séparés pour les données et les programmes). Le mieux est de prendre dès le début les bons réflexes pour économiser la mémoire flash et la mémoire SRAM. Il existe des astuces de programmation qui donnent un code plus compact permettant d’économiser la mémoire flash et un choix judicieux des types de variables permet d’économiser la mémoire SRAM (voir à ce sujet l’article Types, constantes et variables).

Les figures 3 et 4 permettent de comparer l’architecture des deux microcontrôleurs ; elles sont extraites des datasheets des composants. Comme vous le voyez, la ressemblance est frappante. L’ALU (en rouge, Arithmetic Logic Unit ou encore Unité Arithmétique et Logique) est l’unité qui traite les informations ; elle est capable de réaliser trois catégories d’opérations : arithmétiques, logiques ou manipulation de bits sur les octets. L’ALU travaille avec 32 registres à usage général de 8 bits (en bleu) pour les deux microcontrôleurs. Un compteur de programme (en orange, Program Counter) permet de pointer l’instruction en cours de traitement dans la mémoire de programme (en violet). La valeur du compteur de programme peut être sauvegardée dans la mémoire SRAM (en jaune) en cas d’interruption ou de sous-programme. Enfin, dans les deux cas, on trouve un registre d’état (en vert, SREG pour Status Register) de 8 bits permettant d’avoir des informations sur le fonctionnement du µC et la structure des bits est la même pour l’ATmega328P et l’ATtiny45. Par exemple, le bit 0 indique si le résultat d’une opération génère une retenue ; on l’appelle bit de Carry (retenue en anglais). Le bit 1 indique si le résultat d’une opération est zéro. Chacun des bits du registre d’état peut être lu ou écrit par le programmeur pour les besoins du programme à réaliser. Par exemple, on peut écrire dans le bit 7 pour autoriser ou non les interruptions. Le registre d’état est automatiquement mis à jour après chaque opération de l’ALU.

Figure 3
Figure 3
Figure 4
Figure 4

Des registres, il en existe bien d’autres et nous n’allons pas plus entrer dans le détail de fonctionnement des deux microcontrôleurs, mais l’étude des datasheets des deux composants montrent des similitudes que nous pourrons exploiter. Les deux µC contiennent par exemple un convertisseur analogique-digital d’une résolution de 10 bits (ADC pour Analog to Digital Converter avec un résultat donné de 0 à 1023). Enfin, sur le plan matériel, les PORT d’entrée-sortie sont conçus exactement de la même façon et opèrent avec les mêmes registres (voir le chapitre 28 du cours d’électronique donné dans l’article Démarrer en électronique).

Bien entendu, il existe aussi des différences qui confèrent plus de puissance à l’ATmega328P, comme par exemple un timer 16 bits en plus des deux timers 8 bits qu’on retrouve sur les deux µC, six canaux PWM pour l’ATmega328P alors que l’ATtiny45 n’en a que 2, etc. Ces différences nous obligeront à nous adapter à la petitesse de l’ATtiny mais les possibilités de ce dernier n’ont quasiment pas de limites dans la mesure où l’application n’est pas trop gourmande en ressources et surtout est spécialisée sur une seule tâche (gestion d’un signal, gestion d’une aiguille, clignotement de feux de PN, etc.). Le prix à payer est de mettre plus de puces ATtiny sur son réseau, en s’arrangeant pour qu’elles soient indépendantes les unes des autres, ou bien qu’elles communiquent de façon rudimentaire, comme nous le verrons par la suite. En tout cas, cela fonctionne.

Dans les prochains articles, nous verrons comment programmer une puce ATtiny avec un module Arduino/Genuino Uno, puis nous étudierons des exemples simples de ce qu’elles peuvent faire sur un réseau de trains miniatures.

25 Messages

  • Le microcontrôleur ATtiny45 (1) 15 janvier 2017 09:46, par Dominique

    Bonjour,

    On trouve chez TXHANG (voir l’article sur Les Achats) un kit de développement ATtiny85 pour 1,26€.

    Ce kit contient un prise microUSB et il est compatible avec l’IDE Arduino sans matériel supplémentaire.

    Mini ATTINY85 Micro USB Development Board for Digispark Kickstarter

    Répondre

  • Le microcontrôleur ATtiny45 (1) 6 mai 2017 16:42, par CHAMPALBERT

    Bonjour,

    Je viens de recevoir mes ATtiny45 commandés chez Conrad, Je ne sais pas identifier les broches car rien n’est marqué si ce n’est un creux.

    Comment ne pas se tromper.

    Quand je veux graver la séquence d’initialisation, j’ai le message

    avrdude : Error : Could not find USBtiny device (0x2341/0x49)
    Erreur lors de la gravure de la séquence d’initialisation.
    Merci de votre comprehension

    Répondre

    • Le microcontrôleur ATtiny45 (1) 6 mai 2017 17:28, par Christian Bézanger

      Pour repérer la pin N°1 d’un ATtiny, il faut chercher un creux sur le boitier : la pin N°1 est celle située le plus près du creux sur l’ATtiny, (autrement dit, le creux est situé en bas à gauche du boitier quand il est possible de lire les indications portées sur le boitier (marque et modèle)).

      Pour les autres circuits intégrés, le repérage des pins se fait :

      • soit sur le même principe
      • soit grâce à une encoche située sur un bord du boitier et dans ce cas, la pin N°1 est la première rencontrée en partant de l’encoche et en tournant dans le sens inverse des aiguilles d’une montre.
        Un schéma valant mieux qu’un long discours, consultez mon cours d’électronique au chapitre sur les circuits intégrés.
        Le message d’erreur est peut être dû au fait que l’ATtiny a été mal orienté (erreur sur les pins), ou alors à une erreur de port COM (exemple on utilise le port COM1 alors que le module Arduino UNO servant à programmer est sur un autre port).

      Répondre

  • Le microcontrôleur ATtiny45 (1) 8 mai 2017 15:40, par CHAMPALBERT

    Merci Christian pour cette réponse rapide.
    J’ai retouné le microprocesseur (le point correspondant à la patte 1)
    Mais au moment de la séquence d’initialisation j’ai le message
    avrdude : stk500_recv() : programmer is not responding
    avrdude : stk500_getsync() attempt 1 of 10 : not in sync : resp=0x03
    qui boucle 10 fois.

    Le port COM est correct (je peux téléverser des programmes "classiques’ sur le UNO) mais le Attiny résiste farouchement !

    Répondre

    • Le microcontrôleur ATtiny45 (1) 8 mai 2017 17:40, par Christian Bézanger

      Si le microprocesseur a dû être retourné, c’est qu’il était dans le mauvais sens et auquel cas, il n’aura pas supporté le mauvais branchement. Je préconise donc de le remplacer par un neuf et de reprendre la procédure.
      1- Dans Outils -> type de carte est-ce que ATtiny25/45/85 a bien été sélectionné ?
      2- Dans Outils -> Processeur est-ce que ATtiny45 a bien été sélectionné ?
      3- Dans Outils -> Clock est-ce que Internal 8 MHz a bien été sélectionné ?
      4- Dans Outils -> Programmateur est-ce que Arduino as ISP a bien été sélectionné ?
      5- Le module UNO a-t-il été chargé avec ArduinoISP ?
      6- Le branchement entre le module UNO et l’ATtiny respecte-t-il bien toutes les connexions y compris GND et 5V ?
      Si OUI a toutes ces questions, je ne vois pas ce qui peut empêcher la programmation. (pensez à graver la séquence d’initialisation lors de la première programmation).
      Si NON à une question ou plus, reprendre à tête reposée la procédure de programmation.
      Ne vous découragez pas, vous y arriverez.

      Répondre

  • Désolé de vous importuner de nouveau. Toujours impossible d’initialiser le ATtiny45.
    Quand je teste le programme ArduinoISP avant de le télécharger j’ai 15 pages d’erreur du genre

    C :\Program Files (x86)\Arduino\hardware\arduino\avr\libraries\SPI\src/SPI.h:146:16 : error : ’SPE’ was not declared in this scope

    spcr = _BV(SPE) | _BV(MSTR) | ((bitOrder == LSBFIRST) ? _BV(DORD) : 0) |

    ou ArduinoISP:113 : error : ’SCK’ was not declared in this scope

    ArduinoISP:137 : error : ’Serial’ was not declared in this scope

    #define SERIAL Serial

    ^

    C :\Program Files (x86)\Arduino\examples\11.ArduinoISP\ArduinoISP\ArduinoISP.ino:713:7 : note : in expansion of macro ’SERIAL’

    SERIAL.print((char) STK_NOSYNC) ;

    Les bibliothèques sont pourtant celles qui ont été installées par défaut.

    Peut on tester si un micocrotroleur est HS ? Comment être certain que le microprocesseur est bien monté.Je me suis fié au dessin donné dans votre cours d’électronique pour repérer la broche 1 (repérée par un creux sur le boîtier)
    Merci de votre patience

    Répondre

    • Le microcontrôleur ATtiny45 (1) 9 mai 2017 16:42, par Christian

      Le problème n’étant pas résolu malgré deux réponses déjà faites, je vous invite à décrire votre problème dans le forum sur le fil traitant de la programmation des ATtiny : vous aurez ainsi plus de personnes susceptibles de vous aider.
      Qu’appelez-vous "tester ArduinoISP ?" (Ce programme est fait pour transférer un programme dans un composant, pas pour être l’objet de tests.)
      Avez-vous changé quelque chose à ce programme ?
      Visiblement, il y a un "SPE" qui traîne et non compris du compilateur, sans doute au lieu de SPI.
      J’ai donc du mal à comprendre comment vous en êtes arrivé là. Une solution possible serait de réinstaller l’IDE pour repartir sur des programmes exemples qui ne comportent pas d’erreur (ArduinoISP notamment). Une fois l’IDE installé, reprenez la procédure de programmation sans rien oublier.
      L’ATtiny que vous aviez monté dans le mauvais sens n’a aucune chance d’avoir résisté puisque l’alimentation a été inversée (le + au - et réciproquement). Aucun circuit ne résiste à cela. Si vous avez repéré la broche 1, vous êtes certain de bien monter votre circuit, je ne sais pas quoi vous dire de plus.
      Inscrivez-vous sur le forum et rendez-vous sur le forum pour continuer cette discussion.
      Cordialement.

      Répondre

      • Le microcontrôleur ATtiny45 (1) 9 mai 2017 16:51, par Christian

        Je rajoute une chose : quand je compile ArduinoISP (pour un UNO), le croquis utilise 4380 octets et les variables 481 octets. Preuve que ce programme fonctionne.
        Vous avez peut-être dû essayer de le compiler en ayant déjà réglé la carte sur Attiny25/45/85, ce qui bien sûr génère tout un tas de messages d’erreurs.
        Si c’est le cas, je vous invite à relire tout l’article sur la procédure de programmation pour bien comprendre ce qui concerne le module UNO en tant que programmateur et ce qui concerne l’ATtiny qu’on veut programmer. Ce n’est peut-être pas encore tout à fait clair pour vous.

        Répondre

  • Bonjour,
    Dans l’article vous évoquez les « astuces de programmation […] permettant d’économiser la mémoire flash et […] la mémoire SRAM ». Et vous renvoyez à l’article « Types, constantes et variables ». Mais cet article ne répond pas à certaines questions. Par exemple, remplacer un bout de code par une fonction fait-il gagner de la place en mémoire ? Y a-t-il de ce point de vue un intérêt à déclarer une variable comme constante ? D’autre part, notamment si on alimente ses micro-contrôleurs par piles, il serait également judicieux de concevoir l’électronique du circuit et de programmer de façon à minimiser la consommation électrique. Cela soulève certaines questions. Par exemple quand mon Attiny ou mon Arduino bouclent sur la fonction loop(), est-ce que ça consomme (beaucoup) de courant ? Si j’introduis dans ma boucle des delay() pour ralentir la boucle, est-ce que ça consomme moins ? Quel courant consomme un Attiny, d’ailleurs ?
    Je n’ai pas trouvé d’article traitant de ce sujet sur votre site.
    Bonne soirée !

    Répondre

    • Un article ne peut pas être universel, sinon il serait trop long et rebuterait le lecteur. Mais vous avez raison, certains points que vous citez n’ont jamais été traités sur ce site. La raison est liée à l’activité de ce site qui est le modélisme ferroviaire qui n’a absolument pas besoin d’avoir une énergie autonome (pile ou batterie) contrairement à d’autres activités comme la robotique ou les drones. En conséquence, nos montages sont soit alimentés par le câble USB ou bien par une alimentation 12 V reliée à l’entrée jack. Nul besoin donc de se préoccuper de la consommation du montage. Pour ceux qui ont à prendre en compte ce besoin, il faut se référer à la datasheet de la carte Arduino ou du microcontrôleur associé, ou bien consulter des sites de robotique ou de drones. La plupart des microcontrôleurs ont un mode sleep pour économiser l’énergie quand le programme n’a rien à faire : ce sont des techniques non nécessaires à notre activité de modélisme ferroviaire.
      Pour ce qui concerne la place occupée en mémoire par les programmes et les données, nous avons répondu aux questions que vous vous posez, du moins en partie. Par exemple, sur le fait de déclarer comme constantes des variables qui le sont effectivement. Egalement sur le fait d’utiliser la programmation au plus près du µC plutôt que les fonctions d’Arduino : cette solution gagne de la place en mémoire mais n’est guère conseillée à des débutants car elle requiert de bien comprendre ce que l’on fait. Chaque utilisateur d’Arduino peut d’ailleurs voir comment optimiser sa place mémoire puisque la compilation d’un programme donne le nombre d’octets utilisés (en programme et en données).
      Pour ce qui concerne l’utilisation des fonctions, il faut le faire non pas dans le but d’optimiser de la place mémoire, mais dans le but d’avoir un style de programmation plus clair et plus compréhensible par d’autres programmeurs. L’utilisation de la Programmation Orientée Objet (POO) permet, pour les utilisateurs déjà confirmés dans l’utilisation des cartes Arduino, d’accéder à encore plus de clarté et plus de puissance dans leur mode de programmation.
      Je ne sais pas si vous avez lu mon cours d’électronique (publié sur ce site) qui énonce certains principes de programmation au plus près du µC et qui parle également de la consommation de certains composants électroniques (transistors MOSFET par exemple ou bien circuits intégrés CMOS par rapport aux TTL) : cela vous permettra peut-être d’aller plus loin dans les questions que vous vous posez et de trouver des solutions non décrites sur ce site qui est dédié au modélisme ferroviaire.

      Répondre

      • Dans quel article dites-vous que vous avez répondu aux questions que je me pose quant à la place occupée en mémoire par les programmes et les données ? Dans l’article « Types, constantes et variables » ? Dans cet article sont en effet expliquées les différences de taille en mémoire occupées par les divers types de données (byte, int, etc.) mais pas la différence de gestion en mémoire entre une variable (par exemple de type int) et une constante (par exemple de type const int).
        Tout à l’heure en marchant (!) j’y réfléchissais et je pense que les variables et les constantes sont gérées pareil en mémoire. Mais je ne m’y connais pas vraiment, en fait. Je ne sais pas trop comment les programmes, les instructions, les variables sont gérées par un processeur ou micro-contrôleur, comment fonctionne tout cela. Par contre il m’est revenu (ça fait bien longtemps que je ne programme plus en C) l’existence du mot-clé #define qui, lui, agit avant la compilation et doit faire gagner de la place en mémoire… Mais vous avez raison, la compilation d’un programme donnant le nombre d’octets utilisés, je peux faire des tests.
        Je n’ai pas encore lu votre cours d’électronique car j’ai vu qu’il contenait 250 pages, mais je le conserve précieusement sur un coin de mon disque dur pour le lire quand j’aurai un peu de temps. C’est sûrement en électronique que j’ai le plus de lacunes.
        Vous avez raison, un article ne peut pas être universel, mais si avez envie un jour d’écrire un article sur le fonctionnement des processeurs (comment ils fonctionnent) et l’optimisation de la gestion de la mémoire, je le lirai avec intérêt !
        À bientôt ! :-)

        Répondre

  • Le microcontrôleur ATtiny45 (1) 30 avril 2018 11:11, par Christian

    Il est très difficile de dire dans quels articles nous avons abordé ces notions, mais nous l’avons fait. Consultez par exemple l’article "Trois façons de déclarer des constantes" qui renvoie à l’article "Calculer avec l’Arduino (1)". Et souvent nous nous répétons lorsque nous commentons par exemple une partie de programme donnée dans un article.
    Les variables et les constantes ne sont pas gérées de la même façon si le programmeur fait bien son travail ! En effet, comme son nom l’indique, une variable a besoin d’une case en mémoire pour stocker les différentes valeurs qu’elle prendra au cours de l’exécution du programme. Ceci n’est pas nécessaire pour une constante (définie par le terme const) dont l’unique valeur peut être prise en compte par le compilateur lui-même. Il en est de même d’un #define et c’est pourquoi un bon programmeur peut gagner de la place en mémoire. Bien sûr, si le programmeur gère ses constantes de la même façon que ses variables, il ne gagne rien en place mémoire.
    L’article sur le fonctionnement d’un processeur a déjà été écrit : il s’agit du chapitre 27 de mon cours "Un moteur ATmega328P" qui donne les grandes lignes (complétées par d’autres chapitres) du fonctionnement d’un µP ou µC et de la gestion de la mémoire. Pour bien traiter ce sujet, il faudrait un livre entier mais vous pouvez trouver votre bonheur aux éditions Dunod par exemple. Voici donc un chapitre que vous pouvez commencer à lire, ce qui vous donnera peut-être envie ensuite de lire l’ensemble du cours et de revenir à certains articles de ce site.
    Enfin, et je le dis aussi pour d’autres lecteurs, vouloir gagner de la place en mémoire se justifie pour plusieurs raisons :

    • on en a vraiment besoin
    • on veut prendre les bonnes habitudes en écrivant ses programmes car un µC dispose de peu de mémoire, donc il faut l’économiser
    • cela représente un vrai challenge qu’on a envie de relever
      Toutes ces raisons sont excellentes, mais il ne faut pas perdre de vue qu’on écrit un programme dans le but qu’il fonctionne, c’est-à-dire qu’il réalise une certaine tâche à accomplir. Je le dis pour que les débutants qui liraient ces lignes ne fassent aucun complexe : si le programme tourne, je dis bravo ! Il sera ensuite temps d’améliorer son style en augmentant son expérience. C’est aussi vrai pour une langue étrangère, l’important étant avant tout de communiquer, pas forcément de bien s’exprimer.
      Ecrire des articles prend du temps mais nous tiendrons compte de toutes vos demandes afin de répondre le plus possible à vos préoccupations.

    Répondre

    • Le microcontrôleur ATtiny45 (1) 1er mai 2018 01:05, par An

      Merci de votre réponse.
      J’ai découvert votre site la semaine dernière, je n’ai donc pas encore une bonne vision de tous les sujets abordés par vos nombreux et intéressants articles, mais je vais les parcourir peu à peu !
      Enfin, je vous rejoins complètement pour déconseiller l’optimisation de code aux débutants, mais aussi aux utilisateurs avancés dans la grande majorité des cas, hormis les éventuelles exceptions que vous avez très bien décrites. Pour ma part, c’est plus par curiosité et jeu que je me posais ces questions.
      À bientôt :-))

      Répondre

  • Le microcontrôleur ATtiny45 (1)commande servo 21 novembre 2018 18:42, par Guy Besseyre

    bonjour Christian
    mon but:charger sur un attiny 45 un petit programme destiné à ralentir un servo
    pour celà j’ai voulu transposer un programme réalisé pour atmega 8, je ne comprends pas certaines instructions et donc plein d’erreurs sur le uno
    lien ci joint
    merci pour un peu d’aide

    Voir en ligne : ralentisseur de servo

    Répondre

    • Le microcontrôleur ATtiny45 (1)commande servo 2 décembre 2018 23:07, par christian

      Bonjour,
      j’ai bien pris en compte votre question et j’essaierai d’y répondre dès que j’aurais réintégré mon domicile, c’est à dire d’ici à peu près trois semaines.
      ici, je n’ai aucun matériel pour vérifier la réponse que je donnerai.
      merci de votre patience.
      christian

      Répondre

    • Le microcontrôleur ATtiny45 (1)commande servo 3 décembre 2018 11:28, par Dominique

      Ce serait peut-être plus simple d’utiliser La bibliothèque SlowMotionServo en amont.

      Répondre

      • Le microcontrôleur ATtiny45 (1)commande servo 3 décembre 2018 17:20, par guy Besseyre

        Merci Dominique pour la suggestion d’utiliser Slowmotionservo, ce serait bien sûr la solution ,mais dans mon
        application je ne peux pas car le servo à ralentir fait partie d’un automatisme dont je ne peux pas changer le programme,l’attiny 45 serait simplement un composant d’interface
        bien cordialement

        ,

        Répondre

      • Le microcontrôleur ATtiny45 (1)commande servo 4 décembre 2018 14:56, par christian

        Toutes les bibliothèques écrites pour Arduino ne fonctionnent pas avec les puces ATtiny. C’est notamment le cas de la bibliothèque Servo car elle utilise le Timer 16 bits absent de l’ATtiny45.
        Et du coup SlowMotionServo non plus !
        Attention à ce genre de réponse qui paraît évident mais ne l’est absolument pas. Ce n’est pas pour rien si, dans l’article, nous avons reconstitué le signal au lieu d’employer une bibliothèque.

        Répondre

        • Le microcontrôleur ATtiny45 (1)commande servo 5 décembre 2018 09:28, par Jean-Luc

          Effectivement, essais faits, c’est la bibliothèque Servo qui ne compile pas faute de support matériel. Il existe une bibliothèque nommée Servo8bit pour les ATTiny 45 et 85 : https://github.com/fri000/Servo8Bit

          Répondre

          • Le microcontrôleur ATtiny45 (1)commande servo 5 décembre 2018 17:59, par christian

            Merci Jean-Luc pour cette information.
            Cela montre que lorsqu’on est confronté à un problème, la première chose à faire est de chercher s’il existe du logiciel écrit par quelqu’un d’autre. C’est souvent le cas, ce qui permet de gagner du temps et de la sueur.
            Autrement, il faut l’écrire soi même, ce qui était plutôt le but de l’article pour démontrer que c’est tout à fait faisable.
            Mais j’essaierai cette bibliothèque à base de Timer 8 bits maintenant que je sais qu’elle existe.

            Répondre

    • Le microcontrôleur ATtiny45 (1)commande servo 4 décembre 2018 08:50, par Jean-Luc

      Bonjour,

      Peut être pourriez vous ouvrir un fil sur le forum et y mettre les messages d’erreur de compilation que vous obtenez.

      Répondre

  • Le microcontrôleur ATtiny45 (1) 29 mars 14:17, par bobyAndCo

    Dommage que l’on ne puisse plus programmer un ATTiny au travers d’un Arduino avec la version 2.xx du logiciel comme expliqué dans cet article.

    Christophe

    Répondre

    • Le microcontrôleur ATtiny45 (1) 29 mars 14:59, par Christian

      Bonjour Christophe,
      Tu es sûr de ce que tu dis ?
      Cela fait assez longtemps que je n’ai pas eu à programmer d’ATtiny, mais l’IDE 2.xx possède tout ce qui est nécessaire pour le faire. Donc, cela devrait fonctionner, d’autant que la programmation passe par l’exemple ’ArduinoISP’ qui existe sur IDE 2.
      Ma dernière programmation était pour l’écriture de l’article sur le programmateur LOCODUINO, mais je ne me rappelle plus si je l’ai faite avec IDE 1 ou 2 !

      Répondre

  • Le microcontrôleur ATtiny45 (1) 29 mars 15:05, par bobyAndCo

    Je dis bien en passant par un Arduino. J’ai essayé encore hier soir. En passant par la vesrion 1.8 de l’IDE, aucun problème, sur la 2.xx, avec la même manip, il dit toujours que "un programmeur est nécessaire" !!!

    J’ai vu des posts sur le même problème, mais bon, tout ce qui se dit sur internet n’est pas forcement vrai ! (Citation de Napoléon BONAPARTE)

    Répondre

    • Le microcontrôleur ATtiny45 (1) 29 mars 15:14, par Christian

      Je me rappelle qu’il y a eu des problèmes à la sortie de l’IDE 2.0, mais je pensais qu’ils étaient résolus depuis.
      Dès que j’ai un petit moment, je vais faire un essai et essayer de comprendre.
      Pour la citation de Napoléon, ce devait être dans le film de Ridley Scott, là où il tire sur la pyramide !!! ;-))

      Répondre

Réagissez à « Le microcontrôleur ATtiny45 (1) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Matériel »

Les derniers articles

Les articles les plus lus