/*
 * NLase_v1.c
 *
 * Created: 8/31/2020 6:15:27 PM
 * Author : sukha
 */ 

/**
*******************************************************************************
  DOC			:2-1-2019
  Project Name	:SINGLE_TORCH
  Controller	:ATMEGA88P
  Compiler		:AVR GCC
  IDE			:AVR STUDIO4.18.716
  WinAVR		:WinAVR 20100110
  
  //HARDWARE USED
  LASER         :660NM(EGISMOS,50mW) AND 810NM(EGISMOS,200mW)
  DRIVER		:EDL2M
  DISPLAY		:LED FOR CHANNEL_SEL AND TIME_ADJUSTMENT
  PUSH_BUTTON	:FOR CHANNEL_SEL, TIME_ADJUSTMENT AND START_STOP
  SMPS			:BATTERY_3.7V LiIon
   

  Optimization	:-Os (default)

  //FUSE SETTINGS
	BODLEVEL	:Brown-our detection at VCC=2.7V
	OCDEN	  	:Unticked
	JTAGEN		:Unticked
	SPIEN		  :Ticked
	WIDTON		:Unticked
	EESAVE		:Unticked
	BOOTSZ		:Boot Flash size=2048 words start address=$3800 (default)
	BOOTRST		:Unticked
	CKDIV8		:Unticked
	CKOUT		  :Unticked
	SUT_CKSEL	:Ext.Crystal Osc.8.0- MHz;Start-up time:6K/14CK+65ms
 *******************************************************************************
**/

/******************************************************************************
 *****************************		SINGLE_TORCH_Version1.c	***************************
 ******************************************************************************
 *	Description : Main file for initialization and processing				  *

 ******************************************************************************
 *  Created: 2/1/2019 11:53:00 AM
 *  Author: MEDSOL
 *****************************************************************************/

#include <avr/io.h>
#include <stdio.h>
//#define F_CPU 11059200UL
#define F_CPU 16000000UL
#include <util/delay.h>
#include <avr/interrupt.h>

/******************************************************************************
 ***						Constant Declarations							***
 *****************************************************************************/
//KEY_DEFINITIONS
//MIN1_LED
#define MIN1_LED_BIT 							 	PF0
#define MIN1_LED_PORT  					  	PORTF
#define MIN1_LED_DDR     						DDRF
//MIN2_LED
#define MIN2_LED_BIT  							PF1
#define MIN2_LED_PORT    						PORTF
#define MIN2_LED_DDR     						DDRF
//MIN5_LED
#define MIN5_LED_BIT      					PF2
#define MIN5_LED_PORT     					PORTF
#define MIN5_LED_DDR      					DDRF
//MIN10_LED
#define MIN10_LED_BIT  	  	       	PF3
#define MIN10_LED_PORT  	  				PORTF
#define MIN10_LED_DDR		     				DDRF
//CH_660_LED
#define CH_660_LED_BIT  						PF4
#define CH_660_LED_PORT 				   	PORTF
#define CH_660_LED_DDR  				   	DDRF
//CH_808_LED
#define CH_808_LED_BIT  	 					PF5
#define CH_808_LED_PORT   			 		PORTF
#define CH_808_LED_DDR    			 		DDRF
//MLD_EN FOR 660NM
#define MLD_EN_BIT 									PF6
#define MLD_EN_PORT  						 		PORTF
#define MLD_EN_DDR    							DDRF
//EDL_EN FOR 810NM
#define EDL_EN_BIT 									PF7
#define EDL_EN_PORT   							PORTF
#define EDL_EN_DDR    							DDRF
//TIME_ADJ_INC
#define TIME_ADJ_SWITCH_BIT					PK0
#define TIME_ADJ_SWITCH_PORT   			PORTK
#define TIME_ADJ_SWITCH_DDR   			DDRK
#define TIME_ADJ_SWITCH_PORTIN   		PINK
//CHANNEL_SEL
#define CHANNEL_SEL_SWITCH_BIT	  	PK1
#define CHANNEL_SEL_SWITCH_ PORT  	PORTK
#define CHANNEL_SEL_SWITCH_DDR    	DDRK
#define CHANNEL_SEL_SWITCH_PORTIN 	PINK
//START_STOP
#define START_STOP_SWITCH_BIT	    	PK2
#define START_STOP_SWITCH_PORT   		PORTK
#define START_STOP_SWITCH_DDR    		DDRK
#define START_STOP_SWITCH_PORTIN 		PINK
//TEST CHANNEL
#define TEST_CHANNEL_SWITCH_BIT	    PK3
#define TEST_CHANNEL_SWITCH_PORT   	PORTK
#define TEST_CHANNEL_SWITCH_DDR    	DDRK
#define TEST_CHANNEL_SWITCH_PORTIN 	PINK


//BUZZER
#define BUZZER_BIT									PJ1
#define BUZZER_PORT  						 		PORTJ
#define BUZZER_DDR    							DDRJ

//CHANNEL NEW LED
#define CH_NEW_LED_BIT							PJ0
#define CH_NEW_LED_PORT  						PORTJ
#define CH_NEW_LED_DDR    					DDRJ

//TEST CHANNEL LED
#define TEST_CHANNEL_LED_BIT				PD3
#define TEST_CHANNEL_LED_PORT  			PORTD
#define TEST_CHANNEL_LED_DDR    		DDRD

//MIN15_LED
#define MIN15_LED_BIT  	  	       	PH1
#define MIN15_LED_PORT  	  				PORTH
#define MIN15_LED_DDR		     				DDRH

//EDL_TEST_EN
#define EDL_TEST_EN_BIT 									PH0
#define EDL_TEST_EN_PORT   							PORTH
#define EDL_TEST_EN_DDR    							DDRH


//IO_CONFIG
#define BIT_AS_INPUT(DDR,BIT)				 (DDR &= ~(1 << BIT))
#define BIT_AS_OUTPUT(DDR,BIT)			 (DDR |= (1 << BIT))

#define BIT_PULLUP_ENABLE(PORT,BIT)  (PORT |= (1 <<BIT))
#define BIT_PULLUP_DISABLE(PORT,BIT) (PORT &= ~(1 <<BIT))

//OUTPUT_BIT_CONTROL
#define SET_BIT(PORT,BIT)      			 (PORT |= (1 << BIT))
#define CLEAR_BIT(PORT,BIT)    			 (PORT &= ~(1 <<BIT)) 
#define TOGGLE_BIT(PORT,BIT)   			 (PORT ^= (1 <<BIT))

//EDL_EN
#define EDL_EN_SET				SET_BIT(EDL_EN_PORT,EDL_EN_BIT) 
#define EDL_EN_CLEAR			CLEAR_BIT(EDL_EN_PORT,EDL_EN_BIT) 
#define EDL_EN_TOGGLE			TOGGLE_BIT(EDL_EN_PORT,EDL_EN_BIT) 

//MLD_EN
#define MLD_EN_SET				SET_BIT(MLD_EN_PORT,MLD_EN_BIT) 
#define MLD_EN_CLEAR			CLEAR_BIT(MLD_EN_PORT,MLD_EN_BIT) 
#define MLD_EN_TOGGLE			TOGGLE_BIT(MLD_EN_PORT,MLD_EN_BIT) 

//EDL_TEST_EN
#define EDL_TEST_EN_SET				SET_BIT(EDL_TEST_EN_PORT,EDL_TEST_EN_BIT) 
#define EDL_TEST_EN_CLEAR			CLEAR_BIT(EDL_TEST_EN_PORT,EDL_TEST_EN_BIT) 
#define EDL_TEST_EN_TOGGLE			TOGGLE_BIT(EDL_TEST_EN_PORT,EDL_TEST_EN_BIT) 

//BUZZER
#define BUZZER_SET				SET_BIT(BUZZER_PORT,BUZZER_BIT) 
#define BUZZER_CLEAR			CLEAR_BIT(BUZZER_PORT,BUZZER_BIT) 
#define BUZZER_TOGGLE			TOGGLE_BIT(BUZZER_PORT,BUZZER_BIT)

//CHANNEL NEW LED
#define CH_NEW_LED_SET				SET_BIT(CH_NEW_LED_PORT,CH_NEW_LED_BIT) 
#define CH_NEW_LED_CLEAR			CLEAR_BIT(CH_NEW_LED_PORT,CH_NEW_LED_BIT) 
#define CH_NEW_LED_TOGGLE			TOGGLE_BIT(CH_NEW_LED_PORT,CH_NEW_LED_BIT)

//CH_660_LED
#define CH_660_LED_SET			SET_BIT(CH_660_LED_PORT,CH_660_LED_BIT) 
#define CH_660_LED_CLEAR		CLEAR_BIT(CH_660_LED_PORT,CH_660_LED_BIT)
#define CH_660_LED_TOGGLE		TOGGLE_BIT(CH_660_LED_PORT,CH_660_LED_BIT)

//CH_808_LED
#define CH_808_LED_SET			SET_BIT(CH_808_LED_PORT,CH_808_LED_BIT) 
#define CH_808_LED_CLEAR		CLEAR_BIT(CH_808_LED_PORT,CH_808_LED_BIT)
#define CH_808_LED_TOGGLE		TOGGLE_BIT(CH_808_LED_PORT,CH_808_LED_BIT)

//MIN1_LED
#define MIN1_LED_SET		SET_BIT(MIN1_LED_PORT,MIN1_LED_BIT) 
#define MIN1_LED_CLEAR		CLEAR_BIT(MIN1_LED_PORT,MIN1_LED_BIT)
//MIN2_LED
#define MIN2_LED_SET		SET_BIT(MIN2_LED_PORT,MIN2_LED_BIT) 
#define MIN2_LED_CLEAR		CLEAR_BIT(MIN2_LED_PORT,MIN2_LED_BIT)
//MIN5_LED
#define MIN5_LED_SET		SET_BIT(MIN5_LED_PORT,MIN5_LED_BIT) 
#define MIN5_LED_CLEAR		CLEAR_BIT(MIN5_LED_PORT,MIN5_LED_BIT)
//MIN10_LED
#define MIN10_LED_SET		SET_BIT(MIN10_LED_PORT,MIN10_LED_BIT) 
#define MIN10_LED_CLEAR		CLEAR_BIT(MIN10_LED_PORT,MIN10_LED_BIT)

//MIN15_LED
#define MIN15_LED_SET		SET_BIT(MIN15_LED_PORT,MIN15_LED_BIT) 
#define MIN15_LED_CLEAR		CLEAR_BIT(MIN15_LED_PORT,MIN15_LED_BIT)

//TEST CHANNEL LED
#define TEST_CHANNEL_LED_SET			SET_BIT(TEST_CHANNEL_LED_PORT,TEST_CHANNEL_LED_BIT) 
#define TEST_CHANNEL_LED_CLEAR		CLEAR_BIT(TEST_CHANNEL_LED_PORT,TEST_CHANNEL_LED_BIT)
#define TEST_CHANNEL_LED_TOGGLE		TOGGLE_BIT(TEST_CHANNEL_LED_PORT,TEST_CHANNEL_LED_BIT)


//CHECK_INPUT
#define BIT_HIGH(PORTIN,BIT)   (PORTIN & (1 << BIT))
#define BIT_LOW(PORTIN,BIT)    (!(PORTIN & (1 << BIT)))

#define START_STOP_SWITCH_PRESSED		BIT_LOW(START_STOP_SWITCH_PORTIN,START_STOP_SWITCH_BIT)  
#define CHANNEL_SEL_SWITCH_PRESSED		BIT_LOW(CHANNEL_SEL_SWITCH_PORTIN,CHANNEL_SEL_SWITCH_BIT)  
#define TIME_ADJ_SWITCH_PRESSED		BIT_LOW(TIME_ADJ_SWITCH_PORTIN,TIME_ADJ_SWITCH_BIT)  

#define TEST_CHANNEL_SWITCH_PRESSED		BIT_LOW(TEST_CHANNEL_SWITCH_PORTIN,TEST_CHANNEL_SWITCH_BIT)  

#define STOP	0
#define START	1

#define CH_660	0
#define CH_808	1
#define ALL_CH	3
#define CH_TEST 2

#define CW		0
#define PULSED	1

#define	TIMER1_TIMERISR			TIMER1_OVF_vect
#define TREATMENT_TIMER_LIMIT_IN_MILLI_SEC	1000
#define LASER_TIMER_LIMIT_IN_MILLI_SEC		500

/******************************************************************************
 ***						Global Declarations								***
 *****************************************************************************/
unsigned char gStartStopSelectedState=0; // if start means 1 and stop means 0
unsigned char gCurChannel=0;   //  Current channal selection
unsigned char gTreatmentTimeSelectionCount=1;  // 0 means 1min, 1 means 2min, 2 means 5min and 3 means 10 min
unsigned int gTreatmentTimeSelectedInSecs=0; // selection 60sec/120sec/300sec/600sec
unsigned int gTempTreatmentTimeInSecs=0;  // time in sec in betwwen the selected mode(ie.if selected is 60 sec, then it is between 1 to 60)
unsigned int gTreatmentTimeUpdateTimerCount=0; //inside ISR to increment the timer to reach rquired time value
unsigned char gTreatmentTimeSelectedState=0; //Whether treatment time selectin is done or not
unsigned int gTimerBuzzerCount=0;   // To reach required time delay for Buzzer On/OFF inside ISR 
unsigned int gTimerLedCount=0;   //To reach required time delay for LED On/OFF inside ISR
unsigned char gLaserOnState=0;    // 0means Laser Off state, 1 means Laser ON state
/******************************************************************************
 ***						Function prototypes								***
 *****************************************************************************/
void gSysInit(void);     // for system initialisation 
void gGpioInit(void);   // all GPIO assignement as input or output
void gInitLed7Seg(void);   // not used
void gInitLed(void);   //    Once switced ON, all the LEDs to blink two times
void gInitTimerMask(void);  //  Timer1 TMSK set
void gLaserDriverInit(void); //to make Laser EN to 0
void gLaserOn(void);    // to switch the Lasers
void gLaserOff(void);   //to switch off the laser
void gReadInputAndAction(void);  // According to the Channel, time selection and Start/Stop status, switch ON or Off laser
void gInitTimer1(void); // set al l timer registers and timer value
void gUpdateTreatmentTime(void);
void gUpdateTreatmentTimeOut(void);
void gChannelLedBlink(unsigned char xTimes); // To make Channel LED blink
void gChannelLedSet(void);   // To make Channel LED ON
void gChannelLedClear(void);   // To make Channel LED OFF
void gChannelLedToggle(void);   //To make Channel LED toggle
void gTreatmentTimeSet(void);  //To make the corresponding Time selection LED
void gTimeSelectionLedClear(void);  // to switch off the time selection LED

/******************************************************************************
 ***						Extern definitions								***
 *****************************************************************************/

/******************************************************************************
 ***						Start of routinues								***
 *****************************************************************************/
/******************************************************************************
 *** Function Name	: main													***
 *** Description	: This is main function which includes initialization of***
 ***				all the hardware layer, interrupts, modules and 		***
 ***				starts the main processing								***
 *** Inputs			: NONE													***
 *** Outputs		: Complete functionality if MEDSOL LASER Treatment		***
 *** Returns		: NONE													***
 *****************************************************************************/
int main(void)
{
	gSysInit();
	sei();
	_delay_ms(100);
	while (1)
	{
		gReadInputAndAction();
		if((gLaserOnState)&&(gTreatmentTimeSelectedState))
		{
			gUpdateTreatmentTime();
			gTreatmentTimeSelectedState=0;
		}
	}
	return 0;
}

void gSysInit(void)
{
	gGpioInit();
	gLaserDriverInit();
	gInitTimerMask();
	gInitLed();
	gTreatmentTimeSet();
	gChannelLedSet();
	return;
}
void gGpioInit(void)
{
	//INPUTS
	//Set as Input: #define BIT_AS_INPUT(DDR,BIT) = (DDR &= ~(1 << BIT)) 
	BIT_AS_INPUT(START_STOP_SWITCH_DDR,START_STOP_SWITCH_BIT);		
	BIT_AS_INPUT(CHANNEL_SEL_SWITCH_DDR,CHANNEL_SEL_SWITCH_BIT);	
	BIT_AS_INPUT(TIME_ADJ_SWITCH_DDR,TIME_ADJ_SWITCH_BIT);			
	BIT_AS_INPUT(TEST_CHANNEL_SWITCH_DDR,TEST_CHANNEL_SWITCH_BIT);		
	
	//PULLUPS
	//Enable Pullups: #define BIT_PULLUP_ENABLE(PORT,BIT) = (PORT |= (1 <<BIT)) 
	BIT_PULLUP_ENABLE(START_STOP_SWITCH_PORTIN,START_STOP_SWITCH_BIT);	
	BIT_PULLUP_ENABLE(CHANNEL_SEL_SWITCH_PORTIN,CHANNEL_SEL_SWITCH_BIT);
	BIT_PULLUP_ENABLE(TIME_ADJ_SWITCH_PORTIN,TIME_ADJ_SWITCH_BIT);		
	BIT_PULLUP_ENABLE(TEST_CHANNEL_SWITCH_PORTIN,TEST_CHANNEL_SWITCH_BIT);	
	//OUTPUTS
	//Set as Output: #define BIT_AS_OUTPUT(DDR,BIT) = (DDR |= (1 << BIT)) 
	BIT_AS_OUTPUT(MIN5_LED_DDR,MIN5_LED_BIT);		
	BIT_AS_OUTPUT(MIN10_LED_DDR,MIN10_LED_BIT);		
	BIT_AS_OUTPUT(CH_808_LED_DDR,CH_808_LED_BIT);	
	BIT_AS_OUTPUT(MLD_EN_DDR,MLD_EN_BIT);			
	BIT_AS_OUTPUT(EDL_EN_DDR,EDL_EN_BIT);		
	BIT_AS_OUTPUT(BUZZER_DDR,BUZZER_BIT);		
	BIT_AS_OUTPUT(CH_660_LED_DDR,CH_660_LED_BIT);
	BIT_AS_OUTPUT(MIN1_LED_DDR,MIN1_LED_BIT);	
	BIT_AS_OUTPUT(MIN2_LED_DDR,MIN2_LED_BIT);	

	BIT_AS_OUTPUT(CH_NEW_LED_DDR,CH_NEW_LED_BIT);
	BIT_AS_OUTPUT(MIN15_LED_DDR,MIN15_LED_BIT);
	BIT_AS_OUTPUT(TEST_CHANNEL_LED_DDR,TEST_CHANNEL_LED_BIT);	

	return;
}

void gInitLed(void)
{
	for(char i=0;i<2;i++)
	{
		CH_660_LED_SET;
		CH_808_LED_SET;
		MIN1_LED_SET;
		MIN2_LED_SET;
		MIN5_LED_SET;
		MIN10_LED_SET;
		MIN15_LED_SET;
		CH_NEW_LED_SET;
		TEST_CHANNEL_LED_SET;
		_delay_ms(500);
		CH_660_LED_CLEAR;
		CH_808_LED_CLEAR;
		MIN1_LED_CLEAR;
		MIN2_LED_CLEAR;
		MIN5_LED_CLEAR;
		MIN10_LED_CLEAR;
		MIN15_LED_CLEAR;
		CH_NEW_LED_CLEAR;
		TEST_CHANNEL_LED_CLEAR;
		_delay_ms(500);
	}
	return;
}
void gChannelLedBlink(unsigned char xTimes)
{
	switch(gCurChannel)
	{
		case CH_660:
			for(char i=0;i<xTimes;i++)
			{
				CH_660_LED_SET;
				_delay_ms(100);
				CH_660_LED_CLEAR;
				_delay_ms(100);
				
			}
		break;
		case CH_808:
			for(char i=0;i<xTimes;i++)
			{
				CH_808_LED_SET;
				_delay_ms(100);
				CH_808_LED_CLEAR;
				_delay_ms(100);
				
			}
		break;
		case CH_TEST:
			for(char i=0;i<xTimes;i++)
			{
				CH_NEW_LED_SET;
				_delay_ms(100);
				CH_NEW_LED_CLEAR;
				_delay_ms(100);
			}
		break;
		default:
		break;
	}
	return;
}

void gChannelLedSet(void)
{
	switch(gCurChannel)
	{
		case CH_660:
			CH_660_LED_SET;
			CH_808_LED_CLEAR;
			CH_NEW_LED_CLEAR;
		break;
		case CH_808:
			CH_808_LED_SET;
			CH_660_LED_CLEAR;
			CH_NEW_LED_CLEAR;
		break;
		case CH_TEST:
			CH_NEW_LED_SET;
			CH_660_LED_CLEAR;
			CH_808_LED_CLEAR;
		break;
		default:
		break;
	}
	return;
}

void gChannelLedClear(void)
{
	switch(gCurChannel)
	{
		case CH_660:
			CH_660_LED_CLEAR;
		break;
		case CH_808:
			CH_808_LED_CLEAR;
		break;
		case CH_TEST:
			CH_NEW_LED_CLEAR;
		break;
		default:
		break;
	}
	return;
}

void gChannelLedToggle(void)
{
	switch(gCurChannel)
	{
		case CH_660:
			CH_660_LED_TOGGLE;
		break;
		case CH_808:
			CH_808_LED_TOGGLE;
		break;
		case CH_TEST:
			CH_NEW_LED_TOGGLE;
		break;
		default:
		break;
	}
	return;
}
void gInitTimerMask(void)
{
	gInitTimer1();	

	//	Timer/Counter Interrupt initialization
	//	Timer0/1 Overflow Interrupt Enable
	//	Compare A Match Interrupt: Off
	//	Compare B Match Interrupt: Off
	TIMSK1=(0<<ICIE1)|(0<<OCIE1B) | (0<<OCIE1A) | (1<<TOIE1);

	return;
}

void gInitTimer1(void)
{
	/* Timer/Counter 1 initialization */
	// Clock source: System Clock
	// Clock value: 16mHz
	// Prescale value: 1
	// Mode: Normal 
	// Top=0xFFFF
	// OC1A output: Disconnected
	// OC1B output: Disconnected
	// Noise Canceler: Off
	// Input Capture on Falling Edge
	// Timer Period:
	// Force Output Compare: Disconnected
	TCCR1A=(0<<COM1A1) | (0<<COM1A0) | (0<<COM1B1) | (0<<COM1B0) | (0<<WGM11) | (0<<WGM10);
	TCCR1B=(0<<ICNC1) | (0<<ICES1) | (0<<WGM13) | (0<<WGM12)| (0<<CS12) | (0<<CS11) | (1<<CS10);
	TCCR1C=(0<<FOC1A) | (0<<FOC1B);

	//0xE0C0 = 1mS delay@8MHz,Prescale=1
	//0xD4CD = 1mS [email protected],Prescale=1
	//0xC180 = 1 msec delay@16MHz,Prescale=1
	TCNT1H=0xC1;	
	TCNT1L=0x80;

	OCR1AH=0x00;
	OCR1AL=0x00;
	OCR1BH=0x00;
	OCR1BL=0x00;
	ICR1H=0x00;
	ICR1L=0x00;
	return;
}

/******************************************************************************
 *** Function Name	: timer1_ovf_isr										***
 *** Description	: timer 1 ISR for processing events on 1 miliseconds	***
 ***				for all the timing based events to process		 		***
 *** Inputs			: NONE													***
 *** Outputs		: Timer Update											***
 *** Returns		: Process Events based on the timer expiry				***
 *****************************************************************************/

ISR (TIMER1_TIMERISR)
{
	if(gLaserOnState)
	{
		//UPDATE LASER OUTPUT
		gTreatmentTimeUpdateTimerCount++;
		if(gTreatmentTimeUpdateTimerCount>=TREATMENT_TIMER_LIMIT_IN_MILLI_SEC)
		{
			gTreatmentTimeUpdateTimerCount =0;
			gTreatmentTimeSelectedState=1;
		}
		//UPDATE LED AND BUZZER
		gTimerBuzzerCount++;
		if(gTimerBuzzerCount<501)	
		{
			BUZZER_TOGGLE;			//Buzzer ON for 500mSec
		}
		else if(gTimerBuzzerCount>1000)	//1Sec
		{
			gTimerBuzzerCount=0;	//Buzzer off for 500mSec
		}
		gTimerLedCount++;
		if(gTimerLedCount>500)		//500mS
		{
			gTimerLedCount=0;
			
			switch(gCurChannel)
			{
				case CH_660:
					CH_660_LED_TOGGLE;
				break;
				case CH_808:
					CH_808_LED_TOGGLE;
				break;
				case CH_TEST:
					CH_NEW_LED_TOGGLE;
				break;
				default:
				break;
			}
			
		}
	}

	//0xE0C0 = 1mS delay@8MHz,Prescale=1
	//0xD4CD = 1mS [email protected],Prescale=1
  //0xC180 = 1mS [email protected],Prescale=1
	TCNT1H=0xC1;	
	TCNT1L=0x80;

	return;
}

void gReadInputAndAction(void)
{
	if(CHANNEL_SEL_SWITCH_PRESSED)
	{
		_delay_ms(50);
		if(CHANNEL_SEL_SWITCH_PRESSED)
		{
			if(!gStartStopSelectedState)
			{
				//gCurChannel = !gCurChannel; 
				 gCurChannel++;
				 if(gCurChannel>2)
				 {
						gCurChannel = 0;

				 }
				//gCurChannel = CH_660;
				if(gTempTreatmentTimeInSecs)
				{
					gTreatmentTimeSet();
				}
				gChannelLedSet();
			}
			while(CHANNEL_SEL_SWITCH_PRESSED);
		}
	}
	else if(TIME_ADJ_SWITCH_PRESSED)
	{
		_delay_ms(50);
		if(TIME_ADJ_SWITCH_PRESSED)
		{
			if(!gStartStopSelectedState)
			{
				if(gTreatmentTimeSelectionCount>4)	//1/2/5/10/15 MINS SELECTION
				{
					gTreatmentTimeSelectionCount=0;
				}
				gTreatmentTimeSelectionCount++;
				gTreatmentTimeSet();
			}
			while(TIME_ADJ_SWITCH_PRESSED);
		}
	}
	else if(START_STOP_SWITCH_PRESSED)
	{
		_delay_ms(500);
		if(START_STOP_SWITCH_PRESSED)
		{
			gStartStopSelectedState = !gStartStopSelectedState;
			if(gStartStopSelectedState)
			{
				
				gLaserOn();
				gLaserOnState=1;
				gTreatmentTimeUpdateTimerCount=0;
				gTimerBuzzerCount=0;
				gTimerLedCount=0;
			}
			else
			{
				gLaserOnState=0;
				gLaserOff();
				gTreatmentTimeSelectedState=0;
				gTreatmentTimeUpdateTimerCount =0;
				gTimerBuzzerCount=0;
				BUZZER_CLEAR;
				gTimerLedCount=0;
				gChannelLedSet();
			}
			while(START_STOP_SWITCH_PRESSED);
		}
	}
	else if(TEST_CHANNEL_SWITCH_PRESSED)
	{
		_delay_ms(50);
		if(TEST_CHANNEL_SWITCH_PRESSED)
		{
			TEST_CHANNEL_LED_SET;
			_delay_ms(50);
			while(TEST_CHANNEL_SWITCH_PRESSED);
			TEST_CHANNEL_LED_CLEAR;
		}
	}
	return;
}

void gUpdateTreatmentTime(void)
{
	if(gTempTreatmentTimeInSecs)
	{
		gTempTreatmentTimeInSecs--;
		if(!gTempTreatmentTimeInSecs)
		{
			gUpdateTreatmentTimeOut();
		}
	}
	return;
}

void gUpdateTreatmentTimeOut(void)
{
	gStartStopSelectedState=0;
	gLaserOnState=0;
	gLaserOff();
	gTreatmentTimeSelectedState=0;
	gTreatmentTimeUpdateTimerCount =0;
	gTimerBuzzerCount=0;
	BUZZER_CLEAR;
	gTimerLedCount=0;
	gTempTreatmentTimeInSecs = gTreatmentTimeSelectedInSecs;
	gChannelLedSet();
	return;
}

void gLaserDriverInit(void)
{
	EDL_EN_CLEAR;
	MLD_EN_CLEAR;
	EDL_TEST_EN_CLEAR;
	return;
}

void gLaserOn(void)
{
	if(gCurChannel == CH_660)
	{
		MLD_EN_SET;
		EDL_EN_CLEAR;
		EDL_TEST_EN_CLEAR;
	}
	else if(gCurChannel == CH_808)
	{
		EDL_EN_SET;
		MLD_EN_CLEAR;
		EDL_TEST_EN_CLEAR;
	}
	else if(gCurChannel == CH_TEST)
	{
		EDL_EN_CLEAR;
		MLD_EN_CLEAR;
		EDL_TEST_EN_SET;
	}
	return;
}

void gLaserOff(void)
{
	if(gCurChannel == CH_660)
	{
		MLD_EN_CLEAR;
				
	}
	else if(gCurChannel == CH_808)
	{
		EDL_EN_CLEAR;
	}
	else if(gCurChannel == CH_TEST)
	{
		EDL_TEST_EN_CLEAR;
	}
	return;
}

void gTreatmentTimeSet(void)
{
	switch(gTreatmentTimeSelectionCount)
	{
		case 1:
			gTreatmentTimeSelectedInSecs = 60;		//1MINUTE
			MIN1_LED_SET;
			MIN2_LED_CLEAR;
			MIN5_LED_CLEAR;
			MIN10_LED_CLEAR;
			MIN15_LED_CLEAR;
		break;
		case 2:
			gTreatmentTimeSelectedInSecs = 120;		//2MINUTES
			MIN2_LED_SET;
			MIN1_LED_CLEAR;
			MIN5_LED_CLEAR;
			MIN10_LED_CLEAR;
			MIN15_LED_CLEAR;
		break;
		case 3:
			gTreatmentTimeSelectedInSecs = 300;		//5MINUTES
			MIN5_LED_SET;
			MIN1_LED_CLEAR;
			MIN2_LED_CLEAR;
			MIN10_LED_CLEAR;
			MIN15_LED_CLEAR;
		break;
		case 4:
			gTreatmentTimeSelectedInSecs = 600;		//10MINUTES
			MIN10_LED_SET;
			MIN1_LED_CLEAR;
			MIN2_LED_CLEAR;
			MIN5_LED_CLEAR;
			MIN15_LED_CLEAR;
		break;
		case 5:
			gTreatmentTimeSelectedInSecs = 900;		//15MINUTES
			MIN10_LED_CLEAR;
			MIN1_LED_CLEAR;
			MIN2_LED_CLEAR;
			MIN5_LED_CLEAR;
			MIN15_LED_SET;
		break;
		default:
		break;
	}
	gTempTreatmentTimeInSecs = gTreatmentTimeSelectedInSecs;
	return;
}

void gTimeSelectionLedClear(void)
{
	MIN1_LED_CLEAR;
	MIN2_LED_CLEAR;
	MIN5_LED_CLEAR;
	MIN10_LED_CLEAR;
	MIN15_LED_CLEAR;
	return;
}

/******************************************************************************
 ***						End of routinues								***
 *****************************************************************************/