/*----------------------------- Include Files -----------------------------*/

/* include header files for the framework and this service

*/
#include "ES_Configure.h"
#include "ES_Framework.h"
#include "ES_DeferRecall.h"
#include "ES_ShortTimer.h"

#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_gpio.h"
#include "inc/hw_sysctl.h"
#include "driverlib/sysctl.h"
#include "driverlib/pin_map.h" // Define PART_TM4C123GH6PM in project
#include "driverlib/gpio.h"

#include "ES_Port.h"
#include "termio.h"

#include "LEDService.h"
#include "ShiftRegisterWrite.h"
#include "VibratingMotor.h"
#include "FanService.h"

/*----------------------------- Module Defines ----------------------------*/

// these times assume a 1.000mS/tick timing
#define ONE_SEC 976
#define HALF_SEC 488 //488
#define QUARTER_SEC (0.25*ONE_SEC)
#define THIRTY_SEC 30*ONE_SEC

#define RocketLED1 0x01

#define RocketLED2 0x02
#define RocketLED3 0x04
#define KnobLED 0x08
#define Button1LED 0x10
#define Button2LED 0x20
#define Button3LED 0x40
#define TorchIndLED 0x80

/*---------------------------- Module Functions ---------------------------*/

/* prototypes for private functions for this service.They should be functions
relevant to the behavior of this service
*/

/*---------------------------- Module Variables ---------------------------*/

// with the introduction of Gen2, we need a module level Priority variable
static uint8_t MyPriority;

static LEDServiceState_t CurrentState;

uint8_t KnobLEDOn;
uint8_t ButtonLEDOn;
uint8_t TorchLEDOn;
static uint8_t Button1;
static uint8_t Button2;
static uint8_t Button3;
uint8_t LEDstate;
static uint8_t counter;
uint8_t LEDinput;
static uint8_t flame_on;
static uint8_t ButtonOn;
static uint8_t TorchLED;
static uint8_t AllLED;
// add a deferral queue for up to 3 pending deferrals +1 to allow for overhead
static ES_Event DeferralQueue[3+1];

/*------------------------------ Module Code ------------------------------*/

LEDServiceState_t QueryLEDService ( void )
{
return CurrentState;
}

/****************************************************************************/
bool InitializeLEDService ( uint8_t Priority )
{
ES_Event ThisEvent;
MyPriority = Priority; //Initialize the MyPriority variable with the passed in
parameter.

CurrentState = Welcome;
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC); //Initialize cycle by which LEDs
flash for lever
SR_Init();

counter= 0;
TorchLEDOn = 0;
flame_on = 0;
ButtonOn = 0;

if ((HWREG(SYSCTL_RCGCGPIO) & BIT2HI) == 0) { //if clock has not been enabled,

then enable it
HWREG(SYSCTL_RCGCGPIO) |= BIT2HI;
while ((HWREG(SYSCTL_PRGPIO) & BIT2HI) != BIT2HI){
}
}

//Initialize pin for torch flame LED(s)

HWREG(GPIO_PORTC_BASE+GPIO_O_DEN) |= (BIT6HI);
HWREG(GPIO_PORTC_BASE+GPIO_O_DIR) |= (BIT6HI);
HWREG(GPIO_PORTC_BASE+(GPIO_O_DATA+ALL_BITS)) &= BIT6LO;

//ThisEvent.EventType ;

if (ES_PostToService( MyPriority, ThisEvent) == true)

{
return true;
}
else
{
return false;
}
}

/****************************************************************************/
bool PostLEDService( ES_Event ThisEvent )
{
return ES_PostToService( MyPriority, ThisEvent);
}

/****************************************************************************/
/*
SHIFT REGISTER PINOUT FOR LEDs:
0-2 are for Rocket LEDs
3-5 are for Button LEDs
6 is for Knob LED
7 is for Torch indicator LEDs (on both prop torch and actual torch)
On Tiva:
Port C Pin 4 controls Torch Flame LEDs
*/

ES_Event RunLEDService( ES_Event ThisEvent ){

ES_Event ReturnEvent;
ReturnEvent.EventType = ES_NO_EVENT; // assume no errors

LEDServiceState_t NextState;
NextState = CurrentState;

switch(CurrentState){
//Inititate the relevant variables
case Welcome : //If the CurrentState is Welcome
//Create cycle of flashing Rocket LEDs in Welcome state
if(ThisEvent.EventType == ES_LEVER_PULLED){//If the lever is pulled
SR_Write(0x00); //Turn off Rocket LEDs
NextState = Terraform;
ES_Timer_InitTimer(INACTIVITY_TIMER, THIRTY_SEC);
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
SR_Write(KnobLED);
KnobLEDOn = 1;
//Start flashing Terraform LED
}

if(ThisEvent.EventType == ES_TIMEOUT){
LEDstate = counter % 4;
if (LEDstate == 0){
SR_Write(0X00);
}
if (LEDstate == 1){
LEDinput = RocketLED1;
SR_Write(LEDinput);
}
if (LEDstate == 2){
LEDinput = RocketLED1 | RocketLED2;
SR_Write(LEDinput);
}
if (LEDstate == 3){
LEDinput = RocketLED1 | RocketLED2 | RocketLED3;
SR_Write(LEDinput);
}
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
counter = counter + 1;
}

if (flame_on == 1){
ThisEvent.EventType = BACK_TO_WELCOME;
PostVibratingMotor(ThisEvent);
flame_on = 0;
}
break;

case Terraform :
// //When knob is first turned, keep LED on (the way you currently have
it, you keep LED on after a timer expires, but this way may make more sense)
// //Wait some time and then start flashing the PopUp LED(s) (Do we want
to trigger the PopUp by making the user press a particular button or any of the three
buttons?)
if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
INACTIVITY_TIMER)){
//Reset back to the Welcome state:
NextState = Welcome;
 ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
KnobLEDOn = 0;
SR_Write(0x00);
}
if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
ROCKET_TIMER1)){
if (KnobLEDOn == 1){
SR_Write(0x00);
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
KnobLEDOn = 0;
}
else if(KnobLEDOn == 0){
SR_Write(KnobLED);
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
KnobLEDOn = 1;
}
}
if (ThisEvent.EventType == ES_KNOB_TURNED){
if (KnobLEDOn != 2){
SR_Write(KnobLED);
ES_Timer_InitTimer(ROCKET_TIMER2, HALF_SEC);
}
KnobLEDOn = 2;
ES_Timer_InitTimer(INACTIVITY_TIMER, THIRTY_SEC);
}
if (KnobLEDOn == 2){
if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
ROCKET_TIMER2) ){ //All button LEDs flash if no button has been pressed
if (ButtonLEDOn == 1){
SR_Write(KnobLED | Button1LED);
ButtonLEDOn = 0;
}
else if(ButtonLEDOn == 0){
SR_Write(KnobLED);
ButtonLEDOn = 1;
}
ES_Timer_InitTimer(ROCKET_TIMER2, HALF_SEC);
}
}

if ((ThisEvent.EventType == ES_BUTTON1_PRESSED) && (KnobLEDOn == 2)) {

//if a POP_UP_BUTTON_PRESSED event occurs (i.e. user pushed one of the pop up buttons)
NextState = Popup; //NextState = PopUp;
Button1 = 1;
ES_Timer_InitTimer(INACTIVITY_TIMER, THIRTY_SEC); //Reset 30s timer
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);

}
break;

case Popup :
if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
INACTIVITY_TIMER)){
//Reset back to the Welcome state:
NextState = Welcome;
Button1 = 0;
Button2 = 0;
Button3 = 0;
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
}

if ((ThisEvent.EventType == ES_BUTTON2_PRESSED) && (Button2 == 0) ) {

//if a BUTTON2 event occurs (i.e. user pushes Button 2)
Button2 = 1;
 ES_Timer_InitTimer(INACTIVITY_TIMER, THIRTY_SEC); //Reset 30s timer
}
if ((ThisEvent.EventType == ES_BUTTON3_PRESSED) && (Button3 == 0) &&
(Button2 == 1)) {
Button3 = 1;
ES_Timer_InitTimer(INACTIVITY_TIMER, THIRTY_SEC); //Reset 30s timer
}

//Once a user has pressed a button, keep the associated LED for that
button on
if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
ROCKET_TIMER1)){
if(ButtonOn == 0){
if (Button2 == 0){
SR_Write(KnobLED | Button1LED | Button2LED); }
if ((Button2==1) && (Button3 == 0)){
SR_Write(KnobLED | Button1LED | Button2LED | Button3LED );
}
if (Button3 == 1){
SR_Write(KnobLED | Button1LED | Button2LED | Button3LED |
TorchIndLED);
TorchLEDOn = 1;
}
ButtonOn = 1;
}
else if(ButtonOn == 1){
if (Button2 == 0){
SR_Write(KnobLED | Button1LED );
}
if ((Button2==1) && (Button3 == 0)){
SR_Write(KnobLED | Button1LED | Button2LED);
}
if (Button3 == 1){
SR_Write(KnobLED | Button1LED | Button2LED | Button3LED);
TorchLEDOn = 1;
}
ButtonOn = 0;
}
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
}

if ((ThisEvent.EventType == ES_PROX_DETECTED) && (Button3==1)){ //if

there's a ES_PROX_DETECTED event (i.e. if user brings prop torch up to Olympic torch
and proximity sensor is triggered)

ES_Event NewEvent;
NewEvent.EventType = ES_FAN_TRIGGER;
PostFan(NewEvent);

NextState = Torch; //NextState = Torch;

ES_Timer_InitTimer(INACTIVITY_TIMER, THIRTY_SEC); //Reset 30s timer
SR_Write(KnobLED | Button1LED | Button2LED | Button3LED);
ThisEvent.EventType = TORCH_LIT;
PostVibratingMotor(ThisEvent);
HWREG(GPIO_PORTC_BASE+(GPIO_O_DATA+ALL_BITS)) |= BIT6HI; //turn on
torch flame LEDs
TorchLED = 1;
ES_Timer_InitTimer(ROCKET_TIMER2, QUARTER_SEC);
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
AllLED = 1;
}
break;

case Torch :
 if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
ROCKET_TIMER2)){
if(TorchLED == 1){
HWREG(GPIO_PORTC_BASE+(GPIO_O_DATA+ALL_BITS)) &= BIT6LO;
TorchLED = 0;
}
else if (TorchLED == 0){
HWREG(GPIO_PORTC_BASE+(GPIO_O_DATA+ALL_BITS)) |= BIT6HI;
TorchLED = 1;
}
ES_Timer_InitTimer(ROCKET_TIMER2, QUARTER_SEC);
}
if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
ROCKET_TIMER1)){
if(AllLED == 1){
SR_Write(0x00);
AllLED = 0;
}
else if (AllLED == 0){
SR_Write(KnobLED | Button1LED | Button2LED | Button3LED|
TorchIndLED);
AllLED = 1;
}
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
}
if ((ThisEvent.EventType == ES_TIMEOUT) && (ThisEvent.EventParam ==
INACTIVITY_TIMER)){
//Reset back to the Welcome state:
NextState = Welcome;
flame_on = 1;
ES_Timer_InitTimer(ROCKET_TIMER1, HALF_SEC);
HWREG(GPIO_PORTC_BASE+(GPIO_O_DATA+ALL_BITS)) &= BIT6LO; //turn off
torch flame LEDs
Button1 = 0;
Button2 = 0;
Button3 = 0;
}
break;
}

CurrentState = NextState;
return ReturnEvent; //Return ES_NO_EVENT
}