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:
  • 2 Bewertungen - 5 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
03.10.2015, 09:14 (Dieser Beitrag wurde zuletzt bearbeitet: 03.10.2015 09:36 von HaWe.)
Beitrag #1
gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
hi,
ich will eine 32-bit oder 64-bit float Zahl in ihre einzelnen Bytes zerlegen, so wie sie bit/Byteweise codiert sind.

Ich habe mir dazu folgendes überlegt:

float fval; // Basiswert
darauf möchte ich einen Zeiger setzen und die Speicherdresse ermitteln.
float pf *;

dann will ich eine Bytearray-Hilfsvariable einführen
byte bbuf[4]; // 4-Byte- Puffer

Nun möchte ich den Pointerwert (Adresse) des Basiswerts (Float) dem Pointerwert (Adresse) der Hilfsvariablen zuweisenen, sodass beide pointer jetzt auf dieselbe Speicherstelle zeigen, und wenn ich den Wert der Hilfsvariablen auslese, erhlalte ich ihre 4 Bytes hintereinander.


(Anm.: Natürlich haben die dann wertmäßig nichts mehr mit dem floatwert zu tun, außer dass sie Vorzeichenbit, Mantissen-Bits und Exponentenbits in exakt derselben Reihenbolge enthalten. Danach will ich sie dann per bit- und bytesweise weiterverarbeiten (als Bytearray versenden) und später auf der Gegenseite wieder zurückverwandeln. )

Pointerarithmetik in C fällt mir aber extrem schwer - wie kann ich diese Pointerzuweisung in C programmieren?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.10.2015, 09:58
Beitrag #2
RE: gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
Ich selbst habe davon auch (noch) keine Ahnung.
Weil mich das aber auch interessiert, habe ich mal geguckt und etwas gefunden, was dir helfen könnte:
http://forum.arduino.cc/index.php?topic=189259.0
Post #3 sieht vielversprechend aus.

Gruß, Klaus
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.10.2015, 10:22
Beitrag #3
RE: gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
Hi,
also dann wollen wir mal...
Code:
float fval = 3.1415;
float* pf = &fval;  // pf ist jetzt ein float-Zeiger, der die Adresse von fval enthält
byte* pb = (byte*)(&fval);  // pb ist jetzt ein byte-Zeiger, der die Adresse von fval enthält
Das "(byte*)" vor der Adressangabe "(&fval)" nennt man "Cast". Damit sagt man dem Compiler, dass man sehr wohl weiß, dass fval kein byte ist, man es aber trotzdem gerne so machen will.
Speicherplatz braucht man weder für pf noch für pb reservieren, da beide ja sowieso nur auf bereits reservierten Speicherplatz zeigen. D.h. die Definition von "byte bbuf[4]" ist in diesem Zusammenhang nicht so sinnvoll.
Den Zugriff auf pb kann man trotzdem in Array-Schreibweise machen:
Code:
for(int i = 0; i < sizeof(float); i++) {
   Serial.print(pb[i],HEX);
}
Es ist wichtig, bei den ganzen Spielchen darauf zu achten, dass der Speicherbereich, auf den man zeigt, bei dessen Verwendung noch gültig ist.
SO SOLLTE MAN ES NICHT MACHEN:
Code:
byte* getBytePtrFromFloat(float f) {
   return (byte*)(&f);    // Don't try this at home!
}

...

float fval = 3.1415;
byte* bp = getBytePtrFromFloat(fval);
for(int i = 0; i < sizeof(float); i++) {
   bp[i] = 0;   // Das koennte boese enden
}
Nach Aufruf der Funktion zeigt bp auf den Stack des Funktionsaufrufs vorher. Das ist ein Speicherbereich, der nach dem Funktionsaufruf ggf. für etwas anderes verwendet wird. Wenn man darin herumschreibt, dann kann es zu sehr seltsamen Sachen kommen.
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.10.2015, 10:28 (Dieser Beitrag wurde zuletzt bearbeitet: 03.10.2015 10:28 von HaWe.)
Beitrag #4
RE: gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
das ist ja super!
danke euch beiden!
der Link aus arduino.cc zeigt tatsächlich genau, was ich vorhatte, nur mit long statt byte arr[4]

Zitat:"Der Trick dabei ist die Binär-Darstellung des Floats in einem int/long zu erhalten. Das habe ich mir hier abgeguckt:
http://en.wikipedia.org/wiki/Fast_inverse_square_root"


Code:
void floatToByte(byte* arr, float value)
{
     long l = *(long*) &value;

     arr[0] = l & 0x00FF;
     arr[1] = (l >> 8) & 0x00FF;
     arr[2] = (l >> 16) & 0x00FF;
     arr[3] = l >> 24;
}

void loop()
{
    byte arr[4];
    float test = 1.234;
    floatToByte(arr, test);
}

an Thorsten:
herzlichen Dank für das Tutorial! Perfekt verständlich!
Smile
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.10.2015, 10:58
Beitrag #5
RE: gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
Hi,
die Implementierung des floatToByte halte ich nicht für so gelungen. Erstens umständlich und zweitens muss ja nicht immer float und long die gleiche Größe haben. So geht's meiner Meinung nach besser:
Code:
void floatToByte(byte* arr, float value) {
    memcopy(arr, &value, sizeof(float));
}

void loop()
{
     byte arr[sizeof(float)];
     float test = 1.234;
     floatToByte(arr, test);
}
Das braucht man aber nur, wenn man tatsächlich den Speicherbereich kopieren will. Nur weil man einen byte-Zeiger braucht (oder ein byte-Array, was im Prinzip dasselbe ist), sollte man keinen Speicherplatz verschwenden.
(...wobei das auf dem Due unter Umständen egal ist, da Zeiger wohl auch 32 Bit haben.)
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.10.2015, 11:00
Beitrag #6
RE: gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
ps

noch eine Verständnisfrage, da ich die ganzen "*" und "&" immer durcheinanderschmeiße:

Code:
float* pf = &fval;  // pf ist jetzt ein float-Zeiger, der die Adresse von fval enthält
byte* pb = (byte*)(&fval);  // pb ist jetzt ein byte-Zeiger, der die Adresse von fval enthält

d.h., wenn pf eine Speicheradresse vom RAM enthält (also nur eine longint), und pb auch,
warum kann man sie dann nicht einfach einander zuweisen per
Code:
pb=pf;
?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.10.2015, 11:07
Beitrag #7
RE: gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
(03.10.2015 11:00)HaWe schrieb:  
Code:
float* pf = &fval;  // pf ist jetzt ein float-Zeiger, der die Adresse von fval enthält
byte* pb = (byte*)(&fval);  // pb ist jetzt ein byte-Zeiger, der die Adresse von fval enthält

d.h., wenn pf eine Speicheradresse vom RAM enthält (also nur eine longint), und pb auch,
Speicheradressen (also Zeiger) sind kein longint. Unter bestimmten Architekturen belegen sie nur denselben Speicherplatz wie ein long. Genauso könntest Du sagen, ein Zeiger wäre ein float. Man muss unterscheiden zwischen dem, was die Sprache C++ konzeptionell verlangt und bietet (z.B. unterschiedliche Datentypen) und wie es nachher auf der Maschine implementiert ist. Manche "Verrenkungen" sind nur deshalb nötig, weil der Compiler es so will.

Zitat:warum kann man sie dann nicht einfach einander zuweisen per
Code:
pb=pf;
?
In meinem Beispiel habe ich das nicht gemacht, um zu zeigen, wie man das direkt machen kann ohne den Umweg über ein float*. Allerdings geht es nicht so, wie Du es geschrieben hast. Da dürfte der Compiler meckern, da die Typen nicht kompatibel sind. Man braucht wieder einen Cast, also:
Code:
pb=(byte*)pf;
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.10.2015, 11:22 (Dieser Beitrag wurde zuletzt bearbeitet: 03.10.2015 11:29 von HaWe.)
Beitrag #8
RE: gegenseitiges Zuweisen von Pointeradressen und Ihrer "Werte"
danke für die Antwort!

wenn man jetzt nicht gezwungen ist, Speicher zu sparen, sondern nur zum hin- und herverwandeln möglichst verständliche Variablen verwenden will, verstehe ich dich dann richtig, dass es trotzdem auch so geht...?

Code:
float fval;
float* pf;
byte arr[4]; // um Speicherplatz festzulegen
pb* byte;

// umwandeln von float in byte array
pf = &fval;     // float Adresse speichern
pb = (byte*)pf; //  Adressen gleichsetzen
arr* = pb;      // oder wie ?? // Pointer umbiegen, dass arr jetzt die Byte Daten enthält

// umwandeln von byte array in float
pb=&arr;
pf = (float*)pb;
fval* = pf; // oder wie ??

?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Zahl von SD-Card Modul einlesen und Var. zuweisen Nafetz 13 296 28.10.2016 10:12
Letzter Beitrag: hotsystems
  Gewichteten Durchschnitt berechnen, 20 Werte in fortlaufender Variable speichern TimeMen 10 468 03.07.2016 09:00
Letzter Beitrag: Binatone
  Ausgabe druckt immer 2 Werte anstatt nur einen. Finde den Fehler nicht TimeMen 24 736 02.07.2016 14:18
Letzter Beitrag: hotsystems
  Werte an anderes Programm weiterleiten Typ 2 437 12.03.2016 23:28
Letzter Beitrag: Typ
  digitale Werte trotz Stromunterbrechung nicht verlieren goldfisch 63 4.227 06.01.2016 13:17
Letzter Beitrag: Bitklopfer
  werte vom MPU6050 gy521 bekommen max1798 0 463 18.12.2015 21:11
Letzter Beitrag: max1798
  Arduino werte auslesen Atwist 11 1.323 21.11.2015 20:58
Letzter Beitrag: hotsystems
  Werte aus der SD - Karte zuordnen Gandalf 19 1.911 12.09.2015 12:48
Letzter Beitrag: Gandalf
  DHT22-Werte via Funk MeisterQ 27 4.890 27.07.2015 21:48
Letzter Beitrag: MeisterQ
  Werte in die UTouchCD.h eintragen jgrothe 0 439 17.06.2015 17:23
Letzter Beitrag: jgrothe

Gehe zu:


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