Many places sell ATmega chips with the Arduino bootloader pre-loaded. To actually burn the bootloader yourself, you do need an external programmer.  Fear not though – in a previous post, I discovered how to use an Arduino board (together with the mega-isp project) as a make-shift external programmer -> see this post for details.

Putting the Boot-in..

The version of the bootloader that you need to use, depends on the type of hardware that you intend to program.  The Arduino IDE supplies versions of the bootloader for a range of ATmega / Arduino combinations .. see the ‘./hardware/bootloaders/’ sub-directory within your arduino installation directory for more info.

There are also custom versions of the bootloader created by third-parties -> ladyada has produced some bootloader hacks and another unified version of the bootloader can be found here.

Atmel's ATmega8 microprocessor

Once you’ve decided which bootloader you want to use, you can use AVRdude to upload the code.

Steps Required to Burn the Bootloader

1. Unlock the bootloader segment
2. Upload the bootloader code
3. Relock the bootloader segment

Step 1: Unlock

First of all, it’s a good idea to make sure that you can communicate with your programmer successfully. To do so, you can issue a simple command via AVRdude, which will give you a nice ‘all clear’ status message as long as everything is set-up correctly.

The parameters that you use might vary according to your system settings and the external programmer you’re using.

avrdude -p m8 -P /dev/ttyUSB0 -c avrisp -b 19200

Briefly, ‘-p’ defines the chip I’m programming, ‘-P’ is the port that my programmer is connected to, ‘-c’ is the programmer type and the baud-rate is specified by ‘-b’.  You can run ‘avrdude –help’ to discover the full range of options.

This returned:

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.13s

avrdude: Device signature = 0x1e9307

avrdude: safemode: Fuses OK

avrdude done.  Thank you.

.. which is good.  This means that the stage is set for programming and we can begin to set the fuses to unlock the bootloader segment of the AVRdude.

Each ATmega chip has a number of Fuses which can be set.  I think of the fuses as configuration bits -> they define the way that the chip is going to function on a very low level.  I’ve been using a fuse-calculator to simplify the process, and I’d suggest that you do the same.

avrdude -p m8 -P /dev/ttyUSB0 -c avrisp -b 19200 -e -U lock:w:0x3F:m -U lfuse:w:0xc4:m -U hfuse:w:0xd9:m

The ‘-U lock:w:0×3F:m’ performs the unlock and ‘-U lfuse:w:0xc4:m -U hfuse:w:0xd9:m’ is used to set the chip’s low and high fuse values.

I want to use this particular ATmega chip as a minimal Arduino, so I’ve set the fuses to instruct the chip to use it’s own internal 8 MHz oscillator rather than an external crystal oscillator.

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.13s

avrdude: Device signature = 0x1e9307
avrdude: erasing chip
avrdude: reading input file "0xc4"
avrdude: writing lfuse (1 bytes):

Writing | ################################################## | 100% 0.04s

avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0xc4:
avrdude: load data lfuse data from input file 0xc4:
avrdude: input file 0xc4 contains 1 bytes
avrdude: reading on-chip lfuse data:

Reading | ################################################## | 100% 0.04s

avrdude: verifying ...
avrdude: 1 bytes of lfuse verified
avrdude: reading input file "0xd9"
avrdude: writing hfuse (1 bytes):

Writing | ################################################## | 100% 0.04s

avrdude: 1 bytes of hfuse written
avrdude: verifying hfuse memory against 0xd9:
avrdude: load data hfuse data from input file 0xd9:
avrdude: input file 0xd9 contains 1 bytes
avrdude: reading on-chip hfuse data:

Reading | ################################################## | 100% 0.04s

avrdude: verifying ...
avrdude: 1 bytes of hfuse verified

avrdude: safemode: Fuses OK

avrdude done.  Thank you.

Step 2: The Burn

The chip has now been set up – the next stage involves uploading the new firmware.

avrdude -p m8 -P /dev/ttyUSB0 -c avrisp -b 19200 -D -U flash:w:/opt/arduino/hardware/bootloaders/atmega8/ATmegaBOOT.hex

… which produces …

Step 3: Re-lock

The final stage involves re-setting the lock fuse:

avrdude -p m8 -P /dev/ttyUSB0 -c avrisp -b 19200 -U lock:w:0x0F:m

And that’s it!

Kenwood CS-1575a Oscilloscope

I haven’t had any luck yet – so far I managed to source a service manual for a Trio CS-1560a.

If anyone has a copy of the manual for the CS-1575a (that they’re willing to share), please get in contact.

To be honest though, I’m a bit worried about killing myself via the high voltage on the board.  Whatever I do – I will proceed with caution!

I’ve read that it’s possible the capacitors might have dried out – at first I thought the gunk emanating from the base of the larger electrolytic capacitors was a sign of this – but on closer inspection I found it was just glue, which was disappointing, as changing the caps seemed like it was something I’d be capable of carrying out.

Any (and all) suggestions on how to proceed will be gratefully received.

Some of the capacitors used by the 'scopes power circuits.

The effects of high voltage on the PCB...

Stripboard design for the +5V DC power regulator circuit (copper side up)

There are lots of different schematics available to produce a 5V dc regulated current, after searching around I chose one at http://stuff.nekhbet.ro/2006/06/18/how-to-build-a-5v-regulator-using-78l05-7805.html.  I used this as the basis for my design, but I also added a quick blow fuse to limit the amount of current that can be drawn – the 7805 regulator IC the circuit uses has a maximum rating of 1A.

The circuit was drawn up in VeeCAD (which is good for designing stripboard circuits.)

The finished product fits on a 9×25 piece of strip-board and produces a nice steady 5 volts from my 12V power adapter.

Parts List

9×25 stripboard (veroboard)
7805 voltage regulator
a ‘to220′ heatsink
10uF 25V electrolytic capacitor
220uF 25V electrolytic capacitor
fuse holder + a quick blow fuse
1n4007 rectifier diode
some terminal blocks – to make connecting to the regulator easier

The finished board

Programming the ATmega

It’s possible to program Atmel microprocessors using an Arduino board and the megaISP project.  This post documents my attempt.

Before starting of got hold of a copy of the datasheet for the ATmega8 (http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf)

Step 1: Upload mega-isp to Arduino

I downloaded the mega-isp source, and uploaded it to my Arduino board.  The source can be found at google code (http://code.google.com/p/mega-isp/).

Step 2: Set up breadboard

mega-isp: programming an atmega8 with arduino

First of all, I set up the breadboard according the advice given at http://www.uchobby.com/index.php/2007/11/04/arduino-avr-in-system-programmer-isp/

The article mentions something called a bypass capacitor .. which is something I hadn’t come across before.  Basically, it’s a small capacitor that’s used to smooth out small changes in voltage – and should be used whenever you set up a microprocessor in a circuit.  I learnt about them here (http://www.seattlerobotics.org/Encoder/jun97/basics.html)

Because I’m trying to program an ATmega8 (and not the Tiny18 mentioned in the  article) I needed to adjust the pins.  I also added another LED to signal when megaisp is actually programming (which was mentioned in the Arduino source code).

ATmega8/168/328p pinout diagram

The only pins that I needed to consider were:

Step 3: Connecting via AVRdude

AVRdude is an open-source utility for programming Atmel AVR Microcontrollers.

Running the following from a terminal

avrdude -p atmega8 -c avrisp -P /dev/ttyUSB0 -b 19200

produced

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.13s

avrdude: Device signature = 0x1e9307

avrdude: safemode: Fuses OK

avrdude done.  Thank you.

Which indicated that AVRdude had communicated  with the mega-isp successfully.

I spent an evening last week constructing a simple LED matrix.  I’ve been experimenting with Arduino for a while, and had previously ordered sample chips from various semiconductor manufacturers.  One sample chip I’d been planning to use for a while is the TLC5940 – which is can be used to drive up to 16 LEDs (daisy-chained it can drive even more).

You might think there’s nothing special sounding about this.. and you’d be right – only the TLC5940 also takes care of something called PWM (pulse width modulation) which allows control over LED brightness.  Not a huge deal, but still pretty neat.

Interfacing the TLC5940 with Arduino

A library has already been produced  (by Alex Leone) to allow the Arduino to be linked with the TLC5940.  More info about the library can be found here.  The datasheet provided by TI is also actually also pretty useful for working out how to create the supporting circuit.

I built the actual circuit using stripboard.  Stripboard (also known as veroboard) is handy for prototyping circuits.  It’s constructed from a board embossed with strips of copper, which have been punctuated with with evenly spaced holes.  The holes are used for placing the various through-hole components that your circuit requires.

I’ve found that stripboard is much like a permanent form of breadboard – another simple tool used for electronics prototyping.

Planning the circuit

Planning a circuit using stripboard requires a degree of ingenuity, due to the limited amount of copper strips available.  Often to makes the most efficient use of space, the copper needs to be broken at various points to route the flow of electricity.  Previously I’d tried to constuct my circuit on paper before putting iron to solder… but this time I’d heard about a program called VeeCAD so I used that.  I really recommend VeeCAD .. it makes the process of visualising how the circuit will work much, much easier.

Fig. 1 - Schematic produced in VeeCAD

Creating the circuit board

After producing the schematic – translating the design onto stripboard was pretty straightforward.  The first step involved marking out where the copper needed to be broken on the board.

When working with stripboard you need to break the flow of electricity in various places in the circuit. Previously I’d used a screwdriver to scrape away the copper, but small bits of metal were occasionally left behind, making short-circuits an eventuality … so this time I decided to use a drill.

Once the holes had been drilled I could go about assembling the rest of the circuit.

My soldering skills are not the best, but they’re slowing improving.  If you’re a beginner like me, I’d suggest you take it slowly and plan as much as possible before hand.  I tried to approach the building of the board in a measured way; tackling wiring first, followed by the IC sockets and the LEDs.  I found that as long as I took one step at a time I was fine.

Once I’d built the board, I checked continuity with a multimeter and loaded the TLC5940 into the IC socket.  After hooking the board up to my Arduino using some jump leads, I was able to load up some of the demo code from the TLC5940 library and watch it in action.

Fig. 2 - Drilled holes to break the flow of electricity in the circuit

Fig. 3 - Board minus the TLC5940, resistors and LEDs

Fig. 4 - Final board

Fig. 5 - Glowing LED Matrix

While the Arduino IDE is suitable for most tasks, there are times when more granular control over the way that the ATMega microprocessor executes instructions is useful. This is where an understanding of Atmel’s assembly language comes in handy.

To be honest, I initially thought that assembly language would involve concepts that my brain would have a lot of difficulty comprehending. Luckily (for me) the process turned out to be far simpler than I initially imagined, and I was able to start using Atmel Assembly last night.  I decided to post my experiences here in case it helps anyone else (and to cement the info in my own mind). Thanks go to a guy called eadthem on #freenode irc for help and guidance.

ATmega8 Microprocessor

AVR Studio

One of the great things about the ATmega chip (which is the family of microprocessor chips at the heart of the Arduino platform) is the range of free development tools which it’s parent company Atmel provides. In this case, I used an IDE called AVR Studio 3.5 (http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2724)

As I run linux, I needed to use wine to run AVR Studio. There wasn’t any problem doing so. Wine decompresses to a folder in the fake ‘windows/temp’ directory…. you simply need to navigate and open ‘~/.wine/drive_c/windows/temp/cdrom/SETUP.EXE’ which runs and completes the installation process. After installation, Atmel Studio was available in application menu (Applications -> Wine -> Programs->Atmel AVR Tools->AVR Studio 3.56).

Obtaining Supporting Documentation

There are various versions of the ATmega chip in production – and each has a different range of capabilities associated with it. I’m using an Atmega8 microprocessor, so it was important that I made sure I had the relevant datasheet at hand and the AVR 8-bit Instruction Set documents. You can find these via the links below.

[*1] (http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf)

[*2] (http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf) <- pages 10 to 14 are especially relevant.

Setting up the Project

Okay, first task was to set-up a new project in AVR Studio.

Project -> new -> [give it a name] / [pick AVR assembler].

This creates a blank project. Next we need a new text file to put our assembly code.

File -> new text file -> [give it the name 'main.asm']

As far as I know, the name isn’t important – what is important is that when you right click this file, ‘assembler entry file’ is ticked. You also need to drag this file into the Assembler Files folder.

Next, right click the route node of the project, and select the ‘project settings’. Change the output file format to ‘intel hex’. This defines the format that will eventually be used by the programmer software / board to upload the code to the microprocessor.

Writing the Code

Okay – next step is to produce the required code.

Open up the text file created a few steps ago.

The very first stage involves setting the start point in your program memory, to hex address 3A. You need to add the following line at the begining of this newly opened file.

.ORG $3A

and then continue to add the following lines of code …

START:	LDI	r16,high(ramend)	;ramend=$025F p7-9
	OUT	sph,r16
	LDI	r16,low(ramend)
	OUT	spl,r16

It’s worth running through some of the conventions here.

• The word preceding the colon, defines a point in the program code which can be called or jumped to later on. This is then used to enable us to call subroutines and create loops.
• The semicolon defines a comment.
• LDI and OUT are instructions … (a full list of the AVR instruction set can be found in the guide linked above [*2], pages 10-14)
• r16 is a register. Registers can be though of as internal variables, which are able to be accessed very quickly by the processor; some are specific and can only be used in certain circumstances, while others are general purpose.
• sph and spl refer to the AVR stack pointer (which is implemented as two 8-bit registers). The stack is a stack of data – you can add (push) data to the stack, or take (pop) data from the stack. Find out more about the stack on page 13 of [*1].
• As far as I can tell ramend, is a device specific constant, which refers to the end of the available data RAM.

For this first program, I simply wanted to make an LED flash. To do this, I need to output a HIGH signal followed by a LOW signal to one of the ports on the ATmega.

I was a bit confused here, thinking that port is another word for pin… it isn’t. The Atmega8 has three ports labelled BCD which are responsible for looking after 23 IO general purpose IO lines/pins.

Port B

looks after 8 I/O lines (PB7-0)

Port C

looks after 7 I/O lines (PC6-0) … but note that PC6 is special case and is different to others, it’s used as an IO pin or reset see page 5 of [*1] for more info.

Port D

looks after 8 I/O lines (PD7-0)

Each port pin consists of three register bits ( DDxn, PORTxn, PINxn). By using a bit of cleverness, all the required physical ports can be accessed through address lookups.

• DDxn bits are accessed at the DDRx I/O address,
• PORTxn bits are accessed at the PORTx I/O address
• PINxn bits are accessed at the PINx I/O address.

(N/B Page 65 of [*1] is a useful overview of how data is output (PORTxn), how pin direction is defined (DDRxn) and where input data is stored/accessed (PINxn), in relation to the available ports and pins.)

Because the ports and IO lines/pins are general purpose, we need to be able to define which are used for input and which are used for output. This is done by setting the port direction.

	LDI r18,0b10000000
	OUT ddrb,r18

LDI is the instruction for ‘load immediate’, OUT is the instruction for ‘out to i/o location’.

Next, we preload registers r18 and r19 with the data that we’ll use to make our LED flash… because we use these values many times, the assignment happens before the main loop.

	LDI r18,0b10000000; set register to pin 7 high
	LDI r19,0b00000000; set register to all pins low

Then we can add the main loop …

MAINLOOP:
	out portb,r18
	out portb,r19
	jmp MAINLOOP

AVR Studio Screenshot

Now, the great thing about AVR Studio – is that you can use it to run your code in a simulator, which allows you to debug the code, while monitoring the status of registers, i/o ports etc..

Before we can simulate the code we need to include a file in our AVR Studio project (which gives device dependant info) at the beginning of the code. (a range of inc files can be found in the ‘Appnotes’ subdirectory of yr AVR Studio install)

.include "m8def.inc"

Then select; Project -> Build and run… You’ll need to select the chip you’re working with. Select View -> ‘registers’ & ‘new io view’… then you can step through yr code with F10 and examine it’s effect.