main.c

#include <avr/io.h>

#include <util/delay.h>

#include <util/twi.h>

#include <stdint.h>

# define F_CPU 8000000UL

#define AN_SHIFT_PIN PB0

#define AN_SHIFT_PORT PORTB

#define AN_DATA_PIN PD7

#define AN_DATA_PORT PORTD

#define KA_SHIFT_PIN PB1

#define KA_SHIFT_PORT PORTB

#define KA_DATA_PIN PB2

#define KA_DATA_PORT PORTB

#define STORE_PIN PD6

#define STORE_PORT PORTD

#define RTC_ADDR 0b11010000

#define RTC_CTRL 0x0E

#define RTC_SECONDS 0x00

void annodeShift(uint8_t value){

  for(uint8_t b = 0; b < 8; b++){

    if(value & 1){

      AN_DATA_PORT |= _BV(AN_DATA_PIN);

    }else{

      AN_DATA_PORT &= ~_BV(AN_DATA_PIN);

    }

    AN_SHIFT_PORT |= _BV(AN_SHIFT_PIN);

    _delay_us(100);

    AN_SHIFT_PORT &= ~_BV(AN_SHIFT_PIN);

    value >>= 1;

  }

}

void kathodeShift(uint8_t value){

  for(uint8_t b = 0; b < 8; b++){

    if(value & 1){

      KA_DATA_PORT |= _BV(KA_DATA_PIN);

    }else{

      KA_DATA_PORT &= ~_BV(KA_DATA_PIN);

    }

    KA_SHIFT_PORT |= _BV(KA_SHIFT_PIN);

    _delay_us(100);

    KA_SHIFT_PORT &= ~_BV(KA_SHIFT_PIN);

    value >>= 1;

  }

}

void store(){

  STORE_PORT |= _BV(STORE_PIN);

  //_delay_us(10);

  STORE_PORT &= ~_BV(STORE_PIN);

}

void _twi_enable(){

  TWCR |= _BV(TWEN);

}

void ERROR(){

  annodeShift(0b00010000);

  kathodeShift(~(0b00000001));

  store();

}

void ERROR2(){

  annodeShift(0b00010000);

  kathodeShift(~(0b00000010));

  store();

}

void ERROR3(){

  annodeShift(0b00010000);

  kathodeShift(~(0b00000100));

  store();

}

void TWI_START_OK(){

  annodeShift(0b00000001);

  kathodeShift(~(0b00000001));

  store();

}

void ADDRESS_RTC_OK(){

  annodeShift(0b00000010);

  kathodeShift(~(0b00000001));

  store();

}

void REGISTER_RTC_OK(){

  annodeShift(0b00000100);

  kathodeShift(~(0b00000001));

  store();

}

void _twi_init(){

  TWBR = 0x20;

  TWSR &= ~_BV(TWPS0);

  TWSR &= ~_BV(TWPS1);

}

int _twi_start(){

  TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);

  while (!(TWCR & (1<<TWINT)));

  if ((TWSR & 0xF8) != TW_START)

    ERROR();

  else{

    TWI_START_OK();

    //_delay_ms(200);

  }

  return 1;

}

void _twi_stop(){

  TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);

}

void _twi_write(uint8_t slave){

    TWDR = (slave & ~1);

    TWCR = (1<<TWINT) | (1<<TWEN);

    while (!(TWCR & (1<<TWINT)));

    if ((TWSR & 0xF8) != TW_MT_SLA_ACK)

      ERROR();

    else{

      ADDRESS_RTC_OK();

      //_delay_ms(200);

    }

}

void _twi_read(uint8_t slave){

  TWDR = (slave | 1);

  TWCR = (1<<TWINT) | (1<<TWEN);

  while (!(TWCR & (1<<TWINT)));

  if ((TWSR & 0xF8) != TW_MR_SLA_ACK)

    ERROR();

  else

      ADDRESS_RTC_OK();

  if ((TWSR & 0xF8) == TW_MR_SLA_NACK)

    ERROR2();

  if ((TWSR & 0xF8) == TW_MR_ARB_LOST)

    ERROR3();

    //_delay_ms(200);

}

void _twi_send_ack(){

  TWCR = _BV(TWINT) | _BV(TWEN) | _BV(TWEA);

}

void _twi_send_nack(){

  TWCR = _BV(TWINT) | _BV(TWEN);

}

uint8_t _twi_rec(){

  while (!(TWCR & (1<<TWINT)));

  return TWDR;

}

void _twi_send(uint8_t data){

  TWDR = data;

  TWCR = (1<<TWINT) | (1<<TWEN);

  while (!(TWCR & (1<<TWINT)));

  if ((TWSR & 0xF8) != TW_MT_DATA_ACK)

    ERROR();

  else{

    REGISTER_RTC_OK();

    //_delay_ms(200);

  }

}

int main() {

  //init pins as outputs

      DDRB |= ((_BV(AN_SHIFT_PIN) | _BV(KA_SHIFT_PIN)) | _BV(KA_DATA_PIN));

      DDRD |= (_BV(AN_DATA_PIN) | _BV(STORE_PIN));

      DDRB |= _BV(PB6);

      PORTB &= ~_BV(PB6);

      annodeShift(0b00000000);

      kathodeShift(~(0b00000000));

      store();

      _delay_ms(100);

      _twi_init();

      _twi_start();

      _twi_write(RTC_ADDR);

      _twi_send(RTC_CTRL);

      _twi_send(0);

      _twi_stop();

      int count = 0;

      while(1){

          if(count >= 10){

            _twi_start();

            _twi_write(RTC_ADDR);

            _twi_send(RTC_SECONDS);

            _twi_start();

            _twi_read(RTC_ADDR);

            uint8_t secs = _twi_rec();

            _twi_send_nack();

            _twi_stop();

            annodeShift(0b00001000);

            kathodeShift(~secs);

            store();

            count = 0;

          }

          PORTB ^= _BV(PB6);

          count ++;

          _delay_ms(200);

      }

}

void symbole(){

  //init pins as outputs

    DDRB |= ((_BV(AN_SHIFT_PIN) | _BV(KA_SHIFT_PIN)) | _BV(KA_DATA_PIN));

    DDRD |= (_BV(AN_DATA_PIN) | _BV(STORE_PIN));

    int symb[2][5];

    //herz

    symb[0][0] = 0b00000110;

    symb[0][1] = 0b00001001;

    symb[0][2] = 0b00010010;

    symb[0][3] = symb[0][1];

    symb[0][4] = symb[0][0];

    //smile

    /*

    symb[0][0] = 0b00001000;

    symb[0][1] = 0b00010010;

    symb[0][2] = 0b00010000;

    symb[0][3] = symb[0][1];

    symb[0][4] = symb[0][0];

  */

    //pfeil

    symb[1][0] = 0b00000100;

    symb[1][1] = symb[1][0];

    symb[1][2] = 0b00010101;

    symb[1][3] = 0b00001110;

    symb[1][4] = symb[1][0];

    int count = 0;

    int sidx = 0;

    while(1){

      for(int i = 0; i < 5; i++){

        annodeShift(symb[sidx][i]);

        kathodeShift(~(1 << i));

        store();

        _delay_us(10);

        if(count >= 1000){

          if(sidx == 0){

            sidx = 1;

          }else{

            sidx = 0;

          }

          count = 0;

        }

        count ++;

      }

    }

    //while(1){

      //PORTB |= _BV(BLINKEPORT);

      //_delay_ms(1000);

        //PORTB &= ~_BV(BLINKEPORT);

      //_delay_ms(1000);

    //}

}