IoT Career Options for Students in Greater Noida

// Firmware — Publish sensor data over MQTT.
// This is what an entry-level embedded/IoT developer writes.
// Runs on ESP32 — one of the most common IoT boards.

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

#define WIFI_SSID      "your-wifi"
#define WIFI_PASSWORD  "your-password"
#define MQTT_SERVER    "broker.hivemq.com"
#define MQTT_PORT      1883
#define MQTT_TOPIC     "sensors/greaternoida/temp"

#define DHT_PIN        4
#define DHT_TYPE       DHT22

WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(DHT_PIN, DHT_TYPE);

void connectWiFi() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");
}

void connectMQTT() {
  while (!client.connected()) {
    if (client.connect("esp32-sensor-01")) {
      Serial.println("MQTT connected");
    } else {
      delay(2000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  connectWiFi();
  client.setServer(MQTT_SERVER, MQTT_PORT);
}

void loop() {
  if (!client.connected()) connectMQTT();
  client.loop();

  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("Sensor read failed");
    return;
  }

  String payload = "{\"temp\":" + String(temperature, 2) +
                   ",\"humidity\":" + String(humidity, 2) + "}";

  client.publish(MQTT_TOPIC, payload.c_str());
  Serial.println("Published: " + payload);

  delay(10000);  // every 10 seconds
}

// What this teaches:
// - How devices talk to the internet (MQTT)
// - Reading sensors (DHT22 temperature/humidity)
// - JSON payload structure for IoT
// - Basic reconnection handling

// Why this is career-relevant:
// This is the smallest complete IoT project — a real device
// publishing real data to a real broker. If you can explain
// every line, you can pass an entry-level IoT interview.

# Cloud — Subscribe and process device data.
# What an IoT cloud engineer writes on the backend.

import paho.mqtt.client as mqtt
import json
import time
import sqlite3

# Setup the local database (production uses TimescaleDB, InfluxDB, or BigQuery)
db = sqlite3.connect("iot_readings.db")
db.execute("""
    CREATE TABLE IF NOT EXISTS readings (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        device_id TEXT,
        topic TEXT,
        temp REAL,
        humidity REAL,
        received_at INTEGER
    )
""")
db.commit()

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    client.subscribe("sensors/greaternoida/#")

def on_message(client, userdata, msg):
    try:
        payload = json.loads(msg.payload.decode())
    except json.JSONDecodeError:
        print(f"Bad payload on {msg.topic}: {msg.payload}")
        return

    device_id = msg.topic.split("/")[-1]
    temp = payload.get("temp")
    humidity = payload.get("humidity")

    db.execute("""
        INSERT INTO readings (device_id, topic, temp, humidity, received_at)
        VALUES (?, ?, ?, ?, ?)
    """, (device_id, msg.topic, temp, humidity, int(time.time())))
    db.commit()

    print(f"Stored: device={device_id}, temp={temp}, humidity={humidity}")

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect("broker.hivemq.com", 1883, 60)

print("Listening for device data…")
client.loop_forever()

# What this teaches:
# - The backend half of an IoT system
# - MQTT topic wildcards (# for all sub-topics)
# - Parsing and validating device payloads
# - Writing to a database that a dashboard can read

# Why this is career-relevant:
# IoT is a full-stack problem — the cloud engineer is
# the person who turns raw device data into something
# the business can use. That is what "IoT cloud engineer"
# actually means.

# Dashboard — visualise IoT data.
# What a full-stack IoT developer builds on top of the data layer.

import streamlit as st
import sqlite3
import pandas as pd
import plotly.express as px

st.set_page_config(page_title="Greater Noida IoT Dashboard", page_icon="📡")
st.title("📡 Greater Noida IoT — Live Readings")

# Read from the database that the MQTT consumer wrote to
db = sqlite3.connect("iot_readings.db")
df = pd.read_sql_query("""
    SELECT datetime(received_at, 'unixepoch') AS time,
           device_id, temp, humidity
    FROM readings
    WHERE received_at > strftime('%s', 'now') - 3600
    ORDER BY received_at ASC
""", db)

if df.empty:
    st.warning("No data yet — is the device publishing?")
    st.stop()

# Latest reading
latest = df.iloc[-1]
col1, col2, col3 = st.columns(3)
col1.metric("Temperature (°C)", f"{latest['temp']:.1f}")
col2.metric("Humidity (%)", f"{latest['humidity']:.1f}")
col3.metric("Readings (1h)", len(df))

# Time-series charts
st.subheader("Temperature over time")
fig_temp = px.line(df, x="time", y="temp", color="device_id", markers=True)
st.plotly_chart(fig_temp, use_container_width=True)

st.subheader("Humidity over time")
fig_hum = px.line(df, x="time", y="humidity", color="device_id", markers=True)
st.plotly_chart(fig_hum, use_container_width=True)

# What this teaches:
# - Turning IoT data into a business-readable dashboard
# - Streamlit is one of the fastest ways to build a
#   working dashboard for a portfolio project
# - The final layer of the IoT stack

# Why this is career-relevant:
# The most compelling portfolio project for an IoT
# interview is: "I built a device that publishes data,
# a backend that stores it, and a dashboard that shows it."
# That single project covers firmware, cloud, and data —
# the three skills IoT roles hire for.