This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

Can't use I2C device with CC3100BOOST

Other Parts Discussed in Thread: CC3100, CC3100BOOST, MSP430F5529

I have been using the CC3100 SDK to develop a project and have had it running successfully for a while. I recently decided to power he MSP430F5529LP LaunchPad from a USB charger and that is when things started getting weird. I have tried running the same code as before but now the I2C clock looks like a disorganized mess.

If, however, I comment out the functions that set up the CC3100 and CLI_WRITE and only run the I2C code I have no issue (the clock setting does not affect anything . The same applies if I disable the I2C code and  run the other half of the code. The confusing part is the code DID WORK for the better part of a day with almost no issues (only issue was AP connection dropped after ~5 minutes). If anyone has any possible insight as to what may have happened to cause this I would be happy to hear ANY suggestions. I have tried Reinstalling CCS, the SDK and even reflashed the CC3100BOOST. 

Thankfully

Kas

My Code:

/*
 * main.c - TCP socket sample application
 *
 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
 *
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
*/

/*
 * Application Name     -   TCP socket
 * Application Overview -   This is a sample application demonstrating how to open
 *                          and use a standard TCP socket with CC3100.
 * Application Details  -   http://processors.wiki.ti.com/index.php/CC31xx_TCP_Socket_Application
 *                          doc\examples\tcp_socket.pdf
 */


#include "simplelink.h"
#include "cli_uart.h"
#include <msp430.h>

#define APPLICATION_VERSION "1.0.0"

/**/
#define LOOP_FOREVER(line_number) \
            {\
                while(1); \
            }

#define ASSERT_ON_ERROR(line_number, error_code) \
            {\
                /* Handling the error-codes is specific to the application */ \
                if (error_code < 0) return error_code; \
                /* else, continue w/ execution */ \
            }

/*
 * Values for below macros shall be modified per the access-point's (AP) properties
 * SimpleLink device will connect to following AP when the application is executed
 */
// #define SSID_NAME		""      /* AP name to connect to. */
// #define SEC_TYPE		SL_SEC_TYPE_WPA  /* Security type of the Access piont */
// #define PASSKEY		""               /* Password in case of secure AP */
// #define IP_ADDR        		//TODO: Change to a passed in value
// #define PORT_NUM        5001            /* Port number to be used */

#define SSID_NAME       ""      /* AP name to connect to. */
#define SEC_TYPE        SL_SEC_TYPE_WPA /* Security type of the Access piont */
#define PASSKEY         ""               /* Password in case of secure AP */
#define IP_ADDR         		//TODO: Change to a passed in value
#define PORT_NUM        5001            /* Port number to be used */

// #define SSID_NAME       ""      /* AP name to connect to. */
// #define SEC_TYPE        SL_SEC_TYPE_WPA /* Security type of the Access point */
// #define PASSKEY         ""               /* Password in case of secure AP */
//#define IP_ADDR         		//TODO: Change to a passed in value
//#define PORT_NUM        5001            /* Port number to be used */

 #define IP_ADDR		0x6b15d6c7//Plotly
 #define PORT_NUM		80//Plotly            /* Port number to be used */



#define BUF_SIZE        1400
#define NO_OF_PACKETS   10

#define SUCCESS         0

/* Status bits - These are used to set/reset the corresponding bits in a 'status_variable' */
typedef enum{
    STATUS_BIT_CONNECTION =  0, /* If this bit is:
                                 *      1 in a 'status_variable', the device is connected to the AP
                                 *      0 in a 'status_variable', the device is not connected to the AP
                                 */

    STATUS_BIT_IP_AQUIRED       /* If this bit is:
                                 *      1 in a 'status_variable', the device has acquired an IP
                                 *      0 in a 'status_variable', the device has not acquired an IP
                                 */

}e_StatusBits;

/* Application specific status/error codes */
typedef enum{
	DEVICE_NOT_IN_STATION_MODE = -0x7D0,        /* Choosing this number to avoid overlap w/ host-driver's error codes */

	STATUS_CODE_MAX = -0xBB8
}e_AppStatusCodes;

#define SET_STATUS_BIT(status_variable, bit)    status_variable |= (1<<(bit))
#define CLR_STATUS_BIT(status_variable, bit)    status_variable &= ~(1<<(bit))
#define GET_STATUS_BIT(status_variable, bit)    (0 != (status_variable & (1<<(bit))))

#define IS_CONNECTED(status_variable)           GET_STATUS_BIT(status_variable, \
                                                               STATUS_BIT_CONNECTION)
#define IS_IP_AQUIRED(status_variable)          GET_STATUS_BIT(status_variable, \
                                                               STATUS_BIT_IP_AQUIRED)

/*
 * GLOBAL VARIABLES -- Start
 */
union
{
    UINT8 BsdBuf[BUF_SIZE];
    UINT32 demobuf[BUF_SIZE/4];
} uBuf;

UINT8 g_Status = 0;
/****************************************CARRIED OVER START*/
unsigned char *PTxData;                     // Pointer to TX data
unsigned char TXByteCtr;
unsigned char *PRxData;                     // Pointer to RX data
unsigned char RXByteCtr;
unsigned char RxBuffer[128];       			// Allocate 128 byte of RAM
char multiple;
char stopBit = FALSE;
/****************************************CARRIED OVER END*/
char xValue[] = "\0\0\0\0\0\0";
unsigned char errorArray[] = "\0\0\0\0\0\0\0\0\0\0";
int connectedToAP = 0;
int connetcedToSocket = 0;
/*
 * GLOBAL VARIABLES -- End
 */

/*
 * STATIC FUNCTION DEFINITIONS -- Start
 */
void clearErrorArray();
static INT32 configureSimpleLinkToDefaultState();
static INT32 establishConnectionWithAP();
void configureCC3x00();
void startCC3x00();
void connectCC3x00();
//static INT16 BsdTcpServer(UINT16 Port);
static INT16 BsdTcpClient(UINT16 Port);
static INT16 packetTx(UINT16 socketID, unsigned char* message, int length, char closeSocket);
static INT32 initializeAppVariables();
static void displayBanner();
int intToChars(int number, char* chars);
int charToInt(signed char value);
void hexByteToChar(char byteIn, char* nibbleA, char* nibbleB);
int plotlyPlotString(int xVal, int yVal, char* dataStream);
void I2CInit();
void I2CTx(unsigned char* TxData, unsigned char numBytes, char stop);
void I2CRx(unsigned char* RxBuffer, unsigned char numBytes);
int mpl3115aInit();
int mpl3115aRead();
/*
 * STATIC FUNCTION DEFINITIONS -- End
 */


/*
 * ASYNCHRONOUS EVENT HANDLERS -- Start
 */
/*!
    \brief This function handles WLAN events

    \param[in]      pWlanEvent is the event passed to the handler

    \return         None

    \note

    \warning
*/
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent)//TODO: Look at all the possible events that can occur and decide if other events need to be handled
{
    switch(pWlanEvent->Event)
    {
        case SL_WLAN_CONNECT_EVENT:
        {
        	SET_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
            intToChars(pWlanEvent->Event, errorArray);
        	CLI_Write(" STATUS_BIT_CONNECTION Value: ");
        	CLI_Write(errorArray);
        	CLI_Write("\r\n\r\n");
        	clearErrorArray();
            /*
             * Information about the connected AP (like name, MAC etc) will be
             * available in 'sl_protocol_wlanConnectAsyncResponse_t' - Applications
             * can use it if required
             *
             * sl_protocol_wlanConnectAsyncResponse_t *pEventData = NULL;
             * pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
             *
             */
        }
        break;

        case SL_WLAN_DISCONNECT_EVENT:
        {
            sl_protocol_wlanConnectAsyncResponse_t*  pEventData = NULL;

            CLR_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
			CLR_STATUS_BIT(g_Status, STATUS_BIT_IP_AQUIRED);

            pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;

            /* If the user has initiated 'Disconnect' request, 'reason_code' is
             * SL_USER_INITIATED_DISCONNECTION */
            if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)//TODO: Add connection flag here to be checked in main loop and reconnect should a connection error occur
            {
            	CLI_Write(" Device disconnected from the AP on application's request \n\r");
            	intToChars(pWlanEvent->Event, errorArray);
				CLI_Write(" Error Code A.0: ");
				CLI_Write(errorArray);
				CLI_Write("\r\n\r\n");
				clearErrorArray();
				connectedToAP = 0;
				intToChars(pEventData->reason_code, errorArray);
				CLI_Write(" Error Code A.1: ");
				CLI_Write(errorArray);
				CLI_Write("\r\n\r\n");
				clearErrorArray();
            }
            else
            {
            	CLI_Write(" Device disconnected from the AP on an ERROR..!! \n\r");
            	connectedToAP = 0;
				intToChars(pWlanEvent->Event, errorArray);
				CLI_Write(" Error Code A.2: ");
				CLI_Write(errorArray);
				CLI_Write("\r\n\r\n");
				clearErrorArray();
				connectedToAP = 0;
				intToChars(pEventData->reason_code, errorArray);
				CLI_Write(" Error Code A.3: ");
				CLI_Write(errorArray);
				CLI_Write("\r\n\r\n");
				clearErrorArray();
            }
        }
        break;

        default:
        {
        	CLI_Write(" [WLAN EVENT] Unexpected event \n\r");
        	connectedToAP = 0;
			intToChars(pWlanEvent->Event, errorArray);
			CLI_Write(" Error Code B: ");
			CLI_Write(errorArray);
			CLI_Write("\r\n\r\n");
			clearErrorArray();
        }
        break;
    }
}

/*!
    \brief This function handles events for IP address acquisition via DHCP
           indication

    \param[in]      pNetAppEvent is the event passed to the handler

    \return         None

    \note

    \warning
*/
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *pNetAppEvent)
{
    switch(pNetAppEvent->Event)
    {
        case SL_NETAPP_IPV4_ACQUIRED:
        {
        	SET_STATUS_BIT(g_Status, STATUS_BIT_IP_AQUIRED);

            intToChars(pNetAppEvent->Event, errorArray);
        	CLI_Write(" Event Value: ");
        	CLI_Write(errorArray);
        	CLI_Write("\r\n\r\n");
        	clearErrorArray();

			
        	intToChars(STATUS_BIT_IP_AQUIRED, errorArray);
			CLI_Write(" STATUS_BIT_IP_AQUIRED Value: ");
			CLI_Write(errorArray);
			CLI_Write("\r\n\r\n");
			clearErrorArray();
            /*
			 * Information about the connection (like IP, gateway address etc)
			 * will be available in 'SlIpV4AcquiredAsync_t'
			 * Applications can use it if required
			 *
			 * SlIpV4AcquiredAsync_t *pEventData = NULL;
			 * pEventData = &pNetAppEvent->EventData.ipAcquiredV4;
			 *
			 */
        }
        break;

        default:
        {
        	CLI_Write(" [NETAPP EVENT] Unexpected event \n\r");
            intToChars(pNetAppEvent->Event, errorArray);
            CLI_Write(" Error Code C: ");
        	CLI_Write(errorArray);
        	CLI_Write("\r\n\r\n");
        	clearErrorArray();
        }
        break;
    }
}

/*!
    \brief This function handles callback for the HTTP server events

    \param[in]      pServerEvent - Contains the relevant event information
    \param[in]      pServerResponse - Should be filled by the user with the
                    relevant response information

    \return         None

    \note

    \warning
*/
void SimpleLinkHttpServerCallback(SlHttpServerEvent_t *pHttpEvent,
                                  SlHttpServerResponse_t *pHttpResponse)
{
    /* Unused in this application */
	CLI_Write(" [HTTP EVENT] Unexpected event \n\r");
}

/*!
    \brief This function handles general error events indication

    \param[in]      pDevEvent is the event passed to the handler

    \return         None
*/
void SimpleLinkGeneralEventHandler(SlDeviceEvent_t *pDevEvent)
{
    /*
     * Most of the general errors are not FATAL are are to be handled
     * appropriately by the application
     */
	CLI_Write(" [GENERAL EVENT] \n\r");
	intToChars(pDevEvent->Event, errorArray);
	CLI_Write(" Error Code D: ");
	CLI_Write(errorArray);
	CLI_Write("\r\n\r\n");
	clearErrorArray();
}

/*!
    \brief This function handles socket events indication

    \param[in]      pSock is the event passed to the handler

    \return         None
*/
void SimpleLinkSockEventHandler(SlSockEvent_t *pSock)
{
	switch( pSock->Event )
	{
		case SL_NETAPP_IPV4_ACQUIRED:
			//TODO: Fill in needed code here (set flag)
		break;
		case SL_NETAPP_SOCKET_TX_FAILED:
			/*
			 * TX Failed
			 *
			 * Information about the socket descriptor and status will be
			 * available in 'SlSockEventData_t' - Applications can use it if
			 * required
			 *
			 * SlSockEventData_t *pEventData = NULL;
			 * pEventData = & pSock->EventData;
			 */
			switch( pSock->EventData.status )
			{
				case SL_ECLOSE:
					CLI_Write(" [SOCK EVENT] Close socket operation failed to transmit all queued packets\n\r");
					connetcedToSocket = 0;
					intToChars(pSock->Event, errorArray);
					CLI_Write(" Error Code E: ");
					CLI_Write(errorArray);
					CLI_Write("\r\n\r\n");
					clearErrorArray();
					break;
				default:
					CLI_Write(" [SOCK EVENT] Unexpected event 1\n\r");
					connetcedToSocket = 0;
					intToChars(pSock->Event, errorArray);
					CLI_Write(" Error Code F: ");
					CLI_Write(errorArray);
					CLI_Write("\r\n\r\n");
					clearErrorArray();
					break;
			}
			break;

		default:
			CLI_Write(" [SOCK EVENT] Unexpected event 2\n\r");
			connetcedToSocket = 0;
			intToChars(pSock->Event, errorArray);
			CLI_Write(" Error Code G: ");
			CLI_Write(errorArray);
			CLI_Write("\r\n\r\n");
			clearErrorArray();
			break;
	}
}
/*
 * ASYNCHRONOUS EVENT HANDLERS -- End
 */
void clearErrorArray(){
	char i;
	for(i = 0; i < 12; i++){
		errorArray[i] = '\0';
	}
}

/*!
    \brief This function configure the SimpleLink device in its default state. It:
           - Sets the mode to STATION
           - Configures connection policy to Auto and AutoSmartConfig
           - Deletes all the stored profiles
           - Enables DHCP
           - Disables Scan policy
           - Sets Tx power to maximum
           - Sets power policy to normal
           - Unregisters mDNS services

    \param[in]      none

    \return         On success, zero is returned. On error, negative is returned
*/
static INT32 configureSimpleLinkToDefaultState()
{
    SlVersionFull   ver = {0};

    UINT8           val = 1;
    UINT8           configOpt = 0;
    UINT8           configLen = 0;
    UINT8           power = 0;

    INT32           retVal = -1;
    INT32           mode = -1;

    mode = sl_Start(0, 0, 0);
    ASSERT_ON_ERROR(__LINE__, mode);

    /* If the device is not in station-mode, try configuring it in staion-mode */
	if (ROLE_STA != mode)
	{
		if (ROLE_AP == mode)
		{
			/* If the device is in AP mode, we need to wait for this event before doing anything */
			while(!IS_IP_AQUIRED(g_Status)) { _SlNonOsMainLoopTask(); }
		}

		/* Switch to STA role and restart */
		retVal = sl_WlanSetMode(ROLE_STA);
		ASSERT_ON_ERROR(__LINE__, retVal);

		retVal = sl_Stop(0xFF);
		ASSERT_ON_ERROR(__LINE__, retVal);

		retVal = sl_Start(0, 0, 0);
		ASSERT_ON_ERROR(__LINE__, retVal);

		/* Check if the device is in station again */
		if (ROLE_STA != retVal)
		{
			/* We don't want to proceed if the device is not coming up in station-mode */
			return DEVICE_NOT_IN_STATION_MODE;
		}
	}

    /* Get the device's version-information */
    configOpt = SL_DEVICE_GENERAL_VERSION;
    configLen = sizeof(ver);
    retVal = sl_DevGet(SL_DEVICE_GENERAL_CONFIGURATION, &configOpt, &configLen, (unsigned char *)(&ver));
    ASSERT_ON_ERROR(__LINE__, retVal);

    /* Set connection policy to Auto + SmartConfig (Device's default connection policy) */
    retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION, SL_CONNECTION_POLICY(1, 0, 0, 0, 1), NULL, 0);
    ASSERT_ON_ERROR(__LINE__, retVal);

    /* Remove all profiles */
    retVal = sl_WlanProfileDel(0xFF);
    ASSERT_ON_ERROR(__LINE__, retVal);

    /*
     * Device in station-mode. Disconnect previous connection if any
     * The function returns 0 if 'Disconnected done', negative number if already disconnected
     * Wait for 'disconnection' event if 0 is returned, Ignore other return-codes
     */
    retVal = sl_WlanDisconnect();
    if(0 == retVal)
    {
        /* Wait */
        while(IS_CONNECTED(g_Status)) { _SlNonOsMainLoopTask(); }
    }

    /* Enable DHCP client*/
    retVal = sl_NetCfgSet(SL_IPV4_STA_P2P_CL_DHCP_ENABLE,1,1,&val);
    ASSERT_ON_ERROR(__LINE__, retVal);

    /* Disable scan */
    configOpt = SL_SCAN_POLICY(0);
    retVal = sl_WlanPolicySet(SL_POLICY_SCAN , configOpt, NULL, 0);
    ASSERT_ON_ERROR(__LINE__, retVal);

    /* Set Tx power level for station mode
       Number between 0-15, as dB offset from max power - 0 will set maximum power */
    power = 0;
    retVal = sl_WlanSet(SL_WLAN_CFG_GENERAL_PARAM_ID, WLAN_GENERAL_PARAM_OPT_STA_TX_POWER, 1, (unsigned char *)&power);
    ASSERT_ON_ERROR(__LINE__, retVal);

    /* Set PM policy to normal */
    retVal = sl_WlanPolicySet(SL_POLICY_PM , SL_NORMAL_POLICY, NULL, 0);
    ASSERT_ON_ERROR(__LINE__, retVal);

    /* Unregister mDNS services */
    retVal = sl_NetAppMDNSUnRegisterService(0, 0);
    ASSERT_ON_ERROR(__LINE__, retVal);

    retVal = sl_Stop(0xFF);
    ASSERT_ON_ERROR(__LINE__, retVal);

    retVal = initializeAppVariables();
    ASSERT_ON_ERROR(__LINE__, retVal);

    return retVal; /* Success */
}

/*!
    \brief Connecting to a WLAN Access point

    This function connects to the required AP (SSID_NAME).
    The function will return once we are connected and have acquired IP address

    \param[in]  None

    \return     0 on success, negative error-code on error

    \note

    \warning    If the WLAN connection fails or we don't acquire an IP address,
                We will be stuck in this function forever.
*/
static INT32 establishConnectionWithAP()
{
    SlSecParams_t secParams = {0};
    INT32 retVal = 0;

    secParams.Key = PASSKEY;
    secParams.KeyLen = strlen(PASSKEY);
    secParams.Type = SEC_TYPE;

    retVal = sl_WlanConnect(SSID_NAME, strlen(SSID_NAME), 0, &secParams, 0);
    ASSERT_ON_ERROR(__LINE__, retVal);

    /* Wait */
    while((!IS_CONNECTED(g_Status)) || (!IS_IP_AQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }

    connectedToAP = 1;//TODO: remove flag
    return SUCCESS;
}

/****************************************************************************************************************************************/

/*
 * Following function configures the device to default state by cleaning
 * the persistent settings stored in NVMEM (viz. connection profiles &
 * policies, power policy etc)
 *
 * Applications may choose to skip this step if the developer is sure
 * that the device is in its default state at start of application
 *
 * Note that all profiles and persistent settings that were done on the
 * device will be lost
 */
void configureCC3x00(){
	INT32 retVal = -1;
	retVal = configureSimpleLinkToDefaultState();
	if(retVal < 0)
	{
		if (DEVICE_NOT_IN_STATION_MODE == retVal)
		{
			CLI_Write(" Failed to configure the device in its default state \n\r");
		}

		LOOP_FOREVER(__LINE__);
	}
	CLI_Write(" Device is configured in default state \n\r");
}

/*
 * Assumption is that the device is configured in station mode already
 * and it is in its default state
 */
/* Initializing the CC3100 device */
void startCC3x00(){
	INT32 retVal = -1;
	retVal = sl_Start(0, 0, 0);
	if ((retVal < 0) ||
		(ROLE_STA != retVal) )
	{
		CLI_Write(" Failed to start the device \n\r");
		LOOP_FOREVER(__LINE__);
	}
	CLI_Write(" Device started as STATION \n\r");
}


/* Connecting to WLAN AP - Set with static parameters defined at the top
	After this call we will be connected and have IP address */
void connectCC3x00(){
	INT32 retVal = -1;
	retVal = establishConnectionWithAP();
	if(retVal < 0)
	{
		CLI_Write(" Failed to establish connection w/ an AP \n\r");
		LOOP_FOREVER(__LINE__);
	}

	CLI_Write(" Connection established w/ AP and IP is acquired \n\r");
}

/*!
    \brief Opening a client side socket and sending data

    This function opens a TCP socket and tries to connect to a Server IP_ADDR
    waiting on port PORT_NUM. If the socket connection is successful then the
    function will send 1000 TCP packets to the server.

    \param[in]      port number on which the server will be listening on

    \return         0 on success, -1 on Error.

    \note

    \warning        A server must be waiting with an open TCP socket on the
                    right port number before calling this function.
                    Otherwise the socket creation will fail.
*/
static INT16 BsdTcpClient(UINT16 Port)
{
    SlSockAddrIn_t  Addr;
    UINT16          AddrSize = 0;
    INT16           SockID = 0;
    INT16           Status = 0;

    Addr.sin_family = SL_AF_INET;
    Addr.sin_port = sl_Htons((UINT16)Port);
    Addr.sin_addr.s_addr = sl_Htonl((UINT32)IP_ADDR);//TODO: Change this as a passed in value(Keep as defined for current version)
    AddrSize = sizeof(SlSockAddrIn_t);

    SockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, 0);
    if( SockID < 0 )
    {
        /* error */
        return -1;
    }

    CLI_Write(" Establishing connection with TCP server \n\r");

    Status = sl_Connect(SockID, ( SlSockAddr_t *)&Addr, AddrSize);
    if( Status < 0 )
    {
        sl_Close(SockID);
        CLI_Write(" Failed to establish connection with TCP server \n\r");
        return -1;
    }

    CLI_Write(" Connection with TCP server established successfully \n\r");
    connetcedToSocket = 1;//TODO: remove flag
    return  SockID;
}

static INT16 packetTx(UINT16 socketID, unsigned char* message, int length, char closeSocket){
    INT16           Status = 0;
    INT8 			sent = -1;
    INT8 			i = 0;
    INT16 			j = 0;

    CLI_Write(" - Initiating message transmit\n\r");
	while((sent == -1) && (i < 6)){
		Status = sl_Send(socketID, message, length, 0 );
		sent = Status;
		i++;
		if (sent != 0){
			for (j = 0; j < 1000; j++);
		}
	}
    if( Status < 0 )
	{
		CLI_Write(" Error while sending the data \n\r");
		sl_Close(socketID);
		return -1;
	}
	CLI_Write(" - Message transmitted\n\r");

////    if (closeSocket == 1){
//    	sl_Close(socketID);//TODO: Remove close socket
////    }
    return 0;
}


/*!
    \brief This function initializes the application variables

    \param[in]  None

    \return     0 on success, negative error-code on error
*/
static INT32 initializeAppVariables()
{
    g_Status = 0;
    memset(uBuf.BsdBuf, 0, sizeof(uBuf));

    return SUCCESS;
}
/*!
    \brief This function displays the application's banner

    \param      None

    \return     None
*/
static void displayBanner()
{
    CLI_Write("\n\r\n\r");
    CLI_Write(" TCP socket application - Version ");
    CLI_Write(APPLICATION_VERSION);
    CLI_Write("\n\r*******************************************************************************\n\r");
}

int intToChars(int number, char* chars){
	int val = number;
	int i = 0;
	int j = 0;
	int num;
	int neg = 0;
	char temp;
	if (val < 0){
		val = 0 - val;
		neg = 1;
	}

	if (val == 0){
		chars[0] = '0';
		i = 1;
	}

	while(val != 0){
		num = val/10;
		chars[i] = (char)(val - (num * 10) + 0x30);
		val = num;
		i++;
	}
	i--;//Remove extra count
	int f;
	if (i % 2 != 0){
		f = i / 2 + 1;
	}
	else {
		f = i / 2;
	}
	for (j = 0; j < f; j++){
		temp = chars[j];
		chars[j] = chars[i - j];
		chars[i - j] = temp;
	}
	if (neg){
		for (j = i; j >= 0; j--){
			chars[j + 1] = chars[j];
		}
		chars[0] = '-';
		i++;//increase count to account for negitive sign
	}
	return i + 1; //Counting from zero so add one for true length
}

//Converts Hex representation to characters
int charToInt(signed char value){
	int mambo = 0;
	if (value < 0){
		value = 0 - value;
		mambo = 0 - (int)value;
	}
	else{
		mambo = (int)value;
	}
	return mambo;
}

void hexByteToChar(char byteIn, char* nibbleA, char* nibbleB)
{
	switch(byteIn & 0xF0){
		case 0x0:
			*nibbleA = '0';
			break;
		case 0x10:
			*nibbleA = '1';
			break;
		case 0x20:
			*nibbleA = '2';
			break;
		case 0x30:
			*nibbleA = '3';
			break;
		case 0x40:
			*nibbleA = '4';
			break;
		case 0x50:
			*nibbleA = '5';
			break;
		case 0x60:
			*nibbleA = '6';
			break;
		case 0x70:
			*nibbleA = '7';
			break;
		case 0x80:
			*nibbleA = '8';
			break;
		case 0x90:
			*nibbleA = '9';
			break;
		case 0xA0:
			*nibbleA = 'A';
			break;
		case 0xB0:
			*nibbleA = 'B';
			break;
		case 0xC0:
			*nibbleA = 'C';
			break;
		case 0xD0:
			*nibbleA = 'D';
			break;
		case 0xE0:
			*nibbleA = 'E';
			break;
		case 0xF0:
			*nibbleA = 'F';
			break;
	}
	switch (byteIn & 0x0F){
		case 0x00:
			*nibbleB = '0';
			break;
		case 0x01:
			*nibbleB = '1';
			break;
		case 0x02:
			*nibbleB = '2';
			break;
		case 0x03:
			*nibbleB = '3';
			break;
		case 0x04:
			*nibbleB = '4';
			break;
		case 0x05:
			*nibbleB = '5';
			break;
		case 0x06:
			*nibbleB = '6';
			break;
		case 0x07:
			*nibbleB = '7';
			break;
		case 0x08:
			*nibbleB = '8';
			break;
		case 0x09:
			*nibbleB = '9';
			break;
		case 0x0A:
			*nibbleB = 'A';
			break;
		case 0x0B:
			*nibbleB = 'B';
			break;
		case 0x0C:
			*nibbleB = 'C';
			break;
		case 0x0D:
			*nibbleB = 'D';
			break;
		case 0x0E:
			*nibbleB = 'E';
			break;
		case 0x0F:
			*nibbleB = 'F';
			break;
	}
}


int plotlyPlotString(int xVal, int yVal, char* dataStream){
	const char start[] = "\r\n{\"x\":";
	const char middle[] = ",\"y\":";
	const char end[] = "}\r\n";

//	char xValue[] = "\0\0\0\0\0\0";
	char yValue[] = "\0\0\0\0\0\0";

	intToChars(xVal, xValue);
	intToChars(yVal, yValue);

	int offset = 4;
	strncpy(dataStream + offset, start, sizeof(start) - 1);
	offset = offset + sizeof(start) - 1;
	strncpy(dataStream + offset, xValue, strlen(xValue));
	offset = offset + strlen(xValue);
	strncpy(dataStream + offset, middle, sizeof(middle) - 1);
	offset = offset + sizeof(middle) - 1;
	strncpy(dataStream + offset, yValue, strlen(yValue));
	offset = offset + strlen(yValue);
	strncpy(dataStream + offset, end, sizeof(end)); //Leave out the -1 inorder to include the null terminator

	int streamLength;
	char streamDataLen[] = "\0\0\0\0\0";

	streamLength = sizeof(start) - 2 + strlen(xValue) + sizeof(middle) + strlen(yValue) + sizeof(end) - 3;
	intToChars(streamLength, streamDataLen);
	char happyDay[4];
	hexByteToChar(streamDataLen[0], happyDay, happyDay + 1);
	hexByteToChar(streamDataLen[1], happyDay + 2, happyDay + 3);
	strncpy(dataStream, happyDay, 4);

	return streamLength;
}

void I2CInit(){
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  P4SEL |= 0x06;                            // Assign I2C pins to USCI_B0
  UCB1CTL1 |= UCSWRST;                      // Enable SW reset
  UCB1CTL0 = UCMST + UCMODE_3 + UCSYNC;     // I2C Master, synchronous mode
  UCB1CTL1 = UCSSEL_2 + UCSWRST;            // Use SMCLK, keep SW reset
  UCB1BR0 = 10;                             // fSCL = SMCLK/12 = ~100kHz
  UCB1BR1 = 0;
  UCB1I2CSA = 0x60;                         // Slave Address is 048h
  UCB1CTL1 &= ~UCSWRST;                     // Clear SW reset, resume operation
  UCB1IE |= UCTXIE;                         // Enable TX interrupt
  UCB1IE |= UCRXIE;                         // Enable RX interrupt
}

void I2CTx(unsigned char* TxData, unsigned char numBytes, char stop){
    unsigned int i;
    stopBit = stop;
	for(i=0;i<10;i++);                      // Delay required between transaction
    PTxData = (unsigned char *)TxData;      // TX array start address
                                            // Place breakpoint here to see each
                                            // transmit operation.
    TXByteCtr = numBytes;              // Load TX byte counter

    UCB1CTL1 |= UCTR + UCTXSTT;             // I2C TX, start condition

    __bis_SR_register(LPM0_bits + GIE);     // Enter LPM0, enable interrupts
    __no_operation();                       // Remain in LPM0 until all data

    if(stop){
    	UCB1CTL1 |= UCTXSTP;
    }
                                            // is TX'd
    while (UCB1CTL1 & UCTXSTP);             // Ensure stop condition got sent
}

void I2CRx(unsigned char* RxBuffer, unsigned char numBytes){
	PRxData = (unsigned char *)RxBuffer;    // Start of RX buffer
    RXByteCtr = numBytes;                   // Load RX byte counter
    if (numBytes > 1){
    	multiple = 1;
    }
    else {
    	multiple = 0;
    }
    while (UCB1CTL1 & UCTXSTP);           // Ensure stop condition got sent

    UCB1CTL1 &= ~UCTR;
    UCB1CTL1 |= UCTXSTT;                    // I2C start condition

    if (multiple == 0){
		while(UCB1CTL1 & UCTXSTT);          // Start condition sent?
		UCB1CTL1 |= UCTXSTP;
    }
    __bis_SR_register(LPM0_bits + GIE);     // Enter LPM0, enable interrupts
                                            // Remain in LPM0 until all data is RX'd
    __no_operation();
}

int mpl3115aInit(){
	char initialized = 1;

	unsigned char WHO_AM_I[] = {0x0C};
	//R C4
	unsigned char CTRL_REG1_SET1[] = {0x26, 0x38};
	unsigned char CTRL_REG2_SET[] = {0x27, 0x00};
	unsigned char CTRL_REG3_SET[] = {0x28, 0x11};
	unsigned char CTRL_REG4_SET[] = {0x29, 0x00};
	unsigned char CTRL_REG5_SET[] = {0x2A, 0x00};
	unsigned char PT_DATA_CFG_SET[] = {0x13, 0x07};

	unsigned char CTRL_REG1_GET[] = {0x26};
	unsigned char CTRL_REG1_SET2[] = {0x26, 0x39};
	unsigned char CTRL_REG2_GET[] = {0x27};

	I2CTx(WHO_AM_I, sizeof(WHO_AM_I), FALSE);
	I2CRx(RxBuffer, 1);
	if (RxBuffer[0] == 0xC4){
		P4OUT |= 0x80;
		P1OUT &= 0xFE;
	}
	else {
		P1OUT |= 0x01;
		P4OUT &= 0x7F;
		initialized = 0;
	}

	I2CTx(CTRL_REG1_SET1, sizeof(CTRL_REG1_SET1), TRUE);
	I2CTx(CTRL_REG2_SET, sizeof(CTRL_REG2_SET), TRUE);
	I2CTx(CTRL_REG3_SET, sizeof(CTRL_REG3_SET), TRUE);
	I2CTx(CTRL_REG4_SET, sizeof(CTRL_REG4_SET), TRUE);
	I2CTx(CTRL_REG5_SET, sizeof(CTRL_REG5_SET), TRUE);
	I2CTx(PT_DATA_CFG_SET, sizeof(PT_DATA_CFG_SET), TRUE);

	I2CTx(CTRL_REG1_GET, sizeof(CTRL_REG1_GET), FALSE);
	I2CRx(RxBuffer, 1);
	if (RxBuffer[0] == 0x38){
		P4OUT |= 0x80;
		P1OUT &= 0xFE;
	}
	else {
		P1OUT |= 0x01;
		P4OUT &= 0x7F;
		initialized = 0;
	}

	I2CTx(CTRL_REG1_SET2, sizeof(CTRL_REG1_SET2), TRUE);
	I2CTx(CTRL_REG1_GET, sizeof(CTRL_REG1_GET), FALSE);
	I2CRx(RxBuffer, 1);
	if (RxBuffer[0] == 0x39){
		P4OUT |= 0x80;
		P1OUT &= 0xFE;
	}
	else {
		P1OUT |= 0x01;
		P4OUT &= 0x7F;
		initialized = 0;
	}

	I2CTx(CTRL_REG2_GET, sizeof(CTRL_REG2_GET), FALSE);
	I2CRx(RxBuffer, 1);
	if (RxBuffer[0] == 0x00){
		P4OUT |= 0x80;
		P1OUT &= 0xFE;
	}
	else {
		P1OUT |= 0x01;
		P4OUT &= 0x7F;
		initialized = 0;
	}
	return initialized;
}

int mpl3115aRead(){
	unsigned char OUT_P_MSB[] = {0x01};
	unsigned char DR_STATUS[] = {0x06};

	char readPresTemp = 0;

	I2CTx(DR_STATUS, sizeof(DR_STATUS), FALSE);
	I2CRx(RxBuffer, 1);
	if ((RxBuffer[0] == 0x0E) || (RxBuffer[0] == 0xEE)){
		P4OUT |= 0x80;
		P1OUT &= 0xFE;
		readPresTemp = 1;
	}
	else {
		P1OUT |= 0x01;
		P4OUT &= 0x7F;
		readPresTemp = 0;
	}

	if (readPresTemp){
		I2CTx(OUT_P_MSB, sizeof(OUT_P_MSB), FALSE);
		I2CRx(RxBuffer, 5);
		Delay(50);
	}
	return readPresTemp;
}

int main(void)
{
	INT32 retVal = -1;
	int temperatureInt;
	int streamLength;
	int packetLength;
	char dataStream[30];
	int xVal = 0;

	P1OUT &= 0xFE;
 	P1DIR |= 0x01;
	P4OUT &= 0x7F;
	P4DIR |= 0x80;

	retVal = initializeAppVariables();
	ASSERT_ON_ERROR(__LINE__, retVal);

	stopWDT();
	initClk();

	CLI_Configure();
    CLI_Write(" \f\r\n");

	displayBanner();
    
	configureCC3x00();
	startCC3x00();
	connectCC3x00();

 	INT16 socketIDD;
 	socketIDD = BsdTcpClient(PORT_NUM);
 	packetTx(socketIDD, openStream, (sizeof(openStream) - 1), 0);

 	int dataAvilable;

 	CLI_Write(" Initilizing I2C");
 	I2CInit();
 	Delay(700);
 	CLI_Write(" Complete \r\n");
 	Delay(500);
 	CLI_Write(" Initilizing MPL3115A");
 	mpl3115aInit();
 	Delay(700);
 	CLI_Write(" Complete\r\n");
	while (1)
  {
		dataAvilable = mpl3115aRead();
		if (dataAvilable == 1){

			temperatureInt = charToInt((signed char)RxBuffer[3]);
			streamLength = plotlyPlotString(xVal, temperatureInt, dataStream);
			packetLength = streamLength + 6;
			packetTx(socketIDD, dataStream, packetLength, 0);

			CLI_Write("\r\n");
			CLI_Write(dataStream);
			CLI_Write("\r\n");

			xVal++;
		}
		Delay(20);
  }
}

//-------------------------------------------------------------------------------
// The USCI_B0 data ISR is used to move received data from the I2C slave
// to the MSP430 memory. It is structured such that it can be used to receive
// any 2+ number of bytes by pre-loading RXByteCtr with the byte count.
//-------------------------------------------------------------------------------
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector = USCI_B1_VECTOR
__interrupt void USCI_B1_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_B0_VECTOR))) USCI_B0_ISR (void)
#else
#error Compiler not supported!
#endif
{
  switch(__even_in_range(UCB1IV,12))
  {
  case  0: break;                           // Vector  0: No interrupts
  case  2: break;                           // Vector  2: ALIFG
  case  4: break;                           // Vector  4: NACKIFG
  case  6: break;                           // Vector  6: STTIFG
  case  8: break;                           // Vector  8: STPIFG
  case 10:                                  // Vector 10: RXIFG
    RXByteCtr--;                            // Decrement RX byte counter
    if (RXByteCtr)
    {
      *PRxData++ = UCB1RXBUF;               // Move RX data to address PRxData
      if (RXByteCtr == 1 && multiple == 1)                   // Only one byte left?
        UCB1CTL1 |= UCTXSTP;                // Generate I2C stop condition
    }
    else
    {
      *PRxData = UCB1RXBUF;                 // Move final RX data to PRxData
      __bic_SR_register_on_exit(LPM0_bits); // Exit active CPU
    }
    break;
  case 12:                                  // Vector 12: TXIFG
    if (TXByteCtr)                          // Check TX byte counter
    {
      UCB1TXBUF = *PTxData++;               // Load TX buffer
      TXByteCtr--;                          // Decrement TX byte counter
    }
    else
    {
    if (stopBit){
      UCB1CTL1 |= UCTXSTP;                  // I2C stop condition						//Set a stop flag if this should be sent out or not
    }
      UCB1IFG &= ~UCTXIFG;                  // Clear USCI_B0 TX int flag
      __bic_SR_register_on_exit(LPM0_bits); // Exit LPM0
    }
  default: break;
  }
}