Merge branch 'main' into 'main'

Main

See merge request !3

Central_Control_Board/Central_Main.c

+
+#include "JaeYukBookkom.h"
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <pthread.h>
+#include "LCD.c"
+#include "GPIO.c"
+#include "Networking.c"
+#include "PWM.c"
+
+short int Window_Open = 0;
+short int problem_sensing = 0;
+short int user = 0;
+void *Communicating(void *args);
+int ms_handle_sense(void);
+int ms_handle_oper(void);
+int toggle_window(void);
+void *getFromAPI(void *args);
+void *AutoRefrash(void *args);
+struct timeval timeout = {0, 1000};
+pthread_t *mainThread, *APIthread, *TimerThread;
+int main(int argc, char *argv[]){
+    if (argc != 2){
+        printf("Usage : %s <port>\n", argv[0]);
+        exit(1);
+    }
+
+    ServerInit(&serv_sock, atoi(argv[1]));
+    GPIOInit();
+    LCD_init();
+    mainThread = malloc(sizeof(pthread_t));
+    APIthread = malloc(sizeof(pthread_t));
+    TimerThread = malloc(sizeof(pthread_t));
+    if (pthread_create(mainThread, NULL, Communicating, NULL) < 0)
+        perror("main thread create error:");
+    if (pthread_create(APIthread, NULL, getFromAPI, NULL) < 0)
+        perror("API thread create error:");
+    if (pthread_create(TimerThread, NULL, AutoRefrash, NULL) < 0)
+        perror("API thread create error:");
+
+    pthread_join(*mainThread, NULL);
+    pthread_join(*APIthread, NULL);
+    pthread_join(*TimerThread, NULL);
+    free(mainThread);
+    free(APIthread);
+    free(TimerThread);
+    return (0);
+}
+void *Communicating(void *args){
+    int state = 1;
+    int prev_state = 1;
+    while (1){
+        state = GPIORead(BUTTON_IN);
+        if (prev_state == 0 && state == 1) // button polling
+            toggle_window();
+        prev_state = state;
+
+        clients = clients_socket;
+        if (select(max_fd + 1, &clients, NULL, NULL, &timeout)){ // polling with listening clients message
+            if (FD_ISSET(clnt_sock[0], &clients)) // message from sensing board
+                ms_handle_sense();
+            if (FD_ISSET(clnt_sock[1], &clients)) // message from sensing board
+                ms_handle_oper();
+        }
+        usleep(500 * 100);
+    }
+
+    //dispose socket
+    for (int i = 0; i < MAX_CONNECT_BOARD; i++){
+        close(clnt_sock[i]);
+    }
+    close(serv_sock);
+}
+int ms_handle_sense(void){ // message handler from sensing board
+    char input_str[3] = {0};
+    int str_len = read(clnt_sock[0], input_str, sizeof(input_str));
+    if (str_len == -1){
+        error_handling("read() error");
+        return -1;
+    }
+    problem_sensing = atoi(input_str);
+    printf("problem: %d\n");
+    LCD_messaging_error(problem_sensing);
+    if (problem_sensing && !user && problem_sensing != 8)
+        if (Window_Open)
+            toggle_window();
+}
+int ms_handle_oper(void){ // message handler from operation board
+    char input_str[3] = {0};
+    int str_len = read(clnt_sock[1], input_str, sizeof(input_str));
+    if (str_len == -1){
+        error_handling("read() error");
+        return -1;
+    }
+    int danger = atoi(input_str);
+    if (danger){
+        problem_sensing = 8;
+        LCD_messaging_error(problem_sensing);
+        boozerThread = malloc(sizeof(pthread_t));
+        if (pthread_create(boozerThread, NULL, bozzering, NULL) < 0)
+            perror("buzzor thread create error:");
+    }
+}
+int toggle_window(void){
+    printf("Window toggle\n");
+    if (problem_sensing == 8){
+        pthread_cancel(*boozerThread); // boozer off
+        problem_sensing = 0;
+        LCD_messaging_error(problem_sensing);
+        return -1;
+    }
+    else if (problem_sensing && !Window_Open){
+        boozer_Warning();
+        user = 1;
+    }
+    Window_Open = !Window_Open;
+    char output_str[3] = {0};
+    snprintf(output_str, 3, "%d", Window_Open);
+    write(clnt_sock[1], output_str, sizeof(output_str)); // open /close call to operation board
+
+    printf("msg = %s\n", output_str);
+    if (Window_Open)
+        GPIOWrite(BUTTON_LED, HIGH);
+    else{
+        GPIOWrite(BUTTON_LED, LOW);
+        user = 0;
+    }
+        
+}
+void *getFromAPI(void *args){
+    fd_set API_socket, API;
+    struct timeval timeout;
+    timeout.tv_sec = 0;
+    timeout.tv_usec = 1000;
+    FD_ZERO(&API_socket);
+    FD_SET(clnt_sock[2], &API_socket);
+    int max_fd2 = clnt_sock[2];
+    int str_len;
+    char str[50];
+    float temp, hyd;
+    int weatherCode, dust, rainPer;
+    while (1){
+        if (select(max_fd2 + 1, &clients, NULL, NULL, &timeout)){ // polling with listening clients message
+            if (FD_ISSET(clnt_sock[2], &clients)){ // message from sensing board
+                str_len = read(clnt_sock[2], str, sizeof(str));
+                if (str_len == -1){
+                    error_handling("read() error");
+                    continue;
+                }
+                printf("Receive message from Client : %s\n", str);
+
+                char *ptr = strtok(str, " ");
+                printf("temp: %s\n", ptr);
+                temp = atof(ptr);
+                ptr = strtok(NULL, " ");
+                printf("hye: %s\n", ptr);
+                hyd = atof(ptr);
+                ptr = strtok(NULL, " ");
+                printf("wheatherCode: %s\n", ptr);
+                weatherCode = atoi(ptr);
+                ptr = strtok(NULL, " ");
+                printf("dust: %s\n", ptr);
+                dust = atoi(ptr);
+                ptr = strtok(NULL, " ");
+                printf("rainPer: %s\n", ptr);
+                rainPer = atoi(ptr);
+                LCD_weather_prediction(temp, hyd, weatherCode, dust, rainPer);
+                printf("API data received\n");
+            }
+        }
+        usleep(5000000);
+    }
+}
+void *AutoRefrash(void *args){
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    int state = 1, prev_state = 1;
+    printf("refresh sensing start");
+    while (1){
+        state = GPIORead(TIMER_IN);
+        if (prev_state == 0 && state == 1){ // button polling
+            printf("Auto reFrash with 15s\n");
+            if (!Window_Open && !problem_sensing)// when window closed >> op -> cl
+                toggle_window();
+            usleep(15000000); // waiting 15min(alternative: sec) with window open
+            if (problem_sensing != 8 && Window_Open)// if not door interrupt and not user close excuted
+                toggle_window();
+        }
+        prev_state = state;
+        usleep(50000);
+    }
+}
\ No newline at end of file

Central_Control_Board/GPIO.c

+#include "JaeYukBookkom.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+void error_handling(char *message);
+static int GPIOExport(int pin);
+static int GPIOUnexport(int pin);
+static int GPIODirection(int pin, int dir);
+static int GPIORead(int pin);
+static int GPIOWrite(int pin, int value);
+
+int GPIOInit(void){
+    if (-1 == GPIOExport(BUTTON_IN) || -1 == GPIOExport(BUTTON_OUT)|| -1 == GPIOExport(BUTTON_LED)||-1 == GPIOExport(TIMER_IN) || -1 == GPIOExport(TIMER_OUT))
+        return (1);
+    if (-1 == GPIODirection(BUTTON_IN, IN) || -1 == GPIODirection(BUTTON_OUT, OUT) || -1 == GPIODirection(BUTTON_LED, OUT)||-1 == GPIODirection(TIMER_IN, IN) || -1 == GPIODirection(TIMER_OUT, OUT))
+        return (2);
+    if (-1 == GPIOWrite(BUTTON_OUT, 1)||-1 == GPIOWrite(TIMER_OUT, 1))
+        return (3);
+}
+void GPIODispose(void){
+    GPIOUnexport(BUTTON_IN);
+    GPIOUnexport(BUTTON_OUT);
+    GPIOUnexport(BUTTON_LED);
+    GPIOUnexport(TIMER_IN);
+    GPIOUnexport(TIMER_OUT);
+}
+
+static int GPIOExport(int pin){
+    char buffer[BUFFER_MAX];
+    ssize_t bytes_written;
+    int fd;
+
+    fd = open("/sys/class/gpio/export", O_WRONLY);
+    if (-1 == fd)
+    {
+        fprintf(stderr, "Failed to open export for writing!\n");
+        return (-1);
+    }
+
+    bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
+    write(fd, buffer, bytes_written);
+    close(fd);
+    return (0);
+}
+static int GPIOUnexport(int pin){
+    char buffer[BUFFER_MAX];
+    ssize_t bytes_written;
+    int fd;
+
+    fd = open("/sys/class/gpio/unexport", O_WRONLY);
+    if (-1 == fd)
+    {
+        fprintf(stderr, "Failed to open unexport for writing!\n");
+        return (-1);
+    }
+    bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
+    write(fd, buffer, bytes_written);
+    close(fd);
+    return (0);
+}
+static int GPIODirection(int pin, int dir){
+    static const char s_directions_str[] = "in\0out";
+
+    char path[DIRECTION_MAX] = "/sys/class/gpio/gpio%d/direction";
+    int fd;
+
+    snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/direction", pin);
+
+    fd = open(path, O_WRONLY);
+    if (-1 == fd)
+    {
+        fprintf(stderr, "Failed to open gpio direction for writing!\n");
+        return (-1);
+    }
+
+    if (-1 ==
+        write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3))
+    {
+        fprintf(stderr, "Failed to set direction!\n");
+        return (-1);
+    }
+
+    close(fd);
+    return (0);
+}
+static int GPIORead(int pin){
+    char path[VALUE_MAX];
+    char value_str[3];
+    int fd;
+
+    snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
+    fd = open(path, O_RDONLY);
+    if (-1 == fd)
+    {
+        fprintf(stderr, "Failed to open gpio value for reading!\n");
+        return (-1);
+    }
+
+    if (-1 == read(fd, value_str, 3))
+    {
+        fprintf(stderr, "Failed to read value!\n");
+        return (-1);
+    }
+
+    close(fd);
+
+    return (atoi(value_str));
+}
+static int GPIOWrite(int pin, int value){
+    static const char s_values_str[] = "01";
+    char path[VALUE_MAX];
+    int fd;
+
+    snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
+    fd = open(path, O_WRONLY);
+    if (-1 == fd)
+    {
+        fprintf(stderr, "Failed to open gpio value for writing!\n");
+        close(fd);
+        return (-1);
+    }
+
+    if (1 != write(fd, &s_values_str[LOW == value ? 0 : 1], 1))
+    {
+        fprintf(stderr, "Failed to write value!\n");
+        close(fd);
+        return (-1);
+    }
+    close(fd);
+    return (0);
+}

Central_Control_Board/JaeYukBookkom.h

+#ifndef __JaeYukBookkom__
+#define __JaeYukBookkom__
+#define MAX_CONNECT_BOARD 3
+#define IN 0
+#define OUT 1
+#define LOW 0
+#define HIGH 1
+#define BUFFER_MAX 3
+#define DIRECTION_MAX 256
+#define VALUE_MAX 256
+// GPIO PIN Settings
+
+#define BUTTON_LED 26
+#define BUTTON_OUT 19
+#define BUTTON_IN 13
+#define TIMER_OUT 27
+#define TIMER_IN 22
+
+#define SPEAKER 0 // PWM 0
+
+enum WeatherCast
+{
+    Sunny = 0,
+    Cloud,
+    Windy,
+    Rain,
+    Snow
+};
+#endif

Central_Control_Board/LCD.c

+#include "JaeYukBookkom.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/i2c-dev.h>
+#include "LCD.h"
+
+LCDDevice lcd1, lcd2, lcd_error;
+
+int LCD_init(void){
+    LCDDevice **initlist = malloc(LCD_COUNT * sizeof(LCDDevice *));
+    initlist[0] = &lcd1, initlist[1] = &lcd2, initlist[2] = &lcd_error;
+
+    if (LCD_open(&lcd1, 0x23, BUS_NUMBER) < 0 || LCD_open(&lcd2, 0x26, BUS_NUMBER) < 0 || LCD_open(&lcd_error, 0x27, BUS_NUMBER) < 0)
+    {
+        return -1;
+    }
+    for (int i = 0; i < LCD_COUNT; i++)
+    {
+        LCD_write(initlist[i], 0x03, 0);
+        LCD_write(initlist[i], 0x03, 0);
+        LCD_write(initlist[i], 0x03, 0);
+        LCD_write(initlist[i], 0x02, 0);
+        LCD_write(initlist[i], LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE, 0);
+        LCD_write(initlist[i], LCD_DISPLAYCONTROL | LCD_DISPLAYON, 0);
+        LCD_write(initlist[i], LCD_CLEARDISPLAY, 0);
+        LCD_write(initlist[i], LCD_ENTRYMODESET | LCD_ENTRYLEFT, 0);
+        LCD_clear(initlist[i]);
+        LCD_display_string(initlist[i], "S      A      T ", 1);
+        LCD_display_string(initlist[i], "    T     R     ", 2);
+    }
+
+    usleep(5000000);
+    for (int i = 0; i < LCD_COUNT; i++)
+    {
+        LCD_clear(initlist[i]);
+    }
+    free(initlist);
+}
+void LCD_weather_prediction(float temp, float hyd, int weatherCode, int dust, int rainPer){
+    LCD_clear(&lcd1);
+    char str[16];
+    snprintf(str, 16, "%.1f C, %.1f %", temp, hyd);
+    LCD_display_string(&lcd1, str, 1);
+/*
+    Sunny = 0,
+    Cloud,
+    Windy,
+    Rain,
+    Snow
+*/
+    if (weatherCode == Sunny)
+        snprintf(str, 16, "Sunny");
+    else if (weatherCode == Cloud)
+        snprintf(str, 16, "Cloud");
+    else if (weatherCode == Windy)
+        snprintf(str, 16, "Windy");
+    else if (weatherCode == Rain)
+        snprintf(str, 16, "Rain");
+    else if (weatherCode == Snow)
+        snprintf(str, 16, "Snow");
+    LCD_display_string(&lcd1, str, 2);
+    LCD_clear(&lcd2);
+    if(dust > 100)
+        snprintf(str, 16, "dust: BAD(%d)",dust);
+    else
+        snprintf(str, 16, "dust: GOOD(%d)",dust);
+    LCD_display_string(&lcd2, str, 1);
+
+    if(rainPer>60)
+        snprintf(str,16,"!!!!!rainPer: %d",rainPer);
+    else
+        snprintf(str,16,"rainPer : %d",rainPer);
+    LCD_display_string(&lcd2, str, 2);
+}
+void LCD_messaging_error(int errorcode){
+    if (errorcode == 0)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Nothing Problem", 1);
+        LCD_display_string(&lcd_error, "Outdoor is GOOD", 2);
+    }
+    else if (errorcode == 1)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Raining", 1);
+        LCD_display_string(&lcd_error, "Outdoor is BAD", 2);
+    }
+    else if (errorcode == 2)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Gas", 1);
+        LCD_display_string(&lcd_error, "Outdoor is BAD", 2);
+    }
+    else if (errorcode == 3)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Raining, Dust", 1);
+        LCD_display_string(&lcd_error, "Outdoor is BAD", 2);
+    }
+    else if (errorcode == 4)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Noisy", 1);
+        LCD_display_string(&lcd_error, "Outdoor is BAD", 2);
+    }
+    else if (errorcode == 5)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Raining, Noisy", 1);
+        LCD_display_string(&lcd_error, "Outdoor is BAD", 2);
+    }
+    else if (errorcode == 6)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Dust, Noisy", 1);
+        LCD_display_string(&lcd_error, "Outdoor is BAD", 2);
+    }
+    else if (errorcode == 7)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Rain,Dust,Noisy", 1);
+        LCD_display_string(&lcd_error, "Outdoor is BAD", 2);
+    }
+    else if (errorcode == 8)
+    {
+        LCD_clear(&lcd_error);
+        LCD_display_string(&lcd_error, "Danger", 1);
+        LCD_display_string(&lcd_error, "Check Window", 2);
+    }
+}
+int LCD_open(LCDDevice *dev, int addr, int bus){
+    char filename[20];
+    snprintf(filename, 19, "/dev/i2c-%d", bus);
+    dev->file = open(filename, O_RDWR);
+    if (dev->file < 0)
+    {
+        perror("Failed to open the i2c bus");
+        return -1;
+    }
+    dev->addr = addr;
+    dev->bus = bus;
+    if (ioctl(dev->file, I2C_SLAVE, dev->addr) < 0)
+    {
+        perror("Failed to acquire bus access and/or talk to slave");
+        return -1;
+    }
+    return 0;
+}
+void LCDdispose(void){
+    close(lcd1.file);
+    close(lcd2.file);
+    close(lcd_error.file);
+}
+void i2c_write_cmd(LCDDevice *dev, uint8_t cmd){
+    if (write(dev->file, &cmd, 1) != 1)
+        perror("Failed to write command to the i2c bus");
+    usleep(100);
+}
+void LCD_strobe_signal(LCDDevice *dev, uint8_t data){ // strobe signal: notify send data
+    i2c_write_cmd(dev, data | En | LCD_BACKLIGHT);
+    usleep(500);
+    i2c_write_cmd(dev, ((data & ~En) | LCD_BACKLIGHT));
+    usleep(100);
+}
+void LCD_write(LCDDevice *dev, uint8_t cmd, uint8_t mode){
+    i2c_write_cmd(dev, mode | (cmd & 0xF0) | LCD_BACKLIGHT);
+    LCD_strobe_signal(dev, mode | (cmd & 0xF0));
+    i2c_write_cmd(dev, mode | ((cmd << 4) & 0xF0) | LCD_BACKLIGHT);
+    LCD_strobe_signal(dev, mode | ((cmd << 4) & 0xF0));
+}
+void LCD_display_string(LCDDevice *dev, const char *string, int line){
+    if(line == 1) LCD_write(dev, 0x80, 0);
+    else if(line == 2) LCD_write(dev, 0xC0, 0);
+    
+    while (*string){
+        LCD_write(dev, *string++, Rs);
+    }
+}
+void LCD_clear(LCDDevice *dev) //clear display
+{
+    LCD_write(dev, LCD_CLEARDISPLAY, 0);
+    LCD_write(dev, LCD_RETURNHOME, 0);
+}
+

Central_Control_Board/LCD.h

+// LCD Instruction
+#define LCD_CLEARDISPLAY 0x01
+#define LCD_RETURNHOME 0x02
+#define LCD_ENTRYMODESET 0x04
+#define LCD_DISPLAYCONTROL 0x08
+#define LCD_CURSORSHIFT 0x10
+#define LCD_FUNCTIONSET 0x20
+#define LCD_SETCGRAMADDR 0x40
+#define LCD_SETDDRAMADDR 0x80
+
+// Display mode
+#define LCD_ENTRYRIGHT 0x00
+#define LCD_ENTRYLEFT 0x02
+#define LCD_ENTRYSHIFTINCREMENT 0x01
+#define LCD_ENTRYSHIFTDECREMENT 0x00
+
+// Display on/off Control
+#define LCD_DISPLAYON 0x04
+#define LCD_DISPLAYOFF 0x00
+#define LCD_CURSORON 0x02
+#define LCD_CURSOROFF 0x00
+#define LCD_BLINKON 0x01
+#define LCD_BLINKOFF 0x00
+
+// Display Cursor Movement
+#define LCD_DISPLAYMOVE 0x08
+#define LCD_CURSORMOVE 0x00
+#define LCD_MOVERIGHT 0x04
+#define LCD_MOVELEFT 0x00
+
+// Mode Setting
+#define LCD_4BITMODE 0x00
+#define LCD_2LINE 0x08
+#define LCD_5x8DOTS 0x00
+
+// Using BackLight
+#define LCD_BACKLIGHT 0x08
+#define LCD_NOBACKLIGHT 0x00
+
+// GPIO Bit Settings
+#define En 0b00000100 // Enable
+#define Rw 0b00000010 // ReadWrite
+#define Rs 0b00000001 // Register Select
+
+//Number of LCD Setting
+#define LCD_COUNT 3
+// I2C Bus Number Setting
+#define BUS_NUMBER 1
+
+typedef struct {
+    int addr;
+    int bus;
+    int file;
+} LCDDevice;
+
+int LCD_init(void);
+void LCD_weather_prediction(float temp, float hyd, int weatherCode, int dust, int rainPer);
+void LCD_messaging_error(int errorcode);
+int LCD_open(LCDDevice *dev, int addr, int bus);
+void LCDdispose(void);
+void i2c_write_cmd(LCDDevice *dev, uint8_t cmd);
+void LCD_strobe_signal(LCDDevice *dev, uint8_t data);
+void LCD_write(LCDDevice *dev, uint8_t cmd, uint8_t mode);
+void LCD_display_string(LCDDevice *dev, const char *string, int line);
+void LCD_clear(LCDDevice *dev);
\ No newline at end of file

Central_Control_Board/Networking.c

+#include "JaeYukBookkom.h"
+#include <arpa/inet.h>
+#include<stdlib.h>
+#include<stdio.h>
+#include<string.h>
+void ServerInit(int *serv_sock, int port);
+int max(int *list, int length);
+void error_handling(char *message);
+
+int clnt_sock[MAX_CONNECT_BOARD];
+int serv_sock = -1, max_fd;
+fd_set clients_socket, clients;
+
+void ServerInit(int *serv_sock, int port){
+    for (int i = 0; i < MAX_CONNECT_BOARD; i++){
+        clnt_sock[i] = -1;
+    }
+    struct sockaddr_in serv_addr;
+    struct sockaddr_in clnt_addr[MAX_CONNECT_BOARD];
+    socklen_t clnt_addr_size;
+    *serv_sock = socket(PF_INET, SOCK_STREAM, 0);
+    if (*serv_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 = htonl(INADDR_ANY);
+    serv_addr.sin_port = htons(port);
+
+    if (bind(*serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
+        error_handling("bind() error");
+
+    if (listen(*serv_sock, 5) == -1)
+        error_handling("listen() error");
+    for (int i = 0; i < MAX_CONNECT_BOARD; i++){
+        if (clnt_sock[i] < 0){
+            clnt_addr_size = sizeof(clnt_addr[i]);
+            clnt_sock[i] =
+                accept(*serv_sock, (struct sockaddr *)&clnt_addr[i], &clnt_addr_size);
+            if (clnt_sock[i] == -1)
+                error_handling("accept() error");
+        }
+        printf("Connection established with client %d\n",i);
+    }
+    printf("Connection End\n");
+
+    FD_ZERO(&clients_socket);
+    for (int i = 0; i < MAX_CONNECT_BOARD; i++){
+        FD_SET(clnt_sock[i], &clients_socket);
+    }
+    
+    max_fd = max(clnt_sock, MAX_CONNECT_BOARD);
+}
+int max(int *list, int length){
+    int temp = list[0];
+    for (int i = 1; i < length; i++){
+        if (list[i - 1] < list[i])
+            temp = list[i];
+    }
+    return temp;
+}
+void error_handling(char *message){
+    fputs(message, stderr);
+    fputc('\n', stderr);
+    exit(1);
+}

Central_Control_Board/PWM.c

+#include "JaeYukBookkom.h"
+#include <pthread.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+static int PWMExport(int pwmnum);
+static int PWMUnExport(int pwmnum);
+static int PWMEnable(int pwmnum);
+static int PWMWritePeriod(int pwmnum, int value);
+static int PWMWriteDutyCycle(int pwmnum, int value);
+int PWMInit(int pwm, int period, int dutycycle);
+void *bozzering(void *arg);
+void boozer_Warning(void);
+void SpeakerUnExport(void *args);
+
+int boozer_on = 0;
+pthread_t *boozerThread;
+int PWMInit(int pwm, int period, int dutycycle){
+    PWMExport(pwm);
+    PWMWritePeriod(pwm, period);
+    PWMWriteDutyCycle(pwm, dutycycle);
+}
+void *bozzering(void *arg){
+    PWMInit(SPEAKER,10000000,0);
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    pthread_cleanup_push(SpeakerUnExport, NULL);
+    while (1){
+        for (int i = 0; i < 1000; i++){
+            PWMWriteDutyCycle(SPEAKER, i * 10000);
+            usleep(1000);
+        }
+        for (int i = 1000; i > 0; i--){
+            PWMWriteDutyCycle(SPEAKER, i * 10000);
+            usleep(1000);
+        }
+    }
+    pthread_cleanup_pop(0);
+}
+void boozer_Warning(void){
+    PWMInit(SPEAKER,10000000,0);
+    for (int i = 0; i < 1000; i++){
+        PWMWriteDutyCycle(SPEAKER, i * 10000);
+        usleep(1000);
+    }
+    for (int i = 1000; i > 0; i--){
+        PWMWriteDutyCycle(SPEAKER, i * 10000);
+        usleep(1000);
+    }
+    PWMUnExport(SPEAKER);
+}
+static int PWMExport(int pwmnum){
+    char buffer[BUFFER_MAX];
+    int fd, byte;
+
+    // TODO: Enter the export path.
+    fd = open("/sys/class/pwm/pwmchip0/export", O_WRONLY);
+    if (-1 == fd){
+        fprintf(stderr, "Failed to open export for export!\n");
+        return (-1);
+    }
+
+    byte = snprintf(buffer, BUFFER_MAX, "%d", pwmnum);
+    write(fd, buffer, byte);
+    close(fd);
+    
+    usleep(1000000);
+    return (0);
+}
+static int PWMUnExport(int pwmnum){
+    char buffer[BUFFER_MAX];
+    int fd, byte;
+    // TODO: Enter the export path.
+    fd = open("/sys/class/pwm/pwmchip0/unexport", O_WRONLY);
+    if (-1 == fd){
+        fprintf(stderr, "Failed to open export for export!\n");
+        return (-1);
+    }
+    byte = snprintf(buffer, BUFFER_MAX, "%d", pwmnum);
+    write(fd, buffer, byte);
+    close(fd);
+    
+    usleep(1000);
+    return (0);
+}
+void SpeakerUnExport(void *args){
+    PWMUnExport(SPEAKER);
+    free(boozerThread);
+    sleep(1);
+}
+static int PWMEnable(int pwmnum){
+    static const char s_enable_str[] = "1";
+
+    char path[DIRECTION_MAX];
+    int fd;
+
+    // TODO: Enter the enable path.
+    snprintf(path, DIRECTION_MAX, "/sys/class/pwm/pwmchip0/pwm0/enable", pwmnum);
+    fd = open(path, O_WRONLY);
+    if (-1 == fd){
+        fprintf(stderr, "Failed to open in enable!\n");
+        return -1;
+    }
+
+    write(fd, s_enable_str, strlen(s_enable_str));
+    close(fd);
+
+    return (0);
+}
+static int PWMWritePeriod(int pwmnum, int value){
+    char s_value_str[VALUE_MAX];
+    char path[VALUE_MAX];
+    int fd, byte;
+
+    // TODO: Enter the period path.
+    snprintf(path, VALUE_MAX, "/sys/class/pwm/pwmchip0/pwm0/period", pwmnum);
+    fd = open(path, O_WRONLY);
+    if (-1 == fd){
+        fprintf(stderr, "Failed to open in period!\n");
+        return (-1);
+    }
+    byte = snprintf(s_value_str, VALUE_MAX, "%d", value);
+
+    if (-1 == write(fd, s_value_str, byte)){
+        fprintf(stderr, "Failed to write value in period!\n");
+        close(fd);
+        return -1;
+    }
+    close(fd);
+
+    return (0);
+}
+static int PWMWriteDutyCycle(int pwmnum, int value)
+{
+    char s_value_str[VALUE_MAX];
+    char path[VALUE_MAX];
+    int fd, byte;
+
+    // TODO: Enter the duty_cycle path.
+    snprintf(path, VALUE_MAX, "/sys/class/pwm/pwmchip0/pwm0/duty_cycle", pwmnum);
+    fd = open(path, O_WRONLY);
+    if (-1 == fd){
+        fprintf(stderr, "Failed to open in duty cycle!\n");
+        return (-1);
+    }
+    byte = snprintf(s_value_str, VALUE_MAX, "%d", value);
+
+    if (-1 == write(fd, s_value_str, byte)){
+        fprintf(stderr, "Failed to write value in duty cycle!\n");
+        close(fd);
+        return -1;
+    }
+    close(fd);
+
+    return (0);
+}

Central_Control_Board/WheatherAPI/Wheather.c

+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/select.h>
+#include <sys/time.h>
+
+#define BUFFER_MAX 3
+#define DIRECTION_MAX 256
+#define VALUE_MAX 256
+
+#define IN 0
+#define OUT 1
+
+#define LOW 0
+#define HIGH 1
+void error_handling(char *message){
+    fputs(message, stderr);
+    fputc('\n', stderr);
+    exit(1);
+}
+
+int main(int argc, char *argv[]){
+    int sock;
+    struct sockaddr_in serv_addr;
+    int str_len;
+    if (argc != 2){
+        printf("Usage : %s <port>\n", argv[0]);
+        exit(1);
+    }
+
+    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("127.0.0.1");
+    serv_addr.sin_port = htons(atoi(argv[1]));
+
+    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
+        error_handling("connect() error");
+
+    printf("Connection established\n");
+
+    char str[50];
+    while (1)
+    {
+        float temperature, hyderation;
+        int dust, rainPer;
+        int weatherCode;
+        printf("input temperature, hyderation: ");
+        scanf("%f %f",&temperature,&hyderation);
+        printf("input Whether prediction(1.Sunny,2.Cloud,3.Windy,4.Rain,5.Snow)\n:");
+        scanf("%d",&weatherCode);
+        printf("input dust, rainPer:");
+        scanf("%d %d",&dust,&rainPer);
+
+        snprintf(str, 50,"%.2f %.2f %d %d %d", temperature, hyderation, weatherCode, dust, rainPer);
+        int bytes_written = write(sock, str, sizeof(str));
+        if (bytes_written == -1)
+            error_handling("write() error");
+        usleep(500 * 100);
+        printf("Write success: %s\n",str);
+    }
+
+    close(sock);
+
+    return (0);
+}
\ No newline at end of file

Central_Control_Board/WheatherAPI/readme.txt

+this Wheather.c is assuming that Wheather API. 
+this program communicate with central.c by socket communication assuming that webSocket.
\ No newline at end of file

Central_Control_Board/readme.txt

+main code: Central_Main, Excute file: central.
+you should connect by socket communication in order of (0: Sensing Board, 1: Operation Board, 2: WeatherAPI)
+please excute 1)this board - central  ==> 2) Sensing Board - main ==> 3) operation board - actuabor
+ ==> 4)this board - WeatherAPI - whe
\ No newline at end of file