Re: MMM-HoymilesPVMonitor

Ok, new try! I got caught up with some other stuff and started a new topic since it’s been more than half a year since my last attempt at publishing my module… My first attempt at publishing on github was unsuccessful (see previous discussion) so I decided to move the whole repository to Codeberg. Perhaps this works better :-)

A MagicMirror² module that displays live PV power and energy data from a Hoymiles DTU using a Chart.js donut chart.

This module queries the DTU via the local network at regular intervals and visualizes the current power, daily energy, and total energy values on your MagicMirror.

https://codeberg.org/CuddlyCow/MMM-HoymilesPVMonitor.git

Hello,
I have a question for @mumblebaj.
Kindly, is there a way to login with API key instead username+password method?
I read that now API key doesn’t have the classic method’s frequency update limitations.
It could be more useful to have “nearly live data” energy production.

Another question, less important, is there a way to hide the grid from the “table” view?
It’s not so important, I just like compact and minimal styles, when informations are more important than design itself.
Thanks a lot

I updated timeFormat: 12, in config.js and ran pm2 restart mm and it shows online.
npm run config:check returns
[2026-04-09 10:00:53.379] [LOG] [utils] Loading config …
[2026-04-09 10:00:53.394] [INFO] [utils] Checking config file /home/pi/MagicMirror/config/config.js …
[2026-04-09 10:00:53.581] [INFO] [utils] Your configuration file doesn’t contain syntax errors :)
[2026-04-09 10:00:53.582] [INFO] [utils] Checking modules structure configuration …
[2026-04-09 10:00:53.742] [INFO] [utils] Your modules structure configuration doesn’t contain errors :)

But any changes I make to config.js are not taking place. What could be wrong?

Use --update-env to update environment variables
[PM2] Applying action restartProcessId on app [mm](ids: [ 0 ])
[PM2] mm ✓
┌────┬───────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼───────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ mm │ default │ N/A │ fork │ 8787 │ 0s │ 105 │ online │ 0% │ 2.6mb │ pi │ disabled │

Since updating MM to 2.35 from 2.34, the default weather module is no longer displaying the forecast.
I use :
“openweathermap” option for the weatherProvider: key;
“forecast” option for the type: key; and
“/forecast” option for the weatherEndpoint: key

Other than updating the apiVersion from 2.5 to 3.0 in the config, no other changes have been made to any other keys within the module’s config and the module only shows “WEATHER FORECAST” as per the header: key, and then only displays Loading … where the forecast should be displayed.

My config for the module is as follows:

{
    module: "weather",
    position: "top_right",
    header: "WEATHER FORECAST",
    config: {
        // General Options
        weatherProvider: "openweathermap",
        type: "forecast",
        roundTemp: true,
        degreeLabel: true,
        updateInterval: 300000,
        showPeriod: true,
        showPeriodUpper: false,
        appendLocationNameToHeader: false,
        // Forecast Options
        tableClass: "xsmall",
        colored: true,
        fade: false,
        maxNumberOfDays: 5,
        // OpenWeatherMap Options
        apiVersion: "3.0",
        apiBase: "https://api.openweathermap.org/data/",
        weatherEndpoint: "/forecast",
        location: "Melbourne,Australia",
        apiKey: "xxxxx",
    
},

What am i missing in this latest release in the config of this module in MM 2.35?

I am new here and recently joined this helpful community. Happy to join with all forum members. Thanks

Hi,
The OpenWeatherMapForecast stopped working as of this morning.
MM has been running for a few months without any problem, but now no wheater data is displayed.

I use this code in the config file:

module: “weather”,
position: “top_right”,
header: “Current:”,
config: {
weatherProvider: “openmeteo”,
type: “current”,
lat: xxxxxxxx,
lon: xxxxxxxx,
tempUnits: “metric”,
showSun: true,
showWindDirection: false,
showWindDirAsArrow: false,
showHumidity: true,
degreeLabel: true,
showUVIndex: false,
showIndoorTemperature: true,
showIndoorHumidity: true,
showPrecipitationAmount: false,
showPrecipitationProbability: false,
onlyTemp: false,
hideCredits: true,
}

When I look in the MM log file I see this error:
0|mm | [2026-04-07 08:46:28.496] [ERROR] [http_fetcher] [weatherprovider.openmeteo] Server error (502). Retry #1 in 20 minutes

Could someone help me solving this.

Here is a module for displaying the “latest” added Movies and TV-Shows from your Plex server (using Tautulli).
MMM-TautulliLatest

Overview:

Click/Pointed on a “cover” view:

Exaple config:

{
  module: "MMM-TautulliLatest",
  position: "middle_center",
  config: {
    tautulliProtocol: "http",
    tautulliHost: "192.168.1.50",
    tautulliPort: 8181,
    tautulliApiKey: "YOUR_TAUTULLI_API_KEY",
    itemLimit: 8,
    updateInterval: 5 * 60 * 1000,
    posterWidth: 150,
    posterHeight: 225,
    posterMaxWidth: 150,
    posterMaxHeight: 225,
    detailPosterWidth: 400,
    detailPosterHeight: 600,
    showWatchedBadge: true,
    user_id: 123456
  }
}

I built a module to surface basic data from my Whoop tracker:

• Sleep (with prior day contrast)
• Recovery (with prior day contrast)
• Strain (with prior day contrast)
• Activities from the curent day
• Multi-user support for shared mirrors

Available at:
https://github.com/frankrenehan/MMM-Whoop

Hi,

I just updated to the latest version of MM but since the update my OpenWeather info is not working anymore, the info is all empty which was working fine before the update.

This is my config.js , does anyone have a solution?

	{
		module: "weather",
		position: "top_right",
		config: {
			weatherProvider: "openweathermap",
			weatherEndpoint:"/weather", 
			type: "current",	
			location: "Gemeente Nijkerk",
			locationID: "2750064", //ID from http://bulk.openweathermap.org/sample/city.list.json.gz; unzip the gz file and find your city
			apiVersion: "2.5",
			apiKey: "xxxxxxxxxx"
		}
	},
	{
		module: "weather",
		position: "top_right",
		header: "Weather Forecast",
		config: {
			weatherProvider: "openweathermap",
			weatherEndpoint:"/forecast", 
			type: "forecast",
			colored: "true",
			location: "Gemeente Nijkerk",
			locationID: "2750064", //ID from http://bulk.openweathermap.org/sample/city.list.json.gz; unzip the gz file and find your city
			apiVersion: "2.5", 
			apiKey: "xxxxxxx"
		}

Hello together,

Since the April update, I have an issue where the default weather module sends too many requests to the OpenWeathermap API. I reach the free limit of 1,000 requests after just a few hours.

Here’s an extract from my config.js:

 {
                        module: "weather",
                        position: "top_right",
                        config: {
                                weatherProvider: "openweathermap",
                                apiVersion: "3.0",
                                weatherEndpoint: "/onecall",
                                lat: "XXXXXX",
                                lon: "XXXXXX",
                                location: "XXXXXX",
                                showSun: true,
                                type: "current",
                                appendLocationNameToHeader: false,
                                apiKey: "XXXXXXX",
                                updateInterval: 10*60*1000, // Update every 10 minutes
                        }
                },
                {
                        module: "weather",
                        position: "top_right",
                        header: "Wetter Vorschau",
                        config: {
                                weatherProvider: "openweathermap",
                                type: "forecast",
                                location: "XXXXXX",
                                apiVersion: "3.0",
                                weatherEndpoint: "/onecall",
                                lat: "XXXXXX",
                                lon: "XXXXX",
                                appendLocationNameToHeader: false,
                                apiKey: "XXXXX",
                                updateInterval: 10*60*1000, // Update every 10 minutes
                                fade: false,
                                roundTemp: true,
                                ignoreToday: true,
                        }
                },

Has anyone a solution to solve this problem ?

Had anyone got Magic Mirror working on an off the shelf smart mirror?

I’m just starting a Home Lab and someone suggested Magic Mirror as something that might interest me. I could build one myself but for now am interested in any of the shelf options.

I imagine most off the shelf smart mirrors are not suitable for one reason or another, so if any have been used with Magic Mirror it might be handy to have a list of hacked mirrors and a topic for each explaining how to get it working.

This topic can be used to get this started, or if it’s been done please post a link. Thanks

Hi guys, i have changed my Philips hue Bridg to the new model .
I created a user ID
I have the right bridge ID
Now there is a problem.
Hope somebody can help …

Hi everyone,

The goal was to make something simple and reliable without requiring any API keys or Google developer setup.

In the spirit of giving back to the MagicMirror community, and as a companion to MMM-DriveVideos, here is:

MMM-DriveImages

Features:

• Displays images from Google Drive
• No API keys required
• No OAuth app setup
• Automatic background syncing (no cron)
• Simple setup for non-technical users
• Supports linear or random playback

Setup is done with a single command:
~/MagicMirror/modules/MMM-DriveImages/connect

After that, just upload photos to a Google Drive folder named:
mirror-images

The mirror updates automatically.

Repo:
https://github.com/Dresch360/MMM-DriveImages

Would love and appreciate any feedback.

Hi everyone,

The goal was to make something simple and reliable without requiring any API keys or Google developer setup.

In the spirit of giving back to the MagicMirror community, and as a companion to MMM-DriveImages created today, here is:

MMM-DriveVideos

This module lets you play videos directly from a Google Drive folder using simple browser authentication. No API keys. No Google developer setup.

Upload videos to a folder called mirror-videos and they will automatically sync and play on your mirror.

MP4 support
Linear or random playback
Optional sound on or off
Fully local playback after sync

GitHub:
https://github.com/Dresch360/MMM-DriveVideos

Would love and appreciate any feedback.

I need to back down to the previous release. I believe the 4/1 release of MM is a step too far in compatibility breaks.

Is there a guide on how to do this?

I updated MagicMirror the other day.
But now there is an issue: the mirror does not get weather info

— config.js snippet —
{
module: “weather”,
position: “top_right”,
header: “weersverwachting”,
config: {
apiVersion: “2.5”,
lat: “52.xxxxx”,
lon: “6.xxxxx”,
apiKey: “xxxxx”,
appendLocationNameToHeader: false,
type: “forecast”,
decimalSymbol: “,”,
colored: true,
fade: false,
weatherEndpoint: “/forecast”
}
},
— end —
(lat, lon and apikey are obscured for privacy)

So I pressed Ctrl+Shift+i and filtered on weather.
I this message: [weather] provider initialized, location: null (weather.js:177)

Heads up for anyone using the Swedish SMHI weather provider in MagicMirror²!

As of March 31, 2026, SMHI has deprecated their PMP3gv2 forecast API. It now returns HTTP 404.

I noticed this, this week when my MM suddenly were empty of weather reports.

The replacement is SNOW1gv1, hosted on the same domain but with a different data structure.

What changed in the API

• URL path: pmp3g/version/2 → snow1g/version/1
• Time key: validTime → time
• Data structure: The nested parameters[] array is replaced by a flat data object (e.g. entry.data.air_temperature instead of entry.parameters.find(p => p.name === 't').values[0])
• Parameter names: Short codes replaced by human-readable names (t → air_temperature, ws → wind_speed, Wsymb2 → symbol_code, etc.)
• Coordinates: Response now returns flat [lon, lat] instead of nested [[lon, lat]]
• approvedtime.json endpoint: Removed entirely — use referenceTime from the data response instead

Weather symbol codes (1–27) remain unchanged, so icon mapping still works as before.

Updated provider

I’ve updated the smhi.js provider to work with SNOW1gv1. Key changes:

• New API URL
• Rewritten data parser for the flat data object structure
• All parameter names mapped to their new equivalents
• Coordinate parsing updated for the new format
• Added missing value handling (SMHI uses 9999 as sentinel)
• Added support for precipitation type 11 (drizzle, new in SNOW1gv1)
• Backward compatible — existing config.js settings (including precipitationValue) work without changes

Tested and confirmed working with type: "daily" on a Raspberry Pi. The SNOW1gv1 API responds correctly and the weather module displays data as expected.

Code:

const Log = require("logger");
const { getSunTimes, isDayTime, validateCoordinates } = require("../provider-utils");
const HTTPFetcher = require("#http_fetcher");

/**
 * Server-side weather provider for SMHI (Swedish Meteorological and Hydrological Institute)
 * Sweden only, metric system
 *
 * API: SNOW1gv1 — https://opendata.smhi.se/metfcst/snow1gv1
 * Migrated from PMP3gv2 (deprecated 2026-03-31, returns HTTP 404)
 *
 * Version: 2.0.1 (2026-04-02)
 *
 * Key differences from PMP3gv2:
 * - URL: snow1g/version/1 (was pmp3g/version/2)
 * - Time key: "time" (was "validTime")
 * - Data structure: flat object entry.data.X (was parameters[].find().values[0])
 * - Parameter names: human-readable (air_temperature, wind_speed, etc.)
 * - Coordinates: flat [lon, lat] (was nested [[lon, lat]])
 * - Precipitation types: different value mapping (1=rain, not snow)
 */

/**
 * Maps user-facing config precipitationValue to SNOW1gv1 parameter names.
 * Maintains backward compatibility with existing MagicMirror configs.
 */
const PRECIP_VALUE_MAP = {
	pmin: "precipitation_amount_min",
	pmean: "precipitation_amount_mean",
	pmedian: "precipitation_amount_median",
	pmax: "precipitation_amount_max"
};

class SMHIProvider {
	constructor (config) {
		this.config = {
			lat: 0,
			lon: 0,
			precipitationValue: "pmedian", // pmin, pmean, pmedian, pmax
			type: "current",
			updateInterval: 5 * 60 * 1000,
			...config
		};

		// Validate precipitationValue
		if (!Object.keys(PRECIP_VALUE_MAP).includes(this.config.precipitationValue)) {
			Log.warn(`[smhi] Invalid precipitationValue: ${this.config.precipitationValue}, using pmedian`);
			this.config.precipitationValue = "pmedian";
		}

		this.fetcher = null;
		this.onDataCallback = null;
		this.onErrorCallback = null;
	}

	initialize () {
		try {
			// SMHI requires max 6 decimal places
			validateCoordinates(this.config, 6);
			this.#initializeFetcher();
		} catch (error) {
			Log.error("[smhi] Initialization failed:", error);
			if (this.onErrorCallback) {
				this.onErrorCallback({
					message: error.message,
					translationKey: "MODULE_ERROR_UNSPECIFIED"
				});
			}
		}
	}

	setCallbacks (onData, onError) {
		this.onDataCallback = onData;
		this.onErrorCallback = onError;
	}

	start () {
		if (this.fetcher) {
			this.fetcher.startPeriodicFetch();
		}
	}

	stop () {
		if (this.fetcher) {
			this.fetcher.clearTimer();
		}
	}

	#initializeFetcher () {
		const url = this.#getUrl();

		this.fetcher = new HTTPFetcher(url, {
			reloadInterval: this.config.updateInterval,
			logContext: "weatherprovider.smhi"
		});

		this.fetcher.on("response", async (response) => {
			try {
				const data = await response.json();
				this.#handleResponse(data);
			} catch (error) {
				Log.error("[smhi] Failed to parse JSON:", error);
				if (this.onErrorCallback) {
					this.onErrorCallback({
						message: "Failed to parse API response",
						translationKey: "MODULE_ERROR_UNSPECIFIED"
					});
				}
			}
		});

		this.fetcher.on("error", (errorInfo) => {
			if (this.onErrorCallback) {
				this.onErrorCallback(errorInfo);
			}
		});
	}

	#handleResponse (data) {
		try {
			if (!data.timeSeries || !Array.isArray(data.timeSeries)) {
				throw new Error("Invalid weather data");
			}

			const coordinates = this.#resolveCoordinates(data);
			let weatherData;

			switch (this.config.type) {
				case "current":
					weatherData = this.#generateCurrentWeather(data.timeSeries, coordinates);
					break;
				case "forecast":
				case "daily":
					weatherData = this.#generateForecast(data.timeSeries, coordinates);
					break;
				case "hourly":
					weatherData = this.#generateHourly(data.timeSeries, coordinates);
					break;
				default:
					Log.error(`[smhi] Unknown weather type: ${this.config.type}`);
					if (this.onErrorCallback) {
						this.onErrorCallback({
							message: `Unknown weather type: ${this.config.type}`,
							translationKey: "MODULE_ERROR_UNSPECIFIED"
						});
					}
					return;
			}

			if (this.onDataCallback) {
				this.onDataCallback(weatherData);
			}
		} catch (error) {
			Log.error("[smhi] Error processing weather data:", error);
			if (this.onErrorCallback) {
				this.onErrorCallback({
					message: error.message,
					translationKey: "MODULE_ERROR_UNSPECIFIED"
				});
			}
		}
	}

	#generateCurrentWeather (timeSeries, coordinates) {
		const closest = this.#getClosestToCurrentTime(timeSeries);
		return this.#convertWeatherDataToObject(closest, coordinates);
	}

	#generateForecast (timeSeries, coordinates) {
		const filled = this.#fillInGaps(timeSeries);
		return this.#convertWeatherDataGroupedBy(filled, coordinates, "day");
	}

	#generateHourly (timeSeries, coordinates) {
		const filled = this.#fillInGaps(timeSeries);
		return this.#convertWeatherDataGroupedBy(filled, coordinates, "hour");
	}

	/**
	 * Find the time series entry closest to the current time.
	 * SNOW1gv1 uses "time" instead of PMP3gv2's "validTime".
	 */
	#getClosestToCurrentTime (times) {
		const now = new Date();
		let minDiff = null;
		let closest = times[0];

		for (const time of times) {
			const entryTime = new Date(time.time);
			const diff = Math.abs(entryTime - now);

			if (minDiff === null || diff < minDiff) {
				minDiff = diff;
				closest = time;
			}
		}

		return closest;
	}

	/**
	 * Convert a single SNOW1gv1 time series entry to MagicMirror weather object.
	 *
	 * SNOW1gv1 data structure: entry.data.parameter_name (flat object)
	 * PMP3gv2 used: entry.parameters[{name, values}] (array of objects)
	 */
	#convertWeatherDataToObject (weatherData, coordinates) {
		const date = new Date(weatherData.time);
		const { sunrise, sunset } = getSunTimes(date, coordinates.lat, coordinates.lon);
		const isDay = isDayTime(date, sunrise, sunset);

		const current = {
			date: date,
			humidity: this.#paramValue(weatherData, "relative_humidity"),
			temperature: this.#paramValue(weatherData, "air_temperature"),
			windSpeed: this.#paramValue(weatherData, "wind_speed"),
			windFromDirection: this.#paramValue(weatherData, "wind_from_direction"),
			weatherType: this.#convertWeatherType(this.#paramValue(weatherData, "symbol_code"), isDay),
			feelsLikeTemp: this.#calculateApparentTemperature(weatherData),
			sunrise: sunrise,
			sunset: sunset,
			snow: 0,
			rain: 0,
			precipitationAmount: 0
		};

		// Map user config (pmedian/pmean/pmin/pmax) to SNOW1gv1 parameter name
		const precipParamName = PRECIP_VALUE_MAP[this.config.precipitationValue];
		const precipitationValue = this.#paramValue(weatherData, precipParamName);
		const pcat = this.#paramValue(weatherData, "predominant_precipitation_type_at_surface");

		// SNOW1gv1 precipitation type mapping (differs from PMP3gv2!):
		//   0  = no precipitation
		//   1  = rain
		//   2  = sleet (snow + rain mix)
		//   5  = snow / freezing rain
		//   6  = freezing mixed precipitation
		//   11 = drizzle / light rain
		switch (pcat) {
			case 1: // Rain
			case 11: // Drizzle / light rain
				current.rain = precipitationValue;
				current.precipitationAmount = precipitationValue;
				break;
			case 2: // Sleet / mixed rain and snow
				current.snow = precipitationValue / 2;
				current.rain = precipitationValue / 2;
				current.precipitationAmount = precipitationValue;
				break;
			case 5: // Snow / freezing rain
			case 6: // Freezing mixed precipitation
				current.snow = precipitationValue;
				current.precipitationAmount = precipitationValue;
				break;
			case 0:
			default:
				break;
		}

		return current;
	}

	#convertWeatherDataGroupedBy (allWeatherData, coordinates, groupBy = "day") {
		const result = [];
		let currentWeather = null;
		let dayWeatherTypes = [];

		const allWeatherObjects = allWeatherData.map((data) => this.#convertWeatherDataToObject(data, coordinates));

		for (const weatherObject of allWeatherObjects) {
			const objDate = new Date(weatherObject.date);

			// Check if we need a new group (day or hour change)
			const needNewGroup = !currentWeather || !this.#isSamePeriod(currentWeather.date, objDate, groupBy);

			if (needNewGroup) {
				currentWeather = {
					date: objDate,
					temperature: weatherObject.temperature,
					minTemperature: Infinity,
					maxTemperature: -Infinity,
					snow: 0,
					rain: 0,
					precipitationAmount: 0,
					sunrise: weatherObject.sunrise,
					sunset: weatherObject.sunset
				};
				dayWeatherTypes = [];
				result.push(currentWeather);
			}

			// Track weather types during daytime
			const { sunrise: daySunrise, sunset: daySunset } = getSunTimes(objDate, coordinates.lat, coordinates.lon);
			const isDay = isDayTime(objDate, daySunrise, daySunset);

			if (isDay) {
				dayWeatherTypes.push(weatherObject.weatherType);
			}

			// Use median weather type from daytime hours
			if (dayWeatherTypes.length > 0) {
				currentWeather.weatherType = dayWeatherTypes[Math.floor(dayWeatherTypes.length / 2)];
			} else {
				currentWeather.weatherType = weatherObject.weatherType;
			}

			// Aggregate min/max and precipitation
			currentWeather.minTemperature = Math.min(currentWeather.minTemperature, weatherObject.temperature);
			currentWeather.maxTemperature = Math.max(currentWeather.maxTemperature, weatherObject.temperature);
			currentWeather.snow += weatherObject.snow;
			currentWeather.rain += weatherObject.rain;
			currentWeather.precipitationAmount += weatherObject.precipitationAmount;
		}

		return result;
	}

	#isSamePeriod (date1, date2, groupBy) {
		if (groupBy === "hour") {
			return date1.getFullYear() === date2.getFullYear()
			  && date1.getMonth() === date2.getMonth()
			  && date1.getDate() === date2.getDate()
			  && date1.getHours() === date2.getHours();
		} else { // day
			return date1.getFullYear() === date2.getFullYear()
			  && date1.getMonth() === date2.getMonth()
			  && date1.getDate() === date2.getDate();
		}
	}

	/**
	 * Fill gaps in time series data for forecast/hourly grouping.
	 * SNOW1gv1 has variable time steps: 1h (0-48h), 2h (49-72h), 6h (73-132h), 12h (133h+).
	 * Uses "time" key instead of PMP3gv2's "validTime".
	 */
	#fillInGaps (data) {
		if (data.length === 0) return [];

		const result = [];
		result.push(data[0]);

		for (let i = 1; i < data.length; i++) {
			const from = new Date(data[i - 1].time);
			const to = new Date(data[i].time);
			const hours = Math.floor((to - from) / (1000 * 60 * 60));

			// Fill gaps with previous data point (start at j=1 since j=0 is already pushed)
			for (let j = 1; j < hours; j++) {
				const current = { ...data[i - 1] };
				const newTime = new Date(from);
				newTime.setHours(from.getHours() + j);
				current.time = newTime.toISOString();
				result.push(current);
			}

			// Push original data point
			result.push(data[i]);
		}

		return result;
	}

	/**
	 * Extract coordinates from SNOW1gv1 response.
	 * SNOW1gv1 returns flat GeoJSON Point: { coordinates: [lon, lat] }
	 * PMP3gv2 returned nested: { coordinates: [[lon, lat]] }
	 */
	#resolveCoordinates (data) {
		const coords = data?.geometry?.coordinates;

		if (Array.isArray(coords) && coords.length >= 2 && typeof coords[0] === "number") {
			// SNOW1gv1 flat format: [lon, lat]
			return {
				lat: coords[1],
				lon: coords[0]
			};
		}

		Log.warn("[smhi] Invalid coordinate structure in response, using config values");
		return {
			lat: this.config.lat,
			lon: this.config.lon
		};
	}

	/**
	 * Calculate apparent (feels-like) temperature using humidity and wind.
	 * Uses SNOW1gv1 parameter names.
	 */
	#calculateApparentTemperature (weatherData) {
		const Ta = this.#paramValue(weatherData, "air_temperature");
		const rh = this.#paramValue(weatherData, "relative_humidity");
		const ws = this.#paramValue(weatherData, "wind_speed");

		if (Ta === null || rh === null || ws === null) {
			return Ta; // Fallback to raw temperature if data missing
		}

		const p = (rh / 100) * 6.105 * Math.exp((17.27 * Ta) / (237.7 + Ta));
		return Ta + 0.33 * p - 0.7 * ws - 4;
	}

	/**
	 * Get parameter value from SNOW1gv1 flat data structure.
	 * SNOW1gv1: weatherData.data.parameter_name (direct property access)
	 * PMP3gv2 used: weatherData.parameters.find(p => p.name === name).values[0]
	 *
	 * Returns null if parameter missing or equals SMHI missing value (9999).
	 */
	#paramValue (weatherData, name) {
		const value = weatherData.data?.[name];

		if (value === undefined || value === null) {
			return null;
		}

		// SMHI uses 9999 as missing value sentinel for all parameters
		if (value === 9999) {
			return null;
		}

		return value;
	}

	/**
	 * Convert SMHI symbol_code (1-27) to MagicMirror weather icon names.
	 * Symbol codes are identical between PMP3gv2 and SNOW1gv1.
	 */
	#convertWeatherType (input, isDayTime) {
		switch (input) {
			case 1:
				return isDayTime ? "day-sunny" : "night-clear"; // Clear sky
			case 2:
				return isDayTime ? "day-sunny-overcast" : "night-partly-cloudy"; // Nearly clear sky
			case 3:
			case 4:
				return isDayTime ? "day-cloudy" : "night-cloudy"; // Variable/halfclear cloudiness
			case 5:
			case 6:
				return "cloudy"; // Cloudy/overcast
			case 7:
				return "fog";
			case 8:
			case 9:
			case 10:
				return "showers"; // Light/moderate/heavy rain showers
			case 11:
			case 21:
				return "thunderstorm";
			case 12:
			case 13:
			case 14:
			case 22:
			case 23:
			case 24:
				return "sleet"; // Light/moderate/heavy sleet (showers)
			case 15:
			case 16:
			case 17:
			case 25:
			case 26:
			case 27:
				return "snow"; // Light/moderate/heavy snow (showers/fall)
			case 18:
			case 19:
			case 20:
				return "rain"; // Light/moderate/heavy rain
			default:
				return null;
		}
	}

	/**
	 * Build SNOW1gv1 forecast URL.
	 * Changed from: pmp3g/version/2
	 * Changed to:   snow1g/version/1
	 */
	#getUrl () {
		const lon = this.config.lon.toFixed(6);
		const lat = this.config.lat.toFixed(6);
		return `https://opendata-download-metfcst.smhi.se/api/category/snow1g/version/1/geotype/point/lon/${lon}/lat/${lat}/data.json`;
	}
}

module.exports = SMHIProvider;

Hallo Guys,

my Mirror Dashboard is using 13 pages. Since the last update all the modules are shown at page 1 after a restart. When I select the Page 1 for example everything is shown correct. It’s only after a restart or a refresh of the Page. Maybe somebody have an idea?

Please help!

I just updated my MM to the new version and right after doing that my calendar would not load any events. Prior to the update it was working fine. Is there anything in the config I need to tweak? Everything else seems to be working fine.

Thanks in advance!

I’m having a problem with event transforming not working anymore in Mirror 2.35.0

the client title (Client’s name) is shown instead of the ev.title I want (Client)

Nothing is in the logs - help!

Here’s the code:

	{
	  		module: "MMM-CalendarExt3Agenda",
  			position: "bottom_center",
  			classes: "page1",
  			config: {
  				eventTransformer: (ev) => {
					if (ev.title.search("🏠 Personal Commitment") > -1) {
						ev.title = ev.title.replace("🏠 Personal Commitment","Personal Commitment")
					}
					if(ev.description && ev.description.search("YCBM") > -1) {
       					 	ev.title = "Client"
 					} 
					return ev
				},
				showMiniMonthCalendar: false,
				//onlyEventDays: 1, 
				waitFetch: 5000, 
				refreshInterval: 10000,
				animationSpeed: 0,
				calendarSet: ["Main", "Lemay", "Holidays"],
			}
		},