Newsgroup: it.comp.programmare.win32
Titolo: Lettura continua della Seriale

Ho implementato un software in MFC per dialogare tramite porta seriale
con un pic.
Il software funziona perfettamente, solo che vorrei aggiungere un
accorgimento:
visto che il pc adesso riceve dati dalla seriale solo in alcuni casi,
vorrei che il pc stasse sempre in ascolto sulla seriale senza
bloccarmi il programma e che mi visuallizzasse i dati sulla finestra
principale dove ho delle apposite box.
Ho fatto varie ricerche, sò che devo creare un nuovo thread con una
_beginthread o una CreateThread... ho provato in vari modi ... ma c'è
sempre qualcosa che nn và!
Qualcuno saprebbe spiegarmi come posso fare?
Oppure... qualcuno avrebbe qualke spezzone di codice da cui prendere
spunto e capire il funzionamento?
Oppure... qualcuno ha un'altra soluzione al mio problema?
Perfavore aiutatemi che ne ho un bisogno urgentissimo!
Grazie mille!



Ho implementato un software in MFC per dialogare tramite porta seriale
con un pic.
Il software funziona perfettamente, solo che vorrei aggiungere un
accorgimento:
visto che il pc adesso riceve dati dalla seriale solo in alcuni casi,
vorrei che il pc stasse sempre in ascolto sulla seriale senza
bloccarmi il programma e che mi visuallizzasse i dati sulla finestra
principale dove ho delle apposite box.
Ho fatto varie ricerche, sò che devo creare un nuovo thread con una
_beginthread o una CreteThread... ho provato in vari modi ... ma c'è


 wrote in message
news:aa669938.04081...@posting.google.com

Fatto salvo che dalle ricerche si siano gia' studiate le API,
dovresti 
p.es
. avere una variabile globale
CWinThread *p_MioThread;
per poi iniziare una catena con
((CBUTApp*)AfxGetApp())->p_MioThread =
AfxBeginThread(LeggiSeriale,h_hwnd,THREAD_PRIORITY_ABOVE_NORMAL);
in cui LeggiSeriale e' la proc. del thread
p. es., usando 
CEvent per_fine_LS come variabile controllo
volatile HANDLE h_seriale come Handle del file di comunicazione
allora un modello potrebbe essere
UINT LeggiSeriale(LPVOID pParam)
{
	COMSTAT CommStat;
	DWORD dwFlagsErrori;
	OVERLAPPED overlap = {0};
	DWORD nBytesRead;
	int b_Ris;
	int error_code;
 
	// per debugging preferisco avere il buffer a zero!
	ZeroMemory(inbuff,13);
	try
	{
		b_Ris =  ::ClearCommError(h_seriale, &dwFlagsErrori, &CommStat);
		if(dwFlagsErrori)
		{
			switch(dwFlagsErrori)
			{
				case CE_BREAK:
					break;
				case CE_FRAME:
					break;
				case CE_IOE:
					break;
				case CE_MODE:
					break;
				case CE_OVERRUN:
					break;
				case CE_RXOVER:
					break;
				case CE_RXPARITY:
					break;
				case CE_TXFULL:
					break;
				default:
			}
			return 0;
		};
		overlap.hEvent = (HANDLE) per_fine_LS;	
		if(overlap.hEvent==NULL)
			AfxMessageBox("CreateEvent ha fallito", MB_ICONERROR|MB_OK);
		if(!b_Ris||dwFlagsErrori)	throw 1;
		b_Ris = ::ReadFile(h_seriale,inbuff,13,&nBytesRead,&overlap);
		if(!b_Ris)
		{
			error_code = GetLastError();
			if(error_code==ERROR_IO_PENDING)
			{
				b_Ris = ::WaitForSingleObject(overlap.hEvent, INFINITE);
				if(b_Ris != WAIT_OBJECT_0)	throw 2;
				else
				{
					b_Ris = GetOverlappedResult(h_seriale, &overlap, &nBytesRead,
FALSE);
					if(!b_Ris)	throw 3;
					::ResetEvent(overlap.hEvent);// reinizializzazione per la prossima
lettura
				};
			}
			else	throw 4;
		}; // di if(!bRis)
	} // del try
 
	catch(int errore)
	{
		switch(errore)
		{
			case 1:
				{
					//JJ ClearCommError non a buon fine
				};
				break;
			case 2:
				{
					//JJ WAIT_OBJECT_0 non a buon termine");
				};
				break;
			case 3:
				{
					//JJ GetOverlappedResult non a buon termine");
				};
					break;	
		}; //JJ dello switch
		::PurgeComm(h_seriale, PURGE_RXABORT);
		::ResetEvent(overlap.hEvent);
	}; //JJ del catch
	//JJ se siamo qui allora si lavora a regime altrimenti si tentava di
uscire dalla scheda
	if(p_BCRwnd)
	    if(::IsWindow(p_BCRwnd->m_hWnd))
		p_BCRwnd->SendMessage(WM_IMPOSTABARCODE); //JJ Send e non Post per
avere il buffer inbuff non sovrascritto
		//JJ Creazione di un nuovo Thread per leggere la seriale
		((CBUTApp*)AfxGetApp())->p_MioThread =
AfxBeginThread(LeggiSeriale,AfxGetMainWnd(),THREAD_PRIORITY_ABOVE_NORMAL);
//JJ viene lanciato un thread per la nuova lettura
	return 0;
}
In pratica ogni lettura della seriale esce da un thread e ne crea un
altro.
Se si vuole si puo' forzare la chiusura del thread agendo su
per_fine_LS.
N.B. usa 
::PurgeComm(h_seriale_LS, PURGE_RXCLEAR);
 per riutilizzare il canale!!
Saluti
JJ
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Le righe seguenti per errore non sono state cancellate 
(ho ricavato in corsa il modello...) per cui non devono essere
considerate.
------------------------
//JJ se siamo qui allora si lavora a regime altrimenti si tentava di
uscire dalla scheda
	if(p_BCRwnd)
	    if(::IsWindow(p_BCRwnd->m_hWnd))
		p_BCRwnd->SendMessage(WM_IMPOSTABARCODE); //JJ Send e non Post per
avere il buffer inbuff non sovrascritto
 
------------------------
