Badge WHY2025: Meshtastic

cd ~/projects
[ ! -d meshtastic-firmware-why2025-carrier ] && git clone https://github.com/pkoryzna/meshtastic-firmware-why2025-carrier.git
cd meshtastic-firmware-why2025-carrier     
sudo apt update
sudo apt install -y pipx python3-venv

pipx ensurepath
exec $SHELL -l

pipx install platformio

pio run -e why2025-carrier -j 1

SRC=~/projects/meshtastic-firmware-why2025-carrier/.pio/build/why2025-carrier
OUT=~/projects/c6_blobs
mkdir -p "$OUT"

# Copié/renommé pour l'UI
cp "$SRC/bootloader.bin"        "$OUT/c6-bootloader.bin"
cp "$SRC/boot_app0.bin"         "$OUT/c6-boot_app0.bin"
if [ -f "$SRC/partition-table.bin" ]; then
  cp "$SRC/partition-table.bin" "$OUT/c6-partitions.bin"
else
  cp "$SRC/partitions.bin"      "$OUT/c6-partitions.bin"
fi
cp "$SRC/firmware.bin"          "$OUT/c6-firmware.bin"

# MD5 (hex minuscule, sans rien d'autre)
for f in c6-bootloader.bin c6-boot_app0.bin c6-partitions.bin c6-firmware.bin; do
  md5sum "$OUT/$f" | awk '{print tolower($1)}' > "$OUT/$f.md5"
done

tar -czf ~/Downloads/c6_blobs_for_ui.tgz -C "$OUT"

git clone --recursive https://github.com/pkoryzna/meshtastic-ui-why-m2.git
cd meshtastic-ui-why-m2
git submodule update --init --recursive
git lfs pull
p -aL meshtastic-ui-why-m2 meshtastic-ui-why-m2-win
tar -czf ~/Downloads/meshtastic-ui-why-m2-win.tgz -C ~/projects meshtastic-ui-why-m2-win

#  add_custom_target(firmware-why2025-carrier
#          COMMAND ${COMPONENT_DIR}/get_firmware.sh ${MESHTASTIC_VER}
#          BYPRODUCTS
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-boot_app0.bin
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-boot_app0.bin.md5
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-bootloader.bin
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-bootloader.bin.md5
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-partitions.bin
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-partitions.bin.md5
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-firmware.bin
#          ${CMAKE_CURRENT_BINARY_DIR}/c6-firmware.bin.md5
#  )
#  
#  add_dependencies(${COMPONENT_LIB} firmware-why2025-carrier)
#
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-boot_app0.bin BINARY)
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-boot_app0.bin.md5 TEXT)
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-bootloader.bin BINARY)
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-bootloader.bin.md5 TEXT)
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-partitions.bin BINARY)
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-partitions.bin.md5 TEXT)
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-firmware.bin BINARY)
#target_add_binary_data(${COMPONENT_LIB} ${CMAKE_CURRENT_BINARY_DIR}/c6-firmware.bin.md5 TEXT)

target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-boot_app0.bin BINARY)
target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-boot_app0.bin.md5 TEXT)
target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-bootloader.bin BINARY)
target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-bootloader.bin.md5 TEXT)
target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-partitions.bin BINARY)
target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-partitions.bin.md5 TEXT)
target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-firmware.bin BINARY)
target_add_binary_data(${COMPONENT_LIB} ${COMPONENT_DIR}/c6-firmware.bin.md5 TEXT)

python3 -m pip install pillow requests
git clone https://github.com/JustDr00py/tdeck-maps.git
cd tdeck-maps

py meshtastic_tiles.py --city "Belfort, France" --min-zoom 1 --max-zoom 15

#ifndef PIO_UNIT_TESTING

#include "Arduino.h"
#include "esp_loader.h"
#include "Log.h"
#include "comms/EthClient.h"
#include "comms/UARTClient.h"
#include "graphics/DeviceScreen.h"

#include "esp_timer.h"
#include "meshtastic/mesh.pb.h"
#include "pb_encode.h"
#include "util/ILog.h"

#ifndef meshtastic_PortNum_TEXT_MESSAGE_APP
#define meshtastic_PortNum_TEXT_MESSAGE_APP 6
#endif

// Assuming a global client pointer exists:
extern IClientBase* client;

#if defined(ARCH_PORTDUINO)
#include <thread>
#define FSBegin() true
#else
#include "LittleFS.h"
#define FSCom LittleFS
#define FSBegin() LittleFS.begin(true)
#endif

#if defined(I2C_SDA) || defined(I2C_SDA1)
#include "Wire.h"
#endif

// this is pulled in by the device-ui library
const char *firmware_version = "2.6.8";
esp_loader_error_t flash_c6_if_needed();

#ifdef USE_DUMMY_SERIAL
class DummyClient : public IClientBase
{
  public:
    DummyClient() = default;
    void init(void) override {}
    bool connect(void) override { return true; }
    bool disconnect(void) override { return true; }
    bool isConnected(void) override { return false; }
    bool send(meshtastic_ToRadio &&to) override { return false; }
    meshtastic_FromRadio receive(void) override
    {
        meshtastic_FromRadio dummy{};
        return dummy;
    }
    ~DummyClient(){};
} serial;
#else
IClientBase *client = nullptr;
#endif

DeviceScreen *screen = nullptr;

// Define your message list (you can customize this)
const char* message_list[] = {
    "Cyberpaix, maintenant.",
    "HackGyver libere ta curiosite",
    "Apprends. Bricole. Transmets",
    "HackGyver fabrique ta liberte.",
    "La vie privee est un droit humain fondamental",
    "Des livres, pas des bombes",
    "hackgyver.fr - Le hackerspace de Belfort",
    "Si tu peux l'ouvrir, tu peux le comprendre.",
    "Touche a tout, casse un peu, apprends beaucoup.",
    "Rien n'est magique, tout est logique.",
    "Le savoir se partage, HackGyver le prouve.",
    "Belfort + LoRa + hackers = HackGyver <3",
    "Makers de Belfort, unissez-vous.",
    "Fabrique ton monde, pas ta cage",
    "On ne pirate pas, on explore.",
    "L'erreur est juste le debut de la decouverte.",
    "HackGyver c'est pas un bug, c'est une feature de Belfort.",
    "Open hardware, open minds.",
    "HackGyver est la, et toi, t'es ou ?",
    "Ayez le courage de vous servir de votre propre entendement."
};

const int message_count = sizeof(message_list) / sizeof(message_list[0]);

void broadcast_random_message() {
    if (!client) return;
    
    // Select a random message from the list
    int random_index = rand() % message_count;
    const char* random_msg = message_list[random_index];
    
    meshtastic_ToRadio out_msg = meshtastic_ToRadio_init_default;
    out_msg.which_payload_variant = meshtastic_ToRadio_packet_tag;
    
    out_msg.packet.to = 0xFFFFFFFF;
    out_msg.packet.channel = 0;
    out_msg.packet.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
    out_msg.packet.decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
    out_msg.packet.decoded.want_response = false;
    out_msg.packet.want_ack = false;
    out_msg.packet.id = rand() & 0xFFFF;
    
    size_t msg_len = strnlen(random_msg, sizeof(out_msg.packet.decoded.payload.bytes));
    memcpy(out_msg.packet.decoded.payload.bytes, random_msg, msg_len);
    out_msg.packet.decoded.payload.size = (unsigned short)msg_len;
    
    client->send(std::move(out_msg));
    ILOG_INFO("Broadcast random message [%d/%d]: %s", random_index + 1, message_count, random_msg);
}

void broadcast_message(const char* msg) {
    if (!client) return;
    
    meshtastic_ToRadio out_msg = meshtastic_ToRadio_init_default;
    out_msg.which_payload_variant = meshtastic_ToRadio_packet_tag;
    
    out_msg.packet.to = 0xFFFFFFFF;
    out_msg.packet.channel = 0;
    out_msg.packet.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
    out_msg.packet.decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
    out_msg.packet.decoded.want_response = false;
    out_msg.packet.want_ack = false;
    out_msg.packet.id = rand() & 0xFFFF;
    
    size_t msg_len = strnlen(msg, sizeof(out_msg.packet.decoded.payload.bytes));
    memcpy(out_msg.packet.decoded.payload.bytes, msg, msg_len);
    out_msg.packet.decoded.payload.size = (unsigned short)msg_len;
    
    // Just send it and assume it works (since gqrx confirms it does)
    client->send(std::move(out_msg));
    ILOG_INFO("Broadcast transmitted: %s", msg);
}

void periodic_broadcast(void* arg) {
    //broadcast_message("Do you receive my messages? what is 40+2?");
    broadcast_random_message();
}

void setup()
{
#if defined(__APPLE__)
    pthread_setname_np("setup");
#elif defined(__linux__)
    pthread_setname_np(pthread_self(), "setup");
#endif
#ifdef KB_POWERON
    digitalWrite(KB_POWERON, HIGH);
    pinMode(KB_POWERON, OUTPUT);
    delay(200); // wait until keyboard mcu startup finished
#endif

#ifdef PWR_ON_PIN
    pinMode(PWR_ON_PIN, OUTPUT);
    digitalWrite(PWR_ON_PIN, HIGH);
#endif

#ifdef PWR_EN_PIN
    pinMode(PWR_EN_PIN, OUTPUT);
    digitalWrite(PWR_EN_PIN, HIGH);
#endif

#ifndef WHY_BADGE_CUSTOM_C6_FW
    esp_loader_error_t esp_loader_error = flash_c6_if_needed();
    if (esp_loader_error != ESP_LOADER_SUCCESS)
    {
        ILOG_CRIT("failed to flash c6 with error %d", esp_loader_error);
        return;
    }
#elif defined(WHY_BADGE)
    ILOG_INFO("Firmware compiled with WHY_BADGE_CUSTOM_C6_FW, skipping C6 flashing.");
#endif

#ifndef USE_SERIAL0
#ifdef WAIT_FOR_SERIAL0
    delay(2000);
#endif
    Serial.begin(115200);
#ifdef WAIT_FOR_SERIAL0
    time_t timeout = millis();
    while (!Serial && (millis() - timeout) < 2000)
        ;
#endif
    logger.setDebugLevel(ESP_LOG_DEBUG); // use ESP_LOG_VERBOSE for trace category
#else
    logger.setDebugLevel(ESP_LOG_NONE); // do not log when connected over serial0
#endif

#ifdef I2C_SDA
    if (!Wire.begin(I2C_SDA, I2C_SCL, 400000))
        ILOG_ERROR("*** Failed to access I2C0(%d, %d)", I2C_SDA, I2C_SCL);
#endif
#ifdef I2C_SDA1
    if (!Wire.begin(I2C_SDA1, I2C_SCL1, 400000))
        ILOG_ERROR("*** Failed to access I2C1(%d, %d)", I2C_SDA1, I2C_SCL1);
#endif

    ILOG_INFO("\n//\\ E S H T /\\ S T / C   U I\n");
#ifdef ARDUINO_ARCH_ESP32
    uint64_t chipid;
    chipid = ESP.getEfuseMac(); // The chip ID is essentially its MAC address(length: 6 bytes).
    ILOG_DEBUG("  ESP32 Chip ID = %04X %08X", (uint16_t)(chipid >> 32), (uint32_t)chipid);
    ILOG_DEBUG("  Flash size: %8d bytes", ESP.getFlashChipSize());
    ILOG_DEBUG("  Heap size : %8d bytes", ESP.getHeapSize());
    ILOG_DEBUG("  Free heap : %8d bytes", ESP.getFreeHeap());
    ILOG_DEBUG("  PSRAM     : %8d bytes", ESP.getFreePsram());
    ILOG_DEBUG("  PSRAM max : %8d bytes", heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM));
    ILOG_DEBUG("*****************************************");
#endif

    if (!FSBegin()) {
        ILOG_ERROR("LittleFS mount failed!");
    }

#ifdef ARCH_PORTDUINO
    const char *hostname = getenv("MUI_SERVER");
    if (hostname == nullptr) {
        client = new EthClient();
    } else {
        client = new EthClient(hostname);
    }
    int16_t x = 480;
    int16_t y = 480;
    const char *size = getenv("MUI_SIZE");
    if (size != nullptr) {
        sscanf(size, "%" PRId16 "x%" PRId16, &x, &y);
    }
    if (x < 320 || x > 800)
        x = 480;
    if (y < 240 || y > 800)
        y = 480;
    screen = &DeviceScreen::create(DisplayDriverConfig(DisplayDriverConfig::device_t::X11, x, y));
#elif defined(WHY_BADGE)
    client = new UARTClient();
    screen = &DeviceScreen::create(DisplayDriverConfig(DisplayDriverConfig::device_t::WHY2025_M2, 720, 720));
#else
    client = new UARTClient();
    screen = &DeviceScreen::create();
#endif

    screen->init(client);

#ifdef ARDUINO_ARCH_ESP32
    ILOG_DEBUG("Free heap : %8d bytes", ESP.getFreeHeap());
    ILOG_DEBUG("PSRAM     : %8d bytes", ESP.getFreePsram());
#endif

#ifdef ARCH_PORTDUINO
    // create separate thread to handle lvgl X11 GUI simulation
    // otherwise the GUI will slow down the main thread
    extern void tft_task_handler(void *param = nullptr);
    new std::thread([] {
#ifdef __APPLE__
        pthread_setname_np("tft");
#else
        pthread_setname_np(pthread_self(), "tft");
#endif
        tft_task_handler();
    });
#endif

 // Initialize random seed
    srand(esp_timer_get_time());

    // Add connection check
    if (client) {
        ILOG_DEBUG("Client initialized, attempting to connect...");
        if (client->connect()) {
            ILOG_INFO("Client connected successfully");
        } else {
            ILOG_ERROR("Client failed to connect");
        }
    } else {
        ILOG_ERROR("Client is null after initialization");
    }

// Create an esp_timer for broadcasting every 3 minutes (180000ms)
    const esp_timer_create_args_t broadcast_timer_args = {
        .callback = &periodic_broadcast,
        .name = "broadcast_timer"
    };
    esp_timer_handle_t broadcast_timer;
    esp_timer_create(&broadcast_timer_args, &broadcast_timer);
    esp_timer_start_periodic(broadcast_timer, 20000 /*180000*/ * 1000ULL); // period in microseconds


    ILOG_DEBUG("Setup done.");
#if defined(__APPLE__)
    pthread_setname_np("loop");
#elif defined(__linux__)
    pthread_setname_np(pthread_self(), "loop");
#endif
}

#if defined(ARCH_ESP32)
void loop()
{
    screen->task_handler();
    screen->sleep(5);
}

#elif defined(ARCH_PORTDUINO)
void loop()
{
    delay(1000);
    fflush(nullptr);
}

void tft_task_handler(void *)
{
    ILOG_INFO("tft_task_handler started");
    while (true) {
        screen->task_handler();
        screen->sleep(5);
    }
}
#else
#error "Unsupported architecture"
#endif

#endif

Ligne 4: #include "esp_loader.h"
Ligne 37: esp_loader_error_t flash_c6_if_needed();

Lignes 165 à 174:
#ifndef WHY_BADGE_CUSTOM_C6_FW
    esp_loader_error_t esp_loader_error = flash_c6_if_needed();
    if (esp_loader_error != ESP_LOADER_SUCCESS)
    {
        ILOG_CRIT("failed to flash c6 with error %d", esp_loader_error);
        return;
    }
#elif defined(WHY_BADGE)
    ILOG_INFO("Firmware compiled with WHY_BADGE_CUSTOM_C6_FW, skipping C6 flashing.");
#endif