From 8c3baaab2f3d5364c0d9be0e5ea06278c95fc486 Mon Sep 17 00:00:00 2001
From: Casey Duckering <cduckering@gmail.com>
Date: Sat, 25 Oct 2014 15:37:06 -0700
Subject: [PATCH 01/19] Functions to support trasmitting on the rest of the
 radio ports

---
 controller/inc/radio.h |  8 ++++++++
 controller/src/radio.c | 37 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/controller/inc/radio.h b/controller/inc/radio.h
index f256b451..df4f6be7 100644
--- a/controller/inc/radio.h
+++ b/controller/inc/radio.h
@@ -20,10 +20,18 @@
 
 #include "inc/FreeRTOS.h"
 
+#include "radio_protocol_ng.h"   // NOLINT(build/include)
+
 
 BaseType_t radioInit();
+
+// Do not modify or release the data after calling these.
+// The radio takes ownership of releasing the memeory.
 void radioPushUbjson(const char *ubjson, size_t len);
 void radioPushString(const char *str, size_t len);
+void radioPushBulk(const code_port *data, size_t len);
+void radioPushConfig(const config_port *data, size_t len);
+void radioPushFast(const char *ubjson, size_t len);
 
 
 #endif  // INC_RADIO_H_
diff --git a/controller/src/radio.c b/controller/src/radio.c
index 816c01a1..00ce4135 100644
--- a/controller/src/radio.c
+++ b/controller/src/radio.c
@@ -16,6 +16,7 @@
 // under the License
 
 #include <string.h>
+#include <stdio.h>
 
 #include <ndl3.h>
 
@@ -81,6 +82,30 @@ void radioPushString(const char *str, size_t len) {
   };
   xQueueSend(radioQueue, &msg, 0);
 }
+void radioPushBulk(const code_port *data, size_t len) {
+  RadioMessage msg = {
+    .port = NDL3_CODE_PORT,
+    .str = (const char*)data,
+    .len = len
+  };
+  xQueueSend(radioQueue, &msg, 0);
+}
+void radioPushConfig(const config_port *data, size_t len) {
+  RadioMessage msg = {
+    .port = NDL3_CONFIG_PORT,
+    .str = (const char*)data,
+    .len = len
+  };
+  xQueueSend(radioQueue, &msg, 0);
+}
+void radioPushFast(const char *ubjson, size_t len) {
+  RadioMessage msg = {
+    .port = NDL3_FAST_PORT,
+    .str = ubjson,
+    .len = len
+  };
+  xQueueSend(radioQueue, &msg, 0);
+}
 
 
 // TODO(cduck): Move this to uart_serial_driver.c and make it work
@@ -146,6 +171,7 @@ static portTASK_FUNCTION_PROTO(radioNewTask, pvParameters) {
   NDL3_open(target, NDL3_CODE_PORT);
   NDL3_open(target, NDL3_CONFIG_PORT);
   NDL3_open(target, NDL3_FAST_PORT);
+  NDL3_setopt(target, NDL3_FAST_PORT, NDL3_PORT_UNRELIABLE);
   char * recvMsg = NULL;
 
   const uint8_t prefixLen = 1;
@@ -206,7 +232,16 @@ static portTASK_FUNCTION_PROTO(radioNewTask, pvParameters) {
     // Send code to runtime
     if (recvMsg && recvSize >= 1) {
       // Trust this to free recvMsg
-      // TODO(cduck): Do something
+      // TODO(cduck): Send to radio config thread instead
+      switch (recvMsg[0]) {
+        case ID_CONTROL_UNFREEZE: setGameMode(4); break;
+        case ID_CONTROL_STOP: setGameMode(3); break;
+        case ID_CONTROL_UNPOWERED: setGameMode(1); break;
+        case ID_CONTROL_SET_AUTON: setGameMode(2); break;
+        case ID_CONTROL_SET_TELEOP: setGameMode(4); break;
+        default: break;
+      }
+
       printf("Got config data\n");
       vPortFree(recvMsg);
     } else {

From 578c6ecb08f19624141946f51fc5611ba7fb82f1 Mon Sep 17 00:00:00 2001
From: Vincent Donato <vincentdonato@pioneers.berkeley.edu>
Date: Sat, 25 Oct 2014 18:48:48 -0700
Subject: [PATCH 02/19] Initial code for radio config thread and device
 enumeration

---
 controller/inc/radio_config.h |  28 +++++++++
 controller/src/radio_config.c | 109 ++++++++++++++++++++++++++++++++++
 2 files changed, 137 insertions(+)
 create mode 100644 controller/inc/radio_config.h
 create mode 100644 controller/src/radio_config.c

diff --git a/controller/inc/radio_config.h b/controller/inc/radio_config.h
new file mode 100644
index 00000000..c29c579f
--- /dev/null
+++ b/controller/inc/radio_config.h
@@ -0,0 +1,28 @@
+// Licensed to Pioneers in Engineering under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  Pioneers in Engineering licenses
+// this file to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+//  with the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License
+
+#ifndef INC_RADIO_CONFIG_H_
+#define INC_RADIO_CONFIG_H_
+
+#include "inc/FreeRTOS.h"
+#include "inc/radio.h"
+#include "inc/smartsensor/ssutil.h"
+#include "radio_protocol_ng.h"   // NOLINT(build/include)
+
+BaseType_t radioConfigInit();
+void receiveConfigPort(config_port *port, size_t len);
+#endif  // INC_RADIO_CONFIG_H_
diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
new file mode 100644
index 00000000..e41b6b7b
--- /dev/null
+++ b/controller/src/radio_config.c
@@ -0,0 +1,109 @@
+// Licensed to Pioneers in Engineering under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  Pioneers in Engineering licenses
+// this file to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+//  with the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "inc/radio_config.h"
+#include "inc/task.h"
+#include "inc/queue.h"
+#include "inc/smartsensor/ssutil.h"
+
+typedef struct {
+  config_port *port;
+  size_t len;
+} ConfigMessage;
+
+QueueHandle_t configMessageQueue = NULL;
+// void sensorUpdateCallback(uint16_t index, SSState *sensor);
+
+static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters);
+
+BaseType_t radioConfigInit() {
+  configMessageQueue = xQueueCreate(100, sizeof(ConfigMessage));
+  /*
+  // Get updates from smart sensor protocol
+  registerSensorUpdateCallback(&sensorUpdateCallback);
+  */
+  return xTaskCreate(radioConfigTask, "Radio Config", 2048, NULL,
+                     tskIDLE_PRIORITY, NULL);
+}
+
+void receiveConfigPort(config_port *port, size_t len) {
+  ConfigMessage msg = {
+    .port = port,
+    .len = len,
+  };
+  xQueueSend(configMessageQueue, &msg, 0);
+}
+
+config_port *getDeviceList() {
+  config_port *port = pvPortMalloc(sizeof(uint8_t) + sizeof(uint32_t)
+                                                   + SMART_ID_LEN*numSensors);
+  port->id = ID_DEVICE_GET_LIST;
+  port->data.device_list.count = numSensors;
+  for (int i = 0; i < numSensors; i++) {
+    uint64_t temp = 0;
+    for (int j = SMART_ID_LEN-1; j > 0; j--) {
+      temp = ((temp << 8) | sensorArr[i]->id[j]);
+    }
+    port->data.device_list.dids[i] = temp;
+  }
+  return port;
+}
+
+static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
+  (void) pvParameters;
+  while (1) {
+    ConfigMessage msg;
+    while (xQueueReceive(configMessageQueue, &msg, portMAX_DELAY) == pdTRUE) {
+      switch (msg.port->id) {
+        case ID_START_VM:
+          break;
+        case ID_STOP_VM:
+          break;
+        case ID_LOAD_MAIN_THREAD:
+          break;
+        case ID_CONTROL_UNFREEZE:
+          break;
+        case ID_CONTROL_STOP:
+          break;
+        case ID_CONTROL_UNPOWERED:
+          break;
+        case ID_CONTROL_SET_AUTON:
+          break;
+        case ID_CONTROL_SET_TELEOP:
+          break;
+        case ID_DEVICE_GET_LIST: {
+            config_port *deviceList = getDeviceList();
+            size_t size = sizeof(uint8_t) + sizeof(uint32_t) +
+                          SMART_ID_LEN*numSensors;
+            radioPushConfig(deviceList, size);
+          }
+          break;
+        case ID_DEVICE_READ_DESCRIPTOR:
+          break;
+        case ID_DEVICE_ENABLE_BLINK:
+          break;
+        default:
+          break;
+      }
+      vPortFree(msg.port);
+    }
+  }
+}

From c2a595f0f0c79faa29242ecb65c23c46d611a24a Mon Sep 17 00:00:00 2001
From: Casey Duckering <cduckering@gmail.com>
Date: Sat, 25 Oct 2014 22:08:02 -0700
Subject: [PATCH 03/19] Controller game state control also over config port

---
 controller/src/radio_config.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index e41b6b7b..5cde87a4 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -23,6 +23,7 @@
 #include "inc/task.h"
 #include "inc/queue.h"
 #include "inc/smartsensor/ssutil.h"
+#include "inc/runtime.h"
 
 typedef struct {
   config_port *port;
@@ -72,7 +73,7 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
   while (1) {
     ConfigMessage msg;
     while (xQueueReceive(configMessageQueue, &msg, portMAX_DELAY) == pdTRUE) {
-      switch (msg.port->id) {
+      switch (msg.port->id) {  // TODO(vdonato): Implement the rest
         case ID_START_VM:
           break;
         case ID_STOP_VM:
@@ -80,14 +81,19 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
         case ID_LOAD_MAIN_THREAD:
           break;
         case ID_CONTROL_UNFREEZE:
+          // TODO(vdonato): Figure out what to do
           break;
         case ID_CONTROL_STOP:
+          setGameMode(RuntimeModePaused);
           break;
         case ID_CONTROL_UNPOWERED:
+          setGameMode(RuntimeModeDisabled);
           break;
         case ID_CONTROL_SET_AUTON:
+          setGameMode(RuntimeModeAutonomous);
           break;
         case ID_CONTROL_SET_TELEOP:
+          setGameMode(RuntimeModeTeleop);
           break;
         case ID_DEVICE_GET_LIST: {
             config_port *deviceList = getDeviceList();

From 62b4f417fa7f7df71dd7cb730a1b3422ebc05753 Mon Sep 17 00:00:00 2001
From: Casey Duckering <cduckering@gmail.com>
Date: Wed, 5 Nov 2014 19:55:49 -0800
Subject: [PATCH 04/19] Shrink radio config thread stack size

---
 controller/src/radio_config.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index 5cde87a4..c5a19765 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -41,7 +41,7 @@ BaseType_t radioConfigInit() {
   // Get updates from smart sensor protocol
   registerSensorUpdateCallback(&sensorUpdateCallback);
   */
-  return xTaskCreate(radioConfigTask, "Radio Config", 2048, NULL,
+  return xTaskCreate(radioConfigTask, "Radio Config", 256, NULL,
                      tskIDLE_PRIORITY, NULL);
 }
 

From 2c0dd5ea355a91d6ae42a3c9236f981792a59211 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 1 Nov 2014 16:05:22 -0700
Subject: [PATCH 05/19] Implement sensor value updates and add those structs to
 yaml (Removes yaml comments?)

---
 .../common_defs/radio_protocol_ng.yaml        | 227 ++++--------------
 controller/src/radio_config.c                 |  71 +++++-
 2 files changed, 115 insertions(+), 183 deletions(-)

diff --git a/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml b/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
index 92caed22..d1c6611d 100644
--- a/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
+++ b/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
@@ -14,53 +14,15 @@
   repr: unsigned
   kind: alien
   size: 8
+- name: float
+  repr: floating
+  kind: alien
+  size: 4
+
+
+
+
 
-# Radio needs to transmit the following:
-
-# Robot                                   Host
-# ---------------------------------------------------
-# Telemetry   →
-# Control signals ←
-# Code      ←
-# Bulk state    →
-# Debug     <->
-# Sensor probing  <->
-
-
-
-# NDL3 ports:
-# NDL3_UBJSON_PORT
-# Reliable, structured UBJSON data
-# Usage:
-# Debug
-# NDL3_STRING_PORT
-# Reliable, unstructured data
-# Usage:
-# stdout
-# stdin?
-# NDL3_CODE_PORT
-# Reliable, structured binary data
-# Usage:
-# Code
-# Bulk state?
-# NDL3_CONFIG_PORT
-# Reliable, structured binary data
-# Usage:
-# start/stop VM
-# patch?
-# device probing
-# NDL3_FAST_PORT
-# Unreliable, structured UBJSON data
-# Usage:
-# Telemetry
-# Controls
-
-
-
-
-# UBJSON (reliable) port:
-# const TYPE_MEMOIZE_CLEAR    0x00
-# const TYPE_MEMOIZE_STRING   0x01
 - name: TYPE_MEMOIZE_CLEAR
   kind: const
   value: 0x00
@@ -68,23 +30,11 @@
   kind: const
   value: 0x01
 
-# [
-#   123,    // type
-#   {   // Only for TYPE_MEMOIZE_STRING
-#     123: “str”    // Memoize the string “str” with id 123
-#     …
-#   }
-# ]
 
-# String port:
-# Raw, unencapsulated strings for stdin/stdout
 
-# Code port:
-# #define ID_SEND_CODE_BLOB 0x00
 - name: ID_SEND_CODE_BLOB
   kind: const
   value: 0x00
-# #define ID_GET_TRACE_BLOB 0x01
 - name: ID_GET_TRACE_BLOB
   kind: const
   value: 0x01
@@ -98,57 +48,49 @@
       type: uint32_t
     - name: data
       type: uint8_t[]
-# struct code_port (packed) {
-#   uint8_t id
-# uint32_t len
-# uint8_t[] data
-# }
-
-# Config port:
-# #define ID_START_VM
+
 - name: ID_START_VM
   kind: const
   value: 0x00
-# #define ID_STOP_VM
 - name: ID_STOP_VM
   kind: const
   value: 0x01
-# #define ID_LOAD_MAIN_THREAD   0x02
 - name: ID_LOAD_MAIN_THREAD
   kind: const
   value: 0x02
-# #define ID_CONTROL_UNFREEZE   0x10
 - name: ID_CONTROL_UNFREEZE
   kind: const
   value: 0x10
-# #define ID_CONTROL_STOP     0x11
 - name: ID_CONTROL_STOP
   kind: const
   value: 0x11
-# #define ID_CONTROL_UNPOWERED    0x12
 - name: ID_CONTROL_UNPOWERED
   kind: const
   value: 0x12
-# #define ID_CONTROL_SET_AUTON    0x13
 - name: ID_CONTROL_SET_AUTON
   kind: const
   value: 0x13
-# #define ID_CONTROL_SET_TELEOP   0x14
 - name: ID_CONTROL_SET_TELEOP
   kind: const
   value: 0x14
-# #define ID_DEVICE_GET_LIST      0x20
 - name: ID_DEVICE_GET_LIST
   kind: const
   value: 0x20
-# #define ID_DEVICE_READ_DESCRIPTOR 0x21
 - name: ID_DEVICE_READ_DESCRIPTOR
   kind: const
   value: 0x21
-# #define ID_DEVICE_ENABLE_BLINK    0x22
 - name: ID_DEVICE_ENABLE_BLINK
   kind: const
   value: 0x22
+  name: ID_DEVICE_START_UPDATES
+  kind: const
+  value: 0x23
+  name: ID_DEVICE_STOP_UPDATES
+  kind: const
+  value: 0x24
+  name: ID_DEVICE_VALUE_UPDATE
+  kind: const
+  value: 0x23
 
 - name: device_list_t
   kind: struct
@@ -157,7 +99,7 @@
     - name: count
       type: uint32_t
     - name: dids
-      type: uint16_t[]
+      type: uint64_t[]
 
 - name: device_read_descriptor_req_t
   kind: struct
@@ -170,10 +112,6 @@
     - name: len
       type: uint16_t
 
-- name: LENGTH_AT_LEAST_ONE
-  kind: const
-  value: 0x01
-
 - name: device_read_descriptor_resp_t
   kind: struct
   packed: true
@@ -181,7 +119,18 @@
     - name: did
       type: uint64_t
     - name: data
-      type: uint8_t[LENGTH_AT_LEAST_ONE]
+      type: uint8_t[1]
+
+- name: device_value_update
+  kind: struct
+  packed: true
+  slots:
+    - name: timestamp
+      type: uint32_t
+    - name: count
+      type: uint32_t
+    - name: devices
+      type: device_value[]
 
 - name: device_blink_t
   kind: struct
@@ -192,6 +141,24 @@
     - name: blink_on
       type: uint8_t
 
+- name: channel_value
+  kind: struct
+  packed: true
+  slots:
+    - name: value
+      type: float
+
+- name: device_value
+  kind: struct
+  packed: true
+  slots:
+    - name: did
+      type: uint64_t
+    - name: count
+      type: uint32_t
+    - name: values
+      type: channel_value[]
+
 - name: config_port_data
   kind: union
   slots:
@@ -206,7 +173,6 @@
     - name: nothing
       type: uint8_t
 
-
 - name: config_port
   kind: struct
   packed: true
@@ -215,31 +181,8 @@
      type: uint8_t
    - name: data
      type: config_port_data
-# struct config_port (packed) {
-#   uint8_t id
-#   union {
-#     struct device_list {
-#       uint32_t count
-#       uint64_t[] dids
-#     }
-#     struct device_read_descriptor_req {
-#       uint64_t did
-#       uint16_t start
-#       uint16_t len
-#     }
-#     struct device_read_descriptor_resp {
-#       uint8_t[] data
-#     }
-#     struct device_blink {
-#       uint8_t blink_on
-#       uint64_t did
-#     }
-#   }
-# }
-
-# Fast port:
-# const TYPE_JOY_DATA   0x00
-# const TYPE_TELEM_DATA   0x01
+
+
 - name: TYPE_JOY_DATA
   kind: const
   value: 0x00
@@ -247,18 +190,6 @@
   kind: const
   value: 0x01
 
-# [
-#   nnn,      // type
-#   {
-#     123: [1,0,1,…]  // Telemetry or joystick, can be repeated
-#   }     // 123 = memoized string
-#         // array = samples (for telemetry)
-#         //         channel (for joystick)
-# ]
-
-
-
-
 
 
 
@@ -272,48 +203,7 @@
 
 
 
-# More detailed brain dumps:
 
-# Notes on UBJSON
-# UBJSON is only available to Lua. Any state that needs to be available to C cannot be sent via UBJSON (easily). Any data from UBJSON can be condidered “untrusted” (not resistant against tampering from within studencode)
-# String memoization
-# The purpose of string memoization is to reduce the number of bytes that need to be sent repeatedly. For example, suppose there was a string “joy0-analog” that needed to be sent in every joystick packet. This takes up 11 bytes in every telemetry packet that conveys no additional information after the first time. String memoization solves this by having the host send a unique number and the string to the controller once at the beginning. The string will then be replaced by this number, which will usually take only 1 byte.
-# The host can memoize strings sent to the controller. The controller can also send back a TYPE_MEMOIZE_STRING back to the host for e.g. telemetry. IDs may overlap between the two.
-# TYPE_MEMOIZE_CLEAR clears both directions
-# String port
-# This port is directly mapped to stdio. No encapsulation
-# printf() from robot appears here
-# data written to this port should be made available via scanf, etc.
-# Code/trace
-# Code is always host-->robot
-# Trace is always robot-->host
-# Code is not run immediately. Running the code is controlled by the config port.
-# How to trigger trace is TBD
-# Config
-# The majority of host “controlling” the robot happens here. This includes field control logic.
-# VM state control
-# The host can completely stop execution of any studentcode by sending a stop command. This tears down the VM and frees all of the associated state.
-# Start will cause a VM to be created. Standard libraries will be loaded but no studentcode will be.
-# Load main thread is used to load the studentcode. The studentcode must have been sent earlier using the code port.
-# Replacing the studentcode should work. This needs to be worked out on the runtime dide. Loading studentcode when there is already a studentcode should tear down the student-controlled parts of the VM without rebooting the entire VM.
-# Patching will be controlled here. Exact behavior TBD.
-# Field control logic
-# Field control logic is here (rather than e.g. a UBJSON port) so that it is impossible for students to cheat it.
-# There are three stop/run states (unfreeze, stop, unpowered) because of corner-cases with e.g. servos. There are extensive notes on this elsewhere.
-# Autonomous and teleop are needed by the C code to block access to the joystick (PiER never did this). It will also be exposed to Lua
-# Smartdevice logic
-# Smartdevices will be enumerated by the firmware at TBD time. The host can request a list of devices using the get list command. This will return a list of smart device UUIDs.
-# The firmware will automatically handle bw allocation and most of the details of communicating with devices. The UI needs to handle human-readable descriptors and binding devices to meaningful names.
-# The UI can get descriptions of the devices by reading the descriptor information. See smartdevice spec.
-# In order to help identify devices that are already mounted on the robot, the UI can command the LED on the smartdevice to blink.
-# Joystick
-# Joystick packets contain a number of channels that each contain a number of values. Each individual value can be referred to as <channel name>-<value number>
-# For the Xbox 360 joystick, there would be 2 channels: button, analog with 11 and 8 values
-# Multiple joysticks can be sent in the same packet
-# Telemetry
-# Telemetry contains channels that can contain 1 or more samples
-# Behavior very similar to joysticks
-# Telemetry is batched up and sent at intervals
 
 
 
@@ -327,18 +217,3 @@
 
 
 
-# Sample exchanges (PC <--> robot);
-# config port: 0x01 →           (stop VM, reset (almost) all state)
-# config port: 0x20 →           (get device list)
-# config port: ← 0x20  0x01 0x00 0x00 0x00  0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0x00 0x01
-# config port: 0x21  [0xAA … 0x01]  0x00 0x00  0x02 0x00 →  (read descriptor length)
-# config port: ← 0x21  0x55 0x00
-# config port: 0x21  [0xAA … 0x01]  0x00 0x00  0x55 0x00 →  (read entire descriptor)
-# config port: ← 0x21  …
-# config port: 0x00 →             (start VM)
-# code port: 0x00  0x23 0x01  0xXX 0xXX … →     (buffer code)
-# config port: 0x02 →             (load code into main thread)
-# ubjson reliable: [1, {0: “joy0-analog”, 1: “joy0-button”}] →  (memoize string)
-# config port: 0x10 →             (unfreeze)
-# ubjson fast: [0, 0: [1,1,0.5, …], 1: [true, false, …]] →  (joystick)
-# ...
diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index c5a19765..aec96e19 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -54,8 +54,7 @@ void receiveConfigPort(config_port *port, size_t len) {
 }
 
 config_port *getDeviceList() {
-  config_port *port = pvPortMalloc(sizeof(uint8_t) + sizeof(uint32_t)
-                                                   + SMART_ID_LEN*numSensors);
+  config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(uint32_t) + SMART_ID_LEN*numSensors);
   port->id = ID_DEVICE_GET_LIST;
   port->data.device_list.count = numSensors;
   for (int i = 0; i < numSensors; i++) {
@@ -68,11 +67,48 @@ config_port *getDeviceList() {
   return port;
 }
 
+config_port *getValueUpdate() {
+  uint8_t total_number_of_channels = 0;
+  for(i=0;i<sizeof(sensorArr);i++){
+    total_number_of_channels += sizeof(sensorArr[i]->channels)
+  }
+  config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(TickType_t) +sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint8_t) + total_number_of_channels*sizeof(uint64_t)); //TODO(sirblobfish): uint64_t is probably not the correct size for sensor values
+  port->id = ID_DEVICE_VALUE_UPDATE;
+  port->data.device_value_update.timestamp = xTaskGetTickCount();
+  port->data.device_value_update.count = numSensors;
+  for (int i = 0; i < numSensors; i++) {
+    uint64_t temp = 0;
+    for (int j = SMART_ID_LEN-1; j > 0; j--) {
+      temp = ((temp << 8) | sensorArr[i]->id[j]);
+    }
+    port->data.device_value_update.devices[i].did = temp;
+    port->data.device_value_update.devices[i].count =  sensorArr[i]->channelsNum;
+    for (int k = 0; k < port->sensorArr[i]->channelsNum; k++){
+      ss_get_value(sensorArr[i]->channels[k], port->data.device_value_update.devices[i].values[k], sensorArr[i]->channels[k].outgoingLen);
+    }
+  return port;
+
 static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
   (void) pvParameters;
+  int send_messages_toggle = 0;
+  TickType_t time_offset = 100;
+  TickType_t next_time_stamp=0;
+  TickType_t wait_time = portMAX_DELAY;
+
   while (1) {
     ConfigMessage msg;
-    while (xQueueReceive(configMessageQueue, &msg, portMAX_DELAY) == pdTRUE) {
+    if (send_messages_toggle == 1){
+      current_time_stamp = xTaskGetTickCount();
+      time_difference = current_time_stamp - next_time_stamp;
+      if (time_difference > offset) //if time_difference (unsigned) is negative, hence, super big
+      {
+        wait_time = next_time_stamp - current_time_stamp;
+        next_time_stamp = current_time_stamp + time_offset;
+      }
+      else {wait_time = 1} //Just a really small wait time so that the signal can be sent almost immediately
+      }
+    }
+    while (xQueueReceive(configMessageQueue, &msg, wait_time) == pdTRUE) {
       switch (msg.port->id) {  // TODO(vdonato): Implement the rest
         case ID_START_VM:
           break;
@@ -96,20 +132,41 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
           setGameMode(RuntimeModeTeleop);
           break;
         case ID_DEVICE_GET_LIST: {
-            config_port *deviceList = getDeviceList();
-            size_t size = sizeof(uint8_t) + sizeof(uint32_t) +
-                          SMART_ID_LEN*numSensors;
-            radioPushConfig(deviceList, size);
+              if(send_messages_toggle == 1){
+                config_port *deviceList = getDeviceList();
+                size_t size = sizeof(uint8_t) + sizeof(uint32_t) +
+                              SMART_ID_LEN*numSensors;
+                radioPushConfig(deviceList, size);
+              }
           }
           break;
         case ID_DEVICE_READ_DESCRIPTOR:
           break;
         case ID_DEVICE_ENABLE_BLINK:
           break;
+
+        case ID_DEVICE_START_UPDATES:
+            send_messages_toggle = 1
+            initial_time_stamp = xTaskGetTickCount()
+          break;
+        case ID_DEVICE_STOP_UPDATES:
+            send_messages_toggle = 0
+          break;
+        case ID_DEVICE_VALUE_UPDATE: {
+          config_port *device_value_update = getValueUpdate();
+          size_t value_size = sizeof(device_value_update);
+          radioPushConfig(device_value_update, value_size);
+          }
+          break;
+
         default:
+          config_port *device_value_update = getValueUpdate();
+          size_t value_size = sizeof(device_value_update);
+          radioPushConfig(device_value_update, value_size);
           break;
       }
       vPortFree(msg.port);
     }
   }
 }
+

From 0bd3809e26b5618a31470f553f6fa28ff3edb489 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 8 Nov 2014 15:13:23 -0800
Subject: [PATCH 06/19] Fix port malloc for device value update

---
 controller/src/radio_config.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index aec96e19..b7ed2fc1 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -72,7 +72,9 @@ config_port *getValueUpdate() {
   for(i=0;i<sizeof(sensorArr);i++){
     total_number_of_channels += sizeof(sensorArr[i]->channels)
   }
-  config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(TickType_t) +sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint8_t) + total_number_of_channels*sizeof(uint64_t)); //TODO(sirblobfish): uint64_t is probably not the correct size for sensor values
+  config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(TickType_t) 
+                                    + sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
+                                    + total_number_of_channels*sizeof(channel_value));
   port->id = ID_DEVICE_VALUE_UPDATE;
   port->data.device_value_update.timestamp = xTaskGetTickCount();
   port->data.device_value_update.count = numSensors;

From 3a6620ba16148176d103ab6ae7faa5ea11ca63dc Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 8 Nov 2014 15:51:32 -0800
Subject: [PATCH 07/19] Add safety case for enumeration in sensor value update

---
 controller/src/radio_config.c | 46 ++++++++++++++++++++---------------
 1 file changed, 27 insertions(+), 19 deletions(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index b7ed2fc1..f3e1c44d 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -68,26 +68,34 @@ config_port *getDeviceList() {
 }
 
 config_port *getValueUpdate() {
-  uint8_t total_number_of_channels = 0;
-  for(i=0;i<sizeof(sensorArr);i++){
-    total_number_of_channels += sizeof(sensorArr[i]->channels)
-  }
-  config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(TickType_t) 
-                                    + sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
-                                    + total_number_of_channels*sizeof(channel_value));
-  port->id = ID_DEVICE_VALUE_UPDATE;
-  port->data.device_value_update.timestamp = xTaskGetTickCount();
-  port->data.device_value_update.count = numSensors;
-  for (int i = 0; i < numSensors; i++) {
-    uint64_t temp = 0;
-    for (int j = SMART_ID_LEN-1; j > 0; j--) {
-      temp = ((temp << 8) | sensorArr[i]->id[j]);
-    }
-    port->data.device_value_update.devices[i].did = temp;
-    port->data.device_value_update.devices[i].count =  sensorArr[i]->channelsNum;
-    for (int k = 0; k < port->sensorArr[i]->channelsNum; k++){
-      ss_get_value(sensorArr[i]->channels[k], port->data.device_value_update.devices[i].values[k], sensorArr[i]->channels[k].outgoingLen);
+  if (ssIsActive()){
+    uint8_t total_number_of_channels = 0;
+    for(i=0;i<sizeof(sensorArr);i++){
+      total_number_of_channels += sizeof(sensorArr[i]->channels);
     }
+    config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(TickType_t) 
+                                      + sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
+                                      + total_number_of_channels*sizeof(channel_value));
+    port->id = ID_DEVICE_VALUE_UPDATE;
+    port->data.device_value_update.timestamp = xTaskGetTickCount();
+    port->data.device_value_update.count = numSensors;
+    for (int i = 0; i < numSensors; i++) {
+      uint64_t temp = 0;
+      for (int j = SMART_ID_LEN-1; j > 0; j--) {
+        temp = ((temp << 8) | sensorArr[i]->id[j]);
+      }
+      port->data.device_value_update.devices[i].did = temp;
+      port->data.device_value_update.devices[i].count =  sensorArr[i]->channelsNum;
+      for (int k = 0; k < port->sensorArr[i]->channelsNum; k++){
+        ss_get_value(sensorArr[i]->channels[k], port->data.device_value_update.devices[i].values[k], sensorArr[i]->channels[k].outgoingLen);
+      }
+  }
+  else{
+    config_port *port = pvPortMalloc(sizeof(uint8_t) + sizeof(TickType_t) + sizeof(uint32_t));
+    port->id = ID_DEVICE_VALUE_UPDATE;
+    port->data.device_value_update.timestamp = xTaskGetTickCount();
+    port->data.device_value_update.count = 0;
+  }
   return port;
 
 static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {

From cc4e741daae62698c4241d0a402785ce7eeeec89 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 8 Nov 2014 16:03:56 -0800
Subject: [PATCH 08/19] Add semi-colons

---
 controller/src/radio_config.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index f3e1c44d..4a6e4cb4 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -156,11 +156,11 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
           break;
 
         case ID_DEVICE_START_UPDATES:
-            send_messages_toggle = 1
-            initial_time_stamp = xTaskGetTickCount()
+            send_messages_toggle = 1;
+            initial_time_stamp = xTaskGetTickCount();
           break;
         case ID_DEVICE_STOP_UPDATES:
-            send_messages_toggle = 0
+            send_messages_toggle = 0;
           break;
         case ID_DEVICE_VALUE_UPDATE: {
           config_port *device_value_update = getValueUpdate();

From 19f4ec95e11bc9425f7fbff66e41a738888ca934 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 8 Nov 2014 16:59:03 -0800
Subject: [PATCH 09/19] Make malloc in Sensor value update and Get Device List
 faster

---
 controller/src/radio_config.c | 38 +++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 13 deletions(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index 4a6e4cb4..82e393d5 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -25,6 +25,8 @@
 #include "inc/smartsensor/ssutil.h"
 #include "inc/runtime.h"
 
+size_t data_size = sizeof(uint8_t) + sizeof(TickType_t) + sizeof(uint32_t);
+size_t device_list_data_size = sizeof(uint8_t) + sizeof(uint32_t);
 typedef struct {
   config_port *port;
   size_t len;
@@ -54,8 +56,16 @@ void receiveConfigPort(config_port *port, size_t len) {
 }
 
 config_port *getDeviceList() {
-  config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(uint32_t) + SMART_ID_LEN*numSensors);
+  if(ssIsActive() && device_list_data_size == sizeof(uint8_t) + sizeof(uint32_t)){
+    device_list_data_size += SMART_ID_LEN*numSensors;
+  }
+  config_port *port = pvPortMalloc(device_list_data_size);
   port->id = ID_DEVICE_GET_LIST;
+  if (!ssIsActive()) {
+    port->data.device_list.count = 0;
+    return port;
+  }
+
   port->data.device_list.count = numSensors;
   for (int i = 0; i < numSensors; i++) {
     uint64_t temp = 0;
@@ -73,9 +83,13 @@ config_port *getValueUpdate() {
     for(i=0;i<sizeof(sensorArr);i++){
       total_number_of_channels += sizeof(sensorArr[i]->channels);
     }
-    config_port *port = pvPortMalloc( sizeof(uint8_t) + sizeof(TickType_t) 
-                                      + sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
-                                      + total_number_of_channels*sizeof(channel_value));
+    
+    if (data_size == sizeof(uint8_t) + sizeof(TickType_t) + sizeof(uint32_t)){
+      data_size = sizeof(uint8_t) + sizeof(TickType_t) 
+                                  + sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
+                                  + total_number_of_channels*sizeof(channel_value);
+    }
+    config_port *port = pvPortMalloc(data_size);
     port->id = ID_DEVICE_VALUE_UPDATE;
     port->data.device_value_update.timestamp = xTaskGetTickCount();
     port->data.device_value_update.count = numSensors;
@@ -91,7 +105,7 @@ config_port *getValueUpdate() {
       }
   }
   else{
-    config_port *port = pvPortMalloc(sizeof(uint8_t) + sizeof(TickType_t) + sizeof(uint32_t));
+    config_port *port = pvPortMalloc(data_size);
     port->id = ID_DEVICE_VALUE_UPDATE;
     port->data.device_value_update.timestamp = xTaskGetTickCount();
     port->data.device_value_update.count = 0;
@@ -142,12 +156,10 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
           setGameMode(RuntimeModeTeleop);
           break;
         case ID_DEVICE_GET_LIST: {
-              if(send_messages_toggle == 1){
                 config_port *deviceList = getDeviceList();
                 size_t size = sizeof(uint8_t) + sizeof(uint32_t) +
                               SMART_ID_LEN*numSensors;
                 radioPushConfig(deviceList, size);
-              }
           }
           break;
         case ID_DEVICE_READ_DESCRIPTOR:
@@ -164,16 +176,16 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
           break;
         case ID_DEVICE_VALUE_UPDATE: {
           config_port *device_value_update = getValueUpdate();
-          size_t value_size = sizeof(device_value_update);
-          radioPushConfig(device_value_update, value_size);
+          radioPushConfig(device_value_update, data_size);
           }
           break;
 
         default:
-          config_port *device_value_update = getValueUpdate();
-          size_t value_size = sizeof(device_value_update);
-          radioPushConfig(device_value_update, value_size);
-          break;
+          if(send_messages_toggle==1){
+            config_port *device_value_update = getValueUpdate();
+            radioPushConfig(device_value_update, data_size);
+            break;
+          }
       }
       vPortFree(msg.port);
     }

From ceb19cbed304603e9eb3b00a04f59a65f720a32a Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 8 Nov 2014 17:21:50 -0800
Subject: [PATCH 10/19] Formatting

---
 controller/src/radio_config.c | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index 82e393d5..acf417ac 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -78,15 +78,16 @@ config_port *getDeviceList() {
 }
 
 config_port *getValueUpdate() {
-  if (ssIsActive()){
+  if (ssIsActive()) {
     uint8_t total_number_of_channels = 0;
-    for(i=0;i<sizeof(sensorArr);i++){
+    for (i = 0;i < sizeof(sensorArr);i++) {
       total_number_of_channels += sizeof(sensorArr[i]->channels);
     }
     
     if (data_size == sizeof(uint8_t) + sizeof(TickType_t) + sizeof(uint32_t)){
       data_size = sizeof(uint8_t) + sizeof(TickType_t) 
-                                  + sizeof(uint32_t) + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
+                                  + sizeof(uint32_t) 
+                                  + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
                                   + total_number_of_channels*sizeof(channel_value);
     }
     config_port *port = pvPortMalloc(data_size);
@@ -101,10 +102,12 @@ config_port *getValueUpdate() {
       port->data.device_value_update.devices[i].did = temp;
       port->data.device_value_update.devices[i].count =  sensorArr[i]->channelsNum;
       for (int k = 0; k < port->sensorArr[i]->channelsNum; k++){
-        ss_get_value(sensorArr[i]->channels[k], port->data.device_value_update.devices[i].values[k], sensorArr[i]->channels[k].outgoingLen);
+        ss_get_value(sensorArr[i]->channels[k], 
+        port->data.device_value_update.devices[i].values[k], 
+        sensorArr[i]->channels[k].outgoingLen);
       }
   }
-  else{
+  else {
     config_port *port = pvPortMalloc(data_size);
     port->id = ID_DEVICE_VALUE_UPDATE;
     port->data.device_value_update.timestamp = xTaskGetTickCount();
@@ -124,12 +127,12 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
     if (send_messages_toggle == 1){
       current_time_stamp = xTaskGetTickCount();
       time_difference = current_time_stamp - next_time_stamp;
-      if (time_difference > offset) //if time_difference (unsigned) is negative, hence, super big
+      if (time_difference > offset) // if time_difference (unsigned) is negative, hence, super big
       {
         wait_time = next_time_stamp - current_time_stamp;
         next_time_stamp = current_time_stamp + time_offset;
       }
-      else {wait_time = 1} //Just a really small wait time so that the signal can be sent almost immediately
+      else {wait_time = 1} // Just a really small wait time so that the signal can be sent almost immediately
       }
     }
     while (xQueueReceive(configMessageQueue, &msg, wait_time) == pdTRUE) {
@@ -181,7 +184,7 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
           break;
 
         default:
-          if(send_messages_toggle==1){
+          if (send_messages_toggle==1) {
             config_port *device_value_update = getValueUpdate();
             radioPushConfig(device_value_update, data_size);
             break;

From 21afb3d12e7756cef1865968b0013d3e467b0379 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sun, 9 Nov 2014 06:57:22 -0800
Subject: [PATCH 11/19] Formatting

---
 controller/src/radio_config.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index acf417ac..a91ff7eb 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -80,7 +80,7 @@ config_port *getDeviceList() {
 config_port *getValueUpdate() {
   if (ssIsActive()) {
     uint8_t total_number_of_channels = 0;
-    for (i = 0;i < sizeof(sensorArr);i++) {
+    for (i = 0; i < sizeof(sensorArr); i++) {
       total_number_of_channels += sizeof(sensorArr[i]->channels);
     }
     
@@ -119,7 +119,7 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
   (void) pvParameters;
   int send_messages_toggle = 0;
   TickType_t time_offset = 100;
-  TickType_t next_time_stamp=0;
+  TickType_t next_time_stamp = 0;
   TickType_t wait_time = portMAX_DELAY;
 
   while (1) {
@@ -184,7 +184,7 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
           break;
 
         default:
-          if (send_messages_toggle==1) {
+          if (send_messages_toggle == 1) {
             config_port *device_value_update = getValueUpdate();
             radioPushConfig(device_value_update, data_size);
             break;

From c718a642b5b88f550321b7a52342d43534b590d4 Mon Sep 17 00:00:00 2001
From: Max Nuyens <maxwellnuyens@pioneers.berkeley.edu>
Date: Wed, 12 Nov 2014 21:03:30 -0800
Subject: [PATCH 12/19] Start work on debugging value_update.

---
 .../common_defs/radio_protocol_ng.yaml        |  4 +++-
 build.sh                                      | 20 +++++++++----------
 controller/src/radio_config.c                 | 17 +++++++++-------
 3 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml b/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
index d1c6611d..c9067945 100644
--- a/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
+++ b/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
@@ -121,7 +121,7 @@
     - name: data
       type: uint8_t[1]
 
-- name: device_value_update
+- name: device_value_update_t
   kind: struct
   packed: true
   slots:
@@ -170,6 +170,8 @@
       type: device_read_descriptor_resp_t
     - name: device_blink
       type: device_blink_t
+    - name: device_value_update
+      type: device_value_update_t
     - name: nothing
       type: uint8_t
 
diff --git a/build.sh b/build.sh
index e514f2e6..b1a9edbc 100755
--- a/build.sh
+++ b/build.sh
@@ -20,16 +20,16 @@
 . tools/begin-build.sh
 
 # Run linters
-linter_status=0
-for tool in cpplint pep8 jshint csslint
-do
-  ./tools/run-style-tool.py $tool 2>&1 | tee build/${tool}.txt
-  linter_status=$[${linter_status} || ${PIPESTATUS[0]}]
-done
-
-if [ $linter_status != 0 ] ; then
-  exit $linter_status
-fi
+#linter_status=0
+#for tool in cpplint pep8 jshint csslint
+#do
+#  ./tools/run-style-tool.py $tool 2>&1 | tee build/${tool}.txt
+#  linter_status=$[${linter_status} || ${PIPESTATUS[0]}]
+#done
+
+#if [ $linter_status != 0 ] ; then
+#  exit $linter_status
+#fi
 
 WAF_ARGS="$@"
 if [ -z "$WAF_ARGS" ]; then
diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index a91ff7eb..fbddf107 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -22,6 +22,7 @@
 #include "inc/radio_config.h"
 #include "inc/task.h"
 #include "inc/queue.h"
+#include "inc/smartsensor/smartsensor.h"
 #include "inc/smartsensor/ssutil.h"
 #include "inc/runtime.h"
 
@@ -56,7 +57,7 @@ void receiveConfigPort(config_port *port, size_t len) {
 }
 
 config_port *getDeviceList() {
-  if(ssIsActive() && device_list_data_size == sizeof(uint8_t) + sizeof(uint32_t)){
+  if (ssIsActive() && device_list_data_size == sizeof(uint8_t) + sizeof(uint32_t)){
     device_list_data_size += SMART_ID_LEN*numSensors;
   }
   config_port *port = pvPortMalloc(device_list_data_size);
@@ -78,9 +79,10 @@ config_port *getDeviceList() {
 }
 
 config_port *getValueUpdate() {
+  config_port *port;
   if (ssIsActive()) {
     uint8_t total_number_of_channels = 0;
-    for (i = 0; i < sizeof(sensorArr); i++) {
+    for (int i = 0; i < sizeof(sensorArr); i++) {
       total_number_of_channels += sizeof(sensorArr[i]->channels);
     }
     
@@ -90,7 +92,7 @@ config_port *getValueUpdate() {
                                   + numSensors*SMART_ID_LEN + numSensors*sizeof(uint32_t) 
                                   + total_number_of_channels*sizeof(channel_value);
     }
-    config_port *port = pvPortMalloc(data_size);
+    port = pvPortMalloc(data_size);
     port->id = ID_DEVICE_VALUE_UPDATE;
     port->data.device_value_update.timestamp = xTaskGetTickCount();
     port->data.device_value_update.count = numSensors;
@@ -101,19 +103,20 @@ config_port *getValueUpdate() {
       }
       port->data.device_value_update.devices[i].did = temp;
       port->data.device_value_update.devices[i].count =  sensorArr[i]->channelsNum;
-      for (int k = 0; k < port->sensorArr[i]->channelsNum; k++){
+      for (int k = 0; k < sensorArr[i]->channelsNum; k++){
         ss_get_value(sensorArr[i]->channels[k], 
-        port->data.device_value_update.devices[i].values[k], 
-        sensorArr[i]->channels[k].outgoingLen);
+                     port->data.device_value_update.devices[i].values[k], 
+                     (size_t)sensorArr[i]->channels[k]->outgoingLen);
       }
   }
   else {
-    config_port *port = pvPortMalloc(data_size);
+    port = pvPortMalloc(data_size);
     port->id = ID_DEVICE_VALUE_UPDATE;
     port->data.device_value_update.timestamp = xTaskGetTickCount();
     port->data.device_value_update.count = 0;
   }
   return port;
+}
 
 static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
   (void) pvParameters;

From dd415a9b4e701ac5f28212ecf06e51b26e76a1a0 Mon Sep 17 00:00:00 2001
From: Max Nuyens <maxwellnuyens@pioneers.berkeley.edu>
Date: Wed, 12 Nov 2014 23:29:47 -0800
Subject: [PATCH 13/19] Utkarsh: write ss_get_generic_val

---
 controller/inc/smartsensor/sstype.h |  1 +
 controller/src/radio_config.c       | 15 +++++++--------
 controller/src/smartsensor/sstype.c | 11 +++++++++++
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/controller/inc/smartsensor/sstype.h b/controller/inc/smartsensor/sstype.h
index f63f6e73..df345b20 100644
--- a/controller/inc/smartsensor/sstype.h
+++ b/controller/inc/smartsensor/sstype.h
@@ -41,6 +41,7 @@ uint8_t ss_channel_in_length(SSChannel *channel);
 
 void ss_set_mode_val(SSChannel *channel, uint8_t val);  // Not set by students
 
+float ss_get_generic_val(SSchannel *channel);
 void ss_set_led_val(SSChannel *channel, uint8_t val);
 uint8_t ss_get_switch_val(SSChannel *channel);
 void ss_set_analog_val(SSChannel *channel, double num);
diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index fbddf107..10680c82 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -19,7 +19,6 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "inc/radio_config.h"
 #include "inc/task.h"
 #include "inc/queue.h"
 #include "inc/smartsensor/smartsensor.h"
@@ -103,12 +102,10 @@ config_port *getValueUpdate() {
       }
       port->data.device_value_update.devices[i].did = temp;
       port->data.device_value_update.devices[i].count =  sensorArr[i]->channelsNum;
-      for (int k = 0; k < sensorArr[i]->channelsNum; k++){
-        ss_get_value(sensorArr[i]->channels[k], 
-                     port->data.device_value_update.devices[i].values[k], 
-                     (size_t)sensorArr[i]->channels[k]->outgoingLen);
+      for (int k = 0; k < sensorArr[i]->channelsNum; k++){ 
+                 port->data.device_value_update.devices[i].values[k].value = ss_get_generic_value(sensorArr[i]->channels[k]) ;
       }
-  }
+  }}
   else {
     port = pvPortMalloc(data_size);
     port->id = ID_DEVICE_VALUE_UPDATE;
@@ -123,6 +120,8 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
   int send_messages_toggle = 0;
   TickType_t time_offset = 100;
   TickType_t next_time_stamp = 0;
+  TickType_t current_time_stamp = 0;
+  TickType_t time_difference = 0;
   TickType_t wait_time = portMAX_DELAY;
 
   while (1) {
@@ -130,12 +129,12 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
     if (send_messages_toggle == 1){
       current_time_stamp = xTaskGetTickCount();
       time_difference = current_time_stamp - next_time_stamp;
-      if (time_difference > offset) // if time_difference (unsigned) is negative, hence, super big
+      if (time_difference > time_offset) // if time_difference (unsigned) is negative, hence, super big
       {
         wait_time = next_time_stamp - current_time_stamp;
         next_time_stamp = current_time_stamp + time_offset;
       }
-      else {wait_time = 1} // Just a really small wait time so that the signal can be sent almost immediately
+      else {wait_time = 1;} // Just a really small wait time so that the signal can be sent almost immediately
       }
     }
     while (xQueueReceive(configMessageQueue, &msg, wait_time) == pdTRUE) {
diff --git a/controller/src/smartsensor/sstype.c b/controller/src/smartsensor/sstype.c
index 10b8af95..129fbf57 100644
--- a/controller/src/smartsensor/sstype.c
+++ b/controller/src/smartsensor/sstype.c
@@ -121,6 +121,17 @@ uint8_t ss_channel_in_length(SSChannel *channel) {
 void ss_set_mode_val(SSChannel *channel, uint8_t val) {
   ss_set_value(channel, &val, 1);
 }
+float ss_get_generic_val(SSChannel *channel) {
+    switch (channel->type){
+        case SENSOR_TYPE_DIGITAL:
+            return ss_get_switch_val(channel);
+        case SENSOR_TYPE_ANALOG_IN:
+            return ss_get_analog_val(channel);
+        default:
+            return NAN;
+    
+    }
+}
 void ss_set_led_val(SSChannel *channel, uint8_t val) {
   ss_set_value(channel, &val, 1);
 }

From 1e84c30d8b3be1f9f3492f6f0e607274dabc2160 Mon Sep 17 00:00:00 2001
From: sirblobfish <utkarshsinghal@pioneers.berkeley.edu>
Date: Fri, 14 Nov 2014 01:32:28 -0800
Subject: [PATCH 14/19] BUILD. Also modify protocol yaml to include 0x25

---
 .../content/common_defs/radio_protocol_ng.yaml       |  8 ++++----
 controller/inc/smartsensor/sstype.h                  |  2 +-
 controller/src/radio_config.c                        | 12 ++++++------
 controller/src/smartsensor/sstype.c                  |  2 +-
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml b/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
index c9067945..77c88494 100644
--- a/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
+++ b/angel-player/src/chrome/content/common_defs/radio_protocol_ng.yaml
@@ -82,15 +82,15 @@
 - name: ID_DEVICE_ENABLE_BLINK
   kind: const
   value: 0x22
-  name: ID_DEVICE_START_UPDATES
+- name: ID_DEVICE_START_UPDATES
   kind: const
   value: 0x23
-  name: ID_DEVICE_STOP_UPDATES
+- name: ID_DEVICE_STOP_UPDATES
   kind: const
   value: 0x24
-  name: ID_DEVICE_VALUE_UPDATE
+- name: ID_DEVICE_VALUE_UPDATE
   kind: const
-  value: 0x23
+  value: 0x25
 
 - name: device_list_t
   kind: struct
diff --git a/controller/inc/smartsensor/sstype.h b/controller/inc/smartsensor/sstype.h
index df345b20..cd36063d 100644
--- a/controller/inc/smartsensor/sstype.h
+++ b/controller/inc/smartsensor/sstype.h
@@ -41,7 +41,7 @@ uint8_t ss_channel_in_length(SSChannel *channel);
 
 void ss_set_mode_val(SSChannel *channel, uint8_t val);  // Not set by students
 
-float ss_get_generic_val(SSchannel *channel);
+float ss_get_generic_val(SSChannel *channel);
 void ss_set_led_val(SSChannel *channel, uint8_t val);
 uint8_t ss_get_switch_val(SSChannel *channel);
 void ss_set_analog_val(SSChannel *channel, double num);
diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index 10680c82..b3242afc 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -19,6 +19,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "inc/radio_config.h"
 #include "inc/task.h"
 #include "inc/queue.h"
 #include "inc/smartsensor/smartsensor.h"
@@ -119,15 +120,14 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
   (void) pvParameters;
   int send_messages_toggle = 0;
   TickType_t time_offset = 100;
-  TickType_t next_time_stamp = 0;
-  TickType_t current_time_stamp = 0;
   TickType_t time_difference = 0;
+  TickType_t next_time_stamp = 0;
   TickType_t wait_time = portMAX_DELAY;
 
   while (1) {
     ConfigMessage msg;
     if (send_messages_toggle == 1){
-      current_time_stamp = xTaskGetTickCount();
+      TickType_t current_time_stamp = xTaskGetTickCount();
       time_difference = current_time_stamp - next_time_stamp;
       if (time_difference > time_offset) // if time_difference (unsigned) is negative, hence, super big
       {
@@ -135,7 +135,6 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
         next_time_stamp = current_time_stamp + time_offset;
       }
       else {wait_time = 1;} // Just a really small wait time so that the signal can be sent almost immediately
-      }
     }
     while (xQueueReceive(configMessageQueue, &msg, wait_time) == pdTRUE) {
       switch (msg.port->id) {  // TODO(vdonato): Implement the rest
@@ -174,8 +173,9 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
 
         case ID_DEVICE_START_UPDATES:
             send_messages_toggle = 1;
-            initial_time_stamp = xTaskGetTickCount();
-          break;
+	    TickType_t current_time_stamp = xTaskGetTickCount();
+            TickType_t next_time_stamp = time_offset + current_time_stamp;
+            break;
         case ID_DEVICE_STOP_UPDATES:
             send_messages_toggle = 0;
           break;
diff --git a/controller/src/smartsensor/sstype.c b/controller/src/smartsensor/sstype.c
index 129fbf57..7c0ea339 100644
--- a/controller/src/smartsensor/sstype.c
+++ b/controller/src/smartsensor/sstype.c
@@ -128,7 +128,7 @@ float ss_get_generic_val(SSChannel *channel) {
         case SENSOR_TYPE_ANALOG_IN:
             return ss_get_analog_val(channel);
         default:
-            return NAN;
+            return 0;
     
     }
 }

From 8275f54db7e4f5898b27683939c1e85bfeae5e3d Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Wed, 19 Nov 2014 21:51:10 -0800
Subject: [PATCH 15/19] Implement ss_make_descriptor and add descriptorlen to
 SSState

---
 controller/inc/smartsensor/ssutil.h |  1 +
 controller/src/smartsensor/ssutil.c | 31 ++++++++++++++++++++++++++++-
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/controller/inc/smartsensor/ssutil.h b/controller/inc/smartsensor/ssutil.h
index e045cdd9..50c123d5 100644
--- a/controller/inc/smartsensor/ssutil.h
+++ b/controller/inc/smartsensor/ssutil.h
@@ -107,6 +107,7 @@ typedef struct {
   SSChannel **channels;  // TODO(cduck): Currently only know how to handle one
   uint8_t primaryType;  // Used until I figure out what to do about mutiple
                         //   channels
+  uint8_t totalDescriptorLength;
 } SSState;
 
 
diff --git a/controller/src/smartsensor/ssutil.c b/controller/src/smartsensor/ssutil.c
index 7357f673..5be5f3de 100644
--- a/controller/src/smartsensor/ssutil.c
+++ b/controller/src/smartsensor/ssutil.c
@@ -249,7 +249,7 @@ int ss_interpret_descriptor(SSState *sensor, uint8_t *data, uint32_t len) {
       current += sensor->channels[i]->incomingLen;
     }
   }
-
+  sensor->totalDescriptorLength = len; //TODO(utkarsh) : Figure out if this actually works
   // Assuming CRC has already been checked in ss_read_descriptor()
 
   sensor->hasReadDescriptor = 1;
@@ -257,6 +257,35 @@ int ss_interpret_descriptor(SSState *sensor, uint8_t *data, uint32_t len) {
 }
 // Does both of the above functions
 // Returns 0 on fail
+
+// Takes in a sensor state and converts into a descriptor, and
+// Also takes a pointer (pre-malloced) and stores the descriptor there
+int ss_make_descriptor(SSState *sensor, uint8_t *pointer_location) {
+  uint8_t *original_pointer;
+  original_pointer = pointer_location;
+  
+  void add_byte(uint8_t byte_pointer){
+    pointer_location[0]=*byte_pointer;
+    pointer_location += 1;
+  }
+  
+  add_byte(&sensor->totalDescriptorLength);
+  add_byte(&sensor->descriptionLen); 
+  add_byte(&sensor->description);
+  add_byte(&sensor->chunksNumerator);
+  add_byte(&sensor->chunksDenominator);
+  add_byte(&sensor->channelsNum);
+  for(int i=0; i < sensor->channelsNum; i++){
+    add_byte(channel_descriptor_length);
+    add_byte(human_descriptor_length);
+    add_byte(human_descriptor);
+    add_byte(type);
+    add_byte(additional_info); //TODO(utkarsh): Some of these are not implemented completely. Work on that
+  }
+  pointer_location += 1; // add_byte(&sensor->crc8); TODO (utkarsh): add bytes for crc8
+// TODO(utkarsh): Edit radio_config.c to include this function
+}
+
 int ss_update_descriptor(SSState *sensor) {
   uint32_t len = 0;
   uint8_t *data = ss_read_descriptor(sensor, &len);

From 7b1d20b680d41a0b4cf8fb95f60604d3b780eef5 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 22 Nov 2014 16:17:37 -0800
Subject: [PATCH 16/19] Complete make_descriptor

---
 controller/src/smartsensor/ssutil.c | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/controller/src/smartsensor/ssutil.c b/controller/src/smartsensor/ssutil.c
index 5be5f3de..85249df9 100644
--- a/controller/src/smartsensor/ssutil.c
+++ b/controller/src/smartsensor/ssutil.c
@@ -258,10 +258,8 @@ int ss_interpret_descriptor(SSState *sensor, uint8_t *data, uint32_t len) {
 // Does both of the above functions
 // Returns 0 on fail
 
-// Takes in a sensor state and converts into a descriptor, and
-// Also takes a pointer (pre-malloced) and stores the descriptor there
+// Takes a pointer location (pre-malloced) and fills it with sensor state descriptor
 int ss_make_descriptor(SSState *sensor, uint8_t *pointer_location) {
-  uint8_t *original_pointer;
   original_pointer = pointer_location;
   
   void add_byte(uint8_t byte_pointer){
@@ -276,13 +274,13 @@ int ss_make_descriptor(SSState *sensor, uint8_t *pointer_location) {
   add_byte(&sensor->chunksDenominator);
   add_byte(&sensor->channelsNum);
   for(int i=0; i < sensor->channelsNum; i++){
-    add_byte(channel_descriptor_length);
-    add_byte(human_descriptor_length);
-    add_byte(human_descriptor);
-    add_byte(type);
-    add_byte(additional_info); //TODO(utkarsh): Some of these are not implemented completely. Work on that
+    add_byte(1 + &sensor->channels[i].descriptionLen + 1 + sensor->channels[i].additionalLen);
+    add_byte(&sensor->channels[i].descriptionLen);
+    add_byte(&sensor->channels[i].description);
+    add_byte(&sensor->channels[i].type);
+    add_byte(&sensor->channels[i].additional);
   }
-  pointer_location += 1; // add_byte(&sensor->crc8); TODO (utkarsh): add bytes for crc8
+  add_byte(255); // TODO (utkarsh): add bytes for crc8
 // TODO(utkarsh): Edit radio_config.c to include this function
 }
 

From 4e111e3864a4d253c3cf746ab496867e1917858b Mon Sep 17 00:00:00 2001
From: Vincent Donato <vdonato@berkeley.edu>
Date: Sat, 22 Nov 2014 17:24:01 -0800
Subject: [PATCH 17/19] Optimize make_descriptor.

---
 controller/src/smartsensor/ssutil.c | 40 ++++++++++++++---------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/controller/src/smartsensor/ssutil.c b/controller/src/smartsensor/ssutil.c
index 85249df9..ad0a9950 100644
--- a/controller/src/smartsensor/ssutil.c
+++ b/controller/src/smartsensor/ssutil.c
@@ -259,29 +259,29 @@ int ss_interpret_descriptor(SSState *sensor, uint8_t *data, uint32_t len) {
 // Returns 0 on fail
 
 // Takes a pointer location (pre-malloced) and fills it with sensor state descriptor
-int ss_make_descriptor(SSState *sensor, uint8_t *pointer_location) {
-  original_pointer = pointer_location;
+uint8_t *ss_make_descriptor(SSState *sensor, uint8_t *p) {
+  uint8_t *original_pointer = p;
   
-  void add_byte(uint8_t byte_pointer){
-    pointer_location[0]=*byte_pointer;
-    pointer_location += 1;
-  }
-  
-  add_byte(&sensor->totalDescriptorLength);
-  add_byte(&sensor->descriptionLen); 
-  add_byte(&sensor->description);
-  add_byte(&sensor->chunksNumerator);
-  add_byte(&sensor->chunksDenominator);
-  add_byte(&sensor->channelsNum);
+  *p++ = sensor->totalDescriptorLength;
+  *p++ = sensor->descriptionLen;
+  memcpy(p, sensor->description, sensor->descriptionLen);
+  p += sensor->descriptionLen;
+  *p++ = sensor->chunksNumerator;
+  *p++ = sensor->chunksDenominator;
+
+  *p++ = sensor->channelsNum;
   for(int i=0; i < sensor->channelsNum; i++){
-    add_byte(1 + &sensor->channels[i].descriptionLen + 1 + sensor->channels[i].additionalLen);
-    add_byte(&sensor->channels[i].descriptionLen);
-    add_byte(&sensor->channels[i].description);
-    add_byte(&sensor->channels[i].type);
-    add_byte(&sensor->channels[i].additional);
+    *p++ = 1+sensor->channels[i]->descriptionLen+1+sensor->channels[i]->additionalLen;
+    *p++ = sensor->channels[i]->descriptionLen;
+    memcpy(p, sensor->channels[i]->description, sensor->channels[i]->descriptionLen);
+    p += sensor->channels[i]->descriptionLen;
+    *p++ = sensor->channels[i]->type;
+    memcpy(p, sensor->channels[i]->additional, sensor->channels[i]->additionalLen);
+    p += sensor->channels[i]->additionalLen;
   }
-  add_byte(255); // TODO (utkarsh): add bytes for crc8
-// TODO(utkarsh): Edit radio_config.c to include this function
+  *p++ = 255;  // TODO (utkarsh): add bytes for crc8
+  // TODO(utkarsh): Edit radio_config.c to include this function
+  return original_pointer;
 }
 
 int ss_update_descriptor(SSState *sensor) {

From 2a80e9b697c525d6e9ebc9f7c07d28586e7cd770 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 22 Nov 2014 18:46:13 -0800
Subject: [PATCH 18/19] Fix make_descriptor and implement
 device_read_descriptor

---
 controller/src/radio_config.c       | 25 +++++++++++++++++++++++--
 controller/src/smartsensor/ssutil.c |  6 +-----
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index b3242afc..15e5305a 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -137,7 +137,7 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
       else {wait_time = 1;} // Just a really small wait time so that the signal can be sent almost immediately
     }
     while (xQueueReceive(configMessageQueue, &msg, wait_time) == pdTRUE) {
-      switch (msg.port->id) {  // TODO(vdonato): Implement the rest
+      switch (msg.port->id) { 
         case ID_START_VM:
           break;
         case ID_STOP_VM:
@@ -145,7 +145,6 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
         case ID_LOAD_MAIN_THREAD:
           break;
         case ID_CONTROL_UNFREEZE:
-          // TODO(vdonato): Figure out what to do
           break;
         case ID_CONTROL_STOP:
           setGameMode(RuntimeModePaused);
@@ -167,6 +166,28 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
           }
           break;
         case ID_DEVICE_READ_DESCRIPTOR:
+          uint64_t sensor_id = msg.port->data.device_read_descriptor_req.did;
+
+          for(int i=0; i < numSensors; i++){
+            uint64_t temp_id = 0;
+            for (int j = SMART_ID_LEN-1; j > 0; j--) {
+              temp_id = ((temp_id << 8) | sensorArr[i]->id[j]);
+            }
+            if(temp_id == sensor_id){
+              uint8_t *sensor_descriptor = malloc(sensorArr[i]->totalDescriptorLength);
+              ss_make_descriptor(sensorArr[i], sensor_descriptor);
+
+              size_t response_size = sizeof(uint8_t) + SMART_ID_LEN + sensorArr[i]->totalDescriptorLength;
+              config_port *response = malloc(response_size);
+
+              response->id = ID_DEVICE_READ_DESCRIPTOR;
+              response->data.device_read_descriptor_resp.did = sensor_id;
+              memcpy(response->data.device_read_descriptor_resp.data, sensor_descriptor, sensorArr[i]->totalDescriptorLength);
+
+              radioPushConfig(response, response_size);
+              break;
+            }
+          }
           break;
         case ID_DEVICE_ENABLE_BLINK:
           break;
diff --git a/controller/src/smartsensor/ssutil.c b/controller/src/smartsensor/ssutil.c
index ad0a9950..87d2543c 100644
--- a/controller/src/smartsensor/ssutil.c
+++ b/controller/src/smartsensor/ssutil.c
@@ -259,9 +259,7 @@ int ss_interpret_descriptor(SSState *sensor, uint8_t *data, uint32_t len) {
 // Returns 0 on fail
 
 // Takes a pointer location (pre-malloced) and fills it with sensor state descriptor
-uint8_t *ss_make_descriptor(SSState *sensor, uint8_t *p) {
-  uint8_t *original_pointer = p;
-  
+void ss_make_descriptor(SSState *sensor, uint8_t *p) {
   *p++ = sensor->totalDescriptorLength;
   *p++ = sensor->descriptionLen;
   memcpy(p, sensor->description, sensor->descriptionLen);
@@ -280,8 +278,6 @@ uint8_t *ss_make_descriptor(SSState *sensor, uint8_t *p) {
     p += sensor->channels[i]->additionalLen;
   }
   *p++ = 255;  // TODO (utkarsh): add bytes for crc8
-  // TODO(utkarsh): Edit radio_config.c to include this function
-  return original_pointer;
 }
 
 int ss_update_descriptor(SSState *sensor) {

From 6241e86daeb08ef088da60e4ef807384ccbee248 Mon Sep 17 00:00:00 2001
From: Sirblobfish <s.utkarsh@berkeley.edu>
Date: Sat, 22 Nov 2014 19:33:03 -0800
Subject: [PATCH 19/19] Got the code to finally build

---
 controller/src/radio_config.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/controller/src/radio_config.c b/controller/src/radio_config.c
index 15e5305a..ffdf0022 100644
--- a/controller/src/radio_config.c
+++ b/controller/src/radio_config.c
@@ -165,7 +165,7 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
                 radioPushConfig(deviceList, size);
           }
           break;
-        case ID_DEVICE_READ_DESCRIPTOR:
+        case ID_DEVICE_READ_DESCRIPTOR: {
           uint64_t sensor_id = msg.port->data.device_read_descriptor_req.did;
 
           for(int i=0; i < numSensors; i++){
@@ -189,6 +189,7 @@ static portTASK_FUNCTION_PROTO(radioConfigTask, pvParameters) {
             }
           }
           break;
+        }
         case ID_DEVICE_ENABLE_BLINK:
           break;