ZONY Edge Gateway + Firmware™

# Instalação no Raspberry Pi / Jetson Nano
sudo apt update
sudo apt install python3-pip can-utils

# Ativar interface CAN
sudo ip link set can0 type can bitrate 250000
sudo ip link set up can0

# Instalar dependências Python
pip install python-can fastapi uvicorn requests

# zony_gateway.py

import can
import requests
import time
import json

# Config CAN
CAN_INTERFACE = "can0"
SERVER_URL = "http://localhost:8000/telemetry"

bus = can.interface.Bus(channel=CAN_INTERFACE, bustype='socketcan')

def read_can():
    while True:
        message = bus.recv(timeout=1)
        if message:
            data = {
                "id": message.arbitration_id,
                "data": list(message.data),
                "timestamp": time.time()
            }
            print("CAN DATA:", data)
            send_to_server(data)

def send_to_server(data):
    try:
        requests.post(SERVER_URL, json=data)
    except Exception as e:
        print("Erro ao enviar:", e)

def send_command(arbitration_id, data_bytes):
    msg = can.Message(
        arbitration_id=arbitration_id,
        data=data_bytes,
        is_extended_id=False
    )
    bus.send(msg)

if __name__ == "__main__":
    print("ZONY Gateway iniciado...")
    read_can()

# Comando plantio — CAN Frame
send_command(0x100, [0x01, 0x64, 0x05])

# Bytes:
# 0x01 → iniciar plantio
# 0x64 → velocidade (100 dec)
# 0x05 → profundidade (5 cm)

# main.py — FastAPI Backend

from fastapi import FastAPI
from pydantic import BaseModel
import time

app = FastAPI()

telemetry_db = []
commands_db  = []

class Telemetry(BaseModel):
    id: int
    data: list
    timestamp: float

class Command(BaseModel):
    machine_id: str
    action: str
    params: dict

@app.post("/telemetry")
def receive_telemetry(data: Telemetry):
    telemetry_db.append(data)
    return {"status": "ok"}

@app.post("/command")
def send_command(cmd: Command):
    commands_db.append(cmd)
    return {"status": "command queued"}

@app.get("/commands/{machine_id}")
def get_commands(machine_id: str):
    cmds = [c for c in commands_db if c.machine_id == machine_id]
    return cmds

@app.get("/status")
def status():
    return {
        "telemetry_count": len(telemetry_db),
        "commands_count":  len(commands_db),
        "time": time.time()
    }

POST /command

{
  "machine_id": "tractor_01",
  "action": "plant",
  "params": {
    "crop": "milho",
    "depth": 5,
    "spacing": 0.5
  }
}

// ZONY Firmware — ESP32 + CAN Bus
#include <CAN.h>

void setup() {
  Serial.begin(115200);
  CAN.begin(500E3);  // 500 kbps
}

void loop() {
  if (CAN.parsePacket()) {
    int command = CAN.read();

    switch (command) {
      case 0x01: startPlanting();  break;
      case 0x02: startSpray();     break;
      case 0x03: stopAll();        break;
    }
  }
}

void startPlanting() {
  Serial.println("Plantio iniciado");
  // ativar motor hidráulico / implemento
  digitalWrite(PLANT_MOTOR_PIN, HIGH);
}

void startSpray() {
  Serial.println("Pulverização iniciada");
  digitalWrite(SPRAY_VALVE_PIN, HIGH);
}

void stopAll() {
  Serial.println("PARADA DE EMERGÊNCIA");
  digitalWrite(PLANT_MOTOR_PIN, LOW);
  digitalWrite(SPRAY_VALVE_PIN, LOW);
}