//***************************************************************************** // // This function implements the auto channel change policy. // //***************************************************************************** static void CheckChangeChannel(void) { #ifdef FREQUENCY_AGILITY int8_t ucdBm, ucInARow = 0; unsigned long ulLoop; // // Clear out our signal quality array. // memset(g_cSample, 0x0, SSIZE); // // Poll the signal quality several times. // for (ulLoop = 0; ulLoop < SSIZE; ulLoop++) { // // Exit early if we need to service an app frame. // if (g_ucPeerFrameSem || g_ucJoinSem) { return; } // // Get the signal quality from the radio. // NWK_DELAY(1); SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RSSI, (void *)&ucdBm); g_cSample[ulLoop] = ucdBm; // // Is the noise level above our threshold? // if (ucdBm > INTERFERENCE_THRESHOLD_DBM) { // // Yes - increment the counter we use to determine how long the // signal quality has been unacceptable and check to see if we've // reached the point where we perform an automatic channel change. // if (++ucInARow == IN_A_ROW) { // // Signal quality has been too bad for too long so try the next // channel. // ChangeChannel(); break; } } else { // // Signal quality is fine so clear the counter we use to determine // how long the quality has been bad. // ucInARow = 0; } } #endif return; }
//***************************************************************************** // // 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(); } }
AM_UINT CAudioCodecPcm::decode(AM_U8 *input, AM_UINT inDataSize, AM_U8 *output, AM_UINT *outDataSize) { return ChangeChannel(input, output, inDataSize, outDataSize); }