Select Git revision
project_client.c 11.87 KiB
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <time.h>
#include <sys/socket.h>
#include <linux/spi/spidev.h>
#define ARRAY_SIZE(array) sizeof(array) / sizeof(array[0])
#define IN 0
#define OUT 1
#define LOW 0
#define HIGH 1
#define POUT 17
#define PIN1 24
#define POUT1 23
#define BTNOUT 21
#define BTN 20
#define VALUE_MAX 45
#define BUFFER_MAX 45
#define DIRECTION_MAX 45
#define LED 0
static int file_i2c = -1;
static int length = 1;
static const char *DEVICE = "/dev/spidev0.0";
static uint8_t MODE = SPI_MODE_0;
static uint8_t BITS = 8;
static uint32_t CLOCK = 1000000;
static uint16_t DELAY = 5;
static int PWMExport(int pwmnum) {
char buffer[BUFFER_MAX];
int bytes_written;
int fd;
fd = open("/sys/class/pwm/pwmchip0/unexport", O_WRONLY);
if (-1 == fd) {
fprintf(stderr, "Failed to open in unexport!\n");
return -1;
}
bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pwmnum);
write(fd, buffer, bytes_written);
close(fd);
sleep(1);
fd = open("/sys/class/pwm/pwmchip0/export", O_WRONLY);
if (-1 == fd) {
fprintf(stderr, "Failed to open in export!\n");
return -1;
}
bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pwmnum);
write(fd, buffer, bytes_written);
close(fd);
sleep(1);
return 0;
}
static int PWMEnable(int pwmnum) { static const char s_unenable_str[] = "0";
static const char s_enable_str[] = "1";
char path[DIRECTION_MAX];
int fd;
snprintf(path, DIRECTION_MAX, "/sys/class/pwm/pwmchip0/pwm%d/enable", pwmnum);
fd = open(path, O_WRONLY);
if (-1 == fd) {
fprintf(stderr, "Failed to open in enable!\n");
return -1;
}
write(fd, s_unenable_str, strlen(s_unenable_str));
close(fd);
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_values_str[VALUE_MAX];
char path[VALUE_MAX];
int fd, byte;
snprintf(path, VALUE_MAX, "/sys/class/pwm/pwmchip0/pwm%d/period", pwmnum);
fd = open(path, O_WRONLY);
if (-1 == fd) {
fprintf(stderr, "Faild to open in period!\n");
return -1;
}
byte = snprintf(s_values_str, VALUE_MAX, "%d", value);
//fprintf(stderr, "byte: %s\n", s_values_str);
if (-1 == write(fd, s_values_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_values_str[VALUE_MAX];
char path[VALUE_MAX];
int fd, byte;
#define VALUE_MAX 45
snprintf(path, VALUE_MAX, "/sys/class/pwm/pwmchip0/pwm%d/duty_cycle", pwmnum);
fd = open(path, O_WRONLY);
if (-1 == fd) {
fprintf(stderr, "Faild to open in duty_cycle!\n");
return -1;
}
byte = snprintf(s_values_str, VALUE_MAX, "%d", value);
//fprintf(stderr, "byte: %s\n", s_values_str);
if (-1 == write(fd, s_values_str, byte)) {
fprintf(stderr, "Failed to write value in duty_cycle\n");
close(fd); return -1;
}
close(fd);
return 0;
}
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 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!, pin: %d\n", pin);
return(-1);
}
if (-1 == write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3)) {
fprintf(stderr, "Failed to set direction!\n");
close(fd);
return(-1);
}
close(fd);
return 0;
}
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");
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);
}
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);
//fprintf(stderr,path);
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");
close(fd);
return(-1);
}
close(fd);
return(atoi(value_str));
}
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);
}
void error_handling( char *message){
fputs(message,stderr);
fputc( '\n',stderr);
exit(1);
}
static void initLED(int pwmnum) {
PWMExport(pwmnum);
PWMWritePeriod(pwmnum,20000000);
PWMWriteDutyCycle(pwmnum,0);
PWMEnable(pwmnum);
}
static void TurnOnLed(int pwmbtnnum, int bright) {
PWMWriteDutyCycle(pwmbtnnum, bright);
}
float distance;
int databus = -1;
void *light_led(void *data)
{
char* thread_name = (char*)data;
printf("led: %s\n", thread_name);
int bright = 0;
while(1) {
usleep(12347);
if(databus < -1){ bright = 0;
TurnOnLed(LED, bright);
continue;
}
if(databus < 0){
continue;
}
databus += 2;
float tmp = ((float)1/databus);
bright = (int)(tmp * 22000 * 600);
printf("bright: %d\n",bright);
TurnOnLed(LED, bright);
databus = -1;
}
}
clock_t start_t, end_t;
double time2;
void initUltrawave() {
if (-1 == GPIOExport(POUT1) || -1 == GPIOExport(PIN1)) {
printf("gpio export err\n");
exit(0);
}
if (-1 == GPIODirection(POUT1, OUT) || -1 == GPIODirection(PIN1, IN)) {
printf("gpio direction err\n");
exit(0);
}
GPIOWrite(POUT1, 0);
}
float distance;
float logicUltrawave() {
// working phase
if (-1 == GPIOWrite(POUT1, 1)) {
printf("gpio write/trigger err\n");
exit(0);
}
GPIOWrite(POUT1, 0);
while (GPIORead(PIN1) == 0) {
start_t = clock();
}
while (GPIORead(PIN1) == 1) {
end_t = clock();
}
time2 = (double)(end_t - start_t) / CLOCKS_PER_SEC;
distance = time2 * 17000;
if (distance > 300)
distance = 300;
//printf("distance: %.2lfcm\n", distance);
return distance;
}
int sock;
struct sockaddr_in serv_addr;
char buffer[1025] = {0,};
char btnEvent[15]= "110000";
int str_len;
int initConnection(){
if (-1 == GPIOExport(POUT))
return(2);
if (-1 == GPIODirection(POUT, OUT))
return(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("192.168.0.38");
serv_addr.sin_port = htons(8888);
if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1){
printf("cant connect...\n");
return -1;
}
return 1;
}
void logic() {
str_len = read(sock, buffer, sizeof(buffer));
if(str_len == -1)
error_handling("read() error");
int data = atoi(buffer);
databus = data;
printf("received data: %d\n",data);
}
void pushBtnEvent() {
btnEvent[1] = '1'-btnEvent[1] + '0';
}
void makeNumPakcet(int code, int data, char* res) {
char tmp[15] = {0,};
int l = 0;
while(data > 0) {
int tmpN = data%10;
data /= 10;
tmp[l++] = tmpN + '0';
}
for(int i = 0; i < l/2; i++) {
char ttmp = tmp[l - i - 1];
tmp[l - i - 1] = tmp[i];
tmp[i] = ttmp;
}
res[0] = code + '0';
for(int i = 1; i <= l; i++) {
res[i] = tmp[i-1];
}
//printf("tmpres = %s\n",res);
return res;
}
void clearBuffer() {
for(int i = 0; i < 1025; i++)
buffer[i] = 0;
}
static void Write_Bytes(int output){
if(write(file_i2c, &output, length) != length){
printf("Failed to write to the i2c bus.\n");
return;
}
}
//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);
}
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);
}
char gasPacket[15] = {0,};
int gasV = 0;
int main() {
gasPacket[0] = '5';
if(-1 == GPIOExport(BTNOUT) || -1 == GPIOExport(BTN))
return 2;
if (-1 == GPIODirection(BTNOUT, OUT) || -1 == GPIODirection(BTN, IN))
return(2);
int fd = open(DEVICE, O_RDWR);
if (fd <= 0) {
printf("Device %s not found\n", DEVICE);
return -1;
}
if (prepare(fd) == -1)
return -1;
initUltrawave();
while(1) {
usleep(1000000);
if(initConnection() == 1)
break;
printf("trying reconnect...\n");
}
printf("socket connected\n");
int prev = 1;
while(1) {
usleep(20000);
clearBuffer();
if (-1 == GPIOWrite(BTNOUT, 1))
return(3);
if(prev == 1 && GPIORead(BTN) == 0) { //Btn is Pushed.
write(sock,btnEvent, sizeof(1024));
pushBtnEvent();
}
gasV = readadc(fd,0);
if(gasV > 200) {
printf("GasOverFlow = %d\n",gasV);
gasPacket[1] = '1';
write(sock,gasPacket, 15);
}
int ret = recv(sock, buffer, sizeof(buffer), MSG_DONTWAIT);
if(ret < 0) {
//printf("read wait\n");
}
else {
int data = (int)logicUltrawave();
if(buffer[2] == '1') { //send ultrawave
char packet[15] = {0,};
makeNumPakcet(4,data, packet);
write(sock,packet, 1024);
//printf("ultrapacket = %s\n",packet);
}
printf("buffer = %s, len = %d\n",buffer,sizeof(buffer));
}
prev = GPIORead(BTN);
}
printf("Client ended\n");
close(sock);
if (-1 == GPIOUnexport(POUT))
return(4);
return(0);
}