AVR - Comment programmer une puce AVR sous Linux

22

J'ai récemment obtenu un programmeur AVRISmkII AVR, et j'ai un ATtiny85 et ATmega328. Je me demandais comment je pouvais programmer ces puces (avec le programmeur) mais quand j'essaye d'obtenir Atmel Studio 6 c'est uniquement pour Windows. Existe-t-il un moyen que je pourrais utiliser sous Linux (Ubuntu en particulier)? Des suggestions de fourmis? Merci!

avr  linux  programmer 
— user151324
source

Réponses:

36

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

Les 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 ajoutez éventuellement le gdb-avr simulavrdébogage et la simulation.
  • J'ai commencé à créer un répertoire dans lequel tous mes projets ATtiny trouvent un foyer: mkdir ~/attiny: cd ~/attiny
  • Pour chaque projet, je crée un sous-dossier dédié (et cela ne me dérange pas les noms longs): 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 reposent fortement sur des variables d'environnement, pour faciliter la maintenance.

  • Le nom de base des fichiers utilisés / créés: src=project
  • Indicateurs de compilateur courants: 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. Reportez-vous aux manpages pour plus de détails.

  • baud=19200 Le débit en bauds auquel votre programmeur communique avec le PC:
  • programmerDev=/dev/ttyUSB003Le nom du périphérique où se trouve votre programmeur. Vérifiez la dmesgsortie 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=attiny2313Vérifiez les avrdude -c $programmerTypeappareils 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( faites attention à la capitale M). Cela fonctionne comme suit:

  • make makefile Modifiez le makefile;
  • make edit Modifiez le fichier source;
  • make flash Programmer la mémoire flash de l'appareil;
  • make help Liste d'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 avrdudecar root, si cela se produit, cela justifie une question en soi . Il peut être résolu avec udevmais nécessite un peu d'informations 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 «Bonjour tout le monde» qui fait basculer une broche de contrôleur 2 (PB3) (par exemple ATtiny13, ATtiny45, ATtiny85) à 1 Hz. Fixez une LED et une résistance série à la broche et la LED devrait commencer à clignoter.

  • faire éditer

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 flash

Terminé.

— jippie
source
2
Le tutoriel Hello World définitif!
— Vorac
11

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 que l'on appelle la chaîne d'outils.

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

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

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

— NickHalden
source
0

Pour développer AVR dans Ubuntu, il n'y a que quelques étapes:

Installer la chaîne d'outils :

sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc avrdude

Créez un code Hello world et économisez:

#include<avr/io.h>
#define F_CPU 8000000UL
#include<util/delay.h>
int main() {
    DDRB = 0xff; // make PORTB as O/P   
    PORTB = 0xFF;
    while(1) {
        PORTB |= (1 << 0);               
        _delay_ms(100); 
        PORTB &= ~(1 << 0);     
        _delay_ms(100); 
    }
}

Téléchargez Makefile tempelate et enregistrez-le dans le même répertoire que celui où vous avez enregistré le hello_world.cfichier.

Modifier le Makefile :

# MCU name (Specify the MCU you are using)
MCU = atmega16
# Processor frequency.
F_CPU = 8000000
# Target file name (without extension).
#in this case file name is hello_world
TARGET = main

Construisez la cible

Tapez simplement makedans la console et appuyez sur Entrée.

Télécharger des instructions dans AVR à l'aide d'avrdude

Utilisez la commande dans la console comme: (supposé que le programmeur que vous utilisez est usbasp, google ou consultez le manuel pour d'autres options)

$avrdude -c m16 -p usbasp -U flash:w:hello_world.hex
— mrUnfused
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.