fix(creator5): correct msConfig color and temperatureCtl

Author: GhostTypes

src/api/controls/Control.test.ts

@@ -596,13 +596,16 @@ describe('Control', () => {
 
       const result = await control.configureSlot(2, 'PETG', '#46328E');
 
+      // Creator 5: color must be an exact firmware palette match — uppercase
+      // "#RRGGBB" WITH the leading "#". #46328E is off-palette and snaps to the
+      // nearest C5 entry, Purple (#48358C). NOT the stripped AD5X value.
       expect(result).toBe(true);
       expect(mockedAxios.post).toHaveBeenCalledWith(
         `http://printer:8898${Endpoints.Control}`,
         expect.objectContaining({
           payload: {
             cmd: Commands.MaterialStationConfigCmd,
-            args: { slot: 2, mt: 'PETG', rgb: '46328E' },
+            args: { slot: 2, mt: 'PETG', rgb: '#48358C' },
           },
         }),
         expect.any(Object)
@@ -620,6 +623,73 @@ describe('Control', () => {
     });
   });
 
+  // Creator 5 / Creator 5 Pro slot color: the firmware renders an icon ONLY on a
+  // byte-for-byte, case-sensitive match against its 24-entry palette (WITH the
+  // "#"). configureSlot must snap the caller's color to the nearest palette entry
+  // and emit uppercase "#RRGGBB" — never an off-list or stripped value.
+  describe('Creator 5 material-station slot color (palette snapping)', () => {
+    const paletteHexes = [
+      '#FFFFFF', '#FFF245', '#DEF578', '#21CC3D', '#167A4B', '#156682', '#24E4A0',
+      '#7BD9F0', '#4CAAF8', '#2E54DD', '#48358C', '#A341F7', '#F435F6', '#D5B4DE',
+      '#FA6173', '#F82D29', '#805003', '#F9903B', '#FCEBD7', '#D5C5A1', '#B17C38',
+      '#8C8C89', '#BEBEBE', '#1B1B1B',
+    ];
+
+    const captureRgb = async (hexRgb: string): Promise<string> => {
+      mockedAxios.post.mockClear();
+      await control.configureSlot(1, 'PLA', hexRgb);
+      const call = mockedAxios.post.mock.calls[0];
+      const payload = call[1] as { payload: { args: { rgb: string } } };
+      return payload.payload.args.rgb;
+    };
+
+    beforeEach(() => {
+      mockedAxios.post.mockResolvedValue({ status: 200, data: { code: 0, message: 'Success' } });
+      mockFiveMClient.isAD5X = false;
+      mockFiveMClient.isCreator5 = true;
+    });
+
+    it('always snaps to a value from the 24-entry C5 palette (never off-list)', async () => {
+      const inputs = ['#FF0000', '#123456', '#00FF00', '#ABCDEF', '#A341F7', '#112233', '#FEDCBA'];
+      for (const input of inputs) {
+        const rgb = await captureRgb(input);
+        expect(paletteHexes).toContain(rgb);
+      }
+    });
+
+    it('always emits uppercase hex with a leading "#"', async () => {
+      const rgb = await captureRgb('#ff0000');
+      expect(rgb.startsWith('#')).toBe(true);
+      expect(rgb).toBe(rgb.toUpperCase());
+      expect(rgb).toMatch(/^#[0-9A-F]{6}$/);
+    });
+
+    it('snaps #FF0000 (pure red) to #F82D29 (nearest palette red)', async () => {
+      expect(await captureRgb('#FF0000')).toBe('#F82D29');
+    });
+
+    it('snaps an exact palette entry to itself (case-normalized)', async () => {
+      expect(await captureRgb('#4CAAF8')).toBe('#4CAAF8');
+      expect(await captureRgb('#4caaf8')).toBe('#4CAAF8');
+      expect(await captureRgb('4caaF8')).toBe('#4CAAF8');
+    });
+
+    it('snaps white to #FFFFFF', async () => {
+      expect(await captureRgb('#FFFFFF')).toBe('#FFFFFF');
+      expect(await captureRgb('#FFF')).toBe('#FFFFFF');
+    });
+
+    // REGRESSION GUARD: the AD5X path must remain unchanged — freeform hex with
+    // the leading "#" stripped, no palette snapping.
+    it('AD5X path is unchanged: strips "#" and keeps freeform hex (no snapping)', async () => {
+      mockFiveMClient.isAD5X = true;
+      mockFiveMClient.isCreator5 = false;
+
+      expect(await captureRgb('#FF0000')).toBe('FF0000');
+      expect(await captureRgb('#46328E')).toBe('46328E');
+    });
+  });
+
   describe('sendJobControlCmd', () => {
     it('should send job control command', async () => {
       mockedAxios.post.mockResolvedValue({

src/api/controls/Control.ts

@@ -12,6 +12,7 @@ import type { Filament } from '../filament/Filament';
 import { NetworkUtils } from '../network/NetworkUtils';
 import { Commands } from '../server/Commands';
 import { Endpoints } from '../server/Endpoints';
+import { snapToCreator5Palette } from './creator5Palette';
 
 /**
  * Represents printer status information.
@@ -258,13 +259,17 @@ export class Control {
    * that **filament load/unload (`slotAction`) remains AD5X-only** — the Creator 5 firmware
    * has no `ms_cmd`, so {@link slotAction} stays gated to the AD5X.
    *
-   * The firmware accepts arbitrary material/color strings, but only the recognized
-   * materials and the 24-color UI palette render an icon on the printer — callers that
-   * want a clean display should map to the nearest recognized values first.
+   * The firmware accepts arbitrary material strings, but the two models render
+   * the slot color icon differently:
+   *  - AD5X: accepts freeform hex (the leading "#" is stripped before sending).
+   *  - Creator 5 / 5 Pro: renders an icon ONLY when `rgb` is a byte-for-byte,
+   *    case-sensitive match against the firmware's 24-entry palette (WITH the
+   *    "#"); any other value falls back to White. This method snaps the caller's
+   *    color to the nearest palette entry automatically for the Creator 5.
    *
    * @param slot The slot number (1-4).
    * @param materialName The material type (e.g., "PLA", "PETG").
-   * @param hexRgb The color as a hex string; a leading "#" is stripped to match the wire format ("RRGGBB").
+   * @param hexRgb The color as a hex string.
    * @returns A Promise that resolves to true if the command is successful, false otherwise.
    */
   public async configureSlot(
@@ -276,10 +281,19 @@ export class Control {
       console.log('configureSlot() error, material station only available on AD5X / Creator 5.');
       return false;
     }
+    // The AD5X and Creator 5 use MUTUALLY EXCLUSIVE color wire formats (see
+    // creator5Palette for the firmware match rules), so model-gate here:
+    //  - AD5X: freeform hex, the leading "#" stripped ("RRGGBB"). Unchanged.
+    //  - Creator 5 / 5 Pro: the firmware renders an icon ONLY on a byte-for-byte
+    //    match against its 24-entry palette (case-sensitive, WITH the "#"). Snap
+    //    the caller's color to the nearest palette entry in uppercase "#RRGGBB".
+    const rgb = this.client.isCreator5
+      ? snapToCreator5Palette(hexRgb).hex
+      : hexRgb.replace(/^#/, '');
     return await this.sendControlCommand(Commands.MaterialStationConfigCmd, {
       slot,
       mt: materialName,
-      rgb: hexRgb.replace(/^#/, ''),
+      rgb,
     });
   }
 

src/api/controls/TempControl.test.ts

@@ -286,4 +286,54 @@ describe('TempControl', () => {
       expect(mockSendControlCommand).not.toHaveBeenCalled();
     });
   });
+
+  // Creator 5 (isCreator5) drives its tools ONLY via the `nozzles` array; the
+  // firmware's doTemperatureControl handler never reads rightNozzle/leftNozzle.
+  // The generic setExtruderTemp/cancelExtruderTemp must therefore emit a 4-element
+  // `nozzles` array targeting the primary tool (T0) rather than rightNozzle.
+  // The describe above (httpOnly without isCreator5) covers the AD5X / 5M path,
+  // which keeps rightNozzle — a deliberate regression guard.
+  describe('Creator 5 extruder temp (httpOnly, per-tool nozzles[])', () => {
+    let mockSendControlCommand: ReturnType<typeof vi.fn>;
+    let c5TempControl: TempControl;
+
+    beforeEach(() => {
+      mockSendControlCommand = vi.fn().mockResolvedValue(true);
+      const httpClient = {
+        httpOnly: true,
+        isCreator5: true,
+        tcpClient: mockTcpClient,
+        control: { sendControlCommand: mockSendControlCommand },
+      } as unknown as FiveMClient;
+      c5TempControl = new TempControl(httpClient);
+    });
+
+    it('setExtruderTemp drives T0 via nozzles[] and does NOT send rightNozzle', async () => {
+      const result = await c5TempControl.setExtruderTemp(215);
+
+      expect(result).toBe(true);
+      expect(mockTcpClient.setExtruderTemp).not.toHaveBeenCalled();
+      expect(mockSendControlCommand).toHaveBeenCalledWith('temperatureCtl_cmd', {
+        rightNozzle: -200, // TEMP_NO_CHANGE — not set
+        leftNozzle: -200,
+        platform: -200,
+        chamber: -200,
+        nozzles: [215, -200, -200, -200],
+      });
+    });
+
+    it('cancelExtruderTemp turns T0 off via nozzles[] and does NOT send rightNozzle', async () => {
+      const result = await c5TempControl.cancelExtruderTemp();
+
+      expect(result).toBe(true);
+      expect(mockTcpClient.cancelExtruderTemp).not.toHaveBeenCalled();
+      expect(mockSendControlCommand).toHaveBeenCalledWith('temperatureCtl_cmd', {
+        rightNozzle: -200, // TEMP_NO_CHANGE — not set
+        leftNozzle: -200,
+        platform: -200,
+        chamber: -200,
+        nozzles: [-100, -200, -200, -200],
+      });
+    });
+  });
 });

src/api/controls/TempControl.ts

@@ -138,6 +138,17 @@ export class TempControl {
    */
   public async setExtruderTemp(temp: number): Promise<boolean> {
     if (this.client.httpOnly) {
+      // Creator 5 tools are driven ONLY via the `nozzles` array — the firmware's
+      // doTemperatureControl handler never reads rightNozzle/leftNozzle. Target
+      // the primary tool (T0): the active tool isn't reliably known over HTTP, so
+      // callers that need a specific tool should use setToolTemp(index, temp).
+      if (this.client.isCreator5) {
+        const nozzles = this.buildNozzleArray(0, temp);
+        if (nozzles === null) return false;
+        return await this.sendHttpTempCommand({ nozzles });
+      }
+      // Single-tool AD5X / 5M only reachable here if forced into httpOnly mode;
+      // they keep the rightNozzle field (unchanged).
       return await this.sendHttpTempCommand({ rightNozzle: temp });
     }
     return await this.tcpClient.setExtruderTemp(temp);
@@ -161,6 +172,14 @@ export class TempControl {
    */
   public async cancelExtruderTemp(): Promise<boolean> {
     if (this.client.httpOnly) {
+      // See setExtruderTemp: Creator 5 tools are driven only via `nozzles`. Turn
+      // the primary tool (T0) off while leaving the other tools unchanged.
+      if (this.client.isCreator5) {
+        const nozzles = this.buildNozzleArray(0, TEMP_OFF);
+        if (nozzles === null) return false;
+        return await this.sendHttpTempCommand({ nozzles });
+      }
+      // Single-tool AD5X / 5M (forced httpOnly) keep rightNozzle (unchanged).
       return await this.sendHttpTempCommand({ rightNozzle: TEMP_OFF });
     }
     return await this.tcpClient.cancelExtruderTemp();

src/api/controls/creator5Palette.test.ts

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Unit tests for the Creator 5 palette + nearest-color snapping.
+ * Verifies the CIEDE2000 perceptual snap produces byte-for-byte firmware palette
+ * matches (exact, case-sensitive "#RRGGBB") for the msConfig_cmd wire format.
+ */
+import { describe, expect, it } from 'vitest';
+import { CREATOR5_PALETTE, snapToCreator5Palette } from './creator5Palette';
+
+describe('snapToCreator5Palette', () => {
+  const paletteHexes = CREATOR5_PALETTE.map((c) => c.hex);
+
+  it('the palette has exactly 24 entries, all uppercase "#RRGGBB", index 0 = White', () => {
+    expect(CREATOR5_PALETTE).toHaveLength(24);
+    for (const c of CREATOR5_PALETTE) {
+      expect(c.hex).toMatch(/^#[0-9A-F]{6}$/);
+      expect(c.hex).toBe(c.hex.toUpperCase());
+    }
+    expect(CREATOR5_PALETTE[0]).toEqual({ index: 0, name: 'White', hex: '#FFFFFF' });
+  });
+
+  it('every palette entry snaps to itself', () => {
+    for (const c of CREATOR5_PALETTE) {
+      expect(snapToCreator5Palette(c.hex).hex).toBe(c.hex);
+    }
+  });
+
+  it('never returns an off-palette value', () => {
+    const inputs = ['#FF0000', '#123456', '#00FF00', '#ABCDEF', '#112233', '#FEDCBA', '#8080FF'];
+    for (const input of inputs) {
+      const snapped = snapToCreator5Palette(input).hex;
+      expect(paletteHexes).toContain(snapped);
+    }
+  });
+
+  it('always returns uppercase "#RRGGBB" with the leading "#"', () => {
+    for (const input of ['#ff0000', 'ff0000', '#4caaf8', '4CAAf8', '#abc']) {
+      const snapped = snapToCreator5Palette(input).hex;
+      expect(snapped).toMatch(/^#[0-9A-F]{6}$/);
+    }
+  });
+
+  it('snaps pure red #FF0000 to palette Red #F82D29', () => {
+    expect(snapToCreator5Palette('#FF0000').hex).toBe('#F82D29');
+  });
+
+  it('snaps an exact palette entry to itself regardless of input case/shape', () => {
+    expect(snapToCreator5Palette('#4CAAF8').hex).toBe('#4CAAF8');
+    expect(snapToCreator5Palette('#4caaf8').hex).toBe('#4CAAF8');
+    expect(snapToCreator5Palette('4caaF8').hex).toBe('#4CAAF8');
+  });
+
+  it('snaps white to #FFFFFF (3-digit shorthand too)', () => {
+    expect(snapToCreator5Palette('#FFFFFF').hex).toBe('#FFFFFF');
+    expect(snapToCreator5Palette('#FFF').hex).toBe('#FFFFFF');
+  });
+
+  it('falls back to White (index 0) on unparseable input', () => {
+    expect(snapToCreator5Palette('not-a-color')).toEqual(CREATOR5_PALETTE[0]);
+    expect(snapToCreator5Palette('')).toEqual(CREATOR5_PALETTE[0]);
+  });
+});