1Общая структура программного обеспечения
 2├── Базовые функции роботов
 3│   ├── Управление движением
 4│   │   ├── Прямолинейное движение
 5│   │   ├── Повороты
 6│   │   └── Управление скоростью
 7│   ├── Работа с сенсорами
 8│   │   ├── Считывание значений с датчиков
 9│   │   ├── Обработка данных
10│   │   └── Интерпретация сенсорной информации
11│   └── Управление исполнительными механизмами
12│       ├── Управление манипуляторами
13│       ├── Управление захватами
14│       └── Управление специализированными механизмами
15├── Коммуникационные модули
16│   ├── Отправка сообщений
17│   │   ├── Форматирование данных
18│   │   ├── Кодирование информации
19│   │   └── Обеспечение надежности передачи
20│   ├── Прием сообщений
21│   │   ├── Декодирование информации
22│   │   ├── Проверка целостности данных
23│   │   └── Обработка полученных команд
24│   └── Протокол взаимодействия
25│       ├── Инициализация связи
26│       ├── Поддержание соединения
27│       └── Разрешение конфликтов
28└── Алгоритмы координации
29    ├── Распределение задач
30    │   ├── Анализ текущей ситуации
31    │   ├── Определение приоритетов
32    │   └── Назначение задач роботам
33    ├── Синхронизация действий
34    │   ├── Временная синхронизация
35    │   ├── Координация в пространстве
36    │   └── Обработка критических ситуаций
37    └── Оптимизация совместной работы
38        ├── Минимизация затрачиваемых ресурсов
39        ├── Повышение эффективности выполнения задач
40        └── Адаптация к изменениям среды

  1// Пример кода для организации простой коммуникации между роботами с использованием Bluetooth
  2// Данный код является учебным примером и требует адаптации под конкретное оборудование
  3
  4#include <SoftwareSerial.h>
  5
  6// Пины для Bluetooth модуля
  7#define BT_RX 10
  8#define BT_TX 11
  9
 10// Создаем объект для работы с Bluetooth
 11SoftwareSerial bluetoothSerial(BT_RX, BT_TX);
 12
 13// Константы для типов сообщений
 14#define MSG_COMMAND 'C'  // Команда
 15#define MSG_DATA 'D'     // Данные
 16#define MSG_ACK 'A'      // Подтверждение
 17#define MSG_ERROR 'E'    // Ошибка
 18
 19// Буфер для приема сообщений
 20char messageBuffer[64];
 21int bufferIndex = 0;
 22
 23// Структура для хранения команд и данных
 24struct RobotMessage {
 25  char type;
 26  int commandId;
 27  int parameter1;
 28  int parameter2;
 29  bool needAck;
 30};
 31
 32// Функция инициализации коммуникации
 33void initCommunication() {
 34  bluetoothSerial.begin(9600);
 35  Serial.println("Communication initialized");
 36}
 37
 38// Функция отправки сообщения
 39void sendMessage(char type, int commandId, int param1, int param2, bool needAck) {
 40  // Форматируем сообщение: тип,commandId,param1,param2,needAck
 41  String message = String(type) + "," + String(commandId) + "," + 
 42                   String(param1) + "," + String(param2) + "," + 
 43                   (needAck ? "1" : "0") + "\n";
 44                   
 45  bluetoothSerial.print(message);
 46  
 47  Serial.print("Sent: ");
 48  Serial.print(message);
 49}
 50
 51// Функция отправки команды
 52void sendCommand(int commandId, int param1, int param2, bool needAck) {
 53  sendMessage(MSG_COMMAND, commandId, param1, param2, needAck);
 54}
 55
 56// Функция отправки данных
 57void sendData(int dataId, int value1, int value2, bool needAck) {
 58  sendMessage(MSG_DATA, dataId, value1, value2, needAck);
 59}
 60
 61// Функция отправки подтверждения
 62void sendAcknowledgement(int commandId) {
 63  sendMessage(MSG_ACK, commandId, 0, 0, false);
 64}
 65
 66// Функция отправки сообщения об ошибке
 67void sendError(int errorCode, int commandId) {
 68  sendMessage(MSG_ERROR, commandId, errorCode, 0, false);
 69}
 70
 71// Функция обработки входящего сообщения
 72void processMessage(const String& message) {
 73  // Парсинг сообщения
 74  int commaPos1 = message.indexOf(',');
 75  int commaPos2 = message.indexOf(',', commaPos1 + 1);
 76  int commaPos3 = message.indexOf(',', commaPos2 + 1);
 77  int commaPos4 = message.indexOf(',', commaPos3 + 1);
 78  
 79  if (commaPos1 < 0 || commaPos2 < 0 || commaPos3 < 0 || commaPos4 < 0) {
 80    Serial.println("Error parsing message: invalid format");
 81    return;
 82  }
 83  
 84  // Извлекаем части сообщения
 85  char type = message.charAt(0);
 86  int commandId = message.substring(commaPos1 + 1, commaPos2).toInt();
 87  int param1 = message.substring(commaPos2 + 1, commaPos3).toInt();
 88  int param2 = message.substring(commaPos3 + 1, commaPos4).toInt();
 89  bool needAck = (message.substring(commaPos4 + 1).toInt() == 1);
 90  
 91  // Создаем структуру сообщения
 92  RobotMessage msg = {type, commandId, param1, param2, needAck};
 93  
 94  // Обрабатываем сообщение в зависимости от типа
 95  switch (type) {
 96    case MSG_COMMAND:
 97      processCommand(msg);
 98      break;
 99    case MSG_DATA:
100      processData(msg);
101      break;
102    case MSG_ACK:
103      processAcknowledgement(msg);
104      break;
105    case MSG_ERROR:
106      processError(msg);
107      break;
108    default:
109      Serial.println("Unknown message type");
110  }
111  
112  // Отправляем подтверждение, если оно требуется
113  if (needAck) {
114    sendAcknowledgement(commandId);
115  }
116}
117
118// Функция обработки входящей команды
119void processCommand(const RobotMessage& msg) {
120  Serial.print("Command received: ID=");
121  Serial.print(msg.commandId);
122  Serial.print(", Param1=");
123  Serial.print(msg.parameter1);
124  Serial.print(", Param2=");
125  Serial.println(msg.parameter2);
126  
127  // Здесь код для выполнения команды в зависимости от commandId
128  // Например:
129  switch (msg.commandId) {
130    case 1: // Движение
131      moveRobot(msg.parameter1, msg.parameter2);
132      break;
133    case 2: // Взаимодействие с объектом
134      interactWithObject(msg.parameter1);
135      break;
136    // Другие команды...
137    default:
138      Serial.println("Unknown command ID");
139  }
140}
141
142// Обработка данных
143void processData(const RobotMessage& msg) {
144  Serial.print("Data received: ID=");
145  Serial.print(msg.commandId);
146  Serial.print(", Value1=");
147  Serial.print(msg.parameter1);
148  Serial.print(", Value2=");
149  Serial.println(msg.parameter2);
150  
151  // Здесь код для обработки полученных данных
152}
153
154// Обработка подтверждения
155void processAcknowledgement(const RobotMessage& msg) {
156  Serial.print("Acknowledgement for command ID=");
157  Serial.println(msg.commandId);
158  
159  // Здесь код для обработки подтверждения
160}
161
162// Обработка ошибки
163void processError(const RobotMessage& msg) {
164  Serial.print("Error for command ID=");
165  Serial.print(msg.commandId);
166  Serial.print(", Error code=");
167  Serial.println(msg.parameter1);
168  
169  // Здесь код для обработки ошибки
170}
171
172// Проверка входящих сообщений
173void checkIncomingMessages() {
174  while (bluetoothSerial.available()) {
175    char c = bluetoothSerial.read();
176    
177    // Если конец строки, обрабатываем сообщение
178    if (c == '\n') {
179      messageBuffer[bufferIndex] = '\0'; // Добавляем конец строки
180      processMessage(String(messageBuffer));
181      bufferIndex = 0; // Сбрасываем индекс буфера
182    } else if (bufferIndex < 63) { // Проверка переполнения буфера
183      messageBuffer[bufferIndex++] = c;
184    }
185  }
186}
187
188// Примеры функций управления роботом (должны быть реализованы в зависимости от конкретной платформы)
189void moveRobot(int direction, int speed) {
190  // Код для управления движением робота
191  Serial.print("Moving robot: Direction=");
192  Serial.print(direction);
193  Serial.print(", Speed=");
194  Serial.println(speed);
195}
196
197void interactWithObject(int actionType) {
198  // Код для взаимодействия с объектами
199  Serial.print("Interacting with object: Action=");
200  Serial.println(actionType);
201}
202
203void setup() {
204  Serial.begin(9600);
205  initCommunication();
206  
207  // Другие инициализации...
208}
209
210void loop() {
211  // Проверяем входящие сообщения
212  checkIncomingMessages();
213  
214  // Другие задачи робота...
215  
216  delay(10); // Небольшая задержка для стабильности
217}

  1# Пример кода на Python для координации движения нескольких роботов
  2# Данный код является учебным примером и должен быть адаптирован к конкретной платформе
  3
  4import math
  5import time
  6
  7# Класс для представления положения робота
  8class Position:
  9    def __init__(self, x=0, y=0, angle=0):
 10        self.x = x
 11        self.y = y
 12        self.angle = angle
 13    
 14    def distance_to(self, other_position):
 15        """Рассчитывает расстояние до другой позиции"""
 16        return math.sqrt((self.x - other_position.x)**2 + (self.y - other_position.y)**2)
 17    
 18    def angle_to(self, other_position):
 19        """Рассчитывает угол до другой позиции"""
 20        return math.degrees(math.atan2(other_position.y - self.y, other_position.x - self.x))
 21
 22# Класс для представления робота
 23class Robot:
 24    def __init__(self, robot_id, initial_position=Position()):
 25        self.id = robot_id
 26        self.position = initial_position
 27        self.target_position = None
 28        self.speed = 0
 29        self.state = "idle"  # idle, moving, working
 30        self.task = None
 31    
 32    def set_target(self, target_position):
 33        """Устанавливает целевую позицию для робота"""
 34        self.target_position = target_position
 35        self.state = "moving"
 36        
 37    def update_position(self, new_position):
 38        """Обновляет текущую позицию робота"""
 39        self.position = new_position
 40        
 41        # Проверяем, достиг ли робот целевой позиции
 42        if (self.target_position and 
 43            self.position.distance_to(self.target_position) < 0.1):
 44            self.state = "idle"
 45            self.target_position = None
 46            return True
 47        return False
 48    
 49    def assign_task(self, task):
 50        """Назначает задачу роботу"""
 51        self.task = task
 52        self.state = "working"
 53    
 54    def complete_task(self):
 55        """Отмечает задачу как выполненную"""
 56        self.task = None
 57        self.state = "idle"
 58
 59# Класс для координации группы роботов
 60class RobotCoordinator:
 61    def __init__(self):
 62        self.robots = {}
 63        self.tasks = []
 64    
 65    def add_robot(self, robot):
 66        """Добавляет робота в систему координации"""
 67        self.robots[robot.id] = robot
 68    
 69    def add_task(self, task):
 70        """Добавляет задачу в очередь"""
 71        self.tasks.append(task)
 72    
 73    def get_idle_robots(self):
 74        """Возвращает список свободных роботов"""
 75        return [robot for robot in self.robots.values() if robot.state == "idle"]
 76    
 77    def assign_tasks(self):
 78        """Распределяет задачи между свободными роботами"""
 79        idle_robots = self.get_idle_robots()
 80        
 81        while idle_robots and self.tasks:
 82            task = self.tasks.pop(0)  # Берем первую задачу из очереди
 83            
 84            # Находим ближайшего робота к месту выполнения задачи
 85            nearest_robot = None
 86            min_distance = float('inf')
 87            
 88            for robot in idle_robots:
 89                distance = robot.position.distance_to(task.position)
 90                if distance < min_distance:
 91                    min_distance = distance
 92                    nearest_robot = robot
 93            
 94            if nearest_robot:
 95                nearest_robot.set_target(task.position)
 96                nearest_robot.assign_task(task)
 97                idle_robots.remove(nearest_robot)
 98                print(f"Робот {nearest_robot.id} назначен на задачу {task.id} в позиции ({task.position.x}, {task.position.y})")
 99    
100    def coordinate_movement(self):
101        """Координирует движение роботов для избежания столкновений"""
102        moving_robots = [robot for robot in self.robots.values() if robot.state == "moving"]
103        
104        # Проверяем каждую пару движущихся роботов
105        for i in range(len(moving_robots)):
106            for j in range(i + 1, len(moving_robots)):
107                robot1 = moving_robots[i]
108                robot2 = moving_robots[j]
109                
110                # Если роботы находятся слишком близко друг к другу
111                if robot1.position.distance_to(robot2.position) < 2.0:
112                    # Вычисляем векторы направления движения
113                    vector1 = (robot1.target_position.x - robot1.position.x, 
114                              robot1.target_position.y - robot1.position.y)
115                    vector2 = (robot2.target_position.x - robot2.position.x, 
116                              robot2.target_position.y - robot2.position.y)
117                    
118                    # Если роботы движутся навстречу друг другу
119                    dot_product = vector1[0]*vector2[0] + vector1[1]*vector2[1]
120                    if dot_product < 0:
121                        # Определяем, какой робот должен уступить дорогу
122                        # Например, по приоритету задачи или ID робота
123                        if robot1.id > robot2.id:
124                            self.adjust_path(robot1, robot2)
125                        else:
126                            self.adjust_path(robot2, robot1)
127    
128    def adjust_path(self, robot, obstacle_robot):
129        """Корректирует путь робота для избежания столкновения"""
130        # Временно изменяем целевую точку, чтобы обойти препятствие
131        # Это упрощенный пример, в реальности нужен более сложный алгоритм планирования пути
132        
133        # Вычисляем вектор от препятствия к роботу
134        dx = robot.position.x - obstacle_robot.position.x
135        dy = robot.position.y - obstacle_robot.position.y
136        
137        # Нормализуем вектор и создаем смещение
138        length = math.sqrt(dx*dx + dy*dy)
139        if length > 0:
140            dx = dx / length * 3.0  # Смещение на 3 единицы
141            dy = dy / length * 3.0
142        
143        # Создаем промежуточную точку в стороне от препятствия
144        intermediate_position = Position(
145            obstacle_robot.position.x + dx,
146            obstacle_robot.position.y + dy
147        )
148        
149        # Временно устанавливаем эту точку как целевую
150        original_target = robot.target_position
151        robot.set_target(intermediate_position)
152        
153        # Запоминаем оригинальную точку, чтобы вернуться к ней позже
154        # В реальной системе нужно сохранять весь маршрут
155        print(f"Робот {robot.id} корректирует путь для избежания столкновения с роботом {obstacle_robot.id}")
156
157# Класс для представления задачи
158class Task:
159    def __init__(self, task_id, position, priority=0):
160        self.id = task_id
161        self.position = position
162        self.priority = priority
163        self.status = "pending"  # pending, assigned, completed
164
165# Пример использования
166if __name__ == "__main__":
167    # Создаем координатора
168    coordinator = RobotCoordinator()
169    
170    # Создаем роботов
171    robot1 = Robot(1, Position(0, 0))
172    robot2 = Robot(2, Position(10, 0))
173    
174    # Добавляем роботов в систему координации
175    coordinator.add_robot(robot1)
176    coordinator.add_robot(robot2)
177    
178    # Создаем задачи
179    task1 = Task(1, Position(5, 5))
180    task2 = Task(2, Position(8, 8))
181    
182    # Добавляем задачи в очередь
183    coordinator.add_task(task1)
184    coordinator.add_task(task2)
185    
186    # Распределяем задачи
187    coordinator.assign_tasks()
188    
189    # Имитация движения и координации (в реальности это было бы в цикле)
190    for i in range(5):
191        print(f"\nИтерация {i+1}:")
192        
193        # Обновляем позиции роботов (в реальности это было бы фактическое движение)
194        if robot1.state == "moving":
195            robot1.update_position(Position(
196                robot1.position.x + (robot1.target_position.x - robot1.position.x) * 0.2,
197                robot1.position.y + (robot1.target_position.y - robot1.position.y) * 0.2
198            ))
199            print(f"Робот 1: позиция ({robot1.position.x:.1f}, {robot1.position.y:.1f})")
200        
201        if robot2.state == "moving":
202            robot2.update_position(Position(
203                robot2.position.x + (robot2.target_position.x - robot2.position.x) * 0.2,
204                robot2.position.y + (robot2.target_position.y - robot2.position.y) * 0.2
205            ))
206            print(f"Робот 2: позиция ({robot2.position.x:.1f}, {robot2.position.y:.1f})")
207        
208        # Координируем движение для избежания столкновений
209        coordinator.coordinate_movement()
210        
211        # Имитация завершения задач
212        for robot in [robot1, robot2]:
213            if (robot.task and robot.state == "working" and 
214                robot.position.distance_to(robot.task.position) < 0.5):
215                print(f"Робот {robot.id} выполнил задачу {robot.task.id}")
216                robot.complete_task()
217        
218        # Назначаем новые задачи, если они есть
219        coordinator.assign_tasks()
220        
221        # Задержка для наглядности
222        time.sleep(1)

 1ПЛАНИРОВАНИЕ СТРУКТУРЫ ПРОГРАММЫ
 2"ВЗАИМОДЕЙСТВИЕ РОБОТОВ"
 3
 4Группа: _______   Участники: _____________________________
 5
 61. МОДУЛИ РОБОТА 1 (название робота): _________________
 7
 8   1.1. Базовые функции:
 9   
10   | Название функции | Описание | Входные параметры | Выходные параметры |
11   |-----------------|----------|------------------|-------------------|
12   |                 |          |                  |                   |
13   |                 |          |                  |                   |
14   
15   1.2. Коммуникационные функции:
16   
17   | Название функции | Описание | Входные параметры | Выходные параметры |
18   |-----------------|----------|------------------|-------------------|
19   |                 |          |                  |                   |
20   |                 |          |                  |                   |
21   
22   1.3. Функции координации:
23   
24   | Название функции | Описание | Входные параметры | Выходные параметры |
25   |-----------------|----------|------------------|-------------------|
26   |                 |          |                  |                   |
27   |                 |          |                  |                   |
28
292. МОДУЛИ РОБОТА 2 (название робота): _________________
30
31   2.1. Базовые функции:
32   
33   | Название функции | Описание | Входные параметры | Выходные параметры |
34   |-----------------|----------|------------------|-------------------|
35   |                 |          |                  |                   |
36   |                 |          |                  |                   |
37   
38   2.2. Коммуникационные функции:
39   
40   | Название функции | Описание | Входные параметры | Выходные параметры |
41   |-----------------|----------|------------------|-------------------|
42   |                 |          |                  |                   |
43   |                 |          |                  |                   |
44   
45   2.3. Функции координации:
46   
47   | Название функции | Описание | Входные параметры | Выходные параметры |
48   |-----------------|----------|------------------|-------------------|
49   |                 |          |                  |                   |
50   |                 |          |                  |                   |
51
523. ПРОТОКОЛ КОММУНИКАЦИИ:
53
54   3.1. Формат сообщений:
55   _________________________________________________
56   _________________________________________________
57   
58   3.2. Типы сообщений:
59   
60   | Тип сообщения | Код | Формат данных | Описание |
61   |--------------|-----|--------------|----------|
62   |              |     |              |          |
63   |              |     |              |          |
64   
65   3.3. Обработка ошибок:
66   _________________________________________________
67   _________________________________________________
68
694. АЛГОРИТМЫ КООРДИНАЦИИ:
70
71   4.1. Распределение задач:
72   _________________________________________________
73   _________________________________________________
74   
75   4.2. Синхронизация действий:
76   _________________________________________________
77   _________________________________________________
78   
79   4.3. Разрешение конфликтов:
80   _________________________________________________
81   _________________________________________________
82
835. ЗАВИСИМОСТИ МЕЖДУ МОДУЛЯМИ:
84
85   [Место для диаграммы зависимостей модулей]
86
876. ПОРЯДОК РАЗРАБОТКИ И ТЕСТИРОВАНИЯ:
88
89   | Этап | Описание | Ответственный | Критерии готовности |
90   |------|----------|--------------|-------------------|
91   |      |          |              |                   |
92   |      |          |              |                   |
93   |      |          |              |                   |

 1Фамилия, имя: _________________________
 2Группа: _______
 3
 4Оценка программного обеспечения:
 5
 61. Что получилось реализовать в программном обеспечении?
 7_________________________________________________
 8_________________________________________________
 9_________________________________________________
10
112. Какие проблемы остались нерешенными?
12_________________________________________________
13_________________________________________________
14_________________________________________________
15
163. Какие улучшения можно внести в программы?
17_________________________________________________
18_________________________________________________
19_________________________________________________
20
214. Какие математические алгоритмы мы применили?
22_________________________________________________
23_________________________________________________
24_________________________________________________
25
265. Как мы реализовали коммуникацию между роботами?
27_________________________________________________
28_________________________________________________
29_________________________________________________
30
316. Мой личный вклад в программирование:
32_________________________________________________
33_________________________________________________
34_________________________________________________
35
36Самая сложная проблема, которую мне удалось решить:
37_________________________________________________
38_________________________________________________
39
40Степень моей удовлетворенности результатом (от 1 до 10): _______