Ciao a tutti. Mi sono un po' perso e avrei bisogno di essere reindirizzato sulla strada giusta.

Sto creando un applicativo che dialoga con uno strumento via seriale.
Tutto (piu' o meno) ok nell'invio dei dati.

Ecco i miei problemi :

1) dovrei sincronizzare invio e ricezione dei dati, ovvero aspettare che lo strumento risponda prima di inviare un nuovo comando. Al momento ho usato un buffer che viene messo false in fase di invio comendi e valorizzato true alla fine della ricezione. La routine che invia i dati ha un loop iniziale da cui esce solo se il flag e' true.

2) Con l'evento datatreceived dovrei attivare una procedura che elabora i dati ricevuti e fa alcune operazioni, tra le quali attivare o cambiare lo stato di alcuni controlli su una form (li trovate commentati nel codice qui sotto)

Per la lettura del buffer uso serialport.readexisting

Dopo aver ricevuto i dati (li salvo per debug su un file di testo e qui tutto ok) il sistema mi genera un errore. Credo sia dovuto al fatto che l'evento datareceived gira in un thread separato dal resto e si debbano usare i delgates, che pero' mi sono totalmente oscuri.

3) ho la sensazione che il buffer (impostato a 4096 bytes) non venga letto correttamente, infatti una lettura che dovrebbe essere almeno 2048 bytes (1024 word + 6 o 7 bytes di controllo) la rilevo lunga "solo" 1009 bytes.

A complicare il tutto c'e' che lo strumento non e' vicino a me, ma collegato ad un pc che posso controllare da remoto, impossibile quindi vedere il debug in reale se non vado fisicamente la'. Ho simulato con un altro pc, ma non e' la stessa cosa...

Grazie mille in anticipo a chiunque voglia darmi una dritta (anche link sono molto ben accetti) o qualunque tipo di suggerimento.

Max.
ecco alcune info sul codice che uso.

Imports system.io.ports
Module Module1
'porte com usate per le comunicazioni
Public WithEvents DeviceCom As New SerialPort
Public WithEvents ModbusCom As New SerialPort
Public Settaggi As New Settings ' classe contenente i settings applicativo
'array di valori per la scelta del voltaggio della lampada.
Public LampVoltages = New Integer() {0, 400, 410, 420, 430, 440, 450, 460, 470, 480, 490, 500, _
510, 520, 530, 540, 550, 560, 470, 580, 590, 600}
'contatore uso lampada
Public SparkCount As Integer = Settaggi.Leggi("SparkCount")
'array per la lista di Light Integration Period
Public Integration = New Integer() {100, 200, 300, 400}
'array con i 4 coefficienti di calibrazione strumento
Public Coef = New Double() {0, 0, 0, 0}
Public devicename As String = ""
Public model As String = ""
Public Serialno As String = ""
Public firmware As String = ""
Public fwdate As String = ""
'flag per sincronizzare attesa e ricezione dei dati
Public DatiRicevuti As Boolean = True
'flag per attivare il debug dei dati in arrivo dalla com
Public ComDebug As Boolean = True
Public BufferIN As String
Public TipoCalcolo As String = ""

Public Sub DeviceDatiRicevuti(ByVal sender As Object, _
ByVal e As SerialDataReceivedEventArgs) _
Handles DeviceCom.DataReceived
'evento scatenato alla ricezione dei dati.
BufferIN = DeviceCom.ReadExisting
ElaboraBuffer()
End Sub

Public Sub ElaboraBuffer()
Dim cmd As Byte 'codice del dato in arrivo
Dim lungh As Integer ' lunghezza della stringa dati (NON del buffer)
'genero una stringa per debug con i codici esa dei dati ricevuti
Dim y1 As String = String.Empty
For i As Integer = 1 To BufferIN.Length
y1 += Hex(Asc(BufferIN.Substring(i - 1, 1))) & " "
Next
'Messaggi.Info("Ricevuti dati: " & x.Length & " bytes " + vbCrLf + "Contenuto: " + y1)

If BufferIN.Substring(0, 2) = "SY" Then ' e' una risposta ad un comando
cmd = Asc(BufferIN.Substring(4, 1))
Dim lenbyteH As Integer = Hex(Asc(BufferIN.Substring(2, 1)))
Dim lenbyteL As Integer = Hex(Asc(BufferIN.Substring(3, 1)))
lungh = Convert.ToInt32(lenbyteH + lenbyteL, 16)
End If
ComLog("<--- " + BufferIN.Length.ToString + " Bytes. Hex: " + y1 + " Asc: " + BufferIN)
ComLog("<--- Tipo Dato: &H" + cmd.ToString)
ComLog("<--- Lunghezza: " + lungh.ToString)

Select Case cmd
Case &H4E ' NAK Errore comunicazione
'MainForm.stripinfo.Text = "Errore di comunicazione con il Device"
'MainForm.UpdatePicBox(MainForm.pbAlarm, 2)
ComLog("<--- Errore comunicazione")

Case &H76 'risposta con voltaggio lampada
Dim volt As Integer = Convert.ToInt32(BufferIN.Substring(55, 2), 16)
Settaggi.Update("lampvolt", volt)
'frmSettings.cblampVoltage.SelectedText = Convert.ToInt16(BufferIN.Substring(5, 2), 16)
'MainForm.stripinfo.Text = "Voltaggio lampada: " + volt.ToString
ComLog("<--- Voltaggio lampada: " + volt.ToString)

Case &H43 'coefficiente di calibrazione
Dim i As Byte = Convert.ToInt32(BufferIN.Substring(5, 1), 16)
Dim y As String = ""
For k As Byte = 0 To 15
y += Asc(BufferIN.Substring(6 + i, 1))
Next
ComLog("<--- Coeff(" + i.ToString + ")= " + y.ToString)
Coef(i) = Convert.ToDouble(y)

Settaggi.Update("coef" + (i + 1).ToString, Coef(i).ToString)

'TODO impostare e visualizzare coefficiente di correzione
i = Nothing
y = Nothing

Case &H49 'System Info
Dim dato1 As String = BufferIN.Substring(6, 11)
Dim dato2 As String = BufferIN.Substring(17, 5)
If Convert.ToInt32(BufferIN.Substring(5, 1)) = 0 Then
'pagina 0
'frmSettings.txtDevicename.Text = dato1
'frmSettings.txtdeviceserialno.Text = dato2
model = dato1
Serialno = dato2
ComLog("<--- Modello: " + dato1)
ComLog("<--- S/n : " + dato2)
ElseIf Convert.ToInt32(BufferIN.Substring(5, 1)) = 1 Then
'pagina 1
'frmSettings.txtdevicefw.Text = dato1
'frmSettings.txtdate.Text = dato2
firmware = dato1
fwdate = dato2
ComLog("<--- Firmware: " + dato1)
ComLog("<--- Date code: " + dato2)
End If

Case &H53 'Lettura spettro
ComLog("<--- Ricevuta lettura spettro " + BufferIN)
Select Case frmSettings.cbCalcoli.SelectedText
Case "ASTM 1017/56"
Dim valori(1024) As Integer
For i As Integer = 0 To BufferIN.Length - 1
valori(i) = Convert.ToInt32(BufferIN.Substring(i + 6, 1) + BufferIN.Substring(i + 7, 1), 16)
Next
Calcoli.ASTM1017_56(valori, frmSettings.tbdila.Text, frmSettings.tbspessore.Text)
Case Else
End Select
Case Else
If BufferIN.Substring(0, 2) = "UV" Then
'ho ricevuto una risposta al WhoAreYou
devicename = BufferIN
End If
End Select
DatiRicevuti = True
'frmSettings.CompilaCampi()
cmd = Nothing
lungh = Nothing
y1 = Nothing
End Sub

Public Sub ComLog(ByVal txt As String)
MainForm.UpdatePicBox(MainForm.pbOperation, 0)
If ComDebug = False Then Exit Sub
Dim RcvDataFile As System.IO.StreamWriter = System.IO.File.AppendText("ComLog.txt")
RcvDataFile.WriteLine("{0} - {1}", Now().ToString("dd/MM/yyyy hh.mm.ss"), txt)
RcvDataFile.Close()
RcvDataFile = Nothing
End Sub

Public Function Compensa(ByVal Wave As Integer) As Double
Dim C As Double = 0
C = Coef(3) * Wave ^ 3
C += Coef(2) * Wave ^ 2
C += Coef(1) * Wave
C += Coef(0)
End Function
End Module

Allora, innanzitutto benvenuto tra di noi.
Vediamo di risolvere un problema per volta.

La gestione della seriale non è cosa semplicissima in .NET poichè trattasi di ambiente multithreading, anche l'associare una risposta della seriale su un controllo Label di un form causa errori di Threading. Il mio consiglio è quello di impostare la proprietà CheckForIllegalCrossThreadCalls dell'oggetto principale a False così che (se non usi altre gestioni con delegates o multithreading su quell'oggetto) gli errori non vengono sollevati.
Prova intanto a risolvere così poi ci risentiamo per le successive problematiche, intanto studio un po' il tuo codice...
Saluti,
Alberto De Luca

Ok, allora risposta n. 2
La gestione dell'evento DataReceived è molto comoda se sai in anticipo quanti byte riceverai prima di dover elaborare la stringa ricevuta. Se il numero di Byte è sempre lo stesso (ovvero se chi ti risponde ti invia un numero di byte fisso) devi impostare la proprietà
DeviceCom.ReceivedBytesThreshold = x dove x è il numero di Byte che devono essere nel Buffer della seriale prima che ti venga scatenato l'evento DataReceived. Nel momento che l'evento è scatenato ciò che leggerai all'interno del buffer della seriale è "almeno" di quelle dimensioni. Chiaramente se il numero di byte risposti è inferiore l'evento non viene scatenato.
Se la stringa di risposta può essere di dimensioni variabili allora il discorso cambia, generalmente si esegue un loop sulla seriale finchè non si trova un carattere di terminazione riga, in questo caso per effettuare i test dovresti avere disponibile l'apparecchiatura. Se hai altri problemi sono qua...

Saluti,
Alberto De Luca

Innanzitutto grazie per il benvenuto.

Provo ad inserire CheckForIllegalCrossThreadCalls= false nella form di cui devo modificare i controlli. Ti faccio sapere se intanto funziona quello. (lo posso provare da remoto).

Domani dovrei poter collegare lo strumento direttamente al pc di sviluppo, cosi posso fare un debug accurato e non per tentativi come faccio ora.

Grazie per la disponibilita' e.. in bocca al lupo per l'analisi del mio codice. Preparati a dei bei mal di stomaco !!!

(sono agli inizi!)

Grazie.
Max

In merito alla tua risposta n. 2.

Teoricamente so cosa devo ricevere, nel senso che ad un comando corrisponde una risposta di lunghezza definita (o per lo meno prevedibile).

Se chiedo lo stato di un parametro la risposta e' di x bytes (dipende dal tipo di richiesta).

In definitiva posso fare cosi:

imposto il thresold della seriale al n. di bytes che mi aspetto, invio il comando e aspetto che arrivino i dati.

Onestaemente ci avevo pensato, ma mi sembrava un po' debole per il fatto che se un byte si perde sto li ad aspettare come un fesso.

...o no ?

intanto procedo.

Grazie.

Non preoccuparti per il mal di stomaco, ho il Maalox accanto al mouse...
Non è necessario che stai li ad aspettare che ti venga scatenato l'evento di datareceived. Un protocollo serio dovrebbe avere la possibilità di capire a quale richiesta corrisponde una risposta (in genere si usano degli id di messaggio) ma se chi ha sviluppato il firmware del macchinozzo non ha gestito questa evenienza, allora devi impostare tu un timeout per ogni richiesta allo scadere del quale decidi se re-inviare la richiesta oppure generare un'eccezione. Normalmente se la risposta non arriva perchè dall'altra parte nessuno riceve, viene generato un errore di Timeout direttamente dalla seriale, impostandone il valore dalla proprietà WriteTimeout (in fase di scrittura) o ReadTimeout (in fase di lettura). Fai attenzione ad usare questi timeout perchè potrebbero ingannarti. Il ReadTimeout entra in funzione quando richiami un metodo Readxxx non quando invii un comando alla seriale, in quel caso entra in funzione il WriteTimeout che, se entro quel tempo l'operazione di Write non è andata a buon fine ti viene generata un'eccezione.
Spero di esserti stato di aiuto.
Saluti,
Alberto De Luca.

Troppa grazia Messere...

Ti aggiorno.

Ho fatto delle prove e anche impostando nelle 2 form (main e settaggi) check ecc a false ottengo comunque un'eccezione.

In ogni caso, rispondendo ai tuoi post:

Le risposte del macchinozzo sono (tranne un caso specifico) ben definite, ne senso che, ad esempio:

Invio un comando del tipo

&H53 &H59 &H00 &H03 &H43 &H## &Hxx

sta ad indicare:
53 59 = comando in arrivo (iniziano tutti cosi)
00 03 = lunghezza del pacchetto che ti mando
43 = il cosice del comando vero e proprio
## = in questo caso e' un parametro associato al comando
xx = il checksum per verificare che tutto sia ok.

La risposta che ottengo e':

&H53 &H59 &H00 &H13 &H43 &H## [16 bytes] &Hxx

con la stessa logica indicata sopra.

Quindi facendo un parse so gia' che devo elaborare 16 bytes (&H13) che sono una risposta al comando &H43.

Il sistema di sincronia che ho "escogitato" funziona a dovere, infatti ieri ho ottenuto risultati apprezzabili.

Rimane il problema che, oltre a scrivere su file cio' che ricevo qualunque altra operazione genera eccezioni.

Nelle impostazioni della COM inserisco 2 parametri che non mi sono perfettamente chiari nel loro funzionamento:

handshake = RequestToSend
RTS = true

dovrei forse usare questi per gestire il sincronismo? ma come?

per ora ti ringrazio per la disponibilita'. Oggi pomeriggio o domani dovrei poter debuggare con il macchinozzo in linea, direi di non perdere altro tempo su cose empiriche e aspettare un debug serio.

Ti chiedo solo un'ultimo suggerimento.
L'applicazione e' fatta cosi:

una classe statica "Program" con la funzione Main() che inizializza tutta l'applicazione, una form principale, una form per la gestione dei parametri, alcune classi statiche di supporto (messaggi, comandi per il macchinozzo) ed un modulo (quello postato piu' sopra).
Non sono riucito a fare a meno di inserirlo per definire le variabili pubbliche (tipo la com) e le funzioni di gestione della seriale.

la classe program e' definita cosi:

Public Class Program
<STAThread()> _
Shared Sub Main()
...
End Sub

E' corretto tutto cio' ?

Grazie infinite.
Max.

>Il sistema di sincronia che ho "escogitato" funziona a dovere, infatti ieri ho ottenuto >risultati apprezzabili. Rimane il problema che, oltre a scrivere su file cio' che ricevo >qualunque altra operazione genera eccezioni.
Bene, quindi il tutto funziona a dovere da un punto di vista di protocollo ed in effetti è un protocollo "serio" Il problema di scrivere su file ciò che ricevi è dovuto al fatto che la porta seriale gira su un Thread diverso da quello dove gira il tuo oggetto che istanzia la porta seriale, essendo le stringhe dei tipi per riferimento come passi un riferimento da un thread (quello della seriale) all'altro (quello del form principale) il runtime di VB ti genera l'errore. Non sono molto sicuro che funzioni ma in altri casi del genere si utilizzava l'oggetto System.Text.StringBuilder che faceva da "ponte di stringhe" tra i due thread. Potresti provare a leggere la seriale in questo modo:

Dim MyBridge as New System.Text.StringBuilder
MyBridge.Append(SerialPort.Read....)
MyTextBox.Text = MyBridge.ToString

>handshake = RequestToSend
>RTS = true

Per questi due parametri la guida in linea di Visual Studio ti spiega perfettamente a cosa servono: ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.NETDEVFX.v20.it/cpref8/html/T_System_IO_Ports_Handshake.htm

>L'applicazione e' fatta cosi.....
>...E' corretto tutto cio' ?

In linea di massima è corretto, giusto gestire il Thread Principale come Static Thread, anche se la seriale l'avrei più volentieri istanziata sul form principale. Alcuni oggetti apartment-thread girano meglio se istanziati direttamente su un form. Caso mai potresti istanziare le seriali sul form principale e passarle per riferimento alla classe di gestione e settando a False la proprietà CheckForIllegalCross.... ecc... del Form principale.
Saluti,
Alberto De Luca

Per il problema di modificare lo stato di un controllo da un operazione asincrona, vi rimando il codice di un mio vecchio post, che pò aiutarvi.

'VB
Private Delegate Sub InvokeMiaFunzione()
Private mInvokeMiaFunzione As InvokeMiaFunzione

Private Sub MiaFunzione()
If Me.InvokeRequired Then
Me.Invoke(mInvokeMiaFunzione)
Else
'Qui si può modificare lo stato del controllo della form senza incorrere in nessun problema
End If
End Sub

Private Sub CostruttoreDellaClasse()
mInvokeMiaFunzione = AddressOf MiaFunzione
End Sub

'Chiamata da un processo asincrono
Private Sub ProcessoAsincrono()
MiaFunzione()
End Sub

'Chiamata da un processo sincrono
Private Sub ProcessoSincrono()
MiaFunzione()
End Sub

Grazie Rudy,

Avevo pensato infatti all'uso dei delgates, ma la domanda che mi faccio e' (vediamo se ho cpito):

creo una istanza della mia funzione come delegato della classe (esempio la calsse statica Program)

L'evento che viene attivato alla ricezione dei dati della seriale fa una invoke dele metodo "delegato".

In definitiva:

public static class Program
...
private delegate sub InvokeElaboraInputDaSeriale

private sub ElaboraInputDaSeriale
le operazioni che devo fare
end sub

end class

module1 (la com la definisco public in un modulo)
mInvokeElaboraInputDaSeriale = AddressOf InvokeElaboraInputDaSeriale

private sub EventoDatiRicevuti
InvokeElaboraInputDaSeriale
end sub


E' corretto?

Grazie...
Max

Per Rudy:

Ho fatto cosi', ma mi sono un po' perso.


nella mia Main Form:

Public Delegate Sub InvokeElaboraBuffer()
Private mInvokeElaboraBuffer As InvokeElaboraBuffer = AddressOf ElaboraBuffer

Public Sub ElaboraBuffer()
If Me.InvokeRequired Then
Me.Invoke(mInvokeElaboraBuffer)
End If
... ilmio codice ...
end sub

nem modulo "generico" che contiene la dichiarazione della seriale e dell'evento DataReceived

Public Sub DeviceDatiRicevuti(ByVal sender As Object, _
ByVal e As SerialDataReceivedEventArgs) _
Handles DeviceCom.DataReceived

BufferIN = DeviceCom.ReadExisting
MainForm.Invoke(MainForm.ElaboraBuffer)
End Sub

ma non e' corretto perche ottengo l'errore che nella riga

MainForm.Invoke(MainForm.ElaboraBuffer)

MainForm.ElaboraBuffer "L'espressione non genera un valore"

da che parte vado ??

Grazie.

Forse non ci siamo capiti bene.

L'oggetto "seriale" ti genera un evento DataReceived.
Quando tu intercetti questo DataRecevied se in un thread diverso da quello della form.

Questo comporta che se tu tenti di scrivere su un controllo della form i dati dal SerialDataReceivedEventArgs, ricevi un errore di CrossThread.

Quindi l'oggetto, il controllo che riceverà i dati dal evento, richiede di essere Invoke.

Questo può essere fatto chiamando la funzione:

Dim ControlloInCuiVuoiScrivere as TextBox

Public Sub ElaboraBuffer()
If ControlloInCuiVuoiScrivere.InvokeRequired Then
ControlloInCuiVuoiScrivere Invoke(mInvokeElaboraBuffer)
End If
'Qui puoi scrivere il codice che legge dal buffer senza incorrere in errori di CrossThread
ControlloInCuiVuoiScrivere.Text = DatiDalBuffer
end sub

Spero di avere reso il concetto. Comunque continua a seguirci che fra un pò di tempo pubblicherò un articolo che parla di come interagire fra un Nokia 6630 (con installato l'interprete Python) e un applicazione C# tramite Bluetooth ed userò proprio la seriale. Io in questo caso ho creato una classe che si occupa di ricevere i dati dalla seiale e li trasforma in una stringa. Quando ha ricevuto tutti i dati, genera un evento che è intercettato da una form, e traimte Invoke scrive la stringa in una textbox.

Ok, credo che adesso sia piu' chiaro (per me )
Il concetto del thread mi e' chiaro, non avevo capito bene cosa invocare (e come farlo).

Io pensavo di poter chiamare con Invoke l'intero metodo della form e fargli fare tranquillamente le operazioni che deve fare.

Mi ci scorno ancora un po', prima o poi ne esco

Grazie mille

Max.

Ciao a tutti sono nuovo...

scusami, so che la discussione a cui mi riferisco è molto vecchia... ma ho problemi simili, gestione con .net, di uno strumento tramite seriale...


Io non ho lo strumento con me, e ne ho realizzato un simulatore, tramite un altro programmino su VB. net

Passo i dati da un programma ad un altro con  una write

Li leggo tramite evento data received e poi un readexisting o un readbyte.

Il problema è che spesso mi capita che, anche se invio una stringa di 20 caratteri, l'evento data received di attiva alla ricezione di un numero minore di caratteri, ad esempio 5, o 6 o 15, è del tutto casuale... non riesco a gestire questo problema...

Purtroppo mi serve che tutti i dati arrivino insieme in un unico evento datareceived perchè devo poi fare una serie di if e select case, che si attiverebbero alla ricezione dei primi dati, generandomi tanti errori se la stringa non è completa...

Avete idea di come io possa risolvere?

Forse il problema è che uso una velocità di trasmissione molto elevata, 115200

E usando un adattatore seriale - usb, questo può essere più lento.... e quindi non riuscire a vedere sempre tutti i caratteri, dico male?

?