Fez T18 wifi request failed

Hello, I got an error when running my program with a FEZ T18 card. The program has worked on one card and it does not work on another. Containment problem I have no other card to try …
I updated the firmware of the wifi and the card but I still have the problem.

could you ping the wifi ip address?

yes i can do it even after the bug.

could you send http GET to Google.com?

If yes then something wrong with 192.168.1.3

192.168.1.3 works well because it’s domoticz and my light turns on correctly. With google I have the same error.

And the wifi is update with the file : SPWF04S-170216-fd39c59-Full.hex

how can we see the firmware version of the wifi?

https://docs.ghielectronics.com/hardware/components/spwf04sa.html

When the WiFi module starts, it sends a PowerOn message which tells you what firmware version is installed. For example, PowerOn 171117-0328fe3-SPWF04S . In this case the firmware is dated 17 November 2017.

in the firmware zip file I found a more recent file. So it works without problem for the 1st call but not for the 2nd, I have an exception “System.invalidOperationException” in the dll SPWF04Sx.dll

I tested by inverting the two SendHttpGet, in 1st it still works.
I also got the message from the wifi card, it is as follows:

#### Exception System.InvalidOperationException - 0x00000000 (1) ####
#### Message: 
#### GHIElectronics.TinyCLR.Drivers.STMicroelectronics.SPWF04Sx.SPWF04SxInterface::SendHttpGet [IP: 0009] ####
#### FezClientRestFul.Program::Main [IP: 0153] ####

Hello @letailleur, perhaps it’s better if you post your complete code. So eventually others can try your code on their boards.
Kind regards
RoSchmi

using GHIElectronics.TinyCLR.Devices.Gpio;
using GHIElectronics.TinyCLR.Devices.Spi;
using GHIElectronics.TinyCLR.Drivers.STMicroelectronics.SPWF04Sx;
using GHIElectronics.TinyCLR.Pins;
using System;
using System.Collections;
using System.Diagnostics;
using System.Net.NetworkInterface;
using System.Text;
using System.Threading;

namespace FezClientRestFul
{
class Program
{
private static GpioPin led1;
private static GpioPin led2;
private static GpioPin btn1;
private static SPWF04SxInterface wifi;
static void Main()
{
Debug.WriteLine(“début”);
var cont = GpioController.GetDefault();
var reset = cont.OpenPin(FEZ.GpioPin.WiFiReset);
var irq = cont.OpenPin(FEZ.GpioPin.WiFiInterrupt);
var mode = cont.OpenPin(FEZCLR.GpioPin.PA0);
var scont = SpiController.FromName(FEZ.SpiBus.WiFi);
var spi = scont.GetDevice(SPWF04SxInterface.GetConnectionSettings(SpiChipSelectType.Gpio, FEZ.GpioPin.WiFiChipSelect));

        mode.SetDriveMode(GpioPinDriveMode.InputPullDown);

        btn1 = cont.OpenPin(FEZ.GpioPin.Btn1);
        btn1.SetDriveMode(GpioPinDriveMode.InputPullUp);

        led1 = cont.OpenPin(FEZ.GpioPin.Led1);
        led1.SetDriveMode(GpioPinDriveMode.Output);
        led1.Write(GpioPinValue.Low);

        led2 = cont.OpenPin(FEZ.GpioPin.Led2);
        led2.SetDriveMode(GpioPinDriveMode.Output);
        led2.Write(GpioPinValue.Low);

        wifi = new SPWF04SxInterface(spi, irq, reset);
        wifi.IndicationReceived += Message;
        wifi.ErrorReceived += Erreur;
        //   wifi.IndicationReceived += (s, e) => Debug.WriteLine($"WIND: {Program.WindToName(e.Indication)} {e.Message}");
        //   wifi.ErrorReceived += (s, e) => Debug.WriteLine($"ERROR: {e.Error} {e.Message}");
        Debug.WriteLine("Configuration broche terminé!");

        Thread.Sleep(1000);
        wifi.TurnOn();
        Debug.WriteLine("wifi.TurnOn()"+ wifi.Description);
        Thread.Sleep(1000);
        NetworkInterface.ActiveNetworkInterface = wifi;
        Thread.Sleep(1000);

// if (wifi.State == SPWF04SxWiFiState.HardwarePowerUp)
// Debug.WriteLine(“etat HardwarePowerUp”);
wifi.JoinNetwork(“Epinay2.4Ghz”, “Epinay2.4Ghz”);
// wifi.
Debug.WriteLine(“connecté”);
Thread.Sleep(2000);
Thread.Sleep(2000);
wifi.ClearTlsServerRootCertificate();
Thread.Sleep(2000);
Debug.WriteLine(“avant appel!!!”);
led1.Write(GpioPinValue.High);
// wifi.SendHttpGet(“192.168.1.3”, “/json.htm?type=command&param=switchlight&idx=1246&switchcmd=On”, 8080, SPWF04SxConnectionSecurityType.None);
try
{
while (true)
{
WaitForButton();
// wifi.SendHttpGet(“192.168.1.3”, “/json.htm?type=command&param=switchlight&idx=1839&switchcmd=On”, 8080, SPWF04SxConnectionSecurityType.None);
wifi.SendHttpGet(“192.168.1.3”, “/json.htm?type=command&param=switchlight&idx=1839&switchcmd=Off”, 8080, SPWF04SxConnectionSecurityType.None); //wifi.SendHttpGet(“www.google.com”, “/”, 80, SPWF04SxConnectionSecurityType.None);
byte[] reponse = new byte[255];
wifi.ReadHttpResponse(reponse, 0, 250);
string texte = System.Text.Encoding.UTF8.GetString(reponse);
Debug.WriteLine(texte);
SPWF04SxWiFiState etat = wifi.State;
Debug.WriteLine(texte);

                led2.Write(GpioPinValue.High);
                WaitForButton();
                wifi.SendHttpGet("192.168.1.3", "/json.htm?type=command&param=switchlight&idx=1839&switchcmd=On", 8080, SPWF04SxConnectionSecurityType.None);
                //                wifi.SendHttpGet("192.168.1.3", "/json.htm?type=command&param=switchlight&idx=1839&switchcmd=Off", 8080, SPWF04SxConnectionSecurityType.None);
                led2.Write(GpioPinValue.Low);
            }
        }catch (Exception e)
        {
            SPWF04SxWiFiState etat = wifi.State;

        }

        /*            Debug.WriteLine("après appel");
                    Thread.Sleep(1000);
                    var buffer = new byte[512];
                    wifi.ReadHttpResponse(buffer, 0, buffer.Length);
                    Debug.WriteLine(Encoding.UTF8.GetString(buffer));
                    Debug.WriteLine("eteindre");
                    Thread.Sleep(1000);
                    led1.Write(GpioPinValue.Low);
                    wifi.TurnOff();
        */
    }

    private static void WaitForButton()
    {
        while (btn1.Read() == GpioPinValue.High)
        {
            Thread.Sleep(50);
        }

        while (btn1.Read() == GpioPinValue.Low)
            Thread.Sleep(50);
    }

    private static void Message(SPWF04SxInterface sender, SPWF04SxIndicationReceivedEventArgs e)
    {
        Debug.WriteLine("##" + e.Message + "##");
    }
    private static void Erreur(SPWF04SxInterface sender, SPWF04SxErrorReceivedEventArgs e)
    {
        Debug.WriteLine("!!!" + e.Message + "!!!");
    }
    private static string WindToName(SPWF04SxIndication wind)
    {
        switch (wind)
        {
            case SPWF04SxIndication.ConsoleActive: return nameof(SPWF04SxIndication.ConsoleActive);
            case SPWF04SxIndication.PowerOn: return nameof(SPWF04SxIndication.PowerOn);
            case SPWF04SxIndication.Reset: return nameof(SPWF04SxIndication.Reset);
            case SPWF04SxIndication.WatchdogRunning: return nameof(SPWF04SxIndication.WatchdogRunning);
            case SPWF04SxIndication.LowMemory: return nameof(SPWF04SxIndication.LowMemory);
            case SPWF04SxIndication.WiFiHardwareFailure: return nameof(SPWF04SxIndication.WiFiHardwareFailure);
            case SPWF04SxIndication.ConfigurationFailure: return nameof(SPWF04SxIndication.ConfigurationFailure);
            case SPWF04SxIndication.HardFault: return nameof(SPWF04SxIndication.HardFault);
            case SPWF04SxIndication.StackOverflow: return nameof(SPWF04SxIndication.StackOverflow);
            case SPWF04SxIndication.MallocFailed: return nameof(SPWF04SxIndication.MallocFailed);
            case SPWF04SxIndication.RadioStartup: return nameof(SPWF04SxIndication.RadioStartup);
            case SPWF04SxIndication.WiFiPSMode: return nameof(SPWF04SxIndication.WiFiPSMode);
            case SPWF04SxIndication.Copyright: return nameof(SPWF04SxIndication.Copyright);
            case SPWF04SxIndication.WiFiBssRegained: return nameof(SPWF04SxIndication.WiFiBssRegained);
            case SPWF04SxIndication.WiFiSignalLow: return nameof(SPWF04SxIndication.WiFiSignalLow);
            case SPWF04SxIndication.WiFiSignalOk: return nameof(SPWF04SxIndication.WiFiSignalOk);
            case SPWF04SxIndication.BootMessages: return nameof(SPWF04SxIndication.BootMessages);
            case SPWF04SxIndication.KeytypeNotImplemented: return nameof(SPWF04SxIndication.KeytypeNotImplemented);
            case SPWF04SxIndication.WiFiJoin: return nameof(SPWF04SxIndication.WiFiJoin);
            case SPWF04SxIndication.WiFiJoinFailed: return nameof(SPWF04SxIndication.WiFiJoinFailed);
            case SPWF04SxIndication.WiFiScanning: return nameof(SPWF04SxIndication.WiFiScanning);
            case SPWF04SxIndication.ScanBlewUp: return nameof(SPWF04SxIndication.ScanBlewUp);
            case SPWF04SxIndication.ScanFailed: return nameof(SPWF04SxIndication.ScanFailed);
            case SPWF04SxIndication.WiFiUp: return nameof(SPWF04SxIndication.WiFiUp);
            case SPWF04SxIndication.WiFiAssociationSuccessful: return nameof(SPWF04SxIndication.WiFiAssociationSuccessful);
            case SPWF04SxIndication.StartedAP: return nameof(SPWF04SxIndication.StartedAP);
            case SPWF04SxIndication.APStartFailed: return nameof(SPWF04SxIndication.APStartFailed);
            case SPWF04SxIndication.StationAssociated: return nameof(SPWF04SxIndication.StationAssociated);
            case SPWF04SxIndication.DhcpReply: return nameof(SPWF04SxIndication.DhcpReply);
            case SPWF04SxIndication.WiFiBssLost: return nameof(SPWF04SxIndication.WiFiBssLost);
            case SPWF04SxIndication.WiFiException: return nameof(SPWF04SxIndication.WiFiException);
            case SPWF04SxIndication.WiFiHardwareStarted: return nameof(SPWF04SxIndication.WiFiHardwareStarted);
            case SPWF04SxIndication.WiFiNetwork: return nameof(SPWF04SxIndication.WiFiNetwork);
            case SPWF04SxIndication.WiFiUnhandledEvent: return nameof(SPWF04SxIndication.WiFiUnhandledEvent);
            case SPWF04SxIndication.WiFiScan: return nameof(SPWF04SxIndication.WiFiScan);
            case SPWF04SxIndication.WiFiUnhandledIndication: return nameof(SPWF04SxIndication.WiFiUnhandledIndication);
            case SPWF04SxIndication.WiFiPoweredDown: return nameof(SPWF04SxIndication.WiFiPoweredDown);
            case SPWF04SxIndication.HWInMiniAPMode: return nameof(SPWF04SxIndication.HWInMiniAPMode);
            case SPWF04SxIndication.WiFiDeauthentication: return nameof(SPWF04SxIndication.WiFiDeauthentication);
            case SPWF04SxIndication.WiFiDisassociation: return nameof(SPWF04SxIndication.WiFiDisassociation);
            case SPWF04SxIndication.WiFiUnhandledManagement: return nameof(SPWF04SxIndication.WiFiUnhandledManagement);
            case SPWF04SxIndication.WiFiUnhandledData: return nameof(SPWF04SxIndication.WiFiUnhandledData);
            case SPWF04SxIndication.WiFiUnknownFrame: return nameof(SPWF04SxIndication.WiFiUnknownFrame);
            case SPWF04SxIndication.Dot11Illegal: return nameof(SPWF04SxIndication.Dot11Illegal);
            case SPWF04SxIndication.WpaCrunchingPsk: return nameof(SPWF04SxIndication.WpaCrunchingPsk);
            case SPWF04SxIndication.WpaTerminated: return nameof(SPWF04SxIndication.WpaTerminated);
            case SPWF04SxIndication.WpaStartFailed: return nameof(SPWF04SxIndication.WpaStartFailed);
            case SPWF04SxIndication.WpaHandshakeComplete: return nameof(SPWF04SxIndication.WpaHandshakeComplete);
            case SPWF04SxIndication.GpioInterrupt: return nameof(SPWF04SxIndication.GpioInterrupt);
            case SPWF04SxIndication.Wakeup: return nameof(SPWF04SxIndication.Wakeup);
            case SPWF04SxIndication.PendingData: return nameof(SPWF04SxIndication.PendingData);
            case SPWF04SxIndication.InputToRemote: return nameof(SPWF04SxIndication.InputToRemote);
            case SPWF04SxIndication.OutputFromRemote: return nameof(SPWF04SxIndication.OutputFromRemote);
            case SPWF04SxIndication.SocketClosed: return nameof(SPWF04SxIndication.SocketClosed);
            case SPWF04SxIndication.IncomingSocketClient: return nameof(SPWF04SxIndication.IncomingSocketClient);
            case SPWF04SxIndication.SocketClientGone: return nameof(SPWF04SxIndication.SocketClientGone);
            case SPWF04SxIndication.SocketDroppingData: return nameof(SPWF04SxIndication.SocketDroppingData);
            case SPWF04SxIndication.RemoteConfiguration: return nameof(SPWF04SxIndication.RemoteConfiguration);
            case SPWF04SxIndication.FactoryReset: return nameof(SPWF04SxIndication.FactoryReset);
            case SPWF04SxIndication.LowPowerMode: return nameof(SPWF04SxIndication.LowPowerMode);
            case SPWF04SxIndication.GoingIntoStandby: return nameof(SPWF04SxIndication.GoingIntoStandby);
            case SPWF04SxIndication.ResumingFromStandby: return nameof(SPWF04SxIndication.ResumingFromStandby);
            case SPWF04SxIndication.GoingIntoDeepSleep: return nameof(SPWF04SxIndication.GoingIntoDeepSleep);
            case SPWF04SxIndication.ResumingFromDeepSleep: return nameof(SPWF04SxIndication.ResumingFromDeepSleep);
            case SPWF04SxIndication.StationDisassociated: return nameof(SPWF04SxIndication.StationDisassociated);
            case SPWF04SxIndication.SystemConfigurationUpdated: return nameof(SPWF04SxIndication.SystemConfigurationUpdated);
            case SPWF04SxIndication.RejectedFoundNetwork: return nameof(SPWF04SxIndication.RejectedFoundNetwork);
            case SPWF04SxIndication.RejectedAssociation: return nameof(SPWF04SxIndication.RejectedAssociation);
            case SPWF04SxIndication.WiFiAuthenticationTimedOut: return nameof(SPWF04SxIndication.WiFiAuthenticationTimedOut);
            case SPWF04SxIndication.WiFiAssociationTimedOut: return nameof(SPWF04SxIndication.WiFiAssociationTimedOut);
            case SPWF04SxIndication.MicFailure: return nameof(SPWF04SxIndication.MicFailure);
            case SPWF04SxIndication.UdpBroadcast: return nameof(SPWF04SxIndication.UdpBroadcast);
            case SPWF04SxIndication.WpsGeneratedDhKeyset: return nameof(SPWF04SxIndication.WpsGeneratedDhKeyset);
            case SPWF04SxIndication.WpsEnrollmentAttemptTimedOut: return nameof(SPWF04SxIndication.WpsEnrollmentAttemptTimedOut);
            case SPWF04SxIndication.SockdDroppingClient: return nameof(SPWF04SxIndication.SockdDroppingClient);
            case SPWF04SxIndication.NtpServerDelivery: return nameof(SPWF04SxIndication.NtpServerDelivery);
            case SPWF04SxIndication.DhcpFailedToGetLease: return nameof(SPWF04SxIndication.DhcpFailedToGetLease);
            case SPWF04SxIndication.MqttPublished: return nameof(SPWF04SxIndication.MqttPublished);
            case SPWF04SxIndication.MqttClosed: return nameof(SPWF04SxIndication.MqttClosed);
            case SPWF04SxIndication.WebSocketData: return nameof(SPWF04SxIndication.WebSocketData);
            case SPWF04SxIndication.WebSocketClosed: return nameof(SPWF04SxIndication.WebSocketClosed);
            case SPWF04SxIndication.FileReceived: return nameof(SPWF04SxIndication.FileReceived);
            default: return "Other";
        }
    }
}

}

Thanks, which version of the libraries do you have installed in your project?

in visual 2019 nuget give 1.0.0

I had a look on your code and found some things but didn’t get it working in a short time.
Since the SPWF04SX library V 1.0 has some known issues I wouldn’t spend to much time to get it running.
I would suggest to take one of these two options:

  1. Do not use the master SPWF04Sx library from NuGet but download the library from the dev branch

https://github.com/ghi-electronics/TinyCLR-Drivers/tree/dev/STMicroelectronics/SPWF04Sx

  1. About a year ago I had a quite stable application, which I just tried.

https://github.com/RoSchmi/AzureDataSender_FEZ

From the working initialization there it should be easy to adapt it to your needs.

Thank you but I don’t see how to make a SendHttpGet () with your library?
the namesapce GHIElectronics.TinyCLR.Drivers.STMicroelectronics.SPWF04Sx, have you changed it or not?

Yes, I think that there were some changes. It’s quite a time since I worked on this. I will have a look. But you get the time from the NTP server?, then the basics are working.

after deleting all the Azure part, I actually recover my @ip l hour etc etc.
but as soon as I make a wifi.senhttpget () I have an error IP: 00a3 IP: 000b and IP: 0009 and a Request failed

It’s better if I specify the communication port :).
the order passes and my light turns on but at the second request I have the error (Informations supplémentaire : Variable length response command already outstanding. ) in the method:
protected SPWF04SxCommand GetVariableLengthResponseCommand ()
{
if (this.activeVariableLengthResponseCommand! = null) throw new InvalidOperationException (“Variable length response command already outstanding.”);

         return this.activeVariableLengthResponseCommand = this.GetCommand ();
     }

I made some more tests.
If I add this code after the line ‘wifi.ClearTlsServerRootCertificate();’

I get a response with this code:

        var buffer = new byte[512];
        var start = DateTime.UtcNow;
        var code = wifi.SendHttpGet("files.ghielectronics.com", "/", 80,  SPWF04SxConnectionSecurityType.None);
        Debug.WriteLine($"HTTP {code}");

But if I remember right I think that I used the HttpWebRequest Class like it was shown in the GHI example:

private static void TestHttp(string host, string url, string commonName = null)
    {
        if (commonName != null)
        {
            wifi.ForceSocketsTls = true;
            wifi.ForceSocketsTlsCommonName = commonName;
        }
        var buffer = new byte[512];
        var start = DateTime.UtcNow;
        var req = (HttpWebRequest)HttpWebRequest.Create(host + url);
        req.HttpsAuthentCerts = new[] { new X509Certificate() };
        var res = (HttpWebResponse)req.GetResponse();
        var str = res.GetResponseStream();
        Debug.WriteLine($"HTTP {res.StatusCode}");
        var total = 0;
        while (str.Read(buffer, 0, buffer.Length) is var read && read > 0)
        {
            total += read;
            try
            {
                Debugger.Log(0, "", Encoding.UTF8.GetString(buffer, 0, read));
            }
            catch
            {
                Debugger.Log(0, "", Encoding.UTF8.GetString(buffer, 0, read - 1));
            }
            Thread.Sleep(100);
        }
        Debug.WriteLine($"\r\nRead: {total:N0} in {(DateTime.UtcNow - start).TotalMilliseconds:N0}ms");
    }