uncanny eyes with Teensy 3.1
Moderators: adafruit_support_bill, adafruit
Please be positive and constructive with your questions and comments.
- merlins_ghost
- Posts: 50
- Joined: Wed Jan 07, 2015 1:39 am
Re: uncanny eyes with Teensy 3.1
This one is just a conversion of the eyelid mask to RGB. It looks like it fades to black, but that is easily adjusted to make it fade to a surrounding color by adjusting the value from the mask. Since the mask is a value from 0-255 (0=black and 255=white or full brightness), you can multiply the value by 3/4 which will give you a range from 0 to 191, then add 64 and you have 64 to 255. Using this concept you can make the value you get from the mask have as much of a gradient as you like, and setting a minimum value so it won't fade to black..
- Attachments
-
- IMG_0712.JPG (102.13 KiB) Viewed 1494 times
- trimix
- Posts: 12
- Joined: Fri Aug 08, 2014 2:45 pm
Re: uncanny eyes with Teensy 3.1
Hello merlin,
i haven't seen any modif in github.
Is it here ?
https://github.com/merlins-ghost/Uncann ... ncannyEyes
thanks
i haven't seen any modif in github.
Is it here ?
https://github.com/merlins-ghost/Uncann ... ncannyEyes
thanks
- merlins_ghost
- Posts: 50
- Joined: Wed Jan 07, 2015 1:39 am
Re: uncanny eyes with Teensy 3.1
Thanks for saying something. I reinstalled the github program just before putting out the last update and afterward for some reason it did not push out my update to the github server but on my computer it showed it had. It appears to have everything I intended pushed out now, up to and including eyelid mapping.
I will be pushing another update to that shortly as I've changed the RGBi24toRGB565 to having it's brightness variable range from 0-255 instead of 0-1 to get rid of the floating point operation.
The shaded eyelids is not yet available. There seems to be heap problems combining shaded and mapped eyelids. I'm trying to figure out to solve the problem. I may have to transition to the Teensy 3.5/3.6, but there should be more than enough free memory to make it work if I can fix the variables to one location in memory. I'm not super familiar with pointers, but I'm wondering if using pointers or static variables would help.
I will be pushing another update to that shortly as I've changed the RGBi24toRGB565 to having it's brightness variable range from 0-255 instead of 0-1 to get rid of the floating point operation.
The shaded eyelids is not yet available. There seems to be heap problems combining shaded and mapped eyelids. I'm trying to figure out to solve the problem. I may have to transition to the Teensy 3.5/3.6, but there should be more than enough free memory to make it work if I can fix the variables to one location in memory. I'm not super familiar with pointers, but I'm wondering if using pointers or static variables would help.
- trimix
- Posts: 12
- Joined: Fri Aug 08, 2014 2:45 pm
Re: uncanny eyes with Teensy 3.1
for github
make a new commit then push.
you can also have a bug with you re public key.
i also have this kind of bug after reinstall github.
make a new commit then push.
you can also have a bug with you re public key.
i also have this kind of bug after reinstall github.
- merlins_ghost
- Posts: 50
- Joined: Wed Jan 07, 2015 1:39 am
Re: uncanny eyes with Teensy 3.1
Thanks, I will check that stuff out and hopefully have something new to post soon.
- trimix
- Posts: 12
- Joined: Fri Aug 08, 2014 2:45 pm
Re: uncanny eyes with Teensy 3.1
i've seen the modif on github.
thanks
thanks
- merlins_ghost
- Posts: 50
- Joined: Wed Jan 07, 2015 1:39 am
Re: uncanny eyes with Teensy 3.1
Here are some RGB conversion routines I've written for the uncanny eyes, the first uses floating point math, is a bit slower and is in my previous posting on github and is not really named correctly. The next three are for use only integer math. I used 2 different methods on each and one method is commented out. I did not do any testing to see which is faster. The RGBi565 is simply to give brightness control to an already existing RGB565 value.
uint16_t RGBi24toRGB565(uint8_t rrr, uint8_t ggg, uint8_t bbb, float iii) //iii (0 to 1) brightness
{
return ((int(rrr*iii)>>3)<<11) | ((int(ggg*iii)>>2)<<5) | (int(bbb*iii)>>3);
}
uint16_t RGB888itoRGB565(uint8_t rrr, uint8_t ggg, uint8_t bbb, uint8_t iii) //iii (0 to 255) 0 is minimum, 255 is maximum brightness
{
// return ((int((rrr * iii)/255)>>3)<<11) | ((int((ggg * iii)/255)>>2)<<5) | (int((bbb * iii)/255)>>3);
return ((((rrr * iii)/255) & 248)<<8) | ((((ggg * iii)/255)&252)<<3) | (((bbb * iii)/255)>>3);
}
uint16_t RGB24itoRGB565(uint32_t rgb, uint8_t iii) //iii (0 to 255) 0 is minimum, 255 is maximum brightness
{
// return (((((rgb>>16) * iii)/255) & 248)<<8) | ((((((rgb>>8)&255) * iii)/255)&252)<<3) | ((((rgb&255) * iii)/255)>>3);
return (((((rgb & 0xFF0000) * iii)/255) & 0xF80000)>>8) | (((((rgb & 0x00FF00) * iii)/255) & 0x00FC00)>>5) | ((((rgb & 0x0000FF) * iii)/255)>>3);
}
uint16_t RGB565i(uint16_t rgb, uint8_t iii) //iii (0 to 255) 0 is minimum, 255 is maximum brightness
{
// return (((((rgb>>11) * iii)/255) & 31)<<11) | (((((rgb>>5)&63) * iii)/255)<<3) | ((((rgb&255) * iii)/255)>>3);
return ((((rgb&0xF800) * iii)/255) & 0xF800) | ((((rgb&0x7E0) * iii)/255) & 0x7E0) | ((((rgb&0x1F) * iii)/255) & 0x1F);
}
uint16_t RGBi24toRGB565(uint8_t rrr, uint8_t ggg, uint8_t bbb, float iii) //iii (0 to 1) brightness
{
return ((int(rrr*iii)>>3)<<11) | ((int(ggg*iii)>>2)<<5) | (int(bbb*iii)>>3);
}
uint16_t RGB888itoRGB565(uint8_t rrr, uint8_t ggg, uint8_t bbb, uint8_t iii) //iii (0 to 255) 0 is minimum, 255 is maximum brightness
{
// return ((int((rrr * iii)/255)>>3)<<11) | ((int((ggg * iii)/255)>>2)<<5) | (int((bbb * iii)/255)>>3);
return ((((rrr * iii)/255) & 248)<<8) | ((((ggg * iii)/255)&252)<<3) | (((bbb * iii)/255)>>3);
}
uint16_t RGB24itoRGB565(uint32_t rgb, uint8_t iii) //iii (0 to 255) 0 is minimum, 255 is maximum brightness
{
// return (((((rgb>>16) * iii)/255) & 248)<<8) | ((((((rgb>>8)&255) * iii)/255)&252)<<3) | ((((rgb&255) * iii)/255)>>3);
return (((((rgb & 0xFF0000) * iii)/255) & 0xF80000)>>8) | (((((rgb & 0x00FF00) * iii)/255) & 0x00FC00)>>5) | ((((rgb & 0x0000FF) * iii)/255)>>3);
}
uint16_t RGB565i(uint16_t rgb, uint8_t iii) //iii (0 to 255) 0 is minimum, 255 is maximum brightness
{
// return (((((rgb>>11) * iii)/255) & 31)<<11) | (((((rgb>>5)&63) * iii)/255)<<3) | ((((rgb&255) * iii)/255)>>3);
return ((((rgb&0xF800) * iii)/255) & 0xF800) | ((((rgb&0x7E0) * iii)/255) & 0x7E0) | ((((rgb&0x1F) * iii)/255) & 0x1F);
}
- pburgess
- Posts: 4161
- Joined: Sun Oct 26, 2008 2:29 am
Re: uncanny eyes with Teensy 3.1
The 1.5" OLEDs are the largest we currently have access to at hobbyist-level pricing. If/when something bigger & better comes along it's definitely something I'll explore, but for now we're in this holding pattern.
- Dergun
- Posts: 8
- Joined: Mon May 01, 2017 3:42 pm
Re: uncanny eyes with Teensy 3.1
I keep getting narrowing conversion of '-1' from 'int' to 'uint16_t {aka short unsigned int}' inside { } [-Wnarrowing] but only when i try to upload the dragonEye or the krampus. It's showing the error on the actual dragonEye.h header and not the uncanny script. I have no clue what is going on. Any help would be appreciated. Thanks
- pburgess
- Posts: 4161
- Joined: Sun Oct 26, 2008 2:29 am
Re: uncanny eyes with Teensy 3.1
This appears to be a compiler bug, maybe something in gcc 5.4 that's part of the latest Teensyduino release…appears it can't handle super massive arrays.
If you need to use those eye designs, download Arduino IDE 1.8.1 and install Teensyduino 1.35 atop it. The latter can be downloaded here:
https://forum.pjrc.com/threads/41493-Te ... -35-Beta-2
If you need to use those eye designs, download Arduino IDE 1.8.1 and install Teensyduino 1.35 atop it. The latter can be downloaded here:
https://forum.pjrc.com/threads/41493-Te ... -35-Beta-2
- Dergun
- Posts: 8
- Joined: Mon May 01, 2017 3:42 pm
Re: uncanny eyes with Teensy 3.1
Yep that was the problem. Installed the older software and it works great.
Now if i can only find a way for it to include all the #define INSERT_WHATEVER xx in the array files.... It's a pain having to input them manually.
Thanks for the help!
Now if i can only find a way for it to include all the #define INSERT_WHATEVER xx in the array files.... It's a pain having to input them manually.
Thanks for the help!
- bborastero
- Posts: 39
- Joined: Wed Jul 08, 2015 12:44 pm
Re: uncanny eyes with Teensy 3.1
hi all can you help. i'm try to get uncannyeye working on a teensy3.2 with 2 tft 1.44 but keep getting this error code I have managed to get the test running
thanks
Code: Select all
Arduino: 1.8.2 (Windows 10), TD: 1.36, Board: "Teensy 3.2 / 3.1, Serial, 96 MHz (overclock), Faster, US English"
C:\Users\Ben\Documents\Arduino\Teensy 3.2\Teensy3.1_Eyes-master\uncannyEyes\uncannyEyes.ino:120:24: warning: extra tokens at end of #ifdef directive
#ifdef _ADAFRUIT_ST7735.h_ // TFT
^
C:\Users\Ben\Documents\Arduino\Teensy 3.2\Teensy3.1_Eyes-master\uncannyEyes\uncannyEyes.ino:460:17: warning: extra tokens at end of #ifdef directive
#ifdef IRIS_PIN && (IRIS_PIN >= 0) // Interactive iris
^
uncannyEyes: In function 'void setup()':
uncannyEyes:105: error: 'INITR_144GREENTAB' was not declared in this scope
eye[e].display.initR(INITR_144GREENTAB);
^
uncannyEyes:128: error: 'displayType {aka class Adafruit_ST7735}' has no member named 'writeCommand'
eye[0].display.writeCommand(SSD1351_CMD_SETREMAP);
^
uncannyEyes:128: error: 'SSD1351_CMD_SETREMAP' was not declared in this scope
eye[0].display.writeCommand(SSD1351_CMD_SETREMAP);
^
uncannyEyes:129: error: 'displayType {aka class Adafruit_ST7735}' has no member named 'writeData'
eye[0].display.writeData(0x76);
^
uncannyEyes: In function 'void frame(uint16_t)':
uncannyEyes:327: warning: comparison between signed and unsigned integer expressions
if((t - eye[eyeIndex].blink.startTime) >= eye[eyeIndex].blink.duration) {
^
uncannyEyes:404: warning: comparison between signed and unsigned integer expressions
if(s >= eye[eyeIndex].blink.duration) s = 255; // At or past blink end
^
Multiple libraries were found for "Adafruit_GFX.h"
Used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
Not used: C:\Users\Ben\Documents\Arduino\libraries\Adafruit-GFX
Multiple libraries were found for "Adafruit_ST7735.h"
Used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_ST7735
Not used: C:\Users\Ben\Documents\Arduino\libraries\Adafruit-ST7735
'INITR_144GREENTAB' was not declared in this scope
This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.
thanks
- pburgess
- Posts: 4161
- Joined: Sun Oct 26, 2008 2:29 am
Re: uncanny eyes with Teensy 3.1
Looks like a combination of two problems.
First, line 120 in the sketch should look like this:
(NOT _ADAFRUIT_ST7735.h_ ...something got edited and it shouldn't look like that.)
Second, it's using a different version of the ST7735 library which might be a bit out of sync. Rather than using the version that's optionally installed by the Teensyduino installer, you'll need the "plain vanilla" Adafruit version.
i.e. look for this directory:
and delete it (or move it away, like to the desktop or something, or ZIP it).
But keep this one around (maybe rename with an underscore for good measure, i.e. Adafruit_ST7735):
First, line 120 in the sketch should look like this:
Code: Select all
#ifdef _ADAFRUIT_ST7735H_ // TFT
Second, it's using a different version of the ST7735 library which might be a bit out of sync. Rather than using the version that's optionally installed by the Teensyduino installer, you'll need the "plain vanilla" Adafruit version.
i.e. look for this directory:
Code: Select all
Used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_ST7735
But keep this one around (maybe rename with an underscore for good measure, i.e. Adafruit_ST7735):
Code: Select all
Not used: C:\Users\Ben\Documents\Arduino\libraries\Adafruit-ST7735
- bborastero
- Posts: 39
- Joined: Wed Jul 08, 2015 12:44 pm
Re: uncanny eyes with Teensy 3.1
thanks that did the trick
- bborastero
- Posts: 39
- Joined: Wed Jul 08, 2015 12:44 pm
Re: uncanny eyes with Teensy 3.1
hi I got the eyes working but unfortunately I haven't got any eyelids any suggestions
Code: Select all
//------------------------------------------------------------------------
// 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 <Adafruit_GFX.h> // Core graphics lib for Adafruit displays
// Enable ONE of these #includes -- HUGE graphics tables for 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 "human-HAL9000.h" // more like terminator
#include "MyEyeHuman1.h" //
//#include "MyEyeHuman2.h" //
//#include "SpiralGalaxy.h"//
// Then tweak settings below, e.g. change IRIS_MIN/MAX or disable TRACKING.
// DISPLAY HARDWARE CONFIG -------------------------------------------------
#include <Adafruit_ST7735.h> // TFT display library (enable one only)
//#include <Adafruit_SSD1351.h> // OLED display library -OR-
#ifdef _ADAFRUIT_ST7735H_
typedef Adafruit_ST7735 displayType; // Using TFT display(s)
#else
typedef Adafruit_SSD1351 displayType; // Using OLED display(s)
#endif
#define DISPLAY_DC 7 // Data/command pin for BOTH displays
#define DISPLAY_RESET 8 // Reset pin for BOTH displays
#define SELECT_L_PIN 9 // LEFT eye chip select pin
#define SELECT_R_PIN 10 // RIGHT eye chip select pin
// INPUT CONFIG (for eye motion -- enable or comment out as needed) --------
//#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 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 A2 // 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 120 // Clip lower analogRead() range from IRIS_PIN
#define IRIS_MAX 720 // 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
uint32_t duration; // Duration of blink state (micros) *** why is this a signed integer??? changed to unsigned ***
uint32_t startTime; // Time (micros) of last state change
} eyeBlink;
struct {
displayType display; // OLED/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:
displayType(SELECT_L_PIN,DISPLAY_DC,0),SELECT_L_PIN,{WINK_L_PIN,NOBLINK},
displayType(SELECT_R_PIN,DISPLAY_DC,0),SELECT_R_PIN,{WINK_R_PIN,NOBLINK},
};
#define NUM_EYES (sizeof(eye) / sizeof(eye[0]))
//-------------------------------------------------------------------------
// Begin Iris Rotation code Variables //
int16_t Rotation = -67; // Iris Initial Rotation for static position, 0 if rotating
int8_t RotationZ = -1; // Iris Rotation Delay counter. Leave set at -1 for initial value.
int16_t RotationS = 00; // Iris Rotation Step Increment, (how much Iris rotates each time it turns, can be a negative number)
int8_t RotationR = 1; // Iris Rotation Delay Rate ( > 0 ), (1 through n, larger number greater delay)
// End Iris Rotation code Variables //
//-------------------------------------------------------------------------
// Eyelid Pattern Variables
// int16_t cEyelid = ((((255>>3)<<6) | (231>>2))<<5) | (33>>3); // convert RGB to RGB16_5:6:5
uint16_t cEyelid1 = 0; // eyelid color 1
uint16_t cEyelid2 = 0; // eyelid color 2
uint16_t cEyelid3 = 0; // eyelid color 3
uint16_t cEyelid4 = 0; // eyelid color 4
uint8_t pattern_offset =0; // eyelid pattern offset for even odd/rows
// Arrays are [Y][X]
const int8_t pattern_sizeX = 18;
const int8_t pattern_sizeY = 14;
const int8_t pattern[14][18] = {
{1,4,4,3,3,2,2,2,1,1,1,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,1,1,1,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,1,1,1,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,1,1,1,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,1,1,1,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,1,1,1,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,1,1,1,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,2,2,2,2,2,2,3,3,4,4},
{1,4,4,3,3,2,2,2,2,2,2,2,2,2,3,3,4,4},
{1,4,4,3,3,3,2,2,2,2,2,2,2,3,3,3,4,4},
{1,4,4,4,3,3,3,3,3,3,3,3,3,3,3,4,4,4},
{1,1,4,4,4,3,3,3,3,3,3,3,3,3,4,4,4,1},
{1,1,2,4,4,4,4,4,4,4,4,4,4,4,4,4,2,1},
{1,1,2,2,2,4,4,4,4,4,4,4,4,4,2,2,2,1}
} ;
// End Eyelid Pattern Variables
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Convert to RGB565
// The function removes the lower 3 bits from Red and Blue, and the lower 2 bits from Green and applies the Intensity value.
// The Intensity value of 255 is full brightness, 0 is full black. Some color information is lost in the conversion to RGB565.
uint16_t RGBi888toRGB565(uint8_t R8, uint8_t G8, uint8_t B8, uint8_t I8) // change the brightness of individual 8 bit RGB color channels and convert to RGB565
{
// return ((int((R8 * I8) / 255)>>3)<<11) | ((int((G8*I8) / 255)>>2)<<5) | (int((B8 * I8) / 255)>>3);
return ((((R8 * I8) / 255) & 248)<<8) | ((((G8 * I8) / 255) & 252)<<3) | (((B8 * I8) / 255)>>3);
}
uint16_t RGBi24toRGB565(uint32_t rgb, uint8_t I8) //Change the brightness of an RGB24 bit color value and convert result to RGB565
{
// return (((((rgb>>16) * I8) / 255) & 248)<<8) | ((((((rgb>>8) & 255) * I8) / 255) & 252)<<3) | ((((rgb & 255) * I8) / 255)>>3);
return (((((rgb & 0xFF0000) * I8) / 255) & 0xF80000)>>8) | (((((rgb & 0x00FF00) * I8) / 255) & 0x00FC00)>>5) | ((((rgb & 0x0000FF) * I8) / 255)>>3);
}
uint16_t RGBi565(uint16_t rgb, uint8_t I8) //Change the brightness of an RGB565 color value
{
// return (((((rgb>>11) * I8) / 255) & 31)<<11) | ((((((rgb>>5) & 63) * I8) / 255))<<3) | ((((rgb & 255) * I8)/255)>>3);
return ((((rgb & 0xF800) * I8) / 255) & 0xF800) | ((((rgb & 0x7E0) * I8) / 255) & 0x7E0) | ((((rgb & 0x1F) * I8)/255) & 0x1F);
}
//-------------------------------------------------------------------------
// INITIALIZATION -- runs once at startup ----------------------------------
void setup(void) {
uint8_t e;
pattern_offset = pattern_sizeX / 2;
//-------------------------------------------------------------------------
// Eyelid Pattern and ColorVariables
// eyelid colors, note convert the caucasian flesh tones to RGB then use the RGBi24toRGB565 converter to adjust to darker skin tones
// RGB565 RGB24 RGB888
// 0xFEA0 = 0xF86A00 = 248,106,0 //Supposed to be gold
// 0xD566 = 0xD05606 = 208,86,6 //Supposed to be gold
// 0xCCAE = 0xC84A0E = 200,74,14 //Supposed to be brass
// 0xF6B8 = 0xF06A18 = 240,106,24 //Caucasian Flesh Tones
// 0xDD11 = 0xD85011 = 216,80,17 //Caucasian Flesh Tones
// 0xE594 = 0xE05814 = 224,88,20 //Caucasian Flesh Tones
// 0xED93 = 0xE85813 = 232,88,19 //Caucasian Flesh Tones
// 0xFDD4 = 0xF85C14 = 248,92,20 //Caucasian Flesh Tones
// 0xDD74 = 0xD85614 = 216,86,20 //Caucasian Flesh Tones
// 0xE5F5 = 0xE05E15 = 224,94,21 //Caucasian Flesh Tones
// 0xE532 = 0xE05212 = 224,82,18 //Caucasian Flesh Tones
// 0xCCB0 = 0xC84A10 = 200,74,16 //Caucasian Flesh Tones
// 0xAC0E = 0xA8400E = 168,64,14 //Caucasian Flesh Tones
// 0xFDD4 = 0xF85C14 = 248,92,20 //Caucasian Flesh Tones
// 0x1882 = 0x180802 = 24,8,2 //FDD4 at 10% Ebony Flesh Tones, same result should be achieved with RGBi888toRGB565(248,92,20,26)
// 0xFEA8 = 0xF86A08 = 248,106,8 //Minion Yellow1
// 0xFF03 = 0xF87003 = 248,112,3 //Minion Yellow2
// 0xFE8B = 0xF8680B = 248,104,11 //Minion Yellow3
// = 0xC2EA9A = 194,234,154 //Test Color (217=85%,166=65%,115=45%,64=25%)
// cEyelid1 = RGBi888toRGB565(194,234,154,217); //eyelid at 85% brightness.
// cEyelid2 = RGBi888toRGB565(194,234,154,166); //eyelid at 65% brightness.
// cEyelid3 = RGBi888toRGB565(194,234,154,115); //eyelid at 45% brightness
// cEyelid4 = RGBi888toRGB565(194,234,154,64); //eyelid at 25% brightness.
cEyelid1 = RGBi24toRGB565(0xC2EA9A,217); //eyelid at 85% brightness.
cEyelid2 = RGBi24toRGB565(0xC2EA9A,166); //eyelid at 65% brightness.
cEyelid3 = RGBi24toRGB565(0xC2EA9A,115); //eyelid at 45% brightness
cEyelid4 = RGBi24toRGB565(0xC2EA9A,64); //eyelid at 25% brightness.
//-------------------------------------------------------------------------
Serial.begin(115200);
randomSeed(analogRead(A3)); // Seed random() from floating analog input
// Both displays share a common reset line; 0 is passed to display
// constructor (so no reset in begin()) -- must reset manually here:
pinMode(DISPLAY_RESET, OUTPUT);
digitalWrite(DISPLAY_RESET, LOW); delay(1);
digitalWrite(DISPLAY_RESET, HIGH); delay(50);
for(e=0; e<NUM_EYES; e++) { // Deselect all
pinMode(eye[e].cs, OUTPUT);
digitalWrite(eye[e].cs, HIGH);
}
for(e=0; e<NUM_EYES; e++) {
digitalWrite(eye[e].cs, LOW); // Select one eye for init
#ifdef _ADAFRUIT_ST7735H_ // TFT
eye[e].display.initR(INITR_144GREENTAB);
#else // OLED
eye[e].display.begin();
#endif
if(eye[e].blink.pin >= 0) pinMode(eye[e].blink.pin, INPUT_PULLUP);
digitalWrite(eye[e].cs, HIGH); // Deselect
}
#ifdef BLINK_PIN
pinMode(BLINK_PIN, INPUT_PULLUP);
#endif
// 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 _ADAFRUIT_ST7735H_ // TFT
digitalWrite(eye[0].cs , LOW);
digitalWrite(DISPLAY_DC, LOW);
SPI.transfer(ST7735_MADCTL);
digitalWrite(DISPLAY_DC, HIGH);
SPI.transfer(0x88); // MADCTL_MY | MADCTL_BGR
digitalWrite(eye[0].cs , HIGH);
#else // OLED
eye[0].display.writeCommand(SSD1351_CMD_SETREMAP);
eye[0].display.writeData(0x76);
#endif
}
// EYE-RENDERING FUNCTION --------------------------------------------------
//SPI.begin();
//SPISettings settings(24000000, MSBFIRST, SPI_MODE3); // Teensy 3.1 max SPI (works at 72MHz, but not really 24MHz is actually 18MHz)
SPISettings settings(19999999, MSBFIRST, SPI_MODE3); // Teensy 3.1 SSD1351 OLED max SPI (Works at 72MHz-120MHz(oled), will downscale to cpu clock/4 or /8 as necessary to keep below the oled 20MHz limit)
//SPI_CLOCK_DIV2;
//SPI.setClockDivider(0x02);
//SPISettings settings(15000000, MSBFIRST, SPI_MODE3); // Teensy 3.1 max SPI in 96MHz (oled)
void drawEye( // Renders one eye. Inputs must be pre-clipped & valid.
uint8_t e, // Eye array index; 0 or 1 for left/right
uint32_t iScale, // Scale factor for iris
uint8_t scleraX, // First pixel X offset into sclera image
uint8_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, scleraXsave;
int16_t irisX, irisY;
uint16_t p, a;
uint32_t d;
//--------------------------------------------------------------------------------------
//Eyelid Variables
static uint8_t I, J, K; // modulus values for pattern
//--------------------------------------------------------------------------------------
// 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.
SPI.beginTransaction(settings);
// delayMicroseconds(10000);
// SPI.setClockDivider(SPI_CLOCK_DIV2);
#ifdef _ADAFRUIT_ST7735H_ // TFT
eye[e].display.setAddrWindow(0, 0, 127, 127);
#else // OLED
eye[e].display.writeCommand(SSD1351_CMD_SETROW); // Y range
eye[e].display.writeData(0); eye[e].display.writeData(SCREEN_HEIGHT - 1);
eye[e].display.writeCommand(SSD1351_CMD_SETCOLUMN); // X range
eye[e].display.writeData(0); eye[e].display.writeData(SCREEN_WIDTH - 1);
eye[e].display.writeCommand(SSD1351_CMD_WRITERAM); // Begin write
#endif
digitalWrite(eye[e].cs, LOW); // Chip select
digitalWrite(DISPLAY_DC, HIGH); // Data mode
// 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++) {
//--------------------------------------------------------------------------------------
//Colored Eyelid Code
K = (screenY / pattern_sizeY) % 2;
J = screenY % pattern_sizeY;
I = ((pattern_offset * K) + screenX) % pattern_sizeX;
if((lower[screenY][screenX] <= (lT)) ||
(upper[screenY][screenX] <= (uT))) { // Covered by eyelid
switch (pattern[J][I]) {
case 1:{
p = cEyelid1;
}break;
case 2:{
p = cEyelid2;
}break;
case 3:{
p = cEyelid3;
}break;
case 4:{
p = cEyelid4;
}break;
default:{
p = 0;
}break;}
//--------------------------------------------------------------------------------------
} 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 = (iScale * (p & 0x7F)) / 128; // Distance (Y)
if(d < IRIS_MAP_HEIGHT) { // Within iris area
a = (IRIS_MAP_WIDTH * (p >> 7)) / 512; // Angle (X)
a = (a + Rotation + IRIS_MAP_WIDTH) % IRIS_MAP_WIDTH; // Initial Rotation of iris
p = iris[d][a]; // Pixel = iris
} else { // Not in iris
p = sclera[scleraY][scleraX]; // Pixel = sclera
}
}
// SPI FIFO technique from Paul Stoffregen's ILI9341_t3 library:
while(KINETISK_SPI0.SR & 0xC000); // Wait for space in FIFO 0xC000
KINETISK_SPI0.PUSHR = p | SPI_PUSHR_CTAS(1) | SPI_PUSHR_CONT;
}
}
KINETISK_SPI0.SR |= SPI_SR_TCF; // Clear transfer flag
while((KINETISK_SPI0.SR & 0xF000) || // Wait for SPI FIFO to drain 0xF000
!(KINETISK_SPI0.SR & SPI_SR_TCF)); // Wait for last bit out
digitalWrite(eye[e].cs, HIGH); // Deselect
SPI.endTransaction();
delay(1); // is this really necessary?
// delayMicroseconds(10000);
}
// 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
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;
uint32_t t = micros(); // Time at start of function
Serial.println((++frames * 1000) / millis()); // Show frame rate (framerate)
if(++eyeIndex >= NUM_EYES) eyeIndex = 0; // Cycle through eyes, 1 per call
// 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
}
}
#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...
((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 = (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(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() {
//------- Begin Iris Rotation Code ----------//
RotationZ = (1 + RotationZ) % RotationR; // Iris Rotation Delay
if(RotationZ < 1) Rotation = (Rotation + RotationS) % IRIS_MAP_WIDTH;
//------- End Iris Rotation Code ----------//
#ifdef IRIS_PIN && (IRIS_PIN >= 0) // Interactive iris ***
uint16_t v = 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
}
Please be positive and constructive with your questions and comments.