#include "includes.h"

extern tsEDK 	EDK;
extern tsAppCB  appCB;



/******************************************************************************
//	ProccessLED
//
//  aktualizuje stav LED podle prijateho prikazu GUI
******************************************************************************/
void ProccessLED(void)
{
  //**********************************
  // BUZZER a LED kopiruji stav rele?
  //**********************************
  if (EDK.io_flag & FLAG_BUZZ_FOLLOW_MODE)		// pokud piskac ma kopirovat stav rele
   {
	 if (EDK.output & EDK_OUT_RELAY) EDK.output |= EDK_OUT_BUZZER;	
	  else  EDK.output &= ~EDK_OUT_BUZZER;
   }

   
  if (EDK.io_flag & FLAG_RED_FOLLOW_MODE)		// pokud RED_LED ma kopirovat stav rele
   {
	 if (EDK.output & EDK_OUT_RELAY) EDK.output |= EDK_OUT_LED_RED;	
   }


  if (EDK.io_flag & FLAG_GRN_FOLLOW_MODE)		// pokud RED_GRN ma kopirovat stav rele
   {
	 if (EDK.output & EDK_OUT_RELAY) EDK.output |= EDK_OUT_LED_GRN;	
   }



  //******************************
  // blikani LED
  //******************************
	 if (EDK.io_flag & FLAG_LED_TIMEOUT)					// pokud predchozi cyklus docasoval			
	  {
	   if ((EDK.io_flag & FLAG_RED_PULSE_MODE) || (EDK.io_flag & FLAG_GRN_PULSE_MODE))	// je pozadavek blikat LED RED/GRN
   		{
		  if (EDK.io_flag & FLAG_RED_PULSE_MODE)				// pozadavek blikat LED RED
		   {
		    EDK.output ^= EDK_OUT_LED_RED;  				// LED RED flip
		   }
		
		  if (EDK.io_flag & FLAG_GRN_PULSE_MODE)				// pozadavek blikat LED GRN
		   {
	  	     EDK.output ^= EDK_OUT_LED_GRN;  				// LED GRN flip
	       }
				
		  EDK.io_flag &= ~FLAG_LED_TIMEOUT;					// smazat flag timeout
		  EDK.counter.led_time = PRESET_LED_PULSE_LENGTH;	// nastavit casovac delky bliknuti

		 // citac poctu bliknuti	
	     if (EDK.counter.led_cycles != 0xff)				// pokud je pocet bliknuti 0xff
	      {													// tak blika porad
		   if (!EDK.counter.flip_div--)	 		   
	        {
			 EDK.counter.flip_div = 1;
			 EDK.counter.led_cycles--;						// jinak dekrementovat citac
		    }
	      }

		 if (!EDK.counter.led_cycles)
		  {
			
		    if (EDK.io_flag & FLAG_RED_PULSE_MODE)			// pokud se blikalo cervenou 
		     {
		      EDK.io_flag &= ~FLAG_RED_PULSE_MODE;			// a je provedeno pocet bliknuti, tak ukoncit
 			  RestoreIdleLedState();
			 }

		    if (EDK.io_flag & FLAG_GRN_PULSE_MODE)			// pokud se blikalo zelenou
		     {
		      EDK.io_flag &= ~FLAG_GRN_PULSE_MODE;			// a je provedeno pocet bliknuti, tak ukoncit
			  RestoreIdleLedState();
			 }
		  }												
			// ----  staticky rezim -----
	  }				//if ((EDK.io_flag & FLAG_RED_PULSE_MODE) || (EDK.io_flag & FLAG_GRN_PULSE_MODE))		
	   else
	    {
		  EDK.io_flag &= ~FLAG_LED_TIMEOUT;				// mazat flag , aby sem nevstupovalo opakovane
		  
		  if(!(EDK.io_flag & FLAG_RED_FOLLOW_MODE) && !(EDK.io_flag & FLAG_GRN_FOLLOW_MODE)) // s navratem LED do vychoziho stavu
		   {																			// pockat az bude ukoncen FOLOW mode
		     RestoreIdleLedState();
		   }
		}
	   							
   }				//if (EDK.io_flag & FLAG_LED_TIMEOUT)
   
}	 
	 


/******************************************************************************
//	LED_test
//
//  blikce vsemi LED po startu
******************************************************************************/
void LED_test(void)
{
  #if defined INTERFACE_EDK || defined INTERFACE_RS		// EDK ctecky indikuji rozsvicenim vsech LED
 
    LED_RED_ON;				// zapnout LED
    LED_GRN_ON;
    WaitTimeout(250);		// delka bliknuti
    LED_GRN_OFF;			// vypnout LED
    LED_RED_OFF;			// zapnout LED
    WaitTimeout(250);		// delka bliknuti
    LED_RED_ON;

  #elif defined INTERFACE_RSN	// RON 2x blikne cervenou a zapipa
    LED_RED_ON;				// zapnout LED
    BUZZER_ON;
    WaitTimeout(100);		// delka bliknuti
    LED_RED_OFF;			// zapnout LED
	BUZZER_OFF;
    WaitTimeout(100);		// delka bliknuti
    LED_RED_ON;
	BUZZER_ON;
    WaitTimeout(100);		// delka bliknuti
    LED_RED_OFF;			// zapnout LED
	BUZZER_OFF;
  #endif
  
}

	
		
/******************************************************************************
//	SetLedState
//
//  ulozi klidovy stav LED
******************************************************************************/
void SetLedState(void)
{
#if defined INTERFACE_RS || defined INTERFACE_RD3
	EDK.io_flag &= ~FLAG_RED_PULSE_MODE;	// nejdrive smazat flag
	EDK.io_flag &= ~FLAG_GRN_PULSE_MODE;	// nejdrive smazat flag
	
	EDK.output &= ~EDK_OUT_LED_RED;			// nejdrive smazat flag
	EDK.output &= ~EDK_OUT_LED_GRN;			
									
										
		// *********************			
		// funkce LED RED
		// *********************
		switch (EDK.led.mask & GUI_RED_MASK)
		 {
			case GUI_RED_STATIC_MODE: 
  	 			EDK.output |= EDK_OUT_LED_RED;				// RED = ON
		  	    EDK.counter.led_time = EDK.led.value;		// doba svitu LED [x100ms]
				
				if(EDK.led.value == 0xff)					// pokud je pozadovano trvale sepnuti
				 {
				   saveLastLedState();						// stava se to vychozim stavem		
				 }
			break;

			 
			case GUI_RED_PULSE_MODE: 
  	 			EDK.io_flag |= FLAG_RED_PULSE_MODE;				// RED = BLIKA
				EDK.counter.led_time = PRESET_LED_PULSE_LENGTH;	// nastavit casovac delky bliknuti
				EDK.counter.led_cycles = EDK.led.value;			// pocet bliknuti 

				if(EDK.led.value == 0xff)					// pokud je pozadovano trvale sepnuti
				 {
				   saveLastLedState();						// stava se to vychozim stavem		
				 }
			break;


			case GUI_RED_FOLLOW_MODE:	
	 			EDK.io_flag |= FLAG_RED_FOLLOW_MODE;			// a teprve ted nastavit ze RED kopiruje stav rele
	 		break;

			 
			default: break;	
		 }

		// *********************
		// funkce LED GRN
		// *********************
		switch (EDK.led.mask & GUI_GRN_MASK)
		 {
			case GUI_GRN_STATIC_MODE: 
  	 			EDK.output |= EDK_OUT_LED_GRN;				// GRN = ON
				EDK.counter.led_time = EDK.led.value;		// doba svitu LED [x100ms]

				if(EDK.led.value == 0xff)					// pokud je pozadovano trvale sepnuti
				 {
				   saveLastLedState();						// stava se to vychozim stavem		
				 }
				 
			break;

			 
			case GUI_GRN_PULSE_MODE: 
				EDK.output &= ~EDK_OUT_LED_GRN;					// smazat flag, protoze se hned xoruje, aby LED zacala blikat pulsem
  	 			EDK.io_flag |= FLAG_GRN_PULSE_MODE;				// GRN = BLIKA
				EDK.counter.led_time = PRESET_LED_PULSE_LENGTH;	// nastavit casovac delky bliknuti
				EDK.counter.led_cycles = EDK.led.value;			// pocet bliknuti 

				if(EDK.led.value == 0xff)						// pokud je pozadovano trvale sepnuti
				 {
				   saveLastLedState();							// stava se to vychozim stavem		
				 }
			break;


			case GUI_GRN_FOLLOW_MODE:	
				EDK.io_flag |= FLAG_GRN_FOLLOW_MODE;			// a teprce pak nastavit FLAG LED GREEN kopiruje stav rele
	 		break;

			 
			default: break;	
		 }

	// situace pro zadnou indikaci pomoci LED
	if ((EDK.led.mask == 0) && (EDK.led.value == 0xff))	
     {
	   saveLastLedState();										// stava se to vychozim stavem		
	 }


							  
#endif

}



/******************************************************************************
//	saveLastLedState
//
// nastavi klidovy/vychozi stav LED
******************************************************************************/
#if defined INTERFACE_RS || defined INTERFACE_RD3
void saveLastLedState(void)
{	 
  if (!EDK.led.mask && !EDK.led.value) 
  {
    EDK.led.mask |= 0x01;					// default sviti cervena led
    EDK.led.value = 0xff;					// sviti tvale
  }

   EDK.led.idle_value = EDK.led.value;
   EDK.led.idle_mask = EDK.led.mask;  
}		
#endif  


/******************************************************************************
//	RestoreIdleLedState
//
//  obnovi klidovy stav LED
******************************************************************************/
#if defined INTERFACE_RS  || defined INTERFACE_RD3
void RestoreIdleLedState(void)
{
  // obnovi klidovy/vychozi stav LED
  EDK.led.value = EDK.led.idle_value;
  EDK.led.mask = EDK.led.idle_mask;
  
  SetLedState();
}
#endif 

/******************************************************************************
//	UpdateLedState
//
//  aktualizace stavu LED
******************************************************************************/
void UpdateLedState(void)
{
// pokud je pozadavek na blikani obou LED je nutne provest synchronizaci jejich stavu
 if ((EDK.io_flag & FLAG_RED_PULSE_MODE) && (EDK.io_flag & FLAG_GRN_PULSE_MODE))	
 {
   if ((EDK.output & EDK_OUT_LED_RED) != (EDK.output & EDK_OUT_LED_GRN))	// stavy se rozchazeji
    {
     EDK.output |= EDK_OUT_LED_RED;											// tak synchronizovat stav
     EDK.output |= EDK_OUT_LED_GRN;
	}
 }


// aktivace RED LED
 if ( EDK.output & EDK_OUT_LED_RED)
  {
	  LED_RED_ON;
  }
 else
  {
	  LED_RED_OFF;	// ovladani LED RED
  }


// aktivace GRN LED
 if ( EDK.output & EDK_OUT_LED_GRN) 
  {
	  LED_GRN_ON; 
  }
 else 
  {
	  LED_GRN_OFF;	// ovladeni LED GREEN
  }


}




/******************************************************************************
//	SetQuiteLedState
//
//  nastavi stav LED pro tichy rezim
******************************************************************************/
void SetQuiteLedState(void)
{
 EDK.led.value = 0xff;		// value LED - sviti trvale
 EDK.led.mask  = 0x00;		// maska LED - GRN=RED=OFF
 //EDK.led.mask  = 0x04;		// maska LED - GRN=ON
 SetLedState();				// nastavit stavy LED														
}


/******************************************************************************
//	SetOfflineLedState
//
//  nastavi stav LED pro OFFLINE rezim
******************************************************************************/
void SetOfflineLedState(void)
{
 EDK.led.value = 0xff;		// value LED - sviti trvale
 EDK.led.mask  = 0x05;		// maska LED - RED+GRN=ON
 SetLedState();				// nastavit stavy LED														
}


/******************************************************************************
//	SetDefaultLedState
//
//  obnovi klidovy stav LED 
******************************************************************************/
void SetDefaultLedState(void)
{
  EDK.led.mask = 0;			// pokud jiz vypadla komunikace, sviti LED RED+GRN
  EDK.led.value = 0; 		// nastavit proto novy klidovy stav - LED RED sviti trvale
  saveLastLedState();		// ulozit jako posledni stav
  SetLedState();			// aktualizovat			
}




