feat: add Bluetooth LE mode, radio power budget and NINA firmware update path

arduino/libraries/Arduino_SpiNINA/src/Arduino_SpiNINA.h

@@ -0,0 +1,13 @@
+/*
+  This file is part of the Arduino_SpiNINA library.
+
+  Copyright (C) Arduino s.r.l. and/or its affiliated companies
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+#include <spi_drv.h>

arduino/libraries/Arduino_SpiNINA/src/spi_drv.cpp

@@ -0,0 +1,457 @@
+/*
+  This file is part of the Arduino_SpiNINA library.
+
+  Copyright (C) Arduino s.r.l. and/or its affiliated companies
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#include "Arduino.h"
+#include <SPI.h>
+#include "spi_drv.h"
+#include "pins_arduino.h"
+
+#ifdef ARDUINO_SAMD_MKRVIDOR4000
+// STRIX: the STRIX FPGA image passes the NINA module's pins through to SAMD21 pins, so the
+// module is driven directly (SPI on D8-D10) instead of through Arduino's FPGA peripherals.
+// GPIO0 is bidirectional through the FPGA; the firmware switches its direction around begin().
+#define NINA_GPIO0 6
+#define SPIWIFI_SS 5
+#define SPIWIFI_ACK 4
+#define SPIWIFI_RESET 7
+#endif
+
+// #define _DEBUG_
+#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;
+
+#define DELAY_TRANSFER()
+
+#ifndef SPIWIFI
+#define SPIWIFI SPI
+#endif
+
+#ifndef NINA_GPIOIRQ
+#define NINA_GPIOIRQ NINA_GPIO0
+#endif
+
+bool SpiDrv::initialized = false;
+
+void SpiDrv::begin(bool force) {
+  if (initialized && !force) {
+    return;
+  }
+
+
+#ifdef SPIWIFI_SS
+  SLAVESELECT = SPIWIFI_SS;
+#endif
+
+#ifdef SPIWIFI_ACK
+  SLAVEREADY = SPIWIFI_ACK;
+#endif
+
+#ifdef SPIWIFI_RESET
+  SLAVERESET = (uint8_t)SPIWIFI_RESET;
+#endif
+
+#ifdef ARDUINO_SAMD_MKRVIDOR4000
+  inverted_reset = false;
+#else
+  if (SLAVERESET > PINS_COUNT) {
+    inverted_reset = true;
+    SLAVERESET = ~SLAVERESET;
+  }
+#endif
+
+  pinMode(SLAVESELECT, OUTPUT);
+  pinMode(SLAVEREADY, INPUT);
+  pinMode(SLAVERESET, OUTPUT);
+  pinMode(NINA_GPIO0, OUTPUT);
+
+  digitalWrite(NINA_GPIO0, HIGH);
+  digitalWrite(SLAVESELECT, HIGH);
+  digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);
+  delay(10);
+  digitalWrite(SLAVERESET, inverted_reset ? LOW : HIGH);
+  delay(750);
+
+  digitalWrite(NINA_GPIO0, LOW);
+  pinMode(NINA_GPIOIRQ, INPUT);
+
+  SPIWIFI.begin();
+
+#ifdef _DEBUG_
+  INIT_TRIGGER()
+#endif
+
+  initialized = true;
+}
+
+void SpiDrv::end() {
+  digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);
+
+  pinMode(SLAVESELECT, INPUT);
+
+  SPIWIFI.end();
+
+  initialized = false;
+}
+
+void SpiDrv::spiSlaveSelect() {
+  SPIWIFI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
+  digitalWrite(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;);
+}
+
+
+void SpiDrv::spiSlaveDeselect() {
+  digitalWrite(SLAVESELECT, HIGH);
+  SPIWIFI.endTransaction();
+}
+
+
+char SpiDrv::spiTransfer(volatile char data) {
+  char result = SPIWIFI.transfer(data);
+  DELAY_TRANSFER();
+
+  return result;  // return the received byte
+}
+
+int SpiDrv::waitSpiChar(unsigned char waitChar) {
+  int timeout = TIMEOUT_CHAR;
+  unsigned char _readChar = 0;
+  do {
+    _readChar = readChar();  //get data byte
+    if (_readChar == ERR_CMD) {
+      WARN("Err cmd received\n");
+      return -1;
+    }
+  } while ((timeout-- > 0) && (_readChar != waitChar));
+  return (_readChar == waitChar);
+}
+
+int SpiDrv::readAndCheckChar(char checkChar, char* readChar) {
+  getParam((uint8_t*)readChar);
+
+  return (*readChar == checkChar);
+}
+
+char SpiDrv::readChar() {
+  uint8_t readChar = 0;
+  getParam(&readChar);
+  return readChar;
+}
+
+#define WAIT_START_CMD(x) waitSpiChar(START_CMD)
+
+#define IF_CHECK_START_CMD(x) \
+  if (!WAIT_START_CMD(_data)) { \
+    TOGGLE_TRIGGER() \
+    WARN("Error waiting START_CMD"); \
+    return 0; \
+  } else
+
+#define CHECK_DATA(check, x) \
+  if (!readAndCheckChar(check, &x)) { \
+    TOGGLE_TRIGGER() \
+    WARN("Reply error"); \
+    INFO2(check, (uint8_t)x); \
+    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) {}
+
+void SpiDrv::waitForSlaveSign() {
+  while (!waitSlaveSign());
+}
+
+void SpiDrv::waitForSlaveReady(bool const feed_watchdog) {
+  unsigned long const start = millis();
+  while (!waitSlaveReady()) {
+    if (feed_watchdog) {
+      if ((millis() - start) < 10000) {
+        //TODO: Feed watchdog in a proper way
+        //WiFi.feedWatchdog();
+      }
+    }
+  }
+}
+
+void SpiDrv::getParam(uint8_t* param) {
+  // Get Params data
+  *param = spiTransfer(DUMMY_DATA);
+  DELAY_TRANSFER();
+}
+
+int SpiDrv::waitResponseCmd(uint8_t cmd, uint8_t numParam, uint8_t* param, uint8_t* param_len) {
+  char _data = 0;
+  int ii = 0;
+
+  IF_CHECK_START_CMD(_data) {
+    CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+    CHECK_DATA(numParam, _data) {
+      readParamLen8(param_len);
+      for (ii = 0; ii < (*param_len); ++ii) {
+        // Get Params data
+        //param[ii] = spiTransfer(DUMMY_DATA);
+        getParam(&param[ii]);
+      }
+    }
+
+    readAndCheckChar(END_CMD, &_data);
+  }
+
+  return 1;
+}
+
+int SpiDrv::waitResponseData16(uint8_t cmd, uint8_t* param, uint16_t* param_len) {
+  char _data = 0;
+  uint16_t ii = 0;
+
+  IF_CHECK_START_CMD(_data) {
+    CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+    uint8_t numParam = readChar();
+    if (numParam != 0) {
+      readParamLen16(param_len);
+      for (ii = 0; ii < (*param_len); ++ii) {
+        // Get Params data
+        param[ii] = spiTransfer(DUMMY_DATA);
+      }
+    }
+
+    readAndCheckChar(END_CMD, &_data);
+  }
+
+  return 1;
+}
+
+int SpiDrv::waitResponseData8(uint8_t cmd, uint8_t* param, uint8_t* param_len) {
+  char _data = 0;
+  int ii = 0;
+
+  IF_CHECK_START_CMD(_data) {
+    CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+    uint8_t numParam = readChar();
+    if (numParam != 0) {
+      readParamLen8(param_len);
+      for (ii = 0; ii < (*param_len); ++ii) {
+        // Get Params data
+        param[ii] = spiTransfer(DUMMY_DATA);
+      }
+    }
+
+    readAndCheckChar(END_CMD, &_data);
+  }
+
+  return 1;
+}
+
+int SpiDrv::waitResponseParams(uint8_t cmd, uint8_t numParam, tParam* params) {
+  char _data = 0;
+  int i = 0, ii = 0;
+
+
+  IF_CHECK_START_CMD(_data) {
+    CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+    uint8_t _numParam = readChar();
+    if (_numParam != 0) {
+      for (i = 0; i < _numParam; ++i) {
+        params[i].paramLen = readParamLen8();
+        for (ii = 0; ii < params[i].paramLen; ++ii) {
+          // Get Params data
+          params[i].param[ii] = spiTransfer(DUMMY_DATA);
+        }
+      }
+    } else {
+      WARN("Error numParam == 0");
+      return 0;
+    }
+
+    if (numParam != _numParam) {
+      WARN("Mismatch numParam");
+      return 0;
+    }
+
+    readAndCheckChar(END_CMD, &_data);
+  }
+  return 1;
+}
+
+#define SPI_RESPONSE_MAX_LENGTH 32
+#define SPI_MAX_RESPONSE_NUMBER 10
+
+int SpiDrv::waitResponse(uint8_t cmd, uint8_t* numParamRead, uint8_t** params, uint8_t maxNumParams) {
+  char _data = 0;
+  int i = 0, ii = 0;
+
+  char* index[SPI_RESPONSE_MAX_LENGTH];
+
+  for (i = 0; i < SPI_MAX_RESPONSE_NUMBER; i++)
+    index[i] = (char*)params + SPI_RESPONSE_MAX_LENGTH * i;
+
+  IF_CHECK_START_CMD(_data) {
+    CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+    uint8_t numParam = readChar();
+
+    if (numParam > maxNumParams) {
+      numParam = maxNumParams;
+    }
+    *numParamRead = numParam;
+    if (numParam != 0) {
+      for (i = 0; i < numParam; ++i) {
+        uint8_t paramLen = readParamLen8();
+        for (ii = 0; ii < paramLen; ++ii) {
+          //ssid[ii] = spiTransfer(DUMMY_DATA);
+          // Get Params data
+          index[i][ii] = (uint8_t)spiTransfer(DUMMY_DATA);
+        }
+        index[i][ii] = 0;
+      }
+    } else {
+      WARN("Error numParams == 0");
+      readAndCheckChar(END_CMD, &_data);
+      return 0;
+    }
+    readAndCheckChar(END_CMD, &_data);
+  }
+  return 1;
+}
+
+void SpiDrv::sendParamNoLen(const uint8_t* param, size_t param_len, uint8_t lastParam) {
+  size_t i = 0;
+  // Send SPI paramLen
+  sendParamLen8(0);
+
+  // Send SPI param data
+  for (i = 0; i < param_len; ++i) {
+    spiTransfer(param[i]);
+  }
+
+  // if lastParam==1 Send SPI END CMD
+  if (lastParam == 1)
+    spiTransfer(END_CMD);
+}
+
+void SpiDrv::sendParam(const uint8_t* param, uint8_t param_len, uint8_t lastParam) {
+  int i = 0;
+  // Send SPI paramLen
+  sendParamLen8(param_len);
+
+  // Send SPI param data
+  for (i = 0; i < param_len; ++i) {
+    spiTransfer(param[i]);
+  }
+
+  // if lastParam==1 Send SPI END CMD
+  if (lastParam == 1)
+    spiTransfer(END_CMD);
+}
+
+void SpiDrv::sendParamLen8(uint8_t param_len) {
+  // Send SPI paramLen
+  spiTransfer(param_len);
+}
+
+void SpiDrv::sendParamLen16(uint16_t param_len) {
+  // Send SPI paramLen
+  spiTransfer((uint8_t)((param_len & 0xff00) >> 8));
+  spiTransfer((uint8_t)(param_len & 0xff));
+}
+
+uint8_t SpiDrv::readParamLen8(uint8_t* param_len) {
+  uint8_t _param_len = spiTransfer(DUMMY_DATA);
+  if (param_len != NULL) {
+    *param_len = _param_len;
+  }
+  return _param_len;
+}
+
+uint16_t SpiDrv::readParamLen16(uint16_t* param_len) {
+  uint16_t _param_len = spiTransfer(DUMMY_DATA) << 8 | (spiTransfer(DUMMY_DATA) & 0xff);
+  if (param_len != NULL) {
+    *param_len = _param_len;
+  }
+  return _param_len;
+}
+
+
+void SpiDrv::sendBuffer(const uint8_t* param, uint16_t param_len, uint8_t lastParam) {
+  uint16_t i = 0;
+
+  // Send SPI paramLen
+  sendParamLen16(param_len);
+
+  // Send SPI param data
+  for (i = 0; i < param_len; ++i) {
+    spiTransfer(param[i]);
+  }
+
+  // if lastParam==1 Send SPI END CMD
+  if (lastParam == 1)
+    spiTransfer(END_CMD);
+}
+
+
+void SpiDrv::sendParam(uint16_t param, uint8_t lastParam) {
+  // Send SPI paramLen
+  sendParamLen8(2);
+
+  spiTransfer((uint8_t)((param & 0xff00) >> 8));
+  spiTransfer((uint8_t)(param & 0xff));
+
+  // if lastParam==1 Send SPI END CMD
+  if (lastParam == 1)
+    spiTransfer(END_CMD);
+}
+
+/* Cmd Struct Message */
+/* _________________________________________________________________________________  */
+/*| START CMD | C/R  | CMD  |[TOT LEN]| N.PARAM | PARAM LEN | PARAM  | .. | END CMD | */
+/*|___________|______|______|_________|_________|___________|________|____|_________| */
+/*|   8 bit   | 1bit | 7bit |  8bit   |  8bit   |   8bit    | nbytes | .. |   8bit  | */
+/*|___________|______|______|_________|_________|___________|________|____|_________| */
+
+void SpiDrv::sendCmd(uint8_t cmd, uint8_t numParam) {
+  // Send SPI START CMD
+  spiTransfer(START_CMD);
+
+  // Send SPI C + cmd
+  spiTransfer(cmd & ~(REPLY_FLAG));
+
+  // Send SPI totLen
+  //spiTransfer(totLen);
+
+  // Send SPI numParam
+  spiTransfer(numParam);
+
+  // If numParam == 0 send END CMD
+  if (numParam == 0)
+    spiTransfer(END_CMD);
+}
+
+int SpiDrv::available() {
+  return (digitalRead(NINA_GPIOIRQ) != LOW);
+}
+
+SpiDrv spiDrv;

arduino/libraries/Arduino_SpiNINA/src/spi_drv.h

@@ -0,0 +1,67 @@
+/*
+  This file is part of the Arduino_SpiNINA library.
+
+  Copyright (C) Arduino s.r.l. and/or its affiliated companies
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef SPI_Drv_h
+#define SPI_Drv_h
+
+#include <inttypes.h>
+#include "spi_types.h"
+
+#define SPI_START_CMD_DELAY 10
+
+#define NO_LAST_PARAM 0
+#define LAST_PARAM 1
+
+#define DUMMY_DATA 0xFF
+
+#define WAIT_FOR_SLAVE_SELECT() \
+  if (!SpiDrv::initialized) { \
+    SpiDrv::begin(); \
+  } \
+  SpiDrv::waitForSlaveReady(); \
+  SpiDrv::spiSlaveSelect();
+
+class SpiDrv {
+private:
+  static void waitForSlaveSign();
+  static void getParam(uint8_t* param);
+public:
+  static bool initialized;
+
+  static void begin(bool force = false);
+  static void end();
+  static void spiDriverInit();
+  static void spiSlaveSelect();
+  static void spiSlaveDeselect();
+  static char spiTransfer(volatile char data);
+  static void waitForSlaveReady(bool const feed_watchdog = false);
+  static int waitSpiChar(unsigned char waitChar);
+  static int readAndCheckChar(char checkChar, char* readChar);
+  static char readChar();
+  static int waitResponseParams(uint8_t cmd, uint8_t numParam, tParam* params);
+  static int waitResponseCmd(uint8_t cmd, uint8_t numParam, uint8_t* param, uint8_t* param_len);
+  static int waitResponseData8(uint8_t cmd, uint8_t* param, uint8_t* param_len);
+  static int waitResponseData16(uint8_t cmd, uint8_t* param, uint16_t* param_len);
+  static int waitResponse(uint8_t cmd, uint8_t* numParamRead, uint8_t** params, uint8_t maxNumParams);
+  static void sendParam(const uint8_t* param, uint8_t param_len, uint8_t lastParam = NO_LAST_PARAM);
+  static void sendParamNoLen(const uint8_t* param, size_t param_len, uint8_t lastParam = NO_LAST_PARAM);
+  static void sendParamLen8(const uint8_t param_len);
+  static void sendParamLen16(const uint16_t param_len);
+  static uint8_t readParamLen8(uint8_t* param_len = NULL);
+  static uint16_t readParamLen16(uint16_t* param_len = NULL);
+  static void sendBuffer(const uint8_t* param, uint16_t param_len, uint8_t lastParam = NO_LAST_PARAM);
+  static void sendParam(uint16_t param, uint8_t lastParam = NO_LAST_PARAM);
+  static void sendCmd(uint8_t cmd, uint8_t numParam);
+  static int available();
+};
+
+extern SpiDrv spiDrv;
+
+#endif

arduino/libraries/Arduino_SpiNINA/src/spi_types.h

@@ -0,0 +1,88 @@
+/*
+  This file is part of the Arduino_SpiNINA library.
+
+  Copyright (C) Arduino s.r.l. and/or its affiliated companies
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+#include <inttypes.h>
+
+#define CMD_FLAG 0
+#define REPLY_FLAG 1 << 7
+#define DATA_FLAG 0x40
+
+#define WIFI_SPI_ACK 1
+#define WIFI_SPI_ERR 0xFF
+
+#define TIMEOUT_CHAR 1000
+
+#define START_CMD 0xE0
+#define END_CMD 0xEE
+#define ERR_CMD 0xEF
+#define CMD_POS 1        // Position of Command OpCode on SPI stream
+#define PARAM_LEN_POS 2  // Position of Param len on SPI stream
+
+
+enum numParams {
+  PARAM_NUMS_0,
+  PARAM_NUMS_1,
+  PARAM_NUMS_2,
+  PARAM_NUMS_3,
+  PARAM_NUMS_4,
+  PARAM_NUMS_5,
+  PARAM_NUMS_6,
+  MAX_PARAM_NUMS
+};
+
+#define MAX_PARAMS MAX_PARAM_NUMS - 1
+#define PARAM_LEN_SIZE 1
+
+typedef struct __attribute__((__packed__)) {
+  uint8_t paramLen;
+  char* param;
+} tParam;
+
+typedef struct __attribute__((__packed__)) {
+  uint16_t dataLen;
+  char* data;
+} tDataParam;
+
+typedef struct __attribute__((__packed__)) {
+  unsigned char cmd;
+  unsigned char tcmd;
+  unsigned char nParam;
+  tParam params[MAX_PARAMS];
+} tSpiMsg;
+
+typedef struct __attribute__((__packed__)) {
+  unsigned char cmd;
+  unsigned char tcmd;
+  unsigned char nParam;
+  tDataParam params[MAX_PARAMS];
+} tSpiMsgData;
+
+typedef struct __attribute__((__packed__)) {
+  unsigned char cmd;
+  unsigned char tcmd;
+  unsigned char nParam;
+} tSpiHdr;
+
+typedef struct __attribute__((__packed__)) {
+  uint8_t paramLen;
+  uint32_t param;
+} tLongParam;
+
+typedef struct __attribute__((__packed__)) {
+  uint8_t paramLen;
+  uint16_t param;
+} tIntParam;
+
+typedef struct __attribute__((__packed__)) {
+  uint8_t paramLen;
+  uint8_t param;
+} tByteParam;

arduino/libraries/Arduino_SpiNINA/src/utility/debug.h

@@ -0,0 +1,104 @@
+/*
+  This file is part of the Arduino_SpiNINA library.
+
+  Copyright (C) Arduino s.r.l. and/or its affiliated companies
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef Debug_H
+#define Debug_H
+
+#include <stdio.h>
+#include <string.h>
+
+#define PRINT_FILE_LINE() \
+  do { \
+    Serial.print("["); \
+    Serial.print(__FILE__); \
+    Serial.print("::"); \
+    Serial.print(__LINE__); \
+    Serial.print("]"); \
+  } while (0);
+
+#ifdef _DEBUG_
+
+#define INFO(format, args...) \
+  do { \
+    char buf[250]; \
+    sprintf(buf, format, args); \
+    Serial.println(buf); \
+  } while (0);
+
+#define INFO1(x) \
+  do { \
+    PRINT_FILE_LINE() \
+    Serial.print("-I-"); \
+    Serial.println(x); \
+  } while (0);
+
+
+#define INFO2(x, y) \
+  do { \
+    PRINT_FILE_LINE() \
+    Serial.print("-I-"); \
+    Serial.print(x, 16); \
+    Serial.print(","); \
+    Serial.println(y, 16); \
+  } while (0);
+
+
+#else
+#define INFO1(x) \
+  do { \
+  } while (0);
+#define INFO2(x, y) \
+  do { \
+  } while (0);
+#define INFO(format, args...) \
+  do { \
+  } while (0);
+#endif
+
+#if 0
+#define WARN(args) \
+  do { \
+    PRINT_FILE_LINE() \
+    Serial.print("-W-"); \
+    Serial.println(args); \
+  } while (0);
+#else
+#define WARN(args) \
+  do { \
+  } while (0);
+#endif
+
+#if _DEBUG_SPI_
+#define DBG_PIN2 5
+#define DBG_PIN 4
+
+#define START() digitalWrite(DBG_PIN2, HIGH);
+#define END() digitalWrite(DBG_PIN2, LOW);
+#define SET_TRIGGER() digitalWrite(DBG_PIN, HIGH);
+#define RST_TRIGGER() digitalWrite(DBG_PIN, LOW);
+
+#define INIT_TRIGGER() \
+  pinMode(DBG_PIN, OUTPUT); \
+  pinMode(DBG_PIN2, OUTPUT); \
+  RST_TRIGGER()
+#define TOGGLE_TRIGGER() \
+  SET_TRIGGER() \
+  delayMicroseconds(2); \
+  RST_TRIGGER()
+#else
+#define START()
+#define END()
+#define SET_TRIGGER()
+#define RST_TRIGGER()
+#define INIT_TRIGGER()
+#define TOGGLE_TRIGGER()
+#endif
+
+#endif