Subversion Repositories HomeAutomation

#include "SerialReader.h"

#include <assert.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[QUEUE_PLACES];

int queueReadPointer=0;

int queueWritePointer=0;

int queueLength=0;

static CSerial * serial;

static SerialConnection * sc;

static HANDLE  hRunMutex;                   // "Keep Running" mutex

*/

void SerRead(void *pMyID)

{

    unsigned char iBuff[SERIAL_READ_BUFFER_SIZE];

    unsigned int iBuffPointer = 0;

    long lLastError = 0;

    /*

    // Register only for the receive event

    lLastError = serial->SetMask(CSerial::EEventRecv);

    if (lLastError != ERROR_SUCCESS)

    {

        printf("Err! Unable to set COM-port event mask.\n");

        return;

    }

    // Use 'non-blocking' reads, because we don't know how many bytes

    // will be received. This is normally the most convenient mode

    // (and also the default mode for reading data).

    lLastError = serial->SetupReadTimeouts(CSerial::EReadTimeoutNonblocking);

    if (lLastError != ERROR_SUCCESS)

    {

        printf("Err! Unable to set COM-port read timeout.\n");

        return;

    }

*/

    /*

    if (SetCommMask(sc->hCom,EV_RXCHAR))

    {

        // Handle the error.

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

        return;

    }

        // Create an event object for use by WaitCommEvent.

    OVERLAPPED o;

    DWORD dwEvtMask;

    o.hEvent = CreateEvent(

        NULL,   // default security attributes

        TRUE,   // manual-reset event

        FALSE,  // not signaled

        NULL    // no name

        );

    // Intialize the rest of the OVERLAPPED structure to zero.

    o.Internal = 0;

    o.InternalHigh = 0;

    o.Offset = 0;

    o.OffsetHigh = 0;

    */

        DWORD dwCommEvent;

        DWORD dwRead;

        char  chRead;

/*

        if (sc->getHandle() ==0)

        {

            printf("Serial port closed.");

            return;

        }

*/

        /*

        if (!SetCommMask(sc->getHandle(), EV_RXCHAR))

        {

            // Handle the error.

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

            return;

        }

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

    {

        if (WaitCommEvent(sc->getHandle(), &dwCommEvent, NULL))

        {

            if (ReadFile(sc->getHandle(), &chRead, 1, &dwRead, NULL))

            {

                printf("byte receiced\n");

            } else {printf("Error1\n"); break;}

        } else {printf("Error2\n"); break;}

        /*

        if (WaitCommEvent(sc->hCom, &dwEvtMask, &o))

        {

            if (dwEvtMask & EV_RXCHAR)

            {

                printf("RX\n");

            }

        }

        else

        {

            DWORD dwRet = GetLastError();

            if( ERROR_IO_PENDING == dwRet)

            {

                printf("I/O is pending...\n");

                // To do.

            }

            //else printf("Wait failed with error %d.\n", GetLastError());

        }*/

    //}

    return;

/*

    while(1)

    {

        // Wait for an event

        lLastError = serial->WaitEvent();

        if (lLastError != ERROR_SUCCESS)

        {

            printf("Err! Unable to wait for a COM-port event.\n");

            break;

        }

        // Save event

        const CSerial::EEvent eEvent = serial->GetEventType();

        // Handle data receive event

        if (eEvent & CSerial::EEventRecv)

        {

            // Read data, until there is nothing left

            DWORD dwBytesRead = 0;

            unsigned char szBuffer[SERIAL_INPUT_BUFFER_SIZE];

            do

            {

                // Read data from the COM-port

                lLastError = serial->Read(szBuffer,sizeof(szBuffer)-1,&dwBytesRead);

                if (lLastError != ERROR_SUCCESS)

                {

                    printf("Unable to read from COM-port.");

                    return;

                }

                if (dwBytesRead > 0)

                {

                    // Spara i array, sist.

                    arrayCopy(szBuffer, 0, iBuff, iBuffPointer, dwBytesRead);

                    iBuffPointer += dwBytesRead;

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

        }

    }

*/

    return;

}

/*

void serialReaderStart(CSerial * ser)

{

    serial = ser;

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

    _beginthread( SerRead, 0, 0 );

}

void serialReaderStartSerCon(SerialConnection * ser)

{

    sc = ser;

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

    _beginthread( SerRead, 0, 0 );

}

void serialReaderStop( void )

{

    ReleaseMutex( hRunMutex );

    CloseHandle( hRunMutex );

}

*/

//bool 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;

}*/