Subversion Repositories HomeAutomation

#define STRICT

#include "SerialConnection.h"

void arrayCopy(unsigned char *src,unsigned int srcIndex,unsigned char *dst,unsigned int dstIndex,unsigned int length);

bool queueEnqueue(CanProtoMessage cpm);

bool queueDequeue(CanProtoMessage *cpm);

CanProtoMessage *cpmQueue;

int queueReadPointer=0;

int queueWritePointer=0;

int queueLength=0;

static HANDLE hCom;

static HANDLE  hRunMutex;  // "Keep Running" mutex 

static void SerRead(void *pMyID);

SerialConnection::SerialConnection(LPCTSTR portName,EBaudrate baudRate,EDataBits byteSize,EParity parity, EStopBits stopBits)

{

    SerialConnection::uportName=portName;

    SerialConnection::ubaudRate=baudRate;

    SerialConnection::ubyteSize=byteSize;

    SerialConnection::uparity = parity;

    SerialConnection::ustopBits=stopBits;

    hCom = NULL;

}

SerialConnection::~SerialConnection() {  }

bool SerialConnection::open()

{

    DCB dcb;

    // Check if the port isn't already opened

    if (hCom)

    {

        printf ("Open - Port already opened\n");

        return false;

    }

    hCom = CreateFile( uportName,

                    GENERIC_READ | GENERIC_WRITE,

                    0,    // must be opened with exclusive-access

                    NULL, // no security attributes

                    OPEN_EXISTING, // must use OPEN_EXISTING

                    FILE_FLAG_OVERLAPPED,    // not overlapped I/O

                    NULL  // hTemplate must be NULL for comm devices

                    );

    if (hCom == INVALID_HANDLE_VALUE)

    {

       // Handle the error.

       printf ("CreateFile failed with error %d.\n", GetLastError());

       return false;

    }

    // Build on the current configuration, and skip setting the size

    // of the input and output buffers with SetupComm.

    if (!GetCommState(hCom, &dcb))

    {

      // Handle the error.

      printf ("GetCommState failed with error %d.\n", GetLastError());

      return false;

    }

    // Fill in DCB: 57,600 bps, 8 data bits, no parity, and 1 stop bit.

    dcb.BaudRate = SerialConnection::ubaudRate;     // set the baud rate

    dcb.ByteSize = SerialConnection::ubyteSize;             // data size, xmit, and rcv

    dcb.Parity = SerialConnection::uparity;        // no parity bit

    dcb.StopBits = SerialConnection::ustopBits;    // one stop bit

    if (!SetCommState(hCom, &dcb))

    {

      // Handle the error.

      printf ("SetCommState failed with error %d.\n", GetLastError());

      return false;

    }

    if (!SetCommMask(hCom, EV_RXCHAR))

    {

        // Handle the error. 

        printf("SetCommMask failed with error %d.\n", GetLastError());

        return false;

    }

    hRunMutex = CreateMutex( NULL, TRUE, NULL );      // Set 

    _beginthread( SerRead, 0, 0 );

    printf ("Serial port successfully reconfigured.\n");

    return true;

}

HANDLE SerialConnection::getHandle()

{

    return hCom;

}

bool SerialConnection::close()

{

    ReleaseMutex( hRunMutex );

    CloseHandle( hRunMutex );

    if (hCom==0)

    {

        printf("Close - Method called when device is not open\n");

        return false;

    }

    CloseHandle(hCom);

    return true;

}

bool SerialConnection::isOpen()

{

    return (hCom != 0);

}

bool SerialConnection::write(LPCVOID lpBuffer, unsigned int nNumberOfBytesToWrite)

{

    if (hCom==0)

    {

        printf("Close - Method called when device is not open\n");

        return false;

    }

    /*

    OVERLAPPED ol;

    memset(&ol,0,sizeof(ol));

    if (!WriteFileEx(hCom,lpBuffer,nNumberOfBytesToWrite,&ol,NULL))

    {

        printf("Write - Unable to write the data\n");

    }

*/

    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)

   {

      printf("error creating overlapped event handle\n");

      return FALSE;

   }

    // Issue write.

   if (!WriteFile(hCom, lpBuffer, nNumberOfBytesToWrite, &dwWritten, &osWrite))

   {

      if (GetLastError() != ERROR_IO_PENDING)

      {

         printf("WriteFile failed, but isn't delayed. Report error and abort.\n");

         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))

                       fRes = FALSE;

                 else

                  // Write operation completed successfully.

                  fRes = TRUE;

                 break;

            default:

                 // An error has occurred in WaitForSingleObject.

                 // This usually indicates a problem with the

                // OVERLAPPED structure's event handle.

                 fRes = FALSE;

                 break;

         }

      }

   }

   else fRes = TRUE;

      // WriteFile completed immediately.

   CloseHandle(osWrite.hEvent);

   return fRes;

    return false;

}

void SerRead(void *pMyID)

{

    unsigned char iBuff[SERIAL_READ_BUFFER_SIZE];

    unsigned int iBuffPointer = 0;

    cpmQueue = (CanProtoMessage *)malloc(QUEUE_PLACES*sizeof(CanProtoMessage));

    DWORD dwCommEvent;

    DWORD dwRead;

    unsigned char chRead[128];

    if (hCom ==0)

    {

        printf("Serial port closed.");

        return;

    }

    OVERLAPPED osReader = {0};

    // Create the overlapped event. Must be closed before exiting

    // to avoid a handle leak.

    osReader.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

    while ( WaitForSingleObject( hRunMutex, 75L ) == WAIT_TIMEOUT )

    {

        if (WaitCommEvent(hCom, &dwCommEvent, NULL))

        {

            if (ReadFile(hCom, &chRead, 128, &dwRead, &osReader))

            {

                // Read data, until there is nothing left

                DWORD dwBytesRead = 0;

                unsigned char szBuffer[SERIAL_INPUT_BUFFER_SIZE];

                do

                {

                    if (dwRead > 0)

                    {

                        // Spara i array, sist.

                        arrayCopy(chRead, 0, iBuff, iBuffPointer, dwRead);

                        iBuffPointer += dwRead;

                        // Följ parserutin.

                        // Köa.

                        // flytta.

                         // När array större eller lika med PACKET_LENGTH...

                        while (iBuffPointer >= PACKET_LENGTH)

                        {

                            int startIndex = 0;

                            // Sök igenom efter start byte från början.

                            for (unsigned int i = 0; i < iBuffPointer; i++)

                            {

                                // Poppa alla bytes som inte är startbyte.

                                if (iBuff[i] != UART_START_BYTE) startIndex++;

                                else

                                {

                                    // När startbyte hittas, kolla om återstående längd är större eller lika med PACKET_LENGTH (inkl startbyte)

                                    if ((iBuffPointer - startIndex) >= PACKET_LENGTH)

                                    {

                                        //om så, kolla PACKET_LENGTH-1 byte fram.

                                        if (iBuff[startIndex + PACKET_LENGTH - 1] == UART_END_BYTE)

                                        {

                                            // Om byte PACKET_LENGTH-1 är slutbyte så extraktas startIndex till slutbyteindex.

                                            CanProtoMessage cmp(iBuff,startIndex + 1);

                                            queueEnqueue(cmp);

                                            // Sätt ny startindex och avsluta loop.

                                            startIndex += PACKET_LENGTH;

                                            break;

                                        }

                                    }

                                }

                            }

                            // och i slutet göra en array copy.

                            // Flytta ner allt efter slutbyte till index 0 i array.

                            arrayCopy(iBuff, startIndex, iBuff, 0, iBuffPointer - PACKET_LENGTH);

                            iBuffPointer -= startIndex;

                        }

                    }

                }while (dwBytesRead == sizeof(szBuffer)-1);

                //printf("byte receiced\n");

            } else { printf("Error (1): %d\n",GetLastError()); break;}

        } else { printf("Error (2): %d\n",GetLastError()); break;}

    }

}

bool SerialConnection::getMessage(CanProtoMessage *cpm)

{

    return queueDequeue(cpm);

}

void arrayCopy(unsigned char *src,unsigned int srcIndex,unsigned char *dst,unsigned int dstIndex,unsigned int length)

{

    // Copy an aray to another array (of unsigned chars == bytes)

    for(unsigned int i=0;i<length;i++) dst[dstIndex+i]=src[srcIndex+i];

}

bool queueEnqueue(CanProtoMessage cpm)

{

    // Enqueue reveiced message to queue

    if (queueLength>=QUEUE_PLACES) return false;

    cpmQueue[queueWritePointer]=cpm;

    queueLength++;

    queueWritePointer++;

    if (queueWritePointer>=QUEUE_PLACES) queueWritePointer=0;

    printf("[%ld] Queue message, length: %d\n",GetTickCount(),queueLength);

    return true;

}

bool queueDequeue(CanProtoMessage *cpm)

{

    // Dequeue can message.

    if (queueLength==0) return false;

    cpm = &cpmQueue[queueReadPointer];

    queueLength--;

    queueReadPointer++;

    if (queueReadPointer>=QUEUE_PLACES) queueReadPointer=0;

    return true;

}