Add Modbus service for dynamic parameter reading

assets/js/components/Config/DeviceModal/DeviceModalBase.vue

@@ -315,15 +315,6 @@ export default defineComponent({
 		modbusCapabilities() {
 			return (this.modbus?.Choice || []) as ModbusCapability[];
 		},
-		modbusDefaults() {
-			const { ID, Comset, Baudrate, Port } = this.modbus || {};
-			return {
-				id: ID,
-				comset: Comset,
-				baudrate: Baudrate,
-				port: Port,
-			};
-		},
 		description() {
 			return this.template?.Requirements?.Description;
 		},
@@ -339,7 +330,6 @@ export default defineComponent({
 		},
 		apiData(): ApiData {
 			let data: ApiData = {
-				...this.modbusDefaults,
 				...this.values,
 			};
 			if (this.values.type === ConfigType.Template && this.templateName) {

assets/js/components/Config/DeviceModal/index.ts

@@ -95,6 +95,23 @@ export function applyDefaultsFromTemplate(template: Template | null, values: Dev
     .forEach((p) => {
       values[p.Name] = p.Default;
     });
+
+  // Apply modbus defaults from template (for service dependency resolution)
+  const modbusParam = params.find((p) => p.Name === "modbus") as ModbusParam | undefined;
+  if (modbusParam) {
+    if (!values["id"] && modbusParam.ID) {
+      values["id"] = modbusParam.ID;
+    }
+    if (!values["port"] && modbusParam.Port) {
+      values["port"] = modbusParam.Port;
+    }
+    if (!values["comset"] && modbusParam.Comset) {
+      values["comset"] = modbusParam.Comset;
+    }
+    if (!values["baudrate"] && modbusParam.Baudrate) {
+      values["baudrate"] = modbusParam.Baudrate;
+    }
+  }
 }
 
 export function customChargerName(type: ConfigType, isHeating: boolean) {

assets/js/components/Config/PropertyField.vue

@@ -1,17 +1,43 @@
 <template>
-	<div v-if="unitValue" class="input-group" :class="inputClasses">
-		<input
-			:id="id"
-			v-model="value"
-			:type="inputType"
-			:step="step"
-			:placeholder="placeholder"
-			:required="required"
-			:aria-describedby="id + '_unit'"
-			class="form-control"
-			:class="{ 'text-end': endAlign }"
-		/>
-		<span :id="id + '_unit'" class="input-group-text">{{ unitValue }}</span>
+	<div v-if="unitValue" :class="sizeClass">
+		<div class="d-flex">
+			<div class="position-relative flex-grow-1">
+				<input
+					:id="id"
+					v-model="value"
+					:list="datalistId"
+					:type="inputType"
+					:step="step"
+					:placeholder="placeholder"
+					:required="required"
+					:aria-describedby="id + '_unit'"
+					:class="`${datalistId && serviceValues.length > 0 ? 'form-select' : 'form-control'} ${showClearButton ? 'has-clear-button' : ''} ${invalid ? 'is-invalid' : ''}`"
+					class="text-end"
+					style="border-top-right-radius: 0; border-bottom-right-radius: 0"
+					:autocomplete="masked || datalistId ? 'off' : null"
+				/>
+				<button
+					v-if="showClearButton"
+					type="button"
+					class="form-control-clear"
+					:aria-label="$t('config.general.clear')"
+					@click="value = ''"
+				>
+					&times;
+				</button>
+				<datalist v-if="showDatalist" :id="datalistId">
+					<option v-for="v in serviceValues" :key="v" :value="v">
+						{{ v }}
+					</option>
+				</datalist>
+			</div>
+			<span
+				:id="id + '_unit'"
+				class="input-group-text"
+				style="border-top-left-radius: 0; border-bottom-left-radius: 0"
+				>{{ unitValue }}</span
+			>
+		</div>
 	</div>
 	<div v-else-if="icons" class="d-flex flex-wrap">
 		<div
@@ -148,7 +174,15 @@ export default {
 			// no values
 			if (length === 0) return false;
 			// value selected, dont offer single same option again
-			if (this.value && this.serviceValues.includes(this.value)) return false;
+			// Convert both to strings for comparison to handle number/string type mismatches
+			const valueStr = String(this.value ?? "");
+			if (
+				this.value != null &&
+				valueStr !== "" &&
+				this.serviceValues.some((v) => String(v) === valueStr)
+			) {
+				return false;
+			}
 			return true;
 		},
 		showClearButton() {
@@ -294,7 +328,7 @@ export default {
 };
 </script>
 
-<style>
+<style scoped>
 input[type="number"] {
 	appearance: textfield;
 }
@@ -312,4 +346,36 @@ input[type="number"]::-webkit-inner-spin-button {
 .w-min-200 {
 	min-width: min(200px, 100%);
 }
+
+/* Clear button styling */
+.form-control-clear {
+	position: absolute;
+	right: 0.75rem;
+	top: 50%;
+	transform: translateY(-50%);
+	z-index: 5;
+	background: none;
+	border: none;
+	color: #6c757d;
+	font-size: 1.5rem;
+	line-height: 1;
+	cursor: pointer;
+	padding: 0;
+	width: 1.5rem;
+	height: 1.5rem;
+}
+
+/* Adjust input padding when clear button is visible */
+.form-control.has-clear-button {
+	padding-right: 2rem;
+}
+
+/* For form-select with datalist */
+.form-select.has-clear-button {
+	padding-right: 2rem;
+}
+
+.form-select.has-clear-button + .form-control-clear {
+	right: 0.5rem;
+}
 </style>

util/service/modbus.go

@@ -0,0 +1,189 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/evcc-io/evcc/plugin"
+	"github.com/evcc-io/evcc/server/service"
+	"github.com/evcc-io/evcc/util"
+	"github.com/evcc-io/evcc/util/modbus"
+	"github.com/spf13/cast"
+)
+
+// Simple cache for service responses
+type cacheEntry struct {
+	value     any
+	timestamp time.Time
+}
+
+var (
+	cache    = make(map[string]cacheEntry)
+	mu       sync.RWMutex
+	cacheTTL = 1 * time.Minute // Cache for 1 minute
+)
+
+// Query combines modbus settings, register config, and additional parameters
+type Query struct {
+	modbus.Settings `mapstructure:",squash"`
+	modbus.Register `mapstructure:",squash"`
+	Scale           float64 // scaling factor
+	ResultType      string  // type cast (int, float, string)
+}
+
+func init() {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /params", getParams)
+
+	service.Register("modbus", mux)
+}
+
+// getParams reads a parameter value from a device based on URL parameters
+// Returns single value as array (for UI compatibility)
+func getParams(w http.ResponseWriter, req *http.Request) {
+	// Convert URL query parameters to map for decoding
+	cc := make(map[string]any)
+	for k := range req.URL.Query() {
+		cc[k] = req.URL.Query().Get(k)
+	}
+
+	// Decode query parameters into Query struct using mapstructure
+	query := Query{
+		Scale: 1.0,
+	}
+
+	if err := util.DecodeOther(cc, &query); err != nil {
+		jsonError(w, http.StatusBadRequest, err)
+		return
+	}
+
+	// Validate required parameters
+	if (query.URI == "" && query.Device == "") || query.Address == 0 {
+		jsonError(w, http.StatusBadRequest, fmt.Errorf("uri or device and address parameters are required"))
+		return
+	}
+
+	// Create cache key from connection string and register address
+	connStr := query.URI
+	if connStr == "" {
+		connStr = query.Device
+	}
+	cacheKey := fmt.Sprintf("%s:%d", connStr, query.Address)
+
+	// Check cache first
+	mu.RLock()
+	if entry, ok := cache[cacheKey]; ok && time.Since(entry.timestamp) < cacheTTL {
+		mu.RUnlock()
+		jsonWrite(w, []string{cast.ToString(entry.value)})
+		return
+	}
+	mu.RUnlock()
+
+	// Read value from modbus using plugin
+	// Use background context so connection isn't tied to HTTP request lifecycle
+	value, err := readRegisterValue(context.TODO(), query)
+	if err != nil {
+		jsonWrite(w, []string{}) // Return empty array on error
+		return
+	}
+
+	// Apply optional cast
+	if query.ResultType != "" {
+		value = applyCast(value, query.ResultType)
+	}
+
+	// Store in cache
+	mu.Lock()
+	cache[cacheKey] = cacheEntry{
+		value:     value,
+		timestamp: time.Now(),
+	}
+	mu.Unlock()
+
+	jsonWrite(w, []string{cast.ToString(value)})
+}
+
+// readRegisterValue reads a modbus register value by reusing the modbus plugin
+func readRegisterValue(ctx context.Context, query Query) (res any, err error) {
+	// Build config map for plugin - need to flatten embedded structs manually
+	cfg := map[string]any{
+		"uri":      query.URI,
+		"id":       query.ID,
+		"register": query.Register,
+		"scale":    query.Scale,
+	}
+
+	// Add optional settings
+	if query.Device != "" {
+		cfg["device"] = query.Device
+	}
+	if query.Comset != "" {
+		cfg["comset"] = query.Comset
+	}
+	if query.Baudrate != 0 {
+		cfg["baudrate"] = query.Baudrate
+	}
+
+	p, err := plugin.NewModbusFromConfig(ctx, cfg)
+	if err != nil {
+		return 0, fmt.Errorf("failed to create modbus plugin: %w", err)
+	}
+
+	defer func() {
+		if r := recover(); r != nil {
+			res = nil
+			err = fmt.Errorf("read failed: %v", r)
+		}
+	}()
+
+	// Choose getter based on encoding type
+	encoding := strings.ToLower(query.Encoding)
+
+	// String encodings need special handling
+	if encoding == "string" || encoding == "bytes" {
+		return callGetter(p.(plugin.StringGetter).StringGetter())
+	}
+
+	// For all numeric encodings (int*, uint*, float*, bool*), use FloatGetter
+	// This is the base implementation in modbus plugin
+	return callGetter(p.(plugin.FloatGetter).FloatGetter())
+}
+
+// callGetter calls a getter function and returns the result
+func callGetter[T any](getterFn func() (T, error), err error) (any, error) {
+	if err != nil {
+		return nil, err
+	}
+	return getterFn()
+}
+
+// applyCast applies optional type casting
+func applyCast(value any, castType string) any {
+	switch strings.ToLower(castType) {
+	case "int":
+		return cast.ToInt64(value)
+	case "float":
+		return cast.ToFloat64(value)
+	case "string":
+		return cast.ToString(value)
+	default:
+		return value
+	}
+}
+
+// jsonWrite writes a JSON response
+func jsonWrite(w http.ResponseWriter, data any) {
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(data)
+}
+
+// jsonError writes an error response
+func jsonError(w http.ResponseWriter, status int, err error) {
+	w.WriteHeader(status)
+	jsonWrite(w, util.ErrorAsJson(err))
+}