Create the Application

"COM1", GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); if (hComm == INVALID_HANDLE_VALUE) { Memo1->Lines->Add(return; } The next group of functions configure the serial Device Control Block (DCB) which controls baud rate, parity, data bits, and stop bits among other things. We call the WIN32 API GetCommDCB() function to load existing DCB parameters into our dcbCommPort structure. We next call BuildCommDCB() with a string describing baud rate, parity, data bits, and stop bits. Although the DCB has many parameters, in our example we're keeping it simple by using the BuildCommDCB() function to populate the dcbCommPort structure for us. Finally, calling SetCommState() loads our parameters into the DCB for our open port. If it's successful, we move on, otherwise we close the port, print an error message, and return.

  dcbCommPort.DCBlength = if(!BuildCommDCB("Cannot build comm DCB.");
    if(!SetCommState(hComm, &dcbCommPort)) {
    CloseHandle(hComm);
    hComm = NULL;
    Memo1->Lines->Add(return;
  }    

We next set the CommTimeouts. These settings control delays when trying to read from or write to the comm port. The values used in this example cause no delays when reading the port and a maximum delay of 250 ms when writing (Actually, the write delay will never occur in our example because we transmit characters individually without calling WriteFile().) We load our timeout values by calling SetCommTimeouts(). If no errors are returned, the comm port is now configured the way we want it.

  CommTimeouts.ReadIntervalTimeout = MAXDWORD;
  CommTimeouts.ReadTotalTimeoutConstant = 0;
  CommTimeouts.WriteTotalTimeoutConstant = 1;      "Cannot set timeouts.");
    true;
  ButtonStart->Enabled = true;
  Memo1->ReadOnly = Process any events that occur elsewhere in the program.
If bytes were read, display them in Memo1.
Calling ProcessMessages() inside the loop allows the application to handle other events like typing in Memo1 or clicking the Stop button. Sleep() prevents our loop from consuming all available CPU cycles which would far exceed our requirements. Because the serial device driver within the Windows OS has its own internal buffer, we won't miss any incoming characters while still allowing CPU time for other applications. It's the polite thing to do.
The ReadFile() function tries to read 100 bytes into our global array InBuffer. Because of our CommTimeout settings, ReadFile() will return immediately with whatever is available from the Windows internal serial receive buffer even if it's empty. If ReadFile() received any characters, we null-terminate the string and display it in Memo1. Pretty simple.
  1)
    ReadFile(hComm, InBuffer, if(BytesRead) {
      InBuffer[BytesRead] = if(hComm) TransmitCommChar(hComm, Key);
  Key = Final Thoughts

• Memo1 holds a lot of characters but will eventually run out of memory and just stop displaying anything new that arrives. You can limit the number of characters it will display by setting the Memo1 MaxLength property but then it will just run out of space sooner. A better approach is to limit the number of lines without affecting the display.
• LinksSimpleSerial.zip Download Turbo C Explorer Simple Serial Project.
  Microsoft MSDN Serial Communication Resources WIN32 API serial communication reference.
  www.turboexplorer.com/cpp Borland's FREE Turbo C Explorer

  //--------------------------------------------------------------------------- #include #pragma hdrstop #include "Main.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; // Add these global variables HANDLE hComm = NULL; char InBuffer[//--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // Add these local variables. DCB dcbCommPort; COMMTIMEOUTS CommTimeouts; DWORD BytesRead; // Open the port using WIN32 API CreateFile(). // Change COM1 for different port. // Leave the remaining parameters alone for simple // non-overlapped serial I/O. hComm = CreateFile( // If port cannot open, print error message and return. if (hComm == INVALID_HANDLE_VALUE) { Memo1->Lines->Add(return; } // Get the existing DCB parameters dcbCommPort.DCBlength = // Use the WIN32 API BuildCommDCB() to load simple comm parameters // into DCB. If it fails, print error message and return. "baud=9600 parity=N data=8 stop=1", &dcbCommPort)) { hComm = NULL; Memo1->Lines->Add(return; } // Use the WIN32 API SetCommState() to set parameters from DCB. // If it fails, close hComm, print error message, and return. "Cannot set comm state."); // Set CommTimeouts parameters. // See ReadFile() function later for details. CommTimeouts.ReadIntervalTimeout = MAXDWORD; CommTimeouts.ReadTotalTimeoutConstant = 0; CommTimeouts.WriteTotalTimeoutConstant = 1; // Use the WIN32 API SetCommTimeouts() to set parameters from DCB. // If it fails, close hComm, print error message, and return. "Cannot set comm timeouts."); // Set CommFlag and Button states. Allow typing in Memo1. CommFlag = false; ButtonStop->Enabled = false; Memo1->SetFocus(); // Constantly loop while CommFlag is true. // ProcessMessages() allows other other events within the program // to be serviced. ReadFile() tries to read 100 bytes into InBuffer. // Because of the timeouts we used earlier, ReadFile() will return // immediately with whatever characters it has (up to 100). The // BytesRead variable will contain the number of characters loaded // into InBuffer. // If BytesRead > 0, make the last charater in the received string = 0. // This terminates the string. Notice that we dimensioned InBuffer[101] // to accomodate the terminating 0 if necessary. Use SetSelTextBuff() // to append the contents of InBuffer onto the end of text in Memo1. // Pressing either the Stop button or Window close button will // set CommFlag = false. That will end the loop. 1) ReadFile(hComm, InBuffer, if(BytesRead) { InBuffer[BytesRead] = // Close the comm port and set hComm to NULL. CloseHandle(hComm); hComm = NULL; //Set button enables back to original state. Make Memo1 read-only. ButtonStart->Enabled = false; Memo1->ReadOnly = //--------------------------------------------------------------------------- // If Stop button pressed... CommFlag = false; } //--------------------------------------------------------------------------- // If attempting to close the window... CommFlag = //--------------------------------------------------------------------------- // If a Memo1 key is pressed, transmit it. // TransmitCommChar() returns 0 if the previous character has not // finished sending. Keep trying until non-zero is returned. while(TransmitCommChar(hComm, Key) == // Set Key=0 so it will not echo in Memo1. // Omit this line if you want local echo. Key = //---------------------------------------------------------------------------