{

switch (key) {

case OPT_CONFIG_CHECK:

configCheck = true;

break;

case 'p':

if (sscanf(arg, "%d", &TCPPort) < 1) {

return ARGP_ERR_UNKNOWN;

} else {

checkConfigPort = false;

printf("Using config file %d\n", TCPPort);

}

break;

case 'c':

configPath = arg;

break;

case 's':

portduino_config.force_simradio = true;

break;

case 'h':

optionMac = arg;

break;

case 'v':

verboseEnabled = true;

break;

case 'y':

yamlOnly = true;

break;

#ifdef _WIN32

case OPT_SERVICE:

windowsServiceInit();

break;

#endif

case ARGP_KEY_ARG:

return 0;

default:

return ARGP_ERR_UNKNOWN;

}

return 0;

{

if (portduino_config.display_spi_dev == "" || portduino_config.displayWidth == 0 || portduino_config.displayHeight == 0) {

return;

}

switch (portduino_config.displayPanel) {

case no_screen:

case x11:

case fb:

case hub75:

return; // not driven over spidev

default:

break;

}

const long required = (long)portduino_config.displayWidth * portduino_config.displayHeight / 2 * 3;

std::ifstream bufsizFile("/sys/module/spidev/parameters/bufsiz");

long bufsiz = 0;

if (!bufsizFile.is_open() || !(bufsizFile >> bufsiz)) {

// spidev may be built into the kernel without exposing the parameter; nothing to check.

return;

}

if (bufsiz < required) {

std::cerr << "SPI display " << portduino_config.displayWidth << "x" << portduino_config.displayHeight

<< " needs a spidev buffer of at least " << required << " bytes, but "

<< "/sys/module/spidev/parameters/bufsiz is " << bufsiz << "." << std::endl;

std::cerr << "Add 'spidev.bufsiz=" << required << "' to your kernel command line "

<< "(/boot/firmware/cmdline.txt on Raspberry Pi OS) and reboot." << std::endl;

std::cerr << "Or echo that value into /etc/modprobe.d/spidev.conf and reload the spidev module" << std::endl;

exit(EXIT_FAILURE);

}

{

static struct argp_option options[] = {

{"port", 'p', "PORT", 0, "The TCP port to use."},

{"config", 'c', "CONFIG_PATH", 0, "Full path of the .yaml config file to use."},

{"hwid", 'h', "HWID", 0, "The mac address to assign to this virtual machine"},

{"sim", 's', 0, 0, "Run in Simulated radio mode"},

{"verbose", 'v', 0, 0, "Set log level to full debug"},

{"output-yaml", 'y', 0, 0, "Output config yaml and exit"},

{"check", OPT_CONFIG_CHECK, 0, 0, "Check the configuration for problems, print a report, and exit"},

#ifdef _WIN32

{"service", OPT_SERVICE, 0, 0, "Run as a Windows service"},

#endif

{0}};

static void *childArguments;

static char doc[] = "Meshtastic native build.";

static char args_doc[] = "...";

static struct argp argp = {options, parse_opt, args_doc, doc, 0, 0, 0};

const struct argp_child child = {&argp, OPTION_ARG_OPTIONAL, 0, 0};

portduinoAddArguments(child, childArguments);

{

// We should store this value, and short-circuit all this if it's already been set.

if (optionMac != nullptr && strlen(optionMac) > 0) {

if (strlen(optionMac) >= 12) {

MAC_from_string(optionMac, dmac);

} else {

uint32_t hwId = {0};

sscanf(optionMac, "%u", &hwId);

dmac[0] = 0x80;

dmac[1] = 0;

dmac[2] = hwId >> 24;

dmac[3] = hwId >> 16;

dmac[4] = hwId >> 8;

dmac[5] = hwId & 0xff;

}

} else if (portduino_config.mac_address.length() > 11) {

MAC_from_string(portduino_config.mac_address, dmac);

return;

} else {

#ifdef PORTDUINO_LINUX_HARDWARE

struct hci_dev_info di = {0};

di.dev_id = 0;

bdaddr_t bdaddr;

int btsock;

btsock = socket(AF_BLUETOOTH, SOCK_RAW, 1);

if (btsock < 0) { // If anything fails, just return with the default value

return;

}

if (ioctl(btsock, HCIGETDEVINFO, (void *)&di)) {

return;

}

dmac[0] = di.bdaddr.b[5];

dmac[1] = di.bdaddr.b[4];

dmac[2] = di.bdaddr.b[3];

dmac[3] = di.bdaddr.b[2];

dmac[4] = di.bdaddr.b[1];

dmac[5] = di.bdaddr.b[0];

#elif defined(__APPLE__)

// No BlueZ on macOS, but we can fall back to the host's primary

// network interface MAC. `en0` is Wi-Fi on every shipping Mac

// (Ethernet, when present, is en1 or higher), which gives the user

// the same kind of stable, host-derived identifier that the BlueZ

// path provides on Linux. If en0 isn't found or has no MAC, dmac is

// left untouched and the caller's "Blank MAC Address not allowed!"

// check will still fire - preserving existing behavior for users

// who deliberately rely on --hwid or YAML override.

struct ifaddrs *ifap = nullptr;

if (getifaddrs(&ifap) == 0) {

for (struct ifaddrs *p = ifap; p != nullptr; p = p->ifa_next) {

if (p->ifa_addr == nullptr || p->ifa_addr->sa_family != AF_LINK) {

continue;

}

if (strcmp(p->ifa_name, "en0") != 0) {

continue;

}

auto *sdl = reinterpret_cast<struct sockaddr_dl *>(p->ifa_addr);

if (sdl->sdl_alen == 6) {

memcpy(dmac, LLADDR(sdl), 6);

break;

}

}

freeifaddrs(ifap);

}

#elif defined(_WIN32)

// No BlueZ on Windows; the host's primary adapter MAC is the equivalent

// stable identifier. On failure dmac is untouched and the blank-MAC check fires.

portduinoWindowsPrimaryMac(dmac);

#else

// No platform-specific MAC source; leave dmac at its default. Caller

// can override via the --hwid CLI flag or the YAML config.

(void)dmac;

#endif

}

{

if (portduino_config.has_device_id) {

memcpy(deviceId, portduino_config.device_id, sizeof(portduino_config.device_id));

return true;

}

// Config-supplied id stays preferred: host NIC/BT MACs can be unstable (docker, multi-NIC).

return getMacAddrDeviceId(deviceId);

{

// Convert spaces -> dashes, lowercase

std::transform(name.begin(), name.end(), name.begin(), [](unsigned char c) {

if (c == ' ') {

return '-';

}

return (char)std::tolower(c);

});

return name;

{

int max_GPIO = 0;

std::string gpioChipName = "gpiochip";

portduino_config.displayPanel = no_screen;

// Force stdout to be line buffered

setvbuf(stdout, stdoutBuffer, _IOLBF, sizeof(stdoutBuffer));

// We do this super early so that we can log from the rest of the init code

concurrency::hasBeenSetup = true;

consoleInit();

#ifdef ARCH_PORTDUINO_WASM

// Browser build: no YAML/filesystem config. Apply a hardcoded SX1262/CH341

// setup and create the WebUSB-backed Ch341Hal, then skip the Linux config path.

{

extern void wasm_config_apply();

wasm_config_apply();

ch341Hal = std::make_unique<Ch341Hal>(0, portduino_config.lora_usb_serial_num, portduino_config.lora_usb_vid,

portduino_config.lora_usb_pid);

}

return;

#endif

if (portduino_config.force_simradio == true) {

portduino_config.lora_module = use_simradio;

} else if (configPath != nullptr) {

if (loadConfig(configPath)) {

if (!yamlOnly && !configCheck)

std::cout << "Using " << configPath << " as config file" << std::endl;

} else if (!configCheck) {

// In check mode the path is already in attemptedConfigFiles, so fall through

// to runConfigCheck() and let it report the parse error with a file and line.

std::cout << "Unable to use " << configPath << " as config file" << std::endl;

exit(EXIT_FAILURE);

}

} else if (access("config.yaml", R_OK) == 0) {

if (loadConfig("config.yaml")) {

if (!yamlOnly && !configCheck)

std::cout << "Using local config.yaml as config file" << std::endl;

} else if (!configCheck) {

std::cout << "Unable to use local config.yaml as config file" << std::endl;

exit(EXIT_FAILURE);

}

} else if (access("/etc/meshtasticd/config.yaml", R_OK) == 0) {

if (loadConfig("/etc/meshtasticd/config.yaml")) {

if (!yamlOnly && !configCheck)

std::cout << "Using /etc/meshtasticd/config.yaml as config file" << std::endl;

} else if (!configCheck) {

std::cout << "Unable to use /etc/meshtasticd/config.yaml as config file" << std::endl;

exit(EXIT_FAILURE);

}

} else {

if (!yamlOnly && !configCheck)

std::cout << "No 'config.yaml' found..." << std::endl;

portduino_config.lora_module = use_simradio;

}

if (portduino_config.config_directory != "") {

// The throwing form of directory_iterator turns an unreadable ConfigDirectory into an

// uncaught filesystem_error and a SIGABRT, so take the error_code overload instead.

std::error_code dirError;

std::filesystem::directory_iterator entries{portduino_config.config_directory, dirError};

if (dirError) {

// Half a configuration is worse than none. --check continues so the report can say

// so with the rest of the findings.

if (!configCheck) {

std::cout << "Unable to read ConfigDirectory " << portduino_config.config_directory << ": " << dirError.message()

<< std::endl;

exit(EXIT_FAILURE);

}

}

for (const std::filesystem::directory_entry &entry : entries) {

if (ends_with(entry.path().string(), ".yaml")) {

if (!configCheck)

std::cout << "Also using " << entry << " as additional config file" << std::endl;

// .string() rather than .c_str(): path::value_type is wchar_t on

// Windows, and loadConfig() takes a const char *.

loadConfig(entry.path().string().c_str());

}

}

}

#ifndef ARCH_PORTDUINO_WASM

// --check wins over --output-yaml: asking for validation and getting a config dump

// with no report at all would be the more surprising of the two outcomes.

if (configCheck)

exit(runConfigCheck(attemptedConfigFiles));

if (yamlOnly) {

std::cout << portduino_config.emit_yaml() << std::endl;

exit(EXIT_SUCCESS);

}

#endif

if (portduino_config.force_simradio) {

std::cout << "Running in simulated mode." << std::endl;

portduino_config.MaxNodes = 200; // Default to 200 nodes

// Set the random seed equal to TCPPort to have a different seed per instance

uint32_t seed = TCPPort;

HardwareRNG::seed(seed);

randomSeed(seed);

return;

}

// If LoRa `Module: auto` (default in config.yaml),

// attempt to auto config based on Product Strings

if (portduino_config.lora_module == use_autoconf) {

bool found_hat = false;

bool found_rak_eeprom = false;

bool found_ch341 = false;

char hat_vendor[96] = {0};

char autoconf_product[96] = {0};

// Try CH341

try {

std::cout << "autoconf: Looking for CH341 device..." << std::endl;

auto probe = std::unique_ptr<Ch341Hal>(new Ch341Hal(0, portduino_config.lora_usb_serial_num,

portduino_config.lora_usb_vid, portduino_config.lora_usb_pid));

probe->getProductString(autoconf_product, 95);

std::cout << "autoconf: Found CH341 device " << autoconf_product << std::endl;

found_ch341 = true;

} catch (...) {

std::cout << "autoconf: Could not locate CH341 device" << std::endl;

}

// Try Pi HAT+

if (strlen(autoconf_product) < 6) {

std::cout << "autoconf: Looking for Pi HAT+..." << std::endl;

if (access("/proc/device-tree/hat/vendor", R_OK) == 0) {

std::ifstream hatVendorFile("/proc/device-tree/hat/vendor");

if (hatVendorFile.is_open()) {

hatVendorFile.read(hat_vendor, 95);

hatVendorFile.close();

}

}

if (access("/proc/device-tree/hat/product", R_OK) == 0) {

std::ifstream hatProductFile("/proc/device-tree/hat/product");

if (hatProductFile.is_open()) {

hatProductFile.read(autoconf_product, 95);

hatProductFile.close();

}

std::cout << "autoconf: Found Pi HAT+ " << hat_vendor << " " << autoconf_product << " at /proc/device-tree/hat"

<< std::endl;

// check for custom data fields

int i = 0;

while (access(("/proc/device-tree/hat/custom_" + std::to_string(i)).c_str(), R_OK) == 0) {

std::ifstream customFieldFile(("/proc/device-tree/hat/custom_" + std::to_string(i)).c_str());

if (customFieldFile.is_open()) {

std::string customFieldName;

std::string customFieldValue;

getline(customFieldFile, customFieldName, ' ');

getline(customFieldFile, customFieldValue, ' ');

customFieldFile.close();

printf("autoconf: Found hat+ custom field %s: %s\n", customFieldName.c_str(), customFieldValue.c_str());

portduino_config.hat_plus_custom_fields[customFieldName] = customFieldValue;

}

i++;

}

// potential TODO: Validate that this is a real UUID

std::ifstream hatUUID("/proc/device-tree/hat/uuid");

char uuid[38] = {0};

if (hatUUID.is_open()) {

hatUUID.read(uuid, 37);

hatUUID.close();

std::cout << "autoconf: UUID " << uuid << std::endl;

SHA256 uuid_hash;

uint8_t uuid_hash_bytes[32] = {0};

uuid_hash.reset();

uuid_hash.update(uuid, 37);

uuid_hash.finalize(uuid_hash_bytes, 32);

for (int j = 0; j < 16; j++) {

portduino_config.device_id[j] = uuid_hash_bytes[j];

}

portduino_config.has_device_id = true;

uint8_t dmac[6] = {0};

dmac[0] = (uuid_hash_bytes[17] << 4) | 2;

dmac[1] = uuid_hash_bytes[18];

dmac[2] = uuid_hash_bytes[19];

dmac[3] = uuid_hash_bytes[20];

dmac[4] = uuid_hash_bytes[21];

dmac[5] = uuid_hash_bytes[22];

char macBuf[13] = {0};

snprintf(macBuf, sizeof(macBuf), "%02X%02X%02X%02X%02X%02X", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4],

dmac[5]);

portduino_config.mac_address = macBuf;

found_hat = true;

}

} else {

std::cout << "autoconf: Could not locate Pi HAT+ at /proc/device-tree/hat" << std::endl;

}

}

// attempt to load autoconf data from an EEPROM on 0x50

// RAK6421-13300-S1:aabbcc123456:5ba85807d92138b7519cfb60460573af:3061e8d8

// <model string>:mac address :<16 random unique bytes in hexidecimal> : crc32

// crc32 is calculated on the eeprom string up to but not including the final colon

if (strlen(autoconf_product) < 6 && portduino_config.i2cdev != "") {

try {

char *mac_start = nullptr;

char *devID_start = nullptr;

char *crc32_start = nullptr;

Wire.begin();

Wire.beginTransmission(0x50);

Wire.write(0x0);

Wire.write(0x0);

Wire.endTransmission();

Wire.requestFrom((uint8_t)0x50, (uint8_t)75);

uint8_t i = 0;

delay(100);

std::string autoconf_raw;

while (Wire.available() && i < sizeof(autoconf_product)) {

autoconf_product[i] = Wire.read();

if (autoconf_product[i] == 0xff) {

autoconf_product[i] = 0x0;

break;

}

autoconf_raw += autoconf_product[i];

if (autoconf_product[i] == ':') {

autoconf_product[i] = 0x0;

if (mac_start == nullptr) {

mac_start = autoconf_product + i + 1;

} else if (devID_start == nullptr) {

devID_start = autoconf_product + i + 1;

} else if (crc32_start == nullptr) {

crc32_start = autoconf_product + i + 1;

}

}

i++;

}

if (crc32_start != nullptr && strlen(crc32_start) == 8) {

std::string crc32_str(crc32_start);

uint32_t crc32_value = 0;

// convert crc32 ascii to raw uint32

for (int j = 0; j < 4; j++) {

crc32_value += std::stoi(crc32_str.substr(j * 2, 2), nullptr, 16) << (3 - j) * 8;

}

std::cout << "autoconf: Found eeprom crc " << crc32_start << std::endl;

// set the autoconf string to blank and short circuit

if (crc32_value != crc32Buffer(autoconf_raw.c_str(), i - 9)) {

std::cout << "autoconf: crc32 mismatch, dropping " << std::endl;

autoconf_product[0] = 0x0;

} else {

std::cout << "autoconf: Found eeprom data " << autoconf_raw << std::endl;

found_rak_eeprom = true;

if (mac_start != nullptr) {

std::cout << "autoconf: Found mac data " << mac_start << std::endl;

if (strlen(mac_start) == 12)

portduino_config.mac_address = std::string(mac_start);

}

if (devID_start != nullptr) {

std::cout << "autoconf: Found deviceid data " << devID_start << std::endl;

if (strlen(devID_start) == 32) {

std::string devID_str(devID_start);

for (int j = 0; j < 16; j++) {

portduino_config.device_id[j] = std::stoi(devID_str.substr(j * 2, 2), nullptr, 16);

}

portduino_config.has_device_id = true;

}

}

}

} else {

std::cout << "autoconf: crc32 missing " << std::endl;

autoconf_product[0] = 0x0;

}

} catch (...) {

std::cout << "autoconf: Could not locate EEPROM" << std::endl;

}

}

// Load the config file based on the product string

if (strlen(autoconf_product) > 0) {

// From configProducts map in PortduinoGlue.h

std::string product_config = "";

if (configProducts.find(autoconf_product) != configProducts.end()) {

product_config = configProducts.at(autoconf_product);

} else {

if (found_hat) {

product_config =

cleanupNameForAutoconf("lora-hat-" + std::string(hat_vendor) + "-" + autoconf_product + ".yaml");

if (strncmp(hat_vendor, "RAK", strlen("RAK")) == 0 &&

strncmp(autoconf_product, "6421 Pi Hat", strlen("6421 Pi Hat")) == 0) {

std::cout << "autoconf: Setting hardwareModel to RAK6421" << std::endl;

portduino_status.hardwareModel = meshtastic_HardwareModel_RAK6421;

}

} else if (found_ch341) {

product_config = cleanupNameForAutoconf("lora-usb-" + std::string(autoconf_product) + ".yaml");

// look for more data after the null terminator

size_t len = strlen(autoconf_product);

if (len < 74) {

memcpy(portduino_config.device_id, autoconf_product + len + 1, 16);

if (!memfll(portduino_config.device_id, '\0', 16) && !memfll(portduino_config.device_id, 0xff, 16)) {

portduino_config.has_device_id = true;

if (strncmp(autoconf_product, "MESHSTICK 1262", strlen("MESHSTICK 1262")) == 0) {

std::cout << "autoconf: Setting hardwareModel to Meshstick 1262" << std::endl;

portduino_status.hardwareModel = meshtastic_HardwareModel_MESHSTICK_1262;

}

}

}

}

// Don't try to automatically find config for a device with RAK eeprom.

if (found_rak_eeprom) {

std::cerr << "autoconf: Found unknown RAK product " << autoconf_product << std::endl;

exit(EXIT_FAILURE);

}

if (access((portduino_config.available_directory + product_config).c_str(), R_OK) != 0) {

std::cerr << "autoconf: Unable to find config for " << autoconf_product << "(tried " << product_config << ")"

<< std::endl;

exit(EXIT_FAILURE);

}

}

if (loadConfig((portduino_config.available_directory + product_config).c_str())) {

std::cout << "autoconf: Using " << product_config << " as config file for " << autoconf_product << std::endl;

} else {

std::cerr << "autoconf: Unable to use " << product_config << " as config file for " << autoconf_product

<< std::endl;

exit(EXIT_FAILURE);

}

} else {

std::cerr << "autoconf: Could not locate any devices" << std::endl;

exit(EXIT_FAILURE);

}

}

// if we have s SPI display, check /sys/module/spidev/parameters/bufsiz

// It needs to be at least width * height / 2 * 3

// fail with a more useful error message.

checkSpidevBufsiz();

// if we're using a usermode driver, we need to initialize it here, to get a serial number back for mac address

uint8_t dmac[6] = {0};

if (portduino_config.lora_spi_dev == "ch341") {

try {

ch341Hal = std::make_unique<Ch341Hal>(0, portduino_config.lora_usb_serial_num, portduino_config.lora_usb_vid,

portduino_config.lora_usb_pid);

} catch (std::exception &e) {

std::cerr << e.what() << std::endl;

std::cerr << "Could not initialize CH341 device!" << std::endl;

exit(EXIT_FAILURE);

}

char serial[9] = {0};

// Pass the full buffer size (9 = 8 chars + null) to getSerialString,

// not 8. The function treats `len` as buffer size and reserves one

// slot for the null terminator, so passing 8 produced a 7-char serial

// and broke the `strlen(serial) == 8` check below - masked on Linux

// by the BlueZ HCI MAC fallback in getMacAddr(), but on macOS (where

// the BlueZ path is __linux__-guarded) it left mac_address empty and

// meshtasticd refused to start.

ch341Hal->getSerialString(serial, sizeof(serial));

std::cout << "CH341 Serial " << serial << std::endl;

char product_string[96] = {0};

ch341Hal->getProductString(product_string, sizeof(product_string));

std::cout << "CH341 Product " << product_string << std::endl;

if (strlen(serial) == 8 && portduino_config.mac_address.length() < 12) {

std::cout << "Deriving MAC address from Serial and Product String" << std::endl;

uint8_t hash[104] = {0};

memcpy(hash, serial, 8);

memcpy(hash + 8, product_string, strlen(product_string));

crypto->hash(hash, 8 + strlen(product_string));

dmac[0] = (hash[0] << 4) | 2;

dmac[1] = hash[1];

dmac[2] = hash[2];

dmac[3] = hash[3];

dmac[4] = hash[4];

dmac[5] = hash[5];

char macBuf[13] = {0};

sprintf(macBuf, "%02X%02X%02X%02X%02X%02X", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4], dmac[5]);

portduino_config.mac_address = macBuf;

}

}

getMacAddr(dmac);

#ifndef PIO_UNIT_TESTING

if (dmac[0] == 0 && dmac[1] == 0 && dmac[2] == 0 && dmac[3] == 0 && dmac[4] == 0 && dmac[5] == 0) {

std::cout << "*** Blank MAC Address not allowed!" << std::endl;

std::cout << "Please set a MAC Address in config.yaml using either MACAddress or MACAddressSource." << std::endl;

exit(EXIT_FAILURE);

}

#endif

printf("MAC ADDRESS: %02X:%02X:%02X:%02X:%02X:%02X\n", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4], dmac[5]);

// Rather important to set this, if not running simulated.

uint32_t seed = static_cast<uint32_t>(time(NULL));

HardwareRNG::seed(seed);

randomSeed(seed);

std::string defaultGpioChipName = gpioChipName + std::to_string(portduino_config.lora_default_gpiochip);

std::set<int> used_pins;

for (const auto *i : portduino_config.all_pins) {

if (i->enabled && i->pin > max_GPIO) {

max_GPIO = i->pin;

}

}

for (auto i : portduino_config.extra_pins) {

if (i.enabled && i.pin > max_GPIO) {

max_GPIO = i.pin;

}

}

gpioInit(max_GPIO + 1); // Done here so we can inform Portduino how many GPIOs we need.

// Need to bind all the configured GPIO pins so they're not simulated

// TODO: If one of these fails, we should log and terminate

for (const auto *i : portduino_config.all_pins) {

// In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora

// Those GPIO are handled in our usermode driver instead.

if (i->config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {

continue;

}

if (i->enabled) {

if (used_pins.find(i->pin) != used_pins.end()) {

printf("Pin %d is in use for multiple purposes\n", i->pin);

} else {

if (initGPIOPin(i->pin, gpioChipName + std::to_string(i->gpiochip), i->line) != ERRNO_OK) {

printf("Error setting pin number %d. It may not exist, or may already be in use.\n", i->line);

exit(EXIT_FAILURE);

}

used_pins.insert(i->pin);

}

}

}

printf("Initializing extra pins\n");

for (auto i : portduino_config.extra_pins) {

// In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora

// Those GPIO are handled in our usermode driver instead.

if (i.config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {

continue;

}

if (i.enabled) {

if (used_pins.find(i.pin) != used_pins.end()) {

printf("Pin %d is in use for multiple purposes\n", i.pin);

} else {

if (initGPIOPin(i.pin, gpioChipName + std::to_string(i.gpiochip), i.line) != ERRNO_OK) {

printf("Error setting pin number %d. It may not exist, or may already be in use.\n", i.line);

exit(EXIT_FAILURE);

}

used_pins.insert(i.pin);

}

}

}

// In one test, this dance seemed necessary to trigger the pin to detect properly.

if (portduino_config.lora_pa_detect_pin.enabled) {

pinMode(portduino_config.lora_pa_detect_pin.pin, INPUT_PULLDOWN);

sleep(1);

if (digitalRead(portduino_config.lora_pa_detect_pin.pin) == LOW) {

std::cout << "Pin " << portduino_config.lora_pa_detect_pin.pin << " PULLDOWN is LOW" << std::endl;

}

pinMode(portduino_config.lora_pa_detect_pin.pin, INPUT_PULLUP);

sleep(1);

if (digitalRead(portduino_config.lora_pa_detect_pin.pin) == HIGH) {

std::cout << "Pin " << portduino_config.lora_pa_detect_pin.pin << " PULLUP is HIGH, dropping PA curve" << std::endl;

portduino_config.num_pa_points = 1;

portduino_config.tx_gain_lora[0] = 0;

} else {

std::cout << "Pin " << portduino_config.lora_pa_detect_pin.pin << " PULLUP is LOW, using PA curve" << std::endl;

}

// disable bias once finished

pinMode(portduino_config.lora_pa_detect_pin.pin, INPUT);

} else if (portduino_config.hat_plus_custom_fields.find("io_slot1") != portduino_config.hat_plus_custom_fields.end()) {

printf("Hat+ io_slot1 is %s\n", portduino_config.hat_plus_custom_fields["io_slot1"].c_str());

if (portduino_config.hat_plus_custom_fields["io_slot1"] != "RAK13302") {

std::cout << "Hat+ io_slot1 is not RAK13302, skipping PA curve" << std::endl;

portduino_config.num_pa_points = 1;

portduino_config.tx_gain_lora[0] = 0;

}

}

for (auto i : portduino_config.extra_pins) {

// In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora

// Those GPIO are handled in our usermode driver instead.

if (i.config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {

continue;

}

if (i.enabled && i.default_high) {

pinMode(i.pin, OUTPUT);

digitalWrite(i.pin, HIGH);

}

}

// Only initialize the radio pins when dealing with real, kernel controlled SPI hardware

if (portduino_config.lora_spi_dev != "" && portduino_config.lora_spi_dev != "ch341") {

SPI.begin(portduino_config.lora_spi_dev.c_str());

}

if (portduino_config.traceFilename != "") {

try {

traceFile.open(portduino_config.traceFilename, std::ios::out | std::ios::app);

} catch (std::ofstream::failure &e) {

std::cout << "*** traceFile Exception " << e.what() << std::endl;

exit(EXIT_FAILURE);

}

if (!traceFile.is_open()) {

std::cout << "*** traceFile open failure" << std::endl;

exit(EXIT_FAILURE);

}

} else if (portduino_config.JSONFilename != "") {

try {

if (portduino_config.JSONFileRotate == 0) {

JSONFile.open(portduino_config.JSONFilename, std::ios::out | std::ios::app);

}

} catch (std::ofstream::failure &e) {

std::cout << "*** JSONFile Exception " << e.what() << std::endl;

exit(EXIT_FAILURE);

}

if (!JSONFile.is_open()) {

std::cout << "*** JSONFile open failure" << std::endl;

exit(EXIT_FAILURE);

}

}

if (verboseEnabled && portduino_config.logoutputlevel != level_trace) {

portduino_config.logoutputlevel = level_debug;

}

if (portduino_config.lora_spi_dev != "") {

portduinoSetOptions({.realHardware = true});

}

return;

{

#ifdef PORTDUINO_LINUX_HARDWARE

std::string gpio_name = "GPIO" + std::to_string(pinNum);

std::cout << "Initializing " << gpio_name << " on chip " << gpioChipName << std::endl;

try {

auto csPin = std::make_unique<LinuxGPIOPin>(pinNum, gpioChipName.c_str(), line, gpio_name.c_str());

csPin->setSilent();

gpioBind(csPin.get());

csPin.release(); // owned by the gpio table from here on

return ERRNO_OK;

} catch (...) {

const std::type_info *t = abi::__cxa_current_exception_type();

std::cout << "Warning, cannot claim pin " << gpio_name << (t ? t->name() : "null") << std::endl;

return ERRNO_DISABLED;

}

#else

return ERRNO_OK;

#endif

{

(void)configPath;

return false;

{

// Recorded even when the load below fails: an unparseable config.d entry is skipped and its

// return value discarded by the caller, so --check needs to know it was attempted.

attemptedConfigFiles.push_back(configPath);

YAML::Node yamlConfig;

try {

yamlConfig = YAML::LoadFile(configPath);

if (yamlConfig["Logging"]) {

if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "trace") {

portduino_config.logoutputlevel = level_trace;

} else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "debug") {

portduino_config.logoutputlevel = level_debug;

} else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "info") {

portduino_config.logoutputlevel = level_info;

} else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "warn") {

portduino_config.logoutputlevel = level_warn;

} else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "error") {

portduino_config.logoutputlevel = level_error;

}

portduino_config.traceFilename = yamlConfig["Logging"]["TraceFile"].as<std::string>("");

portduino_config.JSONFilename = yamlConfig["Logging"]["JSONFile"].as<std::string>("");

portduino_config.JSONFileRotate = yamlConfig["Logging"]["JSONFileRotate"].as<int>(0);

portduino_config.JSONFilter = (_meshtastic_PortNum)yamlConfig["Logging"]["JSONFilter"].as<int>(0);

if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "textmessage")

portduino_config.JSONFilter = meshtastic_PortNum_TEXT_MESSAGE_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "telemetry")

portduino_config.JSONFilter = meshtastic_PortNum_TELEMETRY_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "nodeinfo")

portduino_config.JSONFilter = meshtastic_PortNum_NODEINFO_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "position")

portduino_config.JSONFilter = meshtastic_PortNum_POSITION_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "waypoint")

portduino_config.JSONFilter = meshtastic_PortNum_WAYPOINT_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "neighborinfo")

portduino_config.JSONFilter = meshtastic_PortNum_NEIGHBORINFO_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "traceroute")

portduino_config.JSONFilter = meshtastic_PortNum_TRACEROUTE_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "detection")

portduino_config.JSONFilter = meshtastic_PortNum_DETECTION_SENSOR_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "paxcounter")

portduino_config.JSONFilter = meshtastic_PortNum_PAXCOUNTER_APP;

else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "remotehardware")

portduino_config.JSONFilter = meshtastic_PortNum_REMOTE_HARDWARE_APP;

if (yamlConfig["Logging"]["AsciiLogs"]) {

// Default is !isatty(1) but can be set explicitly in config.yaml

portduino_config.ascii_logs = yamlConfig["Logging"]["AsciiLogs"].as<bool>();

portduino_config.ascii_logs_explicit = true;

}

}

if (yamlConfig["Lora"]) {

if (yamlConfig["Lora"]["Module"]) {

const std::string moduleName = yamlConfig["Lora"]["Module"].as<std::string>("");

bool found = false;

for (const auto &loraModule : portduino_config.loraModules) {

if (moduleName == loraModule.second) {

portduino_config.lora_module = loraModule.first;

found = true;

break;

}

}

if (!found && !configCheck) {

// --check names the valid modules in its report; exiting here would

// replace that with a bare one-liner.

std::cerr << "Unknown Lora.Module: " << moduleName << std::endl;

exit(EXIT_FAILURE);

}

}

if (yamlConfig["Lora"]["SX126X_MAX_POWER"])

portduino_config.sx126x_max_power = yamlConfig["Lora"]["SX126X_MAX_POWER"].as<int>(22);

if (yamlConfig["Lora"]["SX128X_MAX_POWER"])

portduino_config.sx128x_max_power = yamlConfig["Lora"]["SX128X_MAX_POWER"].as<int>(13);

if (yamlConfig["Lora"]["LR1110_MAX_POWER"])

portduino_config.lr1110_max_power = yamlConfig["Lora"]["LR1110_MAX_POWER"].as<int>(22);

if (yamlConfig["Lora"]["LR1120_MAX_POWER"])

portduino_config.lr1120_max_power = yamlConfig["Lora"]["LR1120_MAX_POWER"].as<int>(13);

if (yamlConfig["Lora"]["LR2021_MAX_POWER"])

portduino_config.lr2021_max_power = yamlConfig["Lora"]["LR2021_MAX_POWER"].as<int>(22);

if (yamlConfig["Lora"]["LR2021_MAX_POWER_HF"])

portduino_config.lr2021_max_power_hf = yamlConfig["Lora"]["LR2021_MAX_POWER_HF"].as<int>(12);

if (yamlConfig["Lora"]["RF95_MAX_POWER"])

portduino_config.rf95_max_power = yamlConfig["Lora"]["RF95_MAX_POWER"].as<int>(20);

if (yamlConfig["Lora"]["TX_GAIN_LORA"]) {

YAML::Node tx_gain_node = yamlConfig["Lora"]["TX_GAIN_LORA"];

if (tx_gain_node.IsSequence() && tx_gain_node.size() != 0) {

portduino_config.num_pa_points = min(tx_gain_node.size(), std::size(portduino_config.tx_gain_lora));

for (int i = 0; i < portduino_config.num_pa_points; i++) {

portduino_config.tx_gain_lora[i] = tx_gain_node[i].as<int>();

}

} else {

portduino_config.num_pa_points = 1;

portduino_config.tx_gain_lora[0] = tx_gain_node.as<int>(0);

}

}

if (portduino_config.lora_module != use_autoconf && portduino_config.lora_module != use_simradio &&

!portduino_config.force_simradio) {

portduino_config.dio2_as_rf_switch = yamlConfig["Lora"]["DIO2_AS_RF_SWITCH"].as<bool>(false);

portduino_config.dio3_tcxo_voltage = yamlConfig["Lora"]["DIO3_TCXO_VOLTAGE"].as<float>(0) * 1000;

if (portduino_config.dio3_tcxo_voltage == 0 && yamlConfig["Lora"]["DIO3_TCXO_VOLTAGE"].as<bool>(false)) {

portduino_config.dio3_tcxo_voltage = 1800; // default millivolts for "true"

}

// backwards API compatibility and to globally set gpiochip once

portduino_config.lora_default_gpiochip = yamlConfig["Lora"]["gpiochip"].as<int>(0);

for (auto this_pin : portduino_config.all_pins) {

if (this_pin->config_section == "Lora") {

readGPIOFromYaml(yamlConfig["Lora"][this_pin->config_name], *this_pin);

}

}

}

if (yamlConfig["Lora"]["Enable_Pins"]) {

for (auto extra_pin : yamlConfig["Lora"]["Enable_Pins"]) {

portduino_config.extra_pins.push_back(pinMapping());

portduino_config.extra_pins.back().config_section = "Lora";

portduino_config.extra_pins.back().config_name = "Enable_Pins";

portduino_config.extra_pins.back().enabled = true;

portduino_config.extra_pins.back().default_high = true;

readGPIOFromYaml(extra_pin, portduino_config.extra_pins.back());

}

}

portduino_config.spiSpeed = yamlConfig["Lora"]["spiSpeed"].as<int>(2000000);