Hab mir aus dem netz das gesaugt

int read()
{
  unsigned char InString[COM_BUFFER_SIZE + 1];
  DWORD dwRead = 0;
  ReadFile (hCom, &InString, sizeof (InString), &dwRead, NULL);
  if (dwRead != 0)
  {
   InString[dwRead] = \´0´;
    cout << InString;
  }
  return 0;
}

Lese jetzt bitweise ein aber wie kriege ich dieses in ein Memofeld ? unsigned char kann nicht nach AnsiString außerdem am ende sollte dieses Herauskommen

$GPGGA,131746.217,0000.0000,N,00000.0000,E,0,00,0.0,0.0,M,,,,0000*0C
$GPRMC,131746.217,V,0000.0000,N,00000.0000,E,,,201005,,*10
$GPVTG,,T,,M,,N,,K*4E

kann mir einer dies etwas genauer erkären ?

Hab grad keine VCL Doku zur Hand: welche Konstruktoren bietet AnsiString?

Habe noch einen anderen Schnipsel mit AnsiStr

DWORD ReceiveData(char* Data,int n)
{
DWORD NumberOfBytesRead; // Anzahl der gelesenen Bytes
bool b=ReadFile(hComReceive, // handle des Com-Ports
Data, // Adresse des Datenpuffers
n, // Anzahl der zu lesenden Bytes
&NumberOfBytesRead, // Adresse übergeben
0); // kein overlapped I/O
if (!b)
ShowLastError("ReadFile");
return NumberOfBytesRead;
}

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
const int BufSize = 3;
char Buffer[BufSize]; // Puffer für die empfangenen Daten
DWORD NumberOfBytesRead=ReceiveData(Buffer,BufSize);
if (NumberOfBytesRead > 0)
{
AnsiString s;
for (DWORD i=0;i<NumberOfBytesRead;i++)
s=s+Buffer[i];
Memo1->Lines->Add("Gelesen n="+IntToStr
(NumberOfBytesRead)+" ch="+s);
}
else
Memo1->Lines->Add("Nichts empfangen");
}

ist aus einem anderen txt

ich hab irgendwie keinen plan as da passiert
kannst du mir das vieleicht so einfach wie nur möglich erklären ???
Der Com Port ist ja schon geöffnet und schickt mir bits, aber werden die jetzt irg[/cpp]endwie gebuffert?? Null Plan

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
const int BufSize = 3;// Puffer wird angelegt um 3 Stellen
char Buffer[BufSize]; // Puffer für die empfangenen Daten
DWORD NumberOfBytesRead=ReceiveData(Buffer,BufSize);//<-------??????
if (NumberOfBytesRead > 0)// wenn NumberOfBytesRead  größer als 0 dann
{
AnsiString s; // Eine Ansisting variable s anlegen
for (DWORD i=0;i<NumberOfBytesRead;i++)//NumberOfBytesRead werden hoch gezählt 
s=s+Buffer[i];//----------------------???????
Memo1->Lines->Add("Gelesen n="+IntToStr
(NumberOfBytesRead)+" ch="+s);// Ausgabe
}
else
Memo1->Lines->Add("Nichts empfangen");
}

Ich verstehe noch nicht den zusammen hang von:
1. das Bit was empfangen wird wo legt der Rechner es ab ?
2.und wie schreibe ich das Bit in das in das Memo Feld bzw String ?

DWORD NumberOfBytesRead=ReceiveData(Buffer,BufSize)
Diese zeile ist mir auch ein Rätzel

Ich hoffe ich habe es diesmal richtig ausgedrückt

AnsiString s; // Eine Ansisting variable s anlegen

Rischtisch.

com-cat schrieb:

for (DWORD i=0;i<NumberOfBytesRead;i++)//NumberOfBytesRead werden hoch gezählt

Sicher?

com-cat schrieb:

s=s+Buffer[i];//----------------------???????

Hm, was passiert hier wohl? Wonach siehts denn aus?

com-cat schrieb:

Ich verstehe noch nicht den zusammen hang von:
1. das Bit was empfangen wird wo legt der Rechner es ab ?

Die Bits werden im 16C550-Chip-Core des PCs gelagert, bis dier Chip das Byte für voll hält. Dann wird es in einen Puffer gelegt und das Betriebssystem holt das Byte ab. Du wiederum holst das Byte danna us diesem Puffer mit der ReadFile-Funktion...

com-cat schrieb:

2.und wie schreibe ich das Bit in das in das Memo Feld bzw String ?

Wozu binäre Darstellung? Davon sehe ich nichts in deinem Beispiel?

com-cat schrieb:

DWORD NumberOfBytesRead=ReceiveData(Buffer,BufSize)
Diese zeile ist mir auch ein Rätzel

Des Rätsels Lösung liegt in der Dokumentation zu ReceiveData, bzw. im Verfolgen dessen, was ReceiveData treibt und was es da so zurückliefert...

s=s+Buffer[i];

Da wird s mit dem Buffer Addiert aber s ist doch ein AnsiStr und kein double oder int????

for (DWORD i=0;i<NumberOfBytesRead;i++)//NumberOfBytesRead werden hoch gezählt

Enschuldigung!
1.i ist am anfang 0
2.Bedinung wenn i kleiner ist als NumberOfBytesRead dann führe schleife durch
3.wenn die schleife einmal druch ist zähle i 1mal rauf.

Jetzt zu ReciveData:

DWORD ReceiveData(char* Data,int n)
{
DWORD NumberOfBytesRead;      // Anzahl der gelesenen Bytes
bool b=ReadFile(hComReceive, // handle des Com-Ports
Data,                        // Adresse des Datenpuffers
n,                          // Anzahl der zu lesenden Bytes
&NumberOfBytesRead,         // Adresse übergeben
0);                        // kein overlapped I/O
if (!b)
ShowLastError("ReadFile");
return NumberOfBytesRead;
}

ReciveData ist der Puffer für die gelesenen Bytes oder ?
DWORD ReceiveData(char* Data,int n)

<-------und da geht es schon los

ich sehe nur das er die NumberOfBytesRead zurücklifert aber wo sind die Bytes drin in Data oder wie

s=s+Buffer[i];

Da wird s mit dem Buffer Addiert aber s ist doch ein AnsiStr und kein double oder int????

*smile* Schau mal in die BCB-Hilfe, gib AnsiString ein, klick auf "Methoden" und lies alles zum Thema "operator +"

Jetzt zu ReciveData:

DWORD ReceiveData(char* Data,int n)
{
DWORD NumberOfBytesRead;      // Anzahl der gelesenen Bytes
bool b=ReadFile(hComReceive, // handle des Com-Ports
Data,                        // Adresse des Datenpuffers
n,                          // Anzahl der zu lesenden Bytes
&NumberOfBytesRead,         // Adresse übergeben
0);                        // kein overlapped I/O
if (!b)
ShowLastError("ReadFile");
return NumberOfBytesRead;
}

com-cat schrieb:

ReciveData ist der Puffer für die gelesenen Bytes oder ?

ReceiveData ist ne Funktion, kein Puffer.

Aber die Funktion erwartet einen char-Zeiger auf einen Puffer für die Daten und eine Puffergrösse... (siehe:

DWORD ReceiveData(char* Data,int n)

)

com-cat schrieb:

ich sehe nur das er die NumberOfBytesRead zurücklifert aber wo sind die Bytes drin in Data oder wie

Was macht denn die Funktion genau?

DWORD ReceiveData(char* Data,int n) //also ist das wie ein Array
ist dann char Data so gesehen der zeiger auf das Array also position auf einen Arrayblock

n = größe des Arraysblock in Zeichen 

sie gibt ne Adresse an NumberOfBytesRead 

[cpp]DWORD NumberOfBytesRead=ReceiveData(Buffer,BufSize);//<-------??????

zurück

du ich hab keinen blaasen schimmer

DWORD ReceiveData(char* Data,int n)
{
    DWORD NumberOfBytesRead;      // Anzahl der gelesenen Bytes
    bool b = ReadFile(hComReceive, Data, n, &NumberOfBytesRead, 0);                       

    if (b == false)
        ShowLastError("ReadFile");

    return NumberOfBytesRead;
}

Versuchen wirs jeztt nochmal...

junix schrieb:

Was macht denn die Funktion genau?

Achte mal darauf womit "b" initialisiert wird...

Da b ein Bool ist und in der Klammer nicht 0 steht wird es mit True formatiert oder?

bool b = ReadFile(hComReceive, Data, n, &NumberOfBytesRead, 0);

So dieser Satz heißt:
n = sind die zu lesenen Bytes
NumberOfBytesRead = sind die tatsächlich gelesenen bytes
Data = ist der zeiger auf das Array Feld

bool b heißt wenn was da ist dann lese

verbesser mich wenn es nicht stimmt !

bool b heißt wenn was da ist dann lese

ne hab schon eiter gedacht es heißt hier natürlich setze b auf true ich blindfisch

&NumberOfBytesRead, 0);

schau dir doch einfach die Parameter der Funktion in der MSDN.
an. Dort ist auch eine Beschreibung, warum du bei dir den letzten Wert auf 0 setzten must.

bis bald
akari

junix hälst du es wirklich für eine gute Idee ihm programmieren anhand eines nicht trivialen Themas beizubringen?

Welches nicht triviale Thema? Ich bring ihm doch nicht programmieren bei, sondern das Denken, analysieren und finden von Informationen... Und das kann man eigentlich anhand jeden beispiels machen...

ot schrieb:

junix hälst du es wirklich für eine gute Idee ihm programmieren anhand eines nicht trivialen Themas beizubringen?

Welches nicht triviale Thema? Ich bring ihm doch nicht programmieren bei, sondern das Denken, analysieren und finden von Informationen... Und das kann man eigentlich anhand jeden beispiels machen...

Und das ist die Grundlage des Programmierens...allerdings hat ihn noch keiner darauf hingewiesen, dass er nicht Bitweise sondern Byteweise liest. Zum Verständnis ist das vielleicht nicht ganz unwichtig.

Und das ist die Grundlage des Programmierens...

Endlich jemand der das begreift *freu*

Serieller schrieb:

allerdings hat ihn noch keiner darauf hingewiesen, dass er nicht Bitweise sondern Byteweise liest. Zum Verständnis ist das vielleicht nicht ganz unwichtig.

Würde ich so jetzt nicht sagen:

junix schrieb:

com-cat schrieb:

Ich verstehe noch nicht den zusammen hang von:
1. das Bit was empfangen wird wo legt der Rechner es ab ?

Die Bits werden im 16C550-Chip-Core des PCs gelagert, bis dier Chip das Byte für voll hält. Dann wird es in einen Puffer gelegt und das Betriebssystem holt das Byte ab. Du wiederum holst das Byte danna us diesem Puffer mit der ReadFile-Funktion...

DWORD ReceiveData(char* Data,int n)
{
DWORD NumberOfBytesRead=0;
bool b= ReadFile(hCom,Data,n,&NumberOfBytesRead,0); // kein overlapped I/O

if (!b)
//ShowMessage("ReadFile");
//return
NumberOfBytesRead;
}

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
const int BufSize = 112000;
char Buffer[BufSize];
DWORD NumberOfBytesRead= ReceiveData(Buffer,BufSize);
if (NumberOfBytesRead > 0)
{
AnsiString s;
for (DWORD i=0;i<NumberOfBytesRead;i++)
        {
        s=s+Buffer[i];

        Memo1->Lines->Add(Buffer);
        }

}

und noch mal Danke für die Hilfe