Управление Arduino из Windows Forms приложения C#. Подключение Arduino и создание приложения

using System.IO.Ports;

private void Form1_Load(object sender, EventArgs e)
{
    // Получаем список доступных портов
    string[] ports = SerialPort.GetPortNames();
    
    // Добавляем их в выпадающий список
    comboBoxPorts.Items.AddRange(ports);
    
    // Если есть доступные порты, выбираем первый по умолчанию
    if (ports.Length > 0)
        comboBoxPorts.SelectedIndex = 0;
}

serialPort1.Open();
System.Threading.Thread.Sleep(2000);  // Даем Arduino время на перезагрузку
// Теперь можно отправлять команды

private void buttonOn_Click(object sender, EventArgs e)
{
    try
    {
        if (!serialPort1.IsOpen)
            serialPort1.Open();
            
        serialPort1.Write("H");
    }
    catch (Exception ex)
    {
        MessageBox.Show("Ошибка при отправке команды: " + ex.Message);
    }
}
 
private void buttonOff_Click(object sender, EventArgs e)
{
    try
    {
        if (!serialPort1.IsOpen)
            serialPort1.Open();
            
        serialPort1.Write("L");
    }
    catch (Exception ex)
    {
        MessageBox.Show("Ошибка при отправке команды: " + ex.Message);
    }
}

public Form1()
{
    InitializeComponent();
    serialPort1.DataReceived += SerialPort1_DataReceived;
}
 
private void SerialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
    // Чтение данных из порта
    string data = serialPort1.ReadLine();
    
    // Вызов метода обновления UI через делегат, так как мы находимся в другом потоке
    this.Invoke((MethodInvoker)delegate {
        textBoxReceived.Text += data + Environment.NewLine;
    });
}

private string FindArduinoPort()
{
    // Получаем список всех доступных портов
    string[] ports = SerialPort.GetPortNames();
    
    foreach (string port in ports)
    {
        try
        {
            // Создаем временное соединение
            using (SerialPort tempPort = new SerialPort(port, 9600))
            {
                tempPort.Open();
                // Даем Arduino время на перезагрузку
                System.Threading.Thread.Sleep(2000);
                
                // Отправляем тестовую команду
                tempPort.Write("T");
                
                // Ждем ответа некоторое время
                System.Threading.Thread.Sleep(500);
                
                if (tempPort.BytesToRead > 0)
                {
                    // Читаем ответ
                    string response = tempPort.ReadLine();
                    
                    // Проверяем, соответствует ли ответ ожидаемому
                    if (response.Contains("Arduino"))
                        return port;
                }
                
                tempPort.Close();
            }
        }
        catch
        {
            // Игнорируем ошибки, просто переходим к следующему порту
            continue;
        }
    }
    
    return null; // Устройство не найдено
}

<команда>:<параметр1>,<параметр2>,...;<контрольная сумма>

LED:13,128;141

private int CalculateChecksum(string data)
{
    int sum = 0;
    foreach (char c in data)
    {
        sum += c;
    }
    return sum % 256; // Ограничиваем одним байтом
}

private string buffer = string.Empty;
 
private void ProcessIncomingData(string data)
{
    buffer += data;
    
    // Ищем конец сообщения (в нашем случае - символ новой строки)
    int newLineIndex = buffer.IndexOf('\n');
    while (newLineIndex > -1)
    {
        // Выделяем сообщение из буфера
        string message = buffer.Substring(0, newLineIndex).Trim();
        // Обрабатываем сообщение
        HandleMessage(message);
        // Удаляем обработанное сообщение из буфера
        buffer = buffer.Substring(newLineIndex + 1);
        // Ищем следующее сообщение
        newLineIndex = buffer.IndexOf('\n');
    }
}

private void SendLargeData(byte[] data)
{
    const int packetSize = 32;
    
    for (int i = 0; i < data.Length; i += packetSize)
    {
        // Определяем размер текущего фрагмента
        int currentPacketSize = Math.Min(packetSize, data.Length - i);
        
        // Создаем буфер для фрагмента
        byte[] packet = new byte[currentPacketSize];
        Array.Copy(data, i, packet, 0, currentPacketSize);
        
        // Отправляем фрагмент
        serialPort1.Write(packet, 0, currentPacketSize);
        
        // Ждем подтверждения получения (в реальном коде нужно более сложная логика)
        WaitForAcknowledgement();
    }
}

// Отправка целого числа в бинарном формате
private void SendIntBinary(int value)
{
    byte[] bytes = BitConverter.GetBytes(value);
    serialPort1.Write(bytes, 0, bytes.Length);
}
 
// Чтение целого числа в бинарном формате
private int ReadIntBinary()
{
    byte[] buffer = new byte[4];
    serialPort1.Read(buffer, 0, 4);
    return BitConverter.ToInt32(buffer, 0);
}

private void InitializeUI()
{
    // Настройка ComboBox для выбора порта
    comboBoxPorts = new ComboBox();
    comboBoxPorts.Location = new Point(12, 12);
    comboBoxPorts.Size = new Size(121, 21);
    comboBoxPorts.DropDownStyle = ComboBoxStyle.DropDownList;
    
    // Кнопки подключения/отключения
    buttonConnect = new Button();
    buttonConnect.Location = new Point(139, 12);
    buttonConnect.Size = new Size(75, 23);
    buttonConnect.Text = "Подключить";
    buttonConnect.Click += ButtonConnect_Click;
    
    buttonDisconnect = new Button();
    buttonDisconnect.Location = new Point(220, 12);
    buttonDisconnect.Size = new Size(75, 23);
    buttonDisconnect.Text = "Отключить";
    buttonDisconnect.Enabled = false;
    buttonDisconnect.Click += ButtonDisconnect_Click;
    
    // Добавляем элементы управления на форму
    this.Controls.Add(comboBoxPorts);
    this.Controls.Add(buttonConnect);
    this.Controls.Add(buttonDisconnect);
    
    // И так далее для остальных элементов...
}

public class ArduinoController : IDisposable
{
    private SerialPort _serialPort;
    private string _buffer = string.Empty;
    
    public event EventHandler<string> DataReceived;
    public event EventHandler ConnectionLost;
    
    public bool IsConnected => _serialPort != null && _serialPort.IsOpen;
    
    public ArduinoController()
    {
        _serialPort = new SerialPort();
        _serialPort.DataReceived += SerialPort_DataReceived;
    }
    
    public bool Connect(string portName, int baudRate = 9600)
    {
        try
        {
            // Настраиваем порт
            _serialPort.PortName = portName;
            _serialPort.BaudRate = baudRate;
            _serialPort.DataBits = 8;
            _serialPort.Parity = Parity.None;
            _serialPort.StopBits = StopBits.One;
            _serialPort.Handshake = Handshake.None;
            
            // Таймауты
            _serialPort.ReadTimeout = 1000;
            _serialPort.WriteTimeout = 1000;
            
            // Открываем порт
            _serialPort.Open();
            
            // Даем Arduino время на перезагрузку
            Thread.Sleep(1500);
            
            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }
    
    public void Disconnect()
    {
        if (_serialPort != null && _serialPort.IsOpen)
        {
            _serialPort.Close();
        }
    }
    
    public bool SendCommand(string command)
    {
        try
        {
            if (!IsConnected)
                return false;
                
            _serialPort.WriteLine(command);
            return true;
        }
        catch (Exception)
        {
            // В реальном коде здесь должна быть обработка исключений
            return false;
        }
    }
    
    private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        try
        {
            string data = _serialPort.ReadExisting();
            ProcessReceivedData(data);
        }
        catch (Exception)
        {
            // Если произошла ошибка при чтении, вероятно соединение потеряно
            OnConnectionLost();
        }
    }
    
    private void ProcessReceivedData(string data)
    {
        _buffer += data;
        
        // Ищем конец сообщения (символ новой строки)
        int newLineIndex = _buffer.IndexOf('\n');
        while (newLineIndex >= 0)
        {
            // Выделяем сообщение
            string message = _buffer.Substring(0, newLineIndex).Trim();
            
            // Уведомляем подписчиков
            OnDataReceived(message);
            
            // Удаляем обработанное сообщение из буфера
            _buffer = _buffer.Substring(newLineIndex + 1);
            
            // Ищем следующее сообщение
            newLineIndex = _buffer.IndexOf('\n');
        }
    }
    
    protected virtual void OnDataReceived(string data)
    {
        DataReceived?.Invoke(this, data);
    }
    
    protected virtual void OnConnectionLost()
    {
        ConnectionLost?.Invoke(this, EventArgs.Empty);
    }
    
    public void Dispose()
    {
        Disconnect();
        
        if (_serialPort != null)
        {
            _serialPort.DataReceived -= SerialPort_DataReceived;
            _serialPort.Dispose();
            _serialPort = null;
        }
    }
}

public partial class MainForm : Form
{
    private ArduinoController _arduino;
    
    public MainForm()
    {
        InitializeComponent();
        
        _arduino = new ArduinoController();
        _arduino.DataReceived += Arduino_DataReceived;
        _arduino.ConnectionLost += Arduino_ConnectionLost;
        
        LoadAvailablePorts();
    }
    
    private void LoadAvailablePorts()
    {
        comboBoxPorts.Items.Clear();
        string[] ports = SerialPort.GetPortNames();
        comboBoxPorts.Items.AddRange(ports);
        
        if (ports.Length > 0)
            comboBoxPorts.SelectedIndex = 0;
            
        buttonConnect.Enabled = ports.Length > 0;
    }
    
    private void ButtonConnect_Click(object sender, EventArgs e)
    {
        if (comboBoxPorts.SelectedItem == null)
            return;
            
        string portName = comboBoxPorts.SelectedItem.ToString();
        
        if (_arduino.Connect(portName))
        {
            UpdateConnectionStatus(true);
            
            // Можно добавить автоматическую отправку команды инициализации
            _arduino.SendCommand("INIT");
        }
        else
        {
            MessageBox.Show("Не удалось подключиться к порту " + portName, 
                           "Ошибка подключения", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
    
    private void ButtonDisconnect_Click(object sender, EventArgs e)
    {
        _arduino.Disconnect();
        UpdateConnectionStatus(false);
    }
    
    private void UpdateConnectionStatus(bool isConnected)
    {
        buttonConnect.Enabled = !isConnected;
        buttonDisconnect.Enabled = isConnected;
        comboBoxPorts.Enabled = !isConnected;
        
        // Обновляем статус других элементов управления
        panelControls.Enabled = isConnected;
        
        // Обновляем индикатор статуса
        labelStatus.Text = isConnected ? "Подключено" : "Отключено";
        labelStatus.ForeColor = isConnected ? Color.Green : Color.Red;
    }
    
    private void Arduino_DataReceived(object sender, string data)
    {
        // Поскольку это событие вызывается в другом потоке,
        // используем Invoke для обновления UI
        this.Invoke((MethodInvoker)delegate
        {
            textBoxLog.AppendText(data + Environment.NewLine);
            
            // Анализируем полученные данные и обновляем интерфейс
            ProcessArduinoData(data);
        });
    }
    
    private void Arduino_ConnectionLost(object sender, EventArgs e)
    {
        this.Invoke((MethodInvoker)delegate
        {
            _arduino.Disconnect();
            UpdateConnectionStatus(false);
            MessageBox.Show("Соединение с устройством потеряно.", 
                           "Ошибка связи", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        });
    }
    
    private void ProcessArduinoData(string data)
    {
        // Парсинг и обработка данных от Arduino
        // Например, если Arduino отправляет данные в формате "TEMP:25.5"
        if (data.StartsWith("TEMP:"))
        {
            string tempValue = data.Substring(5);
            if (float.TryParse(tempValue, out float temperature))
            {
                labelTemperature.Text = temperature.ToString("0.0") + "°C";
                
                // Меняем цвет индикатора в зависимости от температуры
                if (temperature > 30)
                    labelTemperature.ForeColor = Color.Red;
                else if (temperature < 10)
                    labelTemperature.ForeColor = Color.Blue;
                else
                    labelTemperature.ForeColor = Color.Green;
            }
        }
    }
    
    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        // Корректно отключаемся при закрытии формы
        _arduino.Dispose();
        base.OnFormClosing(e);
    }
}

public async Task<string> SendCommandAndWaitForResponseAsync(string command, int timeoutMs = 2000)
{
    // Создаем источник токена отмены для реализации таймаута
    using (var cts = new CancellationTokenSource(timeoutMs))
    {
        try
        {
            // Задача, представляющая ожидание ответа
            var tcs = new TaskCompletionSource<string>();
            
            // Обработчик события получения данных
            EventHandler<string> handler = null;
            handler = (s, data) =>
            {
                // Если данные соответствуют ожидаемому ответу
                if (data.StartsWith(command.Split(':')[0] + "_ACK"))
                {
                    // Устанавливаем результат задачи
                    tcs.TrySetResult(data);
                }
            };
            
            // Подписываемся на событие
            DataReceived += handler;
            
            // Отправляем команду
            if (!SendCommand(command))
            {
                return "ERROR:SEND_FAILED";
            }
            
            // Регистрируем обработчик отмены
            cts.Token.Register(() => tcs.TrySetCanceled(), false);
            
            // Ожидаем результат или отмену по таймауту
            string result = await tcs.Task;
            
            // Отписываемся от события
            DataReceived -= handler;
            
            return result;
        }
        catch (TaskCanceledException)
        {
            return "ERROR:TIMEOUT";
        }
        catch (Exception ex)
        {
            return "ERROR:" + ex.Message;
        }
    }
}

private async void buttonSendCommand_Click(object sender, EventArgs e)
{
    buttonSendCommand.Enabled = false;
    
    try
    {
        string command = textBoxCommand.Text;
        string response = await _arduino.SendCommandAndWaitForResponseAsync(command);
        
        if (response.StartsWith("ERROR:"))
        {
            MessageBox.Show("Ошибка при выполнении команды: " + response.Substring(6));
        }
        else
        {
            textBoxLog.AppendText("Получен ответ: " + response + Environment.NewLine);
        }
    }
    finally
    {
        buttonSendCommand.Enabled = true;
    }
}

public enum CommandResult
{
    Success,
    DeviceNotConnected,
    CommandTimeout,
    InvalidResponse,
    PortError,
    UnknownError
}
 
public CommandResult SetLedState(int pinNumber, bool state)
{
    try
    {
        if (!IsConnected)
            return CommandResult.DeviceNotConnected;
            
        string command = $"LED:{pinNumber},{(state ? "1" : "0")}";
        string response = SendCommandAndWaitForResponse(command);
        
        if (string.IsNullOrEmpty(response))
            return CommandResult.CommandTimeout;
            
        if (response.StartsWith("ACK"))
            return CommandResult.Success;
            
        return CommandResult.InvalidResponse;
    }
    catch (IOException)
    {
        return CommandResult.PortError;
    }
    catch (Exception)
    {
        return CommandResult.UnknownError;
    }
}

private void buttonLedOn_Click(object sender, EventArgs e)
{
    CommandResult result = _arduino.SetLedState(13, true);
    
    switch (result)
    {
        case CommandResult.Success:
            UpdateStatusText("Светодиод включен");
            break;
        case CommandResult.DeviceNotConnected:
            ShowError("Устройство не подключено");
            break;
        case CommandResult.CommandTimeout:
            ShowError("Превышено время ожидания ответа");
            AttemptReconnect();
            break;
        case CommandResult.PortError:
            ShowError("Ошибка порта");
            UpdateConnectionStatus(false);
            break;
        default:
            ShowError("Неизвестная ошибка");
            break;
    }
}

private void SaveSettings()
{
    Properties.Settings.Default.LastComPort = comboBoxPorts.SelectedItem?.ToString() ?? "";
    Properties.Settings.Default.BaudRate = (int)numericUpDownBaudRate.Value;
    Properties.Settings.Default.AutoConnect = checkBoxAutoConnect.Checked;
    Properties.Settings.Default.Save();
}
 
private void LoadSettings()
{
    numericUpDownBaudRate.Value = Properties.Settings.Default.BaudRate;
    checkBoxAutoConnect.Checked = Properties.Settings.Default.AutoConnect;
    
    string lastPort = Properties.Settings.Default.LastComPort;
    if (!string.IsNullOrEmpty(lastPort))
    {
        int index = comboBoxPorts.Items.IndexOf(lastPort);
        if (index >= 0)
            comboBoxPorts.SelectedIndex = index;
    }
    
    // Если настроен автоматический коннект и порт выбран, подключаемся
    if (checkBoxAutoConnect.Checked && comboBoxPorts.SelectedIndex >= 0)
    {
        ButtonConnect_Click(this, EventArgs.Empty);
    }
}

private List<float> _temperatureHistory = new List<float>();
private const int MaxHistoryPoints = 100;
 
private void UpdateTemperatureChart(float temperature)
{
    // Добавляем новую точку
    _temperatureHistory.Add(temperature);
    
    // Ограничиваем количество точек
    if (_temperatureHistory.Count > MaxHistoryPoints)
        _temperatureHistory.RemoveAt(0);
    
    // Очищаем график
    chartTemperature.Series["Temperature"].Points.Clear();
    
    // Добавляем все точки на график
    for (int i = 0; i < _temperatureHistory.Count; i++)
    {
        chartTemperature.Series["Temperature"].Points.AddXY(i, _temperatureHistory[i]);
    }
    
    // Обновляем пределы осей
    chartTemperature.ChartAreas[0].AxisY.Minimum = Math.Floor(_temperatureHistory.Min());
    chartTemperature.ChartAreas[0].AxisY.Maximum = Math.Ceiling(_temperatureHistory.Max());
    
    // Обновляем график
    chartTemperature.Invalidate();
}

public enum LogLevel
{
    Debug,
    Info,
    Warning,
    Error
}
 
public void Log(LogLevel level, string message)
{
    string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
    string logEntry = $"[{timestamp}] [{level}] {message}";
    
    // Добавляем в UI, если он доступен
    try
    {
        if (_logTextBox != null && _logTextBox.InvokeRequired)
        {
            _logTextBox.Invoke(new Action(() => {
                _logTextBox.AppendText(logEntry + Environment.NewLine);
                // Прокручиваем до последней строки
                _logTextBox.SelectionStart = _logTextBox.TextLength;
                _logTextBox.ScrollToCaret();
            }));
        }
        else if (_logTextBox != null)
        {
            _logTextBox.AppendText(logEntry + Environment.NewLine);
            _logTextBox.SelectionStart = _logTextBox.TextLength;
            _logTextBox.ScrollToCaret();
        }
    }
    catch { /* Игнорируем ошибки UI */ }
    
    // Записываем в файл
    try
    {
        using (StreamWriter writer = File.AppendText("application.log"))
        {
            writer.WriteLine(logEntry);
        }
    }
    catch { /* Игнорируем ошибки файловой системы */ }
}