"What's the Use Case?" Is a great question. Until it Isn't.

Notes on figuring out how to work with LLMs, from someone still figuring it out

Introduction

Every experience teaches you something. The only question is what.

Notes from my first job: research, teams, and the things that actually mattered

Things I Learned in 3.5 Years at my first job

A little bit of slope makes up for a lot of y-intercept

Control Wipro smart plugs programmatically using TinyTuya and the Tuya IoT platform, with an example battery-based charging automation script.

Automating Wipro Smart Plugs with TinyTuya

Set up instant, end-to-end encrypted Obsidian note syncing across all your devices using a self-hosted CouchDB server exposed via a Cloudflare Tunnel.

Self-Hosting Obsidian Live Sync with Cloudflare Tunnels

Guide for downloading HTML presentations as PDF files using DeckTape.

Converting HTML Presentations to PDF with DeckTape

How to configure a Jupyter notebook server to start automatically at system boot using systemd.

Creating a Systemd Service for Automatic Startup

Wipro smart plugs run on the Tuya platform, which means they can be controlled locally over your LAN using the [TinyTuya](https://github.com/jasonacox/tinytuya) library -- no cloud dependency required once you have the device credentials.

## Setup

1. **Install the SmartLife app** (not the Wipro app) -- it has better Tuya platform compatibility
2. **Register on the [Tuya IoT Platform](https://iot.tuya.com/)**
   - Create a cloud project
   - Link your devices to it
3. **Install TinyTuya**
   ```bash
   pip install tinytuya
   ```
4. **Discover your devices** -- run the TinyTuya device scan using your API credentials to get the Device ID, IP, and Local Key for each plug
   > **Note:** The scan may fail on macOS. If so, run it from a Linux machine connected to the same Wi-Fi network.
5. **Assign static IPs** in your router for each plug so the IP doesn't change

## Battery-Based Charging Control

A common use case: automatically turn the plug on/off based on laptop battery level to avoid leaving it at 100% all night.

> **Note:** The `get_battery_level()` function below uses `upower`, which is Linux-only. On macOS you can use `pmset -g batt`; on Windows, use `psutil.sensors_battery()`.

Save as `/usr/local/bin/battery-charge-manager.py`:

```python
#!/usr/bin/env python3
import tinytuya
import subprocess
import sys
from datetime import datetime

# Device credentials - fill these in from your TinyTuya scan
DEVICE_ID = 'your-device-id'
DEVICE_IP = 'your-device-ip'
LOCAL_KEY = 'your-local-key'
VERSION = 3.3

# Battery thresholds
HIGH_THRESHOLD = 80  # Stop charging at 80%
LOW_THRESHOLD = 40   # Start charging at 40%

def get_battery_level():
    try:
        result = subprocess.run(
            ['upower', '-i', '/org/freedesktop/UPower/devices/battery_BAT0'],
            capture_output=True,
            text=True,
            timeout=10
        )
        for line in result.stdout.split('\n'):
            if 'percentage' in line.lower():
                percentage_str = line.split(':')[1].strip().replace('%', '')
                return int(float(percentage_str))
    except Exception as e:
        print(f"Error reading battery: {e}")
    return None

def main():
    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    battery = get_battery_level()

    if battery is None:
        print(f"[{timestamp}] ERROR: Could not read battery level")
        sys.exit(1)

    device = tinytuya.OutletDevice(
        dev_id=DEVICE_ID,
        address=DEVICE_IP,
        local_key=LOCAL_KEY,
        version=VERSION
    )

    try:
        status = device.status()
        is_on = status['dps']['1'] if status and 'dps' in status else None

        print(f"[{timestamp}] Battery: {battery}%, Plug: {'ON' if is_on else 'OFF'}")

        if battery >= HIGH_THRESHOLD and is_on:
            print(f"[{timestamp}] Battery >= {HIGH_THRESHOLD}%, turning plug OFF")
            device.turn_off()
        elif battery <= LOW_THRESHOLD and not is_on:
            print(f"[{timestamp}] Battery <= {LOW_THRESHOLD}%, turning plug ON")
            device.turn_on()
        else:
            print(f"[{timestamp}] No action needed")

    except Exception as e:
        print(f"[{timestamp}] ERROR: {e}")
        sys.exit(1)

if __name__ == '__main__':
    main()
```

Make it executable and schedule it with cron:

```bash
chmod +x /usr/local/bin/battery-charge-manager.py
sudo touch /var/log/battery-manager.log
crontab -e
```

Add this entry to run every 10 minutes:

```
*/10 * * * * /usr/bin/python3 /usr/local/bin/battery-charge-manager.py >> /var/log/battery-manager.log 2>&1
```

Monitor the logs:

```bash
tail -f /var/log/battery-manager.log
```

## Controlling Multi-Socket Extension Boards

For Wipro smart extension boards where each socket can be controlled individually:

```python
import tinytuya
import time

d = tinytuya.Device('your-device-id', 'your-device-ip', 'your-local-key', version=3.3)

# Turn all sockets ON
print("Turning all switches ON...")
for switch in range(1, 5):
    d.set_status(True, switch)
    time.sleep(0.5)

time.sleep(3)

# Turn all sockets OFF
print("Turning all switches OFF...")
for switch in range(1, 5):
    d.set_status(False, switch)
    time.sleep(0.5)
```

Each socket maps to a DPS index (1–4 for a 4-socket board). You can target individual sockets by calling `d.set_status(True/False, socket_number)` directly.

---

## References

- [TinyTuya on GitHub](https://github.com/jasonacox/tinytuya)
- [Tuya IoT Platform](https://iot.tuya.com/)
- [Wipro Smart Plug on Amazon](https://www.amazon.in/Wipro-monitoring-appliances-Assistant-DSP1100/dp/B08HNB2FSH/)
