AVR – Chapitre 0 – Découverte de l’ATtiny et amorce du tutoriel

Pour la petite histoire…

Depuis quelque mois maintenant, je m’intéresse au monde des microcontrôleurs et à leurs applications pratiques. J’ai commencé par Arduino (le plus médiatique) pour ensuite m’intéresser au MSP430 de Texas Instruments.

Ça à l’air cool !

J’ai fini par me rendre compte que j’avais ici des plate-formes très intéressantes, mais qui ne m’encourageaient pas réellement à me plonger dans les détails. Je me résignais donc à utiliser des librairies écrites pas plus érudits, à copier/coller des morceaux de code que je ne comprenais pas entièrement, et même si les résultats obtenus étaient ceux attendus, je buttais parfois sur la situation du «cas particulier».

L’enfer du «cas particulier»

Celui sur lequel on ne trouve aucun sujet, aucune aide. Celui sur lequel on planche pendant des heures, et des soirées entières, avant d’abandonner lâchement, car «je ne sais plus comment faire» malgré toute la documentation que j’ai épluchée ; malgré tous ces forums en anglais, en allemand, en espagnol, en chinois, en russe (Merci à Google Translate) que j’ai écumés.

Notez que j’ai pour habitude de ne jamais poser de questions sur les forums. Les sujets finissent souvent par dériver, et par être pollués par des débats d’experts, des questions stupides ou opportunes.

De plus, j’ai peur de poser des questions simplettes, de recevoir des réponses d’abord inquisitrices puis pointues et enfin condescendantes (pour quoi faire ? — t’as juste à faire ça <insérer un bloc de code sans commentaire>. — Apprend les bases et on reparlera.). Je suis trop curieux pour le niveau de base, mais pas assez expérimenté pour le niveau supérieur.

Rarement, j’y trouve une solution qui me convient, et quand j’en trouve une, elle est désuète, hors-sujet ou non-documentée. Ou tout simplement, elle ne fonctionne pas pour mon «cas particulier».

Et puis un jour…

J’ai donc fait une pause, en tout cas sur les arcanes des microcontrôleur, pour attaquer un projet basé sur Arduino, que je n’ai pas encore publié.  Et totalement par hasard, souhaitant ajouter des composants à ce projet, en passant une commande, je suis tombé sur une bestiole qui m’a attendri ; l’ATtiny85.

8 pattes, 8bit, 5 entrées-sorties à un prix minuscule (l’euro symbolique). En butinant un petit peu, je crois comprendre qu’il s’agit, pour schématiser, d’un Arduino épuré ; pas d’amorçage, pas de connexion série, mémoires de taille réduite,… Largement suffisant selon moi pour les projets de base (jeux de lumières, capteurs, …).

Pour la partie programmation, il y a une longue liste d’articles dans toutes les langues, qui vous présentent comment, avec un simple Arduino, quelques câbles et un condensateur, on peut flasher ses ATtiny avec du code Arduino.

Hop ! Dans le panier et c’est commandé !

Coucou, toi !

Quelques jours après, je reçois 10 microcontrôleurs. Je dédie donc un de mes Arduino (Duemlianove) au rôle de programmateur AVR (sans savoir ce que celà signifie). Je configure mon IDE, je programme, je branche, je reprogramme, et voilà ; au bout de vingt minutes d’installation, ma diode clignote : mon premier Hello world sur ATtiny fonctionne.

Je note toutefois que la notion de « delay » n’est pas la même que pour l’Arduino, je bidouille un peu, et c’est bon. Je continue mes bricolages ; je teste une diode RGB, un bouton, un buzzer, … je redécouvre l’Arduino, mais sur ATtiny.

Motivé par ces petites bêtes, je m’intéresse alors à la communication. Et ici, la dichotomie entre le code Arduino joli-mais-ça-ne-marche-pas et le code C bas niveau puissant-mais-illisible refait son apparition. Mais cette fois, je ne vais pas m’arrêter.

RTFM

Première idée ; lire la documentation. 234 pages, je passe mon tour pour cette fois. Alors je cherche… d’abord ATtiny85, ensuite ATtiny et enfin, je comprend ce qu’AVR signifie : l’architecture. Et là tout s’éclaire. Je me remémore mes cours de fac, à propos des jeux d’instructions, des registres, …

Après plusieurs jours de recherches sur le sujet, je me suis aperçu d’une chose. Une fois sorti des sentiers battus par Arduino et sa communauté, les tutoriels pour programmer un microcontrôleur AVR avec du code C sont rares, et d’autant plus si on s’évertue à les chercher en français (je me débrouille très bien en anglais, mais c’est parfois plus pratique quand on parle la même langue que l’auteur).

Alors c’est parti, je commence le mien !

ATtiny85 : un microcontrôleur parfait pour débuter avec AVR

Il s’agit d’un microcontrôleur 8-bit, sorti en 2005 et fabriqué par Atmel proposant un jeu d’instructions réduits (RISC), 8192 octets de mémoire Flash, 512 octets de RAM, et autant d’EEPROM. Son unité de calcul tourne de 1 à 20 MHz. Il est possible d’utiliser jusqu’à 6 entrées-sorties numériques, 2 sorties analogiques, 2 horloges 8-bit, 4 entrées analogiques 10-bit. Pour plus de détails, je vous renvoie à la documentation sur le site d’Atmel.

Plusieurs broches (ou pin) cumulant certaines fonctionnalités, il ne sera pas possible de tout utiliser en même temps.

L’ATtiny85 fonctionne avec une tension continue de 2,7 à 5,5 volts. Deux piles LR6/AA peuvent donc suffire pour l’alimenter. Pour ce tutoriel, je vous conseille l’utilisation d’un des ports USB de votre ordinateur.

Prérequis

Comme pour tous les tutoriels, il est important de fixer quelques prérequis ; rien de bien méchant mais il est important de :

Il y a déjà des tas d’articles à ce sujet sur Internet, mais j’en ferai sûrement quelques-uns ici à terme.

Pour le matériel je vous conseille d’avoir à porter de main :

  • des ATtiny85 : sans blague ?
  • des résistances de différentes valeurs ; il existe des boîtes regroupant une quinzaine de valeurs avec 10 à 20 unités par référence. C’est très bien pour débuter.
  • des condensateurs ; en avoir quelques un de plusieurs références peut être utile. Je vous conseille toutefois d’en récupérer quelques-uns de 10 uF (micro-farad), pour fabriquer votre programmateur AVR pour Arduino.
  • des plaques de prototypage sans soudure (et des câbles) ; ça coute entre 5 et 10€ et ça vous permet de faire des prototypes très rapidement, sans rien souder. Prenez en plusieurs, cela vous évitera de tout démonter entre chaque montage.
  • des diodes lumineuses, cela permet de réaliser des schémas de base, et de vérifier qu’ils fonctionnent.
  • un Arduino ; qui vous servira de programmateur. Il n’y a pas besoin d’un modèle en particulier.

Objectifs

Ce tutoriel va vous permettre de faire l’inverse de l’Arduino ; aller du plus bas niveau, jusqu’au plus haut.

Pour éviter de papillonner je vais rapidement vous décrire les objectifs de ce tutoriel.

  1. Faire clignoter une LED
  2. Comprendre les registres et accéder aux broches
  3. Utiliser les compteurs
  4. Fabriquer des valeurs analogiques
  5. Lire et écrire les mémoires

 Avertissement

Bien entendu, comme je vous l’ai expliqué avant dans ma litanie ; je ne suis pas un expert de ces microcontrôleurs, je découvre même parfois en même temps que j’écris ces lignes… Alors je souhaite vous demander votre attention quant au contenu de ces articles. Je n’y prétend pas tout connaître sur l’architecture AVR et il m’arrivera surement de me tromper.

Ces tutoriels reflètent mon expérience, et ce qui a marché pour moi marchera très probablement pour vous. Si jamais ce n’est pas le cas, où si jamais je me suis trompé, je vous invite à me le signaler en commentaire ou en privé.

De plus, et vous le comprendrez surement, je ne peux pas être tenu responsable en cas de défaillance de vos réalisations, même si celles-ci endommagent vos biens ou ceux d’un tiers, ou pire encore blesse quelqu’un. De mon point de vue, l’électronique s’apprend par l’expérience, et il arrivera à tout le monde d’endommager des composants lors de ses réalisations.

 

5 réflexions au sujet de « AVR – Chapitre 0 – Découverte de l’ATtiny et amorce du tutoriel »

  1. Pouvez vous indiquer comment obtenir les bibliothèques :

    avr/io.h
    util/delay.h
    avr/interrupt.h

    débutant en arduino je souhaite réaliser le montage du projet « feux » de Hackable magazine » mais je « coince » sur ce point.

    merci d’avance

    1. Suivant l’environnent dans lequel on travaille, on peut trouver ces bibliothèques dans

  2. merci pour ces infos.

    En fait il m’a fallu encore chercher sur le NET pour obtenir où dénicher les fameux fichiers :
    arduino\hardware\tools\avr\avr\include
    ……………………………………………………\util
    …………………………………………………….\compat (?)
    mais je rencontre un problème lors de la compilation dans l’IDE ARDUINO :
    feuxtric.ino:52:1: error: ‘TIMSK’ was not declared in this scope
    feuxtric.ino:55:1: error: ‘GIMSK’ was not declared in this scope
    feuxtric.ino:55:14: error: ‘PCIE’ was not declared in this scope
    feuxtric.ino:57:1: error: ‘PCMSK’ was not declared in this scope

    Et là, je coince!
    Daniel

    1. Il peut s’agir d’un problème de sélection de matériel cible ; s’agit-il d’un Atmega8 ? Atmega168 ? Les registres ne sont pas nécessairement les mêmes selon la référence de matériel, il peut être nécessaire de se reporter à la documentation.

      1. En fait le programme est destiné à être « téléversé » dans un ATTINY 85 via une carte UNO configurée en programmeur ISP…ça doit être ça le hic, la gestion des interruptions devant être spécifiée pour un ATTINY…

        bon, va falloir essayer!

        encore merci

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*