Frecuencia y conteo de pulsos

Esta familia cuenta pulsos eléctricos en un pin. Con ella mides cosas que “laten”: las RPM de un motor (tacómetro), el caudal de agua (caudalímetro), la velocidad del viento (anemómetro), objetos que pasan por una cinta o un encoder simple. La placa cuenta los pulsos con interrupciones de hardware (muy rápido) y te manda el conteo cada cierto tiempo.

Empezar a contar: frequencyReport(pin, modo, reportDelayMs, callback)

Cada parámetro:

• pin: debe ser un pin con capacidad de interrupción (no todos pueden detectar pulsos rápidos). En Arduino Uno/Nano son los pines 2 y 3; en Mega y ESP32 hay más. Revisa tu placa.
• modo: qué dispara una cuenta. Un flanco es el instante en que la señal cambia de nivel: de bajo a alto (flanco de subida) o de alto a bajo (flanco de bajada). El modo es uno de board.FREQUENCY_MODES:

Modo	Cuenta cuando…	Uso típico
RISING	hay un flanco de subida (LOW → HIGH)	lo más común: 1 pulso = 1 cuenta
FALLING	hay un flanco de bajada (HIGH → LOW)	igual que RISING, otro flanco
CHANGE	hay cualquier flanco (sube o baja)	cuenta 2 por pulso completo
HIGH	mientras el pin está en alto	señales por nivel
LOW	mientras el pin está en bajo	señales por nivel

• reportDelayMs: cada cuántos milisegundos la placa te manda un reporte. Máximo 16383. Por ejemplo, 1000 = un reporte por segundo.
• callback: se llama en cada reporte con un objeto { pin, timestamp, ticks }:
  • pin: el pin que reporta.
  • ticks: el total acumulado de pulsos contados desde que llamaste a frequencyReport. No se reinicia en cada reporte: sigue creciendo.
  • timestamp: el tiempo de la placa (ms desde que encendió) en ese reporte.

ticks es acumulado

Como ticks siempre crece, para obtener una tasa (Hz o RPM) debes restar dos reportes consecutivos. Si solo quieres un total (p. ej. litros acumulados), úsalo directamente.

Ejemplo 1 — pulsos por segundo (Hz)

let ultTicks = 0;
let ultTiempo = 0;

board.frequencyReport(2, board.FREQUENCY_MODES.RISING, 1000, ({ ticks, timestamp }) => {
  if (ultTiempo > 0) {
    const dPulsos = ticks - ultTicks;             // pulsos en esta ventana
    const dSeg = (timestamp - ultTiempo) / 1000;  // segundos transcurridos
    varG.hz = dPulsos / dSeg;                      // frecuencia en Hz
  }
  ultTicks = ticks;
  ultTiempo = timestamp;
});

ultTicks/ultTiempo guardan el reporte anterior; en cada reporte calculamos la diferencia para saber cuántos pulsos hubo en ese intervalo.

Ejemplo 2 — tacómetro (RPM)

Si el sensor da N pulsos por vuelta (aquí 2):

const PULSOS_POR_VUELTA = 2;
let ultTicks = 0, ultTiempo = 0;

board.frequencyReport(2, board.FREQUENCY_MODES.RISING, 1000, ({ ticks, timestamp }) => {
  if (ultTiempo > 0) {
    const vueltas = (ticks - ultTicks) / PULSOS_POR_VUELTA;
    const minutos = (timestamp - ultTiempo) / 60000; // ms → minutos
    varG.rpm = vueltas / minutos;
  }
  ultTicks = ticks;
  ultTiempo = timestamp;
});

Ejemplo 3 — caudalímetro (litros)

Un sensor de flujo da K pulsos por litro. Aquí el acumulado es justo lo que queremos (volumen total):

const PULSOS_POR_LITRO = 450;

board.frequencyReport(2, board.FREQUENCY_MODES.RISING, 1000, ({ ticks }) => {
  varG.litrosTotales = ticks / PULSOS_POR_LITRO;
});

Ejemplo 4 — usar CHANGE

CHANGE cuenta los dos flancos, así que hay 2 cuentas por pulso real; divide entre 2:

board.frequencyReport(2, board.FREQUENCY_MODES.CHANGE, 1000, ({ ticks }) => {
  varG.pulsosReales = ticks / 2;
});

Filtrar rebotes: frequencyFilter(pin, minTickMicroseconds)

Los contactos mecánicos (un interruptor, un sensor reed) no cierran limpio: “rebotan” durante unos microsegundos y generan varios flancos falsos por cada pulso real, inflando el conteo. El filtro ignora cualquier flanco que llegue antes de minTickMicroseconds desde el anterior.

board.frequencyFilter(2, 1000); // ignora pulsos a menos de 1000 µs (1 ms) del previo

• Úsalo con sensores mecánicos (interruptores, reed).
• No lo uses con señales electrónicas limpias y rápidas: perderías pulsos reales.
• Elige un valor por debajo del intervalo del pulso real más rápido que esperas.

Detener: frequencyClear(pin)

board.frequencyClear(2);    // deja de contar en el pin 2
board.frequencyClear(0x7F); // 0x7F = todos los pines

Errores típicos

• Pin sin interrupción → no cuenta nada. Usa 2 o 3 en Uno/Nano.
• Olvidar que ticks es acumulado y no restar → la frecuencia sale disparada.
• Rebotes inflando el conteo en sensores mecánicos → usa frequencyFilter.
• reportDelayMs mayor que 16383 → da error (el campo es de 14 bits).