Что - то не так с общением Forms и arduino

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Linq;
//using static System.Windows.Forms.VisualStyles.VisualStyleElement;
 
namespace TVGControlApp
{
    public partial class Form1 : Form
    {
        bool isConnected = false;
        Color[][][] gifMassive;
        Color[][][] gifBuffer;
 
        int bright = 255;
        int hasVol = 1;
 
        string pathsPath;
        string selectedPath;
 
        int gifDelay = 100;
 
        public Form1()
        {
            InitializeComponent();
            UpdateCOMList();
            if (!Directory.Exists(Path.Combine("C:/Users/Asus/source/repos/TVGControlApp", "gif_folder.txt"))) { 
                pathsPath = ReadStringOutFile("gif_folder");
                PPText.Text = pathsPath;
                LoadGifs(pathsPath);
            }
            else
            {
                pathsPath = "";
            }
        }
 
        private void LoadGifs(string path)
        {
            if (!Directory.Exists(path) || string.IsNullOrEmpty(path))
            {
                MessageBox.Show("Путь не существует либо пуст");
                return;
            }
 
            flowLayoutPanel.Controls.Clear();
            string[] gifFiles = Directory.GetFiles(path, "*.gif");
 
            foreach (var gifFile in gifFiles)
            {
                Button gifButton = new Button
                {
                    Text = Path.GetFileName(gifFile),
                    Tag = gifFile
                };
                gifButton.Click += Gif_Click;
                flowLayoutPanel.Controls.Add(gifButton);
            }
        }
 
        private void Gif_Click(object sender, EventArgs e)
        {
            Button clickedButton = sender as Button;
            if (clickedButton != null)
            {
                selectedPath = clickedButton.Tag.ToString();
                selectedGif.Text = selectedPath;
                //MessageBox.Show("Selected Path: " + selectedPath);
                gifBuffer = GetGif(selectedPath);
            }
        }
 
        //-------------------------------------------------------------------------------
        private void gifButton_Click(object sender, EventArgs e)
        {
            using (FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog())
            {
                folderBrowserDialog.Description = "Выберите путь к папке с GIF";
                folderBrowserDialog.ShowNewFolderButton = true;
 
                if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
                {
                    string filePath = folderBrowserDialog.SelectedPath;
                    pathsPath = filePath;
                    SaveStringToFile(filePath, "gif_folder");
                    PPText.Text = pathsPath;
                    LoadGifs(pathsPath);
                }
            }
        }
        /*
         * if (string.IsNullOrEmpty(selectedPath) | string.IsNullOrEmpty(pathsPath))
            {
                MessageBox.Show("Please load a GIF first.");
                return;
            }
         */
 
        private Color[][][] GetGif(string path)
        {
            try
            {
                using (var gifImage = Image.FromFile(path))
                {
                    var dimension = new FrameDimension(gifImage.FrameDimensionsList[0]);
                    int frameCount = gifImage.GetFrameCount(dimension);
                    Color[][][] frames = new Color[frameCount][][];
 
                    for (int i = 0; i < frameCount; i++)
                    {
                        gifImage.SelectActiveFrame(dimension, i);
                        Bitmap originalBmp = new Bitmap(gifImage);
                        Bitmap resizedBmp = ResizeImage(originalBmp, 16, 16);
 
                        if (i == 0) { pictureBox1.Image = resizedBmp; }
 
                        int width = resizedBmp.Width;
                        int height = resizedBmp.Height;
                        Color[][] frame = new Color[height][];
                        for (int y = 0; y < height; y++)
                        {
                            frame[y] = new Color[width];
                            for (int x = 0; x < width; x++)
                            {
                                frame[y][x] = resizedBmp.GetPixel(x, y);
                            }
                        }
                        frames[i] = frame;
                        //DebugFrames(gifMassive);
                    }
                    return frames;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
                return null; 
            }
        }
 
        /// <summary>
        /// Пикселизация изображения путём уменьшения картинки до заданного значения,
        /// затем увеличение мелкой картинки путём дублирования пикселей
        /// </summary>
        /// <param name="image">исходная картинка</param>
        /// <param name="width">ширина мелкой картинки</param>
        /// <param name="height">высота мелкой картинки</param>
        /// <returns>пикселизированное изображение</returns>
        
 
            void SendGIF(Color[][][] gif)
        {
            if (!serialPort.IsOpen)
            {
                MessageBox.Show("Serial port is not open.");
                return;
            }
 
            serialPort.Write($"Bright{bright}");
            serialPort.Write($"Vol{hasVol}");
            for (int frame = 0; frame < gif.Length; frame++)
            {
                serialPort.Write("ClearImg");
                for (int pixels = 0; pixels < gif[frame].Length; pixels++)
                {
                    serialPort.Write("Pix" + gif[frame][pixels].ToString() + "," + gif[frame][pixels][0].ToString() + "," + gif[frame][pixels][1].ToString() + "," + gif[frame][pixels][2].ToString());
                    System.Threading.Thread.Sleep(5);
                }
                serialPort.Write("ShowImg");
                System.Threading.Thread.Sleep(gifDelay);
            }
        }
 
 
        private void DebugFrames(Color[][][] frames)
        {
            for (int i = 0; i < frames.Length; i++)
            {
                Console.WriteLine($"Frame {i + 1}:");
                for (int y = 0; y < frames[i].Length; y++)
                {
                    for (int x = 0; x < frames[i][y].Length; x++)
                    {
                        Console.Write(frames[i][y][x]);  // Можно заменить на  для вывода цветов
                    }
                    Console.WriteLine();
                }
                Console.WriteLine();
            }
        }
 
        private void connectToArduino()
        {
            string selectedPort = comboBox.GetItemText(comboBox.SelectedItem);
            try
            {
                if (!serialPort.IsOpen)
                {
                    serialPort.PortName = selectedPort;
                    serialPort.Open();
                    isConnected = true;
                    connectButton.Text = "Отключить";
                    MessageBox.Show($"Подключено к порту {serialPort.PortName}");
                    COMName.Text = serialPort.PortName;
                }
                else
                {
                    MessageBox.Show($"Порт {serialPort.PortName} уже открыт.");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Ошибка при открытии порта {selectedPort}: {ex.Message}");
            }
        }
 
        private void disconnectFromArduino()
        {
            if (serialPort.IsOpen)
            {
                serialPort.Close();
            }
            isConnected = false;
            connectButton.Text = "Подключить";
        }
 
 
        void reloadButton_Click(object sender, EventArgs e)
        {
            LoadGifs(pathsPath);
        }
 
        private void SaveStringToFile(string toSave, string name)
        {
            string ttt = name + ".txt";
            string filePath = Path.Combine("C:/Users/Asus/source/repos/TVGControlApp", ttt); // Имя файла
            try
            {
                File.WriteAllText(filePath, toSave);
                MessageBox.Show("Сохранено в " + filePath);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Ошибка сохранения: " + ex.Message);
            }
        }
 
        string ReadStringOutFile(string name)
        {
            string ttt = name + ".txt";
            string filePath = Path.Combine("C:/Users/Asus/source/repos/TVGControlApp", ttt);
            try
            {
                string fileContent = File.ReadAllText(filePath);
                return fileContent;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Ошибка загрузки: " + ex.Message);
                return null;
            }
        }
 
        private void openPPButton_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(pathsPath))
            {
                try
                {
                    Process.Start("explorer.exe", pathsPath);
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Ошибка открытия: " + ex.Message);
                }
            }
            else
            {
                MessageBox.Show("ОН БЛЯТЬ ПУСТОЙ");
            }
        }
 
        private void connectButton_Click_1(object sender, EventArgs e)
        {
            UpdateCOMList();
        }
 
        void UpdateCOMList()
        {
            comboBox.Items.Clear();
            // Получаем список COM портов доступных в системе
            string[] portnames = SerialPort.GetPortNames();
            // Проверяем есть ли доступные
            if (portnames.Length == 0)
            {
                MessageBox.Show("COM PORT not found");
            }
            foreach (string portName in portnames)
            {
                if (string.IsNullOrEmpty(portName))
                {
                    MessageBox.Show("COM PORT is null");
                    return;
                }
                //добавляем доступные COM порты в список           
                comboBox.Items.Add(portName);
                Console.WriteLine(portnames.Length);
                if (portnames[0] != null)
                {
                    comboBox.SelectedItem = portnames[0];
                }
            }
        }
 
        private void arduinoButton_Click_1(object sender, EventArgs e)
        {
            if (!isConnected)
            {
                connectToArduino();
            }
            else
            {
                disconnectFromArduino();
            }
        }
 
        private void send_Click(object sender, EventArgs e)
        {
             serialPort.Write("Hello, wrld! Im from VSWF!");
            gifMassive = gifBuffer;
            bright = brightBar.Value;
            if (volState.Checked)
                hasVol = 1;
            else
                hasVol = 0;
        }
 
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // if (serialPort.IsOpen) serialPort.Close();
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e); 
            if (gifMassive != null)
            {
                SendGIF(gifMassive);
            }
        }
 
        void test1()
        {
            for (int i = 0; i < 10; i++)
            {
                MessageBox.Show(i.ToString());
                System.Threading.Thread.Sleep(1000);
            }
        }
 
        private Bitmap ResizeImage(Bitmap image, int width, int height)
        {
            if (image.Width != 16 & image.Height != 16)
            {
                // step 0
                Bitmap img = new Bitmap(width, height);
                using (Graphics gr = Graphics.FromImage(img))
                {
                    gr.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                    gr.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
                    gr.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
                    gr.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
 
                    gr.DrawImage(image, new Rectangle(0, 0, width, height));
                }
 
                //step 1
                int kfx = (image.Width * 2) / width;
                Bitmap enlargedImage = new Bitmap(img.Width * kfx, img.Height * kfx);
 
                using (ImageWrapper wrIn = new ImageWrapper(img, true))
                using (ImageWrapper wrOut = new ImageWrapper(enlargedImage))
                {
                    for (int i = 0; i < wrOut.Width; i++)
                    {
                        for (int j = 0; j < wrOut.Height; j++)
                        {
                            wrOut[i, j] = wrIn[i / kfx, j / kfx];
                        }
                    }
                }
 
                //step2
                Bitmap finalImage = new Bitmap(image.Width, image.Height);
 
                using (Graphics graphics = Graphics.FromImage(finalImage))
                {
                    graphics.DrawImage(enlargedImage, new Rectangle(0, 0, image.Width, image.Height));
                }
 
                return finalImage;
            }
            else
            {
                Bitmap img = new Bitmap(width, height);
                using (Graphics gr = Graphics.FromImage(img))
                {
                    gr.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                    gr.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
                    gr.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
                    gr.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
 
                    gr.DrawImage(image, new Rectangle(0, 0, width, height));
                }
                return AutoBright(img);
                //return img;
            }
        }
 
        private Bitmap AutoBright(Bitmap img)
        {
            using (ImageWrapper wr = new ImageWrapper(img))
            {
                int min = 255, max = 0;
                foreach (Point p in wr)
                {
                    if (min > Math.Min(Math.Min(wr[p].R, wr[p].G), wr[p].B))
                    {
                        min = Math.Min(Math.Min(wr[p].R, wr[p].G), wr[p].B);
                    }
                    if (max < Math.Max(Math.Max(wr[p].R, wr[p].G), wr[p].B))
                    {
                        max = Math.Max(Math.Max(wr[p].R, wr[p].G), wr[p].B);
                    }
                }
                double a = min;
                double b = 255.0 / (max - min);
                foreach (Point p in wr)
                {
                    wr.SetPixel(p, (wr[p].R - a) * b, (wr[p].G - a) * b, (wr[p].B - a) * b);
                }
            }
            return img;
        }
 
        public class ImageWrapper : IDisposable, IEnumerable<Point> // С этой функцией мне помогли, я еще не умею работать с битами, учтите это пожалуйста
        {
            /// <summary>
            /// Ширина изображения
            /// </summary>
            public int Width { get; private set; }
            /// <summary>
            /// Высота изображения
            /// </summary>
            public int Height { get; private set; }
            /// <summary>
            /// Цвет по-умолачнию (используется при выходе координат за пределы изображения)
            /// </summary>
            public Color DefaultColor { get; set; }
 
            private byte[] data;//буфер исходного изображения
            private byte[] outData;//выходной буфер
            private int stride;
            private BitmapData bmpData;
            private Bitmap bmp;
 
            /// <summary>
            /// Создание обертки поверх bitmap.
            /// </summary>
            /// <param name="copySourceToOutput">Копирует исходное изображение в выходной буфер</param>
            public ImageWrapper(Bitmap bmp, bool copySourceToOutput = false)
            {
                Width = bmp.Width;
                Height = bmp.Height;
                this.bmp = bmp;
 
                bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
                stride = bmpData.Stride;
 
                data = new byte[stride * Height];
                System.Runtime.InteropServices.Marshal.Copy(bmpData.Scan0, data, 0, data.Length);
 
                outData = copySourceToOutput ? (byte[])data.Clone() : new byte[stride * Height];
            }
 
            /// <summary>
            /// Возвращает пиксел из исходнго изображения.
            /// Либо заносит пиксел в выходной буфер.
            /// </summary>
            public Color this[int x, int y]
            {
                get
                {
                    var i = GetIndex(x, y);
                    return i < 0 ? DefaultColor : Color.FromArgb(data[i + 3], data[i + 2], data[i + 1], data[i]);
                }
 
                set
                {
                    var i = GetIndex(x, y);
                    if (i >= 0)
                    {
                        outData[i] = value.B;
                        outData[i + 1] = value.G;
                        outData[i + 2] = value.R;
                        outData[i + 3] = value.A;
                    };
                }
            }
 
            /// <summary>
            /// Возвращает пиксел из исходнго изображения.
            /// Либо заносит пиксел в выходной буфер.
            /// </summary>
            public Color this[Point p]
            {
                get { return this[p.X, p.Y]; }
                set { this[p.X, p.Y] = value; }
            }
 
            /// <summary>
            /// Заносит в выходной буфер значение цвета, заданные в double.
            /// Допускает выход double за пределы 0-255.
            /// </summary>
            public void SetPixel(Point p, double r, double g, double b)
            {
                if (r < 0) r = 0;
                if (r >= 256) r = 255;
                if (g < 0) g = 0;
                if (g >= 256) g = 255;
                if (b < 0) b = 0;
                if (b >= 256) b = 255;
 
                this[p.X, p.Y] = Color.FromArgb((int)r, (int)g, (int)b);
            }
 
            int GetIndex(int x, int y)
            {
                return (x < 0 || x >= Width || y < 0 || y >= Height) ? -1 : x * 4 + y * stride;
            }
 
            /// <summary>
            /// Заносит в bitmap выходной буфер и снимает лок.
            /// Этот метод обязателен к исполнению (либо явно, лмбо через using)
            /// </summary>
            public void Dispose()
            {
                System.Runtime.InteropServices.Marshal.Copy(outData, 0, bmpData.Scan0, outData.Length);
                bmp.UnlockBits(bmpData);
            }
 
            /// <summary>
            /// Перечисление всех точек изображения
            /// </summary>
            public IEnumerator<Point> GetEnumerator()
            {
                for (int y = 0; y < Height; y++)
                    for (int x = 0; x < Width; x++)
                        yield return new Point(x, y);
            }
 
            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
 
            /// <summary>
            /// Меняет местами входной и выходной буферы
            /// </summary>
            public void SwapBuffers()
            {
                var temp = data;
                data = outData;
                outData = temp;
            }
        }
 
        private void clearGifButton_Click(object sender, EventArgs e)
        {
            gifMassive = null;
            gifBuffer = null;
            pictureBox1.Image = null;
        }
    } 
}

while (true) {
  обработать_все_сообщения()
}

int Add(int a, int b)
{
    Thread.Sleep(3000);
    return a + b;
}
 
var thread = new Thread(() => {
        var result = Add(3, 5);
        Console.WriteLine("result: " + result);
    }) {
    Priority = ThreadPriority.BelowNormal
};
thread.Start();
 
Console.WriteLine("main thread");
//output:
//main thread
//result: 8

int Add(int a, int b) {
    Thread.Sleep(3000);
    return a + b;
}
 
var thread = new Thread(() => {
        var result = Add(3, 5);
        Console.WriteLine("result: " + result);
});
thread.Priority = ThreadPriority.BelowNormal;
thread.Start();
//wait until thread is terminated
thread.Join();
 
Console.WriteLine("main thread");
//output:
//result: 8
//main thread

//class field
Random random = new();
 
void ShowNumber(object number) {
    //lock access for other threads
    lock (random) {
        Thread.Sleep(random.Next(500));
        Console.Write(number + ", ");
    }
}
 
//start ten threads
for (int i = 1; i <= 10; i++) {
    var waitCall = new WaitCallback(ShowNumber);
    ThreadPool.QueueUserWorkItem(waitCall, i);
}
 
//result without lock: 8, 4, 9, 6, 1, 10, 7, 3, 2, 5
//result with lock: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Task<int> Add(int a, int b) {         
    return Task.Run(() => {
            Thread.Sleep(3000);
            return a + b;
    });
}
 
//Start new thread and wait for Add() result
async void Test() {
    var result = await Add(5, 3);
    //result is 8
 
    Console.WriteLine($"result = {result}");
}
 
Test();

void SendGIF(Color[][][] gif)
{
    if (gifMassive != null)
 
    {
        if (!serialPort.IsOpen)
        {
            MessageBox.Show("Serial port is not open.");
            return;
        }
 
        serialPort.Write($"Bright{bright}");
        serialPort.Write($"Vol{hasVol}");
        for (int frame = 0; frame < gif.Length; frame++)
        {
            serialPort.Write("ClearImg");
            for (int pixels = 0; pixels < gif[frame].Length; pixels++)
            {
                serialPort.Write("Pix" + gif[frame][pixels].ToString() + "," + gif[frame][pixels][0].ToString() + "," + gif[frame][pixels][1].ToString() + "," + gif[frame][pixels][2].ToString());
                System.Threading.Thread.Sleep(5);
            }
            serialPort.Write("ShowImg");
            System.Threading.Thread.Sleep(gifDelay);
        }
    }
}

Task<int> task() {         
    return Task.Run(() => {
            Thread.Sleep(3000);
            SendGif(gifMassive);
    });
}
async void SG(){
var r = await task();
}
 
SG();