点对点通信实验

源码
/*----代码截取于RadioCountToLeds/RadioCountToLedsAppC.nc-----*/  
   
configuration RadioCountToLedsAppC { }  
  
implementation {  
      
    //组件定义    
    components MainC, RadioCountToLedsC as App, LedsC;     
    components new AMSenderC(AM_RADIO_COUNT_MSG);  
    components new AMReceiverC(AM_RADIO_COUNT_MSG);  
    components new TimerMilliC();  
    components ActiveMessageC;  
      
    // 组件关系连接   
    App.Boot -> MainC.Boot;      
    App.Receive -> AMReceiverC;  
    App.AMSend -> AMSenderC;  
    App.AMControl -> ActiveMessageC;  
    App.Leds -> LedsC;  
    App.MilliTimer -> TimerMilliC;  
    App.Packet -> AMSenderC;  
}   
    

源码
/*----代码截取于RadioCountToLeds/RadioCountToLedsC.nc-----*/  
  
#include "Timer.h"  
#include "RadioCountToLeds.h"  
module RadioCountToLedsC @safe() {  
    uses {    
        //接口使用声明：在该代码块中，我们可以看到组件RadioCountToLedsC使用的接口  
        interface Leds;  
        interface Boot;  
        interface Receive;  
        interface AMSend;  
        interface Timer< TMilli> as MilliTimer;  
        interface SplitControl as AMControl;  
        interface Packet;  
    }  
}  
implementation {  
    message_t packet    //Message_t类型，详见下面解说  
    bool locked;  
    uint16_t counter = 0;  
      
    event void Boot.booted() {  
        call AMControl.start();   
        //AMControl这个接口作为控制CC2420模块启动和关闭，在下面网络协议中，我们经常会使用该接口。  
    }  
          
    //在CC2420启动完毕后，TinyOS会触发AMControl.startDone事件，该事件表示CC2420启动完毕，  
    //在程序里面我们在CC2420模块启动成功后，开启250ms的定时器，同样该定时器也以事件的形式告知。  
    event void AMControl.startDone(error_t err) {  
        if (err == SUCCESS) {  
            call MilliTimer.startPeriodic(250);  
        }  
        else {  
            call AMControl.start();  
        }  
    }  
           
    event void AMControl.stopDone(error_t err) {  
        // do nothing  
    }   
        
    event void MilliTimer.fired() {  
        counter++;  
        if (locked) { return; }  
        else {  
            radio_count_msg_t* rcm = (radio_count_msg_t*)call Packet.getPayload(&packet,   
                sizeof(radio_count_msg_t));  
            if (rcm == NULL) { return; }  
            rcm->counter = counter;  
            //发包的关键代码  
            if (call AMSend.send(AM_BROADCAST_ADDR, &packet,   
                sizeof(radio_count_msg_t)) == SUCCESS) {  
                dbg("RadioCountToLedsC", "RadioCountToLedsC: packet sent.\n", counter);   
                locked = TRUE;  
            }  
        }  
    }  
            
    //Receive事件，一旦CC2420接收到发送给自己的数据包的时候，就会触发该事件。  
    //通过解析数据包中counter位并使用板载的Led显示。  
    event message_t* Receive.receive(message_t* bufPtr, void* payload, uint8_t len) {  
        dbg("RadioCountToLedsC", "Received packet of length %hhu.\n", len);  
        if (len != sizeof(radio_count_msg_t)) {return bufPtr;}  
        else {  
            radio_count_msg_t* rcm = (radio_count_msg_t*)payload;  
            if (rcm->counter & 0x1) {  
                call Leds.led0On();  
            }  
            else {  
                call Leds.led0Off();  
            }  
            if (rcm->counter & 0x2) {  
                call Leds.led1On();  
            }  
            else {  
                call Leds.led1Off();  
            }  
            if (rcm->counter & 0x4) {  
                call Leds.led2On();  
            }  
            else {  
                call Leds.led2Off();  
            }  
            return bufPtr;  
        }  
    }   
      
    event void AMSend.sendDone(message_t* bufPtr, error_t error) {  
        if (&packet == bufPtr) { locked = FALSE; }  
    }   
}  
    

源码
/*----代码截取于RadioCountToLeds/RadioCountToLeds.h-----*/  
   
typedef nx_struct message_t {  
    nx_uint8_t header[sizeof(message_header_t)];  
    nx_uint8_t data[TOSH_DATA_LENGTH];  
    nx_uint8_t footer[sizeof(message_footer_t)];  
    nx_uint8_t metadata[sizeof(message_metadata_t)];  
} message_t;  
  

//Makefile
COMPONENT=RadioCountToLedsAppC
CFLAGS += -DCC2420_DEF_CHANNEL=14
include $(MAKERULES)

//RadioCountToLeds.h

#ifndef RADIO_COUNT_TO_LEDS_H
#define RADIO_COUNT_TO_LEDS_H

typedef nx_struct radio_count_msg {
  nx_uint16_t counter;
} radio_count_msg_t;

enum {
  AM_RADIO_COUNT_MSG = 6,
};

#endif