Feature/dope 442 unified modbus config

src/backend/editor/compiler/compiler-module.ts

@@ -1,4 +1,4 @@
 import { spawn } from 'node:child_process'
 import crypto, { createHash } from 'node:crypto'
 import { existsSync, promises as fs } from 'node:fs'
 import { cp, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises'
@@ -10,6 +10,7 @@
 
 import { resolveTrustedKeysArtifact } from '@root/backend/shared/compile/steps/generate-trusted-keys'
 import type { VppModbusScreenState } from '@root/backend/shared/compile/steps/modbus-defines'
+import { vppStateFromModbusSlaveConfig } from '@root/frontend/utils/modbus/serial-link-config'
 import { resolveBoardSelection } from '@root/backend/shared/compile/steps/resolve-board-selection'
 
 import { execRecipeArgv, substitutePlaceholders, tokenizeRecipe } from './recipe-exec'
@@ -492,8 +493,8 @@
 
   checkStrucppAvailability(): MethodsResult<string> {
     try {
       const { getVersion } = loadStrucpp()
       return { success: true, data: getVersion() }
     } catch {
       throw new Error('STruC++ not available. Run "npm run setup:binaries" to install it.')
     }
@@ -2953,21 +2954,34 @@
     let vppModbusState: VppModbusScreenState | undefined
     if (boardRuntime !== 'simulator' && boardRuntime !== 'openplc-compiler') {
       const devicesConfigurationFilePath = join(normalizedProjectPath, 'devices', 'configuration.json')
-      try {
-        const deviceConfig = await CompilerModule.readJSONFile<DeviceConfiguration>(devicesConfigurationFilePath)
-        const vendorScreenData = deviceConfig.vendorScreenData ?? {}
-        vppModbusState = {
-          serial: vendorScreenData['serial'] as VppModbusScreenState['serial'],
-          network: vendorScreenData['network'] as VppModbusScreenState['network'],
-          modbus_rtu: vendorScreenData['modbus_rtu'] as VppModbusScreenState['modbus_rtu'],
-          modbus_tcp: vendorScreenData['modbus_tcp'] as VppModbusScreenState['modbus_tcp'],
+      // DOPE-442 moved this configuration onto the project's Modbus server. A
+      // server that carries it wins; a project that has not been edited since
+      // the move still has only the VPP screen state, and compiles from it
+      // exactly as before. Nothing is rewritten either way — the old keys stay
+      // on disk, so rolling the editor back keeps working.
+      const unifiedModbus = projectData.servers?.find(
+        (server) =>
+          server.protocol === 'modbus-tcp' && (server.modbusSlaveConfig?.rtu || server.modbusSlaveConfig?.tcpLink),
+      )?.modbusSlaveConfig
+
+      if (unifiedModbus) {
+        vppModbusState = vppStateFromModbusSlaveConfig(unifiedModbus)
+      } else
+        try {
+          const deviceConfig = await CompilerModule.readJSONFile<DeviceConfiguration>(devicesConfigurationFilePath)
+          const vendorScreenData = deviceConfig.vendorScreenData ?? {}
+          vppModbusState = {
+            serial: vendorScreenData['serial'] as VppModbusScreenState['serial'],
+            network: vendorScreenData['network'] as VppModbusScreenState['network'],
+            modbus_rtu: vendorScreenData['modbus_rtu'] as VppModbusScreenState['modbus_rtu'],
+            modbus_tcp: vendorScreenData['modbus_tcp'] as VppModbusScreenState['modbus_tcp'],
+          }
+        } catch {
+          // No configuration.json — leave undefined so the shared
+          // pipeline skips the Modbus block entirely (matches the
+          // pre-VPP behaviour for boards that never had a comms
+          // config persisted).
         }
-      } catch {
-        // No configuration.json — leave undefined so the shared
-        // pipeline skips the Modbus block entirely (matches the
-        // pre-VPP behaviour for boards that never had a comms
-        // config persisted).
-      }
     }
 
     // For Arduino VPP targets with a modular backplane, bake the
@@ -3210,7 +3224,7 @@
           _mainProcessPort.postMessage({
             logLevel,
             message: data,
             ...(compileError ? { compileError } : {}),
           })
         },
         { hasCBlocks, pous: knownPous, libraries, missingLibraries },

src/backend/shared/compile/__tests__/modbus-defines-unified.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Equivalence between the retired VPP Modbus screen and the unified server
+ * configuration that replaced it (DOPE-442).
+ *
+ * The firmware contract is a set of macro names `ModbusSlave.cpp` reads, so the
+ * only question that matters about the move is whether the same project emits
+ * the same macros. Every case here feeds one legacy `vendorScreenData` state
+ * through both paths — straight into the emitter, and migrated into the new
+ * model and back out through the adapter — and asserts the outputs match.
+ *
+ * The same comparison covers the debug baud and the debug slave id, where a
+ * divergence would not break the build at all: it would make Connect report
+ * "No Firmware Detected" on a healthy board.
+ */
+
+import type { VppModbusScreenState } from '../../../../frontend/utils/modbus/serial-link-config'
+import {
+  migrateVendorScreenModbus,
+  vppStateFromModbusSlaveConfig,
+} from '../../../../frontend/utils/modbus/serial-link-config'
+import { generateModbusDefines, resolveDebugBaud, resolveDebugSlave } from '../steps/modbus-defines'
+
+/** Legacy screen states, one per branch the emitter can take. */
+const LEGACY_STATES: Record<string, Record<string, unknown>> = {
+  'rtu on the default port': {
+    modbus_rtu: {
+      enabled: true,
+      rtu_interface: 'Serial',
+      rtu_baud_rate: '19200',
+      rtu_slave_id: 7,
+      enable_rs485_en_pin: false,
+    },
+  },
+  'rtu on a secondary port': {
+    modbus_rtu: { enabled: true, rtu_interface: 'Serial2', rtu_baud_rate: '57600', rtu_slave_id: 3 },
+  },
+  'rtu with an rs485 driver-enable pin': {
+    modbus_rtu: {
+      enabled: true,
+      rtu_interface: 'Serial',
+      rtu_baud_rate: '115200',
+      rtu_slave_id: 1,
+      enable_rs485_en_pin: true,
+      rtu_rs485_en_pin: 'D5',
+    },
+  },
+  'rtu asking for rs485 without naming a pin': {
+    modbus_rtu: { enabled: true, enable_rs485_en_pin: true },
+  },
+  'rtu toggled on and nothing else touched': {
+    modbus_rtu: { enabled: true },
+  },
+  'rtu left off but configured': {
+    modbus_rtu: { enabled: false, rtu_interface: 'Serial1', rtu_baud_rate: '9600', rtu_slave_id: 42 },
+  },
+  'tcp over ethernet with a static host': {
+    modbus_tcp: {
+      enabled: true,
+      tcp_interface: 'Ethernet',
+      tcp_mac_address: 'de:ad:be:ef:fe:ed',
+      enable_dhcp: false,
+      ip_address: '192.168.0.50',
+      gateway: '192.168.0.1',
+      subnet: '255.255.255.0',
+      dns: '8.8.8.8',
+    },
+  },
+  'tcp over ethernet on dhcp': {
+    modbus_tcp: { enabled: true, tcp_interface: 'Ethernet', enable_dhcp: true },
+  },
+  'tcp over wifi': {
+    modbus_tcp: {
+      enabled: true,
+      tcp_interface: 'Wi-Fi',
+      tcp_wifi_ssid: 'plant-floor',
+      tcp_wifi_password: 'hunter2',
+      enable_dhcp: true,
+    },
+  },
+  'tcp toggled on and nothing else touched': {
+    modbus_tcp: { enabled: true },
+  },
+  'both transports on': {
+    modbus_rtu: { enabled: true, rtu_interface: 'Serial', rtu_baud_rate: '115200', rtu_slave_id: 2 },
+    modbus_tcp: { enabled: true, tcp_interface: 'Wi-Fi', tcp_wifi_ssid: 'shopfloor', enable_dhcp: true },
+  },
+  'neither transport on': {
+    modbus_rtu: { enabled: false },
+    modbus_tcp: { enabled: false },
+  },
+  // A hand-edited project can name a static host without stating the flag that
+  // selects it. The emitter reads a missing `enable_dhcp` as "not DHCP", so the
+  // migration has to reach the same conclusion or the address is dropped.
+  'static host with no dhcp flag at all': {
+    modbus_tcp: {
+      enabled: true,
+      tcp_interface: 'Ethernet',
+      ip_address: '10.0.0.7',
+      gateway: '10.0.0.1',
+      subnet: '255.255.255.0',
+    },
+  },
+}
+
+const throughNewModel = (legacy: Record<string, unknown>): VppModbusScreenState => {
+  const migrated = migrateVendorScreenModbus(legacy)
+  if (!migrated) throw new Error('nothing migrated')
+  return vppStateFromModbusSlaveConfig({
+    enabled: true,
+    networkInterface: '0.0.0.0',
+    port: 502,
+    rtu: migrated.rtu,
+    tcpLink: migrated.tcpLink,
+  })
+}
+
+describe.each(Object.entries(LEGACY_STATES))('%s', (_name, legacy) => {
+  const legacyState = legacy as VppModbusScreenState
+  const unifiedState = throughNewModel(legacy)
+
+  it('emits the same defines.h block', () => {
+    expect(generateModbusDefines(unifiedState)).toBe(generateModbusDefines(legacyState))
+  })
+
+  it('resolves the same debug baud', () => {
+    expect(resolveDebugBaud(unifiedState)).toBe(resolveDebugBaud(legacyState))
+  })
+
+  it('resolves the same debug slave id', () => {
+    expect(resolveDebugSlave(unifiedState)).toBe(resolveDebugSlave(legacyState))
+  })
+})
+
+describe('vppStateFromModbusSlaveConfig', () => {
+  it('describes no transport when the server has neither block', () => {
+    expect(vppStateFromModbusSlaveConfig(undefined)).toEqual({})
+    expect(vppStateFromModbusSlaveConfig({ enabled: true, networkInterface: '0.0.0.0', port: 502 })).toEqual({})
+    // An absent block means "this target has no serial slave", which is not the
+    // same as one configured and switched off — so nothing is emitted for it.
+    expect(generateModbusDefines(vppStateFromModbusSlaveConfig(undefined))).toBe('')
+  })
+
+  it('maps the medium onto the label the emitter switches on', () => {
+    const link = {
+      enabled: true,
+      medium: 'wifi' as const,
+      macAddress: '',
+      wifiSsid: 'floor',
+      wifiPassword: 'pw',
+      useDhcp: true,
+      ipAddress: '',
+      gateway: '',
+      subnet: '',
+      dns: '',
+    }
+    const state = vppStateFromModbusSlaveConfig({
+      enabled: true,
+      networkInterface: '0.0.0.0',
+      port: 502,
+      tcpLink: link,
+    })
+
+    expect(state.modbus_tcp?.tcp_interface).toBe('Wi-Fi')
+    expect(generateModbusDefines(state)).toContain('#define MBTCP_WIFI')
+    expect(
+      generateModbusDefines({ ...state, modbus_tcp: { ...state.modbus_tcp, tcp_interface: 'Ethernet' } }),
+    ).toContain('#define MBTCP_ETHERNET')
+  })
+})

src/backend/shared/compile/steps/modbus-defines.ts

@@ -22,59 +22,9 @@
  * for fishing `modbus_rtu` and `modbus_tcp` out of `vendorScreenData`.
  */
 
-/**
- * Subset of the persisted screen state this emitter reads. Mirrors the
- * field IDs declared in `screens/modbus.json` — keep in sync if the
- * VPP screen field set evolves.
- */
-export interface VppModbusScreenState {
-  /** Phase 2 Serial section — always-on serial baud (debugger + RTU on the
-   *  default port). */
-  serial?: {
-    baud_rate?: string
-  }
-  /** Phase 2 Network section — Ethernet/Wi-Fi config lifted out of modbus_tcp. */
-  network?: {
-    enabled?: boolean
-    interface?: 'Ethernet' | 'Wi-Fi'
-    mac_address?: string
-    wifi_ssid?: string
-    wifi_password?: string
-    enable_dhcp?: boolean
-    ip_address?: string
-    gateway?: string
-    subnet?: string
-    dns?: string
-  }
-  modbus_rtu?: {
-    enabled?: boolean
-    /** Phase 2: chosen serial port. Legacy projects use `rtu_interface`. */
-    serial_port?: string
-    rtu_interface?: string
-    /** Phase 2: baud for RTU on a secondary port. On the default port the
-     *  Serial section's baud is used. Legacy projects use `rtu_baud_rate`. */
-    baud_rate?: string
-    rtu_baud_rate?: string
-    rtu_slave_id?: number
-    enable_rs485_en_pin?: boolean
-    rtu_rs485_en_pin?: string
-  }
-  modbus_tcp?: {
-    enabled?: boolean
-    unit_id?: number
-    // Legacy network fields (pre-Phase-2 projects still on the old screen).
-    // Read as a fallback when the `network` section is absent.
-    tcp_interface?: 'Ethernet' | 'Wi-Fi'
-    tcp_mac_address?: string
-    tcp_wifi_ssid?: string
-    tcp_wifi_password?: string
-    enable_dhcp?: boolean
-    ip_address?: string
-    gateway?: string
-    subnet?: string
-    dns?: string
-  }
-}
+import type { VppModbusScreenState } from '../../../../frontend/utils/modbus/serial-link-config'
+
+export type { VppModbusScreenState }
 
 /** Baud the always-on debugger falls back to when nothing else says otherwise. */
 export const DEFAULT_DEBUG_BAUD = '115200'

src/backend/shared/types/PLC/open-plc.ts

@@ -299,11 +299,44 @@ const ModbusSlaveBufferMappingSchema = z.object({
 })
 type ModbusSlaveBufferMapping = z.infer<typeof ModbusSlaveBufferMappingSchema>
 
+// Bare-metal blocks of a Modbus server (DOPE-442). Mirrors ModbusRtuConfig /
+// ModbusTcpLinkConfig in `middleware/shared/ports/types`; they have to agree,
+// because this schema is what validates the project file and `z.object` drops
+// keys it does not declare.
+const ModbusSerialPortSchema = z.enum(['Serial', 'Serial1', 'Serial2', 'Serial3'])
+const ModbusBaudRateSchema = z.enum(['9600', '14400', '19200', '38400', '57600', '115200'])
+
+const ModbusRtuConfigSchema = z.object({
+  enabled: z.boolean(),
+  serialPort: ModbusSerialPortSchema,
+  baudRate: ModbusBaudRateSchema,
+  slaveId: z.number(),
+  useRs485EnPin: z.boolean(),
+  rs485EnPin: z.string(),
+})
+type ModbusRtuConfig = z.infer<typeof ModbusRtuConfigSchema>
+
+const ModbusTcpLinkConfigSchema = z.object({
+  enabled: z.boolean(),
+  medium: z.enum(['ethernet', 'wifi']),
+  macAddress: z.string(),
+  wifiSsid: z.string(),
+  wifiPassword: z.string(),
+  useDhcp: z.boolean(),
+  ipAddress: z.string(),
+  gateway: z.string(),
+  subnet: z.string(),
+  dns: z.string(),
+})
+type ModbusTcpLinkConfig = z.infer<typeof ModbusTcpLinkConfigSchema>
+
 const ModbusSlaveConfigSchema = z.object({
   enabled: z.boolean(),
   networkInterface: z.string(),
   port: z.number(),
   bufferMapping: ModbusSlaveBufferMappingSchema.optional(),
+  rtu: ModbusRtuConfigSchema.optional(),
+  tcpLink: ModbusTcpLinkConfigSchema.optional(),
 })
 type ModbusSlaveConfig = z.infer<typeof ModbusSlaveConfigSchema>
 
@@ -902,9 +935,11 @@ export {
   ModbusIOGroupSchema,
   ModbusIOPointSchema,
   ModbusParitySchema,
+  ModbusRtuConfigSchema,
   ModbusSlaveBufferMappingSchema,
   ModbusSlaveConfigSchema,
   ModbusTcpConfigSchema,
+  ModbusTcpLinkConfigSchema,
   ModbusTransportTypeSchema,
   OpcUaAddressSpaceConfigSchema,
   OpcUaAuthMethodSchema,
@@ -966,9 +1001,11 @@ export type {
   ModbusIOGroup,
   ModbusIOPoint,
   ModbusParity,
+  ModbusRtuConfig,
   ModbusSlaveBufferMapping,
   ModbusSlaveConfig,
   ModbusTcpConfig,
+  ModbusTcpLinkConfig,
   ModbusTransportType,
   OpcUaAddressSpaceConfig,
   OpcUaAuthMethod,