mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Schiebregister


Autor: Maik C. (maik_c)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,


was ist an diesem Programm falsch?

Wie kann ich meine Werte in das Schieberegister übertragen?


Programm ist im Anhang

#include <avr/io.h>          
#define  F_CPU 1000000UL
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>



#define A     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01111110,0b01000010,0b01000010,0b01000010,0b00000000}
#define B     {0b00000000,0b01111100,0b01000010,0b01000010,0b01111100,0b01000010,0b01000010,0b01000010,0b01111100,0b00000000}
#define C     {0b00000000,0b00111110,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b00111110,0b00000000}
#define D     {0b00000000,0b01111100,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01111100,0b00000000}
#define E     {0b00000000,0b01111110,0b01000000,0b01000000,0b01111100,0b01000000,0b01000000,0b01000000,0b01111110,0b00000000}
#define F     {0b00000000,0b01111110,0b01000000,0b01000000,0b01111100,0b01000000,0b01000000,0b01000000,0b01000000,0b00000000}
#define G     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000000,0b01000111,0b01000010,0b01000010,0b00111100,0b00000000}
#define H     {0b00000000,0b01000010,0b01000010,0b01000010,0b01111110,0b01000010,0b01000010,0b01000010,0b01000010,0b00000000}
#define I     {0b00000000,0b00111000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00111000,0b00000000}
#define J     {0b00000000,0b00011100,0b00001000,0b00001000,0b00001000,0b00001000,0b01001000,0b01001000,0b00110000,0b00000000}
#define K     {0b00000000,0b01000100,0b01001000,0b01010000,0b01100000,0b01010000,0b01001000,0b01000100,0b01000010,0b00000000}
#define L     {0b00000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01111110,0b00000000}
#define M     {0b00000000,0b01000100,0b10101010,0b10010010,0b10010010,0b10000010,0b10000010,0b10000010,0b10000010,0b00000000}
#define N     {0b00000000,0b01000010,0b01100010,0b01010010,0b01001010,0b01001010,0b01001010,0b01000110,0b01000010,0b00000000}
#define O     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}
#define P     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01111100,0b01000000,0b01000000,0b01000000,0b00000000}
#define Q     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000110,0b00111110,0b00000001}
#define R     {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b01111100,0b01000100,0b01000010,0b01000010,0b00000000}
#define S     {0b00000000,0b00111100,0b01000010,0b01000000,0b01000000,0b00111100,0b00000010,0b01000010,0b00111100,0b00000000}
#define T     {0b00000000,0b11111110,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}
#define U     {0b00000000,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}
#define V     {0b00000000,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b00100100,0b00011000,0b00000000}
#define W     {0b00000000,0b10000010,0b10000010,0b10000010,0b10000010,0b10010010,0b10010010,0b10101010,0b01000100,0b00000000}
#define X     {0b00000000,0b01000010,0b01000010,0b00100100,0b00011000,0b00011000,0b00100100,0b01000010,0b01000010,0b00000000}
#define Y     {0b00000000,0b10000010,0b01000100,0b00101000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}
#define Z     {0b00000000,0b01111110,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b01111110,0b00000000}
#define lit_a {0b00000000,0b00000000,0b00000000,0b00000000,0b00111000,0b01000100,0b01000101,0b01000101,0b00111010,0b00000000}
#define lit_b {0b00000000,0b00000000,0b00100000,0b00100000,0b00100000,0b00111100,0b00100010,0b00100010,0b00111100,0b00000000}
#define lit_c {0b00000000,0b00000000,0b00000000,0b00000000,0b00111100,0b01000000,0b01000000,0b01000000,0b00111100,0b00000000}
#define lit_d {0b00000000,0b00000000,0b00000100,0b00000100,0b00000100,0b00111100,0b01000100,0b01000100,0b00111100,0b00000000}
#define lit_e {0b00000000,0b00000000,0b00000000,0b00111000,0b01000100,0b01000100,0b01111000,0b01000000,0b00111100,0b00000000}
#define lit_f {0b00000000,0b00011000,0b00100100,0b00100000,0b00100000,0b01110000,0b00100000,0b00100000,0b00100000,0b00000000}
#define lit_g {0b00000000,0b00011100,0b00100010,0b00100010,0b00011110,0b00000010,0b00000010,0b00010010,0b00001100,0b00000000}
#define lit_h {0b00000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01111000,0b01000100,0b01000100,0b01000100,0b00000000}
#define lit_i {0b00000000,0b00000000,0b00010000,0b00000000,0b00010000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}
#define lit_j {0b00000000,0b00000000,0b00010000,0b00000000,0b00010000,0b00010000,0b00010000,0b01010000,0b00110000,0b00000000}
#define lit_k {0b00000000,0b00000000,0b00000000,0b01001000,0b01010000,0b01100000,0b01100000,0b01010000,0b01001000,0b00000000}
#define lit_l {0b00000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b00000000}
#define lit_m {0b00000000,0b00000000,0b00000000,0b00110100,0b01001010,0b01001010,0b01001010,0b01001010,0b01001010,0b00000000}
#define lit_n {0b00000000,0b00000000,0b00000000,0b01111000,0b01000100,0b01000100,0b01000100,0b01000100,0b01000100,0b00000000}
#define lit_o {0b00000000,0b00000000,0b00000000,0b00000000,0b00011100,0b00100010,0b00100010,0b00100010,0b00011100,0b00000000}
#define lit_p {0b00000000,0b00000000,0b00000000,0b00011100,0b00100010,0b00100010,0b00111100,0b00100000,0b00100000,0b00100000}
#define lit_q {0b00000000,0b00000000,0b00000000,0b00111000,0b01000100,0b01000100,0b00111100,0b00000100,0b00000100,0b00000100}
#define lit_r {0b00000000,0b00000000,0b00000000,0b00111000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b00000000}
#define lit_s {0b00000000,0b00000000,0b00111000,0b01000100,0b01000000,0b00111000,0b00000100,0b01000100,0b00111000,0b00000000}
#define lit_t {0b00000000,0b00100000,0b00100000,0b00100000,0b01111000,0b00100000,0b00100000,0b00100010,0b00011100,0b00000000}
#define lit_u {0b00000000,0b00000000,0b00000000,0b00000000,0b01000100,0b01000100,0b01000100,0b01000100,0b00111000,0b00000000}
#define lit_v {0b00000000,0b00000000,0b00000000,0b01000100,0b01000100,0b01000100,0b01000100,0b00101000,0b00010000,0b00000000}
#define lit_w {0b00000000,0b00000000,0b00000000,0b00000000,0b01000100,0b01000100,0b01010100,0b01010100,0b00101000,0b00000000}
#define lit_x {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00100100,0b00011000,0b00011000,0b00100100,0b00000000}
#define lit_y {0b00000000,0b00000000,0b01000100,0b01000100,0b00111100,0b00000100,0b00000100,0b00000100,0b00111000,0b00000000}
#define lit_z {0b00000000,0b00000000,0b00000000,0b00000000,0b01111100,0b00001000,0b00010000,0b00100000,0b01111100,0b00000000}
#define space {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000}
#define num_0 {0b00000000,0b00111100,0b01000110,0b01001010,0b01001010,0b01001010,0b01010010,0b01100010,0b00111100,0b00000000}
#define num_1 {0b00000000,0b00001000,0b00011000,0b00001000,0b00001000,0b00001000,0b00001000,0b00001000,0b00011100,0b00000000}
#define num_2 {0b00000000,0b00111100,0b01000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b01111110,0b00000000}
#define num_3 {0b00000000,0b01111110,0b00000010,0b00000010,0b00011100,0b00000010,0b00000010,0b01000010,0b00111100,0b00000000}
#define num_4 {0b00000000,0b00000100,0b00001100,0b00010100,0b00100100,0b01000100,0b01111110,0b00000100,0b00000100,0b00000000}
#define num_5 {0b00000000,0b01111110,0b01000000,0b01000000,0b00111100,0b00000010,0b00000010,0b00000010,0b01111100,0b00000000}
#define num_6 {0b00000000,0b00111100,0b01000000,0b01000000,0b01111100,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}
#define num_7 {0b00000000,0b01111110,0b00000010,0b00000100,0b00001000,0b00010000,0b00010000,0b00010000,0b00010000,0b00000000}
#define num_8 {0b00000000,0b00111100,0b01000010,0b01000010,0b00111100,0b01000010,0b01000010,0b01000010,0b00111100,0b00000000}
#define num_9 {0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,0b00111110,0b00000010,0b00000010,0b00111100,0b00000000}
#define times {0b00000000,0b00000000,0b01000010,0b00100100,0b00011000,0b00011000,0b00100100,0b01000010,0b00000000,0b00000000}
#define aus   {0b00000000,0b00011000,0b00011000,0b00011000,0b00011000,0b00011000,0b00000000,0b00011000,0b00011000,0b00000000}
#define col    {0b00000000,0b01111111,0b10111111,0b11011111,0b11101111,0b11110111,0b11111011,0b11111101,0b11111110,0b00000000}
#define herz  {0b00000000,0b01101100,0b11111110,0b11111110,0b01111100,0b01111100,0b00111000,0b00111000,0b00010000,0b00000000}
#define herz2 {0b00000000,0b01101100,0b10010010,0b10000010,0b01000100,0b01000100,0b00101000,0b00010000,0b00000000,0b00000000}
#define und   {0b00000000,0b00011000,0b00011000,0b00011000,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000,0b00000000}
#define gl    {0b00000000,0b00000000,0b00000000,0b00111100,0b00000000,0b00000000,0b00111100,0b00000000,0b00000000,0b00000000}


#define ShiftPort   PORTC
#define ShiftDDR  DDRC
#define LatchPin  (1 << 0)
#define DataPin    (1 << 1)
#define ClkPin    (1 << 2)


typedef unsigned char u8;
typedef unsigned int u16;

unsigned int txtl = 7;

unsigned int text_1[7][10]  = {space,H,A,L,L,O,space};      //Ausgabe Text definieren (Reihe high)
unsigned int reihe [1][10]   = {col};                        //Input Ports definieren  (Spalten low)

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




void shift_int(u8 shiftData)    
{
  ShiftPort &= ~(LatchPin | ClkPin | DataPin);    
  
  for (char i=0; i<10; i++)
  {
    ShiftPort &= ~ClkPin;        

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

    ShiftPort |= ClkPin;        
    ShiftPort &= ~DataPin;        
  }

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





void einzeln(int loop, int time){          // Die Buchstaben werden einzeln nacheinander ausgegeben.
                          //
 for(i=0; i<loop; i++){              // Wiederholungen der Buchstaben
  for(y=0; y<txtl; y++){              // 
   for(a=0; a<time; a++){              // Anzeigedauer der einzelnen Buchstaben
    for(x=0; x<10; x--){              //
  temp_1 = text_1[y][x];              // 
    temp_2 = reihe[0][x];
    shift_int(text_1);
    PORTD  = temp_2;
    _delay_ms(2);
          
    }
   }
  }
 }
}



void port_init(void){        //Ports definieren  
DDRB = 0b11111111;          //rows 
DDRD = 0b11111111;             //cols
}


//(Matrix löschen)

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




int main (void) {         
      
port_init();  
clear_matrix();

einzeln(9,5);

  while(1) {

    
  }


}





Autor: Turbo Toni (turbotoni)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das ist für eine LED Matrix. 8x8

Autor: Turbo Toni (turbotoni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Und was fürn Controller und wie ist die matrix angeschlossen ?

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht 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/Sc...


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.

Autor: Turbo Toni (turbotoni)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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

void shift_int(u8 shiftData)    
{
  ShiftPort &= ~(LatchPin | ClkPin | DataPin);    
  
  for (char i=0; i<10; i++)
  {
    if (shiftData & (1<<i)) ShiftPort |= DataPin;    
    else ShiftPort &= ~DataPin;        

    ShiftPort |= ClkPin;        
    ShiftPort &= ~ClkPin;        
  }

  ShiftPort |= LatchPin;          
  ShiftPort &= ~LatchPin;      
}


Und dann schau dir das hier mal an:
void einzeln(int loop, int time){          // Die Buchstaben werden einzeln nacheinander ausgegeben.
                          //
 for(i=0; i<loop; i++){              // Wiederholungen der Buchstaben
  for(y=0; y<txtl; y++){              // 
   for(a=0; a<time; a++){              // Anzeigedauer der einzelnen Buchstaben
    for(x=0; x<10; x--){              //
  temp_1 = text_1[y][x];              // 
    temp_2 = reihe[0][x];
    shift_int(text_1);
    PORTD  = temp_2;
    _delay_ms(2);
          
    }
   }
  }
 }
}

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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Maik C. schrieb:

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

Und wie kommt da jetzt das Schieberegister ins Spiel?

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

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

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ne hat er nicht aber da soll eig temp_1 rein

also so:
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?

Autor: Joachim K. (minifloat)
Datum:

Bewertung
0 lesenswert
nicht 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:
char mycharlist[] PROGMEM = {/*das ganze Array einfach runterschreiben*/}

void printchar(char mychar)
{
   char offset = 0;

   if (mychar >= 'A' && mychar <= 'Z'){
      mychar -= 'A';
      offset += 0;
   } else if (mychar >= 'a' && mychar <= 'z'){
      mychar -= 'a';
      offset += 26;
   } else if (mychar >= '0' && mychar <= '9'){
      mychar -= '0';
      offset += 52;
   } //und so weiter
   
   for(int i = 0; i < 8; i++){
   soft_spi_out(pgm_read_byte(mycharlist + offset + mychar + i));
   }
}
sobald du den print_char hast, kannst du einfachst auch strings 
ausgeben.
mfg mf

Autor: Turbo Toni (turbotoni)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Joachim K. (minifloat)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Warum nicht gleich eine Maske mit einer 1 schieben, bis die "hinten 
runter fällt"?
char spidata;//enthält SPI Sendedaten
char mask = 0b10000000;//Maske vor jedem Senden auf diesen Wert setzen

while(mask){

   if(spidata & mask){
      PORTX |= (1<<DATA);
   }else{
      PORTX &= ~(1<<DATA);
   }

   PORTX |= (1<<CLK);

   //Hier wird die Maske geschoben
   //macht auch paar clocks delay
   mask = mask >> 1;

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

PORTX |= (1<<LATCH);
PORTX &= ~(1<<LATCH);
mfg mf

Autor: Maik C. (maik_c)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht 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.

Autor: Joachim K. (minifloat)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
//enthält SPI Sendedaten
uint16_t spidata;

//Maske vor jedem Senden auf diesen Wert setzen
uint16_t = 0b1000000000000000;

while(mask){

   if(spidata & mask){
      PORTX |= (1<<DATA);
   }else{
      PORTX &= ~(1<<DATA);
   }

   PORTX |= (1<<CLK);

   //Hier wird die Maske geschoben
   //macht auch paar clocks delay
   mask = mask >> 1;

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

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

mfg mf

(PS: seen, my code hs not really changed since last time)

Autor: Turbo Toni (turbotoni)
Datum:

Bewertung
0 lesenswert
nicht 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&ta...

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht 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&ta...



Mit Bascom kenne ich mich leider nicht aus :-(

Autor: Joachim K. (minifloat)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Turbo Toni (turbotoni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ist das nun ein 595 Register ?

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Turbo Toni schrieb:
> ist das nun ein 595 Register ?

oh ja ^^ sryhab ich vergessen zu sagen

Autor: Joachim K. (minifloat)
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Turbo Toni (turbotoni)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Joachim K. (minifloat)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich halte mich ab jetzt raus.

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe da mal ne Frage an deinem Codebeispiel.

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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Welches DATA?
Reden wir vom seleb Code?
void shift_int(u8 shiftData)    
{
  ShiftPort &= ~(LatchPin | ClkPin | DataPin);    
  
  for (char i=0; i<10; i++)
  {
    if (shiftData & (1<<i)) ShiftPort |= DataPin;    
    else ShiftPort &= ~DataPin;        

    ShiftPort |= ClkPin;        
    ShiftPort &= ~ClkPin;        
  }

  ShiftPort |= LatchPin;          
  ShiftPort &= ~LatchPin;      
}

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ach du meinst Mini Float's Code!
//enthält SPI Sendedaten
uint16_t spidata;

//Maske vor jedem Senden auf diesen Wert setzen
uint16_t = 0b1000000000000000;

while(mask){

   if(spidata & mask){
      PORTX |= (1<<DATA);
   }else{
      PORTX &= ~(1<<DATA);
   }

   PORTX |= (1<<CLK);

   //Hier wird die Maske geschoben
   //macht auch paar clocks delay
   mask = mask >> 1;

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

PORTX |= (1<<LATCH);
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)

Autor: Maik C. (maik_c)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht 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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.

:-)

Autor: Maik C. (maik_c)
Datum:

Bewertung
0 lesenswert
nicht 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 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]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [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.