void TransmitMessage() { uint8_t index; //Send message /******************************************************************/ // 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(); MiApp_WriteData(TxMessageSize); for(index = 0; index < TxMessageSize; index++) { MiApp_WriteData(TxMessage[index]); } //Unicast Message /*******************************************************************/ // 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 lab, the chat is always sent to the // first P2P Connection Entry of the connection table. If that // node is down (eg. student is programming new firmare into it), // the user is prompted to reset the node to re-establish the // connection table with a new peer. // // 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) { //Message TX Failed (peer node 00 was likely being re-programmed by student) //Should reset the node to establish new peer connection to send chat to CONSOLE_PutString((char *) "Transmit to Peer 00 Failed. Press MCLR to establish new connections"); } //Reset Chat Application state variables messagePending = false; transmitPending = false; TxMessageSize = 0; }
void Transmit(INPUT BYTE Transmited_Data) { // First call MiApp_FlushTx to reset the Transmit buffer. MiApp_FlushTx(); MiApp_WriteData(Transmited_Data); MiApp_UnicastAddress(BASE, TRUE, FALSE); }
uint8_t miwiMsg(uint8_t map, uint8_t *data, uint8_t size) { uint8_t iii; MiApp_FlushTx(); for (iii = 0; iii < size; iii++) { MiApp_WriteData(data[iii]); } //return MiApp_UnicastAddress(ConnectionTable[map].Address, true, false); return MiApp_UnicastConnection(map, false); }
void MyMIWI_TxMsg(BOOL enableBroadcast, char *theMsg) { /*******************************************************************/ // First call MiApp_FlushTx to reset the Transmit buffer. Then fill // the buffer one byte by one byte by calling function // MiApp_WriteData /*******************************************************************/ MiApp_FlushTx(); while (*theMsg != '\0') MiApp_WriteData(*theMsg++); if (enableBroadcast) { /*******************************************************************/ // Function MiApp_BroadcastPacket is used to broadcast a message // The only parameter is the boolean to indicate if we need to // secure the frame /*******************************************************************/ MiApp_BroadcastPacket(FALSE); } else { /*******************************************************************/ // Function MiApp_UnicastConnection is one of the functions to // unicast a message. // The first parameter is the index of Connection Entry for // the peer device. In this demo, since there are only two // devices involved, the peer device must be stored in the // first Connection Entry // The second parameter is the boolean to indicate if we need to // secure the frame. If encryption is applied, the security // key are defined in ConfigApp.h // // Another way to unicast a message is by calling function // MiApp_UnicastAddress. Instead of supplying the index of the // Connection Entry of the peer device, this function requires the // input parameter of destination address. /*******************************************************************/ if( MiApp_UnicastConnection(0, FALSE) == FALSE ) Printf("\r\nUnicast Failed\r\n"); } }
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; } } } }
int main(void) #endif { BYTE i, j; BYTE TxSynCount = 0; BOOL bReceivedMessage = FALSE; _U16 m; #define BAUDRG 77 /*******************************************************************/ // Initialize the system /*******************************************************************/ ANCON0 = 0XFF; /*desactiva entradas analogicas*/ ANCON1 = 0XFF; /*desactiva entradas analogicas*/ PPSUnLock(); PPSOutput(PPS_RP10, PPS_TX2CK2); // TX2 RP17/RC6 PPSInput(PPS_RX2DT2, PPS_RP9); // RX2 RP18/RC7 PPSOutput(PPS_RP23, PPS_SDO2); // SDO2 RP23/RD6 PPSInput(PPS_SDI2, PPS_RP24); // SDI2 RP24/RD7 PPSOutput(PPS_RP22, PPS_SCK2); // SCK2 RP22/RD5 PPSLock(); System_PeripheralPinSelect( ExternalInterrupt3, 19); /*external interrupt 3 B3*/ BoardInit(); ConsoleInit(); Open2USART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_EIGHT_BIT & USART_ASYNCH_MODE & USART_ADDEN_OFF, BAUDRG); baud2USART(BAUD_IDLE_TX_PIN_STATE_HIGH & BAUD_IDLE_RX_PIN_STATE_HIGH & BAUD_AUTO_OFF & BAUD_WAKEUP_OFF & BAUD_16_BIT_RATE & USART_RX_INT_OFF); Gpios_PinDirection(GPIOS_PORTD, 7, GPIOS_INPUT); /*pin C0 como salida para SDI*/ Gpios_PinDirection(GPIOS_PORTD, 6, GPIOS_OUTPUT); /*pin C1 como salida para SDO*/ Gpios_PinDirection(GPIOS_PORTD, 5, GPIOS_OUTPUT); /*pin C2 como salida para SCK*/ Spi_Init(SPI_PORT1, SPI_64DIV); /*Inicializamos SPI2*/ Spi_Init(SPI_PORT2, SPI_64DIV); /*Inicializamos SPI2*/ //Spi_SetMode(SPI_PORT1, 1); //Spi_SetMode(SPI_PORT1, 1); LED_1 = 1; LED_2 = 1; Read_MAC_Address(); LED_1 = 0; LED_2 = 0; ConsolePutROMString((ROM char *)"\r\n<MAC Addr:"); PrintChar(myLongAddress[3]); PrintChar(myLongAddress[2]); PrintChar(myLongAddress[1]); PrintChar(myLongAddress[0]); ConsolePutROMString((ROM char *)"\r>"); Printf("\r\nStarting Testing Interface for MiWi(TM) PRO Stack ..."); #if defined(MRF24J40) Printf("\r\n RF Transceiver: MRF24J40"); #elif defined(MRF49XA) Printf("\r\n RF Transceiver: MRF49XA"); #elif defined(MRF89XA) Printf("\r\n RF Transceiver: MRF89XA"); #endif Printf("\r\n Demo Instruction:"); Printf("\r\n Press Enter to bring up the menu."); Printf("\r\n Type in hyper terminal to choose"); Printf("\r\n menu item. "); Printf("\r\n\r\n"); /*******************************************************************/ // Following block display demo information on LCD of Explore 16 or // PIC18 Explorer demo board. /*******************************************************************/ #if defined(MRF49XA) LCDDisplay((char *)"MiWi PRO Test Interface MRF49XA", 0, TRUE); #elif defined(MRF24J40) LCDDisplay((char *)"MiWi PRO Test Interface MRF24J40", 0, TRUE); #elif defined(MRF89XA) LCDDisplay((char *)"MiWi PRO Test Interface MRF89XA", 0, TRUE); #endif //if( (PUSH_BUTTON_1 == 0) || ( MiApp_ProtocolInit(TRUE) == FALSE ) ) if (PUSH_BUTTON_1 == 1) { MiApp_ProtocolInit(FALSE); LED_1 = 0; LED_2 = 0; #ifdef ENABLE_ACTIVE_SCAN myChannel = 0xFF; ConsolePutROMString((ROM char *)"\r\nStarting Active Scan..."); LCDDisplay((char *)"Active Scanning", 0, FALSE); /*******************************************************************/ // 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, 0x02000000); if( i > 0 ) { // now print out the scan result. Printf("\r\nActive Scan Results: \r\n"); for(j = 0; j < i; j++) { Printf("Channel: "); PrintDec(ActiveScanResults[j].Channel ); Printf(" RSSI: "); PrintChar(ActiveScanResults[j].RSSIValue); Printf("\r\n"); myChannel = ActiveScanResults[j].Channel; Printf("PeerInfo: "); PrintChar( ActiveScanResults[j].PeerInfo[0]); } } #endif /*******************************************************************/ // 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 ) { Printf("\r\nJoin Fail"); } } else { /*******************************************************************/ // 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 on currrent 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. /*******************************************************************/ #ifdef ENABLE_ED_SCAN //LCDDisplay((char *)"Active Scanning Energy Scanning", 0, FALSE); ConsolePutROMString((ROM char *)"\r\nActive Scanning Energy Scanning"); MiApp_StartConnection(START_CONN_ENERGY_SCN, 10, 0x02000000); #endif } // Turn on LED 1 to indicate ready to accept new connections LED_1 = 1; } else { //LCDDisplay((char *)" Network Freezer ENABLED", 0, TRUE); Printf("\r\nNetwork Freezer Feature is enabled. There will be no hand-shake process.\r\n"); LED_1 = 1; DumpConnection(0xFF); } LCDDisplay((char *)"Start Connection on Channel %d", currentChannel, TRUE); LCDDisplay((char *)"Testing Menu on Hyper Terminal", 0, FALSE); 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() ) { /*******************************************************************/ // If a packet has been received, following code prints out some of // the information available in rxFrame. /*******************************************************************/ if( rxMessage.flags.bits.secEn ) { ConsolePutROMString((ROM char *)"Secured "); } if( rxMessage.flags.bits.broadcast ) { ConsolePutROMString((ROM char *)"Broadcast Packet with RSSI "); } else { ConsolePutROMString((ROM char *)"Unicast Packet with RSSI "); } PrintChar(rxMessage.PacketRSSI); if( rxMessage.flags.bits.srcPrsnt ) { ConsolePutROMString((ROM char *)" from "); if( rxMessage.flags.bits.altSrcAddr ) { PrintChar(rxMessage.SourceAddress[1]); PrintChar(rxMessage.SourceAddress[0]); } else { for(i = 0; i < MY_ADDRESS_LENGTH; i++) { PrintChar(rxMessage.SourceAddress[MY_ADDRESS_LENGTH-1-i]); } } } ConsolePutROMString((ROM char *)": "); for(i = 0; i < rxMessage.PayloadSize; i++) { ConsolePut(rxMessage.Payload[i]); } // Toggle LED2 to indicate receiving a packet. LED_2 ^= 1; /*******************************************************************/ // 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(); bReceivedMessage = TRUE; /*******************************************************************/ // Following block update the total received and transmitted messages // on the LCD of the demo board. /*******************************************************************/ LCDTRXCount(TxNum, ++RxNum); } else { ++m; if(m > 8000) { m=0; //LED_1 ^= 1; MiApp_FlushTx(); MiApp_WriteData('H'); MiApp_WriteData('o'); MiApp_WriteData('l'); MiApp_WriteData('a'); MiApp_WriteData('a'); MiApp_WriteData('a'); MiApp_WriteData(0x0D); MiApp_WriteData(0x0A); MiApp_BroadcastPacket(FALSE); } if ( ConsoleIsGetReady() ) { //ProcessMenu(); } } } }
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(); }
/********************************************************************* * Function: void RangeDemo(void) * * PreCondition: none * * Input: none * * Output: none * * Side Effects: none * * Overview: Following routine * * * Note: **********************************************************************/ void RangeDemo(void) { BOOL Run_Demo = TRUE; BOOL Tx_Packet = TRUE; BYTE rssi = 0; BYTE Pkt_Loss_Cnt = 0; MIWI_TICK tick1, tick2; BYTE switch_val; /*******************************************************************/ // Dispaly Range Demo Splach Screen /*******************************************************************/ LCDBacklightON(); LCDDisplay((char *)" Microchip Range Demo ", 0, TRUE); LCDBacklightOFF(); /*******************************************************************/ // Read Start tickcount /*******************************************************************/ tick1 = MiWi_TickGet(); while(Run_Demo) { /*******************************************************************/ // Read current tickcount /*******************************************************************/ tick2 = MiWi_TickGet(); // Send a Message if((MiWi_TickGetDiff(tick2,tick1) > (ONE_SECOND * TX_PKT_INTERVAL))) { LCDErase(); if(Tx_Packet) { LCDDisplay((char *)"Checking Signal Strength...", 0, TRUE); MiApp_FlushTx(); MiApp_WriteData(RANGE_PKT); MiApp_WriteData(0x4D); MiApp_WriteData(0x69); MiApp_WriteData(0x57); MiApp_WriteData(0x69); MiApp_WriteData(0x20); MiApp_WriteData(0x52); MiApp_WriteData(0x6F); MiApp_WriteData(0x63); MiApp_WriteData(0x6B); MiApp_WriteData(0x73); MiApp_WriteData(0x21); if( MiApp_UnicastConnection(0, FALSE) == FALSE ) Pkt_Loss_Cnt++; else Pkt_Loss_Cnt = 0; Tx_Packet = FALSE; } else { if(Pkt_Loss_Cnt < 1) { if(rssi > 120) { sprintf((char *)&LCDText, (far rom char*)"Strength: High "); LED0 = 1; LED1 = 0; LED2 = 0; } else if(rssi < 121 && rssi > 60) { sprintf((char *)&LCDText, (far rom char*)"Strength: Medium"); LED0 = 1; LED1 = 1; LED2 = 0; } else if(rssi < 61) { sprintf((char *)&LCDText, (far rom char*)"Strength: Low"); LED0 = 0; LED1 = 1; LED2 = 0; } // Convert to dB //rssi = RSSIlookupTable[rssi]; sprintf((char *)&(LCDText[16]), (far rom char*)"Rcv RSSI: %03d", rssi); } else { LCDDisplay((char *)"No Device Found or Out of Range ", 0, TRUE); LED0 = 0; LED1 = 0; LED2 = 1; } LCDUpdate(); Tx_Packet = TRUE; } /*******************************************************************/ // Read New Start tickcount /*******************************************************************/ tick1 = MiWi_TickGet(); } // Check if Message Available if(MiApp_MessageAvailable()) { if(rxMessage.Payload[0] == EXIT_PKT) { MiApp_DiscardMessage(); MiApp_FlushTx(); MiApp_WriteData(ACK_PKT); MiApp_UnicastConnection(0, FALSE); Run_Demo = FALSE; LCDBacklightON(); LCDDisplay((char *)" Exiting.... Range Demo ", 0, TRUE); LCDBacklightOFF(); } else if(rxMessage.Payload[0] == RANGE_PKT) { // Get RSSI value from Recieved Packet rssi = rxMessage.PacketRSSI; // Disguard the Packet so can recieve next MiApp_DiscardMessage(); } else MiApp_DiscardMessage(); } // Check if Switch Pressed switch_val = ButtonPressed(); if((switch_val == SW0) || (switch_val == SW1)) { /*******************************************************************/ // Send Exit Demo Request Packet and exit Range Demo /*******************************************************************/ MiApp_FlushTx(); MiApp_WriteData(EXIT_PKT); MiApp_UnicastConnection(0, FALSE); LCDBacklightON(); LCDDisplay((char *)" Exiting.... Range Demo ", 0, TRUE); LCDBacklightOFF(); tick1 = MiWi_TickGet(); // Wait for ACK Packet while(Run_Demo) { if(MiApp_MessageAvailable()) { if(rxMessage.Payload[0] == ACK_PKT) Run_Demo = FALSE; MiApp_DiscardMessage(); } if ((MiWi_TickGetDiff(tick2,tick1) > (ONE_SECOND * EXIT_DEMO_TIMEOUT))) Run_Demo = FALSE; tick2 = MiWi_TickGet(); } } } }
void ProjectorScreen(void) { int statusScreen = 0; //etat initialise a 0, l'ecran est roulé // Commentaires de Timer 3 - 2016 par Samuel Proulx // La routine d'interruption pour cette fonction se trouve dans "drv_mrf_miwi_24j40.c" à la ligne 1879 // Nomenclature : (REGISTERNAME . REGISTERBIT) PROJECTOR_TRIS = 0; RCONbits.IPEN = 1; // Interrupt Priority Level Bit . 1 = Enable Priority Levels T3CON = 0b00011111; // Timer 3 Control Register . Voir fin de ce fichier TCLKCONbits.T1RUN = 1; TMR3 = 0xE000; //TMR3H + TMR3L . C'est la valeur du timer (0 à 65536) 0XE000 = 57344 IPR2bits.TMR3IP = 1; // Overflow Priority bit. 1 = High Priority INTCONbits.GIEH = 1; // INTCON = Interrupt Control Access Register . GIEH = Global Interrupt Enable Bit . 1 enables all. PIE2bits.TMR3IE = 0; // Overflow Interrupt Enable Bit . 1 enables PIR2bits.TMR3IF = 0;// Timer 3 Overflow Interrupt Flag Bit . 1 = register overflowed(MUST BE CLEARED IN SOFTWARE) LCD_BKLT = 1; while(true) { if(MiApp_MessageAvailable()) { if(rxMessage.Payload[0] == PROJECTOR_MOTOR_UP) { LED1 = 1 ; delay_ms(100); LED1 = 0 ; statusScreen = 0; pwm_value_high_time = 800; PIE2bits.TMR3IE = 1; } else if (rxMessage.Payload[0] == PROJECTOR_MOTOR_DOWN) { LED2 = 1 ; delay_ms(100); LED2 = 0 ; statusScreen = 1; pwm_value_high_time = 0; PIE2bits.TMR3IE = 1; } else if (rxMessage.Payload[0] == STATUS_SCREEN) { if(statusScreen == 0) { LED1 = 1; MiApp_FlushTx(); MiApp_WriteData(SCREEN_UP); MiApp_WriteData(myShortAddress.v[0]); MiApp_WriteData(myShortAddress.v[1]); MiApp_BroadcastPacket(false); delay_ms(500); LED1 = 0; } else { LED1 = 1; MiApp_FlushTx(); MiApp_WriteData(SCREEN_DOWN); MiApp_WriteData(myShortAddress.v[0]); MiApp_WriteData(myShortAddress.v[1]); MiApp_BroadcastPacket(false); delay_ms(500); LED1 = 0; } MiApp_DiscardMessage(); } } } }
void PingPongStateMachine() { BYTE i; WORD j, k; BYTE packagerssi; switch(case_value) { case 0: //Send 0x01 frame to initiate ping - pong test MiApp_FlushTx(); MiApp_WriteData(0x01); for(i = 0; i < sizeof(PingPongPacket); i++) { MiApp_WriteData(PingPongPacket[i]); } /*******************************************************************/ // Function MiApp_BroadcastPacket is used to broadcast a message // The only parameter is the boolean to indicate if we need to // secure the frame /*******************************************************************/ MiApp_BroadcastPacket(FALSE); PingPong_Count = 0; previous_state = 0; case_value = 8; LCDDisplay((char *)"Transmitting...", 0, TRUE); //Printf("\r\nIn case 0"); break; case 1: //Send 0x04 frames - indicating data transmission MiApp_FlushTx(); MiApp_WriteData(0x04); for(i = 0; i < sizeof(PingPongPacket); i++) { MiApp_WriteData(PingPongPacket[i]); } if(PingPong_Count != PingPong_Package) { MiApp_BroadcastPacket(FALSE); case_value = 1; PingPong_Count++; LED_1 ^= 1; LCDErase(); sprintf((char *)LCDText, (far rom char *) "Transmitting..."); sprintf((char *) &(LCDText[16]), (far rom char *) "Count: %d", PingPong_Count); LCDUpdate(); } else { Printf("\r\nSent Packet Count: "); PrintDec(PingPong_Package); PingPong_Count = 0; case_value = 2; } previous_state = 1; //Printf("\r\nIn case 1"); break; case 2: //Send 0x02 frame to get status response MiApp_FlushTx(); MiApp_WriteData(0x02); for(i = 0; i < sizeof(PingPongPacket); i++) { MiApp_WriteData(PingPongPacket[i]); } MiApp_BroadcastPacket(FALSE); previous_state = 2; case_value = 8; //Printf("\r\n In case 2"); break; case 3: //Ping Pong Receive Mode if(MiApp_MessageAvailable()) { if(rxMessage.Payload[0] == 0x01) { BYTE rssi = rxMessage.PacketRSSI; #if defined(MRF24J40) rssi = RSSIlookupTable[rssi]; #endif MiApp_DiscardMessage(); MiApp_FlushTx(); MiApp_WriteData(0x03); for(i = 0; i < sizeof(PingPongPacket); i++) { MiApp_WriteData(PingPongPacket[i]); } MiApp_BroadcastPacket(FALSE); PingPong_RxCount = 0; //LCDDisplay((char *)"Ping Pong Test Rcvng.. RSSI:", rssi, TRUE); LCDErase(); sprintf((char *)LCDText, (far rom char *) "Receiving.. "); #if defined(MRF24J40) sprintf((char *) &(LCDText[16]), (far rom char *) "RSSI (dB): --"); #else sprintf((char *) &(LCDText[16]), (far rom char *) "RSSI (dB): --"); #endif LCDUpdate(); packagerssi = rssi; } else if(rxMessage.Payload[0] == 0x04) { BYTE rssi = rxMessage.PacketRSSI; #if defined(MRF24J40) rssi = RSSIlookupTable[rssi]; #endif MiApp_DiscardMessage(); PingPong_RxCount++; previous_state = 3; LED_2 ^= 1; LCDErase(); sprintf((char *)LCDText, (far rom char *) "Receiving.. %d", PingPong_RxCount); #if defined(MRF24J40) sprintf((char *) &(LCDText[16]), (far rom char *) "RSSI (dB): -%d", packagerssi); #else sprintf((char *) &(LCDText[16]), (far rom char *) "RSSI (dB): -%d", packagerssi); #endif LCDUpdate(); case_value++; } else if(rxMessage.Payload[0] == 0x02) { Printf("\r\nReceived Packet Count:"); PrintDec(PingPong_RxCount); MiApp_DiscardMessage(); case_value = case_value + 2; } else { //Printf("\r\nIllegal packet received with payload first byte set to - "); //PrintDec(rxMessage.Payload[0]); MiApp_DiscardMessage(); } } //Printf("\r\n In case 3"); break; case 4: if(MiApp_MessageAvailable()) { if(rxMessage.Payload[0] == 0x04) { BYTE rssi = rxMessage.PacketRSSI; MiApp_DiscardMessage(); PingPong_RxCount++; LED_2 ^= 1; LCDErase(); sprintf((char *)LCDText, (far rom char *) "Receiving.. %d", PingPong_RxCount); #if defined(MRF24J40) sprintf((char *) &(LCDText[16]), (far rom char *) "RSSI (dB): -%d", packagerssi); #else sprintf((char *) &(LCDText[16]), (far rom char *) "RSSI (dB): %d", packagerssi); #endif LCDUpdate(); } else if(rxMessage.Payload[0] == 0x02) { Printf("\r\nReceived Packet Count:"); PrintDec(PingPong_RxCount); MiApp_DiscardMessage(); case_value++; } else { //Printf("\r\nIllegal packet received with payload first byte set to - "); //PrintDec(rxMessage.Payload[0]); //Printf("\r\n"); MiApp_DiscardMessage(); } } //Printf("\r\n In case 4"); break; case 5: MiApp_FlushTx(); MiApp_WriteData(0x03); for(i = 0; i < sizeof(PingPongPacket); i++) { MiApp_WriteData(PingPongPacket[i]); } MiApp_BroadcastPacket(FALSE); previous_state = 0; case_value = 8; //Printf("\r\n In case 5"); break; case 8: case_value = previous_state; DelayMs(20); if(MiApp_MessageAvailable()) { if(rxMessage.Payload[0] == 0x03) { case_value = (previous_state + 1); } if(rxMessage.Payload[0] == 0x01) { case_value = (previous_state + 1); } if(rxMessage.Payload[0] == 0x02) { case_value = 5; } MiApp_DiscardMessage(); } //Printf("\r\nIn case 8"); break; default: break; } //end of switch statement }
void run_star_demo(void) { #if defined(PROTOCOL_STAR) t1 = MiWi_TickGet(); LCDDisplay((char *)"Sleeping!!", 0, false); while(1) { t2 = MiWi_TickGet(); // Calculate the Time for Sleeping device if((MiWi_TickGetDiff(t2,t1) > (ONE_SECOND * 20))) { awake = true; #if !defined(EIGHT_BIT_WIRELESS_BOARD) LCD_BacklightON(); #endif MiApp_TransceiverPowerState(POWER_STATE_WAKEUP_DR); LCDDisplay((char *)"Woke Up!!!", 0, false); DELAY_ms(1000); STAR_DEMO_OPTIONS_MESSAGE (false); tt1 = MiWi_TickGet(); } while(awake) { tt2 = MiWi_TickGet(); if((MiWi_TickGetDiff(tt2,tt1) > (ONE_SECOND * 10))) { // The Indirect Message for a Sleeping RFD is stored in PAN CO // We periodically send Data Requests for the Indirect Message to // not loose a message. CheckForData(); tt1 = MiWi_TickGet(); } /*******************************************************************/ // Function MiApp_MessageAvailable returns a boolean to indicate if // a packet has been received by the transceiver. If a packet has // been received, all information will be stored in the rxFrame, // structure of RECEIVED_MESSAGE. /*******************************************************************/ if( MiApp_MessageAvailable()) { /*******************************************************************/ // If a packet has been received, update the information available // in rxMessage. /*******************************************************************/ DemoOutput_UpdateTxRx(TxNum, ++RxNum); DELAY_ms(2000); // Toggle LED2 to indicate receiving a packet. LED_2 ^= 1; /*******************************************************************/ // Function MiApp_DiscardMessage is used to release the current // received packet. // After calling this function, the stack can start to process the // next received frame /*******************************************************************/ MiApp_DiscardMessage(); /****************************************/ } 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. /*******************************************************************/ uint8_t PressedButton = ButtonPressed(); if ( PressedButton == 1 || PressedButton == 2) { uint8_t select_ed =0; bool update_ed = true; while(update_ed == true) { //User Selected Change end device LCD_Erase(); if (myConnectionIndex_in_PanCo == select_ed) { // if END_device displays itself , "me" is added in display to denote itself sprintf((char *)LCDText, (char*)"RB0:%02d-%02x%02x%02x-me",END_DEVICES_Short_Address[select_ed].connection_slot,END_DEVICES_Short_Address[select_ed].Address[0], END_DEVICES_Short_Address[select_ed].Address[1],END_DEVICES_Short_Address[select_ed].Address[2] ); } else { sprintf((char *)LCDText, (char*)"RB0:%02d-%02x%02x%02x",END_DEVICES_Short_Address[select_ed].connection_slot,END_DEVICES_Short_Address[select_ed].Address[0], END_DEVICES_Short_Address[select_ed].Address[1],END_DEVICES_Short_Address[select_ed].Address[2] ); } sprintf((char *)LCDText, (char*)"RB0:%02d-%02x%02x%02x",END_DEVICES_Short_Address[select_ed].connection_slot,END_DEVICES_Short_Address[select_ed].Address[0], END_DEVICES_Short_Address[select_ed].Address[1],END_DEVICES_Short_Address[select_ed].Address[2] ); sprintf((char *)&(LCDText[16]), (char*)"RB2: Change node"); LCD_Update(); chk_sel_status = true; bool sw_layer_ack_status , mac_ack_status; while(chk_sel_status) { uint8_t switch_val = ButtonPressed(); if(switch_val == 1) { update_ed = false; chk_sel_status = false; update_ed = false; // Star_User_Data is defined in star_demo.c // Its user data , in case of Star Network 60 bytes of // Data can be sent at a time from one END_DEVICE_TO_ANOTHER // Edx --> Pan CO --> EDy if (myConnectionIndex_in_PanCo == select_ed) { MiApp_FlushTx(); for (i = 0 ; i < 21 ; i++) { MiApp_WriteData(MiWi[(TxSynCount%6)][i]); } // IF on the demo , a END_Device displays its own Connection Detail // We unicast data packet to just PAN COR , No forwarding #if defined(ENABLE_SECURITY) mac_ack_status = MiApp_UnicastConnection (0, true); #else mac_ack_status = MiApp_UnicastConnection (0, false); #endif TxNum++; } else { // Data can be sent at a time from one END_DEVICE_TO_ANOTHER // Edx --> Pan CO --> EDy // To forward a Packet from one ED to another ED , the first 4 bytes should holding // a CMD and end dest device short address (3 bytes) MiApp_FlushTx(); MiApp_WriteData(CMD_FORWRD_PACKET); MiApp_WriteData(END_DEVICES_Short_Address[select_ed].Address[0]);// sending the first byte payload as the destination nodes MiApp_WriteData(END_DEVICES_Short_Address[select_ed].Address[1]);// sending the first byte payload as the destination nodes MiApp_WriteData(END_DEVICES_Short_Address[select_ed].Address[2]);// sending the first byte payload as the destination nodes for (i = 4 ; i < 25 ; i++) { MiApp_WriteData(MiWi[(TxSynCount%6)][i-4]); } #if defined(ENABLE_SECURITY) sw_layer_ack_status = MiApp_UnicastStar (true); #else sw_layer_ack_status = MiApp_UnicastStar (false); #endif #if defined(ENABLE_APP_LAYER_ACK) if (sw_layer_ack_status) { TxNum++; // Tx was successful } else { LCDDisplay((char *)"Data_Sending_Fail!!", 0, false); } #else TxNum++; #endif } } // end of switch_val == 1 else if(switch_val == 2) { if (select_ed > end_nodes-1) { select_ed = 0; } else { select_ed = select_ed+1; } chk_sel_status = false; } // end of switch_val == 2 } // end of chk_sel_status } // end of updating the LCD info STAR_DEMO_OPTIONS_MESSAGE (false); } // end of actions on button press } // end of check for user inputs (button press check) t3 = MiWi_TickGet(); if((MiWi_TickGetDiff(t3,t2) > (ONE_SECOND * 40))) { awake = false; #if !defined(EIGHT_BIT_WIRELESS_BOARD) LCD_BacklightOFF(); #endif MiApp_TransceiverPowerState(POWER_STATE_SLEEP); LCDDisplay((char *)"Sleeping!!!", 0, false); DELAY_ms(1000); t1 = t3; } if (lost_connection && !role) { MiApp_EstablishConnection(0xFF, CONN_MODE_DIRECT); lost_connection = false; } } // end of actions performed while node is awake } // end of while(1) #endif }
//----------------------------------------------------------------------------// void TaskScheduler(void) { Timer1Tick(); switch(EndDevStateMachine) { case 0: { if( MiApp_MessageAvailable()) { if((rxMessage.Payload[1] == 0x00)&&((rxMessage.Payload[3] == OutputStat))) { if(rxMessage.Payload[4] <= 16) { BaseTimeToTx = rxMessage.Payload[4]; } SwTimer0 = 0; LED_2 ^= 1; EndDevStateMachine = 1; } MiApp_DiscardMessage(); } } break; case 1: { if(SwTimer0 >= (_U08)myNodeNumber) { MyTemp = TemperatureRead(); MiApp_FlushTx(); MiApp_WriteData(' '); MiApp_WriteData(myNodeNumber); MiApp_WriteData(MyTrackingNumber); MiApp_WriteData(OutputStat); MiApp_WriteData(MyStat); MiApp_WriteData(MyTemp); MiApp_BroadcastPacket(FALSE); EndDevStateMachine = 2; } } break; case 2: { LED_1 ^= 1; EndDevStateMachine = 0; //ConsolePutROMString( (ROM char * const) " \r\n Temperature here:" ); //PrintDec(MyTemp); } break; case 3: { } break; default: break; } }
void WirelessTxRx(void) { Timer1Tick(); switch(EndDevStateMachine) { case 0: // recibe estado para relevadores y latencia de comunicacion { if( MiApp_MessageAvailable()) { if((rxMessage.Payload[1] == 0x00)&&((rxMessage.Payload[3] == OutputStat))) { BypassCounter = 0; if(rxMessage.Payload[4] <= 16) { //BaseTimeToTx = rxMessage.Payload[4]; TickScaler = rxMessage.Payload[4]; } j = (myNodeNumber-1)/8; j += 5; i = rxMessage.Payload[j]; j = (myNodeNumber-1)%8; if(QUERY_8BIT(i,j)) { RLY_STATUS = 1; } else { RLY_STATUS = 0; } ConsolePutROMString((ROM char *)"\r\n Req Stat:"); for(i=0;i<rxMessage.PayloadSize;i++) { PrintChar(rxMessage.Payload[i]); } SwTimer0 = 0; WriteTimer1(56161); Tick = 0; LED_2 ^= 1; EndDevStateMachine = 1; SwTimer3 = 0; // clear MIWIPRO STATUS TIMER } else { if((rxMessage.Payload[1] == 0x00)&&((rxMessage.Payload[3] == ListenDevices))) { ConsolePutROMString((ROM char *)"\r\n Listen Devices:"); for(i=0;i<rxMessage.PayloadSize;i++) { PrintChar(rxMessage.Payload[i]); } j = (myNodeNumber-1)/8; j += 4; i = rxMessage.Payload[j]; j = (myNodeNumber-1)%8; if(QUERY_8BIT(i,j)) { ConsolePutROMString((ROM char *)"\r\n Link stablished correctly"); RestartCounter = 0; } else { ConsolePutROMString((ROM char *)"\r\n NO Link stablished!!"); ++RestartCounter; } } else { if((rxMessage.Payload[1] == 0x00)&&((rxMessage.Payload[3] == CalibrationProcedure))) { ConsolePutROMString((ROM char *)"\r\n Temperature sensor calibration:"); //TemperatureCalibrationValue = rxMessage.Payload[5]; if((rxMessage.Payload[5] == MyTemp)||(rxMessage.Payload[5] == 0)) { TemperatureCalibrationValue = 0; } else { if(rxMessage.Payload[5] > MyTemp) // la temp de referencia es mayor a la leida { //TemperatureCalibrationValue = (rxMessage.Payload[5] - MyTemp) & 0x0F; } else // la temperatura leida es mayor a la temp de referencia { //TemperatureCalibrationValue = (MyTemp - rxMessage.Payload[5]) & 0x0F; //SET_8BIT(TemperatureCalibrationValue,7); } } //EEPROMWRITE(TemperatureCalibrationValue,0,1); } } } MiApp_DiscardMessage(); } } break; //-----------------------------------------------------------------------------// case 1: // envia estado y temperatura { if(SwTimer0 >= (_U08)myNodeNumber) { MyTemp = TemperatureRead(); MiApp_FlushTx(); MiApp_WriteData(' '); MiApp_WriteData(myNodeNumber); MiApp_WriteData(MyTrackingNumber); MiApp_WriteData(OutputStat); MiApp_WriteData(RLY_STATUS); MiApp_WriteData(MyTemp); MiApp_BroadcastPacket(FALSE); /* if(RLY_STATUS == 1) { RLY_1 = 1; } else { RLY_1 = 0; } */ //SDW_RLY_STATUS if(RLY_STATUS == 1) { if(SDW_RLY_STATUS == 1) { RLY_1 = 1; if(EEPROMCHG == 0) { i = 0x55; EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); //for(j=0;j<16;j++) //{ //myDevicesOutputStatus[j] = 0x55; //} //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); ConsolePutROMString((ROM char *)"\r\n Relay status updated in eeprom 55"); } EEPROMCHG = 1; } else { SDW_RLY_STATUS = 1; } } else { if(SDW_RLY_STATUS == 0) { RLY_1 = 0; if(EEPROMCHG == 1) { i = 0xAA; EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); EEPROMWRITE(&i,0,1); //for(j=0;j<16;j++) //{ //myDevicesOutputStatus[j] = 0xAA; //} //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); //EEPROMWRITE(&myDevicesOutputStatus,0,16); ConsolePutROMString((ROM char *)"\r\n Relay status updated in eeprom AA"); } EEPROMCHG = 0; } else { SDW_RLY_STATUS = 0; } } IRControl(); EndDevStateMachine = 2; } } break; //-----------------------------------------------------------------------------// case 2: { LED_1 ^= 1; EndDevStateMachine = 0; } break; //-----------------------------------------------------------------------------// default: { EndDevStateMachine = 0; } break; } }
int main(void) #endif { BYTE i, j; BYTE OperatingChannel = 0xFF; BYTE TxSynCount = 0; BYTE TxSynCount2 = 0; BYTE TxPersistFailures = 0; BOOL ReadyToSleep = FALSE; BYTE TxNum = 0; BYTE RxNum = 0; BYTE PressedButton = 0; /*******************************************************************/ // Initialize the system /*******************************************************************/ BoardInit(); ConsoleInit(); DemoOutput_Greeting(); /*********************************************************************/ // Function MiApp_ProtocolInit intialize the protocol stack. // The return value is a boolean to indicate the status of the // operation. // The only parameter indicates if Network Freezer should be invoked. // When Network Freezer feature is invoked, all previous network // configurations will be restored to the states before the // reset or power cycle // // In this example, we assume that the user wants to apply Network // Freezer feature and restore the network configuration if // button 1 is pressed and hold when powering up. /*********************************************************************/ if( (PUSH_BUTTON_1 == 0) && ( MiApp_ProtocolInit(TRUE) == TRUE ) ) { DemoOutput_NetworkFreezer(); while(PUSH_BUTTON_1 == 0 ); } else { /*********************************************************************/ // Function MiApp_ProtocolInit intialize the protocol stack. // The return value is a boolean to indicate the status of the // operation. // The only parameter indicates if Network Freezer should be invoked. // When Network Freezer feature is invoked, all previous network // configurations will be restored to the states before the // reset or power cycle // // In this example, we assume that the user wants to start from // scratch and ignore previous network configuration if button 1 // is released when powering up. /*********************************************************************/ MiApp_ProtocolInit(FALSE); DemoOutput_StartActiveScan(); while(1) { /*********************************************************************/ // 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. /*********************************************************************/ j = MiApp_SearchConnection(10, 0xFFFFFFFF); OperatingChannel = DemoOutput_ActiveScanResults(j); if( OperatingChannel != 0xFF ) { /*******************************************************************/ // Function MiApp_SetChannel assign the operation channel(frequency) // for the transceiver. Channels 0 - 31 has been defined for the // wireless protocols, but not all channels are valid for all // transceivers, depending on their hardware design, operating // frequency band, data rate and other RF parameters. Check the // definition of FULL_CHANNEL_MAP for details. /*******************************************************************/ MiApp_SetChannel(OperatingChannel); break; } DemoOutput_Rescan(); } /*********************************************************************/ // 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); /*******************************************************************/ // Function MiApp_EstablishConnection establish connections between // two devices. It has two input parameters: // The first parameter is the index of the target device in the // active scan table. It requires a MiApp_SearchConnection call // before hand. If seraching connection is not performed in // advance, user can apply 0xFF to the first parameter to // indicate that it is OK to establish connection with any // device. // The second parameter is the connection mode, either directly or // indirectly. Direct connection is a connection in the radio // range. All protocol stack support this connection mode. // Indirect connection is the connection out of radio range. // An indirect connection has to rely on other device to route // the messages between two connected devices. Indirect // connection is also called "Socket" connection in MiWi // Protocol. Since MiWi P2P protocol only handles connection // of one hop, indirect connection is not supported in MiWi // P2P protocol, but supported in other networking protocols. // Function MiApp_EstablishConnection returns the index of the // connected device in the connection table. If no connection // is established after predefined retry times // CONNECTION_RETRY_TIMES, it will return 0xFF. If multiple // connections have been established, it will return the one // of the indexes of the connected device. /*******************************************************************/ i = MiApp_EstablishConnection(0, CONN_MODE_DIRECT); DemoOutput_Connected(); } // Turn on LED 1 to indicate connection established LED_1 = 1; /*******************************************************************/ // Function DumpConnection is used to print out the content of the // P2P Connection Entry on the hyperterminal. It may be useful in // the debugging phase. // The only parameter of this function is the index of the // Connection Entry. The value of 0xFF means to print out all // valid Connection Entries; otherwise, the Connection Entry // of the input index will be printed out. /*******************************************************************/ DumpConnection(0xFF); 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 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; DemoOutput_UpdateTxRx(TxNum, ++RxNum); } else { /***********************************************************************/ // TxPersistFailures is the local variable to track the transmission // failure because no acknowledgement frame is received. Typically, // this is the indication of either very strong noise, or the PAN // has hopped to another channel. /***********************************************************************/ if( TxPersistFailures > 3 ) { DemoOutput_StartResync(); /*******************************************************************/ // Function MiApp_TransceiverPowerState is used to set the power state // of RF transceiver. There are three possible states: // - POWER_STATE_SLEEP Put transceiver into sleep // - POWER_STATE_WAKEUP Wake up the transceiver only // - POWER_STATE_WAKEUP_DR Wake up and send Data Request command /*******************************************************************/ MiApp_TransceiverPowerState(POWER_STATE_WAKEUP); /***********************************************************************/ // Function MiApp_ResyncConnection is used to synchronized connection // if one side of communication jumped to another channel, when // frequency agility is performed. Usually, this is done by the // sleeping device, since the sleeping device cannot hear the broadcast // of channel hopping command. // // The first parameter is the index of connection table for the peer // node, which we would like to resynchronize to. // The second parameter is the bit map of channels to be scanned /***********************************************************************/ MiApp_ResyncConnection(0, 0xFFFFFFFF); TxPersistFailures = 0; ReadyToSleep = FALSE; DemoOutput_EndResync(); } else { ReadyToSleep = TRUE; } /*******************************************************************/ // If Data Request command and data transmision has been handled, // as the RFD device, it is time to consider put both the radio and // MCU into sleep mode to conserve power. /*******************************************************************/ if( ReadyToSleep ) { ReadyToSleep = FALSE; /*******************************************************************/ // Function MiApp_TransceiverPowerState is used to set the power // state of RF transceiver. There are three possible states: // - POWER_STATE_SLEEP Put transceiver into sleep // - POWER_STATE_WAKEUP Wake up the transceiver only // - POWER_STATE_WAKEUP_DR Wake up and send Data Request // command /*******************************************************************/ MiApp_TransceiverPowerState(POWER_STATE_SLEEP); /*******************************************************************/ // Prepare the condition to wake up the MCU. The MCU can either be // waken up by the timeout of watch dog timer (Time Synchronization // off), timeout of counter with external 32KHz crystal (Time // Synchronization on), or by the pin change notification interrupt // by pushing the button. MCU handling of sleep preparing for // different demo boards can be found in HardwareProfile.c /*******************************************************************/ PrepareWakeup(); // Put MCU into sleep mode Sleep(); /*******************************************************************/ // Handling the wakeup procedure. The steps differ for different // demo boards and families of MCUs. Details can be found in // HardwareProfile.c /*******************************************************************/ AfterWakeup(); PressedButton = ButtonPressed(); /*******************************************************************/ // Function MiApp_TransceiverPowerState is used to set the power // state of RF transceiver. There are three possible states: // - POWER_STATE_SLEEP Put transceiver into sleep // - POWER_STATE_WAKEUP Wake up the transceiver only // - POWER_STATE_WAKEUP_DR Wake up and send Data Request // command /*******************************************************************/ if( MiApp_TransceiverPowerState(POWER_STATE_WAKEUP_DR) > SUCCESS ) { TxPersistFailures++; DemoOutput_ConnectionLost(TxPersistFailures); } else { if( TxPersistFailures > 0 ) { DemoOutput_UpdateTxRx(TxNum, RxNum); } TxPersistFailures = 0; } switch( PressedButton ) { case 1: /*******************************************************************/ // Button 1 pressed. // First use MiApp_FlushTx to reset the Transmit buffer. Then fill // the TX buffer by calling function MiApp_WriteData /*******************************************************************/ MiApp_FlushTx(); for(i = 0; i < 21; i++) { MiApp_WriteData(MiWi[(TxSynCount%6)][i]); } TxSynCount++; /*******************************************************************/ // Function MiApp_BroadcastPacket is used to broadcast a message // The only parameter is the boolean to indicate if we need to // secure the message /*******************************************************************/ MiApp_BroadcastPacket(FALSE); DemoOutput_UpdateTxRx(++TxNum, RxNum); break; case 2: /*******************************************************************/ // Button 2 pressed. // First use MiApp_FlushTx to reset the Transmit buffer. Then fill // the TX buffer by calling function MiApp_WriteData /*******************************************************************/ MiApp_FlushTx(); for(i = 0; i < 11; i++) { MiApp_WriteData(DE[(TxSynCount2%6)][i]); } TxSynCount2++; /*******************************************************************/ // 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 Connection Entry in 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; } } } } }