zoukankan      html  css  js  c++  java
  • uart 超声波传感器数据读取

    • 传感器选择

        淘宝上搜索 US-100 , 价格大概在17块人民币左右。
    
    • 读取数据的代码如下:

        // include/aplex_tty.h
        #ifndef _APLEX_TTY_H__                                                          
        #define _APLEX_TTY_H__                                                          
                                                                                    
        #include <stdio.h>                                                              
        #include <stdlib.h>                                                             
        #include <string.h>                                                             
        #include <sys/types.h>                                                          
        #include <sys/stat.h>                                                           
        #include <fcntl.h>                                                              
        #include <unistd.h>                                                             
        #include <termios.h>                                                            
        #include <string.h>                                                             
        #include <errno.h>                                                              
        #include <unistd.h>                                                             
                                                                                    
        int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop);             
        float read_dis(void);                                                           
                                                                                    
        #endif        
    
        // src/aplex_tty.c      
        #include "../include/aplex_tty.h"                                               
                                                                                    
        int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop)              
        {                                                                               
            struct termios newtio, oldtio;                                              
            if(tcgetattr(fd, &oldtio) != 0)                                             
            {                                                                           
                perror("SetupSerial 1");                                                
                return -1;                                                              
            }                                                                           
            bzero(&newtio, sizeof(newtio));                                             
            newtio.c_cflag |= CLOCAL | CREAD;   //CLOCAL:忽略modem控制线  CREAD:打开接受者
            newtio.c_cflag &= ~CSIZE;           //字符长度掩码。取值为:CS5,CS6,CS7或CS8
                                                                                    
            switch( nBits )                                                             
            {                                                                           
            case 7:                                                                     
                newtio.c_cflag |= CS7;                                                  
                break;                                                                  
            case 8:                                                                     
                newtio.c_cflag |= CS8;                                                  
                break;                                                                  
            }                                                                           
                                                                                    
            switch( nEvent )                                                            
            {                                                                           
            case 'O':                                                                   
                newtio.c_cflag |= PARENB;           //允许输出产生奇偶信息以及输入到奇偶校验
                newtio.c_cflag |= PARODD;           //输入和输出是奇及校验              
                newtio.c_iflag |= (INPCK | ISTRIP); // INPACK:启用输入奇偶检测;ISTRIP:去掉第八位
                break;                                                                  
            case 'E':                                                                   
                newtio.c_iflag |= (INPCK | ISTRIP);                                     
                newtio.c_cflag |= PARENB;                                               
                newtio.c_cflag &= ~PARODD;                                              
                break;                                                                  
            case 'N':                                                                   
                newtio.c_cflag &= ~PARENB;                                              
                break;                                                                  
            }                                                                           
                                                                                    
            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;                                                                  
            }                                                                           
                                                                                    
            if( nStop == 1 )                                                            
                newtio.c_cflag &=  ~CSTOPB;     //CSTOPB:设置两个停止位,而不是一个     
            else if ( nStop == 2 )                                                      
                newtio.c_cflag |=  CSTOPB;                                              
                                                                                    
            newtio.c_cc[VTIME]  = 0;            //VTIME:非cannoical模式读时的延时,以十分之一秒位单位
            newtio.c_cc[VMIN] = 0;              //VMIN:非canonical模式读到最小字符数    
            tcflush(fd,TCIFLUSH);               // 改变在所有写入 fd 引用的对象的输出都被传输后生效,所有已接受但未读入的输入都在改变发生前丢弃。
            if((tcsetattr(fd,TCSANOW,&newtio))!=0) //TCSANOW:改变立即发生               
            {                                                                           
                perror("com set error");                                                
                return -1;                                                              
            }                                                    
            printf("set done!
    
    ");                                                    
            return 0;                                                                   
        }                                                                               
                                                                                    
        float read_dis(void)                                                            
        {                                                                               
            float distant = 0;                                                          
            int tty_fd, retval;                                                         
            int write_val = 0x55;                                                       
            char read_val[2];                                                           
                                                                                    
            tty_fd = open("/dev/ttyO0", O_RDWR | O_NOCTTY | O_NDELAY);                  
            if (tty_fd < 0)                                                             
            {                                                                           
                perror("open tty error ");                                              
                return -1;                                                              
            }                                                                           
                                                                                    
            retval = set_opt(tty_fd, 9600, 8, 'N', 1);                                  
            if (retval < 0)                                                             
            {                                                                           
                perror("set error");                                                    
                return -1;                                                              
            }                                                                           
                                                                                        
            retval = write(tty_fd, &write_val, sizeof(int));                            
            if (retval < 0)                                                             
            {                                                                           
                perror("write error");                                                  
                return -1;                                                              
            }      
                                                                                    
            usleep(100000);                                                             
                                                                                    
           retval = read(tty_fd, read_val, 2);                                         
            if (retval < 0)                                                             
            {                                                                           
                perror("read errno");                                                   
                return -1;                                                              
            }                                                                           
                                                                                    
            distant = read_val[0] * 256 + read_val[1] ;                                 
                                                                                    
            close(tty_fd);                                                              
                                                                                    
            return distant;                                                             
        }      
    
        // main/main.c
        #include "../include/aplex_tty.h"                                               
                                                                                    
        int main(void)                                                                  
        {                                                                               
            float read_dis_num = 0;                                                     
                                                                                    
            read_dis_num = read_dis();                                                  
                                                                                    
            printf(" distant : %f
    ", read_dis_num / 1000);                             
                                                                                    
            return 0;                                                                   
        }                                          
    
  • 相关阅读:
    数据恢复基础知识
    Url传递中文终极解决办法
    用来实现Web页面图片移动托拽的代码段
    FAT文件系统原理
    SQL数据库恢复技术
    使用Ghost错选恢复分区后
    全手工数据恢复
    C#class的Dispose和Finalize模板
    SQL语句 嵌套查询
    逻辑数据库设计 无视约束(谈外键)
  • 原文地址:https://www.cnblogs.com/chenfulin5/p/7298764.html
Copyright © 2011-2022 走看看