1.生产者&消费者,进程控制,fifo通信
/*product.c*/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<errno.h>
#include<sys/ipc.h>
#include<semaphore.h>
#include<fcntl.h>
#define FIFO "myfifo"
#define N 5
int lock_var;
time_t end_time;
char buf_r[100];
sem_t mutex,full,avail;
int fd;
void productor(void *arg);
void consumer(void *arg);
int main(int argc,char *argv[])
{
pthread_t id1,id2;
pthread_t mon_th_id;
int ret;
end_time =time(NULL)+30;
if((mkfifo(FIFO,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
rintf("cannot create fifoserver");
printf("Preparein for reading bytes....\n");
memset(buf_r,0,sizeof(buf_r));
fd = open(FIFO,O_RDWR|O_NONBLOCK,0);
if(fd==-1)
{
perror("open");
exit(1);
}
ret = sem_init(&mutex,0,1);
ret = sem_init(&avail,0,N);
ret = sem_init(&full,0,0);
if(ret!=0)
{
perror("sem_init");
}
ret = pthread_create(&id1,NULL,(void*)productor,NULL);
if(ret!=0)
perror("pthread create");
ret = pthread_create(&id2,NULL,(void*)consumer,NULL);
if(ret!=0)
perror("pthread create2");
pthread_join(id1,NULL);
pthread_join(id2,NULL);
exit(0);
}
void productor(void *arg)
{
int i,nwrite;
while(time(NULL)<end_time){
sem_wait(&avail);
sem_wait(&mutex);
if((nwrite=write(fd,"hello",5))==-1)
{
if(errno==EAGAIN)
printf("the fifo has not been read yet.please try later\n");
}
else
printf("write hello to the fifo\n");
sem_post(&full);
sem_post(&mutex);
sleep(1);
}
}
void consumer(void *arg)
{
int nolock = 0;
int ret,nread;
while(time(NULL)<end_time)
{
sem_wait(&full);
sem_wait(&mutex);
memset(buf_r,0,sizeof(buf_r));
if(nread=read(fd,buf_r,100)==-1)
{
if(errno==EAGAIN)
printf("no data yet\n");
}
printf("read %s from FIFO\n",buf_r);
sem_post(&avail);
sem_post(&mutex);
sleep(1);
}
}
2.TCP网络编程server.c
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#define SERV_PORT 2306
#define LENGTH 10
#define SIZE 128
int main()
{
int res;
int sockfd;
int clientfd;
struct sockaddr_in hostaddr;
struct sockaddr_in clientaddr;
unsigned int addrlen;
char buf[SIZE];
int cnt;
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd == -1)
{
perror("socket create failed");
exit(1);
}
hostaddr.sin_family = AF_INET;
hostaddr.sin_port = htons(SERV_PORT);
hostaddr.sin_addr.s_addr = INADDR_ANY;
bzero(&(hostaddr.sin_zero),8);
res = bind(sockfd,(struct sockaddr *)&hostaddr,sizeof(struct sockaddr));
if(res==-1)
{
perror("bind err");
exit(1);
}
res = listen(sockfd,LENGTH);
if(res==-1)
{
perror("listen err");
exit(1);
}
printf("wait connct...\n");
while(1)
{
addrlen = sizeof(struct sockaddr_in);
clientfd = accept(sockfd,(struct sockaddr *)&clientaddr,&addrlen);
if(clientfd==-1)
{
perror("accept err\n");
continue;
}
printf("client ip:%s\n",inet_ntoa(clientaddr.sin_addr));
cnt = recv(clientfd,buf,SIZE,0);
if(cnt ==-1)
{
perror("recv err\n");
exit(1);
}
printf("recv data:%s\n",buf);
close(clientfd);
}
return 0;
}
:gcc server.c -o server
:./server
telnet localhost 2306
3. TCP网络编程 client.c
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/socket.h>
#define SERV_PORT 2306
#define SIZE 128
int main(int argc,char **argv)
{
int res;
int sockfd;
struct sockaddr_in servaddr;
char buf[SIZE];
int cnt;
if(argc!=2)
{
printf("parameter err\n");
exit(1);
}
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd == -1)
{
printf("socket err\n");
exit(1);
}
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
servaddr.sin_addr.s_addr = INADDR_ANY;
bzero(&(servaddr.sin_zero),8);
res = connect(sockfd,(struct sockaddr*)&servaddr,sizeof(struct sockaddr));
if(res == -1)
{
perror("connect err\n");
exit(1);
}
strcpy(buf,argv[1]);
cnt = send(sockfd,buf,SIZE,0);
if(cnt == -1)
{
perror("send err\n");
exit(1);
}
printf("send data: %s\n",buf);
close(sockfd);
return 0;
}
4 .TCP网络编程select.c
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/wait.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/un.h>
#include<sys/time.h>
#include<sys/ioctl.h>
#include<unistd.h>
#include<netinet/in.h>
#define SERVPORT 3333
#define BACKLOG 10
#define MAX_CONNECTED_NO 10
#define MAXDATASIZE 100
int main()
{
struct sockaddr_in server_sockaddr,client_sockaddr;
int sin_size,recvbytes;
fd_set readfd;
fd_set writefd;
int sockfd,client_fd;
char buf[MAXDATASIZE];
if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}
printf("socket success!,socket = %d\n",sockfd);
server_sockaddr.sin_family = AF_INET;
server_sockaddr.sin_port = htons(SERVPORT);
server_sockaddr.sin_addr.s_addr = INADDR_ANY;
bzero(&(server_sockaddr.sin_zero),8);
if(bind(sockfd,(struct sockaddr*)&server_sockaddr,sizeof(struct sockaddr))==-1)
{
perror("bind");
exit(1);
}
printf("bind success!\n");
if(listen(sockfd,BACKLOG)==-1)
{
perror("listen");
exit(1);
}
printf("listenging......\n");
FD_ZERO(&readfd);
FD_SET(sockfd,&readfd);
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if(select(MAX_CONNECTED_NO,&readfd,NULL,NULL,(struct timeval*)0)>0)
{
if(FD_ISSET(sockfd,&readfd)>0)
{
if((client_fd = accept(sockfd,(struct sockaddr *)&client_sockaddr,&sin_size))==-1)
{
perror("accept");
exit(1);
}
if((recvbytes = recv(client_fd,buf,MAXDATASIZE,0))==-1)
{
perror("recv");
exit(1);
}
if(read(client_fd,buf,MAXDATASIZE)<0)
{
perror("read");
exit(1);
}
printf("received a connection:%s",buf);
}
close(client_fd);
}
}
}
5.crc8实现
xCal_crc
//get crc8
unsigned char get_crc8(unsigned char *buf, unsigned char len)
{
const unsigned char *data = buf;
unsigned short crc = 0;
unsigned short i, j;
for (j = len; j; j--, data++)
{
crc ^= (*data << 8);
for (i = 8; i; i--)
{
if (crc & 0x8000)
crc ^= ((unsigned short)0x1070 << 3);
crc <<= 1;
}
}
return (unsigned char)(crc >> 8);
}
6.串口操作
#include <android/log.h>
#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fmserial.h>
static const char *TAG="serial_port";
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)
/* maximum buffer len to store whole LIN message*/
#define SLLIN_DATA_MAX 8
#define SLLIN_5A_LEN 1
#define SLLIN_DATALEN_LEN 1
#define SLLIN_A5_LEN 1
#define SLLIN_SYNC_LEN 1
#define SLLIN_ID_LEN 1
#define SLLIN_CHKSM_LEN 1
#define SLLIN_BUFF_LEN (SLLIN_5A_LEN + SLLIN_DATALEN_LEN + SLLIN_SYNC_LEN + \
SLLIN_ID_LEN + SLLIN_DATA_MAX + \
SLLIN_CHKSM_LEN + SLLIN_A5_LEN)
#define SLLIN_BUFF_5A 0
#define SLLIN_BUFF_DATALEN 1
#define SLLIN_BUFF_SYNC 2
#define SLLIN_BUFF_ID 3
#define SLLIN_BUFF_DATA 4
typedef struct{
unsigned char rx_buff[SLLIN_BUFF_LEN]; /* LIN Rx buffer */
int rx_cnt; /* message buffer Rx fill level */
int data_cnt;/* data len */
int data_index;/* data index */
unsigned char Uart2_Sta;
}fmsllin;
typedef union sumaddc
{
unsigned short sums;
unsigned char sumc[2];
}usumaddc;
FMSerial::FMSerial()
{
m_fd = 0;
}
FMSerial::~FMSerial()
{
if(m_fd != 0)
close(m_fd);
}
unsigned char FMSerial::checksumaddc( unsigned char* buf, int len )
{
usumaddc sum;
sum.sums = 0;
int i = 0;
unsigned char checksum = 0x00;
for(i = 0; i < len; i++){
sum.sums = sum.sumc[0] + (*(buf+i));
sum.sumc[0] = sum.sumc[0] + sum.sumc[1];
sum.sumc[1] = 0x00;
}
//LOGE("sumc0 %x",(~sum.sumc[0])&0xFF);
//checksum = ((unsigned char)0xFF - sum.sumc[0])&0xFF;
checksum = (~sum.sumc[0])&0xFF ;
return checksum;
}
speed_t FMSerial::getBaudrate(int baudrate)
{
switch(baudrate) {
case 0: return B0;
case 50: return B50;
case 75: return B75;
case 110: return B110;
case 134: return B134;
case 150: return B150;
case 200: return B200;
case 300: return B300;
case 600: return B600;
case 1200: return B1200;
case 1800: return B1800;
case 2400: return B2400;
case 4800: return B4800;
case 9600: return B9600;
case 19200: return B19200;
case 38400: return B38400;
case 57600: return B57600;
case 115200: return B115200;
case 230400: return B230400;
case 460800: return B460800;
case 500000: return B500000;
case 576000: return B576000;
case 921600: return B921600;
case 1000000: return B1000000;
case 1152000: return B1152000;
case 1500000: return B1500000;
case 2000000: return B2000000;
case 2500000: return B2500000;
case 3000000: return B3000000;
case 3500000: return B3500000;
case 4000000: return B4000000;
default: return -1;
}
}
int FMSerial::SerialPort_open(const char* path_utf, int baudrate, int flags)
{
int fd;
speed_t speed;
/* Check arguments */
{
speed = getBaudrate(baudrate);
if (speed == -1) {
/* TODO: throw an exception */
LOGE("Invalid baudrate");
return 0;
}
}
/* Opening device */
{
//chmod(path_utf, 0777);
LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
fd = open(path_utf, O_RDWR | O_NOCTTY | O_NONBLOCK | flags);
LOGD("open() fd = %d", fd);
if (fd == -1)
{
/* Throw an exception */
LOGE("Cannot open port");
/* TODO: throw an exception */
return 0;
}
}
/* Configure device */
/*
波特率: 推荐采用19200bps ,其他(9600,38400,57600,115200)仅供参考
位数: 8bit
奇偶校验: 无
停止位: 1bit
*/
{
struct termios cfg;
LOGD("Configuring serial port");
if (tcgetattr(fd, &cfg))
{
LOGE("tcgetattr() failed");
close(fd);
/* TODO: throw an exception */
return 0;
}
#if 0
/* Enable the receiver and set local mode...*/
cfg.c_cflag |= (CLOCAL | CREAD);
/* Set c_cflag options.*/
//无校验
cfg.c_cflag &= ~(PARENB|PARODD);
// 停止位: 1bit
cfg.c_cflag &= ~CSTOPB;
//位数: 8bit
cfg.c_cflag &= ~CSIZE;
cfg.c_cflag |= CS8;
/* Set c_iflag input options */
cfg.c_iflag &=~(IXON | IXOFF | IXANY);
cfg.c_iflag &=~(INLCR | IGNCR | ICRNL);
cfg.c_lflag &=~(ICANON | ECHO | ECHOE | ISIG);
/* Set c_oflag output options */
cfg.c_oflag &= ~(OPOST|ONLCR|OCRNL|ONOCR|ONLRET);
/* Set the timeout options */
//cfg.c_cc[VMIN] = 0;
if(path_utf=="/dev/ttyMT3")
cfg.c_cc[VTIME] = 50; //simon modify for ttyMT3
#else
cfmakeraw(&cfg);
#endif
/* Set the baud rates to 19200...*/
cfsetispeed(&cfg, speed);
cfsetospeed(&cfg, speed);
if (tcsetattr(fd, TCSANOW, &cfg))
{
LOGE("tcsetattr() failed");
close(fd);
/* TODO: throw an exception */
return 0;
}
tcflush(fd, TCIFLUSH);
}
m_fd = fd;
return fd;
}
/*
* Class: com_tcl_factory_serial_SerialPort
* Method: close
* Signature: ()V
*/
void FMSerial::SerialPort_close
(int descriptor)
{
LOGD("close(fd = %d)", descriptor);
close(descriptor);
}
int FMSerial::SerialPort_write( unsigned char* buf, int len )
{
int ret = 0;
if (m_fd == -1)
{
/* Throw an exception */
LOGE("open port first");
/* TODO: throw an exception */
return 0;
}
ret = write(m_fd,buf,len);
return ret;
}
int FMSerial::SerialPort_read( unsigned char* buf, int len )
{
int ret = 0;
if (m_fd == -1)
{
/* Throw an exception */
LOGE("open port first");
/* TODO: throw an exception */
return 0;
}
ret = read(m_fd,buf,len);
return ret;
}
int FMSerial::SerialPort_write_lin( unsigned char* buf, int len, bool b_checksum )
{
int ret = 0;
int rettmp = 0;
int i = 0;
unsigned char checksum = 0x00;
struct termios cfg1,cfg2;
unsigned char cmd00[] = {0x00};
unsigned char cmdbuf[SLLIN_BUFF_LEN] = {0};
bool b_csum = false;
if ( m_fd == -1 )
{
/* Throw an exception */
LOGE("open port first");
/* TODO: throw an exception */
return 0;
}
if( len > SLLIN_BUFF_LEN )
{
/* Throw an exception */
LOGE("len is too long");
/* TODO: throw an exception */
return 0;
}
memset(cmdbuf,0,sizeof(unsigned char)*SLLIN_BUFF_LEN);
memcpy((void *)(cmdbuf+SLLIN_BUFF_ID),(void *)buf,len);
b_csum = b_checksum ;
if( b_csum ){
checksum = FMSerial::checksumaddc( buf, len);
cmdbuf[SLLIN_BUFF_ID+len] = checksum;
len = len + 1;
}
cmdbuf[SLLIN_BUFF_5A] = 0x5A;
cmdbuf[SLLIN_BUFF_DATALEN] = len;
cmdbuf[SLLIN_BUFF_SYNC] = 0x55;
//cmdbuf[SLLIN_5A_LEN + SLLIN_DATALEN_LEN + SLLIN_SYNC_LEN + len] = 0xA5;
cmdbuf[SLLIN_BUFF_LEN-1] = 0xA5;
/*if(len > 0){
printf("cmdbuf");
for(i = 0; i < SLLIN_BUFF_LEN; i++)
printf(" %x",cmdbuf[i]);
printf("\n");
}*/
//LOGE("wjwlen: %d ",(SLLIN_5A_LEN + SLLIN_DATALEN_LEN + SLLIN_SYNC_LEN + len + SLLIN_A5_LEN));
tcflush(m_fd, TCIFLUSH);
ret = write(m_fd,cmdbuf,SLLIN_BUFF_LEN/*(SLLIN_5A_LEN + SLLIN_DATALEN_LEN + SLLIN_SYNC_LEN + len + SLLIN_A5_LEN)*/);
/*for(i = 0; i < SLLIN_BUFF_LEN; i++)
{
rettmp = write(m_fd,&cmdbuf[i],1);
ret = ret + rettmp;
usleep(1000);
}*/
/*(SLLIN_5A_LEN + SLLIN_DATALEN_LEN + SLLIN_SYNC_LEN + len + SLLIN_A5_LEN)*/
//cmdbuf[0] = 0x55;
//ret = write(m_fd,cmdbuf,1);
return ret ;
}
int FMSerial::SerialPort_read_lin( unsigned char* buf, int len, unsigned char retry )
{
int ret = 0;
if (m_fd == -1)
{
/* Throw an exception */
LOGE("open port first");
/* TODO: throw an exception */
return 0;
}
ret = read(m_fd,buf,len);
while( ret < 0 && retry > 0 ){
usleep(2*1000);
ret = read(m_fd,buf,len);
retry--;
}
return ret;
}
7 文件io之文件锁的使用
#include<unistd.h>
#include<sys/file.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h>
#include<stdlib.h>
void lock_set(int fd,int type)
{
struct flock lock;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
while(1)
{
lock.l_type = type;
if((fcntl(fd,F_SETLK,&lock))==0)
{
if(lock.l_type ==F_RDLCK)
printf("read lock set by %d\n",getpid());
else if(lock.l_type ==F_WRLCK)
printf("write lock set by %d\n",getpid());
else if(lock.l_type ==F_UNLCK)
printf("release lock by %d\n",getpid());
return ;
}
fcntl(fd,F_GETLK,&lock);
if(lock.l_type!=F_UNLCK)
{
if(lock.l_type==F_RDLCK)
printf("read lock already set by %d\n",lock.l_pid);
else if(lock.l_type==F_WRLCK)
printf("write lock already set by %d\n",lock.l_pid);
getchar();
}
}
}
int main(void)
{
int fd;
fd = open("hello",O_RDWR|O_CREAT,0666);
if(fd<0){
perror("open");
exit(1);
}
lock_set(fd,F_WRLCK);
getchar();
lock_set(fd,F_UNLCK);
getchar();
close(fd);
exit(0);
}
8.阻塞IO之select使用
#include<fcntl.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<time.h>
int main(void)
{
int fds[2];
char buf[7];
int i,rc,maxfd;
fd_set inset1,inset2;
struct timeval tv;
if((fds[0]=open("hello1",O_RDWR|O_CREAT,0666))<0)
perror("open hello1");
if((fds[1]=open("hello2",O_RDWR|O_CREAT,0666))<0)
perror("open hello2");
if((rc=write(fds[0],"hello!\n",7)))
printf("rc=%d\n",rc);
lseek(fds[0],0,SEEK_SET);
maxfd=fds[0]>fds[1]?fds[0]:fds[1];
FD_ZERO(&inset1);
FD_SET(fds[0],&inset1);
FD_ZERO(&inset2);
FD_SET(fds[1],&inset2);
tv.tv_sec=2;
tv.tv_usec=0;
while(FD_ISSET(fds[0],&inset1)||FD_ISSET(fds[1],&inset2))
{
if(select(maxfd+1,&inset1,&inset2,NULL,&tv)<0)
perror("select");
else{
if(FD_ISSET(fds[0],&inset1))
{
rc=read(fds[0],buf,7);
if(rc>0)
{
buf[rc]='\0';
printf("read:%s\n",buf);
}else
perror("read");
}
if(FD_ISSET(fds[1],&inset2)){
rc = write(fds[1],buf,7);
if(rc>0){
buf[rc]='\0';
printf("rc=%d,write:%d\n",rc,buf);
}else
perror("write");
sleep(10);
}
}
}
exit(0);
}
8.串口操作实例
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<errno.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<termios.h>
#include<stdlib.h>
int set_opt(int fd,int nSpeed,int nBit,char nEvent,int nStop)
{
struct termios newtio,oldtio;
/*保存现有串口参数,如果串口号出错,会有错误提示*/
if(tcgetattr(fd,&oldtio)!=0)
{
perror("SetupSerial 1");
return -1;
}
bzero(&newtio,sizeof(newtio));
//1.设置字体大小
newtio.c_cflag |= CLOCAL|CREAD;
newtio.c_cflag &= ~CSIZE;
//2.设置停止位
switch(nBits)
{
case 7:
newtio.c_cflag |= CS7;
break;
case 8:
newtio.c_cflag |= CS8;
break;
}
//3.设置奇偶校验位
switch(nEvent)
{
case 'O'://奇数
newtio.c_cflag |= PARENB;
newtio.c_clag |= PARODD;
newtio.c_iflag |= (INPCK|ISTRIP);
break;
case 'E'://偶数
newtio.c_iflag |= (INPCK|ISTRIP);
newtio.c_cflag |= PARENB;
newtio.c_clag &= ~PARODD;
break;
case 'N'://无
newtio.c_cflag &= ~PARENB;
break;
}
//4.设置波特率
switch(nSpeed)
{
case 2400:
cfsetispeed(&newtio,B2400);
cfsetospeed(&newtio,B2400);
break;
case 4800:
cfsetispeed(&newtio,B4800);
cfsetospeed(&newtio,B4800);
case 9600:
cfsetispeed(&newtio,B4800);
cfsetospeed(&newtio,B4800);
case 115200:
cfsetispeed(&newtio,B4800);
cfsetospeed(&newtio,B4800);
case 460800:
cfsetispeed(&newtio,B4800);
cfsetospeed(&newtio,B4800);
default:
cfsetispeed(&newtio,B9600);
cfsetospeed(&newtio,B9600);
break;
}
//5.设置停止位
if(nStop==1
newtio.c_cflag &= ~ CSTOPB;
else if(nStop==2)
newtio.c_cflag |= CSTOPB;
//6.设置等待时间和最小接受字符
newtio.c_cc[VTIME]=0;
newtio.c_cc[VMIN]=0;
//刷新输入,处理为接受字符
tcflush(fd,TCIFLUSH);
//激活新配置
if((tcsetattr(fd,TCSANOW,&newtio))!=)
{
perror("com set error");
return -1;
}
printf("set done!\n");
return 0;
}
int open_port(int fd,int comport)
{
chr *dev[]={"/dev/ttyS0","/dev/ttyS1","/dev/ttyS2"};
long vdisable;
if(comport==1){
fd = open("/dev/ttyS0",O_RDWR|O_NOCTTY|O_NDELAY);
if(-1==fd){
perror("cann't open serial port");
return -1;
}
}
else if(comport==2){
fd = open("/dev/ttyS1",O_RDWR|O_NOCTTY|O_NDELAY);
if(-1==fd){
perror("cann't open serial port");
return -1;
}
}
else if(comport==3){
fd = open("/dev/ttyS2",O_RDWR|O_NOCTTY|O_NDELAY);
if(-1==fd){
perror("cann't open serial port");
return -1;
}
}
if(fcntl(fd,F_SETFL,0)<0)
printf("fcntl failed!\n");
else
printf("fcntl=%d\n",fcntl(fd,F_SETFL,0));
//测试是否是串口设备
if(isatty(STDIN_FILENO)==0)
printf("standard input is not a terminal device\n");
else
printf("isatty success!\n");
printf("fd=open=%d\n",fd);
return fd;
}
int main(void)
{
int fd;
int nread,i;
char buff[]="hello\n";
if((fd=open_port(fd,1))<0)
{
perror("open_port error");
return;
}
if((i=set_opt(fd,115200,8,'N',1))<0){
perror("set_opt error");
return;
}
printf("fd=%d\n",fd);
fd = 3;
nread = read(fd,buff,8);
printf("nread=%d,%s\n",nread,buff);
close(fd);
return;
}
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#define DEV_NAME "/dev/ttyUSB0"
static int iFd = -1;
int testi=0;
//不调用
int recv_protocol(int uart_fd,char* buf, int n)
{
int rc, i;
int count = 0;
while(read(uart_fd, buf, n) >0)
{
printf("recv serial----rc is %d testi is %d \n ",rc,testi);
for(i = 0; i < n; i++)
printf(" %x ", buf[i]);
}
printf("no while !!!\n");
for(i = 0; i < n; i++)
printf(" %x ", buf[i]);
printf("\n");
tcflush(uart_fd, TCIOFLUSH);
return rc;
}
// 等待时间 串口描述符 读取的buff
int Select_Tart_Read(struct timeval tv,int uart_fd,char* buff)
{
memset(buff,0,sizeof(char)*8);
fd_set rfds;
int retval=0;
int i;
FD_ZERO(&rfds);
FD_SET(uart_fd, &rfds);
retval=select(uart_fd + 1, &rfds, NULL, NULL, &tv);
if(retval<0)
{
perror("select error\n");
}
else
{
if( retval && FD_ISSET(uart_fd, &rfds) )
{
testi++;
printf("FD_ISSET!\n");
int rc=read(uart_fd, buff, 8);
if(rc>0)
{
printf("recv serial----rc is %d testi is %d \n ",rc,testi);
for(i = 0; i < 8; i++)
printf(" %x ", buff[i]);
printf("\n");
return rc;
}
}
}
return 0;
}
int monitor_routine( int uart_fd)
{
int i;
printf("in monitor_routine\n");
char rebuff[8];//设置最大的数据长度为8个
memset(rebuff,0,sizeof(char)*8);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 10000;
int retval;
unsigned char commbuff[8];//设置最大的数据长度为8个
memset(commbuff,0,sizeof(unsigned char)*8);
while(1)
{
//printf("retval is %d\n",retval);
if(Select_Tart_Read(tv,uart_fd,rebuff)>0)//
{
printf("in while Read!\n");
for(i = 0; i < 8; i++)
printf(" %x ", rebuff[i]);
printf("\n");
}
}
return 0;
}
int open_init_serial_port(void)
{
iFd = open(DEV_NAME, O_RDWR | O_NOCTTY);
if(iFd < 0) {
perror(DEV_NAME);
printf(" open %s faurel!\n",DEV_NAME);
return -1;
}
else
printf(" open %s !\n",DEV_NAME);
tcgetattr(iFd, &opt);
cfsetispeed(&opt, B9600);
cfsetospeed(&opt, B9600);
if (tcgetattr(iFd, &opt)<0) {
return -1;
}
opt.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
opt.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
opt.c_oflag &= ~(OPOST);
opt.c_cflag &= ~(CSIZE | PARENB);
opt.c_cflag |= CS8;
opt.c_cc[VMIN] = 255;
opt.c_cc[VTIME] = 150;
if (tcsetattr(iFd, TCSANOW, &opt)<0) {
return -1;
}
tcflush(iFd,TCIOFLUSH);
return 0;
}
int main_2(int argc, char *argv[])
{
int i;
int len;
unsigned char ucBuf[100];
int ret;
ret = open_init_serial_port();
if(ret < 0)
{
printf("open %s error\n",DEV_NAME);
}
for (i = 0; i < 100; i++){
ucBuf[i] = 0xff - i;
}
char buff[6];
buff[0]=0x9F;buff[1]=0x05;buff[2]=0x05;buff[3]=0x05;buff[4]=0x05;buff[5]=0x05;
printf("buff is :\n");
for(i=0;i<6;i++)
printf("0x%x ",buff[i]);
printf("\n");
printf("write buff!!!");
len = write(iFd, buff, 6);
if(len < 0) {
printf(" write error ! \n");
return -1;
}
int value;
printf("in main monitor_routine\n");
monitor_routine(iFd);
printf("\n");
close(iFd);
return 0;
}