//#######################################################################################################################
//#######################################################################################################################
//ВКЛЮЧАЕМЫЕ ФАЙЛЫ
#define F_CPU 8000000
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>                   //eeprom_read_byte(), eeprom_write_byte(), eeprom_read_word(), eeprom_write_word()

//ДЕФАЙНЫ
#define CtrlPortOut PORTC                  /*порт светодиода для отладки*/
#define CtrlPortIn PINC
#define CtrlPin (1<<0)                     /*светодиод для отладки*/

#define DisplayType 255                     /*0 - дисплей с OK, 255 - дисплей с OA*/
#define DispDataPort PORTB                  /*порт данных дисплея*/
#define DispStrobePort PORTD               /*порт стробов дисплея*/
#define DispStrb0 (1<<4)                  /*линия строба 0*/
#define DispStrb1 (1<<5)                  /*линия строба 1*/
#define DispStrb2 (1<<6)                  /*линия строба 2*/
#define DispStrb3 (1<<7)                  /*линия строба 3*/

#define BtnPort PINC                     /*порт чтения кнопок*/
#define BtnPin (1<<2)                     /*пин чтения кнопок*/

#define BuzPort   PORTC                     /*порт баззера*/
#define BuzPin   (1<<3)                     /*пин баззера*/

#define LPortOut PORTC                     /*порт записи линии 1,2*/
#define LPortIn   PINC                     /*порт чтения линии 1,2*/
#define LPin1 (1<<0)                     /*пин линии 1*/
#define LPin2 (1<<1)                     /*пин линии 2*/

#define LinePortOut PORTD                  /*порт записи в линии*/
#define LinePinOut (1<<3)                  /*пин записи в линию*/
#define LinePortIn PIND                     /*порт чтения с линии*/
#define LinePinIn (1<<2)                  /*пин чтения с линии*/

//ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
volatile char volatilei;                  /*вставка для борьбы с оптимизацией*/

unsigned char Flags1;                     /*байт флагов №1*/
#define b1DispFlash (1<<0)                  /*бит мигающего режима дисплея*/

unsigned char ButtonFlags;
unsigned char *pButtonFlags = &ButtonFlags;      /*АДРЕС БАЙТА ФЛАГОВ НАЖАТЫХ КЛАВИШ*/
#define ShortLeft   (1<<0)                  /*бит короткого нажатия кнопки вверх*/
#define ShortDown   (1<<1)                  /*бит короткого нажатия кнопки вниз*/
#define ShortRight   (1<<2)                  /*бит короткого нажатия кнопки влево*/
#define ShortUp      (1<<3)                  /*бит короткого нажатия кнопки вправо*/
#define LongLeft   (1<<4)                  /*бит длиного нажатия кнопки вверх*/
#define LongDown   (1<<5)                  /*бит длиного нажатия кнопки вниз*/
#define LongRight   (1<<6)                  /*бит длиного нажатия кнопки влево*/
#define LongUp      (1<<7)                  /*бит длиного нажатия кнопки вправо*/

unsigned char DispFlash;                  /*переменная режима индикатора FLASH (счет 0-99 за секунду)*/

unsigned char DispData [] =    {0,0,0,0};      /*БУФЕР ВЫВОДА ДАННЫХ НА ДИСПЛЕЙ*/
#define BitPoint (1<<3)                     /*бит точки дисплея*/
const unsigned char SimbMass [] =             /*символьный массив (не используются K,M,V,W,X,Z)*/
      {0xf5,0x05,0x73,0x57,0x87,            /*01234*/
      0xd6,0xf6,0x45,0xf7,0xd7,            /*56789*/
      0x00,0xe7,0xb6,0xf0,0x37,            /* ABCD*/
      0xf2,0xe2,0xf4,0xa7,0x05,            /*EFGHI*/
      0x35,0x00,0xb0,0x00,0x26,            /*JKLMN*/
      0x36,0xe3,0xc7,0x22,0xd6,            /*OPQRS*/
      0xb2,0x34,0x00,0x00,0x00,            /*TUVWX*/
      0x97,0x00,0xa0,0x23,0x05,            /*YZ[/]*/
      0x02,0x10};                        /*-_   */   

unsigned char TxtSure [] = {"sure"};                  /*МАССИВ СООБЩЕНИЙ ДЛЯ ВЫВОДА НА ДИСПЛЕЙ*/
unsigned char TxtDone [] = {"done"};
unsigned char TxtStup [] = {"stup"};
unsigned char TxtDflt [] = {"dflt"};
unsigned char TxtRet  [] = {" ret"};
unsigned char TxtSpace[] = {"    "};
unsigned char TxtHallo[] = {"^^^^"};
unsigned char TxtUp   [] = {"  up"};
unsigned char TxtDown [] = {"  dn"};
unsigned char TxtLeft [] = {"left"};
unsigned char TxtRight[] = {"rght"};
unsigned char TxtLU   [] = {"  lu"};
unsigned char TxtLD   [] = {"  ld"};
unsigned char TxtLL   [] = {"  ll"};
unsigned char TxtLR   [] = {"  lr"};


//#define EEDataLen 60                     /*длина буфера данных в EEPROM*/
//unsigned char EEData[EEDataLen] EEMEM;      //массив данных в EEPROM
//unsigned char EEPnt EEMEM;                //указатель на байт массива в EEPROM (0-59)   

//прототипы функций   
void DispFresh (void);
void DispSimbShow (unsigned char, unsigned char);
void DispMessageShow (unsigned char*);
void DispIntShow (unsigned int);
void DispIntEdit (unsigned int*, unsigned int, unsigned int);
void ButtonGet (unsigned char);
unsigned char div (unsigned int* , unsigned int);
unsigned char MenuBtnPressWait (unsigned char*, unsigned char*);
unsigned char BtnPressWait1Sec (void);












































//#######################################################################################################################
//#######################################################################################################################
//Главная функция
int main (void)
{
   DDRB  = 0xff;                        //линии порта на вывод (данные дисплея)
   PORTB = 0;                           //подтяжки нет

   DDRC  = (BuzPin|CtrlPin);               //линия порта на вывод для buzzer
   PORTC = (BtnPin & (~DisplayType));         //подтяжка для кнопки с учетом типа дисплея

   DDRD  = (DispStrb0|DispStrb1|DispStrb2|DispStrb3|LinePinOut); //линий порта на вывод                           
   PORTD = 0;                           //подтяжки нет

   TIMSK = 0x80;                         //режим работы - прерывание по совпадению
   TCCR2 = 0x0e;                        //режим таймера T2 = CTC (0x08 сброс при совпадении)(0x06 предделитель на 256)
   OCR2  = 77;                           //регистр сравнения (сброс таймера счетч по совп)

   sei ();                              //разрешаем глобально прерывания

   unsigned int integer = 500;
   DispMessageShow (TxtHallo);

   while(1)                           //бесконечный цикл   
   {
      //volatilei ++;

      unsigned char BtnValue = BtnPressWait1Sec (); //ждем нажатия кнопки

      if   ( BtnValue == ShortUp)
         DispMessageShow (TxtUp);

      if   ( BtnValue == ShortDown)
         DispMessageShow (TxtDown);

      if   ( BtnValue == LongRight)
      {
         DispIntEdit (&integer, 0, 9999);            
         DispMessageShow (TxtHallo);   
      }
   }
}

//----------
//функция вывода сообщения на дисплей
void DispMessageShow (unsigned char *pAdrTxt)
{
   for (unsigned char position =0; position<4; position++)
      DispSimbShow (*pAdrTxt++,position);
}

//----------
//функция вывода символа на дисплей
//аргумент 1 - символ "0-9,A-Z"
//аргумент 2 - знакоместо (0-3)

void DispSimbShow (unsigned char simbol, unsigned char position)
{
   unsigned char tmp =10;

   if (simbol >= 96)
      simbol -= 32;                     //преобразуем знаки a-z в знаки A-Z
   
   if (simbol < 10)                  
      tmp = simbol;                     //значения 0-9
   
   if ((simbol >= 48)&&(simbol < 58))
      tmp = (simbol -48);                  //символы 0-9
   
   if ((simbol >= 64)&&(simbol < 96))
      tmp = (simbol -64 +10);               //символы A-Z

   DispData[position] = SimbMass[tmp];
}

//----------
//функция вывода на дисплей числа 0-9999

void DispIntShow (unsigned int integer)
{
   unsigned char position = 0;               //позиция печати на дисплее

   if (integer < 1000)
      DispData [position ++] = 0;            //очистить тысячи
   if (integer < 100)
      DispData [position ++] = 0;            //очистить сотни
   if (integer < 10)
      DispData [position ++] = 0;            //очистить десятки

   switch (position)
   {
      case 0: DispSimbShow (div (&integer, 1000), position ++);
      case 1: DispSimbShow (div (&integer, 100), position ++);
      case 2: DispSimbShow (div (&integer, 10), position ++);
      case 3: DispSimbShow (integer, position);
   }
}

//ф-ция деления возвращает результат деления
//аргумент 1 - делимое (указатель)
//аргумент 2 - делитель

unsigned char div (unsigned int *pDivident, unsigned int divisor)
{
   unsigned char result =0;
   while (*pDivident >= divisor)
   {
      *pDivident -= divisor;
      result ++;
   }
   return result;
}

//----------
//функция редактирования числа
//аргумент 1 - указатель на редактируемые данные
//аргумент 2 - максимально возможно нижнее значение
//аргумент 3 - максимально возможное верхнее значение

void DispIntEdit (unsigned int* pInteger, unsigned int IntMin, unsigned int IntMax)
{
   unsigned int IntegerTemp = *pInteger;      //редактируем пока промежуточную IntegerTemp
   
   while (1)
   {
      Flags1 |= b1DispFlash;               //включить режим дисплея - FLASH
      DispIntShow (IntegerTemp);            //вывести значение на дисплей
      unsigned char BtnValue = MenuBtnPressWait (0, 0);//ожидаем нажатия кнопки
      Flags1 &= ~b1DispFlash;               //выключить режим дисплея - FLASH       

      if (BtnValue == LongRight){
         *pInteger = IntegerTemp;         //выход с сохранением данных
         DispMessageShow (TxtDone);
         _delay_ms(1500);
         return;                        
      }

      if ((!BtnValue)||(BtnValue == LongLeft)){
         DispMessageShow (TxtRet);         //выход кнопкой без сохранения и по таймауту
         _delay_ms(1500);   
         return;                        
      }

      if (BtnValue == ShortUp){
         if (IntegerTemp < IntMax)         //увеличить значение
            IntegerTemp ++;
      }

      if (BtnValue == ShortDown){
         if (IntegerTemp > IntMin)         //уменьшить значение
            IntegerTemp --;
      }

      if (BtnValue == LongUp){
         if (IntegerTemp < IntMax)         //увеличить значение
            IntegerTemp ++;
      }

      if (BtnValue == LongDown){
         if (IntegerTemp > IntMin)         //уменьшить значение
            IntegerTemp --;
      }
   }
}

//----------
//функция индикации строк меню, и ожидание нажатия кнопки
//аргумент 1 - строка меню №1 (если 0 - не выводится)
//аргумент 2 - строка меню №2 (если 0 - не выводится)
//значение на выходе - байт маска нажатой кнопки (если 0 - выход по таймауту)

unsigned char MenuBtnPressWait (unsigned char *pMenu1, unsigned char *pMenu2)
{
   #define TimeOut 10                     /*если указанное кол-во секунд, кнопка не нажимается, то выход из ф-ции*/
   unsigned char Button;                  //регистр маски нажатой кнопки

   for (unsigned char i =0; i<(TimeOut/2); i++)         
   {
      if (pMenu1)
         DispMessageShow (pMenu1);         //выводим строку 1
      Button = BtnPressWait1Sec();
      if (Button)
         return Button;                  //кнопка нажата, возвращаем маску кнопок

      if (pMenu2)
         DispMessageShow (pMenu2);         //выводим строку 2
      Button = BtnPressWait1Sec();
      if (Button)
         return Button;                  //кнопка нажата, возвращаем маску кнопок
   }
   return 0;                            //выход по таймауту
}

//----------
//функция ожидания нажатия кнопки в течение 1 сек
//значение на выходе - маска кнопок *pButtonFlags (если timeout, то на выходе 0)
unsigned char BtnPressWait1Sec (void)
{
   for (unsigned char i=0; i<10; i++)         //крутимся 10 раз по 100мс т.е. 1 сек
   {   
      volatilei ++;   
      if (*pButtonFlags)
      {
         unsigned char temp = *pButtonFlags;   //кнопка нажата
         *pButtonFlags = 0;
         return temp;                  //возвращаем маску нажатой кнопки
      }
      _delay_ms(100);
   }
   return 0;                           //секунда закончилась, возвращаем значение 0
}









































//#######################################################################################################################
//#######################################################################################################################
//обработка прерывания (частота вызова 400 Гц)
ISR (TIMER2_COMP_vect)
{
   DispFresh ();                     //динамическое обновление дисплея
}

//----------
//функция динамического отображения данных на 4-х разрядном дисплее.
//
void DispFresh (void)
{
   static unsigned char strobe;            //переменная активного строба дисплея и опроса кнопок (0-3)

   ButtonGet (strobe);                     //ф-ция обработки опроса кнопок (аргумент - номер включенного строба индикатора 0-3)

   if (++ strobe >= 4){                  //инкремент строба знакоместа
      strobe =0;

      //здесь обслуживание переменных с частотой 100Гц
      if (++ DispFlash == 100)            //инкремент счетчика FLASH (за секунду счет 0-99)
         DispFlash = 0;
   }

   if (DisplayType)
   {   //обработка дисплея с ОА
      DispStrobePort &= ~(DispStrb0 |DispStrb1 |DispStrb2 |DispStrb3);//погасить все разряды
      DispDataPort = ~(DispData [strobe]);   //вывод данныx

      if (Flags1 & b1DispFlash){            //проверка включен ли режим FLASH
         if (DispFlash >= 50)
            DispDataPort = DisplayType;      //при счетчике 0-49 индикация данных, 50-99 погасить дисплей
      }

      switch (strobe){                  //включение обновленного знакоместа
         case 0: DispStrobePort |= DispStrb0; break;
         case 1: DispStrobePort |= DispStrb1; break;
         case 2: DispStrobePort |= DispStrb2; break;
         case 3: DispStrobePort |= DispStrb3;
      }
   }
   else
   {   //обработка дисплея с ОК                           
      DispStrobePort |= (DispStrb0 |DispStrb1 |DispStrb2 |DispStrb3);//погасить все разряды
      DispDataPort = DispData [strobe];      //вывод данных

      if (Flags1 & b1DispFlash){            //проверка включен ли режим FLASH
         if (DispFlash >= 50)
            DispDataPort = DisplayType;      //при счетчике 0-49 индикация данных, 50-99 погасить дисплей
      }

      switch (strobe){                  //включение обновленного знакоместа                     
         case 0: DispStrobePort &= ~DispStrb0; break;
         case 1: DispStrobePort &= ~DispStrb1; break;
         case 2: DispStrobePort &= ~DispStrb2; break;
         case 3: DispStrobePort &= ~DispStrb3;
      }
   }   
}

//----------
//ф-ция обработки нажатий клавиш (вызывается с частотой 400 Гц)
//аргумент - номер включенного строба индикатора 0-3 (0 - left, 1 - down, 2 - right, 3 - up)

void ButtonGet (unsigned char strobe)
{
   static unsigned char BtnLockBit;         //ащелка (защита от дребезга)
   static unsigned char BtnLockCoun;         //счетчик защелки (защита от дребезга)
   static unsigned char BtnLongCoun;         //счетчик длинного нажатия
   static unsigned char BtnStack;            //здесь накапливаем за время опроса 4-х стробов, маску нажатых кнопок
   static unsigned char BtnTemp;            //бит последней   нажатой кнопки
   #define BtnLock 30                     /*время обработки дребезга в милисекундах (10-100)*/
   #define BtnLongPress 2000               /*время фиксации длинного нажатия в милисекундах (1000 - 2500)*/

   if (!((BtnPort ^ DisplayType) & BtnPin))   //грубый опрос кнопок во время обработки стробов, с учетом типа индикатора (ОК, ОА)
      BtnStack = (1 << strobe);

   if (strobe <3)   
      return;                           //выход первые 3 строба (обработка данных только после последнего 4-го строба)

   if (BtnStack)
   {                        //клавиша нажата
      BtnTemp = BtnStack;
      BtnStack = 0;
      if (BtnLockCoun < (BtnLock/10)){
         BtnLockCoun++;
         return;
      }
      BtnLockBit=1;                     //нажатие зафиксировано
      if (BtnLongCoun >= (BtnLongPress/10))
         return;
      BtnLongCoun ++;
      if (BtnLongCoun >= (BtnLongPress/10))
         *pButtonFlags |= (BtnTemp << 4);   //установка бита длинного нажатия (старшие 4 бита флагов ButtonByte)
   }      
   else
   {                                 //клавиша отжата         
      if (BtnLockCoun != 0){
         BtnLockCoun --;
         return;
      }
      if (! (BtnLockBit))                  //отжатие зафиксировано
         return;
      BtnLockBit =0;
      if (BtnLongCoun < (BtnLongPress/10)){
         *pButtonFlags |= (BtnTemp);         //установка бита короткого нажатия (младшие 4 бита флагов ButtonByte)
         DispFlash = 0;                  //сбросить на начало цикл FLASH дисплея
      }
      BtnLongCoun = 0;
   }
}

//#######################################################################################################################
//#######################################################################################################################
/*
//индикация светиком
if (*pButtonFlags) CtrlPortOut |= CtrlPin;
else CtrlPortOut &= ~CtrlPin;
*/