[Raspberry] Se lancer dans la Programmation AVR avec votre RPi

Cet article a été rédigé il y a 4 années ! Il commence à dater, mais n'est pas forcément obsolète.. Lisez-le en gardant cela en tête !
Bonjour, Voici un article que j’ai tardé à publier, car je me suis vraiment bien amusé en testant tout un tas de choses. En effet, vous allez vite comprendre dans cet article toute la puissance et l’intérêt des AVR. Pour le moment ce terme ne vous évoque pas forcement grand chose, toutefois les possibilités sont quasi illimités 🙂 Voyons ça ensemble !    

I) Présentation des AVR

Un AVR est le terme utilisé par la société Atmel qui les créé pour désigné le coeur d’un processeur. Il s’agit d’un composant électronique programmable et reprogrammable à volonté. De quoi occuper des personnes pendant de longues soirées Un AVR ça ressemble à ça :

 797px-AVR_group-624x468

Comme vous pouvez le voir, il y a ici 3 types d’AVR :

  • ATmega
  • ATtiny
  • ATXmega

Ces trois composants sont programmable et vous permettent de réaliser tout un tas d’actions. Du plus basique, avec une LED qui clignote.. Jusqu’au contrôle domotique de votre maison (centralisé grâce au Raspberry et des  emetteur/recepteur rf ?).

Vous l’imaginez bien ce type de système vous donne le champ libre pour faire tout un tas de choses ! Ce sont des composants qui sont réutilisables. Puisqu’en effet, il suffit simplement de compiler dessus un programme pour en changer le comportement !

Un AVR en plus de cela en ce qui concernant les ATtiny ne coutent que 1 ou 2€/pièces. Formidable n’est-ce pas ? 🙂

Vous pouvez les trouver facilement sur eBay ou Amazon. Personnellement j’ai acheté 5 ATtiny45 avec leur support chacun pour 10€ TTC (Frais de port inclus) Après à vous de voir celui dont vous avez besoin.

Je vous renvoie donc au site du constructeur pour trouver celui dont vous avez besoin :

http://www.atmel.com/products/microcontrollers/avr/

 

II) Préparation du Raspberry et du circuit de programmation

Passons à présent à la partie pratique maintenant que vous avez les idées un peu plus clair sur ce que sont les AVR, car en effet c’est bien beau d’avoir acheté ces petites choses, mais comment s’en servir ?  

1. Retour aux GPIO Raspberry

Pour cela vous allez rentrer dans le détail des GPIO. Je vous ai présenté dans mon article précédent le fonctionnement partiel du P1 Header. (Je vous rappelle le schéma ci-dessous d’ailleurs) p1header Je vous ai expliqué que l’on pouvait se servir des pins vert pour communiquer librement vers l’extérieur. Cependant certains de ces pins sont  réservés et ont une fonction bien particulière. En effet, regardez les pins 19,21,23,24 et 25, ces pins violets fonctionnent selon le protocole SPI. De la même façon que les pins 3,5 en bleu qui se basent sur le protocole I2C.

2. Côté ATtiny

Le premier réflexe est de trouver la documentation de l’ATtiny, je vous aide j’en ai récupéré un résumé sur le site du constructeur La documentation du ATtiny45

En cherchant un peu dans cette donne, on trouve que ce petit composant utilise le protocole SPI ! Génial, n’est-ce pas ? C’est un protocole disponible sur le Raspberry..

Maintenant que l’on sait ça, vous pouvez aussi voir le schéma technique d’un ATtiny à la page 2. C’est en quelque sorte la page clef de cette documentation, alors laissez là ouverte dans un onglet pour y revenir à tout instant quand vous vous poserez une question.

Pour programmer l’ATtiny, je vous propose d’utiliser le circuit suivant, que vous pouvez souder pour quasi-rien ! Il vous permettra de placer un ATtiny sur son support et d’envoyer le programme dessus.

avr  IMG_0008

Avec cela il ne vous reste plus qu’à brancher la nappe Raspberry et tout est prêt niveau matériel pour programmer le Raspberry.

J’ai simplement connecté les différents fils exemple : MISO sur la patte MISO de l’AVR, MOSI sur MOSI, CLK sur SCLK (il s’agit de la clock), sans oublier l’alimentation Vcc-Gnd !

Note : Les led ne sont clairement pas obligatoires !! Mais puisque j’utilise un script fait maison pour automatiser l’envoie je me suis dit que rajouter des led de débuggage pourrait être sympa ! :-

Attention : Je vous ai parlé dans mon article précédent de ne jamais envoyer de 5V sur les pattes du raspberry. Voici l’exemple type qui pourrait vous amener à foutre en l’air votre Raspberry ! Les ATtiny supportent du 5V, mais les GPIO Raspberry non.

Si vous programmez votre ATtiny depuis un circuit alimenté en 5V. Sachez que le programme se lance immédiatement après avoir été envoyé. (sous réserve que le uC n’ait pas planté lamentablement !) Dans ce cas, certaines pattes qui étaient utilisées en entrée seront configurées en sortie. Et donc si de plus ces pattes sont à 5V, pas de soucis pour l’ATtiny, cependant si vous ne réagissez pas dans un lapse de temps assez court.. Vous allez pouvoir voir en direct, ce que qu’il se passe quand un Raspberry claque.. Il lâche une belle fumée blanche. ^^

En effet après avoir été programmé l’ATtiny se lance c’est pourquoi il vous faudra alimenter ce dernier en 3,3V pour être sûr que tout soit compatible. De cette façon le Raspberry supportera la tension, après avoir programmé l’ATtiny.. Franchement ne faites pas l’erreur ça serait vraiment bête de se retrouver avec un GPIO en moins .. ^^"

Notez que sur mon circuit j’utilise biensur du 3,3V ! ^^

3. Côté Raspberry

C’est bien beau, mais malheureusement ce n’est pas encore fini !! Ca ne serait pas drôle sinon ! 🙂 Maintenant que le Hardware est en place, il vous faut encore mettre en place les drivers. Heureusement sur les machines Raspberry les drivers sont disponibles pour le protocole SPI ! Et heureusement d’ailleurs, .. Connectez-vous en root à votre Raspberry et installez les paquets ci-dessous. Retenez simplement qu’il s’agit du nécessaire pour compiler un programme et que AVRDude s’occupera d’envoyer sur l’avr le programme !
# Paquets nécessaires sudo apt-get install -y git autoconf make gcc gcc-avr avr-libc bison flex automake libncurses5-dev # Installation de AVRDude avec le driver "linuxspi". Merci Kevin Cuzner pour ce beau boulot.. !! git clone https://github.com/kcuzner/avrdude.git cd avrdude/avrdude && chmod -R 755 * ./bootstrap && ./configure make && sudo make install
  Cette partie peut prendre un bon moment, allez vous faire couler un café !! 🙂 Une fois cela fait, activez le protocole SPI à l’aide de la commande (Je le met bien en gras, car j’ai cherché pendant une semaine pourquoi mon avr n’était pas détecté !!)
sudo raspi-config
  Connectez votre circuit de programmation aux GPIO du raspberry et placez un AVR sur le support du circuit ! Nous allons tester que tout se passe bien 🙂 Pour cela je vous propose de télécharger le nécessaire pour une première compilation test
wget http://partage.gauss-it.net/raspberrypi/atmel/avr.zip unzip avr.zip && chmod 755 -R ./avr/ && cd avr
Puis lancer la compilation à l’aide des commandes suivantes :
avrdude -c ?type make install
  Si tout ce passe bien vous devriez recevoir le message suivant !!  
avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% 0.02s avrdude: Device signature = 0x1e9206avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed         To disable this feature, specify the -D option. avrdude: erasing chip avrdude: reading input file "main.hex" avrdude: input file main.hex auto detected as Intel Hex avrdude: writing flash (86 bytes): Writing | ################################################## | 100% 0.46s avrdude: 86 bytes of flash written avrdude: verifying flash memory against main.hex: avrdude: load data flash data from input file main.hex: avrdude: input file main.hex auto detected as Intel Hex avrdude: input file main.hex contains 86 bytes avrdude: reading on-chip flash data: Reading | ################################################## | 100% 0.46s avrdude: verifying … avrdude: 86 bytes of flash verified avrdude: safemode: Fuses OK (E:FF, H:DF, L:62) avrdude done.  Thank you.
Si tel est le cas, vous avez reussi à compiler le programme test et la communication se fait correctement. Vous pouvez d’ailleurs tester le pin P4, si vous mettez une diode elle devrait clignoter. Passons à la partie suivante; passons à la pratique, si vous n’obtenez pas le message ci-dessus, laissez un commentaire on trouvera surement une solution à votre problème ! 🙂  

III) Programmation d’un AVR

Pour vous éviter, d’avoir à connaitre et apprendre ces commandes un peu ennuyeuses, je vous ai préparé un petit script qui se chargera d’envoyer les commande permettant de compiler et envoyer un programme. Il permettra aussi d’allumer des LED de contrôle pour le debuggage; je me suis dit que ça pouvait être drôle ! 🙂 Ce programme bash s’appelle raspi-attiny et s’installe à l’aide de root, sur votre Raspberry en une ligne :
cd /bin/ sudo wget http://partage.gauss-it.net/raspberrypi/atmel/raspi-attiny sudo chmod 755 /bin/raspi-attiny
  Pour voir l’aide :
raspi-attiny –help
  Pour mettre à jour le programme raspi-attiny :
sudo raspi-attiny –upgrade  
Pour générer le squelette d’un fichier .c :
raspi-attiny –empty programme.c
  Pour compiler et envoyer un programme :
raspi-attiny ./programme.c
  Pour ce qui est de la programmation en soit, il faut retourner sur la documentation et apprendre à utiliser le PORTB de l’AVR.. (Ou suivre l’article sur le bouton power ou j’explique ses rudiments !!) Bon courage !!

Conclusion,

Si vous avez tout bien suivi de A-Z vous disposez à présent d’un circuit de programmation pour avr et d’un programme permettant de compiler facilement les programmes. Dernière chose, je ne vous l’avais pas dit plus tôt, mais maintenant que vous savez ce que c’est qu’un avr, devinez ce qu’il y a sur les Arduino ? Arduino_Diecimila En réalité un Arduino c’est un peu comme si vous aviez une carte de programmation d’un AVR, mais en plus complet ! Avec ce que je vous ai raconter dans cet article plus la peine d’acheter un Arduino, vous en avez la version minimale couplée avec un Raspberry 🙂

14 réponses à “[Raspberry] Se lancer dans la Programmation AVR avec votre RPi

    1. Bonjour,

      Le bouton sert à faire un reset de l’AVR.
      Mais avec le recul si j’avais à le refaire je mettrai un switch à 2 positions (+resistance) sur la patte d’alimentation entre masse et vcc

  1. Bonjour j’ai essayé de programmer un avr j’ai commencé avec le classique blink tout fonctionne mais quand je change le code du blink pour essayer d’upload celui d’un projet j’ai beaucoup d’erreur

    Le code http://www.instructables.com/files/orig/F95/O60L/I45HOS1E/F95O60LI45HOS1E.txt

    Et les differents liens qu’on m’ont aidé a faire fonctionner le blink

    http://www.instructables.com/id/MASON-JAR-MOOD-LAMP/?ALLSTEPS
    http://www.instructables.com/id/Programming-the-ATtiny85-from-Raspberry-Pi/?ALLSTEPS

    Merci d’avance !

    1. Bonjour,

      Je programme mes AVR via mon Raspberry, malheureusement mon tutoriel est fait pour la programmation Raspberry-AVR et non en passant par un Arduino, je ne saurai donc t’aider

  2. Bonjour

    Je me perds un peu dans la numérotation des pins.

    SPI :
    Je pense qu’il y a une erreur dans la phrase "regardez les pins 19,21,23,24 et 25, ces pins violets". Il faudrait remplacer le "25″ par "26".

    Diodes : dans le diagramme vous indiquez les GPIO 11, 7 et 3 et dans le programme vous utilisez
    sudo gpio mode 0 out
    sudo gpio mode 2 out
    sudo gpio mode 7 out

    Je n’arrive pas à faire le lien entre ces numérotations.

    Pouvez-vous m’éclaircir ?

    Merci

  3. Bonjour BEN,
    Désolé du temps de réponse, j’étais en déplacement toute la semaine 🙂

    Merci d’avoir posé toutes ces questions. Pour y répondre, en effet oui il y a quelques erreurs, j’avais changé le circuit électrique il y a quelques mois sans faire trop attention, je me rends compte que dans ma tête ça marchait, car je l’ai cablé avant de le mettre, mais dans la pratique non. Je corrigerai ça dès ce soir.
    Par ailleurs avec le recul, le circuit n’est pas du tout top, on aurait pu réunir les diodes sur une seule résistance, le switch n’est pas très adapté, cablé comme ça.. Bref, j’ai un regard très critique sur ce que j’ai fais avec le recul !

    Autrement c’est vrai qu’on s’y perd vite, entre pin, gpio, bcm, etc.. Encore que wiringPi a été très bien amélioré, du coup on s’y repère mieux.
    Je travaille actuellement à un petit projet Eagle pour usiner mon propre PCB, je mettrai à jour mon article probablement dans la semaine et en profiterai pour en faire un de présentation dès que j’aurai le temps.
    Il y aura des schémas electrique plus propre aussi et correct !

    Merci encore et n’hésite pas à demander encore, en cas de soucis.

    1. Et pour répondre rapidement à ta question, comme tu as réussir à lire la doc :
      – Vcc sur 3v3,
      – GND sur GND,
      – MISO sur MISO,
      – MOSI sur MOSI et
      – CLK sur SCLK.
      – Autrement il y a le pin de RST qui va sur le GPIO 6, qui correspond au pin numéro 22, si tu utilises mon code.

      Une fois cablé tu lances le programme, ton AVR doit être détecté.
      Mais encore une fois, j’ai l’intention d’améliorer la qualité de cet article qui est somme toute rudimentaire!

  4. Bonjour,
    j’ai suivi les instructions comme indiquées et malheureusement je n’arrive pas à faire communiquer mon Attiny85 avec ma raspberry. Au moment d’envoyer un programme dessus il m’indique simplement "erreur lors de la compilation" et la même chose pour l’upload.

    J’aimerais déjà savoir s’il suffit de mettre la pin VCC de l’attiny sur la pin 3.3V GPIO du Rpi pour que l’attiny soit alimenté ou est ce qu’il faut une autre source de tension ?

    Ensuite j’aimerais savoir s’il y a un moyen de vérifier la communication autre que par l’envoi à chaque fois d’un programme ?

    Merci d’avance 🙂

    1. Bonjour Vincent, je rentre de vacances 🙂 et je réponds progressivement aux commentaires ! Désolé pour l’attente !

      Si vous avez eu un message erreur lors de la compilation, il faut déjà vous assurer que votre code est OK. Normalement, de mémoire, si vous utilisez mon programme raspi-attiny, il devrait vous sortir un fichier de log permettant de comprendre l’erreur.

      Concernant la communication avec l’attiny, il y a en plus du 3.3V et GND, une pin de RST (reset) nécessaire. Toutefois, en vu de votre problème, ce n’est pas encore un problème de communication. (ça sera la prochaine étape!)

      Enfin en effet, oui vous pourrez tout à fait communiquer avec le Raspberry. Toutefois ce sera sommaire dans un premier temps, il s’agira par exemple d’une communication par GPIO, une fois le programme envoyé (change de la valeur d’un pin).

      PS: Y aura bientôt du nouveau concernant les ATtiny, sur mon blog, car je travaille sur un framework type Arduino, un pcb pour programmer le composant et une amélioration de raspi-attiny.

  5. Bonjour. Lorsque l’on consulte la doc du Atiny45 la patte 8 c’est VCC et la patte 1 RESET.
    Sur votre schéma de câblage le switch est connecté sur la patte VCC et le GPIO sur la patte RESET. Est-ce une erreur ?
    Vous parler dans vos dernier post d’une réalisation d’un PCB sous eagle optimisé. Est-il terminé ? si oui est ce possible d’obtenir le fichier ?
    Merci de votre aide.
    Cordialement

    1. En effet l’idée c’était de pouvoir le reset avec un gpio, car aussi attention si vous l’alimentez avec du 5v vous risquez de griller votre raspberry avec les pins retours.
      Pour le pcb, j’ai usiné un premier prototype qui fonctionnait mais avec quelques soucis avec les les!
      Je suis entrain de revoir cela, mon déménagement m’aura fait prendre un peu de retard. Raison pour laquelle je n’ai pas posté grand chose ces derniers temps!

  6. Bonjour. merci de votre réponse. Travaillant avec le Pi régulièrement, je fais bien attention au valeur de tension envoyée sur le GPIO. Par contre pourriez vous m’éclairer sur l’utilité de ce poussoir sur la patte VCC ?
    Merci d’avance

Laisser un commentaire

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