control

type Block interface {
	// Reset will reset the control block to initial state. Returns an error on failure
	Reset(ctx context.Context) error

	// Next calculate the next output. Takes an array of float64 , a delta time returns True and the output value on success false otherwise
	Next(ctx context.Context, x []*Signal, dt time.Duration) ([]*Signal, bool)

	// UpdateConfig update the configuration of a pre-existing control block returns an error on failure
	UpdateConfig(ctx context.Context, config BlockConfig) error

	// Output returns the most recent valid value, useful for block aggregating signals
	Output(ctx context.Context) []*Signal

	// Config returns the underlying config for a Block
	Config(ctx context.Context) BlockConfig
}

type BlockConfig struct {
	Name      string             `json:"name"`       // Control Block name
	Type      controlBlockType   `json:"type"`       // Control Block type
	Attribute utils.AttributeMap `json:"attributes"` // Internal block configuration
	DependsOn []string           `json:"depends_on"` // List of blocks needed for calling Next
}

type Config struct {
	Blocks    []BlockConfig `json:"blocks"`    // Blocks Control Block Config
	Frequency float64       `json:"frequency"` // Frequency loop Frequency
}

type Control interface {
	// OutputAt returns the Signal at the block name, error when the block doesn't exist
	OutputAt(ctx context.Context, name string) ([]*Signal, error)
	// ConfigAt returns the Configl at the block name, error when the block doesn't exist
	ConfigAt(ctx context.Context, name string) (BlockConfig, error)
	// BlockList returns the list of blocks in a control loop error when the list is empty
	BlockList(ctx context.Context) ([]string, error)
	// Frequency returns the loop's frequency
	Frequency(ctx context.Context) (float64, error)
	// Start starts the loop
	Start() error
	// Stop stops the loop
	Stop()
}

type Controllable interface {
	// SetState set the power and direction of the motor
	SetState(ctx context.Context, state []*Signal) error
	// Position returns the current encoder count value
	State(ctx context.Context) ([]float64, error)
}

type Loop struct {
	// contains filtered or unexported fields
}

type Options struct {
	// PositionControlUsingTrapz adds a trapezoidalVelocityProfile block to the
	// control config to allow for position control of a component
	PositionControlUsingTrapz bool

	// SensorFeedback2DVelocityControl adds linear and angular blocks to a control
	// config in order to use the sensorcontrolled base component for velocity control
	SensorFeedback2DVelocityControl bool

	// DerivativeType is the type of derivative to be used for the derivative block of a control config
	DerivativeType string

	// UseCustomeConfig is if the necessary config is not created by this setup file
	UseCustomConfig bool

	// CompleteCustomConfig is the custom control config to be used instead of the config
	// created by this setup file
	CompleteCustomConfig Config

	// NeedsAutoTuning is true when all PID values of a PID block are 0 and
	// the control loop needs to be auto-tuned
	NeedsAutoTuning bool

	// LoopFrequency is the frequency at which the control loop should run
	LoopFrequency float64

	// ControllableType is the type of component the control loop will be set up for,
	// currently a base or motor
	ControllableType string
}

type PIDConfig struct {
	Type string  `json:"type,omitempty"`
	P    float64 `json:"p"`
	I    float64 `json:"i"`
	D    float64 `json:"d"`
	// contains filtered or unexported fields
}

type PIDLoop struct {
	BlockNames   map[string][]string
	PIDVals      []PIDConfig
	TunedVals    *[]PIDConfig
	ControlConf  *Config
	ControlLoop  *Loop
	Options      Options
	Controllable Controllable
	// contains filtered or unexported fields
}

type Signal struct {
	// contains filtered or unexported fields
}