#define F_CPU 8000000UL
#include <avr/io.h>
//#include <stdio.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/eeprom.h>
unsigned char edinicy EEMEM;
unsigned char desyatki EEMEM;
unsigned char sotny EEMEM;
unsigned char ostatok_probega EEMEM;
//.......................0.....1.....2.....3.....4.....5.....6.....7.....8.....9....пусто
const char digit[11] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}; // масив цифр для отправки на К155ИД1
volatile char lev[7] = {255, 1, 1, 255, 255, 255, 255};
volatile uint8_t out[3] = {10, 10, 10};
volatile unsigned char lever;
unsigned int D1, D1N, p, S, df, t;
unsigned char k, sh, l1, l2, l3, l4, ds, n=0, sot, des, edin, batt_8, fuel_8, batt, fuel;
volatile uint8_t fr[3]; // какой разряд изменился
uint8_t tscr[3]; // временный экран
uint8_t iocr = 0, dig = 0;
char ms = 0, digr;
const uint8_t psc[25]={1,11,32,43,64,85,106,157,178,199,220,251,255,251,220,199,178,157,106,85,64,43,32,11,1}; // ступени яркости
const uint8_t lm1[21]={0,1,2,3,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};//массивы для шкалы
const uint8_t lm2[21]={0,0,0,0,0,0,1,2,3,4,5,5,5,5,5,5,5,5,5,5,5};//----
const uint8_t lm3[21]={0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,5,5,5,5,5};//----
const uint8_t lm4[21]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5};//----
const uint8_t anod[4]={0,1,4,5};//распределение анодных портов для шкалы
volatile uint8_t catod[4]={0,0,0,0};//   временный массив
   
void epprom_convert(uint16_t prob)
{
       sot = prob / 100;// сотни
      des = (prob / 10) % 10;//десятки
      edin = prob % 10;//еденицы   
}
   
void shkala(uint8_t l)   //разложение на разряды шкалы в пятиричной системе счисления
{               //с занесением во временный ммассив
   catod[0]=lm1[l];
   catod[1]=lm2[l];
   catod[2]=lm3[l];
   catod[3]=lm4[l];
}

void code(char lever)//пятеричная система переводится на конкретные порты
{
   switch (lever)
   {
   case 0:   break;
   case 1:   PORTB|=(1<<0);   break;
   case 2:   PORTB|=(1<<0)|(1<<4);   break;
   case 3:   PORTB|=(1<<0)|(1<<4)|(1<<5);   break;
   case 4:   PORTB|=(1<<0)|(1<<4)|(1<<5)|(1<<6);   break;
   case 5:   PORTB|=(1<<0)|(1<<4)|(1<<5)|(1<<6)|(1<<7);   break;
   }
   
}

ISR(TIMER0_OVF_vect)//шкала
{
 //организация отрезка выборки ~500ms c ДС
   if (p++>1950)
   {
      D1=S;//перекладываем насчитаное для дальнейшей обработки
      S=0;//сбрасываем насчитаное за 0,5сек
      p=0;
      D1N=D1N+D1/6; //суммируем пробег метры
      if (D1N>1000)// если насчитали больше км складываем в конечную копилку
         {
         df++;
         D1N=D1N/100; //тут оставшиеся десятки, а может даже и сотни возвращаем в сумматор
         }
   }
  PORTB&=~((1<<0)|(1<<4)|(1<<5)|(1<<6)|(1<<7));//сбрасываем катоды шкалы
  PORTD&=~((1<<0)|(1<<1)|(1<<4)|(1<<5));//сбрасываем аноды шкалы
  PORTD|=(1<<anod[k]);               //перебираем аноды
  code(catod[k]);                  //выводим значение для каждого анода
   k++;
   if (k>3){k=0;}               //что бы начать все сначало
}
void batt_fuel(void)
{
   ADCSRA|=(1<<ADSC);
   ADMUX^=(1<<0); //меняем канал
   batt=(batt_8*200)/255;//формула расчета напряжения
   fuel=(255-fuel_8)/255;
   inki(batt);                              //ругается на эту строчку! т.е. на переход в функцию inki
///// Warning   1   implicit declaration of function 'inki' /////Error   3   previous implicit declaration of 'inki' was here
   shkala(fuel);
}
// void inki (int D1)
// {
//    
// }

void inki(int t) // эффект плавной смены цифр, здесь идет поиск тех цифр, которые надо менять ////Warning   2   conflicting types for 'inki'
{
 uint8_t i;// запомнили новое время для 3 разрядов и заносим в массив tscr[]
       tscr[0] = t / 100;// сотни
      tscr[1] = (t / 10) % 10;//десятки
      tscr[2] = t % 10;//еденицы
      for (i = 0; (i < 3); i++) // сравнили с тем, что было 6 раз (цикл)
         if (tscr[i] != out[i]) // узнаём в каком разряде поменялась цифра, массив out[i] содержит текущие значения
            {fr[i] = 1;} // цифра изменилась создаем массив с индикатором 1 измененных цифр
         else
            {fr[i] = 0;} // цифра осталась
         iocr = 0;
}

ISR (TIMER2_OVF_vect) // реализация ШИМ управления яркостью ламп и подсветки
{
   uint8_t i;// переменная i
   PORTB &=~((1<<1)|(1<<2)|(1<<3));
   OCR2 = lev[dig]; // подготавливаемся к выводу следуйщего разряда. таймер по совпадению
   if (iocr < 25)// плавная смена яркости цифр
      {
      if (++ms == 18) // ~38ms
         {
         ms = 0;
         for (i = 0; i < 3; i++) //без 100грамм не разобраться:
            {
            if ((fr[i] == 1) || (iocr == 0))
               {
               lev[i] = psc[iocr];
               }
            if (iocr == 12)
               {
               out[i] = tscr[i];
               }               
            }
         iocr++;
         }
      }
}

ISR (TIMER2_COMP_vect) // реализация ШИМ управления яркостью ламп и подсветки
{
   if(dig < 3)// три разряда 0,1,2 digr3-еденицы
   {
       PORTC = digit[out[dig]]; // выводим цифру на дешифратор катоды т.е.0-9
       digr=dig+1;   
   if (dig==0){if (out[0]!=0){PORTB|=(1<<digr);}}// далее выбор анодов цифр с гашением 0
   if (dig==1){if ((out[0]!=0)||(out[1]!=0)){PORTB|=(1<<digr);}}
   if (dig==2){PORTB|=(1<<digr);}   
   }   
   if (++dig > 3){dig = 0;}
}

ISR(ADC_vect)
{
   if((ADMUX & 0xE6)==1) // Если был выбран канал ADC6 BATT
   {
      batt_8=ADCH;
      PORTC|=(1<<4);//зажигаем запятую
   }
   else
   {
      fuel_8=ADCH;
   }

}

ISR(INT0_vect)
{
S++;// здесь складываются импульсы от ДС
}

ISR(INT1_vect)
{
cli();
 PORTB=0x00;//тушим всю индикацию для снижения энергопотребления
 PORTD&=~((1<<0)|(1<<1)|(1<<4)|(1<<5));
 PORTC&=~((1<<0)|(1<<1)|(1<<2)|(1<<3));
epprom_convert(df);//раскладываем на разряды
if (eeprom_read_byte(&edinicy)!=edin)//если есть изменения, то:
   {
   eeprom_write_byte(&edinicy, edin);// сохраняем пробег поразрядно
   }
if (eeprom_read_byte(&desyatki)!=edin)
   {
   eeprom_write_byte(&desyatki, des);
   }
if (eeprom_read_byte(&sotny)!=edin)
   {
   eeprom_write_byte(&sotny, sot);
   }
if (eeprom_read_byte(&ostatok_probega)!=D1N)//не забываем про остаточек пробега
   {
      eeprom_write_byte(&ostatok_probega, D1N);
   }
}

int main(void)
{
   /**********************************настройка портов******************************/
   DDRB|=(1<<0)|(1<<4)|(1<<5)|(1<<6)|(1<<7)|(1<<1)|(1<<2)|(1<<3);
   DDRD|=(1<<0)|(1<<1)|(1<<4)|(1<<5)|(1<<3);
   DDRC|=(1<<0)|(1<<1)|(1<<2)|(1<<3);//к дешифратору
/**********************************настройка таймера2 индикация цифр*****************************/
TCCR2 |= (1 << CS20) | (1 << CS21);   //предделитель на 32
TIMSK |= (1<<OCIE2) | (1<<TOIE2);
/**********************************настройка таймера1 индикация шкалы*****************************/
TCCR0 |= (1<<CS01);// | (1<<CS00); //предделитель на 8 //на 64
TIMSK |= (1<<TOIE0);
/**********************************настройка внешнего прерывания INT0*****************************/
MCUCR |= (1<<ISC01);            //по убывающему фронту
GICR |= (1<<INT0);      
/**********************************настройка внешнего прерывания INT1*****************************/
//для мониторинга питания, на случай его пропадания записать пробег в eeprom
MCUCR |= (1<<ISC11)|(1<<ISC10);      //по нарастающему фронту
GICR |= (1<<INT1);
/**********************************настройка ADC*****************************/
   ADMUX |= (1 << REFS0)|(1<<REFS1); // Vref=2,56V
   ADMUX |= (1 << MUX0)|(1<<MUX1)|(1<<MUX2)|(1<<ADLAR); // Подключаем канал ADC7, 8-bit ADC
   ADCSRA |= (1 << ADEN) // разрешение АЦП
   |(1 << ADSC) // запуск преобразования
   |(1 << ADPS2)|(1 << ADPS1)|(1 << ADPS0)|(1<<ADFR) // предделитель на 128
   |(1 << ADIE); // разрешение прерывания от АЦП
/********************************************************************************/
D1N=eeprom_read_byte(&ostatok_probega);//прочитали остаточек
df=(eeprom_read_byte(&sotny)*100)+(eeprom_read_byte(&desyatki)*10)+eeprom_read_byte(&edinicy);//прочитали пробег
   sei();
   while(1)//тестовые формулы и т.д.
   {
      sh=(ADCH*100)/1275;
      ds=D1/10;
      inki(df);
      shkala(ds);
//       inki(batt);      ///если ставим здесь переход в функцию inki - ошибок нет!
//       shkala(fuel);
      _delay_ms(1000);
      ADCSRA|=(1<<ADSC);
      //batt_fuel(); //отображение 3 режима
   }
   return 0;
}

#define F_CPU 8000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/eeprom.h>
unsigned char edinicy EEMEM;
unsigned char desyatki EEMEM;
unsigned char sotny EEMEM;
unsigned char vid_ EEMEM;
unsigned int ostatok_probega EEMEM;
unsigned int calibration EEMEM;
unsigned char u_l EEMEM;   //хранит low калибровки бака
unsigned char u_f EEMEM;   //хранит full калибровки бака
unsigned int full_p EEMEM;
/////////////////////////
бла, бла...
////////////////////////
int main(void)
{
/////////////////////////
бла, бла...
////////////////////////
   
   if (eeprom_read_byte(&vid_)>4)
   {
   eeprom_write_byte(&u_l, 249);
   eeprom_write_byte(&u_f, 24);   
   eeprom_write_word(&ostatok_probega, 0);   
   eeprom_write_byte(&vid_, 2);
   
   eeprom_write_byte(&edinicy, 0);
   eeprom_write_byte(&desyatki, 0);
   eeprom_write_byte(&sotny, 0);
   eeprom_write_word(&full_p, 55555); здесь например 65535 при считывании
   eeprom_write_word(&calibration, 458); здесь 9
   }
sei();
D1N=eeprom_read_word(&ostatok_probega);//прочитали остаточек
df=(eeprom_read_byte(&sotny)*100)+(eeprom_read_byte(&desyatki)*10)+eeprom_read_byte(&edinicy);//прочитали и собрали пробег
vid=eeprom_read_byte(&vid_);
calib_v=eeprom_read_word(&calibration);
ul=eeprom_read_byte(&u_l);
uf=eeprom_read_byte(&u_f);

while(1)
   {....... и так далее.....

if (eeprom_read_byte(&vid_)>4)
   {
   eeprom_write_word(&full_p, 0);
   eeprom_write_word(&calibration, 275);
   eeprom_write_byte(&u_l, 219);
   eeprom_write_byte(&vid_, 1);
   }
   if (eeprom_read_word(&ostatok_probega)>3000)
   {
   eeprom_write_word(&ostatok_probega, 0);
   eeprom_write_byte(&u_f, 44);
   }
   if (eeprom_read_byte(&sotny)>9)
   {
   eeprom_write_byte(&edinicy, 3);
   eeprom_write_byte(&desyatki, 2);
   eeprom_write_byte(&sotny, 1);
   }

C Code Example
char cSREG;
cSREG = SREG; /* store SREG value */
/* disable interrupts during timed sequence */
_CLI();
EECR |= (1<<EEMWE); /* start EEPROM write */
EECR |= (1<<EEWE);
SREG = cSREG; /* restore SREG value (I-bit) */