DNSTest tool - testing your core internet connection

I am starting a thread in the Troubleshooting section for resolving an issue with Cores that are not able to resolve DNS properly.

The typical behavior is the calls to TCPConnect will fail when using a hostname, but work when using a IP address.

In this case you need to look at what the core set its DNS server to during the setup of DHCP. I have a few cores that fail to correctly setup DNS and they always get set to 76.83.0.0.

I have written this utility to help diagnose and control the WiFi connection. CAUTION - Use carefully

/*
 *  DNSTEST.ino
 *
 *  Written October 2014
 *  Scott Piette (Piette Technologies, LTD)
 *  Copyright (c) 2014, 2015 Piette Technologies, LTD
 *
 *  Updated January 2015
 *      Added display of RSSI when WiFi is on
 *      Fixed bCloudConnect flag when WiFi is disconnected or off
 *      Enabled use of connecting to cloud after WiFi is on
 *      Implemented way to fix DNS if CC3000 is bad
 *
 *  License:  GPL v3 (http://www.gnu.org/licenses/gpl.html)
 *
 *  Application:  DNSTEST.ino
 *
 *  This application is designed to test the network settings on the Spark
 *  It prompts the user for options allowing the user to control the network connection
 *
 *  Options are -
 *          [0] Print IP/DNS settings
 *          [1] WiFi Enable / Disable
 *          [2] WiFi Clear Credentials
 *          [3] WiFi Set Credentials
 *          [4] WiFi Connect / Disconnect
 *          [5] Set WiFi to DHCP
 *          [6] Set WiFi to static IP/DNS
 *          [7] Connect / Disconnect Cloud
 *          [8] Test DNS lookup
 *          [9] Fix DNS
 *
 *
 *   NOTE:  When you use Reset IP it will force the IP addresses set below into the Spark
 *          You should change the USER settings below to reflect your specific environment
 */

#include <application.h>

SYSTEM_MODE(MANUAL)

// The following define will enable additional options
// not generally needed but I wanted to keep them in there for future use
//#define EXPERT_MODE

// User defined information  ## THESE ARE FOR YOU TO CHANGE ##
#define USER_WIFI_SSID         "Your_SSID"
#define USER_WIFI_PASSWORD     "Your_SSID_PASSWORD"
#define USER_IPADDRESS         192, 168, 1, 104
#define USER_NETMASK           255, 255, 255, 0
#define USER_GATEWAY           192, 168, 1, 1
#define USER_DNS               192, 168, 1, 1

// Global variables
bool bWiFiEnable;
bool bWiFiConnect;
bool bCloudConnect;
bool bGoodDNS;
uint8_t badDNS[] = { 0, 0, 83, 76};   // the TI chip bad DNS
char _buf[20];
char _strMacAddress[18];

char *MacAddress2Str(byte *_mac, bool bReverse = false)
{
	if (bReverse)
		// if the mac is from WiFi.macAddress use this
		sprintf(_strMacAddress, "%02x:%02x:%02x:%02x:%02x:%02x",
            _mac[5], _mac[4], _mac[3], _mac[2], _mac[1], _mac[0]);
	else
        // if the mac is from nvmem_get_mac_address use this
		sprintf(_strMacAddress, "%02x:%02x:%02x:%02x:%02x:%02x",
            _mac[0], _mac[1], _mac[2], _mac[3], _mac[4], _mac[5]);
	return _strMacAddress;
}

void printIP(byte *_addr) {
	sprintf(_strMacAddress, "%i.%i.%i.%i", _addr[3], _addr[2], _addr[1], _addr[0]);
    if (!memcmp(badDNS, _addr, sizeof(badDNS)))
    	sprintf(_buf,"%-15s * |", _strMacAddress);
    else
    	sprintf(_buf,"%-17s |", _strMacAddress);
	Serial.println(_buf);
}

void printIPAddr(IPAddress _addr) {
	sprintf(_strMacAddress, "%i.%i.%i.%i", _addr[0], _addr[1], _addr[2], _addr[3]);
	sprintf(_buf,"%-17s |", _strMacAddress);
	Serial.println(_buf);
}

/*
 *  Helper that takes an IP address and turns it into a 32 bit int
 */
uint32_t IP2U32(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
  uint32_t ip = a;
  ip <<= 8;
  ip |= b;
  ip <<= 8;
  ip |= c;
  ip <<= 8;
  ip |= d;

  return ip;
}

bool setStaticIPAddress(uint32_t ip, uint32_t subnetMask, uint32_t defaultGateway, uint32_t dnsServer)
{
    // Reverse order of bytes in parameters so IP2U32 packed values can be used with the netapp_dhcp function.
    ip = (ip >> 24) | ((ip >> 8) & 0x0000FF00L) | ((ip << 8) & 0x00FF0000L) | (ip << 24);
    subnetMask = (subnetMask >> 24) | ((subnetMask >> 8) & 0x0000FF00L) | ((subnetMask << 8) & 0x00FF0000L) | (subnetMask << 24);
    defaultGateway = (defaultGateway >> 24) | ((defaultGateway >> 8) & 0x0000FF00L) | ((defaultGateway << 8) & 0x00FF0000L) | (defaultGateway << 24);
    dnsServer = (dnsServer >> 24) | ((dnsServer >> 8) & 0x0000FF00L) | ((dnsServer << 8) & 0x00FF0000L) | (dnsServer << 24);

    // Update DHCP state with specified values.
    if (netapp_dhcp(&ip, &subnetMask, &defaultGateway, &dnsServer) != 0) {
      return false;
    }

    // Reset CC3000 to use modified setting.
    wlan_stop();
    delay(200);
    wlan_start(0);
    return true;
}

/**************************************************************************/
/*!
    @brief    Set the CC3000 to use request an IP and network configuration
              using DHCP.  Note that this DHCP state will be saved in the
              CC3000's non-volatile storage and reused on next reconnect.
              This means you only need to call this once and the CC3000 will
              remember the setting forever.  To switch to use a static IP,
              call the cc3000.setStaticIPAddress function.

    @returns  False if an error occurred, true if successfully set.
*/
/**************************************************************************/
bool setDHCP()
{
    return setStaticIPAddress(0,0,0,0);
}

void setDNSIP() {
/*   Optional: Set a static IP address instead of using DHCP.
     Note that the setStaticIPAddress function will save its state
     in the CC3000's internal non-volatile memory and the details
     will be used the next time the CC3000 connects to a network.
     This means you only need to call the function once and the
     CC3000 will remember the connection details.  To switch back
     to using DHCP, call the setDHCP() function (again only needs
     to be called once).
*/
    uint32_t ipAddress = IP2U32(USER_IPADDRESS);
    uint32_t netMask = IP2U32(USER_NETMASK);
    uint32_t defaultGateway = IP2U32(USER_GATEWAY);
    uint32_t dns = IP2U32(USER_DNS);
    if (!setStaticIPAddress(ipAddress, netMask, defaultGateway, dns)) {
        Serial.println("Failed to set static IP!");
        while(1);
    }
}

#define MAX_CONNECT_RETRY 5  // Used by the test function for the number of attempts to connect to the test server
#define MAX_WIFI_RETRY 100  // Used by fixDNS for the number of times in the loop to wait for the WiFi to complete

// CAUTION, This function is aggressive and may damage the hardware
// use at your own risk, it is disabled by default
void fixDNS() {
    // start with the WiFi connected to the AP
	// check if we have a bad DNS address 76.83.0.0
	// make sure the CC3000 knows we want to use DHCP
	// disconnect from the AP
	// make sure the CC3000 knows we want to use DHCP
	// reconnect to the AP
	// go to the beginning and if we still have a bad DNS IP then do it all over again.

	// the bad DNS ip address
	uint8_t badDNS[] = { 0, 0, 83, 76};   // the TI chip bad DNS ip
	bool bGoodDNS = false;
    uint8_t _timeout;
    uint8_t _resetTimeout = 5;


    while (!bGoodDNS && _resetTimeout-- > 0) {
    	Serial.print("Attempt #");
    	Serial.println(5-_resetTimeout);
    	// start with the WiFi connected to the AP
        if (!bWiFiConnect) {
		    Serial.println("Connecting to AP");
		    WiFi.connect();
		    Serial.print("Waiting for WiFi to connect ");
		    _timeout = 0;
		    while (_timeout++ < MAX_WIFI_RETRY && !WiFi.ready()) { Serial.print("+"); Spark.process(); delay(100);}
            while (ip_config.aucDNSServer[3] == 0 && ip_config.aucDNSServer[2] == 0) { Serial.print("-"); Spark.process(); delay(100); }
		    _timeout = 0;
            while (_timeout++ < (MAX_WIFI_RETRY/2) &&  ip_config.aucDNSServer[3] == 76 && ip_config.aucDNSServer[2] == 83) { Serial.print("*"); Spark.process(); delay(100); }
            if (_timeout == MAX_WIFI_RETRY) {
                Serial.print("Failed to connect to WiFi router - credentials ");
                Serial.println(WiFi.hasCredentials() ? "known" : "unknown");
                bGoodDNS = true;  // bail!!
            }
            else Serial.println();
            bWiFiConnect = WiFi.ready();
        }

        // check if we have a bad DNS address 76.83.0.0
	    if (!memcmp(badDNS, ip_config.aucDNSServer, sizeof(badDNS))) {
            // make sure the CC3000 knows we want to use DHCP
            Serial.println("Resetting CC3000 to DHCP while connected");
            setStaticIPAddress(0,0,0,0);
            delay(500);

            // disconnect from the AP
            Serial.println("Disconnecting from AP");
            WiFi.disconnect();
            Serial.print("Waiting for WiFi to disconnect ");
            _timeout = 0;
            while (_timeout < MAX_WIFI_RETRY && WiFi.ready()) { Serial.print("-"); Spark.process(); _timeout++; delay(100); }
            while (ip_config.aucDNSServer[3] != 0 || ip_config.aucDNSServer[2] != 0) { Serial.print("-"); Spark.process(); delay(100); }
            Serial.println();
            bWiFiConnect = false;
            bCloudConnect = false;

            // make sure the CC3000 knows we want to use DHCP
            Serial.println("Resetting CC3000 to DHCP while not connected");
            setStaticIPAddress(0,0,0,0);
            delay(500);
        } else {
		    bGoodDNS = true;
            Serial.println("Success!");
        }
	}
}

void resetDNS() {
    Serial.println("Resetting DNS IP");
    setDNSIP();
}

void dumpIP() {
	Serial.print("\r\n");
    Serial.println("+---------------------------------+");
    Serial.println("|        DNS Test App v2.0        |");
    Serial.println("|    Scott Piette Jan 14, 2015    |");

    Serial.println("+-------------+-------------------+");
	Serial.print("| CC30000     | ");
	Serial.println(bWiFiEnable?"On                |":"Off               |");
    if (bWiFiEnable) {
        uint8_t mac[6];
    	Serial.print("|   Mac Addr  | ");
        if (bWiFiConnect)
            WiFi.macAddress(mac);  // use this function if the CC3000 is on and WiFi connected
        else
        	nvmem_get_mac_address(mac); // use this function only the CC3000 is on
        Serial.print(MacAddress2Str(mac, bWiFiConnect));
        Serial.println(" |");
	}
    Serial.println("|-------------+-------------------|");
	  Serial.print("| WiFi        | ");
	Serial.println(bWiFiConnect?   "Connected         |":"Not Connected     |");
    if (bWiFiConnect) {
		Serial.print("|   SSID      | ");
		sprintf(_buf,"%-17s |", WiFi.SSID());
		Serial.println(_buf);
    	Serial.print("|   RSSI      | ");
		sprintf(_buf,"%-17i |", WiFi.RSSI());
		Serial.println(_buf);
        Serial.print("|   Local IP  | ");
        printIPAddr(WiFi.localIP());
    }
	if (bWiFiConnect) {
		Serial.print("|   Subnet    | ");
		printIPAddr(WiFi.subnetMask());
		Serial.print("|   Gateway   | ");
		printIPAddr(WiFi.gatewayIP());
	    Serial.print("|   DNS IP    | ");
		printIP(ip_config.aucDNSServer);
	}
    Serial.println("|-------------+-------------------|");
	  Serial.print("| Spark Cloud | ");
	Serial.println(bCloudConnect?"Connected         |":"Not Connected     |");
    Serial.println("+-------------+-------------------+");
}

#define MAX_CONNECT_TIMEOUT 100  // How many times in while loop to wait for connection
int connectHttpServerHost(char *_host) {
    int  _ret;
    int _timeout;
    TCPClient _client;
    int8_t _c;
    uint8_t _message[] = { 'G', 'E', 'T', '\n', '\n' };

    //Serial.println("Starting client.connect");
    if(_client.connect(_host, 80)) {
	    //Serial.println("After client.connect()");
	    _timeout = 0;
	    while ( _timeout < MAX_CONNECT_TIMEOUT && !_client.connected()) {
	        //if (!_timeout) Serial.print("Waiting for connect ");
	        //else Serial.print(".");
	        delay(10);
	        ++_timeout;
	    }
	    //if (_timeout) Serial.println("");
	    //Serial.print("Sending");
	    _client.write(_message, 5);
	    _timeout = 0;
	    while (_timeout < MAX_CONNECT_TIMEOUT && !(_ret = _client.available())) {
	        //if (!_timeout) Serial.print("\r\nWaiting for response");
	        //else Serial.print(".");
	        delay(100);
	        ++_timeout;
	    }
	    //if (_ret) {
	    //    Serial.print("\r\nResponse Length = ");
	    //    Serial.println(_ret);
	    //    while ((_c = _client.read()) != -1)
		//    Serial.print((char) _c);
	    //}
	    //else
	    //    Serial.println("\r\nNo Response.");
	    _client.flush();
	    _client.stop();
	    return 1;
    }
    return 0;
}

void setup() {
    Serial.begin(9600);
    while(!Serial.available()) {
        Serial.println("Press any key to begin");
        delay(1000);
    }
    Serial.read();  // Clear any key
    dumpIP();
}

void loop() {

    byte _ans;
    int _ret;
    int _timeout = 0;

    Serial.println("\r\nEnter");
    Serial.print("   [0] Print interface status\r\n");
    Serial.print("   [1] CC3000 ");
    Serial.print(bWiFiEnable?"Disable":"Enable");
    Serial.println();
    if (bWiFiEnable) {
        Serial.print("   [2] WiFi ");
        Serial.println(bWiFiConnect?"Disconnect":"Connect");
#if defined(EXPERT_MODE)
        Serial.print("   [3] WiFi Clear Credentials\r\n");
        Serial.print("   [4] WiFi Set Credentials\r\n");
        Serial.print("   [5] Set WiFi to DHCP\r\n");
        Serial.print("   [6] Set WiFi to static IP/DNS\r\n");
    }
    Serial.print("   [7] Cloud ");
    Serial.print(bCloudConnect?"Disconnect":"Connect");
    Serial.println();
    if (bWiFiConnect) {
        Serial.print("   [8] Test DNS lookup\r\n");
    	if (!memcmp(badDNS, ip_config.aucDNSServer, sizeof(badDNS)))
            Serial.print("   [9] Fix DNS\r\n");
#else
	}
    Serial.print("   [3] Cloud ");
    Serial.print(bCloudConnect?"Disconnect":"Connect");
    Serial.println();
    if (bWiFiConnect) {
        Serial.print("   [4] Test DNS lookup\r\n");
        if (!memcmp(badDNS, ip_config.aucDNSServer, sizeof(badDNS)))
            Serial.print("   [5] Fix DNS\r\n");
#endif
    }

    Serial.print("   --> ");
    while(!Serial.available()) { if (WiFi.ready()) Spark.process(); };
    _ans = Serial.read();
    switch (_ans) {
        case '0':
            Serial.println("Print interface status");
            dumpIP();
            break;
        case '1':
            Serial.print("CC3000 ");
            Serial.print(bWiFiEnable?" Disable":" Enable");
            Serial.print("\r\n\r\nCC3000 - ");
            if (bWiFiEnable) {
                Serial.println("disabling");
            	if (bWiFiConnect) {
                    WiFi.disconnect();
                    Serial.print("Waiting for WiFi to disconnect ");
                    while (_timeout < MAX_WIFI_RETRY && WiFi.ready()) { Serial.print("-"); _timeout++; delay(100); }
                    while (ip_config.aucDNSServer[3] != 0 || ip_config.aucDNSServer[2] != 0)
                        { Serial.print("-"); delay(100); }
                    bCloudConnect = false;
                    Serial.println();
            	}
                WiFi.off();
                Serial.print("Waiting for CC3000 to turn off ");
                while (WiFi.ready()) { Serial.print("-"); Spark.process(); delay(100); }
                while (ip_config.aucDNSServer[3] != 0 || ip_config.aucDNSServer[2] != 0)
                    { Serial.print("+"); delay(100); }
                bWiFiEnable = false;
                bWiFiConnect = false;
                bCloudConnect = false;
            }
            else {
                Serial.println("enabling");
                WiFi.on();
                bWiFiEnable = true;
            }
            delay(500);
            dumpIP();
            break;
        case '2':
            Serial.print("WiFi ");
            Serial.print(bWiFiConnect?"Disconnect":"Connect");
            Serial.print("\r\n\r\nWiFi - ");
            if (bWiFiEnable) {
                if (bWiFiConnect) {
                    Serial.println("disconnecting");
                    WiFi.disconnect();
                    Serial.print("Waiting for WiFi to disconnect ");
                    while (_timeout < MAX_WIFI_RETRY && WiFi.ready()) { Serial.print("-"); _timeout++; delay(100); }
                    while (ip_config.aucDNSServer[3] != 0 || ip_config.aucDNSServer[2] != 0)
                        { Serial.print("-"); delay(100); }
                    bCloudConnect = false;
                    Serial.println();
                }
                else {
                    Serial.println("connecting");
                    WiFi.connect();
                    Serial.print("Waiting for WiFi to connect ");
                    while (_timeout < MAX_WIFI_RETRY && !WiFi.ready()) { Serial.print("+"); _timeout++; delay(100);}
                    if (_timeout == MAX_WIFI_RETRY) {
                        Serial.print("Failed to connect to WiFi router - credentials ");
                        Serial.println(WiFi.hasCredentials() ? "known" : "unknown");
                    }
                    else Serial.println();
                    _timeout = 0;
                }
                bWiFiConnect = WiFi.ready();
                delay(500);
                dumpIP();
            } else
                Serial.println("Error - CC3000 must be enabled");
            break;
#if defined(EXPERT_MODE)
        case '3':
            if (bWiFiEnable) {
                Serial.println("Clearing WiFi Credentials");
                WiFi.clearCredentials();
                dumpIP();
            } else
                Serial.println("Error - CC3000 must be enabled");
            break;
        case '4':
            if (bWiFiEnable) {
                Serial.println("Setting WiFi Credentials");
                WiFi.setCredentials(USER_WIFI_SSID, USER_WIFI_PASSWORD);
                dumpIP();
            } else
                Serial.println("Error - CC3000 must be enabled");
            break;
        case '5':
            if (bWiFiEnable) {
                Serial.println("Setting WiFi to DHCP\r\n");
                setDHCP();
                delay(500);
                dumpIP();
            } else
                Serial.println("Error - CC3000 must be enabled");
            break;
        case '6':
            if (bWiFiEnable) {
                Serial.println("Setting WiFi to static IP/DNS\r\n");
                setDNSIP();
                delay(500);
                dumpIP();
            } else
                Serial.println("Error - CC3000 must be enabled");
            break;
        case '7':
#else
        case '3':
#endif
        	Serial.print("Cloud ");
            Serial.print(bCloudConnect?"Disconnect":"Connect");
            Serial.print("\r\n\r\nCloud - ");
            if (bCloudConnect) {
                Serial.print("disconnecting -");
                Spark.disconnect();
                _timeout = 0;
                while (_timeout < MAX_WIFI_RETRY && Spark.connected()) { Serial.print("-"); _timeout++; delay(100);}
                if (_timeout == MAX_WIFI_RETRY) {
                    Serial.println("Failed to disconnect from cloud");
                }
                else Serial.println();
            } else {
            	Serial.print("connecting +");
            	Spark.connect();
            	_timeout = 0;
            	while (_timeout < MAX_WIFI_RETRY && !Spark.connected()) { Serial.print("+"); _timeout++; delay(100);}
            	if (_timeout == MAX_WIFI_RETRY) {
            		Serial.println("Failed to connect to Spark Cloud.");
            	}
                else {
                	Serial.println();
                	bWiFiEnable = true;
                	bWiFiConnect = WiFi.ready();
                }
            }
            bCloudConnect = Spark.connected();
            dumpIP();
            break;
#if defined(EXPERT_MODE)
        case '8':
#else
        case '4':
#endif
            Serial.println("Test DNS\r\n\r\nConnect to data.sparkfun.com - ");
            if (bWiFiEnable && bWiFiConnect) {
                while (_timeout < MAX_CONNECT_RETRY && !(_ret = connectHttpServerHost("data.sparkfun.com")))  {
                    delay(100);
                    ++_timeout;
                }
                if (_ret)
                    Serial.print("Connect successful! ");
                else
                    Serial.print("Connect unsuccessful. ");

                if (_timeout > 0) {
                    Serial.print("[ ");
                    Serial.print(_timeout);
                    if (_timeout > 1)
                        Serial.print("retries]");
                    else
                        Serial.print("retry]");
                }
                Serial.println();
            } else
                Serial.println("Error - CC3000 must be enabled and WiFi connected");
            break;
#if defined(EXPERT_MODE)
        case '9':
#else
        case '5':
#endif
            Serial.println("Fix DNS\r\n\r\nFixing DNS IP -");
            if (bWiFiConnect) {
                if (!memcmp(badDNS, ip_config.aucDNSServer, sizeof(badDNS))) {
                    fixDNS();
            	    dumpIP();
                }
                else
                    Serial.println("Error - CC3000 DNS must be 76.83.0.0");
            }
            else
                Serial.println("Error - CC3000 must be enabled and WiFi connected");
            break;
        default:
            Serial.println("Invalid selection.");
            break;
    }

}

All debugging is done via the serial port. When you launch the app it will start the Spark in manual WiFi mode. You will be prompted with the following options -

> Press any key to begin
> Press any key to begin

> +---------------------------------+
> |        DNS Test App v2.0        |
> |    Scott Piette Jan 14, 2015    |
> +-------------+-------------------+
> | CC30000     | Off               |
> |-------------+-------------------|
> | WiFi        | Not Connected     |
> |-------------+-------------------|
> | Spark Cloud | Not Connected     |
> +-------------+-------------------+

> Enter
>    [0] Print interface status
>    [1] CC3000 Enable
>    [7] Cloud Connect
>    --> 

You have the option of printing the IP settings, turning the CC3000 on or off or connect to the cloud. The connect to the cloud will call Spark.connect() and that call is fairly automated, it will enable the CC3000, WiFi, connect to the router and finally the spark cloud.

After you have enabled the CC3000 you will see more options -

CC3000 - enabling

+---------------------------------+
|        DNS Test App v2.0        |
|    Scott Piette Jan 14, 2015    |
+-------------+-------------------+
| CC30000     | On                |
|   Mac Addr  | 08:00:28:72:38:26 |
|-------------+-------------------|
| WiFi        | Not Connected     |
|-------------+-------------------|
| Spark Cloud | Not Connected     |
+-------------+-------------------+

Enter
   [0] Print interface status
   [1] CC3000 Disable
   [2] WiFi Connect
   [3] WiFi Clear Credentials
   [4] WiFi Set Credentials
   [5] Set WiFi to DHCP
   [6] Set WiFi to static IP/DNS
   [7] Cloud Connect
   --> 

The list of options above is what you will see in expert mode. You can try connecting to your router, clearing or setting your credentials (remember to put your wifi router settings in the code). You can also set DHCP or Static IP settings (you need to set your static IP settings in the code) and finally you still have the option of connecting to the cloud from here. Note your MAC address is now available.

Once you have connected to a WiFi network and have an IP address you have a one more option -

WiFi - connecting
Waiting for WiFi to connect +++++

+---------------------------------+
|        DNS Test App v2.0        |
|    Scott Piette Jan 14, 2015    |
+-------------+-------------------+
| CC30000     | On                |
|   Mac Addr  | 08:00:28:72:38:26 |
|-------------+-------------------|
| WiFi        | Connected         |
|   SSID      | PietteFiOS        |
|   RSSI      | -51               |
|   Local IP  | 192.168.1.105     |
|   Subnet    | 255.255.255.0     |
|   Gateway   | 192.168.1.1       |
|   DNS IP    | 192.168.1.1       |
|-------------+-------------------|
| Spark Cloud | Not Connected     |
+-------------+-------------------+

Enter
   [0] Print interface status
   [1] CC3000 Disable
   [2] WiFi Disconnect
   [3] WiFi Clear Credentials
   [4] WiFi Set Credentials
   [5] Set WiFi to DHCP
   [6] Set WiFi to static IP/DNS
   [7] Cloud Connect
   [8] Test DNS lookup
   --> 

Once you have established a connection to your WiFi router you can now test DNS. Option [8] will attempt a connection to data.sparkfun.com using DNS to resolve the IP address. It will try this several times. If you are unable to get an connection look at your DNS IP. If it is set to 76.83.0.0 then you have the problem. If the program detects you have 76.83.0.0 as your DNS IP then you will have another option to try and correct this.

If your DNS is set to 76.83.0.0 then you should try the latest CC3000 following these instructions from @Dave

If you use the spark-cli, and place your core in dfu-mode ( https://github.com/spark/spark-cli )
spark flash --usb cc3000
8 Likes

Fantastic! I’m sure that will be immensely helpful in finding a possible workaround for these DNS issues!

This is awesome - thanks so much for sharing!

Has this been sorted yet. I have just spent 3 days fighting to get Ubidots to work with my Core, only to find the root cause is an incorrect DNS lookup. Frustrated to say the least. I have resorted to using the IP address, 15 years ago I would have lived with this, but in today’s world surely TI can at least get DNS working.

Hi @Howard

Sorry about the frustrating debug–I know it is hard. TI has been OK at debugging stuff but it takes a long time even when you rub their nose in the bug.

There is an alternative DNS library that @Hootie81 wrote that can help you if you have room in memory.

Can I ask if your network is “funny” in any way? Are you on a slow link or have a complicated network setup? At this point we don’t know what causes this problem and I am trying to gather data about it.

@bko

Yes I do have a “funny” network. I recently “upgraded” to a VHDSL connection (I live in a little village in the UK) and now get a massive 18 mbps, however they seem to drop the connection on a regular bases so I do see delays in setting up a TCP pipe sometimes. The Core software connects to the Spark server (I assume that CoAP is a more robust protocol) everytime.

I have an apartment that I stay in for work, I’ll check the Core out on there next week. That has a far better IP connection.

If you ever need something tested just drop me a line.

1 Like

I have updated this sample code to be able to correctly pull the MAC address after the CC3000 has been enabled. There are also some additional fixes / changes to make the tool more useful. The new version can be found here

2 Likes