first commit

esp8266-house-led-rgb.ino

@@ -0,0 +1,319 @@
+/*  Govee LED lights that were purcahsed from Amazon.com 100ft for 15USD.
+ *  24Vdc 6 LED in series with current limiting resistor every 19.5".
+ *  
+ *            +----B----B----B----B----B----B----2K4-------------+
+ *            |                                                  |
+ *  24Vdc ----+----R----R----R----R----R----R----2K4-----------------+
+ *            |                                                  |   |
+ *            +----G----G----G----G----G----G----3K3---------------------+
+ *            |                                                  |   |   |
+ *            |                                                  |   |   |
+ *            |                                                  |   |   |
+ *            +---------+----B----B----B----B----B----B----2K4---+   |   |
+ *                      |                                        |   |   |
+ *                      +----R----R----R----R----R----R----2K4-------+   |
+ *                      |                                        |   |   |
+ *                      +----G----G----G----G----G----G----3K3-----------+
+ *                      |                                        |   |   |
+ *                      |                control bus:         blue  red  green
+ *                      |                                        |   |   |
+ *                      ...                                    ...  ...  ...
+ *
+ *  We installed about 150ft so about 90 led circuits will need power.  ESP8266 can
+ *  do 1KHz PWM so we can use 3 pins if we want.  Another idea I had was to use lots
+ *  of pins to control 20mA LED driver ICs.  With 15 pins one could make a circuit to
+ *  drive 32 levels of current to each color giving 32,768 colors.  Each color would
+ *  have 5 npn controlling 1,2,4,8,16 LED drivers.  One could then step through 0..620mA.
+ *  
+ *  Instead we will just use PWM to give us color control.  We just need to calculate how
+ *  much current we want to send to our LED strip.  Because each circuit runs in parallel
+ *  we need to determine how much current each branch will use.  The current limiting
+ *  resistors means we can probably just use a fixed voltage supply.  With a 48Vdc supply
+ *  at max brightness green will see 9mA, blue will see 12mA, and red will see 15mA.  These
+ *  values are all pretty safe for the LED but the red would blow out a PN2222A with 1080mA.
+ *
+ *  We should be careful about the inductance of the wire.  Assuming 1/4mm diameter wire we
+ *  might have 47uH.  We can use a diode on the collector of each color to send the spikes to
+ *  the +48Vdc rail.  Each color will use an NPN-BJT, probably 3 parallel PN2222A with
+ *  ballast resitors, as buffers for the PWM signal from the esp8266.
+ *
+ *  In the end I ended up using optoisolated pwm driving three power mosfets.  This ended
+ *  up being a nuisance since the mosfet gates took forever to discharge resulting in
+ *  the LEDs staying lit when the esp8266 pulled the signal down.  I did not really fix this
+ *  but I did add a few resistors on the gate to bleed off the gate charge.  In effect the
+ *  max brightness is 0xfc instead of 0xff since the led does not turn off on 0xfd.  But that
+ *  is not really a deal-breaker, just annoying.
+ *
+ *  test using:
+ *  curl -X POST http://rain-gutter-rgb.lan.rome7.com/rgb -d "color=010101"
+ */
+#include <ESP8266WiFi.h>
+#include <WiFiClient.h>
+#include <ESP8266WiFiMulti.h> 
+#include <ESP8266mDNS.h>
+#include <ESP8266WebServer.h>
+
+ESP8266WiFiMulti wifiMulti;     // Create an instance of the ESP8266WiFiMulti class, called 'wifiMulti'
+
+uint8_t hexStr[7] = "010101";
+
+/*  131 allows for frame count, 16 colors(3), 16 transistions(1), and a null terminator
+ *  the user provides the input as utf-8 encoded hexidecimal, we need twice
+ *  the storage space, but parsing is a little easier: 2 + (2 * (3 * 16 + 16)) + 1 = 131
+ *  [?] there are 16 transistions because there is an extra transition when we
+ *      reach the end an loop to the begining
+ *  [?] frame count allows user to have an animation that is not the maximum length,
+ *      as of this note, the max frame count is 0x0f, '0f' when using a
+ */
+#define HOW_MANY_ANIMATION_FRAMES 16
+#define MAX_ANIMATE_FRAME_COUNT_LEN 2
+#define NULL_TERMINATOR_LEN 1
+#define FRAME_LEN (3 + 1)
+#define ANIMATE_BUFFER_LEN (MAX_ANIMATE_FRAME_COUNT_LEN + (2 * HOW_MANY_ANIMATION_FRAMES * FRAME_LEN) + NULL_TERMINATOR_LEN)
+#define MAX_ANIMATE_FRAME_COUNT ((ANIMATE_BUFFER_LEN - 2 - 1) / 8)
+uint8_t animateStr[ANIMATE_BUFFER_LEN];
+uint8_t animate = 0;
+
+uint8_t red = 1;
+uint8_t green = 1;
+uint8_t blue = 1;
+
+ESP8266WebServer server(80);    // Create a webserver object that listens for HTTP request on port 80
+
+void handleRoot();              // function prototypes for HTTP handlers
+void handleLogin();
+void handleNotFound();
+
+void setup(void){
+  Serial.begin(115200);         // Start the Serial communication to send messages to the computer
+  delay(10);
+  Serial.println('\n');
+
+  wifiMulti.addAP("n-phone-number-upstairs", "3103229909cedar");   // add Wi-Fi networks you want to connect to
+  wifiMulti.addAP("n-phone-number", "3103229909cedar");
+
+  Serial.println("Connecting ...");
+  int i = 0;
+  while (wifiMulti.run() != WL_CONNECTED) { // Wait for the Wi-Fi to connect: scan for Wi-Fi networks, and connect to the strongest of the networks above
+    delay(250);
+    Serial.print('.');
+  }
+  Serial.println('\n');
+  Serial.print("Connected to ");
+  Serial.println(WiFi.SSID());               // Tell us what network we're connected to
+  Serial.print("IP address:\t");
+  Serial.println(WiFi.localIP());            // Send the IP address of the ESP8266 to the computer
+  /*
+  if (MDNS.begin("rain-gutter-rgb")) {              // Start the mDNS responder for esp8266.local
+    Serial.println("mDNS responder started");
+  } else {
+    Serial.println("Error setting up MDNS responder!");
+  }
+  */
+  server.on("/", HTTP_GET, handleRoot);        // Call the 'handleRoot' function when a client requests URI "/"
+  //server.on("/login", HTTP_POST, handleLogin); // Call the 'handleLogin' function when a POST request is made to URI "/login"
+  server.on("/rgb", HTTP_POST, handleRGB); // Call the 'handleRGB' function when a POST request is made to URI "/login"
+  server.on("/dec", HTTP_GET, handleGetDec);
+  server.on("/echo", HTTP_GET, handleEchoHex);
+  server.on("/animate", HTTP_GET, handleAnimate);
+
+  server.onNotFound(handleNotFound);           // When a client requests an unknown URI (i.e. something other than "/"), call function "handleNotFound"
+
+  server.begin();                            // Actually start the server
+  Serial.println("HTTP server started");
+
+  /* esp8266 12-f breakout board has pins mapped a bit odd, and arduino esp8266 libs use GPIO pin number */
+  #define PIN_5 14 /* GPIO_14 */
+  #define PIN_6 12 /* GPIO_12 */
+  #define PIN_7 13 /* GPIO_13 */
+
+  //analogWriteFreq(1000);
+  analogWriteFreq(250);
+
+  // setup pins with a test pwm
+  analogWrite(PIN_5, red);
+  analogWrite(PIN_6, green);
+  analogWrite(PIN_7, blue);
+}
+
+void loop(void){
+  // keep track of where we are in the animation
+  uint8_t frame = 0;
+  uint8_t frameCount = 0;
+  #define KEY_FRAMES 10
+  #define MS_IN_ANIMATION_DELAY 250
+  #define TEMPORAL_LENGTH (MS_IN_ANIMATION_DELAY / KEY_FRAMES)
+  uint8_t redSubFrames[KEY_FRAMES];
+  uint8_t greenSubFrames[KEY_FRAMES];
+  uint8_t blueSubFrames[KEY_FRAMES];
+  // keep track of where we are in the subframe
+  uint8_t subframe = KEY_FRAMES;
+  /*  because subframes occur every quarter second and animation delays can be long (up to 64 seconds)
+   *  we need to guess what the next color should be for the next second based on where we are now
+   */
+  uint8_t animationDelayCounter = 0;
+  uint16_t totalSubframes = 0;
+
+  uint8_t frameAnimationDelay = 0;
+  uint8_t frameStartRed = 0;
+  uint8_t frameStartGreen = 0;
+  uint8_t frameStartBlue = 0;
+  uint8_t frameEndRed = 0;
+  uint8_t frameEndGreen = 0;
+  uint8_t frameEndBlue = 0;
+
+  // tracking temporal length so that we do not run too fast or slow based on CPU frequency
+  uint8_t delayCount = 0;
+
+  while(true) {
+    // listen for HTTP requests from clients
+    server.handleClient();
+    // check if we are supposed to animate
+    if(0 == animate) break;
+    /*  we will transition several times a second (technically serveral times per animation delay)
+     *
+     *  [?] this delay is not really necesarry, we just need a way to not run too fast
+     *
+     *  [!] this delay also reduces power consumption of the esp8266 significantly
+     *      not something we want necessarily, but worth mentioning in case one questions
+     *      what the heck is happening
+     */
+    delay(1);
+
+    if(delayCount++ < TEMPORAL_LENGTH) break;
+    // do we have any subframes to animate?
+    if(0 == subframe) {
+      // reset the subframe counter
+      subframe = KEY_FRAMES;
+      // are we done with this frame?
+      if(0 == animationDelayCounter) {
+        // move to the next frame
+        if(0 == frame) frame = (ANIMATE_BUFFER_LEN - 1) / 8;
+        frame--;
+        // get the next animation delay
+        frameAnimationDelay = animationDelayCounter = 
+        // is this a stop frame
+        if(0xff == frameAnimationDelay) { animate = 0; break; }
+        // is this a loop frame
+        if(0x00 == frameAnimationDelay) { frame = 0; continue; }
+        // set our start and end frame colors
+        frameStartRed = 0;
+        frameStartGreen = 0;
+        frameStartBlue = 0;
+        frameEndRed = 0;
+        frameEndGreen = 0;
+        frameEndBlue = 0;
+      }
+      // using the start, stop, and animation delay counter, compute subframes
+      // track progress through animation delay
+      animationDelayCounter--;
+    }
+    // set color
+    setColor(redSubFrames[subframe -1], greeenSubFrames[subframe -1], blueSubFrames[subframe -1])
+    // track progress through subframes
+    subframe--;
+  }
+}
+
+void handleRoot() {                          // When URI / is requested, send a web page with a button to toggle the LED
+  //server.send(200, "text/html", "<form action=\"/login\" method=\"POST\"><input type=\"text\" name=\"username\" placeholder=\"Username\"></br><input type=\"password\" name=\"password\" placeholder=\"Password\"></br><input type=\"submit\" value=\"Login\"></form><p>Try 'John Doe' and 'password123' ...</p>");
+  server.send(200, "text/html", "rain-gutter-rgb http-post (hex values): /rgb  color=\'RRGGBB\'");
+}
+
+void handleEchoHex() {
+  // make sure null terminated, then send as string
+  hexStr[6] = '\0';
+  server.send(200, "text/html", (char*) hexStr);
+}
+
+void handleAnimate() {
+  // turn on animate
+  animate = 1;
+}
+
+void handleGetDec() {
+  String hex =  String("");
+  server.send(200, "text/html", hex + red + "," + green + "," + blue + '\n');
+}
+
+void handleRGB() {                         // If a POST request is made to URI /login
+  if( ! server.hasArg("color")) {
+    server.send(400, "text/plain", "400: Invalid Request");         // The request is invalid, so send HTTP status 400
+    return;
+  }
+
+  // turn of animate
+  animate = 1;
+
+  // kinda lame but parsing is not super easy here
+  server.arg("color").getBytes(hexStr, 7);
+  setColor(
+    /* red */ (nibbler(hexStr[0]) << 4) + nibbler(hexStr[1]),
+    /* green */ (nibbler(hexStr[2]) << 4) + nibbler(hexStr[3]),
+    /* blue  */ (nibbler(hexStr[4]) << 4) + nibbler(hexStr[5])
+  )
+
+  /*
+  server.arg("color").substring(0, 2).toCharArray(hexStr, 2);
+  r = hexStrToInt(hexStr);
+  server.arg("color").substring(2, 4).toCharArray(hexStr, 2);
+  g = hexStrToInt(hexStr);
+  server.arg("color").substring(4, 6).toCharArray(hexStr, 2);
+  b = hexStrToInt(hexStr);
+  */
+  String info = "degub r:";
+  server.send(200, "text/html", info + red + " g:" + green + " b:" + blue + '\n');
+  //server.send(200, "text/html", "okay");
+}
+
+void setColor(uint8_t r, uint8_t g, uint8_t b) {
+  // store colors for API
+  red   = r;
+  green = g;
+  blue  = b;
+  analogWrite(PIN_5, red);
+  analogWrite(PIN_6, green);
+  analogWrite(PIN_7, blue);
+}
+// converts ASCII utf8 chars to integer values, [0..F], otherwise zero
+uint8_t nibbler(uint8_t v) {
+  switch (v) {
+    case 'f': case 'F': return 15;
+    case 'e': case 'E': return 14;
+    case 'd': case 'D': return 13;
+    case 'c': case 'C': return 12;
+    case 'b': case 'B': return 11;
+    case 'a': case 'A': return 10;
+    case '9':           return 9;
+    case '8':           return 8;
+    case '7':           return 7;
+    case '6':           return 6;
+    case '5':           return 5;
+    case '4':           return 4;
+    case '3':           return 3;
+    case '2':           return 2;
+    case '1':           return 1;
+    default:            return 0;
+  }
+}
+
+uint8_t hexStrToInt(char buf[]) {
+  return (int) strtol(buf, 0, 16);
+}
+
+void handleLogin() {                         // If a POST request is made to URI /login
+  if( ! server.hasArg("username") || ! server.hasArg("password") 
+      || server.arg("username") == NULL || server.arg("password") == NULL) { // If the POST request doesn't have username and password data
+    server.send(400, "text/plain", "400: Invalid Request");         // The request is invalid, so send HTTP status 400
+    return;
+  }
+  if(server.arg("username") == "John Doe" && server.arg("password") == "password123") { // If both the username and the password are correct
+    server.send(200, "text/html", "<h1>Welcome, " + server.arg("username") + "!</h1><p>Login successful</p>");
+  } else {                                                                              // Username and password don't match
+    server.send(401, "text/plain", "401: Unauthorized");
+  }
+}
+
+void handleNotFound(){
+  server.send(404, "text/plain", "404: Not found"); // Send HTTP status 404 (Not Found) when there's no handler for the URI in the request
+}