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;

}*/