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?
03.02.2021, 12:34
Beitrag #9
RE: 64Bit Variable?
Code:
Bitwise OR (|)

The bitwise OR operator in C++ is the vertical bar symbol, |. Like the & operator, | operates independently each bit in its two surrounding integer expressions, but what it does is different (of course). The bitwise OR of two bits is 1 if either or both of the input bits is 1, otherwise it is 0. In other words:

    0  0  1  1    operand1
    0  1  0  1    operand2
    ----------
    0  1  1  1    (operand1 | operand2) - returned result
Ziel ist es, die Bits der Variable Inputs und der Variablen Outputs zusammen zu führen und auszugeben.

In diesem Beispiel funktioniert das mit den unteren 32Bits auch prima.
Eine LED ist ständig an (spiegelt den aktiven Eingang wieder) und zwei LEDs blinken.

Code:
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000 1000 0000 0000 0001
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000 1000 0000 0000 0001
Wie man sieht, funktioniert Outputs | Inputs
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.02.2021, 12:40
Beitrag #10
RE: 64Bit Variable?
(02.02.2021 16:33)mega-hz schrieb:  ...
Würde ungerne den Weg über 2 32Bit Variablen gehen...

Ich habe mir nicht alles durchgelesen, aber vielleicht versuchst du es mal einen Umweg über eine uint64_t Union die zwei uint32_t Variablen enthält.

Gruß Arne
Mit zunehmender Anzahl qualifizierter Informationen bei einer Fragestellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.02.2021, 12:44
Beitrag #11
RE: 64Bit Variable?
(03.02.2021 12:34)mega-hz schrieb:  In diesem Beispiel funktioniert das mit den unteren 32Bits auch prima.
Eine LED ist ständig an (spiegelt den aktiven Eingang wieder) und zwei LEDs blinken.

Code:
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000 1000 0000 0000 0001
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000
Outputs|Inputs     :0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 0000 0000 1000 0000 0000 0001
Wie man sieht, funktioniert Outputs | Inputs
Warum testest Du es nicht mit belegten Bits im oberen Teil?

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, 12:58
Beitrag #12
RE: 64Bit Variable?
Das funktioniert bei mir (UNO) problemlos:

Code:
#include <binOut.h>
uint64_t u1 = 0x1234567812345678;
uint64_t u2 = 0x2134567121345671;
void setup() {
  Serial.begin(115200);
  Serial.println("Start");
  uint64_t r = u1 | u2;
  printlnBin(Serial,u1,"u1 (BIN): ",true);
  printlnBin(Serial,u2,"u2 (BIN): ",true);
  printlnBin(Serial,r,"r  (BIN): ",true);
}

void loop() {}

ergibt:
Code:
Start
u1 (BIN): 0001 0010 0011 0100 0101 0110 0111 1000 0001 0010 0011 0100 0101 0110 0111 1000
u2 (BIN): 0010 0001 0011 0100 0101 0110 0111 0001 0010 0001 0011 0100 0101 0110 0111 0001
r  (BIN): 0011 0011 0011 0100 0101 0110 0111 1001 0011 0011 0011 0100 0101 0110 0111 1001

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, 13:03 (Dieser Beitrag wurde zuletzt bearbeitet: 03.02.2021 13:13 von mega-hz.)
Beitrag #13
[GELÖST] 64Bit Variable?
So, ich habe eigentlich keinen Fehler gemacht!

bitSet und bitClear können in der Arduino IDE nur 32Bits !
siehe https://forum.arduino.cc/index.php?topic=198455.0

mit
Code:
#define bitSet64(value, bit) ((value) |= (1ULL << (bit)))
#define bitClear64(value, bit) ((value) &= ~(1ULL << (bit)))

im Kopf funktioniert es nun prima!

Hier nochmal das gesamte Listing ohne Debug Routinen:

Code:
#include <binOut.h>

#define bitSet64(value, bit) ((value) |= (1ULL << (bit)))    // bitSet kann nur 32 Bits in Arduino IDE !
#define bitClear64(value, bit) ((value) &= ~(1ULL << (bit))) // bitClear kann nur 32 Bits in Arduino IDE !

// 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)
          {
            bitSet64(Outputs,i);
          }
          else
          {
           bitClear64(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;
}
//-----------------------------------------------------------------------------------------------------------------

Sowas hätte man auch gleich in der Referenz angeben können...
Man kann das auch direkt in der Arduino.h ändern, aber dann muss es auf jedem PC gemacht werden, daher habe ich das direkt ins Listing eingefügt.
Ein Lob noch für Tommys binOut Lib! Top!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.02.2021, 13:11
Beitrag #14
RE: [GELÖST] 64Bit Variable?
Das kann man doch leicht anpassen:
Code:
#include <binOut.h>

#define bitSet64(value, bit) ((value) |= (1ULL << (bit)))
#define bitClear64(value, bit) ((value) &= ~(1ULL << (bit)))
#define bitWrite64(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))

uint64_t u1,u2;
void setup() {

bitSet64(u1,63);
bitSet64(u1,62);
bitSet64(u2,60);

  Serial.begin(115200);
  Serial.println("Start");
  uint64_t r = u1 | u2;
  printlnBin(Serial,u1,"u1 (BIN): ",true);
  printlnBin(Serial,u2,"u2 (BIN): ",true);
  printlnBin(Serial,r,"r  (BIN): ",true);
  bitClear(u2,60);
  r = u1 | u2;
  Serial.println();
  printlnBin(Serial,u1,"u1 (BIN): ",true);
  printlnBin(Serial,u2,"u2 (BIN): ",true);
  printlnBin(Serial,r,"r  (BIN): ",true);
}

void loop() {}

Ergibt:
Code:
Start
u1 (BIN): 1100 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
u2 (BIN): 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
r  (BIN): 1101 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000

u1 (BIN): 1100 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
u2 (BIN): 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
r  (BIN): 1100 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000

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, 13:36
Beitrag #15
RE: 64Bit Variable?
ob sich das auch für 128Bit anpassen lässt?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.02.2021, 13:56 (Dieser Beitrag wurde zuletzt bearbeitet: 03.02.2021 13:57 von Tommy56.)
Beitrag #16
RE: 64Bit Variable?
Die Arduoinos kennen keine 128-Bit-Variablen.

Ich habe mal mit einem BitArray gespielt, das sollte man auch mit 128 Bit nutzen können. Die set/read sind dann etwas anders. Für OR musst Du Dir eine eigene Funktion schreiben

Code:
const byte anzBit = 40;  // Anzahl der Bits

constexpr byte anzByte = (anzBit / 8) + ((anzBit % 8) ? 1 : 0); // resultierende Anzahl der Bytes (Berechnung zur Compilezeit!)

byte bitArray[anzByte]; // Bytearray als Speicher

// Hilfsfunktion Byte binär mit führenden 0en ausgeben
// p = ein Nachfahre von Printer (z.B. Serial, SoftwareSerial, manche LCD)
// b das Byte
void printByteBin(Print &p, byte b) {
  char arr[] = "00000000";
  byte bit;
  for(byte i=0;i<8;i++) {
    bit = b & 0x1;
    arr[7-i]=bit + 0x30;
    b = b >> 1;
  }
  p.print(arr);
}

// Hilfsfunktion Array binär ausgeben
// p = ein Nachfahre von Printer (z.B. Serial oder SoftwareSerial)
// *b das Array
// len die Länge in Bytes
void printArray(Print &p, const byte *b, const byte len) {
  for(byte i=0;i<len;i++) {
    printByteBin(p,b[len-i-1]);
    p.print(" ");
  }
  p.println();
}

// setzt das Bit an Position idx auf den Wert val
void setBit(const byte idx, const bool val) {
  if (idx >= anzBit || idx < 0) return;  // Bereichsüberschreitung
  bitWrite(bitArray[idx/8],idx%8,val);
}

// Liest den Wert des Bits an der Position idx
bool readBit(const byte idx) {
  return bitRead(bitArray[idx/8],idx%8);
}

void setup() {
  Serial.begin(115200);
  Serial.println("Start");
  Serial.print("Ergibt Bytes: ");
  Serial.println(anzByte);
  setBit(34,1);
  Serial.println(readBit(34));
  Serial.println(readBit(3));
  printArray(Serial, bitArray, sizeof(bitArray));
}

void loop() {}

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
  * vor Variable / Code-Frage N1d45 6 132 13.04.2021 19:49
Letzter Beitrag: N1d45
  Variable in for-Schleife volllaufen lassen. gutschy 7 221 09.04.2021 17:54
Letzter Beitrag: Tommy56
  Variable über serielle Eingabe befüllen ? Foto-Ralf 23 1.830 21.11.2020 11:23
Letzter Beitrag: Tommy56
  Erläuterung zu "digitalWrite(PIN, Variable ? LOW : HIGH); " Christian_Moba-Arduino 14 1.335 09.10.2020 08:53
Letzter Beitrag: hotsystems
  HC-12 verschiede Variable übertragen Harry 33 11.759 21.06.2020 20:09
Letzter Beitrag: Tommy56
Photo SIM800l Variable Telefonnummer zuweisen huber5093 18 2.307 15.06.2020 23:07
Letzter Beitrag: georg01
  Variable mit Werten von SD-Karte füllen DO3GE 16 2.350 14.04.2020 19:38
Letzter Beitrag: Corvus
  Merkwürdiges Verhalten einer globalen Variable Anders_Hamburg 6 1.119 29.03.2020 10:46
Letzter Beitrag: Fips
  8 Bit als Variable Parallel einlesen Holzauge 4 1.968 24.03.2020 20:18
Letzter Beitrag: Holzauge
  variable or field declared void Harry 10 2.681 21.02.2020 22:54
Letzter Beitrag: MicroBahner

Gehe zu:


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