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
____________________________________________________________________________________
The fish are biting.
Get more visitors on your site using Yahoo! Search Marketing.
http://searchmarketing.yahoo.com/arp/sponsoredsearch_v2.php_______________________________________________
Tinyos-help mailing list
[email protected]
https://mail.millennium.berkeley.edu/cgi-bin/mailman/listinfo/tinyos-help
