This is the Raspberry Pi board, an ARM based GNU-Linux computer. We’ve heard a little bit about it, but it recently garnered our attention when the machine was shown running XBMC at 1080p. That’s a lot of decoding to be done with the small package, and it’s taken care of at the hardware level.

Regular readers will know we’re fans of the XBMC project and have been looking for a small form factor that can be stuck on the back of a television. We had hoped it would be the BeagleBaord but that never really came to fruition. But this really looks like it has potential, and with a price tag of $35 (that’s for the larger 256MB RAM option) it’s a no-brainer.

Now there’s still a lot of rumors out there. We came across one thread that speculated the device will not decode video formats other than h.264 very well since it uses hardware decoding for that codec only. We’ll reserve judgement until there’s more reliable info. But you can dig through this forum thread where the XMBC dev who’s been working with the hardware is participating in the discussion.

Don’t forget to peek at the demo clip after the break too.

[via Reddit]

Here’s something we thought we would never see: computing with just pipes, /dev/zero, and /dev/null.

As a thought experiment, [Linus] imagined a null byte represented an electron. /dev/zero would have an infinite supply of electrons and /dev/null would make a wonderful positive power supply. With a very short program (named mosfet.c), [Linus] can use Linux pipes to control the flow of electrons between /zero and /null. [Linus] used mosfet.c with a very short shell script to create a NAND gate. From there all bets were off. He ended up creating a D flip-flop, 4-bit adder and a counter.

From a bit of cursory research, Linux has a maximum pipe capacity of 1,048,576 bytes and the maximum number of PIDs is 4,194,304 (correct us if we’re wrong). [Linus]  can theoretically build some of the classic CPUs of the 70s and 80s with his pipe logic. An Intel 486 is just out of reach, though. If you give someone a NAND or a NOR they’ll eventually build a computer; we thought we’d never see this, though.

Regular reader [MS3FGX] recently wrote a guide to compiling OpenWRT from source. You may be wondering why directions for compiling an open source program warrant this kind of attention. The size and scope of the package make it difficult to traverse the options available to you at each point in the process, but [MS3FGX] adds clarity by discussion as much as possible along the way.

OpenWRT is an open source alternative firmware package that runs on may routers. It started as a way to unlock the potential of the Linksys WRT54G. But the versatility of the user interface, and the accessibility of the Linux kernel made it a must-have for any router. This is part of what has complicated the build process. There are many different architectures supported and you’ve got to configure the package to build for your specific hardware (or risk a bad firmware flash!).

You’ll need some hefty hardware to ease the processing time. The source package is about 300 MB but after compilation the disk usage will reach into the Gigabyte range. [MS3FGX] used a 6-core processor for compilation and it still took over 20 minutes for a bare-bones distribution. No wonder pre-built binaries are the only thing we’ve ever tried. But this is a good way to introduce yourself to the inner workings of the package and might make for a frustrating fun weekend project.

[Andrew] was getting ready to print out an assignment when his Samsung printer suddenly started blinking a red error light at him. Unable to find any documentation explaining the issue, he called Samsung directly and found that it was indicating the toner cartridge was nearly empty.

He held down the button that prints a test page, which came out just fine despite the printer’s insistence that there was not enough toner left. Annoyed at the fact that he felt Samsung was trying to strong arm him into buying another pricey toner cartridge, he looked for a way around the restriction.

He discovered that his printer’s software allowed him to specify a custom test page document, though it required that the document be in PostScript format. After a few shell commands, he had his document converted and was on to bigger and better things.

While a bit time consuming, his workaround should let him get by on this toner cartridge at least for a little while longer. We imagine that since he’s using Linux, the process could probably be scripted to save time, though we’re not sure if the same can be said for Windows-based PCs.

[Oliver] had an old NES controller laying around, and without any other use for it, he decided to repurpose it as a portable storage device.

He gutted most of the controller, removing the plastic standoffs, leaving the D-pad and remaining buttons intact. He crammed a 32 GB flash drive inside, along with the guts from an SD card reader. Using a Dremel he cut several openings into the controller, one for the flash drive and SD card reader’s USB ports, as well as for the SD card itself. When the physical modifications were finished, he installed a small Linux distro on the flash drive, which can be run by any PC that supports booting from USB.

While some might argue, we think it’s a neat way to reuse an old gaming peripheral that he might have otherwise thrown out. The portable OS is something that would certainly come in handy, though we can’t wait until the Raspberry Pi is finished – it would be awesome to have a complete computer packed in there too.

Yes, the Kinect is over one year old now, and after some initial unhappiness from [Microsoft], it’s become a hacker’s best friend. [Eric] decided to celebrate this with an Article all about how it works.  If you’re new to this piece of hardware and want to get into working with it, this should be a good hacking introduction.  If you’ve been reading [HAD] lately, you will have noticed this information being used to “build a Kinect bot for 500 bones.”

Some interesting facts in this article include that the Kinect measures 307200 distance point, known as a “point cloud” in the gaming area. From this, it’s able to construct a 3D image of the environment around it and allow interaction. Such interesting hardware didn’t take long to hack after Adafruit announced a $3000.00 bounty to open it up to the masses.  This only took four days to do, making one wonder why, with their incredible resources, [Microsoft] wouldn’t either more effectively lock it down or officially open it to be hacked and modified to begin with. Our vote would be to officially open it up, but no one consulted us on the decision.

Some hard work has gone into making it possible to develop for the STM32 Discovery board using a Linux system. The board boasts an ARM Cortex-M3 processor, which can be programmed via the mini-USB port on the side. But the company only supports development through their IDE’s which don’t run natively on Linux. The stlink project aims to solve this, providing a toolchain, and making it possible to flash the microcontroller via the USB connection.

The github project linked above also includes a tutorial to get you started (pdf). In addition to a walk through on compiling the software packages, it includes a simple blink program that you can use to test out your hardware. GDB, the familiar open-source debugger, is used to flash the chip. This is a bare-bones tutorial so if you end up posting about your experiences using this toolchain with the Discovery boards we’d love to hear about it.

[Thanks Texane]

Do you have a rooted Android device and a computer running Linux? If so, you’re already on your way to coding for Android in Assembly. Android devices use ARM processors, and [Vikram] makes the argument that ARM provides the least-complicated Assembly platform, making it a great choice for those new to Assembly programming. We think his eight-part tutorial does a great job of introducing the language and explaining how to get the development tools up and running. You’ll need to know some basic programming concepts, but from what we saw you don’t need any prior experience with ARM or Android.

So why learn Assembly at all? We took a stab at Assembly for AVR a few months ago and really learned a lot about the hardware that we just never needed to know writing in C. It’s a great way to optimise functions that waste too much time because of quirks with higher-level language compilers. That means you don’t need to write your entire application in Assembly. You can simply use it to streamline hairy parts of your code, then include those Assembly files at compile time.

The “cheap” and “easy” way in about an hour! A question that pop’s up from time to time is “I somehow ended up with an archaic old laptop / computer, can it run Linux?” Well of course it can, but that totally depends! On what? Well machine CPU, CPU speed, hard disk space, RAM and most importantly what you are expecting it to do.

Okay, why a Intel 386? Well number one I own a 386, but more importantly its the absolute bottom Intel CPU you can run Linux on. While it wont be able to do much, it will give you a basic system to kick around and “get to know” the insides of Linux without a million things installed and the worry of breaking it.

Unfortunately a 386 requires some special moves as the actual chip was dropped from almost all distributions long ago. All of the modern distributions I have looked at require at least a 486 CPU. This tutorial will be strictly for installing a basic bare bones Linux on a 386. Have a 486? Pentium? Faster? Never fear I will be covering that in a part II later this week.

Linux on a 386 in about an hour? Madness you might think, it probably takes Linux longer to boot on a 386 (and in some cases you are correct)! Want to know the trick? Simple, cheat!

Join me after the break for the parts and steps needed to get you started.

First we need a target machine, here is mine. It is a DEC PC325SL, which translates out to intel386SL (which is a 386SX CPU in a highly integrated package where much of the support hardware is also inside the chip) running at 25Mhz with 4MB of ram and 120MB of hard disk space. It also has 256K video memory and 640×480 color VGA display. If you can swing it, a 386DX CPU or a 386S(X/L) with a 387 math co-processor is recommended, no it doesn’t really matter if its an Intel, AMD, etc. It also needs an IDE disk up to 2G, sorry MFM drives.

Next we need a distribution that will actually work with a 386 CPU. This is where it gets to be confusing. Everyone still has a distribution called i386, but support for the 386 was dropped a while ago. I looked at some of my favorites, Debian, Slackware, FreeBSD, and NetBSD (which I know are not Linux but hey.) Here is what I found out:

Debian stopped support with 3 so anything earlier is ok.

Slackware stopped around the same time in release 9.

FreeBSD states that it requires a 386DX, but then says most 386 laptops are ok via math emulation, but in a more current readme it states that you need a 486 (confused?)

NetBSD says it should work on all 386′s but I never made it that far.

Well of course I am not a super Linux guru, and can really only futz around without running off to a forum or a book, so I went with Debian. Originally version 2.2 as it was the newest version that machine could run, and yes in fact it did. The problem is it took over an hour to boot with a year 2000 generic kernel and when it finally did it refused to move past the package installer.

You could spend a lot of time trimming and optimizing to get it running great, but I am facing a brutal truth here, and that is the best I could run is still over a decade out of date and its going to require a lot of work. So I just simply stepped back in time a bit further to find something a bit more appropriate.

In the end I used Debian 1.3.1, which is a mid 1990′s Linux, and that’s really the point. Use whatever you like but its going to have to be pretty old or require a ton of work, which at that point you might be better off doing it from scratch.

Tools for the cheat install:

x86 compatible Host PC with an IDE/ATA port, and a standard BIOS capable of booting into DOS. I used my dual core AMD A2X2 with a nvidia chip-set so its pretty safe to say most PC’s will. It also needs an Internet connection and some form of Linux installed or booted (I use mint)

CD ROM or USB stick you can boot from with a windows 98 emergency boot disk (EBD from here on), or since MS DOS does not know how to access USB or SATA CD ROM’s, I used a old IDE drive with a 100Mb FAT16 partition on it.

IDE to 3.5 IDE pin adapter, they are cheap and handy I suggest you have one, just make sure you plug it in correctly you can kill your drive (as in magic smoke kill).

That should do it, lets get started

Step One:

Turn off your Host PC, plug in a spare IDE hard disk set as slave. To keep my self from borking my computers main drive I went ahead and unplugged it from the SATA port. Check BIOS to make sure its detected and that you are booting from your CD drive first, Insert the Windows EBD save changes and let the computer boot from the EBD.

You will see a Windows boot disk menu, choose to “start without cd rom support”. Once at the DOS prompt use FDISK to setup a 100 or so meg partition, be sure to tell FDISK no when it asks you if you want large disk support to ensure a FAT16 partition.

Exit FDISK, reboot with the EBD and use FORMAT C: (make sure that is the correct drive if you have others plugged into the system), then Eject the EBD. In my case I then plugged my SATA hard drive back in and set BIOS to boot from that disk and went on into Linux Mint, though you could leave your main drive unattached and use a live CD Linux.

I know that linux can make a FAT16 partition. I was having trouble with the EBD reading it while figuring this all out, so I just started making the partition with the OS that really needs it most.

Step Two:

Boot your Host PC into Linux, I am using (again) Linux Mint but It does not matter, it just has to be able to get on line, and mount a FAT16 partition. Point your web browser to the Debian archive and goto the following folder Debian-1.3.1/main/disks-i386/1997-10-13/

Download the following files

base1_3.tgz

resc1440.bin

drv1440.bin

linux

loadlin.exe

root.bin

and copy them to your FAT16 partition.

Optional Step:

My 386 came with 120 meg disk, That might be large enough to squeeze a basic Linux system on, but I also wanted a little room for a MS DOS partition so I upgraded to a 540 meg hard drive. Of course 386′s and other <1994 machines have a bios limitation of 1024 cylinders limiting the drive to 500 megs. This computer is even more picky limiting my choices down to 2 DEC approved drives, the 120 meg or a 240 meg (probably sold as an option). In order to use this drive so that both DOS and Linux can live happily on it, I must use a drive overlay (ick). So far I have been avoiding the use of floppies, but I do have floppies, and the drive on the machine works fine.

I found a old copy of Western Digital EZ Drive 9.03, I also used a MS-DOS6.22 boot floppy image. EZ drive is simple but even if you do not want a DOS partition, you HAVE to have one or else EZ drive will scream “no boot partition” and halt. So make at least 1 MSDOS partition at the start of the drive, even if its only a megabyte in size.

Step 3:

Remove the hard disk from the 386 and attach it to your host PC, it should be MASTER on Channel 0 and the drive with the FAT16 partition we put the install files on. should be the SLAVE on Channel 0. Enter your PC bios and find your 386′s drive, and be sure to turn off LBA. If you are using a drive overlay set your bios where it boots from the 386 drive first.

Reboot the Host PC (I disconnected my main drive for now as well), if you are using a drive overlay let it boot the hard disk first, then tell the overlay to boot from drive A, insert your Windows EBD into your CD drive and it will eventually load. If you are not using an overlay just boot from the Windows EBD. When you come up to the EBD boot menu use the arrow keys to stop the timer, then hold SHIFT and press F5 which will just dump you directly to a command prompt.

Find the drive with the linux install files on it and run:

loadlin linux root=/dev/ram initrd=root.bin

The debian installer should fire right up, follow the menus until you come to the disk partitioner. Create 2 partitions, 1 as type 82 (linux swap) at about 16-32 megs big, and the other should be set up as you like as your space. I just used the remainder of the disk and it defaulted to a linux type. Write the changes and continue on with the installer. Also be sure to use the right disk, it should be /dev/hda

The installer should continue and eventually ask you to install lilo, which is fine on the MBR, then reboot. Remove any disks still left in the Host PC and Debian should start. Now you have to go though another round of configuration questions. Eventually you will get to the dselect package manager (which I hate). Once you figure out how to exit dselect you should still be root. Type in halt and the system should start shutting down, if you are logged into your user account you need to use su and enter the root password first to halt the machine.

Step 4:

Once everything is down, remove your 386 drive from the Host PC and place it back into the 386, with a little luck it should start up just fine. Though there is nothing but the bare basics installed, there is still a ton of stuff to check out and poke around through. Outside of reading this and getting everything prepared it should take about an hour.

Getting software packages into the machine, right now I am just downloading the deb files from the Debian archive on my mac and coping them over via floppy disks. Another option would be to use minicom and a null modem cable. If you are really lucky you can get networking going. I downloaded the entire binary-i386 folder for Debian 1.3.1 and its about 400MB, and while I am not trying to load the machine up, some things like a menu driven text editor (fte) and mouse support are nice.

Have fun and be sure to tune in for part II which involves my 8MB Pentium 90 laptop for linux after 386, you might find it surprising.

[Tiakson] just wrapped up the construction of a quadcopter which piqued our interest due to the unexpected mix of hardware he used.

A good portion of the copter is made up of the essential bits we have come to expect from a quad rotor system. Instead of using an Xbee or hobby wireless controller however, [Tiakson] opted to use an old Fonera router running OpenWRT to control the system. He wrote special software that allows him to direct the quadcopter using an HTML 5 interface, adding a few kernel tweaks along the way that enabled him to emulate I2C ports over GPIO pins.

The Fonera takes in data from Wii nunchuck and Motion+ sensors, relaying commands to the on-board PIC 16F976 microcontroller. The PIC is used to manage the electronic speed controller modules using PWM, which the Fonera could not handle on its own.

This is a great use for a old router, and the cost is obviously far cheaper than buying off the shelf wireless control modules. We would love to hear how much extra weight the Fonera adds, as well as if there is any controller lag introduced by the web-based interface.

Continue reading to see a quick demo video of the quadcopter in action.

Console hacker [techknott] has a skill set that is quite possibly second to none. We do love [Ben Heck] and think that his portable consoles are beyond awesome, but you’ve got to check out this portable GameCube [techknott] put together.

While the construction details are pretty sparse, the video below shows off the bulk of the portable ‘Cube’s best features. Far smaller than his Flip-Top GameCube or Dreamcast portables we’ve featured in the past, his new handheld sports a wider screen and is completely disc-less. While the legality of booting backup copies of games from an SD card is something we won’t delve into, we do like the concept.

The console itself is probably only about one and a half times the width of a standard GameCube controller, and while it doesn’t sport an internal battery pack, we wouldn’t turn one down. Besides, who wants to play GameCube outside? With one of these in hand, we are more than happy to keep our pasty selves indoors, thank you very much.

The only complaint we have here is the lack of build details. [techknott’s] handheld consoles are pretty amazing – we just wish that we could see how the magic was made!

Be sure to check out the video below to see the console in action.

[Thanks, Dave]

For a while now I have been battling a dying 2.6Ghz dual core computer, but due to laziness and budget I just let it ride. At first it would occasionally crash in games, then it got to where it would crash during routine activities. After a year of this it would nail 105 degrees C in like 20 seconds and that is where the drama starts!

I threw my 2ghz “electronics” computer into my main machine’s case and used that for a few months. It’s motherboard had suffered from every electrolytic capacitor on it being puffy, but it has worked fine for nearly 5 years. I was surprised by the sound of what ended up being 2 caps blowing off of the geforce 7600 video card. In shock and excitement I removed the blown caps, slapped her back in and got another 4 months out of it before 2 more capacitors blew and took out a voltage regulator (and who knows what else with it).

Only armed with the craptop, I was stuck in a pickle! Then a co-worker came up to me and said “hey man you want this mac I only want its zip drive”. Well of course, going bonkers without my avrgcc, datasheets, and calculators, I took on the 14 year old Apple Power Macintosh 9600/300 as my bench machine, and I will now show you how I turned it from a novelty relic to a daily useful machine after the break.

So the machine I bought for the price of removing its zip drive is a 1997 powermac 9600 with a 300Mhz 604e motoroloa power pc cpu, stock 64 megs and a 8 meg non accelerated video card. These sold for 4,200 bucks new.

This one however was part of an AVID system and came to me loaded with every PCI slot filled with video gear, SCSI2, and 256 megs of ram in 8 out of 12 slots (32 meg sticks). It still had its *bitchy Rocket128 8 meg video card, and luckily a Targa2000 card with VGA output.

The cards, while impressive, are practically useless. Even if I had the dongles required to run avid stuff its mid 90′s technology that eats great amounts of power. All of these double board full length heaters were removed except for the Targa2000 card because of its VGA output. I don’t have a Macintosh monitor or adapter. Regarding the Targa2000 video card, its a fine card for the era, but a card made in this century would be awesome. With this video, mac os works, 8.x is snappy but a little limited. 9 is a dog 9.2 is better but its nothing impressive, any generic pci svga card could do the same, and so video became issue #1.

Video is kind of tricky for mac, it has to have its own rom, and its 2x as large as a standard pc rom (512Kbit vs 1024Kbit), So the first thing to do is find out what cards were available as “mac editions”.

Looking at The Mac Elite Software Downloads will give you an idea of what you can use. I have a power pc machine and would like to use an original rom, so that reduces my list down to the first table. The other tables include some roms for intel based machines, reduced (in attempt to fit the large mac rom on a smaller pc rom chip) and modified which are not really supported cards, so good luck.

To install these roms you pretty much need an x86 IBM compatible machine to use the rom flash software, and your card is going to need to have that 1mbit rom. This posed a problem cause at this moment all my pc’s with pci slots are toast, and the one card I have that might work is a 9250 with a pc rom, and the only mac side updater I could find still available for download was for OSX and this mac by nature will not go past 9.04.

Moving on I started reading about the radeon 7000. It is a pretty darn fast card for this machine, I could find mac os9 rom updates and drivers for it, and you can get the PC versions all day for cheap! Traditionally people would go on a hunt for a couple brands of cards that offered both PC and Mac versions and just never changed to the smaller rom for PC use. Those cards dried up pretty quick and if you see one now its going to cost an arm and leg (a 10 year old mac edition card used is like 40 bucks new around 100!).

During my search for software (ATI mac drivers went bye bye when AMD came in) I ran across an old site where dude grabbed any old pc 7000 and cut off the rom with a pocket knife and soldered a larger one in its place using a stove and a flathead screwdriver. He then proceeded to put it in his pc for the old 2 flash process but wondered if that was even needed. In fact no it isn’t! You can put a radeon7000 with a correct size blank rom in a mac and it will update it just fine.

I got online and instantly found a pc-pci version 7000 with 64 megs of ram brand new for 14.99 with free shipping. Once the card arrived I checked its rom and found it to be a nothing special 512Kbit 25×512 SPI eeprom that everyone has made at one point or another. I then dashed off to digikey and found a 25LC1024 made by microchip that would fit on the pads. Once that arrived I tried my best to do a professional job removing the chip, and yep a guy with a stove and a flathead had no problem, but I hosed the ground pad (doh!) … its nothing a little bit of 30 guage cant fix.

At this time I have a 15$ card with a 6$ (including mail) chip sitting on it and no bios. We need to correct that. First and foremost you need at least system 9.While I was waiting for all that shipping to happen I started upgrading my OS. The machine came with OS8.1? and I had a OS9.04 on a CD, which is the max this machine will take without some fiddling. MacOS9.04 is dreadfully slow and every other mac application you try complains about wanting 9.1 or 9.2(the last version of classic OS). Thankfully some people have sat down and cracked this problem in a program called OS9 helper. Using this program and the update disk images (US English available from apple, but I found a set for the international crowd too) you’re just a hop skip and jump away from 9.22 and the latest ATI drivers for a 7000 and much more!

Now we are ready to finish up that ATI card, insert the card into a unused slot, I wont remove the working video card yet. Then I fired up the mac and downloaded R7000-ROM-208.hqx and ati-retail-9-2-2-jan2005.hqx. Decoded and extracted both, ran the rom updater first. This will bring up a little ui asking if you want to update. It should only take a few moments to flash the blank rom and when it says that it is good. I am now ready to remove the old Targa2000 card and install the drivers.

This R7000 makes a HUGE difference in classic mac OS, where as before you could almost watch the Targa card draw windows, and Classilla (a mozilla browser for mac os9) was scrolling web pages about as my 386 would, I am now in a land of accelerated 2D and 3D graphics, Classilla is pretty useable and the computer plays a pretty mean game of Quake3 Arena @1024×768 all options cranked, but the issue is OS9.22 is very old in computer terms, software support is long gone and its still pretty slow just from its age. Besides what if I want to program my avr’s? Or get to a datasheet that is buried behind some java script? Really for this thing to be useable it needs a modern OS, something light but easy and can run on a Power PC cpu, with a ton of tools and programs, something Like Debian PPC…

I downloaded the newest version of Debian PPC as a 200 meg small CD. There are full cd’s and DVD’s but this one gets what you want off the net so its more practical for me. In order to boot linux on what is called a “Old world Mac” you need a bootloader and a place to install your distro. The main bootloader that works on these old machines is called bootX (linux). It is old and unsupported but works like a charm. The down side to it is you need to at least partially boot into OS9 first, so yeah, you have to keep OS9 around, even if its a tiny install.

As far as a place to install my copy of linux, I have a 9.2 gig SCSI (all the drives are SCSI in this old of a mac) that came out of a PC. Unfortunately, yes macs are a pain in the butt about hard drive’s too, and require that they also have a apple driver loaded onto them before the machine can use it. In the past you needed to use tools like “Hard Disk Toolkit”, which were commercial packages, that do just an OK job. Luckily people have patched apples own drive tools so you can initialize partition and format any drive. These tools do not like my install of OS9.22, so in order to use them, I had to use an OS8 boot disk.

I don’t need to partition and format the drive that linux is going on, but it does need its driver “updated” and initialized, which spatters data onto some special partitions so the computer knows what the heck you’re talking about later when you’re asking it to access the drive. In my situation the linux partitioner would not even see the drive until it been initialized.

I have a boot loader, and I have a decent enough disk to put linux on without killing my OS9 fun drive, so lets get this CD spinning! I extracted the bootX bootloader onto my desktop. Inside the folder is the application, a folder for linux kernels, and a system extension so when you’re done you can set it up where you dont have to go all the way to the OS9 desktop first before starting linux. I put the Debian CD into the drive and copied off the vmlinux and initrd from the install\powerpc folder to the bootX linux kernels folder. Start up bootX and point the kernel selection to the vmlinux off of the Debian PPC linux disk, and then point it to use the initrd ram disk also from the CD and click linux.

Sometimes if the CD was not in the machine at boot it will try and lock up. Just reboot and try again. Otherwise you should be greeted by the usual linux text chatter, then eventually launched into a basic text based installer. Simply follow the menus for the most part. When you arrive at the partitioning section it does not really matter how you partition the disk, just keep in mind to not wipe your OS9 partition or any partitions from the Apple disk drivers. So any option except use entire disk is probably safe. Also at this time it is wise to write down where the different linux partitions are, I have a boot partition at /dev/sdb7 and a root partiton at /dev/sdb8, though really I should have just stuck it all in one partition as the boot partition does not really do anything.

This is the trickiest part of the install. Debian will try to install another bootloader. You might get lucky and it might work. I have tried on a half dozen machines over the years and I have not gotten it to work, and it did not work this time either. That is fine just ignore it. The trick is to get the now customized linux kernel and ramdisk from my boot partition to my mac OS partition. Most tutorials on installing Debian on a “old world” machine say “just mount it and copy”, some even suggest using a apple prodos partition but never mention how to mount it … This install of Debian had no clue what a HFS+ disk was and I tried a dozen different ways to get it mounted or copied over. In the end the final part I needed for my main desktop computer had made it in the mail so I just gave up, used a PC SCSI card and linux on my PC to copy the 2 files off of the drive and just emailed it to myself on the mac.

Now that I have the boot files for my machine I just point bootX to use those, tell it where my root drive is, and within a few moments I am sitting at a nice little login prompt. A few apt-get installs later I was starting to build up my software. I had chosen, in the installer, to just give me a basic command line machine, if I had chosen “gui desktop” then I would have been loaded down with GNOME and a bunch of stuff I did not want or need on this machine, so I choose to install it myself. I ended up with xorg as a display server and XFCE as a desktop manager. Overall its pretty darn snappy for a 14 year old computer if you let an application or webpage load before messing with it, and over the month or so I have been using it near daily I have been happy and impressed with its performance.

Here is a short video of it coming up from a cold boot, into OS9 then into bootX, then into console linux into XFCE, which loads up a gecko browser, pdf reader, task manager, IDE, terminal and file manager along with all the desktop stuff in a reasonable amount of time. Sure its not going to break any speed records, but if you had to be stranded with this computer you would live quite comfortably. As far as its retro appeal goes, this machine is able to boot as low as macOS7 so you can get a ton of retro ware running on it, and was one of the very last models that was able to read and write Apple’s funky 800k DD floppy disks which is invaluable for my mac SE. The fact that I was able to keep it around as a cool old mac to poke around with and make it something that can be productive in my electronics work with near daily use makes this machine worth the hassle and the zip drive.

[Nathan] had an small router kicking around and thought that he might as well put it to good use. He had always been interested in getting a better handle on his espresso machine, and figured that the router would be a perfect Linux-based PID controller.

He installed OpenWRT on the router, then disassembled it in order to get access to the router’s GPIO pins. He built a small PCB that allows him to get temperature info from the machine to the router using i2c. [Nathan] put together a PID package for OpenWRT, allowing him to control the machine over SSH, though he may build in a user-friendly web interface sometime in the future.

He says that most espresso machine PID controllers he has seen come in the form of big ugly boxes slapped on the side of the machine’s case, though we have to disagree with him on that point. Opinions aside, he is going for a minimalist design, and while he says that he is only about half way through the project, we think things are looking promising so far.

When everything is said and done, we hope to get a much closer look at all of his code, schematics, and more information on the router he used as well.

[David Revoy] recently picked up a brand new Cintiq 21UX, and while he liked the drawing pad overall, he was less than impressed with the tablet’s buttons. He says that most 2D linux apps require a good bit of keyboard interaction, and the built-in buttons just were not cutting it.

After seeing a fellow artist use a joypad to augment his tablet, [David] thought that he might be able to do something similar, but he wanted to add a lot more buttons. He dug out an old Logitech game pad that was collecting dust, and disassembled it, rearranging some buttons in the process. Once he was happy with the layout, he built a cardboard enclosure for the PCB and hooked it up to the Wacom via USB.

He spent a few minutes mapping buttons to key presses using Qjoypad, and was up and running with an additional 14 buttons in short order. He says that the extra buttons make his job a ton easier, and add a little bit of comfort to his long drawing sessions. We like the fact that it is a non-permanent fixture, and that he was able to repurpose an old game pad in the process.

Check out the video below for a quick demonstration of his drawing pad hack.

[via Adafruit blog]

The Linksys router seen about is a WRT54G version 1. It famously runs Linux and was the source of much hacking back in the heyday, leading to popular alternative firmware packages such as DD-WRT and Tomato. But the company went away from a Linux-based firmware starting with version 8 of the hardware. Now they are using a proprietary Real Time Operating System called VxWorks.

[Craig] recently put together a reverse engineering guide for WRT54Gv8 and newer routers. His approach is purely firmware based since he doesn’t actually own a router that runs VxWorks. A bit of poking around in the hex dump lets him identify different parts of the files, leading to an ELF header that really starts to unlock the secrets within. From there he carries out a rather lengthy process of accurately disassembling the code into something that makes sense. The tool of choice used for this is IDA Pro diassembler and debugger. We weren’t previously familiar with it, but having seen what it can do we’re quite impressed.

[Image via Wikimedia Commons]