//----------------------------------------------------------------------------
// Вычисления дня недели по дате
// Все деления целочисленные (остаток отбрасывается).
// Результат: 0 — воскресенье, 1 — понедельник и т. д.
//----------------------------------------------------------------------------
unsigned char what_day(unsigned int year, unsigned char month, unsigned char date)  
{
  unsigned char a = (14 - month) / 12;
  unsigned int y = year - a;        
  unsigned char m = month + 12*a - 2;
  
  return (7000 + (date + y + y/4 - y/100 + y/400 + (31*m)/12 ))% 7;  
}

int main()
{
  what_day(2008, 6, 6);
.....................

int main()
{
  what_day(2008, 6, 6);
.....................

int main()
{volatile unsigned char day;
  day = what_day(2008, 6, 6);
.....................

enum Month {January=1,February,March,April,May,June,July,August,
            September,October,November,December};
struct Date
{
  float day;
  Month month;
  int year;
};

signed int DayOfWeek(Date date)
{
    float F;
    if (date.month<March)
      F=365*date.year+date.day+31*(date.month-1)+
        (signed int)((date.year-1)/4)-(signed int)(3*(signed int)((date.year-1)/100+1)/4);
    else
      F=365*date.year+date.day+31*(date.month-1)-(signed int)(0.4*date.month+2.3)+
        (signed int)(date.year/4)-(signed int)(3*(signed int)(date.year/100+1)/4);
    return  (signed int)F-7*(signed int)(F/7)-1;
}

........................
int main()
{volatile unsigned char day;
  Date Today={5,June,2008};
  
    switch (DayOfWeek(Today))
  {
       case -1: day=1;break;  // printf("Sunday\n");break;
       case 0:  day=2;break;  //printf("Monday\n");break;
       case 1:  day=3;break;  //printf("Tuesday\n");break;
       case 2:  day=4;break;  //printf("Wednesday\n");break;
       case 3:  day=5;break;  //printf("Thursday\n");break;
       case 4:  day=6;break;  //printf("Friday\n");break;
       case 5:  day=7;break;  //printf("Saturday\n");break;
  }

  02    what_day(unsigned int, unsigned char, unsigned char)
        | Stack used (prev) :  0000008F 00000038
        | + function block  :  00000008 00000004

//---------------------------------------------------------------------------
int main()
{
volatile unsigned char day;
  day = what_day(2008, 6, 16);

  // Initialise variables from EEPROM
  area = ee_area;         // Площадь поперечного сечения газохода, m^2
  Kt = ee_Kt;             // Коэффициент напорности трубки
  Y0 = ee_Y0;             // Плотность газа при 0 градусов, kg/m^3
  rate = ee_rate;         // Частота обновления данных, Hz
  nmax = ee_nmax;         // Коэффициент усреднения данных
  
  // Initialise
  uart_Init(baud_select);
  i2c_Init(100);          // set TWI bit rate to 100KHz    
  spi_Init();             // Master mode, clock = f/16, select clock phase positive-going in middle of data
  key_Init();
  pca9557_Init();
  lcd_Init();
  menu_Init();
  hp03_Init();
  ds75_Init();
  rtc_Init();

  SLEEP_ENABLE;
  SELECT_IDLE;
  
__enable_interrupt();    // set the Global Interrupt Enable Bit
  ad7799_Init();
  
  //beep();                 // Инициализация прошла успешно
  
  TCCR0B = 0x03;          // Start System Timer f_clk/64
  TIMSK0 |= (1 << TOIE0); // Разрешить прерывания Timer0 по переполнению (OVF)
                          // Период переполнения при f_clk=7.3728 Mhz 2.222 ms
  OS::Run();              //                     при f_clk=20 Mhz 0.8192 ms
}

unsigned char what_day(unsigned int year, unsigned int month, unsigned int day)
{
  unsigned char YEAR[]={0, 2, 3, 4};
  unsigned char MONTH[]={0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5};
  unsigned char a, b, c, e, tmp;
  
  tmp = year - 1996;
  a = tmp & 3;
  b = (tmp >> 2) + (tmp & 0xfc);
  c = MONTH[month-1];
  
  if((a == 0) && (month > 2)) c++;
  a = YEAR[a];
  e = (a + b + c + day) % 7;
  return e;
}

//_____________________________________________________________________________
double quadratic(double a, double b, double c)
{
  double d, x;
  d=b*b-4.*a*c;                 // Дискриминант
  if(d<0.) return 0;            // Уравнение не имеет корней
  if(d==0.) x=-b/(2.*a);        // Уравнение имеет один корень
  else  x=(-b+sqrt(d))/(2.*a);  // Уравнение имеет два корня,
                        // но нужен только положительный
  return x;
}

//#############################################################################
// round down a number to the decimal place given by power
// e.g round(1.0256,-2) means round to 2nd decimal -> 1.03
//_____________________________________________________________________________
double round_to_pow(double x, int power)
{
   double inc, xnew;
   inc  = pow(10.0, (double)power);
   xnew = inc * (floor(x/inc + 0.5 + SMALL));
   return(xnew);
}

//---------------------------------------------------------------------------
int main()
{
volatile unsigned char day;
  day = (unsigned char)round_to_pow(quadratic(100, 200, 3), -5);

CSTACK               DATA          00000100 - 000001FF         100   dse    0
RSTACK               DATA          00000200 - 0000023F          40   dse    0

//=========================================================
void prog3(char ch)
{
    ch=ch+2;
    ch=ch/3;
    ch=ch%3;
}
void prog4(char ch)
{
    ch=ch/3;
    ch=ch%3;
}

??? Лишние инструкции
??? Оптимальнее было-бы так -
_prog3:
    LD   R30,Y
    SUBI R30,-LOW(2)
    ST   Y,R30
_prog4:
    LD   R26,Y
    LDI  R30,LOW(3)
    RCALL __DIVB21U
    ST   Y,R30
    LD   R26,Y
    LDI  R30,LOW(3)
    RCALL __MODB21U
    ST   Y,R30
    ADIW R28,1
    RET

  day = a + year + c + day;// % 7;
  while(day >= 7)  day -= 7;
  
  return day;

unsigned char what_day(unsigned int year, unsigned int month, unsigned int date)
{
  signed int c=0;
  unsigned char day;
  
  if((date>=1)&&(date<=31)&&(month>=1)&&(month<=12)&&(year>=1582)&&(year<=4903))
  {  
    if(month < 3)
    {
      month += 10;    // Месяц январь или февраль?
      year -= 1;
    }
    else
    {
      month -= 2;     // Остальные месяцы
      
      while(year >= 100)
      {
        c++;          // Вычисляем столетие
        year -= 100;  // Находим год в столетии
      }
      
      day = (unsigned char)((26*month-2)/10 + date + (year>>2) + year + (c>>2) - 2*c);
      while(day >= 7) day -= 7;  // Вычисляем день недели
    }
  }
  return day;
}

Maximum stack usage in bytes:

     Function           CSTACK RSTACK
     --------           ------ ------
     lcd_EN_toggle          0      2
     lcd_command            1      2
       -> lcd_waitcmd       1      2
       -> lcd_write         1      2
       -> lcd_waitcmd       1      2

unsigned long DateTimeToLong(TDataTime* pdt){
byte month;
word year;
unsigned long c, ya;
unsigned long res;

month = BCDtoBin(pdt->Month);
year = BCDtoBin(pdt->Year)+2000;

if(month > 2){
month -= 3;
}/*if*/
else {
month += 9;
year--;
}/*else*/

c = (year / 100L);
ya = (year - (100L * c));
res = (146097L * c)/4L + (1461L * ya) /4L + (153L * month + 2L)/5L + BCDtoBin(pdt->Date);
pdt->Day=(res+2)%7;
return (res - 720000L) * 1440L + (BCDtoBin(pdt->Hour) * 60L + BCDtoBin(pdt->Min));
}

day = (unsigned char)((26*month-2)/10 + date + (year>>2) + year + (c>>2) - 2*c);

//NOTE: This module defines or uses C++ features that are not
//      accessible from assembler code. Assembling this file will
//      not produce an equivalent object file to the one produced
//      by the C++ compiler.

        EXTERN ?EPILOGUE_B6_L09
        EXTERN ?EPILOGUE_B8_L09
        EXTERN ?PROLOGUE6_L09
        EXTERN ?PROLOGUE8_L09
....................
        EXTERN ?US_DIVMOD_L02

..................
        CALL    ?US_DIVMOD_L02

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;
}

char __flash characters[16] = {...};
..........................
    while(lineResult & 0x10)    // Loop while row line high
    {
      lineResult >>= 1;            // Next row line into LSB
      tempScan += 4;        // Increment row part of scancode.     Было tempScan += 8;    
    }

    ENABLE_PCINT3;        // Reenable pin change interrupt

__flash const unsigned char Table[13]={0,0,3,3,6,1,4,6,2,5,0,3,5};
unsigned int CurrentYear;
unsigned char Month, Day;

/*********************************************************
* Test Program for the routine GetDayofWeek()
*********************************************************/
void main(void)
{
  char Temp;
  CurrentYear = 1998; //Date : 21 September 1998
  Month = 9;
  Day = 21;
  Temp = GetDayofWeek();// Result stored in Temp
  do{} while(1);
}


/****************************************************************
* GetDayofWeek
* This routine calculate the Day(Sunday, Monday,...Saturday) of
* week when a Date(year, Month, Day) is given.
* Input : Year, Month and Day which in this routine is used
* as global variable.
* Output Variable : 0 to 6(which correspond to Sunday to Saturdaday
* respectively) if the input is acceptable, else a value 8 is return
*****************************************************************/
unsigned char GetDayofWeek(void)
{
  unsigned int TempYear;
  unsigned char AccValue;
  
  if(CheckValidInput(CurrentYear)!= OK) // Return Error if input not Valid  
  return Error;
  
  TempYear = 1990; //Comparation start with year 1990
  AccValue = 0;   //Init AccValue to 0
  
  // If TempYear is a leap year AccValue +2, else AccValue+1
  while(TempYear != CurrentYear)
  {
    AccValue++;
    if(IsLeapYear(TempYear))
    AccValue++;
    TempYear++;
  }
  
  if(Month > 2)
  {
    if(IsLeapYear(TempYear)==1)
    AccValue++;
  }
  
  AccValue += Table[Month];
  AccValue += Day;
  AccValue= AccValue%7;
  
  return(AccValue);
}
/*************************************************************************
* CheckValidInput
* Return a '1' if the input is within the required range. Else
* return a '0'.
*
* Input Variable : 16Bit Unsigned Int
* Output Varible : '1' if input ranges between 1990 & 2099 inclusively
***************************************************************************/
unsigned char CheckValidInput(unsigned int Input)
{
  if(Input >= 1990 && Input <= 2099)
    return OK;    
  else
    return !OK;  
}


/*************************************************************************
* IsLeapYear
* Return a '1' if the input is a leap year. Else return a '0'
*
* Input Variable : 16Bit Unsigned Int
* Output Varible : '1' if is a leap year, else '0'.
***************************************************************************/
unsigned char IsLeapYear(unsigned int Year)
{
  Year=Year&0x0003;
  
  if(Year==0)
    return 1;
  else
    return 0;
}
/*************************************************************************/

//Regra de Zeller
unsigned char GetWDay( int nMDay, int nMonth, int nYear ){
  int nWDay, D, C;
  C = nYear / 100;
  if( nMonth < 3 ) D = ( nYear - 1 ) % 100;
  else D = nYear % 100;
  nMonth = ( ( nMonth + 9 ) % 12 ) + 1;
  nWDay = nMDay + ( ( 13 * nMonth - 1 ) / 5 ) + D + ( D / 4 ) + ( C / 4 ) - 2 * C;
  return( nWDay < 0 ? ( nWDay + 7 ) : ( nWDay % 7 ) );
}

return( ( nWDay + 7 ) % 7  );