allow setting pins and SPI interface. For most client work, gpio0 is optional

src/WiFi.cpp

@@ -21,6 +21,9 @@
 #include "utility/wifi_drv.h"
 #include "WiFi.h"
 
+extern SPIClass *WIFININA_SPIWIFI;
+extern int8_t WIFININA_SLAVESELECT, WIFININA_SLAVEREADY, WIFININA_SLAVERESET, WIFININA_SLAVEGPIO0;
+
 extern "C" {
   #include "utility/wl_definitions.h"
   #include "utility/wl_types.h"
@@ -31,6 +34,23 @@ WiFiClass::WiFiClass()
 {
 }
 
+void WiFiClass::setPins(int8_t cs, int8_t ready, int8_t reset, int8_t gpio0, SPIClass *spi) {
+  WIFININA_SLAVESELECT = cs;
+  WIFININA_SLAVEREADY = ready; 
+  WIFININA_SLAVERESET = reset;
+  WIFININA_SLAVEGPIO0 = gpio0;
+  WIFININA_SPIWIFI = spi;
+}
+
+void WiFiClass::setLEDs(uint8_t red, uint8_t green, uint8_t blue) {
+  WiFiDrv::pinMode(25, OUTPUT);
+  WiFiDrv::pinMode(26, OUTPUT);
+  WiFiDrv::pinMode(27, OUTPUT);
+  WiFiDrv::analogWrite(25, red);
+  WiFiDrv::analogWrite(26, green);
+  WiFiDrv::analogWrite(27, blue);
+}
+
 void WiFiClass::init()
 {
     WiFiDrv::wifiDriverInit();

src/WiFi.h

@@ -24,6 +24,8 @@
 #define WIFI_FIRMWARE_LATEST_VERSION "1.2.1"
 
 #include <inttypes.h>
+#include <Arduino.h>
+#include <SPI.h>
 
 extern "C" {
 	#include "utility/wl_definitions.h"
@@ -259,6 +261,9 @@ public:
     int ping(const char* hostname, uint8_t ttl = 128);
     int ping(const String &hostname, uint8_t ttl = 128);
     int ping(IPAddress host, uint8_t ttl = 128);
+
+    void setPins(int8_t cs=10, int8_t ready=7, int8_t reset=5, int8_t gpio0=6, SPIClass *spi = &SPI);
+    void setLEDs(uint8_t red, uint8_t green, uint8_t blue);
 };
 
 extern WiFiClass WiFi;

src/utility/spi_drv.cpp

@@ -49,18 +49,13 @@ extern "C" {
 #include "utility/debug.h"
 }
 
-static uint8_t SLAVESELECT = 10; // ss
-static uint8_t SLAVEREADY  = 7;  // handshake pin
-static uint8_t SLAVERESET  = 5;  // reset pin
-
 static bool inverted_reset = false;
+SPIClass *WIFININA_SPIWIFI=&SPI;
+int8_t WIFININA_SLAVESELECT = 10, WIFININA_SLAVEREADY = 7, 
+  WIFININA_SLAVERESET = 5, WIFININA_SLAVEGPIO0 = 6;
 
 #define DELAY_TRANSFER()
 
-#ifndef SPIWIFI
-#define SPIWIFI SPI
-#endif
-
 bool SpiDrv::initialized = false;
 
 void SpiDrv::begin()
@@ -70,41 +65,56 @@ void SpiDrv::begin()
 #endif
 
 #ifdef SPIWIFI_SS
-      SLAVESELECT = SPIWIFI_SS;
+      WIFININA_SLAVESELECT = SPIWIFI_SS;
 #endif
-
+      
 #ifdef SPIWIFI_ACK
-      SLAVEREADY = SPIWIFI_ACK;
+      WIFININA_SLAVEREADY = SPIWIFI_ACK;
+#endif
+      
+#ifdef SPIWIFI_RESET
+      WIFININA_SLAVERESET = (uint8_t)SPIWIFI_RESET;
+#endif
+      
+#ifdef NINA_GPIO0
+      WIFININA_SLAVEGPIO0 = NINA_GPIO0;
 #endif
 
-#ifdef SPIWIFI_RESET
-      SLAVERESET = (uint8_t)SPIWIFI_RESET;
+#ifdef SPIWIFI
+      WIFININA_SPIWIFI = &SPIWIFI;
 #endif
 
 #ifdef ARDUINO_SAMD_MKRVIDOR4000
       inverted_reset = false;
 #else
-      if (SLAVERESET > PINS_COUNT) {
+#ifdef PINS_COUNT
+      if (WIFININA_SLAVERESET > PINS_COUNT) {
         inverted_reset = true;
-        SLAVERESET = ~SLAVERESET;
+        WIFININA_SLAVERESET = ~WIFININA_SLAVERESET;
       }      
+#endif
 #endif
 
-      SPIWIFI.begin();
-      pinMode(SLAVESELECT, OUTPUT);
-      pinMode(SLAVEREADY, INPUT);
-      pinMode(SLAVERESET, OUTPUT);
-      pinMode(NINA_GPIO0, OUTPUT);
+      WIFININA_SPIWIFI->begin();
+      pinMode(WIFININA_SLAVESELECT, OUTPUT);
+      pinMode(WIFININA_SLAVEREADY, INPUT);
+      pinMode(WIFININA_SLAVERESET, OUTPUT);
 
-      digitalWrite(NINA_GPIO0, HIGH);
-      digitalWrite(SLAVESELECT, HIGH);
-      digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);
+      if (WIFININA_SLAVEGPIO0 >= 0) {
+	pinMode(WIFININA_SLAVEGPIO0, OUTPUT);
+	digitalWrite(WIFININA_SLAVEGPIO0, HIGH);
+      }
+
+      digitalWrite(WIFININA_SLAVESELECT, HIGH);
+      digitalWrite(WIFININA_SLAVERESET, inverted_reset ? HIGH : LOW);
       delay(10);
-      digitalWrite(SLAVERESET, inverted_reset ? LOW : HIGH);
+      digitalWrite(WIFININA_SLAVERESET, inverted_reset ? LOW : HIGH);
       delay(750);
 
-      digitalWrite(NINA_GPIO0, LOW);
-      pinMode(NINA_GPIO0, INPUT);
+      if (WIFININA_SLAVEGPIO0 >= 0) {
+	digitalWrite(WIFININA_SLAVEGPIO0, LOW);
+	pinMode(WIFININA_SLAVEGPIO0, INPUT);
+      }
 
 #ifdef _DEBUG_
 	  INIT_TRIGGER()
@@ -114,36 +124,36 @@ void SpiDrv::begin()
 }
 
 void SpiDrv::end() {
-    digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);
+    digitalWrite(WIFININA_SLAVERESET, inverted_reset ? HIGH : LOW);
 
-    pinMode(SLAVESELECT, INPUT);
+    pinMode(WIFININA_SLAVESELECT, INPUT);
 
-    SPIWIFI.end();
+    WIFININA_SPIWIFI->end();
 
     initialized = false;
 }
 
 void SpiDrv::spiSlaveSelect()
 {
-    SPIWIFI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
-    digitalWrite(SLAVESELECT,LOW);
+    WIFININA_SPIWIFI->beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
+    digitalWrite(WIFININA_SLAVESELECT, LOW);
 
     // wait for up to 5 ms for the NINA to indicate it is not ready for transfer
     // the timeout is only needed for the case when the shield or module is not present
-    for (unsigned long start = millis(); (digitalRead(SLAVEREADY) != HIGH) && (millis() - start) < 5;);
+    for (unsigned long start = millis(); (digitalRead(WIFININA_SLAVEREADY) != HIGH) && (millis() - start) < 5;);
 }
 
 
 void SpiDrv::spiSlaveDeselect()
 {
-    digitalWrite(SLAVESELECT,HIGH);
-    SPIWIFI.endTransaction();
+    digitalWrite(WIFININA_SLAVESELECT,HIGH);
+    WIFININA_SPIWIFI->endTransaction();
 }
 
 
 char SpiDrv::spiTransfer(volatile char data)
 {
-    char result = SPIWIFI.transfer(data);
+    char result = WIFININA_SPIWIFI->transfer(data);
     DELAY_TRANSFER();
 
     return result;                    // return the received byte
@@ -197,10 +207,10 @@ char SpiDrv::readChar()
             return 0;                                   \
         }else                                           \
 
-#define waitSlaveReady() (digitalRead(SLAVEREADY) == LOW)
-#define waitSlaveSign() (digitalRead(SLAVEREADY) == HIGH)
-#define waitSlaveSignalH() while(digitalRead(SLAVEREADY) != HIGH){}
-#define waitSlaveSignalL() while(digitalRead(SLAVEREADY) != LOW){}
+#define waitSlaveReady() (digitalRead(WIFININA_SLAVEREADY) == LOW)
+#define waitSlaveSign() (digitalRead(WIFININA_SLAVEREADY) == HIGH)
+#define waitSlaveSignalH() while(digitalRead(WIFININA_SLAVEREADY) != HIGH){}
+#define waitSlaveSignalL() while(digitalRead(WIFININA_SLAVEREADY) != LOW){}
 
 void SpiDrv::waitForSlaveSign()
 {
@@ -562,7 +572,10 @@ void SpiDrv::sendCmd(uint8_t cmd, uint8_t numParam)
 
 int SpiDrv::available()
 {
-    return (digitalRead(NINA_GPIO0) != LOW);
+  if (WIFININA_SLAVEGPIO0 >= 0) {
+    return (digitalRead(WIFININA_SLAVEGPIO0) != LOW);
+  }
+  return true;
 }
 
 SpiDrv spiDrv;

src/utility/spi_drv.h

@@ -22,6 +22,8 @@
 #define SPI_Drv_h
 
 #include <inttypes.h>
+#include <Arduino.h>
+#include <SPI.h>
 #include "utility/wifi_spi.h"
 
 #define SPI_START_CMD_DELAY 	10