Forum: Mikrocontroller und Digitale Elektronik ATmega32A; 595; 165 Code Hilfe benötigt


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von Martin K. (thereallife)


Lesenswert?

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
1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
#include <util/delay.h>
4
////////////////////////////////////////////////////////////////////
5
#ifndef MCU             
6
#define MCU  atmega32
7
#endif
8
////////////////////////////////////////////////////////////////////
9
#ifndef F_CPU          
10
#define F_CPU 8000000UL
11
#endif
12
////////////////////////////////////////////////////////////////////
13
#define DATA_PIN      PA1
14
#define DATA_PORT      PORTB
15
#define DATA_DDR      DDRB
16
///////
17
#define DATA_high()      (DATA_PORT |= _BV(DATA_PIN))
18
#define DATA_low()      (DATA_PORT &= ~_BV(DATA_PIN))
19
////////////////
20
#define RCLOCK_PIN      PA0
21
#define RCLOCK_PORT      PORTB
22
#define RCLOCK_DDR      DDRB
23
///////
24
#define RCLOCK_high()    (RCLOCK_PORT |= _BV(RCLOCK_PIN))
25
#define RCLOCK_low()    (RCLOCK_PORT &= ~_BV(RCLOCK_PIN))
26
////////////////
27
#define CLOCK_PIN      PA2
28
#define CLOCK_PORT      PORTB
29
#define CLOCK_DDR      DDRB
30
///////
31
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
32
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
33
////////////////////////////////
34
35
36
////////////////////////////////////////////////////////////////////
37
38
void InitShiftOut()
39
{
40
  RCLOCK_DDR |= _BV(RCLOCK_PIN);
41
  CLOCK_DDR |= _BV(CLOCK_PIN);
42
  DATA_DDR |= _BV(DATA_PIN);
43
}
44
45
void Pulse595Clock()
46
{
47
  CLOCK_high();
48
  _delay_ms(200);
49
  CLOCK_low();
50
  _delay_ms(200);
51
}
52
53
void Pulse595Rclock()
54
{
55
  RCLOCK_high();
56
  _delay_ms(20);
57
  RCLOCK_low();
58
  _delay_ms(20);
59
}
60
61
void ShiftOut(uint8_t data)
62
{
63
  for (uint8_t i =0; i<8; i++)
64
  {
65
    if(data & 0b10000000)
66
    {
67
      DATA_high();
68
    }
69
    else
70
    {
71
      DATA_low();
72
    }
73
    Pulse595Clock();
74
    data=data<<1;   
75
  }
76
  Pulse595Rclock();
77
}
78
79
80
int main(void)
81
{
82
  uint8_t led_pattern[8]={
83
    0b00000001,
84
    0b00000010,
85
    0b00000100,
86
    0b00001000,
87
    0b00010000,
88
    0b00100000,
89
    0b01000000,
90
    0b10000000,
91
    };
92
  InitShiftOut();
93
  while(1) 
94
  {
95
    for(uint8_t i=0; i<8; i++)
96
    {
97
      ShiftOut(led_pattern[i]);
98
      _delay_ms(200);
99
    }
100
  }
101
}

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.
1
#include <avr/io.h>
2
#include <util.delay.h>
3
4
5
#define IDATA_PIN    PD2
6
#define IDATA_PORT    PORTD
7
#define IDATA_DDR    DDRD
8
#define IDATA_read()  (PIND & _BV(IDATA_PIN))
9
////////////////////////////
10
#define ICLOCK_PIN    PD1 // CLK LOW->HIGH FLanke, pro Flanke wird ein bit herrausgeschoben.
11
#define ICLOCK_PORT    PORTD
12
#define ICLOCK_DDR    DDRD
13
#define ICLOCK_high()  ICLOCK_PORT |= _BV(ICLOCK_PIN)
14
#define ICLOCK_low()  ICLOCK_PORT &= ~_BV(ICLOCK_PIN)
15
////////////////////////////
16
#define PARALLEL_PIN  PD0
17
#define PARALLEL_PORT  PORTD
18
#define PARALLEL_DDR  DDRD
19
#define PARALLEL_high()  IRCLOCK_PORT |= _BV(IRCLOCK_PIN)
20
#define PARALLEL_low()  IRCLOCK_PORT &= ~_BV(IRCLOCK_PIN)
21
////////////////////////////
22
23
24
void InitShiftIn()
25
{
26
  PARALLEL_DDR |= _BV(IRCLOCK_PIN);
27
  ICLOCK_DDR |= _BV(ICLOCK_PIN);
28
  IDATA_DDR &= ~_BV(IDATA_PIN);
29
  IDATA_PORT |= _BV(IDATA_PIN);
30
}
31
32
33
// Clock Puls kommt nach dem auslesn des Pins
34
void Pulse165Parallel()
35
{
36
  PARALLEL_high();
37
  PARALLEL_low();
38
}
39
void Pulse165Clock()
40
{
41
  ICLOCK_high();
42
  ICLOCK_low();
43
}
44
int ShiftIn()
45
{
46
  ICLOCK_high()
47
  Pulse165Parallel();
48
  for (unsigned char i = 0; i < 8; i++)
49
  {
50
    var <<= 1;
51
    if (IDATA_read())
52
    var = | 0x01;
53
    Pulse165Clock();
54
  }
55
}
56
57
58
59
int main(void)
60
{
61
  uint8_t var;
62
    while(1)
63
    {
64
        ShiftIn();
65
    }
66
}


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

von Karl H. (kbuchegg) (Moderator)


Lesenswert?

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

von Martin K. (thereallife)


Lesenswert?

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
1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
////////////////////////////////////////////////////////////////////
4
#ifndef MCU             
5
#define MCU  atmega32
6
#endif
7
////////////////////////////////////////////////////////////////////
8
#ifndef F_CPU
9
#define F_CPU 8000000UL
10
#endif
11
////////////////////////////////////////////////////////////////////
12
#include <util/delay.h>
13
////////////////////////////////////////////////////////////////////
14
#define DATA_PIN      PC0
15
#define DATA_PORT      PORTC
16
#define DATA_DDR      DDRC
17
///////
18
#define DATA_high()      (DATA_PORT |= _BV(DATA_PIN))
19
#define DATA_low()      (DATA_PORT &= ~_BV(DATA_PIN))
20
////////////////
21
#define RCLOCK_PIN      PC2
22
#define RCLOCK_PORT      PORTC
23
#define RCLOCK_DDR      DDRC
24
///////
25
#define RCLOCK_high()    (RCLOCK_PORT |= _BV(RCLOCK_PIN))
26
#define RCLOCK_low()    (RCLOCK_PORT &= ~_BV(RCLOCK_PIN))
27
////////////////
28
#define CLOCK_PIN      PC1
29
#define CLOCK_PORT      PORTC
30
#define CLOCK_DDR      DDRC
31
///////
32
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
33
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
34
////////////////////////////////
35
36
37
////////////////////////////////////////////////////////////////////
38
39
void InitShiftOut()
40
{
41
  RCLOCK_DDR |= _BV(RCLOCK_PIN);
42
  CLOCK_DDR |= _BV(CLOCK_PIN);
43
  DATA_DDR |= _BV(DATA_PIN);
44
}
45
46
void Pulse595Clock()
47
{
48
  CLOCK_high();
49
  _delay_ms(20);
50
  CLOCK_low();
51
  _delay_ms(20);
52
}
53
54
void Pulse595Rclock()
55
{
56
  RCLOCK_high();
57
  _delay_ms(20);
58
  RCLOCK_low();
59
  _delay_ms(20);
60
}
61
62
void ShiftOut(uint8_t data)
63
{
64
  for (uint8_t i =0; i<80; i++)
65
  {
66
    if(data & 0b10000000)
67
    {
68
      DATA_high();
69
    }
70
    else
71
    {
72
      DATA_low();
73
    }
74
    Pulse595Clock();
75
    data=data<<1;   
76
    DATA_low();
77
  }
78
  Pulse595Rclock();
79
}
80
81
82
int main(void)
83
{
84
  uint8_t led_pattern[8]={
85
    0b00000001,
86
    0b00000010,
87
    0b00000100,
88
    0b00001000,
89
    0b00010000,
90
    0b00100000,
91
    0b01000000,
92
    0b10000000,
93
    };
94
  InitShiftOut();
95
  while(1) 
96
  {
97
    for(uint8_t i=0; i<2; i++)
98
    {
99
      ShiftOut(led_pattern[i]);
100
      _delay_ms(200);
101
    }
102
  }
103
}

von Martin K. (thereallife)


Lesenswert?

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

von Karl H. (kbuchegg) (Moderator)


Lesenswert?

Projektoptionen korrekt eingestellt?

So etwas
1
#ifndef MCU             
2
#define MCU  atmega32
3
#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.

: Bearbeitet durch Moderator
von Martin K. (thereallife)


Lesenswert?

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...

von Karl H. (kbuchegg) (Moderator)


Lesenswert?

Mach die zb auch hier mal
1
....
2
    DATA_low();
3
  }
4
  Pulse595Rclock();
5
...

einen entsprechenden Delay dazwischen ....
1
    DATA_low();
2
  }
3
  _delay_ms( 200 );
4
  Pulse595Rclock();
5
...

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

von Martin K. (thereallife)


Lesenswert?

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
1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
////////////////////////////////////////////////////////////////////
4
////////////////////////////////////////////////////////////////////
5
#ifndef F_CPU
6
#define F_CPU 1000000UL
7
#endif
8
////////////////////////////////////////////////////////////////////
9
#include <util/delay.h>
10
////////////////////////////////////////////////////////////////////
11
#define DATA_PIN      PC0
12
#define DATA_PORT      PORTC
13
#define DATA_DDR      DDRC
14
///////
15
#define DATA_high()      (DATA_PORT |= _BV(DATA_PIN))
16
#define DATA_low()      (DATA_PORT &= ~_BV(DATA_PIN))
17
////////////////
18
#define RCLOCK_PIN      PC2
19
#define RCLOCK_PORT      PORTC
20
#define RCLOCK_DDR      DDRC
21
///////
22
#define RCLOCK_high()    (RCLOCK_PORT |= _BV(RCLOCK_PIN))
23
#define RCLOCK_low()    (RCLOCK_PORT &= ~_BV(RCLOCK_PIN))
24
////////////////
25
#define CLOCK_PIN      PC1
26
#define CLOCK_PORT      PORTC
27
#define CLOCK_DDR      DDRC
28
///////
29
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
30
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
31
////////////////////////////////
32
33
34
////////////////////////////////////////////////////////////////////
35
36
void InitShiftOut()
37
{
38
  RCLOCK_DDR |= _BV(RCLOCK_PIN);
39
  CLOCK_DDR |= _BV(CLOCK_PIN);
40
  DATA_DDR |= _BV(DATA_PIN);
41
}
42
43
void Pulse595Clock()
44
{
45
  CLOCK_high();
46
  _delay_ms(5000);
47
  CLOCK_low();
48
  _delay_ms(5000);
49
}
50
51
void Pulse595Rclock()
52
{
53
  RCLOCK_high();
54
  _delay_ms(5000);
55
  RCLOCK_low();
56
  _delay_ms(5000);
57
}
58
59
void ShiftOut(uint8_t data)
60
{
61
  for (uint8_t i =0; i<8; i++)
62
  {
63
    if(data & 0b10000000)
64
    {
65
      DATA_high();
66
    }
67
    else
68
    {
69
      DATA_low();
70
    }
71
    _delay_ms(5000);
72
    Pulse595Clock();
73
    _delay_ms(5000);
74
    data=data<<1;   
75
    DATA_low();
76
  }
77
  Pulse595Rclock();
78
}
79
80
81
int main(void)
82
{
83
  uint8_t led_pattern[8]={
84
    0b00000001,
85
    0b00000010,
86
    0b00000100,
87
    0b00001000,
88
    0b00010000,
89
    0b00100000,
90
    0b01000000,
91
    0b10000000,
92
    };
93
    uint8_t var = 0b01010101;
94
  InitShiftOut();
95
  while(1) 
96
  {
97
      ShiftOut(var);
98
      _delay_ms(5000);
99
  }
100
}

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

von Martin K. (thereallife)


Lesenswert?

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!

von Martin K. (thereallife)


Lesenswert?

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
1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
////////////////////////////////////////////////////////////////////
4
////////////////////////////////////////////////////////////////////
5
#ifndef F_CPU
6
#define F_CPU 1000000UL
7
#endif
8
////////////////////////////////////////////////////////////////////
9
#include <util/delay.h>
10
////////////////////////////////////////////////////////////////////
11
#define DATA_PIN      PC2 
12
#define DATA_PORT      PORTC
13
#define DATA_DDR      DDRC
14
#define DATA_read()      (PIND & _BV(DATA_PIN))
15
////////////////////////////
16
#define CLOCK_PIN      PC1 // CLK LOW->HIGH FLanke, pro Flanke wird ein bit herrausgeschoben.
17
#define CLOCK_PORT      PORTC
18
#define CLOCK_DDR      DDRC
19
#define CLOCK_high()    (CLOCK_PORT |= _BV(CLOCK_PIN))
20
#define CLOCK_low()      (CLOCK_PORT &= ~_BV(CLOCK_PIN))
21
////////////////////////////
22
#define PARALLEL_PIN    PC0
23
#define PARALLEL_PORT    PORTC
24
#define PARALLEL_DDR    DDRC
25
#define PARALLEL_high()    (PARALLEL_PORT |= _BV(PARALLEL_PIN))
26
#define PARALLEL_low()    (PARALLEL_PORT &= ~_BV(PARALLEL_PIN))
27
////////////////////////////
28
29
30
void InitShiftIn()
31
{
32
  PARALLEL_DDR |= _BV(PARALLEL_PIN);
33
  CLOCK_DDR |= _BV(CLOCK_PIN);
34
  DATA_DDR &= ~_BV(DATA_PIN);
35
  DATA_PORT &= ~_BV(DATA_PIN);
36
}
37
38
39
// Clock Puls kommt nach dem auslesn des Pins
40
void Pulse165Parallel()
41
{
42
  PARALLEL_high();
43
  _delay_ms(2000);
44
  PARALLEL_low();
45
}
46
void Pulse165Clock()
47
{
48
  CLOCK_low();
49
  _delay_ms(2000);
50
  CLOCK_high();
51
  _delay_ms(2000);
52
}
53
void ShiftIn()
54
{
55
  unsigned char var = 0;
56
  CLOCK_high();
57
  Pulse165Parallel();
58
  for (unsigned char i = 0; i < 8; ++i)
59
  {
60
    var <<= 1;
61
    if (DATA_read())
62
    var |= 0x01;
63
    Pulse165Clock();
64
  }
65
}
66
67
68
69
int main(void)
70
{
71
  InitShiftIn();
72
  while(1)
73
  {
74
    ShiftIn();
75
  }
76
}

von Martin K. (thereallife)


Lesenswert?

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
1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
////////////////////////////////////////////////////////////////////
4
////////////////////////////////////////////////////////////////////
5
#ifndef F_CPU
6
#define F_CPU 1000000UL
7
#endif
8
////////////////////////////////////////////////////////////////////
9
#include <util/delay.h>
10
////////////////////////////////////////////////////////////////////
11
#define DATA595_PIN        PC0
12
#define DATA595_PORT      PORTC
13
#define DATA595_DDR        DDRC
14
///////  
15
#define DATA595_high()      (DATA595_PORT |= _BV(DATA595_PIN))
16
#define DATA595_low()      (DATA595_PORT &= ~_BV(DATA595_PIN))
17
////////////////
18
#define RCLOCK595_PIN      PC2
19
#define RCLOCK595_PORT      PORTC
20
#define RCLOCK595_DDR      DDRC
21
///////
22
#define RCLOCK595_high()    (RCLOCK595_PORT |= _BV(RCLOCK595_PIN))
23
#define RCLOCK595_low()      (RCLOCK595_PORT &= ~_BV(RCLOCK595_PIN))
24
////////////////
25
#define CLOCK595_PIN      PC1
26
#define CLOCK595_PORT      PORTC
27
#define CLOCK595_DDR      DDRC
28
///////
29
#define CLOCK595_high()      (CLOCK595_PORT |= _BV(CLOCK595_PIN))
30
#define CLOCK595_low()      (CLOCK595_PORT &= ~_BV(CLOCK595_PIN))
31
////////////////////////////////////////////////////////////////////
32
#define DATA165_PIN        PC5
33
#define DATA165_PORT      PORTC
34
#define DATA165_DDR        DDRC
35
#define DATA165_read()      (PIND & _BV(DATA165_PIN))
36
////////////////////////////
37
#define CLOCK165_PIN      PC4 // CLK LOW->HIGH FLanke, pro Flanke wird ein bit herrausgeschoben.
38
#define CLOCK165_PORT      PORTC
39
#define CLOCK165_DDR      DDRC
40
#define CLOCK165_high()      (CLOCK165_PORT |= _BV(CLOCK165_PIN))
41
#define CLOCK165_low()      (CLOCK165_PORT &= ~_BV(CLOCK165_PIN))
42
////////////////////////////
43
#define PARALLEL165_PIN      PC3
44
#define PARALLEL165_PORT    PORTC
45
#define PARALLEL165_DDR      DDRC
46
#define PARALLEL165_high()    (PARALLEL165_PORT |= _BV(PARALLEL165_PIN))
47
#define PARALLEL165_low()    (PARALLEL165_PORT &= ~_BV(PARALLEL165_PIN))
48
////////////////////////////
49
////////////////////////////////
50
51
52
////////////////////////////////////////////////////////////////////
53
54
void InitShiftOut()
55
{
56
  RCLOCK595_DDR |= _BV(RCLOCK595_PIN);
57
  CLOCK595_DDR |= _BV(CLOCK595_PIN);
58
  DATA595_DDR |= _BV(DATA595_PIN);
59
}
60
void InitShiftIn()
61
{
62
  PARALLEL165_DDR |= _BV(PARALLEL165_PIN);
63
  CLOCK165_DDR |= _BV(CLOCK165_PIN);
64
  DATA165_DDR &= ~_BV(DATA165_PIN);
65
  DATA165_PORT &= ~_BV(DATA165_PIN);
66
}
67
void Pulse595Clock()
68
{
69
  CLOCK595_high();
70
  _delay_ms(20);
71
  CLOCK595_low();
72
  _delay_ms(20);
73
}
74
void Pulse165Clock()
75
{
76
  CLOCK165_low();
77
  _delay_ms(20);
78
  CLOCK165_high();
79
  _delay_ms(20);
80
}
81
82
void Pulse595Rclock()
83
{
84
  RCLOCK595_high();
85
  _delay_ms(20);
86
  RCLOCK595_low();
87
  _delay_ms(20);
88
}
89
void Pulse165Parallel()
90
{
91
  PARALLEL165_high();
92
  _delay_ms(20);
93
  PARALLEL165_low();
94
}
95
96
void ShiftOut(uint8_t var)
97
{
98
  for (uint8_t i =0; i<8; i++)
99
  {
100
    if(var & 0b10000000)
101
    {
102
      DATA595_high();
103
    }
104
    else
105
    {
106
      DATA595_low();
107
    }
108
    _delay_ms(20);
109
    Pulse595Clock();
110
    _delay_ms(20);
111
    var=var<<1;
112
    DATA595_low();
113
  }
114
  Pulse595Rclock();
115
}
116
void ShiftIn(uint8_t var)
117
{
118
  CLOCK165_high();
119
  Pulse165Parallel();
120
  for (unsigned char i = 0; i < 8; ++i)
121
  {
122
    var <<= 1;
123
    if (DATA165_read())
124
    var |= 0x01;
125
    Pulse165Clock();
126
  }
127
  CLOCK165_low();
128
}
129
130
131
int main(void)
132
{
133
  InitShiftIn();
134
  uint8_t var = 0;
135
  InitShiftOut();
136
  while(1)
137
  {
138
      ShiftIn(var);
139
      ShiftOut(var);
140
      _delay_ms(20);
141
  }
142
}

Grüße

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.