//**************************************************************************** // //! \brief Connecting to a WLAN Accesspoint //! //! This function connects to the required AP (SSID_NAME) with Security //! parameters specified in te form of macros at the top of this file //! //! \param None //! //! \return 0 on success else error code //! //! \warning If the WLAN connection fails or we don't aquire an IP //! address, It will be stuck in this function forever. // //**************************************************************************** long WlanConnect() { long lRetVal = -1; SlSecParams_t secParams; secParams.Key = SECURITY_KEY; secParams.KeyLen = strlen(SECURITY_KEY); secParams.Type = SECURITY_TYPE; lRetVal = sl_WlanConnect(SSID_NAME,strlen(SSID_NAME),0,&secParams,0); ASSERT_ON_ERROR(lRetVal); while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus))) { // Toggle LEDs to Indicate Connection Progress GPIO_IF_LedOff(MCU_IP_ALLOC_IND); MAP_UtilsDelay(800000); GPIO_IF_LedOn(MCU_IP_ALLOC_IND); MAP_UtilsDelay(800000); } // // Red LED on to indicate AP connection // GPIO_IF_LedOn(MCU_IP_ALLOC_IND); return SUCCESS; }
//***************************************************************************** // //! The interrupt handler for the watchdog timer //! //! \param None //! //! \return None // //***************************************************************************** void WatchdogIntHandler(void) { // // If we have been told to stop feeding the watchdog, return immediately // without clearing the interrupt. This will cause the system to reset // next time the watchdog interrupt fires. // if(!g_bFeedWatchdog) { return; } // // After 10 interrupts, switch On LED6 to indicate system reset // and don't clear watchdog interrupt which causes system reset // if(g_ulWatchdogCycles >= 10) { GPIO_IF_LedOn(MCU_RED_LED_GPIO); MAP_UtilsDelay(800000); return; } // // Clear the watchdog interrupt. // MAP_WatchdogIntClear(WDT_BASE); GPIO_IF_LedOn(MCU_RED_LED_GPIO); MAP_UtilsDelay(800000); GPIO_IF_LedOff(MCU_RED_LED_GPIO); // // Increment our interrupt counter. // g_ulWatchdogCycles++; }
//**************************************************************************** // //! \brief Connecting to a WLAN Accesspoint //! //! This function connects to the required AP (SSID_NAME) with Security //! parameters specified in te form of macros at the top of this file //! //! \param None //! //! \return 0 on success else error code //! //! \warning If the WLAN connection fails or we don't aquire an IP //! address, It will be stuck in this function forever. // //**************************************************************************** static long WlanConnect() { SlSecParams_t secParams = {0}; long lRetVal = 0; secParams.Key = SECURITY_KEY; secParams.KeyLen = strlen(SECURITY_KEY); secParams.Type = SECURITY_TYPE; lRetVal = sl_WlanConnect(SSID_NAME, strlen(SSID_NAME), 0, &secParams, 0); ASSERT_ON_ERROR(lRetVal); // Wait for WLAN Event while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus))) { // Toggle LEDs to Indicate Connection Progress _SlNonOsMainLoopTask(); GPIO_IF_LedOff(MCU_IP_ALLOC_IND); MAP_UtilsDelay(800000); _SlNonOsMainLoopTask(); GPIO_IF_LedOn(MCU_IP_ALLOC_IND); MAP_UtilsDelay(800000); } return SUCCESS; }
//***************************************************************************** // //! Check the device mode and switch to STATION(STA) mode //! restart the NWP to activate STATION mode //! //! \param iMode (device mode) //! //! \return None // //***************************************************************************** void SwitchToStaMode(int iMode) { if(iMode != ROLE_STA) { sl_WlanSetMode(ROLE_STA); MAP_UtilsDelay(80000); sl_Stop(10); MAP_UtilsDelay(80000); sl_Start(0,0,0); } }
//***************************************************************************** // //! Speaker Routine //! //! \param pvParameters Parameters to the task's entry function //! //! \return None // //***************************************************************************** void Speaker( void *pvParameters ) { long iRetVal = -1; while(1) { while(g_ucSpkrStartFlag || g_loopback) { if(!g_loopback) { fd_set readfds,writefds; struct SlTimeval_t tv; FD_ZERO(&readfds); FD_ZERO(&writefds); FD_SET(g_UdpSock.iSockDesc,&readfds); FD_SET(g_UdpSock.iSockDesc,&writefds); tv.tv_sec = 0; tv.tv_usec = 2000000; int rv = select(g_UdpSock.iSockDesc, &readfds, NULL, NULL, &tv); if(rv <= 0) { continue; } if (FD_ISSET(g_UdpSock.iSockDesc, &readfds) ) { g_iRetVal = recvfrom(g_UdpSock.iSockDesc, (char*)(speaker_data),\ PACKET_SIZE*16, 0,\ (struct sockaddr *)&(g_UdpSock.Client),\ (SlSocklen_t*)&(g_UdpSock.iClientLength)); } if(g_iRetVal>0) { iRetVal = FillBuffer(pPlayBuffer, (unsigned char*)speaker_data,\ g_iRetVal); if(iRetVal < 0) { UART_PRINT("Unable to fill buffer"); LOOP_FOREVER(); } } } else { MAP_UtilsDelay(1000); } } MAP_UtilsDelay(1000); } }
//**************************************************************************** // //! Enter the HIBernate mode configuring the wakeup timer //! //! \param none //! //! This function //! 1. Sets up the wakeup RTC timer //! 2. Enables the RTC //! 3. Enters into HIBernate //! //! \return None. // //**************************************************************************** void EnterHIBernate() { #define SLOW_CLK_FREQ (32*1024) // // Configure the HIB module RTC wake time // MAP_PRCMHibernateIntervalSet(5 * SLOW_CLK_FREQ); // // Enable the HIB RTC // MAP_PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR); DBG_PRINT("HIB: Entering HIBernate...\n\r"); MAP_UtilsDelay(80000); // // powering down SPI Flash to save power // Utils_SpiFlashDeepPowerDown(); // // Enter HIBernate mode // MAP_PRCMHibernateEnter(); }
//***************************************************************************** // //! Tx_continuous //! //! This function //! 1. Function for sending out pinging data on the //! channel given by the user. //! //! \return none // //***************************************************************************** static int Tx_continuous(int iChannel,SlRateIndex_e rate,int iNumberOfPackets, int iTxPowerLevel,long dIntervalMiliSec) { int iSoc; long lRetVal = -1; long ulIndex; iSoc = sl_Socket(SL_AF_RF,SL_SOCK_RAW,iChannel); ASSERT_ON_ERROR(iSoc); UART_PRINT("Transmitting data...\r\n"); for(ulIndex = 0 ; ulIndex < iNumberOfPackets ; ulIndex++) { lRetVal = sl_Send(iSoc,RawData_Ping,sizeof(RawData_Ping),\ SL_RAW_RF_TX_PARAMS(iChannel, rate, iTxPowerLevel, PREAMBLE)); if(lRetVal < 0) { sl_Close(iSoc); ASSERT_ON_ERROR(lRetVal); } //Sleep(dIntervalMiliSec); MAP_UtilsDelay(4000000); } lRetVal = sl_Close(iSoc); ASSERT_ON_ERROR(lRetVal); UART_PRINT("Transmission complete.\r\n"); return SUCCESS; }
//**************************************************************************** // //! Implements Sleep followed by wakeup using WDT timeout //! //! \param none //! //! This function //! 1. Implements Sleep followed by wakeup using WDT //! //! \return None. // //**************************************************************************** void PerformPRCMSleepWDTWakeup() { // // Initialize the WDT // WDT_IF_Init(AppWDTCallBackHandler, (4 * SYS_CLK)); // // Enable the Sleep Clock // MAP_PRCMPeripheralClkEnable(PRCM_WDT, PRCM_SLP_MODE_CLK); // // Enter SLEEP...WaitForInterrupt ARM intrinsic // DBG_PRINT("WDT_SLEEP: Entering Sleep\n\r"); MAP_UtilsDelay(80000); MAP_PRCMSleepEnter(); DBG_PRINT("WDT_SLEEP: Exiting Sleep\n\r"); // // Disable the Sleep Clock // MAP_PRCMPeripheralClkDisable(PRCM_WDT, PRCM_SLP_MODE_CLK); // // Deinitialize the WDT // WDT_IF_DeInit(); // // PowerOff WDT // MAP_PRCMPeripheralClkDisable(PRCM_WDT, PRCM_RUN_MODE_CLK); }
//**************************************************************************** // //! Reboot the MCU by requesting hibernate for a short duration //! //! \return None // //**************************************************************************** static void RebootMCU() { // // Configure hibernate RTC wakeup // PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR); // // Delay loop // MAP_UtilsDelay(8000000); // // Set wake up time // PRCMHibernateIntervalSet(330); // // Request hibernate // PRCMHibernateEnter(); // // Control should never reach here // while(1) { } }
void HibernateWatchdog() { MAP_PRCMHibernateIntervalSet(SLOW_CLK_FREQ); MAP_PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR); DBG_PRINT("WDT: Entering HIBernate...\n\r"); MAP_UtilsDelay(80000); MAP_PRCMHibernateEnter(); }
//the dsp main thread void DSP( void* pvParameters ) { while (1) { if (gb_DSPprocessing) { DSPConvertUC2F32(gDSP_DSPInstance); DSPCalculateFFT(gDSP_DSPInstance); gb_DSPprocessing = FALSE; } MAP_UtilsDelay(1000); } }
void receiveMessage(){ int i; unsigned long ulStatus; //Get status of UART interrupt ulStatus = MAP_UARTIntStatus(UARTA1_BASE, true); UARTIntClear(UARTA1_BASE, ulStatus ); //Create a small delay to ensure that the hardware functions correctly MAP_UtilsDelay(80000); for(i = 0; i < 8; i++){ //Get the character from UART1 register MessageRx[i] = MAP_UARTCharGet(UARTA1_BASE); MAP_UtilsDelay(80000); //Draw the received char on the OLED drawChar(6*i, 64, MessageRx[i], WHITE, BLACK, 0x01); MAP_UtilsDelay(80000); } UARTIntEnable(UARTA1_BASE, UART_INT_RX|UART_INT_RT); }
void WeatherForecastGet(int iSockID, cInt8 * acSendBuff,cInt8 * acRecvbuff) { int iTXStatus; int iRXDataStatus; char* pcBufLocation; const char prefixBuffer[] = "GET /data/2.5/forecast?"; const char postBuffer[] = "&mode=xml&units=metric HTTP/1.1\r\nHost: api.openweathermap.org\r\nAccept: */"; const char postBuffer2[] = "*\r\n\r\n"; memset(acRecvbuff, 0, RX_BUFF_SIZE); // Puts together the HTTP GET string. // pcBufLocation = acSendBuff; strcpy(pcBufLocation, prefixBuffer); pcBufLocation += strlen(prefixBuffer); #ifdef LOCATION_GPS int l_size; l_size = sprintf(pcBufLocation,"lat=%.6f&lon=%.6f",LOCATION_GPS_LAT,LOCATION_GPS_LON); pcBufLocation += l_size; #else strcpy(pcBufLocation,"q="); pcBufLocation += strlen("q="); strcpy(pcBufLocation,LOCATION_CITY_NAME); pcBufLocation += strlen(LOCATION_CITY_NAME); #endif strcpy(pcBufLocation, postBuffer); pcBufLocation += strlen(postBuffer); strcpy(pcBufLocation, postBuffer2); // // Send the HTTP GET string to the open TCP/IP socket. // DBG_PRINT("Sent HTTP GET request. \n\r"); iTXStatus = sl_Send(iSockID, acSendBuff, strlen(acSendBuff), 0); MAP_UtilsDelay(DELAY_CLK_1_SEK *3); DBG_PRINT("Return value: %d \n\r", iTXStatus); // // Store the reply from the server in buffer. // DBG_PRINT("Received HTTP GET response data. \n\r"); iRXDataStatus = sl_Recv(iSockID, &acRecvbuff[0], RX_BUFF_SIZE, 0); DBG_PRINT("Return value: %d \n\r", iRXDataStatus); acRecvbuff[RX_BUFF_SIZE - 1] = 0; DBG_PRINT(acRecvbuff); }
//***************************************************************************** // //! Configures the pins as GPIOs and peroidically toggles the lines //! //! \param None //! //! This function //! 1. Configures 3 lines connected to LEDs as GPIO //! 2. Sets up the GPIO pins as output //! 3. Periodically toggles each LED one by one by toggling the GPIO line //! //! \return None // //***************************************************************************** void LEDBlinkyRoutine() { // // Toggle the lines initially to turn off the LEDs. // The values driven are as required by the LEDs on the LP. // GPIO_IF_LedOff(MCU_ALL_LED_IND); while(1) { // // Alternately toggle hi-low each of the GPIOs // to switch the corresponding LED on/off. // MAP_UtilsDelay(8000000); GPIO_IF_LedOn(MCU_RED_LED_GPIO); MAP_UtilsDelay(8000000); GPIO_IF_LedOff(MCU_RED_LED_GPIO); MAP_UtilsDelay(8000000); GPIO_IF_LedOn(MCU_ORANGE_LED_GPIO); MAP_UtilsDelay(8000000); GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO); MAP_UtilsDelay(8000000); GPIO_IF_LedOn(MCU_GREEN_LED_GPIO); MAP_UtilsDelay(8000000); GPIO_IF_LedOff(MCU_GREEN_LED_GPIO); } }
//***************************************************************************** // //! \brief Connecting to a WLAN Accesspoint using SmartConfig provisioning //! //! Enables SmartConfig provisioning for adding a new connection profile //! to CC3200. Since we have set the connection policy to Auto, once //! SmartConfig is complete, CC3200 will connect automatically to the new //! connection profile added by smartConfig. //! //! \param[in] None //! //! \return None //! //! \note //! //! \warning If the WLAN connection fails or we don't //! acquire an IP address, We will be stuck in this //! function forever. // //***************************************************************************** int SmartConfigConnect() { unsigned char policyVal; long lRetVal = -1; // Clear all profiles // This is of course not a must, it is used in this example to make sure // we will connect to the new profile added by SmartConfig // lRetVal = sl_WlanProfileDel(WLAN_DEL_ALL_PROFILES); ASSERT_ON_ERROR(lRetVal); //set AUTO policy lRetVal = sl_WlanPolicySet( SL_POLICY_CONNECTION, SL_CONNECTION_POLICY(1,0,0,0,1), &policyVal, 1 /*PolicyValLen*/); ASSERT_ON_ERROR(lRetVal); // Start SmartConfig // This example uses the unsecured SmartConfig method // lRetVal = sl_WlanSmartConfigStart(0, /*groupIdBitmask*/ SMART_CONFIG_CIPHER_NONE, /*cipher*/ 0, /*publicKeyLen*/ 0, /*group1KeyLen*/ 0, /*group2KeyLen */ NULL, /*publicKey */ NULL, /*group1Key */ NULL); /*group2Key*/ ASSERT_ON_ERROR(lRetVal); // Wait for WLAN Event while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus))) { _SlNonOsMainLoopTask(); } // // Turn ON the RED LED to indicate connection success // GPIO_IF_LedOn(MCU_RED_LED_GPIO); //wait for few moments MAP_UtilsDelay(80000000); //reset to default AUTO policy lRetVal = sl_WlanPolicySet( SL_POLICY_CONNECTION, SL_CONNECTION_POLICY(1,0,0,0,0), &policyVal, 1 /*PolicyValLen*/); ASSERT_ON_ERROR(lRetVal); return SUCCESS; }
void HibernateEnter() { // // Enter debugger info // DBG_PRINT("HIB: Entering HIBernate...\n\r"); MAP_UtilsDelay(80000); // // Enter HIBernate mode // MAP_PRCMHibernateEnter(); }
//***************************************************************************** // //! ReadAccSensor //! //! @brief Read Accelerometer Data from Sensor //! //! //! @return none //! //! // //***************************************************************************** void ReadAccSensor() { //Define Accelerometer Threshold to Detect Movement const short csAccThreshold = 5; signed char cAccXT1,cAccYT1,cAccZT1; signed char cAccXT2,cAccYT2,cAccZT2; signed short sDelAccX, sDelAccY, sDelAccZ; int iRet = -1; int iCount = 0; iRet = BMA222ReadNew(&cAccXT1, &cAccYT1, &cAccZT1); if(iRet) { //In case of error/ No New Data return return; } for(iCount=0;iCount<2;iCount++) { MAP_UtilsDelay((90*80*1000)); //30msec iRet = BMA222ReadNew(&cAccXT2, &cAccYT2, &cAccZT2); if(iRet) { //In case of error/ No New Data continue iRet = 0; continue; } else { sDelAccX = abs((signed short)cAccXT2 - (signed short)cAccXT1); sDelAccY = abs((signed short)cAccYT2 - (signed short)cAccYT1); sDelAccZ = abs((signed short)cAccZT2 - (signed short)cAccZT1); //Compare with Pre defined Threshold if(sDelAccX > csAccThreshold || sDelAccY > csAccThreshold || sDelAccZ > csAccThreshold) { //Device Movement Detected, Break and Return g_ucDryerRunning = 1; break; } else { //Device Movement Static g_ucDryerRunning = 0; } } } }
//**************************************************************************** // //! Implements Sleep followed by wakeup using GPT timeout //! //! \param none //! //! This function //! 1. Implements Sleep followed by wakeup using GPT //! //! \return None. // //**************************************************************************** void PerformPRCMSleepGPTWakeup() { // // Power On the GPT along with sleep clock // MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK); // // Initialize the GPT as One Shot timer // Timer_IF_Init(PRCM_TIMERA0, TIMERA0_BASE, TIMER_CFG_ONE_SHOT, TIMER_BOTH, 0); Timer_IF_IntSetup(TIMERA0_BASE, TIMER_BOTH, AppGPTCallBackHandler); // // Start timer with value in mSec // Timer_IF_Start(TIMERA0_BASE, TIMER_BOTH, 4000); // // Enable the Sleep Clock // MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_SLP_MODE_CLK); // // Enter SLEEP...WaitForInterrupt ARM intrinsic // DBG_PRINT("GPT_SLEEP: Entering Sleep\n\r"); MAP_UtilsDelay(80000); MAP_PRCMSleepEnter(); DBG_PRINT("GPT_SLEEP: Exiting Sleep\n\r"); // // Disable the Sleep Clock // MAP_PRCMPeripheralClkDisable(PRCM_TIMERA0, PRCM_SLP_MODE_CLK); // // Deinitialize the GPT // Timer_IF_Stop(TIMERA0_BASE, TIMER_BOTH); Timer_IF_DeInit(TIMERA0_BASE, TIMER_BOTH); // // PowerOff GPT // MAP_PRCMPeripheralClkDisable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK); }
void CC3200Helpers_HibernateNowFor(unsigned long dwSeconds, char flStopSL) { unsigned long long qwTicks = dwSeconds; qwTicks *= SLOW_CLK_FREQ; MAP_PRCMHibernateIntervalSet(qwTicks); MAP_PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR); MAP_UtilsDelay(80000); if ( flStopSL ) { sl_WlanDisconnect(); sl_Stop(0); } MAP_SPICSDisable(SSPI_BASE); MAP_SPICSEnable(SSPI_BASE); MAP_SPIDataPut(SSPI_BASE, 0xB9); // deep power down MAP_SPICSDisable(SSPI_BASE); MAP_PRCMHibernateEnter(); }
//***************************************************************************** // //! mDNS_Task function //! //! \param None //! //! \return None //! //***************************************************************************** void mDNS_Task() { int lRetValmDNS; unsigned int pAddr; unsigned long usPort; unsigned short ulTextLen = 200; char cText[201]; //UnRegister mDNS Service if done Previously lRetValmDNS = sl_NetAppMDNSUnRegisterService((signed char *)CC3200_MDNS_NAME, strlen(CC3200_MDNS_NAME)); while(1) { lRetValmDNS = 1; //Read mDNS service. while(lRetValmDNS) { ulTextLen = 200; lRetValmDNS = sl_NetAppDnsGetHostByService((signed char *) \ CC3200_MDNS_NAME, strlen((const char *)CC3200_MDNS_NAME), SL_AF_INET,(unsigned long *)&pAddr,&usPort, &ulTextLen,(signed char *)&cText[0]); } if(lRetValmDNS == 0 && (pAddr!=INVALID_CLIENT_ADDRESS) && \ (pAddr!=g_uiIpAddress)) { //Speaker Detected - Add Client g_UdpSock.Client.sin_family = AF_INET; g_UdpSock.Client.sin_addr.s_addr = htonl(pAddr); g_UdpSock.Client.sin_port = htons(usPort); g_UdpSock.iClientLength = sizeof(g_UdpSock.Client); g_loopback = 0; } MAP_UtilsDelay(80*1000*100); } }
static void wlan_scan() { unsigned char ucpolicyOpt; union { unsigned char ucPolicy[4]; unsigned int uiPolicyLen; } policyVal; ucpolicyOpt = SL_CONNECTION_POLICY(0, 0, 0, 0,0); sl_WlanPolicySet(SL_POLICY_CONNECTION , ucpolicyOpt, NULL, 0); ucpolicyOpt = SL_SCAN_POLICY(1); policyVal.uiPolicyLen = 10; sl_WlanPolicySet(SL_POLICY_SCAN , ucpolicyOpt, (unsigned char*)(policyVal.ucPolicy), sizeof(policyVal)); MAP_UtilsDelay(8000000); Sl_WlanNetworkEntry_t netEntries[10]; _i16 resultsCount = sl_WlanGetNetworkList(0,10,&netEntries[0]); for (int i=0; i< resultsCount; i++) UART_PRINT("ssid: %s\trssi: %d\tsec-t: %u\r\n",netEntries[i].ssid, netEntries[i].rssi, netEntries[i].sec_type); }
//**************************************************************************** // //! Demonstrates the controlling of LED brightness using PWM //! //! \param none //! //! This function //! 1. Pinmux the GPIOs that drive LEDs to PWM mode. //! 2. Initializes the timer as PWM. //! 3. Loops to continuously change the PWM value and hence brightness //! of LEDs. //! //! \return None. // //**************************************************************************** void main() { int iLoopCnt; // // Board Initialisation // BoardInit(); // // Configure the pinmux settings for the peripherals exercised // PinMuxConfig(); // // Initialize the PWMs used for driving the LEDs // InitPWMModules(); while(1) { // // RYB - Update the duty cycle of the corresponding timers. // This changes the brightness of the LEDs appropriately. // The timers used are as per LP schematics. // for(iLoopCnt = 0; iLoopCnt < 255; iLoopCnt++) { UpdateDutyCycle(TIMERA2_BASE, TIMER_B, iLoopCnt); UpdateDutyCycle(TIMERA3_BASE, TIMER_B, iLoopCnt); UpdateDutyCycle(TIMERA3_BASE, TIMER_A, iLoopCnt); MAP_UtilsDelay(800000); } } // // De-Init peripherals - will not reach here... // //DeInitPWMModules(); }
//***************************************************************************** // //! \brief introduce required delay to manage desired udp tx rate //! //! \param uiTrafficRate is desired udp tx rate in KBps. //! \param uiMsgSize is the size of each udp tx packet in Bytes. //! //! \return none //! //***************************************************************************** void ManageDelay(unsigned int uiTrafficRate, unsigned int uiMsgSize) { if(g_ucIsTrafficDelayCal == 0) { g_ullTrafficDelay = ((((1000 * (unsigned long long)uiMsgSize)* 80000)/ ((uiTrafficRate * 1024)*6) )); if(g_ullTrafficDelay <= 10840) { g_ullTrafficDelay = 0; } else { // Delay adjustment considering code execution time (based on test) g_ullTrafficDelay -= 10840; } // flag indicating the delay has been calculated would not need // recalculation. g_ucIsTrafficDelayCal = 1; } MAP_UtilsDelay(g_ullTrafficDelay); }
void launchpad_init(void){ long lRetVal = -1; PinConfigSet(PIN_58, PIN_STRENGTH_2MA | PIN_STRENGTH_4MA, PIN_TYPE_STD_PD); GPIO_IF_LedConfigure(LED1|LED2|LED3); GPIO_IF_LedOff(MCU_ALL_LED_IND); MAP_UtilsDelay(8000000); GPIO_IF_LedOn(MCU_GREEN_LED_GPIO); Report ("Initialize I2C..."); // // I2C Init // lRetVal = I2C_IF_Open(I2C_MASTER_MODE_FST); if(lRetVal < 0) { Report ("Fail!\r\n"); while(1); } Report ("Success\r\n"); }
int HDC1050::get_tempature_and_humidity(HDC1050::reading &measurement) { // execute pointer write transaction at 0x00 int rc = I2C_IF_Write(DEVICE_ADDRESS,0 /* device address*/, 1 /* bytes to read */, 0 /*no stop bit */); // wait at least 6.5 milliseconds - every 1000 ticks is 12.5 us MAP_UtilsDelay(10000000); static uint8_t temperature[2]; static uint8_t humidity[2]; uint32_t temp = 0; uint32_t hum = 0; // read I2C_IF_Read(DEVICE_ADDRESS + Registers8::temperature, &temperature[0], 2); I2C_IF_Read(DEVICE_ADDRESS + Registers8::humidity , &humidity[0], 2); // process readings temp = temperature[1]; temp = temp << 4; temp += temperature[0]; temp = temp * 165 - 40; temp = temp << 16; measurement.temperature = temp; // celsius hum = humidity[1]; hum *= 100; hum = hum << 16; measurement.humidity = hum; // relative humidty as percentage // todo: check for nack return 0; }
//***************************************************************************** // //! Main Function // //***************************************************************************** int main() { // // Initialize Board configurations // BoardInit(); // // Pinmux for UART // PinMuxConfig(); // // Configuring UART // InitTerm(); // // Display Application Banner // DisplayBanner(APP_NAME); // // Enable pull down // MAP_PinConfigSet(PIN_05,PIN_TYPE_STD_PD,PIN_STRENGTH_6MA); // // Register timer interrupt hander // MAP_TimerIntRegister(TIMERA2_BASE,TIMER_A,TimerIntHandler); // // Configure the timer in edge count mode // MAP_TimerConfigure(TIMERA2_BASE, (TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_CAP_TIME)); // // Set the detection edge // MAP_TimerControlEvent(TIMERA2_BASE,TIMER_A,TIMER_EVENT_POS_EDGE); // // Set the reload value // MAP_TimerLoadSet(TIMERA2_BASE,TIMER_A,0xffff); // // Enable capture event interrupt // MAP_TimerIntEnable(TIMERA2_BASE,TIMER_CAPA_EVENT); // // Enable Timer // MAP_TimerEnable(TIMERA2_BASE,TIMER_A); while(1) { // // Report the calculate frequency // Report("Frequency : %d Hz\n\n\r",g_ulFreq); // // Delay loop // MAP_UtilsDelay(80000000/5); } }
void Microphone( void *pvParameters ) { long lRetVal = -1; #ifdef MULTICAST //Wait for Network Connection while((!IS_IP_ACQUIRED(g_ulStatus))) { } #endif //MULTICAST while(1) { while(g_ucMicStartFlag || g_loopback) { int iBufferFilled = 0; iBufferFilled = GetBufferSize(pRecordBuffer); if(iBufferFilled >= (2*PACKET_SIZE)) { if(!g_loopback) { #ifndef MULTICAST lRetVal = sendto(g_UdpSock.iSockDesc, \ (char*)(pRecordBuffer->pucReadPtr),PACKET_SIZE,\ 0,(struct sockaddr*)&(g_UdpSock.Client),\ sizeof(g_UdpSock.Client)); if(lRetVal < 0) { UART_PRINT("Unable to send data\n\r"); LOOP_FOREVER(); } #else //MULTICAST lRetVal = SendMulticastPacket(); if(lRetVal < 0) { UART_PRINT("Unable to send data\n\r"); LOOP_FOREVER(); } #endif //MULTICAST } else { lRetVal = FillBuffer(pPlayBuffer,\ (unsigned char*)(pRecordBuffer->pucReadPtr), \ PACKET_SIZE); if(lRetVal < 0) { UART_PRINT("Unable to fill buffer\n\r"); } g_iReceiveCount++; } UpdateReadPtr(pRecordBuffer, PACKET_SIZE); g_iSentCount++; } } MAP_UtilsDelay(1000); } }
//***************************************************************************** // //! Network_IF_ConnectAP Connect to an Access Point using the specified SSID //! //! \param[in] pcSsid is a string of the AP's SSID //! \param[in] SecurityParams is Security parameter for AP //! //! \return On success, zero is returned. On error, -ve value is returned // //***************************************************************************** long Network_IF_ConnectAP(char *pcSsid, SlSecParams_t SecurityParams) { #ifndef NOTERM char acCmdStore[128]; unsigned short usConnTimeout; unsigned char ucRecvdAPDetails; #endif long lRetVal; unsigned long ulIP = 0; unsigned long ulSubMask = 0; unsigned long ulDefGateway = 0; unsigned long ulDns = 0; // // Disconnect from the AP // Network_IF_DisconnectFromAP(); // // This triggers the CC3200 to connect to specific AP // lRetVal = sl_WlanConnect((signed char *)pcSsid, strlen((const char *)pcSsid), NULL, &SecurityParams, NULL); ASSERT_ON_ERROR(lRetVal); // // Wait for ~10 sec to check if connection to desire AP succeeds // while(g_usConnectIndex < 15) { #ifndef SL_PLATFORM_MULTI_THREADED _SlNonOsMainLoopTask(); #else osi_Sleep(1); #endif MAP_UtilsDelay(8000000); if(IS_CONNECTED(g_ulStatus) && IS_IP_ACQUIRED(g_ulStatus)) { break; } g_usConnectIndex++; } #ifndef NOTERM // // Check and loop until AP connection successful, else ask new AP SSID name // while(!(IS_CONNECTED(g_ulStatus)) || !(IS_IP_ACQUIRED(g_ulStatus))) { // // Disconnect the previous attempt // Network_IF_DisconnectFromAP(); CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION); CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED); UART_PRINT("Device could not connect to %s\n\r",pcSsid); do { ucRecvdAPDetails = 0; UART_PRINT("\n\r\n\rPlease enter the AP(open) SSID name # "); // // Get the AP name to connect over the UART // lRetVal = GetCmd(acCmdStore, sizeof(acCmdStore)); if(lRetVal > 0) { // remove start/end spaces if any lRetVal = TrimSpace(acCmdStore); // // Parse the AP name // strncpy(pcSsid, acCmdStore, lRetVal); if(pcSsid != NULL) { ucRecvdAPDetails = 1; pcSsid[lRetVal] = '\0'; } } }while(ucRecvdAPDetails == 0); // // Reset Security Parameters to OPEN security type // SecurityParams.Key = (signed char *)""; SecurityParams.KeyLen = 0; SecurityParams.Type = SL_SEC_TYPE_OPEN; UART_PRINT("\n\rTrying to connect to AP: %s ...\n\r",pcSsid); // // Get the current timer tick and setup the timeout accordingly // usConnTimeout = g_usConnectIndex + 15; // // This triggers the CC3200 to connect to specific AP // lRetVal = sl_WlanConnect((signed char *)pcSsid, strlen((const char *)pcSsid), NULL, &SecurityParams, NULL); ASSERT_ON_ERROR(lRetVal); // // Wait ~10 sec to check if connection to specifed AP succeeds // while(!(IS_CONNECTED(g_ulStatus)) || !(IS_IP_ACQUIRED(g_ulStatus))) { #ifndef SL_PLATFORM_MULTI_THREADED _SlNonOsMainLoopTask(); #else osi_Sleep(1); #endif MAP_UtilsDelay(8000000); if(g_usConnectIndex >= usConnTimeout) { break; } g_usConnectIndex++; } } #endif // // Put message on UART // UART_PRINT("\n\rDevice has connected to %s\n\r",pcSsid); // // Get IP address // lRetVal = Network_IF_IpConfigGet(&ulIP,&ulSubMask,&ulDefGateway,&ulDns); ASSERT_ON_ERROR(lRetVal); // // Send the information // UART_PRINT("Device IP Address is %d.%d.%d.%d \n\r\n\r", SL_IPV4_BYTE(ulIP, 3),SL_IPV4_BYTE(ulIP, 2), SL_IPV4_BYTE(ulIP, 1),SL_IPV4_BYTE(ulIP, 0)); return 0; }
long ConnectToNetwork() { long lRetVal = -1; unsigned int uiConnectTimeoutCnt =0; //Start Simplelink Device lRetVal = sl_Start(NULL,NULL,NULL); ASSERT_ON_ERROR(lRetVal); if(lRetVal != ROLE_STA) { if (ROLE_AP == lRetVal) { // If the device is in AP mode, we need to wait for this event // before doing anything while(!IS_IP_ACQUIRED(g_ulStatus)) { #ifndef SL_PLATFORM_MULTI_THREADED _SlNonOsMainLoopTask(); #endif } } // // Configure to STA Mode // lRetVal = ConfigureMode(ROLE_STA); if(lRetVal !=ROLE_STA) { UART_PRINT("Unable to set STA mode...\n\r"); lRetVal = sl_Stop(SL_STOP_TIMEOUT); CLR_STATUS_BIT_ALL(g_ulStatus); return DEVICE_NOT_IN_STATION_MODE; } } //waiting for the device to Auto Connect while(uiConnectTimeoutCnt<AUTO_CONNECTION_TIMEOUT_COUNT && ((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))) { //Turn Green LED On GPIO_IF_LedOn(MCU_GREEN_LED_GPIO); osi_Sleep(50); //Turn Green LED Off GPIO_IF_LedOff(MCU_GREEN_LED_GPIO); osi_Sleep(50); uiConnectTimeoutCnt++; } //Couldn't connect Using Auto Profile if(uiConnectTimeoutCnt==AUTO_CONNECTION_TIMEOUT_COUNT) { CLR_STATUS_BIT_ALL(g_ulStatus); //Turn Green LED On GPIO_IF_LedOn(MCU_GREEN_LED_GPIO); //Connect Using Smart Config lRetVal = SmartConfigConnect(); ASSERT_ON_ERROR(lRetVal); //Waiting for the device to Auto Connect while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus))) { MAP_UtilsDelay(500); } //Turn Green LED Off GPIO_IF_LedOff(MCU_GREEN_LED_GPIO); } return SUCCESS; }
//***************************************************************************** // //! \brief Connecting to a WLAN Accesspoint //! This function connects to the required AP (SSID_NAME). //! This code example assumes the AP doesn't use WIFI security. //! The function will return only once we are connected //! and have acquired IP address //! //! \param[in] None //! //! \return 0 means success, -1 means failure //! //! \note //! //! \warning If the WLAN connection fails or we don't aquire an IP address, //! We will be stuck in this function forever. // //***************************************************************************** int WlanConnect() { int iRetCode = 0; int iRetVal = 0; int iConnect = 0; unsigned char ucQueueMsg = 0; SlSecParams_t secParams; secParams.Key = (signed char *)SECURITY_KEY; secParams.KeyLen = strlen((const char *)secParams.Key); secParams.Type = SECURITY_TYPE; // // Set up the watchdog interrupt handler. // WDT_IF_Init(WatchdogIntHandler, MILLISECONDS_TO_TICKS(WD_PERIOD_MS)); /* Enabling the Sleep clock for the Watch Dog Timer*/ MAP_PRCMPeripheralClkEnable(PRCM_WDT, PRCM_SLP_MODE_CLK); g_ucFeedWatchdog = 1; g_ucWdogCount = 0; while(!(ucQueueMsg & (EVENT_IP_ACQUIRED|CONNECTION_FAILED))) { UART_PRINT("Trying to connect to AP: "); UART_PRINT(SSID_NAME); UART_PRINT("\n\r"); sl_WlanConnect((signed char *)SSID_NAME, strlen((const char *)SSID_NAME), 0, &secParams, 0); iConnect = 0; do{ osi_MsgQRead(&g_tConnection, &ucQueueMsg, OSI_WAIT_FOREVER); switch(ucQueueMsg) { case EVENT_CONNECTION: iConnect = 1; break; case EVENT_IP_ACQUIRED: iRetVal = 0; break; case WDOG_EXPIRED: // // disconnect from the Access Point // if(iConnect) { WlanDisconnect(); } // // stop the simplelink with reqd. timeout value (30 ms) // sl_Stop(SL_STOP_TIMEOUT); UART_PRINT("sl stop\n\r"); MAP_UtilsDelay(8000); // // starting the simplelink // sl_Start(NULL, NULL, NULL); UART_PRINT("sl start\n\r"); break; case EVENT_DISCONNECTION: iConnect = 0; break; case CONNECTION_FAILED: iRetVal = -1; break; default: UART_PRINT("unexpected event\n\r"); break; } }while(ucQueueMsg == (unsigned char)EVENT_CONNECTION); } iRetCode = MAP_WatchdogRunning(WDT_BASE); if(iRetCode) { WDT_IF_DeInit(); MAP_PRCMPeripheralClkDisable(PRCM_WDT, PRCM_RUN_MODE_CLK); } ASSERT_ON_ERROR(iRetVal); return(iRetVal); }