From fb5d135619fd54de84ad6acb28350407afa5f73c Mon Sep 17 00:00:00 2001
From: gudae <guseorn12@daum.nett>
Date: Mon, 15 Jun 2026 13:54:00 +0900
Subject: [PATCH] modify: login GUI

---
 .vs/Housing/DesignTimeBuild/.dtbcache.v2 | Bin 122439 -> 122699 bytes
 Database.ini                             |   9 +
 Hardware.ini                             |  13 +-
 Login/StartupLoginWindow.xaml            |   5 +-
 Login/StartupLoginWindow.xaml.cs         | 313 +++++++++++++++++++++--
 MainWindow.xaml                          |   4 +-
 MainWindow.xaml.cs                       | 191 +++++++++++++-
 Services/BoardTestService.cs             |  14 +-
 Services/HousingAssemblyRepository.cs    |  85 +++++-
 Services/LoginAccountRepository.cs       |  58 +++++
 Services/LoginHistoryStore.cs            |  99 +++++++
 Services/LoginSettings.cs                |  86 +++++++
 Services/Ni6501StartSignalWatcher.cs     | 191 ++++++++++++++
 Services/StartSignalSettings.cs          | 125 +++++++++
 Services/StartSignalWatcher.cs           |  40 +++
 Services/TcpStartSignalWatcher.cs        | 151 +++++++++++
 16 files changed, 1332 insertions(+), 52 deletions(-)
 create mode 100644 Services/LoginAccountRepository.cs
 create mode 100644 Services/LoginHistoryStore.cs
 create mode 100644 Services/LoginSettings.cs
 create mode 100644 Services/Ni6501StartSignalWatcher.cs
 create mode 100644 Services/StartSignalSettings.cs
 create mode 100644 Services/StartSignalWatcher.cs
 create mode 100644 Services/TcpStartSignalWatcher.cs

diff --git a/.vs/Housing/DesignTimeBuild/.dtbcache.v2 b/.vs/Housing/DesignTimeBuild/.dtbcache.v2
index 1e212145c4cd59c351eff0ea1b604b17e6ce7b6e..f13f2f9b80909e91e2efc1a9cb7328d5de91e545 100644
GIT binary patch
delta 9149
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

delta 8424
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

diff --git a/Database.ini b/Database.ini
index d4caecb..a76da2b 100644
--- a/Database.ini
+++ b/Database.ini
@@ -6,3 +6,12 @@ DbPw=your_password
 Encrypt=True
 TrustServerCertificate=True
 Timeout=5
+
+[Login]
+; 로그인 승인에 사용할 DB 테이블/컬럼입니다.
+; 별도 작업자 테이블이 있으면 이 값을 해당 테이블/컬럼으로 바꾸세요.
+Table=dbo.Housing_Assembly
+IdColumn=Operator
+PasswordColumn=Password
+; DB 연결이 안 되는 상태에서 화면만 확인할 때 true로 둡니다. 운영 시 false로 바꾸세요.
+OfflinePreview=true
diff --git a/Hardware.ini b/Hardware.ini
index e0f0927..129f34f 100644
--- a/Hardware.ini
+++ b/Hardware.ini
@@ -10,12 +10,21 @@ EndToken=<end>
 DtrEnable=false
 RtsEnable=false
 
+[StartSignal]
+; USB-6501
+Enabled=true
+Connection=Ni6501
+PhysicalChannel=Dev1/port0/line0
+ActiveState=High
+PollIntervalMilliseconds=50
+TimeoutMilliseconds=30000
+PostSignalDelayMilliseconds=2000
+RequireInactiveBeforeStart=true
+
 [Equipment]
-; 목표: 장비 화면에 표시되는 현재 측정값을 읽습니다.
 ; V 출력: Keysight 34465A DMM 값
 ; A 출력: Keysight E36233A Power Supply CH1 Current 값
 ; USB 장비는 Keysight Connection Expert 또는 NI MAX에서 보이는 VISA 주소를 Resource에 넣으세요.
-; 예: USB0::0x2A8D::0x1301::MY12345678::INSTR
 Timeout=5000
 SettleMilliseconds=300
 PreBoardCommand=VOLT 5, (@2);OUTP ON, (@2)
diff --git a/Login/StartupLoginWindow.xaml b/Login/StartupLoginWindow.xaml
index 84a2c3e..2f7b687 100644
--- a/Login/StartupLoginWindow.xaml
+++ b/Login/StartupLoginWindow.xaml
@@ -513,7 +513,8 @@
                         </Border>
                     </Grid>
 
-                    <Button Grid.Row="9"
+                    <Button x:Name="LoginButton"
+                            Grid.Row="9"
                             Content="ACCESS / LOG IN"
                             Style="{StaticResource CommandButtonStyle}"
                             Click="LogInButton_Click"/>
@@ -521,4 +522,4 @@
             </Grid>
         </Border>
     </Grid>
-</Window>
\ No newline at end of file
+</Window>
diff --git a/Login/StartupLoginWindow.xaml.cs b/Login/StartupLoginWindow.xaml.cs
index 2b4ba05..f73f61f 100644
--- a/Login/StartupLoginWindow.xaml.cs
+++ b/Login/StartupLoginWindow.xaml.cs
@@ -1,5 +1,10 @@
 using System;
+using System.IO;
 using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Threading;
+using Housing.Services;
 
 namespace Housing.Login;
 
@@ -18,59 +23,311 @@ public sealed class StartupLoginWindowResult
 
 public partial class StartupLoginWindow : Window
 {
-    private const string MasterId = "su";
-    private const string MasterPassword = "su";
+    private const string OperatorHistoryFieldName = "Operator";
+    private const string SuppressedOperatorHistoryValue = "su";
+    private readonly LoginHistoryStore _loginHistoryStore;
+    private Popup? _openHistoryPopup;
 
     public StartupLoginWindowResult Result { get; private set; } = new();
 
     public StartupLoginWindow()
     {
+        _loginHistoryStore = LoginHistoryStore.Load(GetLoginHistoryPath());
+        RemoveSuppressedOperatorHistory();
         InitializeComponent();
+        AttachLoginHistoryMenus();
+        PasswordBox.GotKeyboardFocus += (_, _) => CloseHistoryPopup();
+        LoginButton.GotKeyboardFocus += (_, _) => CloseHistoryPopup();
         OperatorTextBox.Focus();
     }
 
-    private void LogInButton_Click(object sender, RoutedEventArgs e)
+    private async void LogInButton_Click(object sender, RoutedEventArgs e)
     {
-        var loginId = OperatorTextBox.Text.Trim();
-        var password = PasswordBox.Password;
+        CloseHistoryPopup();
 
-        if (string.IsNullOrWhiteSpace(loginId))
+        if (!TryReadRequiredFields(out var loginResult))
         {
-            MessageBox.Show(this, "ID를 입력하세요.", "Login", MessageBoxButton.OK, MessageBoxImage.Warning);
-            OperatorTextBox.Focus();
             return;
         }
 
-        if (string.IsNullOrWhiteSpace(password))
+        if (sender is Button button)
         {
-            MessageBox.Show(this, "PW를 입력하세요.", "Login", MessageBoxButton.OK, MessageBoxImage.Warning);
-            PasswordBox.Focus();
-            return;
+            button.IsEnabled = false;
         }
 
-        if (!string.Equals(loginId, MasterId, StringComparison.Ordinal) ||
-            !string.Equals(password, MasterPassword, StringComparison.Ordinal))
+        try
         {
-            MessageBox.Show(this, "마스터 계정만 로그인할 수 있습니다.", "Login", MessageBoxButton.OK, MessageBoxImage.Error);
-            PasswordBox.Clear();
-            PasswordBox.Focus();
-            return;
+            var loginSettings = LoginSettings.Load(GetDatabaseIniPath());
+            if (loginSettings.OfflinePreview)
+            {
+                Result = loginResult;
+                SaveLoginHistory(loginResult);
+                DialogResult = true;
+                Close();
+                return;
+            }
+
+            var repository = new LoginAccountRepository(
+                DatabaseSettings.Load(GetDatabaseIniPath()),
+                loginSettings);
+
+            if (!await repository.ExistsAsync(loginResult.Operator, loginResult.Password))
+            {
+                MessageBox.Show(this, "DB에 등록된 ID/PW가 아닙니다.", "Login", MessageBoxButton.OK, MessageBoxImage.Error);
+                PasswordBox.Clear();
+                PasswordBox.Focus();
+                return;
+            }
+
+            Result = loginResult;
+            SaveLoginHistory(loginResult);
+            DialogResult = true;
+            Close();
         }
+        catch (Exception ex)
+        {
+            MessageBox.Show(this, $"로그인 DB 확인 실패: {ex.Message}", "Login", MessageBoxButton.OK, MessageBoxImage.Error);
+            OperatorTextBox.Focus();
+            OperatorTextBox.SelectAll();
+        }
+        finally
+        {
+            if (sender is Button loginButton)
+            {
+                loginButton.IsEnabled = true;
+            }
+        }
+    }
 
-        Result = new StartupLoginWindowResult
+    private bool TryReadRequiredFields(out StartupLoginWindowResult result)
+    {
+        result = new StartupLoginWindowResult();
+
+        if (!TryReadTextBox(MakerTextBox, "Maker", out var maker) ||
+            !TryReadTextBox(ModelTextBox, "Model", out var model) ||
+            !TryReadTextBox(Variant1TextBox, "Variant 1", out var variant1) ||
+            !TryReadTextBox(Variant2TextBox, "Variant 2", out var variant2) ||
+            !TryReadTextBox(OperatorTextBox, "ID", out var loginId) ||
+            !TryReadPasswordBox(PasswordBox, "PW", out var password) ||
+            !TryReadTextBox(LineNoTextBox, "Line", out var lineNo) ||
+            !TryReadTextBox(LotNoTextBox, "Lot No", out var lotNo) ||
+            !TryReadTextBox(JigNoTextBox, "Jig No", out var jigNo))
+        {
+            return false;
+        }
+
+        result = new StartupLoginWindowResult
         {
-            Maker = MakerTextBox.Text.Trim(),
-            Model = ModelTextBox.Text.Trim(),
-            Variant1 = Variant1TextBox.Text.Trim(),
-            Variant2 = Variant2TextBox.Text.Trim(),
+            Maker = maker,
+            Model = model,
+            Variant1 = variant1,
+            Variant2 = variant2,
             Operator = loginId,
             Password = password,
-            LineNo = LineNoTextBox.Text.Trim(),
-            LotNo = LotNoTextBox.Text.Trim(),
-            JigNo = JigNoTextBox.Text.Trim()
+            LineNo = lineNo,
+            LotNo = lotNo,
+            JigNo = jigNo
         };
 
-        DialogResult = true;
-        Close();
+        return true;
+    }
+
+    private void AttachLoginHistoryMenus()
+    {
+        AttachHistoryMenu(MakerTextBox, "Maker", ModelTextBox);
+        AttachHistoryMenu(ModelTextBox, "Model", Variant1TextBox);
+        AttachHistoryMenu(Variant1TextBox, "Variant1", Variant2TextBox);
+        AttachHistoryMenu(Variant2TextBox, "Variant2", OperatorTextBox);
+        AttachHistoryMenu(OperatorTextBox, OperatorHistoryFieldName, PasswordBox);
+        AttachHistoryMenu(LineNoTextBox, "LineNo", LotNoTextBox);
+        AttachHistoryMenu(LotNoTextBox, "LotNo", JigNoTextBox);
+        AttachHistoryMenu(JigNoTextBox, "JigNo", LoginButton);
+    }
+
+    private void AttachHistoryMenu(TextBox textBox, string fieldName, Control nextFocusControl)
+    {
+        textBox.GotKeyboardFocus += (_, _) => ShowHistoryMenu(textBox, fieldName, nextFocusControl);
+        textBox.PreviewMouseLeftButtonDown += (_, _) =>
+        {
+            if (textBox.IsKeyboardFocusWithin)
+            {
+                ShowHistoryMenu(textBox, fieldName, nextFocusControl);
+            }
+        };
+    }
+
+    private void ShowHistoryMenu(TextBox textBox, string fieldName, Control nextFocusControl)
+    {
+        var values = _loginHistoryStore.GetValues(fieldName);
+        if (values.Count == 0)
+        {
+            CloseHistoryPopup();
+            return;
+        }
+
+        CloseHistoryPopup();
+
+        var menuWidth = Math.Max(160, textBox.ActualWidth);
+        var stackPanel = new StackPanel();
+        var popup = new Popup
+        {
+            PlacementTarget = textBox,
+            Placement = PlacementMode.Bottom,
+            HorizontalOffset = 0,
+            StaysOpen = true,
+            AllowsTransparency = true,
+            Focusable = false
+        };
+
+        foreach (var value in values)
+        {
+            var item = new Button
+            {
+                Content = value,
+                MinWidth = menuWidth,
+                Padding = new Thickness(10, 6, 10, 6),
+                BorderThickness = new Thickness(0),
+                Background = textBox.Background,
+                Foreground = textBox.Foreground,
+                HorizontalContentAlignment = HorizontalAlignment.Left
+            };
+            item.Click += (_, _) =>
+            {
+                textBox.Text = value;
+                textBox.CaretIndex = textBox.Text.Length;
+                CloseHistoryPopup();
+                FocusControl(nextFocusControl);
+            };
+            stackPanel.Children.Add(item);
+        }
+
+        popup.Child = new Border
+        {
+            Width = menuWidth,
+            MaxHeight = 180,
+            Background = textBox.Background,
+            BorderBrush = textBox.BorderBrush,
+            BorderThickness = new Thickness(1),
+            Child = new ScrollViewer
+            {
+                MaxHeight = 180,
+                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
+                Content = stackPanel
+            }
+        };
+
+        _openHistoryPopup = popup;
+        popup.IsOpen = true;
+    }
+
+    private void CloseHistoryPopup()
+    {
+        if (_openHistoryPopup is not null)
+        {
+            _openHistoryPopup.IsOpen = false;
+            _openHistoryPopup = null;
+        }
+    }
+
+    private void FocusControl(Control control)
+    {
+        Dispatcher.BeginInvoke(new Action(() =>
+        {
+            control.Focus();
+
+            if (control is TextBox textBox)
+            {
+                textBox.CaretIndex = textBox.Text.Length;
+            }
+            else if (control is PasswordBox passwordBox)
+            {
+                passwordBox.Focus();
+            }
+        }), DispatcherPriority.Input);
+    }
+
+    private void SaveLoginHistory(StartupLoginWindowResult result)
+    {
+        _loginHistoryStore.Remember("Maker", result.Maker);
+        _loginHistoryStore.Remember("Model", result.Model);
+        _loginHistoryStore.Remember("Variant1", result.Variant1);
+        _loginHistoryStore.Remember("Variant2", result.Variant2);
+        RememberOperatorHistory(result.Operator);
+        _loginHistoryStore.Remember("LineNo", result.LineNo);
+        _loginHistoryStore.Remember("LotNo", result.LotNo);
+        _loginHistoryStore.Remember("JigNo", result.JigNo);
+        _loginHistoryStore.Save();
+    }
+
+    private void RememberOperatorHistory(string operatorId)
+    {
+        if (IsSuppressedOperatorHistoryValue(operatorId))
+        {
+            _loginHistoryStore.Forget(OperatorHistoryFieldName, operatorId);
+            return;
+        }
+
+        _loginHistoryStore.Remember(OperatorHistoryFieldName, operatorId);
+    }
+
+    private void RemoveSuppressedOperatorHistory()
+    {
+        try
+        {
+            if (_loginHistoryStore.Forget(OperatorHistoryFieldName, SuppressedOperatorHistoryValue))
+            {
+                _loginHistoryStore.Save();
+            }
+        }
+        catch
+        {
+            // Login history cleanup is optional and should not block the login window.
+        }
+    }
+
+    private static bool IsSuppressedOperatorHistoryValue(string value)
+    {
+        return string.Equals(value.Trim(), SuppressedOperatorHistoryValue, StringComparison.OrdinalIgnoreCase);
+    }
+
+    private bool TryReadTextBox(TextBox textBox, string fieldName, out string value)
+    {
+        value = textBox.Text.Trim();
+        if (!string.IsNullOrWhiteSpace(value))
+        {
+            return true;
+        }
+
+        MessageBox.Show(this, $"{fieldName}을(를) 입력하세요.", "Login", MessageBoxButton.OK, MessageBoxImage.Warning);
+        textBox.Focus();
+        textBox.SelectAll();
+        return false;
+    }
+
+    private bool TryReadPasswordBox(PasswordBox passwordBox, string fieldName, out string value)
+    {
+        value = passwordBox.Password;
+        if (!string.IsNullOrWhiteSpace(value))
+        {
+            return true;
+        }
+
+        MessageBox.Show(this, $"{fieldName}을(를) 입력하세요.", "Login", MessageBoxButton.OK, MessageBoxImage.Warning);
+        passwordBox.Focus();
+        passwordBox.SelectAll();
+        return false;
+    }
+
+    private static string GetDatabaseIniPath()
+    {
+        return Path.Combine(AppContext.BaseDirectory, "Database.ini");
+    }
+
+    private static string GetLoginHistoryPath()
+    {
+        return Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            "Housing",
+            "LoginHistory.json");
     }
 }
diff --git a/MainWindow.xaml b/MainWindow.xaml
index 13bda62..1dc73f7 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -400,7 +400,9 @@
                                 <TextBox x:Name="BarcodeTextBox"
                                          Grid.Row="1"
                                          Style="{StaticResource InputBoxStyle}"
-                                         KeyDown="BarcodeTextBox_KeyDown"
+                                         PreviewKeyDown="BarcodeTextBox_PreviewKeyDown"
+                                         PreviewTextInput="BarcodeTextBox_PreviewTextInput"
+                                         InputMethod.IsInputMethodEnabled="False"
                                          TextChanged="BarcodeTextBox_TextChanged"/>
                             </Grid>
                         </Border>
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 719f764..366e793 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -1,5 +1,7 @@
 using System.Globalization;
 using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
@@ -12,10 +14,17 @@ namespace Housing;
 
 public partial class MainWindow : Window
 {
-    private const string BarcodeRequiredMessage = "PCB_Barcode를 입력하고 Enter를 눌러주세요.";
-    private const string BoardReadyMessage = "Enter를 누르면 보드 연결 테스트를 시작합니다.";
+    private const string BarcodeRequiredMessage = "스캐너로 PCB_Barcode를 스캔해주세요.";
+    private const string BoardReadyMessage = "스캔 완료. 시료 투입 후 Housing 장비 시작 버튼을 눌러주세요.";
+    private const string BarcodeInvalidMessage = "스캔 형식이 올바르지 않습니다. PCBA S/N 바코드를 스캔해주세요.";
     private const string DefaultOutputValue = "0.00";
+    private const int ScannerInputMinimumLength = 4;
+    private static readonly TimeSpan ScannerInputMaxGap = TimeSpan.FromMilliseconds(80);
+    private static readonly TimeSpan ScannerInputIdleCommitDelay = TimeSpan.FromMilliseconds(250);
 
+    private readonly StringBuilder _scannerInputBuffer = new();
+    private readonly DispatcherTimer _scannerInputCommitTimer;
+    private DateTime _lastScannerInputAt = DateTime.MinValue;
     private StartupLoginWindowResult _loginResult = new();
     private InspectionJudgementSettings _inspectionSettings;
     private bool _isStartupLoginShown;
@@ -26,6 +35,10 @@ public partial class MainWindow : Window
         _inspectionSettings = InspectionSettingsStore.Load(GetInspectionSettingsIniPath());
 
         InitializeComponent();
+        _scannerInputCommitTimer = new DispatcherTimer { Interval = ScannerInputIdleCommitDelay };
+        _scannerInputCommitTimer.Tick += ScannerInputCommitTimer_Tick;
+        CommandManager.AddPreviewExecutedHandler(BarcodeTextBox, BarcodeTextBox_PreviewExecuted);
+
         ApplyInspectionSettingsToTextBoxes();
         ApplyLoginResult();
         ResetScreen();
@@ -59,15 +72,131 @@ public partial class MainWindow : Window
         ResultOutputTextBox.Text = BoardReadyMessage;
     }
 
-    private async void BarcodeTextBox_KeyDown(object sender, KeyEventArgs e)
+    private void BarcodeTextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
+    {
+        e.Handled = true;
+        AppendScannerText(e.Text);
+    }
+
+    private async void BarcodeTextBox_PreviewKeyDown(object sender, KeyEventArgs e)
     {
-        if (e.Key != Key.Enter && e.Key != Key.Return)
+        if (e.Key == Key.Enter || e.Key == Key.Return || e.Key == Key.Tab)
         {
+            e.Handled = true;
+            await CompleteScannerInputAsync(runBoardSequence: true);
             return;
         }
 
+        if (e.Key == Key.Back || e.Key == Key.Delete || e.Key == Key.Escape ||
+            Keyboard.Modifiers.HasFlag(ModifierKeys.Control) ||
+            Keyboard.Modifiers.HasFlag(ModifierKeys.Alt))
+        {
+            e.Handled = true;
+            ClearPendingScannerInput();
+            return;
+        }
+    }
+
+    private void BarcodeTextBox_PreviewExecuted(object sender, ExecutedRoutedEventArgs e)
+    {
         e.Handled = true;
-        await RunBoardSequenceAsync();
+    }
+
+    private void ScannerInputCommitTimer_Tick(object? sender, EventArgs e)
+    {
+        _scannerInputCommitTimer.Stop();
+        _ = CompleteScannerInputAsync(runBoardSequence: true);
+    }
+
+    private void AppendScannerText(string text)
+    {
+        var now = DateTime.UtcNow;
+        if (_scannerInputBuffer.Length > 0 && now - _lastScannerInputAt > ScannerInputMaxGap)
+        {
+            _scannerInputBuffer.Clear();
+        }
+
+        _lastScannerInputAt = now;
+        _scannerInputBuffer.Append(text);
+        _scannerInputCommitTimer.Stop();
+        _scannerInputCommitTimer.Start();
+    }
+
+    private async Task CompleteScannerInputAsync(bool runBoardSequence)
+    {
+        _scannerInputCommitTimer.Stop();
+
+        var scannerText = _scannerInputBuffer.ToString().Trim();
+        _scannerInputBuffer.Clear();
+
+        var hasPendingScannerInput = scannerText.Length > 0;
+        var acceptedScannerInput = TryExtractPcbBarcode(scannerText, out var scannedBarcode);
+
+        if (acceptedScannerInput)
+        {
+            BarcodeTextBox.Text = scannedBarcode;
+            BarcodeTextBox.CaretIndex = BarcodeTextBox.Text.Length;
+        }
+        else if (hasPendingScannerInput && scannerText.Length >= ScannerInputMinimumLength)
+        {
+            BarcodeTextBox.Clear();
+            ResultOutputTextBox.Text = BarcodeInvalidMessage;
+            FocusBarcodeInput();
+        }
+
+        if (runBoardSequence)
+        {
+            if (!hasPendingScannerInput || acceptedScannerInput)
+            {
+                await RunBoardSequenceAsync();
+            }
+
+            return;
+        }
+
+        FocusBarcodeInput();
+    }
+
+    private static bool TryExtractPcbBarcode(string scannerText, out string pcbBarcode)
+    {
+        pcbBarcode = string.Empty;
+        if (string.IsNullOrWhiteSpace(scannerText))
+        {
+            return false;
+        }
+
+        var pcbaSerialMatch = Regex.Match(
+            scannerText,
+            @"PCBA\s*S\/N\s*:\s*(?<serial>[A-Za-z0-9-]{4,50})",
+            RegexOptions.IgnoreCase);
+        if (pcbaSerialMatch.Success)
+        {
+            pcbBarcode = pcbaSerialMatch.Groups["serial"].Value.Trim();
+            return true;
+        }
+
+        var fields = scannerText
+            .Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Select(part => part.Split(':', 2, StringSplitOptions.TrimEntries))
+            .Where(parts => parts.Length == 2)
+            .ToDictionary(parts => parts[0], parts => parts[1], StringComparer.OrdinalIgnoreCase);
+
+        if (!fields.ContainsKey("MODEL") ||
+            !fields.TryGetValue("SERIAL", out var serial) ||
+            !fields.ContainsKey("OPTION") ||
+            string.IsNullOrWhiteSpace(serial))
+        {
+            return false;
+        }
+
+        pcbBarcode = serial.Trim();
+        return pcbBarcode.Length <= 50;
+    }
+
+    private void ClearPendingScannerInput()
+    {
+        _scannerInputCommitTimer.Stop();
+        _scannerInputBuffer.Clear();
     }
 
     public async Task OnEquipmentStartButtonPressedAsync()
@@ -99,22 +228,29 @@ public partial class MainWindow : Window
             _isBoardTestRunning = true;
             SetInputEnabled(false);
 
+            var boardSettings = BoardHardwareSettings.Load(GetHardwareIniPath());
+            var equipmentSettings = EquipmentMeasurementSettings.Load(GetHardwareIniPath());
+            var startSignalSettings = StartSignalSettings.Load(GetHardwareIniPath());
+
+            var startSignalReceivedAt = await WaitForEquipmentStartSignalAsync(startSignalSettings);
+            var measurementNotBeforeUtc = startSignalReceivedAt?.AddMilliseconds(startSignalSettings.PostSignalDelayMilliseconds);
+
             ResultOutputTextBox.Text =
                 "보드 테스트 시작\r\n" +
                 "1. 시료 연결 확인\r\n" +
                 "2. IC_SN 읽기\r\n" +
                 "3. CAL DEFAULT 조건 설정\r\n" +
-                "4. 계측 장비에서 V/A 읽기";
+                "4. 시작 신호 기준 지연 후 계측 장비에서 V/A 읽기";
 
-            var boardSettings = BoardHardwareSettings.Load(GetHardwareIniPath());
-            var equipmentSettings = EquipmentMeasurementSettings.Load(GetHardwareIniPath());
             var service = new BoardTestService(boardSettings, equipmentSettings);
             string? dbHeaderSaveError = null;
-            var measurement = await service.RunAsync(async icSn =>
-            {
-                IcSnOutputTextBox.Text = icSn;
-                dbHeaderSaveError = await SaveHeaderStatusAsync(icSn);
-            });
+            var measurement = await service.RunAsync(
+                async icSn =>
+                {
+                    IcSnOutputTextBox.Text = icSn;
+                    dbHeaderSaveError = await SaveHeaderStatusAsync(icSn);
+                },
+                measurementNotBeforeUtc);
 
             IcSnOutputTextBox.Text = measurement.IcSn;
             VOutputTextBox.Text = FormatDecimal(measurement.Voltage);
@@ -138,6 +274,33 @@ public partial class MainWindow : Window
         }
     }
 
+    private async Task<DateTime?> WaitForEquipmentStartSignalAsync(StartSignalSettings settings)
+    {
+        if (!settings.Enabled)
+        {
+            return null;
+        }
+
+        ResultOutputTextBox.Text =
+            "장비 시작 신호 대기\r\n" +
+            $"{StartSignalWatcher.Describe(settings)}\r\n" +
+            "시료를 넣고 Housing 장비 시작 버튼을 눌러주세요.";
+
+        await StartSignalWatcher.WaitForStartAsync(settings);
+        var receivedAt = DateTime.UtcNow;
+
+        if (settings.PostSignalDelayMilliseconds <= 0)
+        {
+            ResultOutputTextBox.Text = "장비 시작 신호 수신 완료";
+            return receivedAt;
+        }
+
+        ResultOutputTextBox.Text =
+            "장비 시작 신호 수신 완료\r\n" +
+            $"전압 측정은 신호 수신 후 {settings.PostSignalDelayMilliseconds / 1000.0:0.###}초 이후 시작합니다.";
+        return receivedAt;
+    }
+
     private async void LogoutButton_Click(object sender, RoutedEventArgs e)
     {
         LogoutButton.IsEnabled = false;
@@ -232,7 +395,7 @@ public partial class MainWindow : Window
         {
             var repository = new HousingAssemblyRepository(DatabaseSettings.Load(GetDatabaseIniPath()));
             var record = CreateHeaderRecord(icSn);
-            await repository.InsertHeaderAsync(record);
+            await repository.UpsertHeaderAsync(record);
 
             return null;
         }
diff --git a/Services/BoardTestService.cs b/Services/BoardTestService.cs
index fb2195f..63fd4c7 100644
--- a/Services/BoardTestService.cs
+++ b/Services/BoardTestService.cs
@@ -15,7 +15,9 @@ public sealed class BoardTestService
         _equipmentSettings = equipmentSettings;
     }
 
-    public async Task<BoardMeasurementResult> RunAsync(Func<string, Task>? onIcSnReadAsync = null)
+    public async Task<BoardMeasurementResult> RunAsync(
+        Func<string, Task>? onIcSnReadAsync = null,
+        DateTime? measurementNotBeforeUtc = null)
     {
         var log = new StringBuilder();
         var equipmentService = new EquipmentMeasurementService(_equipmentSettings);
@@ -52,6 +54,16 @@ public sealed class BoardTestService
 
         await SendAndLogAsync(boardClient, "CAL_DEFAULT", _boardSettings.CalDefaultCommand, _boardSettings.ReadTimeout, false, log);
 
+        if (measurementNotBeforeUtc.HasValue)
+        {
+            var remainingDelay = measurementNotBeforeUtc.Value - DateTime.UtcNow;
+            if (remainingDelay > TimeSpan.Zero)
+            {
+                log.AppendLine($"> MEASUREMENT START DELAY: {(int)remainingDelay.TotalMilliseconds} ms");
+                await Task.Delay(remainingDelay);
+            }
+        }
+
         var equipmentResult = await equipmentService.ReadAsync();
         log.Append(equipmentResult.RawLog);
 
diff --git a/Services/HousingAssemblyRepository.cs b/Services/HousingAssemblyRepository.cs
index e13e1a4..1ef890f 100644
--- a/Services/HousingAssemblyRepository.cs
+++ b/Services/HousingAssemblyRepository.cs
@@ -67,6 +67,85 @@ VALUES
         await command.ExecuteNonQueryAsync();
     }
 
+    public async Task UpsertHeaderAsync(HousingAssemblyRecord record)
+    {
+        using var connection = new SqlConnection(CreateConnectionString());
+        using var command = connection.CreateCommand();
+
+        command.CommandText = @"
+SET XACT_ABORT ON;
+
+BEGIN TRANSACTION;
+
+UPDATE dbo.Housing_Assembly WITH (UPDLOCK, HOLDLOCK)
+SET
+    [PCB_Barcode] = @PCB_Barcode,
+    [Maker] = @Maker,
+    [Model] = @Model,
+    [Variant_1] = @Variant_1,
+    [Variant_2] = @Variant_2,
+    [Operator] = @Operator,
+    [Password] = @Password,
+    [Production_Date] = @Production_Date,
+    [Line] = @Line,
+    [Lot_No] = @Lot_No,
+    [Jig_No] = @Jig_No
+WHERE
+    [IC_SN] = @IC_SN;
+
+IF @@ROWCOUNT = 0
+BEGIN
+    INSERT INTO dbo.Housing_Assembly
+    (
+        [IC_SN],
+        [PCB_Barcode],
+        [Maker],
+        [Model],
+        [Variant_1],
+        [Variant_2],
+        [Operator],
+        [Password],
+        [Production_Date],
+        [Line],
+        [Lot_No],
+        [Jig_No]
+    )
+    VALUES
+    (
+        @IC_SN,
+        @PCB_Barcode,
+        @Maker,
+        @Model,
+        @Variant_1,
+        @Variant_2,
+        @Operator,
+        @Password,
+        @Production_Date,
+        @Line,
+        @Lot_No,
+        @Jig_No
+    );
+END;
+
+COMMIT TRANSACTION;";
+
+        AddNVarChar(command, "@IC_SN", 50, record.IcSn);
+        AddNVarChar(command, "@PCB_Barcode", 50, record.PcbBarcode);
+        AddNVarChar(command, "@Maker", 10, record.Maker);
+        AddNVarChar(command, "@Model", 10, record.Model);
+        AddNVarChar(command, "@Variant_1", 10, record.Variant1);
+        AddNVarChar(command, "@Variant_2", 10, record.Variant2);
+        AddNVarChar(command, "@Operator", 10, record.Operator);
+        AddNVarChar(command, "@Password", 10, record.Password);
+        command.Parameters.Add(new SqlParameter("@Production_Date", SqlDbType.DateTime2) { Value = record.ProductionDate });
+        AddNVarChar(command, "@Line", 5, record.Line);
+        AddNVarChar(command, "@Lot_No", 8, record.LotNo);
+        AddNVarChar(command, "@Jig_No", 10, record.JigNo);
+
+        await connection.OpenAsync();
+        await command.ExecuteNonQueryAsync();
+    }
+
     public async Task UpdateMeasurementAsync(HousingAssemblyRecord record)
     {
         using var connection = new SqlConnection(CreateConnectionString());
@@ -83,11 +162,9 @@ SET
     [Spare_3] = @Spare_3,
     [Spare_4] = @Spare_4
 WHERE
-    [IC_SN] = @IC_SN
-    AND [PCB_Barcode] = @PCB_Barcode;";
+    [IC_SN] = @IC_SN;";
 
         AddNVarChar(command, "@IC_SN", 50, record.IcSn);
-        AddNVarChar(command, "@PCB_Barcode", 50, record.PcbBarcode);
         AddDecimal(command, "@PT_Vol_1", record.PtVol1);
         AddDecimal(command, "@PT_Current_1", record.PtCurrent1);
         AddNVarChar(command, "@Result", 5, record.Result);
@@ -106,7 +183,7 @@ WHERE
 
     public async Task InsertAsync(HousingAssemblyRecord record)
     {
-        await InsertHeaderAsync(record);
+        await UpsertHeaderAsync(record);
         await UpdateMeasurementAsync(record);
     }
 
diff --git a/Services/LoginAccountRepository.cs b/Services/LoginAccountRepository.cs
new file mode 100644
index 0000000..43b1a5b
--- /dev/null
+++ b/Services/LoginAccountRepository.cs
@@ -0,0 +1,58 @@
+using System.Data;
+using Microsoft.Data.SqlClient;
+
+namespace Housing.Services;
+
+public sealed class LoginAccountRepository
+{
+    private readonly DatabaseSettings _databaseSettings;
+    private readonly LoginSettings _loginSettings;
+
+    public LoginAccountRepository(DatabaseSettings databaseSettings, LoginSettings loginSettings)
+    {
+        _databaseSettings = databaseSettings;
+        _loginSettings = loginSettings;
+    }
+
+    public async Task<bool> ExistsAsync(string loginId, string password)
+    {
+        using var connection = new SqlConnection(CreateConnectionString());
+        using var command = connection.CreateCommand();
+
+        command.CommandText = $@"
+SELECT TOP (1) 1
+FROM {_loginSettings.GetQuotedTableName()}
+WHERE {_loginSettings.GetQuotedIdColumn()} = @LoginId
+  AND {_loginSettings.GetQuotedPasswordColumn()} = @Password;";
+
+        command.Parameters.Add(new SqlParameter("@LoginId", SqlDbType.NVarChar, 50) { Value = loginId });
+        command.Parameters.Add(new SqlParameter("@Password", SqlDbType.NVarChar, 50) { Value = password });
+
+        await connection.OpenAsync();
+        var result = await command.ExecuteScalarAsync();
+        return result is not null;
+    }
+
+    private string CreateConnectionString()
+    {
+        if (string.IsNullOrWhiteSpace(_databaseSettings.Ip) ||
+            string.IsNullOrWhiteSpace(_databaseSettings.Database) ||
+            string.IsNullOrWhiteSpace(_databaseSettings.DbId))
+        {
+            throw new InvalidOperationException("Database.ini의 IP, Database, DbId 값을 확인하세요.");
+        }
+
+        var builder = new SqlConnectionStringBuilder
+        {
+            DataSource = _databaseSettings.Ip,
+            InitialCatalog = _databaseSettings.Database,
+            UserID = _databaseSettings.DbId,
+            Password = _databaseSettings.DbPw,
+            Encrypt = _databaseSettings.Encrypt,
+            TrustServerCertificate = _databaseSettings.TrustServerCertificate,
+            ConnectTimeout = _databaseSettings.Timeout
+        };
+
+        return builder.ConnectionString;
+    }
+}
diff --git a/Services/LoginHistoryStore.cs b/Services/LoginHistoryStore.cs
new file mode 100644
index 0000000..51fc6dd
--- /dev/null
+++ b/Services/LoginHistoryStore.cs
@@ -0,0 +1,99 @@
+using System.IO;
+using System.Text.Json;
+
+namespace Housing.Services;
+
+public sealed class LoginHistoryStore
+{
+    private const int MaxHistoryCount = 3;
+    private readonly string _filePath;
+    private readonly LoginHistoryData _data;
+
+    private LoginHistoryStore(string filePath, LoginHistoryData data)
+    {
+        _filePath = filePath;
+        _data = data;
+    }
+
+    public static LoginHistoryStore Load(string filePath)
+    {
+        try
+        {
+            if (!File.Exists(filePath))
+            {
+                return new LoginHistoryStore(filePath, new LoginHistoryData());
+            }
+
+            var json = File.ReadAllText(filePath);
+            var data = JsonSerializer.Deserialize<LoginHistoryData>(json) ?? new LoginHistoryData();
+            data.Fields ??= new Dictionary<string, List<string>>();
+            return new LoginHistoryStore(filePath, data);
+        }
+        catch
+        {
+            return new LoginHistoryStore(filePath, new LoginHistoryData());
+        }
+    }
+
+    public IReadOnlyList<string> GetValues(string fieldName)
+    {
+        return _data.Fields.TryGetValue(fieldName, out var values)
+            ? values.Where(value => !string.IsNullOrWhiteSpace(value)).Take(MaxHistoryCount).ToArray()
+            : Array.Empty<string>();
+    }
+
+    public void Remember(string fieldName, string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return;
+        }
+
+        if (!_data.Fields.TryGetValue(fieldName, out var values))
+        {
+            values = new List<string>();
+            _data.Fields[fieldName] = values;
+        }
+
+        values.RemoveAll(item => string.Equals(item, value, StringComparison.OrdinalIgnoreCase));
+        values.Insert(0, value);
+        if (values.Count > MaxHistoryCount)
+        {
+            values.RemoveRange(MaxHistoryCount, values.Count - MaxHistoryCount);
+        }
+    }
+
+    public bool Forget(string fieldName, string value)
+    {
+        if (string.IsNullOrWhiteSpace(value) ||
+            !_data.Fields.TryGetValue(fieldName, out var values))
+        {
+            return false;
+        }
+
+        var removedCount = values.RemoveAll(item => string.Equals(item, value, StringComparison.OrdinalIgnoreCase));
+        if (values.Count == 0)
+        {
+            _data.Fields.Remove(fieldName);
+        }
+
+        return removedCount > 0;
+    }
+
+    public void Save()
+    {
+        var directory = Path.GetDirectoryName(_filePath);
+        if (!string.IsNullOrWhiteSpace(directory))
+        {
+            Directory.CreateDirectory(directory);
+        }
+
+        var json = JsonSerializer.Serialize(_data, new JsonSerializerOptions { WriteIndented = true });
+        File.WriteAllText(_filePath, json);
+    }
+
+    private sealed class LoginHistoryData
+    {
+        public Dictionary<string, List<string>> Fields { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    }
+}
diff --git a/Services/LoginSettings.cs b/Services/LoginSettings.cs
new file mode 100644
index 0000000..1f4c175
--- /dev/null
+++ b/Services/LoginSettings.cs
@@ -0,0 +1,86 @@
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace Housing.Services;
+
+public sealed class LoginSettings
+{
+    public string Table { get; set; } = "dbo.Housing_Assembly";
+    public string IdColumn { get; set; } = "Operator";
+    public string PasswordColumn { get; set; } = "Password";
+    public bool OfflinePreview { get; set; }
+
+    public static LoginSettings Load(string filePath)
+    {
+        if (!File.Exists(filePath))
+        {
+            throw new FileNotFoundException("Database.ini 파일을 찾을 수 없습니다.", filePath);
+        }
+
+        var values = IniFile.LoadSection(filePath, "Login");
+        return new LoginSettings
+        {
+            Table = GetString(values, "Table", "dbo.Housing_Assembly"),
+            IdColumn = GetString(values, "IdColumn", "Operator"),
+            PasswordColumn = GetString(values, "PasswordColumn", "Password"),
+            OfflinePreview = GetBool(values, "OfflinePreview", false)
+        };
+    }
+
+    public string GetQuotedTableName()
+    {
+        var parts = Table
+            .Split('.', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Select(QuoteIdentifier)
+            .ToArray();
+
+        if (parts.Length is 0 or > 3)
+        {
+            throw new InvalidOperationException("Database.ini [Login] Table 값을 확인하세요.");
+        }
+
+        return string.Join(".", parts);
+    }
+
+    public string GetQuotedIdColumn()
+    {
+        return QuoteIdentifier(IdColumn);
+    }
+
+    public string GetQuotedPasswordColumn()
+    {
+        return QuoteIdentifier(PasswordColumn);
+    }
+
+    private static string GetString(Dictionary<string, string> values, string key, string defaultValue)
+    {
+        return values.TryGetValue(key, out var value) && !string.IsNullOrWhiteSpace(value)
+            ? value.Trim()
+            : defaultValue;
+    }
+
+    private static bool GetBool(Dictionary<string, string> values, string key, bool defaultValue)
+    {
+        if (!values.TryGetValue(key, out var value) || string.IsNullOrWhiteSpace(value))
+        {
+            return defaultValue;
+        }
+
+        return value.Trim().ToUpperInvariant() switch
+        {
+            "1" or "TRUE" or "YES" or "ON" => true,
+            "0" or "FALSE" or "NO" or "OFF" => false,
+            _ => defaultValue
+        };
+    }
+
+    private static string QuoteIdentifier(string identifier)
+    {
+        if (Regex.IsMatch(identifier, @"^[A-Za-z_][A-Za-z0-9_]*$"))
+        {
+            return $"[{identifier}]";
+        }
+
+        throw new InvalidOperationException($"DB 식별자 값이 올바르지 않습니다: {identifier}");
+    }
+}
diff --git a/Services/Ni6501StartSignalWatcher.cs b/Services/Ni6501StartSignalWatcher.cs
new file mode 100644
index 0000000..3f4d107
--- /dev/null
+++ b/Services/Ni6501StartSignalWatcher.cs
@@ -0,0 +1,191 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Housing.Services;
+
+public sealed class Ni6501StartSignalWatcher
+{
+    private readonly StartSignalSettings _settings;
+
+    public Ni6501StartSignalWatcher(StartSignalSettings settings)
+    {
+        _settings = settings;
+    }
+
+    public async Task WaitForStartAsync(CancellationToken cancellationToken = default)
+    {
+        if (!_settings.Enabled)
+        {
+            return;
+        }
+
+        try
+        {
+            await Task.Run(() => WaitForStart(cancellationToken), cancellationToken);
+        }
+        catch (DllNotFoundException ex)
+        {
+            throw new InvalidOperationException("NI-DAQmx 드라이버(nicaiu.dll)를 찾을 수 없습니다. NI-DAQmx Runtime 설치와 NI-6501 인식 상태를 확인하세요.", ex);
+        }
+        catch (EntryPointNotFoundException ex)
+        {
+            throw new InvalidOperationException("NI-DAQmx DLL에서 필요한 함수가 보이지 않습니다. NI-DAQmx Runtime 버전을 확인하세요.", ex);
+        }
+        catch (BadImageFormatException ex)
+        {
+            throw new InvalidOperationException("NI-DAQmx DLL 비트 수가 현재 프로그램과 맞지 않습니다. x64/x86 Runtime과 실행 설정을 확인하세요.", ex);
+        }
+    }
+
+    private void WaitForStart(CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(_settings.PhysicalChannel))
+        {
+            throw new InvalidOperationException("Hardware.ini [StartSignal] PhysicalChannel 값을 설정하세요.");
+        }
+
+        using var input = new DaqmxDigitalInput(_settings.PhysicalChannel);
+        var stopwatch = Stopwatch.StartNew();
+
+        if (_settings.RequireInactiveBeforeStart)
+        {
+            while (_settings.IsActive(input.ReadSingleLine()))
+            {
+                ThrowIfTimedOut(stopwatch, "기존 신호 해제 대기");
+                Delay(cancellationToken);
+            }
+        }
+
+        while (!_settings.IsActive(input.ReadSingleLine()))
+        {
+            ThrowIfTimedOut(stopwatch, "시작 신호 대기");
+            Delay(cancellationToken);
+        }
+    }
+
+    private void ThrowIfTimedOut(Stopwatch stopwatch, string state)
+    {
+        if (_settings.TimeoutMilliseconds <= 0 ||
+            stopwatch.ElapsedMilliseconds <= _settings.TimeoutMilliseconds)
+        {
+            return;
+        }
+
+        throw new TimeoutException(
+            $"NI-6501 시작 신호 대기 시간 초과: {state}, 채널={_settings.PhysicalChannel}, 제한={_settings.TimeoutMilliseconds}ms");
+    }
+
+    private void Delay(CancellationToken cancellationToken)
+    {
+        if (cancellationToken.WaitHandle.WaitOne(_settings.PollIntervalMilliseconds))
+        {
+            throw new OperationCanceledException(cancellationToken);
+        }
+    }
+
+    private sealed class DaqmxDigitalInput : IDisposable
+    {
+        private const int DaqmxValChanPerLine = 0;
+        private const int DaqmxValGroupByChannel = 0;
+
+        private nint _taskHandle;
+
+        public DaqmxDigitalInput(string physicalChannel)
+        {
+            Check(DaqmxCreateTask("", out _taskHandle), "NI-DAQmx Task 생성 실패");
+
+            try
+            {
+                Check(DaqmxCreateDIChan(_taskHandle, physicalChannel, "", DaqmxValChanPerLine), "NI-6501 DI 채널 생성 실패");
+                Check(DaqmxStartTask(_taskHandle), "NI-6501 DI Task 시작 실패");
+            }
+            catch
+            {
+                Dispose();
+                throw;
+            }
+        }
+
+        public bool ReadSingleLine()
+        {
+            var readArray = new byte[1];
+            Check(
+                DaqmxReadDigitalLines(
+                    _taskHandle,
+                    1,
+                    1.0,
+                    DaqmxValGroupByChannel,
+                    readArray,
+                    (uint)readArray.Length,
+                    out _,
+                    out _,
+                    nint.Zero),
+                "NI-6501 DI 읽기 실패");
+
+            return readArray[0] != 0;
+        }
+
+        public void Dispose()
+        {
+            if (_taskHandle == nint.Zero)
+            {
+                return;
+            }
+
+            DaqmxStopTask(_taskHandle);
+            DaqmxClearTask(_taskHandle);
+            _taskHandle = nint.Zero;
+        }
+
+        private static void Check(int errorCode, string message)
+        {
+            if (errorCode >= 0)
+            {
+                return;
+            }
+
+            var detail = GetExtendedErrorInfo();
+            throw new InvalidOperationException(string.IsNullOrWhiteSpace(detail)
+                ? message
+                : $"{message}: {detail}");
+        }
+
+        private static string GetExtendedErrorInfo()
+        {
+            var errorMessage = new StringBuilder(2048);
+            var errorCode = DaqmxGetExtendedErrorInfo(errorMessage, (uint)errorMessage.Capacity);
+            return errorCode == 0 ? errorMessage.ToString().Trim() : string.Empty;
+        }
+
+        [DllImport("nicaiu.dll", EntryPoint = "DAQmxCreateTask", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        private static extern int DaqmxCreateTask(string taskName, out nint taskHandle);
+
+        [DllImport("nicaiu.dll", EntryPoint = "DAQmxCreateDIChan", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        private static extern int DaqmxCreateDIChan(nint taskHandle, string lines, string nameToAssignToLines, int lineGrouping);
+
+        [DllImport("nicaiu.dll", EntryPoint = "DAQmxStartTask", CallingConvention = CallingConvention.Cdecl)]
+        private static extern int DaqmxStartTask(nint taskHandle);
+
+        [DllImport("nicaiu.dll", EntryPoint = "DAQmxReadDigitalLines", CallingConvention = CallingConvention.Cdecl)]
+        private static extern int DaqmxReadDigitalLines(
+            nint taskHandle,
+            int numSampsPerChan,
+            double timeout,
+            int fillMode,
+            byte[] readArray,
+            uint arraySizeInBytes,
+            out int sampsPerChanRead,
+            out int numBytesPerSamp,
+            nint reserved);
+
+        [DllImport("nicaiu.dll", EntryPoint = "DAQmxStopTask", CallingConvention = CallingConvention.Cdecl)]
+        private static extern int DaqmxStopTask(nint taskHandle);
+
+        [DllImport("nicaiu.dll", EntryPoint = "DAQmxClearTask", CallingConvention = CallingConvention.Cdecl)]
+        private static extern int DaqmxClearTask(nint taskHandle);
+
+        [DllImport("nicaiu.dll", EntryPoint = "DAQmxGetExtendedErrorInfo", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        private static extern int DaqmxGetExtendedErrorInfo(StringBuilder errorString, uint bufferSize);
+    }
+}
diff --git a/Services/StartSignalSettings.cs b/Services/StartSignalSettings.cs
new file mode 100644
index 0000000..0b03e00
--- /dev/null
+++ b/Services/StartSignalSettings.cs
@@ -0,0 +1,125 @@
+using System.IO;
+
+namespace Housing.Services;
+
+public sealed class StartSignalSettings
+{
+    public bool Enabled { get; set; }
+    public string Connection { get; set; } = "Ni6501";
+    public string PhysicalChannel { get; set; } = "Dev1/port0/line0";
+    public string ActiveState { get; set; } = "High";
+    public string Host { get; set; } = string.Empty;
+    public int Port { get; set; } = 5000;
+    public string ReadCommand { get; set; } = string.Empty;
+    public string ActiveResponse { get; set; } = "START,1,ON";
+    public string ResponseMatch { get; set; } = "Contains";
+    public string Terminator { get; set; } = "CRLF";
+    public int ReadTimeoutMilliseconds { get; set; } = 1000;
+    public int PollIntervalMilliseconds { get; set; } = 50;
+    public int TimeoutMilliseconds { get; set; } = 30000;
+    public int PostSignalDelayMilliseconds { get; set; } = 2000;
+    public bool RequireInactiveBeforeStart { get; set; } = true;
+
+    public bool IsActive(bool lineValue)
+    {
+        return string.Equals(ActiveState, "Low", StringComparison.OrdinalIgnoreCase)
+            ? !lineValue
+            : lineValue;
+    }
+
+    public static StartSignalSettings Load(string filePath)
+    {
+        if (!File.Exists(filePath))
+        {
+            throw new FileNotFoundException("Hardware.ini 파일을 찾을 수 없습니다.", filePath);
+        }
+
+        var values = IniFile.LoadSection(filePath, "StartSignal");
+        return new StartSignalSettings
+        {
+            Enabled = GetBool(values, "Enabled", false),
+            Connection = GetString(values, "Connection", "Ni6501"),
+            PhysicalChannel = GetString(values, "PhysicalChannel", "Dev1/port0/line0"),
+            ActiveState = GetString(values, "ActiveState", "High"),
+            Host = GetString(values, "Host", string.Empty),
+            Port = GetInt(values, "Port", 5000),
+            ReadCommand = GetString(values, "ReadCommand", string.Empty),
+            ActiveResponse = GetString(values, "ActiveResponse", "START,1,ON"),
+            ResponseMatch = GetString(values, "ResponseMatch", "Contains"),
+            Terminator = GetString(values, "Terminator", "CRLF"),
+            ReadTimeoutMilliseconds = Math.Max(100, GetInt(values, "ReadTimeoutMilliseconds", 1000)),
+            PollIntervalMilliseconds = Math.Max(10, GetInt(values, "PollIntervalMilliseconds", 50)),
+            TimeoutMilliseconds = Math.Max(0, GetInt(values, "TimeoutMilliseconds", 30000)),
+            PostSignalDelayMilliseconds = Math.Max(0, GetInt(values, "PostSignalDelayMilliseconds", 2000)),
+            RequireInactiveBeforeStart = GetBool(values, "RequireInactiveBeforeStart", true)
+        };
+    }
+
+    public string[] GetActiveResponses()
+    {
+        return ActiveResponse
+            .Split(',', ';')
+            .Select(value => value.Trim())
+            .Where(value => !string.IsNullOrWhiteSpace(value))
+            .ToArray();
+    }
+
+    public string GetTerminator()
+    {
+        return Terminator.Trim().ToUpperInvariant() switch
+        {
+            "CRLF" => "\r\n",
+            "CR" => "\r",
+            "LF" => "\n",
+            "NONE" or "EMPTY" => string.Empty,
+            _ => Terminator
+        };
+    }
+
+    public bool IsActive(string response)
+    {
+        if (string.IsNullOrWhiteSpace(response))
+        {
+            return false;
+        }
+
+        var activeResponses = GetActiveResponses();
+        if (activeResponses.Length == 0)
+        {
+            return false;
+        }
+
+        return string.Equals(ResponseMatch, "Equals", StringComparison.OrdinalIgnoreCase)
+            ? activeResponses.Any(value => string.Equals(response.Trim(), value, StringComparison.OrdinalIgnoreCase))
+            : activeResponses.Any(value => response.Contains(value, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private static string GetString(Dictionary<string, string> values, string key, string defaultValue)
+    {
+        return values.TryGetValue(key, out var value) && !string.IsNullOrWhiteSpace(value)
+            ? value.Trim()
+            : defaultValue;
+    }
+
+    private static int GetInt(Dictionary<string, string> values, string key, int defaultValue)
+    {
+        return values.TryGetValue(key, out var value) && int.TryParse(value, out var result)
+            ? result
+            : defaultValue;
+    }
+
+    private static bool GetBool(Dictionary<string, string> values, string key, bool defaultValue)
+    {
+        if (!values.TryGetValue(key, out var value) || string.IsNullOrWhiteSpace(value))
+        {
+            return defaultValue;
+        }
+
+        return value.Trim().ToUpperInvariant() switch
+        {
+            "1" or "TRUE" or "YES" or "ON" => true,
+            "0" or "FALSE" or "NO" or "OFF" => false,
+            _ => defaultValue
+        };
+    }
+}
diff --git a/Services/StartSignalWatcher.cs b/Services/StartSignalWatcher.cs
new file mode 100644
index 0000000..8155c8f
--- /dev/null
+++ b/Services/StartSignalWatcher.cs
@@ -0,0 +1,40 @@
+namespace Housing.Services;
+
+public static class StartSignalWatcher
+{
+    public static Task WaitForStartAsync(StartSignalSettings settings, CancellationToken cancellationToken = default)
+    {
+        if (!settings.Enabled)
+        {
+            return Task.CompletedTask;
+        }
+
+        var connection = GetConnection(settings);
+        return connection switch
+        {
+            "NI6501" or "NI-6501" or "NIDAQ" or "DAQ" => new Ni6501StartSignalWatcher(settings).WaitForStartAsync(cancellationToken),
+            "TCP" or "LAN" or "ETHERNET" => new TcpStartSignalWatcher(settings).WaitForStartAsync(cancellationToken),
+            _ => throw new InvalidOperationException("Hardware.ini [StartSignal] Connection은 Ni6501 또는 Tcp로 설정하세요.")
+        };
+    }
+
+    public static string Describe(StartSignalSettings settings)
+    {
+        var connection = GetConnection(settings);
+        return connection switch
+        {
+            "NI6501" or "NI-6501" or "NIDAQ" or "DAQ" => $"NI-6501 {settings.PhysicalChannel}",
+            "TCP" or "LAN" or "ETHERNET" => string.IsNullOrWhiteSpace(settings.ReadCommand)
+                ? $"LAN {settings.Host}:{settings.Port} 수신 대기"
+                : $"LAN {settings.Host}:{settings.Port} 명령: {settings.ReadCommand}",
+            _ => connection
+        };
+    }
+
+    private static string GetConnection(StartSignalSettings settings)
+    {
+        return string.IsNullOrWhiteSpace(settings.Connection)
+            ? "NI6501"
+            : settings.Connection.Trim().ToUpperInvariant();
+    }
+}
diff --git a/Services/TcpStartSignalWatcher.cs b/Services/TcpStartSignalWatcher.cs
new file mode 100644
index 0000000..bc1ef01
--- /dev/null
+++ b/Services/TcpStartSignalWatcher.cs
@@ -0,0 +1,151 @@
+using System.Diagnostics;
+using System.Net.Sockets;
+using System.Text;
+
+namespace Housing.Services;
+
+public sealed class TcpStartSignalWatcher
+{
+    private readonly StartSignalSettings _settings;
+
+    public TcpStartSignalWatcher(StartSignalSettings settings)
+    {
+        _settings = settings;
+    }
+
+    public async Task WaitForStartAsync(CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrWhiteSpace(_settings.Host))
+        {
+            throw new InvalidOperationException("Hardware.ini [StartSignal] Host 값을 LAN 장비 IP로 설정하세요.");
+        }
+
+        using var client = new TcpClient();
+        await ConnectAsync(client, cancellationToken);
+
+        using var stream = client.GetStream();
+        var stopwatch = Stopwatch.StartNew();
+
+        if (string.IsNullOrWhiteSpace(_settings.ReadCommand))
+        {
+            await WaitForEventMessageAsync(stream, stopwatch, cancellationToken);
+            return;
+        }
+
+        await WaitForPolledResponseAsync(stream, stopwatch, cancellationToken);
+    }
+
+    private async Task ConnectAsync(TcpClient client, CancellationToken cancellationToken)
+    {
+        try
+        {
+            using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            if (_settings.TimeoutMilliseconds > 0)
+            {
+                timeout.CancelAfter(_settings.TimeoutMilliseconds);
+            }
+
+            await client.ConnectAsync(_settings.Host, _settings.Port, timeout.Token);
+        }
+        catch (OperationCanceledException ex) when (!cancellationToken.IsCancellationRequested)
+        {
+            throw new TimeoutException($"LAN 시작 신호 장비 연결 시간 초과: {_settings.Host}:{_settings.Port}", ex);
+        }
+        catch (SocketException ex)
+        {
+            throw new InvalidOperationException($"LAN 시작 신호 장비 연결 실패: {_settings.Host}:{_settings.Port}, {ex.Message}", ex);
+        }
+    }
+
+    private async Task WaitForEventMessageAsync(NetworkStream stream, Stopwatch stopwatch, CancellationToken cancellationToken)
+    {
+        while (true)
+        {
+            ThrowIfTimedOut(stopwatch, "LAN 메시지 수신 대기");
+
+            var response = await ReadResponseAsync(stream, cancellationToken);
+            if (_settings.IsActive(response))
+            {
+                return;
+            }
+        }
+    }
+
+    private async Task WaitForPolledResponseAsync(NetworkStream stream, Stopwatch stopwatch, CancellationToken cancellationToken)
+    {
+        if (_settings.RequireInactiveBeforeStart)
+        {
+            while (_settings.IsActive(await QueryAsync(stream, cancellationToken)))
+            {
+                ThrowIfTimedOut(stopwatch, "기존 LAN 시작 상태 해제 대기");
+                await DelayAsync(cancellationToken);
+            }
+        }
+
+        while (!_settings.IsActive(await QueryAsync(stream, cancellationToken)))
+        {
+            ThrowIfTimedOut(stopwatch, "LAN 시작 응답 대기");
+            await DelayAsync(cancellationToken);
+        }
+    }
+
+    private async Task<string> QueryAsync(NetworkStream stream, CancellationToken cancellationToken)
+    {
+        var command = _settings.ReadCommand.Trim() + _settings.GetTerminator();
+        var bytes = Encoding.ASCII.GetBytes(command);
+        await stream.WriteAsync(bytes, cancellationToken);
+        await stream.FlushAsync(cancellationToken);
+        return await ReadResponseAsync(stream, cancellationToken);
+    }
+
+    private async Task<string> ReadResponseAsync(NetworkStream stream, CancellationToken cancellationToken)
+    {
+        var buffer = new byte[1024];
+        var response = new StringBuilder();
+
+        using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        timeout.CancelAfter(_settings.ReadTimeoutMilliseconds);
+
+        try
+        {
+            while (true)
+            {
+                var count = await stream.ReadAsync(buffer, timeout.Token);
+                if (count == 0)
+                {
+                    break;
+                }
+
+                var chunk = Encoding.ASCII.GetString(buffer, 0, count);
+                response.Append(chunk);
+                if (chunk.Contains('\n') || chunk.Contains('\r') || !stream.DataAvailable)
+                {
+                    break;
+                }
+            }
+        }
+        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+        {
+            return response.ToString();
+        }
+
+        return response.ToString();
+    }
+
+    private async Task DelayAsync(CancellationToken cancellationToken)
+    {
+        await Task.Delay(_settings.PollIntervalMilliseconds, cancellationToken);
+    }
+
+    private void ThrowIfTimedOut(Stopwatch stopwatch, string state)
+    {
+        if (_settings.TimeoutMilliseconds <= 0 ||
+            stopwatch.ElapsedMilliseconds <= _settings.TimeoutMilliseconds)
+        {
+            return;
+        }
+
+        throw new TimeoutException(
+            $"LAN 시작 신호 대기 시간 초과: {state}, 대상={_settings.Host}:{_settings.Port}, 제한={_settings.TimeoutMilliseconds}ms");
+    }
+}