mikrocontroller.net

Forum: PC-Programmierung Nochmal Winapi und RS232


Autor: soso (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe jetzt nen funktionierenden code, mit welchem ich senden und 
empfangen kann, jedoch funktioniert das empfangen nicht gebuffert ist. 
ich würde gerne aus dem buffer immer das letzte empfangene zeichen 
auslesen. der rest soll solange im buffer warten. momentan empfange ich 
nicht jedes zeichen, wenn ich zwischendurch was anderes mache gehen mir 
zeichen verlohren.

Kann da jemand mal bitte über den code gucken?

Danke Gruß
// Handel fuer den comport
DCB           dcb;
DWORD         iBytesWritten, dwRead = 0;
DWORD         dwEvtMask, dwSetMask = EV_RXCHAR | EV_ERR;
HANDLE        hCom;
BOOL          bRet = TRUE;
OVERLAPPED    o;
COMMTIMEOUTS  ct;


#define RECVBYTES       5      // max. recv. bytes per transmission
#define STX             0x02
#define ETX             0x03
#define Pointer         0x00   // ?? Pointer sind 4 Byte lang?
#define CHK             0x3E
#define ENQ             0x05




/**
 * Diese Funktion initialisiert die RS232 Schnittstelle
 * und ließt / schreibt in die Buffer
 *
 *
 */
DWORD WINAPI rs232_listener(LPVOID lpParam){

    char          flag[] = {ENQ};
    unsigned char          output[] = {STX, 0x0E, Pointer, '1', ETX, CHK};

    int           laenge = sizeof(output);
    char          *Buf;

    Buf = (char*)malloc(laenge * 5 + 1);

    memset(&o, 0, sizeof(OVERLAPPED));
    o.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    if(!(hCom = CreateFile("COM3", GENERIC_WRITE | GENERIC_READ, 0, NULL,
                          OPEN_EXISTING, 0, NULL)))
    {
      LPVOID lpMsgBuf;
      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                      FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(),
                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
      MessageBox(NULL, (LPCTSTR)lpMsgBuf, "Error: CreateFile", MB_OK | MB_ICONINFORMATION);
      LocalFree(lpMsgBuf);
    return 0; // no action
    }

    dcb.DCBlength = sizeof(DCB);
    GetCommState(hCom, &dcb);
    dcb.BaudRate  = 9600;
    dcb.ByteSize  = 8;
    dcb.Parity    = NOPARITY;
    dcb.StopBits  = TWOSTOPBITS;
    SetCommState(hCom, &dcb);

    GetCommTimeouts(hCom, &ct);
    //ct.ReadIntervalTimeout         = 50;
    ct.ReadIntervalTimeout         = 100000 / 9600 * (dcb.ByteSize +
                                                   (dcb.Parity == NOPARITY ? 0 : 1) +
                                                   (dcb.StopBits == ONESTOPBIT ? 1 : 2)) * RECVBYTES;
    ct.ReadTotalTimeoutMultiplier  = 0;
    ct.ReadTotalTimeoutConstant    = 50;
    ct.WriteTotalTimeoutMultiplier = 0;
    ct.WriteTotalTimeoutConstant   = 0;
    SetCommTimeouts(hCom, &ct);

    SetupComm(hCom, COM_BUFFER_SIZE, COM_BUFFER_SIZE);
    SetCommMask(hCom, dwSetMask);

    if(!WriteFile(hCom, &flag, 1, &iBytesWritten, NULL)){
      LPVOID lpMsgBuf;
      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                    FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
      MessageBox(NULL, (LPCTSTR)lpMsgBuf, "Error: WriteFile", MB_OK | MB_ICONINFORMATION);
      LocalFree(lpMsgBuf);
    }




    return 0;




}






/**
 * Diese Funktion sendet ein Zeichen über den Sendebuffer
 */
void send_RS232(char *data, int length){


     OVERLAPPED osWrite = {0};
     DWORD dwWritten;
     DWORD dwRes;
     BOOL fRes;


     // Create this write operation's OVERLAPPED structure's hEvent.
     osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
     if (osWrite.hEvent == NULL)
        // error creating overlapped event handle
        printf("error\r\n");

     //printf("wait for signal");

     // Issue write.
     if (!WriteFile(hCom, data, length, &dwWritten, &osWrite)) {
        if (GetLastError() != ERROR_IO_PENDING) {
           // WriteFile failed, but isn't delayed. Report error and abort.
           fRes = FALSE;
        }else{
           // Write is pending.
           dwRes = WaitForSingleObject(osWrite.hEvent, INFINITE);
           switch(dwRes)
           {
              // OVERLAPPED structure's event has been signaled.
              case WAIT_OBJECT_0:
                   if (!GetOverlappedResult(hCom, &osWrite, &dwWritten, FALSE)){
               printf("Fehler 1");
                 fRes = FALSE;
                   }else{
                    // Write operation completed successfully.
                     printf("Ok");
                    fRes = TRUE;
                   }
                   break;

              default:
                   // An error has occurred in WaitForSingleObject.
                   // This usually indicates a problem with the
                  // OVERLAPPED structure's event handle.
                printf("Fehler 1");
                   fRes = FALSE;
                   break;
           }
        }
     }else{
        // WriteFile completed immediately.
        fRes = TRUE;
        //printf("Fehler");
     }
     CloseHandle(osWrite.hEvent);
     return;


}


/**
 * Diese Funktion empfaengt ein zeichen ueber den RS232 Buffer
 */
char receive_rs232(){
  char ret = 0;
  char InString[COM_BUFFER_SIZE + 1];

    WaitCommEvent(hCom, &dwEvtMask, &o);
    if(WAIT_OBJECT_0 == WaitForSingleObject(o.hEvent, INFINITE)) //warten bis Event
    {
      if(dwEvtMask & EV_RXCHAR)
      {
        bRet = ReadFile(hCom, &InString, sizeof(InString), &dwRead, NULL);
        if(!bRet){
          LPVOID lpMsgBuf;
          FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                        FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(),
                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
          MessageBox(NULL, (LPCTSTR)lpMsgBuf, "Error: ReadFile", MB_OK | MB_ICONINFORMATION);
          LocalFree(lpMsgBuf);
        }
        else
        {
          InString[dwRead] = '\0';
          // Add to buffer
          rxBuffer.buffer[(rxBuffer.iWrite++)%BUFFERSIZE] = InString[0];
          rxBuffer.anzElemente = rxBuffer.anzElemente + 1;
          //printf(TEXT("%s"), InString);
        }
      }
      if(dwEvtMask & EV_ERR)
      {
        MessageBox(NULL, "Error empfangen", "Error: ReadFile", MB_OK);
      }
    }



  return ret;
}

Autor: Justus Skorps (jussa)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
soso schrieb:
> ich würde gerne aus dem buffer immer das letzte empfangene zeichen
> auslesen. der rest soll solange im buffer warten.

mit Verlaub, das ist doch total unsinnig, die Reihenfolge der Zeichen 
wird wohl auch eine Bedeutung haben...und afaik geht das auch gar nicht, 
die Buffer von den üblichen RS232-Schnittstellen sind FIFO, da kann man 
sich nicht aussuchen, welche man jetzt haben möchte....

Autor: soso (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Naja das meine ich doch, nur mir gehen momentan Zeichen verlohren das 
will ich nicht

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.