//****************************************************************************
//
//! \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);
}