Joyce.
aqua feeder the build review 2
22CSU701 (IPCC) · Applied Internet of Things · Mini project · Review 2

Smart Pond Feeder

A boat that feeds fish at fixed spots in a pond, a dock that refills it, and a phone app to watch and control both. This page goes through the ten IoT design steps in order, from why it is needed to the app running.

Nodes 2 × ESP32Boat link ESP-NOW (design) · Wi-Fi HTTP (built)Phone link Wi-Fi · HTTP/JSONCloud Supabase + Vercel, liveRemote control 8 commands, PIN
Updated 3 Nov 2026. Steps 1 to 10 keep the Review 2 design. Slides 11 to 16 show the system as built, with screenshots. Slides 17 to 20 explain the product it is becoming: full autonomy, GPS and the roadmap.
Team
AdityaAnojJoyce MalikKailas ReddyKeshav VKushal Kumar L
Guide
Dr. Smitha Shekar B
Professor, Computer Science and Engineering Programme
Problem

Pond feeding is manual and unmeasured. One 100 × 100 m pond takes ≈20 kg per meal over 400 m of bank.

Idea

A feeder boat drops measured feed at fixed points and returns to a dock that refills it, with water readings adjusting each dose.

Review 2 deliverable

Full IoT design (steps 1–10), wiring, protocols, service API, and a working dashboard simulation of one feeding loop.

In plain words

Right now someone walks the bank of the pond throwing feed by hand, and nobody really measures how much goes in. We replaced the walk with a small boat. It feeds at three marked spots, checks the water temperature and how cloudy it is before each drop, and goes back to a dock that refills its hopper. The farmer watches all of it on a phone, with no internet needed.

What changed since Review 1

The idea did not change: a boat, a dock, a phone app and auto-refill. What we changed was the hardware, making it simple enough to build in two days and still work on demo day.

FunctionReview 1 planReview 2 prototypeReason
PositioningGPS + wheel odometryTimed differential-drive path + V-guide dockingGPS error (2–5 m) is larger than a demo tank
Dispensing25 mm valve + BLDC throw discServo swing flap, gravity drop at each pointNo jamming, no high-current ESC on a small hull
Boat ↔ dock linkNRF24L01+ at 2.4 GHzESP-NOW (built into ESP32)No extra radio module; peer-to-peer with ACK
Power12 V LiFePO42S 18650 (7.4 V) + 5 V buckMatches small motors and servo
HullPaddle boatPVC catamaran, 45 × 30 cmStable, unsinkable, cut in an hour
Phone app, auto-refill, logging, fail-safePlannedKept, now implementedCore of the project
As built: boat ↔ dockESP-NOWWi-Fi HTTP heartbeat, boat found as pondboat.localWorks on a phone hotspot with one network setting
As built: cloudMQTT, plannedHTTPS to Supabase, website on VercelFree tier, no broker to run
As built: controlFixed timed pathDraw any path; remote commands behind a PINFarmer sets the route, not the firmware
01
Step 1

Purpose and requirements specification

What the system is for and what it has to do, written down before we picked any parts.

Purpose

Automatically feed fish in a pond with measured doses at fixed points, adjust each dose to water conditions, refill without a person at the water, and let the farmer monitor and control it from a phone.

Behaviour
  • Auto mode: boat leaves the dock, follows the stored path, drops a dose at each point, returns and docks.
  • Adaptive dose: water temperature and turbidity scale the dose before each drop.
  • Refill: when docked, the dock opens its gate until the boat hopper is full.
  • Manual mode: start, pause, return home, test-drop from the phone.
  • Safe stop: link loss or stop command halts motors and closes both gates.
System management requirement
  • Remote start, pause, home and test-drop.
  • Settings (dose, path timings, thresholds) changed from the app, stored in flash.
  • Live status of both nodes: state, battery, link.
Data analysis requirement
  • Local (on boat): compute dose from temp + turbidity before each drop.
  • Local (on dock): decide refill from hopper level.
  • Logged per event: time, point, grams, temp, turbidity, hopper %.
  • Cloud (planned): daily grams fed, trends.
Application deployment requirement
  • Web app served by the dock ESP32; opens in any phone browser.
  • No internet needed for control (phone joins dock Wi-Fi).
  • Internet only for the optional cloud upload.
Security requirement
  • WPA2 password on the dock access point.
  • ESP-NOW peers paired by MAC; encrypted with a shared key.
  • Commands accepted only from the paired dock.
  • Fail-safe: gates default closed, motors stop on 1 s link silence.
Non-functionalTarget
Dose accuracy±20 % over 5 drops after calibration
Docking success4 of 5 runs end at the limit switch
LinkTelemetry every 500 ms; safe stop after 1 s silence
Endurance≥ 5 complete loops per charge
Water protectionElectronics in a sealed box; hulls float 30 min without ingress
02
Step 2

Process specification

The use cases from step 1, drawn out. One feeding cycle is the main flow and everything else branches off it.

flowchart TD
  A([Farmer taps Start]) --> B{Boat docked?}
  B -- No --> H[Return home]
  H --> B
  B -- Yes --> C{Hopper at least 80 pct?}
  C -- No --> R[Dock opens refill gate]
  R --> C
  C -- Yes --> D[Reverse out, run timed path]
  D --> E{At feed point?}
  E -- No --> D
  E -- Yes --> F[Read temp + turbidity]
  F --> G[Compute dose]
  G --> I[Open flap for dose ms, close]
  I --> J[Send FED event, log]
  J --> K{Last point?}
  K -- No --> D
  K -- Yes --> L[Drive into V-guide]
  L --> M{Limit switch pressed?}
  M -- No --> L
  M -- Yes --> N([Docked, cycle done])
  D -. link lost 1 s .-> S[Safe stop: motors off, flap shut]
Use caseActorTriggerOutcome
UC1 Run feeding cycleFarmer / scheduleStart in app or set timeThree doses delivered, boat docked
UC2 Auto-refillDock nodeBoat docked and hopper < 80 %Hopper filled, REFILL_DONE sent
UC3 Adaptive doseBoat nodeArrival at feed pointDose scaled by temp and turbidity
UC4 MonitorFarmerOpens appLive state, hopper %, water data, event log
UC5 Manual controlFarmerPause / Home / Test dropCommand executed, acknowledged
UC6 Fail-safeEither nodeLink loss, stop button, low batteryMotors off, gates shut, alert in app
03
Step 3

Domain model specification

The things in the pond and the things we build around them, with no technology chosen yet. Drawn as UML.

classDiagram
  direction LR
  class PhysicalEntity_Pond
  class PhysicalEntity_Hopper
  class PhysicalEntity_Water
  class VirtualEntity_Pond
  class VirtualEntity_Hopper
  class VirtualEntity_Water
  class Device_BoatNode
  class Device_DockNode
  class Resource_FlapServo
  class Resource_DriveMotors
  class Resource_TempSensor
  class Resource_TurbiditySensor
  class Resource_RefillServo
  class Resource_LimitSwitch
  class Service_Feed
  class Service_Navigate
  class Service_Refill
  class Service_Monitor
  class User_Farmer
  PhysicalEntity_Pond <-- VirtualEntity_Pond : represents
  PhysicalEntity_Hopper <-- VirtualEntity_Hopper : represents
  PhysicalEntity_Water <-- VirtualEntity_Water : represents
  Device_BoatNode --> Resource_FlapServo : hosts
  Device_BoatNode --> Resource_DriveMotors : hosts
  Device_BoatNode --> Resource_TempSensor : hosts
  Device_BoatNode --> Resource_TurbiditySensor : hosts
  Device_DockNode --> Resource_RefillServo : hosts
  Device_DockNode --> Resource_LimitSwitch : hosts
  Service_Feed --> Resource_FlapServo : exposes
  Service_Navigate --> Resource_DriveMotors : exposes
  Service_Refill --> Resource_RefillServo : exposes
  Service_Monitor --> Resource_TempSensor : exposes
  User_Farmer --> Service_Monitor : uses
  User_Farmer --> Service_Feed : uses
Physical entities

Pond, boat hopper (feed stock), dock hopper, pond water.

Virtual entities

Digital pond (path + feed points), hopper level, water state, boat state.

Devices

Boat node (ESP32 on the water), dock node (ESP32 on the bank).

Resources

On-device: flap servo, drive motors, temp probe, turbidity sensor, refill servo, limit switch. Network: dock web server.

Services

Feed, Navigate, Refill, Monitor, Configure.

User

Farmer, through the phone browser.

04
Step 4

Information model specification

Each virtual entity from step 3 gets its fields. Those fields turn into the packet layout, the API and the log.

classDiagram
  direction LR
  class Boat {
    +string state
    +int pathStep
    +float batteryV
    +bool linkOk
  }
  class Hopper {
    +int levelPct
    +float gramsLeft
    +int lowLimitPct = 30
  }
  class Water {
    +float tempC
    +int turbidityRaw
    +bool turbid
  }
  class FeedPoint {
    +int id
    +int afterStep
    +int baseDoseMs = 300
  }
  class FeedEvent {
    +long ts
    +int pointId
    +int doseMs
    +float grams
    +float tempC
    +int turbidityRaw
  }
  class Dock {
    +bool docked
    +string refillState
    +int refillMs
  }
  class Settings {
    +int[] pathMs
    +int pwmPct
    +float gPerMs
    +float coldC = 22
  }
  Boat "1" --> "1" Hopper : carries
  Boat "1" --> "1" Water : senses
  Boat "1" --> "3" FeedPoint : visits
  FeedPoint "1" --> "*" FeedEvent : produces
  Dock "1" --> "1" Boat : coordinates
  Dock "1" --> "1" Settings : stores
ESP-NOW messageDirectionFields (packed struct)Rate
TELEMBoat → Dockstate, pathStep, levelPct, tempC, turbidityRaw, batteryVevery 500 ms
FEDBoat → DockpointId, doseMs, grams, tempC, turbidityRawper drop
CMDDock → Boatcmd (START | PAUSE | HOME | TEST_DROP | STOP), argon demand
DOCKEDDock → Boatlimit switch stateon change
REFILL_DONEDock → BoatrefillMsafter refill
05
Step 5

Service specification

What each service does, what goes in and out, and how often it runs. They come from the process in step 2 and the information model in step 4.

ServiceTypeRuns onInputOutput / effectSchedule
NavigationNativeBoatPath array, PWM %Motor commands; pathStepContinuous in RUN/RETURN
Feed (drop)NativeBoatdoseMs from Dose serviceFlap 0° → 80° → 0°; FED eventAt each feed point
Dose adjustNative (analysis)BoattempC, turbidityRaw, baseDoseMsdoseMs = base × f(temp) × f(turbidity)Before each drop
RefillNativeDockLimit switch, levelPctGate open/close; REFILL_DONEWhen docked and level < 80 %
MonitorWeb (REST)Dock—GET /api/state JSONPolled every 1 s by app
ControlWeb (REST)Dock{"cmd":"start"}POST /api/cmd → CMD packetOn request
LogWeb (REST)Dock—GET /api/log last 50 events (CSV in flash)On request
ConfigureWeb (REST)DockSettings JSONPOST /api/settings, synced to boatOn request
Fail-safeNativeBothLink watchdog, stopMotors off, gates shutAlways on
Cloud uplink plannedMQTT publishDockFED, TELEMTopic pond/1/eventsPer event
// GET /api/state  →
{
  "boat": {"state":"RUN","step":4,"batteryV":7.62,"link":true},
  "hopper": {"levelPct":71,"gramsLeft":710},
  "water": {"tempC":26.4,"turbid":false},
  "dock": {"docked":false,"refill":"IDLE"},
  "fedToday_g": 34.5
}
// Dose adjust service (boat)
int doseMs(float tC, bool turbid){
  float f = 1.0;
  if (tC < S.coldC) f *= 0.7;   // fish eat less in cold water
  if (turbid)       f *= 0.7;   // uneaten feed or poor water
  return (int)(S.baseDoseMs * f);
}
// grams = doseMs * S.gPerMs   (calibrated)
06
Step 6

IoT level specification

We sit at level 5: one end node that senses and acts, and one coordinator that gathers its data and serves the app. Uploading the coordinator's data to the cloud completes level 5. Level 6 is where it would go at scale.

1Single node, local store and analysis
2Single node, cloud storage
3Single node, cloud analysis
4Many nodes, local analysis, cloud store
5End nodes + coordinator → cloud
6Many independent nodes, central controller, cloud analytics
End node · Boat sense: temp, turbidity act: flap, motors local: dose analysis ESP-NOW Coordinator · Dock collects, refills, logs web server · REST gateway: ESP-NOW ↔ IP Wi-Fi / HTTP App · Phone browser monitor, control, settings, event log Cloud (MQTT) · planned
LevelFit for this projectStatus
1Boat alone can run a loop and log locallymet
2–3Single-node cloud patterns; we have two nodesnot used
4Nodes analyse locally; no separate coordinatornot used
5Boat = end node, dock = coordinator collecting and forwardingselected
6Several boats, dock as central controller, cloud analyticstarget
07
Step 7

Functional view specification

The functional groups of the IoT logical design, and which parts of our system do each job.

Application Phone web app: status, start/pause/home, test drop, settings, event log Management settings inflash, sync,battery, state Security WPA2, ESP-NOWencryption,MAC pairing,fail-safe stop Services Navigation · Feed · Dose adjust · Refill · Monitor · Control · Log · Configure Communication ESP-NOW (boat ↔ dock) · Wi-Fi AP + HTTP/JSON (dock ↔ phone) · MQTT (planned) Device Boat ESP32: flap servo, 2 motors (TB6612), DS18B20, turbidity · Dock ESP32: refill servo, limit switch
08
Step 8

Operational view specification

The actual choices for each group: how the system is deployed and how it runs.

Functional groupOperational choice
Devices2 × ESP32 DevKit (30-pin). Boat: SG90/MG90S flap servo, 2 TT motors on TB6612FNG, DS18B20, analog turbidity sensor, 2S 18650 + 5 V buck. Dock: MG90S refill servo, lever limit switch, 5 V USB adapter.
Communication — link layerESP-NOW over 802.11 at 2.4 GHz (boat ↔ dock); 802.11 Wi-Fi AP on the dock (phone).
Communication — network / transportIPv4 on the dock AP at 192.168.4.1, TCP for HTTP. ESP-NOW is connectionless with MAC-layer ACK.
Communication — applicationHTTP REST with JSON (request–response). ESP-NOW structs (exclusive pair). MQTT publish (planned).
ServicesNative firmware services in C++ (Arduino framework); REST services on WebServer library on the dock.
ApplicationSingle-page HTML/CSS/JS app stored in dock flash, served at http://192.168.4.1.
Database / storageCSV event log in dock flash (LittleFS); settings in NVS (Preferences). Cloud store planned.
ManagementSettings page writes NVS and pushes to boat; serial monitor for debugging.
SecurityWPA2-PSK on AP; ESP-NOW encryption with PMK/LMK; accept packets only from paired MAC; 1 s link watchdog.
Communication models used
  • Request–response: phone ↔ dock REST.
  • Exclusive pair: dock ↔ boat ESP-NOW, bidirectional, persistent peers.
  • Push–pull: navigation pushes feed jobs; feed service pulls when free.
  • Publish–subscribe: dock → MQTT broker (planned).
Dock as an M2M gateway

The boat speaks ESP-NOW only (non-IP). The dock translates its packets into REST/JSON for the phone and back, so the whole boat appears behind one IP address.

09
Step 9

Device and component integration

Where each component sits and how it is wired.

ESP32 box 2S pack hopper + flap over slot FRONT → dock 45 × 30 cm · slot 6 cm · hulls 63 mm PVC
ComponentPlacement
Hopper + flapCentre, over the slot
ESP32 boxFront-left, sealed
BatteryRear-right, low
MotorsRear tip of each hull
SensorsFront beam, hanging in water
Dock hopper + spoutOn PVC arm, 3 cm above boat hopper when docked
Limit switchNarrow end of the V-guide
2S 186507.4 V Switch Buck → 5.0 V TB6612FNG PWMAAIN1AIN2PWMBBIN1BIN2STBYVCC AO1AO2BO1BO2VM M-L M-R Boat ESP32 G25G26G27G32G33G14G43V3VIN G13G18G34 Flap servo+ 470 µF across 5 V DS18B204.7 kΩ pull-up divider Turbidity≤ 4.5 V → ≤ 3.3 V ⏚ all grounds joined
Boat pinToInterface
G13Flap servoPWM 50 Hz
G25 G26 G27PWMA AIN1 AIN2PWM + GPIO
G32 G33 G14PWMB BIN1 BIN2PWM + GPIO
G4STBYGPIO
G18DS18B201-Wire
G34TurbidityADC1
Dock pinToInterface
VIN / GND5 V USB adapterPower
G13Refill servoPWM 50 Hz
G23Limit switch → GNDGPIO, INPUT_PULLUP
G2Onboard LEDDocked / refilling
Wi-FiAP "PondFeeder", WPA2802.11
10
Step 10

Application development

The phone dashboard, running against a simulated boat. Change the water readings and watch the dose at each feed point change.

PondFeeder · 192.168.4.1DOCKED
Hopper25%
Fed this loop0.0 g
Next dose300 ms
LinkOK
27 °C
20
// Boat firmware structure
setup(): servo, motors, sensors, ESP-NOW peer(dock)
loop():
  readSensors()            // every 500 ms
  sendTelem()              // TELEM to dock
  switch(state):
    DOCKED : wait REFILL_DONE + START
    RUN    : runPathStep(); if FEED → DROP
    DROP   : dose = doseMs(t, turbid); flap(dose); sendFED()
    RETURN : runPathStep(); wait DOCKED
    STOP   : motors off, flap shut
  if (millis()-lastRx > 1000) state = STOP;
// Dock firmware structure
setup(): Wi-Fi AP + WebServer, ESP-NOW peer(boat),
         LittleFS log, NVS settings, servo, switch
routes:  GET /  → app.html     GET /api/state
         POST /api/cmd          GET /api/log
         POST /api/settings
onRecv(TELEM|FED): update state, append CSV row
loop():
  server.handleClient()
  if (switchPressed && level < 80) refill();
  if (switch changed) send DOCKED
11
As built

The system running end to end

Steps 1 to 10 are the design we submitted for Review 2. This part is what we built since: a dock, a cloud and a website you can open from anywhere. Everything below is running code.

DockBoatSupabaseWebsite ESP32 + servo gaterefills the hopperheartbeat every 2.5 s ESP32 + 4 motorsfeed gate, DS18B20own Wi-Fi + hotspot 4 tables, RLS onPIN check in the DBcommand queue Vercel, any phonecharts, map, controlsrefreshes every 10 s Wi-FiHTTPphonehotspotHTTPSreads PIN-checked command → queue → boat polls every 2 s → acts → reports back telemetry + events upload every 15 s, with retry if the signal drops Without internet the boat still runs from its own page at 192.168.4.1. The cloud adds reach, it is not needed to feed.
Controllers
2

ESP32 boards: the boat and the dock, each with its own firmware.

Cloud tables
4

Telemetry, events, missions and commands, all with row-level security.

Remote commands
8

Feed, refill, dock open and close, auto on and off, repeat mission, stop.

Upload rhythm
15 s

Temperature, feeds, refills, signal and uptime go up every 15 seconds.

Command latency
≈2 s

From a tap on the website to the boat acting on it.

Path length
200

Steps the boat can follow from a shape drawn on a phone.

12
As built

The boat's own control page

The boat serves its page itself, so any phone on its Wi-Fi can drive and feed it with nothing installed. The screenshot is the real page, rendered with demo readings.

Boat control page: temperature graph, drive pad, feeder, auto feed and dock refill
Boat page, scroll inside the frame. Demo values.
1Water temperature from the DS18B20, a live graph with the 22 to 30 °C good range shaded, and a badge: In range, Too cold, Too hot or No sensor.
2Drive pad, hold to move, speed slider 80 to 255. The boat stops by itself if no command arrives for 0.8 s.
3Feeder: one tap opens the gate for the chosen time and angle. Counters show feeds, time since last, and time to the next auto feed.
4Auto feed on a timer from 1 to 600 minutes. With the guard on, it skips a feed when the water is too cold or too hot and writes that in the log.
5Dock refill: shows whether the dock is online, its gate angle, and sends a timed refill.
6Cloud panel shows upload status and lets you change the phone hotspot without reflashing.
1. draw on the phone 2. page converts it to steps f800 forward 1 squarer600 turn right 90°f800 forward 1 squarer600 turn right 90°f800 · r600 · f800 … timings come from the calibration boxes 3. boat follows the path the same path is uploaded and redrawn online
13
As built

The cloud dashboard

One page on Vercel that reads the Supabase tables. It turns the boat's raw numbers into things a farmer can act on.

Pond Feeder Cloud dashboard
The live page at joycemalik.com/miniproject/feeder, captured on 3 Nov 2026 with the boat powered off, so it shows Offline and its last data. Scroll inside the frame.
Mission map

Redraws any past path from its steps, with a replay and four numbers: steps, distance, duration, turning.

Temperature trend

Six hours of readings with min, average, max and rate of change, and a dashed line projecting the next hour.

Oxygen limit

The most oxygen the water can hold at this temperature at Bengaluru's 920 m altitude (Benson–Krause). Warmer means less.

Ration guide

A feeding curve for warm-water fish, peaking at 25 to 28 °C, with a recommendation from the live reading.

Feeding rhythm

One ring per day for seven days, dots sized by how long the gate stayed open.

Refills and events

Refills today on a 24 h line, plus a live stream of every feed, dock action, mission and sensor change.

14
As built

Remote control, step by step

The boat never opens a port to the internet. It asks the cloud for work. That is why a phone hotspot is enough, and why a stranger cannot reach it.

sequenceDiagram
  participant F as Farmer on the website
  participant S as Supabase
  participant B as Boat
  participant D as Dock
  F->>S: Unlock, send the 6 digit PIN
  S-->>F: PIN ok, checked inside the database
  F->>S: Refill at dock, with the PIN
  S->>S: PIN checked again, command queued as pending
  loop every 2 s
    B->>S: Any commands for me, with the device secret
  end
  S-->>B: refill, marked taken
  B->>D: Open the gate for 3 s
  D-->>B: ok
  B->>S: Event dock refill, 3 s
  S-->>F: Shows in the event stream
PIN stays server side

The page never contains the PIN. A database function checks it, and checks it again on every command.

Allow list

The database accepts only eight command names and an argument from 0 to 20000. Anything else is refused.

No stale commands

Each command is pending, taken or expired, so a command sent while the boat was off never fires later.

Safety rules still win

Repeat mission is refused if a path is running or none exists, and the refusal is logged.

Driving stays local

Live steering over the internet would be unsafe, so joystick control only exists on the boat's own page.

Lock button

The unlocked state lives only in that browser tab, and Lock clears it.

15
As built

The dock refilling the boat

The dock is a second ESP32 with one servo gate. It opens from 180° to 135°, feed falls, and it closes itself when the timer ends.

dock hopper boat hopper, docked gate 180° → 135° open for the requested time, 0.5 to 20 s then closes on its own 1. tap Refillwebsite or boat page 2. boat tells dockHTTP /open?ms=3000 3. dock closesrefill logged as an event
Dock behaviourWhat it does
HeartbeatCalls the boat every 2.5 s. The boat uses it to show the dock online and to learn its address automatically.
Finding the boatOn the phone hotspot it looks the boat up as pondboat.local. Otherwise it joins the boat's own PondFeeder network.
RecoveryAfter 3 missed heartbeats it looks the boat up again. After 8 it rejoins the network.
Stand-alone testIts own page has Open, Close and Refill 3 s buttons.
LEDOn-board LED is lit while the dock is talking to the boat.
16
Honest status

Done, in progress, still to prove

ItemReview 2 saidNow
Boat drives, steers, feeds, reads temperaturePlannedworking
Draw a path on the phone, boat follows itTimed path, fixedworking
Auto feed with temperature guardAdaptive doseworking
Dock refillUnder developmentworking
Cloud upload and websiteMQTT, plannedworking over HTTPS to Supabase
PIN-protected remote controlNot in the planbuilt, database side tested
Dock heartbeat on the phone hotspotESP-NOW linkbeing fixed
Dose in grams, endurance, docking success rate, fail-safe timingTest plannot yet measured
Floating hull, turbidity sensorCatamaran, adaptive dosefuture work
What differs from the design in steps 1 to 10: the boat and dock talk over Wi-Fi HTTP, not ESP-NOW; the app is served by the boat and by the cloud, not only by the dock; the prototype is a four-wheel chassis on a bench, not the catamaran; turbidity is dropped and the dose guard uses temperature alone. The path is dead reckoning with no encoders, so the drawn map is an approximation, not a measurement.
17
The product

From a remote boat to a feeder that runs itself

The demo shows a boat you drive. The product is a boat you stop driving. Each rung below hands one more job from the farmer to the machine. Green is running today, amber is partly there, dashed is the plan.

0 · Remote1 · Drawn path2 · Timer3 · Full loop4 · Self-aware Farmer drives andfeeds from a phonebuilt Draw a route once,the boat follows itRepeat it from the webbuilt Feeds on a schedule,skips if the water istoo cold or too hotDock refills on demandbuilt Leave dock, run theroute, feed at points,return, refill, repeatwith no one tappingparts built, join next GPS + compass + encodersknow where the boat isGeofence and return-to-homeDose adapts to waterSeveral boats, one dashboardplanned less farmer effort →
The honest line for the panel: rungs 0 to 2 are demonstrable today. Rung 3 is the next integration, because the pieces already exist (path following, dock refill, timer, mission replay). Rung 4 is the product direction and is not claimed as built.
18
The product

One autonomous feeding day

What the farmer sees once rung 3 is joined up. This is the target behaviour, drawn from the pieces that already work.

06:0006:0506:1206:2006:2512:00 Timer fireswater 26 °C, in range Leaves the dockruns the stored route Drops feed ateach feed point Returns, docks,dock refills hopper Report goes tothe website Next mealsame again If water is too cold or too hot: skip the meal, log why, tell the farmer If the link drops or STOP is pressed: motors off, gate shut
Already running
  • Timer-based auto feed with temperature guard
  • Follow a stored route and repeat it
  • Dock refill on command
  • Every action logged to the cloud
To join up
  • Run route, feed at points, return and refill as one job
  • Start the job from the timer, not a tap
  • Dock detects the boat is in place
Why it matters

Feeding is the biggest recurring chore and cost on a fish farm. A boat that does the whole loop on its own, and reports it, removes the chore and leaves a record.

19
The product

Knowing where it is: GPS and what goes with it

Today the boat guesses its position from how long it drove, which drifts. A real autonomous boat has to know where it is. This is how we plan to get there.

Now · timed movesNext · add sensorsProduct · fused drawn square, actual path drifts Compass: true heading,so turns stay squareWheel encoders: realdistance, not just timeHopper level sensor:know when to go home GPS: absolute position,so errors cannot build upFused with compass andencoders for a smooth trackGeofence andreturn-to-home on any fault
Why not GPS alone

Basic GPS is accurate to a few metres, which is bigger than a small pond or a feed spot. That is why Review 1 dropped it for the demo. In the product, GPS gives the big picture (where in the pond, how to get home) and a compass plus wheel encoders give the fine movement. A better GNSS receiver can tighten it further.

Where it lands in the system

One more sensor on the boat ESP32. The path stored in the cloud then holds real coordinates, so the mission map shows the measured track instead of a reconstruction, and feed points become places on the map.

20
The product

Roadmap, with an honest status for each item

CapabilityWhat it gives the farmerStatus
Remote driving and feedingFeed from a phone, nothing to installbuilt
Draw a route, repeat it from the webSet the route once, not every daybuilt
Timer feeding with temperature guardNo feeding in water the fish will not eat inbuilt
Dock refillNo one at the water to refillbuilt, hotspot link being fixed
Cloud log, map, trends, oxygen limitA record of what was fed, when and wherebuilt
Whole loop as one scheduled jobComplete autonomy for a mealnext
Daily schedules per day and per pondDifferent meals at different timesnext
Dose calibrated in grams, total fed shownKnow exactly how much went innext
GPS, compass, encoders, geofenceReal position, safe return-to-homeplanned
Turbidity sensor, adaptive doseLess waste, cleaner waterplanned
Sealed floating catamaran hullRuns on a real pondplanned
Several boats on one dashboardCover a farm, not one pondplanned
Everything marked built is in the running firmware and website. Planned items are the direction and are not shown as working anywhere in this deck.
→
Validation

Test plan, demo and timeline

TestMethodPass
Hull float30 min in tank, loadedNo water inside, level
Dose calibration5 drops at 300 ms, weighedWithin ±20 %
Adaptive doseCold water / stirred siltDose drops to 70 % / 49 %
Path + dock5 full loops4 of 5 hit limit switch
RefillDock with hopper at 25 %Reaches ≥ 80 %, no spill
Fail-safePower off dock mid-runBoat stops within 1 s
AppPhone joins AP, all buttonsEvery command acknowledged
Demo script (2 min): open the app → Start → boat drops at three points while the dashboard logs grams → cool the probe in ice water and show the next dose shrink → boat docks and refills on its own → tap Cut link (power off dock) to show the safe stop.
Day 1 AM

Hulls sealed, parts checked, bench wiring of both ESP32s.

Day 1 PM

Flap calibrated, motors steer, dock gate + switch, ESP-NOW link.

Day 2 AM

Full loop on water, web app live, refill working.

Day 2 PM

Tuning, backup video, rehearsal of the demo script.

Smart Pond Feeder · 22CSU701 Applied IoT · Review 2. The numbers for the small prototype are targets until we measure them.