Ich habe vor kurzem einen AVRISmkII AVR-Programmierer und ich habe einen ATtiny85 und einen ATmega328. Ich habe mich gefragt, wie ich diese Chips (mit dem Programmierer) programmieren kann, aber wenn ich versuche, Atmel Studio 6 zu bekommen, ist es nur für Windows. Gibt es eine Möglichkeit, die ich unter Linux (speziell Ubuntu) nutzen könnte? Ant Vorschläge? Vielen Dank!

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.

• machen 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

• mach blitz

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.

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 avrdude

Erstelle einen Hello world Code und speichere:

#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); 
    }
}

Laden Sie Makefile tempelate herunter und speichern Sie es in dem Verzeichnis, in dem Sie die hello_world.cDatei gespeichert haben.

Makefile bearbeiten :

# 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

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)

$avrdude -c m16 -p usbasp -U flash:w:hello_world.hex