Const  parityEnable         = False ; flag if parity is enabled
Const  protocol             = 0     ; stores protocol type
Const  dataBits             = 8     ; stores number if data bits
Const  parityBit            = 0     ; stores type of parity bit
Const  stopBits             = 0     ; stores number of stop bits
Global timeouts             = CreateBank(20)

Const  INVALID_HANDLE_VALUE = -1

Const  GENERIC_READ         = $80000000
Const  GENERIC_WRITE        = $40000000
Const  OPEN_EXISTING        = 3

Const  CBR_110              = 110
Const  CBR_300              = 300
Const  CBR_600              = 600
Const  CBR_1200             = 1200
Const  CBR_2400             = 2400
Const  CBR_4800             = 4800
Const  CBR_9600             = 9600
Const  CBR_14400            = 14400
Const  CBR_19200            = 19200
Const  CBR_38400            = 38400
Const  CBR_56000            = 56000
Const  CBR_57600            = 57600
Const  CBR_115200           = 115200

Const  DTR_CONTROL_DISABLE  = 0
Const  DTR_CONTROL_ENABLE   = 1
Const  RTS_CONTROL_DISABLE  = 0
Const  RTS_CONTROL_ENABLE   = 1
Const  EV_TXEMPTY           = 4

Const  SETRTS               = 3
Const  CLRRTS               = 4

; Example ---------------------------------------------------------------------------
Print "Open COM1 with 9600 baudrate ..."
hCom = openComport(1, 9600)
If hCom <> 0 And hCom <> INVALID_HANDLE_VALUE Then
   Print "   Succesfully"
Else
   Print "   Error"
   WaitKey : End
EndIf


; Transmit:
buffer = CreateBank(6)
PokeByte buffer, 0, Asc("H")
PokeByte buffer, 1, Asc("e")
PokeByte buffer, 2, Asc("l")
PokeByte buffer, 3, Asc("l")
PokeByte buffer, 4, Asc("o")
PokeByte buffer, 5, 0
Print "Sending "+Chr$(34)+"Hello"+Chr$(34)+" ..."
If writeComPort(hCom, 6, buffer) Then
   Print "   Succesfully"
Else
   Print "   Error"
   closeComport(hCom)
   WaitKey : End
EndIf
FreeBank buffer

; Receive
buffer = CreateBank(1024)
bytes  = CreateBank(4)
Print "Receiving datas ..."
If readComport(hCom, bytes, 1024, buffer, 2000) Then ; 2 Second timeout
   Print "   Succesfully"
   Print "   Number of receiving bytes "+PeekInt(bytes, 0)
   ; Datas are in the bank buffer
Else
   Print "   Error"
EndIf

; Close and end
closeComport(hCom)
WaitKey : End
; -----------------------------------------------------------------------------------

Function openComport(comport, baudRate)
   Local dcbBaudRate, driverHandle, dcb
   
   If comport > 255 Or comport < 0 Then
      Return False
   EndIf
   
   Select baudRate
      Case 110
         dcbBaudRate = CBR_110
      Case 300
         dcbBaudRate = CBR_300
      Case 600
         dcbBaudRate = CBR_600
      Case 1200
         dcbBaudRate = CBR_1200
      Case 2400
         dcbBaudRate = CBR_2400
      Case 4800
         dcbBaudRate = CBR_4800
      Case 9600
         dcbBaudRate = CBR_9600
      Case 14400
         dcbBaudRate = CBR_14400
      Case 19200
         dcbBaudRate = CBR_19200
      Case 38400
         dcbBaudRate = CBR_38400
      Case 56000
         dcbBaudRate = CBR_56000
      Case 57600
         dcbBaudRate = CBR_57600
      Case 115200
         dcbBaudRate = CBR_115200
      Default
         Return False
   End Select
   
   driverHandle = apiCreateFile("COM"+comport, GENERIC_READ Or GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0)
   If driverHandle = INVALID_HANDLE_VALUE Then
      Return INVALID_HANDLE_VALUE
   Else
      apiSetupComm(driverHandle, 1024, 1024)
      dcb = CreateBank(80)
      PokeInt dcb, 00, 80                         ; sizeof(DCB)
      PokeInt dcb, 04, dcbBaudRate                ; current baud rate
      PokeInt dcb, 08, 1                          ; binary mode, no EOF check
      If parityEnable = True Then
         PokeInt dcb, 12, 1                       ; enable parity checking
      Else
         PokeInt dcb, 12, 0                       ; disable parity checking
      EndIf
      If protocol = 0 Then
         PokeInt dcb, 24, DTR_CONTROL_ENABLE      ; DTR flow control type
      Else
         PokeInt dcb, 24, DTR_CONTROL_DISABLE     ; DTR flow control type
      EndIf
      PokeInt dcb, 28, False                      ; DSR sensitivity
      If protocol = 1 Then
         PokeInt dcb, 52, RTS_CONTROL_ENABLE      ; RTS flow control
      Else
         PokeInt dcb, 52, RTS_CONTROL_DISABLE     ; RTS flow control
      EndIf
      PokeInt  dcb, 60, 17                        ; reserved
      PokeByte dcb, 70, dataBits                  ; number of bits/byte, 4-8
      PokeByte dcb, 71, parityBit                 ; 0-4=no, odd, even, mark, space
      PokeByte dcb, 72, stopBits                  ; 0,1,2 = 1, 1.5, 2
     
      apiSetCommState(driverHandle, dcb)
      apiSetCommMask(driverHandle, EV_TXEMPTY)
   EndIf
   
   FreeBank dcb
   Return driverHandle
End Function

Function closeComport(driverHandle)
   If driverHandle = INVALID_HANDLE_VALUE Or driverHandle = 0 Then
      Return False
   Else
      Return apiCloseHandle(driverHandle)
   EndIf
End Function

Function writeComport(driverHandle, numBytes, buffer)
   Local state, temp

   If driverHandle = INVALID_HANDLE_VALUE Or driverHandle = 0 Then
      Return False
   EndIf
   
   apiEscapeCommFunction(driverHandle, SETRTS)
   
   temp = CreateBank(4)
   state = apiWriteFile(driverHandle, buffer, numBytes, temp, 0)
   
   apiEscapeCommFunction(driverHandle, CLRRTS)
   
   FreeBank temp
   Return state
End Function

Function readComport(driverHandle, bytesRead, bufferSize, buffer, tOut)
   Local comErrors, comStat
   
   If driverHandle = INVALID_HANDLE_VALUE Or driverHandle = 0 Then
      Return False
   EndIf
   
   PokeInt timeouts, 00, 0
   PokeInt timeouts, 04, 0
   PokeInt timeouts, 08, tOut
   PokeInt timeouts, 12, 0
   apiSetCommTimeouts(driverHandle, timeouts)
   
   comErrors = CreateBank(4)
   comStat   = CreateBank(10)
   apiClearCommError(driverHandle, comErrors, comStat)
   
   apiReadFile(driverHandle, buffer, bufferSize, bytesRead, 0)
   
   FreeBank comErrors
   FreeBank comStat
   Return True
End Function

//---------------------------------------------------------------------------
// METHODEN FÜR RS232 Kommunikation
//---------------------------------------------------------------------------

//-Eingebundene-Header-Dateien-----------------------------------------------
#include <vcl.h>
#include <math.h>
#include <stdio.h>
#pragma hdrstop


//-Variablen---------------------------------------------------------
extern HANDLE  DriverHandle;

HANDLE com_status_h;       // saves COM Status
int portnr_c = 1;          // stores COM-Port number
DWORD baudrate_dw = 9600;  // stores Baudrate
bool open_com_b = false;   // set if COM opened
DWORD rec_bytes_dw = 0;    // number of received bytes

bool par_enable_b;         // flag if parity is enabled
char protocol_c = 0;       // stores protokol type
char databits_c = 8;       // stores number if data bits
char paritbit_c = 0;       // stores type of parity bit
char stopbits_c = 0;       // stores number of stop bits

extern COMMTIMEOUTS timeouts;

//-Prototypen----------------------------------------------------------------
HANDLE Open_Comport (DWORD Comport, DWORD BaudRate);

int Close_Comport (HANDLE DriverHandle);

int Write_Comport (HANDLE DriverHandle, DWORD NumBytes, void *Buffer);

int Read_Comport (HANDLE DriverHandle, DWORD *BytesRead, DWORD BufferSize, void *Buffer,DWORD tout_dw);

//-Methoden------------------------------------------------------------------

//
// Open_Comport
// -------------
// Opens a communications port for use.
//
// Returns:   Handle number if successful, else 0
//
// Comport  = Communications port to open (ie. 1, 2, 3, 4, ... 255)
// BaudRate = Desired baud rate (ie, 110, 300, 600, 1200, 2400, 4800, 9600, 19200, ...)
//
HANDLE Open_Comport (DWORD Comport, DWORD BaudRate)
{
    //HANDLE  DriverHandle;
    unsigned char    Com_Name[10];
    DWORD   DCB_Baud_Rate;
    DCB     Our_DCB;

    //
    // Range check the Comport number
    //

    if (Comport > 255) {
        return INVALID_HANDLE_VALUE;
    }

    //
    // Make a COMPORT name from a number
    //

    sprintf (Com_Name, "COM%i", Comport);

    //
    // Convert the Baud Rate to the Com library define for the DCB
    //
    switch (BaudRate) {
        case 110:
            DCB_Baud_Rate = 110;
            break;
        case 300:
            DCB_Baud_Rate = CBR_300;
            break;
        case 600:
            DCB_Baud_Rate = CBR_600;
            break;
        case 1200:
            DCB_Baud_Rate = CBR_1200;
            break;
        case 2400:
            DCB_Baud_Rate = CBR_2400;
            break;
        case 4800:
            DCB_Baud_Rate = CBR_4800;
            break;
        case 9600:
            DCB_Baud_Rate = CBR_9600;
            break;
        case 19200:
            DCB_Baud_Rate = CBR_19200;
            break;
        case 38400:
            DCB_Baud_Rate = CBR_38400;
            break;
        case 57600:
            DCB_Baud_Rate = CBR_57600;
            break;
        case 115200:
            DCB_Baud_Rate = CBR_115200;
            break;
        default:
            return INVALID_HANDLE_VALUE;
    }

    //
    // Open a channel to the Comport - This example DOES NOT use overlapped I/O
    // Since the benefits of overlapped I/O are few, we suggest not using it.
    //
    DriverHandle = CreateFile (Com_Name, GENERIC_READ | GENERIC_WRITE,
                               0, NULL, OPEN_EXISTING, 0, NULL);

    //
    // Do we have a valid handle? (If not, the driver probably isn't loaded)
    //

    if (DriverHandle == INVALID_HANDLE_VALUE) {
        return (DriverHandle);
    } else {


        //
        // The SetupComm() function establishes the Transmit and Receive
        // buffer sizes.
        //
      SetupComm (DriverHandle, 1024, 1024);

        //
        // Obtain the current DCB structure. this can be saved away for restore after
        // the application is done using the Comport
        //
        GetCommState (DriverHandle, &Our_DCB);

        //
        // Fill in the DCB structure with our own settings.
        //
        Our_DCB.BaudRate = DCB_Baud_Rate;
        if (par_enable_b)
        {
         Our_DCB.fParity = 1;
        }
        else
        {
         Our_DCB.fParity = 0;
        }
        Our_DCB.fOutxCtsFlow = 0;
        Our_DCB.fOutxDsrFlow = 0;
        if (protocol_c == 0x00)
        {
         Our_DCB.fDtrControl = DTR_CONTROL_ENABLE;
        }
        else
        {
         Our_DCB.fDtrControl = DTR_CONTROL_DISABLE;
        }
        Our_DCB.fDsrSensitivity = FALSE;
        Our_DCB.fTXContinueOnXoff = 0;
        Our_DCB.fOutX = 0;
        Our_DCB.fInX = 0;
        Our_DCB.fErrorChar = 0;
        Our_DCB.fNull = 0;
        if (protocol_c == 0x01)
        {
         Our_DCB.fRtsControl = RTS_CONTROL_ENABLE;
        }
        else
        {
         Our_DCB.fRtsControl = RTS_CONTROL_DISABLE;
        }
        Our_DCB.fAbortOnError = 0;
        Our_DCB.ByteSize = databits_c;
        Our_DCB.Parity = paritbit_c;
        Our_DCB.StopBits = stopbits_c;

        //
        // Configure the comport with our new DCB
        //
        SetCommState (DriverHandle, &Our_DCB);

        //
        // Setup a mask that allows us to tell if the port is done transmitting
        // the current buffer of data
        //
        SetCommMask (DriverHandle, EV_TXEMPTY);
    }

    return DriverHandle;
}

//---------------------------------------------------------------------------

//
// Close_Comport
// -------------
// Closes a communications port previously opened
//
// Returns:   TRUE on success, FALSE on failure
//
// DriverHandle = Handle returned on Open_Comport() call
//
int Close_Comport (HANDLE DriverHandle)
{
    //
    // Sanity check on the Handle
    //
    if ((DriverHandle == 0) || (DriverHandle == INVALID_HANDLE_VALUE)) {
        return FALSE;
    }

    //
    // Close the communications port
    //
    CloseHandle (DriverHandle);

    return TRUE;
}

//---------------------------------------------------------------------------

//
// Write_Comport
// -------------
// Writes a buffer of data out the RS232 commmunications port
//
// Returns:   TRUE on success, FALSE on failure
//
// DriverHandle = Handle returned on Open_RS232() call
// NumBytes     = Number of bytes to send
// Buffer       = Buffer of data to send
//
int Write_Comport (HANDLE DriverHandle, DWORD NumBytes, void *Buffer)
{
    DWORD EvtMask, BytesWritten;
    BOOL status;

    //
    // Sanity check on the Handle
    //
    if ((DriverHandle == 0) || (DriverHandle == INVALID_HANDLE_VALUE)) {
        return FALSE;
    }

    //
    // Some devices may require setting RTS or DTR to specific states prior to
    // tranmission of data
    //
    EscapeCommFunction (DriverHandle, SETRTS);

    //
    // Output the data to the Comport
    //
    status = WriteFile (DriverHandle, Buffer, NumBytes, &BytesWritten, 0);

    //
    // If you want, use the WaitCommEvent() function to wait for the
    // data Transmission to complete
    //
    //    WaitCommEvent(DriverHandle, &EvtMask, NULL);

    //
    // Some devices may require clearing RTS or DTR to after transmission of data
    //
    EscapeCommFunction (DriverHandle, CLRRTS);
 
    return status;
}

//---------------------------------------------------------------------------

//
// Read_Comport
// -------------
// Reads data received on the RS232 communications port
//
// Returns:   TRUE on success, FALSE on failure
//
// DriverHandle = Handle returned on Open_RS232() call
// BytesRead    = Number of bytes read by the ReadFile() function
// BufferSize   = Size of Buffer in bytes
// Buffer       = Data buffer that holds received data
//
int Read_Comport (HANDLE DriverHandle, DWORD *BytesRead, DWORD BufferSize, void *Buffer,DWORD tout_dw)
{
    COMSTAT     Our_Comstat;
    DWORD       Com_Errors, BytesToRead;

    //
    // Sanity check on the Handle
    //
    if ((DriverHandle == 0) || (DriverHandle == INVALID_HANDLE_VALUE)) {
        return FALSE;
    }

    //
    // By far the most efficient way to input Comport data is the following:
    // ---------------------------------------------------------------------
    // A) See how much data is present
    // B) Read exactly that amount of data
    //
    // Note: It is possible to ask for more data than is present, but the ReadFile()
    //       function call will not return until that amount of data has been received.
    //       Some programs will request more data and establish a timeout using the
    //       SetCommTimeouts() function to return from the ReadFile() function when
    //       not enough data has been receive. Although this may work, it is inefficient
    //       and generally works like crap. For everyone's sake, use the technique above
    //       and handle your own timeout in applications code.
    //

    timeouts.ReadIntervalTimeout = 0;
    timeouts.ReadTotalTimeoutMultiplier = 0;
    timeouts.ReadTotalTimeoutConstant = tout_dw;
    timeouts.WriteTotalTimeoutMultiplier = 0;
    timeouts.WriteTotalTimeoutConstant = 0;

    SetCommTimeouts(DriverHandle,&timeouts);


    //
    // Check the Input buffer
    //
    ClearCommError (DriverHandle, &Com_Errors, &Our_Comstat);


        //
        // Read the data, no (NULL) Overlapped I/O
        //
        ReadFile (DriverHandle, Buffer, BufferSize, BytesRead, NULL);

   

    return TRUE;
}