MagTest to parse magnetometer data on PlayBook v1.0.7

// Magnetometer access from raw AS3 for the PlayBook
// Copyright 2011 Peter Hansen
// Use under MIT License: see http://www.opensource.org/licenses/mit-license.php

package {
    import flash.desktop.NativeApplication;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;

    import flash.events.Event;
    import flash.events.IOErrorEvent;
    import flash.events.ProgressEvent;

    import flash.filesystem.File;
    import flash.filesystem.FileMode;
    import flash.filesystem.FileStream;

    import flash.text.TextFieldAutoSize;
    import flash.text.TextFormat;
    import flash.utils.*;
    import flash.utils.ByteArray;

    import mx.utils.ObjectUtil;

    import qnx.system.QNXSystem;
    import qnx.system.QNXSystemPowerMode;
    import qnx.ui.text.Label;


    [SWF(backgroundColor="#cccccc")]
    public class MagTest extends Sprite {
        private var label:Label = new Label();

        private var base_time:int = getTimer();

        private var path:File = new File('/dev/sensor/mag');
        private var file:FileStream;

        public function MagTest() {
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;

            QNXSystem.system.inactivePowerMode = QNXSystemPowerMode.THROTTLED;

            var fmt:TextFormat = new TextFormat();
            fmt.font = 'Courier New';
            fmt.size = 24;

            label.format = fmt;
            label.autoSize = TextFieldAutoSize.LEFT;
            label.multiline = true;
            label.x = 10;
            label.y = 10;
            label.width = 1000;
            label.height = 500;
            label.text = 'Go west, young man.';
            addChild(label);

            NativeApplication.nativeApplication.addEventListener(Event.EXITING, onExiting);

            trace(getTimer(), 'starting');

            file = new FileStream();
            file.addEventListener(IOErrorEvent.IO_ERROR, onIOErrorEvent);
            file.addEventListener(ProgressEvent.PROGRESS, onProgressEvent);
            file.openAsync(path, FileMode.READ);

            var hexdigits:String = '0123456789abcdef';
            for (var i:int = 0; i < 16; i++)
                for (var j:int = 0; j < 16; j++) {
                    bin2hex[i * 16 + j] = hexdigits.charAt(i) + hexdigits.charAt(j);
                }
        }

        public var bin2hex:Array = [];

        private function onExiting(e:Event):void {
            trace(getTimer(), 'exiting');
            file.close();
        }


        private function onIOErrorEvent(e:IOErrorEvent):void {
            trace(getTimer(), 'io error', e.toString());
            label.text = e.toString();
        }

        public var buffer:ByteArray = new ByteArray();
        public var packet_count:int;
        public var parser:Parser = new Parser();

        // generally getting 8192 bytes per event, but don't assume anything yet
        // about how big a block we get
        private function onProgressEvent(e:ProgressEvent):void {
            // buffer all available data from file
            buffer.length = 0;
            file.readBytes(buffer, 0, file.bytesAvailable);

            // consume buffer, one packet at a time
            var packet:Object;
            while (parser.feed(buffer)) {
                packet_count++;
                packet = parser.getPacket();

                if (buffer.position >= buffer.length)
                    break;
            }

            // display last packet...
            if (packet) {
                label.text = formatPacket(packet);
                trace('data', packet.time.toFixed(3), packet.x.toFixed(3), packet.y.toFixed(3), packet.z.toFixed(3));
            }
        }


        public function formatPacket(packet:Object):String {
            var rows:Array = [];
            rows.push('time: ' + packet.time.toFixed(9));
            rows.push('x: ' + packet.x.toFixed(3));
            rows.push('y: ' + packet.y.toFixed(3));
            rows.push('z: ' + packet.z.toFixed(3));

            var header:String = (getTimer() / 1000).toFixed(3);
            var rate:Number = packet_count / (getTimer() - base_time) * 1000.0;
            header += ': ' + rate.toFixed(1) + ' Hz';

            var msg:String = rows.join('\n');
            return header + ':\n' + msg;
        }
    }
}


import flash.utils.ByteArray;

class Parser {
    private var length:int;
    private var data:ByteArray = new ByteArray();

    public function Parser() {
        data.endian = 'littleEndian'; // default is bigEndian
    }

    public function feed(buffer:ByteArray):Boolean {
        if (!length) {
            length = buffer.readByte();
            if (!length)
                throw new Error('parse error, length cannot be 0');

            data.length = 0;
            data.writeByte(length);
        }

        var to_read:int = length - data.length;
        var avail:int = buffer.length - buffer.position;
        if (to_read > avail)
            to_read = avail;

        buffer.readBytes(data, data.length, to_read);

        if (data.length >= length) {
            length = 0; // ready for next packet
            return true;
        }
        else
            return false;
    }

    // disassemble a full packet
    //~ 00000000: 6000000001000000 0000000002000000 `...............
    //~ 00000010: 621d20e2aaa00000 628833c19a01a3c1 b.......b.3.....
    //~ 00000020: 52653fc200000000 0000000000000000 Re?.............
    //~ 00000030: 0000000000000000 0000000000000000 ................
    //~ 00000040: 0000000000000000 0000000000000000 ................
    //~ 00000050: 0000000000000000 0000000000000000 ................
    public function getPacket():Object {
        var obj:Object = {length: data.length};

        data.position = 0x10;
        var loword:Number = data.readUnsignedInt();
        var hiword:Number = data.readUnsignedInt();
        obj.time = (hiword * 0x100000000 + loword) / 1e9;

        // no idea if these are really x, y, or z, or in this order
        obj.x = data.readFloat();
        obj.y = data.readFloat();
        obj.z = data.readFloat();

        return obj;
    }
}