diff --git a/arch/apollo3/apollo3.ini b/arch/apollo3/apollo3.ini index 75eaf89e5..05a56eb4f 100644 --- a/arch/apollo3/apollo3.ini +++ b/arch/apollo3/apollo3.ini @@ -1,5 +1,5 @@ [apollo3_base] -platform = https://github.com/nigelb/platform-apollo3blue.git#cdbb76ec805033a4543f2d3c136d926d06bfc361 +platform = https://github.com/nigelb/platform-apollo3blue.git#e24b0b1970aab9e7b20d759e5e86ce6b2647d1e1 platform_packages=framework-arduinoapollo3@https://github.com/sparkfun/Arduino_Apollo3#v2.2.1 framework = arduino build_type = debug @@ -10,5 +10,6 @@ build_src_filter = ${arduino_base.build_src_filter} - - - - - - - - - - - - - - - lib_deps = ${env.lib_deps} + jgromes/RadioLib@^6.1.0 lib_ignore = mathertel/OneButton@^2.0.3 diff --git a/boards/wiscore_rak11720.json b/boards/wiscore_rak11720.json index 74c39f45f..ae521882d 100644 --- a/boards/wiscore_rak11720.json +++ b/boards/wiscore_rak11720.json @@ -13,7 +13,7 @@ "extra_flags": "-DSFE_ARTEMIS" }, "v2": { - "variant": "WisCore_RAK11720_Board", + "variant": "rak11720", "extra_flags": "-DARDUINO_RAK_11720_MODULE" } }, diff --git a/src/AccelerometerThread.h b/src/AccelerometerThread.h index 875ca2e22..2a7ba3b64 100644 --- a/src/AccelerometerThread.h +++ b/src/AccelerometerThread.h @@ -4,6 +4,8 @@ #include "main.h" #include "power.h" +#if defined(HAS_TELEMETRY) && (HAS_TELEMETRY == 1) + #include #include @@ -90,3 +92,5 @@ class AccelerometerThread : public concurrency::OSThread }; } // namespace concurrency + +#endif \ No newline at end of file diff --git a/src/FSCommon.cpp b/src/FSCommon.cpp index 150391237..cc093dfe6 100644 --- a/src/FSCommon.cpp +++ b/src/FSCommon.cpp @@ -37,8 +37,8 @@ bool copyFile(const char *from, const char *to) f2.flush(); f2.close(); f1.close(); - return true; #endif + return true; } bool renameFile(const char *pathFrom, const char *pathTo) @@ -55,6 +55,7 @@ bool renameFile(const char *pathFrom, const char *pathTo) } #endif #endif + return true; } void listDir(const char *dirname, uint8_t levels, bool del = false) diff --git a/src/FSCommon.h b/src/FSCommon.h index ef1d3e4c1..4564eae3c 100644 --- a/src/FSCommon.h +++ b/src/FSCommon.h @@ -20,6 +20,13 @@ using namespace LittleFS_Namespace; #endif +#if defined(ARCH_APOLLO3) +#include "platform/apollo3/InternalFileSystem.h" // Apollo3 +#define FSCom InternalFS +#define FSBegin() FSCom.begin() +using namespace LittleFS_Namespace; +#endif + #if defined(ARCH_RP2040) // RP2040 #include "LittleFS.h" diff --git a/src/Power.cpp b/src/Power.cpp index 37d80a31f..9dd3f7aee 100644 --- a/src/Power.cpp +++ b/src/Power.cpp @@ -134,7 +134,7 @@ class AnalogBatteryLevel : public HasBatteryLevel virtual uint16_t getBattVoltage() override { -#if defined(HAS_TELEMETRY) && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU) +#if defined(HAS_TELEMETRY) && (HAS_TELEMETRY == 1) && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU) if (hasINA()) { LOG_DEBUG("Using INA on I2C addr 0x%x for device battery voltage\n", config.power.device_battery_ina_address); return getINAVoltage(); @@ -260,7 +260,7 @@ class AnalogBatteryLevel : public HasBatteryLevel float last_read_value = 0.0; uint32_t last_read_time_ms = 0; -#if defined(HAS_TELEMETRY) && !defined(ARCH_PORTDUINO) +#if defined(HAS_TELEMETRY) && (HAS_TELEMETRY == 1) && !defined(ARCH_PORTDUINO) uint16_t getINAVoltage() { if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219] == config.power.device_battery_ina_address) { diff --git a/src/RedirectablePrint.cpp b/src/RedirectablePrint.cpp index 0e8e1c798..0ee3be1a5 100644 --- a/src/RedirectablePrint.cpp +++ b/src/RedirectablePrint.cpp @@ -1,6 +1,6 @@ #include "RedirectablePrint.h" #include "NodeDB.h" -#include "RTC.h" +#include "gps/RTC.h" #include "concurrency/OSThread.h" #include "configuration.h" #include diff --git a/src/detect/ScanI2CTwoWire.cpp b/src/detect/ScanI2CTwoWire.cpp index 7afb03ee2..107d1694f 100644 --- a/src/detect/ScanI2CTwoWire.cpp +++ b/src/detect/ScanI2CTwoWire.cpp @@ -73,7 +73,7 @@ ScanI2C::DeviceType ScanI2CTwoWire::probeOLED(ScanI2C::DeviceAddress addr) const } void ScanI2CTwoWire::printATECCInfo() const { -#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) +#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(ARCH_APOLLO3) atecc.readConfigZone(false); LOG_DEBUG("ATECC608B Serial Number: "); @@ -172,7 +172,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port) type = probeOLED(addr); break; -#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) +#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(ARCH_APOLLO3) case ATECC608B_ADDR: type = ATECC608B; if (atecc.begin(addr.address) == true) { diff --git a/src/freertosinc.h b/src/freertosinc.h index 166054241..988dc4379 100644 --- a/src/freertosinc.h +++ b/src/freertosinc.h @@ -12,7 +12,7 @@ #include #endif -#if defined(ARDUINO_NRF52_ADAFRUIT) || defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_RP2040) +#if defined(ARDUINO_NRF52_ADAFRUIT) || defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_APOLLO3) #define HAS_FREE_RTOS #include diff --git a/src/main.cpp b/src/main.cpp index c867930d0..d4ceef893 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -11,7 +11,7 @@ #include "power.h" // #include "debug.h" #include "FSCommon.h" -#include "RTC.h" +#include "gps/RTC.h" #include "SPILock.h" #include "concurrency/OSThread.h" #include "concurrency/Periodic.h" @@ -107,7 +107,7 @@ ScanI2C::DeviceAddress accelerometer_found = ScanI2C::ADDRESS_NONE; // The I2C address of the RGB LED (if found) ScanI2C::FoundDevice rgb_found = ScanI2C::FoundDevice(ScanI2C::DeviceType::NONE, ScanI2C::ADDRESS_NONE); -#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) +#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(ARCH_APOLLO3) ATECCX08A atecc; #endif @@ -459,7 +459,7 @@ void setup() screen_model = meshtastic_Config_DisplayConfig_OledType_OLED_SH1107; // keep dimension of 128x64 #endif -#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) +#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(ARCH_APOLLO3) if (acc_info.type != ScanI2C::DeviceType::NONE) { accelerometerThread = new AccelerometerThread(acc_info.type); } @@ -481,6 +481,9 @@ void setup() SPI.setRX(RF95_MISO); SPI.begin(false); #endif // HW_SPI1_DEVICE +#elif defined(ARCH_APOLLO3) + // Apollo3 + SPI.begin(); #elif !defined(ARCH_ESP32) // ARCH_RP2040 SPI.begin(); #else diff --git a/src/main.h b/src/main.h index 93baec590..d1c06d42a 100644 --- a/src/main.h +++ b/src/main.h @@ -10,7 +10,7 @@ #include "mesh/generated/meshtastic/telemetry.pb.h" #include #include -#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) +#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(ARCH_APOLLO3) #include #endif #if defined(ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2) @@ -34,7 +34,7 @@ extern bool pmu_found; extern bool isCharging; extern bool isUSBPowered; -#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) +#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(ARCH_APOLLO3) extern ATECCX08A atecc; #endif diff --git a/src/mesh/MeshService.cpp b/src/mesh/MeshService.cpp index 2ad46a6b7..142e718e8 100644 --- a/src/mesh/MeshService.cpp +++ b/src/mesh/MeshService.cpp @@ -8,7 +8,7 @@ #include "MeshService.h" #include "NodeDB.h" #include "PowerFSM.h" -#include "RTC.h" +#include "gps/RTC.h" #include "TypeConversions.h" #include "main.h" #include "mesh-pb-constants.h" diff --git a/src/mesh/NodeDB.cpp b/src/mesh/NodeDB.cpp index 565a08ff9..35f11c93f 100644 --- a/src/mesh/NodeDB.cpp +++ b/src/mesh/NodeDB.cpp @@ -9,7 +9,7 @@ #include "NodeDB.h" #include "PacketHistory.h" #include "PowerFSM.h" -#include "RTC.h" +#include "gps/RTC.h" #include "Router.h" #include "TypeConversions.h" #include "error.h" diff --git a/src/platform/apollo3/InternalFileSystem.cpp b/src/platform/apollo3/InternalFileSystem.cpp new file mode 100644 index 000000000..950ceb0cd --- /dev/null +++ b/src/platform/apollo3/InternalFileSystem.cpp @@ -0,0 +1,141 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 hathach for Adafruit Industries + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "InternalFileSystem.h" +#include + +//--------------------------------------------------------------------+ +// LFS Disk IO +//--------------------------------------------------------------------+ + +static inline uint32_t lba2addr(uint32_t block) +{ + return ((uint32_t)LFS_FLASH_ADDR) + block * LFS_BLOCK_SIZE; +} + +static int _internal_flash_read(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size) +{ + (void)c; + + uint32_t addr = lba2addr(block) + off; + uint8_t prom; + + for (int i = 0; i < size; i++) { + prom = EEPROM.read(addr + i); + memcpy((char *)buffer + i, &prom, 1); + } + return 0; +} + +// Program a region in a block. The block must have previously +// been erased. Negative error codes are propogated to the user. +// May return LFS_ERR_CORRUPT if the block should be considered bad. +static int _internal_flash_prog(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size) +{ + (void)c; + + uint32_t addr = lba2addr(block) + off; + uint8_t prom; + + for (int i = 0; i < size; i++) { + memcpy(&prom, (char *)buffer + i, 1); + EEPROM.update(addr + i, prom); + } + return 0; +} + +// Erase a block. A block must be erased before being programmed. +// The state of an erased block is undefined. Negative error codes +// are propogated to the user. +// May return LFS_ERR_CORRUPT if the block should be considered bad. +static int _internal_flash_erase(const struct lfs_config *c, lfs_block_t block) +{ + (void)c; + + uint32_t addr = lba2addr(block); + + // implement as write 0xff to whole block address + for (int i = 0; i < LFS_BLOCK_SIZE; i++) { + EEPROM.update(addr, 0xff); + } + + return 0; +} + +// Sync the state of the underlying block device. Negative error codes +// are propogated to the user. +static int _internal_flash_sync(const struct lfs_config *c) +{ + // we don't use a ram cache, this is a noop + return 0; +} + +static struct lfs_config _InternalFSConfig = {.context = NULL, + + .read = _internal_flash_read, + .prog = _internal_flash_prog, + .erase = _internal_flash_erase, + .sync = _internal_flash_sync, + + .read_size = LFS_CACHE_SIZE, + .prog_size = LFS_CACHE_SIZE, + .block_size = LFS_BLOCK_SIZE, + .block_count = LFS_FLASH_TOTAL_SIZE / LFS_BLOCK_SIZE, + .block_cycles = + 500, // protection against wear leveling (suggested values between 100-1000) + .cache_size = LFS_CACHE_SIZE, + .lookahead_size = LFS_CACHE_SIZE, + + .read_buffer = lfs_read_buffer, + .prog_buffer = lfs_prog_buffer, + .lookahead_buffer = lfs_lookahead_buffer}; + +InternalFileSystem InternalFS; + +//--------------------------------------------------------------------+ +// +//--------------------------------------------------------------------+ + +InternalFileSystem::InternalFileSystem(void) : LittleFS(&_InternalFSConfig) {} + +bool InternalFileSystem::begin(void) +{ + // failed to mount, erase all sector then format and mount again + if (!LittleFS::begin()) { + // Erase all sectors of internal flash region for Filesystem. + // implement as write 0xff to whole block address + for (uint32_t addr = LFS_FLASH_ADDR; addr < (LFS_FLASH_ADDR + LFS_FLASH_TOTAL_SIZE); addr++) { + EEPROM.update(addr, 0xff); + } + + // lfs format + this->format(); + + // mount again if still failed, give up + if (!LittleFS::begin()) + return false; + } + + return true; +} diff --git a/src/platform/apollo3/InternalFileSystem.h b/src/platform/apollo3/InternalFileSystem.h new file mode 100644 index 000000000..66344194e --- /dev/null +++ b/src/platform/apollo3/InternalFileSystem.h @@ -0,0 +1,54 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 hathach for Adafruit Industries + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef INTERNALFILESYSTEM_H_ +#define INTERNALFILESYSTEM_H_ + +#include "LittleFS.h" + +// The EEPROM Library assumes our usable flash area starts at logical 0 +#define LFS_FLASH_ADDR 0 + +// use the built in EEPROM emulation. Total Size is 2Kbyte +#define LFS_BLOCK_SIZE 128 // min. block size is 128 to fit CTZ pointers +#define LFS_CACHE_SIZE 16 + +#define LFS_FLASH_TOTAL_SIZE FLASH_PAGE_SIZE + +static uint8_t lfs_read_buffer[LFS_CACHE_SIZE] = {0}; +static uint8_t lfs_prog_buffer[LFS_CACHE_SIZE] = {0}; +static uint8_t lfs_lookahead_buffer[LFS_CACHE_SIZE] = {0}; + +class InternalFileSystem : public LittleFS +{ + public: + InternalFileSystem(void); + + // overwrite to also perform low level format (sector erase of whole flash region) + bool begin(void); +}; + +extern InternalFileSystem InternalFS; + +#endif /* INTERNALFILESYSTEM_H_ */ diff --git a/src/platform/apollo3/LittleFS.cpp b/src/platform/apollo3/LittleFS.cpp new file mode 100644 index 000000000..b1267d88a --- /dev/null +++ b/src/platform/apollo3/LittleFS.cpp @@ -0,0 +1,258 @@ +#include +#include + +#include "LittleFS.h" + +using namespace LittleFS_Namespace; + +//--------------------------------------------------------------------+ +// Implementation +//--------------------------------------------------------------------+ + +LittleFS::LittleFS(void) : LittleFS(NULL) {} + +LittleFS::LittleFS(struct lfs_config *cfg) +{ + memset(&_lfs, 0, sizeof(_lfs)); + _lfs_cfg = cfg; + _mounted = false; + _mutex = xSemaphoreCreateMutexStatic(&this->_MutexStorageSpace); +} + +LittleFS::~LittleFS() {} + +// Initialize and mount the file system +// Return true if mounted successfully else probably corrupted. +// User should format the disk and try again +bool LittleFS::begin(struct lfs_config *cfg) +{ + _lockFS(); + + bool ret; + // not a loop, just an quick way to short-circuit on error + do { + if (_mounted) { + ret = true; + break; + } + if (cfg) { + _lfs_cfg = cfg; + } + if (nullptr == _lfs_cfg) { + ret = false; + break; + } + // actually attempt to mount, and log error if one occurs + int err = lfs_mount(&_lfs, _lfs_cfg); + PRINT_LFS_ERR(err); + _mounted = (err == LFS_ERR_OK); + ret = _mounted; + } while (0); + + _unlockFS(); + return ret; +} + +// Tear down and unmount file system +void LittleFS::end(void) +{ + _lockFS(); + + if (_mounted) { + _mounted = false; + int err = lfs_unmount(&_lfs); + PRINT_LFS_ERR(err); + (void)err; + } + + _unlockFS(); +} + +bool LittleFS::format(void) +{ + _lockFS(); + + int err = LFS_ERR_OK; + bool attemptMount = _mounted; + // not a loop, just an quick way to short-circuit on error + do { + // if already mounted: umount first -> format -> remount + if (_mounted) { + _mounted = false; + err = lfs_unmount(&_lfs); + if (LFS_ERR_OK != err) { + PRINT_LFS_ERR(err); + break; + } + } + err = lfs_format(&_lfs, _lfs_cfg); + if (LFS_ERR_OK != err) { + PRINT_LFS_ERR(err); + break; + } + + if (attemptMount) { + err = lfs_mount(&_lfs, _lfs_cfg); + if (LFS_ERR_OK != err) { + PRINT_LFS_ERR(err); + break; + } + _mounted = true; + } + // success! + } while (0); + + _unlockFS(); + return LFS_ERR_OK == err; +} + +// Open a file or folder +LittleFS_Namespace::File LittleFS::open(char const *filepath, uint8_t mode) +{ + // No lock is required here ... the File() object will synchronize with the mutex provided + return LittleFS_Namespace::File(filepath, mode, *this); +} + +// Check if file or folder exists +bool LittleFS::exists(char const *filepath) +{ + struct lfs_info info; + _lockFS(); + + bool ret = (0 == lfs_stat(&_lfs, filepath, &info)); + + _unlockFS(); + return ret; +} + +// Create a directory, create intermediate parent if needed +bool LittleFS::mkdir(char const *filepath) +{ + bool ret = true; + const char *slash = filepath; + if (slash[0] == '/') + slash++; // skip root '/' + + _lockFS(); + + // make intermediate parent directory(ies) + while (NULL != (slash = strchr(slash, '/'))) { + char parent[slash - filepath + 1] = {0}; + memcpy(parent, filepath, slash - filepath); + + int rc = lfs_mkdir(&_lfs, parent); + if (rc != LFS_ERR_OK && rc != LFS_ERR_EXIST) { + PRINT_LFS_ERR(rc); + ret = false; + break; + } + slash++; + } + // make the final requested directory + if (ret) { + int rc = lfs_mkdir(&_lfs, filepath); + if (rc != LFS_ERR_OK && rc != LFS_ERR_EXIST) { + PRINT_LFS_ERR(rc); + ret = false; + } + } + + _unlockFS(); + return ret; +} + +// Remove a file +bool LittleFS::remove(char const *filepath) +{ + _lockFS(); + + int err = lfs_remove(&_lfs, filepath); + PRINT_LFS_ERR(err); + + _unlockFS(); + return LFS_ERR_OK == err; +} + +// Rename a file +bool LittleFS::rename(char const *oldfilepath, char const *newfilepath) +{ + _lockFS(); + + int err = lfs_rename(&_lfs, oldfilepath, newfilepath); + PRINT_LFS_ERR(err); + + _unlockFS(); + return LFS_ERR_OK == err; +} + +// Remove a folder +bool LittleFS::rmdir(char const *filepath) +{ + _lockFS(); + + int err = lfs_remove(&_lfs, filepath); + PRINT_LFS_ERR(err); + + _unlockFS(); + return LFS_ERR_OK == err; +} + +// Remove a folder recursively +bool LittleFS::rmdir_r(char const *filepath) +{ + /* adafruit: lfs is modified to remove non-empty folder, + According to below issue, comment these 2 line won't corrupt filesystem + at least when using LFS v1. If moving to LFS v2, see tracked issue + to see if issues (such as the orphans in threaded linked list) are resolved. + https://github.com/ARMmbed/littlefs/issues/43 + */ + _lockFS(); + + int err = lfs_remove(&_lfs, filepath); + PRINT_LFS_ERR(err); + + _unlockFS(); + return LFS_ERR_OK == err; +} + +//------------- Debug -------------// +#if CFG_DEBUG + +const char *dbg_strerr_lfs(int32_t err) +{ + switch (err) { + case LFS_ERR_OK: + return "LFS_ERR_OK"; + case LFS_ERR_IO: + return "LFS_ERR_IO"; + case LFS_ERR_CORRUPT: + return "LFS_ERR_CORRUPT"; + case LFS_ERR_NOENT: + return "LFS_ERR_NOENT"; + case LFS_ERR_EXIST: + return "LFS_ERR_EXIST"; + case LFS_ERR_NOTDIR: + return "LFS_ERR_NOTDIR"; + case LFS_ERR_ISDIR: + return "LFS_ERR_ISDIR"; + case LFS_ERR_NOTEMPTY: + return "LFS_ERR_NOTEMPTY"; + case LFS_ERR_BADF: + return "LFS_ERR_BADF"; + case LFS_ERR_INVAL: + return "LFS_ERR_INVAL"; + case LFS_ERR_NOSPC: + return "LFS_ERR_NOSPC"; + case LFS_ERR_NOMEM: + return "LFS_ERR_NOMEM"; + + default: + static char errcode[10]; + sprintf(errcode, "%ld", err); + return errcode; + } + + return NULL; +} + +#endif diff --git a/src/platform/apollo3/LittleFS.h b/src/platform/apollo3/LittleFS.h new file mode 100644 index 000000000..4a0b01af2 --- /dev/null +++ b/src/platform/apollo3/LittleFS.h @@ -0,0 +1,85 @@ + +#ifndef LITTLEFS_H_ +#define LITTLEFS_H_ + +#include + +#include "lfs.h" + +#include "LittleFS_File.h" + +#include "FreeRTOS.h" // tied to FreeRTOS for serialization +#include "semphr.h" + +class LittleFS +{ + public: + LittleFS(void); + explicit LittleFS(struct lfs_config *cfg); + virtual ~LittleFS(); + + bool begin(struct lfs_config *cfg = NULL); + void end(void); + + // Open the specified file/directory with the supplied mode (e.g. read or + // write, etc). Returns a File object for interacting with the file. + // Note that currently only one file can be open at a time. + LittleFS_Namespace::File open(char const *filename, uint8_t mode = LittleFS_Namespace::FILE_O_READ); + + // Methods to determine if the requested file path exists. + bool exists(char const *filepath); + + // Create the requested directory hierarchy--if intermediate directories + // do not exist they will be created. + bool mkdir(char const *filepath); + + // Delete the file. + bool remove(char const *filepath); + + // Rename the file. + bool rename(char const *oldfilepath, char const *newfilepath); + + // Delete a folder (must be empty) + bool rmdir(char const *filepath); + + // Delete a folder (recursively) + bool rmdir_r(char const *filepath); + + // format file system + bool format(void); + + /*------------------------------------------------------------------*/ + /* INTERNAL USAGE ONLY + * Although declare as public, it is meant to be invoked by internal + * code. User should not call these directly + *------------------------------------------------------------------*/ + lfs_t *_getFS(void) { return &_lfs; } + void _lockFS(void) { xSemaphoreTake(_mutex, portMAX_DELAY); } + void _unlockFS(void) { xSemaphoreGive(_mutex); } + + protected: + bool _mounted; + struct lfs_config *_lfs_cfg; + lfs_t _lfs; + SemaphoreHandle_t _mutex; + + private: + StaticSemaphore_t _MutexStorageSpace; +}; + +#if !CFG_DEBUG +#define VERIFY_LFS(...) _GET_3RD_ARG(__VA_ARGS__, VERIFY_ERR_2ARGS, VERIFY_ERR_1ARGS)(__VA_ARGS__, NULL) +#define PRINT_LFS_ERR(_err) +#else +#define VERIFY_LFS(...) _GET_3RD_ARG(__VA_ARGS__, VERIFY_ERR_2ARGS, VERIFY_ERR_1ARGS)(__VA_ARGS__, dbg_strerr_lfs) +#define PRINT_LFS_ERR(_err) \ + do { \ + if (_err) { \ + VERIFY_MESS((long int)_err, dbg_strerr_lfs); \ + } \ + } while (0) // LFS_ERR are of type int, VERIFY_MESS expects long_int + +const char *dbg_strerr_lfs(int32_t err); +#endif + +#endif /* LITTLEFS_H_ */ diff --git a/src/platform/apollo3/LittleFS_File.cpp b/src/platform/apollo3/LittleFS_File.cpp new file mode 100644 index 000000000..cffb924e1 --- /dev/null +++ b/src/platform/apollo3/LittleFS_File.cpp @@ -0,0 +1,362 @@ +#include + +#include "LittleFS.h" + +#include + +//--------------------------------------------------------------------+ +// MACRO TYPEDEF CONSTANT ENUM DECLARATION +//--------------------------------------------------------------------+ + +using namespace LittleFS_Namespace; + +File::File(LittleFS &fs) +{ + _fs = &fs; + _is_dir = false; + _name[0] = 0; + _dir_path = NULL; + + _dir = NULL; + _file = NULL; +} + +File::File(char const *filename, uint8_t mode, LittleFS &fs) : File(fs) +{ + // public constructor calls public API open(), which will obtain the mutex + this->open(filename, mode); +} + +bool File::_open_file(char const *filepath, uint8_t mode) +{ + int flags = (mode == FILE_O_READ) ? LFS_O_RDONLY : (mode == FILE_O_WRITE) ? (LFS_O_RDWR | LFS_O_CREAT) : 0; + + if (flags) { + _file = (lfs_file_t *)malloc(sizeof(lfs_file_t)); + if (!_file) + return false; + + int rc = lfs_file_open(_fs->_getFS(), _file, filepath, flags); + + if (rc) { + // failed to open + PRINT_LFS_ERR(rc); + return false; + } + + // move to end of file + if (mode == FILE_O_WRITE) + lfs_file_seek(_fs->_getFS(), _file, 0, LFS_SEEK_END); + + _is_dir = false; + } + + return true; +} + +bool File::_open_dir(char const *filepath) +{ + _dir = (lfs_dir_t *)malloc(sizeof(lfs_dir_t)); + if (!_dir) + return false; + + int rc = lfs_dir_open(_fs->_getFS(), _dir, filepath); + + if (rc) { + // failed to open + PRINT_LFS_ERR(rc); + return false; + } + + _is_dir = true; + + _dir_path = (char *)malloc(strlen(filepath) + 1); + strcpy(_dir_path, filepath); + + return true; +} + +bool File::open(char const *filepath, uint8_t mode) +{ + bool ret = false; + _fs->_lockFS(); + + ret = this->_open(filepath, mode); + + _fs->_unlockFS(); + return ret; +} + +bool File::_open(char const *filepath, uint8_t mode) +{ + bool ret = false; + + // close if currently opened + if (this->isOpen()) + _close(); + + struct lfs_info info; + int rc = lfs_stat(_fs->_getFS(), filepath, &info); + + if (LFS_ERR_OK == rc) { + // file existed, open file or directory accordingly + ret = (info.type == LFS_TYPE_REG) ? _open_file(filepath, mode) : _open_dir(filepath); + } else if (LFS_ERR_NOENT == rc) { + // file not existed, only proceed with FILE_O_WRITE mode + if (mode == FILE_O_WRITE) + ret = _open_file(filepath, mode); + } else { + PRINT_LFS_ERR(rc); + } + + // save bare file name + if (ret) { + char const *splash = strrchr(filepath, '/'); + strncpy(_name, splash ? (splash + 1) : filepath, LFS_NAME_MAX); + } + return ret; +} + +size_t File::write(uint8_t ch) +{ + return write(&ch, 1); +} + +size_t File::write(uint8_t const *buf, size_t size) +{ + lfs_ssize_t wrcount = 0; + _fs->_lockFS(); + + if (!this->_is_dir) { + wrcount = lfs_file_write(_fs->_getFS(), _file, buf, size); + if (wrcount < 0) { + wrcount = 0; + } + } + + _fs->_unlockFS(); + return wrcount; +} + +int File::read(void) +{ + // this thin wrapper relies on called function to synchronize + int ret = -1; + uint8_t ch; + if (read(&ch, 1) > 0) { + ret = static_cast(ch); + } + return ret; +} + +int File::read(void *buf, uint16_t nbyte) +{ + int ret = 0; + _fs->_lockFS(); + + if (!this->_is_dir) { + ret = lfs_file_read(_fs->_getFS(), _file, buf, nbyte); + } + + _fs->_unlockFS(); + return ret; +} + +int File::peek(void) +{ + int ret = -1; + _fs->_lockFS(); + + if (!this->_is_dir) { + uint32_t pos = lfs_file_tell(_fs->_getFS(), _file); + uint8_t ch = 0; + if (lfs_file_read(_fs->_getFS(), _file, &ch, 1) > 0) { + ret = static_cast(ch); + } + (void)lfs_file_seek(_fs->_getFS(), _file, pos, LFS_SEEK_SET); + } + + _fs->_unlockFS(); + return ret; +} + +int File::available(void) +{ + int ret = 0; + _fs->_lockFS(); + + if (!this->_is_dir) { + uint32_t size = lfs_file_size(_fs->_getFS(), _file); + uint32_t pos = lfs_file_tell(_fs->_getFS(), _file); + ret = size - pos; + } + + _fs->_unlockFS(); + return ret; +} + +bool File::seek(uint32_t pos) +{ + bool ret = false; + _fs->_lockFS(); + + if (!this->_is_dir) { + ret = lfs_file_seek(_fs->_getFS(), _file, pos, LFS_SEEK_SET) >= 0; + } + + _fs->_unlockFS(); + return ret; +} + +uint32_t File::position(void) +{ + uint32_t ret = 0; + _fs->_lockFS(); + + if (!this->_is_dir) { + ret = lfs_file_tell(_fs->_getFS(), _file); + } + + _fs->_unlockFS(); + return ret; +} + +uint32_t File::size(void) +{ + uint32_t ret = 0; + _fs->_lockFS(); + + if (!this->_is_dir) { + ret = lfs_file_size(_fs->_getFS(), _file); + } + + _fs->_unlockFS(); + return ret; +} + +bool File::truncate(uint32_t pos) +{ + int32_t ret = LFS_ERR_ISDIR; + _fs->_lockFS(); + if (!this->_is_dir) { + ret = lfs_file_truncate(_fs->_getFS(), _file, pos); + } + _fs->_unlockFS(); + return (ret == 0); +} + +bool File::truncate(void) +{ + int32_t ret = LFS_ERR_ISDIR; + _fs->_lockFS(); + if (!this->_is_dir) { + uint32_t pos = lfs_file_tell(_fs->_getFS(), _file); + ret = lfs_file_truncate(_fs->_getFS(), _file, pos); + } + _fs->_unlockFS(); + return (ret == 0); +} + +void File::flush(void) +{ + _fs->_lockFS(); + + if (!this->_is_dir) { + lfs_file_sync(_fs->_getFS(), _file); + } + + _fs->_unlockFS(); + return; +} + +void File::close(void) +{ + _fs->_lockFS(); + this->_close(); + _fs->_unlockFS(); +} + +void File::_close(void) +{ + if (this->isOpen()) { + if (this->_is_dir) { + lfs_dir_close(_fs->_getFS(), _dir); + free(_dir); + _dir = NULL; + + if (this->_dir_path) + free(_dir_path); + _dir_path = NULL; + } else { + lfs_file_close(this->_fs->_getFS(), _file); + free(_file); + _file = NULL; + } + } +} + +File::operator bool(void) +{ + return isOpen(); +} + +bool File::isOpen(void) +{ + return (_file != NULL) || (_dir != NULL); +} + +// WARNING -- although marked as `const`, the values pointed +// to may change. For example, if the same File +// object has `open()` called with a different +// file or directory name, this same pointer will +// suddenly (unexpectedly?) have different values. +char const *File::name(void) +{ + return this->_name; +} + +bool File::isDirectory(void) +{ + return this->_is_dir; +} + +File File::openNextFile(uint8_t mode) +{ + _fs->_lockFS(); + + File ret(*_fs); + if (this->_is_dir) { + struct lfs_info info; + int rc; + + // lfs_dir_read returns 0 when reaching end of directory, 1 if found an entry + // Skip the "." and ".." entries ... + do { + rc = lfs_dir_read(_fs->_getFS(), _dir, &info); + } while (rc == 1 && (!strcmp(".", info.name) || !strcmp("..", info.name))); + + if (rc == 1) { + // string cat name with current folder + char filepath[strlen(_dir_path) + 1 + strlen(info.name) + 1]; // potential for significant stack usage + strcpy(filepath, _dir_path); + if (!(_dir_path[0] == '/' && _dir_path[1] == 0)) + strcat(filepath, "/"); // only add '/' if cwd is not root + strcat(filepath, info.name); + + (void)ret._open(filepath, mode); // return value is ignored ... caller is expected to check isOpened() + } else if (rc < 0) { + PRINT_LFS_ERR(rc); + } + } + _fs->_unlockFS(); + return ret; +} + +void File::rewindDirectory(void) +{ + _fs->_lockFS(); + if (this->_is_dir) { + lfs_dir_rewind(_fs->_getFS(), _dir); + } + _fs->_unlockFS(); +} diff --git a/src/platform/apollo3/LittleFS_File.h b/src/platform/apollo3/LittleFS_File.h new file mode 100644 index 000000000..e88a2790d --- /dev/null +++ b/src/platform/apollo3/LittleFS_File.h @@ -0,0 +1,82 @@ +#ifndef LITTLEFS_FILE_H_ +#define LITTLEFS_FILE_H_ + +// Forward declaration +class LittleFS; + +namespace LittleFS_Namespace +{ + +// avoid conflict with other FileSystem FILE_READ/FILE_WRITE +enum { + FILE_O_READ = 0, + FILE_O_WRITE = 1, +}; + +class File : public Stream +{ + public: + explicit File(LittleFS &fs); + File(char const *filename, uint8_t mode, LittleFS &fs); + + public: + bool open(char const *filename, uint8_t mode); + + //------------- Stream API -------------// + virtual size_t write(uint8_t ch); + virtual size_t write(uint8_t const *buf, size_t size); + size_t write(const char *str) + { + if (str == NULL) + return 0; + return write((const uint8_t *)str, strlen(str)); + } + size_t write(const char *buffer, size_t size) { return write((const uint8_t *)buffer, size); } + + virtual int read(void); + int read(void *buf, uint16_t nbyte); + + virtual int peek(void); + virtual int available(void); + virtual void flush(void); + + bool seek(uint32_t pos); + uint32_t position(void); + uint32_t size(void); + + bool truncate(uint32_t pos); + bool truncate(void); + + void close(void); + + operator bool(void); + + bool isOpen(void); + char const *name(void); + + bool isDirectory(void); + File openNextFile(uint8_t mode = FILE_O_READ); + void rewindDirectory(void); + + private: + LittleFS *_fs; + + bool _is_dir; + + union { + lfs_file_t *_file; + lfs_dir_t *_dir; + }; + + char *_dir_path; + char _name[LFS_NAME_MAX + 1]; + + bool _open(char const *filepath, uint8_t mode); + bool _open_file(char const *filepath, uint8_t mode); + bool _open_dir(char const *filepath); + void _close(void); +}; + +} // namespace LittleFS_Namespace + +#endif /* LITTLEFS_FILE_H_ */ diff --git a/src/platform/apollo3/architecture.h b/src/platform/apollo3/architecture.h index a80dd24d4..afa24d506 100644 --- a/src/platform/apollo3/architecture.h +++ b/src/platform/apollo3/architecture.h @@ -6,10 +6,14 @@ // defaults for ARCH_APOLLO3 architecture // +#ifndef HAS_RADIO +#define HAS_RADIO 1 +#endif + // // set HW_VENDOR // #ifndef HW_VENDOR -#define HW_VENDOR HardwareModel_PRIVATE_HW +#define HW_VENDOR meshtastic_HardwareModel_PRIVATE_HW #endif diff --git a/src/platform/apollo3/main-apollo3.cpp b/src/platform/apollo3/main-apollo3.cpp index 31534768d..d4155b119 100644 --- a/src/platform/apollo3/main-apollo3.cpp +++ b/src/platform/apollo3/main-apollo3.cpp @@ -1,4 +1,4 @@ -#include "RTC.h" +#include "gps/RTC.h" #include "configuration.h" void setBluetoothEnable(bool on) {} diff --git a/variants/rak11720/mbed/.cxx-flags b/variants/rak11720/mbed/.cxx-flags new file mode 100644 index 000000000..3bb78994a --- /dev/null +++ b/variants/rak11720/mbed/.cxx-flags @@ -0,0 +1 @@ +-c -fno-rtti -std=gnu++14 -DMBED_MINIMAL_PRINTF -DMBED_TRAP_ERRORS_ENABLED=1 -Os -fdata-sections -ffunction-sections -fmessage-length=0 -fno-exceptions -fomit-frame-pointer -funsigned-char -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -mthumb \ No newline at end of file diff --git a/variants/rak11720/mbed/.cxx-symbols b/variants/rak11720/mbed/.cxx-symbols new file mode 100644 index 000000000..cd781d23e --- /dev/null +++ b/variants/rak11720/mbed/.cxx-symbols @@ -0,0 +1 @@ +-DAM_CUSTOM_BDADDR -DAM_PACKAGE_BGA -DARDUINO_BLE_FIX -DARM_MATH_CM4 -DCOMPONENT_FLASHIAP=1 -DCORDIO_ZERO_COPY_HCI -DDEVICE_FLASH=1 -DDEVICE_I2C=1 -DDEVICE_INTERRUPTIN=1 -DDEVICE_LPTICKER=1 -DDEVICE_MPU=1 -DDEVICE_SERIAL=1 -DDEVICE_SPI=1 -DDEVICE_STDIO_MESSAGES=1 -DDEVICE_USTICKER=1 -DFEATURE_BLE=1 -DTARGET_AMA3B1KK -DTARGET_Ambiq_Micro -DTARGET_Apollo3 -DTARGET_CORDIO -DTARGET_CORTEX -DTARGET_CORTEX_M -DTARGET_FAMILY_Apollo3 -DTARGET_LIKE_CORTEX_M4 -DTARGET_LIKE_MBED -DTARGET_LoRa_THING_PLUS_expLoRaBLE -DTARGET_M4 -DTARGET_NAME=LoRa_THING_PLUS_expLoRaBLE -DTARGET_RELEASE -DTARGET_RTOS_M4_M7 -DTOOLCHAIN_GCC -DTOOLCHAIN_GCC_ARM -D__CMSIS_RTOS -D__CORTEX_M4 -D__FPU_PRESENT=1 -D__MBED_CMSIS_RTOS_CM -D__MBED__=1 \ No newline at end of file diff --git a/variants/rak11720/mbed/.includes b/variants/rak11720/mbed/.includes new file mode 100644 index 000000000..2c1758698 --- /dev/null +++ b/variants/rak11720/mbed/.includes @@ -0,0 +1,306 @@ +"-iwithprefixbeforembed-os" +"-iwithprefixbeforembed-os/cmsis" +"-iwithprefixbeforembed-os/cmsis/TARGET_CORTEX_M" +"-iwithprefixbeforembed-os/components" +"-iwithprefixbeforembed-os/components/802.15.4_RF" +"-iwithprefixbeforembed-os/components/802.15.4_RF/atmel-rf-driver" +"-iwithprefixbeforembed-os/components/802.15.4_RF/atmel-rf-driver/atmel-rf-driver" +"-iwithprefixbeforembed-os/components/802.15.4_RF/atmel-rf-driver/source" +"-iwithprefixbeforembed-os/components/802.15.4_RF/mcr20a-rf-driver" +"-iwithprefixbeforembed-os/components/802.15.4_RF/mcr20a-rf-driver/mcr20a-rf-driver" +"-iwithprefixbeforembed-os/components/802.15.4_RF/mcr20a-rf-driver/source" +"-iwithprefixbeforembed-os/components/802.15.4_RF/stm-s2lp-rf-driver" +"-iwithprefixbeforembed-os/components/802.15.4_RF/stm-s2lp-rf-driver/source" +"-iwithprefixbeforembed-os/components/802.15.4_RF/stm-s2lp-rf-driver/stm-s2lp-rf-driver" +"-iwithprefixbeforembed-os/components/storage/blockdevice/COMPONENT_FLASHIAP" +"-iwithprefixbeforembed-os/components/storage/blockdevice/COMPONENT_FLASHIAP/COMMON" +"-iwithprefixbeforembed-os/components/wifi" +"-iwithprefixbeforembed-os/components/wifi/esp8266-driver" +"-iwithprefixbeforembed-os/components/wifi/esp8266-driver/ESP8266" +"-iwithprefixbeforembed-os/drivers/internal" +"-iwithprefixbeforembed-os/events" +"-iwithprefixbeforembed-os/events/internal" +"-iwithprefixbeforembed-os/features" +"-iwithprefixbeforembed-os/features/FEATURE_BLE" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/ble" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/ble/common" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/ble/gap" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/ble/generic" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/ble/pal" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/ble/services" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/source" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/source/gap" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/source/generic" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_Ambiq_Micro" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_Ambiq_Micro/TARGET_Apollo3" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_Ambiq_Micro/hal" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_Ambiq_Micro/hal/apollo3" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/driver" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/source" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/include" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/hci" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/hci/dual_chip" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/sec" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/sec/common" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/stack" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/stack/att" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/stack/cfg" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/stack/dm" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/stack/hci" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/stack/l2c" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/ble-host/sources/stack/smp" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/platform" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/platform/include" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/wsf" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/wsf/include" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/wsf/include/util" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/wsf/sources" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/wsf/sources/port" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack/wsf/sources/port/baremetal" +"-iwithprefixbeforembed-os/features/FEATURE_BLE/targets/TARGET_CORDIO/stack_adaptation" +"-iwithprefixbeforembed-os/features/cellular" +"-iwithprefixbeforembed-os/features/cellular/framework" +"-iwithprefixbeforembed-os/features/cellular/framework/API" +"-iwithprefixbeforembed-os/features/cellular/framework/AT" +"-iwithprefixbeforembed-os/features/cellular/framework/common" +"-iwithprefixbeforembed-os/features/cellular/framework/device" +"-iwithprefixbeforembed-os/features/cellular/framework/targets" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/Altair" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/Altair/ALT1250" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/Altair/ALT1250/PPP" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/GEMALTO" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/GEMALTO/CINTERION" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/GENERIC" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/GENERIC/GENERIC_AT3GPP" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/MultiTech" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/MultiTech/DragonflyNano" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/MultiTech/DragonflyNano/PPP" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/QUECTEL" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/QUECTEL/BC95" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/QUECTEL/BG96" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/QUECTEL/EC2X" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/QUECTEL/M26" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/QUECTEL/UG96" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/RiotMicro" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/RiotMicro/AT" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/TELIT" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/TELIT/HE910" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/TELIT/ME310" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/TELIT/ME910" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/UBLOX" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/UBLOX/AT" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/UBLOX/N2XX" +"-iwithprefixbeforembed-os/features/cellular/framework/targets/UBLOX/PPP" +"-iwithprefixbeforembed-os/features/device_key" +"-iwithprefixbeforembed-os/features/device_key/source" +"-iwithprefixbeforembed-os/features/frameworks" +"-iwithprefixbeforembed-os/features/frameworks/greentea-client" +"-iwithprefixbeforembed-os/features/frameworks/greentea-client/greentea-client" +"-iwithprefixbeforembed-os/features/frameworks/mbed-client-cli" +"-iwithprefixbeforembed-os/features/frameworks/mbed-client-cli/mbed-client-cli" +"-iwithprefixbeforembed-os/features/frameworks/mbed-client-randlib" +"-iwithprefixbeforembed-os/features/frameworks/mbed-client-randlib/mbed-client-randlib" +"-iwithprefixbeforembed-os/features/frameworks/mbed-client-randlib/mbed-client-randlib/platform" +"-iwithprefixbeforembed-os/features/frameworks/mbed-coap" +"-iwithprefixbeforembed-os/features/frameworks/mbed-coap/mbed-coap" +"-iwithprefixbeforembed-os/features/frameworks/mbed-coap/source" +"-iwithprefixbeforembed-os/features/frameworks/mbed-coap/source/include" +"-iwithprefixbeforembed-os/features/frameworks/mbed-trace" +"-iwithprefixbeforembed-os/features/frameworks/mbed-trace/mbed-trace" +"-iwithprefixbeforembed-os/features/frameworks/nanostack-libservice" +"-iwithprefixbeforembed-os/features/frameworks/nanostack-libservice/mbed-client-libservice" +"-iwithprefixbeforembed-os/features/frameworks/nanostack-libservice/mbed-client-libservice/platform" +"-iwithprefixbeforembed-os/features/frameworks/unity" +"-iwithprefixbeforembed-os/features/frameworks/unity/unity" +"-iwithprefixbeforembed-os/features/frameworks/utest" +"-iwithprefixbeforembed-os/features/frameworks/utest/utest" +"-iwithprefixbeforembed-os/features/lorawan" +"-iwithprefixbeforembed-os/features/lorawan/lorastack" +"-iwithprefixbeforembed-os/features/lorawan/lorastack/mac" +"-iwithprefixbeforembed-os/features/lorawan/lorastack/phy" +"-iwithprefixbeforembed-os/features/lorawan/system" +"-iwithprefixbeforembed-os/features/lwipstack" +"-iwithprefixbeforembed-os/features/lwipstack/lwip" +"-iwithprefixbeforembed-os/features/lwipstack/lwip-sys" +"-iwithprefixbeforembed-os/features/lwipstack/lwip-sys/arch" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/compat" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/compat/posix" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/compat/posix/arpa" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/compat/posix/net" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/compat/posix/sys" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/lwip" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/lwip/priv" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/lwip/prot" +"-iwithprefixbeforembed-os/features/lwipstack/lwip/src/include/netif" +"-iwithprefixbeforembed-os/features/mbedtls" +"-iwithprefixbeforembed-os/features/mbedtls/inc" +"-iwithprefixbeforembed-os/features/mbedtls/inc/mbedtls" +"-iwithprefixbeforembed-os/features/mbedtls/platform" +"-iwithprefixbeforembed-os/features/mbedtls/platform/inc" +"-iwithprefixbeforembed-os/features/nanostack" +"-iwithprefixbeforembed-os/features/nanostack/coap-service" +"-iwithprefixbeforembed-os/features/nanostack/coap-service/coap-service" +"-iwithprefixbeforembed-os/features/nanostack/coap-service/source" +"-iwithprefixbeforembed-os/features/nanostack/coap-service/source/include" +"-iwithprefixbeforembed-os/features/nanostack/mbed-mesh-api" +"-iwithprefixbeforembed-os/features/nanostack/mbed-mesh-api/mbed-mesh-api" +"-iwithprefixbeforembed-os/features/nanostack/mbed-mesh-api/source" +"-iwithprefixbeforembed-os/features/nanostack/mbed-mesh-api/source/include" +"-iwithprefixbeforembed-os/features/nanostack/nanostack-hal-mbed-cmsis-rtos" +"-iwithprefixbeforembed-os/features/nanostack/nanostack-interface" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack-eventloop" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack-eventloop/nanostack-event-loop" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack-eventloop/nanostack-event-loop/platform" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack-eventloop/source" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/nanostack" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/nanostack/platform" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/Bootstraps" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/Fragmentation" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/IPHC_Decode" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/MAC" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/Mesh" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/ND" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/NVM" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/Thread" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/6LoWPAN/ws" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/BorderRouter" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Common_Protocols" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Core" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Core/include" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/DHCPv6_Server" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/DHCPv6_client" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/MAC" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/MAC/IEEE802_15_4" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/MAC/virtual_rf" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/MLE" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/MPL" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/NWK_INTERFACE" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/NWK_INTERFACE/Include" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/RPL" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/Common" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/PANA" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/TLS" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/eapol" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/kmp" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/protocols" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/protocols/eap_tls_sec_prot" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/protocols/fwh_sec_prot" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/protocols/gkh_sec_prot" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/protocols/key_sec_prot" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Security/protocols/tls_sec_prot" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/Neighbor_cache" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/Trickle" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/blacklist" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/etx" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/fhss" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/fnv_hash" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/hmac" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/ieee_802_11" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/load_balance" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mac_neighbor_table" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/port" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/port/compiler" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/port/cpu" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/services" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/services/dns" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/services/mdns" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/services/poll" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/services/serial" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mdns/fnet/fnet_stack/stack" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/mle_service" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/nd_proxy" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/nist_aes_kw" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/pan_blacklist" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/utils" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/Service_Libs/whiteboard" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/configs" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/configs/base" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/ipv6_stack" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/libDHCPv6" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/libNET" +"-iwithprefixbeforembed-os/features/nanostack/sal-stack-nanostack/source/libNET/src" +"-iwithprefixbeforembed-os/features/netsocket" +"-iwithprefixbeforembed-os/features/netsocket/ppp" +"-iwithprefixbeforembed-os/features/netsocket/ppp/include" +"-iwithprefixbeforembed-os/features/netsocket/ppp/include/polarssl" +"-iwithprefixbeforembed-os/features/nfc" +"-iwithprefixbeforembed-os/features/nfc/acore" +"-iwithprefixbeforembed-os/features/nfc/acore/acore" +"-iwithprefixbeforembed-os/features/nfc/controllers" +"-iwithprefixbeforembed-os/features/nfc/nfc" +"-iwithprefixbeforembed-os/features/nfc/nfc/ndef" +"-iwithprefixbeforembed-os/features/nfc/nfc/ndef/common" +"-iwithprefixbeforembed-os/features/nfc/stack" +"-iwithprefixbeforembed-os/features/nfc/stack/ndef" +"-iwithprefixbeforembed-os/features/nfc/stack/platform" +"-iwithprefixbeforembed-os/features/nfc/stack/tech" +"-iwithprefixbeforembed-os/features/nfc/stack/tech/iso7816" +"-iwithprefixbeforembed-os/features/nfc/stack/tech/isodep" +"-iwithprefixbeforembed-os/features/nfc/stack/tech/type4" +"-iwithprefixbeforembed-os/features/nfc/stack/transceiver" +"-iwithprefixbeforembed-os/features/nfc/stack/transceiver/pn512" +"-iwithprefixbeforembed-os/features/storage" +"-iwithprefixbeforembed-os/features/storage/blockdevice" +"-iwithprefixbeforembed-os/features/storage/filesystem" +"-iwithprefixbeforembed-os/features/storage/filesystem/fat" +"-iwithprefixbeforembed-os/features/storage/filesystem/fat/ChaN" +"-iwithprefixbeforembed-os/features/storage/filesystem/littlefs" +"-iwithprefixbeforembed-os/features/storage/filesystem/littlefs/littlefs" +"-iwithprefixbeforembed-os/features/storage/filesystem/littlefsv2" +"-iwithprefixbeforembed-os/features/storage/filesystem/littlefsv2/littlefs" +"-iwithprefixbeforembed-os/features/storage/kvstore" +"-iwithprefixbeforembed-os/features/storage/kvstore/conf" +"-iwithprefixbeforembed-os/features/storage/kvstore/direct_access_devicekey" +"-iwithprefixbeforembed-os/features/storage/kvstore/filesystemstore" +"-iwithprefixbeforembed-os/features/storage/kvstore/global_api" +"-iwithprefixbeforembed-os/features/storage/kvstore/include" +"-iwithprefixbeforembed-os/features/storage/kvstore/kv_map" +"-iwithprefixbeforembed-os/features/storage/kvstore/securestore" +"-iwithprefixbeforembed-os/features/storage/kvstore/tdbstore" +"-iwithprefixbeforembed-os/hal" +"-iwithprefixbeforembed-os/hal/usb" +"-iwithprefixbeforembed-os/platform" +"-iwithprefixbeforembed-os/platform/cxxsupport" +"-iwithprefixbeforembed-os/platform/internal" +"-iwithprefixbeforembed-os/platform/source" +"-iwithprefixbeforembed-os/platform/source/minimal-printf" +"-iwithprefixbeforembed-os/rtos" +"-iwithprefixbeforembed-os/rtos/source" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX/rtx4" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX/rtx5" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX/rtx5/Include" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX/rtx5/RTX" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX/rtx5/RTX/Config" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX/rtx5/RTX/Include" +"-iwithprefixbeforembed-os/rtos/source/TARGET_CORTEX/rtx5/RTX/Source" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/TARGET_LoRa_THING_PLUS_expLoRaBLE" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/TARGET_LoRa_THING_PLUS_expLoRaBLE/bsp" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/device" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk/CMSIS" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk/CMSIS/AmbiqMicro" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk/CMSIS/AmbiqMicro/Include" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk/mcu" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk/mcu/apollo3" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk/mcu/apollo3/hal" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/TARGET_Apollo3/sdk/mcu/apollo3/regs" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/sdk" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/sdk/devices" +"-iwithprefixbeforembed-os/targets/TARGET_Ambiq_Micro/sdk/utils" \ No newline at end of file diff --git a/variants/rak11720/mbed/mbed_config.h b/variants/rak11720/mbed/mbed_config.h new file mode 100644 index 000000000..3d9a3731a --- /dev/null +++ b/variants/rak11720/mbed/mbed_config.h @@ -0,0 +1,398 @@ +/* + * mbed SDK + * Copyright (c) 2017 ARM Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Automatically generated configuration file. +// DO NOT EDIT, content will be overwritten. + +#ifndef __MBED_CONFIG_DATA__ +#define __MBED_CONFIG_DATA__ + +// Configuration parameters +#define ATT_NUM_SIMUL_NTF 1 // set by library:cordio +#define ATT_NUM_SIMUL_WRITE_CMD 1 // set by library:cordio +#define BLE_FEATURE_EXTENDED_ADVERTISING 1 // set by library:ble +#define BLE_FEATURE_GATT_CLIENT 1 // set by library:ble +#define BLE_FEATURE_GATT_SERVER 1 // set by library:ble +#define BLE_FEATURE_PERIODIC_ADVERTISING 1 // set by library:ble +#define BLE_FEATURE_PHY_MANAGEMENT 1 // set by library:ble +#define BLE_FEATURE_PRIVACY 1 // set by library:ble +#define BLE_FEATURE_SECURE_CONNECTIONS 1 // set by library:ble +#define BLE_FEATURE_SECURITY 1 // set by library:ble +#define BLE_FEATURE_SIGNING 1 // set by library:ble +#define BLE_FEATURE_WHITELIST 1 // set by library:ble +#define BLE_ROLE_BROADCASTER 1 // set by library:ble +#define BLE_ROLE_CENTRAL 1 // set by library:ble +#define BLE_ROLE_OBSERVER 1 // set by library:ble +#define BLE_ROLE_PERIPHERAL 1 // set by library:ble +#define BLE_SECURITY_DATABASE_MAX_ENTRIES 5 // set by library:ble +#define DM_CONN_MAX 3 // set by library:cordio +#define DM_NUM_ADV_SETS 3 // set by library:cordio +#define DM_NUM_PHYS 3 // set by library:cordio +#define DM_SYNC_MAX 1 // set by library:cordio +#define L2C_COC_CHAN_MAX 1 // set by library:cordio +#define L2C_COC_REG_MAX 1 // set by library:cordio +#define MBED_CONF_ALT1250_PPP_BAUDRATE 115200 // set by library:ALT1250_PPP +#define MBED_CONF_ALT1250_PPP_PROVIDE_DEFAULT 0 // set by library:ALT1250_PPP +#define MBED_CONF_ATMEL_RF_ASSUME_SPACED_SPI 0 // set by library:atmel-rf +#define MBED_CONF_ATMEL_RF_FULL_SPI_SPEED 7500000 // set by library:atmel-rf +#define MBED_CONF_ATMEL_RF_FULL_SPI_SPEED_BYTE_SPACING 250 // set by library:atmel-rf +#define MBED_CONF_ATMEL_RF_IRQ_THREAD_STACK_SIZE 1024 // set by library:atmel-rf +#define MBED_CONF_ATMEL_RF_LOW_SPI_SPEED 3750000 // set by library:atmel-rf +#define MBED_CONF_ATMEL_RF_PROVIDE_DEFAULT 0 // set by library:atmel-rf +#define MBED_CONF_ATMEL_RF_USE_SPI_SPACING_API 0 // set by library:atmel-rf +#define MBED_CONF_BLE_PRESENT 1 // set by library:ble +#define MBED_CONF_CELLULAR_CONTROL_PLANE_OPT 0 // set by library:cellular +#define MBED_CONF_CELLULAR_DEBUG_AT 0 // set by library:cellular +#define MBED_CONF_CELLULAR_MAX_CP_DATA_RECV_LEN 1358 // set by library:cellular +#define MBED_CONF_CELLULAR_RANDOM_MAX_START_DELAY 0 // set by library:cellular +#define MBED_CONF_CELLULAR_USE_APN_LOOKUP 0 // set by library:cellular +#define MBED_CONF_CELLULAR_USE_SMS 0 // set by library:cellular +#define MBED_CONF_CORDIO_DESIRED_ATT_MTU 23 // set by library:cordio +#define MBED_CONF_CORDIO_MAX_PREPARED_WRITES 4 // set by library:cordio +#define MBED_CONF_CORDIO_PREFERRED_TX_POWER 0 // set by library:cordio +#define MBED_CONF_CORDIO_ROUTE_UNHANDLED_COMMAND_COMPLETE_EVENTS 1 // set by library:cordio +#define MBED_CONF_CORDIO_RX_ACL_BUFFER_SIZE 70 // set by library:cordio +#define MBED_CONF_DRIVERS_QSPI_CSN QSPI_FLASH1_CSN // set by library:drivers +#define MBED_CONF_DRIVERS_QSPI_IO0 QSPI_FLASH1_IO0 // set by library:drivers +#define MBED_CONF_DRIVERS_QSPI_IO1 QSPI_FLASH1_IO1 // set by library:drivers +#define MBED_CONF_DRIVERS_QSPI_IO2 QSPI_FLASH1_IO2 // set by library:drivers +#define MBED_CONF_DRIVERS_QSPI_IO3 QSPI_FLASH1_IO3 // set by library:drivers +#define MBED_CONF_DRIVERS_QSPI_SCK QSPI_FLASH1_SCK // set by library:drivers +#define MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE 256 // set by library:drivers +#define MBED_CONF_DRIVERS_UART_SERIAL_TXBUF_SIZE 256 // set by library:drivers +#define MBED_CONF_ESP8266_BUILT_IN_DNS 0 // set by library:esp8266 +#define MBED_CONF_ESP8266_DEBUG 0 // set by library:esp8266 +#define MBED_CONF_ESP8266_POWER_OFF_TIME_MS 3 // set by library:esp8266 +#define MBED_CONF_ESP8266_POWER_ON_POLARITY 0 // set by library:esp8266 +#define MBED_CONF_ESP8266_POWER_ON_TIME_MS 3 // set by library:esp8266 +#define MBED_CONF_ESP8266_PROVIDE_DEFAULT 0 // set by library:esp8266 +#define MBED_CONF_ESP8266_SERIAL_BAUDRATE 115200 // set by library:esp8266 +#define MBED_CONF_ESP8266_SNTP_ENABLE 0 // set by library:esp8266 +#define MBED_CONF_ESP8266_SNTP_SERVER0 "" // set by library:esp8266 +#define MBED_CONF_ESP8266_SNTP_SERVER1 "" // set by library:esp8266 +#define MBED_CONF_ESP8266_SNTP_SERVER2 "" // set by library:esp8266 +#define MBED_CONF_ESP8266_SNTP_TIMEZONE 0 // set by library:esp8266 +#define MBED_CONF_ESP8266_SOCKET_BUFSIZE 8192 // set by library:esp8266 +#define MBED_CONF_EVENTS_PRESENT 1 // set by library:events +#define MBED_CONF_EVENTS_SHARED_DISPATCH_FROM_APPLICATION 0 // set by library:events +#define MBED_CONF_EVENTS_SHARED_EVENTSIZE 768 // set by library:events +#define MBED_CONF_EVENTS_SHARED_HIGHPRIO_EVENTSIZE 256 // set by library:events +#define MBED_CONF_EVENTS_SHARED_HIGHPRIO_STACKSIZE 1024 // set by library:events +#define MBED_CONF_EVENTS_SHARED_STACKSIZE 2048 // set by library:events +#define MBED_CONF_EVENTS_USE_LOWPOWER_TIMER_TICKER 0 // set by library:events +#define MBED_CONF_FAT_CHAN_FFS_DBG 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_CODE_PAGE 437 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_EXFAT 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_HEAPBUF 1 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_LOCK 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_MINIMIZE 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_NOFSINFO 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_NORTC 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_READONLY 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_REENTRANT 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_RPATH 1 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_TIMEOUT 1000 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_FS_TINY 1 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_LFN_BUF 255 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_LFN_UNICODE 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_MAX_LFN 255 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_MAX_SS 4096 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_MIN_SS 512 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_MULTI_PARTITION 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_NORTC_MDAY 1 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_NORTC_MON 1 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_NORTC_YEAR 2017 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_SFN_BUF 12 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_STRF_ENCODE 3 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_STR_VOLUME_ID 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_SYNC_T HANDLE // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_CHMOD 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_EXPAND 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_FASTSEEK 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_FIND 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_FORWARD 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_LABEL 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_LFN 3 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_MKFS 1 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_STRFUNC 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_USE_TRIM 1 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_VOLUMES 4 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FF_VOLUME_STRS "RAM","NAND","CF","SD","SD2","USB","USB2","USB3" // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FLUSH_ON_NEW_CLUSTER 0 // set by library:fat_chan +#define MBED_CONF_FAT_CHAN_FLUSH_ON_NEW_SECTOR 1 // set by library:fat_chan +#define MBED_CONF_FILESYSTEM_PRESENT 1 // set by library:filesystem +#define MBED_CONF_FLASHIAP_BLOCK_DEVICE_BASE_ADDRESS 0xFFFFFFFF // set by library:flashiap-block-device +#define MBED_CONF_FLASHIAP_BLOCK_DEVICE_SIZE 0 // set by library:flashiap-block-device +#define MBED_CONF_GEMALTO_CINTERION_BAUDRATE 115200 // set by library:GEMALTO_CINTERION +#define MBED_CONF_GEMALTO_CINTERION_PROVIDE_DEFAULT 0 // set by library:GEMALTO_CINTERION +#define MBED_CONF_GENERIC_AT3GPP_BAUDRATE 115200 // set by library:GENERIC_AT3GPP +#define MBED_CONF_GENERIC_AT3GPP_PROVIDE_DEFAULT 0 // set by library:GENERIC_AT3GPP +#define MBED_CONF_LORA_ADR_ON 1 // set by library:lora +#define MBED_CONF_LORA_APPLICATION_EUI {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora +#define MBED_CONF_LORA_APPLICATION_KEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora +#define MBED_CONF_LORA_APPSKEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora +#define MBED_CONF_LORA_APP_PORT 15 // set by library:lora +#define MBED_CONF_LORA_AUTOMATIC_UPLINK_MESSAGE 1 // set by library:lora +#define MBED_CONF_LORA_DEVICE_ADDRESS 0x00000000 // set by library:lora +#define MBED_CONF_LORA_DEVICE_EUI {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora +#define MBED_CONF_LORA_DOWNLINK_PREAMBLE_LENGTH 5 // set by library:lora +#define MBED_CONF_LORA_DUTY_CYCLE_ON 1 // set by library:lora +#define MBED_CONF_LORA_DUTY_CYCLE_ON_JOIN 1 // set by library:lora +#define MBED_CONF_LORA_FSB_MASK {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00FF} // set by library:lora +#define MBED_CONF_LORA_FSB_MASK_CHINA {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF} // set by library:lora +#define MBED_CONF_LORA_LBT_ON 0 // set by library:lora +#define MBED_CONF_LORA_MAX_SYS_RX_ERROR 5 // set by library:lora +#define MBED_CONF_LORA_NB_TRIALS 12 // set by library:lora +#define MBED_CONF_LORA_NWKSKEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora +#define MBED_CONF_LORA_OVER_THE_AIR_ACTIVATION 1 // set by library:lora +#define MBED_CONF_LORA_PHY EU868 // set by library:lora +#define MBED_CONF_LORA_PUBLIC_NETWORK 1 // set by library:lora +#define MBED_CONF_LORA_TX_MAX_SIZE 64 // set by library:lora +#define MBED_CONF_LORA_UPLINK_PREAMBLE_LENGTH 8 // set by library:lora +#define MBED_CONF_LORA_WAKEUP_TIME 5 // set by library:lora +#define MBED_CONF_LWIP_ADDR_TIMEOUT 5 // set by library:lwip +#define MBED_CONF_LWIP_ADDR_TIMEOUT_MODE 1 // set by library:lwip +#define MBED_CONF_LWIP_DEBUG_ENABLED 0 // set by library:lwip +#define MBED_CONF_LWIP_DEFAULT_THREAD_STACKSIZE 512 // set by library:lwip +#define MBED_CONF_LWIP_DHCP_TIMEOUT 60 // set by library:lwip +#define MBED_CONF_LWIP_ENABLE_PPP_TRACE 0 // set by library:lwip +#define MBED_CONF_LWIP_ETHERNET_ENABLED 1 // set by library:lwip +#define MBED_CONF_LWIP_IPV4_ENABLED 1 // set by library:lwip +#define MBED_CONF_LWIP_IPV6_ENABLED 0 // set by library:lwip +#define MBED_CONF_LWIP_IP_VER_PREF 4 // set by library:lwip +#define MBED_CONF_LWIP_L3IP_ENABLED 0 // set by library:lwip +#define MBED_CONF_LWIP_MBOX_SIZE 8 // set by library:lwip +#define MBED_CONF_LWIP_MEMP_NUM_TCPIP_MSG_INPKT 8 // set by library:lwip +#define MBED_CONF_LWIP_MEMP_NUM_TCP_SEG 16 // set by library:lwip +#define MBED_CONF_LWIP_MEM_SIZE 1600 // set by library:lwip +#define MBED_CONF_LWIP_NUM_NETBUF 8 // set by library:lwip +#define MBED_CONF_LWIP_NUM_PBUF 8 // set by library:lwip +#define MBED_CONF_LWIP_PBUF_POOL_SIZE 5 // set by library:lwip +#define MBED_CONF_LWIP_PPP_ENABLED 0 // set by library:lwip +#define MBED_CONF_LWIP_PPP_IPV4_ENABLED 0 // set by library:lwip +#define MBED_CONF_LWIP_PPP_IPV6_ENABLED 0 // set by library:lwip +#define MBED_CONF_LWIP_PPP_THREAD_STACKSIZE 768 // set by library:lwip +#define MBED_CONF_LWIP_PRESENT 1 // set by library:lwip +#define MBED_CONF_LWIP_RAW_SOCKET_ENABLED 0 // set by library:lwip +#define MBED_CONF_LWIP_SOCKET_MAX 4 // set by library:lwip +#define MBED_CONF_LWIP_TCPIP_THREAD_PRIORITY osPriorityNormal // set by library:lwip +#define MBED_CONF_LWIP_TCPIP_THREAD_STACKSIZE 1200 // set by library:lwip +#define MBED_CONF_LWIP_TCP_CLOSE_TIMEOUT 1000 // set by library:lwip +#define MBED_CONF_LWIP_TCP_ENABLED 1 // set by library:lwip +#define MBED_CONF_LWIP_TCP_MAXRTX 6 // set by library:lwip +#define MBED_CONF_LWIP_TCP_MSS 536 // set by library:lwip +#define MBED_CONF_LWIP_TCP_SERVER_MAX 4 // set by library:lwip +#define MBED_CONF_LWIP_TCP_SND_BUF (2 * TCP_MSS) // set by library:lwip +#define MBED_CONF_LWIP_TCP_SOCKET_MAX 4 // set by library:lwip +#define MBED_CONF_LWIP_TCP_SYNMAXRTX 6 // set by library:lwip +#define MBED_CONF_LWIP_TCP_WND (4 * TCP_MSS) // set by library:lwip +#define MBED_CONF_LWIP_UDP_SOCKET_MAX 4 // set by library:lwip +#define MBED_CONF_LWIP_USE_MBED_TRACE 0 // set by library:lwip +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL 0 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL_MASK 0x7fff800 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL_PAGE 0 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_DEVICE_TYPE NET_6LOWPAN_ROUTER // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PANID_FILTER 0xffff // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf} // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY_ID 1 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SECURITY_MODE NONE // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SEC_LEVEL 5 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_HEAP_SIZE 32500 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_HEAP_STAT_INFO NULL // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_MAC_NEIGH_TABLE_SIZE 32 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL 22 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_MASK 0x7fff800 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_PAGE 0 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_COMMISSIONING_DATASET_TIMESTAMP 0x10000 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_EXTENDED_PANID {0xf1, 0xb5, 0xa1, 0xb2,0xc4, 0xd5, 0xa1, 0xbd } // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_ML_PREFIX {0xfd, 0x0, 0x0d, 0xb8, 0x0, 0x0, 0x0, 0x0} // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_NETWORK_NAME "Thread Network" // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_PANID 0x0700 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_PSKC {0xc8, 0xa6, 0x2e, 0xae, 0xf3, 0x68, 0xf3, 0x46, 0xa9, 0x9e, 0x57, 0x85, 0x98, 0x9d, 0x1c, 0xd0} // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE MESH_DEVICE_TYPE_THREAD_ROUTER // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_MASTER_KEY {0x10, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff} // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_PSKD "ABCDEFGH" // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_SECURITY_POLICY 255 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_THREAD_USE_STATIC_LINK_CONFIG 1 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_USE_MALLOC_FOR_HEAP 0 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_BC_CHANNEL_FUNCTION 255 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_BC_DWELL_INTERVAL 0 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_BC_FIXED_CHANNEL 65535 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_BC_INTERVAL 0 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_DEVICE_TYPE MESH_DEVICE_TYPE_WISUN_ROUTER // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_NETWORK_NAME "Wi-SUN Network" // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_OPERATING_CLASS 255 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_OPERATING_MODE 255 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_REGULATORY_DOMAIN 3 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_UC_CHANNEL_FUNCTION 255 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_UC_DWELL_INTERVAL 255 // set by library:mbed-mesh-api +#define MBED_CONF_MBED_MESH_API_WISUN_UC_FIXED_CHANNEL 65535 // set by library:mbed-mesh-api +#define MBED_CONF_MCR20A_PROVIDE_DEFAULT 0 // set by library:mcr20a +#define MBED_CONF_NANOSTACK_CONFIGURATION nanostack_full // set by library:nanostack +#define MBED_CONF_NANOSTACK_HAL_CRITICAL_SECTION_USABLE_FROM_INTERRUPT 0 // set by library:nanostack-hal +#define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_DISPATCH_FROM_APPLICATION 0 // set by library:nanostack-hal +#define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_THREAD_STACK_SIZE 6144 // set by library:nanostack-hal +#define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_USE_MBED_EVENTS 0 // set by library:nanostack-hal +#define MBED_CONF_NANOSTACK_HAL_KVSTORE_PATH "/kv/" // set by library:nanostack-hal +#define MBED_CONF_NANOSTACK_HAL_USE_KVSTORE 0 // set by library:nanostack-hal +#define MBED_CONF_NSAPI_DEFAULT_MESH_TYPE THREAD // set by library:nsapi +#define MBED_CONF_NSAPI_DEFAULT_STACK LWIP // set by library:nsapi +#define MBED_CONF_NSAPI_DEFAULT_WIFI_SECURITY NONE // set by library:nsapi +#define MBED_CONF_NSAPI_DNS_ADDRESSES_LIMIT 10 // set by library:nsapi +#define MBED_CONF_NSAPI_DNS_CACHE_SIZE 3 // set by library:nsapi +#define MBED_CONF_NSAPI_DNS_RESPONSE_WAIT_TIME 10000 // set by library:nsapi +#define MBED_CONF_NSAPI_DNS_RETRIES 1 // set by library:nsapi +#define MBED_CONF_NSAPI_DNS_TOTAL_ATTEMPTS 10 // set by library:nsapi +#define MBED_CONF_NSAPI_PRESENT 1 // set by library:nsapi +#define MBED_CONF_NSAPI_SOCKET_STATS_ENABLED 0 // set by library:nsapi +#define MBED_CONF_NSAPI_SOCKET_STATS_MAX_COUNT 10 // set by library:nsapi +#define MBED_CONF_PLATFORM_CALLBACK_COMPARABLE 1 // set by library:platform +#define MBED_CONF_PLATFORM_CALLBACK_NONTRIVIAL 0 // set by library:platform +#define MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED 0 // set by library:platform +#define MBED_CONF_PLATFORM_CTHUNK_COUNT_MAX 8 // set by library:platform +#define MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE 9600 // set by library:platform +#define MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO 0 // set by library:platform +#define MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED 0 // set by library:platform +#define MBED_CONF_PLATFORM_ERROR_HIST_ENABLED 0 // set by library:platform +#define MBED_CONF_PLATFORM_ERROR_HIST_SIZE 4 // set by library:platform +#define MBED_CONF_PLATFORM_ERROR_REBOOT_MAX 1 // set by library:platform +#define MBED_CONF_PLATFORM_FATAL_ERROR_AUTO_REBOOT_ENABLED 0 // set by library:platform +#define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 16 // set by library:platform +#define MBED_CONF_PLATFORM_MINIMAL_PRINTF_ENABLE_64_BIT 1 // set by library:platform +#define MBED_CONF_PLATFORM_MINIMAL_PRINTF_ENABLE_FLOATING_POINT 0 // set by library:platform +#define MBED_CONF_PLATFORM_MINIMAL_PRINTF_SET_FLOATING_POINT_MAX_DECIMALS 6 // set by library:platform +#define MBED_CONF_PLATFORM_POLL_USE_LOWPOWER_TIMER 0 // set by library:platform +#define MBED_CONF_PLATFORM_STDIO_BAUD_RATE 9600 // set by library:platform +#define MBED_CONF_PLATFORM_STDIO_BUFFERED_SERIAL 0 // set by library:platform +#define MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES 1 // set by library:platform +#define MBED_CONF_PLATFORM_STDIO_CONVERT_TTY_NEWLINES 1 // set by library:platform +#define MBED_CONF_PLATFORM_STDIO_FLUSH_AT_EXIT 1 // set by library:platform +#define MBED_CONF_PLATFORM_STDIO_MINIMAL_CONSOLE_ONLY 0 // set by library:platform +#define MBED_CONF_PLATFORM_USE_MPU 1 // set by library:platform +#define MBED_CONF_PPP_ENABLED 0 // set by library:ppp +#define MBED_CONF_PPP_ENABLE_TRACE 0 // set by library:ppp +#define MBED_CONF_PPP_IPV4_ENABLED 1 // set by library:ppp +#define MBED_CONF_PPP_IPV6_ENABLED 0 // set by library:ppp +#define MBED_CONF_PPP_MBED_EVENT_QUEUE 0 // set by library:ppp +#define MBED_CONF_PPP_THREAD_STACKSIZE 816 // set by library:ppp +#define MBED_CONF_QUECTEL_BC95_BAUDRATE 9600 // set by library:QUECTEL_BC95 +#define MBED_CONF_QUECTEL_BC95_PROVIDE_DEFAULT 0 // set by library:QUECTEL_BC95 +#define MBED_CONF_QUECTEL_BG96_BAUDRATE 115200 // set by library:QUECTEL_BG96 +#define MBED_CONF_QUECTEL_BG96_PROVIDE_DEFAULT 0 // set by library:QUECTEL_BG96 +#define MBED_CONF_QUECTEL_EC2X_BAUDRATE 115200 // set by library:QUECTEL_EC2X +#define MBED_CONF_QUECTEL_EC2X_PROVIDE_DEFAULT 0 // set by library:QUECTEL_EC2X +#define MBED_CONF_QUECTEL_EC2X_START_TIMEOUT 15000 // set by library:QUECTEL_EC2X +#define MBED_CONF_QUECTEL_M26_BAUDRATE 115200 // set by library:QUECTEL_M26 +#define MBED_CONF_QUECTEL_M26_PROVIDE_DEFAULT 0 // set by library:QUECTEL_M26 +#define MBED_CONF_QUECTEL_UG96_BAUDRATE 115200 // set by library:QUECTEL_UG96 +#define MBED_CONF_QUECTEL_UG96_PROVIDE_DEFAULT 0 // set by library:QUECTEL_UG96 +#define MBED_CONF_RM1000_AT_BAUDRATE 230400 // set by library:RM1000_AT +#define MBED_CONF_RM1000_AT_PROVIDE_DEFAULT 0 // set by library:RM1000_AT +#define MBED_CONF_RTOS_API_PRESENT 1 // set by library:rtos-api +#define MBED_CONF_RTOS_EVFLAGS_NUM 0 // set by library:rtos +#define MBED_CONF_RTOS_IDLE_THREAD_STACK_SIZE 512 // set by library:rtos +#define MBED_CONF_RTOS_IDLE_THREAD_STACK_SIZE_DEBUG_EXTRA 0 // set by library:rtos +#define MBED_CONF_RTOS_IDLE_THREAD_STACK_SIZE_TICKLESS_EXTRA 256 // set by library:rtos +#define MBED_CONF_RTOS_MAIN_THREAD_STACK_SIZE 4096 // set by library:rtos +#define MBED_CONF_RTOS_MSGQUEUE_DATA_SIZE 0 // set by library:rtos +#define MBED_CONF_RTOS_MSGQUEUE_NUM 0 // set by library:rtos +#define MBED_CONF_RTOS_MUTEX_NUM 0 // set by library:rtos +#define MBED_CONF_RTOS_PRESENT 1 // set by library:rtos +#define MBED_CONF_RTOS_SEMAPHORE_NUM 0 // set by library:rtos +#define MBED_CONF_RTOS_THREAD_NUM 0 // set by library:rtos +#define MBED_CONF_RTOS_THREAD_STACK_SIZE 4096 // set by library:rtos +#define MBED_CONF_RTOS_THREAD_USER_STACK_SIZE 0 // set by library:rtos +#define MBED_CONF_RTOS_TIMER_NUM 0 // set by library:rtos +#define MBED_CONF_RTOS_TIMER_THREAD_STACK_SIZE 768 // set by library:rtos +#define MBED_CONF_S2LP_PROVIDE_DEFAULT 0 // set by library:s2lp +#define MBED_CONF_SARA4_PPP_BAUDRATE 115200 // set by library:SARA4_PPP +#define MBED_CONF_SARA4_PPP_PROVIDE_DEFAULT 0 // set by library:SARA4_PPP +#define MBED_CONF_STORAGE_DEFAULT_KV kv // set by library:storage +#define MBED_CONF_STORAGE_FILESYSTEM_BLOCKDEVICE default // set by library:storage_filesystem +#define MBED_CONF_STORAGE_FILESYSTEM_EXTERNAL_BASE_ADDRESS 0 // set by library:storage_filesystem +#define MBED_CONF_STORAGE_FILESYSTEM_EXTERNAL_SIZE 0 // set by library:storage_filesystem +#define MBED_CONF_STORAGE_FILESYSTEM_FILESYSTEM default // set by library:storage_filesystem +#define MBED_CONF_STORAGE_FILESYSTEM_FOLDER_PATH kvstore // set by library:storage_filesystem +#define MBED_CONF_STORAGE_FILESYSTEM_INTERNAL_BASE_ADDRESS 0 // set by library:storage_filesystem +#define MBED_CONF_STORAGE_FILESYSTEM_MOUNT_POINT kv // set by library:storage_filesystem +#define MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_BLOCKDEVICE default // set by library:storage_filesystem_no_rbp +#define MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_EXTERNAL_BASE_ADDRESS 0 // set by library:storage_filesystem_no_rbp +#define MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_EXTERNAL_SIZE 0 // set by library:storage_filesystem_no_rbp +#define MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_FILESYSTEM default // set by library:storage_filesystem_no_rbp +#define MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_FOLDER_PATH kvstore // set by library:storage_filesystem_no_rbp +#define MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_MOUNT_POINT kv // set by library:storage_filesystem_no_rbp +#define MBED_CONF_STORAGE_FILESYSTEM_RBP_INTERNAL_SIZE 0 // set by library:storage_filesystem +#define MBED_CONF_STORAGE_STORAGE_TYPE default // set by library:storage +#define MBED_CONF_STORAGE_TDB_EXTERNAL_BLOCKDEVICE default // set by library:storage_tdb_external +#define MBED_CONF_STORAGE_TDB_EXTERNAL_EXTERNAL_BASE_ADDRESS 0 // set by library:storage_tdb_external +#define MBED_CONF_STORAGE_TDB_EXTERNAL_EXTERNAL_SIZE 0 // set by library:storage_tdb_external +#define MBED_CONF_STORAGE_TDB_EXTERNAL_INTERNAL_BASE_ADDRESS 0 // set by library:storage_tdb_external +#define MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_BLOCKDEVICE default // set by library:storage_tdb_external_no_rbp +#define MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_EXTERNAL_BASE_ADDRESS 0 // set by library:storage_tdb_external_no_rbp +#define MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_EXTERNAL_SIZE 0 // set by library:storage_tdb_external_no_rbp +#define MBED_CONF_STORAGE_TDB_EXTERNAL_RBP_INTERNAL_SIZE 0 // set by library:storage_tdb_external +#define MBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_BASE_ADDRESS 0 // set by library:storage_tdb_internal +#define MBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_SIZE 0 // set by library:storage_tdb_internal +#define MBED_CONF_TARGET_BOOT_STACK_SIZE 0x400 // set by library:rtos[*] +#define MBED_CONF_TARGET_CONSOLE_UART 1 // set by target:Target +#define MBED_CONF_TARGET_DEEP_SLEEP_LATENCY 0 // set by target:Target +#define MBED_CONF_TARGET_DEFAULT_ADC_VREF NAN // set by target:Target +#define MBED_CONF_TARGET_INIT_US_TICKER_AT_BOOT 0 // set by target:Target +#define MBED_CONF_TARGET_MPU_ROM_END 0x0fffffff // set by target:Target +#define MBED_CONF_TARGET_TICKLESS_FROM_US_TICKER 0 // set by target:Target +#define MBED_CONF_TARGET_XIP_ENABLE 0 // set by target:Target +#define MBED_CONF_TELIT_HE910_BAUDRATE 115200 // set by library:TELIT_HE910 +#define MBED_CONF_TELIT_HE910_PROVIDE_DEFAULT 0 // set by library:TELIT_HE910 +#define MBED_CONF_TELIT_ME310_BAUDRATE 115200 // set by library:TELIT_ME310 +#define MBED_CONF_TELIT_ME310_PROVIDE_DEFAULT 0 // set by library:TELIT_ME310 +#define MBED_CONF_TELIT_ME910_BAUDRATE 115200 // set by library:TELIT_ME910 +#define MBED_CONF_TELIT_ME910_PROVIDE_DEFAULT 0 // set by library:TELIT_ME910 +#define MBED_CONF_UBLOX_AT_BAUDRATE 115200 // set by library:UBLOX_AT +#define MBED_CONF_UBLOX_AT_PROVIDE_DEFAULT 0 // set by library:UBLOX_AT +#define MBED_CONF_UBLOX_N2XX_BAUDRATE 9600 // set by library:UBLOX_N2XX +#define MBED_CONF_UBLOX_N2XX_PROVIDE_DEFAULT 0 // set by library:UBLOX_N2XX +#define MBED_CONF_UBLOX_PPP_BAUDRATE 115200 // set by library:UBLOX_PPP +#define MBED_CONF_UBLOX_PPP_PROVIDE_DEFAULT 0 // set by library:UBLOX_PPP +#define MBED_CRC_TABLE_SIZE 16 // set by library:drivers +#define MBED_LFS2_BLOCK_CYCLES 1024 // set by library:littlefs2 +#define MBED_LFS2_BLOCK_SIZE 512 // set by library:littlefs2 +#define MBED_LFS2_CACHE_SIZE 64 // set by library:littlefs2 +#define MBED_LFS2_ENABLE_INFO 0 // set by library:littlefs2 +#define MBED_LFS2_INTRINSICS 1 // set by library:littlefs2 +#define MBED_LFS2_LOOKAHEAD_SIZE 64 // set by library:littlefs2 +#define MBED_LFS_BLOCK_SIZE 512 // set by library:littlefs +#define MBED_LFS_ENABLE_INFO 0 // set by library:littlefs +#define MBED_LFS_INTRINSICS 1 // set by library:littlefs +#define MBED_LFS_LOOKAHEAD 512 // set by library:littlefs +#define MBED_LFS_PROG_SIZE 64 // set by library:littlefs +#define MBED_LFS_READ_SIZE 64 // set by library:littlefs +#define MBED_STACK_DUMP_ENABLED 0 // set by library:platform +#define MEM_ALLOC malloc // set by library:mbed-trace +#define MEM_FREE free // set by library:mbed-trace +#define PPP_DEBUG 0 // set by library:ppp +#define SEC_CCM_CFG 1 // set by library:cordio +#define SMP_DB_MAX_DEVICES 3 // set by library:cordio +// Macros +#define MBEDTLS_CIPHER_MODE_CTR // defined by library:SecureStore +#define MBEDTLS_CMAC_C // defined by library:SecureStore +#define NSAPI_PPP_AVAILABLE (MBED_CONF_PPP_ENABLED || MBED_CONF_LWIP_PPP_ENABLED) // defined by library:ppp +#define NS_USE_EXTERNAL_MBED_TLS // defined by library:nanostack +#define UNITY_INCLUDE_CONFIG_H // defined by library:utest +#define WSF_MS_PER_TICK 1 // defined by library:cordio +#define _RTE_ // defined by library:rtos + +#endif \ No newline at end of file diff --git a/variants/rak11720/variant.h b/variants/rak11720/variant.h index 1fb30627d..4b5c44dd9 100644 --- a/variants/rak11720/variant.h +++ b/variants/rak11720/variant.h @@ -130,21 +130,12 @@ extern const uint32_t g_ADigitalPinMap[]; #define PIN_A0 P13 #define PIN_A1 P33 -static const uint8_t A0 = PIN_A0; -static const uint8_t A1 = PIN_A1; - #define PIN_A3 P5 // channel1 #define PIN_A4 P31 // channel2 #define PIN_A5 P32 // channel4 #define PIN_A6 P36 #define PIN_A7 P7 // channel6 -static const uint8_t A3 = PIN_A3; -static const uint8_t A4 = PIN_A4; -static const uint8_t A5 = PIN_A5; -static const uint8_t A6 = PIN_A6; -static const uint8_t A7 = PIN_A7; - #define ADC_RESOLUTION 14 // Other pins #define PIN_AREF (0) @@ -164,6 +155,7 @@ static const uint8_t AREF = PIN_AREF; * SPI Interfaces */ #define SPI_INTERFACES_COUNT 1 +#define VARIANT_SPI_INTFCS SPI_INTERFACES_COUNT #define PIN_SPI_CS WB_SPI_CS #define PIN_SPI_MISO WB_SPI_MISO @@ -179,6 +171,7 @@ static const uint8_t SCK = PIN_SPI_SCK; * Wire Interfaces */ #define WIRE_INTERFACES_COUNT 1 +#define VARIANT_WIRE_INTFCS WIRE_INTERFACES_COUNT #define PIN_WIRE_SDA WB_I2C1_SDA #define PIN_WIRE_SCL WB_I2C1_SCL