"Imagination is more important than knowledge!".Albert Einstein
mercredi, mars 28, 2012
Linux on an 8-bit micro!
It is common to see newbies asking in microcontroller forums if they can
run Linux on their puny little 8-bit micro. The results are usually
laughter. It is also common to see, in Linux forums, asked what the
minimum specs for Linux are. The common answer is that it requires a
32-bit architecture and an MMU and at least a megabyte of ram to fit the
kernel. This project aims to (and succeeds in) shatter(ing) these
notions. The board you see on the right is based on an ATmega1284p. I've
made one with an ATmega644a as well, with equal success. This board
features no other processor and boots Linux 2.6.34. In fact, it can even
bring up a full Ububntu stack, including (if you have the time) X and
gnome.from here
RAM
Yes, it is true that a full Linux install requires megabytes or RAM
and a 32-bit CPU with an MMU. This project has all of that. First let's
address the RAM. As you can see, there is an antique 30-pin SIMM memory
module on the board. These were in use for 80286-based PCs. It is
interfaced to the ATmega, and I wrote the code to access it as well as
refresh it within spec (SDRAM requires constant refreshing to avoid
losing data). How fast it is? The refresh interrupt happens every 62ms
and takes up 1.5ms, thus eating under 3% of the CPU. RAM is accessed,
for ease of programming, one byte at a time. This results in a maximum
bandwidth of about 300 kilobytes per second.
Storage
With the RAM requirement put to rest, we have two to deal with.
Storage is not too difficult a problem to solve. SD cards are quite easy
to talk to using SPI, and my project does that. A 1GB SD card works
fine, though 512Mb would be enough for this particular file system
(Ubuntu Jaunty). The ATmega does have a hardware SPI module, but for
whatever reason, it didn't quite work out, so I am bit-banging the
interface. It is still plenty fast - about 200kilobytes per second. This
also adds a nice touch to the project - it can be done on any
microcontroller with enough pins - no hardware modules are used.
CPU
All that's left is that pesky 32-bit CPU & MMU requirement. Well
the AVR has no MMU and is 8-bit. To conquer this obstacle, I wrote an
ARM emulator. ARM is the architecture I am most familiar with, and it's
simple enough that I could comfortably write an emulator for it. Why
write one instead of porting one? Well, porting someone else's code is
no fun, plus none of the emulators I saw out there were written in a way
that would make them easy to port to an 8-bit device. One of the
factors: AVR compiler insists on making ints 16-bit so something as
simple as "(1 << 20)" will get you in trouble, producing zero.
Instead you need to do "(1UL << 20)". Needless to say trawling
someone else's unknown codebase looking for all places where ints are
assumed and would fail would be a disaster. Plus I wanted a chance to
write a nice modular ARM emulator. So I did.
Other features
The board's communication with the real world occurs over a serial
port. Currently it is attached to a serial port on my PC running
minicom, but it is fathomable to instead connect a keyboard and a
character LCD to the board, making it entirely standalone. Two LEDs
exist on the board as well. They signal SD card access. One for read,
one for write. A button is onboard too. When pressed and held for a
second it will spit out on the serial port the current effective speed
of the emulated CPU. The AVR is clocked at 24MHz (a slight overclocking
over its stock 20MHz)
Aucun commentaire:
Enregistrer un commentaire