update device-collective readme

Add capabilities to Constructor

.gitignore

@@ -1,6 +1,7 @@
 # Created by .ignore support plugin (hsz.mobi)
 .idea/
 .gradle
+.kotlin
 
 *.iws
 *.iml
@@ -8,4 +9,7 @@
 
 out/
 build/
-!gradle-wrapper.jar
+
+!gradle-wrapper.jar
+
+/demo/device-collective/mapCache/

.space/CODEOWNERS

@@ -1 +0,0 @@
-./space/* "Project Admin"

CHANGELOG.md

@@ -3,6 +3,60 @@
 ## Unreleased
 
 ### Added
+- Value averaging plot extension
+- PLC4X bindings
+- Shortcuts to access all Controls devices in a magix network.
+- `DeviceClient` properly evaluates lifecycle and logs
+- `PeerConnection` API for direct device-device binary sharing
+
+### Changed
+- Constructor properties return `DeviceState` in order to be able to subscribe to them
+- Refactored ports. Now we have `AsynchronousPort` as well as `SynchronousPort`
+- `DeviceClient` now initializes property and action descriptors eagerly.
+- `DeviceHub` now works with `Name` instead of `NameToken`. Tree-like structure is made using `Path`. Device messages no longer have access to sub-devices.
+- Add some utility methods to ports. Synchronous port response could be now consumed as `Source`.
+
+### Deprecated
+
+### Removed
+
+### Fixed
+- Fix a problem with rsocket endpoint with no filter.
+
+### Security
+
+## 0.3.0 - 2024-03-04
+
+### Added
+
+- Device lifecycle message
+- Low-code constructor
+- Automatic description generation for spec properties (JVM only)
+
+### Changed
+
+- Property caching moved from core `Device` to the `CachingDevice`
+- `DeviceSpec` properties no explicitly pass property name to getters and setters.
+- `DeviceHub.respondHubMessage` now returns a list of messages to allow querying multiple devices. Device server also returns an array.
+- DataForge 0.8.0
+
+### Fixed
+
+- Property writing does not trigger change if logical state already is the same as value to be set.
+- Modbus-slave triggers only once for multi-register write.
+- Removed unnecessary scope in hub messageFlow
+
+## 0.2.2-dev-1 - 2023-09-24
+
+### Changed
+
+- updating logical state in `DeviceBase` is now protected and called `propertyChanged()`
+- `DeviceBase` tries to read property after write if the writer does not set the value.
+
+## 0.2.1 - 2023-09-24
+
+### Added
+
 - Core interfaces for building a device server
 - Magix service for binding controls devices (both as RPC client and server)
 - A plugin for Controls-kt device server on top of modbus-rtu/modbus-tcp protocols
@@ -20,13 +74,3 @@
 - A magix event loop implementation in Kotlin. Includes HTTP/SSE and RSocket routes.
 - Magix history database API
 - ZMQ client endpoint for Magix
-
-### Changed
-
-### Deprecated
-
-### Removed
-
-### Fixed
-
-### Security

README.md

@@ -1,5 +1,7 @@
 [![JetBrains Research](https://jb.gg/badges/research.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
 
+[![](https://maven.sciprog.center/api/badge/latest/kscience/space/kscience/controls-core-jvm?color=40c14a&name=repo.kotlin.link&prefix=v)](https://maven.sciprog.center/)
+
 # Controls.kt
 
 Controls.kt (former DataForge-control) is a data acquisition framework (work in progress). It is based on DataForge, a software framework for automated data processing.
@@ -42,6 +44,11 @@ Example view of a demo:
 ## Modules
 
 
+### [controls-constructor](controls-constructor)
+> A low-code constructor for composite devices simulation
+>
+> **Maturity**: PROTOTYPE
+
 ### [controls-core](controls-core)
 > Core interfaces for building a device server
 >
@@ -56,6 +63,10 @@ Example view of a demo:
 > - [ports](controls-core/src/commonMain/kotlin/space/kscience/controls/ports) : Working with asynchronous data sending and receiving raw byte arrays
 
 
+### [controls-jupyter](controls-jupyter)
+>
+> **Maturity**: EXPERIMENTAL
+
 ### [controls-magix](controls-magix)
 > Magix service for binding controls devices (both as RPC client and server)
 >
@@ -93,6 +104,11 @@ Automatically checks consistency.
 >
 > **Maturity**: EXPERIMENTAL
 
+### [controls-plc4x](controls-plc4x)
+> A plugin for Controls-kt device server on top of plc4x library
+>
+> **Maturity**: EXPERIMENTAL
+
 ### [controls-ports-ktor](controls-ports-ktor)
 > Implementation of byte ports on top os ktor-io asynchronous API
 >
@@ -113,6 +129,16 @@ Automatically checks consistency.
 >
 > **Maturity**: PROTOTYPE
 
+### [controls-vision](controls-vision)
+> Dashboard and visualization extensions for devices
+>
+> **Maturity**: PROTOTYPE
+
+### [controls-visualisation-compose](controls-visualisation-compose)
+> Visualisation extension using compose-multiplatform
+>
+> **Maturity**: PROTOTYPE
+
 ### [demo](demo)
 >
 > **Maturity**: EXPERIMENTAL
@@ -134,6 +160,14 @@ Automatically checks consistency.
 >
 > **Maturity**: EXPERIMENTAL
 
+### [demo/constructor](demo/constructor)
+>
+> **Maturity**: EXPERIMENTAL
+
+### [demo/device-collective](demo/device-collective)
+>
+> **Maturity**: EXPERIMENTAL
+
 ### [demo/echo](demo/echo)
 >
 > **Maturity**: EXPERIMENTAL
@@ -189,6 +223,11 @@ Automatically checks consistency.
 >
 > **Maturity**: PROTOTYPE
 
+### [magix/magix-utils](magix/magix-utils)
+> Common utilities and services for Magix endpoints.   
+>
+> **Maturity**: EXPERIMENTAL
+
 ### [magix/magix-zmq](magix/magix-zmq)
 > ZMQ client endpoint for Magix
 >

build.gradle.kts

@@ -1,4 +1,3 @@
-import space.kscience.gradle.isInDevelopment
 import space.kscience.gradle.useApache2Licence
 import space.kscience.gradle.useSPCTeam
 
@@ -6,32 +5,21 @@ plugins {
     id("space.kscience.gradle.project")
 }
 
-val dataforgeVersion: String by extra("0.6.2-dev-3")
-val ktorVersion: String by extra(space.kscience.gradle.KScienceVersions.ktorVersion)
-val rsocketVersion by extra("0.15.4")
-val xodusVersion by extra("2.0.1")
-
 allprojects {
     group = "space.kscience"
-    version = "0.2.0"
+    version = "0.4.0-dev-4"
     repositories{
-        maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
+        google()
     }
 }
 
 ksciencePublish {
-    pom("https://github.com/SciProgCentre/controls.kt") {
+    pom("https://github.com/SciProgCentre/controls-kt") {
         useApache2Licence()
         useSPCTeam()
     }
-    github("controls.kt", "SciProgCentre")
+    repository("spc","https://maven.sciprog.center/kscience")
-    space(
+    sonatype("https://oss.sonatype.org")
-        if (isInDevelopment) {
-            "https://maven.pkg.jetbrains.space/spc/p/sci/dev"
-        } else {
-            "https://maven.pkg.jetbrains.space/spc/p/sci/maven"
-        }
-    )
 }
 
 readme.readmeTemplate = file("docs/templates/README-TEMPLATE.md")

controls-constructor/README.md

@@ -0,0 +1,21 @@
+# Module controls-constructor
+
+A low-code constructor for composite devices simulation
+
+## Usage
+
+## Artifact:
+
+The Maven coordinates of this project are `space.kscience:controls-constructor:0.4.0-dev-4`.
+
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("space.kscience:controls-constructor:0.4.0-dev-4")
+}
+```

controls-constructor/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+    id("space.kscience.gradle.mpp")
+    `maven-publish`
+}
+
+description = """
+    A low-code constructor for composite devices simulation
+""".trimIndent()
+
+kscience{
+    jvm()
+    js()
+    useCoroutines()
+    useSerialization()
+    commonMain {
+        api(projects.controlsCore)
+    }
+
+    commonTest{
+        implementation(spclibs.logback.classic)
+    }
+}
+
+readme{
+    maturity = space.kscience.gradle.Maturity.PROTOTYPE
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/ConstructorElement.kt

@@ -0,0 +1,241 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.*
+import kotlinx.datetime.Instant
+import space.kscience.controls.api.Device
+import space.kscience.controls.manager.ClockManager
+import space.kscience.dataforge.context.ContextAware
+import space.kscience.dataforge.context.request
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * A binding that is used to describe device functionality
+ */
+public sealed interface ConstructorElement
+
+/**
+ * A binding that exposes device property as read-only state
+ */
+public class PropertyConstructorElement<T>(
+    public val device: Device,
+    public val propertyName: String,
+    public val state: DeviceState<T>,
+) : ConstructorElement
+
+/**
+ * A binding for independent state like a timer
+ */
+public class StateConstructorElement<T>(
+    public val state: DeviceState<T>,
+) : ConstructorElement
+
+public class ConnectionConstrucorElement(
+    public val reads: Collection<DeviceState<*>>,
+    public val writes: Collection<DeviceState<*>>,
+) : ConstructorElement
+
+public class ModelConstructorElement(
+    public val model: ModelConstructor,
+) : ConstructorElement
+
+
+public interface StateContainer : ContextAware, CoroutineScope {
+    public val constructorElements: Set<ConstructorElement>
+    public fun registerElement(constructorElement: ConstructorElement)
+    public fun unregisterElement(constructorElement: ConstructorElement)
+
+
+    /**
+     * Bind an action to a [DeviceState]. [onChange] block is performed on each state change
+     *
+     * Optionally provide [writes] - a set of states that this change affects.
+     */
+    public fun <T> DeviceState<T>.onNext(
+        writes: Collection<DeviceState<*>> = emptySet(),
+        reads: Collection<DeviceState<*>> = emptySet(),
+        onChange: suspend (T) -> Unit,
+    ): Job = valueFlow.onEach(onChange).launchIn(this@StateContainer).also {
+        registerElement(ConnectionConstrucorElement(reads + this, writes))
+    }
+
+    public fun <T> DeviceState<T>.onChange(
+        writes: Collection<DeviceState<*>> = emptySet(),
+        reads: Collection<DeviceState<*>> = emptySet(),
+        onChange: suspend (prev: T, next: T) -> Unit,
+    ): Job = valueFlow.runningFold(Pair(value, value)) { pair, next ->
+        Pair(pair.second, next)
+    }.onEach { pair ->
+        if (pair.first != pair.second) {
+            onChange(pair.first, pair.second)
+        }
+    }.launchIn(this@StateContainer).also {
+        registerElement(ConnectionConstrucorElement(reads + this, writes))
+    }
+}
+
+/**
+ * Register a [state] in this container. The state is not registered as a device property if [this] is a [DeviceConstructor]
+ */
+public fun <T, D : DeviceState<T>> StateContainer.registerState(state: D): D {
+    registerElement(StateConstructorElement(state))
+    return state
+}
+
+/**
+ * Create a register a [MutableDeviceState]
+ */
+public fun <T> StateContainer.stateOf(initialValue: T): MutableDeviceState<T> = registerState(
+    MutableDeviceState(initialValue)
+)
+
+public fun <T : ModelConstructor> StateContainer.model(model: T): T {
+    registerElement(ModelConstructorElement(model))
+    return model
+}
+
+/**
+ * Create and register a timer state.
+ */
+public fun StateContainer.timer(tick: Duration): TimerState =
+    registerState(TimerState(context.request(ClockManager), tick))
+
+/**
+ * Register a new timer and perform [block] on its change
+ */
+public fun StateContainer.onTimer(
+    tick: Duration,
+    writes: Collection<DeviceState<*>> = emptySet(),
+    reads: Collection<DeviceState<*>> = emptySet(),
+    block: suspend (prev: Instant, next: Instant) -> Unit,
+): Job = timer(tick).onChange(writes = writes, reads = reads, onChange = block)
+
+public enum class DefaultTimer(public val duration: Duration){
+    REALTIME(5.milliseconds),
+    VERY_FAST(10.milliseconds),
+    FAST(20.milliseconds),
+    MEDIUM(50.milliseconds),
+    SLOW(100.milliseconds),
+    VERY_SLOW(500.milliseconds),
+}
+
+/**
+ * Perform an action on default timer
+ */
+public fun StateContainer.onTimer(
+    defaultTimer: DefaultTimer = DefaultTimer.FAST,
+    writes: Collection<DeviceState<*>> = emptySet(),
+    reads: Collection<DeviceState<*>> = emptySet(),
+    block: suspend (prev: Instant, next: Instant) -> Unit,
+): Job = timer(defaultTimer.duration).onChange(writes = writes, reads = reads, onChange = block)
+//TODO implement timer pooling
+
+public fun <T, R> StateContainer.mapState(
+    origin: DeviceState<T>,
+    transformation: (T) -> R,
+): DeviceStateWithDependencies<R> = registerState(DeviceState.map(origin, transformation))
+
+
+public fun <T, R> StateContainer.flowState(
+    origin: DeviceState<T>,
+    initialValue: R,
+    transformation: suspend FlowCollector<R>.(T) -> Unit,
+): DeviceStateWithDependencies<R> {
+    val state = MutableDeviceState(initialValue)
+    origin.valueFlow.transform(transformation).onEach { state.value = it }.launchIn(this)
+    return registerState(state.withDependencies(setOf(origin)))
+}
+
+/**
+ * Create a new state by combining two existing ones
+ */
+public fun <T1, T2, R> StateContainer.combineState(
+    first: DeviceState<T1>,
+    second: DeviceState<T2>,
+    transformation: (T1, T2) -> R,
+): DeviceState<R> = registerState(DeviceState.combine(first, second, transformation))
+
+/**
+ * Create and start binding between [sourceState] and [targetState]. Changes made to [sourceState] are automatically
+ * transferred onto [targetState], but not vise versa.
+ *
+ * On resulting [Job] cancel the binding is unregistered
+ */
+public fun <T> StateContainer.bind(sourceState: DeviceState<T>, targetState: MutableDeviceState<T>): Job {
+    val descriptor = ConnectionConstrucorElement(setOf(sourceState), setOf(targetState))
+    registerElement(descriptor)
+    return sourceState.valueFlow.onEach {
+        targetState.value = it
+    }.launchIn(this).apply {
+        invokeOnCompletion {
+            unregisterElement(descriptor)
+        }
+    }
+}
+
+/**
+ * Create and start binding between [sourceState] and [targetState]. Changes made to [sourceState] are automatically
+ * transferred onto [targetState] via [transformation], but not vise versa.
+ *
+ * On resulting [Job] cancel the binding is unregistered
+ */
+public fun <T, R> StateContainer.transformTo(
+    sourceState: DeviceState<T>,
+    targetState: MutableDeviceState<R>,
+    transformation: suspend (T) -> R,
+): Job {
+    val descriptor = ConnectionConstrucorElement(setOf(sourceState), setOf(targetState))
+    registerElement(descriptor)
+    return sourceState.valueFlow.onEach {
+        targetState.value = transformation(it)
+    }.launchIn(this).apply {
+        invokeOnCompletion {
+            unregisterElement(descriptor)
+        }
+    }
+}
+
+/**
+ * Register [ConstructorElement] that combines values from [sourceState1] and [sourceState2] using [transformation].
+ *
+ * On resulting [Job] cancel the binding is unregistered
+ */
+public fun <T1, T2, R> StateContainer.combineTo(
+    sourceState1: DeviceState<T1>,
+    sourceState2: DeviceState<T2>,
+    targetState: MutableDeviceState<R>,
+    transformation: suspend (T1, T2) -> R,
+): Job {
+    val descriptor = ConnectionConstrucorElement(setOf(sourceState1, sourceState2), setOf(targetState))
+    registerElement(descriptor)
+    return kotlinx.coroutines.flow.combine(sourceState1.valueFlow, sourceState2.valueFlow, transformation).onEach {
+        targetState.value = it
+    }.launchIn(this).apply {
+        invokeOnCompletion {
+            unregisterElement(descriptor)
+        }
+    }
+}
+
+/**
+ * Register [ConstructorElement] that combines values from [sourceStates] using [transformation].
+ *
+ * On resulting [Job] cancel the binding is unregistered
+ */
+public inline fun <reified T, R> StateContainer.combineTo(
+    sourceStates: Collection<DeviceState<T>>,
+    targetState: MutableDeviceState<R>,
+    noinline transformation: suspend (Array<T>) -> R,
+): Job {
+    val descriptor = ConnectionConstrucorElement(sourceStates, setOf(targetState))
+    registerElement(descriptor)
+    return kotlinx.coroutines.flow.combine(sourceStates.map { it.valueFlow }, transformation).onEach {
+        targetState.value = it
+    }.launchIn(this).apply {
+        invokeOnCompletion {
+            unregisterElement(descriptor)
+        }
+    }
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/DeviceConstructor.kt

@@ -0,0 +1,150 @@
+package space.kscience.controls.constructor
+
+import space.kscience.controls.api.Device
+import space.kscience.controls.api.PropertyDescriptor
+import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.Factory
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaConverter
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.asName
+import kotlin.properties.PropertyDelegateProvider
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+import kotlin.time.Duration
+
+/**
+ * A base for strongly typed device constructor block. Has additional delegates for type-safe devices
+ */
+public abstract class DeviceConstructor(
+    context: Context,
+    meta: Meta = Meta.EMPTY,
+) : DeviceGroup(context, meta), StateContainer {
+    private val _constructorElements: MutableSet<ConstructorElement> = mutableSetOf()
+    override val constructorElements: Set<ConstructorElement> get() = _constructorElements
+
+    override fun registerElement(constructorElement: ConstructorElement) {
+        _constructorElements.add(constructorElement)
+    }
+
+    override fun unregisterElement(constructorElement: ConstructorElement) {
+        _constructorElements.remove(constructorElement)
+    }
+
+    override fun <T, S: DeviceState<T>> registerProperty(
+        converter: MetaConverter<T>,
+        descriptor: PropertyDescriptor,
+        state: S,
+    ): S {
+        val res = super.registerProperty(converter, descriptor, state)
+        registerElement(PropertyConstructorElement(this, descriptor.name, state))
+        return res
+    }
+}
+
+/**
+ * Register a device, provided by a given [factory] and
+ */
+public fun <D : Device> DeviceConstructor.device(
+    factory: Factory<D>,
+    meta: Meta? = null,
+    nameOverride: Name? = null,
+    metaLocation: Name? = null,
+): PropertyDelegateProvider<DeviceConstructor, ReadOnlyProperty<DeviceConstructor, D>> =
+    PropertyDelegateProvider { _: DeviceConstructor, property: KProperty<*> ->
+        val name = nameOverride ?: property.name.asName()
+        val device = install(name, factory, meta, metaLocation ?: name)
+        ReadOnlyProperty { _: DeviceConstructor, _ ->
+            device
+        }
+    }
+
+public fun <D : Device> DeviceConstructor.device(
+    device: D,
+    nameOverride: Name? = null,
+): PropertyDelegateProvider<DeviceConstructor, ReadOnlyProperty<DeviceConstructor, D>> =
+    PropertyDelegateProvider { _: DeviceConstructor, property: KProperty<*> ->
+        val name = nameOverride ?: property.name.asName()
+        install(name, device)
+        ReadOnlyProperty { _: DeviceConstructor, _ ->
+            device
+        }
+    }
+
+/**
+ * Register a property and provide a direct reader for it
+ */
+public fun <T, S : DeviceState<T>> DeviceConstructor.property(
+    converter: MetaConverter<T>,
+    state: S,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+    nameOverride: String? = null,
+): PropertyDelegateProvider<DeviceConstructor, ReadOnlyProperty<DeviceConstructor, S>> =
+    PropertyDelegateProvider { _: DeviceConstructor, property ->
+        val name = nameOverride ?: property.name
+        val descriptor = PropertyDescriptor(name).apply(descriptorBuilder)
+        registerProperty(converter, descriptor, state)
+        ReadOnlyProperty { _: DeviceConstructor, _ ->
+            state
+        }
+    }
+
+/**
+ * Register external state as a property
+ */
+public fun <T : Any> DeviceConstructor.property(
+    metaConverter: MetaConverter<T>,
+    reader: suspend () -> T,
+    readInterval: Duration,
+    initialState: T,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+    nameOverride: String? = null,
+): PropertyDelegateProvider<DeviceConstructor, ReadOnlyProperty<DeviceConstructor, DeviceState<T>>> = property(
+    metaConverter,
+    DeviceState.external(this, readInterval, initialState, reader),
+    descriptorBuilder,
+    nameOverride,
+)
+
+/**
+ * Create and register a mutable external state as a property
+ */
+public fun <T : Any> DeviceConstructor.mutableProperty(
+    metaConverter: MetaConverter<T>,
+    reader: suspend () -> T,
+    writer: suspend (T) -> Unit,
+    readInterval: Duration,
+    initialState: T,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+    nameOverride: String? = null,
+): PropertyDelegateProvider<DeviceConstructor, ReadOnlyProperty<DeviceConstructor, MutableDeviceState<T>>> = property(
+    metaConverter,
+    DeviceState.external(this, readInterval, initialState, reader, writer),
+    descriptorBuilder,
+    nameOverride,
+)
+
+/**
+ * Create and register a virtual mutable property with optional [callback]
+ */
+public fun <T> DeviceConstructor.virtualProperty(
+    metaConverter: MetaConverter<T>,
+    initialState: T,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+    nameOverride: String? = null,
+    callback: (T) -> Unit = {},
+): PropertyDelegateProvider<DeviceConstructor, ReadOnlyProperty<DeviceConstructor, MutableDeviceState<T>>> = property(
+    metaConverter,
+    MutableDeviceState(initialState, callback),
+    descriptorBuilder,
+    nameOverride,
+)
+
+public fun <T, S : DeviceState<T>> DeviceConstructor.registerAsProperty(
+    spec: DevicePropertySpec<*, T>,
+    state: S,
+): S {
+    registerProperty(spec.converter, spec.descriptor, state)
+    return state
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/DeviceGroup.kt

@@ -0,0 +1,318 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import space.kscience.controls.api.*
+import space.kscience.controls.api.DeviceLifecycleState.*
+import space.kscience.controls.manager.DeviceManager
+import space.kscience.controls.manager.install
+import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.dataforge.context.*
+import space.kscience.dataforge.meta.Laminate
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaConverter
+import space.kscience.dataforge.meta.MutableMeta
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.get
+import space.kscience.dataforge.names.parseAsName
+import kotlin.collections.set
+import kotlin.coroutines.CoroutineContext
+
+
+/**
+ * A mutable group of devices and properties to be used for lightweight design and simulations.
+ */
+public open class DeviceGroup(
+    final override val context: Context,
+    override val meta: Meta,
+) : DeviceHub, CachingDevice {
+
+    private class Property<T>(
+        val state: DeviceState<T>,
+        val converter: MetaConverter<T>,
+        val descriptor: PropertyDescriptor,
+    ) {
+        val valueAsMeta get() = converter.convert(state.value)
+
+        fun setMeta(meta: Meta) {
+            check(state is MutableDeviceState) { "Can't write to read-only property" }
+
+            state.value = converter.read(meta)
+        }
+    }
+
+    private class Action<T, R>(
+        val inputConverter: MetaConverter<T>,
+        val outputConverter: MetaConverter<R>,
+        val descriptor: ActionDescriptor,
+        val action: suspend (T) -> R,
+    ) {
+        suspend operator fun invoke(argument: Meta?): Meta? = argument?.let { inputConverter.readOrNull(it) }
+            ?.let { action(it)?.let { outputConverter.convert(it) } }
+    }
+
+
+    private val sharedMessageFlow = MutableSharedFlow<DeviceMessage>()
+
+    override val messageFlow: Flow<DeviceMessage>
+        get() = sharedMessageFlow
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override val coroutineContext: CoroutineContext = context.newCoroutineContext(
+        SupervisorJob(context.coroutineContext[Job]) +
+                CoroutineName("Device $id") +
+                CoroutineExceptionHandler { _, throwable ->
+                    context.launch {
+                        sharedMessageFlow.emit(
+                            DeviceErrorMessage(
+                                errorMessage = throwable.message,
+                                errorType = throwable::class.simpleName,
+                                errorStackTrace = throwable.stackTraceToString()
+                            )
+                        )
+                    }
+                    logger.error(throwable) { "Exception in device $id" }
+                }
+    )
+
+
+    private val _devices = hashMapOf<Name, Device>()
+
+    override val devices: Map<Name, Device> = _devices
+
+    /**
+     * Register and initialize (synchronize child's lifecycle state with group state) a new device in this group
+     */
+    @OptIn(DFExperimental::class)
+    public open fun <D : Device> install(token: Name, device: D): D {
+        require(_devices[token] == null) { "A child device with name $token already exists" }
+        //start the child device if needed
+        if (lifecycleState == STARTED || lifecycleState == STARTING) launch { device.start() }
+        _devices[token] = device
+        return device
+    }
+
+    private val properties: MutableMap<Name, Property<*>> = hashMapOf()
+
+    /**
+     * Register a new property based on [DeviceState]. Properties could be modified dynamically
+     */
+    public open fun <T, S : DeviceState<T>> registerProperty(
+        converter: MetaConverter<T>,
+        descriptor: PropertyDescriptor,
+        state: S,
+    ): S {
+        val name = descriptor.name.parseAsName()
+        require(properties[name] == null) { "Can't add property with name $name. It already exists." }
+        properties[name] = Property(state, converter, descriptor)
+        state.valueFlow.map(converter::convert).onEach {
+            sharedMessageFlow.emit(
+                PropertyChangedMessage(
+                    descriptor.name,
+                    it
+                )
+            )
+        }.launchIn(this)
+        return state
+    }
+
+    private val actions: MutableMap<Name, Action<*, *>> = hashMapOf()
+
+    public fun <T, R> registerAction(
+        inputConverter: MetaConverter<T>,
+        outputConverter: MetaConverter<R>,
+        descriptor: ActionDescriptor,
+        action: suspend (T) -> R,
+    ): suspend (T) -> R {
+        val name = descriptor.name.parseAsName()
+        require(actions[name] == null) { "Can't add action with name $name. It already exists." }
+        actions[name] = Action(
+            inputConverter = inputConverter,
+            outputConverter = outputConverter,
+            descriptor = descriptor,
+            action = action
+        )
+        return {
+            action(it)
+        }
+    }
+
+    override val propertyDescriptors: Collection<PropertyDescriptor>
+        get() = properties.values.map { it.descriptor }
+
+    override val actionDescriptors: Collection<ActionDescriptor>
+        get() = actions.values.map { it.descriptor }
+
+    override suspend fun readProperty(propertyName: String): Meta =
+        properties[propertyName.parseAsName()]?.valueAsMeta
+            ?: error("Property with name $propertyName not found")
+
+    override fun getProperty(propertyName: String): Meta? = properties[propertyName.parseAsName()]?.valueAsMeta
+
+    override suspend fun invalidate(propertyName: String) {
+        //does nothing for this implementation
+    }
+
+    override suspend fun writeProperty(propertyName: String, value: Meta) {
+        val property = properties[propertyName.parseAsName()] ?: error("Property with name $propertyName not found")
+        property.setMeta(value)
+    }
+
+
+    override suspend fun execute(actionName: String, argument: Meta?): Meta? {
+        val action: Action<*, *> = actions[actionName] ?: error("Action with name $actionName not found")
+        return action(argument)
+    }
+
+    final override var lifecycleState: DeviceLifecycleState = DeviceLifecycleState.STOPPED
+        private set
+
+
+    private suspend fun setLifecycleState(lifecycleState: DeviceLifecycleState) {
+        this.lifecycleState = lifecycleState
+        sharedMessageFlow.emit(
+            DeviceLifeCycleMessage(lifecycleState)
+        )
+    }
+
+
+    override suspend fun start() {
+        setLifecycleState(STARTING)
+        super.start()
+        devices.values.forEach {
+            it.start()
+        }
+        setLifecycleState(STARTED)
+    }
+
+    override suspend fun stop() {
+        devices.values.forEach {
+            it.stop()
+        }
+        setLifecycleState(STOPPED)
+        super.stop()
+    }
+
+    public companion object {
+
+    }
+}
+
+public fun <T> DeviceGroup.registerAsProperty(propertySpec: DevicePropertySpec<*, T>, state: DeviceState<T>) {
+    registerProperty(propertySpec.converter, propertySpec.descriptor, state)
+}
+
+public fun DeviceManager.registerDeviceGroup(
+    name: String = "@group",
+    meta: Meta = Meta.EMPTY,
+    block: DeviceGroup.() -> Unit,
+): DeviceGroup {
+    val group = DeviceGroup(context, meta).apply(block)
+    install(name, group)
+    return group
+}
+
+public fun Context.registerDeviceGroup(
+    name: String = "@group",
+    meta: Meta = Meta.EMPTY,
+    block: DeviceGroup.() -> Unit,
+): DeviceGroup = request(DeviceManager).registerDeviceGroup(name, meta, block)
+
+///**
+// * Register a device at given [path] path
+// */
+//public fun <D : Device> DeviceGroup.install(path: Path, device: D): D {
+//    return when (path.length) {
+//        0 -> error("Can't use empty path for a child device")
+//        1 -> install(path.first().name, device)
+//        else -> getOrCreateGroup(path.cutLast()).install(path.tokens.last(), device)
+//    }
+//}
+
+public fun <D : Device> DeviceGroup.install(name: String, device: D): D = install(name.parseAsName(), device)
+
+public fun <D : Device> DeviceGroup.install(device: D): D = install(device.id, device)
+
+/**
+ * Add a device creating intermediate groups if necessary. If device with given [name] already exists, throws an error.
+ * @param name the name of the device in the group
+ * @param factory a factory used to create a device
+ * @param deviceMeta meta override for this specific device
+ * @param metaLocation location of the template meta in parent group meta
+ */
+public fun <D : Device> DeviceGroup.install(
+    name: Name,
+    factory: Factory<D>,
+    deviceMeta: Meta? = null,
+    metaLocation: Name = name,
+): D {
+    val newDevice = factory.build(context, Laminate(deviceMeta, meta[metaLocation]))
+    install(name, newDevice)
+    return newDevice
+}
+
+public fun <D : Device> DeviceGroup.install(
+    name: String,
+    factory: Factory<D>,
+    metaLocation: Name = name.parseAsName(),
+    metaBuilder: (MutableMeta.() -> Unit)? = null,
+): D = install(name.parseAsName(), factory, metaBuilder?.let { Meta(it) }, metaLocation)
+
+/**
+ * Create or edit a group with a given [name].
+ */
+public fun DeviceGroup.registerDeviceGroup(name: Name, block: DeviceGroup.() -> Unit): DeviceGroup =
+    install(name, DeviceGroup(context, meta).apply(block))
+
+public fun DeviceGroup.registerDeviceGroup(name: String, block: DeviceGroup.() -> Unit): DeviceGroup =
+    registerDeviceGroup(name.parseAsName(), block)
+
+/**
+ * Register read-only property based on [state]
+ */
+public fun <T : Any> DeviceGroup.registerAsProperty(
+    name: String,
+    converter: MetaConverter<T>,
+    state: DeviceState<T>,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+) {
+    registerProperty(
+        converter,
+        PropertyDescriptor(name).apply(descriptorBuilder),
+        state
+    )
+}
+
+/**
+ * Register a mutable property based on mutable [state]
+ */
+public fun <T : Any> DeviceGroup.registerMutableProperty(
+    name: String,
+    converter: MetaConverter<T>,
+    state: MutableDeviceState<T>,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+) {
+    registerProperty(
+        converter,
+        PropertyDescriptor(name).apply(descriptorBuilder),
+        state
+    )
+}
+
+
+/**
+ * Create a new virtual mutable state and a property based on it.
+ * @return the mutable state used in property
+ */
+public fun <T : Any> DeviceGroup.registerVirtualProperty(
+    name: String,
+    initialValue: T,
+    converter: MetaConverter<T>,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+    callback: (T) -> Unit = {},
+): MutableDeviceState<T> {
+    val state = MutableDeviceState<T>(initialValue, callback)
+    registerMutableProperty(name, converter, state, descriptorBuilder)
+    return state
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/DeviceState.kt

@@ -0,0 +1,103 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.UnitsOfMeasurement
+import kotlin.reflect.KProperty
+
+/**
+ * An observable state of a device
+ */
+public interface DeviceState<out T> {
+    public val value: T
+
+    public val valueFlow: Flow<T>
+
+    override fun toString(): String
+
+    public companion object
+}
+
+
+public operator fun <T> DeviceState<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value
+
+/**
+ * Collect values in a given [scope]
+ */
+public fun <T> DeviceState<T>.collectValuesIn(scope: CoroutineScope, block: suspend (T) -> Unit): Job =
+    valueFlow.onEach(block).launchIn(scope)
+
+/**
+ * A mutable state of a device
+ */
+public interface MutableDeviceState<T> : DeviceState<T> {
+    override var value: T
+}
+
+public operator fun <T> MutableDeviceState<T>.setValue(thisRef: Any?, property: KProperty<*>, value: T) {
+    this.value = value
+}
+
+/**
+ * Device state with a value that depends on other device states
+ */
+public interface DeviceStateWithDependencies<T> : DeviceState<T> {
+    public val dependencies: Collection<DeviceState<*>>
+}
+
+public fun <T> DeviceState<T>.withDependencies(
+    dependencies: Collection<DeviceState<*>>,
+): DeviceStateWithDependencies<T> = object : DeviceStateWithDependencies<T>, DeviceState<T> by this {
+    override val dependencies: Collection<DeviceState<*>> = dependencies
+}
+
+/**
+ * Create a new read-only [DeviceState] that mirrors receiver state by mapping the value with [mapper].
+ */
+public fun <T, R> DeviceState.Companion.map(
+    state: DeviceState<T>,
+    mapper: (T) -> R,
+): DeviceStateWithDependencies<R> = object : DeviceStateWithDependencies<R> {
+    override val dependencies = listOf(state)
+
+    override val value: R get() = mapper(state.value)
+
+    override val valueFlow: Flow<R> = state.valueFlow.map(mapper)
+
+    override fun toString(): String = "DeviceState.map(state=${state})"
+}
+
+public fun <T, R> DeviceState<T>.map(mapper: (T) -> R): DeviceStateWithDependencies<R> = DeviceState.map(this, mapper)
+
+public fun DeviceState<NumericalValue<out UnitsOfMeasurement>>.values(): DeviceState<Double> =
+    object : DeviceState<Double> {
+        override val value: Double
+            get() = this@values.value.value
+
+        override val valueFlow: Flow<Double>
+            get() = this@values.valueFlow.map { it.value }
+
+        override fun toString(): String = this@values.toString()
+    }
+
+/**
+ * Combine two device states into one read-only [DeviceState]. Only the latest value of each state is used.
+ */
+public fun <T1, T2, R> DeviceState.Companion.combine(
+    state1: DeviceState<T1>,
+    state2: DeviceState<T2>,
+    mapper: (T1, T2) -> R,
+): DeviceStateWithDependencies<R> = object : DeviceStateWithDependencies<R> {
+    override val dependencies = listOf(state1, state2)
+
+    override val value: R get() = mapper(state1.value, state2.value)
+
+    override val valueFlow: Flow<R> = kotlinx.coroutines.flow.combine(state1.valueFlow, state2.valueFlow, mapper)
+
+    override fun toString(): String = "DeviceState.combine(state1=$state1, state2=$state2)"
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/ModelConstructor.kt

@@ -0,0 +1,33 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.newCoroutineContext
+import space.kscience.dataforge.context.Context
+import kotlin.coroutines.CoroutineContext
+
+public abstract class ModelConstructor(
+    final override val context: Context,
+    vararg dependencies: DeviceState<*>,
+) : StateContainer, CoroutineScope {
+
+    @OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+    override val coroutineContext: CoroutineContext = context.newCoroutineContext(SupervisorJob())
+
+
+    private val _constructorElements: MutableSet<ConstructorElement> = mutableSetOf<ConstructorElement>().apply {
+        dependencies.forEach {
+            add(StateConstructorElement(it))
+        }
+    }
+
+    override val constructorElements: Set<ConstructorElement> get() = _constructorElements
+
+    override fun registerElement(constructorElement: ConstructorElement) {
+        _constructorElements.add(constructorElement)
+    }
+
+    override fun unregisterElement(constructorElement: ConstructorElement) {
+        _constructorElements.remove(constructorElement)
+    }
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/TimerState.kt

@@ -0,0 +1,39 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.datetime.Instant
+import space.kscience.controls.manager.ClockManager
+import kotlin.time.Duration
+
+/**
+ * A dedicated [DeviceState] that operates with time.
+ * The state changes with [tick] interval and always shows the time of the last update.
+ *
+ * Both [tick] and current time are computed by [clockManager] enabling time manipulation.
+ *
+ * The timer runs indefinitely until the parent context is closed
+ */
+public class TimerState(
+    public val clockManager: ClockManager,
+    public val tick: Duration,
+) : DeviceState<Instant> {
+
+    private val clock = MutableStateFlow(clockManager.clock.now())
+
+    private val updateJob = clockManager.context.launch(clockManager.asDispatcher()) {
+        while (isActive) {
+            delay(tick)
+            clock.value = clockManager.clock.now()
+        }
+    }
+
+    override val valueFlow: Flow<Instant> get() = clock
+
+    override val value: Instant get() = clock.value
+
+    override fun toString(): String = "TimerState(tick=$tick)"
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/boundState.kt

@@ -0,0 +1,103 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import space.kscience.controls.api.Device
+import space.kscience.controls.api.PropertyChangedMessage
+import space.kscience.controls.api.id
+import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.controls.spec.MutableDevicePropertySpec
+import space.kscience.controls.spec.name
+import space.kscience.dataforge.meta.MetaConverter
+
+
+/**
+ * A copy-free [DeviceState] bound to a device property
+ */
+private open class BoundDeviceState<T>(
+    val converter: MetaConverter<T>,
+    val device: Device,
+    val propertyName: String,
+    initialValue: T,
+) : DeviceState<T> {
+
+    override val valueFlow: StateFlow<T> = device.messageFlow.filterIsInstance<PropertyChangedMessage>().filter {
+        it.property == propertyName
+    }.mapNotNull {
+        converter.read(it.value)
+    }.stateIn(device.context, SharingStarted.Eagerly, initialValue)
+
+    override val value: T get() = valueFlow.value
+    override fun toString(): String =
+        "BoundDeviceState(converter=$converter, device=${device.id}, propertyName='$propertyName')"
+
+
+}
+
+public fun <T> Device.propertyAsState(
+    propertyName: String,
+    metaConverter: MetaConverter<T>,
+    initialValue: T,
+): DeviceState<T> = BoundDeviceState(metaConverter, this, propertyName, initialValue)
+
+/**
+ * Bind a read-only [DeviceState] to a [Device] property
+ */
+public suspend fun <T> Device.propertyAsState(
+    propertyName: String,
+    metaConverter: MetaConverter<T>,
+): DeviceState<T> = propertyAsState(
+    propertyName,
+    metaConverter,
+    metaConverter.readOrNull(readProperty(propertyName)) ?: error("Conversion of property failed")
+)
+
+public suspend fun <D : Device, T> D.propertyAsState(
+    propertySpec: DevicePropertySpec<D, T>,
+): DeviceState<T> = propertyAsState(propertySpec.name, propertySpec.converter)
+
+public fun <D : Device, T> D.propertyAsState(
+    propertySpec: DevicePropertySpec<D, T>,
+    initialValue: T,
+): DeviceState<T> = propertyAsState(propertySpec.name, propertySpec.converter, initialValue)
+
+
+private class MutableBoundDeviceState<T>(
+    converter: MetaConverter<T>,
+    device: Device,
+    propertyName: String,
+    initialValue: T,
+) : BoundDeviceState<T>(converter, device, propertyName, initialValue), MutableDeviceState<T> {
+
+    override var value: T
+        get() = valueFlow.value
+        set(newValue) {
+            device.launch {
+                device.writeProperty(propertyName, converter.convert(newValue))
+            }
+        }
+}
+
+public fun <T> Device.mutablePropertyAsState(
+    propertyName: String,
+    metaConverter: MetaConverter<T>,
+    initialValue: T,
+): MutableDeviceState<T> = MutableBoundDeviceState(metaConverter, this, propertyName, initialValue)
+
+public suspend fun <T> Device.mutablePropertyAsState(
+    propertyName: String,
+    metaConverter: MetaConverter<T>,
+): MutableDeviceState<T> {
+    val initialValue = metaConverter.readOrNull(readProperty(propertyName)) ?: error("Conversion of property failed")
+    return mutablePropertyAsState(propertyName, metaConverter, initialValue)
+}
+
+public suspend fun <D : Device, T> D.propertyAsState(
+    propertySpec: MutableDevicePropertySpec<D, T>,
+): MutableDeviceState<T> = mutablePropertyAsState(propertySpec.name, propertySpec.converter)
+
+public fun <D : Device, T> D.propertyAsState(
+    propertySpec: MutableDevicePropertySpec<D, T>,
+    initialValue: T,
+): MutableDeviceState<T> = mutablePropertyAsState(propertySpec.name, propertySpec.converter, initialValue)
+

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/devices/Drive.kt

@@ -0,0 +1,19 @@
+package space.kscience.controls.constructor.devices
+
+import space.kscience.controls.constructor.DeviceConstructor
+import space.kscience.controls.constructor.MutableDeviceState
+import space.kscience.controls.constructor.property
+import space.kscience.controls.constructor.units.NewtonsMeters
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.numerical
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.meta.MetaConverter
+
+//TODO use current as input
+
+public class Drive(
+    context: Context,
+    force: MutableDeviceState<NumericalValue<NewtonsMeters>> = MutableDeviceState(NumericalValue(0)),
+) : DeviceConstructor(context) {
+    public val force: MutableDeviceState<NumericalValue<NewtonsMeters>> by property(MetaConverter.numerical(), force)
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/devices/EncoderDevice.kt

@@ -0,0 +1,20 @@
+package space.kscience.controls.constructor.devices
+
+import space.kscience.controls.constructor.DeviceConstructor
+import space.kscience.controls.constructor.DeviceState
+import space.kscience.controls.constructor.property
+import space.kscience.controls.constructor.units.Degrees
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.numerical
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.meta.MetaConverter
+
+/**
+ * An encoder that can read an angle
+ */
+public class EncoderDevice(
+    context: Context,
+    position: DeviceState<NumericalValue<Degrees>>
+) : DeviceConstructor(context) {
+    public val position: DeviceState<NumericalValue<Degrees>> by property(MetaConverter.numerical<Degrees>(), position)
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/devices/LimitSwitch.kt

@@ -0,0 +1,44 @@
+package space.kscience.controls.constructor.devices
+
+import space.kscience.controls.constructor.DeviceConstructor
+import space.kscience.controls.constructor.DeviceState
+import space.kscience.controls.constructor.map
+import space.kscience.controls.constructor.registerAsProperty
+import space.kscience.controls.constructor.units.Direction
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.UnitsOfMeasurement
+import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.controls.spec.DeviceSpec
+import space.kscience.controls.spec.booleanProperty
+import space.kscience.dataforge.context.Context
+
+
+/**
+ * Virtual [LimitSwitch]
+ */
+public class LimitSwitch(
+    context: Context,
+    locked: DeviceState<Boolean>,
+) : DeviceConstructor(context) {
+
+    public val locked: DeviceState<Boolean> = registerAsProperty(LimitSwitch.locked, locked)
+
+    public companion object : DeviceSpec<LimitSwitch>() {
+        public val locked: DevicePropertySpec<LimitSwitch, Boolean> by booleanProperty { locked.value }
+    }
+}
+
+public fun <U : UnitsOfMeasurement, T : NumericalValue<U>> LimitSwitch(
+    context: Context,
+    limit: T,
+    boundary: Direction,
+    position: DeviceState<T>,
+): LimitSwitch = LimitSwitch(
+    context,
+    DeviceState.map(position) {
+        when (boundary) {
+            Direction.UP -> it >= limit
+            Direction.DOWN -> it <= limit
+        }
+    }
+)

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/devices/LinearDrive.kt

@@ -0,0 +1,38 @@
+package space.kscience.controls.constructor.devices
+
+import space.kscience.controls.constructor.*
+import space.kscience.controls.constructor.models.PidParameters
+import space.kscience.controls.constructor.models.PidRegulator
+import space.kscience.controls.constructor.units.Meters
+import space.kscience.controls.constructor.units.NewtonsMeters
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.numerical
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaConverter
+
+public class LinearDrive(
+    drive: Drive,
+    start: LimitSwitch,
+    end: LimitSwitch,
+    position: DeviceState<NumericalValue<Meters>>,
+    pidParameters: PidParameters,
+    context: Context = drive.context,
+    meta: Meta = Meta.EMPTY,
+) : DeviceConstructor(context, meta) {
+
+    public val position: DeviceState<NumericalValue<Meters>> by property(MetaConverter.numerical(), position)
+
+    public val drive: Drive by device(drive)
+    public val pid: PidRegulator<Meters, NewtonsMeters>  = model(
+        PidRegulator(
+            context = context,
+            position = position,
+            output = drive.force,
+            pidParameters = pidParameters
+        )
+    )
+
+    public val startLimit: LimitSwitch by device(start)
+    public val endLimit: LimitSwitch by device(end)
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/devices/StepDrive.kt

@@ -0,0 +1,62 @@
+package space.kscience.controls.constructor.devices
+
+import space.kscience.controls.constructor.*
+import space.kscience.controls.constructor.units.Degrees
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.plus
+import space.kscience.controls.constructor.units.times
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.meta.MetaConverter
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToLong
+import kotlin.time.DurationUnit
+
+/**
+ * A step drive
+ *
+ * @param ticksPerSecond ticks per second
+ * @param target target ticks state
+ * @param writeTicks a hardware callback
+ */
+public class StepDrive(
+    context: Context,
+    ticksPerSecond: MutableDeviceState<Double>,
+    target: MutableDeviceState<Long> = MutableDeviceState(0),
+    private val writeTicks: suspend (ticks: Long, speed: Double) -> Unit = { _, _ -> },
+) : DeviceConstructor(context) {
+
+    public val target: MutableDeviceState<Long> by property(MetaConverter.long, target)
+
+    public val speed: MutableDeviceState<Double> by property(MetaConverter.double, ticksPerSecond)
+
+    private val positionState = stateOf(target.value)
+
+    public val position: DeviceState<Long> by property(MetaConverter.long, positionState)
+
+
+    //FIXME round to zero problem
+    private val ticker = onTimer(reads = setOf(target, position), writes = setOf(position)) { prev, next ->
+        val tickSpeed = ticksPerSecond.value
+        val timeDelta = (next - prev).toDouble(DurationUnit.SECONDS)
+        val ticksDelta: Long = target.value - position.value
+        val steps: Long = when {
+            ticksDelta > 0 -> min(ticksDelta, (timeDelta * tickSpeed).roundToLong())
+            ticksDelta < 0 -> max(ticksDelta, -(timeDelta * tickSpeed).roundToLong())
+            else -> return@onTimer
+        }
+        writeTicks(steps, tickSpeed)
+        positionState.value += steps
+    }
+}
+
+/**
+ * Compute a state using given tick-to-angle transformation
+ */
+public fun StepDrive.angle(
+    step: NumericalValue<Degrees>,
+    zero: NumericalValue<Degrees> = NumericalValue(0),
+): DeviceState<NumericalValue<Degrees>> = position.map {
+    zero + it * step
+}
+

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/externalState.kt

@@ -0,0 +1,65 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import kotlin.time.Duration
+
+
+private open class ExternalState<T>(
+    val scope: CoroutineScope,
+    val readInterval: Duration,
+    initialValue: T,
+    val reader: suspend () -> T,
+) : DeviceState<T> {
+
+    protected val flow: StateFlow<T> = flow {
+        while (true) {
+            delay(readInterval)
+            emit(reader())
+        }
+    }.stateIn(scope, SharingStarted.Eagerly, initialValue)
+
+    override val value: T get() = flow.value
+    override val valueFlow: Flow<T> get() = flow
+
+    override fun toString(): String  = "ExternalState()"
+}
+
+/**
+ * Create a [DeviceState] which is constructed by regularly reading external value
+ */
+public fun <T> DeviceState.Companion.external(
+    scope: CoroutineScope,
+    readInterval: Duration,
+    initialValue: T,
+    reader: suspend () -> T,
+): DeviceState<T> = ExternalState(scope,  readInterval, initialValue, reader)
+
+private class MutableExternalState<T>(
+    scope: CoroutineScope,
+    readInterval: Duration,
+    initialValue: T,
+    reader: suspend () -> T,
+    val writer: suspend (T) -> Unit,
+) : ExternalState<T>(scope, readInterval, initialValue, reader), MutableDeviceState<T> {
+    override var value: T
+        get() = super.value
+        set(value) {
+            scope.launch {
+                writer(value)
+            }
+        }
+}
+
+/**
+ * Create a [MutableDeviceState] which is constructed by regularly reading external value and allows writing
+ */
+public fun <T> DeviceState.Companion.external(
+    scope: CoroutineScope,
+    readInterval: Duration,
+    initialValue: T,
+    reader: suspend () -> T,
+    writer: suspend (T) -> Unit,
+): MutableDeviceState<T> = MutableExternalState(scope, readInterval, initialValue, reader, writer)

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/flowState.kt

@@ -0,0 +1,20 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+
+
+private class StateFlowAsState<T>(
+    val flow: MutableStateFlow<T>,
+) : MutableDeviceState<T> {
+    override var value: T by flow::value
+    override val valueFlow: Flow<T> get() = flow
+
+    override fun toString(): String = "FlowAsState($value)"
+}
+
+/**
+ * Create a read-only [DeviceState] that wraps [MutableStateFlow].
+ * No data copy is performed.
+ */
+public fun <T> MutableStateFlow<T>.asDeviceState(): MutableDeviceState<T> = StateFlowAsState(this)

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/internalState.kt

@@ -0,0 +1,53 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.emptyFlow
+
+/**
+ * A [MutableDeviceState] that does not correspond to a physical state
+ *
+ * @param callback a synchronous callback that could be used without a scope
+ */
+private class VirtualDeviceState<T>(
+    initialValue: T,
+    private val callback: (T) -> Unit = {},
+) : MutableDeviceState<T> {
+    private val flow = MutableStateFlow(initialValue)
+    override val valueFlow: Flow<T> get() = flow
+
+    override var value: T
+        get() = flow.value
+        set(value) {
+            flow.value = value
+            callback(value)
+        }
+
+    override fun toString(): String = "VirtualDeviceState($value)"
+}
+
+
+/**
+ * A [MutableDeviceState] that does not correspond to a physical state
+ *
+ * @param callback a synchronous callback that could be used without a scope
+ */
+public fun <T> MutableDeviceState(
+    initialValue: T,
+    callback: (T) -> Unit = {},
+): MutableDeviceState<T> = VirtualDeviceState(initialValue, callback)
+
+
+/**
+ * Create a [DeviceState] with constant value
+ */
+public fun <T> DeviceState(
+    value: T
+): DeviceState<T> = object : DeviceState<T> {
+    override val value: T get() = value
+    override val valueFlow: Flow<T>
+        get() = emptyFlow()
+
+    override fun toString(): String = "ConstDeviceState($value)"
+
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/Inertia.kt

@@ -0,0 +1,70 @@
+package space.kscience.controls.constructor.models
+
+import space.kscience.controls.constructor.*
+import space.kscience.controls.constructor.units.*
+import space.kscience.dataforge.context.Context
+import kotlin.math.pow
+import kotlin.time.DurationUnit
+
+/**
+ * A model for inertial movement. Both linear and angular
+ */
+public class Inertia<U : UnitsOfMeasurement, V : UnitsOfMeasurement>(
+    context: Context,
+    force: DeviceState<Double>, //TODO add system unit sets
+    inertia: Double,
+    public val position: MutableDeviceState<NumericalValue<U>>,
+    public val velocity: MutableDeviceState<NumericalValue<V>>,
+) : ModelConstructor(context) {
+
+    init {
+        registerState(position)
+        registerState(velocity)
+    }
+
+    private var currentForce = force.value
+
+    private val movement = onTimer(DefaultTimer.REALTIME) { prev, next ->
+        val dtSeconds = (next - prev).toDouble(DurationUnit.SECONDS)
+
+        // compute new value based on velocity and acceleration from the previous step
+        position.value += NumericalValue(velocity.value.value * dtSeconds + currentForce / inertia * dtSeconds.pow(2) / 2)
+
+        // compute new velocity based on acceleration on the previous step
+        velocity.value += NumericalValue(currentForce / inertia * dtSeconds)
+        currentForce = force.value
+    }
+
+    public companion object {
+        /**
+         * Linear inertial model with [force] in newtons and [mass] in kilograms
+         */
+        public fun linear(
+            context: Context,
+            force: DeviceState<NumericalValue<Newtons>>,
+            mass: NumericalValue<Kilograms>,
+            position: MutableDeviceState<NumericalValue<Meters>>,
+            velocity: MutableDeviceState<NumericalValue<MetersPerSecond>> = MutableDeviceState(NumericalValue(0.0)),
+        ): Inertia<Meters, MetersPerSecond> = Inertia(
+            context = context,
+            force = force.values(),
+            inertia = mass.value,
+            position = position,
+            velocity = velocity
+        )
+
+        public fun circular(
+            context: Context,
+            force: DeviceState<NumericalValue<NewtonsMeters>>,
+            momentOfInertia: NumericalValue<KgM2>,
+            position: MutableDeviceState<NumericalValue<Degrees>>,
+            velocity: MutableDeviceState<NumericalValue<DegreesPerSecond>> = MutableDeviceState(NumericalValue(0.0)),
+        ): Inertia<Degrees, DegreesPerSecond> = Inertia(
+            context = context,
+            force = force.values(),
+            inertia = momentOfInertia.value,
+            position = position,
+            velocity = velocity
+        )
+    }
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/Leadscrew.kt

@@ -0,0 +1,31 @@
+package space.kscience.controls.constructor.models
+
+import space.kscience.controls.constructor.DeviceState
+import space.kscience.controls.constructor.ModelConstructor
+import space.kscience.controls.constructor.map
+import space.kscience.controls.constructor.units.*
+import space.kscience.dataforge.context.Context
+import kotlin.math.PI
+
+/**
+ * https://en.wikipedia.org/wiki/Leadscrew
+ */
+public class Leadscrew(
+    context: Context,
+    public val leverage: NumericalValue<Meters>,
+) : ModelConstructor(context) {
+
+    public fun torqueToForce(
+        stateOfTorque: DeviceState<NumericalValue<NewtonsMeters>>,
+    ): DeviceState<NumericalValue<Newtons>> = DeviceState.map(stateOfTorque) { torque ->
+        NumericalValue(torque.value / leverage.value )
+    }
+
+    public fun degreesToMeters(
+        stateOfAngle: DeviceState<NumericalValue<Degrees>>,
+        offset: NumericalValue<Meters> = NumericalValue(0),
+    ): DeviceState<NumericalValue<Meters>> = DeviceState.map(stateOfAngle) { degrees ->
+        offset + NumericalValue(degrees.value * 2 * PI / 360 * leverage.value )
+    }
+
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/MaterialPoint.kt

@@ -0,0 +1,48 @@
+package space.kscience.controls.constructor.models
+
+import space.kscience.controls.constructor.*
+import space.kscience.controls.constructor.units.*
+import space.kscience.dataforge.context.Context
+import kotlin.math.pow
+import kotlin.time.DurationUnit
+
+
+/**
+ * 3D material point
+ */
+public class MaterialPoint(
+    context: Context,
+    force: DeviceState<XYZ<Newtons>>,
+    mass: NumericalValue<Kilograms>,
+    public val position: MutableDeviceState<XYZ<Meters>>,
+    public val velocity: MutableDeviceState<XYZ<MetersPerSecond>>,
+) : ModelConstructor(context) {
+
+    init {
+        registerState(position)
+        registerState(velocity)
+    }
+
+    private var currentForce = force.value
+
+    private val movement = onTimer(
+        DefaultTimer.REALTIME,
+        reads = setOf(velocity, position),
+        writes = setOf(velocity, position)
+    ) { prev, next ->
+        val dtSeconds = (next - prev).toDouble(DurationUnit.SECONDS)
+
+        // compute new value based on velocity and acceleration from the previous step
+        val deltaR = (velocity.value * dtSeconds).cast(Meters) +
+                (currentForce / mass.value * dtSeconds.pow(2) / 2).cast(Meters)
+        position.value += deltaR
+
+        // compute new velocity based on acceleration on the previous step
+        val deltaV = (currentForce / mass.value * dtSeconds).cast(MetersPerSecond)
+        //TODO apply energy correction
+        //val work = deltaR.length.value * currentForce.length.value
+        velocity.value += deltaV
+
+        currentForce = force.value
+    }
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/PidRegulator.kt

@@ -0,0 +1,73 @@
+package space.kscience.controls.constructor.models
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import space.kscience.controls.constructor.*
+import space.kscience.controls.constructor.units.*
+import space.kscience.controls.manager.clock
+import space.kscience.dataforge.context.Context
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.DurationUnit
+
+
+/**
+ * Pid regulator parameters
+ */
+public data class PidParameters(
+    val kp: Double,
+    val ki: Double,
+    val kd: Double,
+    val timeStep: Duration = 10.milliseconds,
+)
+
+/**
+ * A PID regulator
+ *
+ * @param P units of position values
+ * @param O units of output values
+ */
+public class PidRegulator<P : UnitsOfMeasurement, O : UnitsOfMeasurement>(
+    context: Context,
+    private val position: DeviceState<NumericalValue<P>>,
+    public var pidParameters: PidParameters, // TODO expose as property
+    output: MutableDeviceState<NumericalValue<O>> = MutableDeviceState(NumericalValue(0.0)),
+    private val convertOutput: (NumericalValue<P>) -> NumericalValue<O> = { NumericalValue(it.value) },
+) : ModelConstructor(context) {
+
+    public val target: MutableDeviceState<NumericalValue<P>> = stateOf(NumericalValue(0.0))
+    public val output: MutableDeviceState<NumericalValue<O>> = registerState(output)
+
+    private val updateJob = launch {
+        var lastPosition: NumericalValue<P> = target.value
+
+        var integral: NumericalValue<P> = NumericalValue(0.0)
+
+        val mutex = Mutex()
+
+        val clock = context.clock
+
+        var lastTime = clock.now()
+
+        while (isActive) {
+            delay(pidParameters.timeStep)
+            mutex.withLock {
+                val realTime = clock.now()
+                val delta: NumericalValue<P> = target.value - position.value
+                val dtSeconds = (realTime - lastTime).toDouble(DurationUnit.SECONDS)
+                integral += delta * dtSeconds
+                val derivative = (position.value - lastPosition) / dtSeconds
+
+                //set last time and value to new values
+                lastTime = realTime
+                lastPosition = position.value
+
+                output.value =
+                    convertOutput(pidParameters.kp * delta + pidParameters.ki * integral + pidParameters.kd * derivative)
+            }
+        }
+    }
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/RangeState.kt

@@ -0,0 +1,70 @@
+package space.kscience.controls.constructor.models
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import space.kscience.controls.constructor.DeviceState
+import space.kscience.controls.constructor.MutableDeviceState
+import space.kscience.controls.constructor.map
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.UnitsOfMeasurement
+
+/**
+ *  A state describing a [T] value in the [range]
+ */
+public open class RangeState<T : Comparable<T>>(
+    private val input: DeviceState<T>,
+    public val range: ClosedRange<T>,
+) : DeviceState<T> {
+
+    override val valueFlow: Flow<T> get() = input.valueFlow.map {
+        it.coerceIn(range)
+    }
+
+    override val value: T get() = input.value.coerceIn(range)
+
+    /**
+     * A state showing that the range is on its lower boundary
+     */
+    public val atStart: DeviceState<Boolean> = input.map { it <= range.start }
+
+    /**
+     * A state showing that the range is on its higher boundary
+     */
+    public val atEnd: DeviceState<Boolean> = input.map { it >= range.endInclusive }
+
+    override fun toString(): String = "DoubleRangeState(value=${value},range=$range)"
+}
+
+public class MutableRangeState<T : Comparable<T>>(
+    private val mutableInput: MutableDeviceState<T>,
+    range: ClosedRange<T>,
+) : RangeState<T>(mutableInput, range), MutableDeviceState<T> {
+    override var value: T
+        get() = super.value
+        set(value) {
+            mutableInput.value = value.coerceIn(range)
+        }
+}
+
+public fun <T : Comparable<T>> MutableRangeState(
+    initialValue: T,
+    range: ClosedRange<T>,
+): MutableRangeState<T> = MutableRangeState<T>(MutableDeviceState(initialValue), range)
+
+public fun <U : UnitsOfMeasurement> MutableRangeState(
+    initialValue: Double,
+    range: ClosedRange<Double>,
+): MutableRangeState<NumericalValue<U>> = MutableRangeState(
+    initialValue = NumericalValue(initialValue),
+    range = NumericalValue<U>(range.start)..NumericalValue<U>(range.endInclusive)
+)
+
+
+public fun <T : Comparable<T>> DeviceState<T>.coerceIn(
+    range: ClosedRange<T>,
+): RangeState<T> = RangeState(this, range)
+
+
+public fun <T : Comparable<T>> MutableDeviceState<T>.coerceIn(
+    range: ClosedRange<T>,
+): MutableRangeState<T> = MutableRangeState(this, range)

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/Reducer.kt

@@ -0,0 +1,25 @@
+package space.kscience.controls.constructor.models
+
+import space.kscience.controls.constructor.*
+import space.kscience.controls.constructor.units.Degrees
+import space.kscience.controls.constructor.units.NumericalValue
+import space.kscience.controls.constructor.units.times
+import space.kscience.dataforge.context.Context
+
+/**
+ * A reducer device used for simulations only (no public properties)
+ */
+public class Reducer(
+    context: Context,
+    public val ratio: Double,
+    public val input: DeviceState<NumericalValue<Degrees>>,
+    public val output: MutableDeviceState<NumericalValue<Degrees>>,
+) : ModelConstructor(context) {
+    init {
+        registerState(input)
+        registerState(output)
+        transformTo(input, output) {
+            it * ratio
+        }
+    }
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/units/Direction.kt

@@ -0,0 +1,6 @@
+package space.kscience.controls.constructor.units
+
+public enum class Direction(public val coef: Int) {
+    UP(1),
+    DOWN(-1)
+}

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/units/NumericalValue.kt

@@ -0,0 +1,60 @@
+package space.kscience.controls.constructor.units
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaConverter
+import space.kscience.dataforge.meta.double
+import kotlin.jvm.JvmInline
+
+
+/**
+ * A value without identity coupled to units of measurements.
+ */
+@JvmInline
+public value class NumericalValue<U : UnitsOfMeasurement>(public val value: Double) : Comparable<NumericalValue<U>> {
+    override fun compareTo(other: NumericalValue<U>): Int = value.compareTo(other.value)
+
+}
+
+public fun <U : UnitsOfMeasurement> NumericalValue(
+    number: Number,
+): NumericalValue<U> = NumericalValue(number.toDouble())
+
+public operator fun <U : UnitsOfMeasurement> NumericalValue<U>.plus(
+    other: NumericalValue<U>,
+): NumericalValue<U> = NumericalValue(this.value + other.value)
+
+public operator fun <U : UnitsOfMeasurement> NumericalValue<U>.minus(
+    other: NumericalValue<U>,
+): NumericalValue<U> = NumericalValue(this.value - other.value)
+
+public operator fun <U : UnitsOfMeasurement> NumericalValue<U>.times(
+    c: Number,
+): NumericalValue<U> = NumericalValue(this.value * c.toDouble())
+
+public operator fun <U : UnitsOfMeasurement> Number.times(
+    numericalValue: NumericalValue<U>,
+): NumericalValue<U> = NumericalValue(numericalValue.value * toDouble())
+
+public operator fun <U : UnitsOfMeasurement> NumericalValue<U>.times(
+    c: Double,
+): NumericalValue<U> = NumericalValue(this.value * c)
+
+public operator fun <U : UnitsOfMeasurement> NumericalValue<U>.div(
+    c: Number,
+): NumericalValue<U> = NumericalValue(this.value / c.toDouble())
+
+public operator fun <U : UnitsOfMeasurement> NumericalValue<U>.div(other: NumericalValue<U>): Double =
+    value / other.value
+
+public operator fun <U: UnitsOfMeasurement> NumericalValue<U>.unaryMinus(): NumericalValue<U> = NumericalValue(-value)
+
+
+private object NumericalValueMetaConverter : MetaConverter<NumericalValue<*>> {
+    override fun convert(obj: NumericalValue<*>): Meta = Meta(obj.value)
+
+    override fun readOrNull(source: Meta): NumericalValue<*>? = source.double?.let { NumericalValue<Nothing>(it) }
+}
+
+@Suppress("UNCHECKED_CAST")
+public fun <U : UnitsOfMeasurement> MetaConverter.Companion.numerical(): MetaConverter<NumericalValue<U>> =
+    NumericalValueMetaConverter as MetaConverter<NumericalValue<U>>

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/units/UnitsOfMeasurement.kt

@@ -0,0 +1,60 @@
+package space.kscience.controls.constructor.units
+
+
+public interface UnitsOfMeasurement
+
+/**/
+
+public interface UnitsOfLength : UnitsOfMeasurement
+
+public data object Meters : UnitsOfLength
+
+/**/
+
+public interface UnitsOfTime : UnitsOfMeasurement
+
+public data object Seconds : UnitsOfTime
+
+/**/
+
+public interface UnitsOfVelocity : UnitsOfMeasurement
+
+public data object MetersPerSecond : UnitsOfVelocity
+
+/**/
+
+public sealed interface UnitsOfAngles : UnitsOfMeasurement
+
+public data object Radians : UnitsOfAngles
+public data object Degrees : UnitsOfAngles
+
+/**/
+
+public sealed interface UnitsAngularOfVelocity : UnitsOfMeasurement
+
+public data object RadiansPerSecond : UnitsAngularOfVelocity
+
+public data object DegreesPerSecond : UnitsAngularOfVelocity
+
+/**/
+public interface UnitsOfForce: UnitsOfMeasurement
+
+public data object Newtons: UnitsOfForce
+
+/**/
+
+public interface UnitsOfTorque: UnitsOfMeasurement
+
+public data object NewtonsMeters: UnitsOfTorque
+
+/**/
+
+public interface UnitsOfMass: UnitsOfMeasurement
+
+public data object Kilograms : UnitsOfMass
+
+/**/
+
+public interface UnitsOfMomentOfInertia: UnitsOfMeasurement
+
+public data object KgM2: UnitsOfMomentOfInertia

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/units/coordinates.kt

@@ -0,0 +1,44 @@
+package space.kscience.controls.constructor.units
+
+import kotlin.math.pow
+import kotlin.math.sqrt
+
+public data class XY<U : UnitsOfMeasurement>(val x: NumericalValue<U>, val y: NumericalValue<U>)
+
+public fun <U : UnitsOfMeasurement> XY(x: Number, y: Number): XY<U> = XY(NumericalValue(x), NumericalValue((y)))
+
+public operator fun <U : UnitsOfMeasurement> XY<U>.plus(other: XY<U>): XY<U> =
+    XY(x + other.x, y + other.y)
+
+public operator fun <U : UnitsOfMeasurement> XY<U>.times(c: Number): XY<U> = XY(x * c, y * c)
+public operator fun <U : UnitsOfMeasurement> XY<U>.div(c: Number): XY<U> = XY(x / c, y / c)
+
+public operator fun <U : UnitsOfMeasurement> XY<U>.unaryMinus(): XY<U> = XY(-x, -y)
+
+public data class XYZ<U : UnitsOfMeasurement>(
+    val x: NumericalValue<U>,
+    val y: NumericalValue<U>,
+    val z: NumericalValue<U>,
+)
+
+public val <U : UnitsOfMeasurement> XYZ<U>.length: NumericalValue<U>
+    get() = NumericalValue(
+        sqrt(x.value.pow(2) + y.value.pow(2) + z.value.pow(2))
+    )
+
+public fun <U : UnitsOfMeasurement> XYZ(x: Number, y: Number, z: Number): XYZ<U> =
+    XYZ(NumericalValue(x), NumericalValue((y)), NumericalValue(z))
+
+@Suppress("UNCHECKED_CAST", "UNUSED_PARAMETER")
+public fun <U : UnitsOfMeasurement, R : UnitsOfMeasurement> XYZ<U>.cast(units: R): XYZ<R> = this as XYZ<R>
+
+public operator fun <U : UnitsOfMeasurement> XYZ<U>.plus(other: XYZ<U>): XYZ<U> =
+    XYZ(x + other.x, y + other.y, z + other.z)
+
+public operator fun <U : UnitsOfMeasurement> XYZ<U>.minus(other: XYZ<U>): XYZ<U> =
+    XYZ(x - other.x, y - other.y, z - other.z)
+
+public operator fun <U : UnitsOfMeasurement> XYZ<U>.times(c: Number): XYZ<U> = XYZ(x * c, y * c, z * c)
+public operator fun <U : UnitsOfMeasurement> XYZ<U>.div(c: Number): XYZ<U> = XYZ(x / c, y / c, z / c)
+
+public operator fun <U : UnitsOfMeasurement> XYZ<U>.unaryMinus(): XYZ<U> = XYZ(-x, -y, -z)

controls-constructor/src/commonTest/kotlin/space/kscience/controls/constructor/DeviceGroupTest.kt

@@ -0,0 +1,43 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import space.kscience.controls.api.Device
+import space.kscience.controls.api.DeviceLifeCycleMessage
+import space.kscience.controls.api.DeviceLifecycleState
+import space.kscience.controls.manager.DeviceManager
+import space.kscience.controls.manager.install
+import space.kscience.controls.spec.doRecurring
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.Factory
+import space.kscience.dataforge.context.Global
+import space.kscience.dataforge.context.request
+import space.kscience.dataforge.meta.Meta
+import kotlin.test.Test
+import kotlin.time.Duration.Companion.milliseconds
+
+class DeviceGroupTest {
+
+    class TestDevice(context: Context) : DeviceConstructor(context) {
+
+        companion object : Factory<Device> {
+            override fun build(context: Context, meta: Meta): Device = TestDevice(context)
+        }
+    }
+
+    @Test
+    fun testRecurringRead() = runTest {
+        var counter = 10
+        val testDevice = Global.request(DeviceManager).install("test", TestDevice)
+        testDevice.doRecurring(1.milliseconds) {
+            counter--
+            println(counter)
+            if (counter <= 0) {
+                testDevice.stop()
+            }
+            error("Error!")
+        }
+        testDevice.messageFlow.first { it is DeviceLifeCycleMessage && it.state == DeviceLifecycleState.STOPPED }
+        println("stopped")
+    }
+}

controls-constructor/src/commonTest/kotlin/space/kscience/controls/constructor/TimerTest.kt

@@ -0,0 +1,23 @@
+package space.kscience.controls.constructor
+
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.test.runTest
+import space.kscience.controls.manager.ClockManager
+import space.kscience.dataforge.context.Global
+import space.kscience.dataforge.context.request
+import kotlin.test.Test
+import kotlin.time.Duration.Companion.milliseconds
+
+class TimerTest {
+
+    @Test
+    fun timer() = runTest {
+        val timer = TimerState(Global.request(ClockManager), 10.milliseconds)
+        timer.valueFlow.take(100).onEach {
+            println(it)
+        }.collect()
+
+    }
+}

controls-core/README.md

@@ -16,18 +16,16 @@ Core interfaces for building a device server
 
 ## Artifact:
 
-The Maven coordinates of this project are `space.kscience:controls-core:0.2.0`.
+The Maven coordinates of this project are `space.kscience:controls-core:0.4.0-dev-4`.
 
 **Gradle Kotlin DSL:**
 ```kotlin
 repositories {
     maven("https://repo.kotlin.link")
-    //uncomment to access development builds
-    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
     mavenCentral()
 }
 
 dependencies {
-    implementation("space.kscience:controls-core:0.2.0")
+    implementation("space.kscience:controls-core:0.4.0-dev-4")
 }
 ```

controls-core/build.gradle.kts

@@ -9,8 +9,6 @@ description = """
     Core interfaces for building a device server
 """.trimIndent()
 
-val dataforgeVersion: String by rootProject.extra
-
 kscience {
     jvm()
     js()
@@ -20,10 +18,14 @@ kscience {
         json()
     }
     useContextReceivers()
-    dependencies {
+    commonMain {
-        api("space.kscience:dataforge-io:$dataforgeVersion")
+        api(libs.dataforge.io)
         api(spclibs.kotlinx.datetime)
     }
+
+    jvmTest{
+        implementation(spclibs.logback.classic)
+    }
 }
 
 

controls-core/src/commonMain/kotlin/space/kscience/controls/api/AsynchronousSocket.kt

@@ -0,0 +1,40 @@
+package space.kscience.controls.api
+
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * A generic bidirectional asynchronous sender/receiver object
+ */
+public interface AsynchronousSocket<T> : AutoCloseable {
+    /**
+     * Send an object to the socket
+     */
+    public suspend fun send(data: T)
+
+    /**
+     * Flow of objects received from socket
+     */
+    public fun subscribe(): Flow<T>
+
+    /**
+     * Start socket operation
+     */
+    public fun open()
+
+    /**
+     * Check if this socket is open
+     */
+    public val isOpen: Boolean
+}
+
+/**
+ * Connect an input to this socket.
+ * Multiple inputs could be connected to the same [AsynchronousSocket].
+ *
+ * This method suspends indefinitely, so it should be started in a separate coroutine.
+ */
+public suspend fun <T> AsynchronousSocket<T>.sendFlow(flow: Flow<T>) {
+    flow.collect { send(it) }
+}
+
+

controls-core/src/commonMain/kotlin/space/kscience/controls/api/Device.kt

@@ -3,26 +3,43 @@ package space.kscience.controls.api
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
-import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.serialization.Serializable
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
 import space.kscience.controls.api.Device.Companion.DEVICE_TARGET
 import space.kscience.dataforge.context.ContextAware
 import space.kscience.dataforge.context.info
 import space.kscience.dataforge.context.logger
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.meta.get
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.meta.string
-import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.misc.DfType
+import space.kscience.dataforge.names.parseAsName
 
 /**
  * A lifecycle state of a device
  */
-public enum class DeviceLifecycleState{
+@Serializable
-    INIT,
+public enum class DeviceLifecycleState {
-    OPEN,
+
-    CLOSED
+    /**
+     * Device is initializing
+     */
+    STARTING,
+
+    /**
+     * The Device is initialized and running
+     */
+    STARTED,
+
+    /**
+     * The Device is closed
+     */
+    STOPPED,
+
+    /**
+     * The device encountered irrecoverable error
+     */
+    ERROR
 }
 
 /**
@@ -30,14 +47,15 @@ public enum class DeviceLifecycleState{
  *  [Device] is a supervisor scope encompassing all operations on a device.
  *  When canceled, cancels all running processes.
  */
-@Type(DEVICE_TARGET)
+@DfType(DEVICE_TARGET)
-public interface Device : AutoCloseable, ContextAware, CoroutineScope {
+public interface Device : ContextAware, CoroutineScope {
 
     /**
      * Initial configuration meta for the device
      */
     public val meta: Meta get() = Meta.EMPTY
 
+
     /**
      * List of supported property descriptors
      */
@@ -54,18 +72,6 @@ public interface Device : AutoCloseable, ContextAware, CoroutineScope {
      */
     public suspend fun readProperty(propertyName: String): Meta
 
-    /**
-     * Get the logical state of property or return null if it is invalid
-     */
-    public fun getProperty(propertyName: String): Meta?
-
-    /**
-     * Invalidate property (set logical state to invalid)
-     *
-     * This message is suspended to provide lock-free local property changes (they require coroutine context).
-     */
-    public suspend fun invalidate(propertyName: String)
-
     /**
      * Set property [value] for a property with name [propertyName].
      * In rare cases could suspend if the [Device] supports command queue, and it is full at the moment.
@@ -85,19 +91,19 @@ public interface Device : AutoCloseable, ContextAware, CoroutineScope {
     public suspend fun execute(actionName: String, argument: Meta? = null): Meta?
 
     /**
-     * Initialize the device. This function suspends until the device is finished initialization
+     * Initialize the device. This function suspends until the device is finished initialization.
+     * Does nothing if the device is started or is starting
      */
-    public suspend fun open(): Unit = Unit
+    public suspend fun start(): Unit = Unit
 
     /**
      * Close and terminate the device. This function does not wait for the device to be closed.
      */
-    override fun close() {
+    public suspend fun stop() {
+        coroutineContext[Job]?.cancel("The device is closed")
         logger.info { "Device $this is closed" }
-        cancel("The device is closed")
     }
 
-    @DFExperimental
     public val lifecycleState: DeviceLifecycleState
 
     public companion object {
@@ -105,24 +111,59 @@ public interface Device : AutoCloseable, ContextAware, CoroutineScope {
     }
 }
 
+/**
+ * Inner id of a device. Not necessary corresponds to the name in the parent container
+ */
+public val Device.id: String get() = meta["id"].string?: "device[${hashCode().toString(16)}]"
+
+/**
+ * Device that caches properties values
+ */
+public interface CachingDevice : Device {
+
+    /**
+     * Immediately (without waiting) get the cached (logical) state of property or return null if it is invalid
+     */
+    public fun getProperty(propertyName: String): Meta?
+
+    /**
+     * Invalidate property (set logical state to invalid).
+     *
+     * This message is suspended to provide lock-free local property changes (they require coroutine context).
+     */
+    public suspend fun invalidate(propertyName: String)
+}
+
 /**
  * Get the logical state of property or suspend to read the physical value.
  */
-public suspend fun Device.getOrReadProperty(propertyName: String): Meta =
+public suspend fun Device.getOrReadProperty(propertyName: String): Meta = if (this is CachingDevice) {
     getProperty(propertyName) ?: readProperty(propertyName)
+} else {
+    readProperty(propertyName)
+}
 
 /**
  * Get a snapshot of the device logical state
  *
  */
-public fun Device.getAllProperties(): Meta = Meta {
+public fun CachingDevice.getAllProperties(): Meta = Meta {
     for (descriptor in propertyDescriptors) {
-        setMeta(Name.parse(descriptor.name), getProperty(descriptor.name))
+        set(descriptor.name.parseAsName(), getProperty(descriptor.name))
     }
 }
 
 /**
  * Subscribe on property changes for the whole device
  */
-public fun Device.onPropertyChange(callback: suspend PropertyChangedMessage.() -> Unit): Job =
+public fun Device.onPropertyChange(
-    messageFlow.filterIsInstance<PropertyChangedMessage>().onEach(callback).launchIn(this)
+    scope: CoroutineScope = this,
+    callback: suspend PropertyChangedMessage.() -> Unit,
+): Job = messageFlow.filterIsInstance<PropertyChangedMessage>().onEach(callback).launchIn(scope)
+
+/**
+ * A [Flow] of property change messages for specific property.
+ */
+public fun Device.propertyMessageFlow(propertyName: String): Flow<PropertyChangedMessage> = messageFlow
+    .filterIsInstance<PropertyChangedMessage>()
+    .filter { it.property == propertyName }

controls-core/src/commonMain/kotlin/space/kscience/controls/api/DeviceHub.kt

@@ -1,73 +1,62 @@
 package space.kscience.controls.api
 
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.names.*
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.provider.Path
 import space.kscience.dataforge.provider.Provider
+import space.kscience.dataforge.provider.asPath
+import space.kscience.dataforge.provider.plus
 
 /**
  * A hub that could locate multiple devices and redirect actions to them
  */
 public interface DeviceHub : Provider {
-    public val devices: Map<NameToken, Device>
+    public val devices: Map<Name, Device>
 
     override val defaultTarget: String get() = Device.DEVICE_TARGET
 
     override val defaultChainTarget: String get() = Device.DEVICE_TARGET
 
     override fun content(target: String): Map<Name, Any> = if (target == Device.DEVICE_TARGET) {
-        buildMap {
+        devices
-            fun putAll(prefix: Name, hub: DeviceHub) {
-                hub.devices.forEach {
-                    put(prefix + it.key, it.value)
-                }
-            }
-
-            devices.forEach {
-                val name = it.key.asName()
-                put(name, it.value)
-                (it.value as? DeviceHub)?.let { hub ->
-                    putAll(name, hub)
-                }
-            }
-        }
     } else {
         emptyMap()
     }
+    //TODO send message on device change
 
     public companion object
 }
 
-public operator fun DeviceHub.get(nameToken: NameToken): Device =
+public fun DeviceHub(deviceMap: Map<Name, Device>): DeviceHub = object : DeviceHub {
-    devices[nameToken] ?: error("Device with name $nameToken not found in $this")
+    override val devices: Map<Name, Device>
-
+        get() = deviceMap
-public fun DeviceHub.getOrNull(name: Name): Device? = when {
-    name.isEmpty() -> this as? Device
-    name.length == 1 -> get(name.firstOrNull()!!)
-    else -> (get(name.firstOrNull()!!) as? DeviceHub)?.getOrNull(name.cutFirst())
 }
 
-public operator fun DeviceHub.get(name: Name): Device =
+/**
-    getOrNull(name) ?: error("Device with name $name not found in $this")
+ * List all devices, including sub-devices
+ */
+public fun DeviceHub.provideAllDevices(): Map<Path, Device> = buildMap {
+    fun putAll(prefix: Path, hub: DeviceHub) {
+        hub.devices.forEach {
+            put(prefix + it.key.asPath(), it.value)
+        }
+    }
 
-public fun DeviceHub.getOrNull(nameString: String): Device? = getOrNull(Name.parse(nameString))
+    devices.forEach {
-
+        val name: Name = it.key
-public operator fun DeviceHub.get(nameString: String): Device =
+        put(name.asPath(), it.value)
-    getOrNull(nameString) ?: error("Device with name $nameString not found in $this")
+        (it.value as? DeviceHub)?.let { hub ->
+            putAll(name.asPath(), hub)
+        }
+    }
+}
 
 public suspend fun DeviceHub.readProperty(deviceName: Name, propertyName: String): Meta =
-    this[deviceName].readProperty(propertyName)
+    (devices[deviceName] ?: error("Device with name $deviceName not found in $this")).readProperty(propertyName)
 
 public suspend fun DeviceHub.writeProperty(deviceName: Name, propertyName: String, value: Meta) {
-    this[deviceName].writeProperty(propertyName, value)
+    (devices[deviceName] ?: error("Device with name $deviceName not found in $this")).writeProperty(propertyName, value)
 }
 
 public suspend fun DeviceHub.execute(deviceName: Name, command: String, argument: Meta?): Meta? =
-    this[deviceName].execute(command, argument)
+    (devices[deviceName] ?: error("Device with name $deviceName not found in $this")).execute(command, argument)
-
-
-//suspend fun DeviceHub.respond(request: Envelope): EnvelopeBuilder {
-//    val target = request.meta[DeviceMessage.TARGET_KEY].string ?: defaultTarget
-//    val device = this[target.toName()]
-//
-//    return device.respond(device, target, request)
-//}

controls-core/src/commonMain/kotlin/space/kscience/controls/api/DeviceMessage.kt

@@ -22,10 +22,10 @@ public sealed class DeviceMessage {
     public abstract val sourceDevice: Name?
     public abstract val targetDevice: Name?
     public abstract val comment: String?
-    public abstract val time: Instant?
+    public abstract val time: Instant
 
     /**
-     * Update the source device name for composition. If the original name is null, resulting name is also null.
+     * Update the source device name for composition. If the original name is null, the resulting name is also null.
      */
     public abstract fun changeSource(block: (Name) -> Name): DeviceMessage
 
@@ -59,7 +59,7 @@ public data class PropertyChangedMessage(
     override val sourceDevice: Name = Name.EMPTY,
     override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = block(sourceDevice))
 }
@@ -71,11 +71,11 @@ public data class PropertyChangedMessage(
 @SerialName("property.set")
 public data class PropertySetMessage(
     public val property: String,
-    public val value: Meta?,
+    public val value: Meta,
     override val sourceDevice: Name? = null,
-    override val targetDevice: Name,
+    override val targetDevice: Name?,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = sourceDevice?.let(block))
 }
@@ -91,7 +91,7 @@ public data class PropertyGetMessage(
     override val sourceDevice: Name? = null,
     override val targetDevice: Name,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = sourceDevice?.let(block))
 }
@@ -103,9 +103,9 @@ public data class PropertyGetMessage(
 @SerialName("description.get")
 public data class GetDescriptionMessage(
     override val sourceDevice: Name? = null,
-    override val targetDevice: Name,
+    override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = sourceDevice?.let(block))
 }
@@ -122,7 +122,7 @@ public data class DescriptionMessage(
     override val sourceDevice: Name,
     override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = block(sourceDevice))
 }
@@ -141,7 +141,7 @@ public data class ActionExecuteMessage(
     override val sourceDevice: Name? = null,
     override val targetDevice: Name,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = sourceDevice?.let(block))
 }
@@ -160,22 +160,28 @@ public data class ActionResultMessage(
     override val sourceDevice: Name,
     override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = block(sourceDevice))
 }
 
 /**
- * Notifies listeners that a new binary with given [binaryID] is available. The binary itself could not be provided via [DeviceMessage] API.
+ * Notifies listeners that a new binary with given [contentId] and [contentMeta] is available.
+ *
+ * [contentMeta] includes public information that could be shared with loop subscribers. It should not contain sensitive data.
+ *
+ * The binary itself could not be provided via [DeviceMessage] API.
+ * [space.kscience.controls.peer.PeerConnection] must be used instead
  */
 @Serializable
 @SerialName("binary.notification")
 public data class BinaryNotificationMessage(
-    val binaryID: String,
+    val contentId: String,
+    val contentMeta: Meta,
     override val sourceDevice: Name,
     override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = block(sourceDevice))
 }
@@ -190,7 +196,7 @@ public data class EmptyDeviceMessage(
     override val sourceDevice: Name? = null,
     override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = sourceDevice?.let(block))
 }
@@ -203,12 +209,12 @@ public data class EmptyDeviceMessage(
 public data class DeviceLogMessage(
     val message: String,
     val data: Meta? = null,
-    override val sourceDevice: Name? = null,
+    override val sourceDevice: Name = Name.EMPTY,
     override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
-    override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = sourceDevice?.let(block))
+    override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = block(sourceDevice))
 }
 
 /**
@@ -220,10 +226,25 @@ public data class DeviceErrorMessage(
     public val errorMessage: String?,
     public val errorType: String? = null,
     public val errorStackTrace: String? = null,
-    override val sourceDevice: Name,
+    override val sourceDevice: Name = Name.EMPTY,
     override val targetDevice: Name? = null,
     override val comment: String? = null,
-    @EncodeDefault override val time: Instant? = Clock.System.now(),
+    @EncodeDefault override val time: Instant = Clock.System.now(),
+) : DeviceMessage() {
+    override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = block(sourceDevice))
+}
+
+/**
+ * Device [Device.lifecycleState] is changed
+ */
+@Serializable
+@SerialName("lifecycle")
+public data class DeviceLifeCycleMessage(
+    val state: DeviceLifecycleState,
+    override val sourceDevice: Name = Name.EMPTY,
+    override val targetDevice: Name? = null,
+    override val comment: String? = null,
+    @EncodeDefault override val time: Instant = Clock.System.now(),
 ) : DeviceMessage() {
     override fun changeSource(block: (Name) -> Name): DeviceMessage = copy(sourceDevice = block(sourceDevice))
 }

controls-core/src/commonMain/kotlin/space/kscience/controls/api/Socket.kt

@@ -1,33 +0,0 @@
-package space.kscience.controls.api
-
-import io.ktor.utils.io.core.Closeable
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.launch
-
-/**
- * A generic bidirectional sender/receiver object
- */
-public interface Socket<T> : Closeable {
-    /**
-     * Send an object to the socket
-     */
-    public suspend fun send(data: T)
-
-    /**
-     * Flow of objects received from socket
-     */
-    public fun receiving(): Flow<T>
-    public fun isOpen(): Boolean
-}
-
-/**
- * Connect an input to this socket using designated [scope] for it and return a handler [Job].
- * Multiple inputs could be connected to the same [Socket].
- */
-public fun <T> Socket<T>.connectInput(scope: CoroutineScope, flow: Flow<T>): Job = scope.launch {
-    flow.collect { send(it) }
-}
-
-

controls-core/src/commonMain/kotlin/space/kscience/controls/api/descriptors.kt

@@ -12,21 +12,26 @@ import space.kscience.dataforge.meta.descriptors.MetaDescriptorBuilder
 @Serializable
 public class PropertyDescriptor(
     public val name: String,
-    public var info: String? = null,
+    public var description: String? = null,
     public var metaDescriptor: MetaDescriptor = MetaDescriptor(),
     public var readable: Boolean = true,
-    public var writable: Boolean = false
+    public var mutable: Boolean = false,
 )
 
-public fun PropertyDescriptor.metaDescriptor(block: MetaDescriptorBuilder.()->Unit){
+public fun PropertyDescriptor.metaDescriptor(block: MetaDescriptorBuilder.() -> Unit) {
-    metaDescriptor = MetaDescriptor(block)
+    metaDescriptor = MetaDescriptor {
+        from(metaDescriptor)
+        block()
+    }
 }
 
 /**
  * A descriptor for property
  */
 @Serializable
-public class ActionDescriptor(public val name: String) {
+public class ActionDescriptor(
-    public var info: String? = null
+    public val name: String,
-}
+    public var description: String? = null,
-
+    public var inputMetaDescriptor: MetaDescriptor = MetaDescriptor(),
+    public var outputMetaDescriptor: MetaDescriptor = MetaDescriptor()
+)

controls-core/src/commonMain/kotlin/space/kscience/controls/manager/ClockManager.kt

@@ -0,0 +1,109 @@
+package space.kscience.controls.manager
+
+import kotlinx.coroutines.*
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import space.kscience.controls.api.Device
+import space.kscience.dataforge.context.*
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.double
+import kotlin.coroutines.CoroutineContext
+import kotlin.math.roundToLong
+import kotlin.time.Duration
+
+@OptIn(InternalCoroutinesApi::class)
+private class CompressedTimeDispatcher(
+    val clockManager: ClockManager,
+    val dispatcher: CoroutineDispatcher,
+    val compression: Double,
+) : CoroutineDispatcher(), Delay {
+
+    @InternalCoroutinesApi
+    override fun dispatchYield(context: CoroutineContext, block: Runnable) {
+        dispatcher.dispatchYield(context, block)
+    }
+
+    override fun isDispatchNeeded(context: CoroutineContext): Boolean = dispatcher.isDispatchNeeded(context)
+
+    @ExperimentalCoroutinesApi
+    override fun limitedParallelism(parallelism: Int): CoroutineDispatcher = dispatcher.limitedParallelism(parallelism)
+
+    override fun dispatch(context: CoroutineContext, block: Runnable) {
+        dispatcher.dispatch(context, block)
+    }
+
+    private val delay = ((dispatcher as? Delay) ?: (Dispatchers.Default as Delay))
+
+    override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
+        delay.scheduleResumeAfterDelay((timeMillis / compression).roundToLong(), continuation)
+    }
+
+
+    override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
+        return delay.invokeOnTimeout((timeMillis / compression).roundToLong(), block, context)
+    }
+}
+
+private class CompressedClock(
+    val start: Instant,
+    val compression: Double,
+    val baseClock: Clock = Clock.System,
+) : Clock {
+    override fun now(): Instant {
+        val elapsed = (baseClock.now() - start)
+        return start + elapsed / compression
+    }
+}
+
+public class ClockManager : AbstractPlugin() {
+    override val tag: PluginTag get() = Companion.tag
+
+    public val timeCompression: Double by meta.double(1.0)
+
+    public val clock: Clock by lazy {
+        if (timeCompression == 1.0) {
+            Clock.System
+        } else {
+            CompressedClock(Clock.System.now(), timeCompression)
+        }
+    }
+
+    /**
+     * Provide a [CoroutineDispatcher] with compressed time based on given [dispatcher]
+     */
+    public fun asDispatcher(
+        dispatcher: CoroutineDispatcher = Dispatchers.Default,
+    ): CoroutineDispatcher = if (timeCompression == 1.0) {
+        dispatcher
+    } else {
+        CompressedTimeDispatcher(this, dispatcher, timeCompression)
+    }
+
+    public fun scheduleWithFixedDelay(tick: Duration, block: suspend () -> Unit): Job = context.launch(asDispatcher()) {
+        while (isActive) {
+            delay(tick)
+            block()
+        }
+    }
+
+
+    public companion object : PluginFactory<ClockManager> {
+        override val tag: PluginTag = PluginTag("clock", group = PluginTag.DATAFORGE_GROUP)
+
+        override fun build(context: Context, meta: Meta): ClockManager = ClockManager()
+    }
+}
+
+public val Context.clock: Clock get() = plugins[ClockManager]?.clock ?: Clock.System
+
+public val Device.clock: Clock get() = context.clock
+
+public fun Device.getCoroutineDispatcher(dispatcher: CoroutineDispatcher = Dispatchers.Default): CoroutineDispatcher =
+    context.plugins[ClockManager]?.asDispatcher(dispatcher) ?: dispatcher
+
+public fun ContextBuilder.withTimeCompression(compression: Double) {
+    require(compression > 0.0) { "Time compression must be greater than zero." }
+    plugin(ClockManager) {
+        "timeCompression" put compression
+    }
+}

controls-core/src/commonMain/kotlin/space/kscience/controls/manager/DeviceManager.kt

@@ -3,12 +3,13 @@ package space.kscience.controls.manager
 import kotlinx.coroutines.launch
 import space.kscience.controls.api.Device
 import space.kscience.controls.api.DeviceHub
-import space.kscience.controls.api.getOrNull
+import space.kscience.controls.api.id
 import space.kscience.dataforge.context.*
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.meta.MutableMeta
 import space.kscience.dataforge.names.Name
-import space.kscience.dataforge.names.NameToken
+import space.kscience.dataforge.names.get
+import space.kscience.dataforge.names.parseAsName
 import kotlin.collections.set
 import kotlin.properties.ReadOnlyProperty
 
@@ -21,11 +22,11 @@ public class DeviceManager : AbstractPlugin(), DeviceHub {
     /**
      * Actual list of connected devices
      */
-    private val top = HashMap<NameToken, Device>()
+    private val _devices = HashMap<Name, Device>()
-    override val devices: Map<NameToken, Device> get() = top
+    override val devices: Map<Name, Device> get() = _devices
 
-    public fun registerDevice(name: NameToken, device: Device) {
+    public fun registerDevice(name: Name, device: Device) {
-        top[name] = device
+        _devices[name] = device
     }
 
     override fun content(target: String): Map<Name, Any> = super<DeviceHub>.content(target)
@@ -38,13 +39,19 @@ public class DeviceManager : AbstractPlugin(), DeviceHub {
 }
 
 public fun <D : Device> DeviceManager.install(name: String, device: D): D {
-    registerDevice(NameToken(name), device)
+    registerDevice(name.parseAsName(), device)
     device.launch {
-        device.open()
+        device.start()
     }
     return device
 }
 
+public fun <D : Device> DeviceManager.install(device: D): D = install(device.id, device)
+
+
+public fun <D : Device> Context.install(name: String, device: D): D = request(DeviceManager).install(name, device)
+
+public fun <D : Device> Context.install(device: D): D = request(DeviceManager).install(device.id, device)
 
 /**
  * Register and start a device built by [factory] with current [Context] and [meta].
@@ -62,7 +69,7 @@ public inline fun <D : Device> DeviceManager.installing(
     val meta = Meta(builder)
     return ReadOnlyProperty { _, property ->
         val name = property.name
-        val current = getOrNull(name)
+        val current = devices[name]
         if (current == null) {
             install(name, factory, meta)
         } else if (current.meta != meta) {
@@ -72,5 +79,4 @@ public inline fun <D : Device> DeviceManager.installing(
             current as D
         }
     }
-}
+}
-

controls-core/src/commonMain/kotlin/space/kscience/controls/manager/respondMessage.kt

@@ -1,10 +1,9 @@
 package space.kscience.controls.manager
 
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.emptyFlow
-import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.merge
 import space.kscience.controls.api.*
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.plus
@@ -24,11 +23,7 @@ public suspend fun Device.respondMessage(deviceTarget: Name, request: DeviceMess
         }
 
         is PropertySetMessage -> {
-            if (request.value == null) {
+            writeProperty(request.property, request.value)
-                invalidate(request.property)
-            } else {
-                writeProperty(request.property, request.value)
-            }
             PropertyChangedMessage(
                 property = request.property,
                 value = getOrReadProperty(request.property),
@@ -64,6 +59,7 @@ public suspend fun Device.respondMessage(deviceTarget: Name, request: DeviceMess
         is DeviceErrorMessage,
         is EmptyDeviceMessage,
         is DeviceLogMessage,
+        is DeviceLifeCycleMessage,
         -> null
     }
 } catch (ex: Exception) {
@@ -71,42 +67,41 @@ public suspend fun Device.respondMessage(deviceTarget: Name, request: DeviceMess
 }
 
 /**
- * Process incoming [DeviceMessage], using hub naming to evaluate target.
+ * Process incoming [DeviceMessage], using hub naming to find target.
+ * If the `targetDevice` is `null`, then the message is sent to each device in this hub
  */
-public suspend fun DeviceHub.respondHubMessage(request: DeviceMessage): DeviceMessage? {
+public suspend fun DeviceHub.respondHubMessage(request: DeviceMessage): List<DeviceMessage> {
     return try {
-        val targetName = request.targetDevice ?: return null
+        val targetName = request.targetDevice
-        val device = getOrNull(targetName) ?: error("The device with name $targetName not found in $this")
+        if (targetName == null) {
-        device.respondMessage(targetName, request)
+            devices.mapNotNull {
+                it.value.respondMessage(it.key, request)
+            }
+        } else {
+            val device = devices[targetName] ?: error("The device with name $targetName not found in $this")
+            listOfNotNull(device.respondMessage(targetName, request))
+        }
     } catch (ex: Exception) {
-        DeviceMessage.error(ex, sourceDevice = Name.EMPTY, targetDevice = request.sourceDevice)
+        listOf(DeviceMessage.error(ex, sourceDevice = Name.EMPTY, targetDevice = request.sourceDevice))
     }
 }
 
 /**
  * Collect all messages from given [DeviceHub], applying proper relative names.
  */
-public fun DeviceHub.hubMessageFlow(scope: CoroutineScope): Flow<DeviceMessage> {
+public fun DeviceHub.hubMessageFlow(): Flow<DeviceMessage> {
-    
+
-    //TODO could we avoid using downstream scope?
+    val deviceMessageFlow = if (this is Device) messageFlow else emptyFlow()
-    val outbox = MutableSharedFlow<DeviceMessage>()
+
-    if (this is Device) {
+    val childrenFlows = devices.map { (token, childDevice) ->
-        messageFlow.onEach {
+        if (childDevice is DeviceHub) {
-            outbox.emit(it)
+            childDevice.hubMessageFlow()
-        }.launchIn(scope)
-    }
-    //TODO maybe better create map of all devices to limit copying
-    devices.forEach { (token, childDevice) ->
-        val flow = if (childDevice is DeviceHub) {
-            childDevice.hubMessageFlow(scope)
         } else {
             childDevice.messageFlow
+        }.map { deviceMessage ->
+            deviceMessage.changeSource { token + it }
         }
-        flow.onEach { deviceMessage ->
-            outbox.emit(
-                deviceMessage.changeSource { token + it }
-            )
-        }.launchIn(scope)
     }
-    return outbox
+
+    return merge(deviceMessageFlow, *childrenFlows.toTypedArray())
 }

controls-core/src/commonMain/kotlin/space/kscience/controls/misc/PropertyHistory.kt

@@ -0,0 +1,70 @@
+package space.kscience.controls.misc
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.*
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import space.kscience.controls.api.Device
+import space.kscience.controls.api.DeviceMessage
+import space.kscience.controls.api.PropertyChangedMessage
+import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.controls.spec.name
+import space.kscience.dataforge.meta.MetaConverter
+import space.kscience.dataforge.names.Name
+
+/**
+ * An interface for device property history.
+ */
+public interface PropertyHistory<T> {
+    /**
+     * Flow property values filtered by a time range. The implementation could flow it as a chunk or provide paging.
+     * So the resulting flow is allowed to suspend.
+     *
+     * If [until] is in the future, the resulting flow is potentially unlimited.
+     * Theoretically, it could be also unlimited if the event source keeps producing new event with timestamp in a given range.
+     */
+    public fun flowHistory(
+        from: Instant = Instant.DISTANT_PAST,
+        until: Instant = Clock.System.now(),
+    ): Flow<ValueWithTime<T>>
+}
+
+/**
+ * An in-memory property values history collector
+ */
+public class CollectedPropertyHistory<T>(
+    public val scope: CoroutineScope,
+    eventFlow: Flow<DeviceMessage>,
+    public val deviceName: Name,
+    public val propertyName: String,
+    public val converter: MetaConverter<T>,
+    maxSize: Int = 1000,
+) : PropertyHistory<T> {
+
+    private val store: SharedFlow<ValueWithTime<T>> = eventFlow
+        .filterIsInstance<PropertyChangedMessage>()
+        .filter { it.sourceDevice == deviceName && it.property == propertyName }
+        .map { ValueWithTime(converter.read(it.value), it.time) }
+        .shareIn(scope, started = SharingStarted.Eagerly, replay = maxSize)
+
+    override fun flowHistory(from: Instant, until: Instant): Flow<ValueWithTime<T>> =
+        store.filter { it.time in from..until }
+}
+
+/**
+ * Collect and store in memory device property changes for a given property
+ */
+public fun <T> Device.collectPropertyHistory(
+    scope: CoroutineScope = this,
+    deviceName: Name,
+    propertyName: String,
+    converter: MetaConverter<T>,
+    maxSize: Int = 1000,
+): PropertyHistory<T> = CollectedPropertyHistory(scope, messageFlow, deviceName, propertyName, converter, maxSize)
+
+public fun <D : Device, T> D.collectPropertyHistory(
+    scope: CoroutineScope = this,
+    deviceName: Name,
+    spec: DevicePropertySpec<D, T>,
+    maxSize: Int = 1000,
+): PropertyHistory<T> = collectPropertyHistory(scope, deviceName, spec.name, spec.converter, maxSize)

controls-core/src/commonMain/kotlin/space/kscience/controls/misc/ValueWithTime.kt

@@ -0,0 +1,69 @@
+package space.kscience.controls.misc
+
+import kotlinx.datetime.Instant
+import kotlinx.io.Sink
+import kotlinx.io.Source
+import space.kscience.dataforge.io.IOFormat
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaConverter
+import space.kscience.dataforge.meta.get
+
+/**
+ * A value coupled to a time it was obtained at
+ */
+public data class ValueWithTime<T>(val value: T, val time: Instant) {
+    public companion object {
+        /**
+         * Create a [ValueWithTime] format for given value value [IOFormat]
+         */
+        public fun <T> ioFormat(
+            valueFormat: IOFormat<T>,
+        ): IOFormat<ValueWithTime<T>> = ValueWithTimeIOFormat(valueFormat)
+
+        /**
+         * Create a [MetaConverter] with time for given value [MetaConverter]
+         */
+        public fun <T> metaConverter(
+            valueConverter: MetaConverter<T>,
+        ): MetaConverter<ValueWithTime<T>> = ValueWithTimeMetaConverter(valueConverter)
+
+
+        public const val META_TIME_KEY: String = "time"
+        public const val META_VALUE_KEY: String = "value"
+    }
+}
+
+private class ValueWithTimeIOFormat<T>(val valueFormat: IOFormat<T>) : IOFormat<ValueWithTime<T>> {
+
+    override fun readFrom(source: Source): ValueWithTime<T> {
+        val timestamp = InstantIOFormat.readFrom(source)
+        val value = valueFormat.readFrom(source)
+        return ValueWithTime(value, timestamp)
+    }
+
+    override fun writeTo(sink: Sink, obj: ValueWithTime<T>) {
+        InstantIOFormat.writeTo(sink, obj.time)
+        valueFormat.writeTo(sink, obj.value)
+    }
+
+}
+
+private class ValueWithTimeMetaConverter<T>(
+    val valueConverter: MetaConverter<T>,
+) : MetaConverter<ValueWithTime<T>> {
+
+
+    override fun readOrNull(
+        source: Meta,
+    ): ValueWithTime<T>? = valueConverter.read(source[ValueWithTime.META_VALUE_KEY] ?: Meta.EMPTY)?.let {
+        ValueWithTime(it, source[ValueWithTime.META_TIME_KEY]?.instant ?: Instant.DISTANT_PAST)
+    }
+
+    override fun convert(obj: ValueWithTime<T>): Meta = Meta {
+        ValueWithTime.META_TIME_KEY put obj.time.toMeta()
+        ValueWithTime.META_VALUE_KEY put valueConverter.convert(obj.value)
+    }
+}
+
+
+public fun <T : Any> MetaConverter<T>.withTime(): MetaConverter<ValueWithTime<T>> = ValueWithTimeMetaConverter(this)

controls-core/src/commonMain/kotlin/space/kscience/controls/misc/converters.kt

@@ -0,0 +1,62 @@
+package space.kscience.controls.misc
+
+import kotlinx.datetime.Instant
+import space.kscience.dataforge.meta.*
+import kotlin.time.Duration
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
+
+public fun Double.asMeta(): Meta = Meta(asValue())
+
+/**
+ * Generate a nullable [MetaConverter] from non-nullable one
+ */
+public fun <T : Any> MetaConverter<T>.nullable(): MetaConverter<T?> = object : MetaConverter<T?> {
+    override fun convert(obj: T?): Meta = obj?.let { this@nullable.convert(it) } ?: Meta(Null)
+
+    override fun readOrNull(source: Meta): T? = if (source.value == Null) null else this@nullable.readOrNull(source)
+
+}
+
+//TODO to be moved to DF
+private object DurationConverter : MetaConverter<Duration> {
+    override fun readOrNull(source: Meta): Duration = source.value?.double?.toDuration(DurationUnit.SECONDS)
+        ?: run {
+            val unit: DurationUnit = source["unit"].enum<DurationUnit>() ?: DurationUnit.SECONDS
+            val value = source[Meta.VALUE_KEY].double ?: error("No value present for Duration")
+            return@run value.toDuration(unit)
+        }
+
+    override fun convert(obj: Duration): Meta = obj.toDouble(DurationUnit.SECONDS).asMeta()
+}
+
+public val MetaConverter.Companion.duration: MetaConverter<Duration> get() = DurationConverter
+
+
+private object InstantConverter : MetaConverter<Instant> {
+    override fun readOrNull(source: Meta): Instant? = source.string?.let { Instant.parse(it) }
+    override fun convert(obj: Instant): Meta = Meta(obj.toString())
+}
+
+public val MetaConverter.Companion.instant: MetaConverter<Instant> get() = InstantConverter
+
+private object DoubleRangeConverter : MetaConverter<ClosedFloatingPointRange<Double>> {
+    override fun readOrNull(source: Meta): ClosedFloatingPointRange<Double>? =
+        source.value?.doubleArray?.let { (start, end) ->
+            start..end
+        }
+
+    override fun convert(
+        obj: ClosedFloatingPointRange<Double>,
+    ): Meta = Meta(doubleArrayOf(obj.start, obj.endInclusive).asValue())
+}
+
+public val MetaConverter.Companion.doubleRange: MetaConverter<ClosedFloatingPointRange<Double>> get() = DoubleRangeConverter
+
+private object StringListConverter : MetaConverter<List<String>> {
+    override fun convert(obj: List<String>): Meta = Meta(obj.map { it.asValue() }.asValue())
+
+    override fun readOrNull(source: Meta): List<String>? = source.stringList ?: source["@jsonArray"]?.stringList
+}
+
+public val MetaConverter.Companion.stringList: MetaConverter<List<String>> get() = StringListConverter

controls-core/src/commonMain/kotlin/space/kscience/controls/misc/timeIO.kt

@@ -0,0 +1,42 @@
+package space.kscience.controls.misc
+
+
+import kotlinx.datetime.Instant
+import kotlinx.io.Sink
+import kotlinx.io.Source
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.io.IOFormat
+import space.kscience.dataforge.io.IOFormatFactory
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.string
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.asName
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+
+/**
+ * An [IOFormat] for [Instant]
+ */
+public object InstantIOFormat : IOFormat<Instant>, IOFormatFactory<Instant> {
+    override fun build(context: Context, meta: Meta): IOFormat<Instant> = this
+
+    override val name: Name = "instant".asName()
+
+    override val type: KType get() = typeOf<Instant>()
+
+    override fun writeTo(sink: Sink, obj: Instant) {
+        sink.writeLong(obj.epochSeconds)
+        sink.writeInt(obj.nanosecondsOfSecond)
+    }
+
+    override fun readFrom(source: Source): Instant {
+        val seconds = source.readLong()
+        val nanoseconds = source.readInt()
+        return Instant.fromEpochSeconds(seconds, nanoseconds)
+    }
+}
+
+public fun Instant.toMeta(): Meta = Meta(toString())
+
+public val Meta.instant: Instant? get() = value?.string?.let { Instant.parse(it) }

controls-core/src/commonMain/kotlin/space/kscience/controls/misc/timeMeta.kt

@@ -1,18 +0,0 @@
-package space.kscience.controls.misc
-
-import kotlinx.datetime.Instant
-import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.meta.get
-import space.kscience.dataforge.meta.long
-
-// TODO move to core
-
-public fun Instant.toMeta(): Meta = Meta {
-    "seconds" put epochSeconds
-    "nanos" put nanosecondsOfSecond
-}
-
-public fun Meta.instant(): Instant = value?.long?.let { Instant.fromEpochMilliseconds(it) } ?: Instant.fromEpochSeconds(
-    get("seconds")?.long ?: 0L,
-    get("nanos")?.long ?: 0L,
-)

controls-core/src/commonMain/kotlin/space/kscience/controls/peer/PeerConnection.kt

@@ -0,0 +1,39 @@
+package space.kscience.controls.peer
+
+import space.kscience.dataforge.io.Envelope
+import space.kscience.dataforge.meta.Meta
+
+/**
+ * A manager that allows direct synchronous sending and receiving binary data
+ */
+public interface PeerConnection {
+    /**
+     * Receive an [Envelope] from a device on a given [address] with given [contentId].
+     *
+     * The address depends on the specifics of given [PeerConnection]. For example, it could be a TCP/IP port or
+     * magix endpoint name.
+     *
+     * Depending on [PeerConnection] implementation, the resulting [Envelope] could be lazy loaded
+     *
+     * Additional metadata in [requestMeta] could be required for authentication.
+     */
+    public suspend fun receive(
+        address: String,
+        contentId: String,
+        requestMeta: Meta = Meta.EMPTY,
+    ): Envelope?
+
+    /**
+     * Send an [envelope] to a device on a given [address]
+     *
+     * The address depends on the specifics of given [PeerConnection]. For example, it could be a TCP/IP port or
+     * magix endpoint name.
+     *
+     * Additional metadata in [requestMeta] could be required for authentication.
+     */
+    public suspend fun send(
+        address: String,
+        envelope: Envelope,
+        requestMeta: Meta = Meta.EMPTY,
+    )
+}

controls-core/src/commonMain/kotlin/space/kscience/controls/ports/AsynchronousPort.kt

@@ -0,0 +1,115 @@
+package space.kscience.controls.ports
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.io.Source
+import space.kscience.controls.api.AsynchronousSocket
+import space.kscience.dataforge.context.*
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.get
+import space.kscience.dataforge.meta.int
+import space.kscience.dataforge.meta.string
+import kotlin.coroutines.CoroutineContext
+
+/**
+ * Raw [ByteArray] port
+ */
+public interface AsynchronousPort : ContextAware, AsynchronousSocket<ByteArray>
+
+/**
+ * Capture [AsynchronousPort] output as kotlinx-io [Source].
+ * [scope] controls the consummation.
+ * If the scope is canceled, the source stops producing.
+ */
+public fun AsynchronousPort.receiveAsSource(scope: CoroutineScope): Source = subscribe().consumeAsSource(scope)
+
+
+/**
+ * Common abstraction for [AsynchronousPort] based on [Channel]
+ */
+public abstract class AbstractAsynchronousPort(
+    override val context: Context,
+    public val meta: Meta,
+    coroutineContext: CoroutineContext = context.coroutineContext,
+) : AsynchronousPort {
+
+
+    protected val scope: CoroutineScope by lazy {
+        CoroutineScope(
+            coroutineContext +
+                    SupervisorJob(coroutineContext[Job]) +
+                    CoroutineExceptionHandler { _, throwable -> logger.error(throwable) { "Asynchronous port error: " + throwable.stackTraceToString() } } +
+                    CoroutineName(toString())
+        )
+    }
+
+    private val outgoing = Channel<ByteArray>(meta["outgoing.capacity"].int ?: 100)
+    private val incoming = Channel<ByteArray>(meta["incoming.capacity"].int ?: 100)
+
+    /**
+     * Internal method to synchronously send data
+     */
+    protected abstract suspend fun write(data: ByteArray)
+
+    /**
+     * Internal method to receive data synchronously
+     */
+    protected suspend fun receive(data: ByteArray) {
+        logger.debug { "$this RECEIVED: ${data.decodeToString()}" }
+        incoming.send(data)
+    }
+
+    private var sendJob: Job? = null
+
+    protected abstract fun onOpen()
+
+    final override fun open() {
+        if (!isOpen) {
+            sendJob = scope.launch {
+                for (data in outgoing) {
+                    try {
+                        write(data)
+                        logger.debug { "${this@AbstractAsynchronousPort} SENT: ${data.decodeToString()}" }
+                    } catch (ex: Exception) {
+                        if (ex is CancellationException) throw ex
+                        logger.error(ex) { "Error while writing data to the port" }
+                    }
+                }
+            }
+            onOpen()
+        } else {
+            logger.warn { "$this already opened" }
+        }
+    }
+
+
+    /**
+     * Send a data packet via the port
+     */
+    override suspend fun send(data: ByteArray) {
+        check(isOpen) { "The port is not opened" }
+        outgoing.send(data)
+    }
+
+    /**
+     * Raw flow of incoming data chunks. The chunks are not guaranteed to be complete phrases.
+     * To form phrases, some condition should be used on top of it.
+     * For example [stringsDelimitedIncoming] generates phrases with fixed delimiter.
+     */
+    override fun subscribe(): Flow<ByteArray> = incoming.receiveAsFlow()
+
+    override fun close() {
+        outgoing.close()
+        incoming.close()
+        sendJob?.cancel()
+    }
+
+    override fun toString(): String = meta["name"].string ?: "ChannelPort[${hashCode().toString(16)}]"
+}
+
+/**
+ * Send UTF-8 encoded string
+ */
+public suspend fun AsynchronousPort.send(string: String): Unit = send(string.encodeToByteArray())

controls-core/src/commonMain/kotlin/space/kscience/controls/ports/Port.kt

@@ -1,100 +0,0 @@
-package space.kscience.controls.ports
-
-import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.receiveAsFlow
-import space.kscience.controls.api.Socket
-import space.kscience.dataforge.context.*
-import space.kscience.dataforge.misc.Type
-import kotlin.coroutines.CoroutineContext
-
-/**
- * Raw [ByteArray] port
- */
-public interface Port : ContextAware, Socket<ByteArray>
-
-/**
- * A specialized factory for [Port]
- */
-@Type(PortFactory.TYPE)
-public interface PortFactory : Factory<Port> {
-    public val type: String
-
-    public companion object {
-        public const val TYPE: String = "controls.port"
-    }
-}
-
-/**
- * Common abstraction for [Port] based on [Channel]
- */
-public abstract class AbstractPort(
-    override val context: Context,
-    coroutineContext: CoroutineContext = context.coroutineContext,
-) : Port {
-
-    protected val scope: CoroutineScope = CoroutineScope(coroutineContext + SupervisorJob(coroutineContext[Job]))
-
-    private val outgoing = Channel<ByteArray>(100)
-    private val incoming = Channel<ByteArray>(Channel.CONFLATED)
-
-    init {
-        scope.coroutineContext[Job]?.invokeOnCompletion {
-            close()
-        }
-    }
-
-    /**
-     * Internal method to synchronously send data
-     */
-    protected abstract suspend fun write(data: ByteArray)
-
-    /**
-     * Internal method to receive data synchronously
-     */
-    protected suspend fun receive(data: ByteArray) {
-        logger.debug { "${this@AbstractPort} RECEIVED: ${data.decodeToString()}" }
-        incoming.send(data)
-    }
-
-    private val sendJob = scope.launch {
-        for (data in outgoing) {
-            try {
-                write(data)
-                logger.debug { "${this@AbstractPort} SENT: ${data.decodeToString()}" }
-            } catch (ex: Exception) {
-                if (ex is CancellationException) throw ex
-                logger.error(ex) { "Error while writing data to the port" }
-            }
-        }
-    }
-
-    /**
-     * Send a data packet via the port
-     */
-    override suspend fun send(data: ByteArray) {
-        outgoing.send(data)
-    }
-
-    /**
-     * Raw flow of incoming data chunks. The chunks are not guaranteed to be complete phrases.
-     * In order to form phrases, some condition should be used on top of it.
-     * For example [stringsDelimitedIncoming] generates phrases with fixed delimiter.
-     */
-    override fun receiving(): Flow<ByteArray> = incoming.receiveAsFlow()
-
-    override fun close() {
-        outgoing.close()
-        incoming.close()
-        sendJob.cancel()
-        scope.cancel()
-    }
-
-    override fun isOpen(): Boolean = scope.isActive
-}
-
-/**
- * Send UTF-8 encoded string
- */
-public suspend fun Port.send(string: String): Unit = send(string.encodeToByteArray())

controls-core/src/commonMain/kotlin/space/kscience/controls/ports/PortProxy.kt

@@ -1,64 +0,0 @@
-package space.kscience.controls.ports
-
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import space.kscience.dataforge.context.*
-
-/**
- * A port that could be closed multiple times and opens automatically on request
- */
-public class PortProxy(override val context: Context = Global, public val factory: suspend () -> Port) : Port, ContextAware {
-
-    private var actualPort: Port? = null
-    private val mutex: Mutex = Mutex()
-
-    private suspend fun port(): Port {
-        return mutex.withLock {
-            if (actualPort?.isOpen() == true) {
-                actualPort!!
-            } else {
-                factory().also {
-                    actualPort = it
-                }
-            }
-        }
-    }
-
-    override suspend fun send(data: ByteArray) {
-        port().send(data)
-    }
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    override fun receiving(): Flow<ByteArray> = flow {
-        while (true) {
-            try {
-                //recreate port and Flow on connection problems
-                port().receiving().collect {
-                    emit(it)
-                }
-            } catch (t: Throwable) {
-                logger.warn{"Port read failed: ${t.message}. Reconnecting."}
-                mutex.withLock {
-                    actualPort?.close()
-                    actualPort = null
-                }
-            }
-        }
-    }
-
-    // open by default
-    override fun isOpen(): Boolean = true
-
-    override fun close() {
-        context.launch {
-            mutex.withLock {
-                actualPort?.close()
-                actualPort = null
-            }
-        }
-    }
-}

controls-core/src/commonMain/kotlin/space/kscience/controls/ports/Ports.kt

@@ -11,26 +11,43 @@ public class Ports : AbstractPlugin() {
 
     override val tag: PluginTag get() = Companion.tag
 
-    private val portFactories by lazy {
+    private val synchronousPortFactories by lazy {
-        context.gather<PortFactory>(PortFactory.TYPE)
+        context.gather<Factory<SynchronousPort>>(SYNCHRONOUS_PORT_TYPE)
     }
 
-    private val portCache = mutableMapOf<Meta, Port>()
+    private val asynchronousPortFactories by lazy {
+        context.gather<Factory<AsynchronousPort>>(ASYNCHRONOUS_PORT_TYPE)
+    }
 
     /**
-     * Create a new [Port] according to specification
+     * Create a new [AsynchronousPort] according to specification
      */
-    public fun buildPort(meta: Meta): Port = portCache.getOrPut(meta) {
+    public fun buildAsynchronousPort(meta: Meta): AsynchronousPort {
         val type by meta.string { error("Port type is not defined") }
-        val factory = portFactories.values.firstOrNull { it.type == type }
+        val factory = asynchronousPortFactories.entries
+            .firstOrNull { it.key.toString() == type }?.value
             ?: error("Port factory for type $type not found")
-        factory.build(context, meta)
+        return factory.build(context, meta)
+    }
+
+    /**
+     * Create a [SynchronousPort] according to specification or wrap an asynchronous implementation
+     */
+    public fun buildSynchronousPort(meta: Meta): SynchronousPort {
+        val type by meta.string { error("Port type is not defined") }
+        val factory = synchronousPortFactories.entries
+            .firstOrNull { it.key.toString() == type }?.value
+            ?: return buildAsynchronousPort(meta).asSynchronousPort()
+        return factory.build(context, meta)
     }
 
     public companion object : PluginFactory<Ports> {
 
         override val tag: PluginTag = PluginTag("controls.ports", group = PluginTag.DATAFORGE_GROUP)
 
+        public const val ASYNCHRONOUS_PORT_TYPE: String = "controls.asynchronousPort"
+        public const val SYNCHRONOUS_PORT_TYPE: String = "controls.synchronousPort"
+
         override fun build(context: Context, meta: Meta): Ports = Ports()
 
     }

controls-core/src/commonMain/kotlin/space/kscience/controls/ports/SynchronousPort.kt

@@ -1,28 +1,105 @@
 package space.kscience.controls.ports
 
-import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import kotlinx.io.Buffer
+import kotlinx.io.Source
+import kotlinx.io.readByteArray
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.ContextAware
 
 /**
- * A port handler for synchronous (request-response) communication with a port. Only one request could be active at a time (others are suspended.
+ * A port handler for synchronous (request-response) communication with a port.
- * The handler does not guarantee exclusive access to the port so the user mush ensure that no other controller handles port at the moment.
+ * Only one request could be active at a time (others are suspended).
  */
-public class SynchronousPort(public val port: Port, private val mutex: Mutex) : Port by port {
+public interface SynchronousPort : ContextAware, AutoCloseable {
+
+    public fun open()
+
+    public val isOpen: Boolean
+
     /**
-     * Send a single message and wait for the flow of respond messages.
+     * Send a single message and wait for the flow of response chunks.
+     * The consumer is responsible for calling a terminal operation on the flow.
      */
-    public suspend fun <R> respond(data: ByteArray, transform: suspend Flow<ByteArray>.() -> R): R = mutex.withLock {
+    public suspend fun <R> respond(
-        port.send(data)
+        request: ByteArray,
-        transform(port.receiving())
+        transform: suspend Flow<ByteArray>.() -> R,
+    ): R
+
+    /**
+     * Synchronously read fixed size response to a given [request]. Discard additional response bytes.
+     */
+    public suspend fun respondFixedMessageSize(
+        request: ByteArray,
+        responseSize: Int,
+    ): ByteArray = respond(request) {
+        val buffer = Buffer()
+        takeWhile {
+            buffer.size < responseSize
+        }.collect {
+            buffer.write(it)
+        }
+        buffer.readByteArray(responseSize)
     }
 }
 
 /**
- * Provide a synchronous wrapper for a port
+ * Read response to a given message using [Source] abstraction
  */
-public fun Port.synchronous(mutex: Mutex = Mutex()): SynchronousPort = SynchronousPort(this, mutex)
+public suspend fun <R> SynchronousPort.respondAsSource(
+    request: ByteArray,
+    transform: suspend Source.() -> R,
+): R = respond(request) {
+    //suspend until the response is fully read
+    coroutineScope {
+        val buffer = Buffer()
+        val collectJob = onEach { buffer.write(it) }.launchIn(this)
+        val res = transform(buffer)
+        //cancel collection when the result is achieved
+        collectJob.cancel()
+        res
+    }
+}
+
+private class SynchronousOverAsynchronousPort(
+    val port: AsynchronousPort,
+    val mutex: Mutex,
+) : SynchronousPort {
+
+    override val context: Context get() = port.context
+
+    override fun open() {
+        if (!port.isOpen) port.open()
+    }
+
+    override val isOpen: Boolean get() = port.isOpen
+
+    override fun close() {
+        if (port.isOpen) port.close()
+    }
+
+    override suspend fun <R> respond(
+        request: ByteArray,
+        transform: suspend Flow<ByteArray>.() -> R,
+    ): R = mutex.withLock {
+        port.send(request)
+        transform(port.subscribe())
+    }
+}
+
+
+/**
+ * Provide a synchronous wrapper for an asynchronous port.
+ * Optionally provide external [mutex] for operation synchronization.
+ *
+ * If the [AsynchronousPort] is called directly, it could violate [SynchronousPort] contract
+ * of only one request running simultaneously.
+ */
+public fun AsynchronousPort.asSynchronousPort(mutex: Mutex = Mutex()): SynchronousPort =
+    SynchronousOverAsynchronousPort(this, mutex)
 
 /**
  * Send request and read incoming data blocks until the delimiter is encountered

controls-core/src/commonMain/kotlin/space/kscience/controls/ports/ioExtensions.kt

@@ -0,0 +1,24 @@
+package space.kscience.controls.ports
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.io.Buffer
+import kotlinx.io.Source
+import space.kscience.dataforge.io.Binary
+
+public fun Binary.readShort(position: Int): Short = read(position) { readShort() }
+
+/**
+ * Consume given flow of [ByteArray] as [Source]. The subscription is canceled when [scope] is closed.
+ */
+public fun Flow<ByteArray>.consumeAsSource(scope: CoroutineScope): Source {
+    val buffer = Buffer()
+    //subscription is canceled when the scope is canceled
+    onEach {
+        buffer.write(it)
+    }.launchIn(scope)
+
+    return buffer
+}

controls-core/src/commonMain/kotlin/space/kscience/controls/ports/phrases.kt

@@ -1,21 +1,27 @@
 package space.kscience.controls.ports
 
-import io.ktor.utils.io.core.BytePacketBuilder
-import io.ktor.utils.io.core.readBytes
-import io.ktor.utils.io.core.reset
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.transform
+import kotlinx.io.Buffer
+import kotlinx.io.readByteArray
 
 /**
  * Transform byte fragments into complete phrases using given delimiter. Not thread safe.
+ *
+ * TODO add type wrapper for phrases
  */
 public fun Flow<ByteArray>.withDelimiter(delimiter: ByteArray): Flow<ByteArray> {
     require(delimiter.isNotEmpty()) { "Delimiter must not be empty" }
 
-    val output = BytePacketBuilder()
+    val output = Buffer()
     var matcherPosition = 0
 
+    onCompletion {
+        output.close()
+    }
+
     return transform { chunk ->
         chunk.forEach { byte ->
             output.writeByte(byte)
@@ -24,9 +30,8 @@ public fun Flow<ByteArray>.withDelimiter(delimiter: ByteArray): Flow<ByteArray>
                 matcherPosition++
                 if (matcherPosition == delimiter.size) {
                     //full match achieved, sending result
-                    val bytes = output.build()
+                    emit(output.readByteArray())
-                    emit(bytes.readBytes())
+                    output.clear()
-                    output.reset()
                     matcherPosition = 0
                 }
             } else if (matcherPosition > 0) {
@@ -37,6 +42,31 @@ public fun Flow<ByteArray>.withDelimiter(delimiter: ByteArray): Flow<ByteArray>
     }
 }
 
+private fun Flow<ByteArray>.withFixedMessageSize(messageSize: Int): Flow<ByteArray> {
+    require(messageSize > 0) { "Message size should be positive" }
+
+    val output = Buffer()
+
+    onCompletion {
+        output.close()
+    }
+
+    return transform { chunk ->
+        val remaining: Int = (messageSize - output.size).toInt()
+        if (chunk.size >= remaining) {
+            output.write(chunk, endIndex = remaining)
+            emit(output.readByteArray())
+            output.clear()
+            //write the remaining chunk fragment
+            if(chunk.size> remaining) {
+                output.write(chunk, startIndex = remaining)
+            }
+        } else {
+            output.write(chunk)
+        }
+    }
+}
+
 /**
  * Transform byte fragments into utf-8 phrases using utf-8 delimiter
  */
@@ -47,9 +77,9 @@ public fun Flow<ByteArray>.withStringDelimiter(delimiter: String): Flow<String>
 /**
  * A flow of delimited phrases
  */
-public fun Port.delimitedIncoming(delimiter: ByteArray): Flow<ByteArray> = receiving().withDelimiter(delimiter)
+public fun AsynchronousPort.delimitedIncoming(delimiter: ByteArray): Flow<ByteArray> = subscribe().withDelimiter(delimiter)
 
 /**
  * A flow of delimited phrases with string content
  */
-public fun Port.stringsDelimitedIncoming(delimiter: String): Flow<String> = receiving().withStringDelimiter(delimiter)
+public fun AsynchronousPort.stringsDelimitedIncoming(delimiter: String): Flow<String> = subscribe().withStringDelimiter(delimiter)

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/DeviceBase.kt

@@ -1,36 +1,44 @@
 package space.kscience.controls.spec
 
 import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import space.kscience.controls.api.*
 import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.debug
 import space.kscience.dataforge.context.error
 import space.kscience.dataforge.context.logger
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.meta.get
+import space.kscience.dataforge.meta.int
 import kotlin.coroutines.CoroutineContext
 
-
+/**
+ * Write a meta [item] to [device]
+ */
 @OptIn(InternalDeviceAPI::class)
-private suspend fun <D : Device, T> WritableDevicePropertySpec<D, T>.writeMeta(device: D, item: Meta) {
+private suspend fun <D : Device, T> MutableDevicePropertySpec<D, T>.writeMeta(device: D, item: Meta) {
-    write(device, converter.metaToObject(item) ?: error("Meta $item could not be read with $converter"))
+    write(device, converter.readOrNull(item) ?: error("Meta $item could not be read with $converter"))
 }
 
+/**
+ * Read Meta item from the [device]
+ */
 @OptIn(InternalDeviceAPI::class)
 private suspend fun <D : Device, T> DevicePropertySpec<D, T>.readMeta(device: D): Meta? =
-    read(device)?.let(converter::objectToMeta)
+    read(device)?.let(converter::convert)
 
 
 private suspend fun <D : Device, I, O> DeviceActionSpec<D, I, O>.executeWithMeta(
     device: D,
     item: Meta,
 ): Meta? {
-    val arg: I = inputConverter.metaToObject(item) ?: error("Failed to convert $item with $inputConverter")
+    val arg: I = inputConverter.readOrNull(item) ?: error("Failed to convert $item with $inputConverter")
     val res = execute(device, arg)
-    return res?.let { outputConverter.objectToMeta(res) }
+    return res?.let { outputConverter.convert(res) }
 }
 
 
@@ -39,8 +47,8 @@ private suspend fun <D : Device, I, O> DeviceActionSpec<D, I, O>.executeWithMeta
  */
 public abstract class DeviceBase<D : Device>(
     final override val context: Context,
-    override val meta: Meta = Meta.EMPTY,
+    final override val meta: Meta = Meta.EMPTY,
-) : Device {
+) : CachingDevice {
 
     /**
      * Collection of property specifications
@@ -58,15 +66,29 @@ public abstract class DeviceBase<D : Device>(
     override val actionDescriptors: Collection<ActionDescriptor>
         get() = actions.values.map { it.descriptor }
 
-    override val coroutineContext: CoroutineContext by lazy {
+
-        context.newCoroutineContext(
+    private val sharedMessageFlow: MutableSharedFlow<DeviceMessage> = MutableSharedFlow(
-            SupervisorJob(context.coroutineContext[Job]) +
+        replay = meta["message.buffer"].int ?: 1000,
-                    CoroutineName("Device $this") +
+        onBufferOverflow = BufferOverflow.DROP_OLDEST
-                    CoroutineExceptionHandler { _, throwable ->
+    )
-                        logger.error(throwable) { "Exception in device $this job" }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override val coroutineContext: CoroutineContext = context.newCoroutineContext(
+        SupervisorJob(context.coroutineContext[Job]) +
+                CoroutineName("Device $id") +
+                CoroutineExceptionHandler { _, throwable ->
+                    launch {
+                        sharedMessageFlow.emit(
+                            DeviceErrorMessage(
+                                errorMessage = throwable.message,
+                                errorType = throwable::class.simpleName,
+                                errorStackTrace = throwable.stackTraceToString()
+                            )
+                        )
                     }
-        )
+                    logger.error(throwable) { "Exception in device $id" }
-    }
+                }
+    )
 
 
     /**
@@ -74,8 +96,6 @@ public abstract class DeviceBase<D : Device>(
      */
     private val logicalState: HashMap<String, Meta?> = HashMap()
 
-    private val sharedMessageFlow: MutableSharedFlow<DeviceMessage> = MutableSharedFlow()
-
     public override val messageFlow: SharedFlow<DeviceMessage> get() = sharedMessageFlow
 
     @Suppress("UNCHECKED_CAST")
@@ -87,7 +107,7 @@ public abstract class DeviceBase<D : Device>(
     /**
      * Update logical property state and notify listeners
      */
-    protected suspend fun updateLogical(propertyName: String, value: Meta?) {
+    protected suspend fun propertyChanged(propertyName: String, value: Meta?) {
         if (value != logicalState[propertyName]) {
             stateLock.withLock {
                 logicalState[propertyName] = value
@@ -99,10 +119,10 @@ public abstract class DeviceBase<D : Device>(
     }
 
     /**
-     * Update logical state using given [spec] and its convertor
+     * Notify the device that a property with [spec] value is changed
      */
-    public suspend fun <T> updateLogical(spec: DevicePropertySpec<D, T>, value: T) {
+    protected suspend fun <T> propertyChanged(spec: DevicePropertySpec<D, T>, value: T) {
-        updateLogical(spec.name, spec.converter.objectToMeta(value))
+        propertyChanged(spec.name, spec.converter.convert(value))
     }
 
     /**
@@ -112,7 +132,7 @@ public abstract class DeviceBase<D : Device>(
     override suspend fun readProperty(propertyName: String): Meta {
         val spec = properties[propertyName] ?: error("Property with name $propertyName not found")
         val meta = spec.readMeta(self) ?: error("Failed to read property $propertyName")
-        updateLogical(propertyName, meta)
+        propertyChanged(propertyName, meta)
         return meta
     }
 
@@ -122,7 +142,7 @@ public abstract class DeviceBase<D : Device>(
     public suspend fun readPropertyOrNull(propertyName: String): Meta? {
         val spec = properties[propertyName] ?: return null
         val meta = spec.readMeta(self) ?: return null
-        updateLogical(propertyName, meta)
+        propertyChanged(propertyName, meta)
         return meta
     }
 
@@ -135,15 +155,26 @@ public abstract class DeviceBase<D : Device>(
     }
 
     override suspend fun writeProperty(propertyName: String, value: Meta): Unit {
+        //bypass property setting if it already has that value
+        if (logicalState[propertyName] == value) {
+            logger.debug { "Skipping setting $propertyName to $value because value is already set" }
+            return
+        }
         when (val property = properties[propertyName]) {
             null -> {
-                //If there is a physical property with a given name, invalidate logical property and write physical one
+                //If there are no registered physical properties with given name, write a logical one.
-                updateLogical(propertyName, value)
+                propertyChanged(propertyName, value)
             }
 
-            is WritableDevicePropertySpec -> {
+            is MutableDevicePropertySpec -> {
+                //if there is a writeable property with a given name, invalidate logical and write physical
                 invalidate(propertyName)
                 property.writeMeta(self, value)
+                // perform read after writing if the writer did not set the value and the value is still in invalid state
+                if (logicalState[propertyName] == null) {
+                    val meta = property.readMeta(self)
+                    propertyChanged(propertyName, meta)
+                }
             }
 
             else -> {
@@ -157,22 +188,43 @@ public abstract class DeviceBase<D : Device>(
         return spec.executeWithMeta(self, argument ?: Meta.EMPTY)
     }
 
-    @DFExperimental
+    final override var lifecycleState: DeviceLifecycleState = DeviceLifecycleState.STOPPED
-    override var lifecycleState: DeviceLifecycleState = DeviceLifecycleState.INIT
+        private set
-        protected set
 
-    @OptIn(DFExperimental::class)
+
-    override suspend fun open() {
+    private suspend fun setLifecycleState(lifecycleState: DeviceLifecycleState) {
-        super.open()
+        this.lifecycleState = lifecycleState
-        lifecycleState = DeviceLifecycleState.OPEN
+        sharedMessageFlow.emit(
+            DeviceLifeCycleMessage(lifecycleState)
+        )
     }
 
-    @OptIn(DFExperimental::class)
+    protected open suspend fun onStart() {
-    override fun close() {
+
-        lifecycleState = DeviceLifecycleState.CLOSED
-        super.close()
     }
 
+    final override suspend fun start() {
+        if (lifecycleState == DeviceLifecycleState.STOPPED) {
+            super.start()
+            setLifecycleState(DeviceLifecycleState.STARTING)
+            onStart()
+            setLifecycleState(DeviceLifecycleState.STARTED)
+        } else {
+            logger.debug { "Device $this is already started" }
+        }
+    }
+
+    protected open suspend fun onStop() {
+
+    }
+
+    final override suspend fun stop() {
+        onStop()
+        setLifecycleState(DeviceLifecycleState.STOPPED)
+        super.stop()
+    }
+
+
     abstract override fun toString(): String
 
 }

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/DeviceBySpec.kt

@@ -16,15 +16,14 @@ public open class DeviceBySpec<D : Device>(
     override val properties: Map<String, DevicePropertySpec<D, *>> get() = spec.properties
     override val actions: Map<String, DeviceActionSpec<D, *, *>> get() = spec.actions
 
-    override suspend fun open(): Unit = with(spec) {
+    override suspend fun onStart(): Unit = with(spec) {
-        super.open()
         self.onOpen()
     }
 
-    override fun close(): Unit = with(spec) {
+    override suspend fun onStop(): Unit = with(spec){
         self.onClose()
-        super.close()
     }
 
+
     override fun toString(): String = "Device(spec=$spec)"
 }

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/DeviceMetaPropertySpec.kt

@@ -3,9 +3,9 @@ package space.kscience.controls.spec
 import space.kscience.controls.api.Device
 import space.kscience.controls.api.PropertyDescriptor
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.meta.transformations.MetaConverter
+import space.kscience.dataforge.meta.MetaConverter
 
-internal object DeviceMetaPropertySpec: DevicePropertySpec<Device,Meta> {
+internal object DeviceMetaPropertySpec : DevicePropertySpec<Device, Meta> {
     override val descriptor: PropertyDescriptor = PropertyDescriptor("@meta")
 
     override val converter: MetaConverter<Meta> = MetaConverter.meta

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/DevicePropertySpec.kt

@@ -4,11 +4,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
-import space.kscience.controls.api.ActionDescriptor
+import space.kscience.controls.api.*
-import space.kscience.controls.api.Device
+import space.kscience.dataforge.meta.MetaConverter
-import space.kscience.controls.api.PropertyChangedMessage
-import space.kscience.controls.api.PropertyDescriptor
-import space.kscience.dataforge.meta.transformations.MetaConverter
 
 
 /**
@@ -20,7 +17,7 @@ public annotation class InternalDeviceAPI
 /**
  * Specification for a device read-only property
  */
-public interface DevicePropertySpec<in D : Device, T> {
+public interface DevicePropertySpec<in D, T> {
     /**
      * Property descriptor
      */
@@ -44,7 +41,7 @@ public interface DevicePropertySpec<in D : Device, T> {
 public val DevicePropertySpec<*, *>.name: String get() = descriptor.name
 
 
-public interface WritableDevicePropertySpec<in D : Device, T> : DevicePropertySpec<D, T> {
+public interface MutableDevicePropertySpec<in D : Device, T> : DevicePropertySpec<D, T> {
     /**
      * Write physical value to a device
      */
@@ -53,7 +50,7 @@ public interface WritableDevicePropertySpec<in D : Device, T> : DevicePropertySp
 
 }
 
-public interface DeviceActionSpec<in D : Device, I, O> {
+public interface DeviceActionSpec<in D, I, O> {
     /**
      * Action descriptor
      */
@@ -75,30 +72,29 @@ public interface DeviceActionSpec<in D : Device, I, O> {
 public val DeviceActionSpec<*, *, *>.name: String get() = descriptor.name
 
 public suspend fun <T, D : Device> D.read(propertySpec: DevicePropertySpec<D, T>): T =
-    propertySpec.converter.metaToObject(readProperty(propertySpec.name)) ?: error("Property read result is not valid")
+    propertySpec.converter.readOrNull(readProperty(propertySpec.name)) ?: error("Property read result is not valid")
 
 /**
  * Read typed value and update/push event if needed.
  * Return null if property read is not successful or property is undefined.
  */
 public suspend fun <T, D : DeviceBase<D>> D.readOrNull(propertySpec: DevicePropertySpec<D, T>): T? =
-    readPropertyOrNull(propertySpec.name)?.let(propertySpec.converter::metaToObject)
+    readPropertyOrNull(propertySpec.name)?.let(propertySpec.converter::readOrNull)
 
-
+public suspend fun <T, D : Device> D.getOrRead(propertySpec: DevicePropertySpec<D, T>): T =
-public operator fun <T, D : Device> D.get(propertySpec: DevicePropertySpec<D, T>): T? =
+    propertySpec.converter.read(getOrReadProperty(propertySpec.name))
-    getProperty(propertySpec.name)?.let(propertySpec.converter::metaToObject)
 
 /**
  * Write typed property state and invalidate logical state
  */
-public suspend fun <T, D : Device> D.write(propertySpec: WritableDevicePropertySpec<D, T>, value: T) {
+public suspend fun <T, D : Device> D.write(propertySpec: MutableDevicePropertySpec<D, T>, value: T) {
-    writeProperty(propertySpec.name, propertySpec.converter.objectToMeta(value))
+    writeProperty(propertySpec.name, propertySpec.converter.convert(value))
 }
 
 /**
  * Fire and forget variant of property writing. Actual write is performed asynchronously on a [Device] scope
  */
-public operator fun <T, D : Device> D.set(propertySpec: WritableDevicePropertySpec<D, T>, value: T): Job = launch {
+public fun <T, D : Device> D.writeAsync(propertySpec: MutableDevicePropertySpec<D, T>, value: T): Job = launch {
     write(propertySpec, value)
 }
 
@@ -108,37 +104,39 @@ public operator fun <T, D : Device> D.set(propertySpec: WritableDevicePropertySp
 public fun <D : Device, T> D.propertyFlow(spec: DevicePropertySpec<D, T>): Flow<T> = messageFlow
     .filterIsInstance<PropertyChangedMessage>()
     .filter { it.property == spec.name }
-    .mapNotNull { spec.converter.metaToObject(it.value) }
+    .mapNotNull { spec.converter.read(it.value) }
 
 /**
  * A type safe property change listener. Uses the device [CoroutineScope].
  */
 public fun <D : Device, T> D.onPropertyChange(
     spec: DevicePropertySpec<D, T>,
+    scope: CoroutineScope = this,
     callback: suspend PropertyChangedMessage.(T) -> Unit,
 ): Job = messageFlow
     .filterIsInstance<PropertyChangedMessage>()
     .filter { it.property == spec.name }
     .onEach { change ->
-        val newValue = spec.converter.metaToObject(change.value)
+        val newValue = spec.converter.read(change.value)
         if (newValue != null) {
             change.callback(newValue)
         }
-    }.launchIn(this)
+    }.launchIn(scope)
 
 /**
  * Call [callback] on initial property value and each value change
  */
 public fun <D : Device, T> D.useProperty(
     spec: DevicePropertySpec<D, T>,
+    scope: CoroutineScope = this,
     callback: suspend (T) -> Unit,
-): Job = launch {
+): Job = scope.launch {
     callback(read(spec))
     messageFlow
         .filterIsInstance<PropertyChangedMessage>()
         .filter { it.property == spec.name }
         .collect { change ->
-            val newValue = spec.converter.metaToObject(change.value)
+            val newValue = spec.converter.readOrNull(change.value)
             if (newValue != null) {
                 callback(newValue)
             }
@@ -149,7 +147,7 @@ public fun <D : Device, T> D.useProperty(
 /**
  * Reset the logical state of a property
  */
-public suspend fun <D : Device> D.invalidate(propertySpec: DevicePropertySpec<D, *>) {
+public suspend fun <D : CachingDevice> D.invalidate(propertySpec: DevicePropertySpec<D, *>) {
     invalidate(propertySpec.name)
 }
 

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/DeviceSpec.kt

@@ -1,28 +1,26 @@
 package space.kscience.controls.spec
 
 import kotlinx.coroutines.withContext
-import space.kscience.controls.api.ActionDescriptor
+import space.kscience.controls.api.*
-import space.kscience.controls.api.Device
-import space.kscience.controls.api.PropertyDescriptor
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.meta.transformations.MetaConverter
+import space.kscience.dataforge.meta.MetaConverter
+import space.kscience.dataforge.meta.descriptors.MetaDescriptor
 import kotlin.properties.PropertyDelegateProvider
 import kotlin.properties.ReadOnlyProperty
-import kotlin.reflect.KMutableProperty1
 import kotlin.reflect.KProperty
-import kotlin.reflect.KProperty1
 
-public object UnitMetaConverter: MetaConverter<Unit>{
+public object UnitMetaConverter : MetaConverter<Unit> {
-    override fun metaToObject(meta: Meta): Unit = Unit
 
-    override fun objectToMeta(obj: Unit): Meta = Meta.EMPTY
+    override fun readOrNull(source: Meta): Unit = Unit
+
+    override fun convert(obj: Unit): Meta = Meta.EMPTY
 }
 
 public val MetaConverter.Companion.unit: MetaConverter<Unit> get() = UnitMetaConverter
 
 @OptIn(InternalDeviceAPI::class)
 public abstract class DeviceSpec<D : Device> {
-    //initializing meta property for everyone
+    //initializing the metadata property for everyone
     private val _properties = hashMapOf<String, DevicePropertySpec<D, *>>(
         DeviceMetaPropertySpec.name to DeviceMetaPropertySpec
     )
@@ -44,72 +42,30 @@ public abstract class DeviceSpec<D : Device> {
         return deviceProperty
     }
 
-    public fun <T> property(
-        converter: MetaConverter<T>,
-        readOnlyProperty: KProperty1<D, T>,
-        descriptorBuilder: PropertyDescriptor.() -> Unit = {},
-    ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<Any?, DevicePropertySpec<D, T>>> =
-        PropertyDelegateProvider { _, property ->
-            val deviceProperty = object : DevicePropertySpec<D, T> {
-                override val descriptor: PropertyDescriptor = PropertyDescriptor(property.name).apply {
-                    //TODO add type from converter
-                    writable = true
-                }.apply(descriptorBuilder)
-
-                override val converter: MetaConverter<T> = converter
-
-                override suspend fun read(device: D): T = withContext(device.coroutineContext) {
-                    readOnlyProperty.get(device)
-                }
-            }
-            registerProperty(deviceProperty)
-            ReadOnlyProperty { _, _ ->
-                deviceProperty
-            }
-        }
-
-    public fun <T> mutableProperty(
-        converter: MetaConverter<T>,
-        readWriteProperty: KMutableProperty1<D, T>,
-        descriptorBuilder: PropertyDescriptor.() -> Unit = {},
-    ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<Any?, WritableDevicePropertySpec<D, T>>> =
-        PropertyDelegateProvider { _, property ->
-            val deviceProperty = object : WritableDevicePropertySpec<D, T> {
-
-                override val descriptor: PropertyDescriptor = PropertyDescriptor(property.name).apply {
-                    //TODO add the type from converter
-                    writable = true
-                }.apply(descriptorBuilder)
-
-                override val converter: MetaConverter<T> = converter
-
-                override suspend fun read(device: D): T = withContext(device.coroutineContext) {
-                    readWriteProperty.get(device)
-                }
-
-                override suspend fun write(device: D, value: T): Unit = withContext(device.coroutineContext) {
-                    readWriteProperty.set(device, value)
-                }
-            }
-            registerProperty(deviceProperty)
-            ReadOnlyProperty { _, _ ->
-                deviceProperty
-            }
-        }
-
     public fun <T> property(
         converter: MetaConverter<T>,
         descriptorBuilder: PropertyDescriptor.() -> Unit = {},
         name: String? = null,
-        read: suspend D.() -> T?,
+        read: suspend D.(propertyName: String) -> T?,
     ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, T>>> =
         PropertyDelegateProvider { _: DeviceSpec<D>, property ->
             val propertyName = name ?: property.name
             val deviceProperty = object : DevicePropertySpec<D, T> {
-                override val descriptor: PropertyDescriptor = PropertyDescriptor(propertyName).apply(descriptorBuilder)
+
+                override val descriptor: PropertyDescriptor = PropertyDescriptor(propertyName).apply {
+                    converter.descriptor?.let { converterDescriptor ->
+                        metaDescriptor {
+                            from(converterDescriptor)
+                        }
+                    }
+                    fromSpec(property)
+                    descriptorBuilder()
+                }
+
                 override val converter: MetaConverter<T> = converter
 
-                override suspend fun read(device: D): T? = withContext(device.coroutineContext) { device.read() }
+                override suspend fun read(device: D): T? =
+                    withContext(device.coroutineContext) { device.read(propertyName) }
             }
             registerProperty(deviceProperty)
             ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, T>> { _, _ ->
@@ -121,23 +77,35 @@ public abstract class DeviceSpec<D : Device> {
         converter: MetaConverter<T>,
         descriptorBuilder: PropertyDescriptor.() -> Unit = {},
         name: String? = null,
-        read: suspend D.() -> T?,
+        read: suspend D.(propertyName: String) -> T?,
-        write: suspend D.(T) -> Unit,
+        write: suspend D.(propertyName: String, value: T) -> Unit,
-    ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, WritableDevicePropertySpec<D, T>>> =
+    ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, T>>> =
         PropertyDelegateProvider { _: DeviceSpec<D>, property: KProperty<*> ->
             val propertyName = name ?: property.name
-            val deviceProperty = object : WritableDevicePropertySpec<D, T> {
+            val deviceProperty = object : MutableDevicePropertySpec<D, T> {
-                override val descriptor: PropertyDescriptor = PropertyDescriptor(propertyName).apply(descriptorBuilder)
+                override val descriptor: PropertyDescriptor = PropertyDescriptor(
+                    propertyName,
+                    mutable = true
+                ).apply {
+                    converter.descriptor?.let { converterDescriptor ->
+                        metaDescriptor {
+                            from(converterDescriptor)
+                        }
+                    }
+                    fromSpec(property)
+                    descriptorBuilder()
+                }
                 override val converter: MetaConverter<T> = converter
 
-                override suspend fun read(device: D): T? = withContext(device.coroutineContext) { device.read() }
+                override suspend fun read(device: D): T? =
+                    withContext(device.coroutineContext) { device.read(propertyName) }
 
                 override suspend fun write(device: D, value: T): Unit = withContext(device.coroutineContext) {
-                    device.write(value)
+                    device.write(propertyName, value)
                 }
             }
-            _properties[propertyName] = deviceProperty
+            registerProperty(deviceProperty)
-            ReadOnlyProperty<DeviceSpec<D>, WritableDevicePropertySpec<D, T>> { _, _ ->
+            ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, T>> { _, _ ->
                 deviceProperty
             }
         }
@@ -155,10 +123,26 @@ public abstract class DeviceSpec<D : Device> {
         name: String? = null,
         execute: suspend D.(I) -> O,
     ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DeviceActionSpec<D, I, O>>> =
-        PropertyDelegateProvider { _: DeviceSpec<D>, property ->
+        PropertyDelegateProvider { _: DeviceSpec<D>, property: KProperty<*> ->
             val actionName = name ?: property.name
             val deviceAction = object : DeviceActionSpec<D, I, O> {
-                override val descriptor: ActionDescriptor = ActionDescriptor(actionName).apply(descriptorBuilder)
+                override val descriptor: ActionDescriptor = ActionDescriptor(actionName).apply {
+                    inputConverter.descriptor?.let { converterDescriptor ->
+                        inputMetaDescriptor = MetaDescriptor {
+                            from(converterDescriptor)
+                            from(inputMetaDescriptor)
+                        }
+                    }
+                    outputConverter.descriptor?.let { converterDescriptor ->
+                        outputMetaDescriptor = MetaDescriptor {
+                            from(converterDescriptor)
+                            from(outputMetaDescriptor)
+                        }
+                    }
+
+                    fromSpec(property)
+                    descriptorBuilder()
+                }
 
                 override val inputConverter: MetaConverter<I> = inputConverter
                 override val outputConverter: MetaConverter<O> = outputConverter
@@ -172,69 +156,52 @@ public abstract class DeviceSpec<D : Device> {
                 deviceAction
             }
         }
-
-    /**
-     * An action that takes [Meta] and returns [Meta]. No conversions are done
-     */
-    public fun metaAction(
-        descriptorBuilder: ActionDescriptor.() -> Unit = {},
-        name: String? = null,
-        execute: suspend D.(Meta) -> Meta,
-    ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DeviceActionSpec<D, Meta, Meta>>> =
-        action(
-            MetaConverter.Companion.meta,
-            MetaConverter.Companion.meta,
-            descriptorBuilder,
-            name
-        ) {
-            execute(it)
-        }
-
-    /**
-     * An action that takes no parameters and returns no values
-     */
-    public fun unitAction(
-        descriptorBuilder: ActionDescriptor.() -> Unit = {},
-        name: String? = null,
-        execute: suspend D.() -> Unit,
-    ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DeviceActionSpec<D, Unit, Unit>>> =
-        action(
-            MetaConverter.Companion.unit,
-            MetaConverter.Companion.unit,
-            descriptorBuilder,
-            name
-        ) {
-            execute()
-        }
 }
 
+/**
+ * An action that takes no parameters and returns no values
+ */
+public fun <D : Device> DeviceSpec<D>.unitAction(
+    descriptorBuilder: ActionDescriptor.() -> Unit = {},
+    name: String? = null,
+    execute: suspend D.() -> Unit,
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DeviceActionSpec<D, Unit, Unit>>> =
+    action(
+        MetaConverter.Companion.unit,
+        MetaConverter.Companion.unit,
+        descriptorBuilder,
+        name
+    ) {
+        execute()
+    }
+
+/**
+ * An action that takes [Meta] and returns [Meta]. No conversions are done
+ */
+public fun <D : Device> DeviceSpec<D>.metaAction(
+    descriptorBuilder: ActionDescriptor.() -> Unit = {},
+    name: String? = null,
+    execute: suspend D.(Meta) -> Meta,
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DeviceActionSpec<D, Meta, Meta>>> =
+    action(
+        MetaConverter.Companion.meta,
+        MetaConverter.Companion.meta,
+        descriptorBuilder,
+        name
+    ) {
+        execute(it)
+    }
+
 
 /**
- * Register a mutable logical property for a device
+ * Throw an exception if device does not have all properties and actions defined by this specification
  */
-@OptIn(InternalDeviceAPI::class)
+public fun DeviceSpec<*>.validate(device: Device) {
-public fun <T, D : DeviceBase<D>> DeviceSpec<D>.logicalProperty(
+    properties.map { it.value.descriptor }.forEach { specProperty ->
-    converter: MetaConverter<T>,
+        check(specProperty in device.propertyDescriptors) { "Property ${specProperty.name} not registered in ${device.id}" }
-    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+    }
-    name: String? = null,
-): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<Any?, WritableDevicePropertySpec<D, T>>> =
-    PropertyDelegateProvider { _, property ->
-        val deviceProperty = object : WritableDevicePropertySpec<D, T> {
-            val propertyName = name ?: property.name
-            override val descriptor: PropertyDescriptor = PropertyDescriptor(propertyName).apply {
-                //TODO add type from converter
-                writable = true
-            }.apply(descriptorBuilder)
 
-            override val converter: MetaConverter<T> = converter
+    actions.map { it.value.descriptor }.forEach { specAction ->
-
+        check(specAction in device.actionDescriptors) { "Action ${specAction.name} not registered in ${device.id}" }
-            override suspend fun read(device: D): T? = device.getProperty(propertyName)?.let(converter::metaToObject)
+    }
-
+}
-            override suspend fun write(device: D, value: T): Unit =
-                device.writeProperty(propertyName, converter.objectToMeta(value))
-        }
-        registerProperty(deviceProperty)
-        ReadOnlyProperty { _, _ ->
-            deviceProperty
-        }
-    }

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/deviceExtensions.kt

@@ -1,38 +1,46 @@
 package space.kscience.controls.spec
 
-import kotlinx.coroutines.Job
+import kotlinx.coroutines.*
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
 import space.kscience.controls.api.Device
+import space.kscience.controls.manager.getCoroutineDispatcher
 import kotlin.time.Duration
 
 /**
- * Perform a recurring asynchronous read action and return a flow of results.
+ * Do a recurring (with a fixed delay) task on a device.
- * The flow is lazy, so action is not performed unless flow is consumed.
- * The flow uses called context. In order to call it on device context, use `flowOn(coroutineContext)`.
- *
- * The flow is canceled when the device scope is canceled
  */
-public fun <D : Device, R> D.readRecurring(interval: Duration, reader: suspend D.() -> R): Flow<R> = flow {
+public fun <D : Device> D.doRecurring(
-    while (isActive) {
+    interval: Duration,
-        delay(interval)
+    debugTaskName: String? = null,
-        launch {
+    task: suspend D.() -> Unit,
-            emit(reader())
+): Job {
+    val taskName = debugTaskName ?: "task[${task.hashCode().toString(16)}]"
+    val dispatcher = getCoroutineDispatcher()
+    return launch(CoroutineName(taskName) + dispatcher) {
+        while (isActive) {
+            delay(interval)
+            //launch in parent scope to properly evaluate exceptions
+            this@doRecurring.launch(CoroutineName("$taskName-recurring") + dispatcher) {
+                task()
+            }
         }
     }
 }
 
 /**
- * Do a recurring (with a fixed delay) task on a device.
+ * Perform a recurring asynchronous read action and return a flow of results.
+ * The flow is lazy, so action is not performed unless flow is consumed.
+ * The flow uses caller context. To call it on device context, use `flowOn(coroutineContext)`.
+ *
+ * The flow is canceled when the device scope is canceled
  */
-public fun <D : Device> D.doRecurring(interval: Duration, task: suspend D.() -> Unit): Job = launch {
+public fun <D : Device, R> D.readRecurring(
-    while (isActive) {
+    interval: Duration,
-        delay(interval)
+    debugTaskName: String? = null,
-        launch {
+    reader: suspend D.() -> R,
-            task()
+): Flow<R> = flow {
-        }
+    doRecurring(interval, debugTaskName) {
+        emit(reader())
     }
 }

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/fromSpec.kt

@@ -0,0 +1,10 @@
+package space.kscience.controls.spec
+
+import space.kscience.controls.api.ActionDescriptor
+import space.kscience.controls.api.PropertyDescriptor
+import kotlin.reflect.KProperty
+
+
+internal expect fun PropertyDescriptor.fromSpec(property: KProperty<*>)
+
+internal expect fun ActionDescriptor.fromSpec(property: KProperty<*>)

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/misc.kt

@@ -1,23 +0,0 @@
-package space.kscience.controls.spec
-
-import space.kscience.dataforge.meta.*
-import space.kscience.dataforge.meta.transformations.MetaConverter
-import kotlin.time.Duration
-import kotlin.time.DurationUnit
-import kotlin.time.toDuration
-
-public fun Double.asMeta(): Meta = Meta(asValue())
-
-//TODO to be moved to DF
-public object DurationConverter : MetaConverter<Duration> {
-    override fun metaToObject(meta: Meta): Duration = meta.value?.double?.toDuration(DurationUnit.SECONDS)
-        ?: run {
-            val unit: DurationUnit = meta["unit"].enum<DurationUnit>() ?: DurationUnit.SECONDS
-            val value = meta[Meta.VALUE_KEY].double ?: error("No value present for Duration")
-            return@run value.toDuration(unit)
-        }
-
-    override fun objectToMeta(obj: Duration): Meta = obj.toDouble(DurationUnit.SECONDS).asMeta()
-}
-
-public val MetaConverter.Companion.duration: MetaConverter<Duration> get() = DurationConverter

controls-core/src/commonMain/kotlin/space/kscience/controls/spec/propertySpecDelegates.kt

@@ -4,22 +4,71 @@ import space.kscience.controls.api.Device
 import space.kscience.controls.api.PropertyDescriptor
 import space.kscience.controls.api.metaDescriptor
 import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaConverter
 import space.kscience.dataforge.meta.ValueType
-import space.kscience.dataforge.meta.transformations.MetaConverter
 import kotlin.properties.PropertyDelegateProvider
 import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KMutableProperty1
+import kotlin.reflect.KProperty1
+
+/**
+ * A read-only device property that delegates reading to a device [KProperty1]
+ */
+public fun <T, D : Device> DeviceSpec<D>.property(
+    converter: MetaConverter<T>,
+    readOnlyProperty: KProperty1<D, T>,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, T>>> = property(
+    converter,
+    descriptorBuilder,
+    name = readOnlyProperty.name,
+    read = { readOnlyProperty.get(this) }
+)
+
+/**
+ * Mutable property that delegates reading and writing to a device [KMutableProperty1]
+ */
+public fun <T, D : Device> DeviceSpec<D>.mutableProperty(
+    converter: MetaConverter<T>,
+    readWriteProperty: KMutableProperty1<D, T>,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, T>>> =
+    mutableProperty(
+        converter,
+        descriptorBuilder,
+        readWriteProperty.name,
+        read = { _ -> readWriteProperty.get(this) },
+        write = { _, value: T -> readWriteProperty.set(this, value) }
+    )
+
+/**
+ * Register a mutable logical property (without a corresponding physical state) for a device
+ */
+public fun <T, D : DeviceBase<D>> DeviceSpec<D>.logicalProperty(
+    converter: MetaConverter<T>,
+    descriptorBuilder: PropertyDescriptor.() -> Unit = {},
+    name: String? = null,
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, T>>> =
+    mutableProperty(
+        converter,
+        descriptorBuilder,
+        name,
+        read = { propertyName -> getProperty(propertyName)?.let(converter::readOrNull) },
+        write = { propertyName, value -> writeProperty(propertyName, converter.convert(value)) }
+    )
+
 
 //read only delegates
 
 public fun <D : Device> DeviceSpec<D>.booleanProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> Boolean?
+    read: suspend D.(propertyName: String) -> Boolean?
 ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, Boolean>>> = property(
     MetaConverter.boolean,
     {
         metaDescriptor {
-            type(ValueType.BOOLEAN)
+            valueType(ValueType.BOOLEAN)
         }
         descriptorBuilder()
     },
@@ -31,15 +80,15 @@ private inline fun numberDescriptor(
     crossinline descriptorBuilder: PropertyDescriptor.() -> Unit = {}
 ): PropertyDescriptor.() -> Unit = {
     metaDescriptor {
-        type(ValueType.NUMBER)
+        valueType(ValueType.NUMBER)
     }
     descriptorBuilder()
 }
 
 public fun <D : Device> DeviceSpec<D>.numberProperty(
-    name: String? = null,
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
-    read: suspend D.() -> Number?
+    name: String? = null,
+    read: suspend D.(propertyName: String) -> Number?
 ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, Number>>> = property(
     MetaConverter.number,
     numberDescriptor(descriptorBuilder),
@@ -50,7 +99,7 @@ public fun <D : Device> DeviceSpec<D>.numberProperty(
 public fun <D : Device> DeviceSpec<D>.doubleProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> Double?
+    read: suspend D.(propertyName: String) -> Double?
 ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, Double>>> = property(
     MetaConverter.double,
     numberDescriptor(descriptorBuilder),
@@ -61,12 +110,12 @@ public fun <D : Device> DeviceSpec<D>.doubleProperty(
 public fun <D : Device> DeviceSpec<D>.stringProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> String?
+    read: suspend D.(propertyName: String) -> String?
 ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, String>>> = property(
     MetaConverter.string,
     {
         metaDescriptor {
-            type(ValueType.STRING)
+            valueType(ValueType.STRING)
         }
         descriptorBuilder()
     },
@@ -77,12 +126,12 @@ public fun <D : Device> DeviceSpec<D>.stringProperty(
 public fun <D : Device> DeviceSpec<D>.metaProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> Meta?
+    read: suspend D.(propertyName: String) -> Meta?
 ): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, DevicePropertySpec<D, Meta>>> = property(
     MetaConverter.meta,
     {
         metaDescriptor {
-            type(ValueType.STRING)
+            valueType(ValueType.STRING)
         }
         descriptorBuilder()
     },
@@ -95,14 +144,14 @@ public fun <D : Device> DeviceSpec<D>.metaProperty(
 public fun <D : Device> DeviceSpec<D>.booleanProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> Boolean?,
+    read: suspend D.(propertyName: String) -> Boolean?,
-    write: suspend D.(Boolean) -> Unit
+    write: suspend D.(propertyName: String, value: Boolean) -> Unit
-): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, WritableDevicePropertySpec<D, Boolean>>> =
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, Boolean>>> =
     mutableProperty(
         MetaConverter.boolean,
         {
             metaDescriptor {
-                type(ValueType.BOOLEAN)
+                valueType(ValueType.BOOLEAN)
             }
             descriptorBuilder()
         },
@@ -115,31 +164,31 @@ public fun <D : Device> DeviceSpec<D>.booleanProperty(
 public fun <D : Device> DeviceSpec<D>.numberProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> Number,
+    read: suspend D.(propertyName: String) -> Number,
-    write: suspend D.(Number) -> Unit
+    write: suspend D.(propertyName: String, value: Number) -> Unit
-): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, WritableDevicePropertySpec<D, Number>>> =
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, Number>>> =
     mutableProperty(MetaConverter.number, numberDescriptor(descriptorBuilder), name, read, write)
 
 public fun <D : Device> DeviceSpec<D>.doubleProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> Double,
+    read: suspend D.(propertyName: String) -> Double,
-    write: suspend D.(Double) -> Unit
+    write: suspend D.(propertyName: String, value: Double) -> Unit
-): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, WritableDevicePropertySpec<D, Double>>> =
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, Double>>> =
     mutableProperty(MetaConverter.double, numberDescriptor(descriptorBuilder), name, read, write)
 
 public fun <D : Device> DeviceSpec<D>.stringProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> String,
+    read: suspend D.(propertyName: String) -> String,
-    write: suspend D.(String) -> Unit
+    write: suspend D.(propertyName: String, value: String) -> Unit
-): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, WritableDevicePropertySpec<D, String>>> =
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, String>>> =
     mutableProperty(MetaConverter.string, descriptorBuilder, name, read, write)
 
 public fun <D : Device> DeviceSpec<D>.metaProperty(
     descriptorBuilder: PropertyDescriptor.() -> Unit = {},
     name: String? = null,
-    read: suspend D.() -> Meta,
+    read: suspend D.(propertyName: String) -> Meta,
-    write: suspend D.(Meta) -> Unit
+    write: suspend D.(propertyName: String, value: Meta) -> Unit
-): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, WritableDevicePropertySpec<D, Meta>>> =
+): PropertyDelegateProvider<DeviceSpec<D>, ReadOnlyProperty<DeviceSpec<D>, MutableDevicePropertySpec<D, Meta>>> =
     mutableProperty(MetaConverter.meta, descriptorBuilder, name, read, write)

controls-core/src/commonTest/kotlin/space/kscience/controls/api/MessageTest.kt

@@ -1,9 +1,8 @@
 package space.kscience.controls.api
 
-import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import space.kscience.controls.spec.asMeta
+import space.kscience.controls.misc.asMeta
 import kotlin.test.Test
 import kotlin.test.assertEquals
 

controls-core/src/jsMain/kotlin/space/kscience/controls/spec/fromSpec.js.kt

@@ -0,0 +1,9 @@
+package space.kscience.controls.spec
+
+import space.kscience.controls.api.ActionDescriptor
+import space.kscience.controls.api.PropertyDescriptor
+import kotlin.reflect.KProperty
+
+internal actual fun PropertyDescriptor.fromSpec(property: KProperty<*>){}
+
+internal actual fun ActionDescriptor.fromSpec(property: KProperty<*>){}

controls-core/src/jvmMain/kotlin/space/kscience/controls/ports/ChannelPort.kt

@@ -1,19 +1,20 @@
 package space.kscience.controls.ports
 
 import kotlinx.coroutines.*
-import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.*
-import space.kscience.dataforge.context.error
-import space.kscience.dataforge.context.info
-import space.kscience.dataforge.context.logger
 import space.kscience.dataforge.meta.*
 import java.net.InetSocketAddress
 import java.nio.ByteBuffer
+import java.nio.channels.AsynchronousCloseException
 import java.nio.channels.ByteChannel
 import java.nio.channels.DatagramChannel
 import java.nio.channels.SocketChannel
 import kotlin.coroutines.CoroutineContext
 
-public fun ByteBuffer.toArray(limit: Int = limit()): ByteArray {
+/**
+ * Copy the contents of this buffer to an array
+ */
+public fun ByteBuffer.copyToArray(limit: Int = limit()): ByteArray {
     rewind()
     val response = ByteArray(limit)
     get(response)
@@ -26,32 +27,41 @@ public fun ByteBuffer.toArray(limit: Int = limit()): ByteArray {
  */
 public class ChannelPort(
     context: Context,
+    meta: Meta,
     coroutineContext: CoroutineContext = context.coroutineContext,
     channelBuilder: suspend () -> ByteChannel,
-) : AbstractPort(context, coroutineContext), AutoCloseable {
+) : AbstractAsynchronousPort(context, meta, coroutineContext), AutoCloseable {
-
-    private val futureChannel: Deferred<ByteChannel> = this.scope.async(Dispatchers.IO) {
-        channelBuilder()
-    }
 
     /**
      * A handler to await port connection
      */
-    public val startJob: Job get() = futureChannel
+    private val futureChannel: Deferred<ByteChannel> = scope.async(Dispatchers.IO, start = CoroutineStart.LAZY) {
+        channelBuilder()
+    }
 
-    private val listenerJob = this.scope.launch(Dispatchers.IO) {
+    private var listenerJob: Job? = null
-        val channel = futureChannel.await()
+
-        val buffer = ByteBuffer.allocate(1024)
+    override val isOpen: Boolean get() = listenerJob?.isActive == true
-        while (isActive) {
+
-            try {
+    override fun onOpen() {
-                val num = channel.read(buffer)
+        listenerJob = scope.launch(Dispatchers.IO) {
-                if (num > 0) {
+            val channel = futureChannel.await()
-                    receive(buffer.toArray(num))
+            val buffer = ByteBuffer.allocate(1024)
+            while (isActive && channel.isOpen) {
+                try {
+                    val num = channel.read(buffer)
+                    if (num > 0) {
+                        receive(buffer.copyToArray(num))
+                    }
+                    if (num < 0) cancel("The input channel is exhausted")
+                } catch (ex: Exception) {
+                    if (ex is AsynchronousCloseException) {
+                        logger.info { "Channel $channel closed" }
+                    } else {
+                        logger.error(ex) { "Channel read error, retrying in 1 second" }
+                        delay(1000)
+                    }
                 }
-                if (num < 0) cancel("The input channel is exhausted")
-            } catch (ex: Exception) {
-                logger.error(ex) { "Channel read error" }
-                delay(1000)
             }
         }
     }
@@ -62,46 +72,86 @@ public class ChannelPort(
 
     @OptIn(ExperimentalCoroutinesApi::class)
     override fun close() {
-        listenerJob.cancel()
+        listenerJob?.cancel()
         if (futureChannel.isCompleted) {
             futureChannel.getCompleted().close()
-        } else {
-            futureChannel.cancel()
         }
         super.close()
     }
 }
 
 /**
- * A [PortFactory] for TCP connections
+ * A [Factory] for TCP connections
  */
-public object TcpPort : PortFactory {
+public object TcpPort : Factory<AsynchronousPort> {
 
-    override val type: String = "tcp"
+    public fun build(
+        context: Context,
+        host: String,
+        port: Int,
+        coroutineContext: CoroutineContext = context.coroutineContext,
+    ): ChannelPort {
+        val meta = Meta {
+            "name" put "tcp://$host:$port"
+            "type" put "tcp"
+            "host" put host
+            "port" put port
+        }
+        return ChannelPort(context, meta, coroutineContext) {
+            SocketChannel.open(InetSocketAddress(host, port))
+        }
+    }
 
+    /**
+     * Create and open TCP port
+     */
     public fun open(
         context: Context,
         host: String,
         port: Int,
         coroutineContext: CoroutineContext = context.coroutineContext,
-    ): ChannelPort = ChannelPort(context, coroutineContext) {
+    ): ChannelPort = build(context, host, port, coroutineContext).apply { open() }
-        SocketChannel.open(InetSocketAddress(host, port))
-    }
 
     override fun build(context: Context, meta: Meta): ChannelPort {
         val host = meta["host"].string ?: "localhost"
         val port = meta["port"].int ?: error("Port value for TCP port is not defined in $meta")
-        return open(context, host, port)
+        return build(context, host, port)
     }
+
 }
 
 
 /**
- * A [PortFactory] for UDP connections
+ * A [Factory] for UDP connections
  */
-public object UdpPort : PortFactory {
+public object UdpPort : Factory<AsynchronousPort> {
 
-    override val type: String = "udp"
+    public fun build(
+        context: Context,
+        remoteHost: String,
+        remotePort: Int,
+        localPort: Int? = null,
+        localHost: String? = null,
+        coroutineContext: CoroutineContext = context.coroutineContext,
+    ): ChannelPort {
+        val meta = Meta {
+            "name" put "udp://$remoteHost:$remotePort"
+            "type" put "udp"
+            "remoteHost" put remoteHost
+            "remotePort" put remotePort
+            localHost?.let { "localHost" put it }
+            localPort?.let { "localPort" put it }
+        }
+        return ChannelPort(context, meta, coroutineContext) {
+            DatagramChannel.open().apply {
+                //bind the channel to a local port to receive messages
+                localPort?.let { bind(InetSocketAddress(localHost ?: "localhost", it)) }
+                //connect to remote port to send messages
+                connect(InetSocketAddress(remoteHost, remotePort.toInt()))
+                context.logger.info { "Connected to UDP $remotePort on $remoteHost" }
+            }
+        }
+    }
 
     /**
      * Connect a datagram channel to a remote host/port. If [localPort] is provided, it is used to bind local port for receiving messages.
@@ -112,22 +162,14 @@ public object UdpPort : PortFactory {
         remotePort: Int,
         localPort: Int? = null,
         localHost: String = "localhost",
-        coroutineContext: CoroutineContext = context.coroutineContext,
+    ): ChannelPort = build(context, remoteHost, remotePort, localPort, localHost).apply { open() }
-    ): ChannelPort = ChannelPort(context, coroutineContext) {
+
-        DatagramChannel.open().apply {
-            //bind the channel to a local port to receive messages
-            localPort?.let { bind(InetSocketAddress(localHost, localPort)) }
-            //connect to remote port to send messages
-            connect(InetSocketAddress(remoteHost, remotePort))
-            context.logger.info { "Connected to UDP $remotePort on $remoteHost" }
-        }
-    }
 
     override fun build(context: Context, meta: Meta): ChannelPort {
         val remoteHost by meta.string { error("Remote host is not specified") }
         val remotePort by meta.number { error("Remote port is not specified") }
         val localHost: String? by meta.string()
         val localPort: Int? by meta.int()
-        return open(context, remoteHost, remotePort.toInt(), localPort, localHost ?: "localhost")
+        return build(context, remoteHost, remotePort.toInt(), localPort, localHost)
     }
 }

controls-core/src/jvmMain/kotlin/space/kscience/controls/ports/JvmPortsPlugin.kt

@@ -6,7 +6,7 @@ import space.kscience.dataforge.context.PluginFactory
 import space.kscience.dataforge.context.PluginTag
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.names.Name
-import space.kscience.dataforge.names.parseAsName
+import space.kscience.dataforge.names.asName
 
 /**
  * A plugin for loading JVM nio-based ports
@@ -17,9 +17,9 @@ public class JvmPortsPlugin : AbstractPlugin() {
     override val tag: PluginTag get() = Companion.tag
 
     override fun content(target: String): Map<Name, Any> = when(target){
-        PortFactory.TYPE -> mapOf(
+        Ports.ASYNCHRONOUS_PORT_TYPE -> mapOf(
-            TcpPort.type.parseAsName() to TcpPort,
+            "tcp".asName() to TcpPort,
-            UdpPort.type.parseAsName() to UdpPort
+            "udp".asName() to UdpPort
         )
         else -> emptyMap()
     }

controls-core/src/jvmMain/kotlin/space/kscience/controls/ports/UdpSocketPort.kt

@@ -0,0 +1,59 @@
+package space.kscience.controls.ports
+
+import kotlinx.coroutines.*
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.meta.Meta
+import java.net.DatagramPacket
+import java.net.DatagramSocket
+import kotlin.coroutines.CoroutineContext
+
+/**
+ * A port based on [DatagramSocket] for cases, where [ChannelPort] does not work for some reason
+ */
+public class UdpSocketPort(
+    override val context: Context,
+    meta: Meta,
+    private val socket: DatagramSocket,
+    coroutineContext: CoroutineContext = context.coroutineContext,
+) : AbstractAsynchronousPort(context, meta, coroutineContext) {
+
+    private var listenerJob: Job? = null
+
+    override fun onOpen() {
+        listenerJob = context.launch(Dispatchers.IO) {
+            while (isActive) {
+                val buf = ByteArray(socket.receiveBufferSize)
+
+                val packet = DatagramPacket(
+                    buf,
+                    buf.size,
+                )
+                socket.receive(packet)
+
+                val bytes = packet.data.copyOfRange(
+                    packet.offset,
+                    packet.offset + packet.length
+                )
+                receive(bytes)
+            }
+        }
+    }
+
+    override fun close() {
+        listenerJob?.cancel()
+        super.close()
+    }
+
+    override val isOpen: Boolean get() = listenerJob?.isActive == true
+
+
+    override suspend fun write(data: ByteArray): Unit = withContext(Dispatchers.IO) {
+        val packet = DatagramPacket(
+            data,
+            data.size,
+            socket.remoteSocketAddress
+        )
+        socket.send(packet)
+    }
+
+}

controls-core/src/jvmMain/kotlin/space/kscience/controls/spec/fromSpec.jvm.kt

@@ -0,0 +1,19 @@
+package space.kscience.controls.spec
+
+import space.kscience.controls.api.ActionDescriptor
+import space.kscience.controls.api.PropertyDescriptor
+import space.kscience.dataforge.descriptors.Description
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.findAnnotation
+
+internal actual fun PropertyDescriptor.fromSpec(property: KProperty<*>) {
+    property.findAnnotation<Description>()?.let {
+        description = it.value
+    }
+}
+
+internal actual fun ActionDescriptor.fromSpec(property: KProperty<*>){
+    property.findAnnotation<Description>()?.let {
+        description = it.value
+    }
+}

controls-core/src/jvmTest/kotlin/space/kscience/controls/ports/AsynchronousPortIOTest.kt

@@ -0,0 +1,50 @@
+package space.kscience.controls.ports
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import space.kscience.dataforge.context.Global
+import kotlin.test.assertEquals
+
+
+internal class AsynchronousPortIOTest {
+
+    @Test
+    fun testDelimiteredByteArrayFlow() {
+        val flow = flowOf("bb?b", "ddd?", ":defgb?:ddf", "34fb?:--").map { it.encodeToByteArray() }
+        val chunked = flow.withDelimiter("?:".encodeToByteArray())
+        runBlocking {
+            val result = chunked.toList()
+            assertEquals(3, result.size)
+            assertEquals("bb?bddd?:", result[0].decodeToString())
+            assertEquals("defgb?:", result[1].decodeToString())
+            assertEquals("ddf34fb?:", result[2].decodeToString())
+        }
+    }
+
+    @Test
+    fun testUdpCommunication() = runTest {
+        val receiver = UdpPort.open(Global, "localhost", 8811, localPort = 8812)
+        val sender = UdpPort.open(Global, "localhost", 8812, localPort = 8811)
+
+        delay(30)
+        repeat(10) {
+            sender.send("Line number $it\n")
+        }
+
+        val res = receiver
+            .subscribe()
+            .withStringDelimiter("\n")
+            .take(10)
+            .toList()
+
+        assertEquals("Line number 3", res[3].trim())
+        receiver.close()
+        sender.close()
+    }
+}

controls-core/src/jvmTest/kotlin/space/kscience/controls/ports/PortIOTest.kt

@@ -1,25 +0,0 @@
-package space.kscience.controls.ports
-
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.toList
-import kotlinx.coroutines.runBlocking
-import org.junit.jupiter.api.Test
-import kotlin.test.assertEquals
-
-
-internal class PortIOTest{
-
-    @Test
-    fun testDelimiteredByteArrayFlow(){
-        val flow = flowOf("bb?b","ddd?",":defgb?:ddf","34fb?:--").map { it.encodeToByteArray() }
-        val chunked = flow.withDelimiter("?:".encodeToByteArray())
-        runBlocking {
-            val result = chunked.toList()
-            assertEquals(3, result.size)
-            assertEquals("bb?bddd?:",result[0].decodeToString())
-            assertEquals("defgb?:", result[1].decodeToString())
-            assertEquals("ddf34fb?:", result[2].decodeToString())
-        }
-    }
-}

controls-core/src/nativeMain/kotlin/space/kscience/controls/spec/fromSpec.native.kt

@@ -0,0 +1,9 @@
+package space.kscience.controls.spec
+
+import space.kscience.controls.api.ActionDescriptor
+import space.kscience.controls.api.PropertyDescriptor
+import kotlin.reflect.KProperty
+
+internal actual fun PropertyDescriptor.fromSpec(property: KProperty<*>) {}
+
+internal actual fun ActionDescriptor.fromSpec(property: KProperty<*>){}

controls-jupyter/README.md

@@ -0,0 +1,21 @@
+# Module controls-jupyter
+
+
+
+## Usage
+
+## Artifact:
+
+The Maven coordinates of this project are `space.kscience:controls-jupyter:0.4.0-dev-4`.
+
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("space.kscience:controls-jupyter:0.4.0-dev-4")
+}
+```

controls-jupyter/api/controls-jupyter.api

@@ -0,0 +1,8 @@
+public final class space/kscience/controls/jupyter/ControlsJupyter : space/kscience/visionforge/jupyter/VisionForgeIntegration {
+	public static final field Companion Lspace/kscience/controls/jupyter/ControlsJupyter$Companion;
+	public fun <init> ()V
+}
+
+public final class space/kscience/controls/jupyter/ControlsJupyter$Companion {
+}
+

controls-jupyter/build.gradle.kts

@@ -0,0 +1,18 @@
+plugins {
+    id("space.kscience.gradle.mpp")
+    `maven-publish`
+}
+
+kscience {
+    fullStack("js/controls-jupyter.js")
+    useKtor()
+    useContextReceivers()
+    jupyterLibrary("space.kscience.controls.jupyter.ControlsJupyter")
+    dependencies {
+        implementation(projects.controlsVision)
+        implementation(libs.visionforge.jupiter)
+    }
+    jvmMain {
+        implementation(spclibs.logback.classic)
+    }
+}

controls-jupyter/src/jsMain/kotlin/commonJupyter.kt

@@ -0,0 +1,14 @@
+import space.kscience.visionforge.html.runVisionClient
+import space.kscience.visionforge.jupyter.VFNotebookClient
+import space.kscience.visionforge.markup.MarkupPlugin
+import space.kscience.visionforge.plotly.PlotlyPlugin
+
+public fun main(): Unit = runVisionClient {
+//    plugin(DeviceManager)
+//    plugin(ClockManager)
+    plugin(PlotlyPlugin)
+    plugin(MarkupPlugin)
+//    plugin(TableVisionJsPlugin)
+    plugin(VFNotebookClient)
+}
+

controls-jupyter/src/jvmMain/kotlin/ControlsJupyter.kt

@@ -0,0 +1,71 @@
+package space.kscience.controls.jupyter
+
+import org.jetbrains.kotlinx.jupyter.api.declare
+import org.jetbrains.kotlinx.jupyter.api.libraries.resources
+import space.kscience.controls.manager.ClockManager
+import space.kscience.controls.manager.DeviceManager
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.plotly.Plot
+import space.kscience.visionforge.jupyter.VisionForge
+import space.kscience.visionforge.jupyter.VisionForgeIntegration
+import space.kscience.visionforge.markup.MarkupPlugin
+import space.kscience.visionforge.plotly.PlotlyPlugin
+import space.kscience.visionforge.plotly.asVision
+import space.kscience.visionforge.visionManager
+
+
+@OptIn(DFExperimental::class)
+public class ControlsJupyter : VisionForgeIntegration(CONTEXT.visionManager) {
+
+    override fun Builder.afterLoaded(vf: VisionForge) {
+
+        resources {
+            js("controls-jupyter") {
+                classPath("js/controls-jupyter.js")
+            }
+        }
+
+        onLoaded {
+            declare("context" to CONTEXT)
+        }
+
+        import(
+            "kotlin.time.*",
+            "kotlin.time.Duration.Companion.milliseconds",
+            "kotlin.time.Duration.Companion.seconds",
+//            "space.kscience.tables.*",
+            "space.kscience.dataforge.meta.*",
+            "space.kscience.dataforge.context.*",
+            "space.kscience.plotly.*",
+            "space.kscience.plotly.models.*",
+            "space.kscience.visionforge.plotly.*",
+            "space.kscience.controls.manager.*",
+            "space.kscience.controls.constructor.*",
+            "space.kscience.controls.vision.*",
+            "space.kscience.controls.spec.*"
+        )
+
+//        render<Table<*>> { table ->
+//            vf.produceHtml {
+//                vision { table.toVision() }
+//            }
+//        }
+
+        render<Plot> { plot ->
+            vf.produceHtml {
+                vision { plot.asVision() }
+            }
+        }
+    }
+
+    public companion object {
+        private val CONTEXT: Context = Context("controls-jupyter") {
+            plugin(DeviceManager)
+            plugin(ClockManager)
+            plugin(PlotlyPlugin)
+//            plugin(TableVisionPlugin)
+            plugin(MarkupPlugin)
+        }
+    }
+}

controls-magix/README.md

@@ -12,18 +12,16 @@ Magix service for binding controls devices (both as RPC client and server)
 
 ## Artifact:
 
-The Maven coordinates of this project are `space.kscience:controls-magix:0.2.0`.
+The Maven coordinates of this project are `space.kscience:controls-magix:0.4.0-dev-4`.
 
 **Gradle Kotlin DSL:**
 ```kotlin
 repositories {
     maven("https://repo.kotlin.link")
-    //uncomment to access development builds
-    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
     mavenCentral()
 }
 
 dependencies {
-    implementation("space.kscience:controls-magix:0.2.0")
+    implementation("space.kscience:controls-magix:0.4.0-dev-4")
 }
 ```

controls-magix/build.gradle.kts

@@ -12,13 +12,25 @@ description = """
 kscience {
     jvm()
     js()
+    native()
+    useCoroutines()
     useSerialization {
         json()
     }
-    dependencies {
+
+    commonMain {
         api(projects.magix.magixApi)
         api(projects.controlsCore)
-        api("com.benasher44:uuid:0.8.0")
+        api(libs.uuid)
+    }
+
+    jvmTest{
+        implementation(spclibs.logback.classic)
+        implementation(projects.magix.magixServer)
+        implementation(projects.magix.magixRsocket)
+        implementation(spclibs.ktor.server.cio)
+        implementation(spclibs.ktor.server.websockets)
+        implementation(spclibs.ktor.client.cio)
     }
 }
 

controls-magix/src/commonMain/kotlin/space/kscience/controls/client/DeviceClient.kt

@@ -1,12 +1,17 @@
 package space.kscience.controls.client
 
 import com.benasher44.uuid.uuid4
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.newCoroutineContext
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import space.kscience.controls.api.*
 import space.kscience.controls.manager.DeviceManager
+import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.controls.spec.name
 import space.kscience.dataforge.context.Context
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.misc.DFExperimental
@@ -21,46 +26,41 @@ private fun stringUID() = uuid4().leastSignificantBits.toString(16)
 /**
  * A remote accessible device that relies on connection via Magix
  */
-public class DeviceClient(
+public class DeviceClient internal constructor(
     override val context: Context,
     private val deviceName: Name,
+    propertyDescriptors: Collection<PropertyDescriptor>,
+    actionDescriptors: Collection<ActionDescriptor>,
     incomingFlow: Flow<DeviceMessage>,
     private val send: suspend (DeviceMessage) -> Unit,
-) : Device {
+) : CachingDevice {
 
-    @OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+
-    override val coroutineContext: CoroutineContext = newCoroutineContext(context.coroutineContext)
+    override var actionDescriptors: Collection<ActionDescriptor> = actionDescriptors
+        internal set
+
+    override var propertyDescriptors: Collection<PropertyDescriptor> = propertyDescriptors
+        internal set
+
+    override val coroutineContext: CoroutineContext = context.coroutineContext + Job(context.coroutineContext[Job])
 
     private val mutex = Mutex()
 
     private val propertyCache = HashMap<String, Meta>()
 
-    override var propertyDescriptors: Collection<PropertyDescriptor> = emptyList()
-        private set
-
-    override var actionDescriptors: Collection<ActionDescriptor> = emptyList()
-        private set
-
     private val flowInternal = incomingFlow.filter {
         it.sourceDevice == deviceName
-    }.shareIn(this, started = SharingStarted.Eagerly).also {
+    }.onEach { message ->
-        it.onEach { message ->
+        when (message) {
-            when (message) {
+            is PropertyChangedMessage -> mutex.withLock {
-                is PropertyChangedMessage -> mutex.withLock {
+                propertyCache[message.property] = message.value
-                    propertyCache[message.property] = message.value
-                }
-
-                is DescriptionMessage -> mutex.withLock {
-                    propertyDescriptors = message.properties
-                    actionDescriptors = message.actions
-                }
-
-                else -> {
-                    //ignore
-                }
             }
-        }.launchIn(this)
+
-    }
+            else -> {
+                //ignore
+            }
+        }
+    }.shareIn(this, started = SharingStarted.Eagerly)
 
     override val messageFlow: Flow<DeviceMessage> get() = flowInternal
 
@@ -69,7 +69,7 @@ public class DeviceClient(
         send(
             PropertyGetMessage(propertyName, targetDevice = deviceName)
         )
-        return flowInternal.filterIsInstance<PropertyChangedMessage>().first {
+        return messageFlow.filterIsInstance<PropertyChangedMessage>().first {
             it.property == propertyName
         }.value
     }
@@ -93,25 +93,181 @@ public class DeviceClient(
         send(
             ActionExecuteMessage(actionName, argument, id, targetDevice = deviceName)
         )
-        return flowInternal.filterIsInstance<ActionResultMessage>().first {
+        return messageFlow.filterIsInstance<ActionResultMessage>().first {
             it.action == actionName && it.requestId == id
         }.result
     }
 
+    private val lifecycleStateFlow = messageFlow.filterIsInstance<DeviceLifeCycleMessage>()
+        .map { it.state }.stateIn(this, started = SharingStarted.Eagerly, DeviceLifecycleState.STARTED)
+
     @DFExperimental
-    override val lifecycleState: DeviceLifecycleState = DeviceLifecycleState.OPEN
+    override val lifecycleState: DeviceLifecycleState get() = lifecycleStateFlow.value
 }
 
 /**
  * Connect to a remote device via this endpoint.
  *
  * @param context a [Context] to run device in
- * @param endpointName the name of endpoint in Magix to connect to
+ * @param thisEndpoint the name of this endpoint
+ * @param deviceEndpoint the name of endpoint in Magix to connect to
  * @param deviceName the name of device within endpoint
  */
-public fun MagixEndpoint.remoteDevice(context: Context, endpointName: String, deviceName: Name): DeviceClient {
+public suspend fun MagixEndpoint.remoteDevice(
-    val subscription = subscribe(DeviceManager.magixFormat, originFilter = listOf(endpointName)).map { it.second }
+    context: Context,
-    return DeviceClient(context, deviceName, subscription) {
+    thisEndpoint: String,
-        send(DeviceManager.magixFormat, it, endpointName, id = stringUID())
+    deviceEndpoint: String,
+    deviceName: Name,
+): DeviceClient = coroutineScope {
+    val subscription = subscribe(DeviceManager.magixFormat, originFilter = listOf(deviceEndpoint))
+        .map { it.second }
+        .filter {
+            it.sourceDevice == null || it.sourceDevice == deviceName
+        }
+
+    val deferredDescriptorMessage = CompletableDeferred<DescriptionMessage>()
+
+    launch {
+        deferredDescriptorMessage.complete(
+            subscription.filterIsInstance<DescriptionMessage>().first()
+        )
     }
+
+    send(
+        format = DeviceManager.magixFormat,
+        payload = GetDescriptionMessage(targetDevice = deviceName),
+        source = thisEndpoint,
+        target = deviceEndpoint,
+        id = stringUID()
+    )
+
+
+    val descriptionMessage = deferredDescriptorMessage.await()
+
+    DeviceClient(
+        context = context,
+        deviceName = deviceName,
+        propertyDescriptors = descriptionMessage.properties,
+        actionDescriptors = descriptionMessage.actions,
+        incomingFlow = subscription
+    ) {
+        send(
+            format = DeviceManager.magixFormat,
+            payload = it,
+            source = thisEndpoint,
+            target = deviceEndpoint,
+            id = stringUID()
+        )
+    }
+}
+
+/**
+ * Create a dynamic [DeviceHub] from incoming messages
+ */
+public suspend fun MagixEndpoint.remoteDeviceHub(
+    context: Context,
+    thisEndpoint: String,
+    deviceEndpoint: String,
+): DeviceHub {
+    val devices = mutableMapOf<Name, DeviceClient>()
+    val subscription = subscribe(DeviceManager.magixFormat, originFilter = listOf(deviceEndpoint)).map { it.second }
+    subscription.filterIsInstance<DescriptionMessage>().onEach { descriptionMessage ->
+        devices.getOrPut(descriptionMessage.sourceDevice) {
+            DeviceClient(
+                context = context,
+                deviceName = descriptionMessage.sourceDevice,
+                propertyDescriptors = descriptionMessage.properties,
+                actionDescriptors = descriptionMessage.actions,
+                incomingFlow = subscription
+            ) {
+                send(
+                    format = DeviceManager.magixFormat,
+                    payload = it,
+                    source = thisEndpoint,
+                    target = deviceEndpoint,
+                    id = stringUID()
+                )
+            }
+        }.run {
+            propertyDescriptors = descriptionMessage.properties
+        }
+    }.launchIn(context)
+
+
+    send(
+        format = DeviceManager.magixFormat,
+        payload = GetDescriptionMessage(targetDevice = null),
+        source = thisEndpoint,
+        target = deviceEndpoint,
+        id = stringUID()
+    )
+
+    return DeviceHub(devices)
+}
+
+/**
+ * Request a description update for all devices on an endpoint
+ */
+public suspend fun MagixEndpoint.requestDeviceUpdate(
+    thisEndpoint: String,
+    deviceEndpoint: String,
+) {
+    send(
+        format = DeviceManager.magixFormat,
+        payload = GetDescriptionMessage(),
+        source = thisEndpoint,
+        target = deviceEndpoint,
+        id = stringUID()
+    )
+}
+
+/**
+ * Subscribe on specific property of a device without creating a device
+ */
+public fun <T> MagixEndpoint.controlsPropertyFlow(
+    endpointName: String,
+    deviceName: Name,
+    propertySpec: DevicePropertySpec<*, T>,
+): Flow<T> {
+    val subscription = subscribe(DeviceManager.magixFormat, originFilter = listOf(endpointName)).map { it.second }
+
+    return subscription.filterIsInstance<PropertyChangedMessage>()
+        .filter { message ->
+            message.sourceDevice == deviceName && message.property == propertySpec.name
+        }.map {
+            propertySpec.converter.read(it.value)
+        }
+}
+
+public suspend fun <T> MagixEndpoint.sendControlsPropertyChange(
+    sourceEndpointName: String,
+    targetEndpointName: String,
+    deviceName: Name,
+    propertySpec: DevicePropertySpec<*, T>,
+    value: T,
+) {
+    val message = PropertySetMessage(
+        property = propertySpec.name,
+        value = propertySpec.converter.convert(value),
+        targetDevice = deviceName
+    )
+    send(DeviceManager.magixFormat, message, source = sourceEndpointName, target = targetEndpointName)
+}
+
+/**
+ * Subscribe on property change messages together with property values
+ */
+public fun <T> MagixEndpoint.controlsPropertyMessageFlow(
+    endpointName: String,
+    deviceName: Name,
+    propertySpec: DevicePropertySpec<*, T>,
+): Flow<Pair<PropertyChangedMessage, T>> {
+    val subscription = subscribe(DeviceManager.magixFormat, originFilter = listOf(endpointName)).map { it.second }
+
+    return subscription.filterIsInstance<PropertyChangedMessage>()
+        .filter { message ->
+            message.sourceDevice == deviceName && message.property == propertySpec.name
+        }.map {
+            it to propertySpec.converter.read(it.value)
+        }
 }

controls-magix/src/commonMain/kotlin/space/kscience/controls/client/clientPropertyAccess.kt

@@ -0,0 +1,82 @@
+package space.kscience.controls.client
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import space.kscience.controls.api.PropertyChangedMessage
+import space.kscience.controls.api.getOrReadProperty
+import space.kscience.controls.spec.DeviceActionSpec
+import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.controls.spec.MutableDevicePropertySpec
+import space.kscience.controls.spec.name
+import space.kscience.dataforge.meta.Meta
+
+
+/**
+ * An accessor that allows DeviceClient to connect to any property without type checks
+ */
+public suspend fun <T> DeviceClient.read(propertySpec: DevicePropertySpec<*, T>): T =
+    propertySpec.converter.readOrNull(readProperty(propertySpec.name)) ?: error("Property read result is not valid")
+
+public suspend fun <T> DeviceClient.request(propertySpec: DevicePropertySpec<*, T>): T =
+    propertySpec.converter.read(getOrReadProperty(propertySpec.name))
+
+public fun <T> DeviceClient.getCached(propertySpec: DevicePropertySpec<*, T>): T? =
+    getProperty(propertySpec.name)?.let { propertySpec.converter.read(it) }
+
+
+public suspend fun <T> DeviceClient.write(propertySpec: MutableDevicePropertySpec<*, T>, value: T) {
+    writeProperty(propertySpec.name, propertySpec.converter.convert(value))
+}
+
+public fun <T> DeviceClient.writeAsync(propertySpec: MutableDevicePropertySpec<*, T>, value: T): Job = launch {
+    write(propertySpec, value)
+}
+
+public fun <T> DeviceClient.propertyFlow(spec: DevicePropertySpec<*, T>): Flow<T> = messageFlow
+    .filterIsInstance<PropertyChangedMessage>()
+    .filter { it.property == spec.name }
+    .mapNotNull { spec.converter.readOrNull(it.value) }
+
+public fun <T> DeviceClient.onPropertyChange(
+    spec: DevicePropertySpec<*, T>,
+    scope: CoroutineScope = this,
+    callback: suspend PropertyChangedMessage.(T) -> Unit,
+): Job = messageFlow
+    .filterIsInstance<PropertyChangedMessage>()
+    .filter { it.property == spec.name }
+    .onEach { change ->
+        val newValue = spec.converter.readOrNull(change.value)
+        if (newValue != null) {
+            change.callback(newValue)
+        }
+    }.launchIn(scope)
+
+public fun <T> DeviceClient.useProperty(
+    spec: DevicePropertySpec<*, T>,
+    scope: CoroutineScope = this,
+    callback: suspend (T) -> Unit,
+): Job = scope.launch {
+    callback(read(spec))
+    messageFlow
+        .filterIsInstance<PropertyChangedMessage>()
+        .filter { it.property == spec.name }
+        .collect { change ->
+            val newValue = spec.converter.readOrNull(change.value)
+            if (newValue != null) {
+                callback(newValue)
+            }
+        }
+}
+
+public suspend fun <I, O> DeviceClient.execute(actionSpec: DeviceActionSpec<*, I, O>, input: I): O {
+    val inputMeta = actionSpec.inputConverter.convert(input)
+    val res = execute(actionSpec.name, inputMeta)
+    return actionSpec.outputConverter.read(res ?: Meta.EMPTY)
+}
+
+public suspend fun <O> DeviceClient.execute(actionSpec: DeviceActionSpec<*, Unit, O>): O {
+    val res = execute(actionSpec.name, Meta.EMPTY)
+    return actionSpec.outputConverter.read(res ?: Meta.EMPTY)
+}

controls-magix/src/commonMain/kotlin/space/kscience/controls/client/controlsMagix.kt

@@ -1,5 +1,7 @@
 package space.kscience.controls.client
 
+import com.benasher44.uuid.uuid4
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.launchIn
@@ -12,6 +14,8 @@ import space.kscience.controls.manager.respondHubMessage
 import space.kscience.dataforge.context.error
 import space.kscience.dataforge.context.logger
 import space.kscience.magix.api.*
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
 
 
 internal val controlsMagixFormat: MagixFormat<DeviceMessage> = MagixFormat(
@@ -27,22 +31,25 @@ public val DeviceManager.Companion.magixFormat: MagixFormat<DeviceMessage> get()
 internal fun generateId(request: MagixMessage): String = if (request.id != null) {
     "${request.id}.response"
 } else {
-    "controls[${request.payload.hashCode().toString(16)}"
+    uuid4().leastSignificantBits.toULong().toString(16)
 }
 
 /**
  * Communicate with server in [Magix format](https://github.com/waltz-controls/rfc/tree/master/1)
+ *
+ * Accepts messages with target that equals [endpointID] or null (broadcast messages)
  */
 public fun DeviceManager.launchMagixService(
     endpoint: MagixEndpoint,
-    endpointID: String = controlsMagixFormat.defaultFormat,
+    endpointID: String,
-): Job = context.launch {
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
-    endpoint.subscribe(controlsMagixFormat, targetFilter = listOf(endpointID)).onEach { (request, payload) ->
+): Job = context.launch(coroutineContext) {
-        val responsePayload = respondHubMessage(payload)
+    endpoint.subscribe(controlsMagixFormat, targetFilter = listOf(endpointID, null)).onEach { (request, payload) ->
-        if (responsePayload != null) {
+        val responsePayload: List<DeviceMessage> = respondHubMessage(payload)
+        responsePayload.forEach {
             endpoint.send(
                 format = controlsMagixFormat,
-                payload = responsePayload,
+                payload = it,
                 source = endpointID,
                 target = request.sourceEndpoint,
                 id = generateId(request),
@@ -50,10 +57,10 @@ public fun DeviceManager.launchMagixService(
             )
         }
     }.catch { error ->
-        logger.error(error) { "Error while responding to message: ${error.message}" }
+        if (error !is CancellationException) logger.error(error) { "Error while responding to message: ${error.message}" }
     }.launchIn(this)
 
-    hubMessageFlow(this).onEach { payload ->
+    hubMessageFlow().onEach { payload ->
         endpoint.send(
             format = controlsMagixFormat,
             payload = payload,

controls-magix/src/commonMain/kotlin/space/kscience/controls/client/tangoMagix.kt

@@ -5,12 +5,12 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
-import space.kscience.controls.api.get
 import space.kscience.controls.api.getOrReadProperty
 import space.kscience.controls.manager.DeviceManager
 import space.kscience.dataforge.context.error
 import space.kscience.dataforge.context.logger
 import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.names.get
 import space.kscience.magix.api.*
 
 public const val TANGO_MAGIX_FORMAT: String = "tango"
@@ -88,7 +88,7 @@ public fun DeviceManager.launchTangoMagix(
     return context.launch {
         endpoint.subscribe(tangoMagixFormat).onEach { (request, payload) ->
             try {
-                val device = get(payload.device)
+                val device = devices[payload.device] ?: error("Device ${payload.device} not found")
                 when (payload.action) {
                     TangoAction.read -> {
                         val value = device.getOrReadProperty(payload.name)
@@ -99,6 +99,7 @@ public fun DeviceManager.launchTangoMagix(
                             )
                         }
                     }
+
                     TangoAction.write -> {
                         payload.value?.let { value ->
                             device.writeProperty(payload.name, value)
@@ -112,6 +113,7 @@ public fun DeviceManager.launchTangoMagix(
                             )
                         }
                     }
+
                     TangoAction.exec -> {
                         val result = device.execute(payload.name, payload.argin)
                         respond(request, payload) { requestPayload ->
@@ -121,6 +123,7 @@ public fun DeviceManager.launchTangoMagix(
                             )
                         }
                     }
+
                     TangoAction.pipe -> TODO("Pipe not implemented")
                 }
             } catch (ex: Exception) {

controls-magix/src/commonTest/kotlin/space/kscience/controls/client/RemoteDeviceConnect.kt

@@ -0,0 +1,130 @@
+package space.kscience.controls.client
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import space.kscience.controls.api.DeviceHub
+import space.kscience.controls.api.DeviceMessage
+import space.kscience.controls.manager.DeviceManager
+import space.kscience.controls.manager.hubMessageFlow
+import space.kscience.controls.manager.install
+import space.kscience.controls.manager.respondHubMessage
+import space.kscience.controls.spec.*
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.Factory
+import space.kscience.dataforge.context.request
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.get
+import space.kscience.dataforge.meta.int
+import space.kscience.dataforge.names.asName
+import space.kscience.magix.api.MagixEndpoint
+import space.kscience.magix.api.MagixMessage
+import space.kscience.magix.api.MagixMessageFilter
+import kotlin.random.Random
+import kotlin.test.Test
+import kotlin.test.assertContains
+import kotlin.test.assertEquals
+import kotlin.time.Duration.Companion.milliseconds
+
+class VirtualMagixEndpoint(val hub: DeviceHub) : MagixEndpoint {
+
+    private val additionalMessages = MutableSharedFlow<DeviceMessage>(1)
+
+    override fun subscribe(
+        filter: MagixMessageFilter,
+    ): Flow<MagixMessage> = merge(hub.hubMessageFlow(), additionalMessages).map {
+        MagixMessage(
+            format = DeviceManager.magixFormat.defaultFormat,
+            payload = MagixEndpoint.magixJson.encodeToJsonElement(DeviceManager.magixFormat.serializer, it),
+            sourceEndpoint = "device",
+        )
+    }
+
+    override suspend fun broadcast(message: MagixMessage) {
+        hub.respondHubMessage(
+            Json.decodeFromJsonElement(DeviceManager.magixFormat.serializer, message.payload)
+        ).forEach {
+            additionalMessages.emit(it)
+        }
+    }
+
+    override fun close() {
+        //
+    }
+}
+
+
+internal class RemoteDeviceConnect {
+
+    class TestDevice(context: Context, meta: Meta) : DeviceBySpec<TestDevice>(TestDevice, context, meta) {
+        private val rng = Random(meta["seed"].int ?: 0)
+
+        private val randomValue get() = rng.nextDouble()
+
+        companion object : DeviceSpec<TestDevice>(), Factory<TestDevice> {
+
+            override fun build(context: Context, meta: Meta): TestDevice = TestDevice(context, meta)
+
+            val value by doubleProperty { randomValue }
+
+            override suspend fun TestDevice.onOpen() {
+                doRecurring((meta["delay"].int ?: 10).milliseconds) {
+                    read(value)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun deviceClient() = runTest {
+        val context = Context {
+            plugin(DeviceManager)
+        }
+        val deviceManager = context.request(DeviceManager)
+
+        deviceManager.install("test", TestDevice)
+
+        val virtualMagixEndpoint = VirtualMagixEndpoint(deviceManager)
+
+        val remoteDevice: DeviceClient = virtualMagixEndpoint.remoteDevice(context, "client", "device", "test".asName())
+
+        assertContains(0.0..1.0, remoteDevice.read(TestDevice.value))
+
+    }
+
+    @Test
+    fun deviceHub() = runTest {
+        val context = Context {
+            plugin(DeviceManager)
+        }
+        val deviceManager = context.request(DeviceManager)
+
+        launch {
+            delay(50)
+            repeat(10) {
+                deviceManager.install("test[$it]", TestDevice)
+            }
+        }
+
+        val virtualMagixEndpoint = VirtualMagixEndpoint(deviceManager)
+
+        val remoteHub = virtualMagixEndpoint.remoteDeviceHub(context, "client", "device")
+
+        assertEquals(0, remoteHub.devices.size)
+
+        delay(60)
+        //switch context to use actual delay
+        withContext(Dispatchers.Default) {
+            virtualMagixEndpoint.requestDeviceUpdate("client", "device")
+            delay(30)
+            assertEquals(10, remoteHub.devices.size)
+        }
+    }
+}

controls-magix/src/jvmTest/kotlin/space/kscience/controls/client/MagixLoopTest.kt

@@ -0,0 +1,56 @@
+package space.kscience.controls.client
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import space.kscience.controls.client.RemoteDeviceConnect.TestDevice
+import space.kscience.controls.manager.DeviceManager
+import space.kscience.controls.manager.install
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.request
+import space.kscience.magix.api.MagixEndpoint
+import space.kscience.magix.rsocket.rSocketWithWebSockets
+import space.kscience.magix.server.startMagixServer
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class MagixLoopTest {
+
+    @Test
+    fun realDeviceHub() = runTest {
+        val context = Context {
+            coroutineContext(Dispatchers.Default)
+            plugin(DeviceManager)
+        }
+
+        val server = context.startMagixServer()
+
+        val deviceManager = context.request(DeviceManager)
+
+        val deviceEndpoint = MagixEndpoint.rSocketWithWebSockets("localhost")
+
+        deviceManager.launchMagixService(deviceEndpoint, "device")
+
+        val trigger = CompletableDeferred<Unit>()
+
+        context.launch {
+            repeat(10) {
+                deviceManager.install("test[$it]", TestDevice)
+            }
+            delay(100)
+            trigger.complete(Unit)
+        }
+
+        val clientEndpoint = MagixEndpoint.rSocketWithWebSockets("localhost")
+
+        val remoteHub = clientEndpoint.remoteDeviceHub(context, "client", "device")
+
+        assertEquals(0, remoteHub.devices.size)
+        clientEndpoint.requestDeviceUpdate("client", "device")
+        trigger.join()
+        assertEquals(10, remoteHub.devices.size)
+        server.stop()
+    }
+}

controls-modbus/README.md

@@ -14,18 +14,16 @@ Automatically checks consistency.
 
 ## Artifact:
 
-The Maven coordinates of this project are `space.kscience:controls-modbus:0.2.0`.
+The Maven coordinates of this project are `space.kscience:controls-modbus:0.4.0-dev-4`.
 
 **Gradle Kotlin DSL:**
 ```kotlin
 repositories {
     maven("https://repo.kotlin.link")
-    //uncomment to access development builds
-    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
     mavenCentral()
 }
 
 dependencies {
-    implementation("space.kscience:controls-modbus:0.2.0")
+    implementation("space.kscience:controls-modbus:0.4.0-dev-4")
 }
 ```

controls-modbus/build.gradle.kts

@@ -1,7 +1,7 @@
 import space.kscience.gradle.Maturity
 
 plugins {
-    id("space.kscience.gradle.jvm")
+    id("space.kscience.gradle.mpp")
     `maven-publish`
 }
 
@@ -9,10 +9,12 @@ description = """
     A plugin for Controls-kt device server on top of modbus-rtu/modbus-tcp protocols
 """.trimIndent()
 
-
+kscience {
-dependencies {
+    jvm()
-    api(projects.controlsCore)
+    jvmMain {
-    api("com.ghgande:j2mod:3.1.1")
+        api(projects.controlsCore)
+        api(libs.j2mod)
+    }
 }
 
 readme{

controls-modbus/src/jvmMain/kotlin/space/kscience/controls/modbus/DeviceProcessImage.kt

@@ -1,15 +1,14 @@
 package space.kscience.controls.modbus
 
 import com.ghgande.j2mod.modbus.procimg.*
-import io.ktor.utils.io.core.buildPacket
+import kotlinx.coroutines.delay
-import io.ktor.utils.io.core.readByteBuffer
+import kotlinx.coroutines.isActive
-import io.ktor.utils.io.core.writeShort
 import kotlinx.coroutines.launch
+import kotlinx.io.Buffer
 import space.kscience.controls.api.Device
-import space.kscience.controls.spec.DevicePropertySpec
+import space.kscience.controls.ports.readShort
-import space.kscience.controls.spec.WritableDevicePropertySpec
+import space.kscience.controls.spec.*
-import space.kscience.controls.spec.set
+import space.kscience.dataforge.io.Binary
-import space.kscience.controls.spec.useProperty
 
 
 public class DeviceProcessImageBuilder<D : Device> internal constructor(
@@ -29,10 +28,10 @@ public class DeviceProcessImageBuilder<D : Device> internal constructor(
 
     public fun bind(
         key: ModbusRegistryKey.Coil,
-        propertySpec: WritableDevicePropertySpec<D, Boolean>,
+        propertySpec: MutableDevicePropertySpec<D, Boolean>,
     ): ObservableDigitalOut = bind(key) { coil ->
         coil.addObserver { _, _ ->
-            device[propertySpec] = coil.isSet
+            device.writeAsync(propertySpec, coil.isSet)
         }
         device.useProperty(propertySpec) { value ->
             coil.set(value)
@@ -89,10 +88,10 @@ public class DeviceProcessImageBuilder<D : Device> internal constructor(
 
     public fun bind(
         key: ModbusRegistryKey.HoldingRegister,
-        propertySpec: WritableDevicePropertySpec<D, Short>,
+        propertySpec: MutableDevicePropertySpec<D, Short>,
     ): ObservableRegister = bind(key) { register ->
         register.addObserver { _, _ ->
-            device[propertySpec] = register.toShort()
+            device.writeAsync(propertySpec, register.toShort())
         }
         device.useProperty(propertySpec) { value ->
             register.setValue(value)
@@ -109,37 +108,63 @@ public class DeviceProcessImageBuilder<D : Device> internal constructor(
         }
 
         device.useProperty(propertySpec) { value ->
-            val packet = buildPacket {
+            val binary = Binary {
-                key.format.writeObject(this, value)
+                key.format.writeTo(this, value)
-            }.readByteBuffer()
+            }
             registers.forEachIndexed { index, register ->
-                register.setValue(packet.getShort(index * 2))
+                register.setValue(binary.readShort(index * 2))
             }
         }
     }
 
-    public fun <T> bind(key: ModbusRegistryKey.HoldingRange<T>, propertySpec: WritableDevicePropertySpec<D, T>) {
+    /**
+     * Trigger [block] if one of register changes.
+     */
+    private fun List<ObservableRegister>.onChange(block: suspend (Buffer) -> Unit) {
+        var ready = false
+
+        forEach { register ->
+            register.addObserver { _, _ ->
+                ready = true
+            }
+        }
+
+        device.launch {
+            val builder = Buffer()
+            while (isActive) {
+                delay(1)
+                if (ready) {
+                    val packet = builder.apply {
+                        forEach { value ->
+                            writeShort(value.toShort())
+                        }
+                    }
+                    block(packet)
+                    ready = false
+                }
+            }
+        }
+    }
+
+    public fun <T> bind(key: ModbusRegistryKey.HoldingRange<T>, propertySpec: MutableDevicePropertySpec<D, T>) {
         val registers = List(key.count) {
             ObservableRegister()
         }
+
         registers.forEachIndexed { index, register ->
-            register.addObserver { _, _ ->
-                val packet = buildPacket {
-                    registers.forEach { value ->
-                        writeShort(value.toShort())
-                    }
-                }
-                device[propertySpec] = key.format.readObject(packet)
-            }
             image.addRegister(key.address + index, register)
         }
 
+        registers.onChange { packet ->
+            device.write(propertySpec, key.format.readFrom(packet))
+        }
+
         device.useProperty(propertySpec) { value ->
-            val packet = buildPacket {
+            val binary = Binary {
-                key.format.writeObject(this, value)
+                key.format.writeTo(this, value)
-            }.readByteBuffer()
+            }
             registers.forEachIndexed { index, observableRegister ->
-                observableRegister.setValue(packet.getShort(index * 2))
+                observableRegister.setValue(binary.readShort(index * 2))
             }
         }
     }
@@ -182,20 +207,17 @@ public class DeviceProcessImageBuilder<D : Device> internal constructor(
         val registers = List(key.count) {
             ObservableRegister()
         }
+
         registers.forEachIndexed { index, register ->
-            register.addObserver { _, _ ->
-                val packet = buildPacket {
-                    registers.forEach { value ->
-                        writeShort(value.toShort())
-                    }
-                }
-                device.launch {
-                    device.action(key.format.readObject(packet))
-                }
-            }
             image.addRegister(key.address + index, register)
         }
 
+        registers.onChange { packet ->
+            device.launch {
+                device.action(key.format.readFrom(packet))
+            }
+        }
+
         return registers
     }
 
@@ -205,14 +227,16 @@ public class DeviceProcessImageBuilder<D : Device> internal constructor(
  * Bind the device to Modbus slave (server) image.
  */
 public fun <D : Device> D.bindProcessImage(
+    unitId: Int = 0,
     openOnBind: Boolean = true,
     binding: DeviceProcessImageBuilder<D>.() -> Unit,
 ): ProcessImage {
-    val image = SimpleProcessImage()
+    val image = SimpleProcessImage(unitId)
     DeviceProcessImageBuilder(this, image).apply(binding)
+    image.setLocked(true)
     if (openOnBind) {
         launch {
-            open()
+            start()
         }
     }
     return image

controls-modbus/src/jvmMain/kotlin/space/kscience/controls/modbus/ModbusDevice.kt

@@ -5,11 +5,10 @@ import com.ghgande.j2mod.modbus.procimg.InputRegister
 import com.ghgande.j2mod.modbus.procimg.Register
 import com.ghgande.j2mod.modbus.procimg.SimpleInputRegister
 import com.ghgande.j2mod.modbus.util.BitVector
-import io.ktor.utils.io.core.ByteReadPacket
+import kotlinx.io.Buffer
-import io.ktor.utils.io.core.buildPacket
-import io.ktor.utils.io.core.readByteBuffer
-import io.ktor.utils.io.core.writeShort
 import space.kscience.controls.api.Device
+import space.kscience.dataforge.io.Buffer
+import space.kscience.dataforge.io.ByteArray
 import java.nio.ByteBuffer
 import kotlin.properties.ReadWriteProperty
 import kotlin.reflect.KProperty
@@ -21,9 +20,9 @@ import kotlin.reflect.KProperty
 public interface ModbusDevice : Device {
 
     /**
-     * Client id for this specific device
+     * Unit id for this specific device
      */
-    public val clientId: Int
+    public val unitId: Int
 
     /**
      * The modubus master connector
@@ -45,7 +44,7 @@ public interface ModbusDevice : Device {
 
     public operator fun <T> ModbusRegistryKey.InputRange<T>.getValue(thisRef: Any?, property: KProperty<*>): T {
         val packet = readInputRegistersToPacket(address, count)
-        return format.readObject(packet)
+        return format.readFrom(packet)
     }
 
 
@@ -61,8 +60,8 @@ public interface ModbusDevice : Device {
     }
 
     public operator fun <T> ModbusRegistryKey.HoldingRange<T>.getValue(thisRef: Any?, property: KProperty<*>): T {
-        val packet = readInputRegistersToPacket(address, count)
+        val packet = readHoldingRegistersToPacket(address, count)
-        return format.readObject(packet)
+        return format.readFrom(packet)
     }
 
     public operator fun <T> ModbusRegistryKey.HoldingRange<T>.setValue(
@@ -70,9 +69,9 @@ public interface ModbusDevice : Device {
         property: KProperty<*>,
         value: T,
     ) {
-        val buffer = buildPacket {
+        val buffer = ByteArray {
-            format.writeObject(this, value)
+            format.writeTo(this, value)
-        }.readByteBuffer()
+        }
         writeHoldingRegisters(address, buffer)
     }
 
@@ -82,35 +81,35 @@ public interface ModbusDevice : Device {
  * Read multiple sequential modbus coils (bit-values)
  */
 public fun ModbusDevice.readCoils(address: Int, count: Int): BitVector =
-    master.readCoils(clientId, address, count)
+    master.readCoils(unitId, address, count)
 
 public fun ModbusDevice.readCoil(address: Int): Boolean =
-    master.readCoils(clientId, address, 1).getBit(0)
+    master.readCoils(unitId, address, 1).getBit(0)
 
 public fun ModbusDevice.writeCoils(address: Int, values: BooleanArray) {
     val bitVector = BitVector(values.size)
     values.forEachIndexed { index, value ->
         bitVector.setBit(index, value)
     }
-    master.writeMultipleCoils(clientId, address, bitVector)
+    master.writeMultipleCoils(unitId, address, bitVector)
 }
 
 public fun ModbusDevice.writeCoil(address: Int, value: Boolean) {
-    master.writeCoil(clientId, address, value)
+    master.writeCoil(unitId, address, value)
 }
 
 public fun ModbusDevice.writeCoil(key: ModbusRegistryKey.Coil, value: Boolean) {
-    master.writeCoil(clientId, key.address, value)
+    master.writeCoil(unitId, key.address, value)
 }
 
 public fun ModbusDevice.readInputDiscretes(address: Int, count: Int): BitVector =
-    master.readInputDiscretes(clientId, address, count)
+    master.readInputDiscretes(unitId, address, count)
 
 public fun ModbusDevice.readInputDiscrete(address: Int): Boolean =
-    master.readInputDiscretes(clientId, address, 1).getBit(0)
+    master.readInputDiscretes(unitId, address, 1).getBit(0)
 
 public fun ModbusDevice.readInputRegisters(address: Int, count: Int): List<InputRegister> =
-    master.readInputRegisters(clientId, address, count).toList()
+    master.readInputRegisters(unitId, address, count).toList()
 
 private fun Array<out InputRegister>.toBuffer(): ByteBuffer {
     val buffer: ByteBuffer = ByteBuffer.allocate(size * 2)
@@ -122,17 +121,17 @@ private fun Array<out InputRegister>.toBuffer(): ByteBuffer {
     return buffer
 }
 
-private fun Array<out InputRegister>.toPacket(): ByteReadPacket = buildPacket {
+private fun Array<out InputRegister>.toPacket(): Buffer = Buffer {
     forEach { value ->
         writeShort(value.toShort())
     }
 }
 
 public fun ModbusDevice.readInputRegistersToBuffer(address: Int, count: Int): ByteBuffer =
-    master.readInputRegisters(clientId, address, count).toBuffer()
+    master.readInputRegisters(unitId, address, count).toBuffer()
 
-public fun ModbusDevice.readInputRegistersToPacket(address: Int, count: Int): ByteReadPacket =
+public fun ModbusDevice.readInputRegistersToPacket(address: Int, count: Int): Buffer =
-    master.readInputRegisters(clientId, address, count).toPacket()
+    master.readInputRegisters(unitId, address, count).toPacket()
 
 public fun ModbusDevice.readDoubleInput(address: Int): Double =
     readInputRegistersToBuffer(address, Double.SIZE_BYTES).getDouble()
@@ -141,7 +140,7 @@ public fun ModbusDevice.readInputRegister(address: Int): Short =
     readInputRegisters(address, 1).first().toShort()
 
 public fun ModbusDevice.readHoldingRegisters(address: Int, count: Int): List<Register> =
-    master.readMultipleRegisters(clientId, address, count).toList()
+    master.readMultipleRegisters(unitId, address, count).toList()
 
 /**
  * Read a number of registers to a [ByteBuffer]
@@ -149,10 +148,10 @@ public fun ModbusDevice.readHoldingRegisters(address: Int, count: Int): List<Reg
  * @param count number of 2-bytes registers to read. Buffer size is 2*[count]
  */
 public fun ModbusDevice.readHoldingRegistersToBuffer(address: Int, count: Int): ByteBuffer =
-    master.readMultipleRegisters(clientId, address, count).toBuffer()
+    master.readMultipleRegisters(unitId, address, count).toBuffer()
 
-public fun ModbusDevice.readHoldingRegistersToPacket(address: Int, count: Int): ByteReadPacket =
+public fun ModbusDevice.readHoldingRegistersToPacket(address: Int, count: Int): Buffer =
-    master.readMultipleRegisters(clientId, address, count).toPacket()
+    master.readMultipleRegisters(unitId, address, count).toPacket()
 
 public fun ModbusDevice.readDoubleRegister(address: Int): Double =
     readHoldingRegistersToBuffer(address, Double.SIZE_BYTES).getDouble()
@@ -162,14 +161,14 @@ public fun ModbusDevice.readHoldingRegister(address: Int): Short =
 
 public fun ModbusDevice.writeHoldingRegisters(address: Int, values: ShortArray): Int =
     master.writeMultipleRegisters(
-        clientId,
+        unitId,
         address,
         Array<Register>(values.size) { SimpleInputRegister(values[it].toInt()) }
     )
 
 public fun ModbusDevice.writeHoldingRegister(address: Int, value: Short): Int =
     master.writeSingleRegister(
-        clientId,
+        unitId,
         address,
         SimpleInputRegister(value.toInt())
     )
@@ -183,8 +182,11 @@ public fun ModbusDevice.writeHoldingRegisters(address: Int, buffer: ByteBuffer):
     return writeHoldingRegisters(address, array)
 }
 
-public fun ModbusDevice.writeShortRegister(address: Int, value: Short) {
+public fun ModbusDevice.writeHoldingRegisters(address: Int, byteArray: ByteArray): Int {
-    master.writeSingleRegister(address, SimpleInputRegister(value.toInt()))
+    val buffer = ByteBuffer.wrap(byteArray)
+    val array: ShortArray = ShortArray(buffer.limit().floorDiv(2)) { buffer.getShort(it * 2) }
+
+    return writeHoldingRegisters(address, array)
 }
 
 public fun ModbusDevice.modbusRegister(

controls-modbus/src/jvmMain/kotlin/space/kscience/controls/modbus/ModbusDeviceBySpec.kt

@@ -7,7 +7,7 @@ import space.kscience.controls.spec.DeviceBySpec
 import space.kscience.controls.spec.DeviceSpec
 import space.kscience.dataforge.context.Context
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.names.NameToken
+import space.kscience.dataforge.names.Name
 
 /**
  * A variant of [DeviceBySpec] that includes Modbus RTU/TCP/UDP client
@@ -15,21 +15,19 @@ import space.kscience.dataforge.names.NameToken
 public open class ModbusDeviceBySpec<D: Device>(
     context: Context,
     spec: DeviceSpec<D>,
-    override val clientId: Int,
+    override val unitId: Int,
     override val master: AbstractModbusMaster,
     private val disposeMasterOnClose: Boolean = true,
     meta: Meta = Meta.EMPTY,
 ) : ModbusDevice, DeviceBySpec<D>(spec, context, meta){
-    override suspend fun open() {
+    override suspend fun onStart() {
         master.connect()
-        super<DeviceBySpec>.open()
     }
 
-    override fun close() {
+    override suspend fun onStop() {
         if(disposeMasterOnClose){
             master.disconnect()
         }
-        super<ModbusDevice>.close()
     }
 }
 
@@ -37,12 +35,12 @@ public open class ModbusDeviceBySpec<D: Device>(
 public class ModbusHub(
     public val context: Context,
     public val masterBuilder: () -> AbstractModbusMaster,
-    public val specs: Map<NameToken, Pair<Int, DeviceSpec<*>>>,
+    public val specs: Map<Name, Pair<Int, DeviceSpec<*>>>,
 ) : DeviceHub, AutoCloseable {
 
     public val master: AbstractModbusMaster by lazy(masterBuilder)
 
-    override val devices: Map<NameToken, ModbusDevice> by lazy {
+    override val devices: Map<Name, ModbusDevice> by lazy {
         specs.mapValues { (_, pair) ->
             ModbusDeviceBySpec(
                 context,

controls-modbus/src/jvmMain/kotlin/space/kscience/controls/modbus/ModbusRegistryMap.kt

@@ -1,8 +1,15 @@
 package space.kscience.controls.modbus
 
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
 import space.kscience.dataforge.io.IOFormat
 
 
+/**
+ * Modbus registry key
+ */
 public sealed class ModbusRegistryKey {
     public abstract val address: Int
     public open val count: Int = 1
@@ -25,6 +32,9 @@ public sealed class ModbusRegistryKey {
         override fun toString(): String = "InputRegister(address=$address)"
     }
 
+    /**
+     * A range of read-only register encoding a single value
+     */
     public class InputRange<T>(
         address: Int,
         override val count: Int,
@@ -36,10 +46,16 @@ public sealed class ModbusRegistryKey {
 
     }
 
+    /**
+     * A single read-write register
+     */
     public open class HoldingRegister(override val address: Int) : ModbusRegistryKey() {
         override fun toString(): String = "HoldingRegister(address=$address)"
     }
 
+    /**
+     * A range of read-write registers encoding a single value
+     */
     public class HoldingRange<T>(
         address: Int,
         override val count: Int,
@@ -52,6 +68,9 @@ public sealed class ModbusRegistryKey {
     }
 }
 
+/**
+ * A base class for modbus registers
+ */
 public abstract class ModbusRegistryMap {
 
     private val _entries: MutableMap<ModbusRegistryKey, String> = mutableMapOf<ModbusRegistryKey, String>()
@@ -63,36 +82,56 @@ public abstract class ModbusRegistryMap {
         return key
     }
 
+    /**
+     * Register a [ModbusRegistryKey.Coil] key and return it
+     */
     protected fun coil(address: Int, description: String = ""): ModbusRegistryKey.Coil =
         register(ModbusRegistryKey.Coil(address), description)
 
 
+    /**
+     * Register a [ModbusRegistryKey.DiscreteInput] key and return it
+     */
     protected fun discrete(address: Int, description: String = ""): ModbusRegistryKey.DiscreteInput =
         register(ModbusRegistryKey.DiscreteInput(address), description)
 
+    /**
+     * Register a [ModbusRegistryKey.InputRegister] key and return it
+     */
     protected fun input(address: Int, description: String = ""): ModbusRegistryKey.InputRegister =
         register(ModbusRegistryKey.InputRegister(address), description)
 
+    /**
+     * Register a [ModbusRegistryKey.InputRange] key and return it
+     */
     protected fun <T> input(
         address: Int,
         count: Int,
         reader: IOFormat<T>,
         description: String = "",
-    ): ModbusRegistryKey.InputRange<T> =
+    ): ModbusRegistryKey.InputRange<T> = register(ModbusRegistryKey.InputRange(address, count, reader), description)
-        register(ModbusRegistryKey.InputRange(address, count, reader), description)
 
+    /**
+     * Register a [ModbusRegistryKey.HoldingRegister] key and return it
+     */
     protected fun register(address: Int, description: String = ""): ModbusRegistryKey.HoldingRegister =
         register(ModbusRegistryKey.HoldingRegister(address), description)
 
+    /**
+     * Register a [ModbusRegistryKey.HoldingRange] key and return it
+     */
     protected fun <T> register(
         address: Int,
         count: Int,
         format: IOFormat<T>,
         description: String = "",
-    ): ModbusRegistryKey.HoldingRange<T> =
+    ): ModbusRegistryKey.HoldingRange<T> = register(ModbusRegistryKey.HoldingRange(address, count, format), description)
-        register(ModbusRegistryKey.HoldingRange(address, count, format), description)
 
     public companion object {
+
+        /**
+         * Validate the register map. Throw an error if the map is invalid
+         */
         public fun validate(map: ModbusRegistryMap) {
             var lastCoil: ModbusRegistryKey.Coil? = null
             var lastDiscreteInput: ModbusRegistryKey.DiscreteInput? = null
@@ -127,36 +166,62 @@ public abstract class ModbusRegistryMap {
             }
         }
 
-        private val ModbusRegistryKey.sectionNumber
+    }
-            get() = when (this) {
+}
-                is ModbusRegistryKey.Coil -> 1
-                is ModbusRegistryKey.DiscreteInput -> 2
-                is ModbusRegistryKey.HoldingRegister -> 4
-                is ModbusRegistryKey.InputRegister -> 3
-            }
 
-        public fun print(map: ModbusRegistryMap, to: Appendable = System.out) {
+private val ModbusRegistryKey.sectionNumber
-            validate(map)
+    get() = when (this) {
-            map.entries.entries
+        is ModbusRegistryKey.Coil -> 1
-                .sortedWith(
+        is ModbusRegistryKey.DiscreteInput -> 2
-                    Comparator.comparingInt<Map.Entry<ModbusRegistryKey, String>?> { it.key.sectionNumber }
+        is ModbusRegistryKey.HoldingRegister -> 4
-                        .thenComparingInt { it.key.address }
+        is ModbusRegistryKey.InputRegister -> 3
-                )
+    }
-                .forEach { (key, description) ->
+
-                    val typeString = when (key) {
+public fun ModbusRegistryMap.print(to: Appendable = System.out) {
-                        is ModbusRegistryKey.Coil -> "Coil"
+    ModbusRegistryMap.validate(this)
-                        is ModbusRegistryKey.DiscreteInput -> "Discrete"
+    entries.entries
-                        is ModbusRegistryKey.HoldingRegister -> "Register"
+        .sortedWith(
-                        is ModbusRegistryKey.InputRegister -> "Input"
+            Comparator.comparingInt<Map.Entry<ModbusRegistryKey, String>?> { it.key.sectionNumber }
-                    }
+                .thenComparingInt { it.key.address }
-                    val rangeString = if (key.count == 1) {
+        )
-                        key.address.toString()
+        .forEach { (key, description) ->
-                    } else {
+            val typeString = when (key) {
-                        "${key.address} - ${key.address + key.count}"
+                is ModbusRegistryKey.Coil -> "Coil"
-                    }
+                is ModbusRegistryKey.DiscreteInput -> "Discrete"
-                    to.appendLine("${typeString}\t$rangeString\t$description")
+                is ModbusRegistryKey.HoldingRegister -> "Register"
-                }
+                is ModbusRegistryKey.InputRegister -> "Input"
+            }
+            val rangeString = if (key.count == 1) {
+                key.address.toString()
+            } else {
+                "${key.address} - ${key.address + key.count - 1}"
+            }
+            to.appendLine("${typeString}\t$rangeString\t$description")
         }
+}
+
+public fun ModbusRegistryMap.toJson(): JsonArray = buildJsonArray {
+    ModbusRegistryMap.validate(this@toJson)
+    entries.forEach { (key, description) ->
+
+        val entry = buildJsonObject {
+            put(
+                "type",
+                when (key) {
+                    is ModbusRegistryKey.Coil -> "Coil"
+                    is ModbusRegistryKey.DiscreteInput -> "Discrete"
+                    is ModbusRegistryKey.HoldingRegister -> "Register"
+                    is ModbusRegistryKey.InputRegister -> "Input"
+                }
+            )
+            put("address", key.address)
+            if (key.count > 1) {
+                put("count", key.count)
+            }
+            put("description", description)
+        }
+
+        add(entry)
     }
 }
 

controls-opcua/README.md

@@ -12,18 +12,16 @@ A client and server connectors for OPC-UA via Eclipse Milo
 
 ## Artifact:
 
-The Maven coordinates of this project are `space.kscience:controls-opcua:0.2.0`.
+The Maven coordinates of this project are `space.kscience:controls-opcua:0.4.0-dev-4`.
 
 **Gradle Kotlin DSL:**
 ```kotlin
 repositories {
     maven("https://repo.kotlin.link")
-    //uncomment to access development builds
-    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
     mavenCentral()
 }
 
 dependencies {
-    implementation("space.kscience:controls-opcua:0.2.0")
+    implementation("space.kscience:controls-opcua:0.4.0-dev-4")
 }
 ```

controls-opcua/build.gradle.kts

@@ -11,15 +11,13 @@ description = """
 
 val ktorVersion: String by rootProject.extra
 
-val miloVersion: String = "0.6.10"
-
 dependencies {
     api(projects.controlsCore)
     api(spclibs.kotlinx.coroutines.jdk8)
 
-    api("org.eclipse.milo:sdk-client:$miloVersion")
+    api(libs.milo.client)
-    api("org.eclipse.milo:bsd-parser:$miloVersion")
+    api(libs.milo.parser)
-    api("org.eclipse.milo:sdk-server:$miloVersion")
+    api(libs.milo.server)
 
     testImplementation(spclibs.kotlinx.coroutines.test)
 }

controls-opcua/src/main/kotlin/space/kscience/controls/opcua/client/MetaBsdParser.kt

@@ -56,6 +56,7 @@ internal class MetaEnumCodec : OpcUaBinaryDataTypeCodec<Number> {
 
 internal fun opcToMeta(value: Any?): Meta = when (value) {
     null -> Meta(Null)
+    is Variant -> opcToMeta(value.value)
     is Meta -> value
     is Value -> Meta(value)
     is Number -> when (value) {
@@ -79,12 +80,17 @@ internal fun opcToMeta(value: Any?): Meta = when (value) {
         "text" put value.text?.asValue()
     }
     is DataValue -> Meta {
-        "value" put opcToMeta(value.value) // need SerializationContext to do that properly
+        val variant= opcToMeta(value.value)
-        value.statusCode?.value?.let { "status" put Meta(it.asValue()) }
+        update(variant)// need SerializationContext to do that properly
-        value.sourceTime?.javaInstant?.let { "sourceTime" put it.toKotlinInstant().toMeta() }
+        //TODO remove after DF 0.7.2
-        value.sourcePicoseconds?.let { "sourcePicoseconds" put Meta(it.asValue()) }
+        this.value =  variant.value
-        value.serverTime?.javaInstant?.let { "serverTime" put it.toKotlinInstant().toMeta() }
+        "@opc" put {
-        value.serverPicoseconds?.let { "serverPicoseconds" put Meta(it.asValue()) }
+            value.statusCode?.value?.let { "status" put Meta(it.asValue()) }
+            value.sourceTime?.javaInstant?.let { "sourceTime" put it.toKotlinInstant().toMeta() }
+            value.sourcePicoseconds?.let { "sourcePicoseconds" put Meta(it.asValue()) }
+            value.serverTime?.javaInstant?.let { "serverTime" put it.toKotlinInstant().toMeta() }
+            value.serverPicoseconds?.let { "serverPicoseconds" put Meta(it.asValue()) }
+        }
     }
     is ByteString -> Meta(value.bytesOrEmpty().asValue())
     is XmlElement -> Meta(value.fragment?.asValue() ?: Null)
@@ -107,7 +113,7 @@ internal class MetaStructureCodec(
 
     override fun createStructure(name: String, members: LinkedHashMap<String, Meta>): Meta = Meta {
         members.forEach { (property: String, value: Meta?) ->
-            setMeta(Name.parse(property), value)
+            set(Name.parse(property), value)
         }
     }
 
@@ -147,7 +153,7 @@ internal class MetaStructureCodec(
             "Float" -> member.value?.numberOrNull?.toFloat()
             "Double" -> member.value?.numberOrNull?.toDouble()
             "String" -> member.string
-            "DateTime" -> DateTime(member.instant().toJavaInstant())
+            "DateTime" -> member.instant?.toJavaInstant()?.let { DateTime(it) }
             "Guid" -> member.string?.let { UUID.fromString(it) }
             "ByteString" -> member.value?.list?.let { list ->
                 ByteString(list.map { it.number.toByte() }.toByteArray())

controls-opcua/src/main/kotlin/space/kscience/controls/opcua/client/OpcUaDevice.kt

@@ -9,8 +9,8 @@ import org.eclipse.milo.opcua.stack.core.types.builtin.*
 import org.eclipse.milo.opcua.stack.core.types.enumerated.TimestampsToReturn
 import space.kscience.controls.api.Device
 import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaConverter
 import space.kscience.dataforge.meta.MetaSerializer
-import space.kscience.dataforge.meta.transformations.MetaConverter
 import kotlin.properties.ReadWriteProperty
 import kotlin.reflect.KProperty
 
@@ -34,7 +34,7 @@ public suspend inline fun <reified T: Any> OpcUaDevice.readOpcWithTime(
     converter: MetaConverter<T>,
     magAge: Double = 500.0
 ): Pair<T, DateTime> {
-    val data = client.readValue(magAge, TimestampsToReturn.Server, nodeId).await()
+    val data: DataValue = client.readValue(magAge, TimestampsToReturn.Server, nodeId).await()
     val time = data.serverTime ?: error("No server time provided")
     val meta: Meta = when (val content = data.value.value) {
         is T -> return content to time
@@ -43,7 +43,7 @@ public suspend inline fun <reified T: Any> OpcUaDevice.readOpcWithTime(
         else -> error("Incompatible OPC property value $content")
     }
 
-    val res: T = converter.metaToObject(meta) ?: error("Meta $meta could not be converted to ${T::class}")
+    val res: T = converter.read(meta)
     return res to time
 }
 
@@ -69,7 +69,7 @@ public suspend inline fun <reified T> OpcUaDevice.readOpc(
         else -> error("Incompatible OPC property value $content")
     }
 
-    return converter.metaToObject(meta) ?: error("Meta $meta could not be converted to ${T::class}")
+    return converter.readOrNull(meta) ?: error("Meta $meta could not be converted to ${T::class}")
 }
 
 public suspend inline fun <reified T> OpcUaDevice.writeOpc(
@@ -77,7 +77,7 @@ public suspend inline fun <reified T> OpcUaDevice.writeOpc(
     converter: MetaConverter<T>,
     value: T
 ): StatusCode {
-    val meta = converter.objectToMeta(value)
+    val meta = converter.convert(value)
     return client.writeValue(nodeId, DataValue(Variant(meta))).await()
 }
 

controls-opcua/src/main/kotlin/space/kscience/controls/opcua/client/OpcUaDeviceBySpec.kt

@@ -31,7 +31,7 @@ public class MiloConfiguration : Scheme() {
 
     public var endpointUrl: String by string { error("Endpoint url is not defined") }
 
-    public var username: MiloUsername? by specOrNull(MiloUsername)
+    public var username: MiloUsername? by schemeOrNull(MiloUsername)
 
     public var securityPolicy: SecurityPolicy by enum(SecurityPolicy.None)
 
@@ -63,8 +63,7 @@ public open class OpcUaDeviceBySpec<D : Device>(
         }
     }
 
-    override fun close() {
+    override suspend fun onStop() {
         client.disconnect()
-        super<DeviceBySpec>.close()
     }
 }