
SmartPot — AI Plant Companion
Voice-controlled ESP32 plant assistant with edge AI and sensor intelligence.
Firmware & AI Systems Engineer
View Details →Engineering rugged, battery-optimized, and cloud-connected hardware solutions. From physical schematic design to production firmware and telemetry dashboards.
4+ Years
Building systems
Remote + Onsite (Guwahati Area)
Concept Validation → Custom PCB Prototype → Production-Ready Firmware
Optimization Summary
Summary: Many IoT projects fail because the hardware designer and firmware coder operate in silos. I handle both, preventing common integration bottlenecks.
“Existing ESP32 firmware is unstable and disconnects from Wi-Fi constantly.”
I implement non-blocking reconnection loops, auto-refreshing TLS certificates, offline network caching inside Flash (SPIFFS/LittleFS), and watchdog timers (WDT) to auto-recover hung threads.
“Batteries drain in days instead of months.”
I replace simple delay loops with deep-sleep RTC timers. I calibrate physical wake interrupts, isolate high-draw sensors using P-channel MOSFET power gates, and configure low-power state machines.
“Updating deployed devices requires physical disassembly.”
I build partition-safe OTA (Over-The-Air) update engines over HTTPS with hash verification. Deployed devices download and flash updates automatically, with automatic rollbacks on boot failure.
“Telemetry lag is too high to coordinate movements.”
I replace high-overhead HTTP requests with ultra-low latency WebSocket loops or structured MQTT binary payloads (Protocol Buffers) running on lightweight transport layers.
Summary: I partner with teams and builders requiring direct access to the developer writing both the hardware firmware and the cloud logic. I do not delegate to junior engineers.
Teams that need a functional prototype fast. I build the physical hardware, flash initial firmware, and deliver a visual cloud dashboard within weeks to validate market fit.
Academic projects needing bespoke sensor arrays, high-speed telemetry loggers, or gesture-controlled actuators (like my 6-DOF robotic arm gesture pipeline).
Operators requiring solar-powered, ruggedized sensor packages for soil moisture, nitrate monitoring, or microclimate telemetry deployed in isolated fields.
Companies seeking to retrofit legacy machinery with Modbus/CAN telemetry adapters to push operational metrics to secure cloud endpoints.
Summary: At the end of a project, you receive 100% of the IP. No vendor lock-in or proprietary dependencies.
Fully routed schematics, 2/4-layer layout files, and customized component libraries built in KiCad.
Production-ready Gerber files, drill files, BOM (Bill of Materials) with active LCSC/DigiKey part numbers, and pick-and-place coordinate maps.
Clean, documented C++ or C firmware source code structured under PlatformIO or ESP-IDF, alongside pre-compiled flashing binaries.
Parametric 3D CAD files (STEP/STL formats) for physical enclosures designed for FDM printing or injection molding.
Clear Markdown specifications outlining the telemetry JSON structure, MQTT topics, security handshake steps, and device variables.
Summary: I build physical devices engineered to capture environmental telemetry, translate physical motions, and execute local logic.
Running neural networks locally. I deploy TensorFlow Lite for Microcontrollers on ESP32-S3 boards to perform local audio wakeword detection (similar to the SmartPot companion) and real-time sensor anomaly classification with sub-100ms response windows and zero cloud bandwidth dependency.
Custom telemetry rigs monitoring physical variables. I design integrated PCB circuits utilizing I2C, SPI, and UART lines to read analog gas sensors, capacitive soil moisture probes, multi-axis accelerometers, and thermal arrays, compiling them into packed payloads.
Bridging computer vision and physical machinery. I construct multi-axis motor controllers (such as gesture-mapped robotic arms) communicating via high-speed WebSockets to convert camera joint coordinates into PWM pulses on servo drivers.
Summary: I write low-level code and design physical boards using industry standard tools.
Summary: This document outlines Jishnu Mahanta's architectural approach to engineering battery-powered sensor networks, writing clean, firmware layers, and developing physical enclosures.
In field deployments, battery life is the ultimate constraint. A standard ESP32 drawing 80mA to 240mA during active operation will drain a 1200mAh LiPo battery in a matter of hours. Achieving a multi-year battery life requires shifting from active polling to event-driven execution and strict sleep-cycle profiles.
Power Consumption during Reconnection
Battery-powered ESP32 devices often consume far more power during Wi-Fi reconnect loops (drawing 150mA+ for 5-15 seconds) than in deep sleep (10µA to 15µA). If a Wi-Fi router is temporarily offline, a naive loop will rapidly drain the battery. Optimizing reconnect intervals with exponential backoff and localized flash caching usually has a larger impact than reducing the CPU frequency.
To optimize power draw, the hardware design must isolate high-power sensors (such as gas sensors or GPS receivers) using P-channel MOSFET power gates. Below is the standard firmware pattern I implement in C++ using ESP-IDF to coordinate deep sleep intervals and interrupt-driven wake cycles:
#include "esp_sleep.h"
#include "driver/rtc_io.h"
#define SENSOR_POWER_PIN GPIO_NUM_4
#define WAKE_UP_PIN GPIO_NUM_12
void setup() {
// Initialize RTC variables
esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
if (wakeup_reason == ESP_SLEEP_WAKEUP_EXT0) {
// Handle sensor trigger interrupt (e.g. rain sensor or tilt sensor)
processSensorInterrupt();
} else {
// Regular scheduled telemetry upload
performTelemetryRoutine();
}
// Power down peripheral rail before sleep
pinMode(SENSOR_POWER_PIN, OUTPUT);
digitalWrite(SENSOR_POWER_PIN, LOW); // Cut power to MOSFET gate
// Configure external pin wake trigger (active low)
esp_sleep_enable_ext0_wakeup(WAKE_UP_PIN, 0);
// Configure timer wake (e.g. 1 hour = 3600 seconds)
esp_sleep_enable_timer_wakeup(3600ULL * 1000000ULL);
// Start deep sleep
esp_deep_sleep_start();
}
RTC Fast Memory Usage
When using deep sleep, standard RAM is powered off, losing all state variables. Instead of repeatedly writing configurations to Flash memory (which has limited write cycles), variables should be annotated with the RTC_DATA_ATTR attribute to preserve them in RTC fast memory.
When routing 2-to-4 layer PCBs in KiCad, high-frequency signals (such as USB-C data lanes or high-speed SPI busses) must be laid out with impedance matching and proper return paths.
Floating Ground Planes & EMI Loops
A common mistake is routing high-speed signal traces directly across gaps in the ground return plane. This forces return currents to flow in a large loop, creating a loop antenna that emits electromagnetic interference (EMI) and corrupts sensitive analog sensor readings.
The SmartPot Bring-up
During the SmartPot bring-up phase, the initial draft had noise interference on the capacitive soil moisture lines. I isolated the analog tracer, surrounded it with a copper ground fill guard ring, and placed an active RC low-pass filter (10kΩ resistor + 1nF capacitor) close to the ADC pin. This reduced reading variance from ±8% to a stable ±0.2%.
Modern IoT edge nodes handle multiple concurrent processes: updating a display, measuring sensors, listening to voice commands, and communicating over MQTT. Running these inside a single blocking loop leads to system lag. I build modular firmware structures by utilizing FreeRTOS queues and task prioritization:
+--------------------+ Queue +---------------------+
| Sensor Polling | ---------------> | MQTT Telemetry Sync |
| (Priority 1, 10Hz) | | (Priority 2, Event) |
+--------------------+ +---------------------+
| |
v v
Reads ADC / I2C / SPI Pipes packets over TLS
This decoupling ensures that if network latency increases during telemetry transfer, sensor measurements continue to run at stable intervals. If a task crashes, a dedicated supervisor task detects the failure and resets only the affected subsystem rather than restarting the entire board.
Summary: I build hardware systematically, ensuring physical errors are caught early during simulation and visual modeling.
Phase 1 of 9
We outline constraints: battery target lifespan, size dimensions, operating temperature, radio range, and component costs. I draft a clear block diagram detailing microcontrollers, power chips, sensors, and flash allocations.
Dynamic projects fetched from the portfolio database demonstrating execution.

Voice-controlled ESP32 plant assistant with edge AI and sensor intelligence.
Firmware & AI Systems Engineer
View Details →
Gesture-controlled multi-axis arm with computer vision.
Firmware & System Engineer
View Details →
AI-driven irrigation system for optimal plant health.
IoT Developer
View Details →
Remote-controlled automated feeding system.
Full-stack IoT
View Details →
Real-time display with sensor fusion & API data
IoT Engineer
View Details →Summary: Agencies often require separate hardware and software teams, doubling your coordination overhead and budget.
| Engineering Criteria | My Freelance Services | Typical Development Agency |
|---|---|---|
| Direct Developer Communication | ✓ Instant Slack/WhatsApp contact with the engineer writing your code. | ❌ Relies on account managers; responses take 24–48 hours. |
| PCB + Firmware + Cloud Integration | ✓ Done by a single engineer, ensuring perfect hardware/software synergy. | ⚠️ Split across departments; frequent miscommunication on APIs. |
| Source Code & Schematic IP Ownership | ✓ 100% IP transferred to you on completion; zero recurring platform fees. | ⚠️ Often retains core firmware blocks or charges licensing. |
| Edge AI & TFLite Optimization | ✓ Experienced in squeezing neural networks onto low-cost ESP32 chips. | ❌ Typically pushes AI logic to cloud APIs, increasing latency/cost. |
| 3D CAD Enclosure Integration | ✓ Custom enclosure design matching the routed PCB geometry. | ❌ Requires hiring a separate mechanical design contractor. |
Summary: In Guwahati, I provide local diagnostics, rapid enclosure iterations, on-site board bring-up sessions, and face-to-face consulting, reducing prototype delivery cycles.
For clients across other major Indian tech hubs (Bengaluru, Hyderabad, Pune, Chennai, Mumbai, Delhi NCR) and global locations (US, Canada, UK, Australia, Germany, Singapore), I provide remote collaboration via GitHub, sandbox database integrations, and international shipping.
Summary: Read how I evaluate components and protocols when designing custom systems.
An engineering evaluation comparing ESP32's built-in Wi-Fi/Bluetooth against STM32's deterministic real-time processing and low-power registers.
Analyzing packet overhead, handshake protocols, and connection stability for low-bandwidth cellular connections.
Detailed schematics showing how to bypass voltage regulators and power down sensors completely using P-MOS switches.
Structured query answers targeting specific informational searches.
Ready to move from a breadboard to a production-ready custom PCB and firmware framework? Schedule a direct engineering call.