布施
布施

串口编程--RS485

最近被安排实现 linux rs485 串口通信。期间遇到各种问题，现在加以分析总结。

一、硬件相关 

1.1 单工、半双工、全双工

首先，我使用的是芯片为 SP3485E 为半双工通信。那么先要明确什么是单工、半双工、全双工。
单工数据传输只支持数据在一个方向上传输；
半双工数据传输允许数据在两个方向上传输，但是，在某一时刻，只允许数据在一个方向上传输，它实际上是一种切换方向的单工通信；
全双工数据通信允许数据同时在两个方向上传输，因此，全双工通信是两个单工通信方式的结合，它要求发送设备和接收设备都有独立的接收和发送能力。 
网卡的全双工（Full Duplex）是指网卡在发送数据的同时也能够接收数据，两者同步进行，这好像我们平时打电话一样，说话的同时也能够听到对方的声音。目前的网卡一般都支持全双工。


提到全双工，就不能不提与之密切对应的另一个概念，那就是“半双工（Half Duplex）”，
所谓半双工就是指一个时间段内只有一个动作发生，举个简单例子，一条窄窄的马路，同时只能有一辆车通过，
当目前有两量车对开，这种情况下就只能一辆先过，等到头儿后另一辆再开，这个例子就形象的说明了半双工的原理。早期的对讲机、以及早期集线器等设备都是基于半双工的产品。随着技术的不断进步，半双工会逐渐退出历史舞台。

1.2 关于RS485通信

RS232 标准是诞生于 RS485 之前的，但是 RS232 有几处不足的地方：
接口的信号电平值较高，达到十几 V，使用不当容易损坏接口芯片，电平标准也与TTL 电平不兼容。
传输速率有局限，不可以过高，一般到一两百千比特每秒(Kb/s)就到极限了。
接口使用信号线和 GND 与其它设备形成共地模式的通信，这种共地模式传输容易产生干扰，并且抗干扰性能也比较弱。
传输距离有限，最多只能通信几十米。
通信的时候只能两点之间进行通信，不能够实现多机联网通信。

针对 RS232 接口的不足，就不断出现了一些新的接口标准，RS485 就是其中之一，它具备以下的特点：
采用差分信号。我们在讲 A/D 的时候，讲过差分信号输入的概念，同时也介绍了差分输入的好处，最大的优势是可以抑制共模干扰。
尤其当工业现场环境比较复杂，干扰比较多时，采用差分方式可以有效的提高通信可靠性。RS485 采用两根通信线，通常用 A 和 B 或者 D+和 D-来表示。逻辑“1”以两线之间的电压差为+(0.2~6)V 表示，逻辑“0”以两线间的电压差为-(0.2~6)V 来表示，是一种典型的差分通信。
RS485 通信速率快，最大传输速度可以达到 10Mb/s 以上。
RS485 内部的物理结构，采用的是平衡驱动器和差分接收器的组合，抗干扰能力也大大增加。
传输距离最远可以达到 1200 米左右，但是它的传输速率和传输距离是成反比的，只有在 100Kb/s 以下的传输速度，才能达到最大的通信距离，如果需要传输更远距离可以使用中继。
可以在总线上进行联网实现多机通信，总线上允许挂多个收发器，从现有的 RS485芯片来看，有可以挂 32、64、128、256 等不同个设备的驱动器。
RS485 的接口非常简单，与 RS232 所使用的 MAX232 是类似的，只需要一个 RS485转换器，就可以直接与单片机的 UART 串口连接起来，并且使用完全相同的异步串行通信协议。
但是由于 RS485 是差分通信，因此接收数据和发送数据是不能同时进行的，也就是说它是一种半双工通信。RS485为差分通信：最大的优势是可以抑制共模干扰。

1.3  关于sp3485硬件分析

串口编程--RS485_第1张图片

                                                                上图为SP3485原理图 

（1）引脚说明： 

Pin1 - RO： 接收器输出

Pin2 - RE#：接收器输出使能 （低电平有效）

Pin3 - DE： 驱动器输出使能 （高电平有效）

Pin4 - DI： 驱动器输入

Pin5 - GND： 连接地

Pin6 - A： 驱动器输出/接收器输入 （同相）

Pin7 - B： 驱动器输出/接收器输入 （反相）

Pin8 - Vcc       

注意将AB间120欧姆去掉，如果采用阻抗匹配的电缆，300米以内几乎可以不用加终端电阻。加终端电阻的缺点就是增大了线路的无用功耗，尤其是电池系统供电时，降低了电池的续航能力。

PS: 我一开始没有将它去掉，导致只能发送数据，无法接收数据。

（2）电气特性

RS-232电平的电气特性

EIA电平（串口）

逻辑1：-3V~-15V

逻辑0：+3V~+15V


TTL电平（TPAD）

逻辑1：+2V~+5V

逻辑0：+0V~+0.8V


接收数据：EIA->TTL  232转TTL

发送数据：TTL->EIA  TTL转232

 

串口异步通信的重要参数：

波特率: bps (bit per second)

数据位的个数： 5 6 7 8

校验方式： 奇校验 偶校验 无校验

停止位： 1bit  2bit


RS485电平 和RS422电平 由于两者均采用 差分传输（平衡传输）的方式，所以他们的电平方式，一般有两个引脚 A,B

发送端 AB间的电压差

＋2 ～ ＋6v 1

－2 ～ －6v   0

接收端 AB间的电压差

大于 ＋200mv   1

小于 －200mv 0


定义逻辑1为B>A的状态

定义逻辑0为A>B的状态

AB之间的电压差不小于200mv


一对一的接头的情况下：

RS232 可做到双向传输，全双工通讯   最高传输速率 20kbps

422    只能做到单向传输，半双工通讯，最高传输速率10Mbps

485    双向传输，半双工通讯, 最高传输速率10Mbps

（3）串行数据的格式

异步串行数据的一般格式是：起始位+数据位+停止位，(8-N-1格式) 其中起始位1 位，数据位可以是5、6、7、8位，停止位可以是1、1.5、2位。

起始位是一个值为0的位，所以对于正逻辑的TTL电平，起始位是一位时间的低电平；停止位是值为1的位，所以对于正逻辑的TTL电平，停止位是高电平。线路路空闲或者数据传输结束，对于正逻辑的TTL电平，线路总是1。对于负逻辑(如RS-232电平)则相反。

例如，对于16进制数据55aaH，当采用8位数据位、1位停止位传输时，它在信号线上的波形如图1(TTL电平)和图2(RS-232电平)所示。 （先传第一个字节55，再传第二个字节aa，每个字节都是从低位向高位逐位传输）

串口编程--RS485_第2张图片
                   图1 TTL电平的串行数据帧格式(55aah)

串口编程--RS485_第3张图片

                    图2 RS-232电平的串行数据帧格式(55aah)

（4）根据波形图计算波特率

如图3是图1在示波器中的显示示意，其中灰色线是示波器的时间分度线，此时假设是200us/格。
串口编程--RS485_第4张图片
                     图3 波特率计算示意图

可以看了，第一个字节的10位(1位起始位，8位数据位和1位停止位)共占约1.05ms，这样可计算出其波特率约为：

10bit / 1.05ms X 1000 ≈ 9600 bit/s

如果上图中的时间轴是100us/格，同样可以计算出波特率应是19200bit/s。

当通讯不正常，又能观察到波形时，就可根据上述方法，从波形图计算一下波特率是否正确。

（5）根据波形图判断RS-485收发数据的正确与否

RS-485是一种半双工的串行通讯方式（RS-422为全双工），485电平芯片所以要正确接收和发送数据，必需保证控制信号和数据的同步，否则要么发送数据丢失，要么接收数据可能丢失。

RS-485发送数据时的正确时序如图4所示。

串口编程--RS485_第5张图片
              图4 RS-485的正确发送数据时序

在图4中，发送控制信号的宽度基本与数据信号的宽度一致，所以能保证发送数据的正确和发送后及时转为接收。

图5 和图6 分别是控制信号太短和控制信号太长的情况。

串口编程--RS485_第6张图片

                图5 RS-485控制信号太短时的时序

串口编程--RS485_第7张图片

                图6 RS-485控制信号太短时的时序

在图5中，由于控制信号关闭过早，则第二个字节的后两位将发送错误；在图6中，由于控制信号关闭过迟，使485芯片在发送数据后，不能及时转到接收状态，此时总线若有数据过来，则本单元将不能正确接收。

总结：只要掌握上述波形分析方法，任何异步串行数据的接收和发送问题，基本都可以得到解决。

二、串口通信

2.1 串口的操作一般都通过四个步骤来完成：

1、打开串口
2、配置串口：对串口的波特率、数据位、停止位、校验码、等进行设置。
3、读写串口
4、关闭串口

2.2 完整代码：

#include      //文件控制定义  
#include      //标准输入输出定义  
#include      //标准函数库定义  
#include     //Unix标准函数定义   
#include      //错误好定义  
#include    //POSIX终端控制定义  
#include    //ioctl函数定义  
#include      //字符操作  
#include     
#include    
#include   
#include   
  
//时间戳  
long long getSystemTime() {  
    struct timeb t;  
    ftime(&t);  
    return 1000 * t.time + t.millitm;  
}  
  
 long long start;  
 long long end;  
  
  
//定义互斥量  
pthread_mutex_t mutex;  
int fd_gpio;  
  
struct termios newtio, oldtio;  
typedef struct {  
        int  pin_idx;  
        int  pin_dir;  
        int  pin_sta;  
} davinci_gio_arg;  
  
typedef enum {  
        AT91PIO_DIR_OUT = 0,  
        AT91PIO_DIR_INP   
} davinci_gio_dir;  
//驱动判断输入输出模式  
  
davinci_gio_arg arg;  
  
#define DEV_PIO_LED "/dev/pio"  
// 需要手动添加设备号 mknod /dev/pio c 203 0  
#define PIO_NUM 47  
// 47pin 为控制输入输出方向引脚  
#define DEV_UART    "/dev/ttyS1"  
// /dev/ttyS1 为串口设备  
  
#define IOCTL_PIO_SETDIR    1       //set gpio direct  
#define IOCTL_PIO_GETDIR    2       //get gpio direct  
#define IOCTL_PIO_SETSTA    3       //set gpio status  
#define IOCTL_PIO_GETSTA    4       //get gpio status  
  
//保存信息  
int log_init( const char *strFileName )  
{  
    int fdLog = -1;  
  
    if( -1 == (fdLog = open( strFileName,  O_CREAT|O_TRUNC ) ) )  
    {  
    }  
    close( fdLog );  
}  
  
int log_out( const char *strFileName, const char * szLog )  
{  
    int fdLog = -1;  
  
    if( -1 == ( fdLog = open( strFileName,  O_CREAT|O_WRONLY|O_APPEND ) ) )  
    {  
        printf( "LOG (%s) open error!\n", strFileName );  
        return -1;  
    }  
  
    write( fdLog, szLog, strlen( szLog ) );  
  
    close( fdLog );  
  
    return 0;  
}  
  
//配置串口  
/* 参数说明：fd 设备文件描述符，nspeed 波特率，nbits 数据位数（7位或8位）， 
            parity 奇偶校验位（'n'或'N'为无校验位，'o'或'O'为偶校验，'e'或'E'奇校验）， 
            nstop 停止位（1位或2位） 
  成功返回1，失败返回-1。  
*/  
int set_com_opt( int fd, int nspeed, int nbits, char parity, int nstop )  
{  
    char szTmp[128];  
//打印配置信息  
    sprintf( szTmp, "set_com_opt - speed:%d,bits:%d,parity:%c,stop:%d\n",   
                nspeed, nbits, parity, nstop );  
      
    log_out( "./485.log", szTmp );  
    //保存并测试现在有串口参数设置，在这里如果串口号等出错，会有相关的出错信息   
    if( tcgetattr( fd, &oldtio ) != 0 )  
    {  
      
    sprintf( szTmp, "SetupSerial 1" );  
  
    log_out( "./485.log", szTmp );  
  
        perror( "SetupSerial 1" );  
        return -1;  
    }  
  
    //修改输出模式，原始数据输出  
    bzero( &newtio, sizeof( newtio ));  
    newtio.c_cflag &=~(OPOST);  
  
    //屏蔽其他标志位  
    newtio.c_cflag |= (CLOCAL | CREAD );  
    newtio.c_cflag &= ~CSIZE;  
      
    //设置数据位  
    switch( nbits )  
    {  
    case 7:  
        newtio.c_cflag |= CS7;  
        break;  
    case 8:  
        newtio.c_cflag |= CS8;  
        break;  
    default:  
        perror("Unsupported date bit!\n");  
        return -1;  
    }  
      
    //设置校验位  
    switch( parity )  
    {  
    case 'n':  
    case 'N':  //无奇偶校验位  
        newtio.c_cflag &= ~PARENB;  
        newtio.c_iflag &= ~INPCK;  
        break;  
    case 'o':  
    case 'O':    //设置为奇校验  
        newtio.c_cflag |= ( PARODD | PARENB );  
        newtio.c_iflag |= ( INPCK | ISTRIP );  
        break;  
    case 'e':  
    case 'E':  //设置为偶校验  
        newtio.c_iflag |= ( INPCK |ISTRIP );  
        newtio.c_cflag |= PARENB;  
        newtio.c_cflag &= ~PARODD;  
        break;  
    default:  
        perror("unsupported parity\n");  
        return -1;  
    }  
  
    //设置停止位  
    switch( nstop )   
    {  
    case 1:   
        newtio.c_cflag &= ~CSTOPB;  
        break;  
    case 2:  
        newtio.c_cflag |= CSTOPB;  
        break;  
    default :  
        perror("Unsupported stop bit\n");  
        return -1;  
    }  
  
    //设置波特率  
    switch( nspeed )  
    {  
    case 2400:  
        cfsetispeed( &newtio, B2400 );  
        cfsetospeed( &newtio, B2400 );  
        break;  
    case 4800:  
        cfsetispeed( &newtio, B4800 );  
        cfsetospeed( &newtio, B4800 );  
        break;    
    case 9600:  
        cfsetispeed( &newtio, B9600 );  
        cfsetospeed( &newtio, B9600 );  
        break;    
    case 115200:  
        cfsetispeed( &newtio, B115200 );  
        cfsetospeed( &newtio, B115200 );  
        break;  
    case 460800:  
        cfsetispeed( &newtio, B460800 );  
        cfsetospeed( &newtio, B460800 );  
        break;  
    default:      
        cfsetispeed( &newtio, B9600 );  
        cfsetospeed( &newtio, B9600 );  
        break;  
    }  
  
    //设置等待时间和最小接收字符  
    newtio.c_cc[VTIME] = 0;    
    newtio.c_cc[VMIN] = 0;     
//VTIME=0，VMIN=0，不管能否读取到数据，read都会立即返回。  
  
//输入模式  
    newtio.c_lflag &= ~(ICANON|ECHO|ECHOE|ISIG);  
//设置数据流控制  
    newtio.c_iflag &= ~(IXON|IXOFF|IXANY); //使用软件流控制  
//如果发生数据溢出，接收数据，但是不再读取 刷新收到的数据但是不读  
    tcflush( fd, TCIFLUSH );   
//激活配置 (将修改后的termios数据设置到串口中）  
    if( tcsetattr( fd, TCSANOW, &newtio ) != 0 )  
    {  
    sprintf( szTmp, "serial set error!\n" );  
  
    log_out( "./485.log", szTmp );  
        perror( "serial set error!" );  
        return -1;  
    }  
  
    log_out( "./485.log", "serial set ok!\n" );  
    return 1;  
}  
  
//打开串口并返回串口设备文件描述  
int open_com_dev( char *dev_name )  
{  
    int fd;  
        char szTmp[128];  
  
    log_init( "./485.log" );  
    if(( fd = open( dev_name, O_RDWR|O_NOCTTY|O_NDELAY)) == -1 )  
    {  
  
        perror("open\n");  
        //printf("Can't open Serial %s Port!\n", dev_name );  
        sprintf( szTmp, "Can't open Serial %s Port!\n", dev_name );  
          
        log_out( "./485.log", szTmp );  
  
        return -1;  
    }  
  
    sprintf( szTmp, "open %s ok!\n", dev_name );  
    log_out( "./485.log", szTmp );  
  
    if(fcntl(fd,F_SETFL,0)<0)  
    {  
        printf("fcntl failed!\n");  
    }  
    //printf("Open %s ok\n",dev_name );  
    return fd;  
}  
  
//发送云台数据  
void* task(void* p)  
{  
    char ch;  
    int j = 0, nread = 0;  
    while(scanf ("%s", &ch) ==1)  
    {  
        pthread_mutex_lock (&mutex);  
        arg.pin_sta = 1;     //设为高电平 发送态  
        ioctl(fd_gpio, IOCTL_PIO_SETSTA, &arg);  
          
        int fd = open_com_dev( DEV_UART );  
        if( fd < 0 )  
        {  
            printf( "open UART device error! %s\n", DEV_UART );  
        }  
        else  
        set_com_opt(fd, 2400,8,'n',1);  
        //set_com_opt(fd, 9600,8,'n',1);  
  
        char buff[] = {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11};  
        int len = write(fd,buff,sizeof (buff));  
        if (len < 0)  
        {  
            perror ("write err");  
            exit (-1);  
        }  
        //打印发送数据  
        printf ("sead: ");  
        for (j = 0; j < sizeof(buff); j++)  
        {  
            printf ("%02X ", buff[j]);  
        }  
        printf ("\n");   
      
        //清除scanf缓冲区  
        scanf ("%*[^\n]");  
        scanf ("%*c");  
        close (fd);  
        pthread_mutex_unlock (&mutex);  
    }  
}  
  
//单片机数据收发  
void* task1(void* p)  
{  
    char buf[255];  
    int j = 0, res = 0, nread = 0, i = 0;  
    while (1) {  
    pthread_mutex_lock (&mutex);  
  
    arg.pin_sta = 1;     //设为高电平 发送态  
    ioctl(fd_gpio, IOCTL_PIO_SETDIR, &arg);  
    //打开/dev/pio   
    int fd_s = open_com_dev( DEV_UART );  
    if( fd_s < 0 )  
    {  
        printf( "open UART device error! %s\n", DEV_UART );  
    }  
    else  
        set_com_opt(fd_s, 2400,8,'n',1);  
        //set_com_opt(fd_s, 9600,8,'n',1);  
    
    //发送数据  
    char buff[] = {0xaa,0x55,0x05,0x00,0x33,0x44,0x14,0x90,0x00};  
    int len = write(fd_s,buff,sizeof (buff));  
    if (len < 0)  
    {  
        perror ("write err");  
        exit (-1);  
    }  
    printf ("sead: ");  
    for (j = 0; j < sizeof (buff); j++)  
    {  
        printf ("%02X ", buff[j]);  
    }  
    printf ("\n");  
    
    close (fd_s);  
    start=getSystemTime();  
    arg.pin_sta = 0;   //设为低电平 接收态    
    ioctl(fd_gpio, IOCTL_PIO_SETSTA, &arg);  
    int fd_r=open_com_dev( DEV_UART );  
    if( fd_r < 0 )  
    {  
        printf( "open UART device error! %s\n", DEV_UART );  
    }  
    else  
        set_com_opt(fd_r, 2400,8,'n',1);  
        //set_com_opt(fd_r, 9600,8,'n',1);  
  
    //执行select  
    fd_set rd;    
    FD_ZERO(&rd);    
    FD_SET(fd_r, &rd);    
    if ((res = select (fd_r+1,&rd, NULL, NULL, NULL) )< 0)  
    {  
        perror ("read err");  
        exit (-1);  
    }  
  
    memset (buf, 0, sizeof (buf));  
    if (FD_ISSET (fd_r, &rd))  
    {  
        //接收数据 8 8 2   
        int res1 = 0;  
        while ((nread = read(fd_r, buf, 8)) > 0)  
        {  
            //打印接收数据  
            for (i = 0; i < nread; i++)  
            {  
                printf ("%02X ", buf[i]);  
            }  
            //退出循环， 这里有点疑问  
            res1 += nread;  
            if (res1 == 18)  
            {  
                memset (buf, 0, sizeof (buf));  
                printf ("\n");  
                break;  
            }  
        }  
    }  
    close (fd_r);   
    pthread_mutex_unlock (&mutex);  
    end=getSystemTime();  
    printf("time: %lld ms\n", end-start);  
    usleep (200000);  
    }  
}  
  
int main (void)  
{  
  
    int error = 0, error1 = 0;  
    arg.pin_idx = PIO_NUM;          
    arg.pin_dir = AT91PIO_DIR_OUT;  
    //打开/dev/pio设备  
    fd_gpio = open(DEV_PIO_LED, O_RDWR);   
    if(fd_gpio < 0)  
    {  
        perror("fd_gpio open err");  
        exit (-1);  
    }  
  
    //初始化互斥量  
    pthread_mutex_init (&mutex, 0);  
    pthread_t tid, tid1;  
    //创建线程  
    error = pthread_create (&tid, NULL, task, NULL);  
    error1 = pthread_create (&tid1, NULL, task1, NULL);  
    //等待线程结束  
    pthread_join (tid, NULL);  
    pthread_join (tid1, NULL);  
    //销毁互斥量  
    pthread_mutex_destroy(&mutex);  
    //关闭设备    
    close (fd_gpio);  
    return 0;  
}
执行结果：
 串口编程--RS485_第8张图片

三、串口通信总结

虽然以上代码只有三百多行，但是其包含的内容确是很多的，下面就一一的来总结。

一般招聘信息上 都会有这样一项要求。了解Modbus基于RS485,RS232,以太网等总线的通讯协议，熟练操作Modbus相关软件。

上面我们对RS485，RS232硬件做了分析，接下来我们看一下软件上面该如何处理。
主要分为下面部分来讲：

（1）串口编程详解

参看：Linux串口编程详解 
参看：Linux下的串口编程(二）
参看：Linux 串口编程

前面已经提到过Linux下皆为文件，这当然也包括我们今天的主角 UART0 串口。因此对他的一切操作都和文件的操作一样（涉及到了open,read,write,close等文件的基本操作）。

（一）Linux下的串口编程又那几部分组成

 

 

1.    打开串口

2.    串口初始化

3.    读串口或写串口

4.    关闭串口

（二）串口的打开

既然串口在linux中被看作了文件，那么在对文件进行操作前先要对其进行打开操作。

1.在Linxu中，串口设备是通过串口终端设备文件来访问的

即通过访问/dev/ttyS0,/dev/ttyS1,/dev/ttyS2这些设备文件实现对串口的访问。

==============================

这里有个问题：

你怎么知道访问的是哪个串口？

可以进行一下测试，echo hello > /dev/ttyS0  

看看是否有hello输出。

如果串口使用不对，会出现错误:

setup serial:bad file descriptor
set parity Error

==============================

2.调用open()函数来代开串口设备，对于串口的打开操作，必须使用O_NOCTTY参数。

l  O_NOCTTY:表示打开的是一个终端设备，程序不会成为该端口的控制终端。如果不使用此标志，任务一个输入(eg:键盘中止信号等)都将影响进程。

l  O_NDELAY:表示不关心DCD信号线所处的状态（端口的另一端是否激活或者停止）。不说明这个标志的话，该程序就会在DCD信号线为低电平时停止。

3.打开串口模块有那及部分组成

1> 调用open()函数打开串口，获取串口设备文件描述符

2> 获取串口状态，判断是否阻塞

3> 测试打开的文件描述符是否为终端设备

 

4程序:

[cpp]  view plain  copy
  1. /***************************************************************** 
  2. * 名称：                    UART0_Open 
  3. * 功能：                    打开串口并返回串口设备文件描述 
  4. * 入口参数：            fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2) 
  5. * 出口参数：            正确返回为1，错误返回为0 
  6. *****************************************************************/  
  7. int UART0_Open(int fd,char* port)  
  8. {  
  9.    
  10.       fd = open( port, O_RDWR|O_NOCTTY|O_NDELAY);  
  11.       if (FALSE == fd)  
  12.              {  
  13.                     perror("Can't Open Serial Port");  
  14.                     return(FASLE);  
  15.              }  
  16.   //判断串口的状态是否为阻塞状态                              
  17.   if(fcntl(fd, F_SETFL, 0) < 0)  
  18.       {  
  19.              printf("fcntl failed!/n");  
  20.            return(FALSE);  
  21.       }       
  22.   else  
  23.   {  
  24.        printf("fcntl=%d/n",fcntl(fd, F_SETFL,0));  
  25.   }  
  26.   //测试是否为终端设备      
  27.   if(0 == isatty(STDIN_FILENO))  
  28.       {  
  29.              printf("standard input is not a terminal device/n");  
  30.         return(FALSE);  
  31.       }  
  32.   else  
  33.       {  
  34.            printf("isatty success!/n");  
  35.       }         
  36.   printf("fd->open=%d/n",fd);  
  37.   return fd;  
  38. }  

（三）串口的初始化

1.    在linux中的串口初始化和前面的串口初始化一样。

需要设置串口波特率，数据流控制，帧的格式(即数据位个数，停止位，校验位,数据流控制)

2.    串口初始化模块有那几部分组成：

1> 设置波特率

2> 设置数据流控制

3> 设置帧的格式(即数据位个数，停止位，校验位)


说明：

1> 设置串口参数时要用到termios结构体,因此先要通过函数 tcgettattr(fd,&options)获得串口指向termios结构的指针。termios.h头文件中定义的termios结构，如下：



[cpp]  view plain  copy
  1. struct termios  
  2. {  
  3.    tcflag_t  c_iflag;   //输入模式标志  
  4.    tcflag_t  c_oflag;  //输出模式标志  
  5.    tcflag_t  c_cflag;  //控制模式标志  
  6.    tcflag_t  c_lflag;   //本地模式标志  
  7.    cc_t   c_line;              //line discipline  
  8.    cc_t   c_cc[NCC];    //control characters  
  9. }  

2> 通过cfsetispeed函数和cfsetospeed函数用来设置串口的输入/输出波特率。一般情况下，输入和输出波特率相等的。

3> 设置数据位可以通过修改termios机构体中c_flag来实现。其中CS5,CS6,CS7,CS8对应数据位的5，6，7，8。在设置数据位时，必须要用CSIZE做位屏蔽。

以下是几个数据位、停止位和校验位的设置方法：（以下均为1位停止位）

[cpp]  view plain  copy
  1. 8位数据位、无校验位：  
  2. Opt.c_cflag &= ~PARENB;  
  3. Opt.c_cflag &= ~CSTOPB;  
  4. Opt.c_cflag &= ~CSIZE;  
  5. Opt.c_cflag |= CS8;  
  6. 7位数据位、奇校验：  
  7. Opt.c_cflag |= PARENB;  
  8. Opt.c_cflag |= PARODD;  
  9. Opt.c_cflag &= ~CSTOPB;  
  10. Opt.c_cflag &= ~CSIZE;  
  11. Opt.c_cflag |= CS7;  
  12. 7位数据位、偶校验：  
  13. Opt.c_cflag |= PARENB;  
  14. Opt.c_cflag &= ~PARODD;  
  15. Opt.c_cflag &= ~CSTOPB;  
  16. Opt.c_cflag &= ~CSIZE;  
  17. Opt.c_cflag |= CS7;  
  18. 7位数据位、Space校验：  
  19. Opt.c_cflag &= ~PARENB;  
  20. Opt.c_cflag &= ~CSTOPB;  
  21. Opt.c_cflag &= ~CSIZE;  
  22. Opt.c_cflag |= CS7;  

4> 数据流控制是使用何种方法来标志数据传输的开始和结束。

5> 在设置完波特率，数据流控制，数据位，校验位，停止位，停止位后，还要设置最小等待时间和最小接收字符。

6> 在完成配置后要通过tcsetattr()函数来激活配置。

3.程序：

[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                UART0_Set 
  3. * 功能：                设置串口数据位，停止位和效验位 
  4. * 入口参数：        fd         串口文件描述符 
  5. *                              speed      串口速度 
  6. *                              flow_ctrl  数据流控制 
  7. *                           databits   数据位   取值为 7 或者8 
  8. *                           stopbits   停止位   取值为 1 或者2 
  9. *                           parity     效验类型 取值为N,E,O,,S 
  10. *出口参数：              正确返回为1，错误返回为0 
  11. *******************************************************************/  
  12. int UART0_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity)  
  13. {  
  14.      
  15.       int   i;  
  16.          int   status;  
  17.          int   speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,  
  18.           B38400, B19200, B9600, B4800, B2400, B1200, B300 };  
  19.      int   name_arr[] = {38400,  19200,  9600,  4800,  2400,  1200,  300,      38400, 19200,  9600, 4800, 2400, 1200,  300 };  
  20.            
  21.     struct termios options;  
  22.      
  23.     /*tcgetattr(fd,&options)得到与fd指向对象的相关参数，并将它们保存于options,该函数,还可以测试配置是否正确，该串口是否可用等。若调用成功，函数返回值为0，若调用失败，函数返回值为1. 
  24.     */  
  25.     if  ( tcgetattr( fd,&options)  !=  0)  
  26.        {  
  27.           perror("SetupSerial 1");      
  28.           return(FALSE);   
  29.        }  
  30.     
  31.     //设置串口输入波特率和输出波特率  
  32.     for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)  
  33.                 {  
  34.               if  (speed == name_arr[i])  
  35.               {         
  36.                           cfsetispeed(&Options, speed_arr[i]);   
  37.                           cfsetospeed(&Options, speed_arr[i]);    
  38.               }  
  39.        }       
  40.      
  41.     //修改控制模式，保证程序不会占用串口  
  42.     options.c_cflag |= CLOCAL;  
  43.     //修改控制模式，使得能够从串口中读取输入数据  
  44.     options.c_cflag |= CREAD;  
  45.     
  46.     //设置数据流控制  
  47.     switch(flow_ctrl)  
  48.     {  
  49.         
  50.        case 0 ://不使用流控制  
  51.               options.c_cflag &= ~CRTSCTS;  
  52.               break;     
  53.         
  54.        case 1 ://使用硬件流控制  
  55.               options.c_cflag |= CRTSCTS;  
  56.               break;  
  57.        case 2 ://使用软件流控制  
  58.               options.c_cflag |= IXON | IXOFF | IXANY;  
  59.               break;  
  60.     }  
  61.     //设置数据位  
  62.     options.c_cflag &= ~CSIZE; //屏蔽其他标志位  
  63.     switch (databits)  
  64.     {    
  65.        case 5    :  
  66.                      options.c_cflag |= CS5;  
  67.                      break;  
  68.        case 6    :  
  69.                      options.c_cflag |= CS6;  
  70.                      break;  
  71.        case 7    :      
  72.                  options.c_cflag |= CS7;  
  73.                  break;  
  74.        case 8:      
  75.                  options.c_cflag |= CS8;  
  76.                  break;    
  77.        default:     
  78.                  fprintf(stderr,"Unsupported data size/n");  
  79.                  return (FALSE);   
  80.     }  
  81.     //设置校验位  
  82.     switch (parity)  
  83.     {    
  84.        case 'n':  
  85.        case 'N': //无奇偶校验位。  
  86.                  options.c_cflag &= ~PARENB;   
  87.                  options.c_iflag &= ~INPCK;      
  88.                  break;   
  89.        case 'o':    
  90.        case 'O'://设置为奇校验      
  91.                  options.c_cflag |= (PARODD | PARENB);   
  92.                  options.c_iflag |= INPCK;               
  93.                  break;   
  94.        case 'e':   
  95.        case 'E'://设置为偶校验    
  96.                  options.c_cflag |= PARENB;         
  97.                  options.c_cflag &= ~PARODD;         
  98.                  options.c_iflag |= INPCK;         
  99.                  break;  
  100.        case 's':  
  101.        case 'S': //设置为空格   
  102.                  options.c_cflag &= ~PARENB;  
  103.                  options.c_cflag &= ~CSTOPB;  
  104.                  break;   
  105.         default:    
  106.                  fprintf(stderr,"Unsupported parity/n");     
  107.                  return (FALSE);   
  108.     }   
  109.     // 设置停止位   
  110.     switch (stopbits)  
  111.     {    
  112.        case 1:     
  113.                  options.c_cflag &= ~CSTOPB;   
  114.                  break;   
  115.        case 2:     
  116.                  options.c_cflag |= CSTOPB;   
  117.                          break;  
  118.        default:     
  119.                        fprintf(stderr,"Unsupported stop bits/n");   
  120.                        return (FALSE);  
  121.     }  
  122.      
  123.     //修改输出模式，原始数据输出  
  124.     options.c_oflag &= ~OPOST;  
  125.      
  126.     //设置等待时间和最小接收字符  
  127.     options.c_cc[VTIME] = 1; /* 读取一个字符等待1*(1/10)s */    
  128.     options.c_cc[VMIN] = 1; /* 读取字符的最少个数为1 */  
  129.      
  130.     //如果发生数据溢出，接收数据，但是不再读取  
  131.     tcflush(fd,TCIFLUSH);  
  132.      
  133.     //激活配置 (将修改后的termios数据设置到串口中）  
  134.     if (tcsetattr(fd,TCSANOW,&options) != 0)    
  135.     {  
  136.                perror("com set error!/n");    
  137.        return (FALSE);   
  138.     }  
  139.     return (TRUE);   
  140. }  
[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                  UART0_Init() 
  3. * 功能：                串口初始化 
  4. * 入口参数：        fd           文件描述符    
  5. *               speed     串口速度 
  6. *                              flow_ctrl   数据流控制 
  7. *               databits    数据位   取值为 7 或者8 
  8. *                           stopbits   停止位   取值为 1 或者2 
  9. *                           parity     效验类型 取值为N,E,O,,S                     
  10. * 出口参数：        正确返回为1，错误返回为0 
  11. *******************************************************************/  
  12. int UART0_Init(int fd, int speed,int flow_ctrlint databits,int stopbits,int parity)  
  13. {  
  14.     int err;  
  15.     //设置串口数据帧格式  
  16.     if (UART0_Set(fd,115200,0,8,1,'N') == FALSE)  
  17.     {                                                       
  18.         return FALSE;  
  19.     }  
  20.     else  
  21.     {  
  22.                return  TRUE;  
  23.         }  
  24. }  
注意：
如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式 (Raw Mode) 方式来通讯，设置方式如下：
options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/
options.c_oflag  &= ~OPOST;   /*Output*/

c_cc 数组的 VSTART 和 VSTOP 元素被设定成 DC1 和 DC3，代表 ASCII 标准的 XON 和 XOFF 字符，如果在传输这两个字符的时候就传不过去，需要把软件流控制屏蔽，即：
Opt.c_iflag &= ~ (IXON | IXOFF | IXANY);
有时候，在用write发送数据时没有键入回车，信息就发送不出去，这主要是因为我们在输入输出时是按照规范模式接收到回车或换行才发送，而更多情况下我们是不必键入回车或换行的。此时应转换到行方式输入，不经处理直接发送，设置如下：
Opt.c_lflag &= ~ (ICANON | ECHO | ECHOE | ISIG);
还存在这样的情况：发送字符0X0d的时候，往往接收端得到的字符是 0X0a，原因是因为在串口设置中 c_iflag 和c_oflag 中存在从 NL-CR 和 CR-NL 的映射，即串口能把回车和换行当成同一个字符，可以进行如下设置屏蔽之：
Opt.c_iflag &= ~ (INLCR | ICRNL | IGNCR);
Opt.c_oflag &= ~(ONLCR | OCRNL);

注意 tcsetattr 函数中使用的标志：
TCSANOW：立即执行而不等待数据发送或者接受完成。
TCSADRAIN：等待所有数据传递完成后执行。
TCSAFLUSH：刷新输入和输出缓冲区,使之变化。

（四）串口的读写函数

读写串口是通过使用read函数和write函数来实现的。程序：

[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                  UART0_Recv 
  3. * 功能：                接收串口数据 
  4. * 入口参数：        fd                  :文件描述符     
  5. *                              rcv_buf     :接收串口中数据存入rcv_buf缓冲区中 
  6. *                              data_len    :一帧数据的长度 
  7. * 出口参数：        正确返回为1，错误返回为0 
  8. *******************************************************************/  
  9. int UART0_Recv(int fd, char *rcv_buf,int data_len)  
  10. {  
  11.     int len,fs_sel;  
  12.     fd_set fs_read;  
  13.      
  14.     struct timeval time;  
  15.      
  16.     FD_ZERO(&fs_read);  
  17.     FD_SET(fd,&fs_read);  
  18.      
  19.     time.tv_sec = 10;  
  20.     time.tv_usec = 0;  
  21.      
  22.     //使用select实现串口的多路通信  
  23.     fs_sel = select(fd+1,&fs_read,NULL,NULL,&time);  
  24.     if(fs_sel)  
  25.        {  
  26.               len = read(fd,data,data_len);  
  27.               return len;  
  28.        }  
  29.     else  
  30.        {  
  31.               return FALSE;  
  32.        }       
  33. }  
[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                UART0_Send 
  3. * 功能：                发送数据 
  4. * 入口参数：        fd                  :文件描述符     
  5. *                              send_buf    :存放串口发送数据 
  6. *                              data_len    :一帧数据的个数 
  7. * 出口参数：        正确返回为1，错误返回为0 
  8. *******************************************************************/  
  9. int UART0_Send(int fd, char *send_buf,int data_len)  
  10. {  
  11.     int len = 0;  
  12.      
  13.     len = write(fd,send_buf,data_len);  
  14.     if (len == data_len )  
  15.        {  
  16.               return len;  
  17.        }       
  18.     else     
  19.         {  
  20.                  
  21.                 tcflush(fd,TCOFLUSH);  
  22.                 return FALSE;  
  23.         }  
  24.     }  

（五）关闭串口

在完成对串口设备的操作后，要调用close函数关闭该文件描述符。程序：
[cpp]  view plain  copy
  1. /****************************************************** 
  2. * 名称：                UART0_Close 
  3. * 功能：                关闭串口并返回串口设备文件描述 
  4. * 入口参数：        fd    :文件描述符    
  5. * 出口参数：        void 
  6. *******************************************************************/  
  7.    
  8. void UART0_Close(int fd)  
  9. {  
  10.     close(fd);  
  11. }  

（六）附录

[cpp]  view plain  copy
  1. c_cflag用于设置控制参数，除了波特率外还包含以下内容：   
  2. EXTA         External rate clock  
  3. EXTB         External rate clock  
  4. CSIZE         Bit mask for data bits  
  5. CS5         5个数据位  
  6. CS6         6个数据位  
  7. CS7         7个数据位  
  8. CS8         8个数据位  
  9. CSTOPB         2个停止位（清除该标志表示1个停止位  
  10. PARENB         允许校验位  
  11. PARODD         使用奇校验（清除该标志表示使用偶校验）  
  12. CREAD         Enable receiver  
  13. HUPCL         Hangup (drop DTR) on last close  
  14. CLOCAL         Local line – do not change “owner” of port  
  15. LOBLK         Block job control outpu  
  16. c_cflag标志可以定义CLOCAL和CREAD，这将确保该程序不被其他端口控制和信号干扰，同时串口驱动将读取进入的数据。CLOCAL和CREAD通常总是被是能的。  
  17.   
  18. c_lflag用于设置本地模式，决定串口驱动如何处理输入字符，设置内容如下：  
  19. ISIG            Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals   
  20. ICANON         Enable canonical input (else raw)   
  21. XCASE         Map uppercase \lowercase (obsolete)   
  22. ECHO         Enable echoing of input characters   
  23. ECHOE         Echo erase character as BS-SP-BS   
  24. ECHOK         Echo NL after kill character   
  25. ECHONL         Echo NL   
  26. NOFLSH         Disable flushing of input buffers after interrupt or quit characters   
  27. IEXTEN         Enable extended functions   
  28. ECHOCTL         Echo control characters as ^char and delete as ~?   
  29. ECHOPRT         Echo erased character as character erased   
  30. ECHOKE         BS-SP-BS entire line on line kill   
  31. FLUSHO         Output being flushed   
  32. PENDIN         Retype pending input at next read or input char   
  33. TOSTOP         Send SIGTTOU for background output  
  34.   
  35. c_iflag用于设置如何处理串口上接收到的数据，包含如下内容：  
  36. INPCK         Enable parity check   
  37. IGNPAR         Ignore parity errors   
  38. PARMRK      Mark parity errors   
  39. ISTRIP         Strip parity bits   
  40. IXON         Enable software flow control (outgoing)   
  41. IXOFF         Enable software flow control (incoming)   
  42. IXANY         Allow any character to start flow again   
  43. IGNBRK         Ignore break condition   
  44. BRKINT         Send a SIGINT when a break condition is detected   
  45. INLCR         Map NL to CR   
  46. IGNCR         Ignore CR   
  47. ICRNL         Map CR to NL   
  48. IUCLC         Map uppercase to lowercase   
  49. IMAXBEL      Echo BEL on input line too long  
  50.   
  51. c_oflag用于设置如何处理输出数据，包含如下内容：  
  52. OPOST         Postprocess output (not set = raw output)   
  53. OLCUC         Map lowercase to uppercase   
  54. ONLCR         Map NL to CR-NL   
  55. OCRNL         Map CR to NL   
  56. NOCR         No CR output at column 0   
  57. ONLRET      NL performs CR function   
  58. OFILL         Use fill characters for delay   
  59. OFDEL         Fill character is DEL   
  60. NLDLY         Mask for delay time needed between lines   
  61. NL0            No delay for NLs   
  62. NL1            Delay further output after newline for 100 milliseconds   
  63. CRDLY      Mask for delay time needed to return carriage to left column   
  64. CR0            No delay for CRs   
  65. CR1            Delay after CRs depending on current column position   
  66. CR2            Delay 100 milliseconds after sending CRs   
  67. CR3            Delay 150 milliseconds after sending CRs   
  68. TABDLY      Mask for delay time needed after TABs   
  69. TAB0            No delay for TABs   
  70. TAB1         Delay after TABs depending on current column position   
  71. TAB2         Delay 100 milliseconds after sending TABs   
  72. TAB3         Expand TAB characters to spaces   
  73. BSDLY      Mask for delay time needed after BSs   
  74. BS0         No delay for BSs   
  75. BS1         Delay 50 milliseconds after sending BSs   
  76. VTDLY      Mask for delay time needed after VTs   
  77. VT0         No delay for VTs   
  78. VT1         Delay 2 seconds after sending VTs   
  79. FFDLY      Mask for delay time needed after FFs   
  80. FF0         No delay for FFs   
  81. FF1         Delay 2 seconds after sending FFs  
  82.   
  83. c_cc定义了控制字符，包含以下内容：  
  84. VINTR  Interrupt  CTRL-C   
  85. VQUIT  Quit    CTRL-Z   
  86. VERASE   Erase    Backspace (BS)   
  87. VKILL   Kill-line   CTRL-U   
  88. VEOF   End-of-file   CTRL-D   
  89. VEOL   End-of-line   Carriage return (CR)   
  90. VEOL2   Second    end-of-line Line feed (LF)   
  91. VMIN   Minimum number of characters to read    
  92. VSTART   Start flow   CTRL-Q (XON)   
  93. VSTOP   Stop flow   CTRL-S (XOFF)   
  94. VTIME   Time to wait for data (tenths of seconds)   
注意：

控制符VTIME和VMIN之间有复杂的关系。VTIME定义要求等待的时间（百毫米，通常是unsigned char变量），而VMIN定义了要求等待的最小字节数（相比之下，read函数的第三个参数指定了要求读的最大字节数）。
如果VTIME=0，VMIN=要求等待读取的最小字节数，read必须在读取了VMIN个字节的数据或者收到一个信号才会返回。
如果VTIME=时间量，VMIN=0，不管能否读取到数据，read也要等待VTIME的时间量。
如果VTIME=时间量，VMIN=要求等待读取的最小字节数，那么将从read读取第一个字节的数据时开始计时，并会在读取到VMIN个字节或者VTIME时间后返回。
如果VTIME=0，VMIN=0，不管能否读取到数据，read都会立即返回。

（七）参看代码

[cpp]  view plain  copy
  1. /************************Copyright(c)*******************************  
  2. **                       西安邮电学院  
  3. **                       graduate school  
  4. **                                     XNMS项目组  
  5. **                       WebSite :blog.csdn.net/tigerjb  
  6. **------------------------------------------FileInfo-------------------------------------------------------  
  7. ** File name:                 main.c  
  8. ** Last modified Date:  2011-01-31  
  9. ** Last Version:              1.0  
  10. ** Descriptions:              
  11. **------------------------------------------------------------------------------------------------------  
  12. ** Created by:               冀博  
  13. ** Created date:            2011-01-31  
  14. ** Version:                            1.0  
  15. ** Descriptions:             The original version  
  16. **------------------------------------------------------------------------------------------------------  
  17. ** Modified by:  
  18. ** Modified date:  
  19. ** Version:  
  20. ** Descriptions:  
  21. *******************************************************************/    
  22.      
  23.      
  24. //串口相关的头文件    
  25. #include      /*标准输入输出定义*/    
  26. #include     /*标准函数库定义*/    
  27. #include     /*Unix 标准函数定义*/    
  28. #include     
  29. #include       
  30. #include      /*文件控制定义*/    
  31. #include    /*PPSIX 终端控制定义*/    
  32. #include      /*错误号定义*/    
  33. #include    
  34.      
  35.      
  36. //宏定义    
  37. #define FALSE  -1    
  38. #define TRUE   0    
  39.      
  40. /*******************************************************************  
  41. * 名称：                  UART0_Open  
  42. * 功能：                打开串口并返回串口设备文件描述  
  43. * 入口参数：        fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2)  
  44. * 出口参数：        正确返回为1，错误返回为0  
  45. *******************************************************************/    
  46. int UART0_Open(int fd,char* port)    
  47. {    
  48.        
  49.          fd = open( port, O_RDWR|O_NOCTTY|O_NDELAY);    
  50.          if (FALSE == fd)    
  51.                 {    
  52.                        perror("Can't Open Serial Port");    
  53.                        return(FALSE);    
  54.                 }    
  55.      //恢复串口为阻塞状态                                   
  56.      if(fcntl(fd, F_SETFL, 0) < 0)    
  57.                 {    
  58.                        printf("fcntl failed!\n");    
  59.                      return(FALSE);    
  60.                 }         
  61.          else    
  62.                 {    
  63.                   printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));    
  64.                 }    
  65.       //测试是否为终端设备        
  66.       if(0 == isatty(STDIN_FILENO))    
  67.                 {    
  68.                        printf("standard input is not a terminal device\n");    
  69.                   return(FALSE);    
  70.                 }    
  71.   else    
  72.                 {    
  73.                      printf("isatty success!\n");    
  74.                 }                  
  75.   printf("fd->open=%d\n",fd);    
  76.   return fd;    
  77. }    
  78. /*******************************************************************  
  79. * 名称：                UART0_Close  
  80. * 功能：                关闭串口并返回串口设备文件描述  
  81. * 入口参数：        fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2)  
  82. * 出口参数：        void  
  83. *******************************************************************/    
  84.      
  85. void UART0_Close(int fd)    
  86. {    
  87.     close(fd);    
  88. }    
  89.      
  90. /*******************************************************************  
  91. * 名称：                UART0_Set  
  92. * 功能：                设置串口数据位，停止位和效验位  
  93. * 入口参数：        fd        串口文件描述符  
  94. *                              speed     串口速度  
  95. *                              flow_ctrl   数据流控制  
  96. *                           databits   数据位   取值为 7 或者8  
  97. *                           stopbits   停止位   取值为 1 或者2  
  98. *                           parity     效验类型 取值为N,E,O,,S  
  99. *出口参数：          正确返回为1，错误返回为0  
  100. *******************************************************************/    
  101. int UART0_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity)    
  102. {    
  103.        
  104.       int   i;    
  105.          int   status;    
  106.          int   speed_arr[] = { B115200, B19200, B9600, B4800, B2400, B1200, B300};    
  107.      int   name_arr[] = {115200,  19200,  9600,  4800,  2400,  1200,  300};    
  108.              
  109.     struct termios options;    
  110.        
  111.     /*tcgetattr(fd,&options)得到与fd指向对象的相关参数，并将它们保存于options,该函数还可以测试配置是否正确，该串口是否可用等。若调用成功，函数返回值为0，若调用失败，函数返回值为1.  
  112.     */    
  113.     if  ( tcgetattr( fd,&options)  !=  0)    
  114.        {    
  115.           perror("SetupSerial 1");        
  116.           return(FALSE);     
  117.        }    
  118.       
  119.     //设置串口输入波特率和输出波特率    
  120.     for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)    
  121.                 {    
  122.                      if  (speed == name_arr[i])    
  123.                             {                 
  124.                                  cfsetispeed(&options, speed_arr[i]);     
  125.                                  cfsetospeed(&options, speed_arr[i]);      
  126.                             }    
  127.               }         
  128.        
  129.     //修改控制模式，保证程序不会占用串口    
  130.     options.c_cflag |= CLOCAL;    
  131.     //修改控制模式，使得能够从串口中读取输入数据    
  132.     options.c_cflag |= CREAD;    
  133.       
  134.     //设置数据流控制    
  135.     switch(flow_ctrl)    
  136.     {    
  137.           
  138.        case 0 ://不使用流控制    
  139.               options.c_cflag &= ~CRTSCTS;    
  140.               break;       
  141.           
  142.        case 1 ://使用硬件流控制    
  143.               options.c_cflag |= CRTSCTS;    
  144.               break;    
  145.        case 2 ://使用软件流控制    
  146.               options.c_cflag |= IXON | IXOFF | IXANY;    
  147.               break;    
  148.     }    
  149.     //设置数据位    
  150.     //屏蔽其他标志位    
  151.     options.c_cflag &= ~CSIZE;    
  152.     switch (databits)    
  153.     {      
  154.        case 5    :    
  155.                      options.c_cflag |= CS5;    
  156.                      break;    
  157.        case 6    :    
  158.                      options.c_cflag |= CS6;    
  159.                      break;    
  160.        case 7    :        
  161.                  options.c_cflag |= CS7;    
  162.                  break;    
  163.        case 8:        
  164.                  options.c_cflag |= CS8;    
  165.                  break;      
  166.        default:       
  167.                  fprintf(stderr,"Unsupported data size\n");    
  168.                  return (FALSE);     
  169.     }    
  170.     //设置校验位    
  171.     switch (parity)    
  172.     {      
  173.        case 'n':    
  174.        case 'N': //无奇偶校验位。    
  175.                  options.c_cflag &= ~PARENB;     
  176.                  options.c_iflag &= ~INPCK;        
  177.                  break;     
  178.        case 'o':      
  179.        case 'O'://设置为奇校验        
  180.                  options.c_cflag |= (PARODD | PARENB);     
  181.                  options.c_iflag |= INPCK;                 
  182.                  break;     
  183.        case 'e':     
  184.        case 'E'://设置为偶校验      
  185.                  options.c_cflag |= PARENB;           
  186.                  options.c_cflag &= ~PARODD;           
  187.                  options.c_iflag |= INPCK;          
  188.                  break;    
  189.        case 's':    
  190.        case 'S': //设置为空格     
  191.                  options.c_cflag &= ~PARENB;    
  192.                  options.c_cflag &= ~CSTOPB;    
  193.                  break;     
  194.         default:      
  195.                  fprintf(stderr,"Unsupported parity\n");        
  196.                  return (FALSE);     
  197.     }     
  198.     // 设置停止位     
  199.     switch (stopbits)    
  200.     {      
  201.        case 1:       
  202.                  options.c_cflag &= ~CSTOPB; break;     
  203.        case 2:       
  204.                  options.c_cflag |= CSTOPB; break;    
  205.        default:       
  206.                        fprintf(stderr,"Unsupported stop bits\n");     
  207.                        return (FALSE);    
  208.     }    
  209.        
  210.   //修改输出模式，原始数据输出    
  211.   options.c_oflag &= ~OPOST;    
  212.       
  213.   options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);//我加的    
  214. //options.c_lflag &= ~(ISIG | ICANON);    
  215.        
  216.     //设置等待时间和最小接收字符    
  217.     options.c_cc[VTIME] = 1; /* 读取一个字符等待1*(1/10)s */      
  218.     options.c_cc[VMIN] = 1; /* 读取字符的最少个数为1 */    
  219.        
  220.     //如果发生数据溢出，接收数据，但是不再读取 刷新收到的数据但是不读    
  221.     tcflush(fd,TCIFLUSH);    
  222.        
  223.     //激活配置 (将修改后的termios数据设置到串口中）    
  224.     if (tcsetattr(fd,TCSANOW,&options) != 0)      
  225.            {    
  226.                perror("com set error!\n");      
  227.               return (FALSE);     
  228.            }    
  229.     return (TRUE);     
  230. }    
  231. /*******************************************************************  
  232. * 名称：                UART0_Init()  
  233. * 功能：                串口初始化  
  234. * 入口参数：        fd       :  文件描述符     
  235. *               speed  :  串口速度  
  236. *                              flow_ctrl  数据流控制  
  237. *               databits   数据位   取值为 7 或者8  
  238. *                           stopbits   停止位   取值为 1 或者2  
  239. *                           parity     效验类型 取值为N,E,O,,S  
  240. *                        
  241. * 出口参数：        正确返回为1，错误返回为0  
  242. *******************************************************************/    
  243. int UART0_Init(int fd, int speed,int flow_ctrl,int databits,int stopbits,int parity)    
  244. {    
  245.     int err;    
  246.     //设置串口数据帧格式    
  247.     if (UART0_Set(fd,19200,0,8,1,'N') == FALSE)    
  248.        {                                                             
  249.         return FALSE;    
  250.        }    
  251.     else    
  252.        {    
  253.                return  TRUE;    
  254.         }    
  255. }    
  256.      
  257. /*******************************************************************  
  258. * 名称：                  UART0_Recv  
  259. * 功能：                接收串口数据  
  260. * 入口参数：        fd                  :文件描述符      
  261. *                              rcv_buf     :接收串口中数据存入rcv_buf缓冲区中  
  262. *                              data_len    :一帧数据的长度  
  263. * 出口参数：        正确返回为1，错误返回为0  
  264. *******************************************************************/    
  265. int UART0_Recv(int fd, char *rcv_buf,int data_len)    
  266. {    
  267.     int len,fs_sel;    
  268.     fd_set fs_read;    
  269.        
  270.     struct timeval time;    
  271.        
  272.     FD_ZERO(&fs_read);    
  273.     FD_SET(fd,&fs_read);    
  274.        
  275.     time.tv_sec = 10;    
  276.     time.tv_usec = 0;    
  277.        
  278.     //使用select实现串口的多路通信    
  279.     fs_sel = select(fd+1,&fs_read,NULL,NULL,&time);    
  280.     if(fs_sel)    
  281.        {    
  282.               len = read(fd,rcv_buf,data_len);    
  283.           printf("I am right!(version1.2) len = %d fs_sel = %d\n",len,fs_sel);    
  284.               return len;    
  285.        }    
  286.     else    
  287.        {    
  288.           printf("Sorry,I am wrong!");    
  289.               return FALSE;    
  290.        }         
  291. }    
  292. /********************************************************************  
  293. * 名称：                  UART0_Send  
  294. * 功能：                发送数据  
  295. * 入口参数：        fd                  :文件描述符      
  296. *                              send_buf    :存放串口发送数据  
  297. *                              data_len    :一帧数据的个数  
  298. * 出口参数：        正确返回为1，错误返回为0  
  299. *******************************************************************/    
  300. int UART0_Send(int fd, char *send_buf,int data_len)    
  301. {    
  302.     int len = 0;    
  303.        
  304.     len = write(fd,send_buf,data_len);    
  305.     if (len == data_len )    
  306.               {    
  307.                      return len;    
  308.               }         
  309.     else       
  310.         {    
  311.                    
  312.                 tcflush(fd,TCOFLUSH);    
  313.                 return FALSE;    
  314.         }    
  315.        
  316. }    
  317.      
  318.      
  319. int main(int argc, char **argv)    
  320. {    
  321.     int fd;                            //文件描述符    
  322.     int err;                           //返回调用函数的状态    
  323.     int len;                            
  324.     int i;    
  325.     char rcv_buf[100];           
  326.     char send_buf[20]="tiger john";    
  327.     if(argc != 3)    
  328.        {    
  329.               printf("Usage: %s /dev/ttySn 0(send data)/1 (receive data) \n",argv[0]);    
  330.               return FALSE;    
  331.        }    
  332.     fd = UART0_Open(fd,argv[1]); //打开串口，返回文件描述符    
  333.     do{    
  334.                   err = UART0_Init(fd,19200,0,8,1,'N');    
  335.                   printf("Set Port Exactly!\n");    
  336.        }while(FALSE == err || FALSE == fd);    
  337.        
  338.     if(0 == strcmp(argv[2],"0"))    
  339.            {    
  340.                   for(i = 0;i < 10;i++)    
  341.                          {    
  342.                                 len = UART0_Send(fd,send_buf,10);    
  343.                                 if(len > 0)    
  344.                                        printf(" %d send data successful\n",i);    
  345.                                 else    
  346.                                        printf("send data failed!\n");    
  347.                               
  348.                                 sleep(2);    
  349.                          }    
  350.                   UART0_Close(fd);                 
  351.            }    
  352.     else    
  353.            {    
  354.                                           
  355.            while (1) //循环读取数据    
  356.                   {      
  357.                      len = UART0_Recv(fd, rcv_buf,9);    
  358.                      if(len > 0)    
  359.                             {    
  360.                        rcv_buf[len] = '\0';    
  361.                                    printf("receive data is %s\n",rcv_buf);    
  362.                        printf("len = %d\n",len);    
  363.                             }    
  364.                      else    
  365.                             {    
  366.                                    printf("cannot receive data\n");    
  367.                             }    
  368.                      sleep(2);    
  369.               }                
  370.        UART0_Close(fd);     
  371.            }    
  372. }    
  373.       
  374. /*********************************************************************                            End Of File                          **  
  375. *******************************************************************/    

（2）select 函数用法

参看：UNIX再学习 -- 函数 select、poll、epoll 

（3）多线程编程-互斥锁

参看：UNIX再学习 -- 线程
参看：UNIX再学习 -- 线程同步

（4）Linux获取毫秒级时间

参看：C语言再学习 -- 时间函数


[cpp]  view plain  copy
  1. struct termios  
  2. {  
  3.    tcflag_t  c_iflag;   //输入模式标志  
  4.    tcflag_t  c_oflag;  //输出模式标志  
  5.    tcflag_t  c_cflag;  //控制模式标志  
  6.    tcflag_t  c_lflag;   //本地模式标志  
  7.    cc_t   c_line;              //line discipline  
  8.    cc_t   c_cc[NCC];    //control characters  
  9. }  

2> 通过cfsetispeed函数和cfsetospeed函数用来设置串口的输入/输出波特率。一般情况下，输入和输出波特率相等的。

3> 设置数据位可以通过修改termios机构体中c_flag来实现。其中CS5,CS6,CS7,CS8对应数据位的5，6，7，8。在设置数据位时，必须要用CSIZE做位屏蔽。

以下是几个数据位、停止位和校验位的设置方法：（以下均为1位停止位）

[cpp]  view plain  copy
  1. 8位数据位、无校验位：  
  2. Opt.c_cflag &= ~PARENB;  
  3. Opt.c_cflag &= ~CSTOPB;  
  4. Opt.c_cflag &= ~CSIZE;  
  5. Opt.c_cflag |= CS8;  
  6. 7位数据位、奇校验：  
  7. Opt.c_cflag |= PARENB;  
  8. Opt.c_cflag |= PARODD;  
  9. Opt.c_cflag &= ~CSTOPB;  
  10. Opt.c_cflag &= ~CSIZE;  
  11. Opt.c_cflag |= CS7;  
  12. 7位数据位、偶校验：  
  13. Opt.c_cflag |= PARENB;  
  14. Opt.c_cflag &= ~PARODD;  
  15. Opt.c_cflag &= ~CSTOPB;  
  16. Opt.c_cflag &= ~CSIZE;  
  17. Opt.c_cflag |= CS7;  
  18. 7位数据位、Space校验：  
  19. Opt.c_cflag &= ~PARENB;  
  20. Opt.c_cflag &= ~CSTOPB;  
  21. Opt.c_cflag &= ~CSIZE;  
  22. Opt.c_cflag |= CS7;  

4> 数据流控制是使用何种方法来标志数据传输的开始和结束。

5> 在设置完波特率，数据流控制，数据位，校验位，停止位，停止位后，还要设置最小等待时间和最小接收字符。

6> 在完成配置后要通过tcsetattr()函数来激活配置。

3.程序：

[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                UART0_Set 
  3. * 功能：                设置串口数据位，停止位和效验位 
  4. * 入口参数：        fd         串口文件描述符 
  5. *                              speed      串口速度 
  6. *                              flow_ctrl  数据流控制 
  7. *                           databits   数据位   取值为 7 或者8 
  8. *                           stopbits   停止位   取值为 1 或者2 
  9. *                           parity     效验类型 取值为N,E,O,,S 
  10. *出口参数：              正确返回为1，错误返回为0 
  11. *******************************************************************/  
  12. int UART0_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity)  
  13. {  
  14.      
  15.       int   i;  
  16.          int   status;  
  17.          int   speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,  
  18.           B38400, B19200, B9600, B4800, B2400, B1200, B300 };  
  19.      int   name_arr[] = {38400,  19200,  9600,  4800,  2400,  1200,  300,      38400, 19200,  9600, 4800, 2400, 1200,  300 };  
  20.            
  21.     struct termios options;  
  22.      
  23.     /*tcgetattr(fd,&options)得到与fd指向对象的相关参数，并将它们保存于options,该函数,还可以测试配置是否正确，该串口是否可用等。若调用成功，函数返回值为0，若调用失败，函数返回值为1. 
  24.     */  
  25.     if  ( tcgetattr( fd,&options)  !=  0)  
  26.        {  
  27.           perror("SetupSerial 1");      
  28.           return(FALSE);   
  29.        }  
  30.     
  31.     //设置串口输入波特率和输出波特率  
  32.     for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)  
  33.                 {  
  34.               if  (speed == name_arr[i])  
  35.               {         
  36.                           cfsetispeed(&Options, speed_arr[i]);   
  37.                           cfsetospeed(&Options, speed_arr[i]);    
  38.               }  
  39.        }       
  40.      
  41.     //修改控制模式，保证程序不会占用串口  
  42.     options.c_cflag |= CLOCAL;  
  43.     //修改控制模式，使得能够从串口中读取输入数据  
  44.     options.c_cflag |= CREAD;  
  45.     
  46.     //设置数据流控制  
  47.     switch(flow_ctrl)  
  48.     {  
  49.         
  50.        case 0 ://不使用流控制  
  51.               options.c_cflag &= ~CRTSCTS;  
  52.               break;     
  53.         
  54.        case 1 ://使用硬件流控制  
  55.               options.c_cflag |= CRTSCTS;  
  56.               break;  
  57.        case 2 ://使用软件流控制  
  58.               options.c_cflag |= IXON | IXOFF | IXANY;  
  59.               break;  
  60.     }  
  61.     //设置数据位  
  62.     options.c_cflag &= ~CSIZE; //屏蔽其他标志位  
  63.     switch (databits)  
  64.     {    
  65.        case 5    :  
  66.                      options.c_cflag |= CS5;  
  67.                      break;  
  68.        case 6    :  
  69.                      options.c_cflag |= CS6;  
  70.                      break;  
  71.        case 7    :      
  72.                  options.c_cflag |= CS7;  
  73.                  break;  
  74.        case 8:      
  75.                  options.c_cflag |= CS8;  
  76.                  break;    
  77.        default:     
  78.                  fprintf(stderr,"Unsupported data size/n");  
  79.                  return (FALSE);   
  80.     }  
  81.     //设置校验位  
  82.     switch (parity)  
  83.     {    
  84.        case 'n':  
  85.        case 'N': //无奇偶校验位。  
  86.                  options.c_cflag &= ~PARENB;   
  87.                  options.c_iflag &= ~INPCK;      
  88.                  break;   
  89.        case 'o':    
  90.        case 'O'://设置为奇校验      
  91.                  options.c_cflag |= (PARODD | PARENB);   
  92.                  options.c_iflag |= INPCK;               
  93.                  break;   
  94.        case 'e':   
  95.        case 'E'://设置为偶校验    
  96.                  options.c_cflag |= PARENB;         
  97.                  options.c_cflag &= ~PARODD;         
  98.                  options.c_iflag |= INPCK;         
  99.                  break;  
  100.        case 's':  
  101.        case 'S': //设置为空格   
  102.                  options.c_cflag &= ~PARENB;  
  103.                  options.c_cflag &= ~CSTOPB;  
  104.                  break;   
  105.         default:    
  106.                  fprintf(stderr,"Unsupported parity/n");     
  107.                  return (FALSE);   
  108.     }   
  109.     // 设置停止位   
  110.     switch (stopbits)  
  111.     {    
  112.        case 1:     
  113.                  options.c_cflag &= ~CSTOPB;   
  114.                  break;   
  115.        case 2:     
  116.                  options.c_cflag |= CSTOPB;   
  117.                          break;  
  118.        default:     
  119.                        fprintf(stderr,"Unsupported stop bits/n");   
  120.                        return (FALSE);  
  121.     }  
  122.      
  123.     //修改输出模式，原始数据输出  
  124.     options.c_oflag &= ~OPOST;  
  125.      
  126.     //设置等待时间和最小接收字符  
  127.     options.c_cc[VTIME] = 1; /* 读取一个字符等待1*(1/10)s */    
  128.     options.c_cc[VMIN] = 1; /* 读取字符的最少个数为1 */  
  129.      
  130.     //如果发生数据溢出，接收数据，但是不再读取  
  131.     tcflush(fd,TCIFLUSH);  
  132.      
  133.     //激活配置 (将修改后的termios数据设置到串口中）  
  134.     if (tcsetattr(fd,TCSANOW,&options) != 0)    
  135.     {  
  136.                perror("com set error!/n");    
  137.        return (FALSE);   
  138.     }  
  139.     return (TRUE);   
  140. }  
[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                  UART0_Init() 
  3. * 功能：                串口初始化 
  4. * 入口参数：        fd           文件描述符    
  5. *               speed     串口速度 
  6. *                              flow_ctrl   数据流控制 
  7. *               databits    数据位   取值为 7 或者8 
  8. *                           stopbits   停止位   取值为 1 或者2 
  9. *                           parity     效验类型 取值为N,E,O,,S                     
  10. * 出口参数：        正确返回为1，错误返回为0 
  11. *******************************************************************/  
  12. int UART0_Init(int fd, int speed,int flow_ctrlint databits,int stopbits,int parity)  
  13. {  
  14.     int err;  
  15.     //设置串口数据帧格式  
  16.     if (UART0_Set(fd,115200,0,8,1,'N') == FALSE)  
  17.     {                                                       
  18.         return FALSE;  
  19.     }  
  20.     else  
  21.     {  
  22.                return  TRUE;  
  23.         }  
  24. }  
注意：
如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式 (Raw Mode) 方式来通讯，设置方式如下：
options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/
options.c_oflag  &= ~OPOST;   /*Output*/

c_cc 数组的 VSTART 和 VSTOP 元素被设定成 DC1 和 DC3，代表 ASCII 标准的 XON 和 XOFF 字符，如果在传输这两个字符的时候就传不过去，需要把软件流控制屏蔽，即：
Opt.c_iflag &= ~ (IXON | IXOFF | IXANY);
有时候，在用write发送数据时没有键入回车，信息就发送不出去，这主要是因为我们在输入输出时是按照规范模式接收到回车或换行才发送，而更多情况下我们是不必键入回车或换行的。此时应转换到行方式输入，不经处理直接发送，设置如下：
Opt.c_lflag &= ~ (ICANON | ECHO | ECHOE | ISIG);
还存在这样的情况：发送字符0X0d的时候，往往接收端得到的字符是 0X0a，原因是因为在串口设置中 c_iflag 和c_oflag 中存在从 NL-CR 和 CR-NL 的映射，即串口能把回车和换行当成同一个字符，可以进行如下设置屏蔽之：
Opt.c_iflag &= ~ (INLCR | ICRNL | IGNCR);
Opt.c_oflag &= ~(ONLCR | OCRNL);

注意 tcsetattr 函数中使用的标志：
TCSANOW：立即执行而不等待数据发送或者接受完成。
TCSADRAIN：等待所有数据传递完成后执行。
TCSAFLUSH：刷新输入和输出缓冲区,使之变化。

（四）串口的读写函数

读写串口是通过使用read函数和write函数来实现的。程序：

[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                  UART0_Recv 
  3. * 功能：                接收串口数据 
  4. * 入口参数：        fd                  :文件描述符     
  5. *                              rcv_buf     :接收串口中数据存入rcv_buf缓冲区中 
  6. *                              data_len    :一帧数据的长度 
  7. * 出口参数：        正确返回为1，错误返回为0 
  8. *******************************************************************/  
  9. int UART0_Recv(int fd, char *rcv_buf,int data_len)  
  10. {  
  11.     int len,fs_sel;  
  12.     fd_set fs_read;  
  13.      
  14.     struct timeval time;  
  15.      
  16.     FD_ZERO(&fs_read);  
  17.     FD_SET(fd,&fs_read);  
  18.      
  19.     time.tv_sec = 10;  
  20.     time.tv_usec = 0;  
  21.      
  22.     //使用select实现串口的多路通信  
  23.     fs_sel = select(fd+1,&fs_read,NULL,NULL,&time);  
  24.     if(fs_sel)  
  25.        {  
  26.               len = read(fd,data,data_len);  
  27.               return len;  
  28.        }  
  29.     else  
  30.        {  
  31.               return FALSE;  
  32.        }       
  33. }  
[cpp]  view plain  copy
  1. /******************************************************************* 
  2. * 名称：                UART0_Send 
  3. * 功能：                发送数据 
  4. * 入口参数：        fd                  :文件描述符     
  5. *                              send_buf    :存放串口发送数据 
  6. *                              data_len    :一帧数据的个数 
  7. * 出口参数：        正确返回为1，错误返回为0 
  8. *******************************************************************/  
  9. int UART0_Send(int fd, char *send_buf,int data_len)  
  10. {  
  11.     int len = 0;  
  12.      
  13.     len = write(fd,send_buf,data_len);  
  14.     if (len == data_len )  
  15.        {  
  16.               return len;  
  17.        }       
  18.     else     
  19.         {  
  20.                  
  21.                 tcflush(fd,TCOFLUSH);  
  22.                 return FALSE;  
  23.         }  
  24.     }  

（五）关闭串口

在完成对串口设备的操作后，要调用close函数关闭该文件描述符。程序：
[cpp]  view plain  copy
  1. /****************************************************** 
  2. * 名称：                UART0_Close 
  3. * 功能：                关闭串口并返回串口设备文件描述 
  4. * 入口参数：        fd    :文件描述符    
  5. * 出口参数：        void 
  6. *******************************************************************/  
  7.    
  8. void UART0_Close(int fd)  
  9. {  
  10.     close(fd);  
  11. }  

（六）附录

[cpp]  view plain  copy
  1. c_cflag用于设置控制参数，除了波特率外还包含以下内容：   
  2. EXTA         External rate clock  
  3. EXTB         External rate clock  
  4. CSIZE         Bit mask for data bits  
  5. CS5         5个数据位  
  6. CS6         6个数据位  
  7. CS7         7个数据位  
  8. CS8         8个数据位  
  9. CSTOPB         2个停止位（清除该标志表示1个停止位  
  10. PARENB         允许校验位  
  11. PARODD         使用奇校验（清除该标志表示使用偶校验）  
  12. CREAD         Enable receiver  
  13. HUPCL         Hangup (drop DTR) on last close  
  14. CLOCAL         Local line – do not change “owner” of port  
  15. LOBLK         Block job control outpu  
  16. c_cflag标志可以定义CLOCAL和CREAD，这将确保该程序不被其他端口控制和信号干扰，同时串口驱动将读取进入的数据。CLOCAL和CREAD通常总是被是能的。  
  17.   
  18. c_lflag用于设置本地模式，决定串口驱动如何处理输入字符，设置内容如下：  
  19. ISIG            Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals   
  20. ICANON         Enable canonical input (else raw)   
  21. XCASE         Map uppercase \lowercase (obsolete)   
  22. ECHO         Enable echoing of input characters   
  23. ECHOE         Echo erase character as BS-SP-BS   
  24. ECHOK         Echo NL after kill character   
  25. ECHONL         Echo NL   
  26. NOFLSH         Disable flushing of input buffers after interrupt or quit characters   
  27. IEXTEN         Enable extended functions   
  28. ECHOCTL         Echo control characters as ^char and delete as ~?   
  29. ECHOPRT         Echo erased character as character erased   
  30. ECHOKE         BS-SP-BS entire line on line kill   
  31. FLUSHO         Output being flushed   
  32. PENDIN         Retype pending input at next read or input char   
  33. TOSTOP         Send SIGTTOU for background output  
  34.   
  35. c_iflag用于设置如何处理串口上接收到的数据，包含如下内容：  
  36. INPCK         Enable parity check   
  37. IGNPAR         Ignore parity errors   
  38. PARMRK      Mark parity errors   
  39. ISTRIP         Strip parity bits   
  40. IXON         Enable software flow control (outgoing)   
  41. IXOFF         Enable software flow control (incoming)   
  42. IXANY         Allow any character to start flow again   
  43. IGNBRK         Ignore break condition   
  44. BRKINT         Send a SIGINT when a break condition is detected   
  45. INLCR         Map NL to CR   
  46. IGNCR         Ignore CR   
  47. ICRNL         Map CR to NL   
  48. IUCLC         Map uppercase to lowercase   
  49. IMAXBEL      Echo BEL on input line too long  
  50.   
  51. c_oflag用于设置如何处理输出数据，包含如下内容：  
  52. OPOST         Postprocess output (not set = raw output)   
  53. OLCUC         Map lowercase to uppercase   
  54. ONLCR         Map NL to CR-NL   
  55. OCRNL         Map CR to NL   
  56. NOCR         No CR output at column 0   
  57. ONLRET      NL performs CR function   
  58. OFILL         Use fill characters for delay   
  59. OFDEL         Fill character is DEL   
  60. NLDLY         Mask for delay time needed between lines   
  61. NL0            No delay for NLs   
  62. NL1            Delay further output after newline for 100 milliseconds   
  63. CRDLY      Mask for delay time needed to return carriage to left column   
  64. CR0            No delay for CRs   
  65. CR1            Delay after CRs depending on current column position   
  66. CR2            Delay 100 milliseconds after sending CRs   
  67. CR3            Delay 150 milliseconds after sending CRs   
  68. TABDLY      Mask for delay time needed after TABs   
  69. TAB0            No delay for TABs   
  70. TAB1         Delay after TABs depending on current column position   
  71. TAB2         Delay 100 milliseconds after sending TABs   
  72. TAB3         Expand TAB characters to spaces   
  73. BSDLY      Mask for delay time needed after BSs   
  74. BS0         No delay for BSs   
  75. BS1         Delay 50 milliseconds after sending BSs   
  76. VTDLY      Mask for delay time needed after VTs   
  77. VT0         No delay for VTs   
  78. VT1         Delay 2 seconds after sending VTs   
  79. FFDLY      Mask for delay time needed after FFs   
  80. FF0         No delay for FFs   
  81. FF1         Delay 2 seconds after sending FFs  
  82.   
  83. c_cc定义了控制字符，包含以下内容：  
  84. VINTR  Interrupt  CTRL-C   
  85. VQUIT  Quit    CTRL-Z   
  86. VERASE   Erase    Backspace (BS)   
  87. VKILL   Kill-line   CTRL-U   
  88. VEOF   End-of-file   CTRL-D   
  89. VEOL   End-of-line   Carriage return (CR)   
  90. VEOL2   Second    end-of-line Line feed (LF)   
  91. VMIN   Minimum number of characters to read    
  92. VSTART   Start flow   CTRL-Q (XON)   
  93. VSTOP   Stop flow   CTRL-S (XOFF)   
  94. VTIME   Time to wait for data (tenths of seconds)   
注意：

控制符VTIME和VMIN之间有复杂的关系。VTIME定义要求等待的时间（百毫米，通常是unsigned char变量），而VMIN定义了要求等待的最小字节数（相比之下，read函数的第三个参数指定了要求读的最大字节数）。
如果VTIME=0，VMIN=要求等待读取的最小字节数，read必须在读取了VMIN个字节的数据或者收到一个信号才会返回。
如果VTIME=时间量，VMIN=0，不管能否读取到数据，read也要等待VTIME的时间量。
如果VTIME=时间量，VMIN=要求等待读取的最小字节数，那么将从read读取第一个字节的数据时开始计时，并会在读取到VMIN个字节或者VTIME时间后返回。
如果VTIME=0，VMIN=0，不管能否读取到数据，read都会立即返回。

（七）参看代码

[cpp]  view plain  copy
  1. /************************Copyright(c)*******************************  
  2. **                       西安邮电学院  
  3. **                       graduate school  
  4. **                                     XNMS项目组  
  5. **                       WebSite :blog.csdn.net/tigerjb  
  6. **------------------------------------------FileInfo-------------------------------------------------------  
  7. ** File name:                 main.c  
  8. ** Last modified Date:  2011-01-31  
  9. ** Last Version:              1.0  
  10. ** Descriptions:              
  11. **------------------------------------------------------------------------------------------------------  
  12. ** Created by:               冀博  
  13. ** Created date:            2011-01-31  
  14. ** Version:                            1.0  
  15. ** Descriptions:             The original version  
  16. **------------------------------------------------------------------------------------------------------  
  17. ** Modified by:  
  18. ** Modified date:  
  19. ** Version:  
  20. ** Descriptions:  
  21. *******************************************************************/    
  22.      
  23.      
  24. //串口相关的头文件    
  25. #include      /*标准输入输出定义*/    
  26. #include     /*标准函数库定义*/    
  27. #include     /*Unix 标准函数定义*/    
  28. #include     
  29. #include       
  30. #include      /*文件控制定义*/    
  31. #include    /*PPSIX 终端控制定义*/    
  32. #include      /*错误号定义*/    
  33. #include    
  34.      
  35.      
  36. //宏定义    
  37. #define FALSE  -1    
  38. #define TRUE   0    
  39.      
  40. /*******************************************************************  
  41. * 名称：                  UART0_Open  
  42. * 功能：                打开串口并返回串口设备文件描述  
  43. * 入口参数：        fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2)  
  44. * 出口参数：        正确返回为1，错误返回为0  
  45. *******************************************************************/    
  46. int UART0_Open(int fd,char* port)    
  47. {    
  48.        
  49.          fd = open( port, O_RDWR|O_NOCTTY|O_NDELAY);    
  50.          if (FALSE == fd)    
  51.                 {    
  52.                        perror("Can't Open Serial Port");    
  53.                        return(FALSE);    
  54.                 }    
  55.      //恢复串口为阻塞状态                                   
  56.      if(fcntl(fd, F_SETFL, 0) < 0)    
  57.                 {    
  58.                        printf("fcntl failed!\n");    
  59.                      return(FALSE);    
  60.                 }         
  61.          else    
  62.                 {    
  63.                   printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));    
  64.                 }    
  65.       //测试是否为终端设备        
  66.       if(0 == isatty(STDIN_FILENO))    
  67.                 {    
  68.                        printf("standard input is not a terminal device\n");    
  69.                   return(FALSE);    
  70.                 }    
  71.   else    
  72.                 {    
  73.                      printf("isatty success!\n");    
  74.                 }                  
  75.   printf("fd->open=%d\n",fd);    
  76.   return fd;    
  77. }    
  78. /*******************************************************************  
  79. * 名称：                UART0_Close  
  80. * 功能：                关闭串口并返回串口设备文件描述  
  81. * 入口参数：        fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2)  
  82. * 出口参数：        void  
  83. *******************************************************************/    
  84.      
  85. void UART0_Close(int fd)    
  86. {    
  87.     close(fd);    
  88. }    
  89.      
  90. /*******************************************************************  
  91. * 名称：                UART0_Set  
  92. * 功能：                设置串口数据位，停止位和效验位  
  93. * 入口参数：        fd        串口文件描述符  
  94. *                              speed     串口速度  
  95. *                              flow_ctrl   数据流控制  
  96. *                           databits   数据位   取值为 7 或者8  
  97. *                           stopbits   停止位   取值为 1 或者2  
  98. *                           parity     效验类型 取值为N,E,O,,S  
  99. *出口参数：          正确返回为1，错误返回为0  
  100. *******************************************************************/    
  101. int UART0_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity)    
  102. {    
  103.        
  104.       int   i;    
  105.          int   status;    
  106.          int   speed_arr[] = { B115200, B19200, B9600, B4800, B2400, B1200, B300};    
  107.      int   name_arr[] = {115200,  19200,  9600,  4800,  2400,  1200,  300};    
  108.              
  109.     struct termios options;    
  110.        
  111.     /*tcgetattr(fd,&options)得到与fd指向对象的相关参数，并将它们保存于options,该函数还可以测试配置是否正确，该串口是否可用等。若调用成功，函数返回值为0，若调用失败，函数返回值为1.  
  112.     */    
  113.     if  ( tcgetattr( fd,&options)  !=  0)    
  114.        {    
  115.           perror("SetupSerial 1");        
  116.           return(FALSE);     
  117.        }    
  118.       
  119.     //设置串口输入波特率和输出波特率    
  120.     for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)    
  121.                 {    
  122.                      if  (speed == name_arr[i])    
  123.                             {                 
  124.                                  cfsetispeed(&options, speed_arr[i]);     
  125.                                  cfsetospeed(&options, speed_arr[i]);      
  126.                             }    
  127.               }         
  128.        
  129.     //修改控制模式，保证程序不会占用串口    
  130.     options.c_cflag |= CLOCAL;    
  131.     //修改控制模式，使得能够从串口中读取输入数据    
  132.     options.c_cflag |= CREAD;    
  133.       
  134.     //设置数据流控制    
  135.     switch(flow_ctrl)    
  136.     {    
  137.           
  138.        case 0 ://不使用流控制    
  139.               options.c_cflag &= ~CRTSCTS;    
  140.               break;       
  141.           
  142.        case 1 ://使用硬件流控制    
  143.               options.c_cflag |= CRTSCTS;    
  144.               break;    
  145.        case 2 ://使用软件流控制    
  146.               options.c_cflag |= IXON | IXOFF | IXANY;    
  147.               break;    
  148.     }    
  149.     //设置数据位    
  150.     //屏蔽其他标志位    
  151.     options.c_cflag &= ~CSIZE;    
  152.     switch (databits)    
  153.     {      
  154.        case 5    :    
  155.                      options.c_cflag |= CS5;    
  156.                      break;    
  157.        case 6    :    
  158.                      options.c_cflag |= CS6;    
  159.                      break;    
  160.        case 7    :        
  161.                  options.c_cflag |= CS7;    
  162.                  break;    
  163.        case 8:        
  164.                  options.c_cflag |= CS8;    
  165.                  break;      
  166.        default:       
  167.                  fprintf(stderr,"Unsupported data size\n");    
  168.                  return (FALSE);     
  169.     }    
  170.     

你可能感兴趣的:(串口编程--RS485)

  • 浅谈C#之232通讯 CN.LG C#c#开发语言
    一、基本介绍C#中实现232通讯，通常指的是通过串行通信接口（如RS232或RS485）与串行设备进行数据交换。以下是一个使用System.IO.Ports命名空间中的SerialPort类创建的基本示例。二、简单示例创建SerialPort实例：首先，你需要创建一个SerialPort对象，并设置其参数，如端口名、波特率、数据位、停止位和奇偶校验位。SerialPortserialPort=ne
  • 无线串口服务器是干什么用的,串口服务器是啥 有哪些作用 Javen Fang 无线串口服务器是干什么用的
    一、串口服务器概述串口服务器提供串口转网络功能，能够将RS-232/485/422串口转换成TCP/IP网络接口，实现RS-232/485/422串口与TCP/IP网络接口的数据双向透明传输。使得串口设备能够立即具备TCP/IP网络接口功能，连接网络进行数据通信，极大的扩展串口设备的通信距离。二、串口服务器的作用概述串口服务器的作用用5个字解释就是：串口转网口。详细的解释是将RS232或RS485
  • 关于STM32 RS485控制I/O口不能正常输出高低电平的解决方法 噗噗bug 嵌入式stm32物联网嵌入式硬件单片机
    一、问题：问题现象：在进行RS485操作时，发现接收时而进时而不进中断：将485的AB输出脚直接与串口的TX,RX对接发现串口定时发数据能进入中断，但是有点不受控制，接着测量MAX485各个引脚的脚，发现MAX485的RE\DE引脚一直处于高电平根据RS485工作原理：当单片机要发送数据的时候，控制CTRL为高电平，数据通过TXD发送出去。当单片机要接收数据的时候，控制CTRL为低电平，数据通过R
  • RS485和modbus的关系 岳海龙
    经常看到RS485和MODBUS写在一起，它们的区别和联系到底是什么呢？简单来说，RS485是一个物理接口，就是硬件。而MODBUS是一种国际标准的通讯协议，用于不同厂商之间的设备交换数据（一般是工业用途）；所谓协议，也可以理解为上面有人说的“语言”吧，简单的说是软件。一般情况下，两台设备通过MODBUS协议传输数据：最早是用RS232C作为硬件接口，（也就是普通电脑上的串行通讯口（串口））；也有
  • ModBus RTU、ModBus ASCII、ModBus TCP，它们有什么区别？ 哄娃睡觉 stm32
    ModBus是一种通信协议，用于连接自动化设备（如PLC、温度控制器等）和计算机。它被广泛应用于工业控制系统，支持多种通信方式，包括ModBusRTU、ModBusASCII和ModBusTCP3种模式。Modbus是一种应用层协议，它定义了与基础网络无关的数据单元（ADU），可以在以太网（TCP/IP）或串行链路上（RS232、RS485等）进行通信（以太网ADU和串行ADU略有不同）。在串行链
  • 工业网关BL110西门子S7-200 PLC接入Modbus TCP Server云平台 钡铼技术物联网 远程监控远程控制网关简介tcp/ipjvm网络协议
    COM口采集西门子S7-200PLC的配置工业智能网关一共有四个COM接口，4个COM口的配置内容一样，COM1固定为RS232，COM2、COM3和COM4是RS232/RS485可选串口（默认为RS485）。因S7-200的COM是RS485接口，则选择以COM2连接为例说明COM口采集配置操作。S7-200的RS485接口DB9的3和8为信号脚，3脚接COM2RS485A，8脚接COM2RS
  • EtherNet/IP转Modbus-RTU主站协议网关（Modbus-RTU转EtherNet/IP） JM398111 tcp/ip网络协议网络协议网关协议转换网关
    一，设备主要功能捷米特JM-EIP-RTU型网关实现EtherNet/IP网络与ModbusRTU串行总线之间的数据通讯，可支持RS232和RS485通讯。即EtherNet/IP和ModbusRTU网络之间无缝内部连接。广泛应用：应用于ModbusRTU接口的变频器、上位机、仪表、马保等等。例如在房山某污水处理厂的PLC控制系统项目中，罗克韦尔PLC作为EtherNet/IP主站，用户的变频器采
  • 基于Modbus的MFC智能控制 LabVIEW开发 LabVIEW开发案例mfclabviewLabVIEW开发
    1.系统概述利用LabVIEW通过Modbus485协议实现对七星（Sevenstar）品牌质量流量控制器（MFC）的智能化控制。该系统将自动控制多个MFC的流速，实时监控其状态，并根据需要进行调整。2.硬件配置MFCs:七星品牌的质量流量控制器，支持Modbus485通讯协议。NI硬件:NIcRIO或cDAQ系统:用于Modbus通讯。NI9870模块:提供RS485接口，用于与MFC进行通讯。
  • 【STM32 CubeMX】串口编程DMA 人才程序员 stm32嵌入式硬件单片机c语言mcu51单片机
    文章目录前言一、DMA方式1.1DMA是什么1.2CubeMX配置DMA1.3DMA方式函数使用DMA的发送接收函数总结前言在嵌入式系统中，串口通信是一项至关重要的功能，它允许单片机与外部设备进行数据交换，如传感器、显示器或其他设备。然而，在高速数据传输的场景下，传统的串口通信方式可能会使CPU过于繁忙，从而影响系统的性能。为了解决这一问题，STM32系列微控制器提供了DMA（直接内存访问）技术，
  • ALINX黑金AXU3EGB 开发板用户手册RS485通信接口图示DI RO信号方向标识错误说明 电子阿板 fpga开发单片机智能硬件嵌入式硬件stm32
    MAX3485这类RS485芯片，DI是TTL信号输入，RO是TTL信号输出如下图是MAX3485手册规格书。因此ALINX黑金AXU3EGB用户手册Page43页图3-11-1PL端485通信的连接示意图，MAX3485芯片的DIRO信号输入输出标识方向是错误的，应为蓝色箭头方向。（备注里面是对的）下图为AXU3EGB开发板用户手册相关内容至于为什么要提出来，因为很多人看原理图设计时大概率会先看
  • 【STM32 CubeMX】串口编程DMA+IDLE中断 人才程序员 stm32单片机嵌入式硬件mcuc51单片机
    文章目录前言一、为什么要引入IDLE中断二、IDLE中断使用方式2.1接收的三种情况2.2函数的使用查询方式中断方式DMA方式分析一个问题总结前言在嵌入式系统中，串口通信是一项关键的任务，而使用DMA（直接内存访问）结合IDLE中断进行串口编程，尤其是在STM32CubeMX环境中，能够提高系统的效率和性能。STM32CubeMX为STM32微控制器提供了图形化的配置工具，可以简化初始化代码的生成
  • RS232、RS485 和 DB9 接口详解 马上到我碗里来 汽车电子RS232RS485汽车电子DB9
    简介：本文介绍了RS232和RS485两种串行通信协议的物理层标准，以及它们与DB9接口的连接方式。此外，还介绍了RS485接口的全双工和半双工模式，以及它们的应用场景。1.DB9接口DB9接口是一种常见的D型连接器，具有9个针脚。它通常用于连接串行通信设备，例如计算机、打印机和路由器。2.RS232和RS485接口2.1RS232接口RS232接口是一种古老的串行通信协议，最初用于连接计算机和调
  • 【51单片机】串口（江科大） 2302_80796399 51单片机单片机嵌入式硬件c语言
    8.1串口通信1.串口介绍2.硬件电路3.电平标准电平标准是数据1和数据0的表达方式,是传输线缆中人为规定的电压与数据的对应关系,串口常用的电平标准有如下三种:·电平标准是数据1和数据O的表达方式,是传输线缆中人为规定的电压与数据的对应关系,串口常用的电平标准有如下三种:·TTL电平:+5V表示1,0V表示0·RS232电平:-3~-15V表示1,+3~+15V表示0·RS485电平:两线压差+2
  • 嵌入式Linux开发---RS485通信驱动硬件编程 牛马大师兄 嵌入式Linux经验教程linux嵌入式硬件arm开发驱动开发mcu物联网
    提醒：RS485的使用与UART串口的使用基本相同，差别在于使用485时需要手动切换485芯片的收发引脚模式。Linux驱动RS485通信的程序源码Demo见文末。1、RS485基础铺垫智能仪表随着80年代初单片机技术的成熟而发展起来，世界仪表市场基本被智能仪表所垄断，这归结于企业信息化的需要，而企业在仪表选型时其中的一个必要条件就是要具有联网通信接口。最初是数据模拟信号输出简单过程量，后来仪表接
  • STM32之USART 穿越过来的全栈工程师 stm32嵌入式硬件单片机
    概述串口通信，通用异步收发传输器（UniversalAsynchronousReceiver/Transmitter），简称UART；而USART（UniversalSynchronous/AsynchronousReceiver/Transmitter）通用同步收发传输器。USART主要用于产生相关接口的协议信号，如RS-232，RS485等；一、RS-232RS-232:它是由美国电子工业协会
  • 09 AB 10串口通信发送原理 Dale_e verilog学习fpga开发笔记经验分享学习
    通用异步收发传输器（UniversalAsynchronousReceiver/Transmitter，UART）是一种异步收发传输器，其在数据发送时将并行数据转换成串行数据来传输，在数据接收时将接收到的串行数据转换成并行数据，可以实现全双工传输和接收。它包括了RS232、RS449、RS423、RS422和RS485等接口标准规范和总线标准规范。换句话说，UART是异步串行通信的总称。而RS23
  • 操作系统杂项笔记 涵锐Vellichor Linux内核linux操作系统arm内核
    目录RS232和RS485通讯接口有什么区别用串口发送十个字节，丢失一个两个你会怎么检查中断能不能睡眠？中断为什么不能嵌套？linux中系统调用过程？Linux中的同步机制ARM处理器的寄存器复位后，ARM处理器处于SVC模式，ARM状态在ARMLinux系统中，中断处理程序进入C代码以后，ARM处于超级用户(SVC)工作模式在ARM系统结构中，MMU映射最小的单元空间是1KB，映射最大的单元空间
  • “智能检测，精准把控。温湿度检测系统，为您的生活带来全方位的健康保障。”#非标协议项目【上】 马哥成长记 学习嵌入式笔记单片机51单片机嵌入式硬件c语言学习
    “智能检测，精准把控。温湿度检测系统，为您的生活带来全方位的健康保障。”#非标协议项目【上】前言预备知识1温湿度检测系统需求2.代码整合2.1找到`编程实现LCD1602显示一行工程`，打开`代码文件`，将所需的`LCD1602驱动代码`拷贝到`温湿度检测系统_1602显示串口发送工程`内。2.2找到`串口编程03_PC发送指令控制LED`工程，打开`代码文件`，将所需的`LCD1602驱动代码`
  • 基于UCOSII的RS485通信(STM32F107) 噗噗bug 嵌入式stm32嵌入式硬件单片机arm
    一、实现效果基于ucosii实时操作系统的RS485通信，采用USART+DMA进行收发，二、开发环境开发工具：KEILV5开发板:STM32f107RC采用方式：USART+DMA使用系统：UCOSII三、RS485部分原理在RS-485通讯网络中，节点中的串口控制器使用RX与TX信号线连接到收发器上，而收发器通过差分线连接到网络总线，串口控制器与收发器之间一般使用TTL信号传输，收发器与总线则
  • VB.net写一个简易串口RS485调试助手 机构师 工业自动化编程VB.net实例应用python
    最近在调试带rs485串口通讯的设备，项目上主要是用PLC和串口通讯，因为PLC有集成好的串口块，使用起来比较容易，为了方便测试，就想着用上位机写一个简易的串口通讯程序，用于调试。在网上查找了一些资料后，基本上选择了两个方式，VB.net和python，python来写串口通讯程序，我在另一篇博客里面已经发了：https://blog.csdn.net/normer123456/article/d
  • RS485协议详解RS485与RS232优缺点比较 Coder-LiyG 网络
    RS485协议1、简介RS485也是UART协议，他是双向、半双工的通讯协议，双向代表可接收可发送，半双工代表同一时刻只能进行数据的接收或者数据的发送，而RS232是双向、全双工，也就是能同时收发数据。并且485采用差分的传输方式，与差分对应的是单端传输方式，并且允许多个驱动器和接收器挂在总线上，其中每个驱动器都能脱离总线！2、单端传输、差分传输单端传输：在传输过程中，我们使用一根导线，在这根导线
  • 串口调试助手读写三菱fx3u数据_用电脑通过串口（RS485）给三菱PLC（FX3U）发指令，怎样在梯形图里写接收串口数据的程序？... SuperSodaSea
    展开全部在PLC参数中设置串口参数、起始符和停止符。具体设e68a8462616964757a686964616f31333431373334置方法是：定义起始符02H，定义停止符为回车或其他即可。当串口检测到停止符，即会产生中断，通知PLC接收数据。梯形图语言是PLC程序设计中最常用的编程语言。它是与继电器线路类似的一种编程语言。由于电气设计人员对继电器控制较为熟悉，因此，梯形图编程语言得到了广
  • 工业智能网关BL110应用之四十二：COM口采集三菱PLC FX3U的配置 钡铼技术网关 工业智能网关bl110物联网智慧水利网络协议智慧水利网关智慧水利物联网关
    COM口采集三菱PLC的配置4个COM口的配置内容一样，COM1固定为RS232，COM2、COM3和COM4是RS232/RS485可选串口（默认为RS485）。因三菱FX3U是RS422接口，通过RS422转RS232线接到BL110网关上，故选择COM1口采集FX3U。1.1.1.1.1COM口的配置COM1通过RS422转RS232线连接三菱FX3U，COM1口配置如下：工业智能网关BL1
  • Hart转 Modbus 转换器 zr526855447 网络单片机嵌入式硬件物联网运维
    第一节功能说明HART转Modbus模块实现将HART信号中的数字信号转换为符合ModbusRTU/ASCII标准的RS485信号和RS232信号，实现仪表的数据读取功能。第二节主要技术指标技术参数描述供电及功耗7-24V电压供电，功耗小于1500mW输入信号HART总线信号处理器32位ARM处理器输出接口1路RS485(RS485-A2,RS495-B2)1路RS232(RS232-T,RS23
  • 485转LORA zr526855447 tcp/ip网络协议网络物联网php
    一、功能概述本产品是一款无线中继器，将RS485信号转为无线信号，通过无线方式远传，实现远程通信功能。采用Lora无线通信技术，工作中心频率433M，空旷传输距离7000米。二、接线、配置方法、指示灯状态1、指示灯指示灯作用PW电源指示灯SY系统指示灯，系统正常启动后闪烁TXLora信号发出或485信号接收（发送端闪烁）RXLora信号接收或485信号发送（接收端闪烁）CH1无用CH2无用E1无用
  • 睿尔曼超轻量仿人机械臂--通信及连接方式 睿尔曼学院 睿尔曼超轻仿人机械臂基础系列人工智能智能硬件机器人经验分享
    目录有线连接网线连接RS485转串口通信与USB串口通信无线连接WIFISTA模式连接WIFIAP模式有线连接网线连接①机械臂开机，使用网线将机械臂网口2与电脑网口相连。②打开电脑设置界面，打开网络与Internet（需设置电脑与机械臂处于同一网段）。③进入电脑设置界面，左侧菜单栏选择-->以太网-->更改适配器设置④双击以太网进入，进入以太网设置界面。⑤点击“属性”进入以太网属性界面，在此处双击
  • RS485网关如何采集传感器和仪器仪表数据-天拓四方 北京天拓四方科技股份有限公司 物联网其他网关rs485
    在自动化生产和监测系统中，传感器和仪器仪表扮演着重要的角色，它们可以收集各种数据，如温度、压力、流量等，并对这些数据进行必要的分析和处理。然而，如何有效地采集这些数据是一个关键问题。RS485网关是一种常见的设备，通过串行通讯接口RS485，实现多个设备之间的数据传输和控制。本文将详细介绍RS485网关如何采集传感器和仪器仪表数据。采集传感器和仪器仪表数据的步骤1、确定连接方式首先需要确定RS48
  • 港口集装箱堆场温湿度监控MQTT无线传输智能节点 钡铼技术物联网关 网络
    设备互联互通的时代已经到来，不同的设备之间需要实现数据互通，提高生产效率和管理效率。因此，一款功能齐全、性能稳定的设备显得尤为重要。我们来介绍一款4G/5G无线远程io模块。具有8DI兼容干湿节点、4DO继电器、6AI可选电流型4-20mA电压型0-5v的产品，同时支持1路RS485采集ModbusRTU协议。该产品通过多重通信协议实现设备互联互通，可实现多平台数据对接，提高数据采集效率。在具体使
  • 【嵌入式外设电路通讯原理】 光芒Shine #嵌入式电路嵌入式硬件
    通讯原理■简介■UART（UniversalAsynchronousReceiver/Transmitter）■设置■中断发送/接收■RS485■RS232■I2C■I2S■TCP/IP■CAN■SPI■简介■UART（UniversalAsynchronousReceiver/Transmitter）通用异步收发传输器（UniversalAsynchronousReceiver/Transmit
  • 什么可以用手机蓝牙控制LED？？？#串口通信【上】 马哥成长记 学习嵌入式笔记智能手机51单片机单片机c语言学习
    什么可以用手机蓝牙控制LED？？？#串口通信【上】前言预备知识1.串口的接线方式2.串口编程要素3.编程实现每秒发送数据给电脑3.1使用单片机下载器生成1000ms延时函数3.2使用单片机下载器实现波特率计算3.3查阅手册配置寄存器`AUXR`3.4完整程序代码3.5串口助手设置及显示4.串口编程寄存器分析4.1PCON电源控制寄存器配置4.1.1`PCON`电源控制寄存器示意图4.1.2`SMO
  • 插入表主键冲突做更新 a-john
    有以下场景： 用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 问题： 如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 解决： mysql中提供了一个sql语
  • Android xml资源文件中@、@android:type、@*、？、@+含义和区别 Cb123456 @+@?@*
    一.@代表引用资源 1.引用自定义资源。格式：@[package:]type/name android：text="@string/hello"   2.引用系统资源。格式：@android:type/name     android:textColor="@android:color/opaque_red"
  • 数据结构的基本介绍 天子之骄 数据结构散列表树、图线性结构价格标签
    数据结构的基本介绍 数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。   经典的数据结构大致如下：   一：线性数据结构 (1)：列表 a
  • 通过二维码开放平台的API快速生成二维码 一炮送你回车库 api
     现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。        html代码如下:(二维码将生成在这div下) ? 1  &nbs
  • ImageIO读取一张图片改变大小 3213213333332132 javaIOimageBufferedImage
    package com.demo; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; /** * @Description 读取一张图片改变大小 * @author FuJianyon
  • myeclipse集成svn（一针见血） 7454103 eclipseSVNMyEclipse
                                     &n
  • 装箱与拆箱----autoboxing和unboxing darkranger J2SE
    4.2　自动装箱和拆箱 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 4.2.1　autoboxing和unboxing 在Java中，所有要处理的东西几乎都是对象(Object)
  • ajax传统的方式制作ajax aijuans Ajax
    //这是前台的代码 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
  • 只用jre的eclipse是怎么编译java源文件的？ avords javaeclipsejdktomcat
    eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ &nb
  • 前端模块化 bee1314 模块化
    背景： 前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。   JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
  • 处理百万级以上的数据处理 bijian1013 oraclesql数据库大数据查询
    一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。         2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
  • mac 卸载 java 1.7 或更高版本 征客丶 javaOS
    卸载 java 1.7 或更高 sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 成功执行此命令后，还可以执行 java 与 javac 命令 sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 成功执行此命令后，还可以执行 java
  • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析 bit1129 Stream
    第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 第二部，Spark Streaming读取Kafka中的数据，进行实时分析   本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
  • Erlang vs TNSDL bookjovi erlang
          TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
  • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个 ljy325 企业应用
    　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 相关新闻： （1）IT行业成五大疾病重灾区：过劳死平均37.9岁
  • 读《研磨设计模式》-代码笔记-原型模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * Effective Java 建议使用copy constructor or copy factory来代替clone()方法： * 1.public Product copy(Product p){} * 2.publi
  • 配置管理---svn工具之权限配置 chenyu19891124 SVN
    今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 pepos    component    webapps 在conf里面的auth里赋予的权限配置为 [groups]
  • 浅谈程序员的数学修养 comsci 设计模式编程算法面试招聘
                                     浅谈程序员的数学修养
  • 批量执行 bulk collect与forall用法 daizj oraclesqlbulk collectforall
    BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。     有关FORALL语句的用法请参考：批量SQL之 F
  • Linux下使用rsync最快速删除海量文件的方法 dongwei_6688 OS
    1、先安装rsync：yum install rsync 2、建立一个空的文件夹：mkdir /tmp/test 3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。
  • Yii CModel中rules验证规格 dcj3sjt126com rulesyiivalidate
    Yii cValidator主要用法分析：  yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError  
  • 基于vagrant的redis主从实验 dcj3sjt126com vagrant
    平台: Mac 工具: Vagrant 系统: Centos6.5 实验目的: Redis主从   实现思路 制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box   制作sentos6.5+redis的box   mkdir vagrant_redis cd vagrant_
  • Memcached(二)、Centos安装Memcached服务器 frank1234 centosmemcached
    一、安装gcc rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]： 建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码...... rpm -ivh kernel-head
  • Remove Duplicates from Sorted List hcx2013 remove
    Given a sorted linked list, delete all duplicates such that each element appear only once. For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
  • Spring4新特性——JSR310日期时间API的支持 jinnianshilongnian spring4
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • 浅谈enum与单例设计模式 247687009 java单例
    在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构 造器，导出静态成员变量，以便调用者访问。 第一种 package singleton; public class Singleton { //导出全局成员 public final static Singleton INSTANCE = new S
  • 使用switch条件语句需要注意的几点 openwrt cbreakswitch
    1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 int main() { int n = 1; switch(n) { case 1: printf("--1--\n"); default: printf("defa
  • 配置Spring Mybatis JUnit测试环境的应用上下文 schnell18 springmybatisJUnit
    Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 单元测试的app context不支持从外部properties文件注入属性 @Value注解不能解析带通配符的路径字符串 解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 第二个问题的具体实例是：    
  • Java 定时任务总结一 tuoni javaspringtimerquartztimertask
     Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
  • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法 yangshangchuan rank相似度计算文本相似度词袋模型余弦相似度
    本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。   最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下：     1、注册多个账号（一般10个以上）。     2、从多个账号中选择一个账号，发表1-2篇博文
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他