test.c

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/sleep.h>

#include <avr/eeprom.h>

#include <avr/pgmspace.h>

#include <util/delay.h>

// CPU: ATTiny44-20PU 8MHz

// =======================================================================

// Ein-/Ausgänge

// -----------------------------------------------------------------------

#define ENCODER_PORT      PORTB

#define ENCODER_DDR        DDRB

#define TASTER_PIN        PINB

#define AUSGANG_PORT      PORTA

#define AUSGANG_DDR        DDRA

#define AUSGANG_PIN        PINA

#define EIN_AUS          (1 << PA7)

// Schalt-Muster

// -----------------------------------------------------------------------

#define LO            0x00                // 0000 0000

#define HI            0xFF                // 1111 1111

#define SCHALT          0x3F                // 0011 1111

#define AKTIV          0x80                // 1000 0000

// LED-Muster

// -----------------------------------------------------------------------

unsigned char led_setzen[4] PROGMEM    = {0b0001, 0b0010, 0b0100, 0b1000};

unsigned char led_loeschen[5] PROGMEM  = {0b1110, 0b1101, 0b1011, 0b0111, 0b1111};

// Tastendruck

// -----------------------------------------------------------------------

#define REPEAT_MASK         (EIN_AUS)

#define REPEAT_START      250

#define REPEAT_NEXT        100

#define DELAY_RESET        500

#define DELAY_SEQUENZ      200

#define DELAY_VERZOEGERUNG    400

volatile uint8_t key_state;

volatile uint8_t key_press;

volatile uint8_t key_rpt;

// =======================================================================

// Timer-Routine

// -----------------------------------------------------------------------

ISR (TIM0_COMPA_vect)

{

  uint8_t i;

  static uint8_t ct0, ct1, rpt;

  i = key_state ^ ~AUSGANG_PIN;

  ct0 = ~(ct0 & i);

  ct1 = ct0 ^ (ct1 & i);

  i &= ct0 & ct1;

  key_state ^= i;

  key_press |= key_state & i;

  if((key_state & REPEAT_MASK) == 0)

  rpt = REPEAT_START;

  if(--rpt == 0)

  {

    rpt = REPEAT_NEXT;

    key_rpt |= key_state & REPEAT_MASK;

  }

}

ISR (PCINT0_vect)

{

}

// Tastendruck auswerten

// -----------------------------------------------------------------------

uint8_t get_key_press(uint8_t key_mask)

{

  cli();

  key_mask &= key_press;

  key_press ^= key_mask;

  sei();

  return key_mask;

}

// Ein-/Ausänge zuweisen

// -----------------------------------------------------------------------

void init()

{

  AUSGANG_DDR = SCHALT;                      // SCHALT = Ausgang

                                  // RESET = Eingang (Tri-State)

                                  // AKTIV = Eingang

  AUSGANG_PORT = AKTIV;                      // AKTIV = PullUp

  ENCODER_DDR = LO;                        // ENCODER = Eingang

  ENCODER_PORT = HI;                        // ENCODER = PullUp

  set_sleep_mode(SLEEP_MODE_PWR_DOWN);              // Schlafmodus definieren

  sleep_enable();                          // Schlafmodus aktivieren

  PCMSK0 = (1<<PA7);

  TCCR0A = (1<<WGM01);

  OCR0A = (uint8_t)(F_CPU / 64.0 * 1e-3 - 0.5);

  TCCR0B = (1<<CS01 | 1<<CS00);

  TIMSK0 = (1<<OCIE0A);

}

// Einschaltsequenz

// -----------------------------------------------------------------------

void einschalt(void)

{

  _delay_ms(DELAY_RESET);

  for (unsigned int a = 0; a < 4; a++)

  {

    AUSGANG_PORT |= pgm_read_word (& led_setzen[a]);

    _delay_ms(DELAY_SEQUENZ);

  }

  _delay_ms(DELAY_RESET);

  AUSGANG_PORT &= ~(pgm_read_word (& led_loeschen[4]));

  _delay_ms(DELAY_SEQUENZ);

}

// Ausschaltsequenz

// -----------------------------------------------------------------------

void ausschalt(void)

{

  AUSGANG_PORT |= pgm_read_word (& led_loeschen[4]);

  _delay_ms(DELAY_VERZOEGERUNG);

  for (unsigned int b = 3; b > 0; b--)

  {

    AUSGANG_PORT &= ~(pgm_read_word (& led_setzen[b]));

    _delay_ms(DELAY_SEQUENZ);

  }

  AUSGANG_PORT &= ~(pgm_read_word (& led_loeschen[4]));

}

// Power-down aktivieren

// -----------------------------------------------------------------------

void schlafen()

{

  TIMSK0 = 0;

  ausschalt();

  GIMSK = (1<<PCIE0);

  sleep_cpu();

  GIMSK = 0;

  TIMSK0 = (1<<OCIE0A);

}

// Hauptprogramm

// -----------------------------------------------------------------------

int main(void)

{

  uint8_t schlafen_ein = 0;

  init();                              // Startwerte setzen

  einschalt();

  sei();                              // alle Interrupt aktivieren

  for(;;)

  {

    if(get_key_press EIN_AUS)

    {

      schlafen_ein = !schlafen_ein;

    }

    if(schlafen_ein && !(key_state & EIN_AUS) && (AUSGANG_PIN & EIN_AUS))

    {

      schlafen();

    }

  }

}