Harald's Random Stuff

I used to use the FT245R chip to program my AVRs but I was looking for something more comfortable. Like the Bus Pirate. Works great. No special configuration needed for avrdude. Simply say it’s using now a Bus Pirate and which USB port it shows at.

Update: It’s too slow, so I flashed the STK500v2 firmware, which means I tell avrdude I got an STK500v2. While it loses all the features of the real Bus Pirate, it’s magnitudes faster (and I have the AVR extended patches and updated the Bus Pirate firmware to 6.1, but it was still too slow for larger programs).

EAGLE is probably the most common software used for PCB creation. Many years ago I saw a professional using it on DOS. Looked good and not simple at all. Back then creating PCBs was quite expensive too, so I never thought about making them myself. For most of my purposes a breadboard works well enough. For a bit more permanent things I have those which is just the same layout and connections, but for soldering.

For a bit more complex things though the problems of breadboards become an issue:

Distressing as it may sound, solderless breadboards can be very flakey, especially as they age. If you’re having problems with your circuit, it could be that the little metal clips on the inside aren’t working well. Try poking it with your finger, or moving it to a different section.

It’s still great for small tests, but for permanent things, expect a  low reliability.

Anyway, for a large clock using those quite large 16 segment LEDs, breadboards don’t work well: a single digit is too large and needs 2 breadboards, with some gap between. The next digit will have a lot of gap between the previous digit. All in all, not optimal.

In the end, and because that clock will be permanent, some soldering is needed. Soldering without PCB is not fun: lots of burned fingers, a messy layout and errors are my experiences. A PCB would be sooo much nicer.

Enter the world of low-cost PCB manufacturing. The low price is done by merging small PCBs onto one larger one, which splits the setup costs by many users. In the end, a 5cm by 5cm board with 2 layers of copper, solder stop mask, silk screen is amazingly US$10. Larger ones get a bit more expensive, but it’s still cheap. And I get 10 boards. There is some extra delay of course as all those small boards needs to get pooled to one large PCB.

What does it have to do with EAGLE? EAGLE is the program which is recommended to create the PCBs from. Other programs work too (e.g. KiCAD), but most tutorials are for EAGLE and most services can handle EAGLE files, either directly or indirectly. EAGLE also runs on Linux.

So I downloaded EAGLE v5.1 as

aptitude install eagle

did not work.

And then the steep learning curve of EAGLE started. At first I could not do anything at all; this is an old program and it shows: hardly anything works as expected. This tutorial helped me to get started. It stops where the layout starts though, so here my additions:

• If you want to fill a plane (e.g. with GND), make a polygon on the board layout of where you want it. RMB (right mouse button) will show the properties of it. Add Isolate to have a distance from signals. 0 is a stupid default value.
• Use the name command (RMB on the polygon) to merge it with the GND signal (of whatever signal you want to have connected).
• To start the autorouter, click on the autorouter button (yeah, it sounds very straightforward). Any signals which could not be connected will be air-wires (thin yellow lines).
• To rip up one trace, use RMB and delete.
• To rip up all traces, click on the ripup button, then on the go icon (the traffic light next to the STOP icon).
• Click on ratsnest to see the polygon being poured.
• It’s fun to watch the autorouter on slightly complex layouts. If your design is complex or space is too limited, you might end up with some air wires. Try to relocate some components.
• The rules file document dictate what the manufacturer can do. E.g. available drill sizes or capabilities like thinnest possible traces etc. The default values are quite conservative. To load, click on Edit/Design rules and load the rules for your service.
• The CAM file creates the layers (copper per layer, silk screen, solder stop masks). It creates all the needed Gerber files.
• gerbv is a nice utility to display those created Gerber files layer for layer. Use it recommended. While you’ll unlikely stop small errors (e.g. a single traces missing), you’ll find layers completely missing.
• Never only open schematics or board view. Always have both open, as otherwise you create inconsistencies which are not fun to manually fix. As long as both are open, any modification on one window will update the other one.
• The free version of EAGLE is limited to 8cm by 10cm and 2 layers. Good for small stuff. For hobby use (non-commercial) you can get the standard edition (10cm by 16cm, 6 layers) for modest US$125. I doubt I’ll need those capabilities, but if I do, I know there’s a cheap upgrade path.

I realized quickly that the MultiAVR library is only the core Arduino library. What is missing are the non-core ones, like the I²C library (AKA TWI or “Wire”). Expecting a serious re-write, I was pleasantly surprised to see that I had to make exactly one change:

*** /usr/share/arduino/libraries/Wire/utility/twi.c     2011-01-10 14:28:07.000000000 +0900
--- /home/harald/workspace/BlinkSanguino/utility/twi.c  2011-09-24 22:38:53.283676108 +0900
***************
*** 69,74 ****
--- 69,77 ----
      // as per note from atmega8 manual pg167
      sbi(PORTC, 4);
      sbi(PORTC, 5);
+   #elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)
+     sbi(PORTC, 0);
+     sbi(PORTC, 1);
    #else
      // activate internal pull-ups for twi
      // as per note from atmega128 manual pg204

and that was it.

In one day I was able to talk to:

1. the LCD (16×2 characters)
2. an PCF8574A (8 bit I/O)
3. an PCF8583 (RTC)
4. an MCP23017 (16 bit I/O)

Arduino’s hardware is great and plentiful available, but for bare bones, the single microcontroller is all you need.

So I got myself some ATmega328P chips (250 Yen a piece) to set up a minimal Arduino like described here. All I need is an Arduino to program the blank chip. Got that, so I was hopeful.

First step is to burn a bootloader via the ISP interface of the 328P. Worked flawlessly. Infact, I tried all variations of bootloaders: with external clock and without, and the normal bootloader as well as OptiBoot. All of them looked ok: after reset an LED connected to digital pin 13 blinks with the usual “there is no program” sequence. But all attempts to program something using the serial connection failed with

avrdude: stk500_recv(): programmer is not responding

errors. I tried all possible board types and I tried to use avrdude using all possible baud rates. Nothing worked.

After spending countless hours trying to find a solution I gave up and skipped the Arduino interface part and its abstraction. The benefit is that I know exactly what is happening and the serial port now is free and available for other uses beside programming.

I found a good (and simple) example here and here I found how to use avrdude correctly:

avrdude -v -p m328p -c avrisp -P /dev/ttyUSB0 -b 19200 -e -U flash:w:demo.hex

This is using an Arduino as programmer acting as an avrisp programmer to program the ATmega328P. Worked on the first try.

Some more examples:

• And to read the config and fuse bits:

avrdude -v -p m328p -c avrisp -P /dev/ttyUSB0 -b 19200

• To program the fuse bits (fuse bit values taken from here) and erase the flash memory (-e):

avrdude -v -p m328p -c avrisp -P /dev/ttyUSB0 -b 19200 -e -U lfuse:w:0xE2:m -U hfuse:w:0xDA:m -U efuse:w:0xFD:m

On an unrelated note: During the next days, so time permits, I’ll check out this and this. This looks helpful too. Then I can get rid of the Arduino IDE, but keep the libraries.

Driving a LCD from an Arduino is no problem at all. There are nice libraries doing this. I bought a slightly different display which uses an I²C interface instead of the usual 4 or 8 bit parallel interface. Since I connected recently the Wii Nunchuck which uses I²C too to my small Arduino board, the next logical step was to add the display too. After all, I²C is all about adding devices to a 2 wire bus.

There was only one small problem: I²C LCD is not supported natively by the Arduino library system. But someone (and I really do not know who as the amount of comments was limited) created a library for Arduino here. All I can say about the author is that he (or she) is using a Mac and probably Japanese since I found a Japanese comment. This library was a great starting point, and although it was not complete and quite some functions were commented out with a “Does not work”, they worked out fine after I replaced them with what I thought should be here according to the data sheet of the used controller (ST7032i).

Now I have connected to my Arduino:

1. Wii Nunchuck (2 button, 3 axis accelerometer, analog joystick)
2. LCD (2 lines with 16 characters each)
3. Servos (like those)
4. A 12V fan which can be controlled via PWM to change its rpm
5. LEDs of course
6. 12V relays

If anyone wonders what the goal here is, for those I can only say: “Der Weg ist das Ziel” by Confucius.

Next on my list:

1. RTC via I²C so the Arduino knows what time it is
2. A piezo buzzer
3. More sensors, like temperature, humidity, light etc.
4. Another uController via I²C

With the first two I can make an alarm clock. Not that I would need one…