Forum Rule: Always post complete source code & details to reproduce any issue!
Results 1 to 4 of 4

Thread: Uncanny Eyes and Audio Adapter Issues

  1. #1

    Uncanny Eyes and Audio Adapter Issues

    I decided to do a Halloween project (Zombie Operation Game) using Uncanny Eyes coupled with the Audio adapter to play various sound effects.

    I am using Teensy 4.1 with the Rev D audio adapter.
    Displays are two ST7789 240x240 LCDs without CS pins on SPI and SPI1. There is nothing else on the SPI buses.
    I am using the Teensy 4.1 SD card to play the wave files to avoid conflict on the main SPI bus.

    As a software test setup, I basically just have the Uncanny Eyes example, plus added the minimal WAV file playback functionality in the Audio Library to play a single file off the SD card.

    The LCDs work fine and the audio plays fine through setup until it enters the main loop where autonomous eye movements kick in and then the audio goes into a fast stutter while the LCD eye movements continue to work normally.

    I think I have ruled out any easy suspects such as pin conflicts and now wondering if the heavy lifting required by the eye rendering + using the audio library to stream WAV files is creating a conflict in some of the lower level hardware/software stuff like with DMA, which is beyond my pay grade.

    Playing around, the only thing that seemed to affect the stutter was to comment out #define USE_ASYNC_UPDATES in which case the stutter was slower but still present.

    Wondering if anyone has successfully used both Uncanny Eyes and the Audio adapter together. I couldn't find any use cases via search.

  2. #2
    Senior Member+ MichaelMeissner's Avatar
    Join Date
    Nov 2012
    Location
    Ayer Massachussetts
    Posts
    4,270
    I had done it in the days when I was using the Teensy 3.2/3.5/3.6 on the 128x128 TFT displays (in 2018) with the prop shield using the built-in DAC for the sound and encoding the sounds as RAW files built-into the Teensy.

    At the time, I needed a special version of Adafruit_ST7735.h because of conflicts in the teensy dunio libraries. I should try it out, and see if it still works.

    It might be useful to post your code.

  3. #3
    Senior Member+ MichaelMeissner's Avatar
    Join Date
    Nov 2012
    Location
    Ayer Massachussetts
    Posts
    4,270

    Cool

    I should mention a simpler approach is to use something like the dfplayer that has a SD card and can emit audio directly. There you only send it commands from the Teensy, and you don't have to have two things that both use interrupts and such competing for the processor.



    I don't recall if dfrobot ships from a USA site or a Chinese site (but Digikey does have these on hand). There are a bunch of clones of the DFPlayer on ebay.
    Last edited by MichaelMeissner; 08-14-2022 at 10:55 PM.

  4. #4
    Here is the code, though it is pretty much the stock example code minus some misc stuff that wasn't being used in my particular application. I started to pull stuff out after running into the issue to try to make the code a little more readable. I soon realized that was a fools errand. Nothing that I removed changed the behavior at all.

    Using something like the DF player is definitely a fallback solution if I need to go that route.

    Code:
    // CONFIG.H
    //#define SERIAL_tt Serial // Send debug_tt output here. Must have SERIAL_tt.begin( ## )
    //#include "debug_tt.h"
    // Pin selections here are based on the original Adafruit Learning System
    // guide for the Teensy 3.x project.  Some of these pin numbers don't even
    // exist on the smaller SAMD M0 & M4 boards, so you may need to make other
    // selections:
    
    // GRAPHICS SETTINGS (appearance of eye) -----------------------------------
    
    // If using a SINGLE EYE, you might want this next line enabled, which
    // uses a simpler "football-shaped" eye that's left/right symmetrical.
    // Default shape includes the caruncle, creating distinct left/right eyes.
    // Otherwise your choice, standard is asymmetrical
    //  #define SYMMETRICAL_EYELID
    
    // Enable ONE of these #includes -- HUGE graphics tables for various eyes:
    #include "graphics/default_large.h"   // 240x240
    
    // DISPLAY HARDWARE SETTINGS (screen type & connections) -------------------
    
      //#define TFT_SPI        SPI
      //#define TFT_PERIPH     PERIPH_SPI
    
      #include <ST7789_t3.h>
      
      #define SPI_FREQ 48000000    // TFT: use max SPI (clips to 12 MHz on M0)
    
    // This table contains ONE LINE PER EYE.  The table MUST be present with
    // this name and contain ONE OR MORE lines.  Each line contains THREE items:
    // a pin number for the corresponding TFT/OLED display's SELECT line, a pin
    // pin number for that eye's "wink" button (or -1 if not used), and a screen
    // rotation value (0-3) for that eye.
    
    eyeInfo_t eyeInfo[] = {
    #ifdef ST77XX_ON_SPI_SPI1
      //CS  DC MOSI SCK RST WINK ROT INIT
      // Going to try to NO CS displays.
       {-1,  9, 11, 13,  31, -1,  0, INITR_144GREENTAB }, // LEFT EYE display-select and wink pins, no rotation
       {-1,  6, 26, 27,  32, -1,  0, INITR_144GREENTAB }, // RIGHT EYE display-select and wink pins, no rotation
    #endif
    };
    // INPUT SETTINGS (for controlling eye motion) -----------------------------
    
    // JOYSTICK_X_PIN and JOYSTICK_Y_PIN specify analog input pins for manually
    // controlling the eye with an analog joystick.  If set to -1 or if not
    // defined, the eye will move on its own.
    // IRIS_PIN speficies an analog input pin for a photocell to make pupils
    // react to light (or potentiometer for manual control).  If set to -1 or
    // if not defined, the pupils will change on their own.
    // BLINK_PIN specifies an input pin for a button (to ground) that will
    // make any/all eyes blink.  If set to -1 or if not defined, the eyes will
    // only blink if AUTOBLINK is defined, or if the eyeInfo[] table above
    // includes wink button settings for each eye.
    
    //#define JOYSTICK_X_PIN A0 // Analog pin for eye horiz pos (else auto)
    //#define JOYSTICK_Y_PIN A1 // Analog pin for eye vert position (")
    //#define JOYSTICK_X_FLIP   // If defined, reverse stick X axis
    //#define JOYSTICK_Y_FLIP   // If defined, reverse stick Y axis
    
    
    #define TRACKING            // If defined, eyelid tracks pupil
    #define AUTOBLINK           // If defined, eyes also blink autonomously
     // #define BLINK_PIN         1 // Pin for manual blink button (BOTH eyes)
     // #define LIGHT_PIN      A3 // Photocell or potentiometer (else auto iris)
     // #define LIGHT_PIN_FLIP    // If defined, reverse reading from dial/photocell
      #define LIGHT_MIN       0 // Lower reading from sensor
      #define LIGHT_MAX    1023 // Upper reading from sensor
    
    #define IRIS_SMOOTH         // If enabled, filter input from IRIS_PIN
    #if !defined(IRIS_MIN)      // Each eye might have its own MIN/MAX
      #define IRIS_MIN      120 // Iris size (0-1023) in brightest light
    #endif
    #if !defined(IRIS_MAX)
      #define IRIS_MAX      900 // Iris size (0-1023) in darkest light
    #endif
    Code:
    /*
     * Test Setup for 240x240 display using Teensy 4.1
     * 
     * Run this file, not the one in the examples directory
     * Ground = Ground
     * Vcc = 3V
     * SCL = Pin 13 / 27
     * SDA = Pin 11 / 26
     * RES = Pin 31 / 32
     * DC = Pin 9 / 6
     */
    
    //This example is configured for using 2 displays on SPI and SPI1
    //using a ST7789 240x240 display without a CS pin.
    //If using a display with a CS pin you can change pin configuration
    //in config.h
    #define USE_ASYNC_UPDATES
    #define ST77XX_ON_SPI_SPI1
    #define USE_ST7789
    //#define DEBUG_ST7789
    #define SERIAL_tt Serial // Send debug_tt output here. Must have SERIAL_tt.begin( ## )
    //#include "debug_tt.h"
    //#define BUTTON_ISR 7
    //--------------------------------------------------------------------------
    // Uncanny eyes for Halloween Project
    //
    // SEE FILE "config.h" FOR MOST CONFIGURATION (graphics, pins, display type,
    // etc).  Probably won't need to edit THIS file unless you're doing some
    // extremely custom modifications.
    //--------------------------------------------------------------------------
    #include <Audio.h>
    #include <Wire.h>
    #include <SPI.h>
    #include <SD.h>
    #include <SerialFlash.h>
    
    AudioPlaySdWav           playSdWav1;
    AudioOutputI2S           i2s1;
    AudioConnection          patchCord1(playSdWav1, 0, i2s1, 0);
    AudioConnection          patchCord2(playSdWav1, 1, i2s1, 1);
    AudioControlSGTL5000     sgtl5000_1;
    
    // Use these with the Teensy SD card reader
    #define SDCARD_CS_PIN    BUILTIN_SDCARD
    #define SDCARD_MOSI_PIN  11  // not actually used
    #define SDCARD_SCK_PIN   13  // not actually used
    
    #include <Adafruit_GFX.h>
    #include <ST7789_t3.h>
    #include <ST7735_t3.h>
    
    typedef struct {        // Struct is defined before including config.h --
      //int8_t  select;       // pin numbers for each eye's screen select line
      int8_t  cs;            // Chip select pin.
      int8_t  dc;            // DC pin
      int8_t  mosi;         // mosi
      int8_t  sck;          // sck pin
      int8_t  rst;          // reset pin
      int8_t  wink;         // and wink button (or -1 if none) specified there,
      uint8_t rotation;     // also display rotation.
      uint8_t init_option;  // option for Init
    } eyeInfo_t;
    
    typedef ST7789_t3 displayType; // Using TFT display(s)
    #define DISPLAY_SIZE 240
    
    #include "config.h"     // ****** CONFIGURATION IS DONE IN HERE ******
    
    #define RGBColor(r, g, b) ST7735_t3x::Color565(r, g, b)
    
    // A simple state machine is used to control eye blinks/winks:
    #define NOBLINK 0       // Not currently engaged in a blink
    #define ENBLINK 1       // Eyelid is currently closing
    #define DEBLINK 2       // Eyelid is currently opening
    typedef struct {
      uint8_t  state;       // NOBLINK/ENBLINK/DEBLINK
      uint32_t duration;    // Duration of blink state (micros)
      uint32_t startTime;   // Time (micros) of last state change
    } eyeBlink;
    
    #define NUM_EYES (sizeof eyeInfo / sizeof eyeInfo[0]) // config.h pin list
    
    struct {                // One-per-eye structure
      displayType *display; // -> OLED/TFT object
      eyeBlink     blink;   // Current blink/wink state
    } eye[NUM_EYES];
    
    uint32_t startTime;  // For FPS indicator
    
    //===============================================================================
    //  Initialization
    //===============================================================================
    void setup(void) {
      uint8_t e; // Eye index, 0 to NUM_EYES-1
      Serial.begin(115200);
      while (!Serial && millis() < 2000 );
      delay(500);
    
      AudioMemory(8);
      sgtl5000_1.enable();
      sgtl5000_1.volume(0.5);
      SPI.setMOSI(SDCARD_MOSI_PIN);
      SPI.setSCK(SDCARD_SCK_PIN);
      if (!(SD.begin(SDCARD_CS_PIN))) {
        while (1) {
          Serial.println("Unable to access the SD card");
          delay(500);
        }
      }   
        playSdWav1.play("Horror_Ambiance.wav");
       delay(10); // wait for library to parse WAV info
      Serial.println("Playing Audio"); 
      Serial.println("Init");
      randomSeed(analogRead(A3)); // Seed random() from floating analog input
    
      // Initialize eye objects based on eyeInfo list in config.h:
      for (e = 0; e < NUM_EYES; e++) {
        Serial.print("Create display #"); Serial.println(e);
    
        eye[e].display = new displayType(eyeInfo[e].cs, eyeInfo[e].dc,
                                         eyeInfo[e].mosi, eyeInfo[e].sck, eyeInfo[e].rst);
        eye[e].blink.state = NOBLINK;
        // If project involves only ONE eye and NO other SPI devices, its
        // select line can be permanently tied to GND and corresponding pin
        // in config.h set to -1.  Best to use it though.
        if (eyeInfo[e].cs >= 0) {
          pinMode(eyeInfo[e].cs, OUTPUT);
          digitalWrite(eyeInfo[e].cs, HIGH); // Deselect them all
        }
        // Also set up an individual eye-wink pin if defined:
        if (eyeInfo[e].wink >= 0) pinMode(eyeInfo[e].wink, INPUT_PULLUP);
      }
    #if defined(BLINK_PIN) && (BLINK_PIN >= 0)
      pinMode(BLINK_PIN, INPUT_PULLUP); // Ditto for all-eyes blink pin
    #endif
    
    #if defined(DISPLAY_RESET) && (DISPLAY_RESET >= 0)
      // Because both displays share a common reset pin, -1 is passed to
      // the display constructor above to prevent the begin() function from
      // resetting both displays after one is initialized.  Instead, handle
      // the reset manually here to take care of both displays just once:
      Serial.println("Reset displays");
      pinMode(DISPLAY_RESET, OUTPUT);
      digitalWrite(DISPLAY_RESET, LOW);  delay(1);
      digitalWrite(DISPLAY_RESET, HIGH); delay(50);
      // Alternately, all display reset pin(s) could be connected to the
      // microcontroller reset, in which case DISPLAY_RESET should be set
      // to -1 or left undefined in config.h.
    #endif
    
      // After all-displays reset, now call init/begin func for each display:
    
      for (e = 0; e < NUM_EYES; e++) {
    #ifdef USE_ST7789
        // Try to handle the ST7789 displays without CS PINS.
        if (eyeInfo[e].cs < 0) eye[e].display->init(240, 240, SPI_MODE2);
        else eye[e].display->init();
    #else
        eye[e].display->initR(eyeInfo[e].init_option);
    #endif
        Serial.print("Init ST77xx display #"); Serial.println(e);
        Serial.println("Rotate");
        eye[e].display->setRotation(eyeInfo[e].rotation);
      }
      Serial.println("done");
    
      // One of the displays is configured to mirror on the X axis.  Simplifies
      // eyelid handling in the drawEye() function -- no need for distinct
      // L-to-R or R-to-L inner loops.  Just the X coordinate of the iris is
      // then reversed when drawing this eye, so they move the same.  Magic!
    #ifdef USE_ST7789
      // The values for setRotation would be: 0XC8(-MX), 0xA8(+MY), 0x8(-MX), 0x68(+MY)
      // 0xC0, A0, 0, 60
      const uint8_t mirrorTFT[]  = { 0x80, 0x20, 0x40, 0xE0 }; // Mirror+rotate
    #else
      // The values for setRotation would be: 0XC8(-MX), 0xA8(+MY), 0x8(-MX), 0x68(+MY)
    
      const uint8_t mirrorTFT[]  = { 0x88, 0x28, 0x48, 0xE8 }; // Mirror+rotate
    #endif
    
      eye[0].display->sendCommand(
         
    #ifdef ST77XX_MADCTL
        ST77XX_MADCTL, // Current TFT lib
    #else
        ST7735_MADCTL, // Older TFT lib
    #endif
        &mirrorTFT[eyeInfo[0].rotation & 3], 1);
    
      for (e = 0; e < NUM_EYES; e++) {
        if (!eye[e].display->useFrameBuffer(1)) {
          Serial.printf("%d: Use Frame Buffer failed\n", e);
        } else {
          Serial.printf("$%d: Using Frame buffer\n", e);
        }
      }
      startTime = millis(); // For frame-rate calculation
     // DumpMemoryInfo();
    }
    
    
    // EYE-RENDERING FUNCTION --------------------------------------------------
    
    SPISettings settings(SPI_FREQ, MSBFIRST, SPI_MODE0);
    
    void drawEye( // Renders one eye.  Inputs must be pre-clipped & valid.
      uint8_t  e,       // Eye array index; 0 or 1 for left/right
      uint16_t iScale,  // Scale factor for iris (0-1023)
      uint16_t  scleraX, // First pixel X offset into sclera image
      uint16_t  scleraY, // First pixel Y offset into sclera image
      uint8_t  uT,      // Upper eyelid threshold value
      uint8_t  lT) {    // Lower eyelid threshold value
    
      uint8_t  screenX, screenY;
      uint16_t scleraXsave;
      int16_t  irisX, irisY;
      uint16_t p, a;
      uint32_t d;
      uint16_t max_d = 0;
      uint16_t max_a = 0;
      uint16_t min_d = 0xff;
      uint16_t min_a = 0xff;
      
      uint32_t  irisThreshold = (DISPLAY_SIZE * (1023 - iScale) + 512) / 1024;
      uint32_t irisScale     = IRIS_MAP_HEIGHT * 65536 / irisThreshold;
    
    
      // Set up raw pixel dump to entire screen.  Although such writes can wrap
      // around automatically from end of rect back to beginning, the region is
      // reset on each frame here in case of an SPI glitch.
      // Now just issue raw 16-bit values for every pixel...
    
      scleraXsave = scleraX; // Save initial X value to reset on each line
      irisY       = scleraY - (SCLERA_HEIGHT - IRIS_HEIGHT) / 2;
      // Lets wait for any previous update screen to complete.
      for (screenY = 0; screenY < SCREEN_HEIGHT; screenY++, scleraY++, irisY++) {
        scleraX = scleraXsave;
        irisX   = scleraXsave - (SCLERA_WIDTH - IRIS_WIDTH) / 2;
        for (screenX = 0; screenX < SCREEN_WIDTH; screenX++, scleraX++, irisX++) {
          if ((lower[screenY][screenX] <= lT) ||
              (upper[screenY][screenX] <= uT)) {             // Covered by eyelid
            p = 0;
          } else if ((irisY < 0) || (irisY >= IRIS_HEIGHT) ||
                     (irisX < 0) || (irisX >= IRIS_WIDTH)) { // In sclera
            p = sclera[scleraY][scleraX];
          } else {                                          // Maybe iris...
            p = polar[irisY][irisX];                        // Polar angle/dist
            d = p & 0x7F;                                   // Distance from edge (0-127)
            if (d < irisThreshold) {                        // Within scaled iris area
              d = d * irisScale / 65536;                    // d scaled to iris image height
              a = (IRIS_MAP_WIDTH * (p >> 7)) / 512;        // Angle (X)
              p = iris[d][a];                               // Pixel = iris
              if (d > max_d) max_d = d;
              if (a > max_a) max_a = a;
              if (d < min_d) min_d = d;
              if (a < min_a) min_a = a;
            } else {                                        // Not in iris
              p = sclera[scleraY][scleraX];                 // Pixel = sclera
            }
          }
    
          eye[e].display->drawPixel(screenX, screenY, p);
        } // end column
      } // end scanline
    #ifdef DEBUG_ST7789
      eye[e].display->setCursor(0, 0);
      eye[e].display->setTextSize(2);
      eye[e].display->setTextColor(ST77XX_RED, ST77XX_BLACK);
      eye[e].display->printf("%4u %4u %5u\n(%3u,%3u)", iScale, irisThreshold, irisScale, scleraX, scleraY);
      eye[e].display->setCursor(0, DISPLAY_SIZE-20);
      eye[e].display->printf("%u %3u %3u %3u %3u\n", uT, lT, eye[e].blink.state, max_d, max_a);
    
      // Debug
      static uint32_t iScale_printed[32] = {0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
      bool print_iScale = (iScale_printed[iScale>>5] & (1<<(iScale &0x1f)))? false : true;
      if (print_iScale) {
        iScale_printed[iScale>>5] |= (1<<(iScale &0x1f));
        Serial.printf("%4u : %6u %6u %4u:%4u %4u:%4u\n", iScale, irisThreshold, irisScale, min_d, max_d, min_a,max_a);
      }
    #endif
    
    #if defined(USE_ASYNC_UPDATES)
      if (!eye[e].display->updateScreenAsync()) {
        Serial.printf("%d : updateScreenAsync FAILED\n", e);
      } else {
        //Serial.printf("%d : updateScreenAsync started\n", e);
      }
    #else
      eye[e].display->updateScreen();
    #endif
    }
    
    // EYE ANIMATION -----------------------------------------------------------
    
    const uint8_t ease[] PROGMEM = { // Ease in/out curve for eye movements 3*t^2-2*t^3
      0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  2,  2,  2,  3,   // T
      3,  3,  4,  4,  4,  5,  5,  6,  6,  7,  7,  8,  9,  9, 10, 10,   // h
      11, 12, 12, 13, 14, 15, 15, 16, 17, 18, 18, 19, 20, 21, 22, 23,   // x
      24, 25, 26, 27, 27, 28, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39,   // 2
      40, 41, 42, 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 56, 57, 58,   // A
      60, 61, 62, 63, 65, 66, 67, 69, 70, 72, 73, 74, 76, 77, 78, 80,   // l
      81, 83, 84, 85, 87, 88, 90, 91, 93, 94, 96, 97, 98, 100, 101, 103, // e
      104, 106, 107, 109, 110, 112, 113, 115, 116, 118, 119, 121, 122, 124, 125, 127, // c
      128, 130, 131, 133, 134, 136, 137, 139, 140, 142, 143, 145, 146, 148, 149, 151, // J
      152, 154, 155, 157, 158, 159, 161, 162, 164, 165, 167, 168, 170, 171, 172, 174, // a
      175, 177, 178, 179, 181, 182, 183, 185, 186, 188, 189, 190, 192, 193, 194, 195, // c
      197, 198, 199, 201, 202, 203, 204, 205, 207, 208, 209, 210, 211, 213, 214, 215, // o
      216, 217, 218, 219, 220, 221, 222, 224, 225, 226, 227, 228, 228, 229, 230, 231, // b
      232, 233, 234, 235, 236, 237, 237, 238, 239, 240, 240, 241, 242, 243, 243, 244, // s
      245, 245, 246, 246, 247, 248, 248, 249, 249, 250, 250, 251, 251, 251, 252, 252, // o
      252, 253, 253, 253, 254, 254, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255
    }; // n
    
    #ifdef AUTOBLINK
    uint32_t timeOfLastBlink = 0L, timeToNextBlink = 0L;
    #endif
    
    void frame( // Process motion for a single frame of left or right eye
      uint16_t        iScale) {     // Iris scale (0-1023) passed in
      static uint32_t frames   = 0; // Used in frame rate calculation
      static uint8_t  eyeIndex = 0; // eye[] array counter
      int16_t         eyeX, eyeY;
    
      if (++eyeIndex >= NUM_EYES) eyeIndex = 0; // Cycle through eyes, 1 per call
    #if defined(USE_ASYNC_UPDATES)
      elapsedMillis emWait = 0;
      while (eye[eyeIndex].display->asyncUpdateActive() && (emWait < 1000)) ;
      if (emWait >= 1000) Serial.println("Long wait");
    #endif
    
    
      uint32_t        t = micros(); // Time at start of function
    
      if (!(++frames & 255)) { // Every 256 frames...
        uint32_t elapsed = (millis() - startTime) / 1000;
        if (elapsed) Serial.println(frames / elapsed); // Print FPS
       // EstimateStackUsage();
      }
    
      // X/Y movement
    
    #if defined(JOYSTICK_X_PIN) && (JOYSTICK_X_PIN >= 0) && \
        defined(JOYSTICK_Y_PIN) && (JOYSTICK_Y_PIN >= 0)
    
      // Read X/Y from joystick, constrain to circle
      int16_t dx, dy;
      int32_t d;
      eyeX = analogRead(JOYSTICK_X_PIN); // Raw (unclipped) X/Y reading
      eyeY = analogRead(JOYSTICK_Y_PIN);
    #ifdef JOYSTICK_X_FLIP
      eyeX = 1023 - eyeX;
    #endif
    #ifdef JOYSTICK_Y_FLIP
      eyeY = 1023 - eyeY;
    #endif
      dx = (eyeX * 2) - 1023; // A/D exact center is at 511.5.  Scale coords
      dy = (eyeY * 2) - 1023; // X2 so range is -1023 to +1023 w/center at 0.
      if ((d = (dx * dx + dy * dy)) > (1023 * 1023)) { // Outside circle
        d    = (int32_t)sqrt((float)d);               // Distance from center
        eyeX = ((dx * 1023 / d) + 1023) / 2;          // Clip to circle edge,
        eyeY = ((dy * 1023 / d) + 1023) / 2;          // scale back to 0-1023
      }
    
    #else // Autonomous X/Y eye motion
      // Periodically initiates motion to a new random point, random speed,
      // holds there for random period until next motion.
    
      static boolean  eyeInMotion      = false;
      static int16_t  eyeOldX = 512, eyeOldY = 512, eyeNewX = 512, eyeNewY = 512;
      static uint32_t eyeMoveStartTime = 0L;
      static int32_t  eyeMoveDuration  = 0L;
    
      int32_t dt = t - eyeMoveStartTime;      // uS elapsed since last eye event
      if (eyeInMotion) {                      // Currently moving?
        if (dt >= eyeMoveDuration) {          // Time up?  Destination reached.
          eyeInMotion      = false;           // Stop moving
          eyeMoveDuration  = random(3000000); // 0-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
          int16_t e = ease[255 * dt / eyeMoveDuration] + 1;   // Ease curve
          eyeX = eyeOldX + (((eyeNewX - eyeOldX) * e) / 256); // Interp X
          eyeY = eyeOldY + (((eyeNewY - eyeOldY) * e) / 256); // and Y
        }
      } else {                                // Eye stopped
        eyeX = eyeOldX;
        eyeY = eyeOldY;
        if (dt > eyeMoveDuration) {           // Time up?  Begin new move.
          int16_t  dx, dy;
          uint32_t d;
          do {                                // Pick new dest in circle
            eyeNewX = random(1024);
            eyeNewY = random(1024);
            dx      = (eyeNewX * 2) - 1023;
            dy      = (eyeNewY * 2) - 1023;
          } while ((d = (dx * dx + dy * dy)) > (1023 * 1023)); // Keep trying
          eyeMoveDuration  = random(72000, 144000); // ~1/14 - ~1/7 sec
          eyeMoveStartTime = t;               // Save initial time of move
          eyeInMotion      = true;            // Start move on next frame
          //Serial.printf("%d: Motion: %d %d (%d,%d)\n", eyeIndex, eyeMoveStartTime,
          //eyeMoveDuration, dx, dy);
        }
      }
    
    #endif // JOYSTICK_X_PIN etc.
    
      // Blinking
    
    #ifdef AUTOBLINK
      // Similar to the autonomous eye movement above -- blink start times
      // and durations are random (within ranges).
      if ((t - timeOfLastBlink) >= timeToNextBlink) { // Start new blink?
        timeOfLastBlink = t;
        uint32_t blinkDuration = random(36000, 72000); // ~1/28 - ~1/14 sec
        // 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) {
            eye[e].blink.state     = ENBLINK;
            eye[e].blink.startTime = t;
            eye[e].blink.duration  = blinkDuration;
          }
        }
        timeToNextBlink = blinkDuration * 3 + random(4000000);
      }
    #endif
    
      if (eye[eyeIndex].blink.state) { // Eye currently blinking?
        // Check if current blink state time has elapsed
        if ((t - eye[eyeIndex].blink.startTime) >= eye[eyeIndex].blink.duration) {
          // Yes -- increment blink state, unless...
          if ((eye[eyeIndex].blink.state == ENBLINK) && ( // Enblinking and...
    #if defined(BLINK_PIN) && (BLINK_PIN >= 0)
                (digitalRead(BLINK_PIN) == LOW) ||           // blink or wink held...
    #endif
                ((eyeInfo[eyeIndex].wink >= 0) &&
                 digitalRead(eyeInfo[eyeIndex].wink) == LOW) )) {
            // Don't advance state yet -- eye is held closed instead
          } else { // No buttons, or other state...
            if (++eye[eyeIndex].blink.state > DEBLINK) { // Deblinking finished?
              eye[eyeIndex].blink.state = NOBLINK;      // No longer blinking
            } else { // Advancing from ENBLINK to DEBLINK mode
              eye[eyeIndex].blink.duration *= 2; // DEBLINK is 1/2 ENBLINK speed
              eye[eyeIndex].blink.startTime = t;
            }
          }
        }
      } else { // Not currently blinking...check buttons!
    #if defined(BLINK_PIN) && (BLINK_PIN >= 0)
        if (digitalRead(BLINK_PIN) == LOW) {
          // Manually-initiated blinks have random durations like auto-blink
          uint32_t blinkDuration = random(36000, 72000);
          for (uint8_t e = 0; e < NUM_EYES; e++) {
            if (eye[e].blink.state == NOBLINK) {
              eye[e].blink.state     = ENBLINK;
              eye[e].blink.startTime = t;
              eye[e].blink.duration  = blinkDuration;
            }
          }
        } else
    #endif
          if ((eyeInfo[eyeIndex].wink >= 0) &&
              (digitalRead(eyeInfo[eyeIndex].wink) == LOW)) { // Wink!
            eye[eyeIndex].blink.state     = ENBLINK;
            eye[eyeIndex].blink.startTime = t;
            eye[eyeIndex].blink.duration  = random(45000, 90000);
          }
      }
    
      // Process motion, blinking and iris scale into renderable values
    
      // Scale eye X/Y positions (0-1023) to pixel units used by drawEye()
      eyeX = map(eyeX, 0, 1023, 0, SCLERA_WIDTH  - DISPLAY_SIZE);
      eyeY = map(eyeY, 0, 1023, 0, SCLERA_HEIGHT - DISPLAY_SIZE);
      if (eyeIndex == 1) eyeX = (SCLERA_WIDTH - DISPLAY_SIZE) - eyeX; // Mirrored display
    
      // Horizontal position is offset so that eyes are very slightly crossed
      // to appear fixated (converged) at a conversational distance.  Number
      // here was extracted from my posterior and not mathematically based.
      // I suppose one could get all clever with a range sensor, but for now...
      if (NUM_EYES > 1) eyeX += 4;
      if (eyeX > (SCLERA_WIDTH - DISPLAY_SIZE)) eyeX = (SCLERA_WIDTH - DISPLAY_SIZE);
    
      // Eyelids are rendered using a brightness threshold image.  This same
      // map can be used to simplify another problem: making the upper eyelid
      // track the pupil (eyes tend to open only as much as needed -- e.g. look
      // down and the upper eyelid drops).  Just sample a point in the upper
      // lid map slightly above the pupil to determine the rendering threshold.
      static uint16_t uThreshold = DISPLAY_SIZE;
      uint16_t        lThreshold, n;
    #ifdef TRACKING
      int16_t sampleX = SCLERA_WIDTH  / 2 - (eyeX / 2), // Reduce X influence
              sampleY = SCLERA_HEIGHT / 2 - (eyeY + IRIS_HEIGHT / 4);
      // Eyelid is slightly asymmetrical, so two readings are taken, averaged
      if (sampleY < 0) n = 0;
      else            n = (upper[sampleY][sampleX] +
                             upper[sampleY][SCREEN_WIDTH - 1 - sampleX]) / 2;
      uThreshold = (uThreshold * 3 + n) / 4; // Filter/soften motion
      // Lower eyelid doesn't track the same way, but seems to be pulled upward
      // by tension from the upper lid.
      lThreshold = 254 - uThreshold;
    #else // No tracking -- eyelids full open unless blink modifies them
      uThreshold = lThreshold = 0;
    #endif
    
      // The upper/lower thresholds are then scaled relative to the current
      // blink position so that blinks work together with pupil tracking.
      if (eye[eyeIndex].blink.state) { // Eye currently blinking?
        uint32_t s = (t - eye[eyeIndex].blink.startTime);
        if (s >= eye[eyeIndex].blink.duration) s = 255;  // At or past blink end
        else s = 255 * s / eye[eyeIndex].blink.duration; // Mid-blink
        s          = (eye[eyeIndex].blink.state == DEBLINK) ? 1 + s : 256 - s;
        n          = (uThreshold * s + 254 * (257 - s)) / 256;
        lThreshold = (lThreshold * s + 254 * (257 - s)) / 256;
      } else {
        n          = uThreshold;
      }
    
      // Pass all the derived values to the eye-rendering function:
      drawEye(eyeIndex, iScale, eyeX, eyeY, n, lThreshold);
    }
    
    // AUTONOMOUS IRIS SCALING (if no photocell or dial) -----------------------
    
    #if !defined(LIGHT_PIN) || (LIGHT_PIN < 0)
    
    // Autonomous iris motion uses a fractal behavior to similate both the major
    // reaction of the eye plus the continuous smaller adjustments that occur.
    
    uint16_t oldIris = (IRIS_MIN + IRIS_MAX) / 2, newIris;
    
    void split( // Subdivides motion path into two sub-paths w/randimization
      int16_t  startValue, // Iris scale value (IRIS_MIN to IRIS_MAX) at start
      int16_t  endValue,   // Iris scale value at end
      uint32_t startTime,  // micros() at start
      int32_t  duration,   // Start-to-end time, in microseconds
      int16_t  range) {    // Allowable scale value variance when subdividing
    
      if (range >= 8) {    // Limit subdvision count, because recursion
        range    /= 2;     // Split range & time in half for subdivision,
        duration /= 2;     // then pick random center point within range:
        int16_t  midValue = (startValue + endValue - range) / 2 + random(range);
        uint32_t midTime  = startTime + duration;
        split(startValue, midValue, startTime, duration, range); // First half
        split(midValue  , endValue, midTime  , duration, range); // Second half
      } else {             // No more subdivisons, do iris motion...
        int32_t dt;        // Time (micros) since start of motion
        int16_t v;         // Interim value
        while ((dt = (micros() - startTime)) < duration) {
          v = startValue + (((endValue - startValue) * dt) / duration);
          if (v < IRIS_MIN)      v = IRIS_MIN; // Clip just in case
          else if (v > IRIS_MAX) v = IRIS_MAX;
          frame(v);        // Draw frame w/interim iris scale value
        }
      }
    }
    
    #endif // !LIGHT_PIN
    
    //===============================================================================
    //  Main
    //===============================================================================
    
    void loop() {
    
    #if defined(LIGHT_PIN) && (LIGHT_PIN >= 0) // Interactive iris
    
      int16_t v = analogRead(LIGHT_PIN);       // Raw dial/photocell reading
    #ifdef LIGHT_PIN_FLIP
      v = 1023 - v;                            // Reverse reading from sensor
    #endif
      if (v < LIGHT_MIN)      v = LIGHT_MIN; // Clamp light sensor range
      else if (v > LIGHT_MAX) v = LIGHT_MAX;
      v -= LIGHT_MIN;  // 0 to (LIGHT_MAX - LIGHT_MIN)
    #ifdef LIGHT_CURVE  // Apply gamma curve to sensor input?
      v = (int16_t)(pow((double)v / (double)(LIGHT_MAX - LIGHT_MIN),
                        LIGHT_CURVE) * (double)(LIGHT_MAX - LIGHT_MIN));
    #endif
      // And scale to iris range (IRIS_MAX is size at LIGHT_MIN)
      v = map(v, 0, (LIGHT_MAX - LIGHT_MIN), IRIS_MAX, IRIS_MIN);
    #ifdef IRIS_SMOOTH // Filter input (gradual motion)
      static int16_t irisValue = (IRIS_MIN + IRIS_MAX) / 2;
      irisValue = ((irisValue * 15) + v) / 16;
      frame(irisValue);
    #else // Unfiltered (immediate motion)
      frame(v);
    #endif // IRIS_SMOOTH
    
    #else  // Autonomous iris scaling -- invoke recursive function
    
      newIris = random(IRIS_MIN, IRIS_MAX);
      split(oldIris, newIris, micros(), 10000000L, IRIS_MAX - IRIS_MIN);
      oldIris = newIris;
    
    #endif // LIGHT_PIN
    
    }
    
    // from the linker
    //  extern unsigned long _stextload;
    extern unsigned long _stext;
    extern unsigned long _etext;
    //  extern unsigned long _sdataload;
    extern unsigned long _sdata;
    extern unsigned long _edata;
    extern unsigned long _sbss;
    extern unsigned long _ebss;
    //  extern unsigned long _flexram_bank_config;
    extern unsigned long _estack;
    
    void DumpMemoryInfo() {
    #if defined(__IMXRT1062__)
      uint32_t flexram_config = IOMUXC_GPR_GPR17;
      Serial.printf("IOMUXC_GPR_GPR17:%x IOMUXC_GPR_GPR16:%x IOMUXC_GPR_GPR14:%x\n",
                    flexram_config, IOMUXC_GPR_GPR16, IOMUXC_GPR_GPR14);
      Serial.printf("Initial Stack pointer: %x\n", &_estack);
      uint32_t dtcm_size = 0;
      uint32_t itcm_size = 0;
      for (; flexram_config; flexram_config >>= 2) {
        if ((flexram_config & 0x3) == 0x2) dtcm_size += 32768;
        else if ((flexram_config & 0x3) == 0x3) itcm_size += 32768;
      }
      Serial.printf("ITCM allocated: %u  DTCM allocated: %u\n", itcm_size, dtcm_size);
      Serial.printf("ITCM init range: %x - %x Count: %u\n", &_stext, &_etext, (uint32_t)&_etext - (uint32_t)&_stext);
      Serial.printf("DTCM init range: %x - %x Count: %u\n", &_sdata, &_edata, (uint32_t)&_edata - (uint32_t)&_sdata);
      Serial.printf("DTCM cleared range: %x - %x Count: %u\n", &_sbss, &_ebss, (uint32_t)&_ebss - (uint32_t)&_sbss);
      Serial.println("Now fill rest of DTCM with known pattern"); Serial.flush(); //
      // Guess of where it is safe to fill memory... Maybe address of last variable we have defined - some slop...
      for (uint32_t *pfill = (&_ebss + 1); pfill < (&itcm_size - 10); pfill++) {
        *pfill = 0x01020304;  // some random value
      }
    #endif
    }
    void EstimateStackUsage() {
    #if defined(__IMXRT1062__)
      uint32_t *pmem = (&_ebss + 1);
      while (*pmem == 0x01020304) pmem++;
      Serial.printf("Estimated max stack usage: %d\n", (uint32_t)&_estack - (uint32_t)pmem);
    #endif
    }

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •