WriteFile und ReadFile

[Thomas H. (datatom)]

Hallo zusammen,

ich sende Daten vom PC zum Controller RN-Mega 2560 und die gleichen 
Daten wieder zurück. Wenn ich den ersten Datensatz "127X1" mit WriteFile 
sende erhalte ich den korrekten Datensatz "127X1" wieder per ReadFile 
zurück. Beim zweiten Datensatz sende ich "127Y1" und erhalte 
"127X1ÌÌÌÌ“ŠupLñ*" anstatt "127Y1" zurück. Nach dem Senden sende ich 
noch "\r\n" per ReadFile, um das Ende des Datensatzes mitzuteilen.


Mein Bascom-Programm sieht folgendermaßen aus:

$prog , 255 , &B11011100 ,                                  '&B11011001 ,                                  'Quarz an / Teiler aus / Jtag aus
$regfile = "m2560def.dat"
$hwstack = 82                                               '80
$framesize = 68                                             ' 64
$swstack = 68                                               '44
$crystal = 16000000                                         'Quarzfrequenz
Config Pind.5 = Output
Led Alias Portd.5
$baud = 19200


'Config Com1 = 19200 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
'Config Com2 = 38400 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
Config Com3 = 19200 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
'Config Com4 = 38400 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
'Open "com1:" For Binary As #1                               'RS232
'Open "com2:" For Binary As #2                               'RS232
Open "com3:" For Binary As #3                               'RS232
'Open "com4:" For Binary As #4                               'RS232



Dim Eingabe As String * 50
Dim Ausgabe As String * 25

Dim String1 As String * 3
Dim String2 As String * 2

Dim X1_position As Integer
Dim Y1_position As Integer
Dim Z1_position As Integer

Config Porth = Output
Out1 Alias Porth.0
Out2 Alias Porth.1
Out3 Alias Porth.2
Out4 Alias Porth.3
Out5 Alias Porth.4
Out6 Alias Porth.5
Out7 Alias Porth.6
Out8 Alias Porth.7

Declare Sub Daten_empfangen()
Declare Sub Daten_senden()

Do

  Led = 0
  Call Daten_empfangen()
  Led = 1
  Call Daten_senden()

Loop

End

Sub Daten_empfangen()

  Input Eingabe
  String1 = Mid(eingabe , 1 , 3)
  String2 = Mid(eingabe , 4 , 2)
  Ausgabe = String1 + String2 + Chr(13)

  If String2 = "X1" Then
     X1_position = Val(string1)
  End If

  If String2 = "Y1" Then
     Y1_position = Val(string1)
  End If

  If String2 = "Z1" Then
     Z1_position = Val(string1)
  End If

End Sub

Sub Daten_senden()

  Print Ausgabe

End Sub

Meine ReadWrite-Funktion in C++ sieht so aus:

tbResult ReadAndWrite(HWND hwnd, char * char_cstr ) 
{
  //char write_buffer[10] = {' '};
  char read_buffer[8] = {' '};
  string string_parameter_read;
  string string_parameter_read2;
  string string_parameter_write;
  string string_parameter_write2;
  string string_fehlerfrei_gesendet;
  char *char_cstr2 = " ";
  char buffer_ende[] = {' '};
  char *angabe_achse = " ";
  size_t newsize = 0; // = strlen(write_buffer) + 1;
  ////////////////////////size_t origsize = wcslen(p_wchar_T) + 1;
  size_t origsize = 0;
  size_t convertedChars = 0;
  int i = 0;
  int Error = 1;

  if(board_angeschlossen == 1)
  {
    do // Senden bis der Achsenwert, etc. und das Endezeichen /r ordnungsmgemäß gesendet wurde
    {
      if(!WriteFile(hSerial, char_cstr, n, &dwBytesWrite, NULL))
      {
        //error occurred. Report to user
        msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei WriteFile!",
          (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
        EndDialog(hwnd, 1);
        return TB_ERROR;
      }
      else
      {
        string_parameter_write = char_cstr;
        int laenge_string_write = string_parameter_write.length() - 2;
        string_parameter_write2 = string_parameter_write.substr(laenge_string_write,2);
        
        if(!WriteFile(hSerial, "\r\n", n, &dwBytesWrite, NULL))
        {
          //error occurred. Report to user
          msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei WriteFile!",
            (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
          EndDialog(hwnd, 1);
          return TB_ERROR;
        }
        else
        {
          string_fehlerfrei_gesendet = "Ja";
        }
        
      }
    }while(string_fehlerfrei_gesendet == "Nein" );

    string_fehlerfrei_gesendet = "Nein";

    int do_zaehler = 1;
    do // Ausführen bis der empfangene Wert der Achse, etc. gleich des gesendeten Wertes der Achse ist
    {
      do_zaehler ++;

      //read_buffer[8] = ' ';
      if(!ReadFile(hSerial, &read_buffer, n, &dwBytesRead, NULL))
      {
        //error occurred. Report to user.
        msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei ReadFile!",
          (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
        EndDialog(hwnd, 1);
        return TB_ERROR;
      }

      // Achsenwert übergeben
      string_parameter_read = read_buffer;

...

belangloses :)

Ich komm einfach nicht weiter:(

Kann mir bitte jemand helfen?

Vielen Dank.

Grüße

datatom

[... (Gast)]

Das hier ist schonmal etwas daneben!

if(!WriteFile(hSerial, "\r\n", n, &dwBytesWrite, NULL))

Schau Dir an, wozu der dritte Parameter dient! Wo kommt dieses "n" 
überhaupt her, in Deinem Codeschnipsel wird das nirgenwo gesetzt.

[Thomas H. (datatom)]

N hat den wert 8. weil ich 8 bytes übertrage. Oder muß n den genauen 
Wert des zu übertragenen Characters haben? Bin gerade unterwegs und 
kanns nicht testen.

[... (Gast)]

Auweia.
Da muß drinstehen, wieviel Bytes aus dem angegebenen Buffer übertragen 
werden sollen! Und im nächsten Parameter bekommst Du zurück, wieviel 
tatsächlich übertragen wurden. Die beiden Werte müssen nicht 
notwendigerweise gleich sein.
Aber noch Schlimmer, in Deinem "Buffer" sind nur 3 Bytes ("\r\n")!
Wenn Du dem WriteFile sagst es soll 8 Bytes senden, sendest Du jede 
Menge Mist.

[Karl H. (kbuchegg)]

Du solltest dir ganz schnell eine

WriteString

Funktion machen, die dir genau diese Details (Anzahl Bytes ist gleich 
der Stringlänge) abnimmt.

Solch kleine Hilfsfunktionen, die sich um 1 oder mehrere Details für 
einen bestimmten Datentypen kümmern, sind das wie man sich selber das 
Leben einfacher machen kann.

[Thomas H. (datatom)]

Ich habe das Problem mit der falschen Längenangabe folgendermaßen 
gelöst:

...

laenge_write_char = sizeof(write_char);
      
      if(!WriteFile(hSerial, &write_char, laenge_write_char, &dwBytesWrite, NULL))
      {
        //error occurred. Report to user
        msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei WriteFile!",
          (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
        EndDialog(hwnd, 1);
        return TB_ERROR;
      }
      else
      {
       
        ...         
   
        int laenge_write_r = strlen ("\r");
        
        if(!WriteFile(hSerial, "\r", laenge_write_r, &dwBytesWrite, NULL))
        {
          //error occurred. Report to user
          msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei WriteFile!",
            (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
          EndDialog(hwnd, 1);
          return TB_ERROR;
        }
        else
        {
          string_fehlerfrei_gesendet = "Ja";
        }
        
      ...

      if(!ReadFile(hSerial, &read_buffer, laenge_write_char, &dwBytesRead, NULL))//n, &dwBytesRead, NULL))
      {
        //error occurred. Report to user.
        msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei ReadFile!",
          (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
        EndDialog(hwnd, 1);
        return TB_ERROR;
      }

      // Achsenwert übergeben
      string_parameter_read = read_buffer;

Erster Durchlauf:
write_char hat den Wert 127X1
laenge_write_char hat den Wert 6

laenge_write_r hat den Wert 1

Senden klappt.

Lesen klappt auch.

read_buffer hat den Wert 127X1

So solls sein.

Aber beim zweiten Durchlauf klappts nicht mehr:-(

Senden klappt.

read_buffer hat den Wert 127XÌÌÌÌÌÌÕ©¦­ñ?
read_buffer ist so definiert:

char read_buffer[6];


Ich glaub ich bin blind.

[Karl H. (kbuchegg)]

Du solltest zumindest dwBytesRead befragen, wieviele Zeichen empfangen 
wurden und nicht einfach annehmen, nur weil der ReadFile Call 
zurückkommt, hättest du 6 Zeichen gekriegt. ReadFile weiß nicht, auf 
wieviele Zeichen du wartest und kann auch vor Erreichen deiner magischen 
6 Zeichen Grenze schon w.o. geben.


wenn du also weißt, dass du eine bestimmte Zeichenanzahl abwarten musst, 
dann gehört das in eine Schleife, in der du die dwBytesRead aufsummierst 
und solange schleifst, bis du deine Anzahl beisammen hast.

Und das du hier

     string_parameter_read = read_buffer;

(string_parameter_read ist wohl eine String Klasse mit einem überladenen 
Zuweisungsoperator) sicherheitshalber den C-String auch noch sauber 
terminieren solltest, sollte eigentlich eine Selbstverständlichkeit 
sein. (*)


    read_buffer[ sizeof( read_buffer ) - 1 ] = '\0';
    string_parameter_read = read_buffer;


(*) ... die ich dir aber als C++ verwöhnter Programmierer nachsehe. 
C-Strings sind um einiges komplizierter zu benutzen als String-Klassen. 
Du musst wesentlich sorgfältiger damit umgehen und selbst dann sind sie 
immern noch wesentlich fehleranfälliger. Das rundum-sorglos Paket einer 
Klasse, die auf sich selbst aufpasst, existiert dort nicht.

[Thomas H. (datatom)]

Wie frage ich denn dwBytesRead ab?

So?

int laenge_read_buffer = sizeof (dwBytesRead);

Bin gerade unterwegs und kanns nicht testen.

[Karl H. (kbuchegg)]

Thomas Holländer schrieb:
> Wie frage ich denn dwBytesRead ab?

Das ist eine Variable.
Die hat einen Wert

    ....  ReadFile(hSerial, &read ........

    if( dwBytesRead == 5)
      MessageBox( ...  "Hurra, ich hab 5 Bytes bekommen" ... );
    else if( dwBytesRead == 4)
      MessageBox( ...  "Schmoll, ich hab bis jetzt nur 4 Bytes gekriegt" ... );

Oder eben in deinem Fall eine while Schleife aufziehen, die solange 
nicht verlassen wird, bis deine erwarteten 5 Bytes beisammen sind. Kein 
Mensch garantiert dir, dass du die Bytes in einem Stück bei einem 
einzigen Aufruf von ReadFile bekommst.


> So?
> int laenge_read_buffer = sizeof (dwBytesRead);

Duko lesen! In dwBytesRead informiert dich Windows darüber, wieviele 
Bytes es in deinen Buffer geschrieben hat. Dein Buffer kann 2 Kilobyte 
gross sein. Das heisst aber noch lange nicht, dass da dann auch 2 
Kilobytes reingeschrieben werden, wenn nur 5 Bytes daherkommen und der 
ReadFile wegen einem Timeout abgebrochen wird. Dann sagt dir eben 
dwbytesRead nach dem Aufruf, dass 5 Bytes in den Buffer geschrieben 
wurden.

[Thomas H. (datatom)]

Versteh ich nich.

Ich habe jetzt die Längen 4 bis 8 durchprobiert. Beim zweiten Senden 
stimmt der Wert nicht mehr und die Doku sagt mir auch nichts.

[... (Gast)]

        int laenge_write_r = strlen ("\r");
        
        if(!WriteFile(hSerial, "\r", laenge_write_r, &dwBytesWrite, NULL))
        {
          //error occurred. Report to user
          msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei WriteFile!",
            (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
          EndDialog(hwnd, 1);
          return TB_ERROR;
        }
        else
        {
          string_fehlerfrei_gesendet = "Ja";
        }

Der Ansatz ist ja schon mal gar nicht so verkehrt. Wenn Du jetzt noch 
dwBytesWrite überprüfst, passt das:

        int laenge_write_r = strlen ("\r");
        
        if(!WriteFile(hSerial, "\r", laenge_write_r, &dwBytesWrite, NULL))
        {
          //error occurred. Report to user
          msgboxIDss = MessageBox(NULL, (LPCWSTR)L"Fehler bei WriteFile!",
            (LPCWSTR)L"Fehler", MB_OK | MB_ICONEXCLAMATION);
          EndDialog(hwnd, 1);
          return TB_ERROR;
        }
        else if(laenge_write_r != dwBytesWrite)
        {
          string_fehlerfrei_gesendet = "Nein";
        }
        else
        {
          string_fehlerfrei_gesendet = "Ja";
        }

Beim ersten WriteFile und beim ReadFile analog

Thomas Holländer schrieb:
> Erster Durchlauf:
> write_char hat den Wert 127X1
> laenge_write_char hat den Wert 6
Was soll der Mist? Warum willst Du bei 5 Zeichen 6 Bytes senden?

> laenge_write_r hat den Wert 1
Das passt dann wieder.

Beim Lesen fehlt irgenwo noch das Stringendezeiche, mach nach dem 
ReadFile ein:

    read_buffer[dwBytesRead] = '\0';

Das ist vermutlich die Ursache für den ausgegebenen Müll.
Ein weiteres Problem ist, daß Du mehr Zeichen sendest als Du liest.
Beim ersten Lesen bekommst Du "127X1", beim zweiten "\r127X", beim 
dritten "1\r127" usw.

[Karl H. (kbuchegg)]

Thomas Holländer schrieb:
> Versteh ich nich.
>
> Ich habe jetzt die Längen 4 bis 8 durchprobiert. Beim zweiten Senden
> stimmt der Wert nicht mehr und die Doku sagt mir auch nichts.

Du gehen mit Korb in Lager und sagen zu Chef:

Ich brauchen Schrauben M8. Da seien Korb, der fassen maximal 200 
Schrauben.

Chef verschwinden hinter Regale und holen Schrauben.

Wenn Cheffe wiederkommen, er geben dir Korb und sagen: Hab dir 10 
Schrauben reingegeben, mehr hab ich nicht.


Was gibt es da nicht zu verstehen?

   Chef_Read_Schrauben( Regal,  Korb,        200,                 &wieviele_wirklich, NULL );
                          ^       ^            ^                   ^                   ^
                          |       |            |                   |                   |
                          v       v            v                   v                   v
   ReadFile(           hSerial, read_buffer, sizeof(read_buffer), &dwBytesRead,       NULL)

Und wenn du 200 Schrauben brauchst, dann musst du halt wieder zum Chef 
gehen und dir die nächste Ladung holen. Dann kriegst du vielleicht 15 
(und damit hast du in Summe 25). Und beinm nächsten mal (eine halbe 
Stunde später) hat Cheffe wieder 23 neue Schrauben im Regal und gibt sie 
dir. Dann hast du in Summe 48. Und so geht das dahin, bis du deine 200 
Schrauben beisammen hast.

[Rufus Τ. F. (rufus)]

Prächtig!

[Thomas H. (datatom)]

... schrieb:
> Thomas Holländer schrieb:
>> Erster Durchlauf:
>> write_char hat den Wert 127X1
>> laenge_write_char hat den Wert 6
> Was soll der Mist? Warum willst Du bei 5 Zeichen 6 Bytes senden?

Die Länge ermittle ich durch:

laenge_write_char = sizeof(write_char);

Siehe ganz oben. Warum der Wert 6 anstatt 5 ermittelt wird weis ich 
nicht. Werd ich gleich mal auf 5 ändern.

... schrieb:
> Beim Lesen fehlt irgenwo noch das Stringendezeiche, mach nach dem
> ReadFile ein:    read_buffer[dwBytesRead] = '\0';
> Das ist vermutlich die Ursache für den ausgegebenen Müll.

Wo und wie baue ich das denn mit dem Endezeichen ein?

[Karl H. (kbuchegg)]

Thomas Holländer schrieb:
> ... schrieb:
>> Thomas Holländer schrieb:
>>> Erster Durchlauf:
>>> write_char hat den Wert 127X1
>>> laenge_write_char hat den Wert 6
>> Was soll der Mist? Warum willst Du bei 5 Zeichen 6 Bytes senden?
>
> Die Länge ermittle ich durch:
>
>

> laenge_write_char = sizeof(write_char);
>

>
> Siehe ganz oben. Warum der Wert 6 anstatt 5 ermittelt wird weis ich
> nicht. Werd ich gleich mal auf 5 ändern.
>
> ... schrieb:
>> Beim Lesen fehlt irgenwo noch das Stringendezeiche, mach nach dem
>> ReadFile ein:    read_buffer[dwBytesRead] = '\0';
>> Das ist vermutlich die Ursache für den ausgegebenen Müll.
>
> Wo und wie baue ich das denn mit dem Endezeichen ein?


Spätestens jetzt sollte klar sein:
Du brauchst ganz dringend Literatur. Wenn dein C++ Buch keinen Abschnitt 
über C-Strings hat, dann musst du eine kleine C++ Pause einlegen und dir 
mit einem C-Buch die Grundlagen der C-Programmierung beibringen. So hat 
das wenig Sinn.

[... (Gast)]

Thomas Holländer schrieb:
> Die Länge ermittle ich durch:
> laenge_write_char = sizeof(write_char);
>
> Siehe ganz oben. Warum der Wert 6 anstatt 5 ermittelt wird weis ich
> nicht. Werd ich gleich mal auf 5 ändern.

Autsch, das tut ja schon weh.
Du solltest Dir definitiv ein gutes Buch zu C und C++ zulegen und 
nachschauen was der sizeof Operator macht! Das was Du da erwartest macht 
er jedenfalls nicht. C-Strings sind anscheinend bisher ein Buch mit 
sieben Siegeln für Dich. Da hilft nur lesen, lesen und nochmals lesen!!!
Ein String in C mit 5 Zeichen benötigt 6 Bytes Speicherplatz, weil das 
Ende der Zeichenkette irgendwie gekennzeichnet werden muß. Und in C 
macht man das, indem man ein 0 (Null, '\0') Byte hinten dran hängt.
Desweiteren hast Du anscheinend das Ganze als Unicode Projekt angelegt. 
Dafür sollte man aber auf jeden Fall auch wissen, was Unicode ist, was 
der Unterschied zwischen ASCII und Unicode ist, welche verschiedenen 
Kodierungen es gibt und wie das Ganze in C/C++ realisiert ist und wie 
man diese Sachen ineinander umwandelt.
Hier mal ein Stück Code zum drüber nachdenken. Solange Du aber nicht 
verstehst was da wann, wie und warum passiert, brauchst Du gar nicht 
erst weitermachen.

int ReadAndWrite(HWND hwnd, char *char_cstr)
{
  if(board_angeschlossen == 1) {
    char *write_pointer = char_cstr;
    DWORD len = write_pointer ? (DWORD)strlen(write_pointer) : 0;
    DWORD dwBytesWritten;
    while(len) {
      if(!WriteFile(hSerial, write_pointer, len, &dwBytesWritten, NULL)) {
        //error occurred. Report to user
        return -1;
      }
      len -= dwBytesWritten;
      write_pointer += dwBytesWritten;
    }
    write_pointer = "\r";
    len = (DWORD)strlen(write_pointer);
    while(len) {
      if(!WriteFile(hSerial, write_pointer, len, &dwBytesWritten, NULL)) {
        //error occurred. Report to user
        return -1;
      }
      len -= dwBytesWritten;
      write_pointer += dwBytesWritten;
    }

    DWORD dwBytesRead;
    char read_buffer[256];
    int read_index = 0;
    while(read_index < sizeof(read_buffer)) {
      if(!ReadFile(hSerial, &read_buffer[read_index], 1, &dwBytesRead, NULL)) {
        //error occurred. Report to user
        return -1;
      }
      if(dwBytesRead != 1) {
         //error occurred. Report to user
        return -1;
      }
      if(read_buffer[read_index] == '\n') {
        // ignore
        continue;
      }
      if(read_buffer[read_index] == '\r') {
        // end of message
        break;
      }
      read_index++;
    }
    if(read_index == sizeof(read_buffer)) {
      //error occurred (buffer overflow). Report to user
      return -1;
    }
    read_buffer[read_index] = '\0';

    wchar_t print_buffer[sizeof(read_buffer)];
    mbtowc(print_buffer, read_buffer, MB_CUR_MAX);
    MessageBox(hwnd, print_buffer, L"ReadFile", MB_OK | MB_ICONINFORMATION);

    // ...

[Thomas H. (datatom)]

Habe den Quelltext aus dem vorherigen Beitrag übernommen. Die Daten 
kommen jetzt. Vielen Dank.

Allerdings, verzögert. Wenn ich die Daten zum Controller sende kommen 
sie erst nach ein paar Sekunden zurück. Beim debuggen erhalte ich die 
Daten sofort, liegt wahrscheinlich an der Verzögerung, die der 
Haltepunkt auslöst.

Wer kann mir sagen, warum die verzögert kommen?

Vielen Dank.

Grüße

datatom