Initial go port of epics
This commit is contained in:
Martino Ferrari
@@ -0,0 +1,336 @@
|
||||
// Command catools provides caget/caput/camonitor/cainfo equivalents using
|
||||
// the pure-Go goca CA client library.
|
||||
//
|
||||
// Usage:
|
||||
//
|
||||
// catools caget <pv> [pv...] # get current value(s)
|
||||
// catools caput <pv> <value> # write a value
|
||||
// catools cainfo <pv> [pv...] # print metadata (units, limits, type)
|
||||
// catools camonitor <pv> [pv...] # stream live updates (Ctrl-C to stop)
|
||||
//
|
||||
// Environment:
|
||||
//
|
||||
// EPICS_CA_ADDR_LIST — space-separated CA server addresses
|
||||
// EPICS_CA_AUTO_ADDR_LIST — set to "NO" to disable broadcast search
|
||||
// UOPI_CA_DEBUG — set to "1" for CA protocol debug logging
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/signal"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
ca "github.com/uopi/goca"
|
||||
"github.com/uopi/goca/proto"
|
||||
)
|
||||
|
||||
func usage() {
|
||||
fmt.Fprintln(os.Stderr, `catools — pure-Go EPICS CA command-line tools
|
||||
|
||||
Commands:
|
||||
caget <pv> [pv...] Get current value(s)
|
||||
caput <pv> <value> Write a value
|
||||
cainfo <pv> [pv...] Print metadata (type, units, limits)
|
||||
camonitor <pv> [pv...] Stream live updates (Ctrl-C to stop)
|
||||
|
||||
Environment:
|
||||
EPICS_CA_ADDR_LIST Space-separated CA server addresses
|
||||
EPICS_CA_AUTO_ADDR_LIST Set to NO to disable broadcast search
|
||||
UOPI_CA_DEBUG Set to 1 for CA protocol debug logging`)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
func main() {
|
||||
if len(os.Args) < 2 {
|
||||
usage()
|
||||
}
|
||||
|
||||
cmd := os.Args[1]
|
||||
args := os.Args[2:]
|
||||
|
||||
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
|
||||
cfg := ca.ConfigFromEnv()
|
||||
cli, err := ca.NewClient(ctx, cfg)
|
||||
if err != nil {
|
||||
fatalf("connect: %v", err)
|
||||
}
|
||||
|
||||
switch cmd {
|
||||
case "caget":
|
||||
if len(args) == 0 {
|
||||
fatalf("caget: no PV names specified")
|
||||
}
|
||||
runCaget(ctx, cli, args)
|
||||
case "caput":
|
||||
if len(args) < 2 {
|
||||
fatalf("caput: usage: catools caput <pv> <value>")
|
||||
}
|
||||
runCaput(ctx, cli, args[0], args[1])
|
||||
case "cainfo":
|
||||
if len(args) == 0 {
|
||||
fatalf("cainfo: no PV names specified")
|
||||
}
|
||||
runCainfo(ctx, cli, args)
|
||||
case "camonitor":
|
||||
if len(args) == 0 {
|
||||
fatalf("camonitor: no PV names specified")
|
||||
}
|
||||
runCamonitor(ctx, cli, args)
|
||||
default:
|
||||
fatalf("unknown command %q — use caget, caput, cainfo, or camonitor", cmd)
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// caget //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
func runCaget(ctx context.Context, cli *ca.Client, pvs []string) {
|
||||
tctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
|
||||
for _, pv := range pvs {
|
||||
tv, err := cli.Get(tctx, pv)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "%s: error: %v\n", pv, err)
|
||||
continue
|
||||
}
|
||||
fmt.Printf("%-30s %s\n", pv, formatValue(tv))
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// caput //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
func runCaput(ctx context.Context, cli *ca.Client, pv, valueStr string) {
|
||||
tctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
|
||||
// First get metadata to determine the right type.
|
||||
ci, err := cli.GetCtrl(tctx, pv)
|
||||
if err != nil {
|
||||
fatalf("%s: get metadata: %v", pv, err)
|
||||
}
|
||||
|
||||
var value any
|
||||
switch ci.DBFType {
|
||||
case proto.DBFString:
|
||||
value = valueStr
|
||||
case proto.DBFEnum:
|
||||
// Try numeric first, then string.
|
||||
if n, err := strconv.ParseInt(valueStr, 10, 32); err == nil {
|
||||
value = int32(n)
|
||||
} else {
|
||||
// Search enum strings.
|
||||
if ci.Enum != nil {
|
||||
for i, s := range ci.Enum.Strings {
|
||||
if strings.EqualFold(s, valueStr) {
|
||||
value = int32(i)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if value == nil {
|
||||
fatalf("%s: unknown enum value %q", pv, valueStr)
|
||||
}
|
||||
}
|
||||
default:
|
||||
if n, err := strconv.ParseFloat(valueStr, 64); err == nil {
|
||||
value = n
|
||||
} else if n, err := strconv.ParseInt(valueStr, 10, 64); err == nil {
|
||||
value = int64(n)
|
||||
} else {
|
||||
value = valueStr
|
||||
}
|
||||
}
|
||||
|
||||
if err := cli.Put(tctx, pv, value); err != nil {
|
||||
fatalf("%s: put: %v", pv, err)
|
||||
}
|
||||
|
||||
// Read back the new value.
|
||||
tv, err := cli.Get(tctx, pv)
|
||||
if err != nil {
|
||||
fmt.Printf("Old: ?\nNew: %s (write sent, readback failed: %v)\n", valueStr, err)
|
||||
return
|
||||
}
|
||||
fmt.Printf("%-30s %s\n", pv, formatValue(tv))
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// cainfo //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
func runCainfo(ctx context.Context, cli *ca.Client, pvs []string) {
|
||||
tctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
|
||||
for _, pv := range pvs {
|
||||
ci, err := cli.GetCtrl(tctx, pv)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "%s: error: %v\n", pv, err)
|
||||
continue
|
||||
}
|
||||
printInfo(pv, ci)
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
|
||||
func printInfo(pv string, ci ca.CtrlInfo) {
|
||||
fmt.Printf("Name : %s\n", pv)
|
||||
fmt.Printf("DBF type : %s (%d)\n", dbfTypeName(ci.DBFType), ci.DBFType)
|
||||
fmt.Printf("Count : %d\n", ci.Count)
|
||||
writable := "No"
|
||||
if ci.Access&proto.AccessWrite != 0 {
|
||||
writable = "Yes"
|
||||
}
|
||||
fmt.Printf("Writable : %s\n", writable)
|
||||
|
||||
switch {
|
||||
case ci.Double != nil:
|
||||
d := ci.Double
|
||||
fmt.Printf("Units : %s\n", d.Units)
|
||||
fmt.Printf("Disp range : [%g, %g]\n", d.LowerDispLimit, d.UpperDispLimit)
|
||||
fmt.Printf("Ctrl range : [%g, %g]\n", d.LowerCtrlLimit, d.UpperCtrlLimit)
|
||||
fmt.Printf("Alarm LOLO : %g HIHI: %g\n", d.LowerAlarmLimit, d.UpperAlarmLimit)
|
||||
fmt.Printf("Warn LOW : %g HIGH: %g\n", d.LowerWarnLimit, d.UpperWarnLimit)
|
||||
case ci.Long != nil:
|
||||
l := ci.Long
|
||||
fmt.Printf("Units : %s\n", l.Units)
|
||||
fmt.Printf("Disp range : [%d, %d]\n", l.LowerDispLimit, l.UpperDispLimit)
|
||||
fmt.Printf("Ctrl range : [%d, %d]\n", l.LowerCtrlLimit, l.UpperCtrlLimit)
|
||||
fmt.Printf("Alarm LOLO : %d HIHI: %d\n", l.LowerAlarmLimit, l.UpperAlarmLimit)
|
||||
fmt.Printf("Warn LOW : %d HIGH: %d\n", l.LowerWarnLimit, l.UpperWarnLimit)
|
||||
case ci.Enum != nil:
|
||||
fmt.Printf("Enum states: %d\n", len(ci.Enum.Strings))
|
||||
for i, s := range ci.Enum.Strings {
|
||||
fmt.Printf(" [%d] %s\n", i, s)
|
||||
}
|
||||
case ci.Str != nil:
|
||||
fmt.Printf("Type : string\n")
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// camonitor //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
func runCamonitor(ctx context.Context, cli *ca.Client, pvs []string) {
|
||||
type entry struct {
|
||||
pv string
|
||||
ch chan proto.TimeValue
|
||||
can context.CancelFunc
|
||||
}
|
||||
|
||||
entries := make([]*entry, 0, len(pvs))
|
||||
tctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
|
||||
for _, pv := range pvs {
|
||||
ch := make(chan proto.TimeValue, 32)
|
||||
cancelFn, err := cli.Subscribe(tctx, pv, ch)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "%s: subscribe error: %v\n", pv, err)
|
||||
continue
|
||||
}
|
||||
entries = append(entries, &entry{pv: pv, ch: ch, can: cancelFn})
|
||||
fmt.Printf("Monitoring %s — press Ctrl-C to stop\n", pv)
|
||||
}
|
||||
|
||||
if len(entries) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// Fan out: one goroutine per PV, print to stdout.
|
||||
done := make(chan struct{})
|
||||
for _, e := range entries {
|
||||
go func(e *entry) {
|
||||
for {
|
||||
select {
|
||||
case tv, ok := <-e.ch:
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
ts := tv.Timestamp.Local().Format("15:04:05.000")
|
||||
fmt.Printf("%s %-30s %s\n", ts, e.pv, formatValue(tv))
|
||||
case <-ctx.Done():
|
||||
return
|
||||
}
|
||||
}
|
||||
}(e)
|
||||
}
|
||||
|
||||
<-ctx.Done()
|
||||
close(done)
|
||||
|
||||
for _, e := range entries {
|
||||
e.can()
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// Formatting helpers //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
func formatValue(tv proto.TimeValue) string {
|
||||
var val string
|
||||
switch {
|
||||
case tv.Doubles != nil:
|
||||
parts := make([]string, len(tv.Doubles))
|
||||
for i, v := range tv.Doubles {
|
||||
parts[i] = strconv.FormatFloat(v, 'g', -1, 64)
|
||||
}
|
||||
val = "[" + strings.Join(parts, " ") + "]"
|
||||
case tv.Str != "":
|
||||
val = tv.Str
|
||||
default:
|
||||
val = strconv.FormatFloat(tv.Double, 'g', -1, 64)
|
||||
}
|
||||
|
||||
severity := ""
|
||||
switch tv.Severity {
|
||||
case proto.SeverityMinor:
|
||||
severity = " MINOR"
|
||||
case proto.SeverityMajor:
|
||||
severity = " MAJOR"
|
||||
case proto.SeverityInvalid:
|
||||
severity = " INVALID"
|
||||
}
|
||||
|
||||
ts := tv.Timestamp.Local().Format("2006-01-02 15:04:05.000")
|
||||
return fmt.Sprintf("%s%s [%s]", val, severity, ts)
|
||||
}
|
||||
|
||||
func dbfTypeName(t int) string {
|
||||
switch t {
|
||||
case proto.DBFString:
|
||||
return "DBF_STRING"
|
||||
case proto.DBFShort:
|
||||
return "DBF_SHORT"
|
||||
case proto.DBFFloat:
|
||||
return "DBF_FLOAT"
|
||||
case proto.DBFEnum:
|
||||
return "DBF_ENUM"
|
||||
case proto.DBFChar:
|
||||
return "DBF_CHAR"
|
||||
case proto.DBFLong:
|
||||
return "DBF_LONG"
|
||||
case proto.DBFDouble:
|
||||
return "DBF_DOUBLE"
|
||||
default:
|
||||
return "DBF_UNKNOWN"
|
||||
}
|
||||
}
|
||||
|
||||
func fatalf(format string, args ...any) {
|
||||
fmt.Fprintf(os.Stderr, "catools: "+format+"\n", args...)
|
||||
os.Exit(1)
|
||||
}
|
||||
Reference in New Issue
Block a user