ED785Worker 클래스 참조

#include <ED785Worker.h>

ED785Worker에 대한 협력 다이어그램:

클래스
struct	Request
struct	Response

Public 타입
using	ResponseCallback = std::function<void(const Response &)>

Public 멤버 함수
	ED785Worker ()
bool	enqueue (const Request &req)
bool	start (int comPort, int baudRate, ResponseCallback callback)
void	stop ()
	~ED785Worker ()

정적 Public 속성
static constexpr int	ResponseCmdInternal = 0xFFFF
static constexpr int	ResponseGcdInitializationFailure = 0x0001
static constexpr int	ResponseJcdInitializationFailure = 0x0001

Private 멤버 함수
bool	createDummyWindow ()
void	destroyDummyWindow ()
bool	initializeED785 (int comPort, int baudRate)
void	notifyInitializationFailure (const std::string &reason)
void	shutdownED785 ()
void	workerThread ()

정적 Private 멤버 함수
static LRESULT CALLBACK	DummyWndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

Private 속성
int	m_baudRate
ResponseCallback	m_callback
int	m_comPort
std::mutex	m_currentMutex
std::unique_ptr< CED785 >	m_ed785
int	m_expectGcd {-1}
int	m_expectJcd {-1}
HWND	m_hDummyWnd {nullptr}
std::mutex	m_queueMutex
std::deque< Request >	m_requestQueue
std::atomic< bool >	m_running {false}
std::thread	m_thread

멤버 타입정의 문서화

ResponseCallback

using ED785Worker::ResponseCallback = std::function<void(const Response &)>

생성자 & 소멸자 문서화

ED785Worker()

ED785Worker::ED785Worker

(

)

    : m_comPort(0), m_baudRate(0)
{
}

다음을 참조함 : m_baudRate, m_comPort.

~ED785Worker()

ED785Worker::~ED785Worker

(

)

{
    stop();
}

다음을 참조함 : stop().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

멤버 함수 문서화

createDummyWindow()

bool ED785Worker::createDummyWindow ( )

private

{
    // 윈도우 클래스 등록
    WNDCLASSEXW wc = {0};
    wc.cbSize = sizeof(WNDCLASSEXW);
    wc.lpfnWndProc = DummyWndProc;
    wc.hInstance = GetModuleHandleW(nullptr);
    wc.lpszClassName = L"ED785WorkerDummy";
 
    if (!RegisterClassExW(&wc))
    {
        DWORD err = GetLastError();
        if (err != ERROR_CLASS_ALREADY_EXISTS)
        {
            Logger::error(std::wstring(L"ED785Worker - 윈도우 클래스 등록 실패: ") + std::to_wstring(err));
            return false;
        }
    }
 
    // 숨겨진 윈도우 생성
    m_hDummyWnd = CreateWindowExW(
        0, L"ED785WorkerDummy", L"ED785Worker",
        WS_OVERLAPPEDWINDOW, 0, 0, 1, 1,
        nullptr, nullptr, GetModuleHandleW(nullptr), this);
 
    if (!m_hDummyWnd)
    {
        Logger::error(L"ED785Worker - 숨겨진 윈도우 생성 실패");
        return false;
    }
 
    Logger::info(L"ED785Worker - 숨겨진 윈도우 생성 완료");
    return true;
}

다음을 참조함 : DummyWndProc(), m_hDummyWnd.

다음에 의해서 참조됨 : initializeED785().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

destroyDummyWindow()

void ED785Worker::destroyDummyWindow ( )

private

{
    if (m_hDummyWnd)
    {
        DestroyWindow(m_hDummyWnd);
        m_hDummyWnd = nullptr;
    }
}

다음을 참조함 : m_hDummyWnd.

다음에 의해서 참조됨 : initializeED785(), shutdownED785().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

DummyWndProc()

LRESULT CALLBACK ED785Worker::DummyWndProc ( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )

staticprivate

{
    // DLL에서 보내는 메시지 처리 (필요 시)
    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

다음에 의해서 참조됨 : createDummyWindow().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

enqueue()

bool ED785Worker::enqueue

(

const Request &

req

)

{
    std::scoped_lock lock(m_queueMutex);
    if (m_requestQueue.size() > 100)
    {
        Logger::error(L"ED785Worker - 요청 큐 초과");
        return false;
    }
 
    m_requestQueue.push_back(req);
    wchar_t logBuf[128];
    swprintf_s(logBuf, L"ED785Worker - 요청 큐에 추가 (큐 크기: %zu)", m_requestQueue.size());
    Logger::debug(logBuf);
    return true;
}

다음을 참조함 : m_queueMutex, m_requestQueue.

initializeED785()

bool ED785Worker::initializeED785 ( int comPort, int baudRate )

private

{
    // 숨겨진 윈도우 생성 (DLL이 윈도우 메시지를 사용할 수 있도록)
    if (!createDummyWindow())
    {
        Logger::warn(L"ED785Worker - 윈도우 생성 실패");
        notifyInitializationFailure("DUMMY_WINDOW_CREATE_FAILED");
        return false;
    }
 
    // DLL 로드 및 함수 포인터 연결
    m_ed785 = std::make_unique<CED785>();
 
    // 윈도우 핸들 전달 (DLL이 메시지 기반일 수 있음)
    int initResult = m_ed785->InitLoadLibrary(m_hDummyWnd);
    if (initResult != TRUE)
    {
        wchar_t errBuf[128];
        swprintf_s(errBuf, L"ED785Worker - DLL 로드 실패: %d", initResult);
        Logger::error(errBuf);
        destroyDummyWindow();
        notifyInitializationFailure("DLL_LOAD_FAILED:" + std::to_string(initResult));
        return false;
    }
 
    Logger::info(L"ED785Worker - DLL 로드 완료");
 
    // 시리얼 포트 연결
    byte errMsg[512] = {0};
    int loadResult = m_ed785->KLoad(comPort, baudRate, errMsg);
    if (loadResult == -1)
    {
        // errMsg는 ASCII이므로 변환 필요
        std::string errStrA(reinterpret_cast<char *>(errMsg));
        int wlen = ::MultiByteToWideChar(CP_ACP, 0, errStrA.c_str(), -1, nullptr, 0);
        std::wstring errStr;
        if (wlen > 0)
        {
            errStr.resize(wlen);
            ::MultiByteToWideChar(CP_ACP, 0, errStrA.c_str(), -1, errStr.data(), wlen);
        }
        Logger::error(L"ED785Worker - 시리얼 포트 연결 실패: " + errStr);
        std::string notifyReason = errStrA.empty() ? "PORT_OPEN_FAILED" : errStrA;
        notifyInitializationFailure(notifyReason);
        m_ed785.reset();
        destroyDummyWindow();
        return false;
    }
 
    wchar_t portLogBuf[128];
    swprintf_s(portLogBuf, L"ED785Worker - 시리얼 포트 연결 완료 (COM%d, %d bps)", comPort, baudRate);
    Logger::info(portLogBuf);
 
    // 초기화 완료 - 단말정보는 TERMINFO 명령으로 별도 요청
    // (초기화 시 직접 요청하면 응답 순서가 꼬여서 제거)
    Logger::info(L"ED785Worker - 초기화 완료, 이벤트 폴링 시작");
 
    return true;
}

다음을 참조함 : createDummyWindow(), destroyDummyWindow(), m_ed785, m_hDummyWnd, notifyInitializationFailure().

다음에 의해서 참조됨 : workerThread().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

notifyInitializationFailure()

void ED785Worker::notifyInitializationFailure ( const std::string & reason )

private

{
    if (!m_callback)
        return;
 
    Response resp{};
    resp.cmd = ResponseCmdInternal;
    resp.gcd = ResponseGcdInitializationFailure;
    resp.jcd = ResponseJcdInitializationFailure;
    resp.rcd = 0xFF;
    resp.data.assign(reason.begin(), reason.end());
    resp.dataLen = resp.data.size();
    resp.hex.clear();
    resp.hexLen = 0;
 
    m_callback(resp);
}

다음을 참조함 : ED785Worker::Response::cmd, ED785Worker::Response::data, ED785Worker::Response::dataLen, ED785Worker::Response::gcd, ED785Worker::Response::hex, ED785Worker::Response::hexLen, ED785Worker::Response::jcd, m_callback, ED785Worker::Response::rcd, ResponseCmdInternal, ResponseGcdInitializationFailure, ResponseJcdInitializationFailure.

다음에 의해서 참조됨 : initializeED785().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

shutdownED785()

void ED785Worker::shutdownED785 ( )

private

{
    if (!m_ed785)
        return;
 
    // 단말기 초기화 (대기 화면으로 복귀) - 0xFB, 0x14, 0x01
    byte emptyData[512] = {0};
    m_ed785->KReqCmd(0xFB, 0x14, 0x01, emptyData, emptyData);
    Logger::info(L"ED785Worker - 단말기 대기 화면 복귀");
 
    // 포트 연결 해제
    m_ed785->KUnLoad();
    Logger::info(L"ED785Worker - 시리얼 포트 연결 해제");
 
    m_ed785.reset();
 
    // 윈도우 제거
    destroyDummyWindow();
}

다음을 참조함 : destroyDummyWindow(), m_ed785.

다음에 의해서 참조됨 : workerThread().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

start()

bool ED785Worker::start	(	int	comPort,
		int	baudRate,
		ResponseCallback	callback )

{
    if (m_running.load())
    {
        Logger::warn(L"ED785Worker - 이미 실행 중");
        return false;
    }
 
    m_comPort = comPort;
    m_baudRate = baudRate;
    m_callback = std::move(callback);
 
    // 워커 스레드 시작 (DLL 초기화는 워커 스레드 내에서 수행)
    m_running = true;
    m_thread = std::thread([this]()
                           { workerThread(); });
 
    // 초기화 시간 확보
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
    Logger::info(L"ED785Worker - 시작 완료");
    return true;
}

다음을 참조함 : m_baudRate, m_callback, m_comPort, m_running, m_thread, workerThread().

다음에 의해서 참조됨 : wWinMain().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

stop()

void ED785Worker::stop

(

)

{
    if (!m_running.load())
        return;
 
    Logger::info(L"ED785Worker - 중지 시작");
 
    m_running = false;
    if (m_thread.joinable())
        m_thread.join();
 
    Logger::info(L"ED785Worker - 중지 완료");
}

다음을 참조함 : m_running, m_thread.

다음에 의해서 참조됨 : wWinMain(), ~ED785Worker().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

workerThread()

void ED785Worker::workerThread ( )

private

{
    Logger::info(L"ED785Worker - 워커 스레드 시작");
 
    // 워커 스레드에서 DLL 초기화 (단일 스레드 보장)
    if (!initializeED785(m_comPort, m_baudRate))
    {
        Logger::error(L"ED785Worker - 초기화 실패, 워커 스레드 종료");
        m_running = false;
        return;
    }
 
    // 메인 루프: 윈도우 메시지 처리 + 요청 처리 + 이벤트 폴링
    while (m_running.load())
    {
        // 0. 윈도우 메시지 처리 (DLL이 윈도우 메시지를 사용할 수 있음)
        MSG msg;
        while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessageW(&msg);
        }
 
        // 1. 요청 큐에서 명령 꺼내기
        Request req;
        bool hasRequest = false;
        {
            std::scoped_lock lock(m_queueMutex);
            if (!m_requestQueue.empty())
            {
                req = m_requestQueue.front();
                m_requestQueue.pop_front();
                hasRequest = true;
            }
        }
 
        // 2. 요청이 있으면 전송
        if (hasRequest)
        {
            wchar_t logBuf[256];
            swprintf_s(logBuf, L"ED785Worker - 명령 전송: CMD=0x%02X GCD=0x%02X JCD=0x%02X",
                       req.cmd, req.gcd, req.jcd);
            Logger::info(logBuf);
 
            // 현재 기대 응답 설정 (응답 매칭용)
            {
                std::scoped_lock lock(m_currentMutex);
                m_expectGcd = req.gcd;
                m_expectJcd = req.jcd;
            }
 
            // KReqCmd 호출
            byte sendData[8192] = {0};
            byte errMsg[512] = {0};
 
            // payload를 sendData에 복사 (최대 8192 바이트)
            size_t copyLen = (req.payload.size() < sizeof(sendData)) ? req.payload.size() : sizeof(sendData);
            if (copyLen > 0)
                memcpy(sendData, req.payload.data(), copyLen);
 
            int cmdResult = m_ed785->KReqCmd(req.cmd, req.gcd, req.jcd, sendData, errMsg);
            if (cmdResult != 0)
            {
                wchar_t warnBuf[128];
                swprintf_s(warnBuf, L"ED785Worker - KReqCmd 실패: %d", cmdResult);
                Logger::warn(warnBuf);
                // 실패 응답 콜백 호출
                if (m_callback)
                {
                    Response resp;
                    resp.cmd = req.cmd;
                    resp.gcd = req.gcd;
                    resp.jcd = req.jcd;
                    resp.rcd = 0xFF; // RC_FAILURE
                    resp.data.resize(512);
                    memcpy(resp.data.data(), errMsg, 512);
                    resp.dataLen = strlen(reinterpret_cast<char *>(errMsg));
                    resp.hexLen = 0;
                    m_callback(resp);
                }
 
                // 기대 응답 초기화
                {
                    std::scoped_lock lock(m_currentMutex);
                    m_expectGcd = -1;
                    m_expectJcd = -1;
                }
                continue;
            }
 
            Logger::debug(L"ED785Worker - KReqCmd 전송 완료, 응답 대기 시작");
        }
 
        // 3. KGetEvent로 이벤트 폴링 (항상 수행)
        int cmd = 0, gcd = 0, jcd = 0, rcd = 0;
        byte rdata[8192] = {0};
        byte hexdata[8192] = {0};
 
        int eventResult = m_ed785->KGetEvent(cmd, gcd, jcd, rcd, rdata, hexdata);
 
#pragma region TEST LINE
 
        //==================TestLine========================
 
        //// 단말기 상태 정보 (0xFB 0x14 0x09) 전용 로그
        // if (gcd == 0x14 && jcd == 0x09)
        //{
        //     std::string statusCode;
        //     if (rdata[0] != 0)
        //     {
        //         statusCode.assign(reinterpret_cast<const char *>(rdata), 2);
        //     }
        //     std::wstring wStatus(statusCode.begin(), statusCode.end());
        //     std::wstring desc = L"알수없음";
        //     if (statusCode == "01")
        //         desc = L"신용카드 투입";
        //     else if (statusCode == "02")
        //         desc = L"서버로 접속 시도";
        //     else if (statusCode == "03")
        //         desc = L"FALLBACK 상황 발생";
        //     else if (statusCode == "04")
        //         desc = L"승인 불가능한 카드 인입";
 
        //    wchar_t statusLog[256];
        //    swprintf_s(statusLog, L"ED785Worker - 상태 이벤트 (0x14/0x09): RC=0x%02X STATUS=%s (%s)",
        //               rcd, wStatus.c_str(), desc.c_str());
        //    Logger::info(statusLog);
        //}
 
        // wchar_t eventLogBuf[256];
        // swprintf_s(eventLogBuf, L"ED785Worker - 아무이벤트 수신: CMD=0x%02X GCD=0x%02X JCD=0x%02X RCD=0x%02X",
        //  cmd, gcd, jcd, rcd);
        // Logger::debug(eventLogBuf);
 
        //==================TestLineEnd========================
 
#pragma endregion
 
        // 디버깅: 폴링 상태 로그 (일부만)
        static int pollCount = 0;
        if (++pollCount % 50 == 0) // 10초마다 (50 * 200ms)
        {
            wchar_t pollLogBuf[128];
            swprintf_s(pollLogBuf, L"ED785Worker - KGetEvent 폴링 중 (결과: %d)", eventResult);
            // Logger::debug(pollLogBuf);
        }
 
        if (eventResult != -1)
        {
            // 이벤트 수신 성공
            wchar_t eventLogBuf[256];
            swprintf_s(eventLogBuf, L"ED785Worker - 이벤트 수신: CMD=0x%02X GCD=0x%02X JCD=0x%02X RCD=0x%02X",
                       cmd, gcd, jcd, rcd);
            Logger::debug(eventLogBuf);
 
            // 응답 구성
            Response resp;
            resp.cmd = cmd;
            resp.gcd = gcd;
            resp.jcd = jcd;
            resp.rcd = rcd;
 
            // RDATA 복사 (유효 길이 계산)
            resp.data.resize(8192);
            memcpy(resp.data.data(), rdata, 8192);
            resp.dataLen = strlen(reinterpret_cast<char *>(rdata));
 
            // HEXDATA 복사 (바이너리이므로 전체 복사, 유효 길이는 별도 처리 필요)
            resp.hex.resize(8192);
            memcpy(resp.hex.data(), hexdata, 8192);
 
            // HEXDATA 유효 길이 계산 (일단 간단히 0이 아닌 마지막 바이트까지)
            resp.hexLen = 0;
            for (int i = 8191; i >= 0; --i)
            {
                if (hexdata[i] != 0)
                {
                    resp.hexLen = i + 1;
                    break;
                }
            }
 
            // 콜백 호출
            if (m_callback)
                m_callback(resp);
 
            // 기대 응답 초기화 (매칭 여부 무관하게)
            {
                std::scoped_lock lock(m_currentMutex);
                m_expectGcd = -1;
                m_expectJcd = -1;
            }
        }
        else
        {
            // 이벤트 없음 - 폴링 간격 대기
            std::this_thread::sleep_for(std::chrono::milliseconds(POLL_INTERVAL_MS));
        }
    }
 
    // 정리
    shutdownED785();
    Logger::info(L"ED785Worker - 워커 스레드 종료");
}

다음을 참조함 : ED785Worker::Request::cmd, ED785Worker::Response::cmd, ED785Worker::Response::data, ED785Worker::Response::dataLen, ED785Worker::Request::gcd, ED785Worker::Response::gcd, ED785Worker::Response::hex, ED785Worker::Response::hexLen, initializeED785(), ED785Worker::Request::jcd, ED785Worker::Response::jcd, m_baudRate, m_callback, m_comPort, m_currentMutex, m_ed785, m_expectGcd, m_expectJcd, m_queueMutex, m_requestQueue, m_running, ED785Worker::Request::payload, POLL_INTERVAL_MS, ED785Worker::Response::rcd, shutdownED785().

다음에 의해서 참조됨 : start().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

m_baudRate

int ED785Worker::m_baudRate

private

다음에 의해서 참조됨 : ED785Worker(), start(), workerThread().

m_callback

ResponseCallback ED785Worker::m_callback

private

다음에 의해서 참조됨 : notifyInitializationFailure(), start(), workerThread().

m_comPort

int ED785Worker::m_comPort

private

다음에 의해서 참조됨 : ED785Worker(), start(), workerThread().

m_currentMutex

std::mutex ED785Worker::m_currentMutex

private

다음에 의해서 참조됨 : workerThread().

m_ed785

std::unique_ptr<CED785> ED785Worker::m_ed785

private

다음에 의해서 참조됨 : initializeED785(), shutdownED785(), workerThread().

m_expectGcd

int ED785Worker::m_expectGcd {-1}

private

{-1};

다음에 의해서 참조됨 : workerThread().

m_expectJcd

int ED785Worker::m_expectJcd {-1}

private

{-1};

다음에 의해서 참조됨 : workerThread().

m_hDummyWnd

HWND ED785Worker::m_hDummyWnd {nullptr}

private

{nullptr};

다음에 의해서 참조됨 : createDummyWindow(), destroyDummyWindow(), initializeED785().

m_queueMutex

std::mutex ED785Worker::m_queueMutex

private

다음에 의해서 참조됨 : enqueue(), workerThread().

m_requestQueue

std::deque<Request> ED785Worker::m_requestQueue

private

다음에 의해서 참조됨 : enqueue(), workerThread().

m_running

std::atomic<bool> ED785Worker::m_running {false}

private

{false};

다음에 의해서 참조됨 : start(), stop(), workerThread().

m_thread

std::thread ED785Worker::m_thread

private

다음에 의해서 참조됨 : start(), stop().

ResponseCmdInternal

int ED785Worker::ResponseCmdInternal = 0xFFFF

staticconstexpr

다음에 의해서 참조됨 : notifyInitializationFailure(), ProtocolAdapter::onEd785Response().

ResponseGcdInitializationFailure

int ED785Worker::ResponseGcdInitializationFailure = 0x0001

staticconstexpr

다음에 의해서 참조됨 : notifyInitializationFailure(), ProtocolAdapter::onEd785Response().

ResponseJcdInitializationFailure

int ED785Worker::ResponseJcdInitializationFailure = 0x0001

staticconstexpr

다음에 의해서 참조됨 : notifyInitializationFailure(), ProtocolAdapter::onEd785Response().

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• ED785Worker.h
• ED785Worker.cpp