There seems to be a fair bit of confusion in- and outside the Arduino world, and it’s spilling over to JeeNodes …
I’d like to go through some terms and buzzwords to try and clarify how to get your Arduino or JeeNode to do the thing you want it to do. I’m going to assume that you are familiar with the process of writing software (“code”), compiling it, and running it – at least on a Windows, Mac, or Linux computer (let’s call them all PC’s for now). With software for the ATmega, there are two approaches, depending on whether you use the Arduino IDE or not:
Both lead to the same result: a “hex” file with code that needs to be transferred from the PC to the ATmega.
The step which can be puzzling when starting out with physical computing and embedded hardware is how to get things across from your PC to that little Arduino or Arduino-like system you’re holding in your hand. And vice versa, since we often want to get results back or see some confirmation that things are working properly.
The confusion comes from the different conceptual levels involved, and things like:
- do you mean how to connnect? – plug in a USB cable
- do you mean how does the ATmega change its own code? – through a boot loader
- do you mean via ISP (In System Programming)? – no, that’s normally not needed
- do you mean via FTDI? – yes, that’s the name of the chip which is hooked up to USB
- isn’t FTDI a connector? – yeah, that too, sort of… i.e. a 6-pin convention
- isn’t a power + serial cable enough? – no, resets also play a key role
- do I have to use the Arduino IDE? – no, you can also use a program called “avrdude”
- what’s avrdude? – a program which can upload to a boot loader or an ISP programmer
- do I need an ISP progranmmer? – nope, the boot loader does essentially the same thing
- so why not just get rid of ISP? – because you need ISP to install the boot loader
Confused? Welcome to the club…
In case you’re wondering… the process is called “uploading” because the PC initiates this as outbound transfer:
To get your code (“sketch” in Arduino-speak) into an ATmega, you need three things, working together to make uploading happen under all possible conditions:
An electrical connection – to power the ATmega, to communicate with it, and to restart the ATmega when it is stuck or busy doing something else.
A common language / protocol – the communication must be understood by both sides, i.e. PC and ATmega.
Software on both sides of the connection – Sending something when the other side isn’t listening, or listening while no-one is sending will not have the desired outcome.
Let’s go through each of these separately.
1. An electrical connection
There are several ways to make the connection. With an Arduino, or any similar board which has a USB connector, you can simply plug in the USB cable:
Some boards use a separate USB interface (“FTDI adapter”), allowing reuse of that interface for multiple boards:
The end effect is the same: a connection which powers the ATmega and allows communicating with it using a simple serial protocol. There’s also a trick in this hookup to let the PC reset the ATmega whenever it wants.
2. A common language / protocol
Ah, now it gets interesting. First thing to note is that there is no single common language / protocol!
That’s right. It all depends on what you want to do. Here we want to upload code from the PC to the ATmega. That requires exchanging “ISP commands” over the connection. But once uploading is done, we really want to reuse the connection as a regular two-way serial link.
The way it works is that the PC will reset the ATmega just before uploading new code. This activates a “boot loader” on the ATmega. Now both sides will be in sync (briefly) so they can exchange the necessary information to make an upload happen. IOW, right after reset the protocol is “ISP commands”. Once the upload is done, the connection can be reused for any protocol you like – as determined by the code that was uploaded.
3. Software on both sides of the connection
Back to the software now. We need to send ISP commands over the connection.
As you may have guessed, that’s exactly what the Arduino boot loader on the ATmega
understands. When reset, the boot loader in the ATmega gets control. It waits and listens for incoming STK500 ISP commands. If none come in within a second or so, it relinquishes control to whatever was previously uploaded to the ATmega.
On the PC side, we need software which resets the ATmega and then immediately sends all the ISP commands needed to transfer and program the contents of a hex file.
This is what “avrdude” does. You can either use it implicitly from the Arduino IDE by starting an “Upload” from the menu, or you can launch it manually from the command line – avrdude needs a few options to tell it where the USB port is, what baudrate to use, the type of ATmega, the protocol to use (i.e. STK500), etc.
The above describes the different pieces and concepts involved in getting code into an ATmega. The beauty of it is that once it works, it really works well. Supplying power, uploading, communication, control, debugging … all with one simple USB cable. You only need to go back a few years to appreciate just how much this approach simplifies embedded development.
But there’s one important detail: the ATmega has to have a functioning boot loader. Placing a boot loader into an ATmega is a bit more complicated (and involves other things such as “fuses”). It’s a chicken-and-egg problem.
This is where the ISP programmer comes in. An ISP programmer is a fairly simple piece of hardware. In fact, you can make your own, as I’ve described in several posts on this weblog. See this and this post for some quick solutions which require nothing more than a working Arduino or JeeNode.
The good news, is that you usually don’t have to worry about installing the boot loader – it’s all done for you. Once. For the mechanism described above, you’ll never need an ISP programmer.
Some people actually prefer to use the ISP technique for uploading their sketches. In fact, sometimes you have no choice, i.e. when you need the serial port at all times, or when you can’t spare the 1..4 Kb required by the boot loader code, or when working with ATtiny chips which don’t support bootloaders.
In thoses cases, you’ll need a setup with an ISP programmer. But for most people doodling around with ATmega’s and the Arduino IDE, the above boot loader mechanism is usually very convenient and the easiest to get going.
Either way, it helps to understand the process. I hope the above was helpful in that direction.