The Wall Unit and Corridor Door Dome LEDs operate as high-reliability Station Nodes on an industrial half-duplex communication network.

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 / Write Registers)

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

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

This section provides the complete reference implementation and exact state machine rules for the wall unit microcontroller firmware developer:

Microcontroller Button Handler (Single-Pass Pipeline with Call Snooze & Dynamic Buzzer Evaluation):

/* Microcontroller Button Press Handler with Multi-Action Bitmask Pipeline (Single-Pass, No Early Returns) */
void handle_button_event(uint8_t btn_index, bool is_long_press) {
    // 0. Read configured Action Bitmask, Color, and Priority Rank from EEPROM
    uint8_t action_mask = get_action_mask_from_eeprom(btn_index, is_long_press);
    uint8_t led_color   = get_color_code_from_eeprom(btn_index, is_long_press);
    uint8_t prio_rank   = get_priority_rank_from_eeprom(btn_index, is_long_press); // Regs 40061..40076 (1..16, 0 for non-calls)

    // Ignore if action code is 0 (0 = Disabled / No Action)
    if (action_mask == 0) {
        return;
    }

    // 1. CLEAR_ALL (0x0001): Immediate local 0ms call reset
    bool has_clear = (action_mask & 0x0001) != 0;
    if (has_clear) {
        turn_off_all_button_leds();
        set_hold_led(false);
        stop_buzzer();
        clear_all_active_calls(); // Clears all call records and their snooze states
        // Do NOT return: allow subsequent non-call actions (e.g. Staff Check-in 0x0010) to execute!
    }

    // 2. Call Actions (0x0002 Solid, 0x0020 Blink, 0x0040 Cycle)
    // Only register call if not cleared in step 1 (Clear All takes precedence over call bits)
    if (!has_clear && (action_mask & (0x0002 | 0x0020 | 0x0040))) {
        register_button_call(btn_index, action_mask, led_color, prio_rank); // Initializes call->muted = false
    }

    // 3. Evaluate Winning Active Call after any registration or clear
    uint8_t win_btn = evaluate_highest_priority_active_call(); // Returns winning button index or NO_ACTIVE_CALL
    if (win_btn != NO_ACTIVE_CALL) {
        uint8_t win_mask  = get_action_mask(win_btn);
        uint8_t win_color = get_color(win_btn);

        // Visual rendering: BLINK (0x0020) takes precedence over SOLID (0x0002)
        if (win_mask & 0x0020) {
            set_button_led_blink(win_btn, win_color);
        } else if (win_mask & 0x0002) {
            set_button_led_solid(win_btn, win_color);
        }

        // Multi-call alternating cycle (0x0040) runs concurrently if active
        if (win_mask & 0x0040) {
            start_color_alternating_loop();
        }
    }

    // 4. ACKNOWLEDGE (0x0004): Acknowledges active winning call (only when pressed as non-call action)
    if ((action_mask & 0x0004) && !(action_mask & (0x0002 | 0x0020 | 0x0040))) {
        if (win_btn != NO_ACTIVE_CALL) {
            set_hold_led(true);
            set_active_call_led_solid();
            ActiveCall_t *call = get_active_call(win_btn);
            if (call) call->muted = true; // Acknowledge silences the active call
        }
        stop_buzzer();
    }

    // 5. MUTE_BUZZER (0x0008) when pressed alone as a snooze action (without call bits)
    if ((action_mask & 0x0008) && !(action_mask & (0x0002 | 0x0020 | 0x0040))) {
        if (win_btn != NO_ACTIVE_CALL) {
            ActiveCall_t *call = get_active_call(win_btn);
            if (call) call->muted = true; // Mark active winning call as snoozed
        }
        stop_buzzer();
    }

    // 6. Dynamic Buzzer Evaluation from Winning Call
    // Sound buzzer ONLY if winning call exists, is not configured as silent (0x0008 in mask), and is not snoozed
    if (win_btn != NO_ACTIVE_CALL) {
        ActiveCall_t *win_call = get_active_call(win_btn);
        if (win_call && !(win_call->action_mask & 0x0008) && !win_call->muted) {
            start_buzzer_beep();
        } else {
            stop_buzzer(); // Silent call stays silent while on top; snoozed call remains quiet
        }
    } else {
        stop_buzzer();
    }

    // 7. STAFF_CHECKIN (0x0010): 3.0s visual confirmation + 100ms short chirp
    if (action_mask & 0x0010) {
        flash_confirmation_led(3000);
        play_short_chirp();
    }

    // 8. Latch Modbus Live Status Register 40001 once at the end for all enabled presses
    latch_live_status_bit(btn_index, is_long_press);
}

/* Modbus Write Callback for Global Emergency Register 40050 */
void on_modbus_reg_40050_written(uint16_t value) {
    if (value == 1) {
        start_all_4_leds_red_flash_with_continuous_alarm();
    } else {
        stop_emergency_alarm_and_restore_standby();
    }
}

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. Gateway rules: 1 active call → Mode 1; 2+ active calls → Mode 3 (skipping color 0 slots); Any Priority 1 call → Mode 2 (emergency red flash). The Gateway writes Registers 40001–40007 in a single FC 16 write to eliminate visual flicker:

Corridor Dome EEPROM Memory Layout (8 Bytes Total):

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 69 94  (Broadcast 0x00, Reg 254 = 0x00AA)
Gateway Master Request (Force All): 00 06 00 FE 00 FF A9 AB  (Broadcast 0x00, Reg 254 = 0x00FF)

Gateway Master Request: FF 03 00 FC 00 01 51 E4  (Read Reg 252/40253 on Slave 255)
Selected Slave Response: FF 03 02 00 01 50 50     (Reg 40253 = 1 -> Unit is Selected!)

Gateway Master Request: FF 06 00 FF 00 65 6C 0F  (Write Reg 255 = 101 to Slave 255)
Slave Echo Response:    FF 06 00 FF 00 65 6C 0F  (Slave echoes back confirmation from current address)

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 (Reg 40253 = 1)
    STATE_ID_CONFIRMED          // Green 3s non-blocking confirmation after ID write
};

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

// 1. In your Main Loop (called continuously):
void loop_discovery_handler() {
    // A. Auto-exit discovery mode after 10-minute timeout
    if (current_state == STATE_DISCOVERY_FLASHING || current_state == STATE_PAIRING_SELECTED) {
        if (millis() - discovery_timeout_timer >= 600000) { // 10 min
            current_state = STATE_NORMAL_RUNNING;
            reg_40253_pairing_selected = 0;
            set_all_leds_idle();
        }
    }

    // B. 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);
        }
    }

    // C. Non-blocking Green 3-second confirmation
    if (current_state == STATE_ID_CONFIRMED) {
        if (millis() - green_confirm_timer >= 3000) {
            current_state = STATE_NORMAL_RUNNING;
            set_all_leds_idle();
        }
    }
}

// 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;
        reg_40253_pairing_selected = 1; // Dedicated pairing flag
        set_button_led(0, COLOR_YELLOW); // Solid Yellow on Button 1
    }
}

// 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) {
            if (config.is_commissioned == 0) {
                current_state = STATE_DISCOVERY_FLASHING;
                discovery_timeout_timer = millis();
            }
        } else if (write_val == 0x00FF) {
            current_state = STATE_DISCOVERY_FLASHING;
            discovery_timeout_timer = millis();
        } else if (write_val == 0x0000) {
            current_state = STATE_NORMAL_RUNNING;
            reg_40253_pairing_selected = 0;
            set_all_leds_idle();
        }
    }
    
    // B. Slave ID Assignment (Reg 255 / 0x00FF)
    else if (reg_addr == 0x00FF) {
        // At address 255, only accept write if this unit is selected
        if (slave_addr == 255 && current_state != STATE_PAIRING_SELECTED) {
            return; // Ignore write to prevent multi-device collisions
        }

        if (write_val >= 1 && write_val <= 247) {
            // 1. Send Modbus echo reply FIRST from current address before switching
            send_modbus_echo_reply(slave_addr, reg_addr, write_val);

            // 2. Burn new Slave ID and mark as Commissioned in EEPROM
            config.slave_id = (uint8_t)write_val;
            config.is_commissioned = 1;
            reg_40253_pairing_selected = 0;
            save_config_to_eeprom();
            
            // 3. Switch active Modbus listening address
            modbus_set_slave_address(config.slave_id);

            // 4. Visual & Audible Non-Blocking Confirmation
            current_state = STATE_ID_CONFIRMED;
            green_confirm_timer = millis();
            set_all_leds(COLOR_GREEN);
            buzzer_beep(200);
        }
    }
}

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

Complete C/C++ packed firmware structure and state handler for the hardware microcontroller:

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

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

// --- EEPROM Non-Volatile Memory Storage Structure (53 Bytes Total, Packed) ---
typedef struct __attribute__((packed)) {
    uint8_t  slave_id;                  // 0x00: Reg 255 (Default 255 / 0xFF)
    uint8_t  is_commissioned;           // 0x01: Reg 253 (0 = Factory/Uncommissioned, 1 = Commissioned)
    uint16_t single_press_mask;         // 0x02..0x03: Reg 1 (Default 0xFFFF)
    uint16_t long_press_mask;           // 0x04..0x05: Reg 2 (Default 0xFFFF)
    uint16_t long_press_hold_ms;        // 0x06..0x07: Reg 3 (Default 2000 ms)
    uint16_t debounce_ms;               // 0x08..0x09: Reg 4 (Default 50 ms)
    uint8_t  idle_glow_color;           // 0x0A: Reg 5 (Default 3 = Blue)
    
    // Action Code Bitmasks (16 Bytes: 0x0B..0x1A)
    uint8_t  btn_sp_action[4];          // 0x0B..0x0E: Reg 10,12,14,16 (Default: 2, 32, 2, 4)
    uint8_t  btn_lp_action[4];          // 0x0F..0x12: Reg 11,13,15,17 (Default: 32, 32, 2, 1)
    uint8_t  toilet_btn1_action[2];     // 0x13..0x14: Reg 18,19 (Default: 32, 32)
    uint8_t  toilet_btn2_action[2];     // 0x15..0x16: Reg 36,37 (Default: 1, 1)
    uint8_t  remote_action[4];          // 0x17..0x1A: Reg 30..33 (Default: 2, 32, 4, 1)

    // RGB Color Codes (10 Bytes: 0x1B..0x24)
    uint8_t  btn_sp_color[4];           // 0x1B..0x1E: Reg 20,22,24,26 (Default: 4, 1, 5, 2)
    uint8_t  btn_lp_color[4];           // 0x1F..0x22: Reg 21,23,25,27 (Default: 1, 1, 1, 0)
    uint8_t  toilet_color;              // 0x23: Reg 28 (Default 4 = Yellow)
    uint8_t  handset_color;             // 0x24: Reg 29 (Default 4 = Yellow)

    // Priority Ranks (16 Bytes: 0x25..0x34, 1..16, 0 for non-calls)
    uint8_t  btn_sp_priority[4];        // 0x25..0x28: Reg 60,62,64,66 (Default: 3, 1, 4, 0)
    uint8_t  btn_lp_priority[4];        // 0x29..0x2C: Reg 61,63,65,67 (Default: 2, 1, 4, 0)
    uint8_t  toilet_btn1_priority[2];   // 0x2D..0x2E: Reg 68,69 (Default: 2, 1)
    uint8_t  toilet_btn2_priority[2];   // 0x2F..0x30: Reg 70,71 (Default: 0, 0)
    uint8_t  remote_priority[4];        // 0x31..0x34: Reg 72..75 (Default: 3, 2, 0, 0)
} DeviceConfig_t;

DeviceConfig_t config;
uint16_t live_status_reg40001 = 0x0000; // Latched bits cleared by Reg 40009
uint16_t continuous_status_reg40008 = 0x0000; // Bit 0 = Bed Occ, Bit 1 = Tamper

// --- 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; // MAGENTA
        case 7: digitalWrite(red_pin, 1); digitalWrite(green_pin, 1); digitalWrite(blue_pin, 1); break; // WHITE
    }
}

Example 1: Master Polls Wall Unit Status (Read Reg 0 on Slave ID 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)

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

Example 3: Master Reads Dedicated Pairing Flag (Register 40253 / Offset 252 on Slave 255)

Master Request:  FF 03 00 FC 00 01 51 E4  (Slave 255, FC 03, Reg 252, Qty 1, CRC)
Slave Response:  FF 03 02 00 01 50 50     (Slave 255, FC 03, 2 Bytes, Reg 40253 = 1 [Unit Selected], CRC)

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

Master Request:  FF 06 00 FF 00 65 6C 0F  (Target Slave 255, FC 06, Reg 255, Value 101, CRC)
Slave Response:  FF 06 00 FF 00 65 6C 0F  (Echo Response, burns ID 101 & sets Reg 253=1 into EEPROM)

Example 5: Master Configures Silent Nurse Call Bitmask (10 = 0x000A)

Master Request:  01 06 00 0A 00 0A 29 CF  (Slave 1, FC 06, Reg 10, Value 0x000A, CRC)

Example 6: Master Configures Call + Attendance Bitmask (18 = 0x0012)

Master Request:  01 06 00 0A 00 12 29 C5  (Slave 1, FC 06, Reg 10, Value 0x0012, CRC)

Example 7: Master Configures Corridor Door Dome Light (Slave 20)

Write Mode (Reg 0 = 3):     14 06 00 00 00 03 CB 0E
Write Color 1 (Reg 1 = 4):  14 06 00 01 00 04 DB 0C
Write Color 2 (Reg 2 = 1):  14 06 00 02 00 01 EB 0F
Write Interval (Reg 10 = 1500ms): 14 06 00 0A 05 DC A9 C4