Eingangsschieberegister 74HCT165 in C

[Tom (Gast)]

Hallo,

bin ja noch relativer Neuling aber arbeite mich grade hoch.

Nur meine 74HCT165 bringen mir Werte, die ich nicht wirklich 
nachvollziehen kann (wenn ich mehrfach nacheinander auslese bleiben die 
16bit (2 stück kaskadiert) aber gleich, also kein Zufallsgenerator ;) )


Folgenden Code lass ich ablaufen, irgendwo muss da wohl ein Fehler sein 
aber ich komm auch nach mehreren Stunden nicht drauf wo...

// zur leichteren Behandlung erstmal Makros definieren
// DPORT ist der Port, an dem die Daten seriell gelesen werden (sollen)
// CPORT clock
// RPORT parallel Load

  #define __SRI_DPORT__ PINC
  #define __SRI_DDDR__  DDRC
  #define __SRI_CPORT__ PORTD
  #define __SRI_CDDR__  DDRD
  #define __SRI_RPORT__ PORTD
  #define __SRI_RDDR__  DDRD
       
  #define __SRI_DPIN__ 0
  #define __SRI_CPIN__ 3
  #define __SRI_RPIN__ 4

// Nur DPORT ist Eingang, die anderen beiden Ausgaenge
  __SRI_DDDR__ &= ~(1 << __SRI_DPIN__);
  __SRI_CDDR__ |= (1 << __SRI_CPIN__);
  __SRI_RDDR__ |= (1 << __SRI_RPIN__);

// Die routine zum einlesen (die 16bit werden in eine uint32_t variable
// gelesen (sr_Input)

void readSR_In(void) {
  int i;

  /* CLK auf High, dann PL LOW HIGH*/
  __SRI_CPORT__ |= (1 << __SRI_CPIN__);
  __SRI_RPORT__ &= ~(1 << __SRI_RPIN__);
  __SRI_RPORT__ |= (1 << __SRI_RPIN__);

  for (i=0; i < MAX_SRP_INPUT; i++) {

                // Bit pruefen
    if ((__SRI_DPORT__ & (1 << __SRI_DPIN__))) {
      sr_Input |= (1UL << i);
    } else {
      sr_Input &= ~(1UL << i);
    }

                //clock
    __SRI_CPORT__ &= ~(1 << __SRI_CPIN__);
    __SRI_CPORT__ |= (1 << __SRI_CPIN__);
  }
}

Das sollte doch so funktionieren :-(
Wenn niemand beim drüberschauen nen fatalen fehler findet muss ich als 
nächstes auf der hardware schaun. IC gebraten?!


Vielen vielen Dank!

[Matthias L. (Gast)]

-> Code ist unvollständig,
-> Schaltplan hinzufügen,
-> Wieso kein Hardware SPI?

[Peter D. (peda)]

Tom wrote:
> bin ja noch relativer Neuling aber arbeite mich grade hoch.

Dann solltest Du gleich versuchen, nicht unnötig Ressourcen zu 
verschwenden, z.B.:

- variables Schieben ist teuer
- unnötig große Datentypen sind teuer (Schleifenzähler 8 Bit)
- globale Variablen sind teuer (lokale sind oft in Registern).

Und auch bessere Lesbarkeit kann nicht schaden, z.B. durch Bitvariablen.

Hier mal ein Beispiel, wie ich es machen würde:

#include <avr\io.h>


struct bits {
  uint8_t b0:1;
  uint8_t b1:1;
  uint8_t b2:1;
  uint8_t b3:1;
  uint8_t b4:1;
  uint8_t b5:1;
  uint8_t b6:1;
  uint8_t b7:1;
} __attribute__((__packed__));

#define SBIT(port,pin) ((*(volatile struct bits*)&port).b##pin)


#define SPI_CLK         SBIT( PORTB, 0 )        // clock
#define SPI_CLK_DDR     SBIT( DDRB,  0 )
#define SPI_MISO_PIN    SBIT( PINB,  2 )
#define HC165_LD        SBIT( PORTB, 3 )
#define HC165_LD_DDR    SBIT( DDRB,  3 )


uint16_t read_2xhc165( void )
{
  uint8_t i;
  uint16_t b = 0;

  SPI_CLK_DDR = 1;
  HC165_LD_DDR = 1;
  HC165_LD = 0;
  HC165_LD = 1;

  for( i = 16; i; i-- ){
    b <<= 1;
    if( SPI_MISO_PIN )
      b++;
    SPI_CLK = 0;
    SPI_CLK = 1;
  }
  return b;
}

Bringt eine Codeeinsparung von 80% (162/32Byte)

Prinzipiell sollte Dein Code es aber tun, allerdings liest er gespiegelt 
aus.


Peter

P.S.:
Und dran denken, alle Eingänge des HC165 müssen beschaltet werden (0V 
oder 5V).
"Offen" ist kein gültiger Logikpegel.