74HCT165 Eingänge gehen nicht

[Alex (Gast)]

Hallo, ich habe mir eine Platine gebastelt. (S.Anhang) Für Diese 
Eingangsplatine habe ich folgenden Code. S.unten.
Ich bin erst mit einer Platine angefangen, insgesamt sollen mal neun 
Stück in Betrieb gehen!

Brücken sind gesteckt auf:
Jumper3: 2 und 3
Junper4: 1 und 2

jetzt funktionieren nur die ersten 8Bits, sprich der erste 74HCT165, 
nicht aber der Zweite! Kann mir einer sagen wodran das liegen 
könnte?!?!?

#define EPL_Anzahl 1                // Anzahl der Eingangsplatinen

void Eingaenge_abfragen ()
{
    PORTC |= (1<<PC4);

    // Mit PL alle Eingänge in das Register schieben.

    // PL auf High
    PORTC |= (1<<PC5);
    // PL auf Low
    PORTC &= ~(1<<PC5);
    // PL auf High
    PORTC |= (1<<PC5);

    int i=0; 
      //Abfragen welches Registerbit gesetzt -> mit clock weiter schieben
    for(i=(EPL_Anzahl * 16)-1;i>=0;i--)
    {
          
      if (PINA & (1<<PINA0)) 
      { // Logisch 0 wenn Schalter nicht gedrückt da Pullup an
      Eingang[i] = 0;     
      
            if      (i<= 7) StatusEingangByte1 &= ~(1 << i);
      else if (i<=15) StatusEingangByte2 &= ~(1 << i);
      
      else if (i<=23) StatusEingangByte3 &= ~(1 << i);
      else if (i<=31) StatusEingangByte4 &= ~(1 << i);
      
      else if (i<=47) StatusEingangByte5 &= ~(1 << i);
      else if (i<=55) StatusEingangByte6 &= ~(1 << i);
      
      else if (i<=63) StatusEingangByte7 &= ~(1 << i);
      else if (i<=71) StatusEingangByte8 &= ~(1 << i);
      
      else if (i<=79) StatusEingangByte9 &= ~(1 << i);
      else if (i<=87) StatusEingangByte10 &= ~(1 << i);
      
      else if (i<=95) StatusEingangByte11 &= ~(1 << i);
      else if (i<=103) StatusEingangByte12 &= ~(1 << i);
      
      else if (i<=111) StatusEingangByte13 &= ~(1 << i);
      else if (i<=119) StatusEingangByte14 &= ~(1 << i);
      
      else if (i<=127) StatusEingangByte15 &= ~(1 << i);
      else if (i<=135) StatusEingangByte16 &= ~(1 << i);
      
      else if (i<=143) StatusEingangByte17 &= ~(1 << i);
      else if (i<=151) StatusEingangByte18 &= ~(1 << i);
      
      } 
      else 
      {
      Eingang[i] = 1;  
      
      if      (i<= 7)  StatusEingangByte1 |= ( 1 << i );
      else if (i<= 15) StatusEingangByte2 |= ( 1 << i );
      
      else if (i<= 23) StatusEingangByte3 |= ( 1 << i );
      else if (i<= 31) StatusEingangByte4 |= ( 1 << i );
    
      else if (i<= 47) StatusEingangByte5 |= ( 1 << i );  
      else if (i<= 55) StatusEingangByte6 |= ( 1 << i );
      
      else if (i<= 63) StatusEingangByte7 |= ( 1 << i );
      else if (i<= 71) StatusEingangByte8 |= ( 1 << i );
      
      else if (i<= 79) StatusEingangByte9 |= ( 1 << i );
      else if (i<= 87) StatusEingangByte10 |= ( 1 << i );
      
      else if (i<= 95) StatusEingangByte11 |= ( 1 << i );
      else if (i<= 103) StatusEingangByte12 |= ( 1 << i );
      
      else if (i<= 111) StatusEingangByte13 |= ( 1 << i );
      else if (i<= 119) StatusEingangByte14 |= ( 1 << i );
      
      else if (i<= 127) StatusEingangByte15 |= ( 1 << i );
      else if (i<= 135) StatusEingangByte16 |= ( 1 << i );
      
      else if (i<= 143) StatusEingangByte17 |= ( 1 << i );
      else if (i<= 151) StatusEingangByte18 |= ( 1 << i );
      }        
      
      
      //Änderung feststellen      
      if ((memmEingangByte1 != StatusEingangByte1) || 
        (memmEingangByte2 != StatusEingangByte2) || 
        (memmEingangByte3 != StatusEingangByte3) || 
        (memmEingangByte4 != StatusEingangByte4) || 
        (memmEingangByte5 != StatusEingangByte5) || 
        (memmEingangByte6 != StatusEingangByte6) ||         
        (memmEingangByte7 != StatusEingangByte7) ||
        (memmEingangByte8 != StatusEingangByte8) ||
        (memmEingangByte9 != StatusEingangByte9) ||
        (memmEingangByte10 != StatusEingangByte10) ||
        (memmEingangByte11 != StatusEingangByte11) ||
        (memmEingangByte12 != StatusEingangByte12) ||
        (memmEingangByte13 != StatusEingangByte13) ||
        (memmEingangByte14 != StatusEingangByte14) ||
        (memmEingangByte15 != StatusEingangByte15) ||
        (memmEingangByte16 != StatusEingangByte16) ||
        (memmEingangByte17 != StatusEingangByte17) ||        
        (memmEingangByte18 != StatusEingangByte18))
        {      
        //Status bei Änderung neu zur Visu übertragen
        usart_writePC("84|01|01|%1i\r",StatusEingangByte1); //Satus Eingang byte
        usart_writePC("84|01|02|%1i\r",StatusEingangByte2); //Satus Eingang byte
        usart_writePC("84|01|03|%1i\r",StatusEingangByte3); //Satus Eingang byte
        usart_writePC("84|01|04|%1i\r",StatusEingangByte4); //Satus Eingang byte
        usart_writePC("84|01|05|%1i\r",StatusEingangByte5); //Satus Eingang byte
        usart_writePC("84|01|06|%1i\r",StatusEingangByte6); //Satus Eingang byte
        usart_writePC("84|01|07|%1i\r",StatusEingangByte7); //Satus Eingang byte
        usart_writePC("84|01|08|%1i\r",StatusEingangByte8); //Satus Eingang byte        
        usart_writePC("84|01|09|%1i\r",StatusEingangByte9); //Satus Eingang byte
        usart_writePC("84|01|10|%1i\r",StatusEingangByte10); //Satus Eingang byte
        usart_writePC("84|01|11|%1i\r",StatusEingangByte11); //Satus Eingang byte
        usart_writePC("84|01|12|%1i\r",StatusEingangByte12); //Satus Eingang byte        
        usart_writePC("84|01|13|%1i\r",StatusEingangByte13); //Satus Eingang byte
        usart_writePC("84|01|14|%1i\r",StatusEingangByte14); //Satus Eingang byte
        usart_writePC("84|01|15|%1i\r",StatusEingangByte15); //Satus Eingang byte
        usart_writePC("84|01|16|%1i\r",StatusEingangByte16); //Satus Eingang byte        
        usart_writePC("84|01|17|%1i\r",StatusEingangByte17); //Satus Eingang byte
        usart_writePC("84|01|18|%1i\r",StatusEingangByte18); //Satus Eingang byte          
        
      
        //Memm Variablen wieder gleich setzen
        memmEingangByte1 = StatusEingangByte1;      
        memmEingangByte2 = StatusEingangByte2;      
        memmEingangByte3 = StatusEingangByte3;    
        memmEingangByte4 = StatusEingangByte4;      
        memmEingangByte5 = StatusEingangByte5;    
        memmEingangByte6 = StatusEingangByte6;  
        memmEingangByte7 = StatusEingangByte7;      
        memmEingangByte8 = StatusEingangByte8;      
        memmEingangByte9 = StatusEingangByte9;    
        memmEingangByte10 = StatusEingangByte10;      
        memmEingangByte11 = StatusEingangByte11;    
        memmEingangByte12 = StatusEingangByte12;  
        memmEingangByte13 = StatusEingangByte13;      
        memmEingangByte14 = StatusEingangByte14;      
        memmEingangByte15 = StatusEingangByte15;    
        memmEingangByte16 = StatusEingangByte16;      
        memmEingangByte17 = StatusEingangByte17;    
        memmEingangByte18 = StatusEingangByte18;      
        }      
              
              
      // Mit Clock weiterschieben

      // Clock auf High
      PORTC |= (1<<PC4);
      // Clock auf Low
      PORTC &= ~(1<<PC4);
      // Clock auf High
      PORTC |= (1<<PC4);    
    }  // For Ende    
}

[Alex (Gast)]

und der Schaltplan noch...

[bko (Gast)]

übersehe ich nur etwas, oder wo ist der Gnd in dem Layout?

[Alex (Gast)]

Em...ja der ist als Polygon ausgeführt. Auf dem Screenshot ist nur der 
gestrichelte Rand zu sehen! Aber gehen wir mal davon aus, dass er 
überall zu Verfügung steht! Später lade ich mal mit kompletter 
Massefläche hoch!

[Mike (Gast)]

Alex schrieb:
> 1.jpg
> 957,2 KB

Alex schrieb:
> 2.jpg
> 221,3 KB

Den Hinweis zu Bildformaten beim Upload hast du gelesen und inhaltlich 
verstanden?

Mit dem JPG-Format verkommt jede noch so scharfe Linienzeichnung zu 
einem weichgezeichneten Pixelbrei. Und die Gitternetzlinien 
interessieren niemand. Warum tust du uns das an???
PNG wurde extra für verlustlose Kompression von Grafiken mit wenig 
Farben und scharfen Linien erfunden.

[Alex (Gast)]

Man kann aber so auch alles erkennen, wenn man nur will!

[Falk B. (falk)]

@Alex (Gast)

>    1.jpg
>    957,2 KB, 33 Downloads

Kleiner Tip: Bildformate, auch wenn man alles erkennen kann.


>Hallo, ich habe mir eine Platine gebastelt. (S.Anhang) Für Diese
>Eingangsplatine habe ich folgenden Code. S.unten.

Dein Programmierstil ist, ähhh, ausbaufähig. Schon mal was von Array und 
Schleifen gehört?

>jetzt funktionieren nur die ersten 8Bits, sprich der erste 74HCT165,
>nicht aber der Zweite! Kann mir einer sagen wodran das liegen
>könnte?!?!?

Der Schaltplan sieht OK aus, dein Programm, wenn gleich arg 
gewöhnungsbedürftig soweit auch.

Prüfe, ob deine Verbindungen auf der Platine stimmen. Zur 
Fehlersuche kann man nach jedem Portzugriff eine _delay_ms(1000) 
einfügen, dann kann man das Klappern der Bits mit ein paar LEDs in den 
Signalleitungen verfolgen, auch ohne Oszi.

[Alex (Gast)]

Danke für die Antwort, ja mit Arrays hast du recht! Oszi hätte ich zur 
Hand, aber nur ein altes mit zwei Kanälen.
Also meinst du auch der Fehler müsste irgendwo auf der Platine 
liegen...ist auch meine Vermutung, da das erste 74HCT165 ja geht...

[Falk B. (falk)]

@ Alex (Gast)

>Danke für die Antwort, ja mit Arrays hast du recht! Oszi hätte ich zur
>Hand,

Dann nutze es!

> aber nur ein altes mit zwei Kanälen.

Reicht das nicht?

http://www.mikrocontroller.net/articles/Fehlersuche#Tips_zum_Hardwaredebugging

[Alex (Gast)]

Ja, das mit dem delay war ein guter Tip, sonst bringt mir das Osi 
irgendwie nicht viel. Kann nicht super damit umgehen. Nur für ein 
Phasenanschnitt habe ich es gebrauchen können.
Ich habe jetzt nochmal 4 andere Platinen zum Testen verwendet und alle 
hatten die gleichen Symptome. Es ging immer nur das erste 
Schieberegister.
Im Anhang noch einmal mit Massefläche, evtl. seht ihr irgendwo nen 
fehelendes GND oder so... ich weiss es nicht. Werde mal das messen 
machen...Danke

[Falk B. (falk)]

@ Alex (Gast)

>Ja, das mit dem delay war ein guter Tip, sonst bringt mir das Osi
>irgendwie nicht viel.

Aua!

> Kann nicht super damit umgehen.

Dann lerne es! Ein Oszi ist ein SEHR leistungsfähiges Messmittel!

> Nur für ein
>Phasenanschnitt habe ich es gebrauchen können.

"Viele Vorgänge in Mikrocontrollerschaltungen sind nicht periodisch. Um 
sie zu messen braucht man meist ein Digitaloszilloskop. Hat man sowas 
nicht zur Verfügung, muss man versuchen, die Vorgänge periodisch zu 
machen, indem man z.B. eine Datenausgabe per UART oder SPI in einer 
Schleife immer wieder ausführt. Damit kann man sie auch mit einem 
Analogoszilloskop darstellen."

Kanal 1 an PL, dort wird auch getriggert. Mit dem 2. Kanal kann man 
wunderschön alle Signale prüfen und hat IMMER den richtigen Zeitbezug.

[Falk B. (falk)]

@Alex (Gast)

>    1.png
>    48,8 KB, 0 Downloads

Was sollen die Schlangenlinien? Längenausgleich? Nicht bei den 
Taktfrequenzen ;-)
Masseflächen sind zwar hipp, hier aber nicht wirklich nötig. Ausserdem 
viel zu zerschnitten, um wirklich wirksam zu sein.

http://www.mikrocontroller.net/articles/Richtiges_Designen_von_Platinenlayouts#Vorgehen_bei_der_Layouterstellung

[Peter D. (peda)]

Dieses Codemonster mag sich keiner ansehen, das ist die pure Folter für 
das Auge eines jeden Programmierers.

Du mußt modular denken und programieren.

Schreib erstmal eine Funktion, die ein Byte einliest.
Die ruft man dann 2-mal auf und schon hast Du 16Bit.
Die kannst Du nun bitweise auswerten.
Dazu schreibt man keine kryptischen if-else Monster, denn die versagen, 
sobald 2 Tasten gedrückt sind.
Man prüft sie also richtig bitweise.
Am einfachsten rotiert man sie in einer Schleife, so das jedes Bit mal 
Bit 1 ist und das testet man dann.

Und man schreibt auch keine 100 Ausgaben, sondern eine einzige, die die 
geänderten Werte als Variable ausgibt.

Und welchen Sinn hat es, aus 16 Bits 36 Byte zu machen?

[Alex (Gast)]

Danke Peter für deine Antwort:

Also ich habe die Funktion gekürzt und Sie funktioniert augenscheinlich:

Jetzt will ich noch am einfachsten das geänderte Bit an die Serielle 
übergeben, und in eine 8Bit große Variable abspeichern. Sei ersteinmal 
egal wofür man das gebrauchen kann... Kannst Du mir bitte sagen wie ich 
das am schönsten machen kann?

void Eingaenge_abfragen ()
{

    PORTC |= (1<<PC4);

    // Mit PL alle Eingänge in das Register schieben.

    // PL auf High
    PORTC |= (1<<PC5);
    // PL auf Low
    PORTC &= ~(1<<PC5);
    // PL auf High
    PORTC |= (1<<PC5);

    int i; 
      //Abfragen welches Registerbit gesetzt -> mit clock weiter schieben
    for(i=16-1;i>=0;i--)
    {
          
      if (PINA & (1<<PINA0)) 
      { // Logisch 0 wenn Schalter nicht gedrückt da Pullup an
      Eingang[i] = 0;     

      }
      else 
      {
      Eingang[i] = 1;  
      }        

              
      // Mit Clock weiterschieben

      // Clock auf High
      PORTC |= (1<<PC4);
      // Clock auf Low
      PORTC &= ~(1<<PC4);
      // Clock auf High
      PORTC |= (1<<PC4);    
    }  // For Ende    
}

[Dietrich L. (dietrichl)]

Alex schrieb:
> Kannst Du mir bitte sagen wie ich
> das am schönsten machen kann?

Vorschlag:
Nimm statt dem Array "Eingang[]" gleich eine 16-Bit Variable. Dann setze 
in der Schleife das Bit PINA0 auf das Bit 0 der Variablen und schiebe 
die Variable 1x nach links.
Zum Schluss hast Du dann alle Bits schön aufgereiht in der Variablen und 
kannst das Low-Byte und das High-Byte an die serielle Schnittstelle 
übergeben.

Gruß Dietrich

[6A66 (Gast)]

Alex schrieb:
> Brücken sind gesteckt auf:
> Jumper3: 2 und 3
> Junper4: 1 und 2

Sollte das nicht anders sein??? Zumindest nach Schaltplan?

rgds

[Alex (Gast)]

Dietrich L. schrieb:
> Alex schrieb:
>> Kannst Du mir bitte sagen wie ich
>> das am schönsten machen kann?
>
> Vorschlag:
> Nimm statt dem Array "Eingang[]" gleich eine 16-Bit Variable. Dann setze
> in der Schleife das Bit PINA0 auf das Bit 0 der Variablen und schiebe
> die Variable 1x nach links.
> Zum Schluss hast Du dann alle Bits schön aufgereiht in der Variablen und
> kannst das Low-Byte und das High-Byte an die serielle Schnittstelle
> übergeben.
>
> Gruß Dietrich

Jou so versuche ich's mal...