Horticulture Lighting Driver with PPFD Sensor Loop
← Back to: Lighting & LED Drivers
A horticulture lighting driver is not just constant-current regulation—it must keep PPFD and the spectral recipe stable over time using closed-loop sensing, synchronized multi-channel control, and long-run thermal/aging compensation. The practical goal is repeatable plant-plane light delivery (PPFD/DLI) with traceable evidence logs, so performance stays predictable from day one through thousands of hours.
Horticulture Lighting Driver: What It Must Guarantee
The 3 horticulture KPIs (the “deliverable”)
- Light quantity: hold PPFD at the canopy to target (stage-dependent) and keep DLI on-plan (daily accumulated dose).
- Spectral recipe: maintain channel ratios (e.g., R/B/FR/W) so the recipe does not drift as LEDs heat up or age.
- Time plan (photoperiod): execute scenes (on/off windows, ramps, fades) so “how long” and “when” are deterministic.
Scope boundary: This page treats upstream power as a bus contract (e.g., 24V/48V range). Detailed PSU topologies and network protocols are intentionally out of scope.
Minimal definitions (only what is used for design & acceptance)
PPFD (μmol·m⁻²·s⁻¹): the “instantaneous output” at the canopy plane. Treat it like Vout in a power supply—something to hold stable.
DLI (mol·m⁻²·day⁻¹): daily integral of PPFD. In engineering terms, it is the area under the PPFD curve.
Photoperiod: the time schedule (hours on/off + ramps) that shapes DLI and stage recipes.
Engineering rule of thumb (unit-consistent):
DLI (mol·m⁻²·day⁻¹) ≈ PPFDavg (μmol·m⁻²·s⁻¹) × LightHours × 0.0036
0.0036 = 3600 seconds/hour × 10⁻⁶ mol/μmol. Use this to translate “PPFD target + hours” into a DLI plan.
Evidence fields to freeze (inputs → measurable outputs)
Spec inputs (must be explicit):
- Stage targets: PPFD_target, DLI_target, photoperiod (hours + ramp profile).
- Recipe vector: channel ratios (e.g., R/B/FR/W) + allowed deviation (Δratio).
- Dimming needs: minimum PPFD, ramp smoothness, channel sync tolerance.
- Allowed drift: %/°C and % per 1000h (quantity + recipe stability).
Measured outputs (acceptance + debug):
- PPFD_meas (raw + filtered) with timestamp + active scene ID.
- I_set / I_meas per channel (R/B/FR/W) to prove recipe integrity.
- Temp_NTC (and optional estimated Tj) to prove derating behavior.
- RuntimeHours + AgingFactor to prove long-term compensation is actually applied.
- FaultLog snapshots: open/short/OV/OT + PPFD/temp/current at event time.
When a PPFD sensor loop is mandatory: tight drift limits, large thermal swings, long maintenance intervals, multi-luminaire uniformity requirements, or multi-channel recipes that must remain stable over aging.
System Architecture for a Multi-Channel Grow Light Node
The 4 blocks and what each must expose
- Upstream PSU (bus contract): provides a stable DC bus (example: 24V/48V). This page uses it as an interface assumption only.
- N-channel constant-current stages: one channel per spectrum band; each channel must support I_set (command), I_meas (telemetry), and Fault flags (open/short/OT).
- Sensing (PPFD + temperature): PPFD sensor provides the feedback variable; NTC (or thermal sensors) protect LEDs and stabilize output via derating.
- Controller + recipe table: scheduler (photoperiod), recipe vectors (R/B/FR/W), PPFD loop, channel allocation, and logs for acceptance + field debug.
Design goal: Make the system auditable. A grow light should be able to “prove” PPFD stability, recipe integrity, and thermal safety using measurable telemetry, not assumptions.
Interface contracts (what must be specified upfront)
Bus contract (PSU → driver): VBUS min/max, allowed ripple, startup slope expectation, and UV/OV behavior (brownout handling).
Channel contract (controller → power stage): I_set range and resolution, dimming mode (PWM/analog/hybrid), ramp step/time, and channel sync tolerance.
Sensing contract (sensors → controller): PPFD sampling cadence, filter time constant, calibration factor K, and sensor health indicators (stuck/dirty/occluded).
| Signal / Field | Purpose | Acceptance / Debug use |
|---|---|---|
| PPFD_meas (raw + filtered) | Closed-loop feedback variable | Proves PPFD stability; flags sensor drift/occlusion |
| I_set / I_meas per channel | Recipe integrity + control authority | Separates “control intent” vs “hardware limitation” |
| Temp_NTC (+ estimated Tj) | Derating + lifetime protection | Explains PPFD drift and prevents thermal runaway |
| RuntimeHours + AgingFactor | Long-term compensation driver | Proves lumen maintenance strategy is applied |
Table overflow is enabled for mobile safety (horizontal scroll only inside this table container).
Evidence-first logging (for acceptance + field debug)
- Scene context: scene ID, time-of-day state, ramp progress (so PPFD and current traces are interpretable).
- PPFD trace: raw + filtered, plus sensor health flags (stuck/flatline/out-of-range/occluded suspicion).
- Channel traces: I_set/I_meas per channel (spot-check or periodic snapshots), plus any saturation flags.
- Thermal context: Temp_NTC and current derating limit applied (so drift is explainable).
- Fault snapshots: open/short/OV/OT codes with PPFD/temp/current at event time (root cause isolation).
Practical pay-off: With these fields, most issues can be classified quickly as (A) sensor problem, (B) thermal/derating behavior, (C) channel saturation/limits, or (D) wiring/open/short events—without guesswork.
Spectral Recipe Design (Channels, Ratios, Constraints)
What a “recipe” must be (engineering definition)
A horticulture spectral recipe is not just a color mix. It must be an auditable control object: a channel vector (R/B/FR/W), a time meaning (duration + ramp), and explicit constraints so the driver can keep PPFD and ratios stable under saturation, temperature, and aging.
Recommended representation: store recipes as ratios (R%, B%, FR%, W%) plus timing. The controller can then apply a global scale factor to hit PPFD while preserving the recipe shape.
Channel selection and the constraints it creates
- R (660) / B (450) / W: typically carry most of the PPFD. The driver must define a linear control region and a minimum controllable current for stable deep dimming.
- FR (730): often used as a time-gated channel. Recipes should encode when FR is allowed and enforce system limits (power/temperature) when FR is active.
- UV-A (optional): can be treated as an additional channel in the same data model without changing the table structure (kept optional here).
Constraint types (must be explicit):
- Per-channel: Imax[ch], Imin_ctrl[ch], and linear window[ch] (range where ratio tracking is repeatable).
- System-level: Ptotal_max (or bus current limit) and Temp_limit (ties into thermal derating later).
- Policy: FR allowed window(s) (time gate) and ratio tolerance Δratio (how much drift is acceptable before flagging).
Evidence fields and how to detect recipe breakage
Scene table (minimum fields):
| Scene | R% | B% | FR% | W% | duration | ramp |
|---|---|---|---|---|---|---|
| Veg-Day | 35 | 30 | 0 | 35 | 10h | 10min |
| Flower-Day | 40 | 20 | 10 | 30 | 12h | 15min |
| Night | 0 | 0 | 0 | 0 | 2h | 5min |
Mobile-safe: table scrolls horizontally inside its own container.
Recipe integrity evidence (loggable fields):
- I_set[ch] and I_meas[ch] per channel (R/B/FR/W).
- sat_flag[ch] (I_set clipped at I_max) and min_ctrl_flag[ch] (below controllable region).
- ActiveSceneID, RampProgress (so “expected ratios” are known at any moment).
- Temp_NTC and derating_active (to explain intentional scale-down).
Common failure mode: When any channel saturates (I_max) or falls into a non-linear low-current region (I_min_ctrl), the ratio drifts. A robust recipe system must expose saturation flags so the controller can (a) scale globally, (b) gate FR by time/power, or (c) flag “recipe cannot be met” instead of silently drifting.
PPFD Sensing Fundamentals (Types, Placement, Calibration)
Why PPFD sensing is the moat
A PPFD loop is only as good as the measurement. If the sensor drifts with spectrum, angle, temperature, or contamination, closed-loop control will stabilize the wrong value. A robust design treats the PPFD sensor as a calibrated instrument, with placement rules and health diagnostics.
Sensor types and what must be recorded
- Quantum sensor: closer to PPFD intent; typically easier to calibrate across recipes, but still needs placement and contamination control.
- Photodiode + filter: easier to integrate; measurement bias can vary with recipe spectrum and angle response, requiring stronger calibration discipline.
Evidence fields (minimum):
- SensorType (quantum / photodiode+filter) and SensorID (traceability).
- K_base (calibration factor) and optional K_recipe_id (if recipes cause bias shifts).
- temp_coeff (temperature drift coefficient) and current Temp_NTC.
- Mount geometry: height h, offset r, tilt θ (cosine/angle error).
- Occlusion/contamination factor: dust/condensation suspicion flags or periodic maintenance counters.
Key horticulture nuance: if spectral recipes change (R/B/FR/W ratios), a non-ideal sensor can show a PPFD shift even when true PPFD is stable. Capture recipe context with PPFD logs to separate “real drift” from “sensor spectral bias”.
Placement rules and calibration workflow (practical)
Placement goal: measure a representative zone on the canopy plane.
- Avoid hotspot center (biases the loop toward under-lighting the area).
- Avoid extreme edge (biases the loop toward over-driving the center).
- Keep a stable geometry (h, r, θ). Angle response matters; cosine deviation grows when incident angles are wide.
- Plan for contamination (dust/condensation) and occlusion (leaves/fixtures). Treat these as measurable risks, not surprises.
Calibration workflow (minimal but traceable):
- Define a calibration condition: fixed height h, known scene/recipe, controlled temperature window.
- Compute K_base and store with SensorID, scene/recipe context, and calibration date.
- Apply temp_coeff if the sensor output drifts with temperature.
- Set re-calibration triggers: persistent offset, lens/board changes, recipe changes, or contamination events.
Closed-Loop PPFD Control (Control Law + Stability Hooks)
What the PPFD loop must guarantee
Closed-loop PPFD control turns PPFD into a trackable target by continuously mapping measurement error to a controlled output that the driver can execute (typically a global brightness/flux scale). The loop must remain stable under ripple/noise, sensor bias, and actuator limits, and it must expose evidence fields whenever the recipe cannot be met (saturation, minimum controllable current, or power limits).
Control target: PPFD is a slow plant variable, but measurement disturbances can be fast. Robust loops prioritize repeatable sampling, filtering, and bounded control actions over aggressive bandwidth.
Sampling and filtering (make PPFD measurable and usable)
- Sampling period (Ts_ppfd): choose a consistent cadence; stability and repeatability matter more than speed. Log both PPFD_raw and Ts_ppfd.
- Filter time constant (tau_f): remove ripple/noise so the controller does not chase fast disturbances. Keep the filter slow enough to suppress ripple, but not so slow that it creates large lag and overshoot.
- Ripple rejection hook: use a repeatable sampling window (e.g., away from known switching/PWM edges) so PPFD_raw variance does not explode during dimming transitions.
Evidence fields to log:
- Ts_ppfd, filter_type (EMA/LPF), tau_f
- PPFD_raw, PPFD_filtered, and a simple noise_metric (e.g., short-term variance)
- scene_id and ramp_progress (so measurement is tied to recipe transitions)
Control law, bounded actions, and anti-windup (the “professional” part)
The controller converts error = PPFD_target − PPFD_filtered into a control output u_ctrl. In horticulture drivers, u_ctrl is best interpreted as a global scale that will later be allocated to channels (ratio-locked or adaptive). PI control or a lookup-based controller both work, but stability depends on strict limiters and anti-windup hooks.
Stability hooks (must be explicit):
- Limiter: constrain u_ctrl by total power/current limits and recipe policy.
- Slew-rate limit: bound the rate of change to prevent visible step changes and stress events.
- Anti-windup: when saturation occurs (power limit, Imax[ch], or minimum controllable region), prevent integrator accumulation that would cause overshoot after the limit clears. Options include integrator clamping, freezing I during saturation, or back-calculation.
- Overshoot guard: specify an overshoot cap and enforce conservative updates when near the target.
Common root cause of “pulsing brightness”: the loop bandwidth is effectively too high because measurement noise is not filtered, or the integrator winds up while the actuator is saturated. Logging sat_flag + anti_windup_mode makes this diagnosable.
Sensor trust, fault detection, and safe fallback
A PPFD loop must stop “optimizing” if the sensor becomes unreliable (occlusion, contamination, wiring faults, or stuck readings). The safe behavior is to freeze the last stable control output or fall back to an open-loop recipe scale, while raising a fault flag and logging the context that explains the fallback.
Evidence fields to log:
- sensor_health (OK/occluded/contaminated/stuck) and fault_code
- fallback_mode (hold-last / open-loop-scale) and u_ctrl_hold
- PPFD_raw/filtered snapshot + scene_id at fault time
Channel Allocation Strategy (How PPFD Error Maps to Multiple Channels)
Allocation is where recipe integrity is protected (or lost)
The PPFD controller produces a correction request (often a global scale or ΔPPFD). Allocation converts that request into per-channel current setpoints for R/B/FR/W while obeying per-channel limits, total power limits, and policy gates (e.g., FR windows). A professional allocator exposes when the recipe is not feasible, instead of silently drifting ratios.
Mode A — Recipe Locked (ratio preserved, global scaling)
In ratio-locked mode, the scene recipe defines a normalized vector v = [R,B,FR,W]. The loop provides a global scale g. The allocator computes:
- I_set[ch] = clip( g · v[ch] ) using Imax[ch] and Imin_ctrl[ch].
- Total limit: if g would exceed P_total_max (or bus limit), bound g before clipping.
- FR gate: force v[FR] = 0 (or cap I_set[FR]) outside allowed windows.
Feasibility rule: if any channel hits Imax or falls below Imin_ctrl, the ratio cannot be preserved. The allocator must either (a) reduce g to regain feasibility, or (b) switch to a declared constrained policy.
Mode B — Recipe Adaptive (weights and priorities)
In adaptive mode, the allocator can intentionally bias PPFD corrections toward selected channels using a weight matrix W or a priority rule set. This must never be “silent drift”: the strategy needs an ID, and its constraints must be explicit.
- ΔI = W · ΔPPFD (conceptually) → per-channel increments.
- I_set[ch] = clip( I_base[ch] + ΔI[ch] ) using Imax/Imin_ctrl and total power limit.
- FR gate enforcement: FR increments are blocked or capped unless FR window is active.
- Slew and stability: apply per-channel slew limits so allocation changes cannot create steps.
Why adaptive exists: it handles constrained scenarios better (e.g., one channel saturates, FR gated), but it must remain traceable via alloc_mode + strategy_id + sat_flags so field behavior is explainable.
Allocation evidence fields (make failures diagnosable)
- alloc_mode (locked/adaptive), ratio_lock_enable
- W_matrix_id (or W summary), strategy_id
- Imax[ch], Imin_ctrl[ch], P_total_max, FR_allowed_window
- I_base[ch], ΔI[ch], I_set[ch]
- sat_flag[ch], min_ctrl_flag[ch], and a single recipe_feasible boolean
Thermal Derating & Junction Temperature Estimation
What thermal control must guarantee in a 24/7 grow light
A horticulture luminaire runs for long photoperiods with high average power. Thermal stress is the dominant driver of lifetime, channel drift, and long-term stability. The derating subsystem must produce a predictable allowed output limit (current, power, or PPFD scale) from temperature evidence, without causing visible oscillations or “hunting” during airflow changes.
Core idea: NTC is not junction temperature. It is a proxy that becomes useful only when paired with a calibrated thermal model and a slow, hysteretic state machine.
NTC placement, heat path, and thermal time constant
- Placement determines meaning: an NTC on the heatsink reflects slow bulk temperature; an NTC near the LED board reflects faster board heating; an NTC near a driver power stage reflects driver self-heating.
- Heat path awareness: LED junction → package/MCPCB → thermal interface → heatsink → ambient. Each segment adds thermal resistance and delay.
- Thermal time constant (tau_th): derating must be slow relative to tau_th. Fast control actions create perceived brightness oscillation (heat “hunting”).
Evidence fields to log:
- T_ntc (with ADC code if available), fan_state (0/1 or PWM%), heatsink_state (OK/fault)
- tau_th (or model_id), plus a simple thermal_rate estimate dT/dt for debugging
Junction temperature estimation (Tj_est) with a calibrated model
Derating decisions should be based on an estimated junction temperature Tj_est, not raw NTC alone. A practical implementation uses a model that is simple enough to calibrate on a luminaire, yet explicit enough to explain why limits changed.
Two “engineering-grade” model tiers:
- Tier 1 (offset model): Tj_est = T_ntc + ΔT_offset. Use when power estimation is unavailable.
- Tier 2 (Rth×P model): Tj_est = T_ntc + Rth_equiv × P_led_est. Use when driver has a usable power estimate.
Model traceability: store a model_id (and parameters such as Rth_equiv, ΔT_offset). Logging model_id + T_ntc + P_led_est makes Tj_est reproducible across firmware updates and field service.
Evidence fields to log:
- Tj_est, Rth_equiv (or model_id), P_led_est (if used)
- ambient_est (optional), plus fan_state as a modifier when airflow changes the model validity
Derating curve and state machine (avoid thermal hunting)
- Curve: start derating at T_start, reach minimum allowed output by T_full. Output limit can be expressed as derate_factor, I_limit_total, or a PPFD scale cap.
- States: Normal → Derate → Protect → Recover. Each transition is keyed to thresholds and timers.
- Hysteresis + minimum dwell: Recover must require Tj_est below a lower threshold (T_recover) for a minimum time window, preventing rapid toggling near the boundary.
- Thermal slew limit: limit the rate of derate_factor change. Slow changes preserve visual smoothness and reduce control interaction with the PPFD loop.
Loop interaction note: thermal derating behaves like an external saturation constraint. The PPFD controller should receive sat flags and apply anti-windup, otherwise the integrator accumulates error during derating and overshoots on recovery.
Evidence fields to log:
- derate_curve_params (T_start, T_full, T_recover, slope), slew_limit_thermal
- thermal_state, state_entry_time, min_dwell_ms
- derate_factor (or I_limit_total), plus thermal_fault_code if Protect is entered
Aging / Lumen Maintenance Compensation (Long-Term Stability)
Aging is not a one-number problem (channels drift differently)
In horticulture lighting, long-term stability means maintaining both PPFD and the spectral recipe over thousands of hours. LED output decays over time, and decay rates differ by channel (R/B/FR/W). Without explicit compensation, recipes drift and PPFD loops spend increasing headroom until saturation forces unplanned changes.
Engineering goal: represent aging as a per-channel compensation factor driven by run hours and calibration data, with clear recalibration triggers when headroom is exhausted.
Run-hour accounting and traceable data fields
- run_hours_total: monotonically increasing runtime counter (persisted across power cycles).
- run_hours_scene[scene_id]: optional per-recipe accounting for better correlation to duty cycle.
- bin_id[ch] / lot_id: channel/board tracking fields so compensation remains valid after service swaps.
- aging_model_id: identifies the compensation model and its parameter set.
Evidence fields to log:
- run_hours_total, aging_model_id, k_decay[ch] (or table_id)
- comp_factor[ch] (current), plus last_cal_time and cal_interval_hours
Compensation model and insertion point (avoid “fighting the PPFD loop”)
Compensation should be applied as a transparent, logged correction in the setpoint path, not as hidden drift. A simple approach uses per-channel factors comp_factor[ch] derived from run hours and calibration data. Insert the correction before final clipping so feasibility can be evaluated explicitly.
Model choices (engineering-grade):
- Piecewise table: run_hours → comp_factor[ch] via lookup (easy to calibrate, predictable).
- Parametric decay: run_hours → comp_factor[ch] using k_decay[ch] (compact and tunable).
Recommended insertion point: build I_base from recipe allocation, then apply comp_factor[ch], then perform clip + feasibility checks. This prevents the PPFD loop from “silently” consuming headroom over months.
Headroom management and explicit recalibration triggers
- Headroom is finite: compensation increases current demand. When a channel approaches Imax, recipe integrity is at risk.
- Recipe feasibility flag: record when ratio/strategy cannot be preserved due to saturation or minimum controllable regions.
- Recal triggers: define thresholds on headroom, persistent PPFD shortfall, or service events (board swap / sensor cleaning).
- Recal workflow fields: cal_status (pending/done/failed) plus timestamps and trigger reasons.
Evidence fields to log:
- Iset_before[ch], Iset_after[ch], headroom[ch], sat_flag[ch]
- recipe_integrity (true/false), recal_trigger, cal_status
Dimming Implementation Details (PWM / Analog / Hybrid) for Plant-Safe Control
What “plant-safe” dimming must guarantee
Horticulture dimming is used for sunrise/sunset ramps and photoperiod transitions. The key requirement is not simply “go darker,” but to maintain stable deep dimming, smooth ramps, and multi-channel synchrony so the spectral recipe does not momentarily drift during transitions.
Engineering targets: no visible steps, no channel skew, predictable minimum controllable output, and ramp behavior that remains smooth even under low-current nonlinearity.
PWM vs analog vs hybrid: choose by controllability, not preference
- PWM dimming: excellent repeatability, but deep dimming is limited by min_on_time and effective resolution at the chosen PWM frequency.
- Analog dimming: can keep PWM artifacts low, but the low-current linear region determines whether very low output remains stable and monotonic.
- Hybrid dimming (recommended for deep ramps): use analog to keep the current inside a controllable region, then use PWM for fine granularity and synchronized fading.
Evidence fields:
- pwm_freq_hz, pwm_resolution_bits, min_on_time_us
- I_min_ctrl[ch], linear_region[ch], analog_dim_range (if used)
Deep dimming stability: min on-time and low-current linearity
Deep dimming can fail in two practical ways: (1) PWM pulses become too short to be represented reliably (min_on_time), or (2) the LED/driver system enters a region where current is not monotonic or stable (low-current nonlinearity). Both issues manifest as visible steps or “jumpiness” during ramps.
- Guardrail 1: define a minimum duty/time window where PWM remains representable (min_on_time margin).
- Guardrail 2: define I_min_ctrl per channel and treat operation below this as “nonlinear/unsafe for smooth ramps.”
- Guardrail 3: apply a ramp slew limit so changes remain visually continuous (even if control updates are discrete).
Implementation note: treat deep-dimming constraints as saturations (min duty / min current). The upstream ramp generator should know the saturation state to avoid accumulating “hidden steps” that appear later as jumps.
Ramp generation and multi-channel synchrony
A plant-safe sunrise/sunset transition is a multi-channel ramp. The ramp must update all channels on the same scheduler tick, with a bounded sync_error so the spectrum does not drift during the transition.
- ramp_step: per update increment (ratio or current domain). Too large creates visible stair-steps.
- ramp_update_period_ms: update cadence. Too slow creates segmented ramps.
- sync_marker: a common commit point so R/B/FR/W change together.
- sync_error_us: measured or budgeted channel skew. Keep it explicit and logged.
Evidence fields:
- ramp_profile_id, ramp_step, ramp_update_period_ms
- sync_error_us, channel_skew[ch] (optional), sync_marker_time
Protection, Fault Handling, and “Safe Output” Behavior
“Safe output” is a controlled downgrade, not always a shutdown
Grow lighting often benefits from maintaining a bounded, non-harmful output rather than going fully dark. A robust fault strategy separates detection, mitigation, and recovery so the luminaire remains predictable and diagnosable. Safe output should be explicitly defined as a profile with logged entry conditions.
Rule: if a fault makes control validity uncertain (sensor failure, persistent saturation, repeated protection), switch to a conservative safe profile and record a snapshot for service.
Detection: criteria + debounce window to prevent false trips
- Open-string (example logic): string voltage rises above an open threshold while commanded current increases but measured response does not track, sustained over a debounce window.
- Short / abnormal load: string voltage collapses below a threshold or protection asserts while current behavior deviates from expected within a confirm window.
- OVP/OCP/OTP: treat these as high-confidence events; still log pre-fault conditions and rate-limit retries.
- Sensor fault flags: PPFD/NTC open/short or implausible jumps should invalidate closed-loop control and trigger safe output.
Evidence fields:
- open_string_criteria, short_criteria, debounce_ms, confirm_count
- ovp_threshold, ocp_threshold, otp_threshold, sensor_fault_flags
Mitigation: derate, disable-channel, or safe profile
- Total derate: reduce overall output when system constraints dominate (e.g., thermal limits). Keep recipe structure stable and communicate saturation to upstream control.
- Disable channel: isolate a failing channel (open/short) while maintaining bounded output on remaining channels. Record recipe_integrity=false if the spectral ratio cannot be preserved.
- Safe profile (open-loop conservative): when sensor validity is questionable or repeated trips occur, hold a conservative output profile with strict limits until service.
Service-friendly design: mitigation actions should be explicit enums (action_mode) and leave a clear trail in logs.
Evidence fields:
- action_mode (derate_total / disable_channel / safe_profile / shutdown)
- safe_output_profile_id, retry_policy, recipe_integrity, sat_flag[ch]
Retry, lockout, and recovery with snapshots
- Retry: use bounded retries with backoff. For hard faults (persistent short), rapid retries only increase stress.
- Lockout/latch: if repeated retries fail, enter lockout and require a cooldown timer or service action.
- Recover: require hysteresis (voltage/temperature) and a minimum stable window before returning to Normal.
- Fault log snapshot: capture PPFD/temperature/bus voltage and setpoints at the moment of fault. This reduces field diagnosis time dramatically.
Evidence fields:
- fault_code + timestamp, recover_timer_ms, lockout_latch, cooldown_hysteresis
- snapshot: PPFD_meas, T_ntc/Tj_est, bus_v, Iset[ch], derate_factor, thermal_state
Validation Plan & Field Debug Playbook (Evidence-First)
Goal: ship a grow-light driver that is measurable, repeatable, and diagnosable
Validation for horticulture lighting is not “does it light up.” It is proving that PPFD closed-loop, spectral recipe execution, thermal derating, and aging compensation remain predictable over time. An evidence-first playbook standardizes what to record (curves/waveforms/log snapshots), so field issues are solved by data rather than guesswork.
Evidence-first rule: every “pass/fail” decision must be backed by at least one of: PPFD curve, per-channel current waveform, temperature curve, hours counter + recipe version, or fault snapshot log.
Concrete MPN examples for a validation-ready node (non-exhaustive)
PPFD reference & sensors
- Apogee SQ-520 (quantum sensor, PPFD reference-grade)
- LI-COR LI-190R (quantum sensor, PPFD reference-grade)
- Apogee MQ-500 (handheld PPFD meter; convenient field cross-check)
- ams OSRAM AS7341 (multi-channel spectral sensor; useful for relative channel drift checks, not a PPFD absolute standard)
Temperature sensing & timekeeping
- Murata NCP18XH103F03RB (10k NTC, typical for board/heatsink sensing)
- Vishay NTCLE203E3103SB0 (10k NTC alternative)
- Microchip MCP7940N (RTC with EEPROM; timestamps for logs)
- NXP PCF8523 (low-power RTC alternative)
Analog capture for evidence logs
- TI ADS1220 (24-bit ADC; stable PPFD/NTC capture with low noise)
- TI ADS1115 (16-bit ADC; simpler, adequate for many monitoring tasks)
- TI INA180 (current-sense amplifier for channel current evidence)
- TI INA199 (current-sense amplifier alternative)
Control, recipe storage, and traceability
- ST STM32G071 (MCU class suitable for multi-channel scheduling + logs)
- Microchip 24LC256 (I²C EEPROM for recipe table + versioning)
- Fujitsu MB85RC256V (I²C FRAM alternative; good for frequent log writes)
Note: MPNs are examples to make the validation checklist concrete; final selection depends on accuracy, operating range, and cost targets.
Evidence pack: standardize logs so “pass/fail” is auditable
- PPFD curve: ppfd_target, ppfd_meas(t), settling_time_s, overshoot_%, steady_error_%
- Channel waveforms: Iset[ch](t) and (if available) I_led[ch](t), ramp_step, ramp_update_period_ms, sync_error_us
- Thermal curve: T_ntc(t), Tj_est(t), derate_factor(t), thermal_state(t), recover_hysteresis
- Aging: hours_counter, aging_model_param[ch], comp_factor[ch], recal_trigger
- Recipe traceability: recipe_table_version, profile_id, ratio_lock, recipe_integrity
- Fault snapshot: fault_code + timestamp + snapshot(PPFD, temp, bus_v, Iset[ch], derate_factor, thermal_state)
Five-stage validation flow (what to do, what to record, what passes)
1) Bring-up (baseline trust)
- Setup: fix sensor geometry (height/angle) and log recipe_table_version + profile_id at boot.
- Measure: raw PPFD noise level (before heavy filtering), Iset vs measured channel current (e.g., via INA180), sensor_fault_flags.
- Pass: monotonic response from command to current, PPFD baseline stable, and traceability fields present in logs.
2) PPFD closed-loop tuning (step response)
- Stimulus: apply PPFD target steps (e.g., 60% → 80% → 50%) while holding recipe ratios constant (ratio_lock = on).
- Measure: ppfd_meas(t), overshoot_%, settling_time_s, steady_error_%, sat_flag, loop_update_period_ms, filter_tau_s.
- Pass: bounded overshoot, repeatable settling, and no sustained oscillation. Saturation behavior must be explicit (sat_flag logged).
3) Thermal derating verification (predictable downgrade)
- Stimulus: increase thermal stress (reduced airflow / elevated ambient) and observe state transitions (Normal → Derate → Protect → Recover).
- Measure: T_ntc(t), Tj_est(t), derate_factor(t), thermal_state(t), recover_hysteresis, thermal_tau_s.
- Pass: smooth derate without “hunting” (rapid state flipping). Recovery requires hysteresis + stable window.
4) Aging compensation verification (model + replay)
- Method: verify compensation logic via accelerated replay (simulate aging factors per channel) rather than waiting months.
- Measure: hours_counter, comp_factor[ch], ppfd_meas(t) under constant ppfd_target, and recipe_integrity.
- Pass: compensation drives steady_error_% back within limit without violating current limits or causing abrupt spectral shifts.
5) Field contamination/occlusion test (diagnose, then downgrade)
- Stimulus: apply controlled occlusion (partial遮挡) and “contamination” attenuation (透光衰减) to the PPFD sensor path.
- Measure: sensor_fault_flags, ppfd_meas anomaly shape, safe_output_profile_id entry, snapshot logs (PPFD/temp/bus/current).
- Pass: system identifies invalid sensor conditions, switches to conservative safe output, and leaves a complete snapshot trail.
Field debug playbook (evidence-first shortcuts)
- PPFD always low: check ppfd_meas + Iset[ch] + T_ntc/Tj_est → decide between saturation, derating, or sensor geometry error.
- PPFD oscillates or “breathes”: check ppfd_meas (pre/post filter) + sat_flag + loop_update_period_ms → look for saturation toggling or insufficient filtering.
- Recipe drift / color shift: check recipe_table_version + ratio_lock + Iset[ch] + channel limits → decide between limit clipping vs unintended ratio unlock.
- Thermal hunting: check thermal_state(t) + derate_factor(t) + recover_hysteresis → validate hysteresis and thermal time constants.
- After cleaning/relocation, behavior changes: check sensor_fault_flags + geometry notes + reference PPFD meter (e.g., MQ-500) → confirm calibration/placement.
Minimum field kit suggestion (MPN examples): Apogee MQ-500 (PPFD spot check) + a known-good quantum sensor (SQ-520 or LI-190R for deeper audits), plus device fault snapshot exports (timestamp + PPFD/temp/current).
Request a Quote
FAQs (Evidence-Linked)
Each answer points back to a measurable evidence field (PPFD curve / channel waveforms / temperature curve / hours counter / recipe version / fault snapshots). MPNs shown are concrete examples to make test setups reproducible.
