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.
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
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 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.
la source
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 avrdudeCréez un code Hello world et économisez:
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 :
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)
la source