[ubuntu] MySQL 활용 IoT 데이터 제어 실습

🤖 실습 목표

이전 채팅 서버, 채팅 클라이언트 프로그램에 이어 IoT 서버, 클라이언트 실습을 진행하였습니다.
채팅 서버, 채팅 클라이언트 내용 -> https://toby12.tistory.com/53

1. iot_server, iot_client 프로그램 작성 
2. 프로그램 빌드  
3. 센서, 디바이스 데이터 베이스 구축
4. 클라이언트 -> 서버 센서 데이터 조회 요청 및 확인
5. 클라이언트 -> 서버 디바이스 설정 업데이트 요청 및 확인

🤖 상세 기능

서버 

1. 소켓 및 스레드 초기화:
   • 서버 소켓 생성 및 초기화
   • 클라이언트의 연결을 처리하는 스레드를 생성
2. 클라이언트 관리:
   • 최대 32개의 클라이언트를 관리할 수 있는 배열과 해당 클라이언트 수를 추적하는 변수 설정
   • 클라이언트의 ID 및 비밀번호를 미리 등록된 정보와 비교하여 인증
3. 클라이언트 연결:
   • 클라이언트가 서버에 접속하면 스레드를 생성하여 클라이언트와 통신을 담당
4. MySQL 연동:
   • MySQL 데이터베이스에 연결하고 클라이언트의 데이터를 조회 및 업데이트
   • "sensor" 및 "device" 테이블에서 데이터를 가져와 클라이언트에게 전송
5. 클라이언트 간 메시지 전송:
   • 클라이언트 간 메시지를 주고받을 수 있는 기능 구현
   • 특정 클라이언트에게 메시지를 전송할 수 있음
   • 클라이언트가 데이터를 요청하면 해당 데이터를 조회하여 전송
6. 데이터 업데이트:
   • 클라이언트가 "SET DEVICE" 메시지를 보내면 MySQL 데이터베이스에서 해당 디바이스 값을 업데이트
7. 뮤텍스 사용:
   • 뮤텍스를 사용하여 동시에 여러 클라이언트가 서버에 접근하는 것을 제어.

클라이언트

1. 소켓 및 스레드 초기화:
   • 서버에 접속하기 위해 소켓을 생성하고 초기화.
2. 연결 및 로그인:
   • 서버에 접속한 후, 미리 지정된 ID와 비밀번호를 사용하여 로그인.
3. 메시지 송수신:
   • 사용자가 표준 입력을 통해 메시지를 입력하면 서버로 전송.
   • 서버로부터 수신한 메시지를 출력.
4. 스레드 생성:
   • 메시지 전송 및 수신을 병렬로 처리하기 위해 각각의 기능을 수행하는 두 개의 스레드 생성.
5. 'quit' 명령어 처리:
   • 사용자가 'quit'을 입력하면 클라이언트가 종료되도록 설정.
6. 메시지 포맷 처리:
   • 입력된 메시지를 서버에 전송하기 전에 포맷에 맞게 가공.
7. 비밀번호 전송:
   • 클라이언트가 서버에 연결되면 먼저 비밀번호를 전송.

🤖 실습 결과

iot client 프로그램 작성

1. iot_server.c
   

   #include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   #include <string.h>
   #include <arpa/inet.h>
   #include <sys/types.h>
   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <pthread.h>
   #include <sys/stat.h>
   #include <fcntl.h>
   #include <dirent.h>
   #include <sys/time.h>
   #include <time.h>
   #include <errno.h>
   #include <mysql/mysql.h>
   #include <ctype.h>
   
   #define BUF_SIZE 200
   #define MAX_CLNT 32
   #define ID_SIZE 10
   #define ARR_CNT 5
   #define DEBUG
   
   // 메시지 정보 구조체
   typedef struct {
     int fd;         // 파일 식별자
     char *from;     // 보낸 사람 ID
     char *to;       // 받는 사람 ID
     char *msg;      // 메시지 내용
     int len;        // 메시지 길이
     int is_sent;    // 전송 여부 플래그
   } MSG_INFO;
   
   // 클라이언트 정보 구조체
   typedef struct {
     int index;      // 클라이언트 인덱스
     int fd;         // 파일 식별자
     char ip[20];    // 클라이언트 IP 주소
     char id[ID_SIZE];  // 클라이언트 ID
     char pw[ID_SIZE];  // 클라이언트 비밀번호
   } CLIENT_INFO;
   
   void *clnt_connection(void *arg); // 클라이언트 연결 처리 함수
   void send_msg(MSG_INFO *msg_info, CLIENT_INFO *first_client_info); // 메시지 전송 함수
   void error_handling(char *msg); // 오류 처리 함수
   void log_file(char *msgstr); // 로그 파일 작성 함수
   void init_mysql(); // MySQL 초기화 함수
   void send_data_to_client(int client_fd, char *name, char *request_type); // 클라이언트에 데이터 전송 함수
   void find_data(int client_fd, char *name, char *request_type); // 데이터 찾기 함수
   
   char *trim(char *str); // 문자열 양 끝의 공백 제거 함수
   int clnt_cnt = 0;  // 현재 연결된 클라이언트 수
   pthread_mutex_t mutx;  // 뮤텍스 선언
   MYSQL *conn;  // MySQL 연결 객체
   
   int main(int argc, char *argv[]) {
     int serv_sock, clnt_sock;
     struct sockaddr_in serv_adr, clnt_adr;
     int clnt_adr_sz;
     int sock_option = 1;
     pthread_t t_id[MAX_CLNT] = {0};
     int str_len = 0;
     int i;
     char idpasswd[(ID_SIZE * 2) + 3];
     char *pToken;
     char *pArray[ARR_CNT] = {0};
     char msg[BUF_SIZE];
   
     // 초기 클라이언트 정보 배열
     CLIENT_INFO client_info[MAX_CLNT] = {
         {0, -1, "", "KHJ_LIN", "PASSWD"},
         {0, -1, "", "KHJ_SQL", "PASSWD"},
         {0, -1, "", "3", "PASSWD"},
         {0, -1, "", "32", "PASSWD"}};
   
     // 포트 번호를 매개변수로 받지 않았을 시 종료 
     if (argc != 2) {
       printf("Usage : %s <port>\n", argv[0]);
       exit(1);
     }
     fputs("IoT Server Start!!\n", stdout);
     init_mysql(); // MySQL 초기화
   
     // 뮤텍스 초기화
     if (pthread_mutex_init(&mutx, NULL))
       error_handling("mutex init error");
   
     // 소켓 생성
     serv_sock = socket(PF_INET, SOCK_STREAM, 0);
   
     // 서버 주소 구조체 초기화
     memset(&serv_adr, 0, sizeof(serv_adr));
     serv_adr.sin_family = AF_INET;
     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
     serv_adr.sin_port = htons(atoi(argv[1]));
   
     // 소켓 옵션 설정
     setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void *)&sock_option,
                sizeof(sock_option));
   
     // 바인딩 처리
     if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
       error_handling("bind() error");
   
     // 리스닝 처리
     if (listen(serv_sock, 5) == -1)
       error_handling("listen() error");
   
     // 클라이언트 연결 대기 및 처리
     while (1) {
       clnt_adr_sz = sizeof(clnt_adr);
       clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
   
       // 클라이언트 수가 최대 클라이언트 수를 초과하면 연결 거부
       if (clnt_cnt >= MAX_CLNT) {
         printf("socket full\n");
         shutdown(clnt_sock, SHUT_WR);
         continue;
       } else if (clnt_sock < 0) {
         perror("accept()");
         continue;
       }
   
       // 클라이언트로부터 ID 및 비밀번호 수신
       str_len = read(clnt_sock, idpasswd, sizeof(idpasswd));
       idpasswd[str_len] = '\0';
   
       // ID 및 비밀번호 처리
       if (str_len > 0) {
         i = 0;
         pToken = strtok(idpasswd, "[:]");
         while (pToken != NULL) {
           pArray[i] = pToken;
           if (i++ >= ARR_CNT)
             break;
           pToken = strtok(NULL, "[:]");
         }
         // 등록된 클라이언트 정보에서 ID와 비밀번호 일치 여부 확인
         for (i = 0; i < MAX_CLNT; i++) {
           if (!strcmp(client_info[i].id, pArray[0])) {
             if (client_info[i].fd != -1) {
               // 이미 로그인한 경우
               sprintf(msg, "[%s] Already logged!\n", pArray[0]);
               write(clnt_sock, msg, strlen(msg));
               log_file(msg);
               shutdown(clnt_sock, SHUT_WR);
               // MCU 클라이언트의 경우 기존 연결 끊기
               shutdown(client_info[i].fd, SHUT_WR);
               client_info[i].fd = -1;
               break;
             }
             // ID와 비밀번호 일치 시 클라이언트 정보 업데이트
             if (!strcmp(client_info[i].pw, pArray[1])) {
               strcpy(client_info[i].ip, inet_ntoa(clnt_adr.sin_addr));
               pthread_mutex_lock(&mutx);
               client_info[i].index = i;
               client_info[i].fd = clnt_sock;
               clnt_cnt++;
               pthread_mutex_unlock(&mutx);
               sprintf(msg, "[%s] New connected! (ip:%s,fd:%d,sockcnt:%d)\n",
                       pArray[0], inet_ntoa(clnt_adr.sin_addr), clnt_sock, clnt_cnt);
               log_file(msg);
               write(clnt_sock, msg, strlen(msg));
               // 클라이언트 연결에 대한 스레드 생성 및 분리
               pthread_create(t_id + i, NULL, clnt_connection,
                              (void *)(client_info + i));
               pthread_detach(t_id[i]);
               break;
             }}}
         // 등록된 클라이언트가 아닌 경우 연결 거부
         if (i == MAX_CLNT) {
           sprintf(msg, "[%s] Authentication Error!\n", pArray[0]);
           write(clnt_sock, msg, strlen(msg));
           log_file(msg);
           shutdown(clnt_sock, SHUT_WR);
         }
       } else
         shutdown(clnt_sock, SHUT_WR);
     }
     return 0;
   }
   // MySQL 초기화 함수
   void init_mysql() {
     conn = mysql_init(NULL);
     if (conn == NULL) {
       fprintf(stderr, "mysql_init() failed\n");
       exit(1);
     } else if (mysql_real_connect(conn, "127.0.0.1", "iot", "pwiot", "iotdb", 0,
                                  NULL, 0) == NULL) {
       fprintf(stderr, "mysql_real_connect() failed\n");
       mysql_close(conn);
       exit(1);
     } else {
       fputs("MYSQL Start!!\n", stdout);
     }}
   // 클라이언트의 데이터 조회
   void find_data(int client_fd, char *name, char *request_type) {
     MYSQL_RES *result;
     MYSQL_ROW row;
     char query[BUF_SIZE];
     char data_info[BUF_SIZE];
   
     // MySQL 데이터베이스에서 데이터 가져오기
     if (strcmp(request_type, "[ALLMSG]GET SENSOR") == 0) {
       sprintf(query,
               "SELECT illu, temp, humi, date, time FROM sensor WHERE name='%s' "
               "ORDER BY id DESC LIMIT 1",
               name);
       if (mysql_query(conn, query)) {
         fprintf(stderr, "SELECT query failed: %s\n", mysql_error(conn));
         return;
       }
       result = mysql_store_result(conn);
       if (result == NULL) {
         fprintf(stderr, "mysql_store_result() failed\n");
         return;
       }
       row = mysql_fetch_row(result);
       if (row != NULL) {
         int illu = atoi(row[0]);
         int temp = atoi(row[1]);
         int humi = atoi(row[2]);
         char date[BUF_SIZE];
         char time[BUF_SIZE];
         strncpy(date, row[3], BUF_SIZE);
         strncpy(time, row[4], BUF_SIZE);
         size_t remaining_space = BUF_SIZE - 1;
         remaining_space -= snprintf(
             data_info, remaining_space,
             "[SENSOR_DATA] %s: Illuminance=%d, Temperature=%d, Humidity=%d, "
             "Date=%s, Time=%s\n",
             name, illu, temp, humi, date, time);
       }
       mysql_free_result(result);
     } else if (strcmp(request_type, "[ALLMSG]GET DEVICE") == 0) {
       sprintf(query,
               "SELECT value, date, time FROM device WHERE name='%s' ORDER BY id "
               "DESC LIMIT 1",
               name);
       if (mysql_query(conn, query)) {
         fprintf(stderr, "SELECT query failed: %s\n", mysql_error(conn));
         return;   
          }
          // MySQL조회 결과를 저장하기 위한 포인터 변수
          result = mysql_store_result(conn);
   	// 결과가 없거나 오류가 발생한 경우 종료
           if (result == NULL) {
               fprintf(stderr, "mysql_store_result() failed\n");
               return;
           }
   	// 결과를 행으로 저장
           row = mysql_fetch_row(result);
   
   	// 가져온 행이 존재하는 경우 
           if (row != NULL) {
           // 행에서 첫 번째 열 값을 정수로 변환
               int value = atoi(row[0]);
           // 행에서 두 번째, 세 번째 열 값을 문자열로 복사
               char date[BUF_SIZE];
               char time[BUF_SIZE];
               strncpy(date, row[1], BUF_SIZE);
               strncpy(time, row[2], BUF_SIZE);
   	// 데이터 정보 문자열을 저장할 버퍼 및 남은 공간 계산
               size_t remaining_space = BUF_SIZE - 1;
           // 데이터 정보를 문자열로 변환하여 버퍼에 저장
               remaining_space -= snprintf(data_info, remaining_space, "[DEVICE_INFO] %s: Value=%d, Date=%s, Time=%s\n", name, value, date, time);
           }
           mysql_free_result(result);
       } else {
           fprintf(stderr, "Invalid request type: %s\n", request_type);
           return;
       }
       // 데이터 정보를 클라이언트에 전송
       write(client_fd, data_info, strlen(data_info));
   }
   
   // 클라이언트에게 데이터 전송
   void send_data_to_client(int client_fd, char *name, char *request_type) {
       if (strcmp(request_type, "[ALLMSG]GET SENSOR") == 0) {
    	find_data(client_fd, name,request_type);
       } else if (strcmp(request_type, "[ALLMSG]GET DEVICE") == 0) {
   	find_data(client_fd, name,request_type);
       } else {
           fprintf(stderr, "Invalid request type: %s\n", request_type);
       }}
   // 클라이언트 쓰레드 함수
   void *clnt_connection(void *arg) {
       // 전달받은 인자를 클라이언트 정보 구조체로 형변환
       CLIENT_INFO *client_info = (CLIENT_INFO *)arg;
   
       // 변수 및 배열 초기화
       int str_len = 0;
       int index = client_info->index;
       char msg[BUF_SIZE];
       char to_msg[MAX_CLNT * ID_SIZE + 1];
       int i = 0;
       char *pToken;
       char *pArray[ARR_CNT] = {0};
       char strBuff[130] = {0};
       char sql_cmd[BUF_SIZE]; // 쿼리 명령문 저장용 배열
       int res;                // 쿼리 실행 결과 저장용 변수
       int *sock;              // 소켓 정보 저장용 변수
   
       // 메시지 정보 및 첫 번째 클라이언트 정보 구조체 초기화
       MSG_INFO msg_info;
       CLIENT_INFO *first_client_info;
       first_client_info = (CLIENT_INFO *)((void *)client_info - (void *)(sizeof(CLIENT_INFO) * index));
   
       // 클라이언트로부터 메시지를 계속 읽어오는 루프
       while (1) {
           // 버퍼 초기화 및 클라이언트로부터 메시지 읽기
           memset(msg, 0x0, sizeof(msg));
           str_len = read(client_info->fd, msg, sizeof(msg) - 1);
   
           // 메시지 길이가 0 이하인 경우 연결 종료
           if (str_len <= 0)
               break;
   
           // 문자열 끝에 null 추가
           msg[str_len] = '\0';
   
           // 받은 메시지 출력
           printf("%s: %s", client_info->id, msg);
   
           // [ALLMSG]GET SENSOR 메시지인 경우 SENSOR 데이터 전송
           if (strcmp(trim(msg), "[ALLMSG]GET SENSOR") == 0) {
               send_data_to_client(client_info->fd, client_info->id, "[ALLMSG]GET SENSOR");
           }
           // [ALLMSG]GET DEVICE 메시지인 경우 DEVICE 데이터 전송
           else if (strcmp(trim(msg), "[ALLMSG]GET DEVICE") == 0) {
               send_data_to_client(client_info->fd, client_info->id, "[ALLMSG]GET DEVICE");
           }
           // [ALLMSG]SET DEVICE 메시지인 경우 값 업데이트
           else if (strstr(msg, "[ALLMSG]SET DEVICE")) {
               // SET DEVICE 메시지 파싱
               int value;
               char device[20];
   
               // 변수 및 배열 초기화
               memset(sql_cmd, 0, sizeof(sql_cmd));
               res = 0;
   
               // SET DEVICE 명령 메시지 파싱
               if (sscanf(msg, "[ALLMSG]SET DEVICE %d", &value) == 1) {
                   // MySQL 데이터베이스 업데이트를 위한 SQL 명령어 생성
                   sprintf(sql_cmd, "UPDATE device SET value=%d, date=CURDATE(), time=CURTIME() WHERE name='%s'", value, client_info->id);
   
                   // SQL 명령어 실행
                   int res = mysql_query(conn, sql_cmd);
   
                   // 업데이트 성공한 경우
                   if (!res) {
                       printf("[%s] 디바이스 값이 %d로 업데이트되었습니다\n", client_info->id, value);
                   }
                   // 업데이트 실패한 경우
                   else {
                       fprintf(stderr, "디바이스 값 업데이트 오류: %s\n", mysql_error(conn));
                   }}
               // 잘못된 SET 명령 형식인 경우
               else {
                   fprintf(stderr, "오류: 잘못된 SET 명령 형식\n");
               }}
           // 메시지를 [:]를 기준으로 분리하여 배열에 저장
           pToken = strtok(msg, "[:]");
           i = 0;
           while (pToken != NULL) {
               pArray[i] = pToken;
               if (i++ >= ARR_CNT)
                   break;
               pToken = strtok(NULL, "[:]");
           }
           // 메시지 정보 구조체에 정보 저장
           msg_info.fd = client_info->fd;
           msg_info.from = client_info->id;
           msg_info.to = pArray[0];
           sprintf(to_msg, "[%s]%s", msg_info.from, pArray[1]);
           msg_info.msg = to_msg;
           msg_info.len = strlen(to_msg);
           // 메시지 발신 여부 초기화
           msg_info.is_sent = 0;
   
           // 로그 파일에 메시지 기록
           log_file(strBuff);
           // send_msg(&msg_info, first_client_info);
       }
   
       // 클라이언트 소켓 종료
       close(client_info->fd);
   
       // 연결 종료 메시지 기록
       sprintf(strBuff, "Disconnect ID:%s (ip:%s,fd:%d,sockcnt:%d)\n", client_info->id, client_info->ip, client_info->fd, clnt_cnt - 1);
       log_file(strBuff);
   
       // 뮤텍스를 사용하여 클라이언트 수 갱신
       pthread_mutex_lock(&mutx);
       clnt_cnt--;
       client_info->fd = -1;
       pthread_mutex_unlock(&mutx);
   
       // 쓰레드 종료
       return 0;
   }
   // 문자열 양 끝의 공백을 제거하는 함수
   char* trim(char* str) {
       char* end;
       // 문자열 시작의 공백 제거
       while (isspace(*str)) str++;
       // 빈 문자열인 경우 문자열 끝의 공백 제거
       if (*str == 0)
           return str;
       end = str + strlen(str) - 1;
       while (end > str && isspace(*end)) end--;
       // NULL 추가하여 문자열 종료
       *(end + 1) = 0;
       return str;
   }
   // 메시지 전송 함수
   void send_msg(MSG_INFO *msg_info, CLIENT_INFO *first_client_info) {
       int i = 0;
       // 전체 또는 특정 클라이언트에 메시지 전송
       if (!strcmp(msg_info->to, "[ALLMSG]") || !strcmp(msg_info->to, "[IDLIST]")) {
           for (i = 0; i < MAX_CLNT; i++) {
               if ((first_client_info + i)->fd != -1) {
                   write((first_client_info + i)->fd, msg_info->msg, msg_info->len);
               }}
           // 다음 메시지를 위해 is_sent를 0으로 초기화
           if ((msg_info->fd != -1) && (msg_info->is_sent == 0)) {
               msg_info->is_sent = 1;
           }
           return;
       }
       // 특정 클라이언트에 메시지 전송
       else {
           if ((msg_info->fd != -1) && (msg_info->is_sent == 0)) {
               write(msg_info->fd, msg_info->msg, msg_info->len);
               msg_info->is_sent = 1;
           }}}
   // 에러 처리 함수
   void error_handling(char *msg) {
       fputs(msg, stderr);
       fputc('\n', stderr);
       exit(1);
   }
   // 로그 파일에 메시지 기록 함수
   void log_file(char *msgstr) {
       fputs(msgstr, stdout);
   }

2. iot_client_sensor.c
   

   #include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   #include <string.h>
   #include <arpa/inet.h>
   #include <sys/types.h>
   #include <sys/socket.h>
   #include <pthread.h>
   #include <signal.h>
   
   #define BUF_SIZE 100
   #define NAME_SIZE 20
   #define ARR_CNT 5
   
   // 메시지를 전송하는 스레드의 역할
   void* send_msg(void* arg);
   
   // 메시지를 수신하는 스레드의 역할
   void* recv_msg(void* arg);
   
   // 에러 메시지를 출력하고 프로그램을 종료하는 함수
   void error_handling(char* msg);
   
   // 사용자의 이름과 메시지를 저장하는 전역 변수
   char name[NAME_SIZE] = "[Default]";
   char msg[BUF_SIZE];
   
   int main(int argc, char* argv[])
   {
       int sock;
       struct sockaddr_in serv_addr;
       pthread_t snd_thread, rcv_thread;
       void* thread_return;
   
       // 프로그램 실행 시 IP, 포트, 이름을 전달하지 않았을 경우 사용법 출력
       if (argc != 4) {
           printf("Usage : %s <IP> <port> <name>\n", argv[0]);
           exit(1);
       }
       // 전달받은 이름을 전역 변수에 저장
       sprintf(name, "%s", argv[3]);
   
       // 소켓 생성
       sock = socket(PF_INET, SOCK_STREAM, 0);
       if (sock == -1)
           error_handling("socket() error");
   
       // 서버 주소 구조체 초기화
       memset(&serv_addr, 0, sizeof(serv_addr));
       serv_addr.sin_family = AF_INET;
       serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
       serv_addr.sin_port = htons(atoi(argv[2]));
   
       // 서버에 연결
       if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1)
           error_handling("connect() error");
   
       // 비밀번호 메시지를 생성하여 서버에 전송
       sprintf(msg, "[%s:PASSWD]", name);
       write(sock, msg, strlen(msg));
   
       // 메시지 전송 및 수신을 위한 스레드 생성
       pthread_create(&rcv_thread, NULL, recv_msg, (void*)&sock);
       pthread_create(&snd_thread, NULL, send_msg, (void*)&sock);
   
       // 스레드 종료를 기다림
       pthread_join(snd_thread, &thread_return);
       pthread_join(rcv_thread, &thread_return);
   
       // 소켓 종료
       close(sock);
       return 0;
   }
   // 메시지를 전송하는 스레드의 역할
   void* send_msg(void* arg)
   {
       int* sock = (int*)arg;
       int str_len;
       char name_msg[NAME_SIZE + BUF_SIZE + 2];
   
       while (1) {
           // 메시지 초기화
           memset(msg, 0, sizeof(msg));
           name_msg[0] = '\0';
   
           // 표준 입력(STDIN)의 상태를 확인하고 10ms마다 대기
           fd_set read_fds;
           FD_ZERO(&read_fds);
           FD_SET(STDIN_FILENO, &read_fds);
   
           struct timeval tv;
           tv.tv_sec = 0;
           tv.tv_usec = 10000; // 10ms로 설정
   
           // 표준 입력 상태 변경을 기다림
           if (select(STDIN_FILENO + 1, &read_fds, NULL, NULL, &tv) > 0) {
               // 표준 입력으로부터 메시지를 읽어옴
               if (FD_ISSET(STDIN_FILENO, &read_fds)) {
                   fgets(msg, BUF_SIZE, stdin);
                   
                   // 'quit' 메시지를 입력하면 소켓 종료
                   if (!strncmp(msg, "quit\n", 5)) {
                       *sock = -1;
                       return NULL;
                   }
                   // 메시지가 '['로 시작하지 않는 경우 '[ALLMSG]' 태그를 추가
                   else if (msg[0] != '[') {
                       strcat(name_msg, "[ALLMSG]");
                       strcat(name_msg, msg);
                   }
                   // 메시지가 '['로 시작하는 경우 그대로 사용
                   else {
                       strcpy(name_msg, msg);
                   }
                   // 서버로 메시지 전송
                   if (write(*sock, name_msg, strlen(name_msg)) <= 0) {
                       *sock = -1;
                       return NULL;
                   }}}}}
   // 메시지를 수신하는 스레드의 역할
   void* recv_msg(void* arg)
   {
       int* sock = (int*)arg;
       char name_msg[NAME_SIZE + BUF_SIZE + 1];
       int str_len;
       
       while (1) {
           // 메시지 초기화
           memset(name_msg, 0x0, sizeof(name_msg));
           // 서버로부터 메시지 수신
           str_len = read(*sock, name_msg, NAME_SIZE + BUF_SIZE);
           if (str_len <= 0) {
               // 에러가 발생하거나 연결이 끊긴 경우 소켓 종료
               *sock = -1;
               return NULL;
           }
           name_msg[str_len] = 0;
           // 수신된 메시지 출력
           printf("%s", name_msg);
       }}
   // 에러 메시지 출력 및 프로그램 종료
   void error_handling(char* msg)
   {
       fputs(msg, stderr);
       fputc('\n', stderr);
       exit(1);
   }

프로그램 빌드

1. iot_server, iot_client 빌드 결과

iot_server, iot_client 빌드 결과

 

데이터 베이스 생성 및 데이터 삽입 

데이터베이스 관련 내용은 해당 카테고리에 정리하였습니다. -> https://toby12.tistory.com/category/database

1. iotdb 생성

create database iotdb character set utf8;

2. sensor 테이블 생성 

create table sensor (id int not null auto_increment, name varchar(20), date date, time time,
 illu int, temp float, humi float, primary key (id)) default character set=utf8;

 

3. sensor 테이블 데이터 삽입 

insert into sensor (name, date, time, illu, temp, humi) value ("KHJ_SQL", now(),now(), 60, 20, 40);

 

4. device 테이블 생성

create table device (id int not null, name varchar(20), date date, time time,  value int,
 info varchar(20), primary key (id) ) default charset=utf8;

sensor 테이블 조회 결과

서버, 클라이언트 프로그램 실행

1. 서버 프로그램

서버 프로그램 실행 결과

2. 클라이언트 프로그램

클라이언트 프로그램 실행 결과

 

클라이언트 -> 서버 센서 데이터 조회 요청 및 확인

1. GET SENSOR 

서버로부터 받은 MYSQL에 저장된 SENSOR 데이터

2. GET DEIVCE

서버로부터 받은 MYSQL에 저장된 DEVICE 데이터

 

클라이언트 -> 서버 디바이스 설정 업데이트 요청 및 확인

SET Device 9 메세지를 서버에 보내어 해당 사용자의 디바이스정보를 업데이트됨 확인

클라이언트에서 SET DEVICE 9의 값을 받은 후 서버에서 업데이트 진행

클라이언트에서 GET 하여 업데이트됨 확인