Bitchat Meshtastic bridge

[Anon000-L]

I got code for a bridge between Meshtastic and bitchat that can be flashed on an esp32. That way bitchat networks can get connected to other bitchat networks using meshtastic.
Can someone with a meshtastic device please test this and give me feedback.

Libraries:

• radiolib
• ESP32 BLE Arduino

Code:

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#include <RadioLib.h>
#include <SPI.h>
#include <esp_sleep.h>

// ===== HARDWARE CONFIGURATION =====
// Adjust for your specific board model
#define LORA_MOSI      27
#define LORA_MISO      19
#define LORA_SCK       5
#define LORA_CS        18
#define LORA_RST       14
#define LORA_DIO0      26
#define LORA_DIO1      33
#define LORA_BUSY      32  // Not needed for all boards

// ===== BLUETOOTH LE CONFIGURATION =====
BLEServer *pServer;
BLEService *pService;
BLECharacteristic *pTxCharacteristic;
BLECharacteristic *pRxCharacteristic;

// BitChat UUIDs (Standard BLE UART Service)
#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

// ===== LORA CONFIGURATION =====
SX1262 radio = new Module(LORA_CS, LORA_DIO0, LORA_RST, LORA_DIO1);
#define LORA_FREQUENCY      915.0  // 868 MHz for EU, 915 MHz for US
#define LORA_BANDWIDTH      125.0
#define LORA_SPREADING_FACTOR 9
#define LORA_CODING_RATE     7
#define LORA_OUTPUT_POWER    10    // Reduced power for onboard antenna

// ===== GLOBAL VARIABLES =====
bool deviceConnected = false;
bool oldDeviceConnected = false;
uint32_t lastMessageTime = 0;
const uint32_t MESSAGE_TIMEOUT = 30000;  // 30-second timeout

// ===== BLUETOOTH CALLBACKS =====
class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
      digitalWrite(LED_BUILTIN, HIGH);  // LED on when connected
    }

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
      digitalWrite(LED_BUILTIN, LOW);  // LED off when disconnected
    }
};

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string rxValue = pCharacteristic->getValue();
      
      if (rxValue.length() > 0) {
        Serial.print("Received from BLE: ");
        Serial.println(rxValue.c_str());
        
        // Send message to LoRa
        sendLoRaMessage(rxValue.c_str());
      }
    }
};

// ===== FUNCTION PROTOTYPES =====
void initBLE();
void initLoRa();
void sendBLEMessage(const char* message);
void sendLoRaMessage(const char* message);
void enterLightSleep();
void processReceivedLoRaMessages();

// ===== MAIN SETUP =====
void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);

  // Initialize hardware communication
  SPI.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
  initBLE();
  initLoRa();

  Serial.println("Bridge ready - Waiting for connections...");
}

// ===== MAIN LOOP =====
void loop() {
  // Bluetooth connection management
  if (!deviceConnected && oldDeviceConnected) {
    delay(500); // Wait for disconnection
    pServer->startAdvertising();
    oldDeviceConnected = deviceConnected;
    Serial.println("BLE advertising started");
  }
  
  if (deviceConnected && !oldDeviceConnected) {
    oldDeviceConnected = deviceConnected;
  }

  // Process received LoRa messages
  processReceivedLoRaMessages();

  // Enter power saving mode after inactivity
  if (millis() - lastMessageTime > MESSAGE_TIMEOUT) {
    enterLightSleep();
  }
  
  delay(100); // Short pause to reduce CPU load
}

// ===== BLUETOOTH INITIALIZATION =====
void initBLE() {
  BLEDevice::init("BitChat-MeshBridge");
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());
  
  pService = pServer->createService(SERVICE_UUID);
  
  // Receive characteristic (from app)
  pRxCharacteristic = pService->createCharacteristic(
                      CHARACTERISTIC_UUID_RX,
                      BLECharacteristic::PROPERTY_WRITE
                    );
  pRxCharacteristic->setCallbacks(new MyCallbacks());
  
  // Transmit characteristic (to app)
  pTxCharacteristic = pService->createCharacteristic(
                      CHARACTERISTIC_UUID_TX,
                      BLECharacteristic::PROPERTY_NOTIFY
                    );
  pTxCharacteristic->addDescriptor(new BLE2902());
  
  pService->start();
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);
  pAdvertising->setMinPreferred(0x12);
  BLEDevice::startAdvertising();
  
  Serial.println("BLE initialized - Waiting for connection");
}

// ===== LORA INITIALIZATION =====
void initLoRa() {
  int state = radio.begin(LORA_FREQUENCY);
  
  if (state == RADIOLIB_ERR_NONE) {
    Serial.println("LoRa initialized!");
  } else {
    Serial.print("LoRa initialization error: ");
    Serial.println(state);
    while (true); // Stop on error
  }

  // Meshtastic-compatible settings
  radio.setBandwidth(LORA_BANDWIDTH);
  radio.setSpreadingFactor(LORA_SPREADING_FACTOR);
  radio.setCodingRate(LORA_CODING_RATE);
  radio.setOutputPower(LORA_OUTPUT_POWER);
  radio.setCurrentLimit(60.0);  // Reduced current for onboard antenna
  
  // Start continuous receive mode
  radio.startReceive();
  
  Serial.println("LoRa in receive mode");
}

// ===== MESSAGE PROCESSING =====
void sendBLEMessage(const char* message) {
  if (deviceConnected) {
    pTxCharacteristic->setValue(message);
    pTxCharacteristic->notify();
    lastMessageTime = millis();
    Serial.print("Sent to BLE: ");
    Serial.println(message);
  }
}

void sendLoRaMessage(const char* message) {
  // Shorten message for LoRa limitations
  char shortMsg[128];
  strncpy(shortMsg, message, sizeof(shortMsg) - 1);
  shortMsg[sizeof(shortMsg) - 1] = '\0';
  
  int state = radio.transmit(shortMsg);
  
  if (state == RADIOLIB_ERR_NONE) {
    Serial.print("Sent to LoRa: ");
    Serial.println(shortMsg);
    lastMessageTime = millis();
  } else {
    Serial.print("LoRa transmission error: ");
    Serial.println(state);
  }
  
  // Re-enable receive mode
  radio.startReceive();
}

void processReceivedLoRaMessages() {
  String str;
  int state = radio.readData(str);
  
  if (state == RADIOLIB_ERR_NONE) {
    Serial.print("Received from LoRa: ");
    Serial.println(str);
    
    // Forward message to BLE
    sendBLEMessage(str.c_str());
    lastMessageTime = millis();
  }
}

// ===== POWER SAVING FUNCTIONS =====
void enterLightSleep() {
  Serial.println("Entering light sleep...");
  
  // Disable Bluetooth
  BLEDevice::deinit();
  
  // Put LoRa in sleep mode
  radio.sleep();
  
  // CPU light sleep with timer
  esp_sleep_enable_timer_wakeup(10 * 1000000);  // Wake up every 10 seconds
  esp_light_sleep_start();
  
  // Reinitialize after wakeup
  initBLE();
  initLoRa();
  
  Serial.println("Woke up");
}

[GigaProjects]

Does it work only for esp32?