How To BuildFlying Mosquito

Same as Dusty: a wrong or missing part gets found now, not on build day. Four numbers in the 3D model are guesses until we measure.

1. Check every part against the shopping list. Write what arrived and what did not.The drone and module ship from India, so they may come separately.
2. Measure with calipers: how far the motor sticks out under the board, how high the props sit, the battery size, and how far the module hangs down once it is plugged in.Write all four in the journal. They go into the 3D model.
3. Weigh the drone, one battery, and the module.The weight table uses 45, 16 and 8 g until now.
4. Look at the battery plug and the + and - marks on the board next to it. Do they match?If not, a grown-up swaps the two pins in the plug. Never force it.

Journal: the date, what arrived, the numbers you measured, and anything different from the plan.

Prove the drone works before anything gets changed. If it will not fly now, it is the drone, not our parts.

1. Charge a battery on the drone by USB-C. The FULL light comes on when it is done.Or use the battery charger that came with the pack.
2. Set the drone on a flat floor, plug in the battery, switch it on, and leave it still until the green light blinks fast.Slow green blinking means it is calibrating. Do not touch it.
3. Install the LiteWing app, join the drone WiFi, and hover for 2 minutes in an open room.Low and slow. Guard is not on yet, so a grown-up flies and everyone stands back.
4. Land, unplug the battery.

The positioning module needs newer firmware on the drone. Firmware is the program that lives inside the drone.

1. Open the LiteWing web flasher in Chrome, plug the drone in by USB-C, and flash the positioning module firmware.Battery unplugged while flashing.
2. Check the drone has female headers underneath. If not, a grown-up solders four 6-pin headers on.Straight up, flush to the board.
3. Plug the module in underneath, arrow pointing at the USB-C port, pressing evenly on both sides.No bent pins.
4. Power up. The module's 4 lights flash once.If the drone does not start, power off and check the arrow.

A 10 minute print tells us which motor collar size grips best before the 33 minute guard gets printed.

1. Print plate 1, the fit check.Any color.
2. Take one motor out of the drone and slide it into each collar: 1 notch is 7.0 mm, 2 notches 7.2 mm, 3 notches 7.4 mm.The right one grips firmly and does not split.
3. Push the arcade button through the big hole and the light sensor into the pocket.
4. Tell the grown-up the winning collar size. It goes into the guard model before plate 2 prints.

Journal: which collar won and how it felt in the other two.

Three small prints: the guard, the white window, and the body. Then weigh them, because every gram counts.

1. Plate 2: prop guard and legsPrints upside down, fence on the bed. Dark gray or black.About 33 minutes · about 7 g
2. Plate 3: hit windowMust be WHITE PLA so the laser dot makes the face glow.About 9 minutes · about 3 g
3. Plate 4: mosquito bodyStands on its front, tail up. Dark gray or black.About 26 minutes · about 5 g

1. Download the .3mf plate files from the Build page and send them to the Adventurer 5M.The settings are inside: 0.2 mm layers, brim, no supports.
2. Peel off the brims carefully. The guard fence is thin.
3. Weigh each part and write it in the weight table.Targets: guard 6.9 g, window 2.6 g, body 5.5 g.

The body with the white window

Journal: the real weights next to the targets.

Our math says the four props push about 120 g and the full drone weighs about 87 g. The experiment checks if the math is right.

1. Test A, the push test: strap the drone to a heavy block on a kitchen scale, zero it, and a grown-up runs the motors at 25, 50, 75 and 100% for 3 seconds each.The scale reads below zero. That number is the push in grams.
2. Test B, the hover test: hover 30 cm off the floor until the low-battery light, with 0, 2, 4, 5, 6 and 7 nickels taped to the middle. Three flights each.The laptop logs battery voltage and motor power.
3. Fill in the data sheet and draw the two graphs.Minutes vs grams added, and push at each power level.
4. Use the decision rules to pick: keep Rev A, go lighter, or bigger props.

import time, cflib.crtp
from cflib.crazyflie import Crazyflie
URI = "udp://192.168.43.42"          # the LiteWing address on its own WiFi
cflib.crtp.init_drivers()
cf = Crazyflie(); cf.open_link(URI); time.sleep(1)
cf.commander.send_setpoint(0, 0, 0, 0)  # unlock
for pct in (25, 50, 75, 100):
    thrust = int(10000 + (60000 - 10000) * pct / 100)
    t0 = time.time()
    while time.time() - t0 < 3:      # keep sending, or the drone stops
        cf.commander.send_setpoint(0, 0, 0, thrust); time.sleep(0.05)
    cf.commander.send_setpoint(0, 0, 0, 0); input(f"{pct}%: read the scale, press Enter")
cf.close_link()

Journal: every flight time, the push numbers, the graphs, and the conclusion.

The floor camera sees movement by watching the floor slide by. A plain or shiny floor gives it nothing to see, and the drone drifts.

1. Glue a printed high-contrast pattern (checkers, dots, or a newspaper page) onto poster board.Matte paper, not shiny.
2. Pop up the bug habitat. Roll the front panel up and pin it open.The open side faces where the turret will sit, 3 feet away.
3. Lay the mat on the habitat floor and the launch pad on top when it is printed.Until then, the drone starts on the mat.

The laptop sends "stay at 40 cm, do not move" 10 times a second, and the drone uses its floor camera and range finder to obey.

1. Install Python and the Crazyflie library (cflib) on the laptop. Join the drone WiFi.pip install cflib
2. Guard on, battery in, drone on the mat, facing the open side of the net.
3. Run the hover script: take off to 40 cm, hold 20 seconds, land.Measure how far it drifts with a ruler taped to the mat.
4. Then run the pattern script: a slow square and a figure eight at 0.2 m per second.If it drifts out of the zone, the script lands it.

import time, cflib.crtp
from cflib.crazyflie import Crazyflie
from cflib.crazyflie.syncCrazyflie import SyncCrazyflie
URI, HEIGHT, SPEED = "udp://192.168.43.42", 0.4, 0.2   # meters, meters per second
cflib.crtp.init_drivers()

def hold(cf, vx, vy, z, seconds):
    for _ in range(int(seconds * 10)):           # 10 times a second
        cf.commander.send_hover_setpoint(vx, vy, 0, z)   # yaw rate 0: window keeps facing the turret
        time.sleep(0.1)

with SyncCrazyflie(URI, cf=Crazyflie()) as scf:
    cf = scf.cf
    cf.commander.send_setpoint(0, 0, 0, 0)       # unlock
    for i in range(1, 21):                       # climb over 2 seconds
        hold(cf, 0, 0, HEIGHT * i / 20, 0.1)
    for vx, vy in [(SPEED, 0), (0, SPEED), (-SPEED, 0), (0, -SPEED)] * 3:
        hold(cf, vx, vy, HEIGHT, 2)               # 40 cm each side
    for i in range(20, 0, -1):                   # come down slowly
        hold(cf, 0, 0, HEIGHT * i / 20, 0.1)
    cf.commander.send_stop_setpoint()

Journal: how far it drifted each time.

Three short wires from the sensor, two from the battery. Everything stays inside the body.

1. Solder 3 thin wires to the light sensor: VIN, GND, OUT. Heat shrink each joint.About 6 cm long.
2. Solder VIN to the XIAO 3V3 pin, GND to GND, OUT to A0 (also marked D0).See the wiring map.
3. Solder two wires to the BAT+ and BAT- pads under the XIAO, and the other ends to the + and - pins on the back of the drone's battery plug.Red to +. Check twice before any battery goes in.
4. Press the sensor into the pocket on the body's front wall, face out. XIAO flat on the floor, USB-C toward the tail slot.A dot of hot glue on each wire where it leaves the board.

The XIAO learns how bright the room is, then shouts HIT when the light jumps. It waits 1 second before it can shout again, like the MS-2000.

#include <WiFi.h>
#include <WiFiUdp.h>
const char* SSID = "LiteWing_xxxx";   // the drone WiFi name
const char* PASS = "........";        // and password, from the LiteWing guide
const int JUMP = 150;                 // how big a jump counts as a hit: set in the flashlight test
WiFiUDP udp; long base = 0; unsigned long lastHit = 0;

void setup() {
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) delay(200);
  for (int i = 0; i < 200; i++) { base += analogRead(A0); delay(5); }
  base /= 200;                        // normal room light
}

void loop() {
  int v = analogRead(A0);
  if (v > base + JUMP && millis() - lastHit > 1000) {
    udp.beginPacket(IPAddress(192, 168, 43, 255), 5005);   // shout to everyone on the drone WiFi
    udp.print("HIT"); udp.endPacket();
    lastHit = millis();
  } else if (v < base + JUMP / 2) {
    base = (base * 31 + v) / 32;      // slowly follow the room light
  }
  delay(5);                           // 200 checks a second
}

1. Flashlight test: flick a flashlight across the white window. The laptop shows HIT.
2. Now the real laser (grown-up turns it on): point the MS-2000 laser at the window. HIT every time.If it misses, make JUMP smaller. If it shouts HIT with no laser, make JUMP bigger.

Journal: the JUMP number you picked and why.

Guard, body, window, wings. Then weigh the whole thing.

1. Push the guard collars up onto the motor cans from below, slits facing the middle so the motor wires pass.Feet point down.
2. Thread the battery strap through the tunnel in the body floor, set the body on the battery, strap it all to the drone.The white window points forward.
3. Plug the white window into the front of the body. Glue it only after step 10 works.
4. Cut two small wings from clear report-cover plastic and glue them on top of the body.Tiny and light, so they do not catch the prop wind.
5. Weigh the whole drone with the battery.Target: about 87 g.

From above: guard around all four props, body in the middle

Three bigger prints. Good for overnight.

1. Plate 5: launch padFour cone cups catch the guard feet. The arrow points at the turret.About 1 hour 16 minutes · about 56 g
2. Plate 6: control boxPrints top down.About 2 hours 16 minutes · about 90 g
3. Plate 7: box floorPi posts and the power bank cradle.About 54 minutes · about 40 g

The Pi is a small Linux computer. It joins the drone WiFi like a phone would, and runs the flight script by itself when it turns on.

1. Use Raspberry Pi Imager to put Raspberry Pi OS Lite on the microSD card. In the settings, type in the drone WiFi name and password, and turn on SSH.
2. Boot the Pi, log in from the laptop, and install the library: pip install cflib pyserial gpiozero.
3. Copy the flight script (step 16) to the Pi and set it to start at power-on.A small systemd service called flymo.
4. Screw the Pi onto its four posts on the box floor.M2.5 x 6.

Follow the control box wiring map.

1. Power bank into its cradle, ports toward the right wall. USB-C panel port through the right wall, its cable into the bank.
2. Bank USB-A into the switch cable, switch cable into the Pi PWR port. Clip the switch into the left wall slot.
3. OTG cable into the Pi USB port, micro:bit cable into it, micro:bit snapped face up under the top window.
4. GO button into the round hole. Jumper wires: switch to GPIO 17 and GND, light to GPIO 27 and GND.Pins 11, 9 and 13.
5. Screw the floor on: 4 x M2 x 8.

Whatever the Pi sends over USB, the micro:bit radios on group 7, the same words the MS-2000 wand uses. It also counts hits and saves each run.

Journal: a screenshot of your code.

One script on the Pi ties it all together. It waits for the button, flies the run, passes every HIT to the micro:bit, and lands.

import socket, time, serial, threading
from gpiozero import Button, LED
# ... hold() and the pattern from step 8 ...
button, light = Button(17, hold_time=1.5), LED(27)
mb = serial.Serial("/dev/ttyACM0", 115200)          # the micro:bit
say = lambda word: mb.write((word + "\n").encode())
hits = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); hits.bind(("", 5005))

def listen():                                        # HIT from the XIAO -> micro:bit
    while True:
        data, _ = hits.recvfrom(16)
        if data == b"HIT": say("HIT")
threading.Thread(target=listen, daemon=True).start()

while True:
    light.on(); button.wait_for_press(); light.off()
    if battery_volts() < 3.8: light.blink(); continue   # too low to fly a full run
    say("GO"); fly_run(seconds=30); say("STOP")         # button.when_held lands right away

1. Drone on the pad, battery in, box switched on, wait for the GO light.
2. Press GO. It takes off, flies the pattern for 30 seconds, and lands on the pad.
3. Hold GO for 1.5 seconds during a flight: it lands right away.Practice this before anything else.

An engineer does not trust one good flight. Twenty in a row shows if it really works.

1. Fly 20 runs. For each one, write: landed on the pad? crashed? how many flashlight hits sent and received?Swap batteries between runs.
2. Anything that fails twice gets a fix and a line in the history log.If the fix changes a part, it needs a change order.

Journal: the 20 results in a table.

The fun part. Can the turret hit something that flies by itself?

1. Teach the MS-2000 camera the flyer: Object Tracking, learn it hovering in the net.This replaces the stuffed mosquito it learned.
2. Turret 3 feet from the net, laser armed by a grown-up. Run 10 flights of 30 seconds.The box micro:bit sends GO, so the turret starts its run.
3. Count hits and the time to the first hit, the same numbers as the MS-2000 experiment.
4. Teach the camera the stuffed mosquito again when you are done.The fair demo uses the stuffed mosquito.

Journal: hits per run and time to first hit, next to the MS-2000 results.