No tengo tiempo para una explicación completa, pero puedo darle los comandos al estilo de los libros de cocina que uso en mi caja de Linux para programar AVR:
Preparativos
- En Ubuntu, asegúrese de que estén instalados varios paquetes necesarios:
sudo apt-get install avr-libc avrdude binutils-avr gcc-avr srecord
opcionalmente, inicie la gdb-avr simulavr
depuración y la simulación.
- Comencé a crear un directorio en el que todos mis proyectos de ATtiny encuentran un hogar:
mkdir ~/attiny: cd ~/attiny
- Para cada proyecto creo una subcarpeta dedicada (y no me importan los nombres largos):
mkdir waveShare4digit8segmentDisplay; cd waveShare4digit8segmentDisplay
Crear fuente
- Edite el archivo fuente con su editor de texto favorito:
vi project.cpp
Configuraciones
Los siguientes comandos dependen en gran medida de las variables de entorno, para facilitar el mantenimiento.
- El nombre base de los archivos utilizados / creados:
src=project
- Banderas comunes del compilador:
cflags="-g -DF_CPU=${avrFreq} -Wall -Os - Werror -Wextra"
Es posible que sea necesario cambiar las siguientes variables según el programador exacto que utilice. Consulte las man
páginas para más detalles.
baud=19200
La velocidad de transmisión a la que se comunica su programador con la PC:
programmerDev=/dev/ttyUSB003
El nombre del dispositivo donde se encuentra su programador. Verifique la dmesg
salida para más detalles.
programmerType=avrisp
Esto puede ser diferente para su programador exacto.
Las siguientes variables dependen del controlador exacto que desea programar:
avrType=attiny2313
Verifique los avrdude -c $programmerType
dispositivos compatibles.
avrFreq=1000000
Consulte la hoja de datos del controlador para ver el reloj predeterminado.
Compilar
- El primer paso es crear un archivo objeto:
avr-gcc ${cflags) -mmcu=${avrType) -Wa,-ahlmns=${src).lst -c -o ${src).o ${src).cpp
- El segundo paso es crear un archivo ELF:
avr-gcc ${cflags) -mmcu=${avrType) -o ${src).elf ${src).o
- El tercer paso es crear un archivo Intel Hex, este es el archivo que realmente se envía al programador:
avr-objcopy -j .text -j .data -O ihex ${src).elf ${src).flash.hex
Programación
- El último paso es programar el dispositivo:
avrdude -p${avrType} -c${programmerType} -P${programmerDev} -b${baud} -v -U flash:w:${src}.flash.hex
Makefile
Como alternativa a recordar los comandos, preparé un archivo provisional a mi gusto personal, puede guardarlo con el nombre Makefile
( tenga en cuenta la capital M
). Funciona de la siguiente manera:
make makefile
Edite el archivo MAKE;
make edit
Edite el archivo fuente;
make flash
Programe la memoria flash del dispositivo;
make help
Enumera otros comandos.
Aquí está el archivo MAKE:
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
Puede parecer necesario ejecutarlo , avrdude
ya root
que si eso sucede justifica una pregunta por sí mismo . Se puede resolver, udev
pero requiere un poco de información específica de cómo el sistema operativo reconoce al programador.
Hola Mundo
Permítanme agregar un 'Hello World' que hace que un pin del controlador 2 (PB3) (por ejemplo, ATtiny13, ATtiny45, ATtiny85) se active a 1Hz. Conecte un LED y una resistencia en serie al pin y el LED debería comenzar a parpadear.
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
Hecho.