Newsgroup: it.comp.programmare.win32
Titolo: Seriali ad interrupt

Ciao a tutti,scusate se O.T. o argomento gia trattato,
non ho esperienza di programmazione Win32, ma volevo realizzare un programma
che elabora dei dati, comunicando con le porte seriali.
Il sistema attuale, esegue un vecchio programma scritto in linguaggio C (di
cui non ho il sorgente)sotto DOS.
Vorrei riscrivere il programma per migliorarne l'aspetto grafico ed
utilizzare il mouse al posto della tastiera.
Il problema riguarda le porte RS232 alle quali e'collegata un'
apparecchiatura che puo' inviare messaggi di comunicazione in momenti non
stabiliti e senza caratteri di controllo. Inoltre il collegamento tra la
seriale del PC e l'apparecchiatura ,dispone di soli 3 fili e non utilizza
quindi segnali di controllo.
Per questo motivo e' stato necessario costruire una routine di gestione ad
interrupt per non perdere i caratteri ricevuti.
E' possibile creare un programma Win32 per Windows98,utilizzando le API per
la gestione delle seriali o e' necessario costruire una routine a basso
livello?.
Windows gestisce le seriali ad interrupt con un proprio buffer?
Grazie.


wrote:



Ti ringrazio per la rapida risposta, anche se del codice non ho visto
traccia.
Ciao.


wrote:


visto che come allegato NON si posta 
-----------------------
ecco il .cpp
----------------------
// SerialPort.cpp: implementation of the CSerialPort class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Ecos.h"
#include "SerialPort.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// C methods
//////////////////////////////////////////////////////////////////////
extern CSerialPort m_ArielTx;
extern CSerialPort m_ArielRx;
extern "C" int __cdecl TxToAriel(char *pStr, short dim) {	
		return(m_ArielTx.Write (pStr, dim));
}
/**********************************************************
Procedura:
Aspetta 100 ms
Pulisce il Buffer
Legge dalla seriale
se x 100 ms non riceve nulla il msg si considera terminato
************************************************************/
extern "C" unsigned long __cdecl RxFromAriel(char *pStr, short dim) {	
	BOOL ok;
	short rt, ret;
	char buf[200], bf[200];
	HANDLE hWait= NULL;
	LARGE_INTEGER start, cur, offset;
	offset.QuadPart = 50;
 
	ASSERT(AfxCheckMemory());
	WaitForSingleObject(hWait, 100);
	m_ArielRx.ClearBuffer(CSerialPort::RX);
 
	ok = QueryPerformanceCounter (&start);
	if (!ok) return(-1);	//Timer NOT supported
	*buf = '\0'; ret = 0;
	while ((start.QuadPart + offset.QuadPart) > cur.QuadPart) {
		rt = m_ArielRx.Read (bf, dim);
		if (rt == -1) break;	//Read Error
		else strncat(buf, bf, dim);
		ret += dim;
 
		QueryPerformanceCounter (&cur);
	}
 
	strcpy (pStr, buf);
	ASSERT(AfxCheckMemory());
	return(ret);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
short CSerialPort::TX = 0;
short CSerialPort::RX = 1;
short CSerialPort::BOTH = 2;
CSerialPort::CSerialPort()
{
	m_hPort = NULL;
	//CSerialPort::TX=0; CSerialPort::RX=1; CSerialPort::BOTH=2;
}
CSerialPort::~CSerialPort()
{
}
HANDLE CSerialPort::Open(char *strPort, long speed)
{	
	int err;
	DWORD dwErr;
	DCB dcb;
	COMMTIMEOUTS tmout;
	COMMPROP commprop;
 
	//m_strPort = strcpy(
	m_hPort = CreateFile( "COM1", 
GENERIC_READ|GENERIC_WRITE,
						0, NULL,
OPEN_EXISTING,
						0, NULL);
	if (m_hPort == INVALID_HANDLE_VALUE) {
		AfxMessageBox("FATAL: unable to Open COM1");
		return (NULL);
	}
	//Set Comm Base parameters
	err = GetCommState(m_hPort, &dcb);
	if (!err)	AfxMessageBox("unable to Get RS params");
	//cb.DCBlength = sizeof(dcb);
	dcb.BaudRate = speed;
	dcb.Parity = NOPARITY;
	dcb.ByteSize = 8;
	dcb.StopBits = ONESTOPBIT;	//TWOSTOPBITS;
	err = SetCommState(m_hPort, &dcb);
	if (!err) AfxMessageBox("unable to Set RS params");
	//Set Comm extended params. as buffer size
	//err = GetCommProperties(m_hPort, &commprop);
	//commprop.dwMaxRxQueue = 17;
	err = SetupComm(m_hPort, 400, 400);	//set input and output
buffers
	if (!err) dwErr = GetLastError();
	//PurgeComm( g_hnd, PURGE_TXABORT | PURGE_RXABORT |
	//				  PURGE_TXCLEAR |
PURGE_RXCLEAR ) ;
	//err = GetCommProperties(g_hnd, &commprop);
 
	//Set Comm Timeout for non blocking read and write	
	SetCommMask (m_hPort, EV_RXCHAR);
	GetCommTimeouts(m_hPort, &tmout);	
	tmout.ReadIntervalTimeout = MAXDWORD; 
	tmout.ReadTotalTimeoutMultiplier = 0;
	tmout.ReadTotalTimeoutConstant = 8;		//max timeout
is 8 ms
	tmout.WriteTotalTimeoutConstant = 2;	//max tm for write a a
char
	SetCommTimeouts(m_hPort, &tmout);
	return (m_hPort);
}
void CSerialPort::Close(void) {	
	if (m_hPort) {
		PurgeComm(m_hPort, PURGE_RXABORT | PURGE_RXCLEAR |
PURGE_TXABORT | PURGE_TXCLEAR);
		CloseHandle(m_hPort);
		m_hPort = NULL;
	}
}
unsigned long CSerialPort::Read(char *pStr, short dim) {
	unsigned long ulNum=0;	
	BOOL ret = ReadFile(m_hPort, pStr, dim, &ulNum, NULL);
	if (ret) 
		*(pStr+ulNum) = '\0';
	else {
		ulNum = -1;
		*pStr = '\0';
	}
	//Bac: da testare
	return (ulNum);
}
BOOL CSerialPort::Write(char *pStr, short dim) {
	unsigned long ulNum=0;	
	BOOL ret = WriteFile(m_hPort, pStr, dim, &ulNum, NULL);	
	return (ret);
}
BOOL CSerialPort::ClearBuffer(short type)
{
	BOOL ret = -1;
	if(type == CSerialPort::TX)
		ret = PurgeComm(m_hPort, PURGE_TXABORT |
PURGE_TXCLEAR);		
	else if(type == CSerialPort::RX)
		ret = PurgeComm(m_hPort, PURGE_RXABORT |
PURGE_RXCLEAR);		
	else if(type == CSerialPort::BOTH)
		ret = PurgeComm(m_hPort, PURGE_RXABORT | PURGE_RXCLEAR
| PURGE_TXABORT | PURGE_TXCLEAR);	
 
	return (ret);
}
------------------
ecco il .h
------------------
// SerialPort.h: interface for the CSerialPort class.
//
//////////////////////////////////////////////////////////////////////
#if
!defined(AFX_SERIALPORT_H__C5E55AD3_595B_11D6_BFEC_00E09828007C__INCLUDED_)
#define
AFX_SERIALPORT_H__C5E55AD3_595B_11D6_BFEC_00E09828007C__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CSerialPort  
{
private:
	char m_strPort[5];
	HANDLE m_hPort;
public:
	static short TX;
	static short RX;
	static short BOTH;
	BOOL ClearBuffer(short type);
	CSerialPort();
	virtual ~CSerialPort();
 
	HANDLE Open(char *strPort, long speed);
	void Close(void);	
	unsigned long CSerialPort::Read(char *pStr, short dim);
	BOOL CSerialPort::Write(char *pStr, short dim);
};
#endif //
!defined(AFX_SERIALPORT_H__C5E55AD3_595B_11D6_BFEC_00E09828007C__INCLUDED_)
--------------------

 
Se gli allegati "NON si postano" è perchè NON li si deve postare!
La prossima volta che devi mandare del codice (se non si tratta di 
poche righe di esempio) fallo via e-mail o posta un link.
-- 
Valter Minute
vmi...@inwind.it
 (the reply address of this message is invalid)

Ricevuto.
Grazie 100.

poche righe di esempio) fallo via e-mail o posta un link.
buono a sapersi, 
credevo cmq che pochi k erano accettati.
bye.
Carlo
-----