rbAmp
PT
Loja
Docs
Atualizado a · Editar no GitHub [Edit on GitHub]

03 · Seleção do sensor de corrente

Instalação da pinça de TC: prenda apenas o fio L, com a seta apontada para a carga.

Este capítulo responde a duas perguntas:

  1. Que sensor de corrente escolher para uma dada carga.
  2. Como indicar ao módulo rbAmp a sua escolha para que a calibração de fábrica dessa combinação seja carregada automaticamente.

A ligação física do sensor (orientação da pinça, verificação de polaridade L/N) está descrita em 04_hardware.md. Este capítulo trata da seleção do modelo e da chamada à API.

Classe do sensor

Os módulos rbAmp funcionam com pinças de corrente da família SCT-013. A classe do sensor para uma pinça SCT-013 de encaixe que instala por si é definida uma vez com setSensorClass(Sct013), antes de escolher o modelo. Se o seu módulo veio com o TC já ligado, salte as chamadas de configuração deste capítulo.

Escolher um modelo SCT-013

Dentro da família SCT-013 há sete modelos suportados (códigos {1, 2, 3, 4, 5, 6, 7}).

code Modelo Gama de corrente Estado Utilização típica
1 SCT-013-005 0…5 A ✅ caracterizado Cargas pequenas — candeeiros, eletrónica de baixa potência, um interruptor simples
2 SCT-013-010 0…10 A ✅ caracterizado Um eletrodoméstico de média potência — frigorífico, máquina de lavar roupa, ar condicionado até 2 kW
3 SCT-013-030 0…30 A ✅ caracterizado Entrada de serviço doméstica de média dimensão — até ~7 kW
4 SCT-013-050 0…50 A ✅ caracterizado Entrada de serviço de grande dimensão — aquecimento elétrico, carregador de VE, moradia unifamiliar com cargas de pico
5 SCT-013-100 0…100 A ✅ caracterizado Entrada de serviço principal de uma casa ou pequeno escritório
6 SCT-013-020 0…20 A ✅ caracterizado Entrada de serviço média — eletrodomésticos de 3–4 kW, grandes eletrodomésticos domésticos
7 SCT-013-060 0…60 A ✅ caracterizado Subcontador industrial
Nota

Códigos aceites — {1, 2, 3, 4, 5, 6, 7}. Um código fora deste conjunto (por exemplo 0 ou 8) passado a dev.setCTModel(...) (ou a configureChannels(...)) devolve false com lastError() == RB_ERR_PARAM — a biblioteca não envia a escrita ao dispositivo (guarda do lado do cliente).

Os códigos 0x06 e 0x07 não são monótonos por calibre — foram acrescentados após o conjunto original 0x01..0x05. Escolha sempre pelo calibre de que precisa, e não pela ordem dos códigos.

Como escolher o modelo certo

A regra básica:

  1. Determine a corrente máxima que pode circular no circuito (maior carga + margem de 30 %).

  2. Leia o modelo na etiqueta impressa na pinça.

  3. Uma regra: escolha a pinça de menor calibre acima da sua maior corrente esperada. Uma pinça com calibre demasiado pequeno satura nos picos e lê baixo; uma com calibre muito grande lê com ruído em correntes pequenas (uma SCT-013-100 num circuito de 5 A funciona, mas com má resolução).

Como escolher uma pinça SCT-013: tome a maior corrente esperada mais 30 % de margem, escolha a pinça de menor calibre acima dela e defina o seu código de modelo.

Margem

Uma pinça SCT-013 funciona sem saturação dentro da sua gama nominal. Picos breves (arranque de compressor, carga indutiva) podem exceder o calibre em 5-7× — isto é normal, a pinça suporta-o fisicamente, mas a medição torna-se não linear acima do calibre.

Se a sua carga tiver um pico de corrente acima da classificação da pinça, escolha a seguinte maior: a pinça classificada mais pequena acima do pico mais uma margem de 30 %. Por exemplo, para uma máquina de lavar com corrente de arranque de 12 A (e 2–3 A em funcionamento), 12 A × 1.3 = 15.6 A, pelo que escolha um SCT-013-020 (e não um SCT-013-005, que cortaria no pico).

Informar o módulo sobre a sua escolha

São necessárias duas chamadas na ordem correta — primeiro setSensorClass(), depois setCTModel(). Se chamar setCTModel() antes de setSensorClass(), o módulo devolve um erro RB_ERR_PARAM e a predefinição NÃO é carregada.

Nota

O modelo de TC é uma predefinição funcional, não uma etiqueta. Escrever o modelo de TC aplica de imediato a calibração de fábrica dessa pinça ao pipeline de medição do módulo; as leituras de corrente mudam. Alterar a sensor_class repõe o modelo de TC a predefinição (0) e exige voltar a defini-lo.

C++
#include 
#include 

RbAmp dev(Wire, 0x50);

void setup() {
    Wire.begin();
    while (!dev.begin()) { delay(500); }

    // Step 1: select the sensor family. REQUIRED before setCTModel().
    if (!dev.setSensorClass(RbAmpSensorClass::Sct013)) {
        // setSensorClass failed — check the connection, power, and address.
        return;
    }

    // Step 2: select the model within the family.
    if (!dev.setCTModel(RbAmpCTModel::Sct013_030)) {
        // Possible causes (any → RB_ERR_PARAM):
        //  1. setSensorClass() was not called before setCTModel()
        //  2. code not in the per-class accept-set (for Sct013: {1,2,3,4,5,6,7})
        //  3. no factory preset for the selected class
        //     (applies to WiredCT / BuiltinCT in the current firmware)
        //  4. communication error (RB_ERR_IO, not RB_ERR_PARAM — a separate code)
        return;
    }
}
Nota

A biblioteca NÃO chama setSensorClass() em nome do utilizador. Se este passo for omitido, setCTModel() devolve false com RB_ERR_PARAM sem escrever na flash. Isto mantém o comportamento previsível e explícito — sem «magia» na API pública.

Após estas duas chamadas:

  • O módulo guarda ambos os valores na flash — a definição sobrevive a um reinício, a um corte de alimentação e a uma nova gravação do firmware.

  • Os coeficientes de calibração para essa combinação específica (classe do sensor + modelo) são carregados a partir da tabela de predefinições de fábrica. Não precisa de tocar em nenhum registo de calibração manual.

  • A chamada seguinte a dev.readCurrent(0) já devolve um valor em ampere com a escala correta.

O tempo total das duas chamadas é de cerca de 1.4 segundos (duas operações de escrita na flash × ~700 ms cada, limitado pelo tempo de apagar a página da flash). É feito uma vez na primeira instalação; a definição fica guardada na flash e não é repetida.

Nota

Se já selecionou o sensor no primeiro arranque e está apenas a reiniciar o controlador, não precisa de repetir as chamadas setSensorClass() e setCTModel() — o módulo lembra-se da escolha anterior. Mas também não faz mal: chamar de novo com o mesmo valor apenas reescreve o mesmo byte.

Verificar a configuração

Uma verificação simples após setCTModel():

C++
void setup() {
    Wire.begin();
    while (!dev.begin()) { delay(500); }
    dev.setSensorClass(RbAmpSensorClass::Sct013);
    dev.setCTModel(RbAmpCTModel::Sct013_030);

    Serial.print(F("Ready. Connect a purely resistive load "));
    Serial.println(F("(for example, an incandescent lamp)."));
    Serial.println(F("Expect a steady PF ≈ 1.0 and positive P."));
}

void loop() {
    Serial.print(F("U=")); Serial.print(dev.readVoltage(), 1);
    Serial.print(F("V  I=")); Serial.print(dev.readCurrent(0), 2);
    Serial.print(F("A  P=")); Serial.print(dev.readPower(0), 1);
    Serial.print(F("W  PF=")); Serial.println(dev.readPowerFactor(0), 2);
    delay(2000);
}

Numa carga puramente resistiva (lâmpada incandescente, chaleira elétrica, elemento de aquecimento), espere:

  • U ≈ 220–240 V (para uma rede de 230 V)
  • I ≈ igual à potência da carga (P / U)
  • P > 0 e estável
  • PF ≈ 1.0 (firmemente positivo)

Se algo não bater certo, veja 10_troubleshooting.md.

Módulos com vários canais de corrente

A gama de SKUs — o que serve para cada trabalho

SKU Canais I Canal U Utilização típica
UI1 1 sim Uma carga única com cálculo completo de potência (P, PF, Q, Wh) — um contador de rede típico
UI2 2 sim Duas cargas independentes numa mesma fase com potência por canal
UI3 3 sim 1 U + 3 I — três cargas numa fase com potência por canal (P, PF, Q, Wh)
I1 1 não Sub-contador sem cálculo de potência (apenas corrente) — quando uma UI1 separada trata da medição da rede
I2 2 não Subcontador de corrente de dois canais — repartição por circuito
I3 3 não Subcontador de corrente de três canais — repartição por circuito / topologia de duplo TC

O que mede cada canal

  • Canal U (apenas UI): U_rms, U_pico, frequência. Um* por módulo.
  • Canais I:
  • em variantes UI — cada canal fornece I_rms, I_pico, P (potência ativa), PF, avg_p sobre o período.
  • nas variantes I — apenas corrente (I_rms, I_pico). A potência ativa e o PF não são calculados — exigem tensão, que a variante I não tem. Os registos power[]/powerFactor[] nas variantes I devolvem 0.
  • Módulo monofásico: todos os canais I têm de estar na mesma fase à qual o canal U está ligado.

Modelo de TC por canal — calibração independente por canal

Nos módulos multicanal (I2, I3), cada canal de corrente tem uma seleção de modelo SCT-013 independente. Pode, por exemplo, ligar um SCT-013-005 ao canal 0 (uma única tomada), um SCT-013-030 ao canal 1 (um circuito de fogão) e um SCT-013-020 ao canal 2 (a entrada de serviço).

C++
uint8_t models[3] = {1, 3, 6};   // ch0=SCT-013-005, ch1=SCT-013-030, ch2=SCT-013-020
dev.configureChannels(RbAmpSensorClass::Sct013, models, 3);

Uma única chamada configura a classe do sensor + todos os canais numa só operação com um único SAVE_USER_CONFIG no final. Medido na bancada: ~1.4 segundos para 1 SAVE contra ~3.5 segundos para 3 ciclos SAVE separados (setCTModel() + gravação manual). O ponto-chave — o desgaste do ciclo de flash é 3× inferior na mesma página de flash.

Método 2: setCTModel(channel, code) por canal — qualquer ordem

A API para a seleção por canal é setCTModel(channel, code):

C++
dev.setSensorClass(RbAmpSensorClass::Sct013);   // once for all channels

// v1.3: binding order is arbitrary.
dev.setCTModel(0, 1);   // SCT-013-005
dev.setCTModel(1, 3);   // SCT-013-030
dev.setCTModel(2, 6);   // SCT-013-020

dev.saveUserConfig();    // explicit save at the end (3-SAVE alternative, slower)
Segurança

✅ A ordem de associação é arbitrária (v1.3). Escrever REG_CT_MODEL (0x05) prepara o valor mas não o aplica automaticamente a nenhum canal. A aplicação faz-se apenas através do CMD_SET_CT_MODEL_CHn por canal, que usa o valor preparado atual e o escreve no seu canal. Os canais podem ser configurados em qualquer ordem (setCTModel(0, ...) primeiro, último ou intercalado — não faz diferença); não há sobreposição. Qualquer menção a «ascendente / descendente / associar o ch0 por último» em documentos e bases de código antigos refere-se ao comportamento anterior à v1.3 — pode ser removida.

Dito isto, a associação de cada canal continua a ser em dois passos ao nível do protocolo de transmissão (preparar REG_CT_MODEL → associar CMD_SET_CT_MODEL_CHn); o setCTModel(channel, code) da biblioteca encapsula os dois passos.

Se todos os canais receberem o mesmo modelo, a ordem não importa (o efeito secundário é idempotente):

C++
dev.setSensorClass(RbAmpSensorClass::Sct013);
dev.setCTModel(0, RbAmpCTModel::Sct013_005);
dev.setCTModel(1, RbAmpCTModel::Sct013_005);   // ch0 is rewritten with the same value — no effect
dev.setCTModel(2, RbAmpCTModel::Sct013_005);
Compatibilidade com versões anteriores

: a sobrecarga inteira setCTModel(uint8_t code) é mantida. Mapeamento da v1.3: 1=Sct013_005, 2=Sct013_010, 3=Sct013_030, 4=Sct013_050, 5=Sct013_100, 6=Sct013_020, 7=Sct013_060. O enum tipado RbAmpCTModel::Sct013_NNN é a forma recomendada (o compilador apanha valores inválidos antes da chamada ao barramento). Em módulos multicanal, o setCTModel(code) de um só argumento aplica-se ao canal 0 — equivalente a setCTModel(0, code).

Módulos multicanal — I2 e I3 (apenas corrente)

O hardware atual para a topologia multicanal é o I2 (dois canais de corrente) e o I3 (três canais de corrente). Ambos os módulos não têm canal U, pelo que o cálculo de P / PF / Q no lado do módulo não é possível — fornecem corrente por canal (I_rms, I_pico em cada canal) e nada mais.

UI2 (1 U + 2 I) e UI3 (1 U + 3 I) acrescentam o canal de tensão ao mesmo layout multicanal, pelo que a potência por canal é calculada no próprio módulo. Quando não é preciso potência no módulo, use I2/I3 como subcontadores de corrente emparelhados com um UI1 separado na entrada de serviço, que fornece a energia da rede + tensão.

Leitura de canais (I2 / I3)

C++
float i0 = dev.readCurrent(0);   // ch0
float i1 = dev.readCurrent(1);   // ch1
float i2 = dev.readCurrent(2);   // ch2 — I3 only

// On an I variant readPower(...) returns 0.0 — this is by design.
float p_dummy = dev.readPower(0);  // = 0.0f

Se precisar de potência ativa em cada subcircuito, instale um UI1 na entrada de serviço e reparta a sua potência total proporcionalmente à corrente por canal I[k] dos I2/I3. Esta é uma implementação doméstica típica (ver o capítulo 06 · Exemplos, cenário 1).

Nota

Trata-se de uma aproximação: a repartição por corrente funciona quando o PF é aproximadamente o mesmo em todas as cargas. Para uma medição de potência exata por carga, use uma variante UI em cada linha (quando UI2/UI3 estiverem disponíveis).

Aplicações I2 / I3

  • Subcontagem de corrente: repartição da corrente por circuito, com um único ponto de instalação no quadro em vez de um módulo por linha.

  • Desagregação emparelhada com a UI1: a UI1 fornece a energia / potência da rede, e as I2/I3 decompõem o consumo por ramal (ver capítulo 06, cenário 1).

  • Monitorização de corrente sem medição de potência: controlo de sobrecarga, deteção de ligar/desligar carga, um perfil I(t).

  • Duplo TC + um terceiro canal (I3): uma pinça grande no canal 0 para uma gama ampla, uma pinça pequena no canal 1 para precisão com correntes baixas, e o terceiro canal para uma linha auxiliar separada. Veja a secção "Configuração avançada: duas pinças de calibres diferentes" abaixo.

Configuração avançada: duas pinças de calibres diferentes num só fio

Nota

⚙ Um padrão avançado, não um básico. Esta secção descreve uma técnica opcional para melhorar a resolução com correntes baixas. Na maioria das instalações, uma só pinça ajustada à gama de carga é suficiente. Use o duplo TC apenas se tiver um requisito específico de precisão para correntes < 1 A.

Quando se aplica

  • Módulos multicanal I2 / I3 (hardware atual).
  • O mesmo fio tem de ser medido tanto para cargas pequenas (≤ 1 A) como para eventos de pico (≥ 5 A) com a mesma qualidade.

  • Um exemplo típico: uma entrada de serviço de um apartamento com 50-100 W de consumo em espera durante o dia e um arranque de chaleira ou fogão de 3+ kW ao fim do dia.

A ideia

Duas pinças SCT-013 de classificações diferentes instaladas no mesmo fio:

  • Canal 0 — uma pinça pequena (por exemplo, SCT-013-005, 5 A): vê correntes pequenas com melhor resolução e um piso de ruído mais baixo.

  • Canal 1 — uma pinça grande (por exemplo, SCT-013-030 ou superior): trata correntes acima do ponto de sobrecarga da pinça pequena sem saturar.

O próprio master escolhe o canal a usar com base no valor da corrente — enquanto a pinça pequena está na sua zona linear, a leitura é mais precisa; quando é excedida, passa para a grande.

Configuração (qualquer ordem — v1.3)

A classe do sensor primeiro uma vez, depois os modelos por canal em qualquer ordem. Na v1.3 escrever REG_CT_MODEL apenas prepara um valor; a associação faz-se através do comando por canal CMD_SET_CT_MODEL_CHn, pelo que os canais nunca se sobrescrevem uns aos outros. (A solução "ordem descendente" aplicava-se apenas ao firmware anterior à v1.3 e já não é necessária.)

C++
dev.setSensorClass(RbAmpSensorClass::Sct013);  // once

// Order is arbitrary — staging is decoupled from binding.
dev.setCTModel(0, RbAmpCTModel::Sct013_005);   // ch0 (range 0..5 A)
dev.setCTModel(1, RbAmpCTModel::Sct013_030);   // ch1 (range 0..30 A)

Estado final: ch0 = SCT-013-005, ch1 = SCT-013-030. ✓

Lógica de agregação do lado do mestre

O padrão mais simples é ativar um limiar:

C++
float read_combined_current(RbAmp& dev) {
    const float i_low  = dev.readCurrent(0);   // small clamp
    const float i_high = dev.readCurrent(1);   // large clamp

    // While the small clamp is well clear of saturation, it gives
    // better accuracy at low currents. We switch to the large one as
    // it approaches the overload point.
    //
    // The 4.5 A threshold for the SCT-013-005 is PROVISIONAL; the exact
    // value will be determined by bench validation (see below).
    // Behavior in the vicinity of the threshold is a matter of
    // measurement, not estimation.
    if (!isnan(i_low) && i_low < 4.5f) {
        return i_low;
    }
    return i_high;
}

Instalação de duplo TC: duas pinças no mesmo fio L, uma de gama baixa e outra de gama alta, ambas com as setas viradas para a carga.

Nota

⚙ Limitação. Os valores para a utilização de duplo TC com correntes baixas (comportamento perto do limiar, deriva térmica, divergência das duas pinças na gama de sobreposição) não são publicados. Trate o duplo TC como um padrão-piloto; para aplicações críticas é preferível uma só pinça ajustada ao limite superior da gama de carga.

Abordagens para melhorar a sensibilidade com correntes baixas

Se a sua carga tiver uma ampla gama dinâmica (por exemplo, 1 W em espera num router contra um aquecedor de imersão de 2000 W na mesma tomada), uma única pinça dimensionada para o limite superior perde as correntes baixas no ruído.

Três estratégias por ordem crescente de complexidade:

  1. Dimensione o TC para o máximo, não "com margem". O erro mais comum é pôr um SCT-013-100 (100 A) numa tomada doméstica com um consumo típico de 0.5–10 A. O sinal fica na faixa inferior de 1–10 % do alcance do sensor — onde o ruído se torna comparável ao sinal. Para um cenário doméstico (tomada de 16 A) um SCT-013-030 é o ideal; para ligar um único aparelho (≤ 5 A) um SCT-013-005.

  2. Topologia de duplo TC (requer um SKU I2/I3 — dois canais de corrente num só módulo): uma pinça pequena para a faixa inferior + uma grande para a faixa superior, com o master a escolher por limiar. Ver a secção «Topologia de duplo TC» acima — o padrão é um piloto, e os números não são publicados.

  3. Piso de ruído calibrado de fábrica: a calibração do módulo já tem em conta o seu piso de ruído. Do lado do utilizador, nada é necessário além de setSensorClass() + setCTModel(). Os valores de precisão específicos para correntes baixas não são publicados.

Modo de produção vs. modo de fábrica (referência de persistência)

O módulo rbAmp funciona em dois modos que diferem em exatamente o que é guardado na flash. O modo atual é lido do registo de estado correspondente.

Comando (opcode) Produção Persiste
CMD_SAVE_USER_CONFIG (0x32) ✅ OK ct_model / sensor_class / TC por canal / fleet_config / group_id / label
CMD_COMMIT_ADDR (0x30, armado por magic) ✅ OK Endereço I²C (ver 04 · Ligação — alterar o endereço)
CMD_RESET (0x01) ✅ OK — (reinício por software)
CMD_LATCH_PERIOD (0x27) ✅ OK — (instantâneo de período)
CMD_CLEAR_ERROR ✅ OK —
CMD_SAVE_GAINS ❌ BLOQUEADO em produção (rejeição silenciosa; REG_ERROR=0xFE; o reinício reverte) ganhos / NF / fase (calibração de fábrica)
CMD_FACTORY_RESET ❌ BLOQUEADO em produção —

Em modo de produção, as escritas de calibração de fábrica (CMD_SAVE_GAINS, CMD_FACTORY_RESET) são rejeitadas pelo firmware — isto protege contra a sobrescrita acidental dos coeficientes de fábrica. Colocar o módulo em modo de fábrica é uma operação do fabricante.

Leitura de verificação ≠ persistência.

A proteção de produção aceita uma escrita para a RAM (uma leitura posterior devolve o que foi escrito), mas a gravação na flash pode ser rejeitada. Depois de um reinício, o valor reverte. A única forma válida de confirmar a persistência é reiniciar o módulo via CMD_RESET e voltar a ler:

C++
dev.setCTModel(code);
dev.reset();                     // CMD_RESET 0x01, works in production
delay(300);                      // boot complete
uint8_t check = dev.ctModel(0);
assert(check == code);           // ONLY now is persistence confirmed

✅ REG_I2C_ADDRESS (0x30) lê o endereço ATIVO no arranque (v1.3). Após um reinício pós-commit, ler 0x30 mostrará o novo endereço ativo. O eco de preparação (após uma escrita do anfitrião) mantém-se por conceção até CMD_COMMIT_ADDR + reinício.

Referência cruzada: 09 · Referência da API — detalhes sobre opcodes específicos; 10 · Resolução de problemas — o que fazer se a persistência não for confirmada.

O que vem a seguir


Fonte e problemas: rb-amp/rbamp-arduino · esta página no repositório: docs/03_sensor_selection.md (v1.6.2)