OS_PROCESS void TKeyScan::Exec()    //TProc1
{
  for(;;)
  {
      PCInt3.Wait();
    
    Sleep(20);        // Задержка 10*2=20мсек для устранения дребезга контактов
    
    scan_key();
  
    if(key_code.scan & KEY_PRESSED)
    {
      key_code.scan &= ~KEY_PRESSED;   // Clear MSB of scan_code (key_pressed)
    
      switch(key_code.scan)      
      {
         case UP:     //k_right
              CurrentMode->Up();  
              break;
              
         case DOWN:   //k_left
              CurrentMode->Down();
              break;
              
         case LEFT:   //k_esc
              CurrentMode->Left();
              break;
              
         case RIGHT:  //k_enter
              CurrentMode->Right();
              break;
              
         default:     // 0...9
              CurrentMode->Numeric();
              break;
      }
    }
  }
}

if((date>=1)&&(date<=31)&&(month>=1)&&(month<=12)&&(year>=1996)&&(year<=2100))

i2c_write(year-2000);

union _key_code
{
    unsigned int complete;            // Access all 16 bits
    
    struct
    {
    union
    {
        unsigned char flags;        // Access flag status only
            
        struct
        {
        unsigned char altKey0 : 1;    // Access the flags separately
        unsigned char altKey1 : 1;
        unsigned char altKey2 : 1;
        unsigned char altKey3 : 1;
        unsigned char lckKey0 : 1;
        unsigned char lckKey1 : 1;
        unsigned char lckKey2 : 1;
        };
    };
        
    union
    {
        unsigned char scan;            // Access scancode
            
        struct
        {
            unsigned char col : 3;        // Access column of keypress
        unsigned char row : 3;        // Access row of keypress
                
        unsigned char unused : 2;
        };
    };
    };
};
extern volatile union _key_code key_code;   // Scan result structure
extern volatile unsigned char key_altState; // Current alternation flags

/*** Global variables ***/
volatile unsigned char key_altState;            // Holding current alternation flags
volatile union _key_code key_code;                // Scan result structure

// Ports
#define KEYMATRIX_COL_PORT  PORTB        // Command Output Register
#define KEYMATRIX_COL_DDR   DDRB        // Data Direction Register for KeymatrixPort
#define KEYMATRIX_COL_PIN   PINB        // PIN Register for KeymatrixPort

#define KEYMATRIX_ROW_PORT  PORTD        // Command Output Register
#define KEYMATRIX_ROW_DDR   DDRD        // Data Direction Register for KeymatrixPort
#define KEYMATRIX_ROW_PIN   PIND        // PIN Register for KeymatrixPort

// pins PCINT28..31->PCI3
#define ENABLE_PCINT3   {PCIFR |= (1<<PCIF3); PCICR |= (1<<PCIE3);}// Clear interrupt status flag, Enable pin change interrupt PCINT3
#define DISABLE_PCINT3  PCICR &= ~(1<<PCIE3)    // Disable pin change interrupt PCINT3
..........................
void key_Init(void)
{
    /* Init global variables */
    key_altState = 0;        // Clear alternation flags
    key_code.complete = 0;    // Clear scan result

    /* Init ports */
    KEYMATRIX_ROW_DDR &= 0x0f;    // Set row lines to input  
    KEYMATRIX_ROW_PORT |= 0xf0;    // Pull row lines high    
        
    KEYMATRIX_COL_DDR |= 0x0f;  // Set column lines to output  
    KEYMATRIX_COL_PORT &= 0xf0; // Drive all column lines low      
    
    /* Enable external interrupt */
//    PCIFR |= (1<<PCIF3);   //Очистить флаги внешних прерываний
    PCMSK3 = (1<<PCINT31)|(1<<PCINT30)|(1<<PCINT29)|(1<<PCINT28); //Настроить  прерывания на выводах PD4...PD7    
    ENABLE_PCINT3;      // Enable pin change interrupt PCINT3
}

    /* Init ports */
    KEYMATRIX_ROW_DDR &= 0x0f;    // Set row lines to input  
    KEYMATRIX_ROW_PORT |= 0xf0;    // Pull row lines high

//#############################################################################
//  Вычисление скан-кода нажатой кнопки
//_____________________________________________________________________________
void scan_key(void)
{
  TCritSect cs;
  
  /* Local variables */
  unsigned char lineResult;    // Resulting column and row lines
  unsigned char tempScan;    // Temporary scancode


  /* Find row of keypress */
  lineResult = KEYMATRIX_ROW_PIN&0xf0;  // Get row lines    
            
  if(lineResult != 0xf0)    // Any row lines low ?
  {
    /* Invert port directions */
    KEYMATRIX_COL_PORT |= 0x0f;    // Drive all col lines high                      
    KEYMATRIX_COL_DDR &= 0xf0;    // Set col lines to input, already pulled up
                                                
    KEYMATRIX_ROW_PORT &= 0x0f; // Disable pull-up on row lines
    KEYMATRIX_ROW_DDR |= 0xf0;  // Set row lines to output, already driven low        

    tempScan = 0;            // Init temp scan code
        
    while(lineResult & 0x10)    // Loop while row line high
    {
      lineResult >>= 1;            // Next row line into LSB
      tempScan += 8;        // Increment row part of scancode
    }
        
    /* Find col of keypress */
    lineResult = KEYMATRIX_COL_PIN&0x0f;  // Get col lines        

    /* Set original port directions */    
    KEYMATRIX_ROW_PORT |= 0xf0; // Drive all row lines high
    KEYMATRIX_ROW_DDR &= 0x0f;    // Set row lines to input, already pulled up,
                                                  
    KEYMATRIX_COL_PORT &= 0xf0; // Disable pull-up on col lines
    KEYMATRIX_COL_DDR |= 0x0f;  // Set col lines to output, alreay driven low            
        

    if(lineResult != 0x0f)    // Any col lines low ?
    {
      while(lineResult & 0x01)  // Loop while col line high
      {
    lineResult >>= 1;       // Next col line into LSB
    tempScan ++;            // Increment col part of scancode
      }
            
      /* Process scancode */
      tempScan |= KEY_PRESSED;  // Set MSB of scan_code (key pressed)
      key_code.scan = tempScan; // Save scancode

      #ifdef ALTKEYS
          key_processAltKeys(); // Process alternation keys if implemented
      #endif            
    }
    else
      key_code.scan = 0;    // Indicate no keys pressed 0x00
  }
  else
    key_code.scan = 0;            // Indicate no keys pressed 0x00
    
    /* Prepare external interrupt */
    ENABLE_PCINT3;        // Reenable pin change interrupt
}

char __flash characters[4][32] = {        
                   { '1', '2', '3', 0, 0, 0, 0, 0,            // No alternation
                             '4', '5', '6', 0, 0, 0, 0, 0,
                             '7', '8', '9', 0, 0, 0, 0, 0,
                             '.', '0', '#', 0, 0, 0, 0, 0 },

                           { 'a', 'd', 'g', 0,   'а', 'г', 'є', 'ъ',    // First character
                             'j', 'm', 'p', 0,   'и', 'й', 'м', 'ы',
                             's', 'v', 'y', 0,   'п', 'т', 'х', 0,
                             '*', '*', '#', 0,   'ш', 'ю', 0, 0 },

                           { 'b', 'e', 'h', 0,   'б', 'д', 'ж', 0,    // Second character
                             'k', 'n', 'q', 0,   'і', 'к', 'н', 0,
                             't', 'w', 'z', 0,   'р', 'у', 'ц', 0,
                             '*', '?', '#', 0,   'щ', 'я', 0, 0 },

                           { 'c', 'f', 'i', 0,   'в', 'е', 'з', 0,    // Third character
                             'l', 'o', 'r', 0,   'ї', 'л', 'о', 0,
                             'u', 'x', '-', 0,   'с', 'ф', 'ч', 0,
                             '*', '!', '#', 0,   'ь', 0, 0, 0 }
                         };

/*** Convert scancode to character ***/
char convertKey(void)
{
  char tempChar;

    if(key_code.altKey0)                // First char ?
        tempChar = characters[1][key_code.scan+4];
    else
        if(key_code.altKey1)                    // Second char ?
       tempChar = characters[2][key_code.scan+4];
    else
            if(key_code.altKey2)            // Third char ?
           tempChar = characters[3][key_code.scan+4];
        else                            // No alternation ?
            tempChar = characters[0][key_code.scan];

    if(key_code.altKey3)                // Uppercase if caps lock
        tempChar = toupper(tempChar);
    
    return tempChar;
}

#ifdef ALTKEYS

void key_processAltKeys()
{
    if     (flags & ALTKEY0) flags ^= ALTKEY0;  
    else if(flags & ALTKEY1) flags ^= ALTKEY1;  
    else if(flags & ALTKEY2) flags ^= ALTKEY2;  
    else if(flags & ALTKEY3) flags ^= ALTKEY3;  
}
#endif

if     ( key_code.scan == ALTKEY0 ) key_altState ^= (1<<0);
    else if( key_code.scan == ALTKEY1 ) key_altState ^= (1<<1);
    else if( key_code.scan == ALTKEY2 ) key_altState ^= (1<<2);
    else if( key_code.scan == ALTKEY3 ) key_altState ^= (1<<3);
    else if( key_code.scan == LCKKEY0 ) key_altState ^= (1<<4);
    else if( key_code.scan == LCKKEY1 ) key_altState ^= (1<<5);
    else if( key_code.scan == LCKKEY2 ) key_altState ^= (1<<6);
    else                                        // Not alternation key ?
    {
        key_altState &= ALTLOCKMASK;                // Clear one-shot key flags
    }

// Alternation key code
#define ALTKEY   26            // '#' on test keypad

#define ALT0   0x01    
#define ALT1   0x02            
#define ALT2   0x04            
#define ALT3   0x08

void key_processAltKeys()
{
    if(scan == ALTKEY)  flags ^= ALT0;
}