Искажается массив структур!

#include "Signal_alarm.h"
 
 
#define STOP 100
#define Led_on  PORTD |=(1<<PIND7)
#define Led_off PORTD &=~(1<<PIND7)
 
volatile bool timer1_trick = false;
volatile uint8_t chanel_adc = 0;
volatile bool adc_go = true;
I_Button_key_type adc_Value;
uint16_t adc_count = 0;
volatile uint8_t adc_count_fake = 0;
volatile bool adc_value_ready = false;
uint8_t chanel_adc_mas[8]{0,0,0,0}; 
uint16_t ADC_sum = 0;   
 
uint8_t value_key_in_EEprom = 0;
 
 
I_Button_1990a my_button(&PORTD,PIND4);
ISR(USART_UDRE_vect)
{
    Usart_tx_handler_txq();
}
ISR(TIMER1_OVF_vect)
{
    timer1_trick = true;
}
ISR(USART_TX_vect)
{
    USART_TX_vect_ready();
    adc_go = true;
    
}
ISR(ADC_vect)
{
    PORTB |=(1<<PINB0);
    PORTB &=~(1<<PINB0);
    if(adc_count_fake>5)
    {
        adc_count++;
        ADC_sum += ADC>>2 ; 
        //adc_Value.key_code[adc_count-1] = ADC>>2;//
    
        if(adc_count >= 16)//8
        {
            adc_stop();
            adc_count_fake = 0;
            
            adc_count = 0;
            adc_value_ready = true;
            
            
            adc_Value.key_code[chanel_adc] =ADC_sum>>4;// //3 ADC_sum/8 
            ADC_sum = 0;
 
            adc_Value.read_Ok = chanel_adc;
            chanel_adc++;
            if(chanel_adc>=4)chanel_adc = 0;
            
        }
        
    }else
    {
        adc_count_fake++;
    }
}
bool check_key_eeprom(void)//Проверка памяти на наличие в ней ключей
{
    value_key_in_EEprom = EEPROM_read(0);// количество ключей в памяти
    if((value_key_in_EEprom==0xff)|(value_key_in_EEprom==0)) return false;
    else return true;
}
 
//unsigned char m[8]{1,193,128,203,1,0,0,1};
bool check_key_data(I_Button_key_type array[5])//Проверка на совпадение 5 захваченных ключей
{
    unsigned char rez = 0;
    unsigned char i = 0,j = 0;
    unsigned char number_key_kod = 0;
    
    while(number_key_kod<8)
    {
        i =0; j = 0;
        while(i<5)
        {
            j=i+1;
            while(j<5)
            {
                if(array[i].key_code[number_key_kod]==array[j].key_code[number_key_kod]){rez++;}
                j++;
            }
            i++;
        }
        number_key_kod ++;
    }
    if(rez==80)return true;
    else return false;
}
 
void add_key_in_EEPROM()//Добавление ключа в EEprom
{
    //Запись ключа в память моргаем ледом
    I_Button_key_type mas_key_for_write[5];
    //I_Button_key_type key_for_write;// = my_button.read_key();
    uint8_t n = 0;
    while(n<5)// пока не прочитаем все 5 вариантов ключа
    {
        Led_on;
        mas_key_for_write[n] = my_button.read_key();
        if(mas_key_for_write[n].read_Ok==1)n++;
        _delay_ms(100);
    }
    if(check_key_data(mas_key_for_write))
    {
        if(value_key_in_EEprom==0xff)
        {
            EEPROM_write(0,1);
            
        }else
        {
            EEPROM_write(0,value_key_in_EEprom + 1);
        }
        _delay_ms(25);
        value_key_in_EEprom = EEPROM_read(0);
        
        for(n = 0;n<8;n++)
        {
            EEPROM_write((value_key_in_EEprom-1)*10+10+n,mas_key_for_write[0].key_code[n]);
        }
        EEPROM_write((value_key_in_EEprom-1)*10+10+8,value_key_in_EEprom);
    }
}
 
bool compare_key_in_Eeprom(volatile I_Button_key_type *mas_key,uint8_t *max_index,I_Button_key_type *key)//
{//Проверка на наличие или отсутствие ключа в  Eeprom
    uint8_t number_key=0;
    uint8_t bit=0;
    uint8_t rez=0;
    volatile I_Button_key_type mas_temp[*max_index];    
    for(uint8_t number = 0;number<*max_index;number++)
    {
        for(uint8_t bit=0;bit<8;bit++)
        {
            mas_temp[number].key_code[bit] = mas_key[number].key_code[bit];
        }
    }
    for(number_key = 0; number_key < *max_index; number_key++)
    {
        for(bit = 0;bit<8; bit++)
        {
            if(mas_temp[number_key].key_code[bit] == key->key_code[bit])rez++;
        }
    }
    if(rez==8)return true;
    else return false;
}
int main(void)
{
    DDRB |=(1<<PINB0);//для отладки 
    DDRD |=(1<<PIND7);//для отладки
    
    asm("cli"); 
    Usart_ini(10);
    _delay_ms(1000);
    
    
    
        
    volatile I_Button_key_type mas_key_for_compare[value_key_in_EEprom];//Массив ключей, прочитанных из памяти. 
                                            //  В нем вся проблема!!! Начинают искажаться в нем данные,                  
    signed char count_event_add_keys = 0;   //  после  нескольких проверок!!!
    timer1_on_off(1);
 
    adc_ini();
    
    asm("sei");
 
    
     while(check_key_eeprom()==false)//если память пуста ждем пока не запишем ключ
      {
            add_key_in_EEPROM();
      }
    
//*********** Вычитываем еепром 
    uint16_t n_key_eeprom = 0;
    while(n_key_eeprom < value_key_in_EEprom)
    {
        for(unsigned char bit = 0;bit<8;bit++)
        {
            mas_key_for_compare[n_key_eeprom].key_code[bit] = EEPROM_read(bit+10); 
        }
        PORTB |=(1<<PINB0);
        n_key_eeprom++;
    }  
    //Проверка:
    while(n_key_eeprom <(uint16_t)value_key_in_EEprom*10+10 )
    {
        Usart_send_uint8_t(n_key_eeprom);
        _delay_ms(25);
        Usart_send_uint8_t(EEPROM_read(n_key_eeprom));
        _delay_ms(25);
        n_key_eeprom++;
    }
    _delay_ms(500);
    Usart_frame_txq(mas_key_for_compare);
    _delay_ms(500);
    Usart_frame_txq(mas_key_for_compare+1);
    _delay_ms(500);
    PORTB |=(1<<PINB0);
    
    
    
//************* 
    
    
    _delay_ms(50);
    while (1) 
    {   Led_off;
    
        if(timer1_trick)
        {
             
            
        
            I_Button_key_type tmp;
            tmp.read_Ok = 0;
            tmp = my_button.read_key();
            
            if(tmp.read_Ok==1)
            {
                
                unsigned char in = 1;
                I_Button_key_type key_tmp_array[5];//5  для анвлиза
                key_tmp_array[0] = tmp;  
                while(in<5)
                 {
                     key_tmp_array[in] = my_button.read_key();
                     in++;
                 }
                 
                 if (check_key_data(key_tmp_array))//проверка захваченных 5 ключей на равество
                 {                                 // то есть нет ошибки, все 5 одинаковые
                     
                    Usart_frame_txq(&tmp);
                    _delay_ms(2);
//                  Usart_frame_txq(mas_key_for_compare);
                    if(mas_key_for_compare[0].key_code[7] != 0x58){while(1){PORTB |=(1<<PINB0);PORTB &=~(1<<PINB0);}}//это для отладки анализатором
                    if(compare_key_in_Eeprom(mas_key_for_compare,&value_key_in_EEprom,&tmp))//проверка наличия ключа в памяти
                    {
                            Led_on; //открыть дверь
                    //Предположительно здесь происходит искажение массива структур ключей mas_key_for_compare[]
                    // когда полностью, когда частично.
 
                            
                            count_event_add_keys += 2;
                            if(count_event_add_keys > 13)//примерно удерживать 5 секунд для добавления нового ключа
                            {
                                
                                while((tmp.key_code[7] == my_button.read_key().key_code[7])&(tmp.key_code[3] == my_button.read_key().key_code[3]))
                                {
                                    //ожидаем пока уберем мастер ключ                 
                                }
                                _delay_ms(100);
                                
                                //проверить что добавляемый ключ отсутствует в памяти
                                //Добавить ключ
                                Led_on;
                                _delay_ms(3000);
                                count_event_add_keys = 0;
                            }
                            _delay_ms(100);
                    }
                    
                 }
                    
            }
            count_event_add_keys -= 1;
            if(count_event_add_keys < 0)count_event_add_keys = 0; 
            timer1_trick = false;
            if(adc_go)
            {
                adc_start(chanel_adc);
                adc_go = false;
            }
            
        }
        if (adc_value_ready)
        {
            adc_value_ready = false;
            Usart_frame_txq(&adc_Value);
        }
        
    }
}

    uint8_t value_key_in_EEprom;
    volatile I_Button_key_type mas_key_for_compare[value_key_in_EEprom];

    volatile I_Button_key_type mas_key_for_compare[100];