Fly your ESP32 Drone on Betaflight with Radio Controller | esp-fc Guide
Configure your ESP32 Drone in Betaflight and fly it with your favorite Radio Controller using esp-fc firmware by rtlopez.
With the ESP32 as a drone flight controller configured in Betaflight, you save money, unlock way better range than WiFi or Bluetooth ever will, and get real hobby-grade control of your drone using your favorite RC transmitter - Radiomaster, ExpressLRS, FlySky, FrSky, Jumper… you name it.
In this guide, you’ll learn how to set up different receivers, motors, flight modes like Angle and Acro, PID tuning, rates, blackbox logging, and a ton of in-depth settings on something so tiny and affordable.
So here’s what you need to get started.
1. Hardware and Software Requirements
For hardware, you’ll need to build an ESP32-based quadcopter like my ESP-FLY micro drone shown in my previous tutorial. You can drive the motors using either a MOSFET-based driver for brushed motors or ESCs if you’re running brushless.
For control, you have two options. You can build an ESP-TX RC link that mounts in your radio’s JR bay, using a second ESP32 for ESP-NOW communication between your transmitter and the drone. Alternatively, you can simply connect a receiver to the drone that supports PPM, SBUS, IBUS, or CRSF - like the ELRS EP1 I’m using.
For your flight controller, you may use an ESP32 or ESP32S3 paired with an MPU6050 or MPU9250 IMU for stabilization. Both IMUs contain the gyro and accelerometer the flight controller needs to maintain orientation and respond to movement.
Listed below is everything you need to get started:
Now here’s where everything comes together: once you start wiring the MCU, the IMU, the motor drivers or ESC connections, and your receiver, it becomes clear why many choose to give their drone a custom PCB, like I did.
You can have a dedicated board like my ESP-FLY’s thumb-sized 3-in-1 stack with the XIAO ESP32S3, the MPU6050, and a 4-channel brushed motor driver all integrated. The PCB made the whole assembly more compact and professional.
If you decide to design your own board or use mine, services like JLCPCB make it easy to get your flight controller PCB made. Uploading your Gerber files with basic specs as seen in the image gives you an instant quote - starting at $2, and they also offer optional PCB assembly if you’d rather not solder tiny SMD components yourself: https://jlcpcb.com/?from=MaxImagination
I cover the full ESP32 Drone assembly in my ESP-FLY tutorial - attached below it, you’ll find a Google Drive folder with the PCB Gerber files, BOM, and Pick and Place files with image instructions for getting the drone’s flight controller made: https://youtu.be/V_mZsiZcy7s
3. Flashing Firmware
To get the quadcopter’s firmware, go to “esp-fc” by rtlopez on GitHub - a Betaflight-compatible software for ESP32 flight controllers: https://github.com/rtlopez/esp-fc/tree/master
You’ll want to scroll down to the flashing section and click on the Releases Page. Under the latest release, download the firmware binary file for your ESP board and extract the zipped file to end up with the binary.
If you’ve never uploaded code to an Arduino or ESP32 before, you may need to check you have the CH340 driver installed on your computer prior to the next step, but if you have before, then you can skip installing it: https://sparks.gogo.co.nz/ch340.html
Now you’ll want to head to Espressif’s online flasher for ESP chips (https://espressif.github.io/esptool-js/ ), plug your drone into your computer, and hit the connect button. If you get a connectivity-related error message at the output, copy the site link and paste it into Google Chrome - a browser that can access serial ports. Check you have the right baud rate, click the button and select your ESP’s COM port in the pop-up window, and then hit “Connect”. Based on the output, check it has detected your chip. Set the flashing address to “0x00”, select the firmware file you downloaded, and hit “Program”.
After it has flashed successfully to the board, you’ll want to disconnect and reconnect the drone to power-cycle it.
Click the link, scroll down to version 10.10.0, click on it, scroll some more until the “Assets” section, and download the installer for your OS version. I’ll skip describing the installation part (it’s straightforward), but once it’s set up, Betaflight should appear like this.
Open Betaflight, click on the options panel and check you’ve enabled “Show all serial devices”. Then you’ll want to select your ESP’s COM port and hit connect. If you get a warning about motors, don’t be alarmed, close this window - as they aren’t set up yet.
As expected, the 3D view won’t move with your drone until you’ve set things up in the Command Line Interface, or CLI for short.
5. Setting up Pin Functions
In the CLI, if you type the command “get pin” and hit enter on your keyboard, you’ll see the current pinouts to each function based on your ESP, which is most likely not how you want it. So, head to the repo, under Documentation, click on setup guide, Pin Functions Reference, and you’ll get the list of default assigned pins which you can copy and paste in a text editor to modify like I’ve done for the way my drone is wired.
Pin Functions Table for the XIAO ESP32S3:
set pin_input_rx -1
set pin_output_0 4
set pin_output_1 7
set pin_output_2 3
set pin_output_3 1
set pin_buzzer 43
set pin_serial_0_tx 43
set pin_serial_0_rx 44
set pin_serial_1_tx 16
set pin_serial_1_rx 15
set pin_serial_2_tx 8
set pin_serial_2_rx 9
set pin_i2c_scl 6
set pin_i2c_sda 5
set pin_input_adc_0 2
set pin_input_adc_1 -1
set pin_spi_0_sck 12
set pin_spi_0_mosi 11
set pin_spi_0_miso 13
set pin_spi_cs_0 8
set pin_spi_cs_1 7
set pin_spi_cs_2 -1
set pin_buzzer_invert 1
To break it down, ensure “pin_input_rx” is set to -1 as it’s unused, assign GPIO pins to motor outputs such as rear-right output 0 to GPIO 4, front-right output 1 to GPIO 7, rear-left output 2 to GPIO 3, and front-left output 3 to GPIO 1. The icon on the left simply shows the motor direction and order. If you built a drone with wiring that differs from my ESP-FLY, you’ll most likely enter different pins according to your wiring.
For alerts, set the pin your buzzer or LED is wired to (set pin_buzzer 43).
Check you’ve matched your board’s serial UART pins as your computer and ESP communicate this way (set pin_serial_0_tx 43, set pin_serial_0_rx 44), the second UART is left unused (set pin_serial_1_tx 16 and set pin_serial_1_rx 15 can be used for VTX control), and the last two UART pins set up to take your external receiver if you choose that as your method of communication (set pin_serial_2_tx 8 and set pin_serial_2_rx 9).
Define your board’s I2C pins for the IMU (set pin_i2c_scl 6 and set pin_i2c_sda 5).
Choose a pin for voltage monitoring (set pin_input_adc_0 2), and a pin for current monitoring (set pin_input_adc_1 -1) - this one is completely optional, and I’ve set it to -1 as I’m not using it.
Further down, you have SPI pins for other sensors which we won’t be using - you can optionally set each to -1.
The buzzer invert functionality allows you to make the buzzer or LED in my case be normally on or normally off when blinking depending on whether you put a 1 or a 0 (normally for reversing state in cases when a MOSFET-driven buzzer module is pulled normally high or low by default).
Now that you’ve defined your pins, copy the above table and paste it in the CLI, hit enter on your keyboard to set the pins. Enter the commands “save” followed by “reboot”, and whatever you do, do not go to the other tabs from here or it will erase all your configurations - instead, hit disconnect, connect, and you should be able to see things like a 3D interpretation of your drone’s orientation.
6. The Configuration Tab
If you don’t see the 3D interpretation of your drone moving, you may want to check the “Configuration” tab and if you get an error saying your gyro/accelerometer was not found - simply disconnect your drone safely, and reconnect it as sometimes a reboot is needed.
However, if you still don’t see your gyro being detected, you may need to swap the I2C pins in the CLI. Once detected, move back into the Configuration tab and set up the gyro. In “System configuration”, set the PID loop frequency to 2.00 kHz, ensure “Accelerometer” is turned on. In “Board and Sensor Alignment”, feel free to align your gyro’s Pitch, Roll, and Yaw by a few degrees if it doesn’t sit perfectly level when flat, set the gyro orientation in the drop-down next to “First GYRO” by the right amount of degrees if your gyro isn’t pointing the right way according to the 3D interpretation (mine is set to “CW 270°”).
In “Personalization”, you can give your aircraft its name. Scroll down to “Other Features” and keep “DYNAMIC_FILTER” on, and only enable “SOFTSERIAL” if you plan on configuring your quad over WiFi, instructions on that can be found in the GitHub repository.
In the “Beeper Configuration”, it’s up to you on what functionalities and when you want your buzzer or LED to activate as an alert.
Once you’re done in the “Configuration” tab, click the save and reboot button, and reconnect.
7. IMU Calibration and Battery Setup
If you go to the Sensors tab, you can tell whether your gyro for orientation and accelerometer for changes in velocity are both working properly.
Going back to the “Setup” tab, let’s calibrate the Accelerometer with the “Calibrate Accelerometer” button. When calibrating, check your quad is either laying flat or held perfectly level and still.
For these next steps, you’ll need to plug in your drone’s battery. I’m using a 250mAh 1-cell LiPo.
Navigate to the “Power & Battery” tab. To see a battery voltage reading at the top of Betaflight and receive battery warnings, select the following: “Onboard ADC” set as the “Voltage Meter Source”, 3.4 as the “Minimum Cell Voltage”, 4.2 as the maximum, and 3.5 the as warning voltage. If you’re not measuring the current drawn, keep “Current Meter Source” set to none.
In “Voltage Meter”, set the “Divider Value” to 5, and it should be set after you hit save and reboot.
8. Setting up Motors
Now, head to the motors tab. The only multirotor the firmware supports is a quadcopter, so keep it set to “QUADX”, motor direction cannot be reversed in the software, so the best way to change direction is by swapping the motor wires.
With the quad pointing up or forward, you must ensure each motor rotates in the correct direction, and you may refer back to the Pin Functions Table to know which motor corresponds to which pin. If for example, you were to enter pins in the wrong order, your drone would literally go ballistic, but when the pins are entered correctly, corresponding to the right motor, the drone takes off how it should.
In the drop-down below, select the ESC/Motor protocol for the type of motors you’re using. As “PWM” is not recommended by the code author, “BRUSHED” would be the one to use like in my case. Select a “DSHOT” or “OneSHOT” protocol according to your ESC if you're running brushless motors. Set the maximum “Motor PWM frequency” for driving the brushed motors - which is 8000 Hertz. If you try to set it any higher, it will reset back to the maximum.
Before you test the motors, take the propellers off to prevent damages or injuries. Then, enable the slider confirming you accept the risk and test each one at a time or all motors at once to ensure they’re spinning in the right direction.
9. External Receiver Setup
Now, let’s get control of the quadcopter using the first method which is through an external receiver. For mine, I’m using a Happymodel EP1 2.4 gHz ExpressLRS receiver (https://amzn.to/48m1fC0 ) which uses two wires for communication via a serial port, a wire for powering it, and a wire for GND. You’ll want to attach your receiver and trim its wires to the right lengths according to where it’ll sit. Strip the wire ends and solder the RX wire to TX GPIO 8, TX to RX GPIO 9, power input to 3.3V, and GND to GND. If you’re using a different ESP, the TX and RX pins on the board can be set to any other two GPIOs.
For receivers on any of the other supported protocols, you’d use only one wire sending signals to a sole RX-defined pin on the ESP for one-way communication. Whereas a CRSF protocol receiver like the EP1, uses a second wire which allows it to work as a transceiver, sending telemetry data such as battery voltage back to the transmitter. As this feature is more like an extra, I’ll leave it up to you to set up telemetry.
Now let’s get the transmitter paired to the receiver. First, turn on your controller (I’m using the Radiomaster TX12: https://amzn.to/4p4hbQc ), and check that the corresponding radio protocol is selected. Then power on the drone, and you should see the signal bars appear, showing it has connected. If you have never binded before, you’ll likely not see these, and you’ll need to follow the binding instructions for your specific type of receiver, like the video I’ve linked at the top of this blog for binding this transmitter to an ELRS receiver.
Once successfully bound, connect to the drone in Betaflight, head to the “Ports” tab, and ensure you’ve enabled “Serial Rx” for the UART port the receiver is using.
Then head down to the “Receiver” tab, set the receiver mode to “Serial (via UART)” and the serial receiver provider to “CRSF” if you’re using an ELRS receiver like mine, “IBUS” if you’re on FlySky, and “SBUS” with signal inversion done for you if on FrSky.
For channel mapping, set the correct letter order for your Pitch, Roll, Yaw, and Throttle channels according to how your receiver takes it. Mine had to be “TAER1234” to have my gimbal movements all match to their designated functions. Afterward, click Save and Reboot, and all the channels should be set.
Double-check to ensure each stick movement corresponds to the channel designated for that function.
Then, you’ll want to head to the “Modes” tab (just below the “Receiver” tab), add a range for the “ARM” function, you may select the AUX channel manually or if you don’t know which is which, set it to “AUTO” to detect your desired toggle switch for Arming the quad as you flick it back and forth, then, move the slider to the right and repeat this for the other modes you want to use such a the two flight modes: “Angle” and “Airmode”, as well as “Beeper”. When you flick each switch all the way, you should see a response with the corresponding cursor falling into the respective range.
Unplugging the quad, feel free to give it a test flight on the ELRS protocol.
10. Assembling ESP-NOW RC Link
If you want to fly your ESP drone as it is, using the built-in radio chip, then you’ll want to set it up with the ESP-NOW protocol which is just as responsive and has a range of about 200 meters.
We’ll disconnect the EP1 receiver and clip the antenna back onto the ESP32 board.
To control the quad, let’s make the transmitter link which’ll sit in the controller’s JR bay using another XIAO ESP32S3 like the one in the drone.
Any other ESP32 should work fine for this purpose. Following the wiring diagram on rtlopez’s RC Link TX repo, take a 5-slot female pin header row and solder a wire for GND, Vbat, and PPM signal in this exact arrangement. Then, find a L7805 which is a 5V regulator, and from the connector, solder the loose end of the power wire to the input pin, the ground wire to ground, a new wire to extend ground, and another wire to the output pin on the LM7805. Connect this output to your board’s 5V pad, ground to ground, and the signal wire to your chosen pin which in my case is GPIO 4.
Now the TX link is all wired up, to make it fit the enclosure, you may need to bend the connector pins and trim any unused pins. You may optionally clip on an external antenna if your ESP board supports it and your TX link is almost ready. Before shoving it into your controller’s JR bay, we need to program it.
Originally, this firmware is set up to work on an ESP-WROOM-32 board with the PPM pin programmed to GPIO 13, and it supports 8 channels of control.
If you’re using the same board as suggested, you’ll need to head to the releases page and download the binary file for flashing to the ESP32 board, unzip the file to reveal the actual binary - you may need to rename the file to avoid conflict with the flight controller’s binary file. Then, visit the ESP-tool website and flash it the same way as you did with the flight controller.
However, if you’re using an ESP board other than the default ESP32, go to the repo and download the zip file for the project. When you open the main folder, head to the “src” folder, and open the “tx” file, you’ll see where you need to change the PPM pin. Even though you can make the changes here, you’ll still need to flash the firmware to the board, and to do that, open Visual Studio Code and the PlatformIO extension within the editor. If you don’t have either, I’ve linked tutorials on how to install them at the top of this blog. For PlatformIO, you’d usually find it in the extensions tab through a search and be able to install from within the editor.
To open the project, make sure you’re in PlatformIO, click “Pick a Folder”, select it, and you should see it appear in the top left under the name “ESP-NOW-RCLINK-TX”. Before proceeding, it’s important the project’s “platformIO” file opens up and is found in the folder. Then, head to “tx.cpp” in the src folder and on line 9, change “PPM_PIN” to 12, 3, 4, or whatever GPIO pin you’ve wired it to.
Afterward, head to the platformIO file. This is where you define your ESP board with its platform, board, and framework. If you’re using an ESP board other than the one I’m using, head to the PlatformIO tab, under boards, search and locate it, copy these lines as your board ID:
“platform = espressif32
board = seeed_xiao_esp32s3
framework = arduino”
And paste them (without the “”, of course) in a custom board section similar to this:
; ---------------- XIAO ESP32-S3 Sense env ----------------
Once that’s set, compile it with the command “pio run -e your_board_name” in that format. Type this line into the terminal and hit enter on your keyboard to compile the firmware, and once successful, upload it to your board with the command “pio run -e your_board_name -t upload”, and it will automatically find the COM port your board is connected to and flash to it.
12. ESP-NOW Controller Setup
Now you can unplug the TX link from your computer and connect it up to the 5-pin header row in your controller’s JR bay.
It’s worth checking the pinout on your exact controller in case it differs from mine. So essentially, it gets powered from the battery’s supply through the regulator, but only when the controller is configured for communicating with an external transmitter which we’ll do now. You may shut the cover while allowing the antenna to protrude, power on the controller, and go into model select.
Right now, it’s using the internal ELRS transmitter module, but in “Model Select”, you need to scroll down and create a new model, automatically selecting it. Then, hit the “Page” button, and use the scroll wheel to enter “ESP-NOW” as the name to identify the protocol.
Hit the return button, scroll down all the way to where it says “External RF” and enable it to use PPM - check the channels range from 1 through 8. Hit the “Page” button until you get to “Mixes” where you’ll set up the AUX channels such as for arming the drone. Highlight the “Source” selector, click it, flick the toggle switch you want to use for arming, and select it. Then, scroll down to “Switch”, flick the toggle switch to the armed position, and select it to have the mode activated at this point.
Exit out with the “Return” button on the controller and confirm it highlights when the switch is fully up. Then you may repeat this for the other modes you’d like such as Beeper, Angle, and Airmode. Flick each switch to confirm each activate at your desired position.
Hit the “Page” button until you end up back at the models page and select “ESP-NOW” - the model we finished setting up. Return back to the main screen and you should see it labeled as the one that is in use.
Connect your drone back to Betaflight, in the “Receiver” tab, select “SPI Rx (e.g. built-in Rx)” as the Receiver Mode, “NRF24_V202_250K” as the SPI Bus Receiver Provider, and adjust the channel map to “AETR1234” or the one that corresponds to your input, then hit Save and Reboot. And again, check that each channel matches what it’s supposed to do.
On the other hand, let’s say you want to build a 100% ESP-NOW-based controller for your drone like friends of mine Raja and Nikhil did from the ConnectRobo team, then you may want to check out their GitHub repository for the code, parts list, and project instructions for their drone setup here: https://github.com/nikhiltelase/mini-esp-now-rc-drone
Back to the configurator, the “Modes” tab remains the same as with the ELRS setup, the “Adjustments” tab does nothing, and getting tuning presets in “Presets” for your quad won’t work either - and it’s not worth trying, as these features aren’t supported by the firmware yet.
In the “Failsafe” tab, the only option is for the quad to “Drop” in cases like the battery running out. Because if you try enabling something like “Land”, and save the changes, it will default back to the “Drop” procedure.
13. Blackbox Logging
Fortunately, Blackbox is supported for logging your flight.
Go to the “Blackbox tab” and select “Onboard Flash” as the Logging Sequence, 1 kHz as the Logging Rate, and choose your Debug Mode to track those specific metrics. Click Save and Reboot for the changes, make a quick test flight, reconnect your quad, and click “Save Flash to File” to download the blackbox logging file (.BBL) and play it back in something like the online Betaflight Blackbox Explorer: https://blackbox.betaflight.com/
Click on “Open Log File” to upload your file, and you should get an interface as such where you can select a specific log and play it back logging data like motor speeds, stick positions, and the drone’s orientation. Back in Betaflight, in the “Modes” tab, you can enable “Blackbox Erase” as a mode, and in the “Configuration” tab - enable the beeper to notify you of the erase or simply erase the flash in the “Blackbox” tab to reset it for your next logging session.
Keep in mind, you only get so much flash on an ESP32 to store such data (2.9 MB on ESP32S3).
14. PID Tuning
Now, let’s tune the quad.
First, let’s get it flying stable through adjusting trims for yaw, pitch, and roll. Flick the switch to enable Angle mode - the self-leveling flight mode, power up your quad where it’s nice and level, arm it and take off. If you notice it drifting in one direction, press the relevant trim button on the controller in the opposite direction to correct it. Keep correcting it in angle mode until it can fly level.
Great! Now, let’s connect it back to Betaflight and tune the PIDs to achieve the desired stability.
With default PIDs set, flying it feels like it’s trying to compensate for a bigger quadcopter and that doesn’t feel stable - let’s fix that.
First, to give you a basic understanding of the effects in the drone from the changes in PIDs.
Play around with “P” a.k.a. the corrective spring effect on both pitch and roll - lower it to about 10 and you’ll see your drone behave like it wants to tip over, not enough corrective force, preventing it from ever gaining stability. Now lift the “P” values to 100, and the drone is given enough correction, providing the stability required to fly. Anything higher may create overshoot.
Now for the “D” values a.k.a. the term that provides damping and anticipates future error - set both to 0 and you’ll notice your drone oscillates more frequently after quick movements. Set both “D”s to 80 and you’ll notice much smoother handling when flying side to side. Ppersonally, 20 works good, as when I move the sticks more aggressively, I can make the drone more snappy for sharper turns.
Now for the “I” value - which acts like a memory of all errors to eliminate persistent issues, such as the drone drifting due to a steady breeze or a weight imbalance, lower it to 10, and you’ll notice that it has a hard time stabilizing after the series of rough movements. Lift both “I” values to 100, and you’ll notice it compensates for the persistent back and forth movements I’m making by smoothening out the motion much quicker. My preference is 45 for both the “I” values as the perfect balance for my size drone to maneuver well.
In the image, you see the PID values I landed on for my 50mm quad, but yours may differ depending on the size and other aspects of your quad.
Switch to the “Rateprofile Settings” tab to tune the rates, keep in mind that adjusting them doesn’t seem to make a difference in responsiveness when the drone is in Angle mode, only when you switch back to Acro. Lowering all values on pitch and roll makes the quad nearly unresponsive. My dramatic stick movements barely make it go where I want it to.
However, if you raise the Center sensitivity, rate, and the expo values high enough, you’ll get the responsiveness you need - higher values than normal are needed on a tinier quad like mine.
With these settings saved, it’s a lot more stable and maneuverable as a micro ESP quad controlled with a proper radio controller.
15. Flight Tests
Let’s give it some more airtime to see what it’s capable of now, having this new firmware.
Angle mode: exactly how you fly most toy drones - it’s beginner-friendly, and moving the pitch and roll stick makes it go the intended direction with angle limits. What sets the mode apart is it uses not only the gyro, but also the accelerometer to self-level when you let go of the pitch and roll stick.
Acro mode, short for acrobatic. It’s how most FPV drone pilots fly their drones - allowing for complex maneuvers like flips and loops in mid air. Using the gyro only, it gives you complete manual control with no angle limits by having the sticks control the rate of rotation rather than the angle of the drone. When the stick is moved and released, the drone continues to rotate at that constant rate until you correct it by moving the stick in the opposite direction.
Airmode is actually a feature added on top of Acro mode helping maintain the quadcopter’s stability and control during maneuvers, adjusting motor speeds even when the throttle is low. I find Airmode makes doing flips much easier than on Acro alone. You may not see it now, but you’ll certainly feel the difference when trying to do flips.
Even though I mentioned this already in the ESP-FLY drone’s tutorial, you guys keep asking me about the flight time on this drone, which is five and a half minutes on a 250mAh cell - when the battery starts going low, it warns you via this blinking LED - if ignored, it runs out eventually and drops like it’s supposed to do according to the failsafe programming.
The range used to be 50 meters on Access-point WiFi controlled from my phone and now goes up to roughly 200 meters from the transmitter via ESP-NOW. With the ELRS receiver, you may get several kilometers of range, but since I don’t see the point for my tiny drone which goes out of sight at 50 meters, I stick with the convenient ESP-NOW protocol using the built-in receiver the ESP32 already has.
16. FPV Camera Support
If you want to add an FPV camera with a VTX, keep in mind that for now, only the TBS SmartAudio protocol is supported for Video Transmitter control and you’d need to set up a dedicated UART for it in the ports tab. Once you do, then you should be able to configure the usual settings in the “Video Transmitter” tab.
To have your On-screen Display (OSD) overlay with flight info, keep in mind it’s not implemented in the project, but you can use an external OSD module called the MinimOSD wired to the system, running a firmware called MW_OSD, short for MultiWii OSD. If you’re keen on implementing this, learn more about it reading the documentations here below.
To keep it simple, you can just use a basic camera + VTX unit like this WT05 5.8gHz, 3-gram AIO cam I’ve used for all my micro drones: https://amzn.to/3XYBlPD
To the ESP-FLY, it attaches using this cover mount and gets powered directly from the 3.7V battery - I show how to properly install it in the ESP-FLY tutorial video. You watch the feed as you fly from a 5.8gHz FPV headset like my Fatshark Scout/Echo: https://amzn.to/4p4DRA5
Pairing it is easy. Hold down on your headset’s “Scan” or “Auto Search” button to find the channel the camera is on, and its feed should appear on the display right away.
Now, let’s fly this micro drone in first person view!
17. Conclusion
That's how you fly a Betaflight-enabled ESP32 drone with a hobby-grade radio controller!
This is just the beginning - upgrades like GPS, Altitude Hold, and more are still on the way - says the code author who is actively developing new features. So, if you want to see future updates to esp-fc by rtlopez, the link is below to support him and grab the firmware.
And if you want to build the micro drone I used in this tutorial to fly with this firmware, go check out my ESP-FLY drone tutorial next - it walks you through the entire assembly step-by-step.
Veuillez saisir votre adresse électronique. Les instructions de réinitialisation de votre mot de passe vous seront immédiatement envoyées par courriel.
Discussion (0 commentaire(s))