Add serial data received event handler to f# serial port reader - f#

Question

I am having simple read write instructions in f# to communicate between serial ports:
async {
do! port.AsyncWriteLineAsByte messange
let! response = port.AsyncReadLineAsByte()
return response
}
Where response is byte[] and method is simple as that:
member this.AsyncReadLineAsByte() : Async<byte[]> =
async {
let buffer_ref = ref (Array.zeroCreate<byte> this.ReadBufferSize)
let buffer = !buffer_ref
let! read_bytes = this.BaseStream.AsyncRead(buffer, 0, this.ReadBufferSize)
return buffer
}
And well it works, it sends and recives messages, there is one but in all this.
Reading responses shold be on event of some sort. I am new to F# but i tried something like:
async {
let data_recived_event = port.AsyncReadLineAsByte()
do! port.AsyncWriteLineAsByte messange
port.DataReceived.AddHandler(data_recived_event) // it says SerialDataReciveHandler is what he expects
let! response = ???
return response
}
But no luck, documentation is rather, for f# it just specify prototype and method construction not a practical usage. I need a event and a way to return that value , is there a way?
EDIT:
Ive been able to add event as serial port namespace has DataReceived.AddHandler event subscription.
So now it looks:
async {
let data_recived() =
async{
let! buffer = port.AsyncReadLineAsByte()
printfn "Response from event %A" buffer
// return buffer
} |> fun response -> Async.RunSynchronously(response)
port.DataReceived.AddHandler(fun _ _ -> data_recived())
do! port.AsyncWriteLineAsByte messange
let! response = port.AsyncReadLineAsByte()
return response
}
And it works, problem is still how to return such a value from event, if I do something like:
let data_recived() =
async{
let! buffer = port.AsyncReadLineAsByte()
printfn "Response from event %A" buffer
return buffer
} |> fun response -> Async.RunSynchronously(response)
port.DataReceived.AddHandler(fun _ _ -> response = data_recived())
Is says it expects uint and get bool

Answer 1

I'm not an expert on how serial ports work, but you can wait for an event inside async workflow using the Async.AwaitEvent operation. So, you could write something like this:
let writeAndRead () = async {
let port = new SerialPort("COM1")
port.Write("TEST")
let mutable finished = false
while not finished do
let! e = port.DataReceived |> Async.AwaitEvent
let data = port.ReadExisting()
printfn "GOT: %A" data
finished <- data.Contains("EOF") }
The only caveat here is that the DataReceived event might be triggered concurrently, while you are processing the received data in the body of the loop - and then you will miss the event. I'm not sure how serial ports work and whether this can actually happen, but it could lead to problems.
To address that, you could use the BlockingQueueAgent type from F# Async Extras. This would let you implement a queue of notifications - so the DataReceived handler would add notifications to the queue and you would then read them from the queue in the loop. I have not actually tested this, but I think something like this should work:
let writeAndRead () = async {
let queue = BlockingQueueAgent<_>(Int32.MaxValue)
let port = new SerialPort("COM1")
port.DataReceived.Add(fun e -> queue.Add(e))
port.Write("TEST")
let mutable finished = false
while not finished do
let! e = queue.AsyncGet()
let data = port.ReadExisting()
finished <- data.Contains("EOF") }
EDIT: Moved the queue event handler setup before writing any data to the port.