ATmega32A; 595; 165 Code Hilfe benötigt

[Martin K. (thereallife)]

Hallo Leute,
ich habe mich heute mal an eine funktion für die 74hc595er und den 
74hc165 gearbeitet.
Meine 595er Funktion funktioniert nicht wirklich, Die LED's gehen zwar 
in einem sich wiederholenden Schema an und aus, aber nicht so wie 
eigentlich gedacht ( es ist reiner Blödsinn was die einzeigen aber es 
ist halt fast immer wieder das gleiche ) von daher denke ich das da 
irgendwo nen Denkfehler oder sowas drin steckt.

Hier erstmal der Code

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
////////////////////////////////////////////////////////////////////
#ifndef MCU             
#define MCU  atmega32
#endif
////////////////////////////////////////////////////////////////////
#ifndef F_CPU          
#define F_CPU 8000000UL
#endif
////////////////////////////////////////////////////////////////////
#define DATA_PIN      PA1
#define DATA_PORT      PORTB
#define DATA_DDR      DDRB
///////
#define DATA_high()      (DATA_PORT |= _BV(DATA_PIN))
#define DATA_low()      (DATA_PORT &= ~_BV(DATA_PIN))
////////////////
#define RCLOCK_PIN      PA0
#define RCLOCK_PORT      PORTB
#define RCLOCK_DDR      DDRB
///////
#define RCLOCK_high()    (RCLOCK_PORT |= _BV(RCLOCK_PIN))
#define RCLOCK_low()    (RCLOCK_PORT &= ~_BV(RCLOCK_PIN))
////////////////
#define CLOCK_PIN      PA2
#define CLOCK_PORT      PORTB
#define CLOCK_DDR      DDRB
///////
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
////////////////////////////////


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

void InitShiftOut()
{
  RCLOCK_DDR |= _BV(RCLOCK_PIN);
  CLOCK_DDR |= _BV(CLOCK_PIN);
  DATA_DDR |= _BV(DATA_PIN);
}

void Pulse595Clock()
{
  CLOCK_high();
  _delay_ms(200);
  CLOCK_low();
  _delay_ms(200);
}

void Pulse595Rclock()
{
  RCLOCK_high();
  _delay_ms(20);
  RCLOCK_low();
  _delay_ms(20);
}

void ShiftOut(uint8_t data)
{
  for (uint8_t i =0; i<8; i++)
  {
    if(data & 0b10000000)
    {
      DATA_high();
    }
    else
    {
      DATA_low();
    }
    Pulse595Clock();
    data=data<<1;   
  }
  Pulse595Rclock();
}


int main(void)
{
  uint8_t led_pattern[8]={
    0b00000001,
    0b00000010,
    0b00000100,
    0b00001000,
    0b00010000,
    0b00100000,
    0b01000000,
    0b10000000,
    };
  InitShiftOut();
  while(1) 
  {
    for(uint8_t i=0; i<8; i++)
    {
      ShiftOut(led_pattern[i]);
      _delay_ms(200);
    }
  }
}

Als ich den Fehler nicht gefunden habe dachte ich mir ich bastel mal die 
funktion für die 165er um danach einen neuen Blick auf die 595er 
funktion zu bekommen (leider erfolglos) Den Code konnte ich nicht testen 
da die 595er funktion ja noch nicht läuft...
Aber vielleicht kann ihn ja hier jmd bei der Gelegenheit gleich mal 
durchchecken ob ich da auch Fehler drin habe.

#include <avr/io.h>
#include <util.delay.h>


#define IDATA_PIN    PD2
#define IDATA_PORT    PORTD
#define IDATA_DDR    DDRD
#define IDATA_read()  (PIND & _BV(IDATA_PIN))
////////////////////////////
#define ICLOCK_PIN    PD1 // CLK LOW->HIGH FLanke, pro Flanke wird ein bit herrausgeschoben.
#define ICLOCK_PORT    PORTD
#define ICLOCK_DDR    DDRD
#define ICLOCK_high()  ICLOCK_PORT |= _BV(ICLOCK_PIN)
#define ICLOCK_low()  ICLOCK_PORT &= ~_BV(ICLOCK_PIN)
////////////////////////////
#define PARALLEL_PIN  PD0
#define PARALLEL_PORT  PORTD
#define PARALLEL_DDR  DDRD
#define PARALLEL_high()  IRCLOCK_PORT |= _BV(IRCLOCK_PIN)
#define PARALLEL_low()  IRCLOCK_PORT &= ~_BV(IRCLOCK_PIN)
////////////////////////////


void InitShiftIn()
{
  PARALLEL_DDR |= _BV(IRCLOCK_PIN);
  ICLOCK_DDR |= _BV(ICLOCK_PIN);
  IDATA_DDR &= ~_BV(IDATA_PIN);
  IDATA_PORT |= _BV(IDATA_PIN);
}


// Clock Puls kommt nach dem auslesn des Pins
void Pulse165Parallel()
{
  PARALLEL_high();
  PARALLEL_low();
}
void Pulse165Clock()
{
  ICLOCK_high();
  ICLOCK_low();
}
int ShiftIn()
{
  ICLOCK_high()
  Pulse165Parallel();
  for (unsigned char i = 0; i < 8; i++)
  {
    var <<= 1;
    if (IDATA_read())
    var = | 0x01;
    Pulse165Clock();
  }
}



int main(void)
{
  uint8_t var;
    while(1)
    {
        ShiftIn();
    }
}

Ich danke euch im Vorfeld schon einmal für eure Hilfe.

PS: beide Code sind bei mir in verschiedenen Projekten, nur damit ihr 
euhc nicht wundert warum die includes doppelt sind etc

Liebe Grüße
Martin

[Karl H. (kbuchegg)]

Der 595 Code ist in Ordnung.
Vielleicht hast du ja beim physikalischen Anschluss Leitungen 
vertauscht?

[Martin K. (thereallife)]

Also irgendwas stimmt da nicht...
ich hab die schaltung nochmal und nochmal und nochmal umgebaut...
immer das selbe

Ich hatte den PORTC spaßeshalber mal ausprobiert, und davor von meinem 
arduino prototypen die 595er kette benutzt (10x595).
(da gings auch nicht)

Als ich wieder auf den einzelnen umgestiegen bin und den code noch nicht 
geändert hatte (von 80 wiederholungen auf 8)
gingen plötzlich alle LEDs an und nacheinander aus (Q1->Q7)
WEnn ich den code wieder auf 8 ändere passiert das nicht und die leds 
bleiben einfach aus...

Ich versteh es nicht grrr

hier nochmal der minimal abgeänderte Code. Vielleicht fällt jmd  ja doch 
was auf

#include <avr/io.h>
#include <avr/interrupt.h>
////////////////////////////////////////////////////////////////////
#ifndef MCU             
#define MCU  atmega32
#endif
////////////////////////////////////////////////////////////////////
#ifndef F_CPU
#define F_CPU 8000000UL
#endif
////////////////////////////////////////////////////////////////////
#include <util/delay.h>
////////////////////////////////////////////////////////////////////
#define DATA_PIN      PC0
#define DATA_PORT      PORTC
#define DATA_DDR      DDRC
///////
#define DATA_high()      (DATA_PORT |= _BV(DATA_PIN))
#define DATA_low()      (DATA_PORT &= ~_BV(DATA_PIN))
////////////////
#define RCLOCK_PIN      PC2
#define RCLOCK_PORT      PORTC
#define RCLOCK_DDR      DDRC
///////
#define RCLOCK_high()    (RCLOCK_PORT |= _BV(RCLOCK_PIN))
#define RCLOCK_low()    (RCLOCK_PORT &= ~_BV(RCLOCK_PIN))
////////////////
#define CLOCK_PIN      PC1
#define CLOCK_PORT      PORTC
#define CLOCK_DDR      DDRC
///////
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
////////////////////////////////


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

void InitShiftOut()
{
  RCLOCK_DDR |= _BV(RCLOCK_PIN);
  CLOCK_DDR |= _BV(CLOCK_PIN);
  DATA_DDR |= _BV(DATA_PIN);
}

void Pulse595Clock()
{
  CLOCK_high();
  _delay_ms(20);
  CLOCK_low();
  _delay_ms(20);
}

void Pulse595Rclock()
{
  RCLOCK_high();
  _delay_ms(20);
  RCLOCK_low();
  _delay_ms(20);
}

void ShiftOut(uint8_t data)
{
  for (uint8_t i =0; i<80; i++)
  {
    if(data & 0b10000000)
    {
      DATA_high();
    }
    else
    {
      DATA_low();
    }
    Pulse595Clock();
    data=data<<1;   
    DATA_low();
  }
  Pulse595Rclock();
}


int main(void)
{
  uint8_t led_pattern[8]={
    0b00000001,
    0b00000010,
    0b00000100,
    0b00001000,
    0b00010000,
    0b00100000,
    0b01000000,
    0b10000000,
    };
  InitShiftOut();
  while(1) 
  {
    for(uint8_t i=0; i<2; i++)
    {
      ShiftOut(led_pattern[i]);
      _delay_ms(200);
    }
  }
}

[Martin K. (thereallife)]

das i<2 war übrigens auch mit absicht,
Wollte statt der schleife erstmal schauen ob wenigstens irgendwas 
passiert...

[Karl H. (kbuchegg)]

Projektoptionen korrekt eingestellt?

So etwas

#ifndef MCU             
#define MCU  atmega32
#endif

ist zb. gar kein gute Idee.
MCU muss von er IDE dem Compiler mitgegeben werden. Wenn nicht, dann ist 
das ein Fehler und sollte nicht vom Source Code eigenmächtig korrigiert 
werden. Wenn es da einen Fehler gibt, dann ist die korrekte Reaktion des 
Progammierers in den Projekt-Optionen nachzusehen, warum das nicht 
korrekt gesetzt ist.

Es muss irgendwas im Umfeld des Programms sein. Der Code an sich ist in 
Ordnung. Was ich allerdings von hier nicht prüfen kann, das ist ob deine 
Projektoptionen richtig sind, ob du das richtige HEX File auf den 
Controller brennst, ob deine Leitungen zm 595 korrekt verdrahtet sind, 
ob sie am richtigen Port sind, etc. etc.

Irgendwas in deinem Umfeld passt nicht.
Dann kannst ja auch mal folgendes probieren um zu sehen, dass dein 
Programm (aus welchem Grund auch immer) nicht das tut, was du 
programmiert hast: Häng ein paar LED direkt am 595 an die 595 Eingänge 
für Data, Clock und RClock. Dann machst du deine Delays mal etwas länger 
(so ca. 1 Sekunde wird gut funktionieren). Was du an den LED sehen 
müsstest, das ist wie sich die Pegel verändern. Wenn du da noch 
verschiedenfarbige LED nimmst, dann ist auch die Verwechslungsgefahr der 
Leitungen kaum gegeben. Zb: Grün für Data, Gelb für Clock, Rot für 
RClock.
Das Muster kennst du ja, in dem die Dinge passieren müssten:
Zuerst nimmt die Datenleitung ihren gewünschten Wert an. Die grüne LED 
geht als entweder an oder aus, je nachdem ob ein 0 Bit oder ein 1 Bit 
eingetaktet werden soll.
Danach muss die Clock Leitung (Gelbe LED) auf High gehen und wieder auf 
Low. Die gelbe LED muss also einmalig aufleuchten.
Das ganze passiert 8 mal, für alle 8 Datenbits
Sind alle 8 Bits auf die Art eingetaktet, dann kommt die RCLock Leitung 
einmalig auf High und wieder zurück auf Low. Die rote LED leuchtet also 
entsprechend auf und wird wieder dunkel.
Und danach sind die 8 eingetakteten Bits an den Ausgängen des 595.

Dein Programm macht genau das. Daher ist nicht der C-Code Schuld, 
sondern irgendetwas anderes. Ich würde ganz ehrlich 3 verschiedenfarbige 
LED direkt an die Pins vom 595 hängen und erst mal nachsehen, ob nicht 
irgendwo Leiterbahnunterbrechungen, schlechte Kontake am Steckbrett, 
gebrochene Kabel oder dgl. vorliegt. Ruhig auch mal das eine Beinchen 
von der LED direkt an den Pin des 595 halten, nicht das ausgerechnet 
dieser Pin im Steckbrett schlechten Kontakt hat, die LED am Steckbrett 
noch brav mitblinkt aber die Leitung zum eigentlichen IC unterbrochen 
ist.
Wenn du dir die Delays lang genug machst, du kannst die so lang machen 
wie du willst, dann musst du mit den LED problemlos verfolgen können, 
wie sich die 8 Bits in den 595 hineintakten und zum Schluss auf die 
Ausgänge durchgeschaltet werden. Das ist alles kein Hexenwerk und gut zu 
verfolgen.

[Martin K. (thereallife)]

Hab das ganze mal aufgebaut, und statt dem led_pattern habe ich dem 
ShiftOut aufruf einfach den wert 01010101 gegeben.

folgendes Passiert

clock pin an
clock pin aus

clock pin an & data pin an
clock pin aus
datapin aus & clock pin an

clock pin an
clock pin aus

clck pin an
clock pin aus

clock pin an
clockpin aus

clock pin an
clock pin aus

clock pin und rclock pin an
clock pin aus
rclock pin aus
data pin an
data pin aus

und von vorne

haut also nicht ganz hin...
die ersten 2 zeilen stimmen,
der rest nicht und warum er am ende auch nochmal den data pin an und aus 
schaltet ist mir auch nen rätsel...

[Karl H. (kbuchegg)]

Mach die zb auch hier mal

....
    DATA_low();
  }
  Pulse595Rclock();
...

einen entsprechenden Delay dazwischen ....

    DATA_low();
  }
  _delay_ms( 200 );
  Pulse595Rclock();
...

... damit du auch hier die Reihenfolgen sehen kannst. Auch zwischen 
Daten-Setzen und Clock Puls würde ich einen Delay einbauen.
An deinen LED kann es nie sein, dass 2 LED gleichzeitig ihren Status 
wechseln. Laut Programm passiert das auch nicht, allerdings sind die 
Zeitunterschiede für dich als Mensch zu kurz, als das du das mit freiem 
Auge beurteilen kannst -> delays einfügen hilft dir als Mensch.

Sollte es trotzdem noch dazu kommen, dass 2 LED gleichzeitig ihren 
Status ändern, dann hast du ev. irgendwo einen Kurzschluss.

PS: Bist du jetzt eigentlich immer noch am PORT C?
Wenn ja: Das JTAG hast du per Fuse abgeschaltet? Wenn nicht, dann 
funktionieren einige Pins wegen des JTAG Interfaces nicht so, wie sie 
sollten. Also unbedingt abschalten (Fuse: JTAGEN)

[Martin K. (thereallife)]

und nochmal :D

clock pin an
clock pin aus

data pin an
clock pin an
clock pin aus
data pin aus

clock pin an
clock pin aus

data pin an
clock pin an
clock pin aus
data pin aus

clock pin an
clock pin aus

data pin an
clock pin an
clock pin aus
data pin aus

clock pin an
cloc pin aus

data pin an
clock pin an
clock pin aus
data pin aus

rclock pin an
rclock pin aus

Stimmt jetzt also, ich werde mal auf die suche gehen warum der 595er das 
nicht mag, hab den allerdings schon 3mal ausgetauscht und die schaltung 
schon 2 mal neu positioniert... Das Steckbrett hab ich auhc gestern erst 
gekauft...
Ist mir also alles ein Rätsel...

Hier nochmal der Code

#include <avr/io.h>
#include <avr/interrupt.h>
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
#ifndef F_CPU
#define F_CPU 1000000UL
#endif
////////////////////////////////////////////////////////////////////
#include <util/delay.h>
////////////////////////////////////////////////////////////////////
#define DATA_PIN      PC0
#define DATA_PORT      PORTC
#define DATA_DDR      DDRC
///////
#define DATA_high()      (DATA_PORT |= _BV(DATA_PIN))
#define DATA_low()      (DATA_PORT &= ~_BV(DATA_PIN))
////////////////
#define RCLOCK_PIN      PC2
#define RCLOCK_PORT      PORTC
#define RCLOCK_DDR      DDRC
///////
#define RCLOCK_high()    (RCLOCK_PORT |= _BV(RCLOCK_PIN))
#define RCLOCK_low()    (RCLOCK_PORT &= ~_BV(RCLOCK_PIN))
////////////////
#define CLOCK_PIN      PC1
#define CLOCK_PORT      PORTC
#define CLOCK_DDR      DDRC
///////
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
////////////////////////////////


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

void InitShiftOut()
{
  RCLOCK_DDR |= _BV(RCLOCK_PIN);
  CLOCK_DDR |= _BV(CLOCK_PIN);
  DATA_DDR |= _BV(DATA_PIN);
}

void Pulse595Clock()
{
  CLOCK_high();
  _delay_ms(5000);
  CLOCK_low();
  _delay_ms(5000);
}

void Pulse595Rclock()
{
  RCLOCK_high();
  _delay_ms(5000);
  RCLOCK_low();
  _delay_ms(5000);
}

void ShiftOut(uint8_t data)
{
  for (uint8_t i =0; i<8; i++)
  {
    if(data & 0b10000000)
    {
      DATA_high();
    }
    else
    {
      DATA_low();
    }
    _delay_ms(5000);
    Pulse595Clock();
    _delay_ms(5000);
    data=data<<1;   
    DATA_low();
  }
  Pulse595Rclock();
}


int main(void)
{
  uint8_t led_pattern[8]={
    0b00000001,
    0b00000010,
    0b00000100,
    0b00001000,
    0b00010000,
    0b00100000,
    0b01000000,
    0b10000000,
    };
    uint8_t var = 0b01010101;
  InitShiftOut();
  while(1) 
  {
      ShiftOut(var);
      _delay_ms(5000);
  }
}

Bei den Fuses ist das JTAG aus (schon die ganze zeit)
ich hab die Hz vom prozessor mal auf Default gestellt, sprich:
INTROCOsC_1MHZ_6CK_64MS_DEFAULT
Falls du mit projekteinstellungen meinst ob ich dort den richtigen 
ATmega eingestellt habe, dann ja dort ist der Atmega32A eingetragen.

Kann sonst noch was falsch eingestellt sein?

Grüße
Martin

[Martin K. (thereallife)]

Fehler scheinbar gefunde, meine MR leitung war scheinbar gebrochen...
ärgerlich, soviel zeit wegen so nem kleinen kabel...

Danke dir trotzdem für deine unterstützung!

[Martin K. (thereallife)]

Guten morgen,
ich sitze grade an den 165ern,
bin wie oben vorgegangen um zu sehen das alles richtig klappt

Pulse Clock und der Parallel Pulse passen.
Allerdings leuchtet meine DATA_Pin LED dauerhaft (hab sie gegen gnd vom 
pin 9 des 165 weggezogen)
Sie leuchtet jedenfalls dauerhaft was mir mehr als komisch vorkommt, 
weil alle tasten sind nicht gedrückt, auch wenn ich alle tasten drücke, 
leuchtet der Daten pin dauerhaft.

Hier mal mein COde,

leieb Grüße

#include <avr/io.h>
#include <avr/interrupt.h>
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
#ifndef F_CPU
#define F_CPU 1000000UL
#endif
////////////////////////////////////////////////////////////////////
#include <util/delay.h>
////////////////////////////////////////////////////////////////////
#define DATA_PIN      PC2 
#define DATA_PORT      PORTC
#define DATA_DDR      DDRC
#define DATA_read()      (PIND & _BV(DATA_PIN))
////////////////////////////
#define CLOCK_PIN      PC1 // CLK LOW->HIGH FLanke, pro Flanke wird ein bit herrausgeschoben.
#define CLOCK_PORT      PORTC
#define CLOCK_DDR      DDRC
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
////////////////////////////
#define PARALLEL_PIN    PC0
#define PARALLEL_PORT    PORTC
#define PARALLEL_DDR    DDRC
#define PARALLEL_high()    (PARALLEL_PORT |= _BV(PARALLEL_PIN))
#define PARALLEL_low()    (PARALLEL_PORT &= ~_BV(PARALLEL_PIN))
////////////////////////////


void InitShiftIn()
{
  PARALLEL_DDR |= _BV(PARALLEL_PIN);
  CLOCK_DDR |= _BV(CLOCK_PIN);
  DATA_DDR &= ~_BV(DATA_PIN);
  DATA_PORT &= ~_BV(DATA_PIN);
}


// Clock Puls kommt nach dem auslesn des Pins
void Pulse165Parallel()
{
  PARALLEL_high();
  _delay_ms(2000);
  PARALLEL_low();
}
void Pulse165Clock()
{
  CLOCK_low();
  _delay_ms(2000);
  CLOCK_high();
  _delay_ms(2000);
}
void ShiftIn()
{
  unsigned char var = 0;
  CLOCK_high();
  Pulse165Parallel();
  for (unsigned char i = 0; i < 8; ++i)
  {
    var <<= 1;
    if (DATA_read())
    var |= 0x01;
    Pulse165Clock();
  }
}



int main(void)
{
  InitShiftIn();
  while(1)
  {
    ShiftIn();
  }
}

[Martin K. (thereallife)]

Sorry, wenn ich den Thread hier wieder hochschiebe,
ich habe weitergearbeitet und mal versucht ob ich die 595er an die 
funktion der 165 bringen kann damit ich eine optische wiedergabe habe 
und schauen kann ob das ganze nun geht oder nicht,
an sämtlichen Clock bzw data ausgängen hängen leds um die signale 
nachvollziehen zu können.

Ansich stimmt alles vom Timing, nur scheint er keine daten vom 165er zu 
nehmen bzw zu bekommen ( am Dateneingang für den 165er von meinem ATmega 
hängt ne led nach gnd, diese leuchtet dauerhaft schwach?!

hier mal der aktuelle code

#include <avr/io.h>
#include <avr/interrupt.h>
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
#ifndef F_CPU
#define F_CPU 1000000UL
#endif
////////////////////////////////////////////////////////////////////
#include <util/delay.h>
////////////////////////////////////////////////////////////////////
#define DATA595_PIN        PC0
#define DATA595_PORT      PORTC
#define DATA595_DDR        DDRC
///////  
#define DATA595_high()      (DATA595_PORT |= _BV(DATA595_PIN))
#define DATA595_low()      (DATA595_PORT &= ~_BV(DATA595_PIN))
////////////////
#define RCLOCK595_PIN      PC2
#define RCLOCK595_PORT      PORTC
#define RCLOCK595_DDR      DDRC
///////
#define RCLOCK595_high()    (RCLOCK595_PORT |= _BV(RCLOCK595_PIN))
#define RCLOCK595_low()      (RCLOCK595_PORT &= ~_BV(RCLOCK595_PIN))
////////////////
#define CLOCK595_PIN      PC1
#define CLOCK595_PORT      PORTC
#define CLOCK595_DDR      DDRC
///////
#define CLOCK595_high()      (CLOCK595_PORT |= _BV(CLOCK595_PIN))
#define CLOCK595_low()      (CLOCK595_PORT &= ~_BV(CLOCK595_PIN))
////////////////////////////////////////////////////////////////////
#define DATA165_PIN        PC5
#define DATA165_PORT      PORTC
#define DATA165_DDR        DDRC
#define DATA165_read()      (PIND & _BV(DATA165_PIN))
////////////////////////////
#define CLOCK165_PIN      PC4 // CLK LOW->HIGH FLanke, pro Flanke wird ein bit herrausgeschoben.
#define CLOCK165_PORT      PORTC
#define CLOCK165_DDR      DDRC
#define CLOCK165_high()      (CLOCK165_PORT |= _BV(CLOCK165_PIN))
#define CLOCK165_low()      (CLOCK165_PORT &= ~_BV(CLOCK165_PIN))
////////////////////////////
#define PARALLEL165_PIN      PC3
#define PARALLEL165_PORT    PORTC
#define PARALLEL165_DDR      DDRC
#define PARALLEL165_high()    (PARALLEL165_PORT |= _BV(PARALLEL165_PIN))
#define PARALLEL165_low()    (PARALLEL165_PORT &= ~_BV(PARALLEL165_PIN))
////////////////////////////
////////////////////////////////


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

void InitShiftOut()
{
  RCLOCK595_DDR |= _BV(RCLOCK595_PIN);
  CLOCK595_DDR |= _BV(CLOCK595_PIN);
  DATA595_DDR |= _BV(DATA595_PIN);
}
void InitShiftIn()
{
  PARALLEL165_DDR |= _BV(PARALLEL165_PIN);
  CLOCK165_DDR |= _BV(CLOCK165_PIN);
  DATA165_DDR &= ~_BV(DATA165_PIN);
  DATA165_PORT &= ~_BV(DATA165_PIN);
}
void Pulse595Clock()
{
  CLOCK595_high();
  _delay_ms(20);
  CLOCK595_low();
  _delay_ms(20);
}
void Pulse165Clock()
{
  CLOCK165_low();
  _delay_ms(20);
  CLOCK165_high();
  _delay_ms(20);
}

void Pulse595Rclock()
{
  RCLOCK595_high();
  _delay_ms(20);
  RCLOCK595_low();
  _delay_ms(20);
}
void Pulse165Parallel()
{
  PARALLEL165_high();
  _delay_ms(20);
  PARALLEL165_low();
}

void ShiftOut(uint8_t var)
{
  for (uint8_t i =0; i<8; i++)
  {
    if(var & 0b10000000)
    {
      DATA595_high();
    }
    else
    {
      DATA595_low();
    }
    _delay_ms(20);
    Pulse595Clock();
    _delay_ms(20);
    var=var<<1;
    DATA595_low();
  }
  Pulse595Rclock();
}
void ShiftIn(uint8_t var)
{
  CLOCK165_high();
  Pulse165Parallel();
  for (unsigned char i = 0; i < 8; ++i)
  {
    var <<= 1;
    if (DATA165_read())
    var |= 0x01;
    Pulse165Clock();
  }
  CLOCK165_low();
}


int main(void)
{
  InitShiftIn();
  uint8_t var = 0;
  InitShiftOut();
  while(1)
  {
      ShiftIn(var);
      ShiftOut(var);
      _delay_ms(20);
  }
}

Grüße