示例代碼

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;
}