INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
64Bit Variable?
02.02.2021, 16:33 (Dieser Beitrag wurde zuletzt bearbeitet: 02.02.2021 19:47 von Bitklopfer.)
Beitrag #1
64Bit Variable?
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...
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.02.2021, 16:36
Beitrag #2
RE: 64Bit Variable?
Als Erinnerung: Wir warten noch auf die Veröffentlichung einer Routine von Dir.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.02.2021, 16:46
Beitrag #3
RE: 64Bit Variable?
(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...Confused
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.02.2021, 17:03 (Dieser Beitrag wurde zuletzt bearbeitet: 02.02.2021 17:03 von Tommy56.)
Beitrag #4
RE: 64Bit Variable?
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

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.02.2021, 20:11
Beitrag #5
RE: 64Bit Variable?
(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.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.02.2021, 20:17
Beitrag #6
RE: 64Bit Variable?
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

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.02.2021, 11:41 (Dieser Beitrag wurde zuletzt bearbeitet: 03.02.2021 11:43 von mega-hz.)
Beitrag #7
RE: 64Bit Variable?
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);
  }
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.02.2021, 11:57
Beitrag #8
RE: 64Bit Variable?
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

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Variable in for-Schleife volllaufen lassen. gutschy 7 160 09.04.2021 17:54
Letzter Beitrag: Tommy56
  Variable über serielle Eingabe befüllen ? Foto-Ralf 23 1.794 21.11.2020 11:23
Letzter Beitrag: Tommy56
  Erläuterung zu "digitalWrite(PIN, Variable ? LOW : HIGH); " Christian_Moba-Arduino 14 1.326 09.10.2020 08:53
Letzter Beitrag: hotsystems
  HC-12 verschiede Variable übertragen Harry 33 11.684 21.06.2020 20:09
Letzter Beitrag: Tommy56
Photo SIM800l Variable Telefonnummer zuweisen huber5093 18 2.298 15.06.2020 23:07
Letzter Beitrag: georg01
  Variable mit Werten von SD-Karte füllen DO3GE 16 2.341 14.04.2020 19:38
Letzter Beitrag: Corvus
  Merkwürdiges Verhalten einer globalen Variable Anders_Hamburg 6 1.114 29.03.2020 10:46
Letzter Beitrag: Fips
  8 Bit als Variable Parallel einlesen Holzauge 4 1.960 24.03.2020 20:18
Letzter Beitrag: Holzauge
  variable or field declared void Harry 10 2.671 21.02.2020 22:54
Letzter Beitrag: MicroBahner
  int variable wird nicht in Schleife übertragen ha0248 8 1.717 11.02.2020 15:25
Letzter Beitrag: ha0248

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste