基于ZigBee的智能家居设计与实现—CC2530开发_iar cc2530单片机智能家居

背景

硬件选择：安联德ZigBee开发板。

下载器：SmartRF04EBR

环境搭建

IAR安装破解

安装包和破解工具：链接：https://pan.baidu.com/s/1OVSprVSMhZwkA-cS4Q1Lpg
提取码：LK5B
复制这段内容后打开百度网盘手机App，操作更方便哦 提取码：LK5B。

双击打开EW8051-EV-8103-Web.exe。然后不断的next，next，I accept …… 然后停一下

管理员身份打开IAR kegen PartA.exe。

点击Generate复制License和 Licensekey到IAR安装窗口中。

SmartRF04EBR驱动安装

SmartRF04EBR下载：链接：https://pan.baidu.com/s/1uFZcTsbtm6sNgGViiZs2zg
提取码：LK5B
复制这段内容后打开百度网盘手机App，操作更方便哦 。提取码：LK5B。

CC2530 I/O口操作

I/O口简介

CC2530具有21个数字I/O口引脚，可以配置为通用I/O口或者外部设备I/O。21个引脚都可以作为外部中断源的输入口。

I/O口分为3组 P0 0-7 P1 0-7 P2 0-5

寄存器介绍

流水灯

实现一个流水灯。

#include <ioCC2530.h>

typedef unsigned char uchar;
typedef unsigned int uint;

#define LED1 P1_3

void DelayMS(uint msec)
{
  uint i,j;
  for(i=0;i<msec;i++)
    for(j=0;j<535;j++);
} 

void InitLed(void)
{
  P1DIR |= 0x08;
}

void main(void)
{
  InitLed();
  
  while (1)
  {
    LED1 = 0;
    DelayMS(1000);
    
    LED1 = 1;
    DelayMS(1000);
  }
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

CC2530 ADC操作

ADC简介

CC2530支持14位模拟数字转换，12位有效数字位，8个各自可配置的通道。支持分辨率设置7-12位，8个通道，可接受单端信号或差分信号，参考电压选择：内部单端，外部单端，外部差分和AVDD5。测量结束产生中断请求，转换结束触发DMA。

寄存器介绍

ADC实验

uint16 ReadGasData( void )
{
  uint16 reading = 0;
  
  /* Enable channel */
  ADCCFG |= 0x20;
  
  /* writing to this register starts the extra conversion */
  ADCCON3 = 0x85;// AVDD5 引脚  00： 64 抽取率(7 位ENOB)  0110： AIN6
  
  /* Wait for the conversion to be done */
  while (!(ADCCON1 & 0x80));
  
  /* Disable channel after done conversion */
  ADCCFG &= (0x40 ^ 0xFF); //按位异或。如1010^1111=0101（二进制）
  
  /* Read the result */
  reading = ADCL;
  reading |= (int16) (ADCH << 8); 
  
  reading >>= 8;
  
  return (reading);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

CC2530 USART操作

CC2530 USART简介

CC2530支持异步串口通信。具有两个串行通信接口。

寄存器介绍

常用波特率设置

USART实验

void InitUart(void)
{ 
    PERCFG = 0x00;           //外设控制寄存器 USART 0的IO位置:0为P0口位置1 
    P0SEL = 0x0c;            //P0_2,P0_3用作串口（外设功能）
    P2DIR &= ~0xC0;          //P0优先作为UART0
    
    U0CSR |= 0x80;           //设置为UART方式
    U0GCR |= 11;				       
    U0BAUD |= 216;           //波特率设为115200
    UTX0IF = 0;              //UART0 TX中断标志初始置位0
    U0CSR |= 0x40;           //允许接收 
    IEN0 |= 0x84;            //开总中断允许接收中断  
}

void UartSendString(char *Data, int len)
{
    uint i;
    
    for(i=0; i<len; i++)
    {
        U0DBUF = *Data++;
        while(UTX0IF == 0);
        UTX0IF = 0;
    }
}

#pragma vector = URX0_VECTOR 
__interrupt void UART0_ISR(void) 
{ 
    URX0IF = 0;       // 清中断标志 
    RxBuf = U0DBUF;                           
}

void main(void)
{	
    CLKCONCMD &= ~0x40;                        //设置系统时钟源为32MHZ晶振
    while(CLKCONSTA & 0x40);                   //等待晶振稳定为32M
    CLKCONCMD &= ~0x47;                        //设置系统主时钟频率为32MHZ   
   
    InitUart();                                //调用串口初始化函数   
    UartState = UART0_RX;                      //串口0默认处于接收模式
    memset(RxData, 0, SIZE);
    
    while(1)
    {
        if(UartState == UART0_RX)              //接收状态 
        { 
            if(RxBuf != 0) 
            {                 
                if((RxBuf != '#')&&(count < 50))//以'＃'为结束符,一次最多接收50个字符            
                    RxData[count++] = RxBuf; 
                else
                {
                    if(count >= 50)             //判断数据合法性，防止溢出
                    {
                        count = 0;              //计数清0
                        memset(RxData, 0, SIZE);//清空接收缓冲区
                    }
                    else
                        UartState = UART0_TX;  //进入发送状态 
                }
                RxBuf  = 0;
            }
        }
        
        if(UartState == UART0_TX)              //发送状态 
        {                         
            U0CSR &= ~0x40;                    //禁止接收 
            UartSendString(RxData, count);     //发送已记录的字符串。
            U0CSR |= 0x40;                     //允许接收 
            UartState = UART0_RX;              //恢复到接收状态 
            count = 0;                         //计数清0
            memset(RxData, 0, SIZE);           //清空接收缓冲区
        }    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

ZigBee基本概念

ZigBee网络中存在3种角色。

1.协调器：协调器负责启动网络，选择一个信道和一个网络ID，启动（构建）整个网络。无上层节点。

2.路由器：允许其它设备加入网络，实现网络间的路由，有上层节点，有下层节点。

3.终端设备：实现自身工作，可以加入构建好的网络。

地址定义：64 MAC 地址 + 16位网络地址。

ZStack-2.5.1a协议栈简介

工程简介

协议栈工作流程

初始化代码

主函数：

int main( void )
{
  // Turn off interrupts
  osal_int_disable( INTS_ALL );

  // Initialization for board related stuff such as LEDs
  HAL_BOARD_INIT();

  // Make sure supply voltage is high enough to run
  zmain_vdd_check();

  // Initialize board I/O
  InitBoard( OB_COLD );

  // Initialze HAL drivers
  HalDriverInit();

  // Initialize NV System
  osal_nv_init( NULL );

  // Initialize the MAC
  ZMacInit();

  // Determine the extended address
  zmain_ext_addr();

#if defined ZCL_KEY_ESTABLISH
  // Initialize the Certicom certificate information.
  zmain_cert_init();
#endif

  // Initialize basic NV items
  zgInit();

#ifndef NONWK
  // Since the AF isn't a task, call it's initialization routine
  afInit();
#endif

  // Initialize the operating system
  osal_init_system();

  // Allow interrupts
  osal_int_enable( INTS_ALL );

  // Final board initialization
  InitBoard( OB_READY );

  // Display information about this device
  zmain_dev_info();

  /* Display the device info on the LCD */
#ifdef LCD_SUPPORTED
  zmain_lcd_init();
#endif

#ifdef WDT_IN_PM1
  /* If WDT is used, this is a good place to enable it. */
  WatchDogEnable( WDTIMX );
#endif

  osal_start_system(); // No Return from here

  return 0;  // Shouldn't get here.
} // main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

系统初始化函数

uint8 osal_init_system( void )
{
  // Initialize the Memory Allocation System
  osal_mem_init();

  // Initialize the message queue
  osal_qHead = NULL;

  // Initialize the timers
  osalTimerInit();

  // Initialize the Power Management System
  osal_pwrmgr_init();

  // Initialize the system tasks.
  osalInitTasks();

  // Setup efficient search for the first free block of heap.
  osal_mem_kick();

  return ( SUCCESS );
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

系统任务初始化

void osalInitTasks( void )
{
  uint8 taskID = 0;

  // 分配内存，返回指向缓冲区的指针
  tasksEvents = (uint16 *)osal_mem_alloc( sizeof( uint16 ) * tasksCnt);
  // 设置所分配的内存空间单元值为0
  osal_memset( tasksEvents, 0, (sizeof( uint16 ) * tasksCnt));

  // 任务优先级由高向低依次排列，高优先级对应taskID 的值反而小
  macTaskInit( taskID++ );  //macTaskInit(0) ，用户不需考虑
  nwk_init( taskID++ );     //nwk_init(1)，用户不需考虑
  Hal_Init( taskID++ );     //Hal_Init(2) ，用户需考虑
#if defined( MT_TASK )
  MT_TaskInit( taskID++ );
#endif
  APS_Init( taskID++ );      //APS_Init(3) ，用户不需考虑
#if defined ( ZIGBEE_FRAGMENTATION )
  APSF_Init( taskID++ );
#endif
  ZDApp_Init( taskID++ );    //ZDApp_Init(4) ，用户需考虑
#if defined ( ZIGBEE_FREQ_AGILITY ) || defined ( ZIGBEE_PANID_CONFLICT )
  ZDNwkMgr_Init( taskID++ );
#endif
  //用户创建的任务
  SampleApp_Init( taskID );  // SampleApp_Init _Init(5) ，用户需考虑
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

重点 用户任务 。

用户任务初始化

void SampleApp_Init( uint8 task_id )
{ 
  SampleApp_TaskID = task_id;   //osal分配的任务ID随着用户添加任务的增多而改变
  SampleApp_NwkState = DEV_INIT;//设备状态设定为ZDO层中定义的初始化状态
  SampleApp_TransID = 0;        //消息发送ID（多消息时有顺序之分）
  
  //----------------配置I/O口---------------//
  //----------------配置外设----------------//
  
  // Device hardware initialization can be added here or in main() (Zmain.c).
  // If the hardware is application specific - add it here.
  // If the hardware is other parts of the device add it in main().

 #if defined ( BUILD_ALL_DEVICES )
  // The "Demo" target is setup to have BUILD_ALL_DEVICES and HOLD_AUTO_START
  // We are looking at a jumper (defined in SampleAppHw.c) to be jumpered
  // together - if they are - we will start up a coordinator. Otherwise,
  // the device will start as a router.
  if ( readCoordinatorJumper() )
    zgDeviceLogicalType = ZG_DEVICETYPE_COORDINATOR;
  else
    zgDeviceLogicalType = ZG_DEVICETYPE_ROUTER;
#endif // BUILD_ALL_DEVICES

//该段的意思是，如果设置了HOLD_AUTO_START宏定义，将会在启动芯片的时候会暂停启动
//流程，只有外部触发以后才会启动芯片。其实就是需要一个按钮触发它的启动流程。  
#if defined ( HOLD_AUTO_START )
  // HOLD_AUTO_START is a compile option that will surpress ZDApp
  //  from starting the device and wait for the application to
  //  start the device.
  ZDOInitDevice(0);
#endif

  // Setup for the periodic message's destination address 设置发送数据的方式和目的地址寻址模式
  // Broadcast to everyone 发送模式:广播发送
  SampleApp_Periodic_DstAddr.addrMode = (afAddrMode_t)AddrBroadcast;//广播
  SampleApp_Periodic_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; //指定端点号
  SampleApp_Periodic_DstAddr.addr.shortAddr = 0xFFFF;//指定目的网络地址为广播地址

  // Setup for the flash command's destination address - Group 1 组播发送
  SampleApp_Flash_DstAddr.addrMode = (afAddrMode_t)afAddrGroup; //组寻址
  SampleApp_Flash_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; //指定端点号
  SampleApp_Flash_DstAddr.addr.shortAddr = SAMPLEAPP_FLASH_GROUP;//组号0x0001
  
  SampleApp_P2P_DstAddr.addrMode = (afAddrMode_t)Addr16Bit;//点播
  SampleApp_P2P_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; 
  SampleApp_P2P_DstAddr.addr.shortAddr = 0x0000;           //发给协调器

  // Fill out the endpoint description. 定义本设备用来通信的APS层端点描述符
  SampleApp_epDesc.endPoint = SAMPLEAPP_ENDPOINT; //指定端点号
  SampleApp_epDesc.task_id = &SampleApp_TaskID;   //SampleApp 描述符的任务ID
  SampleApp_epDesc.simpleDesc
            = (SimpleDescriptionFormat_t *)&SampleApp_SimpleDesc;//SampleApp简单描述符
  SampleApp_epDesc.latencyReq = noLatencyReqs;    //延时策略

  // Register the endpoint description with the AF
  afRegister( &SampleApp_epDesc );    //向AF层登记描述符

  // Register for all key events - This app will handle all key events
  RegisterForKeys( SampleApp_TaskID ); // 登记所有的按键事件

  // By default, all devices start out in Group 1
  SampleApp_Group.ID = 0x0001;//组号
  osal_memcpy( SampleApp_Group.name, "Group 1", 7  );//设定组名
  aps_AddGroup( SAMPLEAPP_ENDPOINT, &SampleApp_Group );//把该组登记添加到APS中

#if defined ( LCD_SUPPORTED )
  HalLcdWriteString( "SampleApp", HAL_LCD_LINE_1 ); //如果支持LCD，显示提示信息
#endif
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

系统实现介绍

系统工作模式

系统采用指令与数据反馈的方式实现控制。协调器与终端会记录所有与自己相关指令与数据，并根据上层下发的指令进行修改。协调器会周期接受WiFi模块下发的指令并反馈自己系统的数据，周期下发自己的指令给自己的终端，终端会周期的执行自己的指令并反馈数据给协调器。

用户任务初始化介绍

根据系统实现的设计，用户任务初始化函数中主要进行：

1. 相关端口，外设初始化。
2. 通信参数初始化

用户任务处理介绍

根据系统实现设计，系统在用户任务处理函数中设计当ZigBee网络配置完成后设计一个定时器。在定时器中根据器件角色分别开发不同的功能。

uint16 SampleApp_ProcessEvent( uint8 task_id, uint16 events )
{
  afIncomingMSGPacket_t *MSGpkt;
  (void)task_id;  // Intentionally unreferenced parameter

  if ( events & SYS_EVENT_MSG ) //接收系统消息再进行判断
  {
    //接收属于本应用任务SampleApp的消息，以SampleApp_TaskID标记
    MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( SampleApp_TaskID );
    while ( MSGpkt )
    {
      switch ( MSGpkt->hdr.event )
      {
        // Received when a key is pressed
        case KEY_CHANGE://按键事件	//没有使用
          SampleApp_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys );
          break;

        // Received when a messages is received (OTA) for this endpoint
        case AF_INCOMING_MSG_CMD://接收数据事件,调用函数AF_DataRequest()接收数据	//没有使用
          SampleApp_MessageMSGCB( MSGpkt );//调用回调函数对收到的数据进行处理
          break;

        // Received whenever the device changes state in the network
        case ZDO_STATE_CHANGE:	//网络状态改变意味着网络配置完成。
          //只要网络状态发生改变，就通过ZDO_STATE_CHANGE事件通知所有的任务。
          //同时完成对协调器，路由器，终端的设置
          SampleApp_NwkState = (devStates_t)(MSGpkt->hdr.status);
          //if ( (SampleApp_NwkState == DEV_ZB_COORD)//实验中协调器只接收数据所以取消发送事件
          if ( (SampleApp_NwkState == DEV_ZB_COORD) || (SampleApp_NwkState == DEV_ROUTER) || (SampleApp_NwkState == DEV_END_DEVICE) )
          {
            // Start sending the periodic message in a regular interval.
            //这个定时器只是为发送周期信息开启的，设备启动初始化后从这里开始
            //触发第一个周期信息的发送，然后周而复始下去
            osal_start_timerEx( SampleApp_TaskID,
                              SAMPLEAPP_SEND_PERIODIC_MSG_EVT,
                              SAMPLEAPP_SEND_PERIODIC_MSG_TIMEOUT );
          }
          else
          {
            // Device is no longer in the network
          }
          break;

        default:
          break;
      }

      // Release the memory 事件处理完了，释放消息占用的内存
      osal_msg_deallocate( (uint8 *)MSGpkt );

      // Next - if one is available 指针指向下一个放在缓冲区的待处理的事件，
      //返回while ( MSGpkt )重新处理事件，直到缓冲区没有等待处理事件为止
      MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( SampleApp_TaskID );
    }

    // return unprocessed events 返回未处理的事件
    return (events ^ SYS_EVENT_MSG);
  }

  // Send a message out - This event is generated by a timer
  //  (setup in SampleApp_Init()).	//定时器事件
  if ( events & SAMPLEAPP_SEND_PERIODIC_MSG_EVT )
  {
	/******************************************/
      系统功能实现开发
     /*****************************************/

    // Setup to send message again in normal period (+ a little jitter)
    osal_start_timerEx( SampleApp_TaskID, SAMPLEAPP_SEND_PERIODIC_MSG_EVT,
        (SAMPLEAPP_SEND_PERIODIC_MSG_TIMEOUT + (osal_rand() & 0x00FF)) );

    // return unprocessed events 返回未处理的事件
    return (events ^ SAMPLEAPP_SEND_PERIODIC_MSG_EVT);
  }

  // Discard unknown events
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

上面的函数就是协议栈中的用户任务事件响应函数。这里面的按键事件和接收数据事件没有使用可以忽略。重点是网络状态改变函数，这里的网络状态改变事件发生就意味着该模块的在网络上中的角色初始化完成。在这里会第一次定时，到达定时后就会再次触发该事件，并进入下面的定时事件处理程序段中，在系统工作完成后再次定时就实现了周期定时。

广播发送通信

void SampleApp_SendPeriodicMessage( void )
{
  byte SendData[];			//预发送数据
  
  //*************广播数据发送前处理*****************//
    
  if( AF_DataRequest( &SampleApp_Periodic_DstAddr,//发送目的地址＋端点地址和传送模式
                     &SampleApp_epDesc,//源(答复或确认)终端的描述（比如操作系统中任务ID等）源EP
                     SAMPLEAPP_PERIODIC_CLUSTERID, //被Profile指定的有效的集群号
                     6,       // 发送数据长度
                     SendData,// 发送数据缓冲区
                     &SampleApp_TransID,     // 任务ID号
                     AF_DISCV_ROUTE,      // 有效位掩码的发送选项
                     AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  //传送跳数，通常设置为AF_DEFAULT_RADIUS
  {
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上面的函数就是广播数据发送函数。这里AF_DataRequest函数中的参数只关注发送数据长度和数据指针这两个。

点播发送通信

void SampleApp_SendP2PMessage() 
{
	uchar data[];	//预发送数据
	//*************广播数据发送前处理*****************//
	if ( AF_DataRequest( &SampleApp_P2P_DstAddr, &SampleApp_epDesc,
						SAMPLEAPP_P2P_CLUSTERID,
						10,	//预发送数据长度
						data,	//预发送数据
						&SampleApp_TransID,
						AF_DISCV_ROUTE,
						AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )
	{
	}
	else
	{
		// Error occurred in request to send.
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

通信数据接收

void SampleApp_MessageMSGCB( afIncomingMSGPacket_t *pkt )
{
  uint16 flashTime;
  uchar buf[12];

  switch ( pkt->clusterId ) //判断簇ID
  {
    case SAMPLEAPP_P2P_CLUSTERID: //收到单播数据
	  //****************协调器应用函数******************//
      break;
    case SAMPLEAPP_PERIODIC_CLUSTERID: //收到广播数据 
      
      //****************终端应用函数*******************//
      break;

    case SAMPLEAPP_FLASH_CLUSTERID: //收到组播数据
     //******************没有使用********************//
      break;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

以上是数据接收函数，当模块接受导数据后就会进入该函数，在这函数中根据数据来源对数据进行分类并做不同的操作。

结束语

以上介绍了CC2530开发环境的搭建，本系统要用到的外设驱动和ZigBee网络技术。对于CC2530芯片本身，ZStack-2.5.1a协议栈以及其他与项目无关的内容并没有赘述，如果有同学对于这里有问题或者有兴趣的话欢迎讨论学习。同时在系统中的用到的应用层逻辑也是我自己做的，并不专业，关于这个我也是正在学习，以后可能会再更新改进，同时也欢迎同学们的指导批评。