Доделал последнюю версию

1/1.ino

@@ -0,0 +1,40 @@
+#include <ModbusMaster.h>
+#include <SoftwareSerial.h>
+
+// Создание объектов для Modbus
+SoftwareSerial modbusSerial(10, 11);  // RX, TX пины для Modbus
+ModbusMaster node;  // Объект Modbus для работы с клиентом
+
+const int pinState = 7;  // Пин для состояния
+
+void setup() {
+  // Настройка пина
+  pinMode(pinState, INPUT);
+
+  // Инициализация Modbus
+  modbusSerial.begin(9600);  // Скорость обмена по серийному порту для Modbus
+  node.begin(1, modbusSerial);  // Адрес устройства (Slave ID)
+
+  // Устанавливаем тайм-аут для Modbus
+  node.preTransmission(preTransmission);
+  node.postTransmission(postTransmission);
+}
+
+void loop() {
+  // Считываем состояние пина (0 или 1)
+  int pinStatus = digitalRead(pinState);
+
+  // Отправляем состояние пина на клиентскую сторону через Modbus
+  node.writeSingleRegister(0, pinStatus);  // Пишем в регистр 0
+
+  delay(100);  // Задержка для предотвращения перегрузки
+}
+
+// Функции для обработки передачи данных
+void preTransmission() {
+  digitalWrite(8, 1);  // Например, управление RE/DE пинами (если используется RS-485)
+}
+
+void postTransmission() {
+  digitalWrite(8, 0);  // Отключение передачи
+}

sketch_feb14a/sketch_feb14a.ino

@@ -1,29 +1,19 @@
 #include <SimpleModbusSlave.h>
 
-
-#define PIN1 7  // Пин для проверки состояния
+#define PIN1 7  // Контролируемый пин
 
 // Настройка регистров
 #define TOTAL_REGS 1
-uint16_t regs[TOTAL_REGS] = {0}; // Один регистр для хранения статуса
+uint16_t regs[TOTAL_REGS] = {0};  // Один регистр для хранения состояния пина
 
-SimpleModbusSlave slave(1);  // Инициализация Slave с ID 1
+SimpleModbusSlave slave(1);  // Инициализация устройства с ID 1
 
 void setup() {
-    // Настройка пина как вход
-    pinMode(PIN1, INPUT);
-
-    // Настройка скорости передачи данных
-    slave.setup(115200); // Установка скорости передачи данных 115200
+    pinMode(PIN1, INPUT);  // Настроим пин как вход
+    slave.setup(115200);   // Установим скорость передачи данных 115200 бод
 }
 
 void loop() {
-    // Чтение состояния пина
-    int pinState = digitalRead(PIN1);
-
-    // Установка регистра в 1, если пин HIGH, иначе 0
-    regs[0] = (pinState == HIGH) ? 1 : 0;
-
-    // Запуск цикла Modbus slave
-    slave.loop(regs, TOTAL_REGS);
+    regs[0] = digitalRead(PIN1);  // Читаем состояние пина и записываем в регистр
+    slave.loop(regs, TOTAL_REGS);  // Обрабатываем Modbus-запросы
 }

Версия_1.0/Server.py

@@ -0,0 +1,77 @@
+#pip install pymodbus flask
+#pip install pymodbus==2.5.3
+#python d:\Антоше\Универ\Гит\Software_and_hardware\Версия_1.0\Server.py
+
+
+
+import serial
+from pymodbus.client.sync import ModbusSerialClient as ModbusClient
+from flask import Flask, render_template
+import serial.tools.list_ports
+import time
+
+app = Flask(__name__)
+
+# Настройка Modbus
+def find_arduino_port():
+    ports = list(serial.tools.list_ports.comports())
+    for port in ports:
+        if "Arduino" in port.description or "CH340" in port.description:
+            return port.device
+    return None
+
+# Поиск порта Arduino
+arduino_port = find_arduino_port()
+
+if arduino_port is None:
+    print("Arduino не подключено или не найдено")
+else:
+    print(f"Подключено к порту: {arduino_port}")
+
+# Настройка клиента Modbus
+modbus_client = ModbusClient(method='rtu', port=arduino_port, baudrate=9600)
+modbus_client.connect()
+
+# Состояние пина (будет обновляться через Modbus)
+modbus_register = 0  # Регистор Modbus для состояния пина
+
+# Функция для вывода состояния пина в консоль
+def print_pin_state():
+    result = modbus_client.read_holding_registers(modbus_register, 1, unit=1)
+    if result.isError():
+        print("Ошибка чтения состояния")
+        return
+    
+    # Состояние пина: 0 - OFF, 1 - ON
+    state = result.registers[0]
+    print(f"Состояние пина: {'Включен' if state == 1 else 'Выключен'}")
+
+# Обновление состояния пина каждую секунду
+def update_state_periodically():
+    while True:
+        print_pin_state()
+        time.sleep(1)
+
+# Запуск обновления состояния в фоновом режиме
+import threading
+state_thread = threading.Thread(target=update_state_periodically)
+state_thread.daemon = True
+state_thread.start()
+
+@app.route('/')
+def index():
+    return render_template('index.html', arduino_port=arduino_port)
+
+@app.route('/state')
+def get_state():
+    # Чтение состояния пина через Modbus
+    result = modbus_client.read_holding_registers(modbus_register, 1, unit=1)
+    if result.isError():
+        return "Ошибка чтения состояния", 500
+    
+    # Состояние пина: 0 - OFF, 1 - ON
+    state = result.registers[0]
+    return str(state)
+
+if __name__ == '__main__':
+    app.run(debug=True)

Версия_1.0/circle.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Modbus Circle</title>
+    <style>
+        .circle {
+            width: 100px;
+            height: 100px;
+            border-radius: 50%;
+            background-color: {{ color }};
+        }
+    </style>
+</head>
+<body>
+    <h1>Circle Color Controlled via Modbus</h1>
+    <div class="circle"></div>
+</body>
+</html>

Версия_1.0/sketch/sketch.ino

@@ -0,0 +1,20 @@
+#include <ModbusMaster.h>
+
+// Параметры Modbus
+ModbusMaster node;
+const int slaveID = 1;  // ID устройства
+const int modbusRegister = 0;  // Регистр для передачи состояния
+
+void setup() {
+  Serial.begin(9600);
+  node.begin(slaveID, Serial);  // Инициализация Modbus связи
+}
+
+void loop() {
+  int state = digitalRead(2);  // Читаем состояние пина 2
+
+  // Отправляем состояние на регистр Modbus
+  node.writeSingleRegister(modbusRegister, state);  // Записываем в регистр
+
+  delay(1000);  // Ждем 1 секунду
+}

Версия_1.0/templates/index.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Arduino State</title>
+    <style>
+        #circle {
+            width: 100px;
+            height: 100px;
+            border-radius: 50%;
+            margin: 20px;
+        }
+    </style>
+</head>
+<body>
+    <h1>Состояние пина Arduino</h1>
+    <p>Подключено к порту: <strong>{{ arduino_port }}</strong></p>
+    <div id="circle"></div>
+    <p>Текущее состояние: <span id="pin-state">Загрузка...</span></p>
+
+    <script>
+        function updateCircleColor() {
+            fetch('/state')
+                .then(response => response.text())
+                .then(state => {
+                    let circle = document.getElementById('circle');
+                    let pinStateText = document.getElementById('pin-state');
+                    
+                    if (state == '1') {
+                        circle.style.backgroundColor = 'green';
+                        pinStateText.innerHTML = 'Включено';
+                    } else {
+                        circle.style.backgroundColor = 'red';
+                        pinStateText.innerHTML = 'Выключено';
+                    }
+                })
+                .catch(error => console.log('Error fetching state:', error));
+        }
+
+        // Обновляем состояние каждые 1000 мс
+        setInterval(updateCircleColor, 1000);
+    </script>
+</body>
+</html>

Версия_2.0/Server.py

@@ -0,0 +1,53 @@
+#python d:\Антоше\Универ\Гит\Software_and_hardware\Версия_2.0\Server.py
+
+
+
+
+import serial
+import serial.tools.list_ports
+import minimalmodbus
+import time
+
+def find_arduino_port():
+    ports = list(serial.tools.list_ports.comports())
+    for port in ports:
+        if "Arduino" in port.description or "CH340" in port.description:
+            return port.device
+    return None
+
+
+
+# Настройки порта
+port = find_arduino_port()  # Укажите порт, к которому подключен Arduino
+slave_id = 1   # ID устройства (адрес Arduino)
+baudrate = 9600
+timeout = 1     # Время ожидания в секундах
+
+# Настроим модбас клиента
+client = minimalmodbus.Instrument(port, slave_id)  # Создаем объект клиента Modbus
+client.serial.baudrate = baudrate                # Устанавливаем скорость
+client.serial.timeout = timeout                  # Время ожидания ответа
+client.mode = minimalmodbus.MODE_RTU             # Используем RTU
+
+# Ожидаем получения данных от Arduino
+try:
+    while True:
+        try:
+            # Чтение 4 регистров с адреса 0
+            result = client.read_registers(0, 1, functioncode=3)
+            print(f"Полученные данные: {result}")
+            break  # Выход из цикла, если данные получены
+        except minimalmodbus.NoResponseError:
+            print("Ошибка: Нет ответа от устройства. Повторяем...")
+            time.sleep(1)  # Подождать 1 секунду и попробовать снова
+        except Exception as e:
+            print(f"Ошибка: {e}")
+            break
+
+except KeyboardInterrupt:
+    print("Программа остановлена пользователем")
+
+
+
+
+

Версия_2.0/sketch/sketch.ino

@@ -0,0 +1,21 @@
+#include <ModbusRtu.h>
+
+#define ID 1      // ID устройства (нужно для адресации в сети Modbus)
+#define PIN 7     // Пин, состояние которого мы хотим читать
+
+Modbus slave(ID, Serial);  // Создание объекта Modbus для Serial
+uint16_t au16data[1];      // Массив данных для хранения состояния пина
+
+void setup() {
+  pinMode(PIN, INPUT);      // Устанавливаем пин 7 как вход
+  Serial.begin(9600);       // Инициализация последовательного порта
+  slave.start();            // Запуск Modbus slave
+}
+
+void loop() {
+  // Чтение состояния пина и запись в массив данных
+  au16data[0] = digitalRead(PIN);  // Чтение состояния пина (0 или 1)
+
+  // Обработка запросов от мастера Modbus
+  slave.poll(au16data, 1);  // Проверка входящих запросов и отправка состояния пина
+}

Версия_3.0/Server.py

@@ -0,0 +1,52 @@
+#python d:\Антоше\Универ\Гит\Software_and_hardware\Версия_3.0\Server.py
+
+
+import serial
+import serial.tools.list_ports
+import minimalmodbus
+import time
+from flask import Flask, jsonify, render_template
+
+app = Flask(__name__)
+
+def find_arduino_port():
+    ports = list(serial.tools.list_ports.comports())
+    for port in ports:
+        if "Arduino" in port.description or "CH340" in port.description:
+            return port.device
+    return None
+
+# Настройки порта
+port = find_arduino_port()  # Укажите порт, к которому подключен Arduino
+slave_id = 1   # ID устройства (адрес Arduino)
+baudrate = 9600
+timeout = 1     # Время ожидания в секундах
+
+
+@app.route('/')
+def index():
+    return render_template('index.html')  # Отдача HTML файла
+
+# Настроим модбас клиента
+client = minimalmodbus.Instrument(port, slave_id)  # Создаем объект клиента Modbus
+client.serial.baudrate = baudrate                # Устанавливаем скорость
+client.serial.timeout = timeout                  # Время ожидания ответа
+client.mode = minimalmodbus.MODE_RTU             # Используем RTU
+
+@app.route('/status', methods=['GET'])
+def get_status():
+    try:
+        # Чтение 4 регистров с адреса 0
+        result = client.read_registers(0, 1, functioncode=3)
+        pin_state = result[0]  # Состояние пина
+        return jsonify({
+            'port': port,
+            'pinState': pin_state
+        })
+    except minimalmodbus.NoResponseError:
+        return jsonify({'error': 'Нет ответа от устройства'})
+    except Exception as e:
+        return jsonify({'error': str(e)})
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)

Версия_3.0/sketch/sketch.ino

@@ -0,0 +1,21 @@
+#include <ModbusRtu.h>
+
+#define ID 1      // ID устройства (нужно для адресации в сети Modbus)
+#define PIN 7     // Пин, состояние которого мы хотим читать
+
+Modbus slave(ID, Serial);  // Создание объекта Modbus для Serial
+uint16_t au16data[1];      // Массив данных для хранения состояния пина
+
+void setup() {
+  pinMode(PIN, INPUT);      // Устанавливаем пин 7 как вход
+  Serial.begin(9600);       // Инициализация последовательного порта
+  slave.start();            // Запуск Modbus slave
+}
+
+void loop() {
+  // Чтение состояния пина и запись в массив данных
+  au16data[0] = digitalRead(PIN);  // Чтение состояния пина (0 или 1)
+
+  // Обработка запросов от мастера Modbus
+  slave.poll(au16data, 1);  // Проверка входящих запросов и отправка состояния пина
+}

Версия_3.0/templates/index.html

@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Modbus Status</title>
+    <style>
+        #statusCircle {
+            width: 100px;
+            height: 100px;
+            border-radius: 50%;
+            background-color: gray;
+            margin: 20px;
+        }
+        #portInfo {
+            margin-top: 20px;
+        }
+    </style>
+</head>
+<body>
+    <h1>Modbus Slave Status</h1>
+    <div id="portInfo">Номер порта: <span id="portNumber">Не подключено</span></div>
+    <div id="statusCircle"></div>
+
+    <script>
+        async function fetchStatus() {
+            try {
+                const response = await fetch('/status');
+                const data = await response.json();
+
+                if (data.error) {
+                    console.log('Ошибка: ', data.error);
+                } else {
+                    document.getElementById("portNumber").innerText = data.port;
+                    const statusCircle = document.getElementById("statusCircle");
+
+                    // Обновляем цвет круга в зависимости от состояния пина
+                    if (data.pinState === 1) {
+                        statusCircle.style.backgroundColor = "green";  // Зеленый если состояние 7 пина HIGH
+                    } else {
+                        statusCircle.style.backgroundColor = "red";  // Красный если состояние 7 пина LOW
+                    }
+                }
+            } catch (error) {
+                console.log('Ошибка при получении данных: ', error);
+            }
+        }
+
+        // Получать данные каждую секунду
+        setInterval(fetchStatus, 1000);
+        fetchStatus(); // Вызвать сразу для начальной загрузки
+    </script>
+</body>
+</html>

Проверка портов.py

@@ -0,0 +1,43 @@
+from flask import Flask, jsonify
+from pymodbus.client import ModbusSerialClient
+import serial.tools.list_ports
+
+app = Flask(__name__)
+
+# Определяем доступные COM-порты
+def find_arduino_port():
+    ports = list(serial.tools.list_ports.comports())
+    for port in ports:
+        if "Arduino" in port.description or "CH340" in port.description:
+            return port.device
+    return None
+
+# Ищем подключенный Arduino
+port = find_arduino_port()
+if not port:
+    print("Не найден Arduino, проверьте подключение!")
+    exit(1)
+
+# Настройка подключения к Modbus
+client = ModbusSerialClient(port=port, baudrate=115200, timeout=1, stopbits=1, bytesize=8, parity='N')
+
+# Проверка подключения
+if not client.connect():
+    print(f"Ошибка подключения к {port}")
+    exit(1)
+else:
+    print(f"Подключение успешно: {port}")
+
+@app.route('/modbus-status', methods=['GET'])
+def modbus_status():
+    try:
+        # Читаем 1 регистр, начиная с адреса 0
+        response = client.read_holding_registers(0, 1, slave=1)
+        if response.isError():
+            return jsonify({"error": "Ошибка чтения Modbus"}), 500
+        return jsonify({"pin_status": response.registers[0]})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=True)

Проверка_портов.py

@@ -0,0 +1,43 @@
+from flask import Flask, jsonify
+from pymodbus.client import ModbusSerialClient
+import serial.tools.list_ports
+
+app = Flask(__name__)
+
+# Определяем доступные COM-порты
+def find_arduino_port():
+    ports = list(serial.tools.list_ports.comports())
+    for port in ports:
+        if "Arduino" in port.description or "CH340" in port.description:
+            return port.device
+    return None
+
+# Ищем подключенный Arduino
+port = find_arduino_port()
+if not port:
+    print("Не найден Arduino, проверьте подключение!")
+    exit(1)
+
+# Настройка подключения к Modbus
+client = ModbusSerialClient(port=port, baudrate=115200, timeout=1, stopbits=1, bytesize=8, parity='N')
+
+# Проверка подключения
+if not client.connect():
+    print(f"Ошибка подключения к {port}")
+    exit(1)
+else:
+    print(f"Подключение успешно: {port}")
+
+@app.route('/modbus-status', methods=['GET'])
+def modbus_status():
+    try:
+        # Читаем 1 регистр, начиная с адреса 0
+        response = client.read_holding_registers(0, 1, slave=1)
+        if response.isError():
+            return jsonify({"error": "Ошибка чтения Modbus"}), 500
+        return jsonify({"pin_status": response.registers[0]})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=True)

Сервер.py

@@ -1,79 +1,53 @@
+
+#python d:\Антоше\Универ\Гит\Software_and_hardware\Сервер.py
+#python d:\Антоше\Универ\Гит\Software_and_hardware\Проверка_портов.py
+
+
+
+
+
+
+
 from flask import Flask, jsonify
 from pymodbus.client.serial import ModbusSerialClient
+import serial.tools.list_ports
+
+# Определяем порт Arduino (ищем доступные порты)
+def find_arduino_port():
+    ports = serial.tools.list_ports.comports()
+    for port in ports:
+        if "Arduino" in port.description or "CH340" in port.description:
+            return port.device
+    return None
+
+# Настройки Modbus
+PORT = find_arduino_port() or "COM3"  # Если не нашли, используем COM3
+BAUDRATE = 115200
+TIMEOUT = 1
+
+# Подключение к Modbus
+client = ModbusSerialClient(port=PORT, baudrate=BAUDRATE, timeout=TIMEOUT, stopbits=1, bytesize=8, parity='N')
+client.unit = 1
 
 app = Flask(__name__)
 
-# Настройка Modbus клиента
-port_Arduino = 'COM3'  # Убедитесь, что это правильный порт для вашего компьютера
-baudrate = 115200
-
-client = ModbusSerialClient(port=port_Arduino, baudrate=115200, timeout=1, stopbits=1, bytesize=8, parity='N')
-
-# Попытка подключения к Modbus клиенту
-try:
+@app.route("/modbus-status", methods=["GET"])
+def get_modbus_status():
     if client.connect():
-        print("Подключение успешно!")
+        print(f"Подключение успешно к {port}")
+    
+        # Чтение катушек (биты, например, с адреса 0)
+        result = client.read_coils(0, 1)  # Чтение одного бита (катушки) с адреса 0
+    
+        if result.isError():
+            print("Ошибка при чтении катушек")
+        else:
+            print(f"Значение катушки: {result.bits}")
+        
+        client.close()
     else:
         print("Не удалось подключиться к порту.")
-except PermissionError as e:
-    print(f'Ошибка доступа к порту: {e}')
-except Exception as e:
-    print(f'Ошибка подключения: {e}')
 
-STATUS_REGISTER = 0  # Адрес регистра, где хранится статус
-
-@app.route('/modbus-status', methods=['GET'])
-def modbus_status():
-    try:
-        result = client.read_holding_registers(STATUS_REGISTER, 1)
-        if result.isError():
-            return jsonify({'error': 'Не удалось прочитать данные с Arduino'}), 500
-        else:
-            connected = bool(result.registers[0])
-            return jsonify({'connected': connected})
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/')
-def index():
-    return '''
-    <!DOCTYPE html>
-    <html lang="ru">
-    <head>
-      <meta charset="UTF-8">
-      <meta name="viewport" content="width=device-width, initial-scale=1.0">
-      <title>Статус пина</title>
-      <style>
-        #status-circle {
-          width: 100px;
-          height: 100px;
-          border-radius: 50%;
-          background-color: red;
-        }
-      </style>
-    </head>
-    <body>
-      <div id="status-circle"></div>
-
-      <script>
-        function updateStatus() {
-          fetch('/modbus-status')
-            .then(response => response.json())
-            .then(data => {
-              const circle = document.getElementById('status-circle');
-              if (data.connected) {
-                circle.style.backgroundColor = 'green';
-              } else {
-                circle.style.backgroundColor = 'red';
-              }
-            });
-        }
-
-        setInterval(updateStatus, 1000);  // Проверка статуса каждую секунду
-      </script>
-    </body>
-    </html>
-    '''
-
-if __name__ == '__main__':
-    app.run(debug=True, host='0.0.0.0')
+if __name__ == "__main__":
+    print(f"Сервер запущен на порту {PORT}")
+    app.run(host="0.0.0.0", port=5000, debug=True)

Сервер1.py

@@ -0,0 +1,82 @@
+from flask import Flask, jsonify
+from pymodbus.client.sync import ModbusSerialClient as ModbusClient
+import threading
+
+app = Flask(__name__)
+
+# Настройка Modbus
+client = ModbusClient( port='COM4', baudrate=9600, timeout=1)
+client.close()
+client.connect()
+
+# Хранилище данных состояния пина
+pin_status = {"state": 0}
+
+# Функция для обновления состояния пина с помощью Modbus
+def read_modbus():
+    global pin_status
+    while True:
+        result = client.read_holding_registers(0, 1, unit=1)  # Чтение первого регистра
+        if result.isError():
+            print("Ошибка чтения данных Modbus")
+        else:
+            pin_status["state"] = result.registers[0]  # 0 - это состояние пина (0 или 1)
+            print(f"Регистр успешно считан: {result.registers}")
+
+# Запуск потока для чтения данных
+modbus_thread = threading.Thread(target=read_modbus)
+modbus_thread.daemon = True
+modbus_thread.start()
+
+# Эндпоинт для отдачи состояния пина
+@app.route('/state', methods=['GET'])
+def get_pin_state():
+    return jsonify(pin_status)
+
+# Главная страница для отображения круга
+@app.route('/')
+def index():
+    return '''
+        <html>
+            <head>
+                <style>
+                    .circle {
+                        width: 100px;
+                        height: 100px;
+                        border-radius: 50%;
+                        margin: 50px;
+                        transition: background-color 0.5s ease;
+                    }
+                    .green {
+                        background-color: green;
+                    }
+                    .red {
+                        background-color: red;
+                    }
+                </style>
+            </head>
+            <body>
+                <div id="circle" class="circle"></div>
+                <script>
+                    function updateCircleColor() {
+                        fetch('/state')
+                            .then(response => response.json())
+                            .then(data => {
+                                const circle = document.getElementById('circle');
+                                if (data.state === 0) {
+                                    circle.className = 'circle green';  // Зеленый цвет
+                                } else {
+                                    circle.className = 'circle red';  // Красный цвет
+                                }
+                            });
+                    }
+
+                    setInterval(updateCircleColor, 1000);  // Обновляем состояние каждую секунду
+                    updateCircleColor();  // Первоначальный вызов
+                </script>
+            </body>
+        </html>
+    '''
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)