As I look at the documentation page for the BLE112 (Bluegiga's Bluetooth LE module), I am reminded of how complex computing has become. There are videos, spec sheets and software guides (well over a dozen documents not including slick sheets and qualification documents). All of this for a small embedded device that uses and 8051. This is all "high level" documentation. At the end of all this you can develop your BLE112 comms using an API or their own scripting language.
I understand the complexities involved and why there is so much documentation. But that isn't all: Add to that all of the Erlang OTP stuff I am planning on doing on the server side. There is lots of documentation; lots of "other people's stuff" I need to master.
Sometimes I "ignore the wheel". This is like "re-inventing the wheel" but tends to avoid the actual construction of a wheel itself. "Ignoring the wheel" is about coming up with your own means of transportation.
Rather than use a mainstream approach, I roll my own solutions. This usually means ignoring an already written body of software (libraries), but when I start from scratch, I intimately understand everything I am working with. I *have* to intimately understand everything I am working with.
Now, one trade-off that must be made for "ignoring the wheel" is that you have to get creative with your resources.
Let me propose an example:
Building a (pro quality) Data Logger the size of your thumb. Now, this data logger must read some arbitrary sensor every 10 seconds and log it to persistent storage until it is later pulled off of the device and analyzed later on a PC. It must be able to capture tens-of-thousands of short (10 bytes?) log events. The whole thing (case and battery included) should be about the size of your thumb.
How would you approach designing it? (Remember, this should be a "pro quality" logger, not a toy -- it must work flawlessly.)
Linux on an ARM? Small, but probably not small enough and I doubt you could run it off a small (coin cell size) battery -- power consumption is an important factor here.
Okay, maybe something Arduino-like. Or maybe a PIC, or even a Silabs 8051. You want something tiny that uses very little power. The tiny MCUs tend to have less RAM and Flash program space, but this is just a simple data logger, right?
Now, what about the log storage medium? A microSD card is small. Plus, you can take it out and plug it into your computer to dump the data. This sounds great.
So, you go with a microSD. Now, of course you'll have to format it as FAT16 or FAT32 to make it readable by the PC (besides there are plenty of FAT libs for MCUs out there, right?).
Now you have a problem: FAT is simple, but still requires choosing a library and getting it to compile. Plus, you'll need (at least) 512 bytes of RAM to hold sectors/buffers. You did pick an MCU with more than 512 bytes of RAM right?
Is the FAT implementation reliable? Is it rock solid? Can you trust your important logs to it?
Now, how do you arrange the logging? Will you exceed the maximum FAT file size? How do you name the file?
Remember the original goal: You are building a data logger, not a database.
Okay, you get the picture. For hobbyist needs, a simple logger (like
OpenLog) fits in a pinch. But things start to get complicated when you consider reliability and longevity.
How can we simplify this design?
First, do you really need FAT? Can you develop a custom "log system" that writes to the "raw" microSD and develop a reader on the PC side? Do you really need the flexibility of a "file system". Consider this: Figure out the max size of a log entry (typically a logger works with structured sensor data: GPS, environmentals, etc). On a 2GB microSD you can fit around 10 million 20 byte logs. Is that adequate?
Second, do you really need a microSD? What if you used a serial Flash storage chip? Maybe one that doesn't require 512 byte RAM buffers for sector writes. Atmel makes a family of serial flash chips that have "on board" pages that you can randomly access before committing to sectors.
Maybe you can pull the data off serially with a cable, or maybe via wireless?
Here is an interesting observation I've made about "Ignoring the wheel" in my own designs: It reinforces the XP tenent: "
do the simplest thing that could possibly work". Because I deal a lot with anemic microcontrollers (8051) and minimalist languages (Forth), the ordeal of supporting FAT on a microSD makes me question whether or not it is "needed" to log a bunch of data as quickly and reliably as possible.
If the customer says I need to use a microSD, okay. But what exactly are they expecting for the FAT support? Could something like this (
http://elm-chan.org/fsw/ff/00index_p.html) work? It only supports 1 fixed size file at a time, but it is very simple. Essentially, all I would need for a data logger is "write" capability to the filesystem. Why have a full FAT implementation on a tiny (write only) logger?
Can I ignore the wheel and simply do something simple?
