Slash lightning (#2058)

* Slash Lightning * Slash lightning UI tweaks * Slash Lightning tweaks * Minor tweaks * Slash Interval settings * UI tweaks * Slash tweaks * More slash modes * Cleanup
2026-02-23 13:00:52 +01:00 · 2024-02-12 18:43:27 +01:00
parent d2cb6965e0
commit 85725fb782
10 changed files with 342 additions and 92 deletions
--- a/app/AnimeMatrix/AniMatrixControl.cs
+++ b/app/AnimeMatrix/AniMatrixControl.cs
@@ -1,6 +1,5 @@
 using NAudio.CoreAudioApi;
 using NAudio.Wave;
-using Starlight.AnimeMatrix;
 using System.Diagnostics;
 using System.Drawing.Drawing2D;
 using System.Drawing.Imaging;
@@ -15,14 +14,17 @@ namespace GHelper.AnimeMatrix
        SettingsForm settings;

        System.Timers.Timer matrixTimer = default!;
-        public AnimeMatrixDevice? device;
+
+        public AnimeMatrixDevice? deviceMatrix;
+        public SlashDevice? deviceSlash;

        double[]? AudioValues;
        WasapiCapture? AudioDevice;
        string? AudioDeviceId;
        private MMDeviceEnumerator? AudioDeviceEnum;

-        public bool IsValid => device != null;
+        public bool IsValid => deviceMatrix != null || deviceSlash != null;
+        public bool IsSlash => deviceSlash != null;

        private long lastPresent;
        private List<double> maxes = new List<double>();
@@ -33,38 +35,82 @@ namespace GHelper.AnimeMatrix

            try
            {
-                device = new AnimeMatrixDevice();
-                Task.Run(device.WakeUp);
+                if (AppConfig.IsSlash())
+                    deviceSlash = new SlashDevice();
+                else
+                    deviceMatrix = new AnimeMatrixDevice();
+
                matrixTimer = new System.Timers.Timer(100);
                matrixTimer.Elapsed += MatrixTimer_Elapsed;
            }
-            catch
+            catch (Exception ex)
            {
-                device = null;
+                Logger.WriteLine(ex.Message);
            }

        }

+        public void SetDevice(bool wakeUp = false)
+        {
+            if (deviceMatrix is not null) SetMatrix(wakeUp);
+            if (deviceSlash is not null) SetSlash(wakeUp);
+        }
+
+
+        public void SetSlash(bool wakeUp = false)
+        {
+            if (deviceSlash is null) return;
+
+            int brightness = AppConfig.Get("matrix_brightness", 0);
+            int running = AppConfig.Get("matrix_running", 0);
+            int inteval = AppConfig.Get("matrix_interval", 0);
+
+            bool auto = AppConfig.Is("matrix_auto");
+
+            Task.Run(() =>
+            {
+                try
+                {
+                    deviceSlash.SetProvider();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                    return;
+                }
+
+                if (wakeUp) deviceSlash.WakeUp();
+
+                if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online))
+                {
+                    deviceSlash.Init();
+                    deviceSlash.SetOptions(false, 0, 0);
+                }
+                else
+                {
+                    deviceSlash.Init();
+                    deviceSlash.SetMode((SlashMode)running);
+                    deviceSlash.SetOptions(true, brightness, inteval);
+                    deviceSlash.Save();
+                }
+            });
+        }
+
+        public void SetBatteryAuto()
+        {
+            if (deviceSlash is not null) deviceSlash.SetBatterySaver(AppConfig.Is("matrix_auto"));
+            if (deviceMatrix is not null) SetMatrix();
+        }
+
        public void SetMatrix(bool wakeUp = false)
        {

-            if (!IsValid) return;
-
-            int brightness = AppConfig.Get("matrix_brightness");
-            int running = AppConfig.Get("matrix_running");
+            if (deviceMatrix is null) return;

+            int brightness = AppConfig.Get("matrix_brightness", 0);
+            int running = AppConfig.Get("matrix_running", 0);
            bool auto = AppConfig.Is("matrix_auto");

-            if (brightness < 0) brightness = 0;
-            if (running < 0) running = 0;
-
-            BuiltInAnimation animation = new BuiltInAnimation(
-                (BuiltInAnimation.Running)running,
-                BuiltInAnimation.Sleeping.Starfield,
-                BuiltInAnimation.Shutdown.SeeYa,
-                BuiltInAnimation.Startup.StaticEmergence
-            );
-
            StopMatrixTimer();
            StopMatrixAudio();

@@ -72,7 +118,7 @@ namespace GHelper.AnimeMatrix
            {
                try
                {
-                    device.SetProvider();
+                    deviceMatrix.SetProvider();
                }
                catch (Exception ex)
                {
@@ -80,18 +126,18 @@ namespace GHelper.AnimeMatrix
                    return;
                }

-                if (wakeUp) device.WakeUp();
+                if (wakeUp) deviceMatrix.WakeUp();

                if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online))
                {
-                    device.SetDisplayState(false);
-                    device.SetDisplayState(false); // some devices are dumb
+                    deviceMatrix.SetDisplayState(false);
+                    deviceMatrix.SetDisplayState(false); // some devices are dumb
                    Logger.WriteLine("Matrix Off");
                }
                else
                {
-                    device.SetDisplayState(true);
-                    device.SetBrightness((BrightnessMode)brightness);
+                    deviceMatrix.SetDisplayState(true);
+                    deviceMatrix.SetBrightness((BrightnessMode)brightness);

                    switch (running)
                    {
@@ -105,8 +151,7 @@ namespace GHelper.AnimeMatrix
                            SetMatrixAudio();
                            break;
                        default:
-                            device.SetBuiltInAnimation(true, animation);
-                            Logger.WriteLine("Matrix builtin " + animation.AsByte);
+                            SetBuiltIn(running);
                            break;
                    }

@@ -115,6 +160,19 @@ namespace GHelper.AnimeMatrix


        }
+
+        private void SetBuiltIn(int running)
+        {
+            BuiltInAnimation animation = new BuiltInAnimation(
+                (BuiltInAnimation.Running)running,
+                BuiltInAnimation.Sleeping.Starfield,
+                BuiltInAnimation.Shutdown.SeeYa,
+                BuiltInAnimation.Startup.StaticEmergence
+            );
+            deviceMatrix.SetBuiltInAnimation(true, animation);
+            Logger.WriteLine("Matrix builtin: " + animation.AsByte);
+        }
+
        private void StartMatrixTimer(int interval = 100)
        {
            matrixTimer.Interval = interval;
@@ -129,15 +187,16 @@ namespace GHelper.AnimeMatrix

        private void MatrixTimer_Elapsed(object? sender, ElapsedEventArgs e)
        {
-            //if (!IsValid) return;
+
+            if (deviceMatrix is null) return;

            switch (AppConfig.Get("matrix_running"))
            {
                case 2:
-                    device.PresentNextFrame();
+                    deviceMatrix.PresentNextFrame();
                    break;
                case 3:
-                    device.PresentClock();
+                    deviceMatrix.PresentClock();
                    break;
            }

@@ -146,7 +205,7 @@ namespace GHelper.AnimeMatrix

        public void SetMatrixClock()
        {
-            device.SetBuiltInAnimation(false);
+            deviceMatrix.SetBuiltInAnimation(false);
            StartMatrixTimer(1000);
            Logger.WriteLine("Matrix Clock");
        }
@@ -177,9 +236,9 @@ namespace GHelper.AnimeMatrix

        void SetMatrixAudio()
        {
-            if (!IsValid) return;
+            if (deviceMatrix is null) return;

-            device.SetBuiltInAnimation(false);
+            deviceMatrix.SetBuiltInAnimation(false);
            StopMatrixTimer();
            StopMatrixAudio();

@@ -251,18 +310,20 @@ namespace GHelper.AnimeMatrix
                for (int x = 0; x < 2 - (y % 2); x++)
                {
                    //color = (byte)(Math.Min(1,(h - y - 2)*2) * 255);
-                    device.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
-                    device.SetLedPlanar(x + dx, dy - y, 255);
+                    deviceMatrix.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
+                    deviceMatrix.SetLedPlanar(x + dx, dy - y, 255);
                }
        }

        void PresentAudio(double[] audio)
        {

+            if (deviceMatrix is null) return;
+
            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastPresent) < 70) return;
            lastPresent = DateTimeOffset.Now.ToUnixTimeMilliseconds();

-            device.Clear();
+            deviceMatrix.Clear();

            int size = 20;
            double[] bars = new double[size];
@@ -280,7 +341,7 @@ namespace GHelper.AnimeMatrix

            for (int i = 0; i < size; i++) DrawBar(20 - i, bars[i] * 20 / maxAverage);

-            device.Present();
+            deviceMatrix.Present();
        }


@@ -309,7 +370,7 @@ namespace GHelper.AnimeMatrix
                AppConfig.Set("matrix_running", 2);

                SetMatrixPicture(fileName);
-                settings.SetMatrixRunning(2);
+                settings.VisualiseMatrixRunning(2);

            }

@@ -318,7 +379,8 @@ namespace GHelper.AnimeMatrix
        public void SetMatrixPicture(string fileName, bool visualise = true)
        {

-            if (!IsValid) return;
+            if (deviceMatrix is null) return;
+
            StopMatrixTimer();

            try
@@ -338,7 +400,7 @@ namespace GHelper.AnimeMatrix
                    }

                    fs.Close();
-                    if (visualise) settings.VisualiseMatrix(fileName);
+                    if (visualise) settings.VisualiseMatrixPicture(fileName);
                }
            }
            catch
@@ -351,8 +413,8 @@ namespace GHelper.AnimeMatrix

        protected void ProcessPicture(Image image)
        {
-            device.SetBuiltInAnimation(false);
-            device.ClearFrames();
+            deviceMatrix.SetBuiltInAnimation(false);
+            deviceMatrix.ClearFrames();

            int matrixX = AppConfig.Get("matrix_x", 0);
            int matrixY = AppConfig.Get("matrix_y", 0);
@@ -380,11 +442,11 @@ namespace GHelper.AnimeMatrix
                    image.SelectActiveFrame(dimension, i);

                    if (rotation == MatrixRotation.Planar)
-                        device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+                        deviceMatrix.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
                    else
-                        device.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+                        deviceMatrix.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);

-                    device.AddFrame();
+                    deviceMatrix.AddFrame();
                }


@@ -397,11 +459,11 @@ namespace GHelper.AnimeMatrix
            else
            {
                if (rotation == MatrixRotation.Planar)
-                    device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+                    deviceMatrix.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
                else
-                    device.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+                    deviceMatrix.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);

-                device.Present();
+                deviceMatrix.Present();
            }

        }
--- a/app/AnimeMatrix/AnimeMatrixDevice.cs
+++ b/app/AnimeMatrix/AnimeMatrixDevice.cs
@@ -5,7 +5,7 @@ using System.Drawing.Drawing2D;
 using System.Drawing.Text;
 using System.Text;

-namespace Starlight.AnimeMatrix
+namespace GHelper.AnimeMatrix
 {
    public class BuiltInAnimation
    {
@@ -91,7 +91,6 @@ namespace Starlight.AnimeMatrix
        public int MaxRows = 61;
        public int MaxColumns = 34;
        public int LedStart = 0;
-
        public int FullRows = 11;

        private int frameIndex = 0;
--- a/app/AnimeMatrix/Communication/Platform/WindowsUsbProvider.cs
+++ b/app/AnimeMatrix/Communication/Platform/WindowsUsbProvider.cs
@@ -36,14 +36,12 @@ namespace GHelper.AnimeMatrix.Communication.Platform
            {
                HidDevice = DeviceList.Local
                    .GetHidDevices(vendorId, productId)
-                    .First(x => x.GetMaxFeatureReportLength() == maxFeatureReportLength);
-
-                Logger.WriteLine("Matrix Device: " + HidDevice.DevicePath);
-
+                    .First(x => x.GetMaxFeatureReportLength() >= maxFeatureReportLength);
+                Logger.WriteLine("Matrix Device: " + HidDevice.DevicePath + " " + HidDevice.GetMaxFeatureReportLength());
            }
            catch
            {
-                throw new IOException("AniMe Matrix control device was not found on your machine.");
+                throw new IOException("Matrix control device was not found on your machine.");
            }

            var config = new OpenConfiguration();
--- a/app/AnimeMatrix/SlashDevice.cs
+++ b/app/AnimeMatrix/SlashDevice.cs
@@ -0,0 +1,138 @@
+using GHelper.AnimeMatrix.Communication;
+using System.Text;
+
+namespace GHelper.AnimeMatrix
+{
+    public enum SlashMode
+    {
+        Bounce,
+        Slash,
+        Loading,
+        BitStream,
+        Transmission,
+        Flow,
+        Flux,
+        Phantom,
+        Spectrum,
+        Hazard,
+        Interfacing,
+        Ramp,
+        GameOver,
+        Start,
+        Buzzer
+    }
+
+    internal class SlashPacket : Packet
+    {
+        public SlashPacket(byte[] command) : base(0x5E, 128, command)
+        {
+        }
+    }
+
+    public class SlashDevice : Device
+    {
+
+        public static Dictionary<SlashMode, string> Modes = new Dictionary<SlashMode, string>
+        {
+            { SlashMode.Bounce, "Bounce"},
+            { SlashMode.Slash, "Slash"},
+            { SlashMode.Loading, "Loading"},
+
+            { SlashMode.BitStream, "Bit Stream"},
+            { SlashMode.Transmission, "Transmission"},
+
+            { SlashMode.Flow, "Flow"},
+            { SlashMode.Flux, "Flux"},
+            { SlashMode.Phantom, "Phantom"},
+            { SlashMode.Spectrum, "Spectrum"},
+
+            { SlashMode.Hazard, "Hazard"},
+            { SlashMode.Interfacing, "Interfacing"},
+            { SlashMode.Ramp, "Ramp"},
+
+            { SlashMode.GameOver, "Game Over"},
+            { SlashMode.Start, "Start"},
+            { SlashMode.Buzzer, "Buzzer"},
+        };
+
+        private static Dictionary<SlashMode, byte> modeCodes = new Dictionary<SlashMode, byte>
+        {
+            { SlashMode.Bounce, 0x10},
+            { SlashMode.Slash, 0x12},
+            { SlashMode.Loading, 0x13},
+
+            { SlashMode.BitStream, 0x1D},
+            { SlashMode.Transmission, 0x1A},
+
+            { SlashMode.Flow, 0x19},
+            { SlashMode.Flux, 0x25},
+            { SlashMode.Phantom, 0x24},
+            { SlashMode.Spectrum, 0x26},
+
+            { SlashMode.Hazard, 0x32},
+            { SlashMode.Interfacing, 0x33},
+            { SlashMode.Ramp, 0x34},
+
+            { SlashMode.GameOver, 0x42},
+            { SlashMode.Start, 0x43},
+            { SlashMode.Buzzer, 0x44},
+        };
+
+        public SlashDevice() : base(0x0B05, 0x193B, 128)
+        {
+        }
+
+        public void WakeUp()
+        {
+            Set(Packet<SlashPacket>(Encoding.ASCII.GetBytes("ASUS Tech.Inc.")));
+        }
+
+        public void Init()
+        {
+            Set(Packet<SlashPacket>(0xD7, 0x00, 0x00, 0x01, 0xAC));
+            Set(Packet<SlashPacket>(0xD2, 0x02, 0x01, 0x08, 0xAB));
+        }
+
+        public void Save()
+        {
+            Set(Packet<SlashPacket>(0xD4, 0x00, 0x00, 0x01, 0xAB));
+        }
+
+        public void SetMode(SlashMode mode)
+        {
+            byte modeByte;
+
+            try
+            {
+                modeByte = modeCodes[mode];
+            }
+            catch (Exception)
+            {
+                modeByte = 0x00;
+            }
+
+            Set(Packet<SlashPacket>(0xD2, 0x03, 0x00, 0x0C));
+            Set(Packet<SlashPacket>(0xD3, 0x04, 0x00, 0x0C, 0x01, modeByte, 0x02, 0x19, 0x03, 0x13, 0x04, 0x11, 0x05, 0x12, 0x06, 0x13));
+        }
+
+        public void SetOptions(bool status, int brightness = 0, int interval = 0)
+        {
+            byte brightnessByte = (byte)(brightness * 85.333);
+
+            Set(Packet<SlashPacket>(0xD3, 0x03, 0x01, 0x08, 0xAB, 0xFF, 0x01, status ? (byte)0x01 : (byte)0x00, 0x06, brightnessByte, 0xFF, (byte)interval));
+        }
+
+        public void SetBatterySaver(bool status)
+        {
+            Set(Packet<SlashPacket>(0xD8, 0x01, 0x00, 0x01, status ? (byte)0x80 : (byte)0x00));
+        }
+
+        public void Set(Packet packet)
+        {
+            _usbProvider?.Set(packet.Data);
+            Logger.WriteLine("Slash:" + BitConverter.ToString(packet.Data));
+        }
+
+
+    }
+}