I am planning to develop ethernet bootloader. So I wanted to modify the existing DFU Bootloader program. I want to delete the already existing bootloader on micro-controller flash and put my own bootloader.
Currently my MCU is AT32UC3A0512. I am using AVR Dragon and AVR One debugger/programmer. Is it possible to reprogram the bootloader region with AVR Dragon or AVR One? or I must need to have MKII debugger?
It is absolutely possible to reprogram the boot loader with AVR One and I would guess that
the AVR Dragon works too (if you can use it to program the AVR32s generally).
The boot loader (if present) resides in the beginning of internal flash and is written as any other bit of code.
Related
I am working on the ATMEL ATtiny1616 micro-controller.
I am looking for a (Linux C/Phython based) serial bootloader application to program the ATtiny1616.
Will you please help me to know, Where I can get the source code for it?
I'm going to use pyupdi for these new tinies (ATtiny814 which has the same programming protocol).
For now, pyupdi
Can read/write fuses
Can write FLASH
Can not read/verify FLASH
Can not read/write EEPROM
UPDI is another way to program the ATtiny1616. But as I said, I would like to program the ATtiny1616 using the Serial Bootloader Application.
I have found a reference link on the site of the microchip. Serial Bootloader Application
& this application will work for me.
How to set AVR to emulate EEPROM over SPI?
I would like to boot my TI's Piccolo from Atmel AVR AR32UV3A0512 via SPI port.
Piccolo has a feature that allows it to boot through SPI connected EEPROM.
TI documentation specifies that if the SPI is connecting to device other than EEPROM, the device should emulate EEPROM.
Does anyone know what is needed to do to make AR32UV3A0512 emulate EEPROM?
Any hint or link towards proper documentation will be appreciated.
I have not found any useful information in AVR documentation.
You need to program your Atmel AVR so that it transfers code to the Piccolo's internal memory using the appropriate data transfer flow. The data transfer flow depends on the chosen emulation boot mode. Keep in mind that you are not restricted to SPI emulation boot mode. You can use any of the following:
SPI
I2C
SCI
Parallel GPIO
SPI boot mode will not necessarily be the easiest one to implement. Anyways, the whole rigamarole comes down to two steps:
Step 1 (easy step): Choose an emulation boot mode, and configure the Piccolo accordingly, as described in the Bootloader Modes section of this doc: http://www.ti.com/lit/ug/sprugo0b/sprugo0b.pdf
Step 2 (hard step): Depending on the emulation boot mode you chose in step 1, you will need to program your Atmel AVR microcontroller to follow the respective data transfer flow. For example, if you chose SPI mode, then you must program your Atmel AVR to follow the transfer flow described in the SPI_Boot Function section of the above doc.
I have just finished a project using an Arduino Micro dev board and want to move to a standalone ATmega32.
I need to run this at 3.3V and I dont want to go down the overclocking road so I have an 8MHz crystal to put on it.
I still want to be able to upload sketches via USB and the Arduino compiler so I gather I need to burn a different bootloader.
For this purpose I have purchased a USBASP programmer.
I am slightly unsure of what to do next - everything I can find on the topic either relates to the ATmega328 or to burning bootloaders using another Arduino.
I have worked out that I need to modify boards.txt to point to the correct bootloader....but which is the correct bootloader for ATmega32 at 8Mhz?
Also do I need to change any fuses?
Thanks
I think you're a bit out of luck.
The ATmega doesn't have hardware USB, so I assume the bootloader is using V-USB to implement USB. That stack, being a software implementation of USB's high-speed signalling, requires at least a 12 MHz clock (higher is better).
I don't think you can run V-USB using only the internal 8 MHz oscillator.
According to the OP comments the micro is indeed an Atmega32u4, not an Atmega32 (#OP: please fix the question to match this).
Since it has onboard USB, you can use a pre-existing bootloader like the sparkfun one:
https://www.sparkfun.com/products/12587
Here you have the link to one of their products, the Arduino pro micro 3.3V (which runs at 8MHz). You can add the sparkfun arduino boards repository to your IDE and then just use the board specification for their pro micro 3.3V do upload the correct bootloader and to program it through the USB just like the usual Arduino Micro.
Good evening ..
I'm new in the microcontroller ..
I have studied a course on "pic 16" and As I knew the pic16 needs an external device to burn hex file in rom .
Now I want to study the pic24 And I found something called usb in pic24 ..
Can I burn the hex file without an external device via a usb ?? Or this is another term has not related to burning hex file ??
Is there a way to burn the file without an additional device ??
And also in the pic32 Are there any types of it can be directly connected without the use kit3 ??
I do not want to buy kit3 :\
Is the kit3 can Programming all kinds pic microcontroller (16,24,32) ??
Sorry for extension
and Thank you very much
The PIC32 starter kits have a debugger/programmer built in. Otherwise there is no way.
Yes, you can burn a hex file without an external device via USB. The term to look for is “Bootloader”. Many Microchip devices can allocate and protect a section of memory for bootload firmware providing the means to self-program.
If you’re buying a demo board with a bootloader pre-installed (and as long as you don’t over-write the bootloader) you can upload hexfiles and run them without an external programmer. But if you build your own board you’ll need a programmer at least once to load the bootload code.
And yes, the PICkit 3 can be used to program a wide variety of Microchip devices. The document Device Support.htm in the release notes of MPLAB X has a matrix of devices and programmers.
unfortunately i've never used pic24 family, but if you're going to try pic32 try to take a look here:
pic32-avrdude-bootloader
It works with avrdude, the same bootloader used by Arduino boards and it's not much hard to use properly. I don't know if there's a way to use also serial monitor via usb, but if you debug with mplabx you don't need it
Ciao!
I am having a question regarding Uboot. I am looking forward to make a ARM based Board.
Now i want to to burn Uboot to NAND flash attached to my controller. How can i perform this operation ?
http://www.stlinux.com/u-boot/target-install
What i got from this link is that -- STx7111 Mboard - have some serial port which is capable to communicate with GDB.
And from GDB we use to burn following file u-boot. Is this file burned in RAM or NAND flash by gdb ?
Then execution moves to this u-boot program "u-boot". Now this program "u-boot" will burn the actual u-boot.bin onto the NAND flash.
Do every controller have some serial port which is capable to communicate with GDB ?
Do every controller follow this approach to burn uboot bootloader into its NAND flash ?
Please suggest.
What i got from this link is that -- STx7111 Mboard - have some serial port which is capable to communicate with GDB. And from GDB we use to burn following file u-boot. Is this file burned in RAM or NAND flash by gdb ?
No, you did not read that article accurately.
GDB is merely used as the interface to the JTAG.
This first step is to load an executable (a copy of U-Boot) into RAM.
Do every controller have some serial port which is capable to communicate with GDB ?
Do every controller follow this approach to burn uboot bootloader into its NAND flash ?
You should avoid making (or trying to make) sweeping generalizations (in this and your other postings).
The features and capabilities of microcontrollers, microprocessors and SoCs ("controllers" is something else) is so broad that very few generalization can be made. Rarely is there only "one way" to perform these procedures.
In order the write a copy of U-Boot (or any file image) to NAND flash, there are two steps:
transfer the image file from the host PC (or some storage device) into local memory;
erase the NAND flash blocks, and then write the image file to NAND flash with ECC if required and cognizant of bad blocks.
These are not trivial steps, so a capable utility is needed. There are at least three approaches:
The microcontroller can be configured (via input pins) to a "receive and write an image file" mode on power-up. A hardcoded program in ROM will load the image and write it to the integrated flash.
The SoC ROM has a bootloader that has capabilities to communicate with a host PC over RS232 or USB, and can perform as the client side of a proprietary utility program. On the host PC you would run the server side of this utility program. This scheme would allow transferring files and reading & writing the target's memories. Atmel's SAM-BA utility fits into this category.
Use an open-source utility, such as U-Boot, that is configurable and extensible to support the external NAND flash and any other memory types on your board, and also has file transfer capabilities. The console for U-Boot is typically a UART/USART serial port, but can be configured to use a USB-to-RS232 adapter.
In the case of using a program like U-Boot to install programs in NAND, a chicken versus egg situation arises: how to get this program loaded in the first place? The two common approaches are:
a. Install the utility (i.e. U-Boot) on a SDcard with any required bootloader, and then boot the SoC from the SDcard. This assumes that the SoC has this booting capability, but this scheme requires the least operator skill.
b. Load the utility (i.e. U-Boot) using JTAG, such as Segger J-Link, which will allow you to transfer the image file to RAM (assuming that RAM has been properly initialized if necessary) and then start its execution. The J-Link can be interfaced using its own JLINK program or GDB.
Once U-Boot is resident and executing, you have all of its capabilities available. U-Boot cannot write itself to NAND flash, so you have to load another copy of U-Boot in order to write it to NAND (or any other type of) flash.
If you load something using GDB, then it must be loaded in RAM..
Using gdb you will run that binary (u-boot), and the binary will give you the u-boot prompt, which you use to burn another image (it can be u-boot.img (configured for running from FLASH), linux kernel image, or any other image) into the flash (it can be NOR or NAND)..