The Wall Unit and Corridor Door Dome LEDs operate as standard Modbus RTU Slaves on an industrial half-duplex RS-485 bus.

Buttons are indexed in standard reading order (Top-Left → Top-Right → Bottom-Left → Bottom-Right):

The hardware uses 3 microcontroller GPIO pins (Red, Green, Blue) to produce 7 pure digital colors (Simple ON/OFF logic):

A. Real-Time Inputs & Status (Read Only)

B. Configuration & Button RGB Color Registers (Saved in Non-Volatile EEPROM)

When the Gateway commissions a device, it writes this complete configuration block into the unit's EEPROM:

The Corridor Door Light is an independent Modbus Slave that displays active calls for the room/ward and automatically alternates colors when multiple beds call at once:

A. The Two Discovery Modes (Handling Factory-Tested Devices with Duplicate IDs)

Even if devices arrive from the factory with identical temporary test IDs (e.g. all set to ID 1), our Commissioned Status Flag (Reg 253) guarantees zero collisions:

Gateway Master Request (New Only):  00 06 00 FE 00 AA 28 69  (Broadcast 0x00, Reg 254 = 0x00AA)
Gateway Master Request (Force All): 00 06 00 FE 00 FF A9 B9  (Broadcast 0x00, Reg 254 = 0x00FF)

Gateway Master Request: FF 03 00 00 00 01 91 D4  (Read Reg 0 on Slave 255)
Selected Slave Response: FF 03 02 00 AA 11 94  (Reg 0 = 0x00AA -> Unit is Selected!)

Gateway Master Request: FF 06 00 FF 00 65 AC 23  (Write Reg 255 = 101 to Slave 255)
Slave Echo Response:    FF 06 00 FF 00 65 AC 23  (Slave echoes back confirmation)

B. Complete Microcontroller Discovery State Machine (C Code)

// =========================================================================
// MICROCONTROLLER DISCOVERY & SLAVE ID STATE MACHINE (C / C++)
// =========================================================================

enum DeviceState {
    STATE_NORMAL_RUNNING,       // Normal hospital operation
    STATE_DISCOVERY_FLASHING,   // Rapid LED blink after receiving Broadcast
    STATE_PAIRING_SELECTED,     // Technician held Button 1 for 3s
    STATE_ID_CONFIRMED          // Green 3s confirmation after ID write
};

enum DeviceState current_state = STATE_NORMAL_RUNNING;
uint32_t blink_timer = 0;
bool blink_led_toggle = false;

// 1. In your Main Loop (called continuously):
void loop_discovery_handler() {
    // If in Discovery Flashing Mode -> Blink all LEDs at 2.5Hz (200ms ON / 200ms OFF)
    if (current_state == STATE_DISCOVERY_FLASHING) {
        if (millis() - blink_timer >= 200) {
            blink_timer = millis();
            blink_led_toggle = !blink_led_toggle;
            set_all_leds(blink_led_toggle ? COLOR_CYAN : COLOR_OFF);
        }
    }
}

// 2. In your Button ISR / Polling Routine:
void on_button1_held_3_seconds() {
    // If unit is in Discovery Mode and Button 1 is held 3s -> Select this unit!
    if (current_state == STATE_DISCOVERY_FLASHING) {
        current_state = STATE_PAIRING_SELECTED;
        live_status_reg0 = 0x00AA; // Set Reg 0 = 0x00AA (Signals Gateway)
        
        // Show Solid Yellow on Button 1 to show technician it is selected
        set_button_led(0, COLOR_YELLOW); 
    }
}

// 3. In your Modbus Register Write Callback:
void handle_modbus_register_write(uint8_t slave_addr, uint16_t reg_addr, uint16_t write_val) {
    // A. Broadcast Discovery Command (Reg 254 / 0x00FE)
    if (reg_addr == 0x00FE) {
        if (write_val == 0x00AA) {
            // Mode 1: Only uncommissioned units (Reg 253 == 0) blink!
            if (config.is_commissioned == 0) {
                current_state = STATE_DISCOVERY_FLASHING;
            }
        } else if (write_val == 0x00FF) {
            // Mode 2: Force ALL units on bus to blink!
            current_state = STATE_DISCOVERY_FLASHING;
        } else if (write_val == 0x0000) {
            // Stop discovery
            current_state = STATE_NORMAL_RUNNING;
            set_all_leds_idle();
        }
    }
    
    // B. Slave ID Assignment (Reg 255 / 0x00FF)
    else if (reg_addr == 0x00FF) {
        if (write_val >= 1 && write_val <= 247) {
            // 1. Burn new Slave ID and mark as Commissioned in EEPROM
            config.slave_id = (uint8_t)write_val;
            config.is_commissioned = 1; // Mark as Commissioned (Reg 253)
            save_config_to_eeprom();
            
            // 2. Visual & Audible Confirmation
            current_state = STATE_ID_CONFIRMED;
            set_all_leds(COLOR_GREEN); // Turn ALL LEDs Solid Green
            buzzer_beep(200);          // 200ms confirmation beep
            delay_ms(3000);            // Hold Solid Green for 3.0 seconds
            
            // 3. Switch active Modbus listening address to the new ID
            modbus_set_slave_address(config.slave_id);
            
            // 4. Return to normal operation
            current_state = STATE_NORMAL_RUNNING;
            live_status_reg0 = 0x0000;
            set_all_leds_idle();
        }
    }
}

To make it 100% simple for the microcontroller firmware developer, here is the complete EEPROM memory layout that must be allocated in non-volatile Flash/EEPROM:

Complete C/C++ firmware skeleton for the hardware microcontroller:

// =========================================================================
// SISCALL PRO - MICROCONTROLLER FIRMWARE REFERENCE IMPLEMENTATION (C / C++)
// =========================================================================

#include <stdint.h>
#include <stdbool.h>

// --- EEPROM Non-Volatile Memory Storage Structure (21 Bytes Total) ---
typedef struct {
    uint8_t  slave_id;              // Reg 255: Default 255 (0xFF)
    uint8_t  is_commissioned;       // Reg 253: 0 = Factory/Uncommissioned, 1 = Commissioned
    uint16_t single_press_mask;     // Reg 1: Single-press enable bitmask
    uint16_t long_press_mask;       // Reg 2: Long-press enable bitmask
    uint16_t long_press_hold_ms;    // Reg 3: Default 2000 ms
    uint16_t debounce_ms;           // Reg 4: Default 50 ms
    uint8_t  idle_glow_color;       // Reg 5: Default 3 (Blue)
    uint8_t  btn_sp_color[4];       // Reg 20, 22, 24, 26 (Button 1..4 Single-Press Color)
    uint8_t  btn_lp_color[4];       // Reg 21, 23, 25, 27 (Button 1..4 Long-Press Color)
    uint8_t  toilet_color;          // Reg 28: Attached Toilet Color (Default 4 = Yellow)
    uint8_t  handset_color;         // Reg 29: Attached Handset Color (Default 4 = Yellow)
} DeviceConfig_t;

DeviceConfig_t config;
uint16_t live_status_reg0 = 0x0000; // Reg 0: Live bitmask read by Gateway

// --- GPIO Pin Output Function for 7-Color Digital RGB ---
void set_rgb_pins(uint8_t red_pin, uint8_t green_pin, uint8_t blue_pin, uint8_t color_code) {
    switch(color_code) {
        case 0: digitalWrite(red_pin, 0); digitalWrite(green_pin, 0); digitalWrite(blue_pin, 0); break; // OFF
        case 1: digitalWrite(red_pin, 1); digitalWrite(green_pin, 0); digitalWrite(blue_pin, 0); break; // RED
        case 2: digitalWrite(red_pin, 0); digitalWrite(green_pin, 1); digitalWrite(blue_pin, 0); break; // GREEN
        case 3: digitalWrite(red_pin, 0); digitalWrite(green_pin, 0); digitalWrite(blue_pin, 1); break; // BLUE
        case 4: digitalWrite(red_pin, 1); digitalWrite(green_pin, 1); digitalWrite(blue_pin, 0); break; // YELLOW
        case 5: digitalWrite(red_pin, 0); digitalWrite(green_pin, 1); digitalWrite(blue_pin, 1); break; // CYAN
        case 6: digitalWrite(red_pin, 1); digitalWrite(green_pin, 0); digitalWrite(blue_pin, 1); break; // PURPLE
        case 7: digitalWrite(red_pin, 1); digitalWrite(green_pin, 1); digitalWrite(blue_pin, 1); break; // WHITE
    }
}

// --- Button Timing & State Machine ---
void handle_button_press(uint8_t btn_index, uint32_t hold_duration_ms) {
    if (hold_duration_ms >= config.long_press_hold_ms) {
        if (config.long_press_mask & (1 << (btn_index * 2 + 1))) {
            live_status_reg0 |= (1 << (btn_index * 2 + 1));
            set_button_led(btn_index, config.btn_lp_color[btn_index]);
        }
    } else if (hold_duration_ms >= config.debounce_ms) {
        if (config.single_press_mask & (1 << (btn_index * 2))) {
            live_status_reg0 |= (1 << (btn_index * 2));
            set_button_led(btn_index, config.btn_sp_color[btn_index]);
        }
    }
}

Example 1: Master Polls Wall Unit Status (Read Reg 0 on Slave ID 1)

Master sends Function Code 0x03 to Slave 1, starting at address 0x0000, quantity 1:

Master Request:  01 03 00 00 00 01 84 0A  (Slave 1, FC 03, Reg 0, Qty 1, CRC)
Slave Response:  01 03 02 00 01 79 84     (Slave 1, FC 03, 2 Bytes, Value = 0x0001 [Button 1 Pressed], CRC)

Example 2: Master Broadcasts Discovery Mode (Reg 254 = 0x00AA or 0x00FF)

Master writes 0x00AA (Pending Only) or 0x00FF (Force All) to Register 254 (0x00FE) using Broadcast address 0x00:

Broadcast New/Pending Only: 00 06 00 FE 00 AA 28 69  (Broadcast 0x00, FC 06, Reg 254 = 0x00AA, CRC)
Broadcast Force ALL Units:  00 06 00 FE 00 FF A9 B9  (Broadcast 0x00, FC 06, Reg 254 = 0x00FF, CRC)

Example 3: Master Assigns Slave ID 101 (Reg 255 = 101)

Master writes value 101 (0x0065) to Register 255 (0x00FF):

Master Request:  FF 06 00 FF 00 65 AC 23  (Target Slave 255, FC 06, Reg 255, Value 101, CRC)
Slave Response:  FF 06 00 FF 00 65 AC 23  (Echo Response, then burns ID 101 and sets Reg 253=1 into EEPROM)

Example 4: Master Sets Corridor Door Light to Alternating Cycle Mode

Master writes Mode 3 (Multi-Call Cycle) with Color 1 (Yellow = 4) and Color 2 (Red = 1) to Door LED Slave 20:

Write Mode (Reg 0 = 3):    14 06 00 00 00 03 C8 CF
Write Color 1 (Reg 1 = 4): 14 06 00 01 00 04 D9 0E
Write Color 2 (Reg 2 = 1): 14 06 00 02 00 01 E9 0E
Write Interval (Reg 10 = 1500ms): 14 06 00 0A 05 DC AC 2A