Merge remote-tracking branch 'adafruit/master'

Author: dastels

M4_Eyes/M4_Eyes.ino

@@ -36,6 +36,7 @@
 
 #define GLOBAL_VAR
 #include "globals.h"
+extern Adafruit_ImageReader reader;
 
 // Global eye state that applies to all eyes (not per-eye):
 bool     eyeInMotion = false;
@@ -56,7 +57,8 @@ uint32_t lastLightReadTime       = 0;
 float    lastLightValue          = 0.5;
 double   irisValue               = 0.5;
 int      iPupilFactor            = 42;
-uint32_t boopSum                 = 0;
+uint32_t boopSum                 = 0,
+         boopSumFiltered         = 0;
 bool     booped                  = false;
 int      fixate                  = 7;
 uint8_t  lightSensorFailCount    = 0;
@@ -106,8 +108,17 @@ SPISettings settings(DISPLAY_FREQ, MSBFIRST, SPI_MODE0);
 // the affected DMA channel (DMAbuddy::fix()).
 #define DMA_TIMEOUT ((240 * 16 * 4000) / (DISPLAY_FREQ / 1000))
 
+static inline uint16_t readBoop(void) {
+  uint16_t counter = 0;
+  pinMode(boopPin, OUTPUT);
+  digitalWrite(boopPin, HIGH);
+  pinMode(boopPin, INPUT);
+  while(digitalRead(boopPin) && (++counter < 1000));
+  return counter;
+}
+
 // Crude error handler. Prints message to Serial Monitor, blinks LED.
-void fatal(char *message, uint16_t blinkDelay) {
+void fatal(const char *message, uint16_t blinkDelay) {
   Serial.println(message);
   for(bool ledState = HIGH;; ledState = !ledState) {
     digitalWrite(LED_BUILTIN, ledState);
@@ -125,7 +136,7 @@ void setup() {
   int i = file_setup();
 
   Serial.begin(9600);
-//  while(!Serial);
+  //while(!Serial) delay(10);
 
   Serial.printf("Available RAM at start: %d\n", availableRAM());
   Serial.printf("Available flash at start: %d\n", availableNVM());
@@ -152,11 +163,43 @@ void setup() {
 #endif
 
   uint8_t e;
+  // Initialize displays
   for(e=0; e<NUM_EYES; e++) {
     eye[e].display = new Adafruit_ST7789(eye[e].spi, eye[e].cs, eye[e].dc, eye[e].rst);
     eye[e].display->init(240, 240);
-    eye[e].display->setRotation(3);
     eye[e].spi->setClockSource(DISPLAY_CLKSRC);
+    eye[e].display->fillScreen(0x1234);
+    eye[e].display->setRotation(0);
+  }
+
+  if (reader.drawBMP("/splash.bmp", *(eye[0].display), 0, 0) == IMAGE_SUCCESS) {
+    Serial.println("Splashing");
+    #if NUM_EYES > 1
+    // other eye
+    reader.drawBMP("/splash.bmp", *(eye[1].display), 0, 0);
+    #endif
+    // backlight on for a bit
+    for (int bl=0; bl<=250; bl+=10) {
+      #if NUM_EYES > 1
+      seesaw.analogWrite(SEESAW_BACKLIGHT_PIN, bl);
+      #endif
+      analogWrite(BACKLIGHT_PIN, bl);
+      delay(10);
+    }
+    delay(2000);
+    // backlight back off
+    for (int bl=250; bl>=0; bl-=10) {
+      #if NUM_EYES > 1
+      seesaw.analogWrite(SEESAW_BACKLIGHT_PIN, bl);
+      #endif
+      analogWrite(BACKLIGHT_PIN, bl);
+      delay(10);
+    }
+  }
+
+  // Initialize DMAs
+  for(e=0; e<NUM_EYES; e++) {
+    eye[e].display->setRotation(3);
     eye[e].display->fillScreen(0);
     eye[e].dma.allocate();
     eye[e].dma.setTrigger(eye[e].spi->getDMAC_ID_TX());
@@ -330,6 +373,14 @@ void setup() {
   calcDisplacement();
   Serial.printf("Free RAM: %d\n", availableRAM());
 
+  if(boopPin >= 0) {
+    boopThreshold = 0;
+    for(i=0; i<240; i++) {
+      boopThreshold += readBoop();
+    }
+    boopThreshold = boopThreshold * 110 / 100; // 10% overhead
+  }
+
   randomSeed(SysTick->VAL + analogRead(A2));
   eyeOldX = eyeNewX = eyeOldY = eyeNewY = mapRadius; // Start in center
   for(e=0; e<NUM_EYES; e++) { // For each eye...
@@ -339,6 +390,16 @@ void setup() {
   lastLightReadTime = micros() + 2000000; // Delay initial light reading
 }
 
+static inline uint16_t readLightSensor(void) {
+#if NUM_EYES > 1
+  if(lightSensorPin >= 100) {
+    return seesaw.analogRead(lightSensorPin - 100);
+  }
+#else
+  return analogRead(lightSensorPin);
+#endif
+}
+
 // LOOP FUNCTION - CALLED REPEATEDLY UNTIL POWER-OFF -----------------------
 
 /*
@@ -376,15 +437,15 @@ an independent frame rate depending on particular complexity at the moment).
 void loop() {
   if(++eyeNum >= NUM_EYES) eyeNum = 0; // Cycle through eyes...
 
-  uint8_t x = eye[eyeNum].colNum;
+  uint8_t  x = eye[eyeNum].colNum;
+  uint32_t t = micros();
 
   // If next column for this eye is not yet rendered...
   if(!eye[eyeNum].column_ready) {
     if(!x) { // If it's the first column...
 
       // ONCE-PER-FRAME EYE ANIMATION LOGIC HAPPENS HERE -------------------
 
-      uint32_t t = micros();
       float eyeX, eyeY;
       // Eye movement
       int32_t dt = t - eyeMoveStartTime;      // uS elapsed since last eye event
@@ -419,66 +480,19 @@ void loop() {
       }
 
       // Eyes fixate (are slightly crossed) -- amount is filtered for boops
-      int nufix = booped ? 150 : 7;
+      int nufix = booped ? 90 : 7;
       fixate = ((fixate * 15) + nufix) / 16;
       // save eye position to this eye's struct so it's same throughout render
       if(eyeNum & 1) eyeX += fixate; // Eyes converge slightly toward center
       else           eyeX -= fixate;
       eye[eyeNum].eyeX = eyeX;
       eye[eyeNum].eyeY = eyeY;
 
-      // Handle pupil scaling
-      if(lightSensorPin >= 0) {
-        // Read light sensor, but not too often (Seesaw hates that)
-        #define LIGHT_INTERVAL (1000000 / 8) // 8 Hz, don't poll Seesaw too often
-        if((t - lastLightReadTime) >= LIGHT_INTERVAL) {
-          // Fun fact: eyes have a "consensual response" to light -- both
-          // pupils will react even if the opposite eye is stimulated.
-          // Meaning we can get away with using a single light sensor for
-          // both eyes. This comment has nothing to do with the code.
-          uint16_t rawReading = (lightSensorPin >= 100) ?
-            seesaw.analogRead(lightSensorPin - 100) : analogRead(lightSensorPin);
-          if(rawReading <= 1023) {
-            if(rawReading < lightSensorMin)      rawReading = lightSensorMin; // Clamp light sensor range
-            else if(rawReading > lightSensorMax) rawReading = lightSensorMax; // to within usable range
-            float v = (float)(rawReading - lightSensorMin) / (float)(lightSensorMax - lightSensorMin); // 0.0 to 1.0
-            v = pow(v, lightSensorCurve);
-            lastLightValue    = irisMin + v * irisRange;
-            lastLightReadTime = t;
-            lightSensorFailCount = 0;
-          } else { // I2C error
-            if(++lightSensorFailCount >= 50) { // If repeated errors in succession...
-              lightSensorPin = -1; // Stop trying to use the light sensor
-            } else {
-              lastLightReadTime = t - LIGHT_INTERVAL + 40000; // Try again in 40 ms
-            }
-          }
-        }
-        irisValue = (irisValue * 0.97) + (lastLightValue * 0.03); // Filter response for smooth reaction
-      } else {
-        // Not light responsive. Use autonomous iris w/fractal subdivision
-        float n, sum = 0.5;
-        for(uint16_t i=0; i<IRIS_LEVELS; i++) { // 0,1,2,3,...
-          uint16_t iexp  = 1 << (i+1);          // 2,4,8,16,...
-          uint16_t imask = (iexp - 1);          // 2^i-1 (1,3,7,15,...)
-          uint16_t ibits = iris_frame & imask;  // 0 to mask
-          if(ibits) {
-            float weight = (float)ibits / (float)iexp; // 0.0 to <1.0
-            n            = iris_prev[i] * (1.0 - weight) + iris_next[i] * weight;
-          } else {
-            n            = iris_next[i];
-            iris_prev[i] = iris_next[i];
-            iris_next[i] = -0.5 + ((float)random(1000) / 999.0); // -0.5 to +0.5
-          }
-          iexp = 1 << (IRIS_LEVELS - i); // ...8,4,2,1
-          sum += n / (float)iexp;
-        }
-        irisValue = irisMin + (sum * irisRange); // 0.0-1.0 -> iris min/max
-        if((++iris_frame) >= (1 << IRIS_LEVELS)) iris_frame = 0;
-      }
-
       // pupilFactor? irisValue? TO DO: pick a name and stick with it
       eye[eyeNum].pupilFactor = irisValue;
+      // Also note - irisValue is calculated at the END of this function
+      // for the next frame (because the sensor must be read when there's
+      // no SPI traffic to the left eye)
 
       // Similar to the autonomous eye movement above -- blink start times
       // and durations are random (within ranges).
@@ -500,37 +514,39 @@ void loop() {
       int ix = (int)map2screen(mapRadius - eye[eyeNum].eyeX) + 120, // Pupil position
           iy = (int)map2screen(mapRadius - eye[eyeNum].eyeY) + 120; // on screen
       iy += irisRadius / 2; // top edge of iris (ish) in screen pixels
-      float qqq; // So many sloppy temp vars in here for now, sorry
+      float uq, lq; // So many sloppy temp vars in here for now, sorry
       if(eyeNum & 1) ix = 239 - ix; // Flip for right eye
       if(iy > upperOpen[ix]) {
-        qqq = 1.0;
+        uq = 1.0;
       } else if(iy < upperClosed[ix]) {
-        qqq = 0.0;
+        uq = 0.0;
       } else {
-        qqq = (float)(iy - upperClosed[ix]) / (float)(upperOpen[ix] - upperClosed[ix]);
+        uq = (float)(iy - upperClosed[ix]) / (float)(upperOpen[ix] - upperClosed[ix]);
+      }
+      if(booped) {
+        uq = 0.9;
+        lq = 0.7;
+      } else {
+        lq = 1.0 - uq;
       }
       // Dampen eyelid movements slightly
       // SAVE upper & lower lid factors per eye,
       // they need to stay consistent across frame
-      eye[eyeNum].upperLidFactor = (eye[eyeNum].upperLidFactor * 0.75) + (qqq * 0.25);
-      eye[eyeNum].lowerLidFactor = 1.0 - eye[eyeNum].upperLidFactor;
+      eye[eyeNum].upperLidFactor = (eye[eyeNum].upperLidFactor * 0.6) + (uq * 0.4);
+      eye[eyeNum].lowerLidFactor = (eye[eyeNum].lowerLidFactor * 0.6) + (lq * 0.4);
+
 
       // Process blinks
       if(eye[eyeNum].blink.state) { // Eye currently blinking?
         // Check if current blink state time has elapsed
         if((t - eye[eyeNum].blink.startTime) >= eye[eyeNum].blink.duration) {
-          if((eye[eyeNum].blink.state == ENBLINK) && booped) {
-            // do nothing, don't advance blink state while booped
+          if(++eye[eyeNum].blink.state > DEBLINK) { // Deblinking finished?
+            eye[eyeNum].blink.state = NOBLINK;      // No longer blinking
+            eye[eyeNum].blinkFactor = 0.0;
+          } else { // Advancing from ENBLINK to DEBLINK mode
+            eye[eyeNum].blink.duration *= 2; // DEBLINK is 1/2 ENBLINK speed
+            eye[eyeNum].blink.startTime = t;
             eye[eyeNum].blinkFactor = 1.0;
-          } else {
-            if(++eye[eyeNum].blink.state > DEBLINK) { // Deblinking finished?
-              eye[eyeNum].blink.state = NOBLINK;      // No longer blinking
-              eye[eyeNum].blinkFactor = 0.0;
-            } else { // Advancing from ENBLINK to DEBLINK mode
-              eye[eyeNum].blink.duration *= 2; // DEBLINK is 1/2 ENBLINK speed
-              eye[eyeNum].blink.startTime = t;
-              eye[eyeNum].blinkFactor = 1.0;
-            }
           }
         } else {
           eye[eyeNum].blinkFactor = (float)(t - eye[eyeNum].blink.startTime) / (float)eye[eyeNum].blink.duration;
@@ -549,21 +565,9 @@ void loop() {
 
       // Once per frame (of eye #0), reset boopSum...
       if((eyeNum == 0) && (boopPin >= 0)) {
-        if(boopSum > boopThreshold) {
+        boopSumFiltered = ((boopSumFiltered * 3) + boopSum) / 4;
+        if(boopSumFiltered > boopThreshold) {
           if(!booped) {
-            timeOfLastBlink = t;
-            // slow, intentional blink
-            uint32_t blinkDuration = random(60000, 100000);
-            // Set up durations for both eyes (if not already winking)
-            for(uint8_t e=0; e<NUM_EYES; e++) {
-//              if(eye[e].blink.state == NOBLINK) {
-              if(1) {
-                eye[e].blink.state     = ENBLINK;
-                eye[e].blink.startTime = t;
-                eye[e].blink.duration  = blinkDuration;
-              }
-            }
-            timeToNextBlink = blinkDuration * 3 + random(4000000);
             Serial.println("BOOP!");
           }
           booped = true;
@@ -813,8 +817,63 @@ void loop() {
     eye[eyeNum].display->setAddrWindow(0, 0, 240, 240);
     delayMicroseconds(1);
     digitalWrite(eye[eyeNum].dc, HIGH); // Data mode
+    if(eyeNum == (NUM_EYES-1)) {
+      // Handle pupil scaling
+      if(lightSensorPin >= 0) {
+        // Read light sensor, but not too often (Seesaw hates that)
+        #define LIGHT_INTERVAL (1000000 / 10) // 10 Hz, don't poll Seesaw too often
+        if((t - lastLightReadTime) >= LIGHT_INTERVAL) {
+          // Fun fact: eyes have a "consensual response" to light -- both
+          // pupils will react even if the opposite eye is stimulated.
+          // Meaning we can get away with using a single light sensor for
+          // both eyes. This comment has nothing to do with the code.
+          uint16_t rawReading = readLightSensor();
+          if(rawReading <= 1023) {
+            if(rawReading < lightSensorMin)      rawReading = lightSensorMin; // Clamp light sensor range
+            else if(rawReading > lightSensorMax) rawReading = lightSensorMax; // to within usable range
+            float v = (float)(rawReading - lightSensorMin) / (float)(lightSensorMax - lightSensorMin); // 0.0 to 1.0
+            v = pow(v, lightSensorCurve);
+            lastLightValue    = irisMin + v * irisRange;
+            lastLightReadTime = t;
+            lightSensorFailCount = 0;
+          } else { // I2C error
+            if(++lightSensorFailCount >= 25) { // If repeated errors in succession...
+              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 {
+        // Not light responsive. Use autonomous iris w/fractal subdivision
+        float n, sum = 0.5;
+        for(uint16_t i=0; i<IRIS_LEVELS; i++) { // 0,1,2,3,...
+          uint16_t iexp  = 1 << (i+1);          // 2,4,8,16,...
+          uint16_t imask = (iexp - 1);          // 2^i-1 (1,3,7,15,...)
+          uint16_t ibits = iris_frame & imask;  // 0 to mask
+          if(ibits) {
+            float weight = (float)ibits / (float)iexp; // 0.0 to <1.0
+            n            = iris_prev[i] * (1.0 - weight) + iris_next[i] * weight;
+          } else {
+            n            = iris_next[i];
+            iris_prev[i] = iris_next[i];
+            iris_next[i] = -0.5 + ((float)random(1000) / 999.0); // -0.5 to +0.5
+          }
+          iexp = 1 << (IRIS_LEVELS - i); // ...8,4,2,1
+          sum += n / (float)iexp;
+        }
+        irisValue = irisMin + (sum * irisRange); // 0.0-1.0 -> iris min/max
+        if((++iris_frame) >= (1 << IRIS_LEVELS)) iris_frame = 0;
+      }
+    }
   } // end first-column check
 
+  // MUST read the booper when there’s no SPI traffic across the nose!
+  if((eyeNum == (NUM_EYES-1)) && (boopPin >= 0)) {
+    boopSum += readBoop();
+  }
+
   memcpy(eye[eyeNum].dptr, &eye[eyeNum].column[eye[eyeNum].colIdx].descriptor[0], sizeof(DmacDescriptor));
   eye[eyeNum].dma_busy       = true;
   eye[eyeNum].dma.startJob();
@@ -824,13 +883,4 @@ void loop() {
   }
   eye[eyeNum].colIdx       ^= 1;    // Alternate 0/1 line structs
   eye[eyeNum].column_ready = false; // OK to render next line
-
-  if((eyeNum == 0) && (boopPin >= 0)) {
-    uint16_t counter = 0;
-    pinMode(boopPin, OUTPUT);
-    digitalWrite(boopPin, HIGH);
-    pinMode(boopPin, INPUT);
-    while(digitalRead(boopPin) && (++counter < 1000));
-    boopSum += counter;
-  }
 }

M4_Eyes/eyes/hazel/lower-symmetrical.bmp

@@ -247,7 +247,8 @@ void loadConfig(char *filename) {
 
       lightSensorPin = doc["lightSensor"]   | lightSensorPin;
       boopPin        = doc["boopSensor"]    | boopPin;
-      boopThreshold  = doc["boopThreshold"] | boopThreshold;
+// Computed at startup, NOT from file now
+//      boopThreshold  = doc["boopThreshold"] | boopThreshold;
 
       // Values that can be distinct per-eye but have a common default...
       uint16_t    pupilColor   = dwim(doc["pupilColor"] , eye[0].pupilColor),