Bits in Str umwandeln

[xeus]

wie kann ich bits in einen string umwandeln?

00000010 in einen string umwandeln

danke,

xeus

[Khabarakh]

Wie liegen die Bits vor? Wie willst du sie als String speichern? Fragen über Fragen.
Wenn du die Bits als '01011' speichern willst, prüfst du einfach jedes Bit und fügst dann '1' oder '0' hinzu. Wenn du es "kompakt" speichern willst, konvertierst du je ein Byte mit Chr in einen Char. Je nachdem, wofür du das brauchst, musst du aber dabei auf Steuerzeichen achten.

[xeus]

muss es umwandeln, weil ich es seriell versenden will.
kannst du mir mal an einem beispiel demonstrieren, wie ich z.b

00000010 in einen sendefertigen string umwandle.

danke

[TeronG]

einfach mit z.B. einer For-Schleife deine Bit's durchlaufen und wenn das bit 1 ist resultstring := resultstring + '1' else resultstring := resultstring + '0';

... je nachdem wie deine bit's vorliegen sollte das recht easy gehen ...

[Sharky]

Hai xeus,

kannst Du mal einen Link zu dem Protokoll des Gerätes geben? Irgendwie kann ich mir kaum vostellen das es eine Zahl als Binärdarstellung durch einen String haben möchte. Zumindest habe ich das so noch nie gesehen.

[Bernhard Geyer]

Zitat:

Zitat von xeus

muss es umwandeln, weil ich es seriell versenden will.
kannst du mir mal an einem beispiel demonstrieren, wie ich z.b

00000010 in einen sendefertigen string umwandle.

danke

Hä? :gruebel:
Das macht doch die Serielle-Schnittstelle automatisch. Du übergibt ihr einen String/Bufferbereich (über Komponenten) und auf unterer Ebene wird das 8-Bit-Muster seriell übertragen. Du brauchst doch auf Programmierebene des nochmals zu konvertieren.

[Sharky]

Um die Frage aber trotzdem zu beantworten ;-)
Ich habe mit der Suche (IntTOBin) diesen Code von Christian gefunden und ihn nur leicht abgeändert.

Delphi-Quellcode:

function IntToBin(const AdwValue: DWORD; adigits : Byte): string;
  function PowerOf2(const AbExponent: byte): DWORD;
  var
    i: byte;
  begin
    Result := 1;
    for i := 1 to AbExponent do
    begin
      Inc(Result, Result)
    end;
  end;
var
  dwPower: DWORD;
  i: integer;
  dwValue: DWORD;
begin
  Result := StringOfChar('0', adigits);
  dwValue := AdwValue;
  for i := Pred(adigits) downto 0 do
  begin
    dwPower := PowerOf2(i);
    if dwValue >= dwPower then
    begin
      Result[adigits - i] := '1';
      Dec(dwValue, dwPower);
    end;
  end;
end;

procedure TForm1.btn_ConvertClick(Sender: TObject);
begin
  ShowMessage (IntToBin(10,8));
end;

[xeus]

Also von vorn und jetzt ein bisschen detailierter:

ich habe ein messgerät, dem ich eine anfrage über rs232 stellen kann:

1.byte: Adresse
2.byte: commando
..

9.byte: clc_l
10.byte:clc_h

dies bedeutet, das ich ein datenpacket mit acht bytes senden muss.
hab mich mal mit einem spy prog daraufgestürtzt

dieses hat mir dann eine tabelle erstellt:

z.b.

2 00000010

ich nehme an das 2 der decf wert und der rest bin ist.

nun dacht ich mir ok sendest du halt einfach 2, falsch gedacht, da kommt nähmlich was anderes dan hinten raus nur nicht das wie oben.

so jetzt wist ihr bescheid, und ich bin immer noch genau so ratlos

[Khabarakh]

@Sharky: :gruebel: Warum so kompliziert?

Delphi-Quellcode:

function DecToBin(const AValue: Cardinal; const ADigits: Byte): string;
var
  i: Integer;
begin
  if ADigits > SizeOf(AValue) * 8 then
    Exit;
  for i := ADigits - 1 downto 0 do
    Result := Result + IntToStr(AValue shr i and 1);
end;

[Sharky]

Zitat:

Zitat von Khabarakh

@Sharky: :gruebel: Warum so kompliziert?

Weil ich zeigen wollte das wir eine Suchfunktion haben ;-)

[marabu]

Hallo xeus,

der spy hat dir wahrscheinlich nur ein Byte in zwei Repräsentationen raus geschrieben: 2 dezimal und dual. Es ist schon so wie Bernhard und Sharky sagen: Üblicherweise benutzt du Funktionen zum Versenden und Empfangen von ByteArrays. Du musst prüfen, ob dein Messgerät mit Binärcodes angesteuert wird, oder - wie z.B. ein HP Drucker - mit einer Mischung aus binären Steuerzeichen und ASCII-kodiertem Text. Dann baust du dir deinen Puffer (ByteArray oder Record) auf und verschickst ihn. Wenn die Programmieranleitung des Messgerätes ein Kommando 85 (dezimal) nennt, dann musst du es nur noch einer Bytevariablen zuweisen und die Übertragung geschieht dann schon korrekt. Hexadezimale Werte (55 hexadezimal) kannst du auch direkt (b := $55;) zuweisen. Binäre Darstellungen musst du erst umwandeln:

Delphi-Quellcode:

function CardToDual(card: cardinal): string;
begin
  Result := '';
  repeat
    Result := Chr(Ord('0') + Ord(Odd(card))) + Result;
    card := card shr 1;
  until card = 0;
end;

function DualToCard(dual: string): cardinal;
var
  i: integer;
begin
  Result := 0;
  if Length(dual) > 8 * SizeOf(Result) then
    Exit;
  for i := 1 to Length(dual) do
    Result := Result shl 1 + Ord(dual[i] <> '0');
end;

...
var
  b: byte;
begin
  b := DualToCard('01010101');
end;

Grüße vom marabu

[xeus]

ok, diese funktion hab ich nun hinz gefügt, und der wert soll nun mit

apdcomport1.putsrting(dectobin(10,8));

gesendet werden.

aber wenn ich nun ein rs232 spy am ende der leitung anstöpsle, kommt nicht

00001010 an

sondern es wird anscheinend wieder jedes digit zerlegt in

00110000 00110000 00110000 00110001 00110000 00110001 00110000 00110000

aber an der empfangsseite kann das natürliuch nicht verarbeitet werden


mfg

xeus

[Robert Marquardt]

Die Jedi Code Library http://jcl.sf.net hat in JclLogic.pas dazu Funktionen.

[xeus]

also, wenn ich über die spy einen datensatz von 10 bytes in vorm von dec oder bín sende, krieg ich antwort in der selben Form.

[marabu]

Delphi-Quellcode:

apdcomport1.PutString(#10);  // und nicht DecToBin(10, 8)

marabu

[Sharky]

Zitat:

Zitat von xeus

also, wenn ich über die spy einen datensatz von 10 bytes in vorm von dec oder bín sende, krieg ich antwort in der selben Form.

Hai xeus,
was willst Du denn immer mit deinem "spy"?
Ich habe schon viele Geräte seriel gesteuert, aber so etwas habe ich nie gebraucht ;-)
Wie oben schon einmal geschrieben -> Hast Du einen Link zu der Protokoll beschreibung des Gerätes :?:

[xeus]

juhuu es funzt vielen dank.

jetzt noch ne frage,

ich krieg jetzt 8 bytes zurück mit je acht bits.

wie kann ich die acht bytes jetzt selektieren??

so das ich jedes byte selektiv verarbeiten kann??

[marabu]

Wenn du sagst, wie die zurückgegebenen 8 Bytes gespeichert sind (string, bytearray, zeiger auf puffer), dann kann man dir sagen, wie du an die einzelnen bytes dran kommst.

marabu

[xeus]

du fragst mich sachen, in der selben form wie auch die gesendeten daten
(bin) siehe weiter oben

[xeus]

Hat alles super geklapt, nur weiss einer fon euch, wie ich diesen schritt genau in die andere richtung mach?

apdcomport1.PutString(#10);

quasi eine zahl vom com empfangen

[marabu]

Wie kann man nur so aneinander vorbeischreiben...

Ich wollte wissen in welcher Variablen du die empfangenen Zeichen abgespeichert hast. Scheint so als hättest du die Zeichen noch gar nicht empfangen, als wüsstest du nicht mal wie du sie empfangen könntest.

Definier dir einen Empfangspuffer:

Delphi-Quellcode:

type
  TDemoForm = class(TForm)
  ...
  private
    ReceiveBuffer1: array of byte;
  end;

Schreibe einen event handler für apdComPort1.OnTriggerAvail:

Delphi-Quellcode:

procedure TDemoForm.apdComPort1TriggerAvail(cp: Comport; count: integer);
begin
  SetLength(ReceiveBuffer1, count);
  cp.GetBlock(ReceiveBuffer[0], count);
end;

Immer wenn jetzt Daten an deiner Schnittstelle eingehen, dann werden Sie im Empfangspuffer abgelegt. Damit sie nicht ständig die alten Daten dort überschreiben, solltest du eventuell einen Ringpuffer anlegen.

Grüße vom marabu

[Sharky]

:gruebel:

Jetzt geht es hier weiter -> klick.

Diesen Thread mache ich zu. Sonnst blickt bald keiner mehr durch.