Hello Scott and everyone else who will read this post.
After many messages that I posted on the news groups about rs232, I have
come up with functional code which reads in as many as 25 characters in one
operation, meaning that a micro-controller can send 25 bytes to the PC and
VC++ has no problem reading this. The code can be altered to read many more
bytes than 25 if required, however I only tested up to 25. All you need to do
is to change the first defined statement > BYTESTOREAD!
Scott, I have learnt a lot form our exchage of posts, so I figure I would
like to share with you, what I have come up with, and I would appreciate your
opinion â?¦ However, I know that the code can probably be made more efficient,
however I think, for me, for now, its quite okay!
This is not the way I will leave the code, there will be some final touches
such as better placement of #define statements and so forth!
I will put comments under every line of code, so if you disagree with the
commentary feel free to correct it.
//////////////////////////////////////////////////////////////////////
#include <windows.h>
CSerialWnd MySerial;
//Create an object of Cserial type.
LRESULT CALLBACK WndProc_CW1 (HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
//RS232 *Receive mode
#define BYTESTOREAD 25 //Depicts the amount of bytes to read!
#define OB_BYTES ((BYTESTOREAD*2)+1) //Number of bytes for official Buffer !
static DWORD dwBytesRead;
//Declaration of variable to indicate actual bytes that are
//read in within the time limit that windows allowed!
static byte CatchByte_BUFFER[BYTESTOREAD+1];
//Bytes returned from the MySerial.Read() function, will be
//immediatelly assigned to this array.
static byte Accum_BUFFER[BYTESTOREAD+1];
//Since windows cannot assure a constant amount of bytes
//returned from the MySerial.Read() function(which come
// from the rs232 port), then when CatchByteBUFFER
//is full, I transfer its bytes to the Accum_BUFFER. So
//now, CatchByteBUFFER is ready for another, set of bytes
//returned from the next MySerial.Read() function.
static TCHAR Official_BUFFER[OB_BYTES];
//This array holds the final and complete string that was read
in .
int k,n,j;
//General purpose variables used to loop and index arrays
//RS232 SERIAL PORT MONITOR
if (message == CSerialWnd::mg_nDefaultComMsg)
{
const CSerialWnd::EEvent eEvent = SerialWnd::EEvent(LOWORD(wParam));
const CSerialWnd::EError eError = CSerialWnd::EError(HIWORD(wParam));
switch (eEvent)
{
case CSerialWnd::EEventRecv:
// A serial message occurred
j = 0;
//Holds Accumulative array index value
do
{
MySerial.Read(CatchByte_BUFFER,
sizeof(CatchByte_BUFFER),
&dwBytesRead);
//Read the port, and the third parameter
//will hold the amount of bytes read in!
CatchByte_BUFFER[dwBytesRead] = '\0';
//Null Terminate the CatchByte_BUFFER array!
n = dwBytesRead;
//Re-assign the amount of bytes read in to another
variableâ?¦
//The reason for this was that I would get the
following error, if I
//were to put this variable straight into the for
loop command:
//c:\_DTS_PROGRAMMING\C_PROGRAMMING\vc++\MY_APPS_LAB
// \XPPLC\WndProc_CW1.cpp(220) : warning C4018: '<' :
//signed/unsigned mismatch.
//So for now, I just re-assigned it!
for(k=0;k<n;k++)
{
Accum_BUFFER[k+j] = CatchByte_BUFFER[k];
//Store the bytes that were just read in into an
//accummulator array!
}
j = j + dwBytesRead;
//Advance the index for the Accum_BUFFER array
//so we can append the next bytes which reside in the
//CatchByte_BUFFER array in the next iteration!
}
while(j != (BYTESTOREAD) && j != 0);
//If all the bytes were read in, then , j will
be equal to
//BYTESTOREAD and will break out of the while
loop, and
//also, for unneccessary subsequent port reads
where
//dwBytesRead will equal to 0, meaning that no
bytes were
//read, then this will cause the breaking out
//of the while loop aswell!
MultiByteToWideChar(CP_ACP,0, (LPCSTR)Accum_BUFFER,-1,Official_BUFFER,OB_BYTES);
//Finally, assign the fully accumulated bytes
//to a TCHAR string array, which are
converted
//to unicode, if I am not mistaken!
break;
default:
break;
}
return 0;
}
switch(message)
{
case WM_CREATE:
MySerial.Open(TEXT("COM1"),hwnd,WM_NULL,lParam,0,0);
//Open the rs232 port
MySerial.Setup(CSerial::EBaud9600,CSerial::EData8,
CSerial::EParNone,CSerial::EStop1);
//Set up the rs232 port
return 0;
case WM_CLOSE:
MySerial.Close(); //Close Port!
break;
return 0;
}
return DefWindowProc(hwnd, message,wParam,lParam);
}
/////////////////////////////////////////////////////////////////////////////////////////////
The above code has been extensively tested, many times and has never failed.
After spending many hours on the subject, I thought I could shine some light
on rs232 in a laymens kind of way, I know for many of you, this is probably
unworthy of your time or knowledge, however, if I would of have had this type
of post 3 months ago, it really would of made the rs232 implementation curve
a lot simpler for me! I invite anyone that is a beginer and finds rs232
complicated just as I did, (and still do! Because I am sure there is much
more to this) to use it and improve upon it!
I have one question though! What is the advantage of using the Wndserial
class as opposed to using functions like CreateFile, WriteFile, ReadFile, and
CloseHandle.
Would I be better off, or is it because in Windows it would be too
complicated!
Just asking!
I thank Scott and all members of the news groups that have helped me on the
subject!
You guys, are a great resource on the subjects of C,C++,VC++.
--
Best regards
Robert