This adds an implementation of the LMIC HAL, plus some files needed for
the Arduino library format and some examples.

In addition, an export.sh script is added that can be used to generate
an Arduino library from this repository. This script only reorders
files, it does not change anything. When given the --link option, it
creates symlinks instead of copies, allowing to test things in the
Arduino IDE easily, while committing the original files in this
repository.

The HAL, examples and library.properties files are taken from the
https://github.com/matthijskooijman/arduino-lmic repository, revision
90bc049 (Print downlink ack status in ttn-otaa example too). Only the
configuration mechanism was changed slightly.

Previously, this used GNU-specific cp options, which are not available
on OSX.

This stops using the osjob scheduling from lmic for scheduling
transmissions, since this is a bit tricky to integrate with existing
code, and users now often think that using it is mandatory. By removing
it, and replacing it by simple time-based checks for scheduling
transmissions, it should be more clear how this works.

Also, remove some code specific to the Pinoccio board.

Examples are untouched, those will be updated separately.

This declares the onLmicEvent() callback function that must be defined by an
application. Previously, the application was expected to define this
itself, and a reference to it was declared in lmic.c.

By moving the declaration into lmic.h, this prevents problems when an
application uses a different function signature for the function, or
when defining the callback in a C++ file (since lmic.h uses extern "C",
the compiler now knows to generate a C-style function rather than C++).

The AES_S array contains 16-bit integers, which are shifted upwards
during processing. On platforms where int is 32-bit or wider, these
integers are integer-promoted to 32-bit before shifting, making them
work as expected. On smaller platforms, this does not happen, causing
the upper 16 bits to be shifted off before the value is converted to a
32-bit integer.

By manually casting these values to 32-bit before shifting, this issue
is prevented.

These functions convert four individiual bytes from a buffer into a
32-bit integer. The upper two bytes were cast to u4_t before being
shifted in place, but not the lower bytes. It seems that this was not
needed, since even when int is 16-bits, shifting a byte by 8 will not
cause any bits to "fall off". However, a problem with sign-extension
would occur in some cases.

The problematic expression is:

	return (u4_t)(buf[0] | (buf[1]<<8) | ((u4_t)buf[2]<<16) | ((u4_t)buf[3]<<24));

Here, `buf[1]` would be integer-promoted before shifting.  It is
promoted to a *signed* `int`, since the original `u1_t` type is small
enough to fit in there. Now, if the MSB of `buf[1]` is 1, it is then
shifted to become the MSB (i.e. sign bit) of the resulting *signed*
integer. Then, before the bitwise-or operator is applied, this value is
extended to 32-bits, since the right operand is 32-bit. Since the
left-hand side is signed, it is sign-extended, causing all upper 16 bits
to become 1, making them also 1 in the resulting value.

To fix this, all bytes are first explicitely cast to `u4_t` to make sure
they are already big enough and remain unsigned. For consistency, the
same is done for `os_rlsbf2()`, even though this same problem cannot
occur there (C guarantees that an int is at least 16-bits wide).

The original LMIC AES implementation is optimized for fast execution on
32bit processors, but it ends up taking a lot of flash space on 8-bit
AVR processors. This commit adds an alternative AES implementation
written by Ideetron, which is a lot smaller, but also about twice as
slow as the original implementation. This new implementation is selected
by default, but the original can be used by modifying config.h.

Disabling this shrinks the code by a fair bit, so this is interesting
for low-memory applications that do not need class B.

This can also disable processing of some MAC commands. They are
completely not recognized anymore, which should be ok since these
commands should never be received at all. If they are received, this
will break processing of subsequent commands, though.

This allows the .h files to be included from C++ code directly, without
having to worry about calling conventions and name mangling.

The `LORA_RXSTART_FIXUP` macro was not defined for this board, breaking
compilation. This just defines it to 0, which is probably incorrect, but
related values are also 0 and to be determined, so this at least fixes
compilation.

In practice, u4_t and s4_t arguments are always passed to %F (freq
mostly). On systems where int is s4_t, this works fine (the signed vs
unsigned mismatch works out as long as values are smaller than 2^31).
However, on systems where int is s2_t, this causes the printf arguments
to run out of sync, producing garbage output and potentially infinite
loops.

In two cases, %F was used for a s1_t, which must now be ucast to s4_t
(it would already be implicitly converted to int, so again this was not needed
on systems that have int equal to s4_t).

This allows printing long values. On ARM, these are identical to int,
but on AVR they are different, so this allows printing 32-bit values
there.

This is not actually used anywhere yet (the only 32-bit values used are
timestamps, which are printed using %t), but this prepares for printing
raw timestamps in a subsequent commit.

This supports a CFG_DEBUG_RAW_TIMESTAMPS define, which changes
timestamps from the hh:mm:ss.mmm format to a raw tick value (which might
be harder to read, but has more precisions).

The default is still the millisecond format.

This uses %t for printing ostime_t values. The field width in the format
string is not normally used, but added for when the "raw" ticks
timestamp format is applied (with CFG_DEBUG_RAW_TIMESTAMP).

On e.g. ARM, %d and %ld are equivalent, but on smaller architectures
like AVR, they are not, so this makes these prints work there.

This is triggered by a CFG_DEBUG_VERBOSE define and gives more spammy
debug output.

This also adds some sleeping-related debug output, but this is disabled
for now since the Arduino port does not do sleeping yet.

The osxtime_t values (which are 64-bit) are printed as ostime_t (which
are 32-bit). Printing them as 64-bit would make it harder to compare
them with ostime_t values. Things might get weird or incorrect after an
overflow, though.

This allows the HAL to indicate reset is not connected, which causes the
reset to be skipped entirely. This will often work as expected, but
(especially when the MCU is reset while the transceiver is working)
might cause problems, of course.

This allows seeing startup messages and errors on native USB boards.

This was already used for the abp example, now they are consistent
again.

This should probably be made configurable, but for now just always
enable it (since typically DIO3 is not used as anything else anyway).

The voltage and timeout values were taken from other example code and
should probably also be configurable. Also, the timout adds TX/RX delay,
so should probably be accounted for.

This actually breaks the build in recent gcc versions.

The SX126x chips can map all interrupts to DIO1, so no need to connect
anything else.

This prevents USB operation on native USB boards, which complicates
subsequent uploads.

We should really use them incrementally and save them, but for now the
LoRaWAN 1.0 behaviour of random nonces should work.

On some Arduino cores, printing with IRQs disabled is problematic (see
e.g. arduino/ArduinoCore-samd#472). In
general, disabling interrupts for shorter amounts of time is a good idea
anyway.

Serial printing with IRQs disabled is problematic on some Arduino cores,
see e.g.  arduino/ArduinoCore-samd#472

BasicMAC (unlike LMIC) has its own debug_printf functions, so this is
probably less necessary, but add it just in case.

Previously, these timeouts were started before starting RX or TX. This
worked normally, but when a HAL did not have access to the BUSY pin and
instead resorted to conservative delays between SPI transactions,
starting RX or TX would take so long that the timeout would effectively
end up too short.

Note that there is no HAL committed yet that supports working without a
BUSY pin, but this came up in some as of yet uncommitted work on the
Arduino port. Even if running without a BUSY pin will never be
supported, setting the timeout like this should be fine, since in the
worst case it only effectively extends the timeout by a few ms. Since
the timeout should normally occur, this is fine.

Some radio modules have separate pins for this, which allows switching
the antenna switch off entirely to save power. On boards with just a
single RXTX pin, this pin can be set as TX pin, to fall back to RX mode
when idle.

This commit intentionally breaks compatibility with the pinmap, to
force sketches to update their pinmap (also for the busy pin, since
omitting a field at the end of a struct initializes it to 0, which could
be a valid pin number).

This prevents printing with interrupts disabled, which is problematic on some
Arduino cores, see e.g.  arduino/ArduinoCore-samd#472

These are boards that include a LoRa module, so have a well-known
pinout.

These are added to a separate file, which is copied into each example
directory on export, which makes it easier to change these pinmaps in a
single place.

This commit also adds some comments about how to add your own pinmap.

This just inserted an empty string, which does not really make sense.

Previously, the NSS pin would only be set to OUTPUT mode, causing it to
become OUTPUT LOW and starting an SPI transaction already. In some cases
(possibly when the chip was subsequently reset), the first SPI
transaction would then fail (readReg would return 0), causing
an assertion failure during initialization.

This is fixed by writing the NSS pin HIGH in addition to changing to
OUTPUT mode. To prevent a low pulse on the line, it is written HIGH
before setting OUTPUT, but it seems not all cores support this (e.g. the
arduino-STM32L4 reset to LOW when changing to OUTPUT), so write HIGH
again after setting OUTPUT to be sure.

This example was not updated to BasicMAC yet, and already for LMIC it
was not really using the library properly. Since it is likely only
confusing for people, better remove it.

This prevents a compiler warning. If these are used later, the attribute
can stay without problems (it just says "It is ok if these are unused").

In C, it is not allowed to reference variables using pointers to an
unrelated type, except when the pointer is uint8_t. So dereferencing a
uint8_t[] through uint32_t* is not allowed (and gives a warning about
type-punning), but dereferencing uint32_t through a uint8_t* is allowed.

This rewrites GetRandom slightly to fix this warning.

This just removes the parameter names to indicate they are unused.

In C, we cannot omit parameter names (like in C++), so use a void-cast
to reference the parameters without really using them. This is typically
done with a macro, but doing it explicitly like this prevents further
polluting the macro namespace with potential conflicting names.

…ESP32

This merges the final release done by Semtech.

This prevents conflicting with existing Arduino macros, or user-defined
functions with the same name.

In version 2.2, Semtech changed the 127x driver to rename txsw to
radio_cw, but this change was not made in the 126x driver, making
compilation fail when using it.

This renames the function for 126x to at least fix compilation.

However, for 126x the continuous mode was split into a TXCW and TXCONT
mode, where the former uses the existing radio_cw (formerly txcw)
function, but the latter txfsk() or txlora() with some changes for
continuous mode. This is not implemented for 126x, so TXCONT is probably
broken for 126x now.

Previously, most files used mixed tabs and spaces (e.g. 4 spaces indent,
each 8 spaces replaced by a tab) which heavily relies on tabs being
rendered as 8 spaces (so it does not allow changing the tab size to your
personal preference). To prevent issues and conflicts resulting from
inconsistent indentation, just switch everything to use spaces
exclusively.

A big indentation change like this is prone to causing conflicts with
existing pullrequests and git clones, but since this repo is still
fairly new, now seems like the best time to do this cleanup.

This was done using the following command:

    for f in $(find -name \*.[ch]); do vim -c "set et|retab|wq" $f; done

And then commiting everything except basicloader (which is a submodule)
and stm32/CMSIS (which is third-party code imported verbatim).

This still had some values from LMIC in there. Also update the project
URL now Semtech officially stopped developing this.

This helps distinguish this version from the 2.2 version released by
Semtech. Assigning a version number is not any particular indication of
stability, though.

This leaves the default at sx1276, but adds a commented line for 126x in
target-config.h.

This is the first header from this library that an Arduino sketch should
include, allowing the IDE to detect the sketch needs this library.
Renaming this from the lmic.h that LMIC uses, allows LMIC and BasicMAC
to co-exist in your libraries folder, with sketches selecting the right
library based on this include.

Note that other header files still use 'lmic' in their name (and
contents). Renaming all these would be too invasive, but also not needed
(once the top-level include selected one library, all other includes
will be resolved using that library if possible).

This is a breaking change, which breaks any existing sketches. Fixing
such sketches is a matter of replacing `#include <lmic.h>` with
`#include <basicmac.h>`.

These examples were not really TTN-specific, but could just as easily be
used for other networks (maybe needing some settings changes), so
reflect that in the name. This adds "basicmac" to the name, to make it
easier to distinguish them from the lmic examples too, when working with
both libraries.

This defined a channel for FSK, but specified the DR using the `FSK`
constant, which is for specifying SF, not DR.

This extends the list of DR constants (which are not currently defined
in BasicMAC itself) in the example to include all EU868-defined
datarates.

These contain detailed, but concise info about TX and RX and are
generally useful without cluttering too much, so better enable them by
default.

This is not strictly needed, but starting the join explicitly and
waiting for it to complete before scheduling the first packet typically
makes things a little more predictable (and would prevent sending old
data when the join takes long in a real sensor application).

This was accidentally spread over three lines, now it is again just one
line.

This makes it a bit easier to find restarts in the serial log.

These replace explicit checks against SF, making the code easier to
read and prepares for adding additional modulations later.

This makes it easier to change these constants if needed.

This fixes a compiler warning but should not otherwise change anything.

There is no need to repeat all modulation parameters on successful RX or
RX timeout, since those have already been printed when RX started with
the RXMODE message.

This would print a timestamp in the past, rather than the actual time of
the next join attempt.

Rather than indexing a string, just calculate the bandwidth value. This
will produce "1000" instead of "rfu" for bw=3, but that should not be
used anyway. This calculation was already used for TX, now also for RX.

Previously, sf=6 would indicate FSK and all modulation parameters were
shown for FSK, even when most were unused. This makes makes the
modulation used more explicit, and shows only relevant parameters in the
debug output.

This can be used to continue a previously started line, since this
version does not include a timestamp.

The `LMIC.seqnoUp` is the frame counter to be used for the *next* uplink
packet. Therefore, one is subtracted before printing, to get the counter
of the current framecounter.

However, when no data uplinks have been sent yet (e.g. when sending a
join request), `LMIC.seqnoUp` would be 0 and the subtraction would
underflow. Earlier, this would print -1, but now that the counter is
properly printed as unsigned, this would print some large value.

With this commit, simply print 0 when no frames have been sent yet.

This can be used to independently toggle debug output about job
scheduling. This is debug output is not usually useful, so it is
disabled by default, making the verbose debug output a lot easier to
read.

Previously, this was only exposed when CFG_extapi was set. However,
disabling DC limitations can sometimes be useful for testing. Use with
caution!

This event was never fired, so better just remove it.

This was not actually used before its definition, so this declaration is
pointless. Also, when DISABLE_CLASS_B was defined, it would never be
defined, resulting in:

     warning: 'startScan' declared 'static' but never defined [-Wunused-function]

This array stores offsets between up and own datarates. Some of these
values are negative, but were now stored as unsigned numbers. In
practice, this worked out ok because unsigned and signed addition are
the same, and the result of such addition (in prepareDnDr) was cast to
s1_t (so any upper bits incorrect due to lack of sign extension were
discarded anyway).

However, in a few cases, comparisons with ILLEGAL_RX1DRoff (which is
defined as -128) would *not* work. The compiler also warned about this:

    warning: comparison is always false due to limited range of data type [-Wtype-limits]
	 if( REGION.rx1DrOff[LMIC.dn1DrOffIdx] == ILLEGAL_RX1DRoff )
                                           ^~

And then the optimizer would remove the if, assuming it is always false.

In practice, this only meant that any invalid offsets in a join accept packet
or MCMD_DN2P_SET MAC command would not be rejected.

If this function would be passed rps that matches none of the defined
DR's, this loop would loop infinitely. This happened because dr_t is
signed, so `dr--` would loop from 0 to 255 rather than to -1, and `dr >=
0` would never be false.

The compiler warned about this:

    warning: comparison is always true due to limited range of data type [-Wtype-limits]
	 for( dr_t dr = 15; dr >= 0; dr-- ) {
			       ^~

In practice, this never happened because there would always be a
matching dr to break the loop, but fix this anyway.

This fixes some signed vs unsigned mismatches, and some functions and
variables that were only used inside preprocessor guards.

This used to be u1_t, but cr_t is more appropriate, also saving a cast.
Since cr_t is just a typdef for u1_t, this should not change the
resulting output.

This uses the C11/C++11 static_assert feature, to be able to check
certain conditions at compiletime. Unlike `#if`, this can make
assertions involving C-level constants, instead of just preprocessor
macros.

This assert would result in:

    warning: comparison is always true due to limited range of data type [-Wtype-limits]
         ASSERT(sf >= SF7 && sf <=SF12 && bw >= BW125 && bw <= BW500);

Because it checked `bw >= BW125`, but `BW125` is 0. This means this part
of the check can be removed, but replace it with a static assertion that
`BW125` is indeed 0, just in case this code is every changed.

It was unused.

This renames the LWUPDR/LWDNDR macros to LORA_UP_RPS and LORA_DN_RPS to
make it more clear that these parameters are LoRa-specific and build an
RPS rather than an DR-number. MAKERPS is also renamed to MAKE_LORA_RPS
and makeRps to makeLoraRps.

For FSK, FSK_UP_RPS, MAKE_FSK_RPS and makeFskRps are introduced which
accept only the parameters needed for FSK.

The `decDR` function would decrement a DR by one, while `lowerDR` would
decrement it by a given amount. To make the code a bit more uniform and
simple, just use ` lowerDR` for both, passing an explicit `1` for
decrementing by one.

This is currently equivalent, but this prepares for adding a custom DR
exception in updr2rps next.

Previously, LMIC.dndr was set to the TX datarate on TX, and then the
corresponding RX1 datarate was derived in txDone. Since nothing happens
in between that could influence the RX1 datarate, it is easier to just
derive the RX1 datarate on TX already.

This removes the confusion where `LMIC.dndr` would actually contain the
TX datarate. It also prepares for introducing a custom datarate.

This makes sure that the `txDone()` function is ran before `EV_TXDONE`,
which makes this consistent with join request packets, and allows to
customize the radio settings for the RX windows without `txDone()`
overwriting them again.

This adds the LMIC_setCustomDr() function which can be used to enable a
custom datarate with arbitrary settings (e.g different CR, bandwidth,
etc.), which is used until explicitly changed back to a standard
datarate.

See comments in lmic.h for detailed usage info.

nextTx is called to select any channel that is available now. It then
returns the timestamp when a channel is first available. If that
timestamp is <= now, the channel is selected, if the timestamp > now,
the nextTx should be called again after the returned timestamp.

However, to decide whether a channel is available, nextTx looked at
`now`, but to decide whether TX should then start, engineUpdate looked
at `now + TX_RAMPUP`. This meant that if `nextTx` was called within
`TX_RAMPUP` of airtime becoming available, `nextTx` could decide that no
airtime was available yet, *not* selecting a channel. Then engineUpdate
decides that airtime *is* available and continues with the transmission,
with the same channel as the previous transmission.

This fixes this by passing the actual threshold (`now + TX_RAMPUP`) to
`nextTx`, so both decisions end up the same.

Additionally, `nextTx_dyn` would actually call `os_getXTime()` rather
than use the `now` argument passed. It now expands the given timestamp
to an `osxtime_t` instead, so the added `TX_RAMPUP` is actually used.

In commit f74ec70 (Fix undefined casting in GetRandom), an addressof
operator for `value` was forgotten, so instead of casting the pointer to
`value`, this would cast `value` itself to a pointer. Combined with a
lack of initialization on `value`, this would end up writing the random
value to a random place in memory, and not actually returning it.

While we're here, also use sizeof instead of hardcoding the number of
bytes to read.

Note that none of this actually seems to make GetRandom work, the
hardware still returns only zeroes from the random register somehow...

This referred to the DISABLE_PING that LMIC had, but this was merged
with DISABLE_CLASSB in Basicmac.

This code would be duplicated four times for different tx and rx mode,
so better make it a function (this also prepares for more conditional
and complicated setup later).

Lw 1.0.2 and Lw 1.1 define DR6 for AU915 to be SF8BW500.

In commit e328468 (Remove some assumptions on constant values), a typo
was introduced in this constant. This was only problematic for the
SX1276, which was probably not tested after that commit.

This fixes #13.