Skip to content
Snippets Groups Projects
Commit 005ac1b5 authored by 영현 손's avatar 영현 손
Browse files

Add new file (센싱보드 코드)

parent 5d2fab43
Branches
No related tags found
1 merge request!1Add new file (센싱보드 코드)
This commit is part of merge request !1. Comments created here will be created in the context of that merge request.
Show whitespace changes
Inline Side-by-side
Showing
with 430 additions and 0 deletions
yeonghyeon.c 0 → 100644
+ 430
− 0
View file @ 005ac1b5
#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 <linux/spi/spidev.h>
#include <linux/types.h>
#include <signal.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
#define BUFFER_MAX 3
#define DIRECTION_MAX 256
#define VALUE_MAX 256
// GPIO 핀 정의
#define IN 0
#define OUT 1
#define LOW 0
#define HIGH 1
// 우적 센서의 GPIO 핀 번호
#define RAIN_SENSOR_PIN 16
// 가스와 소음 센서의 임계값 설정
#define GAS_THRESHOLD 500
#define SOUND_THRESHOLD 30
// SPI 설정
static const char *DEVICE = "/dev/spidev0.0"; // SPI 장치 파일 경로
static uint8_t MODE = 0;
static uint8_t BITS = 8;
static uint32_t CLOCK = 1000000; // 1MHz
static uint16_t DELAY = 5;
static int SAMPLE_SIZE = 10; // 소음 센서 평균을 계산할 샘플 크기
// 서버 정보
const char* SERVER_IP = "192.168.22.4"; // 서버 IP
const int SERVER_PORT = 8800; // 서버 포트
// 전역 소켓 변수
int sock;
int spi_fd;
// 전역 상태 변수
int rain_status = 0;
int gas_status = 0;
int sound_status = 0;
int rain_initialized = 0; // 초기 상태 전송 플래그
int gas_initialized = 0; // 초기 상태 전송 플래그
int sound_initialized = 0; // 초기 상태 전송 플래그
pthread_mutex_t status_mutex = PTHREAD_MUTEX_INITIALIZER; // 상태 변수 보호용 뮤텍스
// GPIO 함수 선언
static int GPIOExport(int pin);
static int GPIOUnexport(int pin);
static int GPIODirection(int pin, int dir);
static int GPIORead(int pin);
// 센서 스레드 함수 선언
void* rain_sensor_routine(void* arg);
void* gas_sensor_routine(void* arg);
void* sound_sensor_routine(void* arg);
// 클라이언트 소켓 함수 선언
void setup_socket();
void send_message_to_server(int value);
void dispose();
void update_status_and_send_message();
// 인터럽트 핸들러 함수
void handle_interrupt(int sig) {
dispose();
exit(0);
}
// GPIO 핀을 시스템에 export 위한 함수
static int GPIOExport(int pin) {
char buffer[3];
int fd = open("/sys/class/gpio/export", O_WRONLY);
if (fd == -1) {
perror("Failed to open export for writing");
return -1;
}
snprintf(buffer, 3, "%d", pin);
if (write(fd, buffer, 3) == -1) {
perror("Failed to export gpio");
close(fd);
return -1;
}
close(fd);
return 0;
}
// GPIO 핀을 시스템에서 unexport 위한 함수
static int GPIOUnexport(int pin) {
char buffer[3];
int fd = open("/sys/class/gpio/unexport", O_WRONLY);
if (fd == -1) {
perror("Failed to open unexport for writing");
return -1;
}
snprintf(buffer, 3, "%d", pin);
if (write(fd, buffer, 3) == -1) {
perror("Failed to unexport gpio");
close(fd);
return -1;
}
close(fd);
return 0;
}
// GPIO 핀의 방향을 설정하는 함수
static int GPIODirection(int pin, int dir) {
const char s_directions_str[] = "in\0out";
char path[40];
int fd;
snprintf(path, 40, "/sys/class/gpio/gpio%d/direction", pin);
fd = open(path, O_WRONLY);
if (fd == -1) {
perror("Failed to open gpio direction for writing");
return -1;
}
if (write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3) == -1) {
perror("Failed to set direction");
close(fd);
return -1;
}
close(fd);
return 0;
}
// GPIO 핀의 값을 읽어오는 함수
static int GPIORead(int pin) {
char path[40];
char value_str[3];
int fd;
snprintf(path, 40, "/sys/class/gpio/gpio%d/value", pin);
fd = open(path, O_RDONLY);
if (fd == -1) {
perror("Failed to open gpio value for reading");
return -1;
}
if (read(fd, value_str, 3) == -1) {
perror("Failed to read value");
close(fd);
return -1;
}
close(fd);
return atoi(value_str);
}
// 클라이언트 소켓 설정 함수
void setup_socket() {
struct sockaddr_in serv_addr;
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1) {
perror("socket() error");
exit(1);
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
serv_addr.sin_port = htons(SERVER_PORT);
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
perror("connect() error");
close(sock);
exit(1);
}
printf("Connection established\n");
}
// 클라이언트 소켓으로 서버에 메시지를 보내는 함수
void send_message_to_server(int value) {
char output_str[3] = {0};
snprintf(output_str, sizeof(output_str), "%d", value);
int len = write(sock, output_str, strlen(output_str));
if (len == -1) {
perror("write() error");
} else {
printf("Sent message to server: %s\n", output_str);
}
}
// 자원 해제 함수. 강제 종료했을 때, 리소스 오류를 방지
void dispose() {
GPIOUnexport(RAIN_SENSOR_PIN);
close(sock);
close(spi_fd);
pthread_mutex_destroy(&status_mutex);
printf("Resources disposed\n");
}
// 상태 업데이트 및 메시지 전송 함수
void update_status_and_send_message() {
pthread_mutex_lock(&status_mutex); // 상태 변수 보호를 위해 뮤텍스 사용
if (rain_initialized && gas_initialized && sound_initialized) {
int combined_status = rain_status + gas_status + sound_status;
send_message_to_server(combined_status);
}
pthread_mutex_unlock(&status_mutex);
}
// 우적 센서 스레드 함수
void* rain_sensor_routine(void* arg) {
int previous_state = -1; // 이전 상태를 저장하기 위한 변수
while (1) {
int value = GPIORead(RAIN_SENSOR_PIN);
if (value == -1) {
printf("Failed to read from rain sensor\n");
break;
}
int current_state = (value == LOW) ? 1 : 0; // 비 감지 시 1, 비 없음 시 0
if (current_state == 1) {
printf("빗물 감지\n");
}
if (current_state != previous_state) {
pthread_mutex_lock(&status_mutex); // 상태 변수 보호를 위해 뮤텍스 사용
rain_status = current_state == 1 ? 1 : 0;
rain_initialized = 1;
pthread_mutex_unlock(&status_mutex);
update_status_and_send_message();
previous_state = current_state;
}
usleep(1000000); // 1초 대기
}
return NULL;
}
// SPI 준비 함수
static int prepare(int fd) {
if (ioctl(fd, SPI_IOC_WR_MODE, &MODE) == -1) {
perror("Can't set MODE");
return -1;
}
if (ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &BITS) == -1) {
perror("Can't set number of BITS");
return -1;
}
if (ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &CLOCK) == -1) {
perror("Can't set write CLOCK");
return -1;
}
if (ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &CLOCK) == -1) {
perror("Can't set read CLOCK");
return -1;
}
return 0;
}
// 차동 모드용 컨트롤 비트를 생성하는 함수
uint8_t control_bits_differential(uint8_t channel) {
return (channel & 7) << 4;
}
// 단일 모드용 컨트롤 비트를 생성하는 함수
uint8_t control_bits(uint8_t channel) {
return 0x8 | control_bits_differential(channel);
}
// ADC 값을 읽어오는 함수
int readadc(int fd, uint8_t channel) {
uint8_t tx[] = {1, control_bits(channel), 0};
uint8_t rx[3];
struct spi_ioc_transfer tr = {
.tx_buf = (unsigned long)tx,
.rx_buf = (unsigned long)rx,
.len = ARRAY_SIZE(tx),
.delay_usecs = DELAY,
.speed_hz = CLOCK,
.bits_per_word = BITS,
};
if (ioctl(fd, SPI_IOC_MESSAGE(1), &tr) == 1) {
perror("IO Error");
abort();
}
return ((rx[1] << 8) & 0x300) | (rx[2] & 0xFF);
}
// 가스 센서 스레드 함수
void* gas_sensor_routine(void* arg) {
int fd = *(int*)arg;
int previous_state = -1; // 이전 상태를 저장하기 위한 변수
while (1) {
int value = readadc(fd, 0); // 채널 0 사용
printf("가스 센서 값: %d\n", value);
int current_state = (value > GAS_THRESHOLD) ? 1 : 0; // 가스 감지 시 1, 가스 없음 시 0
if (current_state != previous_state) {
pthread_mutex_lock(&status_mutex); // 상태 변수 보호를 위해 뮤텍스 사용
gas_status = current_state == 1 ? 2 : 0;
gas_initialized = 1;
pthread_mutex_unlock(&status_mutex);
update_status_and_send_message();
previous_state = current_state;
}
usleep(1000000); // 1초 대기
}
return NULL;
}
// 소음 센서 스레드 함수
void* sound_sensor_routine(void* arg) {
int fd = *(int*)arg;
int32_t samples[SAMPLE_SIZE];
int sample_index = 0;
int previous_state = -1; // 이전 상태를 저장하기 위한 변수
while (1) {
int value = readadc(fd, 7); // 채널 7 사용
samples[sample_index] = value;
sample_index = (sample_index + 1) % SAMPLE_SIZE;
if (sample_index == 0) {
int32_t sum = 0;
for (int i = 0; i < SAMPLE_SIZE; i++) {
sum += samples[i];
}
int32_t average_value = sum / SAMPLE_SIZE;
printf("소음 센서 평균 값: %d\n", average_value);
int current_state = (average_value > SOUND_THRESHOLD) ? 1 : 0; // 소음 감지 시 1, 소음 없음 시 0
if (current_state != previous_state) {
pthread_mutex_lock(&status_mutex); // 상태 변수 보호를 위해 뮤텍스 사용
sound_status = current_state == 1 ? 4 : 0;
sound_initialized = 1;
pthread_mutex_unlock(&status_mutex);
update_status_and_send_message();
previous_state = current_state;
}
}
usleep(1000000); // 1초 대기
}
return NULL;
}
int main(int argc, char **argv) {
// 인터럽트 신호 처리 설정
signal(SIGINT, handle_interrupt);
signal(SIGTERM, handle_interrupt);
// SPI 장치 열기
spi_fd = open(DEVICE, O_RDWR);
if (spi_fd <= 0) {
perror("Device open error");
return -1;
}
// SPI 장치 준비
if (prepare(spi_fd) == -1) {
perror("Device prepare error");
return -1;
}
// 소켓 설정
setup_socket();
pthread_t rain_thread, gas_thread, sound_thread;
// GPIO 초기화
if (GPIOExport(RAIN_SENSOR_PIN) == -1) {
return 1;
}
if (GPIODirection(RAIN_SENSOR_PIN, IN) == -1) {
return 1;
}
printf("프로그램이 시작되었습니다. 센싱을 시작하기 전에 초기 설정을 완료합니다.\n");
printf("10초 후에 센싱을 시작합니다. 잠시 후에 초기 값이 출력이 됩니다.\n");
printf("먼저 소음 센서부터 센싱을 시작하며, 9초 후에 가스 센서와 우적 센서가 순차적으로 시작됩니다.\n");
printf("센서 상태 코드: 정상 상태: 0, 우적 감지: 1, 가스 감지: 2, 소음 감지: 4\n");
printf("복합 상태 코드: 우적 + 가스: 3, 우적 + 소음: 5, 가스 + 소음: 6, 우적 + 가스 + 소음: 7\n");
printf("[초기 상태]\n");
// 소음 센서 스레드 생성
if (pthread_create(&sound_thread, NULL,sound_sensor_routine, &spi_fd) != 0) {
perror("Failed to create sound sensor thread");
return 1;
}
usleep(9000000); // 9초 대기
// 우적 센서 스레드 생성
if (pthread_create(&rain_thread, NULL, rain_sensor_routine, NULL) != 0) {
perror("Failed to create rain sensor thread");
return 1;
}
// 가스 센서 스레드 생성
if (pthread_create(&gas_thread, NULL, gas_sensor_routine, &spi_fd) != 0) {
perror("Failed to create gas sensor thread");
return 1;
}
// 스레드 종료 대기
pthread_join(rain_thread, NULL);
pthread_join(gas_thread, NULL);
pthread_join(sound_thread, NULL);
// 자원 해제
dispose();
return 0;
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment

feedback to tooltime@ajou.ac.kr or hwan@ajou.ac.kr