diff --git a/csharp/App/Backend/Backend.csproj b/csharp/App/Backend/Backend.csproj index 518c98e37..137c54d42 100644 --- a/csharp/App/Backend/Backend.csproj +++ b/csharp/App/Backend/Backend.csproj @@ -8,6 +8,7 @@ + @@ -43,6 +44,15 @@ PreserveNewest + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + diff --git a/csharp/App/Backend/Controller.cs b/csharp/App/Backend/Controller.cs index 0dcbeb057..46b4e3ad8 100644 --- a/csharp/App/Backend/Controller.cs +++ b/csharp/App/Backend/Controller.cs @@ -5,6 +5,7 @@ using InnovEnergy.App.Backend.Database; using InnovEnergy.App.Backend.DataTypes; using InnovEnergy.App.Backend.DataTypes.Methods; using InnovEnergy.App.Backend.Relations; +using InnovEnergy.App.Backend.Services; using InnovEnergy.App.Backend.Websockets; using InnovEnergy.Lib.Utils; using Microsoft.AspNetCore.Mvc; @@ -362,6 +363,38 @@ public class Controller : ControllerBase return user.AccessibleInstallations().ToList(); } + [HttpGet(nameof(GetDirectInstallationAccessForUser))] + public ActionResult> GetDirectInstallationAccessForUser(Int64 userId, Token authToken) + { + var sessionUser = Db.GetSession(authToken)?.User; + if (sessionUser == null) + return Unauthorized(); + + var user = Db.GetUserById(userId); + if (user == null) + return Unauthorized(); + + return user.DirectlyAccessibleInstallations() + .Select(i => new { i.Id, i.Name }) + .ToList(); + } + + [HttpGet(nameof(GetDirectFolderAccessForUser))] + public ActionResult> GetDirectFolderAccessForUser(Int64 userId, Token authToken) + { + var sessionUser = Db.GetSession(authToken)?.User; + if (sessionUser == null) + return Unauthorized(); + + var user = Db.GetUserById(userId); + if (user == null) + return Unauthorized(); + + return user.DirectlyAccessibleFolders() + .Select(f => new { f.Id, f.Name }) + .ToList(); + } + [HttpGet(nameof(GetUsersWithInheritedAccessToInstallation))] public ActionResult> GetUsersWithInheritedAccessToInstallation(Int64 id, Token authToken) { @@ -740,7 +773,189 @@ public class Controller : ControllerBase ? Ok() : Unauthorized(); } - + + /// + /// Returns an AI-generated diagnosis for a single error/alarm description. + /// Responses are cached in memory — repeated calls for the same error code + /// do not hit Mistral again. + /// + [HttpGet(nameof(DiagnoseError))] + public async Task> DiagnoseError(Int64 installationId, string errorDescription, Token authToken) + { + var user = Db.GetSession(authToken)?.User; + if (user == null) + return Unauthorized(); + + var installation = Db.GetInstallationById(installationId); + if (installation is null || !user.HasAccessTo(installation)) + return Unauthorized(); + + // AI diagnostics are scoped to SodistoreHome and SodiStoreMax only + if (installation.Product != (int)ProductType.SodioHome && + installation.Product != (int)ProductType.SodiStoreMax) + return BadRequest("AI diagnostics not available for this product."); + + var result = await DiagnosticService.DiagnoseAsync(installationId, errorDescription, user.Language ?? "en"); + + if (result is null) + return NoContent(); // no diagnosis available (not in knowledge base, no API key) + + return result; + } + + /// + /// Test endpoint for AlarmKnowledgeBase - no authentication required. + /// Tests multiple Sinexcel and Growatt alarms to verify the knowledge base works. + /// Remove this endpoint in production if not needed. + /// + [HttpGet(nameof(TestAlarmKnowledgeBase))] + public ActionResult TestAlarmKnowledgeBase() + { + var testCases = new[] + { + // Sinexcel alarms (keys match SinexcelRecord.Api.cs property names) + "FanFault", + "AbnormalGridVoltage", + "Battery1NotConnected", + "InverterPowerTubeFault", + "IslandProtection", + // Growatt alarms (keys match GrowattWarningCode/GrowattErrorCode enum names) + "NoUtilityGrid", + "BatteryCommunicationFailure", + "BmsFault", + "OverTemperature", + "AFCI Fault", + // Unknown alarm (should return null - would call Mistral) + "Some unknown alarm XYZ123" + }; + + var results = new List(); + foreach (var alarm in testCases) + { + var diagnosis = AlarmKnowledgeBase.TryGetDiagnosis(alarm); + results.Add(new + { + Alarm = alarm, + FoundInKnowledgeBase = diagnosis != null, + Explanation = diagnosis?.Explanation ?? "NOT FOUND - Would call Mistral API", + CausesCount = diagnosis?.Causes.Count ?? 0, + NextStepsCount = diagnosis?.NextSteps.Count ?? 0 + }); + } + + return Ok(new + { + TestTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), + TotalTests = testCases.Length, + FoundInKnowledgeBase = results.Count(r => ((dynamic)r).FoundInKnowledgeBase), + WouldCallMistral = results.Count(r => !((dynamic)r).FoundInKnowledgeBase), + Results = results + }); + } + + /// + /// Test endpoint for the full AI diagnostic flow (knowledge base + Mistral API). + /// No auth required. Remove before production. + /// Usage: GET /api/TestDiagnoseError?errorDescription=SomeAlarm + /// + [HttpGet(nameof(TestDiagnoseError))] + public async Task TestDiagnoseError(string errorDescription = "AbnormalGridVoltage", string language = "en") + { + // 1. Try static lookup (KB for English, pre-generated translations for others) + var staticResult = DiagnosticService.TryGetTranslation(errorDescription, language); + if (staticResult is not null) + { + return Ok(new + { + Source = "KnowledgeBase", + Alarm = errorDescription, + MistralEnabled = DiagnosticService.IsEnabled, + staticResult.Explanation, + staticResult.Causes, + staticResult.NextSteps + }); + } + + // 2. If not found, try Mistral with the correct language + if (!DiagnosticService.IsEnabled) + return Ok(new { Source = "None", Alarm = errorDescription, Message = "Not in knowledge base and Mistral API key not configured." }); + + var aiResult = await DiagnosticService.TestCallMistralAsync(errorDescription, language); + if (aiResult is null) + return Ok(new { Source = "MistralFailed", Alarm = errorDescription, Message = "Mistral API call failed or returned empty." }); + + return Ok(new + { + Source = "MistralAI", + Alarm = errorDescription, + aiResult.Explanation, + aiResult.Causes, + aiResult.NextSteps + }); + } + + // ── Weekly Performance Report ────────────────────────────────────── + + /// + /// Generates a weekly performance report from an Excel file in tmp_report/{installationId}.xlsx + /// Returns JSON with daily data, weekly totals, ratios, and AI insight. + /// + [HttpGet(nameof(GetWeeklyReport))] + public async Task> GetWeeklyReport(Int64 installationId, Token authToken, string? language = null) + { + var user = Db.GetSession(authToken)?.User; + if (user == null) + return Unauthorized(); + + var installation = Db.GetInstallationById(installationId); + if (installation is null || !user.HasAccessTo(installation)) + return Unauthorized(); + + var filePath = Environment.CurrentDirectory + "/tmp_report/" + installationId + ".xlsx"; + if (!System.IO.File.Exists(filePath)) + return NotFound($"No report data file found. Please place the Excel export at: tmp_report/{installationId}.xlsx"); + + try + { + var lang = language ?? user.Language ?? "en"; + var report = await WeeklyReportService.GenerateReportAsync(installationId, installation.InstallationName, lang); + return Ok(report); + } + catch (Exception ex) + { + Console.Error.WriteLine($"[GetWeeklyReport] Error: {ex.Message}"); + return BadRequest($"Failed to generate report: {ex.Message}"); + } + } + + /// + /// Sends the weekly report as a formatted HTML email. + /// + [HttpPost(nameof(SendWeeklyReportEmail))] + public async Task SendWeeklyReportEmail(Int64 installationId, string emailAddress, Token authToken) + { + var user = Db.GetSession(authToken)?.User; + if (user == null) + return Unauthorized(); + + var installation = Db.GetInstallationById(installationId); + if (installation is null || !user.HasAccessTo(installation)) + return Unauthorized(); + + try + { + var lang = user.Language ?? "en"; + var report = await WeeklyReportService.GenerateReportAsync(installationId, installation.InstallationName, lang); + await ReportEmailService.SendReportEmailAsync(report, emailAddress, lang); + return Ok(new { message = $"Report sent to {emailAddress}" }); + } + catch (Exception ex) + { + Console.Error.WriteLine($"[SendWeeklyReportEmail] Error: {ex.Message}"); + return BadRequest($"Failed to send report: {ex.Message}"); + } + } + [HttpPut(nameof(UpdateFolder))] public ActionResult UpdateFolder([FromBody] Folder folder, Token authToken) { @@ -1072,6 +1287,104 @@ public class Controller : ControllerBase return Redirect($"https://monitor.inesco.energy/?username={user.Email}&reset=true"); // TODO: move to settings file } + // ── Alarm Review Campaign ──────────────────────────────────────────────── + + [HttpPost(nameof(SendTestAlarmReview))] + public async Task SendTestAlarmReview() + { + await AlarmReviewService.SendTestBatchAsync(); + return Ok(new { message = "Test review email sent to liu@inesco.energy. Check your inbox." }); + } + + [HttpPost(nameof(StartAlarmReviewCampaign))] + public ActionResult StartAlarmReviewCampaign() + { + AlarmReviewService.StartCampaign(); + return Ok(new { message = "Alarm review campaign started." }); + } + + [HttpPost(nameof(StopAlarmReviewCampaign))] + public ActionResult StopAlarmReviewCampaign() + { + AlarmReviewService.StopCampaign(); + return Ok(new { message = "Campaign paused — progress preserved. Use ResumeAlarmReviewCampaign to restart timers." }); + } + + [HttpPost(nameof(ResumeAlarmReviewCampaign))] + public ActionResult ResumeAlarmReviewCampaign() + { + AlarmReviewService.ResumeCampaign(); + return Ok(new { message = "Campaign resumed — timers restarted from existing progress." }); + } + + [HttpPost(nameof(ResetAlarmReviewCampaign))] + public ActionResult ResetAlarmReviewCampaign() + { + AlarmReviewService.ResetCampaign(); + return Ok(new { message = "Campaign fully reset — all progress deleted. Use StartAlarmReviewCampaign to begin again." }); + } + + [HttpGet(nameof(CorrectAlarm))] + public ActionResult CorrectAlarm(int batch, string key) + { + var html = AlarmReviewService.GetCorrectionPage(batch, key); + return Content(html, "text/html"); + } + + [HttpPost(nameof(ApplyAlarmCorrection))] + public ActionResult ApplyAlarmCorrection([FromBody] AlarmCorrectionRequest req) + { + if (req == null) return BadRequest(); + var correction = new DiagnosticResponse + { + Explanation = req.Explanation ?? "", + Causes = req.Causes ?? new List(), + NextSteps = req.NextSteps ?? new List(), + }; + var ok = AlarmReviewService.ApplyCorrection(req.BatchNumber, req.AlarmKey ?? "", correction); + return ok ? Ok(new { message = "Korrektur gespeichert." }) : BadRequest("Batch or alarm not found."); + } + + [HttpGet(nameof(ReviewAlarms))] + public ActionResult ReviewAlarms(int batch, string reviewer) + { + var html = AlarmReviewService.GetReviewPage(batch, reviewer); + if (html is null) return NotFound("Batch not found or reviewer not recognised."); + return Content(html, "text/html"); + } + + [HttpPost(nameof(SubmitAlarmReview))] + public async Task SubmitAlarmReview(int batch, string? reviewer, [FromBody] List? feedbacks) + { + // Batch 0 = test mode — run dry-run synthesis and return preview HTML (nothing is saved) + if (batch == 0) + { + var previewHtml = await AlarmReviewService.PreviewSynthesisAsync(feedbacks); + return Ok(new { preview = previewHtml }); + } + + var ok = AlarmReviewService.SubmitFeedback(batch, reviewer, feedbacks); + return ok ? Ok(new { message = "Feedback saved. Thank you!" }) + : BadRequest("Batch not found, reviewer not recognised, or already submitted."); + } + + [HttpGet(nameof(GetAlarmReviewStatus))] + public ActionResult GetAlarmReviewStatus() + { + return Ok(AlarmReviewService.GetStatus()); + } + + [HttpGet(nameof(DownloadCheckedKnowledgeBase))] + public ActionResult DownloadCheckedKnowledgeBase() + { + var content = AlarmReviewService.GetCheckedFileContent(); + if (content is null) return NotFound("AlarmKnowledgeBaseChecked.cs has not been generated yet."); + + return File(System.Text.Encoding.UTF8.GetBytes(content), + "text/plain", + "AlarmKnowledgeBaseChecked.cs"); + } + } diff --git a/csharp/App/Backend/DataTypes/BehavioralPattern.cs b/csharp/App/Backend/DataTypes/BehavioralPattern.cs new file mode 100644 index 000000000..a2639cb0f --- /dev/null +++ b/csharp/App/Backend/DataTypes/BehavioralPattern.cs @@ -0,0 +1,28 @@ +namespace InnovEnergy.App.Backend.DataTypes; + +/// +/// Pre-computed behavioral facts derived from hourly data. +/// All heavy analysis is done in C# — the AI only gets these clean conclusions. +/// +public class BehavioralPattern +{ + // Peak hours + public int PeakLoadHour { get; set; } // 0-23, hour of day with highest avg load + public int PeakSolarHour { get; set; } // 0-23, hour with highest avg PV output + public int PeakSolarEndHour { get; set; } // last hour of meaningful solar window + public int HighestGridImportHour { get; set; } // 0-23, hour with most avg grid import + + // kWh figures + public double AvgPeakLoadKwh { get; set; } // avg load at peak hour (per day) + public double AvgPeakSolarKwh { get; set; } // avg PV at peak solar hour (per day) + public double AvoidableGridKwh { get; set; } // grid import during hours solar was active + public double AvgGridImportAtPeakHour { get; set; } // avg grid import at worst hour + + // Weekday vs weekend + public double WeekdayAvgDailyLoad { get; set; } // avg kWh/day Mon-Fri + public double WeekendAvgDailyLoad { get; set; } // avg kWh/day Sat-Sun + + // Battery + public int AvgBatteryDepletedHour { get; set; } // avg hour when SoC first drops below 20% + public bool BatteryDepletesOvernight { get; set; } // true if battery regularly hits low SoC at night +} diff --git a/csharp/App/Backend/DataTypes/DailyEnergyData.cs b/csharp/App/Backend/DataTypes/DailyEnergyData.cs new file mode 100644 index 000000000..80930ac73 --- /dev/null +++ b/csharp/App/Backend/DataTypes/DailyEnergyData.cs @@ -0,0 +1,12 @@ +namespace InnovEnergy.App.Backend.DataTypes; + +public class DailyEnergyData +{ + public string Date { get; set; } = ""; // "2026-02-10" + public double PvProduction { get; set; } // kWh + public double LoadConsumption { get; set; } // kWh + public double GridImport { get; set; } // kWh + public double GridExport { get; set; } // kWh + public double BatteryCharged { get; set; } // kWh + public double BatteryDischarged { get; set; } // kWh +} diff --git a/csharp/App/Backend/DataTypes/HourlyEnergyData.cs b/csharp/App/Backend/DataTypes/HourlyEnergyData.cs new file mode 100644 index 000000000..4b6463fe9 --- /dev/null +++ b/csharp/App/Backend/DataTypes/HourlyEnergyData.cs @@ -0,0 +1,19 @@ +namespace InnovEnergy.App.Backend.DataTypes; + +public class HourlyEnergyData +{ + public DateTime DateTime { get; set; } // e.g. 2026-02-14 08:00:00 + public int Hour { get; set; } // 0-23 + public string DayOfWeek { get; set; } = ""; // "Monday" etc. + public bool IsWeekend { get; set; } + + // Energy for this hour (kWh) — derived from diff of consecutive "Today" cumulative snapshots + public double PvKwh { get; set; } + public double LoadKwh { get; set; } + public double GridImportKwh { get; set; } + public double BatteryChargedKwh { get; set; } + public double BatteryDischargedKwh { get; set; } + + // Instantaneous state at snapshot time + public double BattSoC { get; set; } // % (0-100) +} diff --git a/csharp/App/Backend/DataTypes/Methods/Session.cs b/csharp/App/Backend/DataTypes/Methods/Session.cs index 110b9ab1b..3b62cb6f3 100644 --- a/csharp/App/Backend/DataTypes/Methods/Session.cs +++ b/csharp/App/Backend/DataTypes/Methods/Session.cs @@ -14,9 +14,9 @@ public static class SessionMethods var user = session?.User; return user is not null - && folder is not null - && user.UserType!=0 - && user.HasAccessTo(folder.Parent()) + && folder is not null + && user.UserType==2 + && user.HasAccessTo(folder.Parent()) && Db.Create(folder) // TODO: these two in a transaction && Db.Create(new FolderAccess { UserId = user.Id, FolderId = folder.Id }); } @@ -41,16 +41,32 @@ public static class SessionMethods var user = session?.User; var folder = Db.GetFolderById(folderId); var parent = Db.GetFolderById(parentId); - + return user is not null - && folder is not null - && user.UserType !=0 + && folder is not null + && parent is not null + && folderId != parentId // can't move into itself + && !IsFolderAncestorOf(folderId, parentId) // can't move into a descendant + && user.UserType==2 && user.HasAccessTo(folder) && user.HasAccessTo(parent) && folder .Do(() => folder.ParentId = parentId) .Apply(Db.Update); } + + // Walks up the folder tree from candidateDescendantId to check if ancestorId is an ancestor. + // Prevents circular references when moving a folder into one of its own descendants. + private static Boolean IsFolderAncestorOf(Int64 ancestorId, Int64 candidateDescendantId) + { + var current = Db.GetFolderById(candidateDescendantId); + while (current is not null && current.ParentId != 0) + { + if (current.ParentId == ancestorId) return true; + current = Db.GetFolderById(current.ParentId); + } + return false; + } public static Boolean MoveInstallation(this Session? session, Int64 installationId, Int64 parentId) { @@ -61,7 +77,7 @@ public static class SessionMethods if(installation == null || installation.ParentId == parentId) return false; return user is not null - && user.UserType !=0 + && user.UserType==2 && user.HasAccessTo(installation) && user.HasAccessTo(parent) && installation @@ -144,8 +160,8 @@ public static class SessionMethods var installation = Db.GetInstallationById(action.InstallationId); installation.TestingMode = action.TestingMode; installation.Apply(Db.Update); - WebsocketManager.InformWebsocketsForInstallation(action.InstallationId); - + await WebsocketManager.InformWebsocketsForInstallation(action.InstallationId); + // Save the configuration change to the database Db.HandleAction(action); return true; @@ -163,7 +179,7 @@ public static class SessionMethods { installation.TestingMode = action.TestingMode; installation.Apply(Db.Update); - WebsocketManager.InformWebsocketsForInstallation(action.InstallationId); + await WebsocketManager.InformWebsocketsForInstallation(action.InstallationId); } Db.UpdateAction(action); @@ -183,7 +199,7 @@ public static class SessionMethods var installation = Db.GetInstallationById(action.InstallationId); installation.TestingMode = false; installation.Apply(Db.Update); - WebsocketManager.InformWebsocketsForInstallation(action.InstallationId); + await WebsocketManager.InformWebsocketsForInstallation(action.InstallationId); } Db.Delete(action); @@ -360,8 +376,7 @@ public static class SessionMethods && sessionUser.HasAccessTo(originalUser) && editedUser .WithParentOf(originalUser) // prevent moving - .WithNameOf(originalUser) - .WithPasswordOf(originalUser) + .WithPasswordOf(originalUser) .Apply(Db.Update); } @@ -457,24 +472,36 @@ public static class SessionMethods public static Boolean RevokeUserAccessTo(this Session? session, User? user, Installation? installation) { var sessionUser = session?.User; - - return sessionUser is not null - && installation is not null - && user is not null - && user.IsDescendantOf(sessionUser) - && sessionUser.HasAccessTo(installation) - && user.HasAccessTo(installation) - && Db.InstallationAccess.Delete(a => a.UserId == user.Id && a.InstallationId == installation.Id) > 0; + + if (sessionUser is null || installation is null || user is null) + return false; + + if (!(user.IsDescendantOf(sessionUser) || sessionUser.UserType == 2)) + return false; + + if (!sessionUser.HasAccessTo(installation) || !user.HasAccessTo(installation)) + return false; + + // Try direct InstallationAccess record first + if (Db.InstallationAccess.Delete(a => a.UserId == user.Id && a.InstallationId == installation.Id) > 0) + return true; + + // No direct record — access is inherited via a folder; revoke that folder access + var accessFolder = installation.Ancestors() + .FirstOrDefault(f => user.HasDirectAccessTo(f)); + + return accessFolder is not null + && Db.FolderAccess.Delete(a => a.UserId == user.Id && a.FolderId == accessFolder.Id) > 0; } - + public static Boolean RevokeUserAccessTo(this Session? session, User? user, Folder? folder) { var sessionUser = session?.User; - + return sessionUser is not null && folder is not null && user is not null - && user.IsDescendantOf(sessionUser) + && (user.IsDescendantOf(sessionUser) || sessionUser.UserType == 2) && sessionUser.HasAccessTo(folder) && user.HasAccessTo(folder) && Db.FolderAccess.Delete(a => a.UserId == user.Id && a.FolderId == folder.Id) > 0; diff --git a/csharp/App/Backend/DataTypes/Methods/User.cs b/csharp/App/Backend/DataTypes/Methods/User.cs index cd6b992c9..5792993e6 100644 --- a/csharp/App/Backend/DataTypes/Methods/User.cs +++ b/csharp/App/Backend/DataTypes/Methods/User.cs @@ -237,26 +237,63 @@ public static class UserMethods public static Task SendPasswordResetEmail(this User user, String token) { - const String subject = "Reset the password of your Inesco Energy Account"; const String resetLink = "https://monitor.inesco.energy/api/ResetPassword"; // TODO: move to settings file var encodedToken = HttpUtility.UrlEncode(token); - - var body = $"Dear {user.Name}\n" + - $"To reset your password " + - $"please open this link:{resetLink}?token={encodedToken}"; + + var (subject, body) = (user.Language ?? "en") switch + { + "de" => ( + "Passwort Ihres Inesco Energy Kontos zurücksetzen", + $"Sehr geehrte/r {user.Name}\n" + + $"Um Ihr Passwort zurückzusetzen, öffnen Sie bitte diesen Link: {resetLink}?token={encodedToken}" + ), + "fr" => ( + "Réinitialisation du mot de passe de votre compte Inesco Energy", + $"Cher/Chère {user.Name}\n" + + $"Pour réinitialiser votre mot de passe, veuillez ouvrir ce lien : {resetLink}?token={encodedToken}" + ), + "it" => ( + "Reimposta la password del tuo account Inesco Energy", + $"Gentile {user.Name}\n" + + $"Per reimpostare la password, apra questo link: {resetLink}?token={encodedToken}" + ), + _ => ( + "Reset the password of your Inesco Energy Account", + $"Dear {user.Name}\n" + + $"To reset your password please open this link: {resetLink}?token={encodedToken}" + ) + }; return user.SendEmail(subject, body); } public static Task SendNewUserWelcomeMessage(this User user) { - const String subject = "Your new Inesco Energy Account"; - var resetLink = $"https://monitor.inesco.energy/?username={user.Email}"; // TODO: move to settings file - - var body = $"Dear {user.Name}\n" + - $"To set your password and log in to your " + - $"Inesco Energy Account open this link:{resetLink}"; + + var (subject, body) = (user.Language ?? "en") switch + { + "de" => ( + "Ihr neues Inesco Energy Konto", + $"Sehr geehrte/r {user.Name}\n" + + $"Um Ihr Passwort festzulegen und sich bei Ihrem Inesco Energy Konto anzumelden, öffnen Sie bitte diesen Link: {resetLink}" + ), + "fr" => ( + "Votre nouveau compte Inesco Energy", + $"Cher/Chère {user.Name}\n" + + $"Pour définir votre mot de passe et vous connecter à votre compte Inesco Energy, veuillez ouvrir ce lien : {resetLink}" + ), + "it" => ( + "Il tuo nuovo account Inesco Energy", + $"Gentile {user.Name}\n" + + $"Per impostare la password e accedere al suo account Inesco Energy, apra questo link: {resetLink}" + ), + _ => ( + "Your new Inesco Energy Account", + $"Dear {user.Name}\n" + + $"To set your password and log in to your Inesco Energy Account open this link: {resetLink}" + ) + }; return user.SendEmail(subject, body); } diff --git a/csharp/App/Backend/DataTypes/User.cs b/csharp/App/Backend/DataTypes/User.cs index 4738c7f45..a5ec78224 100644 --- a/csharp/App/Backend/DataTypes/User.cs +++ b/csharp/App/Backend/DataTypes/User.cs @@ -10,6 +10,7 @@ public class User : TreeNode public int UserType { get; set; } = 0; public Boolean MustResetPassword { get; set; } = false; public String? Password { get; set; } = null!; + public String Language { get; set; } = "en"; [Unique] public override String Name { get; set; } = null!; diff --git a/csharp/App/Backend/DataTypes/WeeklyReportResponse.cs b/csharp/App/Backend/DataTypes/WeeklyReportResponse.cs new file mode 100644 index 000000000..8e2660c98 --- /dev/null +++ b/csharp/App/Backend/DataTypes/WeeklyReportResponse.cs @@ -0,0 +1,41 @@ +namespace InnovEnergy.App.Backend.DataTypes; + +public class WeeklyReportResponse +{ + public string InstallationName { get; set; } = ""; + public string PeriodStart { get; set; } = ""; // current week start + public string PeriodEnd { get; set; } = ""; // current week end + + public WeeklySummary CurrentWeek { get; set; } = new(); + public WeeklySummary? PreviousWeek { get; set; } + + // Pre-computed savings — single source of truth for UI and AI + public double TotalEnergySaved { get; set; } // kWh = Consumption - GridImport + public double TotalSavingsCHF { get; set; } // CHF = TotalEnergySaved * 0.27 + public double DaysEquivalent { get; set; } // TotalEnergySaved / avg daily consumption + + // Key ratios (current week) + public double SelfSufficiencyPercent { get; set; } + public double SelfConsumptionPercent { get; set; } + public double BatteryEfficiencyPercent { get; set; } + public double GridDependencyPercent { get; set; } + + // Week-over-week change percentages + public double PvChangePercent { get; set; } + public double ConsumptionChangePercent { get; set; } + public double GridImportChangePercent { get; set; } + + public List DailyData { get; set; } = new(); + public BehavioralPattern? Behavior { get; set; } + public string AiInsight { get; set; } = ""; +} + +public class WeeklySummary +{ + public double TotalPvProduction { get; set; } + public double TotalConsumption { get; set; } + public double TotalGridImport { get; set; } + public double TotalGridExport { get; set; } + public double TotalBatteryCharged { get; set; } + public double TotalBatteryDischarged { get; set; } +} diff --git a/csharp/App/Backend/Database/Db.cs b/csharp/App/Backend/Database/Db.cs index 7d21eee60..5f10d3091 100644 --- a/csharp/App/Backend/Database/Db.cs +++ b/csharp/App/Backend/Database/Db.cs @@ -53,6 +53,12 @@ public static partial class Db Connection.CreateTable(); }); + // One-time migration: normalize legacy long-form language values to ISO codes + Connection.Execute("UPDATE User SET Language = 'en' WHERE Language IS NULL OR Language = '' OR Language = 'english'"); + Connection.Execute("UPDATE User SET Language = 'de' WHERE Language = 'german'"); + Connection.Execute("UPDATE User SET Language = 'fr' WHERE Language = 'french'"); + Connection.Execute("UPDATE User SET Language = 'it' WHERE Language = 'italian'"); + //UpdateKeys(); CleanupSessions().SupressAwaitWarning(); DeleteSnapshots().SupressAwaitWarning(); diff --git a/csharp/App/Backend/Database/Update.cs b/csharp/App/Backend/Database/Update.cs index 88e748240..50037b701 100644 --- a/csharp/App/Backend/Database/Update.cs +++ b/csharp/App/Backend/Database/Update.cs @@ -40,10 +40,9 @@ public static partial class Db var originalUser = GetUserById(user.Id); if (originalUser is null) return false; - // these columns must not be modified! - user.ParentId = originalUser.ParentId; - user.Name = originalUser.Name; - + // ParentId must not be modified via this method + user.ParentId = originalUser.ParentId; + return Update(obj: user); } diff --git a/csharp/App/Backend/MailerConfig.json b/csharp/App/Backend/MailerConfig.json index 80840398f..430e85f31 100644 --- a/csharp/App/Backend/MailerConfig.json +++ b/csharp/App/Backend/MailerConfig.json @@ -1,8 +1,8 @@ { - "SmtpServerUrl" : "smtp.gmail.com", - "SmtpUsername" : "angelis@inesco.energy", - "SmtpPassword" : "huvu pkqd kakz hqtm ", + "SmtpServerUrl" : "mail.agenturserver.de", + "SmtpUsername" : "no-reply@inesco.ch", + "SmtpPassword" : "1ci4vi%+bfccIp", "SmtpPort" : 587, "SenderName" : "Inesco Energy", - "SenderAddress" : "noreply@inesco.energy" + "SenderAddress" : "no-reply@inesco.ch" } diff --git a/csharp/App/Backend/Program.cs b/csharp/App/Backend/Program.cs index 94f20f312..0ae6dc02e 100644 --- a/csharp/App/Backend/Program.cs +++ b/csharp/App/Backend/Program.cs @@ -2,6 +2,7 @@ using System.Diagnostics; using Flurl.Http; using Hellang.Middleware.ProblemDetails; using InnovEnergy.App.Backend.Database; +using InnovEnergy.App.Backend.Services; using InnovEnergy.App.Backend.Websockets; using InnovEnergy.App.Backend.DeleteOldData; using Microsoft.AspNetCore.HttpOverrides; @@ -24,6 +25,9 @@ public static class Program Watchdog.NotifyReady(); Db.Init(); + LoadEnvFile(); + DiagnosticService.Initialize(); + AlarmReviewService.StartDailyScheduler(); var builder = WebApplication.CreateBuilder(args); RabbitMqManager.InitializeEnvironment(); @@ -87,6 +91,33 @@ public static class Program app.Run(); } + private static void LoadEnvFile() + { + var envPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ".env"); + + if (!File.Exists(envPath)) + envPath = ".env"; // fallback for dev + + if (!File.Exists(envPath)) + return; + + foreach (var line in File.ReadAllLines(envPath)) + { + var trimmed = line.Trim(); + if (trimmed.Length == 0 || trimmed.StartsWith('#')) + continue; + + var idx = trimmed.IndexOf('='); + if (idx <= 0) + continue; + + var key = trimmed[..idx].Trim(); + var value = trimmed[(idx + 1)..].Trim(); + + Environment.SetEnvironmentVariable(key, value); + } + } + private static OpenApiInfo OpenApiInfo { get; } = new OpenApiInfo { Title = "Inesco Backend API", diff --git a/csharp/App/Backend/Resources/AlarmNames.de.json b/csharp/App/Backend/Resources/AlarmNames.de.json new file mode 100644 index 000000000..a4fbbf6af --- /dev/null +++ b/csharp/App/Backend/Resources/AlarmNames.de.json @@ -0,0 +1,231 @@ +{ + "AbnormalGridVoltage": "Unnormale Netzspannung", + "AbnormalGridFrequency": "Unnormale Netzfrequenz", + "InvertedSequenceOfGridVoltage": "Falsche Phasenreihenfolge", + "GridVoltagePhaseLoss": "Phasenausfall im Netz", + "AbnormalGridCurrent": "Unnormaler Netzstrom", + "AbnormalOutputVoltage": "Ungewöhnliche Ausgangsspannung", + "AbnormalOutputFrequency": "Ungewöhnliche Ausgangsfrequenz", + "AbnormalNullLine": "Fehlerhafter Nullleiter", + "AbnormalOffGridOutputVoltage": "Ungewöhnliche Backup-Spannung", + "ExcessivelyHighAmbientTemperature": "Zu hohe Umgebungstemperatur", + "ExcessiveRadiatorTemperature": "Überhitzter Kühlkörper", + "PcbOvertemperature": "Überhitzte Leiterplatte", + "DcConverterOvertemperature": "Überhitzter DC-Wandler", + "InverterOvertemperatureAlarm": "Warnung: Überhitzung", + "InverterOvertemperature": "Wechselrichter überhitzt", + "DcConverterOvertemperatureAlarm": "Übertemperaturalarm DC-Wandler", + "InsulationFault": "Isolationsfehler", + "LeakageProtectionFault": "Leckschutzfehler", + "AbnormalLeakageSelfCheck": "Anomaler Leckstrom-Selbsttest", + "PoorGrounding": "Schlechte Erdung", + "FanFault": "Lüfterfehler", + "AuxiliaryPowerFault": "Hilfsstromversorgung Fehler", + "ModelCapacityFault": "Modellkapazitätsfehler", + "AbnormalLightningArrester": "Überspannungsschutz Fehler", + "IslandProtection": "Inselbetrieb Schutz", + "Battery1NotConnected": "Batterie 1 nicht verbunden", + "Battery1Overvoltage": "Batterie 1 Überspannung", + "Battery1Undervoltage": "Batterie 1 Unterspannung", + "Battery1DischargeEnd": "Batterie 1 Entladung beendet", + "Battery1Inverted": "Batterie 1 Polarität vertauscht", + "Battery1OverloadTimeout": "Batterie 1 Überlastung", + "Battery1SoftStartFailure": "Batterie 1 Startfehler", + "Battery1PowerTubeFault": "Batterie 1 Leistungsteil defekt", + "Battery1InsufficientPower": "Batterie 1 Leistung unzureichend", + "Battery1BackupProhibited": "Batterie 1 Backup gesperrt", + "Battery2NotConnected": "Batterie 2 nicht verbunden", + "Battery2Overvoltage": "Batterie 2 Überspannung", + "Battery2Undervoltage": "Batterie 2 Unterspannung", + "Battery2DischargeEnd": "Batterie 2 Entladung beendet", + "Battery2Inverted": "Batterie 2 falsch angeschlossen", + "Battery2OverloadTimeout": "Batterie 2 Überlastung", + "Battery2SoftStartFailure": "Batterie 2 Startfehler", + "Battery2PowerTubeFault": "Batterie 2 Leistungsteil defekt", + "Battery2InsufficientPower": "Batterie 2 Leistung unzureichend", + "Battery2BackupProhibited": "Batterie 2 Backup gesperrt", + "LithiumBattery1ChargeForbidden": "Lithium-Batterie 1 Ladeverbot", + "LithiumBattery1DischargeForbidden": "Lithium-Batterie 1 Entladeverbot", + "LithiumBattery2ChargeForbidden": "Lithium-Batterie 2 Ladeverbot", + "LithiumBattery2DischargeForbidden": "Lithium-Batterie 2 Entladeverbot", + "LithiumBattery1Full": "Lithium-Batterie 1 voll", + "LithiumBattery1DischargeEnd": "Lithium-Batterie 1 entladen", + "LithiumBattery2Full": "Lithium-Batterie 2 voll", + "LithiumBattery2DischargeEnd": "Lithium-Batterie 2 entladen", + "LeadBatteryTemperatureAbnormality": "Batterietemperatur abnormal", + "BatteryAccessMethodError": "Batteriezugriffsfehler", + "Pv1NotAccessed": "PV1 nicht erreichbar", + "Pv1Overvoltage": "PV1 Überspannung", + "AbnormalPv1CurrentSharing": "Ungleichmäßiger PV1-Strom", + "Pv1PowerTubeFault": "PV1 Leistungstubus defekt", + "Pv1SoftStartFailure": "PV1 Soft-Start fehlgeschlagen", + "Pv1OverloadTimeout": "PV1-Überlastung", + "Pv1InsufficientPower": "PV1-Schwacher Strom", + "Photovoltaic1Overcurrent": "PV1-Überstrom", + "Pv2NotAccessed": "PV2-Nicht erkannt", + "Pv2Overvoltage": "PV2-Überspannung", + "AbnormalPv2CurrentSharing": "Ungewöhnliche Stromverteilung PV2", + "Pv2PowerTubeFault": "PV2-Leistungsrohrfehler", + "Pv2SoftStartFailure": "PV2-Softstart fehlgeschlagen", + "Pv2OverloadTimeout": "PV2-Überlastung Timeout", + "Pv2InsufficientPower": "Unzureichende Leistung PV2", + "Pv3NotConnected": "PV3 nicht verbunden", + "Pv3Overvoltage": "PV3 Überspannung", + "Pv3AverageCurrentAnomaly": "PV3 Stromanomalie", + "Pv3PowerTubeFailure": "PV3 Leistungselektronik defekt", + "Pv3SoftStartFailure": "PV3 Startfehler", + "Pv3OverloadTimeout": "PV3-Überlastung", + "Pv3ReverseConnection": "PV3-Falschpolung", + "Pv4NotConnected": "PV4 Nicht Verbunden", + "Pv4Overvoltage": "PV4 Überspannung", + "Pv4AverageCurrentAnomaly": "PV4 Stromanomalie", + "Pv4PowerTubeFailure": "PV4-Leistungsrohr defekt", + "Pv4SoftStartFailure": "PV4-Softstart fehlgeschlagen", + "Pv4OverloadTimeout": "PV4-Überlastung", + "Pv4ReverseConnection": "PV4 falsch angeschlossen", + "InsufficientPhotovoltaicPower": "Zu wenig Solarstrom", + "DcBusOvervoltage": "DC-Bus Überspannung", + "DcBusUndervoltage": "DC-Bus Unterspannung", + "DcBusVoltageUnbalance": "DC-Bus Spannungsungleichgewicht", + "BusSlowOvervoltage": "Langsame DC-Bus Überspannung", + "HardwareBusOvervoltage": "Hardware DC-Bus Überspannung", + "BusSoftStartFailure": "Fehler beim sanften Start", + "InverterPowerTubeFault": "Wechselrichter-Leistungshalbleiter defekt", + "HardwareOvercurrent": "Hardware-Überstrom", + "DcConverterOvervoltage": "DC-Wandler Überspannung", + "DcConverterHardwareOvervoltage": "DC-Wandler Hardware-Überspannung", + "DcConverterOvercurrent": "DC-Wandler Überstrom", + "DcConverterHardwareOvercurrent": "DC-Wandler Hardware-Überstrom", + "DcConverterResonatorOvercurrent": "DC-Wandler Resonanz-Überstrom", + "SystemOutputOverload": "Systemausgang überlastet", + "InverterOverload": "Wechselrichter überlastet", + "InverterOverloadTimeout": "Wechselrichter-Überlastung", + "LoadPowerOverload": "Überlastung der Lastleistung", + "BalancedCircuitOverloadTimeout": "Phasenausgleich-Überlastung", + "InverterSoftStartFailure": "Wechselrichter-Softstart-Fehler", + "Dsp1ParameterSettingFault": "DSP-Parameter-Fehler", + "Dsp2ParameterSettingFault": "DSP2 Parameterfehler", + "DspVersionCompatibilityFault": "DSP-Versionen nicht kompatibel", + "CpldVersionCompatibilityFault": "CPLD-Version nicht kompatibel", + "CpldCommunicationFault": "CPLD-Kommunikationsfehler", + "DspCommunicationFault": "DSP-Kommunikationsfehler", + "OutputVoltageDcOverlimit": "DC-Spannung zu hoch", + "OutputCurrentDcOverlimit": "DC-Strom zu hoch", + "RelaySelfCheckFails": "Relais-Selbsttest fehlgeschlagen", + "InverterRelayOpen": "Wechselrichter-Relais offen", + "InverterRelayShortCircuit": "Wechselrichter-Relais Kurzschluss", + "OpenCircuitOfPowerGridRelay": "Netzrelais offen", + "ShortCircuitOfPowerGridRelay": "Netzrelais kurzgeschlossen", + "GeneratorRelayOpenCircuit": "Generatorrelais offen", + "GeneratorRelayShortCircuit": "Generatorrelais kurzgeschlossen", + "AbnormalInverter": "Wechselrichter abnormal", + "ParallelCommunicationAlarm": "Parallelkommunikationsalarm", + "ParallelModuleMissing": "Parallelmodul fehlt", + "DuplicateMachineNumbersForParallelModules": "Doppelte Gerätenummern", + "ParameterConflictInParallelModule": "Parameterkonflikt im Parallelmodul", + "SystemDerating": "Systemleistung reduziert", + "PvAccessMethodErrorAlarm": "PV-Zugriffsfehler", + "ReservedAlarms4": "Reservierter Alarm 4", + "ReservedAlarms5": "Reservierter Alarm 5", + "ReverseMeterConnection": "Zähler falsch angeschlossen", + "InverterSealPulse": "Wechselrichter-Leistungsbegrenzung", + "AbnormalDieselGeneratorVoltage": "Ungewöhnliche Dieselgenerator-Spannung", + "AbnormalDieselGeneratorFrequency": "Ungewöhnliche Dieselgenerator-Frequenz", + "DieselGeneratorVoltageReverseSequence": "Falsche Phasenfolge des Generators", + "DieselGeneratorVoltageOutOfPhase": "Generator nicht synchronisiert", + "GeneratorOverload": "Generator überlastet", + "StringFault": "PV-String-Fehler", + "PvStringPidQuickConnectAbnormal": "PV-String-Anschluss defekt", + "DcSpdFunctionAbnormal": "DC-Überspannungsschutz defekt", + "PvShortCircuited": "PV-String kurzgeschlossen", + "PvBoostDriverAbnormal": "PV-Boost-Treiber defekt", + "AcSpdFunctionAbnormal": "AC-Überspannungsschutz defekt", + "DcFuseBlown": "DC-Sicherung durchgebrannt", + "DcInputVoltageTooHigh": "DC-Eingangsspannung zu hoch", + "PvReversed": "PV-Polarität vertauscht", + "PidFunctionAbnormal": "PID-Schutzfunktion gestört", + "PvStringDisconnected": "PV-String getrennt", + "PvStringCurrentUnbalanced": "PV-String Strom unausgeglichen", + "NoUtilityGrid": "Kein Stromnetz", + "GridVoltageOutOfRange": "Netzspannung außerhalb des Bereichs", + "GridFrequencyOutOfRange": "Netzfrequenz außerhalb des Bereichs", + "Overload": "Überlastung", + "MeterDisconnected": "Stromzähler getrennt", + "MeterReverselyConnected": "Zähler falsch angeschlossen", + "LinePeVoltageAbnormal": "Abnormale PE-Spannung", + "PhaseSequenceError": "Phasenfolgefehler", + "FanFailure": "Lüfterausfall", + "MeterAbnormal": "Störungsanzeige Zähler", + "OptimizerCommunicationAbnormal": "Kommunikationsstörung Optimierer", + "OverTemperature": "Überhitzung", + "OverTemperatureAlarm": "Überhitzungswarnung", + "NtcTemperatureSensorBroken": "Temperatursensor defekt", + "SyncSignalAbnormal": "Synchronisationsfehler", + "GridStartupConditionsNotMet": "Netzstartbedingungen nicht erfüllt", + "BatteryCommunicationFailure": "Batteriekommunikation fehlgeschlagen", + "BatteryDisconnected": "Batterie getrennt", + "BatteryVoltageTooHigh": "Batteriespannung zu hoch", + "BatteryVoltageTooLow": "Batteriespannung zu niedrig", + "BatteryReverseConnected": "Batterie falsch angeschlossen", + "LeadAcidTempSensorDisconnected": "Temperatursensor nicht angeschlossen", + "BatteryTemperatureOutOfRange": "Batterietemperatur außerhalb des Bereichs", + "BmsFault": "BMS-Fehler", + "LithiumBatteryOverload": "Batterie-Überlastung", + "BmsCommunicationAbnormal": "BMS-Kommunikationsfehler", + "BatterySpdAbnormal": "Batterie-Überspannungsschutz", + "OutputDcComponentBiasAbnormal": "DC-Versatz im Ausgang", + "DcComponentOverHighOutputVoltage": "DC-Komponente zu hohe Ausgangsspannung", + "OffGridOutputVoltageTooLow": "Netzunabhängige Ausgangsspannung zu niedrig", + "OffGridOutputVoltageTooHigh": "Netzunabhängige Ausgangsspannung zu hoch", + "OffGridOutputOverCurrent": "Netzunabhängiger Ausgangsüberstrom", + "OffGridOutputOverload": "Netzunabhängiger Ausgang überlastet", + "BalancedCircuitAbnormal": "Phasenausgleich gestört", + "ExportLimitationFailSafe": "Exportbegrenzung Notaus", + "DcBiasAbnormal": "DC-Vorspannung abnormal", + "HighDcComponentOutputCurrent": "Hohe DC-Komponente im Ausgangsstrom", + "BusVoltageSamplingAbnormal": "Spannungsmessung defekt", + "RelayFault": "Relaisfehler", + "BusVoltageAbnormal": "Gleichspannung abnormal", + "InternalCommunicationFailure": "Interne Kommunikation ausgefallen", + "TemperatureSensorDisconnected": "Temperatursensor getrennt", + "IgbtDriveFault": "IGBT-Ansteuerungsfehler", + "EepromError": "EEPROM-Fehler", + "AuxiliaryPowerAbnormal": "Hilfsstromversorgung abnormal", + "DcAcOvercurrentProtection": "Überstromschutz aktiviert", + "CommunicationProtocolMismatch": "Kommunikationsprotokoll-Fehler", + "DspComFirmwareMismatch": "Firmware-Inkompatibilität DSP/COM", + "DspSoftwareHardwareMismatch": "DSP-Software-Hardware-Inkompatibilität", + "CpldAbnormal": "CPLD-Fehler", + "RedundancySamplingInconsistent": "Inkonsistente redundante Messungen", + "PwmPassThroughSignalFailure": "PWM-Signalweg ausgefallen", + "AfciSelfTestFailure": "AFCI-Selbsttest fehlgeschlagen", + "PvCurrentSamplingAbnormal": "PV-Strommessung abnormal", + "AcCurrentSamplingAbnormal": "AC-Strommessung abnormal", + "BusSoftbootFailure": "DC-Bus-Vorstart fehlgeschlagen", + "EpoFault": "EPO-Fehler (Notaus)", + "MonitoringChipBootVerificationFailed": "Überwachungs-Chip Startfehler", + "BmsCommunicationFailure": "BMS-Kommunikationsfehler", + "BmsChargeDischargeFailure": "BMS-Lade-/Entladefehler", + "BatteryVoltageLow": "Batteriespannung zu niedrig", + "BatteryVoltageHigh": "Batteriespannung zu hoch", + "BatteryTemperatureAbnormal": "Batterietemperatur ungewöhnlich", + "BatteryReversed": "Batterie verkehrt herum", + "BatteryOpenCircuit": "Batteriekreis offen", + "BatteryOverloadProtection": "Batterieüberlastungsschutz", + "Bus2VoltageAbnormal": "Bus2-Spannung ungewöhnlich", + "BatteryChargeOcp": "Batterieladung Überstrom", + "BatteryDischargeOcp": "Batterieentladung Überstrom", + "BatterySoftStartFailed": "Batterie-Softstart fehlgeschlagen", + "EpsOutputShortCircuited": "EPS-Ausgang kurzgeschlossen", + "OffGridBusVoltageLow": "Netzunabhängige Busspannung zu niedrig", + "OffGridTerminalVoltageAbnormal": "Abnormale Spannung am Netzausgang", + "SoftStartFailed": "Sanfter Start fehlgeschlagen", + "OffGridOutputVoltageAbnormal": "Abnormale Ausgangsspannung im Netzmodus", + "BalancedCircuitSelfTestFailed": "Ausgleichsschaltungstest fehlgeschlagen", + "HighDcComponentOutputVoltage": "Hohe Gleichspannungskomponente im Ausgang", + "OffGridParallelSignalAbnormal": "Parallelsignalstörung", + "AFCIFault": "Lichtbogenfehler", + "GFCIHigh": "Erhöhter Fehlerstrom", + "PVVoltageHigh": "PV-Spannung zu hoch", + "OffGridBusVoltageTooLow": "Off-Grid-Busspannung zu niedrig" +} \ No newline at end of file diff --git a/csharp/App/Backend/Resources/AlarmNames.fr.json b/csharp/App/Backend/Resources/AlarmNames.fr.json new file mode 100644 index 000000000..f3fe253e3 --- /dev/null +++ b/csharp/App/Backend/Resources/AlarmNames.fr.json @@ -0,0 +1,231 @@ +{ + "alarm_AbnormalGridVoltage": "Tension réseau anormale", + "alarm_AbnormalGridFrequency": "Fréquence réseau anormale", + "alarm_InvertedSequenceOfGridVoltage": "Séquence de tension inversée", + "alarm_GridVoltagePhaseLoss": "Perte de phase réseau", + "alarm_AbnormalGridCurrent": "Courant réseau anormal", + "alarm_AbnormalOutputVoltage": "Tension de sortie anormale", + "alarm_AbnormalOutputFrequency": "Fréquence de sortie anormale", + "alarm_AbnormalNullLine": "Ligne neutre anormale", + "alarm_AbnormalOffGridOutputVoltage": "Tension de sortie hors réseau anormale", + "alarm_ExcessivelyHighAmbientTemperature": "Température ambiante trop élevée", + "alarm_ExcessiveRadiatorTemperature": "Température excessive du radiateur", + "alarm_PcbOvertemperature": "Température excessive PCB", + "alarm_DcConverterOvertemperature": "Température excessive convertisseur DC", + "alarm_InverterOvertemperatureAlarm": "Alarme température onduleur", + "alarm_InverterOvertemperature": "Température onduleur excessive", + "alarm_DcConverterOvertemperatureAlarm": "Alarme surchauffe convertisseur DC", + "alarm_InsulationFault": "Défaut d'isolation", + "alarm_LeakageProtectionFault": "Défaut protection fuite", + "alarm_AbnormalLeakageSelfCheck": "Auto-test fuite anormale", + "alarm_PoorGrounding": "Mise à la terre insuffisante", + "alarm_FanFault": "Défaut du ventilateur", + "alarm_AuxiliaryPowerFault": "Défaut d'alimentation auxiliaire", + "alarm_ModelCapacityFault": "Défaut de configuration", + "alarm_AbnormalLightningArrester": "Paratonnerre défectueux", + "alarm_IslandProtection": "Protection d'îlotage", + "alarm_Battery1NotConnected": "Batterie 1 non connectée", + "alarm_Battery1Overvoltage": "Tension batterie 1 trop élevée", + "alarm_Battery1Undervoltage": "Tension batterie 1 trop basse", + "alarm_Battery1DischargeEnd": "Fin de décharge batterie 1", + "alarm_Battery1Inverted": "Polarité batterie 1 inversée", + "alarm_Battery1OverloadTimeout": "Dépassement de charge Batterie 1", + "alarm_Battery1SoftStartFailure": "Échec démarrage Batterie 1", + "alarm_Battery1PowerTubeFault": "Défaut électronique Batterie 1", + "alarm_Battery1InsufficientPower": "Puissance insuffisante Batterie 1", + "alarm_Battery1BackupProhibited": "Sauvegarde interdite Batterie 1", + "alarm_Battery2NotConnected": "Batterie 2 non connectée", + "alarm_Battery2Overvoltage": "Tension batterie 2 élevée", + "alarm_Battery2Undervoltage": "Tension batterie 2 basse", + "alarm_Battery2DischargeEnd": "Fin décharge batterie 2", + "alarm_Battery2Inverted": "Polarité batterie 2 inversée", + "alarm_Battery2OverloadTimeout": "Dépassement de charge Batterie 2", + "alarm_Battery2SoftStartFailure": "Échec démarrage Batterie 2", + "alarm_Battery2PowerTubeFault": "Défaut électronique Batterie 2", + "alarm_Battery2InsufficientPower": "Puissance insuffisante Batterie 2", + "alarm_Battery2BackupProhibited": "Sauvegarde interdite Batterie 2", + "alarm_LithiumBattery1ChargeForbidden": "Charge batterie lithium 1 interdite", + "alarm_LithiumBattery1DischargeForbidden": "Décharge batterie lithium 1 interdite", + "alarm_LithiumBattery2ChargeForbidden": "Charge batterie lithium 2 interdite", + "alarm_LithiumBattery2DischargeForbidden": "Décharge batterie lithium 2 interdite", + "alarm_LithiumBattery1Full": "Batterie lithium 1 pleine", + "alarm_LithiumBattery1DischargeEnd": "Fin de décharge batterie lithium 1", + "alarm_LithiumBattery2Full": "Batterie lithium 2 pleine", + "alarm_LithiumBattery2DischargeEnd": "Fin de décharge batterie lithium 2", + "alarm_LeadBatteryTemperatureAbnormality": "Température anormale batterie plomb", + "alarm_BatteryAccessMethodError": "Erreur de méthode d'accès batterie", + "alarm_Pv1NotAccessed": "Chaîne PV1 non accessible", + "alarm_Pv1Overvoltage": "Survoltage PV1", + "alarm_AbnormalPv1CurrentSharing": "Partage de courant PV1 anormal", + "alarm_Pv1PowerTubeFault": "Défaut du tube de puissance PV1", + "alarm_Pv1SoftStartFailure": "Échec de démarrage doux PV1", + "alarm_Pv1OverloadTimeout": "Dépassement de charge PV1", + "alarm_Pv1InsufficientPower": "Puissance PV1 insuffisante", + "alarm_Photovoltaic1Overcurrent": "Surintensité PV1", + "alarm_Pv2NotAccessed": "Chaîne PV2 inaccessible", + "alarm_Pv2Overvoltage": "Survoltage PV2", + "alarm_AbnormalPv2CurrentSharing": "Partage de courant anormal PV2", + "alarm_Pv2PowerTubeFault": "Défaillance du tube de puissance PV2", + "alarm_Pv2SoftStartFailure": "Échec de démarrage progressif PV2", + "alarm_Pv2OverloadTimeout": "Dépassement de charge PV2", + "alarm_Pv2InsufficientPower": "Puissance insuffisante PV2", + "alarm_Pv3NotConnected": "PV3 non connecté", + "alarm_Pv3Overvoltage": "Survoltage PV3", + "alarm_Pv3AverageCurrentAnomaly": "Anomalie courant PV3", + "alarm_Pv3PowerTubeFailure": "Défaillance tube PV3", + "alarm_Pv3SoftStartFailure": "Échec démarrage PV3", + "alarm_Pv3OverloadTimeout": "Dépassement de charge PV3", + "alarm_Pv3ReverseConnection": "Connexion inversée PV3", + "alarm_Pv4NotConnected": "Chaîne PV4 non connectée", + "alarm_Pv4Overvoltage": "Survoltage PV4", + "alarm_Pv4AverageCurrentAnomaly": "Anomalie de courant PV4", + "alarm_Pv4PowerTubeFailure": "Défaillance du tube de puissance PV4", + "alarm_Pv4SoftStartFailure": "Échec du démarrage progressif PV4", + "alarm_Pv4OverloadTimeout": "Dépassement de charge PV4", + "alarm_Pv4ReverseConnection": "Connexion inversée PV4", + "alarm_InsufficientPhotovoltaicPower": "Puissance photovoltaïque insuffisante", + "alarm_DcBusOvervoltage": "Tension DC trop élevée", + "alarm_DcBusUndervoltage": "Tension DC trop basse", + "alarm_DcBusVoltageUnbalance": "Déséquilibre tension DC", + "alarm_BusSlowOvervoltage": "Tension DC lente excessive", + "alarm_HardwareBusOvervoltage": "Tension DC critique", + "alarm_BusSoftStartFailure": "Échec démarrage progressif", + "alarm_InverterPowerTubeFault": "Défaut tube de puissance", + "alarm_HardwareOvercurrent": "Surintensité matérielle", + "alarm_DcConverterOvervoltage": "Survoltage convertisseur DC", + "alarm_DcConverterHardwareOvervoltage": "Survoltage matériel convertisseur DC", + "alarm_DcConverterOvercurrent": "Surintensité convertisseur CC", + "alarm_DcConverterHardwareOvercurrent": "Surintensité matérielle convertisseur CC", + "alarm_DcConverterResonatorOvercurrent": "Surintensité résonateur convertisseur CC", + "alarm_SystemOutputOverload": "Surcharge de sortie système", + "alarm_InverterOverload": "Surcharge onduleur", + "alarm_InverterOverloadTimeout": "Dépassement de charge de l'onduleur", + "alarm_LoadPowerOverload": "Surcharge de puissance de charge", + "alarm_BalancedCircuitOverloadTimeout": "Dépassement de charge du circuit équilibré", + "alarm_InverterSoftStartFailure": "Échec de démarrage progressif de l'onduleur", + "alarm_Dsp1ParameterSettingFault": "Défaillance de paramétrage DSP 1", + "alarm_Dsp2ParameterSettingFault": "Paramètre DSP2 incorrect", + "alarm_DspVersionCompatibilityFault": "Incompatibilité version DSP", + "alarm_CpldVersionCompatibilityFault": "Incompatibilité version CPLD", + "alarm_CpldCommunicationFault": "Échec communication CPLD", + "alarm_DspCommunicationFault": "Échec communication DSP", + "alarm_OutputVoltageDcOverlimit": "Tension de sortie DC excessive", + "alarm_OutputCurrentDcOverlimit": "Courant de sortie DC excessif", + "alarm_RelaySelfCheckFails": "Auto-test relais échoué", + "alarm_InverterRelayOpen": "Relais de l'onduleur ouvert", + "alarm_InverterRelayShortCircuit": "Relais de l'onduleur en court-circuit", + "alarm_OpenCircuitOfPowerGridRelay": "Relais du réseau ouvert", + "alarm_ShortCircuitOfPowerGridRelay": "Court-circuit du relais réseau", + "alarm_GeneratorRelayOpenCircuit": "Relais du générateur ouvert", + "alarm_GeneratorRelayShortCircuit": "Court-circuit du relais générateur", + "alarm_AbnormalInverter": "Onduleur anormal", + "alarm_ParallelCommunicationAlarm": "Alarme de communication parallèle", + "alarm_ParallelModuleMissing": "Module parallèle manquant", + "alarm_DuplicateMachineNumbersForParallelModules": "Numéros de machine en double", + "alarm_ParameterConflictInParallelModule": "Conflit de paramètres parallèle", + "alarm_SystemDerating": "Réduction de puissance du système", + "alarm_PvAccessMethodErrorAlarm": "Erreur méthode d'accès PV", + "alarm_ReservedAlarms4": "Alarme réservée 4", + "alarm_ReservedAlarms5": "Alarme réservée 5", + "alarm_ReverseMeterConnection": "Connexion du compteur inversée", + "alarm_InverterSealPulse": "Impulsion de scellement de l'onduleur", + "alarm_AbnormalDieselGeneratorVoltage": "Tension anormale du générateur diesel", + "alarm_AbnormalDieselGeneratorFrequency": "Fréquence anormale du générateur diesel", + "alarm_DieselGeneratorVoltageReverseSequence": "Séquence de phase inversée du générateur", + "alarm_DieselGeneratorVoltageOutOfPhase": "Déphasage du générateur", + "alarm_GeneratorOverload": "Surcharge du générateur", + "alarm_StringFault": "Défaut de chaîne", + "alarm_PvStringPidQuickConnectAbnormal": "Connexion rapide anormale", + "alarm_DcSpdFunctionAbnormal": "Problème de protection DC", + "alarm_PvShortCircuited": "Court-circuit PV", + "alarm_PvBoostDriverAbnormal": "Problème de convertisseur", + "alarm_AcSpdFunctionAbnormal": "Problème de protection contre les surtensions AC", + "alarm_DcFuseBlown": "Fusible DC grillé", + "alarm_DcInputVoltageTooHigh": "Tension DC d'entrée trop élevée", + "alarm_PvReversed": "Polarité PV inversée", + "alarm_PidFunctionAbnormal": "Problème de fonction PID", + "alarm_PvStringDisconnected": "Chaîne PV déconnectée", + "alarm_PvStringCurrentUnbalanced": "Déséquilibre de courant PV", + "alarm_NoUtilityGrid": "Réseau électrique absent", + "alarm_GridVoltageOutOfRange": "Tension réseau hors plage", + "alarm_GridFrequencyOutOfRange": "Fréquence réseau hors plage", + "alarm_Overload": "Surcharge", + "alarm_MeterDisconnected": "Compteur déconnecté", + "alarm_MeterReverselyConnected": "Compteur inversé", + "alarm_LinePeVoltageAbnormal": "Tension anormale", + "alarm_PhaseSequenceError": "Séquence de phase erronée", + "alarm_FanFailure": "Défaillance du ventilateur", + "alarm_MeterAbnormal": "Compteur anormal", + "alarm_OptimizerCommunicationAbnormal": "Communication optimiseur anormale", + "alarm_OverTemperature": "Température excessive", + "alarm_OverTemperatureAlarm": "Alarme température élevée", + "alarm_NtcTemperatureSensorBroken": "Capteur de température défectueux", + "alarm_SyncSignalAbnormal": "Signal de synchronisation anormal", + "alarm_GridStartupConditionsNotMet": "Conditions de démarrage réseau non remplies", + "alarm_BatteryCommunicationFailure": "Échec de communication batterie", + "alarm_BatteryDisconnected": "Batterie déconnectée", + "alarm_BatteryVoltageTooHigh": "Tension batterie trop élevée", + "alarm_BatteryVoltageTooLow": "Tension batterie trop basse", + "alarm_BatteryReverseConnected": "Batterie branchée à l'envers", + "alarm_LeadAcidTempSensorDisconnected": "Capteur température batterie plomb désactivé", + "alarm_BatteryTemperatureOutOfRange": "Température batterie hors plage", + "alarm_BmsFault": "Défaillance BMS", + "alarm_LithiumBatteryOverload": "Surcharge batterie lithium", + "alarm_BmsCommunicationAbnormal": "Communication BMS anormale", + "alarm_BatterySpdAbnormal": "Défaillance SPD batterie", + "alarm_OutputDcComponentBiasAbnormal": "Biais DC de sortie anormal", + "alarm_DcComponentOverHighOutputVoltage": "Tension de sortie trop élevée", + "alarm_OffGridOutputVoltageTooLow": "Tension de sortie hors réseau trop basse", + "alarm_OffGridOutputVoltageTooHigh": "Tension de sortie hors réseau trop élevée", + "alarm_OffGridOutputOverCurrent": "Courant de sortie hors réseau trop élevé", + "alarm_OffGridOutputOverload": "Surcharge sortie hors réseau", + "alarm_BalancedCircuitAbnormal": "Circuit équilibré anormal", + "alarm_ExportLimitationFailSafe": "Sécurité limite d'exportation", + "alarm_DcBiasAbnormal": "Biais DC anormal", + "alarm_HighDcComponentOutputCurrent": "Composante DC élevée courant de sortie", + "alarm_BusVoltageSamplingAbnormal": "Tension d'alimentation anormale", + "alarm_RelayFault": "Défaillance du relais", + "alarm_BusVoltageAbnormal": "Tension d'alimentation anormale", + "alarm_InternalCommunicationFailure": "Échec de communication interne", + "alarm_TemperatureSensorDisconnected": "Capteur de température déconnecté", + "alarm_IgbtDriveFault": "Défaillance de l'IGBT", + "alarm_EepromError": "Erreur EEPROM", + "alarm_AuxiliaryPowerAbnormal": "Alimentation auxiliaire anormale", + "alarm_DcAcOvercurrentProtection": "Protection contre les surintensités", + "alarm_CommunicationProtocolMismatch": "Incompatibilité de protocole", + "alarm_DspComFirmwareMismatch": "Incompatibilité firmware DSP/COM", + "alarm_DspSoftwareHardwareMismatch": "Incompatibilité logiciel DSP/matériel", + "alarm_CpldAbnormal": "CPLD anormal", + "alarm_RedundancySamplingInconsistent": "Échantillonnage redondant incohérent", + "alarm_PwmPassThroughSignalFailure": "Échec signal PWM", + "alarm_AfciSelfTestFailure": "Échec auto-test AFCI", + "alarm_PvCurrentSamplingAbnormal": "Mesure PV anormale", + "alarm_AcCurrentSamplingAbnormal": "Mesure AC anormale", + "alarm_BusSoftbootFailure": "Échec démarrage DC", + "alarm_EpoFault": "Défaillance EPO", + "alarm_MonitoringChipBootVerificationFailed": "Échec vérification démarrage", + "alarm_BmsCommunicationFailure": "Échec communication BMS", + "alarm_BmsChargeDischargeFailure": "Échec charge/décharge BMS", + "alarm_BatteryVoltageLow": "Tension batterie faible", + "alarm_BatteryVoltageHigh": "Tension batterie élevée", + "alarm_BatteryTemperatureAbnormal": "Température anormale de la batterie", + "alarm_BatteryReversed": "Batterie inversée", + "alarm_BatteryOpenCircuit": "Circuit batterie ouvert", + "alarm_BatteryOverloadProtection": "Protection contre la surcharge", + "alarm_Bus2VoltageAbnormal": "Tension anormale Bus2", + "alarm_BatteryChargeOcp": "Surintensité charge batterie", + "alarm_BatteryDischargeOcp": "Surintensité décharge batterie", + "alarm_BatterySoftStartFailed": "Démarrage en douceur échoué", + "alarm_EpsOutputShortCircuited": "Circuit de secours en court-circuit", + "alarm_OffGridBusVoltageLow": "Tension bus hors réseau basse", + "alarm_OffGridTerminalVoltageAbnormal": "Tension anormale terminal hors réseau", + "alarm_SoftStartFailed": "Démarrage progressif échoué", + "alarm_OffGridOutputVoltageAbnormal": "Tension de sortie hors réseau anormale", + "alarm_BalancedCircuitSelfTestFailed": "Autotest circuit équilibré échoué", + "alarm_HighDcComponentOutputVoltage": "Tension de sortie à composante CC élevée", + "alarm_OffGridParallelSignalAbnormal": "Signal parallèle hors réseau anormal", + "alarm_AFCIFault": "Défaillance AFCI", + "alarm_GFCIHigh": "Courant de défaut élevé", + "alarm_PVVoltageHigh": "Tension PV élevée", + "alarm_OffGridBusVoltageTooLow": "Tension du bus hors réseau trop faible" +} \ No newline at end of file diff --git a/csharp/App/Backend/Resources/AlarmNames.it.json b/csharp/App/Backend/Resources/AlarmNames.it.json new file mode 100644 index 000000000..7e5681cbb --- /dev/null +++ b/csharp/App/Backend/Resources/AlarmNames.it.json @@ -0,0 +1,231 @@ +{ + "alarm_AbnormalGridVoltage": "Tensione di rete anomala", + "alarm_AbnormalGridFrequency": "Frequenza di rete anomala", + "alarm_InvertedSequenceOfGridVoltage": "Sequenza di fase invertita", + "alarm_GridVoltagePhaseLoss": "Mancanza di fase rete", + "alarm_AbnormalGridCurrent": "Corrente di rete anomala", + "alarm_AbnormalOutputVoltage": "Tensione di uscita anomala", + "alarm_AbnormalOutputFrequency": "Frequenza di uscita anomala", + "alarm_AbnormalNullLine": "Linea neutra anomala", + "alarm_AbnormalOffGridOutputVoltage": "Tensione di uscita in standby anomala", + "alarm_ExcessivelyHighAmbientTemperature": "Temperatura ambientale troppo alta", + "alarm_ExcessiveRadiatorTemperature": "Temperatura radiatore troppo alta", + "alarm_PcbOvertemperature": "Scheda elettronica troppo calda", + "alarm_DcConverterOvertemperature": "Sovratemperatura convertitore DC", + "alarm_InverterOvertemperatureAlarm": "Allarme surriscaldamento inverter", + "alarm_InverterOvertemperature": "Surriscaldamento inverter", + "alarm_DcConverterOvertemperatureAlarm": "Allarme sovratemperatura convertitore DC", + "alarm_InsulationFault": "Guasto isolamento", + "alarm_LeakageProtectionFault": "Guasto protezione dispersione", + "alarm_AbnormalLeakageSelfCheck": "Autocontrollo perdite anomalo", + "alarm_PoorGrounding": "Messa a terra insufficiente", + "alarm_FanFault": "Guasto ventilatore", + "alarm_AuxiliaryPowerFault": "Guasto Alimentazione Ausiliaria", + "alarm_ModelCapacityFault": "Guasto Configurazione Modello", + "alarm_AbnormalLightningArrester": "Parasurtense Anomalo", + "alarm_IslandProtection": "Protezione Isola", + "alarm_Battery1NotConnected": "Batteria 1 Non Connessa", + "alarm_Battery1Overvoltage": "Batteria 1 Sovratensione", + "alarm_Battery1Undervoltage": "Batteria 1 sottotensione", + "alarm_Battery1DischargeEnd": "Fine scarica batteria 1", + "alarm_Battery1Inverted": "Batteria 1 invertita", + "alarm_Battery1OverloadTimeout": "Tempo di sovraccarico batteria 1", + "alarm_Battery1SoftStartFailure": "Avvio morbido batteria 1 fallito", + "alarm_Battery1PowerTubeFault": "Guasto modulo di potenza batteria 1", + "alarm_Battery1InsufficientPower": "Batteria 1 Potenza Insufficiente", + "alarm_Battery1BackupProhibited": "Backup Batteria 1 Bloccato", + "alarm_Battery2NotConnected": "Batteria 2 Non Connessa", + "alarm_Battery2Overvoltage": "Sovratensione Batteria 2", + "alarm_Battery2Undervoltage": "Sottotensione Batteria 2", + "alarm_Battery2DischargeEnd": "Fine Scarica Batteria 2", + "alarm_Battery2Inverted": "Polarità batteria 2 invertita", + "alarm_Battery2OverloadTimeout": "Sovraccarico batteria 2", + "alarm_Battery2SoftStartFailure": "Avvio batteria 2 fallito", + "alarm_Battery2PowerTubeFault": "Guasto modulo potenza batteria 2", + "alarm_Battery2InsufficientPower": "Potenza insufficiente batteria 2", + "alarm_Battery2BackupProhibited": "Backup vietato batteria 2", + "alarm_LithiumBattery1ChargeForbidden": "Carica Batteria Litio 1 Bloccata", + "alarm_LithiumBattery1DischargeForbidden": "Scarica Batteria Litio 1 Bloccata", + "alarm_LithiumBattery2ChargeForbidden": "Carica Batteria Litio 2 Bloccata", + "alarm_LithiumBattery2DischargeForbidden": "Scarica Batteria Litio 2 Bloccata", + "alarm_LithiumBattery1Full": "Batteria Litio 1 Piena", + "alarm_LithiumBattery1DischargeEnd": "Fine Scarica Batteria Litio 1", + "alarm_LithiumBattery2Full": "Batteria Litio 2 Piena", + "alarm_LithiumBattery2DischargeEnd": "Fine Scarica Batteria 2", + "alarm_LeadBatteryTemperatureAbnormality": "Temperatura Batteria Anomala", + "alarm_BatteryAccessMethodError": "Errore Metodo Accesso Batteria", + "alarm_Pv1NotAccessed": "PV1 Non Rilevato", + "alarm_Pv1Overvoltage": "Sovratensione PV1", + "alarm_AbnormalPv1CurrentSharing": "Corrente PV1 anomala", + "alarm_Pv1PowerTubeFault": "Guasto tubo di potenza PV1", + "alarm_Pv1SoftStartFailure": "Avvio morbido PV1 fallito", + "alarm_Pv1OverloadTimeout": "Sovraccarico PV1", + "alarm_Pv1InsufficientPower": "Bassa potenza PV1", + "alarm_Photovoltaic1Overcurrent": "Sovracorrente PV1", + "alarm_Pv2NotAccessed": "PV2 non accessibile", + "alarm_Pv2Overvoltage": "Sovratensione PV2", + "alarm_AbnormalPv2CurrentSharing": "Condivisione corrente PV2 anomala", + "alarm_Pv2PowerTubeFault": "Guasto Tubo di Potenza PV2", + "alarm_Pv2SoftStartFailure": "Avvio Morbido PV2 Fallito", + "alarm_Pv2OverloadTimeout": "Sovraccarico PV2 Scaduto", + "alarm_Pv2InsufficientPower": "Potenza PV2 insufficiente", + "alarm_Pv3NotConnected": "PV3 non connesso", + "alarm_Pv3Overvoltage": "Sovratensione PV3", + "alarm_Pv3AverageCurrentAnomaly": "Anomalia Corrente Media PV3", + "alarm_Pv3PowerTubeFailure": "Guasto Tubo di Potenza PV3", + "alarm_Pv3SoftStartFailure": "Guasto Avvio Morbido PV3", + "alarm_Pv3OverloadTimeout": "Sovraccarico Pv3", + "alarm_Pv3ReverseConnection": "Collegamento Inverso Pv3", + "alarm_Pv4NotConnected": "Pv4 Non Collegato", + "alarm_Pv4Overvoltage": "Sovratensione PV4", + "alarm_Pv4AverageCurrentAnomaly": "Anomalia Corrente Media PV4", + "alarm_Pv4PowerTubeFailure": "Guasto Modulo di Potenza PV4", + "alarm_Pv4SoftStartFailure": "Avvio morbido fallito PV4", + "alarm_Pv4OverloadTimeout": "Sovraccarico prolungato PV4", + "alarm_Pv4ReverseConnection": "Connessione invertita PV4", + "alarm_InsufficientPhotovoltaicPower": "Potenza fotovoltaica insufficiente", + "alarm_DcBusOvervoltage": "Sovratensione bus DC", + "alarm_DcBusUndervoltage": "Sottotensione bus DC", + "alarm_DcBusVoltageUnbalance": "Squilibrio tensione DC", + "alarm_BusSlowOvervoltage": "Sovratensione lenta del bus", + "alarm_HardwareBusOvervoltage": "Sovratensione hardware del bus", + "alarm_BusSoftStartFailure": "Avvio morbido fallito", + "alarm_InverterPowerTubeFault": "Guasto modulo inverter", + "alarm_HardwareOvercurrent": "Sovracorrente hardware", + "alarm_DcConverterOvervoltage": "Sovratensione convertitore DC", + "alarm_DcConverterHardwareOvervoltage": "Protezione sovratensione hardware", + "alarm_DcConverterOvercurrent": "Sovracorrente convertitore DC", + "alarm_DcConverterHardwareOvercurrent": "Sovracorrente hardware convertitore DC", + "alarm_DcConverterResonatorOvercurrent": "Sovracorrente risonatore convertitore DC", + "alarm_SystemOutputOverload": "Sovraccarico uscita sistema", + "alarm_InverterOverload": "Sovraccarico Inverter", + "alarm_InverterOverloadTimeout": "Sovraccarico Inverter Prolungato", + "alarm_LoadPowerOverload": "Carico Elettrico Eccessivo", + "alarm_BalancedCircuitOverloadTimeout": "Sovraccarico circuito bilanciato", + "alarm_InverterSoftStartFailure": "Avvio inverter fallito", + "alarm_Dsp1ParameterSettingFault": "Parametri DSP1 errati", + "alarm_Dsp2ParameterSettingFault": "Errore configurazione parametri DSP 2", + "alarm_DspVersionCompatibilityFault": "Errore compatibilità versione DSP", + "alarm_CpldVersionCompatibilityFault": "Errore compatibilità versione CPLD", + "alarm_CpldCommunicationFault": "Guasto comunicazione CPLD", + "alarm_DspCommunicationFault": "Guasto comunicazione DSP", + "alarm_OutputVoltageDcOverlimit": "Tensione DC in uscita eccessiva", + "alarm_OutputCurrentDcOverlimit": "Corrente DC in uscita superata", + "alarm_RelaySelfCheckFails": "Autotest relè fallito", + "alarm_InverterRelayOpen": "Relè inverter aperto", + "alarm_InverterRelayShortCircuit": "Cortocircuito del relè dell'inverter", + "alarm_OpenCircuitOfPowerGridRelay": "Relè di rete aperto", + "alarm_ShortCircuitOfPowerGridRelay": "Cortocircuito del relè di rete", + "alarm_GeneratorRelayOpenCircuit": "Relè generatore aperto", + "alarm_GeneratorRelayShortCircuit": "Relè generatore corto circuito", + "alarm_AbnormalInverter": "Inverter anomalo", + "alarm_ParallelCommunicationAlarm": "Allarme Comunicazione Parallela", + "alarm_ParallelModuleMissing": "Modulo Parallelo Mancante", + "alarm_DuplicateMachineNumbersForParallelModules": "Numeri Duplicati Moduli Paralleli", + "alarm_ParameterConflictInParallelModule": "Conflitto parametri modulo parallelo", + "alarm_SystemDerating": "Riduzione prestazioni sistema", + "alarm_PvAccessMethodErrorAlarm": "Errore metodo accesso PV", + "alarm_ReservedAlarms4": "Allarme Riservato 4", + "alarm_ReservedAlarms5": "Allarme Riservato 5", + "alarm_ReverseMeterConnection": "Contatore Inverso", + "alarm_InverterSealPulse": "Impulso Sigillo Inverter", + "alarm_AbnormalDieselGeneratorVoltage": "Tensione Generatore Diesel Anomala", + "alarm_AbnormalDieselGeneratorFrequency": "Frequenza Generatore Diesel Anomala", + "alarm_DieselGeneratorVoltageReverseSequence": "Sequenza di fase invertita", + "alarm_DieselGeneratorVoltageOutOfPhase": "Fase del generatore errata", + "alarm_GeneratorOverload": "Sovraccarico del generatore", + "alarm_StringFault": "Guasto alla stringa", + "alarm_PvStringPidQuickConnectAbnormal": "Connessione rapida anomala", + "alarm_DcSpdFunctionAbnormal": "Protezione sovratensione DC anomala", + "alarm_PvShortCircuited": "Cortocircuito PV", + "alarm_PvBoostDriverAbnormal": "Anomalia driver di boost PV", + "alarm_AcSpdFunctionAbnormal": "Anomalia protezione da sovratensioni AC", + "alarm_DcFuseBlown": "Fusibile DC saltato", + "alarm_DcInputVoltageTooHigh": "Tensione DC troppo alta", + "alarm_PvReversed": "Polarità PV invertita", + "alarm_PidFunctionAbnormal": "Funzione PID Anomala", + "alarm_PvStringDisconnected": "Stringa PV Disconnessa", + "alarm_PvStringCurrentUnbalanced": "Corrente Stringa PV Squilibrata", + "alarm_NoUtilityGrid": "Nessuna rete elettrica", + "alarm_GridVoltageOutOfRange": "Tensione di rete fuori limite", + "alarm_GridFrequencyOutOfRange": "Frequenza di rete fuori limite", + "alarm_Overload": "Sovraccarico", + "alarm_MeterDisconnected": "Contatore scollegato", + "alarm_MeterReverselyConnected": "Contatore collegato inversamente", + "alarm_LinePeVoltageAbnormal": "Tensione PE anomala", + "alarm_PhaseSequenceError": "Errore sequenza fase", + "alarm_FanFailure": "Guasto ventola", + "alarm_MeterAbnormal": "Contatore Anomalo", + "alarm_OptimizerCommunicationAbnormal": "Comunicazione Ottimizzatore Anomala", + "alarm_OverTemperature": "Temperatura Eccessiva", + "alarm_OverTemperatureAlarm": "Allarme Temperatura Elevata", + "alarm_NtcTemperatureSensorBroken": "Sensore Temperatura NTC Guasto", + "alarm_SyncSignalAbnormal": "Segnale di Sincronizzazione Anomalo", + "alarm_GridStartupConditionsNotMet": "Condizioni di avvio rete non soddisfatte", + "alarm_BatteryCommunicationFailure": "Comunicazione batteria fallita", + "alarm_BatteryDisconnected": "Batteria scollegata", + "alarm_BatteryVoltageTooHigh": "Tensione batteria troppo alta", + "alarm_BatteryVoltageTooLow": "Tensione batteria troppo bassa", + "alarm_BatteryReverseConnected": "Batteria collegata al contrario", + "alarm_LeadAcidTempSensorDisconnected": "Sensore temperatura disconnesso", + "alarm_BatteryTemperatureOutOfRange": "Temperatura batteria anomala", + "alarm_BmsFault": "Guasto BMS", + "alarm_LithiumBatteryOverload": "Sovraccarico batteria litio", + "alarm_BmsCommunicationAbnormal": "Comunicazione BMS anomala", + "alarm_BatterySpdAbnormal": "SPD batteria anomalo", + "alarm_OutputDcComponentBiasAbnormal": "Bias DC anomalo in uscita", + "alarm_DcComponentOverHighOutputVoltage": "Tensione di uscita troppo alta", + "alarm_OffGridOutputVoltageTooLow": "Tensione di uscita troppo bassa", + "alarm_OffGridOutputVoltageTooHigh": "Tensione in uscita troppo alta", + "alarm_OffGridOutputOverCurrent": "Corrente in uscita eccessiva", + "alarm_OffGridOutputOverload": "Sovraccarico uscita off-grid", + "alarm_BalancedCircuitAbnormal": "Circuiti squilibrati anomali", + "alarm_ExportLimitationFailSafe": "Limite esportazione sicurezza", + "alarm_DcBiasAbnormal": "Bias DC anomalo", + "alarm_HighDcComponentOutputCurrent": "Corrente di uscita DC elevata", + "alarm_BusVoltageSamplingAbnormal": "Campionamento tensione bus anomalo", + "alarm_RelayFault": "Guasto Relè", + "alarm_BusVoltageAbnormal": "Tensione Bus Anomala", + "alarm_InternalCommunicationFailure": "Comunicazione Interna Interrotta", + "alarm_TemperatureSensorDisconnected": "Sensore temperatura scollegato", + "alarm_IgbtDriveFault": "Guasto al driver IGBT", + "alarm_EepromError": "Errore EEPROM", + "alarm_AuxiliaryPowerAbnormal": "Alimentazione ausiliaria anomala", + "alarm_DcAcOvercurrentProtection": "Protezione sovracorrente DC/AC", + "alarm_CommunicationProtocolMismatch": "Incompatibilità protocollo comunicazione", + "alarm_DspComFirmwareMismatch": "Incompatibilità firmware DSP/COM", + "alarm_DspSoftwareHardwareMismatch": "Incompatibilità software/hardware DSP", + "alarm_CpldAbnormal": "Anomalia CPLD", + "alarm_RedundancySamplingInconsistent": "Campioni ridondanti incoerenti", + "alarm_PwmPassThroughSignalFailure": "Segnale PWM guasto", + "alarm_AfciSelfTestFailure": "Autotest AFCI fallito", + "alarm_PvCurrentSamplingAbnormal": "Corrente PV Anomala", + "alarm_AcCurrentSamplingAbnormal": "Corrente AC Anomala", + "alarm_BusSoftbootFailure": "Avvio Bus DC Fallito", + "alarm_EpoFault": "Guasto EPO", + "alarm_MonitoringChipBootVerificationFailed": "Verifica avvio chip monitoraggio fallita", + "alarm_BmsCommunicationFailure": "Comunicazione BMS fallita", + "alarm_BmsChargeDischargeFailure": "Guasto Carica/Scarica BMS", + "alarm_BatteryVoltageLow": "Tensione Batteria Bassa", + "alarm_BatteryVoltageHigh": "Tensione Batteria Alta", + "alarm_BatteryTemperatureAbnormal": "Temperatura batteria anomala", + "alarm_BatteryReversed": "Batteria invertita", + "alarm_BatteryOpenCircuit": "Circuiti aperti batteria", + "alarm_BatteryOverloadProtection": "Protezione sovraccarico batteria", + "alarm_Bus2VoltageAbnormal": "Tensione bus2 anomala", + "alarm_BatteryChargeOcp": "Protezione sovraccarico carica", + "alarm_BatteryDischargeOcp": "Protezione sovraccarico scarica", + "alarm_BatterySoftStartFailed": "Avvio batteria fallito", + "alarm_EpsOutputShortCircuited": "Cortocircuito uscita EPS", + "alarm_OffGridBusVoltageLow": "Tensione Bus Fuori Rete Bassa", + "alarm_OffGridTerminalVoltageAbnormal": "Tensione Terminale Fuori Rete Anomala", + "alarm_SoftStartFailed": "Avvio Morbido Fallito", + "alarm_OffGridOutputVoltageAbnormal": "Tensione uscita off-grid anomala", + "alarm_BalancedCircuitSelfTestFailed": "Autotest circuito bilanciato fallito", + "alarm_HighDcComponentOutputVoltage": "Tensione uscita con componente DC elevato", + "alarm_OffGridParallelSignalAbnormal": "Segnale parallelo anomalo", + "alarm_AFCIFault": "Guasto AFCI", + "alarm_GFCIHigh": "Corrente di guasto elevata", + "alarm_PVVoltageHigh": "Tensione PV Elevata", + "alarm_OffGridBusVoltageTooLow": "Tensione bus off-grid troppo bassa" +} \ No newline at end of file diff --git a/csharp/App/Backend/Resources/AlarmTranslations.de.json b/csharp/App/Backend/Resources/AlarmTranslations.de.json new file mode 100644 index 000000000..9ad150841 --- /dev/null +++ b/csharp/App/Backend/Resources/AlarmTranslations.de.json @@ -0,0 +1,2822 @@ +{ + "AbnormalGridVoltage": { + "Explanation": "Der Wechselrichter hat festgestellt, dass die Netzspannung außerhalb des zulässigen Bereichs liegt. Das System benötigt manuellen Eingriff zur Wiederherstellung.", + "Causes": [ + "Spannungsschwankungen oder Instabilität im Stromnetz", + "Schlechte oder lockere Netzverbindung an den Wechselrichteranschlüssen", + "Probleme mit dem lokalen Transformator", + "Hohe Lastanforderung im lokalen Netz" + ], + "NextSteps": [ + "Überprüfen Sie die Netzspannung mit einem Multimeter an den Wechselrichteranschlüssen", + "Stellen Sie sicher, dass alle Netzverbindungen fest und unbeschädigt sind", + "Kontaktieren Sie Ihren Stromanbieter, wenn die Netzspannung weiterhin abnormal ist", + "Starten Sie den Wechselrichter neu, nachdem das Problem behoben wurde" + ] + }, + "AbnormalGridFrequency": { + "Explanation": "Der Wechselrichter hat festgestellt, dass die Netzfrequenz außerhalb des zulässigen Bereichs (typischerweise 50 Hz oder 60 Hz ± Toleranz) liegt. Das System wird nicht betrieben, bis die Frequenz wieder normal ist.", + "Causes": [ + "Netzinstabilität oder Störung durch den Stromanbieter", + "Frequenzdrift des Generators, wenn dieser betrieben wird", + "Schnelle Laständerungen im lokalen Netz" + ], + "NextSteps": [ + "Überprüfen Sie, ob die Netzfrequenz stabil ist", + "Wenn mit einem Generator betrieben wird, stellen Sie sicher, dass die Generatorfrequenz mit der Wechselrichterspezifikation übereinstimmt", + "Warten Sie, bis sich das Netz stabilisiert hat, und starten Sie dann den Wechselrichter neu" + ] + }, + "InvertedSequenceOfGridVoltage": { + "Explanation": "Die Phasenreihenfolge der dreiphasigen Netzspannung ist vertauscht. Dies ist ein Verdrahtungsproblem, das einen sicheren Betrieb verhindert.", + "Causes": [ + "Falsche Verdrahtung der Netzphasen während der Installation (L1, L2, L3 vertauscht)", + "Nachträgliche Verdrahtungsarbeiten ohne Überprüfung der Phasenfolge" + ], + "NextSteps": [ + "Schalten Sie das gesamte System sicher aus, bevor Sie die Verdrahtung berühren", + "Vertauschen Sie zwei der drei Phasenleitungen an der Netzverbindung, um die Reihenfolge zu korrigieren", + "Schalten Sie das System wieder ein und überprüfen Sie, ob die Warnung behoben ist" + ] + }, + "GridVoltagePhaseLoss": { + "Explanation": "Eine oder mehrere Phasen der dreiphasigen Netzverbindung fehlen. Der Wechselrichter kann nicht sicher mit einer unvollständigen dreiphasigen Versorgung betrieben werden.", + "Causes": [ + "Durchgebrannte Sicherung in einer der Netzphasen", + "Lockere oder getrennte Phasenleitung an den Wechselrichteranschlüssen oder dem Verteilerkasten", + "Ausgelöster Phasen-Leistungsschalter im Netz", + "Kabelbeschädigung, die eine Phase unterbricht" + ], + "NextSteps": [ + "Überprüfen Sie alle drei Phasenverbindungen an den Wechselrichtereingangsanschlüssen", + "Überprüfen Sie Sicherungen und Leistungsschalter für jede Phase", + "Untersuchen Sie die Kabel auf sichtbare Schäden oder lockere Verbindungen", + "Stellen Sie die fehlende Phase wieder her und starten Sie nach der Reparatur neu" + ] + }, + "AbnormalGridCurrent": { + "Explanation": "Der Netzstrom ist abnormal, was auf Überstrom oder Stromungleichgewicht zwischen den Phasen hindeuten kann.", + "Causes": [ + "Kurzschluss oder Verdrahtungsfehler auf der Netzseite", + "Systemlast übersteigt die Kapazität", + "Defekter Stromsensor, der falsche Werte liefert", + "Erdschluss, der Stromlecks verursacht" + ], + "NextSteps": [ + "Überprüfen Sie auf Kurzschlüsse in der Verdrahtung und auf der Lastseite", + "Reduzieren Sie die Systemlast und prüfen Sie, ob die Warnung verschwindet", + "Überprüfen Sie die Verbindungen und den Betrieb des Stromsensors", + "Beheben Sie den zugrunde liegenden Fehler und starten Sie dann den Wechselrichter neu" + ] + }, + "AbnormalOutputVoltage": { + "Explanation": "Die Ausgangsspannung des Wechselrichters liegt außerhalb der zulässigen Grenzen. Dies kann angeschlossene Verbraucher beeinträchtigen und deutet auf einen Fehler hin.", + "Causes": [ + "Interne Steuerungsfehler des Wechselrichters", + "Überlastung am Ausgang", + "Einfluss des Netzspannung auf die Ausgangsregelung" + ], + "NextSteps": [ + "Überprüfen Sie alle angeschlossenen Verbraucher und trennen Sie ggf. überlastende Geräte", + "Stellen Sie sicher, dass die Ausgangsspannungseinstellungen des Wechselrichters Ihren Installationsanforderungen entsprechen", + "Schalten Sie den Wechselrichter aus und wieder ein; bei anhaltendem Alarm einen Techniker kontaktieren" + ] + }, + "AbnormalOutputFrequency": { + "Explanation": "Die Ausgangsfrequenz des Wechselrichters ist ungewöhnlich, was empfindliche Geräte beeinträchtigen kann.", + "Causes": [ + "Interne Steuerungsfehler, die die Frequenzregelung beeinflussen", + "Starke oder plötzliche Lastschwankungen, die die Frequenz verändern" + ], + "NextSteps": [ + "Reduzieren Sie die angeschlossene Last und prüfen Sie, ob sich die Frequenz stabilisiert", + "Schalten Sie den Wechselrichter aus und wieder ein; bei anhaltendem Problem einen Techniker kontaktieren" + ] + }, + "AbnormalNullLine": { + "Explanation": "Die Verbindung des Nullleiters (Neutralleiter) ist ungewöhnlich. Ein fehlender oder beschädigter Nullleiter kann zu Spannungsungleichgewicht und gefährlichen Zuständen führen.", + "Causes": [ + "Lockere oder getrennte Neutralleiterverbindung am Wechselrichter oder Verteiler", + "Beschädigter oder unterbrochener Neutralleiter", + "Falsche Verdrahtung während der Installation" + ], + "NextSteps": [ + "Schalten Sie das System sicher aus, bevor Sie die Verdrahtung überprüfen", + "Überprüfen Sie alle Neutralleiterverbindungen am Wechselrichter und Verteiler", + "Beheben Sie alle festgestellten Verdrahtungsprobleme und starten Sie das System erst nach Bestätigung der korrekten Verbindungen" + ] + }, + "AbnormalOffGridOutputVoltage": { + "Explanation": "Die Backup-Ausgangsspannung (Off-Grid) ist ungewöhnlich. An den Backup-Ausgang angeschlossene Verbraucher erhalten möglicherweise keine korrekte Spannung.", + "Causes": [ + "Überlastung am Backup-Ausgang, die die Wechselrichterkapazität überschreitet", + "Interne Hardwareprobleme des Wechselrichters", + "Zu niedrige Batteriespannung, um eine stabile Ausgangsspannung aufrechtzuerhalten" + ], + "NextSteps": [ + "Trennen oder reduzieren Sie die Last am Backup-Ausgang", + "Überprüfen Sie den Ladezustand der Batterie und laden Sie sie ggf. auf", + "Schalten Sie den Wechselrichter aus und wieder ein; bei anhaltendem Problem einen Techniker kontaktieren" + ] + }, + "ExcessivelyHighAmbientTemperature": { + "Explanation": "Die Umgebungstemperatur um den Wechselrichter ist zu hoch. Der Wechselrichter kann die Ausgangsleistung reduzieren, um sich vor Hitzeschäden zu schützen.", + "Causes": [ + "Schlechte Belüftung um den Wechselrichter", + "Hohe Umgebungstemperatur (Hitzeperiode, Sommerhitze)", + "Direkte Sonneneinstrahlung, die das Wechselrichtergehäuse erhitzt", + "Andere Geräte in der Nähe, die übermäßige Wärme erzeugen" + ], + "NextSteps": [ + "Verbessern Sie die Luftzirkulation und Belüftung um den Wechselrichter", + "Schaffen Sie Schatten, wenn der Wechselrichter im Freien oder in direkter Sonneneinstrahlung installiert ist", + "Überlegen Sie, eine Zwangslüftung (Ventilator) hinzuzufügen, wenn der Wechselrichter in einem geschlossenen Raum steht", + "Der Wechselrichter erholt sich automatisch, sobald die Temperatur auf ein sicheres Niveau sinkt" + ] + }, + "ExcessiveRadiatorTemperature": { + "Explanation": "Die Temperatur des Kühlkörpers (Radiator) des Wechselrichters ist zu hoch. Der Kühlkörper dient dazu, Wärme während des Betriebs abzuführen.", + "Causes": [ + "Verstopfte oder blockierte Lüftungsschlitze verhindern die Wärmeabfuhr", + "Ausfall des Kühlgebläses reduziert die Luftzirkulation", + "Hohe Umgebungstemperatur", + "Überlastung erzeugt mehr Wärme" + ], + "NextSteps": [ + "Reinigen Sie die Lüftungsschlitze und Staubfilter – Staubansammlungen sind eine häufige Ursache", + "Überprüfen Sie, ob das Kühlgebläse läuft (Hören Sie auf Gebläsegeräusche während des Betriebs)", + "Reduzieren Sie die Last vorübergehend, um die Wärmeentwicklung zu verringern", + "Reparieren oder ersetzen Sie das Gebläse, falls es defekt ist, und starten Sie den Wechselrichter neu" + ] + }, + "PcbOvertemperature": { + "Explanation": "Die Leiterplatte (PCB) im Wechselrichter hat eine zu hohe Temperatur erreicht.", + "Causes": [ + "Unzureichende Kühlung oder schlechte Belüftung im Gehäuse", + "Hohe Umgebungstemperatur beeinflusst die internen Komponenten", + "Übermäßige Leistungsabgabe über einen längeren Zeitraum" + ], + "NextSteps": [ + "Verbessern Sie die Belüftung um den Wechselrichter herum", + "Überprüfen Sie, ob das Kühlgebläse ordnungsgemäß funktioniert", + "Lassen Sie den Wechselrichter abkühlen, bevor Sie ihn neu starten" + ] + }, + "DcConverterOvertemperature": { + "Explanation": "Der DC-Wandlerbereich des Wechselrichters überhitzt.", + "Causes": [ + "Hoher Lade- oder Entladestrom über einen längeren Zeitraum", + "Schlechte Kühlung oder verstopfte Lüftungsschlitze", + "Hohe Umgebungstemperatur im Installationsbereich" + ], + "NextSteps": [ + "Reduzieren Sie vorübergehend den Stromfluss durch das System", + "Verbessern Sie die Belüftung und überprüfen Sie die Funktion des Gebläses", + "Lassen Sie die Kühlung zu, dann starten Sie den Wechselrichter neu" + ] + }, + "InverterOvertemperatureAlarm": { + "Explanation": "Die Temperatur des Wechselrichters steigt auf gefährliche Werte. Dies ist eine Vorwarnung vor dem thermischen Abschalten.", + "Causes": [ + "Überlastung der Ausgangsleistung über einen längeren Zeitraum", + "Schlechte Belüftung hält die Wärme um den Wechselrichter", + "Ausfall des Kühlgebläses", + "Hohe Umgebungstemperatur im Installationsbereich" + ], + "NextSteps": [ + "Reduzieren Sie die angeschlossene Last sofort", + "Überprüfen Sie, ob die Kühlgebläse laufen und die Lüftungsschlitze frei sind", + "Der Wechselrichter erholt sich, sobald er abgekühlt ist; beheben Sie die Ursache, bevor Sie ihn vollständig neu starten" + ] + }, + "InverterOvertemperature": { + "Explanation": "Der Wechselrichter hat sich überhitzt und der Schutzschalter wurde aktiviert.", + "Causes": [ + "Anhaltender Überlastungszustand erzeugt übermäßige Wärme", + "Ausfall des Kühlsystems (verstopfte Lüftungsschlitze, defektes Gebläse)", + "Extreme Umgebungstemperaturen" + ], + "NextSteps": [ + "Lassen Sie den Wechselrichter vollständig abkühlen, bevor Sie einen Neustart versuchen", + "Überprüfen Sie die Gebläse und stellen Sie sicher, dass alle Lüftungsöffnungen frei sind", + "Reduzieren Sie die Systemlast und verbessern Sie die Kühlung, bevor Sie den Wechselrichter neu starten" + ] + }, + "DcConverterOvertemperatureAlarm": { + "Explanation": "Der DC-Wandler-Temperaturalarm ist aktiv – die Temperatur nähert sich der Abschaltschwelle.", + "Causes": [ + "Hohe Leistungsdurchsatz über längere Zeit", + "Unzureichende Kühlung oder verstopfte Lüftungsschlitze" + ], + "NextSteps": [ + "Leistungsfluss vorübergehend reduzieren, um Abkühlung zu ermöglichen", + "Funktionsfähigkeit des Lüfters prüfen und mögliche Lüftungsblockaden beseitigen", + "Temperatur absinken lassen, dann den Wechselrichter neu starten" + ] + }, + "InsulationFault": { + "Explanation": "Ein Isolationsfehler wurde erkannt, was auf einen möglichen Stromabfluss zur Erde hinweist. Dies ist ein sicherheitskritischer Zustand, der vor der Wiederaufnahme des Betriebs untersucht werden muss.", + "Causes": [ + "Beschädigte Kabelisolierung an PV-, Batterie- oder Netzleitungen", + "Feuchtigkeit oder Wassereintritt in Kabelanschlüsse oder Gehäuse", + "Isolationsversagen einer Komponente im Wechselrichter", + "Erdschluss im PV-Array – häufig nach Sturmschäden" + ], + "NextSteps": [ + "System nicht berühren – Isolationsfehler können Stromschläge verursachen", + "System sicher von allen Trennstellen ausschalten", + "Alle Kabel auf sichtbare Isolationsschäden prüfen, besonders in witterungsbelasteten Bereichen", + "Isolationswiderstandstest an PV-Strängen und Verkabelung durchführen", + "Beschädigte Isolierung reparieren, bevor das System wieder gestartet wird" + ] + }, + "LeakageProtectionFault": { + "Explanation": "Der Erdschluss- oder Leckstromschutz hat ausgelöst. Der Leckstrom zur Erde hat den sicheren Schwellenwert überschritten.", + "Causes": [ + "Erdschluss irgendwo in der Systemverkabelung", + "Beschädigte Kabelisolierung, die Strom zur Erde abfließen lässt", + "Feuchtigkeit in Kabelsteckern oder Klemmkästen", + "Defekter FI-Schalter oder FI-LS-Schutzschalter" + ], + "NextSteps": [ + "System vor der Inspektion ausschalten", + "Auf Erdschlüsse prüfen, indem alle Kabelanschlüsse und Isolierungen inspiziert werden", + "Nach Feuchtigkeit in Steckern, Klemmkästen und Kabelverschraubungen suchen", + "Fehler beheben, dann das System neu starten" + ] + }, + "AbnormalLeakageSelfCheck": { + "Explanation": "Der Leckstrom-Selbsttest des Wechselrichters ist beim Starten fehlgeschlagen.", + "Causes": [ + "Fehler im Selbsttestkreis innerhalb des Wechselrichters", + "Ein tatsächlicher Erdschluss im System", + "Fehlfunktion des Leckstromsensors" + ], + "NextSteps": [ + "Sicher ausschalten und die Erdungsverbindungen des Systems prüfen", + "Verkabelung auf Isolationsschäden inspizieren, die Leckströme verursachen könnten", + "Falls die Verkabelung in Ordnung ist, könnte der interne Sensor des Wechselrichters defekt sein – Service kontaktieren" + ] + }, + "PoorGrounding": { + "Explanation": "Eine schlechte oder unzureichende Erdungsverbindung wurde erkannt. Eine ordnungsgemäße Erdung ist für Sicherheit und Blitzschutz essenziell.", + "Causes": [ + "Lockere Erdverbindung am Wechselrichter", + "Korrodierter oder oxidierter Erdanschluss", + "Zu hoher Widerstand des Erdungskabels aufgrund von Bodenbedingungen oder zu dünnem Kabel", + "Fehlende oder getrennte Erdleitung" + ], + "NextSteps": [ + "Sicher ausschalten und alle Erdverbindungen am Wechselrichter prüfen", + "Korrodierte Anschlüsse reinigen und alle Erdverbindungen festziehen", + "Erdungswiderstand messen und mit der Installationsvorgabe vergleichen", + "Erdung reparieren, dann den Wechselrichter neu starten" + ] + }, + "FanFault": { + "Explanation": "Der Kühlventilator funktioniert nicht richtig oder ist ausgefallen. Ohne ausreichende Kühlung wird der Wechselrichter überhitzen und sich abschalten.", + "Causes": [ + "Der Lüftermotor ist defekt und dreht sich nicht mehr", + "Die Lüfterblätter sind durch Schmutz oder Fremdkörper blockiert", + "Der Lüfterstromanschluss ist locker oder nicht verbunden", + "Ein Fehler in der Lüftersteuerung" + ], + "NextSteps": [ + "Prüfen Sie den Lüfter und ob er sich dreht, wenn der Wechselrichter läuft", + "Entfernen Sie Hindernisse von den Lüfterblättern", + "Stellen Sie sicher, dass der Lüfterstromanschluss fest verbunden ist", + "Ersetzen Sie den Lüfter, wenn er nicht funktioniert — betreiben Sie den Wechselrichter nicht ohne Kühlung" + ] + }, + "AuxiliaryPowerFault": { + "Explanation": "Die interne Hilfsstromversorgung im Wechselrichter ist ausgefallen. Diese Versorgung versorgt die Steuerungselektronik.", + "Causes": [ + "Ausfall eines Bauteils der internen Stromversorgung", + "Problem mit der Eingangsspannung, das die Hilfsversorgung beeinflusst", + "Ausfall eines elektronischen Bauteils auf der Steuerplatine" + ], + "NextSteps": [ + "Schalten Sie den Wechselrichter aus, warten Sie 30 Sekunden und schalten Sie ihn wieder ein", + "Falls der Alarm nach dem Neustart weiterhin besteht, muss die Hilfsversorgung wahrscheinlich ersetzt werden — kontaktieren Sie einen Servicetechniker" + ] + }, + "ModelCapacityFault": { + "Explanation": "Der Wechselrichter hat eine Diskrepanz zwischen Modell oder Kapazitätseinstellungen und der Hardware erkannt.", + "Causes": [ + "Falsche Modelleinstellungen während der Inbetriebnahme", + "Firmware-Version ist nicht mit der Hardware kompatibel", + "Hardwarekomponenten wurden ausgetauscht, ohne die Einstellungen zu aktualisieren" + ], + "NextSteps": [ + "Überprüfen Sie die Modelleinstellungen des Wechselrichters im Konfigurationsmenü", + "Stellen Sie sicher, dass die Firmware-Version mit dieser Hardware-Revision kompatibel ist", + "Kontaktieren Sie Ihren Installateur oder das Serviceteam, um die Einstellungen zu korrigieren, und starten Sie dann neu" + ] + }, + "AbnormalLightningArrester": { + "Explanation": "Die Überspannungsschutzvorrichtung (SPD / Blitzableiter) ist entweder ausgefallen oder wurde durch einen Spannungsstoß aktiviert.", + "Causes": [ + "Ein Blitzschlag oder Spannungsstoß hat den SPD ausgelöst und möglicherweise zerstört", + "Das SPD-Bauteil ist am Ende seiner Lebensdauer und ausgefallen", + "Kabelbaumfehler des SPD" + ], + "NextSteps": [ + "Prüfen Sie den Statusanzeiger des SPD (die meisten SPDs haben eine optische Fehleranzeige)", + "Ersetzen Sie die SPD-Patrone, wenn sie ausgelöst wurde oder einen Fehler anzeigt", + "Starten Sie den Wechselrichter nach dem Austausch neu" + ] + }, + "IslandProtection": { + "Explanation": "Der Inselbetriebsschutz ist aktiv — der Wechselrichter hat sich vom Netz getrennt, um ein Rückspeisen von Strom ins tote Netz zu verhindern. Dies ist eine Sicherheitsfunktion.", + "Causes": [ + "Stromausfall im Versorgungsnetz in Ihrer Gegend", + "Netzspannung oder -frequenz außerhalb der zulässigen Grenzen", + "Absichtliche Netztrennung durch den Versorger" + ], + "NextSteps": [ + "Warten Sie, bis das Versorgungsnetz wiederhergestellt und stabilisiert ist", + "Der Wechselrichter wird sich automatisch wieder verbinden und den normalen Betrieb wieder aufnehmen, sobald das Netz gesund ist", + "Keine Maßnahmen erforderlich, es sei denn, der Ausfall dauert an" + ] + }, + "Battery1NotConnected": { + "Explanation": "Batterie 1 wird nicht erkannt oder ist nicht angeschlossen. Der Wechselrichter kann die Batterie am Gleichstrombus nicht finden.", + "Causes": [ + "Batterietrennschalter ist ausgeschaltet (ausgestellt)", + "Lockere oder gelöste Batteriekabel am Wechselrichter oder Batterieanschluss", + "Batterie-BMS hat die Batterie aufgrund eines Schutzereignisses abgeschaltet", + "Batteriesicherung ist durchgebrannt" + ], + "NextSteps": [ + "Prüfen Sie den Batterietrennschalter und stellen Sie sicher, dass er auf EIN steht", + "Überprüfen Sie die Batteriekabelverbindungen sowohl am Wechselrichter als auch an den Batterieanschlüssen", + "Prüfen Sie den Statusanzeiger des Batterie-BMS auf Fehlercodes", + "Überprüfen und ersetzen Sie die Sicherung, falls sie durchgebrannt ist, und starten Sie dann den Wechselrichter neu" + ] + }, + "Battery1Overvoltage": { + "Explanation": "Die Spannung von Batterie 1 ist zu hoch. Das Laden wurde begrenzt oder gestoppt, um die Batterie zu schützen.", + "Causes": [ + "Batterie wird über ihr maximales Spannungsniveau hinaus geladen", + "BMS-Fehler, der zu einer zu hohen Spannung führt", + "Falsche Batteriespannungs- oder Kapazitätseinstellungen im Wechselrichter", + "Zellungleichgewicht, wodurch einige Zellen überladen werden" + ], + "NextSteps": [ + "Prüfen Sie den Ladezustand und die aktuelle Spannung der Batterie", + "Überprüfen Sie die Batterieladespannungseinstellungen in der Wechselrichterkonfiguration", + "Prüfen Sie den Betrieb des BMS und etwaige BMS-Fehleranzeigen", + "Beheben Sie die zugrunde liegende Ursache und starten Sie dann den Wechselrichter neu" + ] + }, + "Battery1Undervoltage": { + "Explanation": "Die Spannung von Batterie 1 ist zu niedrig. Das Entladen wurde begrenzt oder gestoppt, um die Batterie vor Tiefentladung zu schützen.", + "Causes": [ + "Batterie wurde zu tief entladen", + "Ausfall einer einzelnen Batteriezelle, wodurch die Gesamtkapazität reduziert wird", + "BMS-Ausschaltung aufgrund von Tiefentladungsschutz", + "Hohe Last entlädt die Batterie schneller, als sie geladen wird" + ], + "NextSteps": [ + "Lassen Sie die Batterie von PV oder Netz aufladen", + "Prüfen Sie auf ungewöhnlich hohe Lasten, die übermäßigen Strom verbrauchen", + "Überprüfen Sie die Batteriegesundheit – ältere Batterien halten möglicherweise keine Ladung mehr", + "Beheben Sie die zugrunde liegende Ursache und starten Sie dann den Wechselrichter neu" + ] + }, + "Battery1DischargeEnd": { + "Explanation": "Batterie 1 hat ihren minimalen Ladezustand (Entladungsendpunkt) erreicht. Das System wird das Entladen stoppen, um die Batterie zu schützen.", + "Causes": [ + "Batterie wurde bis zum konfigurierten SOC-Grenzwert vollständig entladen", + "Hoher Stromverbrauch, der die verfügbare Solar- oder Netzladung übersteigt" + ], + "NextSteps": [ + "Warten Sie, bis die Batterie von PV oder Netzstrom geladen wird", + "Überlegen Sie, den Stromverbrauch nachts zu reduzieren, um die Batteriekapazität zu erhalten", + "Dieser Alarm wird automatisch gelöscht, sobald ausreichend Ladung wiederhergestellt ist" + ] + }, + "Battery1Inverted": { + "Explanation": "Die Polarität von Batterie 1 ist vertauscht. Der Betrieb mit vertauschter Polarität kann schwere Schäden am Wechselrichter und der Batterie verursachen.", + "Causes": [ + "Batteriekabel wurden während der Installation mit vertauschten Polen angeschlossen", + "Installationsfehler – positives Kabel am negativen Anschluss oder umgekehrt" + ], + "NextSteps": [ + "SCHALTEN SIE SOFORT das gesamte System ab – versuchen Sie nicht, zu laden oder zu entladen", + "Trennen Sie die Batteriekabel vorsichtig, nachdem die Stromversorgung abgeschaltet wurde", + "Schließen Sie sie mit der richtigen Polarität an: positives Kabel an den positiven (+) Anschluss, negatives Kabel an den negativen (−) Anschluss", + "Überprüfen Sie auf Schäden an Kabeln, Sicherungen oder dem Wechselrichter, bevor Sie das System wieder starten" + ] + }, + "Battery1OverloadTimeout": { + "Explanation": "Batterie 1 hat zu lange unter Überlastbedingungen gearbeitet und die Schutzfunktion ausgelöst.", + "Causes": [ + "Dauerhafte hohe Last, die die Entladerating der Batterie überschreitet", + "Batterie ist für die angeschlossene Last zu klein dimensioniert", + "Batteriealterung reduziert die verfügbare Leistung" + ], + "NextSteps": [ + "Die Gesamtlast des Systems reduzieren", + "Überprüfen, ob die Batterie für die Spitzenlastanforderungen richtig dimensioniert ist", + "Den Grund reparieren und dann den Wechselrichter neu starten" + ] + }, + "Battery1SoftStartFailure": { + "Explanation": "Batterie 1 konnte die sanfte Startsequenz (Vorschaltphase) beim Hochfahren nicht abschließen.", + "Causes": [ + "Fehler im Vorschaltkreis, der den kontrollierten Start verhindert", + "Signifikanter Spannungsunterschied zwischen Batterie und Gleichstrombus", + "Problem mit dem Schütz oder Relais im Batterieanschlusspfad" + ], + "NextSteps": [ + "Batteriespannung prüfen und mit der Gleichstrombus-Spannung vergleichen", + "Überprüfen, ob der Vorschaltkreis und die Schütze korrekt funktionieren", + "Den Fehler beheben und dann den Wechselrichter neu starten" + ] + }, + "Battery1PowerTubeFault": { + "Explanation": "Die Leistungselektronik von Batterie 1 (IGBT- oder MOSFET-Transistoren) ist ausgefallen. Dies ist ein Hardwarefehler, der professionellen Service erfordert.", + "Causes": [ + "Leistungshalbleiter (IGBT/MOSFET) ist durch Überlastung ausgefallen", + "Schaden durch Überstrom oder Kurzschluss", + "Herstellungsfehler, der sich im Laufe der Zeit entwickelt hat" + ], + "NextSteps": [ + "Versuchen Sie nicht, das System neu zu starten", + "Kontaktieren Sie einen qualifizierten Servicetechniker – dies erfordert eine interne Hardware-Reparatur oder -Ersetzung", + "Betreiben Sie das System nicht, bis der Fehler professionell repariert wurde" + ] + }, + "Battery1InsufficientPower": { + "Explanation": "Batterie 1 kann die aktuelle Lastanforderung nicht decken.", + "Causes": [ + "Batterieladestand ist zu niedrig", + "Lastanforderung übersteigt vorübergehend die maximale Entladeleistung der Batterie", + "Batteriekapazität hat sich durch Alterung verringert" + ], + "NextSteps": [ + "Warten Sie, bis die Batterie von PV oder Netz aufgeladen wird", + "Last reduzieren, falls möglich, bei niedrigem Batterieladestand", + "Dieser Alarm sollte sich automatisch lösen, sobald die Batterie ausreichend geladen ist" + ] + }, + "Battery1BackupProhibited": { + "Explanation": "Batterie 1 darf aktuell keinen Backup-Strom liefern, meist aufgrund eines BMS-Schutzzustands.", + "Causes": [ + "Batterie-BMS hat einen Schutz aktiviert, der die Entladung verhindert", + "Batterie ist im Wartungs- oder Kalibrierungsmodus", + "Batterieladestand liegt unter dem Mindestniveau für den Backup-Betrieb" + ], + "NextSteps": [ + "BMS-Status und BMS-Fehleranzeigen prüfen", + "Batterie über den Mindest-SOC-Grenzwert für Backup aufladen", + "BMS-Probleme beheben und dann den Wechselrichter neu starten" + ] + }, + "Battery2NotConnected": { + "Explanation": "Batterie 2 wird nicht erkannt oder ist nicht angeschlossen. Der Wechselrichter kann die zweite Batterie am Gleichstrombus nicht finden.", + "Causes": [ + "Trennschalter von Batterie 2 ist ausgeschaltet", + "Lockere oder gelöste Batteriekabel am Wechselrichter oder Batterieanschluss", + "Batterie 2 BMS wurde aufgrund eines Schutzereignisses abgeschaltet", + "Sicherung von Batterie 2 ist durchgebrannt" + ], + "NextSteps": [ + "Prüfen, ob der Trennschalter von Batterie 2 auf EIN steht", + "Überprüfen Sie die Batteriekabelverbindungen am Wechselrichter und an den Batterieanschlüssen", + "Prüfen Sie den Status des BMS von Batterie 2 auf Fehlercodes", + "Überprüfen und ersetzen Sie die Sicherung, falls sie durchgebrannt ist, und starten Sie den Wechselrichter neu" + ] + }, + "Battery2Overvoltage": { + "Explanation": "Die Spannung von Batterie 2 ist zu hoch. Das Laden wurde begrenzt oder gestoppt, um die Batterie zu schützen.", + "Causes": [ + "Batterie 2 wird über die maximale Spannung hinaus geladen", + "BMS-Fehler, der zu hoher Spannung führt", + "Falsche Batteriespannungseinstellungen im Wechselrichter" + ], + "NextSteps": [ + "Überprüfen Sie den Ladezustand und die Spannung von Batterie 2", + "Überprüfen Sie die Ladeeinstellungen in der Wechselrichterkonfiguration", + "Prüfen Sie die BMS-Funktion und alle Fehleranzeigen, dann neu starten" + ] + }, + "Battery2Undervoltage": { + "Explanation": "Die Spannung von Batterie 2 ist zu niedrig. Die Entladung wurde begrenzt, um die Batterie vor Tiefentladung zu schützen.", + "Causes": [ + "Batterie 2 wurde zu tief entladen", + "Zellenausfall, der die Gesamtkapazität reduziert", + "BMS-Unterspannungsschutz" + ], + "NextSteps": [ + "Lassen Sie Batterie 2 von PV oder Netz aufladen", + "Überprüfen Sie die Batteriegesundheit – ältere Batterien verlieren Kapazität", + "Beheben Sie die Ursache und starten Sie den Wechselrichter neu" + ] + }, + "Battery2DischargeEnd": { + "Explanation": "Batterie 2 hat den minimalen Ladezustand erreicht. Die Entladung wurde gestoppt, um die Batterie zu schützen.", + "Causes": [ + "Batterie 2 wurde bis zum konfigurierten SOC-Grenzwert vollständig entladen", + "Hoher Stromverbrauch, der die verfügbare Ladung übersteigt" + ], + "NextSteps": [ + "Warten Sie, bis Batterie 2 von PV oder Netzstrom aufgeladen wird", + "Dieser Alarm wird automatisch gelöscht, sobald ausreichend Ladung wiederhergestellt ist" + ] + }, + "Battery2Inverted": { + "Explanation": "Die Polarität von Batterie 2 ist vertauscht. Dies ist ein gefährlicher Zustand, der sofort behoben werden muss.", + "Causes": [ + "Batterie 2 Kabel sind mit vertauschter Plus- und Minus-Polarität angeschlossen", + "Installationsfehler beim anfänglichen Verkabeln" + ], + "NextSteps": [ + "Sofort das gesamte System ausschalten", + "Trennen Sie die Kabel von Batterie 2 vorsichtig, nachdem die Stromversorgung ausgeschaltet wurde", + "Schließen Sie die Kabel mit der richtigen Polarität an und überprüfen Sie auf Schäden, bevor Sie das System neu starten" + ] + }, + "Battery2OverloadTimeout": { + "Explanation": "Batterie 2 läuft seit zu langer Zeit unter Überlast.", + "Causes": [ + "Dauerhafte hohe Last, die die Entladerating von Batterie 2 überschreitet", + "Batterie 2 ist degradiert und kann weniger Leistung bereitstellen" + ], + "NextSteps": [ + "Den Gesamtstromverbrauch reduzieren", + "Prüfen, ob Batterie 2 für die Lastanforderungen richtig dimensioniert ist", + "Nach Lastreduzierung den Wechselrichter neu starten" + ] + }, + "Battery2SoftStartFailure": { + "Explanation": "Batterie 2 konnte die Startsequenz nicht abschließen.", + "Causes": [ + "Fehler im Vorladestromkreis von Batterie 2", + "Spannungsunterschied zwischen Batterie 2 und dem Gleichstrombus" + ], + "NextSteps": [ + "Spannung von Batterie 2 prüfen und mit der Gleichstrombus-Spannung vergleichen", + "Vorladestromkreis und Schütze von Batterie 2 prüfen, dann neu starten" + ] + }, + "Battery2PowerTubeFault": { + "Explanation": "Die Leistungselektronik (IGBT- oder MOSFET-Transistoren) von Batterie 2 ist defekt. Fachkundige Reparatur erforderlich.", + "Causes": [ + "Ausfall der Leistungshalbleiter durch Überlastung, Überstrom oder Verschleiß", + "Kurzschluss, der die Leistungselektronik beschädigt hat" + ], + "NextSteps": [ + "Das System nicht neu starten", + "Einen qualifizierten Techniker für die Reparatur der internen Hardware kontaktieren" + ] + }, + "Battery2InsufficientPower": { + "Explanation": "Batterie 2 kann die aktuelle Last nicht decken.", + "Causes": [ + "Ladestand von Batterie 2 zu niedrig", + "Lastanforderung übersteigt die maximale Entladeleistung von Batterie 2", + "Batteriekapazität durch Alterung reduziert" + ], + "NextSteps": [ + "Warten, bis Batterie 2 wieder aufgeladen ist", + "Last reduzieren, wenn die Batterie wenig geladen ist", + "Der Alarm sollte verschwinden, sobald die Batterie wieder geladen ist" + ] + }, + "Battery2BackupProhibited": { + "Explanation": "Batterie 2 darf aktuell keine Backup-Leistung liefern.", + "Causes": [ + "Batterie 2 BMS schützt vor Entladung", + "Ladestand von Batterie 2 unter dem Mindestwert für Backup" + ], + "NextSteps": [ + "Batterie 2 BMS auf Fehlercodes prüfen", + "Batterie 2 über den Mindestladestand für Backup aufladen, dann neu starten" + ] + }, + "LithiumBattery1ChargeForbidden": { + "Explanation": "Das Batteriemanagementsystem von Lithium-Batterie 1 hat das Laden verboten. Das System hat festgestellt, dass das Laden derzeit unsicher ist.", + "Causes": [ + "Die Batterie ist bereits vollständig geladen und benötigt keine weitere Ladung", + "Die Batterietemperatur liegt außerhalb des sicheren Ladebereichs (zu heiß oder zu kalt)", + "Das BMS hat sich aufgrund von Zellspannungsungleichgewicht oder einem internen Fehler aktiviert", + "Zellungleichgewicht, das vor dem erneuten Laden ausgeglichen werden muss" + ], + "NextSteps": [ + "Überprüfen Sie die Batterietemperatur – das Laden ist normalerweise unter 0°C oder über ~45°C blockiert", + "Überprüfen Sie den BMS-Status oder die Anzeigen auf Fehlercodes", + "Lassen Sie die Batterie auf normale Temperatur kommen, bevor Sie sie laden", + "Wenn das Problem bei normaler Temperatur weiterhin besteht, wenden Sie sich an den Batterieservice" + ] + }, + "LithiumBattery1DischargeForbidden": { + "Explanation": "Das Batteriemanagementsystem von Lithium-Batterie 1 hat die Entladung verboten. Das System hat festgestellt, dass die Entladung derzeit unsicher ist.", + "Causes": [ + "Die Batterie ist auf oder unter dem minimalen Ladezustand – zu leer für eine sichere Entladung", + "Die Batterietemperatur liegt außerhalb des sicheren Entladebereichs", + "Das BMS hat den Tiefspannungsschutz aktiviert", + "Zellungleichgewicht oder internes BMS-Schutzereignis" + ], + "NextSteps": [ + "Lassen Sie die Batterie von PV oder Netz aufladen, bis der Ladezustand über dem Mindestwert liegt", + "Überprüfen Sie die Batterietemperatur – die Entladung ist bei sehr kalten Bedingungen blockiert", + "Überprüfen Sie den BMS-Status auf spezifische Fehlercodes", + "Wenn die Batterie keine Ladung annimmt, wenden Sie sich an den Batterieservice" + ] + }, + "LithiumBattery2ChargeForbidden": { + "Explanation": "Das Batteriemanagementsystem von Lithium-Batterie 2 hat das Laden verboten.", + "Causes": [ + "Batterie 2 ist bereits vollständig geladen", + "Die Temperatur von Batterie 2 liegt außerhalb des sicheren Ladebereichs", + "BMS-Schutzereignis an Batterie 2" + ], + "NextSteps": [ + "Überprüfen Sie die Temperatur und den BMS-Status von Batterie 2", + "Lassen Sie die Temperatur normalisieren, bevor Sie laden", + "Wenn das Problem weiterhin besteht, überprüfen Sie die BMS-Fehlercodes" + ] + }, + "LithiumBattery2DischargeForbidden": { + "Explanation": "Das Batteriemanagementsystem von Lithium-Batterie 2 hat die Entladung verboten.", + "Causes": [ + "Batterie 2 ist auf dem minimalen Ladezustand", + "Die Temperatur von Batterie 2 liegt außerhalb des sicheren Entladebereichs", + "BMS-Schutzereignis an Batterie 2" + ], + "NextSteps": [ + "Lassen Sie Batterie 2 von PV oder Netz aufladen", + "Überprüfen Sie die Batterietemperatur und den BMS-Status auf Fehlercodes", + "Wenn die Batterie nicht aufgeladen werden kann, wenden Sie sich an den Batterieservice" + ] + }, + "LithiumBattery1Full": { + "Explanation": "Lithium-Batterie 1 ist vollständig geladen. Das Laden wurde automatisch gestoppt.", + "Causes": [ + "Die Batterie hat 100% Ladezustand erreicht", + "Die Zellenspannung hat den maximalen sicheren Pegel erreicht" + ], + "NextSteps": [ + "Dies ist normaler Betrieb – keine Aktion erforderlich", + "Überwachen Sie den Batteriezustand regelmäßig, um sicherzustellen, dass die Zellen korrekt ausgeglichen werden" + ] + }, + "LithiumBattery1DischargeEnd": { + "Explanation": "Lithium-Batterie 1 hat das Ende ihres Entladezyklus erreicht — die Mindestladung ist erreicht.", + "Causes": [ + "Die Batterie wurde bis zum konfigurierten Mindestladestand entladen", + "Hohe Nachlast oder Tageslast hat die Batterie entleert" + ], + "NextSteps": [ + "Lassen Sie die Batterie über Solar- oder Netzstrom wieder aufladen", + "Überlegen Sie, den Verbrauch bei geringer Sonneneinstrahlung zu reduzieren, um die Ladung zu erhalten" + ] + }, + "LithiumBattery2Full": { + "Explanation": "Lithium-Batterie 2 ist vollständig geladen. Das Laden wurde automatisch gestoppt.", + "Causes": [ + "Batterie 2 hat 100 % Ladezustand erreicht" + ], + "NextSteps": [ + "Dies ist normaler Betrieb — keine Aktion erforderlich", + "Das System wird das Laden automatisch fortsetzen, wenn der Ladezustand sinkt" + ] + }, + "LithiumBattery2DischargeEnd": { + "Explanation": "Lithium-Batterie 2 hat das Ende ihres Entladezyklus erreicht.", + "Causes": [ + "Batterie 2 wurde bis zum konfigurierten Mindestladestand entladen" + ], + "NextSteps": [ + "Lassen Sie Batterie 2 über Solar- oder Netzstrom wieder aufladen", + "Dieser Alarm wird automatisch gelöscht, sobald die Ladung wiederhergestellt ist" + ] + }, + "LeadBatteryTemperatureAbnormality": { + "Explanation": "Die Temperatur der Bleibatterie liegt außerhalb des normalen Betriebsbereichs.", + "Causes": [ + "Batterieüberhitzung durch hohe Umgebungstemperatur oder übermäßigen Ladestrom", + "Temperatursensorfehler mit falschen Messwerten", + "Sehr kalte Umgebungstemperatur verlangsamt chemische Reaktionen" + ], + "NextSteps": [ + "Überprüfen Sie die Batterietemperatur direkt, falls sicher", + "Verbessern Sie die Batteriebelüftung oder Kühlung bei Überhitzung", + "Stellen Sie sicher, dass der Temperatursensor korrekt angeschlossen und funktionsfähig ist", + "Beheben Sie die zugrunde liegende Ursache und starten Sie den Wechselrichter neu" + ] + }, + "BatteryAccessMethodError": { + "Explanation": "Die Batteriezugriffsmethode ist falsch konfiguriert — der Wechselrichter und die Batterie sind nicht für die Kommunikation mit demselben Protokoll eingerichtet.", + "Causes": [ + "Falsches Batteriekommunikationsprotokoll im Wechselrichter eingestellt", + "Batterietyp oder Modell stimmt nicht mit der konfigurierten Zugriffsmethode überein" + ], + "NextSteps": [ + "Überprüfen Sie die Batteriekommunikationseinstellungen in der Wechselrichterkonfiguration", + "Stellen Sie sicher, dass der Batterietyp und das Kommunikationsprotokoll mit der angeschlossenen Batterie übereinstimmen, und starten Sie dann neu" + ] + }, + "Pv1NotAccessed": { + "Explanation": "Die PV-Leitung 1 wird nicht erkannt oder ist nicht zugänglich. Der Wechselrichter misst keine Spannung oder Stromstärke von der PV-Leitung 1.", + "Causes": [ + "PV-Leitung 1 ist ausgeschaltet (Trennschalter offen)", + "Kabelbruch unterbricht den Stromkreis", + "Defekt in einem PV-Modul der Leitung", + "Kein Sonnenlicht verfügbar (Nacht oder starke Bewölkung)" + ], + "NextSteps": [ + "Prüfen, ob der Trennschalter der PV-Leitung 1 eingeschaltet ist", + "Alle Kabelverbindungen der PV-Leitung 1 überprüfen", + "Auf Verschattung oder Hindernisse an den Modulen achten", + "Beschädigte Kabel oder Stecker reparieren und dann neu starten" + ] + }, + "Pv1Overvoltage": { + "Explanation": "Die Spannung der PV-Leitung 1 überschreitet die maximale DC-Eingangsspannung des Wechselrichters. Dies kann den Wechselrichter beschädigen.", + "Causes": [ + "Zu viele PV-Module in Reihe geschaltet für dieses Wechselrichtermodell", + "Kälte erhöht die Modulspannung deutlich", + "Fehlerhafte Systemplanung – falsche Größe der Leitung" + ], + "NextSteps": [ + "Prüfen, wie viele Module in Reihe geschaltet sind und mit der maximalen Eingangsspannung des Wechselrichters vergleichen", + "Überprüfen der Leerlaufspannung bei der niedrigsten erwarteten Temperatur – Spannung muss unter dem Maximalwert des Wechselrichters bleiben", + "Falls nötig, die Anzahl der Module in Reihe reduzieren" + ] + }, + "AbnormalPv1CurrentSharing": { + "Explanation": "Der Stromfluss in der PV-Leitung 1 ist ungleichmäßig, was auf ein Problem hinweist.", + "Causes": [ + "Unterschiedliche PV-Module mit abweichenden elektrischen Eigenschaften", + "Teilweise Verschattung aktiviert Bypass-Dioden", + "Moduldefekt reduziert den Strom in einem Teil der Leitung" + ], + "NextSteps": [ + "Auf Verschattung oder Verschmutzung der PV-Leitung 1 achten", + "Prüfen, ob alle Module der Leitung vom gleichen Modell sind und nicht beschädigt sind", + "Den Grundfehler beheben und dann den Wechselrichter neu starten" + ] + }, + "Pv1PowerTubeFault": { + "Explanation": "Die Leistungselektronik (IGBT/MOSFET) des PV1-DC-Wandlers ist ausgefallen. Dies ist ein Hardware-Defekt.", + "Causes": [ + "IGBT- oder MOSFET-Ausfall durch Überstrom, Überspannung oder langfristige Abnutzung", + "Kurzschluss oder Spannungsspitze beschädigt die Leistungselektronik" + ], + "NextSteps": [ + "Das System nicht neu starten", + "Einen qualifizierten Techniker für die Reparatur kontaktieren" + ] + }, + "Pv1SoftStartFailure": { + "Explanation": "Die PV-Leitung 1 konnte die Soft-Start-Sequenz (Vorladung) beim Start nicht abschließen.", + "Causes": [ + "Defekt im Vorladekreis verhindert kontrollierten Start", + "PV-Spannung weicht deutlich vom erwarteten DC-Bus-Spannungsniveau ab" + ], + "NextSteps": [ + "PV-Spannung an den Wechselrichtereingängen prüfen", + "Vorladekreis reparieren und dann den Wechselrichter neu starten" + ] + }, + "Pv1OverloadTimeout": { + "Explanation": "Die PV-Leitung 1 liefert seit zu langer Zeit zu viel Strom.", + "Causes": [ + "Die PV-Anlage ist zu groß für die DC-Wandlerleistung", + "Der DC-Wandler kann den starken Sonneneinstrahlung nicht standhalten" + ], + "NextSteps": [ + "Prüfen, ob die PV-Anlagengröße zur Wechselrichter-Eingangsleistung passt", + "Die Ursache beheben und den Wechselrichter neu starten" + ] + }, + "Pv1InsufficientPower": { + "Explanation": "Die PV-Leitung 1 liefert zu wenig Strom. Das ist meist wetterbedingt.", + "Causes": [ + "Wolken oder schlechtes Wetter reduzieren die Sonneneinstrahlung", + "Beschattung der PV-Leitung 1", + "Niedrige Sonnenstände am Morgen oder Abend" + ], + "NextSteps": [ + "Warten auf bessere Sonnenbedingungen – das löst sich von selbst", + "Neue Beschattungsquellen wie Bäume, Gebäude oder Schmutz prüfen", + "Der Alarm verschwindet automatisch, sobald die Sonneneinstrahlung zurückkehrt" + ] + }, + "Photovoltaic1Overcurrent": { + "Explanation": "Der Strom in PV-Leitung 1 übersteigt die maximale DC-Eingangsleistung des Wechselrichters.", + "Causes": [ + "Die PV-Anlage ist zu groß mit zu vielen parallelen Leitungen", + "Erdschluss verursacht ungewöhnlichen Stromfluss", + "Kurzschluss in einem Teil der PV-Leitung" + ], + "NextSteps": [ + "Prüfen Sie die Konfiguration von PV-Leitung 1 – Anzahl der parallelen Leitungen", + "Auf Erdschlüsse oder Kurzschlüsse in der Verkabelung prüfen", + "Den Fehler beheben und den Wechselrichter neu starten" + ] + }, + "Pv2NotAccessed": { + "Explanation": "PV-Leitung 2 wird nicht erkannt oder ist nicht zugänglich.", + "Causes": [ + "Der Trennschalter von PV-Leitung 2 ist ausgeschaltet", + "Kabelbeschädigung an Leitung 2", + "Kein Sonnenlicht verfügbar" + ], + "NextSteps": [ + "Prüfen, ob der Trennschalter von PV-Leitung 2 EIN ist", + "Kabelverbindungen an Leitung 2 überprüfen", + "Beschädigungen beheben und den Wechselrichter neu starten" + ] + }, + "Pv2Overvoltage": { + "Explanation": "Die Spannung von PV-Leitung 2 übersteigt die maximale DC-Eingangsspannung.", + "Causes": [ + "Zu viele PV-Module in Reihe in Leitung 2", + "Kälte erhöht die Modulspannung über die Wechselrichter-Grenzen" + ], + "NextSteps": [ + "Prüfen Sie die Anzahl der Module und die Spannung von Leitung 2 gegen die Wechselrichter-Spezifikation", + "Falls nötig, die Anzahl der Module in Reihe reduzieren, um die Spannungsgrenzen einzuhalten" + ] + }, + "AbnormalPv2CurrentSharing": { + "Explanation": "Die Stromverteilung der PV-String 2 ist ungewöhnlich.", + "Causes": [ + "Nicht passende oder verschlechterte Module in String 2", + "Teilweise Beschattung der String 2-Paneele" + ], + "NextSteps": [ + "Prüfen Sie die String 2-Paneele auf Verschmutzung oder Beschattung", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "Pv2PowerTubeFault": { + "Explanation": "Die Leistungselektronik des PV2-Gleichstromwandlers ist ausgefallen. Fachkundiger Service ist erforderlich.", + "Causes": [ + "Ausfall eines Leistungshalbleiters (IGBT/MOSFET)", + "Schäden durch Überstrom oder Spannungsspitzen" + ], + "NextSteps": [ + "Starten Sie das System nicht neu", + "Kontaktieren Sie einen qualifizierten Servicetechniker für die Reparatur" + ] + }, + "Pv2SoftStartFailure": { + "Explanation": "PV-String 2 konnte die Softstart-Sequenz nicht abschließen.", + "Causes": [ + "Vorladungsfehler am PV2-Wandler", + "Spannungsunterschied zwischen PV2 und Gleichstrombus" + ], + "NextSteps": [ + "Prüfen Sie die Eingangsspannung von PV-String 2", + "Beheben Sie den Vorladungsfehler und starten Sie den Wechselrichter neu" + ] + }, + "Pv2OverloadTimeout": { + "Explanation": "PV-String 2 liefert seit zu langer Zeit zu viel Leistung.", + "Causes": [ + "PV-String 2 ist zu groß für die Wandlerleistung", + "Lange hohe Sonneneinstrahlung über den Wandlergrenzen" + ], + "NextSteps": [ + "Überprüfen Sie die Größe von PV-String 2 im Vergleich zur Wechselrichterspezifikation", + "Beheben Sie die Ursache und starten Sie den Wechselrichter neu" + ] + }, + "Pv2InsufficientPower": { + "Explanation": "PV-String 2 liefert nicht genug Leistung. Meist wetterbedingt.", + "Causes": [ + "Geringe Sonneneinstrahlung oder starke Beschattung von String 2", + "Früher Morgen oder später Abend mit zu flachem Sonnenstand" + ], + "NextSteps": [ + "Warten Sie auf bessere Sonnenbedingungen", + "Prüfen Sie auf neue Beschattungsquellen an den String 2-Paneelen" + ] + }, + "Pv3NotConnected": { + "Explanation": "Die PV-Leitung 3 ist nicht angeschlossen oder wird nicht erkannt.", + "Causes": [ + "Trennschalter der PV-Leitung 3 ist ausgeschaltet", + "Kabel der Leitung 3 ist getrennt oder beschädigt", + "Kein Sonnenlicht verfügbar" + ], + "NextSteps": [ + "Prüfen, ob der Trennschalter der PV-Leitung 3 EIN ist", + "Kabelverbindungen der Leitung 3 überprüfen", + "Beschädigungen reparieren und dann neu starten" + ] + }, + "Pv3Overvoltage": { + "Explanation": "Die Spannung der PV-Leitung 3 überschreitet die maximale DC-Eingangsspannung.", + "Causes": [ + "Zu viele PV-Module in Reihe in Leitung 3", + "Kälte erhöht die Modulspannung über die Inverter-Grenzwerte" + ], + "NextSteps": [ + "Prüfen, ob die Anzahl der Module in Leitung 3 die maximale Eingangsspannung des Inverters einhält", + "Modulanzahl reduzieren, falls die Spannung bei minimaler Außentemperatur die Grenzwerte überschreitet" + ] + }, + "Pv3AverageCurrentAnomaly": { + "Explanation": "Der durchschnittliche Strom der PV-Leitung 3 ist ungewöhnlich, was auf ungleichmäßige Leistung hinweist.", + "Causes": [ + "Modul-Unterschiede oder Verschlechterung in Leitung 3", + "Teilweise Beschattung beeinflusst einige Module in Leitung 3" + ], + "NextSteps": [ + "Prüfen Sie die Module in Leitung 3 auf Beschattung, Verschmutzung oder Schäden", + "Den Fehler beheben und dann den Inverter neu starten" + ] + }, + "Pv3PowerTubeFailure": { + "Explanation": "Die Leistungselektronik der PV-Leitung 3 ist ausgefallen. Fachkundiger Service ist erforderlich.", + "Causes": [ + "Ausfall von Leistungshalbleitern durch Überlastung oder Alterung", + "Schäden durch Überstrom oder Spannungsspitzen" + ], + "NextSteps": [ + "System nicht neu starten", + "Kontaktieren Sie einen qualifizierten Servicetechniker für die Reparatur der internen Hardware" + ] + }, + "Pv3SoftStartFailure": { + "Explanation": "Die PV-Leitung 3 konnte den sanften Startvorgang nicht abschließen.", + "Causes": [ + "Fehler im Vorladestromkreis des PV-3-Wandlers", + "Spannungsunterschied zwischen PV-3 und dem DC-Bus" + ], + "NextSteps": [ + "Spannung der PV-Leitung 3 an den Inverter-Anschlüssen prüfen", + "Vorladestromkreis reparieren und dann den Inverter neu starten" + ] + }, + "Pv3OverloadTimeout": { + "Explanation": "PV-String 3 liefert seit zu langer Zeit zu viel Strom.", + "Causes": [ + "PV-String 3 ist für den Wechselrichter zu groß dimensioniert", + "Lange hohe Sonneneinstrahlung übersteigt die DC-Wechselrichter-Grenzen" + ], + "NextSteps": [ + "Prüfen Sie die Größe von PV-String 3 im Vergleich zur Wechselrichter-Spezifikation", + "Beheben Sie die Ursache und starten Sie den Wechselrichter neu" + ] + }, + "Pv3ReverseConnection": { + "Explanation": "PV-String 3 ist mit vertauschter Polarität angeschlossen. Dies ist ein Verdrahtungsfehler, der vor dem Betrieb behoben werden muss.", + "Causes": [ + "Positive und negative Kabel von PV-String 3 wurden während der Installation vertauscht", + "Falsche Kabelverbindung am DC-Eingang des Wechselrichters" + ], + "NextSteps": [ + "Versuchen Sie nicht, den Wechselrichter neu zu starten – falsche Polarität kann Komponenten beschädigen", + "Schalten Sie komplett aus und tauschen Sie die positive und negative Verbindung von PV-String 3", + "Überprüfen Sie die korrekte Polarität vor dem Neustart" + ] + }, + "Pv4NotConnected": { + "Explanation": "PV-String 4 ist nicht angeschlossen oder wird nicht erkannt.", + "Causes": [ + "Trennschalter von PV-String 4 ist ausgeschaltet", + "Kabel von String 4 ist getrennt oder beschädigt", + "Kein Sonnenlicht verfügbar" + ], + "NextSteps": [ + "Überprüfen Sie, ob der Trennschalter von PV-String 4 EIN ist", + "Prüfen Sie die Kabelverbindungen an String 4", + "Beheben Sie eventuelle Schäden und starten Sie dann neu" + ] + }, + "Pv4Overvoltage": { + "Explanation": "Die Spannung von PV-String 4 überschreitet die maximale DC-Eingangsspannung.", + "Causes": [ + "Zu viele PV-Module in Reihe in String 4", + "Kälte lässt die Modulspannung über die Wechselrichter-Grenzen steigen" + ], + "NextSteps": [ + "Prüfen Sie die Anzahl der Module in String 4 im Vergleich zur maximalen Eingangsspannung des Wechselrichters", + "Reduzieren Sie die Module in Reihe, falls die Spannung die Spezifikation überschreitet" + ] + }, + "Pv4AverageCurrentAnomaly": { + "Explanation": "Der Durchschnittsstrom von PV-String 4 ist ungewöhnlich.", + "Causes": [ + "Modul-Unterschiede oder Verschlechterung innerhalb von String 4", + "Teilweise Beschattung beeinflusst die Module in String 4" + ], + "NextSteps": [ + "Überprüfen Sie die Module von String 4 auf Beschattung, Verschmutzung oder Schäden", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "Pv4PowerTubeFailure": { + "Explanation": "Die Leistungselektronik von PV 4 ist ausgefallen. Ein Fachmann muss das System überprüfen.", + "Causes": [ + "Ausfall des Leistungshalbleiters durch Überlastung oder Alterung", + "Schaden durch Überstrom oder Spannungsspitze" + ], + "NextSteps": [ + "Starten Sie das System nicht neu", + "Kontaktieren Sie einen qualifizierten Techniker zur Reparatur" + ] + }, + "Pv4SoftStartFailure": { + "Explanation": "Die PV-Zeile 4 konnte den Softstart nicht abschließen.", + "Causes": [ + "Fehler im Vorladestromkreis des PV-4-Wandlers", + "Spannungsunterschied zwischen PV 4 und dem Gleichstrombus" + ], + "NextSteps": [ + "Überprüfen Sie die Spannung der PV-Zeile 4 an den Wechselrichteranschlüssen", + "Beheben Sie den Vorladefehler und starten Sie den Wechselrichter neu" + ] + }, + "Pv4OverloadTimeout": { + "Explanation": "Die PV-Zeile 4 liefert seit zu langer Zeit zu viel Leistung.", + "Causes": [ + "Die PV-Zeile 4 ist für den Wandler zu groß dimensioniert", + "Anhaltend hohe Sonneneinstrahlung übersteigt die Kapazität des Gleichstromwandlers" + ], + "NextSteps": [ + "Überprüfen Sie die Dimensionierung der PV-Zeile 4 im Vergleich zur Wechselrichterspezifikation", + "Beheben Sie die Ursache und starten Sie den Wechselrichter neu" + ] + }, + "Pv4ReverseConnection": { + "Explanation": "Die PV-Zeile 4 ist mit vertauschter Polarität angeschlossen. Dies muss vor dem Betrieb korrigiert werden.", + "Causes": [ + "Die positiven und negativen Kabel der PV-Zeile 4 wurden während der Installation vertauscht", + "Falsche Kabelverbindung am DC-Eingang des Wechselrichters" + ], + "NextSteps": [ + "Starten Sie das System nicht neu – schalten Sie es zuerst komplett aus", + "Vertauschen Sie die positiven und negativen Anschlüsse der PV-Zeile 4, um die Polarität zu korrigieren", + "Überprüfen Sie die Polarität vor dem Neustart" + ] + }, + "InsufficientPhotovoltaicPower": { + "Explanation": "Die verfügbare PV-Leistung reicht nicht für den aktuellen Verbrauch oder Systembedarf.", + "Causes": [ + "Geringe Sonneneinstrahlung durch Bewölkung oder Wetter", + "Morgens oder abends – zu flacher Sonnenstand für volle Leistung", + "Beschattung auf einem oder mehreren PV-Strings" + ], + "NextSteps": [ + "Warten Sie auf bessere Sonnenbedingungen – dies löst sich meist von selbst", + "Überprüfen Sie die Beschattung der Module und entfernen Sie sie, falls möglich", + "Der Alarm verschwindet automatisch, sobald die Sonneneinstrahlung besser wird" + ] + }, + "DcBusOvervoltage": { + "Explanation": "Die interne DC-Bus-Spannung ist zu hoch. Dies kann auf ein Energiedefizit im System hinweisen.", + "Causes": [ + "Zu viel Ladeleistung fließt in den DC-Bus ohne Verbraucher", + "Rückspeisung von Energie aus regenerativen Lasten in den DC-Bus", + "Fehler in der DC-Bus-Spannungsregelung" + ], + "NextSteps": [ + "Prüfen Sie die Leistungsbilanz zwischen Erzeugung, Verbrauch und Speicher", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "DcBusUndervoltage": { + "Explanation": "Die interne DC-Bus-Spannung ist zu niedrig, was den normalen Betrieb verhindert.", + "Causes": [ + "Die Last entnimmt mehr Leistung, als von allen Quellen verfügbar ist", + "Problem mit der Stromversorgung oder der Batterie, die die DC-Bus-Spannung begrenzt", + "Batterie ist fast leer" + ], + "NextSteps": [ + "Reduzieren Sie die Last des Systems", + "Überprüfen Sie alle Stromquellen – PV, Netz und Batterie – auf Funktionsfähigkeit", + "Beheben Sie die Ursache und starten Sie den Wechselrichter neu" + ] + }, + "DcBusVoltageUnbalance": { + "Explanation": "Die DC-Bus-Spannung ist zwischen den positiven und negativen Hälften unausgeglichen.", + "Causes": [ + "Kapazitätsausfall im DC-Bus-Kondensatorblock", + "Problem mit der DC-Bus-Steuerung", + "Asymmetrische Belastung zwischen den beiden DC-Bus-Hälften" + ], + "NextSteps": [ + "Überprüfen Sie den DC-Bus-Kondensatorblock auf defekte Kondensatoren", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "BusSlowOvervoltage": { + "Explanation": "Ein langsamer, allmählicher Anstieg der DC-Bus-Spannung über die sicheren Grenzen hinaus wurde erkannt.", + "Causes": [ + "Allmählicher Spannungsanstieg aufgrund von Ladeungleichgewicht über die Zeit", + "Problem mit der Ladekontrolle, das zu langsamem Spannungsanstieg führt" + ], + "NextSteps": [ + "Überprüfen Sie die Ladeleistungssteuerung und bestätigen Sie, dass die Einstellungen korrekt sind", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "HardwareBusOvervoltage": { + "Explanation": "Der Hardware-Schutz für DC-Bus-Überspannung hat ausgelöst. Dies ist ein schwerwiegender Überspannungszustand.", + "Causes": [ + "Schwerwiegendes Überspannungsereignis durch eine externe Quelle oder einen internen Ausfall", + "Komponentenausfall, der zu unkontrolliertem Spannungsanstieg führt" + ], + "NextSteps": [ + "Nicht neu starten – dies erfordert eine professionelle Inspektion", + "Kontaktieren Sie einen Servicetechniker, um die Ursache der Überspannung zu untersuchen" + ] + }, + "BusSoftStartFailure": { + "Explanation": "Der Gleichstrombus konnte nicht richtig vorladen und sanft starten.", + "Causes": [ + "Defekt am Vorladewiderstand oder in der Schaltung", + "Ausfall des Gleichstrombus-Kondensators, der das Aufladen verhindert", + "Relais oder Schütz im Vorladekreis funktioniert nicht richtig" + ], + "NextSteps": [ + "Prüfen Sie die Vorladeschaltung und alle zugehörigen Relais", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "InverterPowerTubeFault": { + "Explanation": "Die Hauptleistungselektronik des Wechselrichters (IGBT- oder MOSFET-Transistoren) ist defekt. Dies ist ein Hardwarefehler, der professionellen Service erfordert.", + "Causes": [ + "Ausfall des Leistungshalbleiters durch langanhaltende Überlastung", + "Überstromschaden durch einen Kurzschluss", + "Thermischer Schaden durch Überhitzung", + "Komponentenausfall durch Lebensdauerende" + ], + "NextSteps": [ + "Versuchen Sie nicht, den Wechselrichter neu zu starten – dies könnte zu weiteren Schäden führen", + "Kontaktieren Sie sofort einen qualifizierten Servicetechniker", + "Hardwarereparatur oder Modulaustausch ist erforderlich" + ] + }, + "HardwareOvercurrent": { + "Explanation": "Die Hardware-Überstromschutzvorrichtung hat ausgelöst – der Strom hat die absolute Hardware-Grenze überschritten.", + "Causes": [ + "Kurzschluss in der Ausgangsverkabelung oder angeschlossenen Lasten", + "Schwere Überlastung, die die Hardware-Schutzschwelle überschreitet", + "Ausfall eines internen Leistungselektronikbauteils" + ], + "NextSteps": [ + "Starten Sie das System nicht neu, bevor die Ursache ermittelt wurde", + "Kontaktieren Sie einen Servicetechniker, um auf Kurzschlüsse und Bauteilschäden zu prüfen" + ] + }, + "DcConverterOvervoltage": { + "Explanation": "Die Eingangsspannung oder Ausgangsspannung des DC-Wandlers ist zu hoch.", + "Causes": [ + "Eingangsspannung (PV oder Batterie) überschreitet die Wandlergrenzen", + "Fehler in der Spannungsregelung des DC-Wandlers" + ], + "NextSteps": [ + "Prüfen Sie die PV- und Batteriespannung", + "Beheben Sie die Ursache und starten Sie den Wechselrichter neu" + ] + }, + "DcConverterHardwareOvervoltage": { + "Explanation": "Die Hardware-Überspannungsschutzvorrichtung des DC-Wandlers hat ausgelöst – ein schwerer Überspannungszustand ist aufgetreten.", + "Causes": [ + "Schwere Überspannung am Eingang oder Ausgang des DC-Wandlers", + "Blitzschlag oder externe Spannungsspitze" + ], + "NextSteps": [ + "Starten Sie das System nicht neu – kontaktieren Sie einen Servicetechniker, um Schäden zu prüfen, bevor Sie es weiter betreiben" + ] + }, + "DcConverterOvercurrent": { + "Explanation": "Der Strom im DC-Wandler ist zu hoch.", + "Causes": [ + "Überlastung durch zu hohen Stromverbrauch im Wandler", + "Kurzschluss im DC-Kreis" + ], + "NextSteps": [ + "Last oder Lade-/Entladestrom reduzieren", + "Auf Kurzschlüsse prüfen und dann den Wechselrichter neu starten" + ] + }, + "DcConverterHardwareOvercurrent": { + "Explanation": "Die Hardware-Überstromschutz des DC-Wandlers wurde ausgelöst — die Stromgrenze wurde überschritten.", + "Causes": [ + "Starker Überstrom durch Kurzschluss oder Hardwarefehler", + "Fehler in der Leistungselektronik, der unkontrollierten Stromfluss verursacht" + ], + "NextSteps": [ + "Nicht neu starten — einen Servicetechniker kontaktieren, um Schäden zu prüfen, bevor der Betrieb fortgesetzt wird" + ] + }, + "DcConverterResonatorOvercurrent": { + "Explanation": "Der Resonanzkreis des DC-Wandlers hat einen Überstrom.", + "Causes": [ + "Resonanzbedingung, die zu übermäßigen Stromschwankungen im Wandler führt", + "Steuerungsproblem des DC-Wandlers, das den Resonanzkreis beeinflusst" + ], + "NextSteps": [ + "Den zugrunde liegenden Fehler beheben und dann den Wechselrichter neu starten; bei anhaltendem Problem Service kontaktieren" + ] + }, + "SystemOutputOverload": { + "Explanation": "Die Gesamtausgangsleistung des Systems ist überlastet — es wird mehr Leistung angefordert, als das System sicher liefern kann.", + "Causes": [ + "Zu viele leistungsstarke Verbraucher sind gleichzeitig angeschlossen", + "Die Gesamtlastanforderung überschreitet die Nennleistung des Wechselrichters", + "Kurzschluss in einem der angeschlossenen Verbraucher" + ], + "NextSteps": [ + "Einige Verbraucher trennen, um den Gesamtstromverbrauch zu reduzieren", + "Auf Kurzschlüsse oder Fehler in den angeschlossenen Geräten prüfen", + "Die Ursache beheben und dann den Wechselrichter neu starten" + ] + }, + "InverterOverload": { + "Explanation": "Der Wechselrichter ist überlastet — der Verbraucher zieht mehr Strom, als der Wechselrichter verarbeiten kann.", + "Causes": [ + "Angegliederte Lastleistung überschreitet die Nennleistung des Wechselrichters", + "Hohe Einschaltströme von großen Motoren oder Kompressoren beim Start", + "Kurzschluss in einem angeschlossenen Verbraucher" + ], + "NextSteps": [ + "Die Gesamtlast reduzieren", + "Das Einschalten großer Geräte staffeln, um den Einschaltstrom zu verringern", + "Die Ursache beheben und dann den Wechselrichter neu starten" + ] + }, + "InverterOverloadTimeout": { + "Explanation": "Der Wechselrichter war zu lange überlastet und hat sich abgeschaltet.", + "Causes": [ + "Dauerhafte Überlastung, die die Kurzzeit-Überlastfähigkeit des Wechselrichters überschreitet", + "Der Wechselrichter ist für die tatsächliche Last zu klein dimensioniert" + ], + "NextSteps": [ + "Die angeschlossene Last dauerhaft reduzieren", + "Falls die Last notwendig ist, auf einen größeren Wechselrichter umsteigen", + "Die Ursache beheben und den Wechselrichter neu starten" + ] + }, + "LoadPowerOverload": { + "Explanation": "Die angeschlossene Lastleistung überschreitet die Systemkapazität.", + "Causes": [ + "Zu viele leistungsstarke Geräte laufen gleichzeitig", + "Ein neues leistungsstarkes Gerät wurde hinzugefügt, das die Systemleistung übersteigt" + ], + "NextSteps": [ + "Last reduzieren, indem nicht essentielle Geräte ausgeschaltet werden", + "Nutzung leistungsstarker Geräte staffeln und den Wechselrichter neu starten" + ] + }, + "BalancedCircuitOverloadTimeout": { + "Explanation": "Der Phasenausgleich war zu lange überlastet.", + "Causes": [ + "Ungleichmäßige Lastverteilung zwischen den Phasen – eine Phase trägt deutlich mehr als die anderen", + "Eine einzelne Phase ist deutlich überlastet" + ], + "NextSteps": [ + "Last gleichmäßiger auf die drei Phasen verteilen", + "Die Ursache beheben und den Wechselrichter neu starten" + ] + }, + "InverterSoftStartFailure": { + "Explanation": "Der Wechselrichter konnte die Softstart-Sequenz beim Einschalten nicht abschließen.", + "Causes": [ + "Der Vorwiderstand ist defekt und verhindert das kontrollierte Aufladen des Gleichstrombusses", + "Der Schütz oder Relais schließt während der Startsequenz nicht korrekt", + "Problem mit dem Gleichstrombus-Kondensator, der die Vorladung beeinflusst", + "Fehler auf der Steuerplatine, der die Startsequenz unterbricht" + ], + "NextSteps": [ + "Das System neu starten – alle Trennschalter ausschalten, 30 Sekunden warten und dann wieder einschalten", + "Überprüfen, ob die Gleichstrombus-Spannung während der Vorladung gleichmäßig ansteigt", + "Falls der Fehler weiterhin besteht, einen Servicetechniker kontaktieren" + ] + }, + "Dsp1ParameterSettingFault": { + "Explanation": "DSP 1 (digitaler Signalprozessor) hat eine falsche Parameterkonfiguration erkannt.", + "Causes": [ + "Ein oder mehrere Wechselrichterparameter sind außerhalb des zulässigen Bereichs eingestellt", + "Firmware-Korruption beeinflusst die Parameterspeicherung", + "Konfigurationsinkonsistenz nach einem Firmware-Update" + ], + "NextSteps": [ + "Alle Wechselrichter-Parameter überprüfen und eventuell ungültige Werte korrigieren", + "Parameter auf Werkseinstellungen zurücksetzen, falls unsicher über die richtigen Werte", + "Die Ursache beheben und den Wechselrichter neu starten" + ] + }, + "Dsp2ParameterSettingFault": { + "Explanation": "DSP 2 hat eine falsche Parameterkonfiguration erkannt.", + "Causes": [ + "Ein oder mehrere Parameter liegen außerhalb des gültigen Bereichs", + "Firmware-Beschädigung, die die Parameterspeicherung beeinflusst" + ], + "NextSteps": [ + "Parameter überprüfen und korrigieren", + "Ursache beheben und dann den Wechselrichter neu starten" + ] + }, + "DspVersionCompatibilityFault": { + "Explanation": "Die DSP-Firmware-Version ist mit anderen Systemkomponenten nicht kompatibel.", + "Causes": [ + "Firmware-Versionen von DSP und anderen Platinen stimmen nicht überein", + "Unvollständiger oder fehlgeschlagener Firmware-Update, wodurch Komponenten unterschiedliche Versionen haben" + ], + "NextSteps": [ + "Alle Firmware-Komponenten auf die gleiche kompatible Version aktualisieren", + "Technischen Support kontaktieren, falls die korrekte Version unbekannt ist" + ] + }, + "CpldVersionCompatibilityFault": { + "Explanation": "Die CPLD-Version (Complex Programmable Logic Device) ist mit dem System nicht kompatibel.", + "Causes": [ + "CPLD-Firmware passt nicht zu anderen Komponenten", + "Unvollständiges Firmware-Update" + ], + "NextSteps": [ + "Ein vollständiges Firmware-Update durchführen, um sicherzustellen, dass alle Komponenten auf passenden Versionen sind", + "Wechselrichter nach dem Update neu starten" + ] + }, + "CpldCommunicationFault": { + "Explanation": "Die Kommunikation mit dem internen CPLD-Chip ist fehlgeschlagen.", + "Causes": [ + "Interne Kommunikationsbus-Fehler zwischen DSP und CPLD", + "CPLD-Chip-Ausfall" + ], + "NextSteps": [ + "System neu starten – dies kann die Kommunikation wiederherstellen", + "Falls der Fehler nach dem Neustart weiterhin besteht, einen Servicetechniker kontaktieren" + ] + }, + "DspCommunicationFault": { + "Explanation": "Die Kommunikation mit dem DSP ist fehlgeschlagen.", + "Causes": [ + "Interne Kommunikationsbus-Fehler", + "DSP-Hardware-Ausfall" + ], + "NextSteps": [ + "System neu starten", + "Falls der Fehler nach dem Neustart weiterhin besteht, einen Servicetechniker kontaktieren" + ] + }, + "OutputVoltageDcOverlimit": { + "Explanation": "Eine Gleichspannungskomponente ist in der Wechselspannung aufgetreten und überschreitet den zulässigen Grenzwert.", + "Causes": [ + "Regelkreisdrift führt zu DC-Offset im Ausgang", + "Spannungssensor hat einen Offset-Fehler", + "Hardwareproblem in der Ausgangsstufe" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu — dies behebt oft vorübergehende Offset-Fehler", + "Falls das Problem besteht, kontaktieren Sie einen Servicetechniker" + ] + }, + "OutputCurrentDcOverlimit": { + "Explanation": "Eine Gleichstromkomponente ist im Wechselstrom aufgetreten und überschreitet den zulässigen Grenzwert.", + "Causes": [ + "Regelungsproblem führt zu DC-Offset im Ausgangsstrom", + "Stromsensor hat einen Fehler oder Kalibrierungsfehler" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu", + "Falls der Fehler weiterhin besteht, kontaktieren Sie den Service zur Sensorprüfung" + ] + }, + "RelaySelfCheckFails": { + "Explanation": "Der Selbsttest des Relais ist beim Starten oder während der periodischen Prüfung fehlgeschlagen.", + "Causes": [ + "Relaiskontakt defekt — möglicherweise beschädigt oder verschweißt", + "Relais-Treiberschaltung defekt", + "Relaiskontakte durch Überstrom verschweißt" + ], + "NextSteps": [ + "Prüfen Sie die Relaisfunktion, indem Sie auf Klickgeräusche beim Starten achten", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "InverterRelayOpen": { + "Explanation": "Das Wechselrichter-Ausgangsrelais ist unerwartet offen, obwohl es geschlossen sein sollte.", + "Causes": [ + "Relais-Treiberschaltung verhindert das Schließen des Relais", + "Ein Schutzmechanismus hat das Relais geöffnet" + ], + "NextSteps": [ + "Prüfen Sie auf andere aktive Schutzalarme, die das Relais geöffnet haben könnten", + "Beheben Sie den Fehler und starten Sie den Wechselrichter neu" + ] + }, + "InverterRelayShortCircuit": { + "Explanation": "Die Kontakte des Wechselrichter-Relais sind verschweißt (Kurzschluss). Das Relais kann nicht geöffnet werden, wenn es benötigt wird.", + "Causes": [ + "Relaiskontakte durch Überstrom während eines Fehlerereignisses verschweißt", + "Relaiskomponente defekt" + ], + "NextSteps": [ + "Starten Sie nicht neu — ein verschweißtes Relais ist eine Sicherheitsgefahr", + "Kontaktieren Sie einen Servicetechniker zur Inspektion und zum Austausch des Relais" + ] + }, + "OpenCircuitOfPowerGridRelay": { + "Explanation": "Das Netzanschlussrelais ist unerwartet offen.", + "Causes": [ + "Netzrelais defekt, schließt nicht normal", + "Schutzauslösung hat das Netzrelais geöffnet", + "Problem mit der Ansteuerung des Relais" + ], + "NextSteps": [ + "Überprüfen Sie andere aktive Alarme, die das Öffnen erklären könnten", + "Relais und Ansteuerung prüfen, dann den Wechselrichter neu starten" + ] + }, + "ShortCircuitOfPowerGridRelay": { + "Explanation": "Die Kontakte des Netzrelais sind verschweißt und öffnen nicht mehr.", + "Causes": [ + "Relaiskontakte durch Überstrom verschweißt", + "Relais defekt oder am Lebensende" + ], + "NextSteps": [ + "Nicht neu starten – kontaktieren Sie einen Techniker, um das Relais zu ersetzen, bevor Sie weiterbetreiben" + ] + }, + "GeneratorRelayOpenCircuit": { + "Explanation": "Das Generatoranschlussrelais ist unerwartet offen.", + "Causes": [ + "Generatorrelais defekt, schließt nicht", + "Schutzauslösung hat das Relais geöffnet", + "Problem mit der Ansteuerung des Relais" + ], + "NextSteps": [ + "Überprüfen Sie andere aktive Alarme, die den Zustand erklären könnten", + "Relais prüfen, dann den Wechselrichter neu starten" + ] + }, + "GeneratorRelayShortCircuit": { + "Explanation": "Die Kontakte des Generatorrelais sind verschweißt und öffnen nicht mehr.", + "Causes": [ + "Relaiskontakte durch Überstrom verschweißt", + "Generatorrelais defekt" + ], + "NextSteps": [ + "Nicht neu starten – kontaktieren Sie einen Techniker, um das Generatorrelais zu ersetzen, bevor Sie weiterbetreiben" + ] + }, + "AbnormalInverter": { + "Explanation": "Eine allgemeine Wechselrichteranomalie wurde erkannt. Überprüfen Sie andere spezifischere Alarme, die die Ursache anzeigen könnten.", + "Causes": [ + "Interne Steuerungsfehler ohne genauere Diagnose", + "Mehrere kleinere Fehler gleichzeitig", + "Leistungselektronik arbeitet außerhalb normaler Parameter" + ], + "NextSteps": [ + "Wechselrichter ausschalten und neu starten, um zu prüfen, ob andere spezifische Alarme auftreten", + "Alle Eingangsspannungen und Lastwerte auf ungewöhnliche Werte prüfen", + "Wenn der Alarm anhält, kontaktieren Sie einen Techniker mit dem vollständigen Alarmprotokoll" + ] + }, + "ParallelCommunicationAlarm": { + "Explanation": "Die Kommunikation zwischen parallel geschalteten Wechselrichtern ist ausgefallen. Ohne Kommunikation können die Wechselrichter sich nicht synchronisieren und die Last nicht korrekt aufteilen.", + "Causes": [ + "Das Kommunikationskabel zwischen den parallel geschalteten Wechselrichtern ist beschädigt oder getrennt", + "Ausfall der Parallelkommunikationsschnittstelle an einem Gerät", + "Einstellungen stimmen zwischen den parallelen Einheiten nicht überein" + ], + "NextSteps": [ + "Überprüfen Sie alle Parallelkommunikationskabel zwischen den Wechselrichtereinheiten", + "Stellen Sie sicher, dass alle Parallel-Einstellungen (Spannung, Frequenz, Droop-Einstellungen) auf allen Einheiten übereinstimmen", + "Beheben Sie den zugrunde liegenden Fehler und starten Sie dann das Wechselrichtersystem neu" + ] + }, + "ParallelModuleMissing": { + "Explanation": "Eines der erwarteten parallel geschalteten Wechselrichtermodule reagiert nicht.", + "Causes": [ + "Ein Parallelmodul ist offline gegangen oder wurde ausgeschaltet", + "Die Kommunikationsverbindung zu einem Modul wurde unterbrochen", + "Ein Modul hat aufgrund eines eigenen Alarms abgeschaltet" + ], + "NextSteps": [ + "Überprüfen Sie alle parallel geschalteten Wechselrichtereinheiten auf individuelle Alarme oder Stromausfall", + "Beheben Sie den zugrunde liegenden Fehler am fehlenden Modul und starten Sie dann neu" + ] + }, + "DuplicateMachineNumbersForParallelModules": { + "Explanation": "Zwei parallel geschaltete Wechselrichtermodule wurden mit derselben Gerätenummer konfiguriert, was zu einem Konflikt führt.", + "Causes": [ + "Konfigurationsfehler — dieselbe Gerätenummer wurde zwei verschiedenen Einheiten während der Einrichtung zugewiesen", + "Doppelte Adresse wurde während der Inbetriebnahme nicht erkannt" + ], + "NextSteps": [ + "Greifen Sie auf die Einstellungen jedes Geräts zu und weisen Sie jeder Einheit eine eindeutige Gerätenummer zu", + "Beheben Sie die Konfiguration und starten Sie dann das Wechselrichtersystem neu" + ] + }, + "ParameterConflictInParallelModule": { + "Explanation": "Ein Parameterkonflikt besteht zwischen parallel geschalteten Wechselrichtermodulen — ihre Einstellungen stimmen nicht überein.", + "Causes": [ + "Wichtige Parameter wie Spannungssollwert, Frequenz oder Droop-Einstellungen unterscheiden sich zwischen den Einheiten", + "Eine Einheit wurde aktualisiert oder neu konfiguriert, ohne die anderen zu aktualisieren" + ], + "NextSteps": [ + "Vergleichen Sie die Einstellungen aller parallelen Einheiten und synchronisieren Sie sie auf dieselben Werte", + "Beheben Sie den Konfigurationskonflikt und starten Sie dann das System neu" + ] + }, + "SystemDerating": { + "Explanation": "Das System arbeitet mit reduzierter Leistung (Abregelung), um sich selbst zu schützen. Die Leistung bleibt unter den Nennwerten, bis die Ursache behoben ist.", + "Causes": [ + "Hohe Wechselrichtertemperatur führt zu thermischer Abregelung", + "Eingangsspannung (PV oder Netz) am Rand des Betriebsbereichs", + "Komponente erreicht Betriebsgrenzen" + ], + "NextSteps": [ + "Überprüfen Sie die Wechselrichtertemperatur und verbessern Sie die Belüftung bei Überhitzung", + "Stellen Sie sicher, dass die Eingangsspannungen im normalen Betriebsbereich des Wechselrichters liegen", + "Ermitteln und beheben Sie die spezifische Ursache der Abregelung — prüfen Sie, ob auch andere Alarme aktiv sind" + ] + }, + "PvAccessMethodErrorAlarm": { + "Explanation": "Die PV-Eingangskonfiguration ist falsch eingestellt, wodurch eine Diskrepanz zwischen der physischen Verdrahtung und der Softwarekonfiguration entsteht.", + "Causes": [ + "Die PV-String-Verdrahtung stimmt nicht mit der ausgewählten Konfiguration überein (z. B. falsche Serien- oder Parallel-Einstellung)", + "Verdrahtung ist nicht mit der vom Wechselrichter konfigurierten PV-Zugriffsmethode kompatibel" + ], + "NextSteps": [ + "Überprüfen Sie die PV-Konfigurationseinstellungen und vergleichen Sie sie mit der tatsächlichen physischen Verdrahtung", + "Korrigieren Sie entweder die Einstellungen oder die Verdrahtung, starten Sie dann neu" + ] + }, + "ReservedAlarms4": { + "Explanation": "Reservierter Alarm 4 ist aktiv. Dieser Alarmcode ist nicht in den Standardalarmtabellen dokumentiert.", + "Causes": [ + "Ein nicht dokumentierter interner Zustand wurde erkannt" + ], + "NextSteps": [ + "Beobachten Sie das System auf andere Alarme, die mehr Kontext geben könnten", + "Kontaktieren Sie den technischen Support mit dem vollständigen Alarmprotokoll, falls dieser Alarm weiterhin besteht" + ] + }, + "ReservedAlarms5": { + "Explanation": "Reservierter Alarm 5 ist aktiv. Dieser Alarmcode ist nicht in den Standardalarmtabellen dokumentiert.", + "Causes": [ + "Ein nicht dokumentierter interner Zustand wurde erkannt" + ], + "NextSteps": [ + "Beobachten Sie das System auf andere Alarme, die mehr Kontext geben könnten", + "Kontaktieren Sie den technischen Support mit dem vollständigen Alarmprotokoll, falls dieser Alarm weiterhin besteht" + ] + }, + "ReverseMeterConnection": { + "Explanation": "Der Stromzähler ist falsch installiert oder verdrahtet. Die Zählerstände (Import/Export) sind bis zur Korrektur ungenau.", + "Causes": [ + "Der Stromwandler (CT) ist in die falsche Richtung installiert", + "Die L- und N-Leitungen des Zählers sind bei der Installation vertauscht" + ], + "NextSteps": [ + "Verlassen Sie sich nicht auf die Zählerstände, bis die Korrektur erfolgt ist", + "Kontaktieren Sie Ihren Installateur oder einen qualifizierten Elektriker, um den Stromwandler oder die Zählerverkabelung zu korrigieren" + ] + }, + "InverterSealPulse": { + "Explanation": "Das Wechselrichter-Dichtungsimpulssignal ist aktiv, was darauf hinweist, dass eine Leistungsbegrenzung vorliegt.", + "Causes": [ + "Eine Schutzfunktion hat die Leistungsbegrenzung aktiviert", + "Externe Signale oder Netzcode-Konformitätsfunktionen begrenzen die Leistung" + ], + "NextSteps": [ + "Überprüfen Sie den Systemstatus auf andere aktive Alarme, die die Begrenzung erklären", + "Beheben Sie die zugrunde liegende Ursache und starten Sie den Wechselrichter neu" + ] + }, + "AbnormalDieselGeneratorVoltage": { + "Explanation": "Die Spannung des Dieselgenerators liegt außerhalb des zulässigen Bereichs, sodass der Wechselrichter nicht damit verbunden werden kann.", + "Causes": [ + "Generatorausgangsspannung nicht auf korrektes Niveau eingestellt", + "Fehler am AVR (automatische Spannungsregelung) des Generators", + "Generator unter- oder überlastet, was die Ausgangsspannung beeinflusst" + ], + "NextSteps": [ + "Generator-Spannung prüfen und an die Wechselrichter-Spezifikationen anpassen", + "AVR überprüfen, falls die Spannung nicht stabilisiert werden kann, dann neu starten" + ] + }, + "AbnormalDieselGeneratorFrequency": { + "Explanation": "Die Frequenz des Dieselgenerators liegt außerhalb des zulässigen Bereichs.", + "Causes": [ + "Drehzahl des Generator-Motors nicht korrekt für die Ziel-Frequenz eingestellt", + "Fehler am Regler, der zu Frequenzinstabilität führt" + ], + "NextSteps": [ + "Drehzahl des Generators anpassen, um die korrekte Frequenz (50 Hz oder 60 Hz) zu erreichen", + "Regler überprüfen und reparieren, falls die Frequenz nicht stabilisiert werden kann, dann neu starten" + ] + }, + "DieselGeneratorVoltageReverseSequence": { + "Explanation": "Der Dieselgenerator ist mit vertauschter Phasenfolge angeschlossen.", + "Causes": [ + "Generator-Ausgangskabel falsch an Phasen (L1, L2, L3) angeschlossen" + ], + "NextSteps": [ + "Nicht neu starten – einen qualifizierten Elektriker kontaktieren, um die Generator-Phasenverkabelung zu korrigieren" + ] + }, + "DieselGeneratorVoltageOutOfPhase": { + "Explanation": "Die Generator-Spannung ist nicht mit dem Netz oder System synchronisiert, was eine Synchronisation verhindert.", + "Causes": [ + "Synchronisationsproblem – Generator synchronisiert nicht mit Netz-Phasenwinkel", + "Phasenwinkel-Abweichung zwischen Generator und Netz" + ], + "NextSteps": [ + "Synchronisationseinstellungen prüfen und sicherstellen, dass der Generator Auto-Sync mit diesem Wechselrichter unterstützt", + "Synchronisationsfehler beheben, dann neu starten" + ] + }, + "GeneratorOverload": { + "Explanation": "Der Dieselgenerator ist überlastet – das System verbraucht mehr Strom, als der Generator liefern kann.", + "Causes": [ + "Gesamtlastanforderung übersteigt die Nennleistung des Generators", + "Batterieladung kombiniert mit Lastanforderung übersteigt Generatorleistung", + "Generator für die Installation zu klein dimensioniert" + ], + "NextSteps": [ + "Last reduzieren oder Batterieladung verringern, um die Gesamtanforderung innerhalb der Generatorleistung zu halten", + "Wechselrichter nach Lastreduzierung neu starten" + ] + }, + "StringFault": { + "Explanation": "Ein Fehler im PV-String wurde erkannt. Ein oder mehrere PV-Strings könnten Probleme haben, die die Stromerzeugung beeinträchtigen.", + "Causes": [ + "Fehler oder Beschädigung eines PV-Moduls im String", + "Problem mit der String-Verkabelung oder lockere Verbindung", + "Beschädigter oder korrodierter MC4-Stecker", + "Modulverschlechterung führt zu reduzierter oder keiner Leistung" + ], + "NextSteps": [ + "Prüfen Sie, ob die PV-Module optisch in Ordnung sind – suchen Sie nach Rissen, Verfärbungen oder Schäden", + "Überprüfen Sie die Kabelverbindungen und MC4-Stecker auf Schäden oder Korrosion", + "Suchen Sie nach beschädigten Kabeln entlang des String-Verlaufs", + "Lassen Sie einen Techniker jeden String mit einem Multimeter testen, falls der Fehler nicht behoben wird" + ] + }, + "PvStringPidQuickConnectAbnormal": { + "Explanation": "Der PV-String oder die PID-Schnellanschlüsse sind abnormal.", + "Causes": [ + "Lockerer oder falsch verriegelter Schnellanschluss", + "Beschädigtes Schnellanschlussgehäuse", + "Korrosion oder Oxidation an den Kontakten" + ], + "NextSteps": [ + "Schalten Sie das System vor der Inspektion der Anschlüsse aus", + "Überprüfen Sie alle Schnellanschlüsse und stellen Sie sicher, dass sie vollständig verriegelt sind", + "Reinigen Sie korrodierte Kontakte und verbinden Sie sie sicher" + ] + }, + "DcSpdFunctionAbnormal": { + "Explanation": "Die Funktion des DC-Überspannungsschutzes (SPD) ist abnormal. Der SPD schützt vor Blitzschlag und Spannungsspitzen auf der DC-Seite.", + "Causes": [ + "DC-SPD hat nach einem Überspannungsereignis ausgelöst oder ist ausgefallen", + "SPD-Patrone hat ihre Lebensdauer erreicht", + "Kabelproblem am SPD" + ], + "NextSteps": [ + "Schalten Sie das System aus und prüfen Sie den DC-SPD-Indikator – die meisten SPDs haben eine optische Fehleranzeige", + "Ersetzen Sie die SPD-Patrone, wenn sie ausgelöst hat oder einen Fehler anzeigt", + "Starten Sie den Wechselrichter nach dem Austausch oder der Inspektion neu" + ] + }, + "PvShortCircuited": { + "Explanation": "Der PV1- oder PV2-String scheint kurzgeschlossen zu sein.", + "Causes": [ + "Beschädigte Kabelisolierung, die einen Kurzschluss zwischen Plus- und Minusleiter verursacht", + "MC4-Steckerausfall, der einen internen Kurzschluss verursacht", + "Modulanschlusskasten-Fehler, der einen Kurzschlussweg schafft" + ], + "NextSteps": [ + "Schalten Sie alle DC-Trennschalter vor der Inspektion aus", + "Prüfen Sie die PV1- und PV2-Strings einzeln auf Kurzschluss-Symptome (Spannung null, ungewöhnliche Hitze)", + "Überprüfen Sie die Kabel auf Schäden und testen Sie den Isolationswiderstand", + "Reparieren oder ersetzen Sie beschädigte Kabel/Stecker, bevor Sie das System wieder starten" + ] + }, + "PvBoostDriverAbnormal": { + "Explanation": "Die PV-Boost-Wandler-Treiberschaltung ist abnormal.", + "Causes": [ + "Fehler oder Komponentenausfall in der Boost-Treiberschaltung", + "EMV-Störungen, die das Treibersignal beeinflussen", + "Interne Hardware-Probleme auf der Wechselrichterplatine" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu – vorübergehende Treiberfehler werden oft nach dem Neustart behoben", + "Falls der Fehler nach dem Neustart weiterhin besteht, wenden Sie sich an den Hersteller für Service" + ] + }, + "AcSpdFunctionAbnormal": { + "Explanation": "Die Funktion des AC-Überspannungsschutzes (SPD) ist gestört. Der SPD schützt vor Blitzeinschlägen und Spannungsspitzen auf der AC-Seite.", + "Causes": [ + "AC-SPD hat nach einem Spannungsstoß ausgelöst oder ist defekt", + "SPD-Patrone hat ihre Lebensdauer erreicht", + "Kabelbruch im AC-SPD" + ], + "NextSteps": [ + "Schalten Sie das System aus und prüfen Sie die Anzeige des AC-SPD", + "Ersetzen Sie die AC-SPD-Patrone, wenn sie einen Fehler anzeigt oder ausgelöst hat", + "Starten Sie den Wechselrichter nach dem Austausch oder der Prüfung neu" + ] + }, + "DcFuseBlown": { + "Explanation": "Die DC-Sicherung ist durchgebrannt und unterbricht die PV-Eingabe zum Wechselrichter.", + "Causes": [ + "Überstrom im DC-Kreis vom PV-Array, der die Sicherungsgrenze überschreitet", + "Kurzschluss in der DC-Verkabelung, der die Sicherung durchbrennen lässt", + "Sicherungsermüdung nach wiederholten Überstromereignissen" + ], + "NextSteps": [ + "Schalten Sie alle DC-Schalter und Trennvorrichtungen aus, bevor Sie an der Schaltung arbeiten", + "Lokalisieren und prüfen Sie die DC-Sicherung – sie wird optisch durchgebrannt aussehen oder mit einem Multimeter offen messen", + "Identifizieren und beheben Sie die Ursache des Überstroms, bevor Sie die Sicherung ersetzen", + "Ersetzen Sie die Sicherung mit der richtigen Größe und starten Sie dann den Wechselrichter neu" + ] + }, + "DcInputVoltageTooHigh": { + "Explanation": "Die DC-Eingangsspannung vom PV-Array überschreitet die maximale sichere Eingangsspannung des Wechselrichters. Dies kann den Wechselrichter sofort beschädigen.", + "Causes": [ + "Zu viele PV-Module in Reihe geschaltet, wodurch die maximale String-Spannung überschritten wird", + "Kälte erhöht die Modul-Leerlaufspannung (Voc) über die Wechselrichtergrenze", + "Planungsfehler – String wurde falsch für diesen Wechselrichter dimensioniert" + ], + "NextSteps": [ + "Schalten Sie den DC-Schalter sofort aus, um den Wechselrichter zu schützen", + "Messen Sie die tatsächliche DC-Spannung, bevor Sie wieder anschließen", + "Überprüfen Sie die String-Planung – stellen Sie sicher, dass die Voc bei der erwarteten Mindesttemperatur die Wechselrichtergrenze nicht überschreitet", + "Konfigurieren Sie den String neu, indem Sie die Module in Reihe reduzieren, falls erforderlich" + ] + }, + "PvReversed": { + "Explanation": "Die PV-String-Polarität ist vertauscht – positive und negative Anschlüsse sind vertauscht.", + "Causes": [ + "PV-String-Kabel sind mit vertauschter Polarität am Wechselrichter oder Kasten angeschlossen", + "Installationsfehler bei der anfänglichen Verkabelung" + ], + "NextSteps": [ + "Schalten Sie alle DC-Trennvorrichtungen aus, bevor Sie an der Verkabelung arbeiten", + "Identifizieren Sie die vertauschte Verbindung – prüfen Sie die PV-String-Polarität mit einem Multimeter", + "Vertauschen Sie die positiven und negativen Anschlüsse, um die Polarität zu korrigieren, bevor Sie neu starten" + ] + }, + "PidFunctionAbnormal": { + "Explanation": "Die PID (Potential Induced Degradation)-Schutzfunktion ist gestört.", + "Causes": [ + "PID-Modulfehler oder Konfigurationsfehler", + "Kommunikationsproblem zwischen Wechselrichter und PID-Modul" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu – dies behebt oft vorübergehende PID-Fehler", + "Prüfen Sie die PID-Moduleinstellungen und -verbindungen, wenn das Problem nach dem Neustart weiterhin besteht" + ] + }, + "PvStringDisconnected": { + "Explanation": "Ein PV-String ist getrennt oder liefert keinen Strom.", + "Causes": [ + "Der DC-Trenner oder Isolator für diesen String ist ausgeschaltet", + "Ein Kabel ist gelöst oder getrennt an einem Stecker", + "Defekt am MC4-Stecker" + ], + "NextSteps": [ + "Prüfen, ob alle PV-String-Trenner eingeschaltet sind", + "Kabelverbindungen an beiden Enden (Panel und Wechselrichter) überprüfen", + "Lose Verbindungen wieder anschließen und den Wechselrichter neu starten" + ] + }, + "PvStringCurrentUnbalanced": { + "Explanation": "Die Ströme der verschiedenen PV-Strings sind deutlich unausgeglichen, was darauf hindeutet, dass ein String schlechter arbeitet als die anderen.", + "Causes": [ + "Beschattung einiger Module in einem String, aber nicht in anderen", + "Modul-Unterschiede oder Verschlechterung in einem Teil der Anlage", + "Teilweiser String-Ausfall — einige Module tragen nicht bei", + "Verschmutzung oder Vogeldreck auf den Panelen in einem Bereich" + ], + "NextSteps": [ + "Alle PV-Paneele auf Beschattung, Verschmutzung oder sichtbare Schäden prüfen", + "String-Spannungen und -Ströme einzeln vergleichen, um den unterdurchschnittlichen String zu identifizieren", + "Paneele reinigen, wenn Verschmutzung sichtbar ist, und auf neue Beschattungsquellen prüfen" + ] + }, + "NoUtilityGrid": { + "Explanation": "Keine Verbindung zum Stromnetz wird erkannt oder das Netz ist ausgefallen.", + "Causes": [ + "Stromnetzausfall in Ihrer Gegend", + "Der AC-Leistungsschalter zwischen Wechselrichter und Netz ist ausgeschaltet", + "AC-Netzkabel am Wechselrichter oder Verteilerkasten getrennt", + "Wartungsarbeiten des Netzbetreibers, die die lokale Stromversorgung trennen" + ], + "NextSteps": [ + "Prüfen, ob andere Geräte im Gebäude Netzstrom haben — wenn nicht, handelt es sich um einen Netzausfall", + "Überprüfen, ob der AC-Leistungsschalter eingeschaltet ist und nicht ausgelöst hat", + "AC-Kabelverbindungen am Wechselrichter prüfen", + "Warten, bis der Netzbetreiber den Strom wiederherstellt, wenn es sich um einen Netzausfall handelt" + ] + }, + "GridVoltageOutOfRange": { + "Explanation": "Die Netzspannung liegt außerhalb des Bereichs, in dem der Wechselrichter betrieben werden darf.", + "Causes": [ + "Die Netzspannung ist an Ihrem Anschlusspunkt zu hoch oder zu niedrig", + "Lokale Netzprobleme wie Überlastung oder Transformatorprobleme", + "Transformator-Anzapfung nicht optimal für Ihren Standort" + ], + "NextSteps": [ + "Die tatsächliche Netzspannung an den Wechselrichterklemmen prüfen", + "Wenn die Netzspannung dauerhaft außerhalb des Bereichs liegt, den Netzbetreiber kontaktieren", + "Der Wechselrichter verbindet sich automatisch wieder, wenn die Spannung wieder normal ist" + ] + }, + "GridFrequencyOutOfRange": { + "Explanation": "Die Netzfrequenz liegt außerhalb des Bereichs, in dem der Wechselrichter betrieben werden darf.", + "Causes": [ + "Netzfrequenz instabil aufgrund von Hochlastereignissen im Netz", + "Wenn ein Generator verwendet wird, ist die Generatorfrequenz außerhalb der Toleranz gedriftet", + "Netzstörungsereignis" + ], + "NextSteps": [ + "Die tatsächliche Netzfrequenz am Wechselrichter prüfen", + "Wenn ein Generator verwendet wird, den Regler anpassen, um die Ausgangsfrequenz zu korrigieren", + "Warten, bis sich das Netz stabilisiert — der Wechselrichter verbindet sich automatisch wieder" + ] + }, + "Overload": { + "Explanation": "Das System ist überlastet — es wird mehr Strom angefordert, als der Wechselrichter an den Notstromausgang (EPS) liefern kann.", + "Causes": [ + "Die Gesamtlast am EPS-Ausgang überschreitet die Notstromkapazität des Wechselrichters", + "Anlaufstrom von Geräten mit Motoren oder Kompressoren", + "Kurzschluss in einer der Notstromlasten" + ], + "NextSteps": [ + "Reduzieren Sie die Last am EPS-Ausgang, indem Sie nicht essentielle Geräte ausschalten", + "Überprüfen Sie auf defekte Geräte, die möglicherweise übermäßigen Strom ziehen", + "Starten Sie große Geräte gestaffelt, um den Anlaufstrom zu reduzieren" + ] + }, + "MeterDisconnected": { + "Explanation": "Der Stromzähler hat die Verbindung zum Wechselrichter verloren.", + "Causes": [ + "Der Stromzähler ist ausgeschaltet oder hat keinen Strom", + "Das Kommunikationskabel zwischen Wechselrichter und Zähler ist beschädigt oder getrennt", + "Kommunikationsanschluss des Zählers defekt" + ], + "NextSteps": [ + "Überprüfen Sie, ob der Stromzähler Strom hat und eingeschaltet ist", + "Prüfen Sie die Kommunikationskabelverbindungen am Wechselrichter und am Zähler", + "Überprüfen Sie die Stromversorgung und den Kommunikationsanschluss des Zählers" + ] + }, + "MeterReverselyConnected": { + "Explanation": "Die L (Phase) und N (Neutralleiter) des Stromzählers sind vertauscht.", + "Causes": [ + "L und N während der Installation vertauscht", + "Installationsfehler — häufig, wenn die Zählerpolarität nicht überprüft wurde" + ], + "NextSteps": [ + "Lassen Sie einen qualifizierten Elektriker die Zählerverkabelung überprüfen und korrigieren", + "Tauschen Sie die L- und N-Anschlüsse am Zählerterminal, um die Polarität zu korrigieren" + ] + }, + "LinePeVoltageAbnormal": { + "Explanation": "Abnormale Spannung zwischen dem Neutralleiter (N) und dem Schutzleiter (PE) wurde erkannt. Dies kann auf einen Erdungs- oder Verdrahtungsfehler hinweisen.", + "Causes": [ + "Schlechte oder fehlende PE (Schutzleiter)-Verbindung", + "N und PE sind irgendwo in der Installation kurzgeschlossen", + "Erdschluss in der Gebäudeverkabelung" + ], + "NextSteps": [ + "Schalten Sie das System vor der Inspektion der Verkabelung aus", + "Überprüfen Sie, ob der PE (Erdungs)-Kabel zuverlässig am Wechselrichter und Verteilerkasten angeschlossen ist", + "Überprüfen Sie die Erdungsanlage — lassen Sie bei Bedarf einen qualifizierten Elektriker untersuchen" + ] + }, + "PhaseSequenceError": { + "Explanation": "Ein Phasenfolgefehler wurde in der Dreiphasenverbindung erkannt. Der Wechselrichter wird versuchen, dies automatisch zu korrigieren.", + "Causes": [ + "Dreiphasenkabel in falscher Reihenfolge (L1, L2, L3 vertauscht) angeschlossen" + ], + "NextSteps": [ + "Keine sofortige Aktion erforderlich — der Wechselrichter wird die Phasenfolge automatisch anpassen", + "Falls der Alarm anhält, lassen Sie einen Elektriker die Phasenverkabelung überprüfen und korrigieren" + ] + }, + "FanFailure": { + "Explanation": "Ein Ausfall des Kühlgebläses wurde erkannt. Ohne ausreichende Kühlung wird der Wechselrichter überhitzen und sich abschalten.", + "Causes": [ + "Ausfall des Lüftermotors – Lüfter dreht sich nicht mehr", + "Lüfterblätter durch Schmutz oder Fremdkörper blockiert", + "Lüfterstromanschluss locker oder getrennt", + "Störung im Lüftersteuerkreis" + ], + "NextSteps": [ + "Wechselrichter vor der Lüfterprüfung ausschalten", + "Prüfen, ob sich der Lüfter frei dreht und nicht blockiert ist", + "Überprüfen, ob der Lüfterstromanschluss fest sitzt", + "Lüfter ersetzen, falls er ausgefallen ist – Wechselrichter ohne Kühlung nicht betreiben" + ] + }, + "MeterAbnormal": { + "Explanation": "Der Energiemesser zeigt ungewöhnliche Werte an.", + "Causes": [ + "Messer defekt oder interner Fehler", + "Falsche Messereinstellung oder Skalierung", + "Kommunikationsproblem führt zu Datenfehlern" + ], + "NextSteps": [ + "Prüfen, ob der Messer eingeschaltet ist und funktioniert", + "Überprüfen, ob die Messereinstellungen mit den Wechselrichtereinstellungen übereinstimmen (Stromwandlerverhältnis, Kommunikationsprotokoll)" + ] + }, + "OptimizerCommunicationAbnormal": { + "Explanation": "Die Kommunikation mit einem PV-Moduloptimierer ist ausgefallen.", + "Causes": [ + "Optimierer ist ausgeschaltet oder erhält keine PV-Spannung", + "Kommunikationsstörung in der Stromleitung", + "Hardwaredefekt des Optimierers" + ], + "NextSteps": [ + "Prüfen, ob der Optimierer PV-Spannung erhält und eingeschaltet ist", + "Überprüfen der Kommunikationsverbindung zwischen Wechselrichter und Optimierern", + "Optimierer ersetzen, falls er defekt ist" + ] + }, + "OverTemperature": { + "Explanation": "Die Temperatur des Wechselrichters hat den normalen Betriebsbereich überschritten. Die Leistung wird reduziert, um die Hardware zu schützen.", + "Causes": [ + "Schlechte Belüftung – heiße Luft um den Wechselrichter eingeschlossen", + "Hohe Umgebungstemperatur am Installationsort", + "Lüfterausfall reduziert die Luftzirkulation im Wechselrichter", + "Überlastung führt zu erhöhter Wärmeentwicklung" + ], + "NextSteps": [ + "Wechselrichter nach Abkühlung neu starten", + "Belüftung verbessern – ausreichend Freiraum um den Wechselrichter lassen", + "Prüfen, ob der Kühllüfter einwandfrei läuft", + "Hersteller kontaktieren, falls die Störung trotz guter Belüftung anhält" + ] + }, + "OverTemperatureAlarm": { + "Explanation": "Der Wechselrichter hat eine erhöhte Temperaturwarnung erkannt – dies ist eine Vorwarnung vor dem thermischen Abschalten.", + "Causes": [ + "Hohe Umgebungstemperatur im Aufstellungsraum", + "Schlechte Luftzirkulation oder verstopfte Belüftung um den Wechselrichter", + "Hohe Last bei heißem Wetter", + "Kühllüfter läuft mit reduzierter Geschwindigkeit oder unregelmäßig" + ], + "NextSteps": [ + "Belüftung um den Wechselrichter sofort verbessern", + "Last vorübergehend reduzieren, um dem Wechselrichter Abkühlung zu ermöglichen", + "Lüfterfunktion prüfen und verstopfte Lüftungsschlitze freimachen", + "Temperatur überwachen, bis sie unter den Warnschwellenwert sinkt" + ] + }, + "NtcTemperatureSensorBroken": { + "Explanation": "Der NTC-Temperatursensor im Wechselrichter ist defekt oder getrennt.", + "Causes": [ + "Der NTC-Sensor ist durch Alterung oder mechanische Beschädigung ausgefallen", + "Das Sensorkabel ist beschädigt oder vom Board getrennt", + "Der Sensorstecker hat sich vom PCB gelöst" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu — wenn der Sensor wirklich defekt ist, bleibt die Warnung nach dem Neustart bestehen", + "Falls die Warnung anhält, muss ein Techniker den NTC-Sensor im Wechselrichter überprüfen und ersetzen" + ] + }, + "SyncSignalAbnormal": { + "Explanation": "Das Synchronisationssignal zwischen parallel geschalteten Wechselrichtern ist abnormal.", + "Causes": [ + "Das Synchronisationskabel zwischen den parallel geschalteten Wechselrichtern ist beschädigt oder getrennt", + "Kommunikationsschnittstelle für Synchronisation ist defekt", + "Konfigurationsunterschiede zwischen den Einheiten" + ], + "NextSteps": [ + "Überprüfen Sie die Synchronisationskabelverbindungen zwischen allen parallel geschalteten Wechselrichtereinheiten", + "Stellen Sie sicher, dass die Parallelkommunikationseinstellungen auf allen Einheiten übereinstimmen", + "Ersetzen Sie das Kabel, falls es beschädigt ist" + ] + }, + "GridStartupConditionsNotMet": { + "Explanation": "Die Startbedingungen für den Netzanschluss sind nicht erfüllt. Der Wechselrichter wartet, bis das Netz die erforderlichen Parameter erfüllt, bevor er sich verbindet.", + "Causes": [ + "Netzspannung oder -frequenz liegt außerhalb des zulässigen Bereichs für den Anschluss", + "Die Netzstartspannungsschwelle ist falsch konfiguriert" + ], + "NextSteps": [ + "Überprüfen Sie, ob die Netzspannung im zulässigen Betriebsbereich des Wechselrichters liegt", + "Überprüfen Sie die Konfigurationseinstellungen für Netzanschluss-Spannung und -frequenz" + ] + }, + "BatteryCommunicationFailure": { + "Explanation": "Der Wechselrichter kann nicht mit dem Batterie-BMS (Batteriemanagementsystem) kommunizieren. Ohne BMS-Kommunikation kann das Laden und Entladen nicht sicher gesteuert werden.", + "Causes": [ + "Das Batterie-BMS ist offline oder ausgeschaltet", + "Das RS485- oder CAN-Kommunikationskabel zwischen Wechselrichter und Batterie ist defekt oder getrennt", + "Kommunikationsprotokoll zwischen Wechselrichter und Batterie passt nicht zusammen", + "Batterie im Ruhezustand — BMS hat den Energiesparmodus aktiviert" + ], + "NextSteps": [ + "Stellen Sie sicher, dass das Batteriesystem eingeschaltet ist und nicht im Ruhezustand", + "Überprüfen Sie das RS485-Kommunikationskabel zwischen Wechselrichter und Batterie auf Schäden", + "Stellen Sie sicher, dass die Batteriekommunikationsprotokolleinstellung im Wechselrichter mit dem Batterie-BMS übereinstimmt", + "Wecken Sie die Batterie aus dem Ruhezustand, indem Sie die Batteriestromtaste drücken" + ] + }, + "BatteryDisconnected": { + "Explanation": "Die Batterie ist nicht mit dem Wechselrichter verbunden. Das System läuft ohne Batteriespeicher.", + "Causes": [ + "Der Batterie-Leistungsschalter oder Trennschalter ist ausgeschaltet", + "Das Batteriekabel hat sich gelöst oder wurde getrennt", + "Das BMS hat die Batterie aufgrund eines Schutzereignisses abgeschaltet", + "Hardwarefehler der Batterie verhindert die Verbindung" + ], + "NextSteps": [ + "Überprüfen Sie, ob der Batterie-Leistungsschalter eingeschaltet ist", + "Überprüfen Sie die Batteriekabelverbindungen an den Wechselrichter- und Batterieanschlüssen", + "Überprüfen Sie die BMS-Statusanzeigen auf Fehler- oder Schutzcodes", + "Beheben Sie alle BMS-Schutzereignisse, bevor Sie die Batterie wieder anschließen" + ] + }, + "BatteryVoltageTooHigh": { + "Explanation": "Die Batteriespannung liegt über dem zulässigen Maximum. Das Laden könnte die Spannung über die sicheren Grenzen hinaus erhöht haben.", + "Causes": [ + "Die Batterie wurde über das maximale Spannungslimit hinaus aufgeladen", + "Ein BMS-Fehler hat es zugelassen, dass die Spannung zu hoch ansteigt", + "Zellungleichgewicht führt dazu, dass einzelne Zellen überladen werden", + "Falsche maximale Ladespannungseinstellung im Wechselrichter" + ], + "NextSteps": [ + "Überprüfen Sie die Batteriespannung und vergleichen Sie sie mit der maximalen Herstellerangabe", + "Stellen Sie die Ladespannungseinstellungen im Wechselrichter ein", + "Prüfen Sie die BMS-Funktion – das BMS sollte vor Überspannung schützen" + ] + }, + "BatteryVoltageTooLow": { + "Explanation": "Die Batteriespannung liegt unter dem zulässigen Minimum. Die Batterie ist tief entladen.", + "Causes": [ + "Die Batterie wurde unter die minimale sichere Spannung entladen", + "Einzelne Batteriezellen sind defekt und senken die Packspannung", + "Hohe Last entlädt die Batterie schneller, als sie geladen werden kann", + "Die BMS-Unterspannungsabschaltung wurde aktiviert" + ], + "NextSteps": [ + "Überprüfen Sie die Batteriespannung und vergleichen Sie sie mit der minimalen Herstellerangabe", + "Lassen Sie die Batterie wieder aufladen – zunächst mit Netzstrom, falls Solarstrom nicht ausreicht", + "Bei extrem niedriger Spannung benötigt die Batterie möglicherweise eine professionelle Wiederherstellungsladung" + ] + }, + "BatteryReverseConnected": { + "Explanation": "Die Batterie ist mit vertauschten Polen angeschlossen. Dies ist gefährlich und kann sofortige Schäden verursachen.", + "Causes": [ + "Batterie-Pol und Minuspol wurden bei der Installation vertauscht angeschlossen", + "Installationsfehler – ein schwerwiegender Verdrahtungsfehler" + ], + "NextSteps": [ + "SCHALTEN SIE SOFORT das gesamte System ab – laden oder entladen Sie nicht", + "Überprüfen Sie alle Batteriekabelanschlüsse, bevor Sie etwas anfassen", + "Lassen Sie einen qualifizierten Elektriker die Batteriepolung überprüfen und korrigieren", + "Prüfen Sie auf Schäden an Kabeln, Sicherungen oder dem Wechselrichter, bevor Sie das System wieder starten" + ] + }, + "LeadAcidTempSensorDisconnected": { + "Explanation": "Der Temperatursensor der Bleibatterie ist nicht angeschlossen oder nicht installiert.", + "Causes": [ + "Der Temperatursensor wurde nicht mit der Batterie installiert", + "Das Sensorenkabel ist locker oder beschädigt", + "Der Sensorstecker wurde von der Batterie oder dem Wechselrichter gezogen" + ], + "NextSteps": [ + "Überprüfen Sie, ob ein Temperatursensor an der Bleibatterie installiert ist – er ist typischerweise eine kleine Sonde, die an der Batterie befestigt ist", + "Überprüfen Sie die Sensorenkabelverbindungen an beiden Enden", + "Installieren oder verbinden Sie den Sensor gemäß den Installationsanweisungen" + ] + }, + "BatteryTemperatureOutOfRange": { + "Explanation": "Die Batterietemperatur liegt außerhalb des sicheren Bereichs für Laden oder Entladen.", + "Causes": [ + "Hohe Umgebungstemperatur im Batterieinstallationsbereich", + "Schlechte Batteriebelüftung führt zu Hitzestau", + "Batterie überhitzt während starkem Laden oder Entladen", + "Sehr kalte Umgebungstemperatur im Winter reduziert die Batterieleistung" + ], + "NextSteps": [ + "Überprüfen Sie die Umgebungstemperatur im Batterieinstallationsbereich", + "Verbessern Sie die Batteriebelüftung oder verlegen Sie die Batterie an einen kühleren Ort, falls sie überhitzt", + "In kalten Klimazonen stellen Sie sicher, dass die Batterie nicht Frost ausgesetzt ist – unter 0°C ist Ladevorgang normalerweise nicht erlaubt" + ] + }, + "BmsFault": { + "Explanation": "Das Batterie-BMS hat einen Fehler gemeldet, der das normale Laden und Entladen verhindert.", + "Causes": [ + "Interne BMS-Störung oder Schutzauslösung durch die Batterie", + "Einzelzellenschutz wurde aufgrund von Über- oder Unterspannung oder Temperatur aktiviert", + "BMS-Kommunikationsfehler führt zu Fehlermeldung" + ], + "NextSteps": [ + "Überprüfen Sie das Batteriesystem-Display oder die Anzeigelichter auf einen BMS-spezifischen Fehler oder Fehlercode", + "Beziehen Sie sich auf die Dokumentation des Batterieherstellers für den spezifischen BMS-Fehlercode", + "Kontaktieren Sie den Batteriesupport, wenn der BMS-Fehler nicht durch einen Neustart behoben werden kann" + ] + }, + "LithiumBatteryOverload": { + "Explanation": "Der Überlastschutz der Lithiumbatterie wurde aktiviert – die Last entnimmt mehr Strom, als die Batterie abgeben kann.", + "Causes": [ + "Die Gesamtlastleistung überschreitet die maximale Entladeleistung der Batterie", + "Hochstrom beim Einschalten großer Motoren oder Kompressoren übersteigt vorübergehend die Batteriegrenzen" + ], + "NextSteps": [ + "Überprüfen Sie die Gesamtlastleistung und vergleichen Sie sie mit der Nennentladeleistung der Batterie", + "Reduzieren Sie die Last, indem Sie Hochleistungsgeräte ausschalten", + "Starten Sie große Geräte gestaffelt, um den Spitzenbedarf zu reduzieren" + ] + }, + "BmsCommunicationAbnormal": { + "Explanation": "Die Kommunikation mit dem BMS ist gestört – Daten werden unregelmäßig oder mit Fehlern empfangen.", + "Causes": [ + "Kommunikationszeitüberschreitung aufgrund von Kabelqualität oder -länge", + "Protokollfehler oder falsche Baudrate", + "Physischer Kabeldefekt führt zu unterbrochener Verbindung" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu, um die Kommunikation wiederherzustellen", + "Überprüfen Sie das BMS-Kommunikationskabel auf Schäden oder lockere Verbindungen", + "Stellen Sie sicher, dass die Kommunikationsparameter (Protokoll, Baudrate) zwischen Wechselrichter und BMS übereinstimmen" + ] + }, + "BatterySpdAbnormal": { + "Explanation": "Die Funktion des Überspannungsschutzes (SPD) auf der Batterieseite ist gestört.", + "Causes": [ + "Der Batterie-SPD wurde durch einen Spannungsstoß ausgelöst", + "SPD ist defekt oder hat seine Lebensdauer erreicht", + "Blitzinduzierter Spannungsstoß in der Batterieverkabelung" + ], + "NextSteps": [ + "Schalten Sie das System aus und überprüfen Sie die Anzeige des Batterie-SPD", + "Ersetzen Sie den SPD, wenn dieser einen ausgelösten oder fehlerhaften Zustand anzeigt", + "Starten Sie das System nach dem Austausch neu" + ] + }, + "OutputDcComponentBiasAbnormal": { + "Explanation": "Eine DC-Versatzkomponente im Ausgang ist abnormal, was empfindliche angeschlossene Geräte beeinträchtigen könnte.", + "Causes": [ + "Regelkreisdrift führt zu DC-Offset im Wechselstromausgang", + "Sensor-Kalibrierungsdrift bei der Ausgangsmessung", + "Hardwarefehler in der Ausgangsstufe" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu – DC-Versatzfehler verschwinden oft nach einem Neustart", + "Wenn der Fehler besteht, kontaktieren Sie den Hersteller für Service" + ] + }, + "DcComponentOverHighOutputVoltage": { + "Explanation": "Die Gleichspannungskomponente in der Ausgangsspannung ist zu hoch. Dies kann empfindliche Geräte beeinträchtigen und deutet auf ein Steuerungsproblem hin.", + "Causes": [ + "Steuerkreisdrift, der zu einer Gleichspannungsverschiebung in der Ausgangsspannung führt", + "Fehler des Ausgangsspannungssensors", + "Transformatorsättigung oder Problem im Gleichstrompfad" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu, um die Steuerkreise zurückzusetzen", + "Überprüfen Sie die Ausgangsspannung auf Gleichspannungsverschiebung, falls Geräte betroffen sind" + ] + }, + "OffGridOutputVoltageTooLow": { + "Explanation": "Die netzunabhängige (EPS/Backup-)Ausgangsspannung ist zu niedrig, um angeschlossene Verbraucher ordnungsgemäß zu versorgen.", + "Causes": [ + "Die Last übersteigt die Backup-Kapazität des Wechselrichters, was zu einem Spannungsabfall führt", + "Die Batteriespannung ist zu niedrig, um eine stabile Ausgangsspannung aufrechtzuerhalten", + "Interne Wechselrichterbegrenzung" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu", + "Reduzieren Sie die Last am Backup-Ausgang", + "Lassen Sie die Batterie aufladen, wenn der Ladezustand niedrig ist", + "Wenn der Fehler weiterhin besteht, wenden Sie sich an den Hersteller" + ] + }, + "OffGridOutputVoltageTooHigh": { + "Explanation": "Die netzunabhängige Ausgangsspannung ist zu hoch, was angeschlossene Geräte beschädigen könnte.", + "Causes": [ + "Steuerungsfehler, der dazu führt, dass die Ausgangsspannungsregelung zu hoch ausfällt", + "Spannungsreferenzfehler im Steuersystem" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu", + "Wenn der Fehler weiterhin besteht, wenden Sie sich sofort an den Hersteller, da eine hohe Ausgangsspannung Geräte beschädigen kann" + ] + }, + "OffGridOutputOverCurrent": { + "Explanation": "Der netzunabhängige Ausgangsstrom überschreitet die Überstromgrenze.", + "Causes": [ + "Gesamtlaststrom übersteigt die Nennstromstärke des Wechselrichters für den Backup-Ausgang", + "Kurzschluss in einem der Backup-Verbraucher", + "Anlaufstrom eines großen Motors" + ], + "NextSteps": [ + "Überprüfen Sie, ob alle Verbraucher am Backup-Ausgang innerhalb der Stromspezifikation des Wechselrichters liegen", + "Trennen Sie die Verbraucher nacheinander, um ein defektes Gerät zu identifizieren", + "Reparieren oder entfernen Sie den überlastenden Verbraucher, bevor Sie den Wechselrichter neu starten" + ] + }, + "OffGridOutputOverload": { + "Explanation": "Der netzunabhängige (EPS/Backup)-Ausgang ist überlastet — es wird mehr Strom angefordert, als der Wechselrichter im Backup-Modus liefern kann.", + "Causes": [ + "Die Gesamtlast am EPS-Ausgang überschreitet die Backup-Kapazität des Wechselrichters", + "Zu viele Geräte sind gleichzeitig an den Backup-Stromkreis angeschlossen", + "Ein großer Motor oder Kompressor verursacht einen zu hohen Einschaltstrom" + ], + "NextSteps": [ + "Überprüfen, ob alle Verbraucher innerhalb der EPS-Ausgangsspezifikation des Wechselrichters liegen", + "Die Anzahl der Geräte am Backup-Stromkreis reduzieren", + "Das Einschalten großer Geräte während des Backup-Betriebs staffeln" + ] + }, + "BalancedCircuitAbnormal": { + "Explanation": "Der Phasenausgleichsschaltkreis arbeitet nicht normal.", + "Causes": [ + "Interne Störung im Phasenausgleichsschaltkreis", + "Steuerungsproblem, das den Phasenausgleich beeinflusst" + ], + "NextSteps": [ + "Den Wechselrichter neu starten", + "Falls der Fehler besteht, Phasenausgleichseinstellungen prüfen und Service kontaktieren" + ] + }, + "ExportLimitationFailSafe": { + "Explanation": "Die Exportbegrenzung-Notauslösung wurde aktiviert. Der Wechselrichter speist keinen Strom mehr ins Netz, da er die Einhaltung der Exportgrenzen nicht überprüfen kann.", + "Causes": [ + "Der Stromwandler (CT) ist getrennt oder misst falsch", + "Die Kommunikation mit dem Zähler ist unterbrochen, wodurch die Exportüberwachung nicht möglich ist", + "Die Rückkopplung der Exportbegrenzung ist ausgefallen — der Wechselrichter kann nicht bestätigen, dass der Netzexport kontrolliert wird" + ], + "NextSteps": [ + "Das System vor der Inspektion der CT- oder Zählerverbindungen ausschalten", + "Prüfen, ob der Stromwandler (CT) korrekt installiert und sicher verbunden ist", + "Überprüfen, ob das Kommunikationskabel des Energiemessgeräts intakt ist", + "Exportbegrenzungseinstellungen und Rückkopplung bestätigen, dann neu starten" + ] + }, + "DcBiasAbnormal": { + "Explanation": "Der DC-Einspeise-Schutz (DCI) hat eine abnormale DC-Vorspannung im AC-Ausgang erkannt — ein Sicherheitsmechanismus, der verhindert, dass DC in das Netz eingespeist wird.", + "Causes": [ + "DC-Einspeisung ins Netz vom Wechselrichterausgang", + "Ausgangsstromsensor defekt und liefert falsche Messwerte", + "Transformatorsättigung oder Steuerungsproblem" + ], + "NextSteps": [ + "Den Wechselrichter neu starten — dies behebt manchmal vorübergehende DCI-Fehler", + "Falls der Fehler besteht, ist ein professioneller Service erforderlich" + ] + }, + "HighDcComponentOutputCurrent": { + "Explanation": "Hohe DC-Komponente im AC-Ausgangsstrom erkannt. Dies ist ein Schutzzustand.", + "Causes": [ + "Ausgangsfilterproblem, das DC-Komponenten durchlässt", + "Steuerungsfehler, der die Stromwellenform-Symmetrie beeinflusst", + "Ausgangstransformator-Sättigung" + ], + "NextSteps": [ + "Den Wechselrichter neu starten", + "Die Qualität der Ausgangsstromwellenform prüfen, falls Messgeräte verfügbar sind", + "Falls der Fehler besteht, den Hersteller für Service kontaktieren" + ] + }, + "BusVoltageSamplingAbnormal": { + "Explanation": "Die Messung der Gleichspannung ist fehlerhaft — der Sensor liefert falsche Werte.", + "Causes": [ + "Defekter Spannungssensor oder Messkreis", + "Fehler im ADC (Analog-Digital-Wandler) der Steuerplatine", + "Hardwareproblem, das die Messgenauigkeit beeinträchtigt" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Bei anhaltendem Fehler ist eine professionelle Wartung des Messkreises erforderlich" + ] + }, + "RelayFault": { + "Explanation": "Ein interner Relaisfehler wurde erkannt. Das Relais funktioniert nicht wie erwartet.", + "Causes": [ + "Relais defekt — Kontakte offen oder geschlossen", + "Kontaktverschweißung durch Überstrom", + "Fehler im Relais-Ansteuerkreis" + ], + "NextSteps": [ + "Wechselrichter neu starten, um das Relais zurückzusetzen", + "Wenn der Fehler besteht, muss das Relais wahrscheinlich ersetzt werden — Service kontaktieren" + ] + }, + "BusVoltageAbnormal": { + "Explanation": "Die interne Gleichspannung ist abnormal.", + "Causes": [ + "Fehler in der Leistungselektronik, der die Gleichspannungsregelung beeinflusst", + "Problem mit dem Kondensator im Gleichspannungskreis", + "Ausfall des Steuersystems" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Bei anhaltendem Fehler ist eine professionelle Inspektion des Systems erforderlich" + ] + }, + "InternalCommunicationFailure": { + "Explanation": "Die interne Kommunikation zwischen den Steuerplatine im Wechselrichter ist ausgefallen.", + "Causes": [ + "Fehler oder Ausfall der Kommunikationsplatine", + "Internes Flachbandkabel oder Stecker ist gelöst", + "Elektromagnetische Störungen (EMI) beeinträchtigen die interne Kommunikation" + ], + "NextSteps": [ + "Wechselrichter ausschalten, 30 Sekunden warten und dann neu starten, um zu prüfen, ob die Kommunikation wiederhergestellt wird", + "Bei anhaltendem Fehler sollte ein Techniker den Wechselrichter öffnen und die internen Kommunikationskabelverbindungen prüfen" + ] + }, + "TemperatureSensorDisconnected": { + "Explanation": "Ein Temperatursensor im Wechselrichter ist getrennt, wodurch die thermische Überwachung nicht mehr funktioniert.", + "Causes": [ + "Sensor-Element ist defekt oder hat sich von der Halterung gelöst", + "Sensor-Kabel ist beschädigt oder getrennt", + "Sensor-Stecker ist von der Leiterplatte gezogen" + ], + "NextSteps": [ + "Wechselrichter ausschalten und interne Sensorverkabelung prüfen, falls zugänglich", + "Wenn nicht zugänglich, einen Servicetechniker kontaktieren, um den Sensor zu prüfen und auszutauschen" + ] + }, + "IgbtDriveFault": { + "Explanation": "Ein Fehler in der IGBT-Ansteuerung wurde erkannt. Der IGBT wird nicht korrekt angesteuert, was die Stromumwandlung beeinträchtigen kann.", + "Causes": [ + "Ausfall der Ansteuerschaltung", + "IGBT-Transistor defekt — Bauteil könnte ausgefallen sein", + "Stromversorgungsproblem der Ansteuerung" + ], + "NextSteps": [ + "Wechselrichter neu starten — vorübergehende Fehler können sich beheben", + "Bei anhaltendem Fehler: Fachdienstleistung erforderlich — IGBT oder Ansteuerung muss ersetzt werden" + ] + }, + "EepromError": { + "Explanation": "Ein Lese- oder Schreibfehler im EEPROM ist aufgetreten. Der nichtflüchtige Speicher des Wechselrichters funktioniert nicht richtig.", + "Causes": [ + "EEPROM-Chip defekt — häufig nach vielen Betriebsjahren", + "Datenbeschädigung im EEPROM-Speicher", + "Hardwareausfall der Speicherschaltung" + ], + "NextSteps": [ + "Wechselrichter neu starten — dies kann einen vorübergehenden Speicherfehler beheben", + "Bei anhaltendem Fehler: Werkseinstellung kann die Funktion wiederherstellen; vor dem Versuch Support kontaktieren" + ] + }, + "AuxiliaryPowerAbnormal": { + "Explanation": "Die interne Hilfsstromversorgung ist abnormal. Diese versorgt die Steuerungselektronik.", + "Causes": [ + "Ausfall eines Bauteils der Hilfsstromversorgung", + "Fehler im Spannungsregler der Steuerplatine" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Bei anhaltendem Fehler: Service kontaktieren — die Hilfsstromversorgung muss möglicherweise ersetzt werden" + ] + }, + "DcAcOvercurrentProtection": { + "Explanation": "Der DC/AC-Überstromschutz wurde ausgelöst — der Strom hat den sicheren Grenzwert überschritten.", + "Causes": [ + "Kurzschluss in der AC-Ausgangsverkabelung oder angeschlossenen Lasten", + "Schwere Überlastung weit über der Nennleistung", + "Fehler in der Leistungselektronik, der Überstrom verursacht" + ], + "NextSteps": [ + "Wechselrichter nach Überprüfung und Beseitigung möglicher Kurzschlüsse neu starten", + "Alle angeschlossenen Lasten auf Fehler prüfen", + "Last reduzieren, bevor der Wechselrichter neu gestartet wird" + ] + }, + "CommunicationProtocolMismatch": { + "Explanation": "Ein Protokollfehler zwischen den Komponenten wurde erkannt.", + "Causes": [ + "Firmware-Versionen der Steuerplatine stimmen nicht überein", + "Fehlerhafte Kommunikationskonfiguration" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Bei anhaltendem Fehler: Vollständiges Firmware-Update durchführen, um sicherzustellen, dass alle Komponenten auf der gleichen Version sind" + ] + }, + "DspComFirmwareMismatch": { + "Explanation": "Die Firmware-Versionen des DSP (Signalprozessors) und des COM (Kommunikations)-Boards stimmen nicht überein.", + "Causes": [ + "Firmware-Update war unvollständig, sodass die Boards unterschiedliche Versionen haben", + "Falsche Firmware-Datei wurde auf eines der Boards geladen" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Vollständiges Firmware-Update durchführen – alle Boards auf die korrekte, passende Version aktualisieren" + ] + }, + "DspSoftwareHardwareMismatch": { + "Explanation": "Die DSP-Software-Version ist mit der Hardware-Version nicht kompatibel.", + "Causes": [ + "Hardware-Board wurde durch eine neuere oder ältere Revision ersetzt, die eine andere Firmware-Version erfordert" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Technischen Support kontaktieren, um die korrekte Firmware-Version für diese Hardware-Revision zu ermitteln" + ] + }, + "CpldAbnormal": { + "Explanation": "Das CPLD (Complex Programmable Logic Device) im Wechselrichter funktioniert nicht richtig.", + "Causes": [ + "CPLD-Chip defekt oder Firmware beschädigt", + "Stromversorgungsproblem, das das CPLD beeinflusst" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Bei anhaltendem Problem: Professionelle Wartung erforderlich – CPLD muss ersetzt oder neu programmiert werden" + ] + }, + "RedundancySamplingInconsistent": { + "Explanation": "Die redundanten Spannungs- oder Strommesskreise liefern unterschiedliche Ergebnisse – die beiden Messpfade stimmen nicht überein.", + "Causes": [ + "Einer der redundanten Sensoren ist abgedriftet oder defekt", + "ADC-Kalibrierungsfehler auf einem Messkanal", + "Hardwarefehler in einem der Messkreise" + ], + "NextSteps": [ + "Wechselrichter neu starten, um die Messkreise zurückzusetzen", + "Bei anhaltendem Problem: Neukalibrierung oder Sensortausch erforderlich – Service kontaktieren" + ] + }, + "PwmPassThroughSignalFailure": { + "Explanation": "Der PWM (Pulsweitenmodulation)-Durchgangssignalweg ist ausgefallen.", + "Causes": [ + "Steuerplattenfehler, der die PWM-Signalweiterleitung beeinflusst", + "Hardwareproblem im Signalweg" + ], + "NextSteps": [ + "Wechselrichter neu starten", + "Bei anhaltendem Problem: Service kontaktieren – interne Plattenprüfung erforderlich" + ] + }, + "AfciSelfTestFailure": { + "Explanation": "Der Selbsttest des AFCI (Fehlerstromschutzschalters) ist fehlgeschlagen. Der AFCI schützt vor gefährlichen Lichtbögen in der PV-Verkabelung.", + "Causes": [ + "Fehler im AFCI-Erkennungsmodul, der den Selbsttest verhindert", + "Problem im Selbsttestkreis auf der Steuerplatine" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu, um einen erneuten Selbsttest zu versuchen", + "Falls der Selbsttest weiterhin fehlschlägt, muss möglicherweise das AFCI-Modul ausgetauscht werden — kontaktieren Sie den Service" + ] + }, + "PvCurrentSamplingAbnormal": { + "Explanation": "Die PV-Strommessung liefert ungewöhnliche Werte.", + "Causes": [ + "Fehler im PV-Stromsensor oder Hall-Sensor", + "ADC-Fehler im Strommesskanal" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu", + "Falls das Problem besteht, muss der Stromsensorkreis von einem Fachmann überprüft werden" + ] + }, + "AcCurrentSamplingAbnormal": { + "Explanation": "Die AC-Strommessung liefert ungewöhnliche Werte.", + "Causes": [ + "Fehler im CT-Sensor (Stromwandler) oder falsche Verbindung", + "Fehler im AC-Stromsensor", + "ADC-Fehler im AC-Messkanal" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu", + "Überprüfen Sie die CT-Verbindungen und -Ausrichtung, falls zugänglich", + "Falls das Problem besteht, muss der Messkreis von einem Fachmann überprüft werden" + ] + }, + "BusSoftbootFailure": { + "Explanation": "Der DC-Bus konnte beim Start nicht korrekt vorladen (Vorkonditionierung).", + "Causes": [ + "Fehler im Vorladekreis, der das kontrollierte Aufladen des Kondensators verhindert", + "Problem mit dem DC-Bus-Kondensator", + "Fehler im Vorladerelais oder Schütz" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu", + "Falls das Problem besteht, muss der Vorladekreis von einem Fachmann überprüft werden" + ] + }, + "EpoFault": { + "Explanation": "Ein EPO (Notaus)-Fehler wurde ausgelöst.", + "Causes": [ + "Der EPO-Notaus-Knopf wurde gedrückt", + "Der EPO-Kreis wurde von einem externen Sicherheitssystem aktiviert", + "Fehler im EPO-Kreis, der eine unbeabsichtigte Abschaltung auslöst" + ], + "NextSteps": [ + "Überprüfen Sie, ob der EPO-Knopf gedrückt wurde — setzen Sie ihn zurück, falls nötig", + "Überprüfen Sie die EPO-Kreisverkabelung, falls die Aktivierung unbeabsichtigt war", + "Starten Sie den Wechselrichter neu, nachdem Sie bestätigt haben, dass der EPO-Kreis frei ist" + ] + }, + "MonitoringChipBootVerificationFailed": { + "Explanation": "Der Überwachungs-Chip konnte die Startprüfung nicht bestehen — die Firmware oder die Startsequenz hat ein Problem.", + "Causes": [ + "Firmware-Beschädigung auf dem Überwachungs-Chip", + "Hardwareausfall des Überwachungs-Chips" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu — Startprüfungsfehler lösen sich manchmal beim erneuten Versuch", + "Falls das Problem besteht, ist möglicherweise ein Firmware-Neuladen oder ein Chip-Austausch erforderlich — wenden Sie sich an den Service" + ] + }, + "BmsCommunicationFailure": { + "Explanation": "Das BMS kann nicht mit dem Wechselrichter kommunizieren. Lade- und Entladevorgänge können ohne BMS-Kommunikation nicht sicher gesteuert werden.", + "Causes": [ + "Das RS485-Kommunikationskabel zwischen Wechselrichter und Batterie ist defekt oder getrennt", + "Das BMS ist ausgeschaltet oder reagiert nicht", + "Kommunikationsprotokoll-Inkompatibilität zwischen Wechselrichter und BMS" + ], + "NextSteps": [ + "Überprüfen Sie die RS485-Kabelverbindung zwischen Wechselrichter und Batterie — inspizieren Sie beide Enden", + "Stellen Sie sicher, dass die Batterie eingeschaltet ist und das BMS aktiv ist", + "Überprüfen Sie, ob die Kommunikationseinstellung mit dem Batterie-BMS übereinstimmt" + ] + }, + "BmsChargeDischargeFailure": { + "Explanation": "Das BMS hat gemeldet, dass die Batterie nicht geladen oder entladen werden kann.", + "Causes": [ + "Interne BMS-Schutzfunktion wurde ausgelöst — Zellenüber-/unterspannung oder Temperaturfehler", + "Hardwarefehler im BMS, der Lade-/Entladevorgänge blockiert", + "Von BMS erkanntes Problem mit einer Batteriezelle" + ], + "NextSteps": [ + "Überprüfen Sie das Batteriedisplay oder die BMS-Anzeige auf einen spezifischen Fehlercode", + "Beziehen Sie sich auf die Dokumentation des Batterieherstellers für den BMS-Fehlercode", + "Kontaktieren Sie den Batteriesupport, wenn der Fehler nicht behoben werden kann" + ] + }, + "BatteryVoltageLow": { + "Explanation": "Die Batteriespannung liegt unter dem zulässigen Mindestwert.", + "Causes": [ + "Die Batterie wurde unter die sichere Mindestspannung tiefentladen", + "Ausfall einer einzelnen Zelle, der die Gesamtspannung des Packs verringert" + ], + "NextSteps": [ + "Überprüfen Sie die Batteriespannung — bei kritisch niedrigem Wert kann ein professionelles Wiederaufladen erforderlich sein", + "Lassen Sie die Batterie langsam vom Netz aufladen, bevor Sie den normalen Betrieb wieder aufnehmen" + ] + }, + "BatteryVoltageHigh": { + "Explanation": "Die Batteriespannung überschreitet den maximal zulässigen oberen Grenzwert.", + "Causes": [ + "Die Batterie wurde über ihre maximale Spannung hinaus überladen", + "BMS-Fehler, der ein Ansteigen der Spannung ohne Schutz ermöglicht", + "Ausfall einer einzelnen Zelle, die in einem Teil des Packs eine hohe Spannung erzeugt" + ], + "NextSteps": [ + "Überprüfen Sie die Batteriespannung und vergleichen Sie sie mit der maximalen Spezifikation des Herstellers", + "Falls die Spannung im zulässigen Bereich liegt, starten Sie den Wechselrichter neu", + "Falls die Spannung tatsächlich zu hoch ist, beenden Sie das Laden sofort und kontaktieren Sie den Batterieservice" + ] + }, + "BatteryTemperatureAbnormal": { + "Explanation": "Die Batterietemperatur liegt außerhalb des sicheren Bereichs für Laden oder Entladen.", + "Causes": [ + "Batterie ist zu heiß — schlechte Belüftung oder hohe Umgebungstemperatur", + "Batterie ist zu kalt — gefrorene oder nahegefrorene Umgebung", + "Batterietemperatur-Sensor defekt und gibt falsche Werte an" + ], + "NextSteps": [ + "Prüfen Sie die physische Temperatur der Batterie, wenn es sicher ist", + "Verbessern Sie die Belüftung der Batterie bei Überhitzung", + "Bei Kälte die Batterie vor dem Laden aufwärmen lassen", + "Prüfen Sie die Sensorverbindungen, wenn die Temperaturanzeige falsch erscheint" + ] + }, + "BatteryReversed": { + "Explanation": "Die Batterie ist falsch gepolt — Plus- und Minuspole sind falsch angeschlossen.", + "Causes": [ + "Batterie Plus- und Minuskabel sind an die falschen Wechselrichteranschlüsse angeschlossen", + "Installationsfehler" + ], + "NextSteps": [ + "Sofort das gesamte System ausschalten — falsche Polung kann schwere Schäden verursachen", + "Lassen Sie einen qualifizierten Elektriker die Batteriepolung überprüfen und korrigieren, bevor Sie das System wieder in Betrieb nehmen" + ] + }, + "BatteryOpenCircuit": { + "Explanation": "Der Batteriekreis ist offen — die Batterie ist nicht elektrisch angeschlossen.", + "Causes": [ + "Batteriekabel hat sich gelöst oder ist vom Anschluss getrennt", + "Batteriesicherung ist durchgebrannt und unterbricht den Kreis", + "BMS hat den internen Schalter aufgrund eines Schutzereignisses geöffnet" + ], + "NextSteps": [ + "Prüfen Sie alle Batteriekabelanschlüsse am Wechselrichter und an den Batterieanschlüssen", + "Überprüfen Sie die Batteriesicherung und ersetzen Sie sie, falls sie durchgebrannt ist", + "Prüfen Sie den BMS-Status auf Schutzereignisse, die den Batterieschalter geöffnet haben könnten" + ] + }, + "BatteryOverloadProtection": { + "Explanation": "Der Batterieüberlastungsschutz wurde ausgelöst — die Last zieht mehr Strom ab, als die Batterie sicher entladen kann.", + "Causes": [ + "Gesamtlastleistung überschreitet die maximale Nennentladungsleistung der Batterie", + "Hochstromstoß von großen Geräten, die vorübergehend die Batterienennleistung überschreiten" + ], + "NextSteps": [ + "Prüfen Sie die Gesamtlast und vergleichen Sie sie mit der Nennentladungsleistung der Batterie", + "Reduzieren Sie Hochlasten und starten Sie den Wechselrichter neu" + ] + }, + "Bus2VoltageAbnormal": { + "Explanation": "Die Spannung des sekundären Gleichstrombusses ist ungewöhnlich.", + "Causes": [ + "Fehler in der Leistungselektronik, der den sekundären Gleichstrombus betrifft", + "Steuerungsproblem am sekundären Wandler" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu", + "Falls das Problem anhält, ist eine professionelle Inspektion erforderlich" + ] + }, + "BatteryChargeOcp": { + "Explanation": "Die Überstromschutzvorrichtung (OCP) für die Batterieladung wurde ausgelöst – der Ladestrom ist zu hoch.", + "Causes": [ + "Die PV-Anlage liefert mehr Strom, als die Batterie sicher aufnehmen kann", + "Die Batterieladestrombegrenzung ist zu hoch für die Batteriespezifikation" + ], + "NextSteps": [ + "Prüfen, ob die PV-Anlagenleistung die Batterieladung deutlich überschreitet", + "Die maximale Ladestromeinstellung im Wechselrichter an die Batteriespezifikation anpassen" + ] + }, + "BatteryDischargeOcp": { + "Explanation": "Die Überstromschutzvorrichtung (OCP) für die Batterieentladung wurde ausgelöst – der Entladestrom ist zu hoch.", + "Causes": [ + "Die angeschlossene Last entnimmt mehr Strom, als die Batterie maximal abgeben kann", + "Die Batterieentladestrombegrenzung ist zu hoch eingestellt" + ], + "NextSteps": [ + "Prüfen, ob die Batterieentladestromkonfiguration der Batteriespezifikation entspricht", + "Die angeschlossene Last innerhalb der Batterieentladungsgrenzen reduzieren" + ] + }, + "BatterySoftStartFailed": { + "Explanation": "Die Batterie konnte die Softstart-Sequenz beim Verbinden mit dem Wechselrichter nicht abschließen.", + "Causes": [ + "Fehler im Vorladestromkreis, der eine kontrollierte Batterieverbindung verhindert", + "Batteriespannung weicht deutlich von der Wechselrichter-Gleichspannungsbus-Spannung ab" + ], + "NextSteps": [ + "Den Wechselrichter neu starten", + "Die Batteriespannung mit der Gleichspannungsbus-Spannung vergleichen – eine große Abweichung kann den Softstart verhindern" + ] + }, + "EpsOutputShortCircuited": { + "Explanation": "Der EPS (Notstrom)-Ausgang hat einen Kurzschluss.", + "Causes": [ + "Kurzschluss in der Lastverkabelung, die mit dem Notstromausgang verbunden ist", + "Ein defektes Gerät verursacht einen Kurzschluss im Notstromkreis", + "Kabelbaumfehler in der EPS-Ausgangsverteilung" + ], + "NextSteps": [ + "Alle Lasten vom Notstromausgang trennen", + "Den Kurzschluss in der Lastverkabelung oder den Geräten identifizieren und reparieren, bevor wieder angeschlossen wird" + ] + }, + "OffGridBusVoltageLow": { + "Explanation": "Die netzunabhängige Gleichspannungsbus-Spannung ist zu niedrig, um den Notstrombetrieb aufrechtzuerhalten.", + "Causes": [ + "Die Batterie ist fast leer und kann die Gleichspannungsbus-Spannung nicht aufrechterhalten", + "Hohe Notstromlast in Kombination mit geringer Batterieladung", + "Batteriekapazitätsverlust durch Alterung" + ], + "NextSteps": [ + "Prüfen, ob die Batterie ordnungsgemäß funktioniert und keinen signifikanten Kapazitätsverlust aufweist", + "Die Batterie aufladen, bevor der Notstrombetrieb versucht wird", + "Die Notstromlast reduzieren, um die verfügbare Batterielaufzeit zu verlängern" + ] + }, + "OffGridTerminalVoltageAbnormal": { + "Explanation": "Eine abnormale Spannung wurde am netzunabhängigen Wechselstromausgang erkannt.", + "Causes": [ + "Externe Spannung liegt am Notstromausgang an", + "Kabelverbindung zum Notstromausgang ist defekt", + "Rückspeisung von einer Last mit eigener Stromquelle" + ], + "NextSteps": [ + "Prüfen, ob eine externe Spannungsquelle am Notstromausgang angeschlossen ist", + "Überprüfen, ob die Kabelverbindung des Notstromausgangs mit einer anderen Stromquelle verbunden ist", + "Alle Lasten vom Notstromausgang trennen und Kabel prüfen, bevor das System neu gestartet wird" + ] + }, + "SoftStartFailed": { + "Explanation": "Der sanfte Start im netzunabhängigen Modus ist fehlgeschlagen.", + "Causes": [ + "Vorkonditionierung während des netzunabhängigen Starts fehlgeschlagen", + "Zu hohe Last beim netzunabhängigen Start" + ], + "NextSteps": [ + "Den Wechselrichter neu starten", + "Die anfängliche Last im Notstromkreis reduzieren" + ] + }, + "OffGridOutputVoltageAbnormal": { + "Explanation": "Die Ausgangsspannung im netzunabhängigen Modus ist abnormal.", + "Causes": [ + "Steuerungsfehler, der die Spannungsregelung beeinträchtigt", + "Hardwareproblem im Ausgangsbereich", + "Überlastung, die die Ausgangsspannung zusammenbrechen lässt" + ], + "NextSteps": [ + "Den Wechselrichter neu starten", + "Bei anhaltendem Fehler den Hersteller kontaktieren" + ] + }, + "BalancedCircuitSelfTestFailed": { + "Explanation": "Der Selbsttest der Ausgleichsschaltung ist beim Start fehlgeschlagen.", + "Causes": [ + "Fehler in der Phasenausgleichsschaltung erkannt", + "Hardwareproblem in der Ausgleichsschaltung" + ], + "NextSteps": [ + "Den Wechselrichter neu starten, um den Selbsttest zu wiederholen", + "Bei anhaltendem Fehler den Service kontaktieren" + ] + }, + "HighDcComponentOutputVoltage": { + "Explanation": "Eine hohe Gleichspannungskomponente wurde in der Wechselstromausgangsspannung erkannt.", + "Causes": [ + "Regelkreisdrift, der zu einer Gleichspannungsverschiebung führt", + "Problem mit dem Ausgangstransformator oder Filter" + ], + "NextSteps": [ + "Den Wechselrichter neu starten, um die Regelkreise zurückzusetzen", + "Bei anhaltendem Fehler den Hersteller kontaktieren" + ] + }, + "OffGridParallelSignalAbnormal": { + "Explanation": "Das Parallelkommunikationssignal zwischen den Wechselrichtereinheiten ist gestört.", + "Causes": [ + "Das Parallelkommunikationskabel zwischen den Einheiten ist beschädigt oder getrennt", + "Die Parallelkonfiguration stimmt zwischen den Einheiten nicht überein" + ], + "NextSteps": [ + "Überprüfen Sie, ob alle Parallelkommunikationskabel zwischen den Wechselrichtereinheiten richtig und sicher angeschlossen sind", + "Stellen Sie sicher, dass die Parallel-Einstellungen auf allen Einheiten übereinstimmen" + ] + }, + "AFCIFault": { + "Explanation": "Ein Lichtbogenfehler wurde im PV-System erkannt. Lichtbögen können Brände in der PV-Verkabelung verursachen, und das System wurde aus Sicherheitsgründen abgeschaltet.", + "Causes": [ + "Lockere MC4-Stecker oder PV-Kabelverbindung, die intermittierende Lichtbögen verursacht", + "Beschädigte Kabelisolierung, die einen Lichtbogen am beschädigten Punkt ermöglicht", + "Defekter Stecker oder Anschlusskasten, der einen Lichtbogenweg schafft", + "Beschädigte Modul-Anschlussdose" + ], + "NextSteps": [ + "Schalten Sie alle DC-Trennschalter aus, bevor Sie die PV-Verkabelung inspizieren", + "Überprüfen Sie sorgfältig alle PV-String-Verbindungen, MC4-Stecker und Kabelverläufe auf Schäden", + "Ziehen Sie alle lockeren Stecker fest und ersetzen Sie alle beschädigten Kabel oder Stecker", + "Lassen Sie die Installation professionell überprüfen, wenn die Lichtbogenquelle nicht gefunden wird" + ] + }, + "GFCIHigh": { + "Explanation": "Ein übermäßig hoher Fehlerstrom (Leckstrom) wurde im PV-System erkannt.", + "Causes": [ + "Fehlerstrom im PV-Array – typischerweise ein Kabel, das den Rahmen oder Metallteile berührt", + "Isolationsversagen an PV-Kabeln oder Modul-Anschlusskästen", + "Feuchtigkeitseintritt in Kabelverbindungen oder Modul-Anschlusskästen", + "Kabelschäden, die Leiter freilegen" + ], + "NextSteps": [ + "Starten Sie den Wechselrichter neu, um zu prüfen, ob der Fehler behoben ist", + "Falls der Fehler besteht, führen Sie einen Isolationswiderstandstest an allen PV-Strings durch, um den Fehlerort zu finden", + "Reparieren Sie alle festgestellten Isolationsschäden oder Fehlerströme, bevor Sie den Wechselrichter neu starten" + ] + }, + "PVVoltageHigh": { + "Explanation": "Die DC-Eingangsspannung vom PV-Array überschreitet die absolute maximale sichere Grenze. Dies ist eine unmittelbare Gefahr für den Wechselrichter.", + "Causes": [ + "Zu viele PV-Module in Reihe, die die maximale Eingangsspannung des Wechselrichters überschreiten", + "Sehr kalte Temperaturen, die die Modul-Leerlaufspannung deutlich über die Design-Temperatur-Leerlaufspannung ansteigen lassen" + ], + "NextSteps": [ + "Trennen Sie den DC-Schalter sofort, um den Wechselrichter zu schützen", + "Messen Sie die tatsächliche DC-Spannung, bevor Sie wieder anschließen", + "Überprüfen Sie das String-Design und reduzieren Sie gegebenenfalls die Anzahl der Module in Reihe, um die Wechselrichter-Spannungsgrenzen einzuhalten" + ] + }, + "OffGridBusVoltageTooLow": { + "Explanation": "Die Gleichspannung im Inselbetrieb ist zu stark abgesunken, um einen stabilen Betrieb aufrechtzuerhalten.", + "Causes": [ + "Batterieladestand zu niedrig", + "Zu hohe Last am Inselausgang", + "Defekt oder lockere Verbindung in der DC-Bus-Verdrahtung" + ], + "NextSteps": [ + "Last am Inselausgang reduzieren", + "Batterieladestand prüfen und ggf. aufladen", + "DC-Bus-Verdrahtung auf lockere Verbindungen oder Schäden überprüfen" + ] + } +} \ No newline at end of file diff --git a/csharp/App/Backend/Resources/AlarmTranslations.fr.json b/csharp/App/Backend/Resources/AlarmTranslations.fr.json new file mode 100644 index 000000000..fb5356cef --- /dev/null +++ b/csharp/App/Backend/Resources/AlarmTranslations.fr.json @@ -0,0 +1,2822 @@ +{ + "AbnormalGridVoltage": { + "Explanation": "L'onduleur a détecté que la tension du réseau est en dehors de la plage de fonctionnement acceptable. Le système nécessite une intervention manuelle pour récupérer.", + "Causes": [ + "Fluctuation ou instabilité de la tension du réseau électrique", + "Mauvaise ou connexion lâche du réseau aux bornes de l'onduleur", + "Problèmes locaux avec le transformateur", + "Demande de charge élevée sur le réseau local" + ], + "NextSteps": [ + "Vérifiez la tension du réseau avec un multimètre aux bornes de l'onduleur", + "Vérifiez que tous les câbles de connexion au réseau sont bien serrés et intacts", + "Contactez votre fournisseur d'électricité si la tension du réseau reste anormale", + "Redémarrez l'onduleur après avoir résolu le problème" + ] + }, + "AbnormalGridFrequency": { + "Explanation": "L'onduleur a détecté que la fréquence du réseau est en dehors de la plage acceptable (généralement 50 Hz ou 60 Hz ± tolérance). Le système ne fonctionnera pas tant que la fréquence ne sera pas revenue à la normale.", + "Causes": [ + "Instabilité ou perturbation du réseau par le fournisseur d'électricité", + "Dérive de fréquence du générateur si celui-ci est en fonctionnement", + "Changements rapides de charge sur le réseau local" + ], + "NextSteps": [ + "Vérifiez si la fréquence du réseau est stable", + "Si vous utilisez un générateur, vérifiez que sa fréquence correspond à la spécification de l'onduleur", + "Attendez que le réseau se stabilise, puis redémarrez l'onduleur" + ] + }, + "InvertedSequenceOfGridVoltage": { + "Explanation": "La séquence de phase de la tension triphasée du réseau est inversée. Il s'agit d'un problème de câblage qui empêche un fonctionnement sûr.", + "Causes": [ + "Câblage incorrect des phases du réseau lors de l'installation (L1, L2, L3 intervertis)", + "Travaux de recâblage effectués sans vérifier l'ordre des phases" + ], + "NextSteps": [ + "Mettez hors tension l'ensemble du système avant de toucher à un câblage", + "Inversez deux des trois phases au niveau de la connexion au réseau pour corriger la séquence", + "Remettez le système sous tension et vérifiez que l'alerte est levée" + ] + }, + "GridVoltagePhaseLoss": { + "Explanation": "Une ou plusieurs phases de la connexion triphasée du réseau sont manquantes. L'onduleur ne peut pas fonctionner en toute sécurité avec une alimentation triphasée incomplète.", + "Causes": [ + "Fusible grillé sur l'une des phases du réseau", + "Fils de phase desserrés ou déconnectés aux bornes de l'onduleur ou au tableau de distribution", + "Disjoncteur du côté réseau déclenché sur une phase", + "Dommage au câble interrompant une phase" + ], + "NextSteps": [ + "Vérifiez les trois connexions de phase aux bornes d'entrée de l'onduleur", + "Vérifiez les fusibles et les disjoncteurs pour chaque phase", + "Inspectez les câbles pour détecter des dommages visibles ou des connexions desserrées", + "Rétablissez la phase manquante et redémarrez après la réparation" + ] + }, + "AbnormalGridCurrent": { + "Explanation": "Le courant du réseau est anormal, ce qui peut indiquer un surcourant ou un déséquilibre de courant entre les phases.", + "Causes": [ + "Court-circuit ou défaut de câblage du côté réseau", + "Charge du système dépassant la capacité", + "Capteur de courant défectueux donnant des lectures incorrectes", + "Défaut de mise à la terre provoquant une fuite de courant" + ], + "NextSteps": [ + "Vérifiez les courts-circuits dans le câblage et du côté de la charge", + "Réduisez la charge du système et voyez si l'alerte est levée", + "Vérifiez les connexions et le fonctionnement du capteur de courant", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "AbnormalOutputVoltage": { + "Explanation": "La tension de sortie de l'onduleur est en dehors des limites acceptables. Cela peut affecter les charges connectées et indique un défaut.", + "Causes": [ + "Défaut de contrôle interne de l'onduleur", + "Condition de surcharge sur la sortie", + "Influence de la tension du réseau affectant la régulation de sortie" + ], + "NextSteps": [ + "Vérifiez toutes les charges connectées et déconnectez celles qui peuvent causer une surcharge", + "Vérifiez les réglages de tension de sortie de l'onduleur pour qu'ils correspondent à vos exigences d'installation", + "Redémarrez l'onduleur ; si l'alarme persiste, contactez un technicien de service" + ] + }, + "AbnormalOutputFrequency": { + "Explanation": "La fréquence de sortie de l'onduleur est anormale, ce qui peut affecter les équipements sensibles.", + "Causes": [ + "Défaut du système de contrôle interne affectant la régulation de fréquence", + "Transitoires de charge lourdes ou soudaines causant une déviation de fréquence" + ], + "NextSteps": [ + "Réduisez la charge connectée et vérifiez si la fréquence se stabilise", + "Redémarrez l'onduleur ; si le problème persiste, contactez le service" + ] + }, + "AbnormalNullLine": { + "Explanation": "La connexion de la ligne neutre est anormale. Une ligne neutre manquante ou endommagée peut causer un déséquilibre de tension et des conditions dangereuses.", + "Causes": [ + "Fil neutre desserré ou déconnecté au niveau de l'onduleur ou du tableau de distribution", + "Fil neutre endommagé ou cassé", + "Câblage incorrect lors de l'installation" + ], + "NextSteps": [ + "Mettez le système hors tension en toute sécurité avant d'inspecter le câblage", + "Vérifiez toutes les connexions du fil neutre au niveau de l'onduleur et du panneau de distribution", + "Réparer tout problème de câblage trouvé, puis redémarrez après avoir confirmé les bonnes connexions" + ] + }, + "AbnormalOffGridOutputVoltage": { + "Explanation": "La tension de sortie hors réseau (de secours) est anormale. Les charges connectées à la sortie de secours peuvent ne pas recevoir la tension correcte.", + "Causes": [ + "Surcharge sur la sortie de secours dépassant la capacité de l'onduleur", + "Problème matériel interne de l'onduleur", + "Tension de la batterie trop faible pour maintenir une sortie stable" + ], + "NextSteps": [ + "Déconnectez ou réduisez la charge sur la sortie de secours", + "Vérifiez l'état de charge de la batterie et laissez-la se charger si elle est faible", + "Redémarrez l'onduleur ; si le problème persiste, contactez le service" + ] + }, + "ExcessivelyHighAmbientTemperature": { + "Explanation": "La température ambiante autour de l'onduleur est trop élevée. L'onduleur peut réduire sa puissance de sortie pour se protéger des dommages causés par la chaleur.", + "Causes": [ + "Mauvaise ventilation autour de l'installation de l'onduleur", + "Température environnementale élevée (canicule, pic estival)", + "Exposition directe au soleil chauffant le boîtier de l'onduleur", + "Autres équipements à proximité générant une chaleur excessive" + ], + "NextSteps": [ + "Améliorez le flux d'air et la ventilation autour de l'onduleur", + "Fournissez de l'ombre si l'onduleur est installé en extérieur ou en plein soleil", + "Envisagez d'ajouter un refroidissement forcé (ventilateur) si l'onduleur est dans un espace clos", + "L'onduleur se rétablira automatiquement une fois la température revenue à un niveau sûr" + ] + }, + "ExcessiveRadiatorTemperature": { + "Explanation": "La température du dissipateur thermique (radiateur) de l'onduleur est trop élevée. L'onduleur utilise le dissipateur pour évacuer la chaleur pendant le fonctionnement.", + "Causes": [ + "Les aérations sont bloquées ou obstruées, empêchant la dissipation de la chaleur", + "Panne du ventilateur de refroidissement réduisant le flux d'air", + "Température ambiante élevée", + "Charge excessive générant plus de chaleur" + ], + "NextSteps": [ + "Nettoyer les aérations et les filtres à poussière — l'accumulation de poussière est une cause fréquente", + "Vérifier que le ventilateur de refroidissement fonctionne (écouter le bruit du ventilateur pendant le fonctionnement)", + "Réduire temporairement la charge pour diminuer la génération de chaleur", + "Réparer ou remplacer le ventilateur s'il est défectueux, puis redémarrer l'onduleur" + ] + }, + "PcbOvertemperature": { + "Explanation": "La carte de circuit imprimé (PCB) à l'intérieur de l'onduleur a atteint une température trop élevée.", + "Causes": [ + "Refroidissement insuffisant ou ventilation mauvaise dans l'enceinte", + "Température ambiante élevée affectant les composants internes", + "Puissance de sortie excessive pendant une période prolongée" + ], + "NextSteps": [ + "Améliorer la ventilation autour de l'onduleur", + "Vérifier que le ventilateur de refroidissement fonctionne correctement", + "Laisser l'onduleur refroidir avant de le redémarrer" + ] + }, + "DcConverterOvertemperature": { + "Explanation": "La section convertisseur DC de l'onduleur surchauffe.", + "Causes": [ + "Courant de charge ou de décharge élevé maintenu pendant une longue période", + "Refroidissement insuffisant ou aérations bloquées", + "Température ambiante élevée dans la zone d'installation" + ], + "NextSteps": [ + "Réduire temporairement le flux de puissance dans le système", + "Améliorer la ventilation et vérifier le fonctionnement du ventilateur", + "Laisser refroidir, puis redémarrer l'onduleur" + ] + }, + "InverterOvertemperatureAlarm": { + "Explanation": "La température de l'onduleur atteint des niveaux dangereux. C'est un avertissement précoce avant la coupure thermique.", + "Causes": [ + "Surcharge de puissance de sortie prolongée", + "Ventilation insuffisante piégeant la chaleur autour de l'onduleur", + "Panne du ventilateur de refroidissement", + "Température ambiante élevée dans la zone d'installation" + ], + "NextSteps": [ + "Réduire immédiatement la charge connectée", + "Vérifier que les ventilateurs de refroidissement fonctionnent et que les aérations sont dégagées", + "L'onduleur se rétablira une fois refroidi ; corrigez la cause sous-jacente avant un redémarrage complet" + ] + }, + "InverterOvertemperature": { + "Explanation": "L'onduleur a surchauffé et la coupure de protection s'est activée.", + "Causes": [ + "Condition de surcharge prolongée générant une chaleur excessive", + "Panne du système de refroidissement (aérations bloquées, ventilateur défectueux)", + "Températures environnementales extrêmes" + ], + "NextSteps": [ + "Laisser l'onduleur refroidir complètement avant de tenter un redémarrage", + "Vérifier les ventilateurs et s'assurer que toutes les ouvertures de ventilation sont dégagées", + "Réduire la charge du système et améliorer le refroidissement avant de redémarrer" + ] + }, + "DcConverterOvertemperatureAlarm": { + "Explanation": "L'alarme de température du convertisseur DC est active — la température approche du seuil de coupure.", + "Causes": [ + "Débit de puissance élevé maintenu dans le temps", + "Refroidissement insuffisant ou aérations obstruées" + ], + "NextSteps": [ + "Réduire temporairement le flux de puissance pour permettre le refroidissement", + "Vérifier le fonctionnement du ventilateur et dégager les éventuels obstructions de ventilation", + "Laisser la température baisser, puis redémarrer l'onduleur" + ] + }, + "InsulationFault": { + "Explanation": "Un défaut d'isolation a été détecté, indiquant une possible fuite de courant vers la terre. Il s'agit d'une condition critique pour la sécurité qui doit être investiguée avant de reprendre le fonctionnement.", + "Causes": [ + "Isolation de câble endommagée sur les câbles PV, batterie ou réseau", + "Infiltration d'humidité ou d'eau dans les connexions de câbles ou les boîtiers", + "Défaillance de l'isolation d'un composant à l'intérieur de l'onduleur", + "Défaut de mise à la terre dans le champ PV — fréquent après des dommages causés par une tempête" + ], + "NextSteps": [ + "Ne pas toucher au système — les défauts d'isolation peuvent provoquer un choc électrique", + "Mettre hors tension le système en toute sécurité depuis tous les dispositifs de déconnexion", + "Inspecter tous les câbles pour détecter des dommages visibles à l'isolation, surtout dans les zones exposées aux intempéries", + "Effectuer un test de résistance d'isolation sur les chaînes PV et les câblages", + "Réparer l'isolation endommagée avant de redémarrer" + ] + }, + "LeakageProtectionFault": { + "Explanation": "La protection contre les fuites de courant ou le défaut de mise à la terre a été déclenchée. Le courant de fuite vers la terre a dépassé le seuil de sécurité.", + "Causes": [ + "Défaut de mise à la terre quelque part dans le câblage du système", + "Isolation de câble endommagée permettant au courant de fuir vers la terre", + "Humidité pénétrant dans les connecteurs de câbles ou les boîtes de jonction", + "Dispositif RCD ou GFCI défectueux" + ], + "NextSteps": [ + "Mettre hors tension le système avant inspection", + "Vérifier les défauts de mise à la terre en inspectant toutes les connexions de câbles et l'isolation", + "Rechercher de l'humidité dans les connecteurs, les boîtes de jonction et les presse-étoupes", + "Réparer le défaut, puis redémarrer le système" + ] + }, + "AbnormalLeakageSelfCheck": { + "Explanation": "L'auto-test de courant de fuite de l'onduleur a échoué au démarrage.", + "Causes": [ + "Défaut du circuit d'auto-test à l'intérieur de l'onduleur", + "Un défaut de mise à la terre réel présent dans le système", + "Défaillance du capteur de courant de fuite" + ], + "NextSteps": [ + "Mettre hors tension en toute sécurité et vérifier les connexions de mise à la terre du système", + "Inspecter le câblage pour détecter des dommages à l'isolation pouvant causer des fuites", + "Si le câblage est correct, le capteur interne de l'onduleur peut être défectueux — contacter le service" + ] + }, + "PoorGrounding": { + "Explanation": "Une connexion de mise à la terre inadéquate ou insuffisante a été détectée. Une mise à la terre correcte est essentielle pour la sécurité et la protection contre la foudre.", + "Causes": [ + "Connexion de mise à la terre (terre) desserrée au niveau de l'onduleur", + "Borne de mise à la terre corrodée ou oxydée", + "Résistance du câble de mise à la terre trop élevée en raison des conditions du sol ou d'un câble sous-dimensionné", + "Câble de mise à la terre manquant ou déconnecté" + ], + "NextSteps": [ + "Mettre hors tension en toute sécurité et vérifier toutes les connexions de mise à la terre au niveau de l'onduleur", + "Nettoyer les bornes corrodées et serrer toutes les connexions de mise à la terre", + "Mesurer la résistance de mise à la terre et la comparer à la spécification d'installation", + "Réparer la mise à la terre, puis redémarrer l'onduleur" + ] + }, + "FanFault": { + "Explanation": "Le ventilateur de refroidissement est défectueux ou ne fonctionne pas correctement. Sans refroidissement suffisant, l'onduleur surchauffera et s'éteindra.", + "Causes": [ + "Le moteur du ventilateur est en panne et ne tourne plus", + "Les pales du ventilateur sont bloquées par des débris ou des objets étrangers", + "Le connecteur d'alimentation du ventilateur est desserré ou déconnecté", + "Défaut du circuit de commande du ventilateur" + ], + "NextSteps": [ + "Inspectez visuellement le ventilateur et vérifiez s'il tourne lorsque l'onduleur est en marche", + "Retirez les obstructions des pales du ventilateur", + "Vérifiez que le connecteur d'alimentation du ventilateur est bien branché", + "Remplacez le ventilateur s'il ne fonctionne pas — ne faites pas fonctionner l'onduleur sans refroidissement" + ] + }, + "AuxiliaryPowerFault": { + "Explanation": "L'alimentation auxiliaire interne de l'onduleur a échoué. Cette alimentation interne alimente les composants électroniques de contrôle.", + "Causes": [ + "Défaillance d'un composant de l'alimentation interne", + "Problème de tension d'entrée affectant l'alimentation auxiliaire", + "Défaillance d'un composant électronique sur la carte de contrôle" + ], + "NextSteps": [ + "Redémarrez l'onduleur — éteignez-le, attendez 30 secondes, puis rallumez-le", + "Si l'alarme persiste après le redémarrage, l'alimentation auxiliaire doit probablement être remplacée — contactez un technicien de service" + ] + }, + "ModelCapacityFault": { + "Explanation": "L'onduleur a détecté une incompatibilité entre la configuration du modèle ou de la capacité — les paramètres du système ne correspondent pas au matériel.", + "Causes": [ + "Configuration du modèle incorrecte définie lors de la mise en service", + "Version du micrologiciel incompatible avec le modèle matériel", + "Composants matériels remplacés sans mise à jour de la configuration" + ], + "NextSteps": [ + "Vérifiez les paramètres du modèle de l'onduleur dans le menu de configuration", + "Vérifiez que la version du micrologiciel est compatible avec cette révision matérielle", + "Contactez votre installateur ou l'équipe de service pour corriger la configuration, puis redémarrez" + ] + }, + "AbnormalLightningArrester": { + "Explanation": "Le dispositif de protection contre les surtensions (SPD / paratonnerre) a soit échoué, soit s'est activé en raison d'un événement de surtension.", + "Causes": [ + "Une foudre ou une surtension de tension a déclenché et peut-être détruit le SPD", + "Le composant SPD a atteint la fin de sa durée de vie et a échoué", + "Défaut de câblage du SPD" + ], + "NextSteps": [ + "Vérifiez l'indicateur d'état du SPD (la plupart des SPD ont un indicateur de défaut visuel)", + "Remplacez la cartouche du SPD si elle a été déclenchée ou montre un défaut", + "Après le remplacement, redémarrez l'onduleur" + ] + }, + "IslandProtection": { + "Explanation": "La protection d'îlotage est active — l'onduleur s'est déconnecté du réseau pour éviter d'alimenter un réseau sans électricité. Il s'agit d'une fonction de sécurité.", + "Causes": [ + "Panne de courant du réseau électrique dans votre région", + "Tension ou fréquence du réseau en dehors des limites acceptables", + "Déconnexion intentionnelle du réseau par l'utilitaire" + ], + "NextSteps": [ + "Attendez que le réseau électrique soit rétabli et stabilisé", + "L'onduleur se reconnectera automatiquement et reprendra son fonctionnement normal une fois le réseau sain", + "Aucune action requise sauf si la panne est prolongée" + ] + }, + "Battery1NotConnected": { + "Explanation": "La batterie 1 n'est pas détectée ou n'est pas connectée. L'onduleur ne trouve pas la batterie sur le bus DC.", + "Causes": [ + "Le disjoncteur de batterie est ouvert (éteint)", + "Câble de batterie desserré ou déconnecté au niveau de l'onduleur ou de la borne de batterie", + "Le BMS de la batterie a coupé la batterie en raison d'un événement de protection", + "Le fusible de la batterie a grillé" + ], + "NextSteps": [ + "Vérifiez le disjoncteur de batterie et assurez-vous qu'il est en position MARCHE", + "Inspectez les connexions des câbles de batterie aux extrémités de l'onduleur et de la batterie", + "Vérifiez l'indicateur d'état du BMS de la batterie pour tout code de défaut", + "Inspectez et remplacez le fusible s'il est grillé, puis redémarrez l'onduleur" + ] + }, + "Battery1Overvoltage": { + "Explanation": "La tension de la batterie 1 est trop élevée. La charge a été limitée ou arrêtée pour protéger la batterie.", + "Causes": [ + "La batterie est surchargée au-delà de sa tension maximale", + "Dysfonctionnement du BMS permettant à la tension de monter trop haut", + "Paramètres de tension ou de capacité de batterie incorrects dans l'onduleur", + "Déséquilibre des cellules entraînant la surcharge de certaines cellules" + ], + "NextSteps": [ + "Vérifiez l'état de charge de la batterie et la tension actuelle", + "Vérifiez les paramètres de tension de charge de la batterie dans la configuration de l'onduleur", + "Vérifiez le fonctionnement du BMS et tout indicateur de défaut du BMS", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Battery1Undervoltage": { + "Explanation": "La tension de la batterie 1 est trop basse. La décharge a été limitée ou arrêtée pour protéger la batterie d'une décharge profonde.", + "Causes": [ + "La batterie a été déchargée trop profondément", + "Défaillance d'une cellule de batterie individuelle réduisant la capacité totale", + "Coupe du BMS en raison de la protection contre la tension basse", + "Charge élevée drainant la batterie plus vite qu'elle ne se charge" + ], + "NextSteps": [ + "Laissez la batterie se recharger à partir du PV ou du réseau", + "Vérifiez toute charge inhabituellement élevée consommant trop de puissance", + "Vérifiez l'état de la batterie — les batteries vieillissantes peuvent ne pas tenir la charge", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Battery1DischargeEnd": { + "Explanation": "La batterie 1 a atteint son état de charge minimum (point de fin de décharge). Le système arrêtera la décharge pour protéger la batterie.", + "Causes": [ + "La batterie a été entièrement déchargée jusqu'à la limite de SOC configurée", + "Consommation d'énergie élevée dépassant la charge solaire ou réseau disponible" + ], + "NextSteps": [ + "Attendez que la batterie se recharge à partir de l'énergie PV ou du réseau", + "Envisagez de réduire la consommation d'énergie nocturne pour préserver la capacité de la batterie", + "Cette alarme se désactivera automatiquement une fois que la charge suffisante est restaurée" + ] + }, + "Battery1Inverted": { + "Explanation": "La polarité de la batterie 1 est inversée. Fonctionner avec une polarité inversée peut causer des dommages graves à l'onduleur et à la batterie.", + "Causes": [ + "Les câbles de la batterie ont été connectés avec le positif et le négatif inversés lors de l'installation", + "Erreur d'installation — câble positif sur la borne négative ou vice versa" + ], + "NextSteps": [ + "ÉTEIGNEZ IMMEDIATEMENT tout le système — ne tentez pas de charger ou de décharger", + "Déconnectez les câbles de la batterie avec précaution après avoir coupé l'alimentation", + "Reconnectez avec la bonne polarité : positif sur la borne positive (+), négatif sur la borne négative (−)", + "Vérifiez tout dommage aux câbles, fusibles ou à l'onduleur avant de redémarrer" + ] + }, + "Battery1OverloadTimeout": { + "Explanation": "La batterie 1 a fonctionné trop longtemps en surcharge et a déclenché une protection.", + "Causes": [ + "Charge soutenue dépassant continuellement la capacité de décharge de la batterie", + "Batterie trop petite pour la charge connectée", + "Dégradation de la batterie réduisant sa capacité de puissance" + ], + "NextSteps": [ + "Réduire la charge totale du système", + "Vérifier si la batterie est correctement dimensionnée pour les pics de charge", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Battery1SoftStartFailure": { + "Explanation": "La batterie 1 n'a pas pu compléter la séquence de démarrage progressif (pré-charge) au démarrage.", + "Causes": [ + "Défaut du circuit de pré-charge empêchant un démarrage contrôlé", + "Écart de tension important entre la batterie et le bus DC", + "Problème de contacteur ou relais dans le circuit de la batterie" + ], + "NextSteps": [ + "Vérifier la tension de la batterie et la comparer à celle du bus DC", + "Vérifier que le circuit de pré-charge et les contacteurs fonctionnent correctement", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "Battery1PowerTubeFault": { + "Explanation": "Les composants électroniques de puissance (transistors IGBT ou MOSFET) de la batterie 1 ont échoué. Il s'agit d'un défaut matériel nécessitant une intervention professionnelle.", + "Causes": [ + "Échec du semi-conducteur de puissance (IGBT/MOSFET) dû à une surcharge", + "Dommages causés par un surcourant ou un court-circuit", + "Défaut de fabrication du composant apparu avec le temps" + ], + "NextSteps": [ + "Ne pas tenter de redémarrer le système", + "Contacter un technicien qualifié — cette réparation nécessite un remplacement interne", + "Ne pas utiliser le système avant réparation professionnelle" + ] + }, + "Battery1InsufficientPower": { + "Explanation": "La batterie 1 ne peut pas fournir suffisamment de puissance pour répondre à la demande actuelle.", + "Causes": [ + "Niveau de charge de la batterie trop faible", + "Demande de charge dépassant temporairement la puissance maximale de décharge de la batterie", + "Capacité de la batterie réduite par vieillissement" + ], + "NextSteps": [ + "Attendre que la batterie se recharge via le solaire ou le réseau", + "Réduire la charge si possible lorsque la batterie est peu chargée", + "Cette alarme devrait se résoudre automatiquement une fois la batterie suffisamment chargée" + ] + }, + "Battery1BackupProhibited": { + "Explanation": "La batterie 1 est actuellement empêchée de fournir une alimentation de secours, généralement à cause d'un état de protection du BMS.", + "Causes": [ + "Le BMS de la batterie a activé une protection empêchant la décharge", + "Batterie en mode maintenance ou calibration", + "Niveau de charge de la batterie inférieur au minimum requis pour le mode secours" + ], + "NextSteps": [ + "Vérifier l'état du BMS et les indicateurs de défaut", + "Laisser la batterie se charger au-dessus du seuil minimum de SOC pour le secours", + "Réparer les problèmes du BMS, puis redémarrer l'onduleur" + ] + }, + "Battery2NotConnected": { + "Explanation": "La batterie 2 n'est pas détectée ou n'est pas connectée. L'onduleur ne trouve pas la deuxième batterie sur le bus DC.", + "Causes": [ + "Le disjoncteur de la batterie 2 est ouvert", + "Câble de batterie desserré ou déconnecté au niveau de l'onduleur ou de la borne de la batterie", + "Le BMS de la batterie 2 s'est arrêté en raison d'un événement de protection", + "Le fusible de la batterie 2 a sauté" + ], + "NextSteps": [ + "Vérifiez que le disjoncteur de la batterie 2 est en position MARCHE", + "Vérifiez les connexions des câbles de batterie au niveau de l'onduleur et des bornes de la batterie", + "Vérifiez l'état du BMS de la batterie 2 pour tout code de défaut", + "Inspectez et remplacez le fusible s'il a sauté, puis redémarrez l'onduleur" + ] + }, + "Battery2Overvoltage": { + "Explanation": "La tension de la batterie 2 est trop élevée. La charge a été limitée ou arrêtée pour protéger la batterie.", + "Causes": [ + "La batterie 2 est surchargée au-delà de sa tension maximale", + "Dysfonctionnement du BMS permettant à la tension de monter trop haut", + "Paramètres de tension de batterie incorrects dans l'onduleur" + ], + "NextSteps": [ + "Vérifiez l'état de charge et la tension de la batterie 2", + "Vérifiez les paramètres de charge dans la configuration de l'onduleur", + "Vérifiez le fonctionnement du BMS et tout indicateur de défaut, puis redémarrez" + ] + }, + "Battery2Undervoltage": { + "Explanation": "La tension de la batterie 2 est trop basse. La décharge a été limitée pour protéger la batterie d'une décharge profonde.", + "Causes": [ + "La batterie 2 a été déchargée trop profondément", + "Défaillance d'une cellule individuelle réduisant la capacité totale", + "Coupe de protection de tension basse du BMS" + ], + "NextSteps": [ + "Permettez à la batterie 2 de se recharger à partir du PV ou du réseau", + "Vérifiez l'état de la batterie — les batteries vieillissantes perdent de la capacité", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Battery2DischargeEnd": { + "Explanation": "La batterie 2 a atteint son état de charge minimum. La décharge a été arrêtée pour protéger la batterie.", + "Causes": [ + "La batterie 2 a été entièrement déchargée jusqu'à la limite de SOC configurée", + "Consommation d'énergie élevée dépassant la charge disponible" + ], + "NextSteps": [ + "Attendez que la batterie 2 se recharge à partir de l'énergie PV ou du réseau", + "Cette alarme se désactivera automatiquement une fois que la charge suffisante est restaurée" + ] + }, + "Battery2Inverted": { + "Explanation": "La polarité de la batterie 2 est inversée. Il s'agit d'une condition dangereuse qui doit être corrigée immédiatement.", + "Causes": [ + "Les câbles de la batterie 2 sont connectés avec le positif et le négatif inversés", + "Erreur d'installation lors du câblage initial" + ], + "NextSteps": [ + "ÉTEIGNEZ IMMEDIATEMENT tout le système", + "Déconnectez les câbles de la batterie 2 avec soin après avoir confirmé que l'alimentation est coupée", + "Reconnectez avec la bonne polarité et vérifiez tout dommage avant de redémarrer" + ] + }, + "Battery2OverloadTimeout": { + "Explanation": "La batterie 2 fonctionne en surcharge depuis trop longtemps.", + "Causes": [ + "Charge soutenue dépassant continuellement la capacité de décharge de la batterie 2", + "Dégradation de la batterie 2 réduisant la puissance disponible" + ], + "NextSteps": [ + "Réduire la charge totale du système", + "Vérifier si la batterie 2 est correctement dimensionnée pour les besoins de charge", + "Redémarrer l'onduleur après avoir réduit la charge" + ] + }, + "Battery2SoftStartFailure": { + "Explanation": "La batterie 2 n'a pas pu compléter la séquence de démarrage progressif.", + "Causes": [ + "Défaut du circuit de précharge pour la batterie 2", + "Déséquilibre de tension entre la batterie 2 et le bus DC" + ], + "NextSteps": [ + "Vérifier la tension de la batterie 2 et la comparer à celle du bus DC", + "Inspecter le circuit de précharge et les contacteurs de la batterie 2, puis redémarrer" + ] + }, + "Battery2PowerTubeFault": { + "Explanation": "Les composants électroniques de puissance (transistors IGBT ou MOSFET) de la batterie 2 ont échoué. Un service professionnel est nécessaire.", + "Causes": [ + "Défaillance du semi-conducteur de puissance due à une surcharge, un courant excessif ou une dégradation du composant", + "Événement de court-circuit endommageant l'étage de puissance" + ], + "NextSteps": [ + "Ne pas redémarrer le système", + "Contacter un technicien qualifié pour la réparation du matériel interne" + ] + }, + "Battery2InsufficientPower": { + "Explanation": "La batterie 2 ne peut pas fournir suffisamment de puissance pour répondre à la demande actuelle.", + "Causes": [ + "État de charge de la batterie 2 trop faible", + "Demande de charge dépassant la puissance maximale de décharge de la batterie 2", + "Capacité de la batterie réduite en raison du vieillissement" + ], + "NextSteps": [ + "Attendre que la batterie 2 se recharge", + "Réduire la charge lorsque la batterie est peu chargée", + "Cette alarme devrait se résoudre une fois la batterie rechargée" + ] + }, + "Battery2BackupProhibited": { + "Explanation": "La batterie 2 est actuellement interdite de fournir une alimentation de secours.", + "Causes": [ + "Protection active du BMS de la batterie 2 empêchant la décharge", + "État de charge de la batterie 2 en dessous du seuil minimum de secours" + ], + "NextSteps": [ + "Vérifier l'état du BMS de la batterie 2 pour les codes d'erreur", + "Permettre à la batterie 2 de se charger au-dessus du SOC minimum requis pour la sauvegarde, puis redémarrer" + ] + }, + "LithiumBattery1ChargeForbidden": { + "Explanation": "Le système de gestion de la batterie 1 a interdit la charge. La batterie ne peut pas être chargée en toute sécurité pour le moment.", + "Causes": [ + "La batterie est déjà complètement chargée — aucune charge supplémentaire n'est nécessaire", + "La température de la batterie est en dehors de la plage de charge sûre (trop chaude ou trop froide)", + "La protection du BMS s'est activée en raison d'un déséquilibre de tension des cellules ou d'un défaut interne", + "Déséquilibre des cellules nécessitant un équilibrage avant que la charge ne puisse reprendre" + ], + "NextSteps": [ + "Vérifiez la température de la batterie — la charge est généralement bloquée en dessous de 0°C ou au-dessus de ~45°C", + "Vérifiez l'affichage ou les indicateurs de l'état du BMS pour les codes de défaut", + "Laissez la batterie atteindre une température normale avant de la charger", + "Si le problème persiste à température normale, contactez le service de la batterie" + ] + }, + "LithiumBattery1DischargeForbidden": { + "Explanation": "Le système de gestion de la batterie 1 a interdit la décharge. La batterie ne peut pas être déchargée en toute sécurité pour le moment.", + "Causes": [ + "La batterie est à ou en dessous du niveau de charge minimum — trop vide pour être déchargée en toute sécurité", + "La température de la batterie est en dehors de la plage de décharge sûre", + "La protection de basse tension du BMS s'est activée", + "Déséquilibre des cellules ou événement de protection interne du BMS" + ], + "NextSteps": [ + "Laissez la batterie se recharger à partir du PV ou du réseau jusqu'à ce que le SOC soit au-dessus du seuil minimum", + "Vérifiez la température de la batterie — la décharge est bloquée dans des conditions très froides", + "Vérifiez l'état du BMS pour tout code de défaut spécifique", + "Si la batterie ne peut pas être rechargée, contactez le service de la batterie" + ] + }, + "LithiumBattery2ChargeForbidden": { + "Explanation": "Le système de gestion de la batterie 2 a interdit la charge.", + "Causes": [ + "La batterie 2 est déjà complètement chargée", + "La température de la batterie 2 est en dehors de la plage de charge sûre", + "Événement de protection du BMS sur la batterie 2" + ], + "NextSteps": [ + "Vérifiez la température de la batterie 2 et l'état du BMS", + "Laissez la température se normaliser avant de charger", + "Si le problème persiste, vérifiez les codes de défaut du BMS" + ] + }, + "LithiumBattery2DischargeForbidden": { + "Explanation": "Le système de gestion de la batterie 2 a interdit la décharge.", + "Causes": [ + "La batterie 2 est à son niveau de charge minimum", + "La température de la batterie 2 est en dehors de la plage de décharge sûre", + "Événement de protection du BMS sur la batterie 2" + ], + "NextSteps": [ + "Laissez la batterie 2 se recharger à partir du PV ou du réseau", + "Vérifiez la température de la batterie et l'état du BMS pour les codes de défaut", + "Si la batterie ne peut pas être rechargée, contactez le service de la batterie" + ] + }, + "LithiumBattery1Full": { + "Explanation": "La batterie lithium 1 est complètement chargée. La charge a été arrêtée automatiquement.", + "Causes": [ + "La batterie a atteint 100 % d'état de charge", + "La tension des cellules a atteint le niveau maximum sûr" + ], + "NextSteps": [ + "Ceci est un fonctionnement normal — aucune action requise", + "Surveillez périodiquement la santé de la batterie pour vous assurer que les cellules s'équilibrent correctement" + ] + }, + "LithiumBattery1DischargeEnd": { + "Explanation": "La batterie lithium 1 a atteint la fin de son cycle de décharge — niveau de charge minimal atteint.", + "Causes": [ + "La batterie a été déchargée jusqu'à la limite minimale de SOC configurée", + "Une consommation élevée la nuit ou en journée a épuisé la batterie" + ], + "NextSteps": [ + "Laissez la batterie se recharger à partir du solaire ou du réseau", + "Réduisez la consommation pendant les périodes de faible ensoleillement pour préserver la charge" + ] + }, + "LithiumBattery2Full": { + "Explanation": "La batterie lithium 2 est entièrement chargée. La charge a été arrêtée automatiquement.", + "Causes": [ + "La batterie 2 a atteint 100 % d'état de charge" + ], + "NextSteps": [ + "Ceci est une opération normale — aucune action requise", + "Le système reprendra automatiquement la charge si le SOC baisse" + ] + }, + "LithiumBattery2DischargeEnd": { + "Explanation": "La batterie lithium 2 a atteint la fin de son cycle de décharge.", + "Causes": [ + "La batterie 2 a été déchargée jusqu'à la limite minimale de SOC configurée" + ], + "NextSteps": [ + "Laissez la batterie 2 se recharger à partir du solaire ou du réseau", + "Cette alarme se désactivera automatiquement une fois la charge restaurée" + ] + }, + "LeadBatteryTemperatureAbnormality": { + "Explanation": "La température de la batterie plomb-acide est en dehors de la plage de fonctionnement normale.", + "Causes": [ + "Surchauffe de la batterie due à une température ambiante élevée ou à un courant de charge excessif", + "Défaillance du capteur de température donnant des lectures incorrectes", + "Température environnementale très froide ralentissant les réactions chimiques" + ], + "NextSteps": [ + "Vérifiez la température de la batterie si c'est sans danger", + "Améliorez la ventilation ou le refroidissement de la batterie en cas de surchauffe", + "Vérifiez que le capteur de température est correctement connecté et fonctionne", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "BatteryAccessMethodError": { + "Explanation": "La méthode d'accès à la batterie est incorrectement configurée — l'onduleur et la batterie ne sont pas configurés pour communiquer avec le même protocole.", + "Causes": [ + "Protocole de communication de la batterie incorrect sélectionné dans les paramètres de l'onduleur", + "Type ou modèle de batterie ne correspondant pas à la méthode d'accès configurée" + ], + "NextSteps": [ + "Vérifiez les paramètres de communication de la batterie dans la configuration de l'onduleur", + "Assurez-vous que le type de batterie et le protocole de communication correspondent à la batterie connectée, puis redémarrez" + ] + }, + "Pv1NotAccessed": { + "Explanation": "La chaîne PV 1 n'est pas détectée ou accessible. L'onduleur ne voit aucune tension ou courant de la chaîne PV 1.", + "Causes": [ + "Le disjoncteur ou l'isolateur de la chaîne PV 1 est ouvert (éteint)", + "Dommage au câble interrompant le circuit de la chaîne", + "Défaut de module PV dans la chaîne", + "Absence de soleil (nuit ou nuages épais)" + ], + "NextSteps": [ + "Vérifiez que le disjoncteur de la chaîne PV 1 est en position MARCHE", + "Vérifiez toutes les connexions de câbles sur la chaîne PV 1", + "Vérifiez l'ombrage ou les obstacles sur les panneaux", + "Réparer tout dommage de câble ou de connecteur, puis redémarrer" + ] + }, + "Pv1Overvoltage": { + "Explanation": "La tension de la chaîne PV 1 dépasse la tension d'entrée DC maximale de l'onduleur. Cela peut endommager l'onduleur.", + "Causes": [ + "Trop de modules PV connectés en série pour ce modèle d'onduleur", + "Température froide augmentant significativement la tension Voc des modules", + "Erreur de conception du système — la chaîne a été mal dimensionnée" + ], + "NextSteps": [ + "Vérifiez le nombre de modules en série et comparez-le à la tension d'entrée maximale spécifiée par l'onduleur", + "Vérifiez la tension Voc à la température la plus basse attendue sur le site — la tension doit rester en dessous du maximum de l'onduleur", + "Réduisez le nombre de modules en série si nécessaire" + ] + }, + "AbnormalPv1CurrentSharing": { + "Explanation": "Le partage de courant de la chaîne PV 1 est anormal, suggérant un flux de courant inégal dans la chaîne.", + "Causes": [ + "Modules PV non appariés avec des caractéristiques électriques différentes", + "Ombrage partiel sur certains panneaux activant les diodes de dérivation", + "Défaut de module réduisant le courant dans une partie de la chaîne" + ], + "NextSteps": [ + "Vérifiez l'ombrage ou la saleté sur les panneaux de la chaîne PV 1", + "Vérifiez que tous les modules de la chaîne sont du même modèle et non endommagés", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "Pv1PowerTubeFault": { + "Explanation": "Les composants électroniques de puissance (IGBT/MOSFET) du convertisseur DC de la PV 1 ont échoué. Il s'agit d'un défaut matériel.", + "Causes": [ + "Défaillance de l'IGBT ou du MOSFET due à une surintensité, une surtension ou une dégradation à long terme", + "Court-circuit ou surtension endommageant l'étage de puissance" + ], + "NextSteps": [ + "Ne redémarrez pas le système", + "Contactez un technicien de service qualifié pour la réparation matérielle" + ] + }, + "Pv1SoftStartFailure": { + "Explanation": "La chaîne PV 1 n'a pas pu compléter la séquence de démarrage progressif (pré-charge) lors du démarrage.", + "Causes": [ + "Défaut du circuit de pré-charge empêchant un démarrage contrôlé", + "Tension PV significativement différente du niveau de bus DC attendu" + ], + "NextSteps": [ + "Vérifiez la tension de la chaîne PV 1 aux bornes d'entrée de l'onduleur", + "Réparer tout défaut du circuit de pré-charge, puis redémarrer l'onduleur" + ] + }, + "Pv1OverloadTimeout": { + "Explanation": "La chaîne PV1 fournit trop de puissance au-delà de sa capacité nominale depuis trop longtemps.", + "Causes": [ + "Le champ photovoltaïque est surdimensionné par rapport à la capacité du convertisseur DC", + "La capacité du convertisseur DC est dépassée par une forte irradiation" + ], + "NextSteps": [ + "Vérifiez si la taille du champ photovoltaïque correspond à la puissance d'entrée DC de l'onduleur", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Pv1InsufficientPower": { + "Explanation": "La chaîne PV1 ne fournit pas assez de puissance. Cela est généralement dû aux conditions météorologiques.", + "Causes": [ + "Faible irradiation solaire due aux nuages ou à la météo", + "Ombre sur les panneaux de la chaîne PV1", + "Angles de soleil bas le matin ou le soir" + ], + "NextSteps": [ + "Attendez de meilleures conditions d'ensoleillement — cela se résoudra de lui-même", + "Vérifiez les nouvelles sources d'ombre comme les arbres, les bâtiments ou les débris", + "Cette alarme se désactivera automatiquement lorsque l'irradiation s'améliorera" + ] + }, + "Photovoltaic1Overcurrent": { + "Explanation": "Le courant de la chaîne PV1 dépasse le courant d'entrée DC maximal de l'onduleur.", + "Causes": [ + "Le champ photovoltaïque est surdimensionné avec trop de chaînes en parallèle", + "Défaut de mise à la terre créant un chemin de courant anormal", + "Court-circuit dans une partie de la chaîne PV" + ], + "NextSteps": [ + "Vérifiez la configuration de la chaîne PV1 — confirmez le nombre de chaînes en parallèle", + "Inspectez les défauts de mise à la terre ou les courts-circuits dans le câblage", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "Pv2NotAccessed": { + "Explanation": "La chaîne PV2 n'est pas détectée ou accessible.", + "Causes": [ + "Le sectionneur de la chaîne PV2 est ouvert", + "Dommage au câble de la chaîne 2", + "Aucun ensoleillement disponible" + ], + "NextSteps": [ + "Vérifiez que le sectionneur de la chaîne PV2 est activé", + "Vérifiez les connexions de câble de la chaîne 2", + "Réparer tout dommage trouvé, puis redémarrer l'onduleur" + ] + }, + "Pv2Overvoltage": { + "Explanation": "La tension de la chaîne PV2 dépasse la tension d'entrée DC maximale.", + "Causes": [ + "Trop de modules PV en série sur la chaîne 2", + "Température froide augmentant la tension Voc des modules au-dessus des limites de l'onduleur" + ], + "NextSteps": [ + "Vérifiez le nombre de modules et la tension Voc de la chaîne 2 par rapport à la spécification de l'onduleur", + "Réduisez les modules en série si nécessaire pour rester dans les limites de tension" + ] + }, + "AbnormalPv2CurrentSharing": { + "Explanation": "Le partage de courant de la chaîne PV 2 est anormal.", + "Causes": [ + "Modules dépareillés ou dégradés dans la chaîne 2", + "Ombre partielle sur les panneaux de la chaîne 2" + ], + "NextSteps": [ + "Vérifiez les panneaux de la chaîne 2 pour l'ombre ou la saleté", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "Pv2PowerTubeFault": { + "Explanation": "Les composants électroniques de puissance du convertisseur DC PV 2 ont échoué. Un service professionnel est requis.", + "Causes": [ + "Défaillance du semi-conducteur de puissance (IGBT/MOSFET)", + "Dommages causés par une surintensité ou une surtension" + ], + "NextSteps": [ + "Ne pas redémarrer le système", + "Contactez un technicien de service qualifié pour la réparation matérielle" + ] + }, + "Pv2SoftStartFailure": { + "Explanation": "La chaîne PV 2 n'a pas pu compléter la séquence de démarrage progressif.", + "Causes": [ + "Défaut de précharge sur le convertisseur PV 2", + "Déséquilibre de tension PV 2 avec le bus DC" + ], + "NextSteps": [ + "Vérifiez la tension d'entrée de la chaîne PV 2", + "Réparer le défaut de précharge, puis redémarrer l'onduleur" + ] + }, + "Pv2OverloadTimeout": { + "Explanation": "La chaîne PV 2 a fourni trop de puissance pendant trop longtemps.", + "Causes": [ + "La chaîne PV 2 est surdimensionnée par rapport à la puissance du convertisseur", + "Irradiation solaire prolongée dépassant les limites du convertisseur" + ], + "NextSteps": [ + "Vérifiez la taille de la chaîne PV 2 par rapport aux spécifications de l'onduleur", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Pv2InsufficientPower": { + "Explanation": "La chaîne PV 2 ne fournit pas assez de puissance. Généralement lié à la météo.", + "Causes": [ + "Faible irradiation solaire ou ombre importante sur la chaîne 2", + "Angle du soleil trop bas le matin ou le soir" + ], + "NextSteps": [ + "Attendez des conditions de soleil plus favorables", + "Vérifiez les nouvelles sources d'ombre sur les panneaux de la chaîne 2" + ] + }, + "Pv3NotConnected": { + "Explanation": "La chaîne PV 3 n'est pas connectée ou n'est pas détectée.", + "Causes": [ + "Le disjoncteur de la chaîne PV 3 est ouvert", + "Câble déconnecté ou endommagé sur la chaîne 3", + "Aucun ensoleillement disponible" + ], + "NextSteps": [ + "Vérifiez que le disjoncteur de la chaîne PV 3 est activé", + "Vérifiez les connexions des câbles sur la chaîne 3", + "Réparer les dommages éventuels, puis redémarrer" + ] + }, + "Pv3Overvoltage": { + "Explanation": "La tension de la chaîne PV 3 dépasse la tension d'entrée CC maximale.", + "Causes": [ + "Trop de modules PV en série sur la chaîne 3", + "Température froide faisant augmenter la tension Voc des modules au-delà des limites de l'onduleur" + ], + "NextSteps": [ + "Vérifiez le nombre de modules de la chaîne 3 par rapport à la tension d'entrée maximale spécifiée par l'onduleur", + "Réduisez le nombre de modules en série si la tension dépasse les limites à la température minimale du site" + ] + }, + "Pv3AverageCurrentAnomaly": { + "Explanation": "Le courant moyen de la chaîne PV 3 est anormal, indiquant une performance inégale dans la chaîne.", + "Causes": [ + "Désaccord ou dégradation des modules dans la chaîne 3", + "Ombre partielle affectant certains panneaux de la chaîne 3" + ], + "NextSteps": [ + "Inspectez les panneaux de la chaîne 3 pour détecter des ombres, de la saleté ou des dommages", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "Pv3PowerTubeFailure": { + "Explanation": "L'électronique de puissance du PV 3 a échoué. Un service professionnel est requis.", + "Causes": [ + "Défaillance du semi-conducteur de puissance due à une surcontrainte ou au vieillissement du composant", + "Dommages causés par une surintensité ou une surtension" + ], + "NextSteps": [ + "Ne redémarrez pas le système", + "Contactez un technicien de service qualifié pour la réparation du matériel interne" + ] + }, + "Pv3SoftStartFailure": { + "Explanation": "La chaîne PV 3 n'a pas pu compléter la séquence de démarrage progressif.", + "Causes": [ + "Défaut du circuit de précharge sur le convertisseur PV 3", + "Désaccord de tension entre le PV 3 et le bus CC" + ], + "NextSteps": [ + "Vérifiez la tension de la chaîne PV 3 aux bornes de l'onduleur", + "Réparer le défaut de précharge, puis redémarrer l'onduleur" + ] + }, + "Pv3OverloadTimeout": { + "Explanation": "La chaîne PV 3 fournit trop de puissance depuis trop longtemps.", + "Causes": [ + "La chaîne PV 3 est surdimensionnée par rapport à la capacité du convertisseur", + "Irradiation solaire élevée dépassant les limites du convertisseur DC" + ], + "NextSteps": [ + "Vérifiez la taille de la chaîne PV 3 par rapport aux spécifications de l'onduleur", + "Réparer la cause sous-jacente, puis redémarrez l'onduleur" + ] + }, + "Pv3ReverseConnection": { + "Explanation": "La chaîne PV 3 est connectée avec une polarité inversée. Il s'agit d'une erreur de câblage qui doit être corrigée avant la mise en service.", + "Causes": [ + "Les câbles positif et négatif de la chaîne PV 3 ont été inversés lors de l'installation", + "Connexion incorrecte des câbles à l'entrée DC de l'onduleur" + ], + "NextSteps": [ + "Ne tentez pas de redémarrer — la polarité inversée peut endommager les composants", + "Coupez complètement l'alimentation, puis échangez les connexions positif et négatif de la chaîne PV 3", + "Vérifiez la polarité correcte avant de redémarrer" + ] + }, + "Pv4NotConnected": { + "Explanation": "La chaîne PV 4 n'est pas connectée ou n'est pas détectée.", + "Causes": [ + "Le disjoncteur de la chaîne PV 4 est ouvert", + "Câble déconnecté ou endommagé sur la chaîne 4", + "Aucun ensoleillement disponible" + ], + "NextSteps": [ + "Vérifiez que le disjoncteur de la chaîne PV 4 est activé", + "Vérifiez les connexions des câbles sur la chaîne 4", + "Réparer les éventuels dommages, puis redémarrez" + ] + }, + "Pv4Overvoltage": { + "Explanation": "La tension de la chaîne PV 4 dépasse la tension d'entrée DC maximale.", + "Causes": [ + "Trop de modules PV en série sur la chaîne 4", + "Température froide faisant augmenter la tension Voc des modules au-dessus des limites de l'onduleur" + ], + "NextSteps": [ + "Vérifiez le nombre de modules de la chaîne 4 par rapport à la tension d'entrée maximale de l'onduleur", + "Réduisez le nombre de modules en série si la tension dépasse la spécification" + ] + }, + "Pv4AverageCurrentAnomaly": { + "Explanation": "Le courant moyen de la chaîne PV 4 est anormal.", + "Causes": [ + "Désaccord ou dégradation des modules dans la chaîne 4", + "Ombre partielle affectant les panneaux de la chaîne 4" + ], + "NextSteps": [ + "Inspectez les panneaux de la chaîne 4 pour détecter des ombres, de la saleté ou des dommages", + "Réparer le défaut sous-jacent, puis redémarrez l'onduleur" + ] + }, + "Pv4PowerTubeFailure": { + "Explanation": "Les composants électroniques de puissance du PV 4 ont échoué. Un service professionnel est nécessaire.", + "Causes": [ + "Défaillance du semi-conducteur de puissance due à une surcharge ou à l'usure", + "Dommages causés par une surintensité ou un événement de surtension" + ], + "NextSteps": [ + "Ne pas redémarrer le système", + "Contacter un technicien qualifié pour la réparation du matériel" + ] + }, + "Pv4SoftStartFailure": { + "Explanation": "La chaîne PV 4 n'a pas pu terminer la séquence de démarrage progressif.", + "Causes": [ + "Défaut du circuit de précharge sur le convertisseur PV 4", + "Déséquilibre de tension entre le PV 4 et le bus DC" + ], + "NextSteps": [ + "Vérifier la tension de la chaîne PV 4 aux bornes de l'onduleur", + "Réparer le défaut de précharge, puis redémarrer l'onduleur" + ] + }, + "Pv4OverloadTimeout": { + "Explanation": "La chaîne PV 4 a fourni trop de puissance pendant trop longtemps.", + "Causes": [ + "La chaîne PV 4 est surdimensionnée par rapport à la capacité du convertisseur", + "Irradiation solaire soutenue dépassant la capacité du convertisseur DC" + ], + "NextSteps": [ + "Vérifier la taille de la chaîne PV 4 par rapport aux spécifications de l'onduleur", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Pv4ReverseConnection": { + "Explanation": "La chaîne PV 4 est connectée avec une polarité inversée. Cela doit être corrigé avant la mise en service.", + "Causes": [ + "Les câbles positif et négatif de la chaîne PV 4 ont été inversés lors de l'installation", + "Connexion incorrecte des câbles à l'entrée DC de l'onduleur" + ], + "NextSteps": [ + "Ne pas redémarrer — couper complètement l'alimentation d'abord", + "Inverser les connexions positif et négatif de la chaîne PV 4 pour corriger la polarité", + "Vérifier la polarité avant de redémarrer" + ] + }, + "InsufficientPhotovoltaicPower": { + "Explanation": "La puissance PV disponible est insuffisante pour la charge actuelle ou les exigences du système.", + "Causes": [ + "Faible irradiation solaire due aux nuages ou aux conditions météorologiques", + "Tôt le matin ou en fin de journée — l'angle du soleil est trop bas pour une production optimale", + "Ombre importante sur une ou plusieurs chaînes PV" + ], + "NextSteps": [ + "Attendre de meilleures conditions d'ensoleillement — cela se résout généralement de lui-même", + "Vérifier les ombres sur les panneaux et les enlever si possible", + "Cette alarme se désactive automatiquement lorsque l'irradiation s'améliore" + ] + }, + "DcBusOvervoltage": { + "Explanation": "La tension du bus DC interne est trop élevée. Cela peut indiquer un déséquilibre énergétique dans le système.", + "Causes": [ + "Trop de puissance de charge entrant dans le bus DC sans charge pour la consommer", + "Charge régénérative alimentant de l'énergie dans le bus DC", + "Défaut de contrôle de la tension du bus DC" + ], + "NextSteps": [ + "Vérifiez l'équilibre entre la génération, la charge et le stockage", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "DcBusUndervoltage": { + "Explanation": "La tension du bus DC interne est trop basse, empêchant le fonctionnement normal.", + "Causes": [ + "La charge consomme plus de puissance que ce qui est disponible de toutes les sources", + "Problème d'alimentation ou de batterie limitant la tension du bus DC", + "Batterie presque déchargée" + ], + "NextSteps": [ + "Réduisez la charge sur le système", + "Vérifiez que toutes les sources d'énergie — PV, réseau et batterie — fonctionnent", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "DcBusVoltageUnbalance": { + "Explanation": "La tension du bus DC est déséquilibrée entre les moitiés positive et négative.", + "Causes": [ + "Défaillance d'un condensateur dans le banc de condensateurs du bus DC", + "Problème de contrôle du bus DC", + "Charge asymétrique entre les deux moitiés du bus DC" + ], + "NextSteps": [ + "Vérifiez le banc de condensateurs du bus DC pour les condensateurs défectueux", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "BusSlowOvervoltage": { + "Explanation": "Une augmentation lente et progressive de la tension du bus DC au-delà des limites de sécurité a été détectée.", + "Causes": [ + "Augmentation graduelle de la tension due à un déséquilibre de charge au fil du temps", + "Problème de contrôle de charge permettant une augmentation lente de la tension" + ], + "NextSteps": [ + "Vérifiez le contrôle de la puissance de charge et assurez-vous que les paramètres sont corrects", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "HardwareBusOvervoltage": { + "Explanation": "La protection matérielle contre la surtension du bus DC a été déclenchée. Il s'agit d'une condition de surtension sévère.", + "Causes": [ + "Événement de surtension sévère provenant d'une source externe ou d'une défaillance interne", + "Défaillance d'un composant entraînant une augmentation incontrôlée de la tension" + ], + "NextSteps": [ + "Ne pas redémarrer — cela nécessite une inspection professionnelle", + "Contactez un technicien de service pour enquêter sur la cause de la surtension" + ] + }, + "BusSoftStartFailure": { + "Explanation": "Le bus DC n'a pas pu se précharger et démarrer correctement au démarrage.", + "Causes": [ + "Défaut de la résistance ou du circuit de précharge", + "Défaillance du condensateur du bus DC empêchant une charge correcte", + "Relais ou contacteur du circuit de précharge ne fonctionnant pas correctement" + ], + "NextSteps": [ + "Vérifiez le circuit de précharge et tous les relais associés", + "Réparer le défaut sous-jacent, puis redémarrez l'onduleur" + ] + }, + "InverterPowerTubeFault": { + "Explanation": "Les composants électroniques principaux de l'onduleur (transistors IGBT ou MOSFET) ont échoué. Il s'agit d'une panne matérielle nécessitant une intervention professionnelle.", + "Causes": [ + "Défaillance du semi-conducteur de puissance due à une surcontrainte prolongée", + "Dommages dus à une surintensité provenant d'un court-circuit", + "Dommages thermiques dus à une surchauffe", + "Fin de vie du composant" + ], + "NextSteps": [ + "Ne tentez pas de redémarrer — une utilisation continue risque d'aggraver les dommages", + "Contactez immédiatement un technicien qualifié", + "Une réparation matérielle ou un remplacement de module est nécessaire" + ] + }, + "HardwareOvercurrent": { + "Explanation": "La protection matérielle contre les surintensités a déclenché — le courant a dépassé la limite matérielle absolue.", + "Causes": [ + "Court-circuit dans le câblage de sortie ou les charges connectées", + "Surcharge sévère dépassant le seuil de protection matérielle", + "Défaillance d'un composant électronique interne" + ], + "NextSteps": [ + "Ne redémarrez pas avant d'avoir identifié la cause", + "Contactez un technicien pour inspecter les courts-circuits et les dommages aux composants" + ] + }, + "DcConverterOvervoltage": { + "Explanation": "La tension d'entrée ou de sortie du convertisseur DC est trop élevée.", + "Causes": [ + "Tension d'entrée (PV ou batterie) dépassant les limites du convertisseur", + "Défaut de contrôle de tension du convertisseur DC" + ], + "NextSteps": [ + "Vérifiez les niveaux de tension PV et batterie", + "Réparer la cause sous-jacente, puis redémarrez l'onduleur" + ] + }, + "DcConverterHardwareOvervoltage": { + "Explanation": "La protection matérielle contre les survoltages du convertisseur DC a été déclenchée — une condition de survoltage sévère s'est produite.", + "Causes": [ + "Survoltage sévère à l'entrée ou à la sortie du convertisseur DC", + "Surge de foudre ou pic de tension externe" + ], + "NextSteps": [ + "Ne redémarrez pas — contactez un technicien pour inspecter les dommages avant toute autre opération" + ] + }, + "DcConverterOvercurrent": { + "Explanation": "Le courant du convertisseur CC est trop élevé.", + "Causes": [ + "Condition de surcharge entraînant un courant trop élevé dans le convertisseur", + "Court-circuit dans le circuit CC" + ], + "NextSteps": [ + "Réduire la charge ou la puissance de charge/décharge", + "Vérifier les courts-circuits, puis redémarrer l'onduleur" + ] + }, + "DcConverterHardwareOvercurrent": { + "Explanation": "La protection contre les surintensités du matériel du convertisseur CC a été déclenchée — la limite de courant absolue a été dépassée.", + "Causes": [ + "Surintensité sévère due à un court-circuit ou à une défaillance matérielle", + "Défaillance des composants électroniques de puissance entraînant un flux de courant incontrôlé" + ], + "NextSteps": [ + "Ne pas redémarrer — contacter un technicien de service pour inspecter les dommages avant toute autre opération" + ] + }, + "DcConverterResonatorOvercurrent": { + "Explanation": "Le circuit résonateur du convertisseur CC présente une surintensité.", + "Causes": [ + "Condition de résonance entraînant une oscillation de courant excessive dans le convertisseur", + "Problème de contrôle du convertisseur CC affectant le circuit résonant" + ], + "NextSteps": [ + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur ; si persistant, contacter le service" + ] + }, + "SystemOutputOverload": { + "Explanation": "La puissance de sortie totale du système est surchargée — plus de puissance est demandée que le système ne peut fournir en toute sécurité.", + "Causes": [ + "Trop de charges à haute puissance connectées simultanément", + "La demande totale de charge dépasse la capacité de sortie nominale de l'onduleur", + "Court-circuit dans l'une des charges connectées" + ], + "NextSteps": [ + "Déconnecter certaines charges pour réduire la consommation totale d'énergie", + "Vérifier les courts-circuits ou les défauts dans les équipements connectés", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "InverterOverload": { + "Explanation": "L'onduleur est surchargé — la charge consomme plus de puissance que l'onduleur ne peut fournir.", + "Causes": [ + "La puissance de la charge connectée dépasse la sortie continue nominale de l'onduleur", + "Courant d'appel élevé des grands moteurs ou compresseurs au démarrage", + "Court-circuit dans une charge connectée" + ], + "NextSteps": [ + "Réduire la charge totale connectée", + "Étaler le démarrage des gros appareils pour réduire le courant d'appel", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "InverterOverloadTimeout": { + "Explanation": "L'onduleur a été surchargé trop longtemps et a déclenché la protection.", + "Causes": [ + "Condition de surcharge prolongée dépassant la capacité de surcharge temporaire de l'onduleur", + "Onduleur sous-dimensionné par rapport aux besoins réels" + ], + "NextSteps": [ + "Réduire en permanence la charge connectée", + "Envisager de passer à un onduleur plus puissant si la charge est nécessaire", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "LoadPowerOverload": { + "Explanation": "La puissance de la charge connectée dépasse la capacité du système.", + "Causes": [ + "Trop d'appareils à haute puissance fonctionnant simultanément", + "Un nouvel appareil à haute puissance ajouté dépasse la capacité du système" + ], + "NextSteps": [ + "Réduire la charge en éteignant les appareils non essentiels", + "Étaler l'utilisation des appareils à haute puissance, puis redémarrer l'onduleur" + ] + }, + "BalancedCircuitOverloadTimeout": { + "Explanation": "Le circuit d'équilibrage des phases a été surchargé trop longtemps.", + "Causes": [ + "Charge déséquilibrée entre les phases — une phase supportant beaucoup plus que les autres", + "Une seule phase est significativement surchargée" + ], + "NextSteps": [ + "Répartir les charges plus uniformément sur les trois phases", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "InverterSoftStartFailure": { + "Explanation": "L'onduleur n'a pas pu compléter sa séquence de démarrage progressif lors de la mise sous tension.", + "Causes": [ + "Résistance de précharge défectueuse, empêchant la charge contrôlée du bus DC", + "Contacteur ou relais ne se fermant pas correctement pendant la séquence de démarrage", + "Problème de condensateur du bus DC affectant la précharge", + "Défaillance de la carte de contrôle empêchant l'achèvement de la séquence de démarrage" + ], + "NextSteps": [ + "Recyclage de l'alimentation du système — éteignez tous les dispositifs de déconnexion, attendez 30 secondes, puis rallumez", + "Vérifiez que la tension du bus DC augmente progressivement pendant la précharge", + "Si le défaut persiste, contactez un technicien de service" + ] + }, + "Dsp1ParameterSettingFault": { + "Explanation": "Le DSP 1 (processeur de signal numérique) a détecté une configuration de paramètres incorrecte.", + "Causes": [ + "Un ou plusieurs paramètres de l'onduleur définis en dehors de la plage valide", + "Corruption du micrologiciel affectant le stockage des paramètres", + "Incohérence de configuration après mise à jour du micrologiciel" + ], + "NextSteps": [ + "Examinez tous les paramètres de l'onduleur et corrigez les valeurs hors plage", + "Réinitialisez les paramètres aux valeurs d'usine si vous n'êtes pas sûr des valeurs correctes", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "Dsp2ParameterSettingFault": { + "Explanation": "Le DSP 2 a détecté une configuration de paramètres incorrecte.", + "Causes": [ + "Un ou plusieurs paramètres sont en dehors de la plage valide", + "Corruption du micrologiciel affectant le stockage des paramètres" + ], + "NextSteps": [ + "Vérifier et corriger les paramètres", + "Réparer la cause sous-jacente, puis redémarrer l'onduleur" + ] + }, + "DspVersionCompatibilityFault": { + "Explanation": "La version du micrologiciel DSP est incompatible avec d'autres composants du système.", + "Causes": [ + "Les versions du micrologiciel entre le DSP et les autres cartes ne correspondent pas", + "Mise à jour du micrologiciel incomplète ou échouée laissant les composants sur des versions différentes" + ], + "NextSteps": [ + "Mettre à jour tous les composants du micrologiciel vers une version compatible", + "Contacter le support technique si la version correcte est inconnue" + ] + }, + "CpldVersionCompatibilityFault": { + "Explanation": "La version du CPLD (dispositif logique programmable complexe) est incompatible avec le système.", + "Causes": [ + "Incompatibilité du micrologiciel CPLD avec d'autres composants", + "Mise à jour du micrologiciel incomplète" + ], + "NextSteps": [ + "Effectuer une mise à jour complète du micrologiciel pour s'assurer que tous les composants sont sur des versions correspondantes", + "Redémarrer l'onduleur après la mise à jour" + ] + }, + "CpldCommunicationFault": { + "Explanation": "La communication avec la puce interne CPLD a échoué.", + "Causes": [ + "Défaillance du bus de communication interne entre le DSP et le CPLD", + "Défaillance de la puce CPLD" + ], + "NextSteps": [ + "Redémarrer le système — cela peut rétablir la communication", + "Si le défaut persiste après le redémarrage, contacter un technicien de service" + ] + }, + "DspCommunicationFault": { + "Explanation": "La communication avec le DSP a échoué.", + "Causes": [ + "Défaillance du bus de communication interne", + "Défaillance matérielle du DSP" + ], + "NextSteps": [ + "Redémarrer le système", + "Si le défaut persiste après le redémarrage, contacter un technicien de service" + ] + }, + "OutputVoltageDcOverlimit": { + "Explanation": "Une composante de tension continue est apparue dans la tension de sortie alternative, dépassant la limite autorisée.", + "Causes": [ + "Dérive de la boucle de contrôle introduisant un décalage continu dans la sortie", + "Erreur de décalage du capteur de tension", + "Problème matériel dans l'étage de sortie" + ], + "NextSteps": [ + "Redémarrez l'onduleur — cela élimine souvent les décalages transitoires", + "Si le problème persiste, contactez un technicien de service" + ] + }, + "OutputCurrentDcOverlimit": { + "Explanation": "Une composante de courant continu est apparue dans le courant de sortie alternatif, dépassant la limite autorisée.", + "Causes": [ + "Problème de contrôle introduisant un décalage continu dans le courant de sortie", + "Défaillance ou erreur de calibration du capteur de courant" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le défaut persiste, contactez le service pour une inspection du capteur" + ] + }, + "RelaySelfCheckFails": { + "Explanation": "L'auto-test du relais a échoué lors du démarrage ou des tests périodiques.", + "Causes": [ + "Défaillance des contacts du relais — ils peuvent être endommagés ou soudés", + "Défaillance du circuit de commande du relais", + "Les contacts du relais ont été soudés par surintensité" + ], + "NextSteps": [ + "Vérifiez le fonctionnement du relais en écoutant les clics lors du démarrage", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "InverterRelayOpen": { + "Explanation": "Le relais de sortie de l'onduleur est ouvert alors qu'il devrait être fermé.", + "Causes": [ + "Défaillance du circuit de commande du relais empêchant sa fermeture", + "Un événement de protection a ouvert le relais" + ], + "NextSteps": [ + "Vérifiez les autres alarmes de protection actives qui pourraient avoir ouvert le relais", + "Réparer le défaut sous-jacent, puis redémarrer l'onduleur" + ] + }, + "InverterRelayShortCircuit": { + "Explanation": "Les contacts du relais de l'onduleur sont soudés (court-circuit). Le relais ne peut pas s'ouvrir quand nécessaire.", + "Causes": [ + "Contacts du relais soudés par un courant excessif lors d'un événement de défaut", + "Défaillance d'un composant du relais" + ], + "NextSteps": [ + "Ne redémarrez pas — un relais soudé est un danger", + "Contactez un technicien de service pour inspecter et remplacer le relais" + ] + }, + "OpenCircuitOfPowerGridRelay": { + "Explanation": "Le relais de connexion au réseau est ouvert de manière inattendue.", + "Causes": [ + "Défaut du relais réseau empêchant la fermeture normale", + "Un événement de protection a ouvert le relais du réseau", + "Problème du circuit de commande du relais" + ], + "NextSteps": [ + "Vérifiez les autres alarmes actives qui pourraient expliquer l'ouverture du relais", + "Inspectez le relais et le circuit de commande, puis redémarrez l'onduleur" + ] + }, + "ShortCircuitOfPowerGridRelay": { + "Explanation": "Les contacts du relais du réseau sont soudés et ne peuvent pas s'ouvrir.", + "Causes": [ + "Contacts du relais soudés par un courant excessif dû à un défaut", + "Défaillance ou fin de vie du composant du relais" + ], + "NextSteps": [ + "Ne redémarrez pas — contactez un technicien pour remplacer le relais avant de remettre en service" + ] + }, + "GeneratorRelayOpenCircuit": { + "Explanation": "Le relais de connexion au générateur est ouvert de manière inattendue.", + "Causes": [ + "Défaut du relais du générateur empêchant la fermeture", + "Événement de protection ayant ouvert le relais", + "Problème du circuit de commande du relais" + ], + "NextSteps": [ + "Vérifiez les autres alarmes actives qui pourraient expliquer l'état du relais", + "Inspectez le circuit du relais, puis redémarrez l'onduleur" + ] + }, + "GeneratorRelayShortCircuit": { + "Explanation": "Les contacts du relais du générateur sont soudés et ne peuvent pas s'ouvrir.", + "Causes": [ + "Contacts du relais soudés par un courant excessif", + "Défaillance du composant du relais du générateur" + ], + "NextSteps": [ + "Ne redémarrez pas — contactez un technicien pour remplacer le relais du générateur avant la mise en service" + ] + }, + "AbnormalInverter": { + "Explanation": "Une anomalie générale de l'onduleur a été détectée. Vérifiez les autres codes d'alarmes plus spécifiques qui pourraient indiquer la cause racine.", + "Causes": [ + "Défaut du système de contrôle interne sans diagnostic plus spécifique disponible", + "Plusieurs défauts mineurs survenant simultanément", + "Électronique de puissance fonctionnant en dehors des paramètres normaux" + ], + "NextSteps": [ + "Redémarrez l'onduleur et vérifiez si d'autres alarmes spécifiques apparaissent au redémarrage", + "Vérifiez toutes les tensions d'entrée et les niveaux de charge pour des valeurs anormales", + "Si l'alerte persiste, contactez un technicien avec le journal complet des alarmes" + ] + }, + "ParallelCommunicationAlarm": { + "Explanation": "La communication entre les onduleurs connectés en parallèle a échoué. Sans communication, les onduleurs ne peuvent pas se synchroniser et partager correctement la charge.", + "Causes": [ + "Le câble de communication entre les onduleurs parallèles est endommagé ou déconnecté", + "Défaillance de l'interface de communication parallèle sur un appareil", + "Paramètres non compatibles entre les unités parallèles" + ], + "NextSteps": [ + "Vérifiez tous les câbles de communication parallèle entre les unités d'onduleurs", + "Assurez-vous que tous les paramètres parallèles (tension, fréquence, réglages de décroissance) correspondent sur toutes les unités", + "Réparer le problème sous-jacent, puis redémarrer le système d'onduleurs" + ] + }, + "ParallelModuleMissing": { + "Explanation": "Un des modules d'onduleurs parallèles attendus ne répond pas.", + "Causes": [ + "Un module parallèle est hors ligne ou éteint", + "La liaison de communication avec un module a été perdue", + "Un module a déclenché une alarme interne" + ], + "NextSteps": [ + "Vérifiez tous les onduleurs parallèles pour des alarmes individuelles ou une perte de courant", + "Réparer le problème sous-jacent sur le module manquant, puis redémarrer" + ] + }, + "DuplicateMachineNumbersForParallelModules": { + "Explanation": "Deux modules d'onduleurs parallèles ont été configurés avec le même numéro d'unité, provoquant un conflit.", + "Causes": [ + "Erreur de configuration — le même numéro d'unité a été attribué à deux unités différentes lors de la configuration", + "Adresse en double non détectée lors de la mise en service initiale" + ], + "NextSteps": [ + "Accédez aux paramètres de chaque unité et attribuez un numéro d'unité unique à chacune", + "Réparer la configuration, puis redémarrer le système d'onduleurs" + ] + }, + "ParameterConflictInParallelModule": { + "Explanation": "Un conflit de paramètres existe entre les modules d'onduleurs connectés en parallèle — leurs réglages ne correspondent pas.", + "Causes": [ + "Les paramètres clés tels que la tension de consigne, la fréquence ou les réglages de décroissance diffèrent entre les unités", + "Une unité a été mise à jour ou reconfigurée sans mettre à jour les autres" + ], + "NextSteps": [ + "Comparez les paramètres sur toutes les unités parallèles et synchronisez-les aux mêmes valeurs", + "Résolvez le conflit de configuration, puis redémarrez le système" + ] + }, + "SystemDerating": { + "Explanation": "Le système fonctionne à une puissance réduite (réduction) pour se protéger. Les performances seront inférieures aux niveaux nomiaux jusqu'à ce que la cause sous-jacente soit résolue.", + "Causes": [ + "Température élevée de l'onduleur entraînant une réduction thermique", + "Tension d'entrée (PV ou réseau) à la limite de la plage de fonctionnement", + "Un composant atteint ses limites opérationnelles" + ], + "NextSteps": [ + "Vérifiez la température de l'onduleur et améliorez la ventilation en cas de surchauffe", + "Vérifiez que les tensions d'entrée sont dans la plage de fonctionnement normale de l'onduleur", + "Identifiez et résolvez la cause spécifique de la réduction — vérifiez si d'autres alarmes sont également actives" + ] + }, + "PvAccessMethodErrorAlarm": { + "Explanation": "La configuration de l'entrée PV est incorrectement définie, ce qui provoque une incompatibilité entre le câblage physique et la configuration logicielle.", + "Causes": [ + "Le câblage des chaînes PV ne correspond pas à la configuration sélectionnée (par exemple, réglage série vs parallèle incorrect)", + "Le câblage est connecté d'une manière qui ne correspond pas à la méthode d'accès PV configurée de l'onduleur" + ], + "NextSteps": [ + "Vérifiez les paramètres de configuration PV et comparez-les avec le câblage physique réel", + "Corrigez soit les paramètres, soit le câblage pour les faire correspondre, puis redémarrez" + ] + }, + "ReservedAlarms4": { + "Explanation": "L'alarme réservée 4 est active. Ce code d'alarme n'est pas documenté dans les tables d'alarmes standard.", + "Causes": [ + "Une condition interne non documentée a été détectée" + ], + "NextSteps": [ + "Surveillez le système pour d'autres alarmes qui pourraient donner plus de contexte", + "Contactez le support technique avec le journal complet des alarmes si cela persiste" + ] + }, + "ReservedAlarms5": { + "Explanation": "L'alarme réservée 5 est active. Ce code d'alarme n'est pas documenté dans les tables d'alarmes standard.", + "Causes": [ + "Une condition interne non documentée a été détectée" + ], + "NextSteps": [ + "Surveillez le système pour d'autres alarmes qui pourraient donner plus de contexte", + "Contactez le support technique avec le journal complet des alarmes si cela persiste" + ] + }, + "ReverseMeterConnection": { + "Explanation": "Le compteur d'énergie est installé ou câblé à l'envers. Les relevés du compteur (importation/exportation) seront incorrects jusqu'à ce que cela soit corrigé.", + "Causes": [ + "Le transformateur de courant (CT) est installé dans le mauvais sens", + "Les fils L et N du compteur sont connectés à l'envers lors de l'installation" + ], + "NextSteps": [ + "Ne vous fiez pas aux relevés du compteur jusqu'à ce que cela soit corrigé", + "Contactez votre installateur ou un électricien qualifié pour inverser le CT ou corriger le câblage du compteur" + ] + }, + "InverterSealPulse": { + "Explanation": "Le signal d'impulsion de scellement de l'onduleur est actif, indiquant que la limitation de sortie est en vigueur.", + "Causes": [ + "Une fonction de protection a activé la limitation de sortie", + "Signal externe ou fonction de conformité au code de la grille limitant la sortie" + ], + "NextSteps": [ + "Vérifiez l'état du système pour d'autres alarmes actives expliquant la limitation", + "Réparer la cause sous-jacente, puis redémarrez l'onduleur" + ] + }, + "AbnormalDieselGeneratorVoltage": { + "Explanation": "La tension du générateur diesel est en dehors de la plage acceptable pour que l'onduleur puisse s'y connecter.", + "Causes": [ + "Tension de sortie du générateur non ajustée au niveau correct", + "Défaut du régulateur automatique de tension (AVR) du générateur", + "Charge du générateur insuffisante ou excessive affectant la tension de sortie" + ], + "NextSteps": [ + "Vérifier et ajuster la tension de sortie du générateur pour qu'elle corresponde aux spécifications de l'onduleur", + "Inspecter l'AVR si la tension ne peut pas être stabilisée, puis redémarrer" + ] + }, + "AbnormalDieselGeneratorFrequency": { + "Explanation": "La fréquence du générateur diesel est en dehors de la plage acceptable.", + "Causes": [ + "Vitesse du moteur du générateur non réglée correctement pour la fréquence cible", + "Défaut du régulateur de vitesse entraînant une instabilité de fréquence" + ], + "NextSteps": [ + "Ajuster la vitesse du générateur pour obtenir la fréquence correcte (50 Hz ou 60 Hz selon le cas)", + "Inspecter et réparer le régulateur de vitesse si la fréquence ne peut pas être stabilisée, puis redémarrer" + ] + }, + "DieselGeneratorVoltageReverseSequence": { + "Explanation": "Le générateur diesel est connecté avec une séquence de phase inversée.", + "Causes": [ + "Fils de sortie du générateur connectés dans le mauvais ordre de phase (L1, L2, L3 intervertis)" + ], + "NextSteps": [ + "Ne pas redémarrer — contacter un électricien qualifié pour corriger le câblage de phase du générateur avant de l'utiliser" + ] + }, + "DieselGeneratorVoltageOutOfPhase": { + "Explanation": "La tension du générateur est en déphasage avec le réseau ou le système, empêchant la synchronisation.", + "Causes": [ + "Problème de synchronisation — le générateur ne se verrouille pas sur l'angle de phase du réseau", + "Décalage d'angle de phase entre le générateur et le réseau" + ], + "NextSteps": [ + "Vérifier les paramètres de synchronisation et s'assurer que le générateur supporte la synchronisation automatique avec cet onduleur", + "Réparer le défaut de synchronisation, puis redémarrer" + ] + }, + "GeneratorOverload": { + "Explanation": "Le générateur diesel est surchargé — le système consomme plus de puissance que le générateur ne peut fournir.", + "Causes": [ + "La demande totale de charge dépasse la capacité nominale du générateur", + "La charge de la batterie combinée à la demande de charge dépasse la capacité du générateur", + "Le générateur est trop petit pour l'installation" + ], + "NextSteps": [ + "Réduire la charge ou réduire le taux de charge de la batterie pour ramener la demande totale dans la capacité du générateur", + "Redémarrer l'onduleur après avoir réduit la charge" + ] + }, + "StringFault": { + "Explanation": "Un défaut de chaîne a été détecté. Une ou plusieurs chaînes de panneaux solaires peuvent avoir des problèmes affectant la production d'énergie.", + "Causes": [ + "Défaut ou dommage d'un panneau PV dans la chaîne", + "Problème de câblage ou connexion desserrée dans la chaîne", + "Connecteur MC4 endommagé ou corrodé", + "Dégradation du module réduisant ou supprimant la production" + ], + "NextSteps": [ + "Vérifiez visuellement les panneaux PV — cherchez des fissures, décolorations ou dommages", + "Inspectez les connexions des câbles et les connecteurs MC4 pour détecter des dommages ou de la corrosion", + "Cherchez des câbles endommagés le long du trajet de la chaîne", + "Faites tester chaque chaîne avec un multimètre par un technicien si le défaut persiste" + ] + }, + "PvStringPidQuickConnectAbnormal": { + "Explanation": "La connexion rapide des chaînes PV ou des bornes PID est anormale.", + "Causes": [ + "Borne de connexion rapide desserrée ou mal enclenchée", + "Boîtier de connexion rapide endommagé", + "Corrosion ou oxydation sur les contacts" + ], + "NextSteps": [ + "Éteignez le système avant d'inspecter les bornes", + "Vérifiez toutes les connexions rapides et assurez-vous qu'elles sont bien enclenchées", + "Nettoyez les contacts corrodés et reconnectez-les solidement" + ] + }, + "DcSpdFunctionAbnormal": { + "Explanation": "La fonction du dispositif de protection contre les surtensions (SPD) en courant continu est anormale. Le SPD protège contre la foudre et les surtensions du côté DC.", + "Causes": [ + "Le SPD DC a déclenché ou a échoué après un événement de surtension", + "La cartouche du SPD a atteint la fin de sa durée de vie", + "Défaut de câblage du SPD" + ], + "NextSteps": [ + "Éteignez le système et vérifiez l'indicateur du SPD DC — la plupart des SPDs ont un drapeau de défaut visuel", + "Remplacez la cartouche du SPD si elle a déclenché ou montre un défaut", + "Redémarrez l'onduleur après le remplacement ou l'inspection" + ] + }, + "PvShortCircuited": { + "Explanation": "La chaîne PV1 ou PV2 semble être en court-circuit.", + "Causes": [ + "Dommage de l'isolation du câble causant un court-circuit direct entre les conducteurs positif et négatif", + "Défaillance du connecteur MC4 causant un court-circuit interne", + "Défaut de la boîte de jonction du module créant un chemin de court-circuit" + ], + "NextSteps": [ + "Éteignez tous les sectionneurs DC avant l'inspection", + "Vérifiez les chaînes PV1 et PV2 individuellement pour des symptômes de court-circuit (tension nulle, chaleur anormale)", + "Inspectez les câbles pour détecter des dommages et testez la résistance d'isolation", + "Réparer ou remplacer les câbles/connecteurs endommagés avant de redémarrer" + ] + }, + "PvBoostDriverAbnormal": { + "Explanation": "Le circuit de commande du convertisseur élévateur PV est anormal.", + "Causes": [ + "Défaut du circuit de commande ou défaillance d'un composant", + "Interférence EMI affectant le signal de commande", + "Problème matériel interne sur la carte de l'onduleur" + ], + "NextSteps": [ + "Redémarrez l'onduleur — les défauts transitoires de commande disparaissent souvent après un redémarrage", + "Si le défaut persiste après le redémarrage, contactez le fabricant pour une assistance" + ] + }, + "AcSpdFunctionAbnormal": { + "Explanation": "La fonction de protection contre les surtensions (SPD) sur le côté AC est anormale. Le SPD protège contre la foudre et les surtensions.", + "Causes": [ + "Le SPD AC a déclenché ou a échoué après un événement de surtension", + "La cartouche du SPD a atteint la fin de sa durée de vie", + "Défaut de câblage du SPD AC" + ], + "NextSteps": [ + "Éteignez le système et vérifiez l'indicateur du SPD AC", + "Remplacez la cartouche du SPD AC si elle affiche une erreur ou a déclenché", + "Redémarrez l'onduleur après le remplacement ou l'inspection" + ] + }, + "DcFuseBlown": { + "Explanation": "Le fusible DC a grillé, interrompant l'entrée PV vers l'onduleur.", + "Causes": [ + "Surintensité dans le circuit DC provenant de l'ensemble PV dépassant la limite du fusible", + "Court-circuit dans le câblage DC provoquant la fusion du fusible", + "Fatigue du fusible après des événements répétés de surintensité" + ], + "NextSteps": [ + "Éteignez tous les interrupteurs et sectionneurs DC avant de travailler sur le circuit", + "Localisez et inspectez le fusible DC — il apparaîtra visiblement grillé ou mesurera ouvert avec un multimètre", + "Identifiez et réparez la cause de la surintensité avant de remplacer le fusible", + "Remplacez le fusible par un de la bonne puissance, puis redémarrez l'onduleur" + ] + }, + "DcInputVoltageTooHigh": { + "Explanation": "La tension DC d'entrée provenant de l'ensemble PV dépasse la tension d'entrée maximale sûre de l'onduleur. Cela peut endommager immédiatement l'onduleur.", + "Causes": [ + "Trop de modules PV connectés en série, dépassant la tension maximale de la chaîne", + "Température froide augmentant la tension de circuit ouvert (Voc) des modules au-dessus de la limite de l'onduleur", + "Erreur de conception du système — la chaîne a été incorrectement dimensionnée pour cet onduleur" + ], + "NextSteps": [ + "Éteignez immédiatement l'interrupteur DC pour protéger l'onduleur", + "Mesurez la tension DC réelle avant de reconnecter", + "Vérifiez à nouveau la conception de la chaîne — assurez-vous que la Voc à la température minimale attendue ne dépasse pas la tension maximale de l'onduleur", + "Reconfigurez la chaîne en réduisant les modules en série si nécessaire" + ] + }, + "PvReversed": { + "Explanation": "La polarité de la chaîne PV est inversée — les connexions positive et négative sont échangées.", + "Causes": [ + "Les câbles de la chaîne PV connectés avec la polarité positive et négative inversée au niveau de l'onduleur ou de la boîte de jonction", + "Erreur d'installation lors du câblage initial" + ], + "NextSteps": [ + "Éteignez tous les sectionneurs DC avant de travailler sur le câblage", + "Identifiez la connexion inversée — vérifiez la polarité de la chaîne PV avec un multimètre", + "Échangez les connexions positive et négative pour corriger la polarité avant de redémarrer" + ] + }, + "PidFunctionAbnormal": { + "Explanation": "La fonction de protection contre la dégradation induite par le potentiel (PID) est anormale.", + "Causes": [ + "Défaut du module PID ou erreur de configuration", + "Problème de communication entre l'onduleur et le module PID" + ], + "NextSteps": [ + "Redémarrez l'onduleur — cela résout souvent les défauts transitoires du PID", + "Vérifiez les paramètres et les connexions du module PID si le problème persiste après le redémarrage" + ] + }, + "PvStringDisconnected": { + "Explanation": "Une chaîne PV est déconnectée ou ne fournit pas d'électricité.", + "Causes": [ + "Le disjoncteur ou isolateur DC de cette chaîne est ouvert", + "Un câble s'est desserré ou déconnecté à un connecteur", + "Défaillance du connecteur MC4" + ], + "NextSteps": [ + "Vérifiez que tous les disjoncteurs de chaîne PV sont en position MARCHE", + "Vérifiez les connexions des câbles aux extrémités du panneau et de l'onduleur", + "Reconnectez les connexions desserrées et redémarrez l'onduleur" + ] + }, + "PvStringCurrentUnbalanced": { + "Explanation": "Les courants des différentes chaînes PV sont significativement déséquilibrés, indiquant qu'une chaîne fonctionne moins bien que les autres.", + "Causes": [ + "Ombre sur certains modules d'une chaîne mais pas les autres", + "Incompatibilité ou dégradation des modules dans une partie du champ", + "Défaillance partielle de la chaîne — certains modules ne contribuent pas", + "Salissures ou déjections d'oiseaux sur les panneaux d'une zone" + ], + "NextSteps": [ + "Vérifiez tous les panneaux PV pour l'ombre, les salissures ou les dommages visibles", + "Comparez les tensions et courants des chaînes individuellement pour identifier la chaîne sous-performante", + "Nettoyez les panneaux si des salissures sont visibles et vérifiez les nouvelles sources d'ombre" + ] + }, + "NoUtilityGrid": { + "Explanation": "Aucune connexion au réseau électrique n'est détectée, ou l'alimentation du réseau a échoué.", + "Causes": [ + "Panne du réseau électrique dans votre zone", + "Le disjoncteur AC entre l'onduleur et le réseau a sauté", + "Câble AC déconnecté au niveau de l'onduleur ou du tableau de distribution", + "Travaux de maintenance du réseau déconnectant l'alimentation locale" + ], + "NextSteps": [ + "Vérifiez si d'autres appareils dans le bâtiment ont de l'électricité — si non, c'est une panne du réseau", + "Vérifiez que le disjoncteur AC est en position MARCHE et n'a pas sauté", + "Vérifiez les connexions des câbles AC au niveau de l'onduleur", + "Attendez que le réseau rétablisse l'alimentation si c'est une panne du réseau" + ] + }, + "GridVoltageOutOfRange": { + "Explanation": "La tension du réseau électrique est en dehors de la plage dans laquelle l'onduleur est autorisé à fonctionner.", + "Causes": [ + "La tension du réseau est trop élevée ou trop basse à votre point de connexion", + "Problèmes locaux du réseau tels que surcharge ou problèmes de transformateur", + "Réglage du transformateur non optimal pour votre emplacement" + ], + "NextSteps": [ + "Vérifiez la tension réelle du réseau aux bornes de l'onduleur", + "Si la tension du réseau est constamment hors plage, contactez votre fournisseur d'électricité", + "L'onduleur se reconnectera automatiquement lorsque la tension reviendra à la normale" + ] + }, + "GridFrequencyOutOfRange": { + "Explanation": "La fréquence du réseau électrique est en dehors de la plage dans laquelle l'onduleur est autorisé à fonctionner.", + "Causes": [ + "Fréquence du réseau instable en raison d'événements de charge élevée sur le réseau", + "Si vous utilisez un générateur, la fréquence du générateur a dérivé en dehors de la tolérance", + "Événement de perturbation du réseau" + ], + "NextSteps": [ + "Vérifiez la fréquence réelle du réseau aux bornes de l'onduleur", + "Si vous êtes sur générateur, ajustez le régulateur pour corriger la fréquence de sortie", + "Attendez que le réseau se stabilise — l'onduleur se reconnectera automatiquement" + ] + }, + "Overload": { + "Explanation": "Le système est en surcharge — la demande de puissance dépasse la capacité de l'onduleur à fournir à la sortie de secours (EPS).", + "Causes": [ + "La charge totale connectée à la sortie EPS dépasse la capacité de secours de l'onduleur", + "Courant d'appel des appareils avec moteurs ou compresseurs en démarrage", + "Court-circuit dans l'une des charges de secours" + ], + "NextSteps": [ + "Réduire la charge sur la sortie EPS en éteignant les appareils non essentiels", + "Vérifier les appareils défectueux qui pourraient consommer trop de courant", + "Étaler le démarrage des gros appareils pour réduire le courant d'appel" + ] + }, + "MeterDisconnected": { + "Explanation": "Le compteur d'énergie a perdu la communication avec l'onduleur.", + "Causes": [ + "Le compteur d'énergie est éteint ou a perdu son alimentation", + "Le câble de communication entre l'onduleur et le compteur est endommagé ou déconnecté", + "Défaillance du port de communication du compteur" + ], + "NextSteps": [ + "Vérifier que le compteur d'énergie est sous tension et allumé", + "Vérifier les connexions du câble de communication au niveau de l'onduleur et du compteur", + "Vérifier l'alimentation du compteur et son port de communication" + ] + }, + "MeterReverselyConnected": { + "Explanation": "Les fils L (ligne) et N (neutre) du compteur sont connectés à l'envers.", + "Causes": [ + "Les fils L et N ont été inversés lors de l'installation du compteur", + "Erreur d'installation — fréquente lorsque la polarité du compteur n'est pas vérifiée" + ], + "NextSteps": [ + "Faire vérifier et corriger le câblage du compteur par un électricien qualifié", + "Inverser les connexions L et N au niveau du terminal du compteur pour corriger la polarité" + ] + }, + "LinePeVoltageAbnormal": { + "Explanation": "Une tension anormale a été détectée entre le fil neutre (N) et la terre de protection (PE). Cela peut indiquer un défaut de mise à la terre ou de câblage.", + "Causes": [ + "Connexion PE (terre de protection) manquante ou défectueuse", + "Les fils N et PE sont court-circuités à un endroit de l'installation", + "Défaut de mise à la terre quelque part dans le câblage du bâtiment" + ], + "NextSteps": [ + "Mettre hors tension le système avant d'inspecter le câblage", + "Vérifier que le câble PE (terre) est bien connecté à l'onduleur et au tableau de distribution", + "Vérifier l'intégrité du système de mise à la terre — faire inspecter par un électricien qualifié si nécessaire" + ] + }, + "PhaseSequenceError": { + "Explanation": "Une erreur de séquence de phase a été détectée dans la connexion triphasée. L'onduleur tentera de corriger automatiquement.", + "Causes": [ + "Les fils triphasés sont connectés dans le mauvais ordre (L1, L2, L3 inversés)" + ], + "NextSteps": [ + "Aucune action immédiate requise — le PCS ajustera automatiquement la séquence de phase dans la plupart des cas", + "Si l'alarme persiste, faire vérifier et corriger l'ordre de câblage des phases par un électricien" + ] + }, + "FanFailure": { + "Explanation": "Une défaillance du ventilateur de refroidissement a été détectée. Sans refroidissement adéquat, l'onduleur surchauffera et s'arrêtera.", + "Causes": [ + "Défaillance du moteur du ventilateur — le ventilateur ne tourne plus", + "Les pales du ventilateur sont bloquées par des débris ou des objets étrangers", + "Le connecteur d'alimentation du ventilateur est desserré ou déconnecté", + "Défaut du circuit de commande du ventilateur" + ], + "NextSteps": [ + "Éteignez l'onduleur avant d'inspecter le ventilateur", + "Vérifiez si le ventilateur tourne librement et n'est pas obstrué", + "Vérifiez que le connecteur d'alimentation du ventilateur est bien fixé", + "Remplacez le ventilateur s'il est défectueux — ne faites pas fonctionner l'onduleur sans refroidissement" + ] + }, + "MeterAbnormal": { + "Explanation": "Le compteur d'énergie signale des lectures anormales.", + "Causes": [ + "Dysfonctionnement ou défaut interne du compteur", + "Configuration ou échelle incorrecte du compteur", + "Problème de communication entraînant des erreurs de données" + ], + "NextSteps": [ + "Vérifiez que le compteur est allumé et fonctionne", + "Vérifiez que la configuration du compteur correspond aux paramètres de l'onduleur (rapport CT, protocole de communication)" + ] + }, + "OptimizerCommunicationAbnormal": { + "Explanation": "La communication avec un optimiseur de module photovoltaïque a échoué.", + "Causes": [ + "L'optimiseur est éteint ou ne reçoit pas d'énergie photovoltaïque", + "Interférence de communication sur la ligne électrique", + "Défaut matériel de l'optimiseur" + ], + "NextSteps": [ + "Vérifiez que l'optimiseur reçoit une tension PV et est allumé", + "Vérifiez le câblage de communication entre l'onduleur et les optimiseurs", + "Remplacez l'optimiseur s'il est confirmé défectueux" + ] + }, + "OverTemperature": { + "Explanation": "La température de l'onduleur a dépassé la limite de fonctionnement normale. La puissance de sortie peut être réduite pour protéger le matériel.", + "Causes": [ + "Mauvaise ventilation — air chaud piégé autour de l'onduleur", + "Température ambiante élevée dans la zone d'installation", + "Défaillance du ventilateur de refroidissement réduisant le flux d'air dans l'onduleur", + "Charge excessive faisant surchauffer l'onduleur" + ], + "NextSteps": [ + "Redémarrez l'onduleur après qu'il ait refroidi", + "Améliorez la ventilation — assurez-vous qu'il y a suffisamment d'espace autour de l'onduleur de tous les côtés", + "Vérifiez que le ventilateur de refroidissement fonctionne correctement", + "Contactez le fabricant si l'alarme persiste malgré une bonne ventilation" + ] + }, + "OverTemperatureAlarm": { + "Explanation": "L'onduleur a détecté une alarme de température élevée — il s'agit d'un avertissement précoce avant la coupure thermique.", + "Causes": [ + "Température ambiante élevée dans l'espace d'installation", + "Mauvaise circulation d'air ou ventilation bloquée autour de l'onduleur", + "Charge lourde en fonctionnement pendant les conditions chaudes", + "Ventilateur fonctionnant à vitesse réduite ou par intermittence" + ], + "NextSteps": [ + "Améliorez immédiatement la ventilation autour de l'onduleur", + "Réduisez temporairement la charge pour permettre à l'onduleur de refroidir", + "Vérifiez le fonctionnement du ventilateur et débloquez les évents", + "Surveillez la température jusqu'à ce qu'elle descende en dessous du seuil d'alarme" + ] + }, + "NtcTemperatureSensorBroken": { + "Explanation": "Le capteur de température NTC à l'intérieur de l'onduleur est défectueux ou déconnecté.", + "Causes": [ + "L'élément du capteur NTC a échoué en raison du vieillissement ou de dommages mécaniques", + "Le câble du capteur est endommagé ou déconnecté de la carte", + "Le connecteur du capteur s'est desserré de la carte de circuit imprimé" + ], + "NextSteps": [ + "Redémarrez l'onduleur — si le capteur est vraiment défectueux, l'alarme persistera après le redémarrage", + "Si l'alarme persiste, un technicien devra inspecter et remplacer le capteur NTC à l'intérieur de l'onduleur" + ] + }, + "SyncSignalAbnormal": { + "Explanation": "Le signal de synchronisation entre les onduleurs connectés en parallèle est anormal.", + "Causes": [ + "Le câble de synchronisation entre les onduleurs en parallèle est endommagé ou déconnecté", + "Défaillance de l'interface de communication de synchronisation sur une unité", + "Incompatibilité de configuration entre les unités" + ], + "NextSteps": [ + "Vérifiez les connexions du câble de synchronisation entre toutes les unités d'onduleurs en parallèle", + "Vérifiez que les paramètres de communication en parallèle correspondent sur toutes les unités", + "Remplacez le câble s'il est endommagé" + ] + }, + "GridStartupConditionsNotMet": { + "Explanation": "Les conditions de démarrage pour la connexion au réseau ne sont pas remplies. L'onduleur attend que le réseau atteigne les paramètres requis avant de se connecter.", + "Causes": [ + "La tension ou la fréquence du réseau est en dehors de la plage autorisée pour la connexion", + "Le seuil de tension de démarrage du réseau est configuré incorrectement" + ], + "NextSteps": [ + "Vérifiez que la tension du réseau est dans la plage de fonctionnement autorisée par l'onduleur", + "Examinez les paramètres de configuration de la tension et de la fréquence de démarrage de la connexion au réseau" + ] + }, + "BatteryCommunicationFailure": { + "Explanation": "L'onduleur ne peut pas communiquer avec le BMS (système de gestion de batterie). Sans communication BMS, la charge et la décharge ne peuvent pas être gérées en toute sécurité.", + "Causes": [ + "Le BMS de la batterie est hors ligne ou éteint", + "Le câble de communication RS485 ou CAN entre l'onduleur et la batterie est défectueux ou déconnecté", + "Incompatibilité de protocole de communication entre l'onduleur et la batterie", + "La batterie est en mode veille — le BMS est passé en mode basse consommation" + ], + "NextSteps": [ + "Vérifiez que le système de batterie est allumé et n'est pas en mode veille", + "Vérifiez le câble de communication RS485 entre l'onduleur et la batterie — inspectez les dommages", + "Vérifiez que le paramètre de protocole de communication de la batterie dans l'onduleur correspond au BMS de la batterie", + "Réveillez la batterie si elle est en mode veille en appuyant sur le bouton d'alimentation de la batterie" + ] + }, + "BatteryDisconnected": { + "Explanation": "La batterie n'est pas connectée à l'onduleur. Le système fonctionne sans stockage de batterie.", + "Causes": [ + "Le disjoncteur ou l'isolateur de circuit de la batterie est éteint", + "Le câble de la batterie s'est desserré ou a été déconnecté", + "Le BMS a arrêté la batterie en raison d'un événement de protection", + "Défaut matériel de la batterie empêchant la connexion" + ], + "NextSteps": [ + "Vérifiez que le disjoncteur de circuit de la batterie est en position MARCHE", + "Vérifiez les connexions des câbles de la batterie aux bornes de l'onduleur et de la batterie", + "Vérifiez les indicateurs d'état du BMS pour tout code de défaut ou de protection", + "Résolvez tout événement de protection du BMS avant de reconnecter" + ] + }, + "BatteryVoltageTooHigh": { + "Explanation": "La tension de la batterie dépasse le niveau maximum autorisé. La charge a peut-être fait dépasser les limites de sécurité.", + "Causes": [ + "La batterie a été surchargée au-delà de sa tension maximale", + "Défaut du BMS permettant à la tension de monter trop sans protection", + "Déséquilibre des cellules entraînant une surcharge des cellules individuelles", + "Paramètre de tension de charge maximale incorrect dans l'onduleur" + ], + "NextSteps": [ + "Vérifiez la tension de la batterie et comparez-la à la spécification maximale du fabricant", + "Vérifiez les paramètres de tension de charge dans la configuration de l'onduleur", + "Vérifiez le fonctionnement du BMS — le BMS aurait dû protéger contre la surtension" + ] + }, + "BatteryVoltageTooLow": { + "Explanation": "La tension de la batterie est inférieure au niveau minimum autorisé. La batterie est profondément déchargée.", + "Causes": [ + "La batterie a été déchargée au-delà de sa tension minimale sûre", + "Défaut d'une cellule de batterie individuelle réduisant la tension du pack", + "Charge élevée vidant la batterie plus vite qu'elle ne peut être rechargée", + "Le BMS a activé la coupure de tension basse" + ], + "NextSteps": [ + "Vérifiez la tension de la batterie et comparez-la à la spécification minimale du fabricant", + "Laissez la batterie se recharger — d'abord en utilisant l'électricité du réseau si le solaire est insuffisant", + "Si la tension est extrêmement basse, la batterie peut nécessiter une recharge professionnelle" + ] + }, + "BatteryReverseConnected": { + "Explanation": "La batterie est branchée avec une polarité inversée. C'est dangereux et peut causer des dommages immédiats.", + "Causes": [ + "Les bornes positive et négative de la batterie sont connectées aux mauvaises bornes de l'onduleur lors de l'installation", + "Erreur d'installation — une grave erreur de câblage" + ], + "NextSteps": [ + "ÉTEIGNEZ IMMEDIATEMENT tout le système — ne chargez ni ne déchargez", + "Vérifiez toutes les connexions des câbles de la batterie avant de toucher quoi que ce soit", + "Faites vérifier et corriger la polarité de la batterie par un électricien qualifié", + "Inspectez les éventuels dommages aux câbles, fusibles ou à l'onduleur avant de redémarrer" + ] + }, + "LeadAcidTempSensorDisconnected": { + "Explanation": "Le capteur de température de la batterie au plomb est déconnecté ou non installé.", + "Causes": [ + "Le capteur de température n'a pas été installé avec la batterie", + "Le câble du capteur s'est desserré ou a été endommagé", + "Le connecteur du capteur s'est détaché de la batterie ou de l'onduleur" + ], + "NextSteps": [ + "Vérifiez si un capteur de température est installé sur la batterie au plomb — il s'agit généralement d'une petite sonde clipsée sur la batterie", + "Vérifiez les connexions du câble du capteur aux deux extrémités", + "Installez ou reconnectez le capteur comme indiqué dans les instructions d'installation" + ] + }, + "BatteryTemperatureOutOfRange": { + "Explanation": "La température de la batterie est en dehors de la plage sûre pour la charge ou la décharge.", + "Causes": [ + "Température ambiante élevée dans la zone d'installation de la batterie", + "Mauvaise ventilation de la batterie entraînant une accumulation de chaleur", + "Surchauffe de la batterie pendant une charge ou une décharge intense", + "Température ambiante très basse en hiver réduisant les performances de la batterie" + ], + "NextSteps": [ + "Vérifiez la température ambiante dans la zone d'installation de la batterie", + "Améliorez la ventilation de la batterie ou déplacez-la vers un endroit plus frais en cas de surchauffe", + "Dans les climats froids, assurez-vous que la batterie n'est pas exposée à des températures gélives — la charge est généralement interdite en dessous de 0°C" + ] + }, + "BmsFault": { + "Explanation": "Le BMS de la batterie a signalé une défaillance empêchant la charge et la décharge normales.", + "Causes": [ + "Défaillance interne du BMS ou événement de protection déclenché par la batterie", + "Protection d'une cellule individuelle activée en raison de survoltage, sous-tension ou température", + "Erreur de communication du BMS entraînant un signalement de défaillance" + ], + "NextSteps": [ + "Vérifiez l'affichage du système de batterie ou les voyants pour un code de défaillance spécifique au BMS", + "Référez-vous à la documentation du fabricant de la batterie pour le code de défaillance spécifique du BMS", + "Contactez le support batterie si la défaillance du BMS ne peut pas être effacée par un redémarrage" + ] + }, + "LithiumBatteryOverload": { + "Explanation": "La protection contre la surcharge de la batterie lithium est activée — la charge consomme plus de puissance que la batterie ne peut fournir.", + "Causes": [ + "La puissance totale de la charge dépasse la puissance de décharge maximale nominale de la batterie", + "Courant d'appel élevé provenant de grands moteurs ou compresseurs dépassant temporairement les limites de la batterie" + ], + "NextSteps": [ + "Vérifiez la puissance totale de la charge et comparez-la à la puissance de décharge nominale de la batterie", + "Réduisez la charge en éteignant les appareils à haute puissance", + "Échelonnez le démarrage des grands appareils pour réduire la demande de pointe" + ] + }, + "BmsCommunicationAbnormal": { + "Explanation": "La communication avec le BMS est anormale — les données sont reçues de manière intermittente ou avec des erreurs.", + "Causes": [ + "Dépassement de temps de communication en raison de problèmes de qualité ou de longueur de câble", + "Erreur de protocole ou de débit binaire", + "Défaillance physique du câble entraînant une connexion intermittente" + ], + "NextSteps": [ + "Redémarrez l'onduleur pour tenter de rétablir la communication", + "Vérifiez le câble de communication du BMS pour détecter des dommages ou des connexions desserrées", + "Vérifiez les paramètres de communication (protocole, débit binaire) pour qu'ils correspondent entre l'onduleur et le BMS" + ] + }, + "BatterySpdAbnormal": { + "Explanation": "La fonction du dispositif de protection contre les surtensions (SPD) côté batterie est anormale.", + "Causes": [ + "Le SPD de la batterie a été déclenché en raison d'un événement de surtension", + "Le SPD a échoué ou a atteint la fin de sa durée de vie", + "Surtension induite par la foudre sur le câblage de la batterie" + ], + "NextSteps": [ + "Éteignez le système et inspectez l'indicateur du SPD de la batterie", + "Remplacez le SPD s'il affiche un état déclenché ou de défaillance", + "Redémarrez le système après le remplacement" + ] + }, + "OutputDcComponentBiasAbnormal": { + "Explanation": "Un composant de biais DC dans la sortie est anormal, ce qui pourrait affecter les équipements connectés sensibles.", + "Causes": [ + "Dérive de la boucle de commande introduisant un décalage DC dans la sortie AC", + "Dérive de l'étalonnage du capteur sur la mesure de sortie", + "Défaillance matérielle dans l'étage de sortie" + ], + "NextSteps": [ + "Redémarrez l'onduleur — les défaillances de biais DC se corrigent souvent après redémarrage", + "Si la défaillance persiste, contactez le fabricant pour une assistance" + ] + }, + "DcComponentOverHighOutputVoltage": { + "Explanation": "La composante continue dans la tension de sortie est trop élevée. Cela peut affecter les équipements sensibles et indique un problème de contrôle.", + "Causes": [ + "Dérive de la boucle de contrôle entraînant un décalage continu dans la tension de sortie", + "Défaillance du capteur de tension de sortie", + "Saturation du transformateur ou problème de chemin continu" + ], + "NextSteps": [ + "Redémarrez l'onduleur pour réinitialiser les boucles de contrôle", + "Vérifiez la tension de sortie pour un décalage continu si l'équipement est affecté" + ] + }, + "OffGridOutputVoltageTooLow": { + "Explanation": "La tension de sortie hors réseau (EPS/sauvegarde) est trop basse pour alimenter correctement les charges connectées.", + "Causes": [ + "La charge dépasse la capacité de sauvegarde de l'onduleur, provoquant une baisse de tension", + "Tension de la batterie trop basse pour maintenir une tension de sortie stable", + "Limitation interne de l'onduleur" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Réduisez la charge sur la sortie de secours", + "Laissez la batterie se charger si l'état de charge est faible", + "Si le défaut persiste, contactez le fabricant" + ] + }, + "OffGridOutputVoltageTooHigh": { + "Explanation": "La tension de sortie hors réseau est trop élevée, ce qui pourrait endommager les équipements connectés.", + "Causes": [ + "Défaillance de contrôle entraînant une régulation de tension de sortie défaillante", + "Erreur de référence de tension dans le système de contrôle" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le défaut persiste, contactez immédiatement le fabricant car une tension de sortie élevée peut endommager les appareils" + ] + }, + "OffGridOutputOverCurrent": { + "Explanation": "Le courant de sortie hors réseau dépasse la limite de surintensité.", + "Causes": [ + "Le courant total de charge dépasse la capacité de courant de sortie de secours de l'onduleur", + "Court-circuit dans l'une des charges de secours", + "Courant d'appel d'un démarrage de moteur important" + ], + "NextSteps": [ + "Vérifiez que toutes les charges sur la sortie de secours sont dans les spécifications de courant de l'onduleur", + "Déconnectez les charges une par une pour identifier tout appareil défectueux", + "Réparer ou retirer la charge en surcharge avant de redémarrer" + ] + }, + "OffGridOutputOverload": { + "Explanation": "La sortie hors réseau (EPS/backup) est surchargée — plus de puissance est demandée que ce que l'onduleur peut fournir en mode secours.", + "Causes": [ + "La charge totale sur la sortie EPS dépasse la capacité de secours de l'onduleur", + "Trop d'appareils connectés au circuit de secours simultanément", + "Un moteur ou compresseur important causant un courant d'appel excessif" + ], + "NextSteps": [ + "Vérifiez que toutes les charges sont conformes à la spécification de sortie EPS de l'onduleur", + "Réduisez le nombre d'appareils sur le circuit de secours", + "Étalez le démarrage des gros appareils pendant le fonctionnement en secours" + ] + }, + "BalancedCircuitAbnormal": { + "Explanation": "Le circuit d'équilibrage de phase fonctionne de manière anormale.", + "Causes": [ + "Défaut interne du circuit d'équilibrage de phase", + "Problème de contrôle affectant le fonctionnement de l'équilibrage de phase" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le défaut persiste, vérifiez les paramètres d'équilibrage de phase et contactez le service" + ] + }, + "ExportLimitationFailSafe": { + "Explanation": "La sécurité de limitation d'exportation a été déclenchée. L'onduleur a arrêté d'alimenter le réseau car il ne peut pas vérifier que les limites d'exportation sont respectées.", + "Causes": [ + "Le capteur CT (transformateur de courant) est déconnecté ou mesure incorrectement", + "La communication avec le compteur est perdue, empêchant la surveillance de l'exportation", + "La boucle de rétroaction de la limite d'exportation a échoué — l'onduleur ne peut pas confirmer que l'exportation vers le réseau est contrôlée" + ], + "NextSteps": [ + "Éteignez le système avant d'inspecter les connexions CT ou du compteur", + "Vérifiez que le capteur CT est correctement installé et connecté", + "Vérifiez que le câble de communication du compteur d'énergie est intact", + "Confirmez que les paramètres de limite d'exportation et la rétroaction sont correctement configurés, puis redémarrez" + ] + }, + "DcBiasAbnormal": { + "Explanation": "La protection contre l'injection DC (DCI) a détecté un biais DC anormal dans la sortie AC — une protection de sécurité empêchant l'injection de DC dans le réseau.", + "Causes": [ + "Injection de DC dans le réseau depuis la sortie de l'onduleur", + "Défaut du capteur de courant de sortie donnant des lectures incorrectes", + "Saturation du transformateur ou problème de contrôle" + ], + "NextSteps": [ + "Redémarrez l'onduleur — cela peut parfois résoudre les défauts transitoires DCI", + "Si le défaut persiste, l'onduleur nécessite une intervention professionnelle" + ] + }, + "HighDcComponentOutputCurrent": { + "Explanation": "Une composante DC élevée a été détectée dans le courant de sortie AC. Il s'agit d'une condition de protection.", + "Causes": [ + "Problème de filtre de sortie laissant passer la composante DC", + "Défaut de contrôle affectant la symétrie de la forme d'onde du courant", + "Saturation du transformateur de sortie" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Vérifiez la qualité de la forme d'onde du courant de sortie si l'équipement de mesure est disponible", + "Si le problème persiste, contactez le fabricant pour une intervention" + ] + }, + "BusVoltageSamplingAbnormal": { + "Explanation": "La mesure de la tension continue est anormale — le capteur fournit des lectures incorrectes.", + "Causes": [ + "Défaillance du capteur de tension ou du circuit de mesure", + "Erreur de l'ADC (convertisseur analogique-numérique) sur la carte de contrôle", + "Problème matériel affectant la précision de la mesure" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le problème persiste, le circuit de mesure nécessite un service professionnel" + ] + }, + "RelayFault": { + "Explanation": "Une défaillance interne du relais a été détectée. Le relais ne fonctionne pas comme prévu.", + "Causes": [ + "Le relais a échoué — contacts bloqués ouverts ou fermés", + "Soudure des contacts due à un événement de surintensité", + "Défaillance du circuit de commande du relais" + ], + "NextSteps": [ + "Redémarrez l'onduleur pour réinitialiser le relais", + "Si la défaillance persiste, le relais doit probablement être remplacé — contactez le service" + ] + }, + "BusVoltageAbnormal": { + "Explanation": "La tension continue interne est anormale.", + "Causes": [ + "Défaillance des composants électroniques de puissance affectant la régulation de la tension continue", + "Problème de condensateur dans le bus continu", + "Défaillance du système de contrôle" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le problème persiste, le système nécessite une inspection professionnelle" + ] + }, + "InternalCommunicationFailure": { + "Explanation": "La communication interne a échoué entre les cartes de contrôle à l'intérieur de l'onduleur.", + "Causes": [ + "Défaillance de la carte de communication", + "Le câble ruban ou le connecteur interne s'est desserré", + "Interférence électromagnétique (EMI) affectant la communication interne" + ], + "NextSteps": [ + "Éteignez l'onduleur, attendez 30 secondes, puis redémarrez pour voir si la communication se rétablit", + "Si le problème persiste, un technicien doit ouvrir l'onduleur et vérifier les connexions des câbles de communication internes" + ] + }, + "TemperatureSensorDisconnected": { + "Explanation": "Un capteur de température à l'intérieur de l'onduleur est déconnecté, empêchant une surveillance thermique correcte.", + "Causes": [ + "L'élément du capteur a échoué ou s'est détaché de son support", + "Le câble du capteur est endommagé ou déconnecté", + "Le connecteur du capteur s'est détaché de la carte de circuit imprimé" + ], + "NextSteps": [ + "Éteignez l'onduleur et vérifiez le câblage interne du capteur si accessible", + "Si non accessible, contactez un technicien de service pour inspecter et remplacer le capteur" + ] + }, + "IgbtDriveFault": { + "Explanation": "Une défaillance du circuit de commande de l'IGBT a été détectée. L'IGBT n'est pas piloté correctement, ce qui peut empêcher la conversion d'énergie.", + "Causes": [ + "Défaillance du circuit de commande de grille", + "Défaillance du transistor IGBT — l'appareil peut être défectueux", + "Problème d'alimentation du circuit de commande de grille" + ], + "NextSteps": [ + "Redémarrez l'onduleur — les défauts transitoires mineurs peuvent être résolus après un redémarrage", + "Si le problème persiste, un service professionnel est nécessaire — remplacement de l'IGBT ou du circuit de commande" + ] + }, + "EepromError": { + "Explanation": "Une erreur de lecture ou d'écriture en mémoire EEPROM s'est produite. La mémoire non volatile de l'onduleur ne fonctionne pas correctement.", + "Causes": [ + "La puce EEPROM a échoué — courant après plusieurs années de fonctionnement", + "Corruption des données dans la mémoire EEPROM", + "Défaillance matérielle du circuit mémoire" + ], + "NextSteps": [ + "Redémarrez l'onduleur — cela peut résoudre une erreur mémoire temporaire", + "Si le problème persiste, une réinitialisation d'usine peut restaurer la fonction ; contactez le support avant d'essayer" + ] + }, + "AuxiliaryPowerAbnormal": { + "Explanation": "L'alimentation auxiliaire interne est anormale. Cette alimentation fournit de l'énergie aux composants électroniques de contrôle.", + "Causes": [ + "Défaillance d'un composant de l'alimentation auxiliaire interne", + "Défaillance du régulateur de tension sur la carte de contrôle" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le problème persiste, contactez le service — l'alimentation auxiliaire peut nécessiter un remplacement" + ] + }, + "DcAcOvercurrentProtection": { + "Explanation": "La protection contre les surintensités DC/AC a été déclenchée — le courant a dépassé la limite de sécurité.", + "Causes": [ + "Court-circuit dans le câblage de sortie AC ou dans les charges connectées", + "Surcharge sévère dépassant largement la capacité nominale", + "Défaillance des composants électroniques de puissance causant une surintensité" + ], + "NextSteps": [ + "Redémarrez l'onduleur après avoir vérifié et supprimé tout court-circuit", + "Vérifiez toutes les charges connectées pour détecter des défauts", + "Réduisez la charge avant de redémarrer" + ] + }, + "CommunicationProtocolMismatch": { + "Explanation": "Une incompatibilité de protocole de communication a été détectée entre les composants.", + "Causes": [ + "Les versions de firmware des cartes de contrôle ne correspondent pas", + "Erreur de configuration de communication" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le problème persiste, effectuez une mise à jour complète du firmware pour vous assurer que tous les composants sont sur des versions compatibles" + ] + }, + "DspComFirmwareMismatch": { + "Explanation": "Les versions du firmware du DSP (processeur de signal) et du COM (communication) ne correspondent pas.", + "Causes": [ + "La mise à jour du firmware a été incomplète, laissant les cartes sur des versions différentes", + "Le mauvais fichier de firmware a été chargé sur l'une des cartes" + ], + "NextSteps": [ + "Redémarrer l'onduleur", + "Effectuer une mise à jour complète du firmware — mettre à jour toutes les cartes vers la bonne version correspondante" + ] + }, + "DspSoftwareHardwareMismatch": { + "Explanation": "La version du logiciel DSP est incompatible avec la version du matériel.", + "Causes": [ + "La carte matérielle a été remplacée par une révision plus récente ou plus ancienne nécessitant une version différente de firmware" + ], + "NextSteps": [ + "Redémarrer l'onduleur", + "Contacter le support technique pour identifier la bonne version de firmware pour cette révision matérielle" + ] + }, + "CpldAbnormal": { + "Explanation": "Le CPLD (dispositif logique programmable complexe) à l'intérieur de l'onduleur fonctionne de manière anormale.", + "Causes": [ + "Défaillance de la puce CPLD ou corruption du firmware", + "Problème d'alimentation affectant le fonctionnement du CPLD" + ], + "NextSteps": [ + "Redémarrer l'onduleur", + "Si persistant, un service professionnel est nécessaire — remplacement ou reprogrammation du CPLD" + ] + }, + "RedundancySamplingInconsistent": { + "Explanation": "Les circuits de mesure redondants de tension ou de courant donnent des résultats incohérents — les deux voies de mesure ne sont pas d'accord.", + "Causes": [ + "L'un des capteurs redondants a dévié ou a échoué", + "Erreur de calibration ADC sur un canal de mesure", + "Défaillance matérielle sur l'un des circuits de mesure" + ], + "NextSteps": [ + "Redémarrer l'onduleur pour réinitialiser les circuits de mesure", + "Si persistant, un recalibrage ou un remplacement de capteur peut être nécessaire — contacter le service" + ] + }, + "PwmPassThroughSignalFailure": { + "Explanation": "Le chemin de signal de passage PWM (modulation de largeur d'impulsion) a échoué.", + "Causes": [ + "Défaillance de la carte de contrôle affectant le routage du signal PWM", + "Problème matériel sur le chemin du signal" + ], + "NextSteps": [ + "Redémarrer l'onduleur", + "Si persistant, contacter le service — cela nécessite une inspection interne de la carte" + ] + }, + "AfciSelfTestFailure": { + "Explanation": "Le test automatique de l'AFCI (disjoncteur de courant d'arc) a échoué. L'AFCI protège contre les arcs électriques dangereux dans les câbles PV.", + "Causes": [ + "Défaut du module de détection AFCI empêchant l'achèvement du test", + "Problème de circuit de test automatique sur la carte de contrôle" + ], + "NextSteps": [ + "Redémarrez l'onduleur pour tenter un nouveau test", + "Si le test échoue à nouveau, le module AFCI doit être remplacé — contactez le service" + ] + }, + "PvCurrentSamplingAbnormal": { + "Explanation": "La mesure du courant PV donne des lectures anormales.", + "Causes": [ + "Défaut du capteur de courant PV ou du capteur à effet Hall", + "Erreur ADC sur le canal de mesure de courant" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le problème persiste, le circuit du capteur de courant nécessite une intervention professionnelle" + ] + }, + "AcCurrentSamplingAbnormal": { + "Explanation": "La mesure du courant AC donne des lectures anormales.", + "Causes": [ + "Défaut du capteur CT (transformateur de courant) ou connexion incorrecte", + "Défaillance du capteur de courant AC", + "Erreur ADC sur le canal de mesure AC" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Vérifiez les connexions et l'orientation du CT si accessible", + "Si le problème persiste, le circuit de mesure nécessite une intervention professionnelle" + ] + }, + "BusSoftbootFailure": { + "Explanation": "Le bus DC n'a pas pu se pré-charger correctement au démarrage.", + "Causes": [ + "Défaut du circuit de pré-charge empêchant la charge contrôlée des condensateurs", + "Problème de condensateur du bus DC", + "Défaut du relais ou du contacteur de pré-charge" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le problème persiste, le circuit de pré-charge nécessite une intervention professionnelle" + ] + }, + "EpoFault": { + "Explanation": "Une défaillance EPO (Arrêt d'urgence) a été déclenchée.", + "Causes": [ + "Le bouton d'arrêt d'urgence EPO a été pressé", + "Le circuit EPO a été activé par un système de sécurité externe", + "Défaut du circuit EPO provoquant un arrêt involontaire" + ], + "NextSteps": [ + "Vérifiez si le bouton EPO a été pressé — réinitialisez-le si c'est le cas", + "Vérifiez le câblage du circuit EPO si l'activation était involontaire", + "Redémarrez l'onduleur après avoir confirmé que le circuit EPO est dégagé" + ] + }, + "MonitoringChipBootVerificationFailed": { + "Explanation": "Le chip de surveillance n'a pas réussi la vérification de démarrage — le firmware ou la séquence de démarrage présente un problème.", + "Causes": [ + "Corruption du firmware sur le chip de surveillance", + "Défaillance matérielle du chip de surveillance" + ], + "NextSteps": [ + "Redémarrez l'onduleur — les échecs de vérification de démarrage se résolvent parfois à la réessayer", + "Si le problème persiste, une réinstallation du firmware ou un remplacement du chip peut être nécessaire — contactez le service" + ] + }, + "BmsCommunicationFailure": { + "Explanation": "Le BMS n'arrive pas à communiquer avec l'onduleur. La charge et la décharge ne peuvent pas être gérées en toute sécurité sans communication BMS.", + "Causes": [ + "Câble de communication RS485 entre l'onduleur et la batterie défectueux ou déconnecté", + "Le BMS est éteint ou ne répond pas", + "Incompatibilité du protocole de communication entre l'onduleur et le BMS" + ], + "NextSteps": [ + "Vérifiez la connexion du câble RS485 entre l'onduleur et la batterie — inspectez les deux extrémités", + "Assurez-vous que la batterie est allumée et que le BMS est actif", + "Vérifiez que le paramètre du protocole de communication correspond à celui du BMS de la batterie" + ] + }, + "BmsChargeDischargeFailure": { + "Explanation": "Le BMS a signalé que la batterie ne peut pas se charger ou se décharger.", + "Causes": [ + "Protection interne du BMS déclenchée — surtension, sous-tension ou défaut de température des cellules", + "Défaillance matérielle du BMS bloquant la charge/décharge", + "Problème de cellule détecté par le BMS" + ], + "NextSteps": [ + "Vérifiez l'affichage de la batterie ou l'indicateur du BMS pour un code d'erreur spécifique", + "Consultez la documentation du fabricant de la batterie pour le code de défaut du BMS", + "Contactez le support de la batterie si le défaut ne peut pas être effacé" + ] + }, + "BatteryVoltageLow": { + "Explanation": "La tension de la batterie est en dessous du niveau minimum autorisé.", + "Causes": [ + "La batterie a été déchargée en profondeur en dessous de la tension minimale sûre", + "Défaillance d'une cellule individuelle réduisant la tension globale de la batterie" + ], + "NextSteps": [ + "Vérifiez la tension de la batterie — si elle est critique, une recharge professionnelle peut être nécessaire", + "Laissez la batterie se recharger lentement depuis le réseau avant de reprendre le fonctionnement normal" + ] + }, + "BatteryVoltageHigh": { + "Explanation": "La tension de la batterie dépasse le seuil maximal autorisé.", + "Causes": [ + "La batterie a été surchargée au-delà de sa tension maximale", + "Défaillance du BMS permettant à la tension de monter sans protection", + "Défaillance d'une cellule créant une tension élevée dans une partie de la batterie" + ], + "NextSteps": [ + "Vérifiez la tension de la batterie et comparez-la à la spécification maximale du fabricant", + "Si la tension est dans la plage autorisée, redémarrez l'onduleur", + "Si la tension est réellement trop élevée, arrêtez immédiatement la charge et contactez le service de la batterie" + ] + }, + "BatteryTemperatureAbnormal": { + "Explanation": "La température de la batterie est en dehors de la plage sûre pour la charge ou la décharge.", + "Causes": [ + "La batterie est trop chaude — mauvaise ventilation ou température ambiante élevée", + "La batterie est trop froide — environnement gelé ou proche du gel", + "Défaillance du capteur de température donnant des lectures incorrectes" + ], + "NextSteps": [ + "Vérifiez la température physique de la batterie si cela est sûr à faire", + "Améliorez la ventilation de la batterie en cas de surchauffe", + "Dans des conditions froides, laissez la batterie se réchauffer avant de la charger", + "Vérifiez les connexions du capteur si la lecture de température semble incorrecte" + ] + }, + "BatteryReversed": { + "Explanation": "La polarité de la batterie est inversée — les bornes positive et négative sont connectées incorrectement.", + "Causes": [ + "Les câbles positif et négatif de la batterie sont connectés aux mauvaises bornes de l'onduleur", + "Erreur d'installation" + ], + "NextSteps": [ + "ÉTEIGNEZ IMMEDIATEMENT tout le système — la polarité inversée peut causer des dommages graves", + "Faites vérifier et corriger la polarité de la batterie par un électricien qualifié avant toute autre opération" + ] + }, + "BatteryOpenCircuit": { + "Explanation": "Le circuit de la batterie est ouvert — la batterie n'est pas connectée électriquement.", + "Causes": [ + "Le câble de la batterie s'est desserré ou déconnecté de la borne", + "Le fusible de la batterie a sauté, interrompant le circuit", + "Le BMS a ouvert le contacteur interne en raison d'un événement de protection" + ], + "NextSteps": [ + "Vérifiez toutes les connexions des câbles de la batterie au niveau de l'onduleur et des bornes de la batterie", + "Inspectez le fusible de la batterie et remplacez-le s'il a sauté", + "Vérifiez l'état du BMS pour tout événement de protection ayant pu ouvrir le contacteur de la batterie" + ] + }, + "BatteryOverloadProtection": { + "Explanation": "La protection contre la surcharge de la batterie a été déclenchée — la charge consomme plus de puissance que la batterie ne peut décharger en toute sécurité.", + "Causes": [ + "La puissance totale de la charge dépasse la puissance de décharge maximale nominale de la batterie", + "Courant d'appel élevé d'appareils puissants dépassant temporairement la capacité de la batterie" + ], + "NextSteps": [ + "Vérifiez la charge totale et comparez-la à la puissance de décharge nominale de la batterie", + "Réduisez les charges à haute puissance et redémarrez l'onduleur" + ] + }, + "Bus2VoltageAbnormal": { + "Explanation": "La tension du bus DC secondaire est anormale.", + "Causes": [ + "Défaillance des composants électroniques de puissance affectant le bus DC secondaire", + "Problème de contrôle sur le convertisseur secondaire" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le problème persiste, une inspection professionnelle est nécessaire" + ] + }, + "BatteryChargeOcp": { + "Explanation": "La protection contre les surintensités de charge de la batterie s'est déclenchée — le courant de charge est trop élevé.", + "Causes": [ + "Le panneau solaire est surdimensionné et fournit plus de courant que la batterie ne peut accepter en toute sécurité", + "La limite de courant de charge de la batterie est réglée trop haut par rapport à la spécification de la batterie" + ], + "NextSteps": [ + "Vérifiez si la puissance du panneau solaire dépasse significativement la capacité de charge de la batterie", + "Réduisez le courant de charge maximal dans l'onduleur pour correspondre à la spécification de la batterie" + ] + }, + "BatteryDischargeOcp": { + "Explanation": "La protection contre les surintensités de décharge de la batterie s'est déclenchée — le courant de décharge est trop élevé.", + "Causes": [ + "La charge connectée consomme plus de courant que la batterie ne peut fournir en toute sécurité", + "La limite de courant de décharge de la batterie est réglée trop haut" + ], + "NextSteps": [ + "Vérifiez que le courant de décharge de la batterie correspond à la spécification de la batterie", + "Réduisez la charge connectée pour rester dans les limites de décharge de la batterie" + ] + }, + "BatterySoftStartFailed": { + "Explanation": "La batterie n'a pas pu compléter sa séquence de démarrage en douceur lors de la connexion à l'onduleur.", + "Causes": [ + "Défaut du circuit de précharge empêchant la connexion contrôlée de la batterie", + "La tension de la batterie est significativement différente de la tension du bus DC de l'onduleur" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Vérifiez la tension de la batterie par rapport à la tension du bus DC — un écart important peut empêcher le démarrage en douceur" + ] + }, + "EpsOutputShortCircuited": { + "Explanation": "La sortie de secours (EPS) est en court-circuit.", + "Causes": [ + "Court-circuit dans le câblage de la charge connectée à la sortie de secours", + "Un appareil défectueux provoquant un court-circuit sur le circuit de secours", + "Défaut de câblage dans la distribution de sortie EPS" + ], + "NextSteps": [ + "Déconnectez toutes les charges de la sortie de secours", + "Identifiez et réparez le court-circuit dans le câblage ou les appareils avant de reconnecter" + ] + }, + "OffGridBusVoltageLow": { + "Explanation": "La tension du bus DC hors réseau est trop basse pour maintenir le fonctionnement en secours.", + "Causes": [ + "La batterie est presque déchargée et ne peut pas maintenir la tension du bus DC", + "Charge de secours élevée combinée à une faible charge de la batterie", + "Perte de capacité de la batterie due au vieillissement" + ], + "NextSteps": [ + "Vérifiez si la batterie fonctionne correctement et n'a pas perdu une capacité significative", + "Laissez la batterie se recharger avant de tenter un fonctionnement en secours", + "Réduisez la charge de secours pour prolonger la durée de fonctionnement de la batterie" + ] + }, + "OffGridTerminalVoltageAbnormal": { + "Explanation": "Une tension anormale a été détectée à la sortie AC hors réseau.", + "Causes": [ + "Une tension externe est présente à la sortie AC de secours provenant d'une autre source", + "Défaut de câblage reliant la sortie de secours à un circuit sous tension", + "Retour de courant d'une charge ayant sa propre source d'alimentation" + ], + "NextSteps": [ + "Vérifiez si une source de tension externe est présente au port de sortie AC de secours", + "Vérifiez que le câblage de la sortie de secours ne se connecte à aucune autre source sous tension", + "Déconnectez toutes les charges de la sortie de secours et inspectez le câblage avant de redémarrer" + ] + }, + "SoftStartFailed": { + "Explanation": "La séquence de démarrage progressif en mode hors réseau a échoué.", + "Causes": [ + "Échec de la précharge pendant le démarrage hors réseau", + "Charge trop élevée au moment du démarrage hors réseau" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Réduisez la charge initiale sur le circuit de secours pendant le démarrage" + ] + }, + "OffGridOutputVoltageAbnormal": { + "Explanation": "La tension de sortie hors réseau est anormale.", + "Causes": [ + "Défaut de contrôle entraînant l'échec de la régulation de tension hors réseau", + "Problème matériel au niveau de l'étage de sortie", + "Surcharge sévère faisant chuter la tension de sortie" + ], + "NextSteps": [ + "Redémarrez l'onduleur", + "Si le défaut persiste, contactez le fabricant" + ] + }, + "BalancedCircuitSelfTestFailed": { + "Explanation": "L'autotest du circuit équilibré a échoué pendant le démarrage.", + "Causes": [ + "Défaut du circuit d'équilibrage des phases détecté pendant l'autotest", + "Problème matériel du circuit d'équilibrage" + ], + "NextSteps": [ + "Redémarrez l'onduleur pour relancer l'autotest", + "Si le défaut persiste, contactez le service" + ] + }, + "HighDcComponentOutputVoltage": { + "Explanation": "Une composante CC élevée a été détectée dans la tension de sortie AC.", + "Causes": [ + "Dérive de la boucle de contrôle entraînant une accumulation de décalage CC dans la tension de sortie", + "Problème avec le transformateur de sortie ou le filtre" + ], + "NextSteps": [ + "Redémarrez l'onduleur pour réinitialiser les boucles de contrôle", + "Si le défaut persiste, contactez le fabricant" + ] + }, + "OffGridParallelSignalAbnormal": { + "Explanation": "Le signal de communication parallèle entre les onduleurs en mode hors réseau est anormal.", + "Causes": [ + "Le câble de communication parallèle entre les unités est endommagé ou déconnecté", + "Incompatibilité de configuration parallèle entre les unités" + ], + "NextSteps": [ + "Vérifiez que tous les câbles de communication parallèle sont correctement et solidement connectés entre les onduleurs", + "Vérifiez que les paramètres parallèles correspondent sur toutes les unités" + ] + }, + "AFCIFault": { + "Explanation": "Un défaut d'arc électrique a été détecté dans le système PV. Les arcs électriques peuvent provoquer des incendies dans les câbles PV et le système s'est arrêté par mesure de sécurité.", + "Causes": [ + "Connecteur MC4 ou câble PV desserré provoquant un arc intermittent", + "Isolation de câble endommagée permettant un arc au point endommagé", + "Connecteur ou boîte de jonction défectueux créant un chemin d'arc", + "Boîte de jonction de module endommagée" + ], + "NextSteps": [ + "Coupez l'alimentation de tous les disjoncteurs DC avant d'inspecter les câbles PV", + "Inspectez soigneusement toutes les connexions de chaînes PV, les connecteurs MC4 et les câbles pour détecter des dommages", + "Serrer les connecteurs desserrés et remplacer les câbles ou connecteurs endommagés", + "Faites inspecter professionnellement l'installation si la source de l'arc n'est pas trouvée" + ] + }, + "GFCIHigh": { + "Explanation": "Un courant de défaut (fuite) excessivement élevé a été détecté dans le système PV.", + "Causes": [ + "Défaut de mise à la terre dans le champ PV — généralement un câble touchant le cadre ou les parties métalliques", + "Défaillance de l'isolation des câbles PV ou des boîtes de jonction des modules", + "Infiltration d'humidité dans les connexions de câbles ou les boîtes de jonction des modules", + "Câble endommagé exposant les conducteurs à la terre" + ], + "NextSteps": [ + "Redémarrez l'onduleur pour voir si le défaut est résolu", + "Si le problème persiste, effectuez un test de résistance d'isolation sur toutes les chaînes PV pour localiser le défaut", + "Réparer tout dommage d'isolation ou défaut de mise à la terre avant de redémarrer" + ] + }, + "PVVoltageHigh": { + "Explanation": "La tension d'entrée DC du champ PV dépasse la limite maximale de sécurité absolue. Cela représente un risque immédiat de dommage pour l'onduleur.", + "Causes": [ + "Trop de modules PV en série dépassant la tension d'entrée maximale de l'onduleur", + "Température très froide faisant augmenter la tension Voc des modules bien au-dessus de la tension Voc de conception" + ], + "NextSteps": [ + "Déconnectez immédiatement le disjoncteur DC pour protéger l'onduleur", + "Mesurez la tension DC réelle avant de reconnecter", + "Examinez la conception des chaînes et réduisez le nombre de modules en série si nécessaire pour rester dans les limites de tension de l'onduleur" + ] + }, + "OffGridBusVoltageTooLow": { + "Explanation": "La tension du bus DC en mode hors réseau est trop basse pour assurer un fonctionnement stable.", + "Causes": [ + "État de charge de la batterie trop faible", + "Charge excessive sur la sortie hors réseau", + "Défaut ou connexion lâche du câblage du bus DC" + ], + "NextSteps": [ + "Réduire la charge connectée à la sortie hors réseau", + "Vérifier le niveau de charge de la batterie et recharger si nécessaire", + "Inspecter le câblage du bus DC pour détecter des connexions lâches ou des dommages" + ] + } +} \ No newline at end of file diff --git a/csharp/App/Backend/Resources/AlarmTranslations.it.json b/csharp/App/Backend/Resources/AlarmTranslations.it.json new file mode 100644 index 000000000..fffcd1d1f --- /dev/null +++ b/csharp/App/Backend/Resources/AlarmTranslations.it.json @@ -0,0 +1,2822 @@ +{ + "AbnormalGridVoltage": { + "Explanation": "L'inverter ha rilevato che la tensione di rete è al di fuori dell'intervallo operativo accettabile. Il sistema richiede un intervento manuale per ripristinare il funzionamento.", + "Causes": [ + "Fluttuazioni o instabilità della tensione di rete da parte del fornitore", + "Connessione di rete scarsa o allentata ai terminali dell'inverter", + "Problemi con il trasformatore locale", + "Elevata domanda di carico sulla rete locale" + ], + "NextSteps": [ + "Verificare la tensione di rete con un multimetro ai terminali dell'inverter", + "Controllare che tutti i cavi di connessione alla rete siano ben fissati e intatti", + "Contattare il fornitore di energia se la tensione di rete rimane anomala", + "Riavviare l'inverter dopo aver risolto il problema" + ] + }, + "AbnormalGridFrequency": { + "Explanation": "L'inverter ha rilevato che la frequenza di rete è al di fuori dell'intervallo accettabile (tipicamente 50 Hz o 60 Hz ± tolleranza). Il sistema non funzionerà finché la frequenza non tornerà alla normalità.", + "Causes": [ + "Instabilità o disturbo della rete da parte del fornitore", + "Deriva della frequenza del generatore se si utilizza un generatore", + "Rapidi cambiamenti di carico sulla rete locale" + ], + "NextSteps": [ + "Verificare se la frequenza di rete è stabile", + "Se si utilizza un generatore, assicurarsi che l'impostazione della frequenza del generatore corrisponda alle specifiche dell'inverter", + "Aspettare che la rete si stabilizzi, quindi riavviare l'inverter" + ] + }, + "InvertedSequenceOfGridVoltage": { + "Explanation": "La sequenza di fase della tensione di rete trifase è invertita. Si tratta di un problema di cablaggio che impedisce il funzionamento sicuro.", + "Causes": [ + "Cablaggio errato delle fasi di rete durante l'installazione (L1, L2, L3 invertite)", + "Lavori di ricollegamento eseguiti senza verificare l'ordine delle fasi" + ], + "NextSteps": [ + "Spegnere completamente il sistema in modo sicuro prima di toccare qualsiasi cablaggio", + "Invertire due dei tre cavi di fase alla connessione di rete per correggere la sequenza", + "Riaccendere il sistema e verificare che l'allarme si sia risolto" + ] + }, + "GridVoltagePhaseLoss": { + "Explanation": "Una o più fasi della connessione trifase alla rete sono assenti. L'inverter non può funzionare in sicurezza con un'alimentazione trifase incompleta.", + "Causes": [ + "Fusibile bruciato su una delle fasi della rete", + "Cavo di fase allentato o scollegato ai terminali dell'inverter o al quadro elettrico", + "Interruttore automatico lato rete scattato su una fase", + "Danno al cavo che interrompe una fase" + ], + "NextSteps": [ + "Controllare tutte e tre le connessioni di fase ai terminali di ingresso dell'inverter", + "Verificare i fusibili e gli interruttori automatici per ogni fase", + "Ispezionare i cavi per eventuali danni visibili o connessioni allentate", + "Ripristinare la fase mancante e riavviare dopo la riparazione" + ] + }, + "AbnormalGridCurrent": { + "Explanation": "La corrente di rete è anomala, il che può indicare sovraccarico o squilibrio di corrente tra le fasi.", + "Causes": [ + "Cortocircuito o guasto di cablaggio lato rete", + "Carico del sistema superiore alla capacità", + "Sensore di corrente difettoso che fornisce letture errate", + "Guasto a terra che causa perdita di corrente" + ], + "NextSteps": [ + "Controllare i cortocircuiti nel cablaggio e lato carico", + "Ridurre il carico del sistema e verificare se l'allarme si risolve", + "Verificare le connessioni e il funzionamento del sensore di corrente", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "AbnormalOutputVoltage": { + "Explanation": "La tensione di uscita dell'inverter è al di fuori dei limiti accettabili. Questo può influenzare i carichi collegati e indica una condizione di guasto.", + "Causes": [ + "Guasto interno di controllo dell'inverter", + "Condizione di sovraccarico lato uscita", + "Influenza della tensione di rete sull'output di regolazione" + ], + "NextSteps": [ + "Controllare tutti i carichi collegati e scollegare quelli che potrebbero causare sovraccarico", + "Verificare le impostazioni della tensione di uscita dell'inverter in base ai requisiti dell'installazione", + "Riavviare l'inverter; se l'allarme ritorna, contattare un tecnico di assistenza" + ] + }, + "AbnormalOutputFrequency": { + "Explanation": "La frequenza di uscita dell'inverter è anomala, il che potrebbe influire su apparecchiature sensibili.", + "Causes": [ + "Guasto al sistema di controllo interno che influisce sulla regolazione della frequenza", + "Transitori di carico pesanti o improvvisi che causano deviazioni di frequenza" + ], + "NextSteps": [ + "Ridurre il carico connesso e verificare se la frequenza si stabilizza", + "Riawviare l'inverter; se il problema persiste, contattare l'assistenza" + ] + }, + "AbnormalNullLine": { + "Explanation": "La connessione della linea neutra è anomala. Una linea neutra mancante o danneggiata può causare squilibri di tensione e condizioni pericolose.", + "Causes": [ + "Filo neutro allentato o scollegato all'inverter o al quadro elettrico", + "Filo neutro danneggiato o rotto", + "Cablaggio errato durante l'installazione" + ], + "NextSteps": [ + "Spegnere il sistema in modo sicuro prima di ispezionare i cavi", + "Verificare tutte le connessioni del filo neutro all'inverter e al quadro elettrico", + "Riparare eventuali problemi di cablaggio riscontrati, quindi riavviare dopo aver confermato le connessioni corrette" + ] + }, + "AbnormalOffGridOutputVoltage": { + "Explanation": "La tensione di uscita in modalità standby (di emergenza) è anomala. I carichi collegati all'uscita di emergenza potrebbero non ricevere la tensione corretta.", + "Causes": [ + "Sovraccarico sull'uscita di emergenza che supera la capacità dell'inverter", + "Problema hardware interno all'inverter", + "Tensione della batteria troppo bassa per mantenere un'uscita stabile" + ], + "NextSteps": [ + "Scollegare o ridurre il carico sull'uscita di emergenza", + "Verificare lo stato di carica della batteria e permettere la ricarica se è scarica", + "Riawviare l'inverter; se il problema persiste, contattare l'assistenza" + ] + }, + "ExcessivelyHighAmbientTemperature": { + "Explanation": "La temperatura ambientale intorno all'inverter è troppo alta. L'inverter potrebbe ridurre la potenza in uscita per proteggersi dai danni causati dal calore.", + "Causes": [ + "Scarsa ventilazione intorno all'installazione dell'inverter", + "Temperatura ambientale elevata (ondata di calore, picco estivo)", + "Esposizione diretta ai raggi solari che riscaldano l'involucro dell'inverter", + "Altre apparecchiature vicine che generano troppo calore" + ], + "NextSteps": [ + "Migliorare il flusso d'aria e la ventilazione intorno all'inverter", + "Fornire ombra se l'inverter è installato all'aperto o sotto il sole diretto", + "Considerare l'aggiunta di raffreddamento forzato (ventola) se in uno spazio chiuso", + "L'inverter si riprenderà automaticamente una volta che la temperatura scende a livelli sicuri" + ] + }, + "ExcessiveRadiatorTemperature": { + "Explanation": "La temperatura del dissipatore di calore (radiatore) dell'inverter è troppo alta. L'inverter utilizza il dissipatore per dissipare il calore durante il funzionamento.", + "Causes": [ + "Ventole o aperture per l'aria ostruite che impediscono la dissipazione del calore", + "Guasto del ventilatore di raffreddamento che riduce il flusso d'aria", + "Temperatura ambientale elevata", + "Carico eccessivo che genera più calore" + ], + "NextSteps": [ + "Pulire le aperture per l'aria e i filtri antistatici — l'accumulo di polvere è una causa comune", + "Verificare che il ventilatore di raffreddamento sia in funzione (ascoltare il rumore del ventilatore durante il funzionamento)", + "Ridurre temporaneamente il carico per abbassare la generazione di calore", + "Riparare o sostituire il ventilatore se difettoso, quindi riavviare l'inverter" + ] + }, + "PcbOvertemperature": { + "Explanation": "La scheda elettronica (PCB) all'interno dell'inverter ha raggiunto una temperatura troppo alta.", + "Causes": [ + "Raffreddamento o ventilazione insufficienti all'interno dell'involucro", + "Temperatura ambientale elevata che influisce sui componenti interni", + "Potenza in uscita eccessiva per un periodo prolungato" + ], + "NextSteps": [ + "Migliorare la ventilazione intorno all'inverter", + "Verificare che il ventilatore di raffreddamento funzioni correttamente", + "Lasciare raffreddare l'inverter prima di riavviarlo" + ] + }, + "DcConverterOvertemperature": { + "Explanation": "La sezione del convertitore DC dell'inverter si sta surriscaldando.", + "Causes": [ + "Corrente di carica o scarica elevata prolungata nel tempo", + "Scarsa ventilazione o prese d'aria ostruite", + "Temperatura ambiente elevata nell'area di installazione" + ], + "NextSteps": [ + "Ridurre temporaneamente il flusso di potenza nel sistema", + "Migliorare la ventilazione e verificare il funzionamento della ventola", + "Lasciare raffreddare, poi riavviare l'inverter" + ] + }, + "InverterOvertemperatureAlarm": { + "Explanation": "La temperatura dell'inverter sta aumentando verso livelli pericolosi. Questo è un avviso preliminare prima del blocco termico.", + "Causes": [ + "Sovraccarico di potenza in uscita prolungato", + "Scarsa ventilazione che intrappola il calore intorno all'inverter", + "Guasto della ventola di raffreddamento", + "Temperatura ambiente elevata nell'area di installazione" + ], + "NextSteps": [ + "Ridurre immediatamente il carico connesso", + "Verificare che le ventole di raffreddamento funzionino e che le prese d'aria siano libere", + "L'inverter si riprenderà una volta raffreddato; risolvere la causa prima del riavvio completo" + ] + }, + "InverterOvertemperature": { + "Explanation": "L'inverter si è surriscaldato e il sistema di protezione ha attivato lo spegnimento.", + "Causes": [ + "Condizione di sovraccarico prolungato che genera troppo calore", + "Guasto del sistema di raffreddamento (ventole bloccate, ventola guasta)", + "Temperature ambientali estreme" + ], + "NextSteps": [ + "Lasciare raffreddare completamente l'inverter prima di tentare un riavvio", + "Verificare le ventole e assicurarsi che tutte le aperture di ventilazione siano libere", + "Ridurre il carico del sistema e migliorare il raffreddamento prima di riavviare" + ] + }, + "DcConverterOvertemperatureAlarm": { + "Explanation": "L'allarme di temperatura del convertitore DC è attivo — la temperatura si sta avvicinando alla soglia di spegnimento.", + "Causes": [ + "Alta potenza sostenuta nel tempo", + "Raffreddamento insufficiente o prese d'aria ostruite" + ], + "NextSteps": [ + "Ridurre temporaneamente il flusso di potenza per permettere il raffreddamento", + "Verificare il funzionamento della ventola e rimuovere eventuali ostruzioni alla ventilazione", + "Lasciare che la temperatura scenda, poi riavviare l'inverter" + ] + }, + "InsulationFault": { + "Explanation": "È stato rilevato un guasto di isolamento, indicando una possibile dispersione di corrente a terra. Si tratta di una condizione critica per la sicurezza che deve essere verificata prima di riprendere il funzionamento.", + "Causes": [ + "Isolamento del cavo danneggiato su cavi PV, batteria o di rete", + "Ingresso di umidità o acqua nelle connessioni dei cavi o negli involucri", + "Degradazione dell'isolamento dei componenti all'interno dell'inverter", + "Guasto a terra nell'impianto fotovoltaico — comune dopo danni da tempesta" + ], + "NextSteps": [ + "Non toccare il sistema — i guasti di isolamento possono causare scosse elettriche", + "Spegnere il sistema in modo sicuro da tutti i dispositivi di disconnessione", + "Ispezionare tutti i cavi per eventuali danni visibili all'isolamento, soprattutto nelle aree esposte alle intemperie", + "Eseguire un test di resistenza di isolamento sulle stringhe PV e sui cavi", + "Riparare l'isolamento danneggiato prima di riavviare" + ] + }, + "LeakageProtectionFault": { + "Explanation": "La protezione da guasto a terra o da corrente di dispersione è scattata. La corrente di dispersione a terra ha superato la soglia di sicurezza.", + "Causes": [ + "Guasto a terra in qualche parte del cablaggio del sistema", + "Isolamento del cavo danneggiato che permette alla corrente di disperdersi a terra", + "Umidità che penetra nei connettori dei cavi o nelle scatole di giunzione", + "Dispositivo RCD o GFCI difettoso" + ], + "NextSteps": [ + "Spegnere il sistema prima dell'ispezione", + "Verificare i guasti a terra ispezionando tutte le connessioni dei cavi e l'isolamento", + "Cercare umidità nei connettori, nelle scatole di giunzione e nei passacavi", + "Riparare il guasto, poi riavviare il sistema" + ] + }, + "AbnormalLeakageSelfCheck": { + "Explanation": "L'autocontrollo della corrente di dispersione dell'inverter è fallito durante l'avvio.", + "Causes": [ + "Guasto al circuito di autocontrollo interno all'inverter", + "Presenza di un guasto di massa effettivo nel sistema", + "Malfunzionamento del sensore di corrente di dispersione" + ], + "NextSteps": [ + "Spegnere in sicurezza e controllare i collegamenti di messa a terra del sistema", + "Ispezionare i cavi per eventuali danni all'isolamento che potrebbero causare dispersioni", + "Se i cavi sono a posto, il sensore interno dell'inverter potrebbe essere difettoso — contattare l'assistenza" + ] + }, + "PoorGrounding": { + "Explanation": "È stata rilevata una connessione di messa a terra scarsa o insufficiente. La messa a terra corretta è essenziale per la sicurezza e la protezione dai fulmini.", + "Causes": [ + "Connessione a terra (massa) allentata all'inverter", + "Terminale di terra corroso o ossidato", + "Resistenza del cavo di terra troppo alta a causa delle condizioni del terreno o di un cavo sottodimensionato", + "Cavo di terra mancante o scollegato" + ], + "NextSteps": [ + "Spegnere in sicurezza e controllare tutte le connessioni a terra (massa) all'inverter", + "Pulire eventuali terminali corrotti e stringere tutte le connessioni a terra", + "Misurare la resistenza di terra e confrontarla con la specifica di installazione", + "Riparare la messa a terra, quindi riavviare l'inverter" + ] + }, + "FanFault": { + "Explanation": "Il ventilatore di raffreddamento ha fallito o non funziona correttamente. Senza un adeguato raffreddamento, l'inverter si surriscalderà e si spegnerà.", + "Causes": [ + "Il motore del ventilatore è guasto e non gira più", + "La pala del ventilatore è bloccata da detriti o oggetti estranei", + "Connettore di alimentazione del ventilatore allentato o scollegato", + "Guasto al circuito di controllo del ventilatore" + ], + "NextSteps": [ + "Ispezionare visivamente il ventilatore e verificare se gira quando l'inverter è in funzione", + "Rimuovere eventuali ostacoli dalle pale del ventilatore", + "Verificare che il connettore di alimentazione del ventilatore sia inserito correttamente", + "Sostituire il ventilatore se non funziona — non far funzionare l'inverter senza raffreddamento" + ] + }, + "AuxiliaryPowerFault": { + "Explanation": "L'alimentazione ausiliaria all'interno dell'inverter ha smesso di funzionare. Questa alimentazione interna fornisce energia all'elettronica di controllo.", + "Causes": [ + "Guasto di un componente dell'alimentazione interna", + "Problema di tensione di ingresso che influisce sull'alimentazione ausiliaria", + "Guasto di un componente elettronico sulla scheda di controllo" + ], + "NextSteps": [ + "Riavvia l'inverter — spegnilo, aspetta 30 secondi, poi riaccendilo", + "Se l'allarme persiste dopo il riavvio, probabilmente l'alimentazione ausiliaria deve essere sostituita — contatta un tecnico di assistenza" + ] + }, + "ModelCapacityFault": { + "Explanation": "L'inverter ha rilevato una discrepanza tra la configurazione del modello o della capacità — le impostazioni del sistema non corrispondono all'hardware.", + "Causes": [ + "Configurazione del modello impostata erroneamente durante la messa in servizio", + "Versione del firmware incompatibile con il modello hardware", + "Componenti hardware sostituiti senza aggiornare la configurazione" + ], + "NextSteps": [ + "Verifica le impostazioni del modello dell'inverter nel menu di configurazione", + "Controlla che la versione del firmware sia compatibile con questa revisione hardware", + "Contatta il tuo installatore o il team di assistenza per correggere la configurazione, poi riavvia" + ] + }, + "AbnormalLightningArrester": { + "Explanation": "Il dispositivo di protezione contro le sovratensioni (SPD / parasurtense) ha fallito o si è attivato a causa di un evento di sovratensione.", + "Causes": [ + "Un fulmine o un picco di tensione ha attivato e possibilmente distrutto l'SPD", + "Il componente SPD ha raggiunto la fine della sua vita utile ed è fallito", + "Guasto nel cablaggio dell'SPD" + ], + "NextSteps": [ + "Controlla l'indicatore di stato dell'SPD (la maggior parte degli SPD ha un indicatore visivo di guasto)", + "Sostituisci la cartuccia dell'SPD se si è attivata o mostra un guasto", + "Dopo la sostituzione, riavvia l'inverter" + ] + }, + "IslandProtection": { + "Explanation": "La protezione isola è attiva — l'inverter si è disconnesso dalla rete per evitare di alimentare una rete senza energia. È una funzione di sicurezza.", + "Causes": [ + "Blackout della rete elettrica nella tua zona", + "Tensione o frequenza della rete fuori dai limiti accettabili", + "Disconnessione intenzionale della rete da parte del fornitore" + ], + "NextSteps": [ + "Attendi il ripristino e la stabilizzazione della rete elettrica", + "L'inverter si riconnetterà automaticamente e riprenderà il funzionamento normale una volta che la rete sarà stabile", + "Nessuna azione necessaria a meno che il blackout non sia prolungato" + ] + }, + "Battery1NotConnected": { + "Explanation": "La batteria 1 non è rilevata o non è connessa. L'inverter non riesce a trovare la batteria sul bus DC.", + "Causes": [ + "Interruttore di disconnessione della batteria aperto (spento)", + "Cavo della batteria allentato o disconnesso al terminale dell'inverter o della batteria", + "Il BMS della batteria ha spento la batteria a causa di un evento di protezione", + "Fusibile della batteria bruciato" + ], + "NextSteps": [ + "Controlla l'interruttore di disconnessione della batteria e assicurati che sia in posizione ON", + "Ispeziona i collegamenti dei cavi della batteria sia all'inverter che ai terminali della batteria", + "Controlla l'indicatore di stato del BMS della batteria per eventuali codici di errore", + "Ispeziona e sostituisci il fusibile se bruciato, poi riavvia l'inverter" + ] + }, + "Battery1Overvoltage": { + "Explanation": "La tensione della batteria 1 è troppo alta. La ricarica è stata limitata o interrotta per proteggere la batteria.", + "Causes": [ + "La batteria viene sovraccarica oltre la tensione massima", + "Malfunzionamento del BMS che permette alla tensione di salire troppo", + "Impostazioni errate della tensione o capacità della batteria nell'inverter", + "Squilibrio delle celle che causa la sovraccarica di alcune celle" + ], + "NextSteps": [ + "Controlla lo stato di carica e la tensione corrente della batteria", + "Verifica le impostazioni della tensione di ricarica della batteria nella configurazione dell'inverter", + "Controlla il funzionamento del BMS e eventuali indicatori di errore del BMS", + "Ripara la causa sottostante, poi riavvia l'inverter" + ] + }, + "Battery1Undervoltage": { + "Explanation": "La tensione della batteria 1 è troppo bassa. La scarica è stata limitata o interrotta per proteggere la batteria dalla scarica profonda.", + "Causes": [ + "La batteria è stata scaricata troppo profondamente", + "Guasto di una singola cella della batteria che riduce la capacità totale", + "Taglio BMS a causa della protezione da tensione bassa", + "Carico elevato che scarica la batteria più velocemente di quanto si ricarichi" + ], + "NextSteps": [ + "Permettere alla batteria di ricaricarsi da PV o dalla rete", + "Controllare eventuali carichi anomali che assorbono troppa energia", + "Verificare lo stato di salute della batteria — le batterie vecchie potrebbero non trattenere la carica", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "Battery1DischargeEnd": { + "Explanation": "La batteria 1 ha raggiunto il suo stato di carica minimo (punto di fine scarica). Il sistema smetterà di scaricarsi per proteggere la batteria.", + "Causes": [ + "La batteria è stata completamente scaricata fino al limite di SOC configurato", + "Consumo di potenza elevato che supera la carica disponibile da solare o rete" + ], + "NextSteps": [ + "Aspettare che la batteria si ricarichi da PV o dalla rete", + "Considerare la riduzione del consumo di energia notturna per preservare la capacità della batteria", + "Questo allarme si risolverà automaticamente una volta ripristinata una carica sufficiente" + ] + }, + "Battery1Inverted": { + "Explanation": "La polarità della batteria 1 è invertita. Funzionare con polarità invertita può causare gravi danni all'inverter e alla batteria.", + "Causes": [ + "Cavi della batteria collegati con positivo e negativo invertiti durante l'installazione", + "Errore di installazione — cavo positivo sul terminale negativo o viceversa" + ], + "NextSteps": [ + "SPEGNERE IMMEDIATAMENTE l'intero sistema — non tentare di caricare o scaricare", + "Scollegare i cavi della batteria con attenzione dopo aver spento l'alimentazione", + "Ricollegare con la polarità corretta: positivo al terminale positivo (+), negativo al terminale negativo (−)", + "Controllare eventuali danni ai cavi, ai fusibili o all'inverter prima di riavviare" + ] + }, + "Battery1OverloadTimeout": { + "Explanation": "La batteria 1 ha funzionato in condizioni di sovraccarico per troppo tempo e ha attivato la protezione.", + "Causes": [ + "Carico elevato e continuo che supera la capacità di scarica della batteria", + "Batteria troppo piccola per il carico collegato", + "Degradazione della batteria che riduce la capacità di potenza disponibile" + ], + "NextSteps": [ + "Ridurre il carico totale sul sistema", + "Verificare se la batteria è dimensionata correttamente per i picchi di carico", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "Battery1SoftStartFailure": { + "Explanation": "La batteria 1 non è riuscita a completare la sequenza di avvio morbido (pre-carica) durante l'avvio.", + "Causes": [ + "Guasto nel circuito di pre-carica che impedisce l'avvio controllato", + "Significativa differenza di tensione tra batteria e bus DC", + "Problema con il contatto o il relè nel percorso di connessione della batteria" + ], + "NextSteps": [ + "Controllare la tensione della batteria e confrontarla con quella del bus DC", + "Verificare che il circuito di pre-carica e i contatti funzionino correttamente", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "Battery1PowerTubeFault": { + "Explanation": "L'elettronica di potenza della batteria 1 (transistor IGBT o MOSFET) ha subito un guasto. Si tratta di un guasto hardware che richiede un intervento professionale.", + "Causes": [ + "Guasto del semiconduttore di potenza (IGBT/MOSFET) dovuto a sovraccarico", + "Danni causati da sovracorrente o corto circuito", + "Difetto di fabbricazione del componente sviluppatosi nel tempo" + ], + "NextSteps": [ + "Non tentare di riavviare il sistema", + "Contattare un tecnico qualificato — è necessario riparare o sostituire l'hardware interno", + "Non utilizzare il sistema fino a quando il guasto non è stato riparato professionalmente" + ] + }, + "Battery1InsufficientPower": { + "Explanation": "La batteria 1 non può fornire energia sufficiente per soddisfare la domanda attuale.", + "Causes": [ + "Lo stato di carica della batteria è troppo basso", + "La domanda di energia supera temporaneamente la potenza massima di scarica della batteria", + "La capacità della batteria si è ridotta a causa dell'invecchiamento" + ], + "NextSteps": [ + "Aspettare che la batteria si ricarichi dall'impianto fotovoltaico o dalla rete", + "Ridurre il carico se possibile durante i periodi di bassa carica della batteria", + "Questo allarme dovrebbe risolversi automaticamente una volta che la batteria ha carica sufficiente" + ] + }, + "Battery1BackupProhibited": { + "Explanation": "La batteria 1 è attualmente impedita dal fornire energia di backup, solitamente a causa di uno stato di protezione del BMS.", + "Causes": [ + "Il BMS della batteria ha attivato una protezione che impedisce la scarica", + "La batteria è in modalità di manutenzione o calibrazione", + "Lo stato di carica della batteria è al di sotto del livello minimo richiesto per l'operazione di backup" + ], + "NextSteps": [ + "Controllare lo stato del BMS e eventuali indicatori di guasto", + "Permettere alla batteria di caricarsi sopra la soglia minima di SOC per il backup", + "Riparare eventuali problemi del BMS, poi riavviare l'inverter" + ] + }, + "Battery2NotConnected": { + "Explanation": "La batteria 2 non è rilevata o non è connessa. L'inverter non riesce a trovare la seconda batteria sul bus DC.", + "Causes": [ + "L'interruttore di disconnessione della batteria 2 è aperto", + "Cavo della batteria allentato o scollegato all'inverter o ai terminali della batteria", + "Il BMS della batteria 2 si è spento a causa di un evento di protezione", + "Il fusibile della batteria 2 è saltato" + ], + "NextSteps": [ + "Verificare che l'interruttore di disconnessione della batteria 2 sia in posizione ON", + "Controllare i collegamenti del cavo della batteria sia all'inverter che ai terminali della batteria", + "Controllare lo stato del BMS della batteria 2 per eventuali codici di errore", + "Ispezionare e sostituire il fusibile se saltato, poi riavviare l'inverter" + ] + }, + "Battery2Overvoltage": { + "Explanation": "La tensione della Batteria 2 è troppo alta. La ricarica è stata limitata o interrotta per proteggere la batteria.", + "Causes": [ + "La Batteria 2 è stata sovraccaricata oltre la tensione massima", + "Malfunzionamento del BMS che permette alla tensione di salire troppo", + "Impostazioni della tensione della batteria errate nell'inverter" + ], + "NextSteps": [ + "Controllare lo stato di carica e la tensione della Batteria 2", + "Verificare le impostazioni di ricarica nella configurazione dell'inverter", + "Controllare il funzionamento del BMS e eventuali indicatori di guasto, poi riavviare" + ] + }, + "Battery2Undervoltage": { + "Explanation": "La tensione della Batteria 2 è troppo bassa. La scarica è stata limitata per proteggere la batteria da una scarica eccessiva.", + "Causes": [ + "La Batteria 2 è stata scaricata troppo profondamente", + "Guasto di una cella che riduce la capacità totale", + "Taglio di protezione a bassa tensione del BMS" + ], + "NextSteps": [ + "Permettere alla Batteria 2 di ricaricarsi da PV o dalla rete", + "Controllare lo stato di salute della batteria — le batterie vecchie perdono capacità", + "Riparare la causa sottostante, poi riavviare l'inverter" + ] + }, + "Battery2DischargeEnd": { + "Explanation": "La Batteria 2 ha raggiunto lo stato di carica minimo. La scarica è stata interrotta per proteggere la batteria.", + "Causes": [ + "La Batteria 2 è stata completamente scaricata fino al limite di SOC configurato", + "Consumo di potenza elevato che supera la ricarica disponibile" + ], + "NextSteps": [ + "Aspettare che la Batteria 2 si ricarichi da PV o dalla rete", + "Questo allarme si risolverà automaticamente una volta ripristinata una carica sufficiente" + ] + }, + "Battery2Inverted": { + "Explanation": "La polarità della batteria 2 è invertita. Questa è una condizione pericolosa che deve essere corretta immediatamente.", + "Causes": [ + "Cavi della batteria 2 collegati con positivo e negativo invertiti", + "Errore di installazione durante il cablaggio iniziale" + ], + "NextSteps": [ + "SPEGNIRE IMMEDIATAMENTE l'intero sistema", + "Scollegare i cavi della batteria 2 con attenzione dopo aver confermato che l'alimentazione è spenta", + "Ricollegare con la polarità corretta e verificare eventuali danni prima di riavviare" + ] + }, + "Battery2OverloadTimeout": { + "Explanation": "La batteria 2 ha funzionato in condizioni di sovraccarico per troppo tempo.", + "Causes": [ + "Carico elevato e continuo che supera la capacità di scarica della batteria 2", + "Degradazione della batteria 2 che riduce la potenza disponibile" + ], + "NextSteps": [ + "Ridurre il carico totale del sistema", + "Verificare se la batteria 2 è dimensionata correttamente per le esigenze di carico", + "Riavviare l'inverter dopo aver ridotto il carico" + ] + }, + "Battery2SoftStartFailure": { + "Explanation": "La batteria 2 non è riuscita a completare la sequenza di avvio graduale durante l'accensione.", + "Causes": [ + "Guasto al circuito di pre-carica della batteria 2", + "Discrepanza di tensione tra la batteria 2 e il bus DC" + ], + "NextSteps": [ + "Controllare la tensione della batteria 2 e confrontarla con la tensione del bus DC", + "Ispezionare il circuito di pre-carica e i contattori della batteria 2, quindi riavviare" + ] + }, + "Battery2PowerTubeFault": { + "Explanation": "I componenti elettronici di potenza della batteria 2 (transistor IGBT o MOSFET) hanno smesso di funzionare. È necessario un intervento professionale.", + "Causes": [ + "Guasto del semiconduttore di potenza a causa di sovraccarico, sovracorrente o degradazione del componente", + "Evento di cortocircuito che ha danneggiato lo stadio di potenza" + ], + "NextSteps": [ + "Non riavviare il sistema", + "Contattare un tecnico qualificato per la riparazione dell'hardware interno" + ] + }, + "Battery2InsufficientPower": { + "Explanation": "La batteria 2 non può fornire potenza sufficiente per soddisfare la richiesta attuale.", + "Causes": [ + "Lo stato di carica della batteria 2 è troppo basso", + "La richiesta di potenza supera la potenza massima di scarica della batteria 2", + "La capacità della batteria è degradata a causa dell'invecchiamento" + ], + "NextSteps": [ + "Aspettare che la batteria 2 si ricarichi", + "Ridurre il carico durante i periodi di bassa carica della batteria", + "Questo allarme dovrebbe scomparire una volta che la batteria ha recuperato la carica" + ] + }, + "Battery2BackupProhibited": { + "Explanation": "La batteria 2 è attualmente impedita dal fornire energia di backup.", + "Causes": [ + "La protezione del BMS della batteria 2 è attiva e impedisce la scarica", + "Lo stato di carica della batteria 2 è al di sotto della soglia minima per il backup" + ], + "NextSteps": [ + "Verificare lo stato del BMS della batteria 2 per i codici di errore", + "Consentire alla batteria 2 di caricarsi sopra la carica minima richiesta per il backup, quindi riavviare" + ] + }, + "LithiumBattery1ChargeForbidden": { + "Explanation": "Il sistema di gestione della batteria ha bloccato la carica della batteria al litio 1. La carica non è sicura in questo momento.", + "Causes": [ + "La batteria è già completamente carica — non è necessaria altra carica", + "La temperatura della batteria è fuori dalla fascia sicura per la carica (troppo calda o troppo fredda)", + "Il sistema di gestione ha attivato la protezione a causa di squilibrio di tensione o guasto interno", + "Squilibrio delle celle che richiede bilanciamento prima di riprendere la carica" + ], + "NextSteps": [ + "Controlla la temperatura della batteria — la carica è solitamente bloccata sotto 0°C o sopra ~45°C", + "Controlla lo stato del BMS o gli indicatori per i codici di errore", + "Lascia che la batteria raggiunga la temperatura normale prima di caricarla", + "Se il problema persiste a temperatura normale, contatta l'assistenza della batteria" + ] + }, + "LithiumBattery1DischargeForbidden": { + "Explanation": "Il sistema di gestione della batteria ha bloccato la scarica della batteria al litio 1. La scarica non è sicura in questo momento.", + "Causes": [ + "La batteria è al livello di carica minimo o inferiore — troppo scarica per scaricare in sicurezza", + "La temperatura della batteria è fuori dalla fascia sicura per la scarica", + "Il sistema di gestione ha attivato la protezione a bassa tensione", + "Squilibrio delle celle o evento di protezione interno del BMS" + ], + "NextSteps": [ + "Lascia che la batteria si ricarichi da PV o dalla rete fino a quando il livello di carica è sopra la soglia minima", + "Controlla la temperatura della batteria — la scarica è bloccata in condizioni molto fredde", + "Controlla lo stato del BMS per eventuali codici di errore specifici", + "Se la batteria non accetta la carica, contatta l'assistenza della batteria" + ] + }, + "LithiumBattery2ChargeForbidden": { + "Explanation": "Il sistema di gestione della batteria ha bloccato la carica della batteria al litio 2.", + "Causes": [ + "La batteria 2 è già completamente carica", + "La temperatura della batteria 2 è fuori dalla fascia sicura per la carica", + "Evento di protezione del BMS sulla batteria 2" + ], + "NextSteps": [ + "Controlla la temperatura della batteria 2 e lo stato del BMS", + "Lascia che la temperatura si normalizzi prima di caricare", + "Se il problema persiste, controlla i codici di errore del BMS" + ] + }, + "LithiumBattery2DischargeForbidden": { + "Explanation": "Il sistema di gestione della batteria 2 ha bloccato la scarica della batteria al litio 2.", + "Causes": [ + "La batteria 2 ha raggiunto lo stato di carica minimo", + "La temperatura della batteria 2 è fuori dal range sicuro per la scarica", + "Evento di protezione del BMS sulla batteria 2" + ], + "NextSteps": [ + "Permetti alla batteria 2 di ricaricarsi da pannelli solari o dalla rete", + "Controlla la temperatura della batteria e lo stato del BMS per eventuali codici di errore", + "Se la batteria non si ricarica, contatta l'assistenza della batteria" + ] + }, + "LithiumBattery1Full": { + "Explanation": "La batteria al litio 1 è completamente carica. La ricarica si è fermata automaticamente.", + "Causes": [ + "La batteria ha raggiunto il 100% dello stato di carica", + "La tensione delle celle ha raggiunto il livello massimo sicuro" + ], + "NextSteps": [ + "Questo è un funzionamento normale — nessuna azione richiesta", + "Monitora periodicamente la salute della batteria per assicurarti che le celle si bilancino correttamente" + ] + }, + "LithiumBattery1DischargeEnd": { + "Explanation": "La batteria al litio 1 ha raggiunto la fine del suo ciclo di scarica — è stato raggiunto il livello minimo di SOC sicuro.", + "Causes": [ + "La batteria è stata scaricata fino al limite minimo di SOC configurato", + "Un carico elevato notturno o diurno ha esaurito la batteria" + ], + "NextSteps": [ + "Permetti alla batteria di ricaricarsi da energia solare o dalla rete", + "Considera di ridurre il consumo durante i periodi di scarsa luce solare per preservare la carica" + ] + }, + "LithiumBattery2Full": { + "Explanation": "La batteria al litio 2 è completamente carica. La ricarica si è fermata automaticamente.", + "Causes": [ + "La batteria 2 ha raggiunto il 100% di stato di carica" + ], + "NextSteps": [ + "Questo è normale funzionamento — nessuna azione richiesta", + "Il sistema riprenderà automaticamente la ricarica se lo stato di carica scende" + ] + }, + "LithiumBattery2DischargeEnd": { + "Explanation": "La batteria al litio 2 ha raggiunto la fine del suo ciclo di scarica.", + "Causes": [ + "La batteria 2 è stata scaricata fino al limite minimo di stato di carica configurato" + ], + "NextSteps": [ + "Permetti alla batteria 2 di ricaricarsi da energia solare o dalla rete", + "Questo allarme si cancellerà automaticamente una volta ripristinata la carica" + ] + }, + "LeadBatteryTemperatureAbnormality": { + "Explanation": "La temperatura della batteria al piombo è fuori dal range operativo normale.", + "Causes": [ + "Surriscaldamento della batteria dovuto a temperatura ambiente elevata o corrente di carica eccessiva", + "Guasto al sensore di temperatura che fornisce letture errate", + "Temperatura ambientale molto bassa che rallenta le reazioni chimiche" + ], + "NextSteps": [ + "Controlla la temperatura della batteria direttamente, se è sicuro farlo", + "Migliora la ventilazione o il raffreddamento della batteria se è in sovratemperatura", + "Verifica che il sensore di temperatura sia correttamente collegato e funzionante", + "Ripara la causa sottostante, poi riavvia l'inverter" + ] + }, + "BatteryAccessMethodError": { + "Explanation": "Il metodo di accesso alla batteria è configurato in modo errato — l'inverter e la batteria non sono impostati per comunicare con lo stesso protocollo.", + "Causes": [ + "Protocollo di comunicazione della batteria selezionato in modo errato nelle impostazioni dell'inverter", + "Tipo o modello della batteria non corrispondente al metodo di accesso configurato" + ], + "NextSteps": [ + "Verificare le impostazioni di comunicazione della batteria nella configurazione dell'inverter", + "Assicurarsi che il tipo di batteria e il protocollo di comunicazione corrispondano alla batteria collegata, quindi riavviare" + ] + }, + "Pv1NotAccessed": { + "Explanation": "La stringa PV 1 non è rilevata o accessibile. L'inverter non rileva alcuna tensione o corrente dalla stringa PV 1.", + "Causes": [ + "Interruttore o isolatore della stringa PV 1 è aperto (spento)", + "Danno ai cavi che interrompono il circuito della stringa", + "Guasto a un modulo PV all'interno della stringa", + "Nessuna luce solare disponibile (notte o nuvole dense)" + ], + "NextSteps": [ + "Verificare che l'interruttore della stringa PV 1 sia in posizione ON", + "Controllare tutti i collegamenti dei cavi sulla stringa PV 1", + "Verificare ombreggiamenti o ostacoli sui pannelli", + "Riparare eventuali danni ai cavi o ai connettori trovati, quindi riavviare" + ] + }, + "Pv1Overvoltage": { + "Explanation": "La tensione della stringa PV 1 supera la tensione di ingresso DC massima dell'inverter. Questo può danneggiare l'inverter.", + "Causes": [ + "Troppi moduli PV collegati in serie per questo modello di inverter", + "Temperatura fredda che aumenta significativamente la Voc dei moduli", + "Errore di progettazione del sistema — la stringa è stata dimensionata in modo errato" + ], + "NextSteps": [ + "Verificare quanti moduli sono in serie e confrontarli con la specifica di tensione di ingresso massima dell'inverter", + "Verificare la Voc alla temperatura minima prevista sul sito — la tensione deve rimanere al di sotto del massimo dell'inverter", + "Ridurre il numero di moduli in serie se necessario" + ] + }, + "AbnormalPv1CurrentSharing": { + "Explanation": "La corrente del stringa PV1 è anomala, indicando un flusso di corrente irregolare.", + "Causes": [ + "Moduli PV non compatibili con caratteristiche elettriche diverse", + "Ombre parziali sui pannelli che attivano le diodi di bypass", + "Guasto del modulo che riduce la corrente in parte dello stringa" + ], + "NextSteps": [ + "Controllare ombre o sporco sui pannelli dello stringa PV1", + "Verificare che tutti i moduli dello stringa siano dello stesso modello e non danneggiati", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "Pv1PowerTubeFault": { + "Explanation": "L'elettronica di potenza (IGBT/MOSFET) del convertitore DC PV1 ha fallito. Si tratta di un guasto hardware.", + "Causes": [ + "Guasto IGBT o MOSFET dovuto a sovracorrente, sovratensione o degradazione a lungo termine", + "Cortocircuito o evento di sovratensione che danneggia lo stadio di potenza" + ], + "NextSteps": [ + "Non riavviare il sistema", + "Contattare un tecnico qualificato per la riparazione hardware" + ] + }, + "Pv1SoftStartFailure": { + "Explanation": "Lo stringa PV1 non è riuscito a completare la sequenza di avvio morbido (pre-carica) durante l'avvio.", + "Causes": [ + "Guasto del circuito di pre-carica che impedisce l'avvio controllato", + "Tensione PV significativamente diversa dal livello atteso del bus DC" + ], + "NextSteps": [ + "Controllare la tensione dello stringa PV1 ai terminali di ingresso dell'inverter", + "Riparare eventuali guasti del circuito di pre-carica, quindi riavviare l'inverter" + ] + }, + "Pv1OverloadTimeout": { + "Explanation": "La stringa PV1 sta erogando troppa energia oltre la sua capacità nominale per troppo tempo.", + "Causes": [ + "L'impianto fotovoltaico è sovradimensionato rispetto alla capacità del convertitore DC", + "La capacità del convertitore DC è superata da un'elevata irradiazione" + ], + "NextSteps": [ + "Verificare se le dimensioni dell'impianto fotovoltaico corrispondono alla potenza di ingresso DC dell'inverter", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "Pv1InsufficientPower": { + "Explanation": "La stringa PV1 non sta fornendo abbastanza energia. Questo è tipicamente dovuto alle condizioni meteorologiche.", + "Causes": [ + "Bassa irradiazione solare a causa di nuvole o maltempo", + "Ombreggiamento sui pannelli della stringa PV1", + "Angoli bassi del sole al mattino presto o alla sera" + ], + "NextSteps": [ + "Aspettare condizioni di luce migliore — si risolverà da solo", + "Controllare nuove fonti di ombreggiamento come alberi, edifici o detriti", + "L'allarme si disattiverà automaticamente quando l'irradiazione migliorerà" + ] + }, + "Photovoltaic1Overcurrent": { + "Explanation": "La corrente della stringa PV1 supera la massima corrente di ingresso DC dell'inverter.", + "Causes": [ + "L'impianto fotovoltaico è sovradimensionato con troppe stringhe in parallelo", + "Guasto a terra che causa un percorso di corrente anomalo", + "Cortocircuito in parte della stringa PV" + ], + "NextSteps": [ + "Controllare la configurazione della stringa PV1 — verificare il numero di stringhe in parallelo", + "Ispezionare per guasti a terra o cortocircuiti nel cablaggio", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "Pv2NotAccessed": { + "Explanation": "La stringa PV 2 non è rilevata o accessibile.", + "Causes": [ + "L'interruttore della stringa PV 2 è aperto", + "Danno ai cavi della stringa 2", + "Nessuna luce solare disponibile" + ], + "NextSteps": [ + "Verificare che l'interruttore della stringa PV 2 sia acceso", + "Controllare i collegamenti dei cavi della stringa 2", + "Riparare eventuali danni e poi riavviare l'inverter" + ] + }, + "Pv2Overvoltage": { + "Explanation": "La tensione della stringa PV 2 supera il limite massimo di ingresso DC.", + "Causes": [ + "Troppi moduli PV in serie nella stringa 2", + "Temperatura fredda che aumenta la tensione Voc oltre i limiti dell'inverter" + ], + "NextSteps": [ + "Verificare il numero di moduli e la tensione Voc della stringa 2 rispetto alle specifiche dell'inverter", + "Ridurre i moduli in serie se necessario per rispettare i limiti di tensione" + ] + }, + "AbnormalPv2CurrentSharing": { + "Explanation": "La condivisione della corrente della stringa PV 2 è anomala.", + "Causes": [ + "Moduli non abbinati o degradati nella stringa 2", + "Ombreggiatura parziale sui pannelli della stringa 2" + ], + "NextSteps": [ + "Controllare i pannelli della stringa 2 per ombreggiatura o sporco", + "Riparare il guasto sottostante e poi riavviare l'inverter" + ] + }, + "Pv2PowerTubeFault": { + "Explanation": "L'elettronica di potenza del convertitore DC PV 2 ha smesso di funzionare. È necessaria l'assistenza di un professionista.", + "Causes": [ + "Guasto del semiconduttore di potenza (IGBT/MOSFET)", + "Danni causati da sovracorrente o evento di sovratensione" + ], + "NextSteps": [ + "Non riavviare il sistema", + "Contattare un tecnico qualificato per la riparazione dell'hardware" + ] + }, + "Pv2SoftStartFailure": { + "Explanation": "La stringa PV 2 non è riuscita a completare la sequenza di avvio morbido.", + "Causes": [ + "Guasto di pre-carica sul convertitore PV 2", + "Discrepanza di tensione tra la stringa PV 2 e il bus DC" + ], + "NextSteps": [ + "Verificare la tensione di ingresso della stringa PV 2", + "Riparare il guasto di pre-carica, poi riavviare l'inverter" + ] + }, + "Pv2OverloadTimeout": { + "Explanation": "La stringa PV 2 ha erogato troppa potenza per troppo tempo.", + "Causes": [ + "L'array della stringa PV 2 è sovradimensionato rispetto alla potenza del convertitore", + "Irraggiamento prolungato che supera i limiti del convertitore" + ], + "NextSteps": [ + "Rivedere le dimensioni della stringa PV 2 rispetto alle specifiche dell'inverter", + "Riparare la causa sottostante, poi riavviare l'inverter" + ] + }, + "Pv2InsufficientPower": { + "Explanation": "La stringa PV 2 non sta fornendo abbastanza energia. Solitamente è dovuto alle condizioni meteorologiche.", + "Causes": [ + "Irradiazione solare bassa o ombreggiamento pesante sulla stringa 2", + "Angolo del sole troppo basso al mattino presto o alla sera" + ], + "NextSteps": [ + "Aspettare condizioni di luce migliore", + "Controllare eventuali nuove fonti di ombreggiamento sui pannelli della stringa 2" + ] + }, + "Pv3NotConnected": { + "Explanation": "La stringa PV 3 non è connessa o non è rilevata.", + "Causes": [ + "Interruttore della stringa PV 3 è aperto", + "Cavo disconnesso o danneggiato sulla stringa 3", + "Nessuna luce solare disponibile" + ], + "NextSteps": [ + "Verificare che l'interruttore della stringa PV 3 sia acceso", + "Controllare i collegamenti dei cavi sulla stringa 3", + "Riparare eventuali danni e poi riavviare" + ] + }, + "Pv3Overvoltage": { + "Explanation": "La tensione della stringa PV 3 supera il limite massimo di ingresso DC.", + "Causes": [ + "Troppi moduli PV in serie sulla stringa 3", + "Temperatura fredda che fa aumentare la tensione Voc oltre i limiti dell'inverter" + ], + "NextSteps": [ + "Controllare il numero di moduli della stringa 3 rispetto alla tensione massima di ingresso dell'inverter", + "Ridurre i moduli in serie se la tensione supera i limiti alla temperatura minima del sito" + ] + }, + "Pv3AverageCurrentAnomaly": { + "Explanation": "La corrente media del stringa PV 3 è anomala, indicando prestazioni irregolari all'interno della stringa.", + "Causes": [ + "Discrepanza o degradazione dei moduli nella stringa 3", + "Ombra parziale che colpisce alcuni pannelli nella stringa 3" + ], + "NextSteps": [ + "Ispezionare i pannelli della stringa 3 per ombre, sporco o danni", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "Pv3PowerTubeFailure": { + "Explanation": "L'elettronica di potenza del PV 3 ha fallito. È necessario un intervento professionale.", + "Causes": [ + "Guasto del semiconduttore di potenza per sovraccarico o invecchiamento del componente", + "Danno da sovracorrente o picco di tensione" + ], + "NextSteps": [ + "Non riavviare il sistema", + "Contattare un tecnico qualificato per la riparazione dell'hardware interno" + ] + }, + "Pv3SoftStartFailure": { + "Explanation": "La stringa PV 3 non è riuscita a completare la sequenza di avvio morbido.", + "Causes": [ + "Guasto del circuito di pre-carica sull'inverter PV 3", + "Discrepanza di tensione tra PV 3 e il bus DC" + ], + "NextSteps": [ + "Verificare la tensione della stringa PV 3 ai terminali dell'inverter", + "Riparare il guasto di pre-carica, quindi riavviare l'inverter" + ] + }, + "Pv3OverloadTimeout": { + "Explanation": "La stringa PV 3 sta erogando troppa energia per troppo tempo.", + "Causes": [ + "La stringa PV 3 è sovradimensionata rispetto alla capacità del convertitore", + "Irraggiamento solare prolungato che supera i limiti del convertitore DC" + ], + "NextSteps": [ + "Verificare le dimensioni della stringa PV 3 rispetto alle specifiche dell'inverter", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "Pv3ReverseConnection": { + "Explanation": "La stringa PV 3 è collegata con polarità invertita. Si tratta di un errore di cablaggio che deve essere corretto prima dell'uso.", + "Causes": [ + "I cavi positivo e negativo della stringa PV 3 sono stati scambiati durante l'installazione", + "Collegamento errato dei cavi all'ingresso DC dell'inverter" + ], + "NextSteps": [ + "Non tentare di riavviare — la polarità invertita può danneggiare i componenti", + "Spegnere completamente, quindi scambiare i collegamenti positivo e negativo della stringa PV 3", + "Verificare la corretta polarità prima di riavviare" + ] + }, + "Pv4NotConnected": { + "Explanation": "La stringa PV 4 non è collegata o non è rilevata.", + "Causes": [ + "L'interruttore della stringa PV 4 è aperto", + "Cavo disconnesso o danneggiato sulla stringa 4", + "Nessuna luce solare disponibile" + ], + "NextSteps": [ + "Verificare che l'interruttore della stringa PV 4 sia acceso", + "Controllare i collegamenti dei cavi sulla stringa 4", + "Riparare eventuali danni trovati, quindi riavviare" + ] + }, + "Pv4Overvoltage": { + "Explanation": "La tensione del stringa PV 4 supera la tensione massima di ingresso DC.", + "Causes": [ + "Troppi moduli PV in serie sullo stringa 4", + "Temperatura fredda che fa aumentare la Voc dei moduli oltre i limiti dell'inverter" + ], + "NextSteps": [ + "Verificare il numero di moduli dello stringa 4 rispetto alla tensione massima di ingresso dell'inverter", + "Ridurre i moduli in serie se la tensione supera la specifica" + ] + }, + "Pv4AverageCurrentAnomaly": { + "Explanation": "La corrente media dello stringa PV 4 è anomala.", + "Causes": [ + "Dismatch o degradazione dei moduli nello stringa 4", + "Ombra parziale che influisce sui pannelli dello stringa 4" + ], + "NextSteps": [ + "Ispezionare i pannelli dello stringa 4 per ombre, sporco o danni", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "Pv4PowerTubeFailure": { + "Explanation": "L'elettronica di potenza del PV 4 ha fallito. È necessario un servizio professionale.", + "Causes": [ + "Guasto del semiconduttore di potenza per sovraccarico o invecchiamento", + "Danno da sovracorrente o evento di sovratensione" + ], + "NextSteps": [ + "Non riavviare il sistema", + "Contattare un tecnico qualificato per la riparazione hardware" + ] + }, + "Pv4SoftStartFailure": { + "Explanation": "La stringa PV 4 non è riuscita a completare la sequenza di avvio morbido.", + "Causes": [ + "Guasto al circuito di pre-carica del convertitore PV 4", + "Discrepanza di tensione tra la stringa PV 4 e il bus DC" + ], + "NextSteps": [ + "Verificare la tensione della stringa PV 4 ai terminali dell'inverter", + "Riparare il guasto di pre-carica, quindi riavviare l'inverter" + ] + }, + "Pv4OverloadTimeout": { + "Explanation": "La stringa PV 4 ha erogato troppa energia per troppo tempo.", + "Causes": [ + "Array della stringa PV 4 sovradimensionato rispetto alla potenza del convertitore", + "Irraggiamento prolungato che supera la capacità del convertitore DC" + ], + "NextSteps": [ + "Verificare le dimensioni della stringa PV 4 rispetto alle specifiche dell'inverter", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "Pv4ReverseConnection": { + "Explanation": "La stringa PV 4 è collegata con polarità invertita. Questo deve essere corretto prima dell'uso.", + "Causes": [ + "Cavi positivo e negativo della stringa PV 4 scambiati durante l'installazione", + "Connessione errata dei cavi all'ingresso DC dell'inverter" + ], + "NextSteps": [ + "Non riavviare — spegnere completamente prima", + "Scambiare i collegamenti positivo e negativo della stringa PV 4 per correggere la polarità", + "Verificare la polarità prima di riavviare" + ] + }, + "InsufficientPhotovoltaicPower": { + "Explanation": "La potenza fotovoltaica disponibile è insufficiente per il carico attuale o i requisiti del sistema.", + "Causes": [ + "Bassa irradiazione solare a causa di nuvole o condizioni meteorologiche", + "Mattina o sera — l'angolo del sole è troppo basso per una produzione completa", + "Ombre significative su una o più stringhe fotovoltaiche" + ], + "NextSteps": [ + "Aspetta condizioni di luce migliore — di solito si risolve da solo", + "Controlla le ombre sui pannelli e rimuovile se possibile", + "L'allarme si disattiva automaticamente quando l'irradiazione migliora" + ] + }, + "DcBusOvervoltage": { + "Explanation": "La tensione del bus DC interno è troppo alta. Potrebbe indicare uno squilibrio energetico nel sistema.", + "Causes": [ + "Eccessiva potenza di carica che fluisce nel bus DC senza carico per consumarla", + "Carico rigenerativo che alimenta energia di nuovo nel bus DC", + "Guasto nel controllo della tensione del bus DC" + ], + "NextSteps": [ + "Controlla il bilancio di potenza tra generazione, carico e accumulo", + "Ripara il guasto sottostante, poi riavvia l'inverter" + ] + }, + "DcBusUndervoltage": { + "Explanation": "La tensione del bus DC interno è troppo bassa, impedendo il funzionamento normale.", + "Causes": [ + "Il carico sta assorbendo più potenza di quella disponibile da tutte le fonti", + "Problema di alimentazione o batteria che limita la tensione del bus DC", + "Batteria quasi scarica" + ], + "NextSteps": [ + "Ridurre il carico sul sistema", + "Controlla che tutte le fonti di alimentazione — fotovoltaico, rete e batteria — funzionino", + "Ripara la causa sottostante, poi riavvia l'inverter" + ] + }, + "DcBusVoltageUnbalance": { + "Explanation": "La tensione del bus DC è squilibrata tra le metà positiva e negativa.", + "Causes": [ + "Guasto del condensatore nel banco di condensatori del bus DC", + "Problema di controllo del bus DC", + "Carico asimmetrico tra le due metà del bus DC" + ], + "NextSteps": [ + "Controllare il banco di condensatori del bus DC per verificare eventuali guasti", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "BusSlowOvervoltage": { + "Explanation": "È stata rilevata una lenta e graduale salita della tensione del bus DC oltre i limiti di sicurezza.", + "Causes": [ + "Aumento graduale della tensione dovuto a squilibrio di carica nel tempo", + "Problema di controllo della carica che permette un lento aumento della tensione" + ], + "NextSteps": [ + "Controllare il controllo dell'alimentazione di carica e verificare che le impostazioni siano corrette", + "Riparare il guasto sottostante, quindi riavviare l'inverter" + ] + }, + "HardwareBusOvervoltage": { + "Explanation": "È scattata la protezione hardware contro la sovratensione del bus DC. Si tratta di una condizione di sovratensione grave.", + "Causes": [ + "Evento di sovratensione grave da una fonte esterna o da un guasto interno", + "Guasto di un componente che causa un aumento incontrollato della tensione" + ], + "NextSteps": [ + "Non riavviare — è necessaria un'ispezione professionale", + "Contattare un tecnico di servizio per indagare la causa della sovratensione" + ] + }, + "BusSoftStartFailure": { + "Explanation": "Il bus DC non è riuscito a caricarsi e avviarsi correttamente durante l'accensione.", + "Causes": [ + "Guasto al resistore o circuito di pre-carica", + "Guasto al condensatore del bus DC che impedisce la carica", + "Relè o contattore nel percorso di pre-carica non funziona correttamente" + ], + "NextSteps": [ + "Controllare il circuito di pre-carica e tutti i relè associati", + "Riparare il guasto e riavviare l'inverter" + ] + }, + "InverterPowerTubeFault": { + "Explanation": "I componenti elettronici principali dell'inverter (transistor IGBT o MOSFET) sono guasti. Si tratta di un guasto hardware che richiede assistenza professionale.", + "Causes": [ + "Guasto al semiconduttore di potenza per sovraccarico prolungato", + "Danno da sovracorrente causato da un cortocircuito", + "Danno termico per surriscaldamento", + "Guasto per fine vita del componente" + ], + "NextSteps": [ + "Non tentare di riavviare — l'uso continuo rischia ulteriori danni", + "Contattare immediatamente un tecnico qualificato", + "È necessaria la riparazione hardware o la sostituzione del modulo" + ] + }, + "HardwareOvercurrent": { + "Explanation": "La protezione hardware da sovracorrente è scattata — la corrente ha superato il limite massimo hardware.", + "Causes": [ + "Cortocircuito nei cavi di uscita o nei carichi collegati", + "Sovraccarico grave che supera la soglia di protezione hardware", + "Guasto di un componente elettronico di potenza interno" + ], + "NextSteps": [ + "Non riavviare fino a quando la causa non è identificata", + "Contattare un tecnico per ispezionare cortocircuiti e danni ai componenti" + ] + }, + "DcConverterOvervoltage": { + "Explanation": "La tensione di ingresso o uscita del convertitore DC è troppo alta.", + "Causes": [ + "Tensione di ingresso (PV o batteria) superiore ai limiti del convertitore", + "Guasto al controllo della tensione del convertitore DC" + ], + "NextSteps": [ + "Verificare i livelli di tensione PV e della batteria", + "Riparare la causa sottostante, poi riavviare l'inverter" + ] + }, + "DcConverterHardwareOvervoltage": { + "Explanation": "La protezione da sovratensione hardware del convertitore DC è scattata — si è verificata una condizione di sovratensione grave.", + "Causes": [ + "Sovratensione grave all'ingresso o all'uscita del convertitore DC", + "Impulso di fulmine o picco di tensione esterno" + ], + "NextSteps": [ + "Non riavviare — contattare un tecnico per un'ispezione dei danni prima di qualsiasi ulteriore operazione" + ] + }, + "DcConverterOvercurrent": { + "Explanation": "La corrente del convertitore DC è troppo alta.", + "Causes": [ + "Condizione di sovraccarico che assorbe troppa corrente attraverso il convertitore", + "Cortocircuito nel circuito DC" + ], + "NextSteps": [ + "Ridurre il carico o la potenza di carica/scarica", + "Verificare i cortocircuiti, poi riavviare l'inverter" + ] + }, + "DcConverterHardwareOvercurrent": { + "Explanation": "La protezione da sovracorrente del convertitore DC è stata attivata — il limite di corrente assoluto è stato superato.", + "Causes": [ + "Sovracorrente grave causato da corto circuito o guasto hardware", + "Guasto all'elettronica di potenza che causa un flusso di corrente incontrollato" + ], + "NextSteps": [ + "Non riavviare — contattare un tecnico di servizio per ispezionare eventuali danni prima di qualsiasi ulteriore operazione" + ] + }, + "DcConverterResonatorOvercurrent": { + "Explanation": "Il circuito risonante del convertitore DC sta sperimentando una sovracorrente.", + "Causes": [ + "Condizione di risonanza che causa un'eccessiva oscillazione di corrente nel convertitore", + "Problema di controllo del convertitore DC che influisce sul circuito risonante" + ], + "NextSteps": [ + "Riparare il guasto sottostante, poi riavviare l'inverter; se persistente, contattare il servizio" + ] + }, + "SystemOutputOverload": { + "Explanation": "La potenza di uscita totale del sistema è sovraccarica — viene richiesta più potenza di quella che il sistema può fornire in sicurezza.", + "Causes": [ + "Troppi carichi ad alta potenza collegati contemporaneamente", + "La domanda totale di carico supera la capacità di uscita nominale dell'inverter", + "Corto circuito in uno dei carichi collegati" + ], + "NextSteps": [ + "Disconnettere alcuni carichi per ridurre il consumo totale di energia", + "Controllare eventuali cortocircuiti o guasti negli apparecchi collegati", + "Riparare la causa sottostante, poi riavviare l'inverter" + ] + }, + "InverterOverload": { + "Explanation": "L'inverter è sovraccarico — il carico sta assorbendo più potenza di quanto l'inverter sia progettato per gestire.", + "Causes": [ + "La potenza del carico collegato supera la potenza continua nominale dell'inverter", + "Corrente di avviamento elevata da motori o compressori grandi all'accensione", + "Cortocircuito in un carico collegato" + ], + "NextSteps": [ + "Ridurre il carico totale collegato", + "Distribuire l'avviamento di grandi elettrodomestici per ridurre la corrente di avviamento", + "Riparare la causa sottostante, poi riavviare l'inverter" + ] + }, + "InverterOverloadTimeout": { + "Explanation": "L'inverter è stato sovraccarico per troppo tempo ed è scattato il dispositivo di protezione.", + "Causes": [ + "Condizione di sovraccarico prolungato che supera la capacità di sovraccarico temporaneo dell'inverter", + "Inverter sottodimensionato rispetto ai requisiti di carico effettivi" + ], + "NextSteps": [ + "Ridurre permanentemente il carico collegato", + "Considerare l'aggiornamento a un inverter più grande se il carico è necessario", + "Riparare la causa sottostante, poi riavviare l'inverter" + ] + }, + "LoadPowerOverload": { + "Explanation": "La potenza del carico collegato supera la capacità del sistema.", + "Causes": [ + "Troppi elettrodomestici ad alta potenza in funzione contemporaneamente", + "Un nuovo dispositivo ad alta potenza aggiunto che supera la capacità del sistema" + ], + "NextSteps": [ + "Ridurre il carico spegnendo elettrodomestici non essenziali", + "Distribuire l'uso di dispositivi ad alta potenza, poi riavviare l'inverter" + ] + }, + "BalancedCircuitOverloadTimeout": { + "Explanation": "Il circuito di bilanciamento delle fasi è stato sovraccaricato per troppo tempo.", + "Causes": [ + "Carico sbilanciato tra le fasi — una fase porta molto più delle altre", + "Una singola fase è significativamente sovraccaricata" + ], + "NextSteps": [ + "Ridistribuire i carichi in modo più uniforme tra le tre fasi", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "InverterSoftStartFailure": { + "Explanation": "L'inverter non è riuscito a completare la sequenza di avvio graduale durante l'accensione.", + "Causes": [ + "Resistenza di pre-carica difettosa, impedisce la carica controllata del bus DC", + "Contattore o relè non si chiude correttamente durante la sequenza di avvio", + "Problema del condensatore del bus DC che influisce sulla pre-carica", + "Guasto alla scheda di controllo che impedisce il completamento della sequenza di avvio" + ], + "NextSteps": [ + "Riawviare il sistema — spegnere tutti i dispositivi di disconnessione, attendere 30 secondi, poi riaccendere", + "Verificare che la tensione del bus DC salga in modo uniforme durante la pre-carica", + "Se il guasto persiste, contattare un tecnico di assistenza" + ] + }, + "Dsp1ParameterSettingFault": { + "Explanation": "Il DSP 1 (processore di segnali digitali) ha rilevato una configurazione di parametri errata.", + "Causes": [ + "Uno o più parametri dell'inverter impostati al di fuori dell'intervallo valido", + "Corruzione del firmware che influisce sullo storage dei parametri", + "Incompatibilità di configurazione dopo l'aggiornamento del firmware" + ], + "NextSteps": [ + "Rivedere tutti i parametri dell'inverter e correggere eventuali valori fuori intervallo", + "Ripristinare i parametri ai valori di fabbrica se non si è sicuri dei valori corretti", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "Dsp2ParameterSettingFault": { + "Explanation": "Il DSP 2 ha rilevato una configurazione dei parametri errata.", + "Causes": [ + "Uno o più parametri impostati al di fuori dell'intervallo valido", + "Corruzione del firmware che influisce sulla memorizzazione dei parametri" + ], + "NextSteps": [ + "Rivedere e correggere le impostazioni dei parametri", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "DspVersionCompatibilityFault": { + "Explanation": "La versione del firmware DSP non è compatibile con altri componenti del sistema.", + "Causes": [ + "Le versioni del firmware tra DSP e altre schede non corrispondono", + "Aggiornamento del firmware incompleto o fallito che lascia i componenti su versioni diverse" + ], + "NextSteps": [ + "Aggiornare tutti i componenti del firmware alla stessa versione compatibile", + "Contattare l'assistenza tecnica se la versione corretta è sconosciuta" + ] + }, + "CpldVersionCompatibilityFault": { + "Explanation": "La versione del CPLD (dispositivo logico programmabile complesso) non è compatibile con il sistema.", + "Causes": [ + "Incompatibilità del firmware CPLD con altri componenti", + "Aggiornamento del firmware incompleto" + ], + "NextSteps": [ + "Eseguire un aggiornamento completo del firmware per assicurarsi che tutti i componenti siano sulla stessa versione", + "Riavviare l'inverter dopo l'aggiornamento" + ] + }, + "CpldCommunicationFault": { + "Explanation": "La comunicazione con il chip interno CPLD è fallita.", + "Causes": [ + "Guasto al bus di comunicazione interno tra DSP e CPLD", + "Guasto del chip CPLD" + ], + "NextSteps": [ + "Riavvia il sistema — potrebbe ripristinare la comunicazione", + "Se il guasto persiste dopo il riavvio, contatta un tecnico" + ] + }, + "DspCommunicationFault": { + "Explanation": "La comunicazione con il DSP è fallita.", + "Causes": [ + "Guasto al bus di comunicazione interno", + "Guasto hardware del DSP" + ], + "NextSteps": [ + "Riavvia il sistema", + "Se il guasto persiste dopo il riavvio, contatta un tecnico" + ] + }, + "OutputVoltageDcOverlimit": { + "Explanation": "È comparsa una componente di tensione DC nella tensione di uscita AC, superando il limite consentito.", + "Causes": [ + "Deriva del loop di controllo che introduce un offset DC in uscita", + "Errore di offset del sensore di tensione", + "Problema hardware nello stadio di uscita" + ], + "NextSteps": [ + "Riavvia l'inverter — spesso elimina gli offset transitori", + "Se persistente, contatta un tecnico" + ] + }, + "OutputCurrentDcOverlimit": { + "Explanation": "È presente una componente di corrente continua nella corrente di uscita in corrente alternata, che supera il limite consentito.", + "Causes": [ + "Problema di controllo che introduce un offset DC nella corrente di uscita", + "Guasto o errore di calibrazione del sensore di corrente" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se il guasto persiste, contattare l'assistenza per un'ispezione del sensore" + ] + }, + "RelaySelfCheckFails": { + "Explanation": "L'autotest del relè è fallito durante l'avvio o la verifica periodica.", + "Causes": [ + "Guasto ai contatti del relè — potrebbero essere danneggiati o saldati", + "Guasto al circuito di pilotaggio del relè", + "I contatti del relè si sono saldati a causa di sovracorrente" + ], + "NextSteps": [ + "Verificare il funzionamento del relè ascoltando i click durante l'avvio", + "Riparare il guasto sottostante, poi riavviare l'inverter" + ] + }, + "InverterRelayOpen": { + "Explanation": "Il relè di uscita dell'inverter è inspiegabilmente aperto quando dovrebbe essere chiuso.", + "Causes": [ + "Guasto al circuito di pilotaggio del relè che impedisce la chiusura", + "Un evento di protezione ha aperto il relè" + ], + "NextSteps": [ + "Verificare la presenza di altre allarmi di protezione attivi che potrebbero aver aperto il relè", + "Riparare il guasto sottostante, poi riavviare l'inverter" + ] + }, + "InverterRelayShortCircuit": { + "Explanation": "I contatti del relè dell'inverter si sono saldati (cortocircuito). Il relè non può aprirsi quando necessario.", + "Causes": [ + "I contatti del relè si sono saldati a causa di una corrente eccessiva durante un guasto", + "Guasto del componente del relè" + ], + "NextSteps": [ + "Non riavviare — un relè saldato è un pericolo per la sicurezza", + "Contattare un tecnico di servizio per ispezionare e sostituire il relè" + ] + }, + "OpenCircuitOfPowerGridRelay": { + "Explanation": "Il relè di connessione alla rete è inspiegabilmente aperto.", + "Causes": [ + "Guasto del relè di rete che impedisce la chiusura normale", + "Un evento di protezione ha aperto il relè di rete", + "Problema nel circuito di comando del relè" + ], + "NextSteps": [ + "Verificare se ci sono altre allarmi attive che potrebbero spiegare l'apertura del relè", + "Ispezionare il relè e il circuito di comando, quindi riavviare l'inverter" + ] + }, + "ShortCircuitOfPowerGridRelay": { + "Explanation": "I contatti del relè di rete si sono saldati e non possono aprirsi quando necessario.", + "Causes": [ + "I contatti del relè si sono saldati a causa di una corrente eccessiva da un evento di guasto", + "Guasto o fine vita del componente del relè" + ], + "NextSteps": [ + "Non riavviare — contattare un tecnico di servizio per sostituire il relè prima di riavviare" + ] + }, + "GeneratorRelayOpenCircuit": { + "Explanation": "Il relè di connessione del generatore è inspiegabilmente aperto.", + "Causes": [ + "Guasto al relè del generatore che impedisce la chiusura", + "Evento di protezione che ha aperto il relè", + "Problema nel circuito di pilotaggio del relè" + ], + "NextSteps": [ + "Verificare altri allarmi attivi che potrebbero spiegare lo stato del relè", + "Ispezionare il circuito del relè, quindi riavviare l'inverter" + ] + }, + "GeneratorRelayShortCircuit": { + "Explanation": "I contatti del relè del generatore si sono saldati e non possono aprirsi.", + "Causes": [ + "Contatti del relè saldati da corrente eccessiva", + "Guasto del componente del relè del generatore" + ], + "NextSteps": [ + "Non riavviare — contattare un tecnico per sostituire il relè del generatore prima dell'uso" + ] + }, + "AbnormalInverter": { + "Explanation": "È stato rilevato un'anomalia generale dell'inverter. Verificare eventuali altri codici di allarme più specifici che potrebbero indicare la causa principale.", + "Causes": [ + "Guasto al sistema di controllo interno senza diagnosi più specifica disponibile", + "Più guasti minori che si verificano contemporaneamente", + "Elettronica di potenza che opera al di fuori dei parametri normali" + ], + "NextSteps": [ + "Riavviare l'inverter e verificare se compaiono altri allarmi specifici al riavvio", + "Controllare tutte le tensioni di ingresso e i livelli di carico per valori anomali", + "Se l'allarme persiste, contattare un tecnico con il registro completo degli allarmi" + ] + }, + "ParallelCommunicationAlarm": { + "Explanation": "La comunicazione tra gli inverter collegati in parallelo è fallita. Senza comunicazione, gli inverter non possono sincronizzarsi e condividere correttamente il carico.", + "Causes": [ + "Il cavo di comunicazione tra gli inverter paralleli è danneggiato o scollegato", + "Guasto all'interfaccia di comunicazione parallela su un'unità", + "Impostazioni non corrispondenti tra le unità parallele" + ], + "NextSteps": [ + "Controllare tutti i cavi di comunicazione parallela tra le unità inverter", + "Verificare che tutte le impostazioni parallele (tensione, frequenza, impostazioni di caduta) corrispondano su tutte le unità", + "Riparare il guasto sottostante, quindi riavviare il sistema inverter" + ] + }, + "ParallelModuleMissing": { + "Explanation": "Uno dei moduli inverter paralleli attesi non risponde.", + "Causes": [ + "Un modulo parallelo è andato offline o si è spento", + "Il collegamento di comunicazione con un modulo è stato perso", + "Un modulo ha scatenato un proprio allarme" + ], + "NextSteps": [ + "Controllare tutte le unità inverter parallele per eventuali allarmi individuali o perdita di alimentazione", + "Riparare il guasto sottostante sul modulo mancante, quindi riavviare" + ] + }, + "DuplicateMachineNumbersForParallelModules": { + "Explanation": "Due moduli inverter paralleli sono stati configurati con lo stesso numero di unità, causando un conflitto.", + "Causes": [ + "Errore di configurazione — lo stesso numero di unità assegnato a due unità diverse durante l'impostazione", + "Indirizzo duplicato non rilevato durante la messa in servizio iniziale" + ], + "NextSteps": [ + "Accedere alle impostazioni di ogni unità e assegnare un ID univoco a ciascuna", + "Riparare la configurazione, quindi riavviare il sistema inverter" + ] + }, + "ParameterConflictInParallelModule": { + "Explanation": "Esiste un conflitto di parametri tra i moduli inverter collegati in parallelo — le impostazioni non corrispondono.", + "Causes": [ + "Parametri chiave come tensione di riferimento, frequenza o impostazioni di droop differiscono tra le unità", + "Un'unità è stata aggiornata o riconfigurata senza aggiornare le altre" + ], + "NextSteps": [ + "Confronta le impostazioni su tutte le unità in parallelo e sincronizzale ai medesimi valori", + "Risolvi il conflitto di configurazione, poi riavvia il sistema" + ] + }, + "SystemDerating": { + "Explanation": "Il sistema funziona a potenza ridotta (riduzione) per proteggersi. Le prestazioni saranno inferiori ai livelli nominali finché non sarà risolta la causa.", + "Causes": [ + "Temperatura elevata dell'inverter che causa riduzione termica", + "Tensione di ingresso (PV o rete) al limite del range operativo", + "Componente che raggiunge i limiti operativi" + ], + "NextSteps": [ + "Controlla la temperatura dell'inverter e migliora la ventilazione se necessario", + "Verifica che le tensioni di ingresso siano nel range operativo dell'inverter", + "Identifica e risolvi la causa specifica della riduzione — controlla se sono attivi altri allarmi" + ] + }, + "PvAccessMethodErrorAlarm": { + "Explanation": "Il metodo di configurazione dell'ingresso PV è impostato in modo errato, causando una discrepanza tra il cablaggio fisico e la configurazione software.", + "Causes": [ + "Il cablaggio delle stringhe PV non corrisponde alla configurazione selezionata (es. impostazione serie vs parallelo errata)", + "Cablaggio collegato in modo non conforme al metodo di accesso PV configurato nell'inverter" + ], + "NextSteps": [ + "Controlla le impostazioni di configurazione PV e confrontale con il cablaggio fisico effettivo", + "Correggi le impostazioni o il cablaggio per farli corrispondere, poi riavvia" + ] + }, + "ReservedAlarms4": { + "Explanation": "L'allarme riservato 4 è attivo. Questo codice allarme non è documentato nelle tabelle standard.", + "Causes": [ + "È stata rilevata una condizione interna non documentata" + ], + "NextSteps": [ + "Monitora il sistema per altri allarmi che potrebbero fornire ulteriori dettagli", + "Contatta l'assistenza tecnica con il registro completo degli allarmi se il problema persiste" + ] + }, + "ReservedAlarms5": { + "Explanation": "L'allarme riservato 5 è attivo. Questo codice allarme non è documentato nelle tabelle standard.", + "Causes": [ + "È stata rilevata una condizione interna non documentata" + ], + "NextSteps": [ + "Monitora il sistema per altri allarmi che potrebbero fornire ulteriori dettagli", + "Contatta l'assistenza tecnica con il registro completo degli allarmi se il problema persiste" + ] + }, + "ReverseMeterConnection": { + "Explanation": "Il contatore energetico è installato o cablato in modo inverso. Le letture del contatore (import/export) saranno errate fino a quando non verrà corretto.", + "Causes": [ + "Trasformatore di corrente (CT) installato nella direzione sbagliata", + "Fili L e N del contatore collegati in modo inverso durante l'installazione" + ], + "NextSteps": [ + "Non fare affidamento sulle letture del contatore fino a quando non sarà corretto", + "Contatta l'installatore o un elettricista qualificato per invertire il CT o correggere il cablaggio del contatore" + ] + }, + "InverterSealPulse": { + "Explanation": "Il segnale di impulso del sigillo dell'inverter è attivo, indicando che la limitazione dell'output è in atto.", + "Causes": [ + "Una funzione di protezione ha attivato la limitazione dell'output", + "Segnale esterno o funzione di conformità al codice di rete che limita l'output" + ], + "NextSteps": [ + "Controllare lo stato del sistema per altre allarmi attive che spiegano la limitazione", + "Riparare la causa sottostante, quindi riavviare l'inverter" + ] + }, + "AbnormalDieselGeneratorVoltage": { + "Explanation": "La tensione del generatore diesel è al di fuori dell'intervallo accettabile per il collegamento all'inverter.", + "Causes": [ + "Tensione di uscita del generatore non regolata al livello corretto", + "Guasto all'AVR (regolatore automatico di tensione) del generatore", + "Generatore sottocarico o sovraccarico che influisce sulla tensione di uscita" + ], + "NextSteps": [ + "Controllare e regolare la tensione di uscita del generatore per corrispondere alle specifiche dell'inverter", + "Ispezionare l'AVR se la tensione non può essere stabilizzata, quindi riavviare" + ] + }, + "AbnormalDieselGeneratorFrequency": { + "Explanation": "La frequenza del generatore diesel è al di fuori dell'intervallo accettabile.", + "Causes": [ + "Velocità del motore del generatore non impostata correttamente per la frequenza target", + "Guasto al governatore che causa instabilità di frequenza" + ], + "NextSteps": [ + "Regolare la velocità del generatore per ottenere la frequenza corretta (50 Hz o 60 Hz a seconda del caso)", + "Ispezionare e riparare il governatore se la frequenza non può essere stabilizzata, quindi riavviare" + ] + }, + "DieselGeneratorVoltageReverseSequence": { + "Explanation": "Il generatore diesel è collegato con la sequenza di fase invertita.", + "Causes": [ + "I cavi di uscita del generatore sono collegati nell'ordine di fase errato (L1, L2, L3 invertiti)" + ], + "NextSteps": [ + "Non riavviare — contattare un elettricista qualificato per correggere il cablaggio di fase del generatore prima di utilizzarlo" + ] + }, + "DieselGeneratorVoltageOutOfPhase": { + "Explanation": "La tensione del generatore non è in fase con la rete o il sistema, impedendo la sincronizzazione.", + "Causes": [ + "Problema di sincronizzazione — il generatore non si allinea con l'angolo di fase della rete", + "Disallineamento dell'angolo di fase tra generatore e rete" + ], + "NextSteps": [ + "Verificare le impostazioni di sincronizzazione e assicurarsi che il generatore supporti l'auto-sincronizzazione con questo inverter", + "Riparare il guasto di sincronizzazione, quindi riavviare" + ] + }, + "GeneratorOverload": { + "Explanation": "Il generatore diesel è sovraccarico — il sistema sta prelevando più energia di quanto il generatore sia in grado di fornire.", + "Causes": [ + "La domanda totale di carico supera la capacità nominale del generatore", + "La ricarica della batteria combinata con la domanda di carico supera la capacità del generatore", + "Il generatore è sottodimensionato per l'installazione" + ], + "NextSteps": [ + "Ridurre il carico o ridurre la velocità di ricarica della batteria per portare la domanda totale entro la capacità del generatore", + "Riavviare l'inverter dopo aver ridotto il carico" + ] + }, + "StringFault": { + "Explanation": "È stato rilevato un guasto alla stringa. Una o più stringhe fotovoltaiche potrebbero avere problemi che influenzano la produzione di energia.", + "Causes": [ + "Guasto o danno al pannello fotovoltaico all'interno della stringa", + "Problema di cablaggio della stringa o connessione allentata", + "Connettore MC4 danneggiato o corrosso", + "Degradazione del modulo che causa una riduzione o assenza di produzione" + ], + "NextSteps": [ + "Controllare se i pannelli fotovoltaici sono visivamente normali — cercare crepe, scolorimento o danni", + "Ispezionare i collegamenti dei cavi della stringa e i connettori MC4 per danni o corrosione", + "Cercare cavi danneggiati lungo il percorso della stringa", + "Fare in modo che un tecnico testi ogni stringa con un multimetro se il guasto non si risolve" + ] + }, + "PvStringPidQuickConnectAbnormal": { + "Explanation": "La stringa fotovoltaica o i terminali di connessione rapida PID sono anomali.", + "Causes": [ + "Terminale di connessione rapida allentato o non agganciato correttamente", + "Alloggiamento della connessione rapida danneggiato", + "Corrosione o ossidazione sui contatti del terminale" + ], + "NextSteps": [ + "Spegnere il sistema prima di ispezionare i terminali", + "Controllare tutti i terminali di connessione rapida e assicurarsi che siano completamente agganciati", + "Pulire i contatti corrotti e riconnetterli in modo sicuro" + ] + }, + "DcSpdFunctionAbnormal": { + "Explanation": "La funzione del dispositivo di protezione contro le sovratensioni (SPD) in corrente continua è anomala. L'SPD protegge contro i fulmini e le sovratensioni sul lato DC.", + "Causes": [ + "L'SPD DC ha scattato o è guasto dopo un evento di sovratensione", + "La cartuccia SPD ha raggiunto la fine della sua vita utile", + "Guasto di cablaggio dell'SPD" + ], + "NextSteps": [ + "Spegnere il sistema e controllare l'indicatore dell'SPD DC — la maggior parte degli SPD ha un segnale visivo di guasto", + "Sostituire la cartuccia SPD se ha scattato o mostra un guasto", + "Riavviare l'inverter dopo la sostituzione o l'ispezione" + ] + }, + "PvShortCircuited": { + "Explanation": "La stringa PV1 o PV2 sembra essere in cortocircuito.", + "Causes": [ + "Danneggiamento dell'isolamento del cavo che causa un cortocircuito diretto tra i conduttori positivo e negativo", + "Guasto del connettore MC4 che causa un cortocircuito interno", + "Difetto della scatola di giunzione del modulo che crea un percorso di cortocircuito" + ], + "NextSteps": [ + "Spegnere tutti i dispositivi di interruzione DC prima dell'ispezione", + "Controllare le stringhe PV1 e PV2 singolarmente per sintomi di cortocircuito (lettura di tensione zero, calore anomalo)", + "Ispezionare i cavi per danni e testare la resistenza di isolamento", + "Riparare o sostituire i cavi/connettori danneggiati prima di riavviare" + ] + }, + "PvBoostDriverAbnormal": { + "Explanation": "Il circuito del driver del convertitore di boost PV è anomalo.", + "Causes": [ + "Guasto del circuito del driver di boost o guasto di un componente", + "Interferenza EMI che influisce sul segnale del driver", + "Problema hardware interno sulla scheda dell'inverter" + ], + "NextSteps": [ + "Riavviare l'inverter — i guasti transitori del driver spesso si risolvono dopo il riavvio", + "Se il guasto persiste dopo il riavvio, contattare il produttore per l'assistenza" + ] + }, + "AcSpdFunctionAbnormal": { + "Explanation": "La funzione del dispositivo di protezione da sovratensioni (SPD) AC è anomala. Lo SPD protegge da fulmini e sovratensioni sul lato AC.", + "Causes": [ + "Lo SPD AC ha scattato o è guasto dopo un evento di sovratensione", + "La cartuccia dello SPD ha raggiunto la fine della sua vita utile", + "Difetto di cablaggio dello SPD AC" + ], + "NextSteps": [ + "Spegnere il sistema e controllare l'indicatore dello SPD AC", + "Sostituire la cartuccia dello SPD AC se mostra un guasto o ha scattato", + "Riavviare l'inverter dopo la sostituzione o l'ispezione" + ] + }, + "DcFuseBlown": { + "Explanation": "Il fusibile DC è saltato, interrompendo l'ingresso PV all'inverter.", + "Causes": [ + "Sovracorrente nel circuito DC dal pannello PV che supera la capacità del fusibile", + "Cortocircuito nel cablaggio DC che fa saltare il fusibile", + "Usura del fusibile dopo ripetuti eventi di sovracorrente" + ], + "NextSteps": [ + "Spegnere tutti gli interruttori e i dispositivi di disconnessione DC prima di lavorare sul circuito", + "Localizzare e ispezionare il fusibile DC — apparirà visibilmente saltato o misurerà aperto con un multimetro", + "Identificare e riparare la causa della sovracorrente prima di sostituire il fusibile", + "Sostituire il fusibile con la giusta capacità, poi riavviare l'inverter" + ] + }, + "DcInputVoltageTooHigh": { + "Explanation": "La tensione DC in ingresso dal pannello PV supera la tensione massima sicura dell'inverter. Questo può danneggiare immediatamente l'inverter.", + "Causes": [ + "Troppi moduli PV collegati in serie, superando la tensione massima della stringa", + "Temperatura fredda che aumenta la tensione di circuito aperto (Voc) del modulo oltre il limite dell'inverter", + "Errore di progettazione del sistema — la stringa è stata dimensionata in modo errato per questo inverter" + ], + "NextSteps": [ + "Spegnere immediatamente l'interruttore DC per proteggere l'inverter", + "Misurare la tensione DC effettiva prima di riconnettere", + "Rivereficare il progetto della stringa — verificare che la Voc alla temperatura minima attesa non superi il massimo dell'inverter", + "Riconfigurare la stringa riducendo i moduli in serie se necessario" + ] + }, + "PvReversed": { + "Explanation": "La polarità della stringa PV è invertita — i collegamenti positivo e negativo sono scambiati.", + "Causes": [ + "Cavi della stringa PV collegati con positivo e negativo invertiti all'inverter o alla scatola di giunzione", + "Errore di installazione durante il cablaggio iniziale" + ], + "NextSteps": [ + "Spegnere tutti i dispositivi di disconnessione DC prima di lavorare sul cablaggio", + "Identificare il collegamento invertito — verificare la polarità della stringa PV con un multimetro", + "Scambiare i collegamenti positivo e negativo per correggere la polarità prima di riavviare" + ] + }, + "PidFunctionAbnormal": { + "Explanation": "La funzione di protezione PID (Degradazione Indotta da Potenziale) è anomala.", + "Causes": [ + "Guasto o errore di configurazione del modulo PID", + "Problema di comunicazione tra inverter e modulo PID" + ], + "NextSteps": [ + "Riavviare l'inverter — spesso risolve i guasti PID transitori", + "Verificare le impostazioni e le connessioni del modulo PID se il problema persiste dopo il riavvio" + ] + }, + "PvStringDisconnected": { + "Explanation": "Una stringa PV è stata disconnessa o non sta erogando energia.", + "Causes": [ + "Interruttore DC o isolatore di questa stringa è aperto", + "Cavo si è allentato o disconnesso a un connettore", + "Guasto del connettore MC4" + ], + "NextSteps": [ + "Verificare che tutti gli interruttori delle stringhe PV siano in posizione ON", + "Controllare le connessioni dei cavi sia sul pannello che sull'inverter", + "Ricollegare eventuali connessioni allentate e riavviare l'inverter" + ] + }, + "PvStringCurrentUnbalanced": { + "Explanation": "Le correnti delle diverse stringhe PV sono significativamente squilibrate, suggerendo che una stringa funziona peggio delle altre.", + "Causes": [ + "Ombra su alcuni moduli di una stringa ma non sugli altri", + "Differenze o degradazione dei moduli in parte dell'impianto", + "Guasto parziale della stringa — alcuni moduli non contribuiscono", + "Spolveramento o escrementi di uccelli sui pannelli in un'area" + ], + "NextSteps": [ + "Controllare tutti i pannelli PV per ombra, sporco o danni visibili", + "Confrontare le tensioni e le correnti delle stringhe individualmente per identificare quella con prestazioni inferiori", + "Pulire i pannelli se c'è sporco visibile e controllare nuove fonti di ombra" + ] + }, + "NoUtilityGrid": { + "Explanation": "Non viene rilevata alcuna connessione alla rete elettrica o l'alimentazione della rete è interrotta.", + "Causes": [ + "Interruzione della rete elettrica nella tua zona", + "L'interruttore automatico AC tra l'inverter e la rete è scattato", + "Cavo AC della rete scollegato all'inverter o al quadro elettrico", + "Lavori di manutenzione dell'azienda elettrica che hanno disconnesso l'alimentazione locale" + ], + "NextSteps": [ + "Verifica se altri elettrodomestici nell'edificio hanno alimentazione dalla rete — se non ce l'hanno, si tratta di un'interruzione della rete", + "Controlla che l'interruttore automatico AC sia acceso e non sia scattato", + "Verifica i collegamenti del cavo AC all'inverter", + "Aspetta che l'azienda elettrica ripristini l'alimentazione se si tratta di un'interruzione della rete" + ] + }, + "GridVoltageOutOfRange": { + "Explanation": "La tensione della rete elettrica è al di fuori dell'intervallo in cui l'inverter può funzionare.", + "Causes": [ + "La tensione della rete è troppo alta o troppo bassa al tuo punto di connessione", + "Problemi locali della rete come sovraccarico o problemi al trasformatore", + "Impostazione del trasformatore non ottimale per la tua posizione" + ], + "NextSteps": [ + "Controlla la tensione effettiva della rete ai terminali dell'inverter", + "Se la tensione della rete è costantemente fuori limite, contatta il tuo fornitore di energia", + "L'inverter si riconnetterà automaticamente quando la tensione tornerà alla normalità" + ] + }, + "GridFrequencyOutOfRange": { + "Explanation": "La frequenza della rete elettrica è al di fuori dell'intervallo in cui l'inverter può funzionare.", + "Causes": [ + "Frequenza della rete instabile a causa di eventi di carico elevato sulla rete", + "Se si utilizza un generatore, la frequenza del generatore è fuori tolleranza", + "Evento di disturbo della rete" + ], + "NextSteps": [ + "Controlla la frequenza effettiva della rete all'inverter", + "Se si utilizza un generatore, regola il governatore per correggere la frequenza di uscita", + "Aspetta che la rete si stabilizzi — l'inverter si riconnetterà automaticamente" + ] + }, + "Overload": { + "Explanation": "Il sistema sta subendo un sovraccarico — viene richiesta più energia di quanta l'inverter possa fornire all'uscita di backup (EPS).", + "Causes": [ + "Il carico totale collegato all'uscita EPS supera la capacità di backup dell'inverter", + "Corrente di avviamento da elettrodomestici con motori o compressori che si accendono", + "Cortocircuito in uno dei carichi di backup" + ], + "NextSteps": [ + "Ridurre il carico sull'uscita EPS spegnendo elettrodomestici non essenziali", + "Controllare eventuali elettrodomestici difettosi che potrebbero assorbire troppa corrente", + "Distribuire l'avvio di grandi elettrodomestici per ridurre la corrente di avviamento" + ] + }, + "MeterDisconnected": { + "Explanation": "Il contatore energetico ha perso la comunicazione con l'inverter.", + "Causes": [ + "Il contatore energetico si è spento o ha perso alimentazione", + "Il cavo di comunicazione tra inverter e contatore è danneggiato o scollegato", + "Guasto alla porta di comunicazione del contatore" + ], + "NextSteps": [ + "Verificare che il contatore energetico abbia alimentazione e sia acceso", + "Controllare i collegamenti del cavo di comunicazione sia sull'inverter che sul contatore", + "Controllare l'alimentazione del contatore e la porta di comunicazione" + ] + }, + "MeterReverselyConnected": { + "Explanation": "I cavi L (linea) e N (neutro) del contatore energetico sono collegati in modo inverso.", + "Causes": [ + "I cavi L e N sono stati invertiti durante l'installazione del contatore", + "Errore di installazione — comune quando la polarità del contatore non viene verificata" + ], + "NextSteps": [ + "Fare controllare e correggere il cablaggio del contatore da un elettricista qualificato", + "Invertire i collegamenti L e N al terminale del contatore per correggere la polarità" + ] + }, + "LinePeVoltageAbnormal": { + "Explanation": "Tensione anomala rilevata tra il filo neutro (N) e la terra di protezione (PE). Può indicare un guasto di messa a terra o di cablaggio.", + "Causes": [ + "Connessione PE (terra di protezione) mancante o difettosa", + "Fili N e PE cortocircuitati in qualche punto dell'installazione", + "Guasto di terra nel cablaggio dell'edificio" + ], + "NextSteps": [ + "Spegnere il sistema prima di ispezionare i cavi", + "Verificare che il cavo PE (terra) sia correttamente collegato all'inverter e al quadro elettrico", + "Controllare l'integrità del sistema di messa a terra — far verificare da un elettricista qualificato se necessario" + ] + }, + "PhaseSequenceError": { + "Explanation": "È stato rilevato un errore nella sequenza di fase nella connessione trifase. L'inverter tenterà di correggere automaticamente.", + "Causes": [ + "Fili trifase collegati nell'ordine sbagliato (L1, L2, L3 invertiti)" + ], + "NextSteps": [ + "Nessuna azione immediata necessaria — il PCS regolerà automaticamente la sequenza di fase nella maggior parte dei casi", + "Se l'allarme persiste, far verificare e correggere l'ordine di cablaggio delle fasi da un elettricista" + ] + }, + "FanFailure": { + "Explanation": "È stato rilevato un guasto della ventola di raffreddamento. Senza un adeguato raffreddamento, l'inverter si surriscalderà e si spegnerà.", + "Causes": [ + "Guasto del motore della ventola — la ventola non gira più", + "Pale della ventola bloccate da detriti o oggetti estranei", + "Connettore di alimentazione della ventola allentato o scollegato", + "Guasto nel circuito di controllo della ventola" + ], + "NextSteps": [ + "Spegnere l'inverter prima di ispezionare la ventola", + "Verificare che la ventola giri liberamente e non sia ostruita", + "Controllare che il connettore di alimentazione della ventola sia ben collegato", + "Sostituire la ventola se è guasta — non utilizzare l'inverter senza raffreddamento" + ] + }, + "MeterAbnormal": { + "Explanation": "Il contatore energetico sta segnalando letture anomale.", + "Causes": [ + "Malfunzionamento o guasto interno del contatore", + "Configurazione o taratura del contatore errata", + "Problema di comunicazione che causa errori nei dati" + ], + "NextSteps": [ + "Verificare che il contatore sia acceso e funzionante", + "Controllare che la configurazione del contatore corrisponda alle impostazioni dell'inverter (rapporto CT, protocollo di comunicazione)" + ] + }, + "OptimizerCommunicationAbnormal": { + "Explanation": "La comunicazione con un ottimizzatore a livello di modulo PV è fallita.", + "Causes": [ + "L'ottimizzatore è spento o non riceve energia PV", + "Interferenza di comunicazione sulla linea elettrica", + "Guasto hardware dell'ottimizzatore" + ], + "NextSteps": [ + "Verificare che l'ottimizzatore riceva tensione PV e sia acceso", + "Controllare i cavi di comunicazione tra inverter e ottimizzatori", + "Sostituire l'ottimizzatore se risulta difettoso" + ] + }, + "OverTemperature": { + "Explanation": "La temperatura dell'inverter ha superato il limite operativo normale. La potenza in uscita potrebbe essere ridotta per proteggere l'hardware.", + "Causes": [ + "Scarsa ventilazione — aria calda intrappolata intorno all'inverter", + "Temperatura ambiente elevata nell'area di installazione", + "Guasto del ventilatore di raffreddamento che riduce il flusso d'aria", + "Carico eccessivo che fa surriscaldare l'inverter" + ], + "NextSteps": [ + "Riavviare l'inverter dopo che si è raffreddato", + "Migliorare la ventilazione — assicurarsi che ci sia spazio sufficiente intorno all'inverter su tutti i lati", + "Verificare che il ventilatore di raffreddamento funzioni correttamente", + "Contattare il produttore se l'allarme persiste nonostante una buona ventilazione" + ] + }, + "OverTemperatureAlarm": { + "Explanation": "L'inverter ha rilevato un allarme di temperatura elevata — si tratta di un avviso preliminare prima del blocco termico.", + "Causes": [ + "Temperatura ambiente elevata nello spazio di installazione", + "Scarsa ventilazione o ostacoli alla circolazione d'aria intorno all'inverter", + "Carico elevato durante condizioni meteorologiche calde", + "Ventola che funziona a velocità ridotta o in modo intermittente" + ], + "NextSteps": [ + "Migliorare immediatamente la ventilazione intorno all'inverter", + "Ridurre temporaneamente il carico per permettere all'inverter di raffreddarsi", + "Verificare il funzionamento della ventola e liberare eventuali prese d'aria ostruite", + "Monitorare la temperatura fino a quando non scende sotto la soglia di allarme" + ] + }, + "NtcTemperatureSensorBroken": { + "Explanation": "Il sensore di temperatura NTC all'interno dell'inverter è guasto o scollegato.", + "Causes": [ + "Elemento del sensore NTC guasto a causa di invecchiamento o danni meccanici", + "Cavo del sensore danneggiato o scollegato dalla scheda", + "Connettore del sensore si è allentato dalla scheda di circuito stampato" + ], + "NextSteps": [ + "Riavviare l'inverter — se il sensore è effettivamente guasto, l'allarme persisterà dopo il riavvio", + "Se l'allarme persiste, un tecnico dovrà ispezionare e sostituire il sensore NTC all'interno dell'inverter" + ] + }, + "SyncSignalAbnormal": { + "Explanation": "Il segnale di sincronizzazione tra gli inverter collegati in parallelo è anomalo.", + "Causes": [ + "Cavo di sincronizzazione tra gli inverter in parallelo danneggiato o scollegato", + "Guasto all'interfaccia di comunicazione di sincronizzazione su un'unità", + "Configurazione non corrispondente tra le unità" + ], + "NextSteps": [ + "Verificare i collegamenti del cavo di sincronizzazione tra tutte le unità inverter in parallelo", + "Verificare che le impostazioni di comunicazione in parallelo corrispondano su tutte le unità", + "Sostituire il cavo se danneggiato" + ] + }, + "GridStartupConditionsNotMet": { + "Explanation": "Le condizioni di avvio per la connessione alla rete non sono state soddisfatte. L'inverter attende che la rete raggiunga i parametri richiesti prima di connettersi.", + "Causes": [ + "Tensione o frequenza della rete fuori dai limiti consentiti per la connessione", + "Soglia di tensione di avvio della rete configurata in modo errato" + ], + "NextSteps": [ + "Verificare che la tensione della rete sia entro il range operativo consentito dall'inverter", + "Rivedere le impostazioni di configurazione della tensione e frequenza di connessione alla rete" + ] + }, + "BatteryCommunicationFailure": { + "Explanation": "L'inverter non riesce a comunicare con il BMS della batteria (sistema di gestione batteria). Senza comunicazione con il BMS, la carica e la scarica non possono essere gestite in sicurezza.", + "Causes": [ + "BMS della batteria offline o spento", + "Cavo di comunicazione RS485 o CAN tra inverter e batteria difettoso o scollegato", + "Protocollo di comunicazione non compatibile tra inverter e batteria", + "Batteria in modalità sleep — BMS è entrato in stato di basso consumo" + ], + "NextSteps": [ + "Verificare che il sistema della batteria sia acceso e non in modalità sleep", + "Controllare il cavo di comunicazione RS485 tra inverter e batteria — ispezionare eventuali danni", + "Verificare che l'impostazione del protocollo di comunicazione della batteria nell'inverter corrisponda al BMS della batteria", + "Risvegliare la batteria se è in modalità sleep premendo il pulsante di alimentazione della batteria" + ] + }, + "BatteryDisconnected": { + "Explanation": "La batteria non è collegata all'inverter. Il sistema funziona senza accumulo di energia.", + "Causes": [ + "Interruttore o isolatore del circuito della batteria è spento", + "Cavo della batteria si è allentato o è stato scollegato", + "BMS ha disattivato la batteria a causa di un evento di protezione", + "Guasto hardware della batteria che impedisce la connessione" + ], + "NextSteps": [ + "Verificare che l'interruttore del circuito della batteria sia in posizione ON", + "Controllare i collegamenti dei cavi della batteria sia sull'inverter che sui terminali della batteria", + "Controllare gli indicatori di stato del BMS per eventuali codici di guasto o protezione", + "Risolvere eventuali eventi di protezione del BMS prima di riconnettere la batteria" + ] + }, + "BatteryVoltageTooHigh": { + "Explanation": "La tensione della batteria è superiore al livello massimo consentito. La carica potrebbe aver causato un superamento dei limiti di sicurezza.", + "Causes": [ + "La batteria è stata sovraccaricata oltre la tensione massima", + "Guasto al BMS che ha permesso alla tensione di salire troppo senza protezione", + "Sbilanciamento delle celle che causa il sovraccarico di celle singole", + "Impostazione errata della tensione di carica massima nell'inverter" + ], + "NextSteps": [ + "Controlla la tensione della batteria e confrontala con la specifica massima del produttore", + "Verifica le impostazioni della tensione di carica nell'inverter", + "Controlla il funzionamento del BMS — il BMS avrebbe dovuto proteggere dal sovraccarico" + ] + }, + "BatteryVoltageTooLow": { + "Explanation": "La tensione della batteria è inferiore al livello minimo consentito. La batteria è completamente scarica.", + "Causes": [ + "La batteria è stata scaricata oltre la tensione minima sicura", + "Guasto di una cella della batteria che riduce la tensione complessiva", + "Carico elevato che scarica la batteria più velocemente di quanto possa essere ricaricata", + "Il BMS ha attivato il taglio a bassa tensione" + ], + "NextSteps": [ + "Controlla la tensione della batteria e confrontala con la specifica minima del produttore", + "Lascia ricaricare la batteria — prima utilizzando l'energia di rete se il solare è insufficiente", + "Se la tensione è estremamente bassa, la batteria potrebbe aver bisogno di una ricarica professionale" + ] + }, + "BatteryReverseConnected": { + "Explanation": "La batteria è collegata con polarità invertita. Questo è pericoloso e può causare danni immediati.", + "Causes": [ + "I terminali positivo e negativo della batteria sono collegati ai terminali sbagliati dell'inverter durante l'installazione", + "Errore di installazione — un grave errore di cablaggio" + ], + "NextSteps": [ + "SPEGNI IMMEDIATAMENTE l'intero sistema — non caricare o scaricare", + "Controlla tutti i collegamenti dei cavi della batteria prima di toccare qualsiasi cosa", + "Fai verificare e correggere la polarità della batteria da un elettricista qualificato", + "Ispeziona eventuali danni ai cavi, ai fusibili o all'inverter prima di riavviare" + ] + }, + "LeadAcidTempSensorDisconnected": { + "Explanation": "Il sensore di temperatura della batteria al piombo-acido è disconnesso o non installato.", + "Causes": [ + "Il sensore di temperatura non è stato installato con la batteria", + "Il cavo del sensore si è allentato o è stato danneggiato", + "Il connettore del sensore è stato staccato dalla batteria o dall'inverter" + ], + "NextSteps": [ + "Verificare se un sensore di temperatura è installato sulla batteria al piombo-acido — di solito è una piccola sonda agganciata alla batteria", + "Controllare i collegamenti del cavo del sensore a entrambe le estremità", + "Installare o riconnettere il sensore come indicato nelle istruzioni di installazione" + ] + }, + "BatteryTemperatureOutOfRange": { + "Explanation": "La temperatura della batteria è al di fuori dell'intervallo sicuro per la carica o la scarica.", + "Causes": [ + "Temperatura ambiente elevata nell'area di installazione della batteria", + "Scarsa ventilazione della batteria che causa accumulo di calore", + "Surriscaldamento della batteria durante la carica o scarica intensa", + "Temperatura ambiente molto bassa in inverno che riduce le prestazioni della batteria" + ], + "NextSteps": [ + "Controllare la temperatura ambiente nell'area di installazione della batteria", + "Migliorare la ventilazione della batteria o spostarla in un luogo più fresco se si surriscalda", + "In climi freddi, assicurarsi che la batteria non sia esposta a temperature sotto lo zero — di solito la carica non è consentita sotto 0°C" + ] + }, + "BmsFault": { + "Explanation": "Il BMS della batteria ha segnalato un guasto che impedisce la carica e la scarica normali.", + "Causes": [ + "Guasto interno del BMS o evento di protezione attivato dalla batteria", + "La protezione di una singola cella si è attivata a causa di sovratensione, sottotensione o temperatura", + "Errore di comunicazione del BMS che causa la segnalazione del guasto" + ], + "NextSteps": [ + "Controllare il display o le luci di segnalazione del sistema batteria per un codice di errore specifico del BMS", + "Consultare la documentazione del produttore della batteria per il codice di guasto specifico del BMS", + "Contattare l'assistenza della batteria se il guasto del BMS non può essere risolto con un riavvio" + ] + }, + "LithiumBatteryOverload": { + "Explanation": "La protezione da sovraccarico della batteria al litio è attiva — il carico sta prelevando più energia di quanto la batteria possa erogare.", + "Causes": [ + "La potenza totale del carico supera la potenza massima di scarica della batteria", + "Corrente di avviamento elevata da motori o compressori che superano temporaneamente i limiti della batteria" + ], + "NextSteps": [ + "Verificare la potenza totale del carico e confrontarla con la potenza di scarica nominale della batteria", + "Ridurre il carico spegnendo elettrodomestici ad alto consumo", + "Distribuire l'avvio di grandi elettrodomestici per ridurre la domanda di picco" + ] + }, + "BmsCommunicationAbnormal": { + "Explanation": "La comunicazione con il BMS è anomala — i dati vengono ricevuti in modo intermittente o con errori.", + "Causes": [ + "Timeout di comunicazione dovuto a problemi di qualità o lunghezza del cavo", + "Errore di protocollo o disallineamento del baud rate", + "Guasto fisico del cavo che causa una connessione intermittente" + ], + "NextSteps": [ + "Riavviare l'inverter per tentare di ristabilire la comunicazione", + "Verificare il cavo di comunicazione del BMS per danni o connessioni allentate", + "Verificare le impostazioni di comunicazione (protocollo, baud rate) siano uguali tra inverter e BMS" + ] + }, + "BatterySpdAbnormal": { + "Explanation": "La funzione del dispositivo di protezione contro le sovratensioni (SPD) lato batteria è anomala.", + "Causes": [ + "L'SPD della batteria è scattato a causa di un evento di sovratensione", + "L'SPD è guasto o ha raggiunto la fine della sua vita utile", + "Sovratensione indotta da fulmine sul cablaggio della batteria" + ], + "NextSteps": [ + "Spegnere il sistema e ispezionare l'indicatore dell'SPD della batteria", + "Sostituire l'SPD se mostra uno stato di scatto o guasto", + "Riavviare il sistema dopo la sostituzione" + ] + }, + "OutputDcComponentBiasAbnormal": { + "Explanation": "Un componente DC di bias nell'uscita è anomalo, il che potrebbe influenzare l'attrezzatura collegata sensibile.", + "Causes": [ + "Deriva del loop di controllo che introduce un offset DC nell'uscita AC", + "Deriva della calibrazione del sensore nella misurazione dell'uscita", + "Guasto hardware nello stadio di uscita" + ], + "NextSteps": [ + "Riavviare l'inverter — i guasti di bias DC spesso si risolvono dopo il riavvio", + "Se il guasto persiste, contattare il produttore per l'assistenza" + ] + }, + "DcComponentOverHighOutputVoltage": { + "Explanation": "Il componente DC nella tensione di uscita è troppo alto. Questo può influenzare l'attrezzatura sensibile e indica un problema di controllo.", + "Causes": [ + "Deriva del loop di controllo che causa l'accumulo di offset DC nella tensione di uscita", + "Guasto del sensore di tensione di uscita", + "Saturazione del trasformatore o problema nel percorso DC" + ], + "NextSteps": [ + "Riavviare l'inverter per resettare i loop di controllo", + "Verificare la tensione di uscita per offset DC se l'attrezzatura è influenzata" + ] + }, + "OffGridOutputVoltageTooLow": { + "Explanation": "La tensione di uscita (EPS/backup) è troppo bassa per alimentare correttamente i carichi collegati.", + "Causes": [ + "Carico che supera la capacità di backup dell'inverter causando un calo di tensione", + "Tensione della batteria troppo bassa per mantenere una tensione di uscita stabile", + "Limitazione interna dell'inverter" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Ridurre il carico sull'uscita di backup", + "Permettere alla batteria di caricarsi se lo stato di carica è basso", + "Se il guasto persiste, contattare il produttore" + ] + }, + "OffGridOutputVoltageTooHigh": { + "Explanation": "La tensione in uscita del sistema off-grid è troppo alta, il che potrebbe danneggiare i dispositivi collegati.", + "Causes": [ + "Guasto di controllo che causa il fallimento della regolazione della tensione in uscita", + "Errore di riferimento di tensione nel sistema di controllo" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se il guasto persiste, contattare immediatamente il produttore poiché una tensione di uscita elevata può danneggiare gli elettrodomestici" + ] + }, + "OffGridOutputOverCurrent": { + "Explanation": "La corrente in uscita del sistema off-grid supera il limite di sovracorrente.", + "Causes": [ + "La corrente totale di carico supera la capacità di uscita di backup dell'inverter", + "Cortocircuito in uno dei carichi di backup", + "Corrente di avviamento di un grande motore" + ], + "NextSteps": [ + "Verificare che tutti i carichi sulla uscita di backup siano entro le specifiche di corrente dell'inverter", + "Disconnettere i carichi uno alla volta per identificare eventuali dispositivi difettosi", + "Riparare o rimuovere il carico che sovraccarica prima di riavviare" + ] + }, + "OffGridOutputOverload": { + "Explanation": "L'uscita off-grid (EPS/backup) è sovraccarica — viene richiesta più potenza di quella che l'inverter può fornire in modalità di backup.", + "Causes": [ + "Il carico totale sull'uscita EPS supera la capacità di backup dell'inverter", + "Troppi elettrodomestici collegati al circuito di backup contemporaneamente", + "Un motore o compressore grande causa un'elevata corrente di avviamento" + ], + "NextSteps": [ + "Verificare che tutti i carichi siano entro la specifica di uscita EPS dell'inverter", + "Ridurre il numero di elettrodomestici sul circuito di backup", + "Distribuire l'avvio di grandi elettrodomestici durante l'operazione di backup" + ] + }, + "BalancedCircuitAbnormal": { + "Explanation": "Il circuito di bilanciamento delle fasi funziona in modo anomalo.", + "Causes": [ + "Guasto interno al circuito di bilanciamento delle fasi", + "Problema di controllo che influisce sul funzionamento del bilanciamento delle fasi" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se il guasto persiste, verificare le impostazioni di bilanciamento delle fasi e contattare l'assistenza" + ] + }, + "ExportLimitationFailSafe": { + "Explanation": "La funzione di sicurezza del limite di esportazione è scattata. L'inverter ha interrotto l'alimentazione della rete perché non può verificare che i limiti di esportazione siano rispettati.", + "Causes": [ + "Il sensore CT (trasformatore di corrente) è scollegato o misura in modo errato", + "La comunicazione con il contatore è persa, impedendo il monitoraggio dell'esportazione", + "Il loop di feedback del limite di esportazione è fallito — l'inverter non può confermare che l'esportazione verso la rete è controllata" + ], + "NextSteps": [ + "Spegnere il sistema prima di ispezionare i collegamenti del CT o del contatore", + "Verificare che il sensore CT sia installato correttamente e collegato in modo sicuro", + "Verificare che il cavo di comunicazione del contatore energetico sia intatto", + "Confermare che le impostazioni del limite di esportazione e il feedback siano configurati correttamente, quindi riavviare" + ] + }, + "DcBiasAbnormal": { + "Explanation": "La protezione contro l'iniezione di corrente continua (DCI) ha rilevato un bias DC anomalo nell'uscita in corrente alternata — una protezione di sicurezza che impedisce l'iniezione di corrente continua nella rete.", + "Causes": [ + "Iniezione di corrente continua nella rete dall'uscita dell'inverter", + "Guasto del sensore di corrente di uscita che fornisce letture errate", + "Saturazione del trasformatore o problema di controllo" + ], + "NextSteps": [ + "Riavviare l'inverter — a volte questo elimina i guasti transitori DCI", + "Se il guasto persiste, l'inverter richiede un servizio professionale" + ] + }, + "HighDcComponentOutputCurrent": { + "Explanation": "Componente DC elevato rilevato nella corrente di uscita in corrente alternata. Si tratta di una condizione di protezione.", + "Causes": [ + "Problema del filtro di uscita che permette il passaggio del componente DC", + "Guasto di controllo che influisce sulla simmetria dell'onda di corrente", + "Saturazione del trasformatore di uscita" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Verificare la qualità dell'onda di corrente di uscita se è disponibile l'attrezzatura di misura", + "Se persistente, contattare il produttore per l'assistenza" + ] + }, + "BusVoltageSamplingAbnormal": { + "Explanation": "La misurazione della tensione del bus in corrente continua è anomala — il sensore fornisce letture errate.", + "Causes": [ + "Guasto del sensore di tensione o del circuito di misurazione", + "Errore dell'ADC (convertitore analogico-digitale) sulla scheda di controllo", + "Problema hardware che influisce sull'accuratezza della misurazione" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se persistente, il circuito di misurazione richiede un servizio professionale" + ] + }, + "RelayFault": { + "Explanation": "È stato rilevato un guasto interno al relè. Il relè non funziona come previsto.", + "Causes": [ + "Il relè è guasto — contatti bloccati aperti o chiusi", + "Saldatura dei contatti a causa di un sovraccarico", + "Guasto nel circuito di comando del relè" + ], + "NextSteps": [ + "Riavviare l'inverter per resettare il relè", + "Se il guasto persiste, il relè probabilmente deve essere sostituito — contattare l'assistenza" + ] + }, + "BusVoltageAbnormal": { + "Explanation": "La tensione interna del bus DC è anomala.", + "Causes": [ + "Guasto all'elettronica di potenza che influisce sulla regolazione del bus DC", + "Problema al condensatore nel bus DC", + "Guasto al sistema di controllo" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se il problema persiste, il sistema richiede un'ispezione professionale" + ] + }, + "InternalCommunicationFailure": { + "Explanation": "La comunicazione interna tra le schede di controllo all'interno dell'inverter è fallita.", + "Causes": [ + "Guasto o malfunzionamento della scheda di comunicazione", + "Il cavo a nastro o il connettore interno si è allentato", + "Interferenze elettromagnetiche (EMI) che influenzano la comunicazione interna" + ], + "NextSteps": [ + "Spegnere l'inverter, attendere 30 secondi, poi riavviarlo per vedere se la comunicazione si ripristina", + "Se il problema persiste, un tecnico dovrebbe aprire l'inverter e controllare i collegamenti dei cavi di comunicazione interni" + ] + }, + "TemperatureSensorDisconnected": { + "Explanation": "Un sensore di temperatura all'interno dell'inverter è scollegato, impedendo il corretto monitoraggio termico.", + "Causes": [ + "L'elemento del sensore ha smesso di funzionare o si è staccato dal supporto", + "Il cavo del sensore è danneggiato o scollegato", + "Il connettore del sensore si è staccato dalla scheda" + ], + "NextSteps": [ + "Spegnere l'inverter e controllare i cavi del sensore interno se accessibili", + "Se non accessibili, contattare un tecnico per ispezionare e sostituire il sensore" + ] + }, + "IgbtDriveFault": { + "Explanation": "È stato rilevato un guasto al driver del gate IGBT. L'IGBT non viene pilotato correttamente, il che può impedire la corretta conversione di potenza.", + "Causes": [ + "Guasto al circuito del driver di gate", + "Guasto al transistor IGBT — il dispositivo potrebbe essere guasto", + "Problema all'alimentazione del driver di gate" + ], + "NextSteps": [ + "Riavviare l'inverter — i guasti transitori al gate possono risolversi con il riavvio", + "Se persistente, è necessario un intervento professionale — sostituzione IGBT o driver" + ] + }, + "EepromError": { + "Explanation": "Si è verificato un errore di lettura o scrittura EEPROM. La memoria non volatile dell'inverter non funziona correttamente.", + "Causes": [ + "Il chip EEPROM è guasto — comune dopo molti anni di utilizzo", + "Corruzione dei dati nella memoria EEPROM", + "Guasto hardware nel circuito di memoria" + ], + "NextSteps": [ + "Riavviare l'inverter — questo potrebbe risolvere un errore di memoria transitorio", + "Se persistente, un ripristino di fabbrica potrebbe ripristinare la funzionalità; contattare l'assistenza prima di tentare" + ] + }, + "AuxiliaryPowerAbnormal": { + "Explanation": "L'alimentazione ausiliaria interna è anomala. Questa alimenta l'elettronica di controllo.", + "Causes": [ + "Guasto del componente dell'alimentazione ausiliaria interna", + "Guasto del regolatore di tensione sulla scheda di controllo" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se persiste, contattare l'assistenza — potrebbe essere necessario sostituire l'alimentazione ausiliaria" + ] + }, + "DcAcOvercurrentProtection": { + "Explanation": "È scattata la protezione da sovracorrente DC/AC — la corrente ha superato il limite sicuro.", + "Causes": [ + "Cortocircuito nel cablaggio di uscita AC o nei carichi collegati", + "Sovraccarico grave che supera di molto la capacità nominale", + "Guasto dell'elettronica di potenza che causa sovracorrente" + ], + "NextSteps": [ + "Riavviare l'inverter dopo aver controllato e rimosso eventuali cortocircuiti", + "Controllare tutti i carichi collegati per eventuali guasti", + "Ridurre il carico prima di riavviare" + ] + }, + "CommunicationProtocolMismatch": { + "Explanation": "È stato rilevato un'incompatibilità nel protocollo di comunicazione tra i componenti.", + "Causes": [ + "Versioni del firmware delle schede di controllo non corrispondenti", + "Errore di configurazione della comunicazione" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se persiste, eseguire un aggiornamento completo del firmware per assicurarsi che tutti i componenti abbiano versioni corrispondenti" + ] + }, + "DspComFirmwareMismatch": { + "Explanation": "Le versioni del firmware della scheda DSP (processore di segnale) e COM (comunicazione) non corrispondono.", + "Causes": [ + "Aggiornamento del firmware incompleto, lasciando le schede su versioni diverse", + "File del firmware sbagliato caricato su una delle schede" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Eseguire un aggiornamento completo del firmware — aggiornare tutte le schede alla versione corretta corrispondente" + ] + }, + "DspSoftwareHardwareMismatch": { + "Explanation": "La versione del software DSP non è compatibile con la versione dell'hardware.", + "Causes": [ + "La scheda hardware è stata sostituita con una revisione più recente o più vecchia che richiede una versione diversa del firmware" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Contattare l'assistenza tecnica per identificare la versione corretta del firmware per questa revisione hardware" + ] + }, + "CpldAbnormal": { + "Explanation": "Il CPLD (dispositivo logico programmabile complesso) all'interno dell'inverter funziona in modo anomalo.", + "Causes": [ + "Guasto del chip CPLD o corruzione del firmware", + "Problema di alimentazione che influisce sul funzionamento del CPLD" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se persistente, è necessario un intervento professionale — sostituzione o riprogrammazione del CPLD" + ] + }, + "RedundancySamplingInconsistent": { + "Explanation": "I circuiti di campionamento ridondanti della tensione o della corrente forniscono risultati incoerenti — i due percorsi di misurazione non concordano.", + "Causes": [ + "Uno dei sensori ridondanti si è spostato o è guasto", + "Errore di calibrazione ADC su un canale di misurazione", + "Guasto hardware in uno dei circuiti di misurazione" + ], + "NextSteps": [ + "Riavviare l'inverter per resettare i circuiti di misurazione", + "Se persistente, potrebbe essere necessaria la ricalibrazione o la sostituzione del sensore — contattare l'assistenza" + ] + }, + "PwmPassThroughSignalFailure": { + "Explanation": "Il percorso del segnale di passaggio PWM (modulazione di larghezza d'impulso) è guasto.", + "Causes": [ + "Guasto alla scheda di controllo che influisce sul routing del segnale PWM", + "Problema hardware nel percorso del segnale" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se persistente, contattare l'assistenza — è necessaria un'ispezione interna della scheda" + ] + }, + "AfciSelfTestFailure": { + "Explanation": "L'autotest dell'AFCI (interruttore di circuito per archi elettrici) è fallito. L'AFCI protegge contro pericolosi archi elettrici nei cavi fotovoltaici.", + "Causes": [ + "Guasto al modulo di rilevamento AFCI che impedisce il completamento dell'autotest", + "Problema nel circuito di autotest sulla scheda di controllo" + ], + "NextSteps": [ + "Riavviare l'inverter per tentare un altro autotest", + "Se l'autotest continua a fallire, potrebbe essere necessario sostituire il modulo AFCI — contattare l'assistenza" + ] + }, + "PvCurrentSamplingAbnormal": { + "Explanation": "La misurazione della corrente PV sta dando letture anomale.", + "Causes": [ + "Guasto del sensore di corrente PV o del sensore a effetto Hall", + "Errore ADC sul canale di misurazione della corrente" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se persistente, il circuito del sensore di corrente richiede un servizio professionale" + ] + }, + "AcCurrentSamplingAbnormal": { + "Explanation": "La misurazione della corrente AC sta dando letture anomale.", + "Causes": [ + "Guasto o collegamento errato del sensore CT (trasformatore di corrente)", + "Guasto del sensore di corrente AC", + "Errore ADC sul canale di misurazione AC" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Controllare i collegamenti e l'orientamento del CT se accessibili", + "Se persistente, il circuito di misurazione richiede un servizio professionale" + ] + }, + "BusSoftbootFailure": { + "Explanation": "Il bus DC non è riuscito ad avviarsi correttamente durante la fase di pre-carica.", + "Causes": [ + "Guasto del circuito di pre-carica che impedisce la carica controllata del condensatore", + "Problema con il condensatore del bus DC", + "Guasto del relè o del contattore di pre-carica" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se persistente, il circuito di pre-carica richiede un servizio professionale" + ] + }, + "EpoFault": { + "Explanation": "È stato attivato un guasto EPO (Emergency Power Off).", + "Causes": [ + "È stato premuto il pulsante di arresto di emergenza EPO", + "Il circuito EPO è stato attivato da un sistema di sicurezza esterno", + "Il circuito EPO ha causato uno spegnimento involontario" + ], + "NextSteps": [ + "Verificare se è stato premuto il pulsante EPO — riavviarlo se necessario", + "Controllare il cablaggio del circuito EPO se l'attivazione è stata involontaria", + "Riavviare l'inverter dopo aver confermato che il circuito EPO è libero" + ] + }, + "MonitoringChipBootVerificationFailed": { + "Explanation": "Il chip di monitoraggio non è riuscito a superare la verifica di avvio — il firmware o la sequenza di avvio del chip presenta un problema.", + "Causes": [ + "Corruzione del firmware sul chip di monitoraggio", + "Guasto hardware del chip di monitoraggio" + ], + "NextSteps": [ + "Riavviare l'inverter — i fallimenti di verifica di avvio a volte si risolvono al riavvio", + "Se persistente, potrebbe essere necessario ricaricare il firmware o sostituire il chip — contattare l'assistenza" + ] + }, + "BmsCommunicationFailure": { + "Explanation": "Il BMS non riesce a comunicare con l'inverter. Senza la comunicazione BMS, la carica e la scarica non possono essere gestite in sicurezza.", + "Causes": [ + "Il cavo di comunicazione RS485 tra inverter e batteria è difettoso o scollegato", + "Il BMS è spento o non risponde", + "Incompatibilità del protocollo di comunicazione tra inverter e BMS" + ], + "NextSteps": [ + "Controllare il collegamento del cavo RS485 tra inverter e batteria — ispezionare entrambe le estremità", + "Verificare che la batteria sia accesa e che il BMS sia attivo", + "Controllare che l'impostazione del protocollo di comunicazione corrisponda al BMS della batteria" + ] + }, + "BmsChargeDischargeFailure": { + "Explanation": "Il BMS ha segnalato che la batteria non può caricarsi o scaricarsi.", + "Causes": [ + "Protezione interna del BMS attivata — sovratensione, sottotensione o guasto di temperatura", + "Guasto hardware del BMS che blocca la carica/scarica", + "Problema rilevato nelle celle della batteria" + ], + "NextSteps": [ + "Controlla il display della batteria o l'indicatore del BMS per un codice di errore specifico", + "Consulta la documentazione del produttore della batteria per il codice di guasto del BMS", + "Contatta l'assistenza della batteria se il guasto non può essere risolto" + ] + }, + "BatteryVoltageLow": { + "Explanation": "La tensione della batteria è al di sotto del livello minimo consentito.", + "Causes": [ + "La batteria è stata scaricata troppo al di sotto della tensione minima sicura", + "Guasto di una cella che riduce la tensione complessiva del pacco" + ], + "NextSteps": [ + "Controlla la tensione della batteria — se è critica, potrebbe essere necessaria una ricarica professionale", + "Lascia ricaricare lentamente la batteria dalla rete prima di riprendere il funzionamento normale" + ] + }, + "BatteryVoltageHigh": { + "Explanation": "La tensione della batteria supera il limite massimo consentito.", + "Causes": [ + "La batteria è stata sovraccaricata oltre la tensione massima", + "Guasto del BMS che permette alla tensione di aumentare senza protezione", + "Guasto di una cella che crea alta tensione in parte del pacco" + ], + "NextSteps": [ + "Controlla la tensione della batteria e confrontala con la specifica massima del produttore", + "Se la tensione è entro il range consentito, riavvia l'inverter", + "Se la tensione è effettivamente troppo alta, smetti di caricare immediatamente e contatta l'assistenza della batteria" + ] + }, + "BatteryTemperatureAbnormal": { + "Explanation": "La temperatura della batteria è fuori dalla fascia di sicurezza per la carica o la scarica.", + "Causes": [ + "La batteria è troppo calda — scarsa ventilazione o temperatura ambiente elevata", + "La batteria è troppo fredda — ambiente gelido o vicino allo zero", + "Il sensore di temperatura della batteria è guasto e fornisce letture errate" + ], + "NextSteps": [ + "Controlla la temperatura fisica della batteria, se è sicuro farlo", + "Migliora la ventilazione della batteria in caso di surriscaldamento", + "In condizioni fredde, lascia che la batteria si riscaldi prima di caricarla", + "Controlla i collegamenti del sensore se la lettura della temperatura sembra errata" + ] + }, + "BatteryReversed": { + "Explanation": "La polarità della batteria è invertita — i terminali positivo e negativo sono collegati in modo errato.", + "Causes": [ + "I cavi positivo e negativo della batteria sono collegati ai terminali sbagliati dell'inverter", + "Errore di installazione" + ], + "NextSteps": [ + "SPEGNI IMMEDIATAMENTE l'intero sistema — la polarità invertita può causare gravi danni", + "Fai verificare e correggere la polarità della batteria da un elettricista qualificato prima di qualsiasi ulteriore operazione" + ] + }, + "BatteryOpenCircuit": { + "Explanation": "Il circuito della batteria è aperto — la batteria non è elettricamente collegata.", + "Causes": [ + "Il cavo della batteria si è allentato o scollegato dal terminale", + "L'interruttore automatico della batteria è saltato interrompendo il circuito", + "Il BMS ha aperto il contatto interno a causa di un evento di protezione" + ], + "NextSteps": [ + "Controlla tutti i collegamenti dei cavi della batteria sia ai terminali dell'inverter che della batteria", + "Ispeziona l'interruttore automatico della batteria e sostituiscilo se è saltato", + "Controlla lo stato del BMS per eventuali eventi di protezione che potrebbero aver aperto il contatto della batteria" + ] + }, + "BatteryOverloadProtection": { + "Explanation": "La protezione da sovraccarico della batteria è scattata — il carico sta prelevando più energia di quanta la batteria possa erogare in sicurezza.", + "Causes": [ + "La potenza totale del carico supera la potenza massima di scarica nominale della batteria", + "Corrente di avviamento elevata da grandi elettrodomestici che supera temporaneamente la capacità della batteria" + ], + "NextSteps": [ + "Controllare il carico totale e confrontarlo con la potenza di scarica nominale della batteria", + "Ridurre i carichi ad alta potenza e riavviare l'inverter" + ] + }, + "Bus2VoltageAbnormal": { + "Explanation": "La tensione del bus DC secondario è anomala.", + "Causes": [ + "Guasto all'elettronica di potenza che influisce sul bus DC secondario", + "Problema di controllo sul convertitore secondario" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se il problema persiste, è necessaria un'ispezione professionale" + ] + }, + "BatteryChargeOcp": { + "Explanation": "La protezione da sovraccarico di carica (OCP) della batteria è scattata — la corrente di carica è troppo elevata.", + "Causes": [ + "L'impianto fotovoltaico è sovradimensionato e fornisce più corrente di quanta la batteria possa accettare in sicurezza", + "Impostazione del limite di corrente di carica troppo elevata rispetto alle specifiche della batteria" + ], + "NextSteps": [ + "Verificare se la potenza dell'impianto fotovoltaico supera significativamente la capacità di carica della batteria", + "Ridurre l'impostazione della corrente di carica massima nell'inverter per adattarla alle specifiche della batteria" + ] + }, + "BatteryDischargeOcp": { + "Explanation": "La protezione da sovraccarico (OCP) durante la scarica della batteria è stata attivata — la corrente di scarica è troppo alta.", + "Causes": [ + "Il carico collegato sta assorbendo più corrente rispetto alla massima capacità di scarica della batteria", + "Il limite di corrente di scarica della batteria è impostato troppo alto" + ], + "NextSteps": [ + "Verificare che la configurazione della corrente di scarica della batteria corrisponda alle specifiche della batteria", + "Ridurre il carico collegato entro i limiti di scarica della batteria" + ] + }, + "BatterySoftStartFailed": { + "Explanation": "La batteria non è riuscita a completare la sequenza di avvio graduale quando si è collegata all'inverter.", + "Causes": [ + "Guasto nel circuito di pre-carica che impedisce il collegamento controllato della batteria", + "La tensione della batteria è significativamente diversa dalla tensione del bus DC dell'inverter" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Controllare la tensione della batteria rispetto alla tensione del bus DC — una grande differenza può impedire l'avvio graduale" + ] + }, + "EpsOutputShortCircuited": { + "Explanation": "L'uscita di backup (EPS) ha un cortocircuito.", + "Causes": [ + "Cortocircuito nel cablaggio del carico collegato all'uscita di backup", + "Un elettrodomestico difettoso che causa un cortocircuito nel circuito di backup", + "Guasto nel cablaggio della distribuzione dell'uscita EPS" + ], + "NextSteps": [ + "Scollegare tutti i carichi dall'uscita di backup", + "Identificare e riparare il cortocircuito nel cablaggio o negli elettrodomestici prima di riconnettere" + ] + }, + "OffGridBusVoltageLow": { + "Explanation": "La tensione del bus DC fuori rete è troppo bassa per mantenere l'operazione di backup.", + "Causes": [ + "La batteria è quasi scarica e non può mantenere la tensione del bus DC", + "Carico di backup elevato combinato con bassa carica della batteria", + "Perdita di capacità della batteria dovuta all'invecchiamento" + ], + "NextSteps": [ + "Verificare se la batteria funziona correttamente e non ha perso capacità significativa", + "Consentire alla batteria di caricarsi prima di tentare l'operazione di backup", + "Ridurre il carico di backup per estendere la durata della batteria" + ] + }, + "OffGridTerminalVoltageAbnormal": { + "Explanation": "È stata rilevata una tensione anomala al terminale di uscita AC fuori rete.", + "Causes": [ + "Tensione esterna presente all'uscita AC di backup da un'altra fonte", + "Guasto di cablaggio che collega l'uscita di backup a un circuito alimentato", + "Ritorno di corrente da un carico che ha una propria fonte di alimentazione" + ], + "NextSteps": [ + "Verificare se è presente una fonte di tensione esterna al porto di uscita di backup AC", + "Verificare che il cablaggio di uscita di backup non si colleghi a nessuna altra fonte alimentata", + "Scollegare tutti i carichi dall'uscita di backup e ispezionare il cablaggio prima di riavviare" + ] + }, + "SoftStartFailed": { + "Explanation": "La sequenza di avvio morbido in modalità fuori rete è fallita.", + "Causes": [ + "Fallimento della pre-carica durante l'avvio fuori rete", + "Carico troppo elevato al momento dell'avvio fuori rete" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Ridurre il carico iniziale sul circuito di backup durante l'avvio" + ] + }, + "OffGridOutputVoltageAbnormal": { + "Explanation": "La tensione di uscita off-grid è anomala.", + "Causes": [ + "Guasto di controllo che impedisce la regolazione della tensione off-grid", + "Problema hardware nello stadio di uscita", + "Sovraccarico grave che abbassa la tensione di uscita" + ], + "NextSteps": [ + "Riavviare l'inverter", + "Se il guasto persiste, contattare il produttore" + ] + }, + "BalancedCircuitSelfTestFailed": { + "Explanation": "L'autotest del circuito bilanciato è fallito durante l'avvio.", + "Causes": [ + "Guasto rilevato nel circuito di bilanciamento durante l'autotest", + "Problema hardware nel circuito di bilanciamento" + ], + "NextSteps": [ + "Riavviare l'inverter per ripetere l'autotest", + "Se il guasto persiste, contattare l'assistenza" + ] + }, + "HighDcComponentOutputVoltage": { + "Explanation": "È stato rilevato un componente DC elevato nella tensione di uscita AC.", + "Causes": [ + "Deriva del loop di controllo che causa un offset DC nell'uscita", + "Problema nel trasformatore o filtro di uscita" + ], + "NextSteps": [ + "Riavviare l'inverter per resettare i loop di controllo", + "Se il guasto persiste, contattare il produttore" + ] + }, + "OffGridParallelSignalAbnormal": { + "Explanation": "Il segnale di comunicazione parallela tra gli inverter in modalità off-grid è anomalo.", + "Causes": [ + "Il cavo di comunicazione parallela tra le unità è danneggiato o scollegato", + "Configurazione parallela non corrispondente tra le unità" + ], + "NextSteps": [ + "Verificare che tutti i cavi di comunicazione parallela siano correttamente e saldamente collegati tra gli inverter", + "Controllare che le impostazioni parallele siano uguali su tutte le unità" + ] + }, + "AFCIFault": { + "Explanation": "È stato rilevato un guasto ad arco nel sistema fotovoltaico. Gli archi elettrici possono causare incendi nei cavi fotovoltaici e il sistema si è spento per precauzione.", + "Causes": [ + "Connettore MC4 o cavo fotovoltaico allentato che causa archi intermittenti", + "Isolamento del cavo danneggiato che permette archi nel punto danneggiato", + "Connettore o scatola di giunzione difettosa che crea un percorso di arco", + "Danneggiamento della scatola di giunzione del modulo" + ], + "NextSteps": [ + "Spegnere tutti i dispositivi di interruzione DC prima di ispezionare i cavi fotovoltaici", + "Ispezionare attentamente tutte le connessioni delle stringhe fotovoltaiche, i connettori MC4 e i cavi per danni", + "Stringere eventuali connettori allentati e sostituire cavi o connettori danneggiati", + "Farsi ispezionare professionalmente l'installazione se la fonte dell'arco non viene trovata" + ] + }, + "GFCIHigh": { + "Explanation": "È stata rilevata una corrente di guasto a terra (dispersione) eccessivamente alta nel sistema fotovoltaico.", + "Causes": [ + "Guasto a terra nell'impianto fotovoltaico — tipicamente un cavo che tocca il telaio o le parti metalliche", + "Deterioramento dell'isolamento sui cavi fotovoltaici o nelle scatole di giunzione dei moduli", + "Ingresso di umidità nelle connessioni dei cavi o nelle scatole di giunzione dei moduli", + "Danneggiamento del cavo che espone i conduttori a terra" + ], + "NextSteps": [ + "Riavviare l'inverter per vedere se il guasto si risolve", + "Se persiste, eseguire un test di resistenza di isolamento su tutte le stringhe fotovoltaiche per trovare la posizione del guasto", + "Riparare eventuali danni all'isolamento o guasti a terra prima di riavviare" + ] + }, + "PVVoltageHigh": { + "Explanation": "La tensione di ingresso DC dal pannello fotovoltaico supera il limite massimo di sicurezza assoluto. Questo rappresenta un rischio immediato di danni all'inverter.", + "Causes": [ + "Troppi moduli PV in serie che superano la tensione massima di ingresso dell'inverter", + "Temperatura molto bassa che fa aumentare significativamente la Voc dei moduli rispetto alla Voc di progettazione" + ], + "NextSteps": [ + "Disconnettere immediatamente l'interruttore DC per proteggere l'inverter", + "Misurare la tensione DC effettiva prima di riconnettere", + "Rivedere il progetto della stringa e ridurre il numero di moduli in serie se necessario per rispettare i limiti di tensione dell'inverter" + ] + }, + "OffGridBusVoltageTooLow": { + "Explanation": "La tensione del bus DC in modalità off-grid è scesa troppo per mantenere un funzionamento stabile.", + "Causes": [ + "Livello di carica della batteria troppo basso", + "Carico eccessivo sull'uscita off-grid", + "Connessione difettosa o allentata nel cablaggio del bus DC" + ], + "NextSteps": [ + "Ridurre il carico sull'uscita off-grid", + "Verificare il livello di carica della batteria e ricaricarla se necessario", + "Controllare il cablaggio del bus DC per connessioni allentate o danni" + ] + } +} \ No newline at end of file diff --git a/csharp/App/Backend/Services/AlarmKnowledgeBase.cs b/csharp/App/Backend/Services/AlarmKnowledgeBase.cs new file mode 100644 index 000000000..e5b98f231 --- /dev/null +++ b/csharp/App/Backend/Services/AlarmKnowledgeBase.cs @@ -0,0 +1,1512 @@ +namespace InnovEnergy.App.Backend.Services; + +/// +/// Static knowledge base for Sinexcel and Growatt alarms. +/// Provides pre-defined diagnostics without requiring Mistral API calls. +/// Data sourced from vendor alarm documentation. +/// +public static class AlarmKnowledgeBase +{ + /// + /// Tries to find a pre-defined diagnostic for the given alarm description. + /// Returns null if the alarm is not in the knowledge base. + /// + public static DiagnosticResponse? TryGetDiagnosis(string alarmDescription) + { + if (string.IsNullOrWhiteSpace(alarmDescription)) + return null; + + // Normalize the description for lookup + var normalized = alarmDescription.Trim(); + + // Try exact match first + if (SinexcelAlarms.TryGetValue(normalized, out var sinexcelDiag)) + return sinexcelDiag; + + if (GrowattAlarms.TryGetValue(normalized, out var growattDiag)) + return growattDiag; + + // Try case-insensitive match for both Sinexcel and Growatt + var lowerDesc = normalized.ToLowerInvariant(); + foreach (var kvp in SinexcelAlarms) + { + if (kvp.Key.ToLowerInvariant() == lowerDesc) + return kvp.Value; + } + + foreach (var kvp in GrowattAlarms) + { + if (kvp.Key.ToLowerInvariant() == lowerDesc) + return kvp.Value; + } + + return null; + } + + // ── Sinexcel Alarms ────────────────────────────────────────────────────── + // Register addresses: 0x1048 - 0x10D5 + // Recovery types: AUTO (wait), MANUAL (fix and restart), SERVICE (contact service) + + private static readonly IReadOnlyDictionary SinexcelAlarms = new Dictionary + { + // Grid-related alarms + ["AbnormalGridVoltage"] = new() + { + Explanation = "The inverter has detected that the grid voltage is outside the acceptable operating range. The system requires manual intervention to recover.", + Causes = new[] { "Utility grid voltage fluctuation or instability", "Poor or loose grid connection at the inverter terminals", "Local transformer issues", "High load demand on the local grid" }, + NextSteps = new[] { "Check the grid voltage with a multimeter at the inverter terminals", "Verify all grid connection wiring is tight and undamaged", "Contact your utility provider if the grid voltage is persistently abnormal", "Restart the inverter after the issue is resolved" } + }, + ["AbnormalGridFrequency"] = new() + { + Explanation = "The inverter has detected that the grid frequency is outside the acceptable range (typically 50 Hz or 60 Hz ± tolerance). The system will not operate until the frequency returns to normal.", + Causes = new[] { "Grid instability or disturbance from the utility", "Generator frequency drift if running on a generator", "Rapid load changes on the local grid" }, + NextSteps = new[] { "Check whether the grid frequency is stable", "If operating with a generator, verify the generator's frequency setting matches the inverter specification", "Wait for the grid to stabilise, then restart the inverter" } + }, + ["InvertedSequenceOfGridVoltage"] = new() + { + Explanation = "The phase sequence of the three-phase grid voltage is reversed. This is a wiring issue that prevents safe operation.", + Causes = new[] { "Incorrect wiring of grid phases during installation (L1, L2, L3 swapped)", "Rewiring work carried out without checking phase order" }, + NextSteps = new[] { "Power off the entire system safely before touching any wiring", "Swap any two of the three phase wires at the grid connection to correct the sequence", "Power the system back on and verify the alarm clears" } + }, + ["GridVoltagePhaseLoss"] = new() + { + Explanation = "One or more phases of the three-phase grid connection are missing. The inverter cannot operate safely on an incomplete three-phase supply.", + Causes = new[] { "Blown fuse on one of the grid phases", "Loose or disconnected phase wire at the inverter terminals or distribution board", "Grid-side circuit breaker tripped on one phase", "Cable damage interrupting one phase" }, + NextSteps = new[] { "Check all three phase connections at the inverter input terminals", "Verify fuses and circuit breakers for each phase", "Inspect cables for visible damage or loose connections", "Restore the missing phase and restart after repair" } + }, + ["AbnormalGridCurrent"] = new() + { + Explanation = "The grid current is abnormal, which may indicate overcurrent or current imbalance between phases.", + Causes = new[] { "Grid-side short circuit or wiring fault", "System load exceeding capacity", "Faulty current sensor giving wrong readings", "Ground fault causing current leakage" }, + NextSteps = new[] { "Check for short circuits in the wiring and load side", "Reduce system load and see if the alarm clears", "Verify current sensor connections and operation", "Repair the underlying fault, then restart the inverter" } + }, + + // Output-related alarms + ["AbnormalOutputVoltage"] = new() + { + Explanation = "The inverter's output voltage is outside acceptable limits. This can affect connected loads and indicates a fault condition.", + Causes = new[] { "Internal inverter control fault", "Overload condition on the output", "Grid voltage influence affecting output regulation" }, + NextSteps = new[] { "Check all connected loads and disconnect any that may be causing overload", "Verify inverter output voltage settings match your installation requirements", "Power cycle the inverter; if the alarm returns, contact a service technician" } + }, + ["AbnormalOutputFrequency"] = new() + { + Explanation = "The inverter's output frequency is abnormal, which may affect sensitive equipment.", + Causes = new[] { "Internal control system fault affecting frequency regulation", "Heavy or sudden load transients causing frequency deviation" }, + NextSteps = new[] { "Reduce connected load and check if the frequency stabilises", "Power cycle the inverter; if persistent, contact service" } + }, + ["AbnormalNullLine"] = new() + { + Explanation = "The neutral (null) line connection is abnormal. A missing or damaged neutral can cause voltage imbalance and dangerous conditions.", + Causes = new[] { "Loose or disconnected neutral wire at the inverter or distribution board", "Neutral wire damaged or broken", "Incorrect wiring during installation" }, + NextSteps = new[] { "Power off the system safely before inspecting any wiring", "Check all neutral wire connections at the inverter and distribution panel", "Repair any wiring issues found, then restart after confirming correct connections" } + }, + ["AbnormalOffGridOutputVoltage"] = new() + { + Explanation = "The off-grid (backup) output voltage is abnormal. Loads connected to the backup output may not receive correct voltage.", + Causes = new[] { "Overload on the backup output exceeding inverter capacity", "Internal inverter hardware issue", "Battery voltage too low to maintain stable output" }, + NextSteps = new[] { "Disconnect or reduce the load on the backup output", "Check battery state of charge and allow charging if low", "Power cycle the inverter; if persistent, contact service" } + }, + + // Temperature alarms + ["ExcessivelyHighAmbientTemperature"] = new() + { + Explanation = "The ambient temperature around the inverter is too high. The inverter may reduce output power to protect itself from heat damage.", + Causes = new[] { "Poor ventilation around the inverter installation", "High environmental temperature (heat wave, summer peak)", "Direct sunlight exposure heating the inverter enclosure", "Other equipment nearby generating excessive heat" }, + NextSteps = new[] { "Improve airflow and ventilation around the inverter", "Provide shade if the inverter is installed outdoors or in direct sunlight", "Consider adding forced cooling (fan) if in an enclosed space", "The inverter will recover automatically once temperature drops to safe levels" } + }, + ["ExcessiveRadiatorTemperature"] = new() + { + Explanation = "The inverter's heat sink (radiator) temperature is too high. The inverter uses the heat sink to dissipate heat during operation.", + Causes = new[] { "Blocked or obstructed air vents preventing heat dissipation", "Cooling fan failure reducing airflow", "High ambient temperature", "Excessive load causing more heat generation" }, + NextSteps = new[] { "Clean air vents and any dust filters — dust buildup is a common cause", "Check that the cooling fan is running (listen for fan noise during operation)", "Reduce load temporarily to lower heat generation", "Repair or replace the fan if faulty, then restart the inverter" } + }, + ["PcbOvertemperature"] = new() + { + Explanation = "The printed circuit board (PCB) inside the inverter has reached too high a temperature.", + Causes = new[] { "Inadequate cooling or poor ventilation inside the enclosure", "High ambient temperature affecting internal components", "Excessive power output over an extended period" }, + NextSteps = new[] { "Improve ventilation around the inverter", "Check that the cooling fan is operating correctly", "Allow the inverter to cool down before restarting" } + }, + ["DcConverterOvertemperature"] = new() + { + Explanation = "The DC converter section of the inverter is overheating.", + Causes = new[] { "High charging or discharging current sustained for a long period", "Poor cooling or blocked vents", "High ambient temperature in the installation area" }, + NextSteps = new[] { "Reduce power flow through the system temporarily", "Improve ventilation and check fan operation", "Allow cooling, then restart the inverter" } + }, + ["InverterOvertemperatureAlarm"] = new() + { + Explanation = "The inverter temperature is rising toward dangerous levels. This is an early warning before thermal shutdown occurs.", + Causes = new[] { "Output power overload running for extended time", "Poor ventilation trapping heat around the inverter", "Cooling fan failure", "High ambient temperature in the installation area" }, + NextSteps = new[] { "Reduce connected load immediately", "Check that the cooling fans are running and vents are clear", "The inverter will recover once it cools; fix the underlying cause before full restart" } + }, + ["InverterOvertemperature"] = new() + { + Explanation = "The inverter has overheated and protective shutdown has activated.", + Causes = new[] { "Sustained overload condition generating excessive heat", "Cooling system failure (blocked vents, dead fan)", "Extreme environmental temperatures" }, + NextSteps = new[] { "Allow the inverter to cool down fully before attempting restart", "Check fans and ensure all ventilation openings are clear", "Reduce system load and improve cooling before restarting" } + }, + ["DcConverterOvertemperatureAlarm"] = new() + { + Explanation = "The DC converter temperature alarm is active — temperature is approaching the shutdown threshold.", + Causes = new[] { "High power throughput sustained over time", "Inadequate cooling or blocked vents" }, + NextSteps = new[] { "Reduce power flow temporarily to allow cooling", "Check fan operation and clear any ventilation blockages", "Allow temperature to drop, then restart the inverter" } + }, + + // Insulation and safety alarms + ["InsulationFault"] = new() + { + Explanation = "An insulation fault has been detected, indicating possible current leakage to ground. This is a safety-critical condition that must be investigated before resuming operation.", + Causes = new[] { "Damaged cable insulation on PV, battery, or grid cables", "Moisture or water ingress into cable connections or enclosures", "Component insulation breakdown inside the inverter", "Ground fault in the PV array — common after storm damage" }, + NextSteps = new[] { "Do not touch the system — insulation faults can cause electric shock", "Power off the system safely from all disconnects", "Inspect all cables for visible insulation damage, especially in areas exposed to weather", "Perform an insulation resistance test on PV strings and wiring", "Repair damaged insulation before restarting" } + }, + ["LeakageProtectionFault"] = new() + { + Explanation = "The ground fault or leakage current protection has tripped. Leakage current to ground has exceeded the safe threshold.", + Causes = new[] { "Ground fault somewhere in the system wiring", "Damaged cable insulation allowing current to leak to earth", "Moisture getting into cable connectors or junction boxes", "Faulty RCD or GFCI device" }, + NextSteps = new[] { "Power off the system before inspection", "Check for ground faults by inspecting all cable connections and insulation", "Look for moisture in connectors, junction boxes, and cable glands", "Repair the fault, then restart the system" } + }, + ["AbnormalLeakageSelfCheck"] = new() + { + Explanation = "The inverter's leakage current self-check has failed during startup.", + Causes = new[] { "Self-check circuit fault inside the inverter", "An actual ground fault present in the system", "Leakage current sensor malfunction" }, + NextSteps = new[] { "Power off safely and check the system grounding connections", "Inspect wiring for insulation damage that may be causing leakage", "If wiring checks out, the inverter's internal sensor may be faulty — contact service" } + }, + ["PoorGrounding"] = new() + { + Explanation = "Poor or inadequate grounding connection has been detected. Proper grounding is essential for safety and lightning protection.", + Causes = new[] { "Loose ground (earth) connection at the inverter", "Corroded or oxidised ground terminal", "Ground cable resistance too high due to soil conditions or undersized cable", "Missing or disconnected ground wire" }, + NextSteps = new[] { "Power off safely and check all ground/earth connections at the inverter", "Clean any corroded terminals and tighten all ground connections", "Measure ground resistance and compare with installation specification", "Repair grounding, then restart the inverter" } + }, + + // Fan and cooling alarms + ["FanFault"] = new() + { + Explanation = "The cooling fan has failed or is not operating correctly. Without adequate cooling, the inverter will overheat and shut down.", + Causes = new[] { "Fan motor has failed and is no longer spinning", "Fan blade blocked by debris or foreign objects", "Loose or disconnected fan power connector", "Fan control circuit fault" }, + NextSteps = new[] { "Visually inspect the fan and check if it spins when the inverter is running", "Remove any obstructions from the fan blades", "Check that the fan power connector is securely plugged in", "Replace the fan if it is not working — do not run the inverter without cooling" } + }, + + // Power supply alarms + ["AuxiliaryPowerFault"] = new() + { + Explanation = "The auxiliary power supply inside the inverter has failed. This internal supply powers the control electronics.", + Causes = new[] { "Internal power supply component failure", "Input voltage issue affecting the auxiliary supply", "Electronic component failure on the control board" }, + NextSteps = new[] { "Power cycle the inverter — switch off, wait 30 seconds, then switch back on", "If the alarm persists after restart, the auxiliary supply likely needs replacement — contact a service technician" } + }, + + // Model and configuration alarms + ["ModelCapacityFault"] = new() + { + Explanation = "The inverter has detected a model or capacity configuration mismatch — the system settings do not match the hardware.", + Causes = new[] { "Incorrect model configuration set during commissioning", "Firmware version incompatible with hardware model", "Hardware components replaced without updating configuration" }, + NextSteps = new[] { "Verify the inverter model settings in the configuration menu", "Check that the firmware version is compatible with this hardware revision", "Contact your installer or service team to correct the configuration, then restart" } + }, + + // Lightning and surge protection + ["AbnormalLightningArrester"] = new() + { + Explanation = "The surge protection device (SPD / lightning arrester) has either failed or activated due to a surge event.", + Causes = new[] { "Lightning strike or voltage surge has triggered and possibly destroyed the SPD", "SPD component has reached end-of-life and failed", "SPD wiring fault" }, + NextSteps = new[] { "Check the SPD status indicator (most SPDs have a visual fault indicator)", "Replace the SPD cartridge if it has triggered or shows fault", "After replacing, restart the inverter" } + }, + + // Island protection + ["IslandProtection"] = new() + { + Explanation = "Island protection is active — the inverter has disconnected from the grid to prevent back-feeding power into a dead grid. This is a safety feature.", + Causes = new[] { "Utility grid power outage in your area", "Grid voltage or frequency outside acceptable limits", "Intentional grid disconnection by the utility" }, + NextSteps = new[] { "Wait for the utility grid to restore and stabilise", "The inverter will automatically reconnect and resume normal operation once the grid is healthy", "No action required unless the outage is prolonged" } + }, + + // Battery 1 alarms + ["Battery1NotConnected"] = new() + { + Explanation = "Battery 1 is not detected or not connected. The inverter cannot find the battery on the DC bus.", + Causes = new[] { "Battery disconnect switch is open (turned off)", "Loose or disconnected battery cable at inverter or battery terminal", "Battery BMS has shut down the battery due to a protection event", "Battery fuse has blown" }, + NextSteps = new[] { "Check the battery disconnect switch and ensure it is in the ON position", "Inspect battery cable connections at both the inverter and battery ends", "Check the battery BMS status indicator for any fault codes", "Inspect and replace fuse if blown, then restart the inverter" } + }, + ["Battery1Overvoltage"] = new() + { + Explanation = "Battery 1 voltage is too high. Charging has been limited or stopped to protect the battery.", + Causes = new[] { "Battery being overcharged beyond its maximum voltage", "BMS malfunction allowing voltage to rise too high", "Incorrect battery voltage or capacity settings in the inverter", "Cell imbalance causing some cells to over-charge" }, + NextSteps = new[] { "Check the battery state of charge and current voltage", "Verify battery charging voltage settings in the inverter configuration", "Check BMS operation and any BMS fault indicators", "Repair the underlying cause, then restart the inverter" } + }, + ["Battery1Undervoltage"] = new() + { + Explanation = "Battery 1 voltage is too low. Discharging has been limited or stopped to protect the battery from deep discharge.", + Causes = new[] { "Battery has been discharged too deeply", "Individual battery cell failure reducing total capacity", "BMS cutoff due to low voltage protection", "High load draining the battery faster than it charges" }, + NextSteps = new[] { "Allow the battery to recharge from PV or grid", "Check for any unusually high loads drawing excessive power", "Verify battery health — aging batteries may not hold charge", "Repair the underlying cause, then restart the inverter" } + }, + ["Battery1DischargeEnd"] = new() + { + Explanation = "Battery 1 has reached its minimum state of charge (discharge end point). The system will stop discharging to protect the battery.", + Causes = new[] { "Battery has been fully discharged to the configured SOC limit", "High power consumption exceeding available solar or grid charging" }, + NextSteps = new[] { "Wait for the battery to recharge from PV or grid power", "Consider reducing overnight power consumption to preserve battery capacity", "This alarm will clear automatically once sufficient charge is restored" } + }, + ["Battery1Inverted"] = new() + { + Explanation = "Battery 1 polarity is reversed. Operating with reversed polarity can cause severe damage to the inverter and battery.", + Causes = new[] { "Battery cables connected with positive and negative swapped during installation", "Installation error — positive cable on negative terminal or vice versa" }, + NextSteps = new[] { "IMMEDIATELY power off the entire system — do not attempt to charge or discharge", "Disconnect the battery cables carefully after power is off", "Reconnect with correct polarity: positive to positive (+) terminal, negative to negative (−)", "Check for any damage to cables, fuses, or the inverter before restarting" } + }, + ["Battery1OverloadTimeout"] = new() + { + Explanation = "Battery 1 has been operating under overload conditions for too long and has triggered protection.", + Causes = new[] { "Sustained high load continuously exceeding battery discharge rating", "Battery undersized for the connected load", "Battery degradation reducing available power capacity" }, + NextSteps = new[] { "Reduce the total load on the system", "Review whether the battery is correctly sized for peak load requirements", "Repair the underlying cause, then restart the inverter" } + }, + ["Battery1SoftStartFailure"] = new() + { + Explanation = "Battery 1 failed to complete the soft-start (pre-charge) sequence during startup.", + Causes = new[] { "Pre-charge circuit fault preventing controlled startup", "Significant voltage mismatch between battery and DC bus", "Contactor or relay issue in the battery connection path" }, + NextSteps = new[] { "Check battery voltage and compare to the DC bus voltage", "Verify the pre-charge circuit and contactors are operating correctly", "Repair the underlying fault, then restart the inverter" } + }, + ["Battery1PowerTubeFault"] = new() + { + Explanation = "Battery 1 power electronics (IGBT or MOSFET transistors) have failed. This is a hardware fault requiring professional service.", + Causes = new[] { "Power semiconductor (IGBT/MOSFET) has failed due to overstress", "Damage from overcurrent or short circuit event", "Component manufacturing defect that has developed over time" }, + NextSteps = new[] { "Do not attempt to restart the system", "Contact a qualified service technician — this requires internal hardware repair or replacement", "Do not operate the system until the fault is professionally repaired" } + }, + ["Battery1InsufficientPower"] = new() + { + Explanation = "Battery 1 cannot provide sufficient power to meet the current load demand.", + Causes = new[] { "Battery state of charge is too low", "Load demand temporarily exceeds battery's maximum discharge power", "Battery capacity has degraded due to aging" }, + NextSteps = new[] { "Wait for the battery to recharge from PV or grid", "Reduce load if possible during periods of low battery charge", "This alarm should clear automatically once battery has sufficient charge" } + }, + ["Battery1BackupProhibited"] = new() + { + Explanation = "Battery 1 is currently prohibited from providing backup power, typically due to a BMS protection state.", + Causes = new[] { "Battery BMS has activated a protection preventing discharge", "Battery in maintenance or calibration mode", "Battery SOC is below the minimum level required for backup operation" }, + NextSteps = new[] { "Check the BMS status and any BMS fault indicators", "Allow the battery to charge above the minimum backup SOC threshold", "Repair any BMS issues, then restart the inverter" } + }, + + // Battery 2 alarms (similar to Battery 1) + ["Battery2NotConnected"] = new() + { + Explanation = "Battery 2 is not detected or not connected. The inverter cannot find the second battery on the DC bus.", + Causes = new[] { "Battery 2 disconnect switch is open", "Loose or disconnected battery cable at inverter or battery terminal", "Battery 2 BMS has shut down due to a protection event", "Battery 2 fuse has blown" }, + NextSteps = new[] { "Check the Battery 2 disconnect switch is in the ON position", "Verify battery cable connections at both inverter and battery terminals", "Check the Battery 2 BMS status for any fault codes", "Inspect and replace fuse if blown, then restart the inverter" } + }, + ["Battery2Overvoltage"] = new() + { + Explanation = "Battery 2 voltage is too high. Charging has been limited or stopped to protect the battery.", + Causes = new[] { "Battery 2 being overcharged beyond its maximum voltage", "BMS malfunction allowing voltage to rise too high", "Incorrect battery voltage settings in the inverter" }, + NextSteps = new[] { "Check Battery 2 state of charge and voltage", "Verify charging settings in the inverter configuration", "Check BMS operation and any fault indicators, then restart" } + }, + ["Battery2Undervoltage"] = new() + { + Explanation = "Battery 2 voltage is too low. Discharging has been limited to protect the battery from deep discharge.", + Causes = new[] { "Battery 2 has been discharged too deeply", "Individual cell failure reducing total capacity", "BMS low voltage protection cutoff" }, + NextSteps = new[] { "Allow Battery 2 to recharge from PV or grid", "Check battery health — aging batteries lose capacity", "Repair the underlying cause, then restart the inverter" } + }, + ["Battery2DischargeEnd"] = new() + { + Explanation = "Battery 2 has reached its minimum state of charge. Discharging has stopped to protect the battery.", + Causes = new[] { "Battery 2 has been fully discharged to the configured SOC limit", "High power consumption exceeding available charging" }, + NextSteps = new[] { "Wait for Battery 2 to recharge from PV or grid power", "This alarm will clear automatically once sufficient charge is restored" } + }, + ["Battery2Inverted"] = new() + { + Explanation = "Battery 2 polarity is reversed. This is a dangerous condition that must be corrected immediately.", + Causes = new[] { "Battery 2 cables connected with positive and negative swapped", "Installation error during initial wiring" }, + NextSteps = new[] { "IMMEDIATELY power off the entire system", "Disconnect Battery 2 cables carefully after power is confirmed off", "Reconnect with correct polarity and check for any damage before restarting" } + }, + ["Battery2OverloadTimeout"] = new() + { + Explanation = "Battery 2 has been operating under overload conditions for too long.", + Causes = new[] { "Sustained high load continuously exceeding Battery 2 discharge rating", "Battery 2 degradation reducing available power" }, + NextSteps = new[] { "Reduce the total system load", "Check whether Battery 2 is correctly sized for the load requirements", "Restart the inverter after reducing load" } + }, + ["Battery2SoftStartFailure"] = new() + { + Explanation = "Battery 2 failed to complete the soft-start sequence during startup.", + Causes = new[] { "Pre-charge circuit fault for Battery 2", "Voltage mismatch between Battery 2 and the DC bus" }, + NextSteps = new[] { "Check Battery 2 voltage and compare to DC bus voltage", "Inspect pre-charge circuit and contactors for Battery 2, then restart" } + }, + ["Battery2PowerTubeFault"] = new() + { + Explanation = "Battery 2 power electronics (IGBT or MOSFET transistors) have failed. Professional service is required.", + Causes = new[] { "Power semiconductor failure due to overstress, overcurrent, or component degradation", "Short circuit event damaging the power stage" }, + NextSteps = new[] { "Do not restart the system", "Contact a qualified service technician for internal hardware repair" } + }, + ["Battery2InsufficientPower"] = new() + { + Explanation = "Battery 2 cannot provide sufficient power to meet the current load demand.", + Causes = new[] { "Battery 2 state of charge too low", "Load demand exceeds Battery 2 maximum discharge power", "Battery capacity degraded due to aging" }, + NextSteps = new[] { "Wait for Battery 2 to recharge", "Reduce load during periods of low battery charge", "This alarm should clear once the battery has recovered charge" } + }, + ["Battery2BackupProhibited"] = new() + { + Explanation = "Battery 2 is currently prohibited from providing backup power.", + Causes = new[] { "Battery 2 BMS protection is active preventing discharge", "Battery 2 SOC is below the minimum backup threshold" }, + NextSteps = new[] { "Check Battery 2 BMS status for fault codes", "Allow Battery 2 to charge above the minimum SOC required for backup, then restart" } + }, + + // Lithium battery specific alarms + ["LithiumBattery1ChargeForbidden"] = new() + { + Explanation = "The lithium battery 1 BMS has forbidden charging. The battery management system has determined that charging is unsafe at this time.", + Causes = new[] { "Battery is already fully charged — no more charge needed", "Battery temperature is outside the safe charging range (too hot or too cold)", "BMS protection has activated due to cell voltage imbalance or internal fault", "Cell imbalance requiring balancing before charging can resume" }, + NextSteps = new[] { "Check battery temperature — charging is typically blocked below 0°C or above ~45°C", "Check BMS status display or indicators for fault codes", "Allow the battery to reach normal temperature before charging", "If the issue persists at normal temperature, contact battery service" } + }, + ["LithiumBattery1DischargeForbidden"] = new() + { + Explanation = "The lithium battery 1 BMS has forbidden discharging. The battery management system has determined that discharging is unsafe at this time.", + Causes = new[] { "Battery is at or below minimum state of charge — too empty to safely discharge", "Battery temperature is outside the safe discharging range", "BMS low-voltage protection has activated", "Cell imbalance or internal BMS protection event" }, + NextSteps = new[] { "Allow the battery to recharge from PV or grid until SOC is above the minimum threshold", "Check battery temperature — discharging is blocked in very cold conditions", "Check BMS status for any specific fault codes", "If the battery won't accept charge, contact battery service" } + }, + ["LithiumBattery2ChargeForbidden"] = new() + { + Explanation = "The lithium battery 2 BMS has forbidden charging.", + Causes = new[] { "Battery 2 is already fully charged", "Battery 2 temperature is outside the safe charging range", "BMS protection event on Battery 2" }, + NextSteps = new[] { "Check Battery 2 temperature and BMS status", "Allow temperature to normalise before charging", "If the issue persists, check BMS fault codes" } + }, + ["LithiumBattery2DischargeForbidden"] = new() + { + Explanation = "The lithium battery 2 BMS has forbidden discharging.", + Causes = new[] { "Battery 2 is at minimum state of charge", "Battery 2 temperature is outside the safe discharging range", "BMS protection event on Battery 2" }, + NextSteps = new[] { "Allow Battery 2 to recharge from PV or grid", "Check battery temperature and BMS status for fault codes", "If the battery will not recharge, contact battery service" } + }, + ["LithiumBattery1Full"] = new() + { + Explanation = "Lithium battery 1 is fully charged. Charging has automatically stopped.", + Causes = new[] { "Battery has reached 100% state of charge", "Cell voltage has reached maximum safe level" }, + NextSteps = new[] { "This is normal operation — no action required", "Monitor battery health periodically to ensure cells are balancing correctly" } + }, + ["LithiumBattery1DischargeEnd"] = new() + { + Explanation = "Lithium battery 1 has reached the end of its discharge cycle — minimum safe SOC reached.", + Causes = new[] { "Battery has been discharged to the configured minimum SOC limit", "High overnight or daytime load depleted the battery" }, + NextSteps = new[] { "Allow the battery to recharge from solar or grid power", "Consider reducing consumption during low-sunlight periods to preserve charge" } + }, + ["LithiumBattery2Full"] = new() + { + Explanation = "Lithium battery 2 is fully charged. Charging has automatically stopped.", + Causes = new[] { "Battery 2 has reached 100% state of charge" }, + NextSteps = new[] { "This is normal operation — no action required", "The system will automatically resume charging if SOC drops" } + }, + ["LithiumBattery2DischargeEnd"] = new() + { + Explanation = "Lithium battery 2 has reached the end of its discharge cycle.", + Causes = new[] { "Battery 2 has been discharged to the configured minimum SOC limit" }, + NextSteps = new[] { "Allow Battery 2 to recharge from solar or grid power", "This alarm will clear automatically once charge is restored" } + }, + ["LeadBatteryTemperatureAbnormality"] = new() + { + Explanation = "The lead-acid battery temperature is outside the normal operating range.", + Causes = new[] { "Battery overheating due to high ambient temperature or excessive charge current", "Temperature sensor fault giving incorrect readings", "Very cold environmental temperature slowing chemical reactions" }, + NextSteps = new[] { "Check the battery temperature directly if safe to do so", "Improve battery ventilation or cooling if overheating", "Verify the temperature sensor is correctly connected and functioning", "Repair the underlying cause, then restart the inverter" } + }, + ["BatteryAccessMethodError"] = new() + { + Explanation = "The battery access method is incorrectly configured — the inverter and battery are not set up to communicate using the same protocol.", + Causes = new[] { "Incorrect battery communication protocol selected in inverter settings", "Battery type or model not matching the configured access method" }, + NextSteps = new[] { "Check the battery communication settings in the inverter configuration", "Ensure the battery type and communication protocol match the connected battery, then restart" } + }, + + // PV 1 alarms + ["Pv1NotAccessed"] = new() + { + Explanation = "PV string 1 is not detected or accessible. The inverter cannot see any voltage or current from PV string 1.", + Causes = new[] { "PV string 1 disconnector or isolator is open (turned off)", "Cable damage interrupting the string circuit", "PV module fault within the string", "No sunlight available (night or heavy cloud)" }, + NextSteps = new[] { "Check the PV string 1 disconnector is in the ON position", "Verify all cable connections on PV string 1", "Check for shading or obstructions on the panels", "Repair any cable or connector damage found, then restart" } + }, + ["Pv1Overvoltage"] = new() + { + Explanation = "PV string 1 voltage exceeds the maximum DC input voltage of the inverter. This can damage the inverter.", + Causes = new[] { "Too many PV modules connected in series for this inverter model", "Cold temperature causing module Voc to increase significantly", "System design error — string was incorrectly sized" }, + NextSteps = new[] { "Check how many modules are in series and compare to the inverter's maximum input voltage specification", "Verify Voc at the lowest expected site temperature — voltage must stay below inverter maximum", "Reduce the number of modules in series if necessary" } + }, + ["AbnormalPv1CurrentSharing"] = new() + { + Explanation = "PV string 1 current sharing is abnormal, suggesting uneven current flow in the string.", + Causes = new[] { "Mismatched PV modules with different electrical characteristics", "Partial shading on some panels causing bypass diodes to activate", "Module fault reducing current in part of the string" }, + NextSteps = new[] { "Check for shading or soiling on PV string 1 panels", "Verify that all modules in the string are the same model and not damaged", "Repair the underlying fault, then restart the inverter" } + }, + ["Pv1PowerTubeFault"] = new() + { + Explanation = "The PV 1 DC converter power electronics (IGBT/MOSFET) have failed. This is a hardware fault.", + Causes = new[] { "IGBT or MOSFET failure due to overcurrent, overvoltage, or long-term degradation", "Short circuit or surge event damaging the power stage" }, + NextSteps = new[] { "Do not restart the system", "Contact a qualified service technician for hardware repair" } + }, + ["Pv1SoftStartFailure"] = new() + { + Explanation = "PV string 1 failed to complete the soft-start (pre-charge) sequence during startup.", + Causes = new[] { "Pre-charge circuit fault preventing controlled startup", "PV voltage significantly different from expected DC bus level" }, + NextSteps = new[] { "Check PV string 1 voltage at the inverter input terminals", "Repair any pre-charge circuit fault, then restart the inverter" } + }, + ["Pv1OverloadTimeout"] = new() + { + Explanation = "PV string 1 has been delivering excessive power beyond its rated capacity for too long.", + Causes = new[] { "PV array is oversized relative to the DC converter rating", "DC converter capacity limitation exceeded by strong irradiance" }, + NextSteps = new[] { "Review whether the PV array sizing matches the inverter DC input rating", "Repair the underlying cause, then restart the inverter" } + }, + ["Pv1InsufficientPower"] = new() + { + Explanation = "PV string 1 is not providing enough power. This is typically a weather-related condition.", + Causes = new[] { "Low solar irradiance due to cloud cover or weather", "Shading on PV string 1 panels", "Early morning or late evening low sun angles" }, + NextSteps = new[] { "Wait for better sunlight conditions — this will resolve on its own", "Check for new shading sources such as trees, buildings, or debris", "This alarm will clear automatically when irradiance recovers" } + }, + ["Photovoltaic1Overcurrent"] = new() + { + Explanation = "PV string 1 current is exceeding the inverter's maximum DC input current.", + Causes = new[] { "PV array is oversized with too many strings in parallel", "Ground fault causing abnormal current path", "Short circuit in part of the PV string" }, + NextSteps = new[] { "Check PV string 1 configuration — verify number of parallel strings", "Inspect for ground faults or short circuits in the wiring", "Repair the underlying fault, then restart the inverter" } + }, + + // PV 2 alarms + ["Pv2NotAccessed"] = new() + { + Explanation = "PV string 2 is not detected or accessible.", + Causes = new[] { "PV string 2 disconnector is open", "Cable damage on string 2", "No sunlight available" }, + NextSteps = new[] { "Check the PV string 2 disconnector is ON", "Verify cable connections on string 2", "Repair any damage found, then restart the inverter" } + }, + ["Pv2Overvoltage"] = new() + { + Explanation = "PV string 2 voltage exceeds the maximum DC input voltage.", + Causes = new[] { "Too many PV modules in series on string 2", "Cold temperature increasing module Voc above inverter limits" }, + NextSteps = new[] { "Verify string 2 module count and Voc against inverter specification", "Reduce modules in series if necessary to stay within voltage limits" } + }, + ["AbnormalPv2CurrentSharing"] = new() + { + Explanation = "PV string 2 current sharing is abnormal.", + Causes = new[] { "Mismatched or degraded modules in string 2", "Partial shading on string 2 panels" }, + NextSteps = new[] { "Check string 2 panels for shading or soiling", "Repair the underlying fault, then restart the inverter" } + }, + ["Pv2PowerTubeFault"] = new() + { + Explanation = "The PV 2 DC converter power electronics have failed. Professional service is required.", + Causes = new[] { "Power semiconductor (IGBT/MOSFET) failure", "Damage from overcurrent or surge event" }, + NextSteps = new[] { "Do not restart the system", "Contact a qualified service technician for hardware repair" } + }, + ["Pv2SoftStartFailure"] = new() + { + Explanation = "PV string 2 failed to complete the soft-start sequence.", + Causes = new[] { "Pre-charge fault on the PV 2 converter", "PV 2 voltage mismatch with DC bus" }, + NextSteps = new[] { "Check PV string 2 input voltage", "Repair pre-charge fault, then restart the inverter" } + }, + ["Pv2OverloadTimeout"] = new() + { + Explanation = "PV string 2 has been delivering excessive power for too long.", + Causes = new[] { "PV string 2 array is oversized for the converter rating", "Prolonged high irradiance exceeding converter limits" }, + NextSteps = new[] { "Review PV string 2 sizing versus inverter specification", "Repair the underlying cause, then restart the inverter" } + }, + ["Pv2InsufficientPower"] = new() + { + Explanation = "PV string 2 is not providing enough power. Typically weather-related.", + Causes = new[] { "Low solar irradiance or heavy shading on string 2", "Early morning or late evening sun angle too low" }, + NextSteps = new[] { "Wait for better sunlight conditions", "Check for new shading sources on string 2 panels" } + }, + + // PV 3 alarms + ["Pv3NotConnected"] = new() + { + Explanation = "PV string 3 is not connected or not detected.", + Causes = new[] { "PV string 3 disconnector is open", "Cable disconnected or damaged on string 3", "No sunlight available" }, + NextSteps = new[] { "Check the PV string 3 disconnector is ON", "Verify cable connections on string 3", "Repair any damage found, then restart" } + }, + ["Pv3Overvoltage"] = new() + { + Explanation = "PV string 3 voltage exceeds the maximum DC input voltage.", + Causes = new[] { "Too many PV modules in series on string 3", "Cold temperature causing module Voc to rise above inverter limits" }, + NextSteps = new[] { "Check string 3 module count against inverter maximum input voltage specification", "Reduce modules in series if voltage exceeds limits at minimum site temperature" } + }, + ["Pv3AverageCurrentAnomaly"] = new() + { + Explanation = "PV string 3 average current is abnormal, indicating uneven performance within the string.", + Causes = new[] { "Module mismatch or degradation within string 3", "Partial shading affecting some panels in string 3" }, + NextSteps = new[] { "Inspect string 3 panels for shading, soiling, or damage", "Repair the underlying fault, then restart the inverter" } + }, + ["Pv3PowerTubeFailure"] = new() + { + Explanation = "PV 3 power electronics have failed. Professional service is required.", + Causes = new[] { "Power semiconductor failure from overstress or component aging", "Damage from overcurrent or surge" }, + NextSteps = new[] { "Do not restart the system", "Contact a qualified service technician for internal hardware repair" } + }, + ["Pv3SoftStartFailure"] = new() + { + Explanation = "PV string 3 failed to complete the soft-start sequence.", + Causes = new[] { "Pre-charge circuit fault on PV 3 converter", "Voltage mismatch between PV 3 and the DC bus" }, + NextSteps = new[] { "Check PV string 3 voltage at inverter terminals", "Repair pre-charge fault, then restart the inverter" } + }, + ["Pv3OverloadTimeout"] = new() + { + Explanation = "PV string 3 has been delivering excessive power for too long.", + Causes = new[] { "PV string 3 array oversized for the converter rating", "Sustained high irradiance exceeding DC converter limits" }, + NextSteps = new[] { "Review PV string 3 sizing versus inverter specification", "Repair the underlying cause, then restart the inverter" } + }, + ["Pv3ReverseConnection"] = new() + { + Explanation = "PV string 3 is connected with reversed polarity. This is a wiring error that must be corrected before operation.", + Causes = new[] { "PV string 3 positive and negative cables swapped during installation", "Incorrect cable connection at the inverter DC input" }, + NextSteps = new[] { "Do not attempt to restart — reversed polarity can damage components", "Power off completely, then swap PV string 3 positive and negative connections", "Verify correct polarity before restarting" } + }, + + // PV 4 alarms + ["Pv4NotConnected"] = new() + { + Explanation = "PV string 4 is not connected or not detected.", + Causes = new[] { "PV string 4 disconnector is open", "Cable disconnected or damaged on string 4", "No sunlight available" }, + NextSteps = new[] { "Check the PV string 4 disconnector is ON", "Verify cable connections on string 4", "Repair any damage found, then restart" } + }, + ["Pv4Overvoltage"] = new() + { + Explanation = "PV string 4 voltage exceeds the maximum DC input voltage.", + Causes = new[] { "Too many PV modules in series on string 4", "Cold temperature causing module Voc to rise above inverter limits" }, + NextSteps = new[] { "Check string 4 module count against inverter maximum input voltage", "Reduce modules in series if voltage exceeds specification" } + }, + ["Pv4AverageCurrentAnomaly"] = new() + { + Explanation = "PV string 4 average current is abnormal.", + Causes = new[] { "Module mismatch or degradation within string 4", "Partial shading affecting panels in string 4" }, + NextSteps = new[] { "Inspect string 4 panels for shading, soiling, or damage", "Repair the underlying fault, then restart the inverter" } + }, + ["Pv4PowerTubeFailure"] = new() + { + Explanation = "PV 4 power electronics have failed. Professional service is required.", + Causes = new[] { "Power semiconductor failure from overstress or aging", "Damage from overcurrent or surge event" }, + NextSteps = new[] { "Do not restart the system", "Contact a qualified service technician for hardware repair" } + }, + ["Pv4SoftStartFailure"] = new() + { + Explanation = "PV string 4 failed to complete the soft-start sequence.", + Causes = new[] { "Pre-charge circuit fault on PV 4 converter", "Voltage mismatch between PV 4 and the DC bus" }, + NextSteps = new[] { "Check PV string 4 voltage at inverter terminals", "Repair pre-charge fault, then restart the inverter" } + }, + ["Pv4OverloadTimeout"] = new() + { + Explanation = "PV string 4 has been delivering excessive power for too long.", + Causes = new[] { "PV string 4 array oversized for the converter rating", "Sustained high irradiance exceeding DC converter capacity" }, + NextSteps = new[] { "Review PV string 4 sizing versus inverter specification", "Repair the underlying cause, then restart the inverter" } + }, + ["Pv4ReverseConnection"] = new() + { + Explanation = "PV string 4 is connected with reversed polarity. This must be corrected before operation.", + Causes = new[] { "PV string 4 positive and negative cables swapped during installation", "Incorrect cable connection at the inverter DC input" }, + NextSteps = new[] { "Do not restart — power off completely first", "Swap PV string 4 positive and negative connections to correct polarity", "Verify polarity before restarting" } + }, + ["InsufficientPhotovoltaicPower"] = new() + { + Explanation = "Total available PV power is insufficient for the current load or system requirements.", + Causes = new[] { "Low solar irradiance due to cloud cover or weather", "Evening or morning — sun angle too low for full output", "Significant shading on one or more PV strings" }, + NextSteps = new[] { "Wait for better sunlight conditions — this typically resolves on its own", "Check for shading on panels and remove if possible", "This alarm clears automatically when irradiance improves" } + }, + + // DC Bus alarms + ["DcBusOvervoltage"] = new() + { + Explanation = "The internal DC bus voltage is too high. This may indicate an energy imbalance in the system.", + Causes = new[] { "Excessive charging power flowing into the DC bus without load to consume it", "Regenerative load feeding energy back into the DC bus", "DC bus voltage control fault" }, + NextSteps = new[] { "Check the power balance between generation, load, and storage", "Repair the underlying fault, then restart the inverter" } + }, + ["DcBusUndervoltage"] = new() + { + Explanation = "The internal DC bus voltage is too low, preventing normal operation.", + Causes = new[] { "Load is drawing more power than is available from all sources", "Power supply or battery issue limiting DC bus voltage", "Battery approaching depletion" }, + NextSteps = new[] { "Reduce load on the system", "Check all power sources — PV, grid, and battery — are functioning", "Repair the underlying cause, then restart the inverter" } + }, + ["DcBusVoltageUnbalance"] = new() + { + Explanation = "The DC bus voltage is unbalanced between the positive and negative halves.", + Causes = new[] { "Capacitor failure in the DC bus capacitor bank", "DC bus control issue", "Asymmetric loading between the two DC bus halves" }, + NextSteps = new[] { "Check the DC bus capacitor bank for failed capacitors", "Repair the underlying fault, then restart the inverter" } + }, + ["BusSlowOvervoltage"] = new() + { + Explanation = "A slow, gradual rise in DC bus voltage beyond safe limits has been detected.", + Causes = new[] { "Gradual voltage rise due to charging imbalance over time", "Charging control issue allowing slow voltage creep" }, + NextSteps = new[] { "Check charging power control and verify settings are correct", "Repair the underlying fault, then restart the inverter" } + }, + ["HardwareBusOvervoltage"] = new() + { + Explanation = "The hardware-level DC bus overvoltage protection has triggered. This is a severe overvoltage condition.", + Causes = new[] { "Severe overvoltage event from an external source or internal failure", "Component failure causing uncontrolled voltage rise" }, + NextSteps = new[] { "Do not restart — this requires professional inspection", "Contact a service technician to investigate the cause of the overvoltage" } + }, + ["BusSoftStartFailure"] = new() + { + Explanation = "The DC bus failed to pre-charge and soft-start properly during startup.", + Causes = new[] { "Pre-charge resistor or circuit fault", "DC bus capacitor failure preventing proper charge-up", "Relay or contactor in the pre-charge path not operating correctly" }, + NextSteps = new[] { "Check the pre-charge circuit and all associated relays", "Repair the underlying fault, then restart the inverter" } + }, + + // Inverter power tube and hardware faults + ["InverterPowerTubeFault"] = new() + { + Explanation = "The main inverter power electronics (IGBT or MOSFET transistors) have failed. This is a hardware fault requiring professional service.", + Causes = new[] { "Power semiconductor failure due to prolonged overstress", "Overcurrent damage from a short circuit event", "Thermal damage from overheating", "Component end-of-life failure" }, + NextSteps = new[] { "Do not attempt to restart — continued operation risks further damage", "Contact a qualified service technician immediately", "Hardware repair or module replacement is required" } + }, + ["HardwareOvercurrent"] = new() + { + Explanation = "Hardware overcurrent protection has tripped — the current has exceeded the absolute hardware limit.", + Causes = new[] { "Short circuit in the output wiring or connected loads", "Severe overload exceeding hardware protection threshold", "Internal power electronics component failure" }, + NextSteps = new[] { "Do not restart until the cause is identified", "Contact a service technician to inspect for short circuits and component damage" } + }, + ["DcConverterOvervoltage"] = new() + { + Explanation = "The DC converter input or output voltage is too high.", + Causes = new[] { "Input voltage (PV or battery) exceeding converter limits", "DC converter voltage control fault" }, + NextSteps = new[] { "Check PV and battery voltage levels", "Repair the underlying cause, then restart the inverter" } + }, + ["DcConverterHardwareOvervoltage"] = new() + { + Explanation = "The DC converter hardware overvoltage protection has triggered — a severe overvoltage condition has occurred.", + Causes = new[] { "Severe overvoltage at the DC converter input or output", "Lightning surge or external voltage spike" }, + NextSteps = new[] { "Do not restart — contact a service technician to inspect for damage before any further operation" } + }, + ["DcConverterOvercurrent"] = new() + { + Explanation = "The DC converter current is too high.", + Causes = new[] { "Overload condition drawing too much current through the converter", "Short circuit in the DC circuit" }, + NextSteps = new[] { "Reduce the load or charging/discharging power", "Check for short circuits, then restart the inverter" } + }, + ["DcConverterHardwareOvercurrent"] = new() + { + Explanation = "DC converter hardware overcurrent protection has triggered — absolute current limit exceeded.", + Causes = new[] { "Severe overcurrent from short circuit or hardware failure", "Power electronics fault causing uncontrolled current flow" }, + NextSteps = new[] { "Do not restart — contact a service technician to inspect for damage before any further operation" } + }, + ["DcConverterResonatorOvercurrent"] = new() + { + Explanation = "The DC converter resonator circuit is experiencing overcurrent.", + Causes = new[] { "Resonance condition causing excessive current oscillation in the converter", "DC converter control issue affecting the resonant circuit" }, + NextSteps = new[] { "Repair the underlying fault, then restart the inverter; if persistent, contact service" } + }, + + // Overload alarms + ["SystemOutputOverload"] = new() + { + Explanation = "The total system output power is overloaded — more power is being demanded than the system can safely deliver.", + Causes = new[] { "Too many high-power loads connected simultaneously", "Total load demand exceeds the inverter's rated output capacity", "Short circuit in one of the connected loads" }, + NextSteps = new[] { "Disconnect some loads to reduce total power consumption", "Check for any short circuits or faults in connected equipment", "Repair the underlying cause, then restart the inverter" } + }, + ["InverterOverload"] = new() + { + Explanation = "The inverter is overloaded — the load is drawing more power than the inverter is rated for.", + Causes = new[] { "Connected load power exceeds the inverter's rated continuous output", "High inrush current from large motors or compressors at startup", "Short circuit in a connected load" }, + NextSteps = new[] { "Reduce the total connected load", "Stagger the startup of large appliances to reduce inrush current", "Repair the underlying cause, then restart the inverter" } + }, + ["InverterOverloadTimeout"] = new() + { + Explanation = "The inverter has been overloaded for too long and has tripped protection.", + Causes = new[] { "Sustained overload condition running beyond the inverter's short-term overload capability", "Inverter undersized for the actual load requirements" }, + NextSteps = new[] { "Permanently reduce the connected load", "Consider upgrading to a larger inverter if the load is necessary", "Repair the underlying cause, then restart the inverter" } + }, + ["LoadPowerOverload"] = new() + { + Explanation = "The connected load power exceeds the system capacity.", + Causes = new[] { "Too many high-power appliances running simultaneously", "A new high-power device added that exceeds system rating" }, + NextSteps = new[] { "Reduce load by switching off non-essential appliances", "Stagger use of high-power devices, then restart the inverter" } + }, + ["BalancedCircuitOverloadTimeout"] = new() + { + Explanation = "The phase balancing circuit has been overloaded for too long.", + Causes = new[] { "Unbalanced loading across phases — one phase carrying much more than others", "A single phase is significantly overloaded" }, + NextSteps = new[] { "Redistribute loads more evenly across the three phases", "Repair the underlying cause, then restart the inverter" } + }, + + // Soft start failures + ["InverterSoftStartFailure"] = new() + { + Explanation = "The inverter failed to complete its soft-start sequence during power-up.", + Causes = new[] { "Pre-charge resistor is faulty, preventing controlled DC bus charge-up", "Contactor or relay not closing correctly during startup sequence", "DC bus capacitor issue affecting pre-charge", "Control board fault preventing startup sequence completion" }, + NextSteps = new[] { "Power cycle the system — switch off all disconnects, wait 30 seconds, then power back on", "Check the DC bus voltage rises smoothly during pre-charge", "If the fault persists, contact a service technician" } + }, + + // DSP and firmware alarms + ["Dsp1ParameterSettingFault"] = new() + { + Explanation = "DSP 1 (digital signal processor) has detected an incorrect parameter configuration.", + Causes = new[] { "One or more inverter parameters set outside valid range", "Firmware corruption affecting parameter storage", "Configuration mismatch after firmware update" }, + NextSteps = new[] { "Review all inverter parameter settings and correct any out-of-range values", "Reset parameters to factory defaults if unsure of correct values", "Repair the underlying cause, then restart the inverter" } + }, + ["Dsp2ParameterSettingFault"] = new() + { + Explanation = "DSP 2 has detected an incorrect parameter configuration.", + Causes = new[] { "One or more parameters set outside valid range", "Firmware corruption affecting parameter storage" }, + NextSteps = new[] { "Review and correct parameter settings", "Repair the underlying cause, then restart the inverter" } + }, + ["DspVersionCompatibilityFault"] = new() + { + Explanation = "The DSP firmware version is incompatible with other system components.", + Causes = new[] { "Firmware versions between DSP and other boards do not match", "Incomplete or failed firmware update leaving components on different versions" }, + NextSteps = new[] { "Update all firmware components to the same compatible version", "Contact technical support if the correct version is unknown" } + }, + ["CpldVersionCompatibilityFault"] = new() + { + Explanation = "The CPLD (Complex Programmable Logic Device) version is incompatible with the system.", + Causes = new[] { "CPLD firmware mismatch with other components", "Incomplete firmware update" }, + NextSteps = new[] { "Perform a complete firmware update to ensure all components are on matching versions", "Restart the inverter after updating" } + }, + ["CpldCommunicationFault"] = new() + { + Explanation = "Communication with the CPLD internal chip has failed.", + Causes = new[] { "Internal communication bus fault between DSP and CPLD", "CPLD chip failure" }, + NextSteps = new[] { "Power cycle the system — this may restore communication", "If the fault persists after restart, contact a service technician" } + }, + ["DspCommunicationFault"] = new() + { + Explanation = "Communication with the DSP has failed.", + Causes = new[] { "Internal communication bus fault", "DSP hardware failure" }, + NextSteps = new[] { "Power cycle the system", "If the fault persists after restart, contact a service technician" } + }, + + // Output DC component alarms + ["OutputVoltageDcOverlimit"] = new() + { + Explanation = "A DC voltage component has appeared in the AC output voltage, exceeding the allowed limit.", + Causes = new[] { "Control loop drift introducing DC offset into output", "Voltage sensor offset error", "Hardware issue in the output stage" }, + NextSteps = new[] { "Restart the inverter — this often clears transient offsets", "If persistent, contact a service technician" } + }, + ["OutputCurrentDcOverlimit"] = new() + { + Explanation = "A DC current component has appeared in the AC output current, exceeding the allowed limit.", + Causes = new[] { "Control issue introducing DC offset in output current", "Current sensor fault or calibration error" }, + NextSteps = new[] { "Restart the inverter", "If the fault persists, contact service for sensor inspection" } + }, + + // Relay alarms + ["RelaySelfCheckFails"] = new() + { + Explanation = "The relay self-check has failed during startup or periodic testing.", + Causes = new[] { "Relay contact fault — contact may be damaged or welded", "Relay driver circuit fault", "Relay contacts have welded shut due to overcurrent" }, + NextSteps = new[] { "Check relay operation by listening for click sounds during startup", "Repair the underlying fault, then restart the inverter" } + }, + ["InverterRelayOpen"] = new() + { + Explanation = "The inverter output relay is unexpectedly open when it should be closed.", + Causes = new[] { "Relay driver circuit fault preventing the relay from closing", "A protection event has tripped the relay open" }, + NextSteps = new[] { "Check for other active protection alarms that may have opened the relay", "Repair the underlying fault, then restart the inverter" } + }, + ["InverterRelayShortCircuit"] = new() + { + Explanation = "The inverter relay contacts have welded shut (short circuit). The relay cannot open when required.", + Causes = new[] { "Relay contacts welded by excessive current during a fault event", "Relay component failure" }, + NextSteps = new[] { "Do not restart — a welded relay is a safety hazard", "Contact a service technician to inspect and replace the relay" } + }, + ["OpenCircuitOfPowerGridRelay"] = new() + { + Explanation = "The grid connection relay is unexpectedly open.", + Causes = new[] { "Grid relay fault preventing normal closure", "Protection event has opened the grid relay", "Relay driver circuit issue" }, + NextSteps = new[] { "Check for other active alarms that may explain the relay opening", "Inspect the relay and driver circuit, then restart the inverter" } + }, + ["ShortCircuitOfPowerGridRelay"] = new() + { + Explanation = "The grid relay contacts have welded shut and cannot open when needed.", + Causes = new[] { "Relay contacts welded by excessive current from a fault event", "Relay component failure or end-of-life" }, + NextSteps = new[] { "Do not restart — contact a service technician to replace the relay before operating" } + }, + ["GeneratorRelayOpenCircuit"] = new() + { + Explanation = "The generator connection relay is unexpectedly open.", + Causes = new[] { "Generator relay fault preventing closure", "Protection event that opened the relay", "Relay driver circuit issue" }, + NextSteps = new[] { "Check for other active alarms that may explain the relay state", "Inspect the relay circuit, then restart the inverter" } + }, + ["GeneratorRelayShortCircuit"] = new() + { + Explanation = "The generator relay contacts have welded shut and cannot open.", + Causes = new[] { "Relay contacts welded by excessive current", "Generator relay component failure" }, + NextSteps = new[] { "Do not restart — contact a service technician to replace the generator relay before operation" } + }, + + // Abnormal inverter + ["AbnormalInverter"] = new() + { + Explanation = "A general inverter abnormality has been detected. Check for any other more specific alarm codes that may indicate the root cause.", + Causes = new[] { "Internal control system fault with no more specific diagnostic available", "Multiple minor faults occurring simultaneously", "Power electronics operating outside normal parameters" }, + NextSteps = new[] { "Power cycle the inverter and check if other specific alarms appear on restart", "Check all input voltages and load levels for abnormal values", "If the alarm persists, contact a service technician with the full alarm log" } + }, + + // Parallel operation alarms + ["ParallelCommunicationAlarm"] = new() + { + Explanation = "Communication between the parallel-connected inverters has failed. Without communication, the inverters cannot synchronise and share load correctly.", + Causes = new[] { "Communication cable between parallel inverters is damaged or disconnected", "Parallel communication interface failure on one unit", "Settings mismatch between parallel units" }, + NextSteps = new[] { "Check all parallel communication cables between inverter units", "Verify that all parallel settings (voltage, frequency, droop settings) match on all units", "Repair the underlying fault, then restart the inverter system" } + }, + ["ParallelModuleMissing"] = new() + { + Explanation = "One of the expected parallel inverter modules is not responding.", + Causes = new[] { "A parallel module has gone offline or powered down", "Communication link to one module has been lost", "A module has tripped on its own alarm" }, + NextSteps = new[] { "Check all parallel inverter units for individual alarms or power loss", "Repair the underlying fault on the missing module, then restart" } + }, + ["DuplicateMachineNumbersForParallelModules"] = new() + { + Explanation = "Two parallel inverter modules have been configured with the same unit ID number, causing a conflict.", + Causes = new[] { "Configuration error — same unit number assigned to two different units during setup", "Duplicate address not detected during initial commissioning" }, + NextSteps = new[] { "Access each unit's settings and assign a unique unit ID to each", "Repair the configuration, then restart the inverter system" } + }, + ["ParameterConflictInParallelModule"] = new() + { + Explanation = "A parameter conflict exists between parallel-connected inverter modules — their settings do not match.", + Causes = new[] { "Key parameters such as voltage setpoint, frequency, or droop settings differ between units", "One unit was updated or reconfigured without updating the others" }, + NextSteps = new[] { "Compare settings across all parallel units and synchronise them to the same values", "Repair the configuration conflict, then restart the system" } + }, + + // System derating + ["SystemDerating"] = new() + { + Explanation = "The system is operating at reduced output power (derating) to protect itself. Performance will be below rated levels until the underlying cause is resolved.", + Causes = new[] { "High inverter temperature causing thermal derating", "Input voltage (PV or grid) at the edge of operating range", "Component reaching operational limits" }, + NextSteps = new[] { "Check inverter temperature and improve ventilation if overheating", "Verify input voltages are within the inverter's normal operating range", "Identify and resolve the specific derating cause — check if other alarms are also active" } + }, + + // PV access method + ["PvAccessMethodErrorAlarm"] = new() + { + Explanation = "The PV input configuration method is incorrectly set, causing a mismatch between the physical wiring and the software configuration.", + Causes = new[] { "PV string wiring does not match the selected configuration (e.g. series vs parallel setting wrong)", "Wiring connected in a way not matching the inverter's configured PV access method" }, + NextSteps = new[] { "Check the PV configuration settings and compare with the actual physical wiring", "Correct either the settings or the wiring to match, then restart" } + }, + + // Reserved alarms + ["ReservedAlarms4"] = new() + { + Explanation = "Reserved alarm 4 is active. This alarm code is not documented in standard alarm tables.", + Causes = new[] { "An undocumented internal condition has been detected" }, + NextSteps = new[] { "Monitor the system for other alarms that may give more context", "Contact technical support with the full alarm log if this persists" } + }, + ["ReservedAlarms5"] = new() + { + Explanation = "Reserved alarm 5 is active. This alarm code is not documented in standard alarm tables.", + Causes = new[] { "An undocumented internal condition has been detected" }, + NextSteps = new[] { "Monitor the system for other alarms that may give more context", "Contact technical support with the full alarm log if this persists" } + }, + + // Meter alarms + ["ReverseMeterConnection"] = new() + { + Explanation = "The energy meter is installed or wired in reverse. Meter readings (import/export) will be incorrect until this is corrected.", + Causes = new[] { "Current transformer (CT) installed facing the wrong direction", "Meter L and N wires connected in reverse at installation" }, + NextSteps = new[] { "Do not rely on meter readings until corrected", "Contact your installer or a qualified electrician to reverse the CT or correct the meter wiring" } + }, + + // Seal pulse + ["InverterSealPulse"] = new() + { + Explanation = "The inverter seal pulse signal is active, indicating output limiting is in effect.", + Causes = new[] { "A protection function has activated output limiting", "External signal or grid code compliance function limiting output" }, + NextSteps = new[] { "Check system status for other active alarms explaining the limiting", "Repair the underlying cause, then restart the inverter" } + }, + + // Diesel generator alarms + ["AbnormalDieselGeneratorVoltage"] = new() + { + Explanation = "The diesel generator voltage is outside the acceptable range for the inverter to connect to it.", + Causes = new[] { "Generator output voltage not adjusted to correct level", "Generator AVR (automatic voltage regulator) fault", "Generator underloaded or overloaded affecting output voltage" }, + NextSteps = new[] { "Check and adjust the generator voltage output to match inverter specifications", "Inspect the AVR if voltage cannot be stabilised, then restart" } + }, + ["AbnormalDieselGeneratorFrequency"] = new() + { + Explanation = "The diesel generator frequency is outside the acceptable range.", + Causes = new[] { "Generator engine speed not correctly set for target frequency", "Governor fault causing frequency instability" }, + NextSteps = new[] { "Adjust generator speed to achieve correct frequency (50 Hz or 60 Hz as applicable)", "Inspect and repair the governor if frequency cannot be stabilised, then restart" } + }, + ["DieselGeneratorVoltageReverseSequence"] = new() + { + Explanation = "The diesel generator is connected with reversed phase sequence.", + Causes = new[] { "Generator output wires connected in wrong phase order (L1, L2, L3 swapped)" }, + NextSteps = new[] { "Do not restart — contact a qualified electrician to correct the generator phase wiring before operating" } + }, + ["DieselGeneratorVoltageOutOfPhase"] = new() + { + Explanation = "The generator voltage is out of phase with the grid or system, preventing synchronisation.", + Causes = new[] { "Synchronisation issue — generator not locking to grid phase angle", "Phase angle mismatch between generator and grid" }, + NextSteps = new[] { "Check synchronisation settings and ensure the generator supports auto-sync with this inverter", "Repair the synchronisation fault, then restart" } + }, + ["GeneratorOverload"] = new() + { + Explanation = "The diesel generator is overloaded — the system is drawing more power than the generator is rated to supply.", + Causes = new[] { "Total load demand exceeds generator rated capacity", "Battery charging combined with load demand exceeding generator rating", "Generator undersized for the installation" }, + NextSteps = new[] { "Reduce load or reduce battery charge rate to bring total demand within generator capacity", "Restart the inverter after load is reduced" } + }, + }; + + // ── Growatt Alarms ─────────────────────────────────────────────────────── + // Keys match GrowattWarningCode and GrowattErrorCode enum member names + + private static readonly IReadOnlyDictionary GrowattAlarms = new Dictionary + { + // Warnings (200-series: PV/String) + ["StringFault"] = new() + { + Explanation = "A string fault has been detected. One or more PV strings may have issues affecting power generation.", + Causes = new[] { "PV panel fault or damage within the string", "String wiring issue or loose connection", "Damaged or corroded MC4 connector", "Module degradation causing reduced or no output" }, + NextSteps = new[] { "Check if PV panels are visually normal — look for cracks, discolouration, or damage", "Inspect string cable connections and MC4 connectors for damage or corrosion", "Look for damaged cables along the string route", "Have a technician test each string with a multimeter if the fault does not clear" } + }, + ["PvStringPidQuickConnectAbnormal"] = new() + { + Explanation = "PV string or PID quick-connect terminals are abnormal.", + Causes = new[] { "Loose or improperly latched quick-connect terminal", "Damaged quick-connect housing", "Corrosion or oxidation on terminal contacts" }, + NextSteps = new[] { "Power off the system before inspecting any terminals", "Check all quick-connect terminals and ensure they are fully latched", "Clean corroded contacts and reconnect securely" } + }, + ["DcSpdFunctionAbnormal"] = new() + { + Explanation = "The DC surge protection device (SPD) function is abnormal. The SPD protects against lightning and voltage surges on the DC side.", + Causes = new[] { "DC SPD has triggered or failed after a surge event", "SPD cartridge has reached end-of-life", "SPD wiring fault" }, + NextSteps = new[] { "Power off the system and check the DC SPD indicator — most SPDs have a visual fault flag", "Replace the SPD cartridge if it has triggered or shows fault", "Restart the inverter after replacement or inspection" } + }, + ["PvShortCircuited"] = new() + { + Explanation = "PV1 or PV2 string appears to be short-circuited.", + Causes = new[] { "Cable insulation damage causing a direct short between positive and negative conductors", "MC4 connector failure causing internal short", "Module junction box fault creating a short circuit path" }, + NextSteps = new[] { "Power off all DC disconnectors before inspection", "Check PV1 and PV2 strings individually for short-circuit symptoms (zero voltage reading, abnormal heat)", "Inspect cables for damage and test isolation resistance", "Repair or replace damaged cables/connectors before restarting" } + }, + ["PvBoostDriverAbnormal"] = new() + { + Explanation = "The PV boost converter driver circuit is abnormal.", + Causes = new[] { "Boost driver circuit fault or component failure", "EMI interference affecting the driver signal", "Internal hardware issue on the inverter board" }, + NextSteps = new[] { "Restart the inverter — transient driver faults often clear on reboot", "If the fault persists after restart, contact the manufacturer for service" } + }, + ["AcSpdFunctionAbnormal"] = new() + { + Explanation = "The AC surge protection device (SPD) function is abnormal. The SPD protects against lightning and surges on the AC side.", + Causes = new[] { "AC SPD has triggered or failed after a surge event", "SPD cartridge has reached end-of-life", "AC SPD wiring fault" }, + NextSteps = new[] { "Power off the system and check the AC SPD indicator", "Replace the AC SPD cartridge if it shows a fault or has triggered", "Restart the inverter after replacement or inspection" } + }, + ["DcFuseBlown"] = new() + { + Explanation = "The DC fuse has blown, interrupting the PV input to the inverter.", + Causes = new[] { "Overcurrent in the DC circuit from PV array exceeding fuse rating", "Short circuit in DC wiring causing fuse to blow", "Fuse fatigue after repeated overcurrent events" }, + NextSteps = new[] { "Power off all DC switches and disconnectors before working on the circuit", "Locate and inspect the DC fuse — it will appear visually blown or measure open with a multimeter", "Identify and repair the cause of overcurrent before replacing the fuse", "Replace fuse with correct rating, then restart the inverter" } + }, + ["DcInputVoltageTooHigh"] = new() + { + Explanation = "The DC input voltage from the PV array exceeds the inverter's maximum safe input voltage. This can damage the inverter immediately.", + Causes = new[] { "Too many PV modules connected in series, exceeding maximum string voltage", "Cold temperature increasing module open-circuit voltage (Voc) above inverter limit", "System design error — string was incorrectly sized for this inverter" }, + NextSteps = new[] { "Turn off the DC switch immediately to protect the inverter", "Measure the actual DC voltage before reconnecting", "Recheck the string design — verify Voc at minimum expected temperature does not exceed inverter maximum", "Reconfigure the string by reducing modules in series if needed" } + }, + ["PvReversed"] = new() + { + Explanation = "The PV string polarity is reversed — positive and negative connections are swapped.", + Causes = new[] { "PV string cables connected with positive and negative reversed at the inverter or junction box", "Installation error during initial wiring" }, + NextSteps = new[] { "Power off all DC disconnectors before working on the wiring", "Identify the reversed connection — check PV string polarity with a multimeter", "Swap the positive and negative connections to correct polarity before restarting" } + }, + ["PidFunctionAbnormal"] = new() + { + Explanation = "The PID (Potential Induced Degradation) protection function is abnormal.", + Causes = new[] { "PID module fault or configuration error", "Communication issue between inverter and PID module" }, + NextSteps = new[] { "Restart the inverter — this often clears transient PID faults", "Check PID module settings and connections if it persists after restart" } + }, + ["PvStringDisconnected"] = new() + { + Explanation = "A PV string has been disconnected or is not delivering power.", + Causes = new[] { "DC disconnector or isolator for this string is open", "Cable has come loose or disconnected at a connector", "MC4 connector failure" }, + NextSteps = new[] { "Check that all PV string disconnectors are in the ON position", "Verify cable connections at both panel and inverter ends", "Reconnect any loose connections and restart the inverter" } + }, + ["PvStringCurrentUnbalanced"] = new() + { + Explanation = "The currents from different PV strings are significantly unbalanced, suggesting one string is performing worse than the others.", + Causes = new[] { "Shading on some modules in one string but not others", "Module mismatch or degradation in part of the array", "Partial string failure — some modules not contributing", "Soiling or bird droppings on panels in one area" }, + NextSteps = new[] { "Check all PV panels for shading, soiling, or visible damage", "Compare string voltages and currents individually to identify the underperforming string", "Clean panels if soiling is visible and check for new shading sources" } + }, + + // Warnings (300-series: Grid/AC) + ["NoUtilityGrid"] = new() + { + Explanation = "No utility grid connection is detected, or grid power has failed.", + Causes = new[] { "Utility grid outage in your area", "AC circuit breaker between inverter and grid has tripped", "AC grid cable disconnected at the inverter or distribution board", "Utility maintenance work disconnecting the local supply" }, + NextSteps = new[] { "Check if other appliances in the building have grid power — if not, it is a utility outage", "Verify the AC circuit breaker is ON and has not tripped", "Check AC cable connections at the inverter", "Wait for utility to restore power if it is a grid outage" } + }, + ["GridVoltageOutOfRange"] = new() + { + Explanation = "The utility grid voltage is outside the range the inverter is permitted to operate within.", + Causes = new[] { "Grid voltage is too high or too low at your connection point", "Local grid issues such as overloading or transformer problems", "Transformer tap setting not optimal for your location" }, + NextSteps = new[] { "Check the actual grid voltage at the inverter terminals", "If grid voltage is consistently out of range, contact your utility provider", "The inverter will reconnect automatically when the voltage returns to normal" } + }, + ["GridFrequencyOutOfRange"] = new() + { + Explanation = "The utility grid frequency is outside the range the inverter is permitted to operate within.", + Causes = new[] { "Grid frequency unstable due to high load events on the network", "If using a generator, generator frequency has drifted outside tolerance", "Grid disturbance event" }, + NextSteps = new[] { "Check the actual grid frequency at the inverter", "If on generator, adjust governor to correct output frequency", "Wait for grid to stabilise — the inverter reconnects automatically" } + }, + ["Overload"] = new() + { + Explanation = "The system is experiencing an overload — more power is being demanded than the inverter can supply to the backup (EPS) output.", + Causes = new[] { "Total connected load on EPS output exceeds inverter backup capacity", "Inrush current from appliances with motors or compressors starting up", "Short circuit in one of the backup loads" }, + NextSteps = new[] { "Reduce the load on the EPS output by switching off non-essential appliances", "Check for any faulty appliances that may be drawing excessive current", "Stagger startup of large appliances to reduce inrush current" } + }, + ["MeterDisconnected"] = new() + { + Explanation = "The energy meter has lost communication with the inverter.", + Causes = new[] { "Energy meter has powered off or lost power", "Communication cable between inverter and meter is damaged or disconnected", "Meter communication port failure" }, + NextSteps = new[] { "Check that the energy meter has power and is powered on", "Verify the communication cable connections at both the inverter and meter", "Check meter power supply and communication port" } + }, + ["MeterReverselyConnected"] = new() + { + Explanation = "The energy meter L (line) and N (neutral) wires are connected in reverse.", + Causes = new[] { "L and N wires swapped at the meter during installation", "Installation mistake — common when meter polarity is not checked" }, + NextSteps = new[] { "Have a qualified electrician check and correct the meter wiring", "Swap L and N connections at the meter terminal to correct polarity" } + }, + ["LinePeVoltageAbnormal"] = new() + { + Explanation = "Abnormal voltage detected between the neutral (N) wire and protective earth (PE). This can indicate a grounding or wiring fault.", + Causes = new[] { "Poor or missing PE (protective earth) connection", "N and PE wires shorted together at some point in the installation", "Ground fault somewhere in the building wiring" }, + NextSteps = new[] { "Power off the system before inspecting any wiring", "Check that the PE (earth) cable is reliably connected at the inverter and distribution board", "Verify grounding system integrity — have a qualified electrician investigate if needed" } + }, + ["PhaseSequenceError"] = new() + { + Explanation = "A phase sequence error has been detected in the three-phase connection. The inverter will attempt to auto-correct.", + Causes = new[] { "Three-phase wires connected in the wrong order (L1, L2, L3 swapped)" }, + NextSteps = new[] { "No immediate action required — the PCS will automatically adjust phase sequence for most cases", "If alarm persists, have an electrician verify and correct the phase wiring order" } + }, + + // Warnings (400-series: System/Internal) + ["FanFailure"] = new() + { + Explanation = "A cooling fan failure has been detected. Without proper cooling, the inverter will overheat and shut down.", + Causes = new[] { "Fan motor failure — fan is no longer spinning", "Fan blades blocked by debris or foreign objects", "Fan power connector loose or disconnected", "Fan control circuit fault" }, + NextSteps = new[] { "Power off the inverter before inspecting the fan", "Check if the fan spins freely and is not obstructed", "Verify the fan power connector is secure", "Replace the fan if it has failed — do not operate the inverter without cooling" } + }, + ["MeterAbnormal"] = new() + { + Explanation = "The energy meter is reporting abnormal readings.", + Causes = new[] { "Meter malfunction or internal fault", "Incorrect meter configuration or scaling", "Communication issue causing data errors" }, + NextSteps = new[] { "Check that the meter is powered on and functioning", "Verify meter configuration matches the inverter settings (CT ratio, communication protocol)" } + }, + ["OptimizerCommunicationAbnormal"] = new() + { + Explanation = "Communication with a PV module-level optimizer has failed.", + Causes = new[] { "Optimizer has powered off or is not receiving PV power", "Communication interference on the power line", "Optimizer hardware fault" }, + NextSteps = new[] { "Check that the optimizer is receiving PV voltage and is powered on", "Verify communication wiring between inverter and optimizers", "Replace the optimizer if it is confirmed faulty" } + }, + ["OverTemperature"] = new() + { + Explanation = "The inverter temperature has exceeded the normal operating limit. Power output may be reduced to protect the hardware.", + Causes = new[] { "Poor ventilation — hot air trapped around the inverter", "High ambient temperature in the installation area", "Cooling fan failure reducing airflow through the inverter", "Excessive load causing the inverter to run hot" }, + NextSteps = new[] { "Restart the inverter after it has cooled down", "Improve ventilation — ensure adequate clearance around the inverter on all sides", "Check that the cooling fan is running correctly", "Contact the manufacturer if the alarm persists despite good ventilation" } + }, + ["OverTemperatureAlarm"] = new() + { + Explanation = "The inverter has detected an elevated temperature alarm — this is an early warning before thermal shutdown occurs.", + Causes = new[] { "High ambient temperature in the installation space", "Poor airflow or blocked ventilation around the inverter", "Heavy load running during hot weather conditions", "Cooling fan running at reduced speed or intermittently" }, + NextSteps = new[] { "Improve ventilation around the inverter immediately", "Reduce load temporarily to allow the inverter to cool", "Check fan operation and clear any blocked vents", "Monitor temperature until it drops below the alarm threshold" } + }, + ["NtcTemperatureSensorBroken"] = new() + { + Explanation = "The NTC temperature sensor inside the inverter is broken or disconnected.", + Causes = new[] { "NTC sensor element has failed due to aging or mechanical damage", "Sensor cable damaged or disconnected from the board", "Sensor connector has come loose from the PCB" }, + NextSteps = new[] { "Restart the inverter — if the sensor is truly broken the alarm will persist after restart", "If alarm persists, a technician will need to inspect and replace the NTC sensor inside the inverter" } + }, + ["SyncSignalAbnormal"] = new() + { + Explanation = "The synchronisation signal between parallel-connected inverters is abnormal.", + Causes = new[] { "Synchronisation cable between parallel inverters is damaged or disconnected", "Sync communication interface failure on one unit", "Configuration mismatch between units" }, + NextSteps = new[] { "Check the synchronisation cable connections between all parallel inverter units", "Verify parallel communication settings match on all units", "Replace cable if damaged" } + }, + ["GridStartupConditionsNotMet"] = new() + { + Explanation = "The startup conditions for connecting to the grid have not been met. The inverter is waiting for the grid to meet required parameters before connecting.", + Causes = new[] { "Grid voltage or frequency is outside the permitted range for connection", "Grid startup voltage threshold configured incorrectly" }, + NextSteps = new[] { "Check that the grid voltage is within the inverter's permitted operating range", "Review the grid-connection startup voltage and frequency configuration settings" } + }, + + // Warnings (500-series: Battery) + ["BatteryCommunicationFailure"] = new() + { + Explanation = "The inverter cannot communicate with the battery BMS (battery management system). Without BMS communication, charging and discharging cannot be safely managed.", + Causes = new[] { "Battery BMS is offline or powered down", "RS485 or CAN communication cable between inverter and battery is faulty or disconnected", "Communication protocol mismatch between inverter and battery", "Battery in sleep mode — BMS has entered low-power state" }, + NextSteps = new[] { "Verify the battery system is powered on and not in sleep mode", "Check the RS485 communication cable between inverter and battery — inspect for damage", "Verify the battery communication protocol setting in the inverter matches the battery BMS", "Wake the battery if it is in sleep mode by pressing the battery power button" } + }, + ["BatteryDisconnected"] = new() + { + Explanation = "The battery is not connected to the inverter. The system is running without battery storage.", + Causes = new[] { "Battery circuit breaker or isolator is switched off", "Battery cable has come loose or been disconnected", "BMS has shut down the battery due to a protection event", "Battery hardware fault preventing connection" }, + NextSteps = new[] { "Check that the battery circuit breaker is in the ON position", "Verify battery cable connections at both inverter and battery terminals", "Check BMS status indicators for any fault or protection codes", "Resolve any BMS protection events before reconnecting" } + }, + ["BatteryVoltageTooHigh"] = new() + { + Explanation = "The battery voltage is above the maximum permitted level. Charging may have caused the voltage to exceed safe limits.", + Causes = new[] { "Battery has been overcharged beyond its maximum voltage", "BMS fault allowing voltage to rise too high without protection", "Cell imbalance causing individual cells to overcharge", "Incorrect maximum charge voltage setting in the inverter" }, + NextSteps = new[] { "Check the battery voltage and compare to the manufacturer's maximum specification", "Verify the charge voltage settings in the inverter configuration", "Check BMS operation — the BMS should have protected against overvoltage" } + }, + ["BatteryVoltageTooLow"] = new() + { + Explanation = "The battery voltage is below the minimum permitted level. The battery is deeply discharged.", + Causes = new[] { "Battery has been discharged beyond its minimum safe voltage", "Individual battery cell failure reducing pack voltage", "High load draining battery faster than it can be charged", "BMS low-voltage cutoff has activated" }, + NextSteps = new[] { "Check the battery voltage and compare to the manufacturer's minimum specification", "Allow the battery to recharge — first using any available grid power if solar is insufficient", "If voltage is extremely low, the battery may need professional recovery charging" } + }, + ["BatteryReverseConnected"] = new() + { + Explanation = "The battery is connected with reversed polarity. This is dangerous and can cause immediate damage.", + Causes = new[] { "Battery positive and negative terminals connected to wrong inverter terminals during installation", "Installation error — a serious wiring mistake" }, + NextSteps = new[] { "IMMEDIATELY power off the entire system — do not charge or discharge", "Check all battery cable connections before touching anything", "Have a qualified electrician verify and correct the battery polarity", "Inspect for any damage to cables, fuses, or the inverter before restarting" } + }, + ["LeadAcidTempSensorDisconnected"] = new() + { + Explanation = "The lead-acid battery temperature sensor is disconnected or not installed.", + Causes = new[] { "Temperature sensor was not installed with the battery", "Sensor cable has come loose or been damaged", "Sensor connector pulled out from the battery or inverter" }, + NextSteps = new[] { "Check whether a temperature sensor is installed on the lead-acid battery — it is typically a small probe clipped to the battery", "Verify the sensor cable connections at both ends", "Install or reconnect the sensor as required by the installation instructions" } + }, + ["BatteryTemperatureOutOfRange"] = new() + { + Explanation = "The battery temperature is outside the safe range for charging or discharging.", + Causes = new[] { "High ambient temperature in the battery installation area", "Poor battery ventilation causing heat buildup", "Battery overheating during heavy charging or discharging", "Very cold ambient temperature in winter reducing battery performance" }, + NextSteps = new[] { "Check the ambient temperature in the battery installation area", "Improve battery ventilation or move the battery to a cooler location if overheating", "In cold climates, ensure the battery is not exposed to freezing temperatures — below 0°C charging is typically not allowed" } + }, + ["BmsFault"] = new() + { + Explanation = "The battery BMS has reported a fault that is preventing normal charging and discharging.", + Causes = new[] { "BMS internal fault or protection event triggered by the battery", "Individual cell protection has activated due to overvoltage, undervoltage, or temperature", "BMS communication error causing fault reporting" }, + NextSteps = new[] { "Check the battery system display or indicator lights for a BMS-specific fault or error code", "Refer to the battery manufacturer's documentation for the specific BMS fault code", "Contact battery support if the BMS fault cannot be cleared by a power cycle" } + }, + ["LithiumBatteryOverload"] = new() + { + Explanation = "Lithium battery overload protection has activated — the load is drawing more power than the battery is rated to discharge.", + Causes = new[] { "Total load power exceeds the battery's rated maximum discharge power", "High inrush current from large motors or compressors temporarily exceeding battery limits" }, + NextSteps = new[] { "Check the total load power and compare to the battery's rated discharge power", "Reduce load by switching off high-power appliances", "Stagger startup of large appliances to reduce peak demand" } + }, + ["BmsCommunicationAbnormal"] = new() + { + Explanation = "Communication with the BMS is abnormal — data is being received intermittently or with errors.", + Causes = new[] { "Communication timeout due to cable quality or length issues", "Protocol error or baud rate mismatch", "Physical cable fault causing intermittent connection" }, + NextSteps = new[] { "Restart the inverter to attempt re-establishing communication", "Check BMS communication cable for damage or loose connections", "Verify communication settings (protocol, baud rate) match between inverter and BMS" } + }, + ["BatterySpdAbnormal"] = new() + { + Explanation = "The battery-side surge protection device (SPD) function is abnormal.", + Causes = new[] { "Battery SPD has triggered due to a surge event", "SPD has failed or reached end of life", "Lightning-induced surge on the battery wiring" }, + NextSteps = new[] { "Power off the system and inspect the battery SPD indicator", "Replace the SPD if it shows a triggered or fault state", "Restart the system after replacement" } + }, + + // Warnings (600-series: Off-grid/EPS) + ["OutputDcComponentBiasAbnormal"] = new() + { + Explanation = "A DC bias component in the output is abnormal, which could affect sensitive connected equipment.", + Causes = new[] { "Control loop drift introducing DC offset into the AC output", "Sensor calibration drift on the output measurement", "Hardware fault in the output stage" }, + NextSteps = new[] { "Restart the inverter — DC bias faults often clear after reboot", "If the fault persists, contact the manufacturer for service" } + }, + ["DcComponentOverHighOutputVoltage"] = new() + { + Explanation = "The DC component in the output voltage is too high. This can affect sensitive equipment and indicates a control issue.", + Causes = new[] { "Control loop drift causing DC offset to accumulate in output voltage", "Output voltage sensor fault", "Transformer saturation or DC path issue" }, + NextSteps = new[] { "Restart the inverter to reset the control loops", "Check output voltage for DC offset if equipment is affected" } + }, + ["OffGridOutputVoltageTooLow"] = new() + { + Explanation = "The off-grid (EPS/backup) output voltage is too low to properly supply connected loads.", + Causes = new[] { "Load exceeds inverter backup capacity causing voltage sag", "Battery voltage too low to maintain stable output voltage", "Internal inverter limitation" }, + NextSteps = new[] { "Restart the inverter", "Reduce the load on the backup output", "Allow battery to charge if SOC is low", "If fault persists, contact the manufacturer" } + }, + ["OffGridOutputVoltageTooHigh"] = new() + { + Explanation = "The off-grid output voltage is too high, which could damage connected equipment.", + Causes = new[] { "Control fault causing output voltage regulation to fail high", "Voltage reference error in the control system" }, + NextSteps = new[] { "Restart the inverter", "If the fault persists, contact the manufacturer immediately as high output voltage can damage appliances" } + }, + ["OffGridOutputOverCurrent"] = new() + { + Explanation = "The off-grid output current is exceeding the overcurrent limit.", + Causes = new[] { "Total load current exceeds the inverter's backup output current rating", "Short circuit in one of the backup loads", "Inrush current from large motor startup" }, + NextSteps = new[] { "Check that all loads on the backup output are within the inverter's current specification", "Disconnect loads one by one to identify any faulting appliance", "Repair or remove the overloading load before restarting" } + }, + ["OffGridBusVoltageTooLow"] = new() + { + Explanation = "The off-grid DC bus voltage is too low to maintain stable backup power.", + Causes = new[] { "Battery is near empty with insufficient charge to sustain backup operation", "High load demand drawing down the battery faster than it can recover", "Power electronics issue affecting DC bus voltage" }, + NextSteps = new[] { "Check if the total load power is within the inverter's off-grid power limit", "Allow the battery to charge before resuming backup operation", "Reduce backup load if battery charge is low" } + }, + ["OffGridOutputOverload"] = new() + { + Explanation = "The off-grid (EPS/backup) output is overloaded — more power is being demanded than the inverter can supply in backup mode.", + Causes = new[] { "Total load on EPS output exceeds inverter backup capacity", "Too many appliances connected to the backup circuit simultaneously", "Large motor or compressor causing excessive inrush current" }, + NextSteps = new[] { "Check that all loads are within the inverter's EPS output specification", "Reduce the number of appliances on the backup circuit", "Stagger startup of large appliances during backup operation" } + }, + ["BalancedCircuitAbnormal"] = new() + { + Explanation = "The phase balancing circuit is operating abnormally.", + Causes = new[] { "Phase balance circuit internal fault", "Control issue affecting phase balance operation" }, + NextSteps = new[] { "Restart the inverter", "If the fault persists, check phase balance settings and contact service" } + }, + + // Errors (Protection-level faults) + ["ExportLimitationFailSafe"] = new() + { + Explanation = "The export limitation fail-safe has triggered. The inverter has stopped feeding power to the grid because it cannot verify export limits are being enforced.", + Causes = new[] { "CT (current transformer) sensor is disconnected or measuring incorrectly", "Meter communication has been lost preventing export monitoring", "Export limit feedback loop has failed — the inverter cannot confirm grid export is controlled" }, + NextSteps = new[] { "Power off the system before inspecting CT or meter connections", "Check the CT sensor is correctly installed and securely connected", "Verify the energy meter communication cable is intact", "Confirm export limit settings and feedback are correctly configured, then restart" } + }, + ["DcBiasAbnormal"] = new() + { + Explanation = "The DC injection (DCI) protection has detected abnormal DC bias in the AC output — a safety protection preventing DC from being injected into the grid.", + Causes = new[] { "DC injection into the grid from the inverter output", "Output current sensor fault giving incorrect readings", "Transformer saturation or control issue" }, + NextSteps = new[] { "Restart the inverter — this sometimes clears transient DCI faults", "If the fault persists, the inverter requires professional service" } + }, + ["HighDcComponentOutputCurrent"] = new() + { + Explanation = "High DC component detected in the AC output current. This is a protection condition.", + Causes = new[] { "Output filter issue allowing DC component through", "Control fault affecting current waveform symmetry", "Output transformer saturation" }, + NextSteps = new[] { "Restart the inverter", "Check output current waveform quality if measurement equipment is available", "If persistent, contact the manufacturer for service" } + }, + ["BusVoltageSamplingAbnormal"] = new() + { + Explanation = "The DC bus voltage measurement is abnormal — the sensor is giving incorrect readings.", + Causes = new[] { "Voltage sensor or measurement circuit fault", "ADC (analogue to digital converter) error on the control board", "Hardware issue affecting measurement accuracy" }, + NextSteps = new[] { "Restart the inverter", "If persistent, the measurement circuit requires professional service" } + }, + ["RelayFault"] = new() + { + Explanation = "An internal relay fault has been detected. The relay is not operating as expected.", + Causes = new[] { "Relay has failed — contacts stuck open or closed", "Contact welding from overcurrent event", "Relay driver circuit fault" }, + NextSteps = new[] { "Restart the inverter to reset the relay", "If the fault persists, the relay likely needs replacement — contact service" } + }, + ["BusVoltageAbnormal"] = new() + { + Explanation = "The internal DC bus voltage is abnormal.", + Causes = new[] { "Power electronics fault affecting DC bus regulation", "Capacitor issue in the DC bus", "Control system failure" }, + NextSteps = new[] { "Restart the inverter", "If persistent, the system requires professional inspection" } + }, + ["InternalCommunicationFailure"] = new() + { + Explanation = "Internal communication has failed between control boards inside the inverter.", + Causes = new[] { "Communication board fault or failure", "Internal ribbon cable or connector has come loose", "Electromagnetic interference (EMI) affecting internal communication" }, + NextSteps = new[] { "Power off the inverter, wait 30 seconds, then restart to see if communication restores", "If persistent, a technician should open the inverter and check internal communication cable connections" } + }, + ["TemperatureSensorDisconnected"] = new() + { + Explanation = "A temperature sensor inside the inverter is disconnected, preventing proper thermal monitoring.", + Causes = new[] { "Sensor element has failed or detached from its mounting", "Sensor cable is damaged or disconnected", "Sensor connector has pulled out from the PCB" }, + NextSteps = new[] { "Power off the inverter and check internal sensor wiring if accessible", "If not accessible, contact a service technician to inspect and replace the sensor" } + }, + ["IgbtDriveFault"] = new() + { + Explanation = "An IGBT gate drive fault has been detected. The IGBT is not being driven correctly, which can prevent proper power conversion.", + Causes = new[] { "Gate driver circuit failure", "IGBT transistor fault — device may have failed", "Gate driver power supply issue" }, + NextSteps = new[] { "Restart the inverter — minor transient gate faults can clear on reboot", "If persistent, this requires professional service — IGBT or driver replacement" } + }, + ["EepromError"] = new() + { + Explanation = "An EEPROM read or write error has occurred. The inverter's non-volatile memory is not functioning correctly.", + Causes = new[] { "EEPROM chip has failed — common after many years of operation", "Data corruption in the EEPROM memory", "Hardware failure on the memory circuit" }, + NextSteps = new[] { "Restart the inverter — this may clear a transient memory error", "If persistent, a factory reset may restore function; contact support before attempting" } + }, + ["AuxiliaryPowerAbnormal"] = new() + { + Explanation = "The internal auxiliary power supply is abnormal. This supply powers the control electronics.", + Causes = new[] { "Internal auxiliary power supply component failure", "Voltage regulator fault on the control board" }, + NextSteps = new[] { "Restart the inverter", "If persistent, contact service — the auxiliary supply may need replacement" } + }, + ["DcAcOvercurrentProtection"] = new() + { + Explanation = "DC/AC overcurrent protection has triggered — current has exceeded the safe limit.", + Causes = new[] { "Short circuit in the AC output wiring or connected loads", "Severe overload far exceeding rated capacity", "Power electronics fault causing overcurrent" }, + NextSteps = new[] { "Restart the inverter after checking for and removing any short circuits", "Check all connected loads for faults", "Reduce load before restarting" } + }, + ["CommunicationProtocolMismatch"] = new() + { + Explanation = "A communication protocol mismatch has been detected between components.", + Causes = new[] { "Firmware versions between control boards do not match", "Communication configuration error" }, + NextSteps = new[] { "Restart the inverter", "If persistent, perform a full firmware update to ensure all components are on matching versions" } + }, + ["DspComFirmwareMismatch"] = new() + { + Explanation = "The DSP (signal processor) and COM (communication) board firmware versions do not match.", + Causes = new[] { "Firmware update was incomplete, leaving boards on different versions", "Wrong firmware file was loaded to one of the boards" }, + NextSteps = new[] { "Restart the inverter", "Perform a complete firmware update — update all boards to the correct matching version" } + }, + ["DspSoftwareHardwareMismatch"] = new() + { + Explanation = "The DSP software version is incompatible with the hardware version.", + Causes = new[] { "Hardware board was replaced with a newer or older revision that requires a different firmware version" }, + NextSteps = new[] { "Restart the inverter", "Contact technical support to identify the correct firmware version for this hardware revision" } + }, + ["CpldAbnormal"] = new() + { + Explanation = "The CPLD (Complex Programmable Logic Device) inside the inverter is operating abnormally.", + Causes = new[] { "CPLD chip failure or firmware corruption", "Power supply issue affecting CPLD operation" }, + NextSteps = new[] { "Restart the inverter", "If persistent, this requires professional service — CPLD replacement or reprogramming" } + }, + ["RedundancySamplingInconsistent"] = new() + { + Explanation = "The redundant voltage or current sampling circuits are giving inconsistent results — the two measurement paths disagree.", + Causes = new[] { "One of the redundant sensors has drifted or failed", "ADC calibration error on one measurement channel", "Hardware fault on one of the measurement circuits" }, + NextSteps = new[] { "Restart the inverter to reset measurement circuits", "If persistent, recalibration or sensor replacement may be required — contact service" } + }, + ["PwmPassThroughSignalFailure"] = new() + { + Explanation = "The PWM (pulse-width modulation) pass-through signal path has failed.", + Causes = new[] { "Control board fault affecting PWM signal routing", "Signal path hardware issue" }, + NextSteps = new[] { "Restart the inverter", "If persistent, contact service — this requires internal board inspection" } + }, + ["AfciSelfTestFailure"] = new() + { + Explanation = "The AFCI (Arc Fault Circuit Interrupter) self-test has failed. The AFCI protects against dangerous arc faults in PV wiring.", + Causes = new[] { "AFCI detection module fault preventing self-test completion", "Self-test circuit issue on the control board" }, + NextSteps = new[] { "Restart the inverter to attempt another self-test", "If the self-test continues to fail, the AFCI module may need replacement — contact service" } + }, + ["PvCurrentSamplingAbnormal"] = new() + { + Explanation = "The PV current measurement is giving abnormal readings.", + Causes = new[] { "PV current sensor or hall-effect sensor fault", "ADC error on the current measurement channel" }, + NextSteps = new[] { "Restart the inverter", "If persistent, the current sensor circuit requires professional service" } + }, + ["AcCurrentSamplingAbnormal"] = new() + { + Explanation = "The AC current measurement is giving abnormal readings.", + Causes = new[] { "CT (current transformer) sensor fault or incorrect connection", "AC current sensor failure", "ADC error on the AC measurement channel" }, + NextSteps = new[] { "Restart the inverter", "Check CT connections and orientation if accessible", "If persistent, the measurement circuit requires professional service" } + }, + ["BusSoftbootFailure"] = new() + { + Explanation = "The DC bus failed to soft-boot (pre-charge) correctly during startup.", + Causes = new[] { "Pre-charge circuit fault preventing controlled capacitor charge-up", "DC bus capacitor issue", "Pre-charge relay or contactor fault" }, + NextSteps = new[] { "Restart the inverter", "If persistent, the pre-charge circuit requires professional service" } + }, + ["EpoFault"] = new() + { + Explanation = "An EPO (Emergency Power Off) fault has been triggered.", + Causes = new[] { "EPO emergency stop button was pressed", "EPO circuit has been activated by an external safety system", "EPO circuit fault triggering shutdown unintentionally" }, + NextSteps = new[] { "Check if the EPO button was pressed — reset it if so", "Verify the EPO circuit wiring if activation was unintentional", "Restart the inverter after confirming EPO circuit is clear" } + }, + ["MonitoringChipBootVerificationFailed"] = new() + { + Explanation = "The monitoring chip failed to pass boot verification — the chip's firmware or startup sequence has an issue.", + Causes = new[] { "Firmware corruption on the monitoring chip", "Monitoring chip hardware failure" }, + NextSteps = new[] { "Restart the inverter — boot verification failures sometimes resolve on retry", "If persistent, firmware reload or chip replacement may be required — contact service" } + }, + + // Battery Errors + ["BmsCommunicationFailure"] = new() + { + Explanation = "The BMS has failed to communicate with the inverter. Charging and discharging cannot be safely managed without BMS communication.", + Causes = new[] { "RS485 communication cable between inverter and battery is faulty or disconnected", "BMS has powered off or is unresponsive", "Communication protocol mismatch between inverter and BMS" }, + NextSteps = new[] { "Check the RS485 cable connection between the inverter and battery — inspect both ends", "Verify the battery is powered on and the BMS is active", "Check that the communication protocol setting matches the battery BMS" } + }, + ["BmsChargeDischargeFailure"] = new() + { + Explanation = "The BMS has reported that the battery cannot charge or discharge.", + Causes = new[] { "BMS internal protection has triggered — cell overvoltage, undervoltage, or temperature fault", "BMS hardware fault causing charge/discharge to be blocked", "Battery cell issue detected by BMS" }, + NextSteps = new[] { "Check the battery display or BMS indicator for a specific error code", "Refer to the battery manufacturer's documentation for the BMS fault code", "Contact battery support if the fault cannot be cleared" } + }, + ["BatteryVoltageLow"] = new() + { + Explanation = "Battery voltage is below the minimum permitted level.", + Causes = new[] { "Battery has been deeply discharged below safe minimum voltage", "Individual cell failure reducing overall pack voltage" }, + NextSteps = new[] { "Check the battery voltage — if critically low, professional recovery charging may be needed", "Allow battery to recharge slowly from grid before resuming normal operation" } + }, + ["BatteryVoltageHigh"] = new() + { + Explanation = "Battery voltage exceeds the maximum permitted upper threshold.", + Causes = new[] { "Battery has been overcharged beyond its maximum voltage", "BMS fault allowing voltage to rise without protection", "Individual cell failure creating high voltage in part of the pack" }, + NextSteps = new[] { "Check the battery voltage and compare to the manufacturer's maximum specification", "If voltage is within permissible range, restart the inverter", "If voltage is genuinely too high, stop charging immediately and contact battery service" } + }, + ["BatteryTemperatureAbnormal"] = new() + { + Explanation = "The battery temperature is outside the safe range for charging or discharging.", + Causes = new[] { "Battery is too hot — poor ventilation or high ambient temperature", "Battery is too cold — freezing or near-freezing environment", "Battery temperature sensor fault giving incorrect readings" }, + NextSteps = new[] { "Check the physical temperature of the battery if safe to do so", "Improve battery ventilation if overheating", "In cold conditions, allow the battery to warm up before charging", "Check sensor connections if temperature reading appears incorrect" } + }, + ["BatteryReversed"] = new() + { + Explanation = "Battery polarity is reversed — positive and negative terminals are connected incorrectly.", + Causes = new[] { "Battery positive and negative cables connected to the wrong inverter terminals", "Installation error" }, + NextSteps = new[] { "IMMEDIATELY power off the entire system — reversed polarity can cause severe damage", "Have a qualified electrician verify and correct the battery polarity before any further operation" } + }, + ["BatteryOpenCircuit"] = new() + { + Explanation = "The battery circuit is open — the battery is not electrically connected.", + Causes = new[] { "Battery cable has come loose or disconnected from the terminal", "Battery fuse has blown interrupting the circuit", "BMS has opened the internal contactor due to a protection event" }, + NextSteps = new[] { "Check all battery cable connections at both the inverter and battery terminals", "Inspect the battery fuse and replace if blown", "Check BMS status for any protection events that may have opened the battery contactor" } + }, + ["BatteryOverloadProtection"] = new() + { + Explanation = "Battery overload protection has triggered — the load is drawing more power than the battery can safely discharge.", + Causes = new[] { "Total load power exceeds the battery's rated maximum discharge power", "High inrush current from large appliances temporarily exceeding battery rating" }, + NextSteps = new[] { "Check the total load and compare to the battery's rated discharge power", "Reduce high-power loads and restart the inverter" } + }, + ["Bus2VoltageAbnormal"] = new() + { + Explanation = "The secondary DC bus voltage is abnormal.", + Causes = new[] { "Power electronics fault affecting the secondary DC bus", "Control issue on the secondary converter" }, + NextSteps = new[] { "Restart the inverter", "If persistent, this requires professional inspection" } + }, + ["BatteryChargeOcp"] = new() + { + Explanation = "Battery charge overcurrent protection (OCP) has triggered — the charge current is too high.", + Causes = new[] { "PV array is oversized delivering more current than the battery can safely accept", "Battery charge current limit setting too high for the battery specification" }, + NextSteps = new[] { "Check whether the PV array power significantly exceeds the battery charge rating", "Reduce the maximum charge current setting in the inverter to match the battery specification" } + }, + ["BatteryDischargeOcp"] = new() + { + Explanation = "Battery discharge overcurrent protection (OCP) has triggered — discharge current is too high.", + Causes = new[] { "Connected load is drawing more current than the battery's maximum discharge rating", "Battery discharge current limit setting configured too high" }, + NextSteps = new[] { "Check that the battery discharge current configuration matches the battery specification", "Reduce the connected load to within battery discharge limits" } + }, + ["BatterySoftStartFailed"] = new() + { + Explanation = "The battery failed to complete its soft-start sequence when connecting to the inverter.", + Causes = new[] { "Pre-charge circuit fault preventing controlled battery connection", "Battery voltage significantly different from the inverter DC bus voltage" }, + NextSteps = new[] { "Restart the inverter", "Check the battery voltage against the DC bus voltage — a large mismatch can prevent soft-start" } + }, + + // Off-grid Errors + ["EpsOutputShortCircuited"] = new() + { + Explanation = "The EPS (backup) output has a short circuit.", + Causes = new[] { "Short circuit in the load wiring connected to the backup output", "A faulty appliance causing a short on the backup circuit", "Wiring fault in the EPS output distribution" }, + NextSteps = new[] { "Disconnect all loads from the backup output", "Identify and repair the short circuit in the load wiring or appliances before reconnecting" } + }, + ["OffGridBusVoltageLow"] = new() + { + Explanation = "The off-grid DC bus voltage is too low to maintain backup operation.", + Causes = new[] { "Battery is nearly depleted and cannot maintain DC bus voltage", "High backup load combined with low battery charge", "Battery capacity loss due to aging" }, + NextSteps = new[] { "Check whether the battery is working properly and has not lost significant capacity", "Allow the battery to charge before attempting backup operation", "Reduce backup load to extend available battery runtime" } + }, + ["OffGridTerminalVoltageAbnormal"] = new() + { + Explanation = "An abnormal voltage has been detected at the off-grid AC output terminal.", + Causes = new[] { "External voltage is present at the backup AC output from another source", "Wiring fault connecting the backup output to an energised circuit", "Backfeed from a load that has its own power source" }, + NextSteps = new[] { "Check if an external voltage source is present at the AC backup output port", "Verify backup output wiring does not connect to any other energised source", "Disconnect all loads from the backup output and inspect wiring before restarting" } + }, + ["SoftStartFailed"] = new() + { + Explanation = "The off-grid mode soft-start sequence has failed.", + Causes = new[] { "Pre-charge failure during off-grid startup", "Load is too heavy at the moment of off-grid startup" }, + NextSteps = new[] { "Restart the inverter", "Reduce the initial load on the backup circuit during startup" } + }, + ["OffGridOutputVoltageAbnormal"] = new() + { + Explanation = "The off-grid output voltage is abnormal.", + Causes = new[] { "Control fault causing off-grid voltage regulation to fail", "Hardware issue on the output stage", "Severe overload collapsing output voltage" }, + NextSteps = new[] { "Restart the inverter", "If the fault persists, contact the manufacturer" } + }, + ["BalancedCircuitSelfTestFailed"] = new() + { + Explanation = "The balanced circuit self-test has failed during startup.", + Causes = new[] { "Phase balancing circuit fault detected during self-test", "Balance circuit hardware issue" }, + NextSteps = new[] { "Restart the inverter to retry the self-test", "If the fault persists, contact service" } + }, + ["HighDcComponentOutputVoltage"] = new() + { + Explanation = "A high DC component has been detected in the AC output voltage.", + Causes = new[] { "Control loop drift causing DC offset to build up in the output voltage", "Output transformer or filter issue" }, + NextSteps = new[] { "Restart the inverter to reset control loops", "If the fault persists, contact the manufacturer" } + }, + ["OffGridParallelSignalAbnormal"] = new() + { + Explanation = "The off-grid parallel communication signal between inverter units is abnormal.", + Causes = new[] { "Parallel communication cable between units is damaged or disconnected", "Parallel configuration mismatch between units" }, + NextSteps = new[] { "Check that all parallel communication cables are properly and securely connected between inverter units", "Verify parallel settings match on all units" } + }, + + // Special fault codes + ["AFCIFault"] = new() + { + Explanation = "An arc fault has been detected in the PV system. Arc faults can cause fires in PV wiring and the system has shut down as a safety precaution.", + Causes = new[] { "Loose MC4 connector or PV cable connection causing intermittent arcing", "Damaged cable insulation allowing arc at the damaged point", "Faulty connector or junction box creating an arc path", "Module junction box damage" }, + NextSteps = new[] { "Power off all DC disconnectors before inspecting any PV wiring", "Carefully inspect all PV string connections, MC4 connectors, and cable runs for damage", "Tighten any loose connectors and replace any damaged cables or connectors", "Have the installation professionally inspected if the arc source is not found" } + }, + ["GFCIHigh"] = new() + { + Explanation = "Excessively high ground fault (leakage) current has been detected in the PV system.", + Causes = new[] { "Ground fault in the PV array — typically a cable touching the frame or metalwork", "Insulation breakdown on PV cables or at module junction boxes", "Moisture ingress into cable connections or module junction boxes", "Cable damage exposing conductors to ground" }, + NextSteps = new[] { "Restart the inverter to see if the fault clears", "If it persists, perform insulation resistance testing on all PV strings to find the fault location", "Repair any insulation damage or ground fault found before restarting" } + }, + ["PVVoltageHigh"] = new() + { + Explanation = "The DC input voltage from the PV array exceeds the absolute maximum safe limit. This is an immediate risk of inverter damage.", + Causes = new[] { "Too many PV modules in series exceeding the inverter's maximum input voltage", "Very cold temperature causing module Voc to rise significantly above the design temperature Voc" }, + NextSteps = new[] { "Disconnect the DC switch immediately to protect the inverter", "Measure actual DC voltage before reconnecting", "Review string design and reduce the number of modules in series if needed to stay within inverter voltage limits" } + }, + }; +} diff --git a/csharp/App/Backend/Services/AlarmReviewService.cs b/csharp/App/Backend/Services/AlarmReviewService.cs new file mode 100644 index 000000000..ff278c407 --- /dev/null +++ b/csharp/App/Backend/Services/AlarmReviewService.cs @@ -0,0 +1,1789 @@ +using System.Text; +using System.Text.RegularExpressions; +using Flurl.Http; +using InnovEnergy.Lib.Mailer; +using MailKit.Net.Smtp; +using MailKit.Security; +using MimeKit; +using Newtonsoft.Json; + +namespace InnovEnergy.App.Backend.Services; + +// ── Models ──────────────────────────────────────────────────────────────────── + +public class AlarmReviewProgress +{ + [JsonProperty("startedAt")] public string StartedAt { get; set; } = ""; + [JsonProperty("batches")] public List Batches { get; set; } = new(); +} + +public class BatchRecord +{ + [JsonProperty("batchNumber")] public int BatchNumber { get; set; } + [JsonProperty("sentDate")] public string SentDate { get; set; } = ""; + [JsonProperty("alarmKeys")] public List AlarmKeys { get; set; } = new(); + [JsonProperty("resendCount")] public int ResendCount { get; set; } + [JsonProperty("synthesized")] public bool Synthesized { get; set; } + [JsonProperty("synthesizedAt")] public string? SynthesizedAt { get; set; } + [JsonProperty("submissions")] public Dictionary Submissions { get; set; } = new(); + [JsonProperty("improvedEntries")] public Dictionary ImprovedEntries{ get; set; } = new(); + [JsonProperty("note")] public string? Note { get; set; } +} + +public class ReviewerSubmission +{ + [JsonProperty("submittedAt")] public string SubmittedAt { get; set; } = ""; + [JsonProperty("feedbacks")] public List Feedbacks { get; set; } = new(); +} + +public class ReviewFeedback +{ + [JsonProperty("explanationOk")] public bool ExplanationOk { get; set; } + [JsonProperty("explanation")] public string Explanation { get; set; } = ""; + [JsonProperty("causesOk")] public bool CausesOk { get; set; } + [JsonProperty("causes")] public List Causes { get; set; } = new(); + [JsonProperty("stepsOk")] public bool StepsOk { get; set; } + [JsonProperty("nextSteps")] public List NextSteps { get; set; } = new(); + [JsonProperty("comment")] public string Comment { get; set; } = ""; +} + +public class AlarmCorrectionRequest +{ + [JsonProperty("batchNumber")] public int BatchNumber { get; set; } + [JsonProperty("alarmKey")] public string? AlarmKey { get; set; } + [JsonProperty("explanation")] public string? Explanation { get; set; } + [JsonProperty("causes")] public List? Causes { get; set; } + [JsonProperty("nextSteps")] public List? NextSteps { get; set; } +} + +// ── Service ─────────────────────────────────────────────────────────────────── + +public static class AlarmReviewService +{ + // ── Configuration ───────────────────────────────────────────────────────── + + private static readonly (string Name, string Email)[] Reviewers = + { + ("Rüdiger", "junghans@inesco.energy"), + ("Nico", "lapp@inesco.energy"), + ("Fabio", "niederberger@inesco.energy"), + ("Jan", "dustmann@inesco.energy"), + }; + + private const string AdminEmail = "liu@inesco.energy"; + private const string BaseUrl = "https://monitor.inesco.energy/api"; + private const int BatchSize = 10; + + // ── File paths ───────────────────────────────────────────────────────────── + + private static string ResourcesDir => Path.Combine(AppContext.BaseDirectory, "Resources"); + private static string ProgressFile => Path.Combine(ResourcesDir, "alarm-review-progress.json"); + private static string CheckedFilePath => Path.Combine(ResourcesDir, "AlarmTranslationsChecked.de.json"); + + // ── German alarm display names (loaded from AlarmNames.de.json) ──────────── + + private static IReadOnlyDictionary _germanNames = new Dictionary(); + + public static void LoadGermanNames() + { + var file = Path.Combine(AppContext.BaseDirectory, "Resources", "AlarmNames.de.json"); + if (!File.Exists(file)) return; + try + { + var raw = JsonConvert.DeserializeObject>(File.ReadAllText(file)); + if (raw is not null) _germanNames = raw; + Console.WriteLine($"[AlarmReviewService] Loaded {raw?.Count ?? 0} German alarm names."); + } + catch (Exception ex) + { + Console.Error.WriteLine($"[AlarmReviewService] Failed to load AlarmNames.de.json: {ex.Message}"); + } + } + + private static string GermanName(string key) => + _germanNames.TryGetValue(key, out var name) ? name : SplitCamelCase(key); + + // ── Alarm key ordering: 135 Sinexcel + 94 Growatt = 229 total ──────────── + + private static readonly string[] SinexcelKeys = + { + "AbnormalGridVoltage", "AbnormalGridFrequency", "InvertedSequenceOfGridVoltage", + "GridVoltagePhaseLoss", "AbnormalGridCurrent", "AbnormalOutputVoltage", + "AbnormalOutputFrequency", "AbnormalNullLine", "AbnormalOffGridOutputVoltage", + "ExcessivelyHighAmbientTemperature", "ExcessiveRadiatorTemperature", "PcbOvertemperature", + "DcConverterOvertemperature", "InverterOvertemperatureAlarm", "InverterOvertemperature", + "DcConverterOvertemperatureAlarm", "InsulationFault", "LeakageProtectionFault", + "AbnormalLeakageSelfCheck", "PoorGrounding", "FanFault", "AuxiliaryPowerFault", + "ModelCapacityFault", "AbnormalLightningArrester", "IslandProtection", + "Battery1NotConnected", "Battery1Overvoltage", "Battery1Undervoltage", + "Battery1DischargeEnd", "Battery1Inverted", "Battery1OverloadTimeout", + "Battery1SoftStartFailure", "Battery1PowerTubeFault", "Battery1InsufficientPower", + "Battery1BackupProhibited", "Battery2NotConnected", "Battery2Overvoltage", + "Battery2Undervoltage", "Battery2DischargeEnd", "Battery2Inverted", + "Battery2OverloadTimeout", "Battery2SoftStartFailure", "Battery2PowerTubeFault", + "Battery2InsufficientPower", "Battery2BackupProhibited", "LithiumBattery1ChargeForbidden", + "LithiumBattery1DischargeForbidden", "LithiumBattery2ChargeForbidden", + "LithiumBattery2DischargeForbidden", "LithiumBattery1Full", "LithiumBattery1DischargeEnd", + "LithiumBattery2Full", "LithiumBattery2DischargeEnd", "LeadBatteryTemperatureAbnormality", + "BatteryAccessMethodError", "Pv1NotAccessed", "Pv1Overvoltage", + "AbnormalPv1CurrentSharing", "Pv1PowerTubeFault", "Pv1SoftStartFailure", + "Pv1OverloadTimeout", "Pv1InsufficientPower", "Photovoltaic1Overcurrent", + "Pv2NotAccessed", "Pv2Overvoltage", "AbnormalPv2CurrentSharing", "Pv2PowerTubeFault", + "Pv2SoftStartFailure", "Pv2OverloadTimeout", "Pv2InsufficientPower", + "Pv3NotConnected", "Pv3Overvoltage", "Pv3AverageCurrentAnomaly", "Pv3PowerTubeFailure", + "Pv3SoftStartFailure", "Pv3OverloadTimeout", "Pv3ReverseConnection", + "Pv4NotConnected", "Pv4Overvoltage", "Pv4AverageCurrentAnomaly", "Pv4PowerTubeFailure", + "Pv4SoftStartFailure", "Pv4OverloadTimeout", "Pv4ReverseConnection", + "InsufficientPhotovoltaicPower", "DcBusOvervoltage", "DcBusUndervoltage", + "DcBusVoltageUnbalance", "BusSlowOvervoltage", "HardwareBusOvervoltage", + "BusSoftStartFailure", "InverterPowerTubeFault", "HardwareOvercurrent", + "DcConverterOvervoltage", "DcConverterHardwareOvervoltage", "DcConverterOvercurrent", + "DcConverterHardwareOvercurrent", "DcConverterResonatorOvercurrent", + "SystemOutputOverload", "InverterOverload", "InverterOverloadTimeout", + "LoadPowerOverload", "BalancedCircuitOverloadTimeout", "InverterSoftStartFailure", + "Dsp1ParameterSettingFault", "Dsp2ParameterSettingFault", "DspVersionCompatibilityFault", + "CpldVersionCompatibilityFault", "CpldCommunicationFault", "DspCommunicationFault", + "OutputVoltageDcOverlimit", "OutputCurrentDcOverlimit", "RelaySelfCheckFails", + "InverterRelayOpen", "InverterRelayShortCircuit", "OpenCircuitOfPowerGridRelay", + "ShortCircuitOfPowerGridRelay", "GeneratorRelayOpenCircuit", "GeneratorRelayShortCircuit", + "AbnormalInverter", "ParallelCommunicationAlarm", "ParallelModuleMissing", + "DuplicateMachineNumbersForParallelModules", "ParameterConflictInParallelModule", + "SystemDerating", "PvAccessMethodErrorAlarm", "ReservedAlarms4", "ReservedAlarms5", + "ReverseMeterConnection", "InverterSealPulse", "AbnormalDieselGeneratorVoltage", + "AbnormalDieselGeneratorFrequency", "DieselGeneratorVoltageReverseSequence", + "DieselGeneratorVoltageOutOfPhase", "GeneratorOverload", + }; + + private static readonly string[] GrowattKeys = + { + "StringFault", "PvStringPidQuickConnectAbnormal", "DcSpdFunctionAbnormal", + "PvShortCircuited", "PvBoostDriverAbnormal", "AcSpdFunctionAbnormal", "DcFuseBlown", + "DcInputVoltageTooHigh", "PvReversed", "PidFunctionAbnormal", "PvStringDisconnected", + "PvStringCurrentUnbalanced", "NoUtilityGrid", "GridVoltageOutOfRange", + "GridFrequencyOutOfRange", "Overload", "MeterDisconnected", "MeterReverselyConnected", + "LinePeVoltageAbnormal", "PhaseSequenceError", "FanFailure", "MeterAbnormal", + "OptimizerCommunicationAbnormal", "OverTemperature", "OverTemperatureAlarm", + "NtcTemperatureSensorBroken", "SyncSignalAbnormal", "GridStartupConditionsNotMet", + "BatteryCommunicationFailure", "BatteryDisconnected", "BatteryVoltageTooHigh", + "BatteryVoltageTooLow", "BatteryReverseConnected", "LeadAcidTempSensorDisconnected", + "BatteryTemperatureOutOfRange", "BmsFault", "LithiumBatteryOverload", + "BmsCommunicationAbnormal", "BatterySpdAbnormal", "OutputDcComponentBiasAbnormal", + "DcComponentOverHighOutputVoltage", "OffGridOutputVoltageTooLow", + "OffGridOutputVoltageTooHigh", "OffGridOutputOverCurrent", "OffGridBusVoltageTooLow", + "OffGridOutputOverload", "BalancedCircuitAbnormal", "ExportLimitationFailSafe", + "DcBiasAbnormal", "HighDcComponentOutputCurrent", "BusVoltageSamplingAbnormal", + "RelayFault", "BusVoltageAbnormal", "InternalCommunicationFailure", + "TemperatureSensorDisconnected", "IgbtDriveFault", "EepromError", + "AuxiliaryPowerAbnormal", "DcAcOvercurrentProtection", "CommunicationProtocolMismatch", + "DspComFirmwareMismatch", "DspSoftwareHardwareMismatch", "CpldAbnormal", + "RedundancySamplingInconsistent", "PwmPassThroughSignalFailure", "AfciSelfTestFailure", + "PvCurrentSamplingAbnormal", "AcCurrentSamplingAbnormal", "BusSoftbootFailure", + "EpoFault", "MonitoringChipBootVerificationFailed", "BmsCommunicationFailure", + "BmsChargeDischargeFailure", "BatteryVoltageLow", "BatteryVoltageHigh", + "BatteryTemperatureAbnormal", "BatteryReversed", "BatteryOpenCircuit", + "BatteryOverloadProtection", "Bus2VoltageAbnormal", "BatteryChargeOcp", + "BatteryDischargeOcp", "BatterySoftStartFailed", "EpsOutputShortCircuited", + "OffGridBusVoltageLow", "OffGridTerminalVoltageAbnormal", "SoftStartFailed", + "OffGridOutputVoltageAbnormal", "BalancedCircuitSelfTestFailed", + "HighDcComponentOutputVoltage", "OffGridParallelSignalAbnormal", "AFCIFault", + "GFCIHigh", "PVVoltageHigh", + }; + + private static readonly string[] AllAlarmKeys = SinexcelKeys.Concat(GrowattKeys).ToArray(); + private static readonly HashSet SinexcelKeySet = new(SinexcelKeys); + + // ── Scheduler ───────────────────────────────────────────────────────────── + + private static Timer? _morningTimer; + private static Timer? _afternoonTimer; + private static bool _synthesizing; + + public static void StartDailyScheduler() + { + LoadGermanNames(); + ScheduleTimer(ref _morningTimer, 8, 0, () => RunMorningJobAsync() .GetAwaiter().GetResult()); + ScheduleTimer(ref _afternoonTimer, 14, 0, () => RunAfternoonJobAsync().GetAwaiter().GetResult()); + Console.WriteLine("[AlarmReviewService] Daily scheduler started (8AM + 2PM jobs)."); + } + + /// Pauses the scheduler (timers stopped) but keeps all progress. Resume with ResumeCampaign(). + public static void StopCampaign() + { + _morningTimer?.Dispose(); + _afternoonTimer?.Dispose(); + _morningTimer = null; + _afternoonTimer = null; + _testBatch = null; + Console.WriteLine("[AlarmReviewService] Campaign paused — progress preserved. Call ResumeCampaign() to restart timers."); + } + + /// Resumes timers without touching progress. Use after StopCampaign() or server restart. + public static void ResumeCampaign() + { + if (!File.Exists(ProgressFile)) + { + Console.WriteLine("[AlarmReviewService] No progress file found — use StartCampaign() to begin."); + return; + } + LoadGermanNames(); + ScheduleTimer(ref _morningTimer, 8, 0, () => RunMorningJobAsync() .GetAwaiter().GetResult()); + ScheduleTimer(ref _afternoonTimer, 14, 0, () => RunAfternoonJobAsync().GetAwaiter().GetResult()); + Console.WriteLine("[AlarmReviewService] Campaign resumed — timers restarted."); + } + + /// Deletes all progress and stops timers. Only use to start over from scratch. + public static void ResetCampaign() + { + _morningTimer?.Dispose(); + _afternoonTimer?.Dispose(); + _morningTimer = null; + _afternoonTimer = null; + _testBatch = null; + + if (File.Exists(ProgressFile)) + File.Delete(ProgressFile); + if (File.Exists(CheckedFilePath)) + File.Delete(CheckedFilePath); + + Console.WriteLine("[AlarmReviewService] Campaign fully reset — all progress deleted."); + } + + private static void ScheduleTimer(ref Timer? timer, int hour, int minute, Action action) + { + var now = DateTime.Now; + var next = now.Date.AddHours(hour).AddMinutes(minute); + if (now >= next) next = next.AddDays(1); + + var delay = next - now; + timer = new Timer(_ => { try { action(); } catch (Exception ex) { Console.Error.WriteLine($"[AlarmReviewService] Timer error: {ex.Message}"); } }, + null, delay, TimeSpan.FromDays(1)); + + Console.WriteLine($"[AlarmReviewService] Next {hour:D2}:{minute:D2} job scheduled at {next:yyyy-MM-dd HH:mm}"); + } + + // ── Morning job (8AM) ────────────────────────────────────────────────────── + + private static async Task RunMorningJobAsync() + { + if (!IsWorkday(DateTime.Now)) + { + Console.WriteLine("[AlarmReviewService] 8AM job skipped — weekend or public holiday."); + return; + } + Console.WriteLine("[AlarmReviewService] Running 8AM morning job..."); + var progress = LoadProgress(); + if (progress == null) return; + + var current = progress.Batches.LastOrDefault(); + if (current == null) return; + + if (current.Synthesized) + { + // Next batch is sent immediately after synthesis — only act here as a safety net + // in case the server restarted before SendNextBatchAsync could run. + var nextAlreadySent = progress.Batches.Count > current.BatchNumber; + if (!nextAlreadySent) + { + Console.WriteLine($"[AlarmReviewService] Batch {current.BatchNumber} was synthesized but next batch not sent — sending now (recovery)."); + await SendNextBatchAsync(progress); + } + } + else + { + var submissionCount = current.Submissions.Values.Count(s => s != null); + + // If the batch was sent today, don't treat 0 submissions as a stall — + // reviewers haven't had a full day yet. Skip and wait for tomorrow's job. + var sentToday = current.SentDate == DateTime.Now.ToString("yyyy-MM-dd"); + if (submissionCount == 0 && sentToday) + { + Console.WriteLine($"[AlarmReviewService] Batch {current.BatchNumber}: sent today, 0 submissions so far — waiting for tomorrow."); + return; + } + + if (submissionCount == 0) + { + const int MaxResends = 3; + if (current.ResendCount >= MaxResends) + { + // No responses after 3 resends — auto-advance using original content + Console.WriteLine($"[AlarmReviewService] Batch {current.BatchNumber}: still 0 submissions after {MaxResends} resends — auto-advancing with original content."); + foreach (var key in current.AlarmKeys) + { + var original = DiagnosticService.TryGetTranslation(key, "de") ?? AlarmKnowledgeBase.TryGetDiagnosis(key); + if (original != null) current.ImprovedEntries[key] = original; + } + current.Synthesized = true; + current.SynthesizedAt = DateTime.UtcNow.ToString("O"); + current.Note = "Auto-advanced after 3 resends with no reviewer responses — original content preserved."; + SaveProgress(progress); + RegenerateCheckedFile(progress); + await SendAdminStallAlertAsync(current); + await SendNextBatchAsync(progress); + } + else + { + current.ResendCount++; + SaveProgress(progress); + Console.WriteLine($"[AlarmReviewService] Batch {current.BatchNumber}: 0 submissions — resending (attempt #{current.ResendCount}/{MaxResends})."); + await SendBatchEmailsAsync(current, isResend: true); + await SendAdminStallAlertAsync(current); + } + } + else + { + // SynthesizeBatchAsync will call SendNextBatchAsync internally when done + await SynthesizeBatchAsync(current, progress); + } + } + } + + private static async Task SendNextBatchAsync(AlarmReviewProgress progress) + { + if (!IsWorkday(DateTime.Now)) + { + Console.WriteLine("[AlarmReviewService] Synthesis complete but today is not a workday — next batch will be sent on the next working day."); + return; // Morning job recovery will send the next batch on the next workday + } + + var nextStartIndex = progress.Batches.Count * BatchSize; + if (nextStartIndex >= AllAlarmKeys.Length) + { + Console.WriteLine("[AlarmReviewService] All 229 alarms reviewed! Sending completion email."); + await SendAdminCompletionEmailAsync(progress); + return; + } + + var batch = CreateNextBatch(progress); + progress.Batches.Add(batch); + SaveProgress(progress); + + await SendBatchEmailsAsync(batch, isResend: false); + + var totalReviewed = progress.Batches.Count(b => b.Synthesized) * BatchSize; + Console.WriteLine($"[AlarmReviewService] Batch {batch.BatchNumber} sent. Progress: {totalReviewed}/{AllAlarmKeys.Length}."); + } + + // ── Afternoon job (2PM) ──────────────────────────────────────────────────── + + private static async Task RunAfternoonJobAsync() + { + if (!IsWorkday(DateTime.Now)) + { + Console.WriteLine("[AlarmReviewService] 2PM job skipped — weekend or public holiday."); + return; + } + Console.WriteLine("[AlarmReviewService] Running 2PM afternoon job..."); + var progress = LoadProgress(); + if (progress == null) return; + + var current = progress.Batches.LastOrDefault(); + if (current == null || current.Synthesized) return; + + foreach (var (name, email) in Reviewers) + { + var key = name.ToLowerInvariant(); + if (!current.Submissions.TryGetValue(key, out var sub) || sub == null) + await SendReminderEmailAsync(current, name, email); + } + } + + // ── Progress persistence ─────────────────────────────────────────────────── + + private static readonly object _fileLock = new(); + private static readonly object _submitLock = new(); // serializes the read-modify-write in SubmitFeedback + + private static AlarmReviewProgress? LoadProgress() + { + if (!File.Exists(ProgressFile)) return null; + try + { + lock (_fileLock) + { + var json = File.ReadAllText(ProgressFile); + return JsonConvert.DeserializeObject(json); + } + } + catch (Exception ex) + { + Console.Error.WriteLine($"[AlarmReviewService] Failed to load progress: {ex.Message}"); + return null; + } + } + + private static void SaveProgress(AlarmReviewProgress p) + { + lock (_fileLock) + { + var json = JsonConvert.SerializeObject(p, Formatting.Indented); + File.WriteAllText(ProgressFile, json); + } + } + + private static BatchRecord CreateNextBatch(AlarmReviewProgress progress) + { + var startIdx = progress.Batches.Count * BatchSize; + var keys = AllAlarmKeys.Skip(startIdx).Take(BatchSize).ToList(); + + return new BatchRecord + { + BatchNumber = progress.Batches.Count + 1, + SentDate = DateTime.Now.ToString("yyyy-MM-dd"), + AlarmKeys = keys, + Submissions = Reviewers.ToDictionary(r => r.Name.ToLowerInvariant(), _ => (ReviewerSubmission?)null), + }; + } + + // ── Public API (called by Controller) ───────────────────────────────────── + + /// Starts the campaign: creates progress file and sends Batch 1. + public static void StartCampaign() + { + if (File.Exists(ProgressFile)) + { + Console.WriteLine("[AlarmReviewService] Campaign already started."); + return; + } + + var progress = new AlarmReviewProgress { StartedAt = DateTime.UtcNow.ToString("O") }; + SaveProgress(progress); + + Task.Run(async () => + { + var batch = CreateNextBatch(progress); + progress.Batches.Add(batch); + SaveProgress(progress); + await SendBatchEmailsAsync(batch, isResend: false); + Console.WriteLine("[AlarmReviewService] Campaign started! Batch 1 sent."); + }).GetAwaiter().GetResult(); + } + + /// + /// Sends a test batch of 10 alarms ONLY to the admin email so they can experience the form + /// before the real campaign starts. Uses reviewer name "Admin" and batch number 0. + /// Does NOT affect the real campaign progress file. + /// + public static async Task SendTestBatchAsync() + { + var testBatch = new BatchRecord + { + BatchNumber = 0, + SentDate = DateTime.Now.ToString("yyyy-MM-dd"), + AlarmKeys = AllAlarmKeys.Take(BatchSize).ToList(), + Submissions = new Dictionary { ["Admin"] = null }, + }; + + var testQuote = DailyQuotes[0]; + var reviewUrl = $"{BaseUrl}/ReviewAlarms?batch=0&reviewer=Admin"; + var html = BuildReviewerEmailHtml( + name: "Rüdiger", + reviewUrl: reviewUrl, + batchNum: 1, + alarmCount: BatchSize, + quote: testQuote, + isResend: false); + + await SendEmailAsync(AdminEmail, $"Alarmprüfung · Stapel 1 von {(int)Math.Ceiling((double)AllAlarmKeys.Length / BatchSize)} — Bitte heute prüfen", html); + + // Also store the test batch in memory so the review page can be served + _testBatch = testBatch; + + Console.WriteLine("[AlarmReviewService] Test batch email sent to admin."); + } + + private static BatchRecord? _testBatch; + + /// Returns the HTML review page for a given batch and reviewer. + public static string? GetReviewPage(int batchNumber, string reviewerName) + { + // Batch 0 = admin test — no auth, no campaign needed + if (batchNumber == 0) + { + var tb = _testBatch; + if (tb == null) return null; + return BuildReviewPage(tb, reviewerName); + } + + var progress = LoadProgress(); + if (progress == null) return null; + + var batch = progress.Batches.FirstOrDefault(b => b.BatchNumber == batchNumber); + if (batch == null) return null; + + if (!Reviewers.Any(r => r.Name.Equals(reviewerName, StringComparison.OrdinalIgnoreCase))) + return null; + + return BuildReviewPage(batch, reviewerName); + } + + /// Saves reviewer feedback. Triggers synthesis if all 4 reviewers have submitted. + public static bool SubmitFeedback(int batchNumber, string? reviewerName, List? feedbacks) + { + if (string.IsNullOrWhiteSpace(reviewerName)) return false; + // Batch 0 = test mode — handled separately in Controller via PreviewSynthesisAsync + if (batchNumber == 0) return true; + + BatchRecord? batchForSynthesis = null; + AlarmReviewProgress? progressForSynthesis = null; + + lock (_submitLock) // atomic read-modify-write prevents two reviewers corrupting the file + { + var progress = LoadProgress(); + if (progress == null) return false; + + var batch = progress.Batches.FirstOrDefault(b => b.BatchNumber == batchNumber); + if (batch == null || batch.Synthesized) return false; + + var reviewerKey = reviewerName.ToLowerInvariant(); + if (!Reviewers.Any(r => r.Name.ToLowerInvariant() == reviewerKey)) return false; + + if (feedbacks == null || feedbacks.Count != batch.AlarmKeys.Count) return false; + if (feedbacks.Any(f => f == null)) return false; + + foreach (var f in feedbacks) + { + f.Explanation ??= ""; + f.Comment ??= ""; + f.Causes = f.Causes?.Select(c => c ?? "").ToList() ?? new List(); + f.NextSteps = f.NextSteps?.Select(s => s ?? "").ToList() ?? new List(); + } + + // Re-submission before synthesis is fine — reviewer can correct a mistake + batch.Submissions[reviewerKey] = new ReviewerSubmission + { + SubmittedAt = DateTime.UtcNow.ToString("O"), + Feedbacks = feedbacks, + }; + SaveProgress(progress); + + var submittedCount = batch.Submissions.Values.Count(s => s != null); + Console.WriteLine($"[AlarmReviewService] Batch {batchNumber}: {reviewerName} submitted ({submittedCount}/{Reviewers.Length})."); + + if (submittedCount == Reviewers.Length) + { + Console.WriteLine($"[AlarmReviewService] Batch {batchNumber}: All {Reviewers.Length} reviewers done — synthesizing immediately."); + batchForSynthesis = batch; + progressForSynthesis = progress; + } + } + + if (batchForSynthesis != null) + _ = Task.Run(async () => await SynthesizeBatchAsync(batchForSynthesis, progressForSynthesis!)); + + return true; + } + + /// + /// Dry-run synthesis for batch 0 (test). Runs AI against submitted feedback and returns + /// HTML showing before/after for each alarm — nothing is saved to disk. + /// + public static async Task PreviewSynthesisAsync(List? feedbacks) + { + var testBatch = _testBatch; + if (testBatch == null) + return "
⚠️
Test-Batch abgelaufen
Bitte erneut einen Test-E-Mail senden und nochmal versuchen.
"; + + if (feedbacks == null || feedbacks.Count != testBatch.AlarmKeys.Count || feedbacks.Any(f => f == null)) + return "
⚠️
Ungültige Eingabe
"; + + foreach (var f in feedbacks) + { + f.Explanation ??= ""; + f.Comment ??= ""; + f.Causes = f.Causes?.Select(c => c ?? "").ToList() ?? new List(); + f.NextSteps = f.NextSteps?.Select(s => s ?? "").ToList() ?? new List(); + } + + var mistralAvailable = !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("MISTRAL_API_KEY")); + + // Run all synthesis calls in parallel + var synthTasks = testBatch.AlarmKeys.Select(async (key, i) => + { + var original = DiagnosticService.TryGetTranslation(key, "de") ?? AlarmKnowledgeBase.TryGetDiagnosis(key); + var fb = feedbacks[i]; + var anyChanges = !fb.ExplanationOk || !fb.CausesOk || !fb.StepsOk; + + DiagnosticResponse? synthesized = null; + if (anyChanges && mistralAvailable && original != null) + synthesized = await CallMistralForSynthesisAsync(key, original, new List { fb }); + + return (key, original, synthesized, fb, anyChanges); + }); + var results = await Task.WhenAll(synthTasks); + + var sb = new StringBuilder(); + sb.Append("
"); + sb.Append("
"); + sb.Append("
Synthese-Vorschau (Testlauf)
"); + sb.Append("
Nichts wurde gespeichert. Hier sehen Sie, was die KI mit Ihren Änderungen synthetisieren würde:
"); + sb.Append("
"); + + if (!mistralAvailable) + sb.Append("
⚠️ Mistral API nicht konfiguriert — Es werden Ihre Änderungen angezeigt, ohne KI-Synthese.
"); + + foreach (var (key, original, synthesized, fb, anyChanges) in results) + { + if (original == null) continue; + var label = GermanName(key); + var badgeClass = SinexcelKeySet.Contains(key) ? "sin" : "gro"; + var badgeName = SinexcelKeySet.Contains(key) ? "Sinexcel" : "Growatt"; + var statusText = !anyChanges ? "Keine Änderungen" : (synthesized != null ? "KI synthetisiert" : "Ihre Änderung (kein KI)"); + var statusColor = !anyChanges ? "#27ae60" : (synthesized != null ? "#e67e22" : "#888"); + + // What will actually be used: AI result, or reviewer's direct edit if no AI + var finalResult = synthesized ?? new DiagnosticResponse + { + Explanation = fb.ExplanationOk ? original.Explanation : fb.Explanation, + Causes = fb.CausesOk ? original.Causes : fb.Causes, + NextSteps = fb.StepsOk ? original.NextSteps : fb.NextSteps, + }; + + sb.Append("
"); + sb.Append($"
{badgeName}{System.Web.HttpUtility.HtmlEncode(label)}{statusText}
"); + + if (!anyChanges) + { + sb.Append("
✓ Alle Abschnitte als korrekt markiert — keine Änderungen.
"); + } + else + { + sb.Append(""); + sb.Append(""); + + // Explanation + sb.Append($""); + sb.Append($""); + + // Causes + sb.Append(""); + + // Next Steps + sb.Append(""); + + sb.Append("
Vorher (Original)Nachher (Synthese)
{System.Web.HttpUtility.HtmlEncode(original.Explanation)}{System.Web.HttpUtility.HtmlEncode(finalResult.Explanation)}
"); + sb.Append("
URSACHEN
"); + foreach (var c in original.Causes) sb.Append($"
• {System.Web.HttpUtility.HtmlEncode(c)}
"); + sb.Append("		"); + sb.Append("
URSACHEN
"); + foreach (var c in finalResult.Causes) sb.Append($"
• {System.Web.HttpUtility.HtmlEncode(c)}
"); + sb.Append("
"); + sb.Append("
WAS ZU TUN IST
"); + foreach (var s in original.NextSteps) sb.Append($"
• {System.Web.HttpUtility.HtmlEncode(s)}
"); + sb.Append("		"); + sb.Append("
WAS ZU TUN IST
"); + foreach (var s in finalResult.NextSteps) sb.Append($"
• {System.Web.HttpUtility.HtmlEncode(s)}
"); + sb.Append("
"); + } + + sb.Append("
"); // close .card + } + + sb.Append("
"); + return sb.ToString(); + } + + /// Returns campaign status as an anonymous object (serialized to JSON by Controller). + public static object GetStatus() + { + var progress = LoadProgress(); + if (progress == null) return new { started = false }; + + var synthesized = progress.Batches.Count(b => b.Synthesized); + var totalReviewed = Math.Min(synthesized * BatchSize, AllAlarmKeys.Length); + var current = progress.Batches.LastOrDefault(); + var totalBatches = (int)Math.Ceiling((double)AllAlarmKeys.Length / BatchSize); + + return new + { + started = true, + startedAt = progress.StartedAt, + totalAlarms = AllAlarmKeys.Length, + reviewedAlarms = totalReviewed, + percentComplete = Math.Round((double)totalReviewed / AllAlarmKeys.Length * 100, 1), + completedBatches = synthesized, + totalBatches, + currentBatch = current == null ? null : (object)new + { + batchNumber = current.BatchNumber, + sentDate = current.SentDate, + synthesized = current.Synthesized, + resendCount = current.ResendCount, + submissions = current.Submissions.ToDictionary( + kv => kv.Key, + kv => kv.Value != null ? (object)new { submitted = true, at = kv.Value.SubmittedAt } : null), + }, + }; + } + + /// Returns an HTML correction form pre-filled with the current synthesized content for a specific alarm. + public static string GetCorrectionPage(int batchNumber, string alarmKey) + { + var progress = LoadProgress(); + var batch = progress?.Batches.FirstOrDefault(b => b.BatchNumber == batchNumber); + if (batch == null || !batch.ImprovedEntries.TryGetValue(alarmKey, out var entry)) + return "

Alarm not found.

"; + + var label = GermanName(alarmKey); + var causesJson = Newtonsoft.Json.JsonConvert.SerializeObject(entry.Causes); + var stepsJson = Newtonsoft.Json.JsonConvert.SerializeObject(entry.NextSteps); + var submitUrl = $"{BaseUrl}/ApplyAlarmCorrection"; + + return $$""" + + Korrektur — {{System.Web.HttpUtility.HtmlEncode(label)}} + + +
Alarm-Korrektur
{{System.Web.HttpUtility.HtmlEncode(label)}}
+ + + +
+ +
+ +
+ + """; + } + + /// Applies an admin correction to a specific alarm entry and regenerates the checked file. + public static bool ApplyCorrection(int batchNumber, string alarmKey, DiagnosticResponse correction) + { + if (string.IsNullOrWhiteSpace(correction.Explanation) || + correction.Causes == null || correction.Causes.Count == 0 || + correction.NextSteps == null || correction.NextSteps.Count == 0) + return false; + + lock (_fileLock) + { + var progress = LoadProgress(); + var batch = progress?.Batches.FirstOrDefault(b => b.BatchNumber == batchNumber); + if (batch == null) return false; + + batch.ImprovedEntries[alarmKey] = correction; + SaveProgress(progress!); + } + + // Regenerate outside the lock — reads progress fresh + var prog = LoadProgress(); + if (prog != null) RegenerateCheckedFile(prog); + Console.WriteLine($"[AlarmReviewService] Admin correction applied for {alarmKey} (batch {batchNumber})."); + return true; + } + + /// Returns the generated AlarmTranslationsChecked.de.json content for download. + public static string? GetCheckedFileContent() + { + if (!File.Exists(CheckedFilePath)) return null; + return File.ReadAllText(CheckedFilePath); + } + + // ── Synthesis ────────────────────────────────────────────────────────────── + + private static async Task SynthesizeBatchAsync(BatchRecord batch, AlarmReviewProgress progress) + { + if (_synthesizing || batch.Synthesized) return; + _synthesizing = true; + + try + { + Console.WriteLine($"[AlarmReviewService] Synthesizing batch {batch.BatchNumber}..."); + + var submissions = batch.Submissions.Values.Where(s => s != null).Select(s => s!).ToList(); + if (submissions.Count == 0) + { + Console.WriteLine($"[AlarmReviewService] Batch {batch.BatchNumber}: No submissions — skipping synthesis."); + return; + } + + for (int i = 0; i < batch.AlarmKeys.Count; i++) + { + var alarmKey = batch.AlarmKeys[i]; + var original = DiagnosticService.TryGetTranslation(alarmKey, "de") ?? AlarmKnowledgeBase.TryGetDiagnosis(alarmKey); + if (original == null) continue; + + var feedbacks = submissions + .Where(s => i < s.Feedbacks.Count) + .Select(s => s.Feedbacks[i]) + .ToList(); + + var anyChanges = feedbacks.Any(f => !f.ExplanationOk || !f.CausesOk || !f.StepsOk); + + if (!anyChanges) + { + batch.ImprovedEntries[alarmKey] = original; + continue; + } + + var improved = await CallMistralForSynthesisAsync(alarmKey, original, feedbacks); + + // If AI output is rejected by validation, fall back to reviewer's direct edit + // (not the original) so reviewer changes are always respected. + batch.ImprovedEntries[alarmKey] = improved ?? BuildReviewerDirectEdit(original, feedbacks); + } + + batch.Synthesized = true; + batch.SynthesizedAt = DateTime.UtcNow.ToString("O"); + SaveProgress(progress); + + RegenerateCheckedFile(progress); + + var improved2 = batch.ImprovedEntries.Count(kv => + { + var orig = AlarmKnowledgeBase.TryGetDiagnosis(kv.Key); + return orig != null && kv.Value.Explanation != orig.Explanation; + }); + Console.WriteLine($"[AlarmReviewService] Batch {batch.BatchNumber} synthesized. ~{improved2} alarms changed by AI."); + + var totalReviewed = progress.Batches.Count(b => b.Synthesized) * BatchSize; + await SendAdminDailySummaryAsync(batch, Math.Min(totalReviewed, AllAlarmKeys.Length)); + + // Send next batch immediately after synthesis — no need to wait for 8AM + await SendNextBatchAsync(progress); + } + finally + { + _synthesizing = false; + } + } + + // ── Mistral synthesis call ───────────────────────────────────────────────── + + private const string MistralUrl = "https://api.mistral.ai/v1/chat/completions"; + + private static async Task CallMistralForSynthesisAsync( + string alarmKey, DiagnosticResponse original, List feedbacks) + { + var apiKey = Environment.GetEnvironmentVariable("MISTRAL_API_KEY"); + if (string.IsNullOrWhiteSpace(apiKey)) return null; + + var deviceType = SinexcelKeySet.Contains(alarmKey) ? "Sinexcel" : "Growatt"; + var prompt = BuildSynthesisPrompt(alarmKey, deviceType, original, feedbacks); + + try + { + var requestBody = new + { + model = "mistral-large-latest", + messages = new[] { new { role = "user", content = prompt } }, + max_tokens = 600, + temperature = 0.1, + }; + + var responseText = await MistralUrl + .WithHeader("Authorization", $"Bearer {apiKey}") + .PostJsonAsync(requestBody) + .ReceiveString(); + + var envelope = JsonConvert.DeserializeObject(responseText); + var content = (string?)envelope?.choices?[0]?.message?.content; + if (string.IsNullOrWhiteSpace(content)) return null; + + var json = content.Trim(); + if (json.StartsWith("```")) + { + var nl = json.IndexOf('\n'); + if (nl >= 0) json = json[(nl + 1)..]; + if (json.EndsWith("```")) json = json[..^3]; + json = json.Trim(); + } + + var result = JsonConvert.DeserializeObject(json); + return ValidateSynthesisOutput(result, feedbacks, alarmKey); + } + catch (Exception ex) + { + Console.Error.WriteLine($"[AlarmReviewService] Mistral failed for {alarmKey}: {ex.Message}"); + return null; + } + } + + private static string BuildSynthesisPrompt( + string alarmKey, string deviceType, DiagnosticResponse original, List feedbacks) + { + var sb = new StringBuilder(); + sb.AppendLine("You are a documentation specialist for residential solar+battery systems (Sinexcel/Growatt inverters)."); + sb.AppendLine("Synthesize the ORIGINAL alarm content with REVIEWER FEEDBACK to produce an IMPROVED version."); + sb.AppendLine(); + sb.AppendLine($"Alarm: {SplitCamelCase(alarmKey)} ({deviceType})"); + sb.AppendLine(); + sb.AppendLine("ORIGINAL:"); + sb.AppendLine($" Explanation: {original.Explanation}"); + sb.AppendLine(" Causes:"); + foreach (var c in original.Causes) sb.AppendLine($" - {c}"); + sb.AppendLine(" Next Steps:"); + foreach (var s in original.NextSteps) sb.AppendLine($" - {s}"); + sb.AppendLine(); + sb.AppendLine($"REVIEWER FEEDBACK ({feedbacks.Count} reviewer(s)):"); + + for (int i = 0; i < feedbacks.Count; i++) + { + var f = feedbacks[i]; + sb.AppendLine($" Reviewer {i + 1}:"); + sb.AppendLine($" Explanation: {(f.ExplanationOk ? "Approved as-is" : $"Changed to: \"{f.Explanation}\"")}"); + if (!f.CausesOk) + { + sb.AppendLine(" Causes: Changed to:"); + foreach (var c in f.Causes) sb.AppendLine($" - {c}"); + } + else sb.AppendLine(" Causes: Approved as-is"); + if (!f.StepsOk) + { + sb.AppendLine(" Next Steps: Changed to:"); + foreach (var s in f.NextSteps) sb.AppendLine($" - {s}"); + } + else sb.AppendLine(" Next Steps: Approved as-is"); + if (!string.IsNullOrWhiteSpace(f.Comment)) sb.AppendLine($" Notes: {f.Comment}"); + } + + sb.AppendLine(); + sb.AppendLine("SYNTHESIS RULES:"); + sb.AppendLine("- The original content is already in German. Output must also be in German."); + sb.AppendLine("- Use simple plain language suitable for homeowners, NOT technical jargon."); + sb.AppendLine("- For each section (Explanation / Causes / Next Steps):"); + sb.AppendLine(" * If reviewer marked it 'Approved as-is': keep the original text exactly, no changes."); + sb.AppendLine(" * If reviewer provided a changed list: output EXACTLY those items — same count, same meaning."); + sb.AppendLine(" DO NOT add, remove, merge, or invent any bullets. Only improve the German phrasing."); + sb.AppendLine("- If multiple reviewers changed the same section, pick the best version or merge carefully."); + sb.AppendLine("- Explanation: 1 sentence, max 25 words."); + sb.AppendLine(); + sb.AppendLine("Reply with ONLY valid JSON, no markdown fences:"); + sb.AppendLine("{\"explanation\":\"...\",\"causes\":[\"...\"],\"nextSteps\":[\"...\"]}"); + + return sb.ToString(); + } + + /// + /// Validates AI synthesis output. Returns null (reject) if output is structurally bad + /// so the caller can fall back to the reviewer's direct edit instead. + /// + private static DiagnosticResponse? ValidateSynthesisOutput( + DiagnosticResponse? result, List feedbacks, string alarmKey) + { + if (result == null) return null; + + // Must have non-empty content + if (string.IsNullOrWhiteSpace(result.Explanation)) + { + Console.Error.WriteLine($"[AlarmReviewService] Validation failed for {alarmKey}: empty explanation."); + return null; + } + if (result.Causes == null || result.Causes.Count == 0) + { + Console.Error.WriteLine($"[AlarmReviewService] Validation failed for {alarmKey}: empty causes."); + return null; + } + if (result.NextSteps == null || result.NextSteps.Count == 0) + { + Console.Error.WriteLine($"[AlarmReviewService] Validation failed for {alarmKey}: empty nextSteps."); + return null; + } + + // If reviewer changed causes, output must have the exact same count + var causesFeedback = feedbacks.FirstOrDefault(f => !f.CausesOk); + if (causesFeedback != null && result.Causes.Count != causesFeedback.Causes.Count) + { + Console.Error.WriteLine($"[AlarmReviewService] Validation failed for {alarmKey}: causes count mismatch " + + $"(expected {causesFeedback.Causes.Count}, got {result.Causes.Count})."); + return null; + } + + // If reviewer changed steps, output must have the exact same count + var stepsFeedback = feedbacks.FirstOrDefault(f => !f.StepsOk); + if (stepsFeedback != null && result.NextSteps.Count != stepsFeedback.NextSteps.Count) + { + Console.Error.WriteLine($"[AlarmReviewService] Validation failed for {alarmKey}: nextSteps count mismatch " + + $"(expected {stepsFeedback.NextSteps.Count}, got {result.NextSteps.Count})."); + return null; + } + + return result; + } + + /// + /// Builds a DiagnosticResponse from the reviewer's direct edits (majority vote per section). + /// Used when AI output is rejected by validation. + /// + private static DiagnosticResponse BuildReviewerDirectEdit( + DiagnosticResponse original, List feedbacks) + { + // For explanation: use first reviewer who changed it, else keep original + var expFeedback = feedbacks.FirstOrDefault(f => !f.ExplanationOk); + var explanation = expFeedback != null ? expFeedback.Explanation : original.Explanation; + + // For causes: use first reviewer who changed it, else keep original + var causesFeedback = feedbacks.FirstOrDefault(f => !f.CausesOk); + var causes = causesFeedback != null ? causesFeedback.Causes : original.Causes; + + // For steps: use first reviewer who changed it, else keep original + var stepsFeedback = feedbacks.FirstOrDefault(f => !f.StepsOk); + var steps = stepsFeedback != null ? stepsFeedback.NextSteps : original.NextSteps; + + return new DiagnosticResponse + { + Explanation = explanation, + Causes = causes, + NextSteps = steps, + }; + } + + // ── AlarmTranslationsChecked.de.json generation ─────────────────────────── + + private static void RegenerateCheckedFile(AlarmReviewProgress progress) + { + // Collect all improved entries across all synthesized batches + var improved = new Dictionary(); + foreach (var batch in progress.Batches.Where(b => b.Synthesized)) + foreach (var kv in batch.ImprovedEntries) + improved[kv.Key] = kv.Value; + + // Build the JSON dict: alarmKey → {Explanation, Causes, NextSteps} + // For unreviewed alarms fall back to the existing German translation + var output = new Dictionary(); + foreach (var key in AllAlarmKeys) + { + var entry = improved.TryGetValue(key, out var imp) + ? imp + : DiagnosticService.TryGetTranslation(key, "de") ?? AlarmKnowledgeBase.TryGetDiagnosis(key); + if (entry == null) continue; + output[key] = new { entry.Explanation, entry.Causes, entry.NextSteps }; + } + + var json = JsonConvert.SerializeObject(output, Formatting.Indented); + var totalReviewed = Math.Min(progress.Batches.Count(b => b.Synthesized) * BatchSize, AllAlarmKeys.Length); + Directory.CreateDirectory(ResourcesDir); + File.WriteAllText(CheckedFilePath, json, System.Text.Encoding.UTF8); + Console.WriteLine($"[AlarmReviewService] AlarmTranslationsChecked.de.json written ({totalReviewed}/{AllAlarmKeys.Length} reviewed)."); + } + + private static void AppendEntry(StringBuilder sb, string key, Dictionary improved) + { + var isReviewed = improved.ContainsKey(key); + var entry = isReviewed ? improved[key] : AlarmKnowledgeBase.TryGetDiagnosis(key); + if (entry == null) + { + Console.Error.WriteLine($"[AlarmReviewService] Warning: no entry found for key '{key}' — skipping."); + return; + } + + sb.AppendLine($" [\"{key}\"] = new()"); + sb.AppendLine(" {"); + sb.AppendLine($" Explanation = \"{EscapeForCSharp(entry.Explanation)}\","); + sb.AppendLine(" Causes = new[]"); + sb.AppendLine(" {"); + foreach (var c in entry.Causes) sb.AppendLine($" \"{EscapeForCSharp(c)}\","); + sb.AppendLine(" },"); + sb.AppendLine(" NextSteps = new[]"); + sb.AppendLine(" {"); + foreach (var s in entry.NextSteps) sb.AppendLine($" \"{EscapeForCSharp(s)}\","); + sb.AppendLine(" }"); + sb.AppendLine(" },"); + } + + // ── HTML review page ─────────────────────────────────────────────────────── + + private static string BuildReviewPage(BatchRecord batch, string reviewerName) + { + var alarmData = batch.AlarmKeys.Select(key => + { + var diag = AlarmKnowledgeBase.TryGetDiagnosis(key); + return new + { + key, + deviceType = SinexcelKeySet.Contains(key) ? "Sinexcel" : "Growatt", + displayName = GermanName(key), + explanation = DiagnosticService.TryGetTranslation(key, "de")?.Explanation ?? diag?.Explanation ?? "", + causes = (DiagnosticService.TryGetTranslation(key, "de")?.Causes ?? diag?.Causes)?.ToList() ?? new List(), + nextSteps = (DiagnosticService.TryGetTranslation(key, "de")?.NextSteps ?? diag?.NextSteps)?.ToList() ?? new List(), + }; + }); + + var alarmsJson = JsonConvert.SerializeObject(alarmData); + var submitUrl = $"{BaseUrl}/SubmitAlarmReview?batch={batch.BatchNumber}&reviewer={Uri.EscapeDataString(reviewerName)}"; + // Include a content hash in the key so stale localStorage is auto-invalidated when translations change + var contentHash = (Math.Abs(alarmsJson.GetHashCode()) % 100000).ToString(); + var lsKey = $"ar-b{batch.BatchNumber}-{reviewerName.ToLowerInvariant()}-{contentHash}"; + var total = batch.AlarmKeys.Count; + var quote = DailyQuotes[(Math.Max(0, batch.BatchNumber - 1)) % DailyQuotes.Length]; + + // Use string.Replace placeholders to avoid C# vs JS brace conflicts + var html = HtmlTemplate + .Replace("%%REVIEWER%%", reviewerName) + .Replace("%%BATCH%%", batch.BatchNumber.ToString()) + .Replace("%%TOTAL%%", total.ToString()) + .Replace("%%ALARMS_JSON%%", alarmsJson) + .Replace("%%SUBMIT_URL%%", submitUrl) + .Replace("%%LS_KEY%%", lsKey) + .Replace("%%QUOTE%%", quote); + + return html; + } + + // The HTML template uses %%PLACEHOLDER%% for C# injection, avoids escaping conflicts + private const string HtmlTemplate = """ + + + + + +Alarmprüfung · Stapel %%BATCH%% + + + +
+
Alarmwissensdatenbank – Überprüfung
+
Hallo %%REVIEWER%%  ·  Stapel %%BATCH%%
+
+
+
%%QUOTE%%
+
+ +
Vielen Dank für Ihre Zeit — Ihr Beitrag macht einen echten Unterschied für unsere Kunden. 🙏
+
inesco Energy Monitor
+ + + +"""; + + // ── Email builders ───────────────────────────────────────────────────────── + + private static readonly string[] DailyQuotes = + { + "Jeder Alarm, den Sie verbessern, hilft einem echten Hausbesitzer, ruhiger zu schlafen. ⚡", + "Sie sind die letzte Verteidigungslinie zwischen verwirrendem Fachjargon und einem besorgten Kunden. 🛡️", + "Eine klare Erklärung heute erspart morgen einen nächtlichen Support-Anruf. 🌙", + "Gute Dokumentation ist ein Akt der Freundlichkeit gegenüber jemandem, den man nie treffen wird. 🤝", + "Irgendwo da draußen liest ein Kunde Ihre Worte um 2 Uhr nachts. Machen Sie sie beruhigend. 🌟", + "Klarheit ist eine Superkraft. Heute setzen Sie sie ein. 💪", + "Die beste Alarmmeldung ist eine, bei der der Kunde sagt: 'Ach so, das macht Sinn'. 💡", + "Ihre 10 Minuten heute könnten hunderten von Kunden stundenlange Verwirrung ersparen. ⏱️", + "Einfache Sprache ist schwer. Danke, dass Sie sich die Zeit nehmen, es richtig zu machen. ✍️", + "Hinter jedem Alarmcode steckt ein echter Mensch, der einfach wissen möchte, ob sein Zuhause sicher ist. 🏠", + "Sie übersetzen nicht nur Text — Sie übersetzen Ingenieursprache in Menschensprache. 🌍", + "Großartige Arbeit sieht nicht immer dramatisch aus. Manchmal sieht sie so aus wie 'Passt so' zu klicken. ✅", + "Eine gut geschriebene Schritt-Liste ist tausend Support-E-Mails wert. 📋", + "Sie machen die Plattform für alle besser. Das zählt. 🌱", + "Fachliche Genauigkeit + einfache Sprache = ein zufriedener Kunde. Sie sind die Brücke. 🌉", + "Auch Roboter brauchen Menschen, die ihre Hausaufgaben prüfen. Danke, dass Sie dieser Mensch sind. 🤖", + "Ihr Fachwissen von heute wird morgen die Sicherheit eines anderen. ☀️", + "Gute Alarmmeldungen informieren nicht nur — sie beruhigen. Sie kennen den Unterschied. 🎯", + "Jede Änderung, die Sie vornehmen, ist ein kleiner Sieg der Klarheit über die Verwirrung. 🏆", + "Irgendwo arbeitet eine Solarbatterie still vor sich hin. Ihre Arbeit hilft zu erklären, wenn das nicht so ist. 🔋", + "Das Support-Team der Zukunft wird dankbar sein, dass es diesen Alarm nicht erklären muss. 😄", + "Sie können Alarme nicht verhindern — aber Sie können dafür sorgen, dass die Leute sie verstehen. 💬", + "Diese Kampagne endet in ca. 23 Tagen. Die verbesserte Wissensdatenbank wird viel länger bestehen. 📚", + }; + + private static string BuildReviewerEmailHtml(string name, string reviewUrl, int batchNum, int alarmCount, string quote, bool isResend) + { + var urgentBanner = isResend + ? """
⚠️ Noch keine Rückmeldungen eingegangen. Dieselben Alarme werden erneut gesendet. Bitte bis 8:00 Uhr morgen früh einreichen.
""" + : ""; + + return $""" + + + +
+ + + + +
+
Alarmwissensdatenbank – Überprüfung
+
Stapel {batchNum} · {alarmCount} Alarme
+
+ {urgentBanner} +

Hallo {name},

+

Bitte überprüfen Sie heute die {alarmCount} Alarmbeschreibungen und markieren Sie jede als 'Passt so' oder bearbeiten Sie sie, um sie zu verbessern. Dies dauert etwa 10 Minuten.

+

⏰ Bitte bis 8:00 Uhr morgen früh abschließen.

+ +
+ {quote} +
+

Vielen Dank für Ihre Zeit — Ihr Beitrag macht einen echten Unterschied für unsere Kunden. 🙏

+
+ inesco Energy Monitor +
+ """; + } + + private static async Task SendBatchEmailsAsync(BatchRecord batch, bool isResend) + { + var quote = DailyQuotes[(batch.BatchNumber - 1) % DailyQuotes.Length]; + + foreach (var (name, email) in Reviewers) + { + var reviewUrl = $"{BaseUrl}/ReviewAlarms?batch={batch.BatchNumber}&reviewer={Uri.EscapeDataString(name)}"; + var subject = isResend + ? $"[Erneut gesendet] Alarmprüfung Stapel {batch.BatchNumber} — Keine Rückmeldungen" + : $"Alarmprüfung · Stapel {batch.BatchNumber} von {(int)Math.Ceiling((double)AllAlarmKeys.Length / BatchSize)} — Bitte heute prüfen"; + + var html = BuildReviewerEmailHtml(name, reviewUrl, batch.BatchNumber, batch.AlarmKeys.Count, quote, isResend); + await SendEmailAsync(email, subject, html); + } + + // Notify admin with a preview of what reviewers received + await SendAdminBatchDispatchNoticeAsync(batch, isResend); + } + + private static async Task SendAdminBatchDispatchNoticeAsync(BatchRecord batch, bool isResend) + { + var totalBatches = (int)Math.Ceiling((double)AllAlarmKeys.Length / BatchSize); + var action = isResend ? "erneut gesendet" : "gesendet"; + var subject = $"[Admin] Stapel {batch.BatchNumber}/{totalBatches} {action} an {Reviewers.Length} Prüfer"; + + var previewUrl = $"{BaseUrl}/ReviewAlarms?batch={batch.BatchNumber}&reviewer={Uri.EscapeDataString(Reviewers[0].Name)}"; + var reviewerList = string.Join(", ", Reviewers.Select(r => r.Name)); + + var alarmRows = string.Join("\n", batch.AlarmKeys.Select((key, i) => + $"""{i + 1}. {SplitCamelCase(key)} ({(SinexcelKeySet.Contains(key) ? "Sinexcel" : "Growatt")})""")); + + var html = $""" + + +

Stapel {batch.BatchNumber} {action}

+

{DateTime.Now:yyyy-MM-dd HH:mm} · {batch.AlarmKeys.Count} Alarme · Deadline: 8:00 Uhr morgen früh

+ +

Gesendet an: {reviewerList}

+ +

+ Formular ansehen → + (alle Prüfer sehen denselben Inhalt) +

+ +

Alarme in diesem Stapel

+ + {alarmRows} +
+ +

Diese E-Mail dient nur zur Information — keine Aktion erforderlich.

+ + """; + + await SendEmailAsync(AdminEmail, subject, html); + } + + private static async Task SendReminderEmailAsync(BatchRecord batch, string name, string email) + { + var reviewUrl = $"{BaseUrl}/ReviewAlarms?batch={batch.BatchNumber}&reviewer={Uri.EscapeDataString(name)}"; + var subject = $"Erinnerung: Alarmprüfung Stapel {batch.BatchNumber} bis 8:00 Uhr morgen früh abschließen"; + var html = $""" + + +

Hallo {name},

+

Kurze Erinnerung — die heutige Alarmprüfung (Stapel {batch.BatchNumber}) schließt um 8:00 Uhr morgen früh. Es dauert nur 10 Minuten!

+

Überprüfung abschließen →

+

inesco Energy Monitor

+ + """; + await SendEmailAsync(email, subject, html); + } + + private static async Task SendAdminDailySummaryAsync(BatchRecord batch, int totalReviewed) + { + var submitted = batch.Submissions.Where(kv => kv.Value != null).Select(kv => kv.Key).ToList(); + var totalBatches = (int)Math.Ceiling((double)AllAlarmKeys.Length / BatchSize); + var pct = Math.Round((double)totalReviewed / AllAlarmKeys.Length * 100, 1); + var subject = $"[Alarm Review] Batch {batch.BatchNumber}/{totalBatches} synthesized — {totalReviewed}/{AllAlarmKeys.Length} alarms done ({pct}%)"; + + // Build before/after section for each alarm in the batch + var beforeAfterRows = new StringBuilder(); + foreach (var key in batch.AlarmKeys) + { + var original = DiagnosticService.TryGetTranslation(key, "de") ?? AlarmKnowledgeBase.TryGetDiagnosis(key); + var improved = batch.ImprovedEntries.TryGetValue(key, out var imp) ? imp : null; + var label = GermanName(key); + var changed = improved != null && + (improved.Explanation != original?.Explanation || + !improved.Causes.SequenceEqual(original?.Causes ?? Array.Empty()) || + !improved.NextSteps.SequenceEqual(original?.NextSteps ?? Array.Empty())); + + var statusColor = changed ? "#e67e22" : "#27ae60"; + var statusText = changed ? "KI aktualisiert" : "Unverändert"; + var correctUrl = $"{BaseUrl}/CorrectAlarm?batch={batch.BatchNumber}&key={Uri.EscapeDataString(key)}"; + + beforeAfterRows.Append($""" + + {System.Web.HttpUtility.HtmlEncode(label)} +  {statusText} + {(changed ? $" ✏ Korrigieren" : "")} + + """); + + // Explanation + var origExp = original?.Explanation ?? "(none)"; + var newExp = improved?.Explanation ?? origExp; + beforeAfterRows.Append($""" + + Vorher (Deutsch) + Nachher (KI) + + + {System.Web.HttpUtility.HtmlEncode(origExp)} + {System.Web.HttpUtility.HtmlEncode(newExp)} + + """); + + // Causes + var origCauses = original?.Causes ?? Array.Empty(); + var newCauses = improved?.Causes ?? origCauses; + beforeAfterRows.Append($""" + + +
Ursachen
+ {string.Join("", origCauses.Select(c => $"
• {System.Web.HttpUtility.HtmlEncode(c)}
"))} + + +
Ursachen
+ {string.Join("", newCauses.Select(c => $"
• {System.Web.HttpUtility.HtmlEncode(c)}
"))} + + + """); + + // Steps + var origSteps = original?.NextSteps ?? Array.Empty(); + var newSteps = improved?.NextSteps ?? origSteps; + beforeAfterRows.Append($""" + + +
Was zu tun ist
+ {string.Join("", origSteps.Select(s => $"
• {System.Web.HttpUtility.HtmlEncode(s)}
"))} + + +
Was zu tun ist
+ {string.Join("", newSteps.Select(s => $"
• {System.Web.HttpUtility.HtmlEncode(s)}
"))} + + + """); + } + + var html = $""" + + +

Batch {batch.BatchNumber} Synthesized

+

{DateTime.Now:yyyy-MM-dd HH:mm}

+ + + + + +
Reviewers responded{submitted.Count}/{Reviewers.Length} ({string.Join(", ", submitted)})
Overall progress{totalReviewed} / {AllAlarmKeys.Length} ({pct}%)
+

Vorher → Nachher

+

Rot = Original · Grün = synthetisiertes Ergebnis

+ + {beforeAfterRows} +
+

inesco Energy Monitor

+ + """; + + await SendEmailAsync(AdminEmail, subject, html); + } + + private static async Task SendAdminStallAlertAsync(BatchRecord batch) + { + var subject = $"[Alarm Review] ⚠️ Batch {batch.BatchNumber} stalled — no responses (resend #{batch.ResendCount})"; + var html = $""" + + +

Alarm Review — Batch {batch.BatchNumber} Stalled

+

No reviewer has responded to Batch {batch.BatchNumber}. The batch has been resent (attempt #{batch.ResendCount}).

+

Alarms: {string.Join(", ", batch.AlarmKeys)}

+ + """; + await SendEmailAsync(AdminEmail, subject, html); + } + + private static async Task SendAdminCompletionEmailAsync(AlarmReviewProgress progress) + { + var subject = "✅ Alarm Review Campaign Complete — Ready for Cutover"; + var html = $""" + + +

✅ Alarm Review Campaign Complete

+

All 229 alarms have been reviewed and synthesized.

+

AlarmTranslationsChecked.de.json is ready on the server at Resources/AlarmTranslationsChecked.de.json.

+

Next Steps

+
    +
  1. On your local machine, pull the latest Resources/ folder from the server
    2. +
  2. Run generate_alarm_translations.py — reads AlarmTranslationsChecked.de.json, generates en.json, fr.json, it.json
    3. +
  3. Update DiagnosticService to load AlarmTranslations.en.json for English
    4. +
  4. Deploy: cd csharp/App/Backend && ./deploy.sh
    5. +
+

Campaign Summary

+ + + + + +
Started{progress.StartedAt[..10]}
Completed{DateTime.Now:yyyy-MM-dd}
Total batches{progress.Batches.Count}
Alarms reviewed229
+ + """; + await SendEmailAsync(AdminEmail, subject, html); + } + + // ── Email infrastructure ─────────────────────────────────────────────────── + + private static async Task SendEmailAsync(string toEmail, string subject, string htmlBody) + { + try + { + var config = await ReadMailerConfigAsync(); + var msg = new MimeMessage(); + msg.From.Add(new MailboxAddress(config.SenderName, config.SenderAddress)); + msg.To.Add(new MailboxAddress(toEmail, toEmail)); + msg.Subject = subject; + msg.Body = new TextPart("html") { Text = htmlBody }; + + using var smtp = new SmtpClient(); + await smtp.ConnectAsync(config.SmtpServerUrl, config.SmtpPort, SecureSocketOptions.StartTls); + await smtp.AuthenticateAsync(config.SmtpUsername, config.SmtpPassword); + await smtp.SendAsync(msg); + await smtp.DisconnectAsync(true); + + Console.WriteLine($"[AlarmReviewService] Email sent → {toEmail}: {subject}"); + } + catch (Exception ex) + { + Console.Error.WriteLine($"[AlarmReviewService] Email failed → {toEmail}: {ex.Message}"); + } + } + + private static async Task ReadMailerConfigAsync() + { + await using var fs = File.OpenRead(MailerConfig.DefaultFile); + var config = await System.Text.Json.JsonSerializer.DeserializeAsync(fs); + return config ?? throw new InvalidOperationException("Failed to read MailerConfig.json"); + } + + // ── Helpers ──────────────────────────────────────────────────────────────── + + private static string SplitCamelCase(string name) => + Regex.Replace(name, @"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", " ").Trim(); + + private static string EscapeForCSharp(string s) => + s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "").Replace("\n", "\\n"); + + // ── Workday check (no emails on weekends or Swiss public holidays) ────────── + + private static bool IsWorkday(DateTime date) + { + if (date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday) + return false; + return !IsSwissPublicHoliday(date.Date); + } + + private static bool IsSwissPublicHoliday(DateTime date) + { + var year = date.Year; + + // Fixed federal holidays + if (date == new DateTime(year, 1, 1)) return true; // New Year's Day + if (date == new DateTime(year, 8, 1)) return true; // Swiss National Day + if (date == new DateTime(year, 12, 25)) return true; // Christmas Day + if (date == new DateTime(year, 12, 26)) return true; // St. Stephen's Day + + // Easter-based holidays + var easter = GetEasterSunday(year); + if (date == easter.AddDays(-2)) return true; // Good Friday + if (date == easter) return true; // Easter Sunday + if (date == easter.AddDays(1)) return true; // Easter Monday + if (date == easter.AddDays(39)) return true; // Ascension Day + if (date == easter.AddDays(49)) return true; // Whit Sunday (Pfingstsonntag) + if (date == easter.AddDays(50)) return true; // Whit Monday (Pfingstmontag) + + return false; + } + + private static DateTime GetEasterSunday(int year) + { + // Anonymous Gregorian algorithm + int a = year % 19; + int b = year / 100; + int c = year % 100; + int d = b / 4; + int e = b % 4; + int f = (b + 8) / 25; + int g = (b - f + 1) / 3; + int h = (19 * a + b - d - g + 15) % 30; + int i = c / 4; + int k = c % 4; + int l = (32 + 2 * e + 2 * i - h - k) % 7; + int m = (a + 11 * h + 22 * l) / 451; + int month = (h + l - 7 * m + 114) / 31; + int day = ((h + l - 7 * m + 114) % 31) + 1; + return new DateTime(year, month, day); + } +} diff --git a/csharp/App/Backend/Services/BehaviorAnalyzer.cs b/csharp/App/Backend/Services/BehaviorAnalyzer.cs new file mode 100644 index 000000000..695a2da1c --- /dev/null +++ b/csharp/App/Backend/Services/BehaviorAnalyzer.cs @@ -0,0 +1,101 @@ +using InnovEnergy.App.Backend.DataTypes; + +namespace InnovEnergy.App.Backend.Services; + +public static class BehaviorAnalyzer +{ + private const double SolarActiveThresholdKwh = 0.1; // min PV kWh in an hour to count as "solar active" + private const double LowSoCThreshold = 20.0; // % below which battery is considered depleted + + /// + /// Derives behavioral facts from hourly data for the current week only. + /// All computation is pure C# — no AI involved. + /// + public static BehavioralPattern Analyze(List hourlyData) + { + if (hourlyData.Count == 0) + return new BehavioralPattern(); + + // ── Per-hour averages across the week ────────────────────────────── + // Group by hour-of-day (0-23), average each metric across all days + var byHour = Enumerable.Range(0, 24).Select(h => + { + var rows = hourlyData.Where(r => r.Hour == h).ToList(); + if (rows.Count == 0) + return (Hour: h, AvgPv: 0.0, AvgLoad: 0.0, AvgGridImport: 0.0); + return ( + Hour: h, + AvgPv: rows.Average(r => r.PvKwh), + AvgLoad: rows.Average(r => r.LoadKwh), + AvgGridImport: rows.Average(r => r.GridImportKwh) + ); + }).ToList(); + + // ── Peak load hour ───────────────────────────────────────────────── + var peakLoadEntry = byHour.OrderByDescending(h => h.AvgLoad).First(); + + // ── Peak solar hour and end of solar window ──────────────────────── + var peakSolarEntry = byHour.OrderByDescending(h => h.AvgPv).First(); + + // Solar window: last hour in the day where avg PV > threshold + var solarActiveHours = byHour.Where(h => h.AvgPv >= SolarActiveThresholdKwh).ToList(); + var peakSolarEndHour = solarActiveHours.Count > 0 + ? solarActiveHours.Max(h => h.Hour) + : peakSolarEntry.Hour; + + // ── Highest grid-import hour ──────────────────────────────────────── + var worstGridEntry = byHour.OrderByDescending(h => h.AvgGridImport).First(); + + // ── Avoidable grid imports: grid drawn during hours when solar was active ── + // For each actual hourly record: if solar > threshold AND grid import > 0 → avoidable + var avoidableGridKwh = Math.Round( + hourlyData + .Where(r => r.PvKwh >= SolarActiveThresholdKwh && r.GridImportKwh > 0) + .Sum(r => r.GridImportKwh), + 1); + + // ── Weekday vs weekend average daily load ────────────────────────── + var weekdayDays = hourlyData + .Where(r => !r.IsWeekend) + .GroupBy(r => r.DateTime.Date) + .Select(g => g.Sum(r => r.LoadKwh)) + .ToList(); + + var weekendDays = hourlyData + .Where(r => r.IsWeekend) + .GroupBy(r => r.DateTime.Date) + .Select(g => g.Sum(r => r.LoadKwh)) + .ToList(); + + var weekdayAvg = weekdayDays.Count > 0 ? Math.Round(weekdayDays.Average(), 1) : 0; + var weekendAvg = weekendDays.Count > 0 ? Math.Round(weekendDays.Average(), 1) : 0; + + // ── Battery depletion hour ───────────────────────────────────────── + // For each day, find the first evening hour (after 18:00) where SoC < threshold + // Average that hour across days where it occurs + var depletionHours = hourlyData + .Where(r => r.Hour >= 18 && r.BattSoC > 0 && r.BattSoC < LowSoCThreshold) + .GroupBy(r => r.DateTime.Date) + .Select(g => g.OrderBy(r => r.Hour).First().Hour) + .ToList(); + + var avgDepletedHour = depletionHours.Count > 0 ? (int)Math.Round(depletionHours.Average()) : -1; + var batteryDepletsNight = depletionHours.Count >= 3; // happens on 3+ nights = consistent pattern + + return new BehavioralPattern + { + PeakLoadHour = peakLoadEntry.Hour, + AvgPeakLoadKwh = Math.Round(peakLoadEntry.AvgLoad, 2), + PeakSolarHour = peakSolarEntry.Hour, + PeakSolarEndHour = peakSolarEndHour, + AvgPeakSolarKwh = Math.Round(peakSolarEntry.AvgPv, 2), + HighestGridImportHour = worstGridEntry.Hour, + AvgGridImportAtPeakHour = Math.Round(worstGridEntry.AvgGridImport, 2), + AvoidableGridKwh = avoidableGridKwh, + WeekdayAvgDailyLoad = weekdayAvg, + WeekendAvgDailyLoad = weekendAvg, + AvgBatteryDepletedHour = avgDepletedHour, + BatteryDepletesOvernight = batteryDepletsNight, + }; + } +} diff --git a/csharp/App/Backend/Services/DiagnosticService.cs b/csharp/App/Backend/Services/DiagnosticService.cs new file mode 100644 index 000000000..9fc6911ca --- /dev/null +++ b/csharp/App/Backend/Services/DiagnosticService.cs @@ -0,0 +1,297 @@ +using System.Collections.Concurrent; +using Flurl.Http; +using InnovEnergy.App.Backend.Database; +using InnovEnergy.App.Backend.DataTypes; +using Newtonsoft.Json; +using System.Text.RegularExpressions; + +namespace InnovEnergy.App.Backend.Services; + +/// +/// Calls Mistral AI to generate plain-English diagnostics for errors/warnings. +/// Caches responses in-memory keyed by error description so the same +/// error code is only sent to the API once. +/// +public static class DiagnosticService +{ + private static string _apiKey = ""; + + /// In-memory cache: errorDescription → parsed response. + private static readonly ConcurrentDictionary Cache = new(); + + /// Pre-generated translations keyed by language code → alarm key → response. + private static readonly Dictionary> Translations = new(); + + // ── initialisation ────────────────────────────────────────────── + + public static void Initialize() + { + var apiKey = Environment.GetEnvironmentVariable("MISTRAL_API_KEY"); + + if (string.IsNullOrWhiteSpace(apiKey)) + Console.Error.WriteLine("[DiagnosticService] MISTRAL_API_KEY not set – AI diagnostics disabled."); + else + _apiKey = apiKey; + + // Load pre-generated translation files (en, de, fr, it) if available + // en.json is generated by generate_alarm_translations.py after the review campaign + var resourcesDir = Path.Combine(AppContext.BaseDirectory, "Resources"); + foreach (var lang in new[] { "en", "de", "fr", "it" }) + { + var file = Path.Combine(resourcesDir, $"AlarmTranslations.{lang}.json"); + if (!File.Exists(file)) continue; + + try + { + var json = File.ReadAllText(file); + var raw = JsonConvert.DeserializeObject>(json); + if (raw is not null) + { + Translations[lang] = raw; + Console.WriteLine($"[DiagnosticService] Loaded {raw.Count} {lang} translations."); + } + } + catch (Exception ex) + { + Console.Error.WriteLine($"[DiagnosticService] Failed to load AlarmTranslations.{lang}.json: {ex.Message}"); + } + } + + Console.WriteLine("[DiagnosticService] initialised."); + } + + public static bool IsEnabled => !string.IsNullOrEmpty(_apiKey); + + // ── public entry-point ────────────────────────────────────────── + + private static string LanguageName(string code) => code switch + { + "de" => "German", + "fr" => "French", + "it" => "Italian", + _ => "English" + }; + + /// Converts "AbnormalGridVoltage" → "Abnormal Grid Voltage". + private static string SplitCamelCase(string name) => + Regex.Replace(name, @"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", " ").Trim(); + + /// + /// Returns a diagnosis for in the given language. + /// For English: checks the static AlarmKnowledgeBase first, then in-memory cache, then Mistral AI. + /// For other languages: skips the knowledge base (English-only) and goes directly to Mistral AI. + /// Cache is keyed by (errorDescription, language) so each language is cached separately. + /// + public static async Task DiagnoseAsync(Int64 installationId, string errorDescription, string language = "en") + { + var cacheKey = $"{errorDescription}|{language}"; + + // 1. For English: check the static knowledge base first (no API call needed) + if (language == "en") + { + var knownDiagnosis = AlarmKnowledgeBase.TryGetDiagnosis(errorDescription); + if (knownDiagnosis is not null) + { + Console.WriteLine($"[DiagnosticService] Knowledge base hit (en): {errorDescription}"); + // Return a new instance with Name set — avoids mutating the shared static dictionary + return new DiagnosticResponse + { + Name = SplitCamelCase(errorDescription), + Explanation = knownDiagnosis.Explanation, + Causes = knownDiagnosis.Causes, + NextSteps = knownDiagnosis.NextSteps, + }; + } + } + + // 2. For non-English: check pre-generated translation files (no API call needed) + if (language != "en" && Translations.TryGetValue(language, out var langDict)) + { + if (langDict.TryGetValue(errorDescription, out var translatedDiagnosis)) + { + Console.WriteLine($"[DiagnosticService] Pre-generated translation hit ({language}): {errorDescription}"); + return translatedDiagnosis; + } + } + + // 3. If AI is not enabled, we can't proceed further + if (!IsEnabled) return null; + + // 4. Check in-memory cache for previously fetched AI diagnoses + if (Cache.TryGetValue(cacheKey, out var cached)) + return cached; + + // 4. Gather context from the DB for AI prompt + var installation = Db.GetInstallationById(installationId); + if (installation is null) return null; + + var productName = ((ProductType)installation.Product).ToString(); + + var recentDescriptions = Db.Errors + .Where(e => e.InstallationId == installationId) + .OrderByDescending(e => e.Date) + .ThenByDescending(e => e.Time) + .ToList() // materialize before LINQ-to-objects ops + .Select(e => e.Description) + .Distinct() // deduplicate — same error repeated adds no signal + .Take(5) + .ToList(); + + // 5. Build prompt and call Mistral API (only for unknown alarms) + Console.WriteLine($"[DiagnosticService] Calling Mistral for unknown alarm: {errorDescription} ({language})"); + var prompt = BuildPrompt(errorDescription, productName, recentDescriptions, language); + var response = await CallMistralAsync(prompt); + + if (response is null) return null; + + // 6. Store in cache for future requests + Cache.TryAdd(cacheKey, response); + return response; + } + + // ── test helper (no DB dependency) ───────────────────────────── + + /// + /// Returns a diagnosis from the static knowledge base (English) or pre-generated + /// translations (other languages). Returns null if not found in either. + /// + public static DiagnosticResponse? TryGetTranslation(string errorDescription, string language) + { + // Check JSON translations first (en.json exists after review campaign) + if (Translations.TryGetValue(language, out var langDict) && + langDict.TryGetValue(errorDescription, out var translated)) + return translated; + + // Fallback: English from compiled AlarmKnowledgeBase.cs (until en.json is deployed) + if (language == "en") + { + var kb = AlarmKnowledgeBase.TryGetDiagnosis(errorDescription); + if (kb is null) return null; + return new DiagnosticResponse + { + Name = SplitCamelCase(errorDescription), + Explanation = kb.Explanation, + Causes = kb.Causes, + NextSteps = kb.NextSteps, + }; + } + + return null; + } + + /// + /// Calls Mistral directly with a generic prompt. For testing only - no DB lookup. + /// + public static async Task TestCallMistralAsync(string errorDescription, string language = "en") + { + if (!IsEnabled) return null; + + var cacheKey = $"{errorDescription}|{language}"; + + // Check cache first + if (Cache.TryGetValue(cacheKey, out var cached)) + return cached; + + var prompt = BuildPrompt(errorDescription, "SodioHome", new List(), language); + var response = await CallMistralAsync(prompt); + + if (response is not null) + Cache.TryAdd(cacheKey, response); + + return response; + } + + // ── prompt ────────────────────────────────────────────────────── + + private static string BuildPrompt(string errorDescription, string productName, List recentErrors, string language = "en") + { + var recentList = recentErrors.Count > 0 + ? string.Join(", ", recentErrors) + : "none"; + + return $@"You are a technician for {productName} battery energy storage systems. +These are sodium-ion BESS units with a BMS, PV inverter, and grid inverter. + +Error: {errorDescription} +Other recent errors: {recentList} + +Explain for a non-technical homeowner. Keep it very short and simple: +- name: 2-5 word display title for this alarm +- explanation: 1 short sentence, no jargon +- causes: 2-3 bullet points, plain language +- nextSteps: 2-3 simple action items a homeowner can understand +IMPORTANT: Write all text values in {LanguageName(language)}. Reply with ONLY valid JSON, no markdown: +{{""name"":""short title"",""explanation"":""1 short sentence"",""causes"":[""...""],""nextSteps"":[""...""]}} +"; + } + + // ── Mistral HTTP call ──────────────────────────────────────────── + + private static readonly string MistralUrl = "https://api.mistral.ai/v1/chat/completions"; + + private static async Task CallMistralAsync(string userPrompt) + { + try + { + var requestBody = new + { + model = "mistral-small-latest", // cost-efficient, fast; swap to "mistral-large-latest" if quality needs tuning + messages = new[] + { + new { role = "user", content = userPrompt } + }, + max_tokens = 400, + temperature = 0.2 // low temperature for factual consistency + }; + + var responseText = await MistralUrl + .WithHeader("Authorization", $"Bearer {_apiKey}") + .PostJsonAsync(requestBody) + .ReceiveString(); + + // parse Mistral envelope (same structure as OpenAI) + var envelope = JsonConvert.DeserializeObject(responseText); + var content = (string?) envelope?.choices?[0]?.message?.content; + + if (string.IsNullOrWhiteSpace(content)) + { + Console.Error.WriteLine("[DiagnosticService] Mistral returned empty content."); + return null; + } + + // strip markdown code fences if Mistral wraps the JSON in ```json ... ``` + var json = content.Trim(); + if (json.StartsWith("```")) + { + var firstNewline = json.IndexOf('\n'); + if (firstNewline >= 0) json = json[(firstNewline + 1)..]; + if (json.EndsWith("```")) json = json[..^3]; + json = json.Trim(); + } + + // parse the JSON the model produced + var diagnostic = JsonConvert.DeserializeObject(json); + return diagnostic; + } + catch (FlurlHttpException httpEx) + { + Console.Error.WriteLine($"[DiagnosticService] HTTP error {httpEx.StatusCode}: {httpEx.Message}"); + return null; + } + catch (Exception ex) + { + Console.Error.WriteLine($"[DiagnosticService] {ex.Message}"); + return null; + } + } +} + +// ── config / response models ──────────────────────────────────────────────── + +public class DiagnosticResponse +{ + public string Name { get; set; } = ""; + public string Explanation { get; set; } = ""; + public IReadOnlyList Causes { get; set; } = Array.Empty(); + public IReadOnlyList NextSteps { get; set; } = Array.Empty(); +} diff --git a/csharp/App/Backend/Services/ExcelDataParser.cs b/csharp/App/Backend/Services/ExcelDataParser.cs new file mode 100644 index 000000000..eff88a0eb --- /dev/null +++ b/csharp/App/Backend/Services/ExcelDataParser.cs @@ -0,0 +1,186 @@ +using ClosedXML.Excel; +using InnovEnergy.App.Backend.DataTypes; + +namespace InnovEnergy.App.Backend.Services; + +public static class ExcelDataParser +{ + // Column headers from the ESS Link Cloud Excel export + private const string ColDateTime = "Data time"; + private const string ColPvToday = "PV Generated Energy Today"; + private const string ColLoadToday = "Load Consumption Today"; + private const string ColGridImportToday = "Purchased Energy Today"; + private const string ColGridExportToday = "Feed in energy Today"; + private const string ColBattChargedToday = "Daily Battery Charged"; + private const string ColBattDischargedToday = "Battery Discharged Today"; + private const string ColBattSoC = "Battery 1 SoC"; // instantaneous % + + /// + /// Parses an ESS Link Cloud Excel export file and returns one DailyEnergyData per day. + /// Takes the last row of each day (where "Today" cumulative values are highest). + /// + public static List Parse(string filePath) + { + if (!File.Exists(filePath)) + throw new FileNotFoundException($"Excel file not found: {filePath}"); + + using var workbook = new XLWorkbook(filePath); + var worksheet = workbook.Worksheet(1); + var lastRow = worksheet.LastRowUsed()?.RowNumber() ?? 0; + + if (lastRow < 2) + throw new InvalidOperationException("Excel file has no data rows."); + + // Find column indices by header name (row 1) + var headerRow = worksheet.Row(1); + var colMap = new Dictionary(); + + for (var col = 1; col <= worksheet.LastColumnUsed()?.ColumnNumber(); col++) + { + var header = headerRow.Cell(col).GetString().Trim(); + if (!string.IsNullOrEmpty(header)) + colMap[header] = col; + } + + // Validate required columns exist + var requiredCols = new[] { ColDateTime, ColPvToday, ColLoadToday, ColGridImportToday, ColGridExportToday, ColBattChargedToday, ColBattDischargedToday }; + foreach (var rc in requiredCols) + { + if (!colMap.ContainsKey(rc)) + throw new InvalidOperationException($"Required column '{rc}' not found in Excel file. Available: {string.Join(", ", colMap.Keys)}"); + } + + // Read all rows, group by date, keep last row per day + var dailyLastRows = new SortedDictionary(); + + for (var row = 2; row <= lastRow; row++) + { + var dateTimeStr = worksheet.Row(row).Cell(colMap[ColDateTime]).GetString().Trim(); + if (string.IsNullOrEmpty(dateTimeStr)) continue; + + // Extract date portion (first 10 chars: "2026-02-10") + var date = dateTimeStr.Length >= 10 ? dateTimeStr[..10] : dateTimeStr; + + var data = new DailyEnergyData + { + Date = date, + PvProduction = GetDouble(worksheet, row, colMap[ColPvToday]), + LoadConsumption = GetDouble(worksheet, row, colMap[ColLoadToday]), + GridImport = GetDouble(worksheet, row, colMap[ColGridImportToday]), + GridExport = GetDouble(worksheet, row, colMap[ColGridExportToday]), + BatteryCharged = GetDouble(worksheet, row, colMap[ColBattChargedToday]), + BatteryDischarged = GetDouble(worksheet, row, colMap[ColBattDischargedToday]), + }; + + // Always overwrite — last row of the day has the final cumulative values + dailyLastRows[date] = data; + } + + Console.WriteLine($"[ExcelDataParser] Parsed {dailyLastRows.Count} days from {filePath}"); + return dailyLastRows.Values.ToList(); + } + + /// + /// Parses hourly energy snapshots from the xlsx. + /// For each hour of each day, finds the row nearest HH:00:00 and records the + /// cumulative "Today" values at that moment. The caller (BehaviorAnalyzer) then + /// diffs consecutive snapshots to get per-hour energy. + /// + public static List ParseHourly(string filePath) + { + if (!File.Exists(filePath)) + throw new FileNotFoundException($"Excel file not found: {filePath}"); + + using var workbook = new XLWorkbook(filePath); + var worksheet = workbook.Worksheet(1); + var lastRow = worksheet.LastRowUsed()?.RowNumber() ?? 0; + + if (lastRow < 2) + throw new InvalidOperationException("Excel file has no data rows."); + + // Build column map + var headerRow = worksheet.Row(1); + var colMap = new Dictionary(); + for (var col = 1; col <= worksheet.LastColumnUsed()?.ColumnNumber(); col++) + { + var header = headerRow.Cell(col).GetString().Trim(); + if (!string.IsNullOrEmpty(header)) + colMap[header] = col; + } + + // SoC column is optional — not all exports include it + var hasSoC = colMap.ContainsKey(ColBattSoC); + + // Read all rows into memory as (DateTime, cumulative values) pairs + var rawRows = new List<(DateTime Dt, double Pv, double Load, double GridIn, double BattChg, double BattDis, double SoC)>(); + + for (var row = 2; row <= lastRow; row++) + { + var dtStr = worksheet.Row(row).Cell(colMap[ColDateTime]).GetString().Trim(); + if (string.IsNullOrEmpty(dtStr)) continue; + if (!DateTime.TryParse(dtStr, out var dt)) continue; + + rawRows.Add(( + dt, + GetDouble(worksheet, row, colMap[ColPvToday]), + GetDouble(worksheet, row, colMap[ColLoadToday]), + GetDouble(worksheet, row, colMap[ColGridImportToday]), + GetDouble(worksheet, row, colMap[ColBattChargedToday]), + GetDouble(worksheet, row, colMap[ColBattDischargedToday]), + hasSoC ? GetDouble(worksheet, row, colMap[ColBattSoC]) : 0 + )); + } + + if (rawRows.Count == 0) return new List(); + + // For each calendar hour that exists in the data, find the nearest row to HH:00:00 + // Group rows by (date, hour) and pick the one closest to the round hour + var byHour = rawRows + .GroupBy(r => new DateTime(r.Dt.Year, r.Dt.Month, r.Dt.Day, r.Dt.Hour, 0, 0)) + .OrderBy(g => g.Key) + .Select(g => + { + var roundHour = g.Key; + var nearest = g.OrderBy(r => Math.Abs((r.Dt - roundHour).TotalSeconds)).First(); + return (RoundHour: roundHour, Row: nearest); + }) + .ToList(); + + // Diff consecutive snapshots within the same day to get per-hour energy + var result = new List(); + + for (var i = 1; i < byHour.Count; i++) + { + var prev = byHour[i - 1]; + var curr = byHour[i]; + + // Only diff within the same day — don't carry over across midnight + if (curr.RoundHour.Date != prev.RoundHour.Date) continue; + + // Cumulative "Today" values reset at midnight, so diff is always >= 0 within a day + result.Add(new HourlyEnergyData + { + DateTime = curr.RoundHour, + Hour = curr.RoundHour.Hour, + DayOfWeek = curr.RoundHour.DayOfWeek.ToString(), + IsWeekend = curr.RoundHour.DayOfWeek is DayOfWeek.Saturday or DayOfWeek.Sunday, + PvKwh = Math.Max(0, Math.Round(curr.Row.Pv - prev.Row.Pv, 3)), + LoadKwh = Math.Max(0, Math.Round(curr.Row.Load - prev.Row.Load, 3)), + GridImportKwh = Math.Max(0, Math.Round(curr.Row.GridIn - prev.Row.GridIn, 3)), + BatteryChargedKwh = Math.Max(0, Math.Round(curr.Row.BattChg - prev.Row.BattChg, 3)), + BatteryDischargedKwh = Math.Max(0, Math.Round(curr.Row.BattDis - prev.Row.BattDis, 3)), + BattSoC = curr.Row.SoC, + }); + } + + Console.WriteLine($"[ExcelDataParser] Parsed {result.Count} hourly records from {filePath}"); + return result; + } + + private static double GetDouble(IXLWorksheet ws, int row, int col) + { + var cell = ws.Row(row).Cell(col); + if (cell.IsEmpty()) return 0; + return cell.TryGetValue(out var val) ? Math.Round(val, 4) : 0; + } +} diff --git a/csharp/App/Backend/Services/ReportEmailService.cs b/csharp/App/Backend/Services/ReportEmailService.cs new file mode 100644 index 000000000..230f7c365 --- /dev/null +++ b/csharp/App/Backend/Services/ReportEmailService.cs @@ -0,0 +1,446 @@ +using System.Text.Json; +using InnovEnergy.App.Backend.DataTypes; +using InnovEnergy.Lib.Mailer; +using MailKit.Net.Smtp; +using MailKit.Security; +using MimeKit; + +namespace InnovEnergy.App.Backend.Services; + +public static class ReportEmailService +{ + /// + /// Sends the weekly report as a nicely formatted HTML email in the user's language. + /// Uses MailKit directly (same config as existing Mailer library) but with HTML support. + /// + public static async Task SendReportEmailAsync(WeeklyReportResponse report, string recipientEmail, string language = "en") + { + var strings = GetStrings(language); + var subject = $"{strings.Title} — {report.InstallationName} ({report.PeriodStart} to {report.PeriodEnd})"; + var html = BuildHtmlEmail(report, strings); + + var config = await ReadMailerConfig(); + + var from = new MailboxAddress(config.SenderName, config.SenderAddress); + var to = new MailboxAddress(recipientEmail, recipientEmail); + + var msg = new MimeMessage + { + From = { from }, + To = { to }, + Subject = subject, + Body = new TextPart("html") { Text = html } + }; + + Console.WriteLine($"[ReportEmailService] SMTP: {config.SmtpUsername}@{config.SmtpServerUrl}:{config.SmtpPort}"); + + using var smtp = new SmtpClient(); + await smtp.ConnectAsync(config.SmtpServerUrl, config.SmtpPort, SecureSocketOptions.StartTls); + await smtp.AuthenticateAsync(config.SmtpUsername, config.SmtpPassword); + await smtp.SendAsync(msg); + await smtp.DisconnectAsync(true); + + Console.WriteLine($"[ReportEmailService] Report sent to {recipientEmail}"); + } + + private static async Task ReadMailerConfig() + { + await using var fileStream = File.OpenRead(MailerConfig.DefaultFile); + var config = await JsonSerializer.DeserializeAsync(fileStream); + return config ?? throw new InvalidOperationException("Failed to read MailerConfig.json"); + } + + // ── Translation strings ───────────────────────────────────────────────── + + private record EmailStrings( + string Title, + string Insights, + string Summary, + string SavingsHeader, + string DailyBreakdown, + string Metric, + string ThisWeek, + string LastWeek, + string Change, + string PvProduction, + string Consumption, + string GridImport, + string GridExport, + string BatteryInOut, + string SolarEnergyUsed, + string StayedAtHome, + string EstMoneySaved, + string AtRate, + string SolarCoverage, + string FromSolar, + string BatteryEff, + string OutVsIn, + string Day, + string Load, + string GridIn, + string GridOut, + string BattInOut, + string Footer + ); + + private static EmailStrings GetStrings(string language) => language switch + { + "de" => new EmailStrings( + Title: "Wöchentlicher Leistungsbericht", + Insights: "Wöchentliche Erkenntnisse", + Summary: "Wöchentliche Zusammenfassung", + SavingsHeader: "Ihre Ersparnisse diese Woche", + DailyBreakdown: "Tägliche Aufschlüsselung (kWh)", + Metric: "Kennzahl", + ThisWeek: "Diese Woche", + LastWeek: "Letzte Woche", + Change: "Änderung", + PvProduction: "PV-Produktion", + Consumption: "Verbrauch", + GridImport: "Netzbezug", + GridExport: "Netzeinspeisung", + BatteryInOut: "Batterie Laden / Entladen", + SolarEnergyUsed: "Energie gespart", + StayedAtHome: "Solar + Batterie, nicht vom Netz", + EstMoneySaved: "Geschätzte Ersparnis", + AtRate: "bei 0.39 CHF/kWh", + SolarCoverage: "Eigenversorgung", + FromSolar: "aus Solar + Batterie", + BatteryEff: "Batterie-Eff.", + OutVsIn: "Entladung vs. Ladung", + Day: "Tag", + Load: "Last", + GridIn: "Netz Ein", + GridOut: "Netz Aus", + BattInOut: "Batt. Laden/Entl.", + Footer: "Erstellt von inesco Energy Monitor" + ), + "fr" => new EmailStrings( + Title: "Rapport de performance hebdomadaire", + Insights: "Aperçus de la semaine", + Summary: "Résumé de la semaine", + SavingsHeader: "Vos économies cette semaine", + DailyBreakdown: "Détail quotidien (kWh)", + Metric: "Indicateur", + ThisWeek: "Cette semaine", + LastWeek: "Semaine dernière", + Change: "Variation", + PvProduction: "Production PV", + Consumption: "Consommation", + GridImport: "Import réseau", + GridExport: "Export réseau", + BatteryInOut: "Batterie Charge / Décharge", + SolarEnergyUsed: "Énergie économisée", + StayedAtHome: "solaire + batterie, non achetée au réseau", + EstMoneySaved: "Économies estimées", + AtRate: "à 0.39 CHF/kWh", + SolarCoverage: "Autosuffisance", + FromSolar: "du solaire + batterie", + BatteryEff: "Eff. batterie", + OutVsIn: "décharge vs charge", + Day: "Jour", + Load: "Charge", + GridIn: "Réseau Ent.", + GridOut: "Réseau Sor.", + BattInOut: "Batt. Ch./Déch.", + Footer: "Généré par inesco Energy Monitor" + ), + "it" => new EmailStrings( + Title: "Rapporto settimanale delle prestazioni", + Insights: "Approfondimenti settimanali", + Summary: "Riepilogo settimanale", + SavingsHeader: "I tuoi risparmi questa settimana", + DailyBreakdown: "Dettaglio giornaliero (kWh)", + Metric: "Metrica", + ThisWeek: "Questa settimana", + LastWeek: "La settimana scorsa", + Change: "Variazione", + PvProduction: "Produzione PV", + Consumption: "Consumo", + GridImport: "Import dalla rete", + GridExport: "Export nella rete", + BatteryInOut: "Batteria Carica / Scarica", + SolarEnergyUsed: "Energia risparmiata", + StayedAtHome: "solare + batteria, non acquistata dalla rete", + EstMoneySaved: "Risparmio stimato", + AtRate: "a 0.39 CHF/kWh", + SolarCoverage: "Autosufficienza", + FromSolar: "da solare + batteria", + BatteryEff: "Eff. batteria", + OutVsIn: "scarica vs carica", + Day: "Giorno", + Load: "Carico", + GridIn: "Rete Ent.", + GridOut: "Rete Usc.", + BattInOut: "Batt. Car./Sc.", + Footer: "Generato da inesco Energy Monitor" + ), + _ => new EmailStrings( + Title: "Weekly Performance Report", + Insights: "Weekly Insights", + Summary: "Weekly Summary", + SavingsHeader: "Your Savings This Week", + DailyBreakdown: "Daily Breakdown (kWh)", + Metric: "Metric", + ThisWeek: "This Week", + LastWeek: "Last Week", + Change: "Change", + PvProduction: "PV Production", + Consumption: "Consumption", + GridImport: "Grid Import", + GridExport: "Grid Export", + BatteryInOut: "Battery Charge / Discharge", + SolarEnergyUsed: "Energy Saved", + StayedAtHome: "solar + battery, not bought from grid", + EstMoneySaved: "Est. Money Saved", + AtRate: "at 0.39 CHF/kWh", + SolarCoverage: "Self-Sufficiency", + FromSolar: "from solar + battery", + BatteryEff: "Battery Eff.", + OutVsIn: "discharge vs charge", + Day: "Day", + Load: "Load", + GridIn: "Grid In", + GridOut: "Grid Out", + BattInOut: "Batt. Ch./Dis.", + Footer: "Generated by inesco Energy Monitor" + ) + }; + + // ── HTML email template ───────────────────────────────────────────── + + public static string BuildHtmlEmail(WeeklyReportResponse r, string language = "en") + => BuildHtmlEmail(r, GetStrings(language)); + + private static string BuildHtmlEmail(WeeklyReportResponse r, EmailStrings s) + { + var cur = r.CurrentWeek; + var prev = r.PreviousWeek; + + // Parse AI insight into
  • bullet points (split on newlines, strip leading "- " or "1. ") + var insightLines = r.AiInsight + .Split('\n', StringSplitOptions.RemoveEmptyEntries) + .Select(l => System.Text.RegularExpressions.Regex.Replace(l.Trim(), @"^[\d]+[.)]\s*|^[-*]\s*", "")) + .Where(l => l.Length > 0) + .ToList(); + + var insightHtml = insightLines.Count > 1 + ? "
      " + + string.Join("", insightLines.Select(l => $"
    • {FormatInsightLine(l)}
      • ")) + + "
    " + : $"

    {FormatInsightLine(r.AiInsight)}

    "; + + // Detect which components are present across all daily data + var showPv = r.DailyData.Any(d => d.PvProduction > 0.1); + var showGrid = r.DailyData.Any(d => d.GridImport > 0.1); + + // Daily rows — colorful bar chart (pixel widths, email-safe) + // Scale each day's bars so their combined total always fills maxBarPx (right-edge aligned). + // This replicates the web page's CSS flexbox flex-shrink:1 behaviour. + const int maxBarPx = 400; + + var dailyRows = ""; + foreach (var d in r.DailyData) + { + var dayName = DateTime.Parse(d.Date).ToString("ddd dd.MM"); + var isCurrentWeek = string.Compare(d.Date, r.PeriodStart, StringComparison.Ordinal) >= 0; + var opacity = isCurrentWeek ? "1" : "0.55"; + var fontWeight = isCurrentWeek ? "bold" : "normal"; + var dayTotal = (showPv ? d.PvProduction : 0) + d.LoadConsumption + (showGrid ? d.GridImport : 0); + if (dayTotal < 0.1) dayTotal = 0.1; + var pvPx = showPv ? (int)(d.PvProduction / dayTotal * maxBarPx) : 0; + var ldPx = (int)(d.LoadConsumption / dayTotal * maxBarPx); + var giPx = showGrid ? (int)(d.GridImport / dayTotal * maxBarPx) : 0; + + var pvSpan = showPv ? $@"" : ""; + var gridSpan = showGrid ? $@"" : ""; + var ldRadius = (!showPv ? "border-radius:2px 0 0 2px;" : "") + (!showGrid ? "border-radius:0 2px 2px 0;" : ""); + + var valueText = (showPv ? $"PV {d.PvProduction:F1} | " : "") + + $"{s.Load} {d.LoadConsumption:F1}" + + (showGrid ? $" | {s.GridIn} {d.GridImport:F1}" : "") + + " kWh"; + + dailyRows += $@" + + {dayName} + +
    {valueText}
    +
    {pvSpan}{gridSpan}
    + + "; + } + + // Week-over-week comparison rows + var comparisonHtml = prev != null + ? $@" + + {s.PvProduction} + {cur.TotalPvProduction:F1} kWh + {prev.TotalPvProduction:F1} kWh + {FormatChange(r.PvChangePercent)} + + + {s.Consumption} + {cur.TotalConsumption:F1} kWh + {prev.TotalConsumption:F1} kWh + {FormatChange(r.ConsumptionChangePercent)} + + + {s.GridImport} + {cur.TotalGridImport:F1} kWh + {prev.TotalGridImport:F1} kWh + {FormatChange(r.GridImportChangePercent)} + + + {s.GridExport} + {cur.TotalGridExport:F1} kWh + {prev.TotalGridExport:F1} kWh + — + + + {s.BatteryInOut} + {cur.TotalBatteryCharged:F1}/{cur.TotalBatteryDischarged:F1} kWh + {prev.TotalBatteryCharged:F1}/{prev.TotalBatteryDischarged:F1} kWh + — + " + : $@" + {s.PvProduction}{cur.TotalPvProduction:F1} kWh + {s.Consumption}{cur.TotalConsumption:F1} kWh + {s.GridImport}{cur.TotalGridImport:F1} kWh + {s.GridExport}{cur.TotalGridExport:F1} kWh + {s.BatteryInOut}{cur.TotalBatteryCharged:F1}/{cur.TotalBatteryDischarged:F1} kWh"; + + var comparisonHeaders = prev != null + ? $@"{s.ThisWeek} + {s.LastWeek} + {s.Change}" + : $@"{s.ThisWeek}"; + + return $@" + + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    {s.Title}
    +
    {r.InstallationName}
    +
    {r.PeriodStart} — {r.PeriodEnd}
    +
    +
    {s.Insights}
    +
    + {insightHtml} +
    +
    +
    {s.Summary}
    + + + + {comparisonHeaders} + + {comparisonHtml} +
    {s.Metric}
    +
    +
    {s.SavingsHeader}
    + + + {SavingsBox(s.SolarEnergyUsed, $"{r.TotalEnergySaved:F1} kWh", s.StayedAtHome, "#27ae60")} + {SavingsBox(s.EstMoneySaved, $"~{r.TotalSavingsCHF:F0} CHF", s.AtRate, "#2980b9")} + {SavingsBox(s.SolarCoverage, $"{r.SelfSufficiencyPercent:F0}%", s.FromSolar, "#8e44ad")} + {SavingsBox(s.BatteryEff, $"{r.BatteryEfficiencyPercent:F0}%", s.OutVsIn, "#e67e22")} + +
    +
    +
    {s.DailyBreakdown}
    + + + + + + {dailyRows} +
    + {(showPv ? @$"PV   " : "")} + {s.Load}    + {(showGrid ? @$"{s.GridIn}" : "")} +
    +
    + {s.Footer} +
    +
    + +"; + } + + private static string SavingsBox(string label, string value, string subtitle, string color) => + $@" +
    +
    {value}
    +
    {label}
    +
    {subtitle}
    +
    + "; + + // Bolds "Title" before first colon, and numbers+units in the rest + private static string FormatInsightLine(string line) + { + var colonIdx = line.IndexOf(':'); + string result; + if (colonIdx > 0) + { + var title = line[..colonIdx]; + var rest = line[colonIdx..]; // includes the colon + result = $"{title}{rest}"; + } + else + { + result = line; + } + // Bold all numbers: time ranges (14:00–18:00), times (09:00), decimals, integers + result = System.Text.RegularExpressions.Regex.Replace( + result, + @"(\d{1,2}:\d{2}(?:[–\-]\d{1,2}:\d{2})?|\d+[.,]\d+|\d+)", + "$1"); + return result; + } + + private static string FormatChange(double pct) => + pct == 0 ? "—" : pct > 0 ? $"+{pct:F1}%" : $"{pct:F1}%"; + + private static string ChangeColor(double pct) => + pct > 0 ? "#27ae60" : pct < 0 ? "#e74c3c" : "#888"; +} diff --git a/csharp/App/Backend/Services/WeeklyReportService.cs b/csharp/App/Backend/Services/WeeklyReportService.cs new file mode 100644 index 000000000..9c9e4a3a9 --- /dev/null +++ b/csharp/App/Backend/Services/WeeklyReportService.cs @@ -0,0 +1,340 @@ +using Flurl.Http; +using InnovEnergy.App.Backend.DataTypes; +using Newtonsoft.Json; + +namespace InnovEnergy.App.Backend.Services; + +public static class WeeklyReportService +{ + private static readonly string TmpReportDir = Environment.CurrentDirectory + "/tmp_report/"; + + /// + /// Generates a full weekly report for the given installation. + /// Cache is invalidated automatically when the xlsx file is newer than the cache. + /// To force regeneration (e.g. after a prompt change), simply delete the cache files. + /// + public static async Task GenerateReportAsync(long installationId, string installationName, string language = "en") + { + var xlsxPath = TmpReportDir + installationId + ".xlsx"; + var cachePath = TmpReportDir + $"{installationId}_{language}.cache.json"; + + // Use cached report if xlsx hasn't changed since cache was written + if (File.Exists(cachePath) && File.Exists(xlsxPath)) + { + var xlsxModified = File.GetLastWriteTimeUtc(xlsxPath); + var cacheModified = File.GetLastWriteTimeUtc(cachePath); + if (cacheModified > xlsxModified) + { + try + { + var cached = JsonConvert.DeserializeObject( + await File.ReadAllTextAsync(cachePath)); + if (cached != null) + { + Console.WriteLine($"[WeeklyReportService] Returning cached report for installation {installationId} ({language})."); + return cached; + } + } + catch + { + // Cache corrupt — regenerate + } + } + } + + // Parse both daily summaries and hourly intervals from the same xlsx + var allDays = ExcelDataParser.Parse(xlsxPath); + var allHourly = ExcelDataParser.ParseHourly(xlsxPath); + var report = await GenerateReportFromDataAsync(allDays, allHourly, installationName, language); + + // Write cache + try + { + await File.WriteAllTextAsync(cachePath, JsonConvert.SerializeObject(report)); + } + catch (Exception ex) + { + Console.Error.WriteLine($"[WeeklyReportService] Could not write cache: {ex.Message}"); + } + + return report; + } + + /// + /// Core report generation. Accepts both daily summaries and hourly intervals. + /// + public static async Task GenerateReportFromDataAsync( + List allDays, + List allHourly, + string installationName, + string language = "en") + { + // Sort by date + allDays = allDays.OrderBy(d => d.Date).ToList(); + + // Split into previous week and current week (daily) + List previousWeekDays; + List currentWeekDays; + + if (allDays.Count > 7) + { + previousWeekDays = allDays.Take(allDays.Count - 7).ToList(); + currentWeekDays = allDays.Skip(allDays.Count - 7).ToList(); + } + else + { + previousWeekDays = new List(); + currentWeekDays = allDays; + } + + // Restrict hourly data to current week only for behavioral analysis + var currentWeekStart = DateTime.Parse(currentWeekDays.First().Date); + var currentHourlyData = allHourly.Where(h => h.DateTime.Date >= currentWeekStart.Date).ToList(); + + var currentSummary = Summarize(currentWeekDays); + var previousSummary = previousWeekDays.Count > 0 ? Summarize(previousWeekDays) : null; + + // Key ratios for current week + var selfSufficiency = currentSummary.TotalConsumption > 0 + ? Math.Round((currentSummary.TotalConsumption - currentSummary.TotalGridImport) / currentSummary.TotalConsumption * 100, 1) + : 0; + + var selfConsumption = currentSummary.TotalPvProduction > 0 + ? Math.Round((currentSummary.TotalPvProduction - currentSummary.TotalGridExport) / currentSummary.TotalPvProduction * 100, 1) + : 0; + + var batteryEfficiency = currentSummary.TotalBatteryCharged > 0 + ? Math.Round(currentSummary.TotalBatteryDischarged / currentSummary.TotalBatteryCharged * 100, 1) + : 0; + + var gridDependency = currentSummary.TotalConsumption > 0 + ? Math.Round(currentSummary.TotalGridImport / currentSummary.TotalConsumption * 100, 1) + : 0; + + // Week-over-week changes + var pvChange = PercentChange(previousSummary?.TotalPvProduction, currentSummary.TotalPvProduction); + var consumptionChange = PercentChange(previousSummary?.TotalConsumption, currentSummary.TotalConsumption); + var gridImportChange = PercentChange(previousSummary?.TotalGridImport, currentSummary.TotalGridImport); + + // Behavioral pattern from hourly data (pure C# — no AI) + var behavior = BehaviorAnalyzer.Analyze(currentHourlyData); + + // Pre-computed savings — single source of truth for UI and AI + const double ElectricityPriceCHF = 0.39; + var totalEnergySaved = Math.Round(currentSummary.TotalConsumption - currentSummary.TotalGridImport, 1); + var totalSavingsCHF = Math.Round(totalEnergySaved * ElectricityPriceCHF, 0); + var avgDailyConsumption = currentWeekDays.Count > 0 ? currentSummary.TotalConsumption / currentWeekDays.Count : 0; + var daysEquivalent = avgDailyConsumption > 0 ? Math.Round(totalEnergySaved / avgDailyConsumption, 1) : 0; + + // AI insight combining daily facts + behavioral pattern + var aiInsight = await GetAiInsightAsync( + currentWeekDays, currentSummary, previousSummary, + selfSufficiency, totalEnergySaved, totalSavingsCHF, + behavior, installationName, language); + + return new WeeklyReportResponse + { + InstallationName = installationName, + PeriodStart = currentWeekDays.First().Date, + PeriodEnd = currentWeekDays.Last().Date, + CurrentWeek = currentSummary, + PreviousWeek = previousSummary, + TotalEnergySaved = totalEnergySaved, + TotalSavingsCHF = totalSavingsCHF, + DaysEquivalent = daysEquivalent, + SelfSufficiencyPercent = selfSufficiency, + SelfConsumptionPercent = selfConsumption, + BatteryEfficiencyPercent = batteryEfficiency, + GridDependencyPercent = gridDependency, + PvChangePercent = pvChange, + ConsumptionChangePercent = consumptionChange, + GridImportChangePercent = gridImportChange, + DailyData = allDays, + Behavior = behavior, + AiInsight = aiInsight, + }; + } + + private static WeeklySummary Summarize(List days) => new() + { + TotalPvProduction = Math.Round(days.Sum(d => d.PvProduction), 1), + TotalConsumption = Math.Round(days.Sum(d => d.LoadConsumption), 1), + TotalGridImport = Math.Round(days.Sum(d => d.GridImport), 1), + TotalGridExport = Math.Round(days.Sum(d => d.GridExport), 1), + TotalBatteryCharged = Math.Round(days.Sum(d => d.BatteryCharged), 1), + TotalBatteryDischarged = Math.Round(days.Sum(d => d.BatteryDischarged), 1), + }; + + private static double PercentChange(double? previous, double current) + { + if (previous is null or 0) return 0; + return Math.Round((current - previous.Value) / previous.Value * 100, 1); + } + + // ── Mistral AI Insight ────────────────────────────────────────────── + + private static readonly string MistralUrl = "https://api.mistral.ai/v1/chat/completions"; + + private static string LanguageName(string code) => code switch + { + "de" => "German", + "fr" => "French", + "it" => "Italian", + _ => "English" + }; + + private static string FormatHour(int hour) => $"{hour:D2}:00"; + private static string FormatHourSlot(int hour) => $"{hour:D2}:00–{hour + 1:D2}:00"; + + private static async Task GetAiInsightAsync( + List currentWeek, + WeeklySummary current, + WeeklySummary? previous, + double selfSufficiency, + double totalEnergySaved, + double totalSavingsCHF, + BehavioralPattern behavior, + string installationName, + string language = "en") + { + var apiKey = Environment.GetEnvironmentVariable("MISTRAL_API_KEY"); + if (string.IsNullOrWhiteSpace(apiKey)) + { + Console.WriteLine("[WeeklyReportService] MISTRAL_API_KEY not set — skipping AI insight."); + return "AI insight unavailable (API key not configured)."; + } + + const double ElectricityPriceCHF = 0.39; + + // Detect which components are present + var hasPv = currentWeek.Sum(d => d.PvProduction) > 0.5; + var hasBattery = currentWeek.Sum(d => d.BatteryCharged) > 0.5 + || currentWeek.Sum(d => d.BatteryDischarged) > 0.5; + var hasGrid = currentWeek.Sum(d => d.GridImport) > 0.5; + + var bestDay = currentWeek.OrderByDescending(d => d.PvProduction).First(); + var worstDay = currentWeek.OrderBy(d => d.PvProduction).First(); + var bestDayName = DateTime.Parse(bestDay.Date).ToString("dddd"); + var worstDayName = DateTime.Parse(worstDay.Date).ToString("dddd"); + + var topBattDay = currentWeek.OrderByDescending(d => d.BatteryCharged).First(); + var topBattDayName = DateTime.Parse(topBattDay.Date).ToString("dddd"); + + // Behavioral facts as compact lines + var peakSolarWindow = FormatHour(behavior.PeakSolarHour) + "–" + FormatHour(behavior.PeakSolarEndHour); + var avoidableSavingsCHF = Math.Round(behavior.AvoidableGridKwh * ElectricityPriceCHF, 0); + + var battDepleteLine = hasBattery + ? (behavior.AvgBatteryDepletedHour >= 0 + ? $"Battery typically depletes below 20% during {FormatHourSlot(behavior.AvgBatteryDepletedHour)}." + : "Battery stayed above 20% SoC every night this week.") + : ""; + + var weekdayWeekendLine = behavior.WeekendAvgDailyLoad > 0 + ? $"Weekday avg load: {behavior.WeekdayAvgDailyLoad} kWh/day. Weekend avg: {behavior.WeekendAvgDailyLoad} kWh/day." + : $"Weekday avg load: {behavior.WeekdayAvgDailyLoad} kWh/day."; + + // Build conditional fact lines + var pvDailyFact = hasPv + ? $"- PV: total {current.TotalPvProduction:F1} kWh this week. Best day: {bestDayName} ({bestDay.PvProduction:F1} kWh), worst: {worstDayName} ({worstDay.PvProduction:F1} kWh). Solar covered {selfSufficiency}% of consumption." + : ""; + var battDailyFact = hasBattery + ? $"- Battery: {current.TotalBatteryCharged:F1} kWh charged, {current.TotalBatteryDischarged:F1} kWh discharged. Most active day: {topBattDayName} ({topBattDay.BatteryCharged:F1} kWh charged)." + : ""; + var gridDailyFact = hasGrid + ? $"- Grid import: {current.TotalGridImport:F1} kWh total this week." + : ""; + + var pvBehaviorLines = hasPv ? $@" +- Solar active window: {peakSolarWindow}; peak hour: {FormatHourSlot(behavior.PeakSolarHour)}, avg {behavior.AvgPeakSolarKwh} kWh during that hour +- Grid imported while solar was active: {behavior.AvoidableGridKwh} kWh = {avoidableSavingsCHF} CHF that could have been avoided" : ""; + + var gridBehaviorLine = hasGrid + ? $"- Highest grid-import hour: {FormatHourSlot(behavior.HighestGridImportHour)}, avg {behavior.AvgGridImportAtPeakHour} kWh during that hour" + : ""; + + var battBehaviorLine = !string.IsNullOrEmpty(battDepleteLine) ? $"- {battDepleteLine}" : ""; + + // Build conditional instructions + var instruction1 = $"1. Energy savings: Write 1–2 sentences. Say that this week, thanks to sodistore home, the customer avoided buying {totalEnergySaved} kWh from the grid, saving {totalSavingsCHF} CHF (at {ElectricityPriceCHF} CHF/kWh). Use these exact numbers — do not recalculate or change them."; + + var instruction2 = hasPv + ? $"2. Solar performance: Comment on the best and worst solar day this week and the likely weather reason." + : hasGrid + ? $"2. Grid usage: Comment on the {current.TotalGridImport:F1} kWh drawn from the grid this week and what time of day drives it most ({FormatHourSlot(behavior.HighestGridImportHour)})." + : "2. Consumption pattern: Comment on the weekday vs weekend load pattern."; + + var instruction3 = hasBattery + ? $"3. Battery performance: Use the daily facts. Keep it simple for a homeowner." + : "3. Consumption pattern: Comment on the peak load time and weekday vs weekend usage."; + + var instruction4 = hasPv + ? $"4. Smart action for next week: Write exactly 2 sentences. Sentence 1: point out the timing mismatch using exact numbers — peak household load is during {FormatHourSlot(behavior.PeakLoadHour)} ({behavior.AvgPeakLoadKwh} kWh) but solar peaks during {FormatHourSlot(behavior.PeakSolarHour)} ({behavior.AvgPeakSolarKwh} kWh), with solar active from {peakSolarWindow}. Sentence 2: suggest shifting energy-intensive appliances (such as washing machine, dishwasher, heat pump, or EV charger if applicable) to run during the solar window {peakSolarWindow} — do not assume which specific device the customer has." + : hasGrid + ? $"4. Smart action for next week: Write exactly 2 sentences. Sentence 1: state that the peak grid-import hour is {FormatHourSlot(behavior.HighestGridImportHour)} ({behavior.AvgGridImportAtPeakHour} kWh avg). Sentence 2: suggest one action to reduce grid use during that hour — shifting energy-intensive appliances (washing machine, dishwasher, heat pump, EV charger) away from that time." + : "4. Smart action for next week: Give one practical tip to reduce energy consumption based on the peak load time and weekday/weekend pattern."; + + var prompt = $@"You are an energy advisor for a sodistore home installation: ""{installationName}"". + +Write 4 bullet points (each on its own line starting with ""- ""). No bold markers, no asterisks, no markdown — plain text only. + +IMPORTANT FORMAT RULE: Each bullet MUST start with a short title followed by a colon, then the description. Example: ""- Title label: Description text here."" Translate the title label into {LanguageName(language)} but always keep the ""Title: description"" structure. + +CRITICAL: All numbers below are pre-calculated. Use these values as-is — do not recalculate, round differently, or change any number. + +SYSTEM COMPONENTS: PV={hasPv}, Battery={hasBattery}, Grid={hasGrid} + +DAILY FACTS: +- Total consumption: {current.TotalConsumption:F1} kWh this week. Self-sufficiency: {selfSufficiency}%. +{pvDailyFact} +{battDailyFact} +{gridDailyFact} + +BEHAVIORAL PATTERN (from hourly data this week): +- Peak household load: {FormatHourSlot(behavior.PeakLoadHour)}, avg {behavior.AvgPeakLoadKwh} kWh during that hour +- {weekdayWeekendLine}{pvBehaviorLines} +{gridBehaviorLine} +{battBehaviorLine} + +INSTRUCTIONS: +{instruction1} +{instruction2} +{instruction3} +{instruction4} + +Rules: Write for a homeowner, not an engineer. Do NOT use asterisks or any formatting marks. Only describe components that exist (PV={hasPv}, Battery={hasBattery}, Grid={hasGrid}). Do NOT add any closing remark, summary sentence, or motivational phrase after the 4 bullet points (e.g. no 'Das ist ein guter Fortschritt', 'Keep it up', 'Good progress', etc.). Write exactly 4 bullet points — nothing before, nothing after. +IMPORTANT: Write your entire response in {LanguageName(language)}."; + + try + { + var requestBody = new + { + model = "mistral-small-latest", + messages = new[] { new { role = "user", content = prompt } }, + max_tokens = 400, + temperature = 0.3 + }; + + var responseText = await MistralUrl + .WithHeader("Authorization", $"Bearer {apiKey}") + .PostJsonAsync(requestBody) + .ReceiveString(); + + var envelope = JsonConvert.DeserializeObject(responseText); + var content = (string?)envelope?.choices?[0]?.message?.content; + + if (!string.IsNullOrWhiteSpace(content)) + { + var insight = content.Trim(); + Console.WriteLine($"[WeeklyReportService] AI insight generated ({insight.Length} chars)."); + return insight; + } + } + catch (Exception ex) + { + Console.Error.WriteLine($"[WeeklyReportService] Mistral error: {ex.Message}"); + } + + return "AI insight could not be generated at this time."; + } +} diff --git a/csharp/App/Backend/Websockets/RabbitMQManager.cs b/csharp/App/Backend/Websockets/RabbitMQManager.cs index 3f6afe52d..48d63f116 100644 --- a/csharp/App/Backend/Websockets/RabbitMQManager.cs +++ b/csharp/App/Backend/Websockets/RabbitMQManager.cs @@ -181,7 +181,7 @@ public static class RabbitMqManager //If the status has changed, update all the connected front-ends regarding this installation if(prevStatus != receivedStatusMessage.Status && WebsocketManager.InstallationConnections[installationId].Connections.Count > 0) { - WebsocketManager.InformWebsocketsForInstallation(installationId); + _ = WebsocketManager.InformWebsocketsForInstallation(installationId); // fire-and-forget: sync event handler, can't await } } } diff --git a/csharp/App/Backend/Websockets/WebsockerManager.cs b/csharp/App/Backend/Websockets/WebsockerManager.cs index 57ffc7bea..5d521364a 100644 --- a/csharp/App/Backend/Websockets/WebsockerManager.cs +++ b/csharp/App/Backend/Websockets/WebsockerManager.cs @@ -17,6 +17,8 @@ public static class WebsocketManager { while (true) { + var idsToInform = new List(); + lock (InstallationConnections) { Console.WriteLine("Monitoring installation table..."); @@ -31,10 +33,8 @@ public static class WebsocketManager (installationConnection.Value.Product == (int)ProductType.SodiStoreMax && (DateTime.Now - installationConnection.Value.Timestamp) > TimeSpan.FromMinutes(2)) ) { - Console.WriteLine("Installation ID is " + installationConnection.Key); Console.WriteLine("installationConnection.Value.Timestamp is " + installationConnection.Value.Timestamp); - // Console.WriteLine("diff is "+(DateTime.Now-installationConnection.Value.Timestamp)); installationConnection.Value.Status = (int)StatusType.Offline; Installation installation = Db.Installations.FirstOrDefault(f => f.Product == installationConnection.Value.Product && f.Id == installationConnection.Key); @@ -42,42 +42,59 @@ public static class WebsocketManager installation.Apply(Db.Update); if (installationConnection.Value.Connections.Count > 0) { - InformWebsocketsForInstallation(installationConnection.Key); + idsToInform.Add(installationConnection.Key); } } } } + // Send notifications outside the lock so we can await the async SendAsync calls + foreach (var id in idsToInform) + await InformWebsocketsForInstallation(id); + await Task.Delay(TimeSpan.FromMinutes(1)); } } //Inform all the connected websockets regarding installation "installationId" - public static void InformWebsocketsForInstallation(Int64 installationId) + public static async Task InformWebsocketsForInstallation(Int64 installationId) { var installation = Db.GetInstallationById(installationId); - var installationConnection = InstallationConnections[installationId]; - Console.WriteLine("Update all the connected websockets for installation " + installation.Name); - - var jsonObject = new - { - id = installationId, - status = installationConnection.Status, - testingMode = installation.TestingMode - }; + byte[] dataToSend; + List connections; - string jsonString = JsonSerializer.Serialize(jsonObject); - byte[] dataToSend = Encoding.UTF8.GetBytes(jsonString); - - foreach (var connection in installationConnection.Connections) + lock (InstallationConnections) { - connection.SendAsync( - new ArraySegment(dataToSend, 0, dataToSend.Length), - WebSocketMessageType.Text, - true, // Indicates that this is the end of the message - CancellationToken.None - ); + var installationConnection = InstallationConnections[installationId]; + Console.WriteLine("Update all the connected websockets for installation " + installation.Name); + + var jsonObject = new + { + id = installationId, + status = installationConnection.Status, + testingMode = installation.TestingMode + }; + + dataToSend = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(jsonObject)); + connections = installationConnection.Connections.ToList(); // snapshot before releasing lock } + + // Send to all connections concurrently (preserves original fire-and-forget intent), + // but isolate failures so one closed socket doesn't affect others or crash the caller. + await Task.WhenAll(connections + .Where(c => c.State == WebSocketState.Open) + .Select(async c => + { + try + { + await c.SendAsync(new ArraySegment(dataToSend, 0, dataToSend.Length), + WebSocketMessageType.Text, true, CancellationToken.None); + } + catch (Exception ex) + { + Console.WriteLine($"WebSocket send failed for installation {installationId}: {ex.Message}"); + } + })); } @@ -109,9 +126,9 @@ public static class WebsocketManager var jsonString = JsonSerializer.Serialize(jsonObject); var dataToSend = Encoding.UTF8.GetBytes(jsonString); - currentWebSocket.SendAsync(dataToSend, + await currentWebSocket.SendAsync(dataToSend, WebSocketMessageType.Text, - true, + true, CancellationToken.None ); @@ -120,6 +137,7 @@ public static class WebsocketManager //Received a new message from this websocket. //We have a HandleWebSocketConnection per connected frontend + byte[] encodedDataToSend; lock (InstallationConnections) { List dataToSend = new List(); @@ -157,15 +175,7 @@ public static class WebsocketManager } var jsonString = JsonSerializer.Serialize(dataToSend); - var encodedDataToSend = Encoding.UTF8.GetBytes(jsonString); - - - currentWebSocket.SendAsync(encodedDataToSend, - WebSocketMessageType.Text, - true, // Indicates that this is the end of the message - CancellationToken.None - ); - + encodedDataToSend = Encoding.UTF8.GetBytes(jsonString); // Console.WriteLine("Printing installation connection list"); // Console.WriteLine("----------------------------------------------"); @@ -175,6 +185,12 @@ public static class WebsocketManager // } // Console.WriteLine("----------------------------------------------"); } + + await currentWebSocket.SendAsync(encodedDataToSend, + WebSocketMessageType.Text, + true, + CancellationToken.None + ); } lock (InstallationConnections) diff --git a/csharp/App/Backend/__pycache__/generate_alarm_translations.cpython-310.pyc b/csharp/App/Backend/__pycache__/generate_alarm_translations.cpython-310.pyc new file mode 100644 index 000000000..6f54ae44f Binary files /dev/null and b/csharp/App/Backend/__pycache__/generate_alarm_translations.cpython-310.pyc differ diff --git a/csharp/App/Backend/generate_alarm_translations.py b/csharp/App/Backend/generate_alarm_translations.py new file mode 100644 index 000000000..f5537bd96 --- /dev/null +++ b/csharp/App/Backend/generate_alarm_translations.py @@ -0,0 +1,320 @@ +#!/usr/bin/env python3 +""" +generate_alarm_translations.py + +Post-campaign script: reads AlarmTranslationsChecked.de.json (the reviewed and +AI-synthesized German content), translates into English, French, and Italian, +and writes: + + Resources/AlarmTranslations.de.json ← replace with reviewed German + Resources/AlarmTranslations.en.json ← back-translated from German + Resources/AlarmTranslations.fr.json ← translated from German + Resources/AlarmTranslations.it.json ← translated from German + Services/AlarmKnowledgeBase.cs ← updated English source (keeps same structure) + +Run this AFTER the review campaign is complete: + export MISTRAL_API_KEY=your_key_here + cd csharp/App/Backend + python3 generate_alarm_translations.py +""" + +import json +import os +import re +import sys +import time +import shutil +from typing import Optional +import requests + +# ── Config ───────────────────────────────────────────────────────────────── + +CHECKED_FILE = "Resources/AlarmTranslationsChecked.de.json" +KNOWLEDGE_BASE = "Services/AlarmKnowledgeBase.cs" +RESOURCES_DIR = "Resources" +MISTRAL_URL = "https://api.mistral.ai/v1/chat/completions" +MISTRAL_MODEL = "mistral-large-latest" +BATCH_SIZE = 5 # alarms per API call +RETRY_DELAY = 5 # seconds between retries on rate-limit +MAX_RETRIES = 3 +REQUEST_TIMEOUT = (10, 90) + +TARGET_LANGUAGES = { + "en": "English", + "fr": "French", + "it": "Italian", +} + + +# ── Mistral API ───────────────────────────────────────────────────────────── + +def call_mistral(api_key: str, prompt: str) -> Optional[str]: + headers = { + "Authorization": f"Bearer {api_key}", + "Content-Type": "application/json", + } + body = { + "model": MISTRAL_MODEL, + "messages": [{"role": "user", "content": prompt}], + "max_tokens": 1800, + "temperature": 0.1, + } + + for attempt in range(1, MAX_RETRIES + 1): + try: + resp = requests.post(MISTRAL_URL, headers=headers, json=body, timeout=REQUEST_TIMEOUT) + if resp.status_code == 429: + print(f" Rate limited, waiting {RETRY_DELAY}s (attempt {attempt}/{MAX_RETRIES})...") + time.sleep(RETRY_DELAY * attempt) + continue + resp.raise_for_status() + content = resp.json()["choices"][0]["message"]["content"].strip() + if content.startswith("```"): + first_newline = content.index("\n") + content = content[first_newline + 1:] + if content.endswith("```"): + content = content[:-3].strip() + return content + except requests.RequestException as e: + print(f" HTTP error: {e} (attempt {attempt}/{MAX_RETRIES})") + time.sleep(RETRY_DELAY) + + return None + + +def translate_batch(api_key: str, batch: dict, target_language: str) -> Optional[dict]: + """ + Translates a batch of German alarm entries into the target language. + Input: { "AlarmKey": { "Explanation": "...", "Causes": [...], "NextSteps": [...] } } + Output: same structure in target language. + """ + prompt = f"""You are translating battery energy storage system alarm descriptions from German into {target_language}. +The source content has been reviewed by field engineers and is accurate. +Translate faithfully — keep the same number of bullet points, same meaning, plain language for homeowners. + +Input JSON (German): +{json.dumps(batch, ensure_ascii=False, indent=2)} + +Return ONLY a valid JSON object with the same alarm keys. Each value must have exactly: +{{ + "Explanation": "translated explanation (1 sentence)", + "Causes": ["translated cause 1", ...], + "NextSteps": ["translated step 1", ...] +}} + +Reply with ONLY the JSON object, no markdown, no extra text.""" + + raw = call_mistral(api_key, prompt) + if raw is None: + return None + + try: + return json.loads(raw) + except json.JSONDecodeError as e: + print(f" JSON parse error: {e}") + print(f" Raw (first 300 chars): {raw[:300]}") + return None + + +# ── AlarmKnowledgeBase.cs generation ──────────────────────────────────────── + +def parse_kb_key_sections(filepath: str) -> dict: + """ + Reads AlarmKnowledgeBase.cs and returns {key: "Sinexcel"|"Growatt"} + preserving the original section order. + """ + with open(filepath, "r", encoding="utf-8") as f: + content = f.read() + + sinexcel_match = re.search(r'SinexcelAlarms\s*=\s*new Dictionary.*?\{(.*?)^\s*\};', content, re.DOTALL | re.MULTILINE) + growatt_match = re.search(r'GrowattAlarms\s*=\s*new Dictionary.*?\{(.*?)^\s*\};', content, re.DOTALL | re.MULTILINE) + + result = {} + if sinexcel_match: + for key in re.findall(r'\["(\w+)"\]\s*=\s*new\(\)', sinexcel_match.group(1)): + result[key] = "Sinexcel" + if growatt_match: + for key in re.findall(r'\["(\w+)"\]\s*=\s*new\(\)', growatt_match.group(1)): + result[key] = "Growatt" + return result + + +def cs_escape(s: str) -> str: + """Escapes a string for use inside a C# double-quoted string literal.""" + return s.replace("\\", "\\\\").replace('"', '\\"') + + +def write_knowledge_base_cs(filepath: str, en_translations: dict, key_sections: dict): + """ + Writes an updated AlarmKnowledgeBase.cs using the new English translations, + preserving the original Sinexcel/Growatt section structure. + """ + sinexcel_keys = [k for k, s in key_sections.items() if s == "Sinexcel"] + growatt_keys = [k for k, s in key_sections.items() if s == "Growatt"] + + def entry_block(key: str) -> str: + entry = en_translations.get(key) + if not entry: + return f' // [{key}] — no translation available\n' + exp = cs_escape(entry.get("Explanation", "")) + causes = ",\n ".join(f'"{cs_escape(c)}"' for c in entry.get("Causes", [])) + steps = ",\n ".join(f'"{cs_escape(s)}"' for s in entry.get("NextSteps", [])) + return ( + f' ["{key}"] = new()\n' + f' {{\n' + f' Explanation = "{exp}",\n' + f' Causes = new[] {{ {causes} }},\n' + f' NextSteps = new[] {{ {steps} }}\n' + f' }},\n' + ) + + lines = [] + lines.append("namespace InnovEnergy.App.Backend.Services;\n") + lines.append("\n") + lines.append("/// \n") + lines.append("/// Static knowledge base for Sinexcel and Growatt alarms.\n") + lines.append("/// Provides pre-defined diagnostics without requiring Mistral API calls.\n") + lines.append("/// Updated by generate_alarm_translations.py after the review campaign.\n") + lines.append("/// \n") + lines.append("public static class AlarmKnowledgeBase\n") + lines.append("{\n") + lines.append(" public static DiagnosticResponse? TryGetDiagnosis(string alarmDescription)\n") + lines.append(" {\n") + lines.append(" if (string.IsNullOrWhiteSpace(alarmDescription)) return null;\n") + lines.append(" var normalized = alarmDescription.Trim();\n") + lines.append(" if (SinexcelAlarms.TryGetValue(normalized, out var s)) return s;\n") + lines.append(" if (GrowattAlarms.TryGetValue(normalized, out var g)) return g;\n") + lines.append(" var lower = normalized.ToLowerInvariant();\n") + lines.append(" foreach (var kvp in SinexcelAlarms) if (kvp.Key.ToLowerInvariant() == lower) return kvp.Value;\n") + lines.append(" foreach (var kvp in GrowattAlarms) if (kvp.Key.ToLowerInvariant() == lower) return kvp.Value;\n") + lines.append(" return null;\n") + lines.append(" }\n") + lines.append("\n") + lines.append(" // ── Sinexcel Alarms ──────────────────────────────────────────────────────\n") + lines.append("\n") + lines.append(" private static readonly IReadOnlyDictionary SinexcelAlarms = new Dictionary\n") + lines.append(" {\n") + for key in sinexcel_keys: + lines.append(entry_block(key)) + lines.append(" };\n") + lines.append("\n") + lines.append(" // ── Growatt Alarms ───────────────────────────────────────────────────────\n") + lines.append("\n") + lines.append(" private static readonly IReadOnlyDictionary GrowattAlarms = new Dictionary\n") + lines.append(" {\n") + for key in growatt_keys: + lines.append(entry_block(key)) + lines.append(" };\n") + lines.append("}\n") + + with open(filepath, "w", encoding="utf-8") as f: + f.writelines(lines) + print(f" ✓ Wrote updated AlarmKnowledgeBase.cs ({len(sinexcel_keys)} Sinexcel + {len(growatt_keys)} Growatt keys)") + + +# ── Main ──────────────────────────────────────────────────────────────────── + +def load_env_file(env_path: str) -> dict: + env = {} + try: + with open(env_path) as f: + for line in f: + line = line.strip() + if line and not line.startswith("#") and "=" in line: + k, _, v = line.partition("=") + env[k.strip()] = v.strip() + except FileNotFoundError: + pass + return env + + +def main(): + api_key = os.environ.get("MISTRAL_API_KEY", "").strip() + if not api_key: + script_dir = os.path.dirname(os.path.abspath(__file__)) + api_key = load_env_file(os.path.join(script_dir, ".env")).get("MISTRAL_API_KEY", "").strip() + + if not api_key: + print("ERROR: MISTRAL_API_KEY not found in environment or .env file.") + sys.exit(1) + + print("MISTRAL_API_KEY loaded.") + + # Load reviewed German source + if not os.path.exists(CHECKED_FILE): + print(f"ERROR: {CHECKED_FILE} not found. Run the review campaign first.") + sys.exit(1) + + with open(CHECKED_FILE, "r", encoding="utf-8") as f: + german_source = json.load(f) + + alarm_keys = list(german_source.keys()) + print(f"Loaded {len(alarm_keys)} alarms from {CHECKED_FILE}.") + + # Step 1: copy reviewed German as the new de.json + de_out = os.path.join(RESOURCES_DIR, "AlarmTranslations.de.json") + shutil.copy(CHECKED_FILE, de_out) + print(f"\n✓ Copied reviewed German → {de_out}") + + # Step 2: translate to en, fr, it + all_translations = {} # lang_code → {key → entry} + for lang_code, lang_name in TARGET_LANGUAGES.items(): + print(f"\n── Translating to {lang_name} ({lang_code}) ──") + + translations = {} + failed_keys = [] + + batches = [ + {k: german_source[k] for k in alarm_keys[i:i + BATCH_SIZE]} + for i in range(0, len(alarm_keys), BATCH_SIZE) + ] + + for batch_num, batch in enumerate(batches, 1): + keys_in_batch = list(batch.keys()) + print(f" Batch {batch_num}/{len(batches)}: {', '.join(keys_in_batch)}") + + result = translate_batch(api_key, batch, lang_name) + + if result is None: + print(f" FAILED batch {batch_num} — marking keys as failed") + failed_keys.extend(keys_in_batch) + continue + + for key in keys_in_batch: + if key in result: + entry = result[key] + translations[key] = { + "Explanation": entry.get("Explanation", ""), + "Causes": entry.get("Causes", []), + "NextSteps": entry.get("NextSteps", []), + } + else: + print(f" WARNING: key '{key}' missing from batch result") + failed_keys.append(key) + + if batch_num < len(batches): + time.sleep(1) + + all_translations[lang_code] = translations + out_file = os.path.join(RESOURCES_DIR, f"AlarmTranslations.{lang_code}.json") + with open(out_file, "w", encoding="utf-8") as f: + json.dump(translations, f, ensure_ascii=False, indent=2) + print(f" ✓ Wrote {len(translations)} entries → {out_file}") + + if failed_keys: + print(f" ⚠ Failed keys ({len(failed_keys)}): {failed_keys}") + + # Step 3: update AlarmKnowledgeBase.cs with the new English back-translation + print("\n── Updating AlarmKnowledgeBase.cs ──") + if "en" in all_translations and os.path.exists(KNOWLEDGE_BASE): + key_sections = parse_kb_key_sections(KNOWLEDGE_BASE) + write_knowledge_base_cs(KNOWLEDGE_BASE, all_translations["en"], key_sections) + else: + print(" Skipped — en.json not generated or AlarmKnowledgeBase.cs not found.") + + print("\n✓ Done. Review the output files before deploying.") + print(" Next: cd csharp/App/Backend && dotnet build && ./deploy.sh") + + +if __name__ == "__main__": + main() diff --git a/csharp/App/Backend/tmp_report/848.xlsx b/csharp/App/Backend/tmp_report/848.xlsx new file mode 100644 index 000000000..e729511ce Binary files /dev/null and b/csharp/App/Backend/tmp_report/848.xlsx differ diff --git a/typescript/frontend-marios2/src/App.tsx b/typescript/frontend-marios2/src/App.tsx index 8ea1209fe..b03530cb7 100644 --- a/typescript/frontend-marios2/src/App.tsx +++ b/typescript/frontend-marios2/src/App.tsx @@ -1,21 +1,22 @@ import { Navigate, Route, Routes, useNavigate } from 'react-router-dom'; import { CssBaseline } from '@mui/material'; import ThemeProvider from './theme/ThemeProvider'; -import React, { lazy, Suspense, useContext, useState } from 'react'; +import React, { lazy, Suspense, useContext, useEffect, useState } from 'react'; import { UserContext } from './contexts/userContext'; import Login from './components/login'; import { IntlProvider } from 'react-intl'; import en from './lang/en.json'; import de from './lang/de.json'; import fr from './lang/fr.json'; +import it from './lang/it.json'; import SuspenseLoader from './components/SuspenseLoader'; +import axiosConfig, { axiosConfigWithoutToken } from './Resources/axiosConfig'; import SidebarLayout from './layouts/SidebarLayout'; import { TokenContext } from './contexts/tokenContext'; import InstallationTabs from './content/dashboards/Installations/index'; import routes from 'src/Resources/routes.json'; import './App.css'; import ForgotPassword from './components/ForgotPassword'; -import { axiosConfigWithoutToken } from './Resources/axiosConfig'; import InstallationsContextProvider from './contexts/InstallationsContextProvider'; import AccessContextProvider from './contexts/AccessContextProvider'; import SalidomoInstallationTabs from './content/dashboards/SalidomoInstallations'; @@ -37,15 +38,38 @@ function App() { setAccessToSodistore } = useContext(ProductIdContext); - const [language, setLanguage] = useState('en'); + const [language, setLanguage] = useState( + () => localStorage.getItem('language') || currentUser?.language || 'en' + ); + + const onSelectLanguage = (lang: string) => { + setLanguage(lang); + localStorage.setItem('language', lang); + if (currentUser) { + const updatedUser = { ...currentUser, language: lang }; + setUser(updatedUser); + axiosConfig.put('/UpdateUser', updatedUser).catch(() => {}); + } + }; + + // Sync localStorage language to DB when it differs (e.g. user changed language before new code was deployed) + useEffect(() => { + if (currentUser && token) { + const storedLang = localStorage.getItem('language'); + if (storedLang && storedLang !== currentUser.language) { + const updatedUser = { ...currentUser, language: storedLang }; + setUser(updatedUser); + axiosConfig.put('/UpdateUser', updatedUser).catch(() => {}); + } + } + }, [token]); + const getTranslations = () => { switch (language) { - case 'en': - return en; - case 'de': - return de; - case 'fr': - return fr; + case 'de': return de; + case 'fr': return fr; + case 'it': return it; + default: return en; } }; @@ -151,7 +175,7 @@ function App() { element={ } > diff --git a/typescript/frontend-marios2/src/Resources/routes.json b/typescript/frontend-marios2/src/Resources/routes.json index 8629e04cd..215866358 100644 --- a/typescript/frontend-marios2/src/Resources/routes.json +++ b/typescript/frontend-marios2/src/Resources/routes.json @@ -20,5 +20,6 @@ "configuration": "configuration", "history": "history", "mainstats": "mainstats", - "detailed_view": "detailed_view/" + "detailed_view": "detailed_view/", + "report": "report" } diff --git a/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryView.tsx b/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryView.tsx index 34f8d9954..0dd779294 100644 --- a/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryView.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryView.tsx @@ -1,4 +1,5 @@ import React, { useContext, useEffect, useState } from 'react'; +import { FormattedMessage, useIntl } from 'react-intl'; import { I_S3Credentials } from '../../../interfaces/S3Types'; import { Box, @@ -36,6 +37,7 @@ function DetailedBatteryView(props: DetailedBatteryViewProps) { if (props.batteryData === null) { return null; } + const intl = useIntl(); const navigate = useNavigate(); const [openModalFirmwareUpdate, setOpenModalFirmwareUpdate] = useState(false); const [openModalResultFirmwareUpdate, setOpenModalResultFirmwareUpdate] = @@ -242,7 +244,7 @@ function DetailedBatteryView(props: DetailedBatteryViewProps) { } } catch (error) { console.error('Error:', error.message); - setErrorMessage('Download battery log failed, please try again.'); + setErrorMessage(intl.formatMessage({ id: 'downloadBatteryLogFailed' })); setOpenModalError(true); } finally { setOpenModalStartDownloadBatteryLog(false); @@ -282,7 +284,7 @@ function DetailedBatteryView(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - The firmware is getting updated. Please wait... +
    - Ok +
    @@ -337,12 +339,11 @@ function DetailedBatteryView(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - Do you really want to update the firmware? + - This action requires the battery service to be stopped for around - 10-15 minutes. +
    - Proceed +
    @@ -409,8 +410,7 @@ function DetailedBatteryView(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - The battery log is getting downloaded. It will be saved in the - Downloads folder. Please wait... +
    - Ok +
    @@ -465,12 +465,11 @@ function DetailedBatteryView(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - Do you really want to download battery log? + - This action requires the battery service to be stopped for around - 10-15 minutes. +
    - Proceed +
    @@ -553,7 +552,7 @@ function DetailedBatteryView(props: DetailedBatteryViewProps) { }} onClick={ErrorModalHandleOk} > - Ok + diff --git a/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryViewSalidomo.tsx b/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryViewSalidomo.tsx index e62529324..5eb2172c7 100644 --- a/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryViewSalidomo.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/BatteryView/DetailedBatteryViewSalidomo.tsx @@ -1,4 +1,5 @@ import React, { useContext, useEffect, useState } from 'react'; +import { FormattedMessage, useIntl } from 'react-intl'; import { I_S3Credentials } from '../../../interfaces/S3Types'; import { Box, @@ -36,7 +37,7 @@ function DetailedBatteryViewSalidomo(props: DetailedBatteryViewProps) { if (props.batteryData === null) { return null; } - + const intl = useIntl(); const navigate = useNavigate(); const [openModalFirmwareUpdate, setOpenModalFirmwareUpdate] = useState(false); const [openModalResultFirmwareUpdate, setOpenModalResultFirmwareUpdate] = @@ -243,7 +244,7 @@ function DetailedBatteryViewSalidomo(props: DetailedBatteryViewProps) { } } catch (error) { console.error('Error:', error.message); - setErrorMessage('Download battery log failed, please try again.'); + setErrorMessage(intl.formatMessage({ id: 'downloadBatteryLogFailed' })); setOpenModalError(true); } finally { setOpenModalStartDownloadBatteryLog(false); @@ -283,7 +284,7 @@ function DetailedBatteryViewSalidomo(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - The firmware is getting updated. Please wait... +
    - Ok +
    @@ -338,12 +339,11 @@ function DetailedBatteryViewSalidomo(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - Do you really want to update the firmware? + - This action requires the battery service to be stopped for around - 10-15 minutes. +
    - Proceed +
    @@ -410,8 +410,7 @@ function DetailedBatteryViewSalidomo(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - The battery log is getting downloaded. It will be saved in the - Downloads folder. Please wait... +
    - Ok +
    @@ -466,12 +465,11 @@ function DetailedBatteryViewSalidomo(props: DetailedBatteryViewProps) { gutterBottom sx={{ fontWeight: 'bold' }} > - Do you really want to download battery log? + - This action requires the battery service to be stopped for around - 10-15 minutes. +
    - Proceed +
    @@ -554,7 +552,7 @@ function DetailedBatteryViewSalidomo(props: DetailedBatteryViewProps) { }} onClick={ErrorModalHandleOk} > - Ok + diff --git a/typescript/frontend-marios2/src/content/dashboards/Information/InformationSodistoreHome.tsx b/typescript/frontend-marios2/src/content/dashboards/Information/InformationSodistoreHome.tsx index cebd9afbb..bc8f7ab75 100644 --- a/typescript/frontend-marios2/src/content/dashboards/Information/InformationSodistoreHome.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/Information/InformationSodistoreHome.tsx @@ -175,6 +175,9 @@ function InformationSodistorehome(props: InformationSodistorehomeProps) { return true; }; + const canEdit = currentUser.userType === UserType.admin; + const isPartner = currentUser.userType === UserType.partner; + return ( <> {openModalDeleteInstallation && ( @@ -276,6 +279,7 @@ function InformationSodistorehome(props: InformationSodistorehomeProps) { onChange={handleChange} variant="outlined" fullWidth + inputProps={{ readOnly: !canEdit }} />
    @@ -288,8 +292,9 @@ function InformationSodistorehome(props: InformationSodistorehomeProps) { onChange={handleChange} variant="outlined" fullWidth - required - error={formValues.region === ''} + required={canEdit} + error={canEdit && formValues.region === ''} + inputProps={{ readOnly: !canEdit }} />
    @@ -305,8 +310,9 @@ function InformationSodistorehome(props: InformationSodistorehomeProps) { onChange={handleChange} variant="outlined" fullWidth - required - error={formValues.location === ''} + required={canEdit} + error={canEdit && formValues.location === ''} + inputProps={{ readOnly: !canEdit }} />
    @@ -319,23 +325,26 @@ function InformationSodistorehome(props: InformationSodistorehomeProps) { onChange={handleChange} variant="outlined" fullWidth - required - error={formValues.country === ''} + required={canEdit} + error={canEdit && formValues.country === ''} + inputProps={{ readOnly: !canEdit }} />
    -
    - - } - name="vpnIp" - value={formValues.vpnIp} - onChange={handleChange} - variant="outlined" - fullWidth - /> -
    + {canEdit && ( +
    + + } + name="vpnIp" + value={formValues.vpnIp} + onChange={handleChange} + variant="outlined" + fullWidth + /> +
    + )}
    {DeviceTypes.map((device) => ( @@ -372,106 +382,116 @@ function InformationSodistorehome(props: InformationSodistorehomeProps) {
    -
    - - } - name="serialNumber" - value={formValues.serialNumber} - onChange={handleChange} - variant="outlined" - fullWidth - /> -
    - -
    - - } - name="inverterSN" - value={formValues.inverterSN} - onChange={handleChange} - variant="outlined" - fullWidth - /> -
    - -
    - - } - name="dataloggerSN" - value={formValues.dataloggerSN} - onChange={handleChange} - variant="outlined" - fullWidth - /> -
    - -
    - - } - name="batteryClusterNumber" - value={formValues.batteryClusterNumber} - onChange={handleChange} - variant="outlined" - fullWidth - /> -
    - -
    - - } - name="batteryNumber" - type="text" - value={batteryNumber === 0 ? '' : batteryNumber} - onChange={handleBatteryNumberChange} - variant="outlined" - fullWidth - placeholder="Enter number of batteries" - /> -
    - - {batteryNumber > 0 && - batterySerialNumbers.map((serialNumber, index) => ( -
    + {(canEdit || isPartner) && ( + <> +
    - handleBatterySerialNumberChange(index, e.target.value) + label={ + } - onKeyDown={(e) => handleBatterySnKeyDown(e, index)} - inputRef={(el) => (batterySnRefs.current[index] = el)} + name="serialNumber" + value={formValues.serialNumber} + onChange={handleChange} variant="outlined" fullWidth - placeholder="Scan or enter serial number" + inputProps={{ readOnly: !canEdit }} />
    - ))} + +
    + + } + name="inverterSN" + value={formValues.inverterSN} + onChange={handleChange} + variant="outlined" + fullWidth + inputProps={{ readOnly: !canEdit }} + /> +
    + +
    + + } + name="dataloggerSN" + value={formValues.dataloggerSN} + onChange={handleChange} + variant="outlined" + fullWidth + inputProps={{ readOnly: !canEdit }} + /> +
    + +
    + + } + name="batteryClusterNumber" + value={formValues.batteryClusterNumber} + onChange={handleChange} + variant="outlined" + fullWidth + inputProps={{ readOnly: !canEdit }} + /> +
    + +
    + + } + name="batteryNumber" + type="text" + value={batteryNumber === 0 ? '' : batteryNumber} + onChange={handleBatteryNumberChange} + variant="outlined" + fullWidth + placeholder={canEdit ? 'Enter number of batteries' : ''} + inputProps={{ readOnly: !canEdit }} + /> +
    + + {batteryNumber > 0 && + batterySerialNumbers.map((serialNumber, index) => ( +
    + + handleBatterySerialNumberChange(index, e.target.value) + } + onKeyDown={(e) => handleBatterySnKeyDown(e, index)} + inputRef={(el) => (batterySnRefs.current[index] = el)} + variant="outlined" + fullWidth + placeholder={canEdit ? 'Scan or enter serial number' : ''} + inputProps={{ readOnly: !canEdit }} + /> +
    + ))} + + )}
    - {currentUser.userType == UserType.admin && ( + {canEdit && ( <>
    - + {canEdit && ( + + )} - {currentUser.userType == UserType.admin && ( + {canEdit && ( + + + {demoPanelOpen && ( + + + + + + + + + {demoAlarm === '__custom__' && ( + { setDemoCustom(e.target.value); setDemoResult(null); }} + sx={{ minWidth: 220 }} + /> + )} + + + + + {demoResult && ( + + + + {splitCamelCase(demoResult.alarm)} + + {sourceChip(demoResult.source)} + + + {demoResult.message ? ( + {demoResult.message} + ) : ( + <> + {demoResult.explanation} + + +
      + {(demoResult.causes ?? []).map((c, i) => ( +
    • {c}
      • + ))} +
    + +
      + {(demoResult.nextSteps ?? []).map((s, i) => ( +
    1. {s}
      2. + ))} +
    +     + + )} +     + )} +     + )} + + + {/* AI Diagnosis banner — shown when loading or diagnoses are available */} + {diagnosisLoading && ( + + + + + + + + + + + )} + + {!diagnosisLoading && diagnoses.map((diag, idx) => { + const isExpanded = expandedDiagnoses.has(idx); + return ( + + + + + + {diag.response.name || alarmDisplayName(diag.description)} + + + : {diag.lastSeen} + + + + + {diag.response.explanation} + + + + + {isExpanded && ( + + + + +
      + {diag.response.causes.map((cause, i) => ( +
    • {cause}
      • + ))} +
    + + + + +
      + {diag.response.nextSteps.map((step, i) => ( +
    1. {step}
      2. + ))} +
    +     + )} +     +     +     + ); + })} + @@ -353,7 +625,7 @@ function Log(props: LogProps) { gutterBottom noWrap > - {errorDescriptionMap[error.description] || error.description} + {alarmDisplayName(error.description)}
    - {warningDescriptionMap[warning.description] || warning.description} + {alarmDisplayName(warning.description)}
    0) { setError(true); - - const message = - ( - - ).props.defaultMessage + - ' ' + - NotGrantedAccessUsers.join(', '); - - setErrorMessage(message); + setErrorMessage(intl.formatMessage({ id: 'unableToGrantAccess' }) + ' ' + NotGrantedAccessUsers.join(', ')); } if (grantedAccessUsers.length > 0) { - const message = - ( - - ).props.defaultMessage + - ' ' + - grantedAccessUsers.join(', '); - setUpdatedMessage(message); + setUpdatedMessage(intl.formatMessage({ id: 'grantedAccessToUsers' }) + ' ' + grantedAccessUsers.join(', ')); setUpdated(true); @@ -306,7 +287,7 @@ function Access(props: AccessProps) { }} onClick={handleCloseFolder} > - Ok + diff --git a/typescript/frontend-marios2/src/content/dashboards/ManageAccess/UserAccess.tsx b/typescript/frontend-marios2/src/content/dashboards/ManageAccess/UserAccess.tsx index a0b8f5ddf..3f035d2ae 100644 --- a/typescript/frontend-marios2/src/content/dashboards/ManageAccess/UserAccess.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/ManageAccess/UserAccess.tsx @@ -15,9 +15,11 @@ import { IconButton, InputLabel, ListItem, + ListSubheader, MenuItem, Modal, Select, + Typography, useTheme } from '@mui/material'; import { TokenContext } from 'src/contexts/tokenContext'; @@ -26,10 +28,11 @@ import ListItemAvatar from '@mui/material/ListItemAvatar'; import Avatar from '@mui/material/Avatar'; import ListItemText from '@mui/material/ListItemText'; import PersonIcon from '@mui/icons-material/Person'; +import FolderIcon from '@mui/icons-material/Folder'; import Button from '@mui/material/Button'; import { Close as CloseIcon } from '@mui/icons-material'; import { AccessContext } from 'src/contexts/AccessContextProvider'; -import { FormattedMessage } from 'react-intl'; +import { FormattedMessage, useIntl } from 'react-intl'; import { InnovEnergyUser, UserType } from '../../../interfaces/UserTypes'; import PersonRemoveIcon from '@mui/icons-material/PersonRemove'; import { @@ -47,26 +50,29 @@ function UserAccess(props: UserAccessProps) { return null; } + const intl = useIntl(); const theme = useTheme(); const tokencontext = useContext(TokenContext); const { removeToken } = tokencontext; const context = useContext(UserContext); - const { currentUser, setUser } = context; + const { currentUser } = context; const [openFolder, setOpenFolder] = useState(false); const [openInstallation, setOpenInstallation] = useState(false); const [openModal, setOpenModal] = useState(false); const [selectedFolderNames, setSelectedFolderNames] = useState([]); - const [selectedInstallationNames, setSelectedInstallationNames] = useState< - string[] - >([]); + const [selectedInstallationNames, setSelectedInstallationNames] = useState([]); + + // Available choices for grant modal + const [availableFolders, setAvailableFolders] = useState([]); + const [availableInstallations, setAvailableInstallations] = useState([]); + + // Direct grants for this user + const [directFolders, setDirectFolders] = useState<{ id: number; name: string }[]>([]); + const [directInstallations, setDirectInstallations] = useState<{ id: number; name: string }[]>([]); - const [folders, setFolders] = useState([]); - const [installations, setInstallations] = useState([]); const accessContext = useContext(AccessContext); const { - fetchInstallationsForUser, - accessibleInstallationsForUser, error, setError, updated, @@ -74,146 +80,118 @@ function UserAccess(props: UserAccessProps) { updatedmessage, errormessage, setErrorMessage, - setUpdatedMessage, - RevokeAccessFromResource + setUpdatedMessage } = accessContext; - const fetchFolders = useCallback(async () => { + const fetchDirectGrants = useCallback(async () => { + try { + const [foldersRes, installationsRes] = await Promise.all([ + axiosConfig.get(`/GetDirectFolderAccessForUser?userId=${props.current_user.id}`), + axiosConfig.get(`/GetDirectInstallationAccessForUser?userId=${props.current_user.id}`) + ]); + setDirectFolders(foldersRes.data); + setDirectInstallations(installationsRes.data); + } catch (err) { + if (err.response && err.response.status === 401) removeToken(); + } + }, [props.current_user.id]); + + const fetchAvailableFolders = useCallback(async () => { return axiosConfig .get('/GetAllFolders') - .then((res) => { - setFolders(res.data); - }) + .then((res) => setAvailableFolders(res.data)) .catch((err) => { - if (err.response && err.response.status == 401) { - removeToken(); - } + if (err.response && err.response.status == 401) removeToken(); }); - }, [setFolders]); + }, []); - const fetchInstallations = useCallback(async () => { + const fetchAvailableInstallations = useCallback(async () => { try { - // fetch product 0 - const res0 = await axiosConfig.get( - `/GetAllInstallationsFromProduct?product=0` - ); - const installations0 = res0.data; - - // fetch product 1 - const res1 = await axiosConfig.get( - `/GetAllInstallationsFromProduct?product=3` - ); - const installations1 = res1.data; - - // aggregate - const combined = [...installations0, ...installations1]; - - // update - setInstallations(combined); + const [res0, res1, res2, res3] = await Promise.all([ + axiosConfig.get(`/GetAllInstallationsFromProduct?product=0`), + axiosConfig.get(`/GetAllInstallationsFromProduct?product=1`), + axiosConfig.get(`/GetAllInstallationsFromProduct?product=2`), + axiosConfig.get(`/GetAllInstallationsFromProduct?product=3`) + ]); + setAvailableInstallations([...res0.data, ...res1.data, ...res2.data, ...res3.data]); } catch (err) { - if (err.response && err.response.status === 401) { - removeToken(); - } - } finally { + if (err.response && err.response.status === 401) removeToken(); } - }, [setInstallations]); + }, []); useEffect(() => { - fetchInstallationsForUser(props.current_user.id); + fetchDirectGrants(); }, [props.current_user]); const handleGrantAccess = () => { - fetchFolders(); - fetchInstallations(); + fetchAvailableFolders(); + fetchAvailableInstallations(); setOpenModal(true); setSelectedFolderNames([]); setSelectedInstallationNames([]); }; - const handleFolderChange = (event) => { - setSelectedFolderNames(event.target.value); + const handleRevokeFolder = async (folderId: number, folderName: string) => { + axiosConfig + .post(`/RevokeUserAccessToFolder?UserId=${props.current_user.id}&FolderId=${folderId}`) + .then(() => { + setUpdatedMessage(intl.formatMessage({ id: 'revokedAccessFromUser' }) + ' ' + props.current_user.name); + setUpdated(true); + setTimeout(() => setUpdated(false), 3000); + fetchDirectGrants(); + }) + .catch(() => { + setErrorMessage(intl.formatMessage({ id: 'unableToRevokeAccess' })); + setError(true); + }); }; - const handleInstallationChange = (event) => { - setSelectedInstallationNames(event.target.value); - }; - const handleOpenFolder = () => { - setOpenFolder(true); - }; - - const handleCloseFolder = () => { - setOpenFolder(false); - }; - const handleCancel = () => { - setOpenModal(false); - }; - const handleOpenInstallation = () => { - setOpenInstallation(true); - }; - - const handleCloseInstallation = () => { - setOpenInstallation(false); + const handleRevokeInstallation = async (installationId: number) => { + axiosConfig + .post(`/RevokeUserAccessToInstallation?UserId=${props.current_user.id}&InstallationId=${installationId}`) + .then(() => { + setUpdatedMessage(intl.formatMessage({ id: 'revokedAccessFromUser' }) + ' ' + props.current_user.name); + setUpdated(true); + setTimeout(() => setUpdated(false), 3000); + fetchDirectGrants(); + }) + .catch(() => { + setErrorMessage(intl.formatMessage({ id: 'unableToRevokeAccess' })); + setError(true); + }); }; const handleSubmit = async () => { for (const folderName of selectedFolderNames) { - const folder = folders.find((folder) => folder.name === folderName); - + const folder = availableFolders.find((f) => f.name === folderName); await axiosConfig - .post( - `/GrantUserAccessToFolder?UserId=${props.current_user.id}&FolderId=${folder.id}` - ) - .then((response) => { - if (response) { - setUpdatedMessage( - 'Granted access to user ' + props.current_user.name - ); - setUpdated(true); - } + .post(`/GrantUserAccessToFolder?UserId=${props.current_user.id}&FolderId=${folder.id}`) + .then(() => { + setUpdatedMessage(intl.formatMessage({ id: 'grantedAccessToUser' }, { name: props.current_user.name })); + setUpdated(true); }) - .catch((err) => { - if (err.response && err.response.status === 401) { - setErrorMessage( - `User ${props.current_user.name} already has access to folder "${folder.name}" or you don't have permission to grant this access` - ); - } else { - setErrorMessage('An error has occured'); - } + .catch(() => { + setErrorMessage(intl.formatMessage({ id: 'errorOccured' })); setError(true); }); } for (const installationName of selectedInstallationNames) { - const installation = installations.find( - (installation) => installation.name === installationName - ); - + const installation = availableInstallations.find((i) => i.name === installationName); await axiosConfig - .post( - `/GrantUserAccessToInstallation?UserId=${props.current_user.id}&InstallationId=${installation.id}` - ) - .then((response) => { - if (response) { - setUpdatedMessage( - 'Granted access to user ' + props.current_user.name - ); - setUpdated(true); - } + .post(`/GrantUserAccessToInstallation?UserId=${props.current_user.id}&InstallationId=${installation.id}`) + .then(() => { + setUpdatedMessage(intl.formatMessage({ id: 'grantedAccessToUser' }, { name: props.current_user.name })); + setUpdated(true); }) - .catch((err) => { - if (err.response && err.response.status === 401) { - setErrorMessage( - `User ${props.current_user.name} already has access to installation "${installation.name}" or you don't have permission to grant this access` - ); - } else { - setErrorMessage('An error has occured'); - } + .catch(() => { + setErrorMessage(intl.formatMessage({ id: 'errorOccured' })); setError(true); }); } setOpenModal(false); - fetchInstallationsForUser(props.current_user.id); + fetchDirectGrants(); }; return ( @@ -221,51 +199,25 @@ function UserAccess(props: UserAccessProps) { {updated && ( - + {updatedmessage} - setUpdated(false)} - > + setUpdated(false)}> )} {error && ( - + {errormessage} - setError(false)} - sx={{ - marginLeft: '10px' - }} - > + setError(false)} sx={{ marginLeft: '10px' }}> )} - {}} - aria-labelledby="error-modal" - aria-describedby="error-modal-description" - > + {/* Grant Access Modal */} + {}} aria-labelledby="grant-modal"> - +
    - - + + setSelectedInstallationNames(e.target.value as string[])} open={openInstallation} - onClose={handleCloseInstallation} - onOpen={handleOpenInstallation} + onClose={() => setOpenInstallation(false)} + onOpen={() => setOpenInstallation(true)} renderValue={(selected) => ( -
    - {selected.map((installation) => ( - {installation}, - ))} -
    +
    {selected.map((i) => {i}, )}
    )} > - {installations.map((installation) => ( - - {installation.name} - + {availableInstallations.map((installation) => ( + {installation.name} ))} @@ -395,32 +291,15 @@ function UserAccess(props: UserAccessProps) {
    @@ -431,43 +310,63 @@ function UserAccess(props: UserAccessProps) {     - - {accessibleInstallationsForUser.map((installation, index) => { - const isLast = index === accessibleInstallationsForUser.length - 1; + {/* Folder Access Section */} + + + + + {directFolders.map((folder, index) => { + const isLast = index === directFolders.length - 1; return ( - + { - RevokeAccessFromResource( - 'ToInstallation', - props.current_user.id, - 'InstallationId', - installation.id, - props.current_user.name - ); + handleRevokeFolder(folder.id, folder.name)} edge="end"> + + + ) + } + > + + + + + + + + + + ); + })} + {directFolders.length === 0 && ( + + + + )} + - fetchInstallationsForUser(props.current_user.id); - }} - edge="end" - > + {/* Direct Installation Access Section */} + + + + + {directInstallations.map((installation, index) => { + const isLast = index === directInstallations.length - 1; + return ( + + handleRevokeInstallation(installation.id)} edge="end"> ) @@ -484,22 +383,9 @@ function UserAccess(props: UserAccessProps) { ); })} - - {accessibleInstallationsForUser.length == 0 && ( - - - + {directInstallations.length === 0 && ( + + )} diff --git a/typescript/frontend-marios2/src/content/dashboards/Overview/overview.tsx b/typescript/frontend-marios2/src/content/dashboards/Overview/overview.tsx index 8e0a4a249..d0170668d 100644 --- a/typescript/frontend-marios2/src/content/dashboards/Overview/overview.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/Overview/overview.tsx @@ -621,7 +621,7 @@ function Overview(props: OverviewProps) { )} - {!loading && ( + {!loading && dailyDataArray.length > 0 && ( {dailyData && ( } /> diff --git a/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/FlatInstallationView.tsx b/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/FlatInstallationView.tsx index a8563ee3c..982e187b4 100644 --- a/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/FlatInstallationView.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/FlatInstallationView.tsx @@ -99,6 +99,9 @@ const FlatInstallationView = (props: FlatInstallationViewProps) => { + + + @@ -156,6 +159,19 @@ const FlatInstallationView = (props: FlatInstallationViewProps) => { + + + {installation.serialNumber} + + + - - } - /> + {currentUser.userType !== UserType.client && ( + + } + /> + )} - - } - > + {currentUser.userType !== UserType.client && ( + + } + /> + )} {currentUser.userType == UserType.admin && ( + + } + /> + } diff --git a/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/WeeklyReport.tsx b/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/WeeklyReport.tsx new file mode 100644 index 000000000..de375f997 --- /dev/null +++ b/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/WeeklyReport.tsx @@ -0,0 +1,474 @@ +import { useEffect, useState } from 'react'; +import { useIntl, FormattedMessage } from 'react-intl'; +import { + Box, + Button, + CircularProgress, + Container, + Grid, + Paper, + TextField, + Typography, + Alert +} from '@mui/material'; +import SendIcon from '@mui/icons-material/Send'; +import axiosConfig from 'src/Resources/axiosConfig'; + +interface WeeklyReportProps { + installationId: number; +} + +interface DailyEnergyData { + date: string; + pvProduction: number; + loadConsumption: number; + gridImport: number; + gridExport: number; + batteryCharged: number; + batteryDischarged: number; +} + +interface WeeklySummary { + totalPvProduction: number; + totalConsumption: number; + totalGridImport: number; + totalGridExport: number; + totalBatteryCharged: number; + totalBatteryDischarged: number; +} + +interface WeeklyReportResponse { + installationName: string; + periodStart: string; + periodEnd: string; + currentWeek: WeeklySummary; + previousWeek: WeeklySummary | null; + totalEnergySaved: number; + totalSavingsCHF: number; + daysEquivalent: number; + selfSufficiencyPercent: number; + selfConsumptionPercent: number; + batteryEfficiencyPercent: number; + gridDependencyPercent: number; + pvChangePercent: number; + consumptionChangePercent: number; + gridImportChangePercent: number; + dailyData: DailyEnergyData[]; + aiInsight: string; +} + +// Matches: time ranges (14:00–18:00), times (09:00), decimals (126.4 / 1,3), integers (34) +// Any number in any language gets bolded — no unit matching needed +const BOLD_PATTERN = /(\d{1,2}:\d{2}(?:[–\-]\d{1,2}:\d{2})?|\d+[.,]\d+|\d+)/g; +const isBold = (s: string) => /\d/.test(s); + +// Renders a bullet line: bolds the "Title" part before the first colon, and numbers with units +function FormattedBullet({ text }: { text: string }) { + const colonIdx = text.indexOf(':'); + if (colonIdx > 0) { + const title = text.slice(0, colonIdx); + const rest = text.slice(colonIdx + 1); // e.g. " This week, your system saved 120.9 kWh..." + const restParts = rest.split(BOLD_PATTERN).map((p, i) => + isBold(p) ? {p} : {p} + ); + return <>{title}:{restParts}; + } + // No colon — just bold figures + const parts = text.split(BOLD_PATTERN).map((p, i) => + isBold(p) ? {p} : {p} + ); + return <>{parts}; +} + +function WeeklyReport({ installationId }: WeeklyReportProps) { + const intl = useIntl(); + const [report, setReport] = useState(null); + const [loading, setLoading] = useState(true); + const [error, setError] = useState(null); + const [email, setEmail] = useState(''); + const [sending, setSending] = useState(false); + const [sendStatus, setSendStatus] = useState<{ + message: string; + severity: 'success' | 'error'; + } | null>(null); + + useEffect(() => { + fetchReport(); + }, [installationId, intl.locale]); + + const fetchReport = async () => { + setLoading(true); + setError(null); + try { + const res = await axiosConfig.get('/GetWeeklyReport', { + params: { installationId, language: intl.locale } + }); + setReport(res.data); + } catch (err: any) { + const msg = + err.response?.data || + err.message || + 'Failed to load report. Make sure the Excel file is placed in tmp_report/'; + setError(typeof msg === 'string' ? msg : JSON.stringify(msg)); + } finally { + setLoading(false); + } + }; + + const handleSendEmail = async () => { + if (!email.trim()) return; + setSending(true); + try { + await axiosConfig.post('/SendWeeklyReportEmail', null, { + params: { installationId, emailAddress: email.trim() } + }); + setSendStatus({ message: intl.formatMessage({ id: 'reportSentTo' }, { email }), severity: 'success' }); + } catch (err: any) { + setSendStatus({ message: intl.formatMessage({ id: 'reportSendError' }), severity: 'error' }); + } finally { + setSending(false); + } + }; + + if (loading) { + return ( + + + + + + + ); + } + + if (error) { + return ( + + + + ); + } + + if (!report) return null; + + const cur = report.currentWeek; + const prev = report.previousWeek; + + // Backend: currentWeek = last 7 days, previousWeek = everything before + const currentWeekDayCount = Math.min(7, report.dailyData.length); + const previousWeekDayCount = Math.max(1, report.dailyData.length - currentWeekDayCount); + + const formatChange = (pct: number) => + pct === 0 ? '—' : pct > 0 ? `+${pct.toFixed(1)}%` : `${pct.toFixed(1)}%`; + + const changeColor = (pct: number, invert = false) => { + const effective = invert ? -pct : pct; + return effective > 0 ? '#27ae60' : effective < 0 ? '#e74c3c' : '#888'; + }; + + // Parse AI insight into bullet points + const insightBullets = report.aiInsight + .split(/\n+/) + .map((line) => line.replace(/^[\d]+[.)]\s*/, '').replace(/^[-*]\s*/, '').trim()) + .filter((line) => line.length > 0); + + // Read pre-computed values from backend — no arithmetic in the frontend + const totalEnergySavedKwh = report.totalEnergySaved; + const totalSavingsCHF = report.totalSavingsCHF; + + // Find max value for daily bar chart scaling + const maxDailyValue = Math.max( + ...report.dailyData.map((d) => Math.max(d.pvProduction, d.loadConsumption, d.gridImport)), + 1 + ); + + return ( + + {/* Email bar */} + + + { setEmail(e.target.value); setSendStatus(null); }} + sx={{ width: 280 }} + onKeyDown={(e) => e.key === 'Enter' && handleSendEmail()} + /> + + + {sendStatus && ( + + {sendStatus.message} + + )} + + + {/* Report Header */} + + + + + + {report.installationName} + + + {report.periodStart} — {report.periodEnd} + + + + {/* Weekly Insights (was AI Insights) */} + + + + + + {insightBullets.length > 1 ? ( + + {insightBullets.map((bullet, i) => ( +
    • + ))} + + ) : ( + + + + )} + + + + {/* Your Savings This Week */} + + + + + + + 0 ? `≈ ${report.daysEquivalent} ${intl.formatMessage({ id: 'daysOfYourUsage' })}` : undefined} + /> + + + + + + + + + + + + + + {/* Weekly Summary Table */} + + + + + + + + + + {prev && } + {prev && } + + + + + + {cur.totalPvProduction.toFixed(1)} kWh + {prev && {prev.totalPvProduction.toFixed(1)} kWh} + {prev && {formatChange(report.pvChangePercent)}} + + + + {cur.totalConsumption.toFixed(1)} kWh + {prev && {prev.totalConsumption.toFixed(1)} kWh} + {prev && {formatChange(report.consumptionChangePercent)}} + + + + + + + {(cur.totalConsumption / currentWeekDayCount).toFixed(1)} kWh + + {prev && + {(prev.totalConsumption / previousWeekDayCount).toFixed(1)} kWh + } + {prev && } + + + + {cur.totalGridImport.toFixed(1)} kWh + {prev && {prev.totalGridImport.toFixed(1)} kWh} + {prev && {formatChange(report.gridImportChangePercent)}} + + + + {cur.totalGridExport.toFixed(1)} kWh + {prev && {prev.totalGridExport.toFixed(1)} kWh} + {prev && —} + + + + {cur.totalBatteryCharged.toFixed(1)} / {cur.totalBatteryDischarged.toFixed(1)} kWh + {prev && {prev.totalBatteryCharged.toFixed(1)} / {prev.totalBatteryDischarged.toFixed(1)} kWh} + {prev && —} + + + + + + {/* Daily Breakdown - CSS bar chart */} + {report.dailyData.length > 0 && ( + + + + + {/* Legend */} + + + + + + + + + + + + {/* Bars */} + {report.dailyData.map((d, i) => { + const dt = new Date(d.date); + const dayLabel = dt.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }); + const isCurrentWeek = report.dailyData.length > 7 ? i >= report.dailyData.length - 7 : true; + return ( + + + + {dayLabel} + {!isCurrentWeek && } + + + PV {d.pvProduction.toFixed(1)} | Load {d.loadConsumption.toFixed(1)} | Grid {d.gridImport.toFixed(1)} kWh + + + + 0 ? '2px' : 0, + transition: 'width 0.3s' + }} + /> + 0 ? '2px' : 0, + transition: 'width 0.3s' + }} + /> + 0 ? '2px' : 0, + transition: 'width 0.3s' + }} + /> + + + ); + })} + + )} + + + ); +} + +function SavingsCard({ label, value, subtitle, color, hint }: { label: string; value: string; subtitle: string; color: string; hint?: string }) { + return ( + + + {value} + + + {label} + + + {subtitle} + + {hint && ( + + {hint} + + )} + + ); +} + +export default WeeklyReport; diff --git a/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/index.tsx b/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/index.tsx index a538b196e..5b2e9f0ba 100644 --- a/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/index.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/SodiohomeInstallations/index.tsx @@ -30,7 +30,8 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { 'manage', 'log', 'history', - 'configuration' + 'configuration', + 'report' ]; const [currentTab, setCurrentTab] = useState(undefined); @@ -117,7 +118,6 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { value: 'log', label: }, - { value: 'manage', label: ( @@ -127,14 +127,12 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { /> ) }, - { value: 'information', label: ( ) }, - { value: 'configuration', label: ( @@ -152,6 +150,54 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { defaultMessage="History Of Actions" /> ) + }, + { + value: 'report', + label: ( + + ) + } + ] + : currentUser.userType == UserType.partner + ? [ + { + value: 'live', + label: + }, + { + value: 'overview', + label: + }, + { + value: 'batteryview', + label: ( + + ) + }, + { + value: 'log', + label: + }, + { + value: 'information', + label: ( + + ) + }, + { + value: 'report', + label: ( + + ) } ] : [ @@ -168,14 +214,24 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { label: ( ) + }, + { + value: 'report', + label: ( + + ) } ]; - const tabs = + const inInstallationView = currentTab != 'list' && currentTab != 'tree' && - !location.pathname.includes('folder') && - currentUser.userType == UserType.admin + !location.pathname.includes('folder'); + + const tabs = inInstallationView && currentUser.userType == UserType.admin ? [ { value: 'list', @@ -206,7 +262,6 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { value: 'log', label: }, - { value: 'manage', label: ( @@ -216,7 +271,6 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { /> ) }, - { value: 'information', label: ( @@ -240,12 +294,18 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { defaultMessage="History Of Actions" /> ) + }, + { + value: 'report', + label: ( + + ) } ] - : currentTab != 'list' && - currentTab != 'tree' && - !location.pathname.includes('folder') && - currentUser.userType == UserType.client + : inInstallationView && currentUser.userType == UserType.partner ? [ { value: 'list', @@ -263,12 +323,67 @@ function SodioHomeInstallationTabs(props: SodioHomeInstallationTabsProps) { value: 'overview', label: }, - + { + value: 'batteryview', + label: ( + + ) + }, + { + value: 'log', + label: + }, { value: 'information', label: ( ) + }, + { + value: 'report', + label: ( + + ) + } + ] + : inInstallationView && currentUser.userType == UserType.client + ? [ + { + value: 'list', + icon: + }, + { + value: 'tree', + icon: + }, + { + value: 'live', + label: + }, + { + value: 'overview', + label: + }, + { + value: 'information', + label: ( + + ) + }, + { + value: 'report', + label: ( + + ) } ] : [ diff --git a/typescript/frontend-marios2/src/content/dashboards/Tree/CustomTreeItem.tsx b/typescript/frontend-marios2/src/content/dashboards/Tree/CustomTreeItem.tsx index 036540aa7..469d9658d 100644 --- a/typescript/frontend-marios2/src/content/dashboards/Tree/CustomTreeItem.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/Tree/CustomTreeItem.tsx @@ -1,15 +1,19 @@ import React, { ReactNode, useContext, useState } from 'react'; -import { CircularProgress, ListItemIcon, useTheme } from '@mui/material'; +import { CircularProgress, IconButton, ListItemIcon, useTheme } from '@mui/material'; import { TreeItem } from '@mui/lab'; import { I_Folder, I_Installation } from 'src/interfaces/InstallationTypes'; import FolderIcon from '@mui/icons-material/Folder'; import InsertDriveFileIcon from '@mui/icons-material/InsertDriveFile'; +import DriveFileMoveOutlinedIcon from '@mui/icons-material/DriveFileMoveOutlined'; import Typography from '@mui/material/Typography'; import { makeStyles } from '@mui/styles'; import CancelIcon from '@mui/icons-material/Cancel'; import routes from 'src/Resources/routes.json'; import { useLocation, useNavigate } from 'react-router-dom'; import { ProductIdContext } from '../../../contexts/ProductIdContextProvider'; +import { UserContext } from '../../../contexts/userContext'; +import { UserType } from '../../../interfaces/UserTypes'; +import MoveModal from './MoveModal'; interface CustomTreeItemProps { node: I_Installation | I_Folder; @@ -41,8 +45,10 @@ function CustomTreeItem(props: CustomTreeItemProps) { const status = props.node.status; const navigate = useNavigate(); const [selected, setSelected] = useState(false); + const [openMoveModal, setOpenMoveModal] = useState(false); const currentLocation = useLocation(); const { product } = useContext(ProductIdContext); + const { currentUser } = useContext(UserContext); const handleSelectOneInstallation = (): void => { let installation = props.node; @@ -126,6 +132,24 @@ function CustomTreeItem(props: CustomTreeItemProps) { {props.node.name} + {currentUser.userType === UserType.admin && ( +
    e.stopPropagation()}> + setOpenMoveModal(true)} + sx={{ ml: 1 }} + > + + + {openMoveModal && ( + setOpenMoveModal(false)} + /> + )} +
    + )} + {props.node.type === 'Installation' && (
    {status === -1 ? ( diff --git a/typescript/frontend-marios2/src/content/dashboards/Tree/Folder.tsx b/typescript/frontend-marios2/src/content/dashboards/Tree/Folder.tsx index 6c73ab495..51d1087f5 100644 --- a/typescript/frontend-marios2/src/content/dashboards/Tree/Folder.tsx +++ b/typescript/frontend-marios2/src/content/dashboards/Tree/Folder.tsx @@ -44,12 +44,12 @@ function Folder(props: singleFolderProps) { value: 'information', label: }, - { + ...(currentUser.userType === UserType.admin ? [{ value: 'manage', label: ( ) - } + }] : []) ]; const handleTabsChange = (_event: ChangeEvent<{}>, value: string): void => { diff --git a/typescript/frontend-marios2/src/content/dashboards/Tree/MoveModal.tsx b/typescript/frontend-marios2/src/content/dashboards/Tree/MoveModal.tsx new file mode 100644 index 000000000..b822fbb34 --- /dev/null +++ b/typescript/frontend-marios2/src/content/dashboards/Tree/MoveModal.tsx @@ -0,0 +1,165 @@ +import React, { useContext, useState } from 'react'; +import { + Alert, + Box, + CircularProgress, + FormControl, + IconButton, + InputLabel, + MenuItem, + Modal, + Select, + Typography, + useTheme +} from '@mui/material'; +import Button from '@mui/material/Button'; +import { Close as CloseIcon } from '@mui/icons-material'; +import { I_Folder, I_Installation } from 'src/interfaces/InstallationTypes'; +import { InstallationsContext } from 'src/contexts/InstallationsContextProvider'; +import { ProductIdContext } from 'src/contexts/ProductIdContextProvider'; +import { FormattedMessage } from 'react-intl'; + +interface MoveModalProps { + node: I_Installation | I_Folder; + onClose: () => void; +} + +// Returns the IDs of a folder and all its descendants (to prevent circular moves) +function getDescendantIds(folderId: number, allItems: any[]): Set { + const result = new Set([folderId]); + const queue = [folderId]; + while (queue.length > 0) { + const currentId = queue.shift(); + allItems + .filter((item) => item.parentId === currentId && item.type === 'Folder') + .forEach((child) => { + result.add(child.id); + queue.push(child.id); + }); + } + return result; +} + +function MoveModal(props: MoveModalProps) { + const theme = useTheme(); + const { foldersAndInstallations, moveInstallation, moveFolder, loading, setLoading, error, setError } = + useContext(InstallationsContext); + const { product } = useContext(ProductIdContext); + const [selectedFolderId, setSelectedFolderId] = useState(''); + + // For folders: exclude self and all descendants to prevent circular nesting + // For installations: any folder is valid + const excludedIds = + props.node.type === 'Folder' + ? getDescendantIds(props.node.id, foldersAndInstallations) + : new Set(); + + const availableFolders = foldersAndInstallations.filter( + (item) => item.type === 'Folder' && !excludedIds.has(item.id) + ); + + const handleSubmit = async () => { + if (selectedFolderId === '') return; + setLoading(true); + setError(false); + if (props.node.type === 'Installation') { + await moveInstallation(props.node.id, selectedFolderId as number, product); + } else { + await moveFolder(props.node.id, selectedFolderId as number, product); + } + setLoading(false); + props.onClose(); + }; + + return ( + {}} + aria-labelledby="move-modal" + > + + + :{' '} + + {props.node.name} + + + + + + + + + + +
    + + + + + {loading && ( + + )} + + {error && ( + + + setError(false)} + sx={{ marginLeft: '4px' }} + > + + + + )} +
    +     +     + ); +} + +export default MoveModal; diff --git a/typescript/frontend-marios2/src/contexts/AccessContextProvider.tsx b/typescript/frontend-marios2/src/contexts/AccessContextProvider.tsx index 5280ff674..c7a58c1b6 100644 --- a/typescript/frontend-marios2/src/contexts/AccessContextProvider.tsx +++ b/typescript/frontend-marios2/src/contexts/AccessContextProvider.tsx @@ -11,7 +11,7 @@ import { I_UserWithInheritedAccess, InnovEnergyUser } from '../interfaces/UserTypes'; -import { FormattedMessage } from 'react-intl'; +import { useIntl } from 'react-intl'; import { I_Installation } from '../interfaces/InstallationTypes'; interface AccessContextProviderProps { @@ -69,10 +69,11 @@ export const AccessContext = createContext({ }); const AccessContextProvider = ({ children }: { children: ReactNode }) => { + const intl = useIntl(); const [error, setError] = useState(false); - const [errormessage, setErrorMessage] = useState('An error has occured'); + const [errormessage, setErrorMessage] = useState(''); const [updated, setUpdated] = useState(false); - const [updatedmessage, setUpdatedMessage] = useState('Successfully updated'); + const [updatedmessage, setUpdatedMessage] = useState(''); const tokencontext = useContext(TokenContext); const { removeToken } = tokencontext; const [usersWithDirectAccess, setUsersWithDirectAccess] = useState< @@ -95,20 +96,12 @@ const AccessContextProvider = ({ children }: { children: ReactNode }) => { setUsersWithDirectAccess(response.data); } }) - .catch((error) => { + .catch(() => { setError(true); - - const message = ( - - ).props.defaultMessage; - - setErrorMessage(message); + setErrorMessage(intl.formatMessage({ id: 'unableToLoadData' })); }); }, - [] + [intl] ); const fetchInstallationsForUser = useCallback(async (userId: number) => { @@ -119,17 +112,11 @@ const AccessContextProvider = ({ children }: { children: ReactNode }) => { setAccessibleInstallationsForUser(response.data); } }) - .catch((error) => { + .catch(() => { setError(true); - const message = ( - - ).props.defaultMessage; - setErrorMessage(message); + setErrorMessage(intl.formatMessage({ id: 'unableToLoadData' })); }); - }, []); + }, [intl]); const fetchUsersWithInheritedAccessForResource = useCallback( async (tempresourceType: string, id: number) => { @@ -140,18 +127,12 @@ const AccessContextProvider = ({ children }: { children: ReactNode }) => { setUsersWithInheritedAccess(response.data); } }) - .catch((error) => { + .catch(() => { setError(true); - const message = ( - - ).props.defaultMessage; - setErrorMessage(message); + setErrorMessage(intl.formatMessage({ id: 'unableToLoadData' })); }); }, - [] + [intl] ); const fetchAvailableUsers = async (): Promise => { @@ -183,17 +164,7 @@ const AccessContextProvider = ({ children }: { children: ReactNode }) => { current_ResourceId ); - const message = - ( - - ).props.defaultMessage + - ' ' + - name; - - setUpdatedMessage(message); + setUpdatedMessage(intl.formatMessage({ id: 'revokedAccessFromUser' }) + ' ' + name); setUpdated(true); setTimeout(() => { @@ -201,19 +172,12 @@ const AccessContextProvider = ({ children }: { children: ReactNode }) => { }, 3000); } }) - .catch((error) => { + .catch(() => { setError(true); - const message = ( - - ).props.defaultMessage; - - setErrorMessage(message); + setErrorMessage(intl.formatMessage({ id: 'unableToRevokeAccess' })); }); }, - [] + [intl, fetchUsersWithDirectAccessForResource, fetchUsersWithInheritedAccessForResource] ); return ( diff --git a/typescript/frontend-marios2/src/contexts/InstallationsContextProvider.tsx b/typescript/frontend-marios2/src/contexts/InstallationsContextProvider.tsx index 909b68e5f..939ad344f 100644 --- a/typescript/frontend-marios2/src/contexts/InstallationsContextProvider.tsx +++ b/typescript/frontend-marios2/src/contexts/InstallationsContextProvider.tsx @@ -349,6 +349,42 @@ const InstallationsContextProvider = ({ [fetchAllFoldersAndInstallations, navigate, removeToken] ); + const moveInstallation = useCallback( + async (installationId: number, parentId: number, product: number) => { + try { + await axiosConfig.put( + `/MoveInstallation?installationId=${installationId}&parentId=${parentId}` + ); + await fetchAllFoldersAndInstallations(product); + } catch (error) { + setError(true); + if (error.response?.status === 401) { + removeToken(); + navigate(routes.login); + } + } + }, + [fetchAllFoldersAndInstallations, navigate, removeToken] + ); + + const moveFolder = useCallback( + async (folderId: number, parentId: number, product: number) => { + try { + await axiosConfig.put( + `/MoveFolder?folderId=${folderId}&parentId=${parentId}` + ); + await fetchAllFoldersAndInstallations(product); + } catch (error) { + setError(true); + if (error.response?.status === 401) { + removeToken(); + navigate(routes.login); + } + } + }, + [fetchAllFoldersAndInstallations, navigate, removeToken] + ); + const contextValue = useMemo( () => ({ salimax_or_sodistore_Installations, @@ -369,6 +405,8 @@ const InstallationsContextProvider = ({ createFolder, updateFolder, deleteFolder, + moveInstallation, + moveFolder, //currentProduct, socket, openSocket, diff --git a/typescript/frontend-marios2/src/interfaces/S3Types.tsx b/typescript/frontend-marios2/src/interfaces/S3Types.tsx index 7d9b60efe..d719bf2cc 100644 --- a/typescript/frontend-marios2/src/interfaces/S3Types.tsx +++ b/typescript/frontend-marios2/src/interfaces/S3Types.tsx @@ -31,3 +31,10 @@ export interface Action { description: string; testingMode: boolean; } + +export interface DiagnosticResponse { + name: string; + explanation: string; + causes: string[]; + nextSteps: string[]; +} diff --git a/typescript/frontend-marios2/src/lang/de.json b/typescript/frontend-marios2/src/lang/de.json index 6abfa2c0d..e6ae4a13f 100644 --- a/typescript/frontend-marios2/src/lang/de.json +++ b/typescript/frontend-marios2/src/lang/de.json @@ -13,7 +13,9 @@ "english": "Englisch", "error": "Fehler", "folder": "Ordner", + "french": "Französisch", "german": "Deutsch", + "italian": "Italienisch", "groupTabs": "Gruppen", "groupTree": "Gruppenbaum", "overview": "Überblick", @@ -89,5 +91,292 @@ "unableToGrantAccess": "Der Zugriff kann nicht gewährt werden", "unableToLoadData": "Daten können nicht geladen werden", "unableToRevokeAccess": "Der Zugriff konnte nicht widerrufen werden", - "revokedAccessFromUser": "Zugriff vom Benutzer widerrufen" + "revokedAccessFromUser": "Zugriff vom Benutzer widerrufen", + "Show Errors": "Fehler anzeigen", + "Show Warnings": "Warnungen anzeigen", + "lastSeen": "Zuletzt gesehen", + "reportTitle": "Wöchentlicher Leistungsbericht", + "weeklyInsights": "Wöchentliche Einblicke", + "weeklySavings": "Ihre Einsparungen diese Woche", + "solarEnergyUsed": "Energie gespart", + "solarStayedHome": "Solar + Batterie, nicht vom Netz", + "daysOfYourUsage": "Tage Ihres Verbrauchs", + "estMoneySaved": "Geschätzte Ersparnisse", + "atCHFRate": "bei 0,39 CHF/kWh Ø", + "solarCoverage": "Eigenversorgung", + "fromSolarSub": "aus Solar + Batterie", + "avgDailyConsumption": "Ø Tagesverbrauch", + "batteryEfficiency": "Batterieeffizienz", + "batteryEffSub": "Entladung vs. Ladung", + "weeklySummary": "Wöchentliche Zusammenfassung", + "metric": "Kennzahl", + "thisWeek": "Diese Woche", + "change": "Änderung", + "pvProduction": "PV-Produktion", + "consumption": "Verbrauch", + "gridImport": "Netzbezug", + "gridExport": "Netzeinspeisung", + "batteryInOut": "Batterie Laden / Entladen", + "dailyBreakdown": "Tägliche Aufschlüsselung", + "prevWeek": "(Vorwoche)", + "sendReport": "Bericht senden", + "generatingReport": "Wochenbericht wird erstellt...", + "reportSentTo": "Bericht gesendet an {email}", + "reportSendError": "Senden fehlgeschlagen. Bitte überprüfen Sie die E-Mail-Adresse und versuchen Sie es erneut.", + "ok": "Ok", + "grantedAccessToUser": "Zugriff für Benutzer {name} gewährt", + "proceed": "Fortfahren", + "firmwareUpdating": "Firmware wird aktualisiert. Bitte warten...", + "confirmFirmwareUpdate": "Möchten Sie die Firmware wirklich aktualisieren?", + "batteryServiceStopWarning": "Diese Aktion erfordert, dass der Batteriedienst ca. 10-15 Minuten gestoppt wird.", + "downloadingBatteryLog": "Das Batterieprotokoll wird heruntergeladen. Es wird im Downloads-Ordner gespeichert. Bitte warten...", + "confirmBatteryLogDownload": "Möchten Sie das Batterieprotokoll wirklich herunterladen?", + "downloadBatteryLogFailed": "Herunterladen des Batterieprotokolls fehlgeschlagen, bitte versuchen Sie es erneut.", + "noReportData": "Keine Berichtsdaten gefunden.", + "ai_analyzing": "KI analysiert...", + "ai_show_details": "Details anzeigen", + "ai_show_less": "Weniger anzeigen", + "ai_likely_causes": "Wahrscheinliche Ursachen:", + "ai_next_steps": "Empfohlene nächste Schritte:", + "demo_test_button": "KI-Diagnose testen", + "demo_hide_button": "KI-Diagnose Demo ausblenden", + "demo_panel_title": "KI-Diagnose Demo", + "demo_custom_group": "Benutzerdefiniert (kann Mistral KI verwenden)", + "demo_custom_option": "Benutzerdefinierten Alarm eingeben…", + "demo_custom_placeholder": "z.B. UnknownBatteryFault", + "demo_diagnose_button": "Diagnostizieren", + "alarm_AbnormalGridVoltage": "Unnormale Netzspannung", + "alarm_AbnormalGridFrequency": "Unnormale Netzfrequenz", + "alarm_InvertedSequenceOfGridVoltage": "Falsche Phasenreihenfolge", + "alarm_GridVoltagePhaseLoss": "Phasenausfall im Netz", + "alarm_AbnormalGridCurrent": "Unnormaler Netzstrom", + "alarm_AbnormalOutputVoltage": "Ungewöhnliche Ausgangsspannung", + "alarm_AbnormalOutputFrequency": "Ungewöhnliche Ausgangsfrequenz", + "alarm_AbnormalNullLine": "Fehlerhafter Nullleiter", + "alarm_AbnormalOffGridOutputVoltage": "Ungewöhnliche Backup-Spannung", + "alarm_ExcessivelyHighAmbientTemperature": "Zu hohe Umgebungstemperatur", + "alarm_ExcessiveRadiatorTemperature": "Überhitzter Kühlkörper", + "alarm_PcbOvertemperature": "Überhitzte Leiterplatte", + "alarm_DcConverterOvertemperature": "Überhitzter DC-Wandler", + "alarm_InverterOvertemperatureAlarm": "Warnung: Überhitzung", + "alarm_InverterOvertemperature": "Wechselrichter überhitzt", + "alarm_DcConverterOvertemperatureAlarm": "Übertemperaturalarm DC-Wandler", + "alarm_InsulationFault": "Isolationsfehler", + "alarm_LeakageProtectionFault": "Leckschutzfehler", + "alarm_AbnormalLeakageSelfCheck": "Anomaler Leckstrom-Selbsttest", + "alarm_PoorGrounding": "Schlechte Erdung", + "alarm_FanFault": "Lüfterfehler", + "alarm_AuxiliaryPowerFault": "Hilfsstromversorgung Fehler", + "alarm_ModelCapacityFault": "Modellkapazitätsfehler", + "alarm_AbnormalLightningArrester": "Überspannungsschutz Fehler", + "alarm_IslandProtection": "Inselbetrieb Schutz", + "alarm_Battery1NotConnected": "Batterie 1 nicht verbunden", + "alarm_Battery1Overvoltage": "Batterie 1 Überspannung", + "alarm_Battery1Undervoltage": "Batterie 1 Unterspannung", + "alarm_Battery1DischargeEnd": "Batterie 1 Entladung beendet", + "alarm_Battery1Inverted": "Batterie 1 Polarität vertauscht", + "alarm_Battery1OverloadTimeout": "Batterie 1 Überlastung", + "alarm_Battery1SoftStartFailure": "Batterie 1 Startfehler", + "alarm_Battery1PowerTubeFault": "Batterie 1 Leistungsteil defekt", + "alarm_Battery1InsufficientPower": "Batterie 1 Leistung unzureichend", + "alarm_Battery1BackupProhibited": "Batterie 1 Backup gesperrt", + "alarm_Battery2NotConnected": "Batterie 2 nicht verbunden", + "alarm_Battery2Overvoltage": "Batterie 2 Überspannung", + "alarm_Battery2Undervoltage": "Batterie 2 Unterspannung", + "alarm_Battery2DischargeEnd": "Batterie 2 Entladung beendet", + "alarm_Battery2Inverted": "Batterie 2 falsch angeschlossen", + "alarm_Battery2OverloadTimeout": "Batterie 2 Überlastung", + "alarm_Battery2SoftStartFailure": "Batterie 2 Startfehler", + "alarm_Battery2PowerTubeFault": "Batterie 2 Leistungsteil defekt", + "alarm_Battery2InsufficientPower": "Batterie 2 Leistung unzureichend", + "alarm_Battery2BackupProhibited": "Batterie 2 Backup gesperrt", + "alarm_LithiumBattery1ChargeForbidden": "Lithium-Batterie 1 Ladeverbot", + "alarm_LithiumBattery1DischargeForbidden": "Lithium-Batterie 1 Entladeverbot", + "alarm_LithiumBattery2ChargeForbidden": "Lithium-Batterie 2 Ladeverbot", + "alarm_LithiumBattery2DischargeForbidden": "Lithium-Batterie 2 Entladeverbot", + "alarm_LithiumBattery1Full": "Lithium-Batterie 1 voll", + "alarm_LithiumBattery1DischargeEnd": "Lithium-Batterie 1 entladen", + "alarm_LithiumBattery2Full": "Lithium-Batterie 2 voll", + "alarm_LithiumBattery2DischargeEnd": "Lithium-Batterie 2 entladen", + "alarm_LeadBatteryTemperatureAbnormality": "Batterietemperatur abnormal", + "alarm_BatteryAccessMethodError": "Batteriezugriffsfehler", + "alarm_Pv1NotAccessed": "PV1 nicht erreichbar", + "alarm_Pv1Overvoltage": "PV1 Überspannung", + "alarm_AbnormalPv1CurrentSharing": "Ungleichmäßiger PV1-Strom", + "alarm_Pv1PowerTubeFault": "PV1 Leistungstubus defekt", + "alarm_Pv1SoftStartFailure": "PV1 Soft-Start fehlgeschlagen", + "alarm_Pv1OverloadTimeout": "PV1-Überlastung", + "alarm_Pv1InsufficientPower": "PV1-Schwacher Strom", + "alarm_Photovoltaic1Overcurrent": "PV1-Überstrom", + "alarm_Pv2NotAccessed": "PV2-Nicht erkannt", + "alarm_Pv2Overvoltage": "PV2-Überspannung", + "alarm_AbnormalPv2CurrentSharing": "Ungewöhnliche Stromverteilung PV2", + "alarm_Pv2PowerTubeFault": "PV2-Leistungsrohrfehler", + "alarm_Pv2SoftStartFailure": "PV2-Softstart fehlgeschlagen", + "alarm_Pv2OverloadTimeout": "PV2-Überlastung Timeout", + "alarm_Pv2InsufficientPower": "Unzureichende Leistung PV2", + "alarm_Pv3NotConnected": "PV3 nicht verbunden", + "alarm_Pv3Overvoltage": "PV3 Überspannung", + "alarm_Pv3AverageCurrentAnomaly": "PV3 Stromanomalie", + "alarm_Pv3PowerTubeFailure": "PV3 Leistungselektronik defekt", + "alarm_Pv3SoftStartFailure": "PV3 Startfehler", + "alarm_Pv3OverloadTimeout": "PV3-Überlastung", + "alarm_Pv3ReverseConnection": "PV3-Falschpolung", + "alarm_Pv4NotConnected": "PV4 Nicht Verbunden", + "alarm_Pv4Overvoltage": "PV4 Überspannung", + "alarm_Pv4AverageCurrentAnomaly": "PV4 Stromanomalie", + "alarm_Pv4PowerTubeFailure": "PV4-Leistungsrohr defekt", + "alarm_Pv4SoftStartFailure": "PV4-Softstart fehlgeschlagen", + "alarm_Pv4OverloadTimeout": "PV4-Überlastung", + "alarm_Pv4ReverseConnection": "PV4 falsch angeschlossen", + "alarm_InsufficientPhotovoltaicPower": "Zu wenig Solarstrom", + "alarm_DcBusOvervoltage": "DC-Bus Überspannung", + "alarm_DcBusUndervoltage": "DC-Bus Unterspannung", + "alarm_DcBusVoltageUnbalance": "DC-Bus Spannungsungleichgewicht", + "alarm_BusSlowOvervoltage": "Langsame DC-Bus Überspannung", + "alarm_HardwareBusOvervoltage": "Hardware DC-Bus Überspannung", + "alarm_BusSoftStartFailure": "Fehler beim sanften Start", + "alarm_InverterPowerTubeFault": "Wechselrichter-Leistungshalbleiter defekt", + "alarm_HardwareOvercurrent": "Hardware-Überstrom", + "alarm_DcConverterOvervoltage": "DC-Wandler Überspannung", + "alarm_DcConverterHardwareOvervoltage": "DC-Wandler Hardware-Überspannung", + "alarm_DcConverterOvercurrent": "DC-Wandler Überstrom", + "alarm_DcConverterHardwareOvercurrent": "DC-Wandler Hardware-Überstrom", + "alarm_DcConverterResonatorOvercurrent": "DC-Wandler Resonanz-Überstrom", + "alarm_SystemOutputOverload": "Systemausgang überlastet", + "alarm_InverterOverload": "Wechselrichter überlastet", + "alarm_InverterOverloadTimeout": "Wechselrichter-Überlastung", + "alarm_LoadPowerOverload": "Überlastung der Lastleistung", + "alarm_BalancedCircuitOverloadTimeout": "Phasenausgleich-Überlastung", + "alarm_InverterSoftStartFailure": "Wechselrichter-Softstart-Fehler", + "alarm_Dsp1ParameterSettingFault": "DSP-Parameter-Fehler", + "alarm_Dsp2ParameterSettingFault": "DSP2 Parameterfehler", + "alarm_DspVersionCompatibilityFault": "DSP-Versionen nicht kompatibel", + "alarm_CpldVersionCompatibilityFault": "CPLD-Version nicht kompatibel", + "alarm_CpldCommunicationFault": "CPLD-Kommunikationsfehler", + "alarm_DspCommunicationFault": "DSP-Kommunikationsfehler", + "alarm_OutputVoltageDcOverlimit": "DC-Spannung zu hoch", + "alarm_OutputCurrentDcOverlimit": "DC-Strom zu hoch", + "alarm_RelaySelfCheckFails": "Relais-Selbsttest fehlgeschlagen", + "alarm_InverterRelayOpen": "Wechselrichter-Relais offen", + "alarm_InverterRelayShortCircuit": "Wechselrichter-Relais Kurzschluss", + "alarm_OpenCircuitOfPowerGridRelay": "Netzrelais offen", + "alarm_ShortCircuitOfPowerGridRelay": "Netzrelais kurzgeschlossen", + "alarm_GeneratorRelayOpenCircuit": "Generatorrelais offen", + "alarm_GeneratorRelayShortCircuit": "Generatorrelais kurzgeschlossen", + "alarm_AbnormalInverter": "Wechselrichter abnormal", + "alarm_ParallelCommunicationAlarm": "Parallelkommunikationsalarm", + "alarm_ParallelModuleMissing": "Parallelmodul fehlt", + "alarm_DuplicateMachineNumbersForParallelModules": "Doppelte Gerätenummern", + "alarm_ParameterConflictInParallelModule": "Parameterkonflikt im Parallelmodul", + "alarm_SystemDerating": "Systemleistung reduziert", + "alarm_PvAccessMethodErrorAlarm": "PV-Zugriffsfehler", + "alarm_ReservedAlarms4": "Reservierter Alarm 4", + "alarm_ReservedAlarms5": "Reservierter Alarm 5", + "alarm_ReverseMeterConnection": "Zähler falsch angeschlossen", + "alarm_InverterSealPulse": "Wechselrichter-Leistungsbegrenzung", + "alarm_AbnormalDieselGeneratorVoltage": "Ungewöhnliche Dieselgenerator-Spannung", + "alarm_AbnormalDieselGeneratorFrequency": "Ungewöhnliche Dieselgenerator-Frequenz", + "alarm_DieselGeneratorVoltageReverseSequence": "Falsche Phasenfolge des Generators", + "alarm_DieselGeneratorVoltageOutOfPhase": "Generator nicht synchronisiert", + "alarm_GeneratorOverload": "Generator überlastet", + "alarm_StringFault": "PV-String-Fehler", + "alarm_PvStringPidQuickConnectAbnormal": "PV-String-Anschluss defekt", + "alarm_DcSpdFunctionAbnormal": "DC-Überspannungsschutz defekt", + "alarm_PvShortCircuited": "PV-String kurzgeschlossen", + "alarm_PvBoostDriverAbnormal": "PV-Boost-Treiber defekt", + "alarm_AcSpdFunctionAbnormal": "AC-Überspannungsschutz defekt", + "alarm_DcFuseBlown": "DC-Sicherung durchgebrannt", + "alarm_DcInputVoltageTooHigh": "DC-Eingangsspannung zu hoch", + "alarm_PvReversed": "PV-Polarität vertauscht", + "alarm_PidFunctionAbnormal": "PID-Schutzfunktion gestört", + "alarm_PvStringDisconnected": "PV-String getrennt", + "alarm_PvStringCurrentUnbalanced": "PV-String Strom unausgeglichen", + "alarm_NoUtilityGrid": "Kein Stromnetz", + "alarm_GridVoltageOutOfRange": "Netzspannung außerhalb des Bereichs", + "alarm_GridFrequencyOutOfRange": "Netzfrequenz außerhalb des Bereichs", + "alarm_Overload": "Überlastung", + "alarm_MeterDisconnected": "Stromzähler getrennt", + "alarm_MeterReverselyConnected": "Zähler falsch angeschlossen", + "alarm_LinePeVoltageAbnormal": "Abnormale PE-Spannung", + "alarm_PhaseSequenceError": "Phasenfolgefehler", + "alarm_FanFailure": "Lüfterausfall", + "alarm_MeterAbnormal": "Störungsanzeige Zähler", + "alarm_OptimizerCommunicationAbnormal": "Kommunikationsstörung Optimierer", + "alarm_OverTemperature": "Überhitzung", + "alarm_OverTemperatureAlarm": "Überhitzungswarnung", + "alarm_NtcTemperatureSensorBroken": "Temperatursensor defekt", + "alarm_SyncSignalAbnormal": "Synchronisationsfehler", + "alarm_GridStartupConditionsNotMet": "Netzstartbedingungen nicht erfüllt", + "alarm_BatteryCommunicationFailure": "Batteriekommunikation fehlgeschlagen", + "alarm_BatteryDisconnected": "Batterie getrennt", + "alarm_BatteryVoltageTooHigh": "Batteriespannung zu hoch", + "alarm_BatteryVoltageTooLow": "Batteriespannung zu niedrig", + "alarm_BatteryReverseConnected": "Batterie falsch angeschlossen", + "alarm_LeadAcidTempSensorDisconnected": "Temperatursensor nicht angeschlossen", + "alarm_BatteryTemperatureOutOfRange": "Batterietemperatur außerhalb des Bereichs", + "alarm_BmsFault": "BMS-Fehler", + "alarm_LithiumBatteryOverload": "Batterie-Überlastung", + "alarm_BmsCommunicationAbnormal": "BMS-Kommunikationsfehler", + "alarm_BatterySpdAbnormal": "Batterie-Überspannungsschutz", + "alarm_OutputDcComponentBiasAbnormal": "DC-Versatz im Ausgang", + "alarm_DcComponentOverHighOutputVoltage": "DC-Komponente zu hohe Ausgangsspannung", + "alarm_OffGridOutputVoltageTooLow": "Netzunabhängige Ausgangsspannung zu niedrig", + "alarm_OffGridOutputVoltageTooHigh": "Netzunabhängige Ausgangsspannung zu hoch", + "alarm_OffGridOutputOverCurrent": "Netzunabhängiger Ausgangsüberstrom", + "alarm_OffGridOutputOverload": "Netzunabhängiger Ausgang überlastet", + "alarm_BalancedCircuitAbnormal": "Phasenausgleich gestört", + "alarm_ExportLimitationFailSafe": "Exportbegrenzung Notaus", + "alarm_DcBiasAbnormal": "DC-Vorspannung abnormal", + "alarm_HighDcComponentOutputCurrent": "Hohe DC-Komponente im Ausgangsstrom", + "alarm_BusVoltageSamplingAbnormal": "Spannungsmessung defekt", + "alarm_RelayFault": "Relaisfehler", + "alarm_BusVoltageAbnormal": "Gleichspannung abnormal", + "alarm_InternalCommunicationFailure": "Interne Kommunikation ausgefallen", + "alarm_TemperatureSensorDisconnected": "Temperatursensor getrennt", + "alarm_IgbtDriveFault": "IGBT-Ansteuerungsfehler", + "alarm_EepromError": "EEPROM-Fehler", + "alarm_AuxiliaryPowerAbnormal": "Hilfsstromversorgung abnormal", + "alarm_DcAcOvercurrentProtection": "Überstromschutz aktiviert", + "alarm_CommunicationProtocolMismatch": "Kommunikationsprotokoll-Fehler", + "alarm_DspComFirmwareMismatch": "Firmware-Inkompatibilität DSP/COM", + "alarm_DspSoftwareHardwareMismatch": "DSP-Software-Hardware-Inkompatibilität", + "alarm_CpldAbnormal": "CPLD-Fehler", + "alarm_RedundancySamplingInconsistent": "Inkonsistente redundante Messungen", + "alarm_PwmPassThroughSignalFailure": "PWM-Signalweg ausgefallen", + "alarm_AfciSelfTestFailure": "AFCI-Selbsttest fehlgeschlagen", + "alarm_PvCurrentSamplingAbnormal": "PV-Strommessung abnormal", + "alarm_AcCurrentSamplingAbnormal": "AC-Strommessung abnormal", + "alarm_BusSoftbootFailure": "DC-Bus-Vorstart fehlgeschlagen", + "alarm_EpoFault": "EPO-Fehler (Notaus)", + "alarm_MonitoringChipBootVerificationFailed": "Überwachungs-Chip Startfehler", + "alarm_BmsCommunicationFailure": "BMS-Kommunikationsfehler", + "alarm_BmsChargeDischargeFailure": "BMS-Lade-/Entladefehler", + "alarm_BatteryVoltageLow": "Batteriespannung zu niedrig", + "alarm_BatteryVoltageHigh": "Batteriespannung zu hoch", + "alarm_BatteryTemperatureAbnormal": "Batterietemperatur ungewöhnlich", + "alarm_BatteryReversed": "Batterie verkehrt herum", + "alarm_BatteryOpenCircuit": "Batteriekreis offen", + "alarm_BatteryOverloadProtection": "Batterieüberlastungsschutz", + "alarm_Bus2VoltageAbnormal": "Bus2-Spannung ungewöhnlich", + "alarm_BatteryChargeOcp": "Batterieladung Überstrom", + "alarm_BatteryDischargeOcp": "Batterieentladung Überstrom", + "alarm_BatterySoftStartFailed": "Batterie-Softstart fehlgeschlagen", + "alarm_EpsOutputShortCircuited": "EPS-Ausgang kurzgeschlossen", + "alarm_OffGridBusVoltageLow": "Netzunabhängige Busspannung zu niedrig", + "alarm_OffGridTerminalVoltageAbnormal": "Abnormale Spannung am Netzausgang", + "alarm_SoftStartFailed": "Sanfter Start fehlgeschlagen", + "alarm_OffGridOutputVoltageAbnormal": "Abnormale Ausgangsspannung im Netzmodus", + "alarm_BalancedCircuitSelfTestFailed": "Ausgleichsschaltungstest fehlgeschlagen", + "alarm_HighDcComponentOutputVoltage": "Hohe Gleichspannungskomponente im Ausgang", + "alarm_OffGridParallelSignalAbnormal": "Parallelsignalstörung", + "alarm_AFCIFault": "Lichtbogenfehler", + "alarm_GFCIHigh": "Erhöhter Fehlerstrom", + "alarm_PVVoltageHigh": "PV-Spannung zu hoch", + "alarm_OffGridBusVoltageTooLow": "Off-Grid-Busspannung zu niedrig", + "Information": "Informationen", + "allInstallations": "Alle Installationen", + "group": "Gruppe", + "groups": "Gruppen", + "requiredOrderNumber": "Pflichtbestellnummer" } \ No newline at end of file diff --git a/typescript/frontend-marios2/src/lang/en.json b/typescript/frontend-marios2/src/lang/en.json index 71756e085..9d3a3ae64 100644 --- a/typescript/frontend-marios2/src/lang/en.json +++ b/typescript/frontend-marios2/src/lang/en.json @@ -5,6 +5,9 @@ "customerName": "Customer name", "english": "English", "german": "German", + "french": "French", + "italian": "Italian", + "language": "Language", "installation": "Installation", "location": "Location", "log": "Log", @@ -70,5 +73,58 @@ "unableToGrantAccess": "Unable to grant access to: ", "unableToLoadData": "Unable to load data", "unableToRevokeAccess": "Unable to revoke access", - "revokedAccessFromUser": "Revoked access from user: " + "revokedAccessFromUser": "Revoked access from user: ", + "Show Errors": "Show Errors", + "Show Warnings": "Show Warnings", + "lastSeen": "Last seen", + "reportTitle": "Weekly Performance Report", + "weeklyInsights": "Weekly Insights", + "weeklySavings": "Your Savings This Week", + "solarEnergyUsed": "Energy Saved", + "solarStayedHome": "solar + battery, not bought from grid", + "daysOfYourUsage": "days of your usage", + "estMoneySaved": "Est. Money Saved", + "atCHFRate": "at 0.39 CHF/kWh avg.", + "solarCoverage": "Self-Sufficiency", + "fromSolarSub": "from solar + battery", + "avgDailyConsumption": "Avg Daily Consumption", + "batteryEfficiency": "Battery Efficiency", + "batteryEffSub": "discharge vs charge", + "weeklySummary": "Weekly Summary", + "metric": "Metric", + "thisWeek": "This Week", + "change": "Change", + "pvProduction": "PV Production", + "consumption": "Consumption", + "gridImport": "Grid Import", + "gridExport": "Grid Export", + "batteryInOut": "Battery Charge / Discharge", + "dailyBreakdown": "Daily Breakdown", + "prevWeek": "(prev week)", + "sendReport": "Send Report", + "generatingReport": "Generating weekly report...", + "reportSentTo": "Report sent to {email}", + "reportSendError": "Failed to send. Please check the email address and try again.", + "ok": "Ok", + "grantedAccessToUser": "Granted access to user {name}", + "proceed": "Proceed", + "firmwareUpdating": "The firmware is getting updated. Please wait...", + "confirmFirmwareUpdate": "Do you really want to update the firmware?", + "batteryServiceStopWarning": "This action requires the battery service to be stopped for around 10-15 minutes.", + "downloadingBatteryLog": "The battery log is getting downloaded. It will be saved in the Downloads folder. Please wait...", + "confirmBatteryLogDownload": "Do you really want to download battery log?", + "downloadBatteryLogFailed": "Download battery log failed, please try again.", + "noReportData": "No report data found.", + "ai_analyzing": "AI is analyzing...", + "ai_show_details": "Show details", + "ai_show_less": "Show less", + "ai_likely_causes": "Likely causes:", + "ai_next_steps": "Suggested next steps:", + "demo_test_button": "Test AI Diagnosis", + "demo_hide_button": "Hide AI Diagnosis Demo", + "demo_panel_title": "AI Diagnosis Demo", + "demo_custom_group": "Custom (may use Mistral AI)", + "demo_custom_option": "Type custom alarm below…", + "demo_custom_placeholder": "e.g. UnknownBatteryFault", + "demo_diagnose_button": "Diagnose" } diff --git a/typescript/frontend-marios2/src/lang/fr.json b/typescript/frontend-marios2/src/lang/fr.json index 4e5487359..3f3190411 100644 --- a/typescript/frontend-marios2/src/lang/fr.json +++ b/typescript/frontend-marios2/src/lang/fr.json @@ -11,7 +11,10 @@ "english": "Anglais", "error": "Erreur", "folder": "Dossier", + "french": "Français", "german": "Allemand", + "italian": "Italien", + "language": "Langue", "overview": "Aperçu", "manage": "Gestion des accès", "configuration": "Configuration", @@ -19,7 +22,6 @@ "apply_changes": "Appliquer", "delete_user": "Supprimer l'utilisateur", "installation_name_simple": "Nom de l'installation: ", - "language": "Langue", "minimum_soc": "Soc minimum", "calibration_charge_forced": "Charge d'étalonnage forcée", "grid_set_point": "Point de consigne de grid", @@ -41,7 +43,7 @@ "lastWeek": "La semaine dernière", "location": "Localité", "log": "Journal", - "logout": "Fermer las session", + "logout": "Fermer la session", "makeASelection": "Veuillez faire une sélection à gauche", "manageAccess": "Gérer l'accès", "move": "Déplacer", @@ -63,7 +65,7 @@ "status": "Statut", "live": "Diffusion en direct", "deleteInstallation": "Supprimer l'installation", - "errorOccured": "Une erreur s’est produite", + "errorOccured": "Une erreur s'est produite", "successfullyUpdated": "Mise à jour réussie", "grantAccess": "Accorder l'accès", "UserswithDirectAccess": "Utilisateurs avec accès direct", @@ -83,5 +85,298 @@ "unableToGrantAccess": "Impossible d'accorder l'accès à", "unableToLoadData": "Impossible de charger les données", "unableToRevokeAccess": "Impossible de révoquer l'accès", - "revokedAccessFromUser": "Accès révoqué de l'utilisateur" + "revokedAccessFromUser": "Accès révoqué de l'utilisateur", + "Show Errors": "Afficher les erreurs", + "Show Warnings": "Afficher les avertissements", + "lastSeen": "Dernière connexion", + "reportTitle": "Rapport de performance hebdomadaire", + "weeklyInsights": "Aperçus hebdomadaires", + "weeklySavings": "Vos économies cette semaine", + "solarEnergyUsed": "Énergie économisée", + "solarStayedHome": "solaire + batterie, non achetée au réseau", + "daysOfYourUsage": "jours de votre consommation", + "estMoneySaved": "Économies estimées", + "atCHFRate": "à 0,39 CHF/kWh moy.", + "solarCoverage": "Autosuffisance", + "fromSolarSub": "du solaire + batterie", + "avgDailyConsumption": "Conso. quotidienne moy.", + "batteryEfficiency": "Efficacité de la batterie", + "batteryEffSub": "décharge vs charge", + "weeklySummary": "Résumé hebdomadaire", + "metric": "Métrique", + "thisWeek": "Cette semaine", + "change": "Variation", + "pvProduction": "Production PV", + "consumption": "Consommation", + "gridImport": "Importation réseau", + "gridExport": "Exportation réseau", + "batteryInOut": "Batterie Charge / Décharge", + "dailyBreakdown": "Répartition quotidienne", + "prevWeek": "(semaine précédente)", + "sendReport": "Envoyer le rapport", + "generatingReport": "Génération du rapport hebdomadaire...", + "reportSentTo": "Rapport envoyé à {email}", + "reportSendError": "Échec de l'envoi. Veuillez vérifier l'adresse e-mail et réessayer.", + "ok": "Ok", + "grantedAccessToUser": "Accès accordé à l'utilisateur {name}", + "proceed": "Continuer", + "firmwareUpdating": "Le firmware est en cours de mise à jour. Veuillez patienter...", + "confirmFirmwareUpdate": "Voulez-vous vraiment mettre à jour le firmware?", + "batteryServiceStopWarning": "Cette action nécessite l'arrêt du service batterie pendant environ 10-15 minutes.", + "downloadingBatteryLog": "Le journal de la batterie est en cours de téléchargement. Il sera enregistré dans le dossier Téléchargements. Veuillez patienter...", + "confirmBatteryLogDownload": "Voulez-vous vraiment télécharger le journal de la batterie?", + "downloadBatteryLogFailed": "Échec du téléchargement du journal de la batterie, veuillez réessayer.", + "noReportData": "Aucune donnée de rapport trouvée.", + "ai_analyzing": "L'IA analyse...", + "ai_show_details": "Afficher les détails", + "ai_show_less": "Afficher moins", + "ai_likely_causes": "Causes probables :", + "ai_next_steps": "Prochaines étapes suggérées :", + "demo_test_button": "Tester le diagnostic IA", + "demo_hide_button": "Masquer la démo de diagnostic IA", + "demo_panel_title": "Démo de diagnostic IA", + "demo_custom_group": "Personnalisé (peut utiliser Mistral IA)", + "demo_custom_option": "Saisir une alarme personnalisée…", + "demo_custom_placeholder": "ex. UnknownBatteryFault", + "demo_diagnose_button": "Diagnostiquer", + "alarm_AbnormalGridVoltage": "Tension réseau anormale", + "alarm_AbnormalGridFrequency": "Fréquence réseau anormale", + "alarm_InvertedSequenceOfGridVoltage": "Séquence de tension inversée", + "alarm_GridVoltagePhaseLoss": "Perte de phase réseau", + "alarm_AbnormalGridCurrent": "Courant réseau anormal", + "alarm_AbnormalOutputVoltage": "Tension de sortie anormale", + "alarm_AbnormalOutputFrequency": "Fréquence de sortie anormale", + "alarm_AbnormalNullLine": "Ligne neutre anormale", + "alarm_AbnormalOffGridOutputVoltage": "Tension de sortie hors réseau anormale", + "alarm_ExcessivelyHighAmbientTemperature": "Température ambiante trop élevée", + "alarm_ExcessiveRadiatorTemperature": "Température excessive du radiateur", + "alarm_PcbOvertemperature": "Température excessive PCB", + "alarm_DcConverterOvertemperature": "Température excessive convertisseur DC", + "alarm_InverterOvertemperatureAlarm": "Alarme température onduleur", + "alarm_InverterOvertemperature": "Température onduleur excessive", + "alarm_DcConverterOvertemperatureAlarm": "Alarme surchauffe convertisseur DC", + "alarm_InsulationFault": "Défaut d'isolation", + "alarm_LeakageProtectionFault": "Défaut protection fuite", + "alarm_AbnormalLeakageSelfCheck": "Auto-test fuite anormale", + "alarm_PoorGrounding": "Mise à la terre insuffisante", + "alarm_FanFault": "Défaut du ventilateur", + "alarm_AuxiliaryPowerFault": "Défaut d'alimentation auxiliaire", + "alarm_ModelCapacityFault": "Défaut de configuration", + "alarm_AbnormalLightningArrester": "Paratonnerre défectueux", + "alarm_IslandProtection": "Protection d'îlotage", + "alarm_Battery1NotConnected": "Batterie 1 non connectée", + "alarm_Battery1Overvoltage": "Tension batterie 1 trop élevée", + "alarm_Battery1Undervoltage": "Tension batterie 1 trop basse", + "alarm_Battery1DischargeEnd": "Fin de décharge batterie 1", + "alarm_Battery1Inverted": "Polarité batterie 1 inversée", + "alarm_Battery1OverloadTimeout": "Dépassement de charge Batterie 1", + "alarm_Battery1SoftStartFailure": "Échec démarrage Batterie 1", + "alarm_Battery1PowerTubeFault": "Défaut électronique Batterie 1", + "alarm_Battery1InsufficientPower": "Puissance insuffisante Batterie 1", + "alarm_Battery1BackupProhibited": "Sauvegarde interdite Batterie 1", + "alarm_Battery2NotConnected": "Batterie 2 non connectée", + "alarm_Battery2Overvoltage": "Tension batterie 2 élevée", + "alarm_Battery2Undervoltage": "Tension batterie 2 basse", + "alarm_Battery2DischargeEnd": "Fin décharge batterie 2", + "alarm_Battery2Inverted": "Polarité batterie 2 inversée", + "alarm_Battery2OverloadTimeout": "Dépassement de charge Batterie 2", + "alarm_Battery2SoftStartFailure": "Échec démarrage Batterie 2", + "alarm_Battery2PowerTubeFault": "Défaut électronique Batterie 2", + "alarm_Battery2InsufficientPower": "Puissance insuffisante Batterie 2", + "alarm_Battery2BackupProhibited": "Sauvegarde interdite Batterie 2", + "alarm_LithiumBattery1ChargeForbidden": "Charge batterie lithium 1 interdite", + "alarm_LithiumBattery1DischargeForbidden": "Décharge batterie lithium 1 interdite", + "alarm_LithiumBattery2ChargeForbidden": "Charge batterie lithium 2 interdite", + "alarm_LithiumBattery2DischargeForbidden": "Décharge batterie lithium 2 interdite", + "alarm_LithiumBattery1Full": "Batterie lithium 1 pleine", + "alarm_LithiumBattery1DischargeEnd": "Fin de décharge batterie lithium 1", + "alarm_LithiumBattery2Full": "Batterie lithium 2 pleine", + "alarm_LithiumBattery2DischargeEnd": "Fin de décharge batterie lithium 2", + "alarm_LeadBatteryTemperatureAbnormality": "Température anormale batterie plomb", + "alarm_BatteryAccessMethodError": "Erreur de méthode d'accès batterie", + "alarm_Pv1NotAccessed": "Chaîne PV1 non accessible", + "alarm_Pv1Overvoltage": "Survoltage PV1", + "alarm_AbnormalPv1CurrentSharing": "Partage de courant PV1 anormal", + "alarm_Pv1PowerTubeFault": "Défaut du tube de puissance PV1", + "alarm_Pv1SoftStartFailure": "Échec de démarrage doux PV1", + "alarm_Pv1OverloadTimeout": "Dépassement de charge PV1", + "alarm_Pv1InsufficientPower": "Puissance PV1 insuffisante", + "alarm_Photovoltaic1Overcurrent": "Surintensité PV1", + "alarm_Pv2NotAccessed": "Chaîne PV2 inaccessible", + "alarm_Pv2Overvoltage": "Survoltage PV2", + "alarm_AbnormalPv2CurrentSharing": "Partage de courant anormal PV2", + "alarm_Pv2PowerTubeFault": "Défaillance du tube de puissance PV2", + "alarm_Pv2SoftStartFailure": "Échec de démarrage progressif PV2", + "alarm_Pv2OverloadTimeout": "Dépassement de charge PV2", + "alarm_Pv2InsufficientPower": "Puissance insuffisante PV2", + "alarm_Pv3NotConnected": "PV3 non connecté", + "alarm_Pv3Overvoltage": "Survoltage PV3", + "alarm_Pv3AverageCurrentAnomaly": "Anomalie courant PV3", + "alarm_Pv3PowerTubeFailure": "Défaillance tube PV3", + "alarm_Pv3SoftStartFailure": "Échec démarrage PV3", + "alarm_Pv3OverloadTimeout": "Dépassement de charge PV3", + "alarm_Pv3ReverseConnection": "Connexion inversée PV3", + "alarm_Pv4NotConnected": "Chaîne PV4 non connectée", + "alarm_Pv4Overvoltage": "Survoltage PV4", + "alarm_Pv4AverageCurrentAnomaly": "Anomalie de courant PV4", + "alarm_Pv4PowerTubeFailure": "Défaillance du tube de puissance PV4", + "alarm_Pv4SoftStartFailure": "Échec du démarrage progressif PV4", + "alarm_Pv4OverloadTimeout": "Dépassement de charge PV4", + "alarm_Pv4ReverseConnection": "Connexion inversée PV4", + "alarm_InsufficientPhotovoltaicPower": "Puissance photovoltaïque insuffisante", + "alarm_DcBusOvervoltage": "Tension DC trop élevée", + "alarm_DcBusUndervoltage": "Tension DC trop basse", + "alarm_DcBusVoltageUnbalance": "Déséquilibre tension DC", + "alarm_BusSlowOvervoltage": "Tension DC lente excessive", + "alarm_HardwareBusOvervoltage": "Tension DC critique", + "alarm_BusSoftStartFailure": "Échec démarrage progressif", + "alarm_InverterPowerTubeFault": "Défaut tube de puissance", + "alarm_HardwareOvercurrent": "Surintensité matérielle", + "alarm_DcConverterOvervoltage": "Survoltage convertisseur DC", + "alarm_DcConverterHardwareOvervoltage": "Survoltage matériel convertisseur DC", + "alarm_DcConverterOvercurrent": "Surintensité convertisseur CC", + "alarm_DcConverterHardwareOvercurrent": "Surintensité matérielle convertisseur CC", + "alarm_DcConverterResonatorOvercurrent": "Surintensité résonateur convertisseur CC", + "alarm_SystemOutputOverload": "Surcharge de sortie système", + "alarm_InverterOverload": "Surcharge onduleur", + "alarm_InverterOverloadTimeout": "Dépassement de charge de l'onduleur", + "alarm_LoadPowerOverload": "Surcharge de puissance de charge", + "alarm_BalancedCircuitOverloadTimeout": "Dépassement de charge du circuit équilibré", + "alarm_InverterSoftStartFailure": "Échec de démarrage progressif de l'onduleur", + "alarm_Dsp1ParameterSettingFault": "Défaillance de paramétrage DSP 1", + "alarm_Dsp2ParameterSettingFault": "Paramètre DSP2 incorrect", + "alarm_DspVersionCompatibilityFault": "Incompatibilité version DSP", + "alarm_CpldVersionCompatibilityFault": "Incompatibilité version CPLD", + "alarm_CpldCommunicationFault": "Échec communication CPLD", + "alarm_DspCommunicationFault": "Échec communication DSP", + "alarm_OutputVoltageDcOverlimit": "Tension de sortie DC excessive", + "alarm_OutputCurrentDcOverlimit": "Courant de sortie DC excessif", + "alarm_RelaySelfCheckFails": "Auto-test relais échoué", + "alarm_InverterRelayOpen": "Relais de l'onduleur ouvert", + "alarm_InverterRelayShortCircuit": "Relais de l'onduleur en court-circuit", + "alarm_OpenCircuitOfPowerGridRelay": "Relais du réseau ouvert", + "alarm_ShortCircuitOfPowerGridRelay": "Court-circuit du relais réseau", + "alarm_GeneratorRelayOpenCircuit": "Relais du générateur ouvert", + "alarm_GeneratorRelayShortCircuit": "Court-circuit du relais générateur", + "alarm_AbnormalInverter": "Onduleur anormal", + "alarm_ParallelCommunicationAlarm": "Alarme de communication parallèle", + "alarm_ParallelModuleMissing": "Module parallèle manquant", + "alarm_DuplicateMachineNumbersForParallelModules": "Numéros de machine en double", + "alarm_ParameterConflictInParallelModule": "Conflit de paramètres parallèle", + "alarm_SystemDerating": "Réduction de puissance du système", + "alarm_PvAccessMethodErrorAlarm": "Erreur méthode d'accès PV", + "alarm_ReservedAlarms4": "Alarme réservée 4", + "alarm_ReservedAlarms5": "Alarme réservée 5", + "alarm_ReverseMeterConnection": "Connexion du compteur inversée", + "alarm_InverterSealPulse": "Impulsion de scellement de l'onduleur", + "alarm_AbnormalDieselGeneratorVoltage": "Tension anormale du générateur diesel", + "alarm_AbnormalDieselGeneratorFrequency": "Fréquence anormale du générateur diesel", + "alarm_DieselGeneratorVoltageReverseSequence": "Séquence de phase inversée du générateur", + "alarm_DieselGeneratorVoltageOutOfPhase": "Déphasage du générateur", + "alarm_GeneratorOverload": "Surcharge du générateur", + "alarm_StringFault": "Défaut de chaîne", + "alarm_PvStringPidQuickConnectAbnormal": "Connexion rapide anormale", + "alarm_DcSpdFunctionAbnormal": "Problème de protection DC", + "alarm_PvShortCircuited": "Court-circuit PV", + "alarm_PvBoostDriverAbnormal": "Problème de convertisseur", + "alarm_AcSpdFunctionAbnormal": "Problème de protection contre les surtensions AC", + "alarm_DcFuseBlown": "Fusible DC grillé", + "alarm_DcInputVoltageTooHigh": "Tension DC d'entrée trop élevée", + "alarm_PvReversed": "Polarité PV inversée", + "alarm_PidFunctionAbnormal": "Problème de fonction PID", + "alarm_PvStringDisconnected": "Chaîne PV déconnectée", + "alarm_PvStringCurrentUnbalanced": "Déséquilibre de courant PV", + "alarm_NoUtilityGrid": "Réseau électrique absent", + "alarm_GridVoltageOutOfRange": "Tension réseau hors plage", + "alarm_GridFrequencyOutOfRange": "Fréquence réseau hors plage", + "alarm_Overload": "Surcharge", + "alarm_MeterDisconnected": "Compteur déconnecté", + "alarm_MeterReverselyConnected": "Compteur inversé", + "alarm_LinePeVoltageAbnormal": "Tension anormale", + "alarm_PhaseSequenceError": "Séquence de phase erronée", + "alarm_FanFailure": "Défaillance du ventilateur", + "alarm_MeterAbnormal": "Compteur anormal", + "alarm_OptimizerCommunicationAbnormal": "Communication optimiseur anormale", + "alarm_OverTemperature": "Température excessive", + "alarm_OverTemperatureAlarm": "Alarme température élevée", + "alarm_NtcTemperatureSensorBroken": "Capteur de température défectueux", + "alarm_SyncSignalAbnormal": "Signal de synchronisation anormal", + "alarm_GridStartupConditionsNotMet": "Conditions de démarrage réseau non remplies", + "alarm_BatteryCommunicationFailure": "Échec de communication batterie", + "alarm_BatteryDisconnected": "Batterie déconnectée", + "alarm_BatteryVoltageTooHigh": "Tension batterie trop élevée", + "alarm_BatteryVoltageTooLow": "Tension batterie trop basse", + "alarm_BatteryReverseConnected": "Batterie branchée à l'envers", + "alarm_LeadAcidTempSensorDisconnected": "Capteur température batterie plomb désactivé", + "alarm_BatteryTemperatureOutOfRange": "Température batterie hors plage", + "alarm_BmsFault": "Défaillance BMS", + "alarm_LithiumBatteryOverload": "Surcharge batterie lithium", + "alarm_BmsCommunicationAbnormal": "Communication BMS anormale", + "alarm_BatterySpdAbnormal": "Défaillance SPD batterie", + "alarm_OutputDcComponentBiasAbnormal": "Biais DC de sortie anormal", + "alarm_DcComponentOverHighOutputVoltage": "Tension de sortie trop élevée", + "alarm_OffGridOutputVoltageTooLow": "Tension de sortie hors réseau trop basse", + "alarm_OffGridOutputVoltageTooHigh": "Tension de sortie hors réseau trop élevée", + "alarm_OffGridOutputOverCurrent": "Courant de sortie hors réseau trop élevé", + "alarm_OffGridOutputOverload": "Surcharge sortie hors réseau", + "alarm_BalancedCircuitAbnormal": "Circuit équilibré anormal", + "alarm_ExportLimitationFailSafe": "Sécurité limite d'exportation", + "alarm_DcBiasAbnormal": "Biais DC anormal", + "alarm_HighDcComponentOutputCurrent": "Composante DC élevée courant de sortie", + "alarm_BusVoltageSamplingAbnormal": "Tension d'alimentation anormale", + "alarm_RelayFault": "Défaillance du relais", + "alarm_BusVoltageAbnormal": "Tension d'alimentation anormale", + "alarm_InternalCommunicationFailure": "Échec de communication interne", + "alarm_TemperatureSensorDisconnected": "Capteur de température déconnecté", + "alarm_IgbtDriveFault": "Défaillance de l'IGBT", + "alarm_EepromError": "Erreur EEPROM", + "alarm_AuxiliaryPowerAbnormal": "Alimentation auxiliaire anormale", + "alarm_DcAcOvercurrentProtection": "Protection contre les surintensités", + "alarm_CommunicationProtocolMismatch": "Incompatibilité de protocole", + "alarm_DspComFirmwareMismatch": "Incompatibilité firmware DSP/COM", + "alarm_DspSoftwareHardwareMismatch": "Incompatibilité logiciel DSP/matériel", + "alarm_CpldAbnormal": "CPLD anormal", + "alarm_RedundancySamplingInconsistent": "Échantillonnage redondant incohérent", + "alarm_PwmPassThroughSignalFailure": "Échec signal PWM", + "alarm_AfciSelfTestFailure": "Échec auto-test AFCI", + "alarm_PvCurrentSamplingAbnormal": "Mesure PV anormale", + "alarm_AcCurrentSamplingAbnormal": "Mesure AC anormale", + "alarm_BusSoftbootFailure": "Échec démarrage DC", + "alarm_EpoFault": "Défaillance EPO", + "alarm_MonitoringChipBootVerificationFailed": "Échec vérification démarrage", + "alarm_BmsCommunicationFailure": "Échec communication BMS", + "alarm_BmsChargeDischargeFailure": "Échec charge/décharge BMS", + "alarm_BatteryVoltageLow": "Tension batterie faible", + "alarm_BatteryVoltageHigh": "Tension batterie élevée", + "alarm_BatteryTemperatureAbnormal": "Température anormale de la batterie", + "alarm_BatteryReversed": "Batterie inversée", + "alarm_BatteryOpenCircuit": "Circuit batterie ouvert", + "alarm_BatteryOverloadProtection": "Protection contre la surcharge", + "alarm_Bus2VoltageAbnormal": "Tension anormale Bus2", + "alarm_BatteryChargeOcp": "Surintensité charge batterie", + "alarm_BatteryDischargeOcp": "Surintensité décharge batterie", + "alarm_BatterySoftStartFailed": "Démarrage en douceur échoué", + "alarm_EpsOutputShortCircuited": "Circuit de secours en court-circuit", + "alarm_OffGridBusVoltageLow": "Tension bus hors réseau basse", + "alarm_OffGridTerminalVoltageAbnormal": "Tension anormale terminal hors réseau", + "alarm_SoftStartFailed": "Démarrage progressif échoué", + "alarm_OffGridOutputVoltageAbnormal": "Tension de sortie hors réseau anormale", + "alarm_BalancedCircuitSelfTestFailed": "Autotest circuit équilibré échoué", + "alarm_HighDcComponentOutputVoltage": "Tension de sortie à composante CC élevée", + "alarm_OffGridParallelSignalAbnormal": "Signal parallèle hors réseau anormal", + "alarm_AFCIFault": "Défaillance AFCI", + "alarm_GFCIHigh": "Courant de défaut élevé", + "alarm_PVVoltageHigh": "Tension PV élevée", + "alarm_OffGridBusVoltageTooLow": "Tension du bus hors réseau trop faible", + "Information": "Informations", + "allInstallations": "Toutes les installations", + "group": "Groupe", + "groups": "Groupes", + "requiredOrderNumber": "Numéro de commande requis", + "addNewChild": "Ajouter un sous-élément", + "addNewDialogButton": "Ajouter un bouton de dialogue", + "groupTabs": "Groupes", + "groupTree": "Arborescence de groupes", + "installationTabs": "Installations", + "navigationTabs": "Navigation" } \ No newline at end of file diff --git a/typescript/frontend-marios2/src/lang/it.json b/typescript/frontend-marios2/src/lang/it.json new file mode 100644 index 000000000..e6d7df9b3 --- /dev/null +++ b/typescript/frontend-marios2/src/lang/it.json @@ -0,0 +1,382 @@ +{ + "allInstallations": "Tutte le installazioni", + "applyChanges": "Applica modifiche", + "country": "Paese", + "customerName": "Nome cliente", + "english": "Inglese", + "german": "Tedesco", + "french": "Francese", + "italian": "Italiano", + "language": "Lingua", + "installation": "Installazione", + "location": "Posizione", + "log": "Registro", + "orderNumbers": "Numeri d'ordine", + "region": "Regione", + "search": "Cerca", + "users": "Utenti", + "logout": "Disconnetti", + "updatedSuccessfully": "Aggiornamento riuscito", + "groups": "Gruppi", + "group": "Gruppo", + "folder": "Cartella", + "updateFolderErrorMessage": "Impossibile aggiornare la cartella, si è verificato un errore", + "Information": "Informazioni", + "addNewChild": "Aggiungi nuovo figlio", + "addNewDialogButton": "Aggiungi nuovo pulsante di dialogo", + "addUser": "Crea utente", + "createNewFolder": "Crea nuova cartella", + "createNewUser": "Crea nuovo utente", + "email": "Email", + "error": "Errore", + "groupTabs": "Schede gruppo", + "groupTree": "Albero gruppo", + "information": "Informazioni", + "inheritedAccess": "Accesso ereditato da", + "installationTabs": "Schede installazione", + "installations": "Installazioni", + "lastWeek": "Settimana scorsa", + "makeASelection": "Effettuare una selezione a sinistra", + "manageAccess": "Gestisci accesso", + "move": "Sposta", + "moveTo": "Sposta in", + "moveTree": "Sposta albero", + "name": "Nome", + "navigationTabs": "Schede di navigazione", + "requiredLocation": "La posizione è obbligatoria", + "requiredName": "Il nome è obbligatorio", + "requiredRegion": "La regione è obbligatoria", + "requiredOrderNumber": "Numero d'ordine obbligatorio", + "submit": "Invia", + "user": "Utente", + "userTabs": "Schede utente", + "status": "Stato", + "live": "Vista in diretta", + "deleteInstallation": "Elimina installazione", + "errorOccured": "Si è verificato un errore", + "successfullyUpdated": "Aggiornamento riuscito", + "grantAccess": "Concedi accesso", + "UserswithDirectAccess": "Utenti con accesso diretto", + "UserswithInheritedAccess": "Utenti con accesso ereditato", + "noerrors": "Non ci sono errori", + "nowarnings": "Non ci sono avvisi", + "noUsersWithDirectAccessToThis": "Nessun utente con accesso diretto a questo", + "selectUsers": "Seleziona utenti", + "cancel": "Annulla", + "addNewFolder": "Aggiungi nuova cartella", + "addNewInstallation": "Aggiungi nuova installazione", + "deleteFolder": "Elimina cartella", + "grantAccessToFolders": "Concedi accesso alle cartelle", + "grantAccessToInstallations": "Concedi accesso alle installazioni", + "cannotloadloggingdata": "Impossibile caricare i dati di registro", + "grantedAccessToUsers": "Accesso concesso agli utenti: ", + "unableToGrantAccess": "Impossibile concedere l'accesso a: ", + "unableToLoadData": "Impossibile caricare i dati", + "unableToRevokeAccess": "Impossibile revocare l'accesso", + "revokedAccessFromUser": "Accesso revocato all'utente: ", + "alarms": "Allarmi", + "overview": "Panoramica", + "manage": "Gestione accessi", + "configuration": "Configurazione", + "installation_name_simple": "Nome installazione: ", + "installation_name": "Nome installazione", + "minimum_soc": "SoC minimo", + "calibration_charge_forced": "Carica di calibrazione forzata", + "grid_set_point": "Punto di riferimento rete", + "Installed_Power_DC1010": "Potenza installata DC1010", + "Maximum_Discharge_Power": "Potenza massima di scarica", + "Number_of_Batteries": "Numero di batterie", + "24_hours": "24 ore", + "lastweek": "Settimana scorsa", + "lastmonth": "Mese scorso", + "apply_changes": "Applica modifiche", + "delete_user": "Elimina utente", + "battery_temperature": "Temperatura batteria", + "pv_production": "Produzione fotovoltaica", + "grid_power": "Potenza di rete", + "battery_power": "Potenza batteria", + "dc_voltage": "Tensione bus DC", + "battery_soc": "Stato di carica (SOC)", + "Show Errors": "Mostra errori", + "Show Warnings": "Mostra avvisi", + "lastSeen": "Ultima visualizzazione", + "reportTitle": "Rapporto settimanale sulle prestazioni", + "weeklyInsights": "Approfondimenti settimanali", + "weeklySavings": "I tuoi risparmi questa settimana", + "solarEnergyUsed": "Energia risparmiata", + "solarStayedHome": "solare + batteria, non acquistata dalla rete", + "daysOfYourUsage": "giorni del tuo consumo", + "estMoneySaved": "Risparmio stimato", + "atCHFRate": "a 0,39 CHF/kWh media", + "solarCoverage": "Autosufficienza", + "fromSolarSub": "da solare + batteria", + "avgDailyConsumption": "Consumo medio giornaliero", + "batteryEfficiency": "Efficienza della batteria", + "batteryEffSub": "scarica vs carica", + "weeklySummary": "Riepilogo settimanale", + "metric": "Metrica", + "thisWeek": "Questa settimana", + "change": "Variazione", + "pvProduction": "Produzione FV", + "consumption": "Consumo", + "gridImport": "Importazione rete", + "gridExport": "Esportazione rete", + "batteryInOut": "Batteria Carica / Scarica", + "dailyBreakdown": "Ripartizione giornaliera", + "prevWeek": "(settimana precedente)", + "sendReport": "Invia rapporto", + "generatingReport": "Generazione del rapporto settimanale...", + "reportSentTo": "Rapporto inviato a {email}", + "reportSendError": "Invio fallito. Verificare l'indirizzo e-mail e riprovare.", + "ok": "Ok", + "grantedAccessToUser": "Accesso concesso all'utente {name}", + "proceed": "Procedi", + "firmwareUpdating": "Il firmware è in fase di aggiornamento. Attendere prego...", + "confirmFirmwareUpdate": "Vuoi davvero aggiornare il firmware?", + "batteryServiceStopWarning": "Questa azione richiede l'interruzione del servizio batteria per circa 10-15 minuti.", + "downloadingBatteryLog": "Il registro della batteria è in fase di download. Verrà salvato nella cartella Download. Attendere prego...", + "confirmBatteryLogDownload": "Vuoi davvero scaricare il registro della batteria?", + "downloadBatteryLogFailed": "Download del registro della batteria fallito, riprovare.", + "noReportData": "Nessun dato del rapporto trovato.", + "ai_analyzing": "L'IA sta analizzando...", + "ai_show_details": "Mostra dettagli", + "ai_show_less": "Mostra meno", + "ai_likely_causes": "Cause probabili:", + "ai_next_steps": "Passi successivi suggeriti:", + "demo_test_button": "Testa diagnosi IA", + "demo_hide_button": "Nascondi demo diagnosi IA", + "demo_panel_title": "Demo diagnosi IA", + "demo_custom_group": "Personalizzato (potrebbe usare Mistral IA)", + "demo_custom_option": "Inserisci allarme personalizzato…", + "demo_custom_placeholder": "es. UnknownBatteryFault", + "demo_diagnose_button": "Diagnostica", + "alarm_AbnormalGridVoltage": "Tensione di rete anomala", + "alarm_AbnormalGridFrequency": "Frequenza di rete anomala", + "alarm_InvertedSequenceOfGridVoltage": "Sequenza di fase invertita", + "alarm_GridVoltagePhaseLoss": "Fase di rete mancante", + "alarm_AbnormalGridCurrent": "Corrente di rete anomala", + "alarm_AbnormalOutputVoltage": "Tensione di uscita anomala", + "alarm_AbnormalOutputFrequency": "Frequenza di uscita anomala", + "alarm_AbnormalNullLine": "Linea neutra anomala", + "alarm_AbnormalOffGridOutputVoltage": "Tensione di uscita off-grid anomala", + "alarm_ExcessivelyHighAmbientTemperature": "Temperatura ambiente eccessivamente alta", + "alarm_ExcessiveRadiatorTemperature": "Temperatura radiatore eccessiva", + "alarm_PcbOvertemperature": "Temperatura PCB eccessiva", + "alarm_DcConverterOvertemperature": "Temperatura convertitore DC eccessiva", + "alarm_InverterOvertemperatureAlarm": "Allarme temperatura inverter elevata", + "alarm_InverterOvertemperature": "Temperatura inverter eccessiva", + "alarm_DcConverterOvertemperatureAlarm": "Allarme sovratemperatura convertitore DC", + "alarm_InsulationFault": "Guasto isolamento", + "alarm_LeakageProtectionFault": "Guasto protezione dispersione", + "alarm_AbnormalLeakageSelfCheck": "Autocontrollo dispersione anomalo", + "alarm_PoorGrounding": "Messa a terra insufficiente", + "alarm_FanFault": "Guasto Ventola", + "alarm_AuxiliaryPowerFault": "Guasto Alimentazione Ausiliaria", + "alarm_ModelCapacityFault": "Guasto Configurazione Modello", + "alarm_AbnormalLightningArrester": "Parasurtense Anomalo", + "alarm_IslandProtection": "Protezione Isola", + "alarm_Battery1NotConnected": "Batteria 1 non collegata", + "alarm_Battery1Overvoltage": "Batteria 1 sovratensione", + "alarm_Battery1Undervoltage": "Batteria 1 sottotensione", + "alarm_Battery1DischargeEnd": "Batteria 1 scarica", + "alarm_Battery1Inverted": "Batteria 1 polarità invertita", + "alarm_Battery1OverloadTimeout": "Timeout sovraccarico batteria 1", + "alarm_Battery1SoftStartFailure": "Avvio morbido fallito batteria 1", + "alarm_Battery1PowerTubeFault": "Guasto modulo potenza batteria 1", + "alarm_Battery1InsufficientPower": "Potenza insufficiente batteria 1", + "alarm_Battery1BackupProhibited": "Backup vietato batteria 1", + "alarm_Battery2NotConnected": "Batteria 2 non collegata", + "alarm_Battery2Overvoltage": "Sovratensione batteria 2", + "alarm_Battery2Undervoltage": "Sottotensione batteria 2", + "alarm_Battery2DischargeEnd": "Fine scarica batteria 2", + "alarm_Battery2Inverted": "Polarità invertita batteria 2", + "alarm_Battery2OverloadTimeout": "Timeout sovraccarico Batteria 2", + "alarm_Battery2SoftStartFailure": "Avvio morbido fallito Batteria 2", + "alarm_Battery2PowerTubeFault": "Guasto modulo potenza Batteria 2", + "alarm_Battery2InsufficientPower": "Potenza insufficiente Batteria 2", + "alarm_Battery2BackupProhibited": "Backup vietato Batteria 2", + "alarm_LithiumBattery1ChargeForbidden": "Carica Batteria Litio 1 Bloccata", + "alarm_LithiumBattery1DischargeForbidden": "Scarica Batteria Litio 1 Bloccata", + "alarm_LithiumBattery2ChargeForbidden": "Carica Batteria Litio 2 Bloccata", + "alarm_LithiumBattery2DischargeForbidden": "Scarica Batteria Litio 2 Bloccata", + "alarm_LithiumBattery1Full": "Batteria Litio 1 Piena", + "alarm_LithiumBattery1DischargeEnd": "Fine scarica batteria litio 1", + "alarm_LithiumBattery2Full": "Batteria litio 2 piena", + "alarm_LithiumBattery2DischargeEnd": "Fine scarica batteria litio 2", + "alarm_LeadBatteryTemperatureAbnormality": "Temperatura batteria piombo anomala", + "alarm_BatteryAccessMethodError": "Errore metodo accesso batteria", + "alarm_Pv1NotAccessed": "PV1 non accessibile", + "alarm_Pv1Overvoltage": "Sovratensione PV1", + "alarm_AbnormalPv1CurrentSharing": "Corrente PV1 anomala", + "alarm_Pv1PowerTubeFault": "Guasto tubo di potenza PV1", + "alarm_Pv1SoftStartFailure": "Avvio morbido PV1 fallito", + "alarm_Pv1OverloadTimeout": "Sovraccarico PV1", + "alarm_Pv1InsufficientPower": "Bassa potenza PV1", + "alarm_Photovoltaic1Overcurrent": "Sovracorrente PV1", + "alarm_Pv2NotAccessed": "PV2 non rilevato", + "alarm_Pv2Overvoltage": "Sovratensione PV2", + "alarm_AbnormalPv2CurrentSharing": "Condivisione Corrente PV2 Anomala", + "alarm_Pv2PowerTubeFault": "Guasto Tubo di Potenza PV2", + "alarm_Pv2SoftStartFailure": "Avvio Morbido PV2 Fallito", + "alarm_Pv2OverloadTimeout": "Sovraccarico PV2 Timeout", + "alarm_Pv2InsufficientPower": "Potenza Insufficiente PV2", + "alarm_Pv3NotConnected": "PV3 non connesso", + "alarm_Pv3Overvoltage": "Sovratensione PV3", + "alarm_Pv3AverageCurrentAnomaly": "Corrente PV3 anomala", + "alarm_Pv3PowerTubeFailure": "Guasto tubo di potenza PV3", + "alarm_Pv3SoftStartFailure": "Avvio morbido PV3 fallito", + "alarm_Pv3OverloadTimeout": "Sovraccarico PV3", + "alarm_Pv3ReverseConnection": "Connessione Inversa PV3", + "alarm_Pv4NotConnected": "PV4 Non Collegato", + "alarm_Pv4Overvoltage": "Sovratensione PV4", + "alarm_Pv4AverageCurrentAnomaly": "Anomalia Corrente PV4", + "alarm_Pv4PowerTubeFailure": "Guasto Tubo di Potenza PV4", + "alarm_Pv4SoftStartFailure": "Avvio Morbido PV4 Fallito", + "alarm_Pv4OverloadTimeout": "Sovraccarico PV4", + "alarm_Pv4ReverseConnection": "Connessione Inversa PV4", + "alarm_InsufficientPhotovoltaicPower": "Potenza Fotovoltaica Insufficiente", + "alarm_DcBusOvervoltage": "Sovratensione Bus DC", + "alarm_DcBusUndervoltage": "Sottotensione Bus DC", + "alarm_DcBusVoltageUnbalance": "Squilibrio Tensione Bus DC", + "alarm_BusSlowOvervoltage": "Sovratensione Lenta Bus", + "alarm_HardwareBusOvervoltage": "Sovratensione Critica Bus", + "alarm_BusSoftStartFailure": "Avvio morbido fallito", + "alarm_InverterPowerTubeFault": "Guasto al modulo di potenza", + "alarm_HardwareOvercurrent": "Sovracorrente hardware", + "alarm_DcConverterOvervoltage": "Sovratensione convertitore DC", + "alarm_DcConverterHardwareOvervoltage": "Sovratensione hardware convertitore", + "alarm_DcConverterOvercurrent": "Sovraccarico convertitore DC", + "alarm_DcConverterHardwareOvercurrent": "Sovraccarico hardware convertitore DC", + "alarm_DcConverterResonatorOvercurrent": "Sovraccarico risonatore convertitore DC", + "alarm_SystemOutputOverload": "Sovraccarico uscita sistema", + "alarm_InverterOverload": "Sovraccarico inverter", + "alarm_InverterOverloadTimeout": "Sovraccarico Inverter", + "alarm_LoadPowerOverload": "Sovraccarico Carico", + "alarm_BalancedCircuitOverloadTimeout": "Sovraccarico Circuito Bilanciato", + "alarm_InverterSoftStartFailure": "Avvio Inverter Fallito", + "alarm_Dsp1ParameterSettingFault": "Parametri DSP Errati", + "alarm_Dsp2ParameterSettingFault": "Errore configurazione parametri DSP 2", + "alarm_DspVersionCompatibilityFault": "Errore compatibilità versione DSP", + "alarm_CpldVersionCompatibilityFault": "Errore compatibilità versione CPLD", + "alarm_CpldCommunicationFault": "Errore comunicazione CPLD", + "alarm_DspCommunicationFault": "Errore comunicazione DSP", + "alarm_OutputVoltageDcOverlimit": "Tensione DC in uscita eccessiva", + "alarm_OutputCurrentDcOverlimit": "Corrente DC in uscita eccessiva", + "alarm_RelaySelfCheckFails": "Autotest relè fallito", + "alarm_InverterRelayOpen": "Relè inverter aperto", + "alarm_InverterRelayShortCircuit": "Relè inverter in cortocircuito", + "alarm_OpenCircuitOfPowerGridRelay": "Relè di rete aperto", + "alarm_ShortCircuitOfPowerGridRelay": "Relè di rete in cortocircuito", + "alarm_GeneratorRelayOpenCircuit": "Relè del generatore aperto", + "alarm_GeneratorRelayShortCircuit": "Relè del generatore in cortocircuito", + "alarm_AbnormalInverter": "Inverter anomalo", + "alarm_ParallelCommunicationAlarm": "Allarme Comunicazione Parallela", + "alarm_ParallelModuleMissing": "Modulo Parallelo Mancante", + "alarm_DuplicateMachineNumbersForParallelModules": "Numeri Duplicati Moduli Paralleli", + "alarm_ParameterConflictInParallelModule": "Conflitto Parametri Modulo Parallelo", + "alarm_SystemDerating": "Riduzione Prestazioni Sistema", + "alarm_PvAccessMethodErrorAlarm": "Errore Metodo Accesso PV", + "alarm_ReservedAlarms4": "Allarme Riservato 4", + "alarm_ReservedAlarms5": "Allarme Riservato 5", + "alarm_ReverseMeterConnection": "Contatore Inverso", + "alarm_InverterSealPulse": "Impulso Sigillo Inverter", + "alarm_AbnormalDieselGeneratorVoltage": "Tensione anomala del generatore", + "alarm_AbnormalDieselGeneratorFrequency": "Frequenza anomala del generatore", + "alarm_DieselGeneratorVoltageReverseSequence": "Sequenza di fase invertita", + "alarm_DieselGeneratorVoltageOutOfPhase": "Generatore fuori fase", + "alarm_GeneratorOverload": "Sovraccarico del generatore", + "alarm_StringFault": "Guasto Stringa", + "alarm_PvStringPidQuickConnectAbnormal": "Connessione Rapida Anomala", + "alarm_DcSpdFunctionAbnormal": "Protezione SPD Anomala", + "alarm_PvShortCircuited": "Cortocircuito PV", + "alarm_PvBoostDriverAbnormal": "Driver di Boost Anomalo", + "alarm_AcSpdFunctionAbnormal": "Funzione SPD AC anomala", + "alarm_DcFuseBlown": "Fusibile DC saltato", + "alarm_DcInputVoltageTooHigh": "Tensione DC in ingresso troppo alta", + "alarm_PvReversed": "Polarità PV invertita", + "alarm_PidFunctionAbnormal": "Funzione PID anomala", + "alarm_PvStringDisconnected": "Stringa PV disconnessa", + "alarm_PvStringCurrentUnbalanced": "Corrente stringa PV squilibrata", + "alarm_NoUtilityGrid": "Nessuna rete elettrica", + "alarm_GridVoltageOutOfRange": "Tensione rete fuori limite", + "alarm_GridFrequencyOutOfRange": "Frequenza rete fuori limite", + "alarm_Overload": "Sovraccarico", + "alarm_MeterDisconnected": "Contatore scollegato", + "alarm_MeterReverselyConnected": "Contatore collegato al contrario", + "alarm_LinePeVoltageAbnormal": "Tensione anomala PE", + "alarm_PhaseSequenceError": "Errore sequenza fase", + "alarm_FanFailure": "Guasto Ventilatore", + "alarm_MeterAbnormal": "Contatore Anomalo", + "alarm_OptimizerCommunicationAbnormal": "Comunicazione Ottimizzatore Anomala", + "alarm_OverTemperature": "Temperatura Eccessiva", + "alarm_OverTemperatureAlarm": "Allarme Temperatura Eccessiva", + "alarm_NtcTemperatureSensorBroken": "Sensore temperatura guasto", + "alarm_SyncSignalAbnormal": "Segnale di sincronizzazione anomalo", + "alarm_GridStartupConditionsNotMet": "Condizioni di avvio rete non soddisfatte", + "alarm_BatteryCommunicationFailure": "Comunicazione batteria fallita", + "alarm_BatteryDisconnected": "Batteria scollegata", + "alarm_BatteryVoltageTooHigh": "Tensione batteria troppo alta", + "alarm_BatteryVoltageTooLow": "Tensione batteria troppo bassa", + "alarm_BatteryReverseConnected": "Batteria collegata al contrario", + "alarm_LeadAcidTempSensorDisconnected": "Sensore temperatura piombo acido scollegato", + "alarm_BatteryTemperatureOutOfRange": "Temperatura batteria fuori range", + "alarm_BmsFault": "Guasto BMS", + "alarm_LithiumBatteryOverload": "Sovraccarico Batteria Litio", + "alarm_BmsCommunicationAbnormal": "Comunicazione BMS Anomala", + "alarm_BatterySpdAbnormal": "SPD Batteria Anomalo", + "alarm_OutputDcComponentBiasAbnormal": "Bias DC di Uscita Anomalo", + "alarm_DcComponentOverHighOutputVoltage": "Tensione di uscita DC troppo alta", + "alarm_OffGridOutputVoltageTooLow": "Tensione di uscita off-grid troppo bassa", + "alarm_OffGridOutputVoltageTooHigh": "Tensione di uscita off-grid troppo alta", + "alarm_OffGridOutputOverCurrent": "Corrente di uscita off-grid troppo alta", + "alarm_OffGridOutputOverload": "Sovraccarico Uscita Off-Grid", + "alarm_BalancedCircuitAbnormal": "Circuiti Squilibrati Anomali", + "alarm_ExportLimitationFailSafe": "Limite Esportazione Sicurezza", + "alarm_DcBiasAbnormal": "Bias DC Anomalo", + "alarm_HighDcComponentOutputCurrent": "Alta Componente DC Corrente", + "alarm_BusVoltageSamplingAbnormal": "Campionamento tensione anomalo", + "alarm_RelayFault": "Guasto al relè", + "alarm_BusVoltageAbnormal": "Tensione bus anomala", + "alarm_InternalCommunicationFailure": "Comunicazione interna guasta", + "alarm_TemperatureSensorDisconnected": "Sensore temperatura scollegato", + "alarm_IgbtDriveFault": "Guasto guida IGBT", + "alarm_EepromError": "Errore EEPROM", + "alarm_AuxiliaryPowerAbnormal": "Alimentazione ausiliaria anomala", + "alarm_DcAcOvercurrentProtection": "Protezione sovracorrente DC/AC", + "alarm_CommunicationProtocolMismatch": "Protocollo di comunicazione non corrispondente", + "alarm_DspComFirmwareMismatch": "Incompatibilità firmware DSP/COM", + "alarm_DspSoftwareHardwareMismatch": "Incompatibilità software/hardware DSP", + "alarm_CpldAbnormal": "Anomalia CPLD", + "alarm_RedundancySamplingInconsistent": "Campionamento ridondante inconsistente", + "alarm_PwmPassThroughSignalFailure": "Guasto segnale PWM", + "alarm_AfciSelfTestFailure": "Test AFCI fallito", + "alarm_PvCurrentSamplingAbnormal": "Corrente PV anomala", + "alarm_AcCurrentSamplingAbnormal": "Corrente AC anomala", + "alarm_BusSoftbootFailure": "Avvio bus fallito", + "alarm_EpoFault": "Guasto EPO", + "alarm_MonitoringChipBootVerificationFailed": "Verifica avvio chip monitoraggio fallita", + "alarm_BmsCommunicationFailure": "Comunicazione BMS fallita", + "alarm_BmsChargeDischargeFailure": "Carica/scarica BMS bloccata", + "alarm_BatteryVoltageLow": "Tensione batteria bassa", + "alarm_BatteryVoltageHigh": "Tensione batteria alta", + "alarm_BatteryTemperatureAbnormal": "Temperatura batteria anomala", + "alarm_BatteryReversed": "Batteria invertita", + "alarm_BatteryOpenCircuit": "Circolazione batteria aperta", + "alarm_BatteryOverloadProtection": "Protezione sovraccarico batteria", + "alarm_Bus2VoltageAbnormal": "Tensione Bus2 anomala", + "alarm_BatteryChargeOcp": "Sovraccarico carica batteria", + "alarm_BatteryDischargeOcp": "Sovraccarico scarica batteria", + "alarm_BatterySoftStartFailed": "Avvio batteria fallito", + "alarm_EpsOutputShortCircuited": "Uscita EPS in cortocircuito", + "alarm_OffGridBusVoltageLow": "Tensione bus off-grid bassa", + "alarm_OffGridTerminalVoltageAbnormal": "Tensione terminale anomala", + "alarm_SoftStartFailed": "Avvio morbido fallito", + "alarm_OffGridOutputVoltageAbnormal": "Tensione di uscita anomala", + "alarm_BalancedCircuitSelfTestFailed": "Autotest circuito bilanciato fallito", + "alarm_HighDcComponentOutputVoltage": "Tensione di uscita DC elevata", + "alarm_OffGridParallelSignalAbnormal": "Segnale parallelo off-grid anomalo", + "alarm_AFCIFault": "Guasto AFCI", + "alarm_GFCIHigh": "Corrente di guasto a terra elevata", + "alarm_PVVoltageHigh": "Tensione PV elevata", + "alarm_OffGridBusVoltageTooLow": "Tensione Bus Fuori Rete Troppo Bassa" +} diff --git a/typescript/frontend-marios2/src/layouts/SidebarLayout/Header/Menu/index.tsx b/typescript/frontend-marios2/src/layouts/SidebarLayout/Header/Menu/index.tsx index 743301461..32ceaf848 100644 --- a/typescript/frontend-marios2/src/layouts/SidebarLayout/Header/Menu/index.tsx +++ b/typescript/frontend-marios2/src/layouts/SidebarLayout/Header/Menu/index.tsx @@ -141,10 +141,13 @@ function HeaderMenu(props: HeaderButtonsProps) { English handleLanguageSelect('de')}> - German + Deutsch handleLanguageSelect('fr')}> - French + Français + + handleLanguageSelect('it')}> + Italiano