Go Down

Topic: Solucion: "efuse" memory type not defined for part "ATmega8" (Read 225 times) previous topic - next topic

_NTVG_

Hola a toda la gente de la comunidad, espero que se encuentren muy bien. Hoy me gustaria compartir algo que quizas a mas de uno como yo, que este empezando a programar con Arduino, le pueda llegar a servir.

Viendome en la necesidad de utilizar mi Arduino Uno como programador ISP para grabar mis sketchs en un Atmega8, me encontre con un error el cual no hay casi nada (por no decir nada) de informacion en la red. Este error "efuse" memory type not defined for part "ATmega8" se genera cuando se intenta cargar el bootloader en el Atmega8 a traves del ArduinoISP y es por eso que me gustaria mostrarles como pude solucionar este problema.

Lo primero que debemos hacer es conectar nuestro Arduino Uno a la PC y abrir el IDE-Arduino.
Una vez abierto el IDE, hacemos click en Archivo>Ejemplos>ArduinoISP. Despues de haber seleccionado la opcion ArduinoISP se abrira la siguiente ventana:







Ahora nos vamos a Programa>Subir. Esperamos a que nuestro IDE grabe el archivo que seleccionamos y una vez que nos indique que ya esta subido, hemos convertido nuestro arduino en un programador ISP.
Lo siguiente sera desconectar nuestro Arduino y realizar las conexiones para grabar el bootloader en el Atmega8. En la siguiente imagen les dejo un esquema el cual utilizo para programar mis Atmega8





Una vez realizada la conexion en nuestra protoboard junto con nuestro ArduinoISP. Volvemos a conectarlo a la PC y vamos a seleccionar algunas opciones del menu Herramientas.

Lo primero es hacer click en:
Herramientas>Placa>Arduino NG or older.

Una vez seleccionado, hacemos el segundo paso:
Herramientas>Procesador>Atmega8

y nuestra ultima opcion:
Herramientas>Programador>Arduino As ISP

Por favor, verifiquen tambien en Herramientas>Puerto si se encuentre seleccionado.

Hasta este instante se puede decir que podriamos realizar la carga del bootloader a nuestro Atmega8, pero cuando hacemos click en Herramientas>Quemar Bootloader nos aparace el siguiente error en el IDE:







Para solucionar este problema tenemos que buscar el archivo platform.txt el cual es necesario que lo editen con el Notepad++ o algun otro editor de texto que no sea el de Windows. Yo lo hice desde el Notepad++ y lo pueden descargar desde su web oficial:

https://notepad-plus-plus.org/download/v6.7.9.2.html

La ubicacion de este archivo es la siguiente (En mi caso): C:Program FilesArduinohardwarearduinoavr. Una vez hallado, damos click derecho y edit with Notepad++








_NTVG_

Si ya hemos abierto el archivo en Notepad++, tendremos que buscar la seccion que dice # AVR Uploader/Programmers tools y en esa seccion buscamos la linea -Uefuse: w: {bootloader.extended_fuses}: m  y la ¡ELIMINAMOS!.



Quote
# Arduino AVR Core and platform.
# ------------------------------
#
# For more info:
# https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5---3rd-party-Hardware-specification

name=Arduino AVR Boards
version=1.6.7

# AVR compile variables
# ---------------------

compiler.warning_flags=-w
compiler.warning_flags.none=-w
compiler.warning_flags.default=
compiler.warning_flags.more=-Wall
compiler.warning_flags.all=-Wall -Wextra

# Default "compiler.path" is correct, change only if you want to overidde the initial value
compiler.path={runtime.tools.avr-gcc.path}/bin/
compiler.c.cmd=avr-gcc
compiler.c.flags=-c -g -Os {compiler.warning_flags} -ffunction-sections -fdata-sections -MMD
# -w flag added to avoid printing a wrong warning http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59396
# This is fixed in gcc 4.8.3 and will be removed as soon as we update the toolchain
compiler.c.elf.flags={compiler.warning_flags} -Os -Wl,--gc-sections
compiler.c.elf.cmd=avr-gcc
compiler.S.flags=-c -g -x assembler-with-cpp
compiler.cpp.cmd=avr-g++
compiler.cpp.flags=-c -g -Os {compiler.warning_flags} -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -MMD
compiler.ar.cmd=avr-ar
compiler.ar.flags=rcs
compiler.objcopy.cmd=avr-objcopy
compiler.objcopy.eep.flags=-O ihex -j .eeprom --set-section-flags=.eeprom=alloc,load --no-change-warnings --change-section-lma .eeprom=0
compiler.elf2hex.flags=-O ihex -R .eeprom
compiler.elf2hex.cmd=avr-objcopy
compiler.ldflags=
compiler.size.cmd=avr-size

# This can be overriden in boards.txt
build.extra_flags=

# These can be overridden in platform.local.txt
compiler.c.extra_flags=
compiler.c.elf.extra_flags=
compiler.S.extra_flags=
compiler.cpp.extra_flags=
compiler.ar.extra_flags=
compiler.objcopy.eep.extra_flags=
compiler.elf2hex.extra_flags=

# AVR compile patterns
# --------------------

## Compile c files
recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.c.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.c.extra_flags} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Compile c++ files
recipe.cpp.o.pattern="{compiler.path}{compiler.cpp.cmd}" {compiler.cpp.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.cpp.extra_flags} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Compile S files
recipe.S.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.S.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.S.extra_flags} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Create archives
recipe.ar.pattern="{compiler.path}{compiler.ar.cmd}" {compiler.ar.flags} {compiler.ar.extra_flags} "{build.path}/{archive_file}" "{object_file}"

## Combine gc-sections, archives, and objects
recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} -mmcu={build.mcu} {compiler.c.elf.extra_flags} -o "{build.path}/{build.project_name}.elf" {object_files} "{build.path}/{archive_file}" "-L{build.path}" -lm

## Create output files (.eep and .hex)
recipe.objcopy.eep.pattern="{compiler.path}{compiler.objcopy.cmd}" {compiler.objcopy.eep.flags} {compiler.objcopy.eep.extra_flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.eep"
recipe.objcopy.hex.pattern="{compiler.path}{compiler.elf2hex.cmd}" {compiler.elf2hex.flags} {compiler.elf2hex.extra_flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.hex"

## Save hex
recipe.output.tmp_file={build.project_name}.hex
recipe.output.save_file={build.project_name}.{build.variant}.hex

## Compute size
recipe.size.pattern="{compiler.path}{compiler.size.cmd}" -A "{build.path}/{build.project_name}.elf"
recipe.size.regex=^(?:.text|.data|.bootloader)s+([0-9]+).*
recipe.size.regex.data=^(?:.data|.bss|.noinit)s+([0-9]+).*
recipe.size.regex.eeprom=^(?:.eeprom)s+([0-9]+).*


# AVR Uploader/Programmers tools
# ------------------------------

tools.avrdude.path={runtime.tools.avrdude.path}
tools.avrdude.cmd.path={path}/bin/avrdude
tools.avrdude.config.path={path}/etc/avrdude.conf

tools.avrdude.upload.params.verbose=-v
tools.avrdude.upload.params.quiet=-q -q
tools.avrdude.upload.pattern="{cmd.path}" "-C{config.path}" {upload.verbose} -p{build.mcu} -c{upload.protocol} -P{serial.port} -b{upload.speed} -D "-Uflash:w:{build.path}/{build.project_name}.hex:i"

tools.avrdude.program.params.verbose=-v
tools.avrdude.program.params.quiet=-q -q
tools.avrdude.program.pattern="{cmd.path}" "-C{config.path}" {program.verbose} -p{build.mcu} -c{protocol} {program.extra_params} "-Uflash:w:{build.path}/{build.project_name}.hex:i"

tools.avrdude.erase.params.verbose=-v
tools.avrdude.erase.params.quiet=-q -q
tools.avrdude.erase.pattern="{cmd.path}" "-C{config.path}" {erase.verbose} -p{build.mcu} -c{protocol} {program.extra_params} -e -Ulock:w:{bootloader.unlock_bits}:m -Uefuse: w: {bootloader.extended_fuses}: m -Uhfuse:w:{bootloader.high_fuses}:m -Ulfuse:w:{bootloader.low_fuses}:m

tools.avrdude.bootloader.params.verbose=-v
tools.avrdude.bootloader.params.quiet=-q -q
tools.avrdude.bootloader.pattern="{cmd.path}" "-C{config.path}" {bootloader.verbose} -p{build.mcu} -c{protocol} {program.extra_params} "-Uflash:w:{runtime.platform.path}/bootloaders/{bootloader.file}:i" -Ulock:w:{bootloader.lock_bits}:m


# USB Default Flags
# Default blank usb manufacturer will be filled it at compile time
# - from numeric vendor ID, set to Unknown otherwise
build.usb_manufacturer="Unknown"
build.usb_flags=-DUSB_VID={build.vid} -DUSB_PID={build.pid} '-DUSB_MANUFACTURER={build.usb_manufacturer}' '-DUSB_PRODUCT={build.usb_product}'
Sin editar:

Quote
tools.avrdude.erase.params.verbose=-v
tools.avrdude.erase.params.quiet=-q -q
tools.avrdude.erase.pattern="{cmd.path}" "-C{config.path}" {erase.verbose} -p{build.mcu} -c{protocol} {program.extra_params} -e -Ulock:w:{bootloader.unlock_bits}:m -Uefuse: w: {bootloader.extended_fuses}: m -Uhfuse:w:{bootloader.high_fuses}:m -Ulfuse:w:{bootloader.low_fuses}:m
Archivo una vez editado:

Quote
tools.avrdude.erase.params.verbose=-v
tools.avrdude.erase.params.quiet=-q -q
tools.avrdude.erase.pattern="{cmd.path}" "-C{config.path}" {erase.verbose} -p{build.mcu} -c{protocol} {program.extra_params} -e -Ulock:w:{bootloader.unlock_bits}:m -Uhfuse:w:{bootloader.high_fuses}:m -Ulfuse:w:{bootloader.low_fuses}:m
Una vez eliminada esa parte, guardamos el archivo y cerramos Notepad++. Ahora si podremos reintentar grabar el bootloader en nuestro Atmega8, asi que nos dirigimos nuevamente a Herramientas>Quemar Bootloader y esperamos a que el IDE lo cargue, el led indicador debe parpadear y despues quedar fijo unos segundos hasta apagarse. Una vez apagado quiere decir que ya esta grabado.





Una vez grabado, nuestro Atemga8 ya se encuentra listo para cargar los skectchs que realicemos!
Espero que les sirva de ayuda para todos los que quieran realizar distintos proyecto y que si tienen alguna duda la podamos debatir por este medio. Saludo muy grande a todos!

Gustavo

rigelinorion

I think this way is more versatile
https://github.com/arduino/Arduino/issues/2541

Go Up