Nrthugu

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

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.