Release 2.5.8

Released: 2026-06-08 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

Fixes three separate bugs that caused last_strike_distance and last_strike_time to remain empty or stale during active thunderstorms. Fixes Public Tempest Station unit conversion — temperature, wind, pressure, and rain states were always displayed in metric regardless of device configuration. Also adds a Distance Display unit preference (km / mi) to Tempest, Sky, and Air device configuration.

NB: Lightning states are very confusing (at least to me) Check the Wiki for information

Bug Fixes

1. last_strike_distance gated behind include_standard (web API path)

Root cause: The web API field lightning_strike_last_distance was only read inside the include_standard block. That block only runs when UDP observations are inactive (stale / web-only mode). With a working UDP device, evt_strike UDP packets are supposed to keep last_strike_distance current — but evt_strike is a separate UDP event that can be silently lost even when normal obs_st observations are flowing normally. When that happens, the state never updates from either path and stays permanently empty.

Fix: Moved last_strike_distance to the always-runs section of _build_web_observation_states, identical to where lightning_count_last_1hr / lightning_count_last_3hr already sit. It now refreshes on every web poll regardless of whether UDP is active.

2. last_strike_time had no web source at all

Root cause: The WeatherFlow REST API provides lightning_strike_last_epoch — a Unix timestamp of the most recent strike — in every observation response. The plugin never read this field. last_strike_time could only ever be populated by UDP evt_strike packets. If those don't arrive (see bug 1), the state stays permanently empty with no fallback.

Fix: Added lightning_strike_last_epoch → last_strike_time extraction in the always-runs section, converting the Unix epoch to a UTC datetime string.

3. UDP strike events logged at DEBUG only (observability gap)

Root cause: The _on_strike handler emitted its summary at DEBUG level. In normal (non-debug) operation, there was no log evidence that evt_strike UDP packets were arriving at all, making it impossible to distinguish "strikes are happening but states aren't updating" from "no strike packets are arriving."

Fix: Promoted to INFO — every UDP strike now logs distance=X energy=Y at INFO level.

Bug Fix

4. Public Tempest Station ignored unit preferences (always showed metric)

Root cause: _build_public_obs_states assumed the observations/station/{id} API would honour unit query parameters (units_temp=f, units_wind=mph, etc.) and return values already in the user's preferred units. In practice the endpoint returns metric values regardless of what unit parameters are sent — meaning a Public Station configured for Fahrenheit, mph, and inches still displayed °C, m/s, and mm.

Fix: Aligned the Public Tempest Station path with how personal stations have always worked:

Affected states (now correctly converted):

Fixed-unit states (UV, solar radiation, illuminance, relative humidity, elevation, air density) are unchanged.

Existing devices: No configuration changes required. Values will now display in whatever units are set in Edit Device — if you've had the device configured for Fahrenheit/mph/inches all along, they will now correctly show those units after the plugin reloads.

New Feature

Distance Display unit preference for Tempest, Sky, and Air devices

Problem: last_strike_distance and lightning_strike_average_distance were always displayed in kilometres, regardless of how the device was otherwise configured. The Public Tempest Station device type already had a Distance Display preference; Tempest, Sky, and Air did not.

Fix:

• Added a Distance Display field (Kilometres / Miles) to the ConfigUI of Tempest, Sky, and Air device types.
• _get_unit_prefs() now reads distUnit from the device's saved properties (defaulting to "km" for existing devices).
• Lightning distance states are converted to the selected unit before being written to Indigo.
• The per-strike INFO log line shows the distance in the selected unit.

Existing devices default to km — no action required unless you want miles.

Lightning State Reference

The WeatherFlow lightning sensor uses radio frequency detection to identify return strokes. Its data reaches the plugin through three separate pathways that update at different times and answer different questions — mixing them up is the source of most lightning-related confusion.

Per-observation states (updated every ~1 minute with each obs_st packet)

lightning_strike_count = 0 between strike-active minutes is completely normal. The sensor reports a fresh window count every minute; if no strike was detected in that minute, the count is 0. For "is there a storm right now?", use lightning_count_last_1hr (requires Web API token).

Per-strike states (updated when a strike is detected)

These states are written by two sources that now both feed the same states:

• UDP path — evt_strike packets arrive separately from observations and can occasionally be lost even when obs_st packets are flowing normally.
• Web API path (new in v2.5.8, requires API token) — lightning_strike_last_distance and lightning_strike_last_epoch are present in every observation response and now always update these states as a fallback.

† Web API fallback requires a valid API token in Plugin Preferences. Without a token, these states are only populated by UDP evt_strike packets.

Rolling window counts (updated every ~60 s from the Web API)

Requires a valid API token. These are quality-controlled by the WeatherFlow cloud.

Quick reference: which state to use for what

Upgrade Notes

• No configuration changes required for any device type.
• Public Tempest Station: Values will now display in the units configured in Edit Device. If you have had the device set to Fahrenheit/mph/inches and it was showing metric, it will immediately show correct values after the plugin reloads — no reconfiguration needed.
• Lightning states (last_strike_distance, last_strike_time) now populate from the web API even when UDP strike events are not arriving — requires an API token.
• Distance Display for Tempest/Sky/Air: Existing devices default to km. To switch to miles, Edit Device → Distance Display → Miles (mi).

Release 2.5.7

Released: 2026-06-04 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

Completes the unit-label cleanup started in 2.5.6. The Conditions menu (used when adding conditions to Triggers and Schedules) no longer shows hardcoded metric unit annotations alongside state names.

Changes

Conditions menu — remove hardcoded unit annotations from ControlPageLabel

Background: Indigo uses two separate label fields in Devices.xml:

Release 2.5.6 removed hardcoded metric units from TriggerLabel but did not touch ControlPageLabel. As a result, the Conditions tab still showed entries like "Air Temp °C", "Wind Speed m/s", "Pressure mbar" regardless of the device's unit setting.

Fix: Removed the hardcoded unit suffix from all variable-unit ControlPageLabel entries across the Tempest, Sky, Air, and Public Station device blocks.

Examples:

Fixed-unit labels (%, W/m², lx, UV, V, dBm, °) are unchanged. Existing conditions and triggers continue to work without modification.

Upgrade Notes

• No configuration changes required.
• Label changes take effect after plugin reload.
• Existing triggers and conditions are unaffected — only the display text in the state picker menus changes.

Release 2.5.6

Released: 2026-06-03 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

heat_index and wind_chill_temperature now show blank when conditions are not met. Trigger/condition menus no longer show hardcoded °C, mbar, m/s, or mm unit labels.

Changes

Heat Index and Wind Chill — blank (None) when conditions are not met

pyweatherflowudp returns None for these states when conditions are outside the calculation range:

Previously, when the value was None the plugin skipped writing the state entirely — leaving whatever value was last recorded. This meant a stale reading persisted indefinitely, and a unit preference change (e.g. Celsius → Fahrenheit) would never be reflected until conditions happened to come back into range.

The plugin now always writes the state when None is received, storing None as the value with a blank display string:

The None write is immediate — no stale value lingers after a weather change or unit preference update. Because these states are not typically used in numeric triggers, the None value is appropriate; the blank display clearly communicates "not applicable" rather than a misleading 0.

Trigger/condition menus — remove hardcoded unit annotations

The Indigo trigger and condition UI shows the state's TriggerLabel from Devices.xml in the state picker dropdown. These labels were annotated with hardcoded metric units — (°C), (mbar), (m/s), (mm) — regardless of the device's actual unit setting. A device set to Fahrenheit would show "Air Temperature (°C)" in the trigger dropdown, creating confusion about what unit to enter for the comparison threshold.

The unit suffix has been removed from all variable-unit TriggerLabel entries across the Tempest, Sky, Air, and Public Station device blocks. Fixed-unit labels (%, W/m², lx, UV, V, dBm, °) are unchanged.

Examples:

The active unit is always visible in the state's current uiValue (e.g. 32.8 °F) and is also stored in the unit_temperature, unit_pressure, unit_wind, and unit_rain states.

Upgrade Notes

• No configuration changes required.
• TriggerLabel changes take effect after plugin reload — existing triggers continue to work unchanged.
• On the next observation after reload, heat_index and wind_chill_temperature will show blank if conditions are not currently met, clearing any stale reading.

2.5.4 and 2.5.5 Changes below (and see wiki)

Release 2.5.4

Released: 2026-05-30 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

Rain accumulation is now cleanly separated into two independent tracks. The web API provides rain-check corrected daily totals in rain_today / rain_yesterday. The device provides raw local totals in rain_today_local / rain_yesterday_local. Neither track can corrupt the other.

Changes

Separate Local and Web Rain Accumulation

Background: Two independent paths were writing to the same rain_today state:

• UDP path — reads the hub's own daily rain counter (hub index 18, resets at local midnight). Falls back to accumulating per-minute rain values when the hub sends shorter packets in power-save / low-battery mode (e.g. when Precipitation Failed appears in sensor_status).
• Web API path — reads precip_accum_local_day from WeatherFlow, which is always rain-check corrected and typically the more accurate total.

With both paths writing rain_today, the state alternated every ~60 seconds between the raw local value and the web value. In power-save mode this was especially visible: local showed "accumulated" while web showed a slightly different corrected total.

Additionally, the fallback accumulation used rain_today_raw_mm as its running baseline — the same state the web API wrote to. Each web poll would shift the baseline, causing the next per-minute delta to be added on top of a different starting point.

Fix — fully separated write ownership:

rain_today_source values:

Web API is the primary source for most users. rain_today shows the rain-check corrected total and is the recommended state for automations. rain_today_local is available when you want the raw device value or need a value independent of web availability.

Midnight rollover: at midnight the plugin captures rain_today_local_raw_mm into rain_yesterday_local. The web API writes rain_yesterday from precip_accum_local_yesterday. Both yesterday states update independently.

Upgrade Notes

• No configuration changes required.
• The four new states are added automatically on the first observation after the plugin is reloaded.
• rain_today and rain_yesterday now update only when the web API polls (~60 s). They no longer update every UDP observation. Existing automations using these states are unaffected — values are the same, just sourced exclusively from web.
• If you were using rain_today as a real-time per-minute counter, switch to rain_today_local for that use case.

&&&&

Release 2.5.5

Released: 2026-05-31 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

delta_t and heat_index now correctly honour the device temperature unit preference. Previously both states always displayed in Celsius regardless of whether the device was set to Fahrenheit.

Changes

Fix delta_t temperature unit conversion

Problem: delta_t (the difference between air temperature and wet-bulb temperature) was listed in _FIXED_SPECS with a hardcoded Δ°C label, so it never converted to Δ°F even when the device's temperature unit was set to Fahrenheit.

Fix: Moved delta_t out of _FIXED_SPECS and into the standard unit conversion pipeline:

The public station path also hardcoded Δ°C; that is corrected to match the device's temperature unit preference.

Why ×1.8 and not a Pint .to("degF") call?

delta_t is a temperature differential, not an absolute temperature. Converting Δ1 °C → Δ°F requires multiplying by 1.8. Using Pint's .to("degF") on a degC quantity would add the 32 °F offset, producing a wrong result. The manual factor of 1.8 avoids this.

Fix heat_index stale Celsius when conditions are not met

Problem: pyweatherflowudp returns None for heat_index when the temperature is below 80 °F or relative humidity is below 40 %. When that happens the plugin skips writing the state entirely, leaving whatever value was last written. If the user had previously been in Celsius mode and then switched to Fahrenheit while conditions were below the heat index threshold, the state would show the stale Celsius reading indefinitely.

Fix: When device.heat_index is None, the plugin now explicitly writes 0 with the correct unit symbol for the current temperature preference. This clears any stale reading.

Upgrade Notes

• No configuration changes required.
• On the first observation after plugin reload, delta_t and heat_index will update with correctly converted values.
• If delta_t had previously been showing Δ°C and you are set to Fahrenheit, it will now show Δ°F from the next UDP observation.
• heat_index will show 0 °F (or 0 °C) when conditions are not met, rather than the previous valid reading.

Release 2.5.3

Released: 2026-05-26 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

Two improvements to how the plugin handles an offline personal Tempest station:

1. Offline detection rewritten — the 2.5.1 implementation used a better_forecast field that proved unreliable; a correct documented API endpoint is now used instead.
2. Device error state — when a station goes stale or offline, the Indigo device turns red in the UI with a status string. Clears automatically when the station recovers.

Changes

Personal Station Offline Detection Rewritten

Problem (2.5.1 regression): The 2.5.1 fix for stale web data worked correctly for Public Tempest Station devices but not for personal stations. The personal web poller used better_forecast.current_conditions.time as the observation timestamp — a field that always reflects the time WeatherFlow generated the API response (2–3 seconds ago), not when the Tempest device last transmitted. Additionally, better_forecast.station.is_station_online returns True even when the device has a completely flat battery.

The result: the 10-minute age gate in 2.5.1 never fired for personal stations, and stale cached data continued to be written to Indigo states when a station was offline.

Investigation: A complete audit of available WeatherFlow REST API endpoints was performed against a live flat-battery device:

Fix: Every web poll cycle now makes two API calls:

1. better_forecast — unchanged, provides current conditions data for device states.
2. /observations/stn/{station_id}?api_key={token}&bucket=1 — the documented personal station observations endpoint. bucket=1 returns the latest 1-minute record only. When the station is offline, obs: [] is returned.

Offline detection logic:

• obs: [] → station has no recent observations — update is rejected.
• obs[-1][0] → timestamp of the most recent observation record. If more than 10 minutes old, update is also rejected (secondary age gate).
• Normal operation — observation age is logged at Debug level: station 183063: /observations/stn status={'status_code': 0, 'status_message': 'SUCCESS'} obs count=1 My Tempest: web observation age 47 s (0.8 min)

Note on endpoint naming: /observations/stn is the documented personal station endpoint in the WeatherFlow API reference. /observations/station (used for public stations) also returns obs: [] when offline, but is the public-facing endpoint. Using the correct personal endpoint avoids any reliance on undocumented behaviour.

Device Error State When Station is Offline

When a personal station's data is stale or absent, the plugin now marks the Indigo device with an error state so it is immediately visible in the Indigo client UI (device row turns red, status column shows the error string).

Two thresholds:

Recovery is automatic — on the next successful poll after the station comes back online, the error state is cleared and all device states resume updating normally. No manual action required.

Cleared at startup — if the plugin is reloaded or Indigo restarts while a station is offline, any lingering error state from the previous session is cleared immediately on deviceStartComm and set fresh once the first poll completes.

Log output during an offline event:

Warning: My Tempest: station offline — no recent observations (stale 0 min)
Warning: My Tempest: station offline — no recent observations (stale 12 min)   ← device now shows "Stale data"
Warning: My Tempest: station offline — no recent observations (stale 31 min)   ← device now shows "Offline"
My Tempest: web observation age 43 s (0.7 min)                                 ← station recovered, error cleared

Upgrade Notes

• No configuration changes required. Both fixes are automatic.
• Reload the plugin after updating to clear any stale error state from prior versions.
• The Public Tempest Station offline detection from 2.5.1 is unchanged and unaffected.

Release 2.5.2

Released: 2026-05-26 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

Two improvements to how the plugin handles an offline personal Tempest station:

1. Offline detection rewritten — the 2.5.1 implementation used a better_forecast field that proved unreliable; a correct documented API endpoint is now used instead.
2. Device error state — when a station goes stale or offline, the Indigo device turns red in the UI with a status string. Clears automatically when the station recovers.

Changes

Personal Station Offline Detection Rewritten

Problem (2.5.1 regression): The 2.5.1 fix for stale web data worked correctly for Public Tempest Station devices but not for personal stations. The personal web poller used better_forecast.current_conditions.time as the observation timestamp — a field that always reflects the time WeatherFlow generated the API response (2–3 seconds ago), not when the Tempest device last transmitted. Additionally, better_forecast.station.is_station_online returns True even when the device has a completely flat battery.

The result: the 10-minute age gate in 2.5.1 never fired for personal stations, and stale cached data continued to be written to Indigo states when a station was offline.

Investigation: A complete audit of available WeatherFlow REST API endpoints was performed against a live flat-battery device:

Fix: Every web poll cycle now makes two API calls:

1. better_forecast — unchanged, provides current conditions data for device states.
2. /observations/stn/{station_id}?api_key={token}&bucket=1 — the documented personal station observations endpoint. bucket=1 returns the latest 1-minute record only. When the station is offline, obs: [] is returned.

Offline detection logic:

• obs: [] → station has no recent observations — update is rejected.
• obs[-1][0] → timestamp of the most recent observation record. If more than 10 minutes old, update is also rejected (secondary age gate).
• Normal operation — observation age is logged at Debug level: station 183063: /observations/stn status={'status_code': 0, 'status_message': 'SUCCESS'} obs count=1 My Tempest: web observation age 47 s (0.8 min)

Note on endpoint naming: /observations/stn is the documented personal station endpoint in the WeatherFlow API reference. /observations/station (used for public stations) also returns obs: [] when offline, but is the public-facing endpoint. Using the correct personal endpoint avoids any reliance on undocumented behaviour.

Device Error State When Station is Offline

When a personal station's data is stale or absent, the plugin now marks the Indigo device with an error state so it is immediately visible in the Indigo client UI (device row turns red, status column shows the error string).

Two thresholds:

Recovery is automatic — on the next successful poll after the station comes back online, the error state is cleared and all device states resume updating normally. No manual action required.

Cleared at startup — if the plugin is reloaded or Indigo restarts while a station is offline, any lingering error state from the previous session is cleared immediately on deviceStartComm and set fresh once the first poll completes.

Log output during an offline event:

Warning: My Tempest: station offline — no recent observations (stale 0 min)
Warning: My Tempest: station offline — no recent observations (stale 12 min)   ← device now shows "Stale data"
Warning: My Tempest: station offline — no recent observations (stale 31 min)   ← device now shows "Offline"
My Tempest: web observation age 43 s (0.7 min)                                 ← station recovered, error cleared

Upgrade Notes

• No configuration changes required. Both fixes are automatic.
• Reload the plugin after updating to clear any stale error state from prior versions.
• The Public Tempest Station offline detection from 2.5.1 is unchanged and unaffected.

Release 2.5.1

Released: 2026-05-24 Minimum Indigo version: 2025.2

← Back to Changelog

Highlights

This is a bug-fix release addressing three issues: stale web data being written to device states when a station goes offline, Indigo state errors on older Air and Sky devices, and duplicate polling on plugin startup.

Bug Fixes

Web Backup No Longer Updates States with Stale Data

Problem: When UDP communication to a local Tempest went down, the web backup poller would take over and push all sensor states from the WeatherFlow cloud API. If the station itself was also offline, WeatherFlow's API returns its last cached observation indefinitely — meaning the plugin would keep writing hour-old (or older) temperature, wind, pressure, and rain values to Indigo device states on every poll cycle.

The same issue affected Public Tempest Station devices: if a public station went offline, its last cached data would keep refreshing in Indigo as though it were live.

Fix: Both the personal web API poller and the public station poller now check the age of the observation timestamp before committing any states:

• Personal stations — current_conditions.time from the better_forecast endpoint is the actual observation timestamp (confirmed from WeatherFlow's own REST API library). If the observation is more than 10 minutes old, the update is skipped entirely.
• Public stations — obs[0].timestamp from the /observations/station/{id} endpoint. Same 10-minute threshold.

When data is rejected, a warning is written to the Indigo log:

My Tempest: web observation is 47.2 min old (obs_time=1748030400) — skipping update
My Public Station: public observation is 23.8 min old (timestamp=1748031600) — skipping update

Observation Age Now Logged at Debug Level

On every successful web poll, the observation age is now written to the plugin log at Debug level. This makes it straightforward to confirm data freshness and to spot a station going stale before it crosses the rejection threshold:

My Tempest: web observation age 3 s (0.1 min)
My Public Station: public observation age 47 s (0.8 min)

Air Device State Errors Fixed

Problem: Users with older WeatherFlow Air (AR-) devices saw a stream of Indigo state errors on every observation:

Error device "WeatherFlow Air AR-XXXXXXXX" state key rain_intensity not defined (ignoring update request)
Error device "WeatherFlow Air AR-XXXXXXXX" state key rain_today not defined (ignoring update request)
Error device "WeatherFlow Air AR-XXXXXXXX" state key rain_today_raw_mm not defined (ignoring update request)
Error device "WeatherFlow Air AR-XXXXXXXX" state key rain_today_date not defined (ignoring update request)

The Air sensor has no rain hardware, so its device type does not define rain states. However the observation state builder was writing rain states unconditionally for all device types. A secondary issue caused the daily rain accumulator to compute a spurious 0.0 mm value for Air (because both rain properties return None, summing to 0.0), which passed a not None check and attempted to write rain_today and rain_today_raw_mm.

Fix: All rain-related states (rain_intensity, rain_today, rain_today_raw_mm, rain_today_date, rain_yesterday, rain_rate, rain_accumulation_previous_minute, precipitation_type) are now guarded by a SkySensorType check. Sky and Tempest devices both satisfy this check and are unaffected. The daily rain accumulation calculation is also skipped entirely for Air, so no spurious 0.0 value is computed.

Duplicate Polling on Startup Fixed

Problem: On plugin startup, the public station poller and web API poller could each spawn two concurrent polling tasks, resulting in every API call and every log line being doubled:

Fix: A second guard check was added inside the scheduled callback, which runs on the event loop and is therefore strictly serial. By the time the second callback executes, the first has already assigned the task, so the duplicate creation is suppressed. The same fix was applied to the web API poller. The "poller started" log message was also moved inside the callback so it only appears when a task is actually created.

Upgrade Notes

• No configuration changes required. All fixes are automatic for existing devices.
• The 10-minute staleness threshold is intentionally conservative — a healthy station updates every 60 seconds, so any age above 10 minutes indicates the station or its cloud connection is genuinely offline.
• Air (AR-) and Sky (SK-) device users should reload the plugin after updating to clear any accumulated state errors from prior versions.

Release 2.0.2

Released: 2026-05-23 Minimum Indigo version: 2022.1

← Back to Changelog

Highlights

This release adds an optional WeatherFlow Web API integration that unlocks nine new device states unavailable from UDP, including rain-check corrected totals, rolling rain and lightning counts, and current weather conditions. It also introduces web-only mode — a way to monitor a Tempest hub on a different network by sourcing all data from the cloud API.

New Features

WeatherFlow Web API (Optional)

Enable in Plugin Preferences → Enable Web API with a free Personal Use Token from your WeatherFlow account. When active, the plugin polls the WeatherFlow REST API every 5 minutes to supplement local UDP data.

Nine new device states are added:

When UDP and the Web API are both active, real-time sensor readings (temperature, wind, pressure, etc.) continue to come from UDP. Web API updates rain totals and provides the web-exclusive states above.

Web-only Mode

Devices can now be configured for web-only mode — tick Web-only (hub on different network) in the device configuration and enter your Station ID. Use this when:

• The Tempest hub is on a different network, subnet, or VLAN from the Indigo Mac
• UDP broadcast cannot reach the Indigo Mac
• You want a fully cloud-sourced device with no dependency on local networking

In web-only mode, all sensor readings come from the REST API, polled every 60 seconds. deviceStatus displays Active (web) when data is flowing.

Web-only devices require only a Station ID — no serial number entry is needed.

Automatic UDP Fallback

If a UDP station goes silent for more than 5 minutes, the web API automatically provides all standard sensor readings (including temperature, wind, pressure, etc.) until UDP resumes. This ensures states remain current even during temporary network interruptions.

Improvements

• Plugin Preferences now includes a Web API section with enable toggle and API token field
• Device configuration simplified — web-only devices no longer require a serial number to be entered manually
• Web poller auto-restart: runConcurrentThread detects if the web poll task exits unexpectedly and restarts it automatically
• Consecutive failure tracking: the web poller warns after 1–2 consecutive failures per station and silently suspends polling after 3. Edit and save the device to reset the counter and resume
• Wind direction stored as cardinal abbreviation (N, NNE, NE … NNW) via an internal _degrees_to_cardinal helper
• Plugin Menu: new List Discovered WeatherFlow Devices item — logs all currently-discovered serial numbers, models, and firmware versions to the Event Log

Documentation

• New wiki pages: Plugin Configuration, Tempest Device Configuration, Web API
• GitHub Actions workflow to automatically sync wiki/ from the main repo to the GitHub wiki on every push
• README.md updated with new device states, configuration screenshots, and full wiki links
• README.bbcode updated for the Indigo plugin forum

Upgrade Notes

• The Web API is opt-in — the plugin continues to work without it. No configuration changes are needed for existing UDP-only setups.
• To enable the Web API, get a free Personal Use Token from tempestwx.com → Settings → Data Authorizations and enter it in Plugin Preferences.
• A 401 Unauthorized error from the web API means either the token is invalid or the Station ID belongs to a different account. The WeatherFlow REST API only serves stations registered to the token's account.

WeatherFlow Tempest Weather Station — Indigo Plugin

Receives live weather data from WeatherFlow Tempest stations via local UDP broadcast and maps all sensor observations to Indigo device states. No cloud account or API key is required. Everything runs on your local network.

See Wiki https://github.com/Ghawken/WeatherFlowTempest/wiki

Screenshot

Indigo device states for a Tempest Weather Station showing live sensor readings and unit labels.

Features

Navigation

Requirements

Quick Start

1. Install the plugin (double-click WeatherFlowTempest.indigoPlugin).
2. Go to Plugins → WeatherFlow Tempest → Configure → Generate Devices.
3. Done — states populate within 60 seconds of the first UDP broadcast.

See [[Installation]] for full details.

Screenshot

Indigo device states for a Tempest Weather Station, showing live sensor readings and unit labels.

Requirements

Installation

1. Download WeatherFlowTempest.indigoPlugin and double-click it to install.
2. Indigo will prompt to enable the plugin — click Enable.
3. The plugin begins listening on UDP port 50222 immediately. No further configuration is required to start receiving data.

Device Setup

Auto-create all devices at once (recommended)

1. Open Plugins → WeatherFlow Tempest Weather Station → Configure.
2. Click Generate Devices.
3. The plugin creates one Indigo device for every Tempest and Hub currently broadcasting on the network. Devices are placed in the main Indigo device folder and can be moved afterward.
4. Re-click the button whenever new hardware is added.

Manual device creation

1. Go to Devices → New Device → Type: WeatherFlow Tempest Weather Station.
2. Choose Tempest Weather Station or WeatherFlow Hub.
3. Select your unit from the dropdown — devices are listed as soon as the hub broadcasts.
4. Click Save.

Tip: If the device dropdown is empty, the hub has not yet sent a broadcast. Wait 30–60 seconds and use the Reload button in the dialog to refresh the list.

Tempest Device Configuration

Unit selections are independent — mix and match as needed. Changes take effect on the next sensor observation (within ~1 minute). Active unit labels are reflected in the unit_temperature, unit_pressure, unit_wind, and unit_rain device states.

Device States

Tempest Weather Station

Temperature

Atmospheric

Derived (require altitude > 0)

Light & UV

Rain

Lightning

Wind

Unit labels

Battery & power

Diagnostics

WeatherFlow Hub

Triggers

Three custom trigger types are available under Triggers → New Trigger → WeatherFlow Tempest Weather Station.

Each trigger includes a Tempest Device picker so it can be scoped to a specific station when you have more than one.

Lightning Strike Detected

Fires whenever the selected Tempest detects a lightning strike.

Configuration:

Use cases: - Send a push notification with distance and energy. - Flash a light or sound an alert. - Log strikes to a variable for counting.

Available at trigger time: The last_strike_distance, last_strike_energy, and last_strike_time device states are updated before the trigger fires, so you can read them in trigger actions.

Rain Started

Fires when the Tempest detects the onset of precipitation (the first rain-start event after a dry period).

Configuration:

Use cases: - Close roof vents or skylights. - Retract a pergola awning. - Send a "rain started" notification.

Note: This trigger fires from the Tempest's dedicated rain-start event, which is sent immediately when the sensor detects rain — independent of the 1-minute observation cycle. It fires once per rain onset, not repeatedly while rain continues.

The last_rain_start device state is updated when this trigger fires.

Rapid Wind Exceeds Threshold

Fires when an instantaneous wind reading meets or exceeds a configurable speed.

Rapid-wind readings arrive approximately every 3 seconds, giving near-real-time wind monitoring.

Configuration:

Use cases: - Close greenhouse vents above 10 m/s. - Retract a sail shade above 15 m/s. - Log wind gusts to a time-stamped variable.

The threshold is always compared against the raw m/s magnitude regardless of the display unit set in the device configuration. Convert your target speed if needed: 1 m/s = 3.6 km/h = 2.237 mph = 1.944 kn.

Trigger Limitations

• In power-save MODE_2 and above, rapid-wind events are not sent by the Tempest. The Rapid Wind Exceeds Threshold trigger will not fire in those modes. The wind_speed state still updates from the 1-minute observation, but at a lower frequency.
• Lightning and rain-start triggers fire from discrete UDP events and are not affected by power-save mode.

Station Silence Detection

The plugin monitors each Tempest station for data dropouts. If no observation is received for more than 5 minutes:

• The deviceStatus state is updated to "No data — last seen N min ago", making the outage visible in the Indigo device list without checking logs.
• A warning is written to the Indigo Event Log.
• The warning repeats every 30 minutes for as long as the silence continues, with an updated elapsed time.

When data resumes, deviceStatus returns to "Active" automatically on the next observation, and a recovery notice is logged.

The plugin also monitors the UDP listener itself. If the background socket task crashes for any reason, the listener is restarted automatically within 60 seconds.

Plugin Preferences

Open Plugins → WeatherFlow Tempest Weather Station → Configure.

Saving the preferences automatically restarts the UDP listener.

Plugin Menu

Plugins → WeatherFlow Tempest Weather Station exposes two menu commands:

• List Discovered WeatherFlow Devices — logs all currently-discovered serial numbers, models, and firmware versions to the Event Log.
• Restart UDP Listener — stops and restarts the listener without reloading the plugin (useful after network changes).

Troubleshooting

Device dropdown is empty / "No devices discovered yet" - Confirm the WeatherFlow hub is on the same subnet as the Indigo Mac. UDP broadcast does not cross router boundaries. - Check that nothing is blocking UDP port 50222 (macOS firewall, managed switch, VLAN separation). - Wait 60 seconds — hubs broadcast a status packet roughly once per minute — then use the Reload button in the device dialog.

deviceStatus shows "No data — last seen N min ago" - The station has not sent an observation in over 5 minutes. Check the hub's power and Wi-Fi connection, and confirm the Tempest is within RF range. - Check the Indigo Event Log for listener errors. Use Plugins → WeatherFlow → Restart UDP Listener to retry without reloading the plugin.

sea_level_pressure, cloud_base, freezing_level are missing - Set Altitude (m) to a non-zero value in the Tempest device configuration.

sensor_status shows all sensors failed - This is a known reporting quirk in some Tempest firmware versions where the raw hardware register value is broadcast before the sensor self-test completes. The plugin detects this pattern and displays OK instead. If only a subset of sensors are listed as failed, that is a genuine fault.

Debug logging - Set Indigo Log Level to Debugging Messages in Plugin Preferences for verbose output in the Event Log. - The plugin log file is written independently to ~/Library/Application Support/Perceptive Automation/Indigo 2025.x/Logs/. Set File Log Level to Detailed Debugging Messages for maximum detail.

Libraries & Acknowledgements

This plugin is built on several excellent open-source libraries bundled within the plugin package:

pyweatherflowudp — v1.5.2

by Nathan Spencer (@natekspencer)

The core UDP library that handles all communication with the WeatherFlow hub. It provides an event-based asynchronous interface, parses every WeatherFlow message type (observations, rapid wind, lightning strikes, rain events, device status), and exposes sensor values as typed properties with full unit support.

All derived meteorological calculations in the plugin — dew point, wet bulb temperature, heat index, feels-like temperature, vapour pressure, air density, sea-level pressure, cloud base, and freezing level — are provided by this library.

Licensed under MIT. If you find it useful, consider supporting Nathan on Ko-fi.

Pint — v0.25.3

Physical quantity handling with units. All sensor values from pyweatherflowudp carry their native unit (e.g. metres per second, millibars) and are converted to the user's chosen display unit using Pint's unit registry. This ensures unit conversions are numerically correct and the original precision is preserved.

PsychroLib — v2.5.0

Psychrometric calculations used by pyweatherflowudp to derive wet bulb temperature and related humidity metrics from the raw sensor readings.

License

MIT — see LICENSE for details.

Developed by GlennNZ.