Betaflight configuration help!!

[lbaron42]

Greetings.

I'm having trouble setting up the communication protocol between the esp_32 and the drone; I ordered most of the components from China, and the f3 flight controllers never arrived, so I'm using an old Cinewoop that has a Geprc FC, with a proper Rx pad to solder the esp32, it is running in UART 2 and ween set to SPECTRUM1024 I can see the bars going crazy, but they make no sense and the drone never aArm I sure have some communication going on, but I need the proper protocol, and bald rate, if anyone have some clue on how to solve this problem?

Even rote a different script just to test:

#include <esp_now.h>
#include <esp_wifi.h>
#include <WiFi.h>
#include <ArduinoJson.h>
#include <PID_v1.h>
#include <stdint.h>
#include <EEPROM.h>
#include "sbus.h"

#define batVoltagePin 34
#define MAX_VEL 100
#define ROTOR_RADIUS 0.0225
#define Z_GAIN 0.7

#define DRONE_INDEX 0

#define EEPROM_SIZE 4

unsigned long lastPing;

bfs::SbusTx sbus_tx(&Serial1, 33, 32, true, false);
bfs::SbusData data;

bool armed = false;
unsigned long timeArmed = 0;

StaticJsonDocument<1024> json;

int xTrim = 0, yTrim = 0, zTrim = 0, yawTrim = 0;

double groundEffectCoef = 28, groundEffectOffset = -0.035;

double xPosSetpoint = 0, xPos = 0;
double yPosSetpoint = 0, yPos = 0;
double zPosSetpoint = 0, zPos = 0;
double yawPosSetpoint = 0, yawPos, yawPosOutput;

double xyPosKp = 1, xyPosKi = 0, xyPosKd = 0;
double zPosKp = 1.5, zPosKi = 0, zPosKd = 0;
double yawPosKp = 0.3, yawPosKi = 0.1, yawPosKd = 0.05;

double xVelSetpoint, xVel, xVelOutput;
double yVelSetpoint, yVel, yVelOutput;
double zVelSetpoint, zVel, zVelOutput;

double xyVelKp = 0.2, xyVelKi = 0.03, xyVelKd = 0.05;
double zVelKp = 0.3, zVelKi = 0.1, zVelKd = 0.05;

PID xPosPID(&xPos, &xVelSetpoint, &xPosSetpoint, xyPosKp, xyPosKi, xyPosKd, DIRECT);
PID yPosPID(&yPos, &yVelSetpoint, &yPosSetpoint, xyPosKp, xyPosKi, xyPosKd, DIRECT);
PID zPosPID(&zPos, &zVelSetpoint, &zPosSetpoint, zPosKp, zPosKi, zPosKd, DIRECT);
PID yawPosPID(&yawPos, &yawPosOutput, &yawPosSetpoint, yawPosKp, yawPosKi, yawPosKd, DIRECT);

PID xVelPID(&xVel, &xVelOutput, &xVelSetpoint, xyVelKp, xyVelKi, xyVelKd, DIRECT);
PID yVelPID(&yVel, &yVelOutput, &yVelSetpoint, xyVelKp, xyVelKi, xyVelKd, DIRECT);
PID zVelPID(&zVel, &zVelOutput, &zVelSetpoint, zVelKp, zVelKi, zVelKd, DIRECT);

unsigned long lastLoopTime = micros();
unsigned long lastSbusSend = micros();
float loopFrequency = 2000.0;
float sbusFrequency = 50.0;

#if DRONE_INDEX == 0
  uint8_t mac_addr[6] = { 0x08, 0xB6, 0x1F, 0xBC, 0x8E, 0x9B };
#elif DRONE_INDEX == 1
  uint8_t mac_addr[6] = { 0x08, 0xB6, 0x1F, 0xBC, 0x8E, 0x9C };
#endif

// Function to map the values from script to Betaflight
int mapValue(int val, int minIn, int maxIn, int minOut, int maxOut) {
  return (val - minIn) * (maxOut - minOut) / (maxIn - minIn) + minOut;
}

// Callback function that will be executed when data is received
void data_recv_cb(const esp_now_recv_info_t *info, const uint8_t *incomingData, int len) {
  Serial.printf("Recv %d data: ", len);
  Serial.println();

  DeserializationError err = deserializeJson(json, (const char *)incomingData);

  if (err) {
    Serial.println("failed to parse json");
    return;
  }

  serializeJsonPretty(json, Serial);

  if (json.containsKey("pos") && json.containsKey("vel")) {
    xPos = json["pos"][0];
    yPos = json["pos"][1];
    zPos = json["pos"][2];
    yawPos = json["pos"][3];

    xVel = json["vel"][0];
    yVel = json["vel"][1];
    zVel = json["vel"][2];
  } else if (json.containsKey("armed")) {
    if (json["armed"] != armed && json["armed"]) {
      timeArmed = millis();
    }
    armed = json["armed"];
  } else if (json.containsKey("setpoint")) {
    xPosSetpoint = json["setpoint"][0];
    yPosSetpoint = json["setpoint"][1];
    zPosSetpoint = json["setpoint"][2];
  } else if (json.containsKey("pid")) {
    xPosPID.SetTunings(json["pid"][0], json["pid"][1], json["pid"][2]);
    yPosPID.SetTunings(json["pid"][0], json["pid"][1], json["pid"][2]);
    zPosPID.SetTunings(json["pid"][3], json["pid"][4], json["pid"][5]);
    yawPosPID.SetTunings(json["pid"][6], json["pid"][7], json["pid"][8]);

    xVelPID.SetTunings(json["pid"][9], json["pid"][10], json["pid"][11]);
    yVelPID.SetTunings(json["pid"][9], json["pid"][10], json["pid"][11]);
    zVelPID.SetTunings(json["pid"][12], json["pid"][13], json["pid"][14]);

    groundEffectCoef = json["pid"][15];
    groundEffectOffset = json["pid"][16];
  } else if (json.containsKey("trim")) {
    xTrim = json["trim"][0];
    yTrim = json["trim"][1];
    zTrim = json["trim"][2];
    yawTrim = json["trim"][3];
  }

  lastPing = micros();
}

void resetPid(PID &pid, double min, double max) {
  pid.SetOutputLimits(0.0, 1.0); 
  pid.SetOutputLimits(-1.0, 0.0);
  pid.SetOutputLimits(min, max);
}

void readMacAddress(){
  uint8_t baseMac[6];
  esp_err_t ret = esp_wifi_get_mac(WIFI_IF_STA, baseMac);
  if (ret == ESP_OK) {
    Serial.printf("%02x:%02x:%02x:%02x:%02x:%02x\n",
                  baseMac[0], baseMac[1], baseMac[2],
                  baseMac[3], baseMac[4], baseMac[5]);
  } else {
    Serial.println("Failed to read MAC address");
  }
}

void setup() {
  // Initialize Serial Monitor
  Serial.begin(115200);

  sbus_tx.Begin();
  data.failsafe = false;
  data.ch17 = true;
  data.ch18 = true;
  data.lost_frame = false;

  // Set device as a Wi-Fi Station
  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  esp_wifi_init(&cfg);
  esp_wifi_set_mode(WIFI_MODE_STA);
  esp_wifi_set_mac(WIFI_IF_STA, mac_addr);
  esp_wifi_set_bandwidth(WIFI_IF_STA, WIFI_BW_HT20);
  esp_wifi_set_storage(WIFI_STORAGE_RAM);
  esp_wifi_set_ps(WIFI_PS_NONE);
  //esp_wifi_set_channel(1, WIFI_SECOND_CHAN_NONE);
  esp_wifi_start();

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  esp_wifi_config_espnow_rate(WIFI_IF_STA, WIFI_PHY_RATE_24M);
  esp_wifi_start();

  // Register the receive callback
  esp_now_register_recv_cb(data_recv_cb);

  readMacAddress();

  xPosPID.SetMode(AUTOMATIC);
  yPosPID.SetMode(AUTOMATIC);
  zPosPID.SetMode(AUTOMATIC);
  yawPosPID.SetMode(AUTOMATIC);
  xVelPID.SetMode(AUTOMATIC);
  yVelPID.SetMode(AUTOMATIC);
  zVelPID.SetMode(AUTOMATIC);
  
  // Sample rate is determined by main loop
  xPosPID.SetSampleTime(0);
  yPosPID.SetSampleTime(0);
  zPosPID.SetSampleTime(0);
  yawPosPID.SetSampleTime(0);
  xVelPID.SetSampleTime(0);
  yVelPID.SetSampleTime(0);
  zVelPID.SetSampleTime(0);

  xPosPID.SetOutputLimits(-MAX_VEL, MAX_VEL);
  yPosPID.SetOutputLimits(-MAX_VEL, MAX_VEL);
  zPosPID.SetOutputLimits(-MAX_VEL, MAX_VEL);
  yawPosPID.SetOutputLimits(-1, 1);
  xVelPID.SetOutputLimits(-1, 1);
  yVelPID.SetOutputLimits(-1, 1);
  zVelPID.SetOutputLimits(-1, 1);

  EEPROM.begin(EEPROM_SIZE);

  // xTrim = EEPROM.read(0);
  // yTrim = EEPROM.read(1);
  // zTrim = EEPROM.read(2);
  // yawTrim = EEPROM.read(3);

  lastPing = micros();
  lastLoopTime = micros();
  lastSbusSend = micros();
}

void loop() {
  // Incremental Movement
  for (int value = 1000; value <= 2000; value += 50) {
    data.ch[0] = mapValue(value, 1000, 2000, 988, 2012); // Roll
    sbus_tx.data(data);
    sbus_tx.Write();
    Serial.print("Roll: ");
    Serial.println(data.ch[0]);
    delay(500); // Small delay to observe changes
  }
  for (int value = 2000; value >= 1000; value -= 50) {
    data.ch[0] = mapValue(value, 1000, 2000, 988, 2012); // Roll
    sbus_tx.data(data);
    sbus_tx.Write();
    Serial.print("Roll: ");
    Serial.println(data.ch[0]);
    delay(500); // Small delay to observe changes
  }

  for (int value = 1000; value <= 2000; value += 50) {
    data.ch[1] = mapValue(value, 1000, 2000, 988, 2012); // Pitch
    sbus_tx.data(data);
    sbus_tx.Write();
    Serial.print("Pitch: ");
    Serial.println(data.ch[1]);
    delay(500); // Small delay to observe changes
  }
  for (int value = 2000; value >= 1000; value -= 50) {
    data.ch[1] = mapValue(value, 1000, 2000, 988, 2012); // Pitch
    sbus_tx.data(data);
    sbus_tx.Write();
    Serial.print("Pitch: ");
    Serial.println(data.ch[1]);
    delay(500); // Small delay to observe changes
  }

  for (int value = 1000; value <= 2000; value += 50) {
    data.ch[3] = mapValue(value, 1000, 2000, 988, 2012); // Yaw
    sbus_tx.data(data);
    sbus_tx.Write();
    Serial.print("Yaw: ");
    Serial.println(data.ch[3]);
    delay(500); // Small delay to observe changes
  }
  for (int value = 2000; value >= 1000; value -= 50) {
    data.ch[3] = mapValue(value, 1000, 2000, 988, 2012); // Yaw
    sbus_tx.data(data);
    sbus_tx.Write();
    Serial.print("Yaw: ");
    Serial.println(data.ch[3]);
    delay(500); // Small delay to observe changes
  }

  // Armthe drone
  Serial.println("Arming the drone");
  data.ch[4] = mapValue(2000, 1000, 2000, 988, 2012); // Arm switch (value above 2000 to arm)
  sbus_tx.data(data);
  sbus_tx.Write();
  delay(3000); // Wait for 3 seconds to ensure the drone is armed

  // Accelerate to 1300 PWM
  Serial.println("Accelerating to 1300 PWM");
  data.ch[2] = mapValue(1300, 1000, 2000, 988, 2012); // Throttle to 1300
  sbus_tx.data(data);
  sbus_tx.Write();
  delay(3000); // Hold throttle for 3 seconds

  // Decelerate to 987 PWM
  Serial.println("Decelerating to 987 PWM");
  data.ch[2] = mapValue(987, 1000, 2000, 988, 2012); // Throttle to minimum
  sbus_tx.data(data);
  sbus_tx.Write();
  delay(3000); // Hold throttle at minimum for 3 seconds

  // Disarm the drone
  Serial.println("Disarming the drone");
  data.ch[4] = mapValue(1000, 1000, 2000, 988, 2012); // Disarm switch
  sbus_tx.data(data);
  sbus_tx.Write();

  Serial.println("Completed Sequence");

  // Stop the loop to prevent repeated commands
  while (true) {
    delay(1000);
  }
}

[jyjblrd]

Hi, the receiver protocol should be set to SBUS on the betaflight configurator, and the correct UART must be selected as the receiver input.