encoder4.c

/************************************************************************/

/*                                    */

/*            Commodore 64 Red Edition            */

/*            Encoder 4 - SD2IEC ID              */

/*                                    */

/************************************************************************/

#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 ENCODER_A        (PINB & (1 << PB0))

#define ENCODER_B        (PINB & (1 << PB1))

#define TASTER          (1 << PB2)

#define EIN_AUS          (1 << PA7)

// Schalt-Muster

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

#define LO            0x00                // 0000 0000

#define HI            0xFF                // 1111 1111

#define SCHALT          0x3F                // 0011 1111

#define RESET          0x40                // 0100 0000

#define AKTIV          0x80                // 1000 0000

#define ID_LO          0x30                // 0011 0000

#define ID_8          0x30                // 0011 0000

#define ID_9          0x20                // 0010 0000

#define ID_10          0x10                // 0001 0000

#define ID_11          0x00                // 0000 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         (TASTER)

#define REPEAT_MASK2         (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;

volatile uint8_t key_state2;

volatile uint8_t key_press2;

volatile uint8_t key_rpt2;

volatile int8_t enc_delta;

volatile int8_t encoder      = 0;

volatile int8_t encoderwert    = 0;

volatile int16_t timeCount    = 0;

static int8_t last;

// Variablen/EEPROM

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

uint8_t eeprom_sdid EEMEM    = 1;                // 1.Byte im EEPROM für ID-Wert

uint8_t eeprom_encoderid EEMEM  = 2;                // 2.Byte im EEPROM für ENCODER-Wert

uint8_t sdid;

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

// Timer-Routine

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

ISR (TIM0_COMPA_vect)

{

  int8_t neu, diff;

  neu = 0;

  if(ENCODER_A)

    neu = 3;

  if(ENCODER_B)

    neu ^= 1;

  diff = last - neu;

  if(diff & 1)

  {

    last = neu;

    enc_delta += (diff & 2) - 1;

  }

  uint8_t i;

  static uint8_t ct0, ct1, rpt;

  i = key_state ^ ~TASTER_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;

  }

  uint8_t h;

  static uint8_t ct2, ct3, rpt2;

  h = key_state2 ^ ~AUSGANG_PIN;

  ct2 = ~(ct2 & h);

  ct3 = ct2 ^ (ct3 & h);

  i &= ct2 & ct3;

  key_state2 ^= h;

  key_press2 |= key_state2 & h;

  if((key_state2 & REPEAT_MASK2) == 0)

    rpt2 = REPEAT_START;

  if(--rpt2 == 0)

  {

    rpt2 = REPEAT_NEXT;

    key_rpt2 |= key_state2 & REPEAT_MASK2;

  }

    if(timeCount > 0) timeCount--;

}

// 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);

}

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;

}

uint8_t get_key_press2(uint8_t key_mask2)

{

  cli();

  key_mask2 &= key_press2;

  key_press2 ^= key_mask2;

  sei();

  return key_mask2;

}

uint8_t get_key_rpt(uint8_t key_mask)

{

  cli();

  key_mask &= key_rpt;

  key_rpt ^= key_mask;

  sei();

  return key_mask;

}

uint8_t get_key_short(uint8_t key_mask)

{

  cli();

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

}

// Encoder auswerten

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

int8_t encode_read(void)

{

  int8_t val;

  cli();

  val = enc_delta;

  enc_delta = val & 1;

  sei();

  return val >> 1;

}

// Prüfen ob Encoder gedreht wurde

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

int8_t encode_read_timeout(void)

{

  int8_t tmp = encode_read();

  if(tmp != 0) timeCount = 3000;

  return tmp;

}

// LED setzen

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

void led_setzen_loeschen(uint8_t led_ein_aus)

{

  AUSGANG_PORT |= pgm_read_word (& led_setzen[led_ein_aus]);    // Aktiven LED-PIN setzen

  AUSGANG_PORT &= ~(pgm_read_word (& led_loeschen[led_ein_aus]));  // Inaktive LED-PIN löschen 

}

// SD2IEC ID-Wert setzen

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

void sd_id(int8_t sdid)

{

  AUSGANG_PORT &= ~(ID_LO);                    // Alle ID-PIN auf LO setzen

  AUSGANG_PORT |= (sdid);                      // ID-PIN setzen

}

// EPROM-Werte auslesen

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

void eeprom_var(void)

{

  if(eeprom_read_byte(&eeprom_sdid) != HI)

  {

    sdid = eeprom_read_byte(&eeprom_sdid);            // KERNAL-Wert aus EEPROM auslesen

    encoder = eeprom_read_byte(&eeprom_encoderid);        // ENCODER-Wert aus EEPROM auslesen

    encoderwert = encoder;

    sd_id(sdid);                        // gespeicherten KENRAL aktivieren

  }

}

// SD2IEC-Reset durchführen

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

void reset()

{

  AUSGANG_DDR |= (RESET);                      // ResetPIN = Ausgang

  AUSGANG_PORT &= ~(RESET);                    // ResetPIN = LO

  _delay_ms(DELAY_RESET);                      // Warten

  AUSGANG_DDR &= ~(RESET);                    // ResetPIN = Eingang

}

// 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);

}

// Encoder initialisieren

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

void encode_init(void)

{

  int8_t neu;

  neu = 0;

  if(ENCODER_A)

    neu = 3;

  if(ENCODER_B)

    neu ^= 1;

  last = neu;

  enc_delta = 0;

  TCCR0A = (1<<WGM01);

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

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

  TIMSK0 = (1<<OCIE0A);

}

// Ausschaltsequenz

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

void ausschalt(void)

{

  encoder = encoderwert;

  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

  eeprom_var();                          // EEPROM-Werte auslesen

  einschalt();                          // LED Einschaltsequenz starten

  encode_init();                          // ENCODER initialisieren

  sei();                              // alle Interrupt aktivieren

  for(;;)

  {

    ADCSRA &= !(1<<ADEN);                    // ADC deaktivieren

    ACSR = 0x80;                        // Analogcomperator deaktivieren

    if(get_key_press2 EIN_AUS)

    {

      schlafen_ein = !schlafen_ein;

    }

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

    {

      schlafen();

    }

    encoder += encode_read_timeout();              // ENCODER-Wert auslesen

    if (timeCount == 0) encoder = encoderwert;          // Nach Zeit zurück zum Ausgangswert

    if (encoder < 1) encoder = 0;                // ENCODER-Wert darf nicht kleiner als 0

    if (encoder > 2) encoder = 3;                // und größer als 3 werden

    switch(encoder)

    {

      case 0:

        led_setzen_loeschen(encoder);

        if (get_key_short(TASTER))              // bei kurzem Tastendruck

        {

          sd_id(ID_8);

          encoderwert = encoder;

          reset();

        }

        if(get_key_long(TASTER))              // bei langen Tastendruck

        {

          sd_id(ID_8);

          encoderwert = encoder;

          eeprom_write_byte(&eeprom_sdid, ID_8);      // KERNAL-Wert in EEPROM speichern

          eeprom_write_byte(&eeprom_encoderid, encoder);  // ENCODER-Wert in EEPROM speichern

          reset();

        }

        break;

      case 1:

        led_setzen_loeschen(encoder);

        if (get_key_short(TASTER))

        {

          sd_id(ID_9);

          encoderwert = encoder;

          reset();

        }

        if(get_key_long(TASTER))

        {

          sd_id(ID_9);

          encoderwert = encoder;

          eeprom_write_byte(&eeprom_sdid, ID_9);

          eeprom_write_byte(&eeprom_encoderid, encoder);

          reset();

        }

        break;

      case 2:

        led_setzen_loeschen(encoder);

        if (get_key_short(TASTER))

        {

          sd_id(ID_10);

          encoderwert = encoder;

          reset();

        }

        if(get_key_long(TASTER))

        {

          sd_id(ID_10);

          encoderwert = encoder;

          eeprom_write_byte(&eeprom_sdid, ID_10);

          eeprom_write_byte(&eeprom_encoderid, encoder);

          reset();

        }

        break;

      case 3:

        led_setzen_loeschen(encoder);

        if (get_key_short(TASTER))

        {

          sd_id(ID_11);

          encoderwert = encoder;

          reset();

        }

        if(get_key_long(TASTER))

        {

          sd_id(ID_11);

          encoderwert = encoder;

          eeprom_write_byte(&eeprom_sdid, ID_11);

          eeprom_write_byte(&eeprom_encoderid, encoder);

          reset();

        }

        break;

    }

  }

}