Slashdot Mirror
Microcomputers for Homebrew Projects?
tengwar asks: "Way back when I was at university, I did a course on microcomputers which went into enough detail to design, build and program a Z80-based system - more or less state of the art at the time. Now that my lecture notes are firmly embedded in the Carboniferous layer, I'd like to have a go at doing this with a more modern chip, and I wondered what's available. I'm not brilliant at electronics, and I liked the way the Z80 peripheral chips integrated easily with the CPU. Obviously I'm not looking to just slot together the latest PC motherboard with the latest Pentium, but I'd need to go for something where the board design won't get too complicated, which probably rules out processors with full 32-bit external interfaces on space grounds. I'm not really concerned about performance, but it would be nice to be able to port a JRE to it rather than working entirely in assembler. Any thoughts on suitable starting points?"
I'm not sure if anything short of Pentium/Athlon would be state of the art enough, but I'd recommend the Atmel AVR. Firstly, there are lots of demo/examples with it and existing software archives exist.
This processor is used in some smart-sensor applications where you have distributed sensors.
Here's a 1998 EDN mag review and some simm circuit boards which make project computers.
One of the reasons you won't get modern CPUs to work on hand-made boards is the length of connections. With the z80, you can trim wires by hand and it'll still work quite happily; with faster CPUs, though, you need to be far more precise with the length of the wires / tracks connecting the CPU to memory and the like. At speeds of over a few MHz, even a mm difference is more than enough to screw things up...
Microcontrollers are extremely small, low-powered devices containing a CPU, some code/data memory peripheral interfaces. You might have seen them at work in your preferred game station mod chip...
I think Motorola, AMD and Intel also have a line of powerful 68xxx- and x86-, respectively, -based microcontrollers that might be closer to the capabilities of a PC processor.
There are also some chips that you can program in Basic (ugh) via a small interpreter in their boot code. It really depends on what you are planning to do.
PIC, or AVR generally is where you should start. There's really no way around working in either Assembly or C if you want to do anything serious with it.
To go to a more powerful CPU gets you into all the stuff you don't want to get into, like critical and complex board layouts.
There's BASIC compilers, but you aren't going to get very far before you run into some serious limitations if you want to do anything complex.
Good luck on the JRE thing, something like that is way too slow and bloated to run on a hobbiest CPU. I think sun made a chip that executed bytecode, but I don't think they make them anymore.
I've had enough abrasive sigs. Kittens are cute and fuzzy.
We have made a few ARM Boards to teach undergraduate students. They work with ARM Angel or with our own debugger KMD. You can write code in asm or C or any even gcc front end (inc java).
The best feature for me is the huge FPGA's to play around with. Its quite easy to pick up any electronic equipment and plug it into it. Lots of fun and great experience gaining stuff.
The board total was around 100 GBP (inc board manufacture and mounting) and I think if you ask nicely the designs will be available.
Alternatively you could use something like a 6809 or an 8051 but then writing code for them is a pain. The best idea if you use someting old is to emulate a better processor. You can then run your favorite ARM/MIPS/x86 code on an emulation and forget the real system.
Mouse powered Chips, Open source Processors and Lego
You might try an Arm processor, many of which have great built-in features (like NIC, daq, memory management). You can get demo boards, and run linux + related gnu tools on them. ARM-based systems make great embedded/distributed systems (aka 'the future'), and are a useful to learn for the old-resume.
mx
Firstly, these are good, and cheap: http://www.oopic.com/
:)
They can be programmed with java, c and much more, yet are basic. They are made to work well with servos and such, and are very versitile (read up on vitural circuit)
For a more expensive option, the famous mini-itx boards are great, and robot sized heh http://www.mini-itx.com/
Starting at about the same price as a microcontroller (well, some)!! Java is here too
I suppose I'm more looking into cpus for robots, so maybe this is not ideal.
puts ("Python r0cks\n");
I've been using Jave modules for a while...both from DalSemi/MAXIM (the "TINI", http://www.ibutton.com) and Imsys (the "SNAP", http://www.imsys.se).
They provide a JRE environment (JDK1.1.3 in the case of TINI, J2ME CLDC 1.0 in the case of SNAP) and allow me not to worry about processor and memory design etc.
Right now, my SNAP module lives in a custom extuded aluminum enclosure I designed, and has a MMC interfaced for it (an extra 16Mbytes of removable storage), and a bunch of other things like temperature/humidity sensors, LEDs, an LCD, and dry contact sensors.
One reason I like both these modules is that they support I2C, SPI and 1-wire for expansion....meaning that you don't have to necessarily hang stuff off the CPU's data bus.
Good luck.
-psy
If you *really* want a JRE (which is generally not synonymous with performance, in the microcontroller world), check out the TINI from Dallas Semiconductor, here.
If you want to get into heavier duty gear (and available only in surface mount), you can look at things like the Patriot from PTSC, here. There are also several others that I've seen, but can't recall the name of. A little Googling should find those.
If you want a processor, and not just a microcontroller, but still want it fairly simple, you might want to check Motorola's Dragonball chips. It sounds like you want something with a low pin count, and simple ISA, so that'd be my first suggestion, followed very closely by ARM.
If you want a microcontroller, then maybe the 68HCxx series, or a RISC-ish PIC. The 68HCxx series is probably the most popular there, and you can easily find code and design samples for them.
--That's the point of being root, you can do anything you want, even if it's stupid.
I had to get back into microcontrollers, after a long absence (since the days when the 6809 was state of the art).
I decided to go with the Motorola HC12. Unlike the HC11, it runs compiled C code with reasonable efficiency (gcc supported), it's highly integrated, and you have a simple execution model (not very many registers, etc.) when debugging by hand. It's reasonably capable, and almost trivial to design your own project board (clock frequencies within reason, few external components required, every kind of I/O pin conceivable).
The more powerful versions have huge amounts of internal FLASH (256K), but not quite as much internal memory as I would like (8K is typical of recent versions).
There are cheap modules available from Technological Arts in Toronto. They don't seem to be very active this year with new designs, but they continue to supply their product line to local colleges last I checked.
Anything more complex than an HC12 I think I would want some kind of kernel OS. The next step up the food chain, in our evaluation, was an Atmel chip.
Nuts, I thought the title was Home Computers for Microbrew Projects. So I am understandably disappointed with the non-beer focus of these comments.
Better I would think to start with an FPGA. I did a lab like this when I was in school - not that it was being taught in the course, just that I was bored with the labs so decided to make my lab reports more interesting. Take an adder (in my case it was an actual 74181) and show how it's incorporated into a "real" CPU. Then counters, memory, etc. You can introduce it a module at a time, build a lab project around it (like wiring the FPGA as a basic adder and flipping switches on the workbench) then use it as part of the next project to make a more complex ALU. Keep going piece by piece and you've not only made everyone relatively comfy with a soldering iron and proto boards, you've also prepared them for senior classes and CAD tools.
There's a bazillion premade CPUs on the market now that have several on chip peripherals. But every one of them in low quantity is relatively expensive at $20 or more. Why not just spend that on an FPGA (or even twice that) and teach some skills that will help qualify students for something better than "skilled labor" assembly line work?
Many of the current MCUs are ball grid array (BGA) devices, which make them pretty hard to work with if you're not a professional, but a few can be had in PLCC or QFP packages, which means you can get an adapter board or socket.
You can also buy preassembled demo/development boards (this is the route I'm taking) and wire-up anything the board doesn't include by hand. Most of the MCUs on the market will have 32-bit memory busses (though they may not support more that 25 or 26 address lines), so you can attach just about anything you want to them.
This is exactly the kind of thing that Steve Ciarcia (of Ciarcia's Circuit Cellar) used to do: building personal computers from microcontrollers. Most of his designs used Z80 based devices, which was fine back in the mid- to late-eighties. Now, however, you can do a fair bit better.
As for speed, I don't know exactly what you're looking for, but the ARM devices can be had in speeds from 50MHz to 400MHz, and the same is true of the PPC and MIPS devices. That may not seem like much, compared to a 2GHz Pentium, but it's really quite nice.
Some good resources: Digi-Key is a reasonable source for all sorts of parts, Atmel makes some nice MCUs, programmable logic, and Flash RAM, Cirrus Logic makes some ARM MCUs and networking chips (amoung other things), Sharp, Samsung, Motorola, and AMD all make nice MCUs, Cogent Computers builds some nice development boards, and EarthLCD has good prices on LCDs and has an ARM based board in the works.