Schiebregister

Maik C. OP #2047414
Lesenswert?
• ▲
▼ 
Hallo,


was ist an diesem Programm falsch?

Wie kann ich meine Werte in das Schieberegister übertragen?


Programm ist im Anhang


1
#include <avr/io.h>          

2
#define  F_CPU 1000000UL

3
#include <util/delay.h>

4
#include <avr/interrupt.h>

5
#include <avr/pgmspace.h>

6


7


8


9
#define A     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01111110,0b01000010,0b01000010,0b01000010,0b00000000}

10
#define B     {0b00000000,0b01111100,0b01000010,0b01000010,0b01111100,0b01000010,0b01000010,0b01000010,0b01111100,0b00000000}

11
#define C     {0b00000000,0b00111110,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b00111110,0b00000000}

12
#define D     {0b00000000,0b01111100,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01111100,0b00000000}

13
#define E     {0b00000000,0b01111110,0b01000000,0b01000000,0b01111100,0b01000000,0b01000000,0b01000000,0b01111110,0b00000000}

14
#define F     {0b00000000,0b01111110,0b01000000,0b01000000,0b01111100,0b01000000,0b01000000,0b01000000,0b01000000,0b00000000}

15
#define G     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000000,0b01000111,0b01000010,0b01000010,0b00111100,0b00000000}

16
#define H     {0b00000000,0b01000010,0b01000010,0b01000010,0b01111110,0b01000010,0b01000010,0b01000010,0b01000010,0b00000000}

17
#define I     {0b00000000,0b00111000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00111000,0b00000000}

18
#define J     {0b00000000,0b00011100,0b00001000,0b00001000,0b00001000,0b00001000,0b01001000,0b01001000,0b00110000,0b00000000}

19
#define K     {0b00000000,0b01000100,0b01001000,0b01010000,0b01100000,0b01010000,0b01001000,0b01000100,0b01000010,0b00000000}

20
#define L     {0b00000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01111110,0b00000000}

21
#define M     {0b00000000,0b01000100,0b10101010,0b10010010,0b10010010,0b10000010,0b10000010,0b10000010,0b10000010,0b00000000}

22
#define N     {0b00000000,0b01000010,0b01100010,0b01010010,0b01001010,0b01001010,0b01001010,0b01000110,0b01000010,0b00000000}

23
#define O     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}

24
#define P     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01111100,0b01000000,0b01000000,0b01000000,0b00000000}

25
#define Q     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000110,0b00111110,0b00000001}

26
#define R     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01111100,0b01000100,0b01000010,0b01000010,0b00000000}

27
#define S     {0b00000000,0b00111100,0b01000010,0b01000000,0b01000000,0b00111100,0b00000010,0b01000010,0b00111100,0b00000000}

28
#define T     {0b00000000,0b11111110,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}

29
#define U     {0b00000000,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}

30
#define V     {0b00000000,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b00100100,0b00011000,0b00000000}

31
#define W     {0b00000000,0b10000010,0b10000010,0b10000010,0b10000010,0b10010010,0b10010010,0b10101010,0b01000100,0b00000000}

32
#define X     {0b00000000,0b01000010,0b01000010,0b00100100,0b00011000,0b00011000,0b00100100,0b01000010,0b01000010,0b00000000}

33
#define Y     {0b00000000,0b10000010,0b01000100,0b00101000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}

34
#define Z     {0b00000000,0b01111110,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b01111110,0b00000000}

35
#define lit_a {0b00000000,0b00000000,0b00000000,0b00000000,0b00111000,0b01000100,0b01000101,0b01000101,0b00111010,0b00000000}

36
#define lit_b {0b00000000,0b00000000,0b00100000,0b00100000,0b00100000,0b00111100,0b00100010,0b00100010,0b00111100,0b00000000}

37
#define lit_c {0b00000000,0b00000000,0b00000000,0b00000000,0b00111100,0b01000000,0b01000000,0b01000000,0b00111100,0b00000000}

38
#define lit_d {0b00000000,0b00000000,0b00000100,0b00000100,0b00000100,0b00111100,0b01000100,0b01000100,0b00111100,0b00000000}

39
#define lit_e {0b00000000,0b00000000,0b00000000,0b00111000,0b01000100,0b01000100,0b01111000,0b01000000,0b00111100,0b00000000}

40
#define lit_f {0b00000000,0b00011000,0b00100100,0b00100000,0b00100000,0b01110000,0b00100000,0b00100000,0b00100000,0b00000000}

41
#define lit_g {0b00000000,0b00011100,0b00100010,0b00100010,0b00011110,0b00000010,0b00000010,0b00010010,0b00001100,0b00000000}

42
#define lit_h {0b00000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01111000,0b01000100,0b01000100,0b01000100,0b00000000}

43
#define lit_i {0b00000000,0b00000000,0b00010000,0b00000000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}

44
#define lit_j {0b00000000,0b00000000,0b00010000,0b00000000,0b00010000,0b00010000,0b00010000,0b01010000,0b00110000,0b00000000}

45
#define lit_k {0b00000000,0b00000000,0b00000000,0b01001000,0b01010000,0b01100000,0b01100000,0b01010000,0b01001000,0b00000000}

46
#define lit_l {0b00000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b00000000}

47
#define lit_m {0b00000000,0b00000000,0b00000000,0b00110100,0b01001010,0b01001010,0b01001010,0b01001010,0b01001010,0b00000000}

48
#define lit_n {0b00000000,0b00000000,0b00000000,0b01111000,0b01000100,0b01000100,0b01000100,0b01000100,0b01000100,0b00000000}

49
#define lit_o {0b00000000,0b00000000,0b00000000,0b00000000,0b00011100,0b00100010,0b00100010,0b00100010,0b00011100,0b00000000}

50
#define lit_p {0b00000000,0b00000000,0b00000000,0b00011100,0b00100010,0b00100010,0b00111100,0b00100000,0b00100000,0b00100000}

51
#define lit_q {0b00000000,0b00000000,0b00000000,0b00111000,0b01000100,0b01000100,0b00111100,0b00000100,0b00000100,0b00000100}

52
#define lit_r {0b00000000,0b00000000,0b00000000,0b00111000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b00000000}

53
#define lit_s {0b00000000,0b00000000,0b00111000,0b01000100,0b01000000,0b00111000,0b00000100,0b01000100,0b00111000,0b00000000}

54
#define lit_t {0b00000000,0b00100000,0b00100000,0b00100000,0b01111000,0b00100000,0b00100000,0b00100010,0b00011100,0b00000000}

55
#define lit_u {0b00000000,0b00000000,0b00000000,0b00000000,0b01000100,0b01000100,0b01000100,0b01000100,0b00111000,0b00000000}

56
#define lit_v {0b00000000,0b00000000,0b00000000,0b01000100,0b01000100,0b01000100,0b01000100,0b00101000,0b00010000,0b00000000}

57
#define lit_w {0b00000000,0b00000000,0b00000000,0b00000000,0b01000100,0b01000100,0b01010100,0b01010100,0b00101000,0b00000000}

58
#define lit_x {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00100100,0b00011000,0b00011000,0b00100100,0b00000000}

59
#define lit_y {0b00000000,0b00000000,0b01000100,0b01000100,0b00111100,0b00000100,0b00000100,0b00000100,0b00111000,0b00000000}

60
#define lit_z {0b00000000,0b00000000,0b00000000,0b00000000,0b01111100,0b00001000,0b00010000,0b00100000,0b01111100,0b00000000}

61
#define space {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000}

62
#define num_0 {0b00000000,0b00111100,0b01000110,0b01001010,0b01001010,0b01001010,0b01010010,0b01100010,0b00111100,0b00000000}

63
#define num_1 {0b00000000,0b00001000,0b00011000,0b00001000,0b00001000,0b00001000,0b00001000,0b00001000,0b00011100,0b00000000}

64
#define num_2 {0b00000000,0b00111100,0b01000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b01111110,0b00000000}

65
#define num_3 {0b00000000,0b01111110,0b00000010,0b00000010,0b00011100,0b00000010,0b00000010,0b01000010,0b00111100,0b00000000}

66
#define num_4 {0b00000000,0b00000100,0b00001100,0b00010100,0b00100100,0b01000100,0b01111110,0b00000100,0b00000100,0b00000000}

67
#define num_5 {0b00000000,0b01111110,0b01000000,0b01000000,0b00111100,0b00000010,0b00000010,0b00000010,0b01111100,0b00000000}

68
#define num_6 {0b00000000,0b00111100,0b01000000,0b01000000,0b01111100,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}

69
#define num_7 {0b00000000,0b01111110,0b00000010,0b00000100,0b00001000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}

70
#define num_8 {0b00000000,0b00111100,0b01000010,0b01000010,0b00111100,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}

71
#define num_9 {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b00111110,0b00000010,0b00000010,0b00111100,0b00000000}

72
#define times {0b00000000,0b00000000,0b01000010,0b00100100,0b00011000,0b00011000,0b00100100,0b01000010,0b00000000,0b00000000}

73
#define aus   {0b00000000,0b00011000,0b00011000,0b00011000,0b00011000,0b00011000,0b00000000,0b00011000,0b00011000,0b00000000}

74
#define col    {0b00000000,0b01111111,0b10111111,0b11011111,0b11101111,0b11110111,0b11111011,0b11111101,0b11111110,0b00000000}

75
#define herz  {0b00000000,0b01101100,0b11111110,0b11111110,0b01111100,0b01111100,0b00111000,0b00111000,0b00010000,0b00000000}

76
#define herz2 {0b00000000,0b01101100,0b10010010,0b10000010,0b01000100,0b01000100,0b00101000,0b00010000,0b00000000,0b00000000}

77
#define und   {0b00000000,0b00011000,0b00011000,0b00011000,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000,0b00000000}

78
#define gl    {0b00000000,0b00000000,0b00000000,0b00111100,0b00000000,0b00000000,0b00111100,0b00000000,0b00000000,0b00000000}

79


80


81
#define ShiftPort   PORTC

82
#define ShiftDDR  DDRC

83
#define LatchPin  (1 << 0)

84
#define DataPin    (1 << 1)

85
#define ClkPin    (1 << 2)

86


87


88
typedef unsigned char u8;

89
typedef unsigned int u16;

90


91
unsigned int txtl = 7;

92


93
unsigned int text_1[7][10]  = {space,H,A,L,L,O,space};      //Ausgabe Text definieren (Reihe high)

94
unsigned int reihe [1][10]   = {col};                        //Input Ports definieren  (Spalten low)

95


96
unsigned int x, y, i, a, temp_1, temp_2, temp_3;

97


98


99


100


101
void shift_int(u8 shiftData)    

102
{

103
  ShiftPort &= ~(LatchPin | ClkPin | DataPin);    

104
  

105
  for (char i=0; i<10; i++)

106
  {

107
    ShiftPort &= ~ClkPin;        

108


109
    if (shiftData & (1<<i)) ShiftPort |= DataPin;    

110
    else ShiftPort &= ~DataPin;        

111


112
    ShiftPort |= ClkPin;        

113
    ShiftPort &= ~DataPin;        

114
  }

115


116
  ShiftPort |= LatchPin;          

117
  ShiftPort &= ~(ClkPin | DataPin);      

118
}

119


120


121


122


123


124
void einzeln(int loop, int time){          // Die Buchstaben werden einzeln nacheinander ausgegeben.

125
                          //

126
 for(i=0; i<loop; i++){              // Wiederholungen der Buchstaben

127
  for(y=0; y<txtl; y++){              // 

128
   for(a=0; a<time; a++){              // Anzeigedauer der einzelnen Buchstaben

129
    for(x=0; x<10; x--){              //

130
  temp_1 = text_1[y][x];              // 

131
    temp_2 = reihe[0][x];

132
    shift_int(text_1);

133
    PORTD  = temp_2;

134
    _delay_ms(2);

135
          

136
    }

137
   }

138
  }

139
 }

140
}

141


142


143


144
void port_init(void){        //Ports definieren  

145
DDRB = 0b11111111;          //rows 

146
DDRD = 0b11111111;             //cols

147
}

148


149


150
//(Matrix löschen)

151


152
void clear_matrix(void){PORTB = 0b00000000; PORTD = 0b11111111;}

153


154


155


156


157
int main (void) {         

158
      

159
port_init();  

160
clear_matrix();

161


162
einzeln(9,5);

163


164
  while(1) {

165


166
    

167
  }

168


169


170
}
Angehängte Dateien:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Maik C. OP #2047442
Lesenswert?
• ▲
▼ 
Cntroller: Atmega8



die Anoden sind an den Dusgängen des Schieberegisters.
Das Schieberegister is an den Ports "C"

und die Kathoden an den I/0 PortD.


und so ist die Matrix aufgebaut....


http://www.mikrocontroller.net/attachment/51115/Schaltplan_LED_Matrix.png


aber was ich nicht gesagt habe, ist wieso die Funktion shift_int(); 
nicht funktioniert. die Funktion soll die Werte in das Schieberegister 
übertragen

 z.b. 0b01000010

das tut sie aber iwie nicht.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Turbo T. #2047457
Lesenswert?
• ▲
▼ 
Als erstes solltest du in der Überrschrift rein schreiben, das es sich 
um eine AVR handelt.
z.b. "Schieberegister an einen AVR"
somit wäre dieser Beitrag auch dort zu sehen, wenn man nur auf beiträge 
achtet, die sich auf AVRs beziehen.

Als nächstes müsste man wissen, um welches Schieberegister es sich 
handelt und wie dieses am AVR angeschlossen ist.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2047463
Lesenswert?
• ▲
▼ 
Maik C. schrieb:

> aber was ich nicht gesagt habe, ist wieso die Funktion shift_int();
> nicht funktioniert. die Funktion soll die Werte in das Schieberegister
> übertragen
>
>  z.b. 0b01000010
>
> das tut sie aber iwie nicht.

Dann schau dir doch die Funktion mal an.
Insebesondere, welche Pins du immer wieder auf 0 zurücksetzt.

Wenn du einen Puls erzeugen willst, dann setzt den Pin auf 1 und danach 
wieder zurück auf 0.
Aber verstreu dir die Dinge nicht so quer über die Funktion


1
void shift_int(u8 shiftData)    

2
{

3
  ShiftPort &= ~(LatchPin | ClkPin | DataPin);    

4
  

5
  for (char i=0; i<10; i++)

6
  {

7
    if (shiftData & (1<<i)) ShiftPort |= DataPin;    

8
    else ShiftPort &= ~DataPin;        

9


10
    ShiftPort |= ClkPin;        

11
    ShiftPort &= ~ClkPin;        

12
  }

13


14
  ShiftPort |= LatchPin;          

15
  ShiftPort &= ~LatchPin;      

16
}



Und dann schau dir das hier mal an:

1
void einzeln(int loop, int time){          // Die Buchstaben werden einzeln nacheinander ausgegeben.

2
                          //

3
 for(i=0; i<loop; i++){              // Wiederholungen der Buchstaben

4
  for(y=0; y<txtl; y++){              // 

5
   for(a=0; a<time; a++){              // Anzeigedauer der einzelnen Buchstaben

6
    for(x=0; x<10; x--){              //

7
  temp_1 = text_1[y][x];              // 

8
    temp_2 = reihe[0][x];

9
    shift_int(text_1);

10
    PORTD  = temp_2;

11
    _delay_ms(2);

12
          

13
    }

14
   }

15
  }

16
 }

17
}


Ich denke nicht, dass du shift_int mit dem Argument 'text_1' aufrufen 
willst. Hatt denn dein Compiler da gar nichts dazu zu sagen?

Etwas übersichtlicher schreiben! Dann passieren dir nicht solche dummen 
Fehler.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Achim M. #2047485
Lesenswert?
• ▲
▼ 
Wieso packst du dir die Buchstaben-Auflösungstabelle als #defines rein?
Ich würde eher ein char-Array aufmachen. Das wird dann "ge-PROGMEM-t". 
Nachher kannst du mit einem PGM_P darauf zugreifen. Da du weißt, dass 
ein Buchstabe 8 Byte ausmacht, kannst du "mit den Buchstaben" und 
Pointern rechnen. z.B. so:
1
char mycharlist[] PROGMEM = {/*das ganze Array einfach runterschreiben*/}

2


3
void printchar(char mychar)

4
{

5
   char offset = 0;

6


7
   if (mychar >= 'A' && mychar <= 'Z'){

8
      mychar -= 'A';

9
      offset += 0;

10
   } else if (mychar >= 'a' && mychar <= 'z'){

11
      mychar -= 'a';

12
      offset += 26;

13
   } else if (mychar >= '0' && mychar <= '9'){

14
      mychar -= '0';

15
      offset += 52;

16
   } //und so weiter

17
   

18
   for(int i = 0; i < 8; i++){

19
   soft_spi_out(pgm_read_byte(mycharlist + offset + mychar + i));

20
   }

21
}

sobald du den print_char hast, kannst du einfachst auch strings 
ausgeben.
mfg mf
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Turbo T. #2047489
Lesenswert?
• ▲
▼ 
Das Prinzip so einer 8x 8 Matrix ist der Zeitmultiplexbetrtieb.
Man schiebt die lezte zeile ins Register, dann schaltet man die unterste 
zeile ein, danach wird die wieder ausgeschaltet und die 2t unterste 
zeile in register geschoben. Dann wird diese zeile eingeschaltet... bis 
man bei der obersten Zeile angelangt ist. dann wird wieder von unten 
angefangen.

Dieses multiplexing sollte in einer sich ständig wiederholenden 
Hauptschleife erfolgen oder mit einen Timerinterrupt.

Beides kann ich in deinen Programm nicht erkennen.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Maik C. OP #2047494
Lesenswert?
• ▲
▼ 
Mini Float schrieb:
> Wieso packst du dir die Buchstaben-Auflösungstabelle als #defines rein?
> Ich würde eher ein char-Array aufmachen. Das wird dann "ge-PROGMEM-t".
> Nachher kannst du mit einem PGM_P darauf zugreifen. Da du weißt, dass
> ein Buchstabe 8 Byte ausmacht, kannst du "mit den Buchstaben" und


damit habe ich mich noch nicht beschäftigt.

es geht mir ja nur darum wie ich diese Bits... ka wie ich das bezeichnen 
soll in das schieberegister kriege.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Achim M. #2047495
Lesenswert?
• ▲
▼ 
Warum nicht gleich eine Maske mit einer 1 schieben, bis die "hinten 
runter fällt"?
1
char spidata;//enthält SPI Sendedaten

2
char mask = 0b10000000;//Maske vor jedem Senden auf diesen Wert setzen

3


4
while(mask){

5


6
   if(spidata & mask){

7
      PORTX |= (1<<DATA);

8
   }else{

9
      PORTX &= ~(1<<DATA);

10
   }

11


12
   PORTX |= (1<<CLK);

13


14
   //Hier wird die Maske geschoben

15
   //macht auch paar clocks delay

16
   mask = mask >> 1;

17


18
   PORTX &= ~(1<<CLK);

19
}

20


21
PORTX |= (1<<LATCH);

22
PORTX &= ~(1<<LATCH);

mfg mf
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Maik C. OP #2047500
Lesenswert?
• ▲
▼ 
Turbo Toni schrieb:
> Das Prinzip so einer 8x 8 Matrix ist der Zeitmultiplexbetrtieb.
> Man schiebt die lezte zeile ins Register, dann schaltet man die unterste
> zeile ein, danach wird die wieder ausgeschaltet und die 2t unterste
> zeile in register geschoben. Dann wird diese zeile eingeschaltet... bis
> man bei der obersten Zeile angelangt ist. dann wird wieder von unten
> angefangen.
>
> Dieses multiplexing sollte in einer sich ständig wiederholenden
> Hauptschleife erfolgen oder mit einen Timerinterrupt.
>
> Beides kann ich in deinen Programm nicht erkennen.




das habe ich ja schon hinbekomme nur ohne Schieberegister. Nun will ich 
ein Schieberegister anschließen um die Matrix zu erweitern.

code ist im Anhang... so nun will ich diese erweitern. um z.b. eine 
8x16 anzuschließen.
Angehängte Dateien:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Achim M. #2047503
Lesenswert?
• ▲
▼ 
1
//enthält SPI Sendedaten

2
uint16_t spidata;

3


4
//Maske vor jedem Senden auf diesen Wert setzen

5
uint16_t = 0b1000000000000000;

6


7
while(mask){

8


9
   if(spidata & mask){

10
      PORTX |= (1<<DATA);

11
   }else{

12
      PORTX &= ~(1<<DATA);

13
   }

14


15
   PORTX |= (1<<CLK);

16


17
   //Hier wird die Maske geschoben

18
   //macht auch paar clocks delay

19
   mask = mask >> 1;

20


21
   PORTX &= ~(1<<CLK);

22
}

23


24
PORTX |= (1<<LATCH);

25
PORTX &= ~(1<<LATCH);

mfg mf

(PS: seen, my code hs not really changed since last time)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Turbo T. #2047531
Lesenswert?
• ▲
▼ 
Als zuerst die Clock-Ltg auf L setzen, dann das 8te bit testen, ist es L 
dann eine L auf die Datenleitung legen, ansonsten ein H, dann die 
Clock-ltg wieder auf H setzen, Clock wieder auf L, das 7te Bit testen 
und Datenltg entsprechend setzen, Clock wieder auf H ... bis das erste 
Bit ereicht is.
Dann die Store-ltg auf H setzen und danch wieder auf L.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2048510
Lesenswert?
• ▲
▼ 
Indem du ihn raustaktest.

0b00110011
  |
  |              Ausgangslage CLK auf 0, RCLK auf 0
  |
  +---------  weil hier eine 0 ist, Datenleitung auf 0
              danach CLK auf 1 und CLK wieder auf 0
   |
   +--------  nächste Stelle: wieder 0
              daher Datenleitung auf 0
              CLK auf 1, CLK auf 0
    |
    +-------  nächste Stelle: eine 1
              daher Datenleitung auf 1
              CLK auf 1, CLK auf 0

      ..... und so geht es dahin. Immer Datenleitung richtig
            einstellen und danach .... CLK auf 1 ... CLK auf 0


damit sind die 8 Bits in der Schiebekette gespeichert.

Einmal RCLK auf 1, RCLK auf 0

und der 595 schaltet die SChiebekette auf die Ausgangsleitungen und die 
Bits erscheinen dort.


So wie ich dir das weiter oben in Code schon mal gezeigt habe. Aber du 
wolltest ja lieber deinem Durcheinander von da mal einen Pin auf 1 
setzen, dort mal einen Pin auf 0 setzen vertrauen.

Wenns danach immer noch nicht geht, hast du irgendwo einen 
Verdrahtungsfehler.


Aber Achtung: Nur weil aus deinem Schieberegister da jetzt die richtigen 
Bits rauskommen, leuchtet höchst wahrscheinlich in deiner Matrix noch 
nichts.

Deswegen hatte ich ja nach einem Schaltplan nachgefragt. Nur ist der nie 
gekommen. Daher kann man auch nicht sagen, wie bei dir jetzt die 
Schieberegister eigentlich ins Spiel kommen.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2048583
Lesenswert?
• ▲
▼ 
Welches DATA?
Reden wir vom seleb Code?

1
void shift_int(u8 shiftData)    

2
{

3
  ShiftPort &= ~(LatchPin | ClkPin | DataPin);    

4
  

5
  for (char i=0; i<10; i++)

6
  {

7
    if (shiftData & (1<<i)) ShiftPort |= DataPin;    

8
    else ShiftPort &= ~DataPin;        

9


10
    ShiftPort |= ClkPin;        

11
    ShiftPort &= ~ClkPin;        

12
  }

13


14
  ShiftPort |= LatchPin;          

15
  ShiftPort &= ~LatchPin;      

16
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2048590
Lesenswert?
• ▲
▼ 
Ach du meinst Mini Float's Code!

1
//enthält SPI Sendedaten

2
uint16_t spidata;

3


4
//Maske vor jedem Senden auf diesen Wert setzen

5
uint16_t = 0b1000000000000000;

6


7
while(mask){

8


9
   if(spidata & mask){

10
      PORTX |= (1<<DATA);

11
   }else{

12
      PORTX &= ~(1<<DATA);

13
   }

14


15
   PORTX |= (1<<CLK);

16


17
   //Hier wird die Maske geschoben

18
   //macht auch paar clocks delay

19
   mask = mask >> 1;

20


21
   PORTX &= ~(1<<CLK);

22
}

23


24
PORTX |= (1<<LATCH);

25
PORTX &= ~(1<<LATCH);


wie wird denn das DATA verwendet?
Offenbar genauso wie du dein DataPin verwendet hast.
Also was wird das sein?

(Der einzige echte Unterschied: Mini Float hält sich an eine der wenigen 
welteit gültigen Konventionen, nach der man in C Makronamen 
grundsätzlich komplett in Grossbuchstaben schreibt. Und auch umgekehrt: 
die Schreibweise alles in Grossbuchstaben ist ausschliesslich Makronamen 
vorbehalten)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Maik C. OP #2048683
Lesenswert?
• ▲
▼ 
Karl heinz Buchegger schrieb:
> Deswegen testet man solche Dinge auch nicht gleicht mit dem möglichst
> komplizierten Code, den man kriegen kann, sondern mit einem einfachen
> simplen Einzelprogramm, welches nur darauf abzielt diese eine
> Funktionalität zu testen.
>
> :-)



SO ok die Funktion habe ich jetzt mal einzeln getestet und sie Funzt 
HEHE

dann liegt das also nur noch an meinem scheiß was ich da Programmiert 
habe :-(


aber ich danke euch schonmal.

:-) :-*

Ihr habt mir echt weiter geholfen
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren