💻 Программирование и оценка качества

 1Задача: Сортировка объектов по цвету
 2Входные данные: Цвет объекта (красный/синий/зеленый)
 3Выходные данные: Направление движения объекта
 4Ограничения: Время сортировки < 5 секунд
 5
 6Алгоритм:
 71. Захватить объект
 82. Определить цвет объекта
 93. ЕСЛИ цвет = красный, ТО переместить в контейнер А
104. ЕСЛИ цвет = синий, ТО переместить в контейнер Б  
115. ЕСЛИ цвет = зеленый, ТО переместить в контейнер В
126. Освободить захват
137. Вернуться к началу

 1Задача: Исследование неизвестной территории
 2Входные данные: Показания датчиков расстояния
 3Выходные данные: Карта местности, найденные объекты
 4Ограничения: Не выходить за границы поля
 5
 6Алгоритм:
 71. Начать движение прямо
 82. ПОКА расстояние > 20 см, ДЕЛАТЬ: двигаться вперед
 93. ЕСЛИ препятствие, ТО:
10   - Записать координаты препятствия
11   - Повернуть на 90° вправо
12   - Продолжить движение
134. ЕСЛИ границы поля, ТО: развернуться
145. Повторять до полного исследования

 1        [СТАРТ]
 2           │
 3    [Инициализация]
 4           │
 5      [Основной цикл]◄──────┐
 6           │                │
 7    [Чтение датчиков]       │
 8           │                │
 9    [Принятие решения]      │
10           │                │
11    [Выполнение действия]   │
12           │                │
13    [Проверка условий]──────┘
14           │
15        [СТОП]

 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└──────────────────────────────────┘

 1# Псевдокод инициализации
 2def initialize_robot():
 3    # Настройка портов
 4    motor_left = Motor(PORT_B)
 5    motor_right = Motor(PORT_C)
 6    color_sensor = ColorSensor(PORT_1)
 7    ultrasonic_sensor = UltrasonicSensor(PORT_4)
 8    
 9    # Калибровка датчиков
10    color_sensor.calibrate()
11    
12    # Установка начальных параметров
13    speed = 50
14    turn_angle = 90
15    
16    print("Робот инициализирован!")

 1def move_forward(distance_cm):
 2    # Расчет времени движения
 3    # Скорость: 20 см/сек при мощности 50%
 4    time_sec = distance_cm / 20
 5    
 6    motor_left.run(speed=50, time=time_sec)
 7    motor_right.run(speed=50, time=time_sec)
 8
 9def turn_right(angle_degrees):
10    # Поворот на месте
11    # 90° = 1 секунда при разности скоростей
12    time_sec = angle_degrees / 90
13    
14    motor_left.run(speed=50, time=time_sec)
15    motor_right.run(speed=-50, time=time_sec)
16
17def stop_robot():
18    motor_left.stop()
19    motor_right.stop()

 1def process_color_detection():
 2    color = color_sensor.get_color()
 3    
 4    if color == "RED":
 5        move_to_container_A()
 6        objects_red += 1
 7    elif color == "BLUE":
 8        move_to_container_B()
 9        objects_blue += 1
10    elif color == "GREEN":
11        move_to_container_C()
12        objects_green += 1
13    else:
14        # Неопознанный цвет
15        move_to_unknown_container()
16        objects_unknown += 1
17    
18    update_statistics()

 1def main_work_cycle():
 2    while True:  # Бесконечный рабочий цикл
 3        
 4        # Ожидание объекта
 5        while not object_detected():
 6            wait(0.1)  # Пауза 100 мс
 7        
 8        # Обработка объекта
 9        grab_object()
10        process_color_detection()
11        release_object()
12        return_to_start()
13        
14        # Проверка условий завершения
15        if total_objects >= 50:
16            break
17        if battery_level < 20:
18            break
19            
20    print("Работа завершена!")

 1def collect_statistics():
 2    total_time = get_elapsed_time()
 3    total_objects = objects_red + objects_blue + objects_green
 4    
 5    if total_objects > 0:
 6        average_time = total_time / total_objects
 7        accuracy = (total_objects - objects_unknown) / total_objects * 100
 8        
 9        print(f"Обработано объектов: {total_objects}")
10        print(f"Среднее время на объект: {average_time:.2f} сек")
11        print(f"Точность распознавания: {accuracy:.1f}%")

 1# ОШИБКА: Неправильный синтаксис
 2if color = "RED":  # Должно быть ==, а не =
 3    move_forward(10)
 4
 5# ОШИБКА: Незакрытые скобки
 6def move_robot(distance:
 7    motor.run(speed=50)  # Нет закрывающей скобки
 8
 9# ОШИБКА: Неправильные отступы
10if distance > 20:
11move_forward(10)  # Нужен отступ
12
13# ПРАВИЛЬНО:
14if color == "RED":
15    move_forward(10)
16
17def move_robot(distance):
18    motor.run(speed=50)
19
20if distance > 20:
21    move_forward(10)

 1# ОШИБКА: Бесконечный цикл
 2while distance > 10:
 3    print("Двигаемся вперед")  # distance не изменяется!
 4
 5# ОШИБКА: Неправильное условие
 6if battery_level > 20:  # Должно быть <
 7    print("Батарея разряжена!")
 8
 9# ОШИБКА: Неучтенные граничные случаи
10speed = distance / time  # Что если time = 0?
11
12# ПРАВИЛЬНО:
13while distance > 10:
14    move_forward(1)
15    distance = ultrasonic.get_distance()
16
17if battery_level < 20:
18    print("Батарея разряжена!")
19
20if time > 0:
21    speed = distance / time
22else:
23    speed = 0

 1def debug_move_to_target(target_x, target_y):
 2    print(f"DEBUG: Начинаем движение к ({target_x}, {target_y})")
 3    
 4    current_x = get_position_x()
 5    current_y = get_position_y()
 6    print(f"DEBUG: Текущая позиция ({current_x}, {current_y})")
 7    
 8    distance = calculate_distance(current_x, current_y, target_x, target_y)
 9    print(f"DEBUG: Расстояние до цели: {distance} см")
10    
11    angle = calculate_angle(current_x, current_y, target_x, target_y)
12    print(f"DEBUG: Угол поворота: {angle}°")
13    
14    turn_to_angle(angle)
15    print("DEBUG: Поворот выполнен")
16    
17    move_forward(distance)
18    print("DEBUG: Движение завершено")
19    
20    # Проверка результата
21    final_x = get_position_x()
22    final_y = get_position_y()
23    error = calculate_distance(final_x, final_y, target_x, target_y)
24    print(f"DEBUG: Погрешность позиционирования: {error} см")

 1def monitor_sensors():
 2    print("=== МОНИТОРИНГ ДАТЧИКОВ ===")
 3    
 4    for i in range(10):  # 10 измерений
 5        distance = ultrasonic.get_distance()
 6        color = color_sensor.get_color()
 7        light = light_sensor.get_intensity()
 8        battery = get_battery_level()
 9        
10        print(f"Измерение {i+1}:")
11        print(f"  Расстояние: {distance} см")
12        print(f"  Цвет: {color}")
13        print(f"  Освещенность: {light}")
14        print(f"  Батарея: {battery}%")
15        
16        wait(1)  # Пауза 1 секунда

 1def test_basic_functions():
 2    print("=== ТЕСТ БАЗОВЫХ ФУНКЦИЙ ===")
 3    
 4    # Тест 1: Движение вперед
 5    print("Тест 1: Движение вперед на 20 см")
 6    start_pos = get_position()
 7    move_forward(20)
 8    end_pos = get_position()
 9    actual_distance = calculate_distance(start_pos, end_pos)
10    error = abs(actual_distance - 20)
11    print(f"Ожидалось: 20 см, Фактически: {actual_distance:.1f} см")
12    print(f"Погрешность: {error:.1f} см")
13    
14    # Тест 2: Поворот на 90°
15    print("\nТест 2: Поворот на 90°")
16    start_angle = get_heading()
17    turn_right(90)
18    end_angle = get_heading()
19    actual_turn = abs(end_angle - start_angle)
20    error = abs(actual_turn - 90)
21    print(f"Ожидалось: 90°, Фактически: {actual_turn:.1f}°")
22    print(f"Погрешность: {error:.1f}°")
23    
24    # Тест 3: Распознавание цвета
25    print("\nТест 3: Распознавание цвета")
26    test_colors = ["RED", "BLUE", "GREEN"]
27    correct_detections = 0
28    
29    for expected_color in test_colors:
30        print(f"Поместите {expected_color} объект перед датчиком")
31        wait(3)  # Время на размещение объекта
32        detected_color = color_sensor.get_color()
33        
34        if detected_color == expected_color:
35            print(f"✅ Правильно: {detected_color}")
36            correct_detections += 1
37        else:
38            print(f"❌ Ошибка: ожидался {expected_color}, получен {detected_color}")
39    
40    accuracy = (correct_detections / len(test_colors)) * 100
41    print(f"\nТочность распознавания цвета: {accuracy:.1f}%")

 1def performance_test():
 2    print("=== ТЕСТ ПРОИЗВОДИТЕЛЬНОСТИ ===")
 3    
 4    # Тест скорости сортировки
 5    start_time = get_time()
 6    objects_processed = 0
 7    
 8    for i in range(10):  # Тест на 10 объектах
 9        process_one_object()
10        objects_processed += 1
11    
12    end_time = get_time()
13    total_time = end_time - start_time
14    
15    average_time = total_time / objects_processed
16    objects_per_minute = 60 / average_time
17    
18    print(f"Общее время: {total_time:.1f} сек")
19    print(f"Среднее время на объект: {average_time:.2f} сек")
20    print(f"Производительность: {objects_per_minute:.1f} объектов/мин")
21    
22    # Сравнение с требованиями ТЗ
23    required_time = 5.0  # секунд на объект по ТЗ
24    if average_time <= required_time:
25        print(f"✅ Требование выполнено (≤{required_time} сек)")
26    else:
27        print(f"❌ Требование не выполнено (>{required_time} сек)")
28        print(f"Нужно ускорить на {average_time - required_time:.2f} сек")

 1def measure_speed_direct():
 2    distance = 100  # см
 3    
 4    print(f"Измерение скорости на дистанции {distance} см")
 5    print("Установите робота на стартовую линию")
 6    
 7    input("Нажмите Enter для начала измерения...")
 8    
 9    start_time = get_time()
10    move_forward(distance)
11    end_time = get_time()
12    
13    travel_time = end_time - start_time
14    speed = distance / travel_time
15    
16    print(f"Время прохождения: {travel_time:.2f} сек")
17    print(f"Скорость: {speed:.1f} см/сек = {speed*0.36:.2f} км/ч")
18    
19    return speed

 1def measure_speed_on_surfaces():
 2    surfaces = ["Гладкий стол", "Ковер", "Линолеум", "Картон"]
 3    speeds = []
 4    
 5    for surface in surfaces:
 6        print(f"\n=== ИЗМЕРЕНИЕ НА: {surface.upper()} ===")
 7        input(f"Поместите робота на {surface.lower()}, нажмите Enter...")
 8        
 9        # Три измерения для точности
10        surface_speeds = []
11        for i in range(3):
12            print(f"Измерение {i+1}/3")
13            speed = measure_speed_direct()
14            surface_speeds.append(speed)
15            
16        avg_speed = sum(surface_speeds) / len(surface_speeds)
17        speeds.append(avg_speed)
18        
19        print(f"Средняя скорость на {surface.lower()}: {avg_speed:.1f} см/сек")
20    
21    # Анализ результатов
22    print("\n=== СВОДКА РЕЗУЛЬТАТОВ ===")
23    for i, surface in enumerate(surfaces):
24        print(f"{surface}: {speeds[i]:.1f} см/сек")
25    
26    max_speed = max(speeds)
27    min_speed = min(speeds)
28    print(f"\nМаксимальная скорость: {max_speed:.1f} см/сек")
29    print(f"Минимальная скорость: {min_speed:.1f} см/сек")
30    print(f"Разница: {max_speed - min_speed:.1f} см/сек ({((max_speed-min_speed)/min_speed*100):.1f}%)")

 1def measure_max_load():
 2    print("=== ТЕСТ МАКСИМАЛЬНОЙ НАГРУЗКИ ===")
 3    
 4    weights = [0, 100, 200, 300, 400, 500]  # граммы
 5    results = []
 6    
 7    for weight in weights:
 8        print(f"\nТест с грузом {weight} г")
 9        input(f"Установите груз {weight} г, нажмите Enter...")
10        
11        # Тест способности двигаться
12        print("Тестируем движение...")
13        start_time = get_time()
14        
15        try:
16            move_forward(50)  # 50 см
17            end_time = get_time()
18            time_taken = end_time - start_time
19            
20            if time_taken < 10:  # Успел за 10 секунд
21                print(f"✅ Справился за {time_taken:.2f} сек")
22                results.append({"weight": weight, "time": time_taken, "success": True})
23            else:
24                print(f"❌ Слишком медленно: {time_taken:.2f} сек")
25                results.append({"weight": weight, "time": time_taken, "success": False})
26                
27        except:
28            print("❌ Не смог сдвинуться с места")
29            results.append({"weight": weight, "time": None, "success": False})
30            break
31    
32    # Анализ результатов
33    print("\n=== РЕЗУЛЬТАТЫ НАГРУЗОЧНОГО ТЕСТА ===")
34    max_successful_weight = 0
35    
36    for result in results:
37        if result["success"]:
38            print(f"Груз {result['weight']} г: ✅ {result['time']:.2f} сек")
39            max_successful_weight = result["weight"]
40        else:
41            print(f"Груз {result['weight']} г: ❌ Не справился")
42    
43    print(f"\nМаксимальная нагрузка: {max_successful_weight} г")

 1def measure_battery_life():
 2    print("=== ТЕСТ АВТОНОМНОСТИ ===")
 3    
 4    start_battery = get_battery_level()
 5    start_time = get_time()
 6    cycles_completed = 0
 7    
 8    print(f"Начальный заряд: {start_battery}%")
 9    print("Начинаем циклическую работу...")
10    
11    while get_battery_level() > 20:  # До критического уровня
12        # Один рабочий цикл
13        move_forward(30)
14        turn_right(90)
15        wait(1)
16        
17        cycles_completed += 1
18        
19        if cycles_completed % 10 == 0:  # Каждые 10 циклов
20            current_battery = get_battery_level()
21            current_time = get_time()
22            elapsed_time = (current_time - start_time) / 60  # минуты
23            
24            print(f"Цикл {cycles_completed}: {current_battery}%, время {elapsed_time:.1f} мин")
25    
26    end_time = get_time()
27    end_battery = get_battery_level()
28    
29    total_time = (end_time - start_time) / 60  # минуты
30    battery_used = start_battery - end_battery
31    
32    print(f"\n=== РЕЗУЛЬТАТЫ ТЕСТА АВТОНОМНОСТИ ===")
33    print(f"Время работы: {total_time:.1f} минут")
34    print(f"Использовано заряда: {battery_used}%")
35    print(f"Выполнено циклов: {cycles_completed}")
36    print(f"Время на цикл: {total_time/cycles_completed:.2f} мин")
37    print(f"Расход батареи: {battery_used/total_time:.2f}%/мин")
38    
39    # Прогноз полного времени работы
40    if battery_used > 0:
41        full_work_time = 80 * total_time / battery_used  # 80% рабочего заряда
42        print(f"Прогноз полного времени работы: {full_work_time:.1f} минут")

 1def measure_positioning_accuracy():
 2    print("=== ТЕСТ ТОЧНОСТИ ПОЗИЦИОНИРОВАНИЯ ===")
 3    
 4    target_positions = [
 5        (50, 0),    # 50 см вперед
 6        (50, 50),   # 50 см вперед, 50 см вправо
 7        (0, 50),    # вернуться к X=0, Y=50
 8        (0, 0)      # вернуться в исходную точку
 9    ]
10    
11    errors = []
12    
13    for i, (target_x, target_y) in enumerate(target_positions):
14        print(f"\nТочка {i+1}: Движение к ({target_x}, {target_y})")
15        
16        # Движение к цели
17        move_to_position(target_x, target_y)
18        
19        # Измерение фактической позиции
20        print("Измерьте фактическое положение робота")
21        actual_x = float(input("Фактическая X (см): "))
22        actual_y = float(input("Фактическая Y (см): "))
23        
24        # Расчет погрешности
25        error_x = abs(actual_x - target_x)
26        error_y = abs(actual_y - target_y)
27        total_error = (error_x**2 + error_y**2)**0.5
28        
29        errors.append(total_error)
30        
31        print(f"Целевая позиция: ({target_x}, {target_y})")
32        print(f"Фактическая позиция: ({actual_x}, {actual_y})")
33        print(f"Погрешность: X={error_x:.1f} см, Y={error_y:.1f} см")
34        print(f"Общая погрешность: {total_error:.1f} см")
35    
36    # Статистический анализ
37    avg_error = sum(errors) / len(errors)
38    max_error = max(errors)
39    min_error = min(errors)
40    
41    print(f"\n=== СТАТИСТИКА ТОЧНОСТИ ===")
42    print(f"Средняя погрешность: {avg_error:.1f} см")
43    print(f"Максимальная погрешность: {max_error:.1f} см")
44    print(f"Минимальная погрешность: {min_error:.1f} см")
45    
46    # Оценка качества
47    if avg_error <= 2:
48        print("✅ Отличная точность (≤2 см)")
49    elif avg_error <= 5:
50        print("⚠️ Хорошая точность (≤5 см)")
51    else:
52        print("❌ Требуется улучшение точности (>5 см)")

 1def calculate_errors(expected, actual):
 2    """
 3    Расчет различных типов погрешностей
 4    """
 5    # Абсолютная погрешность
 6    absolute_error = abs(actual - expected)
 7    
 8    # Относительная погрешность (в %)
 9    if expected != 0:
10        relative_error = (absolute_error / abs(expected)) * 100
11    else:
12        relative_error = float('inf')
13    
14    # Приведенная погрешность (к максимальному значению)
15    max_value = 100  # Например, для батареи 100%
16    reduced_error = (absolute_error / max_value) * 100
17    
18    return {
19        'absolute': absolute_error,
20        'relative': relative_error,
21        'reduced': reduced_error
22    }
23
24# Пример использования
25expected_distance = 50  # см
26actual_distance = 48.3  # см
27
28errors = calculate_errors(expected_distance, actual_distance)
29print(f"Ожидалось: {expected_distance} см")
30print(f"Получено: {actual_distance} см")
31print(f"Абсолютная погрешность: {errors['absolute']:.1f} см")
32print(f"Относительная погрешность: {errors['relative']:.1f}%")

 1def statistical_analysis(measurements, expected_value):
 2    """
 3    Полный статистический анализ измерений
 4    """
 5    import math
 6    
 7    n = len(measurements)
 8    
 9    # Основные статистики
10    mean = sum(measurements) / n
11    
12    # Стандартное отклонение
13    variance = sum((x - mean)**2 for x in measurements) / (n - 1)
14    std_dev = math.sqrt(variance)
15    
16    # Минимум и максимум
17    min_val = min(measurements)
18    max_val = max(measurements)
19    
20    # Размах
21    range_val = max_val - min_val
22    
23    # Медиана
24    sorted_measurements = sorted(measurements)
25    if n % 2 == 0:
26        median = (sorted_measurements[n//2 - 1] + sorted_measurements[n//2]) / 2
27    else:
28        median = sorted_measurements[n//2]
29    
30    # Погрешности относительно ожидаемого значения
31    mean_error = abs(mean - expected_value)
32    mean_relative_error = (mean_error / abs(expected_value)) * 100 if expected_value != 0 else 0
33    
34    # Коэффициент вариации
35    cv = (std_dev / mean) * 100 if mean != 0 else 0
36    
37    return {
38        'count': n,
39        'mean': mean,
40        'std_dev': std_dev,
41        'min': min_val,
42        'max': max_val,
43        'range': range_val,
44        'median': median,
45        'mean_error': mean_error,
46        'mean_relative_error': mean_relative_error,
47        'coefficient_of_variation': cv
48    }
49
50# Пример анализа измерений скорости
51speed_measurements = [19.2, 20.1, 18.8, 19.7, 20.3, 19.5, 18.9, 20.0]
52expected_speed = 20.0
53
54stats = statistical_analysis(speed_measurements, expected_speed)
55
56print("=== СТАТИСТИЧЕСКИЙ АНАЛИЗ СКОРОСТИ ===")
57print(f"Количество измерений: {stats['count']}")
58print(f"Среднее значение: {stats['mean']:.2f} см/сек")
59print(f"Стандартное отклонение: {stats['std_dev']:.2f} см/сек")
60print(f"Медиана: {stats['median']:.2f} см/сек")
61print(f"Диапазон: {stats['min']:.1f} - {stats['max']:.1f} см/сек")
62print(f"Размах: {stats['range']:.1f} см/сек")
63print(f"Коэффициент вариации: {stats['coefficient_of_variation']:.1f}%")
64print(f"Погрешность среднего: {stats['mean_error']:.2f} см/сек ({stats['mean_relative_error']:.1f}%)")

 1def repeatability_test(test_function, num_tests=10):
 2    """
 3    Тест повторяемости выполнения функции
 4    """
 5    print(f"=== ТЕСТ ПОВТОРЯЕМОСТИ ({num_tests} попыток) ===")
 6    
 7    results = []
 8    
 9    for i in range(num_tests):
10        print(f"Попытка {i+1}/{num_tests}")
11        
12        try:
13            result = test_function()
14            results.append(result)
15            print(f"Результат: {result:.2f}")
16        except Exception as e:
17            print(f"Ошибка: {e}")
18            results.append(None)
19    
20    # Анализ успешных результатов
21    successful_results = [r for r in results if r is not None]
22    success_rate = len(successful_results) / num_tests * 100
23    
24    print(f"\n=== АНАЛИЗ ПОВТОРЯЕМОСТИ ===")
25    print(f"Успешных тестов: {len(successful_results)}/{num_tests} ({success_rate:.1f}%)")
26    
27    if len(successful_results) >= 3:  # Минимум для анализа
28        stats = statistical_analysis(successful_results, successful_results[0])
29        
30        print(f"Среднее значение: {stats['mean']:.2f}")
31        print(f"Стандартное отклонение: {stats['std_dev']:.2f}")
32        print(f"Коэффициент вариации: {stats['coefficient_of_variation']:.1f}%")
33        
34        # Оценка стабильности
35        if stats['coefficient_of_variation'] <= 5:
36            print("✅ Отличная стабильность (CV ≤ 5%)")
37        elif stats['coefficient_of_variation'] <= 10:
38            print("⚠️ Хорошая стабильность (CV ≤ 10%)")
39        else:
40            print("❌ Низкая стабильность (CV > 10%)")
41    
42    return {
43        'success_rate': success_rate,
44        'results': successful_results,
45        'statistics': stats if len(successful_results) >= 3 else None
46    }
47
48# Пример использования
49def test_positioning():
50    """Тест позиционирования робота"""
51    move_to_position(50, 50)
52    actual_pos = measure_actual_position()
53    target_pos = (50, 50)
54    error = calculate_distance(actual_pos, target_pos)
55    return_to_start()
56    return error
57
58repeatability_results = repeatability_test(test_positioning, 5)

  1def comprehensive_quality_assessment():
  2    """
  3    Комплексная оценка качества модели робота
  4    """
  5    print("=== КОМПЛЕКСНАЯ ОЦЕНКА КАЧЕСТВА ===")
  6    
  7    criteria = {
  8        'functionality': 0,     # Функциональность
  9        'reliability': 0,       # Надежность  
 10        'accuracy': 0,          # Точность
 11        'performance': 0,       # Производительность
 12        'efficiency': 0,        # Эффективность
 13        'usability': 0          # Удобство использования
 14    }
 15    
 16    # 1. Функциональность (0-100)
 17    print("\n1. ФУНКЦИОНАЛЬНОСТЬ")
 18    required_functions = [
 19        "Движение вперед/назад",
 20        "Повороты влево/вправо", 
 21        "Определение препятствий",
 22        "Распознавание цветов",
 23        "Выполнение основной задачи"
 24    ]
 25    
 26    working_functions = 0
 27    for func in required_functions:
 28        works = input(f"Функция '{func}' работает? (y/n): ").lower() == 'y'
 29        if works:
 30            working_functions += 1
 31    
 32    criteria['functionality'] = (working_functions / len(required_functions)) * 100
 33    print(f"Функциональность: {criteria['functionality']:.0f}/100")
 34    
 35    # 2. Надежность (0-100)
 36    print("\n2. НАДЕЖНОСТЬ")
 37    reliability_tests = {
 38        "Стабильность подключений": 0,
 39        "Отсутствие поломок": 0,
 40        "Повторяемость результатов": 0,
 41        "Работа при разном освещении": 0
 42    }
 43    
 44    for test, score in reliability_tests.items():
 45        score = int(input(f"{test} (0-25): "))
 46        reliability_tests[test] = min(score, 25)
 47    
 48    criteria['reliability'] = sum(reliability_tests.values())
 49    print(f"Надежность: {criteria['reliability']:.0f}/100")
 50    
 51    # 3. Точность (из ранее проведенных тестов)
 52    print("\n3. ТОЧНОСТЬ")
 53    positioning_error = float(input("Средняя погрешность позиционирования (см): "))
 54    if positioning_error <= 2:
 55        criteria['accuracy'] = 100
 56    elif positioning_error <= 5:
 57        criteria['accuracy'] = 80
 58    elif positioning_error <= 10:
 59        criteria['accuracy'] = 60
 60    else:
 61        criteria['accuracy'] = 40
 62    
 63    print(f"Точность: {criteria['accuracy']:.0f}/100")
 64    
 65    # 4. Производительность
 66    print("\n4. ПРОИЗВОДИТЕЛЬНОСТЬ")
 67    task_time = float(input("Среднее время выполнения задачи (сек): "))
 68    required_time = float(input("Требуемое время по ТЗ (сек): "))
 69    
 70    if task_time <= required_time:
 71        criteria['performance'] = 100
 72    else:
 73        ratio = required_time / task_time
 74        criteria['performance'] = max(0, ratio * 100)
 75    
 76    print(f"Производительность: {criteria['performance']:.0f}/100")
 77    
 78    # 5. Энергоэффективность
 79    print("\n5. ЭНЕРГОЭФФЕКТИВНОСТЬ")
 80    battery_life = float(input("Время автономной работы (мин): "))
 81    if battery_life >= 60:
 82        criteria['efficiency'] = 100
 83    elif battery_life >= 30:
 84        criteria['efficiency'] = 80
 85    elif battery_life >= 15:
 86        criteria['efficiency'] = 60
 87    else:
 88        criteria['efficiency'] = 40
 89    
 90    print(f"Энергоэффективность: {criteria['efficiency']:.0f}/100")
 91    
 92    # 6. Удобство использования
 93    print("\n6. УДОБСТВО ИСПОЛЬЗОВАНИЯ")
 94    usability_aspects = {
 95        "Простота программирования": 0,
 96        "Понятность интерфейса": 0,
 97        "Удобство обслуживания": 0,
 98        "Качество документации": 0
 99    }
100    
101    for aspect in usability_aspects:
102        score = int(input(f"{aspect} (0-25): "))
103        usability_aspects[aspect] = min(score, 25)
104    
105    criteria['usability'] = sum(usability_aspects.values())
106    print(f"Удобство использования: {criteria['usability']:.0f}/100")
107    
108    # Общая оценка
109    overall_score = sum(criteria.values()) / len(criteria)
110    
111    print(f"\n=== ОБЩАЯ ОЦЕНКА КАЧЕСТВА ===")
112    for criterion, score in criteria.items():
113        print(f"{criterion.capitalize()}: {score:.0f}/100")
114    
115    print(f"\nОБЩИЙ БАЛЛ: {overall_score:.1f}/100")
116    
117    # Классификация качества
118    if overall_score >= 90:
119        grade = "Отлично"
120    elif overall_score >= 75:
121        grade = "Хорошо"
122    elif overall_score >= 60:
123        grade = "Удовлетворительно"
124    else:
125        grade = "Требует доработки"
126    
127    print(f"ОЦЕНКА: {grade}")
128    
129    return {
130        'criteria': criteria,
131        'overall_score': overall_score,
132        'grade': grade
133    }