It’s a design for a wireless gateway/hub.

I went and got a few formal quotes from PCB manufacturers.
They’re all around £130 for a single 12in x 9in panel.
I can pay closer to £100 if I order from abroad, but then I’ll likely have to pay import duty on top.

It’s not really 12in x 9in as you need a margin around the edge and a gap between PCBs of at least 0.1in.

Here’s my current PCB:

It’s 1.7in x 2.4in  = 4.08 sq in
That’s a best case of 26 PCBs per panel, coming out at £5 per PCB.
If I tesselate with appropriate gaps, I can get 20 on a panel for a real cost of £6.50 per PCB.

That cost is much too high for my project.

And, not to forget, that doesn’t include any sensor PCBs…
At the ratio of 1:2 for hubs:sensors that I wanted to get made, I’ll be getting maybe 6 or 7 hubs for £130, which I can’t stomach…

So, back to the drawing board!
It’s not as sexy (or easy to fit in a box), but it’s much smaller. (I haven’t routed the tracks yet, so it might end up a little bigger).
Looking down, the Ciseco module faces you with the antenna poking you in the eye.
The blue board sits on top of the ethernet board, mating with the square pads on the right.
The power jack is mounted on the underside of the blue board along with the serial header and LED.

This PCB is 0.9in x 1in = 0.9 sq in
Best case of 109 PCBs per panel, coming out at £1.20 per PCB.
Even if the reality is only half that yield, I’d be a lot happier.

It’s a bit fugly, but they’re just prototypes…

But, the XRF doesn’t feature a standard connector for programming. So, here’s a single sided programming/test jig users can etch at home (or you can buy something similar).

There’s a single LED on P2_3, a serial port on P0_2/P0_3 and nothing else.

I’m making the project files available as I’ve created a custom Eagle CAD footprint for the XRF with the CC1110F32 pins labelled.

Here are the Eagle files.

(Note, looking down on the board, pin 1 on the programming header is on the bottom right)

I found a great little tool called BoxMaker which can generate a PDF of the faces to cut. There’s an online version or a Java app.

I’ve modified it to generate a lid piece, so an external hinge can be fitted. Get the sources on github: https://github.com/jobytaffey/boxmaker.

Today, the proof that it works arrived from @RazorLab.

Etching a QR code, seemed to work pretty well too.

Now that I’m doing projects with the IM-Me, I’m getting the hang of modifying them. Here’s my process.

Buy an IM-Me. My local Toys’R'Us has them for £4.99.

Gather some tools.

Unscrew and remove the casing.

Remove the USB connector. Apply gentle pressure while heating all of the pins on the top.

Then do the same for the bottom two pins and remove the connector.

Find and remove the Cypress USB controller chip.

Blob solder down one side. Heat the solder and lift the legs, so that one side is raised. Then repeat.

Clean up the pads with solder wick.

Glue some pin strip along the edge to turn the dongle into a SIL module suitable for a breadboard.

Use thin insulated wire to connect the pins to the board. I’m using a laquered copper wire.

Use this reference to help you. Connect your power and ground pins to the legs of the electrolytic capacitor, connect your serial port to the two pads from the Cypress (TX = MOSI, RX = MISO), connect your programmer to the vias with the white circles.

Build a handy programming, serial and power cable. Mine plugs into a SmartRF board, you may want a different header for GoodFET.

Plug and play.

Grab some sample UART code and a test binary.

Upload PinkOS.

I found an old XBox arcade stick. But, I couldn’t persuade OSX to read it properly. So decided to gut it and replace the internals.

I wired a Teensy 1.0 up and hacked the LUFA keyboard sample to emit the right keys.

I’m off to play Mr. Do…

Making PCBs and learning how not to solder.

Test driving cheap ARM JTAG adapters

Developing a single chip USB Bus Pirate around an AVR with new hardware and software

Getting familiar with the TI MSP430

Hacking IM-me dongles and handsets to do interesting new things

Playing Chiphacker

I’m really happy with how they’ve turned out.

In the dark, they’re quite hypnotic.

We used old glass jars, diffused with some spray on paint. Inside, there’s an MSP430G2221, 7 LEDs, 2 resistors and a piezo transducer (to detect tapping). Cheap and simple.

I prototyped everything on TI’s MSP430 Launchpad before home-etching some single sided PCBs.
Here are the Eagle CAD design files. Admittedly, the Launchpad is only $4.30, but, I didn’t want the bulk.

Here’s the first prototype:

Each jar contains seven lights, which slowly synchronize with each other over time, like real fireflies. Tapping the piezo transducer in the lid makes them all flash and randomises the pattern.

Real flies synchronize with pulse coupled oscillators. Here’s a good overview. I use a simple algorithmic version.

And here’s my firmware image for anyone wanting to make their own: fireflies.elf.gz.

Here’s my source code (compile with mspgcc).

I’ve released my open source IM-Me bootloader/operating system, PinkOS.

• Interactive shell “with backspace!”
• 32×8 scrolling text console on handset LCD
• Console over UART (for modified dongles)
• Packet radio (868MHz@250kbaud+pauses)
• Sequence numbers, ACKs and CRCs (think UDP)
• Broadcast and 255 unique device addresses
• Over the air graphics blitting
• Remote LED control!
• Bootloader for launching third-party applications from the top half of the flash (eg. Michael Ossmann’s speccan)

If you have an interesting app, bug fix or improvement to the bootloader - come and contribute something.

(Serial and over-the-air application upgrades are on the todo list…)

An IM-Me dongle, hacked for battery power and TTL serial (click for detail):

The first thing I did when I got my IM-Me was to try and communicate through the existing Cypress chip. It works, but it’s slow and clunky. I had to treat the channel as lossy and build an ACKing and retry system on top. It’s a hack.

A much better solution is to solder a real TTL level serial port onto the dongle and communicate with it that way.

Modifying the board for serial comms isn’t much harder than wiring on a GoodFET.

Here is an unmodified dongle:

Add an external power source:
On an unmodified IM-me dongle, 5V is supplied over USB. This drives the Cypress’ internal voltage regulator which produces 3V for the CC1110.
I run my boards with the Cypress powered down and I provide 3V directly into the CC1110. I am using a wall-wart and a 3.3V regulator, but 2xAA batteries work fine.
Connect your 3V power supply to ground and 3V on the dongle. The easiest connections are at the positive leg of the through hole capacitor and the GND pin of the USB plug.

Disable the Cypress chip:
It seems that supplying 3V to the board has the side effect of powering up the Cypress chip. It will immediately start writing junk over the SPI lines which will interrupt the serial communications. To disable it, cut or lift the Cypress VCC pin. This is best done by heating the pin with a soldering iron then levering it up with a small screwdriver.

Add serial:
Connect a standard 3V FTDI-type cable to the Cypress pins marked MOSI and MISO. MOSI is transmit and MISO is receive.
Connect the ground pin of your serial cable to GND on the board.

For reference, this may be useful (Note that most of the thin green wires connected to the Cypress won’t be needed)

Once the board is modified - here’s a test firmware image:

:0400000002001B32AD
:01000B0032C2
:03001300020117D0
:0300740002001671
:0500160012007780FEDE
:100077001200B01200DC1200CF43FD4012011A7AC1
:10008700647B017C808A828B838CF0120144FD6043
:10009700EE8D820ABA00010BC002C003C004120130
:0900A70038D004D003D00280DC43
:1001640057617272616E747920766F696465640D8B
:020174000A007F
:1000B000539ADFA2AFE433F452A82274FC55C9F579
:1000C000F0740345F0F5C953C9FB43C90880FE43EA
:1000D000F32843FD1443FE0275FF182253BEFBE5CF
:1000E000BE30E6FB53C6B8E5C620E6FB43BE04229D
:1000F000AA82AB831ABAFF011BC3E49A74808BF007
:1001000063F08095F0500F7CB07D041CBCFF011D96
:10011000EC4D70F780DE22C28B32AAF174FE5AF5E4
:10012000F0740245F0F5F143F33C7586C075C222C8
:1001300075C50CD28BD2AA228582C1E58630E1FB3F
:040140005386FD22C3
:06004A00E478FFF6D8FD8A
:100028007900E94400601B7A0090017678007593A6
:1000380000E493F2A308B800020593D9F4DAF27544
:0200480093FF24
:100050007800E84400600A7900759300E4F309D859
:10006000FC7800E84400600C7900900000E4F0A304
:04007000D8FCD9FAE5
:0D001B00758107120160E582600302001686
:1001440020F71430F6148883A88220F507E6A883E4
:1001540075830022E280F7E49322E0227582002274
:00000001FF

$ goodfet.cc erase
$ goodfet.cc flash dongle.hex

Connect to the serial port at 115200 8-N-1

Driving the UART from C using SDCC looks like this:

void uart0rx_isr(void) __interrupt URX0_VECTOR
{
    URX0IF = 0;
    // read U0DBUF and do something with it...
}
 
void uart_init(void)
{
    PERCFG = (PERCFG & ~PERCFG_U0CFG) | PERCFG_U1CFG;
    P0SEL |= BIT5 | BIT4 | BIT3 | BIT2;
 
    U0CSR = 0x80 | 0x40;    // UART, RX on
 
    U0BAUD = 34;    // 115200
    U0GCR = 12;
 
    URX0IF = 1;
    URX0IE = 1;
}
 
void uart_putc(uint8_t ch)
{
    U0DBUF = ch;
    while(!(U0CSR & U0CSR_TX_BYTE)); // wait for byte to be transmitted
    U0CSR &= ~U0CSR_TX_BYTE;         // Clear transmit byte status
}

Good luck and enjoy voiding your warranty.

It’s all released under the GPL and is a decent framework for making your own games.

Download the source code and precompiled IM-me binary here.

• Engine features:
  • No in-memory framebuffer - 8×8 cursor based graphics (very low RAM usage)
  • Background tiles must be aligned to an 8 pixel grid
  • Foreground sprites blitted with transparency to floor tile and aligned on a 1 pixel grid
  • No proper overlapping of foreground sprites implemented
• Build features:
  • Compiles for both IM-Me (CC1110) and PC (using SDL)
  • Converts sprites from BMP to ST7565 8bit monochrome vertical stripes in C header files
  • Converts Tiled TMX files to C header files

I did experiment with adding music. But, the IM-me is designed to be a pager. It’s good at making very loud, very high pitch noises and not a lot else.

Here’s the game map:

Who’s going to write me an RF networked Bomberman clone?