Merge pull request #881 from teejaydub/master

Integrate Watcher project via user module

Author: TheKitty

M4_Eyes/HeatSensor.cpp

@@ -0,0 +1,110 @@
+/* Read the IR sensor and try to figure out where the heat is located. 
+*/
+
+#include "HeatSensor.h"
+
+#include <Wire.h>
+#include <Adafruit_AMG88xx.h>
+
+Adafruit_AMG88xx amg;
+
+float pixels[AMG88xx_PIXEL_ARRAY_SIZE];
+
+void HeatSensor::setup()
+{
+    x = 0;
+    y = 0;
+    magnitude = 0;
+
+    bool status;
+    
+    // default settings
+    status = amg.begin();
+    if (!status) {
+        Serial.println("Could not find a valid AMG88xx sensor, check wiring!");
+        while (1);
+    }
+
+    yield();
+    delay(100); // let sensor boot up
+}
+
+// Find the approximate X and Y values of the peak temperature in the pixel array,
+// along with the magnitude of the brightest spot.
+void HeatSensor::find_focus()
+{
+    amg.readPixels(pixels);
+    yield();
+
+    x = 0, y = 0, magnitude = 0;
+    float minVal = 100, maxVal = 0;
+    int i = 0;
+    for (float yPos = 3.5; yPos > -4; yPos -= 1.0) {
+        for (float xPos = 3.5; xPos > -4; xPos -= 1.0) {
+            float p = pixels[i];
+            x += xPos * p;
+            y += yPos * p;
+            minVal = min(minVal, p);
+            maxVal = max(maxVal, p);
+            i++;
+        }
+    }
+    x = - x / AMG88xx_PIXEL_ARRAY_SIZE / 5.0;
+    y = y / AMG88xx_PIXEL_ARRAY_SIZE / 5.0;
+    x = max(-1.0, min(1.0, x));
+    y = max(-1.0, min(1.0, y));
+    magnitude = max(0, min(50, maxVal - 20));
+
+    // Report.
+#define SERIAL_OUT  3
+#if SERIAL_OUT == 1
+    // Print raw values
+    Serial.print("[");
+    for(int i=1; i<=AMG88xx_PIXEL_ARRAY_SIZE; i++){
+      Serial.print(pixels[i-1]);
+      Serial.print(", ");
+      if( i%8 == 0 ) Serial.println();
+    }
+    Serial.println("]");
+    Serial.println();
+#endif
+#if SERIAL_OUT == 2
+    // Print character-graphic array
+    const char charPixels[] = " .-*o0#";
+    Serial.println("========");
+    for (int i = 1; i <= AMG88xx_PIXEL_ARRAY_SIZE; i++) {
+      int val = min(5, round(max(0, pixels[i-1] - 20) / 2));
+      Serial.print(charPixels[val]);
+      if (i % 8 == 0) 
+        Serial.println();
+    }
+    Serial.println();
+#endif
+#if SERIAL_OUT == 3 || SERIAL_OUT == 2
+    // Print coordinates and brightness
+    Serial.print(x);
+    Serial.print(' ');
+    Serial.print(y);
+    Serial.print(' ');
+    Serial.println(magnitude);
+#endif
+}
+
+/*
+void loop() {
+    // Read all the pixels
+
+    // Find the focal point.
+    float x, y, magnitude;
+    find_focus(x, y, magnitude);
+
+    // Set diagnostic LEDs.
+    analogWrite(CENTER_LED, round(max(0, magnitude / 30) * 255));
+    analogWrite(RIGHT_LED, round(min(1.0, max(0.0, -x / 3)) * 255));
+    analogWrite(LEFT_LED, round(min(1.0, max(0.0, x / 3)) * 255));
+    analogWrite(UP_LED, round(min(1.0, max(0.0, y / 3)) * 255));
+    analogWrite(DOWN_LED, round(min(1.0, max(0.0, -y / 3)) * 255));
+
+    delay(200);
+}
+*/

M4_Eyes/HeatSensor.h

@@ -0,0 +1,29 @@
+/* Read the IR sensor and try to figure out where the heat is located. 
+
+    Orientation: Looking into the sensor, the window is on the bottom of the silver package,
+    and the Adafruit star is at the upper left.
+    X goes from about -1.0 on the left, facing out of the sensor, to +1.0 on the right.
+    Y goes roughly from -1.0 (less?) on the bottom to +1.0 on the top.
+    The sensor is oriented with its text upside down for the moment.
+    Magnitude is currently the maximum temperature of any pixel, in degrees C.
+*/
+
+#ifndef __HEAT_SENSOR_H
+#define __HEAT_SENSOR_H
+
+class HeatSensor {
+public:
+    // The current focus position, each from -1.0 .. +1.0.
+    float x, y;
+
+    // The current magnitude estimate, in degrees C.
+    float magnitude;
+
+    // Must be called once.
+    void setup();
+
+    // Reads the sensor and updates x, y, and magnitude.
+    void find_focus();
+};
+
+#endif

M4_Eyes/M4WATCH.UF2

@@ -187,22 +187,24 @@ void setup() {
   #endif
 
   yield();
-  if (arcada.drawBMP((char *)"/splash.bmp", 0, 0, (eye[0].display)) == IMAGE_SUCCESS) {
-    Serial.println("Splashing");
-    if (NUM_EYES > 1) {    // other eye
-      yield();
-      arcada.drawBMP((char *)"/splash.bmp", 0, 0, (eye[1].display));
-    }
-    // backlight on for a bit
-    for (int bl=0; bl<=250; bl+=20) {
-      arcada.setBacklight(bl);
-      delay(20);
-    }
-    delay(2000);
-    // backlight back off
-    for (int bl=250; bl>=0; bl-=20) {
-      arcada.setBacklight(bl);
-      delay(20);
+  if (showSplashScreen) {
+    if (arcada.drawBMP((char *)"/splash.bmp", 0, 0, (eye[0].display)) == IMAGE_SUCCESS) {
+      Serial.println("Splashing");
+      if (NUM_EYES > 1) {    // other eye
+        yield();
+        arcada.drawBMP((char *)"/splash.bmp", 0, 0, (eye[1].display));
+      }
+      // backlight on for a bit
+      for (int bl=0; bl<=250; bl+=20) {
+        arcada.setBacklight(bl);
+        delay(20);
+      }
+      delay(2000);
+      // backlight back off
+      for (int bl=250; bl>=0; bl-=20) {
+        arcada.setBacklight(bl);
+        delay(20);
+      }
     }
   }
 
@@ -475,8 +477,10 @@ void loop() {
       if(eyeInMotion) {                       // Currently moving?
         if(dt >= eyeMoveDuration) {           // Time up?  Destination reached.
           eyeInMotion      = false;           // Stop moving
-          eyeMoveDuration  = random(10000, 3000000); // 0.01-3 sec stop
-          eyeMoveStartTime = t;               // Save initial time of stop
+          if (moveEyesRandomly) {
+            eyeMoveDuration  = random(10000, 3000000); // 0.01-3 sec stop
+            eyeMoveStartTime = t;               // Save initial time of stop
+          }
           eyeX = eyeOldX = eyeNewX;           // Save position
           eyeY = eyeOldY = eyeNewY;
         } else { // Move time's not yet fully elapsed -- interpolate position
@@ -489,13 +493,23 @@ void loop() {
         eyeX = eyeOldX;
         eyeY = eyeOldY;
         if(dt > eyeMoveDuration) {            // Time up?  Begin new move.
+          // r is the radius in X and Y that the eye can go, from (0,0) in the center.
           float r = (float)mapDiameter - (float)DISPLAY_SIZE * M_PI_2; // radius of motion
-          r *= 0.6;
-          eyeNewX = random(-r, r);
-          float h = sqrt(r * r - x * x);
-          eyeNewY = random(-h, h);
+          r *= 0.6;  // calibration constant
+
+          if (moveEyesRandomly) {
+            eyeNewX = random(-r, r);
+            float h = sqrt(r * r - x * x);
+            eyeNewY = random(-h, h);
+          } else {
+            eyeNewX = eyeTargetX * r;
+            eyeNewY = eyeTargetY * r;
+          }
+    
           eyeNewX += mapRadius;
           eyeNewY += mapRadius;
+
+          // Set the duration for this move, and start it going.
           eyeMoveDuration  = random(83000, 166000); // ~1/12 - ~1/6 sec
           eyeMoveStartTime = t;               // Save initial time of move
           eyeInMotion      = true;            // Start move on next frame
@@ -870,8 +884,7 @@ void loop() {
               lightSensorPin = -1; // Stop trying to use the light sensor
             } else {
               lastLightReadTime = t - LIGHT_INTERVAL + 30000; // Try again in 30 ms
-            }
-          }
+            } }
         }
         irisValue = (irisValue * 0.97) + (lastLightValue * 0.03); // Filter response for smooth reaction
       } else {

M4_Eyes/M4_Eyes.ino

@@ -22,6 +22,8 @@
 
 GLOBAL_VAR Adafruit_Arcada arcada;
 
+GLOBAL_VAR bool      showSplashScreen    GLOBAL_INIT(true);   // Clear to suppress the splash screen
+
 #define MAX_DISPLAY_SIZE 240
 GLOBAL_VAR int       DISPLAY_SIZE        GLOBAL_INIT(240);    // Start with assuming a 240x240 display
 GLOBAL_VAR int       DISPLAY_X_OFFSET    GLOBAL_INIT(0);      // Used with rectangular screens
@@ -68,6 +70,11 @@ GLOBAL_VAR float     irisRange           GLOBAL_INIT(0.35);
 GLOBAL_VAR bool      tracking            GLOBAL_INIT(true);
 GLOBAL_VAR float     trackFactor         GLOBAL_INIT(0.5);
 
+// Random eye motion: provided by the base project, but overridable by user code.
+GLOBAL_VAR bool      moveEyesRandomly    GLOBAL_INIT(true);   // Clear to suppress random eye motion and let user code control it
+GLOBAL_VAR float     eyeTargetX          GLOBAL_INIT(0.0);  // THen set these continuously in user_loop.
+GLOBAL_VAR float     eyeTargetY          GLOBAL_INIT(0.0);  // Range is from -1.0 to +1.0.
+
 // Pin definition stuff will go here
 
 GLOBAL_VAR int8_t    lightSensorPin      GLOBAL_INIT(-1);

M4_Eyes/globals.h

@@ -0,0 +1,42 @@
+#if 0 // Change to 0 to disable this code (must enable ONE user*.cpp only!)
+
+#include "globals.h"
+#include "heatSensor.h"
+
+
+// For heat sensing
+HeatSensor heatSensor;
+
+// This file provides a crude way to "drop in" user code to the eyes,
+// allowing concurrent operations without having to maintain a bunch of
+// special derivatives of the eye code (which is still undergoing a lot
+// of development). Just replace the source code contents of THIS TAB ONLY,
+// compile and upload to board. Shouldn't need to modify other eye code.
+
+// User globals can go here, recommend declaring as static, e.g.:
+// static int foo = 42;
+
+// Called once near the end of the setup() function. If your code requires
+// a lot of time to initialize, make periodic calls to yield() to keep the
+// USB mass storage filesystem alive.
+void user_setup(void) {
+  showSplashScreen = false;
+  moveEyesRandomly = false;
+  heatSensor.setup();
+}
+
+// Called periodically during eye animation. This is invoked in the
+// interval before starting drawing on the last eye (left eye on MONSTER
+// M4SK, sole eye on HalloWing M0) so it won't exacerbate visible tearing
+// in eye rendering. This is also SPI "quiet time" on the MONSTER M4SK so
+// it's OK to do I2C or other communication across the bridge.
+void user_loop(void) {
+  // Estimate the focus position.
+  heatSensor.find_focus();
+
+  // Set values for the new X and Y.
+  eyeTargetX = heatSensor.x;
+  eyeTargetY = -heatSensor.y;
+}
+
+#endif // 0