From 14f870619822678c0fa9d90c583d3f3c8f4de382 Mon Sep 17 00:00:00 2001 From: suffian Date: Mon, 28 Sep 2026 16:55:31 +0800 Subject: [PATCH] Initial Commit --- .gitignore | 482 ++++++ TuneBoss.Core.Tests/MapFileTests.cs | 86 + TuneBoss.Core.Tests/MapTableFormatTests.cs | 101 ++ TuneBoss.Core.Tests/MemoryLayoutTests.cs | 71 + TuneBoss.Core.Tests/MiscBitSpecTests.cs | 104 ++ TuneBoss.Core.Tests/MiscFieldRegistryTests.cs | 43 + TuneBoss.Core.Tests/MiscValuesTests.cs | 58 + TuneBoss.Core.Tests/OneDimDisplayTests.cs | 54 + TuneBoss.Core.Tests/OneDimRegistryTests.cs | 42 + TuneBoss.Core.Tests/OneDimTableTests.cs | 99 ++ TuneBoss.Core.Tests/TestData.cs | 46 + TuneBoss.Core.Tests/TpsCalibrationTests.cs | 82 + .../TuneBoss.Core.Tests.csproj | 26 + TuneBoss.Core/BLE/BleManager.cs | 668 ++++++++ TuneBoss.Core/BLE/IBleService.cs | 196 +++ TuneBoss.Core/BLE/PacketParser.cs | 168 ++ TuneBoss.Core/BLE/SimBleService.cs | 368 ++++ TuneBoss.Core/Class1.cs | 7 + TuneBoss.Core/IO/FsrFile.cs | 470 +++++ TuneBoss.Core/IO/IMapTableCodec.cs | 54 + TuneBoss.Core/IO/MapCompatibility.cs | 44 + TuneBoss.Core/IO/MapFile.cs | 77 + TuneBoss.Core/IO/MapTableFormat.cs | 139 ++ TuneBoss.Core/IO/MapTag.cs | 100 ++ TuneBoss.Core/Models/AfrTable.cs | 221 +++ TuneBoss.Core/Models/BikeRegistry.cs | 109 ++ TuneBoss.Core/Models/DiagnosticsFrame.cs | 417 +++++ TuneBoss.Core/Models/EcuInfo.cs | 190 +++ TuneBoss.Core/Models/EcuSession.cs | 79 + TuneBoss.Core/Models/MemoryLayout.cs | 302 ++++ TuneBoss.Core/Models/MiscBitSpec.cs | 34 + TuneBoss.Core/Models/MiscBitSpecRegistry.cs | 228 +++ TuneBoss.Core/Models/MiscDisplayText.cs | 120 ++ TuneBoss.Core/Models/MiscFieldRegistry.cs | 349 ++++ TuneBoss.Core/Models/MiscValues.cs | 482 ++++++ TuneBoss.Core/Models/OneDimDisplay.cs | 39 + TuneBoss.Core/Models/OneDimTable.cs | 127 ++ TuneBoss.Core/Models/OneDimTableRegistry.cs | 102 ++ TuneBoss.Core/Models/SubTable.cs | 182 ++ TuneBoss.Core/Models/TableTracker.cs | 158 ++ TuneBoss.Core/Models/TpsCalibration.cs | 101 ++ TuneBoss.Core/Models/TuningTable.cs | 232 +++ TuneBoss.Core/Models/TwoCylinderRegistry.cs | 68 + TuneBoss.Core/Models/VvaModelRegistry.cs | 114 ++ TuneBoss.Core/Protocol/ChecksumHelper.cs | 73 + TuneBoss.Core/Protocol/Commands.cs | 78 + TuneBoss.Core/Protocol/GenerationConfig.cs | 135 ++ TuneBoss.Core/Protocol/PacketBuilder.cs | 163 ++ TuneBoss.Core/TuneBoss.Core.csproj | 15 + TuneBossPC.slnx | 4 + TuneBossPC/App.xaml | 22 + TuneBossPC/App.xaml.cs | 81 + TuneBossPC/AppInfo.cs | 82 + TuneBossPC/AssemblyInfo.cs | 10 + TuneBossPC/Assets/Fonts/Roboto-Bold.ttf | Bin 0 -> 159900 bytes TuneBossPC/Assets/Fonts/Roboto-Medium.ttf | Bin 0 -> 159296 bytes TuneBossPC/Assets/Fonts/Roboto-Regular.ttf | Bin 0 -> 159108 bytes .../Assets/Fonts/RobotoCondensed-Bold.ttf | Bin 0 -> 145528 bytes .../Assets/Fonts/RobotoCondensed-Medium.ttf | Bin 0 -> 144884 bytes .../Assets/Fonts/RobotoCondensed-Regular.ttf | Bin 0 -> 144848 bytes TuneBossPC/Assets/Styles/Colors.xaml | 67 + TuneBossPC/Assets/Styles/Controls.xaml | 615 +++++++ TuneBossPC/Assets/Styles/Typography.xaml | 22 + TuneBossPC/Controls/HoldToConfirmButton.cs | 208 +++ TuneBossPC/Controls/Surface3DControl.cs | 407 +++++ .../Converters/EqualityMultiConverter.cs | 15 + .../Converters/ErrorStatusConverters.cs | 70 + TuneBossPC/Properties/launchSettings.json | 11 + TuneBossPC/Services/AuthService.cs | 137 ++ TuneBossPC/Services/IAuthService.cs | 45 + TuneBossPC/Services/ISessionService.cs | 123 ++ TuneBossPC/Services/MapTableCodec.cs | 589 +++++++ TuneBossPC/Services/SettingsService.cs | 84 + TuneBossPC/TuneBossPC.csproj | 44 + TuneBossPC/ViewModels/ConnectViewModel.cs | 263 +++ .../ViewModels/DiagnosticsStripViewModel.cs | 223 +++ TuneBossPC/ViewModels/DiagnosticsViewModel.cs | 133 ++ .../Dialogs/PasswordDialogViewModel.cs | 100 ++ TuneBossPC/ViewModels/FilesViewModel.cs | 462 +++++ TuneBossPC/ViewModels/MainWindowViewModel.cs | 297 ++++ .../MiscValuesViewModel.MapSupport.cs | 36 + TuneBossPC/ViewModels/MiscValuesViewModel.cs | 376 ++++ .../OneDimTablesViewModel.MapSupport.cs | 35 + .../ViewModels/OneDimTablesViewModel.cs | 789 +++++++++ TuneBossPC/ViewModels/RpmSettingsViewModel.cs | 256 +++ TuneBossPC/ViewModels/SettingsViewModel.cs | 41 + TuneBossPC/ViewModels/StubViewModels.cs | 6 + .../ViewModels/Tables/AxisHeaderViewModel.cs | 26 + .../Tables/BoolToExpanderGlyphConverter.cs | 16 + TuneBossPC/ViewModels/Tables/HeatmapHelper.cs | 92 + .../ViewModels/Tables/TableEntryViewModel.cs | 134 ++ .../ViewModels/Tables/TableRowViewModel.cs | 23 + .../Tables/TuningTableCellViewModel.cs | 25 + .../TuningTablesViewModel.MapSupport.cs | 257 +++ .../Tables/TuningTablesViewModel.cs | 1518 +++++++++++++++++ TuneBossPC/ViewModels/TpsCalViewModel.cs | 258 +++ TuneBossPC/Views/ConnectView.xaml | 177 ++ TuneBossPC/Views/ConnectView.xaml.cs | 14 + TuneBossPC/Views/DiagnosticsStrip.xaml | 142 ++ TuneBossPC/Views/DiagnosticsStrip.xaml.cs | 32 + TuneBossPC/Views/DiagnosticsView.xaml | 432 +++++ TuneBossPC/Views/DiagnosticsView.xaml.cs | 13 + .../Views/Dialogs/ChannelPickerDialog.xaml | 57 + .../Views/Dialogs/ChannelPickerDialog.xaml.cs | 44 + TuneBossPC/Views/Dialogs/PasswordDialog.xaml | 157 ++ .../Views/Dialogs/PasswordDialog.xaml.cs | 80 + TuneBossPC/Views/FilesView.xaml | 163 ++ TuneBossPC/Views/FilesView.xaml.cs | 13 + TuneBossPC/Views/MainWindow.xaml | 233 +++ TuneBossPC/Views/MainWindow.xaml.cs | 47 + TuneBossPC/Views/MiscValuesView.xaml | 266 +++ TuneBossPC/Views/MiscValuesView.xaml.cs | 13 + TuneBossPC/Views/OneDimTablesView.xaml | 512 ++++++ TuneBossPC/Views/OneDimTablesView.xaml.cs | 324 ++++ TuneBossPC/Views/ProgressDialog.xaml | 35 + TuneBossPC/Views/ProgressDialog.xaml.cs | 19 + TuneBossPC/Views/RpmSettingsView.xaml | 138 ++ TuneBossPC/Views/RpmSettingsView.xaml.cs | 23 + TuneBossPC/Views/SettingsView.xaml | 71 + TuneBossPC/Views/SettingsView.xaml.cs | 13 + TuneBossPC/Views/TpsCalView.xaml | 124 ++ TuneBossPC/Views/TpsCalView.xaml.cs | 16 + TuneBossPC/Views/TuningTablesView.xaml | 711 ++++++++ TuneBossPC/Views/TuningTablesView.xaml.cs | 286 ++++ TuneBossPC_23Jul2026.zip | Bin 0 -> 707234 bytes TuneBossPC_28Jul2026.zip | Bin 0 -> 731302 bytes TuneBossPC_28Jun2026.zip | Bin 0 -> 13596990 bytes TuneBossPC_30Jul2026.zip | Bin 0 -> 732399 bytes 128 files changed, 19860 insertions(+) create mode 100644 .gitignore create mode 100644 TuneBoss.Core.Tests/MapFileTests.cs create mode 100644 TuneBoss.Core.Tests/MapTableFormatTests.cs create mode 100644 TuneBoss.Core.Tests/MemoryLayoutTests.cs create mode 100644 TuneBoss.Core.Tests/MiscBitSpecTests.cs create mode 100644 TuneBoss.Core.Tests/MiscFieldRegistryTests.cs create mode 100644 TuneBoss.Core.Tests/MiscValuesTests.cs create mode 100644 TuneBoss.Core.Tests/OneDimDisplayTests.cs create mode 100644 TuneBoss.Core.Tests/OneDimRegistryTests.cs create mode 100644 TuneBoss.Core.Tests/OneDimTableTests.cs create mode 100644 TuneBoss.Core.Tests/TestData.cs create mode 100644 TuneBoss.Core.Tests/TpsCalibrationTests.cs create mode 100644 TuneBoss.Core.Tests/TuneBoss.Core.Tests.csproj create mode 100644 TuneBoss.Core/BLE/BleManager.cs create mode 100644 TuneBoss.Core/BLE/IBleService.cs create mode 100644 TuneBoss.Core/BLE/PacketParser.cs create mode 100644 TuneBoss.Core/BLE/SimBleService.cs create mode 100644 TuneBoss.Core/Class1.cs create mode 100644 TuneBoss.Core/IO/FsrFile.cs create mode 100644 TuneBoss.Core/IO/IMapTableCodec.cs create mode 100644 TuneBoss.Core/IO/MapCompatibility.cs create mode 100644 TuneBoss.Core/IO/MapFile.cs create mode 100644 TuneBoss.Core/IO/MapTableFormat.cs create mode 100644 TuneBoss.Core/IO/MapTag.cs create mode 100644 TuneBoss.Core/Models/AfrTable.cs create mode 100644 TuneBoss.Core/Models/BikeRegistry.cs create mode 100644 TuneBoss.Core/Models/DiagnosticsFrame.cs create mode 100644 TuneBoss.Core/Models/EcuInfo.cs create mode 100644 TuneBoss.Core/Models/EcuSession.cs create mode 100644 TuneBoss.Core/Models/MemoryLayout.cs create mode 100644 TuneBoss.Core/Models/MiscBitSpec.cs create mode 100644 TuneBoss.Core/Models/MiscBitSpecRegistry.cs create mode 100644 TuneBoss.Core/Models/MiscDisplayText.cs create mode 100644 TuneBoss.Core/Models/MiscFieldRegistry.cs create mode 100644 TuneBoss.Core/Models/MiscValues.cs create mode 100644 TuneBoss.Core/Models/OneDimDisplay.cs create mode 100644 TuneBoss.Core/Models/OneDimTable.cs create mode 100644 TuneBoss.Core/Models/OneDimTableRegistry.cs create mode 100644 TuneBoss.Core/Models/SubTable.cs create mode 100644 TuneBoss.Core/Models/TableTracker.cs create mode 100644 TuneBoss.Core/Models/TpsCalibration.cs create mode 100644 TuneBoss.Core/Models/TuningTable.cs create mode 100644 TuneBoss.Core/Models/TwoCylinderRegistry.cs create mode 100644 TuneBoss.Core/Models/VvaModelRegistry.cs create mode 100644 TuneBoss.Core/Protocol/ChecksumHelper.cs create mode 100644 TuneBoss.Core/Protocol/Commands.cs create mode 100644 TuneBoss.Core/Protocol/GenerationConfig.cs create mode 100644 TuneBoss.Core/Protocol/PacketBuilder.cs create mode 100644 TuneBoss.Core/TuneBoss.Core.csproj create mode 100644 TuneBossPC.slnx create mode 100644 TuneBossPC/App.xaml create mode 100644 TuneBossPC/App.xaml.cs create mode 100644 TuneBossPC/AppInfo.cs create mode 100644 TuneBossPC/AssemblyInfo.cs create mode 100644 TuneBossPC/Assets/Fonts/Roboto-Bold.ttf create mode 100644 TuneBossPC/Assets/Fonts/Roboto-Medium.ttf create mode 100644 TuneBossPC/Assets/Fonts/Roboto-Regular.ttf create mode 100644 TuneBossPC/Assets/Fonts/RobotoCondensed-Bold.ttf create mode 100644 TuneBossPC/Assets/Fonts/RobotoCondensed-Medium.ttf create mode 100644 TuneBossPC/Assets/Fonts/RobotoCondensed-Regular.ttf create mode 100644 TuneBossPC/Assets/Styles/Colors.xaml create mode 100644 TuneBossPC/Assets/Styles/Controls.xaml create mode 100644 TuneBossPC/Assets/Styles/Typography.xaml create mode 100644 TuneBossPC/Controls/HoldToConfirmButton.cs create mode 100644 TuneBossPC/Controls/Surface3DControl.cs create mode 100644 TuneBossPC/Converters/EqualityMultiConverter.cs create mode 100644 TuneBossPC/Converters/ErrorStatusConverters.cs create mode 100644 TuneBossPC/Properties/launchSettings.json create mode 100644 TuneBossPC/Services/AuthService.cs create mode 100644 TuneBossPC/Services/IAuthService.cs create mode 100644 TuneBossPC/Services/ISessionService.cs create mode 100644 TuneBossPC/Services/MapTableCodec.cs create mode 100644 TuneBossPC/Services/SettingsService.cs create mode 100644 TuneBossPC/TuneBossPC.csproj create mode 100644 TuneBossPC/ViewModels/ConnectViewModel.cs create mode 100644 TuneBossPC/ViewModels/DiagnosticsStripViewModel.cs create mode 100644 TuneBossPC/ViewModels/DiagnosticsViewModel.cs create mode 100644 TuneBossPC/ViewModels/Dialogs/PasswordDialogViewModel.cs create mode 100644 TuneBossPC/ViewModels/FilesViewModel.cs create mode 100644 TuneBossPC/ViewModels/MainWindowViewModel.cs create mode 100644 TuneBossPC/ViewModels/MiscValuesViewModel.MapSupport.cs create mode 100644 TuneBossPC/ViewModels/MiscValuesViewModel.cs create mode 100644 TuneBossPC/ViewModels/OneDimTablesViewModel.MapSupport.cs create mode 100644 TuneBossPC/ViewModels/OneDimTablesViewModel.cs create mode 100644 TuneBossPC/ViewModels/RpmSettingsViewModel.cs create mode 100644 TuneBossPC/ViewModels/SettingsViewModel.cs create mode 100644 TuneBossPC/ViewModels/StubViewModels.cs create mode 100644 TuneBossPC/ViewModels/Tables/AxisHeaderViewModel.cs create mode 100644 TuneBossPC/ViewModels/Tables/BoolToExpanderGlyphConverter.cs create mode 100644 TuneBossPC/ViewModels/Tables/HeatmapHelper.cs create mode 100644 TuneBossPC/ViewModels/Tables/TableEntryViewModel.cs create mode 100644 TuneBossPC/ViewModels/Tables/TableRowViewModel.cs create mode 100644 TuneBossPC/ViewModels/Tables/TuningTableCellViewModel.cs create mode 100644 TuneBossPC/ViewModels/Tables/TuningTablesViewModel.MapSupport.cs create mode 100644 TuneBossPC/ViewModels/Tables/TuningTablesViewModel.cs create mode 100644 TuneBossPC/ViewModels/TpsCalViewModel.cs create mode 100644 TuneBossPC/Views/ConnectView.xaml create mode 100644 TuneBossPC/Views/ConnectView.xaml.cs create mode 100644 TuneBossPC/Views/DiagnosticsStrip.xaml create mode 100644 TuneBossPC/Views/DiagnosticsStrip.xaml.cs create mode 100644 TuneBossPC/Views/DiagnosticsView.xaml create mode 100644 TuneBossPC/Views/DiagnosticsView.xaml.cs create mode 100644 TuneBossPC/Views/Dialogs/ChannelPickerDialog.xaml create mode 100644 TuneBossPC/Views/Dialogs/ChannelPickerDialog.xaml.cs create mode 100644 TuneBossPC/Views/Dialogs/PasswordDialog.xaml create mode 100644 TuneBossPC/Views/Dialogs/PasswordDialog.xaml.cs create mode 100644 TuneBossPC/Views/FilesView.xaml create mode 100644 TuneBossPC/Views/FilesView.xaml.cs create mode 100644 TuneBossPC/Views/MainWindow.xaml create mode 100644 TuneBossPC/Views/MainWindow.xaml.cs create mode 100644 TuneBossPC/Views/MiscValuesView.xaml create mode 100644 TuneBossPC/Views/MiscValuesView.xaml.cs create mode 100644 TuneBossPC/Views/OneDimTablesView.xaml create mode 100644 TuneBossPC/Views/OneDimTablesView.xaml.cs create mode 100644 TuneBossPC/Views/ProgressDialog.xaml create mode 100644 TuneBossPC/Views/ProgressDialog.xaml.cs create mode 100644 TuneBossPC/Views/RpmSettingsView.xaml create mode 100644 TuneBossPC/Views/RpmSettingsView.xaml.cs create mode 100644 TuneBossPC/Views/SettingsView.xaml create mode 100644 TuneBossPC/Views/SettingsView.xaml.cs create mode 100644 TuneBossPC/Views/TpsCalView.xaml create mode 100644 TuneBossPC/Views/TpsCalView.xaml.cs create mode 100644 TuneBossPC/Views/TuningTablesView.xaml create mode 100644 TuneBossPC/Views/TuningTablesView.xaml.cs create mode 100644 TuneBossPC_23Jul2026.zip create mode 100644 TuneBossPC_28Jul2026.zip create mode 100644 TuneBossPC_28Jun2026.zip create mode 100644 TuneBossPC_30Jul2026.zip diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0808c4a --- /dev/null +++ b/.gitignore @@ -0,0 +1,482 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from `dotnet new gitignore` + +# dotenv files +.env + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET +project.lock.json +project.fragment.lock.json +artifacts/ + +# Tye +.tye/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +# but not Directory.Build.rsp, as it configures directory-level build defaults +!Directory.Build.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio 6 auto-generated project file (contains which files were open etc.) +*.vbp + +# Visual Studio 6 workspace and project file (working project files containing files to include in project) +*.dsw +*.dsp + +# Visual Studio 6 technical files +*.ncb +*.aps + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# Visual Studio History (VSHistory) files +.vshistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +*.sln.iml +.idea/ + +## +## Visual studio for Mac +## + + +# globs +Makefile.in +*.userprefs +*.usertasks +config.make +config.status +aclocal.m4 +install-sh +autom4te.cache/ +*.tar.gz +tarballs/ +test-results/ + +# content below from: https://github.com/github/gitignore/blob/main/Global/macOS.gitignore +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# content below from: https://github.com/github/gitignore/blob/main/Global/Windows.gitignore +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# Vim temporary swap files +*.swp diff --git a/TuneBoss.Core.Tests/MapFileTests.cs b/TuneBoss.Core.Tests/MapFileTests.cs new file mode 100644 index 0000000..c657054 --- /dev/null +++ b/TuneBoss.Core.Tests/MapFileTests.cs @@ -0,0 +1,86 @@ +using TuneBoss.Core.IO; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class MapFileTests +{ + [Fact] + public void Md5Hex_is_uppercase_no_separators() + => Assert.Equal("D41D8CD98F00B204E9800998ECF8427E", MapFile.Md5Hex("")); + + [Fact] + public void Envelope_round_trips() + { + var env = MapFile.BuildEnvelope("the-tag", "the data section"); + var r = MapFile.TryParse(env); + Assert.True(r.Ok); + Assert.Equal("the-tag", r.Tag); + Assert.Equal("the data section", r.Data); + } + + [Fact] + public void Envelope_tolerates_crlf_newlines() + { + var env = MapFile.BuildEnvelope("t", "d").Replace("\n", "\r\n"); + Assert.True(MapFile.TryParse(env).Ok); + } + + [Fact] + public void Tampered_tag_is_rejected() + { + var env = MapFile.BuildEnvelope("original", "data"); + var bad = env.Replace("_____original", "_____TAMPERED"); + var r = MapFile.TryParse(bad); + Assert.False(r.Ok); + Assert.Contains("Tag checksum", r.Error); + } + + [Fact] + public void Tampered_data_is_rejected() + { + var env = MapFile.BuildEnvelope("tag", "good"); + var bad = env.Replace("_____good", "_____bad!"); + Assert.False(MapFile.TryParse(bad).Ok); + } + + [Fact] + public void Missing_data_record_is_rejected() + => Assert.False(MapFile.TryParse(MapFile.Md5Hex("x") + "_____x").Ok); + + [Fact] + public void Tag_round_trips_all_fields() + { + var t = new MapTag + { + CreatorId = "TUNER01", FwVersion = 193, HwVersion = 10, + Make = 1, Model = 6, CylinderCount = 1, SaveType = MapSaveType.FullConfig, + EngineBlock = "stock", Camshaft = "stage2", Exhaust = "akra", + AirFilter = "k&n", CylinderHead = "ported", Injector = "440cc", + ThrottleBody = "34mm", JackRod = "none", MiscNote = "dyno 18.2hp", + }; + var back = MapTag.Parse(t.Build()); + + Assert.Equal(t.CreatorId, back.CreatorId); + Assert.Equal(t.FwVersion, back.FwVersion); + Assert.Equal(t.Make, back.Make); + Assert.Equal(t.Model, back.Model); + Assert.Equal(t.CylinderCount, back.CylinderCount); + Assert.Equal(t.SaveType, back.SaveType); + Assert.Equal(t.Exhaust, back.Exhaust); + Assert.Equal(t.MiscNote, back.MiscNote); + } + + [Fact] + public void Tag_has_16_fields() + => Assert.Equal(MapTag.FieldCount, new MapTag().Build().Split(MapTag.FieldSep).Length); + + [Fact] + public void Tag_parse_tolerates_short_input() + { + var t = MapTag.Parse("CREATOR___193___10___1___6___1___4"); + Assert.Equal("CREATOR", t.CreatorId); + Assert.Equal(MapSaveType.FullConfig, t.SaveType); + Assert.Equal("", t.MiscNote); // absent field → empty, no throw + } +} diff --git a/TuneBoss.Core.Tests/MapTableFormatTests.cs b/TuneBoss.Core.Tests/MapTableFormatTests.cs new file mode 100644 index 0000000..14e6472 --- /dev/null +++ b/TuneBoss.Core.Tests/MapTableFormatTests.cs @@ -0,0 +1,101 @@ +using TuneBoss.Core.IO; +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class MapTableFormatTests +{ + private static byte[] Ramp(int n, int start = 0, int step = 1) + { + var a = new byte[n]; + for (int i = 0; i < n; i++) a[i] = (byte)((start + i * step) & 0xFF); + return a; + } + + [Fact] + public void Section2D_round_trips() + { + var t = new TuningTable + { + Data = Ramp(TuningTable.DataBytes, 1), + LoadAxis = Ramp(TuningTable.Rows, 10, 5), + RpmAxis = Ramp(TuningTable.Cols, 8, 9), + MaxRaw = 250, MinRaw = 3, Mult = 1, Sign = 0, + }; + var section = MapTableFormat.Section2D("Fuel_PulseWidth_Adjust1", t); + Assert.Equal("Fuel_PulseWidth_Adjust1", MapTableFormat.LabelOf(section)); + + // Single section + trailing empty after the ____ terminator. + var parts = MapTableFormat.SplitSections(section); + var back = MapTableFormat.Parse2D(parts[0]); + + Assert.Equal(t.Data, back.Data); + Assert.Equal(t.LoadAxis, back.LoadAxis); + Assert.Equal(t.RpmAxis, back.RpmAxis); + Assert.Equal(t.MaxRaw, back.MaxRaw); + Assert.Equal(t.MinRaw, back.MinRaw); + Assert.Equal(t.Mult, back.Mult); + Assert.Equal(t.Sign, back.Sign); + } + + [Fact] + public void Afr_round_trips_without_modifiers() + { + var t = new AfrTable + { + Data = Ramp(AfrTable.DataBytes, 130), + LoadAxis = Ramp(AfrTable.Rows, 20), + RpmAxis = Ramp(AfrTable.Cols, 5, 7), + }; + var back = MapTableFormat.ParseAfr(MapTableFormat.SplitSections(MapTableFormat.SectionAfr("AFR_Target1", t))[0]); + Assert.Equal(t.Data, back.Data); + Assert.Equal(t.LoadAxis, back.LoadAxis); + Assert.Equal(t.RpmAxis, back.RpmAxis); + } + + [Fact] + public void Sub_derives_rpm_from_parent() + { + var parentRpm = Ramp(TuningTable.Cols, 0, 1); // 0,1,2,...,23 + var sub = new SubTable { Data = Ramp(SubTable.DataBytes, 100) }; + var section = MapTableFormat.SplitSections(MapTableFormat.SectionSub("Spark_Angle_Adjust1_SubTable", sub))[0]; + + var back = MapTableFormat.ParseSub(section, parentRpm); + Assert.Equal(sub.Data, back.Data); + for (int x = 0; x < SubTable.Cols; x++) + { + Assert.Equal(parentRpm[x * 4], back.RpmAxis[x * 2]); + Assert.Equal(parentRpm[x * 4 + 3], back.RpmAxis[x * 2 + 1]); + } + } + + [Fact] + public void OneD_round_trips_24_byte_wire() + { + var t = new OneDimTable + { + MaxRaw = 200, MinRaw = 0, RawSignedFlag = 0, ConvSignedFlag = 1, + RawMultiplier = 2, ConvMultiplier = 3, RawRounding = 0, ConvOffset = -5, + }; + for (int i = 0; i < OneDimTable.PointCount; i++) { t.RawAxis[i] = i * 8; t.ConvValues[i] = 40 - i; } + + var section = MapTableFormat.SplitSections(MapTableFormat.Section1D("O2_Conversion_Table", t))[0]; + var back = MapTableFormat.Parse1D(section); + Assert.Equal(t.ToWirePayload(), back.ToWirePayload()); // metadata + axes + values round-trip verbatim + } + + [Fact] + public void ParseBytes_handles_trailing_space() + => Assert.Equal(new byte[] { 10, 20, 255 }, MapTableFormat.ParseBytes("10 20 255 ")); + + [Fact] + public void Two_sections_split_positionally() + { + var t = new TuningTable(); + var doc = MapTableFormat.Section2D("A", t) + MapTableFormat.Section2D("B", t); + var parts = MapTableFormat.SplitSections(doc); + Assert.Equal("A", MapTableFormat.LabelOf(parts[0])); + Assert.Equal("B", MapTableFormat.LabelOf(parts[1])); + } +} diff --git a/TuneBoss.Core.Tests/MemoryLayoutTests.cs b/TuneBoss.Core.Tests/MemoryLayoutTests.cs new file mode 100644 index 0000000..542c15a --- /dev/null +++ b/TuneBoss.Core.Tests/MemoryLayoutTests.cs @@ -0,0 +1,71 @@ +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class MemoryLayoutTests +{ + [Theory] + [InlineData(70)] + [InlineData(80)] + [InlineData(83)] + [InlineData(90)] + [InlineData(130)] + [InlineData(193)] + public void Gen3_1D_availability_matches_registry_firmware_gating(byte fw) + { + var layout = MemoryLayout.For(TestData.Ecu(TestData.Gen3, fw), EcuVariant.TwoCylinderR15); + + Assert.Equal(37, layout.OneDimTables.Length); + + foreach (var def in OneDimTableRegistry.All) + { + var region = layout.OneDimTables[def.Slot - 1]; + Assert.Equal(fw >= def.MinFirmware, region.IsAvailable); + } + } + + [Theory] + [InlineData(149, false)] + [InlineData(150, true)] + [InlineData(193, true)] + public void Gen3_misc_padding_is_gated_at_fw150(byte fw, bool available) + { + var l = MemoryLayout.For(TestData.Ecu(TestData.Gen3, fw), EcuVariant.TwoCylinder); + + Assert.Equal(available, l.MiscLaunchFuel.IsAvailable); + Assert.Equal(available, l.MiscLaunchFuel2.IsAvailable); + Assert.Equal(available, l.MiscAuxOut.IsAvailable); + Assert.Equal(available, l.MiscExtended.IsAvailable); + } + + [Theory] + [InlineData(70)] + [InlineData(150)] + [InlineData(193)] + public void MiscCore_is_always_present_and_136_bytes(byte fw) + { + var l = MemoryLayout.For(TestData.Ecu(TestData.Gen3, fw), EcuVariant.TwoCylinder); + Assert.True(l.MiscCore.IsAvailable); + Assert.Equal(0x88, l.MiscCore.Length); + } + + [Theory] + [InlineData(EcuVariant.SingleCylinder)] + [InlineData(EcuVariant.TwoCylinder)] + [InlineData(EcuVariant.TwoCylinderR15)] + public void MiscExtended_length_follows_variant_when_available(EcuVariant variant) + { + var l = MemoryLayout.For(TestData.Ecu(TestData.Gen3, 193), variant); + Assert.True(l.MiscExtended.IsAvailable); + Assert.Equal((byte)MiscValues.ExtendedLengthFor(variant), l.MiscExtended.Length); + } + + [Fact] + public void Gen1_exposes_only_the_base_18_oneDim_tables() + { + var l = MemoryLayout.For(TestData.Ecu(TestData.Gen1, 193), EcuVariant.SingleCylinder); + for (int i = 0; i < 37; i++) + Assert.Equal(i < 18, l.OneDimTables[i].IsAvailable); + } +} diff --git a/TuneBoss.Core.Tests/MiscBitSpecTests.cs b/TuneBoss.Core.Tests/MiscBitSpecTests.cs new file mode 100644 index 0000000..692580f --- /dev/null +++ b/TuneBoss.Core.Tests/MiscBitSpecTests.cs @@ -0,0 +1,104 @@ +using System.Numerics; +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +/// +/// These are the high-value regression tests: they tie the bit-editor specs to the +/// field registry and validate every mask. The "spec key exists" test is exactly what +/// would have caught the ShiftBoss byte-84 mislabel and the Core_25/31/33/120 key drift. +/// +public class MiscBitSpecTests +{ + [Fact] + public void Every_spec_key_resolves_to_a_field() + { + foreach (var spec in MiscBitSpecRegistry.All) + { + bool found = MiscFieldRegistry.All.Any( + f => f.Block == spec.Block && f.Label == spec.FieldLabel); + + Assert.True(found, + $"Spec '{spec.FieldLabel}' ({spec.Block}) has no matching MiscField — " + + "the bit editor will silently fail to attach."); + } + } + + [Fact] + public void Find_returns_spec_by_key() + { + var s = MiscBitSpecRegistry.Find(MiscBlock.Core, "ShiftBoss_Enable"); + Assert.NotNull(s); + Assert.Equal("ShiftBoss_Enable", s!.FieldLabel); + + Assert.Null(MiscBitSpecRegistry.Find(MiscBlock.Core, "does_not_exist")); + } + + [Fact] + public void All_masks_are_within_a_byte_and_nonzero() + { + foreach (var spec in MiscBitSpecRegistry.All) + foreach (var f in spec.Fields) + Assert.InRange(f.Mask, 1, 255); + } + + [Fact] + public void Flag_fields_are_a_single_bit() + { + foreach (var spec in MiscBitSpecRegistry.All) + foreach (var f in spec.Fields) + if (f.Kind == MiscEditorKind.Flag) + Assert.Equal(1, BitOperations.PopCount((uint)f.Mask)); + } + + [Fact] + public void Enum_options_fit_the_mask_range() + { + foreach (var spec in MiscBitSpecRegistry.All) + foreach (var f in spec.Fields) + { + if (f.Kind != MiscEditorKind.Enum) continue; + Assert.NotNull(f.Options); + int shift = BitOperations.TrailingZeroCount((uint)f.Mask); + int maxVal = f.Mask >> shift; // e.g. 0x06 -> 3 + Assert.True(f.Options!.Length >= 2, + $"{spec.FieldLabel}/{f.Label}: enum needs >= 2 options"); + Assert.True(f.Options.Length <= maxVal + 1, + $"{spec.FieldLabel}/{f.Label}: {f.Options.Length} options exceed mask range {maxVal + 1}"); + } + } + + [Fact] + public void Fields_within_a_spec_do_not_overlap_bits() + { + foreach (var spec in MiscBitSpecRegistry.All) + { + int used = 0; + foreach (var f in spec.Fields) + { + Assert.True((used & f.Mask) == 0, + $"{spec.FieldLabel}: field '{f.Label}' mask 0x{f.Mask:X2} overlaps another field"); + used |= f.Mask; + } + } + } + + [Fact] + public void Constraint_indices_are_valid_bit_positions() + { + foreach (var spec in MiscBitSpecRegistry.All) + { + foreach (var (a, b) in spec.MutualExclusive ?? Enumerable.Empty<(int, int)>()) + { + Assert.InRange(a, 0, 7); + Assert.InRange(b, 0, 7); + } + foreach (var (a, b) in spec.Linked ?? Enumerable.Empty<(int, int)>()) + { + Assert.InRange(a, 0, 7); + Assert.InRange(b, 0, 7); + } + } + } +} diff --git a/TuneBoss.Core.Tests/MiscFieldRegistryTests.cs b/TuneBoss.Core.Tests/MiscFieldRegistryTests.cs new file mode 100644 index 0000000..d7d3c10 --- /dev/null +++ b/TuneBoss.Core.Tests/MiscFieldRegistryTests.cs @@ -0,0 +1,43 @@ +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class MiscFieldRegistryTests +{ + private static int BlockSize(MiscBlock b) => b switch + { + MiscBlock.Core => 136, + MiscBlock.LaunchFuel => 12, + MiscBlock.LaunchFuel2 => 12, + MiscBlock.AuxOut => 12, + MiscBlock.Extended => 152, + _ => 0, + }; + + [Fact] + public void All_field_indices_are_within_their_block() + { + foreach (var f in MiscFieldRegistry.All) + Assert.InRange(f.Index, 0, BlockSize(f.Block) - 1); + } + + [Fact] + public void No_two_fields_share_a_block_and_index() + { + var dupes = MiscFieldRegistry.All + .GroupBy(f => (f.Block, f.Index)) + .Where(g => g.Count() > 1) + .Select(g => $"{g.Key.Block}[{g.Key.Index}]: {string.Join(", ", g.Select(x => x.Label))}") + .ToList(); + + Assert.True(dupes.Count == 0, "Duplicate (block,index) mappings:\n" + string.Join("\n", dupes)); + } + + [Fact] + public void All_labels_are_nonblank() + { + foreach (var f in MiscFieldRegistry.All) + Assert.False(string.IsNullOrWhiteSpace(f.Label)); + } +} diff --git a/TuneBoss.Core.Tests/MiscValuesTests.cs b/TuneBoss.Core.Tests/MiscValuesTests.cs new file mode 100644 index 0000000..a962938 --- /dev/null +++ b/TuneBoss.Core.Tests/MiscValuesTests.cs @@ -0,0 +1,58 @@ +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class MiscValuesTests +{ + [Fact] + public void Core_is_sliced_from_offset_4() + { + var data = new byte[136]; + for (int i = 0; i < data.Length; i++) data[i] = (byte)i; + + var mv = MiscValues.FromPayloads(TestData.WithHeader(data, 0x46)); + + Assert.Equal(136, mv.Core.Length); + Assert.Equal(0, mv.Core[0]); // header skipped + Assert.Equal(135, mv.Core[135]); + } + + [Fact] + public void Short_core_payload_yields_empty() + { + // 4 header + 100 data = 104 < 4 + 136, so Slice returns empty. + var mv = MiscValues.FromPayloads(TestData.WithHeader(new byte[100])); + Assert.Empty(mv.Core); + } + + [Fact] + public void Optional_blocks_default_to_empty() + { + var mv = MiscValues.FromPayloads(TestData.WithHeader(new byte[136])); + Assert.Empty(mv.LaunchFuel); + Assert.Empty(mv.LaunchFuel2); + Assert.Empty(mv.AuxOut); + Assert.Empty(mv.Extended); + } + + [Theory] + [InlineData(EcuVariant.SingleCylinder, 0x29)] + [InlineData(EcuVariant.TwoCylinder, 0x73)] + [InlineData(EcuVariant.TwoCylinderR15, 0x97)] + public void ExtendedLengthFor_matches_variant(EcuVariant v, int expected) + { + Assert.Equal(expected, MiscValues.ExtendedLengthFor(v)); + } + + [Fact] + public void Extended_slice_size_follows_payload_length() + { + int n = MiscValues.ExtendedLengthFor(EcuVariant.TwoCylinderR15); // 0x97 + var mv = MiscValues.FromPayloads( + corePayload: new byte[140], // 4 + 136 + extendedPayload: TestData.WithHeader(new byte[n])); + + Assert.Equal(n, mv.Extended.Length); + } +} diff --git a/TuneBoss.Core.Tests/OneDimDisplayTests.cs b/TuneBoss.Core.Tests/OneDimDisplayTests.cs new file mode 100644 index 0000000..965d43c --- /dev/null +++ b/TuneBoss.Core.Tests/OneDimDisplayTests.cs @@ -0,0 +1,54 @@ +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class OneDimDisplayTests +{ + [Theory] + [InlineData(0, 1)] + [InlineData(1, 1)] + [InlineData(100, 100)] + [InlineData(50, 50)] + public void Multiplier_0_or_1_is_unscaled(int mult, int expected) + => Assert.Equal(expected, OneDimDisplay.EffectiveMultiplier(mult)); + + [Theory] + [InlineData(130, 100, 13000)] // RPM + [InlineData(45, 1, 45)] // unscaled + [InlineData(7, 0, 7)] // mult 0 -> ×1 + [InlineData(-5, 2, -10)] // signed + public void ToDisplay_scales(int raw, int mult, long expected) + => Assert.Equal(expected, OneDimDisplay.ToDisplay(raw, mult)); + + [Theory] + [InlineData(13000, 100, 130)] + [InlineData(13100, 100, 131)] + [InlineData(42, 1, 42)] + [InlineData(-10, 2, -5)] + public void TryFromDisplay_accepts_multiples(double display, int mult, int expectedRaw) + { + Assert.True(OneDimDisplay.TryFromDisplay(display, mult, out int raw)); + Assert.Equal(expectedRaw, raw); + } + + [Theory] + [InlineData(13050, 100)] // not a multiple of 100 + [InlineData(42.5, 1)] // not a whole number + [InlineData(13, 5)] // not a multiple of 5 + public void TryFromDisplay_rejects_non_multiples(double display, int mult) + { + Assert.False(OneDimDisplay.TryFromDisplay(display, mult, out _)); + } + + [Fact] + public void Round_trips_display_then_raw() + { + for (int raw = -120; raw <= 120; raw += 7) + { + long disp = OneDimDisplay.ToDisplay(raw, 100); + Assert.True(OneDimDisplay.TryFromDisplay(disp, 100, out int back)); + Assert.Equal(raw, back); + } + } +} diff --git a/TuneBoss.Core.Tests/OneDimRegistryTests.cs b/TuneBoss.Core.Tests/OneDimRegistryTests.cs new file mode 100644 index 0000000..07e76d4 --- /dev/null +++ b/TuneBoss.Core.Tests/OneDimRegistryTests.cs @@ -0,0 +1,42 @@ +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class OneDimRegistryTests +{ + [Fact] + public void Has_37_tables() + { + Assert.Equal(37, OneDimTableRegistry.All.Count); + } + + [Fact] + public void Slots_are_unique_and_contiguous_1_to_37() + { + var slots = OneDimTableRegistry.All.Select(d => d.Slot).OrderBy(s => s).ToList(); + Assert.Equal(Enumerable.Range(1, 37), slots); + } + + [Fact] + public void Min_firmware_values_are_known_tiers() + { + var allowed = new[] { 0, 80, 83, 90, 130 }; + foreach (var d in OneDimTableRegistry.All) + Assert.Contains(d.MinFirmware, allowed); + } + + [Fact] + public void Every_group_used_appears_in_group_order() + { + foreach (var d in OneDimTableRegistry.All) + Assert.Contains(d.Group, OneDimTableRegistry.GroupOrder); + } + + [Fact] + public void Labels_are_nonblank() + { + foreach (var d in OneDimTableRegistry.All) + Assert.False(string.IsNullOrWhiteSpace(d.Label)); + } +} diff --git a/TuneBoss.Core.Tests/OneDimTableTests.cs b/TuneBoss.Core.Tests/OneDimTableTests.cs new file mode 100644 index 0000000..48b1c22 --- /dev/null +++ b/TuneBoss.Core.Tests/OneDimTableTests.cs @@ -0,0 +1,99 @@ +using TuneBoss.Core.Models; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class OneDimTableTests +{ + [Fact] + public void FromWire_then_ToWire_is_byte_identical_unsigned() + { + var wire = TestData.OneDimWire( + axis: new byte[] { 0, 10, 20, 40, 80, 120, 200, 255 }, + conv: new byte[] { 5, 6, 7, 8, 9, 10, 11, 12 }, + rawMult: 100, convMult: 1, maxRaw: 255, minRaw: 0, convOffset: -3); + + var t = OneDimTable.FromWire(wire); + var rt = t.ToWirePayload(); + + Assert.Equal(wire, rt); // full verbatim round-trip + } + + [Fact] + public void Metadata_bytes_round_trip_verbatim() + { + var wire = TestData.OneDimWire( + axis: new byte[8], conv: new byte[8], + rawSigned: 1, convSigned: 1, rawMult: 100, convMult: 50, + maxRaw: 200, minRaw: 10, rawRound: 7, convOffset: -12); + + var t = OneDimTable.FromWire(wire); + + Assert.Equal(1, t.RawSignedFlag); + Assert.Equal(1, t.ConvSignedFlag); + Assert.Equal(100, t.RawMultiplier); + Assert.Equal(50, t.ConvMultiplier); + Assert.Equal(7, t.RawRounding); + Assert.Equal(-12, t.ConvOffset); + Assert.Equal(wire, t.ToWirePayload()); + } + + [Fact] + public void Signed_axis_and_values_decode_negative() + { + var wire = TestData.OneDimWire( + axis: new byte[] { 0xFF, 0xFE, 0, 1, 2, 3, 4, 5 }, // -1, -2, 0, 1... + conv: new byte[] { 0x80, 0xFF, 0, 1, 2, 3, 4, 5 }, // -128, -1, 0... + rawSigned: 1, convSigned: 1); + + var t = OneDimTable.FromWire(wire); + + Assert.Equal(-1, t.RawAxis[0]); + Assert.Equal(-2, t.RawAxis[1]); + Assert.Equal(-128, t.ConvValues[0]); + Assert.Equal(-1, t.ConvValues[1]); + Assert.Equal(wire, t.ToWirePayload()); // signed values re-encode exactly + } + + [Fact] + public void Unsigned_high_byte_stays_positive() + { + var wire = TestData.OneDimWire( + axis: new byte[] { 200, 255, 0, 0, 0, 0, 0, 0 }, + conv: new byte[] { 255, 200, 0, 0, 0, 0, 0, 0 }, + rawSigned: 0, convSigned: 0); + + var t = OneDimTable.FromWire(wire); + + Assert.Equal(200, t.RawAxis[0]); + Assert.Equal(255, t.RawAxis[1]); + Assert.Equal(255, t.ConvValues[0]); + } + + [Fact] + public void FromWire_honours_offset() + { + var inner = TestData.OneDimWire(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, new byte[8]); + var framed = TestData.WithHeader(inner); // 4-byte header + 24-byte block + + var t = OneDimTable.FromWire(framed, 4); + + Assert.Equal(1, t.RawAxis[0]); + Assert.Equal(8, t.RawAxis[7]); + } + + [Fact] + public void FromWire_short_payload_throws() + { + Assert.Throws(() => OneDimTable.FromWire(new byte[10])); + } + + [Fact] + public void Clone_is_independent() + { + var t = OneDimTable.FromWire(TestData.OneDimWire(new byte[8], new byte[8])); + var c = t.Clone(); + c.ConvValues[0] = 99; + Assert.NotEqual(99, t.ConvValues[0]); + } +} diff --git a/TuneBoss.Core.Tests/TestData.cs b/TuneBoss.Core.Tests/TestData.cs new file mode 100644 index 0000000..f939920 --- /dev/null +++ b/TuneBoss.Core.Tests/TestData.cs @@ -0,0 +1,46 @@ +using TuneBoss.Core.Models; + +namespace TuneBoss.Core.Tests; + +/// Shared builders for synthetic device data. +internal static class TestData +{ + public const byte Gen1 = 245, Gen2 = 1, Gen3 = 2; + + public static EcuInfo Ecu(byte appInfoVersion, byte fw, byte rpmMax = 130) => new() + { + Username = "SIM-RIDER", + UniqueId = "AABBCCDD-EEFF0011-22334455", + AppInfoVersion = appInfoVersion, + FwVersion = fw, + HwVersion = 10, + UpgradeRpmMax = rpmMax, + BikeManufacturer = 1, + }; + + /// Wraps a data block in the 4-byte response header the parsers skip (51 xx xx 00). + public static byte[] WithHeader(byte[] data, byte cmd = 0x43) + { + var p = new byte[4 + data.Length]; + p[0] = 0x51; p[1] = cmd; p[2] = (byte)data.Length; p[3] = 0x00; + Buffer.BlockCopy(data, 0, p, 4, data.Length); + return p; + } + + /// A valid 24-byte 1D block with chosen sign flags / multipliers. + public static byte[] OneDimWire( + byte[] axis, byte[] conv, + byte rawSigned = 0, byte convSigned = 0, + byte rawMult = 1, byte convMult = 1, + byte maxRaw = 255, byte minRaw = 0, byte rawRound = 0, sbyte convOffset = 0) + { + var d = new byte[OneDimTable.WireLength]; + Array.Copy(axis, 0, d, 0, 8); + Array.Copy(conv, 0, d, 8, 8); + d[16] = maxRaw; d[17] = minRaw; + d[18] = rawSigned; d[19] = convSigned; + d[20] = rawMult; d[21] = convMult; + d[22] = rawRound; d[23] = unchecked((byte)convOffset); + return d; + } +} diff --git a/TuneBoss.Core.Tests/TpsCalibrationTests.cs b/TuneBoss.Core.Tests/TpsCalibrationTests.cs new file mode 100644 index 0000000..f0b3252 --- /dev/null +++ b/TuneBoss.Core.Tests/TpsCalibrationTests.cs @@ -0,0 +1,82 @@ +using TuneBoss.Core.Models; +using TuneBoss.Core.Protocol; +using Xunit; + +namespace TuneBoss.Core.Tests; + +public class TpsCalibrationTests +{ + // ── Write payload ─────────────────────────────────────────────────────────── + [Fact] + public void CalWritePayload_matches_legacy_ramp() + { + var p = TpsCalibration.BuildCalWritePayload(10, 180); + Assert.Equal(new byte[] { 10, 180, 182, 184, 186, 188, 190, 192 }, p); + } + + [Fact] + public void CalWritePayload_wraps_high_max_into_byte() + { + // max+12 above 255 wraps (unchecked byte), matching the legacy (byte) cast. + var p = TpsCalibration.BuildCalWritePayload(8, 250); + Assert.Equal(8, p[0]); + Assert.Equal(250, p[1]); + Assert.Equal((byte)(250 + 12), p[7]); // 262 & 0xFF = 6 + } + + // ── Validation ────────────────────────────────────────────────────────────── + [Fact] + public void Validate_in_range_is_ok() + => Assert.Equal(TpsCalibration.Validation.Ok, + TpsCalibration.Validate(minRaw: 10, maxRaw: 188, absMin: 5, absMax: 195)); + + [Fact] + public void Validate_min_below_floor() + => Assert.Equal(TpsCalibration.Validation.MinBelowFloor, + TpsCalibration.Validate(minRaw: 3, maxRaw: 188, absMin: 5, absMax: 195)); + + [Fact] + public void Validate_max_above_ceiling() + => Assert.Equal(TpsCalibration.Validation.MaxAboveCeiling, + TpsCalibration.Validate(minRaw: 10, maxRaw: 200, absMin: 5, absMax: 195)); + + [Fact] + public void Validate_extreme_crossed_values() + => Assert.Equal(TpsCalibration.Validation.Extreme, + TpsCalibration.Validate(minRaw: 196, maxRaw: 196, absMin: 5, absMax: 195)); + + // ── Address resolution ────────────────────────────────────────────────────── + [Fact] + public void Gen3_uses_small_address_layout() + { + var a = TpsCalibration.For(GenerationType.Gen3, fwVersion: 193); + Assert.Equal(0x0078, a.CalWrite); + Assert.Equal(0x0088, a.AbsBounds); + Assert.Equal(0x0094, a.AdvSettings); + Assert.True(a.AdvSupported); // 193 >= 152 + } + + [Fact] + public void Gen3_below_152_has_no_advanced_settings() + => Assert.False(TpsCalibration.For(GenerationType.Gen3, 150).AdvSupported); + + [Fact] + public void Gen2_shares_gen3_addresses() + { + var g2 = TpsCalibration.For(GenerationType.Gen2, 100); + var g3 = TpsCalibration.For(GenerationType.Gen3, 100); + Assert.Equal(g3.CalWrite, g2.CalWrite); + Assert.Equal(g3.AbsBounds, g2.AbsBounds); + } + + [Fact] + public void Gen1_uses_legacy_high_addresses() + { + var a = TpsCalibration.For(GenerationType.Gen1, 70); + Assert.Equal(0x06FC, a.CalWrite); + Assert.False(a.AdvSupported); + } + + [Fact] + public void CalDoneFlag_is_one() => Assert.Equal(1, TpsCalibration.CalDoneFlag); +} diff --git a/TuneBoss.Core.Tests/TuneBoss.Core.Tests.csproj b/TuneBoss.Core.Tests/TuneBoss.Core.Tests.csproj new file mode 100644 index 0000000..9aea594 --- /dev/null +++ b/TuneBoss.Core.Tests/TuneBoss.Core.Tests.csproj @@ -0,0 +1,26 @@ + + + + net9.0 + enable + enable + false + true + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + + + diff --git a/TuneBoss.Core/BLE/BleManager.cs b/TuneBoss.Core/BLE/BleManager.cs new file mode 100644 index 0000000..8931ed9 --- /dev/null +++ b/TuneBoss.Core/BLE/BleManager.cs @@ -0,0 +1,668 @@ +using System.Collections.Concurrent; +using System.Reactive.Linq; +using System.Reactive.Subjects; +using Windows.Devices.Bluetooth; +using Windows.Devices.Bluetooth.Advertisement; +using Windows.Devices.Bluetooth.GenericAttributeProfile; +using Windows.Storage.Streams; +using TuneBoss.Core.Models; +using TuneBoss.Core.Protocol; +using System.Runtime.InteropServices.WindowsRuntime; + +namespace TuneBoss.Core.BLE; + +/// +/// Windows WinRT BLE implementation of IBleService. +/// Uses Nordic UART Service (NUS) over a single bidirectional characteristic. +/// +public sealed class BleManager : IBleService +{ + // ── NUS UUIDs ──────────────────────────────────────────────────────────── + private static readonly Guid NusServiceUuid = new("0000f0f0-0000-1000-8000-00805f9b34fb"); + private static readonly Guid NusCharUuid = new("0000f0f1-0000-1000-8000-00805f9b34fb"); + + // ── Config ─────────────────────────────────────────────────────────────── + private const int CommandTimeoutMs = 3000; // 3s default timeout + private const int SilenceWindowMs = 300; // diag silence detection window + private const int MaxSilenceWaitMs = 5000; // max wait for diagnostics drain + private const int KeepaliveIdleMs = 15000; // send keepalive after 15s idle + + // ── GATT resources ─────────────────────────────────────────────────────── + private BluetoothLEDevice? _device; + private GattDeviceService? _nusService; + private GattCharacteristic? _nusChar; + + // ── State ──────────────────────────────────────────────────────────────── + private BleConnectionState _connectionState = BleConnectionState.Disconnected; + private GenerationConfig? _genConfig; + private byte _seqNum = 1; + + // ── Rx processing ──────────────────────────────────────────────────────── + private readonly ConcurrentQueue _bleQueue = new(); + private readonly SemaphoreSlim _bleSignal = new(0); + private CancellationTokenSource? _loopCts; + + // ── Packet parser state ────────────────────────────────────────────────── + private readonly PacketParser _parser; + + // ── Response rendezvous ────────────────────────────────────────────────── + // The BLE receive loop sets this when a non-streaming packet arrives. + private readonly SemaphoreSlim _responseReady = new(0); + private volatile byte[]? _responsePayload; + private readonly object _responseLock = new(); + + // ── Diagnostics ────────────────────────────────────────────────────────── + private readonly Subject _diagSubject = new(); + private volatile bool _diagnosticsRunning; + private long _lastDiagTickUtc; + + // ── Observables ────────────────────────────────────────────────────────── + private readonly BehaviorSubject _connSubject = + new(BleConnectionState.Disconnected); + + private readonly Subject _scanSubject = new(); + private BluetoothLEAdvertisementWatcher? _watcher; + + // ── Keepalive ──────────────────────────────────────────────────────────── + private long _lastCommandTickUtc; + + // ──────────────────────────────────────────────────────────────────────── + // Constructor + // ──────────────────────────────────────────────────────────────────────── + public BleManager() + { + _parser = new PacketParser(OnFullPacketReceived); + } + + // ── IBleService: State ─────────────────────────────────────────────────── + public BleConnectionState ConnectionState => _connectionState; + public bool IsConnected => _connectionState == BleConnectionState.Connected; + public IObservable ConnectionStateChanged => _connSubject.AsObservable(); + public IObservable DiagnosticsFrames => _diagSubject.AsObservable(); + public bool DiagnosticsRunning => _diagnosticsRunning; + + // ──────────────────────────────────────────────────────────────────────── + // SCANNING + // ──────────────────────────────────────────────────────────────────────── + public IObservable StartScan() + { + var seen = new Dictionary(); + + _watcher = new BluetoothLEAdvertisementWatcher + { + ScanningMode = BluetoothLEScanningMode.Active + }; + _watcher.SignalStrengthFilter.InRangeThresholdInDBm = -127; + _watcher.SignalStrengthFilter.OutOfRangeThresholdInDBm = -127; + _watcher.SignalStrengthFilter.OutOfRangeTimeout = null; + + _watcher.Received += (_, args) => + { + ulong addr = args.BluetoothAddress; + string name = args.Advertisement.LocalName?.Trim() ?? string.Empty; + bool hasName = !string.IsNullOrWhiteSpace(name); + + lock (seen) + { + if (!seen.ContainsKey(addr)) + { + seen[addr] = hasName ? name : $"Unknown [{new BleDeviceInfo(addr, "", 0).MacAddress}]"; + _scanSubject.OnNext(new BleDeviceInfo(addr, seen[addr], args.RawSignalStrengthInDBm)); + } + else if (hasName && seen[addr].StartsWith("Unknown")) + { + seen[addr] = name; + _scanSubject.OnNext(new BleDeviceInfo(addr, name, args.RawSignalStrengthInDBm)); + } + } + }; + + _watcher.Start(); + return _scanSubject.AsObservable(); + } + + public void StopScan() + { + _watcher?.Stop(); + _watcher = null; + } + + // ──────────────────────────────────────────────────────────────────────── + // CONNECTION + // ──────────────────────────────────────────────────────────────────────── + public async Task ConnectAsync(BleDeviceInfo device, CancellationToken ct = default) + { + SetState(BleConnectionState.Connecting); + + try + { + // Step 1: Resolve device + _device = await BluetoothLEDevice.FromBluetoothAddressAsync(device.Address); + if (_device == null) return Fail("Could not resolve device from address."); + + _device.ConnectionStatusChanged += OnDeviceConnectionStatusChanged; + + // Step 2: Open GATT channel with retry + if (!await OpenGattChannelAsync(ct)) return Fail("Could not open GATT channel."); + + // Step 3: Stabilize + await Task.Delay(1500, ct); + + // Step 4: Get NUS service + _nusService = await GetServiceAsync(NusServiceUuid, ct); + if (_nusService == null) return Fail("NUS service not found."); + + // Step 5: Get characteristic + _nusChar = await GetCharacteristicAsync(_nusService, NusCharUuid, ct); + if (_nusChar == null) return Fail("NUS characteristic not found."); + + // Step 6: Enable notifications + _nusChar.ValueChanged += OnCharValueChanged; + await _nusChar.WriteClientCharacteristicConfigurationDescriptorAsync( + GattClientCharacteristicConfigurationDescriptorValue.Notify); + + // Step 7: Start BLE processing loop + StartProcessingLoop(); + + SetState(BleConnectionState.Connected); + return true; + } + catch (OperationCanceledException) { return Fail("Connection cancelled."); } + catch (Exception ex) { return Fail($"Connection error: {ex.Message}"); } + } + + public async Task DisconnectAsync() + { + SetState(BleConnectionState.Disconnecting); + + if (_diagnosticsRunning) + await StopDiagnosticsAsync(); + + StopProcessingLoop(); + + if (_nusChar != null) + { + _nusChar.ValueChanged -= OnCharValueChanged; + try { await _nusChar.WriteClientCharacteristicConfigurationDescriptorAsync( + GattClientCharacteristicConfigurationDescriptorValue.None); } catch { } + } + + _nusChar = null; + _nusService?.Dispose(); + _nusService = null; + + if (_device != null) + { + _device.ConnectionStatusChanged -= OnDeviceConnectionStatusChanged; + _device.Dispose(); + _device = null; + } + + SetState(BleConnectionState.Disconnected); + } + + // ──────────────────────────────────────────────────────────────────────── + // DEVICE INFO + // ──────────────────────────────────────────────────────────────────────── + public async Task ReadEcuInfoAsync(CancellationToken ct = default) + { + var frame = PacketBuilder.BuildReadInfo(NextSeq()); + var result = await SendAndWaitAsync(frame, ct); + if (!result.Success) return null; + + var info = EcuInfo.Parse(result.Payload); + + // Store generation config for subsequent table operations + var gen = GenerationConfig.ResolveGeneration(info.AppInfoVersion); + _genConfig = GenerationConfig.For(gen); + + return info; + } + + // ──────────────────────────────────────────────────────────────────────── + // AUTH + // ──────────────────────────────────────────────────────────────────────── + public async Task UnlockAsync(string password, CancellationToken ct = default) + { + var payload = BuildUnlockPayload(_genConfig?.UnlockCmd ?? Commands.APP_UNLOCK, password, isReset: false); + var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload); + return await SendAndWaitAsync(frame, ct); + } + + public async Task UnlockTunerAsync(string password, CancellationToken ct = default) + { + var payload = BuildUnlockPayload(Commands.APP_UNLOCK_TUNER, password, isReset: false); + var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload); + return await SendAndWaitAsync(frame, ct); + } + + // ──────────────────────────────────────────────────────────────────────── + // TABLE OPERATIONS + // ──────────────────────────────────────────────────────────────────────── + public Task ReadTable2DAsync(ushort address, byte lengthBytes, bool userTable = false, CancellationToken ct = default) + => ReadTableAsync( + userTable ? (_genConfig?.ReadCmd2DUser ?? Commands.APP_MEMRD_2D_USER) + : (_genConfig?.ReadCmd2D ?? Commands.APP_MEMRD_2D), + address, lengthBytes, ct); + + public Task WriteTable2DAsync(ushort address, byte[] data, bool userTable = false, CancellationToken ct = default) + => WriteTableAsync( + userTable ? (_genConfig?.WriteCmd2DUser ?? Commands.APP_MEMWR_2D_USER) + : (_genConfig?.WriteCmd2D ?? Commands.APP_MEMWR_2D), + address, data, ct); + + public Task ReadTable1DAsync(ushort address, byte lengthBytes, CancellationToken ct = default) + => ReadTableAsync(_genConfig?.ReadCmd1D ?? Commands.APP_MEMRD_1D, address, lengthBytes, ct); + + public Task WriteTable1DAsync(ushort address, byte[] data, CancellationToken ct = default) + => WriteTableAsync(_genConfig?.WriteCmd1D ?? Commands.APP_MEMWR_1D, address, data, ct); + + public Task ReadSubTableAsync(ushort address, CancellationToken ct = default) + => ReadTableAsync(_genConfig?.ReadCmdSubT ?? Commands.APP_MEMRD_SUBT, address, + (byte)TuneBoss.Core.Models.SubTable.TotalBytes, ct); + + public Task WriteSubTableAsync(ushort address, byte[] data, CancellationToken ct = default) + => WriteTableAsync(_genConfig?.WriteCmdSubT ?? Commands.APP_MEMWR_SUBT, address, data, ct); + + public Task ReadMiscAsync(ushort address, byte lengthBytes, CancellationToken ct = default) + => ReadTableAsync(_genConfig?.ReadCmdMisc ?? Commands.APP_MEMRD_MISC, address, lengthBytes, ct); + + public Task WriteMiscAsync(ushort address, byte[] data, CancellationToken ct = default) + => WriteTableAsync(_genConfig?.WriteCmdMisc ?? Commands.APP_MEMWR_MISC, address, data, ct); + + // ──────────────────────────────────────────────────────────────────────── + // FLASH WRITE + // ──────────────────────────────────────────────────────────────────────── + public async Task FlashWriteAsync(CancellationToken ct = default) + { + await StopDiagnosticsIfRunningAsync(ct); + + var now = DateTime.Now; + var payload = new byte[] + { + Commands.APP_FLASH_WR, + (byte)'F', (byte)'S', (byte)'R', + (byte)now.Day, + (byte)now.Month, + (byte)(now.Year % 100), + 0x00 + }; + var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload); + var result = await SendAndWaitAsync(frame, ct); + + await RestartDiagnosticsIfStoppedAsync(ct); + return result; + } + + // ──────────────────────────────────────────────────────────────────────── + // FIRST-USE SETTINGS (APP_FIRSTUSE) + // ──────────────────────────────────────────────────────────────────────── + public async Task WriteFirstUseAsync(byte[] fourBytes, CancellationToken ct = default) + { + if (fourBytes is null || fourBytes.Length < 4) + return CommandResult.Fail(0x00, "First-use payload must be 4 bytes."); + + // Legacy updateFirstUseSettings layout: [APP_FIRSTUSE, 0x00, 0x00, 0x00, b0, b1, b2, b3] + var payload = new byte[] + { + Commands.APP_FIRSTUSE, 0x00, 0x00, 0x00, + fourBytes[0], fourBytes[1], fourBytes[2], fourBytes[3], + }; + var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload); + return await SendAndWaitAsync(frame, ct); + } + + // ──────────────────────────────────────────────────────────────────────── + // DIAGNOSTICS + // ──────────────────────────────────────────────────────────────────────── + public async Task StartDiagnosticsAsync(CancellationToken ct = default) + { + if (_diagnosticsRunning) return; + _diagnosticsRunning = true; + Interlocked.Exchange(ref _lastDiagTickUtc, DateTime.UtcNow.Ticks); + await SendRawAsync(PacketBuilder.BuildMonStart()); + } + + public async Task StopDiagnosticsAsync(CancellationToken ct = default) + { + if (!_diagnosticsRunning) return; + _diagnosticsRunning = false; + + await SendRawAsync(PacketBuilder.BuildMonStop()); + + // Wait for silence — device keeps sending 0x70s for a while after STOP + Interlocked.Exchange(ref _lastDiagTickUtc, DateTime.UtcNow.Ticks); + int waited = 0; + while (waited < MaxSilenceWaitMs) + { + await Task.Delay(100, ct); + waited += 100; + long elapsed = (DateTime.UtcNow.Ticks - Interlocked.Read(ref _lastDiagTickUtc)) + / TimeSpan.TicksPerMillisecond; + if (elapsed >= SilenceWindowMs) break; + } + + // Flush residual 0x70 packets + _parser.Reset(); + while (_bleQueue.TryDequeue(out byte[]? _)) { } + } + + // ──────────────────────────────────────────────────────────────────────── + // KEEPALIVE + // ──────────────────────────────────────────────────────────────────────── + public void OnKeepaliveTimer() + { + if (!IsConnected) return; + long idleMs = (DateTime.UtcNow.Ticks - Interlocked.Read(ref _lastCommandTickUtc)) + / TimeSpan.TicksPerMillisecond; + if (idleMs >= KeepaliveIdleMs) + _ = SendRawAsync(PacketBuilder.BuildReadInfo(NextSeq())); + } + + // ──────────────────────────────────────────────────────────────────────── + // PRIVATE: Table helpers + // ──────────────────────────────────────────────────────────────────────── + private async Task ReadTableAsync( + byte cmd, ushort address, byte lengthBytes, CancellationToken ct) + { + await StopDiagnosticsIfRunningAsync(ct); + + var addrBytes = BitConverter.GetBytes(address); // little-endian + var payload = new byte[] { cmd, lengthBytes, addrBytes[0], addrBytes[1] }; + var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload); + + // Flush residual diagnostic packets before sending + _parser.Reset(); + while (_bleQueue.TryDequeue(out byte[]? _)) { } + + var result = await SendAndWaitAsync(frame, ct); + + await RestartDiagnosticsIfStoppedAsync(ct); + return result; + } + + private async Task WriteTableAsync( + byte cmd, ushort address, byte[] data, CancellationToken ct) + { + await StopDiagnosticsIfRunningAsync(ct); + + var addrBytes = BitConverter.GetBytes(address); + var payload = new byte[4 + data.Length]; + payload[0] = cmd; + // The length byte is the LAST inclusive offset the device writes (offset 0..N), + // exactly like the read commands — so N = data.Length - 1. Sending the raw count + // wrote one byte past the region and returned 0x54 (APP_MEMADDR_INV) — seen on the + // tightly-packed 1D tables and on 2D part-2 writes (100-byte tail region). + payload[1] = (byte)(data.Length - 1); + payload[2] = addrBytes[0]; + payload[3] = addrBytes[1]; + data.CopyTo(payload, 4); + + var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload); + var result = await SendAndWaitAsync(frame, ct); + + await RestartDiagnosticsIfStoppedAsync(ct); + return result; + } + + private async Task StopDiagnosticsIfRunningAsync(CancellationToken ct) + { + if (_diagnosticsRunning) + await StopDiagnosticsAsync(ct); + } + + private async Task RestartDiagnosticsIfStoppedAsync(CancellationToken ct) + { + // Intentionally does NOT auto-restart here. Resume is driven by the ViewModel + // layer (ResumeDiagnosticsIfLiveAsync) which knows whether the strip should be + // live. Restarting here as well caused a double MON_START and a frame storm that + // disrupted the next command's response matching (froze edits / writes). + } + + // ──────────────────────────────────────────────────────────────────────── + // PRIVATE: Send and wait for response + // ──────────────────────────────────────────────────────────────────────── + private async Task SendAndWaitAsync(byte[] frame, CancellationToken ct) + { + lock (_responseLock) + { + _responsePayload = null; + // drain any stale ready signal + while (_responseReady.CurrentCount > 0) + _responseReady.Wait(0); + } + + await SendRawAsync(frame); + Interlocked.Exchange(ref _lastCommandTickUtc, DateTime.UtcNow.Ticks); + + using var timeout = new CancellationTokenSource(CommandTimeoutMs); + using var linked = CancellationTokenSource.CreateLinkedTokenSource(ct, timeout.Token); + + try + { + await _responseReady.WaitAsync(linked.Token); + } + catch (OperationCanceledException) + { + return timeout.IsCancellationRequested + ? CommandResult.Timeout() + : CommandResult.Fail(0x00, "Cancelled"); + } + + var payload = _responsePayload; + if (payload == null || payload.Length == 0) + return CommandResult.Fail(0x00, "Empty response"); + + return payload[0] == 0x51 + ? CommandResult.Ok(payload) + : CommandResult.Fail(payload[0], $"Device returned 0x{payload[0]:X2}"); + } + + private async Task SendRawAsync(byte[] frame) + { + if (_nusChar == null) return; + + var writer = new DataWriter(); + writer.WriteBytes(frame); + + var writeOption = _nusChar.CharacteristicProperties + .HasFlag(GattCharacteristicProperties.WriteWithoutResponse) + ? GattWriteOption.WriteWithoutResponse + : GattWriteOption.WriteWithResponse; + + await _nusChar.WriteValueAsync(writer.DetachBuffer(), writeOption); + } + + // ──────────────────────────────────────────────────────────────────────── + // PRIVATE: BLE receive path + // ──────────────────────────────────────────────────────────────────────── + private void OnCharValueChanged(GattCharacteristic _, GattValueChangedEventArgs args) + { + try + { + var chunk = args.CharacteristicValue.ToArray(); + if (chunk.Length == 0) return; + _bleQueue.Enqueue(chunk); + _bleSignal.Release(); + } + catch { /* non-critical */ } + } + + private void StartProcessingLoop() + { + _loopCts = new CancellationTokenSource(); + var token = _loopCts.Token; + + Task.Run(async () => + { + while (!token.IsCancellationRequested) + { + await _bleSignal.WaitAsync(token); + + while (_bleQueue.TryDequeue(out byte[]? chunk)) + { + foreach (byte b in chunk) + _parser.ProcessByte(b); + } + } + }, token); + } + + private void StopProcessingLoop() + { + _loopCts?.Cancel(); + _loopCts?.Dispose(); + _loopCts = null; + } + + // ──────────────────────────────────────────────────────────────────────── + // PRIVATE: Packet dispatch + // ──────────────────────────────────────────────────────────────────────── + private void OnFullPacketReceived(PacketParser.ParsedPacket packet) + { + // ── Diagnostics frame ──────────────────────────────────────────────── + if (packet.TlResponse == Commands.APP_MONITORING) + { + + Interlocked.Exchange(ref _lastDiagTickUtc, DateTime.UtcNow.Ticks); + + if (_diagnosticsRunning) + { + try + { + var frame = DiagnosticsFrame.Parse(packet.Payload, packet.SeqNum, DateTime.UtcNow); + _diagSubject.OnNext(frame); + } + catch (Exception ex) + { + System.Diagnostics.Debug.WriteLine($"[DIAG] Parse error: {ex.Message}"); + } + } + return; + } + + // ── Non-posted response ────────────────────────────────────────────── + lock (_responseLock) + { + _responsePayload = packet.Payload; + } + _responseReady.Release(); + } + + // ──────────────────────────────────────────────────────────────────────── + // PRIVATE: GATT helpers + // ──────────────────────────────────────────────────────────────────────── + private async Task OpenGattChannelAsync(CancellationToken ct, int maxAttempts = 6) + { + for (int i = 1; i <= maxAttempts; i++) + { + try + { + var result = await _device!.GetGattServicesAsync(BluetoothCacheMode.Uncached); + if (result.Status == GattCommunicationStatus.Success) return true; + + if (result.Status == GattCommunicationStatus.AccessDenied) + await TrySilentPairAsync(); + } + catch { } + + if (i < maxAttempts) await Task.Delay(2000, ct); + } + return false; + } + + private async Task GetServiceAsync(Guid uuid, CancellationToken ct, int maxAttempts = 4) + { + for (int i = 1; i <= maxAttempts; i++) + { + var result = await _device!.GetGattServicesAsync(BluetoothCacheMode.Uncached); + if (result.Status == GattCommunicationStatus.Success) + { + var svc = result.Services.FirstOrDefault(s => s.Uuid == uuid); + if (svc != null) return svc; + } + if (i < maxAttempts) await Task.Delay(1500, ct); + } + return null; + } + + private async Task GetCharacteristicAsync( + GattDeviceService service, Guid uuid, CancellationToken ct, int maxAttempts = 3) + { + for (int i = 1; i <= maxAttempts; i++) + { + var result = await service.GetCharacteristicsForUuidAsync(uuid, BluetoothCacheMode.Uncached); + if (result.Status == GattCommunicationStatus.Success && result.Characteristics.Count > 0) + return result.Characteristics[0]; + if (i < maxAttempts) await Task.Delay(1000, ct); + } + return null; + } + + private async Task TrySilentPairAsync() + { + var pairing = _device!.DeviceInformation.Pairing; + if (pairing.IsPaired || !pairing.CanPair) return; + await pairing.PairAsync(Windows.Devices.Enumeration.DevicePairingProtectionLevel.None); + await Task.Delay(800); + } + + private void OnDeviceConnectionStatusChanged(BluetoothLEDevice sender, object _) + { + if (sender.ConnectionStatus == BluetoothConnectionStatus.Disconnected && IsConnected) + { + _diagnosticsRunning = false; + _parser.Reset(); + while (_bleQueue.TryDequeue(out byte[]? _)) { } + SetState(BleConnectionState.Disconnected); + } + } + + // ──────────────────────────────────────────────────────────────────────── + // PRIVATE: Misc helpers + // ──────────────────────────────────────────────────────────────────────── + private void SetState(BleConnectionState state) + { + _connectionState = state; + _connSubject.OnNext(state); + } + + private bool Fail(string _) { SetState(BleConnectionState.Disconnected); return false; } + + private byte NextSeq() => _seqNum == 0xFF ? (_seqNum = 1) : _seqNum++; + + private static byte[] BuildUnlockPayload(byte unlockCmd, string password, bool isReset) + { + var now = DateTime.Now; + var pwd = System.Text.Encoding.ASCII.GetBytes(password.Trim()); + var data = new List + { + unlockCmd, 0x00, 0x00, 0x00 + }; + + // 16-byte password field (null-padded) + for (int i = 0; i < 16; i++) + data.Add(i < pwd.Length ? pwd[i] : (byte)0x00); + + data.Add((byte)now.Day); + data.Add((byte)now.Month); + data.Add((byte)(now.Year % 100)); + data.Add(0x00); // reserved + + // Sentinel bytes matching original + data.AddRange(new byte[] { 0xF3, 0xF3, 0xF3, 0xF3 }); + + return data.ToArray(); + } + + public void Dispose() + { + StopProcessingLoop(); + _nusService?.Dispose(); + _device?.Dispose(); + _diagSubject.Dispose(); + _connSubject.Dispose(); + _responseReady.Dispose(); + _bleSignal.Dispose(); + } +} diff --git a/TuneBoss.Core/BLE/IBleService.cs b/TuneBoss.Core/BLE/IBleService.cs new file mode 100644 index 0000000..195585a --- /dev/null +++ b/TuneBoss.Core/BLE/IBleService.cs @@ -0,0 +1,196 @@ +using TuneBoss.Core.Models; +using TuneBoss.Core.Protocol; + +namespace TuneBoss.Core.BLE; + +/// +/// Represents a discovered BLE device before connection. +/// +public sealed record BleDeviceInfo( + ulong Address, + string Name, + short Rssi) +{ + public string MacAddress => FormatMac(Address); + + private static string FormatMac(ulong a) + { + var b = BitConverter.GetBytes(a); + return $"{b[5]:X2}:{b[4]:X2}:{b[3]:X2}:{b[2]:X2}:{b[1]:X2}:{b[0]:X2}"; + } + + public override string ToString() => $"{Name} | {MacAddress} | {Rssi} dBm"; +} + +/// +/// Connection state published to observers. +/// +public enum BleConnectionState +{ + Disconnected, + Connecting, + Connected, + Disconnecting, +} + +/// +/// Result of a command sent to the device. +/// +public sealed record CommandResult( + bool Success, + byte ResponseCode, // 0x51 = success, 0x52 = fail, etc. + byte[] Payload, + string? ErrorMessage = null) +{ + public static CommandResult Ok(byte[] payload) => + new(true, 0x51, payload); + + public static CommandResult Fail(byte responseCode, string message) => + new(false, responseCode, Array.Empty(), message); + + public static CommandResult Timeout() => + new(false, 0x00, Array.Empty(), "Command timed out"); +} + +/// +/// The primary BLE service contract. +/// All table and device operations go through this interface. +/// The UI layer never touches BLE APIs directly. +/// +public interface IBleService : IDisposable +{ + // ── State ──────────────────────────────────────────────────────────────── + + BleConnectionState ConnectionState { get; } + bool IsConnected { get; } + + /// Observable connection state changes. + IObservable ConnectionStateChanged { get; } + + // ── Scanning ───────────────────────────────────────────────────────────── + + /// Starts BLE advertisement scanning. Emits discovered devices. + IObservable StartScan(); + + /// Stops active scan. + void StopScan(); + + // ── Connection ─────────────────────────────────────────────────────────── + + /// + /// Connects to a device. Handles GATT channel opening, NUS service + /// discovery, notification subscription, and the post-connect APP_READ_INFO. + /// + Task ConnectAsync(BleDeviceInfo device, CancellationToken ct = default); + + /// Gracefully disconnects, stops diagnostics, cleans up GATT resources. + Task DisconnectAsync(); + + // ── Device info ────────────────────────────────────────────────────────── + + /// + /// Reads ECU info (APP_READ_INFO). Returns null on timeout or failure. + /// Also sets the active GenerationConfig internally. + /// + Task ReadEcuInfoAsync(CancellationToken ct = default); + + // ── Auth ───────────────────────────────────────────────────────────────── + + /// Sends unlock command with password and current date. + Task UnlockAsync(string password, CancellationToken ct = default); + + /// Sends tuner unlock command. + Task UnlockTunerAsync(string password, CancellationToken ct = default); + + // ── Table operations ───────────────────────────────────────────────────── + + /// + /// Reads a 2D table (split read: two halves, with diagnostics pause/resume). + /// Returns the raw combined payload. + /// + Task ReadTable2DAsync( + ushort address, + byte lengthBytes, + bool userTable = false, + CancellationToken ct = default); + + /// Writes a 2D table (split write). + Task WriteTable2DAsync( + ushort address, + byte[] data, + bool userTable = false, + CancellationToken ct = default); + + /// Reads a 1D table. + Task ReadTable1DAsync( + ushort address, + byte lengthBytes, + CancellationToken ct = default); + + /// Writes a 1D table. + Task WriteTable1DAsync( + ushort address, + byte[] data, + CancellationToken ct = default); + + /// Reads a subtable. + Task ReadSubTableAsync( + ushort address, + CancellationToken ct = default); + + /// Writes a subtable. + Task WriteSubTableAsync( + ushort address, + byte[] data, + CancellationToken ct = default); + + /// Reads misc values block. + Task ReadMiscAsync( + ushort address, + byte lengthBytes, + CancellationToken ct = default); + + /// Writes misc values block. + Task WriteMiscAsync( + ushort address, + byte[] data, + CancellationToken ct = default); + + // ── Flash ──────────────────────────────────────────────────────────────── + + /// Sends APP_FLASH_WR to persist all writes to ECU flash. + Task FlashWriteAsync(CancellationToken ct = default); + + /// + /// Writes the 4-byte first-use settings block via APP_FIRSTUSE (0x35). + /// Byte[0] (DD slot) carries the TPS-calibration-done flag. + /// + Task WriteFirstUseAsync(byte[] fourBytes, CancellationToken ct = default); + + // ── Diagnostics streaming ──────────────────────────────────────────────── + + /// + /// Observable stream of diagnostics frames (APP_MONITORING 0x70). + /// Emits continuously while diagnostics are running. + /// + IObservable DiagnosticsFrames { get; } + + bool DiagnosticsRunning { get; } + + /// Sends APP_MON_START and begins emitting DiagnosticsFrames. + Task StartDiagnosticsAsync(CancellationToken ct = default); + + /// + /// Sends APP_MON_STOP and waits for silence before returning. + /// Safe to call even if diagnostics aren't running. + /// + Task StopDiagnosticsAsync(CancellationToken ct = default); + + // ── Keepalive ──────────────────────────────────────────────────────────── + + /// + /// Called by the keepalive timer. Sends APP_READ_INFO if idle for > 15s. + /// Internally managed — exposed for test visibility only. + /// + void OnKeepaliveTimer(); +} diff --git a/TuneBoss.Core/BLE/PacketParser.cs b/TuneBoss.Core/BLE/PacketParser.cs new file mode 100644 index 0000000..d690497 --- /dev/null +++ b/TuneBoss.Core/BLE/PacketParser.cs @@ -0,0 +1,168 @@ +namespace TuneBoss.Core.BLE; + +/// +/// Stateful byte-stream parser for TuneBoss BLE packets. +/// Extracted from Form1_BLEhelper.cs ProcessByte() / OnFullPacketReceived(). +/// Thread-safe only when all calls are serialized (BLE processing loop does this). +/// +public sealed class PacketParser +{ + public sealed record ParsedPacket( + byte DlCommand, + byte SeqNum, + byte DwCount, + byte TlResponse, + byte TlCommand, + byte TlLength, + byte[] Payload); + + private readonly Action _onPacketReceived; + + // ── Parser state ───────────────────────────────────────────────────────── + private int _byteCycle; + private int _startSeqCycle; + private int _packetHeaderCycle; + private int _dWordByteTrack; + private int _dWordCheckSumTrack; + + private readonly byte[] _startSeq = new byte[4]; + private readonly byte[] _packetHeader = new byte[4]; + private readonly List _dataBuffer = new(); + private readonly List _csBuffer = new(); + + private byte _currDlCommand; + private byte _currDlSeqCount; + private byte _currDlDWordCount; + private byte _currTlResp; + private byte _currTlCommand; + private byte _currTlLength; + + public PacketParser(Action onPacketReceived) + { + _onPacketReceived = onPacketReceived; + } + + public void Reset() + { + _byteCycle = 0; + _startSeqCycle = 0; + _packetHeaderCycle = 0; + _dWordByteTrack = 0; + _dWordCheckSumTrack = 0; + _dataBuffer.Clear(); + _csBuffer.Clear(); + _currDlCommand = 0; + _currDlSeqCount = 0; + _currDlDWordCount = 0; + _currTlResp = 0; + _currTlCommand = 0; + _currTlLength = 0; + } + + public void ProcessByte(byte b) + { + // ── Zone 1: bytes 0–3 — preamble FF 00 FF 00 ───────────────────── + if (_byteCycle <= 3) + { + _startSeq[_startSeqCycle] = b; + + if (_startSeqCycle == 3) + { + bool valid = _startSeq[0] == 0xFF && _startSeq[1] == 0x00 + && _startSeq[2] == 0xFF && _startSeq[3] == 0x00; + if (!valid) { Reset(); return; } + } + + _startSeqCycle++; + _byteCycle++; + return; + } + + // ── Zone 2: bytes 4–7 — packet header ──────────────────────────── + if (_byteCycle <= 7) + { + _packetHeader[_packetHeaderCycle] = b; + + if (_packetHeaderCycle == 3) + { + if (!HeaderIntegrityOk(_packetHeader)) { Reset(); return; } + + _currDlCommand = _packetHeader[0]; + _currDlSeqCount = _packetHeader[1]; + _currDlDWordCount = _packetHeader[2]; + } + + _packetHeaderCycle++; + _byteCycle++; + return; + } + + // ── Zone 3: no payload ──────────────────────────────────────────── + if (_currDlDWordCount == 0) { Reset(); return; } + + // ── Zone 4: bytes 8–11 — TL header (first DWord of payload) ────── + if (_byteCycle <= 11) + { + switch (_byteCycle) + { + case 8: _currTlResp = b; break; + case 9: _currTlCommand = b; break; + case 10: _currTlLength = b; break; + } + + _dataBuffer.Add(b); + _byteCycle++; + return; + } + + // ── Zone 5: bytes 12+ — payload bytes + checksum ───────────────── + _byteCycle++; + + int payloadBytes = 4 * (_currDlDWordCount - 1); // DWords after the TL header + + if (_dWordByteTrack < payloadBytes) + { + _dataBuffer.Add(b); + _dWordByteTrack++; + } + else if (_dWordCheckSumTrack < 4) + { + _csBuffer.Add(b); + _dWordCheckSumTrack++; + + if (_dWordCheckSumTrack == 4) + OnFullPacketReceived(); + } + } + + private void OnFullPacketReceived() + { + byte[] data = _dataBuffer.ToArray(); + byte[] cs = _csBuffer.ToArray(); + + // Verify checksum + var expected = Protocol.ChecksumHelper.GenChecksumDW(data); + var receivedCs = (uint)(cs[0] | (cs[1] << 8) | (cs[2] << 16) | (cs[3] << 24)); + + if (expected != receivedCs) { Reset(); return; } + + var packet = new ParsedPacket( + DlCommand: _currDlCommand, + SeqNum: _currDlSeqCount, + DwCount: _currDlDWordCount, + TlResponse: _currTlResp, + TlCommand: _currTlCommand, + TlLength: _currTlLength, + Payload: data); + + Reset(); + _onPacketReceived(packet); + } + + private static bool HeaderIntegrityOk(byte[] h) + { + byte sum = unchecked((byte)(h[0] + h[1] + h[2])); + byte invSum = unchecked((byte)~sum); + return invSum == h[3]; + } +} diff --git a/TuneBoss.Core/BLE/SimBleService.cs b/TuneBoss.Core/BLE/SimBleService.cs new file mode 100644 index 0000000..a13c4e1 --- /dev/null +++ b/TuneBoss.Core/BLE/SimBleService.cs @@ -0,0 +1,368 @@ +using System.Reactive.Disposables; +using System.Reactive.Linq; +using System.Reactive.Subjects; +using TuneBoss.Core.Models; +using TuneBoss.Core.Protocol; + +namespace TuneBoss.Core.BLE; + +/// +/// A fully in-memory for hardware-free testing. +/// +/// • Scan/connect/unlock succeed instantly. +/// • Reads synthesize correctly-framed wire payloads (4-byte header, data at offset 4, +/// the device len+1 convention, and the 2D split-read halves) so every table, +/// misc block and 1D table populates in the real UI. +/// • Diagnostics stream a LIVE, moving RPM + load (sine sweep, ~20 Hz) so the 2D +/// tuning-table tracker visibly walks across the grid. The six gauge channels +/// move with it (MAP follows load, ETemp warms up, AFR wobbles, spark advances). +/// +/// Swap it in via DI (see the App.xaml.cs snippet in SimBleService_DI_README). +/// +public sealed class SimBleService : IBleService +{ + // ── Tunables (change before connecting to exercise different cases) ──────── + public byte SimAppInfoVersion { get; set; } = 2; // 2=Gen3, 1=Gen2, 245=Gen1 + public byte SimFwVersion { get; set; } = 193; // try 70 / 100 / 150 to see FW gating + public bool SimTpsCalibrated { get; set; } = false; // false => connect warns + jumps to TPS cal + public byte SimRpmMax { get; set; } = 130; // ×100 = 13000 rpm limit + public double SweepSeconds { get; set; } = 6.0; // one full idle→redline→idle cycle + public int EmitHz { get; set; } = 20; // diagnostics frames per second + + // ── Plumbing ────────────────────────────────────────────────────────────── + private readonly BehaviorSubject _state = new(BleConnectionState.Disconnected); + private readonly Subject _diag = new(); + private CancellationTokenSource? _diagCts; + private byte _seq; + private readonly Random _rng = new(1234); + + public BleConnectionState ConnectionState => _state.Value; + public bool IsConnected => _state.Value == BleConnectionState.Connected; + public IObservable ConnectionStateChanged => _state.AsObservable(); + + // ── Scan ────────────────────────────────────────────────────────────────── + public IObservable StartScan() => Observable.Create(o => + { + o.OnNext(new BleDeviceInfo(0xAABBCCDDEEFF, "B_SIM-PG1", -42)); + o.OnNext(new BleDeviceInfo(0x0011223344556, "B_SIM-R15", -57)); + return Disposable.Empty; // stay "scanning" (no completion) + }); + + public void StopScan() { } + + // ── Connect ─────────────────────────────────────────────────────────────── + public async Task ConnectAsync(BleDeviceInfo device, CancellationToken ct = default) + { + _state.OnNext(BleConnectionState.Connecting); + await Task.Delay(120, ct); + _state.OnNext(BleConnectionState.Connected); + + // Auto-start the live stream so the persistent gauge strip + table tracker + // come alive immediately. Idempotent — a later StartDiagnosticsAsync() is a no-op. + await StartDiagnosticsAsync(ct); + return true; + } + + public async Task DisconnectAsync() + { + await StopDiagnosticsAsync(); + _state.OnNext(BleConnectionState.Disconnecting); + _state.OnNext(BleConnectionState.Disconnected); + } + + // ── Device info ─────────────────────────────────────────────────────────── + public Task ReadEcuInfoAsync(CancellationToken ct = default) => + Task.FromResult(new EcuInfo + { + Username = "SIM-RIDER", + UniqueId = "51A0-0000-0000-0001", + AppInfoVersion = SimAppInfoVersion, + FwVersion = SimFwVersion, + HwVersion = 10, + UpgradeRpmMax = SimRpmMax, + BikeManufacturer = 1, // Yamaha + UpgradeLogImmo = 0x0F, // dual-injector unlocked + FirstUseInfo0 = SimTpsCalibrated ? TpsCalibration.CalDoneFlag : (byte)0, + }); + + // ── Auth ────────────────────────────────────────────────────────────────── + public Task UnlockAsync(string password, CancellationToken ct = default) + => Task.FromResult(CommandResult.Ok(Array.Empty())); + + public Task UnlockTunerAsync(string password, CancellationToken ct = default) + => Task.FromResult(CommandResult.Ok(Array.Empty())); + + // ── 2D tables (split read) ──────────────────────────────────────────────── + // The VM reads part 1 with len = SplitFirstLength (0x7F) at the base address, + // then part 2 (len = 100) at base+128. FromSplitResponses copies from offset 4 + // of each. We branch on the requested length. Tuning + AFR share this layout. + public Task ReadTable2DAsync(ushort address, byte lengthBytes, + bool userTable = false, CancellationToken ct = default) + { + var combined = Canonical2D(); // 228 bytes + const int firstCount = TuningTable.SplitFirstLength + 1; // 128 + + if (lengthBytes == TuningTable.SplitFirstLength) + return OkFramed(Slice(combined, 0, firstCount), Commands.APP_MEMRD_2D); + + int secondCount = TuningTable.TotalPayloadBytes - firstCount; // 100 + return OkFramed(Slice(combined, firstCount, secondCount), Commands.APP_MEMRD_2D); + } + + public Task WriteTable2DAsync(ushort address, byte[] data, + bool userTable = false, CancellationToken ct = default) + => Task.FromResult(CommandResult.Ok(data)); + + // ── 1D tables ───────────────────────────────────────────────────────────── + public Task ReadTable1DAsync(ushort address, byte lengthBytes, + CancellationToken ct = default) + { + // TPS absolute bounds live at a fixed address; return [max, min, ...] so the + // calibration page validates a full sweep successfully. + var addr = TpsCalibration.For((GenerationType)SimAppInfoVersion, SimFwVersion); + if (address == addr.AbsBounds) + return OkFramed(TpsAbsBounds(), Commands.APP_MEMRD_1D); + + return OkFramed(Canonical1D(), Commands.APP_MEMRD_1D); + } + + /// 8-byte TPS abs-bounds block: [absMax, absMin, store2, store3, ...]. + private static byte[] TpsAbsBounds() + => new byte[] { 195, 5, 197, 199, 201, 203, 205, 207 }; + + public Task WriteTable1DAsync(ushort address, byte[] data, + CancellationToken ct = default) + => Task.FromResult(CommandResult.Ok(data)); + + // ── Subtables ───────────────────────────────────────────────────────────── + public Task ReadSubTableAsync(ushort address, CancellationToken ct = default) + => OkFramed(CanonicalSub(), Commands.APP_MEMRD_SUBT); + + public Task WriteSubTableAsync(ushort address, byte[] data, + CancellationToken ct = default) + => Task.FromResult(CommandResult.Ok(data)); + + // ── Misc ────────────────────────────────────────────────────────────────── + public Task ReadMiscAsync(ushort address, byte lengthBytes, + CancellationToken ct = default) + => OkFramed(CanonicalMisc(lengthBytes), Commands.APP_MEMRD_MISC); + + public Task WriteMiscAsync(ushort address, byte[] data, + CancellationToken ct = default) + => Task.FromResult(CommandResult.Ok(data)); + + // ── Flash ───────────────────────────────────────────────────────────────── + public Task FlashWriteAsync(CancellationToken ct = default) + => Task.FromResult(CommandResult.Ok(Array.Empty())); + + // ── First-use settings ────────────────────────────────────────────────────── + public Task WriteFirstUseAsync(byte[] fourBytes, CancellationToken ct = default) + { + if (fourBytes is { Length: >= 1 }) + SimTpsCalibrated = fourBytes[0] == TpsCalibration.CalDoneFlag; + return Task.FromResult(CommandResult.Ok(Array.Empty())); + } + + // ── Diagnostics (the moving part) ───────────────────────────────────────── + public IObservable DiagnosticsFrames => _diag.AsObservable(); + public bool DiagnosticsRunning => _diagCts is not null; + + public Task StartDiagnosticsAsync(CancellationToken ct = default) + { + if (_diagCts is not null) return Task.CompletedTask; + _diagCts = new CancellationTokenSource(); + _ = RunDiagnosticsLoop(_diagCts.Token); + return Task.CompletedTask; + } + + public Task StopDiagnosticsAsync(CancellationToken ct = default) + { + _diagCts?.Cancel(); + _diagCts?.Dispose(); + _diagCts = null; + return Task.CompletedTask; + } + + public void OnKeepaliveTimer() { /* no-op in sim */ } + + private async Task RunDiagnosticsLoop(CancellationToken ct) + { + var period = TimeSpan.FromMilliseconds(1000.0 / Math.Max(1, EmitHz)); + using var timer = new PeriodicTimer(period); + var start = DateTime.UtcNow; + + // RPM raw sweep range — must sit inside the canonical RpmAxis (10..217) + const double rpmIdle = 12, rpmRedline = 205; + const double loadLo = 22, loadHi = 95; + + try + { + while (await timer.WaitForNextTickAsync(ct)) + { + double tSec = (DateTime.UtcNow - start).TotalSeconds; + double phase = tSec / Math.Max(0.5, SweepSeconds) * 2 * Math.PI; + double s = (Math.Sin(phase) + 1) / 2; // 0..1 + bool rising = Math.Cos(phase) >= 0; + + byte rpmRaw = (byte)Math.Round(rpmIdle + s * (rpmRedline - rpmIdle)); + byte load = (byte)Math.Round(loadLo + s * (loadHi - loadLo) + Noise(2)); + byte tps = (byte)Math.Clamp(Math.Round(s * 100 + Noise(2)), 0, 100); + byte map = (byte)Math.Clamp(load + Noise(2), 0, 255); + byte etemp = (byte)Math.Clamp(40 + tSec * 3, 40, 92); // warm-up ramp + byte afrx10 = (byte)Math.Clamp(Math.Round(145 + Noise(8)), 120, 170); + + _diag.OnNext(new DiagnosticsFrame + { + SeqNum = _seq++, + ReceivedAt = DateTime.UtcNow, + + // tracker channels + Load = load, + RPM_Raw = rpmRaw, + TPS_Percent = tps, + TPS_Raw = (byte)Math.Clamp(Math.Round(10 + s * 178), 0, 255), + + // gauges + Baro_kPa = 101, + Baro_Dynamic = 101, + VBAT_deciV = (byte)(138 - (int)(s * 6)), // sags under load + ETEMP_DegC = etemp, + IAT_DegC = 32, + MAP_kPa = map, + MAP_Lo_Avg = (byte)Math.Max(0, map - 4), + MAP_Hi_Avg_Raw = (byte)Math.Clamp(s * 120, 0, 255), // doubles as meter speed + O2_AFR_x10 = afrx10, + FuelStartAngle1_Raw = (byte)Math.Clamp(20 + s * 30, 0, 255), + FuelStartAngle2_Raw = (byte)Math.Clamp(20 + s * 30, 0, 255), + FuelPulseWidth1 = (int)(1500 + s * 6000), + FuelEndAngle = (int)(s * 360), + SparkAngle1 = (sbyte)Math.Clamp(5 + s * 30, -30, 60), + SparkAngle2 = (sbyte)Math.Clamp(5 + s * 30, -30, 60), + SparkPulseWidth = 25, + CrankSyncLostCounter = 0, + + // packed state bytes + CrankState_Raw = 0x06, // 6 = RUNNING (low nibble), TC_Mode 0 (high) + UMState_Packed = 0x33, // UMState 3 = RUN, gear 3 (high nibble) + ThrottleState_Packed = (byte)(rising ? 0x01 : 0x02), // Accel / Decel + RPMState_Packed = (byte)((rising ? 0x02 : 0x01) | 0x80), // Accel/Decel + StayTuned + + // no faults + ErrorsFatal = 0, + AnalogError_Current = 0, AnalogError_Persistent = 0, + OutputError_Current = 0, OutputError_Persistent = 0, + }); + } + } + catch (OperationCanceledException) { /* normal stop */ } + } + + private double Noise(double amp) => (_rng.NextDouble() - 0.5) * 2 * amp; + + // ── Canonical payloads ──────────────────────────────────────────────────── + + /// 228-byte 2D combined payload: smooth fuel surface, realistic axes. + private static byte[] Canonical2D() + { + var data = new byte[TuningTable.DataBytes]; // 24 cols × 8 rows + for (int r = 0; r < TuningTable.Rows; r++) + for (int c = 0; c < TuningTable.Cols; c++) + data[r * TuningTable.Cols + c] = (byte)Math.Clamp(30 + c * 8 + r * 3, 0, 255); + + var loadAxis = new byte[TuningTable.Rows]; + for (int r = 0; r < TuningTable.Rows; r++) loadAxis[r] = (byte)(20 + r * 10); // 20..90 + + var rpmAxis = new byte[TuningTable.Cols]; + for (int c = 0; c < TuningTable.Cols; c++) rpmAxis[c] = (byte)(10 + c * 9); // 10..217 (×100) + + var t = new TuningTable + { + Data = data, LoadAxis = loadAxis, RpmAxis = rpmAxis, + MaxRaw = 255, MinRaw = 0, Mult = 1, Sign = 0, + }; + return t.ToWirePayload(); // 228 bytes + } + + /// 24-byte 1D table: monotonic axis + ramp values, unscaled. + private static byte[] Canonical1D() + { + var t = new OneDimTable + { + MaxRaw = 255, MinRaw = 0, + RawSignedFlag = 0, ConvSignedFlag = 0, + RawMultiplier = 1, ConvMultiplier = 1, RawRounding = 0, ConvOffset = 0, + }; + for (int i = 0; i < OneDimTable.PointCount; i++) + { + t.RawAxis[i] = i * 10; // 0,10,...,70 + t.ConvValues[i] = 20 + i * 6; // gentle ramp + } + return t.ToWirePayload(); // 24 bytes + } + + /// 40-byte subtable body (4×6) with a monotonic RPM/load axis so it parses cleanly. + private static byte[] CanonicalSub() + { + var buf = new byte[SubTable.TotalBytes]; // 40 + for (int i = 0; i < SubTable.DataBytes; i++) buf[i] = (byte)(40 + i); + // load axis (4) + var lo = SubTable.DefaultLoadAxis; + for (int i = 0; i < SubTable.LoadBytes; i++) buf[SubTable.DataBytes + i] = lo[i]; + // rpm axis (12 = 6 lo/hi pairs) + for (int c = 0; c < SubTable.Cols; c++) + { + buf[SubTable.DataBytes + SubTable.LoadBytes + c * 2] = (byte)(15 + c * 20); + buf[SubTable.DataBytes + SubTable.LoadBytes + c * 2 + 1] = (byte)(20 + c * 20); + } + return buf; + } + + /// + /// Misc block sized for the request (returns len+1 bytes, mimicking the device + /// off-by-one). The 136-byte core block gets a few representative settings bytes + /// set so the bit-editors show real state. + /// + private byte[] CanonicalMisc(byte lengthBytes) + { + var data = new byte[lengthBytes + 1]; // device returns len+1 + + if (lengthBytes >= MemoryLayout.LenMiscCore) // core block (0x88 = 136) + { + data[8] = 131; // Crank_CamSync_Config + data[25] = 0x05; // Fuel_Settings2 (a couple of flags) + data[31] = 0x12; // Spark_Settings + data[33] = 0x01; // O2_Autotune_Enable + data[84] = 0x0F; // ShiftBoss_Enable = enable + both DIN bits + data[88] = 35; // ShiftBoss_Spark_Retard_deg + } + return data; + } + + // ── Framing helpers ─────────────────────────────────────────────────────── + private static byte[] Slice(byte[] src, int start, int count) + { + var b = new byte[count]; + Buffer.BlockCopy(src, start, b, 0, count); + return b; + } + + /// Wraps a data block in the 4-byte response header (51 cmd len 00). + private static Task OkFramed(byte[] data, byte cmd) + { + var buf = new byte[4 + data.Length]; + buf[0] = 0x51; + buf[1] = cmd; + buf[2] = (byte)data.Length; + buf[3] = 0x00; + Buffer.BlockCopy(data, 0, buf, 4, data.Length); + return Task.FromResult(CommandResult.Ok(buf)); + } + + public void Dispose() + { + _diagCts?.Cancel(); + _diagCts?.Dispose(); + _diag.Dispose(); + _state.Dispose(); + } +} diff --git a/TuneBoss.Core/Class1.cs b/TuneBoss.Core/Class1.cs new file mode 100644 index 0000000..f477816 --- /dev/null +++ b/TuneBoss.Core/Class1.cs @@ -0,0 +1,7 @@ +namespace TuneBoss.Core +{ + public class Class1 + { + + } +} diff --git a/TuneBoss.Core/IO/FsrFile.cs b/TuneBoss.Core/IO/FsrFile.cs new file mode 100644 index 0000000..16b226d --- /dev/null +++ b/TuneBoss.Core/IO/FsrFile.cs @@ -0,0 +1,470 @@ +using System.Globalization; +using System.Security.Cryptography; +using System.Text; +using TuneBoss.Core.Models; + +namespace TuneBoss.Core.IO; + +/// +/// Reader/writer for the TuneBoss .fsr configuration format (v1) — a +/// text-based, self-describing container for a full ECU tuning configuration. +/// See FSR_FORMAT_SPEC.md for the authoritative specification. +/// +/// This type is model-based and standalone: it (de)serialises the actual table +/// models, so it does not depend on the app's nav-tree/codec plumbing. +/// +public static class FsrFile +{ + public const int FormatVersion = 1; + + // ── Public data structures ────────────────────────────────────────────── + + public sealed class FsrDocument + { + public FsrHeader Header { get; set; } = new(); + public List Sections { get; } = new(); + + public FsrSection? Find(string name) => + Sections.FirstOrDefault(s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase)); + } + + public sealed class FsrHeader + { + public int FsrVersion { get; set; } = FormatVersion; + public string Generator { get; set; } = ""; + public string CreatedUtc { get; set; } = ""; + public string CreatorId { get; set; } = ""; + public int FwVersion { get; set; } + public int HwVersion { get; set; } + public int Make { get; set; } + public int Model { get; set; } + public int Cylinders { get; set; } = 1; + public int Generation { get; set; } = 3; + public string SaveType { get; set; } = "full_config"; + public string Note { get; set; } = "none"; + // Modification tags + public string ModEngineBlock { get; set; } = "none"; + public string ModCamshaft { get; set; } = "none"; + public string ModExhaust { get; set; } = "none"; + public string ModAirFilter { get; set; } = "none"; + public string ModCylinderHead { get; set; } = "none"; + public string ModInjector { get; set; } = "none"; + public string ModThrottleBody { get; set; } = "none"; + public string ModJackRod { get; set; } = "none"; + /// Any header keys not recognised — preserved on round-trip. + public Dictionary Extra { get; } = new(StringComparer.OrdinalIgnoreCase); + } + + public enum SectionType { Table2D, Table1D, SubTable, Afr, Misc, Unknown } + + public sealed class FsrSection + { + public SectionType Type { get; set; } + public string TypeToken { get; set; } = ""; // raw token, preserves Unknown + public string Name { get; set; } = ""; // stable feature key + public string Label { get; set; } = ""; + public ushort Addr { get; set; } + public byte Length { get; set; } // last-inclusive-offset (bytes-1) + public int Gen { get; set; } + + // Exactly one of these is populated depending on Type. + public TuningTable? Table2D { get; set; } + public AfrTable? Afr { get; set; } + public OneDimTable? Table1D { get; set; } + public SubTable? Sub { get; set; } + public byte[]? MiscBytes { get; set; } + + /// Raw field lines for Unknown sections / unrecognised keys. + public Dictionary Extra { get; } = new(StringComparer.OrdinalIgnoreCase); + } + + // ════════════════════════════════════════════════════════════════════════ + // WRITE + // ════════════════════════════════════════════════════════════════════════ + + /// Serialises a document to .fsr text (with an optional whole-body sha256). + public static string Write(FsrDocument doc, bool includeSha256 = true) + { + var body = new StringBuilder(); + WriteHeader(body, doc.Header); + body.Append('\n'); + foreach (var s in doc.Sections) + WriteSection(body, s); + + if (!includeSha256) + return body.ToString(); + + // sha256 covers everything after the sha256 line — write header line first. + string bodyText = body.ToString(); + string hash = Sha256Hex(bodyText); + return $"# integrity\nsha256 = {hash}\n{bodyText}"; + } + + private static void WriteHeader(StringBuilder sb, FsrHeader h) + { + sb.Append("# TuneBoss configuration — .fsr v").Append(h.FsrVersion).Append('\n'); + void F(string k, object v) => sb.Append(k).Append(" = ").Append(v).Append('\n'); + F("fsr_version", h.FsrVersion); + if (!string.IsNullOrEmpty(h.Generator)) F("generator", h.Generator); + if (!string.IsNullOrEmpty(h.CreatedUtc)) F("created_utc", h.CreatedUtc); + F("creator_id", h.CreatorId); + F("fw_version", h.FwVersion); + F("hw_version", h.HwVersion); + F("make", h.Make); + F("model", h.Model); + F("cylinders", h.Cylinders); + F("generation", h.Generation); + F("save_type", h.SaveType); + F("mod_engine_block", h.ModEngineBlock); + F("mod_camshaft", h.ModCamshaft); + F("mod_exhaust", h.ModExhaust); + F("mod_air_filter", h.ModAirFilter); + F("mod_cylinder_head", h.ModCylinderHead); + F("mod_injector", h.ModInjector); + F("mod_throttle_body", h.ModThrottleBody); + F("mod_jack_rod", h.ModJackRod); + F("note", h.Note); + foreach (var kv in h.Extra) F(kv.Key, kv.Value); + } + + private static void WriteSection(StringBuilder sb, FsrSection s) + { + string typeToken = s.Type switch + { + SectionType.Table2D => "TABLE2D", + SectionType.Afr => "AFR", + SectionType.Table1D => "TABLE1D", + SectionType.SubTable => "SUBTABLE", + SectionType.Misc => "MISC", + _ => s.TypeToken, + }; + sb.Append('[').Append(typeToken).Append(' ').Append(s.Name).Append("]\n"); + void F(string k, object v) => sb.Append(k).Append(" = ").Append(v).Append('\n'); + F("label", s.Label); + F("addr", Hex16(s.Addr)); + F("length", Hex8(s.Length)); + if (s.Gen != 0) F("gen", s.Gen); + + switch (s.Type) + { + case SectionType.Table2D when s.Table2D is { } t: Write2D(sb, t.Data, t.RpmAxis, t.LoadAxis, t.Sign, t.MaxRaw, t.MinRaw, t.Mult); break; + case SectionType.Afr when s.Afr is { } a: Write2D(sb, a.Data, a.RpmAxis, a.LoadAxis, a.Sign, a.MaxRaw, a.MinRaw, a.Mult); break; + case SectionType.Table1D when s.Table1D is { } o: Write1D(sb, o); break; + case SectionType.SubTable when s.Sub is { } sub: WriteSub(sb, sub); break; + case SectionType.Misc when s.MiscBytes is { } b: WriteBytes(sb, b); break; + default: + foreach (var kv in s.Extra) F(kv.Key, kv.Value); + break; + } + sb.Append('\n'); + } + + private static void Write2D(StringBuilder sb, byte[] data, byte[] rpm, byte[] load, byte sign, byte maxRaw, byte minRaw, byte mult) + { + sb.Append("signed = ").Append(sign > 0 ? 1 : 0).Append('\n'); + sb.Append("mult = ").Append(mult).Append('\n'); + sb.Append("max_raw = ").Append(maxRaw).Append('\n'); + sb.Append("min_raw = ").Append(minRaw).Append('\n'); + sb.Append("rpm_axis = ").Append(HexBytes(rpm)).Append('\n'); + sb.Append("load_axis = ").Append(HexBytes(load)).Append('\n'); + for (int r = 0; r < TuningTable.Rows; r++) + { + sb.Append("row").Append(r).Append(" = "); + for (int c = 0; c < TuningTable.Cols; c++) + { + if (c > 0) sb.Append(' '); + sb.Append(Hex8(data[r * TuningTable.Cols + c])); + } + sb.Append('\n'); + } + } + + private static void Write1D(StringBuilder sb, OneDimTable o) + { + sb.Append("raw_signed = ").Append(o.RawSignedFlag > 0 ? 1 : 0).Append('\n'); + sb.Append("conv_signed = ").Append(o.ConvSignedFlag > 0 ? 1 : 0).Append('\n'); + sb.Append("raw_mult = ").Append(o.RawMultiplier).Append('\n'); + sb.Append("conv_mult = ").Append(o.ConvMultiplier).Append('\n'); + sb.Append("raw_round = ").Append(o.RawRounding).Append('\n'); + sb.Append("conv_offset = ").Append((int)o.ConvOffset).Append('\n'); + sb.Append("max_raw = ").Append(o.MaxRaw).Append('\n'); + sb.Append("min_raw = ").Append(o.MinRaw).Append('\n'); + for (int i = 0; i < OneDimTable.PointCount; i++) + sb.Append('p').Append(i).Append(" = ").Append(o.RawAxis[i]).Append(", ").Append(o.ConvValues[i]).Append('\n'); + } + + private static void WriteSub(StringBuilder sb, SubTable sub) + { + for (int r = 0; r < SubTable.Rows; r++) + { + sb.Append("row").Append(r).Append(" = "); + for (int c = 0; c < SubTable.Cols; c++) + { + if (c > 0) sb.Append(", "); + sb.Append((int)unchecked((sbyte)sub.Data[r * SubTable.Cols + c])); + } + sb.Append('\n'); + } + } + + private static void WriteBytes(StringBuilder sb, byte[] bytes) + { + const int perLine = 32; + for (int off = 0; off < bytes.Length; off += perLine) + { + int n = Math.Min(perLine, bytes.Length - off); + sb.Append("bytes = "); + for (int i = 0; i < n; i++) + { + if (i > 0) sb.Append(' '); + sb.Append(Hex8(bytes[off + i])); + } + sb.Append('\n'); + } + } + + // ════════════════════════════════════════════════════════════════════════ + // READ + // ════════════════════════════════════════════════════════════════════════ + + public static FsrDocument Read(string text) + { + var doc = new FsrDocument(); + FsrSection? cur = null; + var secFields = new Dictionary(StringComparer.OrdinalIgnoreCase); + var rowLines = new List<(string key, string val)>(); + + void Flush() + { + if (cur == null) return; + BuildSection(cur, secFields, rowLines); + doc.Sections.Add(cur); + secFields = new(StringComparer.OrdinalIgnoreCase); + rowLines = new(); + } + + foreach (var raw in text.Split('\n')) + { + var line = raw.TrimEnd('\r'); + var t = line.TrimStart(); + if (t.Length == 0 || t[0] == '#') continue; + + if (t[0] == '[') + { + Flush(); + int close = t.IndexOf(']'); + var inner = (close > 0 ? t[1..close] : t[1..]).Trim(); + int sp = inner.IndexOf(' '); + string typeTok = sp > 0 ? inner[..sp] : inner; + string name = sp > 0 ? inner[(sp + 1)..].Trim() : ""; + cur = new FsrSection { TypeToken = typeTok, Type = ParseType(typeTok), Name = name }; + continue; + } + + int eq = line.IndexOf('='); + if (eq < 0) continue; + string key = line[..eq].Trim(); + string val = line[(eq + 1)..].Trim(); + + if (cur == null) { ApplyHeader(doc.Header, key, val); continue; } + + // Row-style keys accumulate (rowN, pN, bytes); everything else is a field. + if (IsRowKey(key)) rowLines.Add((key, val)); + else secFields[key] = val; + } + Flush(); + return doc; + } + + private static bool IsRowKey(string k) => + k.StartsWith("row", StringComparison.OrdinalIgnoreCase) || + (k.Length >= 2 && (k[0] == 'p' || k[0] == 'P') && char.IsDigit(k[1])) || + k.Equals("bytes", StringComparison.OrdinalIgnoreCase); + + private static SectionType ParseType(string tok) => tok.ToUpperInvariant() switch + { + "TABLE2D" => SectionType.Table2D, + "AFR" => SectionType.Afr, + "TABLE1D" => SectionType.Table1D, + "SUBTABLE" => SectionType.SubTable, + "MISC" => SectionType.Misc, + _ => SectionType.Unknown, + }; + + private static void ApplyHeader(FsrHeader h, string key, string val) + { + switch (key.ToLowerInvariant()) + { + case "fsr_version": h.FsrVersion = ParseInt(val); break; + case "generator": h.Generator = val; break; + case "created_utc": h.CreatedUtc = val; break; + case "creator_id": h.CreatorId = val; break; + case "fw_version": h.FwVersion = ParseInt(val); break; + case "hw_version": h.HwVersion = ParseInt(val); break; + case "make": h.Make = ParseInt(val); break; + case "model": h.Model = ParseInt(val); break; + case "cylinders": h.Cylinders = ParseInt(val); break; + case "generation": h.Generation = ParseInt(val); break; + case "save_type": h.SaveType = val; break; + case "note": h.Note = val; break; + case "mod_engine_block": h.ModEngineBlock = val; break; + case "mod_camshaft": h.ModCamshaft = val; break; + case "mod_exhaust": h.ModExhaust = val; break; + case "mod_air_filter": h.ModAirFilter = val; break; + case "mod_cylinder_head": h.ModCylinderHead = val; break; + case "mod_injector": h.ModInjector = val; break; + case "mod_throttle_body": h.ModThrottleBody = val; break; + case "mod_jack_rod": h.ModJackRod = val; break; + case "sha256": break; // integrity only; not structural + default: h.Extra[key] = val; break; // forward-compat + } + } + + private static void BuildSection(FsrSection s, Dictionary f, List<(string key, string val)> rows) + { + s.Label = f.GetValueOrDefault("label", s.Name); + s.Addr = (ushort)ParseInt(f.GetValueOrDefault("addr", "0")); + s.Length = (byte)ParseInt(f.GetValueOrDefault("length", "0")); + s.Gen = ParseInt(f.GetValueOrDefault("gen", "0")); + + switch (s.Type) + { + case SectionType.Table2D: s.Table2D = Build2D(f, rows); break; + case SectionType.Afr: s.Afr = BuildAfr(f, rows); break; + case SectionType.Table1D: s.Table1D = Build1D(f, rows); break; + case SectionType.SubTable:s.Sub = BuildSub(rows); break; + case SectionType.Misc: s.MiscBytes = BuildBytes(rows); break; + default: + foreach (var kv in f) s.Extra[kv.Key] = kv.Value; + break; + } + } + + private static (byte[] data, byte[] rpm, byte[] load, byte sign, byte maxRaw, byte minRaw, byte mult) Read2DCore( + Dictionary f, List<(string key, string val)> rows) + { + var rpm = ParseHexBytes(f.GetValueOrDefault("rpm_axis", "")); + var load = ParseHexBytes(f.GetValueOrDefault("load_axis", "")); + byte sign = (byte)(ParseInt(f.GetValueOrDefault("signed", "0")) > 0 ? 1 : 0); + byte maxRaw = (byte)ParseInt(f.GetValueOrDefault("max_raw", "0")); + byte minRaw = (byte)ParseInt(f.GetValueOrDefault("min_raw", "0")); + byte mult = (byte)ParseInt(f.GetValueOrDefault("mult", "1")); + var data = new byte[TuningTable.DataBytes]; + foreach (var (key, val) in rows) + { + if (!key.StartsWith("row", StringComparison.OrdinalIgnoreCase)) continue; + int r = ParseInt(key[3..]); + var cells = ParseHexBytes(val); + for (int c = 0; c < cells.Length && c < TuningTable.Cols; c++) + data[r * TuningTable.Cols + c] = cells[c]; + } + return (data, rpm, load, sign, maxRaw, minRaw, mult); + } + + private static TuningTable Build2D(Dictionary f, List<(string, string)> rows) + { + var (data, rpm, load, sign, maxRaw, minRaw, mult) = Read2DCore(f, rows); + return new TuningTable { Data = data, RpmAxis = rpm, LoadAxis = load, Sign = sign, MaxRaw = maxRaw, MinRaw = minRaw, Mult = mult }; + } + + private static AfrTable BuildAfr(Dictionary f, List<(string, string)> rows) + { + var (data, rpm, load, sign, maxRaw, minRaw, mult) = Read2DCore(f, rows); + return new AfrTable { Data = data, RpmAxis = rpm, LoadAxis = load, Sign = sign, MaxRaw = maxRaw, MinRaw = minRaw, Mult = mult }; + } + + private static OneDimTable Build1D(Dictionary f, List<(string key, string val)> rows) + { + var o = new OneDimTable + { + RawSignedFlag = (byte)(ParseInt(f.GetValueOrDefault("raw_signed", "0")) > 0 ? 1 : 0), + ConvSignedFlag = (byte)(ParseInt(f.GetValueOrDefault("conv_signed", "0")) > 0 ? 1 : 0), + RawMultiplier = (byte)ParseInt(f.GetValueOrDefault("raw_mult", "1")), + ConvMultiplier = (byte)ParseInt(f.GetValueOrDefault("conv_mult", "1")), + RawRounding = (byte)ParseInt(f.GetValueOrDefault("raw_round", "0")), + ConvOffset = (sbyte)ParseInt(f.GetValueOrDefault("conv_offset", "0")), + MaxRaw = ParseInt(f.GetValueOrDefault("max_raw", "0")), + MinRaw = ParseInt(f.GetValueOrDefault("min_raw", "0")), + }; + foreach (var (key, val) in rows) + { + if (key.Length < 2 || (key[0] != 'p' && key[0] != 'P')) continue; + int i = ParseInt(key[1..]); + if (i < 0 || i >= OneDimTable.PointCount) continue; + var parts = val.Split(','); + if (parts.Length >= 1) o.RawAxis[i] = ParseInt(parts[0].Trim()); + if (parts.Length >= 2) o.ConvValues[i] = ParseInt(parts[1].Trim()); + } + return o; + } + + private static SubTable BuildSub(List<(string key, string val)> rows) + { + var data = new byte[SubTable.DataBytes]; + foreach (var (key, val) in rows) + { + if (!key.StartsWith("row", StringComparison.OrdinalIgnoreCase)) continue; + int r = ParseInt(key[3..]); + var parts = val.Split(','); + for (int c = 0; c < parts.Length && c < SubTable.Cols; c++) + data[r * SubTable.Cols + c] = unchecked((byte)(sbyte)ParseInt(parts[c].Trim())); + } + return new SubTable { Data = data }; + } + + private static byte[] BuildBytes(List<(string key, string val)> rows) + { + var all = new List(); + foreach (var (key, val) in rows) + if (key.Equals("bytes", StringComparison.OrdinalIgnoreCase)) + all.AddRange(ParseHexBytes(val)); + return all.ToArray(); + } + + // ── Helpers ───────────────────────────────────────────────────────────── + + private static string Hex8(byte b) => "0x" + b.ToString("X2", CultureInfo.InvariantCulture); + private static string Hex16(ushort v) => "0x" + v.ToString("X4", CultureInfo.InvariantCulture); + + private static string HexBytes(byte[] bytes) + { + var sb = new StringBuilder(bytes.Length * 3); + for (int i = 0; i < bytes.Length; i++) + { + if (i > 0) sb.Append(' '); + sb.Append(bytes[i].ToString("X2", CultureInfo.InvariantCulture)); + } + return sb.ToString(); + } + + private static byte[] ParseHexBytes(string s) + { + if (string.IsNullOrWhiteSpace(s)) return Array.Empty(); + var toks = s.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); + var outp = new byte[toks.Length]; + for (int i = 0; i < toks.Length; i++) + { + var tok = toks[i]; + if (tok.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) tok = tok[2..]; + outp[i] = byte.Parse(tok, NumberStyles.HexNumber, CultureInfo.InvariantCulture); + } + return outp; + } + + private static int ParseInt(string s) + { + s = s.Trim(); + if (s.Length == 0) return 0; + if (s.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) + return int.Parse(s[2..], NumberStyles.HexNumber, CultureInfo.InvariantCulture); + return int.Parse(s, NumberStyles.Integer | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture); + } + + private static string Sha256Hex(string body) + { + var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(body)); + var sb = new StringBuilder(bytes.Length * 2); + foreach (var b in bytes) sb.Append(b.ToString("x2", CultureInfo.InvariantCulture)); + return sb.ToString(); + } +} diff --git a/TuneBoss.Core/IO/IMapTableCodec.cs b/TuneBoss.Core/IO/IMapTableCodec.cs new file mode 100644 index 0000000..790687c --- /dev/null +++ b/TuneBoss.Core/IO/IMapTableCodec.cs @@ -0,0 +1,54 @@ +using System.Threading.Tasks; +using TuneBoss.Core.Models; + +namespace TuneBoss.Core.IO; + +/// +/// Serializes / parses the data section of a map file — the space- and +/// __-delimited table dump. Kept behind an interface because its exact +/// table ordering is interop-critical and is filled once the format (legacy-exact +/// vs. new) and the included save-types are confirmed. +/// +/// Implementations live in the app layer, where they can read and write the +/// table view-models that hold the current ECU state. +/// +public interface IMapTableCodec +{ + /// + /// Ensures any device-backed state required to serialize the given type is loaded, + /// re-reading tables whose models are not cached. Called before + /// so a save works even if the user reached this page before a full table load + /// finished (or a table read was missed). Default: nothing to do. + /// + Task PrepareAsync(MapSaveType saveType, int cylinderCount) => Task.CompletedTask; + + /// Runs an on-hardware diagnostic of the user-table read path and returns a report. + Task DiagnoseAsync() => Task.FromResult(string.Empty); + + /// Serializes the current in-app table state into a map data section. + string Serialize(MapSaveType saveType, int cylinderCount); + + /// + /// Writes the currently-applied content for the given save type to the ECU, + /// optionally flashing at the end. Returns a human-readable summary. + /// + Task WriteLoadedAsync(MapSaveType saveType, int cylinderCount, bool flash, + IProgress? progress = null) + => throw new NotImplementedException("Write-to-ECU on load is not wired for this codec."); + + /// Parses a map data section and applies it to the in-app table state. + void Deserialize(string data, MapSaveType saveType, int cylinderCount); + + /// Rebuilds the editor nav trees from the current session layout + /// (used after an offline file establishes a layout, so entries exist to populate). + void RebuildNavTrees() { } + + /// + /// Builds an FSR document from the currently-loaded editors. Walks loaded entries + /// directly and skips anything not loaded (never throws "not loaded"). + /// + FsrFile.FsrDocument BuildFsrFromEditors(Models.EcuInfo? info, MapTag? tag, int cylinderCount); + + /// Applies a parsed FSR document into the editors. + void ApplyFsr(FsrFile.FsrDocument doc); +} diff --git a/TuneBoss.Core/IO/MapCompatibility.cs b/TuneBoss.Core/IO/MapCompatibility.cs new file mode 100644 index 0000000..724997f --- /dev/null +++ b/TuneBoss.Core/IO/MapCompatibility.cs @@ -0,0 +1,44 @@ +using TuneBoss.Core.Models; + +namespace TuneBoss.Core.IO; + +/// +/// Checks whether a loaded map's tag matches the connected ECU. Mirrors the legacy +/// open-time check, which warns (but doesn't hard-block) on make/model mismatch. +/// +public static class MapCompatibility +{ + public enum Result + { + Match, + ModelMismatch, + MakeMismatch, + CylinderMismatch, + } + + public readonly record struct Report(Result Result, string Message) + { + public bool IsMatch => Result == Result.Match; + } + + public static Report Check(MapTag tag, EcuInfo ecu, int connectedCylinders) + { + if (tag.Make != ecu.BikeManufacturer) + return new Report(Result.MakeMismatch, + $"This map is for {BikeRegistry.GetMake((byte)tag.Make)} but the connected unit is " + + $"{BikeRegistry.GetMake(ecu.BikeManufacturer)}. Loading it is not recommended."); + + if (tag.Model != ecu.BikeModel) + return new Report(Result.ModelMismatch, + $"This map is for {BikeRegistry.GetDisplayName((byte)tag.Make, tag.Model)} but the connected unit is " + + $"{BikeRegistry.GetDisplayName(ecu.BikeManufacturer, ecu.BikeModel)}. Loading it is not recommended."); + + if (connectedCylinders > 0 && tag.CylinderCount != connectedCylinders) + return new Report(Result.CylinderMismatch, + $"This map is for a {tag.CylinderCount}-cylinder layout but the connected unit is " + + $"{connectedCylinders}-cylinder."); + + return new Report(Result.Match, + $"Map matches the connected {BikeRegistry.GetDisplayName(ecu.BikeManufacturer, ecu.BikeModel)}."); + } +} diff --git a/TuneBoss.Core/IO/MapFile.cs b/TuneBoss.Core/IO/MapFile.cs new file mode 100644 index 0000000..f10fef8 --- /dev/null +++ b/TuneBoss.Core/IO/MapFile.cs @@ -0,0 +1,77 @@ +using System.Security.Cryptography; +using System.Text; + +namespace TuneBoss.Core.IO; + +/// +/// The on-disk envelope of a TuneBoss .tst map file: +/// +/// MD5(tag)_____tag\nMD5(data)_____data +/// +/// Two records separated by a newline; each record is MD5hex_____payload. +/// The MD5 is upper-case hex with no separators (matching the legacy +/// BitConverter.ToString(...).Replace("-","")). On load, both digests are +/// recomputed and must match or the file is rejected as corrupt/tampered. +/// +public static class MapFile +{ + public const string Extension = ".tst"; + public const string RecordSep = "_____"; + + /// Upper-case, separator-free MD5 hex of a UTF-8 string. + public static string Md5Hex(string s) + { + var hash = MD5.HashData(Encoding.UTF8.GetBytes(s)); + return Convert.ToHexString(hash); // upper-case, no separators + } + + /// Builds the full file text from a tag string and a data string. + public static string BuildEnvelope(string tag, string data) + => $"{Md5Hex(tag)}{RecordSep}{tag}\n{Md5Hex(data)}{RecordSep}{data}"; + + public readonly record struct ParseResult( + bool Ok, + string Tag, + string Data, + string? Error) + { + public static ParseResult Fail(string error) => new(false, "", "", error); + public static ParseResult Success(string tag, string data) => new(true, tag, data, null); + } + + /// + /// Parses and integrity-checks a file's full text. Splits on \r\n or + /// \n, separates each record on _____, and verifies both MD5s. + /// + public static ParseResult TryParse(string fileText) + { + if (string.IsNullOrEmpty(fileText)) + return ParseResult.Fail("File is empty."); + + var lines = fileText.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); + if (lines.Length < 2) + return ParseResult.Fail("File is not a valid TuneBoss map (missing data record)."); + + var tagRec = SplitOnce(lines[0]); + var dataRec = SplitOnce(lines[1]); + if (tagRec is null || dataRec is null) + return ParseResult.Fail("File is not a valid TuneBoss map (bad record format)."); + + var (tagHash, tag) = tagRec.Value; + var (dataHash, data) = dataRec.Value; + + if (!string.Equals(tagHash, Md5Hex(tag), StringComparison.OrdinalIgnoreCase)) + return ParseResult.Fail("Tag checksum mismatch — the file may be corrupt or edited."); + if (!string.Equals(dataHash, Md5Hex(data), StringComparison.OrdinalIgnoreCase)) + return ParseResult.Fail("Data checksum mismatch — the file may be corrupt or edited."); + + return ParseResult.Success(tag, data); + } + + private static (string Hash, string Payload)? SplitOnce(string record) + { + int i = record.IndexOf(RecordSep, StringComparison.Ordinal); + if (i < 0) return null; + return (record[..i], record[(i + RecordSep.Length)..]); + } +} diff --git a/TuneBoss.Core/IO/MapTableFormat.cs b/TuneBoss.Core/IO/MapTableFormat.cs new file mode 100644 index 0000000..8ac15e4 --- /dev/null +++ b/TuneBoss.Core/IO/MapTableFormat.cs @@ -0,0 +1,139 @@ +using System.Text; +using TuneBoss.Core.Models; + +namespace TuneBoss.Core.IO; + +/// +/// Byte-exact serializer / parser for the table sections inside a .tst map's +/// data string. Replicates the legacy helpers verbatim: +/// +/// 2D : label__data__load__rpm__max min mult sign ____ +/// AFR : label__data__load__rpm____ (no modifiers) +/// Sub : label__data____ (24 data bytes) +/// 1D : label__<24 wire bytes>____ +/// +/// Every value is its unsigned decimal followed by a single space; __ separates +/// fields within a section, ____ terminates each section. Subtable RPM axes are +/// not stored — on load they are derived from the parent 2D table's RPM axis (every +/// 4th breakpoint), matching legacy populateSubTable. +/// +public static class MapTableFormat +{ + public const string SectionSep = "____"; + public const string FieldSep = "__"; + + // ── Value lists ───────────────────────────────────────────────────────────── + private static string Bytes(byte[] a) + { + var sb = new StringBuilder(a.Length * 4); + foreach (var b in a) sb.Append((int)b).Append(' '); // "v v v " + return sb.ToString(); + } + + /// Parses a space-separated decimal list into bytes (empties skipped). + public static byte[] ParseBytes(string s) + { + var parts = s.Split(' ', StringSplitOptions.RemoveEmptyEntries); + var r = new byte[parts.Length]; + for (int i = 0; i < parts.Length; i++) + r[i] = (byte)(int.Parse(parts[i]) & 0xFF); + return r; + } + + // ── Serialize ─────────────────────────────────────────────────────────────── + public static string Section2D(string label, TuningTable t) => + label + FieldSep + Bytes(t.Data) + FieldSep + Bytes(t.LoadAxis) + FieldSep + Bytes(t.RpmAxis) + + FieldSep + $"{t.MaxRaw} {t.MinRaw} {t.Mult} {t.Sign} " + SectionSep; + + public static string SectionAfr(string label, AfrTable t) => + label + FieldSep + Bytes(t.Data) + FieldSep + Bytes(t.LoadAxis) + FieldSep + Bytes(t.RpmAxis) + SectionSep; + + public static string SectionSub(string label, SubTable t) => + label + FieldSep + Bytes(t.Data) + SectionSep; + + public static string Section1D(string label, OneDimTable t) => + label + FieldSep + Bytes(t.ToWirePayload()) + SectionSep; + + /// Generic named byte block (used for the misc regions). label__<bytes>____. + public static string SectionBytes(string label, byte[] data) => + label + FieldSep + Bytes(data) + SectionSep; + + /// Parses a block back into its raw bytes. + public static byte[] ParseBytesSection(string section) + { + var f = Fields(section); + return f.Length > 1 ? ParseBytes(f[1]) : Array.Empty(); + } + + // ── Section splitting ─────────────────────────────────────────────────────── + /// Splits a data string into its ____-terminated sections (positional). + public static string[] SplitSections(string data) => + data.Split(SectionSep, StringSplitOptions.None); + + private static string[] Fields(string section) => + section.Split(FieldSep, StringSplitOptions.None); + + /// The label of a section (its first field), for sanity checks. + public static string LabelOf(string section) => Fields(section)[0]; + + // ── Parse ─────────────────────────────────────────────────────────────────── + public static TuningTable Parse2D(string section) + { + var f = Fields(section); + var data = Fit(ParseBytes(f[1]), TuningTable.DataBytes); + var load = Fit(ParseBytes(f[2]), TuningTable.Rows); + var rpm = Fit(ParseBytes(f[3]), TuningTable.Cols); + var mod = ParseBytes(f.Length > 4 ? f[4] : ""); + return new TuningTable + { + Data = data, LoadAxis = load, RpmAxis = rpm, + MaxRaw = At(mod, 0), MinRaw = At(mod, 1), Mult = At(mod, 2), Sign = At(mod, 3), + }; + } + + public static AfrTable ParseAfr(string section) + { + var f = Fields(section); + return new AfrTable + { + Data = Fit(ParseBytes(f[1]), AfrTable.DataBytes), + LoadAxis = Fit(ParseBytes(f[2]), AfrTable.Rows), + RpmAxis = Fit(ParseBytes(f[3]), AfrTable.Cols), + }; + } + + /// + /// Parses a subtable section. The 12-byte RPM axis is derived from the parent 2D + /// table's 24-byte RPM axis: 6 (lo,hi) pairs taken from indices 4·x and 4·x+3. + /// + public static SubTable ParseSub(string section, byte[] parentRpm) + { + var f = Fields(section); + var sub = new SubTable { Data = Fit(ParseBytes(f[1]), SubTable.DataBytes) }; + for (int x = 0; x < SubTable.Cols; x++) + { + sub.RpmAxis[x * 2] = At(parentRpm, x * 4); + sub.RpmAxis[x * 2 + 1] = At(parentRpm, x * 4 + 3); + } + return sub; + } + + public static OneDimTable Parse1D(string section) + { + var f = Fields(section); + var wire = Fit(ParseBytes(f[1]), OneDimTable.WireLength); + return OneDimTable.FromWire(wire, 0); + } + + // ── Helpers ───────────────────────────────────────────────────────────────── + private static byte At(byte[] a, int i) => i < a.Length ? a[i] : (byte)0; + + /// Returns an array of exactly bytes (pad/truncate). + private static byte[] Fit(byte[] src, int n) + { + if (src.Length == n) return src; + var r = new byte[n]; + Array.Copy(src, r, Math.Min(src.Length, n)); + return r; + } +} diff --git a/TuneBoss.Core/IO/MapTag.cs b/TuneBoss.Core/IO/MapTag.cs new file mode 100644 index 0000000..5826216 --- /dev/null +++ b/TuneBoss.Core/IO/MapTag.cs @@ -0,0 +1,100 @@ +using System.Text; + +namespace TuneBoss.Core.IO; + +/// +/// Which tables a saved map contains. Values match the legacy save-type codes. +/// +public enum MapSaveType +{ + User = 1, // user adjust tables (+ their subtables) + FullTables = 2, // all base + user 2D tables, AFR, subtables, 1D + FullConfig = 4, // FullTables plus the misc / extended config blocks +} + +/// +/// The metadata header of a TuneBoss map file — the legacy "tag", 16 fields joined +/// by ___: +/// creatorID, FW, HW, make, model, cyl, saveType, +/// engineBlock, camshaft, exhaust, airFilter, cylinderHead, injector, throttleBody, jackRod, +/// miscNote +/// +/// The trailing note carries no separator; every other field is followed by ___. +/// +public sealed record MapTag +{ + public const string FieldSep = "___"; + public const int FieldCount = 16; + + public string CreatorId { get; init; } = ""; + public int FwVersion { get; init; } + public int HwVersion { get; init; } + public int Make { get; init; } + public int Model { get; init; } + public int CylinderCount { get; init; } = 1; + public MapSaveType SaveType { get; init; } = MapSaveType.FullConfig; + + public string EngineBlock { get; init; } = "none"; + public string Camshaft { get; init; } = "none"; + public string Exhaust { get; init; } = "none"; + public string AirFilter { get; init; } = "none"; + public string CylinderHead { get; init; } = "none"; + public string Injector { get; init; } = "none"; + public string ThrottleBody { get; init; } = "none"; + public string JackRod { get; init; } = "none"; + + public string MiscNote { get; init; } = "none"; + + /// Serializes to the ___-joined legacy string. + public string Build() + { + var sb = new StringBuilder(); + void F(string v) => sb.Append(v).Append(FieldSep); + + F(CreatorId); + F(FwVersion.ToString()); + F(HwVersion.ToString()); + F(Make.ToString()); + F(Model.ToString()); + F(CylinderCount.ToString()); + F(((int)SaveType).ToString()); + F(EngineBlock); + F(Camshaft); + F(Exhaust); + F(AirFilter); + F(CylinderHead); + F(Injector); + F(ThrottleBody); + F(JackRod); + sb.Append(MiscNote); // no trailing separator + return sb.ToString(); + } + + /// Parses a ___-joined tag string. Tolerates a short mod section. + public static MapTag Parse(string tag) + { + var f = tag.Split(FieldSep); + string At(int i) => i < f.Length ? f[i] : ""; + int AtInt(int i) => int.TryParse(At(i), out var v) ? v : 0; + + return new MapTag + { + CreatorId = At(0), + FwVersion = AtInt(1), + HwVersion = AtInt(2), + Make = AtInt(3), + Model = AtInt(4), + CylinderCount = AtInt(5) is var c && c > 0 ? c : 1, + SaveType = (MapSaveType)AtInt(6), + EngineBlock = At(7), + Camshaft = At(8), + Exhaust = At(9), + AirFilter = At(10), + CylinderHead = At(11), + Injector = At(12), + ThrottleBody = At(13), + JackRod = At(14), + MiscNote = At(15), + }; + } +} diff --git a/TuneBoss.Core/Models/AfrTable.cs b/TuneBoss.Core/Models/AfrTable.cs new file mode 100644 index 0000000..0eb753b --- /dev/null +++ b/TuneBoss.Core/Models/AfrTable.cs @@ -0,0 +1,221 @@ +namespace TuneBoss.Core.Models; + +/// +/// Data model for an AFR Target table (AFR_Target1, AFR_Target2). +/// +/// Structurally identical to TuningTable (24 cols × 8 rows, same split read/write, +/// same wire layout) but with a critical difference in value encoding: +/// +/// ── Fixed-point ×10 encoding ───────────────────────────────────────────────── +/// All cell values are stored as byte × 10 on the wire. +/// Wire byte 145 = AFR 14.5, byte 137 = AFR 13.7, etc. +/// Display range set by caller: minDataVal=0.0, maxDataVal=15.0 (from populateInitTables) +/// +/// ── Modifier encoding ───────────────────────────────────────────────────────── +/// MaxRaw / MinRaw are also stored ×10 on wire: +/// modifiersInArray[0] = (byte)(maxRawVal * 10.0) +/// modifiersInArray[1] = (byte)(minRawVal * 10.0) +/// modifiersInArray[2] = (byte)multRawVal (same as TuningTable) +/// modifiersInArray[3] = (byte)signRawVal (same as TuningTable) +/// Confirmed from writeBtn_Click and prepareAllData() in TuningTablePanelAFR.cs. +/// +/// ── Button increments ──────────────────────────────────────────────────────── +/// +/- large = 5.0 AFR (minusFive_Click / plusFive_Click) +/// +/- small = 0.1 AFR (minusOne_Click / plusOne_Click) ← different from TuningTable +/// Validated as double, displayed as "N1" (1 decimal place). +/// +/// ── Wire format ────────────────────────────────────────────────────────────── +/// Identical layout to TuningTable (228 bytes, split at 0x7F): +/// [0..191] Data — 192 bytes, row-major, each byte = AFR × 10 +/// [192..199] Load — 8 bytes +/// [200..223] RPM — 24 bytes, each × 100 = display RPM +/// [224] MaxRaw — stored as byte = maxAFR × 10 +/// [225] MinRaw — stored as byte = minAFR × 10 +/// [226] Mult +/// [227] Sign +/// +/// Read length from populateInitTables: 0xEF (239) — larger than TuningTable's 0xE3. +/// +public sealed record AfrTable +{ + public const int Cols = 24; + public const int Rows = 8; + public const int DataBytes = Cols * Rows; // 192 + public const int SplitFirstLength = 0x7F; // 127 — same as TuningTable + public const int TotalPayloadBytes = DataBytes + Rows + Cols + 4; // 228 + public const byte ReadLength = 0xEF; // 239 — from populateInitTables + + // ── Raw wire arrays ─────────────────────────────────────────────────────── + /// 192 bytes, row-major [row * 24 + col]. Wire value = AFR × 10. + public byte[] Data { get; init; } = new byte[DataBytes]; + + /// 8 bytes — load axis (0–110). + public byte[] LoadAxis { get; init; } = new byte[Rows]; + + /// 24 bytes — RPM axis, each × 100 = display RPM. + public byte[] RpmAxis { get; init; } = new byte[Cols]; + + // ── Modifiers [224–227] ─────────────────────────────────────────────────── + /// Wire: maxAFR × 10. E.g. byte 150 = AFR 15.0. + public byte MaxRaw { get; init; } + + /// Wire: minAFR × 10. E.g. byte 0 = AFR 0.0. + public byte MinRaw { get; init; } + + public byte Mult { get; init; } + public byte Sign { get; init; } + + // ── Derived display values ──────────────────────────────────────────────── + public bool IsSigned => Sign > 0; + + /// Display AFR value for a cell (wire byte ÷ 10.0). + public double GetCell(int row, int col) + { + byte raw = Data[row * Cols + col]; + return IsSigned + ? unchecked((sbyte)raw) / 10.0 + : raw / 10.0; + } + + /// Max AFR display value. + public double MaxAfrDisplay => IsSigned + ? unchecked((sbyte)MaxRaw) / 10.0 + : MaxRaw / 10.0; + + /// Min AFR display value. + public double MinAfrDisplay => IsSigned + ? unchecked((sbyte)MinRaw) / 10.0 + : MinRaw / 10.0; + + /// RPM axis in display units (raw × 100). + public int[] RpmValues => RpmAxis.Select(r => r * 100).ToArray(); + + /// Load axis values (raw, 0–110). + public int[] LoadValues => LoadAxis.Select(l => (int)l).ToArray(); + + // ── Serialisation ───────────────────────────────────────────────────────── + + /// + /// Builds the combined 228-byte write payload. + /// Matches prepareAllData() / writeBtn_Click() in TuningTablePanelAFR.cs. + /// Modifier bytes [224–225] are stored as AFR × 10. + /// + public byte[] ToWirePayload() + { + var buf = new byte[TotalPayloadBytes]; + Buffer.BlockCopy(Data, 0, buf, 0, DataBytes); + Buffer.BlockCopy(LoadAxis,0, buf, DataBytes, Rows); + Buffer.BlockCopy(RpmAxis, 0, buf, DataBytes + Rows, Cols); + buf[DataBytes + Rows + Cols] = MaxRaw; + buf[DataBytes + Rows + Cols + 1] = MinRaw; + buf[DataBytes + Rows + Cols + 2] = Mult; + buf[DataBytes + Rows + Cols + 3] = Sign; + return buf; + } + + public byte[] ToWirePayloadPart1() => ToWirePayload()[..(SplitFirstLength + 1)]; + public byte[] ToWirePayloadPart2() => ToWirePayload()[(SplitFirstLength + 1)..]; + + // ── Deserialisation ─────────────────────────────────────────────────────── + + /// + /// Parses a combined 228-byte buffer from two split read responses. + /// Matches sendReadSplitTableToPanelThread (AFR path) in Form1_TableHandling.cs. + /// + public static AfrTable FromWirePayload(byte[] combined) + { + if (combined.Length < TotalPayloadBytes) + throw new ArgumentException( + $"Expected {TotalPayloadBytes} bytes, got {combined.Length}.", nameof(combined)); + + var data = new byte[DataBytes]; + var loadAxis = new byte[Rows]; + var rpmAxis = new byte[Cols]; + + Buffer.BlockCopy(combined, 0, data, 0, DataBytes); + Buffer.BlockCopy(combined, DataBytes, loadAxis,0, Rows); + Buffer.BlockCopy(combined, DataBytes + Rows, rpmAxis, 0, Cols); + + int modBase = DataBytes + Rows + Cols; + return new AfrTable + { + Data = data, + LoadAxis = loadAxis, + RpmAxis = rpmAxis, + MaxRaw = combined[modBase], + MinRaw = combined[modBase + 1], + Mult = combined[modBase + 2], + Sign = combined[modBase + 3], + }; + } + + /// + /// Assembles from two raw device response buffers (data starts at offset 4). + /// + public static AfrTable FromSplitResponses(byte[] part1Response, byte[] part2Response) + { + var combined = new byte[TotalPayloadBytes]; + Buffer.BlockCopy(part1Response, 4, combined, 0, SplitFirstLength + 1); + int part2Len = TotalPayloadBytes - (SplitFirstLength + 1); + Buffer.BlockCopy(part2Response, 4, combined, SplitFirstLength + 1, part2Len); + return FromWirePayload(combined); + } + + // ── Mutation ────────────────────────────────────────────────────────────── + + /// + /// Returns a new AfrTable with cell (row, col) adjusted by delta (in AFR units, e.g. 0.1). + /// Delta is converted to wire units (×10) before clamping. + /// Matches minusButton/addButton in TuningTablePanelAFR.cs. + /// + public AfrTable WithCellAdjusted(int row, int col, double deltaAfr, + double minAfr = 0.0, double maxAfr = 15.0) + { + var newData = (byte[])Data.Clone(); + int idx = row * Cols + col; + + double current = GetCell(row, col); + double adjusted = Math.Clamp(current + deltaAfr, minAfr, maxAfr); + + // Round to 1 decimal place then encode ×10 + double rounded = Math.Round(adjusted, 1, MidpointRounding.AwayFromZero); + newData[idx] = IsSigned + ? unchecked((byte)(sbyte)(rounded * 10.0)) + : (byte)(rounded * 10.0); + + return new AfrTable + { + Data = newData, + LoadAxis = LoadAxis, + RpmAxis = RpmAxis, + MaxRaw = MaxRaw, + MinRaw = MinRaw, + Mult = Mult, + Sign = Sign, + }; + } + + // ── Convenience ────────────────────────────────────────────────────────── + + /// + /// Returns modifier bytes as stored on wire. + /// MaxRaw/MinRaw are AFR × 10; Mult/Sign are unchanged. + /// + public byte[] ToModifierBytes() => new[] + { + MaxRaw, MinRaw, Mult, Sign + }; + + /// + /// Builds modifier bytes from display AFR values for writing. + /// Matches: modifiersInArray[0] = (byte)(maxRawVal * 10.0) + /// + public static byte[] BuildModifierBytes(double maxAfr, double minAfr, + byte mult = 1, byte sign = 0) => new[] + { + (byte)(maxAfr * 10.0), + (byte)(minAfr * 10.0), + mult, + sign + }; +} diff --git a/TuneBoss.Core/Models/BikeRegistry.cs b/TuneBoss.Core/Models/BikeRegistry.cs new file mode 100644 index 0000000..7da05f5 --- /dev/null +++ b/TuneBoss.Core/Models/BikeRegistry.cs @@ -0,0 +1,109 @@ +namespace TuneBoss.Core.Models; + +/// +/// Bike manufacturer and model registry. +/// To add a new make: add a new entry to Manufacturers. +/// To add a new model: add a new entry to the Models list for that make. +/// +public static class BikeRegistry +{ + // ── Manufacturer codes ──────────────────────────────────────────────────── + public const byte Yamaha = 1; + public const byte Honda = 2; + public const byte Modenas = 5; + public const byte Suzuki = 6; + + // ── Registry ────────────────────────────────────────────────────────────── + private static readonly Dictionary Models)> _registry + = new() + { + [Yamaha] = ("Yamaha", new() + { + [1] = "FZ150i (2008–2013)", + [2] = "Lagenda 115z EFi", + [3] = "FZ150i (2014)", + [4] = "YZF R15 (2008–2013)", + [5] = "YZF R15 (2014)", + [6] = "Y15ZR / Exciter 150 / MX King 150", + [7] = "FZ150i / YZF R15", + [8] = "FZ150i (2016)", + [9] = "MSLAZ 2015", + [10] = "YZF R25 2018", + [11] = "YZF R3 2015", + [13] = "YZF R15 2015", + [14] = "NMAX", + [15] = "NVX", + [16] = "Y15ZR 2019", + [17] = "Y16ZR", + [18] = "135LC Fi", + [19] = "XMAX", + [20] = "XMAX V2", + [21] = "R15M 2022", + [22] = "MT15 2022", + [23] = "EGO AVANTIZ", + [24] = "R125 2019", + [25] = "R25 2019", + [26] = "R3 2019", + [27] = "R125 2008", + [28] = "XMAX V3", + [29] = "NVX V1", + [30] = "PG1 / EZ115", + }), + + [Honda] = ("Honda", new() + { + [1] = "Dream110 / Wave110 / Wave125 / MSX125", + [2] = "PCX", + [3] = "RS150R / Winner150", + [4] = "CBR250", + [5] = "CRF250L (2013)", + [6] = "CRF250L (2017)", + [7] = "EX5", + [8] = "RSX", + }), + + [Modenas] = ("Modenas", new() + { + [1] = "VF3i", + }), + + [Suzuki] = ("Suzuki", new() + { + [1] = "Raider R150", + }), + }; + + // ── Lookups ─────────────────────────────────────────────────────────────── + + /// Returns the manufacturer name, or empty string if unknown. + public static string GetMake(byte makeCode) + => _registry.TryGetValue(makeCode, out var entry) ? entry.Make : string.Empty; + + /// Returns the model name, or empty string if unknown. + public static string GetModel(byte makeCode, int modelCode) + { + if (!_registry.TryGetValue(makeCode, out var entry)) return string.Empty; + return entry.Models.TryGetValue(modelCode, out var name) ? name : string.Empty; + } + + /// Returns "Make — Model" display string, e.g. "Yamaha — Y15ZR 2019". + public static string GetDisplayName(byte makeCode, int modelCode) + { + string make = GetMake(makeCode); + string model = GetModel(makeCode, modelCode); + + if (string.IsNullOrEmpty(make)) return $"Unknown ({makeCode}/{modelCode})"; + if (string.IsNullOrEmpty(model)) return $"{make} — Unknown model ({modelCode})"; + return $"{make} — {model}"; + } + + /// All registered manufacturers. + public static IEnumerable<(byte Code, string Name)> AllMakes + => _registry.Select(kv => (kv.Key, kv.Value.Make)); + + /// All models for a given manufacturer code. + public static IEnumerable<(int Code, string Name)> ModelsFor(byte makeCode) + => _registry.TryGetValue(makeCode, out var entry) + ? entry.Models.Select(kv => (kv.Key, kv.Value)) + : Enumerable.Empty<(int, string)>(); +} diff --git a/TuneBoss.Core/Models/DiagnosticsFrame.cs b/TuneBoss.Core/Models/DiagnosticsFrame.cs new file mode 100644 index 0000000..9da4e5d --- /dev/null +++ b/TuneBoss.Core/Models/DiagnosticsFrame.cs @@ -0,0 +1,417 @@ +namespace TuneBoss.Core.Models; + +/// +/// Parsed APP_MONITORING (0x70) streaming diagnostics frame. +/// +/// ── Wire layout — 36 bytes (value[0..35]) ──────────────────────────────────── +/// Sourced from UpdateDiagLabel() and label assignment logic in the WinForms app. +/// Column mapping confirmed from tableLayoutPanel1 Designer.cs: +/// col 0/2 = definition label (static text) +/// col 1/3 = value label (updated each frame) +/// +/// Byte Channel Notes / Display +/// ───── ───────────────────────── ────────────────────────────────────────── +/// [0] (TL command = 0x70) Packet type, not a data channel +/// [1] (reserved / seq) +/// [2] (reserved) +/// [3] (reserved) +/// [4] Load Raw load value +/// [5] RPM_raw × 100 = display RPM +/// [6] Baro_kPa Barometric pressure kPa +/// [7] VBAT_deciV Battery voltage (decivolts) +/// [8] FuelStartAngle1_raw × 3 = display degrees (label71) +/// [9] FuelStartAngle2_raw × 3 = display degrees (label71a) +/// [10] FuelPW1_lo Combined: [10] + 256×[11] = fuel PW 1 +/// [11] FuelPW1_hi +/// [12] SparkAngle1 unchecked sbyte +/// [13] SparkAngle2 unchecked sbyte +/// [14] CrankSyncLostCounter +/// [15] SparkPulseWidth +/// [16] FuelEndAngle_lo Combined: [16] + 256×[17] +/// [17] FuelEndAngle_hi +/// [18] TPS_Raw Raw TPS value (label78 = "TPS Raw") +/// [19] CrankState_packed [19] & 0x0F = CrankState, [19] & 0xF0 >> 4 = TC_Mode +/// [20] ETEMP_DegC Engine temperature °C +/// [21] IAT_DegC Intake air temperature °C +/// [22] TPS_Percent TPS as percentage (used for gauge + tracker) +/// [23] MAP_kPa Manifold absolute pressure kPa +/// [24] O2_AirFuel_x10 AFR × 10 (e.g. 145 = 14.5 AFR) +/// [25] MAP_Lo_Avg_kPa +/// [26] MAP_Hi_Avg_kPa + ([29] & 0x10) × 16 = extra speed bit (2026/04/06) +/// [27] Baro_Dynamic +/// [28] ThrottleState_packed [28] & 0x0F = ThrottleState, [28] & 0x10 = FuelPW_Limit +/// [29] RPMState_packed [29] & 0x0F = RPMState, [29] & 0x80 = StayTuned, +/// [29] & 0x20 = Mode, [29] & 0x10 = extra speed bit +/// [30] UMState_packed [30] & 0x0F = UMState, [30] & 0xF0 >> 4 = GearRatio +/// [31] ErrorState1 Bit-packed analog errors (current) +/// [32] ErrorState2 Bit-packed output errors (current) +/// [33] ErrorState1_Persistent Bit-packed analog errors (persistent) +/// [34] ErrorState2_Persistent Bit-packed output errors (persistent) (also captureError arg 3) +/// [35] ErrorState_Extra Bit-packed output errors persistent (captureError arg 4) +/// +/// ── Tracker channels ────────────────────────────────────────────────────────── +/// Load tracker : uses value[4] (Load) +/// RPM tracker : uses value[5] (RPM_raw) +/// TPS tracker : uses value[22] (TPS_Percent) ← for user-adjust tables (diag4/5/10/11/12) +/// +/// ── CrankState display values ───────────────────────────────────────────────── +/// 5 = Yellow (near-sync), 6 = Green (running), other = Red (lost/searching) +/// +/// ── UMState display values ──────────────────────────────────────────────────── +/// 0=INIT, 1=STOP, 2=START, 3=RUN, 4=CUT, 5=SAFEMODE_RUN, 6=SAFEMODE_CUT, +/// 7=LAUNCHBOSS, 8=LAUNCHBOSS_CUT +/// +public sealed class DiagnosticsFrame +{ + public const int FrameBytes = 36; + + // ── Identity ───────────────────────────────────────────────────────────── + public byte SeqNum { get; init; } + public DateTime ReceivedAt { get; init; } + + // ── Primary channels ───────────────────────────────────────────────────── + public byte Load { get; init; } // [4] + public byte RPM_Raw { get; init; } // [5] × 100 = RPM + public byte Baro_kPa { get; init; } // [6] + public byte VBAT_deciV { get; init; } // [7] + + // ── Fuel channels ──────────────────────────────────────────────────────── + public byte FuelStartAngle1_Raw { get; init; } // [8] × 3 = degrees + public byte FuelStartAngle2_Raw { get; init; } // [9] × 3 = degrees + public int FuelPulseWidth1 { get; init; } // [10] + 256×[11] + public int FuelEndAngle { get; init; } // [16] + 256×[17] + + // ── Spark channels ──────────────────────────────────────────────────────── + public sbyte SparkAngle1 { get; init; } // [12] sbyte + public sbyte SparkAngle2 { get; init; } // [13] sbyte + public byte SparkPulseWidth { get; init; } // [15] + + // ── Crank ──────────────────────────────────────────────────────────────── + public byte CrankSyncLostCounter { get; init; } // [14] + public byte CrankState_Raw { get; init; } // [19] raw packed byte + public byte TPS_Raw { get; init; } // [18] + + // ── Sensor channels ────────────────────────────────────────────────────── + public byte ETEMP_DegC { get; init; } // [20] + public byte IAT_DegC { get; init; } // [21] + public byte TPS_Percent { get; init; } // [22] + public byte MAP_kPa { get; init; } // [23] + public byte O2_AFR_x10 { get; init; } // [24] ÷ 10 = AFR + public byte MAP_Lo_Avg { get; init; } // [25] + public byte MAP_Hi_Avg_Raw{ get; init; } // [26] raw (extra bit in [29]) + public byte Baro_Dynamic { get; init; } // [27] + + // ── State packed bytes ──────────────────────────────────────────────────── + public byte ThrottleState_Packed { get; init; } // [28] + public byte RPMState_Packed { get; init; } // [29] + public byte UMState_Packed { get; init; } // [30] + + // ── Error bytes ────────────────────────────────────────────────────────── + // captureError(value[32], value[33], value[34], value[35]) + // = captureError(analogError, analogErrorP, outputError, outputErrorP) + public byte ErrorsFatal { get; init; } // [31] raw display only (label91) + public byte AnalogError_Current { get; init; } // [32] analogError + public byte AnalogError_Persistent { get; init; } // [33] analogErrorP + public byte OutputError_Current { get; init; } // [34] outputError + public byte OutputError_Persistent { get; init; } // [35] outputErrorP + + // ── Derived display values ──────────────────────────────────────────────── + public int RPM => RPM_Raw * 100; + public int FuelStartAngle1_Deg => FuelStartAngle1_Raw * 3; + public int FuelStartAngle2_Deg => FuelStartAngle2_Raw * 3; + public double O2_AFR => O2_AFR_x10 / 10.0; + public double VBAT_Volts => VBAT_deciV / 10.0; + + // [19] CrankState nibbles + public int CrankState => CrankState_Raw & 0x0F; + public int TC_Mode => (CrankState_Raw & 0xF0) >> 4; + + // [28] ThrottleState + public ThrottleStateValue ThrottleState => (ThrottleStateValue)(ThrottleState_Packed & 0x0F); + public bool FuelPW_LimitActive => (ThrottleState_Packed & 0x10) != 0; + + // [29] RPM State + public RPMStateValue RPMState => (RPMStateValue)(RPMState_Packed & 0x0F); + public bool StayTunedRunning => (RPMState_Packed & 0x80) != 0; + public bool ModeSelected => (RPMState_Packed & 0x20) != 0; + public bool SpeedExtraBit => (RPMState_Packed & 0x10) != 0; + + // [26] Meter speed with extra bit from [29] (added 2026/04/06) + public int MeterSpeed => MAP_Hi_Avg_Raw + (SpeedExtraBit ? 0x10 * 16 : 0); + + // [30] UM State + public UMStateValue UMState => (UMStateValue)(UMState_Packed & 0x0F); + public int GearRatio => (UMState_Packed & 0xF0) >> 4; + + // ── Error flags ─────────────────────────────────────────────────────────── + public bool[] AnalogErrors_Current => UnpackBits(AnalogError_Current); + public bool[] OutputErrors_Current => UnpackBits(OutputError_Current); + public bool[] AnalogErrors_Persistent => UnpackBits(AnalogError_Persistent); + public bool[] OutputErrors_Persistent => UnpackBits(OutputError_Persistent); + + public bool HasActiveError => + AnalogError_Current != 0 || OutputError_Current != 0; + + /// Parsed error flags — ready to drive the 16-indicator error panel. + public ErrorFlags Errors => ErrorFlags.From(this); + + // ── Parser ──────────────────────────────────────────────────────────────── + + /// + /// Parses a raw diagnostics frame payload. + /// is the full BLE packet payload starting at byte [0] = 0x70. + /// Byte indices in comments refer to the payload array as used in UpdateDiagLabel(). + /// + public static DiagnosticsFrame Parse(byte[] data, byte seqNum, DateTime? receivedAt = null) + { + if (data.Length < FrameBytes) + throw new ArgumentException( + $"Expected at least {FrameBytes} bytes, got {data.Length}.", nameof(data)); + + return new DiagnosticsFrame + { + SeqNum = seqNum, + ReceivedAt = receivedAt ?? DateTime.UtcNow, + + Load = data[4], + RPM_Raw = data[5], + Baro_kPa = data[6], + VBAT_deciV = data[7], + + FuelStartAngle1_Raw = data[8], + FuelStartAngle2_Raw = data[9], + FuelPulseWidth1 = data[10] + (256 * data[11]), + SparkAngle1 = unchecked((sbyte)data[12]), + SparkAngle2 = unchecked((sbyte)data[13]), + CrankSyncLostCounter = data[14], + SparkPulseWidth = data[15], + FuelEndAngle = data[16] + (256 * data[17]), + + TPS_Raw = data[18], + CrankState_Raw = data[19], + + ETEMP_DegC = data[20], + IAT_DegC = data[21], + TPS_Percent = data[22], + MAP_kPa = data[23], + O2_AFR_x10 = data[24], + MAP_Lo_Avg = data[25], + MAP_Hi_Avg_Raw = data[26], + Baro_Dynamic = data[27], + + ThrottleState_Packed = data[28], + RPMState_Packed = data[29], + UMState_Packed = data[30], + + ErrorsFatal = data[31], + AnalogError_Current = data[32], + AnalogError_Persistent = data[33], + OutputError_Current = data[34], + OutputError_Persistent = data[35], + }; + } + + // ── CSV log format ──────────────────────────────────────────────────────── + + /// + /// Returns a CSV log row matching the format in UpdateDiagLabel(). + /// Columns match the .tbd log format used by TracBoss. + /// + public string ToCsvRow(string timestamp) => + $"{timestamp}," + + $"{Load}," + + $"{RPM}," + + $"{Baro_kPa}," + + $"{VBAT_deciV}," + + $"{FuelPulseWidth1}," + + $"{FuelEndAngle}," + + $"{SparkAngle1}," + + $"{SparkAngle2}," + + $"{CrankSyncLostCounter}," + + $"{SparkPulseWidth}," + + $"{FuelEndAngle}," + + $"{TPS_Raw}," + + $"{CrankState_Raw}," + + $"{ETEMP_DegC}," + + $"{IAT_DegC}," + + $"{TPS_Percent}," + + $"{MAP_kPa}," + + $"{O2_AFR_x10}," + + $"{MAP_Lo_Avg}," + + $"{MAP_Hi_Avg_Raw}," + + $"{Baro_Dynamic}," + + $"{ThrottleState_Packed}," + + $"{RPMState_Packed}," + + $"{UMState_Packed}," + + $"{AnalogError_Current}," + + $"{OutputError_Current}," + + $"{AnalogError_Persistent}," + + $"{OutputError_Persistent},"; + + // ── Helpers ─────────────────────────────────────────────────────────────── + private static bool[] UnpackBits(byte b) => + Enumerable.Range(0, 8).Select(i => (b & (1 << i)) != 0).ToArray(); +} + +// ── State enums ─────────────────────────────────────────────────────────────── + +public enum ThrottleStateValue : byte +{ + Steady = 0, + Accel = 1, + Decel = 2, +} + +public enum RPMStateValue : byte +{ + Steady = 0, + Decel = 1, + Accel = 2, +} + +public enum UMStateValue : byte +{ + Init = 0, + Stop = 1, + Start = 2, + Run = 3, + Cut = 4, + SafeMode_Run = 5, + SafeMode_Cut = 6, + LaunchBoss = 7, + LaunchBoss_Cut = 8, +} + +/// +/// Diagnostics tracker coordinates for highlighting the active cell +/// in a tuning table grid. Produced by getRpmToHighlight/getLoadToHighlight. +/// +public sealed record DiagnosticsTracker( + int ColHighlight, // exact RPM column + int ColLowlight, // next RPM column + int RowHighlight, // exact load/TPS row + int RowLowlight); // next load/TPS row + +/// +/// Parsed error flags from the four error bytes in a DiagnosticsFrame. +/// +/// Call site (UpdateDiagLabel): captureError(value[32], value[33], value[34], value[35]) +/// analogError = [32] AnalogError_Current +/// analogErrorP = [33] AnalogError_Persistent +/// outputError = [34] OutputError_Current +/// outputErrorP = [35] OutputError_Persistent +/// +/// Display: Red = active now, Yellow = persistent (ever triggered), Green = clear +/// +/// ── Analog errors (err1–err8) bit map ──────────────────────────────────────── +/// Bit 0 err1 Throttle Position Sensor +/// Bit 1 err2 Manifold Air Pressure Sensor +/// Bit 2 err3 Intake Air Temperature Sensor +/// Bit 3 err4 Vehicle Down Sensor +/// Bit 4 err5 Engine Temperature Sensor +/// Bit 5 err6 Oxygen Sensor +/// Bit 6 err7 Battery Voltage +/// Bit 7 err8 Aux +/// +/// ── Output errors (err9o–err16o) bit map ───────────────────────────────────── +/// Bit 0 err9o Injector 1 +/// Bit 1 err10o Injector 2 / Idle Solenoid +/// Bit 2 err11o Fuel Pump +/// Bit 3 err12o Radiator Fan +/// Bit 4 err13o Spark Ignition 1 +/// Bit 5 err14o Spark Ignition 2 +/// Bit 6 err15o 5V PSU +/// Bit 7 err16o O2H +/// +public sealed class ErrorFlags +{ + // ── Raw bytes ───────────────────────────────────────────────────────────── + public byte AnalogCurrent { get; init; } // value[32] + public byte AnalogPersistent { get; init; } // value[33] + public byte OutputCurrent { get; init; } // value[34] + public byte OutputPersistent { get; init; } // value[35] + + // ── Analog error channels ───────────────────────────────────────────────── + public ErrorStatus TPS => Get(AnalogCurrent, AnalogPersistent, 0); + public ErrorStatus MAP => Get(AnalogCurrent, AnalogPersistent, 1); + public ErrorStatus IAT => Get(AnalogCurrent, AnalogPersistent, 2); + public ErrorStatus VehicleDown => Get(AnalogCurrent, AnalogPersistent, 3); + public ErrorStatus ETemp => Get(AnalogCurrent, AnalogPersistent, 4); + public ErrorStatus OxygenSensor=> Get(AnalogCurrent, AnalogPersistent, 5); + public ErrorStatus BattVoltage => Get(AnalogCurrent, AnalogPersistent, 6); + public ErrorStatus Aux => Get(AnalogCurrent, AnalogPersistent, 7); + + // ── Output error channels ───────────────────────────────────────────────── + public ErrorStatus Injector1 => Get(OutputCurrent, OutputPersistent, 0); + public ErrorStatus Injector2_IdleSol => Get(OutputCurrent, OutputPersistent, 1); + public ErrorStatus FuelPump => Get(OutputCurrent, OutputPersistent, 2); + public ErrorStatus RadiatorFan => Get(OutputCurrent, OutputPersistent, 3); + public ErrorStatus SparkIgnition1 => Get(OutputCurrent, OutputPersistent, 4); + public ErrorStatus SparkIgnition2 => Get(OutputCurrent, OutputPersistent, 5); + public ErrorStatus PSU_5V => Get(OutputCurrent, OutputPersistent, 6); + public ErrorStatus O2Heater => Get(OutputCurrent, OutputPersistent, 7); + + // ── Summary ─────────────────────────────────────────────────────────────── + public bool HasActiveError => + AnalogCurrent != 0 || OutputCurrent != 0; + + /// All 16 error channels in display order (analog first, then output). + public IEnumerable<(string Name, ErrorStatus Status)> AllErrors() + { + yield return ("Throttle Position Sensor", TPS); + yield return ("Manifold Air Pressure Sensor", MAP); + yield return ("Intake Air Temperature Sensor", IAT); + yield return ("Vehicle Down Sensor", VehicleDown); + yield return ("Engine Temperature Sensor", ETemp); + yield return ("Oxygen Sensor", OxygenSensor); + yield return ("Battery Voltage", BattVoltage); + yield return ("Aux", Aux); + yield return ("Injector 1", Injector1); + yield return ("Injector 2 / Idle Solenoid", Injector2_IdleSol); + yield return ("Fuel Pump", FuelPump); + yield return ("Radiator Fan", RadiatorFan); + yield return ("Spark Ignition 1", SparkIgnition1); + yield return ("Spark Ignition 2", SparkIgnition2); + yield return ("5V PSU", PSU_5V); + yield return ("O2 Heater", O2Heater); + } + + // ── Factory ─────────────────────────────────────────────────────────────── + public static ErrorFlags From(DiagnosticsFrame frame) => new() + { + AnalogCurrent = frame.AnalogError_Current, + AnalogPersistent = frame.AnalogError_Persistent, + OutputCurrent = frame.OutputError_Current, + OutputPersistent = frame.OutputError_Persistent, + }; + + public static ErrorFlags Clear => new() + { + AnalogCurrent = 0, AnalogPersistent = 0, + OutputCurrent = 0, OutputPersistent = 0, + }; + + // ── Helper ──────────────────────────────────────────────────────────────── + private static ErrorStatus Get(byte current, byte persistent, int bit) + { + bool isActive = (current & (1 << bit)) != 0; + bool wasPersistent= (persistent & (1 << bit)) != 0; + + if (isActive) return ErrorStatus.Active; + if (wasPersistent) return ErrorStatus.Persistent; + return ErrorStatus.Clear; + } +} + +/// +/// Three-state error status matching the traffic-light display: +/// Active = Red (currently faulted) +/// Persistent = Yellow (was faulted this session, now cleared) +/// Clear = Green (no fault) +/// +public enum ErrorStatus +{ + Clear, + Persistent, + Active, +} diff --git a/TuneBoss.Core/Models/EcuInfo.cs b/TuneBoss.Core/Models/EcuInfo.cs new file mode 100644 index 0000000..fcb3ca6 --- /dev/null +++ b/TuneBoss.Core/Models/EcuInfo.cs @@ -0,0 +1,190 @@ +namespace TuneBoss.Core.Models; + +/// +/// Parsed response from APP_READ_INFO (0x37). +/// Immutable — constructed once per successful read. +/// +public sealed class EcuInfo +{ + // ── Identity ───────────────────────────────────────────────────────────── + public string Username { get; init; } = string.Empty; + public string UniqueId { get; init; } = string.Empty; // "AABBCCDD-EEFF0011-..." + + // ── Version ────────────────────────────────────────────────────────────── + public byte FwVersion { get; init; } + public byte HwVersion { get; init; } + public byte FwVersion2 { get; init; } // Only present if buffer > 68 + public byte FwSubVersion2 { get; init; } + public byte TableVersion { get; init; } + public byte HwComponentVersion { get; init; } + public byte AppInfoVersion { get; init; } // Generation discriminator + + // ── Bike identity ──────────────────────────────────────────────────────── + public byte BikeManufacturer { get; init; } // 1=Yamaha 2=Honda 3=Kawasaki 6=Suzuki + public byte BikeModel { get; init; } + + // ── Usage counters ─────────────────────────────────────────────────────── + public uint FlashWriteCount { get; init; } + public uint SwitchToggleCount { get; init; } + public byte PwdResetCount { get; init; } + + // ── Dates ──────────────────────────────────────────────────────────────── + public DateOnly? ProgrammingDate { get; init; } + public DateOnly? FirstUseDate { get; init; } + public byte FirstUseInfo0 { get; init; } // raw buf[32] (FirstUseDate DD) + public byte FirstUseInfo1 { get; init; } // raw buf[33] — TPS cal-done flag (Android UIfirstUseDate[1]) + public DateOnly? FirstFlashDate { get; init; } + + // ── Upgrade flags ──────────────────────────────────────────────────────── + public byte UpgradeRpmMax { get; init; } // × 100 = actual RPM limit + public byte UpgradeShiftAuto { get; init; } + public byte UpgradeLogImmo { get; init; } // low nibble = legacy Upgrade_Stage3 (see Stage) + public byte UpgradeFuture12 { get; init; } + public byte UpgradeFuture2 { get; init; } // only if buffer > 68 + + // ── Derived ────────────────────────────────────────────────────────────── + public int RpmLimit => UpgradeRpmMax * 100; + /// + /// Dual injector is a Stage 3 feature — the same nibble the Android app reads as + /// Upgrade_Stage3, so it follows the stage rather than being an independent flag. + /// + public bool IsDualInjectorUnlocked => Stage >= 3; + + /// True once the throttle (TPS) calibration has been completed on this unit. + /// The firmware/Android app stores the flag in the second first-use byte + /// (UIfirstUseDate[1] = buf[33]), not the first. + public bool HasTpsCalibration => FirstUseInfo1 == TpsCalibration.CalDoneFlag; + + /// + /// Legacy Upgrade_Stage2 — high nibble of the shift/stage byte + /// (legacy buf[offset+42] & 0xF0, whose low nibble is Shift Auto). + /// + public byte UpgradeStage2 => (byte)(UpgradeShiftAuto & 0xF0); + + /// + /// Legacy Upgrade_Stage3 — low nibble of the next byte + /// (legacy buf[offset+43] & 0x0F; the WPF parser stores that byte + /// as ). + /// + public byte UpgradeStage3 => (byte)(UpgradeLogImmo & 0x0F); + + /// + /// ECU stage — 1, 2 or 3. Mirrors the Android app's precedence exactly: + /// Stage 3 wins if its nibble is set, else Stage 2, else Stage 1. + /// Stage 1 does not expose the user 24×8 adjust tables (only the subtables). + /// + public int Stage => + UpgradeStage3 > 0 ? 3 : + UpgradeStage2 > 0 ? 2 : 1; + + /// True when the stage exposes the user 24×8 adjust tables (Stage 2+). + public bool HasUserAdjustTables => Stage >= 2; + + // ── Parser ─────────────────────────────────────────────────────────────── + /// + /// Parses a raw APP_READ_INFO response buffer. + /// Buffer[0] must be APP_CMD_SUCCESS (0x51); payload starts at byte 4. + /// + public static EcuInfo Parse(byte[] buf) + { + if (buf[0] != 0x51) + throw new InvalidOperationException($"Expected APP_CMD_SUCCESS (0x51), got 0x{buf[0]:X2}"); + + const int payloadStart = 4; + const int fieldStart = payloadStart + 16; // after 16-byte username + + // Username (16 bytes, null-terminated ASCII) + var username = System.Text.Encoding.ASCII + .GetString(buf, payloadStart, 16) + .TrimEnd('\0'); + + // Little-endian uint32 helper + uint ReadU32(int offset) => + buf[offset] | + ((uint)buf[offset + 1] << 8) | + ((uint)buf[offset + 2] << 16) | + ((uint)buf[offset + 3] << 24); + + var flashWriteCount = ReadU32(fieldStart); + var switchToggleCount = ReadU32(fieldStart + 4); + + // Dates — DD=0 means "Never" + // Day/Month/Year(+2000) as raw bytes. DD==0 means "Never". Some units carry + // uninitialised or garbage bytes in unused date slots (e.g. month 0 or 14, + // day 31 in a 30-day month); those must NOT throw and abort the whole info + // read — treat any non-calendar value as "not set" (null). + DateOnly? ParseDate(int offset) + { + int day = buf[offset], month = buf[offset + 1], year = 2000 + buf[offset + 2]; + if (day == 0) return null; + if (month < 1 || month > 12) return null; + if (day > DateTime.DaysInMonth(year, month)) return null; + return new DateOnly(year, month, day); + } + + var progDate = ParseDate(fieldStart + 8); + var firstUseDate = ParseDate(fieldStart + 12); + var firstUseInfo0 = buf[fieldStart + 12]; // DD slot (first-use date day) + var firstUseInfo1 = buf[fieldStart + 13]; // MM slot — doubles as the TPS cal-done flag + var firstFlashDate = ParseDate(fieldStart + 16); + + // UniqueID — 16 bytes formatted as 4×4 hex groups + var uid = buf.Skip(fieldStart + 20).Take(16).ToArray(); + var uniqueId = $"{Hex(uid, 0, 4)}-{Hex(uid, 4, 4)}-{Hex(uid, 8, 4)}-{Hex(uid, 12, 4)}"; + + int o = fieldStart + 36; // after UniqueID + + var fwVersion = buf[o]; + var hwVersion = buf[o + 1]; + var bikeMfr = buf[o + 2]; + var bikeModel = buf[o + 3]; + var upgradeRpmMax = buf[o + 4]; + var upgradeShift = buf[o + 5]; + var upgradeLogImmo = buf[o + 6]; + var upgradeFuture12 = buf[o + 7]; + + byte upgradeFuture2 = 0, fw2 = 0, fw2sub = 0, tableVer = 0, hwComp = 0; + if (buf.Length > 68) + { + upgradeFuture2 = buf[o + 8]; + fw2 = buf[o + 9]; + fw2sub = buf[o + 10]; + tableVer = buf[o + 11]; + hwComp = buf[o + 12]; + } + + var appInfoVersion = buf[^1]; // last byte + var pwdRstCount = buf[^5]; // 4 bytes from end + + return new EcuInfo + { + Username = username, + UniqueId = uniqueId, + FwVersion = fwVersion, + HwVersion = hwVersion, + FwVersion2 = fw2, + FwSubVersion2 = fw2sub, + TableVersion = tableVer, + HwComponentVersion = hwComp, + AppInfoVersion = appInfoVersion, + BikeManufacturer = bikeMfr, + BikeModel = bikeModel, + FlashWriteCount = flashWriteCount, + SwitchToggleCount = switchToggleCount, + PwdResetCount = pwdRstCount, + ProgrammingDate = progDate, + FirstUseDate = firstUseDate, + FirstUseInfo0 = firstUseInfo0, + FirstUseInfo1 = firstUseInfo1, + FirstFlashDate = firstFlashDate, + UpgradeRpmMax = upgradeRpmMax, + UpgradeShiftAuto = upgradeShift, + UpgradeLogImmo = upgradeLogImmo, + UpgradeFuture12 = upgradeFuture12, + UpgradeFuture2 = upgradeFuture2, + }; + } + + private static string Hex(byte[] src, int start, int count) => + string.Concat(src.Skip(start).Take(count).Select(b => $"{b:X2}")); +} diff --git a/TuneBoss.Core/Models/EcuSession.cs b/TuneBoss.Core/Models/EcuSession.cs new file mode 100644 index 0000000..1e24a66 --- /dev/null +++ b/TuneBoss.Core/Models/EcuSession.cs @@ -0,0 +1,79 @@ +namespace TuneBoss.Core.Models; + +/// +/// Holds all table data loaded from a connected TuneBoss device. +/// Constructed after a successful populateInitTables sequence. +/// +/// Acts as the single source of truth for the current session. +/// ViewModels bind to properties on this object. +/// Immutable by convention — table updates produce new instances. +/// +public sealed record EcuSession +{ + // ── Device identity ─────────────────────────────────────────────────────── + public EcuInfo Info { get; init; } = null!; + public MemoryLayout Layout { get; init; } = null!; + public EcuVariant Variant { get; init; } + + // ── 2D tuning tables — cylinder 1 ──────────────────────────────────────── + public TuningTable? Fuel_PulseWidth1 { get; init; } + public TuningTable? Spark_Angle1 { get; init; } + public TuningTable? Fuel_Angle2D { get; init; } + public TuningTable? Secondary_Load_Conversion { get; init; } + public TuningTable? Fuel_PulseWidth_Adjust1 { get; init; } + public TuningTable? Spark_Angle_Adjust1 { get; init; } + public AfrTable? AFR_Target1 { get; init; } + + // ── Subtables — cylinder 1 ──────────────────────────────────────────────── + public SubTable? AFR_Target1_SubTable { get; init; } + public SubTable? Fuel_PulseWidth_Adjust1_SubTable { get; init; } + public SubTable? Spark_Angle_Adjust1_SubTable { get; init; } + + // ── 2D tuning tables — cylinder 2 (isTwoCylinder only) ─────────────────── + public TuningTable? Fuel_PulseWidth2 { get; init; } + public TuningTable? Spark_Angle2 { get; init; } + public TuningTable? Fuel_Angle2D_2 { get; init; } + public TuningTable? Fuel_PulseWidth_Adjust2 { get; init; } + public TuningTable? Spark_Angle_Adjust2 { get; init; } + public AfrTable? AFR_Target2 { get; init; } + + // ── Subtables — cylinder 2 ──────────────────────────────────────────────── + public SubTable? AFR_Target2_SubTable { get; init; } + public SubTable? Fuel_PulseWidth_Adjust2_SubTable { get; init; } + public SubTable? Spark_Angle_Adjust2_SubTable { get; init; } + + // ── 1D tables (up to 37, null = not available on this FW version) ───────── + public OneDimTable?[] OneDimTables { get; init; } = new OneDimTable?[37]; + + // ── Misc values ─────────────────────────────────────────────────────────── + public MiscValues? Misc { get; init; } + + // ── Derived ────────────────────────────────────────────────────────────── + public bool IsTwoCylinder => Variant != EcuVariant.SingleCylinder; + + public bool HasExtendedMisc => Info.FwVersion >= 150; + + /// + /// True when the session has been fully loaded — + /// i.e. all tables available for this device have been read. + /// + public bool IsFullyLoaded { get; init; } + + // ── Mutation helpers ────────────────────────────────────────────────────── + + /// Returns a new session with Fuel_PulseWidth1 replaced. + public EcuSession WithFuel1(TuningTable t) => this with { Fuel_PulseWidth1 = t }; + public EcuSession WithSpark1(TuningTable t) => this with { Spark_Angle1 = t }; + public EcuSession WithFuelAdjust1(TuningTable t) => this with { Fuel_PulseWidth_Adjust1 = t }; + public EcuSession WithSparkAdjust1(TuningTable t) => this with { Spark_Angle_Adjust1 = t }; + public EcuSession WithFuelAngle(TuningTable t) => this with { Fuel_Angle2D = t }; + public EcuSession WithAfr1(AfrTable t) => this with { AFR_Target1 = t }; + public EcuSession WithMisc(MiscValues m) => this with { Misc = m }; + + public EcuSession WithOneDimTable(int index, OneDimTable t) + { + var arr = (OneDimTable?[])OneDimTables.Clone(); + arr[index] = t; + return this with { OneDimTables = arr }; + } +} diff --git a/TuneBoss.Core/Models/MemoryLayout.cs b/TuneBoss.Core/Models/MemoryLayout.cs new file mode 100644 index 0000000..1e16f13 --- /dev/null +++ b/TuneBoss.Core/Models/MemoryLayout.cs @@ -0,0 +1,302 @@ +using TuneBoss.Core.Protocol; + +namespace TuneBoss.Core.Models; + +/// +/// Describes a single memory region on the device — its address and read length. +/// +public sealed record MemoryRegion(ushort Address, byte Length) +{ + public byte AddrLo => (byte)(Address & 0xFF); + public byte AddrHi => (byte)(Address >> 8); + public byte[] AddrBytes => new[] { AddrLo, AddrHi }; + + /// True if this region exists (address != 0x0000 or explicit availability flag). + public bool IsAvailable { get; init; } = true; + + public static MemoryRegion Unavailable => new(0x0000, 0) { IsAvailable = false }; +} + +/// +/// Complete memory address map for a connected TuneBoss device. +/// Constructed once after EcuInfo is parsed; replaces the static memAddress class. +/// +/// ── Generation mapping ──────────────────────────────────────────────────────── +/// Gen1 (AppInfoVersion=245): legacy addresses, APP_MEMRD_SEQ for all ops +/// Gen2 (AppInfoVersion=1) : dedicated read commands, single-cylinder layout +/// Gen3 (AppInfoVersion=2) : same as Gen2 + separate 2D_USER address space +/// +/// ── 1D table FW gates (from populateInitTables) ─────────────────────────────── +/// Tables 1–18 : always (base set) +/// Tables 19–24 : FW_Version >= 80 +/// Tables 25–26 : FW_Version >= 83 +/// Tables 27–34 : FW_Version >= 90 +/// Tables 35–37 : FW_Version >= 130 +/// +/// ── Misc FW gates ───────────────────────────────────────────────────────────── +/// Core (136B) : always +/// LaunchFuel (12B) : FW_Version >= 150 +/// LaunchFuel2 (12B) : FW_Version >= 150 +/// AuxOut (12B) : FW_Version >= 150 +/// Extended (var B) : FW_Version >= 150, size from EcuVariant +/// +public sealed record MemoryLayout +{ + // ── 2D main tuning tables ───────────────────────────────────────────────── + public MemoryRegion Fuel_PulseWidth1 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Spark_Angle1 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion AFR_Target1 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Fuel_Angle2D { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Secondary_Load_Conversion { get; init; } = MemoryRegion.Unavailable; + + // ── 2D user-adjustable tables (cyl1) ───────────────────────────────────── + public MemoryRegion Fuel_PulseWidth_Adjust1 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Spark_Angle_Adjust1 { get; init; } = MemoryRegion.Unavailable; + + // ── Subtables (cyl1) ───────────────────────────────────────────────────── + public MemoryRegion AFR_Target1_SubTable { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Fuel_PulseWidth_Adjust1_SubTable { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Spark_Angle_Adjust1_SubTable { get; init; } = MemoryRegion.Unavailable; + + // ── 2D tables cyl2 (isTwoCylinder only) ────────────────────────────────── + public MemoryRegion Fuel_PulseWidth2 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Spark_Angle2 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion AFR_Target2 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Fuel_Angle2D_2 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Fuel_PulseWidth_Adjust2 { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Spark_Angle_Adjust2 { get; init; } = MemoryRegion.Unavailable; + + // ── Subtables cyl2 ─────────────────────────────────────────────────────── + public MemoryRegion AFR_Target2_SubTable { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Fuel_PulseWidth_Adjust2_SubTable { get; init; } = MemoryRegion.Unavailable; + public MemoryRegion Spark_Angle_Adjust2_SubTable { get; init; } = MemoryRegion.Unavailable; + + // ── 1D tables (up to 37 depending on FW_Version) ───────────────────────── + // Index 0-based: OneDimTables[0] = table 1, OneDimTables[36] = table 37 + // Unavailable entries have IsAvailable=false and are skipped by the service layer. + public MemoryRegion[] OneDimTables { get; init; } = new MemoryRegion[37]; + + // ── Misc regions ───────────────────────────────────────────────────────── + public MemoryRegion MiscCore { get; init; } = MemoryRegion.Unavailable; // 136 bytes, always + public MemoryRegion MiscLaunchFuel { get; init; } = MemoryRegion.Unavailable; // 12B, FW>=150 + public MemoryRegion MiscLaunchFuel2 { get; init; } = MemoryRegion.Unavailable; // 12B, FW>=150 + public MemoryRegion MiscAuxOut { get; init; } = MemoryRegion.Unavailable; // 12B, FW>=150 + public MemoryRegion MiscExtended { get; init; } = MemoryRegion.Unavailable; // var, FW>=150 + + // ── RPM limit misc address ──────────────────────────────────────────────── + public MemoryRegion RpmLimitMisc { get; init; } = MemoryRegion.Unavailable; // 0x63 length + + // ── Read lengths (fixed from populateInitTables) ────────────────────────── + public const byte Len2DTable = 0xE3; // 227 — split read + public const byte LenAFRTable = 0xEF; // 239 — AFR split read + public const byte Len1DTable = 0x17; // 23 — single read + public const byte LenSubTable = 0x17; // 23 — single read + public const byte LenMiscCore = 0x88; // 136 + public const byte LenMiscExt12 = 0x0B; // 11 (12 bytes incl [0]) + public const byte LenRpmCheck = 0x63; // 99 + + // ════════════════════════════════════════════════════════════════════════ + // FACTORY + // ════════════════════════════════════════════════════════════════════════ + + /// + /// Constructs the complete memory layout from parsed EcuInfo. + /// This is the single entry point — call once after ReadEcuInfoAsync(). + /// + public static MemoryLayout For(EcuInfo info, EcuVariant variant) + { + var gen = GenerationConfig.ResolveGeneration(info.AppInfoVersion); + byte fw = info.FwVersion; + byte fw2sub = info.FwSubVersion2; + + return gen switch + { + GenerationType.Gen1 => BuildGen1(fw, variant), + GenerationType.Gen2 => BuildGen2(fw, variant, fw2sub), + GenerationType.Gen3 => BuildGen3(fw, variant, fw2sub), + _ => throw new InvalidOperationException($"Unknown generation for AppInfoVersion {info.AppInfoVersion}") + }; + } + + // ════════════════════════════════════════════════════════════════════════ + // GEN1 — legacy, APP_MEMRD_SEQ for all + // ════════════════════════════════════════════════════════════════════════ + private static MemoryLayout BuildGen1(byte fw, EcuVariant variant) + { + static MemoryRegion R(ushort addr, byte len) => new(addr, len); + var layout = new MemoryLayout + { + // 2D tables at fixed GEN1 addresses + Fuel_PulseWidth1 = R(0x0000, Len2DTable), + Spark_Angle1 = R(0x00E4, Len2DTable), + AFR_Target1 = R(0x01C8, LenAFRTable), + Fuel_Angle2D = R(0x02AC, Len2DTable), + Secondary_Load_Conversion = R(0x0390, Len2DTable), + Fuel_PulseWidth_Adjust1 = R(0x048C, Len2DTable), + Spark_Angle_Adjust1 = R(0x0588, Len2DTable), + + // Subtables + AFR_Target1_SubTable = R(0x02AC, LenSubTable), + Fuel_PulseWidth_Adjust1_SubTable = R(0x0570, LenSubTable), + Spark_Angle_Adjust1_SubTable = R(0x066C, LenSubTable), + + // Misc + MiscCore = R(0x0834, LenMiscCore), + RpmLimitMisc = R(0x0840, LenRpmCheck), + + // GEN1 has no extended misc regions + MiscLaunchFuel = MemoryRegion.Unavailable, + MiscLaunchFuel2 = MemoryRegion.Unavailable, + MiscAuxOut = MemoryRegion.Unavailable, + MiscExtended = MemoryRegion.Unavailable, + + OneDimTables = Build1DTables_Gen1(fw), + }; + return layout; + } + + // ════════════════════════════════════════════════════════════════════════ + // GEN2 — dedicated read commands, single/dual cylinder + // ════════════════════════════════════════════════════════════════════════ + private static MemoryLayout BuildGen2(byte fw, EcuVariant variant, byte fw2sub = 0) + { + static MemoryRegion R(ushort addr, byte len) => new(addr, len); + bool isTwoCyl = variant != EcuVariant.SingleCylinder; + + return new MemoryLayout + { + // Cyl1 2D + Fuel_PulseWidth1 = R(0x0000, Len2DTable), + Spark_Angle1 = R(0x00E4, Len2DTable), + AFR_Target1 = R(0x01C8, LenAFRTable), + Fuel_Angle2D = R(0x02AC, Len2DTable), + Secondary_Load_Conversion = R(0x0390, Len2DTable), + Fuel_PulseWidth_Adjust1 = R(0x0474, Len2DTable), + Spark_Angle_Adjust1 = R(0x0558, Len2DTable), + + // Cyl1 subtables + AFR_Target1_SubTable = R(0x0000, LenSubTable), + Fuel_PulseWidth_Adjust1_SubTable = R(0x0018, LenSubTable), + Spark_Angle_Adjust1_SubTable = R(0x0030, LenSubTable), + + // Cyl2 2D (zero/unavailable for single cylinder) + Fuel_PulseWidth2 = isTwoCyl ? R(0x063C, Len2DTable) : MemoryRegion.Unavailable, + AFR_Target2 = isTwoCyl ? R(0x0720, LenAFRTable) : MemoryRegion.Unavailable, + Fuel_Angle2D_2 = isTwoCyl ? R(0x0804, Len2DTable) : MemoryRegion.Unavailable, + Spark_Angle2 = isTwoCyl ? R(0x08E8, Len2DTable) : MemoryRegion.Unavailable, + Fuel_PulseWidth_Adjust2 = isTwoCyl ? R(0x09CC, Len2DTable) : MemoryRegion.Unavailable, + Spark_Angle_Adjust2 = isTwoCyl ? R(0x0AB0, Len2DTable) : MemoryRegion.Unavailable, + + // Cyl2 subtables + AFR_Target2_SubTable = isTwoCyl ? R(0x0048, LenSubTable) : MemoryRegion.Unavailable, + Fuel_PulseWidth_Adjust2_SubTable = isTwoCyl ? R(0x0060, LenSubTable) : MemoryRegion.Unavailable, + Spark_Angle_Adjust2_SubTable = isTwoCyl ? R(0x0078, LenSubTable) : MemoryRegion.Unavailable, + + // Misc core + MiscCore = R(0x0000, LenMiscCore), + RpmLimitMisc = R(0x000C, LenRpmCheck), + + // Extended misc — FW >= 150 + MiscLaunchFuel = fw >= 150 ? R(0x0088, LenMiscExt12) : MemoryRegion.Unavailable, + MiscLaunchFuel2 = fw >= 150 ? R(0x0094, LenMiscExt12) : MemoryRegion.Unavailable, + MiscAuxOut = fw >= 150 ? R(0x00A0, LenMiscExt12) : MemoryRegion.Unavailable, + MiscExtended = fw >= 150 + ? R(0x00AC, MiscValues.ExtendedLengthFor(fw2sub)) + : MemoryRegion.Unavailable, + + OneDimTables = Build1DTables_Gen2(fw), + }; + } + + // ════════════════════════════════════════════════════════════════════════ + // GEN3 — same as Gen2 but 2D_USER in separate address space + // ════════════════════════════════════════════════════════════════════════ + private static MemoryLayout BuildGen3(byte fw, EcuVariant variant, byte fw2sub = 0) + { + // GEN3 user-adjust tables live in a separate address space: + // Fuel_PulseWidth_Adjust1 = 0x0000, Spark_Angle_Adjust1 = 0x00E4 + // etc. (addressed via APP_MEMRD_2D_USER not APP_MEMRD_2D) + var base2 = BuildGen2(fw, variant, fw2sub); + bool isTwoCyl = variant != EcuVariant.SingleCylinder; + + static MemoryRegion R(ushort addr, byte len) => new(addr, len); + + return base2 with + { + // Override user-adjust addresses for GEN3 + Fuel_PulseWidth_Adjust1 = R(0x0000, Len2DTable), + Spark_Angle_Adjust1 = R(0x00E4, Len2DTable), + Fuel_PulseWidth_Adjust2 = isTwoCyl ? R(0x01C8, Len2DTable) : MemoryRegion.Unavailable, + Spark_Angle_Adjust2 = isTwoCyl ? R(0x02AC, Len2DTable) : MemoryRegion.Unavailable, + }; + } + + // ════════════════════════════════════════════════════════════════════════ + // 1D TABLE ADDRESS BUILDERS + // Note the deliberate addr17→panel19, addr18→panel20 swap observed in + // populateInitTables — preserved here in array order. + // ════════════════════════════════════════════════════════════════════════ + private static MemoryRegion[] Build1DTables_Gen1(byte fw) + { + var t = Enumerable.Repeat(MemoryRegion.Unavailable, 37).ToArray(); + static MemoryRegion R(ushort a) => new(a, Len1DTable); + + // Base 18 (addr 0x0684 onwards, 0x18 = 24 byte stride) + t[0] = R(0x0684); t[1] = R(0x069C); t[2] = R(0x06B4); + t[3] = R(0x06CC); t[4] = R(0x06E4); t[5] = R(0x06FC); + t[6] = R(0x0714); t[7] = R(0x072C); t[8] = R(0x0744); + t[9] = R(0x075C); t[10] = R(0x0774); t[11] = R(0x078C); + t[12] = R(0x07A4); t[13] = R(0x07BC); t[14] = R(0x07D4); + t[15] = R(0x07EC); t[16] = R(0x0804); t[17] = R(0x081C); + return t; + } + + private static MemoryRegion[] Build1DTables_Gen2(byte fw) + { + var t = Enumerable.Repeat(MemoryRegion.Unavailable, 37).ToArray(); + static MemoryRegion R(ushort a) => new(a, Len1DTable); + + // Base 18 — always + t[0] = R(0x0000); t[1] = R(0x0018); t[2] = R(0x0030); + t[3] = R(0x0048); t[4] = R(0x0060); t[5] = R(0x0078); + t[6] = R(0x0090); t[7] = R(0x00A8); t[8] = R(0x00C0); + t[9] = R(0x00D8); t[10] = R(0x00F0); t[11] = R(0x0108); + t[12] = R(0x0120); t[13] = R(0x0138); t[14] = R(0x0150); + t[15] = R(0x0168); t[16] = R(0x0180); t[17] = R(0x0198); + + if (fw >= 80) + { + t[18] = R(0x01B0); t[19] = R(0x01C8); t[20] = R(0x01E0); + t[21] = R(0x01F8); t[22] = R(0x0210); t[23] = R(0x0228); + } + if (fw >= 83) + { + // Slots 25-26 (Speed Fuel/Spark Comp) ship in FW 83, not 80 — + // populateInitTables gates these in a nested FW>=83 check. + t[24] = R(0x0240); t[25] = R(0x0258); + } + if (fw >= 90) + { + t[26] = R(0x0270); t[27] = R(0x0288); t[28] = R(0x02A0); + t[29] = R(0x02B8); t[30] = R(0x02D0); t[31] = R(0x02E8); + t[32] = R(0x0300); t[33] = R(0x0318); + } + if (fw >= 130) + { + t[34] = R(0x0330); t[35] = R(0x0348); t[36] = R(0x0360); + } + + return t; + } + + // ── Convenience ────────────────────────────────────────────────────────── + + /// + /// Returns all available 1D table regions in index order. + /// Skips Unavailable entries (FW-gated tables not present on this device). + /// + public IEnumerable<(int Index, MemoryRegion Region)> Available1DTables => + OneDimTables + .Select((r, i) => (i, r)) + .Where(x => x.r.IsAvailable); +} diff --git a/TuneBoss.Core/Models/MiscBitSpec.cs b/TuneBoss.Core/Models/MiscBitSpec.cs new file mode 100644 index 0000000..44d6553 --- /dev/null +++ b/TuneBoss.Core/Models/MiscBitSpec.cs @@ -0,0 +1,34 @@ +namespace TuneBoss.Core.Models; + +/// How a sub-field of a settings byte is edited. +public enum MiscEditorKind +{ + Flag, // single bit → checkbox + Enum, // bit range → combo (Options indexed by value) + Number, // bit range → numeric 0..(mask>>shift) +} + +/// +/// One sub-field occupying a contiguous bit range of a byte. +/// Value = (byte & Mask) >> shift(Mask); written back masked. +/// +public sealed record MiscBitField( + string Label, + int Mask, // e.g. 0x01 (flag), 0xF0 (high nibble), 0x7F (7-bit value) + MiscEditorKind Kind = MiscEditorKind.Flag, + string[]? Options = null) // Enum only: option labels indexed by value +{ + /// Human-readable label: underscores → spaces, shortforms expanded. + public string DisplayText => MiscDisplayText.For(Label); +} + +/// +/// Decomposition of a single settings byte into bit sub-fields, plus optional +/// inter-bit constraints (bit indices 0..7). +/// +public sealed record MiscByteSpec( + MiscBlock Block, + string FieldLabel, // must match a MiscField.Label in MiscFieldRegistry + MiscBitField[] Fields, + (int A, int B)[]? MutualExclusive = null, // checking one clears the other + (int A, int B)[]? Linked = null); // toggling one toggles the other diff --git a/TuneBoss.Core/Models/MiscBitSpecRegistry.cs b/TuneBoss.Core/Models/MiscBitSpecRegistry.cs new file mode 100644 index 0000000..a3d6370 --- /dev/null +++ b/TuneBoss.Core/Models/MiscBitSpecRegistry.cs @@ -0,0 +1,228 @@ +namespace TuneBoss.Core.Models; + +/// +/// Per-byte bit decompositions for the misc "settings" bytes. +/// Labels are taken verbatim from the legacy Form1.Designer.cs CheckedListBox / +/// ComboBox item strings (TuneBossPCAppBLE2026), so bit order is authoritative. +/// +/// KEYING: each spec attaches by (Block, FieldLabel); FieldLabel matches a MiscField.Label +/// in MiscFieldRegistry. Keys were resolved against the legacy core write-map +/// (returnBytes[N] = textBox(N+1)), so byte indices are exact. The flag bytes your model +/// left unnamed map to the raw placeholders: Core_8 (CamSync), Core_25 (Fuel_Settings2), +/// Core_31 (Spark_Settings), Core_33 (O2_Autotune_Enable), Core_120 (TPS_Accel_Type). +/// +/// MODEL FIX NEEDED — ShiftBoss Enable: byte 84 is the enable flags byte (legacy value +/// 15 = 0x0F), but MiscValues.cs currently names Core[84] "ShiftBoss_Retard_Degrees". +/// Rename that accessor (and its MiscFieldRegistry entry) to "ShiftBoss_Enable" so this +/// spec attaches. The real retard degrees is the low 7 bits of byte 88 (ShiftBoss_Spark_Retard_deg). +/// +public static class MiscBitSpecRegistry +{ + private static MiscBitField Flag(string label, int mask) => new(label, mask, MiscEditorKind.Flag); + private static MiscBitField Num (string label, int mask) => new(label, mask, MiscEditorKind.Number); + private static MiscBitField Enum(string label, int mask, params string[] opts) => new(label, mask, MiscEditorKind.Enum, opts); + + // VRS combo option labels (index = nibble value 0..15), from the designer. + private static readonly string[] VrsMilliVolt = { "10","14","20","28","40","56","80","110","150","215","300","425","600","850","1210","1715" }; + private static readonly string[] VrsBlanking = { "0","3.12","6.25","9.37","12.5","15.62","18.75","21.87","25","28.1","31.3","34.4","37.5","40.6","43.8","46.9" }; + + public static readonly IReadOnlyList All = new[] + { + // ── Crank CamSync Config — raw byte Core_8 (value 131 on test device) (rename Core_8 → Crank_CamSync_Config) + new MiscByteSpec(MiscBlock.Core, "Crank_CamSync_Config", new[] + { + Flag("MAP Sync - Enable", 0x01), + Flag("Rotation Sync - whole rotation compare", 0x02), + Flag("Rotation Sync - No min RPM", 0x04), + Flag("Rotation Sync - Disable", 0x08), + Flag("MAP Sync - sync TPS < 50pct", 0x10), + Flag("MAP Sync - disable min RPM", 0x20), + Flag("Unused [2025/03/06]", 0x40), + Flag("Startup Fixed Spark Trigger Tooth", 0x80), + }), + + // ── O2 Autotune Enable + new MiscByteSpec(MiscBlock.Core, "O2_Autotune_Enable", new[] + { + Flag("Enable Autotune", 0x01), + Flag("Average with current table value", 0x02), + Flag("Write to Fuel Table", 0x04), + Flag("Read initial value from Fuel Table", 0x08), + Flag("Ignore TPS State", 0x10), + Flag("Ignore RPM State", 0x20), + Flag("Unused [2025/04/24]", 0x40), + Flag("Enable Autotune in all conditions", 0x80), + }), + + // ── ShiftBoss Enable ─ bit2<->bit3 linked (DIN) + new MiscByteSpec(MiscBlock.Core, "ShiftBoss_Enable", new[] + { + Flag("Enable ShiftBoss", 0x01), + Flag("Unused [2025/04/25]", 0x02), + Flag("Enable DIN (uncheck for Analog)", 0x04), + Flag("Enable DIN (uncheck for Analog)", 0x08), + Flag("Enable AutoTrigger RPM", 0x10), + Flag("Use Fuel Cut 1D Table", 0x20), + Flag("Use Spark Cut 1D Table", 0x40), + Flag("Use Spark Retard 1D Table", 0x80), + }, + Linked: new[] { (2, 3) }), + + // ── ShiftBoss Spark Retard deg + new MiscByteSpec(MiscBlock.Core, "ShiftBoss_Spark_Retard_deg", new[] + { + Num ("Retard Degrees (0-127)", 0x7F), + Flag("Retard reference = Current Spark Angle", 0x80), + }), + + // ── ShiftBoss Input Active High + new MiscByteSpec(MiscBlock.Core, "ShiftBoss_Input_Active_High", new[] + { + Flag("Input Active High", 0x01), + }), + + // ── ShiftBoss Input Debounce ms + new MiscByteSpec(MiscBlock.Core, "ShiftBoss_Input_Debounce_ms", new[] + { + Num ("Debounce ms (0-63)", 0x3F), + Flag("Input Display - Engine Light", 0x40), + Flag("Input Display - Overheat Light", 0x80), + }), + + // ── MAP Settings + new MiscByteSpec(MiscBlock.Core, "MAP_Settings", new[] + { + Flag("Auto Temperature Correction", 0x01), + Flag("Baro Compensation Static", 0x02), + Flag("Static Error Detect", 0x04), + Flag("UNUSED", 0x08), + Flag("CamSync on MAP Hi->Lo transition", 0x10), + Flag("Cam sync use MAP tooth average", 0x20), + Flag("MAP Avg use tooth average", 0x40), + Flag("Unsync use Lowest MAP_Lo_Avg reading across 2 cycles", 0x80), + }), + + // ── TPS Accel Type + new MiscByteSpec(MiscBlock.Core, "TPS_Accel_Type", new[] + { + Enum("TPS source", 0x01, "TPS Raw", "TPS Percent"), + Enum("1D Table Raw", 0x02, "Start_Value", "Diff"), + Flag("Unused [2025/05/16]", 0x04), + Enum("1D Table Conv", 0x08, "Absolute PW", "% Table"), + Flag("Unused [2025/05/16] (0x10)", 0x10), + Flag("Unused [2025/05/16] (0x20)", 0x20), + Flag("Unused [2025/05/16] (0x40)", 0x40), + Flag("Unused [2025/05/16] (0x80)", 0x80), + }), + + // ── Fuel Settings + new MiscByteSpec(MiscBlock.Core, "Fuel_Settings", new[] + { + Enum("Reference Angle", 0x01, "End Angle", "Start Angle"), + Flag("2nd Injector Enable (see 0x80)", 0x02), + Flag("1D Fuel Idle Table - Enable", 0x04), + Flag("Unused [2025/07/04]", 0x08), + Flag("Combine Fuel Base Tables", 0x10), + Flag("Combine Fuel Adjustment Tables", 0x20), + Flag("Combine Fuel Angle Tables", 0x40), + Flag("AFR Table change to 2nd Injector Table (see 0x02)", 0x80), + }), + + // ── Fuel Settings 2 ─ bits1-2 form a MAP-source mode + new MiscByteSpec(MiscBlock.Core, "Fuel_Settings2", new[] + { + Flag("1D idle table MAP scaling factor (see 0x02)", 0x01), + Enum("Idle MAP source", 0x06, "MAP Avg", "Baro Static", "Map Lo Avg", "(reserved)"), + Flag("Unused [2025/07/04] (0x08)", 0x08), + Flag("Unused [2025/07/04] (0x10)", 0x10), + Flag("Unused [2025/07/04] (0x20)", 0x20), + Flag("Unused [2025/07/04] (0x40)", 0x40), + Flag("Enable Baro/Map scaling for 1D idle table", 0x80), + }), + + // ── Spark Settings + new MiscByteSpec(MiscBlock.Core, "Spark_Settings", new[] + { + Flag("Spark cut when fuel cut", 0x01), + Flag("Max dwell time clamping - Enable", 0x02), + Flag("OverCurrent dwell AutoClamp - Enable", 0x04), + Flag("Spark end time recalc - Enable", 0x08), + Flag("Combine Spark Base Tables", 0x10), + Flag("Combine Spark Adjust Tables", 0x20), + Enum("VBAT Table axis", 0x40, "RPM", "RawVal"), + Enum("Spark Table units", 0x80, "Degrees", "Timer ticks"), + }), + + // ── MC33814 VRS Misc Params + new MiscByteSpec(MiscBlock.Core, "MC33814_VRS_Misc_Params", new[] + { + Flag("Disable 2.5V reference", 0x01), + Flag("Swap VRSN & VRSP", 0x02), + Flag("Single ended mode (VRSN=GND)", 0x04), + Flag("De-glitch enable", 0x08), + Enum("Blanking time calc ref", 0x10, "High PW", "Low PW"), + Flag("reserved", 0x20), + Flag("Disable VRS", 0x40), + Flag("Automatic Mode VRS", 0x80), + }), + + // ── VRS Manual Control (Running): hi nibble = mV, lo nibble = blanking% + new MiscByteSpec(MiscBlock.Core, "MC33814_Cfg_VRS_Manual_Control", new[] + { + Enum("Running blanking %", 0x0F, VrsBlanking), + Enum("Running miliVolt", 0xF0, VrsMilliVolt), + }), + + // ── VRS Conditioner (Cranking): hi nibble = mV, lo nibble = blanking% + new MiscByteSpec(MiscBlock.Core, "MC33814_Ctrl_VRS_Conditioner", new[] + { + Enum("Cranking blanking %", 0x0F, VrsBlanking), + Enum("Cranking miliVolt", 0xF0, VrsMilliVolt), + }), + + // ── ISM Settings 1 (Extended/R25 block) ─ bit0/bit1 mutually exclusive (Mode) + new MiscByteSpec(MiscBlock.Extended, "ISM_Settings1", new[] + { + Flag("Mode - Test", 0x01), + Flag("Mode - Normal", 0x02), + Flag("Mode - Unused [2025/03/19]", 0x04), + Flag("Mode - Unused [2025/03/19]", 0x08), + Flag("Off Throttle ISM - Enable", 0x10), + Flag("OffThrottle ISM - Ignore TPS", 0x20), + Flag("Fixed position for Engine Start", 0x40), + Flag("ISM Auto target RPM", 0x80), + }, + MutualExclusive: new[] { (0, 1) }), + + // ── ISM PID Config (Extended block) + new MiscByteSpec(MiscBlock.Extended, "ISM_PID_Config", new[] + { + Flag("Init use stored target step", 0x01), + Flag("Clutch Input for stored tgt step", 0x02), + Flag("Speed Input for stored tgt step", 0x04), + Flag("Always enable stored tgt step", 0x08), + Flag("RPM ramp down detect", 0x10), + Flag("Reduce tgt step when > table val", 0x20), + Flag("Increase tgt step when < table val", 0x40), + Flag("Unused", 0x80), + }), + + // ── Mode Switch Settings (low nibble flags; high nibble = input selection 0-15) + new MiscByteSpec(MiscBlock.Extended, "Mode_Switch_Settings", new[] + { + Flag("Enable Mode Switch", 0x01), + Flag("Invert Input", 0x02), + Flag("Unused (0x04)", 0x04), + Flag("Unused (0x08)", 0x08), + Num ("Input selection (0-15)", 0xF0), + }), + }; + + /// Lookup a spec by block + field label, or null. + public static MiscByteSpec? Find(MiscBlock block, string label) + { + foreach (var s in All) + if (s.Block == block && s.FieldLabel == label) return s; + return null; + } +} diff --git a/TuneBoss.Core/Models/MiscDisplayText.cs b/TuneBoss.Core/Models/MiscDisplayText.cs new file mode 100644 index 0000000..33b6fdf --- /dev/null +++ b/TuneBoss.Core/Models/MiscDisplayText.cs @@ -0,0 +1,120 @@ +namespace TuneBoss.Core.Models; + +/// +/// Converts raw config field identifiers into human-readable display text: +/// underscores become spaces, and engineering shortforms expand to their meaning +/// (e.g. RPM_Limit_div100 → "RPM Limit (divided by 100)", +/// Fuel_Max_PW_Mult → "Fuel Max Pulse Width Multiplier"). +/// Unknown tokens pass through unchanged, so new fields degrade gracefully. +/// +public static class MiscDisplayText +{ + // Case-insensitive single-token expansions. + private static readonly Dictionary Map = new(StringComparer.OrdinalIgnoreCase) + { + // scaling / units + ["div100"] = "(divided by 100)", + ["div10"] = "(divided by 10)", + ["div5"] = "(divided by 5)", + ["x10"] = "(times 10)", + ["x100"] = "(times 100)", + ["ms"] = "(in milliseconds)", + ["5ms"] = "(in 5 ms steps)", + ["10ms"] = "(in 10 ms steps)", + ["100ms"] = "(in 100 ms steps)", + ["us"] = "(in microseconds)", + ["degC"] = "(in Celsius degrees)", + ["deg"] = "(in degrees)", + ["kph"] = "(in km/h)", + ["kmh"] = "(in km/h)", + ["pct"] = "Percent", + ["raw"] = "(raw)", + + // engineering shortforms + ["PW"] = "Pulse Width", + ["Decel"] = "Deceleration", + ["Accel"] = "Acceleration", + ["Etemp"] = "Engine Temperature", + ["VBAT"] = "Battery Voltage", + ["IAT"] = "Intake Air Temperature", + ["BARO"] = "Barometric", + ["NOS"] = "Nitrous", + ["ISM"] = "Idle Stepper Motor", + ["AIS"] = "Air Induction System", + ["O2H"] = "O2 Heater", + ["FC"] = "Fuel Consumption", + ["PerSec"] = "Per Second", + ["Hi"] = "High", + ["Lo"] = "Low", + ["Neg"] = "Negative", + ["Pos"] = "Positive", + ["Mult"] = "Multiplier", + ["Div"] = "Divider", + ["Num"] = "Number", + ["Init"] = "Initial", + ["Cfg"] = "Config", + ["Ctrl"] = "Control", + ["Rsvd"] = "Reserved", + ["Isol"] = "Idle Solenoid", + ["Ref"] = "Reference", + ["Retard"] = "Retard", + ["Solenoid"] = "Solenoid", + ["Samplepoint"] = "Sample Point", + }; + + // Case-SENSITIVE tokens (too dangerous to match loosely). + private static readonly Dictionary ExactMap = new(StringComparer.Ordinal) + { + ["s"] = "(in seconds)", + }; + + // Multi-token sequences consumed together (checked before single tokens). + private static readonly (string A, string B, string Text)[] Pairs = + { + ("ms", "div5", "(in milliseconds, divided by 5)"), + ("ms", "div10", "(in milliseconds, divided by 10)"), + }; + + private static readonly Dictionary Cache = new(); + + /// Display text for a raw field identifier. + public static string For(string raw) + { + if (string.IsNullOrEmpty(raw)) return raw; + lock (Cache) + { + if (Cache.TryGetValue(raw, out var hit)) return hit; + } + + var tokens = raw.Split('_', StringSplitOptions.RemoveEmptyEntries); + var outParts = new List(tokens.Length); + + for (int i = 0; i < tokens.Length; i++) + { + bool paired = false; + if (i + 1 < tokens.Length) + { + foreach (var (a, b, text) in Pairs) + { + if (tokens[i].Equals(a, StringComparison.OrdinalIgnoreCase) && + tokens[i + 1].Equals(b, StringComparison.OrdinalIgnoreCase)) + { + outParts.Add(text); + i++; // consume both + paired = true; + break; + } + } + } + if (paired) continue; + + if (ExactMap.TryGetValue(tokens[i], out var exact)) outParts.Add(exact); + else if (Map.TryGetValue(tokens[i], out var mapped)) outParts.Add(mapped); + else outParts.Add(tokens[i]); + } + + var result = string.Join(" ", outParts); + lock (Cache) { Cache[raw] = result; } + return result; + } +} diff --git a/TuneBoss.Core/Models/MiscFieldRegistry.cs b/TuneBoss.Core/Models/MiscFieldRegistry.cs new file mode 100644 index 0000000..859543d --- /dev/null +++ b/TuneBoss.Core/Models/MiscFieldRegistry.cs @@ -0,0 +1,349 @@ +namespace TuneBoss.Core.Models; + +/// Which raw misc block a field lives in. +public enum MiscBlock { Core, LaunchFuel, LaunchFuel2, AuxOut, Extended } + +/// One editable misc setting: a single raw byte in a block. +/// Generated from MiscValues.cs accessor map; unnamed bytes are exposed as +/// raw placeholders (rename in this file later). +public sealed record MiscField(string Section, string Label, MiscBlock Block, int Index) +{ + /// Human-readable label: underscores → spaces, shortforms expanded. + public string DisplayText => MiscDisplayText.For(Label); +} + +public static class MiscFieldRegistry +{ + public static readonly IReadOnlyList All = new MiscField[] + { + // ── Core ── + new("Crank", "Crank_Teeth", MiscBlock.Core, 0), + new("Crank", "Crank_Missing_Teeth", MiscBlock.Core, 1), + new("Crank", "Crank_Detect_Edge", MiscBlock.Core, 2), + new("Crank", "CrankTooth_Positive_Period_Pct", MiscBlock.Core, 3), + new("Crank", "CrankTooth_Negative_Period_Pct", MiscBlock.Core, 4), + new("Crank", "Crank_Timeout_Pct", MiscBlock.Core, 5), + new("Crank", "Crank_CamSync_Detect_Method", MiscBlock.Core, 6), + new("Crank", "Crank_CamSync_Detect_Cycle", MiscBlock.Core, 7), + new("Crank", "Crank_CamSync_Config", MiscBlock.Core, 8), + new("Crank", "Crank_CamSync_MAP_Detect_Cycle", MiscBlock.Core, 9), + new("Crank", "Crank_CamSync_Rotation_Tooth", MiscBlock.Core, 10), + new("Crank", "Crank_CamSync_Num_Fast_Rotations", MiscBlock.Core, 11), + new("RPM", "RPM_Limit_div100", MiscBlock.Core, 12), + new("RPM", "RPM_Limit_Recovery_div100", MiscBlock.Core, 13), + new("RPM", "RPM_Limit_Failsafe_div100", MiscBlock.Core, 14), + new("RPM", "RPM_Limit_Failsafe_Recovery_div100", MiscBlock.Core, 15), + new("RPM", "RPM_Detect_Min_div100", MiscBlock.Core, 16), + new("RPM", "RPM_Detect_Min_Recovery_div100", MiscBlock.Core, 17), + new("RPM", "RPM_Stall_div100", MiscBlock.Core, 18), + new("RPM", "RPM_Stall_Recovery_div100", MiscBlock.Core, 19), + new("RPM", "RPM_Decel_Threshold_PerSec_div100", MiscBlock.Core, 20), + new("RPM", "RPM_Accel_Threshold_PerSec_div100", MiscBlock.Core, 21), + new("RPM", "RPM_Meter_Divider", MiscBlock.Core, 22), + new("Fuel", "Fuel_Settings", MiscBlock.Core, 23), + new("Fuel", "Fuel_Max_PW_Mult", MiscBlock.Core, 24), + new("Fuel", "Fuel_Settings2", MiscBlock.Core, 25), + new("Fuel", "Fuel_Cut_Min_LOAD", MiscBlock.Core, 26), + new("Fuel", "Fuel_Cut_Min_TPS_pct", MiscBlock.Core, 27), + new("Fuel", "Fuel_Cut_Min_RPM_div100", MiscBlock.Core, 28), + new("Fuel", "Fuel_Cut_Disable_LOAD", MiscBlock.Core, 29), + new("Fuel", "Fuel_Cut_Min_Etemp_degC", MiscBlock.Core, 30), + new("Fuel", "Spark_Settings", MiscBlock.Core, 31), + new("Fuel", "VBAT_Trim_deciV", MiscBlock.Core, 32), + new("Fuel", "O2_Autotune_Enable", MiscBlock.Core, 33), + new("O2 Sensor / Autotune", "O2_Sensor_Sample_Rate_ms", MiscBlock.Core, 34), + new("O2 Sensor / Autotune", "O2_Sensor_Delay_ms_div5", MiscBlock.Core, 35), + new("O2 Sensor / Autotune", "O2_Fuel_Max_Add_Pct", MiscBlock.Core, 36), + new("O2 Sensor / Autotune", "O2_Fuel_Max_Sub_Pct", MiscBlock.Core, 37), + new("O2 Sensor / Autotune", "O2_Autotune_Max_RPM_div100", MiscBlock.Core, 38), + new("O2 Sensor / Autotune", "O2_Autotune_Min_RPM_div100", MiscBlock.Core, 39), + new("O2 Sensor / Autotune", "O2_Autotune_Max_Load", MiscBlock.Core, 40), + new("O2 Sensor / Autotune", "O2_Autotune_Min_Load", MiscBlock.Core, 41), + new("O2 Sensor / Autotune", "O2_Autotune_StepUp_Pct", MiscBlock.Core, 42), + new("O2 Sensor / Autotune", "O2_Autotune_Average_Weight", MiscBlock.Core, 43), + new("O2 Sensor / Autotune", "O2_Autotune_AFR_x10_Diff", MiscBlock.Core, 44), + new("O2 Sensor / Autotune", "O2_Autotune_Start_Delay_s", MiscBlock.Core, 45), + new("O2 Sensor / Autotune", "O2_Autotune_Min_ETemp", MiscBlock.Core, 46), + new("O2 Sensor / Autotune", "O2_Autotune_Max_ETemp", MiscBlock.Core, 47), + new("TPS", "TPS_Accel_Threshold_PctPer100ms", MiscBlock.Core, 48), + new("TPS", "TPS_Decel_Threshold_PctPer100ms", MiscBlock.Core, 49), + new("TPS", "TPS_Threshold_10ms_sample_gap", MiscBlock.Core, 50), + new("TPS", "TPS_Accel_Fuel_Adjust_Hold_Time_10ms", MiscBlock.Core, 51), + new("TPS", "TPS_Accel_Fuel_Adjust_Decay_Time_10ms", MiscBlock.Core, 52), + new("TPS", "TPS_Accel_Spark_Adjust_Hold_Time_10ms", MiscBlock.Core, 53), + new("TPS", "TPS_Accel_Spark_Adjust_Decay_Time_10ms", MiscBlock.Core, 54), + new("TPS", "TPS_Steady_State_Delay_Time_10ms", MiscBlock.Core, 55), + new("MAP", "MAP_Settings", MiscBlock.Core, 56), + new("MAP", "MAP_Lo_Hyst_Mult", MiscBlock.Core, 57), + new("MAP", "MAP_Ref_Temp_DegC", MiscBlock.Core, 58), + new("MAP", "MAP_Intake_Tooth_End", MiscBlock.Core, 59), + new("MAP", "MAP_Intake_Num_Teeth", MiscBlock.Core, 60), + new("MAP", "MAP_Baro_Tooth_End", MiscBlock.Core, 61), + new("MAP", "MAP_Baro_Num_Teeth", MiscBlock.Core, 62), + new("MAP", "MAP_Baro_RPM_div100_Limit", MiscBlock.Core, 63), + new("MAP", "MAP_Baro_TPS_Limit", MiscBlock.Core, 64), + new("MAP", "MAP_Baro_Static_Delay_10ms", MiscBlock.Core, 65), + new("MAP", "MAP_Settings2", MiscBlock.Core, 66), + new("Radiator / Overheat", "RadFan_On_Temp_DegC", MiscBlock.Core, 67), + new("Radiator / Overheat", "RadFan_Off_Temp_DegC", MiscBlock.Core, 68), + new("Radiator / Overheat", "Etemp_Overheat_On_Temp_DegC", MiscBlock.Core, 69), + new("Radiator / Overheat", "Etemp_Overheat_Off_Temp_DegC", MiscBlock.Core, 70), + new("Radiator / Overheat", "Etemp_Sensor_Error_Temp", MiscBlock.Core, 71), + new("Bluetooth / MC33814", "Bluetooth_PowerOn_Timeout_s", MiscBlock.Core, 72), + new("Bluetooth / MC33814", "MC33814_Init_Delay_10ms", MiscBlock.Core, 73), + new("Bluetooth / MC33814", "MC33814_Tacho_Control", MiscBlock.Core, 74), + new("Bluetooth / MC33814", "MC33814_VRS_Misc_Params", MiscBlock.Core, 75), + new("Bluetooth / MC33814", "MC33814_Cfg_VRS_Manual_Control", MiscBlock.Core, 76), + new("Bluetooth / MC33814", "MC33814_Ctrl_VRS_Conditioner", MiscBlock.Core, 77), + new("Fuel Pump / Solenoid", "Fuel_Pump_Timeout_100ms", MiscBlock.Core, 78), + new("Fuel Pump / Solenoid", "Idle_Solenoid_Off_Tooth", MiscBlock.Core, 79), + new("Fuel Pump / Solenoid", "Idle_Solenoid_Reset_RPM_div100", MiscBlock.Core, 80), + new("Fuel Pump / Solenoid", "Idle_Solenoid_Step_Down", MiscBlock.Core, 81), + new("Fuel Pump / Solenoid", "Idle_Solenoid_PID_Kp", MiscBlock.Core, 82), + new("Fuel Pump / Solenoid", "Idle_Solenoid_Min_Open_Angle_deg", MiscBlock.Core, 83), + new("ShiftBoss", "ShiftBoss_Enable", MiscBlock.Core, 84), + new("ShiftBoss", "ShiftBoss_Fuel_Cut_ms", MiscBlock.Core, 85), + new("ShiftBoss", "ShiftBoss_Spark_Cut_ms", MiscBlock.Core, 86), + new("ShiftBoss", "ShiftBoss_Spark_Retard_ms", MiscBlock.Core, 87), + new("ShiftBoss", "ShiftBoss_Spark_Retard_deg", MiscBlock.Core, 88), + new("ShiftBoss", "ShiftBoss_Interval_Time_10ms", MiscBlock.Core, 89), + new("ShiftBoss", "ShiftBoss_Min_RPM_div100", MiscBlock.Core, 90), + new("ShiftBoss", "ShiftBoss_Input_Active_High", MiscBlock.Core, 91), + new("ShiftBoss", "ShiftBoss_Input_Debounce_ms", MiscBlock.Core, 92), + new("ShiftBoss", "ShiftBoss_Autotrigger_RPM_div100", MiscBlock.Core, 93), + new("Load selection", "Load_Primary_Select", MiscBlock.Core, 94), + new("Load selection", "Load_Fuel_PulseWidth1_Select", MiscBlock.Core, 95), + new("Load selection", "Load_Spark_Angle1_Select", MiscBlock.Core, 96), + new("Load selection", "Load_AFR_Target1_Select", MiscBlock.Core, 97), + new("Load selection", "Load_Fuel_Angle2D_Select", MiscBlock.Core, 98), + new("Load selection", "Load_Fuel_PulseWidth_Adjust1_Select", MiscBlock.Core, 99), + new("Load selection", "Load_Spark_Angle_Adjust1_Select", MiscBlock.Core, 100), + new("Extended config", "VBAT_Min_deciV", MiscBlock.Core, 101), + new("Extended config", "VBAT_Max_deciV", MiscBlock.Core, 102), + new("Extended config", "O2_Sensor_Present", MiscBlock.Core, 103), + new("Extended config", "VDS_Present", MiscBlock.Core, 104), + new("Extended config", "TPS_Accel_Taper_Start_RPM_div100", MiscBlock.Core, 105), + new("Extended config", "TPS_Accel_Taper_End_RPM_div100", MiscBlock.Core, 106), + new("Extended config", "Error_Check_Startup_Delay", MiscBlock.Core, 107), + new("Extended config", "ErrorLog_Recording_Delay", MiscBlock.Core, 108), + new("Extended config", "ShiftLight_On_RPM_div100", MiscBlock.Core, 109), + new("Extended config", "ShiftLight_Off_RPM_div100", MiscBlock.Core, 110), + new("Extended config", "ShiftLight_Output_Select", MiscBlock.Core, 111), + new("Extended config", "MC33814_Lamp_Config", MiscBlock.Core, 112), + new("Extended config", "MC33814_O2H_Config", MiscBlock.Core, 113), + new("Extended config", "VBAT_Longterm_Min_DeciV", MiscBlock.Core, 114), + new("Extended config", "ErrorLog_MC33814_Mask_Lo", MiscBlock.Core, 115), + new("Extended config", "ErrorLog_MC33814_Mask_Hi", MiscBlock.Core, 116), + new("Extended config", "ErrorLog_MC33814_EngineOff_Enable", MiscBlock.Core, 117), + new("Extended config", "ErrorLog_MC33814_OL_Hysteresis", MiscBlock.Core, 118), + new("Extended config", "ErrorLog_MC33814_Killswitch_Mask", MiscBlock.Core, 119), + new("Extended config", "TPS_Accel_Type", MiscBlock.Core, 120), + new("Extended config", "TPS_Accel_Fuel_TempComp", MiscBlock.Core, 121), + new("Extended config", "TPS_Accel_Threshold_Fast_PctPer100ms", MiscBlock.Core, 122), + new("Extended config", "TPS_Decel_Fuel_Adjust_Pct", MiscBlock.Core, 123), + new("Extended config", "TPS_Accel_Modifier_Cyclecount", MiscBlock.Core, 124), + new("Extended config", "TPS_Accel_Threshold_SuperFast_PctPer100ms", MiscBlock.Core, 125), + new("Extended config", "VBAT_longterm_min_DeciV", MiscBlock.Core, 126), + new("Extended config", "ErrorLog_MC33814_SafeMode_Trigger_Lo", MiscBlock.Core, 127), + new("Extended config", "ErrorLog_MC33814_SafeMode_Trigger_Hi", MiscBlock.Core, 128), + new("Extended config", "VDS_Time_Delay_100ms", MiscBlock.Core, 129), + new("Extended config", "UM_Stop_Timer_Delay_100ms", MiscBlock.Core, 130), + new("Extended config", "Start_Fuel_Enrichment_Hold_100ms", MiscBlock.Core, 131), + new("Extended config", "Start_Fuel_Enrichment_Decay_100ms", MiscBlock.Core, 132), + new("Extended config", "TPS_Accel_Recursive_Accel", MiscBlock.Core, 133), + new("Extended config", "Idle_Solenoid_Reset_Timeout_100ms", MiscBlock.Core, 134), + new("Extended config", "Speed_Adjust_Percent", MiscBlock.Core, 135), + // ── LaunchFuel (spark/fuel reference angles + init) ── + new("Timing", "RPM_Table_2Samplepoint_div100", MiscBlock.LaunchFuel, 0), + new("Timing", "Fuel_Init_Cycles", MiscBlock.LaunchFuel, 1), + new("Timing", "Idle_Solenoid_Settings", MiscBlock.LaunchFuel, 2), + new("Timing", "Spark_Ref_Angle_Lo", MiscBlock.LaunchFuel, 3), + new("Timing", "Spark_Ref_Angle_Hi", MiscBlock.LaunchFuel, 4), + new("Timing", "Fuel_Ref_Angle_Lo", MiscBlock.LaunchFuel, 5), + new("Timing", "Fuel_Ref_Angle_Hi", MiscBlock.LaunchFuel, 6), + new("Timing", "Fuel_Base_PW_ms_x10", MiscBlock.LaunchFuel, 7), + new("Timing", "Spark2_Ref_Angle_Lo", MiscBlock.LaunchFuel, 8), + new("Timing", "Spark2_Ref_Angle_Hi", MiscBlock.LaunchFuel, 9), + new("Timing", "Fuel2_Ref_Angle_Lo", MiscBlock.LaunchFuel, 10), + new("Timing", "Fuel2_Ref_Angle_Hi", MiscBlock.LaunchFuel, 11), + // ── LaunchFuel2 (launch control + rad fan) ── + new("Launch Control", "TBD_Unused", MiscBlock.LaunchFuel2, 0), + new("Launch Control", "LaunchBoss_Enable", MiscBlock.LaunchFuel2, 1), + new("Launch Control", "LaunchBoss_Settings", MiscBlock.LaunchFuel2, 2), + new("Launch Control", "LaunchBoss_RPM_Limit_Start_div100", MiscBlock.LaunchFuel2, 3), + new("Launch Control", "LaunchBoss_RPM_Limit_End_div100", MiscBlock.LaunchFuel2, 4), + new("Launch Control", "LaunchBoss_RPM_Persec_Up_Rate_div100", MiscBlock.LaunchFuel2, 5), + new("Launch Control", "LaunchBoss_RPM_Up_Speed_Start_kph", MiscBlock.LaunchFuel2, 6), + new("Launch Control", "LaunchBoss_Speed_End_kph", MiscBlock.LaunchFuel2, 7), + new("Launch Control", "LaunchBoss_Spark_Retard_deg", MiscBlock.LaunchFuel2, 8), + new("Launch Control", "RadFan_Settings", MiscBlock.LaunchFuel2, 9), + new("Launch Control", "RadFan_PWM_Width_100ms", MiscBlock.LaunchFuel2, 10), + new("Launch Control", "Analog_Safe_Mode_Trigger", MiscBlock.LaunchFuel2, 11), + // ── AuxOut ── + new("General", "AuxOut_Control", MiscBlock.AuxOut, 0), + new("General", "AuxOut_Control2", MiscBlock.AuxOut, 1), + new("General", "RadFan_On_Temp_NOS_RPM", MiscBlock.AuxOut, 2), + new("General", "RadFan_Off_Temp_NOS_TPS", MiscBlock.AuxOut, 3), + new("General", "NOS_Speed", MiscBlock.AuxOut, 4), + new("General", "AuxOut_Ref_Value2_Off", MiscBlock.AuxOut, 5), + new("General", "AuxOut_Delay1_10ms", MiscBlock.AuxOut, 6), + new("General", "AuxOut_Delay2_10ms", MiscBlock.AuxOut, 7), + new("General", "Idle_Threshold_TPS", MiscBlock.AuxOut, 8), + new("General", "Idle_Threshold_RPM_div100", MiscBlock.AuxOut, 9), + new("General", "Spark_Dwell_Max_100us", MiscBlock.AuxOut, 10), + new("General", "Spark_Dwell_Min_100us", MiscBlock.AuxOut, 11), + // ── Extended ── + new("Spark tab", "Spark_Dwell_Reduction_10us", MiscBlock.Extended, 0), + new("Spark tab", "Spark_Dwell_Min_Deg", MiscBlock.Extended, 1), + new("Spark tab", "Spark_Dwell_Max_Deg_div4", MiscBlock.Extended, 2), + new("Spark tab", "Spark_Dwell_Reserved1", MiscBlock.Extended, 3), + new("Spark tab", "Crank_MissingTooth2_Pos_Period_Mult", MiscBlock.Extended, 4), + new("Spark tab", "Crank_MissingTooth2_Neg_Period_Mult", MiscBlock.Extended, 5), + new("Spark tab", "Crank_MissingTooth_Pos_Period_Mult", MiscBlock.Extended, 6), + new("Spark tab", "Crank_MissingTooth_Neg_Period_Mult", MiscBlock.Extended, 7), + new("Spark tab", "VRS_Threshold_Lo_RPM_div100", MiscBlock.Extended, 8), + new("Spark tab", "VRS_Threshold_Hi_RPM_div100", MiscBlock.Extended, 9), + new("Spark tab", "Spark_Cut_Retard1_RPM_Gap_div100", MiscBlock.Extended, 10), + new("Spark tab", "Spark_Cut_Retard2_RPM_Gap_div100", MiscBlock.Extended, 11), + new("Spark tab", "Spark_Cut_Retard1", MiscBlock.Extended, 12), + new("Spark tab", "Spark_Cut_Retard2", MiscBlock.Extended, 13), + new("Spark tab", "CrankTooth_Pos_Period_Mult_Run", MiscBlock.Extended, 14), + new("Spark tab", "CrankTooth_Neg_Period_Mult_Run", MiscBlock.Extended, 15), + new("Spark tab", "Gear_Ratio_Hysteresis_Count", MiscBlock.Extended, 16), + new("Spark tab", "Gear_Ratio_min_RPM_div100", MiscBlock.Extended, 17), + new("TC tab", "TC_Settings1", MiscBlock.Extended, 18), + new("TC tab", "TC_Settings2", MiscBlock.Extended, 19), + new("TC tab", "TC_Rpm_Min_div100", MiscBlock.Extended, 20), + new("TC tab", "TC_Rpm_Max_div100", MiscBlock.Extended, 21), + new("TC tab", "TC_TPS_Min", MiscBlock.Extended, 22), + new("TC tab", "TC_TPS_Max", MiscBlock.Extended, 23), + new("TC tab", "TC_Speed_Min", MiscBlock.Extended, 24), + new("TC tab", "TC_Speed_Max", MiscBlock.Extended, 25), + new("TC tab", "TC_Consecutive_Error_Trigger", MiscBlock.Extended, 26), + new("TC tab", "TC_Retard_Off_Ramp_deg_per100ms", MiscBlock.Extended, 27), + new("TC tab", "TC_Table_Input_Selection", MiscBlock.Extended, 28), + new("TC tab", "TC_Sample_Rate_ms", MiscBlock.Extended, 29), + new("TC tab", "TC_Speed_Tooth_Skip", MiscBlock.Extended, 30), + new("TC tab", "TC_Tooth_Average_Count", MiscBlock.Extended, 31), + new("TC tab", "TC_Tooth_Compare_Count", MiscBlock.Extended, 32), + new("TC tab", "TC_Gear_Max", MiscBlock.Extended, 33), + new("TC tab", "TC_Button_Modes", MiscBlock.Extended, 34), + new("TC tab", "TC_Button_Sensitivity_Modifier", MiscBlock.Extended, 35), + new("TC tab", "TC_Button_Delay_100ms", MiscBlock.Extended, 36), + new("TC tab", "TC_Tooth_Undriven_Count", MiscBlock.Extended, 37), + new("TC tab", "TC_Reserved6", MiscBlock.Extended, 38), + new("TC tab", "Offthrottle_Threshold_TPS", MiscBlock.Extended, 39), + new("TC tab", "Idle_Rumble_Min_Rpm_div100", MiscBlock.Extended, 40), + new("TC tab", "Speed_Settings1", MiscBlock.Extended, 41), + new("ISM tab", "ISM_Settings1", MiscBlock.Extended, 42), + new("ISM tab", "ISM_Startup_Delay_10ms", MiscBlock.Extended, 43), + new("ISM tab", "ISM_Max_Steps_Lo", MiscBlock.Extended, 44), + new("ISM tab", "ISM_Max_Steps_Hi", MiscBlock.Extended, 45), + new("ISM tab", "ISM_CR0_Init", MiscBlock.Extended, 46), + new("ISM tab", "ISM_CR1_Init", MiscBlock.Extended, 47), + new("ISM tab", "ISM_CR2_Init", MiscBlock.Extended, 48), + new("ISM tab", "ISM_Test_Step_Lo", MiscBlock.Extended, 49), + new("ISM tab", "ISM_Test_Step_Hi", MiscBlock.Extended, 50), + new("ISM tab", "ISM_Off_Delay_10ms", MiscBlock.Extended, 51), + new("ISM tab", "ISM_Max_Open_Steps_Per_Cycle", MiscBlock.Extended, 52), + new("ISM tab", "ISM_Max_Close_Steps_Per_Cycle", MiscBlock.Extended, 53), + new("ISM tab", "ISM_CR0_Run", MiscBlock.Extended, 54), + new("ISM tab", "ISM_CR0_Hold", MiscBlock.Extended, 55), + new("ISM tab", "ISM_Calibrate_Overshoot_Steps", MiscBlock.Extended, 56), + new("ISM tab", "ISM_PID_Delay_5ms", MiscBlock.Extended, 57), + new("ISM tab", "ISM_PID_Kp_lo", MiscBlock.Extended, 58), + new("ISM tab", "ISM_PID_Kp_hi", MiscBlock.Extended, 59), + new("ISM tab", "ISM_PID_Ki_lo", MiscBlock.Extended, 60), + new("ISM tab", "ISM_PID_Ki_hi", MiscBlock.Extended, 61), + new("ISM tab", "ISM_PID_Kd_lo", MiscBlock.Extended, 62), + new("ISM tab", "ISM_PID_Kd_hi", MiscBlock.Extended, 63), + new("ISM tab", "ISM_PID_Error_Threshold", MiscBlock.Extended, 64), + new("ISM tab", "ISM_PID_Config", MiscBlock.Extended, 65), + new("ISM tab", "ISM_Start_Boost_Step_raw", MiscBlock.Extended, 66), + new("ISM tab", "ISM_Stall_Boost_Step_raw", MiscBlock.Extended, 67), + new("ISM tab", "ISM_Start_Boost_Step_Delay_100ms", MiscBlock.Extended, 68), + new("ISM tab", "ISM_Stall_Boost_Step_Delay_100ms", MiscBlock.Extended, 69), + new("ISM tab", "ISM_Stall_Boost_RPM_div100", MiscBlock.Extended, 70), + new("ISM tab", "ISM_Boost_Step_Mult", MiscBlock.Extended, 71), + new("ISM tab", "ISM_PID_Gain_Mult", MiscBlock.Extended, 72), + new("ISM tab", "ISM_PID_Gain_Div_ShiftRight", MiscBlock.Extended, 73), + new("ISM tab", "ISM_PID_RPM_Rampdown_Rate", MiscBlock.Extended, 74), + new("ISM tab", "ISM_Rsvd22", MiscBlock.Extended, 75), + new("AIS tab", "AIS_Settings1", MiscBlock.Extended, 76), + new("AIS tab", "AIS_Settings2", MiscBlock.Extended, 77), + new("AIS tab", "AIS_RPM_Threshold1", MiscBlock.Extended, 78), + new("AIS tab", "AIS_TPS_Threshold1", MiscBlock.Extended, 79), + new("AIS tab", "AIS_RPM_Threshold2", MiscBlock.Extended, 80), + new("AIS tab", "AIS_TPS_Threshold2", MiscBlock.Extended, 81), + new("AIS tab", "AIS_RPM_Threshold3", MiscBlock.Extended, 82), + new("AIS tab", "AIS_TPS_Threshold3", MiscBlock.Extended, 83), + new("O2Heater tab", "AIS_Delay1_10ms", MiscBlock.Extended, 84), + new("O2Heater tab", "AIS_Settings10", MiscBlock.Extended, 85), + new("O2Heater tab", "ETEMP_Sensor_Sample_Rate_ms", MiscBlock.Extended, 86), + new("O2Heater tab", "IAT_Sensor_Sample_Rate_ms", MiscBlock.Extended, 87), + new("O2Heater tab", "O2Heater_Settings1", MiscBlock.Extended, 88), + new("O2Heater tab", "O2Heater_Settings2", MiscBlock.Extended, 89), + new("O2Heater tab", "O2Heater_Delay1_10ms", MiscBlock.Extended, 90), + new("O2Heater tab", "O2Heater_Settings4", MiscBlock.Extended, 91), + new("O2Heater tab", "O2Heater_Settings5", MiscBlock.Extended, 92), + new("O2Heater tab", "O2Heater_Settings6", MiscBlock.Extended, 93), + new("O2Heater tab", "ShiftBoss_Spark_RampDown_ms", MiscBlock.Extended, 94), + new("O2Heater tab", "ShiftBoss_Spark_RampUp_ms", MiscBlock.Extended, 95), + new("O2Heater tab", "VBAT_UVReset_DeciV", MiscBlock.Extended, 96), + new("O2Heater tab", "O2Heater_Settings10", MiscBlock.Extended, 97), + new("O2Heater tab", "LaunchBoss_Settings3", MiscBlock.Extended, 98), + new("O2Heater tab", "LaunchBoss_RPM_Limit_Fixed_div100", MiscBlock.Extended, 99), + new("O2Autotune tab", "O2_Autotune_Settings2", MiscBlock.Extended, 100), + new("O2Autotune tab", "O2_Autotune_Cylinder_Correct", MiscBlock.Extended, 101), + new("O2Autotune tab", "O2_Autotune_Cylinder_Write", MiscBlock.Extended, 102), + new("O2Autotune tab", "O2_Autotune_Settings5", MiscBlock.Extended, 103), + new("O2Autotune tab", "VRS_Settings1", MiscBlock.Extended, 104), + new("O2Autotune tab", "MC33814_VRS_MaxVolt_Val", MiscBlock.Extended, 105), + new("O2Autotune tab", "MC33814_Relay1_Config", MiscBlock.Extended, 106), + new("O2Autotune tab", "MC33814_Relay2_Config", MiscBlock.Extended, 107), + new("MCU Tacho tab", "MCU_Tacho_Settings1", MiscBlock.Extended, 108), + new("MCU Tacho tab", "MCU_Tacho_Divider", MiscBlock.Extended, 109), + new("MCU Tacho tab", "MCU_Tacho_Settings3", MiscBlock.Extended, 110), + new("MCU Tacho tab", "MCU_Tacho_Settings4", MiscBlock.Extended, 111), + new("MCU Tacho tab", "Meter_Speed_Mult", MiscBlock.Extended, 112), + new("MCU Tacho tab", "Meter_Speed_Div", MiscBlock.Extended, 113), + new("MCU Tacho tab", "Meter_Speed_Test", MiscBlock.Extended, 114), + new("MCU Tacho tab", "Meter_FC_Mult", MiscBlock.Extended, 115), + new("VVA tab", "VVA_Settings1", MiscBlock.Extended, 116), + new("VVA tab", "VVA_Settings2", MiscBlock.Extended, 117), + new("VVA tab", "VVA_Settings3", MiscBlock.Extended, 118), + new("VVA tab", "VVA_Settings4", MiscBlock.Extended, 119), + new("VVA tab", "VVA_Etemp_HiVal", MiscBlock.Extended, 120), + new("VVA tab", "VVA_Etemp_LoVal", MiscBlock.Extended, 121), + new("VVA tab", "VVA_EngineOn_Delay1_100ms", MiscBlock.Extended, 122), + new("VVA tab", "VVA_EngineOn_Delay2_10ms", MiscBlock.Extended, 123), + new("VVA tab", "VVA_On_RPM_div100", MiscBlock.Extended, 124), + new("VVA tab", "VVA_Off_RPM_div100", MiscBlock.Extended, 125), + new("VVA tab", "VVA_On_TPS_pct", MiscBlock.Extended, 126), + new("VVA tab", "VVA_Off_TPS_pct", MiscBlock.Extended, 127), + new("VVA tab", "VVA_On_Stage1_PWM_Pct", MiscBlock.Extended, 128), + new("VVA tab", "VVA_On_Stage1_Delay_10ms", MiscBlock.Extended, 129), + new("VVA tab", "VVA_On_Stage2_PWM_Pct", MiscBlock.Extended, 130), + new("VVA tab", "VVA_On_Stage2_Delay_10ms", MiscBlock.Extended, 131), + new("VVA tab", "VVA_On_Stage3_PWM_Pct", MiscBlock.Extended, 132), + new("VVA tab", "VVA_On_Stage3_Delay_10ms", MiscBlock.Extended, 133), + new("VVA tab", "VVA_On_Stage4_PWM_Pct", MiscBlock.Extended, 134), + new("VVA tab", "VVA_On_Stage4_Delay_10ms", MiscBlock.Extended, 135), + new("VVA tab", "VVA_On_TableSwap_Delay_ms_lo", MiscBlock.Extended, 136), + new("VVA tab", "VVA_On_TableSwap_Delay_ms_hi", MiscBlock.Extended, 137), + new("VVA tab", "VVA_Off_TableSwap_Delay_ms_lo", MiscBlock.Extended, 138), + new("VVA tab", "VVA_Off_TableSwap_Delay_ms_hi", MiscBlock.Extended, 139), + new("VVA tab", "VVA_On_Tooth", MiscBlock.Extended, 140), + new("VVA tab", "VVA_Off_Tooth", MiscBlock.Extended, 141), + new("VVA tab", "VVA_HiSide_Toggle_Gap_Rpm_div100", MiscBlock.Extended, 142), + new("VVA tab", "VVA_ErrorCheck_Delay_10ms", MiscBlock.Extended, 143), + new("VVA tab", "VVA_Rsvd9", MiscBlock.Extended, 144), + new("VVA tab", "VVA_Rsvd10", MiscBlock.Extended, 145), + new("VVA tab", "VVA_Rsvd11", MiscBlock.Extended, 146), + new("VVA tab", "VVA_Rsvd12", MiscBlock.Extended, 147), + new("VVA tab", "MAP_Error_Value_Fixed", MiscBlock.Extended, 148), + new("VVA tab", "TPS_Error_Value_Fixed", MiscBlock.Extended, 149), + new("VVA tab", "Digital_Input_Mask", MiscBlock.Extended, 150), + new("VVA tab", "Mode_Switch_Settings", MiscBlock.Extended, 151), + }; +} diff --git a/TuneBoss.Core/Models/MiscValues.cs b/TuneBoss.Core/Models/MiscValues.cs new file mode 100644 index 0000000..1ed1a5e --- /dev/null +++ b/TuneBoss.Core/Models/MiscValues.cs @@ -0,0 +1,482 @@ +namespace TuneBoss.Core.Models; + +/// +/// All ECU configuration parameters outside the 2D/1D tuning tables. +/// +/// Five memory regions, each read via APP_MEMRD_MISC. Addresses from +/// GenerationConfig; regions beyond Core gated on EcuInfo.FwVersion >= 150. +/// +/// Region Address field Size FW gate +/// ──────────── ───────────────────────── ─────── ──────── +/// Core miscValStartAddress 136 B always +/// LaunchFuel extraPaddingStartAddress 12 B FW >= 150 +/// LaunchFuel2 extraPaddingStartAddress2 12 B FW >= 150 +/// AuxOut extraPaddingStartAddress3 12 B FW >= 150 +/// Extended extraPaddingStartAddress4 var B FW >= 150 +/// (FW2_SubVersion & 0x80) == 0 → 0x73 (116 B, up to Ex(115)) +/// (FW2_SubVersion & 0x80) != 0 → 0x97 (152 B, full set) +/// +/// Extended label map is authoritative — derived from: +/// READ: UpdateMiscValuesExtraPadding4New() in Form1_Utils.cs +/// WRITE: getMiscValByteArrayExtraPadding4New() in Form1_TableHandling.cs +/// LABELS: Designer.cs parsed per inner tab of tabControl14 (Spark/TC/ISM/ +/// AIS/O2Heater/O2Autotune/MCU Tacho/VVA) inside tabPage93. +/// Each inner tab parsed independently to avoid cross-column pollution. +/// +public sealed class MiscValues +{ + // ── Raw memory regions ─────────────────────────────────────────────────── + public byte[] Core { get; init; } = new byte[136]; + public byte[] LaunchFuel { get; init; } = Array.Empty(); + public byte[] LaunchFuel2 { get; init; } = Array.Empty(); + public byte[] AuxOut { get; init; } = Array.Empty(); + public byte[] Extended { get; init; } = Array.Empty(); + + // ════════════════════════════════════════════════════════════════════════ + // CORE — 136 bytes (tabControl4, tabPage3 through tabPage2) + // ════════════════════════════════════════════════════════════════════════ + + // ── Crank [0–11] ───────────────────────────────────────────────────────── + public byte Crank_Teeth => Core[0]; + public byte Crank_Missing_Teeth => Core[1]; + public byte Crank_Detect_Edge => Core[2]; + public byte CrankTooth_Positive_Period_Pct => Core[3]; + public byte CrankTooth_Negative_Period_Pct => Core[4]; + public byte Crank_Timeout_Pct => Core[5]; + public byte Crank_CamSync_Detect_Method => Core[6]; + public byte Crank_CamSync_Detect_Cycle => Core[7]; + // [8] reserved + public byte Crank_CamSync_MAP_Detect_Cycle => Core[9]; + public byte Crank_CamSync_Rotation_Tooth => Core[10]; + public byte Crank_CamSync_Num_Fast_Rotations => Core[11]; + + // ── RPM [12–22] ────────────────────────────────────────────────────────── + public byte RPM_Limit_div100 => Core[12]; + public byte RPM_Limit_Recovery_div100 => Core[13]; + public byte RPM_Limit_Failsafe_div100 => Core[14]; + public byte RPM_Limit_Failsafe_Recovery_div100 => Core[15]; + public byte RPM_Detect_Min_div100 => Core[16]; + public byte RPM_Detect_Min_Recovery_div100 => Core[17]; + public byte RPM_Stall_div100 => Core[18]; + public byte RPM_Stall_Recovery_div100 => Core[19]; + public byte RPM_Decel_Threshold_PerSec_div100 => Core[20]; + public byte RPM_Accel_Threshold_PerSec_div100 => Core[21]; + public byte RPM_Meter_Divider => Core[22]; + public int RPM_Limit => RPM_Limit_div100 * 100; + + // ── Fuel [23–32] ───────────────────────────────────────────────────────── + public byte Fuel_Settings => Core[23]; + public byte Fuel_Max_PW_Mult => Core[24]; + // [25] reserved + public byte Fuel_Cut_Min_LOAD => Core[26]; + public byte Fuel_Cut_Min_TPS_pct => Core[27]; + public byte Fuel_Cut_Min_RPM_div100 => Core[28]; + public byte Fuel_Cut_Disable_LOAD => Core[29]; + public byte Fuel_Cut_Min_Etemp_degC => Core[30]; + // [31] reserved + public byte VBAT_Trim_deciV => Core[32]; + + // ── O2 Sensor / Autotune [33–47] ───────────────────────────────────────── + // [33] reserved + public byte O2_Sensor_Sample_Rate_ms => Core[34]; + public byte O2_Sensor_Delay_ms_div5 => Core[35]; + public byte O2_Fuel_Max_Add_Pct => Core[36]; + public byte O2_Fuel_Max_Sub_Pct => Core[37]; + public byte O2_Autotune_Max_RPM_div100 => Core[38]; + public byte O2_Autotune_Min_RPM_div100 => Core[39]; + public byte O2_Autotune_Max_Load => Core[40]; + public byte O2_Autotune_Min_Load => Core[41]; + public byte O2_Autotune_StepUp_Pct => Core[42]; + public byte O2_Autotune_Average_Weight => Core[43]; + public byte O2_Autotune_AFR_x10_Diff => Core[44]; + public byte O2_Autotune_Start_Delay_s => Core[45]; + public byte O2_Autotune_Min_ETemp => Core[46]; + public byte O2_Autotune_Max_ETemp => Core[47]; + + // ── TPS [48–55] ────────────────────────────────────────────────────────── + public byte TPS_Accel_Threshold_PctPer100ms => Core[48]; + public byte TPS_Decel_Threshold_PctPer100ms => Core[49]; + public byte TPS_Threshold_10ms_sample_gap => Core[50]; + public byte TPS_Accel_Fuel_Adjust_Hold_Time_10ms => Core[51]; + public byte TPS_Accel_Fuel_Adjust_Decay_Time_10ms => Core[52]; + public byte TPS_Accel_Spark_Adjust_Hold_Time_10ms => Core[53]; + public byte TPS_Accel_Spark_Adjust_Decay_Time_10ms => Core[54]; + public byte TPS_Steady_State_Delay_Time_10ms => Core[55]; + + // ── MAP [56–66] ────────────────────────────────────────────────────────── + public byte MAP_Settings => Core[56]; + public byte MAP_Lo_Hyst_Mult => Core[57]; + public byte MAP_Ref_Temp_DegC => Core[58]; + public byte MAP_Intake_Tooth_End => Core[59]; + public byte MAP_Intake_Num_Teeth => Core[60]; + public byte MAP_Baro_Tooth_End => Core[61]; + public byte MAP_Baro_Num_Teeth => Core[62]; + public byte MAP_Baro_RPM_div100_Limit => Core[63]; + public byte MAP_Baro_TPS_Limit => Core[64]; + public byte MAP_Baro_Static_Delay_10ms => Core[65]; + public byte MAP_Settings2 => Core[66]; + + // ── Radiator / Overheat [67–71] ────────────────────────────────────────── + public byte RadFan_On_Temp_DegC => Core[67]; + public byte RadFan_Off_Temp_DegC => Core[68]; + public byte Etemp_Overheat_On_Temp_DegC => Core[69]; + public byte Etemp_Overheat_Off_Temp_DegC => Core[70]; + public byte Etemp_Sensor_Error_Temp => Core[71]; + + // ── Bluetooth / MC33814 [72–77] ────────────────────────────────────────── + public byte Bluetooth_PowerOn_Timeout_s => Core[72]; + public byte MC33814_Init_Delay_10ms => Core[73]; + public byte MC33814_Tacho_Control => Core[74]; + public byte MC33814_VRS_Misc_Params => Core[75]; + public byte MC33814_Cfg_VRS_Manual_Control => Core[76]; + public byte MC33814_Ctrl_VRS_Conditioner => Core[77]; + + // ── Fuel Pump / Solenoid [78–83] ───────────────────────────────────────── + public byte Fuel_Pump_Timeout_100ms => Core[78]; + public byte Idle_Solenoid_Off_Tooth => Core[79]; + public byte Idle_Solenoid_Reset_RPM_div100 => Core[80]; + public byte Idle_Solenoid_Step_Down => Core[81]; + public byte Idle_Solenoid_PID_Kp => Core[82]; + public byte Idle_Solenoid_Min_Open_Angle_deg => Core[83]; + + // ── ShiftBoss [84–93] ──────────────────────────────────────────────────── + public byte ShiftBoss_Enable => Core[84]; // byte 84 = enable flags (see MiscBitSpecRegistry); real retard deg = ShiftBoss_Spark_Retard_deg & 0x7F + public byte ShiftBoss_Fuel_Cut_ms => Core[85]; + public byte ShiftBoss_Spark_Cut_ms => Core[86]; + public byte ShiftBoss_Spark_Retard_ms => Core[87]; + public byte ShiftBoss_Spark_Retard_deg => Core[88]; + public byte ShiftBoss_Interval_Time_10ms => Core[89]; + public byte ShiftBoss_Min_RPM_div100 => Core[90]; + public byte ShiftBoss_Input_Active_High => Core[91]; + public byte ShiftBoss_Input_Debounce_ms => Core[92]; + public byte ShiftBoss_Autotrigger_RPM_div100 => Core[93]; + + // ── Load selection [94–100] ────────────────────────────────────────────── + public byte Load_Primary_Select => Core[94]; + public byte Load_Fuel_PulseWidth1_Select => Core[95]; + public byte Load_Spark_Angle1_Select => Core[96]; + public byte Load_AFR_Target1_Select => Core[97]; + public byte Load_Fuel_Angle2D_Select => Core[98]; + public byte Load_Fuel_PulseWidth_Adjust1_Select => Core[99]; + public byte Load_Spark_Angle_Adjust1_Select => Core[100]; + + // ── Extended config [101–135] ───────────────────────────────────────────── + public byte VBAT_Min_deciV => Core[101]; + public byte VBAT_Max_deciV => Core[102]; + public byte O2_Sensor_Present => Core[103]; + public byte VDS_Present => Core[104]; + public byte TPS_Accel_Taper_Start_RPM_div100 => Core[105]; + public byte TPS_Accel_Taper_End_RPM_div100 => Core[106]; + public byte Error_Check_Startup_Delay => Core[107]; + public byte ErrorLog_Recording_Delay => Core[108]; + public byte ShiftLight_On_RPM_div100 => Core[109]; + public byte ShiftLight_Off_RPM_div100 => Core[110]; + public byte ShiftLight_Output_Select => Core[111]; + public byte MC33814_Lamp_Config => Core[112]; + public byte MC33814_O2H_Config => Core[113]; + public byte VBAT_Longterm_Min_DeciV => Core[114]; + public byte ErrorLog_MC33814_Mask_Lo => Core[115]; + public byte ErrorLog_MC33814_Mask_Hi => Core[116]; + public byte ErrorLog_MC33814_EngineOff_Enable => Core[117]; + public byte ErrorLog_MC33814_OL_Hysteresis => Core[118]; + public byte ErrorLog_MC33814_Killswitch_Mask => Core[119]; + // [120] reserved + public byte TPS_Accel_Fuel_TempComp => Core[121]; + public byte TPS_Accel_Threshold_Fast_PctPer100ms => Core[122]; + public byte TPS_Decel_Fuel_Adjust_Pct => Core[123]; + public byte TPS_Accel_Modifier_Cyclecount => Core[124]; + public byte TPS_Accel_Threshold_SuperFast_PctPer100ms => Core[125]; + // [120, 126–131] distinct settings/log bytes — named via MiscFieldRegistry, bound raw in the VM + public byte Start_Fuel_Enrichment_Decay_100ms => Core[132]; + public byte TPS_Accel_Recursive_Accel => Core[133]; + public byte Idle_Solenoid_Reset_Timeout_100ms => Core[134]; + public byte Speed_Adjust_Percent => Core[135]; + + public int ShiftLight_On_RPM => ShiftLight_On_RPM_div100 * 100; + public int ShiftLight_Off_RPM => ShiftLight_Off_RPM_div100 * 100; + + // ════════════════════════════════════════════════════════════════════════ + // LAUNCHFUEL — 12 bytes (spark/fuel reference angles + init) + // ════════════════════════════════════════════════════════════════════════ + public byte? RPM_Table_2Samplepoint_div100 => Lf(0); + public byte? Fuel_Init_Cycles => Lf(1); + public byte? Idle_Solenoid_Settings => Lf(2); + public byte? Spark_Ref_Angle_Lo => Lf(3); + public byte? Spark_Ref_Angle_Hi => Lf(4); + public byte? Fuel_Ref_Angle_Lo => Lf(5); + public byte? Fuel_Ref_Angle_Hi => Lf(6); + public byte? Fuel_Base_PW_ms_x10 => Lf(7); + public byte? Spark2_Ref_Angle_Lo => Lf(8); + public byte? Spark2_Ref_Angle_Hi => Lf(9); + public byte? Fuel2_Ref_Angle_Lo => Lf(10); + public byte? Fuel2_Ref_Angle_Hi => Lf(11); + + // ════════════════════════════════════════════════════════════════════════ + // LAUNCHFUEL2 — 12 bytes (launch control + rad fan) + // ════════════════════════════════════════════════════════════════════════ + public byte? LF2_TBD_Unused => Lf2(0); + public byte? LaunchBoss_Enable => Lf2(1); + public byte? LaunchBoss_Settings => Lf2(2); + public byte? LaunchBoss_RPM_Limit_Start_div100 => Lf2(3); + public byte? LaunchBoss_RPM_Limit_End_div100 => Lf2(4); + public byte? LaunchBoss_RPM_Persec_Up_Rate_div100 => Lf2(5); + public byte? LaunchBoss_RPM_Up_Speed_Start_kph => Lf2(6); + public byte? LaunchBoss_Speed_End_kph => Lf2(7); + public byte? LaunchBoss_Spark_Retard_deg => Lf2(8); + public byte? LF2_RadFan_Settings => Lf2(9); + public byte? LF2_RadFan_PWM_Width_100ms => Lf2(10); + public byte? Analog_Safe_Mode_Trigger => Lf2(11); + + // ════════════════════════════════════════════════════════════════════════ + // AUXOUT — 12 bytes + // ════════════════════════════════════════════════════════════════════════ + public byte? AuxOut_Control => Ao(0); + public byte? AuxOut_Control2 => Ao(1); + public byte? RadFan_On_Temp_NOS_RPM => Ao(2); + public byte? RadFan_Off_Temp_NOS_TPS => Ao(3); + public byte? NOS_Speed => Ao(4); + public byte? AuxOut_Ref_Value2_Off => Ao(5); + public byte? AuxOut_Delay1_10ms => Ao(6); + public byte? AuxOut_Delay2_10ms => Ao(7); + public byte? Idle_Threshold_TPS => Ao(8); + public byte? Idle_Threshold_RPM_div100 => Ao(9); + public byte? Spark_Dwell_Max_100us => Ao(10); + public byte? Spark_Dwell_Min_100us => Ao(11); + public int? AuxOut_Mode_Index => AuxOut_Control is byte b && b <= 3 ? (int?)b : null; + + // ════════════════════════════════════════════════════════════════════════ + // EXTENDED — variable size + // + // Buffer index → textbox → label, sourced from: + // READ: UpdateMiscValuesExtraPadding4New() (Form1_Utils.cs) + // WRITE: getMiscValByteArrayExtraPadding4New() (Form1_TableHandling.cs) + // LABELS: Designer.cs per-inner-tab parsing of tabControl14 inside tabPage93 + // + // Y15 [0–41] — always present when Extended is non-empty + // R25 [42–115] — EcuVariant >= TwoCylinder + // R15 [116–151]— EcuVariant == TwoCylinderR15 + // ════════════════════════════════════════════════════════════════════════ + + // ── Y15: Spark tab [0–17] ──────────────────────────────────────────────── + public byte? Spark_Dwell_Reduction_10us => Ex(0); // textBox261 + public byte? Spark_Dwell_Min_Deg => Ex(1); // textBox262 + public byte? Spark_Dwell_Max_Deg_div4 => Ex(2); // textBox263 + public byte? Spark_Dwell_Reserved1 => Ex(3); // textBox264 + public byte? Crank_MissingTooth2_Pos_Period_Mult => Ex(4); // textBox265 + public byte? Crank_MissingTooth2_Neg_Period_Mult => Ex(5); // textBox266 + public byte? Crank_MissingTooth_Pos_Period_Mult => Ex(6); // textBox267 + public byte? Crank_MissingTooth_Neg_Period_Mult => Ex(7); // textBox268 + public byte? VRS_Threshold_Lo_RPM_div100 => Ex(8); // textBox269 + public byte? VRS_Threshold_Hi_RPM_div100 => Ex(9); // textBox270 + public byte? Spark_Cut_Retard1_RPM_Gap_div100 => Ex(10); // textBox271 + public byte? Spark_Cut_Retard2_RPM_Gap_div100 => Ex(11); // textBox272 + public byte? Spark_Cut_Retard1 => Ex(12); // textBox273 + public byte? Spark_Cut_Retard2 => Ex(13); // textBox274 + public byte? CrankTooth_Pos_Period_Mult_Run => Ex(14); // textBox275 + public byte? CrankTooth_Neg_Period_Mult_Run => Ex(15); // textBox276 + public byte? Gear_Ratio_Hysteresis_Count => Ex(16); // textBox277 + public byte? Gear_Ratio_min_RPM_div100 => Ex(17); // textBox278 + + // ── Y15: TC tab [18–41] ────────────────────────────────────────────────── + public byte? TC_Settings1 => Ex(18); // textBox279 + public byte? TC_Settings2 => Ex(19); // textBox280 + public byte? TC_Rpm_Min_div100 => Ex(20); // textBox281 + public byte? TC_Rpm_Max_div100 => Ex(21); // textBox282 + public byte? TC_TPS_Min => Ex(22); // textBox283 + public byte? TC_TPS_Max => Ex(23); // textBox284 + public byte? TC_Speed_Min => Ex(24); // textBox285 + public byte? TC_Speed_Max => Ex(25); // textBox286 + public byte? TC_Consecutive_Error_Trigger => Ex(26); // textBox287 + public byte? TC_Retard_Off_Ramp_deg_per100ms => Ex(27); // textBox288 + public byte? TC_Table_Input_Selection => Ex(28); // textBox289 + public byte? TC_Sample_Rate_ms => Ex(29); // textBox290 + public byte? TC_Speed_Tooth_Skip => Ex(30); // textBox291 + public byte? TC_Tooth_Average_Count => Ex(31); // textBox292 + public byte? TC_Tooth_Compare_Count => Ex(32); // textBox293 + public byte? TC_Gear_Max => Ex(33); // textBox294 + public byte? TC_Button_Modes => Ex(34); // textBox295 + public byte? TC_Button_Sensitivity_Modifier => Ex(35); // textBox296 + public byte? TC_Button_Delay_100ms => Ex(36); // textBox297 + public byte? TC_Tooth_Undriven_Count => Ex(37); // textBox298 + public byte? TC_Reserved6 => Ex(38); // textBox299 + public byte? Offthrottle_Threshold_TPS => Ex(39); // textBox300 + public byte? Idle_Rumble_Min_Rpm_div100 => Ex(40); // textBox301 + public byte? Speed_Settings1 => Ex(41); // textBox302 + + // ── R25: ISM tab [42–75] ───────────────────────────────────────────────── + public byte? ISM_Settings1 => Ex(42); // textBox303 + public byte? ISM_Startup_Delay_10ms => Ex(43); // textBox304 ✓ + public byte? ISM_Max_Steps_Lo => Ex(44); // textBox305 + public byte? ISM_Max_Steps_Hi => Ex(45); // textBox306 + public byte? ISM_CR0_Init => Ex(46); // textBox307 + public byte? ISM_CR1_Init => Ex(47); // textBox308 + public byte? ISM_CR2_Init => Ex(48); // textBox309 + public byte? ISM_Test_Step_Lo => Ex(49); // textBox310 ✓ + public byte? ISM_Test_Step_Hi => Ex(50); // textBox311 + public byte? ISM_Off_Delay_10ms => Ex(51); // textBox312 + public byte? ISM_Max_Open_Steps_Per_Cycle => Ex(52); // textBox313 + public byte? ISM_Max_Close_Steps_Per_Cycle => Ex(53); // textBox314 + public byte? ISM_CR0_Run => Ex(54); // textBox315 + public byte? ISM_CR0_Hold => Ex(55); // textBox316 + public byte? ISM_Calibrate_Overshoot_Steps => Ex(56); // textBox317 + public byte? ISM_PID_Delay_5ms => Ex(57); // textBox318 + public byte? ISM_PID_Kp_lo => Ex(58); // textBox319 + public byte? ISM_PID_Kp_hi => Ex(59); // textBox320 + public byte? ISM_PID_Ki_lo => Ex(60); // textBox321 + public byte? ISM_PID_Ki_hi => Ex(61); // textBox322 + public byte? ISM_PID_Kd_lo => Ex(62); // textBox323 + public byte? ISM_PID_Kd_hi => Ex(63); // textBox324 + public byte? ISM_PID_Error_Threshold => Ex(64); // textBox325 + public byte? ISM_PID_Config => Ex(65); // textBox326 + public byte? ISM_Start_Boost_Step_raw => Ex(66); // textBox327 + public byte? ISM_Stall_Boost_Step_raw => Ex(67); // textBox328 + public byte? ISM_Start_Boost_Step_Delay_100ms => Ex(68); // textBox329 + public byte? ISM_Stall_Boost_Step_Delay_100ms => Ex(69); // textBox330 + public byte? ISM_Stall_Boost_RPM_div100 => Ex(70); // textBox331 + public byte? ISM_Boost_Step_Mult => Ex(71); // textBox332 + public byte? ISM_PID_Gain_Mult => Ex(72); // textBox333 + public byte? ISM_PID_Gain_Div_ShiftRight => Ex(73); // textBox334 + public byte? ISM_PID_RPM_Rampdown_Rate => Ex(74); // textBox335 + public byte? ISM_Rsvd22 => Ex(75); // textBox336 + + // ── R25: AIS tab [76–83] ───────────────────────────────────────────────── + public byte? AIS_Settings1 => Ex(76); // textBox337 + public byte? AIS_Settings2 => Ex(77); // textBox338 + public byte? AIS_RPM_Threshold1 => Ex(78); // textBox339 + public byte? AIS_TPS_Threshold1 => Ex(79); // textBox340 + public byte? AIS_RPM_Threshold2 => Ex(80); // textBox341 + public byte? AIS_TPS_Threshold2 => Ex(81); // textBox342 + public byte? AIS_RPM_Threshold3 => Ex(82); // textBox343 + public byte? AIS_TPS_Threshold3 => Ex(83); // textBox344 + + // ── R25: O2Heater tab [84–99] ──────────────────────────────────────────── + public byte? AIS_Delay1_10ms => Ex(84); // textBox345 + public byte? AIS_Settings10 => Ex(85); // textBox346 + public byte? ETEMP_Sensor_Sample_Rate_ms => Ex(86); // textBox347 + public byte? IAT_Sensor_Sample_Rate_ms => Ex(87); // textBox348 + public byte? O2Heater_Settings1 => Ex(88); // textBox349 + public byte? O2Heater_Settings2 => Ex(89); // textBox350 + public byte? O2Heater_Delay1_10ms => Ex(90); // textBox351 + public byte? O2Heater_Settings4 => Ex(91); // textBox352 + public byte? O2Heater_Settings5 => Ex(92); // textBox353 + public byte? O2Heater_Settings6 => Ex(93); // textBox354 + public byte? ShiftBoss_Spark_RampDown_ms => Ex(94); // textBox355 + public byte? ShiftBoss_Spark_RampUp_ms => Ex(95); // textBox356 + public byte? VBAT_UVReset_DeciV => Ex(96); // textBox357 + public byte? O2Heater_Settings10 => Ex(97); // textBox358 + public byte? LaunchBoss_Settings3 => Ex(98); // textBox359 + public byte? LaunchBoss_RPM_Limit_Fixed_div100 => Ex(99); // textBox360 + + // ── R25: O2Autotune tab [100–107] ──────────────────────────────────────── + public byte? O2_Autotune_Settings2 => Ex(100); // textBox361 + public byte? O2_Autotune_Cylinder_Correct => Ex(101); // textBox362 + public byte? O2_Autotune_Cylinder_Write => Ex(102); // textBox363 + public byte? O2_Autotune_Settings5 => Ex(103); // textBox364 + public byte? VRS_Settings1 => Ex(104); // textBox365 + public byte? MC33814_VRS_MaxVolt_Val => Ex(105); // textBox366 + public byte? MC33814_Relay1_Config => Ex(106); // textBox367 + public byte? MC33814_Relay2_Config => Ex(107); // textBox368 + + // ── R25: MCU Tacho tab [108–115] ───────────────────────────────────────── + public byte? MCU_Tacho_Settings1 => Ex(108); // textBox369 + public byte? MCU_Tacho_Divider => Ex(109); // textBox370 + public byte? MCU_Tacho_Settings3 => Ex(110); // textBox371 + public byte? MCU_Tacho_Settings4 => Ex(111); // textBox372 + public byte? Meter_Speed_Mult => Ex(112); // textBox373 + public byte? Meter_Speed_Div => Ex(113); // textBox374 + public byte? Meter_Speed_Test => Ex(114); // textBox375 + public byte? Meter_FC_Mult => Ex(115); // textBox376 + + // ── R15: VVA tab [116–151] ─────────────────────────────────────────────── + public byte? VVA_Settings1 => Ex(116); // textBox377 + public byte? VVA_Settings2 => Ex(117); // textBox378 + public byte? VVA_Settings3 => Ex(118); // textBox379 + public byte? VVA_Settings4 => Ex(119); // textBox380 + public byte? VVA_Etemp_HiVal => Ex(120); // textBox381 + public byte? VVA_Etemp_LoVal => Ex(121); // textBox382 + public byte? VVA_EngineOn_Delay1_100ms => Ex(122); // textBox383 + public byte? VVA_EngineOn_Delay2_10ms => Ex(123); // textBox384 + public byte? VVA_On_RPM_div100 => Ex(124); // textBox385 + public byte? VVA_Off_RPM_div100 => Ex(125); // textBox386 + public byte? VVA_On_TPS_pct => Ex(126); // textBox387 + public byte? VVA_Off_TPS_pct => Ex(127); // textBox388 + public byte? VVA_On_Stage1_PWM_Pct => Ex(128); // textBox389 + public byte? VVA_On_Stage1_Delay_10ms => Ex(129); // textBox390 + public byte? VVA_On_Stage2_PWM_Pct => Ex(130); // textBox391 + public byte? VVA_On_Stage2_Delay_10ms => Ex(131); // textBox392 + public byte? VVA_On_Stage3_PWM_Pct => Ex(132); // textBox393 + public byte? VVA_On_Stage3_Delay_10ms => Ex(133); // textBox394 + public byte? VVA_On_Stage4_PWM_Pct => Ex(134); // textBox395 + public byte? VVA_On_Stage4_Delay_10ms => Ex(135); // textBox396 + public byte? VVA_On_TableSwap_Delay_ms_lo => Ex(136); // textBox397 + public byte? VVA_On_TableSwap_Delay_ms_hi => Ex(137); // textBox398 + public byte? VVA_Off_TableSwap_Delay_ms_lo => Ex(138); // textBox399 + public byte? VVA_Off_TableSwap_Delay_ms_hi => Ex(139); // textBox400 + public byte? VVA_On_Tooth => Ex(140); // textBox401 + public byte? VVA_Off_Tooth => Ex(141); // textBox402 + public byte? VVA_HiSide_Toggle_Gap_Rpm_div100 => Ex(142); // textBox403 + public byte? VVA_ErrorCheck_Delay_10ms => Ex(143); // textBox404 + public byte? VVA_Rsvd9 => Ex(144); // textBox405 + public byte? VVA_Rsvd10 => Ex(145); // textBox406 + public byte? VVA_Rsvd11 => Ex(146); // textBox407 + public byte? VVA_Rsvd12 => Ex(147); // textBox408 + public byte? MAP_Error_Value_Fixed => Ex(148); // textBox409 + public byte? TPS_Error_Value_Fixed => Ex(149); // textBox410 + public byte? Digital_Input_Mask => Ex(150); // textBox411 + public byte? Mode_Switch_Settings => Ex(151); // textBox412 + + // ════════════════════════════════════════════════════════════════════════ + // FACTORY + // ════════════════════════════════════════════════════════════════════════ + public static MiscValues FromPayloads( + byte[] corePayload, + byte[]? launchFuelPayload = null, + byte[]? launchFuel2Payload = null, + byte[]? auxOutPayload = null, + byte[]? extendedPayload = null) + { + static byte[] Slice(byte[]? payload, int size) + { + if (payload == null || payload.Length < 4 + size) return Array.Empty(); + var buf = new byte[size]; + Buffer.BlockCopy(payload, 4, buf, 0, size); + return buf; + } + int extSize = extendedPayload != null ? Math.Max(0, extendedPayload.Length - 4) : 0; + return new MiscValues + { + Core = Slice(corePayload, 136), + LaunchFuel = Slice(launchFuelPayload, 12), + LaunchFuel2 = Slice(launchFuel2Payload, 12), + AuxOut = Slice(auxOutPayload, 12), + Extended = extendedPayload != null && extSize > 0 + ? Slice(extendedPayload, extSize) + : Array.Empty(), + }; + } + + /// + /// Extended region byte count to request. Per the legacy firmware, this is gated by + /// bit 7 of FW2_SubVersion, NOT by bike model: + /// (FW2_SubVersion & 0x80) != 0 → full extended set (0x97 = 152 bytes) + /// otherwise → up to Ex(115) (0x73 = 116 bytes) + /// + public static byte ExtendedLengthFor(byte fw2SubVersion) + => (fw2SubVersion & 0x80) != 0 ? (byte)0x97 : (byte)0x73; + + private byte? Lf(int i) => i < LaunchFuel.Length ? LaunchFuel[i] : null; + private byte? Lf2(int i) => i < LaunchFuel2.Length ? LaunchFuel2[i] : null; + private byte? Ao(int i) => i < AuxOut.Length ? AuxOut[i] : null; + private byte? Ex(int i) => i < Extended.Length ? Extended[i] : null; +} + +/// +/// Bike cylinder classification — determines Extended region size. +/// Derived from EcuInfo via TwoCylinderRegistry. +/// +public enum EcuVariant +{ + SingleCylinder, // Y15, NVX etc. — Extended = 0x29 + TwoCylinder, // R25, R3, MT25 — Extended = 0x73 + TwoCylinderR15, // R15M, CBR250RR — Extended = 0x97 +} diff --git a/TuneBoss.Core/Models/OneDimDisplay.cs b/TuneBoss.Core/Models/OneDimDisplay.cs new file mode 100644 index 0000000..53132c5 --- /dev/null +++ b/TuneBoss.Core/Models/OneDimDisplay.cs @@ -0,0 +1,39 @@ +using System; + +namespace TuneBoss.Core.Models +{ + /// + /// Display scaling for 1D tables: displayed value = raw × multiplier. + /// A multiplier of 0 or 1 means unscaled (×1). Editing is done in displayed units + /// and must land on a multiple of the multiplier. + /// + /// This is the single source of truth for the rules the 1D view-model applies + /// (OneDimTablesViewModel can delegate to it so the UI and tests can't drift). + /// + public static class OneDimDisplay + { + /// 0/1 => 1; otherwise the multiplier itself. + public static int EffectiveMultiplier(int multiplier) => multiplier < 1 ? 1 : multiplier; + + /// Raw byte value → displayed value. + public static long ToDisplay(int raw, int multiplier) => + (long)raw * EffectiveMultiplier(multiplier); + + /// + /// Displayed value → raw. Returns false if the displayed value is not an exact + /// multiple of the (effective) multiplier, so the caller can reject the edit. + /// + public static bool TryFromDisplay(double display, int multiplier, out int raw) + { + int m = EffectiveMultiplier(multiplier); + double q = display / m; + if (Math.Abs(q - Math.Round(q)) > 1e-6) + { + raw = 0; + return false; + } + raw = (int)Math.Round(q); + return true; + } + } +} diff --git a/TuneBoss.Core/Models/OneDimTable.cs b/TuneBoss.Core/Models/OneDimTable.cs new file mode 100644 index 0000000..46bfea5 --- /dev/null +++ b/TuneBoss.Core/Models/OneDimTable.cs @@ -0,0 +1,127 @@ +using System; + +namespace TuneBoss.Core.Models +{ + /// + /// A 1D lookup table as stored on the ECU: 8 raw-axis breakpoints mapped to + /// 8 conversion (output) values, plus 8 metadata bytes (scaling / sign / clamp). + /// + /// Fixed 24-byte wire layout: + /// [0..7] raw axis breakpoints (signed when RawSignedFlag > 0) + /// [8..15] conversion/output vals (signed when ConvSignedFlag > 0) + /// [16] MaxRaw (follows raw sign) + /// [17] MinRaw (follows raw sign) + /// [18] RawSignedFlag (> 0 => axis bytes are signed) + /// [19] ConvSignedFlag (> 0 => value bytes are signed) + /// [20] RawMultiplier (firmware-side display scaling) + /// [21] ConvMultiplier + /// [22] RawRounding + /// [23] ConvOffset (ALWAYS signed) + /// + /// Read with APP_MEMRD_1D (0x43), written with APP_MEMWR_1D (0x4B). + /// The sign flags and the four scaling bytes are round-tripped VERBATIM so a + /// write never disturbs metadata the firmware relies on. + /// + public sealed class OneDimTable + { + public const int PointCount = 8; + public const int WireLength = 24; + + public int[] RawAxis { get; } + public int[] ConvValues { get; } + + // metadata (bytes 16..23) + public int MaxRaw { get; set; } + public int MinRaw { get; set; } + public byte RawSignedFlag { get; set; } + public byte ConvSignedFlag { get; set; } + public byte RawMultiplier { get; set; } + public byte ConvMultiplier { get; set; } + public byte RawRounding { get; set; } + public sbyte ConvOffset { get; set; } + + public bool IsRawSigned => RawSignedFlag > 0; + public bool IsConvSigned => ConvSignedFlag > 0; + + public OneDimTable() + { + RawAxis = new int[PointCount]; + ConvValues = new int[PointCount]; + } + + /// Decode a 24-byte block (e.g. the data section of a 0x51 0x43 response). + public static OneDimTable FromWire(byte[] data, int offset = 0) + { + if (data is null) throw new ArgumentNullException(nameof(data)); + if (data.Length - offset < WireLength) + throw new ArgumentException($"1D payload needs {WireLength} bytes from offset {offset}.", nameof(data)); + + var t = new OneDimTable + { + RawSignedFlag = data[offset + 18], + ConvSignedFlag = data[offset + 19], + RawMultiplier = data[offset + 20], + ConvMultiplier = data[offset + 21], + RawRounding = data[offset + 22], + ConvOffset = unchecked((sbyte)data[offset + 23]), + }; + + bool rawSigned = t.RawSignedFlag > 0; + bool convSigned = t.ConvSignedFlag > 0; + + for (int i = 0; i < PointCount; i++) + { + t.RawAxis[i] = Decode(data[offset + i], rawSigned); + t.ConvValues[i] = Decode(data[offset + 8 + i], convSigned); + } + + t.MaxRaw = Decode(data[offset + 16], rawSigned); + t.MinRaw = Decode(data[offset + 17], rawSigned); + return t; + } + + /// Produce the 24-byte data block to send with APP_MEMWR_1D. + public byte[] ToWirePayload() + { + var d = new byte[WireLength]; + bool rawSigned = IsRawSigned; + bool convSigned = IsConvSigned; + + for (int i = 0; i < PointCount; i++) + { + d[i] = Encode(RawAxis[i], rawSigned); + d[8 + i] = Encode(ConvValues[i], convSigned); + } + + d[16] = Encode(MaxRaw, rawSigned); + d[17] = Encode(MinRaw, rawSigned); + d[18] = RawSignedFlag; + d[19] = ConvSignedFlag; + d[20] = RawMultiplier; + d[21] = ConvMultiplier; + d[22] = RawRounding; + d[23] = unchecked((byte)ConvOffset); + return d; + } + + public OneDimTable Clone() + { + var c = new OneDimTable + { + MaxRaw = MaxRaw, MinRaw = MinRaw, + RawSignedFlag = RawSignedFlag, ConvSignedFlag = ConvSignedFlag, + RawMultiplier = RawMultiplier, ConvMultiplier = ConvMultiplier, + RawRounding = RawRounding, ConvOffset = ConvOffset, + }; + Array.Copy(RawAxis, c.RawAxis, PointCount); + Array.Copy(ConvValues, c.ConvValues, PointCount); + return c; + } + + private static int Decode(byte b, bool signed) => signed ? unchecked((sbyte)b) : b; + + private static byte Encode(int v, bool signed) => signed + ? unchecked((byte)(sbyte)Math.Clamp(v, sbyte.MinValue, sbyte.MaxValue)) + : (byte)Math.Clamp(v, byte.MinValue, byte.MaxValue); + } +} diff --git a/TuneBoss.Core/Models/OneDimTableRegistry.cs b/TuneBoss.Core/Models/OneDimTableRegistry.cs new file mode 100644 index 0000000..0bddc2a --- /dev/null +++ b/TuneBoss.Core/Models/OneDimTableRegistry.cs @@ -0,0 +1,102 @@ +using System.Collections.Generic; + +namespace TuneBoss.Core.Models +{ + public enum OneDimGroup + { + SensorCalibration, + FuelCompensation, + SparkCompensation, + IdleControl, + TractionControl, + Quickshifter, + Nitrous, + OutputsAndHardware, + } + + /// + /// Stable identity of a 1D table slot. The ECU ADDRESS is generation-dependent and + /// is resolved at connect time (see MemoryLayout) — it is intentionally NOT stored + /// here. Slot is the 1-based ECU read order. + /// + /// AxisUnit / ValueUnit are display-only labels (proposed defaults — editable in the + /// UI per table). They never affect the wire format. + /// + public sealed record OneDimTableDefinition( + int Slot, + string Label, + OneDimGroup Group, + int MinFirmware, // 0 = base; otherwise 80 / 83 / 90 / 130 + string AxisUnit = "", + string ValueUnit = ""); + + public static class OneDimTableRegistry + { + public static readonly IReadOnlyList All = new[] + { + new OneDimTableDefinition( 1, "Spark Dwell Time", OneDimGroup.OutputsAndHardware, 0, "V", "ms"), + new OneDimTableDefinition( 2, "O2 Sensor", OneDimGroup.SensorCalibration, 0, "mV", "AFR"), + new OneDimTableDefinition( 3, "Intake Air Temperature", OneDimGroup.SensorCalibration, 0, "raw", "\u00B0C"), + new OneDimTableDefinition( 4, "Engine Temperature", OneDimGroup.SensorCalibration, 0, "raw", "\u00B0C"), + new OneDimTableDefinition( 5, "Manifold Air Pressure", OneDimGroup.SensorCalibration, 0, "raw", "kPa"), + new OneDimTableDefinition( 6, "Throttle Position", OneDimGroup.SensorCalibration, 0, "raw", "%"), + new OneDimTableDefinition( 7, "Fuel \u00B7 Engine Temp", OneDimGroup.FuelCompensation, 0, "\u00B0C", "%"), + new OneDimTableDefinition( 8, "Spark \u00B7 Engine Temp", OneDimGroup.SparkCompensation, 0, "\u00B0C", "\u00B0"), + new OneDimTableDefinition( 9, "Fuel \u00B7 Barometer", OneDimGroup.FuelCompensation, 0, "kPa", "%"), + new OneDimTableDefinition(10, "AUX Conversion", OneDimGroup.OutputsAndHardware, 0, "raw", "raw"), + new OneDimTableDefinition(11, "Fuel \u00B7 Intake Air Temp", OneDimGroup.FuelCompensation, 0, "\u00B0C", "%"), + new OneDimTableDefinition(12, "Spark \u00B7 Intake Air Temp", OneDimGroup.SparkCompensation, 0, "\u00B0C", "\u00B0"), + new OneDimTableDefinition(13, "Fuel \u00B7 TPS Accel", OneDimGroup.FuelCompensation, 0, "%", "%"), + new OneDimTableDefinition(14, "Spark \u00B7 TPS Accel", OneDimGroup.SparkCompensation, 0, "%", "\u00B0"), + new OneDimTableDefinition(15, "Battery V / Injector Opening", OneDimGroup.OutputsAndHardware, 0, "V", "\u00B5s"), + new OneDimTableDefinition(16, "TPS / MAP Percentage", OneDimGroup.SensorCalibration, 0, "raw", "%"), + new OneDimTableDefinition(17, "Idle Solenoid Ctrl Pct", OneDimGroup.IdleControl, 0, "RPM", "%"), + new OneDimTableDefinition(18, "Startup Fuel Comp", OneDimGroup.FuelCompensation, 0, "\u00B0C", "%"), + new OneDimTableDefinition(19, "Injector 2 Pct", OneDimGroup.OutputsAndHardware, 80, "RPM", "%"), + new OneDimTableDefinition(20, "RadFan PWM", OneDimGroup.OutputsAndHardware, 80, "\u00B0C", "%"), + new OneDimTableDefinition(21, "Idle Spark Rumble", OneDimGroup.Nitrous, 80, "RPM", "\u00B0"), + new OneDimTableDefinition(22, "Antilag Spark Control", OneDimGroup.Nitrous, 80, "RPM", "\u00B0"), + new OneDimTableDefinition(23, "Idle Fuel Pulse Width", OneDimGroup.IdleControl, 80, "\u00B0C", "\u00B5s"), + new OneDimTableDefinition(24, "Off-Throttle Isol Control", OneDimGroup.OutputsAndHardware, 80, "RPM", "%"), + new OneDimTableDefinition(25, "Speed Fuel Comp", OneDimGroup.FuelCompensation, 83, "km/h", "%"), + new OneDimTableDefinition(26, "Speed Spark Comp", OneDimGroup.SparkCompensation, 83, "km/h", "\u00B0"), + new OneDimTableDefinition(27, "ShiftBoss Fuel Cut", OneDimGroup.Quickshifter, 90, "RPM", "%"), + new OneDimTableDefinition(28, "ShiftBoss Spark Cut", OneDimGroup.Quickshifter, 90, "RPM", "%"), + new OneDimTableDefinition(29, "ShiftBoss Spark Retard", OneDimGroup.Quickshifter, 90, "RPM", "\u00B0"), + new OneDimTableDefinition(30, "TC Sensitivity", OneDimGroup.TractionControl, 90, "RPM", "%"), + new OneDimTableDefinition(31, "TC Spark Retard Degrees", OneDimGroup.TractionControl, 90, "%", "\u00B0"), + new OneDimTableDefinition(32, "TC Spark Retard Duration", OneDimGroup.TractionControl, 90, "%", "ms"), + new OneDimTableDefinition(33, "Gear Ratio Detection", OneDimGroup.TractionControl, 90, "gear", "ratio"), + new OneDimTableDefinition(34, "AUX PWM", OneDimGroup.OutputsAndHardware, 90, "raw", "%"), + new OneDimTableDefinition(35, "Idle Solenoid Control Steps", OneDimGroup.IdleControl, 130, "\u00B0C", "steps"), + new OneDimTableDefinition(36, "BARO Spark Comp", OneDimGroup.SparkCompensation, 130, "kPa", "\u00B0"), + new OneDimTableDefinition(37, "Idle Spark Compensation", OneDimGroup.IdleControl, 130, "RPM", "\u00B0"), + }; + + /// Nav-tree order for the groups. + public static readonly IReadOnlyList GroupOrder = new[] + { + OneDimGroup.SensorCalibration, + OneDimGroup.FuelCompensation, + OneDimGroup.SparkCompensation, + OneDimGroup.IdleControl, + OneDimGroup.TractionControl, + OneDimGroup.Quickshifter, + OneDimGroup.Nitrous, + OneDimGroup.OutputsAndHardware, + }; + + public static string DisplayName(OneDimGroup g) => g switch + { + OneDimGroup.SensorCalibration => "Sensor Calibration", + OneDimGroup.FuelCompensation => "Fuel Compensation", + OneDimGroup.SparkCompensation => "Spark Compensation", + OneDimGroup.IdleControl => "Idle Control", + OneDimGroup.TractionControl => "Traction Control", + OneDimGroup.Quickshifter => "Quickshifter", + OneDimGroup.Nitrous => "Rumble & Antilag", + OneDimGroup.OutputsAndHardware => "Outputs & Hardware", + _ => g.ToString(), + }; + } +} diff --git a/TuneBoss.Core/Models/SubTable.cs b/TuneBoss.Core/Models/SubTable.cs new file mode 100644 index 0000000..f3487b5 --- /dev/null +++ b/TuneBoss.Core/Models/SubTable.cs @@ -0,0 +1,182 @@ +namespace TuneBoss.Core.Models; + +/// +/// Data model for a subtable (AFR_Target_SubTable, Fuel_PulseWidth_Adjust_SubTable, +/// Spark_Angle_Adjust_SubTable — one per cylinder pair). +/// +/// A subtable is a small 2D correction grid: 4 load rows × 6 RPM columns, +/// always signed sbyte values. It provides a secondary axis multiplier on +/// top of the main 2D table, keyed by RPM range pairs rather than absolute RPM. +/// +/// ── Wire format — single read/write, no split ───────────────────────────────── +/// +/// Field Size Notes +/// ─────────── ────── ──────────────────────────────────────────────────── +/// Data cells 24 B sbyte[4 rows × 6 cols], row-major, always signed +/// Load axis 4 B byte[4] — fixed default {5, 15, 40, 70} +/// RPM axis 12 B byte[12] — pairs: [lo÷100, hi÷100] × 6 columns +/// +/// Total 40 B = dataInArray(24) + loadInArray(4) + rpmInArray(12) +/// +/// ── Key differences from TuningTable ───────────────────────────────────────── +/// - Always signed sbyte (no sign flag — hard-coded in the UI's Convert.ToSByte) +/// - Smaller grid: 4 rows × 6 cols vs 8 rows × 24 cols +/// - RPM axis uses pairs (low/high range per column), not single values +/// Each RPM cell displays as "loRPM\nhiRPM" (two lines) +/// - No modifier bytes (no MaxRaw/MinRaw/Mult/Sign trailer) +/// - Write sends only dataOutArray (no RPM/load arrays on write) +/// confirmed from writeSubTableFunctionThread: userDataArrayFromTable = sttp.dataOutArray +/// - Read response length comes from _tableMemReadBuffer[2] (Fix 1 in CheckNPreturn) +/// +/// ── Default load axis ───────────────────────────────────────────────────────── +/// Fixed at {5, 15, 40, 70} — hardcoded in SubTuningTablePanel.InitializeTable() +/// +public sealed record SubTable +{ + public const int Rows = 4; + public const int Cols = 6; + public const int DataBytes = Rows * Cols; // 24 + public const int LoadBytes = Rows; // 4 + public const int RpmBytes = Cols * 2; // 12 (lo+hi pair per column) + public const int TotalBytes = DataBytes + LoadBytes + RpmBytes; // 40 + + // ── Default axis values ─────────────────────────────────────────────────── + public static readonly byte[] DefaultLoadAxis = { 5, 15, 40, 70 }; + + // ── Raw wire arrays ─────────────────────────────────────────────────────── + /// + /// 24 bytes — cell data, row-major [row * 6 + col]. + /// Always signed sbyte on wire (stored as byte, interpreted as sbyte). + /// + public byte[] Data { get; init; } = new byte[DataBytes]; + + /// 4 bytes — load axis values. Default: {5, 15, 40, 70}. + public byte[] LoadAxis { get; init; } = (byte[])DefaultLoadAxis.Clone(); + + /// + /// 12 bytes — RPM axis pairs, [lo÷100, hi÷100] interleaved. + /// rpmInArray[col*2] = lo RPM ÷ 100, rpmInArray[col*2+1] = hi RPM ÷ 100. + /// Display: "loRPM\nhiRPM" (two lines per cell in the UI). + /// + public byte[] RpmAxis { get; init; } = new byte[RpmBytes]; + + // ── Derived display values ──────────────────────────────────────────────── + + /// + /// Gets the signed display value for a data cell. + /// SubTable cells are always sbyte — matches Convert.ToSByte() in the UI. + /// + public int GetCell(int row, int col) => + unchecked((sbyte)Data[row * Cols + col]); + + /// Low RPM bound for a column (display units). + public int GetRpmLo(int col) => RpmAxis[col * 2] * 100; + + /// High RPM bound for a column (display units). + public int GetRpmHi(int col) => RpmAxis[col * 2 + 1] * 100; + + /// Load axis value for a row (raw, 0–110). + public int GetLoad(int row) => LoadAxis[row]; + + // ── Deserialisation ─────────────────────────────────────────────────────── + + /// + /// Parses the device response for a subtable read. + /// The response payload starts at byte offset 4 (after the 4-byte header). + /// Response length is given by _tableMemReadBuffer[2] per CheckNPreturn Fix 1. + /// + /// Layout matches sendReadSplitTableToPanelThread (subtable path): + /// response[4 .. 4+DataBytes-1] → Data + /// response[4+DataBytes .. 4+DataBytes+3] → LoadAxis + /// response[4+DataBytes+4 .. 4+TotalBytes-1] → RpmAxis + /// + public static SubTable FromPayload(byte[] payload) + { + int expectedMin = 4 + TotalBytes; + if (payload.Length < expectedMin) + throw new ArgumentException( + $"Expected at least {expectedMin} bytes, got {payload.Length}.", nameof(payload)); + + const int o = 4; + var data = payload[o..(o + DataBytes)]; + var loadAxis = payload[(o + DataBytes)..(o + DataBytes + LoadBytes)]; + var rpmAxis = payload[(o + DataBytes + LoadBytes)..(o + TotalBytes)]; + + return new SubTable + { + Data = data, + LoadAxis = loadAxis, + RpmAxis = rpmAxis, + }; + } + + /// + /// Parses when only the data segment length is known from the response header. + /// Matches the CheckNPreturn Fix 1 pattern: + /// sttp.dataInArray = new byte[_tableMemReadBuffer[2]] + /// BlockCopy from _tableMemReadBuffer[4] + /// Load/RPM axes use defaults when not included in the response. + /// + public static SubTable FromDataOnlyPayload(byte[] payload, int dataLength) + { + if (payload.Length < 4 + dataLength) + throw new ArgumentException( + $"Payload too short for {dataLength} data bytes.", nameof(payload)); + + var data = new byte[dataLength]; + Buffer.BlockCopy(payload, 4, data, 0, dataLength); + + return new SubTable + { + Data = data, + LoadAxis = (byte[])DefaultLoadAxis.Clone(), + RpmAxis = new byte[RpmBytes], + }; + } + + // ── Serialisation ───────────────────────────────────────────────────────── + + /// + /// Returns the data-only write payload (24 bytes). + /// Matches writeSubTableFunctionThread: only dataOutArray is sent, + /// no RPM/load arrays on write. + /// + public byte[] ToWirePayload() => (byte[])Data.Clone(); + + /// + /// Full 40-byte payload including load and RPM axes. + /// Used when full round-trip serialisation is needed. + /// + public byte[] ToFullPayload() + { + var buf = new byte[TotalBytes]; + Buffer.BlockCopy(Data, 0, buf, 0, DataBytes); + Buffer.BlockCopy(LoadAxis, 0, buf, DataBytes, LoadBytes); + Buffer.BlockCopy(RpmAxis, 0, buf, DataBytes + LoadBytes, RpmBytes); + return buf; + } + + // ── Mutation ────────────────────────────────────────────────────────────── + + /// + /// Returns a new SubTable with cell (row, col) adjusted by delta, + /// clamped to the signed sbyte range [-128, 127]. + /// Matches minusButton/addButton in SubTuningTablePanel using Convert.ToSByte. + /// + public SubTable WithCellAdjusted(int row, int col, int delta, + int minVal = -128, int maxVal = 127) + { + var newData = (byte[])Data.Clone(); + int idx = row * Cols + col; + int current = unchecked((sbyte)newData[idx]); + int adjusted = Math.Clamp(current + delta, minVal, maxVal); + newData[idx] = unchecked((byte)(sbyte)adjusted); + + return new SubTable + { + Data = newData, + LoadAxis = LoadAxis, + RpmAxis = RpmAxis, + }; + } +} diff --git a/TuneBoss.Core/Models/TableTracker.cs b/TuneBoss.Core/Models/TableTracker.cs new file mode 100644 index 0000000..ad8572e --- /dev/null +++ b/TuneBoss.Core/Models/TableTracker.cs @@ -0,0 +1,158 @@ +namespace TuneBoss.Core.Models; + +/// +/// Calculates which table cells to highlight during live diagnostics. +/// +/// Given a live sensor value and a table's axis array, returns two indices: +/// [0] = the primary (exact) cell — the bracket the value falls into +/// [1] = the adjacent cell — either the previous or next bracket +/// (-1 means "before first" or "after last" — no secondary highlight) +/// +/// ── Algorithm ──────────────────────────────────────────────────────────────── +/// For each pair of adjacent axis values, the midpoint defines the boundary +/// between brackets. The live value is assigned to the bracket whose midpoint +/// boundary it falls within, then the adjacent bracket is the one whose axis +/// value is closest to the live value. +/// +/// Reverse-engineered from getRpmToHighlight() and getLoadToHighlight() in the +/// WinForms app. Both functions are identical in structure — only the axis +/// length differs (24 for RPM, 8 for Load/TPS). +/// +/// ── Usage ──────────────────────────────────────────────────────────────────── +/// var (col, adjCol) = TableTracker.FindIndex(table.RpmAxis, frame.RPM_Raw); +/// var (row, adjRow) = TableTracker.FindIndex(table.LoadAxis, frame.Load); +/// +/// // TPS-keyed tables (user-adjust: diag4/5/10/11/12) +/// var (row, adjRow) = TableTracker.FindIndex(table.LoadAxis, frame.TPS_Percent); +/// +public static class TableTracker +{ + /// + /// Finds the highlight and adjacent indices for a live value against an axis array. + /// + /// The table axis (RPM ÷100 bytes or load bytes). + /// The live sensor value in the same units as the axis. + /// + /// (highlight, adjacent) where -1 means "out of range on that side". + /// + public static (int Highlight, int Adjacent) FindIndex(byte[] axis, byte value) + { + int n = axis.Length; + if (n == 0) return (0, -1); + if (n == 1) return (0, -1); + + // Below first midpoint → bracket 0 + if (value < Midpoint(axis, 0, 1)) + { + int adj = value < axis[0] ? -1 : 1; + return (0, adj); + } + + // Middle brackets + for (int i = 1; i < n - 1; i++) + { + int lo = Midpoint(axis, i - 1, i); + int hi = Midpoint(axis, i, i + 1); + + if (lo <= value && value < hi) + { + int adj = value < axis[i] ? i - 1 : i + 1; + return (i, adj); + } + } + + // Above last midpoint → bracket n-1 + { + int adj = value < axis[n - 1] ? n - 2 : -1; + return (n - 1, adj); + } + } + + /// + /// Produces a for a tuning table from live frame data. + /// + /// Table RPM axis (raw bytes, each × 100 = RPM). + /// Table load axis (raw bytes). + /// Live RPM raw value from DiagnosticsFrame.RPM_Raw. + /// Live load/TPS value — use frame.Load for main tables, + /// frame.TPS_Percent for user-adjust tables. + public static DiagnosticsTracker Calculate( + byte[] rpmAxis, + byte[] loadAxis, + byte rpmRaw, + byte loadValue) + { + var (col, adjCol) = FindIndex(rpmAxis, rpmRaw); + var (row, adjRow) = FindIndex(loadAxis, loadValue); + + return new DiagnosticsTracker( + ColHighlight: col, + ColLowlight: adjCol, + RowHighlight: row, + RowLowlight: adjRow); + } + + /// + /// Calculates trackers for all loaded tables in a session from one frame. + /// Returns a dictionary keyed by table name. + /// Only includes tables whose axes are loaded. + /// + public static IReadOnlyDictionary CalculateAll( + EcuSession session, + DiagnosticsFrame frame) + { + var result = new Dictionary(); + + byte rpm = frame.RPM_Raw; + byte load = frame.Load; + byte tps = frame.TPS_Percent; + + void Add(string name, TuningTable? t, byte axisValue) + { + if (t == null) return; + result[name] = Calculate(t.RpmAxis, t.LoadAxis, rpm, axisValue); + } + + void AddAfr(string name, AfrTable? t, byte axisValue) + { + if (t == null) return; + result[name] = Calculate(t.RpmAxis, t.LoadAxis, rpm, axisValue); + } + + // Cyl1 main tables — load-keyed + Add("Fuel_PulseWidth1", session.Fuel_PulseWidth1, load); + Add("Spark_Angle1", session.Spark_Angle1, load); + Add("Fuel_Angle2D", session.Fuel_Angle2D, load); + Add("Secondary_Load_Conversion", session.Secondary_Load_Conversion, load); + AddAfr("AFR_Target1", session.AFR_Target1, load); + + // Cyl1 user-adjust — TPS-keyed + Add("Fuel_PulseWidth_Adjust1", session.Fuel_PulseWidth_Adjust1, tps); + Add("Spark_Angle_Adjust1", session.Spark_Angle_Adjust1, tps); + + if (session.IsTwoCylinder) + { + // Cyl2 main tables — load-keyed + Add("Fuel_PulseWidth2", session.Fuel_PulseWidth2, load); + Add("Spark_Angle2", session.Spark_Angle2, load); + Add("Fuel_Angle2D_2", session.Fuel_Angle2D_2, load); + AddAfr("AFR_Target2", session.AFR_Target2, load); + + // Cyl2 user-adjust — TPS-keyed + Add("Fuel_PulseWidth_Adjust2", session.Fuel_PulseWidth_Adjust2, tps); + Add("Spark_Angle_Adjust2", session.Spark_Angle_Adjust2, tps); + } + + return result; + } + + // ── Helpers ─────────────────────────────────────────────────────────────── + + /// + /// Integer midpoint of two adjacent axis values. + /// Matches (rpmArrayRef[i] + rpmArrayRef[i+1]) / 2 in the original code. + /// Uses integer division — no rounding. + /// + private static byte Midpoint(byte[] axis, int i, int j) + => (byte)((axis[i] + axis[j]) / 2); +} diff --git a/TuneBoss.Core/Models/TpsCalibration.cs b/TuneBoss.Core/Models/TpsCalibration.cs new file mode 100644 index 0000000..e49ec93 --- /dev/null +++ b/TuneBoss.Core/Models/TpsCalibration.cs @@ -0,0 +1,101 @@ +using TuneBoss.Core.Protocol; + +namespace TuneBoss.Core.Models; + +/// +/// Throttle-position-sensor calibration rules, resolved verbatim from the legacy +/// WinForms (saveUserReadInfo / TPS page) and Android (TpsCalPage / +/// BtApp.sendTpsCalWrite) sources. +/// +/// The calibration captures the raw TPS ADC (, +/// channel [18]) at closed and wide-open throttle over several sweeps, validates the +/// captured min/max against the per-unit absolute bounds, then writes an 8-byte 1D +/// block and sets the first-use flag. +/// +/// ── Generation addressing (absolute ECU addresses) ─────────────────────────── +/// Gen2 / Gen3 (small-address layout — PG1/EZ115 is Gen3): +/// CalWrite = 0x0078 (120) ← 8-byte calibration block +/// AbsBounds = 0x0088 (136) ← [max, min, store2, store3] sanity bounds +/// AdvSettings = 0x0094 (148) ← advanced TPS toggle (FW ≥ 152) +/// Gen1 (legacy ~1788 range): CalWrite = 0x06FC, AbsBounds = 0x070C, no adv. +/// +public static class TpsCalibration +{ + public readonly record struct Addresses( + ushort CalWrite, + ushort AbsBounds, + ushort AdvSettings, + bool AdvSupported); + + /// Minimum firmware that exposes the advanced TPS settings byte. + public const int AdvMinFirmware = 152; + + /// Number of full open/close sweeps the guide asks the tuner to perform. + public const int RequiredSweeps = 5; + + /// + /// FirstUseInfo[0] sentinel (READ_INFO buf[32], the DD slot, overloaded as a flag + /// on Gen2/Gen3). The unit is considered calibrated iff this byte == 1. + /// + public const byte CalDoneFlag = 1; + + // Absolute-bounds editor limits (legacy long-press editor ranges). + public const byte AbsMaxFloor = 180, AbsMaxCeil = 198; + public const byte AbsMinFloor = 2, AbsMinCeil = 10; + + /// Resolves the calibration addresses for a generation + firmware. + public static Addresses For(GenerationType generation, byte fwVersion) => generation switch + { + GenerationType.Gen1 => new Addresses(0x06FC, 0x070C, 0x0000, AdvSupported: false), + _ => new Addresses(0x0078, 0x0088, 0x0094, AdvSupported: fwVersion >= AdvMinFirmware), + }; + + /// Convenience overload resolving the generation from . + public static Addresses For(EcuInfo info) => + For((GenerationType)info.AppInfoVersion, info.FwVersion); + + /// + /// Builds the 8-byte 1D calibration payload exactly as the legacy + /// sendTpsCalWrite does: [min, max, max+2, max+4, max+6, max+8, max+10, max+12]. + /// The trailing ramp defines the TPS% curve above wide-open throttle. + /// + public static byte[] BuildCalWritePayload(int minRaw, int maxRaw) + { + byte m = (byte)(maxRaw & 0xFF); + return new[] + { + (byte)(minRaw & 0xFF), + m, + (byte)(m + 2), (byte)(m + 4), (byte)(m + 6), + (byte)(m + 8), (byte)(m + 10), (byte)(m + 12), + }; + } + + public enum Validation + { + Ok, + MinBelowFloor, // captured closed-throttle raw fell below the absolute minimum + MaxAboveCeiling, // captured WOT raw rose above the absolute maximum + Extreme, // crossed/implausible values + } + + /// + /// Replicates the legacy acceptance test against the absolute bounds read from + /// ([0] = absMax, [1] = absMin). + /// + public static Validation Validate(int minRaw, int maxRaw, int absMin, int absMax) + { + if (minRaw < absMin) return Validation.MinBelowFloor; + if (maxRaw > absMax) return Validation.MaxAboveCeiling; + if (minRaw > absMax || maxRaw < absMin) return Validation.Extreme; + return Validation.Ok; + } + + public static string Describe(Validation v, int minRaw, int maxRaw, int absMin, int absMax) => v switch + { + Validation.MinBelowFloor => $"Min raw {minRaw} is below the expected minimum of {absMin}. Please check your throttle.", + Validation.MaxAboveCeiling => $"Max raw {maxRaw} is above the expected maximum of {absMax}. Please check your throttle.", + Validation.Extreme => $"Calibration failed due to extreme TPS values (min {minRaw}, max {maxRaw}). Please check your throttle.", + _ => $"Calibration successful — min {minRaw}, max {maxRaw}.", + }; +} diff --git a/TuneBoss.Core/Models/TuningTable.cs b/TuneBoss.Core/Models/TuningTable.cs new file mode 100644 index 0000000..4dc07d3 --- /dev/null +++ b/TuneBoss.Core/Models/TuningTable.cs @@ -0,0 +1,232 @@ +namespace TuneBoss.Core.Models; + +/// +/// Complete data model for a 2D tuning table (Fuel PulseWidth, Spark Angle, +/// AFR Target, etc.). +/// +/// ── Wire format on the device ──────────────────────────────────────────────── +/// Total payload = 227 bytes, split across two reads/writes at 0x7F boundary: +/// +/// Offset Length Field +/// ─────── ─────── ────────────────────────────────────────────────────── +/// 0 192 Data cells (24 cols × 8 rows, row-major, byte each) +/// 192 8 Load axis (8 bytes, ascending, 0–110 range) +/// 200 24 RPM axis (24 bytes, each × 100 = actual RPM) +/// 224 1 Max raw (byte; sbyte if signed) +/// 225 1 Min raw (byte; sbyte if signed) +/// 226 1 Mult (multiplier for display scaling) +/// 227 1 Sign (0 = unsigned byte, >0 = signed sbyte) +/// +/// Split read: +/// Part 1: bytes [0..127] → lengthFirstPart = 0x7F (127) +/// Part 2: bytes [128..227] → lengthSecondPart = 227 - 127 - 1 = 99 +/// Part 2 address = baseAddress + 0x7F + 1 +/// +/// Split write (same split, different order — data is written first): +/// Part 1 writes dataArray[0..127] +/// Part 2 writes dataArray[128..191] + loadArray[0..7] +/// + rpmArray[0..23] + modifiers[0..3] +/// +/// ── Display / UI mapping ───────────────────────────────────────────────────── +/// RPM axis : stored as raw byte (÷100 on wire), displayed × 100 (e.g. 50→5000) +/// Load axis : stored as raw byte (0–110), displayed as-is +/// Data cells: if Sign > 0 → sbyte interpretation, else byte +/// minDataVal/maxDataVal derived from min/maxRawVal via sign flag +/// Color map : 7 linear bands from minDataVal to maxDataVal (red→green) +/// +public sealed record TuningTable +{ + // ── Dimensions ──────────────────────────────────────────────────────────── + public const int Cols = 24; // RPM columns + public const int Rows = 8; // Load rows + public const int DataBytes = Cols * Rows; // 192 + + // ── Split constants (match TableHandling lengthFirstPart) ───────────────── + public const int SplitFirstLength = 0x7F; // 127 + public const int TotalPayloadBytes = DataBytes + Rows + Cols + 4; // 228 + + // ── Raw wire arrays ─────────────────────────────────────────────────────── + /// 192 bytes, row-major [row * 24 + col]. + public byte[] Data { get; init; } = new byte[DataBytes]; + + /// 8 bytes — load axis values (0–110). + public byte[] LoadAxis { get; init; } = new byte[Rows]; + + /// 24 bytes — RPM axis, each × 100 = actual RPM. + public byte[] RpmAxis { get; init; } = new byte[Cols]; + + // ── Modifiers (bytes 224–227) ───────────────────────────────────────────── + /// Raw max value from device (index [0] in modifiersInArray). + public byte MaxRaw { get; init; } + + /// Raw min value from device (index [1] in modifiersInArray). + public byte MinRaw { get; init; } + + /// Multiplier for display scaling (index [2]). + public byte Mult { get; init; } + + /// Sign flag: 0 = unsigned byte, >0 = signed sbyte (index [3]). + public byte Sign { get; init; } + + // ── Derived display values ──────────────────────────────────────────────── + public bool IsSigned => Sign > 0; + + /// Display min — sbyte if signed, byte if unsigned. + public int MinDataVal => IsSigned + ? unchecked((sbyte)MinRaw) + : (int)MinRaw; + + /// Display max — sbyte if signed, byte if unsigned. + public int MaxDataVal => IsSigned + ? unchecked((sbyte)MaxRaw) + : (int)MaxRaw; + + /// + /// Gets the display value for a cell. + /// Applies sign interpretation matching UpdateTable(readCmd=1) in TuningTablePanel. + /// + public int GetCell(int row, int col) => + IsSigned + ? unchecked((sbyte)Data[row * Cols + col]) + : Data[row * Cols + col]; + + /// RPM axis values in display units (raw × 100). + public int[] RpmValues => RpmAxis.Select(r => r * 100).ToArray(); + + /// Load axis values (raw, 0–110 range). + public int[] LoadValues => LoadAxis.Select(l => (int)l).ToArray(); + + /// + /// 7-band color range thresholds, matching setDataValRange() in TuningTablePanel. + /// dataValRange[x] = minDataVal + (x * (maxDataVal - minDataVal)) / 7 + /// + public double[] ColorBandThresholds() + { + var range = new double[8]; + int span = MaxDataVal - MinDataVal; + for (int x = 0; x < 8; x++) + range[x] = MinDataVal + (x * span) / 7.0; + return range; + } + + // ── Serialisation (write path) ──────────────────────────────────────────── + + /// + /// Builds the combined 228-byte payload for the write path. + /// Matches the order in writeTableFunctionSplitThreadCustom: + /// [0..191] data cells + /// [192..199] load axis + /// [200..223] rpm axis + /// [224] MaxRaw + /// [225] MinRaw + /// [226] Mult + /// [227] Sign + /// + public byte[] ToWirePayload() + { + var buf = new byte[TotalPayloadBytes]; + Buffer.BlockCopy(Data, 0, buf, 0, DataBytes); + Buffer.BlockCopy(LoadAxis,0, buf, DataBytes, Rows); + Buffer.BlockCopy(RpmAxis, 0, buf, DataBytes + Rows, Cols); + buf[DataBytes + Rows + Cols] = MaxRaw; + buf[DataBytes + Rows + Cols + 1] = MinRaw; + buf[DataBytes + Rows + Cols + 2] = Mult; + buf[DataBytes + Rows + Cols + 3] = Sign; + return buf; + } + + /// First 128 bytes of the payload — sent as part 1 of split write. + public byte[] ToWirePayloadPart1() => ToWirePayload()[..( SplitFirstLength + 1)]; + + /// Remaining bytes — sent as part 2 of split write. + public byte[] ToWirePayloadPart2() => ToWirePayload()[(SplitFirstLength + 1)..]; + + // ── Deserialisation (read path) ─────────────────────────────────────────── + + /// + /// Parses a combined 228-byte buffer assembled from the two split reads. + /// Matches sendReadSplitTableToPanelThreadCustom() in Form1_TableHandling.cs. + /// + /// Part 1 response[4..131] → dataCombined[0..127] + /// Part 2 response[4..103] → dataCombined[128..227] + /// + public static TuningTable FromWirePayload(byte[] combined) + { + if (combined.Length < TotalPayloadBytes) + throw new ArgumentException( + $"Expected {TotalPayloadBytes} bytes, got {combined.Length}.", nameof(combined)); + + var data = new byte[DataBytes]; + var loadAxis = new byte[Rows]; + var rpmAxis = new byte[Cols]; + + Buffer.BlockCopy(combined, 0, data, 0, DataBytes); + Buffer.BlockCopy(combined, DataBytes, loadAxis,0, Rows); + Buffer.BlockCopy(combined, DataBytes + Rows, rpmAxis, 0, Cols); + + int modBase = DataBytes + Rows + Cols; + byte maxRaw = combined[modBase]; + byte minRaw = combined[modBase + 1]; + byte mult = combined[modBase + 2]; + byte sign = combined[modBase + 3]; + + return new TuningTable + { + Data = data, + LoadAxis = loadAxis, + RpmAxis = rpmAxis, + MaxRaw = maxRaw, + MinRaw = minRaw, + Mult = mult, + Sign = sign, + }; + } + + /// + /// Assembles the combined payload from the two raw device response buffers. + /// Each response buffer has a 4-byte header; data starts at offset 4. + /// + public static TuningTable FromSplitResponses(byte[] part1Response, byte[] part2Response) + { + var combined = new byte[TotalPayloadBytes]; + + // Part 1: bytes [4 .. 4+SplitFirstLength] → combined[0..SplitFirstLength] + Buffer.BlockCopy(part1Response, 4, combined, 0, + SplitFirstLength + 1); + + // Part 2: bytes [4 ..] → combined[SplitFirstLength+1..] + int part2Len = TotalPayloadBytes - (SplitFirstLength + 1); + Buffer.BlockCopy(part2Response, 4, combined, SplitFirstLength + 1, + part2Len); + + return FromWirePayload(combined); + } + + // ── Mutation (for +1/-1/+5/-5 operations) ──────────────────────────────── + + /// + /// Returns a new TuningTable with the cell at (row, col) adjusted by delta, + /// clamped to [MinDataVal, MaxDataVal]. + /// + public TuningTable WithCellAdjusted(int row, int col, int delta) + { + var newData = (byte[])Data.Clone(); + int idx = row * Cols + col; + int current = IsSigned ? unchecked((sbyte)newData[idx]) : newData[idx]; + int adjusted = Math.Clamp(current + delta, MinDataVal, MaxDataVal); + newData[idx] = IsSigned + ? unchecked((byte)(sbyte)adjusted) + : (byte)adjusted; + + return new TuningTable + { + Data = newData, + LoadAxis = LoadAxis, + RpmAxis = RpmAxis, + MaxRaw = MaxRaw, + MinRaw = MinRaw, + Mult = Mult, + Sign = Sign, + }; + } +} diff --git a/TuneBoss.Core/Models/TwoCylinderRegistry.cs b/TuneBoss.Core/Models/TwoCylinderRegistry.cs new file mode 100644 index 0000000..2f77878 --- /dev/null +++ b/TuneBoss.Core/Models/TwoCylinderRegistry.cs @@ -0,0 +1,68 @@ +using System.Xml.Linq; + +namespace TuneBoss.Core.Models; + +/// +/// Determines whether a bike is a two-cylinder model based on +/// manufacturer + model code, driven by twoCylModels.xml. +/// +public sealed class TwoCylinderRegistry +{ + // Manufacturer codes + public const byte Yamaha = 1; + public const byte Honda = 2; + public const byte Kawasaki = 3; + public const byte Suzuki = 6; + + private readonly Dictionary> _models = new(); + + private TwoCylinderRegistry() { } + + /// + /// Loads from a twoCylModels.xml file path. + /// + public static TwoCylinderRegistry Load(string xmlPath) + { + var doc = XDocument.Load(xmlPath); + var registry = new TwoCylinderRegistry(); + + registry.LoadTag(doc, "ym", Yamaha); + registry.LoadTag(doc, "hn", Honda); + registry.LoadTag(doc, "kw", Kawasaki); + registry.LoadTag(doc, "su", Suzuki); + + return registry; + } + + /// + /// Loads from an XML string (useful for embedding or testing). + /// + public static TwoCylinderRegistry LoadFromString(string xml) + { + var doc = XDocument.Parse(xml); + var registry = new TwoCylinderRegistry(); + + registry.LoadTag(doc, "ym", Yamaha); + registry.LoadTag(doc, "hn", Honda); + registry.LoadTag(doc, "kw", Kawasaki); + registry.LoadTag(doc, "su", Suzuki); + + return registry; + } + + public bool IsTwoCylinder(byte manufacturer, uint model) + { + return _models.TryGetValue(manufacturer, out var set) && set.Contains(model); + } + + private void LoadTag(XDocument doc, string tag, byte manufacturerCode) + { + var models = doc.Descendants(tag) + .Select(e => uint.TryParse(e.Value.Trim(), out var v) ? (uint?)v : null) + .Where(v => v.HasValue) + .Select(v => v!.Value) + .ToHashSet(); + + _models[manufacturerCode] = models; + } +} diff --git a/TuneBoss.Core/Models/VvaModelRegistry.cs b/TuneBoss.Core/Models/VvaModelRegistry.cs new file mode 100644 index 0000000..340a68d --- /dev/null +++ b/TuneBoss.Core/Models/VvaModelRegistry.cs @@ -0,0 +1,114 @@ +using System.Collections.Generic; +using System.Linq; +using System.Xml.Linq; + +namespace TuneBoss.Core.Models; + +/// +/// Which bike models have VVA (variable valve actuation), so the RPM Settings page can +/// gate the VVA RPM Trigger. Mirrors the legacy vvaModels.xml / checkVvaModels. +/// +/// The list is loaded from an EDITABLE external file at +/// %APPDATA%\TuneBoss\vvaModels.xml so it can be changed without recompiling. +/// The file is auto-created (seeded with the defaults below) on first use if missing. +/// If it can't be read, the built-in defaults are used. +/// +/// XML schema (same as legacy): <vvaModels><ym>14</ym>…<hn>…</hn> +/// <su>…</su><kw>…</kw></vvaModels>. +/// Element → manufacturer code: ym=1 Yamaha, hn=2 Honda, kw=3 Kawasaki, su=6 Suzuki. +/// +public static class VvaModelRegistry +{ + private static readonly object _lock = new(); + private static Dictionary>? _map; + + /// Editable list file. Sits beside settings.json in %APPDATA%\TuneBoss. + public static string FilePath => System.IO.Path.Combine( + System.Environment.GetFolderPath(System.Environment.SpecialFolder.ApplicationData), + "TuneBoss", "vvaModels.xml"); + + // Element name → manufacturer code. + private static readonly (string Elem, byte Mfr)[] Makes = + { + ("ym", 1), ("hn", 2), ("kw", 3), ("su", 6), + }; + + // Built-in defaults (legacy vvaModels.xml): only these Yamaha models carry VVA. + private static Dictionary> Defaults() => new() + { + [1] = new HashSet { 14, 17, 21, 22 }, + }; + + /// True when the given make/model is known to have VVA. + public static bool IsVvaModel(byte manufacturer, byte model) + { + var map = EnsureLoaded(); + return map.TryGetValue(manufacturer, out var models) && models.Contains(model); + } + + /// Force a re-read of the file on the next lookup (call after editing it). + public static void Reload() + { + lock (_lock) { _map = null; } + } + + private static Dictionary> EnsureLoaded() + { + lock (_lock) + { + if (_map != null) return _map; + + try + { + if (System.IO.File.Exists(FilePath)) + { + _map = Parse(XDocument.Load(FilePath)); + return _map; + } + + // First run — seed the editable file with the defaults, then use them. + _map = Defaults(); + TrySeedFile(); + } + catch + { + // Missing / malformed / unreadable → fall back to the built-in list. + _map = Defaults(); + } + + return _map; + } + } + + private static Dictionary> Parse(XDocument doc) + { + var map = new Dictionary>(); + foreach (var (elem, mfr) in Makes) + { + var set = new HashSet(); + foreach (var node in doc.Descendants(elem)) + { + if (byte.TryParse(node.Value.Trim(), out byte m)) + set.Add(m); // a 999 placeholder simply never matches a real model + } + if (set.Count > 0) map[mfr] = set; + } + return map.Count > 0 ? map : Defaults(); + } + + private static void TrySeedFile() + { + try + { + var dir = System.IO.Path.GetDirectoryName(FilePath); + if (!string.IsNullOrEmpty(dir)) System.IO.Directory.CreateDirectory(dir); + + var doc = new XDocument(new XElement("vvaModels", + new XElement("ym", 14), new XElement("ym", 17), + new XElement("ym", 21), new XElement("ym", 22), + new XElement("hn", 999), new XElement("su", 999), new XElement("kw", 999))); + doc.Save(FilePath); + } + catch { /* seeding is best-effort; defaults still apply in memory */ } + } +} diff --git a/TuneBoss.Core/Protocol/ChecksumHelper.cs b/TuneBoss.Core/Protocol/ChecksumHelper.cs new file mode 100644 index 0000000..7a685ed --- /dev/null +++ b/TuneBoss.Core/Protocol/ChecksumHelper.cs @@ -0,0 +1,73 @@ +namespace TuneBoss.Core.Protocol; + +/// +/// Checksum helpers for the TuneBoss BLE packet protocol. +/// +/// genCheckSumDW: accumulates payload as little-endian uint32 DWords, +/// sums them (wrapping uint32), then returns the bitwise inverse (~sum). +/// Verified against debug log 17-Mar-2026. +/// +public static class ChecksumHelper +{ + /// + /// Computes the DWord checksum over a byte span. + /// The span length must be a multiple of 4 (pad before calling if needed). + /// + public static uint GenChecksumDW(ReadOnlySpan data) + { + if (data.Length % 4 != 0) + throw new ArgumentException("Data length must be a multiple of 4.", nameof(data)); + + uint cumResult = 0; + for (int i = 0; i < data.Length; i += 4) + { + uint dword = data[i] + | ((uint)data[i + 1] << 8) + | ((uint)data[i + 2] << 16) + | ((uint)data[i + 3] << 24); + cumResult += dword; // wrapping uint32 addition + } + + return ~cumResult; // bitwise inverse + } + + /// + /// Writes the 4-byte little-endian checksum into . + /// + public static void WriteChecksumDW(ReadOnlySpan data, Span dest) + { + uint cs = GenChecksumDW(data); + dest[0] = (byte)(cs); + dest[1] = (byte)(cs >> 8); + dest[2] = (byte)(cs >> 16); + dest[3] = (byte)(cs >> 24); + } + + /// + /// Computes the single-byte header inverse sum. + /// sum = TL_type + seqNum + dwCount; result = 0xFF - sum (byte wrap). + /// Verified: TL=02 seq=01 dw=02 → sum=05 → invSum=FA ✓ + /// + public static byte HeaderInverseSum(byte tlType, byte seqNum, byte dwCount) + => unchecked((byte)(0xFF - (tlType + seqNum + dwCount))); + + /// + /// Verifies an inbound packet's DWord checksum. + /// The last 4 bytes of are the checksum; + /// the preceding bytes are the data. + /// + public static bool VerifyChecksumDW(ReadOnlySpan payload) + { + if (payload.Length < 8 || payload.Length % 4 != 0) + return false; + int dataLen = payload.Length - 4; + var data = payload.Slice(0, dataLen); + var expected = payload.Slice(dataLen, 4); + uint computed = GenChecksumDW(data); + + return expected[0] == (byte)(computed) + && expected[1] == (byte)(computed >> 8) + && expected[2] == (byte)(computed >> 16) + && expected[3] == (byte)(computed >> 24); + } +} diff --git a/TuneBoss.Core/Protocol/Commands.cs b/TuneBoss.Core/Protocol/Commands.cs new file mode 100644 index 0000000..1ed4857 --- /dev/null +++ b/TuneBoss.Core/Protocol/Commands.cs @@ -0,0 +1,78 @@ +namespace TuneBoss.Core.Protocol; + +/// +/// TuneBoss hardware command bytes. +/// +public static class Commands +{ + // ── Data Link layer ───────────────────────────────────────────────────── + public const byte DL_ACK = 0x11; + public const byte DL_NAK_HDR = 0x12; + public const byte DL_NAK_DATA = 0x13; + public const byte DL_NAK_OVF = 0x14; // Rx buffer overflow — use smaller packet + public const byte DL_NAK_TIMEOUT = 0x15; + + // ── Transport layer ────────────────────────────────────────────────────── + public const byte TL_POSTED = 0x01; // Requires ACK from device + public const byte TL_NONPOSTED = 0x02; // No ACK; device returns a data packet + public const byte TL_NP_RETURN = 0x03; // Return packet for TL_NONPOSTED + public const byte TL_STREAMING = 0x04; // Streaming; no ACK/NAK required + + public const byte DL_PING_NOREPLY = 0x21; // Host connectivity test; device ignores + + // ── App commands — Non-Posted ──────────────────────────────────────────── + public const byte APP_UNLOCK = 0x30; // Password + current date at byte 4 + public const byte APP_LOCK = 0x31; + public const byte APP_MEMRD_SEQ = 0x32; // Legacy: 8-bit len @ b1, 16-bit addr @ b2-3 + public const byte APP_UNLOCK2 = 0x33; // Basic ECU unlock (GEN3) + public const byte APP_MEMWR_SEQ = 0x34; // Legacy: 8-bit len @ b1, 16-bit addr @ b2-3 + public const byte APP_FIRSTUSE = 0x35; + public const byte APP_FLASH_WR = 0x36; + public const byte APP_READ_INFO = 0x37; // Read ECU info / keepalive + public const byte APP_CHANGE_PWD = 0x38; + public const byte APP_IMMOBILIZER = 0x3A; + public const byte APP_READ_DEBUG = 0x3D; + public const byte APP_UPGRADE_MOD = 0x3E; + + public const byte APP_MEM_INFO = 0x40; // Reserved / ignore for now + + // ── App commands — Table read ──────────────────────────────────────────── + public const byte APP_MEMRD_2D = 0x41; // 2D tables (tuner) + public const byte APP_MEMRD_SUBT = 0x42; // Subtables + public const byte APP_MEMRD_1D = 0x43; // 1D tables + public const byte APP_MEMRD_MISC = 0x44; // Misc values + device info + public const byte APP_MEMRD_2D_USER = 0x45; // 2D user tables (GEN3 basic ECU) + + // ── App commands — Table write ─────────────────────────────────────────── + public const byte APP_MEMWR_2D = 0x49; + public const byte APP_MEMWR_SUBT = 0x4A; + public const byte APP_MEMWR_1D = 0x4B; + public const byte APP_MEMWR_MISC = 0x4C; + public const byte APP_MEMWR_2D_USER = 0x4D; // GEN3 basic ECU + + // ── App response codes ─────────────────────────────────────────────────── + public const byte APP_CMD_SUCCESS = 0x51; + public const byte APP_CMD_FAIL = 0x52; + public const byte APP_CMD_INV = 0x53; + public const byte APP_MEMADDR_INV = 0x54; // Invalid read/write address + public const byte APP_MEMLEN_OVF = 0x55; // Length too large for Tx/Rx buffer + public const byte APP_MEMADDR_LOCK = 0x56; // Address locked (basic ECU) + public const byte APP_TUNER_LOCK = 0x57; // Command locked by tuner + + // ── App commands — Diagnostics streaming ──────────────────────────────── + public const byte APP_MONITORING = 0x70; // Streaming diagnostics frame + public const byte APP_MON_START = 0x71; + public const byte APP_MON_STOP = 0x72; + + // ── App commands — Tuner lock domain ──────────────────────────────────── + public const byte APP_UNLOCK_TUNER = 0x60; // Same usage model as APP_UNLOCK + public const byte APP_NEW_PWD_TUNER = 0x61; // Change tuner password (null×16 = disable) + public const byte APP_RST_PWD_TUNER = 0x62; // Reset tuner password (0x55×16 = disable + reset tables) + public const byte APP_ENCRYPT_READ = 0x63; + public const byte APP_ENCRYPT_WRITE = 0x64; + public const byte APP_RESET_SETTINGS = 0x65; + + // ── App commands — Special ─────────────────────────────────────────────── + public const byte APP_ERASE_ALL = 0xF0; + public const byte APP_LOCKED = 0xFF; +} diff --git a/TuneBoss.Core/Protocol/GenerationConfig.cs b/TuneBoss.Core/Protocol/GenerationConfig.cs new file mode 100644 index 0000000..81d4dca --- /dev/null +++ b/TuneBoss.Core/Protocol/GenerationConfig.cs @@ -0,0 +1,135 @@ +namespace TuneBoss.Core.Protocol; + +/// +/// Hardware/firmware generation, discriminated by App_Info_Version byte. +/// +public enum GenerationType +{ + Gen1 = 245, // App_Info_Version 0xF5 — legacy, APP_MEMRD_SEQ for all table ops + Gen2 = 1, // Dedicated read commands per table type; APP_UNLOCK + Gen3 = 2, // Same as Gen2 but 2D_USER uses APP_MEMRD_2D_USER; APP_UNLOCK2 +} + +/// +/// Per-generation command bytes and misc memory addresses resolved after +/// reading App_Info_Version from the device. +/// +public sealed class GenerationConfig +{ + // ── Table read commands ────────────────────────────────────────────────── + public byte ReadCmd1D { get; init; } + public byte ReadCmd2D { get; init; } + public byte ReadCmd2DUser{ get; init; } + public byte ReadCmdSubT { get; init; } + public byte ReadCmdMisc { get; init; } + + // ── Table write commands ───────────────────────────────────────────────── + public byte WriteCmd1D { get; init; } + public byte WriteCmd2D { get; init; } + public byte WriteCmd2DUser{ get; init; } + public byte WriteCmdSubT { get; init; } + public byte WriteCmdMisc { get; init; } + + // ── Unlock command ─────────────────────────────────────────────────────── + public byte UnlockCmd { get; init; } + + // ── Misc memory addresses ──────────────────────────────────────────────── + public ushort RpmLimitAddr { get; init; } + public ushort ShiftRpmLimitAddr { get; init; } + public ushort MusicModeStartAddr { get; init; } + public ushort ExtraPaddingAddr1 { get; init; } + public ushort ExtraPaddingAddr2 { get; init; } + public ushort ExtraPaddingAddr3 { get; init; } + public ushort ExtraPaddingAddr4 { get; init; } + public ushort ExtraPaddingAddr5 { get; init; } + public ushort ExtraPaddingAddr6 { get; init; } + + // ── Factory ───────────────────────────────────────────────────────────── + public static GenerationConfig For(GenerationType gen) => gen switch + { + GenerationType.Gen1 => new GenerationConfig + { + ReadCmd1D = Commands.APP_MEMRD_SEQ, + ReadCmd2D = Commands.APP_MEMRD_SEQ, + ReadCmd2DUser = Commands.APP_MEMRD_SEQ, + ReadCmdSubT = Commands.APP_MEMRD_SEQ, + ReadCmdMisc = Commands.APP_MEMRD_SEQ, + WriteCmd1D = Commands.APP_MEMWR_SEQ, + WriteCmd2D = Commands.APP_MEMWR_SEQ, + WriteCmd2DUser = Commands.APP_MEMWR_SEQ, + WriteCmdSubT = Commands.APP_MEMWR_SEQ, + WriteCmdMisc = Commands.APP_MEMWR_SEQ, + UnlockCmd = Commands.APP_UNLOCK, + RpmLimitAddr = 0x0840, + ShiftRpmLimitAddr = 0x08A0, + MusicModeStartAddr = 0x090E, + ExtraPaddingAddr1 = 0x08BC, + ExtraPaddingAddr2 = 0x08C8, + ExtraPaddingAddr3 = 0x08D4, + ExtraPaddingAddr4 = 0x08E0, + ExtraPaddingAddr5 = 0x08FC, + ExtraPaddingAddr6 = 0x0918, + }, + + GenerationType.Gen2 => new GenerationConfig + { + ReadCmd1D = Commands.APP_MEMRD_1D, + ReadCmd2D = Commands.APP_MEMRD_2D, + ReadCmd2DUser = Commands.APP_MEMRD_2D, + ReadCmdSubT = Commands.APP_MEMRD_SUBT, + ReadCmdMisc = Commands.APP_MEMRD_MISC, + WriteCmd1D = Commands.APP_MEMWR_1D, + WriteCmd2D = Commands.APP_MEMWR_2D, + WriteCmd2DUser = Commands.APP_MEMWR_2D, + WriteCmdSubT = Commands.APP_MEMWR_SUBT, + WriteCmdMisc = Commands.APP_MEMWR_MISC, + UnlockCmd = Commands.APP_UNLOCK, + RpmLimitAddr = 0x000C, + ShiftRpmLimitAddr = 0x006C, + MusicModeStartAddr = 0x00DA, + ExtraPaddingAddr1 = 0x0088, + ExtraPaddingAddr2 = 0x0094, + ExtraPaddingAddr3 = 0x00A0, + ExtraPaddingAddr4 = 0x00AC, + ExtraPaddingAddr5 = 0x00C8, + ExtraPaddingAddr6 = 0x00E4, + }, + + GenerationType.Gen3 => new GenerationConfig + { + ReadCmd1D = Commands.APP_MEMRD_1D, + ReadCmd2D = Commands.APP_MEMRD_2D, + ReadCmd2DUser = Commands.APP_MEMRD_2D_USER, // ← key difference from Gen2 + ReadCmdSubT = Commands.APP_MEMRD_SUBT, + ReadCmdMisc = Commands.APP_MEMRD_MISC, + WriteCmd1D = Commands.APP_MEMWR_1D, + WriteCmd2D = Commands.APP_MEMWR_2D, + WriteCmd2DUser = Commands.APP_MEMWR_2D_USER, // ← key difference from Gen2 + WriteCmdSubT = Commands.APP_MEMWR_SUBT, + WriteCmdMisc = Commands.APP_MEMWR_MISC, + UnlockCmd = Commands.APP_UNLOCK2, // ← different unlock + RpmLimitAddr = 0x000C, + ShiftRpmLimitAddr = 0x006C, + MusicModeStartAddr = 0x00DA, + ExtraPaddingAddr1 = 0x0088, + ExtraPaddingAddr2 = 0x0094, + ExtraPaddingAddr3 = 0x00A0, + ExtraPaddingAddr4 = 0x00AC, + ExtraPaddingAddr5 = 0x00C8, + ExtraPaddingAddr6 = 0x00E4, + }, + + _ => throw new ArgumentOutOfRangeException(nameof(gen), gen, "Unknown generation") + }; + + /// + /// Resolves generation from the App_Info_Version byte on the wire. + /// + public static GenerationType ResolveGeneration(byte appInfoVersion) => appInfoVersion switch + { + 245 => GenerationType.Gen1, + 1 => GenerationType.Gen2, + 2 => GenerationType.Gen3, + _ => throw new InvalidOperationException($"Unknown App_Info_Version: {appInfoVersion}") + }; +} diff --git a/TuneBoss.Core/Protocol/PacketBuilder.cs b/TuneBoss.Core/Protocol/PacketBuilder.cs new file mode 100644 index 0000000..ee6887a --- /dev/null +++ b/TuneBoss.Core/Protocol/PacketBuilder.cs @@ -0,0 +1,163 @@ +namespace TuneBoss.Core.Protocol; + +/// +/// Builds and parses TuneBoss BLE packets over Nordic UART Service (NUS). +/// +/// Outbound frame layout (verified against debug log 17-Mar-2026): +/// [0..3] FF 00 FF 00 Preamble +/// [4] TL_type Transport layer type (TL_POSTED / TL_NONPOSTED / TL_STREAMING) +/// [5] SeqNum Sequence number (0 for streaming) +/// [6] DwCount Payload size in DWords (4-byte units) +/// [7] InvSum 0xFF - (TL_type + SeqNum + DwCount) +/// [8..] Data Command payload (DwCount × 4 bytes) +/// [last4] DataChecksum ~sum of data DWords, little-endian uint32 +/// +/// Total frame size = 8 (header) + DwCount×4 (data) + 4 (checksum) +/// +public static class PacketBuilder +{ + private static readonly byte[] Preamble = { 0xFF, 0x00, 0xFF, 0x00 }; + + // ── Outbound ───────────────────────────────────────────────────────────── + + /// + /// Builds a complete outbound packet. + /// + /// Transport layer type (TL_NONPOSTED, TL_STREAMING etc.) + /// Sequence number. Use 0 for streaming commands. + /// Command payload. Will be zero-padded to DWord boundary. + public static byte[] Build(byte tlType, byte seqNum, ReadOnlySpan data) + { + // Pad data to DWord boundary + int paddedLen = (data.Length + 3) & ~3; + byte[] paddedData = new byte[paddedLen]; + data.CopyTo(paddedData); + + byte dwCount = (byte)(paddedLen / 4); + byte invSum = ChecksumHelper.HeaderInverseSum(tlType, seqNum, dwCount); + + // Total: 4 preamble + 4 header + paddedData + 4 checksum + byte[] frame = new byte[8 + paddedLen + 4]; + + // Preamble + frame[0] = 0xFF; frame[1] = 0x00; frame[2] = 0xFF; frame[3] = 0x00; + + // Header + frame[4] = tlType; + frame[5] = seqNum; + frame[6] = dwCount; + frame[7] = invSum; + + // Data + paddedData.CopyTo(frame, 8); + + // Checksum + ChecksumHelper.WriteChecksumDW(paddedData, frame.AsSpan(8 + paddedLen)); + + return frame; + } + + /// + /// Convenience: builds a TL_NONPOSTED packet with a single command byte + /// and optional parameters, auto-padded. + /// + public static byte[] BuildNonPosted(byte seqNum, byte command, ReadOnlySpan parameters = default) + { + byte[] payload = new byte[1 + parameters.Length]; + payload[0] = command; + parameters.CopyTo(payload.AsSpan(1)); + return Build(Commands.TL_NONPOSTED, seqNum, payload); + } + + /// + /// Convenience: builds a TL_STREAMING packet (always seq=0). + /// + public static byte[] BuildStreaming(byte command) + { + return Build(Commands.TL_STREAMING, seqNum: 0, data: new[] { command }); + } + + /// + /// Builds an APP_MON_START (0x71) streaming packet. + /// + public static byte[] BuildMonStart() => BuildStreaming(Commands.APP_MON_START); + + /// + /// Builds an APP_MON_STOP (0x72) streaming packet. + /// + public static byte[] BuildMonStop() => BuildStreaming(Commands.APP_MON_STOP); + + /// + /// Builds an APP_READ_INFO (0x37) request. + /// Data = [0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] — 2 DWords. + /// Verified: log line 5–7. + /// + public static byte[] BuildReadInfo(byte seqNum) + => BuildNonPosted(seqNum, Commands.APP_READ_INFO, new byte[7]); + + // ── Inbound ────────────────────────────────────────────────────────────── + + /// + /// Result of parsing an inbound packet. + /// + public sealed class InboundPacket + { + public byte TlType { get; init; } + public byte SeqNum { get; init; } + public byte DwCount { get; init; } + public byte ResponseCode { get; init; } // First byte of payload (e.g. 0x51 = success) + public byte OriginalCmd { get; init; } // Second byte of payload (echoed command) + public byte[] Payload { get; init; } = Array.Empty(); // Full payload excl. checksum + public bool ChecksumValid { get; init; } + } + + /// + /// Parses a raw inbound frame received over BLE. + /// Returns null if the preamble is missing or the frame is too short. + /// + public static InboundPacket? Parse(ReadOnlySpan frame) + { + // Minimum: 4 preamble + 4 header + 4 data + 4 checksum = 16 bytes + if (frame.Length < 16) return null; + + // Validate preamble + if (frame[0] != 0xFF || frame[1] != 0x00 || frame[2] != 0xFF || frame[3] != 0x00) + return null; + + byte tlType = frame[4]; + byte seqNum = frame[5]; + byte dwCount = frame[6]; + // frame[7] = invSum (not validated here; add if needed) + + int payloadLen = dwCount * 4; + int expectedLen = 8 + payloadLen + 4; + if (frame.Length < expectedLen) return null; + + var payloadWithChecksum = frame.Slice(8, payloadLen + 4); + var payload = frame.Slice(8, payloadLen).ToArray(); + + bool csValid = ChecksumHelper.VerifyChecksumDW(payloadWithChecksum); + + return new InboundPacket + { + TlType = tlType, + SeqNum = seqNum, + DwCount = dwCount, + ResponseCode = payload.Length > 0 ? payload[0] : (byte)0, + OriginalCmd = payload.Length > 1 ? payload[1] : (byte)0, + Payload = payload, + ChecksumValid = csValid, + }; + } + + // ── Diagnostics helpers ────────────────────────────────────────────────── + + /// + /// Returns true if a raw frame is a diagnostics streaming packet (0x70). + /// Fast check without full parse — used in the hot receive path. + /// + public static bool IsDiagnosticsFrame(ReadOnlySpan frame) + => frame.Length >= 9 + && frame[4] == Commands.TL_STREAMING + && frame[8] == Commands.APP_MONITORING; +} diff --git a/TuneBoss.Core/TuneBoss.Core.csproj b/TuneBoss.Core/TuneBoss.Core.csproj new file mode 100644 index 0000000..27670c6 --- /dev/null +++ b/TuneBoss.Core/TuneBoss.Core.csproj @@ -0,0 +1,15 @@ + + + net9.0-windows10.0.19041.0 + enable + enable + + + + + + + + + + \ No newline at end of file diff --git a/TuneBossPC.slnx b/TuneBossPC.slnx new file mode 100644 index 0000000..6ab51f7 --- /dev/null +++ b/TuneBossPC.slnx @@ -0,0 +1,4 @@ + + + + diff --git a/TuneBossPC/App.xaml b/TuneBossPC/App.xaml new file mode 100644 index 0000000..44505b8 --- /dev/null +++ b/TuneBossPC/App.xaml @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + diff --git a/TuneBossPC/App.xaml.cs b/TuneBossPC/App.xaml.cs new file mode 100644 index 0000000..b2eb7f8 --- /dev/null +++ b/TuneBossPC/App.xaml.cs @@ -0,0 +1,81 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; +using System.Windows; +using TuneBoss.Core.BLE; +using TuneBossPC.Services; +using TuneBossPC.ViewModels; +using TuneBossPC.ViewModels.Tables; +using TuneBossPC.Views; +using Wpf.Ui; + +namespace TuneBossPC; + +public partial class App : Application +{ + private readonly IHost _host; + + public App() + { + _host = Host.CreateDefaultBuilder() + .ConfigureServices(ConfigureServices) + .Build(); + } + + private static void ConfigureServices(IServiceCollection services) + { + // --sim on the command line swaps in the fake ECU. + bool useSim = Environment.GetCommandLineArgs().Contains("--sim"); + if (useSim) + services.AddSingleton(); + else + services.AddSingleton(); + + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddTransient(); + services.AddTransient(); + services.AddTransient(); + services.AddTransient(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddTransient(); + services.AddTransient(); + services.AddSingleton(); + services.AddTransient(); + services.AddTransient(); + services.AddSingleton(); + services.AddSingleton(); + } + + protected override async void OnStartup(StartupEventArgs e) + { + await _host.StartAsync(); + Wpf.Ui.Appearance.ApplicationThemeManager.Apply( + Wpf.Ui.Appearance.ApplicationTheme.Dark); + var mainWindow = _host.Services.GetRequiredService(); + mainWindow.Show(); + base.OnStartup(e); + } + + protected override async void OnExit(ExitEventArgs e) + { + await _host.StopAsync(); + _host.Dispose(); + base.OnExit(e); + } + + public static T GetService() where T : class + => (Current as App)!._host.Services.GetRequiredService(); +} diff --git a/TuneBossPC/AppInfo.cs b/TuneBossPC/AppInfo.cs new file mode 100644 index 0000000..b550dde --- /dev/null +++ b/TuneBossPC/AppInfo.cs @@ -0,0 +1,82 @@ +using System.Reflection; + +namespace TuneBossPC; + +/// +/// Build/version string shown in the UI (top-left, under the logo). +/// +/// When launched as a published ClickOnce install, shows the ClickOnce publish +/// version — the auto-incrementing major.minor.build.revision from the publish +/// profile (ApplicationVersion, e.g. 1.0.0.7). +/// +/// When run outside ClickOnce (Visual Studio / a direct exe run) there is no +/// deployment version, so it falls back to the assembly <Version>. +/// +public static class AppInfo +{ + /// e.g. "v1.0.0.7" (ClickOnce publish) or "v2026.8.13" (assembly fallback). + public static string Version { get; } = ResolveVersion(); + + /// + /// Whether the "advanced" nav items (Config + 1D Tables) are shown. FALSE in the + /// dealer release — a cut-down build for dealers until those pages' UI/UX is + /// cleaned up. Controlled by the DEALER compile symbol: define it (publish with + /// -p:Dealer=true, or a publish profile that sets <Dealer>true</Dealer>) + /// to produce the dealer build; a normal build shows everything. + /// + public static bool ShowAdvancedNav => +#if DEALER + false; +#else + true; +#endif + + private static string ResolveVersion() + { + // 1) ClickOnce publish version, if the app is network-deployed. + // Reflection keeps this compiling even when the ClickOnce API type + // isn't present (e.g. running the plain exe during development). + var clickOnce = TryGetClickOnceVersion(); + if (clickOnce != null) + return "v" + clickOnce; + + // 2) Fallback: assembly InformationalVersion (mirrors ). + var asm = Assembly.GetExecutingAssembly(); + var info = asm.GetCustomAttribute()?.InformationalVersion; + if (!string.IsNullOrWhiteSpace(info)) + { + int plus = info.IndexOf('+'); + if (plus >= 0) info = info[..plus]; + return "v" + info; + } + + // 3) Last resort: numeric assembly version. + var v = asm.GetName().Version; + return v != null ? $"v{v.Major}.{v.Minor}.{v.Build}" : "v—"; + } + + private static string? TryGetClickOnceVersion() + { + try + { + var adType = Type.GetType( + "System.Deployment.Application.ApplicationDeployment, System.Deployment"); + if (adType == null) return null; + + var isDeployed = adType.GetProperty("IsNetworkDeployed", + BindingFlags.Public | BindingFlags.Static)?.GetValue(null) as bool?; + if (isDeployed != true) return null; + + var current = adType.GetProperty("CurrentDeployment", + BindingFlags.Public | BindingFlags.Static)?.GetValue(null); + var version = current?.GetType() + .GetProperty("CurrentVersion")?.GetValue(current); + + return version?.ToString(); // "major.minor.build.revision" + } + catch + { + return null; // not deployed, or API unavailable — use the fallback + } + } +} diff --git a/TuneBossPC/AssemblyInfo.cs b/TuneBossPC/AssemblyInfo.cs new file mode 100644 index 0000000..b0ec827 --- /dev/null +++ b/TuneBossPC/AssemblyInfo.cs @@ -0,0 +1,10 @@ +using System.Windows; + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] diff --git a/TuneBossPC/Assets/Fonts/Roboto-Bold.ttf b/TuneBossPC/Assets/Fonts/Roboto-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..651618564b510664348f0419d7869be392ebd666 GIT binary patch literal 159900 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

o^%&r8QC3m}Neb#~(v4j&)#M0K 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 IJ#Jb51NZ@?ivR!s literal 0 HcmV?d00001 diff --git a/TuneBossPC/Assets/Fonts/RobotoCondensed-Medium.ttf b/TuneBossPC/Assets/Fonts/RobotoCondensed-Medium.ttf new file mode 100644 index 0000000000000000000000000000000000000000..e3f02fd6c7183b1264e24711db1aaeabb12565bf GIT binary patch literal 144884 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 z zGAK+zTtafZJ0c2M;4Qq1ELwH6w`w09X$wn^)o≺*}?7d`*?3j&u1Oym3UNqiG1j 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/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%0D9@r6qsZ2=|g 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%0D=eG@!tD8wrLMR0fIaYZPmCdW14K)INu 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 literal 0 HcmV?d00001 diff --git a/TuneBossPC/Assets/Styles/Colors.xaml b/TuneBossPC/Assets/Styles/Colors.xaml new file mode 100644 index 0000000..ffc0c94 --- /dev/null +++ b/TuneBossPC/Assets/Styles/Colors.xaml @@ -0,0 +1,67 @@ + + + + + + #FF111416 + #FF1A1D21 + #FF22262B + #FF2C3036 + #FF4A505A + #FF16191D + + + #FFFF6B00 + #FF994000 + #33FF6B00 + + + #FFF4F6F8 + #FFB4BAC4 + #FF6E7580 + #FFFF7D1F + + + #FF3DDC84 + #FFFF4D4D + #FFFFD11A + #FF4C90FF + + + #FF0050B4 + #FF0096C8 + #FF00C8C8 + #FF50C850 + #FF96DC00 + #FFDCDC00 + + + + + + + + + + + + + + + + + + + + + + diff --git a/TuneBossPC/Assets/Styles/Controls.xaml b/TuneBossPC/Assets/Styles/Controls.xaml new file mode 100644 index 0000000..34ac579 --- /dev/null +++ b/TuneBossPC/Assets/Styles/Controls.xaml @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/TuneBossPC/Assets/Styles/Typography.xaml b/TuneBossPC/Assets/Styles/Typography.xaml new file mode 100644 index 0000000..b9c74b4 --- /dev/null +++ b/TuneBossPC/Assets/Styles/Typography.xaml @@ -0,0 +1,22 @@ + + + pack://application:,,,/Assets/Fonts/#Roboto Condensed + pack://application:,,,/Assets/Fonts/#Roboto + + pack://application:,,,/Assets/Fonts/#Roboto + + 11 + 12 + 14 + 18 + 32 + + 17 + 18 + 22 + + diff --git a/TuneBossPC/Controls/HoldToConfirmButton.cs b/TuneBossPC/Controls/HoldToConfirmButton.cs new file mode 100644 index 0000000..05b8f9b --- /dev/null +++ b/TuneBossPC/Controls/HoldToConfirmButton.cs @@ -0,0 +1,208 @@ +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Animation; +using System.Windows.Threading; + +namespace TuneBossPC.Controls; + +///

+/// A button that fires its command only after being pressed and HELD for +/// seconds. A fill bar (template part "PART_Fill", +/// scaled horizontally) shows progress; releasing early cancels and briefly +/// shows a "HOLD" hint so the gesture is discoverable. +/// +/// Used for destructive/permanent actions (ECU FLASH) where a stray click — +/// or a gloved hand — must never trigger accidentally. A press-and-hold is +/// deliberate in a way a dialog click-through is not. +/// +[TemplatePart(Name = PartFill, Type = typeof(FrameworkElement))] +public class HoldToConfirmButton : ContentControl +{ + private const string PartFill = "PART_Fill"; + private const string PartSuccess = "PART_Success"; + private FrameworkElement? _successLayer; + + private readonly ScaleTransform _fillScale = new(0.0, 1.0); + private readonly DispatcherTimer _tick = new() { Interval = TimeSpan.FromMilliseconds(25) }; + private readonly DispatcherTimer _hintTimer = new() { Interval = TimeSpan.FromMilliseconds(800) }; + + private DateTime _pressedAt; + private bool _holding; + private bool _showingHint; + private object? _originalContent; + private bool _canExecute = true; + + public HoldToConfirmButton() + { + Focusable = true; + Cursor = Cursors.Hand; + _tick.Tick += (_, _) => OnTick(); + _hintTimer.Tick += (_, _) => ClearHint(); + } + + // ── HoldCommand ────────────────────────────────────────────────────────── + public static readonly DependencyProperty HoldCommandProperty = + DependencyProperty.Register(nameof(HoldCommand), typeof(ICommand), typeof(HoldToConfirmButton), + new PropertyMetadata(null, OnHoldCommandChanged)); + + public ICommand? HoldCommand + { + get => (ICommand?)GetValue(HoldCommandProperty); + set => SetValue(HoldCommandProperty, value); + } + + public static readonly DependencyProperty HoldCommandParameterProperty = + DependencyProperty.Register(nameof(HoldCommandParameter), typeof(object), typeof(HoldToConfirmButton)); + + public object? HoldCommandParameter + { + get => GetValue(HoldCommandParameterProperty); + set => SetValue(HoldCommandParameterProperty, value); + } + + /// + /// Increment to flash the success layer (green double-blink). Bind to a counter + /// the view-model bumps after a confirmed flash write, so success is visible + /// without reading the status line. + /// + public static readonly DependencyProperty SuccessSignalProperty = + DependencyProperty.Register(nameof(SuccessSignal), typeof(int), typeof(HoldToConfirmButton), + new PropertyMetadata(0, (d, _) => ((HoldToConfirmButton)d).BlinkSuccess())); + + public int SuccessSignal + { + get => (int)GetValue(SuccessSignalProperty); + set => SetValue(SuccessSignalProperty, value); + } + + private void BlinkSuccess() + { + if (_successLayer == null) return; + var anim = new DoubleAnimation + { + From = 0, To = 0.9, + Duration = new Duration(TimeSpan.FromMilliseconds(170)), + AutoReverse = true, + RepeatBehavior = new RepeatBehavior(2), // two clear green pulses + }; + _successLayer.BeginAnimation(OpacityProperty, anim); + } + + /// Seconds the button must be held before the command fires. + public static readonly DependencyProperty HoldDurationProperty = + DependencyProperty.Register(nameof(HoldDuration), typeof(double), typeof(HoldToConfirmButton), + new PropertyMetadata(1.2)); + + public double HoldDuration + { + get => (double)GetValue(HoldDurationProperty); + set => SetValue(HoldDurationProperty, value); + } + + private static void OnHoldCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var self = (HoldToConfirmButton)d; + if (e.OldValue is ICommand oldCmd) oldCmd.CanExecuteChanged -= self.OnCanExecuteChanged; + if (e.NewValue is ICommand newCmd) newCmd.CanExecuteChanged += self.OnCanExecuteChanged; + self.RefreshCanExecute(); + } + + private void OnCanExecuteChanged(object? sender, EventArgs e) => RefreshCanExecute(); + + private void RefreshCanExecute() + { + _canExecute = HoldCommand?.CanExecute(HoldCommandParameter) ?? true; + CoerceValue(IsEnabledProperty); + } + + protected override bool IsEnabledCore => base.IsEnabledCore && _canExecute; + + // ── Template ───────────────────────────────────────────────────────────── + public override void OnApplyTemplate() + { + base.OnApplyTemplate(); + if (GetTemplateChild(PartFill) is FrameworkElement fill) + { + fill.RenderTransformOrigin = new Point(0, 0); + fill.RenderTransform = _fillScale; + _fillScale.ScaleX = 0; + } + _successLayer = GetTemplateChild(PartSuccess) as FrameworkElement; + } + + // ── Hold gesture ───────────────────────────────────────────────────────── + protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e) + { + base.OnMouseLeftButtonDown(e); + if (!IsEnabled) return; + + ClearHint(); + _holding = true; + _pressedAt = DateTime.UtcNow; + CaptureMouse(); + _tick.Start(); + e.Handled = true; + } + + protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e) + { + base.OnMouseLeftButtonUp(e); + if (_holding) CancelHold(showHint: true); + if (IsMouseCaptured) ReleaseMouseCapture(); + e.Handled = true; + } + + protected override void OnLostMouseCapture(MouseEventArgs e) + { + base.OnLostMouseCapture(e); + if (_holding) CancelHold(showHint: false); + } + + private void OnTick() + { + if (!_holding) return; + double frac = (DateTime.UtcNow - _pressedAt).TotalSeconds / Math.Max(0.1, HoldDuration); + _fillScale.ScaleX = Math.Min(1.0, frac); + if (frac >= 1.0) Complete(); + } + + private void Complete() + { + _tick.Stop(); + _holding = false; + if (IsMouseCaptured) ReleaseMouseCapture(); + _fillScale.ScaleX = 0; + + var cmd = HoldCommand; + if (cmd?.CanExecute(HoldCommandParameter) == true) + cmd.Execute(HoldCommandParameter); + } + + private void CancelHold(bool showHint) + { + _tick.Stop(); + _holding = false; + _fillScale.ScaleX = 0; + + // Released early → teach the gesture. + if (showHint && !_showingHint) + { + _showingHint = true; + _originalContent = Content; + Content = "HOLD…"; + _hintTimer.Start(); + } + } + + private void ClearHint() + { + _hintTimer.Stop(); + if (_showingHint) + { + Content = _originalContent; + _showingHint = false; + } + } +} diff --git a/TuneBossPC/Controls/Surface3DControl.cs b/TuneBossPC/Controls/Surface3DControl.cs new file mode 100644 index 0000000..e1c17a5 --- /dev/null +++ b/TuneBossPC/Controls/Surface3DControl.cs @@ -0,0 +1,407 @@ +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Media.Media3D; + +namespace TuneBossPC.Controls; + +/// +/// Rotatable 3D surface ("contour map") of a 2D tuning table, rendered with WPF's +/// built-in Viewport3D — no external packages. X = RPM columns, depth = Load rows, +/// height + colour = cell value (same ramp as the grid heatmap, via a 1-D texture). +/// +/// Axis reference: RPM / LOAD tick labels are 2D overlay text projected from 3D +/// anchor points, so they stay screen-readable at any rotation, and they jump to +/// whichever edge currently faces the camera. A live tracker marker (orange +/// diamond) can be placed on any cell via . +/// +/// Interaction: left-drag orbits, mouse wheel zooms. +/// +public sealed class Surface3DControl : Border +{ + private readonly Viewport3D _viewport = new(); + private readonly Canvas _overlay = new() { IsHitTestVisible = false }; + private readonly PerspectiveCamera _camera = new() { FieldOfView = 40 }; + private readonly MeshGeometry3D _mesh = new(); + + // Tracker marker + private readonly TranslateTransform3D _markerPos = new(); + private readonly ScaleTransform3D _markerScale = new(0, 0, 0); // hidden until placed + private int _trackerRow = -1, _trackerCol = -1; + + // Data cache (for marker height + label layout) + private double[]? _values; + private double _min, _max; + private int _cols, _rows; + private string[] _colLabels = Array.Empty(); + private string[] _rowLabels = Array.Empty(); + + // Overlay label pool + private readonly List _labels = new(); + + // Orbit state + // _dist starts at the zoom clamp maximum so the map first appears fully + // zoomed out — the whole surface (and both axis edges) visible at a glance. + private double _yaw = -0.70, _pitch = 0.55, _dist = 95; + private double _fitDist = 95; // recomputed from data + panel aspect + private bool _userZoomed; // once the user zooms, we stop auto-fitting + private Point _lastDrag; + private bool _dragging; + + // World scale + private const double SX = 1.0; // per RPM column + private const double SZ = 2.4; // per Load row + private const double H = 7.0; // full height span + private const int ColLabelStep = 2; // label every 2nd RPM column + + public Surface3DControl() + { + Background = new SolidColorBrush(Color.FromRgb(0x14, 0x17, 0x1A)); + BorderBrush = (Brush?)Application.Current.TryFindResource("BorderBrush") ?? Brushes.DimGray; + BorderThickness = new Thickness(1); + CornerRadius = new CornerRadius(6); + ClipToBounds = true; + + var root = new Grid(); + root.Children.Add(_viewport); + root.Children.Add(_overlay); + Child = root; + + _viewport.Camera = _camera; + + var material = new DiffuseMaterial(BuildRampBrush()); + material.Freeze(); + var surface = new GeometryModel3D(_mesh, material) { BackMaterial = material }; + + var markerBrush = new SolidColorBrush(Color.FromRgb(0xFF, 0xFF, 0xFF)); + var markerMat = new MaterialGroup(); + markerMat.Children.Add(new DiffuseMaterial(markerBrush)); + markerMat.Children.Add(new EmissiveMaterial(new SolidColorBrush(Color.FromRgb(0x88, 0x88, 0x88)))); + markerMat.Freeze(); + var markerXform = new Transform3DGroup(); + markerXform.Children.Add(_markerScale); + markerXform.Children.Add(_markerPos); + var marker = new GeometryModel3D(BuildDiamondMesh(), markerMat) + { + BackMaterial = markerMat, + Transform = markerXform, + }; + + var group = new Model3DGroup(); + group.Children.Add(new AmbientLight(Color.FromRgb(0x8C, 0x8C, 0x8C))); + group.Children.Add(new DirectionalLight(Color.FromRgb(0x90, 0x90, 0x90), + new Vector3D(-0.3, -0.8, -0.5))); + group.Children.Add(surface); + group.Children.Add(marker); + _viewport.Children.Add(new ModelVisual3D { Content = group }); + + UpdateCamera(); + + SizeChanged += (_, _) => { RecomputeFitDistance(); UpdateOverlay(); }; + + MouseLeftButtonDown += (_, e) => + { + _dragging = true; _lastDrag = e.GetPosition(this); CaptureMouse(); + }; + MouseLeftButtonUp += (_, _) => { _dragging = false; ReleaseMouseCapture(); }; + MouseMove += (_, e) => + { + if (!_dragging) return; + var p = e.GetPosition(this); + _yaw += (p.X - _lastDrag.X) * 0.010; + _pitch += (p.Y - _lastDrag.Y) * 0.008; + _pitch = Math.Clamp(_pitch, 0.05, 1.45); + _lastDrag = p; + UpdateCamera(); + }; + MouseWheel += (_, e) => + { + _userZoomed = true; + _dist = Math.Clamp(_dist * Math.Exp(-e.Delta * 0.0009), 10, _fitDist); + UpdateCamera(); + }; + } + + // ── Public API ────────────────────────────────────────────────────────────── + + /// + /// Updates the surface from a row-major value array (values[row*cols+col]) + /// plus axis tick label strings. Heights/colours normalise to the array's own + /// min/max so relief is always visible. + /// + public void SetData(double[] values, int cols, int rows, + string[]? colLabels = null, string[]? rowLabels = null) + { + if (values.Length < cols * rows || cols < 2 || rows < 2) return; + + double min = double.MaxValue, max = double.MinValue; + for (int i = 0; i < cols * rows; i++) + { + if (values[i] < min) min = values[i]; + if (values[i] > max) max = values[i]; + } + + bool rebuildTopology = cols != _cols || rows != _rows; + _values = values; _min = min; _max = max; + _cols = cols; _rows = rows; + _colLabels = colLabels ?? Array.Empty(); + _rowLabels = rowLabels ?? Array.Empty(); + + double span = max - min; + var positions = new Point3DCollection(cols * rows); + var texCoords = new PointCollection(cols * rows); + + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + { + double norm = span <= 0 ? 0.5 : (values[r * cols + c] - min) / span; + positions.Add(new Point3D(WX(c), norm * H, WZ(r))); + texCoords.Add(new Point(Math.Clamp(norm, 0.004, 0.996), 0.5)); + } + + _mesh.Positions = positions; + _mesh.TextureCoordinates = texCoords; + + if (rebuildTopology) + { + var idx = new Int32Collection((cols - 1) * (rows - 1) * 6); + for (int r = 0; r < rows - 1; r++) + for (int c = 0; c < cols - 1; c++) + { + int i0 = r * cols + c; + int i1 = i0 + 1; + int i2 = i0 + cols; + int i3 = i2 + 1; + idx.Add(i0); idx.Add(i2); idx.Add(i1); + idx.Add(i1); idx.Add(i2); idx.Add(i3); + } + _mesh.TriangleIndices = idx; + } + + PlaceMarker(); + RecomputeFitDistance(); + UpdateOverlay(); + } + + /// + /// Auto-framing: from the surface's bounding sphere and the panel's aspect + /// ratio, computes the camera distance at which the WHOLE surface (plus label + /// margin) fits in view at any rotation — no guessed constants, no clipping. + /// Applied as the default and the zoom-out limit; a manual zoom sticks. + /// + private void RecomputeFitDistance() + { + if (_cols < 2 || _rows < 2 || ActualWidth <= 0 || ActualHeight <= 0) return; + + double hx = (_cols - 1) * SX / 2.0 + 2.2; // + label margin + double hz = (_rows - 1) * SZ / 2.0 + 2.2; + double hy = H * 0.65; // camera centre sits at 0.35·H + double radius = Math.Sqrt(hx * hx + hy * hy + hz * hz); + + double tanH = Math.Tan(_camera.FieldOfView * Math.PI / 360.0); + double tanV = tanH * ActualHeight / Math.Max(1.0, ActualWidth); + double half = Math.Atan(Math.Min(tanH, tanV)); // tighter of the two FOVs + + _fitDist = radius / Math.Max(0.05, Math.Sin(half)); + + if (!_userZoomed) + { + _dist = _fitDist; + UpdateCamera(); + } + else if (_dist > _fitDist) + { + _dist = _fitDist; + UpdateCamera(); + } + } + + /// Places the live tracker marker on a cell; pass -1,-1 to hide. + public void SetTracker(int row, int col) + { + _trackerRow = row; _trackerCol = col; + PlaceMarker(); + } + + // ── Internals ─────────────────────────────────────────────────────────────── + + private double WX(int c) => (c - (_cols - 1) / 2.0) * SX; + private double WZ(int r) => (r - (_rows - 1) / 2.0) * SZ; + + private double HeightAt(int row, int col) + { + if (_values == null) return 0; + double span = _max - _min; + double v = _values[row * _cols + col]; + return (span <= 0 ? 0.5 : (v - _min) / span) * H; + } + + private void PlaceMarker() + { + bool visible = _values != null && + _trackerRow >= 0 && _trackerRow < _rows && + _trackerCol >= 0 && _trackerCol < _cols; + if (!visible) + { + _markerScale.ScaleX = _markerScale.ScaleY = _markerScale.ScaleZ = 0; + return; + } + + _markerScale.ScaleX = _markerScale.ScaleY = _markerScale.ScaleZ = 1; + _markerPos.OffsetX = WX(_trackerCol); + _markerPos.OffsetY = HeightAt(_trackerRow, _trackerCol) + 0.55; + _markerPos.OffsetZ = WZ(_trackerRow); + } + + private void UpdateCamera() + { + var center = new Point3D(0, H * 0.35, 0); + double cp = Math.Cos(_pitch), sp = Math.Sin(_pitch); + var offset = new Vector3D(cp * Math.Sin(_yaw), sp, cp * Math.Cos(_yaw)) * _dist; + _camera.Position = center + offset; + _camera.LookDirection = center - _camera.Position; + _camera.UpDirection = new Vector3D(0, 1, 0); + UpdateOverlay(); + } + + /// + /// Lays out the axis tick labels: 3D anchor points on the camera-facing edges, + /// projected to 2D and positioned on the overlay canvas. + /// + private void UpdateOverlay() + { + _overlay.Children.Clear(); + int used = 0; + if (_cols < 2 || _rows < 2 || ActualWidth < 40 || ActualHeight < 40) return; + + // Camera-facing edges: RPM labels along the near Z edge, LOAD along the near + // X edge — both flip sides as the map is rotated so they stay toward the viewer. + int zSign = Math.Cos(_yaw) >= 0 ? 1 : -1; + int xSign = Math.Sin(_yaw) >= 0 ? 1 : -1; + double zEdge = (zSign > 0 ? WZ(_rows - 1) : WZ(0)) + zSign * 1.1; + double xEdge = (xSign > 0 ? WX(_cols - 1) : WX(0)) + xSign * 1.2; + + // RPM ticks (every Nth column) along the near Z edge + for (int c = 0; c < _cols && c < _colLabels.Length; c += ColLabelStep) + AddLabel(ref used, _colLabels[c], new Point3D(WX(c), 0, zEdge), centerX: true); + + // RPM caption past the end AWAY from the LOAD edge (avoids overlap) + double rpmCapX = xSign > 0 ? WX(0) - 1.8 : WX(_cols - 1) + 1.8; + AddLabel(ref used, "RPM", new Point3D(rpmCapX, 0, zEdge), centerX: true, bold: true); + + // LOAD ticks (all rows) along the near X edge + for (int r = 0; r < _rows && r < _rowLabels.Length; r++) + AddLabel(ref used, _rowLabels[r], new Point3D(xEdge, 0, WZ(r)), centerX: true); + + // LOAD caption past the end AWAY from the RPM edge + double loadCapZ = zSign > 0 ? WZ(0) - 1.6 : WZ(_rows - 1) + 1.6; + AddLabel(ref used, "LOAD", new Point3D(xEdge, 0, loadCapZ), centerX: true, bold: true); + } + + private void AddLabel(ref int poolIndex, string text, Point3D world, bool centerX, bool bold = false) + { + if (!WorldToScreen(world, out var pt)) return; + if (pt.X < -30 || pt.Y < -14 || pt.X > ActualWidth + 30 || pt.Y > ActualHeight + 14) return; + + TextBlock tb; + if (poolIndex < _labels.Count) tb = _labels[poolIndex]; + else { tb = new TextBlock(); _labels.Add(tb); } + poolIndex++; + + tb.Text = text; + tb.FontSize = bold ? 11 : 10; + tb.FontWeight = bold ? FontWeights.Bold : FontWeights.Normal; + tb.Foreground = bold + ? (Brush?)Application.Current.TryFindResource("TextPrimaryBrush") ?? Brushes.White + : (Brush?)Application.Current.TryFindResource("TextSecondaryBrush") ?? Brushes.Gray; + + tb.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity)); + Canvas.SetLeft(tb, centerX ? pt.X - tb.DesiredSize.Width / 2 : pt.X); + Canvas.SetTop(tb, pt.Y - tb.DesiredSize.Height / 2); + _overlay.Children.Add(tb); + } + + /// Projects a world point through the perspective camera to canvas pixels. + private bool WorldToScreen(Point3D world, out Point screen) + { + screen = default; + double w = ActualWidth, h = ActualHeight; + if (w <= 0 || h <= 0) return false; + + var fwd = _camera.LookDirection; fwd.Normalize(); + var right = Vector3D.CrossProduct(fwd, _camera.UpDirection); right.Normalize(); + var up = Vector3D.CrossProduct(right, fwd); + + var v = world - _camera.Position; + double zv = Vector3D.DotProduct(v, fwd); + if (zv <= 0.1) return false; // behind the camera + + double xv = Vector3D.DotProduct(v, right); + double yv = Vector3D.DotProduct(v, up); + + double tanH = Math.Tan(_camera.FieldOfView * Math.PI / 360.0); // half horizontal FOV + double xNdc = xv / (zv * tanH); + double yNdc = yv / (zv * tanH * h / w); + + screen = new Point((xNdc + 1) / 2 * w, (1 - yNdc) / 2 * h); + return true; + } + + /// Small octahedron used as the tracker marker. + private static MeshGeometry3D BuildDiamondMesh() + { + const double s = 0.45, hh = 0.62; + var m = new MeshGeometry3D + { + Positions = new Point3DCollection + { + new(0, hh, 0), // top + new(-s, 0, 0), new(0, 0, s), new(s, 0, 0), new(0, 0, -s), + new(0, -hh, 0), // bottom + }, + TriangleIndices = new Int32Collection + { + 0,1,2, 0,2,3, 0,3,4, 0,4,1, + 5,2,1, 5,3,2, 5,4,3, 5,1,4, + }, + }; + m.Freeze(); + return m; + } + + /// 1-D heatmap gradient texture — mirrors the grid's colour ramp. + private static ImageBrush BuildRampBrush() + { + var stops = new (double T, Color C)[] + { + (0.00, Color.FromRgb(0x00, 0x50, 0xB4)), + (0.17, Color.FromRgb(0x00, 0x96, 0xC8)), + (0.34, Color.FromRgb(0x00, 0xC8, 0xC8)), + (0.51, Color.FromRgb(0x50, 0xC8, 0x50)), + (0.68, Color.FromRgb(0x96, 0xDC, 0x00)), + (0.85, Color.FromRgb(0xDC, 0xDC, 0x00)), + (1.00, Color.FromRgb(0xFF, 0x80, 0x00)), + }; + + const int W = 256; + var pixels = new byte[W * 4]; + for (int x = 0; x < W; x++) + { + double t = x / (double)(W - 1); + int s = 0; + while (s < stops.Length - 2 && t > stops[s + 1].T) s++; + double f = (t - stops[s].T) / Math.Max(1e-9, stops[s + 1].T - stops[s].T); + f = Math.Clamp(f, 0, 1); + byte R = (byte)(stops[s].C.R + (stops[s + 1].C.R - stops[s].C.R) * f); + byte G = (byte)(stops[s].C.G + (stops[s + 1].C.G - stops[s].C.G) * f); + byte B = (byte)(stops[s].C.B + (stops[s + 1].C.B - stops[s].C.B) * f); + pixels[x * 4 + 0] = B; pixels[x * 4 + 1] = G; pixels[x * 4 + 2] = R; pixels[x * 4 + 3] = 255; + } + + var bmp = BitmapSource.Create(W, 1, 96, 96, PixelFormats.Bgra32, null, pixels, W * 4); + bmp.Freeze(); + return new ImageBrush(bmp) { ViewportUnits = BrushMappingMode.Absolute }; + } +} diff --git a/TuneBossPC/Converters/EqualityMultiConverter.cs b/TuneBossPC/Converters/EqualityMultiConverter.cs new file mode 100644 index 0000000..3d12c54 --- /dev/null +++ b/TuneBossPC/Converters/EqualityMultiConverter.cs @@ -0,0 +1,15 @@ +using System.Globalization; +using System.Windows.Data; + +namespace TuneBossPC.Converters; + +/// True when the two bound values are equal — used by the nav rail to +/// highlight the button whose Tag matches the currently displayed page. +public sealed class EqualityMultiConverter : IMultiValueConverter +{ + public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) => + values.Length >= 2 && Equals(values[0]?.ToString(), values[1]?.ToString()); + + public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture) => + throw new NotSupportedException(); +} diff --git a/TuneBossPC/Converters/ErrorStatusConverters.cs b/TuneBossPC/Converters/ErrorStatusConverters.cs new file mode 100644 index 0000000..b6e7b41 --- /dev/null +++ b/TuneBossPC/Converters/ErrorStatusConverters.cs @@ -0,0 +1,70 @@ +using System.Globalization; +using System.Windows; +using System.Windows.Data; +using System.Windows.Media; +using TuneBoss.Core.Models; + +namespace TuneBossPC.Converters; + +/// +/// Converts ErrorStatus to a background brush: +/// Active → Red +/// Persistent → Yellow +/// Clear → Green +/// +public class ErrorStatusToBrushConverter : IValueConverter +{ + public object Convert(object value, Type t, object p, CultureInfo c) + { + if (value is not ErrorStatus status) return Brushes.Transparent; + return status switch + { + ErrorStatus.Active => new SolidColorBrush(Color.FromRgb(0xFF, 0x44, 0x44)), + ErrorStatus.Persistent => new SolidColorBrush(Color.FromRgb(0xFF, 0xCC, 0x00)), + _ => new SolidColorBrush(Color.FromRgb(0x3D, 0xDC, 0x84)), + }; + } + + public object ConvertBack(object value, Type t, object p, CultureInfo c) + => throw new NotImplementedException(); +} + +/// +/// Converts ErrorStatus to foreground text colour — +/// dark text on yellow, white on red/green. +/// +public class ErrorStatusToForegroundConverter : IValueConverter +{ + public object Convert(object value, Type t, object p, CultureInfo c) + { + if (value is ErrorStatus.Persistent) + return new SolidColorBrush(Color.FromRgb(0x22, 0x22, 0x22)); + return Brushes.White; + } + + public object ConvertBack(object value, Type t, object p, CultureInfo c) + => throw new NotImplementedException(); +} + +/// +/// Converts CrankState int to background brush: +/// 6 → Green (running) +/// 5 → Yellow (near sync) +/// * → Red +/// +public class CrankStateToBrushConverter : IValueConverter +{ + public object Convert(object value, Type t, object p, CultureInfo c) + { + if (value is not int state) return Brushes.Transparent; + return state switch + { + 6 => new SolidColorBrush(Color.FromRgb(0x3D, 0xDC, 0x84)), + 5 => new SolidColorBrush(Color.FromRgb(0xFF, 0xCC, 0x00)), + _ => new SolidColorBrush(Color.FromRgb(0xFF, 0x44, 0x44)), + }; + } + + public object ConvertBack(object value, Type t, object p, CultureInfo c) + => throw new NotImplementedException(); +} diff --git a/TuneBossPC/Properties/launchSettings.json b/TuneBossPC/Properties/launchSettings.json new file mode 100644 index 0000000..a9fd492 --- /dev/null +++ b/TuneBossPC/Properties/launchSettings.json @@ -0,0 +1,11 @@ +{ + "profiles": { + "TuneBossPC": { + "commandName": "Project" + }, + "TuneBossPC Sim": { + "commandName": "Project", + "commandLineArgs": "--sim" + } + } +} \ No newline at end of file diff --git a/TuneBossPC/Services/AuthService.cs b/TuneBossPC/Services/AuthService.cs new file mode 100644 index 0000000..ffe9660 --- /dev/null +++ b/TuneBossPC/Services/AuthService.cs @@ -0,0 +1,137 @@ +using System.Windows; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Protocol; +using TuneBossPC.Views.Dialogs; +using TuneBossPC.ViewModels.Dialogs; + +namespace TuneBossPC.Services; + +/// +/// Implements the ECU password/unlock flow. +/// Mirrors CheckForDeviceLocked() from the WinForms app: +/// 1. Send a table read — if response is APP_LOCKED (0xFF) → show dialog +/// 2. Get password from user → send APP_UNLOCK (or APP_UNLOCK2 for GEN3) +/// 3. Retry up to 3 times +/// 4. On success → caller proceeds to populateInitTables equivalent +/// +public sealed class AuthService : IAuthService +{ + private readonly IBleService _ble; + private readonly ISettingsService _settings; + + public string? SavedPassword { get; private set; } + public string? SavedTunerPassword { get; private set; } + + private const int MaxAttempts = 3; + + public AuthService(IBleService ble, ISettingsService settings) + { + _ble = ble; + _settings = settings; + } + + // ── Basic ECU unlock ────────────────────────────────────────────────── + + public async Task EnsureUnlockedAsync( + string username, + CancellationToken ct = default) + { + // If we have a saved password, try it silently first + if (!string.IsNullOrEmpty(SavedPassword)) + { + var silentResult = await _ble.UnlockAsync(SavedPassword, ct); + if (silentResult.Success) + return UnlockResult.Ok(); + } + + return await RunUnlockLoopAsync( + username, + attempt => _ble.UnlockAsync(attempt.Password, ct), + isTuner: false, + ct); + } + + // ── Tuner unlock ────────────────────────────────────────────────────── + + public async Task EnsureTunerUnlockedAsync( + string username, + CancellationToken ct = default) + { + if (!string.IsNullOrEmpty(SavedTunerPassword)) + { + var silentResult = await _ble.UnlockTunerAsync(SavedTunerPassword, ct); + if (silentResult.Success) + return UnlockResult.Ok(); + } + + return await RunUnlockLoopAsync( + username, + attempt => _ble.UnlockTunerAsync(attempt.Password, ct), + isTuner: true, + ct); + } + + // ── Core loop — mirrors CheckForDeviceLocked ────────────────────────── + + private async Task RunUnlockLoopAsync( + string username, + Func> sendUnlock, + bool isTuner, + CancellationToken ct) + { + string? lastError = null; + + for (int attempt = 1; attempt <= MaxAttempts; attempt++) + { + // Show password dialog on UI thread + PasswordDialogViewModel? vm = null; + PasswordDialogResult dialogResult = PasswordDialogResult.Cancelled; + + await Application.Current.Dispatcher.InvokeAsync(() => + { + vm = new PasswordDialogViewModel + { + Username = username, + LastPassword = _settings.Settings.LastPassword ?? string.Empty, + }; + vm.SetAttempt(attempt, lastError); + + var dialog = new PasswordDialog(vm) + { + Owner = Application.Current.MainWindow + }; + dialog.ShowDialog(); + dialogResult = vm.Result; + }); + + if (dialogResult == PasswordDialogResult.Cancelled) + return UnlockResult.Cancelled(); + + if (vm == null) continue; + + // Send unlock command + var result = await sendUnlock(vm); + + if (result.Success) + { + // Save for auto-reconnect + if (isTuner) + SavedTunerPassword = vm.FinalPassword; + else + SavedPassword = vm.FinalPassword; + + // Persist as the "last used" password for next connection. + _settings.Settings.LastPassword = vm.FinalPassword; + + return UnlockResult.Ok(); + } + + // Wrong password — set error for next attempt + lastError = result.ResponseCode == Commands.APP_LOCKED + ? "Incorrect password. Please try again." + : $"Unlock failed (0x{result.ResponseCode:X2}). Please try again."; + } + + return UnlockResult.TooManyAttempts(); + } +} diff --git a/TuneBossPC/Services/IAuthService.cs b/TuneBossPC/Services/IAuthService.cs new file mode 100644 index 0000000..fdcd032 --- /dev/null +++ b/TuneBossPC/Services/IAuthService.cs @@ -0,0 +1,45 @@ +namespace TuneBossPC.Services; + +/// +/// Result of an unlock attempt. +/// +public sealed record UnlockResult( + bool Success, + string? ErrorMessage = null) +{ + public static UnlockResult Ok() => new(true); + public static UnlockResult Fail(string message) => new(false, message); + public static UnlockResult Cancelled() => new(false, "Cancelled by user"); + public static UnlockResult TooManyAttempts() => new(false, "Too many failed attempts"); +} + +/// +/// Manages the ECU unlock/password flow. +/// Called after connect, before table population. +/// Two unlock domains: basic ECU and tuner tables. +/// +public interface IAuthService +{ + /// + /// Checks if the ECU is locked and runs the unlock flow if needed. + /// Shows password dialog up to 3 times before giving up. + /// Returns Success=true when the device is unlocked and ready. + /// + Task EnsureUnlockedAsync( + string username, + CancellationToken ct = default); + + /// + /// Runs the tuner unlock flow (APP_UNLOCK_TUNER). + /// Only needed for tuner-mode table access. + /// + Task EnsureTunerUnlockedAsync( + string username, + CancellationToken ct = default); + + /// Last password successfully used — stored for auto-reconnect. + string? SavedPassword { get; } + + /// Last tuner password successfully used. + string? SavedTunerPassword { get; } +} diff --git a/TuneBossPC/Services/ISessionService.cs b/TuneBossPC/Services/ISessionService.cs new file mode 100644 index 0000000..7687b0a --- /dev/null +++ b/TuneBossPC/Services/ISessionService.cs @@ -0,0 +1,123 @@ +using TuneBoss.Core.Models; + +namespace TuneBossPC.Services; + +/// +/// Holds the current connected device's session state — +/// EcuInfo, MemoryLayout, and variant. Populated on connect, +/// cleared on disconnect. Shared across all ViewModels. +/// +public interface ISessionService +{ + EcuInfo? Info { get; } + MemoryLayout? Layout { get; } + EcuVariant Variant { get; } + + /// True only when a real device is connected — gates all hardware comms. + bool IsActive { get; } + + /// True when a layout is available to render tables — connected OR offline file view. + bool HasLayout { get; } + + /// Raised whenever the session is established or cleared (connect / disconnect / offline load). + event Action? SessionChanged; + + /// Builds and stores the session after a successful connect. + void Establish(EcuInfo info, EcuVariant variant); + + /// + /// Establishes an OFFLINE, view-only session from a loaded map file's tag so the + /// editor pages can populate without hardware. Assumes the current-generation (Gen3) + /// layout that all shipping units use. IsActive stays FALSE (comms disabled); + /// HasLayout becomes true. + /// + void EstablishOffline(byte make, byte model, byte fw, int cylinderCount); + + /// Clears the session on disconnect / closing an offline file. + void Clear(); +} + +public sealed class SessionService : ISessionService +{ + public EcuInfo? Info { get; private set; } + public MemoryLayout? Layout { get; private set; } + public EcuVariant Variant { get; private set; } + + private bool _offline; + + // Connected = has info+layout AND not an offline file view. + public bool IsActive => Info != null && Layout != null && !_offline; + public bool HasLayout => Layout != null; + + public event Action? SessionChanged; + + public void Establish(EcuInfo info, EcuVariant variant) + { + Info = info; + Variant = variant; + Layout = MemoryLayout.For(info, variant); + _offline = false; + SessionChanged?.Invoke(); + } + + public void EstablishOffline(byte make, byte model, byte fw, int cylinderCount) + { + // Synthesize a minimal EcuInfo from the file tag. AppInfoVersion = 2 (Gen3), + // which every current TuneBoss unit uses; FW drives the extended-layout split. + var info = new EcuInfo + { + BikeManufacturer = make, + BikeModel = model, + FwVersion = fw, + AppInfoVersion = 2, // Gen3 + }; + var variant = cylinderCount >= 2 + ? EcuVariantResolver.Resolve(info) is var v && v != EcuVariant.SingleCylinder + ? v : EcuVariant.TwoCylinderR15 + : EcuVariant.SingleCylinder; + + Info = info; + Variant = variant; + Layout = MemoryLayout.For(info, variant); + _offline = true; + SessionChanged?.Invoke(); + } + + public void Clear() + { + Info = null; + Layout = null; + Variant = default; + _offline = false; + SessionChanged?.Invoke(); + } +} + +/// +/// Resolves the EcuVariant from bike manufacturer + model. +/// For now uses a simple lookup; extend with the two-cylinder registry as needed. +/// +public static class EcuVariantResolver +{ + // Yamaha two-cylinder R-series models (R25/R3) use the R15 variant layout + private static readonly HashSet<(byte mfr, byte model)> TwoCylinderR15 = new() + { + (1, 10), // R25 2018 + (1, 25), // R25 2019 + (1, 26), // R3 2019 + (1, 11), // R3 2015 + }; + + private static readonly HashSet<(byte mfr, byte model)> TwoCylinder = new() + { + // Add genuinely two-cylinder (non-R15-layout) models here as discovered + }; + + public static EcuVariant Resolve(EcuInfo info) + { + var key = (info.BikeManufacturer, info.BikeModel); + if (TwoCylinderR15.Contains(key)) return EcuVariant.TwoCylinderR15; + if (TwoCylinder.Contains(key)) return EcuVariant.TwoCylinder; + return EcuVariant.SingleCylinder; + } +} diff --git a/TuneBossPC/Services/MapTableCodec.cs b/TuneBossPC/Services/MapTableCodec.cs new file mode 100644 index 0000000..e91b888 --- /dev/null +++ b/TuneBossPC/Services/MapTableCodec.cs @@ -0,0 +1,589 @@ +using System.Collections.Generic; +using System.Text; +using System.Windows; +using TuneBoss.Core.BLE; +using TuneBoss.Core.IO; +using TuneBoss.Core.Models; +using TuneBossPC.ViewModels.Tables; + +namespace TuneBossPC.Services; + +/// +/// Real — maps the legacy .tst sections to the WPF +/// view-models. +/// +/// User saves the adjust tables + their subtables (legacy-exact order). +/// Full Config saves every editable in the app: all base/user 2D + AFR +/// tables and their subtables (legacy-exact order), all 37 1D tables (slot order = legacy +/// order), and the misc values. The table/1D sections are legacy-compatible; the misc block +/// is written as named WPF regions (Core / LaunchFuel / LaunchFuel2 / AuxOut / Extended) +/// rather than the legacy 324-byte textbox array — clean and complete for in-app round-trip. +/// +/// Full Config deserialize is label-keyed (each section carries its name), so it is robust to +/// tables a given device/firmware doesn't expose (those are simply skipped). +/// +public sealed class MapTableCodec : IMapTableCodec +{ + private readonly TuningTablesViewModel _tables; + private readonly OneDimTablesViewModel _oneDim; + private readonly MiscValuesViewModel _misc; + private readonly IBleService _ble; + + public MapTableCodec(TuningTablesViewModel tables, OneDimTablesViewModel oneDim, + MiscValuesViewModel misc, IBleService ble) + { + _tables = tables; + _oneDim = oneDim; + _misc = misc; + _ble = ble; + } + + private const string NotWired = + "Full Tables isn't wired — use User or Full Config."; + + // ── User layout (legacy key -> WPF label) ──────────────────────────────────── + private static readonly (string Key, string Label)[] UserCyl1 = + { + ("Fuel_PulseWidth_Adjust1", "User Fuel Pulse Width 1"), + ("Spark_Angle_Adjust1", "User Spark Angle 1"), + }; + private static readonly (string Key, string Label)[] UserCyl2 = + { + ("Fuel_PulseWidth_Adjust1", "User Fuel Pulse Width 1"), + ("Spark_Angle_Adjust1", "User Spark Angle 1"), + ("Fuel_PulseWidth_Adjust2", "User Fuel Pulse Width 2"), + ("Spark_Angle_Adjust2", "User Spark Angle 2"), + }; + + // ── Full Config layout ─────────────────────────────────────────────────────── + private enum K { TwoD, Afr, Sub } + private readonly record struct Spec(string Key, string Label, K Kind); + + // 2D/AFR first (base then user, cyl1 then cyl2), then subtables — legacy Full Config order. + private static IEnumerable ConfigTables(int cyl) + { + yield return new("Fuel_PulseWidth1", "Base Fuel Pulse Width 1", K.TwoD); + yield return new("Spark_Angle1", "Base Spark Angle 1", K.TwoD); + yield return new("AFR_Target1", "Base AFR Target 1", K.Afr); + yield return new("Fuel_Angle2D", "Base Fuel Injection Angle 1", K.TwoD); + yield return new("Secondary_Load_Conversion", "Base MAP Compensation", K.TwoD); + yield return new("Fuel_PulseWidth_Adjust1", "User Fuel Pulse Width 1", K.TwoD); + yield return new("Spark_Angle_Adjust1", "User Spark Angle 1", K.TwoD); + if (cyl >= 2) + { + yield return new("Fuel_PulseWidth2", "Base Fuel Pulse Width 2", K.TwoD); + yield return new("AFR_Target2", "Base AFR Target 2", K.Afr); + yield return new("Fuel_Angle2D_2", "Base Fuel Injection Angle 2", K.TwoD); + yield return new("Spark_Angle2", "Base Spark Angle 2", K.TwoD); + yield return new("Fuel_PulseWidth_Adjust2", "User Fuel Pulse Width 2", K.TwoD); + yield return new("Spark_Angle_Adjust2", "User Spark Angle 2", K.TwoD); + } + + yield return new("Fuel_PulseWidth_Adjust1_SubTable", "User Fuel Pulse Width 1", K.Sub); + yield return new("Spark_Angle_Adjust1_SubTable", "User Spark Angle 1", K.Sub); + if (cyl >= 2) + { + yield return new("Fuel_PulseWidth_Adjust2_SubTable", "User Fuel Pulse Width 2", K.Sub); + yield return new("Spark_Angle_Adjust2_SubTable", "User Spark Angle 2", K.Sub); + } + } + + // Slot 1..37 -> legacy 1D section name (matches OneDimTableRegistry slot order). + private static readonly string[] OneDimNames = + { + "Spark_DwellTime_Table", "O2_Conversion_Table", "IAT_Conversion_Table", "ETEMP_Conversion_Table", + "MAP_Conversion_Table", "TPS_Conversion_Table", "ETEMP_Fuel_Comp_Table", "ETEMP_Spark_Comp_Table", + "BARO_Fuel_Comp_Table", "AUX_Conversion_Table", "IAT_Fuel_Comp_Table", "IAT_Spark_Comp_Table", + "TPS_Accel_Fuel_Comp_Table_100us", "TPS_Accel_Spark_Comp_Table", "VBAT_IOT_Comp_Table_10us", + "LOAD_Primary_Pct_Table", "Idle_Solenoid_Ctrl_Pct", "Startup_Fuel_Comp", "Injector2_Pct_Table", + "RadFan_PWM_Settings_ms", "NOS_Fuel_Comp_Table", "NOS_Spark_Comp_Table", "Idle_Fuel_PulseWidth", + "OffThrottle_Isol_Control", "Speed_Fuel_Comp_Table", "Speed_Spark_Comp_Table", + "ShiftBoss_Fuel_Cut_ms_Table", "ShiftBoss_Spark_Cut_ms_Table", "ShiftBoss_Spark_Retard_ms_Table", + "TC_Sensitivity_Table_1D", "TC_Spark_Retard_Degrees_1D", "TC_Spark_Retard_Duration_1D", + "Gear_Ratio_Detection_Table", "Aux_PWM_Table_1D", "Idle_Solenoid_Ctrl_Steps", + "BARO_Spark_Comp_Table", "Idle_Spark_Compensation", + }; + + // ── Prepare (re-read uncached editables before serializing) ─────────────────── + public async Task PrepareAsync(MapSaveType saveType, int cylinderCount) + { + switch (saveType) + { + case MapSaveType.User: + var um = cylinderCount >= 2 ? UserCyl2 : UserCyl1; + await _tables.EnsureLoadedAsync( + um.Select(x => x.Label) + .Concat(um.Select(x => StandaloneSubLabel(x.Key + "_SubTable")))); + break; + + case MapSaveType.FullConfig: + await _tables.EnsureLoadedAsync( + ConfigTables(cylinderCount).Where(t => t.Kind != K.Sub).Select(s => s.Label) + .Concat(ConfigTables(cylinderCount).Where(t => t.Kind == K.Sub) + .Select(t => StandaloneSubLabel(t.Key))) + .Distinct()); + await _oneDim.EnsureLoadedAsync(); + await _misc.EnsureLoadedAsync(); + break; + } + } + + public Task DiagnoseAsync() => _tables.DiagnoseUserReadAsync(); + + // ── Serialize ───────────────────────────────────────────────────────────────── + public string Serialize(MapSaveType saveType, int cylinderCount) => saveType switch + { + MapSaveType.User => SerializeUser(cylinderCount), + MapSaveType.FullConfig => SerializeFullConfig(cylinderCount), + _ => throw new NotImplementedException(NotWired), + }; + + private string SerializeUser(int cyl) + { + var map = cyl >= 2 ? UserCyl2 : UserCyl1; + var sb = new StringBuilder(); + foreach (var (key, label) in map) + sb.Append(MapTableFormat.Section2D(key, Entry(label).TuningTable ?? throw NotLoaded(label))); + foreach (var (key, label) in map) + sb.Append(MapTableFormat.SectionSub(key + "_SubTable", + FindEntry(StandaloneSubLabel(key + "_SubTable"))?.SubTable + ?? Entry(label).SubTableEntry?.SubTable + ?? throw NotLoaded(label + " subtable"))); + return sb.ToString(); + } + + private string SerializeFullConfig(int cyl) + { + var sb = new StringBuilder(); + + foreach (var s in ConfigTables(cyl)) + { + var e = FindEntry(s.Label); + if (e == null) continue; // device doesn't expose this table + switch (s.Kind) + { + case K.TwoD: + sb.Append(MapTableFormat.Section2D(s.Key, e.TuningTable ?? throw NotLoaded(s.Label))); + break; + case K.Afr: + sb.Append(MapTableFormat.SectionAfr(s.Key, e.AfrTable ?? throw NotLoaded(s.Label))); + break; + case K.Sub: + // Sub lives on the standalone Stage-1 entry now (fallback to nested). + var subModel = FindEntry(StandaloneSubLabel(s.Key))?.SubTable + ?? e.SubTableEntry?.SubTable + ?? throw NotLoaded(s.Label + " subtable"); + sb.Append(MapTableFormat.SectionSub(s.Key, subModel)); + break; + } + } + + for (int slot = 1; slot <= OneDimNames.Length; slot++) + { + var e = OneDimEntry(slot); + if (e?.Table == null) continue; // gated out for this device/firmware + sb.Append(MapTableFormat.Section1D(OneDimNames[slot - 1], e.Table)); + } + + var misc = _misc.CurrentMisc ?? throw new InvalidOperationException("Misc values are not loaded."); + sb.Append(MapTableFormat.SectionBytes("MiscCore", misc.Core)); + sb.Append(MapTableFormat.SectionBytes("MiscLaunchFuel", misc.LaunchFuel)); + sb.Append(MapTableFormat.SectionBytes("MiscLaunchFuel2", misc.LaunchFuel2)); + sb.Append(MapTableFormat.SectionBytes("MiscAuxOut", misc.AuxOut)); + sb.Append(MapTableFormat.SectionBytes("MiscExtended", misc.Extended)); + return sb.ToString(); + } + + // ── Write applied content to the ECU (file-load "Apply + Write") ────────────── + public async Task WriteLoadedAsync(MapSaveType saveType, int cylinderCount, bool flash, + IProgress? progress = null) + { + int tables, oneD = 0; bool misc = false; + List lockedLabels; + switch (saveType) + { + case MapSaveType.User: + var um = cylinderCount >= 2 ? UserCyl2 : UserCyl1; + var userLabels = um.Select(x => x.Label) + .Concat(um.Select(x => StandaloneSubLabel(x.Key + "_SubTable"))); + (tables, lockedLabels) = await _tables.WriteEntriesFromModelsAsync(userLabels, progress); + break; + + case MapSaveType.FullConfig: + // Base/user 2D + AFR by label, plus the standalone Stage-1 subtable entries. + var cfgLabels = ConfigTables(cylinderCount).Where(t => t.Kind != K.Sub).Select(t => t.Label) + .Concat(ConfigTables(cylinderCount).Where(t => t.Kind == K.Sub) + .Select(t => StandaloneSubLabel(t.Key))) + .Distinct(); + (tables, lockedLabels) = await _tables.WriteEntriesFromModelsAsync(cfgLabels, progress); + oneD = await _oneDim.WriteAllLoadedAsync(progress); + progress?.Report("Writing misc values…"); + await _misc.WriteAsync(); + misc = true; + break; + + default: + throw new NotImplementedException(NotWired); + } + + var summary = misc + ? $"{tables} tables, {oneD} 1D tables, misc values" + : $"{tables} tables (+ subtables)"; + + if (lockedLabels.Count > 0) + summary += $". NOTE: this is a Stage 1 ECU — the user main tables were NOT written ({string.Join(", ", lockedLabels.Distinct())})"; + + if (flash) + { + progress?.Report("Flashing — do not power off…"); + var fr = await _ble.FlashWriteAsync(); + if (!fr.Success) throw new InvalidOperationException($"Flash failed: {fr.ErrorMessage}"); + summary += ", flashed"; + } + + await _tables.ResumeStreamIfLiveAsync(); + return summary; + } + + // ── Deserialize ─────────────────────────────────────────────────────────────── + + /// Rebuilds the tuning + 1D nav trees from the current layout so entries + /// exist to populate (needed after an offline file establishes a layout). + public void RebuildNavTrees() + { + _tables.RebuildNavTree(); + _oneDim.RebuildNavTree(); + } + + public void Deserialize(string data, MapSaveType saveType, int cylinderCount) + { + switch (saveType) + { + case MapSaveType.User: DeserializeUser(data, cylinderCount); break; + case MapSaveType.FullConfig: DeserializeFullConfig(data, cylinderCount); break; + default: throw new NotImplementedException(NotWired); + } + } + + private void DeserializeUser(string data, int cyl) + { + var map = cyl >= 2 ? UserCyl2 : UserCyl1; + var sections = MapTableFormat.SplitSections(data); + int n = map.Length; + if (sections.Length < n * 2) + throw new InvalidOperationException("Map file is missing table sections for this layout."); + + var entries = new TableEntryViewModel[n]; + var tts = new TuningTable[n]; + for (int i = 0; i < n; i++) + { + entries[i] = Entry(map[i].Label); + tts[i] = MapTableFormat.Parse2D(sections[i]); + } + var subs = new SubTable[n]; + for (int i = 0; i < n; i++) + subs[i] = MapTableFormat.ParseSub(sections[n + i], tts[i].RpmAxis); + + Application.Current.Dispatcher.Invoke(() => + { + for (int i = 0; i < n; i++) + { + entries[i].TuningTable = tts[i]; + entries[i].IsLocked = false; + entries[i].IsLoaded = true; + + // Stage-1 subtables are standalone entries now; route by label + // (fall back to the legacy nested slot if present). + var stand = FindEntry(StandaloneSubLabel(map[i].Key + "_SubTable")); + if (stand != null) { stand.SubTable = subs[i]; stand.IsLoaded = true; } + else if (entries[i].SubTableEntry is { } se) { se.SubTable = subs[i]; se.IsLoaded = true; } + } + var sel = _tables.SelectedEntry; + if (sel != null && Array.IndexOf(entries, sel) >= 0) _tables.SelectEntry(sel); + }); + } + + private void DeserializeFullConfig(string data, int cyl) + { + var map = new Dictionary(); + foreach (var sec in MapTableFormat.SplitSections(data)) + { + if (string.IsNullOrWhiteSpace(sec)) continue; + map[MapTableFormat.LabelOf(sec)] = sec; // label-keyed; last wins + } + + Application.Current.Dispatcher.Invoke(() => + { + // 2D/AFR/sub — parents precede subs in ConfigTables, so parent RPM is set first. + foreach (var s in ConfigTables(cyl)) + { + var e = FindEntry(s.Label); + if (e == null || !map.TryGetValue(s.Key, out var sec)) continue; + switch (s.Kind) + { + case K.TwoD: + e.TuningTable = MapTableFormat.Parse2D(sec); + e.IsLocked = false; e.IsLoaded = true; + break; + case K.Afr: + e.AfrTable = MapTableFormat.ParseAfr(sec); + e.IsLoaded = true; + break; + case K.Sub: + // Stage-1 subtables are now STANDALONE entries (own .SubTable), not + // nested under the user table. Route the parsed sub to that entry by + // its own label. Parent RPM axis (if the parent 2D loaded) seeds the + // sub's display axis. Fall back to the legacy nested slot if present. + var parentRpm = e.TuningTable?.RpmAxis ?? Array.Empty(); + var standalone = FindEntry(StandaloneSubLabel(s.Key)); + if (standalone != null) + { + standalone.SubTable = MapTableFormat.ParseSub(sec, parentRpm); + standalone.IsLoaded = true; + } + else if (e.SubTableEntry is { } se) + { + se.SubTable = MapTableFormat.ParseSub(sec, parentRpm); + se.IsLoaded = true; + } + break; + } + } + + // 1D + for (int slot = 1; slot <= OneDimNames.Length; slot++) + { + var e = OneDimEntry(slot); + if (e == null || !map.TryGetValue(OneDimNames[slot - 1], out var sec)) continue; + e.Table = MapTableFormat.Parse1D(sec); + e.IsLoaded = true; + } + + // Misc (applied as a set; missing regions become empty) + if (map.ContainsKey("MiscCore")) + { + _misc.ApplyRegions( + Region(map, "MiscCore"), + Region(map, "MiscLaunchFuel"), + Region(map, "MiscLaunchFuel2"), + Region(map, "MiscAuxOut"), + Region(map, "MiscExtended")); + } + + // Repaint whatever is on screen. + var selT = _tables.SelectedEntry; if (selT != null) _tables.SelectEntry(selT); + var selO = _oneDim.SelectedEntry; if (selO != null) _oneDim.SelectEntry(selO); + }); + } + + private static byte[] Region(Dictionary map, string label) => + map.TryGetValue(label, out var sec) ? MapTableFormat.ParseBytesSection(sec) : Array.Empty(); + + // ── Helpers ─────────────────────────────────────────────────────────────────── + /// Maps a subtable section key to the standalone Stage-1 nav entry's label, + /// so offline-deserialized sub data lands on the entry that actually renders it. + private static string StandaloneSubLabel(string subKey) => subKey switch + { + "Fuel_PulseWidth_Adjust1_SubTable" => "Fuel PW Subtable 1", + "Spark_Angle_Adjust1_SubTable" => "Spark Angle Subtable 1", + "Fuel_PulseWidth_Adjust2_SubTable" => "Fuel PW Subtable 2", + "Spark_Angle_Adjust2_SubTable" => "Spark Angle Subtable 2", + _ => subKey, + }; + + private TableEntryViewModel? FindEntry(string label) => + _tables.Groups.SelectMany(g => g.Entries).FirstOrDefault(e => e.Label == label); + + private TableEntryViewModel Entry(string label) => + FindEntry(label) ?? throw new InvalidOperationException($"Table '{label}' is not present for this device."); + + private OneDimEntryViewModel? OneDimEntry(int slot) => + _oneDim.Groups.SelectMany(g => g.Entries).FirstOrDefault(e => e.Slot == slot); + + // ════════════════════════════════════════════════════════════════════════ + // FSR format — build from loaded editors / apply to editors + // ════════════════════════════════════════════════════════════════════════ + + /// + /// Builds an from whatever is currently loaded in + /// the editors. Unlike the .tst serializer, this walks the loaded entries directly + /// and simply SKIPS anything not loaded — it never throws "not loaded", so a partial + /// configuration still saves what it has. + /// + public FsrFile.FsrDocument BuildFsrFromEditors(EcuInfo? info, MapTag? tag, int cyl) + { + var doc = new FsrFile.FsrDocument(); + var h = doc.Header; + h.FsrVersion = FsrFile.FormatVersion; + h.Generator = "TuneBossPC"; + h.CreatedUtc = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ"); + h.CreatorId = tag?.CreatorId ?? (info?.Username ?? "TUNER"); + h.FwVersion = tag?.FwVersion ?? info?.FwVersion ?? 0; + h.HwVersion = tag?.HwVersion ?? info?.HwVersion ?? 0; + h.Make = tag?.Make ?? info?.BikeManufacturer ?? 0; + h.Model = tag?.Model ?? info?.BikeModel ?? 0; + h.Cylinders = cyl; + h.Generation = info != null ? GenInt(info.AppInfoVersion) : 3; + h.SaveType = "full_config"; + if (tag != null) + { + h.Note = tag.MiscNote; + h.ModEngineBlock = tag.EngineBlock; h.ModCamshaft = tag.Camshaft; + h.ModExhaust = tag.Exhaust; h.ModAirFilter = tag.AirFilter; + h.ModCylinderHead = tag.CylinderHead; h.ModInjector = tag.Injector; + h.ModThrottleBody = tag.ThrottleBody; h.ModJackRod = tag.JackRod; + } + + // 2D / AFR / subtable / user tables — walk the tuning nav, emit what's loaded. + foreach (var e in _tables.Groups.SelectMany(g => g.Entries)) + { + if (e.IsPlaceholder) continue; + var key = TuningKey(e.Label); + if (key == null) continue; // not a persisted table (e.g. Dual Injector) + + if (e.IsStandaloneSub && e.SubTable != null) + doc.Sections.Add(new FsrFile.FsrSection + { + Type = FsrFile.SectionType.SubTable, Name = key, Label = e.Label, + Addr = e.Address, Length = e.ReadLength, Sub = e.SubTable, + }); + else if (e.EntryType == TableEntryType.TuningTable && e.TuningTable != null) + doc.Sections.Add(new FsrFile.FsrSection + { + Type = FsrFile.SectionType.Table2D, Name = key, Label = e.Label, + Addr = e.Address, Length = e.ReadLength, Table2D = e.TuningTable, + }); + else if (e.EntryType == TableEntryType.AfrTable && e.AfrTable != null) + doc.Sections.Add(new FsrFile.FsrSection + { + Type = FsrFile.SectionType.Afr, Name = key, Label = e.Label, + Addr = e.Address, Length = e.ReadLength, Afr = e.AfrTable, + }); + } + + // 1D tables + for (int slot = 1; slot <= OneDimNames.Length; slot++) + { + var e = OneDimEntry(slot); + if (e?.Table == null) continue; + doc.Sections.Add(new FsrFile.FsrSection + { + Type = FsrFile.SectionType.Table1D, Name = OneDimNames[slot - 1], Label = e.Label, + Addr = e.Address, Length = e.ReadLength, Table1D = e.Table, + }); + } + + // Misc byte blocks + var misc = _misc.CurrentMisc; + if (misc != null) + { + AddMisc(doc, "MiscCore", misc.Core); + AddMisc(doc, "MiscLaunchFuel", misc.LaunchFuel); + AddMisc(doc, "MiscLaunchFuel2", misc.LaunchFuel2); + AddMisc(doc, "MiscAuxOut", misc.AuxOut); + AddMisc(doc, "MiscExtended", misc.Extended); + } + + return doc; + } + + private void AddMisc(FsrFile.FsrDocument doc, string name, byte[]? bytes) + { + if (bytes == null || bytes.Length == 0) return; + doc.Sections.Add(new FsrFile.FsrSection + { + Type = FsrFile.SectionType.Misc, Name = name, Label = name, + Addr = _misc.RegionAddress(name), + Length = (byte)Math.Max(0, bytes.Length - 1), MiscBytes = bytes, + }); + } + + private static int GenInt(byte appInfoVersion) => appInfoVersion switch + { + 245 => 1, 1 => 2, 2 => 3, _ => 3, + }; + + /// Maps a tuning entry's display label to its stable FSR feature key. + private static string? TuningKey(string label) => label switch + { + "Base Fuel Pulse Width 1" => "Fuel_PulseWidth1", + "Base Fuel Pulse Width 2" => "Fuel_PulseWidth2", + "Base Spark Angle 1" => "Spark_Angle1", + "Base Spark Angle 2" => "Spark_Angle2", + "Base AFR Target 1" => "AFR_Target1", + "Base AFR Target 2" => "AFR_Target2", + "Base Fuel Injection Angle 1" => "Fuel_Angle2D", + "Base Fuel Injection Angle 2" => "Fuel_Angle2D_2", + "Base MAP Compensation" => "Secondary_Load_Conversion", + "User Fuel Pulse Width 1" => "Fuel_PulseWidth_Adjust1", + "User Fuel Pulse Width 2" => "Fuel_PulseWidth_Adjust2", + "User Spark Angle 1" => "Spark_Angle_Adjust1", + "User Spark Angle 2" => "Spark_Angle_Adjust2", + "Fuel PW Subtable 1" => "Fuel_PulseWidth_Adjust1_SubTable", + "Fuel PW Subtable 2" => "Fuel_PulseWidth_Adjust2_SubTable", + "Spark Angle Subtable 1" => "Spark_Angle_Adjust1_SubTable", + "Spark Angle Subtable 2" => "Spark_Angle_Adjust2_SubTable", + _ => null, + }; + + /// Applies a parsed FSR document into the editors (offline or connected view). + public void ApplyFsr(FsrFile.FsrDocument doc) + { + // Reverse of TuningKey — feature key to the nav entry label. + TableEntryViewModel? FindByKey(string key) + { + foreach (var e in _tables.Groups.SelectMany(g => g.Entries)) + if (TuningKey(e.Label) == key) return e; + return null; + } + + foreach (var s in doc.Sections) + { + switch (s.Type) + { + case FsrFile.SectionType.Table2D when s.Table2D != null: + { + var e = FindByKey(s.Name); + if (e != null) { e.TuningTable = s.Table2D; e.IsLoaded = true; } + break; + } + case FsrFile.SectionType.Afr when s.Afr != null: + { + var e = FindByKey(s.Name); + if (e != null) { e.AfrTable = s.Afr; e.IsLoaded = true; } + break; + } + case FsrFile.SectionType.SubTable when s.Sub != null: + { + var e = FindByKey(s.Name); + if (e != null) { e.SubTable = s.Sub; e.IsLoaded = true; } + break; + } + case FsrFile.SectionType.Table1D when s.Table1D != null: + { + var e = _oneDim.Groups.SelectMany(g => g.Entries) + .FirstOrDefault(x => x.Slot >= 1 && x.Slot <= OneDimNames.Length + && OneDimNames[x.Slot - 1] == s.Name); + if (e != null) { e.Table = s.Table1D; e.IsLoaded = true; } + break; + } + case FsrFile.SectionType.Misc when s.MiscBytes != null: + // collected below and applied as a set + break; + } + } + + // Misc as a set (ApplyRegions rebuilds the config sections). + byte[] Region(string name) => + doc.Find(name)?.MiscBytes ?? Array.Empty(); + if (doc.Sections.Any(x => x.Type == FsrFile.SectionType.Misc)) + _misc.ApplyRegions(Region("MiscCore"), Region("MiscLaunchFuel"), + Region("MiscLaunchFuel2"), Region("MiscAuxOut"), Region("MiscExtended")); + + // Repaint whatever is on screen. + var selT = _tables.SelectedEntry; if (selT != null) _tables.SelectEntry(selT); + } + + private static InvalidOperationException NotLoaded(string what) => + new($"'{what}' is not loaded — read it first."); +} diff --git a/TuneBossPC/Services/SettingsService.cs b/TuneBossPC/Services/SettingsService.cs new file mode 100644 index 0000000..4c5b1b8 --- /dev/null +++ b/TuneBossPC/Services/SettingsService.cs @@ -0,0 +1,84 @@ +using System.IO; +using System.Text.Json; +using CommunityToolkit.Mvvm.ComponentModel; + +namespace TuneBossPC.Services; + +/// +/// App-level behaviour settings (not hardware state). Observable so pages bind +/// directly; persisted automatically on every change. +/// +public sealed partial class AppSettings : ObservableObject +{ + /// + /// When on, the live tracker's exact cell becomes the active selection as it + /// moves — SUB/ADD/SET act on it without the tuner clicking the grid. + /// + [ObservableProperty] private bool _trackerAutoSelect; + + /// + /// When on, any tuning-table cell change (typed, SET, SUB/ADD, paste) triggers + /// a debounced write to the ECU so a forgotten WRITE can't lose work. + /// Flash remains manual. + /// + [ObservableProperty] private bool _autoWriteOnChange; + + /// + /// When on, the 2D tuning table is drawn as a flat white grid with no contour + /// heatmap; the live tracker switches to orange (exact) + yellow (adjacent) so + /// it stays visible against the white. Off = the normal colour contour map. + /// + [ObservableProperty] private bool _flatMapNoContour; + + /// The most recently used device password (stored so the user can pick + /// "use last password" on the next connection). Empty when none stored yet. + [ObservableProperty] private string _lastPassword = string.Empty; +} + +public interface ISettingsService +{ + AppSettings Settings { get; } + void Save(); +} + +/// +/// Loads settings from %APPDATA%\TuneBoss\settings.json at startup and saves on +/// every property change. Failures are non-fatal — defaults apply. +/// +public sealed class SettingsService : ISettingsService +{ + private static readonly string Dir = + Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "TuneBoss"); + private static readonly string FilePath = Path.Combine(Dir, "settings.json"); + + private static readonly JsonSerializerOptions JsonOpts = new() { WriteIndented = true }; + + public AppSettings Settings { get; } + + public SettingsService() + { + Settings = Load(); + Settings.PropertyChanged += (_, _) => Save(); + } + + private static AppSettings Load() + { + try + { + if (File.Exists(FilePath)) + return JsonSerializer.Deserialize(File.ReadAllText(FilePath)) ?? new AppSettings(); + } + catch { /* corrupted file — fall back to defaults */ } + return new AppSettings(); + } + + public void Save() + { + try + { + Directory.CreateDirectory(Dir); + File.WriteAllText(FilePath, JsonSerializer.Serialize(Settings, JsonOpts)); + } + catch { /* non-fatal */ } + } +} diff --git a/TuneBossPC/TuneBossPC.csproj b/TuneBossPC/TuneBossPC.csproj new file mode 100644 index 0000000..8da9d4a --- /dev/null +++ b/TuneBossPC/TuneBossPC.csproj @@ -0,0 +1,44 @@ + + + WinExe + net9.0-windows10.0.19041.0 + enable + enable + true + TuneBossPC + + 2026.8.13 + + true + + + + + $(DefineConstants);DEALER + + TuneBossPC.Dealer + TuneBoss PC (Dealer) + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TuneBossPC/ViewModels/ConnectViewModel.cs b/TuneBossPC/ViewModels/ConnectViewModel.cs new file mode 100644 index 0000000..4454f68 --- /dev/null +++ b/TuneBossPC/ViewModels/ConnectViewModel.cs @@ -0,0 +1,263 @@ +using System.Collections.ObjectModel; +using System.Windows; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; +using TuneBossPC.Services; +using Wpf.Ui; + +namespace TuneBossPC.ViewModels; + +public partial class ConnectViewModel : ObservableObject, IDisposable +{ + private readonly IBleService _ble; + private readonly MainWindowViewModel _mainVm; + private readonly IAuthService _auth; + private readonly ISessionService _session; + private readonly TuneBossPC.ViewModels.Tables.TuningTablesViewModel _tablesVm; + private readonly TuneBossPC.ViewModels.Tables.OneDimTablesViewModel _oneDimVm; + private readonly TuneBossPC.ViewModels.Tables.MiscValuesViewModel _miscVm; + private readonly ISnackbarService _snackbar; + private IDisposable? _scanSub; + private IDisposable? _connSub; + private EcuInfo? _ecuInfo; + + [ObservableProperty] private bool _isScanning; + [ObservableProperty] private bool _isConnecting; + [ObservableProperty] private bool _isConnected; + [ObservableProperty] private string _scanButtonText = "Scan"; + [ObservableProperty] private string _statusMessage = string.Empty; + [ObservableProperty] private bool _hasStatusMessage; + + // ECU info fields + [ObservableProperty] private string _ecuUsername = string.Empty; + [ObservableProperty] private string _ecuFwVersion = string.Empty; + [ObservableProperty] private string _ecuHwVersion = string.Empty; + [ObservableProperty] private string _ecuRpmLimit = string.Empty; + [ObservableProperty] private string _ecuFlashWrites = string.Empty; + [ObservableProperty] private string _ecuUniqueId = string.Empty; + + public ObservableCollection Devices { get; } = new(); + + [ObservableProperty] + [NotifyCanExecuteChangedFor(nameof(ConnectCommand))] + private BleDeviceInfo? _selectedDevice; + + public bool CanConnect => SelectedDevice != null && !IsConnecting && !IsConnected; + + public ConnectViewModel( + IBleService ble, + MainWindowViewModel mainVm, + IAuthService auth, + ISessionService session, + TuneBossPC.ViewModels.Tables.TuningTablesViewModel tablesVm, + TuneBossPC.ViewModels.Tables.OneDimTablesViewModel oneDimVm, + TuneBossPC.ViewModels.Tables.MiscValuesViewModel miscVm, + ISnackbarService snackbar) + { + _ble = ble; + _mainVm = mainVm; + _auth = auth; + _session = session; + _tablesVm = tablesVm; + _oneDimVm = oneDimVm; + _miscVm = miscVm; + _snackbar = snackbar; + + _connSub = ble.ConnectionStateChanged.Subscribe(state => + { + Application.Current.Dispatcher.Invoke(() => + { + IsConnected = state == BleConnectionState.Connected; + if (state == BleConnectionState.Disconnected) + { + _mainVm.OnDeviceDisconnected(); + SetStatus("Disconnected"); + } + }); + }); + } + + [RelayCommand] + public void StartScan() + { + if (IsScanning) return; + Devices.Clear(); + IsScanning = true; + ScanButtonText = "Stop"; + + _scanSub = _ble.StartScan().Subscribe(device => + { + // Only surface TuneBoss ECUs — their advertised name starts with "B_T". + if (!device.Name.StartsWith("B_T", StringComparison.OrdinalIgnoreCase)) + return; + + Application.Current.Dispatcher.Invoke(() => + { + var existing = Devices.FirstOrDefault(d => d.Address == device.Address); + if (existing != null) + Devices[Devices.IndexOf(existing)] = device; + else + Devices.Add(device); + }); + }); + } + + [RelayCommand] + public void ToggleScan() + { + if (IsScanning) + { + _ble.StopScan(); + _scanSub?.Dispose(); + IsScanning = false; + ScanButtonText = "Scan"; + } + else + { + StartScan(); + } + } + + [RelayCommand(CanExecute = nameof(CanConnect))] + public async Task ConnectAsync() + { + if (SelectedDevice == null) return; + if (IsScanning) ToggleScan(); + + IsConnecting = true; + SetStatus($"Connecting to {SelectedDevice.Name}…"); + + try + { + // Step 1 — BLE connect + bool ok = await _ble.ConnectAsync(SelectedDevice); + if (!ok) { SetStatus("Connection failed."); return; } + + // Step 2 — Read ECU info (determines generation + unlock command) + SetStatus("Reading device info…"); + _ecuInfo = await _ble.ReadEcuInfoAsync(); + if (_ecuInfo == null) { SetStatus("Could not read device info."); return; } + + // Step 3 — Unlock if needed + SetStatus("Checking device lock status…"); + var unlockResult = await _auth.EnsureUnlockedAsync(_ecuInfo.Username); + + if (!unlockResult.Success) + { + SetStatus($"Unlock failed: {unlockResult.ErrorMessage}"); + await _ble.DisconnectAsync(); + return; + } + + // Step 4 — Populate UI + EcuUsername = _ecuInfo.Username; + EcuFwVersion = $"v{_ecuInfo.FwVersion} FW2: {_ecuInfo.FwVersion2}.{_ecuInfo.FwSubVersion2}"; + EcuHwVersion = $"HW {_ecuInfo.HwVersion} Comp {_ecuInfo.HwComponentVersion}"; + EcuRpmLimit = $"{_ecuInfo.RpmLimit:N0} RPM"; + EcuFlashWrites = _ecuInfo.FlashWriteCount.ToString("N0"); + EcuUniqueId = _ecuInfo.UniqueId; + + // Build the memory layout for this device + var variant = EcuVariantResolver.Resolve(_ecuInfo); + _session.Establish(_ecuInfo, variant); + + _mainVm.OnDeviceConnected(SelectedDevice, _ecuInfo); + + // Pre-load all tables (2D + 1D + misc) behind a modal progress dialog + await LoadAllTablesAsync(); + + SetStatus($"Connected · {_ecuInfo.Username}"); + + // Post-clearance gate: if this unit was never TPS-calibrated, warn the + // tuner and jump straight to the calibration page (legacy UIFirstUseInfo[0]). + if (!_ecuInfo.HasTpsCalibration) + { + MessageBox.Show( + "WARNING: TPS Calibration has not been done on this TuneBoss unit yet.", + "TPS Calibration Warning", + MessageBoxButton.OK, MessageBoxImage.Warning); + _mainVm.NavigateTo("TpsCal"); + } + } + catch (Exception ex) + { + SetStatus($"Error: {ex.Message}"); + } + finally + { + IsConnecting = false; + ConnectCommand.NotifyCanExecuteChanged(); + } + } + + /// + /// Reads every available 2D table, 1D table, and misc block while a + /// non-cancellable modal progress dialog blocks the UI. + /// + private async Task LoadAllTablesAsync() + { + _tablesVm.RebuildNavTree(); + _oneDimVm.RebuildNavTree(); + + var owner = Application.Current.MainWindow; + var dialog = new TuneBossPC.Views.ProgressDialog(); + if (owner != null) + { + dialog.Owner = owner; + owner.IsEnabled = false; + } + + var progress = new Progress(msg => + { + dialog.Report(msg); + SetStatus(msg); + }); + + dialog.Show(); + try + { + dialog.SetHeader("Loading tuning tables…"); + await _tablesVm.InitializeAllAsync(progress); + + dialog.SetHeader("Loading 1D tables…"); + await _oneDimVm.InitializeAllAsync(progress); + + dialog.SetHeader("Loading misc values…"); + await _miscVm.InitializeAllAsync(progress); + } + finally + { + dialog.Close(); + if (owner != null) owner.IsEnabled = true; + } + } + + [RelayCommand] + public async Task DisconnectAsync() + { + SetStatus("Disconnecting…"); + await _ble.DisconnectAsync(); + ClearEcuInfo(); + SetStatus("Disconnected"); + } + + private void SetStatus(string msg) + { + StatusMessage = msg; + HasStatusMessage = !string.IsNullOrEmpty(msg); + } + + private void ClearEcuInfo() + { + EcuUsername = EcuFwVersion = EcuHwVersion = + EcuRpmLimit = EcuFlashWrites = EcuUniqueId = string.Empty; + } + + public void Dispose() + { + _scanSub?.Dispose(); + _connSub?.Dispose(); + } +} diff --git a/TuneBossPC/ViewModels/DiagnosticsStripViewModel.cs b/TuneBossPC/ViewModels/DiagnosticsStripViewModel.cs new file mode 100644 index 0000000..f65a3bd --- /dev/null +++ b/TuneBossPC/ViewModels/DiagnosticsStripViewModel.cs @@ -0,0 +1,223 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using System.Collections.ObjectModel; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; + +namespace TuneBossPC.ViewModels; + +/// +/// Represents one slot in the 6-gauge persistent bottom strip. +/// +public partial class GaugeSlotViewModel : ObservableObject +{ + [ObservableProperty] private string _label = string.Empty; + [ObservableProperty] private string _value = "—"; + [ObservableProperty] private string _unit = string.Empty; + [ObservableProperty] private DiagChannel _channel; + + public GaugeSlotViewModel(DiagChannel channel) + { + AssignChannel(channel); + } + + public void AssignChannel(DiagChannel channel) + { + Channel = channel; + Label = channel.GetLabel(); + Unit = channel.GetUnit(); + Value = "—"; + } + + public void UpdateFromFrame(DiagnosticsFrame frame) + { + Value = Channel.GetValue(frame); + } +} + +/// +/// Available diagnostics channels that can be assigned to a gauge slot. +/// +public enum DiagChannel +{ + TPS, + RPM, + EngineTemp, + MAP, + SparkAngle1, + SparkAngle2, + Load, + IAT, + VBAT, + AFR, + FuelPulseWidth, + FuelStartAngle1, + FuelEndAngle, + CrankState, + ThrottleState, + RPMState, + UMState, + MeterSpeed, + MapLoAvg, + BaroDynamic, +} + +public static class DiagChannelExtensions +{ + public static string GetLabel(this DiagChannel c) => c switch + { + DiagChannel.TPS => "TPS", + DiagChannel.RPM => "RPM", + DiagChannel.EngineTemp => "Engine Temp", + DiagChannel.MAP => "MAP", + DiagChannel.SparkAngle1 => "Spark Angle 1", + DiagChannel.SparkAngle2 => "Spark Angle 2", + DiagChannel.Load => "Load", + DiagChannel.IAT => "IAT", + DiagChannel.VBAT => "Battery", + DiagChannel.AFR => "AFR", + DiagChannel.FuelPulseWidth => "Fuel PW", + DiagChannel.FuelStartAngle1=> "Fuel St. Angle", + DiagChannel.FuelEndAngle => "Fuel End Angle", + DiagChannel.CrankState => "Crank State", + DiagChannel.ThrottleState => "Throttle State", + DiagChannel.RPMState => "RPM State", + DiagChannel.UMState => "UM State", + DiagChannel.MeterSpeed => "Speed", + DiagChannel.MapLoAvg => "MAP Lo Avg", + DiagChannel.BaroDynamic => "Baro Dynamic", + _ => c.ToString() + }; + + public static string GetUnit(this DiagChannel c) => c switch + { + DiagChannel.RPM => "rpm", + DiagChannel.EngineTemp => "°C", + DiagChannel.MAP => "kPa", + DiagChannel.IAT => "°C", + DiagChannel.VBAT => "V", + DiagChannel.AFR => "λ", + DiagChannel.TPS => "%", + DiagChannel.MeterSpeed => "kph", + DiagChannel.MapLoAvg => "kPa", + DiagChannel.BaroDynamic => "kPa", + _ => string.Empty + }; + + public static string GetValue(this DiagChannel c, DiagnosticsFrame frame) => c switch + { + DiagChannel.TPS => frame.TPS_Percent.ToString(), + DiagChannel.RPM => frame.RPM.ToString("N0"), + DiagChannel.EngineTemp => frame.ETEMP_DegC.ToString(), + DiagChannel.MAP => frame.MAP_kPa.ToString(), + DiagChannel.SparkAngle1 => frame.SparkAngle1.ToString(), + DiagChannel.SparkAngle2 => frame.SparkAngle2.ToString(), + DiagChannel.Load => frame.Load.ToString(), + DiagChannel.IAT => frame.IAT_DegC.ToString(), + DiagChannel.VBAT => frame.VBAT_Volts.ToString("F1"), + DiagChannel.AFR => frame.O2_AFR.ToString("F1"), + DiagChannel.FuelPulseWidth => frame.FuelPulseWidth1.ToString(), + DiagChannel.FuelStartAngle1=> frame.FuelStartAngle1_Deg.ToString(), + DiagChannel.FuelEndAngle => frame.FuelEndAngle.ToString(), + DiagChannel.CrankState => frame.CrankState.ToString(), + DiagChannel.ThrottleState => frame.ThrottleState.ToString(), + DiagChannel.RPMState => frame.RPMState.ToString(), + DiagChannel.UMState => frame.UMState.ToString(), + DiagChannel.MeterSpeed => frame.MeterSpeed.ToString(), + DiagChannel.MapLoAvg => frame.MAP_Lo_Avg.ToString(), + DiagChannel.BaroDynamic => frame.Baro_Dynamic.ToString(), + _ => "—" + }; +} + +/// +/// ViewModel for the persistent 6-gauge bottom strip. +/// Lives in MainWindowViewModel — always active when diagnostics are running. +/// +public partial class DiagnosticsStripViewModel : ObservableObject, IDisposable +{ + private readonly IBleService _ble; + private IDisposable? _diagSub; + + [ObservableProperty] private bool _isRunning; + + // The 6 configurable gauge slots + public ObservableCollection Slots { get; } = new() + { + new GaugeSlotViewModel(DiagChannel.TPS), + new GaugeSlotViewModel(DiagChannel.RPM), + new GaugeSlotViewModel(DiagChannel.EngineTemp), + new GaugeSlotViewModel(DiagChannel.MAP), + new GaugeSlotViewModel(DiagChannel.SparkAngle1), + new GaugeSlotViewModel(DiagChannel.SparkAngle2), + }; + + // All available channels for the slot picker dialog + public static IEnumerable AllChannels + => Enum.GetValues(); + + public DiagnosticsStripViewModel(IBleService ble) + { + _ble = ble; + } + + // ── Start / Stop ────────────────────────────────────────────────────────── + + [RelayCommand] + public async Task StartAsync() + { + if (IsRunning) return; + await _ble.StartDiagnosticsAsync(); + IsRunning = true; + + _diagSub = _ble.DiagnosticsFrames.Subscribe(OnFrame); + } + + [RelayCommand] + public async Task StopAsync() + { + if (!IsRunning) return; + _diagSub?.Dispose(); + _diagSub = null; + await _ble.StopDiagnosticsAsync(); + IsRunning = false; + + foreach (var slot in Slots) + slot.Value = "—"; + } + + // ── Slot assignment ─────────────────────────────────────────────────────── + + /// Assigns a new channel to a slot by index (0–5). + public void AssignSlot(int slotIndex, DiagChannel channel) + { + if (slotIndex < 0 || slotIndex >= Slots.Count) return; + Slots[slotIndex].AssignChannel(channel); + } + + // ── Frame handling ──────────────────────────────────────────────────────── + + private void OnFrame(DiagnosticsFrame frame) + { + System.Diagnostics.Debug.WriteLine($"[STRIP] Frame received RPM={frame.RPM}"); + System.Windows.Application.Current.Dispatcher.Invoke(() => + { + foreach (var slot in Slots) + slot.UpdateFromFrame(frame); + }); + } + + public void Dispose() + { + _diagSub?.Dispose(); + } + + [RelayCommand] + public async Task ToggleAsync() + { + if (IsRunning) + await StopAsync(); + else + await StartAsync(); + } +} diff --git a/TuneBossPC/ViewModels/DiagnosticsViewModel.cs b/TuneBossPC/ViewModels/DiagnosticsViewModel.cs new file mode 100644 index 0000000..3e7b3b8 --- /dev/null +++ b/TuneBossPC/ViewModels/DiagnosticsViewModel.cs @@ -0,0 +1,133 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; +using static System.Windows.Forms.AxHost; + +namespace TuneBossPC.ViewModels; + +public partial class DiagnosticsViewModel : ObservableObject, IDisposable +{ + private readonly IBleService _ble; + private IDisposable? _diagSub; + + // ── Secondary channels ──────────────────────────────────────────────────── + [ObservableProperty] private string _load = "—"; + [ObservableProperty] private string _iatDisplay = "—"; + [ObservableProperty] private string _vbatDisplay = "—"; + [ObservableProperty] private string _afrDisplay = "—"; + [ObservableProperty] private string _fuelPW = "—"; + [ObservableProperty] private string _fuelStartAngle = "—"; + [ObservableProperty] private string _fuelEndAngle = "—"; + [ObservableProperty] private string _sparkAngle1 = "—"; + [ObservableProperty] private string _sparkAngle2 = "—"; + [ObservableProperty] private string _baro = "—"; + [ObservableProperty] private string _baroDynamic = "—"; + [ObservableProperty] private string _mapLoAvg = "—"; + [ObservableProperty] private string _meterSpeed = "—"; + [ObservableProperty] private string _crankSyncLost = "—"; + + // ── State indicators ────────────────────────────────────────────────────── + [ObservableProperty] private int _crankState = -1; // -1 = no data + [ObservableProperty] private string _crankStateText = "—"; + [ObservableProperty] private int _tcMode = 0; + [ObservableProperty] private string _umState = "—"; + [ObservableProperty] private int _gearRatio = 0; + [ObservableProperty] private string _throttleStateText = "—"; + [ObservableProperty] private string _rpmState = "—"; + [ObservableProperty] private bool _stayTuned; + [ObservableProperty] private bool _fuelPWLimit; + [ObservableProperty] private bool _modeSelected; + + // ── Error flags ─────────────────────────────────────────────────────────── + // Analog (8 channels) + [ObservableProperty] private ErrorStatus _errTPS = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errMAP = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errIAT = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errVehicleDown = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errETemp = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errO2 = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errVBAT = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errAux = ErrorStatus.Clear; + + // Output (8 channels) + [ObservableProperty] private ErrorStatus _errInjector1 = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errInjector2 = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errFuelPump = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errRadFan = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errSpark1 = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errSpark2 = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errPSU5V = ErrorStatus.Clear; + [ObservableProperty] private ErrorStatus _errO2Heater = ErrorStatus.Clear; + + [ObservableProperty] private bool _hasActiveError; + + public DiagnosticsViewModel(IBleService ble) + { + _ble = ble; + + // Subscribe to the shared strip stream + _diagSub = ble.DiagnosticsFrames.Subscribe(OnFrame); + } + + private void OnFrame(DiagnosticsFrame frame) + { + System.Windows.Application.Current.Dispatcher.Invoke(() => + { + // Secondary channels + Load = frame.Load.ToString(); + IatDisplay = $"{frame.IAT_DegC} °C"; + VbatDisplay = $"{frame.VBAT_Volts:F1} V"; + AfrDisplay = $"{frame.O2_AFR:F1}"; + FuelPW = frame.FuelPulseWidth1.ToString(); + FuelStartAngle = $"{frame.FuelStartAngle1_Deg}°"; + FuelEndAngle = frame.FuelEndAngle.ToString(); + SparkAngle1 = $"{frame.SparkAngle1}°"; + SparkAngle2 = $"{frame.SparkAngle2}°"; + Baro = $"{frame.Baro_kPa} kPa"; + BaroDynamic = $"{frame.Baro_Dynamic} kPa"; + MapLoAvg = $"{frame.MAP_Lo_Avg} kPa"; + MeterSpeed = $"{frame.MeterSpeed} kph"; + CrankSyncLost = frame.CrankSyncLostCounter.ToString(); + + // State indicators + CrankState = frame.CrankState; + CrankStateText = frame.CrankState switch + { + 5 => "NEAR SYNC", + 6 => "RUNNING", + _ => $"SEARCHING ({frame.CrankState})" + }; + TcMode = frame.TC_Mode; + UmState = frame.UMState.ToString().Replace("_", " "); + GearRatio = frame.GearRatio; + ThrottleStateText = frame.ThrottleState.ToString(); + RpmState = frame.RPMState.ToString(); + StayTuned = frame.StayTunedRunning; + FuelPWLimit = frame.FuelPW_LimitActive; + ModeSelected = frame.ModeSelected; + + // Error flags + var err = frame.Errors; + ErrTPS = err.TPS; + ErrMAP = err.MAP; + ErrIAT = err.IAT; + ErrVehicleDown = err.VehicleDown; + ErrETemp = err.ETemp; + ErrO2 = err.OxygenSensor; + ErrVBAT = err.BattVoltage; + ErrAux = err.Aux; + ErrInjector1 = err.Injector1; + ErrInjector2 = err.Injector2_IdleSol; + ErrFuelPump = err.FuelPump; + ErrRadFan = err.RadiatorFan; + ErrSpark1 = err.SparkIgnition1; + ErrSpark2 = err.SparkIgnition2; + ErrPSU5V = err.PSU_5V; + ErrO2Heater = err.O2Heater; + HasActiveError = err.HasActiveError; + }); + } + + public void Dispose() => _diagSub?.Dispose(); +} diff --git a/TuneBossPC/ViewModels/Dialogs/PasswordDialogViewModel.cs b/TuneBossPC/ViewModels/Dialogs/PasswordDialogViewModel.cs new file mode 100644 index 0000000..d87212b --- /dev/null +++ b/TuneBossPC/ViewModels/Dialogs/PasswordDialogViewModel.cs @@ -0,0 +1,100 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; + +namespace TuneBossPC.ViewModels.Dialogs; + +public enum PasswordDialogResult +{ + Confirmed, + Cancelled, +} + +/// How the user wants to supply the device password. +public enum PasswordChoice +{ + EnterNew, // type a password + UseDefault, // use the built-in default + UseLast, // reuse the last successfully used password +} + +public partial class PasswordDialogViewModel : ObservableObject +{ + private const string DefaultPassword = "PASSWORD"; + + [ObservableProperty] private string _username = string.Empty; + [ObservableProperty] private string _password = string.Empty; + [ObservableProperty] private bool _showPassword; + [ObservableProperty] private string _errorMessage = string.Empty; + [ObservableProperty] private bool _hasError; + [ObservableProperty] private int _attemptNumber = 1; + + /// The last successfully used password (from settings); empty if none. + [ObservableProperty] private string _lastPassword = string.Empty; + + [NotifyPropertyChangedFor(nameof(IsEnterNew))] + [ObservableProperty] private PasswordChoice _choice = PasswordChoice.EnterNew; + + /// True when a stored last password exists (enables that radio option). + public bool HasLastPassword => !string.IsNullOrEmpty(LastPassword); + + /// True when the "enter new" option is selected (shows the password box). + public bool IsEnterNew => Choice == PasswordChoice.EnterNew; + + public PasswordDialogResult Result { get; private set; } = PasswordDialogResult.Cancelled; + public string FinalPassword { get; private set; } = string.Empty; + public Action? CloseAction { get; set; } + + partial void OnLastPasswordChanged(string value) => OnPropertyChanged(nameof(HasLastPassword)); + + // Selecting default / last populates the password; enter-new clears it for typing. + partial void OnChoiceChanged(PasswordChoice value) + { + Password = value switch + { + PasswordChoice.UseDefault => DefaultPassword, + PasswordChoice.UseLast => LastPassword, + _ => string.Empty, + }; + } + + // ── Commands ────────────────────────────────────────────────────────────── + + [RelayCommand] + private void Confirm() + { + if (string.IsNullOrWhiteSpace(Password)) + { + SetError("Please enter a password."); + return; + } + + FinalPassword = Password.Trim(); + Result = PasswordDialogResult.Confirmed; + CloseAction?.Invoke(); + } + + [RelayCommand] + private void Cancel() + { + Result = PasswordDialogResult.Cancelled; + CloseAction?.Invoke(); + } + + // ── Helpers ─────────────────────────────────────────────────────────────── + + public void SetAttempt(int attempt, string? errorFromLastAttempt = null) + { + AttemptNumber = attempt; + // Default to reusing the last password when one exists; otherwise type a new one. + Choice = HasLastPassword ? PasswordChoice.UseLast : PasswordChoice.EnterNew; + Password = HasLastPassword ? LastPassword : string.Empty; + + if (errorFromLastAttempt != null) + SetError(errorFromLastAttempt); + else + ClearError(); + } + + private void SetError(string msg) { ErrorMessage = msg; HasError = true; } + private void ClearError() { ErrorMessage = string.Empty; HasError = false; } +} diff --git a/TuneBossPC/ViewModels/FilesViewModel.cs b/TuneBossPC/ViewModels/FilesViewModel.cs new file mode 100644 index 0000000..112c2e5 --- /dev/null +++ b/TuneBossPC/ViewModels/FilesViewModel.cs @@ -0,0 +1,462 @@ +using Microsoft.Win32; +using System.IO; +using System.Windows; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.IO; +using TuneBoss.Core.Models; +using TuneBossPC.Services; + +namespace TuneBossPC.ViewModels; + +/// +/// Save / open TuneBoss map files (.tst). +/// +/// Open verifies the file's integrity (MD5 of tag + data), parses the metadata tag, +/// and runs a compatibility check against the connected ECU before optionally +/// applying the tables to the editors. Save builds the tag from the connected unit +/// plus a note + save-type, serializes the tables, and writes the MD5-wrapped file. +/// +public partial class FilesViewModel : ObservableObject +{ + private readonly ISessionService _session; + private readonly IMapTableCodec _codec; + + private string? _loadedData; // verified data section awaiting "Apply" + private MapSaveType _loadedSaveType; + private int _loadedCylinders; + private MapTag? _loadedTag; // full tag of the opened file — reused on offline save + private FsrFile.FsrDocument? _loadedFsr; // parsed .fsr awaiting Apply + + // ── Save options ─────────────────────────────────────────────────────────── + public IReadOnlyList SaveTypes { get; } = + new[] { MapSaveType.User, MapSaveType.FullConfig }; + + [ObservableProperty] private MapSaveType _selectedSaveType = MapSaveType.User; + [ObservableProperty] private string _note = string.Empty; + + // ── Loaded-file summary ──────────────────────────────────────────────────── + [ObservableProperty] private bool _hasLoadedFile; + [ObservableProperty] private string _loadedFileName = string.Empty; + [ObservableProperty] private string _tagSummary = string.Empty; + [ObservableProperty] private string _compatMessage = string.Empty; + [ObservableProperty] private bool _isCompatible; + + [ObservableProperty] private string _statusMessage = "Open a map file to inspect it, or save the current tune."; + [ObservableProperty] private string _diagnosticsReport = string.Empty; + + /// Bumped on each confirmed flash — drives the flash button's green blink. + [ObservableProperty] private int _flashSuccessCount; + + public FilesViewModel(ISessionService session, IMapTableCodec codec) + { + _session = session; + _codec = codec; + _session.SessionChanged += NotifyFileCommands; + } + + private int ConnectedCylinders => + _session.Variant == EcuVariant.SingleCylinder ? 1 : 2; + + // ── OPEN ──────────────────────────────────────────────────────────────────── + + [RelayCommand] + private void Open() + { + var dlg = new OpenFileDialog + { + Title = "Open TuneBoss map file", + Filter = "TuneBoss files (*.fsr;*.tst)|*.fsr;*.tst|" + + "FSR config (*.fsr)|*.fsr|" + + "TuneBoss map (*.tst)|*.tst|All files (*.*)|*.*", + }; + if (dlg.ShowDialog() != true) return; + + // .fsr is the new all-encompassing format; .tst stays for user-level data. + if (dlg.FileName.EndsWith(".fsr", StringComparison.OrdinalIgnoreCase)) + { + OpenFsr(dlg.FileName); + return; + } + + try + { + var text = File.ReadAllText(dlg.FileName); // UTF-8 + var parsed = MapFile.TryParse(text); + if (!parsed.Ok) + { + ResetLoaded(); + StatusMessage = parsed.Error ?? "Could not read this file."; + return; + } + + var tag = MapTag.Parse(parsed.Tag); + _loadedData = parsed.Data; + _loadedSaveType = tag.SaveType; + _loadedCylinders = tag.CylinderCount; + _loadedTag = tag; + + LoadedFileName = Path.GetFileName(dlg.FileName); + TagSummary = BuildSummary(tag); + HasLoadedFile = true; + NotifyFileCommands(); + + // Compatibility against the connected unit (if any). + if (_session.IsActive && _session.Info is { } ecu) + { + var report = MapCompatibility.Check(tag, ecu, ConnectedCylinders); + IsCompatible = report.IsMatch; + CompatMessage = report.Message; + } + else + { + IsCompatible = false; + CompatMessage = "No device connected — open, edit and save this map as a new file offline."; + } + + StatusMessage = _session.IsActive + ? "File verified. Review the details, then Apply to load it into the editors." + : "File verified (offline). Apply to editors, edit, then Save as a new file."; + } + catch (Exception ex) + { + ResetLoaded(); + StatusMessage = $"Error reading file: {ex.Message}"; + } + } + + /// Opens a .fsr file: parse, stash the doc, and surface a tag summary. + private void OpenFsr(string path) + { + try + { + var doc = FsrFile.Read(File.ReadAllText(path)); + if (doc.Header.FsrVersion > FsrFile.FormatVersion) + { + ResetLoaded(); + StatusMessage = $"This .fsr is version {doc.Header.FsrVersion}; this app supports up to {FsrFile.FormatVersion}. Update the app."; + return; + } + + _loadedFsr = doc; + _loadedData = null; // FSR path doesn't use the .tst data blob + _loadedSaveType = MapSaveType.FullConfig; + _loadedCylinders = doc.Header.Cylinders; + // Synthesize a MapTag from the FSR header so Save/summary reuse the same credentials. + _loadedTag = new MapTag + { + CreatorId = doc.Header.CreatorId, + FwVersion = doc.Header.FwVersion, + HwVersion = doc.Header.HwVersion, + Make = doc.Header.Make, + Model = doc.Header.Model, + CylinderCount = doc.Header.Cylinders, + SaveType = MapSaveType.FullConfig, + MiscNote = doc.Header.Note, + EngineBlock = doc.Header.ModEngineBlock, Camshaft = doc.Header.ModCamshaft, + Exhaust = doc.Header.ModExhaust, AirFilter = doc.Header.ModAirFilter, + CylinderHead = doc.Header.ModCylinderHead, Injector = doc.Header.ModInjector, + ThrottleBody = doc.Header.ModThrottleBody, JackRod = doc.Header.ModJackRod, + }; + + LoadedFileName = Path.GetFileName(path); + TagSummary = BuildSummary(_loadedTag); + HasLoadedFile = true; + NotifyFileCommands(); + + if (_session.IsActive && _session.Info is { } ecu) + { + var report = MapCompatibility.Check(_loadedTag, ecu, ConnectedCylinders); + IsCompatible = report.IsMatch; + CompatMessage = report.Message; + } + else + { + IsCompatible = false; + CompatMessage = "No device connected — open, edit and save this config offline."; + } + + StatusMessage = "FSR config verified. Apply to load it into the editors."; + } + catch (Exception ex) + { + ResetLoaded(); + StatusMessage = $"Error reading .fsr: {ex.Message}"; + } + } + public bool CanApply => HasLoadedFile; + public bool CanApplyToEcu => HasLoadedFile && _session.IsActive; + + [RelayCommand(CanExecute = nameof(CanApply))] + private Task ApplyToEditors() => ApplyCoreAsync(write: false, flash: false); + + [RelayCommand(CanExecute = nameof(CanApplyToEcu))] + private Task ApplyAndWrite() => ApplyCoreAsync(write: true, flash: false); + + [RelayCommand(CanExecute = nameof(CanApplyToEcu))] + private Task ApplyWriteFlash() => ApplyCoreAsync(write: true, flash: true); + + /// + /// Shared apply pipeline: populate the editors from the verified file, then + /// optionally push everything to the ECU, then optionally flash. Editor-only + /// remains the safe default; flash is behind a hold-to-confirm button. + /// + private async Task ApplyCoreAsync(bool write, bool flash) + { + bool isFsr = _loadedFsr != null; + if (_loadedData is null && !isFsr) return; + try + { + // Offline: no connected device, so synthesize a view-only layout from the + // file's make/model/fw and rebuild the nav trees, so there are entries to + // populate. (Connected: the device's own layout is already in place.) + if (!_session.IsActive && _loadedTag is { } t) + { + _session.EstablishOffline((byte)t.Make, (byte)t.Model, (byte)t.FwVersion, _loadedCylinders); + _codec.RebuildNavTrees(); + NotifyFileCommands(); // HasLayout now true → Save enabled offline + } + + if (isFsr) _codec.ApplyFsr(_loadedFsr!); + else _codec.Deserialize(_loadedData!, _loadedSaveType, _loadedCylinders); + if (!write) + { + StatusMessage = _session.IsActive + ? "Map applied to the editors. Review, then Write / Flash to the ECU." + : "Map applied to the editors (offline view). Open Tuning / 1D / Config to inspect."; + return; + } + + var progress = new Progress(m => StatusMessage = m); + var summary = await _codec.WriteLoadedAsync(_loadedSaveType, _loadedCylinders, flash, progress); + if (flash) FlashSuccessCount++; + StatusMessage = flash + ? $"Applied, written and FLASHED to the ECU ({summary})." + : $"Applied and written to the ECU ({summary}) — flash manually to make permanent."; + } + catch (NotImplementedException ex) + { + StatusMessage = ex.Message; // pending-codec message + } + catch (Exception ex) + { + StatusMessage = $"Could not apply map: {ex.Message}"; + } + } + + // ── SAVE ──────────────────────────────────────────────────────────────────── + + // Save is available when connected (reads from device) OR when an offline file + // has been applied to the editors (HasLayout true) — offline saves the edited + // editor contents into a new file reusing the loaded file's credentials. + public bool CanSave => _session.IsActive || (_loadedTag != null && _session.HasLayout); + + [RelayCommand(CanExecute = nameof(CanSave))] + private async Task Save() + { + bool offline = !_session.IsActive; + if (offline && _loadedTag is null) + { + StatusMessage = "Open and apply a map file first."; + return; + } + + // Offline reuses the opened file's save type/cylinders; connected uses the picker. + var saveType = offline ? _loadedSaveType : SelectedSaveType; + int cyl = offline ? _loadedCylinders : ConnectedCylinders; + + // Full config → new .fsr format; user-level data → legacy .tst (unchanged). + if (saveType == MapSaveType.FullConfig) + { + await SaveFsrCore(offline, cyl); + return; + } + + string data; + try + { + if (!offline) + { + StatusMessage = "Reading tables from the device…"; + await _codec.PrepareAsync(saveType, cyl); + } + // Offline: the editors already hold the applied+edited values — just serialise. + data = _codec.Serialize(saveType, cyl); + } + catch (NotImplementedException ex) + { + StatusMessage = ex.Message; // pending-codec message + return; + } + catch (Exception ex) + { + StatusMessage = $"Could not read the tables to save: {ex.Message}"; + return; + } + + // Reuse the opened file's credentials offline; build from the device when connected. + MapTag tag; + if (offline) + { + tag = _loadedTag! with + { + SaveType = saveType, + MiscNote = string.IsNullOrWhiteSpace(Note) ? _loadedTag!.MiscNote : Note.Trim(), + }; + } + else + { + var ecu = _session.Info!; + tag = new MapTag + { + CreatorId = string.IsNullOrWhiteSpace(ecu.Username) ? "TUNER" : ecu.Username, + FwVersion = ecu.FwVersion, + HwVersion = ecu.HwVersion, + Make = ecu.BikeManufacturer, + Model = ecu.BikeModel, + CylinderCount = cyl, + SaveType = saveType, + MiscNote = string.IsNullOrWhiteSpace(Note) ? "none" : Note.Trim(), + }; + } + + var dlg = new SaveFileDialog + { + Title = "Save TuneBoss map file", + Filter = "TuneBoss map (*.tst)|*.tst|All files (*.*)|*.*", + DefaultExt = "tst", + AddExtension = true, + FileName = offline ? SuggestOfflineName() : SuggestFileName(_session.Info!), + }; + if (dlg.ShowDialog() != true) return; + + try + { + // BuildEnvelope reproduces the per-record MD5 checksums automatically. + File.WriteAllText(dlg.FileName, MapFile.BuildEnvelope(tag.Build(), data)); + StatusMessage = $"Saved {Path.GetFileName(dlg.FileName)} ({saveType}){(offline ? " — offline edit" : "")}."; + } + catch (Exception ex) + { + StatusMessage = $"Could not save file: {ex.Message}"; + } + } + + // ── SAVE AS .fsr (full-config; invoked by Save() when save-type = FullConfig) ── + + private async Task SaveFsrCore(bool offline, int cyl) + { + // Connected: make sure the editors hold current device data first. Unlike the + // .tst path this never throws "not loaded" — BuildFsrFromEditors just skips + // whatever isn't loaded — but PrepareAsync gives a best-effort full read. + if (!offline) + { + try + { + StatusMessage = "Reading tables from the device…"; + await _codec.PrepareAsync(MapSaveType.FullConfig, cyl); + } + catch { /* partial config still saves what loaded */ } + } + + var tag = offline ? _loadedTag : null; + var doc = _codec.BuildFsrFromEditors(_session.Info, tag, cyl); + if (!string.IsNullOrWhiteSpace(Note)) doc.Header.Note = Note.Trim(); + + if (doc.Sections.Count == 0) + { + StatusMessage = "Nothing loaded to save. Read some tables first."; + return; + } + + var dlg = new SaveFileDialog + { + Title = "Save TuneBoss config (.fsr)", + Filter = "FSR config (*.fsr)|*.fsr|All files (*.*)|*.*", + DefaultExt = "fsr", + AddExtension = true, + FileName = offline ? SuggestOfflineName() : SuggestFileName(_session.Info!), + }; + if (dlg.ShowDialog() != true) return; + + try + { + File.WriteAllText(dlg.FileName, FsrFile.Write(doc)); + int n = doc.Sections.Count; + StatusMessage = $"Saved {Path.GetFileName(dlg.FileName)} — {n} section{(n == 1 ? "" : "s")}."; + } + catch (Exception ex) + { + StatusMessage = $"Could not save .fsr: {ex.Message}"; + } + } + + private string SuggestOfflineName() + { + var mk = _loadedTag != null ? BikeRegistry.GetMake((byte)_loadedTag.Make) : "map"; + return $"{mk}_{DateTime.Now:yyyyMMdd}_edited"; + } + + + // ── DIAGNOSE (why aren't user tables reading?) ─────────────────────────────── + [RelayCommand(CanExecute = nameof(CanSave))] + private async Task Diagnose() + { + StatusMessage = "Running read diagnostic…"; + try + { + var report = await _codec.DiagnoseAsync(); + DiagnosticsReport = report; + System.Diagnostics.Debug.WriteLine(report); + StatusMessage = "Diagnostic complete — see the report below."; + } + catch (Exception ex) + { + StatusMessage = $"Diagnostic error: {ex.Message}"; + } + } + + // ── Helpers ────────────────────────────────────────────────────────────────── + + private static string SuggestFileName(EcuInfo ecu) + { + var bike = BikeRegistry.GetModel(ecu.BikeManufacturer, ecu.BikeModel) + .Replace(' ', '_').Replace('/', '-'); + return $"{bike}_{DateTime.Now:yyyyMMdd}"; + } + + private static string BuildSummary(MapTag t) + { + var bike = BikeRegistry.GetDisplayName((byte)t.Make, t.Model); + return + $"Creator: {t.CreatorId}\n" + + $"Firmware: {t.FwVersion} Hardware: {t.HwVersion}\n" + + $"Bike: {bike} ({t.CylinderCount}-cyl)\n" + + $"Contents: {t.SaveType}\n" + + $"Mods: block {t.EngineBlock}, cam {t.Camshaft}, exhaust {t.Exhaust}, " + + $"filter {t.AirFilter}, head {t.CylinderHead}, injector {t.Injector}, " + + $"throttle {t.ThrottleBody}, jackrod {t.JackRod}\n" + + $"Note: {t.MiscNote}"; + } + + private void ResetLoaded() + { + HasLoadedFile = false; + _loadedData = null; + _loadedTag = null; + _loadedFsr = null; + LoadedFileName = TagSummary = CompatMessage = string.Empty; + IsCompatible = false; + NotifyFileCommands(); + } + + partial void OnHasLoadedFileChanged(bool value) => NotifyFileCommands(); + + private void NotifyFileCommands() + { + ApplyToEditorsCommand.NotifyCanExecuteChanged(); + ApplyAndWriteCommand.NotifyCanExecuteChanged(); + ApplyWriteFlashCommand.NotifyCanExecuteChanged(); + SaveCommand.NotifyCanExecuteChanged(); + } +} diff --git a/TuneBossPC/ViewModels/MainWindowViewModel.cs b/TuneBossPC/ViewModels/MainWindowViewModel.cs new file mode 100644 index 0000000..2eadca7 --- /dev/null +++ b/TuneBossPC/ViewModels/MainWindowViewModel.cs @@ -0,0 +1,297 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; +using TuneBossPC.Views; + +namespace TuneBossPC.ViewModels; + +public partial class MainWindowViewModel : ObservableObject, IDisposable +{ + private readonly IBleService _ble; + private readonly IServiceProvider _services; + private readonly TuneBossPC.Services.ISessionService _session; + private readonly IDisposable _connSub; + + /// Build/version string shown under the logo. + public string AppVersion => TuneBossPC.AppInfo.Version; + + /// False in the dealer build → the Config and 1D Tables nav items are hidden. + public bool ShowAdvancedNav => TuneBossPC.AppInfo.ShowAdvancedNav; + + [ObservableProperty] private bool _isConnected; + [ObservableProperty] private string _connectionStatusText = "Not connected"; + [ObservableProperty] private string _deviceName = string.Empty; + [ObservableProperty] private string _firmwareInfo = string.Empty; + [ObservableProperty] private string _bikeInfo = string.Empty; + [ObservableProperty] private string _stageInfo = string.Empty; + [ObservableProperty] private string _statusLeft = "Ready"; + [ObservableProperty] private string _statusRight = string.Empty; + [ObservableProperty] private object? _currentPage; + + // ── Killswitch (press-and-hold / momentary) ──────────────────────────────── + // Kills the engine without switching off the bike by zeroing the two RPM-limit + // bytes at misc core[12..13] (RPM_Limit_div100 + Recovery). It only stays killed + // WHILE the button is held; releasing restores the saved value immediately. This + // avoids leaving a latched 0 RPM limit that a stray FLASH could persist. + // Public because [ObservableProperty] generates a public KillPhase property of this type. + public enum KillState { Inactive, Arming, Active, Restoring } + + private const int KillRpmLimitOffset = 12; + private byte _savedRpmLimit; + private byte _savedRpmRecovery; + + private readonly System.Threading.SemaphoreSlim _killGate = new(1, 1); + private volatile bool _killHeld; // mouse currently held on the button + private bool _killZeroed; // the RPM limit is currently zeroed (needs restore) + private System.DateTime _killDownUtc; + private System.Windows.Threading.DispatcherTimer? _killArmTimer; + + [NotifyPropertyChangedFor(nameof(KillswitchLabel))] + [NotifyPropertyChangedFor(nameof(KillswitchBrush))] + [ObservableProperty] private KillState _killPhase = KillState.Inactive; + + public string KillswitchLabel => KillPhase switch + { + KillState.Arming => "KILLSWITCH …", + KillState.Active => "KILLSWITCH ACTIVE", + KillState.Restoring => "KILLSWITCH …", + _ => "KILLSWITCH INACTIVE", + }; + + /// Green when active (engine killed), amber while arming/restoring, red when inactive. + public System.Windows.Media.Brush KillswitchBrush => KillPhase switch + { + KillState.Active => KillBrush(0x1E, 0x8E, 0x3E), // green + KillState.Arming or KillState.Restoring => KillBrush(0xE8, 0xA0, 0x00), // amber (working) + _ => KillBrush(0xC6, 0x28, 0x28), // red + }; + + private static System.Windows.Media.SolidColorBrush KillBrush(byte r, byte g, byte b) + => new(System.Windows.Media.Color.FromRgb(r, g, b)); + + public bool IsNotConnected => !IsConnected; + + /// The persistent diagnostics strip — always alive in the shell. + public DiagnosticsStripViewModel Strip { get; } + + public MainWindowViewModel(IBleService ble, IServiceProvider services, TuneBossPC.Services.ISessionService session, + DiagnosticsStripViewModel strip) + { + _ble = ble; + _services = services; + _session = session; + Strip = strip; + + _connSub = ble.ConnectionStateChanged.Subscribe(OnConnectionStateChanged); + } + + /// Tag of the page currently shown — drives the nav-rail highlight. + [ObservableProperty] private string _currentPageTag = ""; + + public void NavigateTo(string page) + { + // The Throttle Cal page drives the device itself and needs diagnostics off. + // Stop them through the strip VM so its START button resets to the ready state + // (rather than being silently stopped at the BLE layer, leaving the button stuck). + if (page == "TpsCal" && Strip.IsRunning) + _ = Strip.StopAsync(); + + CurrentPageTag = page; + CurrentPage = page switch + { + "Connect" => _services.GetService(typeof(ConnectView)), + "Diagnostics" => _services.GetService(typeof(DiagnosticsView)), + "TuningTables" => _services.GetService(typeof(TuningTablesView)), + "OneDimTables" => _services.GetService(typeof(OneDimTablesView)), + "MiscValues" => _services.GetService(typeof(MiscValuesView)), + "RpmSettings" => _services.GetService(typeof(RpmSettingsView)), + "TpsCal" => _services.GetService(typeof(TpsCalView)), + "Files" => _services.GetService(typeof(FilesView)), + "Settings" => _services.GetService(typeof(SettingsView)), + _ => _services.GetService(typeof(ConnectView)), + }; + } + + private void OnConnectionStateChanged(BleConnectionState state) + { + System.Windows.Application.Current.Dispatcher.Invoke(() => + { + IsConnected = state == BleConnectionState.Connected; + OnPropertyChanged(nameof(IsNotConnected)); + ConnectionStatusText = state switch + { + BleConnectionState.Connected => "Connected", + BleConnectionState.Connecting => "Connecting…", + BleConnectionState.Disconnecting => "Disconnecting…", + _ => "Not connected", + }; + StatusLeft = ConnectionStatusText; + + // Stop strip when disconnected + if (state == BleConnectionState.Disconnected && Strip.IsRunning) + _ = Strip.StopAsync(); + }); + } + + public void OnDeviceConnected(BleDeviceInfo device, EcuInfo info) + { + DeviceName = device.Name; + FirmwareInfo = $"FW {info.FwVersion} HW {info.HwVersion}"; + BikeInfo = BikeRegistry.GetDisplayName(info.BikeManufacturer, info.BikeModel); + StageInfo = $"Stage {info.Stage}"; + StatusRight = $"Flash writes: {info.FlashWriteCount}"; + } + + public void OnDeviceDisconnected() + { + DeviceName = FirmwareInfo = BikeInfo = StageInfo = StatusRight = string.Empty; + // A disconnect drops the live RAM edit anyway; clear killswitch state so a + // fresh connection starts inactive. + _killHeld = false; + _killZeroed = false; + _killArmTimer?.Stop(); + KillPhase = KillState.Inactive; + } + + [RelayCommand] + private async Task DisconnectAsync() + { + await _ble.DisconnectAsync(); + _session.Clear(); + OnDeviceDisconnected(); + NavigateTo("Connect"); + } + + // ── Killswitch: press-and-hold ────────────────────────────────────────────── + // Called on mouse-down: stash the current RPM limit and zero it (engine cuts). + public void KillswitchPress() + { + if (_killHeld) return; + if (!_session.IsActive || _session.Layout is null) + { + StatusLeft = "Killswitch needs a connected device."; + return; + } + _killHeld = true; + _ = KillswitchArmAsync(); + } + + // Called on mouse-up (or lost capture): restore the saved RPM limit. + public void KillswitchRelease() + { + if (!_killHeld) return; + _killHeld = false; + _killArmTimer?.Stop(); + _ = KillswitchRestoreAsync(); + } + + private async Task KillswitchArmAsync() + { + await _killGate.WaitAsync(); + bool zeroedNow = false; + try + { + if (_session.Layout is null) { KillPhase = KillState.Inactive; return; } + + KillPhase = KillState.Arming; + _killZeroed = false; + _killDownUtc = DateTime.UtcNow; + + ushort addr = (ushort)(_session.Layout.MiscCore.Address + KillRpmLimitOffset); + + // Read + stash the two RPM-limit bytes (data begins at payload[4]). + var read = await _ble.ReadMiscAsync(addr, 2); + if (!read.Success || read.Payload is null || read.Payload.Length < 6) + { + StatusLeft = $"Killswitch: read failed ({read.ErrorMessage})."; + KillPhase = KillState.Inactive; + return; + } + _savedRpmLimit = read.Payload[4]; + _savedRpmRecovery = read.Payload[5]; + + // Released before we zeroed anything — nothing to restore. + if (!_killHeld) { KillPhase = KillState.Inactive; return; } + + var write = await _ble.WriteMiscAsync(addr, new byte[] { 0, 0 }); + if (!write.Success) + { + StatusLeft = $"Killswitch: write failed ({write.ErrorMessage})."; + KillPhase = KillState.Inactive; + return; + } + _killZeroed = true; + zeroedNow = true; + StatusLeft = "KILLSWITCH engaged — hold to keep the engine disabled."; + } + catch (Exception ex) { StatusLeft = $"Killswitch error: {ex.Message}"; KillPhase = KillState.Inactive; } + finally { _killGate.Release(); } + + if (!zeroedNow) { await ResumeDiagIfLiveAsync(); return; } + + // Zeroed OK. If released during the write, restore now; else arm the 3s → ACTIVE. + if (!_killHeld) { await KillswitchRestoreAsync(); return; } + ArmActiveTimer(); + } + + // Flip to ACTIVE only after ~3s of continuous hold AND the zero-write has responded. + private void ArmActiveTimer() + { + var remaining = TimeSpan.FromSeconds(3) - (DateTime.UtcNow - _killDownUtc); + if (remaining <= TimeSpan.Zero) + { + if (_killHeld && _killZeroed) KillPhase = KillState.Active; + return; + } + _killArmTimer?.Stop(); + _killArmTimer = new System.Windows.Threading.DispatcherTimer { Interval = remaining }; + _killArmTimer.Tick += (_, _) => + { + _killArmTimer!.Stop(); + if (_killHeld && _killZeroed) KillPhase = KillState.Active; + }; + _killArmTimer.Start(); + } + + private async Task KillswitchRestoreAsync() + { + await _killGate.WaitAsync(); + try + { + // Nothing was zeroed (too-fast tap, or already restored) → just go inactive. + if (!_killZeroed || _session.Layout is null) + { + _killZeroed = false; + KillPhase = KillState.Inactive; + return; + } + + KillPhase = KillState.Restoring; + ushort addr = (ushort)(_session.Layout.MiscCore.Address + KillRpmLimitOffset); + var write = await _ble.WriteMiscAsync( + addr, new byte[] { _savedRpmLimit, _savedRpmRecovery }); + _killZeroed = false; + StatusLeft = write.Success + ? "Killswitch released — RPM limit restored." + : $"Killswitch: restore failed ({write.ErrorMessage})."; + KillPhase = KillState.Inactive; + } + catch (Exception ex) { StatusLeft = $"Killswitch error: {ex.Message}"; KillPhase = KillState.Inactive; } + finally { _killGate.Release(); await ResumeDiagIfLiveAsync(); } + } + + // Misc read/write pause diagnostics at the BLE layer — resume if the strip is live + // (VM-layer resume only; never restart at the BLE layer). + private async Task ResumeDiagIfLiveAsync() + { + try { if (Strip.IsRunning) await _ble.StartDiagnosticsAsync(); } + catch { /* best-effort */ } + } + + public void Dispose() + { + _connSub.Dispose(); + Strip.Dispose(); + } +} diff --git a/TuneBossPC/ViewModels/MiscValuesViewModel.MapSupport.cs b/TuneBossPC/ViewModels/MiscValuesViewModel.MapSupport.cs new file mode 100644 index 0000000..e7d570b --- /dev/null +++ b/TuneBossPC/ViewModels/MiscValuesViewModel.MapSupport.cs @@ -0,0 +1,36 @@ +using TuneBoss.Core.Models; + +namespace TuneBossPC.ViewModels.Tables; + +/// +/// Map-file support for Full Config: expose the raw misc regions for serialization, +/// apply parsed regions back, and ensure misc is read before a save. +/// +public partial class MiscValuesViewModel +{ + /// The currently-loaded misc model (raw regions), or null if not read yet. + public MiscValues? CurrentMisc => _misc; + + /// Reads the misc regions if they aren't loaded yet. + public async Task EnsureLoadedAsync() + { + if (_misc == null) await ReadAllAsync(null); + } + + /// + /// Replaces the misc model from parsed region byte blocks (data-only, no header) + /// and rebuilds the editor sections so the page reflects the loaded values. + /// + public void ApplyRegions(byte[] core, byte[] launchFuel, byte[] launchFuel2, byte[] auxOut, byte[] extended) + { + _misc = new MiscValues + { + Core = core, + LaunchFuel = launchFuel, + LaunchFuel2 = launchFuel2, + AuxOut = auxOut, + Extended = extended, + }; + RebuildSections(); + } +} diff --git a/TuneBossPC/ViewModels/MiscValuesViewModel.cs b/TuneBossPC/ViewModels/MiscValuesViewModel.cs new file mode 100644 index 0000000..96102de --- /dev/null +++ b/TuneBossPC/ViewModels/MiscValuesViewModel.cs @@ -0,0 +1,376 @@ +using System.Collections.ObjectModel; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; + +namespace TuneBossPC.ViewModels.Tables; + +// ──────────────────────────────────────────────────────────────────────────── +// One bit sub-field editor (checkbox / combo / number) over a shared byte. +// ──────────────────────────────────────────────────────────────────────────── +public partial class MiscBitEditorViewModel : ObservableObject +{ + private readonly MiscFieldViewModel _owner; + public MiscBitField Field { get; } + private readonly int _shift; + private bool _suppress; + + public string Label => Field.DisplayText; // display text (raw name stays in Field.Label) + public bool IsFlag => Field.Kind == MiscEditorKind.Flag; + public bool IsEnum => Field.Kind == MiscEditorKind.Enum; + public bool IsNumber => Field.Kind == MiscEditorKind.Number; + public string[]? Options => Field.Options; + public int Max => Field.Mask >> _shift; + public int BitIndex => _shift; // meaningful for single-bit flags + + public MiscBitEditorViewModel(MiscFieldViewModel owner, MiscBitField field) + { + _owner = owner; + Field = field; + _shift = Shift(field.Mask); + RefreshFromByte(); + } + + [ObservableProperty] private bool _isChecked; + [ObservableProperty] private int _selectedIndex; + [ObservableProperty] private int _number; + + partial void OnIsCheckedChanged(bool value) { if (!_suppress) Write(value ? 1 : 0); } + partial void OnSelectedIndexChanged(int value) { if (!_suppress && value >= 0) Write(value); } + partial void OnNumberChanged(int value) { if (!_suppress) Write(Math.Clamp(value, 0, Max)); } + + private void Write(int raw) + { + var b = _owner.ByteValue; + b = (byte)((b & ~Field.Mask) | ((raw << _shift) & Field.Mask)); + _owner.ByteValue = b; + _owner.OnBitChanged(this); + } + + public void RefreshFromByte() + { + _suppress = true; + int raw = (_owner.ByteValue & Field.Mask) >> _shift; + if (IsFlag) IsChecked = raw != 0; + else if (IsEnum) SelectedIndex = raw; + else Number = raw; + _suppress = false; + } + + private static int Shift(int mask) + { + if (mask == 0) return 0; + int s = 0; + while ((mask & 1) == 0) { mask >>= 1; s++; } + return s; + } +} + +// ──────────────────────────────────────────────────────────────────────────── +// One editable raw-byte field. Optionally carries a bit-field spec; when present +// it also exposes Bits (checkboxes / combos / numbers) over the same byte. +// ──────────────────────────────────────────────────────────────────────────── +public partial class MiscFieldViewModel : ObservableObject +{ + public MiscField Def { get; } + public MiscByteSpec? Spec { get; } + private readonly byte[] _block; + + public string Label => Def.DisplayText; // display text (raw name stays in Def.Label) + public int Index => Def.Index; + public bool HasSpec => Spec != null; + + public ObservableCollection Bits { get; } = new(); + [ObservableProperty] private bool _isExpanded; + + public MiscFieldViewModel(MiscField def, byte[] block, MiscByteSpec? spec = null) + { + Def = def; + _block = block; + Spec = spec; + _value = def.Index < block.Length ? block[def.Index] : 0; + + if (spec != null) + foreach (var f in spec.Fields) + Bits.Add(new MiscBitEditorViewModel(this, f)); + } + + /// The underlying raw byte, read/written in place. + public byte ByteValue + { + get => Def.Index < _block.Length ? _block[Def.Index] : (byte)0; + set { if (Def.Index < _block.Length) _block[Def.Index] = value; } + } + + [ObservableProperty] private int _value; + private bool _syncing; + + partial void OnValueChanged(int value) + { + int clamped = Math.Clamp(value, 0, 255); + if (clamped != value) { Value = clamped; return; } + ByteValue = (byte)clamped; + if (!_syncing) RefreshBits(); + } + + /// Called after a bit edit: apply constraints, then resync siblings + raw value. + public void OnBitChanged(MiscBitEditorViewModel src) + { + if (Spec?.MutualExclusive != null) + foreach (var (a, b) in Spec.MutualExclusive) + if (BitSet(a) && BitSet(b)) + SetBit(src.BitIndex == a ? b : a, false); + + if (Spec?.Linked != null) + foreach (var (a, b) in Spec.Linked) + { + if (src.BitIndex == a) SetBit(b, BitSet(a)); + else if (src.BitIndex == b) SetBit(a, BitSet(b)); + } + + RefreshBits(); + _syncing = true; Value = ByteValue; _syncing = false; + } + + public void RefreshBits() { foreach (var b in Bits) b.RefreshFromByte(); } + + private bool BitSet(int i) => (ByteValue & (1 << i)) != 0; + private void SetBit(int i, bool on) + { + var b = ByteValue; + ByteValue = (byte)(on ? (b | (1 << i)) : (b & ~(1 << i))); + } +} + +public partial class MiscSectionViewModel : ObservableObject +{ + public string Label { get; init; } = string.Empty; + [ObservableProperty] private bool _isSelected; + public List Fields { get; } = new(); +} + +public partial class MiscBlockGroupViewModel : ObservableObject +{ + public string Label { get; init; } = string.Empty; + [ObservableProperty] private bool _isExpanded = true; + public List Sections { get; } = new(); +} + +// ──────────────────────────────────────────────────────────────────────────── +// Misc Values page +// ──────────────────────────────────────────────────────────────────────────── +public partial class MiscValuesViewModel : ObservableObject, IDisposable +{ + private readonly IBleService _ble; + private readonly TuneBossPC.Services.ISessionService _session; + private MiscValues? _misc; + + public ObservableCollection Groups { get; } = new(); + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(HasSelection))] + private MiscSectionViewModel? _selectedSection; + + public bool HasSelection => SelectedSection != null; + + [ObservableProperty] private bool _isReading; + [ObservableProperty] private bool _isWriting; + /// Bumped on each confirmed flash — drives the FLASH button's green blink. + [ObservableProperty] private int _flashSuccessCount; + [ObservableProperty] private string _statusMessage = string.Empty; + + public MiscValuesViewModel(IBleService ble, TuneBossPC.Services.ISessionService session) + { + _ble = ble; + _session = session; + _session.SessionChanged += () => OnPropertyChanged(nameof(CanComms)); + } + + /// True when hardware comms are allowed — a live session. Offline is view-only. + public bool CanComms => _session.IsActive; + + [RelayCommand] + public void SelectSection(MiscSectionViewModel section) + { + if (SelectedSection != null) SelectedSection.IsSelected = false; + SelectedSection = section; + section.IsSelected = true; + } + + public Task InitializeAllAsync(IProgress? progress = null) => ReadAllAsync(progress); + + [RelayCommand] + public Task ReadAsync() => ReadAllAsync(null); + + /// ECU address of a misc block in the current layout (0 if no layout). + /// Used by the .fsr writer so each MISC section carries its real address. + public ushort RegionAddress(string blockName) + { + var l = _session.Layout; + if (l is null) return 0; + return blockName switch + { + "MiscCore" => l.MiscCore.Address, + "MiscLaunchFuel" => l.MiscLaunchFuel.Address, + "MiscLaunchFuel2" => l.MiscLaunchFuel2.Address, + "MiscAuxOut" => l.MiscAuxOut.Address, + "MiscExtended" => l.MiscExtended.Address, + _ => 0, + }; + } + + private async Task ReadAllAsync(IProgress? progress) + { + if (!_session.HasLayout || _session.Layout is null) return; + var layout = _session.Layout; + + IsReading = true; + StatusMessage = "Reading misc values…"; + try + { + progress?.Report("Reading misc core…"); + var core = await _ble.ReadMiscAsync(layout.MiscCore.Address, layout.MiscCore.Length); + if (!core.Success) { StatusMessage = $"Misc read failed: {core.ErrorMessage}"; return; } + + byte[]? lf = await ReadBlock(layout.MiscLaunchFuel, progress, "launch fuel"); + byte[]? lf2 = await ReadBlock(layout.MiscLaunchFuel2, progress, "launch fuel 2"); + byte[]? ao = await ReadBlock(layout.MiscAuxOut, progress, "aux out"); + byte[]? ext = await ReadBlock(layout.MiscExtended, progress, "extended"); + + _misc = MiscValues.FromPayloads(core.Payload, lf, lf2, ao, ext); + RebuildSections(); + StatusMessage = "Misc read OK"; + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsReading = false; } + } + + private async Task ReadBlock(MemoryRegion region, IProgress? progress, string name) + { + if (!region.IsAvailable) return null; + progress?.Report($"Reading misc {name}…"); + var r = await _ble.ReadMiscAsync(region.Address, region.Length); + return r.Success ? r.Payload : null; + } + + [RelayCommand] + public async Task WriteAsync() + { + if (_misc is null || _session.Layout is null) return; + var layout = _session.Layout; + + IsWriting = true; + StatusMessage = "Writing misc values…"; + try + { + if (!await WriteBlock(layout.MiscCore, _misc.Core)) return; + if (!await WriteBlock(layout.MiscLaunchFuel, _misc.LaunchFuel)) return; + if (!await WriteBlock(layout.MiscLaunchFuel2, _misc.LaunchFuel2)) return; + if (!await WriteBlock(layout.MiscAuxOut, _misc.AuxOut)) return; + if (!await WriteBlock(layout.MiscExtended, _misc.Extended)) return; + StatusMessage = "Misc write OK — click Flash to make permanent"; + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsWriting = false; } + } + + private async Task WriteBlock(MemoryRegion region, byte[] data) + { + if (!region.IsAvailable || data.Length == 0) return true; + var w = await _ble.WriteMiscAsync(region.Address, data); + if (!w.Success) { StatusMessage = $"Misc write failed: {w.ErrorMessage}"; return false; } + return true; + } + + [RelayCommand] + private async Task FlashAsync() + { + IsWriting = true; + StatusMessage = "Flashing to ECU…"; + try + { + var fr = await _ble.FlashWriteAsync(); + if (fr.Success) FlashSuccessCount++; + StatusMessage = fr.Success + ? "Flash OK — settings saved to ECU" + : $"Flash failed: {fr.ErrorMessage}"; + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsWriting = false; } + } + + private void RebuildSections() + { + // Remember which section was open so a Read/refresh doesn't jump back to the top. + string? prevGroup = SelectedSection is null + ? null + : Groups.FirstOrDefault(g => g.Sections.Contains(SelectedSection))?.Label; + string? prevSection = SelectedSection?.Label; + + Groups.Clear(); + SelectedSection = null; + if (_misc is null) return; + + var groupByBlock = new Dictionary(); + var sectionMap = new Dictionary<(MiscBlock, string), MiscSectionViewModel>(); + + foreach (var f in MiscFieldRegistry.All) + { + var arr = BlockArray(f.Block); + if (f.Index >= arr.Length) continue; + + if (!groupByBlock.TryGetValue(f.Block, out var grp)) + { + grp = new MiscBlockGroupViewModel { Label = BlockDisplay(f.Block) }; + groupByBlock[f.Block] = grp; + Groups.Add(grp); + } + + var key = (f.Block, f.Section); + if (!sectionMap.TryGetValue(key, out var sec)) + { + sec = new MiscSectionViewModel { Label = f.Section }; + sectionMap[key] = sec; + grp.Sections.Add(sec); + } + + var spec = MiscBitSpecRegistry.Find(f.Block, f.Label); + sec.Fields.Add(new MiscFieldViewModel(f, arr, spec)); + } + + // Reselect the previously-open section if it still exists; otherwise fall back + // to the first one (initial load, or the section no longer present). + MiscSectionViewModel? restore = null; + if (prevSection != null) + restore = Groups + .Where(g => prevGroup == null || g.Label == prevGroup) + .SelectMany(g => g.Sections) + .FirstOrDefault(s => s.Label == prevSection); + + var target = restore ?? Groups.SelectMany(g => g.Sections).FirstOrDefault(); + if (target != null) SelectSection(target); + } + + private byte[] BlockArray(MiscBlock b) => b switch + { + MiscBlock.Core => _misc!.Core, + MiscBlock.LaunchFuel => _misc!.LaunchFuel, + MiscBlock.LaunchFuel2 => _misc!.LaunchFuel2, + MiscBlock.AuxOut => _misc!.AuxOut, + MiscBlock.Extended => _misc!.Extended, + _ => Array.Empty(), + }; + + private static string BlockDisplay(MiscBlock b) => b switch + { + MiscBlock.Core => "Core", + MiscBlock.LaunchFuel => "Launch Fuel", + MiscBlock.LaunchFuel2 => "Launch Fuel 2", + MiscBlock.AuxOut => "Aux Out", + MiscBlock.Extended => "Extended", + _ => b.ToString(), + }; + + public void Dispose() { } +} diff --git a/TuneBossPC/ViewModels/OneDimTablesViewModel.MapSupport.cs b/TuneBossPC/ViewModels/OneDimTablesViewModel.MapSupport.cs new file mode 100644 index 0000000..9bcd791 --- /dev/null +++ b/TuneBossPC/ViewModels/OneDimTablesViewModel.MapSupport.cs @@ -0,0 +1,35 @@ +namespace TuneBossPC.ViewModels.Tables; + +/// +/// Map-file support: read any 1D tables that aren't cached yet, so a Full Config save +/// captures all 37 tables even if the user hasn't opened the 1D page this session. +/// +public partial class OneDimTablesViewModel +{ + /// Reads every available 1D table whose model isn't loaded. Best-effort. + public async Task EnsureLoadedAsync() + { + foreach (var entry in Groups.SelectMany(g => g.Entries)) + { + if (entry.Table == null && entry.IsAvailable) + { + try { await ReadEntryAsync(entry); } catch { /* reported by caller */ } + } + } + } + + /// Writes every loaded 1D table to the ECU from its model. Throws on first failure. + public async Task WriteAllLoadedAsync(IProgress? progress = null) + { + int written = 0; + foreach (var e in Groups.SelectMany(g => g.Entries)) + { + if (e.Table == null || !e.IsAvailable) continue; + progress?.Report($"Writing 1D: {e.Label}…"); + var w = await _ble.WriteTable1DAsync(e.Address, e.Table.ToWirePayload()); + if (!w.Success) throw new InvalidOperationException($"{e.Label}: {w.ErrorMessage}"); + written++; + } + return written; + } +} diff --git a/TuneBossPC/ViewModels/OneDimTablesViewModel.cs b/TuneBossPC/ViewModels/OneDimTablesViewModel.cs new file mode 100644 index 0000000..2de8433 --- /dev/null +++ b/TuneBossPC/ViewModels/OneDimTablesViewModel.cs @@ -0,0 +1,789 @@ +using System.Collections.ObjectModel; +using System.Windows; +using System.Windows.Media; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; + +namespace TuneBossPC.ViewModels.Tables; + +// ──────────────────────────────────────────────────────────────────────────── +// Nav-tree entry / group (1D-specific, parallel to TableEntry/GroupViewModel). +// Kept separate so the shared 2D nav types stay untouched. +// ──────────────────────────────────────────────────────────────────────────── +public partial class OneDimEntryViewModel : ObservableObject +{ + public int Slot { get; init; } + public string Label { get; init; } = string.Empty; + public OneDimGroup Group { get; init; } + public ushort Address { get; init; } + public byte ReadLength { get; init; } + public bool IsAvailable { get; init; } = true; + + /// Display-only unit labels (default from registry, editable in the UI). + [ObservableProperty] private string _axisUnit = string.Empty; + [ObservableProperty] private string _valueUnit = string.Empty; + + [ObservableProperty] private bool _isSelected; + [ObservableProperty] private bool _isLoaded; + [ObservableProperty] private bool _isLoading; + + /// Loaded model (null until first read). + public OneDimTable? Table { get; set; } +} + +public partial class OneDimGroupViewModel : ObservableObject +{ + public string Label { get; init; } = string.Empty; + [ObservableProperty] private bool _isExpanded = true; + [ObservableProperty] private bool _isSelected; + public List Entries { get; } = new(); +} + +// ──────────────────────────────────────────────────────────────────────────── +// 1D Tables page view-model +// ──────────────────────────────────────────────────────────────────────────── +public partial class OneDimTablesViewModel : ObservableObject, IDisposable +{ + private const int N = OneDimTable.PointCount; // 8 + + private readonly IBleService _ble; + private readonly TuneBossPC.Services.ISessionService _session; + + private static readonly Brush CellBg = MakeFrozen(0x22, 0x26, 0x2B); + + // ── Nav tree ────────────────────────────────────────────────────────────── + public ObservableCollection Groups { get; } = new(); + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(HasSelectedTable))] + private OneDimEntryViewModel? _selectedEntry; + + public bool HasSelectedTable => SelectedEntry != null; + + // ── Grid (single value row + editable axis breakpoints) ─────────────────── + public ObservableCollection Cells { get; } = new(); + [ObservableProperty] private ObservableCollection _axisHeaders = new(); + + [ObservableProperty] private TuningTableCellViewModel? _selectedCell; + [ObservableProperty] private TuningTableCellViewModel? _editingCell; + [ObservableProperty] private AxisHeaderViewModel? _editingHeader; + + [ObservableProperty] private string _setValueText = string.Empty; + [ObservableProperty] private string _statusMessage = string.Empty; + [ObservableProperty] private string _metaSummary = string.Empty; + [ObservableProperty] private bool _isReading; + [ObservableProperty] private bool _isWriting; + /// Bumped on each confirmed flash — drives the FLASH button's green blink. + [ObservableProperty] private int _flashSuccessCount; + + /// Raised when the curve needs redrawing (after populate or any value/axis edit). + public event Action? CurveInvalidated; + + private readonly DiagnosticsStripViewModel _strip; + + public OneDimTablesViewModel(IBleService ble, TuneBossPC.Services.ISessionService session, + DiagnosticsStripViewModel strip) + { + _ble = ble; + _session = session; + _strip = strip; + _session.SessionChanged += () => OnPropertyChanged(nameof(CanComms)); + + for (int c = 0; c < N; c++) + Cells.Add(new TuningTableCellViewModel { Row = 0, Col = c }); + + RebuildNavTree(); + } + + /// + /// When true, the Y (value) column is shown raw × value-multiplier; when false + /// (default) the raw stored values are shown as-is. Independent of the X toggle. + /// + [ObservableProperty] private bool _showYMultiplied; + + /// + /// When true, the X (axis/breakpoint) row is shown raw × raw-multiplier; when + /// false (default) the raw stored breakpoints are shown as-is. Independent of Y. + /// + [ObservableProperty] private bool _showXMultiplied; + + partial void OnShowYMultipliedChanged(bool value) + { + if (SelectedEntry?.Table != null) PopulateGrid(SelectedEntry.Table); + CurveInvalidated?.Invoke(); + } + + partial void OnShowXMultipliedChanged(bool value) + { + if (SelectedEntry?.Table != null) PopulateGrid(SelectedEntry.Table); + CurveInvalidated?.Invoke(); + } + + /// Effective value multiplier honouring the Y toggle (1 = unscaled). + private int DisplayConvMult => ShowYMultiplied ? EffConvMult : 1; + + /// Value multiplier the curve axis labels should use (honours the Y toggle). + public int DisplayCurveMult => DisplayConvMult; + + /// X-axis (breakpoint) multiplier — honours the independent X toggle + /// (1 = unscaled when unchecked). + public int AxisDisplayMult => ShowXMultiplied ? EffRawMult : 1; + + // ── Metadata bytes [16..23] of the selected 1D table (read-only display) ────── + // Shown to the right of the curve as a label/value pair list. + /// + /// One row in the metadata panel. Read-only display by default; when the panel is + /// unlocked (5 clicks on the header) the numeric rows expose an editable text box + /// whose committed value writes straight back to the OneDimTable model, so the + /// existing 1D WRITE (which serialises via ToWirePayload) sends the new metadata. + /// + public sealed partial class MetaRow : ObservableObject + { + private readonly System.Func? _read; + private readonly System.Action? _apply; + + public string Label { get; } + public bool IsEditable => _apply != null; + + [ObservableProperty] private string _value = string.Empty; + [ObservableProperty] private string _editText = string.Empty; + + // Display-only row (e.g. Address). + public MetaRow(string label, string value) + { + Label = label; + Value = value; + } + + // Editable row: read() gives the display value, apply(text) parses + writes the model. + public MetaRow(string label, System.Func read, System.Action apply) + { + Label = label; + _read = read; + _apply = apply; + Value = read(); + EditText = Value; + } + + /// Parse the edit box and push into the model; refresh display. Returns + /// false (and reverts the box) if the text isn't a valid byte value. + public bool Commit() + { + if (_apply == null || _read == null) return true; + try { _apply(EditText.Trim()); } + catch { EditText = Value; return false; } + Value = _read(); + EditText = Value; + return true; + } + + public void Revert() + { + if (_read != null) { Value = _read(); EditText = Value; } + } + } + + /// True once the hidden 5-click gesture on the metadata header unlocks editing. + [ObservableProperty] private bool _metadataUnlocked; + + private int _metaClickCount; + private System.DateTime _lastMetaClickUtc; + + /// + /// Hidden gesture: five clicks on the metadata header (within ~2s of each other) + /// unlocks the metadata fields for editing. A sixth click re-locks them. + /// + public void RegisterMetadataHeaderClick() + { + var now = System.DateTime.UtcNow; + if ((now - _lastMetaClickUtc).TotalSeconds > 2) _metaClickCount = 0; + _lastMetaClickUtc = now; + _metaClickCount++; + + if (_metaClickCount >= 5) + { + _metaClickCount = 0; + MetadataUnlocked = !MetadataUnlocked; + StatusMessage = MetadataUnlocked + ? "Metadata editing UNLOCKED — values will be written on WRITE." + : "Metadata editing locked."; + if (!MetadataUnlocked) OnPropertyChanged(nameof(MetaRows)); // discard uncommitted edits + } + } + + public IReadOnlyList MetaRows + { + get + { + var t = SelectedEntry?.Table; + if (t == null) return System.Array.Empty(); + + // Editable numeric row: parse as int, range-check to a byte/sbyte, assign. + MetaRow ByteRow(string label, System.Func get, System.Action set, + int lo, int hi) => + new(label, () => get().ToString(), text => + { + if (!int.TryParse(text, out int v) || v < lo || v > hi) + throw new System.FormatException(); + set(v); + }); + + return new MetaRow[] + { + new("Address", "0x" + SelectedEntry!.Address.ToString("X4")), + ByteRow("Max Raw", () => t.MaxRaw, v => t.MaxRaw = v, -128, 255), + ByteRow("Min Raw", () => t.MinRaw, v => t.MinRaw = v, -128, 255), + ByteRow("Raw Signed", () => t.RawSignedFlag, v => t.RawSignedFlag = (byte)v, 0, 255), + ByteRow("Conv Signed", () => t.ConvSignedFlag, v => t.ConvSignedFlag = (byte)v, 0, 255), + ByteRow("Raw Mult", () => t.RawMultiplier, v => t.RawMultiplier = (byte)v, 0, 255), + ByteRow("Conv Mult", () => t.ConvMultiplier, v => t.ConvMultiplier = (byte)v, 0, 255), + ByteRow("Raw Round", () => t.RawRounding, v => t.RawRounding = (byte)v, 0, 255), + ByteRow("Conv Offset", () => (int)t.ConvOffset, v => t.ConvOffset = (sbyte)v, -128, 127), + }; + } + } + + /// + /// Diagnostics stops at the protocol level on every write and nothing restarts it; + /// resume the live stream if the strip says it should be running. + /// + private async Task ResumeDiagnosticsIfLiveAsync() + { + try { if (_strip.IsRunning) await _ble.StartDiagnosticsAsync(); } + catch { /* best-effort */ } + } + + // ── Nav tree ────────────────────────────────────────────────────────────── + + /// True when hardware comms are allowed — a live session. Offline is view-only. + public bool CanComms => _session.IsActive; + + /// Rebuilds the nav tree from the current session layout. Call after connect. + public void RebuildNavTree() + { + OnPropertyChanged(nameof(CanComms)); + Groups.Clear(); + if (!_session.HasLayout || _session.Layout is null) return; + + var layout = _session.Layout; + + var entries = new List(); + foreach (var def in OneDimTableRegistry.All) + { + int idx = def.Slot - 1; + if (idx < 0 || idx >= layout.OneDimTables.Length) continue; + + var region = layout.OneDimTables[idx]; + if (!region.IsAvailable) continue; // FW / generation gated out + + entries.Add(new OneDimEntryViewModel + { + Slot = def.Slot, + Label = def.Label, + Group = def.Group, + Address = region.Address, + ReadLength = region.Length, + IsAvailable = true, + AxisUnit = def.AxisUnit, + ValueUnit = def.ValueUnit, + }); + } + + foreach (var g in OneDimTableRegistry.GroupOrder) + { + var groupEntries = entries.Where(e => e.Group == g).ToList(); + if (groupEntries.Count == 0) continue; + + var gvm = new OneDimGroupViewModel { Label = OneDimTableRegistry.DisplayName(g) }; + gvm.Entries.AddRange(groupEntries); + Groups.Add(gvm); + } + + // Two-panel nav: default to the first category + SelectGroup(Groups.FirstOrDefault()); + } + + // ── Category (main group) selection — drives the child entry panel ───────── + + [ObservableProperty] private OneDimGroupViewModel? _selectedGroup; + + [RelayCommand] + public void SelectGroup(OneDimGroupViewModel? group) + { + foreach (var g in Groups) g.IsSelected = false; + SelectedGroup = group; + if (group != null) group.IsSelected = true; + } + + // ── Nav selection ───────────────────────────────────────────────────────── + + [RelayCommand] + public void SelectEntry(OneDimEntryViewModel entry) + { + // Keep the category panel in sync when selection comes from code + // (e.g. first-loaded entry after connect). + var owner = Groups.FirstOrDefault(g => g.Entries.Contains(entry)); + if (owner != null && owner != SelectedGroup) SelectGroup(owner); + + // Preserve unwritten edits: harvest the OUTGOING table's on-screen values into + // its model before navigating away, so returning shows edits not the read data. + if (SelectedEntry is { IsLoaded: true, Table: not null } prev && prev != entry) + HarvestToModel(prev); + + if (SelectedEntry != null) SelectedEntry.IsSelected = false; + ClearSelection(); + + SelectedEntry = entry; + entry.IsSelected = true; + + if (entry.IsLoaded && entry.Table != null) + PopulateGrid(entry.Table); + else + { + ClearGrid(); + OnPropertyChanged(nameof(MetaRows)); + StatusMessage = "Click READ to load this table."; + } + } + + // ── Read / Write / Flash ────────────────────────────────────────────────── + + [RelayCommand] + public async Task ReadAsync() + { + var entry = SelectedEntry; + if (entry == null) return; + + IsReading = true; + StatusMessage = "Reading…"; + try + { + if (await ReadEntryAsync(entry) && entry.Table != null) + { + PopulateGrid(entry.Table); + StatusMessage = "Read OK"; + } + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsReading = false; await ResumeDiagnosticsIfLiveAsync(); } + } + + /// Reads all available 1D tables so they're cached for instant viewing. Mirrors the 2D init. + public async Task InitializeAllAsync(IProgress? progress = null) + { + IsReading = true; + var all = Groups.SelectMany(g => g.Entries).ToList(); + + int done = 0; + foreach (var e in all) + { + progress?.Report($"Loading {e.Label}… ({++done}/{all.Count})"); + try { await ReadEntryAsync(e); } + catch { /* keep loading the rest */ } + } + IsReading = false; + + var first = all.FirstOrDefault(e => e.IsLoaded); + if (first != null) + Application.Current.Dispatcher.Invoke(() => SelectEntry(first)); + } + + private async Task ReadEntryAsync(OneDimEntryViewModel entry) + { + if (!entry.IsAvailable) return false; + + entry.IsLoading = true; + try + { + var r = await _ble.ReadTable1DAsync(entry.Address, entry.ReadLength); + if (!r.Success) { StatusMessage = $"Read failed: {r.ErrorMessage}"; return false; } + if (r.Payload.Length < 4 + OneDimTable.WireLength) + { StatusMessage = "Read returned a short payload."; return false; } + + entry.Table = OneDimTable.FromWire(r.Payload, 4); // skip 51 43 17 00 + entry.IsLoaded = true; + return true; + } + finally { entry.IsLoading = false; } + } + + [RelayCommand] + public async Task WriteAsync() + { + var entry = SelectedEntry; + if (entry?.Table == null || !entry.IsLoaded) return; + + IsWriting = true; + StatusMessage = "Writing…"; + try + { + HarvestToModel(entry); + var w = await _ble.WriteTable1DAsync(entry.Address, entry.Table.ToWirePayload()); + StatusMessage = w.Success + ? "Write OK — click Flash to make permanent" + : $"Write failed: {w.ErrorMessage}"; + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsWriting = false; await ResumeDiagnosticsIfLiveAsync(); } + } + + [RelayCommand] + private async Task FlashAsync() + { + IsWriting = true; + StatusMessage = "Flashing to ECU…"; + try + { + var fr = await _ble.FlashWriteAsync(); + if (fr.Success) FlashSuccessCount++; + StatusMessage = fr.Success + ? "Flash OK — settings saved to ECU" + : $"Flash failed: {fr.ErrorMessage}"; + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsWriting = false; } + } + + // ── Bulk adjust / set ───────────────────────────────────────────────────── + + // Effective display multipliers (0/1 => unscaled). Display = raw × mult. + private int EffRawMult => Math.Max(1, (int)(SelectedEntry?.Table?.RawMultiplier ?? 1)); + private int EffConvMult => Math.Max(1, (int)(SelectedEntry?.Table?.ConvMultiplier ?? 1)); + + [RelayCommand] public void AdjustPlus1() => AdjustSelected(+1); + [RelayCommand] public void AdjustMinus1() => AdjustSelected(-1); + + [RelayCommand] + private void ApplySetValue() + { + if (double.TryParse(SetValueText, out double disp)) ApplyDisplayToSelection(disp); + } + + /// Bulk nudge by whole RAW units (one press = ±1 raw = ±multiplier on the display). + private void AdjustSelected(int rawDelta) + { + if (SelectedEntry?.Table == null) return; + foreach (var c in BulkTargets()) SetCellValue(c, c.RawValue + rawDelta); + CurveInvalidated?.Invoke(); + } + + /// Set the selection from a DISPLAYED (scaled) value. Rejects non-multiples of the value multiplier. + public void ApplyDisplayToSelection(double display) + { + if (SelectedEntry?.Table == null) return; + + int mult = DisplayConvMult; + double q = display / mult; + if (Math.Abs(q - Math.Round(q)) > 1e-6) + { + StatusMessage = mult == 1 + ? "Value must be a whole number" + : $"Value must be a multiple of {mult}"; + return; + } + + double raw = Math.Round(q); + foreach (var c in BulkTargets()) SetCellValue(c, raw); + CurveInvalidated?.Invoke(); + } + + /// Stores the RAW value on the cell and shows raw × multiplier. + private void SetCellValue(TuningTableCellViewModel cell, double raw) + { + double cv = ClampConv(raw); + cell.RawValue = cv; + cell.DisplayValue = ((long)Math.Round(cv * DisplayConvMult)).ToString(); + } + + private double ClampConv(double v) + { + var t = SelectedEntry?.Table; + double r = Math.Round(v); + if (t == null) return r; + return t.IsConvSigned ? Math.Clamp(r, -128, 127) : Math.Clamp(r, 0, 255); + } + + // ── Selection (single row → contiguous column span) ─────────────────────── + + private IEnumerable SelectedCells => Cells.Where(c => c.IsSelected); + + public void BeginSelection(TuningTableCellViewModel cell) + { + CommitEdit(); + foreach (var c in Cells) c.IsSelected = false; + SelectedCell = cell; + cell.IsSelected = true; + UpdateSelectionBorders(); + CurveInvalidated?.Invoke(); // recolour the active curve point + } + + public void ExtendSelection(TuningTableCellViewModel target) + { + if (SelectedCell == null) { BeginSelection(target); return; } + int c0 = Math.Min(SelectedCell.Col, target.Col); + int c1 = Math.Max(SelectedCell.Col, target.Col); + foreach (var c in Cells) c.IsSelected = c.Col >= c0 && c.Col <= c1; + UpdateSelectionBorders(); + CurveInvalidated?.Invoke(); + } + + private void UpdateSelectionBorders() + { + const double bw = 2.5; + var cols = new HashSet(SelectedCells.Select(c => c.Col)); + foreach (var c in Cells) + { + if (!c.IsSelected) { c.SelectionBorder = new Thickness(0); continue; } + double l = cols.Contains(c.Col - 1) ? 0 : bw; + double r = cols.Contains(c.Col + 1) ? 0 : bw; + c.SelectionBorder = new Thickness(l, bw, r, bw); + } + } + + private void ClearSelection() + { + CancelEdit(); + foreach (var c in Cells) c.IsSelected = false; + SelectedCell = null; + UpdateSelectionBorders(); + } + + private List BulkTargets() + { + var t = SelectedCells.ToList(); + if (t.Count == 0 && SelectedCell != null) t.Add(SelectedCell); + return t; + } + + // ── In-cell editing ─────────────────────────────────────────────────────── + + public void BeginEdit(string? seed = null) + { + if (SelectedCell == null || SelectedEntry?.Table == null) return; + CancelEdit(); + EditingCell = SelectedCell; + SelectedCell.EditText = seed ?? SelectedCell.DisplayValue; + SelectedCell.IsEditing = true; + } + + public void CommitEdit() + { + var cell = EditingCell; + if (cell == null) return; + cell.IsEditing = false; + EditingCell = null; + if (double.TryParse(cell.EditText, out double v)) ApplyDisplayToSelection(v); + } + + public void CancelEdit() + { + if (EditingCell == null) return; + EditingCell.IsEditing = false; + EditingCell = null; + } + + // ── Copy / paste (horizontal) ───────────────────────────────────────────── + + private double[]? _clipboard; + + [RelayCommand] + private void CopySelection() + { + var cells = SelectedCells.OrderBy(c => c.Col).ToList(); + if (cells.Count == 0) return; + _clipboard = cells.Select(c => c.RawValue).ToArray(); + StatusMessage = $"Copied {_clipboard.Length} cells"; + } + + [RelayCommand] + private void PasteToSelection() + { + if (_clipboard == null || SelectedEntry?.Table == null || SelectedCell == null) return; + + int baseC = SelectedCell.Col; + var pasted = new List(); + for (int i = 0; i < _clipboard.Length; i++) + { + int cc = baseC + i; + if (cc >= N) break; // clamp to last column + SetCellValue(Cells[cc], _clipboard[i]); + pasted.Add(Cells[cc]); + } + + foreach (var c in Cells) c.IsSelected = false; + foreach (var c in pasted) c.IsSelected = true; + UpdateSelectionBorders(); + CurveInvalidated?.Invoke(); + StatusMessage = $"Pasted {pasted.Count} cells"; + } + + // ── Axis breakpoint editing ─────────────────────────────────────────────── + + public void BeginAxisEdit(AxisHeaderViewModel h) + { + CommitEdit(); + foreach (var x in AxisHeaders) x.IsEditing = false; + h.EditText = h.DisplayValue; + h.IsEditing = true; + EditingHeader = h; + } + + public void CommitAxisEdit(AxisHeaderViewModel h) + { + if (!h.IsEditing) return; + h.IsEditing = false; + if (ReferenceEquals(EditingHeader, h)) EditingHeader = null; + + var t = SelectedEntry?.Table; + if (t == null) return; + if (!double.TryParse(h.EditText, out double entered)) return; // revert silently + + // Match whatever the axis is currently displaying: scaled when the ×scale + // toggle is on, unscaled (raw) when off — so the user types what they see. + int mult = ShowXMultiplied ? EffRawMult : 1; + double q = entered / mult; + if (Math.Abs(q - Math.Round(q)) > 1e-6) + { + StatusMessage = mult == 1 + ? "Axis must be a whole number" + : $"Axis must be a multiple of {mult}"; + return; // reject, display reverts + } + + // Bound only to what a raw axis byte can physically store. The table's + // MinRaw/MaxRaw bytes are display metadata and are frequently 0/0, which + // previously clamped every entry to 0 and then failed the sequence check. + // The strict-between-neighbours check below is the real ordering constraint. + int lo = t.IsRawSigned ? -128 : 0; + int hi = t.IsRawSigned ? 127 : 255; + int raw = Math.Clamp((int)Math.Round(q), lo, hi); + + var vals = AxisHeaders.Select(x => x.Value).ToList(); + if (!IsInSequence(vals, h.Index, raw)) + { + StatusMessage = SequenceMessage(vals, h.Index, mult); + return; // out of sequence → reject, display reverts + } + + h.Value = raw; + h.DisplayValue = ((long)raw * mult).ToString(); + StatusMessage = $"Axis[{h.Index}] = {(long)raw * mult}{UnitSuffix(SelectedEntry?.AxisUnit)}"; + CurveInvalidated?.Invoke(); + } + + public void CancelAxisEdit(AxisHeaderViewModel h) + { + h.IsEditing = false; + if (ReferenceEquals(EditingHeader, h)) EditingHeader = null; + } + + /// Strict monotonic check against immediate neighbours (direction auto-detected). + private static bool IsInSequence(IReadOnlyList vals, int index, int newVal) + { + bool ascending = vals.Count < 2 || vals[^1] >= vals[0]; + int? lo = index > 0 ? vals[index - 1] : (int?)null; + int? hi = index < vals.Count - 1 ? vals[index + 1] : (int?)null; + + return ascending + ? (lo is null || newVal > lo) && (hi is null || newVal < hi) + : (lo is null || newVal < lo) && (hi is null || newVal > hi); + } + + private static string SequenceMessage(IReadOnlyList vals, int index, int mult) + { + bool ascending = vals.Count < 2 || vals[^1] >= vals[0]; + int? lo = index > 0 ? vals[index - 1] : (int?)null; + int? hi = index < vals.Count - 1 ? vals[index + 1] : (int?)null; + long? lower = (ascending ? lo : hi) is int a ? (long)a * mult : (long?)null; + long? upper = (ascending ? hi : lo) is int b ? (long)b * mult : (long?)null; + + if (lower is not null && upper is not null) return $"Axis must be between {lower} and {upper}"; + if (lower is not null) return $"Axis must be greater than {lower}"; + if (upper is not null) return $"Axis must be less than {upper}"; + return "Axis out of sequence"; + } + + private static string UnitSuffix(string? u) => string.IsNullOrWhiteSpace(u) ? "" : " " + u; + + // ── Grid population ─────────────────────────────────────────────────────── + + private void PopulateGrid(OneDimTable t) + { + int rawMult = Math.Max(1, (int)t.RawMultiplier); + int convMult = Math.Max(1, (int)t.ConvMultiplier); + + AxisHeaders.Clear(); + for (int i = 0; i < N; i++) + AxisHeaders.Add(new AxisHeaderViewModel + { + Index = i, + Kind = AxisKind.Rpm, // tag only; 1D edit logic is local + Value = t.RawAxis[i], + DisplayValue = ((long)t.RawAxis[i] * (ShowXMultiplied ? rawMult : 1)).ToString(), + }); + + for (int c = 0; c < N; c++) + { + var cell = Cells[c]; + cell.RawValue = t.ConvValues[c]; + cell.DisplayValue = ((long)t.ConvValues[c] * (ShowYMultiplied ? convMult : 1)).ToString(); + cell.Background = CellBg; + cell.Foreground = Brushes.White; + cell.IsSelected = false; + cell.SelectionBorder = new Thickness(0); + } + + MetaSummary = BuildMeta(t); + OnPropertyChanged(nameof(MetaRows)); + CurveInvalidated?.Invoke(); + } + + private void ClearGrid() + { + AxisHeaders.Clear(); + foreach (var c in Cells) + { + c.RawValue = 0; + c.DisplayValue = string.Empty; + c.IsSelected = false; + c.SelectionBorder = new Thickness(0); + } + MetaSummary = string.Empty; + CurveInvalidated?.Invoke(); + } + + private void HarvestToModel(OneDimEntryViewModel entry) + { + var t = entry.Table; + if (t == null) return; + + for (int c = 0; c < N; c++) + t.ConvValues[c] = (int)Math.Round(Cells[c].RawValue); + + for (int i = 0; i < N && i < AxisHeaders.Count; i++) + t.RawAxis[i] = AxisHeaders[i].Value; + + // Metadata bytes (sign / min / max / multipliers / rounding / offset) are + // left untouched and round-trip verbatim via OneDimTable.ToWirePayload(). + } + + private static string BuildMeta(OneDimTable t) + { + int rm = Math.Max(1, (int)t.RawMultiplier), cm = Math.Max(1, (int)t.ConvMultiplier); + string axisRange = $"[{(long)t.MinRaw * rm}\u2026{(long)t.MaxRaw * rm}]"; + return $"axis {(t.IsRawSigned ? "signed" : "unsigned")} {axisRange} \u00D7{rm} " + + $"value {(t.IsConvSigned ? "signed" : "unsigned")} \u00D7{cm} offset {t.ConvOffset} " + + $"(display = raw \u00D7 multiplier)"; + } + + private static Brush MakeFrozen(byte r, byte g, byte b) + { + var br = new SolidColorBrush(Color.FromRgb(r, g, b)); + br.Freeze(); + return br; + } + + public void Dispose() { } +} diff --git a/TuneBossPC/ViewModels/RpmSettingsViewModel.cs b/TuneBossPC/ViewModels/RpmSettingsViewModel.cs new file mode 100644 index 0000000..5a73bc0 --- /dev/null +++ b/TuneBossPC/ViewModels/RpmSettingsViewModel.cs @@ -0,0 +1,256 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; +using TuneBossPC.Services; + +namespace TuneBossPC.ViewModels; + +/// +/// One adjustable RPM setting (RPM Limit / Shift Light / VVA Trigger). Values are shown +/// to the user in RPM; the ECU stores each as a single byte = RPM ÷ 100. +/// +public sealed partial class RpmSettingItem : ObservableObject +{ + public const int Step = 100; // one raw unit = 100 RPM + public const int MinRpm = 5000; // legacy − buttons floor at 50 × 100 + public const int ByteMaxRpm = 25500; // 255 × 100 — a single byte cannot hold more + + private readonly System.Func _setAsync; + + public string Title { get; } + public bool HasMaximum { get; } // whether the "Maximum" row is shown (VVA hides it) + + /// Raw units subtracted for the paired recovery/off byte written alongside the + /// value (legacy: RPM Limit −1, Shift Light −2, VVA −5 → 100/200/500 RPM hysteresis). + public int RecoveryDelta { get; } + + /// False when this setting isn't present on the connected unit (e.g. VVA on a non-VVA ECU). + [ObservableProperty] private bool _isAvailable = true; + + [NotifyPropertyChangedFor(nameof(Ceiling))] + [ObservableProperty] private int _maxRpm; // 0 when HasMaximum == false + + [ObservableProperty] private int _currentRpm; + [ObservableProperty] private int _newRpm; + + public RpmSettingItem(string title, bool hasMaximum, int recoveryDelta, + System.Func setAsync) + { + Title = title; + HasMaximum = hasMaximum; + RecoveryDelta = recoveryDelta; + _setAsync = setAsync; + } + + /// Upper bound for the New value — the licensed RPM cap (all three cap at it; + /// VVA just doesn't display the Maximum row), else the byte ceiling. + public int Ceiling => MaxRpm > 0 ? System.Math.Min(MaxRpm, ByteMaxRpm) : ByteMaxRpm; + + /// Apply a freshly-read current value and reset the pending New value to match. + public void SetCurrent(int rpm) + { + CurrentRpm = rpm; + NewRpm = rpm; + } + + [RelayCommand] private void Increment() => NewRpm = System.Math.Min(Ceiling, NewRpm + Step); + [RelayCommand] private void Decrement() => NewRpm = System.Math.Max(MinRpm, NewRpm - Step); + [RelayCommand] private System.Threading.Tasks.Task Set() => _setAsync(this); +} + +/// +/// RPM Settings page — read/adjust/write the RPM Limit, Shift Light and VVA RPM Trigger. +/// Ported from the legacy WinForms "RPM Settings" tab (three Max/Current/New groups). +/// +/// Each value is a single misc-Core / misc-Extended byte (RPM ÷ 100), written with a +/// targeted 1-byte write so nothing else in the block is touched (same approach as the +/// killswitch). "Set" writes to RAM (takes effect immediately); FLASH persists to flash. +/// +public sealed partial class RpmSettingsViewModel : ObservableObject +{ + private readonly IBleService _ble; + private readonly ISessionService _session; + private readonly DiagnosticsStripViewModel _strip; + + // ── Byte offsets within their misc block (from MiscFieldRegistry / legacy layout). + // Change here if a firmware revision moves them. + // NOTE: legacy shiftRpmLimitAddr was Core[108]; the current Gen3 registry places + // ShiftLight_On_RPM at Core[109] — verify the read-back on hardware. + private const int RpmLimitCoreOffset = 12; // Core[12] RPM_Limit_div100 + private const int ShiftLightCoreOffset = 109; // Core[109] ShiftLight_On_RPM_div100 + private const int VvaExtendedOffset = 124; // Extended[124] VVA_On_RPM_div100 + + public RpmSettingItem RpmLimit { get; } + public RpmSettingItem ShiftLight { get; } + public RpmSettingItem Vva { get; } + + [ObservableProperty] private string _statusMessage = "Press READ to load current values."; + [ObservableProperty] private bool _isBusy; + [ObservableProperty] private int _flashSuccessCount; + + public bool CanComms => _session.IsActive; + + public RpmSettingsViewModel(IBleService ble, ISessionService session, DiagnosticsStripViewModel strip) + { + _ble = ble; + _session = session; + _strip = strip; + + // recoveryDelta = raw units for the paired recovery/off byte (matches legacy). + RpmLimit = new RpmSettingItem("RPM Limit", hasMaximum: true, recoveryDelta: 1, WriteItemAsync); + ShiftLight = new RpmSettingItem("Shift Light RPM", hasMaximum: true, recoveryDelta: 2, WriteItemAsync); + Vva = new RpmSettingItem("VVA RPM Trigger", hasMaximum: false, recoveryDelta: 5, WriteItemAsync); + } + + // ── Address resolvers ─────────────────────────────────────────────────────── + private ushort? RpmLimitAddr => Addr(_session.Layout?.MiscCore, RpmLimitCoreOffset); + private ushort? ShiftLightAddr => Addr(_session.Layout?.MiscCore, ShiftLightCoreOffset); + private ushort? VvaAddr => Addr(_session.Layout?.MiscExtended, VvaExtendedOffset); + + private static ushort? Addr(MemoryRegion? region, int offset) + => region is { IsAvailable: true } r && r.Length > offset + ? (ushort)(r.Address + offset) + : (ushort?)null; + + // ── Read ───────────────────────────────────────────────────────────────────── + [RelayCommand] + private async System.Threading.Tasks.Task ReadAllAsync() + { + OnPropertyChanged(nameof(CanComms)); + if (IsBusy) return; + if (!_session.IsActive || _session.Layout is null) + { + StatusMessage = "Connect to a device first."; + return; + } + + IsBusy = true; + try + { + // All three cap at the licensed RPM max (legacy + buttons cap here, VVA too). + int maxRpm = (_session.Info?.UpgradeRpmMax ?? 0) * 100; + RpmLimit.MaxRpm = maxRpm; + ShiftLight.MaxRpm = maxRpm; + Vva.MaxRpm = maxRpm; + + await ReadOneAsync(RpmLimit, RpmLimitAddr); + await ReadOneAsync(ShiftLight, ShiftLightAddr); + + // VVA is gated by the bike model (legacy checkVvaModels / vvaModels.xml), + // and the extended byte must be reachable on this layout. + bool isVvaModel = VvaModelRegistry.IsVvaModel( + _session.Info?.BikeManufacturer ?? 0, _session.Info?.BikeModel ?? 0); + Vva.IsAvailable = isVvaModel && VvaAddr.HasValue; + if (Vva.IsAvailable) await ReadOneAsync(Vva, VvaAddr); + + StatusMessage = "Current values loaded."; + } + catch (System.Exception ex) { StatusMessage = $"Read error: {ex.Message}"; } + finally { IsBusy = false; await ResumeDiagAsync(); } + } + + /// + /// Targeted read of one setting. Misc read responses are [0x51][3-byte header][data…], + /// so the value sits at Payload[4] (same offset MiscValues.FromPayloads slices from). + /// Reads 2 bytes like the proven killswitch read and uses only the first. + /// + private async System.Threading.Tasks.Task ReadOneAsync(RpmSettingItem item, ushort? addr) + { + if (addr is null) { item.IsAvailable = false; return; } + + var r = await _ble.ReadMiscAsync(addr.Value, 2); + if (!r.Success || r.Payload is null || r.Payload.Length < 6) + { + StatusMessage = $"{item.Title}: read failed ({r.ErrorMessage})."; + return; + } + + item.IsAvailable = true; + item.SetCurrent(r.Payload[4] * 100); + } + + // ── Write ──────────────────────────────────────────────────────────────────── + private async System.Threading.Tasks.Task WriteItemAsync(RpmSettingItem item) + { + OnPropertyChanged(nameof(CanComms)); + if (IsBusy) return; + if (!_session.IsActive) + { + StatusMessage = "Connect to a device first."; + return; + } + + if (item == Vva && !Vva.IsAvailable) + { + StatusMessage = "This model does not have VVA."; + return; + } + + ushort? addr = item == RpmLimit ? RpmLimitAddr + : item == ShiftLight ? ShiftLightAddr + : item == Vva ? VvaAddr + : null; + if (addr is null) + { + StatusMessage = $"{item.Title}: not available on this unit."; + return; + } + + // Round to a whole 100-RPM step and clamp to [floor, licensed cap]. + int rpm = System.Math.Clamp( + (int)System.Math.Round(item.NewRpm / 100.0) * 100, + RpmSettingItem.MinRpm, item.Ceiling); + byte raw = (byte)(rpm / 100); + // Paired recovery/off byte written to value+1 (legacy hysteresis: −1/−2/−5 raw). + byte recovery = (byte)System.Math.Max(0, raw - item.RecoveryDelta); + + IsBusy = true; + try + { + // Targeted 2-byte write: [value, recovery/off] — leaves the surrounding + // bytes (failsafe / output-select) untouched, matching the legacy result. + var w = await _ble.WriteMiscAsync(addr.Value, new byte[] { raw, recovery }); + if (!w.Success) + { + StatusMessage = $"{item.Title}: write failed ({w.ErrorMessage})."; + return; + } + + await ReadOneAsync(item, addr); // read back to confirm what the ECU stored + StatusMessage = $"{item.Title} set to {item.CurrentRpm} RPM. Press FLASH to save permanently."; + } + catch (System.Exception ex) { StatusMessage = $"{item.Title}: {ex.Message}"; } + finally { IsBusy = false; await ResumeDiagAsync(); } + } + + // ── Flash (persist RAM edits) ──────────────────────────────────────────────── + [RelayCommand] + private async System.Threading.Tasks.Task FlashAsync() + { + if (IsBusy) return; + if (!_session.IsActive) + { + StatusMessage = "Connect to a device first."; + return; + } + + IsBusy = true; + try + { + var fr = await _ble.FlashWriteAsync(); + if (fr.Success) { FlashSuccessCount++; StatusMessage = "Saved to ECU flash."; } + else { StatusMessage = $"Flash failed: {fr.ErrorMessage}"; } + } + catch (System.Exception ex) { StatusMessage = $"Flash error: {ex.Message}"; } + finally { IsBusy = false; await ResumeDiagAsync(); } + } + + // Misc read/write pause diagnostics at the BLE layer — resume if the strip is live + // (VM-layer resume only; never restart at the BLE layer — a duplicate MON_START storms). + private async System.Threading.Tasks.Task ResumeDiagAsync() + { + try { if (_strip.IsRunning) await _ble.StartDiagnosticsAsync(); } + catch { /* best-effort */ } + } +} diff --git a/TuneBossPC/ViewModels/SettingsViewModel.cs b/TuneBossPC/ViewModels/SettingsViewModel.cs new file mode 100644 index 0000000..023a75f --- /dev/null +++ b/TuneBossPC/ViewModels/SettingsViewModel.cs @@ -0,0 +1,41 @@ +using System.Windows; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBossPC.Services; + +namespace TuneBossPC.ViewModels; + +public partial class SettingsViewModel : ObservableObject +{ + private readonly ISettingsService _settingsService; + + public AppSettings Settings => _settingsService.Settings; + + [ObservableProperty] private string _statusMessage = string.Empty; + + public SettingsViewModel(ISettingsService settingsService) + { + _settingsService = settingsService; + } + + [RelayCommand] + private void FactoryReset() + { + var confirm = MessageBox.Show( + "This will reset the ECU to factory settings, erasing all tuning changes.\n\n" + + "Are you sure you want to continue?", + "ECU Factory Reset", + MessageBoxButton.YesNo, + MessageBoxImage.Warning, + MessageBoxResult.No); + + if (confirm != MessageBoxResult.Yes) + { + StatusMessage = "Factory reset cancelled."; + return; + } + + // Protocol command (APP_RESET_SETTINGS 0x65) is scaffolded but not wired yet. + StatusMessage = "Factory reset is not implemented yet — coming in a future update."; + } +} diff --git a/TuneBossPC/ViewModels/StubViewModels.cs b/TuneBossPC/ViewModels/StubViewModels.cs new file mode 100644 index 0000000..416b56b --- /dev/null +++ b/TuneBossPC/ViewModels/StubViewModels.cs @@ -0,0 +1,6 @@ +using CommunityToolkit.Mvvm.ComponentModel; + +namespace TuneBossPC.ViewModels; + +// Stubs for pages not yet implemented + diff --git a/TuneBossPC/ViewModels/Tables/AxisHeaderViewModel.cs b/TuneBossPC/ViewModels/Tables/AxisHeaderViewModel.cs new file mode 100644 index 0000000..2582113 --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/AxisHeaderViewModel.cs @@ -0,0 +1,26 @@ +using CommunityToolkit.Mvvm.ComponentModel; + +namespace TuneBossPC.ViewModels.Tables; + +/// Which axis a header belongs to. +public enum AxisKind { Rpm, Load } + +/// +/// An editable axis breakpoint — one RPM column header (top) or one Load row +/// header (side). Edits are validated for monotonic sequence against neighbours +/// and written back into the table model's RpmAxis / LoadAxis by the view-model. +/// +public partial class AxisHeaderViewModel : ObservableObject +{ + /// Position along the axis (0..23 for RPM, 0..7 for Load). + public int Index { get; init; } + + public AxisKind Kind { get; init; } + + /// Numeric display value (RPM in rpm; Load in raw units). + public int Value { get; set; } + + [ObservableProperty] private string _displayValue = ""; + [ObservableProperty] private bool _isEditing; + [ObservableProperty] private string _editText = ""; +} diff --git a/TuneBossPC/ViewModels/Tables/BoolToExpanderGlyphConverter.cs b/TuneBossPC/ViewModels/Tables/BoolToExpanderGlyphConverter.cs new file mode 100644 index 0000000..4af8b68 --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/BoolToExpanderGlyphConverter.cs @@ -0,0 +1,16 @@ +using System.Globalization; +using System.Windows.Data; + +namespace TuneBossPC.ViewModels.Tables; + +/// Shows ▾ when expanded, ▸ when collapsed. +public class BoolToExpanderGlyphConverter : IValueConverter +{ + public static readonly BoolToExpanderGlyphConverter Instance = new(); + + public object Convert(object value, Type t, object p, CultureInfo c) + => value is true ? "▾" : "▸"; + + public object ConvertBack(object value, Type t, object p, CultureInfo c) + => throw new NotImplementedException(); +} diff --git a/TuneBossPC/ViewModels/Tables/HeatmapHelper.cs b/TuneBossPC/ViewModels/Tables/HeatmapHelper.cs new file mode 100644 index 0000000..3246205 --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/HeatmapHelper.cs @@ -0,0 +1,92 @@ +using System.Windows.Media; + +namespace TuneBossPC.ViewModels.Tables; + +/// +/// Computes heatmap colours for tuning table cells. +/// 7-band gradient: blue → cyan → green → yellow-green → yellow +/// Matches setDataValRange() / updateCellBackgroundColors() in TuningTablePanel.cs. +/// +public static class HeatmapHelper +{ + // Heatmap colour stops (cold → hot) + private static readonly Color[] Stops = + { + Color.FromRgb(0x00, 0x50, 0xB4), // 0/7 — deep blue + Color.FromRgb(0x00, 0x96, 0xC8), // 1/7 — blue-cyan + Color.FromRgb(0x00, 0xC8, 0xC8), // 2/7 — cyan + Color.FromRgb(0x00, 0xC8, 0x64), // 3/7 — cyan-green + Color.FromRgb(0x50, 0xC8, 0x00), // 4/7 — green + Color.FromRgb(0x96, 0xDC, 0x00), // 5/7 — yellow-green + Color.FromRgb(0xDC, 0xDC, 0x00), // 6/7 — yellow + Color.FromRgb(0xFF, 0x80, 0x00), // 7/7 — orange (max) + }; + + /// + /// Gets background and foreground brushes for a cell value. + /// + public static (SolidColorBrush Background, SolidColorBrush Foreground) + GetCellColors(double value, double minVal, double maxVal) + { + var bg = GetBackground(value, minVal, maxVal); + + // Always black — the heatmap's lime/cyan midtones made luminance-picked + // white text illegible; black stays readable across the whole ramp. + var fg = Brushes.Black; + + return (bg, fg); + } + + /// + /// Gets the tracker highlight colour — the exact live position. White so it + /// stands out against any heatmap colour (yellow/orange used to blend in). + /// In flat (no-contour) mode the cells are white, so the tracker goes orange. + /// + public static SolidColorBrush TrackerHighlight + => new(Color.FromRgb(0xFF, 0xFF, 0xFF)); // white + + /// + /// Gets the tracker adjacent colour — the three neighbouring cells. + /// + public static SolidColorBrush TrackerAdjacent + => new(Color.FromRgb(0xD3, 0xD3, 0xD3)); // light grey + + // ── Flat (no-contour) mode ─────────────────────────────────────────────── + /// Flat cell fill when the contour heatmap is turned off — plain white. + public static SolidColorBrush FlatBackground + => new(Color.FromRgb(0xFF, 0xFF, 0xFF)); // white + + /// Tracker exact-position colour in flat mode — orange (white would vanish). + public static SolidColorBrush FlatTrackerHighlight + => new(Color.FromRgb(0xFF, 0x80, 0x00)); // orange + + /// Tracker neighbour colour in flat mode — a PALE yellow. Kept light so + /// the orange active cell clearly stands out from its three neighbours. + public static SolidColorBrush FlatTrackerAdjacent + => new(Color.FromRgb(0xFF, 0xF0, 0xB3)); // pale yellow + + private static SolidColorBrush GetBackground(double value, double minVal, double maxVal) + { + double span = maxVal - minVal; + + // All values same — use mid colour + if (span <= 0) + return new SolidColorBrush(Stops[3]); + + double t = Math.Clamp((value - minVal) / span, 0.0, 1.0); + + // Map t to the 7-segment colour scale + double scaled = t * (Stops.Length - 1); + int lo = (int)Math.Floor(scaled); + int hi = Math.Min(lo + 1, Stops.Length - 1); + double frac = scaled - lo; + + var color = Lerp(Stops[lo], Stops[hi], frac); + return new SolidColorBrush(color); + } + + private static Color Lerp(Color a, Color b, double t) => Color.FromRgb( + (byte)(a.R + (b.R - a.R) * t), + (byte)(a.G + (b.G - a.G) * t), + (byte)(a.B + (b.B - a.B) * t)); +} diff --git a/TuneBossPC/ViewModels/Tables/TableEntryViewModel.cs b/TuneBossPC/ViewModels/Tables/TableEntryViewModel.cs new file mode 100644 index 0000000..1ee1ef2 --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/TableEntryViewModel.cs @@ -0,0 +1,134 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using TuneBoss.Core.Models; + +namespace TuneBossPC.ViewModels.Tables; + +/// +/// Type of table entry in the nav tree. +/// +public enum TableEntryType +{ + TuningTable, // 2D main table (TuningTable model) + AfrTable, // 2D AFR table (AfrTable model) + SubTable, // 4×6 subtable (SubTable model) + Placeholder, // Not yet implemented (e.g. Dual Injector) +} + +/// Icon shown beside a 2D table's big title. +public enum TableIconKind +{ + None, + Fuel, // droplet — fuel tables + Spark, // lightning — spark/ignition tables + Angle, // injection angle + Afr, // AFR target +} + +/// +/// A single entry in the tuning table nav tree. +/// Carries the address, label, type, and loaded data. +/// +public partial class TableEntryViewModel : ObservableObject +{ + public string Label { get; init; } = string.Empty; + /// Nav + title text shown to the user. Falls back to Label. The Label + /// remains the internal key (lookups, User→Base mapping), so only this changes. + public string? DisplayNameRaw { get; init; } + public string DisplayName => string.IsNullOrEmpty(DisplayNameRaw) ? Label : DisplayNameRaw!; + /// Hidden from the nav (still constructed so lookups/writes are unaffected). + public bool IsHidden { get; init; } + /// Which icon to show beside the big table title. + public TableIconKind IconKind { get; init; } = TableIconKind.None; + public TableEntryType EntryType { get; init; } + public ushort Address { get; init; } + public byte ReadLength { get; init; } + public bool IsAvailable { get; init; } = true; + public bool IsUserTable { get; init; } + + /// Optional subtable that lives below this table on the same view. + public TableEntryViewModel? SubTableEntry { get; init; } + + [ObservableProperty] private bool _isSelected; + [ObservableProperty] private bool _isLoaded; + [ObservableProperty] private bool _isLoading; + [ObservableProperty] private bool _isLocked; // Stage-1: user 24×8 table not exposed (read returned 0x56) + + /// False when this entry's stage group is above the connected ECU's stage + /// (read-only view). True offline or when the stage is unlocked. + [ObservableProperty] private bool _isStageUnlocked = true; + + /// True for a standalone Stage-1 subtable entry (renders the 4×6 grid only). + public bool IsStandaloneSub => EntryType == TableEntryType.SubTable; + + // Loaded data — only one will be non-null depending on EntryType + public TuningTable? TuningTable { get; set; } + public AfrTable? AfrTable { get; set; } + public SubTable? SubTable { get; set; } + + public bool IsPlaceholder => EntryType == TableEntryType.Placeholder; + public bool HasSubTable => SubTableEntry != null; + + /// Emoji/symbol glyph shown beside the big table title. + public string IconGlyph => IconKind switch + { + TableIconKind.Fuel => "💧", + TableIconKind.Spark => "⚡", + TableIconKind.Angle => "📐", + TableIconKind.Afr => "🎯", + _ => string.Empty, + }; + + /// + /// A distinct tint for this table's RPM row + Load column headers so switching + /// between tables is visually obvious. Deterministic per table (hash of Label), + /// kept dark and low-saturation so header text stays readable. + /// + public System.Windows.Media.Brush HeaderShade + { + get + { + int h = 0; + foreach (char c in Label) h = h * 31 + c; + double hue = ((h % 360) + 360) % 360; + var col = FromHsv(hue, 0.35, 0.28); + var brush = new System.Windows.Media.SolidColorBrush(col); + brush.Freeze(); + return brush; + } + } + + private static System.Windows.Media.Color FromHsv(double h, double s, double v) + { + double c = v * s; + double x = c * (1 - System.Math.Abs((h / 60.0) % 2 - 1)); + double m = v - c; + double r = 0, g = 0, b = 0; + if (h < 60) { r = c; g = x; } + else if (h < 120) { r = x; g = c; } + else if (h < 180) { g = c; b = x; } + else if (h < 240) { g = x; b = c; } + else if (h < 300) { r = x; b = c; } + else { r = c; b = x; } + return System.Windows.Media.Color.FromRgb( + (byte)((r + m) * 255), (byte)((g + m) * 255), (byte)((b + m) * 255)); + } +} + +/// +/// A group in the nav tree (Base Tables / User Tables). +/// +public partial class TableGroupViewModel : ObservableObject +{ + public string Label { get; init; } = string.Empty; + + /// Minimum ECU stage that unlocks this group (1/2/3). 0 = always on. + public int RequiredStage { get; init; } + + [ObservableProperty] private bool _isExpanded = true; + + /// False when the connected ECU is below . + /// Entries stay selectable/viewable (read-only); comms actions are disabled. + [ObservableProperty] private bool _isStageUnlocked = true; + + public List Entries { get; } = new(); +} diff --git a/TuneBossPC/ViewModels/Tables/TableRowViewModel.cs b/TuneBossPC/ViewModels/Tables/TableRowViewModel.cs new file mode 100644 index 0000000..bf05eca --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/TableRowViewModel.cs @@ -0,0 +1,23 @@ +using System; + +namespace TuneBossPC.ViewModels.Tables; + +/// +/// One row in the tuning table for binding: the editable Load breakpoint header +/// plus the 24 cell view-models. +/// +public sealed class TableRowViewModel +{ + public AxisHeaderViewModel LoadHeader { get; init; } = new(); + public TuningTableCellViewModel[] Cells { get; init; } = Array.Empty(); +} + +/// +/// One row in the subtable. Its load header stays a plain label (subtable axis +/// editing is out of scope for now). +/// +public sealed class SubTableRowViewModel +{ + public string LoadHeader { get; init; } = string.Empty; + public TuningTableCellViewModel[] Cells { get; init; } = Array.Empty(); +} diff --git a/TuneBossPC/ViewModels/Tables/TuningTableCellViewModel.cs b/TuneBossPC/ViewModels/Tables/TuningTableCellViewModel.cs new file mode 100644 index 0000000..5bc923f --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/TuningTableCellViewModel.cs @@ -0,0 +1,25 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using System.Windows; +using System.Windows.Media; + +namespace TuneBossPC.ViewModels.Tables; + +public partial class TuningTableCellViewModel : ObservableObject +{ + public int Row { get; init; } + public int Col { get; init; } + + [ObservableProperty] private string _displayValue = "0"; + [ObservableProperty] private Brush _background = Brushes.Transparent; + [ObservableProperty] private Brush _foreground = Brushes.White; + [ObservableProperty] private bool _isSelected; + [ObservableProperty] private bool _isTrackerHighlight; // exact RPM+Load match + [ObservableProperty] private bool _isTrackerAdjacent; // neighbouring cell + [ObservableProperty] private bool _isVisited; // tracker-history: cell entered while recording + [ObservableProperty] private bool _isEditing; // editor TextBox shown + [ObservableProperty] private string _editText = ""; // transient edit buffer + [ObservableProperty] private Thickness _selectionBorder; // region outline (boundary edges only) + + // Raw value (int for TuningTable, double for AfrTable) + public double RawValue { get; set; } +} diff --git a/TuneBossPC/ViewModels/Tables/TuningTablesViewModel.MapSupport.cs b/TuneBossPC/ViewModels/Tables/TuningTablesViewModel.MapSupport.cs new file mode 100644 index 0000000..ffafb3f --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/TuningTablesViewModel.MapSupport.cs @@ -0,0 +1,257 @@ +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; +using TuneBoss.Core.Protocol; + +namespace TuneBossPC.ViewModels.Tables; + +/// +/// Map-file support: re-read specific tables on demand (so a save isn't blocked by a +/// table that wasn't cached during the connect-time load, whose failures are swallowed), +/// plus an on-hardware diagnostic for the user-table read path. +/// +public partial class TuningTablesViewModel +{ + /// + /// Ensures the named entries — and their subtables — are read from the device. + /// Best-effort: a failed read leaves the model null, and the caller surfaces a + /// clear "not loaded" error rather than crashing. + /// + public async Task EnsureLoadedAsync(IEnumerable labels) + { + foreach (var label in labels) + { + var entry = Groups.SelectMany(g => g.Entries).FirstOrDefault(e => e.Label == label); + if (entry == null) continue; + + // Standalone Stage-1 subtable entry — read its own 4×6 if not loaded. + if (entry.IsStandaloneSub) + { + if (entry.SubTable == null) + { + try + { + var sr = await _ble.ReadSubTableAsync(entry.Address); + if (sr.Success) { entry.SubTable = SubTable.FromPayload(sr.Payload); entry.IsLoaded = true; } + } + catch { /* reported later */ } + } + continue; + } + + bool needMain = + (entry.EntryType == TableEntryType.TuningTable && entry.TuningTable == null) || + (entry.EntryType == TableEntryType.AfrTable && entry.AfrTable == null); + + if (needMain) + { + // Read, retrying once — a transient failure during the rapid save + // sweep otherwise leaves the table null and Save reports "not loaded". + bool ok = false; + for (int attempt = 0; attempt < 2 && !ok; attempt++) + { + try { ok = await ReadEntryAsync(entry); } + catch { ok = false; } + if (!ok) await System.Threading.Tasks.Task.Delay(60); + } + if (!ok) + throw new InvalidOperationException( + $"Couldn't read \u201C{label}\u201D from the ECU while saving. " + + $"Open its table, press READ until it loads, then save again."); + } + + if (entry.HasSubTable && entry.SubTableEntry?.SubTable == null) + { + try { await ReadSubtableInto(entry); } catch { /* reported later */ } + } + } + } + + /// + /// Reads the first user adjust table from the device with full reporting, to pin + /// down why user tables don't load. Prints the resolved generation (the value that + /// decides the opcode), the entry's address/availability, and the result of a + /// USER-opcode read vs a BASE-opcode read at the same address (the base read is + /// for comparison only and is NOT applied to any model). + /// + public async Task DiagnoseUserReadAsync() + { + var sb = new System.Text.StringBuilder(); + sb.AppendLine("── User-table read diagnostic ──"); + + var info = _sessionService.Info; + if (info is null) { sb.AppendLine("No active session — connect first."); return sb.ToString(); } + + GenerationType gen; + try { gen = GenerationConfig.ResolveGeneration(info.AppInfoVersion); } + catch (Exception ex) { sb.AppendLine($"Generation resolve FAILED: {ex.Message}"); return sb.ToString(); } + + byte expUserOp = gen == GenerationType.Gen3 ? (byte)0x45 + : gen == GenerationType.Gen2 ? (byte)0x41 + : (byte)0x00; + + sb.AppendLine($"AppInfoVersion = {info.AppInfoVersion} -> {gen}"); + sb.AppendLine($"Variant = {_sessionService.Variant}"); + sb.AppendLine($"FW / HW = {info.FwVersion} / {info.HwVersion}"); + sb.AppendLine($"Expected user opcode for {gen} = 0x{expUserOp:X2} (Gen3=0x45, Gen2=0x41)"); + if (gen != GenerationType.Gen3) + sb.AppendLine("WARN: NOT Gen3 — user reads will use the BASE opcode at the wrong address. " + + "If this bike is a basic ECU it should resolve to Gen3 (AppInfoVersion 2)."); + sb.AppendLine(); + + var entry = Groups.SelectMany(g => g.Entries).FirstOrDefault(e => e.Label == "User Fuel Pulse Width 1"); + if (entry is null) { sb.AppendLine("Entry 'User Fuel Pulse Width 1' not found."); return sb.ToString(); } + + sb.AppendLine($"Entry: addr=0x{entry.Address:X4} len={entry.ReadLength} " + + $"available={entry.IsAvailable} isUser={entry.IsUserTable}"); + if (!entry.IsAvailable) + sb.AppendLine("WARN: Entry NOT available — layout has no address for this generation."); + sb.AppendLine(); + + const byte p1 = TuneBoss.Core.Models.TuningTable.SplitFirstLength; // 127 + + var ru = await _ble.ReadTable2DAsync(entry.Address, p1, userTable: true); + sb.AppendLine($"USER read (0x{expUserOp:X2}) @0x{entry.Address:X4} len={p1}: {Fmt(ru)}"); + + var rb = await _ble.ReadTable2DAsync(entry.Address, p1, userTable: false); + sb.AppendLine($"BASE read (0x41) @0x{entry.Address:X4} len={p1}: {Fmt(rb)}"); + sb.AppendLine(); + + if (ru.Success) + sb.AppendLine("=> USER read SUCCEEDED. The null model was a one-off; re-reading at save time fixes it."); + else if (rb.Success) + sb.AppendLine("=> USER fails, BASE works at this address. The device isn't accepting the user opcode/address — " + + "confirm generation is Gen3 (0x45) and the user-space address is right for this firmware."); + else + sb.AppendLine("=> Both fail here. Likely addressing/timeout rather than opcode. " + + "resp=0x52 means the device rejected it; a timeout means no response at all."); + + return sb.ToString(); + + static string Fmt(CommandResult r) => + $"success={r.Success} resp=0x{r.ResponseCode:X2} payload={r.Payload?.Length ?? 0}B err={r.ErrorMessage ?? "-"}"; + } + + /// + /// Builds the placeholder shown for a user 24×8 adjust table that the ECU keeps + /// locked (Stage 1). Cells are all zero; the RPM/Load axis is borrowed from the + /// matching base table (read earlier in the load, same grid) so the grid headers — + /// and the subtable RPM derived from them — show a sensible range rather than zeros. + /// + private TuneBoss.Core.Models.TuningTable BuildLockedUserTable(TableEntryViewModel userEntry) + { + var baseLabel = userEntry.Label.Replace("User ", "Base "); + var baseTable = Groups.SelectMany(g => g.Entries) + .FirstOrDefault(e => e.Label == baseLabel)?.TuningTable; + + var rpm = (baseTable?.RpmAxis is byte[] ra && ra.Length == TuneBoss.Core.Models.TuningTable.Cols) + ? (byte[])ra.Clone() : DefaultRpmAxis(); + var load = (baseTable?.LoadAxis is byte[] la && la.Length == TuneBoss.Core.Models.TuningTable.Rows) + ? (byte[])la.Clone() : new byte[TuneBoss.Core.Models.TuningTable.Rows]; + + return new TuneBoss.Core.Models.TuningTable + { + Data = new byte[TuneBoss.Core.Models.TuningTable.DataBytes], + RpmAxis = rpm, + LoadAxis = load, + }; + } + + /// Fallback typical RPM axis (×100 ⇒ 1500…13000 rpm) when no base table is loaded. + private static byte[] DefaultRpmAxis() + { + var a = new byte[TuneBoss.Core.Models.TuningTable.Cols]; + for (int i = 0; i < a.Length; i++) a[i] = (byte)(15 + i * 5); + return a; + } + + /// + /// Writes the given entries to the ECU straight from their MODELS (not the on-screen + /// grid), including each entry's subtable — used by "Apply + Write" on file load, + /// where the loaded models are authoritative and may not be the selected table. + /// Locked (Stage-1) user tables are skipped. Throws on the first failed write. + /// + public async Task<(int Written, List LockedLabels)> WriteEntriesFromModelsAsync( + IEnumerable labels, IProgress? progress = null) + { + int written = 0; + var locked = new List(); + bool IsLock(CommandResult r) => r.ResponseCode == TuneBoss.Core.Protocol.Commands.APP_MEMADDR_LOCK; + + foreach (var label in labels) + { + var e = Groups.SelectMany(g => g.Entries).FirstOrDefault(x => x.Label == label); + if (e == null || !e.IsAvailable) continue; + + if (e.EntryType == TableEntryType.TuningTable && e.TuningTable != null) + { + if (e.IsLocked) + { + progress?.Report($"{label}: skipped (locked on Stage 1)"); + locked.Add(label); + } + else + { + progress?.Report($"Writing {label}…"); + var p1 = e.TuningTable.ToWirePayloadPart1(); + var p2 = e.TuningTable.ToWirePayloadPart2(); + var w1 = await _ble.WriteTable2DAsync(e.Address, p1, userTable: e.IsUserTable); + if (IsLock(w1)) + { + // Stage-1 ECU: user 24×8 space is locked. Note it, keep going — + // the rest of the file still applies. + e.IsLocked = true; + locked.Add(label); + progress?.Report($"{label}: locked (0x56) — skipped"); + continue; + } + if (!w1.Success) throw new InvalidOperationException($"{label}: {w1.ErrorMessage}"); + ushort a2 = (ushort)(e.Address + TuneBoss.Core.Models.TuningTable.SplitFirstLength + 1); + var w2 = await _ble.WriteTable2DAsync(a2, p2, userTable: e.IsUserTable); + if (IsLock(w2)) { e.IsLocked = true; locked.Add(label); continue; } + if (!w2.Success) throw new InvalidOperationException($"{label} (part 2): {w2.ErrorMessage}"); + written++; + } + } + else if (e.EntryType == TableEntryType.AfrTable && e.AfrTable != null) + { + progress?.Report($"Writing {label}…"); + var p1 = e.AfrTable.ToWirePayloadPart1(); + var p2 = e.AfrTable.ToWirePayloadPart2(); + var w1 = await _ble.WriteTable2DAsync(e.Address, p1); + if (IsLock(w1)) { locked.Add(label); continue; } + if (!w1.Success) throw new InvalidOperationException($"{label}: {w1.ErrorMessage}"); + ushort a2 = (ushort)(e.Address + TuneBoss.Core.Models.AfrTable.SplitFirstLength + 1); + var w2 = await _ble.WriteTable2DAsync(a2, p2); + if (IsLock(w2)) { locked.Add(label); continue; } + if (!w2.Success) throw new InvalidOperationException($"{label} (part 2): {w2.ErrorMessage}"); + written++; + } + + // Standalone Stage-1 subtable entry (its own SubTable, no parent). + if (e.IsStandaloneSub) + { + if (e.SubTable != null) + { + progress?.Report($"Writing {label}…"); + var sw0 = await _ble.WriteSubTableAsync(e.Address, e.SubTable.ToWirePayload()); + if (IsLock(sw0)) { locked.Add(label); continue; } + if (!sw0.Success) throw new InvalidOperationException($"{label}: {sw0.ErrorMessage}"); + written++; + } + continue; + } + + if (e.SubTableEntry is { SubTable: not null } se) + { + progress?.Report($"Writing {label} subtable…"); + var sw = await _ble.WriteSubTableAsync(se.Address, se.SubTable.ToWirePayload()); + if (IsLock(sw)) { locked.Add(label + " subtable"); continue; } + if (!sw.Success) throw new InvalidOperationException($"{label} subtable: {sw.ErrorMessage}"); + } + } + return (written, locked); + } + + /// Public wrapper so services can resume the live stream after bulk writes. + public Task ResumeStreamIfLiveAsync() => ResumeDiagnosticsIfLiveAsync(); +} diff --git a/TuneBossPC/ViewModels/Tables/TuningTablesViewModel.cs b/TuneBossPC/ViewModels/Tables/TuningTablesViewModel.cs new file mode 100644 index 0000000..29980ed --- /dev/null +++ b/TuneBossPC/ViewModels/Tables/TuningTablesViewModel.cs @@ -0,0 +1,1518 @@ +using System.Collections.ObjectModel; +using System.Windows; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; + +namespace TuneBossPC.ViewModels.Tables; + +public partial class TuningTablesViewModel : ObservableObject, IDisposable +{ + private readonly IBleService _ble; + private IDisposable? _diagSub; + + // ── Nav tree ────────────────────────────────────────────────────────────── + public ObservableCollection Groups { get; } = new(); + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(HasSelectedTable))] + [NotifyPropertyChangedFor(nameof(ShowMainGrid))] + [NotifyPropertyChangedFor(nameof(IsSubtableOnly))] + [NotifyPropertyChangedFor(nameof(CanComms))] + [NotifyPropertyChangedFor(nameof(CommsBlockReason))] + [NotifyPropertyChangedFor(nameof(AdjustMinus5Label))] + [NotifyPropertyChangedFor(nameof(AdjustMinus1Label))] + [NotifyPropertyChangedFor(nameof(AdjustPlus1Label))] + [NotifyPropertyChangedFor(nameof(AdjustPlus5Label))] + private TableEntryViewModel? _selectedEntry; + + public bool HasSelectedTable => SelectedEntry != null && !SelectedEntry.IsPlaceholder; + + /// Border colour of the tracker-history marker. White reads on the colour + /// contour, but is invisible on the flat white map — so use black there. + public System.Windows.Media.Brush HistoryMarkerBrush => + _settings.Settings.FlatMapNoContour + ? System.Windows.Media.Brushes.Black + : System.Windows.Media.Brushes.White; + + /// A standalone Stage-1 subtable entry — show the subtable grid only. + public bool IsSubtableOnly => SelectedEntry?.IsStandaloneSub == true; + + /// Main 24×8 grid + 3D map are shown for everything EXCEPT a standalone subtable. + public bool ShowMainGrid => HasSelectedTable && !IsSubtableOnly; + + /// + /// True when hardware comms (READ / WRITE / FLASH) are allowed for the current entry: + /// a live session AND the entry's stage is unlocked. False offline or read-only stage. + /// + public bool CanComms => + _sessionService.IsActive && (SelectedEntry?.IsStageUnlocked ?? false); + + /// Tooltip explaining why comms is disabled (empty when enabled). + public string CommsBlockReason => + !_sessionService.IsActive ? "No hardware connected — editing offline." + : SelectedEntry is { IsStageUnlocked: false } + ? "This table's stage is not unlocked on the connected ECU (view only)." + : string.Empty; + + /// Raised whenever the visible table's values change — feeds the 3D surface. + public event Action? SurfaceChanged; + + /// Raised on every tracker update with the exact-match (row, col); (-1,-1) = none. + public event Action? TrackerMoved; + + /// + /// Angle-like tables (spark angle, injection angle) keep motorsport RET/ADV wording; + /// quantity tables (fuel pulse width, AFR, MAP comp) read SUB/ADD instead. + /// + private bool SelectedIsAngle => + SelectedEntry?.Label is { } l && (l.Contains("Spark") || l.Contains("Angle")); + + // For angle tables, retard = more positive, advance = more negative — so RET sits + // on the +buttons and ADV on the −buttons (labels only; the math is unchanged). + public string AdjustMinus5Label => SelectedIsAngle ? "ADV 5" : "SUB 5"; + public string AdjustMinus1Label => SelectedIsAngle ? "ADV 1" : "SUB 1"; + public string AdjustPlus1Label => SelectedIsAngle ? "RET 1" : "ADD 1"; + public string AdjustPlus5Label => SelectedIsAngle ? "RET 5" : "ADD 5"; + + // ── Current table cell grid ─────────────────────────────────────────────── + public ObservableCollection Cells { get; } = new(); + public ObservableCollection SubCells { get; } = new(); + public ObservableCollection Rows { get; } = new(); + public ObservableCollection SubRows { get; } = new(); + + [ObservableProperty] private ObservableCollection _rpmHeaders = new(); + [ObservableProperty] private ObservableCollection _loadHeaders = new(); + [ObservableProperty] private ObservableCollection _subRpmHeaders = new(); + [ObservableProperty] private ObservableCollection _subLoadHeaders = new(); + + [ObservableProperty] private TuningTableCellViewModel? _selectedCell; + [ObservableProperty] private TuningTableCellViewModel? _selectedSubCell; + [ObservableProperty] private TuningTableCellViewModel? _editingCell; + [ObservableProperty] private AxisHeaderViewModel? _editingHeader; + [ObservableProperty] private string _setValueText = string.Empty; + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(ZoomPercentText))] + private double _zoomFactor = 1.0; + + public string ZoomPercentText => $"{ZoomFactor * 100:0}%"; + [ObservableProperty] private bool _isReading; + [ObservableProperty] private bool _isWriting; + /// Bumped on each confirmed flash — drives the FLASH button's green blink. + [ObservableProperty] private int _flashSuccessCount; + [ObservableProperty] private bool _hasSubTable; + [ObservableProperty] private string _statusMessage = string.Empty; + + // Tracker state from diagnostics + private int _trackerCol = -1, _trackerAdjCol = -1; + private int _trackerRow = -1, _trackerAdjRow = -1; + + // Table dimensions + private const int Cols = TuningTable.Cols; // 24 + private const int Rows_ = TuningTable.Rows; // 8 (underscore to avoid conflict with Rows collection) + private const int SubCols = SubTable.Cols; // 6 + private const int SubRows_ = SubTable.Rows; // 4 + + private readonly TuneBossPC.Services.ISessionService _sessionService; + private readonly TuneBossPC.Services.ISettingsService _settings; + + // Auto-write debounce (Settings → "Auto-write on cell change") + private readonly System.Windows.Threading.DispatcherTimer _autoWriteTimer; + private bool _autoDirtyMain, _autoDirtySub; + + // Tracker auto-select bookkeeping (Settings → "Tracker cell auto-select") + private int _autoSelRow = -1, _autoSelCol = -1; + + private readonly DiagnosticsStripViewModel _strip; + + public TuningTablesViewModel(IBleService ble, TuneBossPC.Services.ISessionService session, + TuneBossPC.Services.ISettingsService settings, + DiagnosticsStripViewModel strip) + { + _ble = ble; + _sessionService = session; + _settings = settings; + _strip = strip; + _sessionService.SessionChanged += () => + { + OnPropertyChanged(nameof(CanComms)); + OnPropertyChanged(nameof(CommsBlockReason)); + }; + + // Live-toggle the flat/contour map: recolour cells + tracker immediately, + // without disturbing the values or the current selection. + _settings.Settings.PropertyChanged += (_, e) => + { + if (e.PropertyName == nameof(TuneBossPC.Services.AppSettings.FlatMapNoContour)) + { + RecomputeHeatRangeAndRecolorAll(); + ApplyTracker(); + OnPropertyChanged(nameof(HistoryMarkerBrush)); + } + }; + + _autoWriteTimer = new System.Windows.Threading.DispatcherTimer + { + Interval = TimeSpan.FromMilliseconds(400) + }; + _autoWriteTimer.Tick += async (_, _) => await AutoWriteTickAsync(); + + InitCellGrids(); + + // Subscribe to diagnostics for live tracker + _diagSub = ble.DiagnosticsFrames.Subscribe(OnDiagFrame); + } + + // ── Auto-write on change ─────────────────────────────────────────────────── + // Any tuning-table value change marks the table dirty and (re)arms a short + // debounce, so a burst of ADD presses produces ONE write, sent 400 ms after + // the last change. Flash is never automatic. + + private void TouchAutoWrite(bool subTable) + { + if (!_settings.Settings.AutoWriteOnChange) return; + if (SelectedEntry == null || SelectedEntry.IsLocked) return; + + if (subTable) _autoDirtySub = true; else _autoDirtyMain = true; + _autoWriteTimer.Stop(); + _autoWriteTimer.Start(); + } + + private async Task AutoWriteTickAsync() + { + _autoWriteTimer.Stop(); + if (IsWriting || IsReading) { _autoWriteTimer.Start(); return; } // busy — retry shortly + + bool main = _autoDirtyMain, sub = _autoDirtySub; + _autoDirtyMain = _autoDirtySub = false; + + if (main) await WriteAsync(); + if (sub) await SubWriteAsync(); + } + + /// + /// Every write stops the ECU's diagnostics stream at the protocol level and + /// nothing restarts it automatically. If the strip says the stream should be + /// live, resume it — so neither auto-writes nor manual WRITE/FLASH silently + /// freeze the gauges and tracker. + /// + private async Task ResumeDiagnosticsIfLiveAsync() + { + try + { + if (_strip.IsRunning) + await _ble.StartDiagnosticsAsync(); + } + catch { /* stream resume is best-effort */ } + } + + /// + /// Builds the nav tree from the current session. Call after connect. + /// + public void RebuildNavTree() + { + OnPropertyChanged(nameof(CanComms)); + OnPropertyChanged(nameof(CommsBlockReason)); + Groups.Clear(); + // Build whenever a layout exists — connected OR offline file view. Offline the + // session has a layout but IsActive is false, so comms stay gated (CanComms). + var ecuSession = _sessionService.HasLayout + ? new EcuSession + { + Info = _sessionService.Info!, + Layout = _sessionService.Layout!, + Variant = _sessionService.Variant + } + : null; + BuildNavTree(ecuSession); + } + + // ── Nav tree builder ────────────────────────────────────────────────────── + + private void BuildNavTree(EcuSession? session) + { + bool isTwoCyl = session?.IsTwoCylinder ?? false; + var layout = session?.Layout; + + // Connected stage gates the groups; offline (no session) shows all, unlocked. + // Stage gating applies ONLY to a real connected device. Offline file view + // (HasLayout but not IsActive) shows every stage unlocked for inspection. + int? connectedStage = _sessionService.IsActive ? session?.Info?.Stage : null; + + // ── Stage 1: subtables, standalone (own entry, own 4×6 grid) ── + var stage1 = new TableGroupViewModel { Label = "STAGE 1", RequiredStage = 1 }; + stage1.Entries.Add(MakeSubEntry("Fuel PW Subtable 1", + layout?.Fuel_PulseWidth_Adjust1_SubTable, "Fuel Subtable 1", TableIconKind.Fuel)); + stage1.Entries.Add(MakeSubEntry("Spark Angle Subtable 1", + layout?.Spark_Angle_Adjust1_SubTable, "Spark Subtable 1", TableIconKind.Spark)); + if (isTwoCyl) + { + stage1.Entries.Add(MakeSubEntry("Fuel PW Subtable 2", + layout?.Fuel_PulseWidth_Adjust2_SubTable, "Fuel Subtable 2", TableIconKind.Fuel)); + stage1.Entries.Add(MakeSubEntry("Spark Angle Subtable 2", + layout?.Spark_Angle_Adjust2_SubTable, "Spark Subtable 2", TableIconKind.Spark)); + } + Groups.Add(stage1); + + // ── Stage 2: user adjust tables + AFR target ── + var stage2 = new TableGroupViewModel { Label = "STAGE 2", RequiredStage = 2 }; + stage2.Entries.Add(MakeEntry("User Fuel Pulse Width 1", + layout?.Fuel_PulseWidth_Adjust1, TableEntryType.TuningTable, + isUser: true, displayName: "Fuel Adjust % 1", icon: TableIconKind.Fuel)); + stage2.Entries.Add(MakeEntry("User Spark Angle 1", + layout?.Spark_Angle_Adjust1, TableEntryType.TuningTable, + isUser: true, displayName: "Spark Adjust 1", icon: TableIconKind.Spark)); + if (isTwoCyl) + { + stage2.Entries.Add(MakeEntry("User Fuel Pulse Width 2", + layout?.Fuel_PulseWidth_Adjust2, TableEntryType.TuningTable, + isUser: true, displayName: "Fuel Adjust % 2", icon: TableIconKind.Fuel)); + stage2.Entries.Add(MakeEntry("User Spark Angle 2", + layout?.Spark_Angle_Adjust2, TableEntryType.TuningTable, + isUser: true, displayName: "Spark Adjust 2", icon: TableIconKind.Spark)); + } + // Base MAP Compensation — kept (functional) but hidden from the nav. + stage2.Entries.Add(MakeEntry("Base MAP Compensation", + layout?.Secondary_Load_Conversion, TableEntryType.TuningTable, + isHidden: true)); + // AFR Target moved here (from Stage 3). + stage2.Entries.Add(MakeEntry("Base AFR Target 1", + layout?.AFR_Target1, TableEntryType.AfrTable, + displayName: "AFR Target 1", icon: TableIconKind.Afr)); + if (isTwoCyl) + stage2.Entries.Add(MakeEntry("Base AFR Target 2", + layout?.AFR_Target2, TableEntryType.AfrTable, + displayName: "AFR Target 2", icon: TableIconKind.Afr)); + Groups.Add(stage2); + + // ── Stage 3: base fuel PW, base spark angle, injection angle ── + var stage3 = new TableGroupViewModel { Label = "STAGE 3", RequiredStage = 3 }; + stage3.Entries.Add(MakeEntry("Base Fuel Pulse Width 1", + layout?.Fuel_PulseWidth1, TableEntryType.TuningTable, + displayName: "Base Fuel 1", icon: TableIconKind.Fuel)); + if (isTwoCyl) + stage3.Entries.Add(MakeEntry("Base Fuel Pulse Width 2", + layout?.Fuel_PulseWidth2, TableEntryType.TuningTable, + displayName: "Base Fuel 2", icon: TableIconKind.Fuel)); + stage3.Entries.Add(MakeEntry("Base Spark Angle 1", + layout?.Spark_Angle1, TableEntryType.TuningTable, + displayName: "Base Angle 1", icon: TableIconKind.Spark)); + if (isTwoCyl) + stage3.Entries.Add(MakeEntry("Base Spark Angle 2", + layout?.Spark_Angle2, TableEntryType.TuningTable, + displayName: "Base Angle 2", icon: TableIconKind.Spark)); + // Injection Angle moved here (from Stage 2). + stage3.Entries.Add(MakeEntry("Base Fuel Injection Angle 1", + layout?.Fuel_Angle2D, TableEntryType.TuningTable, + displayName: "Injection Angle 1", icon: TableIconKind.Angle)); + if (isTwoCyl) + stage3.Entries.Add(MakeEntry("Base Fuel Injection Angle 2", + layout?.Fuel_Angle2D_2, TableEntryType.TuningTable, + displayName: "Injection Angle 2", icon: TableIconKind.Angle)); + // Dual Injector — hidden. + stage3.Entries.Add(new TableEntryViewModel + { + Label = "Dual Injector", + EntryType = TableEntryType.Placeholder, + IsHidden = true, + }); + Groups.Add(stage3); + + // Read-only gate: a group is stage-unlocked if the ECU is at/above its stage. + // Offline (connectedStage == null) leaves everything unlocked. Entries mirror + // their group so per-entry comms gating is a simple bind. + foreach (var g in Groups) + { + g.IsStageUnlocked = connectedStage == null || connectedStage >= g.RequiredStage; + foreach (var e in g.Entries) e.IsStageUnlocked = g.IsStageUnlocked; + } + } + + private static TableEntryViewModel MakeEntry( + string label, + TuneBoss.Core.Models.MemoryRegion? region, + TableEntryType type, + TableEntryViewModel? subEntry = null, + bool isUser = false, + string? displayName = null, + bool isHidden = false, + TableIconKind icon = TableIconKind.None) => new() + { + Label = label, + DisplayNameRaw = displayName, + IsHidden = isHidden, + IconKind = icon, + EntryType = type, + Address = region?.Address ?? 0, + ReadLength = region?.Length ?? 0, + IsAvailable = region?.IsAvailable ?? false, + IsUserTable = isUser, + SubTableEntry = subEntry, + }; + + private static TableEntryViewModel MakeSubEntry( + string label, + TuneBoss.Core.Models.MemoryRegion? region, + string? displayName = null, + TableIconKind icon = TableIconKind.None) => new() + { + Label = label, + DisplayNameRaw = displayName, + IconKind = icon, + EntryType = TableEntryType.SubTable, + Address = region?.Address ?? 0, + ReadLength = region?.Length ?? 0, + IsAvailable = region?.IsAvailable ?? false, + }; + + // ── Cell grid initialisation ────────────────────────────────────────────── + + private void InitCellGrids() + { + for (int r = 0; r < Rows_; r++) + for (int c = 0; c < Cols; c++) + Cells.Add(new TuningTableCellViewModel { Row = r, Col = c }); + + for (int r = 0; r < SubRows_; r++) + for (int c = 0; c < SubCols; c++) + SubCells.Add(new TuningTableCellViewModel { Row = r, Col = c }); + } + + // ── Nav selection ───────────────────────────────────────────────────────── + + [RelayCommand] + public void SelectEntry(TableEntryViewModel entry) + { + if (entry.IsPlaceholder) return; + + // Preserve unwritten edits: harvest the OUTGOING table's on-screen values + // back into its model before we navigate away, so returning to it (which + // re-populates from the model) shows the edits instead of the last-read data. + if (SelectedEntry is { IsLoaded: true } prev && prev != entry) + { + if (prev.IsStandaloneSub) HarvestSubCellsToModel(prev); + else + { + HarvestCellsToModel(prev); + if (prev.SubTableEntry is { SubTable: not null }) HarvestSubCellsToModel(prev.SubTableEntry); + } + } + + // Deselect previous + if (SelectedEntry != null) SelectedEntry.IsSelected = false; + + ClearCellSelection(); + + SelectedEntry = entry; + entry.IsSelected = true; + HasSubTable = entry.HasSubTable || entry.IsStandaloneSub; + + ClearVisited(); // tracker-history is per-table (axes differ); reset on switch + + // Populate grid from cached data if available + if (entry.IsLoaded) + { + PopulateGridFromEntry(entry); + if (!IsSubtableOnly) + { + RecomputeHeatRangeAndRecolorAll(); + SurfaceChanged?.Invoke(); + } + } + else + StatusMessage = entry.IsStandaloneSub + ? "Click READ to load this subtable." + : "Click READ to load this table."; + } + + // ── Read ────────────────────────────────────────────────────────────────── + + [RelayCommand] + public async Task ReadAsync() + { + if (SelectedEntry == null) return; + IsReading = true; + StatusMessage = "Reading…"; + + try + { + bool ok = await ReadEntryAsync(SelectedEntry); + if (ok) + { + PopulateGridFromEntry(SelectedEntry); + if (!IsSubtableOnly) + { + RecomputeHeatRangeAndRecolorAll(); + SurfaceChanged?.Invoke(); + } + StatusMessage = SelectedEntry.IsLocked + ? "Locked (0x56) — Stage 1 ECU does not expose this user 24×8 table. Showing zeros." + : "Read OK"; + } + } + catch (Exception ex) + { + StatusMessage = $"Error: {ex.Message}"; + } + finally + { + IsReading = false; + await ResumeDiagnosticsIfLiveAsync(); + } + } + + /// + /// Reads all tables on connect so they're cached and instantly viewable. + /// Mirrors populateInitTables() from the WinForms app. + /// + public async Task InitializeAllAsync(IProgress? progress = null) + { + IsReading = true; + var allEntries = Groups + .SelectMany(g => g.Entries) + .Where(e => !e.IsPlaceholder) + .ToList(); + + int done = 0; + foreach (var entry in allEntries) + { + progress?.Report($"Loading {entry.Label}… ({++done}/{allEntries.Count})"); + try + { + await ReadEntryAsync(entry); + await ReadSubtableInto(entry); // cache subtable for instant display + } + catch + { + // Continue loading remaining tables even if one fails + } + } + + IsReading = false; + + // Auto-select the first table so it's visible immediately + var first = allEntries.FirstOrDefault(e => e.IsLoaded); + if (first != null) + System.Windows.Application.Current.Dispatcher.Invoke(() => SelectEntry(first)); + } + + /// + /// Reads a single entry (and its subtable) from the device into the entry's model. + /// Does NOT touch the UI grid — caller decides when to populate. + /// + private async Task ReadEntryAsync(TableEntryViewModel entry) + { + if (!entry.IsAvailable) return false; + + // Standalone Stage-1 subtable — read the 4×6 subtable directly (0x42). + if (entry.IsStandaloneSub) + { + var srr = await _ble.ReadSubTableAsync(entry.Address); + if (!srr.Success) { StatusMessage = $"Read failed: {srr.ErrorMessage}"; return false; } + entry.SubTable = SubTable.FromPayload(srr.Payload); + entry.IsLoaded = true; + return true; + } + + if (entry.EntryType == TableEntryType.TuningTable) + { + const byte p1Len = TuneBoss.Core.Models.TuningTable.SplitFirstLength; + var r1 = await _ble.ReadTable2DAsync(entry.Address, p1Len, userTable: entry.IsUserTable); + if (!r1.Success) + { + // Stage-1 ECUs don't expose the user 24×8 adjust tables: the read is + // rejected with APP_MEMADDR_LOCK (0x56). That's expected, not an error — + // present an all-zero table (with a sensible RPM/Load axis) so the grid + // shows zeros instead of leaving the previously-selected base table up. + if (entry.IsUserTable && + r1.ResponseCode == TuneBoss.Core.Protocol.Commands.APP_MEMADDR_LOCK) + { + entry.TuningTable = BuildLockedUserTable(entry); + entry.IsLocked = true; + entry.IsLoaded = true; + return true; + } + StatusMessage = $"Read failed: {r1.ErrorMessage}"; + return false; + } + + ushort part2Addr = (ushort)(entry.Address + p1Len + 1); + // The device's length byte is the LAST offset to read (inclusive), i.e. + // (bytesWanted - 1) — the same reason part 1 uses 0x7F to fetch 128 bytes. + // Part 2 wants (TotalPayloadBytes - 128) bytes, so the field is that minus 1. + int p2Bytes = TuneBoss.Core.Models.TuningTable.TotalPayloadBytes - (p1Len + 1); + byte p2Len = (byte)(p2Bytes - 1); + var r2 = await _ble.ReadTable2DAsync(part2Addr, p2Len, userTable: entry.IsUserTable); + if (!r2.Success) { StatusMessage = $"Read part 2 failed: {r2.ErrorMessage}"; return false; } + + entry.TuningTable = TuneBoss.Core.Models.TuningTable.FromSplitResponses(r1.Payload, r2.Payload); + entry.IsLocked = false; + entry.IsLoaded = true; + } + else if (entry.EntryType == TableEntryType.AfrTable) + { + const byte p1Len = TuneBoss.Core.Models.AfrTable.SplitFirstLength; + var r1 = await _ble.ReadTable2DAsync(entry.Address, p1Len); + if (!r1.Success) { StatusMessage = $"Read failed: {r1.ErrorMessage}"; return false; } + + ushort part2Addr = (ushort)(entry.Address + p1Len + 1); + // Length field is the last offset to read (inclusive) = bytesWanted - 1, + // same convention as the 2D read (part 1's 0x7F fetches 128 bytes). + int p2Bytes = TuneBoss.Core.Models.AfrTable.TotalPayloadBytes - (p1Len + 1); + byte p2Len = (byte)(p2Bytes - 1); + var r2 = await _ble.ReadTable2DAsync(part2Addr, p2Len); + if (!r2.Success) { StatusMessage = $"Read part 2 failed: {r2.ErrorMessage}"; return false; } + + entry.AfrTable = TuneBoss.Core.Models.AfrTable.FromSplitResponses(r1.Payload, r2.Payload); + entry.IsLoaded = true; + } + + // Subtable is read/written via its own dedicated buttons (see Sub* commands), + // not as part of the main table read. + return true; + } + + /// Reads the entry's subtable into its model. Used by init and the Sub Read button. + private async Task ReadSubtableInto(TableEntryViewModel entry) + { + if (!entry.HasSubTable || entry.SubTableEntry == null || !entry.SubTableEntry.IsAvailable) + return false; + + var sub = entry.SubTableEntry; + var sr = await _ble.ReadSubTableAsync(sub.Address); + if (!sr.Success) return false; + + sub.SubTable = SubTable.FromPayload(sr.Payload); + sub.IsLoaded = true; + return true; + } + + + // ── Write ───────────────────────────────────────────────────────────────── + + [RelayCommand] + public async Task WriteAsync() + { + if (SelectedEntry == null || !SelectedEntry.IsLoaded) return; + if (SelectedEntry.IsLocked) + { + StatusMessage = "This user table is locked on a Stage 1 ECU and can't be written."; + return; + } + IsWriting = true; + StatusMessage = "Writing…"; + + try + { + var entry = SelectedEntry; + + // Standalone Stage-1 subtable — harvest the 4×6 grid and write it (0x4A). + if (entry.IsStandaloneSub) + { + HarvestSubCellsToModel(entry); + if (entry.SubTable == null) { StatusMessage = "Nothing to write."; return; } + var sw = await _ble.WriteSubTableAsync(entry.Address, entry.SubTable.ToWirePayload()); + StatusMessage = sw.Success + ? "Subtable write OK — click Flash to make permanent" + : $"Subtable write failed: {sw.ErrorMessage}"; + return; + } + + // Harvest current cell values back into the model + HarvestCellsToModel(entry); + + if (entry.EntryType == TableEntryType.TuningTable && entry.TuningTable != null) + { + var p1 = entry.TuningTable.ToWirePayloadPart1(); + var p2 = entry.TuningTable.ToWirePayloadPart2(); + var w1 = await _ble.WriteTable2DAsync(entry.Address, p1, userTable: entry.IsUserTable); + if (!w1.Success) { StatusMessage = $"Write failed: {w1.ErrorMessage}"; return; } + ushort part2Addr = (ushort)(entry.Address + TuneBoss.Core.Models.TuningTable.SplitFirstLength + 1); + var w2 = await _ble.WriteTable2DAsync(part2Addr, p2, userTable: entry.IsUserTable); + if (!w2.Success) { StatusMessage = $"Write part 2 failed: {w2.ErrorMessage}"; return; } + } + else if (entry.EntryType == TableEntryType.AfrTable && entry.AfrTable != null) + { + var p1 = entry.AfrTable.ToWirePayloadPart1(); + var p2 = entry.AfrTable.ToWirePayloadPart2(); + var w1 = await _ble.WriteTable2DAsync(entry.Address, p1); + if (!w1.Success) { StatusMessage = $"Write failed: {w1.ErrorMessage}"; return; } + ushort part2Addr = (ushort)(entry.Address + TuneBoss.Core.Models.AfrTable.SplitFirstLength + 1); + var w2 = await _ble.WriteTable2DAsync(part2Addr, p2); + if (!w2.Success) { StatusMessage = $"Write part 2 failed: {w2.ErrorMessage}"; return; } + } + + StatusMessage = "Write OK — click Flash to make permanent"; + } + catch (Exception ex) + { + StatusMessage = $"Error: {ex.Message}"; + } + finally + { + IsWriting = false; + await ResumeDiagnosticsIfLiveAsync(); + } + } + + // ── Subtable read / write (independent of the main table) ────────────────── + + [RelayCommand] + private async Task SubReadAsync() + { + var entry = SelectedEntry; + if (entry == null) return; + + // Standalone Stage-1 subtable: the entry IS the subtable (no SubTableEntry). + if (entry.IsStandaloneSub) + { + IsReading = true; + StatusMessage = "Reading subtable…"; + try + { + var sr = await _ble.ReadSubTableAsync(entry.Address); + if (sr.Success) + { + entry.SubTable = SubTable.FromPayload(sr.Payload); + entry.IsLoaded = true; + PopulateSubGrid(entry.SubTable); + StatusMessage = "Subtable read OK"; + } + else StatusMessage = $"Subtable read failed: {sr.ErrorMessage}"; + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsReading = false; } + return; + } + + if (entry.SubTableEntry == null) return; + + IsReading = true; + StatusMessage = "Reading subtable…"; + try + { + if (await ReadSubtableInto(entry) && entry.SubTableEntry.SubTable != null) + { + PopulateSubGrid(entry.SubTableEntry.SubTable); + StatusMessage = "Subtable read OK"; + } + else + { + StatusMessage = "Subtable read failed"; + } + } + catch (Exception ex) + { + StatusMessage = $"Error: {ex.Message}"; + } + finally + { + IsReading = false; + } + } + + [RelayCommand] + private async Task SubWriteAsync() + { + var entry = SelectedEntry; + if (entry == null) return; + + // Standalone Stage-1 subtable: harvest and write the entry's own 4×6 (0x4A). + if (entry.IsStandaloneSub) + { + if (entry.SubTable == null) { StatusMessage = "Read the subtable first."; return; } + IsWriting = true; + StatusMessage = "Writing subtable…"; + try + { + HarvestSubCellsToModel(entry); + var sw = await _ble.WriteSubTableAsync(entry.Address, entry.SubTable.ToWirePayload()); + StatusMessage = sw.Success + ? "Subtable write OK — click Flash to make permanent" + : $"Subtable write failed: {sw.ErrorMessage}"; + } + catch (Exception ex) { StatusMessage = $"Error: {ex.Message}"; } + finally { IsWriting = false; await ResumeDiagnosticsIfLiveAsync(); } + return; + } + + if (entry.SubTableEntry?.SubTable == null) return; + + IsWriting = true; + StatusMessage = "Writing subtable…"; + try + { + HarvestSubCellsToModel(entry.SubTableEntry); + var sw = await _ble.WriteSubTableAsync( + entry.SubTableEntry.Address, + entry.SubTableEntry.SubTable.ToWirePayload()); // data-only (24 bytes) + + StatusMessage = sw.Success + ? "Subtable write OK — click Flash to make permanent" + : $"Subtable write failed: {sw.ErrorMessage}"; + } + catch (Exception ex) + { + StatusMessage = $"Error: {ex.Message}"; + } + finally + { + IsWriting = false; + await ResumeDiagnosticsIfLiveAsync(); + } + } + + // ── Flash (persist all writes to ECU flash) ──────────────────────────────── + + [RelayCommand] + private async Task FlashAsync() + { + IsWriting = true; + StatusMessage = "Flashing to ECU…"; + try + { + var fr = await _ble.FlashWriteAsync(); + if (fr.Success) FlashSuccessCount++; + StatusMessage = fr.Success + ? "Flash OK — settings saved to ECU" + : $"Flash failed: {fr.ErrorMessage}"; + } + catch (Exception ex) + { + StatusMessage = $"Error: {ex.Message}"; + } + finally + { + IsWriting = false; + await ResumeDiagnosticsIfLiveAsync(); + } + } + + [RelayCommand] public void AdjustPlus5() => AdjustSelected(+5); + [RelayCommand] public void AdjustPlus1() => AdjustSelected(+1); + [RelayCommand] public void AdjustMinus1() => AdjustSelected(-1); + [RelayCommand] public void AdjustMinus5() => AdjustSelected(-5); + + [RelayCommand] public void SubAdjustPlus5() => AdjustSubSelected(+5); + [RelayCommand] public void SubAdjustPlus1() => AdjustSubSelected(+1); + [RelayCommand] public void SubAdjustMinus1() => AdjustSubSelected(-1); + [RelayCommand] public void SubAdjustMinus5() => AdjustSubSelected(-5); + + // ── Multi-cell selection ────────────────────────────────────────────────── + + /// Rectangular clipboard buffer from the last Copy (row-major from top-left). + private double[,]? _clipboard; + + /// All currently selected main-grid cells. + private IEnumerable SelectedCells => Cells.Where(c => c.IsSelected); + + /// Begins a new selection at (the drag anchor). + public void BeginSelection(TuningTableCellViewModel cell) + { + CommitEdit(); // commit any open edit before changing selection + foreach (var c in Cells) c.IsSelected = false; + SelectedCell = cell; // anchor + cell.IsSelected = true; + UpdateSelectionBorders(); + } + + /// Extends the selection rectangle from the anchor to . + public void ExtendSelection(TuningTableCellViewModel target) + { + if (SelectedCell == null) { BeginSelection(target); return; } + + int r0 = Math.Min(SelectedCell.Row, target.Row); + int r1 = Math.Max(SelectedCell.Row, target.Row); + int c0 = Math.Min(SelectedCell.Col, target.Col); + int c1 = Math.Max(SelectedCell.Col, target.Col); + + foreach (var c in Cells) + c.IsSelected = c.Row >= r0 && c.Row <= r1 && c.Col >= c0 && c.Col <= c1; + UpdateSelectionBorders(); + } + + private void ClearCellSelection() + { + CancelEdit(); + foreach (var c in Cells) c.IsSelected = false; + SelectedCell = null; + UpdateSelectionBorders(); + } + + /// Draws a thick border only on the outer edges of the selected region. + private void UpdateSelectionBorders() + { + const double bw = 2.5; + var sel = new HashSet<(int, int)>(SelectedCells.Select(c => (c.Row, c.Col))); + foreach (var c in Cells) + { + if (!c.IsSelected) { c.SelectionBorder = new Thickness(0); continue; } + double l = sel.Contains((c.Row, c.Col - 1)) ? 0 : bw; + double t = sel.Contains((c.Row - 1, c.Col)) ? 0 : bw; + double r = sel.Contains((c.Row, c.Col + 1)) ? 0 : bw; + double b = sel.Contains((c.Row + 1, c.Col)) ? 0 : bw; + c.SelectionBorder = new Thickness(l, t, r, b); + } + } + + /// Targets for a bulk op: every selected cell, or the anchor as a fallback. + private List BulkTargets() + { + var t = SelectedCells.ToList(); + if (t.Count == 0 && SelectedCell != null) t.Add(SelectedCell); + return t; + } + + // ── Value application (shared by buttons, type-to-edit, and the Set box) ──── + + private double ClampForEntry(double val) + { + if (SelectedEntry == null) return val; + if (SelectedEntry.EntryType == TableEntryType.AfrTable) + return Math.Round(Math.Clamp(val, + SelectedEntry.AfrTable?.MinAfrDisplay ?? 0, + SelectedEntry.AfrTable?.MaxAfrDisplay ?? 15), 1); + if (SelectedEntry.TuningTable is { } tt) + { + int lo = tt.MinDataVal, hi = tt.MaxDataVal; + // A table with no meaningful bounds (e.g. loaded from an older .fsr that didn't + // carry the max/min bytes) reports lo == hi; clamping to that would pin every + // edit to a single value. Fall back to the full storable byte range instead. + if (hi <= lo) { lo = tt.IsSigned ? -128 : 0; hi = tt.IsSigned ? 127 : 255; } + return Math.Round(Math.Clamp(val, lo, hi)); + } + return val; + } + + private void SetCellValue(TuningTableCellViewModel cell, double rawVal) + { + if (SelectedEntry == null) return; + double v = ClampForEntry(rawVal); + cell.RawValue = v; + cell.DisplayValue = FormatValue(v, SelectedEntry.EntryType); + RecomputeHeatRangeAndRecolorAll(); + TouchAutoWrite(subTable: false); + SurfaceChanged?.Invoke(); + } + + private void AdjustSelected(double delta) + { + if (SelectedEntry == null) return; + foreach (var cell in BulkTargets()) + SetCellValue(cell, cell.RawValue + delta); + } + + /// Writes the same value into every selected cell. + public void ApplyValueToSelection(double val) + { + if (SelectedEntry == null) return; + foreach (var cell in BulkTargets()) + SetCellValue(cell, val); + } + + // ── Copy / paste (Excel-style) ───────────────────────────────────────────── + + /// Copies the selected rectangle into the clipboard buffer. + [RelayCommand] + private void CopySelection() + { + var cells = SelectedCells.ToList(); + if (cells.Count == 0) return; + + int minR = cells.Min(c => c.Row), maxR = cells.Max(c => c.Row); + int minC = cells.Min(c => c.Col), maxC = cells.Max(c => c.Col); + + var buf = new double[maxR - minR + 1, maxC - minC + 1]; + foreach (var c in cells) + buf[c.Row - minR, c.Col - minC] = c.RawValue; + + _clipboard = buf; + StatusMessage = $"Copied {buf.GetLength(0)}×{buf.GetLength(1)} region"; + } + + /// + /// Pastes the clipboard starting at the anchor cell, clamped to the last + /// row/column (pastes as much as fits). + /// + [RelayCommand] + private void PasteToSelection() + { + if (_clipboard == null || SelectedEntry == null || SelectedCell == null) return; + + int rows = _clipboard.GetLength(0); + int cols = _clipboard.GetLength(1); + int baseR = SelectedCell.Row; + int baseC = SelectedCell.Col; + + var pasted = new List(); + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + { + int rr = baseR + r, cc = baseC + c; + if (rr >= Rows_ || cc >= Cols) continue; // clamp to last row/col + var cell = Cells[rr * Cols + cc]; + SetCellValue(cell, _clipboard[r, c]); + pasted.Add(cell); + } + + // Reselect the pasted region (anchor stays top-left) + foreach (var c in Cells) c.IsSelected = false; + foreach (var c in pasted) c.IsSelected = true; + UpdateSelectionBorders(); + StatusMessage = $"Pasted {pasted.Count} cells"; + } + + // ── In-cell editing (type-to-edit / double-click) ────────────────────────── + + /// Opens the editor on the anchor cell, optionally seeded with a typed char. + public void BeginEdit(string? seed = null) + { + if (SelectedCell == null || SelectedEntry == null) return; + CancelEdit(); + EditingCell = SelectedCell; + SelectedCell.EditText = seed ?? SelectedCell.DisplayValue; + SelectedCell.IsEditing = true; + } + + /// Commits the editor value to the whole selection. + public void CommitEdit() + { + var cell = EditingCell; + if (cell == null) return; + cell.IsEditing = false; + EditingCell = null; + if (double.TryParse(cell.EditText, out double val)) + ApplyValueToSelection(val); + } + + public void CancelEdit() + { + if (EditingCell == null) return; + EditingCell.IsEditing = false; + EditingCell = null; + } + + // ── Axis breakpoint editing (RPM / Load headers) ─────────────────────────── + + public void BeginHeaderEdit(AxisHeaderViewModel h) + { + CommitEdit(); // close any open cell edit + CancelAllHeaderEdits(); // close any other header edit + h.EditText = h.DisplayValue; + h.IsEditing = true; + EditingHeader = h; + } + + public void CommitHeaderEdit(AxisHeaderViewModel h) + { + if (!h.IsEditing) return; + h.IsEditing = false; + if (ReferenceEquals(EditingHeader, h)) EditingHeader = null; + if (SelectedEntry == null) return; + + if (!double.TryParse(h.EditText, out double entered)) + return; // unparseable → revert silently + + if (h.Kind == AxisKind.Rpm) ApplyRpmEdit(h, entered); + else ApplyLoadEdit(h, entered); + } + + public void CancelHeaderEdit(AxisHeaderViewModel h) + { + h.IsEditing = false; + if (ReferenceEquals(EditingHeader, h)) EditingHeader = null; + } + + private void CancelAllHeaderEdits() + { + foreach (var x in RpmHeaders) x.IsEditing = false; + foreach (var x in LoadHeaders) x.IsEditing = false; + EditingHeader = null; + } + + private void ApplyRpmEdit(AxisHeaderViewModel h, double entered) + { + // RPM is stored as byte × 100 → snap to nearest 100, clamp to byte range. + int raw = Math.Clamp((int)Math.Round(entered / 100.0), 0, 255); + int snapped = raw * 100; + + var vals = RpmHeaders.Select(x => x.Value).ToList(); + if (!IsInSequence(vals, h.Index, snapped)) + { + StatusMessage = SequenceMessage(vals, h.Index, "RPM"); + return; // out of sequence → reject, display reverts + } + + SetAxisByte(AxisKind.Rpm, h.Index, (byte)raw); + h.Value = snapped; + h.DisplayValue = snapped.ToString(); + StatusMessage = $"RPM[{h.Index}] = {snapped}"; + } + + private void ApplyLoadEdit(AxisHeaderViewModel h, double entered) + { + // Load is the raw byte (0–110). + int raw = Math.Clamp((int)Math.Round(entered), 0, 110); + + var vals = LoadHeaders.Select(x => x.Value).ToList(); + if (!IsInSequence(vals, h.Index, raw)) + { + StatusMessage = SequenceMessage(vals, h.Index, "Load"); + return; + } + + SetAxisByte(AxisKind.Load, h.Index, (byte)raw); + h.Value = raw; + h.DisplayValue = raw.ToString(); + StatusMessage = $"Load[{h.Index}] = {raw}"; + } + + /// Strict monotonic check against immediate neighbours (direction auto-detected). + private static bool IsInSequence(IReadOnlyList vals, int index, int newVal) + { + bool ascending = vals.Count < 2 || vals[^1] >= vals[0]; + int? lo = index > 0 ? vals[index - 1] : (int?)null; + int? hi = index < vals.Count - 1 ? vals[index + 1] : (int?)null; + + return ascending + ? (lo is null || newVal > lo) && (hi is null || newVal < hi) + : (lo is null || newVal < lo) && (hi is null || newVal > hi); + } + + private static string SequenceMessage(IReadOnlyList vals, int index, string label) + { + bool ascending = vals.Count < 2 || vals[^1] >= vals[0]; + int? lo = index > 0 ? vals[index - 1] : (int?)null; + int? hi = index < vals.Count - 1 ? vals[index + 1] : (int?)null; + int? lower = ascending ? lo : hi; + int? upper = ascending ? hi : lo; + + if (lower is not null && upper is not null) return $"{label} must be between {lower} and {upper}"; + if (lower is not null) return $"{label} must be greater than {lower}"; + if (upper is not null) return $"{label} must be less than {upper}"; + return $"{label} out of sequence"; + } + + /// Writes one axis byte back into the selected entry's model. + private void SetAxisByte(AxisKind kind, int index, byte raw) + { + if (SelectedEntry == null) return; + + if (SelectedEntry.EntryType == TableEntryType.AfrTable && SelectedEntry.AfrTable != null) + { + if (kind == AxisKind.Rpm) + { + var axis = (byte[])SelectedEntry.AfrTable.RpmAxis.Clone(); + axis[index] = raw; + SelectedEntry.AfrTable = SelectedEntry.AfrTable with { RpmAxis = axis }; + } + else + { + var axis = (byte[])SelectedEntry.AfrTable.LoadAxis.Clone(); + axis[index] = raw; + SelectedEntry.AfrTable = SelectedEntry.AfrTable with { LoadAxis = axis }; + } + } + else if (SelectedEntry.TuningTable != null) + { + if (kind == AxisKind.Rpm) + { + var axis = (byte[])SelectedEntry.TuningTable.RpmAxis.Clone(); + axis[index] = raw; + SelectedEntry.TuningTable = SelectedEntry.TuningTable with { RpmAxis = axis }; + } + else + { + var axis = (byte[])SelectedEntry.TuningTable.LoadAxis.Clone(); + axis[index] = raw; + SelectedEntry.TuningTable = SelectedEntry.TuningTable with { LoadAxis = axis }; + } + } + } + + // ── "Set value" box ──────────────────────────────────────────────────────── + + [RelayCommand] + private void ApplySetValue() + { + if (double.TryParse(SetValueText, out double val)) + ApplyValueToSelection(val); + } + + // ── Zoom ─────────────────────────────────────────────────────────────────── + + private const double MinZoom = 0.6; + private const double ZoomStep = 0.1; + private double _maxZoom = 3.0; + + /// Upper zoom bound, set by the view from the container's fit-to-height. + public double MaxZoom + { + get => _maxZoom; + set + { + _maxZoom = value < 1.0 ? 1.0 : value; + if (ZoomFactor > _maxZoom) ZoomFactor = _maxZoom; + } + } + + [RelayCommand] + private void ZoomIn() => ZoomFactor = Math.Min(MaxZoom, Math.Round(ZoomFactor + ZoomStep, 2)); + + [RelayCommand] + private void ZoomOut() => ZoomFactor = Math.Max(MinZoom, Math.Round(ZoomFactor - ZoomStep, 2)); + + private void AdjustSubSelected(double delta) + { + if (SelectedSubCell == null) return; + double newVal = Math.Clamp(SelectedSubCell.RawValue + delta, -128, 127); + SelectedSubCell.RawValue = newVal; + SelectedSubCell.DisplayValue = ((int)newVal).ToString(); + TouchAutoWrite(subTable: true); + } + + // ── Grid population ─────────────────────────────────────────────────────── + + private void PopulateGridFromEntry(TableEntryViewModel entry) + { + RpmHeaders.Clear(); + LoadHeaders.Clear(); + Rows.Clear(); + SubRows.Clear(); + + // Standalone Stage-1 subtable: render its own 4×6 grid only, no main table. + if (entry.IsStandaloneSub) + { + if (entry.SubTable != null) PopulateSubGrid(entry.SubTable); + return; + } + + if (entry.EntryType == TableEntryType.TuningTable && entry.TuningTable != null) + { + var t = entry.TuningTable; + BuildAxisHeaders(t.RpmValues, t.LoadValues); + + for (int r = 0; r < Rows_; r++) + for (int c = 0; c < Cols; c++) + { + var cell = Cells[r * Cols + c]; + cell.RawValue = t.GetCell(r, c); + cell.DisplayValue = cell.RawValue.ToString(); + RefreshCellColor(cell, entry); + } + + for (int r = 0; r < Rows_; r++) + { + var rowCells = Enumerable.Range(0, Cols) + .Select(c => Cells[r * Cols + c]) + .ToArray(); + Rows.Add(new TableRowViewModel + { + LoadHeader = LoadHeaders[r], + Cells = rowCells, + }); + } + } + else if (entry.EntryType == TableEntryType.AfrTable && entry.AfrTable != null) + { + var t = entry.AfrTable; + BuildAxisHeaders(t.RpmValues, t.LoadValues); + + for (int r = 0; r < Rows_; r++) + for (int c = 0; c < Cols; c++) + { + var cell = Cells[r * Cols + c]; + cell.RawValue = t.GetCell(r, c); + cell.DisplayValue = cell.RawValue.ToString("F1"); + RefreshCellColor(cell, entry); + } + + for (int r = 0; r < Rows_; r++) + { + var rowCells = Enumerable.Range(0, Cols) + .Select(c => Cells[r * Cols + c]) + .ToArray(); + Rows.Add(new TableRowViewModel + { + LoadHeader = LoadHeaders[r], + Cells = rowCells, + }); + } + } + + // Subtable + if (entry.HasSubTable && entry.SubTableEntry?.SubTable != null) + PopulateSubGrid(entry.SubTableEntry.SubTable); + + ApplyTracker(); + } + + /// Builds editable RPM (top) and Load (side) breakpoint headers. + private void BuildAxisHeaders(int[] rpmValues, int[] loadValues) + { + for (int i = 0; i < rpmValues.Length; i++) + RpmHeaders.Add(new AxisHeaderViewModel + { + Index = i, Kind = AxisKind.Rpm, + Value = rpmValues[i], DisplayValue = rpmValues[i].ToString(), + }); + + for (int i = 0; i < loadValues.Length; i++) + LoadHeaders.Add(new AxisHeaderViewModel + { + Index = i, Kind = AxisKind.Load, + Value = loadValues[i], DisplayValue = loadValues[i].ToString(), + }); + } + + private void PopulateSubGrid(SubTable sub) + { + SubRpmHeaders.Clear(); + SubLoadHeaders.Clear(); + SubRows.Clear(); + + // RPM range labels come from the parent full table's RPM axis (display-only, + // never written to the ECU): column c spans parentRpm[4c] (lo) … parentRpm[4c+3] (hi). + var parentRpm = SelectedEntry?.TuningTable?.RpmValues; + for (int c = 0; c < SubCols; c++) + { + int lo, hi; + if (parentRpm != null && parentRpm.Length >= Cols) + { + lo = parentRpm[c * 4]; + hi = parentRpm[c * 4 + 3]; + } + else // fallback to the subtable's own axis if the parent isn't loaded + { + lo = sub.GetRpmLo(c); + hi = sub.GetRpmHi(c); + } + SubRpmHeaders.Add($"{lo}\n{hi}"); + } + + // Load labels are fixed defaults (5, 15, 40, 70) — display-only. + for (int r = 0; r < SubRows_; r++) + SubLoadHeaders.Add(SubTable.DefaultLoadAxis[r].ToString()); + + for (int r = 0; r < SubRows_; r++) + for (int c = 0; c < SubCols; c++) + { + var cell = SubCells[r * SubCols + c]; + cell.RawValue = sub.GetCell(r, c); + cell.DisplayValue = ((int)cell.RawValue).ToString(); + cell.Background = new System.Windows.Media.SolidColorBrush( + System.Windows.Media.Color.FromRgb(0x22, 0x26, 0x2B)); + cell.Foreground = System.Windows.Media.Brushes.White; + } + + for (int r = 0; r < SubRows_; r++) + { + var rowCells = Enumerable.Range(0, SubCols) + .Select(c => SubCells[r * SubCols + c]) + .ToArray(); + SubRows.Add(new SubTableRowViewModel + { + LoadHeader = SubTable.DefaultLoadAxis[r].ToString(), + Cells = rowCells, + }); + } + } + + // Heat range follows the CURRENT table's actual values (matching the 3D + // surface), not the theoretical possible extremes — so the full colour ramp + // is always spent on the spread that's on screen. + private double _heatMin = 0, _heatMax = 255; + + private void RecomputeHeatRangeAndRecolorAll() + { + if (Cells.Count == 0 || SelectedEntry == null) return; + + double min = double.MaxValue, max = double.MinValue; + foreach (var c in Cells) + { + if (c.RawValue < min) min = c.RawValue; + if (c.RawValue > max) max = c.RawValue; + } + if (max <= min) max = min + 1; // flat table — avoid div-by-zero, mid colour + + _heatMin = min; + _heatMax = max; + foreach (var c in Cells) RefreshCellColor(c, SelectedEntry); + } + + private void RefreshCellColor(TuningTableCellViewModel cell, TableEntryViewModel entry) + { + if (_settings.Settings.FlatMapNoContour) + { + cell.Background = HeatmapHelper.FlatBackground; + cell.Foreground = System.Windows.Media.Brushes.Black; + return; + } + var (bg, fg) = HeatmapHelper.GetCellColors(cell.RawValue, _heatMin, _heatMax); + cell.Background = bg; + cell.Foreground = fg; + } + + private static string FormatValue(double val, TableEntryType type) + => type == TableEntryType.AfrTable ? val.ToString("F1") : ((int)val).ToString(); + + // ── Harvest cells back to model ─────────────────────────────────────────── + + private void HarvestCellsToModel(TableEntryViewModel entry) + { + if (entry.EntryType == TableEntryType.TuningTable && entry.TuningTable != null) + { + var data = new byte[TuningTable.DataBytes]; + bool signed = entry.TuningTable.IsSigned; + for (int i = 0; i < Cells.Count; i++) + { + int v = (int)Cells[i].RawValue; + data[i] = signed ? unchecked((byte)(sbyte)v) : (byte)v; + } + entry.TuningTable = entry.TuningTable with { Data = data }; + } + else if (entry.EntryType == TableEntryType.AfrTable && entry.AfrTable != null) + { + var data = new byte[AfrTable.DataBytes]; + for (int i = 0; i < Cells.Count; i++) + data[i] = (byte)(Cells[i].RawValue * 10.0); + entry.AfrTable = entry.AfrTable with { Data = data }; + } + } + + private void HarvestSubCellsToModel(TableEntryViewModel subEntry) + { + if (subEntry.SubTable == null) return; + var data = new byte[SubTable.DataBytes]; + for (int i = 0; i < SubCells.Count; i++) + data[i] = unchecked((byte)(sbyte)(int)SubCells[i].RawValue); + subEntry.SubTable = subEntry.SubTable with { Data = data }; + } + + // ── Live tracker ────────────────────────────────────────────────────────── + + private void OnDiagFrame(DiagnosticsFrame frame) + { + if (SelectedEntry == null || !SelectedEntry.IsLoaded) return; + + byte[] rpmAxis = SelectedEntry.TuningTable?.RpmAxis + ?? SelectedEntry.AfrTable?.RpmAxis + ?? Array.Empty(); + byte[] loadAxis = SelectedEntry.TuningTable?.LoadAxis + ?? SelectedEntry.AfrTable?.LoadAxis + ?? Array.Empty(); + + if (rpmAxis.Length == 0) return; + + // TPS-keyed for user-adjust tables, load-keyed for base tables + bool useTps = SelectedEntry.Label.StartsWith("User"); + var tracker = TableTracker.Calculate(rpmAxis, loadAxis, + frame.RPM_Raw, + useTps ? frame.TPS_Percent : frame.Load); + + _trackerCol = tracker.ColHighlight; + _trackerAdjCol = tracker.ColLowlight; + _trackerRow = tracker.RowHighlight; + _trackerAdjRow = tracker.RowLowlight; + + Application.Current.Dispatcher.Invoke(ApplyTracker); + } + + // ── Tracker history ──────────────────────────────────────────────────────── + // Records the path of the live tracker: every cell the exact-match tracker + // enters while recording gets a sticky white inner frame (IsVisited), so the + // tuner can see which cells have been covered. Markers reset when the selected + // table changes (axes differ per table). + + [ObservableProperty] private bool _isRecordingHistory; + + [RelayCommand] + private void StartTrackerHistory() + { + IsRecordingHistory = true; + StatusMessage = "Tracker history: recording"; + } + + [RelayCommand] + private void StopTrackerHistory() + { + IsRecordingHistory = false; + StatusMessage = "Tracker history: stopped"; + } + + [RelayCommand] + private void ClearTrackerHistory() + { + foreach (var c in Cells) c.IsVisited = false; + StatusMessage = "Tracker history: cleared"; + } + + private void ClearVisited() + { + foreach (var c in Cells) c.IsVisited = false; + } + + private void ApplyTracker() + { + // Settings → tracker cell auto-select: the exact-match tracker cell becomes + // the active selection whenever it moves. Manual selection still works + // between moves; typing in a cell is never interrupted (guarded on edit). + if (_settings.Settings.TrackerAutoSelect && + _trackerRow >= 0 && _trackerCol >= 0 && + (_trackerRow != _autoSelRow || _trackerCol != _autoSelCol) && + EditingCell == null && + SelectedEntry is { IsLoaded: true }) + { + var target = Cells.FirstOrDefault(c => c.Row == _trackerRow && c.Col == _trackerCol); + if (target != null) + { + BeginSelection(target); + _autoSelRow = _trackerRow; + _autoSelCol = _trackerCol; + } + } + + TrackerMoved?.Invoke(_trackerRow, _trackerCol); + + foreach (var cell in Cells) + { + bool isHigh = cell.Col == _trackerCol && cell.Row == _trackerRow; + bool isAdj = (cell.Col == _trackerAdjCol && cell.Row == _trackerRow) || + (cell.Col == _trackerCol && cell.Row == _trackerAdjRow)|| + (cell.Col == _trackerAdjCol && cell.Row == _trackerAdjRow); + + cell.IsTrackerHighlight = isHigh; + cell.IsTrackerAdjacent = isAdj; + + // Paint the tracker/heatmap on EVERY cell, selected or not. The selection + // visual is a translucent overlay (see the cell template), so the tracker + // colour shows through a selection — the active point stays visible even + // when it falls inside a selected range. + bool flat = _settings.Settings.FlatMapNoContour; + if (isHigh) + { + if (IsRecordingHistory) cell.IsVisited = true; // tracker-history: sticky marker + cell.Background = flat ? HeatmapHelper.FlatTrackerHighlight + : HeatmapHelper.TrackerHighlight; + cell.Foreground = new System.Windows.Media.SolidColorBrush( + System.Windows.Media.Color.FromRgb(0x20, 0x20, 0x20)); + } + else if (isAdj) + { + cell.Background = flat ? HeatmapHelper.FlatTrackerAdjacent + : HeatmapHelper.TrackerAdjacent; + cell.Foreground = System.Windows.Media.Brushes.Black; + } + else if (SelectedEntry != null) + { + RefreshCellColor(cell, SelectedEntry); + } + } + } + + public void Dispose() => _diagSub?.Dispose(); +} + + diff --git a/TuneBossPC/ViewModels/TpsCalViewModel.cs b/TuneBossPC/ViewModels/TpsCalViewModel.cs new file mode 100644 index 0000000..c424658 --- /dev/null +++ b/TuneBossPC/ViewModels/TpsCalViewModel.cs @@ -0,0 +1,258 @@ +using System.Windows; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using TuneBoss.Core.BLE; +using TuneBoss.Core.Models; +using TuneBossPC.Services; + +namespace TuneBossPC.ViewModels; + +/// +/// Throttle-position-sensor calibration page. +/// +/// Faithful port of the legacy Android TpsCalPage flow: +/// 1. On activation, read the per-unit absolute bounds (max/min) from the ECU. +/// 2. START → stream diagnostics and track the running min/max of the raw TPS +/// ADC () while the tuner sweeps the +/// throttle fully open↔closed ~5 times. +/// 3. FINISH → validate the captured min/max against the bounds, then write the +/// 8-byte calibration block, set the first-use flag, and flash. +/// +/// Diagnostics are paused for the write/flash sequence and resumed afterward so the +/// shared diagnostics strip keeps working. +/// +public partial class TpsCalViewModel : ObservableObject, IDisposable +{ + private readonly IBleService _ble; + private readonly ISessionService _session; + + private IDisposable? _diagSub; + private TpsCalibration.Addresses _addr; + private bool _addrResolved; + + private int _absMaxVal; + private int _absMinVal; + private int _minRaw; + private int _maxRaw; + private bool _firstSample; + + // ── Bound display ────────────────────────────────────────────────────────── + [ObservableProperty] private string _absMax = "—"; + [ObservableProperty] private string _absMin = "—"; + [ObservableProperty] private string _currMax = "—"; + [ObservableProperty] private string _currMin = "—"; + [ObservableProperty] private string _currVal = "—"; + + // ── Guide / status ───────────────────────────────────────────────────────── + [ObservableProperty] private string _heading = "TPS Calibration is Inactive"; + [ObservableProperty] private string _step1 = "1. Open throttle to maximum position"; + [ObservableProperty] private string _step2 = "2. Close throttle to minimum position"; + [ObservableProperty] private string _step3 = $"3. Repeat {TpsCalibration.RequiredSweeps} times"; + [ObservableProperty] private string _step4 = "4. Press FINISH when done"; + [ObservableProperty] private string _statusMessage = "Ready."; + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(IsIdle))] + private bool _isCalibrating; + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(IsIdle))] + private bool _isBusy; // write / flash in progress — blocks navigation away + + public bool IsIdle => !IsCalibrating && !IsBusy; + + public TpsCalViewModel(IBleService ble, ISessionService session) + { + _ble = ble; + _session = session; + } + + // ── Activation ───────────────────────────────────────────────────────────── + + /// Called when the page is shown. Reads the absolute bounds. + public async Task OnNavigatedToAsync() + { + if (!ResolveAddresses()) + { + StatusMessage = "No active session — connect a device first."; + return; + } + + try + { + var r = await _ble.ReadTable1DAsync(_addr.AbsBounds, 0x03); + if (r.Success && r.Payload.Length >= 6) + { + _absMaxVal = r.Payload[4]; // [4] = absMax, [5] = absMin (offset 4 = after 51 43 .. header) + _absMinVal = r.Payload[5]; + AbsMax = _absMaxVal.ToString(); + AbsMin = _absMinVal.ToString(); + StatusMessage = "Absolute bounds read. Press START to begin."; + } + else + { + StatusMessage = "Could not read TPS absolute bounds."; + } + } + catch (Exception ex) { StatusMessage = $"Error reading bounds: {ex.Message}"; } + } + + private bool ResolveAddresses() + { + if (_addrResolved) return true; + var info = _session.Info; + if (info == null) return false; + _addr = TpsCalibration.For(info); + _addrResolved = true; + return true; + } + + // ── START ────────────────────────────────────────────────────────────────── + + public bool CanStart => IsIdle && _session.IsActive; + + [RelayCommand(CanExecute = nameof(CanStart))] + private async Task StartAsync() + { + if (!ResolveAddresses()) { StatusMessage = "No active session."; return; } + + _minRaw = _maxRaw = 0; + _firstSample = true; + CurrMax = CurrMin = CurrVal = "—"; + + IsCalibrating = true; + Heading = "TPS Calibration — reading values…"; + StatusMessage = "Sweep the throttle fully open and closed several times, then press FINISH."; + RaiseCanExecute(); + + // Make sure frames are flowing (idempotent), then observe TPS_Raw. + await _ble.StartDiagnosticsAsync(); + _diagSub = _ble.DiagnosticsFrames.Subscribe(OnFrame); + } + + private void OnFrame(DiagnosticsFrame frame) + { + if (!IsCalibrating) return; + int raw = frame.TPS_Raw; + + Application.Current.Dispatcher.Invoke(() => + { + if (_firstSample) + { + _minRaw = _maxRaw = raw; + _firstSample = false; + } + else + { + if (raw < _minRaw) _minRaw = raw; + if (raw > _maxRaw) _maxRaw = raw; + } + + CurrMax = _maxRaw.ToString(); + CurrMin = _minRaw.ToString(); + CurrVal = raw.ToString(); + }); + } + + // ── FINISH ───────────────────────────────────────────────────────────────── + + [RelayCommand(CanExecute = nameof(IsCalibratingState))] + private async Task FinishAsync() + { + StopCapture(); + IsCalibrating = false; + Heading = "TPS Calibration is Inactive"; + + // The calibration session is over — leave diagnostics stopped. The tuner can + // restart the stream from the Diagnostics page if they want live data again. + await _ble.StopDiagnosticsAsync(); + RaiseCanExecute(); + + if (_firstSample) // no frames captured at all + { + StatusMessage = "No TPS data captured. Try again."; + return; + } + + var verdict = TpsCalibration.Validate(_minRaw, _maxRaw, _absMinVal, _absMaxVal); + StatusMessage = TpsCalibration.Describe(verdict, _minRaw, _maxRaw, _absMinVal, _absMaxVal); + if (verdict != TpsCalibration.Validation.Ok) + return; + + await WriteCalibrationAsync(); + } + + public bool IsCalibratingState => IsCalibrating; + + // ── CANCEL ───────────────────────────────────────────────────────────────── + + [RelayCommand(CanExecute = nameof(IsCalibratingState))] + private async Task Cancel() + { + StopCapture(); + IsCalibrating = false; + Heading = "TPS Calibration is Inactive"; + StatusMessage = "Calibration cancelled."; + CurrMax = CurrMin = CurrVal = "—"; + await _ble.StopDiagnosticsAsync(); + RaiseCanExecute(); + } + + private void StopCapture() + { + _diagSub?.Dispose(); + _diagSub = null; + } + + // ── Write sequence: cal block → first-use flag → flash ───────────────────── + + private async Task WriteCalibrationAsync() + { + IsBusy = true; + RaiseCanExecute(); + + // Diagnostics was already stopped when the capture phase ended; these writes + // run with the stream quiet (BleManager also keeps it stopped across writes). + try + { + // 1) Write the 8-byte calibration block. + var payload = TpsCalibration.BuildCalWritePayload(_minRaw, _maxRaw); + var w = await _ble.WriteTable1DAsync(_addr.CalWrite, payload); + if (!w.Success) { StatusMessage = $"Calibration write failed: {w.ErrorMessage}"; return; } + + // 2) Set the first-use flag (DD slot = 1, per the WinForms read of UIFirstUseInfo[0]). + var fu = await _ble.WriteFirstUseAsync(FirstUseFlagBytes()); + if (!fu.Success) { StatusMessage = $"First-use flag write failed: {fu.ErrorMessage}"; return; } + + // 3) Persist to flash. + var fr = await _ble.FlashWriteAsync(); + StatusMessage = fr.Success + ? "TPS calibration successful and saved to ECU." + : $"Flash write failed: {fr.ErrorMessage}"; + } + catch (Exception ex) { StatusMessage = $"Error during write: {ex.Message}"; } + finally + { + IsBusy = false; + RaiseCanExecute(); + } + } + + /// + /// First-use block written via APP_FIRSTUSE. The calibration-done flag lives in + /// byte[1] (the MM slot) — matching the Android app, which sets UIfirstUseDate[1]=1 + /// (fus_1) on a successful calibration and reads the same byte to decide whether to + /// warn. byte[0] (DD) is left untouched. + /// + private static byte[] FirstUseFlagBytes() => + new byte[] { 0x00, TpsCalibration.CalDoneFlag, 0x00, 0x00 }; + + private void RaiseCanExecute() + { + StartCommand.NotifyCanExecuteChanged(); + FinishCommand.NotifyCanExecuteChanged(); + CancelCommand.NotifyCanExecuteChanged(); + } + + public void Dispose() => StopCapture(); +} diff --git a/TuneBossPC/Views/ConnectView.xaml b/TuneBossPC/Views/ConnectView.xaml new file mode 100644 index 0000000..b08286f --- /dev/null +++ b/TuneBossPC/Views/ConnectView.xaml @@ -0,0 +1,177 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/TuneBossPC/Views/DiagnosticsStrip.xaml.cs b/TuneBossPC/Views/DiagnosticsStrip.xaml.cs new file mode 100644 index 0000000..2e057a4 --- /dev/null +++ b/TuneBossPC/Views/DiagnosticsStrip.xaml.cs @@ -0,0 +1,32 @@ +using System.Windows; +using System.Windows.Controls; +using TuneBossPC.ViewModels; +using TuneBossPC.Views.Dialogs; + +namespace TuneBossPC.Views; + +public partial class DiagnosticsStrip : UserControl +{ + public DiagnosticsStrip() + { + InitializeComponent(); + } + + private void ChangeChannel_Click(object sender, RoutedEventArgs e) + { + if (sender is not MenuItem mi) return; + if (mi.Tag is not GaugeSlotViewModel slot) return; + if (DataContext is not DiagnosticsStripViewModel stripVm) return; + + int slotIndex = stripVm.Slots.IndexOf(slot); + if (slotIndex < 0) return; + + var dialog = new ChannelPickerDialog(slot.Channel) + { + Owner = Window.GetWindow(this) + }; + + if (dialog.ShowDialog() == true) + stripVm.AssignSlot(slotIndex, dialog.SelectedChannel); + } +} diff --git a/TuneBossPC/Views/DiagnosticsView.xaml b/TuneBossPC/Views/DiagnosticsView.xaml new file mode 100644 index 0000000..fe2d412 --- /dev/null +++ b/TuneBossPC/Views/DiagnosticsView.xaml @@ -0,0 +1,432 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/TuneBossPC/Views/DiagnosticsView.xaml.cs b/TuneBossPC/Views/DiagnosticsView.xaml.cs new file mode 100644 index 0000000..8105aa2 --- /dev/null +++ b/TuneBossPC/Views/DiagnosticsView.xaml.cs @@ -0,0 +1,13 @@ +using System.Windows.Controls; +using TuneBossPC.ViewModels; + +namespace TuneBossPC.Views; + +public partial class DiagnosticsView : UserControl +{ + public DiagnosticsView(DiagnosticsViewModel vm) + { + DataContext = vm; + InitializeComponent(); + } +} diff --git a/TuneBossPC/Views/Dialogs/ChannelPickerDialog.xaml b/TuneBossPC/Views/Dialogs/ChannelPickerDialog.xaml new file mode 100644 index 0000000..c3caa09 --- /dev/null +++ b/TuneBossPC/Views/Dialogs/ChannelPickerDialog.xaml @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/TuneBossPC/Views/MainWindow.xaml.cs b/TuneBossPC/Views/MainWindow.xaml.cs new file mode 100644 index 0000000..9b8c871 --- /dev/null +++ b/TuneBossPC/Views/MainWindow.xaml.cs @@ -0,0 +1,47 @@ +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using TuneBossPC.ViewModels; + +namespace TuneBossPC.Views; + +public partial class MainWindow : Window +{ + private readonly MainWindowViewModel _vm; + + public MainWindow(MainWindowViewModel vm) + { + _vm = vm; + DataContext = vm; + InitializeComponent(); + + // Navigate to Connect on startup + vm.NavigateTo("Connect"); + } + + private void NavButton_Click(object sender, RoutedEventArgs e) + { + if (sender is Button btn && btn.Tag is string tag) + _vm.NavigateTo(tag); + } + + // ── Killswitch: press-and-hold ────────────────────────────────────────────── + // Capture the mouse on press so we still get the release even if the pointer + // leaves the button; release is driven by LostMouseCapture (covers mouse-up, + // dragging away, and the window losing focus). + private void Killswitch_MouseDown(object sender, MouseButtonEventArgs e) + { + if (sender is UIElement el) el.CaptureMouse(); + _vm.KillswitchPress(); + } + + private void Killswitch_MouseUp(object sender, MouseButtonEventArgs e) + { + if (sender is UIElement el) el.ReleaseMouseCapture(); // → fires LostMouseCapture + } + + private void Killswitch_LostCapture(object sender, MouseEventArgs e) + { + _vm.KillswitchRelease(); + } +} diff --git a/TuneBossPC/Views/MiscValuesView.xaml b/TuneBossPC/Views/MiscValuesView.xaml new file mode 100644 index 0000000..8d6ad0e --- /dev/null +++ b/TuneBossPC/Views/MiscValuesView.xaml @@ -0,0 +1,266 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +