New Radio API (#287)

* Adding radio API for receiving a packet

* More new radio API changes

* renaming some properties

* Redoing radio packet parsing and updating new callback api

sim/state/radio.ts

@@ -1,15 +1,14 @@
 namespace pxsim {
     export interface PacketBuffer {
-        data: number[] | string;
-        rssi?: number;
+        payload: SimulatorRadioPacketPayload;
+        rssi: number;
+        serial: number;
+        time: number;
     }
 
     export class RadioDatagram {
         datagram: PacketBuffer[] = [];
-        lastReceived: PacketBuffer = {
-            data: [0, 0, 0, 0],
-            rssi: -1
-        };
+        lastReceived: PacketBuffer = RadioDatagram.defaultPacket();
 
         constructor(private runtime: Runtime) {
         }
@@ -21,35 +20,43 @@ namespace pxsim {
             (<DalBoard>runtime.board).bus.queue(DAL.MICROBIT_ID_RADIO, DAL.MICROBIT_RADIO_EVT_DATAGRAM);
         }
 
-        send(buffer: number[] | string) {
-            if (buffer instanceof String) buffer = buffer.slice(0, 32);
-            else buffer = buffer.slice(0, 8);
-
+        send(payload: SimulatorRadioPacketPayload) {
             Runtime.postMessage(<SimulatorRadioPacketMessage>{
                 type: "radiopacket",
-                data: buffer
+                rssi: 0, // Not yet supported
+                serial: board().radioState.bus.transmitSerialNumber ? board().radioState.bus.serial : 0,
+                time: 0, // Not yet supported
+                payload
             })
         }
 
         recv(): PacketBuffer {
             let r = this.datagram.shift();
-            if (!r) r = {
-                data: [0, 0, 0, 0],
-                rssi: -1
-            };
+            if (!r) r = RadioDatagram.defaultPacket();
             return this.lastReceived = r;
         }
+
+        private static defaultPacket(): PacketBuffer {
+            return {
+                rssi: -1,
+                serial: 0,
+                time: 0,
+                payload: { type: -1 }
+            };
+        }
     }
 
     export class RadioBus {
         // uint8_t radioDefaultGroup = MICROBIT_RADIO_DEFAULT_GROUP;
         groupId = 0; // todo
         power = 0;
+        serial = 0;
         transmitSerialNumber = false;
         datagram: RadioDatagram;
 
         constructor(private runtime: Runtime) {
             this.datagram = new RadioDatagram(runtime);
+            this.serial = Math.floor(Math.random() * Math.pow(2, 32)) - Math.pow(2, 31); // 32 bit signed integer
         }
 
         setGroup(id: number) {
@@ -83,12 +90,18 @@ namespace pxsim {
         }
 
         public recievePacket(packet: SimulatorRadioPacketMessage) {
-            this.bus.datagram.queue({ data: packet.data, rssi: packet.rssi || 0 })
+            this.bus.datagram.queue(packet)
         }
     }
 }
 
 namespace pxsim.radio {
+    enum PacketPayloadType {
+        NUMBER = 0,
+        VALUE = 1,
+        STRING = 2
+    }
+
     export function broadcastMessage(msg: number): void {
         board().radioState.bus.broadcast(msg);
     }
@@ -110,41 +123,57 @@ namespace pxsim.radio {
     }
 
     export function sendNumber(value: number): void {
-        board().radioState.bus.datagram.send([value]);
+        board().radioState.bus.datagram.send({
+            type: PacketPayloadType.NUMBER,
+            numberData: value
+        });
     }
 
     export function sendString(msg: string): void {
-        board().radioState.bus.datagram.send(msg);
+        msg = msg.substr(0, 19);
+        board().radioState.bus.datagram.send({
+            type: PacketPayloadType.STRING,
+            stringData: msg
+        });
     }
 
     export function writeValueToSerial(): void {
         let b = board();
-        let v = b.radioState.bus.datagram.recv().data[0];
-        b.writeSerial(`{v:${v}}`);
+        let p = b.radioState.bus.datagram.recv();
+
+        switch(p.payload.type) {
+            case PacketPayloadType.NUMBER:
+                b.writeSerial(`{"t":${p.time},"s":${p.serial},"v":${p.payload.numberData}}`)
+                break;
+            case PacketPayloadType.VALUE:
+                b.writeSerial(`{"t":${p.time},"s":${p.serial},"n":"${p.payload.stringData}","v":${p.payload.numberData}}`)
+                break;
+            case PacketPayloadType.STRING:
+                b.writeSerial(`{"t":${p.time},"s":${p.serial},"n":"${p.payload.stringData}"}`)
+                break;
+            default:
+        }
     }
 
     export function sendValue(name: string, value: number) {
-        board().radioState.bus.datagram.send([value]);
+        name = name.substr(0, 12);
+        const msg: number[] = [];
+        msg.push()
+        board().radioState.bus.datagram.send({
+            type: PacketPayloadType.VALUE,
+            stringData: name,
+            numberData: value
+        });
     }
 
     export function receiveNumber(): number {
-        let buffer = board().radioState.bus.datagram.recv().data;
-        if (buffer instanceof Array) return buffer[0];
-
-        return 0;
+        const packet = board().radioState.bus.datagram.recv();
+        return receivedNumber();
     }
 
     export function receiveString(): string {
-        let buffer = board().radioState.bus.datagram.recv().data;
-        if (typeof buffer === "string") return <string>buffer;
-        return "";
-    }
-
-    export function receivedNumberAt(index: number): number {
-        let buffer = board().radioState.bus.datagram.recv().data;
-        if (buffer instanceof Array) return buffer[index] || 0;
-
-        return 0;
+        const packet = board().radioState.bus.datagram.recv();
+        return receivedString();
     }
 
     export function receivedSignalStrength(): number {
@@ -155,4 +184,20 @@ namespace pxsim.radio {
         pxtcore.registerWithDal(DAL.MICROBIT_ID_RADIO, DAL.MICROBIT_RADIO_EVT_DATAGRAM, handler);
         radio.receiveNumber();
     }
+
+    export function receivedNumber(): number {
+        return board().radioState.bus.datagram.lastReceived.payload.numberData || 0;
+    }
+
+    export function receivedSerial(): number {
+        return board().radioState.bus.datagram.lastReceived.serial;
+    }
+
+    export function receivedString(): string {
+        return board().radioState.bus.datagram.lastReceived.payload.stringData || "";
+    }
+
+    export function receivedTime(): number {
+        return board().radioState.bus.datagram.lastReceived.time;
+    }
 }