Hi Bandara,
I'm always a bit hesitant when people say that one part of their program
must be correct because of whatever reason. If what you're saying is
correct then the only difference between the two testing programs would
be that the program that doesn't wait for the confirmation just jumps to
the sending part. If this is what you think you indeed did, then the
problem must be somewhere in this difference. Why don't you modify your
program such that you only have to exchange two lines of code (comment
one, uncomment the other) to switch between the two behaviours? It
should look something like (this is not real code!):
void SensorReadingDone() {
num++;
if(num >= 16 && bcastNotStarted) {
bcastNotStarted = FALSE;
// post startBcastingResults();
post requestConfirmation();
}
}
void Confirmation.receive(..) {
post startBcastingResults();
}
task void startBcastingResults() {
readEEProm();
sendBcastWithResutls();
}
void Bcast.sendDone() {
num--;
if(num > 0) {
post startBcastingResults();
} else {
bcastNotStarted = TRUE;
}
}
You could even potentially add a delay (with a timer) to ensure that
nothing changes during the brief delay while waiting for the confirmation.
There is a bug in some versions of TinyOS (I didn't check whether this
is fixed now) where reading from the EEPROM did not result in an error
when reaching the end of the data. Instead the buffer simply wasn't
altered. With the above approach you ensure that both scenarios really
are equivalent.
***
I also see a potential concurrency problem with your code. In
LoggerRead.readDone() you start sending and also start reading from the
EEPROM before the send is completed. Theoretically it could be possible
that the read would be done before the send is done. You would then
loose one (or more) reading. However I don't think this explains your
observation.
Cheers,
Urs
Thusitha Bandara schrieb:
> Hi Hunkeler,
>
> Yes. Your understanding is correct. This is a part of the protocol which
> i am going to implement. So it needs to communicate with the Base Station,
> before it broadcast its packets. So in my application:
>
> * First Sense the Sensor Data and store them in the EEPROM as a Packet.
> * When it over the Sensing (Say 16 Time), It broadcast a request Message
> to ask for its data Transfer.
> * When the base Station confirms the request, it broadcast the
> confirmation.
> * When the Mote recieve the confirmation: It should send all its stored
> data continuously.
> * But the problem is that it just send the first data packet always. Like:
>
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> ........................................................................
> But i want it to send the data packets one by one in its EEPROM. Like:
>
> FF FF 09 7D 12 01 00 F5 03 F4 03 F7 03 EE 03 F0 03 EC 03 E9 03 F2 03
> FF FF 09 7D 12 01 00 E0 03 E4 03 E6 03 E6 03 F5 03 E7 03 EE 03 E7 03
> FF FF 09 7D 12 01 00 EE 03 ED 03 ED 03 ED 03 EC 03 EC 03 EC 03 E8 03
> FF FF 09 7D 12 01 00 ED 03 F0 03 E9 03 E7 03 E6 03 E2 03 DD 03 D9 03
> FF FF 09 7D 12 01 00 69 03 63 03 52 03 49 03 3A 03 34 03 33 03 24 03
> FF FF 09 7D 12 01 00 DE 02 DF 02 D4 02 2F 03 21 03 23 03 05 03 08 03
> FF FF 09 7D 12 01 00 ED 03 EB 03 EB 03 EA 03 C7 03 C1 03 E6 03 E9 03
> FF FF 09 7D 12 01 00 CB 12 83 42 69 21 9A 50 04 27 00 92 10 06 03 82
>
> The following Code does the above communication scenario and attempt to send
> the stored data.
>
> * I can sure that my module correctly write to the EEPROM. Because it
> reads correctly, when i programm this application to execute without that
> request-confirmation thing.
>
> 1) So can you please analyse this code and say, what would be the problem??
> or
> 2) Is there any special procedure to follow when we want to make EEPROM READ
> Continuously?
> or
> 3) Is there any special procedure to follow when we want to broadcast several
> packets continuously in a short interval of time??
>
> I really need yours help.
> Please help me to resolve them.
>
> Regards,
> Bandara.
>
>
> // $Id: SimpleCmdM.nc,v 1.2 2003/10/07 21:44:59 idgay Exp $
> includes SimpleCmdMsg;
> module SimpleCmdM {
> provides {
> interface StdControl;
> interface ProcessCmd;
> interface Reading;
> }
> uses {
> interface Leds;
> interface ReceiveMsg as ReceiveCmdMsg;
> interface StdControl as CommControl;
> interface StdControl as RequestCommControl;
> interface StdControl as SounderControl;
> interface LoggerRead;
> interface SendMsg as SendLogMsg;
> interface ReceiveMsg as RequestReceiveMsg;
> interface SendMsg as RequestSendMsg;
> interface Sensing;
> }
> }
> implementation
> {
> // declare module static variables here
> TOS_MsgPtr cur_msg; // The current command message
> TOS_Msg log_msg , request_msg; // The current log message
> bool send_pending; // TRUE if a message send is pending
> bool eeprom_read_pending; // TRUE if an EEPROM read is pending
> TOS_Msg buf; // Free buffer for message reception
> uint16_t num;
> bool request_send_pending;
>
> task void cmdInterpret() {
> result_t status = SUCCESS;
> if(!eeprom_read_pending){
> if (call LoggerRead.readNext(((struct LogMsg *)log_msg.data)->log)) {
> call Leds.yellowOn();
> eeprom_read_pending = TRUE;
> }
> }
>
> signal ProcessCmd.done(cur_msg, status);
> }
>
> task void cmdInterpretRepeat() {
> if(!eeprom_read_pending){
> call SounderControl.start();
> if (call LoggerRead.readNext(((struct LogMsg *)log_msg.data)->log)) {
> eeprom_read_pending = TRUE;
> }
> }
> }
>
> task void RequestConfirm()
> {
> struct RequestMsg *request = (struct RequestMsg * )request_msg.data;
> result_t status = FAIL;
> if(!request_send_pending)
> {
> /**
> uint16_t sourceMoteID; uint8_t type; uint8_t sendDone;
> uint16_t packetNumber; uint8_t noOfPackets; uint16_t npackets;
> uint16_t token; uint8_t confirm; uint8_t channel;
> **/
> atomic{
> request->sourceMoteID = TOS_LOCAL_ADDRESS;
> }
> request->type = 0;
> request->sendDone = 0;
> request->packetNumber = 0;
> request->noOfPackets = 0;
> request->npackets = 0;
> request->token = 0;
> request->confirm = 0;
> request->channel = 0;
> if(call RequestSendMsg.send(TOS_BCAST_ADDR , (sizeof(struct RequestMsg)) ,
> &request_msg))
> {
> request_send_pending = TRUE;
> status = SUCCESS;
> }
> }
> }
>
>
> command result_t StdControl.init() {
> cur_msg = &buf;
> send_pending = FALSE;
> eeprom_read_pending = FALSE;
> request_send_pending = FALSE;
> num = 30;
> return rcombine(call CommControl.init(), call Leds.init());
> }
> command result_t StdControl.start(){
> call Sensing.start(256, 500);
> return SUCCESS;
> }
> command result_t StdControl.stop(){
> return SUCCESS;
> }
>
> command result_t ProcessCmd.execute(TOS_MsgPtr pmsg) {
> signal Reading.done();
> post cmdInterpret();
> return SUCCESS;
> }
>
> command result_t Reading.start(){
> TOS_MsgPtr pmsg;
> result_t retval;
> retval = call ProcessCmd.execute(pmsg);
> if (retval==SUCCESS) {
> return retval;
> }
> return SUCCESS;
> }
>
>
> event result_t LoggerRead.readDone(uint8_t * packet, result_t success) {
> result_t retval;
> // Send message only if read was successful
> struct LogMsg *lm;
> num--;
> if (success && eeprom_read_pending && !send_pending) {
> lm = (struct LogMsg *)(log_msg.data);
> lm->sourceaddr = TOS_LOCAL_ADDRESS;
> eeprom_read_pending = FALSE;
> if (call SendLogMsg.send(TOS_BCAST_ADDR, sizeof(struct LogMsg), &log_msg)) {
> call Leds.redOn();
> send_pending = TRUE;
> if(num>0){
> call Reading.start();
> }
> }
> }
> eeprom_read_pending = FALSE;
> call Leds.yellowOff();
> return SUCCESS;
> }
>
> event TOS_MsgPtr ReceiveCmdMsg.receive(TOS_MsgPtr pmsg){
> result_t retval;
> TOS_MsgPtr ret = cur_msg;
> call Leds.greenToggle();
> retval = call ProcessCmd.execute(pmsg);
> if (retval==SUCCESS) {
> return ret;
> } else {
> return pmsg;
> }
> }
>
> event TOS_MsgPtr RequestReceiveMsg.receive(TOS_MsgPtr pmsg){
> struct RequestMsg *rmsg=(struct RequestMsg *)pmsg->data;
>
> if(rmsg->confirm == TOS_LOCAL_ADDRESS)
> {
> //call ProcessRead.readEEPROM(no_of_packets_to_read);
> call Reading.start();
> }
> return pmsg;
> }
>
> event result_t SendLogMsg.sendDone(TOS_MsgPtr pmsg, result_t status) {
> send_pending = FALSE;
> //call Reading.start();
> return SUCCESS;
> }
> event result_t RequestSendMsg.sendDone(TOS_MsgPtr pmsg, result_t status) {
> request_send_pending = FALSE;
> return SUCCESS;
> }
>
> default event result_t ProcessCmd.done(TOS_MsgPtr pmsg, result_t status) {
> return status;
> }
> default event result_t Reading.done() {
> return SUCCESS;
> }
> event result_t Sensing.done() {
> post RequestConfirm();
>
> return SUCCESS;
> }
>
>
> } // end of implementation
_______________________________________________
Tinyos-help mailing list
[email protected]
https://mail.millennium.berkeley.edu/cgi-bin/mailman/listinfo/tinyos-help
