Thanks to Per for bringing up the error.
I apologize for this mistake and I’ll do my best to look out for them in the future.

This was my first real PCB. It is almost completely all surface mount, with the exception of a few headers, serial port and stuff like that. The passive component’s size is 0805, which I thought would be a good start with smt. I discovered that smt is awesome. It is much more convenient than through-hole, and you don’t have to reach around and flip the board in all kinds of directions if you need to desolder something.

Since I had little time after developing the schematic in two weeks, I rush designed the board in about 3 days. In the end, not too bad. I chose the wrong component packages for a few things, but I made them fit when I soldered them down. That’s all cosmetics. As for true design mistakes, I shared the TXD0 and RXD0 UART pins of the microcontroller with chip select and interrupt pins on an ethernet controller which happens to hold them high (thus screwing up my uart channel), and I think I messed up the SO/SI – MISO/MOSI lines on the spi. Well, it’s all correctable with wire wrap wire.

Continue reading for more info and cool pictures. 

JTAG works great. UART is coming along. It works when the mcu is connected to an external little UART board, but not with the onboard chip and serial port. Soon it should all be fixed.

I got the prototype boards done by Advanced Circuits (http://www.4pcb.com). They shipped the next day, and I had the board about 3 days after I submitting the order. I ordered 3 prototype boards (no soldermask, no silkscreen), and it cost $83 shipped, with UPS 2nd Day. I guess I recommend them, but then again the only other place I’ve tried is SparkFun (now BatchPCB), which took considerably longer (but they cost less for better quality boards). They did a good job too. Advanced Circuits gave me this cool clock-date-temperature-snooze alarm-timer pen/pencil holder thing, the classic promotional post-it pad, and popcorn. Here’s a picture if you don’t believe me:

I soldered everything by hand. I first thought I would need a skillet/hot plate and do some reflow soldering with solder paste, but I changed my mind and I returned the skillet. It actually isn’t that difficult to do by hand at all. I don’t know how I managed to solder the LQFP64 pins for the first time, but things worked out and now I consider SMD is easy.

Here is a picture of the legs of LPC2148. Most of the pins should be down, if not I corrected it at a later time (after the picture was taken).

Finally, I decided to take a quick picture of my electronics setup so far:

Soon I’ll be getting an oscilloscope. Yeah, I’ve been doing all of this stiff the whole time without one. I guess I really don’t need one, but it might help when time is short and I have a big problem. Other than that, I think my setup is pretty complete. Not shown in the picture are my two big green component boxes that store most of my electronics components. 

The JuiceBox is a great dev board to learn on. Everything is production prewired, all you have to do is write the code to work it…

Today I have made some significant progress with the general understanding of this embedded hardware. Using just JTAG/OCDCommander, the datasheet, and the register definitions in s3c44b0x.h, I have gotten two different parts of the board to work. First, the buttons. This was pretty easy, since I have worked with the idea of setting the direction of a port and manipulating the port in the past.

The buttons of the juicebox are located on port G, so two primary registers are involved: PCONG and PDATG. The first one being the direction of the port (16-bit register, 2 bits per pin to be: input, output, special), and the second one being the data representing that port (8-bit). Instead of fumbling with the math and finding the bitwise masks required to push certain buttons, I simply read the PDATG back in OCDCommander with different buttons pressed at different times, and then defined these values in my own code to be easily accessible and easily compared to PDATG. I get this in the end:

#define JB_PLAY 0x9D
#define JB_RETURN 0x9E
#define JB_STAR 0x8F
#define JB_FORWARD 0x9B
#define JB_REVERSE 0×97
#define JB_ATREST 0x9F

To use the port G, I first set the direction of the whole port to input (pcong = 0×0000;), and then the data on port G can be directly compared to these constants. It works great.

Since this worked out of the box so well, I decided to write my own UART interface. I am familiar with UART in general (used it a lot in the AVRs), so I have a basic understanding of how it works. The init() and putc() of my UART interface also surprisingly worked out of the box, but the getc() still needs a bit of work (it half works). When I’m done, I’ll post the UART interface code.

JB Button Test Source Code (prints out in the LCD what button you have pressed), precompiled elf included as well:
http://www.frozeneskimo.com/electronics/wp-content/uploads/Software/JBButtons.zip
Note: I take absolutely no responsibility for any damage this software may cause.

Since births and deaths simultaneously occur in the Game of Life, you can’t modify a grid directly when applying the three rules of the game. Originally I kept a temporary copy grid that would be checked, while the original would be modified. But, due to memory limitations on the JuiceBox itself, I had to rewrite the grids to use a more complex “marked for death/birth” status in the cells. Anyway, it runs perfectly, and it’s pretty cool to watch.

Here is a picture of a sample game, near the beginning:

Here is it towards the end, when it is rather stable:

If you want to try it for yourself, here is the elf file that can be downloaded with OCD Commander or similar program to your JuiceBox (given you have a JTAG emulator as well): gol.elf
I take absolutely no responsibility for any damage this software may cause.
I will post the sources shortly…

Next project is learning to use those buttons and I/O ports on this ARM chip.

Using OCD Commander you can easily upload the code to the processor’s memory through a JTAG emulator, and it will automatically set the PC register to the start of the program. All you have to do is hit go, and your program is running.

I played with the LCD demos, and modified the second one to print a greeting message, which I took a picture of to post here:

My next familiarization project is to port, for the first time ever, the game of life to the JuiceBox. I will have pictures of this tomorrow when the project is complete. It shouldn’t be too difficult, since the LCD demo code has shows how to drive the LCD and plot pixels.

In addition, I want to mess with the buttons. They are located on PORTG, but I still have yet to learn how I am supposed to properly manipulate the PORT registers on this ARM chip…

I love JTAG and $15 ARM development boards.

jtag> cable parallel 0×378 WIGGLER
Initializing Macraigor Wiggler JTAG Cable on parallel port at 0×378
jtag> detect
IR length: 4
Chain length: 1
Device Id: 00011111000011110000111100001111
Manufacturer: Samsung
Part: s3c44b0x
Stepping: 0
Filename: /usr/local/share/jtag/samsung/s3c44b0x/s3c44b0x
jtag>

In addition, I ran ocdremote, which recognized the Wiggler, connected to it immediately, and setup the local TCP server for GDB to connect to. I ran the arm-elf-insight (Insight is a standalone frontend to GDB) that is packaged with the GNUARM toolchain, and connected to OCDRemote. After the connection I could view all of the juicebox’s CPU registers and internal RAM. I could also step through the program instructions.

Now I’m compiling jtager over cygwin so I can dump the internal RAM of the CPU and compare some of it to the chunks that are posted on the linuxhacker forums…

Soon I’ll write a tutorial for integrating OCDRemote with GDB with Code::Blocks, so people can easily develop and debug all ARM7 projects through Code::Blocks. Finally, I can uninstall eclipse.