hey...........

I managed to compile the below code in Dev C++.Its a program to intialize a serial port and write to it.

The program is compiling. The problem i am facing now is......... how do I check weather it is running properly. I m simply initializing the serial port and writing the letter 'a' to it.

Acctually ...can I use a digital oscilloscope and check the waveform pattern in it???????????

11 01000001 0 = stop bits / data bits / start bit

would I be able to see a waveform pattern in the oscilloscope???????

For example......I am using a Dell Laptop. I connect the serial port of the Dell laptop to a digital oscilloscope.Then observe the digital waveform pattern........Do you think it can be done. If so how long will the waveform pattern last.

Are there any other ways to verify weather the program is writing to the serial port?

I would greatly appreciate any help u guys can give....

the code is below (compiles without errors on Dev C++ )



Serial.h
CODE
// Flow control flags

#define FC_DTRDSR 0x01
#define FC_RTSCTS 0x02
#define FC_XONXOFF 0x04

// ascii definitions
#include <stdio.h>
#include <time.h>

//#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers

//#include <afxwin.h> // serial.cpp : Defines the entry point for the console application.

//#include "stdafx.h"
#include <string.h>

#define ASCII_BEL 0x07
#define ASCII_BS 0x08
#define ASCII_LF 0x0A
#define ASCII_CR 0x0D
#define ASCII_XON 0x11
#define ASCII_XOFF 0x13


HANDLE SerialInit(char*, int);

char SerialGetc(HANDLE*);

void SerialPutc(HANDLE*, char);

--------------------------------------------------------------------------


Serial.cpp
CODE
#include <iostream>
#include <conio.h>
#include <stdio.h>
#include <time.h>
#include <windows.h>

//#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
//#include <bios.h>
//#include <afxwin.h> // serial.cpp : Defines the entry point for the console application.

//#include "stdafx.h"
#include <string.h>
#include "serial.h"

// Flow control flags

#define FC_DTRDSR 0x01
#define FC_RTSCTS 0x02
#define FC_XONXOFF 0x04

// ascii definitions

#define ASCII_BEL 0x07
#define ASCII_BS 0x08
#define ASCII_LF 0x0A
#define ASCII_CR 0x0D
#define ASCII_XON 0x11
#define ASCII_XOFF 0x13
using namespace std;
// variables used with the com port
BOOL bPortReady;
DCB dcb;
COMMTIMEOUTS CommTimeouts;
BOOL bWriteRC;
BOOL bReadRC;
DWORD iBytesWritten;
DWORD iBytesRead;

HANDLE SerialInit(char *ComPortName, int BaudRate)
{
HANDLE hCom;

hCom = CreateFile(ComPortName,
GENERIC_READ | GENERIC_WRITE,
0, // exclusive access
NULL, // no security
OPEN_EXISTING,
0, // no overlapped I/O
NULL); // null template

bPortReady = SetupComm(hCom, 2, 128); // set buffer sizes


bPortReady = GetCommState(hCom, &dcb);
dcb.BaudRate = BaudRate;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
// dcb.Parity = EVENPARITY;
dcb.StopBits = ONESTOPBIT;
dcb.fAbortOnError = TRUE;

// set XON/XOFF
dcb.fOutX = FALSE; // XON/XOFF off for transmit
dcb.fInX = FALSE; // XON/XOFF off for receive
// set RTSCTS
dcb.fOutxCtsFlow = TRUE; // turn on CTS flow control
dcb.fRtsControl = RTS_CONTROL_HANDSHAKE; //
// set DSRDTR
dcb.fOutxDsrFlow = FALSE; // turn on DSR flow control
dcb.fDtrControl = DTR_CONTROL_ENABLE; //
// dcb.fDtrControl = DTR_CONTROL_DISABLE; //
// dcb.fDtrControl = DTR_CONTROL_HANDSHAKE; //

bPortReady = SetCommState(hCom, &dcb);

// Communication timeouts are optional

bPortReady = GetCommTimeouts (hCom, &CommTimeouts);

CommTimeouts.ReadIntervalTimeout = 5000;
CommTimeouts.ReadTotalTimeoutConstant = 5000;
CommTimeouts.ReadTotalTimeoutMultiplier = 1000;
CommTimeouts.WriteTotalTimeoutConstant = 5000;
CommTimeouts.WriteTotalTimeoutMultiplier = 1000;

bPortReady = SetCommTimeouts (hCom, &CommTimeouts);

return hCom;
}

char SerialGetc(HANDLE *hCom)
{
char rxchar;
BOOL bReadRC;
static DWORD iBytesRead;

bReadRC = ReadFile(*hCom, &rxchar, 1, &iBytesRead, NULL);

return rxchar;
}

void SerialPutc(HANDLE *hCom, char txchar)
{
BOOL bWriteRC;
static DWORD iBytesWritten;

bWriteRC = WriteFile(*hCom, &txchar, 1, &iBytesWritten,NULL);

return;
}

int main()
{
HANDLE my=SerialInit("com1",1200);
char letter;

HANDLE *ptr;
*ptr=my;
SerialPutc(ptr,'a');
//letter=SerialGetc(ptr);
getch();

return 0;

}
[s]

Yes, you can use oscilloscopes to check the output. You can also use led's. Add some delays and see the variations. Before interfacing your ports with any hardware device make sure you protect your port from back currents.

PS: Use code tags from next time

The simplest way to is connect your PC back to back with another PC using a null modem cable (see http://www.nullmodem.com/NullModem.htm) – in fact if you switch off all handshaking you can just cross pins 2 and 3. run Hyperterm or TerraTerm on the other PC to check your output.

You program works OK sending and receiving characters – the version below acts as a simple terminal – characters typed on keyboard are transmitted over serial line and characters received are displayed

I believe the solution yuou seek is to use a "loop back" connector... they are used when testing the serial port and would be the quickest way to test.

If you really must use a CRO, make sure you can store the waveform.. simple way to determine the time is to:
1/baud * (databits + stopbits )

to give you the approximate time the data will be present on the TX pin.