AVR - Comment programmer une puce AVR sous Linux

Je n'ai pas le temps pour une explication complète, mais je peux vous donner un style de livre de cuisine les commandes que j'utilise sur ma machine Linux pour programmer les AVR :

Préparatifs

Sur Ubuntu, assurez-vous que plusieurs packages requis sont installés :sudo apt-get install avr-libc avrdude binutils-avr gcc-avr srecord ajouter éventuellement gdb-avr simulavr pour le débogage et la simulation.
J'ai commencé à créer un répertoire dans lequel tous mes projets ATtiny trouvent leur place :mkdir ~/attiny: cd ~/attiny
Pour chaque projet, je crée un sous-dossier dédié (et les noms longs ne me dérangent pas) :mkdir waveShare4digit8segmentDisplay; cd waveShare4digit8segmentDisplay

Créer une source

Modifiez le fichier source avec votre éditeur de texte préféré :vi project.cpp

Paramètres

Les commandes ci-dessous dépendent fortement des variables d'environnement, pour faciliter la maintenance.

Le nom de base des fichiers utilisés/créés :src=project
Options courantes du compilateur :cflags="-g -DF_CPU=${avrFreq} -Wall -Os - Werror -Wextra"

Les variables ci-dessous peuvent devoir être modifiées en fonction du programmeur exact que vous utilisez. Se référer au man pages pour plus de détails.

baud=19200 Le débit en bauds auquel votre programmeur communique avec le PC :
programmerDev=/dev/ttyUSB003 Le nom de l'appareil où se trouve votre programmateur. Vérifiez dmesg sortie pour plus de détails.
programmerType=avrisp Cela peut être différent pour votre programmeur exact.

Les variables ci-dessous dépendent du contrôleur exact que vous souhaitez programmer :

avrType=attiny2313 Vérifiez avrdude -c $programmerType pour les appareils pris en charge.
avrFreq=1000000 Vérifiez la fiche technique du contrôleur pour l'horloge par défaut.

Compiler

La première étape consiste à créer un fichier objet :avr-gcc ${cflags) -mmcu=${avrType) -Wa,-ahlmns=${src).lst -c -o ${src).o ${src).cpp
La deuxième étape consiste à créer un fichier ELF :avr-gcc ${cflags) -mmcu=${avrType) -o ${src).elf ${src).o
La troisième étape consiste à créer un fichier Intel Hex, c'est le fichier qui est réellement envoyé au programmeur :avr-objcopy -j .text -j .data -O ihex ${src).elf ${src).flash.hex

Programmation

La dernière étape consiste à programmer l'appareil :avrdude -p${avrType} -c${programmerType} -P${programmerDev} -b${baud} -v -U flash:w:${src}.flash.hex

Makefile

Comme alternative à la mémorisation des commandes, j'ai concocté un makefile à mon goût personnel, vous pouvez l'enregistrer sous le nom Makefile (attention à la capitale M ). Cela fonctionne comme suit :

make makefile Modifier le makefile ;
make edit Modifier le fichier source ;
make flash programmer la mémoire flash de l'appareil ;
make help Lister les autres commandes.

Voici le makefile :

baud=19200
src=project
avrType=attiny2313
avrFreq=4000000 # 4MHz for accurate baudrate timing
programmerDev=/dev/ttyUSB003
programmerType=arduino

cflags=-g -DF_CPU=$(avrFreq) -Wall -Os -Werror -Wextra

memoryTypes=calibration eeprom efuse flash fuse hfuse lfuse lock signature application apptable boot prodsig usersig

.PHONY: backup clean disassemble dumpelf edit eeprom elf flash fuses help hex makefile object program

help:
    @echo 'backup       Read all known memory types from controller and write it into a file. Available memory types: $(memoryTypes)'
    @echo 'clean        Delete automatically created files.'
    @echo 'disassemble  Compile source code, then disassemble object file to mnemonics.'
    @echo 'dumpelf      Dump the contents of the .elf file. Useful for information purposes only.'
    @echo 'edit     Edit the .cpp source file.'
    @echo 'eeprom       Extract EEPROM data from .elf file and program the device with it.'
    @echo 'elf      Create $(src).elf'
    @echo 'flash        Program $(src).hex to controller flash memory.'
    @echo 'fuses        Extract FUSES data from .elf file and program the device with it.'
    @echo 'help     Show this text.'
    @echo 'hex      Create all hex files for flash, eeprom and fuses.'
    @echo 'object       Create $(src).o'
    @echo 'program      Do all programming to controller.'

edit:
    vi $(src).cpp

makefile:
    vi Makefile

#all: object elf hex

clean: 
    rm $(src).elf $(src).eeprom.hex $(src).fuses.hex $(src).lfuse.hex $(src).hfuse.hex $(src).efuse.hex $(src).flash.hex $(src).o
    date

object:
    avr-gcc $(cflags) -mmcu=$(avrType) -Wa,-ahlmns=$(src).lst -c -o $(src).o $(src).cpp 

elf: object
    avr-gcc $(cflags) -mmcu=$(avrType) -o $(src).elf $(src).o
    chmod a-x $(src).elf 2>&1

hex:    elf
    avr-objcopy -j .text -j .data -O ihex $(src).elf $(src).flash.hex
    avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 -O ihex $(src).elf $(src).eeprom.hex
    avr-objcopy -j .fuse -O ihex $(src).elf $(src).fuses.hex --change-section-lma .fuse=0
    srec_cat $(src).fuses.hex -Intel -crop 0x00 0x01 -offset  0x00 -O $(src).lfuse.hex -Intel
    srec_cat $(src).fuses.hex -Intel -crop 0x01 0x02 -offset -0x01 -O $(src).hfuse.hex -Intel
    srec_cat $(src).fuses.hex -Intel -crop 0x02 0x03 -offset -0x02 -O $(src).efuse.hex -Intel

disassemble: elf
    avr-objdump -s -j .fuse $(src).elf
    avr-objdump -C -d $(src).elf 2>&1

eeprom: hex
    #avrdude -p$(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U eeprom:w:$(src).eeprom.hex
    date

fuses: hex
    avrdude -p$(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U lfuse:w:$(src).lfuse.hex
    #avrdude -p$(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U hfuse:w:$(src).hfuse.hex
    #avrdude -p$(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U efuse:w:$(src).efuse.hex
    date

dumpelf: elf
    avr-objdump -s -h $(src).elf

program: flash eeprom fuses

flash: hex
    avrdude -p$(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U flash:w:$(src).flash.hex
    date

backup:
    @for memory in $(memoryTypes); do \
        avrdude -p $(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U $$memory:r:./$(avrType).$$memory.hex:i; \
    done

Il peut sembler nécessaire d'exécuter avrdude comme root , si cela se produit, cela justifie une question en soi . Il peut être résolu avec udev mais nécessite des informations un peu spécifiques sur la façon dont le programmeur est reconnu par le système d'exploitation.

Bonjour le monde

Permettez-moi d'ajouter un "Hello World" qui fait basculer une broche de contrôleur 2 (PB3) (par exemple ATtiny13, ATtiny45, ATtiny85) à 1Hz. Attachez une LED et une résistance série à la broche et la LED devrait commencer à clignoter.

apporter des modifications

i

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
  DDRB = 0x08;

  while (1) {
    PORTB = 0x00; _delay_ms(500);
    PORTB = 0x08; _delay_ms(500);
  }
}

<ESC>:wq

faire clignoter

Terminé.

Vous pouvez utiliser les outils AVR GNU en tant que packages autonomes sous Linux. Ceux-ci incluent avr-gcc, avr-binutils et avr-libc. C'est ce qu'on appelle la chaîne d'outils.

Une fois que vous avez créé un fichier hexadécimal et que vous souhaitez le flasher sur votre puce, vous pouvez utiliser avrdude.

Tous ces éléments sont disponibles gratuitement et facilement sur Linux et ne sont pas trop difficiles à configurer pour fonctionner ensemble.

LadyAda a un solide tutoriel étape par étape sur l'ensemble du processus.