AVR - Cómo programar un chip AVR en Linux

18

Hace poco recibí un programador AVRISmkII AVR, y tengo un ATtiny85 y ATmega328. Me preguntaba cómo podría programar estos chips (con el programador) pero cuando intento obtener Atmel Studio 6 es solo para Windows. ¿Hay alguna manera que pueda usar en Linux (específicamente Ubuntu)? Sugerencias de hormigas? Gracias!

    
pregunta user151324

3 respuestas

36

No tengo tiempo para una explicación completa, pero puedo darte el estilo de libro de cocina de los comandos que uso en mi caja de Linux para programar los 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 agregue gdb-avr simulavr para la depuración y 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 de origen con su editor de texto favorito: vi project.cpp

Configuración

Los comandos a continuación dependen en gran medida de las variables de entorno, para mantener el mantenimiento fácil.

  • 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 las variables a continuación deban cambiarse dependiendo del programador exacto que utilice. Consulte las páginas man para obtener más información.

  • baud=19200 La velocidad en baudios con la que se comunica su programador con la PC:
  • programmerDev=/dev/ttyUSB003 El nombre del dispositivo donde se encuentra su programador. Ver dmesg output para más detalles.
  • programmerType=avrisp Esto puede ser diferente para su programador exacto.

Las variables a continuación dependen del controlador exacto que desea programar:

  • avrType=attiny2313 Marque avrdude -c $programmerType para dispositivos compatibles.
  • avrFreq=1000000 Verifique la hoja de datos del controlador para el reloj predeterminado.

Compilar

  • El primer paso es crear un archivo de 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 paso final 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, cociné un makefile a mi gusto personal, puede guardarlo con el nombre Makefile (tenga en cuenta el capital M ). Funciona de la siguiente manera:

  • make makefile Editar el archivo make;
  • make edit Edite el archivo fuente;
  • make flash Programa la memoria flash del dispositivo;
  • make help Listar 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 ejecutar avrdude como root , si eso sucede, justifica una pregunta por sí misma . Se puede resolver con udev , pero requiere un poco de información específica de cómo el sistema operativo reconoce al programador.

Hola mundo

Permítame lanzar un 'Hello World' que hace que el pin 2 (PB3) del controlador (por ejemplo, ATtiny13, ATtiny45, ATtiny85) cambie a 1Hz. Conecte un LED y una resistencia en serie al pin y el LED debería comenzar a parpadear.

  • hacer edición

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

  • hacer flash

Hecho.

    
respondido por el jippie
11

Puede usar las herramientas AVR GNU como paquetes independientes en linux. Estos incluyen avr-gcc, avr-binutils y avr-libc. Esto es lo que se conoce como la cadena de herramientas.

Una vez que haya creado un archivo hexadecimal y desee colocarlo en su chip, puede usar avrdude.

Todos estos están disponibles de forma libre y gratuita en Linux y no es demasiado difícil de configurar para trabajar juntos.

LadyAda tiene un sólido paso a paso tutorial sobre todo el proceso.

    
respondido por el NickHalden
0

Para desarrollar AVR en Ubuntu, solo hay unos pocos pasos:

Instalar la cadena de herramientas :

sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc avrdude

Crea un código Hello world y guarda:

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

Descargue Makefile tempelate y guárdelo en el mismo directorio donde guardó el archivo hello_world.c .

Editar Makefile :

# 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

Construye el objetivo

Simplemente escribe make en la consola y pulsa enter.

Sube las instrucciones en AVR usando avrdude

Usa el comando en la consola como: (asumió que el programador que está utilizando es usbasp, google o consulte el manual para otras opciones)

$avrdude -c m16 -p usbasp -U flash:w:hello_world.hex
    
respondido por el mrUnfused

Lea otras preguntas en las etiquetas