SimpliciTi 1.0.6 EZ430-RF2500 Timer

Hey guys

I have tried everything that is possible but still my system doesnt work,I am using simpliciti 1.0.6 with IAR for EZ430-RF2500.

I think its Timing problem because My AP can not see other EDs and vice versa.

AP:

#include <string.h>
#include "bsp.h"
#include "mrfi.h"
#include "bsp_leds.h"
#include "bsp_buttons.h"
#include "nwk_types.h"
#include "nwk_api.h"
#include "nwk_frame.h"
#include "nwk.h"

#include "aleged_io.h"
#include "aleged_init.h"
//#include "aleged_console.h"

#include "app_remap_led.h"

#define MESSAGE_LENGTH 3

/* reserve space for the maximum possible peer Link IDs */
static linkID_t sLID[NUM_CONNECTIONS];
static uint8_t  sNumCurrentPeers;

/* callback handler */
static uint8_t sCB(linkID_t);

/* work loop semaphores */
static volatile uint8_t sPeerFrameSem;
static volatile uint8_t sSelfMeasureSem;
static volatile uint8_t sJoinSem;

static void   processMessage(linkID_t, uint8_t *, uint8_t);
void createRandomAddress(void);


/* blink LEDs when channel changes... */
volatile static uint8_t sBlinky;

void TXString( char* string, int length );
void transmitDataString(char addr[4],char rssi[3], char msg[MESSAGE_LENGTH]);       
void transmitData(int addr, signed char rssi,  char msg[MESSAGE_LENGTH] );

__no_init volatile int tempOffset @ 0x10F4; // Temperature offset set at production
__no_init volatile char Flash_Addr[4] @ 0x10F0; // Flash address set randomly

#define SPIN_ABOUT_A_QUARTER_SECOND   NWK_DELAY(250)

void main (void)
{
  addr_t lAddr;
  bspIState_t intState;

  WDTCTL = WDTPW + WDTHOLD;  
 
   __delay_cycles(65000);

  if( CALBC1_8MHZ == 0xFF && CALDCO_8MHZ == 0xFF )// Do not run if cal values
  {
    P1DIR |= 0x03;
    /*LED1 Is RED */
     turnOnLed(RED_LED);
     turnOffLed(GREEN_LED);
    while(1)
    {
      __delay_cycles(65000);
      toggleLED(GREEN_LED);
      toggleLED(RED_LED);
    }
  }
   BSP_Init();
 
  if( Flash_Addr[0] == 0xFF &&
      Flash_Addr[1] == 0xFF &&
      Flash_Addr[2] == 0xFF &&
      Flash_Addr[3] == 0xFF )
    {
      createRandomAddress();                // Create Random device address at
    }                                       // initial startup if missing
  lAddr.addr[0]=Flash_Addr[0];
  lAddr.addr[1]=Flash_Addr[1];
  lAddr.addr[2]=Flash_Addr[2];
  lAddr.addr[3]=Flash_Addr[3];

  SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &lAddr);
 
  initialise_timer();
  initialise_uart();
 
  SMPL_Init(sCB);

  turnOnLed(GREEN_LED);
  turnOnLed(RED_LED);

  /* main work loop */
  while (1)
  {
    /* Wait for the Join semaphore to be set by the receipt of a Join frame from a
     * device that supports an End Device.
     *
     * An external method could be used as well. A button press could be connected
     * to an ISR and the ISR could set a semaphore that is checked by a function
     * call here, or a command shell running in support of a serial connection
     * could set a semaphore that is checked by a function call.
     */
    if (sJoinSem && (sNumCurrentPeers < NUM_CONNECTIONS))
    {
      /* listen for a new connection */
      while (1)
      {
        if (SMPL_SUCCESS == SMPL_LinkListen(&sLID[sNumCurrentPeers]))
        {
          int i=0;
          for(i=0;i<sLID[sNumCurrentPeers];i++)
          {
            ToSerial("\n\rNode Found: ",15);
          intToSerial(sLID[i]);
          }
          break;
        }
        /* Implement fail-to-link policy here. otherwise, listen again. */
      }

      sNumCurrentPeers++;

      BSP_ENTER_CRITICAL_SECTION(intState);
      sJoinSem--;
      BSP_EXIT_CRITICAL_SECTION(intState);
    }
        if(sSelfMeasureSem)
        {
          volatile long temp;
            int i=0;
            int degC, volt;
            int results[2];
            char msg [3];
                    char rssi[]={"000"};
            char Addr[] = {"AP01"};
                               
         
             ADC10CTL1 = INCH_10 + ADC10DIV_4;     // Temp Sensor ADC10CLK/5
              ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE + ADC10SR;
              __delay_cycles(250);                  // delay to allow reference to settle      ADC10CTL0 |= ENC + ADC10SC;           // Sampling and conversion start
            
              ADC10CTL0 |= ENC + ADC10SC;           // Sampling and conversion start
              __bis_SR_register(CPUOFF + GIE);      // LPM0 with interrupts enabled
              results[0] = ADC10MEM;
           
              ADC10CTL0 &= ~ENC;
           
              ADC10CTL1 = INCH_11;                  // AVcc/2
              ADC10CTL0 = SREF_1 + ADC10SHT_2 + REFON + ADC10ON + ADC10IE + REF2_5V;
              __delay_cycles(250);                  // delay to allow reference to settle      ADC10CTL0 |= ENC + ADC10SC;           // Sampling and conversion start
            
              ADC10CTL0 |= ENC + ADC10SC;           // Sampling and conversion start
              __bis_SR_register(CPUOFF + GIE);      // LPM0 with interrupts enabled
              results[1] = ADC10MEM;
              ADC10CTL0 &= ~ENC;
              ADC10CTL0 &= ~(REFON + ADC10ON);      // turn off A/D to save powe
       
            // oC = ((A10/1024)*1500mV)-986mV)*1/3.55mV = A10*423/1024 - 278
            // the temperature is transmitted as an integer where 32.1 = 321
            // hence 4230 instead of 423
            temp = results[0];
            degC = ((temp - 673) * 4230) / 1024;
            if( tempOffset != 0xFFFF )
            {
              degC += tempOffset;
            }
           
            temp = results[1];
            volt = (temp*25)/512;
            msg[0] = degC&0xFF;
            msg[1] = (degC>>8)&0xFF;
            msg[2] = volt;
         
            transmitDataString(Addr ,rssi, msg);
            toggleLED(GREEN_LED);
            sSelfMeasureSem = 0;
           
        }
   
    /* Have we received a frame on one of the ED connections?
     * No critical section -- it doesn't really matter much if we miss a poll
     */
    if (sPeerFrameSem)
    {
      uint8_t     msg[MAX_APP_PAYLOAD], len, i;

      /* process all frames waiting */
      for (i=0; i<sNumCurrentPeers; ++i)
      {
        if (SMPL_SUCCESS == SMPL_Receive(sLID[i], msg, &len))
        {
          //processMessage(sLID[i], msg, len);
          ioctlRadioSiginfo_t sigInfo;
          sigInfo.lid = sLID[i];
          SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SIGINFO, (void *)&sigInfo);
          transmitData( i, (signed char)sigInfo.sigInfo.rssi, (char*)msg );
         
          BSP_ENTER_CRITICAL_SECTION(intState);
          sPeerFrameSem--;
          BSP_EXIT_CRITICAL_SECTION(intState);
        }
      }
    }

  }
}



/* Runs in ISR context. Reading the frame should be done in the */
/* application thread not in the ISR thread. */
static uint8_t sCB(linkID_t lid)
{
  if (lid)
  {
    sPeerFrameSem++;
  }
  else
  {
    sJoinSem++;
  }

  /* leave frame to be read by application. */
  return 0;
}

static void processMessage(linkID_t lid, uint8_t *msg, uint8_t len)
{
  /* do something useful */
  if (len)
  {
    toggleLED(*msg);
    *msg |= NWK_APP_REPLY_BIT;
    /* send ack frame... */
    SMPL_Send(lid, msg, len);
  }
  return;
}

/*******************************************************************************
*BEGHDR
*
*NAME:createRandomAddress()
*
*DESCRIPTION: generate random address
*
*******************************************************************************/
void createRandomAddress(void)
{
  unsigned int rand, rand2;
  char *Flash_Addr;                         // Initialize radio address location
  Flash_Addr = (char *)0x10F0;

  do
  {
    rand = TI_getRandomIntegerFromVLO();    // first byte can not be 0x00 of 0xFF
  }
  while( (rand & 0xFF00)==0xFF00 || (rand & 0xFF00)==0x0000 );
  rand2 = TI_getRandomIntegerFromVLO();

  BCSCTL1 = CALBC1_1MHZ;                    // Set DCO to 1MHz
  DCOCTL = CALDCO_1MHZ;
  FCTL2 = FWKEY + FSSEL0 + FN1;             // MCLK/3 for Flash Timing Generator
  FCTL3 = FWKEY + LOCKA;                    // Clear LOCK & LOCKA bits
  FCTL1 = FWKEY + WRT;                      // Set WRT bit for write operation

  Flash_Addr[0]=(rand>>8) & 0xFF;
  Flash_Addr[1]=rand & 0xFF;
  Flash_Addr[2]=(rand2>>8) & 0xFF;
  Flash_Addr[3]=rand2 & 0xFF;

  FCTL1 = FWKEY;                            // Clear WRT bit
  FCTL3 = FWKEY + LOCKA + LOCK;             // Set LOCK & LOCKA bit
}

void transmitData(int addr, signed char rssi,  char msg[MESSAGE_LENGTH] )
{
  char addrString[4];
  char rssiString[3];
  volatile signed int rssi_int;

  addrString[0] = '0';
  addrString[1] = '0';
  addrString[2] = '0'+(((addr+1)/10)%10);
  addrString[3] = '0'+((addr+1)%10);
  rssi_int = (signed int) rssi;
  rssi_int = rssi_int+128;
  rssi_int = (rssi_int*100)/256;
  rssiString[0] = '0'+(rssi_int%10);
  rssiString[1] = '0'+((rssi_int/10)%10);
  rssiString[2] = '0'+((rssi_int/100)%10);

  transmitDataString( addrString, rssiString, msg );
}
void transmitDataString(char addr[4],char rssi[3], char msg[MESSAGE_LENGTH] )
{ 
  char output[]={"\r\nNode:XXXX,Temp:-XX.XC,Battery:X.XV,Strength:XXX%"};   
 
  char temp_string[] = {" XX.XC"};
  int temp = msg[0] + (msg[1]<<8);
 

  if( temp < 0 )
  {
    temp_string[0] = '-';
    temp = temp * -1;
  }
  else if( ((temp/1000)%10) != 0 )
  {
    temp_string[0] = '0'+((temp/1000)%10);
  }
  temp_string[4] = '0'+(temp%10);
  temp_string[2] = '0'+((temp/10)%10);
  temp_string[1] = '0'+((temp/100)%10);
 
    output[7]  = addr[0];
    output[8]  = addr[1];
    output[9]  = addr[2];
    output[10] = addr[3];
 
    output[17] = temp_string[0];
    output[18] = temp_string[1];
    output[19] = temp_string[2];
    output[20] = temp_string[3];
    output[21] = temp_string[4];
    output[22] = temp_string[5];
   
    output[32] = '0'+(msg[2]/10)%10;
    output[34] = '0'+(msg[2]%10);
   
    output[46] = rssi[2];
    output[47] = rssi[1];
    output[48] = rssi[0];
 
   
    TXString(output, sizeof output );
  }

 
 void TXString( char* string, int length )
{
  int pointer;
  for( pointer = 0; pointer < length; pointer++)
  {
    volatile int i;
    UCA0TXBUF = string[pointer];
    while (!(IFG2&UCA0TXIFG));              // USCI_A0 TX buffer ready?
  }
}
#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR(void)
{
  __bic_SR_register_on_exit(CPUOFF);     // Clear CPUOFF bit from 0(SR)
}
#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B (void)
{
    sSelfMeasureSem = 1;
}

ED:

#include "bsp.h"
#include "mrfi.h"
#include "bsp_leds.h"
#include "bsp_buttons.h"
#include "nwk_types.h"
#include "nwk_api.h"
#include "nwk_frame.h"
#include "nwk.h"

#include "msp430x22x4.h"
#include "vlo_rand.h"

void linkTo(void);
void MCU_Init(void);

__no_init volatile int tempOffset @ 0x10F4;     // Temperature offset set at production
__no_init volatile char Flash_Addr[4] @ 0x10F0; // Flash address set randomly

void createRandomAddress(void);

void main (void)
{
  addr_t lAddr;
//  volatile int i;

 WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  {
  // delay loop to ensure proper startup before SimpliciTI increases DCO
  // This is typically tailored to the power supply used, and in this case
  // is overkill for safety due to wide distribution.
    volatile int i;
    for(i = 0; i < 0xFFFF; i++){}
  }
  if( CALBC1_8MHZ == 0xFF )                 // Do not run if cal values are erased
  {
    volatile int i;
    P1DIR |= 0x03;
    BSP_TURN_ON_LED1();
    BSP_TURN_OFF_LED2();
    while(1)
    {
      for(i = 0; i < 0x5FFF; i++){}
      BSP_TOGGLE_LED2();
      BSP_TOGGLE_LED1();
    }
  }

  if( Flash_Addr[0] == 0xFF &&              // Check if device Address is missing
      Flash_Addr[1] == 0xFF &&
      Flash_Addr[2] == 0xFF &&
      Flash_Addr[3] == 0xFF )
  {
    createRandomAddress();                  // Create Random device address at
  }                                         // initial startup if missing
  lAddr.addr[0]=Flash_Addr[0];
  lAddr.addr[1]=Flash_Addr[1];
  lAddr.addr[2]=Flash_Addr[2];
  lAddr.addr[3]=Flash_Addr[3];
  SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &lAddr);

 
   // SimpliciTI will change port pin settings as well
  P1DIR = 0xFF;
  P1OUT = 0x00;
  P2DIR = 0x27;
  P2OUT = 0x00;
  P3DIR = 0xC0;
  P3OUT = 0x00;
  P4DIR = 0xFF;
  P4OUT = 0x00;
  BSP_Init();                               // Initialize eZ430 hardware

   while (SMPL_NO_JOIN == SMPL_Init((uint8_t (*)(linkID_t))0))
  {
    BSP_TOGGLE_LED1();
    BSP_TOGGLE_LED2();;
    __bis_SR_register(LPM3_bits + GIE);     // LPM3 with interrupts enabled
  }
                        


  BCSCTL1 = CALBC1_8MHZ;                    // Set DCO = 1MHz
  DCOCTL = CALDCO_8MHZ;

  BCSCTL3 |= LFXT1S_2;                      // LFXT1 = VLO
  TBCCTL0 = CCIE;                           // TBCCR0 interrupt enabled
  TBCCR0 =  12000;                   // ~10 sec (=15000/(12000/8))
  TBCTL = TASSEL_1 + MC_1;           // ACLK, upmode, Divider = 8

 

  linkTo();  // unconditional link to AP which is listening due to successful join.
}

void linkTo() {
  linkID_t linkID1;
  uint8_t  msg[3];
 


// keep trying to link...
  while (SMPL_SUCCESS != SMPL_Link(&linkID1))
  {
    __bis_SR_register(LPM3_bits + GIE);     // LPM3 with interrupts enabled
    BSP_TOGGLE_LED1();
    BSP_TOGGLE_LED2();
  }

  // Turn off all LEDs
  if (BSP_LED1_IS_ON())
  {
    BSP_TOGGLE_LED1();
  }
  if (BSP_LED2_IS_ON())
  {
    BSP_TOGGLE_LED2();
  }
  while (1)
  {
    volatile long temp;
    int degC, volt;
    int results[2];

    SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, "" );
    __bis_SR_register(LPM3_bits+GIE);       // LPM3 with interrupts enabled
    SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, "" );

    BSP_TOGGLE_LED2();
    ADC10CTL1 = INCH_10 + ADC10DIV_4;       // Temp Sensor ADC10CLK/5
    ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE + ADC10SR;
    for( degC = 240; degC > 0; degC-- );    // delay to allow reference to settle
    ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
    __bis_SR_register(CPUOFF + GIE);        // LPM0 with interrupts enabled
    results[0] = ADC10MEM;

    ADC10CTL0 &= ~ENC;

    ADC10CTL1 = INCH_11;                     // AVcc/2
    ADC10CTL0 = SREF_1 + ADC10SHT_2 + REFON + ADC10ON + ADC10IE + REF2_5V;
    for( degC = 240; degC > 0; degC-- );    // delay to allow reference to settle
    ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
    __bis_SR_register(CPUOFF + GIE);        // LPM0 with interrupts enabled
    results[1] = ADC10MEM;
    ADC10CTL0 &= ~ENC;
    ADC10CTL0 &= ~(REFON + ADC10ON);        // turn off A/D to save power

    // oC = ((A10/1024)*1500mV)-986mV)*1/3.55mV = A10*423/1024 - 278
    // the temperature is transmitted as an integer where 32.1 = 321
    // hence 4230 instead of 423
    temp = results[0];
    degC = ((temp - 673) * 4230) / 1024;
    if( tempOffset != 0xFFFF )
    {
      degC += tempOffset;
    }
    /*message format,  UB = upper Byte, LB = lower Byte
    -------------------------------
    |degC LB | degC UB |  volt LB |
    -------------------------------
       0         1          2
    */

    temp = results[1];
    volt = (temp*25)/512;
    msg[0] = degC&0xFF;
    msg[1] = (degC>>8)&0xFF;
    msg[2] = volt;

    if (SMPL_SUCCESS == SMPL_Send(linkID1, msg, sizeof(msg)))
    {
      BSP_TOGGLE_LED2();
    }
    else
    {
      BSP_TOGGLE_LED2();
      BSP_TOGGLE_LED1();
    }
  }
}

/***********************************************************************
*BEGHDR
*NAME:createRandomAddress()
*DESCRIPTION: generate random address
***********************************************************************/


void createRandomAddress()
{
  unsigned int rand, rand2;
  do
  {
    rand = TI_getRandomIntegerFromVLO();    // first byte can not be 0x00 of 0xFF
  }
  while( (rand & 0xFF00)==0xFF00 || (rand & 0xFF00)==0x0000 );
  rand2 = TI_getRandomIntegerFromVLO();

  BCSCTL1 = CALBC1_1MHZ;                    // Set DCO to 1MHz
  DCOCTL = CALDCO_1MHZ;
  FCTL2 = FWKEY + FSSEL0 + FN1;             // MCLK/3 for Flash Timing Generator
  FCTL3 = FWKEY + LOCKA;                    // Clear LOCK & LOCKA bits
  FCTL1 = FWKEY + WRT;                      // Set WRT bit for write operation

  Flash_Addr[0]=(rand>>8) & 0xFF;
  Flash_Addr[1]=rand & 0xFF;
  Flash_Addr[2]=(rand2>>8) & 0xFF;
  Flash_Addr[3]=rand2 & 0xFF;

  FCTL1 = FWKEY;                            // Clear WRT bit
  FCTL3 = FWKEY + LOCKA + LOCK;             // Set LOCK & LOCKA bit
}

/***********************************************************************
*BEGHDR
*NAME:__interrupt void ADC10_ISR(void)
*DESCRIPTION:ADC10 interrupt service routine

*INPUTS:
*PROCESSING:service A/D interupt

*OUTPUTS:
***********************************************************************/



/*------------------------------------------------------------------------------
* ADC10 interrupt service routine
------------------------------------------------------------------------------*/
#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR(void)
{
  __bic_SR_register_on_exit(CPUOFF);        // Clear CPUOFF bit from 0(SR)
}
/***********************************************************************
*BEGHDR
*NAME:__interrupt void Timer_B (void)
*DESCRIPTION:Timer B0 interrupt service routine

*INPUTS:
*PROCESSING:Interupt service

*OUTPUTS:None
***********************************************************************/

/*------------------------------------------------------------------------------
* Timer B0 interrupt service routine
------------------------------------------------------------------------------*/

#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B (void)
{
  __bic_SR_register_on_exit(LPM3_bits);     // Clear LPM3 bit from 0(SR)
}

please help, I am trying to use  timer_B but nothing works for ED.

AP writes its temp and ... into terminal but can not find ED.