/* handle received messages */
uint8_t rxCallback(linkID_t port) {
uint8_t len;
packet_t thePacket;
/* is the callback for the link ID we want to handle? */
if (port == myLinkID) {
if ((SMPL_SUCCESS == SMPL_Receive(myLinkID, (uint8_t *) &thePacket,
&len)) && len) {
uint8_t plen = thePacket.dlen + HEADER_SIZE;
uint8_t *packet_ptr = (uint8_t *) &thePacket;
if (thePacket.dev_id != BS_ID)
return 1;
if (plen <= len) {
// add to the queue
uint8_t i;
for (i = 0; i < plen; i++)
rq_push(packet_ptr[i]);
newRepPacket++;
}
// drop frame. we're done with it.
return 1;
}
}
/* keep frame for later handling */
return 0;
}
void main(void)
{
BSP_Init(); // Initialisation de la librairie BSP
NWK_DELAY(500);
SMPL_Init(&RxCallBack); // Initialisation de la librairie simpliciTI
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0); // Activation de la radio pour permettre la réception des messages
COM_Init(); // Initialisation du port COM
while (1)
{
if(broadSem)
{
memset(msg, 0, sizeof(msg));
if ((SMPL_Receive(SMPL_LINKID_USER_UUD, msg, &msgLen)) == SMPL_SUCCESS) // Cette fonction permet de stocker les messages reçu par un périphérique en spécifiant son linkID
{
sigInfo.lid = SMPL_LINKID_USER_UUD; // Permet d'indiquer les informations de quel périphérique sont demandées
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SIGINFO, &sigInfo); // On récupère les informations sur la force de connexion dans la structure sigInfo
msg[5] = 'S';
msg[6] = sigInfo.sigInfo.rssi+128;
msg[7] = 'L';
msg[8] = sigInfo.sigInfo.lqi;
msg[9] = 0xFF;
broadSem--;
TXString(msg, sizeof(msg));
}
}
}
}
/* handle received messages */
static uint8_t sRxCallback(linkID_t port)
{
uint8_t msg[2], len, tid;
/* is the callback for the link ID we want to handle? */
if (port == sLinkID2)
{
/* yes. go get the frame. we know this call will succeed. */
if ((SMPL_SUCCESS == SMPL_Receive(sLinkID2, msg, &len)) && len)
{
/* Check the application sequence number to detect
* late or missing frames...
*/
tid = *(msg+1);
if (tid)
{
if (tid > sRxTid)
{
/* we're good. toggle LED */
if ((*msg) == 0)
{
LedToggle(&led_red);
}
else
{
LedToggle(&led_green);
}
sRxTid = tid;
}
}
else
{
/* wrap case... */
if (sRxTid)
{
/* we're good. toggle LED */
if ((*msg) == 0)
{
LedToggle(&led_red);
}
else
{
LedToggle(&led_green);
}
sRxTid = tid;
}
}
/* Post to the semaphore to let application know so it sends
* the reply
*/
sSemaphore = 1;
/* drop frame. we're done with it. */
return 1;
}
}
/* keep frame for later handling */
return 0;
}
// *************************************************************************************************
// @fn simpliciti_main_sync
// @brief Send ready-to-receive packets in regular intervals. Listen shortly for host reply.
// Decode received host command and trigger action.
// @param none
// @return none
// *************************************************************************************************
void simpliciti_main_sync(void)
{
uint8_t len, i;
uint8_t ed_data[2];
while (1)
{
// Sleep 0.5sec between ready-to-receive packets
// SimpliciTI has no low power delay function, so we have to use ours
Timer0_A4_Delay(CONV_MS_TO_TICKS(500));
// Get radio ready. Radio wakes up in IDLE state.
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
// Send 2 byte long ready-to-receive packet to stimulate host reply
ed_data[0] = SYNC_ED_TYPE_R2R;
ed_data[1] = 0xCB;
SMPL_SendOpt(sLinkID1, ed_data, 2, SMPL_TXOPTION_NONE);
// Wait shortly for host reply
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
NWK_DELAY(10);
// Check if a command packet was received
while (SMPL_Receive(sLinkID1, simpliciti_data, &len) == SMPL_SUCCESS)
{
// Decode received data
if (len > 0)
{
// Use callback function in application to decode data and react
simpliciti_sync_decode_ap_cmd_callback();
// Get reply data and send out reply packet burst (19 bytes each)
for (i = 0; i < simpliciti_reply_count; i++)
{
NWK_DELAY(10);
simpliciti_sync_get_data_callback(i);
SMPL_SendOpt(sLinkID1, simpliciti_data, BM_SYNC_DATA_LENGTH, SMPL_TXOPTION_NONE);
}
}
}
// Put radio back to sleep
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
// Service watchdog
WDTCTL = WDTPW + WDTIS__512K + WDTSSEL__ACLK + WDTCNTCL;
// Exit when flag bit SIMPLICITI_TRIGGER_STOP is set
if (getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_STOP))
{
// Clean up SimpliciTI stack to enable restarting
sInit_done = 0;
break;
}
}
}
/* handle received frames. */
static uint8_t sRxCallback(linkID_t port)
{
uint8_t msg[10], len, tid;
memset(msg, 0, 10);
/* is the callback for the link ID we want to handle? */
if (port == sLinkID1)
{
/* yes. go get the frame. we know this call will succeed. */
if ((SMPL_SUCCESS == SMPL_Receive(sLinkID1, msg, &len)) && len)
{
/* Check the application sequence number to detect
* late or missing frames...
*/
tid = *(msg+9);
if (tid)
{
if (tid > sRxTid)
{
/* we're good. toggle LED in the message */
toggleLED(*msg);
sRxTid = tid;
}
}
else
{
/* the wrap case... */
if (sRxTid)
{
/* we're good. toggle LED in the message */
toggleLED(*msg);
sRxTid = tid;
}
}
/* drop frame. we're done with it. */
return 1;
}
}
/* keep frame for later handling. */
return 0;
}
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
}
//*****************************************************************************
//
// Handle frames received from the radio.
//
//*****************************************************************************
static uint8_t
RxCallback(linkID_t port)
{
uint8_t pcMsg[2], ucLen, ucTid;
smplStatus_t eRetcode;
//
// Is the callback for the link ID we want to handle?
//
if (port == sLinkID)
{
//
// Yes - go and get the frame. We know this call will succeed.
//
eRetcode = SMPL_Receive(sLinkID, pcMsg, &ucLen);
if ((eRetcode == SMPL_SUCCESS) && ucLen)
{
//
// Update our receive counter.
//
g_ulRxCount++;
//
// Check the application sequence number to detect late or missing
// frames.
//
ucTid = *(pcMsg+1);
if (ucTid)
{
if (ucTid > g_ucRxTid)
{
//
// Things are fine so toggle the requested LED. Note that
// we send a message to the main loop to do this for us
// since redrawing the widget on the screen is a
// time-consuming operation that we don't want to do in
// interrupt context.
//
HWREGBITW(&g_ulCommandFlags, ((*pcMsg == 1) ?
COMMAND_LED1_TOGGLE : COMMAND_LED2_TOGGLE)) = 1;
g_ucRxTid = ucTid;
}
}
else
{
//
// The sequence number has wrapped.
//
if (g_ucRxTid)
{
//
// Send a message to the main loop asking it to toggle the
// "LED" on the display.
//
HWREGBITW(&g_ulCommandFlags, ((*pcMsg == 1) ?
COMMAND_LED1_TOGGLE : COMMAND_LED2_TOGGLE)) = 1;
g_ucRxTid = ucTid;
}
}
//
// If we're operating as the listener, we need to reply with another
// packet so tell the main loop to do this for us.
//
if(g_ulMode == MODE_LISTENER)
{
HWREGBITW(&g_ulCommandFlags, COMMAND_SEND_REPLY) = 1;
}
//
// We've finished processing this frame.
//
return(1);
}
}
//
// Tell SimpliciTI to keep frame for later handling.
//
return(0);
}
//*****************************************************************************
//
// Main application entry function.
//
//*****************************************************************************
int
main(void)
{
tBoolean bRetcode;
bspIState_t intState;
uint8_t ucLastChannel;
//
// Set the system clock to run at 50MHz from the PLL
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// NB: We don't call PinoutSet() in this testcase since the EM header
// expansion board doesn't currently have an I2C ID EEPROM. If we did
// call PinoutSet() this would configure all the EPI pins for SDRAM and
// we don't want to do this.
//
g_eDaughterType = DAUGHTER_NONE;
//
// Enable peripherals required to drive the LCD.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
//
// Configure SysTick for a 10Hz interrupt.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the touch screen driver.
//
TouchScreenInit();
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(WidgetPointerMessage);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sHeading);
//
// Initialize the status string.
//
UpdateStatus(true, "Initializing...");
//
// Paint the widget tree to make sure they all appear on the display.
//
WidgetPaint(WIDGET_ROOT);
//
// Initialize the SimpliciTI BSP.
//
BSP_Init();
//
// Set the SimpliciTI device address using the current Ethernet MAC address
// to ensure something like uniqueness.
//
bRetcode = SetSimpliciTIAddress();
//
// Did we have a problem with the address?
//
if(!bRetcode)
{
//
// Yes - make sure the display is updated then hang the app.
//
WidgetMessageQueueProcess();
while(1)
{
//
// MAC address is not set so hang the app.
//
}
}
//
// Turn on both our LEDs
//
SetLED(1, true);
SetLED(2, true);
UpdateStatus(true, "Waiting for a device...");
//
// Initialize the SimpliciTI stack and register our receive callback.
//
SMPL_Init(ReceiveCallback);
//
// Tell the user what's up.
//
UpdateStatus(true, "Access point active.");
//
// Do nothing after this - the SimpliciTI stack code handles all the
// access point function required.
//
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 (g_ucJoinSem && (g_ucNumCurrentPeers < NUM_CONNECTIONS))
{
//
// Listen for a new incoming connection.
//
while (1)
{
if (SMPL_SUCCESS == SMPL_LinkListen(&g_sLID[g_ucNumCurrentPeers]))
{
//
// The connection attempt succeeded so break out of the
// loop.
//
break;
}
//
// Process our widget message queue.
//
WidgetMessageQueueProcess();
//
// A "real" application would implement its fail-to-link
// policy here. We go back and listen again.
//
}
//
// Increment our peer counter.
//
g_ucNumCurrentPeers++;
//
// Decrement the join semaphore.
//
BSP_ENTER_CRITICAL_SECTION(intState);
g_ucJoinSem--;
BSP_EXIT_CRITICAL_SECTION(intState);
//
// Tell the user how many devices we are now connected to.
//
UpdateStatus(false, "%d devices connected.", g_ucNumCurrentPeers);
}
//
// Have we received a frame on one of the ED connections? We don't use
// a critical section here since it doesn't really matter much if we
// miss a poll.
//
if (g_ucPeerFrameSem)
{
uint8_t pucMsg[MAX_APP_PAYLOAD], ucLen, ucLoop;
/* process all frames waiting */
for (ucLoop = 0; ucLoop < g_ucNumCurrentPeers; ucLoop++)
{
//
// Receive the message.
//
if (SMPL_SUCCESS == SMPL_Receive(g_sLID[ucLoop], pucMsg,
&ucLen))
{
//
// ...and pass it to the function that processes it.
//
ProcessMessage(g_sLID[ucLoop], pucMsg, ucLen);
//
// Decrement our frame semaphore.
//
BSP_ENTER_CRITICAL_SECTION(intState);
g_ucPeerFrameSem--;
BSP_EXIT_CRITICAL_SECTION(intState);
}
}
}
//
// Have we been asked to change channel?
//
ucLastChannel = g_ucChannel;
if (g_bChangeChannel)
{
//
// Yes - go ahead and change to the next radio channel.
//
g_bChangeChannel = false;
ChangeChannel();
}
else
{
//
// No - check to see if we need to automatically change channel
// due to interference on the current one.
//
CheckChangeChannel();
}
//
// If the channel changed, update the display.
//
if(g_ucChannel != ucLastChannel)
{
UpdateStatus(false, "Changed to channel %d.", g_ucChannel);
}
//
// If required, blink the "LEDs" to indicate we are waiting for a
// message following a channel change.
//
BSP_ENTER_CRITICAL_SECTION(intState);
if (g_ulBlinky)
{
if (++g_ulBlinky >= 0xF)
{
g_ulBlinky = 1;
ToggleLED(1);
ToggleLED(2);
}
}
BSP_EXIT_CRITICAL_SECTION(intState);
//
// Process our widget message queue.
//
WidgetMessageQueueProcess();
}
}
void main1 (void)
{
/* holds length of current message */
uint8_t len;
/* the link token */
linkID_t LinkID = 0;
/* the transmit and receive buffers */
uint8_t rx[MAX_APP_PAYLOAD], tx[MAX_APP_PAYLOAD];
/* holds led indicator time out counts */
uint16_t led_tmr;
int8_t rssi_value;
BSP_Init( );
SMPL_Init( NULL );
uart_intfc_init( );
/* turn on the radio so we are always able to receive data asynchronously */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, NULL );
/* turn on LED. */
BSP_TURN_ON_LED1( );
#ifdef LINK_TO
{
uint8_t cnt = 0;
tx_send_wait( "Linking to...\r\n", 15 );
while (SMPL_SUCCESS != SMPL_Link(&LinkID))
if( cnt++ == 0 )
{
/* blink LED until we link successfully */
BSP_TOGGLE_LED1( );
}
}
#else // ifdef LINK_LISTEN
tx_send_wait( "Listening for Link...\r\n", 23 );
while (SMPL_SUCCESS != SMPL_LinkListen(&LinkID))
{
/* blink LED until we link successfully */
BSP_TOGGLE_LED1( );
}
#endif
tx_send_wait( "Link Established!\r\nReady...\r\n", 29 );
/* turn off the led */
BSP_TURN_OFF_LED1( );
main_loop:
/* Check to see if we received any characters from the other radio
* and if we have send them out the uart and reset indicator timeout.
* Prioritize on radio received links as that buffer is the most time
* critical with respect to the UART buffers.
*/
if( SMPL_Receive( LinkID, tx, &len ) == SMPL_SUCCESS )
{
/* blocking call but should be ok if both ends have same uart buad rate */
//tx_send_wait( tx, len );
led_tmr = INDICATOR_TIME_OUT; /* update activity time out */
/*
int8_t dbm;
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RSSI, (void *)&dbm);
sSample= dbm;
tx_send_wait(&char2send, 1 );//input only (unsigned char)
tx_send_wait("\n", 1 );*/
unsigned char Test2;
//unsigned char Test;
rssi_value = 0 ;
ioctlRadioSiginfo_t sigInfo1;
sigInfo1.lid=LinkID;
smplStatus_t SMPL_SUCCESS = SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SIGINFO, (void *)&sigInfo1);
//if( SMPL_SUCCESS == SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RSSI,(void*)&rssi_value) )
{
//transmitData( i, (signed char)sigInfo.sigInfo.rssi, (char*)msg );
//MRFI_Rssi()
//Test2=RSSI;
//Test=rssi_value;
//int8_t i =-127;
//int i =-127;
unsigned char rssi_tmp[10];
int8_t rssi_int = sigInfo1.sigInfo.rssi;
itoa(rssi_int,rssi_tmp);
//tx_send_wait("This is Test :", sizeof("This is Test :") );
//tx_send_wait(&Test2, strlen(&Test2));
tx_send_wait(&rssi_tmp, strlen(rssi_tmp));
//tx_send_wait("\r\n", sizeof("\r\n") );
int8_t mk=0x01,bitshift=0;
tx_send_wait("=",1);
for (bitshift=0;bitshift<8;bitshift++)
{
if( (mk<<bitshift) & rssi_int )
tx_send_wait("1",1);
else
tx_send_wait("0",1);
//tx_send_wait("x",1);
MRFI_DelayMs( 5 );
}
tx_send_wait("\r\n", sizeof("\r\n") );
/*
tx_send_wait("This is Test2 :", sizeof("This is Test2 :") );
tx_send_wait( &Test2, sizeof(Test2) );
tx_send_wait("\n", sizeof("\n") );
*/
}
}
FHSS_ACTIVE( if( nwk_pllBackgrounder( false ) != false ) );
{
/* check to see if the host has sent any characters and if it has
* then send them over the radio link and reset indicator timeout.
*/
len = rx_receive( rx, MAX_APP_PAYLOAD );
if( len != 0 )
{
while( SMPL_Send( LinkID, rx, len ) != SMPL_SUCCESS )
;
/*
if( SMPL_SUCCESS == SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RSSI,&rssi_value ) ){
SMPL_Send( LinkID, &rssi_value, sizeof(rssi_value) );
}*/
led_tmr = INDICATOR_TIME_OUT; /* update activity time out */
/* By forcing a minimum delay between transmissions we guarantee
* a window for receiving packets. This is necessary as the radio
* link is half duplex while the UART is full duplex. Without this
* delay mechanism, packets can get lost as both ends may attempt to
* transmit at the same time which the CCA algorithm fails to handle.
*/
MRFI_DelayMs( 5 );
}
}
/* manage led indicator */
if( led_tmr != 0 )
{
led_tmr--;
BSP_TURN_ON_LED1( );
}
else
BSP_TURN_OFF_LED1( );
goto main_loop; /* do it again and again and again and ... */
}
//*****************************************************************************
//
// This function listens for a link request from another SimpliciTI device.
//
//*****************************************************************************
tBoolean
LinkFrom(void)
{
linkID_t linkID1;
uint8_t pucMsg[MAX_APP_PAYLOAD], ucLen, ucLtid;
unsigned long ulCount;
smplStatus_t eRetcode;
//
// Tell the user what we're doing.
//
UpdateStatus(false, "Listening for link...");
//
// Keep the compiler happy.
//
eRetcode = SMPL_TIMEOUT;
//
// Turn on LED 1 to indicate that we are listening.
//
SetLED(1, true);
//
// Listen for link for 10 seconds or so. This logic may fail if you
// happen to have sat around for about 13.6 years between starting the
// example and pressing the mode selection button. I suspect I will be
// forgiven for this.
//
ulCount = g_ulSysTickCount + (LINK_TIMEOUT_SECONDS * TICKS_PER_SECOND);
while (ulCount > g_ulSysTickCount)
{
//
// Process our message queue to keep the widget library happy.
//
WidgetMessageQueueProcess();
//
// Listen for a link. This call takes quite some time to return.
//
eRetcode = SMPL_LinkListen(&linkID1);
//
// Was the link successful?
//
if (SMPL_SUCCESS == eRetcode)
{
//
// Yes - drop out of the loop.
//
break;
}
}
//
// Did we link successfully?
//
if(eRetcode != SMPL_SUCCESS)
{
//
// No - Tell the user what happened and return an error.
//
UpdateStatus(false, "Failed to link!");
return(false);
}
//
// Turn off LED 1 to indicate that our listen succeeded.
//
UpdateStatus(false, "Link succeeded.");
SetLED(1, false);
//
// Clear our message counter.
//
ulCount = 0;
//
// Enter an infinite loop polling for messages.
//
while (1)
{
//
// Turn the radio off and pretend to sleep for a second or so.
//
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
SPIN_ABOUT_A_SECOND; /* emulate MCU sleeping */
//
// Turn the radio back on again.
//
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
//
// Were any messages "received"?
//
// The receive call results in polling the Access Point. The success
// case occurs when a payload is actually returned. When there is no
// frame waiting for the device a frame with no payload is returned by
// the Access Point. Note that this loop will retrieve any and all
// frames that are waiting for this device on the specified link ID.
// This call will also return frames that were received directly. It
// is possible to get frames that were repeated either from the initial
// transmission from the peer or via a Range Extender. This is why we
// implement the TID check.
//
do
{
//
// Receive whatever the AP has for us.
//
eRetcode = SMPL_Receive(linkID1, pucMsg, &ucLen);
//
// Did we get a real frame?
//
if((eRetcode == SMPL_SUCCESS) && ucLen)
{
//
// Tell the user what's going on.
//
UpdateStatus(false, "Received msg %d", ++ulCount);
//
// Process our message queue to keep the widget library happy.
//
WidgetMessageQueueProcess();
//
// Check the application sequence number to detect late or missing
// frames.
//
ucLtid = *(pucMsg+1);
if (ucLtid)
{
//
// If the current TID is non-zero and the last one we saw was
// less than this one assume we've received the 'next' one.
//
if (g_ucTid < ucLtid)
{
//
// 'Next' frame. We may have missed some but we don't
// care.
//
if ((*pucMsg == 1) || (*pucMsg == 2))
{
//
// We're good. Toggle the requested LED.
//
ToggleLED(*pucMsg);
}
//
// Remember the last TID.
//
g_ucTid = ucLtid;
}
//
// If current TID is non-zero and less than or equal to the last
// one we saw assume we received a duplicate. Just ignore it.
//
}
else
{
//
// Current TID is zero so the count wrapped or we just started.
// Let's just accept it and start over.
//
if ((*pucMsg == 1) || (*pucMsg == 2))
{
//
// We're good. Toggle the requested LED.
//
ToggleLED(*pucMsg);
}
//
// Remember the last TID.
//
g_ucTid = ucLtid;
}
}
} while ((eRetcode == SMPL_SUCCESS) & ucLen);
}
}
void main (void)
{
addr_t lAddr;
bspIState_t intState;
char *Flash_Addr; // Initialize radio address location
Flash_Addr = (char *)0x10F0;
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.
__delay_cycles(65000);
if( CALBC1_8MHZ == 0xFF && CALDCO_8MHZ == 0xFF )// Do not run if cal values
{
P1DIR |= 0x03;
BSP_TURN_ON_LED1();
BSP_TURN_OFF_LED2();
while(1)
{
__delay_cycles(65000);
BSP_TOGGLE_LED2();
BSP_TOGGLE_LED1();
}
}
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_Init();
SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &lAddr);
MCU_Init();
//Transmit splash screen and network init notification
TXString( (char*)splash, sizeof splash);
TXString( "\r\nInitializing Network....", 26 );
SMPL_Init(sCB);
// network initialized
TXString( "Done\r\n", 6);
// 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 and End Device.
if (sJoinSem && (sNumCurrentPeers < NUM_CONNECTIONS))
{
// listen for a new connection
SMPL_LinkListen(&sLID[sNumCurrentPeers]);
sNumCurrentPeers++;
BSP_ENTER_CRITICAL_SECTION(intState);
if (sJoinSem)
{
sJoinSem--;
}
BSP_EXIT_CRITICAL_SECTION(intState);
}
// if it is time to measure our own temperature...
if(sSelfMeasureSem)
{
// TXString("\r\n...", 5);
BSP_TOGGLE_LED1();
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[MESSAGE_LENGTH], len, i;
// process all frames waiting
for (i=0; i<sNumCurrentPeers; ++i)
{
if (SMPL_Receive(sLID[i], msg, &len) == SMPL_SUCCESS)
{
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_TURN_ON_LED2(); // Toggle LED2 when received packet
BSP_ENTER_CRITICAL_SECTION(intState);
sPeerFrameSem--;
BSP_EXIT_CRITICAL_SECTION(intState);
__delay_cycles(10000);
BSP_TURN_OFF_LED2();
}
}
}
}
}
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);
}
}
}
// *************************************************************************************************
// @fn simpliciti_main_tx_only
// @brief Get data through callback. Transfer data when external trigger is set.
// @param none
// @return none
// *************************************************************************************************
void simpliciti_main_tx_only(void)
{
uint8_t len, i;
uint8_t ed_data[2];
while(1)
{
// Get end device data from callback function
simpliciti_get_ed_data_callback();
// Get radio ready. Wakes up in IDLE state.
if(getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_SEND_DATA) ||
getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_RECEIVE_DATA)) {
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
// Send data when flag bit SIMPLICITI_TRIGGER_SEND_DATA is set
if (getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_SEND_DATA))
{
// Acceleration / button events packets are 4 bytes long
SMPL_SendOpt(sLinkID1, simpliciti_data, simpliciti_payload_length, SMPL_TXOPTION_NONE);
//SMPL_SendOpt(sLinkID1, simpliciti_data, simpliciti_payload_length, simpliciti_options);
// reset options to default
//simpliciti_options = SMPL_TXOPTION_NONE;
clearFlag(simpliciti_flag, SIMPLICITI_TRIGGER_SEND_DATA);
}
// Receive data when flag bit SIMPLICITI_TRIGGER_RECEIVE_DATA is set
if (getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_RECEIVE_DATA)) {
// Send 2 byte long ready-to-receive packet to stimulate host reply
clearFlag(simpliciti_flag, SIMPLICITI_TRIGGER_RECEIVE_DATA);
// clean up tha buffer first
simpliciti_data[0] = 0x00;
simpliciti_data[1] = 0x00;
simpliciti_data[3] = 0x00;
simpliciti_data[4] = 0x00;
// generate a ready to receive packet
ed_data[0] = SYNC_ED_TYPE_R2R;
ed_data[1] = 0xCB;
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
// we try to receive 9 times by sending a R2R packet
for (i = 0; i < 10; i++) {
SMPL_SendOpt(sLinkID1, ed_data, 2, SMPL_TXOPTION_NONE);
//WDTCTL = WDTPW + WDTHOLD;
// Wait shortly for host reply
NWK_DELAY(10);
while (SMPL_Receive(sLinkID1, simpliciti_data, &len) == SMPL_SUCCESS)
{
if (len > 0)
{
// Decode received data
if(simpliciti_get_rvc_callback(len))
{
// stop retry loop
i = 10;
break;
}
}
}
Timer0_A4_Delay(CONV_MS_TO_TICKS(500));
}
}
// Put radio back to SLEEP state
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
}
// Exit when flag bit SIMPLICITI_TRIGGER_STOP is set
if (getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_STOP))
{
// Clean up SimpliciTI stack to enable restarting
sInit_done = 0;
break;
}
}
}
static void monitorForBadNews()
{
uint8_t i, msg[1], len;
/* Turn off LEDs. Check for bad news will toggle one LED.
* The other LED will toggle when bad news message is sent.
*/
toggleLED(2);
toggleLED(1);
/* frequency hopping doesn't support sleeping just yet */
#ifndef FREQUENCY_HOPPING
/* start the radio off sleeping */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
#endif
while (1)
{
/* spoof MCU sleeping... */
for (i=0; i<CHECK_RATE; ++i)
{
SPIN_ABOUT_A_SECOND; /* manages FHSS implicitly */
}
toggleLED(1);
/* check "sensor" to see if we need to send an alert */
if (BSP_BUTTON1() || BSP_BUTTON2())
{
/* sensor activated. start babbling. */
start2Babble();
}
/* frequency hopping doesn't support sleeping just yet */
#ifndef FREQUENCY_HOPPING
/* wake up radio. we need it to listen for others babbling. */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
/* turn on RX. default is RX off. */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
#endif
/* stay on "long enough" to see if someone else is babbling */
SPIN_ABOUT_A_QUARTER_SECOND;
/* frequency hopping doesn't support sleeping just yet */
#ifndef FREQUENCY_HOPPING
/* we're done with radio. shut it down */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
#endif
/* got message? */
if (SMPL_SUCCESS == SMPL_Receive(SMPL_LINKID_USER_UUD, msg, &len))
{
/* got something. is it bad news? */
if (len && (msg[0] == BAD_NEWS))
{
/* Yep. start babbling. If there is a filtering token make
* sure the token matches the expected value.
*/
start2Babble();
}
}
}
}
// AP main routine
void simpliciti_main(void)
{
bspIState_t intState;
uint8_t j;
uint8_t len;
uint32_t led_toggle = 0;
uint8_t pwr;
// Init variables
simpliciti_flag = SIMPLICITI_STATUS_LINKING;
// Init SimpliciTI
SMPL_Init(sCB);
// Set output power to +1.1dBm (868MHz) / +1.3dBm (915MHz)
pwr = IOCTL_LEVEL_2;
SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SETPWR, &pwr);
// LED off
BSP_TURN_OFF_LED1();
/* 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.
if (sJoinSem && !sNumCurrentPeers)
{
/* listen for a new connection */
while (1)
{
if (SMPL_SUCCESS == SMPL_LinkListen(&linkID0))
{
// We have a connection
simpliciti_flag = SIMPLICITI_STATUS_LINKED;
BSP_TURN_ON_LED1();
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)
{
// Continuously try to receive end device packets
if (SMPL_SUCCESS == SMPL_Receive(linkID0, ed_data, &len))
{
// Acceleration / ppt data packets are 4 byte long
if (len == 4)
{
BSP_TOGGLE_LED1();
memcpy(simpliciti_data, ed_data, 4);
setFlag(simpliciti_flag, SIMPLICITI_TRIGGER_RECEIVED_DATA);
#ifdef EMBEDDED_UART
uart_analyze_packet(simpliciti_data[0],simpliciti_data[1],simpliciti_data[2],simpliciti_data[3]);
#endif
}
// Sync packets are either R2R (2 byte) or data (19 byte) long
else if ((len == 2) || (len == 19))
{
// Indicate received packet
BSP_TOGGLE_LED1();
// Decode end device packet
switch (ed_data[0])
{
case SYNC_ED_TYPE_R2R:
// Send reply
if (getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_SEND_CMD))
{
// Clear flag
clearFlag(simpliciti_flag, SIMPLICITI_TRIGGER_SEND_CMD);
// Command data was set by USB buffer previously
len = BM_SYNC_DATA_LENGTH;
}
else // No command currently available
{
simpliciti_data[0] = SYNC_AP_CMD_NOP;
simpliciti_data[1] = 0x55;
len = 2;
}
// Send reply packet to end device
SMPL_Send(linkID0, simpliciti_data, len);
break;
case SYNC_ED_TYPE_MEMORY:
case SYNC_ED_TYPE_STATUS:
// If buffer is empty, copy received end device data to intermediate buffer
if (!simpliciti_sync_buffer_status)
{
for (j=0; j<BM_SYNC_DATA_LENGTH; j++) simpliciti_data[j] = ed_data[j];
simpliciti_sync_buffer_status = 1;
}
// Set buffer status to full
break;
}
}
}
}
// Exit function if SIMPLICITI_TRIGGER_STOP flag bit is set in USB driver
if (getFlag(simpliciti_flag, SIMPLICITI_TRIGGER_STOP))
{
// Immediately turn off RF interrupt
IEN2 &= ~BIT0;
RFIM = 0;
RFIF = 0;
// Clean up after SimpliciTI and enable restarting the stack
linkID0 = 0;
sNumCurrentPeers = 0;
sJoinSem = 0;
sPeerFrameSem = 0;
sInit_done = 0;
// LED off
BSP_TURN_OFF_LED1();
return;
}
// Blink slowly to indicate that access point is on
if (!sNumCurrentPeers)
{
if (led_toggle++>150000)
{
BSP_TOGGLE_LED1();
led_toggle = 0;
}
}
}
}
//*****************************************************************************
//
// This is the main monitoring function for the applicaiton. It "sleeps" for
// 5 seconds or so then checks to see if there are any alerts being broadcast.
// If not, it toggles a LED and goes back to "sleep". If an alert is received
// it switches into "babbling" mode where it retransmits the alert every 100mS
// to propagate the alert through the network.
//
// This function does not return.
//
//*****************************************************************************
void
MonitorForBadNews(void)
{
uint8_t pucMsg[1], ucLen;
unsigned long ulLoop;
//
// Turn off LEDs. Check for bad news will toggle one LED. The other LED will
// toggle when bad news message is sent.
//
SetLED(2, false);
SetLED(1, false);
//
// Start with radio sleeping.
//
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
while (1)
{
//
// Spoof MCU sleeping...
//
for (ulLoop = 0; ulLoop < CHECK_RATE; ulLoop++)
{
SPIN_ABOUT_A_SECOND;
}
ToggleLED(1);
//
// Check the "sensor" to see if we need to send an alert.
//
if (g_bAlarmRaised)
{
//
// The sensor has been activated. Start babbling. This function
// will not return.
//
Start2Babble();
}
//
// Wake up the radio and receiver so that we can listen for others
// babbling.
//
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_AWAKE, 0);
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
//
// Stay on "long enough" to see if someone else is babbling
//
SPIN_ABOUT_A_QUARTER_SECOND;
//
// We're done with the radio so shut it down.
//
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SLEEP, 0);
//
// Did we receive a message while the radio was on?
//
if (SMPL_SUCCESS == SMPL_Receive(SMPL_LINKID_USER_UUD, pucMsg, &ucLen))
{
//
// Did we receive something and, if so, is it bad news?
//
if (ucLen && (pucMsg[0] == BAD_NEWS))
{
//
// Bad news has been received so start babbling to pass the
// alert on to the other devices in the network.
//
UpdateStatus(true, "Alarm received!");
Start2Babble();
}
}
}
}
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);
}
}
