🔬 Физика • 📐 Математика • 💻 Информатика • 🛠️ Технология
6 класс • Технология • 80 минут
👨🏫 Учитель: Ахметов Рустам
🏫 Школа: ГБОУ № 1362
📅 Дата: 2025-06-14
🎯 Цель: Создать и запрограммировать виртуальный транспортный робот!
Основная транспортная задача:
Создать автономную виртуальную модель транспортного робота для логистических операций в складском комплексе с возможностью адаптации алгоритмов под различные сценарии грузоперевозок.
Техническая спецификация робота:
| Параметр | Значение | Обоснование |
|---|---|---|
| Грузоподъемность | 2.0 кг | Оптимальное соотношение мощности и энергопотребления |
| Габариты (Д×Ш×В) | 300×200×150 мм | Соответствие стандартным проходам |
| Максимальная скорость | 0.5 м/с | Безопасность и точность позиционирования |
| Точность позиционирования | ±20 мм | Требования складской логистики |
| Время автономной работы | 120 мин | Полный рабочий цикл |
| Угол преодолеваемого подъема | 15° | Работа на наклонных поверхностях |
Функциональные требования к системе управления:
Кинематическая модель дифференциального привода:
Для робота с дифференциальным приводом основные кинематические уравнения:
\[\begin{cases} v = \frac{v_L + v_R}{2} \\ \omega = \frac{v_R - v_L}{L} \\ \dot{x} = v \cos(\theta) \\ \dot{y} = v \sin(\theta) \\ \dot{\theta} = \omega \end{cases}\]где:
Динамическая модель с учетом инерции:
\[\begin{cases} m \ddot{x} = F_x - F_{friction,x} \\ m \ddot{y} = F_y - F_{friction,y} \\ I \ddot{\theta} = \tau - \tau_{friction} \end{cases}\]где:
Момент инерции составного тела:
\[I_{total} = I_{chassis} + I_{cargo} + m_{cargo} \cdot d^2\]где $d$ - расстояние от центра масс груза до оси вращения робота.
Масса и распределение массы:
\[\vec{r}_{cm} = \frac{\sum_{i} m_i \vec{r}_i}{\sum_{i} m_i}\]Компоненты массы робота:
Моменты инерции компонентов:
Для прямоугольного корпуса: \[I_{z} = \frac{m}{12}(a^2 + b^2)\]
Для цилиндрических колес: \[I_{wheel} = \frac{1}{2}m_{wheel}r^2\]
Коэффициенты трения:
Модель трения Кулона: \[F_{friction} = \begin{cases} \mu_s \cdot N & \text{при } v = 0 \\ \mu_k \cdot N & \text{при } v > 0 \end{cases}\]
Типичные значения для резина-бетон:
PROTO-определение транспортного робота:
1PROTO TransportRobot [
2 field SFVec3f translation 0 0 0.05
3 field SFRotation rotation 0 1 0 0
4 field SFString name "transport_robot"
5 field MFNode cargoSensor []
6 field SFFloat maxVelocity 10
7 field SFColor bodyColor 0.3 0.3 0.8
8]
9{
10 Robot {
11 translation IS translation
12 rotation IS rotation
13 name IS name
14 children [
15 # Основной корпус робота
16 DEF MAIN_BODY Transform {
17 children [
18 Shape {
19 geometry Box { size 0.30 0.20 0.08 }
20 appearance PBRAppearance {
21 baseColor IS bodyColor
22 metallic 0.3
23 roughness 0.4
24 }
25 }
26 ]
27 }
28
29 # Левое колесо с мотором
30 DEF LEFT_WHEEL HingeJoint {
31 jointParameters HingeJointParameters {
32 axis 0 1 0
33 anchor -0.075 0.12 0
34 dampingConstant 0.1
35 staticFriction 0.9
36 kineticFriction 0.7
37 }
38 device RotationalMotor {
39 name "left_motor"
40 maxVelocity IS maxVelocity
41 maxTorque 2.0
42 acceleration 5.0
43 }
44 device PositionSensor {
45 name "left_encoder"
46 resolution 0.00628 # 1000 импульсов на оборот
47 }
48 endPoint DEF LEFT_WHEEL_SOLID Solid {
49 translation -0.075 0.12 0
50 children [
51 DEF WHEEL_SHAPE Shape {
52 geometry Cylinder {
53 height 0.025
54 radius 0.04
55 }
56 appearance PBRAppearance {
57 baseColor 0.1 0.1 0.1
58 roughness 0.8
59 }
60 }
61 ]
62 physics Physics {
63 density 1200
64 bounce 0.1
65 }
66 boundingObject USE WHEEL_SHAPE
67 }
68 }
69 ]
70
71 # Физические свойства робота
72 physics Physics {
73 density -1
74 mass 1.5
75 centerOfMass [0 0 0.02]
76 inertiaMatrix [
77 0.0045 0.0045 0.0075 # Ix, Iy, Iz
78 0 0 0 # Ixy, Ixz, Iyz
79 ]
80 }
81 }
82}
Расчет момента инерции корпуса:
\[I_z = \frac{m}{12}(L^2 + W^2) = \frac{1.5}{12}(0.30^2 + 0.20^2) = 0.0075 \text{ кг⋅м}^2\]Ультразвуковой датчик с детальной конфигурацией:
1DEF FRONT_SONAR DistanceSensor {
2 translation 0.12 0 0.06
3 rotation 0 1 0 0
4 name "front_sonar"
5 lookupTable [
6 0.02 0.02 0.001 # минимальная дистанция с шумом
7 0.05 0.05 0.001 # ближняя зона
8 1.00 1.00 0.01 # рабочая зона
9 4.00 4.00 0.05 # максимальная дистанция
10 4.01 4.01 0.1 # зона нечувствительности
11 ]
12 type "sonar"
13 numberOfRays 5
14 aperture 0.52 # 30° в радианах
15 gaussianWidth 0.1
16 resolution 0.01
17}
Математическая модель ультразвукового датчика:
Время распространения сигнала: \[t = \frac{2d}{v_{sound}}\]
где скорость звука зависит от температуры: \[v_{sound} = 331.3 + 0.606 \cdot T_{celsius}\]
Погрешность измерения расстояния:
\[\sigma_d = \sqrt{(\frac{\partial d}{\partial t} \sigma_t)^2 + (\frac{\partial d}{\partial v} \sigma_v)^2}\]где:
Лидар для точной навигации:
1DEF NAVIGATION_LIDAR Lidar {
2 translation 0 0 0.12
3 name "nav_lidar"
4 horizontalResolution 360
5 fieldOfView 6.283185 # 2π радиан (360°)
6 numberOfLayers 1
7 near 0.05
8 far 8.0
9 type "rotating"
10 rotatingHead Solid {
11 children [
12 Shape {
13 geometry Cylinder { height 0.02 radius 0.015 }
14 }
15 ]
16 }
17 defaultFrequency 10 # 10 Гц
18 minFrequency 5
19 maxFrequency 25
20}
Обработка данных лидара:
Преобразование полярных координат в декартовы: \[\begin{cases} x_i = r_i \cos(\theta_i) \\ y_i = r_i \sin(\theta_i) \end{cases}\]
где $\theta_i = \frac{2\pi i}{N}$, $N$ = 360 (количество лучей)
Алгоритм обнаружения препятствий:
\[obstacle(i) = \begin{cases} 1 & \text{если } r_i < r_{threshold} \\ 0 & \text{иначе} \end{cases}\]Модель электродвигателя постоянного тока:
Уравнение крутящего момента: \[\tau_m = K_t \cdot I_a - \tau_{friction}\]
Уравнение ЭДС: \[E = K_e \cdot \omega\]
Электрическое уравнение цепи якоря: \[V = I_a \cdot R_a + L_a \frac{dI_a}{dt} + E\]
где:
Передаточная функция мотора:
\[G(s) = \frac{\Omega(s)}{V(s)} = \frac{K_t}{(J \cdot s + B)(L_a \cdot s + R_a) + K_t \cdot K_e}\]где:
Иерархическая структура управления:
1Уровень 1: Планирование миссии
2├── Глобальное планирование пути
3├── Распределение задач
4└── Мониторинг выполнения
5
6Уровень 2: Навигация и локализация
7├── SLAM (одновременная локализация и картографирование)
8├── Локальное планирование пути
9└── Избежание препятствий
10
11Уровень 3: Управление движением
12├── Кинематическое управление
13├── Динамическое управление
14└── Управление приводами
15
16Уровень 4: Сенсорная обработка
17├── Обработка данных лидара
18├── Обработка ультразвуковых датчиков
19└── Фильтрация и предобработка сигналов
ПИД-регулятор для управления скоростью:
\[u(t) = K_p \cdot e(t) + K_i \int_0^t e(\tau) d\tau + K_d \frac{de(t)}{dt}\]Дискретная реализация: \[u_k = K_p \cdot e_k + K_i \sum_{i=0}^k e_i \Delta t + K_d \frac{e_k - e_{k-1}}{\Delta t}\]
Настройка коэффициентов ПИД:
1class PIDController:
2 def __init__(self, kp, ki, kd, dt):
3 self.kp = kp
4 self.ki = ki
5 self.kd = kd
6 self.dt = dt
7 self.prev_error = 0.0
8 self.integral = 0.0
9
10 def compute(self, setpoint, measured_value):
11 error = setpoint - measured_value
12
13 # Пропорциональная составляющая
14 proportional = self.kp * error
15
16 # Интегральная составляющая с ограничением
17 self.integral += error * self.dt
18 self.integral = max(-10, min(10, self.integral)) # anti-windup
19 integral = self.ki * self.integral
20
21 # Дифференциальная составляющая
22 derivative = self.kd * (error - self.prev_error) / self.dt
23
24 # Общий выход
25 output = proportional + integral + derivative
26 self.prev_error = error
27
28 return output
Алгоритм A для глобального планирования:*
Функция стоимости: \[f(n) = g(n) + h(n)\]
где:
Эвристическая функция (Евклидово расстояние): \[h(n) = \sqrt{(x_{goal} - x_n)^2 + (y_{goal} - y_n)^2}\]
1import heapq
2import math
3
4class AStarPlanner:
5 def __init__(self, grid_map, resolution=0.1):
6 self.grid_map = grid_map
7 self.resolution = resolution
8
9 def heuristic(self, node1, node2):
10 """Евклидово расстояние как эвристика"""
11 return math.sqrt((node1[0] - node2[0])**2 + (node1[1] - node2[1])**2)
12
13 def get_neighbors(self, node):
14 """Получение соседних узлов (8-связность)"""
15 neighbors = []
16 for dx in [-1, 0, 1]:
17 for dy in [-1, 0, 1]:
18 if dx == 0 and dy == 0:
19 continue
20 neighbor = (node[0] + dx, node[1] + dy)
21 if self.is_valid(neighbor):
22 neighbors.append(neighbor)
23 return neighbors
24
25 def plan_path(self, start, goal):
26 """Основной алгоритм A*"""
27 open_set = [(0, start)]
28 came_from = {}
29 g_score = {start: 0}
30 f_score = {start: self.heuristic(start, goal)}
31
32 while open_set:
33 current = heapq.heappop(open_set)[1]
34
35 if current == goal:
36 return self.reconstruct_path(came_from, current)
37
38 for neighbor in self.get_neighbors(current):
39 tentative_g = g_score[current] + self.distance(current, neighbor)
40
41 if neighbor not in g_score or tentative_g < g_score[neighbor]:
42 came_from[neighbor] = current
43 g_score[neighbor] = tentative_g
44 f_score[neighbor] = tentative_g + self.heuristic(neighbor, goal)
45 heapq.heappush(open_set, (f_score[neighbor], neighbor))
46
47 return None # Путь не найден
Алгоритм локального планирования (Dynamic Window Approach):
Функция оценки траектории: \[G(v, \omega) = \alpha \cdot heading(v, \omega) + \beta \cdot distance(v, \omega) + \gamma \cdot velocity(v, \omega)\]
где:
Ограничения скорости: \[V_s = \{(v, \omega) | v_{min} \leq v \leq v_{max}, \omega_{min} \leq \omega \leq \omega_{max}\}\]
Ограничения ускорения: \[V_a = \{(v, \omega) | v_{current} - a_{max} \Delta t \leq v \leq v_{current} + a_{max} \Delta t\}\]
1class DynamicWindowApproach:
2 def __init__(self, max_v=0.5, max_omega=1.0, max_accel=1.0):
3 self.max_v = max_v
4 self.max_omega = max_omega
5 self.max_accel = max_accel
6 self.dt = 0.1
7
8 def predict_trajectory(self, v, omega, time_horizon=3.0):
9 """Предсказание траектории на заданный горизонт"""
10 trajectory = []
11 x, y, theta = 0, 0, 0
12
13 steps = int(time_horizon / self.dt)
14 for _ in range(steps):
15 x += v * math.cos(theta) * self.dt
16 y += v * math.sin(theta) * self.dt
17 theta += omega * self.dt
18 trajectory.append((x, y, theta))
19
20 return trajectory
21
22 def evaluate_trajectory(self, trajectory, goal, obstacles):
23 """Оценка качества траектории"""
24 if not trajectory:
25 return -float('inf')
26
27 # Компонент направленности к цели
28 final_pos = trajectory[-1]
29 goal_angle = math.atan2(goal[1] - final_pos[1], goal[0] - final_pos[0])
30 heading_score = math.cos(goal_angle - final_pos[2])
31
32 # Компонент безопасности (расстояние до препятствий)
33 min_distance = float('inf')
34 for point in trajectory:
35 for obstacle in obstacles:
36 dist = math.sqrt((point[0] - obstacle[0])**2 + (point[1] - obstacle[1])**2)
37 min_distance = min(min_distance, dist)
38
39 if min_distance < 0.2: # Слишком близко к препятствию
40 return -float('inf')
41
42 distance_score = min_distance
43
44 # Общая оценка
45 return 0.5 * heading_score + 0.3 * distance_score + 0.2 * len(trajectory)
Кинематика простого захвата:
Для двухпальцевого захвата угол открытия: \[\theta_{grip} = 2 \arcsin\left(\frac{w_{object}}{2L_{finger}}\right)\]
где:
Силовое управление захватом:
Требуемая сила сжатия: \[F_{grip} = \frac{m_{object} \cdot g \cdot \sin(\alpha)}{\mu \cdot \cos(\alpha)} + F_{safety}\]
где:
1class CargoManipulator:
2 def __init__(self, max_grip_force=50.0): # Н
3 self.max_grip_force = max_grip_force
4 self.grip_motor = None
5 self.force_sensor = None
6 self.cargo_detected = False
7
8 def calculate_grip_force(self, object_mass, surface_angle=0, safety_factor=2.0):
9 """Расчет необходимой силы захвата"""
10 mu = 0.6 # Коэффициент трения резина-пластик
11 g = 9.81 # Ускорение свободного падения
12
13 # Базовая сила для удержания объекта
14 base_force = (object_mass * g * math.sin(math.radians(surface_angle))) / \
15 (mu * math.cos(math.radians(surface_angle)))
16
17 # Применение коэффициента безопасности
18 required_force = base_force * safety_factor
19
20 return min(required_force, self.max_grip_force)
21
22 def adaptive_grip_control(self, target_force):
23 """Адаптивное управление силой захвата"""
24 current_force = self.force_sensor.getValue()
25 error = target_force - current_force
26
27 # ПИД-регулятор для силы
28 pid_output = self.force_pid.compute(target_force, current_force)
29
30 # Ограничение выходного сигнала
31 grip_command = max(0, min(1, pid_output))
32 self.grip_motor.setPosition(grip_command)
33
34 return abs(error) < 2.0 # Допустимая погрешность 2Н
Основные показатели эффективности (KPI):
1. Точность навигации: \[\text{Accuracy}_{nav} = 1 - \frac{\sqrt{(x_{actual} - x_{target})^2 + (y_{actual} - y_{target})^2}}{d_{max}}\]
где $d_{max}$ - максимально допустимое отклонение (0.1 м)
2. Эффективность планирования пути: \[\text{Efficiency}_{path} = \frac{L_{optimal}}{L_{actual}}\]
где:
3. Энергоэффективность: \[\text{Energy}_{efficiency} = \frac{E_{theoretical}}{E_{consumed}}\]
Теоретическое энергопотребление: \[E_{theoretical} = m \cdot g \cdot h + \frac{1}{2} m v^2 + \int_0^T P_{friction} dt\]
4. Время выполнения задачи: \[\text{Time}_{efficiency} = \frac{T_{baseline}}{T_{actual}}\]
где $T_{baseline}$ - базовое время выполнения задачи
Тест 1: Базовая мобильность
1class MobilityTestSuite:
2 def __init__(self, robot_controller):
3 self.robot = robot_controller
4 self.test_results = {}
5
6 def test_straight_line_motion(self, distance=2.0, target_velocity=0.3):
7 """Тест движения по прямой линии"""
8 start_position = self.robot.get_position()
9 start_time = self.robot.get_time()
10
11 # Команда движения вперед
12 self.robot.move_straight(target_velocity)
13
14 # Ожидание достижения целевого расстояния
15 while self.robot.get_distance_traveled() < distance:
16 self.robot.step()
17
18 end_position = self.robot.get_position()
19 end_time = self.robot.get_time()
20
21 # Анализ результатов
22 actual_distance = self.calculate_distance(start_position, end_position)
23 actual_time = end_time - start_time
24 average_velocity = actual_distance / actual_time
25
26 # Метрики
27 distance_error = abs(actual_distance - distance) / distance
28 velocity_error = abs(average_velocity - target_velocity) / target_velocity
29
30 self.test_results['straight_motion'] = {
31 'distance_accuracy': 1 - distance_error,
32 'velocity_accuracy': 1 - velocity_error,
33 'trajectory_deviation': self.calculate_trajectory_deviation()
34 }
35
36 return self.test_results['straight_motion']
37
38 def test_rotation_accuracy(self, target_angle=90): # градусы
39 """Тест точности поворота"""
40 start_orientation = self.robot.get_orientation()
41
42 # Выполнение поворота
43 self.robot.rotate(math.radians(target_angle))
44
45 end_orientation = self.robot.get_orientation()
46 actual_angle = math.degrees(end_orientation - start_orientation)
47
48 # Нормализация угла
49 actual_angle = (actual_angle + 180) % 360 - 180
50
51 angle_error = abs(actual_angle - target_angle)
52 accuracy = max(0, 1 - angle_error / 10) # 10° допустимое отклонение
53
54 self.test_results['rotation'] = {
55 'target_angle': target_angle,
56 'actual_angle': actual_angle,
57 'accuracy': accuracy
58 }
59
60 return self.test_results['rotation']
Тест 2: Обнаружение и избежание препятствий
1def test_obstacle_avoidance(self):
2 """Комплексный тест системы избежания препятствий"""
3
4 # Создание тестового лабиринта
5 obstacles = [
6 {'position': (1.0, 0.5), 'size': (0.2, 0.5)},
7 {'position': (2.0, -0.5), 'size': (0.3, 0.4)},
8 {'position': (3.0, 0.0), 'size': (0.2, 0.6)}
9 ]
10
11 start_pos = (0, 0)
12 goal_pos = (4, 0)
13
14 # Статистика выполнения
15 collision_count = 0
16 path_length = 0
17 completion_time = 0
18
19 # Выполнение навигации
20 while not self.robot.reached_goal(goal_pos, tolerance=0.1):
21 sensor_data = self.robot.get_sensor_readings()
22
23 # Проверка коллизий
24 if self.detect_collision(sensor_data):
25 collision_count += 1
26
27 # Планирование локального пути
28 control_commands = self.robot.plan_local_path(goal_pos, sensor_data)
29 self.robot.execute_commands(control_commands)
30
31 # Обновление метрик
32 path_length += self.robot.get_step_distance()
33 completion_time += self.robot.timestep
34
35 self.robot.step()
36
37 # Анализ результатов
38 optimal_path_length = self.calculate_optimal_path(start_pos, goal_pos, obstacles)
39 path_efficiency = optimal_path_length / path_length
40
41 safety_score = max(0, 1 - collision_count / 10) # Штраф за коллизии
42
43 return {
44 'path_efficiency': path_efficiency,
45 'safety_score': safety_score,
46 'collision_count': collision_count,
47 'completion_time': completion_time
48 }
Тест 3: Транспортная задача с грузом
1def test_cargo_transport_mission(self):
2 """Полный тест транспортной миссии"""
3
4 # Параметры миссии
5 cargo_pickup_location = (1.5, 1.0)
6 cargo_delivery_location = (3.5, -1.0)
7 cargo_mass = 1.0 # кг
8
9 mission_phases = {
10 'navigation_to_pickup': False,
11 'cargo_detection': False,
12 'cargo_pickup': False,
13 'navigation_to_delivery': False,
14 'cargo_delivery': False
15 }
16
17 start_time = self.robot.get_time()
18
19 # Фаза 1: Навигация к месту захвата
20 phase_start = self.robot.get_time()
21 self.robot.navigate_to(cargo_pickup_location)
22
23 if self.robot.reached_goal(cargo_pickup_location, tolerance=0.15):
24 mission_phases['navigation_to_pickup'] = True
25
26 # Фаза 2: Обнаружение груза
27 cargo_detected = self.robot.scan_for_cargo()
28 if cargo_detected:
29 mission_phases['cargo_detection'] = True
30
31 # Фаза 3: Захват груза
32 pickup_success = self.robot.pickup_cargo()
33 if pickup_success:
34 mission_phases['cargo_pickup'] = True
35
36 # Обновление динамической модели робота
37 self.robot.update_mass(self.robot.base_mass + cargo_mass)
38
39 # Фаза 4: Навигация к месту доставки
40 self.robot.navigate_to(cargo_delivery_location)
41
42 if self.robot.reached_goal(cargo_delivery_location, tolerance=0.15):
43 mission_phases['navigation_to_delivery'] = True
44
45 # Фаза 5: Доставка груза
46 delivery_success = self.robot.deliver_cargo()
47 if delivery_success:
48 mission_phases['cargo_delivery'] = True
49
50 end_time = self.robot.get_time()
51 total_mission_time = end_time - start_time
52
53 # Расчет общего успеха миссии
54 mission_success_rate = sum(mission_phases.values()) / len(mission_phases)
55
56 return {
57 'mission_success_rate': mission_success_rate,
58 'total_time': total_mission_time,
59 'phase_results': mission_phases,
60 'energy_consumption': self.robot.get_energy_consumed()
61 }
Профилирование производительности алгоритмов:
1import time
2import cProfile
3
4class PerformanceProfiler:
5 def __init__(self):
6 self.execution_times = {}
7 self.function_calls = {}
8
9 def profile_function(self, func_name):
10 """Декоратор для профилирования функций"""
11 def decorator(func):
12 def wrapper(*args, **kwargs):
13 start_time = time.perf_counter()
14 result = func(*args, **kwargs)
15 end_time = time.perf_counter()
16
17 execution_time = end_time - start_time
18
19 if func_name not in self.execution_times:
20 self.execution_times[func_name] = []
21 self.function_calls[func_name] = 0
22
23 self.execution_times[func_name].append(execution_time)
24 self.function_calls[func_name] += 1
25
26 return result
27 return wrapper
28 return decorator
29
30 def get_performance_report(self):
31 """Генерация отчета о производительности"""
32 report = {}
33
34 for func_name in self.execution_times:
35 times = self.execution_times[func_name]
36 calls = self.function_calls[func_name]
37
38 report[func_name] = {
39 'total_calls': calls,
40 'average_time': sum(times) / len(times),
41 'min_time': min(times),
42 'max_time': max(times),
43 'total_time': sum(times)
44 }
45
46 return report
Оптимизация параметров ПИД-регулятора:
1class PIDTuner:
2 def __init__(self, robot_system):
3 self.robot = robot_system
4 self.best_params = None
5 self.best_score = float('inf')
6
7 def objective_function(self, params):
8 """Целевая функция для оптимизации ПИД"""
9 kp, ki, kd = params
10
11 # Тестирование с заданными параметрами
12 self.robot.set_pid_params(kp, ki, kd)
13
14 # Выполнение стандартного теста
15 test_results = self.robot.run_standard_test()
16
17 # Расчет интегральной ошибки
18 settling_time = test_results['settling_time']
19 overshoot = test_results['overshoot']
20 steady_state_error = test_results['steady_state_error']
21
22 # Интегральный критерий качества
23 score = settling_time + 10 * overshoot + 100 * steady_state_error
24
25 return score
26
27 def tune_parameters(self, param_ranges):
28 """Оптимизация параметров методом сетки"""
29 from itertools import product
30
31 kp_range = param_ranges['kp']
32 ki_range = param_ranges['ki']
33 kd_range = param_ranges['kd']
34
35 for kp, ki, kd in product(kp_range, ki_range, kd_range):
36 score = self.objective_function([kp, ki, kd])
37
38 if score < self.best_score:
39 self.best_score = score
40 self.best_params = [kp, ki, kd]
41
42 return self.best_params, self.best_score
Формат презентации результатов:
1. Техническая спецификация модели (30 сек):
2. Алгоритмическое решение (45 сек):
3. Результаты тестирования (30 сек):
4. Демонстрация работы (15 сек):
Детальные критерии оценки (максимум 30 баллов):
Техническая реализация модели (8 баллов):
Алгоритмическая сложность (8 баллов):
Выполнение транспортной задачи (8 баллов):
Инновационные решения (6 баллов):
Шкала оценивания:
Решение 1: Продвинутая система локализации
1class AdvancedLocalization:
2 def __init__(self):
3 self.particle_filter = ParticleFilter(num_particles=1000)
4 self.kalman_filter = ExtendedKalmanFilter()
5 self.localization_mode = 'particle_filter'
6
7 def sensor_fusion_localization(self, lidar_data, odometry_data, imu_data):
8 """Объединение данных от множественных датчиков"""
9
10 # Предобработка данных лидара
11 processed_lidar = self.preprocess_lidar(lidar_data)
12
13 # Обновление фильтра частиц
14 self.particle_filter.predict(odometry_data, imu_data)
15 self.particle_filter.update(processed_lidar)
16
17 # Получение оценки положения
18 estimated_pose = self.particle_filter.get_best_estimate()
19
20 # Переключение на Калман при высокой точности
21 if self.particle_filter.get_confidence() > 0.95:
22 self.localization_mode = 'kalman_filter'
23 self.kalman_filter.initialize(estimated_pose)
24
25 return estimated_pose
26
27 def adaptive_localization(self, sensor_data):
28 """Адаптивная локализация в зависимости от условий"""
29
30 # Оценка качества сенсорных данных
31 data_quality = self.assess_sensor_quality(sensor_data)
32
33 if data_quality['lidar'] > 0.8 and self.localization_mode == 'kalman_filter':
34 # Высокое качество данных - используем Калман
35 return self.kalman_filter.update(sensor_data)
36 else:
37 # Низкое качество или неопределенность - возврат к частицам
38 self.localization_mode = 'particle_filter'
39 return self.particle_filter.update(sensor_data)
Математическая модель фильтра частиц:
Предсказание состояния частицы: \[\mathbf{x}_t^{(i)} = f(\mathbf{x}_{t-1}^{(i)}, \mathbf{u}_t) + \mathbf{w}_t^{(i)}\]
Обновление весов частиц: \[w_t^{(i)} = w_{t-1}^{(i)} \cdot p(\mathbf{z}_t | \mathbf{x}_t^{(i)})\]
Нормализация весов: \[\tilde{w}_t^{(i)} = \frac{w_t^{(i)}}{\sum_{j=1}^N w_t^{(j)}}\]
Решение 2: Интеллектуальное управление энергопотреблением
1class EnergyOptimizedController:
2 def __init__(self, battery_capacity=100.0): # Ампер-часы
3 self.battery_capacity = battery_capacity
4 self.current_charge = battery_capacity
5 self.energy_model = EnergyConsumptionModel()
6
7 def calculate_energy_cost(self, velocity, angular_velocity, payload_mass):
8 """Расчет энергозатрат для заданных параметров движения"""
9
10 # Энергия на преодоление трения
11 friction_power = self.energy_model.friction_loss(velocity, payload_mass)
12
13 # Энергия на ускорение
14 acceleration_energy = self.energy_model.acceleration_cost(velocity)
15
16 # Энергия поворота
17 rotation_energy = self.energy_model.rotation_cost(angular_velocity)
18
19 # Потери в электронике
20 electronics_power = self.energy_model.base_consumption()
21
22 total_power = friction_power + acceleration_energy + rotation_energy + electronics_power
23
24 return total_power
25
26 def energy_aware_path_planning(self, start, goal, obstacles):
27 """Планирование пути с учетом энергопотребления"""
28
29 # Модификация алгоритма A* с энергетической функцией стоимости
30 def energy_cost_function(node1, node2, velocity):
31 distance = self.euclidean_distance(node1, node2)
32 time_cost = distance / velocity
33
34 # Энергозатраты на движение
35 energy_cost = self.calculate_energy_cost(velocity, 0, self.current_payload)
36 total_energy = energy_cost * time_cost
37
38 # Комбинированная стоимость: время + энергия
39 combined_cost = 0.3 * time_cost + 0.7 * total_energy
40
41 return combined_cost
42
43 # Поиск энергоэффективного пути
44 optimal_path = self.modified_astar(start, goal, obstacles, energy_cost_function)
45
46 return optimal_path
47
48 def adaptive_speed_control(self, target_position, remaining_battery):
49 """Адаптивное управление скоростью в зависимости от заряда батареи"""
50
51 battery_level = remaining_battery / self.battery_capacity
52 distance_to_goal = self.calculate_distance_to_goal(target_position)
53
54 # Оценка необходимой энергии для завершения миссии
55 estimated_energy_needed = self.estimate_energy_to_goal(distance_to_goal)
56
57 if estimated_energy_needed > remaining_battery * 0.9:
58 # Критический уровень батареи - снижение скорости
59 speed_factor = 0.5
60 elif battery_level > 0.7:
61 # Высокий заряд - можно двигаться быстро
62 speed_factor = 1.0
63 else:
64 # Умеренный заряд - оптимальная скорость
65 speed_factor = 0.7 + 0.3 * battery_level
66
67 return speed_factor
Модель энергопотребления:
Мощность трения: \[P_{friction} = \mu \cdot m \cdot g \cdot v + \frac{1}{2} \rho \cdot C_d \cdot A \cdot v^3\]
Энергия ускорения: \[E_{acceleration} = \frac{1}{2} m (v_f^2 - v_i^2) + E_{losses}\]
где $E_{losses}$ - потери в трансмиссии и двигателях.
Анализ ограничений виртуального моделирования:
1. Физическая достоверность:
2. Вычислительные ограничения:
Количественная оценка точности моделирования:
\[\text{Accuracy}_{sim} = 1 - \frac{\sum_{i=1}^{n} |x_{sim,i} - x_{real,i}|}{n \cdot \text{Range}}\]где:
Типичные отклонения виртуальной модели от реальности:
Калибровка виртуальной модели:
1class SimToRealCalibration:
2 def __init__(self, virtual_robot, real_robot):
3 self.virtual_robot = virtual_robot
4 self.real_robot = real_robot
5 self.calibration_factors = {}
6
7 def calibrate_motion_model(self, test_distances=[0.5, 1.0, 2.0]):
8 """Калибровка модели движения"""
9
10 calibration_data = []
11
12 for target_distance in test_distances:
13 # Виртуальный тест
14 virtual_result = self.virtual_robot.move_distance(target_distance)
15
16 # Реальный тест
17 real_result = self.real_robot.move_distance(target_distance)
18
19 # Расчет коэффициента коррекции
20 correction_factor = real_result['actual_distance'] / virtual_result['actual_distance']
21
22 calibration_data.append({
23 'target': target_distance,
24 'virtual': virtual_result['actual_distance'],
25 'real': real_result['actual_distance'],
26 'correction': correction_factor
27 })
28
29 # Линейная регрессия для нахождения калибровочных коэффициентов
30 self.calibration_factors['motion'] = self.fit_linear_model(calibration_data)
31
32 return self.calibration_factors['motion']
33
34 def apply_calibration(self, virtual_command):
35 """Применение калибровки к командам виртуального робота"""
36
37 if 'motion' in self.calibration_factors:
38 calibrated_command = virtual_command * self.calibration_factors['motion']['slope'] + \
39 self.calibration_factors['motion']['offset']
40 else:
41 calibrated_command = virtual_command
42
43 return calibrated_command
Математическая модель калибровки:
Линейная калибровочная модель: \[x_{real} = k \cdot x_{virtual} + b\]
Метод наименьших квадратов для определения параметров: \[k = \frac{n\sum x_v x_r - \sum x_v \sum x_r}{n\sum x_v^2 - (\sum x_v)^2}\]
\[b = \frac{\sum x_r - k\sum x_v}{n}\]Интегральный показатель качества решения:
\[Q_{total} = w_1 \cdot Q_{tech} + w_2 \cdot Q_{algo} + w_3 \cdot Q_{performance} + w_4 \cdot Q_{innovation}\]где весовые коэффициенты: $w_1 = 0.3, w_2 = 0.3, w_3 = 0.3, w_4 = 0.1$
Техническое качество ($Q_{tech}$): \[Q_{tech} = \frac{1}{4}(Q_{model} + Q_{physics} + Q_{sensors} + Q_{stability})\]
Алгоритмическое качество ($Q_{algo}$): \[Q_{algo} = \frac{1}{3}(Q_{navigation} + Q_{control} + Q_{optimization})\]
Производительность ($Q_{performance}$): \[Q_{performance} = \frac{1}{4}(Q_{accuracy} + Q_{speed} + Q_{efficiency} + Q_{reliability})\]
Статистический анализ результатов:
1import numpy as np
2from scipy import stats
3
4class PerformanceAnalyzer:
5 def __init__(self):
6 self.test_results = []
7
8 def statistical_analysis(self, test_data):
9 """Статистический анализ результатов тестирования"""
10
11 # Описательная статистика
12 results = {
13 'mean': np.mean(test_data),
14 'std': np.std(test_data),
15 'median': np.median(test_data),
16 'min': np.min(test_data),
17 'max': np.max(test_data),
18 'quartiles': np.percentile(test_data, [25, 75])
19 }
20
21 # Проверка нормальности распределения
22 shapiro_stat, shapiro_p = stats.shapiro(test_data)
23 results['normality'] = {
24 'shapiro_statistic': shapiro_stat,
25 'p_value': shapiro_p,
26 'is_normal': shapiro_p > 0.05
27 }
28
29 # Доверительный интервал для среднего
30 confidence_interval = stats.t.interval(
31 confidence=0.95,
32 df=len(test_data)-1,
33 loc=results['mean'],
34 scale=stats.sem(test_data)
35 )
36 results['confidence_interval_95'] = confidence_interval
37
38 return results
39
40 def performance_regression_analysis(self, independent_vars, dependent_var):
41 """Регрессионный анализ факторов производительности"""
42
43 # Множественная линейная регрессия
44 from sklearn.linear_model import LinearRegression
45 from sklearn.metrics import r2_score
46
47 model = LinearRegression()
48 model.fit(independent_vars, dependent_var)
49
50 predictions = model.predict(independent_vars)
51 r2 = r2_score(dependent_var, predictions)
52
53 # Анализ значимости коэффициентов
54 coefficients = model.coef_
55 intercept = model.intercept_
56
57 return {
58 'r_squared': r2,
59 'coefficients': coefficients,
60 'intercept': intercept,
61 'feature_importance': np.abs(coefficients) / np.sum(np.abs(coefficients))
62 }
Машинное обучение в управлении роботами:
1import tensorflow as tf
2from tensorflow.keras import layers
3
4class ReinforcementLearningController:
5 def __init__(self, state_size, action_size):
6 self.state_size = state_size
7 self.action_size = action_size
8 self.model = self.build_neural_network()
9 self.target_model = self.build_neural_network()
10
11 def build_neural_network(self):
12 """Создание нейронной сети для Q-learning"""
13 model = tf.keras.Sequential([
14 layers.Dense(128, activation='relu', input_shape=(self.state_size,)),
15 layers.Dropout(0.2),
16 layers.Dense(128, activation='relu'),
17 layers.Dropout(0.2),
18 layers.Dense(64, activation='relu'),
19 layers.Dense(self.action_size, activation='linear')
20 ])
21
22 model.compile(optimizer='adam', loss='mse')
23 return model
24
25 def get_state_representation(self, sensor_data, robot_state):
26 """Представление состояния для нейронной сети"""
27
28 # Обработка данных лидара (дискретизация)
29 lidar_features = self.process_lidar_data(sensor_data['lidar'])
30
31 # Состояние робота
32 robot_features = [
33 robot_state['position'][0],
34 robot_state['position'][1],
35 robot_state['orientation'],
36 robot_state['velocity'],
37 robot_state['angular_velocity']
38 ]
39
40 # Целевая информация
41 goal_features = [
42 robot_state['goal'][0] - robot_state['position'][0], # относительная позиция
43 robot_state['goal'][1] - robot_state['position'][1],
44 self.calculate_distance_to_goal(robot_state)
45 ]
46
47 # Объединение всех признаков
48 state_vector = np.concatenate([lidar_features, robot_features, goal_features])
49
50 return state_vector
51
52