#include <avr/io.h>          // (1)
#include <avr/interrupt.h>

#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
// #define F_CPU 3686400UL     /* Quarz mit 3.6864 Mhz */
#define F_CPU 1000000UL     /* Quarz mit 3.6864 Mhz */
#endif

#include <util/delay.h>
#include <stdint.h>


// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
  *target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
  *target &= ~(1<<bit);
};

///* -----------------------------------------------------------------------------------------------------------*/
///*! Eine schnelle MEM->SPI Blocksende Routine mit optimierungen auf Speed.
// * \param  buffer    Zeiger auf den Puffer der gesendet werden soll.
// * \param  Datalenght  Anzahl der Bytes die gesedet werden soll.
// */
///* -----------------------------------------------------------------------------------------------------------*/
//void SPI_FastMem2Write( unsigned char * buffer, unsigned int Datalenght )
//{
//  unsigned int Counter = 0;
//  unsigned char data;
//
//  // erten Wert senden
//  SPDR = buffer[ Counter++ ];
//  while( Counter < Datalenght )
//  {
//    // Wert schon mal in Register holen, schneller da der Wert jetzt in einem Register steht und nicht mehr aus dem RAM geholt werden muss
//    // nachdem das senden des vorherigen Wertes fertig ist,
//    data = buffer[ Counter ];
//    // warten auf fertig
//    while(!(SPSR & (1<<SPIF)));
//    // Wert aus Register senden
//    SPDR = data;
//    Counter++;
//  }
//  while(!(SPSR & (1<<SPIF)));
//  return;
//}
uint8_t spi_transfer(uint8_t data) {
  USIDR = data;
  USISR = _BV(USIOIF); // clear flag

  while ( (USISR & _BV(USIOIF)) == 0 ) {
    USICR = (1<<USIWM0)|(1<<USICS1)|(1<<USICLK)|(1<<USITC);
  }
  return USIDR;
}

void pulse_sck()
{
  PORTB |= ( 1 << PB2 );
  _delay_ms(10);        // Eine Sekunde +/-1/10000 Sekunde warten...
  PORTB ^= ( 1 << PB2 );
}

void print_data(uint16_t data)
{
  BIT_CLEAR(&PORTB, PB4);
  _delay_ms(100);
  BIT_SET(&PORTB, PB4);

  for(int i=0; i<16; i++)
  {
    if(data<<i & 0b1000000000000000)
      BIT_SET(&PORTB, PB4);
    pulse_sck();
    BIT_CLEAR(&PORTB, PB4);
    //PORTB &= (1 << PB4);
  }
  //pulse_sck();


  BIT_CLEAR(&PORTB, PB3);
  _delay_ms(50);
  BIT_SET(&PORTB, PB3);
}


int main (void) {

  //DDRB |= _BV(PB4); // as output (latch)
  //DDRB |= _BV(PB6); // as output (DO) - data out
  //DDRB |= _BV(PB7); // as output (USISCK) - clock
  _delay_ms(1000);
  // DDRB   = (1<<PB0) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5);  // PB0 an PORTB als Ausgang setzen
  DDRB   = 0xFF;


  BIT_CLEAR(&PORTB, PB5);
  _delay_ms(500);
  BIT_SET(&PORTB, PB5);
  BIT_CLEAR(&PORTB, PB5);
  _delay_ms(500);
  BIT_SET(&PORTB, PB5);
  //DDRB  &= ~_BV(PB5);     // as input (DI) - data in
  //PORTB |= _BV(PB5);      // pullup on (DI)

  while( 1 )
  {                // Endlosschleife

    _delay_ms(1000);        // Eine Sekunde +/-1/10000 Sekunde warten...


    // char data = 0b10101010;
    // char data = 0b11001101;
    // char data = 0b10101100;
    //
    //
    //
    //
    //
    //
    //
    //

    print_data(0x0001);
    print_data(0x0002);
    print_data(0x0004);
    print_data(0x0008);
    print_data(0x000F);
    print_data(0xFF00);
    print_data(0x00FF);
    print_data(0xFF00);
    print_data(0x00FF);
    print_data(0xFF00);

    uint16_t data;
    for(int i=0; i<16; i++)
      print_data(1<<i);
    for(int i=0; i<16; i++)
      print_data(0X8000>>i);

    /*

    char data = 1;
    for(; data<128; data++)
    {
      // clear register (reset)
      print_data(data);
      _delay_ms(1000);
    }

    */

    // spi_transfer(0x10101010b);


  }
  return 0;
}