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); } }