Led PWM in Stufen

#include <stdint.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#ifndef F_CPU

#define F_CPU           1000000                   // processor clock frequency

#warning kein F_CPU definiert

#endif

 #define true 1

#define false 0

#define STK500 false

#include <inttypes.h>

#include <avr/io.h>

#include <util/delay.h>

#include <avr/pgmspace.h>

#define KEY_DDR         DDRD

#define KEY_PORT        PORTD

#define KEY_PIN         PIND

#define KEY0            7

#define KEY1            6

#define KEY2            5

#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2

#define REPEAT_START    50                        // after 500ms

#define REPEAT_NEXT     20                        // every 200ms

#define LED_DDR         DDRC

#define LED_PORT        PORTC

#define LED0            3

#define LED1            4

#define LED2            5

volatile uint8_t key_state;                                // debounced and inverted key state:

                                                  // bit = 1: key pressed

volatile uint8_t key_press;                                // key press detect

volatile uint8_t key_rpt;                                  // key long press and repeat

 // global variables

uint16_t pwmtable_8A[4]   PROGMEM = {0, 16, 64, 255};

int16_t tmp;

// long delays

void my_delay(uint16_t milliseconds) {

    for(; milliseconds>0; milliseconds--) _delay_ms(1);

}

// 8-Bit PWM with only 4 different settings

ISR( TIMER0_OVF_vect )                            // every 10ms

{

  static uint8_t ct0, ct1, rpt;

  uint8_t i;

  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms

  i = key_state ^ ~KEY_PIN;                       // key changed ?

  ct0 = ~( ct0 & i );                             // reset or count ct0

  ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1

  i &= ct0 & ct1;                                 // count until roll over ?

  key_state ^= i;                                 // then toggle debounced state

  key_press |= key_state & i;                     // 0->1: key press detect

  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function

     rpt = REPEAT_START;                          // start delay

  if( --rpt == 0 ){

    rpt = REPEAT_NEXT;                            // repeat delay

    key_rpt |= key_state & REPEAT_MASK;

  }

}

///////////////////////////////////////////////////////////////////

//

// check if a key has been pressed. Each pressed key is reported

// only once

//

uint8_t get_key_press( uint8_t key_mask )

{

  cli();                                          // read and clear atomic !

  key_mask &= key_press;                          // read key(s)

  key_press ^= key_mask;                          // clear key(s)

  sei();

  return key_mask;

}

///////////////////////////////////////////////////////////////////

//

// check if a key has been pressed long enough such that the

// key repeat functionality kicks in. After a small setup delay

// the key is reported beeing pressed in subsequent calls

// to this function. This simulates the user repeatedly

// pressing and releasing the key.

//

uint8_t get_key_rpt( uint8_t key_mask )

{

  cli();                                          // read and clear atomic !

  key_mask &= key_rpt;                            // read key(s)

  key_rpt ^= key_mask;                            // clear key(s)

  sei();

  return key_mask;

}

///////////////////////////////////////////////////////////////////

//

uint8_t get_key_short( uint8_t key_mask )

{

  cli();                                          // read key state and key press atomic !

  return get_key_press( ~key_state & key_mask );

}

///////////////////////////////////////////////////////////////////

//

uint8_t get_key_long( uint8_t key_mask )

{

  return get_key_press( get_key_rpt( key_mask ));

}

///////////////////////////////////////////////////////////////////

int main( void )

{ 

    KEY_DDR &= ~ALL_KEYS;                // konfigure key port for input

    KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

    TCCR0 = (1<<CS02)|(1<<CS00);      // divide by 1024

    TIMSK = 1<<TOIE0;        // enable timer interrupt

  LED_PORT = 0xFF;

  LED_DDR = 0xFF;                    

  int16_t a;

    int16_t step_time=100;

   int16_t tmp;

#if STK500

    TCCR1A = 0xC1;          // inverted PWM on OC1A, 8 Bit Fast PWM

#else

    TCCR1A = 0x81;          // non-inverted PWM on OC1A, 8 Bit Fast PWM

#endif

    TCCR1B = 0x08;

    TCCR1B &= ~0x7;         // clear clk setting

    TCCR1B |= 2;  

  while(1){

 /*   if( get_key_short( 1<<KEY1 ))

  {DDRB |= (1<<PB1); 

    OCR1A =  pgm_read_word(pwmtable_8A+1);

      my_delay(100);

  }

    if( get_key_s( 1<<KEY1 ))

    {

   DDRB |= (1<<PB1); 

    OCR1A =  pgm_read_word(pwmtable_8A+3);

      my_delay(100);

    }

 */

                                                  // single press and repeat

    if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){

      uint8_t i ;

     DDRB |= (1<<PB1);

       i++;

       OCR1A =  pgm_read_word(pwmtable_8A+i);

      _delay_ms(100);

    }

  }

}

OCR1A =  pgm_read_word(pwmtable_8A+i);