Description: A fidget device to help me focus by giving my hands a mindless task to do.

Process:

Image result for snes controller

My visual inspiration: a Super Nintendo Entertainment System controller

Some of the original sketches that detailed some of the form issues I would have to solve.

Designing this project was mostly a pain because of how many electronics had to be fit into such a small space. I consistently had to change the dimensions of the SPES to fit in new components like a power switch or an LED ring.

This is the ATTiny84A, a microcontroller small enough to control the SPES!

The original print of the SPES case. It is very small, and I had to make a hole in the back for a set of batteries.

 

 

 

 

 

 

 

The project was very difficult to power effectively since I was using a NeoPixel LED Ring, which uses a lot of current. My solution was to simply push the electronics as close to the front of the SPES as possible, and sneak two AA batteries in behind them.

In terms of software, I did not experience any real challenges except implementing an event-loop system to make the SPES able to change modes very quickly and reliably, as well as flash its LED’s consistently while switching game modes.

An extremely short video of the first time the event loop for flashing the LED ring worked!

The SPES in its normal place on my desk. It fits in quite well amongst the other pieces.

Discussion:

Some feedback from my classmates included:

“Some light sequences seem a bit jarring.”
I agree with this feedback, in regards to other users. However, I do not find them jarring personally, and this is a very personalized device. If I were to market this kind of product to others, I would certainly dim down any extreme color shifts and perhaps make a more cohesive user interface.

“…it would be cool to have labels.”
I also agree with this. The original plan was to have colorful buttons with letters on them, much like a Super Nintendo console controller, but acquiring the buttons would have been expensive relative to the rest of the project. I could have 3D-printed them, but their quality may have been questionable.

Overall, I am very happy with how this project turned out. It was hard work to manufacture the case for my electronics, but it looks as polished as I would have liked. The software works as was intended, but my color-blending “game” is very hard since my concept of color comes from pigmented colors like paint and colored pencils, not mixing light together. This is somewhat annoying, but helps my mind stay occupied when I am not trying to focus on something else.

I certainly did not enjoy spending all night building that case, so I learned to always start (no matter what other progress I have made) building the container earlier. I am very sensitive to the amount of sleep I get, and the day after finishing the case was absolutely terrible. The case was 3D-printed, but I ran out of material and had to remake it, which taught me to always have material handy.

The project certainly sparked a fun train of thought while I was implementing the color-blending mode. My original idea was to somehow make a different, more “traditional” game out the LED ring, but I changed it relatively late in the process. I got the idea from a game on my iPhone called Blendoku, and simply implemented its logic in a simpler format.

I would like to rebuild the SPES with a prettier body (e.g. not white) and I would like to solder the electronics absolutely perfectly so that I do have to worry about breaking hard-to-detect connections.

Schematic:

This schematic has many pushbuttons with pull-down resistors.

Code:

  1. /*=============================================================
  2. * SUPER PULANDO ENTERTAINMENT SYSTEM (SPES)
  3. *
  4. * By: Rolando Garcia III
  5. *
  6. * This code controls the SPES, a small handheld fidget device
  7. * inspired by a Super Nintendo Entertainment System controller.
  8. *
  9. * There are two "game" modes:
  10. *
  11. * • Fun with LED's - Just play around with mixing colors
  12. * and making a light move around!
  13. *
  14. * • Blendoku - You are given two colors and you must mix them properly to
  15. * win!
  16. =============================================================*/
  18. /*=============================================================
  19. * PIN MAPPING:
  20. *
  21. * • A button - 2
  22. * • B button - 3
  23. * • X button - 4
  24. * • Y button - 5
  25. * • Select button - 6
  26. * • Start button - 7
  27. * • NeoPixel Ring - 8
  28. * • Joystick switch - 9
  29. * • Joystick X - A0
  30. * • Joystick Y - A1
  31. *
  32. =============================================================*/
  34. #include <Adafruit_NeoPixel.h>
  35. #define APIN 2
  36. #define BPIN 3
  37. #define XPIN 4
  38. #define YPIN 5
  39. #define SELECT 6
  40. #define START 7
  41. #define LEDS 8
  42. #define STICKSW 9 //MUST BE PULLED UP TO WORK PROPERLY
  43. #define STICKX A0
  44. #define STICKY A1
  47. //Flashing event loop variables
  48. uint32_t lastTimeLightsOn;
  49. uint32_t lastTimeLightsOff;
  50. const int flashInterval = 250; //How long to flash on or off
  52. /*=============================================================
  53. * INPUTS:
  54. * • Joystick
  55. * • Joystick switch
  56. * • Start Button
  57. * • Select Button
  58. * • A
  59. * • B
  60. * • X
  61. * • Y
  62. =============================================================*/
  63. //Struct to hold a button and its properties, including debouncing properties
  64. struct button {
  66. int pin; //Pin mapping of button
  67. int lastState; //Previous state of button
  68. int buttonState; //Current state of button
  69. unsigned long lastBounceTime; //Last bounce time of button
  71. };
  73. //Initialize buttons
  74. struct button A = { APIN, LOW, LOW, millis() };
  75. struct button B = { BPIN, LOW, LOW, millis() };
  76. struct button X = { XPIN, LOW, LOW, millis() };
  77. struct button Y = { YPIN, LOW, LOW, millis() };
  78. struct button Select = { SELECT, LOW, LOW, millis() };
  79. struct button Start = { START, LOW, LOW, millis() };
  80. struct button StickSwitch = { STICKSW, HIGH, HIGH, millis() };
  82. //Button debounce function
  83. int debounce(struct button *b) {
  85. //Get the current reading
  86. int buttonReading = digitalRead(b->pin);
  87. bool result = HIGH;
  89. //If the buttonState has changed
  90. if (buttonReading != b->lastState) {
  91. //Reset the bounce timer
  92. b->lastBounceTime = millis();
  93. }
  95. //If enough time has passed, check if the state is the same
  96. if ( (millis() - (b->lastBounceTime)) > 10 ) {
  98. if (buttonReading != b->buttonState) {
  100. b->buttonState = buttonReading;
  103. // only toggle the LED if the new button state is HIGH
  104. if (b->buttonState == LOW) {
  105. result = !result;
  106. }
  107. }
  109. }
  111. b->lastState = buttonReading;
  113. return result;
  115. }
  117. //=============================================================
  118. //OUTPUT: NeoPixel Ring (16 LEDs)
  119. //=============================================================
  120. //Initialize the ring
  121. Adafruit_NeoPixel ring = Adafruit_NeoPixel(16, LEDS, NEO_RGBW + NEO_KHZ800);
  123. //Function to clear the lights of all their color
  124. void clearLights(){
  126. //Loop through all the pixels and set their RGBW values to all 0's
  127. for(int i = 0; i < 16; i++){
  128. ring.setPixelColor(i, 0, 0, 0, 0);
  129. }
  130. //Then show them so that the change is reflected
  131. ring.show();
  133. }
  135. /*=============================================================
  136. * GAME MODES:
  137. * true = Fun with LEDs
  138. * false = Blendoku
  139. =============================================================*/
  140. //Game state variables
  141. bool gameMode = true;
  142. bool lastMode = false;
  144. //Hue changing variables
  145. int color = 0; //Color being changed
  146. int red = 1; //Value of red
  147. int green = 1; //Value of green
  148. int blue = 1; //Value of blue
  149. const int change = 10; //Amount of change in color during increases or decreases
  151. //Increase the saturation of a certain color with no rollover
  152. void increaseColor() {
  153. //Determine which color is being changed
  154. //and ensure that it is not already maxed out
  155. if(color == 0 && red+change <= 255){
  156. red += change;
  157. } else if(color == 1 && green+change <= 255) {
  158. green += change;
  159. } else if(color == 2 && blue+change <= 255) {
  160. blue += change;
  161. }
  162. }
  164. //Decrease the saturation of a certain color with no rollover
  165. void decreaseColor() {
  166. //Determine which color is being changed
  167. //and ensure that it is not already minimized
  168. if(color == 0 && red-change >= 0){
  169. red -= change;
  170. } else if(color == 1 && green-change >= 0) {
  171. green -= change;
  172. } else if(color == 2 && blue-change >= 0) {
  173. blue -= change;
  174. }
  175. }
  177. //Function to randomize a passed-in hue
  178. void randomizeColors(int *redVal, int *greenVal, int *blueVal){
  180. *redVal = random(0,255);
  181. *greenVal = random(0,255);
  182. *blueVal = random(0,255);
  184. }
  186. //Resets all user's hue variables
  187. void resetColors(){
  188. red = 0;
  189. green = 0;
  190. blue = 0;
  191. }
  193. //Flash the center lights to alert the user of the game mode
  194. void flashLights(bool currentMode) {
  196. //For the funwithLEDs mode, simply flash white lights
  197. if (currentMode == true) {
  199. if(millis() - lastTimeLightsOff >= flashInterval){
  200. clearLights();
  201. lastTimeLightsOff = millis();
  202. }
  204. if(millis() - lastTimeLightsOn >= flashInterval*2){
  205. for (int j = 0; j < 16; j++) {
  207. ring.setPixelColor(j, 0, 0, 0, 255);
  209. }
  210. ring.show();
  211. lastTimeLightsOn = millis();
  212. }
  214. } else { //For the blendoku mode, flash colorful lights
  216. if(millis() - lastTimeLightsOff >= flashInterval){
  217. clearLights();
  218. lastTimeLightsOff = millis();
  219. }
  221. if(millis() - lastTimeLightsOn >= flashInterval*2){
  222. //For the blendoku game mode, flash colorful lights
  223. for (int j = 0; j < 16; j++) {
  225. ring.setPixelColor(j, random(0,255), random(0,255), random(0,255), 0);
  227. }
  228. ring.show();
  229. lastTimeLightsOn = millis();
  230. }
  232. }
  234. }
  236. //=============================================================
  237. //VARIABLES/FUNCTIONS FOR BLENDOKU MODE
  238. //=============================================================
  239. //Random Color 1
  240. int red1;
  241. int green1;
  242. int blue1;
  243. //Random Color 2;
  244. int red2;
  245. int green2;
  246. int blue2;
  248. //New blendoku game flag variable
  249. bool newBlendoku = true;
  251. //Randomizes the colors that the person has to blend
  252. void pick2RandomColors() {
  254. //Use the randomizeColors() function to do the work for you
  255. randomizeColors(&red1, &green1, &blue1);
  256. randomizeColors(&red2, &green2, &blue2);
  258. }
  260. //Shows player the two colors of the game
  261. void showPlayerProblem(){
  263. //Flash the first color
  264. for (int i = 0; i < 16; i++) {
  266. ring.setPixelColor(i, green1, red1, blue1, 0);
  268. }
  269. ring.show();
  270. delay(500);
  272. clearLights();
  273. delay(500);
  275. //Flash the second color
  276. for (int i = 0; i < 16; i++) {
  278. ring.setPixelColor(i, green2, red2, blue2, 0);
  280. }
  281. ring.show();
  282. delay(500);
  284. clearLights();
  285. delay(500);
  287. }
  289. //Function to show player's current color combination
  290. void showPlayerColors() {
  292. for (int i = 0; i < 16; i++) {
  294. ring.setPixelColor(i, green, red, blue, 0);
  296. }
  297. ring.show();
  299. }
  301. //Checks the user's solution
  302. bool checkBlendoku(){
  304. //Set the threshold for verifying two colors
  305. const int threshold = 200;
  307. //Determine the solution
  308. int solveRed = min(red2,red1) + (int)(abs(red1-red2)/2);
  309. int solveGreen = min(green2,green1) + (int)(abs(green1-green2)/2);
  310. int solveBlue = min(blue2,blue1) + (int)(abs(blue1-blue2)/2);
  312. //If the RGB value is between those of the random colors, they solved it
  313. if( (sq(red-solveRed) + sq(green-solveGreen) + sq(blue-solveBlue)) <= sq(threshold) ) {
  314. return true;
  315. }
  317. return false;
  319. }
  321. //Flash a green circle when a player solves a blendoku
  322. void success(){
  324. for(int j = 0; j < 2; j++){
  325. for (int i = 0; i < 16; i++) {
  327. ring.setPixelColor(i, 255, 0, 0, 0);
  329. }
  330. ring.show();
  331. delay(500);
  333. clearLights();
  334. delay(500);
  335. }
  337. }
  339. //Flash a red circle for a failure
  340. void failure(){
  342. for(int j = 0; j < 2; j++){
  343. for (int i = 0; i < 16; i++) {
  345. ring.setPixelColor(i, 0, 255, 0, 0);
  347. }
  348. ring.show();
  349. delay(500);
  351. clearLights();
  352. delay(500);
  353. }
  355. }
  357. //Game mode where the player must blend two colors
  358. void blendoku() {
  360. //If a new game is initiated, pick two new colors and show them
  361. if(newBlendoku || debounce(&Start) == LOW){
  362. clearLights();
  363. pick2RandomColors();
  364. resetColors();
  365. showPlayerProblem();
  366. newBlendoku = false;
  367. }
  369. //Allow the user to recheck the colors they were given
  370. //by moving the stick up or down
  371. if(analogRead(STICKY) >= 900 || analogRead(STICKY) <= 100){
  372. showPlayerProblem();
  373. }
  375. //Allow the user to switch the hue they are changing
  376. if(debounce(&StickSwitch) == LOW){
  377. color += 1;
  378. color %= 3;
  379. }
  381. if(debounce(&X) == LOW){
  382. increaseColor();
  383. }
  385. if(debounce(&B) == LOW){
  386. decreaseColor();
  387. }
  389. //Also allow them to reset their color selections and start over
  390. if(debounce(&Y) == LOW){
  391. resetColors();
  392. }
  394. showPlayerColors();
  396. //If the user confirms their solution, check it and start a new game
  397. if(debounce(&A) == LOW){
  399. if(checkBlendoku() == true){
  400. success();
  401. } else {
  402. failure();
  403. }
  404. newBlendoku = true;
  406. }
  409. }
  411. //VARIABLES/FUNCTIONS FOR FUNWITHLEDS MODE
  413. //Index of the light that is currently on
  414. int lightOn = 0;
  416. //Function to determine light index from joystick position
  417. float lightIndexFromJoystick(int stickX, int stickY){
  419. //Arctangent magics!
  420. float angle = atan2(stickY, stickX);
  421. int lightIndex = 15 - round((angle/1.57)*15);
  423. return lightIndex;
  424. }
  426. //Fun mode where the user can simply play with colors on the wheel
  427. void funWithLEDs() {
  429. clearLights();
  430. int stickX = analogRead(STICKX);
  431. int stickY = analogRead(STICKY);
  433. //Find how far the joystick is from its center
  434. int xDist = stickX - 512;
  435. int yDist = stickY - 512;
  437. double distance = sqrt( (float)xDist*xDist + (float)yDist*yDist );
  439. //Only change the light that is on if the analog stick is fully pushed
  440. if(distance > 100){
  441. ring.setPixelColor(lightOn, 0, 0, 0, 0);
  442. lightOn = lightIndexFromJoystick( stickX, stickY );
  443. }
  445. //Allow the user to switch the hue they are changing
  446. if(debounce(&A) == LOW){
  447. color += 1;
  448. color %= 3;
  449. }
  451. if(debounce(&X) == LOW){
  452. increaseColor();
  453. }
  455. if(debounce(&B) == LOW){
  456. decreaseColor();
  457. }
  459. //Also allow them to reset their color selections and start over
  460. if(debounce(&Y) == LOW){
  461. randomizeColors(&red, &green, &blue);
  462. }
  464. if(debounce(&Start) == LOW){
  465. resetColors();
  466. }
  468. ring.setPixelColor(lightOn, green, red, blue, 0);
  469. ring.show();
  471. }
  473. //Switches game modes when the Select button is pressed
  474. void switchGameMode() {
  475. //Switch the game mode
  476. gameMode = !gameMode;
  478. //Reinitialize blendoku
  479. if(gameMode == false){
  480. newBlendoku = true;
  481. }
  483. //Blank out the lights and reset the timers
  484. resetColors();
  485. lastTimeLightsOff = millis();
  486. lastTimeLightsOn = millis() + flashInterval;
  487. delay(10);
  488. }
  490. void setup() {
  491. // put your setup code here, to run once:
  492. pinMode(APIN, INPUT);
  493. pinMode(BPIN, INPUT);
  494. pinMode(XPIN, INPUT);
  495. pinMode(YPIN, INPUT);
  496. pinMode(STICKX, INPUT);
  497. pinMode(STICKY, INPUT);
  498. pinMode(STICKSW, INPUT_PULLUP); //Remember to pull up for reliable reading
  500. ring.setBrightness(30); //Lower the default brightness so as not to
  501. ring.begin(); //Initialize the LED ring
  502. ring.show();
  504. lastTimeLightsOff = millis();
  505. lastTimeLightsOn = millis() + flashInterval;
  506. }
  508. void loop() {
  510. //Check the select button
  511. if (debounce(&Select) == LOW) {
  512. lastMode = gameMode;
  513. switchGameMode();
  514. }
  516. //If the person has not confirmed the game mode, flash the lights at them
  517. if(lastMode != gameMode && debounce(&Start) == HIGH ){
  518. resetColors();
  519. flashLights(gameMode);
  520. return;
  521. } else {
  522. //Otherwise continue into the gameMode
  523. lastMode = gameMode;
  524. }
  526. //Determine the correct game mode and play it
  527. if (gameMode == true) {
  529. funWithLEDs();
  531. } else {
  533. blendoku();
  535. }
  536. }
/*============================================================= 
 * SUPER PULANDO ENTERTAINMENT SYSTEM (SPES)
 *
 * By: Rolando Garcia III
 * 
 * This code controls the SPES, a small handheld fidget device
 * inspired by a Super Nintendo Entertainment System controller.
 *
 * There are two "game" modes:
 *
 * • Fun with LED's - Just play around with mixing colors
 *                    and making a light move around!
 *
 * • Blendoku - You are given two colors and you must mix them properly to
 *              win!
 =============================================================*/

/*============================================================= 
 * PIN MAPPING:
 *
 * • A button - 2
 * • B button - 3
 * • X button - 4
 * • Y button - 5
 * • Select button - 6
 * • Start button - 7
 * • NeoPixel Ring - 8
 * • Joystick switch - 9
 * • Joystick X - A0
 * • Joystick Y - A1
 *
 =============================================================*/

#include <Adafruit_NeoPixel.h>
#define APIN 2
#define BPIN 3
#define XPIN 4
#define YPIN 5
#define SELECT 6
#define START 7
#define LEDS 8
#define STICKSW 9 //MUST BE PULLED UP TO WORK PROPERLY
#define STICKX A0
#define STICKY A1


//Flashing event loop variables
uint32_t lastTimeLightsOn;
uint32_t lastTimeLightsOff;
const int flashInterval = 250; //How long to flash on or off

/*=============================================================
 * INPUTS:
 * • Joystick
 * • Joystick switch
 * • Start Button
 * • Select Button
 * • A
 * • B
 * • X
 * • Y
  =============================================================*/
//Struct to hold a button and its properties, including debouncing properties
struct button {

  int pin; //Pin mapping of button
  int lastState; //Previous state of button
  int buttonState; //Current state of button
  unsigned long lastBounceTime; //Last bounce time of button

};

//Initialize buttons
struct button A = { APIN, LOW, LOW, millis() };
struct button B = { BPIN, LOW, LOW, millis() };
struct button X = { XPIN, LOW, LOW, millis() };
struct button Y = { YPIN, LOW, LOW, millis() };
struct button Select = { SELECT, LOW, LOW, millis() };
struct button Start = { START, LOW, LOW, millis() };
struct button StickSwitch = { STICKSW, HIGH, HIGH, millis() };

//Button debounce function
int debounce(struct button *b) {

  //Get the current reading
  int buttonReading = digitalRead(b->pin);
  bool result = HIGH;

  //If the buttonState has changed
  if (buttonReading != b->lastState) {
    //Reset the bounce timer
    b->lastBounceTime = millis();
  }

  //If enough time has passed, check if the state is the same
  if ( (millis() - (b->lastBounceTime)) > 10 ) {

    if (buttonReading != b->buttonState) {

      b->buttonState = buttonReading;


      // only toggle the LED if the new button state is HIGH
      if (b->buttonState == LOW) {
        result = !result;
      }
    }

  }

  b->lastState = buttonReading;

  return result;

}

//=============================================================
//OUTPUT: NeoPixel Ring (16 LEDs)
//=============================================================
//Initialize the ring
Adafruit_NeoPixel ring = Adafruit_NeoPixel(16, LEDS, NEO_RGBW + NEO_KHZ800);

//Function to clear the lights of all their color
void clearLights(){

  //Loop through all the pixels and set their RGBW values to all 0's
  for(int i = 0; i < 16; i++){
    ring.setPixelColor(i, 0, 0, 0, 0);
  }
  //Then show them so that the change is reflected
  ring.show();
  
}

/*=============================================================
 * GAME MODES:
 *  true = Fun with LEDs
 *  false = Blendoku
  =============================================================*/
//Game state variables
bool gameMode = true;
bool lastMode = false;

//Hue changing variables
int color = 0; //Color being changed
int red = 1; //Value of red
int green = 1; //Value of green
int blue = 1; //Value of blue
const int change = 10; //Amount of change in color during increases or decreases

//Increase the saturation of a certain color with no rollover
void increaseColor() {
  //Determine which color is being changed
  //and ensure that it is not already maxed out
  if(color == 0 && red+change <= 255){
    red += change;
  } else if(color == 1 && green+change <= 255) {
    green += change;
  } else if(color == 2 && blue+change <= 255) {
    blue += change;
  }
}

//Decrease the saturation of a certain color with no rollover
void decreaseColor() {
  //Determine which color is being changed
  //and ensure that it is not already minimized
  if(color == 0 && red-change >= 0){
    red -= change;
  } else if(color == 1 && green-change >= 0) {
    green -= change;
  } else if(color == 2 && blue-change >= 0) {
    blue -= change;
  }
}

//Function to randomize a passed-in hue
void randomizeColors(int *redVal, int *greenVal, int *blueVal){

  *redVal = random(0,255);
  *greenVal = random(0,255);
  *blueVal = random(0,255);
  
}

//Resets all user's hue variables
void resetColors(){
  red = 0;
  green = 0;
  blue = 0;
}

//Flash the center lights to alert the user of the game mode
void flashLights(bool currentMode) {

  //For the funwithLEDs mode, simply flash white lights
  if (currentMode == true) {

    if(millis() - lastTimeLightsOff >= flashInterval){
      clearLights();
      lastTimeLightsOff = millis();
    }

    if(millis() - lastTimeLightsOn >= flashInterval*2){
      for (int j = 0; j < 16; j++) {
  
        ring.setPixelColor(j, 0, 0, 0, 255);
  
      }
      ring.show();
      lastTimeLightsOn = millis();
    }

  } else { //For the blendoku mode, flash colorful lights

    if(millis() - lastTimeLightsOff >= flashInterval){
      clearLights();
      lastTimeLightsOff = millis();
    }
    
    if(millis() - lastTimeLightsOn >= flashInterval*2){
      //For the blendoku game mode, flash colorful lights
      for (int j = 0; j < 16; j++) {
  
        ring.setPixelColor(j, random(0,255), random(0,255), random(0,255), 0);
  
      }
      ring.show();
      lastTimeLightsOn = millis();
    }

  }

}

//=============================================================
//VARIABLES/FUNCTIONS FOR BLENDOKU MODE
//=============================================================
//Random Color 1
int red1;
int green1;
int blue1;
//Random Color 2;
int red2;
int green2;
int blue2;

//New blendoku game flag variable
bool newBlendoku = true;

//Randomizes the colors that the person has to blend
void pick2RandomColors() {

  //Use the randomizeColors() function to do the work for you
  randomizeColors(&red1, &green1, &blue1);
  randomizeColors(&red2, &green2, &blue2);
  
}

//Shows player the two colors of the game
void showPlayerProblem(){

  //Flash the first color
  for (int i = 0; i < 16; i++) {

    ring.setPixelColor(i, green1, red1, blue1, 0);

  }
  ring.show();
  delay(500);

  clearLights();
  delay(500);

  //Flash the second color
  for (int i = 0; i < 16; i++) {

    ring.setPixelColor(i, green2, red2, blue2, 0);

  }
  ring.show();
  delay(500);

  clearLights();
  delay(500);
  
}

//Function to show player's current color combination
void showPlayerColors() {

  for (int i = 0; i < 16; i++) {

    ring.setPixelColor(i, green, red, blue, 0);

  }
  ring.show();
  
}

//Checks the user's solution 
bool checkBlendoku(){

  //Set the threshold for verifying two colors
  const int threshold = 200;

  //Determine the solution
  int solveRed = min(red2,red1) + (int)(abs(red1-red2)/2);
  int solveGreen = min(green2,green1) + (int)(abs(green1-green2)/2);
  int solveBlue = min(blue2,blue1) + (int)(abs(blue1-blue2)/2);
  
  //If the RGB value is between those of the random colors, they solved it
  if( (sq(red-solveRed) + sq(green-solveGreen) + sq(blue-solveBlue)) <= sq(threshold) ) {
    return true;
  }
  
  return false;
  
}

//Flash a green circle when a player solves a blendoku
void success(){

  for(int j = 0; j < 2; j++){
    for (int i = 0; i < 16; i++) {
  
      ring.setPixelColor(i, 255, 0, 0, 0);
  
    }
    ring.show();
    delay(500);
  
    clearLights();
    delay(500);
  }
  
}

//Flash a red circle for a failure
void failure(){

  for(int j = 0; j < 2; j++){
    for (int i = 0; i < 16; i++) {
  
      ring.setPixelColor(i, 0, 255, 0, 0);
  
    }
    ring.show();
    delay(500);
  
    clearLights();
    delay(500);
  }
  
}

//Game mode where the player must blend two colors
void blendoku() {

  //If a new game is initiated, pick two new colors and show them
  if(newBlendoku || debounce(&Start) == LOW){
    clearLights();
    pick2RandomColors();
    resetColors();
    showPlayerProblem();
    newBlendoku = false;
  }

  //Allow the user to recheck the colors they were given
  //by moving the stick up or down
  if(analogRead(STICKY) >= 900 || analogRead(STICKY) <= 100){
    showPlayerProblem();
  }

  //Allow the user to switch the hue they are changing
  if(debounce(&StickSwitch) == LOW){
    color += 1;
    color %= 3;
  }

  if(debounce(&X) == LOW){
    increaseColor();
  }

  if(debounce(&B) == LOW){
    decreaseColor();
  }

  //Also allow them to reset their color selections and start over
  if(debounce(&Y) == LOW){
    resetColors();
  }

  showPlayerColors();

  //If the user confirms their solution, check it and start a new game
  if(debounce(&A) == LOW){
    
    if(checkBlendoku() == true){
      success();
    } else {
      failure();
    }
    newBlendoku = true;
    
  }


}

//VARIABLES/FUNCTIONS FOR FUNWITHLEDS MODE

//Index of the light that is currently on
int lightOn = 0;

//Function to determine light index from joystick position
float lightIndexFromJoystick(int stickX, int stickY){

  //Arctangent magics!
  float angle = atan2(stickY, stickX);
  int lightIndex = 15 - round((angle/1.57)*15);

  return lightIndex;
}

//Fun mode where the user can simply play with colors on the wheel
void funWithLEDs() {

  clearLights();
  int stickX = analogRead(STICKX);
  int stickY = analogRead(STICKY);

  //Find how far the joystick is from its center
  int xDist = stickX - 512;
  int yDist = stickY - 512;

  double distance = sqrt( (float)xDist*xDist + (float)yDist*yDist );

  //Only change the light that is on if the analog stick is fully pushed
  if(distance > 100){
    ring.setPixelColor(lightOn, 0, 0, 0, 0);
    lightOn = lightIndexFromJoystick( stickX, stickY );
  }

  //Allow the user to switch the hue they are changing
  if(debounce(&A) == LOW){
    color += 1;
    color %= 3;
  }

  if(debounce(&X) == LOW){
    increaseColor();
  }

  if(debounce(&B) == LOW){
    decreaseColor();
  }

  //Also allow them to reset their color selections and start over
  if(debounce(&Y) == LOW){
    randomizeColors(&red, &green, &blue);
  }

  if(debounce(&Start) == LOW){
    resetColors();
  }
  
  ring.setPixelColor(lightOn, green, red, blue, 0);
  ring.show();

}

//Switches game modes when the Select button is pressed
void switchGameMode() {
  //Switch the game mode
  gameMode = !gameMode;

  //Reinitialize blendoku
  if(gameMode == false){
    newBlendoku = true;
  }

  //Blank out the lights and reset the timers
  resetColors();
  lastTimeLightsOff = millis();
  lastTimeLightsOn = millis() + flashInterval;
  delay(10);
}

void setup() {
  // put your setup code here, to run once:
  pinMode(APIN, INPUT);
  pinMode(BPIN, INPUT);
  pinMode(XPIN, INPUT);
  pinMode(YPIN, INPUT);
  pinMode(STICKX, INPUT);
  pinMode(STICKY, INPUT);
  pinMode(STICKSW, INPUT_PULLUP); //Remember to pull up for reliable reading

  ring.setBrightness(30); //Lower the default brightness so as not to 
  ring.begin(); //Initialize the LED ring
  ring.show();

  lastTimeLightsOff = millis();
  lastTimeLightsOn = millis() + flashInterval;
}

void loop() {
  
  //Check the select button
  if (debounce(&Select) == LOW) {
    lastMode = gameMode;
    switchGameMode();
  }

  //If the person has not confirmed the game mode, flash the lights at them
  if(lastMode != gameMode && debounce(&Start) == HIGH ){
    resetColors();
    flashLights(gameMode);
    return;
  } else {
    //Otherwise continue into the gameMode
    lastMode = gameMode;
  }

  //Determine the correct game mode and play it
  if (gameMode == true) {

    funWithLEDs();

  } else {

    blendoku();
    
  }
}