/*
 * This file is part of Detour
 * Electronic object that displays arrow patterns
 * 
 * This project is part of Accrochages
 * See http://accrochages.drone.ws
 * 
 * (c) 2008 Sofian Audry (info@sofianaudry.com)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <EEPROM.h>
#include <avr/sleep.h>

#include "arrow_animation_data.h"

/*
 * Definitions and constants.
 */
#define PUSHBUTTON_IN 2 // Pin for pushbutton.
#define PHOTO_IN 3 // Pin for the photoresistor (for daylight sleep mode)

#define TIME_STEP 500                // Time between each frame.
#define TIME_BETWEEN_ANIMATIONS 4000 // Time between each animation.

// In MODE_RANDOM, once every TIME_RANDOM_CHANGE_DIRECTION ms, there 
// is a 50% probability that direction of the arrow will change.
#define TIME_RANDOM_CHANGE_DIRECTION 300000L

#define N_LEDS N_PIXELS     // Number of LEDS.
#define LED_BRIGHTNESS 0.3f // Brightness of the LEDs (for energy saving)

// Internal use (for LEDs brightness).
#define LED_PERIOD_US 1000L
const long LED_PERIOD_US_ON  = (long) (LED_PERIOD_US * LED_BRIGHTNESS);
const long LED_PERIOD_US_OFF = (long) (LED_PERIOD_US * (1 - LED_BRIGHTNESS));

// On/off (can be changed wether you opt for pull-up/pull-down LEDs)
#define ON HIGH
#define OFF LOW

// The different modes.
#define MODE_RANDOM 0 // 50% chances of changing direction every TIME_RANDOM_CHANGE_DIRECTION ms
#define MODE_LEFT 1   // Left arrow
#define MODE_RIGHT 2  // Right arrow

// The ordrered N_LEDS pin numbers of the LEDs.
// NOTE: This is useful if you make an error in soldering your circuit and you 
// need to reorder your pins (like I did) ;)
//const byte LED_PINS[] = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
const byte LED_PINS[] = { 1, 11, 12, 4, 5, 6, 7, 8, 9, 10 };

/*
 * Library.
 */
// Returns true 50% of the time.
boolean randomBoolean() {
  return (random(2) == 0);
}

// Clears the LEDs.
void clear() {
  for (int pin=0; pin<N_LEDS; pin++) {
    digitalWrite(LED_PINS[pin], OFF);
  }
}

// Draws an image on the screen. Argument #pinMapping# can be specified to change
// the order in which the LEDs are turned on/off (used here for left/right symmetry).
void draw(prog_uchar *image, byte *pinMapping = NULL) {
  int pin;
  for (int i=0; i<N_LEDS; i++) {
    pin = LED_PINS[(pinMapping ? pinMapping[i] : i)];
    digitalWrite(pin, (pgm_read_byte(&image[i]) ? ON : OFF));
  }
}

// Like draw() (above) but draws the image for a limited time #time# using LED
// brightness control for energy savings.
void timedDraw(long time, prog_uchar *image, byte *pinMapping = NULL) {
  long startTime = millis();
  while (millis() - startTime < time) {
    draw(image, pinMapping);
    delayMicroseconds(LED_PERIOD_US_ON);
    clear();
    delayMicroseconds(LED_PERIOD_US_OFF);
  }
}

// Main animation class.
class LedAnimation {
private:
  prog_uchar** _frames; // The list of frames.
  int _currentFrame; // The current frame.
  int _nFrames; // The total number of frames.

public:
  // Constructor.
  LedAnimation() {
    _nFrames = 0;
    reset();
  }
  
  // Adds a frame to the animation.
  void addFrame(prog_uchar* frame) {
    _frames = (prog_uchar**) realloc(_frames, (_nFrames+1) * sizeof(prog_uchar*));
    _frames[_nFrames++] = frame;
  }
  
  // Draws the next frame, using optional #pinMapping#. Returns true if animation
  // has reached its end (will then go on again from the start ie. looping).
  boolean drawNextFrame(long time, byte *pinMapping = NULL) {
    prog_uchar* frame = _frames[_currentFrame];
    timedDraw(time, frame, pinMapping);
    _currentFrame++;
    if (_currentFrame == _nFrames) {
      reset();
      return false;
    }
    return true;
  }
  
  // Resets animation to start.
  void reset() {
    _currentFrame = 0; 
  }
};

/*
 * Variables
 */

// Main animation.
LedAnimation animationLeft;

// Mapping to display the right arrow.
byte rightToLeftMapping[] = { 0, 2, 1, 6, 5, 4, 3, 8, 7, 9 };

volatile boolean goingLeft;      // True iff arrow is currently going left
#define EEPROM_MODE_INDEX 0      // The index of the mode variable in the EEPROM.
volatile int mode;               // The current mode (MODE_RANDOM, MODE_LEFT, MODE_RIGHT)
volatile boolean resetAnimation; // True iff we need to reset the animation (after mode change)
volatile boolean block = false;  // Mutex (prevents animation to flow while button is pushed.
long startTime;                  // Used in MODE_RANDOM to compute the time elasped.

/*
 * Pushbutton/mode change methods.
 */
#define PUSHBUTTON_THRESHOLD 2000 // Internal use (to prevent bouncing).

// Sets (change) mode.
void setMode(int m) {
  mode = m;
  switch (mode) {
  case MODE_RANDOM:
    goingLeft = randomBoolean();
    break;
  case MODE_LEFT:
    goingLeft = true;
    break;
  case MODE_RIGHT:
    goingLeft = false;
    break;
  }
}

// Interrupt triggered by pushbutton.
void changeModeIn() {
  if (!block) {
    block = true; // Block (mutex).
    
    // XXX Prevents problems caused by sluggish rising ("boucing")
    // Makes sure the rising is stable
    for (int i=0; i<PUSHBUTTON_THRESHOLD; i++)
      if (digitalRead(PUSHBUTTON_IN) == LOW) {
        block = false;
        return;
      }
    
    // Change mode.
    mode = (mode + 1) % 3;
    EEPROM.write( EEPROM_MODE_INDEX, (byte) mode);
    clear();
    setMode(mode);
    
    // Keep on while button stays pushed.
    int count = 0;
    while (digitalRead(PUSHBUTTON_IN) == HIGH) {
      draw(ARROW, goingLeft ? NULL : rightToLeftMapping);
      if (mode == MODE_RANDOM && count > 1000) {
        goingLeft = !goingLeft;
        count = 0;
      }
      count++;
    };
    clear();
    
    // for now don't do this because not volatile ... we'll figure out later
    resetAnimation = true;
    
    block = false; // Release mutex.
  }
}

/*
 * Sleep during daylight methods.
 */
#define SLEEP_TOLERANCE 500  // Number of times we tolerate to read a HIGH value in PHOTO_IN
                             // before switching to sleep mode.

// Wake up.
void wakeUpNow()        // here the interrupt is handled after wakeup
{
  resetAnimation = true;
  // execute code here after wake-up before returning to the loop() function
  // timers and code using timers (serial.print and more...) will not work here.
  // we don't really need to execute any special functions here, since we
  // just want the thing to wake up
}

// Go to sleep.
void sleepNow()         // here we put the arduino to sleep
{
  clear();
  
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);   // sleep mode is set here

  sleep_enable();          // enables the sleep bit in the mcucr register
                           // so sleep is possible. just a safety pin 

  attachInterrupt(1, wakeUpNow, LOW); // use interrupt 0 (pin 2) and run function
                                      // wakeUpNow when pin 2 gets LOW 

  sleep_mode();            // here the device is actually put to sleep!!
                           // THE PROGRAM CONTINUES FROM HERE AFTER WAKING UP

  sleep_disable();         // first thing after waking from sleep:
                           // disable sleep...
  detachInterrupt(1);      // disables interrupt 0 on pin 2 so the 
                           // wakeUpNow code will not be executed 
                           // during normal running time.
}

// Returns true iff we evaluate this is daylight.
boolean isDayLight() {
  int k = 0;
  while (digitalRead(PHOTO_IN) == HIGH) {
    k++;
    if (k >= SLEEP_TOLERANCE) {
      return true;
    }
  }
  return false;
}

/*
 * Main methods.
 */

void setup() {
  // Set pin modes.
  for (int pin=0; pin<N_LEDS; pin++) {
    pinMode(LED_PINS[pin], OUTPUT);
  }
  pinMode(PUSHBUTTON_IN, INPUT);
  pinMode(PHOTO_IN, INPUT);

  // Attach the pushbutton interrupt.
  attachInterrupt(0, changeModeIn, RISING);

  // Clear screen.
  clear();
  
  // Init animation.
  for (int i=0; i<N_FRAMES; i++) {
    animationLeft.addFrame(FRAMES[i]);
  }

  // Reset animation and switch to MODE_RANDOM.
  animationLeft.reset();
  setMode( EEPROM.read(EEPROM_MODE_INDEX) );
  startTime = millis();
  
  // Interrupt-related options.
  block = false;
  resetAnimation = false;

  // Set random seed.
  randomSeed(analogRead(0));
  
  delay(1000);
}

void loop() {
  if (!block) { // Prevent animation if pushbutton is on.
  
    // Switch to sleep mode during daylight.
    if (isDayLight()) {
      sleepNow();
      return;
    }
    
    // Reset animation (after a mode change).
    if (resetAnimation) {
      animationLeft.reset();
      resetAnimation = false;
      startTime = millis();
    }

    // Draw frame.
    boolean finished = !(animationLeft.drawNextFrame(TIME_STEP, goingLeft ? NULL : rightToLeftMapping));
    
    // Animation is over.
    if (finished) {
      // Add up some blank after finish.
      delay(TIME_BETWEEN_ANIMATIONS);
      // In MODE_RANDOM, toss a coin for direction after TIME_RANDOM_CHANGE_DIRECTION.
      if ((mode == MODE_RANDOM) && (millis() - startTime > TIME_RANDOM_CHANGE_DIRECTION)) {
        startTime = millis();
        clear();
        if (randomBoolean())
          goingLeft = !goingLeft;
      }
    }
  }
}