class Leds : public DriverObject
{
public:
	virtual int Init (void *pParam, int countParam) {return 0;};
private:
	typedef enum {ZERO, ONE} STATE;	
	// functions for setup cathode lines
	void L1(STATE state){if (state==ZERO) PORTA &= ~(1 << 0); else PORTA |= (1 << 0);}
	void L2 (STATE state) {if (state==ZERO) PORTA &= ~(1 << 1); else PORTA |= (1 << 1);}
	void L3 (STATE state) {if (state==ZERO) PORTA &= ~(1 << 2); else PORTA |= (1 << 2);}
	void L4 (STATE state) {if (state==ZERO) PORTA &= ~(1 << 3); else PORTA |= (1 << 3);}
	void L5 (STATE state) {if (state==ZERO) PORTA &= ~(1 << 4); else PORTA |= (1 << 4);}
	void L6 (STATE state) {if (state==ZERO) PORTA &= ~(1 << 5); else PORTA |= (1 << 5);}
	void L7 (STATE state) {if (state==ZERO) PORTA &= ~(1 << 6); else PORTA |= (1 << 6);}
	void L8 (STATE state) {if (state==ZERO) PORTA &= ~(1 << 7); else PORTA |= (1 << 7);}
	void L9 (STATE state) {if (state==ZERO) PORTC &= ~(1 << 0); else PORTC |= (1 << 0);}
	//
	// functions for setup drive lines
	void VX1(STATE state){if (state==ZERO) PORTC &= ~(1 << 3); else PORTC |= (1 << 3);}
	void VX2(STATE state){if (state==ZERO) PORTC &= ~(1 << 4); else PORTC |= (1 << 4);}	
	void VX3(STATE state){if (state==ZERO) PORTC &= ~(1 << 5); else PORTC |= (1 << 5);}	
	void VX4(STATE state){if (state==ZERO) PORTC &= ~(1 << 6); else PORTC |= (1 << 6);}	
	void VX5(STATE state){if (state==ZERO) PORTC &= ~(1 << 7); else PORTC |= (1 << 7);}	

	typedef void (Leds::*pToDriveFoo) (STATE state);	
	static pToDriveFoo driveLines[];
	static pToDriveFoo cathodeLines[];
public:
	typedef enum {RED, GREEN, YELLOW, OFF} COLOR;
	//
	typedef enum {A_SDI, A_EDH, A_MOTION, A_DIFF_LEVEL, A_AUDIO, A_AUDIO1, A_AUDIO2, A_AUDIO3, A_AUDIO4,
		B_SDI, B_EDH, B_MOTION, B_DIFF_LEVEL, B_AUDIO, B_AUDIO1, B_AUDIO2, B_AUDIO3, B_AUDIO4, MON_A,
		MON_B, MON_MAIN, MON_STANDBY, NET, GPY, 
		BTN_A, BTN_AUTO, BTN_B} LEDS;
	//
private:
	typedef struct
	{
		void (Leds::*pToDriveFoo) (STATE state);	
		void (Leds::*pToCathodeFoo) (STATE state);		
		LEDS led_name;
		COLOR color;
		STATE m_state;
	} LEDS_INFO;

// cpp
unsigned char Leds::m_currentCicle = 0;
Leds::pToDriveFoo Leds::driveLines[] =  {&Leds::VX1,
																&Leds::VX2,
																&Leds::VX3,
																&Leds::VX4,
																&Leds::VX5,
	};

Leds::pToDriveFoo Leds::cathodeLines[] =  {&Leds::L1,
																&Leds::L2,
																&Leds::L3,
																&Leds::L4,
																&Leds::L5,
																&Leds::L6,
																&Leds::L7,
																&Leds::L8,
																&Leds::L9,
};


Leds::LEDS_INFO Leds::leds_info[]=
{
	{&VX1, &L1, A_SDI, GREEN, ZERO},
	{&VX2, &L1, A_SDI, RED, ZERO},

	{&VX1, &L2, A_EDH, GREEN, ZERO},
	{&VX2, &L2, A_EDH, RED, ZERO},

	{&VX1, &L3, A_MOTION, GREEN, ZERO},
	{&VX2, &L3, A_MOTION, RED, ZERO},

	{&VX1, &L4, A_DIFF_LEVEL, GREEN, ZERO},
	{&VX2, &L4, A_DIFF_LEVEL, RED, ZERO},

	{&VX1, &L5, A_AUDIO, GREEN, ZERO},
	{&VX2, &L5, A_AUDIO, RED, ZERO},

	{&VX1, &L6, A_AUDIO1, GREEN, ZERO},
	{&VX2, &L6, A_AUDIO1, RED, ZERO},

	{&VX1, &L7, A_AUDIO2, GREEN, ZERO},
	{&VX2, &L7, A_AUDIO2, RED, ZERO},

	{&VX1, &L8, A_AUDIO3, GREEN, ZERO},
	{&VX2, &L8, A_AUDIO3, RED, ZERO},

	{&VX1, &L9, A_AUDIO4, GREEN, ZERO},
	{&VX2, &L9, A_AUDIO4, RED, ZERO},
//
	{&VX3, &L1, B_SDI, GREEN, ZERO},
	{&VX4, &L1, B_SDI, RED, ZERO},

	{&VX3, &L2, B_EDH, GREEN, ZERO},
	{&VX4, &L2, B_EDH, RED, ZERO},

	{&VX3, &L3, B_MOTION, GREEN, ZERO},
	{&VX4, &L3, B_MOTION, RED, ZERO},

	{&VX3, &L4, B_DIFF_LEVEL, GREEN, ZERO},
	{&VX4, &L4, B_DIFF_LEVEL, RED, ZERO},

	{&VX3, &L5, B_AUDIO, GREEN, ZERO},
	{&VX4, &L5, B_AUDIO, RED, ZERO},

	{&VX3, &L6, B_AUDIO1, GREEN, ZERO},
	{&VX4, &L6, B_AUDIO1, RED, ZERO},

	{&VX3, &L7, B_AUDIO2, GREEN, ZERO},
	{&VX4, &L7, B_AUDIO2, RED, ZERO},

	{&VX3, &L8, B_AUDIO3, GREEN, ZERO},
	{&VX4, &L8, B_AUDIO3, RED, ZERO},

	{&VX3, &L9, B_AUDIO4, GREEN, ZERO},
	{&VX4, &L9, B_AUDIO4, RED, ZERO},
//
	{&VX5, &L1, MON_A, GREEN, ZERO},

	{&VX5, &L2, MON_B, GREEN, ZERO},

	{&VX5, &L3, MON_MAIN, GREEN, ZERO},

	{&VX5, &L4, MON_STANDBY, GREEN, ZERO},
//

	{&VX5, &L5, NET, GREEN, ZERO},

	{&VX5, &L6, GPY, GREEN, ZERO},
// BTNS
	{&VX5, &L9, BTN_A, GREEN, ZERO},

	{&VX5, &L8, BTN_AUTO, GREEN, ZERO},

	{&VX5, &L7, BTN_B, GREEN, ZERO},


};
//---------------------------------------------------------------------------------------------
void Leds::Execute()
{
	// first turn off all LEDS
	unsigned char numCathLines = sizeof(cathodeLines) / sizeof (pToDriveFoo);
	unsigned char numDriveLines = sizeof(driveLines) / sizeof (pToDriveFoo);
	for (int i = 0; i < numDriveLines; i++) 
		(this->*driveLines[i])(ONE);
	for (int i = 0; i < numCathLines; i++) 
		(this->*cathodeLines[i])(ONE);

	static unsigned char nCicle = 0;
	// turn on current drive line
	(this->*driveLines[nCicle])(ZERO);
	unsigned char leds_count = sizeof(leds_info)/sizeof(LEDS_INFO);
	for (int i = 0; i < leds_count; i++)
	{
		if (leds_info[i].pToDriveFoo == driveLines[nCicle]) // if LED belongs to current drive line
		{
			if (leds_info[i].m_state == ONE)
				(this->*leds_info[i].pToCathodeFoo)(ZERO);
		}
	}
	nCicle++;
	if (nCicle == numDriveLines) nCicle = 0;
};
//---------------------------------------------------------------------------------------------
void Leds::SetLedState (LEDS led, COLOR color)
{
	unsigned char leds_count = sizeof(leds_info)/sizeof(LEDS_INFO);
	for (int i = 0; i < leds_count; i++)
	{
		if (leds_info[i].led_name == led)
		{
			if (leds_info[i].color == color)
				leds_info[i].m_state = ONE;
			else leds_info[i].m_state = ZERO;
		}
	}
}