64Bit Variable?

[mega-hz]

Hallo,
ich habe 8 Schieberegister 74165 und 8 Schieberegister 74595 mit 64 In- und 64 Outputs.
Zuerst sollen erstmal die Zustände der Inputs(x165) auf den entsprechenden Output(x595) dargestellt werden sowie vorgegebene Ausgänge blinken.
Das funktionierte mit 32 In- und Outputs auch prima, aber mit 64Bit scheint es nicht zu funktionieren, obwohl ich bereits uint64_t benutze.
Weiss jemand wie man 64 Bits in einer Variable erfolgreich speichern kann?
Der Prozessor ist ein ATMEGA2560...

Hier der code:

Code:

// Pin- und Variablen-Definierung der Input Shiftregister 74165

uint8_t IN_loadPin = 4;         // per Jumper wählbar D2 - D11
uint8_t IN_dataPin = 2;         // per Jumper wählbar D2 - D11
uint8_t IN_clockPin = 3;         // per Jumper wählbar D2 - D11
uint8_t Input[64] = {};
uint64_t Inputs = 0;

// Pin- und Variablen-Definierung der Output Schiftregister 74595

uint8_t OUT_latchPin = 7;         // per Jumper wählbar D2 - D11
uint8_t OUT_dataPin = 5;          // per Jumper wählbar D2 - D11
uint8_t OUT_clockPin = 6;         // per Jumper wählbar D2 - D11
uint8_t Output[64] = {};
uint64_t Outputs =     0b0000000000000000000000000000000000000000000000000000000000000000;
uint64_t BlinkOutput = 0b1000000000000000000000000000000110000000000000000000000000000001;
unsigned long previousMillis = 0;    
uint8_t BlinkInterval = 250;         // interval at which to blink (milliseconds)

void setup()
{
  pinMode(IN_dataPin, INPUT);
  pinMode(IN_loadPin, OUTPUT);
  pinMode(IN_clockPin, OUTPUT);
  pinMode(OUT_latchPin, OUTPUT);
  pinMode(OUT_clockPin, OUTPUT);
  pinMode(OUT_dataPin, OUTPUT);

  digitalWrite(IN_dataPin, LOW);      // Pullups abschalten
  digitalWrite(OUT_clockPin, LOW);
  digitalWrite(IN_clockPin, LOW);
  digitalWrite(IN_loadPin, LOW);
  digitalWrite(OUT_latchPin, LOW);
  digitalWrite(OUT_dataPin, LOW);

  clr_Outputs();
}

void loop()
{
  unsigned long currentMillis = millis();

  shiftIn64();

  if (currentMillis - previousMillis >= BlinkInterval)
    {
      previousMillis = currentMillis;
      for( uint8_t i = 0; i<64; i++ )
      {
        if (bitRead(BlinkOutput,i) == 1)
        {
          if(bitRead(Outputs,i) == 0)
          {
            bitSet(Outputs,i);
          }
          else if(bitRead(Outputs,i) == 1)
          {
            bitClear(Outputs,i);
          }
        }
      }
  shiftOut64(Outputs | Inputs);
  }
}
//-----------------------------------------------------------------------------------------------------------------
void clr_Outputs()
//-----------------------------------------------------------------------------------------------------------------
{
  Outputs = 0x0; // alle Ausgänge aus
  shiftOut64(Outputs);
}
//-----------------------------------------------------------------------------------------------------------------
// 64 Bit ShiftOut Routine für 8x 74HCT595
//-----------------------------------------------------------------------------------------------------------------
void shiftOut64(uint64_t val)
{
digitalWrite(OUT_latchPin, LOW);
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val >> 8);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val >> 16);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val >> 24);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val >> 32);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val >> 40);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val >> 48);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val >> 56);      
digitalWrite(OUT_latchPin, HIGH);
digitalWrite(OUT_latchPin, LOW);
}
//-----------------------------------------------------------------------------------------------------------------
// 64 Bit ShiftIn Routine für 8x 74HCT165
//-----------------------------------------------------------------------------------------------------------------
uint64_t shiftIn64( void )
{

  digitalWrite(IN_loadPin, LOW);
  digitalWrite(IN_loadPin, HIGH);
  for ( uint8_t i = 0; i < 64; i++ )
  {
    Inputs >>= 1;
    if ( digitalRead(IN_dataPin))
    {
      Inputs |= 0x8000000000000000;
      Input[i] = 1;
    }
    else
    {
      Input[i] = 0;
    }

    digitalWrite(IN_clockPin, HIGH);
    digitalWrite(IN_clockPin, LOW);
  }
  return Inputs;
}
//-----------------------------------------------------------------------------------------------------------------

Würde ungerne den Weg über 2 32Bit Variablen gehen...

[Tommy56]

Als Erinnerung: Wir warten noch auf die Veröffentlichung einer Routine von Dir.

Gruß Tommy

[mega-hz]

(02.02.2021 16:36)Tommy56 schrieb:  Als Erinnerung: Wir warten noch auf die Veröffentlichung einer Routine von Dir.

Gruß Tommy

Stimmt, ganz vergessen...

[Tommy56]

Wo klemmt es denn genau?
Bei der Arbeit mit den uint64_t, bei der Ausgabe auf die Schieberegister oder noch wo anders?
Zur Ausgabe (print unterstützt es nicht) habe ich mir hier ein paar Routinen gebaut.

ShiftOut will Byte.
Wäre da nicht ein &0xFF angebracht?

Code:

shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val & 0xFF);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, (val >> 8) & 0xFF);  
...

Gruß Tommy

[mega-hz]

(02.02.2021 17:03)Tommy56 schrieb:  Wo klemmt es denn genau?
Bei der Arbeit mit den uint64_t, bei der Ausgabe auf die Schieberegister oder noch wo anders?
Zur Ausgabe (print unterstützt es nicht) habe ich mir hier ein paar Routinen gebaut.

ShiftOut will Byte.
Wäre da nicht ein &0xFF angebracht?

Code:

shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, val & 0xFF);  
shiftOut(OUT_dataPin, OUT_clockPin, LSBFIRST, (val >> 8) & 0xFF);  
...

Gruß Tommy

Es kommen immer nur 32 Bits an, da diese aber an den richtigen Positionen sitzen, werden 64Bits durch die Shiftregister erfolgreich geschoben.
Allerdings sind die obersten 32Bits alle auf 0.

[Tommy56]

Dann lass Dir doch zur Kontrolle das jeweilige Byte, bevor Du es an Shiftout übergibst auf dem seriellen Monitor ausgeben und vorher die 64 Bit binär, wenn Du in die Funktion rein kommst.
Wenn das richtig ist, dann hast Du ein Hardwareproblem. Leitung vom 4. zum 5. SR nicht ok?

Gruß Tommy

[mega-hz]

Hier die Ausgaben mithilfe Deiner binOut Routine:

Code:

Inputs      :0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000
BlinkOutputs:1000 0000 0000 0000 0000 0000 0000 0001 1000 0000 0000 0000 0000 0000 0000 0001
ShiftOut64  :0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000 1000 0000 0000 0001

hier sieht man, daß z.B. in der BlinkOutput Variable 64Bit gespeichert sind.
Nach jedem 2. Aufruf sieht man auch daß die Bits aus "BlinkOutputs" 1 und 0 werden, also blinken, genau wie es die LEDs auch anzeigen!

Rufe ich die shiftOut64 Routine direkt mit dem festen Wert auf, leuchten die LEDs wie sie sollen!

Code:

shiftOut64(BlinkOutput);

Hardwarefehler sind daher ausgeschlossen!

Ich vermute einen Fehler in der Blink-Vergleich-Mühle, finde aber nix:

Code:

void loop()
{
  unsigned long currentMillis = millis();

  shiftIn64();

  if (currentMillis - previousMillis >= BlinkInterval)
    {
      previousMillis = currentMillis;
      for( uint8_t i = 0; i<64; i++ )
      {
        if (bitRead(BlinkOutput,i) == 1)
        {
          if(bitRead(Outputs,i) == 0)
          {
            bitSet(Outputs,i);
          }
          else if(bitRead(Outputs,i) == 1)
          {
            bitClear(Outputs,i);
          }
        }
      }
  shiftOut64(Outputs | Inputs);
  }
}

[Tommy56]

Ich weiß nicht, für was Outputs | Inputs gut sein soll aber lass Dir für die Zwischenschritte der Bearbeitung die Werte ausgeben, auch für diese Verknüpfung.

Gruß Tommy