Ich habe keine Zeit für eine vollständige Erklärung, aber ich kann Ihnen die Befehle, die ich auf meiner Linux-Box zum Programmieren von AVRs verwende, im Stil eines Kochbuchs geben:
Vorbereitungen
- Stellen Sie unter Ubuntu sicher, dass mehrere erforderliche Pakete installiert sind:
sudo apt-get install avr-libc avrdude binutils-avr gcc-avr srecordOptional können Sie sie gdb-avr simulavrfür das Debuggen und die Simulation einwerfen .
- 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 mir machen lange Namen nichts aus):
mkdir waveShare4digit8segmentDisplay; cd waveShare4digit8segmentDisplay
Quelle erstellen
- Bearbeiten Sie die Quelldatei mit Ihrem bevorzugten Texteditor:
vi project.cpp
die Einstellungen
Die folgenden Befehle hängen stark von Umgebungsvariablen ab, um die Wartung zu vereinfachen.
- Der Basisname der verwendeten / erstellten Dateien:
src=project
- Allgemeine Compiler-Flags:
cflags="-g -DF_CPU=${avrFreq} -Wall -Os - Werror -Wextra"
Die folgenden Variablen müssen möglicherweise geändert werden, je nachdem, welches Programmiergerät Sie verwenden. manEinzelheiten finden Sie auf den Seiten.
baud=19200 Die Baudrate, mit der Ihr Programmierer mit dem PC kommuniziert: programmerDev=/dev/ttyUSB003Der Gerätename, unter dem sich Ihr Programmierer befindet. Überprüfen Sie die dmesgAusgabe auf Details.programmerType=avrisp Dies kann für Ihren genauen Programmierer unterschiedlich sein.
Die folgenden Variablen hängen von der genauen Steuerung ab, die Sie programmieren möchten:
avrType=attiny2313Suchen Sie avrdude -c $programmerTypenach unterstützten Geräten.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
- Im zweiten Schritt erstellen Sie eine ELF-Datei:
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 das Programmieren des Geräts:
avrdude -p${avrType} -c${programmerType} -P${programmerDev} -b${baud} -v -U flash:w:${src}.flash.hex
Makefile
Als Alternative zum Speichern der Befehle habe ich ein Makefile nach meinem persönlichen Geschmack zusammengestellt. Sie können es unter dem Namen speichern Makefile(beachten Sie die Groß- und Kleinschreibung M). Es funktioniert wie folgt:
make makefile Bearbeiten Sie das Makefile.make edit Bearbeiten Sie die Quelldatei.make flash Programmieren Sie den Flash-Speicher des Geräts.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 mag notwendig erscheinen, so zu verfahren, avrdudeals rootwürde dies eine eigene Frage rechtfertigen . Es kann gelöst werden udev, erfordert jedoch ein wenig spezifische Informationen darüber, wie der Programmierer vom Betriebssystem erkannt wird.
Hallo Welt
Lassen Sie mich eine 'Hallo Welt' einwerfen, bei der ein Controller-Pin 2 (PB3) (z. B. ATtiny13, ATtiny45, ATtiny85) auf 1 Hz umschaltet. Bringen Sie eine LED und einen Vorwiderstand am Pin an und die LED sollte anfangen zu blinken.
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
Getan.
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 frei und leicht verfügbar und für die Zusammenarbeit nicht allzu schwierig zu konfigurieren.
LadyAda hat eine solide Schritt-für-Schritt- Anleitung für den gesamten Prozess.
quelle
Für die Entwicklung von AVR in Ubuntu sind nur wenige Schritte erforderlich:
Installieren Sie Tool-Chain :
sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc avrdudeErstelle einen Hello world Code und speichere:
Laden Sie Makefile tempelate herunter und speichern Sie es in dem Verzeichnis, in dem Sie die
hello_world.cDatei gespeichert haben.Makefile bearbeiten :
Bauen Sie das Ziel
Geben Sie einfach
makedie Konsole ein und drücken Sie die Eingabetaste.Laden Sie Anweisungen mit avrdude in AVR hoch
Verwenden Sie den Befehl in der Konsole als: (vorausgesetzt, der von Ihnen verwendete Programmierer ist usbasp, google oder siehe Handbuch für andere Optionen)
quelle