【英蓓特I.MX8M MaaXBoard开发板】试用-Zigbee网关

断点0216

  上一篇在MaaXBoard安装了qtcreator，并通过qt实现了仪表和曲线图控件，但显示的数据是程序模拟的，并非真实的外部数据。今天抽空来让MaaXBoard与Zigbee碰撞一下。本篇MaaXBoard将作为物联网网关，与Zigbee网络的协调器通过串口连接。Zigbee协调器负责创建和维护网络，是网络中的唯一节点，Zigbee终端负责加入网络，将采集到的传感器数据无线传输给协调器。协调器通过串口传给MaaXBoard。

  接线方式如下：

  协调器1个

  终端3个

  数据传输方式采用广播的方式。

  数据发送部分代码：

1. void SampleApp_SendPeriodicMessage( void )
   
2. {
   
3.   byte SendData[18]="end1,hello world!";
   
4.   if( AF_DataRequest( &SampleApp_Periodic_DstAddr,
   
5.                        &SampleApp_epDesc,
   
6.                        SAMPLEAPP_PERIODIC_CLUSTERID,
   
7.                        17,
   
8.                        SendData,
   
9.                        &SampleApp_TransID,
   
10.                        AF_DISCV_ROUTE,
    
11.                        AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )
    
12.   {
    
13.   }
    
14.   else
    
15.   {
    
16.     HalLedSet(HAL_LED_1, HAL_LED_MODE_ON);
    
17.     // Error occurred in request to send.
    
18.   }
    
19. }

复制代码

  数据接收处理代码

1. void SampleApp_MessageMSGCB( afIncomingMSGPacket_t *pkt )
   
2. {
   
3.   uint16 flashTime;
   
4.   byte buf[18];
   
5.   byte tmpbuf[10];
   
6. 
   
7.   switch ( pkt->clusterId )
   
8.   {
   
9.     case SAMPLEAPP_PERIODIC_CLUSTERID: //收到广播数据
   
10.       osal_memset(buf, 0 , 18);
    
11.       osal_memcpy(buf, pkt->cmd.Data, 17); //复制数据到缓冲区中
    
12.       
    
13.       if(buf[0]=='e' && buf[1]=='n' && buf[2]=='d')
    
14.       {
    
15.           HalLedBlink(HAL_LED_1, 0, 50, 500);//如果是则Led1间隔500ms闪烁
    
16. #if defined(ZDO_COORDINATOR)
    
17.           SampleApp_SendPeriodicMessage();
    
18.           HalUARTWrite(0,"Receive data from ", strlen("Receive data from "));//串口发送
    
19.           HalUARTWrite(0,buf, 4);
    
20.           HalUARTWrite(0,"\n", 1);
    
21. #endif
    
22.       }
    
23.       else
    
24.       {
    
25.           HalLedSet(HAL_LED_1, HAL_LED_MODE_ON);                  
    
26.       }
    
27.       break;
    
28. 
    
29.     case SAMPLEAPP_FLASH_CLUSTERID: //收到组播数据
    
30.       flashTime = BUILD_UINT16(pkt->cmd.Data[1], pkt->cmd.Data[2] );
    
31.       HalLedBlink( HAL_LED_4, 4, 50, (flashTime / 4) );
    
32.       break;
    
33.   }
    
34. }

复制代码

  接下来是MaaXBoard串口的读取，这里有段小插曲，之前没有留意到板卡的40pin还有个串口2，我一直用的USB转TTL的串口转换板。接入后执行lsusb命令，已经能看到CH340的设备，但是在/dev目录下怎么也找不到设备（或者说根本区分不出哪个设备是USB串口），开发指南和说明文档上也没有关于USB转串口这部分的说明。好在仔细浏览了一遍文档，才发现有TTL串口。

  串口设备找到了，那就用吧。创建一个c文件myuart.c。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <time.h>
   
5. #include <pthread.h>
   
6. #include <string.h>
   
7. #include <stdio.h>
   
8. #include <stdlib.h>
   
9. #include <unistd.h>
   
10. #include <fcntl.h>
    
11. #include <sys/ioctl.h>
    
12. #include <termios.h>
    
13. #include <sys/types.h>
    
14. 
    
15. int Option_Set(int fd,int baudRate,int nBits,char nEvent,int nStop)
    
16. {
    
17.         struct termios newtio,oldtio;
    
18.         if(tcgetattr(fd,&oldtio)!=0)
    
19.         {               
    
20.                 return -1;
    
21.         }
    
22.         bzero(&newtio,sizeof(newtio));
    
23.         newtio.c_cflag |= CLOCAL |CREAD;
    
24.         newtio.c_iflag &= ~CSIZE;
    
25.         switch(nBits)
    
26.         {
    
27.                 case 5:
    
28.                         newtio.c_cflag |= CS5;
    
29.                         break;
    
30.                 case 6:
    
31.                         newtio.c_cflag |= CS6;
    
32.                         break;
    
33.                 case 7:
    
34.                         newtio.c_cflag |= CS7;
    
35.                         break;
    
36.                 case 8:
    
37.                         newtio.c_cflag |=CS8;
    
38.                         break;
    
39.                 default:
    
40.                         newtio.c_cflag |=CS8;
    
41.                         break;
    
42.         }
    
43.         switch(nEvent)
    
44.         {
    
45.                 case 'o':
    
46.                         newtio.c_cflag |= PARENB;
    
47.                         newtio.c_cflag |=PARODD;
    
48.                         newtio.c_iflag |=(INPCK | ISTRIP);
    
49.                         break;
    
50.                 case 'E':
    
51.                         newtio.c_iflag |=(INPCK | ISTRIP);
    
52.                         newtio.c_cflag |=PARENB;
    
53.                         newtio.c_cflag &= ~PARODD;
    
54.                         break;
    
55.                 case 'N':
    
56.                         newtio.c_cflag &= ~PARENB;
    
57.                         break;
    
58.                 default:
    
59.                         newtio.c_cflag &= ~PARENB;
    
60.                         break;
    
61. 
    
62.         }
    
63.         switch(baudRate)
    
64.         {  
    
65.                 case 2400:
    
66.                         cfsetispeed(&newtio,B2400);
    
67.                         cfsetospeed(&newtio,B2400);
    
68.                         break;
    
69.                 case 4800:
    
70.                         cfsetispeed(&newtio,B4800);
    
71.                         cfsetospeed(&newtio,B4800);
    
72.                         break;
    
73.                 case 9600:
    
74.                         cfsetispeed(&newtio,B9600);
    
75.                         cfsetospeed(&newtio,B9600);
    
76.                         break;
    
77.                 case 57600:
    
78.                         cfsetispeed(&newtio,B57600);
    
79.                         cfsetospeed(&newtio,B57600);
    
80.                         break;
    
81.                 case 115200:
    
82.                         cfsetispeed(&newtio,B115200);
    
83.                         cfsetospeed(&newtio,B115200);
    
84.                         break;
    
85.                 case 460800:
    
86.                         cfsetispeed(&newtio,B460800);
    
87.                         cfsetospeed(&newtio,B460800);
    
88.                         break;
    
89.                 default:
    
90.                         cfsetispeed(&newtio,B9600);
    
91.                         cfsetospeed(&newtio,B9600);
    
92.                         break;
    
93.         }
    
94.         if(nStop == 1)
    
95.         {
    
96.                 newtio.c_cflag &= ~CSTOPB;
    
97.         }
    
98.         else if(nStop == 2)
    
99.         {
    
100.                 newtio.c_cflag |= CSTOPB;
     
101.         }
     
102.         newtio.c_cc[VTIME] = 0;
     
103.         newtio.c_cc[VMIN] = 1;
     
104.         tcflush(fd,TCIFLUSH);
     
105.         if((tcsetattr(fd,TCSANOW,&newtio))!=0)
     
106.         {
     
107.                 printf("com set error");
     
108.                 return -1;
     
109.         }
     
110.         return 0;
     
111. }
     
112. 
     
113. 
     
114. int SerialInit(const char* ttyName,int baudRate,int nBits,char nEvent,int nStop)
     
115. {
     
116.         if (NULL == ttyName)
     
117.         {
     
118.                 printf("ttyName is NULL");
     
119.                 return -1;
     
120.         }
     
121.         int nComFd = 0;
     
122.         nComFd = open(ttyName, O_RDWR|O_NOCTTY);
     
123.         if (nComFd <= 0 )
     
124.         {
     
125.                 printf("Couldn't open %s", ttyName);               
     
126.                 return -2;
     
127.         }
     
128.         else
     
129.         {
     
130.                 printf("open %s success!", ttyName);        
     
131.         }
     
132.         Option_Set(nComFd,baudRate,nBits,nEvent,nStop);
     
133.         fcntl( nComFd, F_SETFL, 0 );
     
134.         return nComFd;
     
135. }
     
136. 
     
137. int SerialDestroy(int nComFd)
     
138. {
     
139.         if (nComFd > 0)
     
140.         {
     
141.                 close(nComFd);
     
142.         }
     
143.         return 0;
     
144. }
     
145. 
     
146. int main(void)
     
147. {
     
148.         int fd = 0;
     
149.         fd = SerialInit("/dev/ttymxc1", 9600, 8, 'N', 1);
     
150.         if (fd < 0)
     
151.         {
     
152.                 printf("/dev/ttymxc1 does not exist!\n");
     
153.                 return 0;
     
154.         }
     
155. 
     
156.         char RcvBuf[1024] = {0};
     
157.         int nRead = 0;
     
158. 
     
159.         while (1)
     
160.         {
     
161.                 memset(RcvBuf, 0, 1024);
     
162.                 nRead = read(fd, RcvBuf, 1024);
     
163.                 if (nRead > 0)
     
164.                 {
     
165.                         //printf("recv %d data: %s", nRead, RcvBuf);
     
166.                         printf(RcvBuf);
     
167.                 }
     
168.                 sleep(0.1);
     
169.         }
     
170.         SerialDestroy(fd);
     
171.         return 0;
     
172. }
     

复制代码

  编译代码

  gcc myuart.c -o main，生成可执行文件main

  给zigbee模块上电，并执行main文件

  ./main

  协调器会收到3个zigbee终端定时发出的数据包，至此，初步的组网和数据上传网关功能完成。下一篇，通过qt编写zigbee网关程序，并将数据写入共享内存，qt窗体程序和共享内存交互，实现控件的联动。