This is a project I’ve been thinking about, and working towards, on and off, for positively ages now. Work is really busy (need a website designing and building?), and with a (still relatively) new daughter to fill in the gaps, my free time for the last eighteen months has been somewhat limited.

Apart from electronics projects, another work in progress is my motorcycle. It’s thirty-two years old, and, being a Honda, still runs really well. I do plan to strip it right down and re-paint the frame eventually. It also needs the occasional fix, for example the speedometer gave up the ghost last year, simply making a racket as the drive cable rotated around, presumably, a jammed shaft. I didn’t bother trying to fix it – I’d been thinking for a while how cool it would be to build an arduino-based circuit that counted wheel revolutions via a hall sensor and magnet to display speed.

My plans became more grandiose – I could also monitor engine revs, extrapolate the gear I’m in from the speed/revs, and have an electronic ignition lock. I actually built the first circuit. It worked really well on my desk, not so well on the bike. For one thing the ignition lock was based around a relay which would disconnect occasionally, stalling the bike. Also the 4×20 LCD display was too small and impossible to read in sunlight, and the rectangular project box that everything went in looked horrible on the bike.

I decided to pare back to essentials. Essentially I need a speedo, and I wanted it to look more in keeping. I decided I was going to use the original speedo housing, and add bright LEDs around the outside to show the speed, and have more in the middle to act as indicator, neutral and high-beam warning lights.

I started, with Eagle, to lay out the LEDs. I’d need twenty-seven to go around the outside to show speed in 5kph increments, another three for the warning lights, and then I thought maybe I’d add a ten-LED array (from Farnell) below them in case down the line I wanted to use it as a rudimentary tacho. Getting the LEDs arranged in a circle required a bit of a spreadsheet with sine and cosine calcs on it.

To drive 40 LEDs from one Arduino requires either a bit of jiggery pokery (Google “charlieplexing” if you’re interested) or, to cut the Gordian knot, simply buying a bit of extra hardware to do it. I opted for the latter given my lack of time. I went for the Maxim 7221 (from Farnell, the link to the item is: http://uk.farnell.com/maxim-integrated-products/max7221cng/ic-led-display-driver-8dig-24dip/dp/1593381). Information on linking this IC to an Arduino can be found here. It basically allows you to drive 64 LEDs from the one chip, and you can daisy-chain them together. The Arduino communicates with it via SPI, so it only ties up three pins no matter how many MAX7221s you have chained together.

I’ve been experimenting with etching my own circuit boards using the printer toner and HCl/H2O2 method with great success, so that’s what I used here.

The LEDs effectively sit in an array – obviously physically they can be laid out any way – and I was using single-sided copper-clad board as it’s DIY. Usually when laying out a circuit in Eagle when you’ve only got one side (or layer) of copper means a bit of tweaking here and there to allow “nets” or tracks to connect where there’s no route for them to do so – normally I’ll add a few zero-ohm resistors in the board layout to connect them (and use plain wire, of course, when building). I found laying this array out impossible like this though, so the easiest solution was to tell Eagle I was using double-sided board, and tell it to favour the bottom side, and I figured I’d just add wire on the top where the tracks were meant to be. That ended up a bit of a rat’s nest when I came to build it!

I’m not proud of how this looks – but it works, which I was pleased with. I think if I had to lay out something like this with so many top-side connections again I’d experiment with using two single-sided boards and sandwiching them together, linked with through pins (“vias“) where needed.

To control the 7221, I used the LedContol library – which makes addressing each individual LED on the matrix as easy as just specifying a row and column. You can also control the intensity of the LEDs as well, which is nice. Here’s the thing running. The photo doesn’t do the display justice – it should be much easier to see the LEDs even in bright sunlight. The green LED in the middle will be the neutral indicator.

Next time (when I get a chance!!) I’ll document building the “veroboarduino” driver and handling the inputs from the hall sensor to count wheel rotations and pick up the neutral, high-beam and indicator warning signals.

Disclaimer: this post discusses using the Ethernet shield in a way for which it wasn’t designed. If you blow yours up experimenting, you’ll have to buy another one, not blame me :)  However, mine still works OK.

So, the nice chaps at Farnell (http://uk.farnell.com) sent me an Arduino Ethernet shield to play around with and review.  (Update: I see they now have a dedicated Arduino section at http://uk.farnell.com/arduino/)

Reviewing a stock board is pretty boring – nice little Arduino box, free stickers etc. I plugged it on the top of my Uno, loaded up the Example “WebServer” program available from the IDE’s File→Examples→Ethernet→WebServer menu, set the IP address, subnet mask, MAC address (it’s the number on the sticker on the bottom of the board), uploaded the “sketch” and off it went. Immediately working. Like I say, it works out of the box – cool, but not very exciting to write about!

However my mind immediately started thinking… it’s all very well playing with this, but what if I want to build this in to a finished project? If you’ve read previous posts which explain how to build an Arduino-compatible circuit, you’ll know there’s no point buying a new Arduino board each time you make a new invention. Prototype on your Arduino, then build a Veroboarduino to make it permanent. But how would you interface a shield such as this Ethernet shield to a Veroboarduino?

In my innocence my first thought would be that the shield just uses a few of the pins on the headers – find the pins, connect them appropriately, and off you go.

So firstly I built up a quick Veroboarduino on a breadboard for this test:

On the board you can see the FTDI connector I use and a big LED. I ran the “blink” program to ensure everything was working OK. So far so good :)

First test – I connected +5V and GND from the breadboard to 5V and GND header sockets. My first problem! The ethernet shield’s “ON” LED wouldn’t light. Hmm… so how does it get its power? I tried all the GND and voltage sockets on the board – none of them would cause the shield to power up.

Then I realised that, as well as connecting to all the normal Arduino header sockets, there’s also a six-pin header socket under the shield which connects to the Arduino’s ICSP pins. Aha! The pinout of the Arduino’s ICSP header (the six pins by the reset button) are as follows (click the image to see it larger). Pay attention… we’ll revisit this later!

 (NOTE: this image shows the pins as if if you are looking down onto the top of an Arduino board. NOT the underside of the shield.)

 1 - MISO
 2 - VCC (+5V)
 3 - SCK
 4 - MOSI
 5 - RESET
 6 - GND

So pins 2 and 6 – I connected them to the power rails of my breadboard and the shield’s “ON” LED lit up. One success!

Now… what pins does the shield use?

This was a useful post on the Arduino forums, a chap called Rob Gray has compiled a list of shields and what pins they use: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1286284349/5#5 (bottom post at time of writing).

According to his sheet,  the Ethernet shield uses the following pins: D2, D10, D11, D12, D13, A0 and A1.

So first I tried hooking these up, as one would..!  Expectantly I browsed to 192.168.1.7 (the IP address I’d assigned the board in the sketch). No response from the board. Hmmm.

Then I noticed Rob’s comment in the sheet on the Ethernet shield’s line: “SPI signals picked up from the ISP header”

The ICSP header actually just connects to pins on the Atmel chip – here’s where they go…

 MOSI - D11
 MISO - D12
 SCK  - D13
 RST  - RESET

So, I figured I needed to connect up more than just the power to the shield’s ICSP input!  I didn’t bother with the RESET connection, but I attached the others. On the top of the shield I just kept D10 and D2 “passed through” to the D10 and D2 pins of the breadboard.

I ignored A0 and A1 which Rob’s sheet said were the other pins the shield uses – as I’d read elsewhere that these are used to control access to the SD card reader built into the Ethernet shield. I might experiment with this later but ignored them for the time being.

And… power up the circuit again, browse to 192.168.1.7, and I’m greeted with:

So, as a quick summary: to connect a Veroboarduino or breadboard Arduino to the Ethernet shield:

• Connect the ICSP sockets on the bottom of the shield as described above for power and data connections.
• “Pass through” D10 and D2
• A0 and A1 are used for SD card access (I didn’t connect them – I wasn’t using it – something to experiment with at a later date)

Note: this is the final part of a series of posts describing how to create an arduino-compatible board from scratch for very little money. You can find the previous posts here:

Part 1
Part 2
Part 2.5 (circuit and parts list)
Part 3

BURNING THE BOOTLOADER

This section describes how you can easily burn a bootloader onto the stock ATMega chip in your new circuit using nothing more than your existing Arduino Uno (or older board), a few wires and one component. You do not need an external programmer device.

Wait, what IS a bootloader?? – Good question. The bootloader is a small program that is run whenever the chip starts up, and, for a few seconds, it waits and listens to see if you want to upload a new sketch. If it doesn’t get an upload, it just runs the sketch that’s already resident on the chip.

N.B. it is possible to buy ATMega chips with the arduino bootloader already burned onto them (obviously they cost more). If you have one of these, you can skip down to “Uploading a Sketch to the Board”

So, grab your “real” arduino and load up the normal arduino IDE on your computer. Load the ArduinoISP “sketch” from the File -> Examples menu option and upload it. Now connect up your new circuit to your arduino according to the image below (click to show larger in a new window).

The picture might not be as clear as it might be with all those wires floating about, so here are the connections:

Finally we need to add a component to defeat the “real” arduino’s auto-reset feature as this gets in the way of the bootloader-burning sketch. For an Arduino Uno (which I’m using), you’ll need to take a  capacitor (electrolytic, so make sure you have the polarity right) from the +5V we’ve got on the BREADboard (not the stripboard). Connect the other end of this to the Uno’s RESET socket. If you’re using an older arduino, I understand a 120 ohm resistor will work in place of the capacitor.

Once you’re all hooked up, and you’ve got the ArduinoISP sketch loaded on your “real” arduino, change the board on the IDE to the one you’re burning TO – I’m burning an ATMega 168 so I select “Arduino Diecimila, Duemilanova or Nano w/ ATMega 168” from the Tools -> Board menu.

Then make sure you’re holding the reset wire (the white wire that’s labelled in the picture) against the RESET pin on your new board, and select Tools -> Burn Bootloader -> w/ Arduino as ISP from the menu.

If all is connected correctly, you should see the TX/RX lights on your “real” Arduino flash for a couple of minutes, then the IDE should report “Done burning bootloader“.

Congratulations – we’ve made an Arduino! Next step will be programming the thing.

UPLOADING A SKETCH TO THE BOARD

“Real” arduinos normally have a USB socket on them to allow you to connect the board to your computer to allow you to upload “sketches” (i.e. your programs). As this is a designed to be a dedicated circuit, adding extra USB circuitry would be a waste and an unnecessary complication.

Therefore we are going to need to use something to convert USB to serial (which is what the chip “speaks” natively). Here are a couple of suggestions:

http://www.sparkfun.com/products/10008 – this is the one I’m using, I’ve soldered male header pins onto it so it plugs directly into the serial header on the circuit we’ve made.

Alternatively there are complete cables, e.g.:
http://www.sparkfun.com/products/9718
or
http://www.oomlout.co.uk/usb-serial-cable-33v-p-232.html

Both of the cables mentioned above have female ends – when using one of these I usually use a 6 pin male to male adapter I made by soldering two six pin male headers back-to-back to convert it to a male end. You could of course use a male header on the circuit we’ve just made, but it’s easier with the female header to connect up for bootloader burning etc. Your choice!

So, with my FTDI Basic Breakout board plugged into the serial connector on our board (note which way round it goes – “BLK” on the breakout board corresponds to row 6 (i.e. GND) and a USB mini cable connecting that to my PC, I should have be able to upload sketches. Note that on the IDE I need to select “Arduino Diecimila, Duemilanova or Nano w/ ATMega 168″ as the board type (as I used an ATMega 168) and the serial port is different from the usual one that shows up for the Uno – it’s /dev/ttyUSB0 (I’m running this on Linux).

I could now load up the Blink “sketch” and upload. But here’s a little “gotcha” – we don’t have any way to automatically reset our new board when uploading – we’ve not connected up the required line on the serial connector. I haven’t bothered with this because, for some reason, I found it very temperamental, and older arduinos didn’t have an auto-reset anyway. But to upload a sketch the board needs to be reset (because, as I explained earlier, that’s the only time that the bootloader is listening).

So here’s how to upload without problems every time… hold down the reset button on your new circuit, press the upload button on the IDE (or press Ctrl-U), then, only when you see the message “Binary sketch size: xxx bytes (of a xxxxx byte maximum)” pop up in the bottom black window (indicating it’s compiled and is about to upload), immediately let go of the reset button. This ensures the board is reset at just the right time. If you timed it correctly, you should soon then see the “Done uploading” message, and you’re done!

Try testing your board with the Blink program and connecting pin 13 to an LED with suitable resistor.

I hope this little series has been useful – if you have any comments, suggestions or have spotted any errors then feel free to leave a comment. It’s been fun – cheers!

—

By the way, “Vero” is a trademark of Vero Technologies Ltd, UK.

The text and images in this series are Creative Commons licensed – if you wish to use them for non-commercial purposes, go ahead – please just prominently label what you use with a link back to this site!

This VeroBoardUino Tutorial is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

This is part three of a short series describing in detail how to build an arduino clone from scratch for very little money.  You can find the previous parts here:

Part 1
Part 2
Part 2.5 (circuit and parts list)

CRYSTAL OSCILLATOR CIRCUIT

The crystal circuit is used to allow the ATMega chip to accurately time intervals.

Components required:

• 1 × crystal – 16.0MHz U4 style low profile can
• 2 × 22pF ceramic capacitors

See the picture below for placement. As you can’t see where the crystal’s legs are placed, I’ve marked which holes they are in by two red dots. For clarity I’ve also marked where the capacitors’ legs attach also.

For extra clarity, from the picture:

Capacitor “A” connects to rows 15 and 17
Capacitor “B” connects to rows 15 and 16
Crystal “C” connects to rows 16 and 17.

Note that the crystal’s legs are set too wide to span two adjacent rows – I’ve just bent them in so they fit – it means the crystal’s case doesn’t sit flush to the board, but that doesn’t matter.

None of these components have a polarity so it doesn’t matter which way round they go.

FINAL CONNECTIONS

We’ve got all the componentry on the board now (apart from plugging in the ATMega chip!). Now it’s just a question of making a few more connections. See the following image and follow the list below:

Wire “A” connects row 7 to row 22 – now 7 and 22 are at +5V.
Wire “B” connects row 2 (GND) to 23. We now have power “rails” at the bottom of the board.
Wire “C” connects 22 back to row 14 (left side), i.e. attaches the ATMega’s VCC pin to +5V.
Wire “D” connects 23 back to row 15 (left side), i.e. attaches the ATMega’s GND pin to negative.

We also need to connect a couple of pins on the right side of the ATMega:

Wire “E” connects row 22 to 16 (right side), i.e. attaches the ATMega’s AVCC pin to +5V.
Wire “F” connects row 23 to 14 (right side), i.e. attaches the ATMega’s other GND pin to negative.
Capacitor “G” connects between the bottom power “rails”, i.e. row 22 & 23.

Now’s probably a good time to list the pins of the chip in more detail. I’ll list them by the row number of the board, starting with the left side:

Row Pin Description 
8 RESET - we've wired this to the reset button 
9 RXD (pin 0) - this connects to the serial connector on the left for uploading your "sketches".
10 TXD (pin 1) - again, connects to the serial connector.
11 pin 2
12 pin 3
13 pin 4
14 VCC - connected to +5V
15 GND - connected to negative
16 CLOCK1 - connected to the crystal
17 CLOCK2 - connected to the crystal
18 pin 5
19 pin 6
20 pin 7
21 pin 8

Now the right side of the chip:

Row Pin Description
8 Analogue pin 5
9 Analogue pin 4
10 Analogue pin 3
11 Analogue pin 2
12 Analogue pin 1
13 Analogue pin 0
14 GND - connected to negative
15 AREF - we're leaving this unconnected
16 AVCC - connected to +5V
17 pin 13
18 pin 12
19 pin 11
20 pin 10
21 pin 9

As you’ll probably see, all the pin names are the ones available on your “real” arduino. So, for example, if we wanted to test the board using the “blink” sketch, we could hook up an LED (plus current limiting resistor) to pin 13 on row 17, right hand side (“real” arduino boards already have an LED connected) and test it.

ADDING A HEADER FOR PIN-OUTS

Normally if we’re building a dedicated circuit we’ll want to solder our connections to particular input / output pins on the ATMega directly to the stripboard. However for convenience of testing and burning the bootloader, I’m adding a small female header to the board. This step is optional, especially if you are using an ATMega which has already had an arduino bootloader burned onto it.

We’re essentially just exposing three pins – 13,12 and 11. Connect it to rows 17,18 and 19,  on the right hand edge of the stripboard.

Now plug the ATMega chip in, carefully, to its socket, making sure the little notch on the top edge matches the notch on the socket (i.e. at the top, nearest to the power supply circuit). Usually chips come with their feet splayed a little wider than the socket – just gently bend them in on a flat surface if this is the case. When you’re inserting the chip make sure none of the legs get folded under rather than going into their sockets – it’s an easy thing to do if you’re not careful.

So, we’re finished as far as the hardware is concerned. Here’s the finished product:

-

And that wraps up this installment.  We now have a board which is almost ready. So the next post will be an interesting one – how to burn the bootloader, which a lot of people seem to have problems with (especially using an Uno to do so), and after that we can then cover how to upload our programs to it.

Next post is now up here:  http://martyndavis.com/?p=188

It was suggested to me that I should publish the actual circuit diagram of this project, together with a parts list. Here it is!

• Stripboard, at least 23 tracks long and 14 holes wide
• LM7805 voltage regulator
• C1 & C2 – 100μF 25V electrolytic capacitor
• C3 & C4 – 100nF ceramic disc capacitor
• C5 & C6 – 22pF ceramic disc capacitor
• R1 & R2 – 10K resistor
• X1 – 16MHz crystal
• Atmel ATMega168-20PU microcontroller*
• 28-Pin DIL Socket 0.3″ Pitch
• Momentary make push button
• 6 pin female header (you may want to make this male) **
• Hookup wire

* You could use a 328 rather than the 168 to give you extra capacity, it depends on the requirements of your application.

** As the board has no USB circuitry, to upload your programs you’ll need a USB to serial FTDI adapter or cable, e.g. http://www.sparkfun.com/products/10008 – this is the one I’m using, I’ve soldered male header pins onto it so it plugs directly into the serial header on the circuit we’ve made.

Alternatively there are complete cables, e.g.: http://www.sparkfun.com/products/9718 or http://www.oomlout.co.uk/usb-serial-cable-33v-p-232.html?zenid=b3297f914547cb4f9649318b7a95cf9a – these have a female six pin end, which is why you might want the header on the board to be male instead of female.

-

If the circuit doesn’t mean much to you, keep following the posts – all will become clear!

Next Post: http://martyndavis.com/?p=168

HARDWARE

Components required:

• 1 × 28-pin DIL socket (.3″ pitch) suitable for ATMega chips
• 1 × 6-pin female header

Solder the DIL socket (i.e. the socket for the ATMega chip) across the line of 14 holes we cut vertically under the board. Make sure the little notch on the end of the socket is facing up, towards the power supply circuitry. This will act as a reminder for us when we insert the ATMega chip itself. Solder the female header on the left-hand column, from row 6 down, as per the image below (click to zoom in).

The 6-pin female header (henceforth referred to as the serial connector) on the left will be the socket we use to program the device via the arduino IDE once the circuit is finished. I’ve labelled the sockets in figure 3 but you can ignore that for the time being. NOTE – if you already have an FTDI cable you may find it has a female end – you might wish to use a male header for the serial connector. I’ve chosen female as it makes it easier to hook up for burning the bootloader. If this means nothing to you don’t worry at this stage.

RESET CIRCUIT

Components required:

• Momentary push-to-make button
• 10K resistor (brown, black, orange)
• 2 × short connector wire

Any momentary-make button will do. Connect it so it connects rows 4 and 6 when pressed. Row 6 will be connected to row 2, so is ground. Row four will be connected to the “Reset” pin on the ATMega, which will normally be held high via a 10k resistor. Most little buttons like this have four legs, two connected pairs. Make sure you have it the right way around otherwise rows 4 and 6 will be permantly connected regardless of whether the button is pressed or not.

Connect row 2 (GND, i.e. negative) to row 6 with a piece of hookup wire – “A” in the image below.

Use the 10K resistor to connect row 3 (+5V) to the reset pin on the ATMega (row 8, left side) – “B” in the image.

Connect row 4 to the reset pin also – “C” in the image.

So it can be seen that when the button is pressed, the reset button is taken low (i.e. connected to GND) which will trigger a reset of the ATMega.

That’s the reset circuitry complete. We can’t test this yet as we have no chip inserted!

SERIAL CONNECTOR

This is here so we can upload “sketches” (i.e. arduino programs) to the board. By virtue of its position on the stripboard, the serial connector (the six-pin female header we’ve already soldered to the board) is half way connected. The pins, top to bottom, are as follows:

GND (currently connected, as row 6 is GND thanks to wire “A” in the previous step)

CTS (“Clear to Send”) – not used, we’ve cut its track already

VCC (i.e. +5V) – we need to connect this.

TX – needs to be connected to the RXD pin on the ATMega via a 10K resistor

RX – connected directly to the TXD pin on the ATMega, already connected as it’s on the same row.

RTS – not connected. We’ve already cut this track.

So we need to connect VCC – we do this with hookup wires “A” and “B” in the image below.

Also we connect TX to the ATMega’s RXD pin – that’s just a question of bridging a cut we’ve already made with a 10K resistor (“C” in the image).

Once those connections are made, our serial connector is finished. Again, with no chip, we can’t test it yet.

Stay tuned… the next part is coming up in a day or so, where we’ll add a crystal to the circuit to allow the ATMega to time accurately, and we’ll make the rest of the connections.  After that the interesting stuff – burning the bootloader and programming the chip with your sketches!

The next post in this series can be found here: http://martyndavis.com/?p=150

So you’ve got a nice Arduino board for experimentation and you’ve built a circuit on a breadboard which you’d like to make permanent.

It’s expensive (and overkill) to use a new arduino each time you build a new circuit you want to keep. Here’s how you can easily build an arduino-compatible board, from complete scratch, for a few pounds/dollars/euros so you can keep your real arduino for experimenting with…

I assume you already have an arduino (we’ll need it to program the arduino bootloader on the ATMega chip). You can get ATMega chips with the arduino boot loader burned in already, but I’ve even saved that expense and used a stock Atmel ATMega168-20PU (available in the UK for about £3, I got mine from http://www.bitsbox.co.uk/), and we’ll cover burning the boot loader in a later post.

We start with the vero board (AKA stripboard). Stripboard is simply a board with copper tracks running across it, with pre-drilled holes in it. It’s simply a permanent version of a breadboard.

The stripboard we’re going to use should be a MINIMUM of 23 holes long (across the tracks) and 14 wide (along the tracks). This will make the board around 37mm wide and 58mm long – quite a bit smaller than a regular arduino. If you have space for it in your project, make the board bigger than this to avoid running out of space, particularly if you know you are going to need to add a lot of other components.

Cut the tracks on the board where indicated in the image below (click to zoom in) – you can use a “spot face cutter” or just a large-ish drill bit (which is practically all a spot face cutter is) for this. Use a magnifying glass or other aid to look closely to ensure that the track is completely severed. Brush away any little shreds of copper track.

POWER

First we’ll build the power supply for the board. By building in sections, this allows us to test as we go along.

Like the real arduino, we want to be able to run the board from a battery or other input with a voltage of something between 7V to 12V (we’ll also be able to run it from USB’s 5V, this won’t be via the power supply though, it’ll be via the connection to the computer — see later posts for more details).

The component that allows us to generate regulated 5V (which all our circuitry requires) from the input is an LM7805 (see http://en.wikipedia.org/wiki/78xx). The full list of components we’ll need are:

• 1 × LM7805
• 2 × 100 µF, 25V electrolytic capacitors
• 1 × 100 nF ceramic capacitor

Solder them on to the board as shown in the image below (click on it to zoom in). Note that the 7805′s heatsink should be on the right. Also note the electrolytic capacitors have a polarity so need to be connected the right way around. Usually there’s a stripe down the side of the barrel showing the negative and the positive lead is longer. The ceramic capacitor (100nF) can go either way round. Position of these components can be anywhere along the strips – I’ve opted to put them in the middle.

We now already have a board that we can test. The input voltage will go to rows one and two – the top row is positive, and row two is negative. If all is working correctly, the regulated output voltage will be on rows 2 (negative) and three (positive, 5V). So to test this, I’ve temporarily soldered a 9V battery connector to rows 1 and 2. Position along the row is not important – but NOTE that if you get the polarity wrong you will fry the voltage regulator. You might want to consider incorporating a diode for reverse polarity protection, and maybe a PTC (resettable thermal fuse) for overload protection in case of short circuits. Both of these are outside the scope of this basic circuit.

Also you could consider putting an LED (with suitable resistor) across rows 2 & 3 to show that the circuit is powered on. If this is going inside a box this may not be useful!

With 9V applied to rows 1 & 2, my multimeter shows 5.04V across rows 2 & 3 as expected, and 9V (from the battery) across 1 & 2.

Stay tuned for part 2 of several, I promise they’ll be no more than a day or two apart!

Edit: Part two is now available; you can find it at http://martyndavis.com/?p=133

So what’s with Ubuntu? I got used to the buttons suddenly going on the other side of the window bar in 10.04, but this whole Unity thing now has just pushed me a bit too far.

Again, I know that you can log in using “Ubuntu Classic” but soon Gnome 2.x will be gone and where are my options then?

I tried to like Unity, but (a) it’s buggy and (b) it’s virtually unconfigurable.  The menu at the top left of the screen, when you’re running at 1920 resolution and your window is in the bottom right of the screen is just madness. And those “hidden” scroll bars are driving me crazy.

Unity is clearly designed as a touch interface and for beginners. It just doesn’t work for power users. It’s a shame that Ubuntu feel they need to force it on their users instead of offering it as an option.

I was thinking about going for Linux Mint, which still has Gnome 2.x as their main desktop, but with Gnome 3.x coming how long before they make the leap? Besides, I’m too busy to re-install my machine from scratch again.

So finally I decided to run the following:

sudo apt-get install xfce4

I logged out, logged in again selecting XFCE as the desktop, and it’s made my day. Everything is configurable again, and opening a window feels really snappy. I’ve used XFCE before and am happy to see it’s always improving.

Still got those weird scrollbars, but I disabled those by running

sudo apt-get remove overlay-scrollbar liboverlay-scrollbar-0.1-0

and logging out and in again.

I’m happy.