Forum: Mikrocontroller und Digitale Elektronik Schiebregister


Schiebregister
von Maik C. (maik_c)

Angehängte Dateien:
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
}


  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Turbo T.
        (turbotoni)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Da niemand weis, für was das Programm da sein soll, kann man auch so 
pauschal nicht sagen was daran falsch sein soll.

MfG Turbotoni

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Das ist für eine LED Matrix. 8x8

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Turbo T.
        (turbotoni)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Und was fürn Controller und wie ist die matrix angeschlossen ?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Turbo T.
        (turbotoni)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Maik C. schrieb:

> und so ist die Matrix aufgebaut....
>
>
> http://www.mikrocontroller.net/attachment/51115/Schaltplan_LED_Matrix.png

Und wie kommt da jetzt das Schieberegister ins Spiel?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Irgendwie fehlt mir da bei dir was.
Wo werden da die Zeilen angesteuert und wo die Spalten?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
ne hat er nicht aber da soll eig temp_1 rein

also so:
1
shift_int(temp_1);


da habe ich mich vertippt.

Ich habe den Code gekürzt. da die anderen Funktionen unwichtig sind.



aber ich erzeuge doch einen Impuls.

oder nicht?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Achim M.
        (minifloat)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Turbo T.
        (turbotoni)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Achim M.
        (minifloat)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

      

      

      Angehängte Dateien:


      

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Achim M.
        (minifloat)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Turbo T.
        (turbotoni)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Es gibt da ein schönes Beispiel, allerdings ist das in BASCOM 
geschrieben.
Da wird eine 48 x 8 Matrix angesteuert.
http://mcselec.com/index.php?option=com_content&task=view&id=225&Itemid=57

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Turbo Toni schrieb:
> Es gibt da ein schönes Beispiel, allerdings ist das in BASCOM
> geschrieben.
> Da wird eine 48 x 8 Matrix angesteuert.
> http://mcselec.com/index.php?option=com_content&task=view&id=225&Itemid=57



Mit Bascom kenne ich mich leider nicht aus :-(

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Achim M.
        (minifloat)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Die Register dann einfach Daisy-Chainen, also letzten ungelatchten OUT 
an IN vom nächsten, der Kram wird dann "durchgeschoben". Latch und Clock 
bekommen beide denselben. mfg mf

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Turbo T.
        (turbotoni)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
ist das nun ein 595 Register ?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Turbo Toni schrieb:
> ist das nun ein 595 Register ?

oh ja ^^ sryhab ich vergessen zu sagen

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Achim M.
        (minifloat)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister#Kaskadieren_von_Schieberegistern

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Turbo T.
        (turbotoni)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Achim M.
        (minifloat)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich halte mich ab jetzt raus.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
mal ne ganz andere Frage....

wie bekomme ich denn jetzt den Wert  (z.b. 0b00110011) in das 
Schieberegister?

wenn ich den in einem Array[1][1]{0b00110011}; gespeichert habe.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich habe da mal ne Frage an deinem Codebeispiel.

was bedeutet bei dir DATA.... was ist darin gespeichert?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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
}


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

      

      

      Angehängte Dateien:


      

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
So ich habe das jetzt wie folgt umgeschrieben.

nur wenn ich in meinem Simulator gucke wie die Ports angesteuert 
werden... werden immer nur clk und latch angesteuert... der datenpin 
bleib die ganze zeit low

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
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.

:-)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Schiebregister
  


  

    

      von
      
        Maik C.
        (maik_c)
        
      
      


      
    


    

      
    

    

    

  
  


  

  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

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.