It wasn't me asking about the previous Timer questions. Many thanks for your
hints. Will try and get back soon.

Ittipong

2009/4/21 Michael Schippling <[email protected]>

> I guess this is what you were trying to get at in previous
> Timer questions, right?
>
> It looks like it should work the way you want. The only thing
> I can see that is questionable is the long atomic {block} for
> your message sending in DataSendTimer.fired(). This might
> block interrupts for too long.
>
> I would try to simplify the Timer scheme on it's own, flashing
> LEDs or something to see if it works the way you expect, and then
> start adding the radio message drivers back in.
>
> I think you should also be able to use the receive() method instead
> of starting your first timer, because it is called after the message
> is fully received.
>
> MS
>
> Ittipong Khemapech wrote:
>
>> Hi,
>>
>> I have been trying to figure the problems out for days. No idea what
>> causes it.
>>
>> I have a source receiving a packet from the base station. After the SFD is
>> received, a timer is called to run to make sure that the reception is
>> completed. The source waits for a wait_interval duration to send its data
>> packet. So, another timer is used for timing the transmission.
>>
>> I am using AlarmToTimer component. The command startOneShot is called.
>> What I expect is that the source should send *only after* it receives the
>> packet from base station. It seems to me that the source keeps sending.
>>
>> Look forward to hear from you soon.
>>
>> Thanks,
>> Ittipong
>>
>> The codes are as follows:
>>
>> MyDef.h
>>
>> ---------------------------------------------------------------------------------------------------
>>
>> #ifndef MYDEF_H_
>> #define MYDEF_H_
>>
>> enum {
>>   WAIT_TO_RECEIVE = 1024
>> };
>>
>> #endif
>> ==================================================
>>
>> SourceAppC.nc
>>
>> ----------------------------------------------------------------------------------------------------
>>
>> #include "MyDef.h"                   #include "DataMsg.h"
>> #include "ControlMsg.h"
>>
>> configuration SourceAppC {
>> }
>> implementation {
>>   components MainC;
>>   components ActiveMessageC;
>>
>>   components new AMSenderC(AM_DATAMSG) as AMSenderDataC;
>>   components new AMReceiverC(AM_CONTROLMSG) as AMReceiverCtrlC;
>>
>>   components new Alarm32khz32C() as Alarm2Timer;
>>   components new AlarmToTimerC(T32khz) as W2RTimer;             components
>> new AlarmToTimerC(T32khz) as SendTimer;
>>
>>   components CC2420TransmitC;
>>   components CC2420ActiveMessageC;
>>
>>   components SourceC as App;
>>
>>   // Wiring
>>   App.Boot -> MainC;
>>
>>   App.Packet -> AMSenderDataC;
>>   App.AMPacket -> AMSenderDataC;
>>   App.AMSend -> AMSenderDataC;
>>   App.Receive -> AMReceiverCtrlC;
>>
>>   App.AMControl -> ActiveMessageC;;
>>
>>   App.InitW2RTimer -> W2RTimer;     App.DataSendTimer -> SendTimer;
>>     W2RTimer.Alarm -> Alarm2Timer;
>>   SendTimer.Alarm -> Alarm2Timer;
>>                 App.CC2420Packet -> CC2420ActiveMessageC;
>>   App.RadioTimeStamping -> CC2420TransmitC;
>>   App.CC2420Transmit -> CC2420TransmitC;
>>     }
>> =====================================================
>>
>> SourceC.nc
>>
>> ----------------------------------------------------------------------------------------------------------
>>
>> #include <Timer.h>
>> #include "MyDef.h"                   #include "DataMsg.h"
>> #include "ControlMsg.h"
>>
>> module SourceC {
>>   uses {
>>       interface Boot;
>>       interface AMSend;
>>       interface Receive;                         interface AMPacket;
>>       interface Packet;
>>       interface Timer<T32khz> as InitW2RTimer;
>>       interface Timer<T32khz> as DataSendTimer;
>>       interface RadioTimeStamping;             interface SplitControl as
>> AMControl;
>>       interface CC2420Packet;                         interface
>> CC2420Transmit;
>>   }
>> }
>> implementation {
>>   message_t dpkt, cpkt;
>>   bool sending = FALSE;
>>   uint16_t pktseq, sentpkts;                 uint8_t current_tx;
>>                                                       uint8_t base_addr, me;
>>   uint32_t no_slot, slot_length, slot_start;         uint32_t
>> wait_interval;
>>
>>   uint16_t rcv_no;
>>
>>   task void callInitW2RTimer() {
>>       call InitW2RTimer.startOneShot(WAIT_TO_RECEIVE);
>>   }
>>
>>   task void callDataSendTimer() {
>>       call DataSendTimer.startOneShot(wait_interval);
>>   }
>>
>>   event void Boot.booted() {
>>       call AMControl.start();
>>   }
>>
>>   event void AMControl.startDone(error_t err) {
>>       if (err != SUCCESS) {
>>           call AMControl.start();
>>       }
>>   }
>>
>>   event void AMControl.stopDone(error_t err) {
>>   }
>>
>>   event void InitW2RTimer.fired() {
>>       post callDataSendTimer();
>>   }
>>   event void DataSendTimer.fired() {
>>
>>       if (!sending) {
>>           atomic {
>>
>>               DataMsg* dataMsg = (DataMsg*)(call Packet.getPayload(&dpkt,
>> NULL));
>>
>>               sentpkts++;
>>               pktseq++;
>>
>>               call CC2420Packet.setPower(&dpkt, MAX_TX);
>> current_tx = call CC2420Packet.getPower(&dpkt);
>>               dataMsg->pkt_type = 1;
>>               dataMsg->source_id = me;
>>               dataMsg->rcv_no = rcv_no;
>>
>>               dataMsg->tx_power = current_tx;
>>               dataMsg->snt_no = sentpkts;
>>               dataMsg->seq_no = pktseq;
>>               dataMsg->slot = no_slot;
>>               dataMsg->length = slot_length;
>>               dataMsg->start = slot_start;
>>               dataMsg->wait = wait_interval;
>>
>>               if (call AMSend.send(base_addr, &dpkt, sizeof(DataMsg)) ==
>> SUCCESS) {
>>                   sending = TRUE;                     }
>>           }
>>       }
>>
>>   }
>>   event void AMSend.sendDone(message_t *msg, error_t error) {
>>       if (&dpkt == msg) {
>>           atomic {
>>               sending = FALSE;
>>           }             }
>>   }
>>   event message_t* Receive.receive(message_t* msg, void* payload, uint8_t
>> len) {
>>
>>       if (len == sizeof(ControlMsg)) {
>>           atomic {
>>                 ControlMsg* controlMsg = (ControlMsg*) payload;
>>
>>               base_addr = controlMsg->base_id;
>>               me = TOS_NODE_ID;
>>
>>               rcv_no = controlMsg->snt_no;
>>
>>               no_slot = controlMsg->no_alloc_slot;
>>               slot_length = controlMsg->slot_length;
>>               slot_start = controlMsg->slot_start;
>>
>>               wait_interval = (uint32_t) (((me - 1) * slot_length) +
>> slot_start);
>>
>>           }
>>       }
>>       return msg;
>>   }
>>
>>
>>   async event void RadioTimeStamping.transmittedSFD(uint16_t time,
>> message_t* p_msg) {
>>   }
>>
>>   async event void RadioTimeStamping.receivedSFD(uint16_t time) {
>>       post callInitW2RTimer();           }
>>
>>   async event void CC2420Transmit.sendDone(message_t* p_msg, error_t
>> error) {
>>   }
>>
>> }
>> ====================================================================
>>
>>
>>
>>
>> ------------------------------------------------------------------------
>>
>> _______________________________________________
>> Tinyos-help mailing list
>> [email protected]
>> https://www.millennium.berkeley.edu/cgi-bin/mailman/listinfo/tinyos-help
>>
>
_______________________________________________
Tinyos-help mailing list
[email protected]
https://www.millennium.berkeley.edu/cgi-bin/mailman/listinfo/tinyos-help

Reply via email to