中国领先的IT技术网站
|
|
创建专栏

使用嵌入式开发板实现对车位锁控制的流程及程序实现

本文介绍了通过嵌入式开发板控制车位锁开关的流程,并给出了完整的C代码实现。

作者:周兆熊|2017-05-05 14:02

【技术沙龙】AI开发者实战营-7分钟打造1个定制技能。7月22号,我们等你一起!


随着城市化进程的加快,新能源汽车呼之欲出。在笔者所在的城市,力帆和长安等公司都先后推出了可供市民租用的电动汽车。在享受租车所带来的便利的同时,汽车的充电就成了一个难题,在城市道路和停车场安装充电桩成为解决这个问题的一个有效的手段。汽车充电时,需要有一个可用于停靠的车位,并且这个车位只能在汽车充电的时候使用,在其他时间都不能被占用。也就是说,每个充电的车位需要有一个车位锁,当有汽车充电的时候,车位锁打开,否则车位锁关闭。

本文用嵌入式开发板实现了对车位锁开关的控制,可供相关项目的开发人员参考。

一、硬件选型

在嵌入式开发板这块,我们选择了天嵌科技的TQ335X开发板,如下图所示:

天嵌科技的TQ335X开发板

在车位锁这块,我们选择了泊享网络的带RS485的车位锁,如下图所示:

泊享网络的带RS485的车位锁

二、电路连接

嵌入式开发板通过RS485方式和车位锁相连,RS485的电路原理图如下所示:

这里写图片描述

如上图所示,电路为TTL转RS485电路,通过跳线SW5接口相应配置,使之与串口2相连。

为了实现485通信功能,板载SW5的跳线选择方式如下图所示:

这里写图片描述

对于车位锁与开发板的连接,要将车位锁的红色连接线(+)与485的A端相连,将车位锁的黄色连接线(-)与485的B端相连。

三、软件开发环境

由于嵌入式开发板使用的是裁剪版的Linux(ubuntu),因此需要在办公电脑(windows系统)上安装对应的交叉编译环境。

首先,我们要安装Vmware虚拟机,笔者使用的虚拟机版本如下图所示:

Vmware虚拟机

接着,我们要将嵌入式系统配备的资料光盘中的裁剪版的Linux(ubuntu)系统安装到虚拟机上,以供编译程序时使用。笔者使用的ubuntu版本如下图所示:

ubuntu版本

在安装了ubuntu之后,还要将交叉编译器装载到系统中。交叉编译器的安装过程可以参看开发板使用手册,只要按照手册中的步骤(如下图所示)安装就可以了。

将交叉编译器装载到系统中

四、车位锁协议

我们使用程序通过向车位锁下发指令来控制其开关并获取其状态。车位锁的协议如下图所示:

车位锁的协议

具体而言,各命令的样例如下:

1.开锁命令:55 ADDR 01 01 CRC AA

  • 接收成功返回 5A ADDR 02 01 01 CRC AA
  • 接收失败返回 5B ADDR 03 01 01 00 CRC AA

2.闭锁命令:55 ADDR 01 02 CRC AA

  • 接收成功返回 5A ADDR 02 02 01 CRC AA
  • 接收失败返回 5B ADDR 03 02 01 00 CRC AA

3.读取锁状态:55 ADDR 01 06 CRC AA

  • 执行成功返回 5A ADDR 02 06 STATUS CRC AA
  • 接收失败返回 5B ADDR 03 06 01 00 CRC AA

注:STATUS 各状态为:00-闭锁状态,01-开锁状态,02-中间状态0~90°,03-中间状态90~180°,88-运动状态,10-当前开锁状态并且检测到上面无车。

五、程序编写

有了开发环境,有了协议,那么接下来我们就可以开始编写程序了。根据我们在第二部分的描述,程序要通过串口来连接RS485电路,因此,程序的大体流程为:初始化串口—>向串口发消息—>接收串口的响应消息—>关闭串口。

完整的C代码(LockCtrl.h和LockCtrl.c)如下所示:

  1. #include <errno.h> 
  2. #include <stdio.h> 
  3. #include <string.h> 
  4. #include <stdlib.h> 
  5. #include <stdio.h>  
  6. #include <stdlib.h>  
  7. #include <unistd.h>  
  8. #include <sys/types.h>  
  9. #include <sys/stat.h>  
  10. #include <fcntl.h>      //文件控制定义  
  11. #include <termios.h>    //终端控制定义  
  12. #include <errno.h>  
  13.  
  14. #define DEVICE "/dev/ttySAC2"  
  15.  
  16.  
  17. int init_serial(void);  // 打开串口并初始化设置 
  18. int uart_send(int fd, char *data, int datalen);   // 串口发送数据 
  19. int uart_recv(int fd, char *data, int datalen);    // 串口接收数据 
  20. int OpenLock(void);      // 开车位锁 
  21. int CloseLock(void);     // 关车位锁 
  22. int GetLockStatus(void); // 获取车位锁 状态 

LockCtrl.c代码内容:

  1. #include "LockCtrl.h" 
  2.  
  3. int serial_fd = 0;  
  4.  
  5. // 打开串口并初始化设置 
  6. int init_serial(void)  
  7. {  
  8.     serial_fd = open(DEVICE, O_RDWR | O_NOCTTY | O_NDELAY);  
  9.     if (serial_fd < 0)  
  10.     {  
  11.         perror("open");  
  12.         return -1;  
  13.     }  
  14.     //串口主要设置结构体termios <termios.h>  
  15.     struct termios options;  
  16.  
  17.     /**1. tcgetattr函数用于获取与终端相关的参数。  
  18.       *    参数fd为终端的文件描述符,返回的结果保存在termios结构体中  
  19.       */  
  20.     tcgetattr(serial_fd, &options);  
  21.  
  22.     /*2. 修改所获得的参数*/  
  23.     options.c_cflag |= (CLOCAL | CREAD);    // 设置控制模式状态,本地连接,接收使能  
  24.     options.c_cflag &= ~CSIZE;              // 字符长度,设置数据位之前一定要屏掉这个位  
  25.     options.c_cflag &= ~CRTSCTS;            // 无硬件流控  
  26.     options.c_cflag |= CS8;                 // 8位数据长度  
  27.     options.c_cflag &= ~CSTOPB;             // 1位停止位 
  28.     options.c_iflag |= IGNPAR;              // 无奇偶检验位  
  29.     options.c_oflag = 0;                    // 输出模式  
  30.     options.c_lflag = 0;                    // 不激活终端模式  
  31.     cfsetospeed(&options, B9600);           // 设置波特率  
  32.  
  33.     /**3. 设置新属性,TCSANOW:所有改变立即生效*/  
  34.     tcflush(serial_fd, TCIFLUSH);           // 溢出数据可以接收,但不读  
  35.     tcsetattr(serial_fd, TCSANOW, &options);  
  36.  
  37.     return 0;  
  38. }  
  39.  
  40.  
  41. /**  
  42. *串口发送数据  
  43. *@fd:串口描述符  
  44. *@data:待发送数据  
  45. *@datalen:数据长度  
  46. */  
  47. int uart_send(int fd, char *data, int datalen)  
  48. {  
  49.     int len = 0;  
  50.     len = write(fd, data, datalen);    // 实际写入的长度  
  51.  
  52.     printf("uart_send:len=%d,datalen=%d\n", len, datalen);  
  53.  
  54.     if (len == datalen)      // 发送成功 
  55.     {  
  56.         return len;  
  57.     }  
  58.     else  
  59.     {  
  60.         tcflush(fd, TCOFLUSH);   // TCOFLUSH刷新写入的数据但不传送  
  61.         return -1;  
  62.     }  
  63.  
  64.     // return 0;  
  65. }  
  66.  
  67.  
  68. /**  
  69. *串口接收数据  
  70. *要求启动后,在pc端发送ascii文件  
  71. */  
  72. int uart_recv(int fd, char *data, int datalen)  
  73. {  
  74.     int len = 0ret = 0;  
  75.     fd_set fs_read;  
  76.     struct timeval tv_timeout;  
  77.  
  78.     FD_ZERO(&fs_read);  
  79.     FD_SET(fd, &fs_read);  
  80.     tv_timeout.tv_sec = (10*20/115200+2);  
  81.     tv_timeout.tv_usec = 0;  
  82.  
  83.     ret = select(fd+1, &fs_read, NULL, NULL, &tv_timeout);  
  84.     printf("ret = %d\n", ret);   //如果返回0,代表在描述符状态改变前已超过timeout时间,错误返回-1  
  85.  
  86.     if (FD_ISSET(fd, &fs_read))  
  87.     {  
  88.         len = read(fd, data, datalen);  
  89.         printf("len = %d\n", len);  
  90.         return len;  
  91.     }  
  92.     else  
  93.     {  
  94.         perror("select");  
  95.         return -1;  
  96.     }  
  97.  
  98.     // return 0;  
  99. }  
  100.  
  101. /**  
  102. *开车位锁  
  103. */  
  104. int OpenLock(void)  
  105. {  
  106.     int  iDataLen      = 0
  107.     int  iRetVal       = 0
  108.     char szRcvBuf[20]  = {0}; 
  109.  
  110.     unsigned char szOpen[6] = {0x55,0x01,0x01,0x01,0x9A,0xAA};     // 55 01 01 01 9A AA 
  111.  
  112.     iRetVal = init_serial();  
  113.     if (iRetVal != 0) 
  114.     { 
  115.         printf("OpenLock: exec init_serial failed!\n"); 
  116.         return -1; 
  117.     } 
  118.  
  119.     iDataLen = uart_send(serial_fd, szOpen, sizeof(szOpen)); 
  120.     if (iDataLen == -1) 
  121.     { 
  122.         printf("OpenLock: exec uart_send failed!\n"); 
  123.         return -1; 
  124.     } 
  125.  
  126.     iDataLen = uart_recv(serial_fd, szRcvBuf, sizeof(szRcvBuf)); 
  127.     if (iDataLen == -1) 
  128.     { 
  129.         printf("OpenLock: exec uart_recv failed!\n"); 
  130.         return -1; 
  131.     } 
  132.  
  133.     printf("OpenLock: received len=%d\n", iDataLen);  
  134.  
  135.     if (szRcvBuf[0] == 0x5A) 
  136.     { 
  137.         printf("OpenLock: open lock success!\n"); 
  138.     } 
  139.     else if (szRcvBuf[0] == 0x5B) 
  140.     { 
  141.         printf("OpenLock: open lock failed!\n");  
  142.     } 
  143.     else 
  144.     { 
  145.         printf("OpenLock: received data is wrong!\n");  
  146.     } 
  147.  
  148.     close(serial_fd);  
  149.  
  150.     return 0; 
  151.  
  152.  
  153. /**  
  154. *关车位锁  
  155. */  
  156. int CloseLock(void)  
  157. {  
  158.     int  iDataLen      = 0
  159.     int  iRetVal       = 0
  160.     char szRcvBuf[20]  = {0}; 
  161.  
  162.     unsigned char szClose[6] = {0x55,0x01,0x01,0x02,0x78,0xAA};    // 55 01 01 02 78 AA  
  163.  
  164.     iRetVal = init_serial();  
  165.     if (iRetVal != 0) 
  166.     { 
  167.         printf("CloseLock: exec init_serial failed!\n"); 
  168.         return -1; 
  169.     } 
  170.  
  171.     iDataLen = uart_send(serial_fd, szClose, sizeof(szClose)); 
  172.     if (iDataLen == -1) 
  173.     { 
  174.         printf("CloseLock: exec uart_send failed!\n"); 
  175.         return -1; 
  176.     } 
  177.  
  178.     iDataLen = uart_recv(serial_fd, szRcvBuf, sizeof(szRcvBuf)); 
  179.     if (iDataLen == -1) 
  180.     { 
  181.         printf("CloseLock: exec uart_recv failed!\n"); 
  182.         return -1; 
  183.     } 
  184.  
  185.     printf("CloseLock: received len=%d\n", iDataLen);  
  186.  
  187.     if (szRcvBuf[0] == 0x5A) 
  188.     { 
  189.         printf("CloseLock: close lock success!\n"); 
  190.     } 
  191.     else if (szRcvBuf[0] == 0x5B) 
  192.     { 
  193.         printf("CloseLock: close lock failed!\n");  
  194.     } 
  195.     else 
  196.     { 
  197.         printf("CloseLock: received data is wrong!\n");  
  198.     } 
  199.  
  200.     close(serial_fd);  
  201.  
  202.     return 0; 
  203.  
  204.  
  205. /**  
  206. *获取车位锁 状态 
  207. */  
  208. int GetLockStatus(void)  
  209. {  
  210.     int  iDataLen      = 0
  211.     int  iRetVal       = 0
  212.     char szRcvBuf[20]  = {0}; 
  213.  
  214.     unsigned char szStatus[6] = {0x55,0x01,0x01,0x06,0x19,0xAA};   // 55 01 01 06 19 AA  
  215.  
  216.     iRetVal = init_serial();  
  217.     if (iRetVal != 0) 
  218.     { 
  219.         printf("GetLockStatus: exec init_serial failed!\n"); 
  220.         return -1; 
  221.     } 
  222.  
  223.     iDataLen = uart_send(serial_fd, szStatus, sizeof(szStatus)); 
  224.     if (iDataLen == -1) 
  225.     { 
  226.         printf("GetLockStatus: exec uart_send failed!\n"); 
  227.         return -1; 
  228.     } 
  229.  
  230.     iDataLen = uart_recv(serial_fd, szRcvBuf, sizeof(szRcvBuf)); 
  231.     if (iDataLen == -1) 
  232.     { 
  233.         printf("GetLockStatus: exec uart_recv failed!\n"); 
  234.         return -1; 
  235.     } 
  236.  
  237.     printf("GetLockStatus: received len=%d\n", iDataLen);  
  238.  
  239.     if (szRcvBuf[0] == 0x5A) 
  240.     { 
  241.         printf("GetLockStatus: get lock status success!\n"); 
  242.  
  243.         if (szRcvBuf[4] == 0x00) 
  244.         { 
  245.             printf("Locked!\n"); 
  246.         } 
  247.         else if (szRcvBuf[4] == 0x01) 
  248.         { 
  249.             printf("Opened!\n"); 
  250.         } 
  251.         else if (szRcvBuf[4] == 0x02) 
  252.         { 
  253.             printf("Middle status(0~90)!\n"); 
  254.         } 
  255.         else if (szRcvBuf[4] == 0x03) 
  256.         { 
  257.             printf("Middle status(90~180)!\n"); 
  258.         } 
  259.         else if (szRcvBuf[4] == 0x88) 
  260.         { 
  261.             printf("Running status!\n"); 
  262.         } 
  263.         else if (szRcvBuf[4] == 0x10) 
  264.         { 
  265.             printf("Opened and no car on it!\n"); 
  266.         } 
  267.     } 
  268.     else if (szRcvBuf[0] == 0x5B) 
  269.     { 
  270.         printf("GetLockStatus: Get lock status failed!\n");  
  271.     } 
  272.     else 
  273.     { 
  274.         printf("GetLockStatus: GetLockStatus: received data is wrong!\n");  
  275.     } 
  276.  
  277.     close(serial_fd);  
  278.  
  279.     return 0; 
  280.  
  281.  
  282. // 主函数 
  283. int main(int argc, char **argv)  
  284. {  
  285.     int iRetVal = 0
  286.  
  287.     // 开锁 
  288.     iRetVal = OpenLock(); 
  289.     if (iRetVal != 0) 
  290.     { 
  291.         printf("Open lock failed!\n"); 
  292.         return -1; 
  293.     } 
  294.  
  295.     // 闭锁 
  296.     sleep(10); 
  297.     iRetVal = CloseLock(); 
  298.     if (iRetVal != 0) 
  299.     { 
  300.         printf("Close lock failed!\n"); 
  301.         return -1; 
  302.     } 
  303.  
  304.     // 开锁 
  305.     sleep(10); 
  306.     iRetVal = OpenLock(); 
  307.     if (iRetVal != 0) 
  308.     { 
  309.         printf("Open lock failed!\n"); 
  310.         return -1; 
  311.     } 
  312.  
  313.     // 获取车位锁 状态 
  314.     sleep(10); 
  315.     iRetVal = GetLockStatus(); 
  316.     if (iRetVal != 0) 
  317.     { 
  318.         printf("Get lock status failed!\n"); 
  319.         return -1; 
  320.     } 
  321.  
  322.     return 0;  

六、程序编译及运行

将LockCtrl.c和LockCtrl.h文件拷贝到交叉编译环境上,并使用“arm-linux-gcc -g -o LockCtrl LockCtrl.c”命令编译程序,生成LockCtrl文件。

接着,通过FTP工具或“ftpget -u XXX -p XXX 10.10.10.10 LockCtrl”命令将LockCtrl文件上传到嵌入式开发板的特定目录下,修改权限之后执行“./LockCtrl”命令,可以看到程序正常运行,车位锁成功执行了开关操作。程序的输出如下:

  1. [root@EmbedSky local]# ./LockCtrl 
  2. uart_send:len=6,datalen=6 
  3. ret = 1 
  4. len = 7 
  5. OpenLock: received len=7 
  6. OpenLock: open lock success! 
  7. uart_send:len=6,datalen=6 
  8. ret = 1 
  9. len = 7 
  10. CloseLock: received len=7 
  11. CloseLock: close lock success! 
  12. uart_send:len=6,datalen=6 
  13. ret = 1 
  14. len = 7 
  15. OpenLock: received len=7 
  16. OpenLock: open lock success! 
  17. uart_send:len=6,datalen=6 
  18. ret = 1 
  19. len = 7 
  20. GetLockStatus: received len=7 
  21. GetLockStatus: get lock status success! 
  22. Opened! 

七、总结

本文介绍了通过嵌入式开发板控制车位锁开关的流程,并给出了完整的C代码实现。对于嵌入式开发,大家不仅要懂得如何编写程序,还要了解开发板的电路原理及接线方式,这对开发者提出了更高的要求。

【本文是51CTO专栏作者周兆熊的原创文章,作者微信公众号:周氏逻辑(logiczhou)】

戳这里,看该作者更多好文

【编辑推荐】

  1. 物联网兴起 嵌入式系统安全日益受到关注
  2. AMD 嵌入式R系列APU助力三星数字标牌系统
  3. 怎么选择合适的嵌入式设计软件?
  4. 物联网兴起 嵌入式系统安全日益受关注
  5. 完美支持Android Things的开发板都在这里了
【责任编辑:IT疯 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

热门职位+更多

× Python一种神奇的语言