feedc0de/AsyncHTTPRequest_Generic
1
0
Fork 0
forked from khoih-prog/AsyncHTTPRequest_Generic
Code Pull Requests Activity

Update Packages_Patches

Browse Source
This commit is contained in:
Khoi Hoang
2021-11-23 02:14:54 -05:00
committed by GitHub
parent d1d442e927
commit 853798cd90
54 changed files with 5373 additions and 666 deletions
Download Patch File Download Diff File Expand all files Collapse all files

420
Packages_Patches/adafruit/hardware/nrf52/0.19.0/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.19.0/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.19.0/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.19.0/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.19.0/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.19.0/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/0.20.1/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.20.1/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.20.1/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.20.1/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.20.1/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.20.1/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/0.20.5/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.20.5/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.20.5/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.20.5/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.20.5/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.20.5/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/0.21.0/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.21.0/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.21.0/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.21.0/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.21.0/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.21.0/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/0.22.0/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.22.0/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.22.0/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.22.0/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.22.0/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.22.0/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/0.22.1/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.22.1/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.22.1/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.22.1/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.22.1/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.22.1/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/0.23.0/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.23.0/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.23.0/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.23.0/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.23.0/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.23.0/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/0.24.0/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/0.24.0/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/0.24.0/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/0.24.0/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/0.24.0/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/0.24.0/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces

420
Packages_Patches/adafruit/hardware/nrf52/1.0.0/cores/nRF5/Print.cpp Normal file
View File

@@ -0,0 +1,420 @@
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
//using namespace arduino;
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
if (write(*buffer++)) n++;
else break;
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(long long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printULLNumber(n, 10) + t;
}
return printULLNumber(n, 10);
} else {
return printULLNumber(n, base);
}
}
size_t Print::print(unsigned long long n, int base)
{
if (base == 0) return write(n);
else return printULLNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
return write("\r\n");
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char * format, ...)
{
char buf[256];
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(buf, 256, format, ap);
this->write(buf, len);
va_end(ap);
return len;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
// REFERENCE IMPLEMENTATION FOR ULL
// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
// {
// // if limited to base 10 and 16 the bufsize can be smaller
// char buf[65];
// char *str = &buf[64];
// *str = '\0';
// // prevent crash if called with base == 1
// if (base < 2) base = 10;
// do {
// unsigned long long t = n / base;
// char c = n - t * base; // faster than c = n%base;
// n = t;
// *--str = c < 10 ? c + '0' : c + 'A' - 10;
// } while(n);
// return write(str);
// }
// FAST IMPLEMENTATION FOR ULL
size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
{
// if limited to base 10 and 16 the bufsize can be 20
char buf[64];
uint8_t i = 0;
uint8_t innerLoops = 0;
// prevent crash if called with base == 1
if (base < 2) base = 10;
// process chunks that fit in "16 bit math".
uint16_t top = 0xFFFF / base;
uint16_t th16 = 1;
while (th16 < top)
{
th16 *= base;
innerLoops++;
}
while (n64 > th16)
{
// 64 bit math part
uint64_t q = n64 / th16;
uint16_t r = n64 - q*th16;
n64 = q;
// 16 bit math loop to do remainder. (note buffer is filled reverse)
for (uint8_t j=0; j < innerLoops; j++)
{
uint16_t qq = r/base;
buf[i++] = r - qq*base;
r = qq;
}
}
uint16_t n16 = n64;
while (n16 > 0)
{
uint16_t qq = n16/base;
buf[i++] = n16 - qq*base;
n16 = qq;
}
size_t bytes = i;
for (; i > 0; i--)
write((char) (buf[i - 1] < 10 ?
'0' + buf[i - 1] :
'A' + buf[i - 1] - 10));
return bytes;
}
size_t Print::printFloat(double number, int digits)
{
if (digits < 0)
digits = 2;
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)remainder;
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
size_t Print::printBuffer(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if ( i != 0 ) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[i]);
}
return (len*3 - 1);
}
size_t Print::printBufferReverse(uint8_t const buffer[], int len, char delim, int byteline)
{
if (buffer == NULL || len == 0) return 0;
for(int i=0; i<len; i++)
{
if (i != 0) print(delim);
if ( byteline && (i%byteline == 0) ) println();
this->printf("%02X", buffer[len-1-i]);
}
return (len*3 - 1);
}

107
Packages_Patches/adafruit/hardware/nrf52/1.0.0/cores/nRF5/Print.h Normal file
View File

@@ -0,0 +1,107 @@
/*
Copyright (c) 2016 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <inttypes.h>
#include <stdio.h> // for size_t
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printULLNumber(unsigned long long, uint8_t);
size_t printFloat(double, int);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
// default to zero, meaning "a single write may block"
// should be overridden by subclasses with buffering
virtual int availableForWrite() { return 0; }
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(long long, int = DEC);
size_t print(unsigned long long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(long long, int = DEC);
size_t println(unsigned long long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char * format, ...);
size_t printBuffer(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBuffer(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBuffer((uint8_t const*) buffer, size, delim, byteline);
}
size_t printBufferReverse(uint8_t const buffer[], int len, char delim=' ', int byteline = 0);
size_t printBufferReverse(char const buffer[], int size, char delim=' ', int byteline = 0)
{
return printBufferReverse((uint8_t const*) buffer, size, delim, byteline);
}
virtual void flush() { /* Empty implementation for backward compatibility */ }
};

69
Packages_Patches/adafruit/hardware/nrf52/1.0.0/variants/NINA_B112_ublox/variant.cpp
View File

@@ -17,46 +17,43 @@
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// Thanks to great work of [Miguel Alexandre Wisintainer](https://github.com/tcpipchip).
// See [u-blox nina b](https://github.com/khoih-prog/WiFiNINA_Generic/issues/1)
#include "variant.h" #include "variant.h"
#include "wiring_constants.h" #include "wiring_constants.h"
#include "wiring_digital.h" #include "wiring_digital.h"
#include "nrf.h" #include "nrf.h"
const uint32_t g_ADigitalPinMap[] = { //https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
0, //https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
};
const uint32_t g_ADigitalPinMap[] = {
// D0 .. D13
5, // D0 is P0.05 (UART RX)
6, // D1 is P0.06 (UART TX)
7, // D2 is P0.07
31, // D3 is P0.31
18, // D4 is P0.18 (LED Blue)
99, // D5 (NC)
9, // D6 is P0.09 NFC1
10, // D7 is P0.10 (Button) NFC2
99, // D8 (NC)
8, // D9 is P0.08
11, // D10 is P0.11 CS
13, // D11 is P0.13 MOSI
12, // D12 is P0.12 MISO
14, // D13 is P0.14 SCK
//I2C
2, // D14 is P0.2 (SDA)
3, // D15 is P0.3 (SCL)
// D16 .. D21 (aka A0 .. A5)
3, // D16 is P0.03 (A0)
2, // D17 is P0.02 (A1)
4, // D18 is P0.04 (A2)
30, // D19 is P0.30 (A3) SW2
29, // D20 is P0.29 (A4)
28, // D21 is P0.28 (A5)
9, // P0.09 NFC
10, // P0.10 NFC
16, // SW1 (LED Green)
};

67
Packages_Patches/adafruit/hardware/nrf52/1.0.0/variants/NINA_B112_ublox/variant.h
View File

@@ -16,6 +16,9 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
//https://www.u-blox.com/sites/default/files/NINA-B1_DataSheet_UBX-15019243.pdf
//https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29_C1-Public.pdf
#ifndef _VARIANT_NINA_B112_UBLOX_ #ifndef _VARIANT_NINA_B112_UBLOX_
#define _VARIANT_NINA_B112_UBLOX_ #define _VARIANT_NINA_B112_UBLOX_
@@ -52,30 +55,29 @@ extern "C"
#define LED_BUILTIN PIN_LED #define LED_BUILTIN PIN_LED
//LEDs onboard //LEDs onboard
#define LED1 (8) // Red #define LED1 (0) // Red
#define LED2 (16) // Green/SW1 #define LED2 (24) // Green/SW1
#define LED3 (18) // Blue #define LED3 (4) // Blue
#define LED_STATE_ON 1 // State when LED is litted #define LED_STATE_ON 1 // State when LED is litted
//Switch //Switch
#define SW1 (24)
#define SW1 (16) #define SW2 (19)
#define SW2 (30)
// NFC // NFC
#define PIN_NFC_1 (9) // P0.9 #define PIN_NFC_1 (6) // P0.9
#define PIN_NFC_2 (10) // P0.10 #define PIN_NFC_2 (7) // P0.10
/* /*
* Analog pins * Analog pins
*/ */
#define PIN_A0 (3) // P0.03 #define PIN_A0 (16) // P0.03
#define PIN_A1 (2) // P0.02 #define PIN_A1 (17) // P0.02
#define PIN_A2 (4) // P0.04 #define PIN_A2 (18) // P0.04
#define PIN_A3 (30) // P0.30 #define PIN_A3 (19) // P0.30
#define PIN_A4 (29) // P0.29 #define PIN_A4 (20) // P0.29
#define PIN_A5 (28) // P0.28 #define PIN_A5 (21) // P0.28
static const uint8_t A0 = PIN_A0 ; static const uint8_t A0 = PIN_A0 ;
static const uint8_t A1 = PIN_A1 ; static const uint8_t A1 = PIN_A1 ;
@@ -86,14 +88,14 @@ static const uint8_t A5 = PIN_A5 ;
#define ADC_RESOLUTION 14 #define ADC_RESOLUTION 14
#define PIN_D0 (5) // P0.05 #define PIN_D0 (0) // P0.05
#define PIN_D1 (6) // P0.06 #define PIN_D1 (1) // P0.06
#define PIN_D2 (7) // P0.07 #define PIN_D2 (2) // P0.07
#define PIN_D3 (31) // P0.31 #define PIN_D3 (4) // P0.31
#define PIN_D4 (18) // P0.18 #define PIN_D4 (5) // P0.18
#define PIN_D6 (9) // P0.09 #define PIN_D6 (6) // P0.09
#define PIN_D7 (10) // P0.10 #define PIN_D7 (7) // P0.10
#define PIN_D9 (8) // P0.8 #define PIN_D9 (9) // P0.08
#define PIN_D10 (11) // P0.11 #define PIN_D10 (11) // P0.11
#define PIN_D11 (13) // P0.13 #define PIN_D11 (13) // P0.13
#define PIN_D12 (12) // P0.12 #define PIN_D12 (12) // P0.12
@@ -125,13 +127,10 @@ static const uint8_t D15 = PIN_D15 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
//#define PIN_SERIAL_RX (8) //used for original Adafruit Bootloader #define PIN_SERIAL_RX (0) // P0.05
//#define PIN_SERIAL_TX (6) //used for original Adafruit Bootloader #define PIN_SERIAL_TX (1) // P0.06
#define PIN_SERIAL_CTS (2) // P0.07
#define PIN_SERIAL_RX (5) // P0.05 #define PIN_SERIAL_RTS (3) // P0.31
#define PIN_SERIAL_TX (6) // P0.06
#define PIN_SERIAL_CTS (7) // P0.07
#define PIN_SERIAL_RTS (31) // P0.31
#define PIN_SERIAL_DTR (28) // P0.28 #define PIN_SERIAL_DTR (28) // P0.28
#define PIN_SERIAL_DSR (29) // P0.29 #define PIN_SERIAL_DSR (29) // P0.29
@@ -141,10 +140,10 @@ static const uint8_t D15 = PIN_D15 ;
#define SPI_INTERFACES_COUNT 1 #define SPI_INTERFACES_COUNT 1
#define PIN_SPI_MISO (12) // P0.12 #define PIN_SPI_MISO (12) // P0.12
#define PIN_SPI_MOSI (13) // P0.13 #define PIN_SPI_MOSI (11) // P0.13
#define PIN_SPI_SCK (14) // P0.14 #define PIN_SPI_SCK (13) // P0.14
static const uint8_t SS = 11 ; // P0.11 static const uint8_t SS = 10 ; // P0.11
static const uint8_t MOSI = PIN_SPI_MOSI ; static const uint8_t MOSI = PIN_SPI_MOSI ;
static const uint8_t MISO = PIN_SPI_MISO ; static const uint8_t MISO = PIN_SPI_MISO ;
static const uint8_t SCK = PIN_SPI_SCK ; static const uint8_t SCK = PIN_SPI_SCK ;
@@ -154,8 +153,8 @@ static const uint8_t SCK = PIN_SPI_SCK ;
*/ */
#define WIRE_INTERFACES_COUNT 1 #define WIRE_INTERFACES_COUNT 1
#define PIN_WIRE_SDA (2) // P0.02 #define PIN_WIRE_SDA (14) // P0.02
#define PIN_WIRE_SCL (3) // P0.03 #define PIN_WIRE_SCL (15) // P0.03
static const uint8_t SDA = PIN_WIRE_SDA; static const uint8_t SDA = PIN_WIRE_SDA;
static const uint8_t SCL = PIN_WIRE_SCL; static const uint8_t SCL = PIN_WIRE_SCL;

4
Packages_Patches/adafruit/hardware/nrf52/1.0.0/variants/NINA_B302_ublox/variant.cpp
View File

@@ -28,8 +28,8 @@
const uint32_t g_ADigitalPinMap[] = const uint32_t g_ADigitalPinMap[] =
{ {
// D0 .. D13 // D0 .. D13
29, // D0 is P0.29 (UART TX) 29, // D0 is P0.29 (UART RX)
45, // D1 is P1.13 (UART RX 45, // D1 is P1.13 (UART TX)
44, // D2 is P1.12 (NFC2) 44, // D2 is P1.12 (NFC2)
31, // D3 is P0.31 (LED1) 31, // D3 is P0.31 (LED1)
13, // D4 is P0.13 (LED2) 13, // D4 is P0.13 (LED2)

4
Packages_Patches/adafruit/hardware/nrf52/1.0.0/variants/NINA_B302_ublox/variant.h
View File

@@ -101,8 +101,8 @@ static const uint8_t A5 = PIN_A5 ;
/* /*
* Serial interfaces * Serial interfaces
*/ */
#define PIN_SERIAL1_RX (1) #define PIN_SERIAL1_RX (0)
#define PIN_SERIAL1_TX (0) #define PIN_SERIAL1_TX (1)
/* /*
* SPI Interfaces * SPI Interfaces