Giga WiFi not working

Official Hardware Mega GIGA R1 WiFi
1

I am using the GIGA R1 and the GIGA Display. I wanted to experiment with WiFi so I tried the example shown on GIGA R1 WiFi Network Examples here: GIGA R1 WiFi Network Examples | Arduino Documentation

The 'Scan Networks' example works fine, so I know the basic hardware is working.

However, when I try the 'Wi-Fi RTC Example', although I get no compile errors, I see this on the serial monitor:

`11:23:37.140 -> Attempting to connect to SSID:

This is odd because I have specified the SSID and password in the arduino_secrets.h tab which looks like this:

//arduino_secrets.h header file
#define SECRET_SSID "something"
#define SECRET_PASS "password"

(SSID and password changed of course)

The network is actually WEP so I thought I might have to change line 67, which in the example says:

status = WiFi.begin(ssid, pass);

to...

status = WiFi.begin(ssid, keyIndex, pass);

...but when I try this I get the following compile error:

C:\Users\nigel\AppData\Local\Temp\arduino\sketches\F7F8542EB79B0E12F9A8C07AA1F03F77\sketch\wifi2.ino.cpp.o: In function `setup':
C:\Users\nigel\Documents\Arduino\wifi2/wifi2.ino:67: undefined reference to `arduino::WiFiClass::begin(char const*, unsigned char, char const*)'
collect2.exe: error: ld returned 1 exit status

exit status 1

Compilation error: exit status 1

I wonder why the WiFi.begin doesn't seem to be working properly.

I have a suspicion that the fact that it is not printing the actual SSID with these lines:

Serial.print("Attempting to connect to SSID: ");
Serial.println(ssid);

...may be significant, but I can't see why it doesn't work, when in the example called 'WPA Connection' it does print the SSID (even though it (rightly) doesn't connect because it's a WEP network).

2

what example do you use? the WiFi library in Mbed Core has only one example WiFiWebClient.
so I guess you try the examples of the old WiFi library

3

An update: An error I found is that I had to change the char statements to:

char ssid[] = SECRET_SSID; // your network SSID (name)
char pass[] = SECRET_PASS; // your network password

...and I was able to connect to a WPA network. However, when I add in the keyIndex (to try to contact a WEP network) I still get the compile error.

4

I used examples shown in the link at the start of my post. Here it is again...

5 
  /* Start Wifi connection with WEP encryption.
     * Configure a key into the device. The key type (WEP-40, WEP-104)
     * is determined by the size of the key (5 bytes for WEP-40, 13 bytes for WEP-104).
     *
     * param ssid: Pointer to the SSID string.
     * param key_idx: The key index to set. Valid values are 0-3.
     * param key: Key input buffer.
     */
  int begin(const char* ssid, uint8_t key_idx, const char* key);

Hi, maybe not using the begin correctly - It's difficult to tell without a whole script

6

Hi Steve,

For convenience, here is the script:

/*
 Udp NTP Client

 Get the time from a Network Time Protocol (NTP) time server
 Demonstrates use of UDP sendPacket and ReceivePacket
 For more on NTP time servers and the messages needed to communicate with them,
 see http://en.wikipedia.org/wiki/Network_Time_Protocol

 created 4 Sep 2010
 by Michael Margolis
 modified 9 Apr 2012
 by Tom Igoe
 modified 28 Dec 2022
 by Giampaolo Mancini

This code is in the public domain.
 */

#include <WiFi.h>
#include <WiFiUdp.h>
#include <mbed_mktime.h>

int status = WL_IDLE_STATUS;
#include "arduino_secrets.h"
///////please enter your sensitive data in the Secret tab/arduino_secrets.h
char ssid[] = ""; // your network SSID (name)
char pass[] = ""; // your network password (use for WPA, or use as key for WEP)
int keyIndex = 0; // your network key index number (needed only for WEP)

unsigned int localPort = 2390; // local port to listen for UDP packets

// IPAddress timeServer(162, 159, 200, 123); // pool.ntp.org NTP server

constexpr auto timeServer { "pool.ntp.org" };

const int NTP_PACKET_SIZE = 48; // NTP timestamp is in the first 48 bytes of the message

byte packetBuffer[NTP_PACKET_SIZE]; // buffer to hold incoming and outgoing packets

// A UDP instance to let us send and receive packets over UDP
WiFiUDP Udp;

constexpr unsigned long printInterval { 1000 };
unsigned long printNow {};

void setup()
{
    // Open serial communications and wait for port to open:
    Serial.begin(9600);
    while (!Serial) {
        ; // wait for serial port to connect. Needed for native USB port only
    }

    // check for the WiFi module:
    if (WiFi.status() == WL_NO_SHIELD) {
        Serial.println("Communication with WiFi module failed!");
        // don't continue
        while (true)
            ;
    }

    // attempt to connect to WiFi network:
    while (status != WL_CONNECTED) {
        Serial.print("Attempting to connect to SSID: ");
        Serial.println(ssid);
        // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
        status = WiFi.begin(ssid, pass);

        // wait 10 seconds for connection:
        delay(10000);
    }

    Serial.println("Connected to WiFi");
    printWifiStatus();

    setNtpTime();

}

void loop()
{
    if (millis() > printNow) {
        Serial.print("System Clock:          ");
        Serial.println(getLocaltime());
        printNow = millis() + printInterval;
    }
}

void setNtpTime()
{
    Udp.begin(localPort);
    sendNTPpacket(timeServer);
    delay(1000);
    parseNtpPacket();
}

// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(const char * address)
{
    memset(packetBuffer, 0, NTP_PACKET_SIZE);
    packetBuffer[0] = 0b11100011; // LI, Version, Mode
    packetBuffer[1] = 0; // Stratum, or type of clock
    packetBuffer[2] = 6; // Polling Interval
    packetBuffer[3] = 0xEC; // Peer Clock Precision
    // 8 bytes of zero for Root Delay & Root Dispersion
    packetBuffer[12] = 49;
    packetBuffer[13] = 0x4E;
    packetBuffer[14] = 49;
    packetBuffer[15] = 52;

    Udp.beginPacket(address, 123); // NTP requests are to port 123
    Udp.write(packetBuffer, NTP_PACKET_SIZE);
    Udp.endPacket();
}

unsigned long parseNtpPacket()
{
    if (!Udp.parsePacket())
        return 0;

    Udp.read(packetBuffer, NTP_PACKET_SIZE);
    const unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    const unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
    const unsigned long secsSince1900 = highWord << 16 | lowWord;
    constexpr unsigned long seventyYears = 2208988800UL;
    const unsigned long epoch = secsSince1900 - seventyYears;
    set_time(epoch);

#if defined(VERBOSE)
    Serial.print("Seconds since Jan 1 1900 = ");
    Serial.println(secsSince1900);

    // now convert NTP time into everyday time:
    Serial.print("Unix time = ");
    // print Unix time:
    Serial.println(epoch);

    // print the hour, minute and second:
    Serial.print("The UTC time is "); // UTC is the time at Greenwich Meridian (GMT)
    Serial.print((epoch % 86400L) / 3600); // print the hour (86400 equals secs per day)
    Serial.print(':');
    if (((epoch % 3600) / 60) < 10) {
        // In the first 10 minutes of each hour, we'll want a leading '0'
        Serial.print('0');
    }
    Serial.print((epoch % 3600) / 60); // print the minute (3600 equals secs per minute)
    Serial.print(':');
    if ((epoch % 60) < 10) {
        // In the first 10 seconds of each minute, we'll want a leading '0'
        Serial.print('0');
    }
    Serial.println(epoch % 60); // print the second
#endif

    return epoch;
}

String getLocaltime()
{
    char buffer[32];
    tm t;
    _rtc_localtime(time(NULL), &t, RTC_FULL_LEAP_YEAR_SUPPORT);
    strftime(buffer, 32, "%Y-%m-%d %k:%M:%S", &t);
    return String(buffer);
}

void printWifiStatus()
{
    // print the SSID of the network you're attached to:
    Serial.print("SSID: ");
    Serial.println(WiFi.SSID());

    // print your board's IP address:
    IPAddress ip = WiFi.localIP();
    Serial.print("IP Address: ");
    Serial.println(ip);

    // print the received signal strength:
    long rssi = WiFi.RSSI();
    Serial.print("signal strength (RSSI):");
    Serial.print(rssi);
    Serial.println(" dBm");
}
7

hmm.. the .begin() for WEP is in Wifi.h but is not implemented in Wifi.cpp. You can raise an issue here GitHub - arduino/ArduinoCore-mbed

9

Thanks, I have raised the issue.

10

In order to make all relevant information available to any who are interested in this subject, I'll share a link to the issue report here:

1 Like