443 lines
19 KiB
C++
443 lines
19 KiB
C++
// Adapted by Bodmer to work with a NodeMCU and ILI9341 or ST7735 display.
|
|
//
|
|
// This code currently does not "blink" the eye!
|
|
//
|
|
// Library used is here:
|
|
// https://github.com/Bodmer/TFT_eSPI
|
|
//
|
|
// To do, maybe, one day:
|
|
// 1. Get the eye to blink
|
|
// 2. Add another screen for another eye
|
|
// 3. Add variable to set how wide open the eye is
|
|
// 4. Add a reflected highlight to the cornea
|
|
// 5. Add top eyelid shadow to eye surface
|
|
// 6. Add aliasing to blur mask edge
|
|
//
|
|
// With one lidded eye drawn the code runs at 28-33fps (at 27-40MHz SPI clock)
|
|
// which is quite reasonable. Operation at an 80MHz SPI clock is possible but
|
|
// the display may not be able to cope with a clock rate that high and the
|
|
// performance improvement is small. Operate the ESP8266 at 160MHz for best
|
|
// frame rate. Note the images are stored in SPI FLASH (PROGMEM) so performance
|
|
// will be constrained by the increased memory access time.
|
|
|
|
// Original header for this sketch is below. Note: the technical aspects of the
|
|
// text no longer apply to this modified version of the sketch:
|
|
/*
|
|
//--------------------------------------------------------------------------
|
|
// Uncanny eyes for PJRC Teensy 3.1 with Adafruit 1.5" OLED (product #1431)
|
|
// or 1.44" TFT LCD (#2088). This uses Teensy-3.1-specific features and
|
|
// WILL NOT work on normal Arduino or other boards! Use 72 MHz (Optimized)
|
|
// board speed -- OLED does not work at 96 MHz.
|
|
//
|
|
// Adafruit invests time and resources providing this open source code,
|
|
// please support Adafruit and open-source hardware by purchasing products
|
|
// from Adafruit!
|
|
//
|
|
// Written by Phil Burgess / Paint Your Dragon for Adafruit Industries.
|
|
// MIT license. SPI FIFO insight from Paul Stoffregen's ILI9341_t3 library.
|
|
// Inspired by David Boccabella's (Marcwolf) hybrid servo/OLED eye concept.
|
|
//--------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include <SPI.h>
|
|
#include <TFT_eSPI.h> // Hardware-specific library
|
|
|
|
// Enable ONE of these #includes for the various eyes:
|
|
#include "defaultEye.h" // Standard human-ish hazel eye
|
|
//#include "noScleraEye.h" // Large iris, no sclera
|
|
//#include "dragonEye.h" // Slit pupil fiery dragon/demon eye
|
|
//#include "goatEye.h" // Horizontal pupil goat/Krampus eye
|
|
|
|
|
|
#define DISPLAY_DC D3 // Data/command pin for BOTH displays
|
|
#define DISPLAY_RESET D4 // Reset pin for BOTH displays
|
|
#define SELECT_L_PIN D8 // LEFT eye chip select pin
|
|
#define SELECT_R_PIN D8 // RIGHT eye chip select pin
|
|
|
|
// INPUT CONFIG (for eye motion -- enable or comment out as needed) --------
|
|
|
|
// The ESP8266 is rather constrained here as it only has one analogue port.
|
|
// An I2C ADC could be used for more analogue channels
|
|
//#define JOYSTICK_X_PIN A0 // Analogue pin for eye horiz pos (else auto)
|
|
//#define JOYSTICK_Y_PIN A0 // Analogue pin for eye vert position (")
|
|
//#define JOYSTICK_X_FLIP // If set, reverse stick X axis
|
|
//#define JOYSTICK_Y_FLIP // If set, reverse stick Y axis
|
|
#define TRACKING // If enabled, eyelid tracks pupil
|
|
//#define IRIS_PIN A0 // Photocell or potentiometer (else auto iris)
|
|
//#define IRIS_PIN_FLIP // If set, reverse reading from dial/photocell
|
|
//#define IRIS_SMOOTH // If enabled, filter input from IRIS_PIN
|
|
#define IRIS_MIN 140 // Clip lower analogRead() range from IRIS_PIN
|
|
#define IRIS_MAX 260 // Clip upper "
|
|
#define WINK_L_PIN 0 // Pin for LEFT eye wink button
|
|
#define BLINK_PIN 1 // Pin for blink button (BOTH eyes)
|
|
#define WINK_R_PIN 2 // Pin for RIGHT eye wink button
|
|
#define AUTOBLINK // If enabled, eyes blink autonomously
|
|
|
|
// Probably don't need to edit any config below this line, -----------------
|
|
// unless building a single-eye project (pendant, etc.), in which case one
|
|
// of the two elements in the eye[] array further down can be commented out.
|
|
|
|
// Eye blinks are a tiny 3-state machine. Per-eye allows winks + blinks.
|
|
#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 {
|
|
int8_t pin; // Optional button here for indiv. wink
|
|
uint8_t state; // NOBLINK/ENBLINK/DEBLINK
|
|
int32_t duration; // Duration of blink state (micros)
|
|
uint32_t startTime; // Time (micros) of last state change
|
|
} eyeBlink;
|
|
|
|
struct {
|
|
TFT_eSPI tft; // OLED/eye[e].tft object
|
|
uint8_t cs; // Chip select pin
|
|
eyeBlink blink; // Current blink state
|
|
} eye[] = { // OK to comment out one of these for single-eye display:
|
|
TFT_eSPI(),SELECT_L_PIN,{WINK_L_PIN,NOBLINK},
|
|
//TFT_eSPI(),SELECT_R_PIN,{WINK_R_PIN,NOBLINK},
|
|
};
|
|
|
|
#define NUM_EYES (sizeof(eye) / sizeof(eye[0]))
|
|
|
|
uint32_t fstart = 0; // start time to improve frame rate calculation at startup
|
|
|
|
// INITIALIZATION -- runs once at startup ----------------------------------
|
|
|
|
void setup(void) {
|
|
uint8_t e = 0;
|
|
|
|
Serial.begin(250000);
|
|
randomSeed(analogRead(A0)); // Seed random() from floating analogue input
|
|
|
|
eye[e].tft.init();
|
|
eye[e].tft.fillScreen(TFT_BLACK);
|
|
eye[e].tft.setRotation(0);
|
|
|
|
fstart = millis()-1; // Subtract 1 to avoid divide by zero later
|
|
}
|
|
|
|
|
|
// EYE-RENDERING FUNCTION --------------------------------------------------
|
|
#define BUFFER_SIZE 256 // 64 to 512 seems optimum = 30 fps for default eye
|
|
void drawEye( // Renders one eye. Inputs must be pre-clipped & valid.
|
|
// Use native 32 bit variables where possible as this is 10% faster!
|
|
uint8_t e, // Eye array index; 0 or 1 for left/right
|
|
uint32_t iScale, // Scale factor for iris
|
|
uint32_t scleraX, // First pixel X offset into sclera image
|
|
uint32_t scleraY, // First pixel Y offset into sclera image
|
|
uint32_t uT, // Upper eyelid threshold value
|
|
uint32_t lT) { // Lower eyelid threshold value
|
|
|
|
uint32_t screenX, screenY, scleraXsave;
|
|
int32_t irisX, irisY;
|
|
uint32_t p, a;
|
|
uint32_t d;
|
|
|
|
uint32_t pixels = 0;
|
|
uint16_t pbuffer[BUFFER_SIZE]; // This one needs to be 16 bit
|
|
|
|
// 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.
|
|
|
|
//eye[e].tft.setAddrWindow(319-127, 0, 319, 127);
|
|
eye[e].tft.setAddrWindow(0, 0, 128, 128);
|
|
|
|
//digitalWrite(eye[e].cs, LOW); // Chip select
|
|
|
|
// 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;
|
|
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((pgm_read_byte(lower + screenY * SCREEN_WIDTH + screenX) <= lT) ||
|
|
(pgm_read_byte(upper + screenY * SCREEN_WIDTH + screenX) <= uT)) { // Covered by eyelid
|
|
p = 0;
|
|
} else if((irisY < 0) || (irisY >= IRIS_HEIGHT) ||
|
|
(irisX < 0) || (irisX >= IRIS_WIDTH)) { // In sclera
|
|
p = pgm_read_word(sclera + scleraY * SCLERA_WIDTH + scleraX);
|
|
} else { // Maybe iris...
|
|
p = pgm_read_word(polar + irisY * IRIS_WIDTH + irisX); // Polar angle/dist
|
|
d = (iScale * (p & 0x7F)) / 128; // Distance (Y)
|
|
if(d < IRIS_MAP_HEIGHT) { // Within iris area
|
|
a = (IRIS_MAP_WIDTH * (p >> 7)) / 512; // Angle (X)
|
|
p = pgm_read_word(iris + d * IRIS_MAP_WIDTH + a); // Pixel = iris
|
|
} else { // Not in iris
|
|
p = pgm_read_word(sclera + scleraY * SCLERA_WIDTH + scleraX); // Pixel = sclera
|
|
}
|
|
}
|
|
*(pbuffer + pixels++) = p>>8 | p<<8;
|
|
|
|
if (pixels >= BUFFER_SIZE) { yield(); eye[e].tft.pushColors((uint8_t*)pbuffer, pixels*2); pixels = 0;}
|
|
}
|
|
}
|
|
|
|
if (pixels) { eye[e].tft.pushColors(pbuffer, pixels); pixels = 0;}
|
|
}
|
|
|
|
|
|
// EYE ANIMATION -----------------------------------------------------------
|
|
|
|
const uint8_t ease[] = { // 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
|
|
uint32_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
|
|
int32_t eyeX, eyeY;
|
|
uint32_t t = micros(); // Time at start of function
|
|
|
|
Serial.print((++frames * 1000) / (millis() - fstart)); Serial.println("fps");// Show frame rate
|
|
|
|
if(++eyeIndex >= NUM_EYES) eyeIndex = 0; // Cycle through eyes, 1 per call
|
|
|
|
// Autonomous X/Y eye motion
|
|
// Periodically initiates motion to a new random point, random speed,
|
|
// holds there for random period until next motion.
|
|
|
|
static bool eyeInMotion = false;
|
|
static int32_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(3000000L); // 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(50000, 150000);//random(72000, 144000); // ~1/14 - ~1/7 sec
|
|
eyeMoveStartTime = t; // Save initial time of move
|
|
eyeInMotion = true; // Start move on next frame
|
|
}
|
|
}
|
|
|
|
// 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...
|
|
((digitalRead(BLINK_PIN) == LOW) || // blink or wink held...
|
|
digitalRead(eye[eyeIndex].blink.pin) == 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(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 if(digitalRead(eye[eyeIndex].blink.pin) == 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
|
|
|
|
// Iris scaling: remap from 0-1023 input to iris map height pixel units
|
|
iScale = ((IRIS_MAP_HEIGHT + 1) * 1024) /
|
|
(1024 - (iScale * (IRIS_MAP_HEIGHT - 1) / IRIS_MAP_HEIGHT));
|
|
|
|
// Scale eye X/Y positions (0-1023) to pixel units used by drawEye()
|
|
eyeX = map(eyeX, 0, 1023, 0, SCLERA_WIDTH - 128);
|
|
eyeY = map(eyeY, 0, 1023, 0, SCLERA_HEIGHT - 128);
|
|
if(eyeIndex == 1) eyeX = (SCLERA_WIDTH - 128) - 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...
|
|
eyeX += 4;
|
|
if(eyeX > (SCLERA_WIDTH - 128)) eyeX = (SCLERA_WIDTH - 128);
|
|
|
|
// 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 uint8_t uThreshold = 128;
|
|
uint8_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 = (pgm_read_byte(upper + sampleY * SCREEN_WIDTH + sampleX) +
|
|
pgm_read_byte(upper + sampleY * SCREEN_WIDTH + (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(IRIS_PIN) || (IRIS_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 // !IRIS_PIN
|
|
|
|
|
|
// MAIN LOOP -- runs continuously after setup() ----------------------------
|
|
|
|
void loop() {
|
|
|
|
#if defined(IRIS_PIN) && (IRIS_PIN >= 0) // Interactive iris
|
|
|
|
uint16_t v = 512; //analogRead(IRIS_PIN); // Raw dial/photocell reading
|
|
#ifdef IRIS_PIN_FLIP
|
|
v = 1023 - v;
|
|
#endif
|
|
v = map(v, 0, 1023, IRIS_MIN, IRIS_MAX); // Scale to iris range
|
|
#ifdef IRIS_SMOOTH // Filter input (gradual motion)
|
|
static uint16_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 // IRIS_PIN
|
|
|
|
//screenshotToConsole();
|
|
}
|
|
|
|
|
|
|