Electronic – How to build a custom laptop computer with original chassis, keyboard, etc?

I started learning a PCB designing software and successfully made a working PCB prototype containing two Arduinos, RTC, external EEPROM, RF module and some other components on a single board all within two weeks.

This is how I did it:

Selection of PCB designing software - I chose Eagle because:

• It's free but with a limited board size (not a big deal for most of the hobby projects)
• Huge community support as compared to other softwares (because it's free)
• Most of the open source hardware schematics and board layouts available in Eagle format. Ex Sparkfun releases eagle schematics and layout. Arduino available as well.
• Learning was quite easy.

What electronics concepts to learn: As you mentioned, you are a software guy, you need to do a little reading before you start developing complex projects. This is necessary and it'll pay off.

• Power regulators - Here you need to learn about linear regulators and switching regulators. Which one to use and when.
• Decoupling capacitors and their proper placement on a PCB.
• Diodes and their uses - Voltage clamping, reverse polarity protection etc.
• Pull up and pull down.
• Filtering capacitors.
• Benefits of having a good ground plane. (I underestimated it once. Paid the price.)

What software concepts to learn: Obviously you need to learn most of it to make a PCB. But here I'll highlight some concepts you should know even if you don't need it in your first project. This will come in use at some point for sure.

• How to make a component on your own.
• How to make a custom library.
• Copying symbols and packages from other libraries to your library.
• How to use ULPs. In eagle, there are ULPs to automate some tasks. I haven't explored much but I have used one which extracts all components from any schematic and dumps them into a library so that you can use it in different projects. That's how I got Atmega328p. I was unable to find it in default libs so I extracted it from Arduino's schematic.
• How to make a logo - You might like to have a custom logo on your PCBs.

Production part:

• Once you are done with your schematic and board layout, you need to export Gerber files to be sent to the production houses. It contains all the info in a numeric form which can be understood by their machines. Eagle will do it for you. Find this in Cam processor section. Sparkfun provides a Cam job file but don't hesitate to modify it to suit your needs.
• You need to select a PCB thickness and copper layer thickness. For low power, 1-2 mm PCB with 35 microns of copper will do the job easily. You can also specify the mask color if your production house allows you to.
• Most of the production companies provide prototyping of PCBs. This is costly but there doesn't seem to be an alternative. They will charge you more if you want it to be delivered quickly. Make sure you talk to 5-10 production houses before selecting one. Their prices vary wildly. In my case, one was asking 10 times the price quoted by the other. No kidding.
• Component selection - Through hole or smd? Both have their pros and cons. SMD will allow to make compact and neat boards but they are relatively difficult to solder on your own. However if you select relatively larger footprints (1206 or so), it shouldn't be that hard. For a start, I'd suggest through hole components. Pretty easy to handle.
• Verifying your Gerbers: Before you send the gerber files for production, you can verify them by using softwares available for free. I use GerberLogix.

Tip: Before sending your first board for production, post the schematic and board layout on forum so that you can get suggestions/opinions from people who are experienced in this field.

Yes, many people have built many systems from a bunch of hardware modules, each system leaving out the modules that have functions not necessary for that system.

Most systems are divided up into several PCBs, with non-standard ad-hoc interfaces between the boards. Very often "sensitive analog stuff", "noisy high-speed digital stuff", and "noisy power supply stuff" are put on 3 different boards, often in 3 different boxes. (For example, cell phones with analog stuff in the Bluetooth headset, high-speed digital stuff in the handset, and power supply stuff in the wall-wart charger).

There are already several (alas, incompatible) standardized systems of hardware modules. In no particular order (and with widely varying amounts of functionality and connector costs):

• PC/104
• Bug Labs as mentioned by Joby Taffey
• the JeeNode Arduino-compatible board and JeeLabs modules that plug into it: a b c d
• R-Dev-Ino stackable Arduino compatible board
• PlugaPodS
• gumstix packs
• DIP chips and breadboard-compatible plug-in modules: the 74HC00 series and many (but alas, not all) microcontrollers come in DIP packaging, such as many 8-bit and 16-bit microprocessors from Atmel, Microchip, Freescale (formerly a division of Motorola), Cypress, and the 32-bit Parallax Propeller. Combine these with solderless breadboard or stripboard or other prototyping boards.
• "pass-through 40-Pin OOPic expansion connectors"
• the Freescale Tower System
• Modular interface extension (MIX) stacking and communications interface
• VMEbus
• STEbus
• CompactPCI
• GPIB IEEE-488
• virtual cogs (they used to have some interesting parts at Sparkfun ?)
• I've heard rumors of a "Stackable USB" (?) (USB is smaller and faster than the ISA bus used in the original PC/104)

If you are lucky, then perhaps one of the above systems will be adequate for your needs -- you can use off-the-shelf hardware for your system, and only design a few boards for functions that are not available off-the-shelf -- at least for the first prototype of your system, even if you end up custom-manufacturing every part of your system later.

While the abstract idea of "modules" is very useful in both hardware design and software design, hardware modules have some annoying differences from software modules:

• connectors cost money. enclosures cost money. So once I have a block diagram of all the parts I need for a system, it's tempting to cram everything onto one or two PCBs so I can use a slightly smaller, cheaper enclosure, and avoid paying for a bunch of connectors.
• In hardware, everything happens at the same time. This can create problems that are difficult to debug by people are used to serial software.
• Connecting two chips on two separate boards with a connector between them usually has worse EMC than than the same two chips on one big board with only a short trace between them.
• Putting a small memory on each module sounds like a good idea. That memory can hold (a) a short unique ID number for the module, and perhaps (b) hold information about the module, like Autoconfig, PC Card CIS, PCI configuration space, Display Data Channel, etc., and perhaps going further an (c) store some executable "device driver" code -- preferably in a processor-independent language, like Open Firmware, rather than in raw executable code for one particular processor, like some other kinds of option ROM. Alas, the temptation to save a few bucks by getting the same number of bytes of memory in one "big" memory chip for the entire system -- rather than one "little" memory chip per board -- often seems overwhelming. Also, you have the dilemma of either (a) reprogrammable memory such as Flash -- which risks erasing a module's local storage; or worse, re-programming it with the wrong stuff, or (b) one-time-programmable memory -- which risks sending out a bunch of hardware with a bug in that memory that is expensive to fix.
• Hotplugging -- worth a separate question. It's much simpler to design a system that is only intended to plug and unplug modules while the power is off. Just one of the many issues involved in getting hot-plugging working right is Best options for limiting input ringing with ceramic capacitors .