🎯 SERVO и STEPPER моторы - АБСОЛЮТНАЯ ТОЧНОСТЬ! Миллиметр к миллиметру!

 1🎯 SERVO = УМНЫЙ МОТОР С МОЗГОМ
 2
 3АНАТОМИЯ SERVO:
 4┌─────────────────┐
 5│ DC Motor        │ ← Сердце
 6│ Gear Reduction  │ ← Мускулы  
 7│ Potentiometer   │ ← Глаза (feedback)
 8│ Control Circuit │ ← Мозг
 9└─────────────────┘
10
11КАК РАБОТАЕТ МАГИЯ:
121. Команда: "Повернись на 90°"
132. Мозг: "Сейчас я на 45°, нужно +45°"
143. Мотор: вращается до 90°
154. Глаза: "Стоп! Я на 90°!"
165. Мозг: "Держи позицию!"
17
18PWM CONTROL СИГНАЛЫ:
19┌─┐     ┌─┐     ← 1.5ms pulse = 90° (center)
20│ │     │ │
21└─┘─────└─┘─────  20ms period (50 Hz)
22
23┌──┐    ┌──┐    ← 2.0ms pulse = 180° (max)
24│  │    │  │
25└──┘────└──┘────
26
27┌┐      ┌┐      ← 1.0ms pulse = 0° (min)
28││      ││
29└┘──────└┘──────
30
31ТИПЫ SERVO:
32🎯 STANDARD (180°): SG90, MG996R
33   • Дешевые ($2-10)
34   • Простые в использовании
35   • Ограниченный угол
36
37🔄 CONTINUOUS (360°): FS90R
38   • Как DC мотор, но с PWM speed control
39   • Может крутиться бесконечно
40   • Контроль скорости, не позиции
41
42🏋️ HIGH-TORQUE: MG996R, DS3218
43   • Металлические шестерни
44   • Высокий крутящий момент (20+ kg⋅cm)
45   • Для тяжелых нагрузок
46
47⚡ DIGITAL SERVO: Futaba, Hitec
48   • Цифровая обратная связь
49   • Быстрее, точнее, дороже ($50+)
50   • Программируемые параметры

 1👣 STEPPER = МОТОР БЕЗ КОМПРОМИССОВ
 2
 3ПРИНЦИП РАБОТЫ:
 4🧲 Электромагниты активируются по очереди
 5🔄 Ротор поворачивается ТОЧНО на один шаг
 6📐 Шаг = 360° / количество шагов
 7
 8ТИПЫ STEPPER'ОВ:
 9📏 FULL STEP:
10   • 200 steps/revolution = 1.8° per step
11   • Максимальный момент
12   • Простое управление
13
14🔬 HALF STEP:  
15   • 400 steps/revolution = 0.9° per step
16   • Более плавное движение
17   • Чуть сложнее в управлении
18
19⚡ MICROSTEPPING:
20   • 1600+ steps/revolution = 0.225° per step
21   • Ультра-плавное движение
22   • Нужен специальный драйвер
23
24STEPPER ДРАЙВЕРЫ:
25🔧 ULN2003 (для 28BYJ-48):
26   • 4-wire control
27   • 5V, слабый момент
28   • Отлично для обучения
29
30💪 A4988/DRV8825:
31   • 2-wire control (step + direction)
32   • Microstepping support
33   • Variable current control
34
35🏭 TMC2208/TMC2209:
36   • Silent operation
37   • Stallguard (обнаружение препятствий)
38   • UART configuration
39
40STEPPING PATTERNS:
41FULL STEP (4-phase):
42Step 1: A=1, B=0, C=0, D=0
43Step 2: A=0, B=1, C=0, D=0  
44Step 3: A=0, B=0, C=1, D=0
45Step 4: A=0, B=0, C=0, D=1
46
47WAVE STEP (1-phase):
48Step 1: A=1, B=0, C=0, D=0
49Step 2: A=0, B=1, C=0, D=0
50Step 3: A=0, B=0, C=1, D=0  
51Step 4: A=0, B=0, C=0, D=1
52
53HALF STEP (8-phase):
54Step 1: A=1, B=0, C=0, D=0
55Step 2: A=1, B=1, C=0, D=0  ← Промежуточный
56Step 3: A=0, B=1, C=0, D=0
57Step 4: A=0, B=1, C=1, D=0  ← Промежуточный
58...
59
60🆕 ADVANCED FEATURES:
61• Homing sequences (поиск нулевой позиции)
62• Acceleration/deceleration profiles
63• Load sensing и stall detection
64• Closed-loop steppers с энкодерами

 1📐 МНОГООСЕВЫЕ СИСТЕМЫ
 2
 3XY PLOTTER СИСТЕМА:
 4      Y-axis (stepper)
 5           ↑
 6    ┌──────┼──────┐
 7    │      │      │
 8────┼──────┼──────┼──── X-axis (stepper)  
 9    │      │      │
10    └──────┼──────┘
11           ↓
12   Pen (servo Z-axis)
13
14КООРДИНАТНОЕ ПРОГРАММИРОВАНИЕ:
15void moveTo(float x, float y) {
16  int stepsX = (x - currentX) * STEPS_PER_MM_X;
17  int stepsY = (y - currentY) * STEPS_PER_MM_Y;
18  
19  // Синхронное движение обеих осей
20  moveSteppers(stepsX, stepsY);
21  
22  currentX = x;
23  currentY = y;
24}
25
26void drawLine(float x1, float y1, float x2, float y2) {
27  int steps = max(abs(x2-x1), abs(y2-y1)) * RESOLUTION;
28  
29  for (int i = 0; i <= steps; i++) {
30    float t = (float)i / steps;
31    float x = x1 + t * (x2 - x1);
32    float y = y1 + t * (y2 - y1);
33    moveTo(x, y);
34    delay(DRAW_SPEED);
35  }
36}
37
38РОБО-РУКА КИНЕМАТИКА:
39Joint Angles → End Effector Position
40
41FORWARD KINEMATICS:
42x = L1*cos(θ1) + L2*cos(θ1+θ2) + L3*cos(θ1+θ2+θ3)
43y = L1*sin(θ1) + L2*sin(θ1+θ2) + L3*sin(θ1+θ2+θ3)
44z = shoulder_height + elbow_offset
45
46INVERSE KINEMATICS (сложнее!):
47θ1 = atan2(y, x)
48θ2 = acos((x²+y²+z²-L1²-L2²)/(2*L1*L2))  
49θ3 = target_orientation - θ1 - θ2
50
51🆕 TRAJECTORY PLANNING:
52• Point-to-point motion
53• Smooth acceleration curves
54• Obstacle avoidance
55• Minimum time paths
56• Energy optimization
57
58CALIBRATION ПРОЦЕДУРЫ:
591. Home position detection (limit switches)
602. Backlash compensation
613. Step calibration (steps per mm/degree)
624. Repeatability testing

 1🎯 HARDWARE SETUP:
 2• Arduino Uno
 3• 2x High-torque servos (MG996R)
 4• Pan-tilt bracket
 5• Laser pointer module
 6• Potentiometer для manual control
 7• OLED display для feedback
 8
 9ПОДКЛЮЧЕНИЕ СНАЙПЕРСКОЙ ТОЧНОСТИ:
10Servo X (pan):  Signal→Pin 9, VCC→6V, GND→GND
11Servo Y (tilt): Signal→Pin 10, VCC→6V, GND→GND  
12Laser:          Control→Pin 8, VCC→5V, GND→GND
13Potentiometer:  Wiper→A0, VCC→5V, GND→GND
14OLED:           SDA→A4, SCL→A5
15
16#include <Servo.h>
17#include <Wire.h>
18#include <Adafruit_SSD1306.h>
19
20Servo panServo, tiltServo;
21Adafruit_SSD1306 display(128, 64, &Wire);
22
23struct TargetPosition {
24  int panAngle;   // 0-180 degrees
25  int tiltAngle;  // 0-180 degrees
26  bool laserOn;
27};
28
29void aimAt(TargetPosition target) {
30  // Плавное движение к цели
31  int currentPan = panServo.read();
32  int currentTilt = tiltServo.read();
33  
34  int steps = max(abs(target.panAngle - currentPan), 
35                  abs(target.tiltAngle - currentTilt));
36  
37  for (int i = 0; i <= steps; i++) {
38    float progress = (float)i / steps;
39    
40    int newPan = currentPan + progress * (target.panAngle - currentPan);
41    int newTilt = currentTilt + progress * (target.tiltAngle - currentTilt);
42    
43    panServo.write(newPan);
44    tiltServo.write(newTilt);
45    
46    updateDisplay(newPan, newTilt);
47    delay(20); // Smooth 50fps movement
48  }
49  
50  digitalWrite(8, target.laserOn); // Laser control
51}
52
53ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
54✓ Точное наведение на 4 угла комнаты
55✓ Следование за движущейся целью (ручное управление)
56✓ Preset позиции: "North", "South", "East", "West"
57✓ Laser ON только при точном позиционировании
58✓ MQTT remote control: {"pan": 90, "tilt": 45, "laser": true}

 1🤖 HARDWARE SETUP:
 2• Arduino Mega (много PWM!)
 3• 5x Servo motors (SG90)
 4• 3D-printed hand или mechanical gripper
 5• Flex sensors (опционально)
 6• Force sensitive resistor
 7• RGB LED для status
 8
 9ПОДКЛЮЧЕНИЕ КИБЕР-РУКИ:
10Thumb:    Pin 3  (большой палец)
11Index:    Pin 5  (указательный)  
12Middle:   Pin 6  (средний)
13Ring:     Pin 9  (безымянный)
14Pinky:    Pin 10 (мизинец)
15Wrist:    Pin 11 (поворот кисти)
16
17struct HandPose {
18  int thumb, index, middle, ring, pinky, wrist;
19  String name;
20};
21
22// Предустановленные позы
23HandPose poses[] = {
24  {90, 90, 90, 90, 90, 90, "Open"},
25  {0, 0, 0, 0, 0, 90, "Fist"},  
26  {90, 0, 90, 90, 90, 90, "Point"},
27  {0, 0, 90, 90, 90, 90, "Peace"},
28  {45, 45, 45, 45, 45, 90, "Gentle_Grip"}
29};
30
31void setPose(HandPose pose) {
32  Serial.println("Setting pose: " + pose.name);
33  
34  // Плавный переход между позами
35  HandPose current = getCurrentPose();
36  
37  for (int step = 0; step <= 100; step++) {
38    float t = step / 100.0;
39    
40    int newThumb = lerp(current.thumb, pose.thumb, t);
41    int newIndex = lerp(current.index, pose.index, t);
42    int newMiddle = lerp(current.middle, pose.middle, t);
43    int newRing = lerp(current.ring, pose.ring, t);
44    int newPinky = lerp(current.pinky, pose.pinky, t);
45    int newWrist = lerp(current.wrist, pose.wrist, t);
46    
47    setFingerPositions(newThumb, newIndex, newMiddle, newRing, newPinky, newWrist);
48    delay(50); // Realistic human-like speed
49  }
50}
51
52// 🆕 Adaptive grip с force feedback
53void adaptiveGrip(int targetForce) {
54  int currentForce = analogRead(FORCE_SENSOR);
55  
56  while (abs(currentForce - targetForce) > 10) {
57    if (currentForce < targetForce) {
58      tightenGrip(5); // Increase grip gradually
59    } else {
60      loosenGrip(5);  // Decrease grip gradually  
61    }
62    
63    currentForce = analogRead(FORCE_SENSOR);
64    delay(100);
65    
66    // Safety: don't crush objects!
67    if (currentForce > MAX_SAFE_FORCE) {
68      emergencyRelease();
69      break;
70    }
71  }
72}
73
74ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
75✓ Демонстрация всех preset поз
76✓ Захват объектов разного размера
77✓ Адаптивный grip с force control
78✓ "Rock Paper Scissors" игра
79✓ MQTT жесты: {"gesture": "peace", "speed": "slow"}

  1📐 HARDWARE SETUP:
  2• Arduino Uno
  3• 2x NEMA17 stepper motors
  4• 2x A4988 stepper drivers  
  5• XY mechanical frame
  6• Servo для pen lift
  7• Limit switches для homing
  8• 12V power supply
  9
 10ПОДКЛЮЧЕНИЕ ТОЧНОЙ МЕХАНИКИ:
 11X-Stepper Driver:
 12├── Step → Pin 2
 13├── Dir  → Pin 3  
 14├── Enable → Pin 4
 15└── VDD → 12V, VMOT → 12V
 16
 17Y-Stepper Driver:
 18├── Step → Pin 5
 19├── Dir  → Pin 6
 20├── Enable → Pin 7
 21└── VDD → 12V, VMOT → 12V
 22
 23Pen Servo: Signal → Pin 9
 24Limit Switches: X→Pin 10, Y→Pin 11
 25
 26#include <AccelStepper.h>
 27#include <MultiStepper.h>
 28
 29AccelStepper stepperX(AccelStepper::DRIVER, 2, 3);
 30AccelStepper stepperY(AccelStepper::DRIVER, 5, 6);
 31MultiStepper steppers;
 32
 33// Калибровка системы
 34const float STEPS_PER_MM_X = 80.0; // Зависит от шкивов/винтов
 35const float STEPS_PER_MM_Y = 80.0;
 36const float MAX_SPEED = 1000;      // steps/second
 37const float ACCELERATION = 500;    // steps/second²
 38
 39void setup() {
 40  stepperX.setMaxSpeed(MAX_SPEED);
 41  stepperX.setAcceleration(ACCELERATION);
 42  stepperY.setMaxSpeed(MAX_SPEED);  
 43  stepperY.setAcceleration(ACCELERATION);
 44  
 45  steppers.addStepper(stepperX);
 46  steppers.addStepper(stepperY);
 47  
 48  homeAxes(); // Найти нулевую позицию
 49}
 50
 51void homeAxes() {
 52  // Двигаемся к limit switches
 53  while (!digitalRead(10)) { // X limit
 54    stepperX.move(-1);
 55    stepperX.run();
 56  }
 57  
 58  while (!digitalRead(11)) { // Y limit  
 59    stepperY.move(-1);
 60    stepperY.run();
 61  }
 62  
 63  // Устанавливаем текущую позицию как (0,0)
 64  stepperX.setCurrentPosition(0);
 65  stepperY.setCurrentPosition(0);
 66}
 67
 68void moveToMM(float x, float y) {
 69  long targetX = x * STEPS_PER_MM_X;
 70  long targetY = y * STEPS_PER_MM_Y;
 71  
 72  long positions[2] = {targetX, targetY};
 73  steppers.moveTo(positions);
 74  steppers.runSpeedToPosition(); // Синхронное движение
 75}
 76
 77void drawCircle(float centerX, float centerY, float radius, int segments) {
 78  penUp();
 79  
 80  for (int i = 0; i <= segments; i++) {
 81    float angle = 2.0 * PI * i / segments;
 82    float x = centerX + radius * cos(angle);
 83    float y = centerY + radius * sin(angle);
 84    
 85    if (i == 0) {
 86      moveToMM(x, y);
 87      penDown();
 88    } else {
 89      moveToMM(x, y);
 90    }
 91  }
 92  
 93  penUp();
 94}
 95
 96// 🆕 G-code interpreter
 97void processGCode(String command) {
 98  if (command.startsWith("G0") || command.startsWith("G1")) {
 99    // Linear movement
100    float x = parseFloat(command, 'X');
101    float y = parseFloat(command, 'Y');
102    moveToMM(x, y);
103  }
104  else if (command.startsWith("M3")) {
105    penDown(); // Pen down
106  }
107  else if (command.startsWith("M5")) {
108    penUp();   // Pen up
109  }
110  else if (command.startsWith("G28")) {
111    homeAxes(); // Home
112  }
113}
114
115ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
116✓ Нарисовать идеальный квадрат 50x50mm
117✓ Нарисовать окружность радиусом 25mm
118✓ Написать текст "IoT 2025"
119✓ Homing sequence при старте
120✓ MQTT G-code commands: {"gcode": "G1 X50 Y50"}

  1📸 HARDWARE SETUP:
  2• ESP32 (WiFi + больше памяти)
  3• NEMA17 stepper + TMC2208 (silent!)
  4• Linear rail system
  5• Camera mount
  6• Hall sensor для position feedback
  7• OLED display
  8• Battery pack для portable operation
  9
 10ПОДКЛЮЧЕНИЕ КИНЕМАТОГРАФИЧЕСКОЙ ТОЧНОСТИ:
 11TMC2208 → ESP32:
 12├── Step → GPIO 2
 13├── Dir  → GPIO 4
 14├── EN   → GPIO 16
 15├── UART → GPIO 17 (для настройки)
 16└── VMotor → 12V
 17
 18Hall Position Sensor → GPIO 34 (analog)
 19OLED Display → SDA: GPIO 21, SCL: GPIO 22
 20
 21#include <TMCStepper.h>
 22#include <AccelStepper.h>
 23
 24TMC2208Stepper driver(&Serial2, R_SENSE, DRIVER_ADDRESS);
 25AccelStepper stepper = AccelStepper(stepper.DRIVER, 2, 4);
 26
 27struct CameraMove {
 28  float startPos;    // mm from home
 29  float endPos;      // mm from home  
 30  float duration;    // seconds
 31  String easing;     // "linear", "ease_in", "ease_out", "ease_in_out"
 32};
 33
 34void executeMove(CameraMove move) {
 35  long startSteps = move.startPos * STEPS_PER_MM;
 36  long endSteps = move.endPos * STEPS_PER_MM;
 37  long totalSteps = abs(endSteps - startSteps);
 38  
 39  unsigned long startTime = millis();
 40  unsigned long moveDuration = move.duration * 1000; // Convert to ms
 41  
 42  while (millis() - startTime < moveDuration) {
 43    float progress = (float)(millis() - startTime) / moveDuration;
 44    
 45    // Apply easing function
 46    if (move.easing == "ease_in") {
 47      progress = progress * progress;
 48    } else if (move.easing == "ease_out") {
 49      progress = 1 - (1 - progress) * (1 - progress);
 50    } else if (move.easing == "ease_in_out") {
 51      progress = progress < 0.5 ? 
 52        2 * progress * progress : 
 53        1 - 2 * (1 - progress) * (1 - progress);
 54    }
 55    
 56    long targetSteps = startSteps + progress * (endSteps - startSteps);
 57    stepper.moveTo(targetSteps);
 58    stepper.run();
 59    
 60    // Update position display
 61    updateOLED(stepper.currentPosition() / STEPS_PER_MM, progress * 100);
 62  }
 63}
 64
 65// 🆕 Time-lapse photography integration
 66void timelapseSequence(int shots, float totalDistance, int intervalSeconds) {
 67  float stepDistance = totalDistance / (shots - 1);
 68  
 69  for (int shot = 0; shot < shots; shot++) {
 70    float position = shot * stepDistance;
 71    
 72    // Move to position
 73    stepper.moveTo(position * STEPS_PER_MM);
 74    stepper.runToPosition();
 75    
 76    // Trigger camera (relay or servo)
 77    triggerCamera();
 78    
 79    // Wait for interval
 80    delay(intervalSeconds * 1000);
 81    
 82    // MQTT status update
 83    publishTimelapseProgress(shot + 1, shots, position);
 84  }
 85}
 86
 87// 🆕 Motion control profiles
 88void cinematicMove(float distance, float maxSpeed, float acceleration) {
 89  // Professional cinema-quality motion profiles
 90  long targetSteps = distance * STEPS_PER_MM;
 91  
 92  stepper.setMaxSpeed(maxSpeed * STEPS_PER_MM);
 93  stepper.setAcceleration(acceleration * STEPS_PER_MM);
 94  stepper.moveTo(targetSteps);
 95  
 96  while (stepper.distanceToGo() != 0) {
 97    stepper.run();
 98    
 99    // Real-time position feedback
100    float currentPos = stepper.currentPosition() / STEPS_PER_MM;
101    float currentSpeed = stepper.speed() / STEPS_PER_MM;
102    
103    publishMotionTelemetry(currentPos, currentSpeed);
104    delay(10);
105  }
106}
107
108ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
109✓ Smooth linear движение на 1 метр за 30 секунд
110✓ Time-lapse: 10 кадров с интервалом 5 секунд
111✓ Ease-in/ease-out motion profiles
112✓ Position feedback с точностью ±1mm
113✓ MQTT cinema control: {"move": "linear", "distance": 500, "time": 20}

  1// 🎼 MULTI-ROBOT COORDINATION SYSTEM
  2#include <WiFi.h>
  3#include <PubSubClient.h>
  4#include <ArduinoJson.h>
  5
  6// Global coordination state
  7struct RobotState {
  8  String robotId;
  9  float positionX, positionY, positionZ;
 10  bool isMoving;
 11  unsigned long lastUpdate;
 12};
 13
 14RobotState robots[4]; // Track all robots in system
 15
 16// 🎯 CHOREOGRAPHED SEQUENCES
 17void executeChoreography(String sequenceName) {
 18  if (sequenceName == "synchronized_dance") {
 19    // All robots move in perfect synchronization
 20    
 21    // Turret: Pan 180° in 10 seconds
 22    publishMQTT("robots/turret/command", 
 23               "{\"action\":\"pan\", \"angle\":180, \"duration\":10}");
 24    
 25    // Hand: Wave gesture
 26    publishMQTT("robots/hand/command",
 27               "{\"gesture\":\"wave\", \"repetitions\":5, \"speed\":\"medium\"}");
 28    
 29    // Plotter: Draw spiral
 30    publishMQTT("robots/plotter/command",
 31               "{\"shape\":\"spiral\", \"radius\":50, \"turns\":3}");
 32               
 33    // Camera: Smooth tracking shot
 34    publishMQTT("robots/camera/command", 
 35               "{\"move\":\"tracking\", \"distance\":800, \"duration\":10}");
 36  }
 37  
 38  else if (sequenceName == "assembly_line") {
 39    // Industrial coordination sequence
 40    
 41    // 1. Plotter draws part outline
 42    publishMQTT("robots/plotter/command", "{\"action\":\"draw_template\"}");
 43    
 44    // 2. Camera moves to inspect
 45    delay(2000);
 46    publishMQTT("robots/camera/command", "{\"action\":\"inspect_quality\"}");
 47    
 48    // 3. Hand picks up part
 49    delay(1000); 
 50    publishMQTT("robots/hand/command", "{\"action\":\"pick_part\"}");
 51    
 52    // 4. Turret laser marks part
 53    delay(1500);
 54    publishMQTT("robots/turret/command", "{\"action\":\"laser_mark\"}");
 55    
 56    // 5. Hand places finished part
 57    delay(1000);
 58    publishMQTT("robots/hand/command", "{\"action\":\"place_part\"}");
 59  }
 60  
 61  else if (sequenceName == "security_mode") {
 62    // Coordinated security scanning
 63    
 64    // Turret: Sweep area in search pattern
 65    publishMQTT("robots/turret/command",
 66               "{\"action\":\"security_sweep\", \"pattern\":\"spiral\"}");
 67    
 68    // Camera: Follow turret with recording
 69    publishMQTT("robots/camera/command", 
 70               "{\"action\":\"follow_turret\", \"record\":true}");
 71    
 72    // Hand: Ready position for interaction
 73    publishMQTT("robots/hand/command",
 74               "{\"pose\":\"alert_ready\"}");
 75  }
 76}
 77
 78// 🔄 REAL-TIME COORDINATION
 79void onMqttMessage(char* topic, byte* payload, unsigned int length) {
 80  String message = String((char*)payload, length);
 81  StaticJsonDocument<300> doc;
 82  deserializeJson(doc, message);
 83  
 84  // Update robot states
 85  if (String(topic).startsWith("robots/") && String(topic).endsWith("/status")) {
 86    String robotId = extractRobotId(topic);
 87    updateRobotState(robotId, doc);
 88  }
 89  
 90  // Coordination commands
 91  if (String(topic) == "coordination/choreography") {
 92    String sequence = doc["sequence"];
 93    executeChoreography(sequence);
 94  }
 95  
 96  // Emergency coordination
 97  if (String(topic) == "coordination/emergency") {
 98    emergencyStopAll();
 99  }
100  
101  // Formation control
102  if (String(topic) == "coordination/formation") {
103    String formation = doc["formation"];
104    executeFormation(formation);
105  }
106}
107
108// 🆕 COLLISION AVOIDANCE
109bool checkCollisionRisk(String robotA, String robotB) {
110  RobotState stateA = getRobotState(robotA);
111  RobotState stateB = getRobotState(robotB);
112  
113  float distance = sqrt(pow(stateA.positionX - stateB.positionX, 2) +
114                       pow(stateA.positionY - stateB.positionY, 2) +
115                       pow(stateA.positionZ - stateB.positionZ, 2));
116  
117  return distance < MINIMUM_SAFE_DISTANCE;
118}
119
120void avoidCollision(String robotA, String robotB) {
121  // Pause lower priority robot
122  if (getRobotPriority(robotA) > getRobotPriority(robotB)) {
123    pauseRobot(robotB);
124  } else {
125    pauseRobot(robotA);
126  }
127  
128  // Resume when safe
129  while (checkCollisionRisk(robotA, robotB)) {
130    delay(100);
131  }
132  
133  resumeRobot(robotA);
134  resumeRobot(robotB);
135}

  1// 🎥 COMPUTER VISION + SERVO CONTROL
  2#include <OpenCV.h> // Псевдокод для концепции
  3
  4struct Target {
  5  int x, y;           // Pixel coordinates
  6  float confidence;   // Detection confidence 0-1
  7  bool detected;
  8};
  9
 10class VisualServoController {
 11private:
 12  Servo panServo, tiltServo;
 13  int currentPan = 90, currentTilt = 90;
 14  
 15public:
 16  void trackTarget(Target target) {
 17    if (!target.detected) {
 18      // Search pattern if target lost
 19      searchPattern();
 20      return;
 21    }
 22    
 23    // Convert pixel error to servo adjustment
 24    int centerX = CAMERA_WIDTH / 2;
 25    int centerY = CAMERA_HEIGHT / 2;
 26    
 27    int errorX = target.x - centerX;
 28    int errorY = target.y - centerY;
 29    
 30    // PID control for smooth tracking
 31    float panAdjust = pidX.calculate(errorX);
 32    float tiltAdjust = pidY.calculate(errorY);
 33    
 34    // Update servo positions
 35    currentPan = constrain(currentPan + panAdjust, 0, 180);
 36    currentTilt = constrain(currentTilt + tiltAdjust, 0, 180);
 37    
 38    panServo.write(currentPan);
 39    tiltServo.write(currentTilt);
 40    
 41    // Publish tracking data
 42    publishTrackingData(target, currentPan, currentTilt);
 43  }
 44  
 45  void searchPattern() {
 46    // Systematic search when target lost
 47    static int searchStep = 0;
 48    static unsigned long lastSearch = 0;
 49    
 50    if (millis() - lastSearch > 200) {
 51      // Spiral search pattern
 52      float angle = searchStep * 0.2;
 53      float radius = min(searchStep * 2, 40);
 54      
 55      int newPan = 90 + radius * cos(angle);
 56      int newTilt = 90 + radius * sin(angle);
 57      
 58      panServo.write(newPan);
 59      tiltServo.write(newTilt);
 60      
 61      searchStep++;
 62      lastSearch = millis();
 63      
 64      if (searchStep > 100) searchStep = 0; // Reset search
 65    }
 66  }
 67};
 68
 69// 🆕 OBJECT RECOGNITION + ROBOT INTERACTION
 70void objectRecognitionLoop() {
 71  // Capture frame from camera
 72  Mat frame = captureFrame();
 73  
 74  // Detect objects (colors, shapes, faces, etc.)
 75  vector<Target> detectedObjects = detectObjects(frame);
 76  
 77  for (auto& obj : detectedObjects) {
 78    if (obj.confidence > 0.8) {
 79      
 80      // Different actions for different objects
 81      if (obj.type == "red_ball") {
 82        // Turret: Track red ball
 83        visualServo.trackTarget(obj);
 84        
 85        // Hand: Ready to catch
 86        publishMQTT("robots/hand/command", "{\"pose\":\"ready_catch\"}");
 87      }
 88      
 89      else if (obj.type == "human_face") {
 90        // Friendly wave
 91        publishMQTT("robots/hand/command", "{\"gesture\":\"wave\"}");
 92        
 93        // Look at person
 94        visualServo.trackTarget(obj);
 95      }
 96      
 97      else if (obj.type == "qr_code") {
 98        // Decode QR and execute command
 99        String command = decodeQR(obj);
100        executeQRCommand(command);
101      }
102    }
103  }
104}
105
106// 🆕 AUGMENTED REALITY OVERLAY
107void publishAROverlay() {
108  StaticJsonDocument<500> ar_data;
109  
110  ar_data["robots"]["turret"]["position"] = {currentPan, currentTilt};
111  ar_data["robots"]["turret"]["laser_active"] = laserActive;
112  
113  ar_data["detection"]["targets"] = detectedTargets.size();
114  ar_data["detection"]["tracking_active"] = trackingActive;
115  
116  ar_data["workspace"]["safe_zone"] = calculateSafeZone();
117  ar_data["workspace"]["collision_risk"] = checkCollisionRisk();
118  
119  String ar_json;
120  serializeJson(ar_data, ar_json);
121  
122  client.publish("coordination/ar_overlay", ar_json.c_str());
123}

1ЗАДАЧА: Laser pointer точное попадание в цели
2✓ 5 мишеней размером 1см на расстоянии 2м
3✓ Время: максимум 30 секунд на все цели
4✓ Scoring: 10 points за попадание, -2 за промах
5✓ BONUS: Движущаяся мишень (+20 points)
6✓ MQTT real-time scoring система

1ЗАДАЧА: Нарисовать сложную геометрическую фигуру
2✓ Star with 8 points, каждый луч точно 25mm
3✓ Tolerance: ±0.5mm максимум
4✓ No pen lifts during drawing
5✓ Scoring: Accuracy measurement с штангенциркулем
6✓ BONUS: 3D wireframe cube drawing (+30 points)

1ЗАДАЧА: Pick-and-place марафон
2✓ Переложить 10 objects разного размера
3✓ От маленьких (спичка) до больших (теннисный мяч)
4✓ No dropping = perfect score
5✓ Speed bonus: под 60 секунд
6✓ BONUS: Stack objects в tower (+25 points)

1ЗАДАЧА: Снять "professional" video sequence
2✓ Smooth movement без jerks
3✓ Follow moving object
4✓ 3 different motion profiles (linear, ease-in, ease-out)
5✓ Scoring: Visual quality + smoothness
6✓ BONUS: Time-lapse sequence (+15 points)

1ЗАДАЧА: Все роботы работают вместе
2✓ Choreographed sequence на 2 минуты
3✓ No collisions между роботами
4✓ Synchronized timing
5✓ Creative storytelling
6✓ BONUS: Audience participation (+40 points)

 1📏 MEASUREMENT PROTOCOLS:
 2
 3SERVO ACCURACY:
 4• Commanded vs actual position (encoder feedback)
 5• Repeatability testing (10 cycles to same position)
 6• Hysteresis measurement (forward vs reverse)
 7• Temperature drift analysis
 8
 9STEPPER PRECISION:
10• Step accuracy (oscilloscope measurement)
11• Lost steps detection
12• Mechanical backlash quantification
13• Load vs accuracy correlation
14
15SYSTEM PERFORMANCE:
16• End-to-end latency (MQTT command → mechanical response)
17• Throughput (operations per minute)
18• Error rates under different conditions
19• Power consumption vs performance
20
21REAL-WORLD BENCHMARKS:
22• Industrial robot accuracy: ±0.1mm
23• 3D printer precision: ±0.05mm
24• Medical robot precision: ±0.01mm
25• Where do our systems rank?

 1⚙️ PRECISION MANUFACTURING SPECIFICATION:
 2
 31. ACCURACY REQUIREMENTS:
 4   • Position tolerance: ±0.05mm
 5   • Angular precision: ±0.1°
 6   • Repeatability: 99.9%
 7   • Cycle time: <30 seconds per operation
 8
 92. MULTI-AXIS COORDINATION:
10   • 6-DOF robotic arm design
11   • XY positioning table
12   • Rotary indexing для parts
13   • Vision system для quality control
14
153. PROCESS AUTOMATION:
16   • Pick micro-components (1mm parts)
17   • Precise assembly sequence
18   • Quality inspection
19   • Automatic rejection of defects
20
214. 🆕 INDUSTRY 4.0 INTEGRATION:
22   • Digital twin simulation
23   • Predictive maintenance
24   • Real-time production analytics
25   • Remote monitoring capabilities
26
27DELIVERABLE: Complete automation cell design + precision analysis