I fixed some DRC violations.
Most of them were caused by me needing to shrink the default trace sizes for that one sensor.
Four errors remain, which I likely won’t bother fixing since they’re just courtyard violations of the esp32s3’s antenna, which is not that integral to my project.
Routed (most of) the Flight Controller.
It may not look like much, but it was a lot of suffering.
To start off, the magnetometer I’m using has the most annoying package I’ve encountered yet. There are pins buried deep inside the center of it, and I had to adjust trace and via sizes to accommodate for them. I ended up using the absolute minimum sizes that JLCPCB has to offer.
Secondly, the radio module I’m using, which could not be moved or oriented differently, has a seriously unlucky pinout, and I ended up needing vias for almost every pin for it. Consequently, most other pins of the other sensors needed vias too, since they had to pass through or be connected to it.
I ended up with the worst PCB layout I’ve ever seen. (To be fair, I haven’t seen many PCB layouts, so it probably isn’t as bad as I make it sound)
I think it works though, I just need to spend like a day checking over it, and also route the remaining things, which are just ground planes, and power traces.
I also cost optimized my board a little by reducing the assortment of header pins, so most of them will use the same parts, reducing JLC’s unique extended component fee.
Here are some takeaways
I did more component placing. I think it’s almost ready to route, but I want to make sure I didn’t make any mistakes, namely using a forbidden pin.
I also did some component testing with the parts I already have, such as seeing if multiple motors could run at once, while the radio was transmitting, etc.
Before continuing with the PCB, I wanted to do a quick and stress free session where I tested firmware that would make the motors run.
Safe to say, it was not quick and stress free.
I initially tested the servo code on a mini mg90 servo since it was safer than testing with the esc which is powered by a big scary LiPo battery. I wasted 45 minutes with the firmware only to learn that the battery pack I used was drained. (All 4 AA batteries fell to 0.9v…)
Then I managed to get the espservo library to work, but for some reason it kept crashing the entire code whenever I tried using pinMode(). I still don’t know why that happened.
I switched to controlling the servo using the ledc api instead, which worked much better, and was quite fun to figure out. After succeeding in moving the mini servo, the ESC + motor gave me some issues. For safety purposes, ESCs have to be armed before they spin. To learn exactly how to calibrate it, I dug up a datasheet of the ESC, and finally got the ESC to spin the motor.
Overall I learned:
I started working on component placements of the PCB.
It was harder than I thought it would be.
Firstly, I had over-estimated the size of flight controllers in general, so I had less space to work with as anticipated.
Secondly, I forgot to add some decoupling capacitors in the schematic, so after doing so, I had much more components to wire.
Thirdly, the connectors were bigger than I thought, especially the ones for the radio module I plan to attach to it.
I’m still deciding some things, such as how big I want the board to be, (I’m thinking somewhere around 50x50mm, excluding the protruding antenna and usb port) and whether the PCB will be a 2 or 4 layer pcb.
I assigned some footprints
Not many interesting things happened, just mostly browsing LCSC and JLCPCB’s parts.
I also spent some effort figuring out how to import footprints from componentsearchengine
I finished the schematic. I still have some warnings to fix, but I’ve reviewed the connections, and they seem correct.
The current schematic has:
I hate working on the flight controller so I decided to work on something else instead. This is supposed to be a webpage that tests drone sensors where you can see the drone’s orientation in real time.
I’ve been dying to try out the web serial api for a while now, but I never got to it. Fortunately, I finally got to use it to receive data from the microcontroller. I managed to make the webpage receive serial data from the receiver that I built in the last devlog.
I took on a little sidequest from working on the schematic of the flight controller. I plan to use a set of nrf24l01’s as the radio, since I already have them. Therefore, I wanted to test them before putting it on the schematic. I hooked one up to a brand new esp32-s3, and the other to an esp32-wroom1.
The process of sending data between each one was relatively straightforward, thanks to a helpful instructable I found. However, I did get some issues with the default SPI pins with the s3, but that got sorted out after some pin switching. Eventually I got the two devices to remotely talk to each other and was overjoyed.
Also somewhere in between all of that, I realized I ran out of male to female jumper wires so that sucks :(
I made some more progress on the flight controller. I may have forgotten some of what I did since the lapse was recorded like a day ago, but I added some connectors to the four escs, and connected most things to the main microcontroller.
I started researching/designing a custom flight controller!
I began by choosing an IMU for it. I was initially going to use an MPU-6500, but learned it was trash for drones. I eventually settled on the BMI270 since it was relatively cheap but still powerful. Another benefit of that chip was that it could be hooked up to a magnetometer, so I looked into the BMM150, which was recommended. I also wasted my time with another random magnetometer that I keep forgetting the name of.
Anyway I added those to the schematic, which wasn’t too bad. I’m pretty new to KiCad so I needed to figure out how to import symbols into it. I discovered the lifesaver known as the componentsearchengine, which is an extensive database of symbols that KiCad or other cad programs may not have.
I also chose a microcontroller for the FC. I wanted to use an ESP32 chip since I’m most familiar with them, and ended up choosing an ESP32-S3 Wroom 1 (mostly arbitrarily)
