博客园_学习日志

ZigBee学习之37——osalInitTasks()分析

2010-07-19T20:33:00Z

此函数完成了任务ID的分配，以及所有任务的初始化，如果我们要加入自己的应用必须在这里加入自己的任务初始化函数，以使系统可以自动为任务分配一个ID号。如果是想要自己创建一个应用，那么必须首先实现两个东西，一是任务回调函数队列，另一个是系统任务初始化及ID分配。任务队列是一个pTaskEventHandlerFn结构的数组，只要把每个任务相关的回调函数按初始化队列中的顺序填到数组中就可以了，他们的实现一般是写在自己的应用源码里面。介绍一个例子（SimpleApp）：

const pTaskEventHandlerFn tasksArr[] = {

macEventLoop,

nwk_event_loop,

Hal_ProcessEvent,

#if defined( MT_TASK )

MT_ProcessEvent,

#endif

APS_event_loop,

ZDApp_event_loop,

SAPI_ProcessEvent

};

void osalInitTasks( void )

{

uint8 taskID = 0;

tasksEvents = (uint16 *)osal_mem_alloc( sizeof( uint16 ) * tasksCnt);

osal_memset( tasksEvents, 0, (sizeof( uint16 ) * tasksCnt));

macTaskInit( taskID++ );

nwk_init( taskID++ );

Hal_Init( taskID++ );

#if defined( MT_TASK )

MT_TaskInit( taskID++ );

#endif

APS_Init( taskID++ );

ZDApp_Init( taskID++ );

SAPI_Init( taskID );

}

注意这里两个实体里面的顺序要一一对应！

macTaskInit( taskID++ )，nwk_init( taskID++ )，APS_Init( taskID++ )定义在mac_api.h，nwk.h，APS.h中，但没有找到其实现，可能被打包在链接库文件里面了。

void Hal_Init( uint8 task_id )

{

/*将系统分配的任务的ID传给变量*/

Hal_TaskID = task_id;

}

//开始器件的启动【ZDApp.c】

void ZDApp_Init( byte task_id )

{

uint8 capabilities;

//保存系统分配的任务ID

ZDAppTaskID = task_id;

//初始化ZDO全局的短地址，并配置成无效的一个地址

ZDAppNwkAddr.addrMode = Addr16Bit;

ZDAppNwkAddr.addr.shortAddr = INVALID_NODE_ADDR;

// ZDAppNwkAddr为一个地址数据结构：addrMode只有几种：

AddrNotPresent = 0,

AddrGroup = 1,

Addr16Bit = 2,

Addr64Bit = 3,

AddrBroadcast = 15

typedef struct

{

union

{

uint16 shortAddr;

ZLongAddr_t extAddr;

} addr;

byte addrMode;

} zAddrType_t;

(void)NLME_GetExtAddr(); //这是个ZstackAPI，返回指向此器件64位地址的指针

//检查"Hold Auto Start"，如果启动的时候按着SW1，此函数就会设置设备的状态为：DEV_HOLD

ZDAppCheckForHoldKey();

//初始化ZDO物件，并且设置设备

ZDO_Init();

//【ZDObject.c】

void ZDO_Init( void )

{

#if defined ( REFLECTOR )

//如果器件定义的是“反射器”则需要定义个路由的设备结构，REFLECTOR是一个编译选项，如果定义了这个编译选项则使用“源绑定”，源绑定的定义有这样一句话In the Zigbee 2006 release,the binding mechanism is implemented in all devices and is called source binding（在Zigbee2006中，绑定机制在所有的设备中实现，这就叫做源绑定），如果使用源绑定则绑表是存放在源设备中的，这样就不用为找绑定入口而先向协调器提交绑定请求，但是方面又增大了源节点的开销，因为要为保存绑定表而开辟一段静态内存。默认是不使用源绑定。

ZDO_EDBind = NULL;

#endif

//设置创建设备的类型

ZDODeviceSetup();

//根据设置的编译选项来调用不同的网络层管理函数

// ZDO_COORDINATOR：设备作为协调器

// SOFT_START：如果没有协调器则设备以协调器启动，否则以路由器启动

//这里面的几个函数都做成了静态库了看不到源码！看来TI的所谓开放也不是完全开放

static void ZDODeviceSetup( void )

{

#if defined( ZDO_COORDINATOR )

NLME_CoordinatorInit();

#endif

#if defined ( REFLECTOR )

#if defined ( ZDO_COORDINATOR )

APS_ReflectorInit( APS_REFLECTOR_PUBLIC );

#else

APS_ReflectorInit( APS_REFLECTOR_PRIVATE );

#endif

#if !defined( ZDO_COORDINATOR ) || defined( SOFT_START )

NLME_DeviceJoiningInit();

#endif

}

// 向AF层注册endpoint（终端）

afRegister( (endPointDesc_t *)&ZDApp_epDesc );

endPointDesc_t ZDApp_epDesc =

{

ZDO_EP,

//0，ZDO为终端0

&ZDAppTaskID,

//指向应用任务号

(SimpleDescriptionFormat_t *)NULL,

// 终端的简单描述，No Simple description for ZDO

(afNetworkLatencyReq_t)0 // No Network Latency req

};

#if defined( ZDO_USERDESC_RESPONSE )

ZDApp_InitUserDesc();

#endif // ZDO_USERDESC_RESPONSE

//从NIB中读取属性

NLME_GetRequest(nwkCapabilityInfo, 0, &capabilities);

//设置设备能处理的广播消息

NLME_SetBroadcastFilter( capabilities );

//根据设备状态启动设备，如果不是DEV_HOLD则启动ZDO设备，否则闪烁LED1

if ( devState != DEV_HOLD )

{

ZDOInitDevice( 0 );

//启动网络中的设备，在这个函数中会调用ZDApp_NetworkInit()来启动网络，并发送ZDO_NETWORK_INIT事件，当ZDO事件循环ZDApp_event_loop()接收到这个事件后会执行ZDO_StartDevice()来启动设备

}

else

{

// Blink LED to indicate HOLD_START

HalLedBlink ( HAL_LED_4, 0, 50, 500 );

}

ZDApp_RegisterCBs();

//注册ZDO消息，只有注册了的消息才能以ZDO_CB_MSG消息的形式发送给指定的任务

} /* ZDO_Init() */

事件处理函数SAPI_ProcessEvent()，在任何地方只要调用osal_set_event()对这个处理函数对应的任务ID设置了事件的话就会启动这个事件处理函数。

系统消息事件SYS_EVENT_MSG包含几个子类的消息（子类可以在文档【Z-Stack Sample Applications (F8W-2006-0023).pdf】中找到），SYS_EVENT_MS由函数osal_msg_send()【OSAL.C】发送，osal_msg_send()首先将传过来的任务ID加入到消息包中，然后再把这个消息包通过osal_msg_enqueue加入到消息队列中，（osal_qHead是消息队列的头指针），然后我们再来查找调用osal_msg_send()的函数，这样我们就可以知道系统消息SYS_EVENT_MSG是在什么情况下如何发出的了。afDataConfirm()【AF.c】会调用osal_msg_send()，并且构造的消息中包含事件AF_DATA_CONFIRM_CMD（此事件说明由AF_DataRequest()初始化的数据已成功发送，若AF_DataRequest()的选项中要求有回应，则此事件表示目标已收到数据）

void afDataConfirm( uint8 endPoint, uint8 transID, ZStatus_t status )

{

endPointDesc_t *epDesc;

afDataConfirm_t *msgPtr;

//每个终端都需要一个描述，如果没有则直接返回

epDesc = afFindEndPointDesc( endPoint );

if ( epDesc == NULL )

return;

………………

// Determine the incoming command type

msgPtr = (afDataConfirm_t *)osal_msg_allocate( sizeof(afDataConfirm_t) );

if ( msgPtr )

{

// Build the Data Confirm message

msgPtr->hdr.event = AF_DATA_CONFIRM_CMD;

//设置消息的事件为AF_DATA_CONFIRM_CMD

msgPtr->hdr.status = status;

msgPtr->endpoint = endPoint;

msgPtr->transID = transID;

//给指定任务发送消息，并且设置事件数组中SYS_EVENT_MS事件准备好

osal_msg_send( *(epDesc->task_id), (byte *)msgPtr );

}

换个思路看看SAPI的事件处理函数当接收到数据的时候干了些什么，然后找出接收数据的函数！从文档中我们得知当采集器接收到数据后就会发送到串口，好那么就找出发送串口数据的处理函数：SAPI_ReceiveDataIndication()，当收到系统消息中的事件为AF_INCOMING_MSG_CMD事调用此函数，afBuildMSGIncoming()会构造基于此事件的消息，而afIncomingData将会调用此函数，

本文链接

ZigBee2006协议栈介绍

2010-07-15T14:50:00Z

ZigBee2006 协议栈是一个公开的半开源的短距离无线网络协议，ZigBee 协议栈于2004年发布第一版，我们称为ZigBee2004，ZigBee2004 是一个全源代码的协议栈，这个协议栈的能力已经有了网络的概念，并能完成一些简单的通信，但在组网方面只能组建串状网络和星状网络，如果需要组建网状网络必须要自己外加程序，在安全和路由方面也做的不是很理想。
在2006 协议栈中，很好的解决了网络组网问题，整个协议栈的安全性更高，层次性更强，再功耗方面也有了进步，并实现了网状网络，下面主要介绍Zigbee2006。先看看协议栈的结构：打开协议栈文件夹，可以看到整个协议栈由Componts，Documents，Projects、Tools 文件夹组成，在Componts 中包含了协议栈文件和硬件底层驱动文件；Doucuments 中包含了这个协议栈的说明文档；Project 中包含可这个协议栈的工程架构，在演示代码中还包含了WXL 增加文件；在Tools 文件夹中，包含了一个查看网络拓扑的工具。具体内容请参阅Doucuments 中的说明文档。

协议栈的构架

打开协议栈，在工程文件的左边Workspace 中可以看到整个协议栈的构架，如图所示，
APP：应用层目录，这是用户创建各种不同工程的区域，在这个目录中包含了应用层的内容和这个项目的主要内容，在协议栈里面一般是以操作系统的任务实现的。
HAL：硬件层目录，包含有与硬件相关的配置和驱动及操作函数。
MAC：MAC 层目录，包含了MAC 层的参数配置文件及其MAC 的LIB 库的函数接口文件。
MT：实现通过串口可控各层，于各层进行直接交互。
NWK：网络层目录，含网络层配置参数文件及网络层库的函数接口文件，APS 层库的函数接口
OSAL：协议栈的操作系统。
Profile：AF层目录，包含AF 层处理函数文件。
Security：安全层目录，安全层处理函数，比如加密函数等。
Services：地址处理函数目录，包括着地址模式的定义及地址处理函数。
Tools：工程配置目录，包括空间划分及ZStack 相关配置信息。
ZDO：ZDO目录。
ZMac： MAC 层目录，包括MAC 层参数配置及MAC 层LIB 库函数回调处理函数。
ZMain：主函数目录，包括入口函数及硬件配置文件。
Output：输出文件目录，这个EW8051 IDE 自动生成的。

本文链接

点对点（单向）传输实验之LED灯指示

2010-07-15T14:48:00Z

http://blog.sina.com.cn/s/blog_5f6e4fce0100htd4.html

实验器材：

无线龙C51RF3-PK ,(06光盘)...\C51RF-3-PK无线ZigBee网络开发平台V5.10\C51RF-3演示程序\点对点无线通信\点对点无线基本通信

实验目的：

实现个人目的的无线传输。

实验步骤：

1> 函数调用脉络：主函数 app_ex_main.c

void main(void)
{
   SET_MAIN_CLOCK_SOURCE(CRYSTAL); //设置主时钟：晶振32MHz
   RFPWR = 0x04;                    //射频功率
   while(RFPWR & 0x10);          //等待稳定
   initUART();                   //初始化串口
   //IO_DIR_PORT_PIN(0,5,IO_OUT);
   //IO_DIR_PORT_PIN(1,3,IO_OUT);
   //IO_DIR_PORT_PIN(1,2,IO_IN);
   //IO_DIR_PORT_PIN(1,2,IO_OUT);
   //P0_5 = 1;

   //P1_0 = 0;
   rf_test_main();             //调用rf_test.c中的主函数rf_test_main();
}

2> 射频测试子程序 rf_test.c

#ifdef COMPLETE_APPLICATION
void rf_test_main(void){
#else
void main(void){
#endif                             //条件编译主函数名
   INT_GLOBAL_ENABLE(INT_ON);      //EA=1；开中中断
   #ifdef RX
      myAddr = ADDRESS_0;
      remoteAddr = ADDRESS_1;
      initRfTest();                //初始化射频

     receiveMode();               //定义本模块为接收功能
   }
   #else
   {
      myAddr = ADDRESS_1;
      initRfTest();
      contionuousMode();          //定义接收
   }
   #endif
}

3> 接收部分：receiveMode(）

void receiveMode(void)
{
   BYTE* receiveBuffer;
   BYTE length;
   BYTE res;
   BYTE sender;
   while(1)
   {
      RLED = LED_ON;      //开始接受，红灯闪烁
      res = radioReceive(&receiveBuffer, &length, RECEIVE_TIMEOUT, &sender);
      halWait(200);

RLED = LED_OFF;

     if(res == TRUE)
      {
         GLED = LED_ON;   //接收成功，绿灯亮闪烁
         YLED=!YLED;      //自己添加的黄色指示灯，添加方法：RF04EB.h
         halWait(200);
      }
      else
      {
         GLED = LED_OFF;    //接受失败，绿灯灭
         halWait(200);
      }

GLED = LED_OFF;
}
}

4> 发送部分 contionuousMode()

void contionuousMode(void)
{
   BOOL res;                         //结果变量
   BYTE sendBuffer[] = "Hello";      //待发送字符
   while(1)
   {
      RLED = LED_ON;
      res = radioSend(sendBuffer, sizeof(sendBuffer), remoteAddr, DO_NOT_ACK );
      halWait(200);
      RLED = LED_OFF;
      if(res == TRUE)     //发送成功，绿灯亮
      {
         GLED = LED_ON;

        YLED=!YLED;      //自己加一句用来测试
         halWait(200);
      }
      else                //发送失败，绿灯灭
      {
        GLED = LED_OFF;
        halWait(200);
      }

GLED = LED_OFF;
}

}

总结：条件编译的好处是可以把收发双方的程序写在同一个工程目录下，无须分开写，编译器会有选择编译

本文链接

ZigBee四种绑定方式在TI Z-Stack中的应用【转载】

2010-07-15T10:05:00Z

BINDING

KuangJunBin：本文是作者根据TI Z-Stack开发文档，ZigBee Specification-2007，《Zigbee Wireless Networking》等英文资料整合和翻译而成，采用中英双语对照方便读者理解，文中翻译不当之处，望广大同行不吝赐教。推广ZigBee技术，提高国内电子行业的国际影响力，是我们无线通讯工程师的愿景。本文欢迎转载，请保留作者信息和出处，作为支持我继续努力前行的动力，谢谢！

E-mail:kuangjunbin@gmail.com

In the Zigbee 2006 release,the binding mechanism is implemented in all devices and is called source binding. Binding allows an application to send a packet without knowing the destination address,the APS layer determines the destination address from its binding table,and then forwards the message on to the destination application(or multiple applications)or group.

ZigBee2006版本中规定，在全部节点中实现绑定机制，并将其称为源绑定。绑定机制允许一个应用服务在不知道目标地址的情况下向对方（的应用服务）发送数据包。发送时使用的目标地址将由应用支持子层（APS）从绑定表中自动获得，从而能使消息顺利被目标节点的一个或多个应用服务，乃至分组接收。

Binding Table

1.Defined in RAM,but can be saved in Flash if the NV_RESTORE compiler option is used

2.Stored on source node(REFLECTOR compiler option required)

3.Entries map messages to their intended destination

4.Each entry in the binding table contains the following:

typedef struct

{

uint16 srcIdx;//Source index

uint8 srcEP;//Source endpoint

uint8 dstGroupMode;//Specifies normal or group addressing

uint16 dstIdx;//Destination index or group address

uint8 dstEP;//Destination endpoint

uint8 numClusterIds;//Number of cluster IDs in the clusterIdList below

uint16 clusterIdList[MAX_BINDING_CLUSTER_IDS];

}BindingEntry_t;

绑定表

1. 绑定表存放的位置是内存中预先定义的RAM块，如果编译选项NV_RESTORE被激活，也能保存在Flash里。

2. 绑定表放置在源节点（需要激活编译选项REFLECTOR）。

3. 绑定表的条目把需要发送的消息映射到它们的目标地址上。

4. 绑定表中每个条目（entry）包括以下内容：

绑定表条目结构体的定义

typedef struct

{

uint16 srcIdx; //源地址索引

uint8 srcEP; //源端点

uint8 dstGroupMode; //指定寻址模式

uint16 dstIdx; //目标地址索引或者分组号

uint8 dstEP; //目标端点

uint8 numClusterIds; //在簇标识符表中簇标识符的个数

uint16 clusterIdList[MAX_BINDING_CLUSTER_IDS]; //簇标识符表

}BindingEntry_t;

概述---怎样绑定节点

绑定指的是两个节点在应用层上建立起来的一条逻辑链路。在同一个节点上可以建立多个绑定服务，分别对应不同种类的数据包。此外，绑定也允许有多个目标节点（一对多绑定）。

举个例子，在一个灯光网络中，有多个开关和灯光设备，每一个开关可以控制一个或以上的灯光设备。在这种情况下，需要在每个开关中建立绑定服务。这使得开关中的应用服务在不知道灯光设备确切的目标地址时，可以顺利地向灯光设备发送数据包。

一旦在源节点上建立了绑定，其应用服务即可向目标节点发送数据，而不需指定目标地址了（调用zb_SendDataRequest()，目标地址可用一个无效值0xFFFE代替）。这样，协议栈将会根据数据包的命令标识符，通过自身的绑定表查找到所对应的目标设备地址。

在绑定表的条目中，有时会有多个目标端点。这使得协议栈自动地重复发送数据包到绑定表指定的各个目标地址。同时，如果在编译目标文件时，编译选项NV_RESTORE被打开，协议栈将会把绑定条目保存在非易失性存储器里。因此当意外重启（或者节点电池耗尽需要更换）等突发情况的发生时，节点能自动恢复到掉电前的工作状态，而不需要用户重新设置绑定服务。

配置设备绑定服务，有两种机制可供选择。1、如果目标设备的扩展地址（64位地址）已知，可通过调用zb_BindDeviceRequest()建立绑定条目。2、如果目标设备的扩展地址未知，可实施一个“按键”策略实现绑定。这时，目标设备将首先进入一个允许绑定的状态，并通过zb_AllowBindResponse()对配对请求作出响应。然后，在源节点中执行zb_BindDeviceRequest()（目标地址设为无效）可实现绑定。

此外，使用节点外部的委托工具（通常是协调器）也可实现绑定服务。请注意，绑定服务只能在“互补”设备之间建立。那就是，只有分别在两个节点的简单描述结构体（simple descriptor structure）中，同时注册了相同的命令标识符（command_id）并且方向相反（一个属于输出指令“output”，另一个属于输入指令“input”），才能成功建立绑定。

There are 4 ways to build a binding table:

建立一个绑定表格有四种方法可供选择：

l Automatic Binding

A. Sending device broadcasts a“personal ad”on the network with:

1) Address,Profile ID,Cluster Lists

2) Match Description Request-ZDP_MatchDescReq()

B. Compatible devices respond

C. Response handled and validated by the ZDO

D. Sender application stores binding record in binding table

自动绑定

一、负责发送消息的设备在网络上广播带有如下参数的“个人公告”（Personal Advertisement）：

（1）地址(Address)，配置文件标识符(Profile ID)，簇集合列表(Cluster Lists)；

（2）描述符匹配请求- ZDP_MatchDescReq()。

二、匹配的设备会作出响应。

三、由ZDO处理和验证响应。

四、负责发送消息的设备建立绑定表并保存绑定记录。

五、这种方法有时也称“服务发现”，“自动找寻”或者“自动匹配”。

ZigBee设备对象绑定请求-一种告诉目标设备建立绑定记录的委托工具，也称辅助绑定。

任何一个设备或应用服务，都能通过无线信道向网络上的另一个设备发送一个ZDO消息，帮助其建立一个绑定记录。这称为辅助绑定，在消息发向的设备上会建立一个绑定条目。

委托绑定的申请：

任一个应用服务，通过向ZDP_BindReq()[defined in ZDProfile.h]提供绑定记录所需要的应用服务入口参数（地址和端点）以及簇标识号（cluster ID），即可启动委托绑定的申请。第一个参数（消息发送目标地址）是绑定源节点的短地址（即保存绑定记录的节点地址，这是因为ZDP需委托应用框架AF辅助实现绑定，如果节点本身是REFLECTOR，并且希望保存绑定记录，则此消息发送的目标地址就是本地的AF，这与目标节点的地址DestinationAddr of Receiving device不同）。

注意事项：

l 确保[ZDConfig.h]中ZDO_BIND_UNBIND_REQUEST特性已经打开！

l 你可以通过ZDP_UnbindReq()（使用相同参数）来移除绑定记录。

l 被请求辅助绑定的目标设备会返回的ZDO申请绑定或者解除绑定的应答消息。此ZDO消息会被解析并通过调用ZDApp_BindRsp()或ZDApp_UnbindRsp()告知ZDApp.c此次请求的结果。

l 对于申请绑定的应答消息，从协调器返回的状态可能有ZDP_SUCCESS,ZDP_TABLE_FULL or ZDP_NOT_SUPPORTED。

l 对于解除绑定的应答消息，从协调器返回的状态可能有ZDP_SUCCESS,ZDP_NO_ENTRY or ZDP_NOT_SUPPORTED。

l 绑定是由外部的设备发起（“外部”的意思是发起绑定的不是绑定的对象之一）。

l 外部设备应用程序以两个应用服务（地址和端点）和簇标识符作为参数调用ZDP_BindReq ()发起绑定。第一个参数就是绑定记录保存的设备地址。委托绑定。

l 确保编译选项REFLECTOR已经打开！

函数解析：

ZDP_BindReq()实际上是调用ZDP_BindUnbindReq()的一个宏。这一调用会产生并发送一个绑定的请求，使得ZigBee协调器根据簇标识号clusterID对相应的应用服务实施绑定。

函数原型：

afStatus_t ZDP_BindReq(zAddrType_t*dstAddr,byte*SourceAddr,

byte SrcEPIntf,byte ClusterID,byte*DestinationAddr,byte DstEPIntf,

byte SecuritySuite);

参数细节：

DstAddr-消息发送地址（负责绑定的设备地址，本地的AF）-参见上面委托绑定

SourceAddr–源节点的64位IEEE地址

SrcEPIntf–源节点应用服务的端点

ClusterID–需要绑定的簇标识符

DestinationAddr–目标节点的64位IEEE地址

DstEPIntf–目标节点应用服务的端点

SecuritySuite-安全机制模式

返回值：

afStatus_t–此函数需要借助AF发送（AF_DataRequest()）生成的消息，因此返回值是AF状态值。

ZigBee设备对象终端节点绑定请求-两个设备可向协调器告知他们想建立一个绑定表记录。协调器通过安排配对并分别在这两个设备上建立绑定表条目，也称集中式绑定。

这一机制规定在指定的时限内，通过按键或者其他类似动作对指定的设备实施绑定。在规定的时限内，协调器负责收集终端设备绑定请求消息，然后根据相同的配置文件标识号(profile id)和簇标识号(cluster id)建立相应的绑定表格条目。默认的终端节点绑定时限(APS_DEFAULT_MAXBINDING_TIME)是16秒(在nwk_globals.h中定义)，若要修改可在f8wConfig.cfg中新增数值。

所有例子的应用服务中都有一个响应按键事件的函数（例如，TransmitApp.c中的TransmitApp_HandleKeys()）。这一响应函数调用ZDApp_SendEndDeviceBindReq()[在 ZDApp.c中]收集该应用服务端点的所有信息，然后再调用ZDP_EndDeviceBindReq()[在ZDProfile.c中]把信息发送给协调器。或者，像SampleLight和SampleSwitch例程中，按键后直接调用ZDP_EndDeviceBindReq()，仅把与开关灯函数相关的簇标识号发送出去。

这一消息将会被协调器接收[ZDP_IncomingData()in ZDProfile.c]和解析[ZDO_ProcessEndDeviceBindReq()in ZDObject.c]，然后让回调函数ZDApp_EndDeviceBindReqCB()[in ZDApp.c]调用ZDO_MatchEndDeviceBind()[ZDObject.c]处理这一请求。

当协调器接收到第一个绑定请求时，他会在一定的时限内保留这一请求并等待第二个请求的出现。（默认的最长时间间隔是16秒）。

一旦协调器接收到两个需要匹配的终端设备绑定请求时，它就会启动绑定过程，为发出请求的设备建立源绑定条目。假设在ZDO终端设备绑定请求中找到匹配，协调器将采取以下步骤：

1. 协调器发送一个ZDO解除绑定请求给第一个设备。终端设备绑定 是一个切换过程，所以解除绑定请求需要发送给第一个设备，以便移除一个已有的绑定条目。

2. 等待ZDO解除绑定的应答，如果返回的状态是ZDP_NO_ENTRY（没有已存在的绑定），协调器可以发送一个ZDO绑定请求，在源设备（ZDP_EndDeviceBindReq()第一个参数指定的地址）中建立绑定条目。假如此时返回的状态是ZDP_SUCCESS，可继续处理第一个设备的簇标识符（解除绑定指令已经移除了绑定条目，即已经切换完成）。

3. 等待ZDO绑定应答。收到以后，继续处理第一个设备的下一个簇标识符。

4. 等第一个设备完成了以后，在第二个设备上实行同样的过程。

5. 等第二个设备也完成了，协调器向两个设备发送ZDO终端设备绑定应答消息。

注意打开编译选项：REFLECTOR和ZDO_COORDINATOR

ZDApp_SendEndDeviceBindReq()

优点：

1. 绑定信息保存在网络反射设备（例如协调器、路由器）中，可以节省目标设备的内存空间。

2. 网络反射设备总是处于监听网络的状态。所以，如果其中一个被绑定的节点广播网络地址改变的消息，网络反射设备就可以马上更新相应的绑定表条目。这样，其他被绑定的节点即使处于休眠状态（没有收到该节点网络地址改变的消息），随后向该节点（网络地址已改变）发送的消息，（在）网络反射设备（协助下）仍能准确定位。

缺点：

1. 一个与多个设备绑定的节点不能只向一个或若干个配对的设备发送消息。网络反射设备会向全部已绑定的设备本别发送单播消息。

2. 发送消息的设备无法收到目标设备接收情况的通告。（没有像AF_ACK_REQUEST标志位那样返回接收情况的功能！）

3. 所有的消息必须经过网络反射设备传输，降低了网络的带宽。

进一步分析：

与六个设备绑定的某个设备，向网络反射器发送一个消息后，会导致反射器发送六个单播消息。假设一个网络被分成两个相等的地理区域A和B，网络反射器在两区之间的中央。如果发送消息的设备在A区的深处，接收消息的（六个）设备在B区的深处，那么每次通过绑定（向反射器）发送一个消息，A区的网络流量将会是对六个接收设备分别发送消息时的六分之一。（这是优点！）但如果发送和接收的设备都邻近在一个区的深处（假设离反射器很远），那么（其中一个设备通过反射器的绑定功能向其他设备发送一个消息）该区的网络流量将会是对六个接收设备分别发送单跳消息的许多倍。（这是缺点！）

设备的应用服务-设备上的一个应用服务可以建立或者维护一个绑定表。进入设备上绑定条目的另一种方法是由应用服务本身去管理绑定表。

这意味着应用服务通过调用以下的绑定表管理函数，可以在本地进入或者移除绑定表的条目。

管理绑定表使用的API：

bindAddEntry()–绑定表中加条目

bindRemoveEntry()–绑定表中移除条目

bindRemoveClusterIdFromList()–从一个已有的绑定表条目中移除一个簇标识符

bindAddClusterIdToList()–在一个已有的绑定表条目中加入一个簇标识符

bindRemoveDev()–移除某目标地址的所有条目

bindRemoveSrcDev()–移除某源地址的所有条目

bindUpdateAddr()–更新条目到新的地址

bindFindExisting()–查找一个绑定条目

bindIsClusterIDinList()–在绑定条目中查找一个已有的簇标识符

bindNumBoundTo()–某一地址（源地址或目标地址）绑定条目的个数

bindNumOfEntries()–绑定表条目的个数

bindCapacity()–允许的最大绑定条目数

BindWriteNV()–在NV中保存新的绑定表

Which Binding Method To Use?

我们应该选择哪一种绑定方式？

Automatic

+no user interaction required

+no tool cost

-development time knowledge

-non-configurable

Assisted

+install-time decisions(site-specific knowledge)

+analysis,maintenance,modification,visualization

can be under installers control

-cost of tool

Centralized

+allows user to decide

+cost of tool minimal

-few,if any,configurable parameters

-requires a user interface on each device

Application

+maximum flexibility

-you must write all the code

来自TI E2E社区的进一步讨论：

一、“终端设备绑定请求”这一命名有误导的嫌疑。这一请求不仅仅适用于终端设备，而且适用于对希望在协调器上绑定的两个设备中匹配的簇实施绑定。一旦这个函数被调用，将假设REFLECTOR这一编译选项在所有希望使用这一服务的节点中都已经打开。具体操作如下：

（1） (Bind Req) Device 1 --> Coordinator <--- Device 2 (Bind Req)

协调器首先找出包含在绑定请求中的簇，然后对比每一设备的IEEE地址，如果簇可以匹配，而且这几个设备没有已经存在的绑定表，那他将发送一个绑定应答给每一个设备。

（2） Device 1 <--- NWK Addr Req ------ Coordinator ------- NWK addr Req ----> Device 2

（3） Device 1 ----> NWK Addr Rsp ---> Coordinator <---- NWK addr Rsp <--- Device 2

（4） Device 1 <----- Bind Rsp <----- Coordinator -----> Bind Rsp ----> Device 2

二、“描述符匹配”为源设备的服务发现提供了一种灵巧的方法。下面是具体的操作，这一过程并没有通过协调器。

（1） Device 1 ----> Match Descriptor request (broadcast or unicast) Device 2

（2） Device 1 <---- Match Descriptor response (if clusters, application profile id match) that includes src endpoint, src address <---- Device 2

1号设备需要维护一个端点和地址的记录。

许多应用服务最终都会使用第二种方法。

说明：本文转载自阿元博客：http://blog.sina.com.cn/s/articlelist_1283622691_8_1.html

《ZigBee四种绑定方式在TI Z-Stack中的应用1—8》

注意点：协议版本不同，有些内容及函数不完全适用匹配.

本文链接

DSP串行FLASH（AT45DB642）的源代码

2010-07-04T17:28:00Z

#include"serprt30.h"

#include"math.h"

//'注释：

//'DB45BUSY = CLKR0;

//'DB45CS = CLKX0;

//'DB45SCLK = FSX0;

//'SI = DX0; //'输出

//'SO = FSR0;//'输入

//'DB45OE = DR0;

volatile SERIAL_PORT_REG *slpt = SERIAL_PORT_ADDR(0);

extern unsigned int shu_cai_flag;

/* //'串口控制寄存器

spo->gcontrol = 0x04;//'串行口总体控制寄存器

spo->s_x_control = 0x666;//'串行口发送控制寄存器

spo->s_r_control = 0x020;//'串行口接首控制寄存器

extern int nCurRotorNum_new;

extern int flash_write_buf[0x4000];

void busy_wait()

{

unsigned int busy_bit;

busy_bit = read_status();

while((busy_bit&0x80) != 0x80)

busy_bit = read_status(); //'信号忙则等

}

unsigned int read_status()

{

unsigned int i,statusBuffer=0;

unsigned int statusComand;

statusComand = 0x57;

//'串口选择模式0

wait_busy:

if( slpt->s_r_control_bit.clkdati == 0)

goto wait_busy; //' DB45BUSY

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

delay_new(10);

slpt->s_x_control_bit.clkdato = 0; //' DB45CS

delay_new(10);

for(i=0;i<17;i++)

{

if(i<8)

{

if((statusComand&0x80) == 0x80)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

statusComand = statusComand<<1;

}

else if(i>8)

{

statusBuffer<<=1;

if(slpt->s_r_control_bit.fsdatin == 1) //' SO

statusBuffer++;

}

slpt->s_x_control_bit.fsdatout = 1; //' DB45CLK

delay_new(2);

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

}

delay_new(5);

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

return(statusBuffer);

}

void read_mainMemoryPage(unsigned int pageAddr, unsigned int byteAddr,unsigned int wordLong)

{

unsigned int i,j;

unsigned int readPageComand = 0x52;

int *pBuffer;

int tempData = 0;

pBuffer = flash_write_buf;

busy_wait();

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

slpt->s_x_control_bit.clkdato = 0; //' DB45CS

for(i=0;i<65;i++)

{

if(i<8)

{

if((readPageComand&0x80) == 0x80)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

readPageComand <<= 1;

}

if((i>=8)&&(i<21))

{

if((pageAddr&0x1000) == 0x1000)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

pageAddr <<= 1;

}

if((i>=21)&&(i<32))

{

if((byteAddr&0x400) == 0x400)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

byteAddr <<= 1;

}

slpt->s_x_control_bit.fsdatout = 1; //' DB45CLK

delay_new(1);

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

}

for(i=0;i<WORDLONG;I++) if(slpt- <<="1;" *pBuffer="0;" { for(j="0;j<32;j++)">s_r_control_bit.fsdatin == 1)

*pBuffer = *pBuffer + 1; //' SO

slpt->s_x_control_bit.fsdatout = 1; //' DB45CLK

delay_new(4);

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

}

pBuffer++;

}

delay_new(5);

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

}

void write_mainMemoryPage(unsigned int pageAddr,unsigned int byteAddr,unsigned int wordLong)

{

unsigned int i,j;

unsigned int writePageComand = 0x53; // 'main->buffer1

int *pBuffer,temp;

pBuffer = flash_write_buf;

temp = pageAddr;

busy_wait();

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

slpt->s_x_control_bit.clkdato = 0; //' DB45CS

for(i=0;i<32;i++)

{

if(i<8)

{

if((writePageComand&0x80) == 0x80)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

writePageComand <<= 1;

}

if((i>=8)&&(i<21))

{

if((pageAddr&0x1000) == 0x1000)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

pageAddr <<= 1;

}

slpt->s_x_control_bit.fsdatout = 1; //' DB45CLK

delay_new(2);

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

}

pageAddr = temp;

writePageComand = 0x82;

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

busy_wait();

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

slpt->s_x_control_bit.clkdato = 0; //' DB45CS

for(i=0;i<32;i++)

{

if(i<8)

{

if((writePageComand&0x80) == 0x80)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

writePageComand <<= 1;

}

if((i>=8)&&(i<21))

{

if((pageAddr&0x1000) == 0x1000)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

pageAddr <<= 1;

}

if(i>=21)

{

if((byteAddr&0x400) == 0x400)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

byteAddr <<= 1;

}

slpt->s_x_control_bit.fsdatout = 1; //' DB45CLK

delay_new(2);

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

}

for(i=0;i<WORDLONG;I++) { for(j="0;j<32;j++)" slpt- 0x80000000) if((temp&0x80000000)="=" temp="*pBuffer;">s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

temp <<= 1;

slpt->s_x_control_bit.fsdatout = 1; //' DB45CLK

delay_new(3);

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

}

pBuffer++;

}

delay_new(5);

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

}

void erase_mainMemoryPage(int pageAddr,int comandFlag)

{

unsigned int i,j = 1,k;

unsigned int erasePageComand ; //'也擦出

unsigned int buf1,buf2;

if(comandFlag == 0)

{

erasePageComand = 0x81;

}

if(comandFlag == 1)

{

erasePageComand = 0x50;

}

if(comandFlag == 2)

{

erasePageComand = 0x50;

j = 1024;

}

buf1 = erasePageComand;

buf2 = pageAddr;

for(k=0;k<J;K++,BUF2=BUF2+8) { slpt- busy_wait(); pageAddr="buf2;" erasePageComand="buf1;">s_x_control_bit.clkdato = 1; //' DB45CS

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

slpt->s_x_control_bit.clkdato = 0; //' DB45CS

for(i=0;i<32;i++)

{

if(i<8)

{

if((erasePageComand&0x80) == 0x80)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

erasePageComand <<= 1;

}

if((i>=8)&&(i<21))

{

if((pageAddr&0x1000) == 0x1000)

slpt->s_x_control_bit.ddatout = 1; //' SI

else

slpt->s_x_control_bit.ddatout = 0; //' SI

pageAddr <<= 1;

}

slpt->s_x_control_bit.fsdatout = 1; //' DB45CLK

delay_new(2);

slpt->s_x_control_bit.fsdatout = 0; //' DB45CLK

}

delay_new(5);

slpt->s_x_control_bit.clkdato = 1; //' DB45CS

}

busy_wait();

本文链接

at45db642 程序代码

2010-07-04T16:39:00Z

at45db642_WR.C

#include "main.h"

//#include "at45db642_WR.h"

//================================================================================

//define data and flag moudle

//================================================================================

//==================================================read command

#define RESERVED_BITS 4

#define PAGE_ADDRESS_BITS 13

#define BUFF_ADDRESS_BITS 9

#define FLASH_READY BIT7+BIT5+BIT4+BIT3

#define COMP BIT6

const unsigned char CMD_flash_continousread = 0xE8; //Continues Array Read and 60 pluse no care

const unsigned char CMD_flash_continousRead_a = 0x69; //Continues Array Read and 61 pluse no care

const unsigned char CMD_flash_mainpagesread = 0xd2; //Main Memory Page Read and 60 pluse no care

const unsigned char CMD_flash_mainpagesRead_a = 0x52; //Main Memory Page Read and 61 pluse no care

const unsigned char CMD_flash_buffer1read = 0xd4; // Buffer 1 Read and 1 pules no care

const unsigned char CMD_flash_buffer1Read_a = 0x54; // Buffer 1 Read and 2 pules no care

const unsigned char CMD_flash_buffer2read = 0xd6; // Buffer 2 Read and 1 pules no care

const unsigned char CMD_flash_buffer2Read_a = 0x56; // Buffer 2 Read and 2 pules no care

const unsigned char CMD_flash_registerread = 0xd7; // register 1 Read and 0 pules no care

const unsigned char CMD_flash_registerRead_a = 0x57; // register 1 Read and 1 pules no care

//------------------------------------------------write command

const unsigned char CMD_flash_buffer1thmain = 0x82; // Main Memory Page Program through Buffer 1

const unsigned char CMD_flash_buffer1thmain_f = 0x92; // Main Memory Page Program through Buffer 1 ,fast programme

const unsigned char CMD_flash_buffer2thmain = 0x85; // Main Memory Page Program through Buffer 2

const unsigned char CMD_flash_buffer2thmain_f = 0x95; // Main Memory Page Program through Buffer 2 ,fast programme

const unsigned char CMD_flash_page_erase = 0x81; //page erase

const unsigned char CMD_flash_block_erase = 0x50; //block erase

const unsigned char CMD_flash_buffer1_write = 0x84; // Buffer1 Write

const unsigned char CMD_flash_buffer2_write = 0x87; // Buffer2 Write

const unsigned char CMD_flash_buffer1tomain_e = 0x83; // Buffer1 to Main Memory Page Program with Built-in Erase

const unsigned char CMD_flash_buffer2tomain_e = 0x86; // Buffer2 to Main Memory Page Program with Built-in Erase

const unsigned char CMD_flash_buffer1tomain = 0x88; // Buffer1 to Main Memory Page Program without Built-in Erase

const unsigned char CMD_flash_buffer2tomain = 0x89; // Buffer2 to Main Memory Page Program without Built-in Erase

const unsigned char CMD_flash_buffer1tomain_ef = 0x93; // Buffer1 to Main Memory Page Program with Built-in Erase ,fast programme

const unsigned char CMD_flash_buffer2tomain_ef = 0x96; // Buffer2 to Main Memory Page Program with Built-in Erase ,fast programme

const unsigned char CMD_flash_buffer1tomain_f = 0x98; // Buffer1 to Main Memory Page Program without Built-in Erase ,fast programme

const unsigned char CMD_flash_buffer2tomain_f = 0x99; // Buffer2 to Main Memory Page Program without Built-in Erase ,fast programme

//-----------------------------------------------additional command

const unsigned char CMD_flash_maintobuffer1 = 0x53; // Main Memory Page to Buffer 1

const unsigned char CMD_flash_maintobuffer2 = 0x55; // Main Memory Page to Buffer 2

const unsigned char CMD_flash_maincmpbuffer1 = 0x60; // Main Memory Page to Buffer 1 compare

const unsigned char CMD_flash_maincmpbuffer2 = 0x61; // Main Memory Page to Buffer 2 compare

const unsigned char CMD_flash_rewritethbuffer1 = 0x58; // Auto Page Rewrite through Buffer 1

const unsigned char CMD_flash_rewritethbuffer2 = 0x59; // Auto Page Rewrite through Buffer 2

//-------------------------------

#define CLOCK_DELAY() _NOP();_NOP();_NOP()

#define SET_FLASH_CS_LOW() at45db642ctr_out &= ~cs_ctr;CLOCK_DELAY()

#define SET_FLASH_CS_HIGH() at45db642ctr_out |= cs_ctr;CLOCK_DELAY()

#define SET_FLASH_PORT_OUT() at45db642io_dir = 0xff

#define SET_FLASH_PORT_INPUT() at45db642io_dir = 0x0

//-------------------------------

unsigned char check_busy(void);

void write_a_Byte(unsigned char w_type);

void write_nocareBit(unsigned short nocare_number);

void write_comand(unsigned char cmd,unsigned short adr_page,unsigned short buffer);

////////////////////////////////////////////////////////////////////////////////////////////

//=============================================================================================

//this is a subcountine for read and write a programme

//--------------------------------------

unsigned char Intialize_Write_at45db642memory(void)

{

unsigned short j;

if(Error_Code>RESULT_READY)return(Error_Code);

at45db642ctr_sel &= ~(parall_ctr + busy_ctr +cs_ctr);

at45db642spi_dir |= clk_ctr;

at45db642spi_out |= clk_ctr;

at45db642io_sel = 0x00;

at45db642io_dir = 0xff;

at45db642io_out = 0x00; //built on output port

at45db642ctr_dir |= parall_ctr; //select the parall port for transmit

at45db642ctr_dir |= cs_ctr;

CLOCK_DELAY();

at45db642ctr_dir &= ~busy_ctr;

at45db642ctr_out &= ~busy_ctr;

//--------------------------

CLOCK_DELAY();

at45db642spi_sel &= ~clk_ctr; //spi mode at45db642spi_sel |= clk_ctr;

at45db642spi_dir |= clk_ctr;

at45db642spi_out &= ~clk_ctr; //clk =0

//-----------------------------

CLOCK_DELAY();

at45db642ctr_out &= ~parall_ctr;

at45db642ctr_out |= cs_ctr; //cs = 1 """""""""""\_________________

at45db642spi_out &= ~clk_ctr; //clk = 0 _____________|""|__|""|______

for(j=1000;j>0;j--);

Error_Location=1;

if((Read_Status()&FLASH_READY)!=FLASH_READY)return(ERROR_FLASH_BUSY);

return(NO_ERROR);

}

////////////////////////////////////////////////////////////////////////////////////////////////////////

unsigned char Wait_busy(void)

{

unsigned short j;

if(Error_Code>RESULT_READY)return(Error_Code);

for(j=10000;j>0;j--)if(check_busy()==0)return(NO_ERROR); /// check flash ready

Error_Location=5;

return(ERROR_FLASH_BUSY);

}

////////////////////////////////////////////////////////////////////////////////////////////////////////read a stutes register

unsigned char Read_Status(void)

{

unsigned char cmd_adr[1];

unsigned char i;

cmd_adr[0] = CMD_flash_registerread; //no add pulse//60

//----------------------------------------

SET_FLASH_PORT_OUT();

SET_FLASH_CS_LOW();

write_a_Byte(cmd_adr[0]);

SET_FLASH_PORT_INPUT();

i = Read_a_Byte();

SET_FLASH_CS_HIGH();

return (i);

}

//-------------------------------

//////////////////////////////////////////////////////////////////////////////////////

unsigned char Erease_Block(unsigned short BlockNo)

{

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY);

write_comand(CMD_flash_block_erase,0,0);

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

//////////////////////////////////////////////////////////////////////////////////////

unsigned char Transfer_Page_to_Buffer(unsigned char bufferNo,unsigned short adr_page)

{

unsigned char cmd;

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY);

if(bufferNo==0)cmd = CMD_flash_maintobuffer1;

else cmd = CMD_flash_maintobuffer2;

write_comand(cmd,adr_page,0);

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

//////////////////////////////////////////////////////////////////////////////////////

unsigned char Compare_Page_to_Buffer(unsigned char bufferNo,unsigned short adr_page)

{ unsigned char cmd;

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY);

if(bufferNo==0)cmd = CMD_flash_maintobuffer1;

else cmd = CMD_flash_maintobuffer2;

write_comand(cmd,adr_page,0);

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

//////////////////////////////////////////////////////////////////////////////////////

unsigned char Auto_Page_rewrite(unsigned char bufferNo,unsigned short adr_page)

{

unsigned char cmd;

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY);

if(bufferNo==0)cmd = CMD_flash_rewritethbuffer1;

else cmd = CMD_flash_rewritethbuffer2;

write_comand(cmd,adr_page,0);

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////

unsigned char Start_Continuous_Array_Read(unsigned short adr_page,unsigned short adr_buffer)

{

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY); /// check flash ready

write_comand(CMD_flash_continousRead_a,adr_page,adr_buffer);

write_nocareBit(60); //write no care

SET_FLASH_PORT_INPUT();

Read_a_Byte();

return(NO_ERROR);

}

void End_Continuous_Array_Read(void)

{

SET_FLASH_CS_HIGH();

}

///////////////////////////////////////////////////////////////////////////////////////////////////read a type from buffer1

unsigned char Read_nByte_buffer(unsigned char bufferNo,type_datas_toFlash *rdata,unsigned short adr_buffer)

{

unsigned char cmd;

unsigned short i;

unsigned char * data = rdata->data;

unsigned short data_len = rdata->data_len;

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY); /// check flash ready

if(bufferNo==0)cmd = CMD_flash_buffer1read;

else cmd = CMD_flash_buffer2read;

write_comand(cmd,0,adr_buffer);

write_nocareBit(0x01); //write no care

SET_FLASH_PORT_INPUT();

for (i = 0; i <DATA_LEN; data="rdata-" * char unsigned i; short { *flash_address) *rdata,type_flash_address Read_nByte_main(type_datas_toFlash } (NO_ERROR); return SET_FLASH_CS_HIGH(); ++data; *data="Read_a_Byte();" i++)>data;

unsigned short data_len = rdata->data_len;

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY); /// check flash ready

write_comand(CMD_flash_mainpagesread,flash_address->adr_page,flash_address->adr_buffer);

write_nocareBit(60); //write no care

SET_FLASH_PORT_INPUT();

for (i = 0; i <DATA_LEN; data="rdata-" * char unsigned short { *flash_address) *rdata,type_flash_address } (NO_ERROR); return SET_FLASH_CS_HIGH(); ++data; *data="Read_a_Byte();" i++) i,adr_buff; cmd; bufferNo,type_datas_toFlash Write_mainpage_thr_buffer(unsigned buffer1 throuth pages main to types 1056 write>data;

unsigned short data_len = rdata->data_len;

if(Error_Code>RESULT_READY)return(Error_Code);

if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY);

Error_Location=4;

adr_buff=flash_address->adr_buffer;

if(adr_buff>=AT45DB642_BUFFER_LENGTH)return(ERROR_FLASH_BUFFER_ADR);

if(bufferNo==0)cmd = CMD_flash_buffer1thmain;

else cmd = CMD_flash_buffer2thmain;

write_comand(cmd,flash_address->adr_page,flash_address->adr_buffer);

for (i = 0 ; i < data_len; i++)

{

write_a_Byte(*data);

++data;

if(++adr_buff>AT45DB642_BUFFER_LENGTH)

{

SET_FLASH_CS_HIGH();

return(ERROR_FLASH_BUFFER_ADR);

}

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////write two types to buffer2

unsigned char Write_1byte_to_buffer(unsigned char bufferNo,unsigned char data,unsigned short adr_buffer)

{

unsigned char cmd;

// if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY); /// check flash ready

if(Error_Code>RESULT_READY)return(Error_Code);

if(adr_buffer>=AT45DB642_BUFFER_LENGTH)return(ERROR_FLASH_BUFFER_ADR);

if(bufferNo==0)cmd = CMD_flash_buffer1_write;

else cmd = CMD_flash_buffer2_write;

write_comand(cmd,0,adr_buffer);

write_a_Byte(data);

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

////////////////////////////////////////////////////////////////////////////////////

unsigned char Write_nbyte_to_buffer(unsigned char bufferNo,type_datas_toFlash *rdata,unsigned short adr_buffer)

{

unsigned char cmd;

unsigned short i;

unsigned char * data = rdata->data;

unsigned short data_len = rdata->data_len;

if(Error_Code>RESULT_READY)return(Error_Code);

// if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY); /// check flash ready

if(adr_buffer>=AT45DB642_BUFFER_LENGTH)return(ERROR_FLASH_BUFFER_ADR);

if(bufferNo==0)cmd = CMD_flash_buffer1_write;

else cmd = CMD_flash_buffer2_write;

write_comand(cmd,0,adr_buffer);

for (i = 0 ; i < data_len; i++)

{

write_a_Byte(*data);

data++;

if(++adr_buffer>AT45DB642_BUFFER_LENGTH)

{

SET_FLASH_CS_HIGH();

return(ERROR_FLASH_BUFFER_ADR);

}

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

//////////////////////////////////////////////////////////////////////////////////////////////////

unsigned char Write_buffer_to_main_Erase_Fast(unsigned char bufferNo,unsigned short adr_page)

{

unsigned char cmd;

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY);

if(bufferNo==0)cmd = CMD_flash_buffer1tomain_ef;

else cmd = CMD_flash_buffer1tomain_ef; //no add pulse//60

write_comand(cmd,adr_page,0);

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

//////////////////////////////////////////////////////////////////////////////////////////////////

unsigned char Write_buffer_to_main_Erase(unsigned char bufferNo, unsigned short adr_page)

{

unsigned char cmd;

if(Error_Code>RESULT_READY)return(Error_Code);

//if(Wait_busy()>RESULT_READY)return(ERROR_FLASH_BUSY);

if(bufferNo==0)cmd = CMD_flash_buffer1tomain_e;

else cmd = CMD_flash_buffer2tomain_e; //no add pulse//60

write_comand(cmd,adr_page,0);

SET_FLASH_CS_HIGH();

return(NO_ERROR);

}

///////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////

void write_comand(unsigned char cmd,unsigned short adr_page,unsigned short adr_buff)

{

unsigned char cmd_adr[4];

unsigned short i,j;

cmd_adr[0] = cmd;

i = adr_page;

i >>= 5;

cmd_adr[1] = i;

i = adr_page;

i <<= 3;

cmd_adr[2] = i;

i &= 0xf8;

j = adr_buff;

j >>= 8;

j &= 0x07;

i += j;

cmd_adr[2] = i;

cmd_adr[3] = adr_buff;

//----------------------------------------

SET_FLASH_PORT_OUT();

SET_FLASH_CS_LOW();

for (i = 0 ; i < 4; i++)write_a_Byte(cmd_adr[i]);

}

//-------------------------------

unsigned char check_busy(void)

{

if((at45db642ctr_in & busy_ctr)==0)return(1);

return (0);

}

//-------------------------------

void write_a_Byte(unsigned char w_type)

{

at45db642io_out = w_type;

at45db642spi_out |= clk_ctr; //clk = 1

CLOCK_DELAY();

at45db642spi_out &= ~clk_ctr; //clk =0

}

//--------------------------------

unsigned char Read_a_Byte(void)

{

unsigned char r_type;

at45db642spi_out |= clk_ctr; //clk = 1

CLOCK_DELAY();

r_type = at45db642io_in;

at45db642spi_out &= ~clk_ctr; //clk =0

return r_type;

}

//--------------------------------

void write_nocareBit(unsigned short nocare_number)

{

unsigned short i;

for (i = 0; i < nocare_number; i++)

{

at45db642io_out = i;

at45db642spi_out |= clk_ctr; //clk = 1

CLOCK_DELAY();

at45db642spi_out &= ~clk_ctr; //clk =0

}

at45db642_WR.h

#include "Mem_Global.h"
#ifdefEXTERN
#undefEXTERN
#endif

#ifdefMAIN_INCLUDE
#defineEXTERN
#else
#defineEXTERN extern
#endif

#ifdef DEFINE_AT45DB642
#else
#define DEFINE_AT45DB642
#define       AT45DB642_BUFFER_LENGTH         1024
#define       AT45DB642_TOTAL_BLOCK      1024
#define       AT45DB642_TOTAL_PAGE       8192
#define       AT45DB642_TOTAL_SECTOR     33
#endif

#define at45db642io_sel    P4SEL
#define at45db642io_dir    P4DIR
#define at45db642io_out    P4OUT
#define at45db642io_in     P4IN

#define clk_ctr            BIT3
#define simo_ctr           BIT1
#define somi_ctr           BIT2
#define at45db642spi_sel   P3SEL
#define at45db642spi_in    P3IN
#define at45db642spi_out   P3OUT
#define at45db642spi_dir   P3DIR

#define at45db642ctr_sel   P2SEL
#define at45db642ctr_dir   P2DIR
#define at45db642ctr_out   P2OUT
#define at45db642ctr_in    P2IN
#define parall_ctr         BIT0
#define cs_ctr             BIT1
#define gnd_ctr            BIT2
#define busy_ctr           BIT3

EXTERN       unsigned char Intialize_Write_at45db642memory(void);
EXTERN       unsigned char Read_Status(void);
EXTERN       unsigned char Wait_busy(void);
EXTERN       unsigned char Read_a_Byte(void);

EXTERN       unsigned char Erease_Block(unsigned short BlockNo);
EXTERN       unsigned char Transfer_Page_to_Buffer(unsigned char bufferNo,unsigned short adr_page);
EXTERN       unsigned char Compare_Page_to_Buffer(unsigned char bufferNo,unsigned short adr_page);
EXTERN       unsigned char Auto_Page_rewrite(unsigned char bufferNo,unsigned short adr_page);

EXTERN       unsigned char Start_Continuous_Array_Read(unsigned short adr_page,unsigned short adr_buffer);
EXTERN       void          End_Continuous_Array_Read(void);

EXTERN       unsigned char Read_nByte_buffer(unsigned char bufferNo,type_datas_toFlash *rdata,unsigned short adr_buffer);
EXTERN       unsigned char Read_nByte_main(type_datas_toFlash *rdata,type_flash_address *flash_address);

EXTERN       unsigned char Write_1byte_to_buffer(unsigned char buffer,unsigned char data,unsigned short adr_buffer);
EXTERN       unsigned char Write_nbyte_to_buffer(unsigned char bufferNo,type_datas_toFlash *rdata,unsigned short adr_buffer);
EXTERN       unsigned char Write_buffer_to_main_Erase(unsigned char bufferNo,unsigned short adr_page);
EXTERN       unsigned char Write_buffer_to_main_Erase_Fast(unsigned char bufferNo,unsigned short adr_page);
EXTERN       unsigned char Write_mainpage_thr_buffer(unsigned char bufferNo,type_datas_toFlash *rdata,type_flash_address *flash_address);
#undefEXTERN
//---------------------------------------------------------------------------------

本文链接

点对点通信实验小结

2010-07-03T19:10:00Z

zigbee点对点通信 2010-06-28 21:47:32 阅读36 评论0 字号：大中小

协议栈版本信息：无线龙2004协议栈点对点无线通信实验

今天晴天从以前430那数据采集板上取了一块好的CC2430模块,这样5块里面有两块能用了,下午做了下点对点的通信.

总结下.
实验的内容是发送节点A发送字符串到接收节点B,节点B再把接收到的数据通过串口送PC显示.(由于扩展板液晶有问题只能送PC显示数据)
主要改动集中在rf_test.c这个文件中.
/****
Filename:     rf_test.c
Target:       cc2430
Revised:      16/12-2005
Revision:     1.0

Description:
    This file provides 4 small tests which demonstrates use of the radio.

/

#include "ioCC2430.h"
#include "cul.h"
#include "hal.h"
#include "RF04EB.h"

#define ADDRESS_0 0x01
#define ADDRESS_1 0x02

#define SEND     0
#define RECEIVE 1

#define SINGLE      0
#define CONTINUOUS 1
#define PING_PONG   2
#define PER_TEST    3
#define EXIT        4

#define RECEIVE_TIMEOUT               800

#define PING_PONG_TIMEOUT             1200
#define PING_PONG_REQUEST             0x80
#define PING_PONG_RESPONSE            0x40

#define PER_RECEIVE_TIMEOUT          10000
#define PER_TOTAL_PACKET_NUMBER       1000
#define PER_TEST_REQUEST              0x20

void initRfTest(void);
void rf_test_main(void);
void receivePacket(UINT8 receiveByte);
void sendPacket(UINT8 sendByte);

void receiveMode(void);
void contionuousMode(void);

UINT8 RxTxState;
UINT8 myAddr;
UINT8 remoteAddr;
/********************************************
* @fn initRfTest
*
* @brief
*      Initializes components for the RF test application example.
*
* Parameters:
*
* @param void
*
* @return void
*
/
void initRfTest(void)
{
   UINT32 frequency = 2405000;
   INIT_GLED();
   INIT_YLED();
   radioInit(frequency, myAddr);
}

/
* @fn rf_test_main
*
* @brief
*      Main function.
*
* Parameters:
*
* @param void
*
* @return void
*
/
#ifdef COMPLETE_APPLICATION
void rf_test_main(void){
#else
void main(void){
#endif
   INT_GLOBAL_ENABLE(INT_ON);
   P1_2 = 0; //###设为0下载进发送节点;设为1下载进接收节点
   if(P1_2)
   {
      myAddr = ADDRESS_0;
      remoteAddr = ADDRESS_1;
      initRfTest();
                        receiveMode(); //P1_2 = 1 接收
   }
   else
   {
      myAddr = ADDRESS_1;
      remoteAddr = ADDRESS_0;
      initRfTest();
                        contionuousMode(); //P1_2 = 0 发送
   }
}

/
* @fn contionuousMode
*
* @brief
*      Function for transferring packets until stopped by user.
*
* Parameters:
*
* @param void
*
* @return void
*
****************/
void contionuousMode(void)
{
   BOOL res;
   //BYTE sendBuffer[ ] = "hello.";
   BYTE sendBuffer[ ] = "hello! my name is WuJianFeng.";
   while(1)
   {
      GLED = LED_OFF; //红灭
      YLED = LED_ON;    //黄亮
      res = radioSend(sendBuffer, sizeof(sendBuffer), remoteAddr, DO_NOT_ACK );
      halWait(200);
      YLED = LED_OFF; //黄灭
      halWait(200);
      if(res == TRUE)
      {
         GLED = LED_ON; //红亮
         halWait(200);
      }
      else
      {
         GLED = LED_OFF; //红灭
         halWait(200);
      }
   }
}

//
/*
void txdata(BYTE* dat) //###串口发送函数：字符串，字符
{
while(dat)
{
U0DBUF=dat++;
while(!UTX0IF);
UTX0IF=0;
}
}
/

void txdata_1(BYTE dat) //###串口发送函数：单个字符
{
U0DBUF = dat;
while (!UTX0IF);
UTX0IF = 0;
}

void UartTX_Send_String(char Data,int len) //###串口发送函数：字符串
{
int j;
for(j=0;j<len;j++)
{
    U0DBUF = *Data++;
    while(UTX0IF == 0);
    UTX0IF = 0;
}
}
/**********************************************
* @fn receiveMode
*
* @brief
*      Function for receiving data.
*
* Parameters:
*
* @param void
*
* @return void
*
***********************************************/
void receiveMode(void)
{
   BYTE* receiveBuffer;
   BYTE length;
   BYTE res;
   BYTE sender;

   while(1)
   {
      YLED = LED_ON; //黄亮
      res = radioReceive(&receiveBuffer, &length, RECEIVE_TIMEOUT, &sender);
      YLED = LED_OFF; //黄灭

      //res = TRUE;//###个人添加

      if(res == TRUE)
      {
         GLED = LED_ON; //红亮
         halWait(200);
        // txdata_1('x');
         UartTX_Send_String(receiveBuffer,length); //###把接收到的数据通过串口送PC
         txdata_1(' \n '); //###换行符
      }
      else
      {
         GLED = LED_OFF; //红灯—原：OFF
         halWait(200);
      }

      GLED = LED_OFF; //红灯—原：OFF
   }
}

//-----------------------------------------
//###添加的串口接收中断函数
#pragma vector = URX0_VECTOR
__interrupt void URX0_ISR(void)
{
    unsigned uarttemp;
    uarttemp = U0DBUF; //串口调试软件发送的数据给uarttemp
    U0DBUF = uarttemp; //把接收到的数据返送串口软件显示
}
/*********************************************/

在rf_test_main()中设置P1.2=0,把程序下载进发送节点A,设置P1.2=1下载进接收节点B;个人这样做是不准备用外部跳线来设置节点类型.

函数radioReceive(&receiveBuffer, &length, RECEIVE_TIMEOUT, &sender)的原型是
BOOL radioReceive(BYTE receiveData, BYTE* length, WORD timeout, BYTE* sender)
receiveData是一个双重指针变量，receiveBuffer是一个指针变量，从上面可以看到双重指针变量receiveData是指向指针变量receiveBuffer，而receiveBuffer指向BYTE型变量的数据,即receiveData指向BYTE型变量的数据.
receiveData = rxData.payload
接收中payload是一个数组,把数组的首地址赋给receiveData
因而这里：
UartTX_Send_String(receiveBuffer,length)
UartTX_Send_String(char Data,int len)
是把BYTE型变量数据(即数组payload内的数据)首地址赋给*Data.

程序中的YLED和GLED与我板上的灯不匹配,具体信息可以参见<CC2430单片机LED实验>这篇记录.
从发送节点A的contionuousMode()函数来看，如果发送成功，则板上的红黄灯会不停地亮灭；
而从接收节点B的receiveMode()函数来看，如果接收成功，板上的红黄灯也会不停地亮灭；这时如果把发送节点A关闭,则红灯灭,黄灯不停地亮灭,这点可以自己试验下.
我在程序中添加了两个函数，一个是txdata_1()用于在接收节点B中发给串口单个字符;一个是UartTX_Send_String()用于在接收节点B中发给串口字符串.最后的串口接收中断函数只是为了看下回显情况.
第一次是发送sendBuffer[ ] = "hello.";
第二次是发送sendBuffer[ ] = "hello! my name is WuJianFeng."; 和'\n'换行符

实验结果如下：

发送节点A:

接收节点B:

第一次是发送sendBuffer[ ] = "hello.";

第二次是发送sendBuffer[ ] = "hello! my name is WuJianFeng."; 和'\n' 换行符

11是验证下程序最后的串口接收中断函数是否有效.

发送节点A与接收节点B.具体能有多远我没有去测试.

    本想试验下发送节点A和接收节点B都通过串口与PC相连,在串口助手上发送数据.下次有空再做下.

****

*

说明：
本文作者所记录，错误处还请高手指点，本人随时更新，转载请注明出处。谢谢！
注意波特率为57600                                                           2010.6.28   ～XF

更新：2010.6.29
本文链接

CC2430串口收发数据

2010-07-03T18:37:00Z

//cd wxl

//说明：本实验在成都无线龙提供的CC2430模块中调试通过。http://http://www.c51rf.com/

//cd wxl
/*****************************************
数据格式：灯选择开关 #
10# 关RED LED
11# 开RED LED
20# 关GREEN LED
21# 开GREEN LED
*****************************************/
#include <iocc2430.h>
#include <string.h>

#define uint unsigned int
#define uchar unsigned char
#define FALSE 0
#define TURE 1

//定义控制灯的端口
#define led1 P1_0
#define led2 P1_1

void Delay(uint);
void initUARTtest(void);

uchar Recdata[3]="000";
uchar RTflag = 1;
uchar temp;
uint datanumber = 0;
uint stringlen;

/****************************************************************
*函数功能：延时
*入口参数：定性延时
*返回值：无
*说    明：
****************************************************************/
void Delay(uint n)
{
uint i;
for(i=0;i<n;i++);
for(i=0;i<n;i++);
for(i=0;i<n;i++);
for(i=0;i<n;i++);
for(i=0;i<n;i++);
}

/****************************************************************
*函数功能：初始化串口1
*入口参数：无
*返回值：无
*说    明：57600-8-n-1
****************************************************************/
void initUARTtest(void)
{

CLKCON &= ~0x40;              //晶振
    while(!(SLEEP & 0x40));      //等待晶振稳定
    CLKCON &= ~0x47;             //TICHSPD128分频，CLKSPD不分频
    SLEEP |= 0x04;    //关闭不用的RC振荡器

PERCFG = 0x00; //位置1 P0口
P0SEL = 0x3c; //P0用作串口

U0CSR |= 0x80;     //UART方式
    U0GCR |= 10;     //baud_e
    U0BAUD |= 216;     //波特率设为57600
    UTX0IF = 1;

U0CSR |= 0X40; //允许接收
IEN0 |= 0x84; //开总中断，接收中断
}

/*****************************************
*函数功能：初始化P1口为输出
*入口参数：无
*返回值：无
*说    明：无
*****************************************/
void Init_LED_IO(void)
{
//P1 out
P1DIR |= 0x03;      //P1控制LED
led1 = 1;
led2 = 1;     //关LED
}

/****************************************************************
*函数功能：主函数
*入口参数：无
*返回值：无
*说    明：无
****************************************************************/
void main(void)
{
        uchar ii;

Init_LED_IO();
initUARTtest();

while(1)
{
          if(RTflag == 1)    //接收
          {
            if( temp != 0)
            {
                if((temp!='#')&&(datanumber<3))
                {                               //’＃‘被定义为结束字符
                                                //最多能接收3个字符
                  Recdata[datanumber++] = temp;
                }
                else
                {
                  RTflag = 3;                   //进入改变小灯的程序
                }
                if(datanumber == 3)RTflag = 3;
              temp = 0;
            }
          }
          if(RTflag == 3)
          {
            if(Recdata[0]=='1')
            {
              if(Recdata[1]=='0')led1 = 1;      // 10# 关红色LED
              else
                led1 = 0;                       // 11# 开红色LED
            }

if(Recdata[0]=='2')
            {
              if(Recdata[1]=='0')led2 = 1;      // 20# 关绿色LED
              else
                led2 = 0;                       // 21# 开绿色LED
            }
            RTflag = 1;
            for(ii=0;ii<3;ii++)Recdata[ii]=' '; //清除刚才的命令
            datanumber = 0;                     //指针归位
          }
        }//while
}

/****************************************************************
*函数功能：串口接收一个字符
*入口参数 : 无
*返回值：无
*说    明：接收完成后仍然允许接收
****************************************************************/
#pragma vector = URX0_VECTOR
__interrupt void UART0_ISR(void)
{
   URX0IF = 0;     //清中断标志
temp = U0DBUF;
}

更多资料与技术讨论请联系：

上海无线龙通讯科技有限公司

本文链接

gps 信号解析与显示

2010-07-03T18:35:00Z

; 使用AVR单片机解析出GPSRM数据段的信息，提取时间、经纬度、指示出南北半球及东西经、日期、以及当前数据是否有效的标识位，

; 并将这些信息显示在1602液晶屏上。

;

; 网站: http://www.ruixuedz.cn

；email: unaided@tom.com

; 作者: 老蒋

#include <AVR_PQ1A.H> //包含自定义常量头文件

#include <AVR interrupt.h>

uchar buf[500]; //串口接受数据缓冲区

uint readCount=0; //串口解析数据计数

uint writeCount=0; //串口接受数据计数

uchar Time[6]; //gps时间

uchar Date[6]; //gps日期

uchar Status; //gps有效性

uchar Latitude[9]; //gps纬度

uchar NSIndicator; //gps南北半球标识位

uchar Longitude[10];//gps经度

uchar EWIndicator; //gps东西经标识位

uchar Speed[4]; //gps速度

/*******************************************

函数名称: Uart_init

功能: 异步串口初始化

参数: baud--设置的波特率

返回值 : 无

********************************************/

void Uart_init(uint baud)

{

baud=MCLK/16/baud-1; //波特率最大为65K

UCSRB=0x00;

UCSRA=0x00; //控制寄存器清零

UCSRC=(1<<URSEL)|(0<<UPM0)|(3<<UCSZ0); UBRRH="baud" UBRRL="baud;" 选择UCSRC，异步模式，禁止校验，1位停止位，8位数据位>>8; //设置波特率

UCSRB=(1<<TXEN)|(1<<RXEN)|(1<<RXCIE); if(writeCount ++writeCount; 将接收到的数据存入全局数组 buf[writeCount]="UDR;" 关闭接收中断 UCSRB&="~BIT(RXCIE);" { ISR(USART_RXC_vect) ******************************************** 无 : 返回值数: 参异步串口接收能: 功 Uart_RX 函数名称: ******************************************* } Uart_sendB(*sendpt++); 字符串未结束则继续发送 while(*sendpt) *sendpt) Uart_sentstr(uchar void sendpt--发送的数组指针异步串口发送一个字符串 Uart_sentstr 清除发送完毕状态位 UCSRA|="1<<TXC;" 等待发送完毕 while(!(UCSRA&(1<<TXC))); 发送数据 UDR="sendB;" 等待发送缓冲区为空 while(!(UCSRA&(1<<UDRE))); sendB) Uart_sendB(uchar sendB--发送的字节数据异步串口发送一个字节 Uart_sendB 配置TX为输出（很重要） DDRD|="0X02;" 全局中断开放 sei(); 接收、发送使能，接收中断使能> 499)

writeCount = 0;

UCSRB|=BIT(RXCIE); //使能接收中断

}

/*******************************************

函数名称: Read_byte

功能: 从接受缓冲区中读取一个字节

参数: 无

返回值 : temp--读取到的数据

********************************************/

uchar Read_byte(void)

{

uchar temp;

while(readCount == writeCount)

{

Delayms(10);

}

temp = buf[readCount];

++readCount;

if(readCount > 499)

readCount = 0;

return temp;

}

/*******************************************

函数名称: LCD1602_portini

功能: 初始化1602液晶用到的IO口

参数: 无

返回值 : 无

********************************************/

void LCD1602_portini(void)

{

LCDa_CTRL_DDR |= BIT(LCDa_RS)|BIT(LCDa_RW)|BIT(LCDa_E);//配置控制管脚为输出

LCDa_DATA_DDR |= 0xFF;//配置数据管脚为输出

}

/*******************************************

函数名称: LCD1602_readbyte

功能: 从1602液晶读出一个字节数据或者指令

参数: DatCmd--为iDat时是数据，为iCmd时是指令

返回值 : dByte--读回的数据或者指令

********************************************/

uchar LCD1602_readbyte(uchar DatCmd)

{

uchar dByte;

if (DatCmd == iCmd) //指令操作

LCDa_CLR_RS;

else

LCDa_SET_RS;

LCDa_SET_RW; //读操作

LCDa_SET_E;

LCDa_DATA_DDR=0x00; //数据总线定义为输入

dByte=LCDa_DI; //读数据或者指令

Delayms(1); //时序调整

LCDa_CLR_E;

LCDa_DATA_DDR|=0xff; //数据总线还原为输出

return dByte;

}

/*******************************************

函数名称: LCD1602_sendbyte

功能: 向1602液晶写入一个字节数据或者指令

参数: DatCmd--为iDat时是数据，为iCmd时是指令

dByte--为写入1602的数据或者指令

返回值 : 无

********************************************/

void LCD1602_sendbyte(uchar DatCmd, uchar dByte)

{

if (DatCmd == iCmd) //指令操作

LCDa_CLR_RS;

else

LCDa_SET_RS; //数据操作

LCDa_CLR_RW; //写操作操作

LCDa_SET_E;

LCDa_DO = dByte; //写入数据

Delayms(1);

LCDa_CLR_E;

}

/*******************************************

函数名称: LCD1602_sendstr

功能: 向1602液晶写入一个字符串

参数: ptString--字符串指针

返回值 : 无

********************************************/

void LCD1602_sendstr(uchar *ptString)

{

while((*ptString)!='\0') //字符串未结束就一直写

{

LCD1602_sendbyte(iDat, *ptString++);

}

/*******************************************

函数名称: LCD1602_clear

功能: 1602液晶清屏

参数: 无

返回值 : 无

********************************************/

void LCD1602_clear(void)

{

LCD1602_sendbyte(iCmd,LCDa_CLS);//写入清屏指令

Delayms(40);// 清屏指令写入后，2ms 的延时是很必要的!!!

}

/*******************************************

函数名称: LCD1602_readBF

功能: 1602液晶清屏

参数: 无

返回值 : busy--为1时是忙状态，为0时可以接收指令

********************************************/

uchar LCD1602_readBF(void)

{

uchar busy;

busy=LCD1602_readbyte(iCmd); //读回BF标志（忙标志）和地址

if(busy&0x80) //如果忙返回正在忙的状态

busy=1;

else //如果不忙，可以写入

busy=0;

return busy;

}

/*******************************************

函数名称: LCD1602_gotoXY

功能: 移动到指定位置

参数: Row--指定的行

Col--指定的列

返回值 : 无

********************************************/

void LCD1602_gotoXY(uchar Row, uchar Col)

{

switch (Row) //选择行

{

case 1:

LCD1602_sendbyte(iCmd, LCDa_L1 + Col); break; //写入第1行的指定列

case 2:

LCD1602_sendbyte(iCmd, LCDa_L2 + Col); break; //写入第2行的指定列

default:

break;

}

/*******************************************

函数名称: LCD1602_initial

功能: 1602液晶初始化

参数: 无

返回值 : 无

********************************************/

void LCD1602_initial(void)

{

Delayms(100); //上电后等待内部复位

LCD1602_portini(); //端口初始化

LCD1602_sendbyte(iCmd, LCDa_FUNCTION); //功能、模式设定，具体的设定功能可以看C:\icc\include\AVR_PQ1A.H里面的常量定义

while(LCD1602_readBF()); //等待不忙为止

LCD1602_sendbyte(iCmd, LCDa_ON); //打开显示

while(LCD1602_readBF()); //等待不忙为止

LCD1602_clear(); //清屏

while(LCD1602_readBF()); //等待不忙为止

LCD1602_sendbyte(iCmd, LCDa_ENTRY); //输入模式设定

}

/*******************************************

函数名称: clear_gprmc

功能: 清空gprmc显示缓冲区

参数: 无

返回值 : 无

********************************************/

void clear_gprmc(void)

{

uchar i;

for(i=0; i<6; i++)

{

Time[i] = '0';

Date[i] = '0';

}

for(i=0; i<9; i++)

{

Latitude[i] = '0';

}

for(i=0; i<10; i++)

{

Longitude[i] = '0';

}

for(i=0; i<4; i++)

{

Speed[i] = '0';

}

Status = '0';

NSIndicator = '0';

EWIndicator = '0';

}

/*******************************************

函数名称: Parse_gprmc

功能: 解析GPRMC字段

参数: 无

返回值 : 无

********************************************/

void Parse_gprmc(void)

{

uchar i;

uchar temp;

clear_gprmc();

Read_byte();

temp = Read_byte();

if(',' != temp)

{

Time[0] = temp;

for(i=0; i<5; i++)

{

Time[i+1] = Read_byte();

}

Read_byte();

}

Status = Read_byte();

Read_byte();

temp = Read_byte();

if(',' != temp)

{

Latitude[0] = temp;

for(i=0; i<3; i++)

{

Latitude[i+1] = Read_byte();

}

Read_byte();

for(i=0; i<5; i++)

{

Latitude[4+i] = Read_byte();

}

Read_byte();

}

temp = Read_byte();

if(',' != temp)

{

NSIndicator = temp;

Read_byte();

}

temp = Read_byte();

if(',' != temp)

{

Longitude[0] = temp;

for(i=0; i<4; i++)

{

Longitude[i+1] = Read_byte();

}

Read_byte();

for(i=0; i<5; i++)

{

Longitude[5+i] = Read_byte();

}

Read_byte();

}

temp = Read_byte();

if(',' != temp)

{

EWIndicator = temp;

Read_byte();

}

temp = Read_byte();

if(',' != temp)

{

Speed[0] = temp;

Read_byte();

for(i=0; i<3; i++)

{

Speed[1+i] = Read_byte();

}

Read_byte();

}

Read_byte();

temp = Read_byte();

if(',' != temp)

{

Date[0] = temp;

for(i=0; i<5; i++)

{

Date[i+1] = Read_byte();

}

/*******************************************

函数名称: Display_gprmc

功能: 显示GPRMC字段信息

参数: 无

返回值 : 无

********************************************/

void Display_gprmc(void)

{

uchar high,low,i;

high = Time[0];

low = Time[1];

low = low+8;

if(low > 57)

{

low = low - 10;

high = high + 1;

}

LCD1602_clear();

while(LCD1602_readBF());

LCD1602_gotoXY(1,0);

LCD1602_sendbyte(iDat,high);

LCD1602_sendbyte(iDat,low);

LCD1602_sendbyte(iDat,':');

LCD1602_sendbyte(iDat,Time[2]);

LCD1602_sendbyte(iDat,Time[3]);

LCD1602_sendbyte(iDat,':');

LCD1602_sendbyte(iDat,Time[4]);

LCD1602_sendbyte(iDat,Time[5]);

LCD1602_sendbyte(iDat,' ');

LCD1602_sendbyte(iDat,Status);

while(LCD1602_readBF());

LCD1602_gotoXY(2,0);

LCD1602_sendbyte(iDat,Date[4]);

LCD1602_sendbyte(iDat,Date[5]);

LCD1602_sendbyte(iDat,'.');

LCD1602_sendbyte(iDat,Date[2]);

LCD1602_sendbyte(iDat,Date[3]);

LCD1602_sendbyte(iDat,'.');

LCD1602_sendbyte(iDat,Date[0]);

LCD1602_sendbyte(iDat,Date[1]);

Delayms(50000);

LCD1602_clear();

while(LCD1602_readBF());

LCD1602_gotoXY(1,0);

LCD1602_sendbyte(iDat,Latitude[0]);

LCD1602_sendbyte(iDat,Latitude[1]);

LCD1602_sendbyte(iDat,'.');

for(i=0; i<7; i++)

{

LCD1602_sendbyte(iDat,Latitude[2+i]);

}

LCD1602_sendbyte(iDat,' ');

LCD1602_sendbyte(iDat,NSIndicator);

while(LCD1602_readBF());

LCD1602_gotoXY(2,0);

LCD1602_sendbyte(iDat,Longitude[0]);

LCD1602_sendbyte(iDat,Longitude[1]);

LCD1602_sendbyte(iDat,Longitude[2]);

LCD1602_sendbyte(iDat,'.');

for(i=0; i<7; i++)

{

LCD1602_sendbyte(iDat,Longitude[3+i]);

}

LCD1602_sendbyte(iDat,' ');

LCD1602_sendbyte(iDat,EWIndicator);

Delayms(50000);

}

/*******************************************

函数名称: Read_gprmc

功能: 读取GPRMC字段

参数: 无

返回值 : 无

********************************************/

void Read_gprmc(void)

{

uchar temp = 0;

temp = Read_byte();

if(temp == '$')

{

Read_byte();

temp = Read_byte();

if(temp == 'R')

{

temp = Read_byte();

if(temp == 'M')

{

temp = Read_byte();

if(temp == 'C')

{

Parse_gprmc();

Display_gprmc();

}

/*******************************************

函数名称: main

功能:

参数: 无

返回值 : 无

********************************************/

int main(void)

{

Board_init( ); //初始化开发板

Uart_init(9600); //初始化串口，设置波特率

LCD1602_initial();

while(LCD1602_readBF());

LCD1602_gotoXY(1,0);

LCD1602_sendstr("AVR_PQ1A BOARD");

while(1)

{

Read_gprmc();

}

本文链接

CC2430串口测试实验（UART）

2010-07-03T08:51:00Z

zigbee实验 2010-03-26 12:04:37 阅读388 评论13 字号：大中小

无线龙04协议栈 CC2430单片机串口测试实验（UART）

程序：

1、《main.c》

#define ENABLE_ALL_INTERRUPT() (IEN0 |= 0x80)
#define DISABLE_ALL_INTERRUPT() (IEN0 &= ~0x80)

#include"ioCC2430.h"

#define uchar unsigned char
#define uint unsigned int
#define BYTE unsigned char

extern void UARTxISRopen(void); //开串口接收中断服务函数
extern void SET_UART0_ISR(void); //串口中断接收设置函数
extern void initUART(void); //初始化函数

main( void )
{
     uchar temp = 0;

     SLEEP &= ~0x04; //reset 2:Both oscillators powered up
     while(!(SLEEP & 0x40)); //XOSC is powered up and stable 等待起振
     CLKCON &= ~0x47; //reset 6:Main clock oscillator select: 32 MHz crystal oscillator
     SLEEP |= 0x04; //set 2:Oscillator not selected by OSC bit powered down
                               //先让两个振荡器都起振；等待晶体振荡器起振并稳定；
                               //通过CLKCON的OSC位把主时钟选择32M晶体振荡器；
                               //再让没有被CLKCON的OSC位选择的振荡器停止起振（关RC振荡器）

     initUART(); //初始化
     UARTxISRopen(); //开串口中断
     ENABLE_ALL_INTERRUPT(); //开全局中断
     while(1);
}

振荡器起振稳定——>设置主时钟——>初始化串口——>开串口中断——>开全局中断

//----------------------------------------------------------------------------

2、《uart.c》

#include"ioCC2430.h"
unsigned uarttemp;

#define ENABLE_ALL_INTERRUPT() (IEN0 |= 0x80) //开全局中断
#define DISABLE_ALL_INTERRUPT() (IEN0 &= ~0x80) //关全局中断

#define IO_PER_LOC_UART0_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x01)|0x00; } while (0)
//reste 0:USART0 I/O location: Alternative 1 location
//选择USART0为通道1：P0.2345
#define uchar unsigned char

#define CRYSTAL 0x00
#define RC 0x01

#define HIGH_STOP 0x02 //停止位为高电平
#define LOW_STOP 0x00 //停止位为低电平

#define CLKSPD (CLKCON & 0x07) //32KHZ and 32MHZ crystal oscilliator;32MHZ ticks

#define TRANSFER_MSB_FIRST 0x80 //最高位先发送
#define TRANSFER_MSB_LAST 0x00 //最高位后发送
//LSB（Least Significant Bit），意为最低有效位
//MSB（Most Significant Bit），意为最高有效位

#define UART_ENABLE_RECEIVE 0x40 //UART接收使能

#define UART_SETUP(uart, baudRate, options)        \
   do                        \
      {                                            \
        if((uart) == 0)      \ //if uart=0,chose USART0_UART/SPI
        {                                          \
           if(PERCFG & 0x01) \ //if U0CFG=1,chose location 2
           {                                       \
              P1SEL |= 0x30; \ //then P1.4/5 set as peripheral I/O
           }                   //P1.4/5分别是RX，TX两条线，UART可由这两线组成，也可再加上RT，CT这两条
           else              \ //if U0CFG=0,chose location 1
           {
              P0SEL |= 0x0C; \ //then P0.2/3 set as peripheral I/O；同样为RX，TX两线
           }                                       \
        }                                          \
        else                 \ //if uart=1,chose USART1_UART/SPI
        {                                          \
           if(PERCFG & 0x02) \ //if U1CFG=1,chose location 2
           {                                       \
              P1SEL |= 0xC0; \ //then P1.6/7 set as peripheral I/O
           }
           else              \ //if U1CFG=0 ,chose location 1
           {                                       \
              P0SEL |= 0x30; \ //then P0.4/5 set as peripheral I/O
           }                                       \
        }                                          \
                                                 //以上进行USATR通道选择设置
                                                 // ##中间的uart根据上面的设置为0或1
      U##uart##GCR = BAUD_E((baudRate),CLKSPD); \ //设置波特率指数值
             //U##uart##GCR：普通控制寄存器
      U##uart##BAUD = BAUD_M(baudRate);         \ //设置波特率尾数值
             //U##uart##BAUD：波特率控制寄存器
                                                 \
      U##uart##CSR |= 0x80;                  \                    //USART设为UART模式
             //U##uart##CSR：控制及状态寄存器
      U##uart##UCR |= ((options) | 0x80);      \ //chose UART stop bit level and set FLUSH bit
              //U##uart##UCR :UART控制寄存器
                                         \
      if((options) & TRANSFER_MSB_FIRST) \ //options=0x02：High stop bit
      { \ // 0x02/0x00 & 0x80
         U##uart##GCR |= 0x20;           \ //MSB first
      } \ //对于options=0x00这种情况，估计是以GCR寄存器默认的LSB first方式
      U##uart##CSR |= 0x40;              \ //Receiver enabled 接收使能
   } while(0) // The macros in this section are available for both SPI and UART operation.



#define SET_MAIN_CLOCK_SOURCE(source) \ //source=CRYSTAL(0x00)/RC(0x01)
   do {                               \
      if(source) //RC Oscillator
      {                    \
        CLKCON |= 0x40; //set 7, 16MHZ HF RC Oscillator
        while(!HIGH_FREQUENCY_RC_OSC_STABLE); // wait for stable
        if(TICKSPD == 0)
        {             \
          CLKCON |= 0x08; //set 3,16MHZ Timer ticks output
        }                             \
        SLEEP |= 0x04;   //set 2,"oscillator not slected by OSC bit" powered down
      }                \//因为这里是用RC Oscillator，因此在CLKCON中的OSC位
                        //选择16M的RC；无论在SLEEP中有没有选择让它起振，
                        //通过OSC位选择的振荡器都会起振。最后SLEEP |= 0x04
                        //确定所用振荡器由CLKCON中的OSC位来选择，
                        //那这里是选择了16M的RC，因而CRYSTAL没有起振。

      else //CRYSTAL Oscillator
      {                          \
        SLEEP &= ~0x04; //reset 2,both oscillator powered up；
        while(!XOSC_STABLE); //wait for stable
        asm("NOP");                   \
          CLKCON &= ~0x47; //rest 6: 32M crystal oscillator;这里也应该是默认的16M ticks吧？
        SLEEP |= 0x04;         \ //首先SLEEP选择了两个振荡器都起振
      }                        \        //然后通过CLKON的OSC位选择了32M的主时钟晶体振荡器
   }while (0)                   //最后SLEEP |= 0x04确定所用振荡器由CLKCON中
                                       //的OSC位来选择，那这里是选择了32M的CRYSTAL，因而

                                        //晶体振荡器起振，RC振荡器没有起振
// BAUD_E along with BAUD_M decides the UART baud rate
// and the SPI master SCK clock frequency
// BAUD_E和BAUD_M共同决定了波特率，参见波特率计算公式
// BAUD_E=Baud rate exponent value 指数值 BAUD_E[4:0]在U0/1GCR寄存器中
// BAUD_M=Baud rate mantissa value 尾数值 BAUD_M[7:0]在U0/1BAUD寄存器中

#define BAUD_E(baud, clkDivPow) // The macros in this section simplify UART operation.
     (     \                           //此处为多级条件运算
    (baud==2400)   ? 6 +clkDivPow : \ //表达式1？表达式2：表达式3
    (baud==4800)   ? 7 +clkDivPow : \ //1真为2；1假为3
    (baud==9600)   ? 8 +clkDivPow : \
    (baud==14400) ? 8 +clkDivPow : \
    (baud==19200) ? 9 +clkDivPow : \
    (baud==28800) ? 9 +clkDivPow : \
    (baud==38400) ? 10 +clkDivPow : \
    (baud==57600) ? 10 +clkDivPow : \
    (baud==76800) ? 11 +clkDivPow : \
    (baud==115200) ? 11 +clkDivPow : \
    (baud==153600) ? 12 +clkDivPow : \
    (baud==230400) ? 12 +clkDivPow : \
    (baud==307200) ? 13 +clkDivPow : \
    0 )

#define BAUD_M(baud) (      \
    (baud==2400)   ? 59 : \
    (baud==4800)   ? 59 : \
    (baud==9600)   ? 59 : \
    (baud==14400) ? 216 : \
    (baud==19200) ? 59 : \
    (baud==28800) ? 216 : \
    (baud==38400) ? 59 : \
    (baud==57600) ? 216 : \
    (baud==76800) ? 59 : \
    (baud==115200) ? 216 : \
    (baud==153600) ? 59 : \
    (baud==230400) ? 216 : \
    (baud==307200) ? 59 : \
0)
//以上宏定义的函数：UART_SETUP(uart, baudRate, options) 设置波特率
//                  SET_MAIN_CLOCK_SOURCE(source)   设置主时钟
//                  BAUD_E(baud, clkDivPow)    设置波特率的指数值
//                  BAUD_M(baud)    设置波特率的尾数值

#define XOSC_STABLE (SLEEP & 0x40) //XOSC is powered up and stable
#define TICKSPD ((CLKCON & 0x38) >> 3)
#define HIGH_FREQUENCY_RC_OSC_STABLE    (SLEEP & 0x20) //HF RCOSC is powered up and stable

void ChangUartBaund(uchar temp);
void initUART(void);
void SET_UART0_ISR(void);

//*****************************************************************************
//串口初始化函数
//串口参数设置为57600，8,None,1,None
//打开串口，允许接收
//*****************************************************************************
void initUART(void)
{
   IO_PER_LOC_UART0_AT_PORT0_PIN2345(); //reste 0:USART0 I/O location: Alternative 1 location
   SET_MAIN_CLOCK_SOURCE(CRYSTAL); //主时钟时钟源设置函数（设置成晶体振荡器）
   UART_SETUP(0, 9600, HIGH_STOP); //波特率设置函数（将波特率设置成9600）
   U0CSR = 0xC5; //U0CSR（USART0控制和状态）
      //1100 0101 ;UART mode; receiver enable; received byte ready; USART busy in transmit
      // or receive mode;
}

//------------------------------------------------------------------------
//describe:chang baund
//return:
//in:
//------------------------------------------------------------------------
void ChangUartBaund(uchar temp)
{
switch(temp)
{
case '0':UART_SETUP(0, 2400, HIGH_STOP);break;
case '1':UART_SETUP(0, 4800, HIGH_STOP);break;
case '2':UART_SETUP(0, 9600, HIGH_STOP);break;
case '3':UART_SETUP(0, 14400, HIGH_STOP);break;
case '4':UART_SETUP(0, 19200, HIGH_STOP);break;
case '5':UART_SETUP(0, 28800, HIGH_STOP);break;
case '6':UART_SETUP(0, 38400, HIGH_STOP);break;
case '7':UART_SETUP(0, 57600, HIGH_STOP);break;
case '8':UART_SETUP(0, 76800, HIGH_STOP);break;
case '9':UART_SETUP(0, 115200, HIGH_STOP);break;
default: UART_SETUP(0, 9600, HIGH_STOP);break;
}
}
//example 9600;
//------------------------------------------------------------------------
//describe:open the uart isr(中断服务程序)
//return:
//in:
//本例串口接收程序是运用中断来完成的，所以首先要设置ISR
//------------------------------------------------------------------------
void SET_UART0_ISR(void) //串口接收设置函数
{
U0CSR |= 0xd0; //1101 0000；UART mode; receiver enable; Byte received with incorrect stop bit level
U0UCR |= 0x02; //UART stop bit level: High stop bit
}

void UARTxISRopen(void) //开串口接收中断函数
{
U0CSR |= 0x40; //receiver enable;
IEN0 |= 0X04; //开串口接收中断 'URX0IE = 1',
}

#pragma vector = URX0_VECTOR
__interrupt void URX0_ISR(void)
{

    uarttemp = U0DBUF; //串口调试软件发送的数据给uarttemp
    U0DBUF = uarttemp; //把接收到的数据返送串口软件显示
}

//---------------------------------------------------------------------------------

以上为无线龙04协议栈串口实验程序，注释部分为个人理解，有错误还请高手指点。

下面记录下实验情况：

用的是USB-232串口，驱动程序为CH341SER。发现占用的老是电脑的com15口，而我用的串口精灵只能支持com1~com4；最后下载了AccessPort1.33这款功能强大的串口调试软件。支持com1~com255（这让我联想到了一个节点支持EP0～EP255，某种意义上加深了理解吧！）。软件使用方法可参见网址：http://www.sudt.com/cn/ap/help/

串口连接如下：

串口设置如下：

对应我的PC端口如下：

烧入程序完成，串口设置完成，实验现象如下：

（1）串口调试软件发送字符串”“hello word!“；CC2430接收到后返回其显示：

（2）串口调试软件发送十六进制数”FF 45 F0 D6“，CC2430接收到后返回其显示：

当我屏弊语句：

//U0DBUF = uarttemp; //把接收到的数据返送串口软件显示

实验现象如下：

（1）串口调试软件发送字符串”“hello word!“；CC2430接收到后不返回其显示：

（2）串口调试软件发送十六进制数“E4 52 FF 52”，CC2430接收到后不返回其显示：

以上就是串口通信实验的现象。为了能看到CC2430接收到的数据是不是PC机串口调试软件发送出去的数据，进一步验证实验，我准备把发送的16进制数送到LED上去显示；一开始LED亮灭总是跟自己在串口通信软件上发送的16进制数不符，后来发现是CC2430板和扩展板上LED对应的P1口我记错了，并不是资料上所注明的。于是重新烧入第一个LED实验的程序进行检验，具体参见第一个实验的记录。我的套件各LED对应的P口如下：

因而PC机串口调试软件发送的数据与 LED亮灭及颜色对应关系如下：

0XFE P1.0亮红黄

0XFD P1.1亮绿红

0XFB P1.2亮黄

（当然，高5位可以随意，因为用不到）

下面进行程序的修改：

我在main.c函数中加入

P1SEL = 0x00; //P1口为普通I/O口

P1DIR = 0xff; //P1口为输出口

并在中断函数中加入P1=uarttemp;如下：

#pragma vector = URX0_VECTOR

__interrupt void URX0_ISR(void)

{

uarttemp = U0DBUF; //串口软件发送的数据给uarttemp

P1=uarttemp; //送到P1口去显示

U0DBUF = uarttemp; //把接收到的数据返送串口软件显示

}

烧入程序，实验现象如下：

（1）串口调试软件发送十六进制数“0XFE”，P1.0亮，对应灯颜色红黄

（1）串口调试软件发送十六进制数“0XFD”，P1.1亮，对应灯颜色绿红

（1）串口调试软件发送十六进制数“0XFB”，P1.2亮，对应灯颜色黄

以上表明了：从PC机串口调试软件发送的数据与 CC2430接收到的数据相符合与返回到PC机串口调试软件显示的数据相符合。

说明：

本文作者所记录，错误处还请高手指点，本人随时更新，转载请注明出处。谢谢！

串口通信程序的注释为我个人理解，还有许多地方很模糊，不可避免会有错误，希望能给予指出，在此谢过先！

本文链接