Well that’s… interesting. Baffled, she brings it to me. I inspect the box and notice the lithium-ion warning on the bottom. After a moment of trying to figure out what in the world it could be, I remembered the ChromeOS pilot program form I submitted no more than a week earlier. Thanks, Google!

In the last three days, I’ve been doing my best to include the CR-48 ChromeOS notebook into my day-to-day life. It’s really such a handy companion. The 12″ form factor and super lightweight design makes it easy to lug around with you everywhere. It’s thin, minimal, and does exactly what it’s supposed to. The roughly 13-second boot-up time and a hair over 1 second wake-up time means the CR-48 (Mario) will be at your beck and call at a moment’s notice. I can get to the web faster by waking up the CR-48 than I can by waiting for my Android’s web browser to load, and that’s impressive. Did I mention roughly 10 hours of battery life? Especially on the cusp of utter battery failure in my Dell Inspiron (with a mind-blowing 10-15 minutes of battery life), the CR-48 has reopened the doors to anytime quick access to a computer. I don’t have to worry about hunting for a power cord.

The hardware is impressive for a test platform. The keyboard feels great, screen resolution is impressive (higher than my 15″ Dell!), and the integrated microphone and webcam are a nice addition. I’ve heard this thing has bluetooth, but there doesn’t seem to be a way to utilize it in the OS yet. The touchpad is almost identical in size to the Macbook touchpad’s area and features only a single clicking button nestled below the touchpad’s flush surface. On the left edge, the CR-48 notebook features only a VGA port, a vent, and the left speaker. On the right resides the charging port (would have preferred this on the back), USB port, headphone jack, MMC/SD card slot, and the right speaker.

The CR-48 isn’t without it’s problems, however. Although very light and thin, it can feel somewhat flimsy. Every time I use the tap-to-click on the touchpad, there’s an unpleasant “thud” as the case impacts the internals. A few extra screws and maybe a mil or two thicker materials aught to solve that easily enough though. The touchpad itself is also a nightmare. The area above the touchpad’s button is motion sensitive. Imagine laying your finger flat on any laptop touchpad, then roll to the tip of your finger without lifting up; the cursor will move. That’s what happens on the CR-48 when you depress the button. Dragging and/or selecting groups of things is equally painful at times as the multi-touch results in a jumpy cursor and if you’re not careful, resting an extra finger on the touchpad renders it useless. The display also seems far too cool and the contrast is washed out on all but the brightest settings which can strain your eyes indoors. Considering this is what you’re looking at the whole time you’re using it, some improvement on the display would be a godsend.

What about the software? I think I’ll wait for another blog post to go further in depth on that subject so I can better elaborate. I already expressed my concern that Google’s lineup of web apps aren’t ready for the concept of ChromeOS, so I’ll revisit that idea later. Keep an eye on my Google Chrome OS Notebook set on Flickr as I update it with notable shots as I discover new things.

I do most of my development in Chromium, but noticed when I was testing my code for the new JSON responses, data wasn’t showing up properly in Firefox. I didn’t think much of it and figured I would return to the issue once I could focus on browser compatibility. I eventually, however, found myself at that point in development. I discovered that returning only a sliver of the normal response data lead Firefox to respond properly. I also found Chromium was hitting it’s own, significantly higher, limit. Firefox was capping the JSON response at 4096 bytes, whereas Chromium was somewhere in the area of 305kB. The Chromium limit was practically reasonable for my application, but there was no way I could dodge Firefox’s measly 4kB cap. But wait, there’s no way Firefox limits all AJAX responses to 4kB, right? Gmail can’t possibly operate on an army of tiny 4kB responses, so what am I doing wrong?

Courtesy of Firebug, I compared responses and noticed something peculiar, my server’s JSON responses contained the entire data contents in the headers of the response itself. After some Googling, it seems response header fields have a size limit. In Firefox that limit is, you guessed it, 4096 bytes. As I found, CakePHP’s automatic handling of JSON extensions takes the view variables and places them directly in the headers. Not only that, but my JSON views were returning the json_encode()’ed result of my data, so the response contained the same data in two places. Without much time available for finding a proper way to make Cake stop adding data in the headers, I decided to go back and do it the ol’ fashioned way, by myself. I got rid of Cake’s router line for Router::parseExtensions(‘json’); left my controller action alone, and changed my view to:

<?php
$this->layout = 'ajax';
Configure::write('debug', 0);
header('conten-type:text/x-json');
header('cache-control:no-store,no-cache,max-age=0,must-revalidate');
echo json_encode($results);
?>

And with that, both Firefox and Chromium now accept responses greater than 4kB and 305kB respectively. I’m still sprinting to finish this project, so I haven’t had time to investigate if the core Cake team knows about this issue. I plan to revisit after project launch and see if I can learn more about this strange behavior.

Event hasAndBelongsToMany Image

And I needed to make it so that when retrieving an event, the associated Image data was sorted by a specific field. Here’s how to do that using Containable:

public function myAction($order) {
	$this->Event->Behaviors->attach('Containable');
	$this->Event->contain(array(
		'Image' => array(
			'order' => $order
		)
	));

	$event = $this->Event->find('first');

	$this->set(compact('event'));
}

Well that was easy… hopefully I just saved you from a world of hurt.

$res = ($primary)
	? &$result['MyModel']
	: &$result;

But for whatever reason, PHP fails with an “unexpected &” error after the ternary `?` operator. The ternary syntax is just a shorthand I use for a really easy if-then, so I decided to expand it and see what happens.

if($primary) {
	$res = &$result['MyModel'];
} else {
	$res = &$result;
}

This code runs without a hitch. So then what’s happening? Your guess is as good as mine. I honestly can’t discern what’s making PHP break on the ternary version. Although the ternary syntax is rather simple and can be considered synonymous to the if-then code, PHP seems to handle them differently and consequently breaks reference assignment when using ternary.

Server: Msg 8120, Level 16, State 1, Line 1
Column ‘ItemNumber’ is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause.

I found some reasoning for this online, which is all well and good, except that MySQL does this like a champ and makes life easier as a result. So off I went to find a solution for SQL Server… I eventually stumbled on a page from the SQL Authority, by Pinal Dave (a very humble guy, judging by the title of his site). The gem, however, wasn’t the post itself but a comment by Madhivanan further down the page. Thanks to Madhivanan, I came up with the following solution.

DELETE t FROM

(

select (row_number() over (partition by ItemNumber

order by ItemID)) as cnt, * from Item

) as t

WHERE t.cnt > 1

But wait, there’s more! Amazon EC2 doesn’t have hosted DNS like Rackspace. The means for real development that you don’t need a physical hosted server or third party service to host DNS for you. With Rackspace Cloud Servers, you can host an entire domain in the cloud. Everything is completely flexible to your needs and the pricing is shockingly reasonable.

I’ve wanted a VPS for years, so for me, Cloud Servers couldn’t be more promising. My current host, DreamHost, has proven to be a great shared hosting company, but their VPS solution was $25/month. It seemed reasonable, and I was tempted to switch just a few weeks ago, but if I can get a Cloud Server for $11/month, why bother? I made the obvious decision and signed up for Rackspace Cloud and have my very own cloud server running. What am I going to do with it? Who knows, but it’s awesome!

Bridgestone Potenza RE-01R tires provide oodles of grip.

I absolutely love “Extreme Performance” summer tires! Last year I put my snow tires on early after noticing the extra wear on my summer tires, hoping to save the tread for this summer. I finally got my set of Bridgestone Potenza RE-01R’s back on last night and I am absolutely floored at the difference in my car. I completely forgot the level of grip these tires provide. It is literally a night and day difference, every aspect of my car’s performance has improved. The stock alloys my Potenzas are mounted on are lighter than the snow tires’ steel wheels, so the car accelerates faster. The lateral grip blows the snow tires out of the water (comparison accelerometer log coming soon!) with an amazing improvement in steering response and highway straight-line stability courtesy of rock-solid sidewalls. But most importantly, the car now tugs at your face a bit in a hard stop.

If you’re driving a performance car without performance tires, you’re absolutely insane. It’s impossible to describe the feeling of confidence you get in the car when you can feel it so firmly planted to the ground. Imagine running around wearing bowling shoes versus a good pair of tennis shoes. That’s how drastic a difference I feel with these tires. Now I just need the money for R-compound tires…

First, let’s figure out the path to our serial device. Ubuntu typically places these devices at /dev/ttyUSB#. Use the following command to determine the appropriate number of your device.

$ ls /dev/ttyUSB*

Now we’ll install Minicom to get started.

$ sudo apt-get install minicom

Once that’s complete, we’ll need to configure Minicom so that it’s using the correct port. To do this, run the command below.

$ minicom -s

You’ll be prompted with a configuration menu. Arrow down to “Serial port setup” and press enter.

+--------------------------------------------------------+
| A -    Serial Device      : /dev/ttyUSB0               |
| B - Lockfile Location     : /var/lock                  |
| C -   Callin Program      :                            |
| D -  Callout Program      :                            |
| E -    Bps/Par/Bits       : 115200 8N1                 |
| F - Hardware Flow Control : Yes                        |
| G - Software Flow Control : No                         |
|                                                        |
|    Change which setting?                               |
+--------------------------------------------------------+

The first line will give you the path to the serial port Minicom is going to talk to. If this doesn’t match the /dev/ttyUSB# path you found above, hit “A” on your keyboard and enter in the correct path and press enter. Now double check your Bps/Par/Bits settings. The default 9600 8N1 is pretty standard, but you may need to hit “E” and provide a different Speed setting depending on the device you’re talking to. In my case, OpenLog is running at 115200bps, so I went through and made the appropriate changes. Hit enter again to exit the serial port settings menu. The other settings can usually be left to their default values, so arrow down to “Save setup as dfl” to save this configuration as default. This way you don’t have to configure Minicom every time you use it. Now arrow down to “Exit” and hit enter. Minicom will now start up using the settings you specified. If all goes well, you should now be connected to your device and ready to send/receive. From now on, you can start minicom without the -s switch.

$ minicom

Got a better HyperTerminal replacement that you use in Linux? Let me know about it in the comments.

I expect that you have the Arduino IDE installed and running properly. This means the avrdude and avr-gcc libraries necessary to flash OpenLog will already be installed. Next step is to pull the firmware source code from the GitHub repository. If you don’t have git installed, run the following command:

$ sudo apt-get install git-core

Now you can run the git command to pull the source code over the read-only HTTP path. This is generally the easiest path to use to avoid issues with proxies or closed/blocked ports on your network.

$ git clone http://github.com/nseidle/OpenLog.git

Once the command has completed, you’ll have an OpenLog directory in your currently active directory. Time to compile the source code to make the required hex file that we’ll write to OpenLog.

$ cd OpenLog/Code/

$ make

You should see several notices about compiling various .c files, linking main.elf, and most importantly loading main.hex. Now we need to get that hex file onto OpenLog. Grab your trusty FTDI breakout board (you should never leave home without it) and wire it to OpenLog as shown below.

Before connecting the FTDI to your computer, we want to make sure we have the correct device path for the next step. Look at the list of all tty-capable USB devices. It’s okay if none show up right now.

$ ls /dev/ttyUSB*

Now connect the FTDI board and run the command again. The new ttyUSB# device listed is your FTDI board. I’ll use ttyUSB0 in the command below, so you will need to change the zero if your # is different.

I hope you have an extra wire at hand. The Linux build of avrdude unfortunately doesn’t have the “DTR wiggle” necessary to automatically reset OpenLog’s ATMega328p, so we have to do it ourselves. Grab a wire and connect one end to ground. If necessary, the microSD socket’s case can be used as a ground if you don’t have OpenLog on a breadboard. You’ll need to tap the other end of the wire onto the GPIO pin 6 on OpenLog. This is the square pin pad near the “O” in “OpenLog” on the silkscreen (the bottom-left most pin in the image featured above). Timing here is of the essence; run the command below, hit enter on your keyboard, then immediately tap the other end of your grounded wire to pin 6. Don’t leave the wire sitting on pin 6, it’s just a quick tap to momentarily ground it and force a reset.

$ avrdude -p atmega328p -P /dev/ttyUSB0 -c stk500v1 -b 57600 -U flash:w:main.hex

Don’t forget to change the ttyUSB# number if necessary. If your timing was good enough, you should see avrdude show a progress bar as it flashes the hex firmware onto OpenLog. If not, you’ll likely see errors like “programmer not responding” or “out of sync”. Try try again. Tapping enter and grounding pin 6 should be almost instantaneous, with the enter key coming ever so slightly first.

After a few seconds, the updated firmware will now be on your OpenLog chip and you’ll be on your merry way. I hope this helps someone out there.

I’ve been participating in autocross events for years and have always wished I could afford a data acquisition system like those you see used in Formula 1, Indy, Le Mans, and/or NASCAR. With a DAQ, I’d be able to see exactly what my car is doing at an event and use that information to help me drive the course faster on my next run. Hopefully.

That got me thinking. Surely I’m not the only amateur autocrosser wishing for an affordable data acquisition system made for the weekend warrior. In fact, LOTS of people across the nation, and across the globe would probably love such a system. I didn’t know of any that existed on a college student budget, so I figured why not make one? It just so happens this senior design semester is the perfect time to get started. But where to begin?

I began looking at professional systems to see what they were doing so I could get an idea where to start. After looking at a few of the products out there, most of them seemed to be doing some sort of GPS tracking as well as logging all the sensor data the user needs (or can afford). I started looking into using a USB GPS plugged into a laptop and use software to track and log the position data so the user could review it later. In the midst of looking for a GPS, I discovered most of the professional units were boasting GPS units with 5-20Hz refresh rates, but the units I found were all 1Hz. Hmm, I know I want to go cheap, but it also needs to do it’s job well. I had to find something better. I eventually stumbled upon a 10Hz GPS chip that sounded like it would do the trick, but how in the world was I going to get data off a lone circuit chip? I also want to use an accelerometer to measure precise movements of the car, but USB versions were expensive. Chip-only models were vastly cheaper, but how do I connect one to a computer? Time for some more research.

That’s when I met the Arduino.

So many possibilities in such a tiny package.

I think the Nintendo was the last time I used an 8-bit processor, but I have a feeling I’m going to have so much more fun with this thing! Could your Nintendo convert an analog voltage into a 10-bit digital value? I didn’t think so.

The Arduino Duemilanove is the latest board to come from the open hardware Arduino project. The beauty of Arduino is it’s openess and ease of use. The design schematics are openly available; ready for people to adapt and improve, or to integrate directly into their own projects. The microcontrollers used also come pre-programmed with the Arduino bootloader which makes it a piece of cake to write some code, plug the board in via USB, click a button to upload the code and make it run. The Arduino drastically lowers the learning curve necessary to start using a microcontroller.

With my Arduino, the possibilities are endless. This little board has opened the door wide open to this project and should be able to handle everything a motorsport data acquisition system should need. Now it’s time to fire this thing up and see what it can do! Stay tuned.

Or maybe not. I hopped into the #Sparkfun chatroom on irc.freenode.net the morning of Free Day to check out what people were chatting about. To my dismay, hours before the event started, there were already almost 700 people in the chatroom. According to Sparkfun’s limitations on the event, only 1,000 $100 orders would be awarded. The numbers were already daunting. I pulled up the Sparkfun website to find their recently updated web servers were already buckling under the load of people preparing their shopping carts. Uh oh. As time neared 11am, the chatroom hit the 1,400 user mark and my hopes of free electronics started to dwindle.

Minutes before the event, I went to my shopping cart, and prepared to click the Checkout button on the hour. 11am struck, my finger punctually tapped the mouse button, and my order request was on it’s way across the ‘tubes to Sparkfun’s datacenter in Colorado… Minutes later, the page timed out and I sent the request again, and again. As the minutes went by, so did the time outs and blank white pages across my screen. Scanning the chatroom, I saw reports of people successfully reaching the shipping page, ready to submit their Free Day order; still nothing on my screen. After an hour of failed attempts, I finally reached the log-in screen. Gah, I logged in just before the event started to avoid this! After providing my account info, I waited another 10 minutes and reached the shipping page. The taste of success was on my tongue as many before me reported their completed orders shortly after reaching the shipping page. I gleefully submitted my shipping information.

And that was the last I saw of Sparkfun.com. As I watched the Firefox throbber spin away, my heart dropped as people reported the giveaway totals nearing dangerously to the $100,000 limit. Before I could reach the billing page, SparkFun announced on Twitter that Free Day was officially over. And so were lost my dreams of free electronics. Sulked, I returned to the chatroom to read the flurry of exuberant posts from those who had successfully received their Free Day orders.

This story ends happily, however. Once the rush of traffic to Sparkfun’s site died down after the event, I was able to trim my bloated cart of electronic goodies to only that which I needed for my project, and proudly submitted my non-free order.

Thanks for the experience, Sparkfun.

Consider the following snippet of code:

<?php
$a = array(
     0 => "test {$a[1]}",
     1 => "blah {$a[2]}",
     2 => "argh"
);
echo $a[0]."\n";	// outputs: test

$s2 = "argh";
$s1 = "blah {$s2}";
$s0 = "test {$s1}";

echo $s0."\n";	// outputs: test blah argh
?>

At first, we attempt to use an array to handle the string recursion, then we use string variables.We can see from the output that the array code simply doesn’t work. It appears you can’t access parts of the array from within itself. At the moment, it looks like I’m stuck avoiding arrays for this. If anyone out there knows a way around this, please let me know!

You might assume that Google’s offline technology, Google Gears, just isn’t capable of seamless online/offline transitions, but a quick look through their developer tutorial proves otherwise.

In a “background sync”, the application continuously synchronizes the data between the local data store and the server. This can be implemented by pinging the server every once in a while or better yet, letting the server push or stream data to the client (this is called Comet in the Ajax lingo).

The benefits of background synching are:

• Data is ready at all times, whenever the user chooses to go offline, or is accidentally disconnected.
• The performance is enhanced when using a slow Internet connection.

The downside is that the sync engine might consume resources or slow down the online experience with its background processing (if it’s not using the WorkerPool). Using WorkerPool the cost of synching is minimized and no longer affects the user’s experience.

This is exactly the type of synchronization feature that Google’s apps need to make Chrome OS possible. Without it, Chrome OS will never succeed. Gears has been capable of background synchronization, yet each time Google adds offline capability to one of their apps they force you to manually sync your data before going offline. I’ve never understood this strategy and now it appears they must revise their offline strategy for the Chrome OS project. I’d imagine Google to think more ahead than this, but let’s hope they catch on and we start seeing background sync rolled into their web apps as the Chrome OS launch nears.

Update (2009-12-23): It looks like Gmail has the most robust offline support of all the Google web apps now. Reader still forces you to manually sync, you can’t create new documents in Docs if you’re offline, and Calendar still only lets you look at your events without changing anything. This is promising though, as Gmail is now a suitable replacement for a desktop e-mail client. One step at a time.

Though this has the potential to be a disaster, I can’t help but to encourage Microsoft if it really plans to push this further. Alienating mobile device vendors that use FAT by forbidding the open use of the filesystem means a large majority of those vendors will pursue open royalty-free alternatives. FAT is antiquated and there are many other viable filesystems for the industry to adopt. This has the potential of becoming a very good technological push forward for the industry as a whole. There will be some pains for sure, but I can only encourage Microsoft in alienating itself from an industry that has become reliate on FAT and essentially forcing an upswing in filesystem adoption to more open platforms. If that’s the case, then thank you Microsoft.

I wonder why my repository list never updated during the dist-upgrade…