Textfeldinhalt als Hexadezimal behandeln

Linnea

ok, dafür gibts Funktionen im BCB, z.B.: IntToHex

Th69

Das was du als Hex bezeichnest ist aber nur eine String-Darstellung. Du meinst also einfach den Zahlenwert (als Char bzw. Byte)?
Dann einfach StrToInt (http://docwiki.embarcadero.com/VCL/en/SysUtils.StrToInt)
auf den von Linnea geposteten Code anwenden und das Ergebnis dann noch nach "char" wandeln (casten)...

berniebutt

Vielleicht reicht schon die C-Standard-Funktion itoa() mit dem Radix 16 aus?

kasper84

Habe ich versucht:

int a;
a = StrToInt(Form1->Edit1->Text);

Aber wenn ich z.B. 4B in mein Editfeld eingeben will, funktioniert das leider nicht. Kann ich dem String nicht einfach irgendwie '\x' hinzufügen? Benötige halt eine direkte Eingabe für Hexziffern, die dann 1 zu 1 gesendet werden können.

berniebutt

Ich verstehe dein Problem immer noch nicht so ganz. Also der Reihe nach:

1. Du hast ein Edit-Feld für eine HEX-Eingabe, z.B, 4B
2. Du willst den Inhalt der Eingabe original irgendwo hin schicken, also ebenfalls 4B
Wieso bleibst du da nicht einfach bei einem Textstring?
3. Willst du die Eingabe auf gültige HEX-Zeichen überprüfen?
4. Willst du aus dem Textstring eine gültige HEX-Zahl machen?
Das ist mit eigenen kleinen Funktionen schnell gemacht, wenn es dafür nichts fertiges gibt!
5. Wie willst du die HEX-Eingabe wohin schicken? An einen anderen Prozess?
6. Warum willst du '\x' anhängen, wenn du doch Originale haben willst?

Ich denke, wenn du dich etwas klarer ausdrücken kannst, kriegen wir die Sache leicht geregelt.

kasper84

berniebutt schrieb:

1. Du hast ein Edit-Feld für eine HEX-Eingabe, z.B, 4B
2. Du willst den Inhalt der Eingabe original irgendwo hin schicken, also ebenfalls 4B

Genau, ich möchte es an eine Schnittstelle senden.
Es muss aber Hexadezimal sein.

berniebutt schrieb:

4. Willst du aus dem Textstring eine gültige HEX-Zahl machen?
Das ist mit eigenen kleinen Funktionen schnell gemacht, wenn es dafür nichts fertiges gibt!

Jepp, genau das benötige ich. Ich will den Textstring eine gültige Hex-Zahl machen. Also genau das was man eingibt, nur als gültige Hex-Zahl und nicht als String. Sorry das ich mich so undeutlig ausgedrückt habe.

myerscola

Es ist auch nicht einfach zu verstehen was Du genau willst.
Ich rate mal und gebe Dir das mal:

Edit2->Text =  IntToHex(Edit1->Text.ToInt(),2);

Jedenfalls kommt in Edit2 dann die in hex umgerechte Zahl an, was aber von dem Datentyp dann wohl doch wieder als String übertragen wird. Wenn Deine Schnittstele nur hex versteht, dann kannst Du Dir das 0x schenken.
Deine 22 ist hex 16, bzw. hex 22 ist dezimal 34.
Und die nächste Frage wird sein, was ist mit größeren Zahlen? Sollen die dann als eine hex-Zahl oder als 2stellige Blöcke von 00-FF (also dez.0-255) ausgeben werden?

Aber die ursprügliche Fragestellung hat doch Linnea direkt beantwortet.

Gruß myerscola

kasper84

Ok. Ich versuch es nochmal richtig zu erklären. Hier erstmal mein Quelltext:

char Daten ;
AnsiString Bytes; 

Bytes = Form1->Edit1->Text;
Daten = Bytes.c_str();

ftStatus = FT_Write(ftHandle, Daten, sizeof(Daten) , &BytesWritten);
               if (ftStatus == FT_OK) { // FT_Write OK
               Form1->RichEdit2->Lines->Add("TX: ");
               Form1->RichEdit2->Lines->Add(Daten);

               FT_Close(ftHandle);
               }
               else { // FT_Write Failed
               ftStatus_Auswertung(ftStatus);
               }

Ich möchte jetzt in Edit1 eine 22 eingeben und diese soll auch gesendet werden. Wenn ich sie aber so wie oben im Quelltext übergebe, sende ich eine 16 als Hexadezimal, da meine Write-Funktion die Eingabe umrechnet. Also von Dezimal zu Hex. Ich möchte aber das ich hier eine 22 eingeben kann und diese auch als 22 hexadezimal gesendet wird.
Hier mal ein Link:
http://www.mikrocontroller.net/topic/26477

Dort kann man die Software Hterm runterladen. In dieser Software gibt es die Möglichkeit Daten als ASCI, HEX oder Dezimal einzugeben und zu senden.
Hier ein Bild (siehe Bereich "INPUT CONTROL"):
http://www.der-hammer.info/terminal/bilder/term_071linux_large.png
Ich hoffe jetzt ist es verständlicher was ich möchte.

Gruß

Braunstein

Das was du da machst funktioniert doch hinten und vorne nicht.
Deine Variable Daten ist doch ein char, also 1 Byte groß.
Hier

Daten = Bytes.c_str();

übergibst du deinem char ein const char*. Das sollte eigentlich gar nicht gehen.
So wie ich dich verstanden habe, willst du die 22 hexadezimal interpretieren und dann senden.
Das ginge z.Bsp. so:

int Daten ;
AnsiString Bytes;

Bytes = Form1->Edit1->Text;
Bytes = "0x" + Bytes; // Zahl als hex interpretieren
Daten = StrToInt(Bytes); // String in Zahl umwandeln

ftStatus = FT_Write(ftHandle, reinterpret_cast<char*>(&Daten), sizeof(Daten) , &BytesWritten);

kpeter

Hallo,

Eine andere Variante:
angenommen, im Edit steht die Zeichenfolge AF3.

Dann ergeben sich doch folgende Werte:

Entsprechend ihrer Stellung in der Zeichenfolge multiplizieren mit Basis 16:

int zero =  3 * pow(16, 0);  // 3 = 3
   int one  = 15 * pow(16, 1);  // F = 15
   int two  = 10 * pow(16, 2);  // A = 10

Wenn diese Werte addiert werden, liegt dez. Wert vor. Dieser wird m.E. wie ein Hexwert akzeptiert.

edit: Kommentare korrigiert

@Braunstein, deine Lösung ist natürlich die kürzere

kasper84

Perfekt. Das ist geanu das as ich gesucht habe.
Danke@ Braunstein
Jetzt noch eine kleine Frage. Hier mal mein Code:

int Daten;
AnsiString Byte1;
AnsiString Byte2;
AnsiString Byte3;
AnsiString Byte4;
AnsiString Byte5;
AnsiString Byte6;
AnsiString Byte7;
AnsiString Byte8;
AnsiString Byte9;
AnsiString Byte10;
AnsiString Bytes;

                //Byte 1
                Byte1 = Form1->Edit1->Text;

                //Byte 2
                Byte2 = Form1->Edit2->Text;

                //Byte 3
                Byte3 = Form1->Edit3->Text;

                //Byte 4
                Byte4 = Form1->Edit4->Text;

                //Byte 5
                Byte5 = Form1->Edit5->Text;

                //Byte 6
                Byte6 = Form1->Edit6->Text;

                //Byte 7
                Byte7 = Form1->Edit7->Text;

                //Byte 8
                Byte8 = Form1->Edit8->Text;

                //Byte 9
                Byte9 = Form1->Edit9->Text;

                //Byte 10
                Byte10 = Form1->Edit10->Text;

                Bytes = "0x" + Byte1  + Byte2 + Byte3 + Byte4 + Byte5+ Byte6 + Byte7 + Byte8 + Byte9 + Byte10; // Zahl als hex interpretieren
                Daten = StrToInt(Bytes); // String in Zahl umwandeln

               ftStatus = FT_Write(ftHandle, reinterpret_cast<char*>(&Daten) , sizeof(Daten) , &BytesWritten);

Ich habe jetzt 10 Editfelder, in die man jeweils 2 Zahlen eingeben kann. So bekomme ich genau die 10 Bytes die ich senden will.
Ich kann mit diesem Code jetzt aber leider nur 4 Bytes senden, da ich ansonsten die Fehlermeldung '0x34097052389' ist kein gültiger Integerwert.
Ich möchte aber alle 10 bytes eingeben können und dann zusammenfügen und als ganzes senden. Gibt's da ne Möglichkeit?

Braunstein

Deine Zahl sprengt den Wetebereich eines int. Die kannst du nicht als Ganzes senden. Es kommt jetzt natürlich auf den Empfänger an.
Was macht der Empfänger mit dem Wert?
Wie wird der interpretiert?
Gibt es andere Übertragungsprotokolle?

berniebutt

So langsam kommen wir der Sache näher!
Du hast doch schon die einzelnen Bytes der HEX-Zahl. Dann sende diese schlicht einzeln oder in sendbaren int-Blöcken, wenn der Wertebereich von int überschritten wird. Der Empfänger kann das z.B. in einem long int zusammensetzen. Also regel erstmal das Editfeld und die Übertragung an den Empfänger. Wenn alles wie gewünscht ankommt, interessiert nur noch der Empfänger. Oder hast du auf diesen keinen Einfluss? Dann bist du vielleicht gekniffen - da helfen dann nur geeignete Protokolle, die der Empfänger unterstützt.

Burkhi

Edit. Gelöscht, sorry falsch gelesen

kasper84

berniebutt schrieb:

So langsam kommen wir der Sache näher!
Du hast doch schon die einzelnen Bytes der HEX-Zahl. Dann sende diese schlicht einzeln oder in sendbaren int-Blöcken, wenn der Wertebereich von int überschritten wird. Der Empfänger kann das z.B. in einem long int zusammensetzen. Also regel erstmal das Editfeld und die Übertragung an den Empfänger. Wenn alles wie gewünscht ankommt, interessiert nur noch der Empfänger. Oder hast du auf diesen keinen Einfluss? Dann bist du vielleicht gekniffen - da helfen dann nur geeignete Protokolle, die der Empfänger unterstützt.

Gut. Habe es jetzt in sendbare int-Blöcke zerpflückt. So funktioniert es. Danke nochmals.