#define LED1    PORTC,2,H   // output, active high (led from PC2 to GND)
#define LED2    PORTD,3,L   // output, active low (led from Vcc to PD3)
#define KEY1    PINB,5,L    // input, active low (key from PB5 to GND, pull-up resistor)
#define KEY2    PINC,7,H    // input, active high (key from Vcc to PC7, pull-down resistor)

#include "ascold.h"
unsigned char Key1Status;
unsigned char Key2Status;
void main() {
    Key1Status = signal(KEY1);
    Key2Status = signal(KEY2);
    for(;;) {
        cpl(LED1);          // toggle LED1
        if(signal(KEY1))    // if KEY1 pressed, turn on LED2
            on(LED2);
        else                // otherwice turn off LED2
            off(LED2);
    }
}}

(*
   Вычисление дня недели в приложениях автоматического вычисления
   дня недели в датах от 1996 года и старше.

   Copyright (C) Sergei Frolov, 1998.   v1.0  Jan, 4, 1998.

   Программа ориентирована на применение в приложениях, написанных
   на языке ассемблера без использования аппаратного умножения/деления
   и операций с плавающей запятой.
*)

program denned;
const
  YEARS  : array[0.. 3] of byte = (0, 2, 3, 4);
  MONTHS : array[1..12] of byte = (0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5);
  DAYOFWEEKS  : array[0..6] of string =
    ('Воскресенье', 'Понедельник', 'Вторник', 'Среда', 'Четверг',
     'Пятница', 'Суббота');
var
  a, b, c, d, e, f, tmp : byte;
  day, month, year      : word;

begin
  repeat
    write('Число XX -> ');    readln(day);
    if day = 0 then break; { выход }
    write('Месяц XX -> ');    readln(month);
    write('Год XXXX -> ');    readln(year);
    tmp := year - 1996;
    a := tmp and 3;
    b := (tmp shr 2) + (tmp and $FC);
    c := MONTHS[month];
    if (a = 0) and (month > 2) then inc(c);
    a := YEARS[a];
    e := (a + b + c + day) mod 7;
    writeln('Результат: ', DAYOFWEEKS[e]);    writeln;
  until false;
end.

#include <ioavr.h>

adc.h     Sample A/D converter driver, for multiple users
button.h     Sample API functions for using push-buttons
buzzer.h     Sample API functions for playing tunes on a piezo buzzer
crc.h     Functions that provide access to cyclic redundancy check calculation
dev0470.h     Functions specific to the dev0470 breakout board
ember-types.h     Ember data type definitions
error-def.h     Return code definitions for EmberZNet stack API functions
error.h     Return codes for Ember API functions and module definitions
hal.h     Generic set of HAL includes for all platforms
iar.h     Compiler/platform-specific definitions and typedefs for the IAR AVR C compiler
led.h     Sample API funtions for controlling LEDs
micro.h     Functions common across all microcontroller-specific files
random.h     Functions that provide access to random numbers
reserved-ram.h     Memory allocations that allow for data sharing between the normally running application and bootloader
hal/micro/serial.h     Serial hardware abstraction layer interfaces
app/util/serial/serial.h     High-level serial communication functions
spi-protocol.h    Example AVR SPI Protocol implementation for interfacing with EM260
spi.h     Generic SPI manipulation routines
system-timer.h     Functions that provide access to the system clock
avr-atmega/32/system-timer.h     Functions that provide access to the system clock for ATmega32 microcontroller
uart.h     Prototypes and defines for the hardware-specific UARTs

ISR(ADC_vect)
{
    for(;;)
    {
        on(TEST);
        _nop();
        _nop();
        _nop();
        off(TEST)
    }
}
ISR(UDRE_vect)
{
    for(;;)
    {
        _nop();
        on(TEST);
        _nop();
        _nop();
        off(TEST)
    }
}
......
ISR(UDRE_vect)
{
    for(;;)
    {
        _nop();
        _nop();
        on(TEST);
        _nop();
        off(TEST)
    }
}
.......
ISR(TIMER2_COMP_vect)
{
    for(;;)
    {
        _nop();
        _nop();
        _nop();
        on(TEST);
        off(TEST)
    }
}

void ltoa_fmt(long val, s_char length, u_char *buff)
{
long ltemp;
int itemp;
s_char binc,atemp;
u_char *ptr1, *ptr2;

  ptr1 = buff;

  if (val<0)
   {
     val = -val;
     *buff++ = '-';
   }

  atemp='0';
  ltemp=1000000;
    while(val >= ltemp)
    {
      atemp++;
      val-=ltemp;
    };
  if(atemp != '0')
    *buff++=atemp;
  atemp='0';
  ltemp=100000;
    while(val >= ltemp)
    {
      atemp++;
      val-=ltemp;
    };
  if(atemp != '0')
    *buff++=atemp;
  atemp='0';
  itemp=10000;
    while(val >= itemp)
    {
      atemp++;
      val-=itemp;
    };
  if(atemp != '0')
    *buff++=atemp;
  atemp='0';
  itemp=1000;
    while(val >= itemp)
    {
      atemp++;
      val-=itemp;
    };
  if(atemp != '0')
    *buff++=atemp;
  atemp='0';
  itemp=100;
    while(val >= itemp)
    {
      atemp++;
      val-=itemp;
    };
  if(atemp != '0')
    *buff++=atemp;
  atemp='0';
  binc=(char)val;
    while(binc >= 10)
    {
      atemp++;
      binc-=10;
    };
  if(atemp != '0')
    *buff++=atemp;
  binc += '0';
  *buff=binc;

  atemp = buff - ptr1 + 1;
  ptr2 = ptr1 + length-1;
  while(atemp--)
    *ptr2-- = *buff--;
  atemp = ptr2 - ptr1 + 1;
  while(atemp--)          
    *ptr2-- = ' ';
}

u32 bin2bcd_u32(u32 data, u8 result_bytes) NAKED;
u32 bin2bcd_u32(u32 data, u8 result_bytes)
{asm volatile(
  "push __tmp_reg__ \n push r26 \n push r27 \n push r30 \n push r31 \n"
  "mov __tmp_reg__, %A1   \n" /*number of bytes in result*/
   "bin2bcd_u32_00:       \n" /*correct input number by left shifts*/
     "mov r31, %A0        \n"
     "mov %A0, %B0        \n"
     "mov %B0, %C0        \n"
     "mov %C0, %D0        \n"
     "mov %D0, r31        \n"
     "dec __tmp_reg__     \n"
     "brne bin2bcd_u32_00 \n"
  
   "eor r26, r26          \n" /*clear result*/
   "eor r27, r27          \n"
   "eor r30, r30          \n"
   "eor r31, r31          \n"
   "mov __tmp_reg__, %A1  \n"
   "lsl __tmp_reg__ \n lsl __tmp_reg__ \n lsl __tmp_reg__ \n" /*__tmp_reg__=size in bits*8*/
  
   "bin2bcd_u32_01:       \n" /*shift loop*/
    "subi r26,-0x33       \n" /*add 0x33*/
    "sbrs r26, 3          \n" /*if carry to bit 3,*/
    "subi r26, 3          \n" /*subtract 3*/
    "sbrs r26, 7          \n" /*if carry to bit 7,*/
    "subi r26, 0x30       \n" /*subtract 0x30*/
    "subi r27,-0x33       \n" /*add 0x33*/
    "sbrs r27, 3          \n" /*if carry to bit 3,*/
    "subi r27, 3          \n" /*subtract 3*/
    "sbrs r27, 7          \n" /*if carry to bit 7,*/
    "subi r27, 0x30       \n" /*subtract 0x30*/
    "subi r30,-0x33       \n" /*add 0x33*/
    "sbrs r30, 3          \n" /*if carry to bit 3,*/
    "subi r30, 3          \n" /*subtract 3*/
    "sbrs r30, 7          \n" /*if carry to bit 7,*/
    "subi r30, 0x30       \n" /*subtract 0x30*/
    "subi r31,-0x33       \n" /*add 0x33*/
    "sbrs r31, 3          \n" /*if carry to bit 3,*/
    "subi r31, 3          \n" /*subtract 3*/
    "sbrs r31, 7          \n" /*if carry to bit 7,*/
    "subi r31, 0x30       \n" /*subtract 0x30*/
    "lsl r26 \n rol r27 \n rol r30 \n rol r31 \n" /*shift out buffer*/
  
    "sbrc %D0, 7          \n" /*skip if msbit of input =0*/
    "ori  r26, 1          \n" /*set lsb of output*/
    "lsl %A0 \n rol %B0 \n rol %C0 \n rol %D0 \n"/*shift input*/
  
    "dec __tmp_reg__      \n"
    "brne bin2bcd_u32_01  \n" /*repeat for all bits*/
  
    "movw r22, r26        \n" /*move result*/
    "movw r24, r30        \n"
    "pop r31 \n pop r30 \n pop r27 \n pop r26 \n pop __tmp_reg__\n"
    "ret \n"
  : :"r"(data),"r"(result_bytes):"r0","r26","r27","r30","r31" /*input and output parameters*/
  );

u32 bin2bcd_u32(u32 data, u8 result_bytes)
{u32 result = 0; /*result*/
  u8 u8_1;
  for (u8_1 = (4 - result_bytes); u8_1; u8_1--) data <<= 8; /*adjust input bytes*/
  for (u8_1 = (result_bytes << 3); u8_1; u8_1--) /*bit shift loop*/
  {u8 u8_2, u8_3;
   /*result BCD nibbles correction*/
   result += 0x33333333;
   /*result correction loop*/
   for (u8_3 = 4; u8_3; u8_3--)
   {u8_2 = result >> 24;
    if (!(u8_2 & 0x08)) u8_2 -= 0x03;
    if (!(u8_2 & 0x80)) u8_2 -= 0x30;
    result <<= 8; /*shift result*/
    result |= u8_2; /*set 8 bits of result*/
   }
   /*shift next bit of input to result*/
   result <<= 1;
   if (((u8)(data >> 24)) & 0x80) result |= 1;
   data <<= 1;
  }
  return(result);
}

u32 bcd2bin_u32(u32 data, u8 result_bytes) NAKED;
u32 bcd2bin_u32(u32 data, u8 result_bytes)
{asm("push __tmp_reg__ \n push r26 \n push r27 \n push r30 \n push r31 \n"
  "eor r26, r26           \n" /*clear result*/
  "eor r27, r27           \n"
  "eor r30, r30           \n"
  "eor r31, r31           \n"
  "mov __tmp_reg__, %A1   \n"
  "lsl __tmp_reg__ \n lsl __tmp_reg__ \n lsl __tmp_reg__ \n" /*__tmp_reg__=input parameter size in bits*/

   "bcd2bin_u32_00:       \n" /*bits shift loop*/
  
    "lsr r31 \n ror r30 \n ror r27 \n ror r26 \n" /*shift out buffer*/
  
    "sbrc %A0, 0          \n" /*move lowest bit*/
    "ori  r31, 0x80       \n"
  
    "lsr %D0 \n ror %C0 \n ror %B0 \n ror %A0 \n"
  
    "sbrc %D0, 7          \n" /*if carry to bit 7,*/
    "subi %D0, 0x30       \n" /*subtract 0x30*/
    "sbrc %D0, 3          \n" /*if carry to bit 3,*/
    "subi %D0, 3          \n" /*subtract 3*/
    "sbrc %C0, 7          \n" /*if carry to bit 7,*/
    "subi %C0, 0x30       \n" /*subtract 0x30*/
    "sbrc %C0, 3          \n" /*if carry to bit 3,*/
    "subi %C0, 3          \n" /*subtract 0x30*/
    "sbrc %B0, 7          \n" /*if carry to bit 7,*/
    "subi %B0, 0x30       \n" /*subtract 0x30*/
    "sbrc %B0, 3          \n" /*if carry to bit 3,*/
    "subi %B0, 3          \n" /*subtract 3*/
    "sbrc %A0, 7          \n" /*if carry to bit 7,*/
    "subi %A0, 0x30       \n" /*subtract 0x30*/
    "sbrc %A0, 3          \n" /*if carry to bit 3,*/
    "subi %A0, 3          \n" /*subtract 3*/
  
    "dec __tmp_reg__      \n" /*repeat for all bits*/
    "brne bcd2bin_u32_00  \n"
  
   "movw r22, r26         \n" /*adjust result bytes*/
   "movw r24, r30         \n"
    "bcd2bin_u32_01:      \n"
     "mov __tmp_reg__,r25 \n"
     "mov r25,r24         \n"
     "mov r24,r23         \n"
     "mov r23,r22         \n"
     "mov r22,__tmp_reg__ \n"
     "dec %A1             \n"
     "brne bcd2bin_u32_01 \n"
  
   "pop r31 \n pop r30 \n pop r27 \n pop r26 \n pop __tmp_reg__ \n"
   "ret \n"
   : :"r"(data),"r"(result_bytes):"r0","r26","r27","r30","r31" /*input and output parameters*/
  );
}

u32 bcd2bin_u32(u32 data, u8 input_bytes)
{u32 result = 0; /*result*/
  u8 cnt_bits, cnt_bytes, tmp_byte;
  for (cnt_bits = (input_bytes << 3); cnt_bits; cnt_bits--)
  {/*shift next bit*/
   result >>= 1;
   if (((u8)(data)) & 0x01) result |= 0x80000000;
   data >>= 1;
   {/*BCD correction of result*/
    for (cnt_bytes = 4; cnt_bytes; cnt_bytes--)
    {tmp_byte = (data >> 24);
     if (tmp_byte & 0x80) tmp_byte -= 0x30;
     if (tmp_byte & 0x08) tmp_byte -= 0x03;
     data <<= 8;
     data |= tmp_byte;
    }
   }
  }
  /*adjust result bytes*/
  for (cnt_bits = (4 - input_bytes); cnt_bits; cnt_bits--) result >>= 8;
  return(result);
}

void num2asc_s32(s32 data, u8 *buf, u8 options)
{u8 cnt_chars, point_pos;
cnt_chars = (options & 7); /*number of digits*/
/*convert negative to positive, set '-' flag*/
if (data < 0) {data = -data; options |= 1;} else options &= ~1;
/*if necessary, convert to BCD*/
if (options & 0x80) data = bin2bcd_u32(data, (cnt_chars >> 1) + 1);
cnt_chars++;
/*calculate point position*/
point_pos = cnt_chars - ((options >> 4) & 7);
if (point_pos) point_pos++;
while (cnt_chars) /*digits conversion loop*/
{if ((options & 8) && (data == 0) && (cnt_chars < point_pos))
  {if (options & 1) *buf = asc_minus; else *buf = asc_space;
   options &= ~1;
  } else
   {if ((cnt_chars == point_pos) && (options & 0x70)) /*store point*/
    {*buf = asc_point;
     cnt_chars--;
     buf--;
    }
    *buf = bin2asc_u8(data); /*store ASCII digit*/
   }
  cnt_chars--;
  buf--;
  data >>= 4;
}
if (options & 1) *buf = asc_minus;
}