AVR - So programmieren Sie einen AVR-Chip unter Linux

Ich habe nicht die Zeit für eine vollständige Erklärung, aber ich kann Ihnen die Befehle, die ich auf meiner Linux-Box verwende, um AVRs zu programmieren, im Kochbuchstil geben:

Vorbereitungen

• Stellen Sie unter Ubuntu sicher, dass mehrere erforderliche Pakete installiert sind:sudo apt-get install avr-libc avrdude binutils-avr gcc-avr srecord werfen Sie optional gdb-avr simulavr ein für Debugging und Simulation.
• Ich habe begonnen, ein Verzeichnis zu erstellen, in dem alle meine ATtiny-Projekte ein Zuhause finden:mkdir ~/attiny: cd ~/attiny
• Für jedes Projekt erstelle ich einen eigenen Unterordner (und ich habe nichts gegen lange Namen):mkdir waveShare4digit8segmentDisplay; cd waveShare4digit8segmentDisplay

Quelle erstellen

• Bearbeiten Sie die Quelldatei mit Ihrem bevorzugten Texteditor:vi project.cpp

Einstellungen

Die folgenden Befehle verlassen sich stark auf Umgebungsvariablen, um die Wartung einfach zu halten.

• Der Basisname der verwendeten/erstellten Dateien:src=project
• Gemeinsame Compiler-Flags:cflags="-g -DF_CPU=${avrFreq} -Wall -Os - Werror -Wextra"

Die folgenden Variablen müssen möglicherweise geändert werden, je nachdem, welchen Programmierer Sie verwenden. Siehe man Seiten für Details.

• baud=19200 Die Baudrate, mit der Ihr Programmiergerät mit dem PC kommuniziert:
• programmerDev=/dev/ttyUSB003 Der Gerätename, an dem sich Ihr Programmiergerät befindet. Überprüfen Sie dmesg Ausgabe für Details.
• programmerType=avrisp Dies kann für Ihren genauen Programmierer anders sein.

Die folgenden Variablen hängen von der genauen Steuerung ab, die Sie programmieren möchten:

• avrType=attiny2313 Überprüfen Sie avrdude -c $programmerType für unterstützte Geräte.
• avrFreq=1000000 Überprüfen Sie das Datenblatt des Controllers auf die Standarduhr.

Kompilieren

• Der erste Schritt besteht darin, eine Objektdatei zu erstellen:avr-gcc ${cflags) -mmcu=${avrType) -Wa,-ahlmns=${src).lst -c -o ${src).o ${src).cpp
• Der zweite Schritt besteht darin, eine ELF-Datei zu erstellen:avr-gcc ${cflags) -mmcu=${avrType) -o ${src).elf ${src).o
• Der dritte Schritt besteht darin, eine Intel-Hex-Datei zu erstellen, dies ist die Datei, die tatsächlich an den Programmierer gesendet wird:avr-objcopy -j .text -j .data -O ihex ${src).elf ${src).flash.hex

Programmierung

• Der letzte Schritt ist die Programmierung des Geräts:avrdude -p${avrType} -c${programmerType} -P${programmerDev} -b${baud} -v -U flash:w:${src}.flash.hex

Makefile

Als Alternative zum Merken der Befehle habe ich mir ein Makefile nach meinem persönlichen Geschmack zusammengebastelt, Sie können es unter dem Namen Makefile speichern (achten Sie auf den Großbuchstaben M ). Es funktioniert wie folgt:

• make makefile Bearbeiten Sie das Makefile;
• make edit Quelldatei bearbeiten;
• make flash Flash-Speicher des Geräts programmieren;
• make help Andere Befehle auflisten.

Hier ist das 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

Es kann notwendig erscheinen, avrdude auszuführen als root , wenn das passiert, rechtfertigt es eine eigene Frage . Es kann mit udev gelöst werden erfordert aber etwas spezifische Informationen darüber, wie der Programmierer vom Betriebssystem erkannt wird.

Hallo Welt

Lassen Sie mich ein „Hello World“ einwerfen, das einen Controller-Pin 2 (PB3) (z. B. ATtiny13, ATtiny45, ATtiny85) mit 1 Hz umschalten lässt. Befestigen Sie eine LED und einen Vorwiderstand an dem Pin und die LED sollte anfangen zu blinken.

• Bearbeiten

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

• Flash machen

Fertig.

Sie können die AVR GNU-Tools als eigenständige Pakete unter Linux verwenden. Dazu gehören avr-gcc, avr-binutils und avr-libc. Dies wird als Toolchain bezeichnet.

Sobald Sie eine Hex-Datei erstellt haben und diese auf Ihren Chip flashen möchten, können Sie avrdude verwenden.

All dies ist unter Linux kostenlos und leicht verfügbar und nicht zu schwierig zu konfigurieren, um zusammenzuarbeiten.

LadyAda hat eine solide Schritt-für-Schritt-Anleitung für den gesamten Prozess.