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 (SPI) or UART

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 the 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 (SPI)  and CLI_WRITE (UART) 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

I did post this originally in the SimpleLink forum but after a long while they have suggested I try see if you guys have any explanation a why now I2C is not working at all.

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;
  }
}

  • I have just checked both crystals on the board and neither of them are being driven by the MSP430 (scope produces a ramp that flattens out in a few ms). I'm not sure how this allows the UART and SPI to work but not the I2C.

    Kas

**Attention** This is a public forum