Plano de Negócios Mining Farm 50 kW: CAPEX, OPEX e ROI

Rodar uma operação de mineração de 50 kW é aquele cenário de fronteira entre uma tomada residencial pesada e um data center comercial. Por um lado, uma carga ativa de 50 kW ainda dá para puxar num pequeno galpão comercial ou num imóvel particular com subestação própria (transformador). Por outro lado, estamos falando de uns 14 a 15 ASICs modernos, onde cada máquina cospe até 3,5 kW de calor, consome de 15 a 16 amperes por fase e exige uma vazão de 600 a 800 metros cúbicos de ar por hora.

Este guia traz o panorama prático de engenharia sobre projeto, compra de hardware, infra elétrica, refrigeração e automação para uma farm de mineração de 50 kW. Sem enrolação, sem papo furado ou teoria acadêmica - apenas números crus, hardware, cabos, estudo de lençol freático e scripts de monitoramento prontos para produção.

1. Parâmetros Iniciais e Infraestrutura Elétrica

A base de qualquer operação de mineração é o custo do quilowatt-hora e a confiabilidade da subestação. Para uma carga contínua de 50 kW rodando 24/7, a proteção geral de entrada deve ser dimensionada com uma folga de 20% na corrente (seguindo normas NFPA/IEC para cargas contínuas).

I_total = P / (√3 · U · cosφ) = 50000 / (√3 · 380 · 0.95) ≈ 79.8 A

Considerando a margem de 1,25, o disjuntor geral de entrada precisa ser de no mínimo 100 A (trifásico).

Especificação do Quadro Elétrico Geral (QGBT 50 kW)

• Disjuntor Geral: 3P 100 A (curva C, capacidade de interrupção de pelo menos 10 kA, ex.: Schneider Electric Acti9 ou ABB S200).
• Balanceamento de Fases: 3 fases L1, L2, L3, distribuídas estritamente de forma igual com 5 aparelhos por fase (para um total de 15 dispositivos) para evitar desequilíbrio de fases e corrente excessiva no neutro.
• Cabeamento da Subestação ao QGBT: Cabo de cobre U1000 R2V 4x25 mm² ou alumínio 4x50 mm² em instalação subterrânea (garantindo queda de tensão máxima de 2% em 50 metros).
• Proteção dos Circuitos Derivados: Para cada ASIC, um disjuntor dedicado 2P 20 A (curva C) + cabo de cobre antichama com dupla isolação 3x2,5 mm².
• Sistema de Aterramentos: Malha de terra ou esquema TN-S / TN-C-S com resistência inferior a 4 ohms (formada por 3 hastes cobreadas de 2,5 m cravadas em triângulo e soldadas com barra chata de 40x4 mm).

2. Escolha de Hardware e CAPEX (Investimento Inicial)

Para os cálculos, vamos adotar o padrão absoluto da indústria: as séries Bitmain Antminer S19k Pro / S21 ou MicroBT Whatsminer M50/M60. Para fechar redondinho em 50 kW, o ideal é colocar 14 unidades do Antminer S21 (200 TH/s) com consumo padrão de aproximadamente 3.500 W por equipamento.

• Hashrate Total: 14 · 200 TH/s = 2.800 TH/s = 2,8 PH/s
• Consumo Total: 14 · 3.500 W = 49 kW (cabe dentro do limite de 50 kW, deixando margem para a ventilação).

Tabela de Custos de Capital (CAPEX)

3. Refrigeração e Ventilação: Cálculo Termodinâmico

O erro clássico de quem está começando: colocar ar-condicionado residencial. O ar-condicionado remove umidade e baixa a temperatura via ciclo frigorífico, mas para 50 kW de carga térmica você precisaria de um monstro de 150.000 BTU que sozinho consumiria mais 15 a 18 kW de eletricidade.

Mineração se resfria exclusivamente com ventilação mecânica cruzada (exaustão e insuflamento forçados).

Cálculo do Fluxo de Ar Necessário

Fórmula da vazão de ar exigida:

Q = P_dissip / (ρ · c_p · ΔT)

Onde:

• P_dissip = 49.000 W (calor gerado)
• ρ = 1,2 kg/m³ (densidade do ar a 20 °C)
• c_p = 1.005 J/(kg·K) (capacidade térmica mássica do ar)
• ΔT = 15 °C (elevação de temperatura admissível entre entrada e saída)

Q = 49000 / (1.2 · 1005 · 15) ≈ 2.708 m³/s = 9.750 m³/h

Considerando a perda de carga dos filtros grossos (G4), é necessário especificar exaustores com capacidade total de pelo menos 12.000 a 14.000 m³/h.

Compartimentação de Fluxos (Corredor Quente / Corredor Frio)

• Corredor Frio: Admissão de ar externo através de paredes filtrantes. A pressão atmosférica fica ligeiramente positiva aqui.
• Corredor Quente: Os ASICs ficam embutidos em uma divisória selada (rack com dutos direcionais). As ventoinhas das próprias máquinas sopram o ar quente diretamente em uma câmara isolada, de onde um exaustor industrial joga tudo para fora.

4. OPEX e Custos Operacionais (Cálculo Mensal)

As despesas operacionais giram em torno de três pilares: eletricidade, aluguel do espaço, link de internet e manutenção preventiva.

Vamos usar um custo médio de eletricidade comercial de $0,07 por kWh.

Cálculo da Conta de Luz Mensal

• Consumo por Hora: 49 kW (miners) + 1,5 kW (ventilação e rede) = 50,5 kW
• Consumo Diário: 50,5 · 24 = 1.212 kWh
• Consumo Mensal (30,5 dias): 1.212 · 30,5 = 36.966 kWh
• Gasto com Energia por Mês: 36.966 · 0,07 $ = 2.587,62 $

Despesas Fixas Mensais (OPEX)

5. Projeção de Retorno, Payback (ROI) e Modelo Financeiro

Para projetar o faturamento, aplicamos as métricas de dificuldade da rede Bitcoin e recompensa de bloco vigentes em 2026. Vamos assumir que 1 TH/s rende cerca de $0,042 por dia (sem descontar a energia, considerando o BTC a ~$65.000).

Cálculo de Receita (Revenue)

• Hashrate Total: 2.800 TH/s
• Faturamento Diário: 2.800 · $0,042 = $117,60
• Faturamento Mensal (30,5 dias): $117,60 · 30,5 = $3.586,80

Lucro Líquido (EBITDA / Net Profit)

• Net Profit/mo = Receita ($3.586,80) - OPEX ($3.077,62) = $509,18 (se o rendimento por TH/s estiver alto, o valor sobe; com o BTC a $90.000, o lucro escala de forma proporcional).

Observação importante sobre a sensibilidade do ROI em relação ao preço do BTC e da energia:
Se o custo da eletricidade cair para $0,05 / kWh, o OPEX de energia despenca para $1.848,30 e o lucro líquido pula para $1.248,50 por mês. Isso reduz o prazo de payback de patamares inviáveis para razoáveis 35 a 40 meses. Minerar com tarifa comercial acima de $0,065–0,07/kWh sem bull run ou sem hardware de altíssima eficiência coloca a operação diretamente na zona de risco elevado.

6. Automação e Controle: Script Python de Monitoramento (CGMiner / CGMiner API)

Um engenheiro de verdade não fica perdendo tempo clicando na interface web de 14 dispositivos manualmente. Todos os ASIC miners modernos (Antminer, Whatsminer) suportam o protocolo CGMiner API (baseado em JSON via sockets TCP).

Abaixo está um script Python pronto para produção para monitorar o pool da sua farm. O script consulta todos os 14 ASICs na rede local, coleta o hashrate e a temperatura dos chips, e dispara um alerta direto no Telegram se houver queda de desempenho ou superaquecimento.

#!/usr/bin/env python3
"""
Monitoramento de farm de ASIC miners via CGMiner API (Porta 4028).
Funcionalidades:
  * consulta todos os dispositivos em paralelo;
  * Antminer (chave "command") e Whatsminer (chave "cmd") — o tipo é definido em MINERS;
  * alertas: offline, queda de hashrate, superaquecimento, campos de temperatura não encontrados;
  * desduplicação: o mesmo evento não é enviado mais de uma vez a cada REPEAT_MINUTES;
  * aviso de recuperação quando o problema é resolvido;
  * confirmação de problema ao longo de CONFIRM_CYCLES consultas consecutivas (proteção contra falsos positivos);
  * o estado é salvo em arquivo, funcionando perfeitamente em loop ou via cron (--once).
Configuração via variáveis de ambiente:
  TG_BOT_TOKEN, TG_CHAT_ID              — obrigatórias
  TEMP_THRESHOLD (padrão 85)            — limite de temperatura dos chips, °C
  HASHRATE_WARN_TH (padrão 170)         — hashrate mínimo aceitável, TH/s
  POLL_INTERVAL_SEC (padrão 60)         — intervalo de consulta no modo loop
  REPEAT_MINUTES (padrão 60)            — intervalo de repetição para o mesmo alerta
  CONFIRM_CYCLES (padrão 2)             — consultas consecutivas necessárias para confirmar um problema
Execução:
  python3 asic_monitor.py               # loop infinito
  python3 asic_monitor.py --once        # execução única (para cron / systemd timer)
IMPORTANTE: A porta 4028 deve ser acessível apenas a partir da rede local.
Nunca a exponha para a internet pública.
"""
import json
import logging
import os
import socket
import sys
import time
from concurrent.futures import ThreadPoolExecutor
import requests
# --------------------------------------------------------------------------
# Configuração
# --------------------------------------------------------------------------
# (ip, tipo): "antminer" ou "whatsminer"
MINERS = [(f"192.168.1.{i}", "antminer") for i in range(101, 115)]  # .101 - .114
# Exemplo de farm mista:
# MINERS[0] = ("192.168.1.101", "whatsminer")
API_PORT = 4028
SOCKET_TIMEOUT = 3.0
TG_BOT_TOKEN = os.environ.get("TG_BOT_TOKEN", "")
TG_CHAT_ID = os.environ.get("TG_CHAT_ID", "")
TEMP_THRESHOLD = float(os.environ.get("TEMP_THRESHOLD", "85"))
HASHRATE_WARN_TH = float(os.environ.get("HASHRATE_WARN_TH", "170"))
POLL_INTERVAL_SEC = int(os.environ.get("POLL_INTERVAL_SEC", "60"))
REPEAT_MINUTES = int(os.environ.get("REPEAT_MINUTES", "60"))
CONFIRM_CYCLES = int(os.environ.get("CONFIRM_CYCLES", "2"))
STATE_FILE = os.environ.get("STATE_FILE", "asic_monitor_state.json")
# Prefixos das chaves de temperatura dos chips na resposta `stats` do Antminer.
# Valide com o seu firmware: execute `stats` e inspecione as chaves reais.
ANTMINER_TEMP_PREFIXES = ("temp2_", "temp_chip")
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("asic_monitor")
# --------------------------------------------------------------------------
# Telegram
# --------------------------------------------------------------------------
def send_telegram(text: str) -> bool:
    """Envia uma mensagem sem parse_mode (texto dinâmico não quebra a formatação).
    Retorna True apenas se o Telegram aceitar a mensagem."""
    if not TG_BOT_TOKEN or not TG_CHAT_ID:
        log.error("TG_BOT_TOKEN / TG_CHAT_ID não definidos, alerta descartado: %s", text)
        return False
    url = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage"
    try:
        r = requests.post(url, json={"chat_id": TG_CHAT_ID, "text": text}, timeout=10)
        if not r.ok:
            log.error("Telegram retornou %s: %s", r.status_code, r.text[:200])
        return r.ok
    except requests.RequestException as e:
        log.error("Erro de transmissão para o Telegram: %s", e)
        return False
# --------------------------------------------------------------------------
# Interação com a CGMiner API
# --------------------------------------------------------------------------
def query_miner(ip: str, kind: str, command: str) -> dict:
    """Envia um comando para a CGMiner API. Em caso de falha, retorna {"error": "..."}."""
    key = "cmd" if kind == "whatsminer" else "command"
    try:
        with socket.create_connection((ip, API_PORT), timeout=SOCKET_TIMEOUT) as s:
            s.settimeout(SOCKET_TIMEOUT)
            s.sendall(json.dumps({key: command}).encode("utf-8"))
            chunks = []
            while True:
                chunk = s.recv(4096)
                if not chunk:
                    break
                chunks.append(chunk)
        text = b"".join(chunks).decode("utf-8", errors="ignore").replace("\x00", "")
        # Algumas versões de firmware retornam "}{" sem vírgula entre os objetos
        text = text.replace("}{", "},{")
        return json.loads(text)
    except Exception as e:  # rede, timeout, JSON inválido
        return {"error": f"{type(e).__name__}: {e}"}
def to_float(value):
    """Número ou string numérica -> float, caso contrário None."""
    try:
        return float(value)
    except (TypeError, ValueError):
        return None
def get_hashrate_th(summary: dict, kind: str):
    """Hashrate em TH/s ou None se o campo não for encontrado."""
    try:
        s = summary["SUMMARY"][0]
    except (KeyError, IndexError, TypeError):
        return None
    if kind == "whatsminer":
        # MH/s -> TH/s. Média de 5 minutos se disponível, caso contrário média da sessão.
        for key in ("MHS 5m", "MHS av"):
            v = to_float(s.get(key))
            if v is not None:
                return v / 1_000_000.0
        return None
    # Antminer: GH/s -> TH/s. Evitamos "GHS 5s" (oscila demais).
    for key in ("rate_30m", "GHS av"):
        v = to_float(s.get(key))
        if v is not None:
            return v / 1000.0
    return None
def get_max_chip_temp(ip: str, kind: str, summary: dict):
    """Temperatura máxima dos chips ou None se os campos não forem encontrados."""
    if kind == "whatsminer":
        try:
            s = summary["SUMMARY"][0]
        except (KeyError, IndexError, TypeError):
            return None
        temps = [to_float(s.get(k)) for k in ("Chip Temp Max", "Temperature")]
        temps = [t for t in temps if t]
        return max(temps) if temps else None
    stats = query_miner(ip, kind, "stats")
    try:
        info = stats["STATS"][1]
    except (KeyError, IndexError, TypeError):
        return None
    temps = []
    for k, v in info.items():
        if k.startswith(ANTMINER_TEMP_PREFIXES):
            t = to_float(v)
            if t:  # 0 = placa não retornando valor
                temps.append(t)
    return max(temps) if temps else None
# --------------------------------------------------------------------------
# Verificação de Dispositivo Individual
# --------------------------------------------------------------------------
def check_miner(ip: str, kind: str) -> dict:
    """Retorna {issue_key: texto_alerta} para problemas ativos."""
    issues = {}
    summary = query_miner(ip, kind, "summary")
    if "error" in summary:
        # Offline: verificações adicionais são inúteis
        return {"offline": f"⚠️ {ip}: API inacessível ({summary['error']})"}
    th = get_hashrate_th(summary, kind)
    if th is None:
        issues["parse"] = f"❌ {ip}: falha ao extrair hashrate do summary (verifique o firmware/tipo)"
    elif th < HASHRATE_WARN_TH:
        issues["hashrate"] = f"📉 {ip}: hashrate caiu para {th:.1f} TH/s (limite {HASHRATE_WARN_TH:.0f})"
    temp = get_max_chip_temp(ip, kind, summary)
    if temp is None:
        issues["temp_keys"] = f"❓ {ip}: campos de temperatura não encontrados, verifique as chaves em stats"
    elif temp > TEMP_THRESHOLD:
        issues["temp"] = f"🔥 {ip}: superaquecimento, chips a {temp:.0f}°C (limite {TEMP_THRESHOLD:.0f})"
    return issues
# --------------------------------------------------------------------------
# Estado e Desduplicação
# --------------------------------------------------------------------------
def load_state() -> dict:
    try:
        with open(STATE_FILE, encoding="utf-8") as f:
            return json.load(f)
    except (OSError, ValueError):
        return {"sent": {}, "streak": {}}
def save_state(state: dict) -> None:
    try:
        tmp = STATE_FILE + ".tmp"
        with open(tmp, "w", encoding="utf-8") as f:
            json.dump(state, f)
        os.replace(tmp, STATE_FILE)
    except OSError as e:
        log.error("Falha ao salvar o estado: %s", e)
def run_cycle(state: dict) -> None:
    sent, streak = state["sent"], state["streak"]
    now = time.time()
    with ThreadPoolExecutor(max_workers=len(MINERS)) as pool:
        results = list(pool.map(lambda m: (m[0], check_miner(*m)), MINERS))
    for ip, issues in results:
        # 1) Problemas ativos
        for key, text in issues.items():
            sid = f"{ip}|{key}"
            streak[sid] = streak.get(sid, 0) + 1
            if streak[sid] < CONFIRM_CYCLES:
                continue
            last = sent.get(sid)
            if last is None or now - last >= REPEAT_MINUTES * 60:
                if send_telegram(text):
                    sent[sid] = now
        # 2) Problemas resolvidos
        prefix = f"{ip}|"
        for sid in [s for s in list(streak) if s.startswith(prefix)]:
            key = sid[len(prefix):]
            if key in issues:
                continue
            streak.pop(sid, None)
            if sid in sent:  # notifica recuperação apenas se um alerta foi enviado anteriormente
                if send_telegram(f"✅ {ip}: problema '{key}' resolvido"):
                    sent.pop(sid, None)
    ok = sum(1 for _, i in results if not i)
    log.info("Varredura concluída: %d/%d saudáveis", ok, len(results))
    save_state(state)
# --------------------------------------------------------------------------
def main() -> None:
    state = load_state()
    state.setdefault("sent", {})
    state.setdefault("streak", {})
    if "--once" in sys.argv:
        run_cycle(state)
        return
    log.info("Iniciando monitoramento: %d dispositivos, período de %d s", len(MINERS), POLL_INTERVAL_SEC)
    while True:
        try:
            run_cycle(state)
        except Exception:
            log.exception("Exceção não tratada no loop de monitoramento")
        time.sleep(POLL_INTERVAL_SEC)
if __name__ == "__main__":
    main()

7. Checklist Pré-Voo (Aceitação de Engenharia)

• 1. Teste de Carga Elétrica: Coloque um aquecedor industrial de 50 kW para rodar por 4 horas antes de instalar os miners. Use um pirômetro para verificar o aquecimento dos blocos de contato no disjuntor principal e nas barras de distribuição. A temperatura dos contatos não deve ultrapassar 65°C.
• 2. Medição de Aterramento: Chame um laboratório elétrico para medir a impedância da malha fase-neutro e a resistência de dispersão do sistema de aterramento (deve ser < 4 Ohms).
• 3. Verificação de Fluxo de Ar: Certifique-se de que a resistência do filtro G4 não crie vácuo ou pressão negativa no ambiente (a porta do corredor frio deve abrir facilmente sem esforço excessivo com o exaustor ligado).
• 4. Configuração de Watchdog: Ative os recursos integrados de reinicialização automática por hardware (Hardware Auto-Reboot) no firmware dos miners (LUXOS, VNISH ou Stock) como rede de segurança contra queda de pool ou perda de IP.

Execução:

export TG_BOT_TOKEN="..." TG_CHAT_ID="..."
python3 asic_monitor.py

8. Enquadramento Jurídico, Contrato PPA e Contabilidade Fiscal Internacional

Rodar uma operação de 50 kW em qualquer jurisdição exige o status oficial de consumidor comercial. Minerar "por baixo do pano" puxando energia de uma tomada residencial comum vai inevitavelmente atrair notificações da concessionária de energia, multas pesadas por estouro de limite de demanda e uso irregular das redes.

Esquema de Estruturação e Arquitetura Legal

• Registro da Empresa Operacional (LLC / Ltda. / Inc.): A infraestrutura é registrada em nome de uma pessoa jurídica padrão de responsabilidade limitada. Isso é obrigatório para assinar legalmente contratos comerciais de locação de espaço e acordos de conexão com a rede elétrica.
• Contrato PPA (Power Purchase Agreement): O documento-chave da operação é o contrato comercial de fornecimento de energia elétrica (PPA) firmado com a concessionária ou o proprietário da subestação. O contrato fixa:
  • Demanda alocada: 50 kW sob a categoria de confiabilidade III (com carga contínua permitida 24/7).
  • Ponto de entrega e fronteira de medição: 0,4 kV nos barramentos de baixa tensão do transformador.
  • Estrutura tarifária: Custo fixo por kWh (meta < $0,065–0,07).
• Importação de Hardware (Código HS 8471): A aquisição dos ASICs é feita via contrato B2B direto. O código do Sistema Harmonizado (HS Code) internacional para o equipamento é 8471 50 000 0 (unidades de processamento). Em um processo de importação formal ("canal verde/branco"), são pagos o imposto de importação e os tributos aplicáveis (ICMS/PIS/COFINS), deixando em mãos as declarações de importação e faturas comerciais que comprovam a origem dos ativos imobilizados.
• Contabilidade Fiscal e Conversão (Off-ramping): O lucro da mineração é gerado em BTC diretamente no pool. Para cobrir os custos operacionais mensais (OPEX: energia, aluguel), utiliza-se uma conta institucional (Corporate Account) em uma corretora de criptomoedas ou mesa OTC com o processo de KYB (Know Your Business) concluído. Os fundos em fiat obtidos são transferidos via TED/wire transfer para a conta bancária PJ para pagar as contas de luz regularmente.

9. Logística e Recebimento de Equipamentos

O peso de 14 unidades do Antminer S21 na embalagem de fábrica é de aproximadamente 230–250 kg.

Protocolo de Inspeção de Entrada (QC na Entrega)

• 1. Inspeção Visual da Embalagem: Verificação de lacres invioláveis e avarias nas caixas.
• 2. Shake Test (Verificação de Dissipadores): Durante o transporte internacional, fortes vibrações podem espanar parafusos de fixação ou soltar dissipadores individuais dos chips (especialmente em hardwares usados). O equipamento deve ser chacoalhado levemente — não pode haver som de peças soltas por dentro.
• 3. Teste de Resistência (Cold Test): Antes de aplicar 220V, usa-se um multímetro para verificar a ausência de curto-circuito nos barramentos de alimentação das hash boards (a resistência da linha VDD deve bater com o manual, na casa de dezenas de ohms).
• 4. Bancada de Testes (15 minutos): Ligação sequencial em um circuito isolado. Validação do atingimento do hashrate alvo (200 TH/s), resposta das 3 placas (3/3 Boards detected) e ausência de chips defeituosos (HW Errors < 0.5%).

10. Segurança e Isolamento de Rede

Uma fazenda de 50 kW é um alvo atra tanto para furto físico quanto para ataques cibernéticos (sequestro de tráfego stratum, injeção de malware de mineração).

Arquitetura da Topologia de Rede:
[ Internet (WAN) ]
          &│
     [ Backup 4G/LTE ]
           &│
   ┌───────┴────────┐
   │ Router / WAF │ (MikroTik / OPNsense)
   │ Firewall │ ── WireGuard VPN (Apenas Acesso Remoto)
   └───────┬────────┘
           │ (VLAN Isolada 10.0.10.0/24)
  ┌────────┼─────────────────┬─────────────────┐
  │        │                 │                 │
[ASIC 1] [ASIC 2] ...    [ASIC 14]     [Node do Script]
10.0.10.101 10.0.10.102  10.0.10.114    10.0.10.250 (Python Watchdog)

Parâmetros do Perímetro de Rede

• Isolamento Total da WAN: Os ASICs ficam em um segmento de VLAN fechado, sem IP público exposto.
• Porta 4028 Fechada (CGMiner API): O acesso à porta de coleta de métricas é liberado estritamente para o IP do servidor de monitoramento interno.
• Criptografia Stratum/TLS: Rotear o tráfego para o pool via Stratum V2 ou Stratum over TLS elimina qualquer chance de ataque de homem do meio (MitM) para redirecionamento de carteira no nível do provedor.

11. Resumo do Engenheiro (Checklist de Implantação)

• 1. Elétrica: Conferir a bitola dos cabos VVGng-LS 3x2.5 mm² para cada tomada C19, reapertar com torquímetro todos os bornes no QGBT após 48 horas de operação sob carga.
• 2. Ventilação: Medir o delta de temperatura entre insuflamento e exaustão. Se $\Delta T > 18^\circ\text{C}$, colocar os exaustores em rotação mais alta via inversor de frequência (VFD).
• 3. Monitoramento: Subir o script automatizado de controle dos ASICs com alertas configurados para quedas de hashrate abaixo de 170 TH/s.
• 4. Gestão de Risco Financeiro: Projetar o ponto de equilíbrio (break-even) considerando um crescimento potencial na dificuldade da rede de 15–20% ao ano.