As you may (should :P) know, a Floppy Drive Emulator has been designed by Jean-Francois Del Nero. See http://torlus.com/floppy/ for more information.

His interface uses programmable logic (CPLD or FPGA) to deliver a perfect timing and emulation of a floppy drive. However, various projects exist, based on microcontrollers.
So I wanted to give it a try myself, using a microcontroller. I chose a LPC2106 mounted on a convenient DIP board (LPC-H2106 from Olimex), and started to work on it last week.

Unlike the current CLPD-based version from Jeff, it uses SD cards for storage, as in his WIP FPGA-based standalone version. With great help of Jeff, I eventually managed to get some good results, as you can see on these pictures :





Thanks again Jeff for your time and patience ;)

As you're probably aware of, MCU are easier to use, and cheaper than programmable logic. However, they bring some limitations, and in such a project where timing is critical, there are some features (especially floppy write support), that are probably not possible with a MCU "alone". However, this work could be a good start to study solutions that could mix external (programmable) logic and MCUs, in order to keep the cost as low as possible, and make it easy to assemble by hand.
Stay tuned !

Here it is :) My not-so-secret project was to build a custom handheld. See below (previous news) for the beast, assembled :

You can check all the previous news I wrote about this project, that were offline until today. All their titles start with "MEX", that stands for "Micro ElectorluX" :)

Thanks to Devpsx for his help on this project, I will put all the related files for download in a few (Eagle files, C source...).

I spent some time today building a package for the system. It's basically made of balsa wood, as it is easy to work with. But even with that, it's still looking quite bad, as I don't like "standard" do-it-yourself tasks :)
Anyway, I'm satisfied with the results, here is how it looks like :

Here is the contents : main board, SparkFun header board holding the LCD screen, keypad board, and some last-minute parts (I forgot to tie P0.14 high, and the power switch).

Next step, maybe paint it and, more important, make a game for it :)

I just connected my keypad to the board, on the places left for this purpose, and wrote a simple program to show up button status on the LCD, and everything's fine !

It means that the hard work is now done, I will now try to make a not-too-ugly packaging, and see if I can add sound support (I had to remove the dedicated pin when I fixed the design, but I can still use the UART0 pins that can do PWM).

Ok, the board is now working (see previous "public" news). I connected pins P0.0, P0.1 and P0.14 to the FPGA, and re-used a simple design I used for programming the Olimex LPC2106 board.
I've been able to flash the LPC2106 using Philips ISP software, and run the well-known blinking LED program. Good!

Next thing to do, put the Sparkfun header board carrying the LCD on the place dedicated to it, and check if everything's working as it used to do on the breadboard, but I will do that later.

Meanwhile, Sparkfun has restocked some Hirose DF23 compatible connectors, so I could do without the header board but well, as having this first board up and running was quite painful, I think I will choose the easy path for now :) However, I've ordered some of those connectors, just in case of...

After another set of attempts, I finally got my board working !!!

I think I've probably made all the mistakes one can make : stupid design errors like inverting pins on the voltage regulators, placing the main component the wrong way (and finding it out only once all pins are soldered, of course). But well, this is history now, as this frigging board now works !

After some other attempts, I managed to get a quite clean PCB. So I went into soldering, which was painful especially at the beginning, before I had the idea of using solder flux, which makes things way easier :)

It was also the opportunity to find some (obvious) mistakes in the board design too. Anyway, I managed to make some workarounds, and things should have gone OK... but they didn't. My first soldering (and desoldering) attempts might have destroyed the central component (I started with it, thinking that if I wasn't able to solder it properly, it would be useless to solder the remaining parts).

Anyway, things are getting better and better, so let's continue :)

I played a bit with the LCD screen, and got a bit disappointed by its capabilities. The SPI, which is a serial interface, is in my opinion the main issue for high performance. However, it has some interesting abilities, like region-based RAM access, and with some software trickery, it could probably give good results.

Nevertheless, as I know how to use it in software, the option of using a LPC21xx chip was no more a must-have. So I started to investigate a bit on which kind of MCU I could use instead of these ARM chips. You can see on this picture the beginning of a SX28-based system.

However, I quickly cancelled the idea. 2K of code space won't probably be enough to make a game. The idea of using the SX28 looked nice at a first glance, as it is able to perform at 80Mhz, and is in DIL format. As the number of connections is small, I could have made quickly a small circuit on a protoboard, and the system would have been done in a few :)

So I decided that with this project, I will stick with LPC chips. Having much ROM and RAM will be more convenient, and I could even add CompactFlash support, to load programs for this system. So it seems that it is the right moment to build my first PCB. I will use a LPC2106 for the final system, because I know it a bit now, and also because if I don't feel comfortable with soldering, I could train myself on a LPC2101, which is pin-compatible, and costs only $3. It's a bit challenging, as I will use surface-mount components (the LPC2106 comes in a tiny LQFP48 package, and it looks very very tiny compared to the DIP chips I'm used to play with).

I will use the SparkFun carrier board as is, because I haven't be able to find anywhere a site to purchase the small Hirose DF23 connector for the screen... Well, it will keep my own PCB simplier, which is not a bad thing.

I have received my LCD and carrier board from SparkFun. I quickly set up a small circuit on a breadboard, and started to port the source code, designed for a LPC2138 to my LPC2106... and encountered the first issue !

The LCD uses a weird 9-bit SPI interface (1 bit to select either command or data, and 8 bits for data). The LPC2138 provides this kind of SPI features, but not the LPC2106, that can only do 8-bit SPI !

I started to wonder what to do... Get a LPC2138 too ? I disliked this idea, as I would have to find a convenient (and cheap) header board, or maybe make one myself (which would have taken much time).
So I decided to look closer at SPI, and found out that it was pretty simple, so I started to write a SPI implementation in software. And after half an hour or so, I was quite happy to have the interface work ! The LCD screen now displays a multi-colored square (at a quite low display rate, but I'll look at that later).

First impression, this small screen is very bright, the brightness/contrast flickers a bit, but I haven't soldered the filtering capacitor SparkFun recommends, so I guess it's normal at this stage.

While chatting on IRC channel #hwdev, someone talked about some nice and very cheap LCD screens available at SparkFun. $20 for a 128x128 backlit 4096-colors display is plain great! Sparkfun provides also an example source code for LPC2138 ARM MCUs to control the display.

Naturally, it gave me the idea to try to build a custom handheld console.
The project name is "MEX" which stands for "Micro ElectorluX".

I ordered one of these screens from SparkFun, as well as a carrier board for prototyping. As I already have a LCP2106 module from Olimex, it would be quite easy to have things up and running quickly, to see how capable this little LCD screen is.

Yesterday I got the USB module working, for the purpose of my current hardware project (see the Atari section).


Next stage of this project involves getting my hands into the Atari ST itself, but before doing that, I need to get a VGA adapter (I don't want to use the telly, and I expect such an adaptor to be delivered to me soon).



So I decided to work a bit on Bixente II project, by having my LPC-H2106 board from Olimex up and running. You can see the board on the picture (surrounded by an ellipse), next to the USB module and wired to one of the extension port of the FPGA board.

I set up the following connections :

• Ground and Power pins.
• One switch of the FPGA board to control the P0.14 pin, in order to select either the ISP mode (to program the flash memory for instance) and user application mode.
• One push button of the FPGA board to control the RST pin.
• TXD and RXD pins of UART0 connected to the FPGA board's serial interface, in order to use the ST3232 (that is equivalent to the MAX2332) and the DB9 connector.
• One led of the FPGA board connected to P0.7 (see below).
  

Everything worked fine, and I have been able to flash a sample program that blinks a led (available at Olimex's website). Good.
I also suscribed to a Yahoo group called LPC2000 that seems to be active and provide lots of information about these ARM MCUs.
More particularly, I was looking for information about the way to use a free toolchain, instead of the commercial ones that are very expensive (for a hoobyist, at least). And it looks that a standard GCC build, and proper specs/linker/startup files (found on this group) should do the trick. Very Good.

Now I need to spend some time reading the documentation, and then begin to make my own programs. I'm quite familiar with ARM programming, but I need to see what kind of I/O I can use and how, in order to make, at first, a video interface for the console.

Some parts arrived, as you can see on the picture, and I expected others (mostly samples) to come in the next weeks.

Here you can find :

• A LPC-H2106 evaluation board from Olimex featuring a Philips LCP2106 ARM7 MCU. It will probably become the CPU for my Bixente II project :)
• A DLP-USB245M evalutation board from Future Technology Devices. It's a USB controller that will be useful for many purposes, one of these being related in my Atari section.
• A Z8400 MCU. Yes, a good old Z80 MCU. It will probably be used in a future hardware emulation project.
• Some samples from Analog Devices, that will bring hopefully decent sound and video to Bixente II.