<div id="readability-page-1" class="page"><div>
												
<p>이런 코드 따위는 인공지능이 작성해 주더라…</p>
<h2>Visual C++ 에서 컴파일하는 방법</h2>
<ul>
<li>Developer Command Prompt for VS 관리자권한으로 실행</li>
<li>소스코드 경로로 이동</li>
<li>cl /MT /O2 /utf-8 lora.c /link advapi32.lib</li>
<li>cl /MT /O2 /utf-8 /W4 /EHsc lora.c /link advapi32.lib user32.lib /OUT:lora.exe</li>
</ul>
<h2>소스코드</h2>
<pre><code>#include &lt;windows.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;stdbool.h&gt;

#define MAX_BUFFER_SIZE 256
#define MAX_COM_PORTS 32
#define DEFAULT_BAUDRATE CBR_9600
#define TRANSMISSION_INTERVAL 100
#define PORT_CHECK_INTERVAL 2000
#define AT_RESPONSE_TIMEOUT 1000

typedef struct {
    HANDLE hSerial;
    char portName[10];
    bool isConnected;
} LoRaDevice;

bool isLoRaDevice(HANDLE hSerial) {
    const char* testCommand = "AT\r\n";
    char buffer[MAX_BUFFER_SIZE];
    DWORD bytesWritten, bytesRead;

    // AT 명령어 전송
    if (!WriteFile(hSerial, testCommand, strlen(testCommand), &amp;bytesWritten, NULL)) {
        printf("Error: AT 명령어 전송 실패\n");
        return false;
    }

    // 응답 대기
    Sleep(AT_RESPONSE_TIMEOUT);

    if (ReadFile(hSerial, buffer, MAX_BUFFER_SIZE - 1, &amp;bytesRead, NULL)) {
        buffer[bytesRead] = '\0';

        // "OK" 응답 확인
        if (strstr(buffer, "OK") != NULL) {
            printf("LoRa 장치 확인됨\n");
            return true;
        }
    }

    printf("Error: LoRa 장치가 아니거나 응답이 없습니다\n");
    return false;
}

bool findAvailableComPorts(char** comPorts, int* numPorts) {
    HKEY hKey;
    char keyPath[] = "HARDWARE\\DEVICEMAP\\SERIALCOMM";
    *numPorts = 0;

    // 레지스트리 키 열기
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_READ, &amp;hKey) != ERROR_SUCCESS) {
        printf("Error: 레지스트리 키를 열 수 없습니다\n");
        return false;
    }

    char valueName[MAX_BUFFER_SIZE];
    char valueData[MAX_BUFFER_SIZE];
    DWORD valueSize;
    DWORD valueNameSize;
    DWORD type;
    DWORD index = 0;

    // 레지스트리에서 COM 포트 열거
    while (*numPorts &lt; MAX_COM_PORTS) {
        valueSize = MAX_BUFFER_SIZE;
        valueNameSize = MAX_BUFFER_SIZE;

        if (RegEnumValue(hKey, index++, valueName, &amp;valueNameSize, NULL, &amp;type, 
                        (LPBYTE)valueData, &amp;valueSize) != ERROR_SUCCESS) {
            break;
        }

        if (type == REG_SZ) {
            comPorts[*numPorts] = (char*)malloc(valueSize);
            strcpy(comPorts[*numPorts], valueData);
            (*numPorts)++;
        }
    }

    RegCloseKey(hKey);
    return *numPorts &gt; 0;
}

// COM 포트 선택 함수
bool selectComPort(char* selectedPort) {
    char* comPorts[MAX_COM_PORTS];
    int numPorts;

    if (!findAvailableComPorts(comPorts, &amp;numPorts)) {
        printf("사용 가능한 COM 포트를 찾을 수 없습니다\n");
        return false;
    }

    printf("\n=== 사용 가능한 COM 포트 목록 ===\n");
    for (int i = 0; i &lt; numPorts; i++) {
        printf("%d: %s\n", i + 1, comPorts[i]);
    }

    if (numPorts == 1) {
        strcpy(selectedPort, comPorts[0]);
        printf("\n단일 COM 포트 발견. %s 선택됨\n", selectedPort);
    } else {
        int choice;
        printf("\n포트를 선택하세요 (1-%d): ", numPorts);
        scanf("%d", &amp;choice);

        if (choice &lt; 1 || choice &gt; numPorts) {
            printf("잘못된 선택입니다\n");
            return false;
        }
        strcpy(selectedPort, comPorts[choice - 1]);
    }

    // 메모리 해제
    for (int i = 0; i &lt; numPorts; i++) {
        free(comPorts[i]);
    }

    return true;
}

bool initializeSerialPort(LoRaDevice* device, const char* portName) {
    sprintf(device-&gt;portName, "\\\\.\\%s", portName);

    device-&gt;hSerial = CreateFile(device-&gt;portName,
                                GENERIC_READ | GENERIC_WRITE,
                                0,
                                0,
                                OPEN_EXISTING,
                                FILE_ATTRIBUTE_NORMAL,
                                0);

    if (device-&gt;hSerial == INVALID_HANDLE_VALUE) {
        printf("Error: 포트를 열 수 없습니다 %s\n", portName);
        return false;
    }

    DCB dcbSerialParams = {0};
    dcbSerialParams.DCBlength = sizeof(dcbSerialParams);

    if (!GetCommState(device-&gt;hSerial, &amp;dcbSerialParams)) {
        printf("Error: 현재 DCB 설정을 가져올 수 없습니다\n");
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    dcbSerialParams.BaudRate = DEFAULT_BAUDRATE;
    dcbSerialParams.ByteSize = 8;
    dcbSerialParams.StopBits = ONESTOPBIT;
    dcbSerialParams.Parity = NOPARITY;

    if (!SetCommState(device-&gt;hSerial, &amp;dcbSerialParams)) {
        printf("Error: DCB 설정을 적용할 수 없습니다\n");
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    COMMTIMEOUTS timeouts = {0};
    timeouts.ReadIntervalTimeout = 50;
    timeouts.ReadTotalTimeoutConstant = 50;
    timeouts.ReadTotalTimeoutMultiplier = 10;
    timeouts.WriteTotalTimeoutConstant = 50;
    timeouts.WriteTotalTimeoutMultiplier = 10;

    if (!SetCommTimeouts(device-&gt;hSerial, &amp;timeouts)) {
        printf("Error: 타임아웃 설정을 적용할 수 없습니다\n");
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    // LoRa 장치 확인 추가
    if (!isLoRaDevice(device-&gt;hSerial)) {
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    device-&gt;isConnected = true;
    return true;
}

bool initializeLoRa(LoRaDevice* device) {
    const char* initCommands[] = {
        "AT+MODE=LWOTAA\r\n",
        "AT+JOIN=1\r\n",
        "AT+DR=0\r\n",
        "AT+CH=0,920.9\r\n",
        "AT+POWER=20\r\n",
        "AT+SF=12\r\n",
        "AT+BW=125\r\n",
        "AT+CR=4/5\r\n",
        "AT+PL=1\r\n",
        "AT+CRC=1\r\n",
        "AT+IQ=1\r\n",
        "AT+SYNC=34\r\n"
    };

    DWORD bytesWritten;
    char buffer[MAX_BUFFER_SIZE];

    for (int i = 0; i &lt; sizeof(initCommands) / sizeof(initCommands[0]); i++) {
        if (!WriteFile(device-&gt;hSerial, initCommands[i], strlen(initCommands[i]), &amp;bytesWritten, NULL)) {
            printf("Error: LoRa 초기화 명령어 전송 실패\n");
            return false;
        }

        Sleep(1000);

        DWORD bytesRead;
        if (ReadFile(device-&gt;hSerial, buffer, MAX_BUFFER_SIZE - 1, &amp;bytesRead, NULL)) {
            buffer[bytesRead] = '\0';
            printf("응답: %s\n", buffer);
        }
    }

    return true;
}

bool sendMessage(LoRaDevice* device, const char* message) {
    if (!device-&gt;isConnected) {
        printf("Error: 장치가 연결되어 있지 않습니다\n");
        return false;
    }

    char command[MAX_BUFFER_SIZE];
    sprintf(command, "AT+SEND=%s\r\n", message);

    DWORD bytesWritten;
    if (!WriteFile(device-&gt;hSerial, command, strlen(command), &amp;bytesWritten, NULL)) {
        printf("Error: 메시지 전송 실패\n");
        return false;
    }

    printf("메시지 전송됨: %s\n", message);
    return true;
}

void disconnectDevice(LoRaDevice* device) {
    if (device-&gt;isConnected) {
        CloseHandle(device-&gt;hSerial);
        device-&gt;isConnected = false;
        printf("장치 연결이 해제되었습니다\n");
    }
}

bool waitForComPort(LoRaDevice* device) {
    printf("사용 가능한 COM 포트를 찾을 때까지 대기중...\n");

    while (1) {
        char portName[10];
        if (selectComPort(portName)) {
            printf("\nCOM 포트 발견: %s\n", portName);
            printf("포트 초기화 및 LoRa 장치 확인 중...\n");

            // 시리얼 포트 초기화 및 LoRa 장치 확인
            if (initializeSerialPort(device, portName)) {
                printf("시리얼 포트 연결 성공 (LoRa 장치 확인됨)\n");
                return true;
            }

            printf("해당 포트에서 LoRa 장치를 찾을 수 없습니다. 다른 포트를 확인합니다.\n");
        }
        printf(".");
        fflush(stdout);
        Sleep(PORT_CHECK_INTERVAL);
    }

    return false;
}

int main() {
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);

    LoRaDevice loraDevice = {0};
    char portName[10];
    DWORD messageCount = 0;

    if (!waitForComPort(&amp;loraDevice)) {
        printf("프로그램을 종료합니다\n");
        return 1;
    }

    printf("시리얼 포트 연결 성공\n");

    if (!initializeLoRa(&amp;loraDevice)) {
        printf("LoRa 초기화 실패\n");
        disconnectDevice(&amp;loraDevice);
        return 1;
    }

    printf("LoRa 초기화 완료\n");
    printf("\n=== LoRa 송신 프로그램 시작 ===\n");
    printf("'Hello, World!' 메시지를 연속 전송합니다.\n");
    printf("프로그램을 종료하려면 Ctrl+C를 누르세요.\n\n");

    while (1) {
        if (sendMessage(&amp;loraDevice, "Hello, World!")) {
            messageCount++;
            printf("총 전송 횟수: %lu\n", messageCount);
        }
        Sleep(TRANSMISSION_INTERVAL);  // 전송 간격 대기
    }

    disconnectDevice(&amp;loraDevice);
    return 0;
}</code></pre>
<pre><code>#include &lt;windows.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;stdbool.h&gt;

#define MAX_BUFFER_SIZE 256
#define MAX_COM_PORTS 32
#define DEFAULT_BAUDRATE CBR_9600
#define PORT_CHECK_INTERVAL 2000
#define AT_RESPONSE_TIMEOUT 1000

typedef struct {
    HANDLE hSerial;
    char portName[10];
    bool isConnected;
} LoRaDevice;

bool isLoRaDevice(HANDLE hSerial) {
    const char* testCommand = "AT\r\n";
    char buffer[MAX_BUFFER_SIZE];
    DWORD bytesWritten, bytesRead;

    // AT 명령어 전송
    if (!WriteFile(hSerial, testCommand, strlen(testCommand), &amp;bytesWritten, NULL)) {
        printf("Error: AT 명령어 전송 실패\n");
        return false;
    }

    // 응답 대기
    Sleep(AT_RESPONSE_TIMEOUT);

    if (ReadFile(hSerial, buffer, MAX_BUFFER_SIZE - 1, &amp;bytesRead, NULL)) {
        buffer[bytesRead] = '\0';

        // "OK" 응답 확인
        if (strstr(buffer, "OK") != NULL) {
            printf("LoRa 장치 확인됨\n");
            return true;
        }
    }

    printf("Error: LoRa 장치가 아니거나 응답이 없습니다\n");
    return false;
}

bool findAvailableComPorts(char** comPorts, int* numPorts) {
    HKEY hKey;
    char keyPath[] = "HARDWARE\\DEVICEMAP\\SERIALCOMM";
    *numPorts = 0;

    // 레지스트리 키 열기
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_READ, &amp;hKey) != ERROR_SUCCESS) {
        printf("Error: 레지스트리 키를 열 수 없습니다\n");
        return false;
    }

    char valueName[MAX_BUFFER_SIZE];
    char valueData[MAX_BUFFER_SIZE];
    DWORD valueSize;
    DWORD valueNameSize;
    DWORD type;
    DWORD index = 0;

    // 레지스트리에서 COM 포트 열거
    while (*numPorts &lt; MAX_COM_PORTS) {
        valueSize = MAX_BUFFER_SIZE;
        valueNameSize = MAX_BUFFER_SIZE;

        if (RegEnumValue(hKey, index++, valueName, &amp;valueNameSize, NULL, &amp;type, 
                        (LPBYTE)valueData, &amp;valueSize) != ERROR_SUCCESS) {
            break;
        }

        if (type == REG_SZ) {
            comPorts[*numPorts] = (char*)malloc(valueSize);
            strcpy(comPorts[*numPorts], valueData);
            (*numPorts)++;
        }
    }

    RegCloseKey(hKey);
    return *numPorts &gt; 0;
}

// COM 포트 선택 함수
bool selectComPort(char* selectedPort) {
    char* comPorts[MAX_COM_PORTS];
    int numPorts;

    if (!findAvailableComPorts(comPorts, &amp;numPorts)) {
        printf("사용 가능한 COM 포트를 찾을 수 없습니다\n");
        return false;
    }

    printf("\n=== 사용 가능한 COM 포트 목록 ===\n");
    for (int i = 0; i &lt; numPorts; i++) {
        printf("%d: %s\n", i + 1, comPorts[i]);
    }

    if (numPorts == 1) {
        strcpy(selectedPort, comPorts[0]);
        printf("\n단일 COM 포트 발견. %s 선택됨\n", selectedPort);
    } else {
        int choice;
        printf("\n포트를 선택하세요 (1-%d): ", numPorts);
        scanf("%d", &amp;choice);

        if (choice &lt; 1 || choice &gt; numPorts) {
            printf("잘못된 선택입니다\n");
            return false;
        }
        strcpy(selectedPort, comPorts[choice - 1]);
    }

    // 메모리 해제
    for (int i = 0; i &lt; numPorts; i++) {
        free(comPorts[i]);
    }

    return true;
}

bool initializeSerialPort(LoRaDevice* device, const char* portName) {
    sprintf(device-&gt;portName, "\\\\.\\%s", portName);

    device-&gt;hSerial = CreateFile(device-&gt;portName,
                                GENERIC_READ | GENERIC_WRITE,
                                0,
                                0,
                                OPEN_EXISTING,
                                FILE_ATTRIBUTE_NORMAL,
                                0);

    if (device-&gt;hSerial == INVALID_HANDLE_VALUE) {
        printf("Error: 포트를 열 수 없습니다 %s\n", portName);
        return false;
    }

    DCB dcbSerialParams = {0};
    dcbSerialParams.DCBlength = sizeof(dcbSerialParams);

    if (!GetCommState(device-&gt;hSerial, &amp;dcbSerialParams)) {
        printf("Error: 현재 DCB 설정을 가져올 수 없습니다\n");
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    dcbSerialParams.BaudRate = DEFAULT_BAUDRATE;
    dcbSerialParams.ByteSize = 8;
    dcbSerialParams.StopBits = ONESTOPBIT;
    dcbSerialParams.Parity = NOPARITY;

    if (!SetCommState(device-&gt;hSerial, &amp;dcbSerialParams)) {
        printf("Error: DCB 설정을 적용할 수 없습니다\n");
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    COMMTIMEOUTS timeouts = {0};
    timeouts.ReadIntervalTimeout = 50;
    timeouts.ReadTotalTimeoutConstant = 50;
    timeouts.ReadTotalTimeoutMultiplier = 10;
    timeouts.WriteTotalTimeoutConstant = 50;
    timeouts.WriteTotalTimeoutMultiplier = 10;

    if (!SetCommTimeouts(device-&gt;hSerial, &amp;timeouts)) {
        printf("Error: 타임아웃 설정을 적용할 수 없습니다\n");
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    // LoRa 장치 확인 추가
    if (!isLoRaDevice(device-&gt;hSerial)) {
        CloseHandle(device-&gt;hSerial);
        return false;
    }

    device-&gt;isConnected = true;
    return true;
}

bool initializeLoRa(LoRaDevice* device) {
    const char* initCommands[] = {
        "AT+MODE=LWOTAA\r\n",
        "AT+JOIN=1\r\n",
        "AT+DR=0\r\n",
        "AT+CH=0,920.9\r\n",
        "AT+POWER=20\r\n",
        "AT+SF=12\r\n",
        "AT+BW=125\r\n",
        "AT+CR=4/5\r\n",
        "AT+PL=1\r\n",
        "AT+CRC=1\r\n",
        "AT+IQ=1\r\n",
        "AT+SYNC=34\r\n"
    };

    DWORD bytesWritten;
    char buffer[MAX_BUFFER_SIZE];

    for (int i = 0; i &lt; sizeof(initCommands) / sizeof(initCommands[0]); i++) {
        if (!WriteFile(device-&gt;hSerial, initCommands[i], strlen(initCommands[i]), &amp;bytesWritten, NULL)) {
            printf("Error: LoRa 초기화 명령어 전송 실패\n");
            return false;
        }

        Sleep(1000);

        DWORD bytesRead;
        if (ReadFile(device-&gt;hSerial, buffer, MAX_BUFFER_SIZE - 1, &amp;bytesRead, NULL)) {
            buffer[bytesRead] = '\0';
            printf("응답: %s\n", buffer);
        }
    }

    return true;
}

bool receiveMessage(LoRaDevice* device) {
    if (!device-&gt;isConnected) {
        printf("Error: 장치가 연결되어 있지 않습니다\n");
        return false;
    }

    char buffer[MAX_BUFFER_SIZE];
    DWORD bytesRead;

    if (ReadFile(device-&gt;hSerial, buffer, MAX_BUFFER_SIZE - 1, &amp;bytesRead, NULL)) {
        if (bytesRead &gt; 0) {
            buffer[bytesRead] = '\0';
            printf("수신된 메시지: %s\n", buffer);
            return true;
        }
    }

    return false;
}

void disconnectDevice(LoRaDevice* device) {
    if (device-&gt;isConnected) {
        CloseHandle(device-&gt;hSerial);
        device-&gt;isConnected = false;
        printf("장치 연결이 해제되었습니다\n");
    }
}

bool waitForComPort(LoRaDevice* device) {
    printf("사용 가능한 COM 포트를 찾을 때까지 대기중...\n");

    while (1) {
        char portName[10];
        if (selectComPort(portName)) {
            printf("\nCOM 포트 발견: %s\n", portName);
            printf("포트 초기화 및 LoRa 장치 확인 중...\n");

            // 시리얼 포트 초기화 및 LoRa 장치 확인
            if (initializeSerialPort(device, portName)) {
                printf("시리얼 포트 연결 성공 (LoRa 장치 확인됨)\n");
                return true;
            }

            printf("해당 포트에서 LoRa 장치를 찾을 수 없습니다. 다른 포트를 확인합니다.\n");
        }
        printf(".");
        fflush(stdout);
        Sleep(PORT_CHECK_INTERVAL);
    }

    return false;
}

int main() {
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);

    LoRaDevice loraDevice = {0};
    char portName[10];
    DWORD messageCount = 0;

    if (!waitForComPort(&amp;loraDevice)) {
        printf("프로그램을 종료합니다\n");
        return 1;
    }

    printf("시리얼 포트 연결 성공\n");

    if (!initializeLoRa(&amp;loraDevice)) {
        printf("LoRa 초기화 실패\n");
        disconnectDevice(&amp;loraDevice);
        return 1;
    }

    printf("LoRa 초기화 완료\n");
    printf("\n=== LoRa 수신 프로그램 시작 ===\n");
    printf("메시지 수신 대기 중...\n");
    printf("프로그램을 종료하려면 Ctrl+C를 누르세요.\n\n");

    while (1) {
        if (receiveMessage(&amp;loraDevice)) {
            messageCount++;
            printf("총 수신 횟수: %lu\n", messageCount);
        }
        Sleep(10);  // CPU 부하 감소를 위한 짧은 대기
    }

    disconnectDevice(&amp;loraDevice);
    return 0;
}</code></pre>
<p><span></span> <span>Post Views:</span> <span>8</span>
			</p>											</div></div>

상구리의 기술 블로그

LoRaWAN 송신 및 수신 코드
이런 코드 따위는 인공지능이 작성해 주더라…
Visual C++ 에서 컴파일하는 방법
Developer Command Prompt for VS 관리자권한으로 실행
소스코드 경로로 이동
cl /MT /O2 /utf-8 lora.c /link advapi32.lib
cl /MT /O2 /utf-8 /W4 /EHsc lora.c /link advapi32.lib user32.lib /OUT:lora.exe
소스코드
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#define MAX_BUFFER_SIZE 256
#define MAX_COM_PORTS 32
#define DEFAULT_BAUDRATE CBR_9600
#define TRANSMISSION_INTERVAL 100
#define PORT_CHECK_INTERVAL 2000
#define AT_RESPONSE_TIMEOUT 1000
typedef struct {
    HANDLE hSerial;
    char portName[10];
    bool isConnected;
} LoRaDevice;
bool isLoRaDevice(HANDLE hSerial) {
    const char* testCommand = "AT\r\n";
    char buffer[MAX_BUFFER_SIZE];
    DWORD bytesWritten, bytesRead;
    // AT 명령어 전송
    if (!WriteFile(hSerial, testCommand, strlen(testCommand), &bytesWritten, NULL)) {
        printf("Error: AT 명령어 전송 실패\n");
        return false;
    }
    // 응답 대기
    Sleep(AT_RESPONSE_TIMEOUT);
    if (ReadFile(hSerial, buffer, MAX_BUFFER_SIZE - 1, &bytesRead, NULL)) {
        buffer[bytesRead] = '\0';
        // "OK" 응답 확인
        if (strstr(buffer, "OK") != NULL) {
            printf("LoRa 장치 확인됨\n");
            return true;
        }
    }
    printf("Error: LoRa 장치가 아니거나 응답이 없습니다\n");
    return false;
}
bool findAvailableComPorts(char** comPorts, int* numPorts) {
    HKEY hKey;
    char keyPath[] = "HARDWARE\\DEVICEMAP\\SERIALCOMM";
    *numPorts = 0;
    // 레지스트리 키 열기
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS) {
        printf("Error: 레지스트리 키를 열 수 없습니다\n");
        return false;
    }
    char valueName[MAX_BUFFER_SIZE];
    char valueData[MAX_BUFFER_SIZE];
    DWORD valueSize;
    DWORD valueNameSize;
    DWORD type;
    DWORD index = 0;
    // 레지스트리에서 COM 포트 열거
    while (*numPorts < MAX_COM_PORTS) {
        valueSize = MAX_BUFFER_SIZE;
        valueNameSize = MAX_BUFFER_SIZE;
        if (RegEnumValue(hKey, index++, valueName, &valueNameSize, NULL, &type, 
                        (LPBYTE)valueData, &valueSize) != ERROR_SUCCESS) {
            break;
        }
        if (type == REG_SZ) {
            comPorts[*numPorts] = (char*)malloc(valueSize);
            strcpy(comPorts[*numPorts], valueData);
            (*numPorts)++;
        }
    }
    RegCloseKey(hKey);
    return *numPorts > 0;
}
// COM 포트 선택 함수
bool selectComPort(char* selectedPort) {
    char* comPorts[MAX_COM_PORTS];
    int numPorts;
    if (!findAvailableComPorts(comPorts, &numPorts)) {
        printf("사용 가능한 COM 포트를 찾을 수 없습니다\n");
        return false;
    }
    printf("\n=== 사용 가능한 COM 포트 목록 ===\n");
    for (int i = 0; i < numPorts; i++) {
        printf("%d: %s\n", i + 1, comPorts[i]);
    }
    if (numPorts == 1) {
        strcpy(selectedPort, comPorts[0]);
        printf("\n단일 COM 포트 발견. %s 선택됨\n", selectedPort);
    } else {
        int choice;
        printf("\n포트를 선택하세요 (1-%d): ", numPorts);
        scanf("%d", &choice);
        if (choice < 1 || choice > numPorts) {
            printf("잘못된 선택입니다\n");
            return false;
        }
        strcpy(selectedPort, comPorts[choice - 1]);
    }
    // 메모리 해제
    for (int i = 0; i < numPorts; i++) {
        free(comPorts[i]);
    }
    return true;
}
bool initializeSerialPort(LoRaDevice* device, const char* portName) {
    sprintf(device->portName, "\\\\.\\%s", portName);
    device->hSerial = CreateFile(device->portName,
                                GENERIC_READ | GENERIC_WRITE,
                                0,
                                0,
                                OPEN_EXISTING,
                                FILE_ATTRIBUTE_NORMAL,
                                0);
    if (device->hSerial == INVALID_HANDLE_VALUE) {
        printf("Error: 포트를 열 수 없습니다 %s\n", portName);
        return false;
    }
    DCB dcbSerialParams = {0};
    dcbSerialParams.DCBlength = sizeof(dcbSerialParams);
    if (!GetCommState(device->hSerial, &dcbSerialParams)) {
        printf("Error: 현재 DCB 설정을 가져올 수 없습니다\n");
        CloseHandle(device->hSerial);
        return false;
    }
    dcbSerialParams.BaudRate = DEFAULT_BAUDRATE;
    dcbSerialParams.ByteSize = 8;
    dcbSerialParams.StopBits = ONESTOPBIT;
    dcbSerialParams.Parity = NOPARITY;
    if (!SetCommState(device->hSerial, &dcbSerialParams)) {
        printf("Error: DCB 설정을 적용할 수 없습니다\n");
        CloseHandle(device->hSerial);
        return false;
    }
    COMMTIMEOUTS timeouts = {0};
    timeouts.ReadIntervalTimeout = 50;
    timeouts.ReadTotalTimeoutConstant = 50;
    timeouts.ReadTotalTimeoutMultiplier = 10;
    timeouts.WriteTotalTimeoutConstant = 50;
    timeouts.WriteTotalTimeoutMultiplier = 10;
    if (!SetCommTimeouts(device->hSerial, &timeouts)) {
        printf("Error: 타임아웃 설정을 적용할 수 없습니다\n");
        CloseHandle(device->hSerial);
        return false;
    }
    // LoRa 장치 확인 추가
    if (!isLoRaDevice(device->hSerial)) {
        CloseHandle(device->hSerial);
        return false;
    }
    device->isConnected = true;
    return true;
}
bool initializeLoRa(LoRaDevice* device) {
    const char* initCommands[] = {
        "AT+MODE=LWOTAA\r\n",
        "AT+JOIN=1\r\n",
        "AT+DR=0\r\n",
        "AT+CH=0,920.9\r\n",
        "AT+POWER=20\r\n",
        "AT+SF=12\r\n",
        "AT+BW=125\r\n",
        "AT+CR=4/5\r\n",
        "AT+PL=1\r\n",
        "AT+CRC=1\r\n",
        "AT+IQ=1\r\n",
        "AT+SYNC=34\r\n"
    };
    DWORD bytesWritten;
    char buffer[MAX_BUFFER_SIZE];
    for (int i = 0; i < sizeof(initCommands) / sizeof(initCommands[0]); i++) {
        if (!WriteFile(device->hSerial, initCommands[i], strlen(initCommands[i]), &bytesWritten, NULL)) {
            printf("Error: LoRa 초기화 명령어 전송 실패\n");
            return false;
        }
        Sleep(1000);
        DWORD bytesRead;
        if (ReadFile(device->hSerial, buffer, MAX_BUFFER_SIZE - 1, &bytesRead, NULL)) {
            buffer[bytesRead] = '\0';
            printf("응답: %s\n", buffer);
        }
    }
    return true;
}
bool sendMessage(LoRaDevice* device, const char* message) {
    if (!device->isConnected) {
        printf("Error: 장치가 연결되어 있지 않습니다\n");
        return false;
    }
    char command[MAX_BUFFER_SIZE];
    sprintf(command, "AT+SEND=%s\r\n", message);
    DWORD bytesWritten;
    if (!WriteFile(device->hSerial, command, strlen(command), &bytesWritten, NULL)) {
        printf("Error: 메시지 전송 실패\n");
        return false;
    }
    printf("메시지 전송됨: %s\n", message);
    return true;
}
void disconnectDevice(LoRaDevice* device) {
    if (device->isConnected) {
        CloseHandle(device->hSerial);
        device->isConnected = false;
        printf("장치 연결이 해제되었습니다\n");
    }
}
bool waitForComPort(LoRaDevice* device) {
    printf("사용 가능한 COM 포트를 찾을 때까지 대기중...\n");
    while (1) {
        char portName[10];
        if (selectComPort(portName)) {
            printf("\nCOM 포트 발견: %s\n", portName);
            printf("포트 초기화 및 LoRa 장치 확인 중...\n");
            // 시리얼 포트 초기화 및 LoRa 장치 확인
            if (initializeSerialPort(device, portName)) {
                printf("시리얼 포트 연결 성공 (LoRa 장치 확인됨)\n");
                return true;
            }
            printf("해당 포트에서 LoRa 장치를 찾을 수 없습니다. 다른 포트를 확인합니다.\n");
        }
        printf(".");
        fflush(stdout);
        Sleep(PORT_CHECK_INTERVAL);
    }
    return false;
}
int main() {
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);
    LoRaDevice loraDevice = {0};
    char portName[10];
    DWORD messageCount = 0;
    if (!waitForComPort(&loraDevice)) {
        printf("프로그램을 종료합니다\n");
        return 1;
    }
    printf("시리얼 포트 연결 성공\n");
    if (!initializeLoRa(&loraDevice)) {
        printf("LoRa 초기화 실패\n");
        disconnectDevice(&loraDevice);
        return 1;
    }
    printf("LoRa 초기화 완료\n");
    printf("\n=== LoRa 송신 프로그램 시작 ===\n");
    printf("'Hello, World!' 메시지를 연속 전송합니다.\n");
    printf("프로그램을 종료하려면 Ctrl+C를 누르세요.\n\n");
    while (1) {
        if (sendMessage(&loraDevice, "Hello, World!")) {
            messageCount++;
            printf("총 전송 횟수: %lu\n", messageCount);
        }
        Sleep(TRANSMISSION_INTERVAL);  // 전송 간격 대기
    }
    disconnectDevice(&loraDevice);
    return 0;
}
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#define MAX_BUFFER_SIZE 256
#define MAX_COM_PORTS 32
#define DEFAULT_BAUDRATE CBR_9600
#define PORT_CHECK_INTERVAL 2000
#define AT_RESPONSE_TIMEOUT 1000
typedef struct {
    HANDLE hSerial;
    char portName[10];
    bool isConnected;
} LoRaDevice;
bool isLoRaDevice(HANDLE hSerial) {
    const char* testCommand = "AT\r\n";
    char buffer[MAX_BUFFER_SIZE];
    DWORD bytesWritten, bytesRead;
    // AT 명령어 전송
    if (!WriteFile(hSerial, testCommand, strlen(testCommand), &bytesWritten, NULL)) {
        printf("Error: AT 명령어 전송 실패\n");
        return false;
    }
    // 응답 대기
    Sleep(AT_RESPONSE_TIMEOUT);
    if (ReadFile(hSerial, buffer, MAX_BUFFER_SIZE - 1, &bytesRead, NULL)) {
        buffer[bytesRead] = '\0';
        // "OK" 응답 확인
        if (strstr(buffer, "OK") != NULL) {
            printf("LoRa 장치 확인됨\n");
            return true;
        }
    }
    printf("Error: LoRa 장치가 아니거나 응답이 없습니다\n");
    return false;
}
bool findAvailableComPorts(char** comPorts, int* numPorts) {
    HKEY hKey;
    char keyPath[] = "HARDWARE\\DEVICEMAP\\SERIALCOMM";
    *numPorts = 0;
    // 레지스트리 키 열기
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS) {
        printf("Error: 레지스트리 키를 열 수 없습니다\n");
        return false;
    }
    char valueName[MAX_BUFFER_SIZE];
    char valueData[MAX_BUFFER_SIZE];
    DWORD valueSize;
    DWORD valueNameSize;
    DWORD type;
    DWORD index = 0;
    // 레지스트리에서 COM 포트 열거
    while (*numPorts < MAX_COM_PORTS) {
        valueSize = MAX_BUFFER_SIZE;
        valueNameSize = MAX_BUFFER_SIZE;
        if (RegEnumValue(hKey, index++, valueName, &valueNameSize, NULL, &type, 
                        (LPBYTE)valueData, &valueSize) != ERROR_SUCCESS) {
            break;
        }
        if (type == REG_SZ) {
            comPorts[*numPorts] = (char*)malloc(valueSize);
            strcpy(comPorts[*numPorts], valueData);
            (*numPorts)++;
        }
    }
    RegCloseKey(hKey);
    return *numPorts > 0;
}
// COM 포트 선택 함수
bool selectComPort(char* selectedPort) {
    char* comPorts[MAX_COM_PORTS];
    int numPorts;
    if (!findAvailableComPorts(comPorts, &numPorts)) {
        printf("사용 가능한 COM 포트를 찾을 수 없습니다\n");
        return false;
    }
    printf("\n=== 사용 가능한 COM 포트 목록 ===\n");
    for (int i = 0; i < numPorts; i++) {
        printf("%d: %s\n", i + 1, comPorts[i]);
    }
    if (numPorts == 1) {
        strcpy(selectedPort, comPorts[0]);
        printf("\n단일 COM 포트 발견. %s 선택됨\n", selectedPort);
    } else {
        int choice;
        printf("\n포트를 선택하세요 (1-%d): ", numPorts);
        scanf("%d", &choice);
        if (choice < 1 || choice > numPorts) {
            printf("잘못된 선택입니다\n");
            return false;
        }
        strcpy(selectedPort, comPorts[choice - 1]);
    }
    // 메모리 해제
    for (int i = 0; i < numPorts; i++) {
        free(comPorts[i]);
    }
    return true;
}
bool initializeSerialPort(LoRaDevice* device, const char* portName) {
    sprintf(device->portName, "\\\\.\\%s", portName);
    device->hSerial = CreateFile(device->portName,
                                GENERIC_READ | GENERIC_WRITE,
                                0,
                                0,
                                OPEN_EXISTING,
                                FILE_ATTRIBUTE_NORMAL,
                                0);
    if (device->hSerial == INVALID_HANDLE_VALUE) {
        printf("Error: 포트를 열 수 없습니다 %s\n", portName);
        return false;
    }
    DCB dcbSerialParams = {0};
    dcbSerialParams.DCBlength = sizeof(dcbSerialParams);
    if (!GetCommState(device->hSerial, &dcbSerialParams)) {
        printf("Error: 현재 DCB 설정을 가져올 수 없습니다\n");
        CloseHandle(device->hSerial);
        return false;
    }
    dcbSerialParams.BaudRate = DEFAULT_BAUDRATE;
    dcbSerialParams.ByteSize = 8;
    dcbSerialParams.StopBits = ONESTOPBIT;
    dcbSerialParams.Parity = NOPARITY;
    if (!SetCommState(device->hSerial, &dcbSerialParams)) {
        printf("Error: DCB 설정을 적용할 수 없습니다\n");
        CloseHandle(device->hSerial);
        return false;
    }
    COMMTIMEOUTS timeouts = {0};
    timeouts.ReadIntervalTimeout = 50;
    timeouts.ReadTotalTimeoutConstant = 50;
    timeouts.ReadTotalTimeoutMultiplier = 10;
    timeouts.WriteTotalTimeoutConstant = 50;
    timeouts.WriteTotalTimeoutMultiplier = 10;
    if (!SetCommTimeouts(device->hSerial, &timeouts)) {
        printf("Error: 타임아웃 설정을 적용할 수 없습니다\n");
        CloseHandle(device->hSerial);
        return false;
    }
    // LoRa 장치 확인 추가
    if (!isLoRaDevice(device->hSerial)) {
        CloseHandle(device->hSerial);
        return false;
    }
    device->isConnected = true;
    return true;
}
bool initializeLoRa(LoRaDevice* device) {
    const char* initCommands[] = {
        "AT+MODE=LWOTAA\r\n",
        "AT+JOIN=1\r\n",
        "AT+DR=0\r\n",
        "AT+CH=0,920.9\r\n",
        "AT+POWER=20\r\n",
        "AT+SF=12\r\n",
        "AT+BW=125\r\n",
        "AT+CR=4/5\r\n",
        "AT+PL=1\r\n",
        "AT+CRC=1\r\n",
        "AT+IQ=1\r\n",
        "AT+SYNC=34\r\n"
    };
    DWORD bytesWritten;
    char buffer[MAX_BUFFER_SIZE];
    for (int i = 0; i < sizeof(initCommands) / sizeof(initCommands[0]); i++) {
        if (!WriteFile(device->hSerial, initCommands[i], strlen(initCommands[i]), &bytesWritten, NULL)) {
            printf("Error: LoRa 초기화 명령어 전송 실패\n");
            return false;
        }
        Sleep(1000);
        DWORD bytesRead;
        if (ReadFile(device->hSerial, buffer, MAX_BUFFER_SIZE - 1, &bytesRead, NULL)) {
            buffer[bytesRead] = '\0';
            printf("응답: %s\n", buffer);
        }
    }
    return true;
}
bool receiveMessage(LoRaDevice* device) {
    if (!device->isConnected) {
        printf("Error: 장치가 연결되어 있지 않습니다\n");
        return false;
    }
    char buffer[MAX_BUFFER_SIZE];
    DWORD bytesRead;
    if (ReadFile(device->hSerial, buffer, MAX_BUFFER_SIZE - 1, &bytesRead, NULL)) {
        if (bytesRead > 0) {
            buffer[bytesRead] = '\0';
            printf("수신된 메시지: %s\n", buffer);
            return true;
        }
    }
    return false;
}
void disconnectDevice(LoRaDevice* device) {
    if (device->isConnected) {
        CloseHandle(device->hSerial);
        device->isConnected = false;
        printf("장치 연결이 해제되었습니다\n");
    }
}
bool waitForComPort(LoRaDevice* device) {
    printf("사용 가능한 COM 포트를 찾을 때까지 대기중...\n");
    while (1) {
        char portName[10];
        if (selectComPort(portName)) {
            printf("\nCOM 포트 발견: %s\n", portName);
            printf("포트 초기화 및 LoRa 장치 확인 중...\n");
            // 시리얼 포트 초기화 및 LoRa 장치 확인
            if (initializeSerialPort(device, portName)) {
                printf("시리얼 포트 연결 성공 (LoRa 장치 확인됨)\n");
                return true;
            }
            printf("해당 포트에서 LoRa 장치를 찾을 수 없습니다. 다른 포트를 확인합니다.\n");
        }
        printf(".");
        fflush(stdout);
        Sleep(PORT_CHECK_INTERVAL);
    }
    return false;
}
int main() {
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);
    LoRaDevice loraDevice = {0};
    char portName[10];
    DWORD messageCount = 0;
    if (!waitForComPort(&loraDevice)) {
        printf("프로그램을 종료합니다\n");
        return 1;
    }
    printf("시리얼 포트 연결 성공\n");
    if (!initializeLoRa(&loraDevice)) {
        printf("LoRa 초기화 실패\n");
        disconnectDevice(&loraDevice);
        return 1;
    }
    printf("LoRa 초기화 완료\n");
    printf("\n=== LoRa 수신 프로그램 시작 ===\n");
    printf("메시지 수신 대기 중...\n");
    printf("프로그램을 종료하려면 Ctrl+C를 누르세요.\n\n");
    while (1) {
        if (receiveMessage(&loraDevice)) {
            messageCount++;
            printf("총 수신 횟수: %lu\n", messageCount);
        }
        Sleep(10);  // CPU 부하 감소를 위한 짧은 대기
    }
    disconnectDevice(&loraDevice);
    return 0;
}

LoRaWAN 송신 및 수신 코드

댓글