[Tinyos-help] Set RFPower from TestSerial.java

[Modi, Jenis]

Hi Guys, 

I am trying to set RF power from TestSerial.java, but I don't see the output as 
expected.  I run below command to run my code:

make telosb install.1 bsl,/dev/ttyUSB0
java TestSerial -comm serial@/dev/ttyUSB0:telos 1  (Here 1 refers to RF power I 
am passing)


Instead of getting actual RF power, I receive RF power 0 everytime. I receive 
below output when I run above commands: 
Sending packet 1
Received packet power: 0
Received packet sequence number 8
Sending packet 2
Received packet power: 0
Received packet sequence number 9
Sending packet 3
Received packet power: 0
Received packet sequence number 10
Sending packet 4
Received packet power: 0
Received packet sequence number 11


Could anyone tell me what am I doing wrong here? Plz help. 

Here is my code: 

TestSerial.java :

public class TestSerial implements MessageListener {

  private MoteIF moteIF;
  
  public TestSerial(MoteIF moteIF) {
    this.moteIF = moteIF;
    this.moteIF.registerListener(new TestSerialMsg(), this);
  }

  public void sendPackets(String rf_power) {
    int counter = 1;
    int rfpower = Integer.parseInt(rf_power);
    TestSerialMsg payload = new TestSerialMsg();
    
    try {
        payload.set_rfpower(rfpower);
      while (true) {
        System.out.println("Sending packet " + counter);

        payload.set_counter(counter);
        moteIF.send(0, payload);
        counter++;
        try {Thread.sleep(1000);}
        catch (InterruptedException exception) {}
      }
    }
    catch (IOException exception) {
      System.err.println("Exception thrown when sending packets. Exiting.");
      System.err.println(exception);
    }
  }

  public void messageReceived(int to, Message message) {
    TestSerialMsg msg = (TestSerialMsg)message;
    System.out.println("Received packet power: "+msg.get_rfpower());
    System.out.println("Received packet sequence number " + msg.get_counter());
  }
  
  private static void usage() {
    System.err.println("usage: TestSerial [-comm <source>]");
  }
  
  public static void main(String[] args) throws Exception {

    String source = null;
    String rf_power = null;
    if (args.length == 3) {
      if (!args[0].equals("-comm")) {
        usage();
        System.exit(1);
      }
      source = args[1];
      rf_power= args[2];
    }
    else if (args.length != 0) {
      usage();
      System.exit(1);
    }
    System.out.println("trying to set RFpower from here");
    System.out.println("RfPower:"+args[2]);
    PhoenixSource phoenix;
    
    if (source == null) {
      phoenix = BuildSource.makePhoenix(PrintStreamMessenger.err);
    }
    else {
      phoenix = BuildSource.makePhoenix(source, PrintStreamMessenger.err);
    }

    MoteIF mif = new MoteIF(phoenix);
    TestSerial serial = new TestSerial(mif);
    serial.sendPackets(rf_power);
  }


}

TestSerialC.nc

#include "Timer.h"
#include "TestSerial.h"

module TestSerialC {
  uses {
    interface SplitControl as Control;
    interface Leds;
    interface Boot;
    interface Receive;
    interface AMSend;
    interface Timer<TMilli> as MilliTimer;
    interface Packet;
    interface CC2420Packet;
  }
}
implementation {

  message_t packet;

  bool locked = FALSE;
  uint16_t counter = 0;
//  uint8_t TRANS_POWER = 1;
  
  event void Boot.booted() {
    call Control.start();
  }
  
  event void MilliTimer.fired() {
    counter++;
    if (locked) {
      return;
    }
    else {
      test_serial_msg_t* rcm = (test_serial_msg_t*)call 
Packet.getPayload(&packet, sizeof(test_serial_msg_t));
      if (rcm == NULL) {return;}
      if (call Packet.maxPayloadLength() < sizeof(test_serial_msg_t)) {
        return;
      }

      rcm->counter = counter;
      call CC2420Packet.setPower(&packet,rcm->rfpower);
      if (call AMSend.send(AM_BROADCAST_ADDR, &packet, 
sizeof(test_serial_msg_t)) == SUCCESS) {
        locked = TRUE;
      }
    }
  }

  event message_t* Receive.receive(message_t* bufPtr, 
                                   void* payload, uint8_t len) {
    if (len != sizeof(test_serial_msg_t)) {return bufPtr;}
    else {
      test_serial_msg_t* rcm = (test_serial_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;
    }
  }

  event void Control.startDone(error_t err) {
    if (err == SUCCESS) {
      call MilliTimer.startPeriodic(1000);
    }
  }
  event void Control.stopDone(error_t err) {}
}


TestSerialAppC.nc

#include "TestSerial.h"

configuration TestSerialAppC {}
implementation {
  components TestSerialC as App, LedsC, MainC;
  components SerialActiveMessageC as AM;
  components new TimerMilliC();
  components CC2420ActiveMessageC;

  App.Boot -> MainC.Boot;
  App.Control -> AM;
  App.Receive -> AM.Receive[AM_TEST_SERIAL_MSG];
  App.AMSend -> AM.AMSend[AM_TEST_SERIAL_MSG];
  App.Leds -> LedsC;
  App -> CC2420ActiveMessageC.CC2420Packet;
  App.MilliTimer -> TimerMilliC;
  App.Packet -> AM;
}
 
TestSerial.h

#ifndef TEST_SERIAL_H
#define TEST_SERIAL_H

typedef nx_struct test_serial_msg {
  nx_uint16_t counter;
  nx_uint16_t rfpower;
} test_serial_msg_t;

enum {
  AM_TEST_SERIAL_MSG = 0x89,
};

#endif


Thanks.
Jenis

_______________________________________________
Tinyos-help mailing list
Tinyos-help@millennium.berkeley.edu
https://www.millennium.berkeley.edu/cgi-bin/mailman/listinfo/tinyos-help