I am planning a project using three different uC: ATSAMC21N18, PIC18F4548 and a motor driver (not yet chosen). In total there will be 20-30 PCBs many of them are the same kind with the same firmware. For the main communication between the µC I have chosen CAN.
Usually, I flash the uC using a PICKIT with MPLab but with constant revisions and that many uC I am wondering if it is possible to flash the individual uC using CAN?
From my experience with the Arduino, it has a bootloader that enables the UART communication.
Can I include a bootloader that enables CAN on my chips? Do I have to write them myself? Are there existing tools to enable some functionality and write a bootloader to the chip?
I am unable to find literature on this topic.
Related
Coming from the world of MCUs, I create bootloaders so that customers can update the firmware.
How is this done with FPGAs and CPLD.
For FPGA:
Since the firmware is stored in external flash memory, does the FPGA image just write to it's external flash and then restart? But what happens if the new file is corrupt or the connection is removed while updating? Is there a way to make a default backup? In MCUs, the bootloader is never overwritten so the application can mess up anytime and the bootloader will still work.
Is there a separate dedicated non-volatile memory portion that is not re-configured on power up that you can load a bootloader in?
For CPLD:
Since the image is stored internally, do they have a way to configure themselves? How would one make a bootloader for a CPLD?
Other thoughts:
Maybe you can put an FTDI chip of some sort with GPIO that you can control from a PC app via USB. This way you can bitbang an SPI to load in a new image on the external flash? Anybody do that? That way the FPGA image can be corrupt or missing and still will be able to load a new image.
Note that i'm assuming that the FPGA or CPLD is alone on a board. Meaning there is not an MCU on the board to do all this.
Any insight as to how the industry achieves this task would be great.
FPGAs
There is no single common answer to this question. It is different for different FPGAs, and for different types of applications.
Some FPGAs have the capability to have two bitstreams in the external flash, so that if one bitstream is corrupted it will fallback to the second bitstream.
You must check the datasheet for your exact FPGA to find out if it has this kind of recovery feature, and exactly how it works.
Another common way to do it is to have a MCU sitting beside the FPGA, and let the MCU manage the bitstream update of the FPGA. Make it the MCUs responsibility to ensure there is a valid bitstream in the external flash.
Or, you can skip the external flash completely and make the MCU send the bitstream to the FPGA at every startup.
Some FPGAs, like the Xilinx ZYNQ, has a built-in hard processor. That processor can boot independent of the FPGA, so you write a normal bootloader for that processor, and make it the processors responsibility to update the FPGA bitstream.
If your application is a USB peripheral, then one nice way of handling it is to skip the flash memory, and make the USB driver on the PC load the bitstream to the FPGA at every startup.
Bitbanging it via a FTDIchip GPIO is not recommended as it would take a very long time. FTDIchip and other manufactuers have hardware support for both SPI and JTAG. With these you can do it quickly at each startup, with no bitbanging.
CPLDs
Typically no built-in recovery mechanism. (There may be exceptions)
CPLDs are very basic devices. If you want bitstream update capability, then it typically has to be done by an external MCU.
Normally you do not implement bitstream update function for CPLDs. You make your design error-free from the start instead.
Is there a way to make a default backup?
There is Intel MAX 10 family of fpga, it has on-chip configuration flash memory, and supports dual configuration. If anything wrong happens with one config, the other is still there and will be used as a fallback image.
But that's probably an exception, and not a typical case in fpga world.
In case the FPGA does not support dual configuration, and you are programming the FPGA directly ( not through a microcontroller), and somehow the new bitfile or the connection gets messed up, you have to program it again from scratch.
However, in Spartan 6, there are two ways to load the program directly to the FPGA :
1. This one is relatively fast and happens withing a couple of minutes. But if the setup gets messed up you have to start from scratch. This method is mostly used when you are doing minor modification (specially time related fine tuning) as the loading of the bitfile doesn't take up much time.
2. There's an external memory on which you load the program. The bitfile loaded on this memory remains unless you decide to explicitly re-write it. Loading the bitfile on this memory takes way more time (depending on the complexity of the code), but it stays there and you can load this code onto the FPGA.
I have a usb modem with MT6272M chipset, can I take out its chipset and program it? I know that some ICs are programmable and some are not but I really want to program an IC without investing on arduino, rhasberry pi, or intel gallileo so trying to recycle electronic wastes.
Most of the ICs in the electronic waste are not programmable. Because they are specifically designed to do one job efficiently and that program is bound to the IC.
What you are searching is Programmable Integrated Circuit or Micro-controller chips. These are specifically designed to re-program again and again.
Anyhow if you find a specific Integrated Circuit from the waste,
First and most importantly, find its data-sheet (mostly available
in their manufacturer's website for free).
check whether is it a Programmable Integrated Circuit.
if yes, what is the hardware requirement to program it and build the
hardware circuit
write the program according to the specific requirements using
compatible libraries.
connect to the PC
Find the correct boot loader and upload it to the IC.
upload the program, which you have written, to the Programmable Integrated Circuit.
Test it
As you can see, you will need to build different hardware for different Programmable Integrated Circuit. So it is cheaper for you to buy arduino or raspberry circuit board. Then you can reprogram more chips using same board again and again plus the help of the community and the thousands of libraries.
Edit
If it is not mentioned in the datasheet whether you can program it or not , most probably it can't reprogram.
And other thing is that the main function of a modem is signal processing. For example, old cable modems are converting analog signals into digital signals. So they are not designed to reprogram or to do logical calculations. With my personal experience, you better start with a simple micro-controller and once you know the basics, you can go for higher level. Anyway I admire your idea to recycle the waste ICs.
I have a PCIe generated core / endpoint with the xilinx core generator tool for a spartan6 fpga on a development board which I have modified a bit to enable MSI and send these every couple of seconds.
Also, I did a simple C kernel module on my linux desktop in which I plugged in the development board. This registers device, allocates memory, enables bus mastership for device and handles the interrupts etc.
What I want to do now is some DMA transfer from the board to the PC, and then will send an interrupt when finished, so that the cpu can go and read it. I'm not a Verilog expert, and the code I have doesn't seem to be capable of any DMA functions.
I couldn't find any relevant information online, so this is my last hope.
Original text from comment above:
Have you implemented a transaction layer above the generated PCIe core? Why don't you use a free PCIe core if your HDL skills are not so high? PCIe is a very big thing....
Yes, the Xilinx IPCore generator adds a very simple PIO interface ontop of the link layer to handle simple PIO transactioons. Note: PIO transaction are outdated and not allowed for new devices.
Currently I know two rather good IPCores:
XILLYBUS
free educational license
create the IPCore for your FPGA device online and download a netlist
free linux and windows drivers (the linux driver will be included in the standard kernel)
8-bit and 32-bit FIFO interface and a memory interface
linux-driver mapps FPGA to /dev/xillybus_read /dev/xillybus_write devices
RIFFA
I'm not sure if this core is still maintained
free driver
it has a strange interface with up to 12 FIFO channels
free HDL sources
All these cores require the Xilinx Core Generator to generate a PCIe core for your device/board. The core itself provides transaction handling, ...
I'm new to fpga programming, and I'm wondering how to make my fpga design distributable. Here's the scenario I have in mind. I have a network of computers, each deployed with an fpga based peripheral. I want to update the fpga design on the peripherals periodically. How do I accomplish this without spending a fortune on software licenses?
I have a small dev kit for an fpga that shipped with an executable to load example design files (it was an Altera fpga FYI). Does anyone know how I would create such an executable?
Some specifics:
My fpgas are Xilinx Spartan 6Es. I'm using Xilinx ISE for fpga development. The host computers are running debian linux.
Thanks for any and all advice!
If youre dealing with Altera: one computer would have the software tools and licenses needed to synthesize the project. Assuming all the FPGAs are the same model on each station/node, Quartus will generate an .sof file which you can copy and open from station to station. All you would need to do is download the Altera programmer tool (I believe you can download it separately from Quartus II) on each station which is free. Then upload the .sof to the board using the programmer, where you can permanently store it on the fpga prom using a technique similar to the following:
https://m.youtube.com/watch?v=ZrMe8JS7Ktk
However if you have Xilinx and Altera mix, Xilinx has .bit/xdl files, and uses another tool (impact) to upload their bitstreams. They can't be converted to and from bit and sof. So it's recommended that you probably stick to one make (Xilinx or Altera) and model based on your plans.
It looks like what you are looking for is how to make your FPGA's field upgradable. Assuming your FPGA is loading from an external memory such as an SPI flash chip, then you need to modify your design so that it is capable of writing to the SPI chip (or whatever) itself. This is most simply done by putting a register in your design which maps to the individual pins on the flash chip, and then "bit bang" the register from a connected computer. Assuming your FPGAs feed data into your own software running on the computer, then you would modify this software to have the functionality of manipulating this register to reflash the flash device. Obviously, if this goes wrong you bricked your device until it can be flashed again with the JTAG, but it provides a way for all the devices to get updated in the systems they operate without needing to buy a JTAG cable for every single station.
If you have Ethernet on your board you can use the remote programming tool from fpga-cores.
Then you can remote login to the network and program the FPGAs or mail the new config file to you customer and they run the programmer. This is how we remotely updates our boards.
Spartan 6 is supported. As a bonus you can also do some remote debugging with the remote logic analyzer.
Everything is free for non commercial use.
My company is trying to build a pcb with an obsolete xilinx fpga (XC3042A) which is part of the XC3000 series chips. Does anyone have any experience programming the data to the chip? I'm looking for what software, hardware, etc. people have used.
I have programmed old Xilinx chips (XC4010XL) using a custom built interface to the ISA bus.
I used Turbo-C on a DOS box and a home-made ISA card with '245 (bidir transceiver) and a 74LS74 (dual flip flop D) for strobe signals on a slave parallel configuration.
It is not difficult to implement the same using a parallel port, for instance.
You should be able to find the programming specs from the Xilinx website. They provide documentation on the different methods used in programming their FPGA. It should be in their AppNotes. They have several modes - typically slave serial or select map (parallel). That means some sort of SPI flash, or parallel flash, or JTAG.
If you look around, you may find schematics for a DIY programming cable too! You can also interface a small micro, say a 8-bit PIC to handle the programming specs while you design your own custom interface to it or interface it to a SD card or something else.
The current Xilinx tools and cables will program old parts.
The XC3000 series does not use the JTAG interface, so you can not use the Xilinx programmer to download your configuration.
You can do so by either using an external EPROM or an embedded processor to download the code.
Take a look at this applications note from Xilinx:
http://www.xilinx.com/support/documentation/application_notes/xapp090.pdf
For daisy chain:
http://www.xilinx.com/support/documentation/application_notes/xapp091.pdf
It describes the data format as well as signal info for downloading the configuration file to the FPGA.
You can use older version of the Xilinx programmer from their web site and configure the devices, I believe the last version of the xilinx supporting the 3000 series was version 8 but I am not sure.
Check out FTDI. You might be able to convince them to go with some updated hardware. It's currently $150 CAD for USB + FPGA, and $80 CAD extra if you bundle it with a Manual. Plus shipping.
It even supports the free web kit available from the Xilinx website.