[size=2]//ICC-AVR application builder : 19.09.2008 15:07:18
// Target : M128
// Crystal: 4.0000Mhz

#include <iom128v.h>
#include <macros.h>

void port_init(void)
{
PORTA = 0x00;
DDRA  = 0x00;
PORTB = 0x00;
DDRB  = 0x00;
PORTC = 0x00; //m103 output only
DDRC  = 0x00;
PORTD = 0x00;
DDRD  = 0x00;
PORTE = 0x00;
DDRE  = 0x00;
PORTF = 0x00;
DDRF  = 0x00;
PORTG = 0x00;
DDRG  = 0x00;
}

//TIMER0 initialize - prescale:64
// WGM: Normal
// desired value: 5KHz
// actual value:  5,208KHz (4,0%)
void timer0_init(void)
{
TCCR0 = 0x00; //stop
ASSR  = 0x00; //set async mode
TCNT0 = 0xF4; //set count
OCR0  = 0x0C;
TCCR0 = 0x04; //start timer
}

#pragma interrupt_handler timer0_ovf_isr:iv_TIM0_OVF
void timer0_ovf_isr(void)
{
TCNT0 = 0xF4; //reload counter value
}

//TIMER1 initialize - prescale:8
// WGM: 0) Normal, TOP=0xFFFF
// desired value: 25Hz
// actual value: 25,000Hz (0,0%)
void timer1_init(void)
{
TCCR1B = 0x00; //stop
TCNT1H = 0xB1; //setup
TCNT1L = 0xE0;
OCR1AH = 0x4E;
OCR1AL = 0x20;
OCR1BH = 0x4E;
OCR1BL = 0x20;
OCR1CH = 0x4E;
OCR1CL = 0x20;
ICR1H  = 0x4E;
ICR1L  = 0x20;
TCCR1A = 0x00;
TCCR1B = 0x02; //start Timer
}

#pragma interrupt_handler timer1_ovf_isr:iv_TIM1_OVF
void timer1_ovf_isr(void)
{
//TIMER1 has overflowed
TCNT1H = 0xB1; //reload counter high value
TCNT1L = 0xE0; //reload counter low value
}

//SPI initialize
// clock rate: 31250hz
void spi_init(void)
{
SPCR = 0xC3; //setup SPI
SPSR = 0x00; //setup SPI
}

#pragma interrupt_handler spi_stc_isr:iv_SPI_STC
void spi_stc_isr(void)
{
//byte in SPDR has been sent/received
}

//UART0 initialize
// desired baud rate: 57600
// actual: baud rate:62500 (7,8%)
// char size: 8 bit
// parity: Disabled
void uart0_init(void)
{
UCSR0B = 0x00; //disable while setting baud rate
UCSR0A = 0x00;
UCSR0C = 0x06;
UBRR0L = 0x03; //set baud rate lo
UBRR0H = 0x00; //set baud rate hi
UCSR0B = 0xF8;
}

#pragma interrupt_handler uart0_rx_isr:iv_USART0_RXC
void uart0_rx_isr(void)
{
//uart has received a character in UDR
}

#pragma interrupt_handler uart0_udre_isr:iv_USART0_UDRE
void uart0_udre_isr(void)
{
//character transferred to shift register so UDR is now empty
}

#pragma interrupt_handler uart0_tx_isr:iv_USART0_TXC
void uart0_tx_isr(void)
{
//character has been transmitted
}

//Comparator initialize
// trigger on: Falling output edge
void comparator_init(void)
{
ACSR = ACSR & 0xF7; //ensure interrupt is off before changing
ACSR = 0x8A;
}

#pragma interrupt_handler ana_comp_isr:iv_ANA_COMP
void ana_comp_isr(void)
{
//analog comparator compare event
}

//ADC initialize
// Conversion time: 208uS
void adc_init(void)
{
ADCSRA = 0x00; //disable adc
ADMUX = 0x00; //select adc input 0
ACSR  = 0x8A;
ADCSRA = 0x8E;
}

#pragma interrupt_handler adc_isr:iv_ADC
void adc_isr(void)
{
//conversion complete, read value (int) using...
// value=ADCL;            //Read 8 low bits first (important)
// value|=(int)ADCH << 8; //read 2 high bits and shift into top byte
}

#pragma interrupt_handler int0_isr:iv_INT0
void int0_isr(void)
{
//external interupt on INT0
}

//call this routine to initialize all peripherals
void init_devices(void)
{
//stop errant interrupts until set up
CLI(); //disable all interrupts
XDIV  = 0x00; //xtal divider
XMCRA = 0x00; //external memory
port_init();
timer0_init();
timer1_init();
spi_init();
uart0_init();
comparator_init();
adc_init();

MCUCR = 0x00;
EICRA = 0x00; //extended ext ints
EICRB = 0x00; //extended ext ints
EIMSK = 0x01;
TIMSK = 0x05; //timer interrupt sources
ETIMSK = 0x00; //extended timer interrupt sources
SEI(); //re-enable interrupts
//all peripherals are now initialized
}

//
void main(void)
{
init_devices();
//insert your functional code here...
}

[/size]

#pragma vector = TIMER0_COMP_vect
__interrupt void TC0_int_handler ( void )
{ ON_LED;
  BackgroundService();
  __enable_interrupt();
  InternalAdcService();
  MotorsService();
  FanControlService();
  OFF_LED;
}

#include <avr/io.h>
#include <avr/interrupt.h>

volatile uint8_t led2IsOn = 0;

int main(void)
{
  uint8_t led1IsOn = 0;

  // Конфигурируем порт на выход.
  DDRB |= (1 << DDB6) | (1 << DDB5);
  
  // Настраиваем порт на котором висит кнопка на вход.
  DDRE &= ~(1 << DDE6);
  PORTE |= (1 << PORTE6);
  // Прерывание по возрастающий фронту сигнала.
  EICRB = (1 << ISC61) | (1<< ISC60);

  sei(); // Глобальное разрешение прерываний.
  EIMSK |= (1 << INT6); // Разрешаем внешнее прерывание, заведенное на PORTE6.
  // Бесконечный цикл.
  while(1)
  {
    uint16_t i;

    // Задержка.
    for(i = 65535; i != 0; i--);
    if(led1IsOn)
    {
      led1IsOn = 0;
      PORTB &= ~(1 << PORTB5);  // Выключаем светодиод 1.
    }
    else
    {
      led1IsOn = 1;
      PORTB |= (1 << PORTB5);   // Включаем светодиод 1.
    }
  }
}

// Обработчик прерывания.
SIGNAL(SIG_INTERRUPT6)
{
  if(led2IsOn)
  {
    led2IsOn = 0;
    PORTB &= ~(1 << PORTB6);   // Выключаем светодиод 2.
  }
  else
  {
    led2IsOn = 1;
    PORTB |= (1 << PORTB6);   // Включаем светодиод 2.
  }
}