Merge branch 'staging'

Author: rickkas7

scripts/metalsmith.js

@@ -46,6 +46,7 @@ var fs = require('fs');
 var sitemap = require('./sitemap.js');
 var buildZip = require('./buildZip.js');
 var carriersUpdate = require('./carriers-update/carriers-update.js');
+var trackerSchema = require('./tracker-schema.js');
 
 var handlebars = require('handlebars');
 var prettify = require('prettify');
@@ -90,9 +91,22 @@ exports.metalsmith = function () {
       'content/languages/**/*',
       'assets/images/**/*.ai'
     ]))
-    .use(buildZip({
-      dir: '../src/assets/files/app-notes/'
-    }))
+    .use(msIf(
+      environment === 'development',
+      buildZip({
+        dir: '../src/assets/files/app-notes/'
+    })))
+    .use(msIf(
+      environment === 'development',
+      trackerSchema({
+        dir: '../src/assets/files/tracker/',
+        officialSchema: 'tracker-edge.json',        
+        defaultSchema: 'default-schema.json',
+        fragments: [
+          'engine-schema',
+          'test-schema'
+        ]
+    })))
     // Minify CSS
     .use(cleanCSS({
       files: '**/*.css'
@@ -298,10 +312,12 @@ exports.metalsmith = function () {
       omitExtensions: ['.md'],
       omitTrailingSlashes: false
     }))
-    .use(function(files, metalsmith, done) {
+    .use(msIf(
+      environment === 'development',
+      function(files, metalsmith, done) {
       carriersUpdate.doUpdate(__dirname);
       done();
-    })
+    }))
     // Replace the {{handlebar}} markers inside Markdown files before they are rendered into HTML and
     // any other files with a .hbs extension in the src folder
     .use(inPlace({
@@ -397,6 +413,7 @@ exports.server = function (callback) {
           '../templates/layouts/workshops.hbs': 'content/workshops/**/*.md',
           '../templates/layouts/landing.hbs': 'content/*.md',
           '../templates/layouts/main.hbs': 'content/index.md',
+          '../templates/helpers/**/*.hbs': 'content/**/*.md',
           '../templates/partials/**/*.hbs': 'content/**/*.md',
           '${source}/assets/js/*.js*': true,
           '${source}/assets/files/**/*': true,

scripts/tracker-schema.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const indentLevel = 2;
+
+function updateFileIfChanged(file, newContents) {
+	let oldContents = '';
+	if (fs.existsSync(file)) {
+		oldContents = fs.readFileSync(file);
+	}
+	if (oldContents != newContents) {
+		fs.writeFileSync(file, newContents);
+	}
+}
+
+function updateConfigurationSchemas(dir, options) {
+	// console.log('updating configuration schemas ' + dir);
+
+	const originalSchemaObj = JSON.parse(fs.readFileSync(path.join(dir, options.officialSchema), 'utf8'));
+
+	// Reformat to 2 spaces per indent to make it easier to read in the code box
+	const newDefaultSchema = JSON.stringify(originalSchemaObj, null, indentLevel);
+	updateFileIfChanged(path.join(dir, options.defaultSchema), newDefaultSchema);
+
+	options.fragments.forEach(function(frag) {
+		const fragmentPath = path.join(dir, frag + '-fragment.json');
+		const fragmentObj = JSON.parse(fs.readFileSync(fragmentPath, 'utf8'));
+		const dstPath = path.join(dir, frag + '.json');
+
+		// Clean up fragment source if necessary
+		updateFileIfChanged(fragmentPath, JSON.stringify(fragmentObj, null, indentLevel));
+
+		// Duplicate original
+		let newSchema = JSON.parse(JSON.stringify(originalSchemaObj));
+
+		// Copy in new 
+		Object.keys(fragmentObj).forEach(function(key) {
+			newSchema.properties[key] = fragmentObj[key];
+		});
+
+		const newSchemaString = JSON.stringify(newSchema, null, indentLevel);
+		updateFileIfChanged(dstPath, newSchemaString);
+	});
+}
+
+
+module.exports = function(options) {
+
+	return function(files, metalsmith, done) {
+        const dir = metalsmith.path(options.dir);
+		updateConfigurationSchemas(dir, options);
+		done();
+	};
+};

src/assets/files/cloud-communication/function1.cpp

@@ -0,0 +1,53 @@
+#include "Particle.h"
+
+// The following line is optional, but it allows your code to run
+// even when not cloud connected
+SYSTEM_THREAD(ENABLED);
+
+// This allows for USB serial debug logs
+SerialLogHandler logHandler;
+
+unsigned long colorSetTime = 0;
+std::chrono::milliseconds colorExpirationTime = 10s;
+
+// Forward declarations (functions used before they're implemented)
+int setColor(String cmd);
+
+void setup()
+{
+    Particle.function("setColor", setColor);
+}
+
+void loop()
+{
+    if (colorSetTime != 0 && millis() - colorSetTime >= colorExpirationTime.count())
+    {
+        // Revert back to system color scheme
+        RGB.control(false);
+        colorSetTime = 0;
+        Log.info("reverted to normal color scheme");
+    }
+}
+
+int setColor(String cmd)
+{
+    int result = 0;
+
+    Log.info("setColor %s", cmd.c_str());
+
+    int red, green, blue;
+    if (sscanf(cmd, "%d,%d,%d", &red, &green, &blue) == 3)
+    {
+        // Override the status LED color temporarily
+        RGB.control(true);
+        RGB.color(red, green, blue);
+        colorSetTime = millis();
+
+        Log.info("red=%d green=%d blue=%d", red, green, blue);
+        result = 1;
+    }
+    else {
+        Log.info("not red,green,blue");
+    }
+    return result;
+}

src/assets/files/cloud-communication/publish1.cpp

@@ -0,0 +1,59 @@
+#include "Particle.h"
+
+// The following line is optional, but it allows your code to run
+// even when not cloud connected
+SYSTEM_THREAD(ENABLED);
+
+// This allows for USB serial debug logs
+SerialLogHandler logHandler;
+
+// Forward declarations (functions used before they're implemented)
+int getSensor();
+
+// This is the event name to publish
+const char *eventName = "testEvent";
+
+// This is how often to publish (30s = every 30 seconds)
+// Other useful units include min for minutes and h for hours.
+std::chrono::milliseconds publishPeriod = 30s;
+
+// This keeps track of the last time we published
+unsigned long lastPublishMs;
+
+void setup()
+{
+}
+
+void loop()
+{
+    // Check to see if it's time to publish
+    if (millis() - lastPublishMs >= publishPeriod.count())
+    {
+        lastPublishMs = millis();
+
+        // The event data is string but we just send our value as
+        // a ASCII formatted decimal number
+        String eventData = String::format("%d", getSensor());
+
+        // Make sure we're cloud connected before publishing
+        if (Particle.connected())
+        {
+            Particle.publish(eventName, eventData);
+
+            Log.info("published %s", eventData.c_str());
+        }
+        else
+        {
+            Log.info("not cloud connected %s", eventData.c_str());
+        }
+    }
+}
+
+int getSensor()
+{
+    // To make this tutorial function without actually
+    // requiring a sensor, we just return a random
+    // value from 0 - 4095 like you'd get from an
+    // analogRead() call
+    return rand() % 4096;
+}

src/assets/files/cloud-communication/publish2.cpp

@@ -0,0 +1,67 @@
+#include "Particle.h"
+
+// The following line is optional, but it allows your code to run
+// even when not cloud connected
+SYSTEM_THREAD(ENABLED);
+
+// This allows for USB serial debug logs
+SerialLogHandler logHandler;
+
+// Forward declarations (functions used before they're implemented)
+void getSensor(float &temperatureC, float &humidity);
+
+// This is the event name to publish
+const char *eventName = "testEvent";
+
+// This is how often to publish (30s = every 30 seconds)
+// Other useful units include min for minutes and h for hours.
+std::chrono::milliseconds publishPeriod = 30s;
+
+// This keeps track of the last time we published
+unsigned long lastPublishMs;
+
+void setup()
+{
+}
+
+void loop()
+{
+    // Check to see if it's time to publish
+    if (millis() - lastPublishMs >= publishPeriod.count())
+    {
+        lastPublishMs = millis();
+
+        // Get temperature and humidity values
+        float temperatureC, humidity;
+        getSensor(temperatureC, humidity);
+
+        // Make a comma-separated output of both values. Each
+        // value is a floating point number with 1 decimal place
+        // %f is a floating point number and the .1 is one
+        // decimal place in the float.
+        String eventData = String::format("%.1f,%.1f",
+                                          temperatureC, humidity);
+
+        // Make sure we're cloud connected before publishing
+        if (Particle.connected())
+        {
+            Particle.publish(eventName, eventData);
+
+            Log.info("published %s", eventData.c_str());
+        }
+        else
+        {
+            Log.info("not cloud connected %s", eventData.c_str());
+        }
+    }
+}
+
+void getSensor(float &temperatureC, float &humidity)
+{
+    // Return a random temperature from -20 to +40 C
+    // and a humidity from 0 to 100 just for testing
+    // purposes. You would normally get it from your
+    // sensor hardware here.
+    temperatureC = (float)(rand() % 600) / 10 - 20;
+    humidity = (float)(rand() % 1010) / 10;
+}

src/assets/files/cloud-communication/publish3.cpp

@@ -0,0 +1,48 @@
+#include "Particle.h"
+
+// The following line is optional, but it allows your code to run
+// even when not cloud connected
+SYSTEM_THREAD(ENABLED);
+
+// This allows for USB serial debug logs
+SerialLogHandler logHandler;
+
+// This is the event name to publish
+const char *eventName = "testEvent";
+
+// This is how often to publish (30s = every 30 seconds)
+// Other useful units include min for minutes and h for hours.
+std::chrono::milliseconds publishPeriod = 15s;
+
+// This keeps track of the last time we published
+unsigned long lastPublishMs;
+
+void setup()
+{
+}
+
+void loop()
+{
+    // Check to see if it's time to publish
+    if (millis() - lastPublishMs >= publishPeriod.count())
+    {
+        lastPublishMs = millis();
+
+        // Make sure we're cloud connected before publishing
+        if (Particle.connected())
+        {
+            int a = rand() % 10000;
+            float b = ((float)rand()) / 100.0;
+            bool c = (bool)(rand() % 2);
+            String d(String::format("testing %d", rand() % 1000));
+
+            char buf[256];
+            snprintf(buf, sizeof(buf), 
+                "{\"a\":%d,\"b\":%.3f,\"c\":%s,\"d\":\"%s\"}", 
+                a, b, (c ? "true" : "false"), d.c_str());
+            Particle.publish(eventName, buf);
+
+            Log.info("published %s", buf);
+        }
+    }
+}

src/assets/files/cloud-communication/publish4.cpp

@@ -0,0 +1,54 @@
+#include "Particle.h"
+
+// The following line is optional, but it allows your code to run
+// even when not cloud connected
+SYSTEM_THREAD(ENABLED);
+
+// This allows for USB serial debug logs
+SerialLogHandler logHandler;
+
+// This is the event name to publish
+const char *eventName = "testEvent";
+
+// This is how often to publish (30s = every 30 seconds)
+// Other useful units include min for minutes and h for hours.
+std::chrono::milliseconds publishPeriod = 15s;
+
+// This keeps track of the last time we published
+unsigned long lastPublishMs;
+
+void setup()
+{
+}
+
+void loop()
+{
+    // Check to see if it's time to publish
+    if (millis() - lastPublishMs >= publishPeriod.count())
+    {
+        lastPublishMs = millis();
+
+        // Make sure we're cloud connected before publishing
+        if (Particle.connected())
+        {
+            int a = rand() % 10000;
+            float b = ((float)rand()) / 100.0;
+            bool c = (bool)(rand() % 2);
+            String d(String::format("testing %d", rand() % 1000));
+
+            char buf[256];
+            JSONBufferWriter writer(buf, sizeof(buf));
+            writer.beginObject();
+                writer.name("a").value(a);
+                writer.name("b").value(b, 3);
+                writer.name("c").value(c);
+                writer.name("d").value(d);
+            writer.endObject();
+            writer.buffer()[std::min(writer.bufferSize(), writer.dataSize())] = 0;
+
+            Particle.publish(eventName, buf);
+
+            Log.info("published %s", buf);
+        }
+    }
+}