static void linkTo()
{
uint8_t msg[10], delay = 0;
memset(msg, 0, 10);
while (SMPL_SUCCESS != SMPL_Link(&sLinkID1))
{
/* blink LEDs until we link successfully */
toggleLED(1);
toggleLED(2);
SPIN_ABOUT_A_SECOND;
}
/* we're linked. turn off red LED. received messages will toggle the green LED. */
if (BSP_LED2_IS_ON())
{
toggleLED(2);
}
/* turn on RX. default is RX off. */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
/* put LED to toggle in the message */
msg[0] = 2; /* toggle red */
while (1)
{
__bis_SR_register(LPM4_bits + GIE); // Enter LPM4 w/interrupt
SPIN_ABOUT_A_SECOND;
if (delay > 0x00)
{
SPIN_ABOUT_A_SECOND;
}
if (delay > 0x01)
{
SPIN_ABOUT_A_SECOND;
}
if (delay > 0x02)
{
SPIN_ABOUT_A_SECOND;
}
/* delay longer and longer -- then start over */
delay = (delay+1) & 0x03;
/* put the sequence ID in the message */
msg[9] = ++sTxTid;
ReadRTCCTimeDate(&Rtcctimedate);
/* put data into packet */
msg[1] = Rtcctimedate.Sec;
msg[2] = Rtcctimedate.Min;
msg[3] = Rtcctimedate.Hour;
msg[4] = Rtcctimedate.Day;
msg[5] = Rtcctimedate.Date;
msg[6] = Rtcctimedate.Month;
msg[7] = Rtcctimedate.Year;
SMPL_Send(sLinkID1, msg, sizeof(msg));
}
}
void turnOffLeds(void)
{
/* turn on LEDs. */
if (BSP_LED2_IS_ON())
{
toggleLED(2);
}
if (BSP_LED1_IS_ON())
{
toggleLED(1);
}
}
static void linkFrom()
{
uint8_t msg[2], tid = 0;
/* Turn off one LED so we can tell the device is now listening.
* Received messages will toggle the other LED.
*/
//toggleLED(1);
/* listen for link forever... */
while (1)
{
if (SMPL_SUCCESS == SMPL_LinkListen(&sLinkID2))
{
break;
}
/* Implement fail-to-link policy here. otherwise, listen again. */
}
/* we're linked. turn off red LED. Received messages will toggle the green LED. */
if (BSP_LED2_IS_ON())
{
toggleLED(2);
}
if (BSP_LED1_IS_ON())
{
toggleLED(1);
}
/* turn on LED1 on the peer in response to receiving a frame. */
*msg = 0x01; /* toggle red led */
/* turn on RX. default is RX off. */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
while (1)
{
/* Wait for a frame to be received. The Rx handler, which is running in
* ISR thread, will post to this semaphore allowing the application to
* send the reply message in the user thread.
*/
if (sSemaphore)
{
*(msg+1) = ++tid;
SMPL_Send(sLinkID2, msg, 2);
/* Reset semaphore. This is not properly protected and there is a race
* here. In theory we could miss a message. Good enough for a demo, though.
*/
sSemaphore = 0;
}
}
}
void main (void)
{
init_cc();
BSP_Init();
/* If an on-the-fly device address is generated it must be done before the
* call to SMPL_Init(). If the address is set here the ROM value will not
* be used. If SMPL_Init() runs before this IOCTL is used the IOCTL call
* will not take effect. One shot only. The IOCTL call below is conformal.
*/
#ifdef I_WANT_TO_CHANGE_DEFAULT_ROM_DEVICE_ADDRESS_PSEUDO_CODE
{
addr_t lAddr;
createRandomAddress(&lAddr);
SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &lAddr);
}
#endif /* I_WANT_TO_CHANGE_DEFAULT_ROM_DEVICE_ADDRESS_PSEUDO_CODE */
/* This call will fail because the join will fail since there is no Access Point
* in this scenario. But we don't care -- just use the default link token later.
* We supply a callback pointer to handle the message returned by the peer.
*/
SMPL_Init(sRxCallback);
/* turn on LEDs. */
if (!BSP_LED2_IS_ON())
{
toggleLED(2);
}
if (!BSP_LED1_IS_ON())
{
toggleLED(1);
}
/* wait for a button press... */
do {
if (BSP_BUTTON1() || BSP_BUTTON2())
{
break;
}
} while (1);
/* never coming back... */
linkTo();
/* but in case we do... */
while (1) ;
}
void main (void)
{
BSP_Init();
/* If an on-the-fly device address is generated it must be done before the
* call to SMPL_Init(). If the address is set here the ROM value will not
* be used. If SMPL_Init() runs before this IOCTL is used the IOCTL call
* will not take effect. One shot only. The IOCTL call below is conformal.
*/
#ifdef I_WANT_TO_CHANGE_DEFAULT_ROM_DEVICE_ADDRESS_PSEUDO_CODE
{
addr_t lAddr;
createRandomAddress(&lAddr);
SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &lAddr);
}
#endif /* I_WANT_TO_CHANGE_DEFAULT_ROM_DEVICE_ADDRESS_PSEUDO_CODE */
/* Keep trying to join (a side effect of successful initialization) until
* successful. Toggle LEDS to indicate that joining has not occurred.
*/
while (SMPL_SUCCESS != SMPL_Init(0))
{
toggleLED(1);
toggleLED(2);
SPIN_ABOUT_A_SECOND;
}
/* LEDs on solid to indicate successful join. */
if (!BSP_LED2_IS_ON())
{
toggleLED(2);
}
if (!BSP_LED1_IS_ON())
{
toggleLED(1);
}
/* Unconditional link to AP which is listening due to successful join. */
linkTo();
while (1) ;
}
void unsyncRepere()
{
uint8_t msgTemp[10] = {0,0,0,0,0,0,0,0,0,0};
uint8_t msgLen = 0;
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0); // Activation de la radio pour permettre la réception des messages
NWK_DELAY(10);
while((SMPL_Receive(SMPL_LINKID_USER_UUD, msgTemp, &msgLen)) == SMPL_SUCCESS) // Boucle de désynchronisation des repères
{
BSP_TOGGLE_LED2();
NWK_DELAY(10);
}
if(BSP_LED2_IS_ON())
BSP_TOGGLE_LED2();
TACCR0 = 2280; // ~ 0.2sec - 10 msec
TACTL = TASSEL_1 + MC_1; // ACLK, upmode
__bis_SR_register(LPM3_bits + GIE);
TACCR0 = 2400; // ~ 0.2sec
TACTL = TASSEL_1 + MC_1; // ACLK, upmode
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXIDLE, 0); // Désactivation de la réception des messages
}
static void linkTo()
{
uint8_t msg[2];
uint8_t button, misses, done;
/* Keep trying to link... */
while (SMPL_SUCCESS != SMPL_Link(&sLinkID1))
{
toggleLED(1);
toggleLED(2);
SPIN_ABOUT_A_SECOND;
}
/* Turn off LEDs. */
if (BSP_LED2_IS_ON())
{
toggleLED(2);
}
if (BSP_LED1_IS_ON())
{
toggleLED(1);
}
/* sleep until button press... */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
while (1)
{
button = 0;
/* Send a message when either button pressed */
if (BSP_BUTTON1())
{
SPIN_ABOUT_A_QUARTER_SECOND; /* debounce... */
/* Message to toggle LED 1. */
button = 1;
}
else if (BSP_BUTTON2())
{
SPIN_ABOUT_A_QUARTER_SECOND; /* debounce... */
/* Message to toggle LED 2. */
button = 2;
}
if (button)
{
uint8_t noAck;
smplStatus_t rc;
/* get radio ready...awakens in idle state */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
/* Set TID and designate which LED to toggle */
msg[1] = ++sTid;
msg[0] = (button == 1) ? 1 : 2;
done = 0;
while (!done)
{
noAck = 0;
/* Try sending message MISSES_IN_A_ROW times looking for ack */
for (misses=0; misses < MISSES_IN_A_ROW; ++misses)
{
if (SMPL_SUCCESS == (rc=SMPL_SendOpt(sLinkID1, msg, sizeof(msg), SMPL_TXOPTION_ACKREQ)))
{
/* Message acked. We're done. Toggle LED 1 to indicate ack received. */
toggleLED(1);
break;
}
if (SMPL_NO_ACK == rc)
{
/* Count ack failures. Could also fail becuase of CCA and
* we don't want to scan in this case.
*/
noAck++;
}
}
if (MISSES_IN_A_ROW == noAck)
{
/* Message not acked. Toggle LED 2. */
toggleLED(2);
#ifdef FREQUENCY_AGILITY
/* Assume we're on the wrong channel so look for channel by
* using the Ping to initiate a scan when it gets no reply. With
* a successful ping try sending the message again. Otherwise,
* for any error we get we will wait until the next button
* press to try again.
*/
if (SMPL_SUCCESS != SMPL_Ping(sLinkID1))
{
done = 1;
}
#else
done = 1;
#endif /* FREQUENCY_AGILITY */
}
else
{
/* Got the ack or we don't care. We're done. */
done = 1;
}
}
/* radio back to sleep */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
}
}
}
static void linkTo()
{
uint8_t msg[2];
uint8_t button, misses, done;
/* Keep trying to link... */
while (SMPL_SUCCESS != SMPL_Link(&sLinkID1))
{
toggleLED(1);
toggleLED(2);
SPIN_ABOUT_A_SECOND;
}
/* Turn off LEDs. */
if (BSP_LED2_IS_ON())
{
toggleLED(2);
}
if (BSP_LED1_IS_ON())
{
toggleLED(1);
}
/* sleep until button press... */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
while (1)
{
button = 0;
/* Send a message when either button pressed */
if (BSP_BUTTON1())
{
SPIN_ABOUT_A_QUARTER_SECOND; /* debounce... */
/* Message to toggle LED 1. */
button = 1;
}
else if (BSP_BUTTON2())
{
SPIN_ABOUT_A_QUARTER_SECOND; /* debounce... */
/* Message to toggle LED 2. */
button = 2;
}
if (button)
{
/* get radio ready...awakens in idle state */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
/* Set TID and designate which LED to toggle */
msg[1] = ++sTid;
msg[0] = (button == 1) ? 1 : 2;
done = 0;
while (!done)
{
for (misses=0; misses < MISSES_IN_A_ROW; ++misses)
{
if (SMPL_SUCCESS == SMPL_Send(sLinkID1, msg, sizeof(msg)))
{
#if defined( FREQUENCY_AGILITY )
/* If macro is defined we're supporting Frequency Agility. In this case
* the peer will acknowledge the message sent. It is the only way we can
* tell if we are on the right channel. Wait for ack.
*/
{
bspIState_t intState;
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
NWK_REPLY_DELAY();
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXIDLE, 0);
if (!sPeerFrameSem)
{
/* Try again if we havn't received anything. */
continue;
}
else
{
uint8_t len;
BSP_ENTER_CRITICAL_SECTION(intState);
sPeerFrameSem--;
BSP_EXIT_CRITICAL_SECTION(intState);
/* We got something. Go get it. */
SMPL_Receive(sLinkID1, msg, &len);
if (len && (*msg & NWK_APP_REPLY_BIT))
{
toggleLED(*msg & ~NWK_APP_REPLY_BIT);
break;
}
}
}
#else
/* Not supporting Frequency agility. Just break out since there
* will be no ack.
*/
break;
#endif
}
}
if (misses == MISSES_IN_A_ROW)
{
/* This can only happen if we are supporting Frequency Agility and we
* appear not to have received an acknowledge. Do a scan.
*/
ioctlScanChan_t scan;
freqEntry_t freq[NWK_FREQ_TBL_SIZE];
scan.freq = freq;
SMPL_Ioctl(IOCTL_OBJ_FREQ, IOCTL_ACT_SCAN, &scan);
/* If we now know the channel (number == 1) change to it. In any case
* try it all again. If we changed channels we should get an ack now.
*/
if (1 == scan.numChan)
{
SMPL_Ioctl(IOCTL_OBJ_FREQ, IOCTL_ACT_SET, freq);
}
}
else
{
/* Got the ack. We're done. */
done = 1;
}
}
/* radio back to sleep */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
}
}
}
void main (void)
{
bspIState_t intState;
#ifdef FREQUENCY_AGILITY
memset(sSample, 0x0, sizeof(sSample));
#endif
BSP_Init();
/* If an on-the-fly device address is generated it must be done before the
* call to SMPL_Init(). If the address is set here the ROM value will not
* be used. If SMPL_Init() runs before this IOCTL is used the IOCTL call
* will not take effect. One shot only. The IOCTL call below is conformal.
*/
#ifdef I_WANT_TO_CHANGE_DEFAULT_ROM_DEVICE_ADDRESS_PSEUDO_CODE
{
addr_t lAddr;
createRandomAddress(&lAddr);
SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &lAddr);
}
#endif /* I_WANT_TO_CHANGE_DEFAULT_ROM_DEVICE_ADDRESS_PSEUDO_CODE */
SMPL_Init(sCB);
/* green and red LEDs on solid to indicate waiting for a Join. */
if (!BSP_LED2_IS_ON())
{
toggleLED(2);
}
if (!BSP_LED1_IS_ON())
{
toggleLED(1);
}
/* main work loop */
while (1)
{
/* manage FHSS schedule if FHSS is active */
FHSS_ACTIVE( nwk_pllBackgrounder( false ) );
/* 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)
{ /* SMPL_LinkListen will call nwk_PllBackgrounder for us if FHSS active */
if (SMPL_SUCCESS == SMPL_LinkListen(&sLID[sNumCurrentPeers]))
{
break;
}
/* Implement fail-to-link policy here. otherwise, listen again. */
}
sNumCurrentPeers++;
BSP_ENTER_CRITICAL_SECTION(intState);
sJoinSem--;
BSP_EXIT_CRITICAL_SECTION(intState);
}
/* 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);
BSP_ENTER_CRITICAL_SECTION(intState);
sPeerFrameSem--;
BSP_EXIT_CRITICAL_SECTION(intState);
}
}
}
if (BSP_BUTTON1())
{
SPIN_ABOUT_A_QUARTER_SECOND; /* debounce */
changeChannel();
}
else
{
checkChangeChannel();
}
BSP_ENTER_CRITICAL_SECTION(intState);
if (sBlinky)
{
if (++sBlinky >= 0xF)
{
sBlinky = 1;
toggleLED(1);
toggleLED(2);
}
}
BSP_EXIT_CRITICAL_SECTION(intState);
}
}
