Pins

Pins are building blocks of Ports. Pins can be thought of gates of components as they are the most primitive type for data transfer inside and outside the components. There are two types of pins: Outpin and Inpin. The data flows from inside of the components to its outside through Outpin while data flow from outside of the components to its inside through Inpin.

Connection and Disconnection of Pins

In Jusdl, signal flow modelling approach is adopted(see Modeling and Simulation for more information on modelling approach in Jusdl). In this approach, the components drive each other and data flow is unidirectional. The unidirectional data movement is carried out though the Links. A Link connects Outpins to Inpins, and the data flow is from Outpin to Inpin.

For example, let us construct and Outpin and Inpins and connect the together.

julia> using Jusdl # hide

julia> op = Outpin()
Outpin(eltype:Float64, isbound:false)

julia> ip = Inpin()
Inpin(eltype:Float64, isbound:false)

julia> link = connect(op, ip)
Link(state:open, eltype:Float64, isreadable:false, iswritable:false)

Note connect(op, ip) connects op and ip through a Link can return the constructed link. The connection of pins can be monitored.

julia> isconnected(op, ip)
true

The constructed link can be accessed though the pins.

julia> op.links[1] === link
true

julia> ip.link === link
true

The connected links Outpin and Inpin can be disconnected using disconnect function. When disconnected, the data transfer from the Outpin to Inpin is not possible.

Data Flow Through Pins

The data flow from an Outpin to an Inpin. However for data flow through a pin, a running task must be bound the channel of the link of the pin. See the example below.

julia> t = @async while true
           take!(ip) === NaN && break
       end
Task (runnable) @0x00007fa670d73a90

As the task t is bound the channel of the link data can flow through op and ip.

julia> put!(op, 1.)

julia> put!(op, 2.)

julia> put!(op, 3.)

Note that t is a taker job. As the taker job t takes data from op, we were able to put values into op. The converse is also possible.

julia> op2, ip2  = Outpin(), Inpin()
(Outpin(eltype:Float64, isbound:false), Inpin(eltype:Float64, isbound:false))

julia> link2 = connect(op2, ip2)
Link(state:open, eltype:Float64, isreadable:false, iswritable:false)

julia> t2 = @async for item in 1 : 5
           put!(op2, item)
       end
Task (runnable) @0x00007fa674c10760

julia> take!(ip2)
1.0

julia> take!(ip2)
2.0

Note that in both of the cases given above the data flow is always from an Outpin to an Inpin.

Full API

AbstractPin{T}

Inpin{T}()

Outpin{T}()

connect(outpin::Link, inpin::Link)

connect(outpin::AbstractVector{<:Link}, inpin::AbstractVector{<:Link})

julia> op, ip = Outpin(), Inpin();

julia> l = connect(op, ip)
Link(state:open, eltype:Float64, isreadable:false, iswritable:false)

julia> l in op.links
true

julia> ip.link === l
true

disconnect(link1::Link, link2::Link)

isbound(pin::AbstractPin)

isconnected(link1, link2)

UnconnectedLinkError <: Exception

bind(link::Link, pin)

eltype(pin::AbstractPin)

put!(pin::Outpin, val)

julia> op = Outpin();

julia> l = Link();

julia> bind(l, op);

julia> t = @async while true 
       val = take!(l) 
       val === NaN && break
       println("Took " * string(val))
       end;

julia> put!(op, 1.)
Took 1.0

julia> put!(op, 3.)
Took 3.0

julia> put!(op, NaN)

take!(pin::Inpin)

julia> ip = Inpin();

julia> l = Link();

julia> bind(l, ip);

julia> t = @async for item in 1 : 5 
       put!(l, item)
       end;

julia> take!(ip)
1.0

julia> take!(ip)
2.0