//#######################################################################################################################
//#
//#	ФУНКЦИИ РАБОТЫ С ДИСПЛЕЕМ И КЛАВИАТУРОЙ
//#
//#######################################################################################################################

//----------------------------------------------------------------------------------------------
//ФУНКЦИЯ ВЫВОДА СИМВОЛА В СТРОКУ
//АРГУМЕНТ 1 - код символа
//АРГУМЕНТ 2 - знакоместо (0 - левый невидимый символ, 1-8 - видимые символы, 9 - правый невидимый символ)
//невидимые символы справа и слева, предназначены для организации плавной прокрутки строки
void LedBoardSimbPrint (unsigned char simbol, unsigned char position)
{
	if (position > (LedBoardSize+1))
		return;

	char* pPosition = position * LedBoardSimbWidth + LedBoardBuffer;//указатель на первый байт символа в бегущей строке

	if (simbol < 0x20)
		simbol = 0x20;
	if (simbol >= 0xc0)
		simbol -= 0x40;
	char *pSimbol = (simbol - 0x20) * FontSimbWidth + SimbMass;		//указатель на первый байт символа в массиве фонта
		
	for (char i=0; i<FontSimbWidth; i++)							//печать символа
		*pPosition++ = pgm_read_byte (pSimbol++);
	for (char i=0; i<(LedBoardSimbWidth-FontSimbWidth); i++)		//разделитель между символами
		*pPosition++ = 0;
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ВЫВОДА СТАТИЧНОГО СООБЩЕНИЯ НА ДИСПЛЕЙ
//АРГУМЕНТ - указатель на текстовый массив в PROGMEM
void LedBoardMessageShow (char *pAdrTxt)
{
	unsigned char position = 1;
	while (1){
		if (position > LedBoardSize)
			return;											//дошли до конца дисплея	
		char byte = pgm_read_byte (pAdrTxt++);
		if (! byte)
			return;											//дошли до конца строки
		LedBoardSimbPrint (byte, position++);				//печать символа
	} 
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ВЫВОДА БЕГУЩЕГО СООБЩЕНИЯ НА ДИСПЛЕЙ (в режиме бегущей влево строки)
//АРГУМЕНТ - указатель на текстовый массив в PROGMEM
void LedBoardMessageScrollLeft (char *pAdrTxt)
{
	while (1){
		char byte = pgm_read_byte (pAdrTxt++);
		if (! byte)											//проверка на конец строки
			return;

		LedBoardSimbPrint (byte, LedBoardSize+1);			//напечатать в позиции за экраном

		for (char i=0; i<LedBoardSimbWidth; i++)			//сдвинуть на ширину символа
			LedBoard1PixScrollLeft ();	
	}
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ОЧИСТКИ БЕГУЩЕЙ СТРОКИ - СДВИГОМ В ЛЕВО 
void LedBoardClearScrollLeft (void)
{
	LedBoardSimbPrint (' ', LedBoardSize+1);
	unsigned char Length = LedBoardSize * LedBoardSimbWidth;//участок очистки в пикселях
	for (char i=0; i<Length; i++)
		LedBoard1PixScrollLeft ();	
}


//ФУНКЦИЯ СДВИГА ДИСПЛЕЯ ВЛЕВО на 1 пиксель, с обработкой скорости смещения
void LedBoard1PixScrollLeft (void)
{
	unsigned char speed = 100/LedBoardHorScrollSpeed;			//скорость перемещения строки (1-100 точек\сек)	
	for (char z=0; z<speed; z++){	
		while (! (Flags1 & b1LedBoardPageCompleted)){}			//дождаться завершения отрисовки кадра
		Flags1 &= ~b1LedBoardPageCompleted;						//сбросить флаг
	}

	char* pLineBuf1 = LedBoardBuffer+LedBoardSimbWidth;			//указатели на начало первого символа
	char* pLineBuf2 = LedBoardBuffer+LedBoardSimbWidth+1;		//следующий байт
	unsigned char Length = (LedBoardSize+1)*LedBoardSimbWidth-1;//размер смещаемой области
	for (char z=0; z<Length; z++)								//цикл сдвига байтов буфера дисплея
		*pLineBuf1++ = *pLineBuf2++;
	*pLineBuf1 = 0;

	if (ClockPosition)											//сдвинуть позицию часов (если задействованы)
		ClockPosition--;
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ОЧИСТКИ СДВИГОМ ДИСПЛЕЯ ВНИЗ
void LedBoardClearScrollDown (void)
{
	ClockPosition = 0;											//отключить покадровую прорисовку часов (если были задействованы)
	unsigned char speed = 100/LedBoardVertScrollSpeed;			//скорость перемещения строки (1-100 точек\сек)	
	for (char i=0; i<8; i++){
		for (char z=0; z<speed; z++){	
			while (! (Flags1 & b1LedBoardPageCompleted)){}		//дождаться завершения отрисовки кадра
			Flags1 &= ~b1LedBoardPageCompleted;					//сбросить флаг
		}
		
		char* pBufPtr = LedBoardBuffer+LedBoardSimbWidth;		//указатель на начало первого символа
		unsigned char Length = LedBoardSize*LedBoardSimbWidth;	//размер смещаемой области
	
		for (char z=0; z<Length; z++){
			char temp = *pBufPtr;
			temp >>= 1;
			*pBufPtr++ = temp;
		}
	}
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ВЫВОДА ДАННЫХ ТЕМПЕРАТУРЫ НА ДИСПЛЕЙ
//АРГУМЕНТ 1 - позиция вывода данных температуры на дисплей (0- с лева от видимой части экрана, 1-8 видимый экран, 9- справа экрана)
//АРГУМЕНТ 2 - номер датчика показания которого выводятся (0,1)

char TxtError	[] PROGMEM = "   ERROR";

void LedBoardTermoShow (char Position, uint8_t NumDev)
{
	if (OneWireErr & (1<<NumDev))
		LedBoardMessageShow (TxtError);							//ошибка чтения соответствующего датчика
	else{
		LedBoardSimbPrint (' ', Position);						//вывести значение температуры
		LedBoardIntPrint(OneWireTermoData[NumDev],Position+1, 5, 1);
		if ((Position+6) <= (LedBoardSize+1))
			LedBoardSimbPrint ('`', Position+6);
		if ((Position+7) <= (LedBoardSize+1))
			LedBoardSimbPrint ('C', Position+7);
	}
}


//ФУНКЦИЯ ВЫВОДА ДАННЫХ ТЕМПЕРАТУРЫ НА ДИСПЛЕЙ СО CДВИГОМ ВЛЕВО
//АРГУМЕНТ - номер датчика показания которого выводятся (0,1)
void LedBoardTermoScrollLeft (uint8_t NumDev)
{
	if (OneWireErr & (1<<NumDev))
		LedBoardMessageScrollLeft (TxtError);					//ошибка чтения соответствующего датчика
	else{
		for (char i=9; i>1; i--){								//вывести значение температуры со сдвигом влево
			LedBoardTermoShow (i, NumDev);						
			for (char x=0; x<LedBoardSimbWidth; x++)			//сдвинуть на ширину символа
				LedBoard1PixScrollLeft ();	
		}
	}
}


//----------------------------------------------------------------------------------------------
//ФУНКЦИЯ ВЫВОДА ВРЕМЕНИ В СТРОКУ LedBoard
//АРГУМЕНТ 1 - позиция первого символа в строке (1-9)
void LedBoardClockShow (uint8_t Position)
{
	if ((Position > 0) && (Position <= LedBoardSize+1))
		ClockPosition = (Position +7) * LedBoardSimbWidth;
}


//----------------------------------------------------------------------------------------------
//ФУНКЦИЯ ВЫВОДА ВРЕМЕНИ В СТРОКУ СДВИГОМ ВЛЕВО
void LedBoardClockScrollLeft (void)
{
	LedBoardClockShow (9);
	LedBoardClearScrollLeft ();
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ОЖИДАНИЯ X СЕК
//АРГУМЕНТ - количество секунд ожидания
NOINLINE void Delay (unsigned char second)
{
	for (unsigned char i=0; i<second; i++)		//цикл по количеству секунд	
		_delay_ms (1000);
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ПЕЧАТИ 16-ти битного ЧИСЛА на LcdBoard (в т.ч. отрицательные и с десятичной точкой)
//АРГУМЕНТ 1 - 16-ти битное число
//АРГУМЕНТ 2 - первое знакоместо выводимого числа в LcdBoard (0-слева от экрана, 1-8-основной экран, 9-справа от экрана)  
//АРГУМЕНТ 3 - длина числа (1-8)  (исп-ся для гарантированной очистки прошлого значения)
//АРГУМЕНТ 4 - позиция точки внутри числа (0-нет точки, 1-один знак после точки, 2-два знака, и.т.д.)

void LedBoardIntPrint (signed int integer, uint8_t IntPos, uint8_t IntLength, uint8_t DotPosition)
{												
	char IntBuf [IntLength];					//буфер для формируемого числа
	char* pIntBuf = IntBuf+IntLength-1; 		//указатель на буфер
	uint8_t DigitCoun = 0;						//счетчик напечатанных символов

	uint8_t negative = 0;						//подготовка отрицательного числа
	if (integer < 0){							
		integer ^= 0xffff;
		integer++;
		negative = 1;									
	}

	for (uint8_t i=0; i<IntLength; i++){		//выводим цифры в цикле
		*pIntBuf-- = integer %10+0x30;			//печатаем младшую цифру
		integer /= 10;							//деление на 10
		DigitCoun ++;
		if (! integer)
			break;
	}
			
	if (DotPosition){							//если задана точка - обработать
		while (DotPosition > DigitCoun){		//допечатываем недостающие нули
			*pIntBuf-- = 0x30;				
			DigitCoun++;
		}
												
		if (DotPosition == DigitCoun){			//впечатываем точку с нулем перед точкой
			*pIntBuf-- = '.'; 
			*pIntBuf-- = 0x30;	
			DigitCoun += 2;
			goto m1;
		} 
		
		// if (DotPos < DigitCoun) 				//сдвигаем левую часть числа влево, чтобы вставить точку
		char *pMoveCntr = pIntBuf--;			//указатель для переноса разрядов для вставки разделительной точки
		char MoveVal = DigitCoun-DotPosition;	//кол-во знаков для переноса
		for (char i=0; i<MoveVal; i++){
			char temp = *(pMoveCntr+1);
			*pMoveCntr++ = temp;
		}

		*pMoveCntr = '.';						//вставить точку
		DigitCoun++;
	}

m1:	if (negative){								//если число было отрицательным, дописать "-"
		*pIntBuf-- = '-'; 
		DigitCoun++;
	}

	while (DigitCoun++ < IntLength)				//если число короче чем поле для вывода - очищаем символы перед числом
		*pIntBuf-- = 0x20;

	for (uint8_t i=0; i<IntLength; i++){		//вывод буфера с содержимым числа - на дисплей 
		if ((IntPos+i) <= (LedBoardSize+1))
			LedBoardSimbPrint (IntBuf [i], IntPos+i);
	}
}


//#######################################################################################################################
//#
//#	ФУНКЦИИ РАБОТЫ С 1WIRE
//#
//#######################################################################################################################

//ФУНКЦИЯ СБРОСА УСТРОЙСТВ НА ЛИНИИ ПО 1WIRE
//АРГУМЕНТ - маска линии устройства
void OneWireReset (char mask)
{
	OneWireDDR |= (mask);						//старт импульса сброса
	_delay_us (480);

	OneWireDDR &= ~(mask);						//конец импульса сброса
	_delay_us (480); 
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ БАЙТОВОГО ОБМЕНА ПО 1WIRE
//АРГУМЕНТ 1 - передаваемый байт данных
//АРГУМЕНТ 2 - маска линии устройства
//ЗНАЧЕНИЕ - принятый байт данных 
//прием и передача происходят в одной ф-ции (если нужно принять байт данных, аргумент должен быть 0xff)

unsigned char OneWireData (unsigned char OutByte, char mask)
{
	char InByte =0;								//в цикле задвигаются принятые биты

	for (unsigned char i = 0; i<8; i++){
		//прием\передача бита по 1wire
		InByte >>= 1;
		cli ();
		OneWireDDR |= mask;						//прижать линию
		if (OutByte & 0x01){
			//передаем 1
			_delay_us (5);				
			OneWireDDR &= ~mask;				//отпустить линию
			_delay_us (5);
	
			if (OneWirePIN & mask)				//читаем бит от 1wire устройства
				InByte |= 0x80;					//принятый бит = 1
			sei ();

			_delay_us (70);
		}
		else{
			//передаем 0
			_delay_us (75);				
			OneWireDDR &= ~mask;				//отпустить линию
			sei ();
			_delay_us (5);
		}

		OutByte >>= 1;
	}
	CheckSumm (InByte);							//подсчет контрольной суммы
	return InByte;
}


//-----------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ ПОДСЧЕТА КОНТРОЛЬНОЙ СУММЫ
//АРГУМЕНТ - байт участвующий в формировании контрольной суммы
//OneWireCheckSumm - глобальная переменная контрольной суммы
//в начале обмена необходимо обнулить переменную
//по завершении обмена в переменной должно быть 0
void CheckSumm(char data)
{
	for (char i=0; i<8; i++){
		char temp = data;
		temp ^= OneWireCheckSumm;

		if (temp & 0x01){
			OneWireCheckSumm ^= 0x18;
			temp = 0x80;
		}
		else
			temp = 0;

		OneWireCheckSumm >>= 1;
		OneWireCheckSumm |= temp;
		data >>= 1;
	}
}


//#######################################################################################################################
//#
//#	ФУНКЦИИ РАБОТЫ С ЧАСАМИ DS1307
//#
//#######################################################################################################################

//ФУНКЦИЯ ЧТЕНИЯ БЛОКА ДАННЫХ ИЗ МИКРОСХЕМЫ ЧАСОВ DS1307
//чтение происходит в глобальный массив ClockData[7]
//последовательность данных - [0]секунды, [1]минуты, [2]часы, [3]день, [4]дата, [5]месяц, [6]год
void IICClockReadData (void)
{
	IICStart();
	IICByteWrite (0xD0);						//запись данных в DS1307
	IICByteWrite (0x00);						//сбросить указатель адреса DS1307 на 0 

	IICStart();
	IICByteWrite (0xD1);						//команда на чтение данных

	char temp;									//временный байт для чтения данных часов
	char Accumulate = 0;						//байт для формирования маски изменившихся разрядов
	char NumBit = (1<<0);						//плавающий бит для накладывания на маску 
	char* pClockData = ClockData;				//указатель на данные часов

	for (char i = 0; i<6; i++){					//в цикле читаем данные часов
		temp = IICByteRead (0);					//читаем, секунды, минуты, часы, день, дата, месяц (с выдачей подтверждения (0))

		if (i == 0){							//во время чтения секунд, проверить изменились ли секунды
			if (temp != *pClockData){	
				Flags1 |= b1ClockChange;		//отметить флаг об изменения данных времени
				ClockMiliSecond = 0;			//обнулить милисекунды		
			}
		}

		if (i < 3){								//обработка флагов изменившихся разрядов часов
			if ((temp & 0x0F) != (*pClockData & 0x0F))//единицы секунд, минут и часов
				Accumulate |= NumBit;
			NumBit <<= 1;
			if ((temp & 0xF0) != (*pClockData & 0xF0))//десятки секунд, минут и часов
				Accumulate |= NumBit;
			NumBit <<= 1;
		}

		*pClockData++ = temp;					//сохраняем - минуты, часы, день, дата, месяц
	}
	*pClockData = IICByteRead (1);				//пишем год (без подтверждения)
	IICStop(); 

	ClockChangeMask |= Accumulate;				//добавляем флаги обновленных цифр
}


//ФУНКЦИЯ ЗАПИСИ БЛОКА ДАННЫХ В МИКРОСХЕМУ ЧАСОВ DS1307
//запись происходит из глобального массива ClockData[7]
//последовательность данных - [0]секунды, [1]минуты, [2]часы, [3]день, [4]дата, [5]месяц, [6]год
void IICClockWriteData (void)
{
	IICStart();
	IICByteWrite (0xD0);					//запись данных в DS1307
	IICByteWrite (0x00);					//сбросить указатель адреса DS1307 на 0 

	for (unsigned char i = 0; i<7; i++)
		IICByteWrite (ClockData [i]);		//пишем, секунды, минуты, часы, день, дата, месяц, год

	IICStop();
}


//ФУНКЦИЯ ПРЕОБРАЗОВАНИЯ ДВОИЧНО\ДЕСЯТИЧНОГО ЧИСЛА В ШЕСТНАДЦАТЕРИЧНОЕ
//АРГУМЕНТ - двоично-десятичное число
//ЗНАЧЕНИЕ - шестнадцатеричное число
char ConvBinDecToHex (char byte)
{				
	char result = 10 * (byte >> 4);
	result += (byte & 0x0f);
	return result; 
}


//ФУНКЦИЯ ПРЕОБРАЗОВАНИЯ ШЕСТНАДЦАТЕРИЧНОГО ЧИСЛА В ДВОИЧНО\ДЕСЯТИЧНОЕ
//АРГУМЕНТ - шестнадцатеричное число
//ЗНАЧЕНИЕ - двоично-десятичное число
char ConvHexToBinDec (char byte){
	char result = byte %10;
	result |= ((byte/10) << 4);
	return result; 
}


//#######################################################################################################################
//#
//# ФУНКЦИИ ОБСЛУЖИВАНИЯ ИНТЕРФЕЙСА I2C (софтовый вариант)
//#
//#######################################################################################################################

//задержка 2 микросекунды для формированя временных задержек IIC
NOINLINE void Delay2Mks (void)
{
	_delay_us (2);
}


//ФУНКЦИЯ ФОРМИРОВАНИЯ СОСТОЯНИЯ START ПО ИНТЕРФЕЙСУ IIC
void IICStart (void)
{
	IICDDR &= ~(IICData | IICClc);
	Delay2Mks();

	IICDDR |= IICData;							//подтяжка data к нулю
	Delay2Mks();

	IICDDR |= IICClc;							//подтяжка clc к нулю
	Delay2Mks();			
}


//ФУНКЦИЯ ФОРМИРОВАНИЯ СОСТОЯНИЯ STOP ПО ИНТЕРФЕЙСУ IIC
void IICStop (void)
{
	IICDDR |= (IICData | IICClc);
	Delay2Mks();

	IICDDR &= ~IICClc;							//подтяжка data к нулю
	Delay2Mks();

	IICDDR &= ~IICData;							//подтяжка clc к нулю
	Delay2Mks();			
}


//ФУНКЦИЯ ЗАПИСИ БАЙТА ПО ИНТЕРФЕЙСУ IIC
//АРГУМЕНТ - байт данных для вывода по IIC
//ЗНАЧЕНИЕ - флаг подтверждения 0 (есть подтверждение) или 1 (нет подтверждения) 
char IICByteWrite (char byte)
{
	for (char i = 0; i<8; i++)
		byte = IICBit (byte);

	byte = 0x80;								
	return IICBit (byte);						//возвращаем бит подтверждения (0-есть бит подтверждения, 1-нет)
}


//ФУНКЦИЯ ЧТЕНИЯ БАЙТА ПО ИНТЕРФЕЙСУ IIC
//АРГУМЕНТ - значение бита подтверждения (0 - есть подтверждение, 1 - нет подтверждения)
//ЗНАЧЕНИЕ - принятый байт
char IICByteRead (char bit)
{
	char byte = 0xFF;
	for (char i = 0; i<8; i++)
		byte = IICBit (byte);

	bit <<= 7;
	IICBit (bit);								//передать значение бита подтверждения
	return byte;								//возвращаем принятый байт
}


//ФУНКЦИЯ ЗАПИСИ\ЧТЕНИЯ БИТА ПО ИНТЕРФЕЙСУ IIC
//выводится значение старшего бита аргумента
//принятый бит возвращается в младшем бите предварительно сдвинутого влево аргумента
char IICBit (char byte)						
{
	if (byte & 0x80)						//выводимый бит
		IICDDR &= ~IICData; 				//вывод 1 на линию данных
	else 
		IICDDR |= IICData;					//вывод 0 на линию данных
	Delay2Mks();

	IICDDR &= ~IICClc;						//старт строб импульса
	while (! (IICPIN & IICClc)){}			//ожидание формирования строба
	Delay2Mks();

	char temp;	
	if (IICPIN & IICData)					//принимаем бит
		temp = 1;
	else
		temp = 0;
	IICDDR |= IICClc;						//завершить строб

	byte <<= 1;
	byte |= temp;
	return byte;
}
//-------------------------------------------------- menu
// ha hosszan (2 sec) nyomjuk a fel gombot, akkor belйp a menьbe, az уra mуdosнtбsba
// ha itt a fel-le gombokat nyomkodjuk akkor nх csцkken az уra йs ez remйlhetхleg lбtszik is a kijelzхn
//ha a jobb gombot nyomjuk, akkor a perceket lehet a fel-le gombokkal vбltoztatni, ha a bal gombot, akkor a mбsodpercet lehet nullбzni a fel-le gombokkal
// a menubхl a jobb gomb hosszъ nyomvatartбsбval lehet kilйpni
//Sajnos azt nem lehet lбtni, hogy йppen melyik adatot lehet vбltoztatni, illetve azt sem, hogy benne vagyunk-e a menьben
//Ha nem lйpьnk be a menьbe, akkor a bal gomb rцvid megnyomбsбra megjelenнti a 3. szцveget TxtTitle2

// a menuhцz vбltozуk йs a kуd
unsigned sec,min,hour,wday,day,month,year;

typedef enum 
{
NORMAL=0,
HOUR,
MIN,
SEC
} STATE;

STATE state=NORMAL;

void time_to_rtc()
{
ClockData[0] = sec / 10 * 16 + sec % 10;
ClockData[1] = min / 10 * 16 + min % 10;
ClockData[2] = hour / 10 * 16 + hour % 10;
//ClockData[3] = wday & 7;
//ClockData[4] = mday / 10 * 16 + mday % 10;
//ClockData[5] = month / 10 * 16 + month % 10;
//ClockData[6] = year/ 10 * 16 + (year % 10);
}

void rtc_to_time()
{
sec=(ClockData[0]&0x0f)+((ClockData[0] >> 4) & 7) * 10;
min = (ClockData[1] & 0x0F) + (ClockData[1] >> 4) * 10;
hour = (ClockData[2] & 0x0F) + ((ClockData[2] >> 4) & 3) * 10;
wday = (ClockData[3] & 0x07);
day = (ClockData[4] & 0x0F) + ((ClockData[4] >> 4) & 3) * 10;
month = (ClockData[5] & 0x0F) + ((ClockData[5] >> 4) & 1) * 10;
year = (ClockData[6] & 0x0F) + (ClockData[6] >> 4) * 10;
}


extern char TxtTitle2	[] PROGMEM;
void menu()
{

char BtnMask = BtnFlags;
BtnFlags =0;
unsigned char rtc_flag;

switch(state)
{
case NORMAL :
{
if (BtnMask == LongUp)
{
state=HOUR;
} else
{
if(BtnMask == ShortLeft)
{	
LedBoardClearScrollDown ();
LedBoardMessageScrollLeft (TxtTitle2);
LedBoardClearScrollLeft ();
LedBoardClockScrollLeft ();
}
rtc_flag=Flags1;
if(rtc_flag & b1ClockChange)
{
sec=(ClockData[0]&0x0f)+((ClockData[0] >> 4) & 7) * 10;
if(sec == 10)
{
LedBoardMessageScrollLeft (benti);
LedBoardTermoScrollLeft (0);
Delay (2);
LedBoardClearScrollDown ();
LedBoardClockScrollLeft ();
}	
if(sec == 25)
{
LedBoardMessageScrollLeft (kinti);
LedBoardTermoScrollLeft (1);
Delay (2);
LedBoardClearScrollDown ();
LedBoardClockScrollLeft ();
}	
}
}
break;	
}
case HOUR :
{
if(BtnMask == ShortUp)
{
rtc_to_time();
hour++;
if(hour == 24) hour=0;
time_to_rtc();
IICClockWriteData();
}
if(BtnMask == ShortDown)
{
rtc_to_time();
hour--;
if(hour == 0) hour=23;
time_to_rtc();
IICClockWriteData();
}
if(BtnMask == ShortRight)
{
state=MIN;
}
if(BtnMask == ShortLeft)
{
state=SEC;
}
if (BtnMask == LongRight)
{	
state=NORMAL;
}
break;
}
case MIN :
{
if(BtnMask == ShortUp)
{
rtc_to_time();
min++;
if(min == 59) hour=0;
time_to_rtc();
IICClockWriteData();
}
if(BtnMask == ShortDown)
{
min--;
if(hour == 0) min=23;
time_to_rtc();
IICClockWriteData();
}
if(BtnMask == ShortRight)
{
state=SEC;
}
if(BtnMask == ShortLeft)
{
state=HOUR;
}
if (BtnMask == LongRight)
{	
state=NORMAL;
}
break;
}
case SEC :
{
if((BtnMask == ShortUp) || (BtnMask == ShortUp))
{
sec=0;
time_to_rtc();
IICClockWriteData();
}	
if(BtnMask == ShortRight)
{
state=HOUR;
}
if(BtnMask == ShortLeft)
{
state=HOUR;
}
if (BtnMask == LongRight)
{	
state=NORMAL;
}
break;
}
}
}

//#######################################################################################################################
//#
//# end
//#
//#######################################################################################################################
