Add C API to NeoPixel, example app

And refactor JS implementation on top of C.

CL: Refactor neopixel to a separate lib and add C API, add a C example app (example-neopixel-c)

PUBLISHED_FROM=bb01f7031303d0debd76ff89f7a45abc6945722d

Author: dimonomid

include/mgos_neopixel.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2014-2018 Cesanta Software Limited
+ * All rights reserved
+ */
+
+#ifndef CS_MOS_LIBS_NEOPIXEL_INCLUDE_MGOS_NEOPIXEL_H_
+#define CS_MOS_LIBS_NEOPIXEL_INCLUDE_MGOS_NEOPIXEL_H_
+
+#include <stdbool.h>
+
+#if defined(__cplusplus)
+extern "C" {  // Make sure we have C-declarations in C++ programs
+#endif
+
+/*
+ * Pixel order: RGB, GRB, or BGR.
+ */
+enum mgos_neopixel_order {
+  MGOS_NEOPIXEL_ORDER_RGB,
+  MGOS_NEOPIXEL_ORDER_GRB,
+  MGOS_NEOPIXEL_ORDER_BGR,
+};
+
+/*
+ * Opaque neopixel instance
+ */
+struct mgos_neopixel;
+
+/*
+ * Create and return a NeoPixel strip object. Example:
+ * ```c
+ * struct mgos_neopixel *mystrip = mgos_neopixel_create(
+ *     5, 16, MGOS_NEOPIXEL_ORDER_GRB);
+ * mgos_neopixel_set(mystrip, 0, 12, 34, 56);
+ * mgos_neopixel_show(mystrip);
+ *
+ * mgos_neopixel_clear(mystrip);
+ * mgos_neopixel_set(mystrip, 1, 12, 34, 56);
+ * mgos_neopixel_show(mystrip);
+ * ```
+ */
+struct mgos_neopixel *mgos_neopixel_create(int pin, int num_pixels,
+                                           enum mgos_neopixel_order order);
+
+/*
+ * Set i-th pixel's RGB value. Each color (`r`, `g`, `b`) should be an integer
+ * from 0 to 255; they are ints and not `uint8_t`s just for the FFI.
+ *
+ * Note that this only affects in-memory value of the pixel; you'll need to
+ * call `mgos_neopixel_show()` to apply changes.
+ */
+void mgos_neopixel_set(struct mgos_neopixel *np, int i, int r, int g, int b);
+
+/*
+ * Clear in-memory values of the pixels.
+ */
+void mgos_neopixel_clear(struct mgos_neopixel *np);
+
+/*
+ * Output values of the pixels.
+ */
+void mgos_neopixel_show(struct mgos_neopixel *np);
+
+/*
+ * Free neopixel instance.
+ */
+void mgos_neopixel_free(struct mgos_neopixel *np);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* CS_MOS_LIBS_NEOPIXEL_INCLUDE_MGOS_NEOPIXEL_H_ */

mjs_fs/api_neopixel.js

@@ -20,58 +20,36 @@ let NeoPixel = {
   // strip.show();
   // ```
   create: function(pin, numPixels, order) {
-    GPIO.set_mode(pin, GPIO.MODE_OUTPUT);
-    GPIO.write(pin, 0);  // Keep in reset.
-    let s = Object.create({
-      pin: pin,
-      len: numPixels * 3,
-      // Note: memory allocated here is currently not released.
-      // This should be ok for now, we don't expect strips to be re-created.
-      data: Sys.malloc(numPixels * 3),
-      order: order,
-      setPixel: NeoPixel.set,
+    return Object.create({
+      _i: NeoPixel._c(pin, numPixels, order),
+
+      setPixel: NeoPixel.setPixel,
       clear: NeoPixel.clear,
       show: NeoPixel.show,
     });
-    s.clear();
-    return s;
   },
 
   // ## **`strip.setPixel(i, r, g, b)`**
   // Set i-th's pixel's RGB value.
   // Note that this only affects in-memory value of the pixel.
-  set: function(i, r, g, b) {
-    let v0, v1, v2;
-    if (this.order === NeoPixel.RGB) {
-      v0 = r; v1 = g; v2 = b;
-    } else if (this.order === NeoPixel.GRB) {
-      v0 = g; v1 = r; v2 = b;
-    } else if (this.order === NeoPixel.BGR) {
-      v0 = b; v1 = g; v2 = r;
-    } else {
-      return;
-    }
-    this.data[i * 3] = v0;
-    this.data[i * 3 + 1] = v1;
-    this.data[i * 3 + 2] = v2;
+  setPixel: function(i, r, g, b) {
+    NeoPixel._set(this._i, i, r, g, b);
   },
 
   // ## **`strip.clear()`**
   // Clear in-memory values of the pixels.
   clear: function() {
-    for (let i = 0; i < this.len; i++) {
-      this.data[i] = 0;
-    }
+    NeoPixel._clear(this._i);
   },
 
   // ## **`strip.show()`**
   // Output values of the pixels.
   show: function() {
-    GPIO.write(this.pin, 0);
-    Sys.usleep(60);
-    BitBang.write(this.pin, BitBang.DELAY_100NSEC, 3, 8, 8, 6, this.data, this.len);
-    GPIO.write(this.pin, 0);
-    Sys.usleep(60);
-    GPIO.write(this.pin, 1);
+    NeoPixel._show(this._i);
   },
+
+  _c: ffi('void *mgos_neopixel_create(int, int, int)'),
+  _set: ffi('void mgos_neopixel_set(void *, int, int, int, int)'),
+  _clear: ffi('void mgos_neopixel_clear(void *)'),
+  _show: ffi('void mgos_neopixel_show(void *)'),
 };

src/mgos_neopixel.c

@@ -3,7 +3,85 @@
  * All rights reserved
  */
 
-#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "mgos_neopixel.h"
+
+#include "common/cs_dbg.h"
+#include "mgos_bitbang.h"
+#include "mgos_gpio.h"
+#include "mgos_system.h"
+
+#define NUM_CHANNELS 3 /* r, g, b */
+
+struct mgos_neopixel {
+  int pin;
+  int num_pixels;
+  enum mgos_neopixel_order order;
+  uint8_t *data;
+};
+
+struct mgos_neopixel *mgos_neopixel_create(int pin, int num_pixels,
+                                           enum mgos_neopixel_order order) {
+  mgos_gpio_set_mode(pin, MGOS_GPIO_MODE_OUTPUT);
+  /* Keep in reset */
+  mgos_gpio_write(pin, 0);
+
+  struct mgos_neopixel *np = calloc(1, sizeof(*np));
+  np->pin = pin;
+  np->num_pixels = num_pixels;
+  np->order = order;
+  np->data = malloc(num_pixels * NUM_CHANNELS);
+  mgos_neopixel_clear(np);
+  return np;
+}
+
+void mgos_neopixel_set(struct mgos_neopixel *np, int i, int r, int g, int b) {
+  uint8_t *p = np->data + i * NUM_CHANNELS;
+  switch (np->order) {
+    case MGOS_NEOPIXEL_ORDER_RGB:
+      p[0] = r;
+      p[1] = g;
+      p[2] = b;
+      break;
+
+    case MGOS_NEOPIXEL_ORDER_GRB:
+      p[0] = g;
+      p[1] = r;
+      p[2] = b;
+      break;
+
+    case MGOS_NEOPIXEL_ORDER_BGR:
+      p[0] = b;
+      p[1] = g;
+      p[2] = r;
+      break;
+
+    default:
+      LOG(LL_ERROR, ("Wrong order: %d", np->order));
+      break;
+  }
+}
+
+void mgos_neopixel_clear(struct mgos_neopixel *np) {
+  memset(np->data, 0, np->num_pixels * NUM_CHANNELS);
+}
+
+void mgos_neopixel_show(struct mgos_neopixel *np) {
+  mgos_gpio_write(np->pin, 0);
+  mgos_usleep(60);
+  mgos_bitbang_write_bits(np->pin, MGOS_DELAY_100NSEC, 3, 8, 8, 6, np->data,
+                          np->num_pixels * NUM_CHANNELS);
+  mgos_gpio_write(np->pin, 0);
+  mgos_usleep(60);
+  mgos_gpio_write(np->pin, 1);
+}
+
+void mgos_neopixel_free(struct mgos_neopixel *np) {
+  free(np->data);
+  free(np);
+}
 
 bool mgos_neopixel_init(void) {
   return true;