황규석 I'm third rate programmer

C#에서 SFTP 기능을 구현하려면 가장 널리 사용되는 SSH.NET 라이브러리를 활용해야 합니다. 비주얼 스튜디오의 NuGet 패키지 관리자에서 SSH.NET (Renci.SshNet)을 먼저 설치해야 한다.

• 사전 준비 (NuGet 패키지 설치)
  • 비주얼 스튜디오 상단 메뉴에서 도구 > NuGet 패키지 관리자 > 패키지 관리자 콘솔을 연다.
  • 콘솔창에 Install-Package SshNet.Core (또는 Install-Package Ssh.NET)를 입력하여 라이브러리를 설치한다.
• 폼 디자인 구성 요소
  • 접속 버튼 (btnConnect)
  • 전송 버튼 (btnSend)
  • 상태 표시 레이블 (lblStatus) 또는 진행률 바 (progressBar1)
• 전체 소스 코드 구현 예시

using System;
using System.IO;
using System.Windows.Forms;
using Renci.SshNet;

namespace SftpClientApp
{
    public partial class MainForm : Form
    {
        private SftpClient sftpClient;
        
        // 요구하신 접속 정보 설정
        private readonly string host = "172.16.32.108";
        private readonly int port = 22;
        private readonly string username = "admin";
        private readonly string password = "hks003";

        public MainForm()
        {
            InitializeComponent();
        }

        // 1. 접속 버튼 클릭 이벤트
        private void btnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                sftpClient = new SftpClient(host, port, username, password);
                sftpClient.Connect();

                if (sftpClient.IsConnected)
                {
                    MessageBox.Show("정상적으로 접속되었습니다!", "접속 성공", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"접속 실패: {ex.Message}", "연결 오류", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 2. 전송 버튼 클릭 이벤트 (% 표시 및 100% 완료 처리)
        private void btnSend_Click(object sender, EventArgs e)
        {
            if (sftpClient == null || !sftpClient.IsConnected)
            {
                MessageBox.Show("먼저 SFTP 서버에 접속해주세요.", "경고", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            string localFilePath = @"D:\temp\test.zip";
            string remoteFilePath = "/home/hks003/test.zip";

            if (!File.Exists(localFilePath))
            {
                MessageBox.Show($"로컬 파일을 찾을 수 없습니다: {localFilePath}", "파일 오류", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            try
            {
                using (var fileStream = new FileStream(localFilePath, FileMode.Open))
                {
                    long totalLength = fileStream.Length;

                    // UploadFile 메서드의 콜백을 통해 업로드 진행률 실시간 수신
                    sftpClient.UploadFile(fileStream, remoteFilePath, (uploadedBytes) =>
                    {
                        int percentage = (int)((double)uploadedBytes / totalLength * 100);

                        // 비동기 스레드에서 UI를 안전하게 업데이트하기 위해 Invoke 사용
                        this.Invoke((MethodInvoker)(() =>
                        {
                            lblStatus.Text = $"{percentage}% 전송 중...";
                            if (progressBar1 != null) progressBar1.Value = percentage;
                        }));
                    });
                }

                // 전송 완료 시 100% 확정 디스플레이
                this.Invoke((MethodInvoker)(() =>
                {
                    lblStatus.Text = "100% 전송 완료!";
                    if (progressBar1 != null) progressBar1.Value = 100;
                }));

                MessageBox.Show("파일 전송이 정상적으로 완료되었습니다!", "전송 완료", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"전송 중 오류가 발생했습니다: {ex.Message}", "전송 오류", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

코드 핵심 포인트

• SftpClient: 지정된 IP, 포트, 계정 정보를 바탕으로 안전하게 SFTP 세션을 맺는다.
• UploadFile 콜백: 파일이 전송되는 동안 전송된 바이트(uploadedBytes)를 전체 용량과 비교하여 실시간 퍼센트(%)를 계산한다.
• UI 스레드 동기화 (Invoke): 네트워크 및 파일 I/O 작업은 별도의 백그라운드 스레드에서 처리되므로, 폼의 레이블이나 프로그레스바를 안전하게 갱신하려면 Invoke를 사용해야 윈도우 멈춤 현상 없이 정상적으로 퍼센트가 표시된다.

[ 결과 ]

- 정상동작확인했음- 

(I). C# 프로젝트의 실행 파일(EXE) 아이콘을 변경

• 아이콘 파일 준비
  1. 사용할 이미지를. ico 확장자 파일로 준비.
  2. 준비한 아이콘 파일을 프로젝트 폴더 내부(또는 소스 폴더)에 넣어둔다.
• 프로젝트 속성에서 아이콘 지정하기
  1. 우측 솔루션 탐색기에서 설루션이 아닌 C# 프로젝트 이름을 우클릭하고 속성(Properties)을 선택한다.
  2. 좌측 메뉴 또는 탭에서 응용 프로그램(Application) 항목을 선택합니다.
  3. 리소스(Resources) 또는 아이콘 및 매니페스트(Icon and manifest) 섹션에 있는 아이콘(Icon) 설정 항목을 찾는다.
  4. 드롭다운 옆의 찾아보기(Browse) 버튼을 눌러 아까 준비한. ico 파일을 선택한다
• 저장 및 빌드 확인
  1. 설정을 저장(Ctrl + S)한 뒤, 프로젝트를 다시 빌드(Rebuild) .
  2. 프로젝트 폴더 내의 bin/Debug 또는 bin/Release 폴더에 들어가 보면 생성된 실행 파일(EXE)의 아이콘이 변경된 것을 확인. (※ 참고: 비주얼 스튜디오에서 디버깅 실행 직후에는 윈도 캐시나 임시 실행 파일 문제로 곧바로 아이콘이 바뀌어 보이지 않을 수 있으나, 탐색기에서 실제 파일을 직접 확인하면 정상적으로 적용되어 있다.)

(II). 폼(Form)의 아이콘 속성에서 변경하기

1. 비주얼 스튜디오 디자이너에서 아이콘을 바꾸고 싶은 해당 폼(. cs [Design])을 연다.
2. 폼을 클릭하여 선택한 뒤, 우측 하단의 속성(Properties) 창을 연다.
3. 속성 목록에서 Icon 항목을 찾는다.
4. Icon 속성 옆의 값 부분을 누르고 [...] 버튼을 클릭하여, 준비해 둔. ico 파일을 선택.

II-1 코드로 동적 지정하기 (필요한 경우)

만약 코드로 직접 아이콘을 지정하고 싶다면, 폼의 생성자나 Load 이벤트 내부에 다음과 같이 작성.

// 현재 폴더에 있는 icon.ico 파일을 아이콘으로 지정하는 예시
this.Icon = new System.Drawing.Icon("icon.ico");

💡 참고사항

• 서브 폼들의 아이콘을 따로 지정하지 않으면, 기본적으로 프로젝트 속성에 설정된 메인 아이콘이 그대로 상속된다.
• 만약 특정 서브 폼만 독특한 아이콘으로 따로 변경하고 싶을 때만 위 방법처럼 개별 폼의 Icon 속성을 따로 지정.

Lastupdate : 아직 미수행

리눅스나 스크립트에 익숙하지 않더라도 라즈베리파이 부팅 시 파이썬 스트림릿(Streamlit) 웹서버가 자동으로 실행되도록 만드는 가장 표준적이고 안전한 방법인 Systemd 서비스 등록 방법을 차근차근 배워 볼까?.

sudo nano /etc/systemd/system/streamlit.service

Ini, TOML

[Unit]
Description=Streamlit Web Server
After=network.target

[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/myApp
ExecStart=/usr/local/bin/streamlit run app.py --server.address=0.0.0.0
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

# 1. 시스템에 새 서비스 파일 등록 새로고침
sudo systemctl daemon-reload

# 2. 부팅 시 자동 실행(Enable) 설정
sudo systemctl enable streamlit.service

# 3. 지금 당장 서비스 실행해 보기
sudo systemctl start streamlit.service

sudo systemctl status streamlit.service

• UNO-220에 탑재된 AdvRaspbian 이미지에는 시리얼 통신을 곧바로 테스트할 수 있도록 전용 명령어(uno220 uartrecv, uno220 uartsend)가 미리 빌드되어 포함되어 있다.
• 실제 현장에서 센서나 바코드 스캐너, PLC 등의 시리얼 장비를 연결할 때 이 테스트 방식을 응용하면 포트가 정상적으로 통신하는지 쉽게 검증할 수 있다 한번 볼까!.

🔌 통신 포트 (Serial Port) 기능 및 테스트 상세 가이드

어드밴텍(Advantech)의 UNO-220은 산업용 환경에서 흔히 쓰이는 RS-232 / RS-485 시리얼 통신 기능을 지원한다.

어드벤텍 매뉴얼에서는 호스트 PC(우분투)와 라즈베리파이(UNO-220)를 시리얼 케이블(TxD, RxD, GND)로 연결해 데이터를 서로 주고받으며 테스트하는 방법을 안내하고 있지만.

여기서는 통신 테스트는 크게 "1) PC에서 보낸 데이터를 라즈베리가 잘 받는지"와 "2) 라즈베리가 보낸 데이터를 PC가 잘 받는지" 두 가지 방향으로 진행해 보자..

ㅁ 시나리오 1: PC ➔ 라즈베리파이 (PC가 데이터를 보내고 파이가 수신)

PC가 라즈베리파이로 특정 데이터를 송신했을 때, 라즈베리가 이를 정확히 받아내는지를 테스트하는 과정이다.

1. 라즈베리파이(Pi) 측 준비 (수신 대기):
   • UNO-220 터미널에 아래 명령어를 입력하여 수신 대기 상태를 만든다.

     sudo uno220uartrecv
     

2. 호스트 PC 측 실행 (데이터 송신):

PC 터미널에서 아래 명령어를 입력해 라즈베리파이 쪽으로 바이트 데이터(\x01\x02\x03)를 전송합니다.

./files/host-x86_64/host_send /dev/ttyUSB0 $(echo -ne "\x01\x02\x03")

결과: 전송이 완료되면 라즈베리파이(UNO-220) 화면에 PC가 보낸 데이터가 프롬프트 형태로 정상 출력된다.

ㅁ 시나리오 2: 라즈베리파이 ➔ PC (파이가 데이터를 보내고 PC가 수신)

반대로 라즈베리파이에서 시리얼 포트를 통해 PC로 데이터를 쏘았을 때, PC가 이를 올바르게 수신하는지 테스트하는 과정.

1. 호스트 PC 측 준비 (수신 대기):
   • PC 터미널에서 라즈베리파이로부터 오는 신호를 받을 수 있도록 수신 대기 명령어를 실행한다.

     sudo ./host_recv /dev/ttyUSB0
     

2. 라즈베리파이(Pi) 측 실행 (데이터 송신):
   • UNO-220 터미널에서 시리얼 포트(ttyS0)를 통해 데이터(\x01\x02\x03)를 PC로 전송한다.

     sudo uno220uartsend /dev/ttyS0 $(echo -ne "\x01\x02\x03")
     

   • 결과: 명령어를 실행하면 라즈베리파이가 데이터를 송신하고, PC 측 수신 프로그램 화면에 해당 데이터가 정상적으로 찍히게 된다.

1. 시리얼 관련 장치 파일 목록 보기 (ls -l /dev/tty*)

가장 널리 쓰이는 방법으로, 시스템에 존재하는 모든 시리얼 통신 장치(하드웨어 UART, USB-to-Serial 컨버터 등)를 나열.

hks003@raspberrypi:/usr/sbin $ ls -l /dev/ttyS* /dev/ttyAMA* /dev/ttyUSB* /dev/ttyACM* 2>/dev/null
crw-rw---- 1 root dialout 204, 64  8월 21 13:10  /dev/ttyAMA0
crw-rw---- 1 root dialout   4, 64  8월 21 13:09  /dev/ttyS0

확인 방법:

• /dev/ttyS0 또는 /dev/ttyAMA0: 라즈베리파이 기판의 GPIO 핀에 연결된 기본 하드웨어 시리얼 포트다.
• /dev/ttyUSB0 또는 /dev/ttyACM0: USB 포트에 RS-232/RS-485 컨버터나 아두이노 등을 꽂았을 때 생성되는 포트다.

2. 커널이 인식한 시리얼/UART 정보 확인하기 (dmesg 또는 lsto)

시스템이 부팅되면서 어떤 시리얼 포트를 활성화했는지 로그로 확인할 수 있다.

hks003@raspberrypi:/usr/sbin $ dmesg | grep tty
[    0.000304] printk: console [tty0] enabled
[    1.470948] fe201000.serial: ttyAMA0 at MMIO 0xfe201000 (irq = 19, base_baud = 0) is a PL011 rev2
[    1.479715] fe215040.serial: ttyS0 at MMIO 0xfe215040 (irq = 21, base_baud = 62500000) is a 16550
[    2.817069] systemd[1]: Created slice system-getty.slice.

확인 방법: 출력 결과 중에 uart-pl011이나 ttyS0, ttyAMA0 같은 하드웨어 포트가 정상적으로 등록되어 사용 가능한 상태인지 확인할 수 있다.

Lastupdate : 2026. 08.26

1. 사전 준비 (라이브러리 설치)

Visual Studio의 [도구] ➔ [NuGet 패키지 관리자] ➔ [설루션용 NuGet 패키지 관리]에서 아래 라이브러리를 검색해서 설치하자.

• 패키지 이름: NModbus (또는 최신 .NET 환경에서 호환되는 NModbus 포크 버전) (또는 패키지 관리자 콘솔에서 Install-Package NModbus 입력)
• 설치화면 I.

• 설치화면 II.

Install-Package NModbus

• 설치확인화면 III.

사용예: 

using System;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using NModbus;

string serverIp = "172.16.32.108"; // 대상 장치 IP
int port = 502;

CancellationTokenSource cts = new CancellationTokenSource();

Console.WriteLine("[시스템] Modbus TCP 자동 재접속 클라이언트를 시작...");

// 메인 루프: 연결이 끊기면 무한으로 재접속 시도
while (!cts.Token.IsCancellationRequested)
{
    TcpClient client = null;
    IModbusMaster master = null; // 수정됨: IModbusIpMaster -> IModbusMaster

    try
    {
        // 1. 서버 연결 시도
        client = new TcpClient();
        Console.WriteLine($"[연결 시도] {serverIp}:{port} 연결 중...");

        // 연결 타임아웃 설정 (3초 안에 응답 없으면 예외 발생)
        var connectTask = client.ConnectAsync(serverIp, port);
        if (await Task.WhenAny(connectTask, Task.Delay(3000)) != connectTask)
        {
            throw new TimeoutException("연결 시간 초과");
        }

        Console.WriteLine("[연결 성공] 통신을 시작.");

        // 2. NModbus 3.x 버전에 맞는 Master 생성 방식
        var factory = new ModbusFactory();
        master = factory.CreateMaster(client); // 수정됨: CreateIpMaster -> CreateMaster

        // 3. 수신(폴링)을 담당하는 백그라운드 스레드 실행
        await RunCommunicationLoop(master, cts.Token);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"[통신 오류 또는 연결 끊김] {ex.Message}");
    }
    finally
    {
        // 사용한 자원(소켓 등) 깨끗이 정리
        master?.Dispose();
        client?.Dispose();
        Console.WriteLine("[자원 해제] 연결을 닫고 재접속을 준비.");
    }

    // 4. 바로 재시도하면 서버에 부하를 주므로 3초 대기 후 재접속 시도
    if (!cts.Token.IsCancellationRequested)
    {
        Console.WriteLine("[재접속 대기] 3초 후 다시 연결을 시도...");
        await Task.Delay(3000, cts.Token);
    }
}

// ==========================================
// 통신 및 데이터 수신 루프 메서드
// ==========================================
async Task RunCommunicationLoop(IModbusMaster master, CancellationToken cancellationToken) // 수정됨
{
    byte slaveId = 1;
    ushort startAddress = 0;
    ushort numRegisters = 10;

    while (!cancellationToken.IsCancellationRequested)
    {
        // 데이터 읽기 (Function 3 예시)
        ushort[] registers = await master.ReadHoldingRegistersAsync(slaveId, startAddress, numRegisters);
        Console.WriteLine($"[수신 데이터] Reg[0]: {registers[0]}, Reg[1]: {registers[1]}");

        // 주기 조절 (1초 간격)
        await Task.Delay(1000, cancellationToken);
    }
}

라이브러리를 사용할지, 아니면 기존처럼 C# 기본 TcpClient로 직접 소켓 통신을 구현할지 고민.

두 방식의 장단점을 명확하게 비교

1. NModbus 라이브러리를 사용할 때

• 장점:
  • 생산성 최고: Modbus 프로토콜은 바이트 단위의 프레임(Function Code, 주소, 데이터, CRC 체크섬 등)을 엄격하게 지켜야 하는데, 라이브러리가 이 복잡한 과정을 전부 알아서 처리해 줌 (master.ReadHoldingRegistersAsync 한 줄이면 끝난다.)
  • 오류 방지: 통신 과정에서 발생할 수 있는 프로토콜 규칙 오류나 CRC 에러 계산 등을 직접 구현할 필요가 없어 개발 시간이 획기적으로 줄어든다.
• 단점:
  • 혹시 겪을수 있는 라이브러리 버전(3.x)에 따라 네임스페이스나 메서드 이름이 바뀔 때 문서를 찾아봐야 하는 약간의 러닝커브가 있다.

2. 직접 TcpClient로 구현할 때

• 장점:
  • 외부 의존성 제로: NuGet 패키지를 쓸 필요가 없으므로 버전 호환성 문제로 골치 아플 일이 전혀 없다.
  • 완벽한 제어: Modbus TCP 패킷(MBAP Header + PDU) 구조를 직접 바이트 배열(byte [])로 조립하고 파싱 하므로, 프로토콜 구조를 뼛속까지 이해할 수 있다.
• 단점:
  • 구현의 번거로움: 소켓으로 바이트를 보낸 뒤, 응답 데이터의 바이트 배열을 받아와서 Function Code가 에러인지 정상인지, CRC나 트랜잭션 ID는 맞는지 직접 쪼개고 검증하는 코드를 일일이 다 짜야 한다. (생각보다 손이 많이 가고 실수가 발생하기 쉽다.)

💡 최종 추천

• 안전하고 빠른 개발을 원한다면 👉 NModbus 라이브러리 사용을 추천.
  • 비록 처음에 설정과 버전 차이 때문에 약간의 시행착오가 있었지만, 일단 한번 세팅해 두면 이후부터는 센서나 PLC 데이터를 읽고 쓰는 비즈니스 로직(핵심 기능) 개발에만 집중할 수 있어 훨씬 효율적.
• 만약 프로토콜을 직접 바이트 단위로 제어하는 재미를 느끼고 싶거나 외부 라이브러리 자체를 배제하고 싶다면 👉 직접 구현도 나쁘지 않지만, 산업용 현장에서 안정성과 유지보수를 고려한다면 검증된 라이브러리를 쓰는 것이 실무 표준이래나 뭐래나.

이미 NModbus 패키지도 설치했고 기본 구조를 잡아가고 있으니, 이번 기회에 라이브러리를 활용해 빠르게 기능을 완성해 볼가 한다 나는~~ 

using System;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using NModbus;

class Program
{
    static async Task Main(string[] args)
    {
        // 1. 설정 정보 (라즈베리파이에서 접속할 대상 장치 IP와 포트)
        string serverIp = "192.168.0.4"; // 대상 장치 IP (필요시 변경)
        int port = 502;                  // Modbus TCP 기본 포트

        CancellationTokenSource cts = new CancellationTokenSource();

        // 콘솔 종료 시 안전하게 취소하기 위한 이벤트 처리 (Ctrl + C)
        Console.CancelKeyPress += (sender, e) =>
        {
            e.Cancel = true;
            cts.Cancel();
            Console.WriteLine("\n[시스템] 종료 요청을 받았습니다. 자원을 정리합니다...");
        };

        Console.WriteLine("[시스템] 라즈베리파이 Modbus TCP 콘솔 클라이언트를 시작합니다...");
        Console.WriteLine($"[대상 정보] IP: {serverIp}, Port: {port}");
        Console.WriteLine("------------------------------------------------------------");

        // 메인 루프: 연결이 끊기면 3초 후 무한 재접속 시도
        while (!cts.Token.IsCancellationRequested)
        {
            TcpClient client = null;
            IModbusMaster master = null;

            try
            {
                // 2. TCP 서버 연결 시도 (3초 타임아웃)
                client = new TcpClient();
                Console.WriteLine($"\n[연결 시도] {serverIp}:{port} 연결 중...");

                var connectTask = client.ConnectAsync(serverIp, port);
                if (await Task.WhenAny(connectTask, Task.Delay(3000, cts.Token)) != connectTask)
                {
                    throw new TimeoutException("연결 시간 초과 (3초)");
                }

                Console.WriteLine("[연결 성공] Modbus 통신을 시작합니다. (1초 주기 요청)");

                // 3. NModbus Master 생성
                var factory = new ModbusFactory();
                master = factory.CreateMaster(client);

                byte slaveId = 1;             // 장비 ID (Unit ID)
                ushort startAddress = 0x0004;   // 시작 주소 (0x04)
                ushort numRegisters = 0x59;   // 요청 개수 (0x59 = 89개)

                // 4. 1초 간격 데이터 요청 및 디스플레이 루프
                while (!cts.Token.IsCancellationRequested)
                {
                    try
                    {
                        // Function Code 4: Read Input Registers
                        ushort[] registers = await master.ReadInputRegistersAsync(slaveId, startAddress, numRegisters);

                        // 수신된 데이터를 1궤도(Hex 형식)로 변환
                        string hexValues = string.Join(", ", Array.ConvertAll(registers, r => $"0x{r:X4}"));

                        // 화면 출력 (디스플레이)
                        Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] ➔ [수신 성공] 총 {registers.Length}개 레지스터 읽기 완료");
                        Console.WriteLine($"      Hex 데이터: {hexValues}");

                        // 예시로 첫 번째 레지스터 값(Reg[0])의 십진수 값도 함께 출력
                        if (registers.Length > 0)
                        {
                            Console.WriteLine($"      Reg[0] Dec 값: {registers[0]}");
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"  ➔ [통신 에러 발생]: {ex.Message}");
                        break; // 통신 에러 발생 시 내부 루프를 탈출하여 재접속 수행
                    }

                    // 1초 대기
                    await Task.Delay(1000, cts.Token);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[연결 오류]: {ex.Message}");
            }
            finally
            {
                // 자원 정리
                master?.Dispose();
                client?.Dispose();
                Console.WriteLine("[자원 해제] 연결을 닫았습니다. 3초 후 재접속을 시도합니다.");
            }

            // 재접속 대기 (취소 요청이 없을 경우)
            if (!cts.Token.IsCancellationRequested)
            {
                try
                {
                    await Task.Delay(3000, cts.Token);
                }
                catch (TaskCanceledException)
                {
                    break;
                }
            }
        }

        Console.WriteLine("[시스템] 프로그램이 완전히 종료되었습니다.");
    }
}

CModbusClientTcp.cs

using NModbus;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace ENS_RaspberryPi
{
    /// <summary>
    /// 윈도우용 CTcpModbusClient 역할을 대체하는 라즈베리파이용 Modbus TCP 워커 클래스
    /// </summary>
    class CModbusClientTcp
    {
        private readonly string _deviceName;
        private readonly string _ipAddress;
        private readonly int _port;
        private readonly int _intervalMs;

        public CModbusClientTcp(string deviceName, string ipAddress, int port, int intervalMs)
        {
            _deviceName = deviceName;
            _ipAddress = ipAddress;
            _port = port;
            _intervalMs = intervalMs;
        }

        public async Task StartAsync(CancellationToken cancellationToken)
        {
            //취소 신호가 들어오기 전까지 계속해서 통신을 시도하고 유지하는 큰 틀의 while 반복문.
            while (!cancellationToken.IsCancellationRequested)
            {
                TcpClient client = null;
                IModbusMaster master = null;

                try
                {
                    // TCP 연결 준비: 소켓 통신을 위한 TcpClient를 만들고, 지정한 IP와 포트로 비동기 연결을 시도.
                    Console.WriteLine($"\n[{_deviceName}] 연결 시도중... ({_ipAddress}:{_port})");

                    client = new TcpClient();
                    var connectTask = client.ConnectAsync(_ipAddress, _port);

                    // 3초 안에 연결되지 않으면 타임아웃 예외 발생 :
                    // 장치가 꺼져있거나 네트워크가 끊겨서 무한 대기에 빠지는 걸 막기 위해,
                    // "딱 3초만 기다려보고 연결 안 되면 에러를 발생시키고(TimeoutException)" 타이머를 건다.
                    if (await Task.WhenAny(connectTask, Task.Delay(3000, cancellationToken)) != connectTask)
                    {
                        throw new TimeoutException("TCP 연결 시간 초과");
                    }

                    // 모드버스 마스터 생성:
                    // TCP 연결이 성공하면 NModbus 라이브러리의 ModbusFactory를 이용해 통신 master를 만든다.
                    // 그리고 슬레이브 ID는 1, 읽기 시작할 주소는 0x0004, 개수는 0x59(89개)로 정의합니다.
                    Console.WriteLine($"[{_deviceName}] 연결 성공! 1초 주기 데이터 요청 시작.");

                    var factory = new ModbusFactory();
                    master = factory.CreateMaster(client);

                    byte unitId = 1;
                    ushort startAddress = 0x0004; // 윈도우 코드에서 사용한 시작 주소 예시
                    ushort registerCount = 0x59;  // 89개 레지스터 요청

                    // 순차적 단일 스레드 비동기 루프 (교착 상태 없음) 데이터 반복 수신 루프:
                    // 1.master.ReadInputRegistersAsync: Func 4번을 이용해 장치로부터 입력 레지스터 데이터를 싹 긁어옴.
                    // 2.DisplayReceivedData: 받아온 데이터를 화면에 출력.
                    // 3.통신 도중 에러가 나면 break로 안쪽 루프를 탈출해 재접속 단계로 넘어감.
                    // 4.await Task.Delay: 설정한 주기(여기서는 0.2초)만큼 쉬었다가 다시 데이터를 요청한다.                    

                    // [수정 포인트 1] 내부 루프에서 복잡한 통신 로직을 별도 메서드로 분리하여 깔끔하게 호출
                    while (!cancellationToken.IsCancellationRequested)
                    {
                        bool isSuccess = await ReadAndDisplayDataAsync(master, unitId, startAddress, registerCount, cancellationToken);

                        // 통신 에러가 발생했다면(false 리턴) 내부 루프를 탈출하여 재접속 단계로 이동
                        if (!isSuccess)
                        {
                            break;
                        }

                        // 설정된 간격 만큼 대기
                        await Task.Delay(_intervalMs, cancellationToken);
                    }
                }
                
                // 통신이 끊기거나 에러가 나서 루프를 빠져나오면
                
                catch (Exception ex)
                {
                    Console.WriteLine($"[{_deviceName}] 연결/통신 오류: {ex.Message}");
                }
                finally // 자원 정리 및 재시도 
                {
                    //열어뒀던 통신망을 정리(Dispose) 메모리 누수막음
                    master?.Dispose();
                    client?.Dispose();
                    Console.WriteLine($"[{_deviceName}] 연결 해제. 3초 후 재접속을 시도합니다.");
                }

                // 3초 뒤에 다시 처음부터 while 문을 돌며 자동 재접속을 시도.
                // 재접속 전 3초 대기
                if (!cancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        await Task.Delay(3000, cancellationToken);
                    }
                    catch (TaskCanceledException)
                    {
                        break;
                    }
                }
            }
        }
        private async Task<bool> ReadAndDisplayDataAsync(IModbusMaster master, byte unitId, ushort startAddress, ushort registerCount, CancellationToken cancellationToken)
        {
            try
            {
                // Function Code 4 (Read Input Registers) - 취소 토큰을 함께 전달하여 안전성 확보
                ushort[] registers = await master.ReadInputRegistersAsync(unitId, startAddress, registerCount);

                // 수신 데이터 디스플레이 출력
                DisplayReceivedData(registers);

                return true; // 성공 시 true 반환
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[{_deviceName}] 통신 에러 발생: {ex.Message}");
                return false; // 에러 발생 시 false를 반환하여 바깥쪽 루프가 재접속을 하도록 유도
            }
        }

        private void DisplayReceivedData(ushort[] registers)
        {
            string timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
            Console.WriteLine($"[{timestamp}] [{_deviceName}] 수신 완료 (총 {registers.Length}개 레지스터)");

            // 수신된 데이터를 1궤도(Hex 형식)로 변환
            string hexValues = string.Join(", ", Array.ConvertAll(registers, r => $"0x{r:X4}"));

            // 화면 출력 (디스플레이)
            Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] ➔ [수신 성공] 총 {registers.Length}개 레지스터 읽기 완료");
            Console.WriteLine($"      Hex 데이터: {hexValues}");

            // 예시로 첫 번째 레지스터 값(Reg[0])의 십진수 값도 함께 출력
            if (registers.Length > 0)
            {
                Console.WriteLine($"  ➔ Reg[0] Dec: {registers[0]}, Hex: 0x{registers[0]:X4}");
            }
        }

    }
}

Program.cs

/*
 * 모듈이름 :
 * 작성일자 : 2026. 08. 25
 * 작성자명 : Hwang KyuSeok
 * 
 * 
 * **/

using ENS_RaspberryPi;  // CModbusClientTcp 클래스 사용
using NModbus;          // NModbus 라이브러리 사용
using System;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;

Console.WriteLine("[시스템] 라즈베리파이 Modbus TCP 클라이언트 시작...");

// 윈도우용 소스의 Cfg_Tcp 설정값들을 빗대어 객체 생성
// (예: 설비용 PCS 또는 피시험품 PCS 접속 정보)
var modbusWorker = new CModbusClientTcp(
    deviceName: "PCS_Equipment",
    ipAddress: "192.168.0.4",
    port: 502,
    intervalMs: 200
);

// 취소 토큰 소스(버튼장치) 생성 : 언제든지 취소 요청 가능
CancellationTokenSource cts = new CancellationTokenSource();

// Ctrl + C 입력 시 안전하게 종료 :
// Ctrl + C를 누를 경우, 프로그램을 강제로 튕기지 않고 안전하게 멈추기 위해
// 위에서 만든 취소 리모컨(cts.Cancel())을 누르도록 이벤트를 등록.
Console.CancelKeyPress += (sender, e) =>
{
    e.Cancel = true;
    cts.Cancel();
    Console.WriteLine("\n[시스템] 종료 중...");
};

// 백그라운드에서 주기적 통신 시작:
// 앞에서 만든 통신 로봇에게 '지금부터 비동기(StartAsync)로 통신을 시작해 줘!' 하고 명령을 내림.
// 프로그램이 멈추지 않고 계속 데이터를 주고받도록 백그라운드에서 실행된다.
var workTask = modbusWorker.StartAsync(cts.Token);

// 프로그램이 종료되지 않도록 대기 :
// 프로그램이 사용자나 시스템에 의해 종료될 때까지 안전하게 기다리다,
// 완전히 끝나면 마지막 문구를 띄우고 프로그램을 종료다.

try
{
    await workTask;
}
catch (TaskCanceledException)
{
    // 정상 취소
}

Console.WriteLine("[시스템] 프로그램이 종료되었습니다.");

using NModbus;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace ENS_RaspberryPi
{
    class CModbusClientTcp
    {
        private readonly string _deviceName;
        private readonly string _ipAddress;
        private readonly int _port;
        private readonly int _intervalMs;

        public CModbusClientTcp(string deviceName, string ipAddress, int port, int intervalMs)
        {
            _deviceName = deviceName;
            _ipAddress = ipAddress;
            _port = port;
            _intervalMs = intervalMs;
        }

        public async Task StartAsync(CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested)
            {
                TcpClient client = null;
                IModbusMaster master = null;

                try
                {
                    Console.WriteLine($"\n[{_deviceName}] 연결 시도중... ({_ipAddress}:{_port})");

                    client = new TcpClient();
                    var connectTask = client.ConnectAsync(_ipAddress, _port);

                    if (await Task.WhenAny(connectTask, Task.Delay(3000, cancellationToken)) != connectTask)
                    {
                        throw new TimeoutException("TCP 연결 시간 초과");
                    }

                    Console.WriteLine($"[{_deviceName}] 연결 성공! 개별 주기 다중 블록 요청 시작.");

                    var factory = new ModbusFactory();
                    master = factory.CreateMaster(client);
                    byte unitId = 1;

                    // 1초나 0.2초 간격으로 각 블록을 순차적으로 타격하는 루프
                    while (!cancellationToken.IsCancellationRequested)
                    {
                        // 1번 블록 요청
                        if (!await ReadAndDisplayBlockAsync(master, unitId, 0x0004, 0x56, "블록1")) break;
                        await Task.Delay(_intervalMs, cancellationToken);

                        // 2번 블록 요청
                        if (!await ReadAndDisplayBlockAsync(master, unitId, 0x005a, 0x68, "블록2")) break;
                        await Task.Delay(_intervalMs, cancellationToken);

                        // 3번 블록 요청
                        if (!await ReadAndDisplayBlockAsync(master, unitId, 0x00c2, 0x4e, "블록3")) break;
                        await Task.Delay(_intervalMs, cancellationToken);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"[{_deviceName}] 연결/통신 오류: {ex.Message}");
                }
                finally
                {
                    master?.Dispose();
                    client?.Dispose();
                    Console.WriteLine($"[{_deviceName}] 연결 해제. 3초 후 재접속을 시도합니다.");
                }

                if (!cancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        await Task.Delay(3000, cancellationToken);
                    }
                    catch (TaskCanceledException)
                    {
                        break;
                    }
                }
            }
        }

        private async Task<bool> ReadAndDisplayBlockAsync(IModbusMaster master, byte unitId, ushort startAddress, ushort registerCount, string blockName)
        {
            try
            {
                // Function Code 4: Read Input Registers
                ushort[] registers = await master.ReadInputRegistersAsync(unitId, startAddress, registerCount);

                DisplayReceivedData(registers, blockName, startAddress);
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[{_deviceName}] [{blockName}] 통신 에러: {ex.Message}");
                return false; // 에러 발생 시 false를 반환해 전체 루프를 끊고 재접속 유도
            }
        }

        private void DisplayReceivedData(ushort[] registers, string blockName, ushort startAddress)
        {
            string timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
            string hexValues = string.Join(", ", Array.ConvertAll(registers, r => $"0x{r:X4}"));

            Console.WriteLine($"[{timestamp}] [{_deviceName}] [{blockName}] 수신 성공 (Start: 0x{startAddress:X4}, 개수: {registers.Length})");
            Console.WriteLine($"      Hex: {hexValues}");
        }
    }
}

- 기존에 익숙했던 Visual Studio (Community 2026 버전 기준)를 활용하여, 메인 윈도 PC에서 프로젝트를 생성하고,

- 리눅스(라즈베리파이 4B)에 맞게 빌드한 뒤

- 결과물만 복사해 실행하는 과정을

1단계: 윈도우 PC의 Visual Studio에서 프로젝트 생성하기

1. Visual Studio 2026을 실행하고 [새 프로젝트 만들기]를 선택
2. 프로젝트 템플릿 검색창에 "콘솔" 또는 "Console"을 입력.
3. C# 언어 기반의 [콘솔 앱 (Console App)]을 선택하고 다음으로 넘어간다. (이때. NET 버전은 라즈베리파이에 설치하신 버전에 맞춰. NET 8.0 이상을 선택.)
4. 프로젝트 이름과 저장 위치를 지정하고 [만들기]를 누르면 기본 코드가 생성.

2단계: 리눅스(라즈베리파이) 타깃에 맞게 빌드(게시)하기

라즈베리파이 4B(64비트 기준)에서 바로 실행할 수 있도록 윈도 PC에서 리눅스용 파일로 변환(Publish)하는 과정.

1. Visual Studio 상단 메뉴에서 [빌드] ➔ [게시(Publish)...]를 선택합니다. (또는 설루션 탐색기에서 프로젝트 우클릭 ➔ [게시])
2. 대상(Target) 선택 창이 뜨면 [폴더(Folder)]를 선택하고 다음으로 넘어간다.
3. 폴더 위치를 지정하고 완료하면 게시 프로필이 생성된다.
4. 게시 설정 화면에서 우측 상단의 [편집(Edit)] 아이콘을 클릭한다.
5. 설정 창에서 아래 항목들을 변경한다.
   • 대상 프레임워크(Target Framework): net8.0
   • 배포 모드(Deployment Mode): 프레임워크 종속(Framework-dependent) 또는 단일 파일(Self-contained) 중 선택
     • 팁: 라즈베리파이에 .NET 8 런타임이 이미 설치되어 있다면 용량이 가벼운 프레임워크 종속을, 런타임 설치 없이 단일 파일로 실행하고 싶다면 단일 파일을 선택한다.
   • 대상 런타임(Target Runtime): linux-arm64 (라즈베리파이 4B 64비트 OS 기준)로 변경하고 [저장]을 클릭.
6. 화면 우측 상단의 [게시(Publish)] 버튼을 클릭.
7. 빌드가 완료되면 지정한 폴더에 라즈베리파이에서 구동될 실행 파일과 라이브러리 결과물들이 쏙 뽑혀 나오게 된다.

3단계: 결과물을 라즈베리파이로 복사하고 실행하기

이제 윈도우에서 추출된 결과물 파일들을 라즈베리파이로 이동시켜 실행하면 됨.

1. 파일 전송하기:
   • 방금 게시(Publish) 폴더에 생성된 모든 파일과 폴더를 복사한다.
   • 네트워크를 통해 라즈베리파이로 보내거나, USB 메모리에 담아 라즈베리파이에 꽂은 뒤 원하는 폴더(예: /home/pi/myApp)로 붙여 넣기 한다.
2. 실행 권한 부여하기 (터미널에서 진행):
   • 라즈베리파이 터미널을 열고, 파일이 복사된 폴더로 이동한다.

   cd /home/pi/myApp
   

   • 메인 프로그램(프로젝트 이름으로 된 실행 파일)에 실행 권한을 부여합니다.

   chmod +x YourProjectName
   

3. 프로그램 실행하기:

   ./YourProjectName
   

이 워크플로우를 사용면 성능이 제한된 라즈베리파이에서 직접 무겁게 코딩하거나 빌드할 필요 없이, 익숙하고 강력한 Visual Studio에서 편하게 개발한 뒤 결과물만 쏙 넣어 가볍고 빠르게 테스트할 수 있다!

다음은 Windows에서 개발된 프로젝트를 컴파일 후 리눅스용으로 배포하기 위한 위에 설명된 내용일부를 캡처한 화면.

1) [빌드] 메뉴에서 

2) 또는 [설루션 탐색기]에서

3). 폴더선택

4) 구성 Release를 클릭해서 편집한다.

5) 설치할 대상으로 프로필 설정

6) <게시> 버튼을 클릭해 파일을 생성한다.

생성된 디렉터리를 통째로 복사해서 설치할 장치에 붙여 넣으면 끝!

실행 전에 chmod로 속성을 변경하지 않으면 아래 화면처럼 허가거부!

한번 더 설명  chmode +x 프로젝트명