int main(void)
#endif
{
BYTE i, j;
BYTE TxSynCount = 0;
BYTE TxNum = 0;
BYTE RxNum = 0;
BOOL bReceivedMessage = FALSE;
/*******************************************************************/
// Initialize the system
/*******************************************************************/
BoardInit();
ConsoleInit();
DemoOutput_Greeting();
/*******************************************************************/
// Function MiApp_ProtocolInit initialize the protocol stack. The
// only input parameter indicates if previous network configuration
// should be restored. In this example, if button 1 is pressed and
// hold when powering up, we assume the user would like to enable
// the Network Freezer and load previous network configuration
// from NVM.
/*******************************************************************/
if( (PUSH_BUTTON_1 == 0) && ( MiApp_ProtocolInit(TRUE) == TRUE ) )
{
DemoOutput_NetworkFreezer();
LED_1 = 1;
while(PUSH_BUTTON_1 == 0);
}
else
{
/*******************************************************************/
// Function MiApp_ProtocolInit initialize the protocol stack. In
// this example, if button 1 is released when powering up, we assume
// that the user want the network to start from scratch.
/*******************************************************************/
MiApp_ProtocolInit(FALSE);
LED_1 = 0;
LED_2 = 0;
myChannel = 0xFF;
DemoOutput_StartActiveScan();
/*******************************************************************/
// Function MiApp_SearchConnection will return the number of
// existing connections in all channels. It will help to decide
// which channel to operate on and which connection to add.
// The return value is the number of connections. The connection
// data are stored in global variable ActiveScanResults.
// Maximum active scan result is defined as
// ACTIVE_SCAN_RESULT_SIZE
// The first parameter is the scan duration, which has the same
// definition in Energy Scan. 10 is roughly 1 second. 9 is a
// half second and 11 is 2 seconds. Maximum scan duration is 14,
// or roughly 16 seconds.
// The second parameter is the channel map. Bit 0 of the
// double word parameter represents channel 0. For the 2.4GHz
// frequency band, all possible channels are channel 11 to
// channel 26. As the result, the bit map is 0x07FFF800. Stack
// will filter out all invalid channels, so the application
// only needs to pay attention to the channels that are not
// preferred.
/*******************************************************************/
i = MiApp_SearchConnection(10, 0xFFFFFFFF);
DemoOutput_ActiveScanResults(i);
/*******************************************************************/
// Function MiApp_ConnectionMode sets the connection mode for the
// protocol stack. Possible connection modes are:
// - ENABLE_ALL_CONN accept all connection request
// - ENABLE_PREV_CONN accept only known device to connect
// - ENABL_ACTIVE_SCAN_RSP do not accept connection request, but
// allow response to active scan
// - DISABLE_ALL_CONN disable all connection request, including
// active scan request
/*******************************************************************/
MiApp_ConnectionMode(ENABLE_ALL_CONN);
if( i > 0 )
{
/*******************************************************************/
// Function MiApp_EstablishConnection try to establish a new
// connection with peer device.
// The first parameter is the index to the active scan result, which
// is acquired by discovery process (active scan). If the value
// of the index is 0xFF, try to establish a connection with any
// peer.
// The second parameter is the mode to establish connection, either
// direct or indirect. Direct mode means connection within the
// radio range; Indirect mode means connection may or may not
// in the radio range.
/*******************************************************************/
if( MiApp_EstablishConnection(0, CONN_MODE_DIRECT) == 0xFF )
{
DemoOutput_JoinFail();
}
}
else
{
DemoOutput_EnergyScan();
/*******************************************************************/
// Function MiApp_StartConnection tries to start a new network
//
// The first parameter is the mode of start connection. There are
// two valid connection modes:
// - START_CONN_DIRECT start the connection on current
// channel
// - START_CONN_ENERGY_SCN perform an energy scan first,
// before starting the connection on
// the channel with least noise
// - START_CONN_CS_SCN perform a carrier sense scan
// first, before starting the
// connection on the channel with
// least carrier sense noise. Not
// supported for current radios
//
// The second parameter is the scan duration, which has the same
// definition in Energy Scan. 10 is roughly 1 second. 9 is a
// half second and 11 is 2 seconds. Maximum scan duration is
// 14, or roughly 16 seconds.
//
// The third parameter is the channel map. Bit 0 of the
// double word parameter represents channel 0. For the 2.4GHz
// frequency band, all possible channels are channel 11 to
// channel 26. As the result, the bit map is 0x07FFF800. Stack
// will filter out all invalid channels, so the application
// only needs to pay attention to the channels that are not
// preferred.
/*******************************************************************/
MiApp_StartConnection(START_CONN_ENERGY_SCN, 10, 0xFFFFFFFF);
}
// Turn on LED 1 to indicate ready to accept new connections
LED_1 = 1;
}
DumpConnection(0xFF);
DemoOutput_StartConnection();
DemoOutput_Instruction();
while(1)
{
/*******************************************************************/
// Function MiApp_MessageAvailable will return a boolean to indicate
// if a message for application layer has been received by the
// transceiver. If a message has been received, all information will
// be stored in the rxMessage, structure of RECEIVED_MESSAGE.
/*******************************************************************/
if( MiApp_MessageAvailable() )
{
DemoOutput_HandleMessage();
/*******************************************************************/
// Function MiApp_DiscardMessage is used to release the current
// received message. After calling this function, the stack can
// start to process the next received message.
/*******************************************************************/
MiApp_DiscardMessage();
// Toggle LED2 to indicate receiving a packet.
LED_2 ^= 1;
bReceivedMessage = TRUE;
DemoOutput_UpdateTxRx(TxNum, ++RxNum);
}
else
{
/*******************************************************************/
// If no packet received, now we can check if we want to send out
// any information.
// Function ButtonPressed will return if any of the two buttons
// has been pushed.
/*******************************************************************/
BYTE PressedButton = ButtonPressed();
switch( PressedButton )
{
case 1:
{
DWORD ChannelMap = ~((DWORD)0x00000001 << currentChannel);
DemoOutput_InitFreqHop();
/*******************************************************************/
// Function MiApp_InitChannelHopping will start the process of
// channel hopping. This function can be only called by Frquency
// Agility starter and the device must have the energy detection
// feature turned on. This function will do an energy detection
// scan of all input channels and start the process of jumping to
// the channel with least noise
//
// The only parameter of this function is the bit map of the
// allowed channels. Bit 0 of the double word parameter represents
// channel 0. For the 2.4GHz frequency band, the possible channels
// are channel 11 to channel 26. As the result, the bit map is
// 0x07FFF800.
//
// Microchip proprietary stack does not limit the application when to
// do channel hopping. The typical triggers for channel hopping are:
// 1. Continuous data transmission failures
// 2. Periodical try the channel hopping process every few hours
// or once per day
// 3. Receive a request to start the channel hopping process. This
// demo is an example of manually issue the request. In the
// real application, a Frequency Agility follower can send a
// message to request channel hopping and the Frequency Agility
// starter will decide if start the process.
/*******************************************************************/
if( MiApp_InitChannelHopping(ChannelMap & 0xFFFFFFFF) == TRUE )
{
DemoOutput_FreqHopSuccess();
}
else
{
DemoOutput_FreqHopFail();
}
}
break;
case 2:
/*******************************************************************/
// Button 2 (RB4 on PICDEM Z or RD7 on Explorer 16) pressed. We need
// to send out the bitmap of word "P2P" encrypted.
// First call function MiApp_FlushTx to reset the Transmit buffer.
// Then fill the buffer one byte by one byte by calling function
// MiApp_WriteData
/*******************************************************************/
MiApp_FlushTx();
for(i = 0; i < 11; i++)
{
MiApp_WriteData(DE[(TxSynCount%6)][i]);
}
TxSynCount++;
/*******************************************************************/
// Function MiApp_UnicastConnection is one of the functions to
// unicast a message.
// The first parameter is the index of connection table for
// the peer device. In this demo, since there are only two
// devices involved, the peer device must be stored in the
// first P2P Connection Entry of the connection table.
// The second parameter is the boolean to indicate if we need
// to secure the frame. If encryption is applied, the
// security level and security key are defined in the
// configuration file for the transceiver
//
// Another way to unicast a message is by calling function
// MiApp_UnicastAddress. Instead of supplying the index of the
// connection table of the peer device, this function requires the
// input parameter of destination address directly.
/*******************************************************************/
if( MiApp_UnicastConnection(0, TRUE) == FALSE )
{
DemoOutput_UnicastFail();
}
else
{
TxNum++;
}
DemoOutput_UpdateTxRx(TxNum, RxNum);
break;
default:
break;
}
}
}
}
void ProcessMenu( void )
{
BYTE c;
BYTE i;
// Get the key value.
c = ConsoleGet();
ConsolePut( c );
switch (c)
{
case '1':
ConsolePutROMString((ROM char * const)"\r\n1=ENABLE_ALL 2=ENABLE PREV 3=ENABLE SCAN 4=DISABLE: ");
while( !ConsoleIsGetReady());
c = ConsoleGet();
ConsolePut(c);
switch(c)
{
case '1':
MiApp_ConnectionMode(ENABLE_ALL_CONN);
break;
case '2':
MiApp_ConnectionMode(ENABLE_PREV_CONN);
break;
case '3':
MiApp_ConnectionMode(ENABLE_ACTIVE_SCAN_RSP);
break;
case '4':
MiApp_ConnectionMode(DISABLE_ALL_CONN);
break;
default:
break;
}
break;
case '2':
Printf("\r\nFamily Tree: ");
for(i = 0; i < NUM_COORDINATOR; i++)
{
PrintChar(FamilyTree[i]);
Printf(" ");
}
break;
case '3':
Printf("\r\nMy Routing Table: ");
for(i = 0; i < NUM_COORDINATOR/8; i++)
{
PrintChar(RoutingTable[i]);
}
Printf("\r\nNeighbor Routing Table: ");
for(i = 0; i < NUM_COORDINATOR; i++)
{
BYTE j;
for(j = 0; j < NUM_COORDINATOR/8; j++)
{
PrintChar(NeighborRoutingTable[i][j]);
}
Printf(" ");
}
break;
case '4':
{
WORD_VAL tempShortAddr;
Printf("\r\n1=Broadcast 2=Unicast Connection 3=Unicast Addr: ");
while( !ConsoleIsGetReady());
c = ConsoleGet();
ConsolePut(c);
MiApp_FlushTx();
MiApp_WriteData('T');
MiApp_WriteData('e');
MiApp_WriteData('s');
MiApp_WriteData('t');
MiApp_WriteData(0x0D);
MiApp_WriteData(0x0A);
switch(c)
{
case '1':
MiApp_BroadcastPacket(FALSE);
TxNum++;
break;
case '2':
Printf("\r\nConnection Index: ");
while( !ConsoleIsGetReady());
c = GetHexDigit();
MiApp_UnicastConnection(c, FALSE);
TxNum++;
break;
case '3':
Printf("\r\n1=Long Address 2=Short Address: ");
while( !ConsoleIsGetReady());
c = ConsoleGet();
ConsolePut(c);
switch(c)
{
case '1':
Printf("\r\nDestination Long Address: ");
for(i = 0; i < MY_ADDRESS_LENGTH; i++)
{
tempLongAddress[MY_ADDRESS_LENGTH-1-i] = GetMACByte();
}
MiApp_UnicastAddress(tempLongAddress, TRUE, FALSE);
TxNum++;
break;
case '2':
Printf("\r\nDestination Short Address: ");
tempLongAddress[1] = GetMACByte();
tempLongAddress[0] = GetMACByte();
MiApp_UnicastAddress(tempLongAddress, FALSE, FALSE);
TxNum++;
break;
default:
break;
}
break;
default:
break;
}
}
LCDTRXCount(TxNum, RxNum);
break;
case '5':
{
Printf("\r\nMSB of the Coordinator: ");
i = GetMACByte();
Printf("\r\nSet MSB of this Node's Parent: ");
FamilyTree[i] = GetMACByte();
}
break;
case '6':
{
Printf("\r\nSet my Routing Table: ");
for(i = 0; i < NUM_COORDINATOR/8; i++)
{
RoutingTable[i] = GetMACByte();
Printf(" ");
}
}
break;
case '7':
{
BYTE j;
Printf("\r\nNode Number: ");
i = GetMACByte();
Printf("\r\nContent of Neighbor Routing Table: ");
for(j = 0; j < NUM_COORDINATOR/8; j++)
{
NeighborRoutingTable[i][j] = GetMACByte();
Printf(" ");
}
}
break;
case '8':
{
MiApp_InitChannelHopping(0xFFFFFFFF);
}
break;
case '9':
{
Printf("\r\nSocket: ");
PrintChar(MiApp_EstablishConnection(0xFF, CONN_MODE_INDIRECT));
}
break;
case 'z':
case 'Z':
{
DumpConnection(0xFF);
}
default:
break;
}
PrintMenu();
}
