Your first motion (simulation)

package main

import (
	"context"
	"errors"
	"fmt"
	"os"
	"time"

	"rosieos/rt-core/ipcclient"
	"rosieos/rt-core/sdk/control"
)

// Simulation-only inputs: all nine axes, J1 at 0.01 rad/s for one second,
// a 10 ms update cadence and a 100 ms deadline on each jog update.
const (
	mask     = 0x1ff // J1..J9
	velocity = 0.01  // rad/s
	duration = time.Second
	cadence  = 10 * time.Millisecond
	inputAge = 100 * time.Millisecond
)

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, "first-motion:", err)
		os.Exit(1)
	}
}

func run() error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	c, err := control.Dial(control.UnixPath(os.Getenv("TMPDIR") + "/control.sock"))
	if err != nil {
		return err
	}
	defer c.Close()

	// Refuse anything but the simulator started above.
	d, err := c.Describe(ctx)
	if err != nil {
		return err
	}
	if d.Backend != "simulation" || d.ConfigurationSHA256 != os.Getenv("SHA") {
		return errors.New("not the simulator this example started")
	}

	// 1. Acquire: one controller at a time, bound to this pair and configuration.
	g, err := c.Acquire(ctx, "first-motion", control.Binding{
		PairID: "first-motion", Revision: 1, ConfigurationSHA256: d.ConfigurationSHA256,
	})
	if err != nil {
		return err
	}
	released := false
	defer func() { // on any failure, inhibit and give up control
		if !released {
			c.Stop(context.Background())
			c.Release(context.Background())
		}
	}()
	fmt.Printf("acquire generation=%d\n", g.Generation)

	// Keep the lease alive: interval 0 renews every third of the lease.
	renewals, err := c.StartRenewal(ctx, 0)
	if err != nil {
		return err
	}

	// 2. Enable and arm, then wait for every axis to report Operation Enabled.
	e, err := c.Enable(ctx, mask)
	if err != nil {
		return err
	}
	fmt.Printf("enable sequence=%d\n", e.Sequence)
	a, err := c.Arm(ctx)
	if err != nil {
		return err
	}
	fmt.Printf("arm sequence=%d\n", a.Sequence)

	tick := time.NewTicker(cadence)
	defer tick.Stop()
	for {
		s, err := c.Status(ctx)
		if err != nil {
			return err
		}
		if ipcclient.AllOperationEnabled(s.Core) {
			break
		}
		select {
		case <-tick.C:
		case <-ctx.Done():
			return ctx.Err()
		}
	}
	s, err := c.Status(ctx)
	if err != nil {
		return err
	}
	before := s.Core.Axes[0].PositionCounts

	// 3. Jog J1. Each datagram carries its own deadline; if updates stop,
	// the core ramps the axis to a hold.
	jog, err := c.PrepareJogSession(ctx, mask)
	if err != nil {
		return err
	}
	velocities := make([]float64, len(d.Axes))
	velocities[0] = velocity
	for end := time.Now().Add(duration); time.Now().Before(end); {
		origin := ipcclient.HostMonotonicNS()
		if err := jog.UpdateAt(velocities, origin, origin+uint64(inputAge)); err != nil {
			return err
		}
		select {
		case renewal, ok := <-renewals:
			if !ok {
				return errors.New("lease renewal ended")
			}
			if renewal.Err != nil {
				return renewal.Err
			}
		case <-tick.C:
		case <-ctx.Done():
			return ctx.Err()
		}
	}
	if err := jog.End(ctx); err != nil {
		return err
	}
	s, err = c.Status(ctx)
	if err != nil {
		return err
	}
	fmt.Printf("jog requested_ns=%d delta_counts=%d\n", duration, s.Core.Axes[0].PositionCounts-before)

	// 4. Stop inhibits outputs and bumps the fence; Release gives up the session.
	stopped, err := c.Stop(ctx)
	if err != nil {
		return err
	}
	fmt.Printf("stop generation=%d\n", stopped.Generation)
	r, err := c.Release(ctx)
	if err != nil {
		return err
	}
	released = true
	fmt.Printf("release session_empty=%t\n", r.Session == "")
	return nil
}