Cảm biến nhiệt độ & độ ẩm thông minh ATH22

<?php
declare(strict_types=1);

header('Content-Type: application/json; charset=utf-8');

function respond(int $status, string $message): void
{
    http_response_code($status);
    echo json_encode(['message' => $message], JSON_UNESCAPED_UNICODE);
    exit;
}

$ip         = trim($_GET['ip'] ?? '');
$temp       = filter_var($_GET['temp'] ?? null, FILTER_VALIDATE_FLOAT);
$hum        = filter_var($_GET['hum'] ?? null, FILTER_VALIDATE_FLOAT);
$location   = trim($_GET['location'] ?? '');
$deviceName = trim($_GET['deviceName'] ?? '');

if (!filter_var($ip, FILTER_VALIDATE_IP)
    || $temp === false
    || $hum === false
    || $location === ''
    || $deviceName === '') {
    respond(400, 'Invalid or missing parameters');
}

try {
    $pdo = new PDO(
        getenv('DB_DSN') ?: '',
        getenv('DB_USER') ?: '',
        getenv('DB_PASSWORD') ?: '',
        [
            PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_EMULATE_PREPARES   => false,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
        ]
    );

    $sql = <<<'SQL'
INSERT INTO STF_TempHum_Data
    (sensor_name, ip_address, location, temp, hum)
VALUES
    (:device_name, :ip, :location, :temp, :hum)
SQL;

    $statement = $pdo->prepare($sql);
    $statement->execute([
        ':device_name' => $deviceName,
        ':ip'          => $ip,
        ':location'    => $location,
        ':temp'        => $temp,
        ':hum'         => $hum,
    ]);

    respond(200, 'Success');
} catch (Throwable $error) {
    error_log($error->getMessage());
    respond(500, 'Database error');
}

Biến môi trường: DB_DSN=sqlsrv:Server=YOUR_DB_SERVER;Database=STFApp, DB_USER và DB_PASSWORD.

using Microsoft.Data.SqlClient;
using System.Data;
using System.Net;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var connectionString = builder.Configuration
    .GetConnectionString("DefaultConnection")
    ?? throw new InvalidOperationException("Missing connection string");

app.MapGet("/api/sensor", async (
    string? ip,
    decimal? temp,
    decimal? hum,
    string? location,
    string? deviceName) =>
{
    if (!IPAddress.TryParse(ip, out _)
        || temp is null
        || hum is null
        || hum < 0 || hum > 100
        || string.IsNullOrWhiteSpace(location)
        || string.IsNullOrWhiteSpace(deviceName))
    {
        return Results.BadRequest(new
        {
            message = "Invalid or missing parameters"
        });
    }

    const string sql = @"
        INSERT INTO STF_TempHum_Data
            (sensor_name, ip_address, location, temp, hum)
        VALUES
            (@deviceName, @ip, @location, @temp, @hum)";

    await using var connection = new SqlConnection(connectionString);
    await using var command = new SqlCommand(sql, connection);

    command.Parameters.Add("@deviceName", SqlDbType.NVarChar, 100).Value = deviceName;
    command.Parameters.Add("@ip", SqlDbType.VarChar, 45).Value = ip;
    command.Parameters.Add("@location", SqlDbType.NVarChar, 200).Value = location;

    var tempParameter = command.Parameters.Add("@temp", SqlDbType.Decimal);
    tempParameter.Precision = 6;
    tempParameter.Scale = 2;
    tempParameter.Value = temp.Value;

    var humParameter = command.Parameters.Add("@hum", SqlDbType.Decimal);
    humParameter.Precision = 6;
    humParameter.Scale = 2;
    humParameter.Value = hum.Value;

    await connection.OpenAsync();
    await command.ExecuteNonQueryAsync();

    return Results.Ok(new { message = "Success" });
});

app.Run();

Cài package: dotnet add package Microsoft.Data.SqlClient. Đặt chuỗi kết nối bằng biến môi trường ConnectionStrings__DefaultConnection.

import ipaddress
import os
from decimal import Decimal, InvalidOperation

import pyodbc
from flask import Flask, jsonify, request

app = Flask(__name__)


@app.get("/api/sensor")
def receive_sensor_data():
    ip = request.args.get("ip", "").strip()
    location = request.args.get("location", "").strip()
    device_name = request.args.get("deviceName", "").strip()

    try:
        ipaddress.ip_address(ip)
        temp = Decimal(request.args.get("temp", ""))
        hum = Decimal(request.args.get("hum", ""))
    except (ValueError, InvalidOperation):
        return jsonify(message="Invalid numeric value or IP address"), 400

    if not location or not device_name or hum < 0 or hum > 100:
        return jsonify(message="Invalid or missing parameters"), 400

    sql = """
        INSERT INTO STF_TempHum_Data
            (sensor_name, ip_address, location, temp, hum)
        VALUES (?, ?, ?, ?, ?)
    """

    try:
        with pyodbc.connect(os.environ["DB_CONNECTION_STRING"]) as connection:
            cursor = connection.cursor()
            cursor.execute(sql, device_name, ip, location, temp, hum)
            connection.commit()
    except pyodbc.Error as error:
        app.logger.exception("Database error: %s", error)
        return jsonify(message="Database error"), 500

    return jsonify(message="Success"), 200


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Cài thư viện: pip install flask pyodbc. Đặt chuỗi ODBC trong biến môi trường DB_CONNECTION_STRING.

package com.example.sensorapi;

import java.math.BigDecimal;
import java.util.Map;

import org.springframework.dao.DataAccessException;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class SensorController {
    private final JdbcTemplate jdbcTemplate;

    public SensorController(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @GetMapping("/sensor")
    public ResponseEntity<Map<String, String>> receive(
            @RequestParam String ip,
            @RequestParam BigDecimal temp,
            @RequestParam BigDecimal hum,
            @RequestParam String location,
            @RequestParam String deviceName) {

        if (ip.isBlank()
                || location.isBlank()
                || deviceName.isBlank()
                || hum.compareTo(BigDecimal.ZERO) < 0
                || hum.compareTo(new BigDecimal("100")) > 0) {
            return ResponseEntity.badRequest()
                    .body(Map.of("message", "Invalid or missing parameters"));
        }

        String sql = """
                INSERT INTO STF_TempHum_Data
                    (sensor_name, ip_address, location, temp, hum)
                VALUES (?, ?, ?, ?, ?)
                """;

        try {
            jdbcTemplate.update(
                    sql,
                    deviceName,
                    ip,
                    location,
                    temp,
                    hum
            );
        } catch (DataAccessException exception) {
            return ResponseEntity.internalServerError()
                    .body(Map.of("message", "Database error"));
        }

        return ResponseEntity.ok(Map.of("message", "Success"));
    }
}

Dùng các dependency spring-boot-starter-web, spring-boot-starter-jdbc và mssql-jdbc. Cấu hình bằng DB_URL, DB_USER, DB_PASSWORD.

const express = require("express");
const net = require("node:net");
const sql = require("mssql");

const app = express();

const poolPromise = sql.connect({
  server: process.env.DB_SERVER,
  database: process.env.DB_NAME,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  options: {
    encrypt: process.env.DB_ENCRYPT === "true",
    trustServerCertificate: process.env.DB_TRUST_CERT === "true"
  }
});

app.get("/api/sensor", async (request, response) => {
  const { ip, temp, hum, location, deviceName } = request.query;
  const tempValue = Number(temp);
  const humValue = Number(hum);

  if (net.isIP(ip) === 0
      || !Number.isFinite(tempValue)
      || !Number.isFinite(humValue)
      || humValue < 0
      || humValue > 100
      || typeof location !== "string"
      || typeof deviceName !== "string"
      || !location.trim()
      || !deviceName.trim()) {
    return response.status(400).json({
      message: "Invalid or missing parameters"
    });
  }

  try {
    const pool = await poolPromise;

    await pool.request()
      .input("sensor_name", sql.NVarChar(100), deviceName.trim())
      .input("ip_address", sql.VarChar(45), ip)
      .input("location", sql.NVarChar(200), location.trim())
      .input("temp", sql.Decimal(6, 2), tempValue)
      .input("hum", sql.Decimal(6, 2), humValue)
      .query(`
        INSERT INTO STF_TempHum_Data
          (sensor_name, ip_address, location, temp, hum)
        VALUES
          (@sensor_name, @ip_address, @location, @temp, @hum)
      `);

    return response.json({ message: "Success" });
  } catch (error) {
    console.error("Database error", error);
    return response.status(500).json({ message: "Database error" });
  }
});

app.listen(process.env.PORT || 3000, () => {
  console.log("Sensor API is running");
});

Cài thư viện: npm install express mssql. Cấu hình DB_SERVER, DB_NAME, DB_USER và DB_PASSWORD.