Update app.py

app.py

@@ -2,64 +2,78 @@ from flask import Flask, request, jsonify, render_template
 import requests
 import threading
 import time
-import json
-import os
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
 
-# Global variables to track servo state
 servo_state = {
-    'a_pressed': False,
     'current_angles': [0, 0, 0],
     'rotation_active': False,
-    'esp_ip': None
+    'esp_ip': "manipulatable-ungenitive-lorenzo.ngrok-free.dev"  # Your ngrok URL
 }
 
-# Thread lock for thread safety
 state_lock = threading.Lock()
 
 def send_servo_command(servo_num, angle):
+    """Send command to specific servo with detailed logging"""
     try:
         with state_lock:
             esp_ip = servo_state['esp_ip']
         
-        # Use your ngrok URL directly
+        if not esp_ip:
+            error_msg = "No ESP32 IP configured"
+            logger.error(error_msg)
+            return error_msg
+            
+        # Construct the URL - IMPORTANT: ngrok uses http (not https for free tier)
         url = f"http://{esp_ip}/{servo_num}?angle={angle}"
-        print(f"Calling: {url}")
+        logger.info(f"🔧 Sending to ESP32: {url}")
         
-        response = requests.get(url, timeout=5)
-        return f"Servo {servo_num} → {angle}°"
+        # Add a timeout and better error handling
+        response = requests.get(url, timeout=10)
         
-    except Exception as e:
-        return f"Error: {e}"
-
-def send_stop_command():
-    """Send emergency stop command"""
-    try:
-        with state_lock:
-            esp_ip = servo_state['esp_ip']
+        logger.info(f"📡 ESP32 Response: HTTP {response.status_code} - {response.text}")
         
-        if not esp_ip:
-            return "Error: No ESP32 IP configured"
+        if response.status_code == 200:
+            success_msg = f"Servo {servo_num} → {angle}°"
+            logger.info(f"✅ {success_msg}")
+            return success_msg
+        else:
+            error_msg = f"ESP32 returned HTTP {response.status_code}"
+            logger.error(f"❌ {error_msg}")
+            return error_msg
             
-        url = f"http://{esp_ip}/stop"
-        response = requests.get(url, timeout=1)
-        return "EMERGENCY STOP"
+    except requests.exceptions.ConnectTimeout:
+        error_msg = "Connection timeout - ngrok/ESP32 not responding"
+        logger.error(f"❌ {error_msg}")
+        return error_msg
+    except requests.exceptions.ConnectionError as e:
+        error_msg = f"Cannot connect to ESP32 via ngrok: {str(e)}"
+        logger.error(f"❌ {error_msg}")
+        return error_msg
     except Exception as e:
-        return f"Stop Error: {e}"
+        error_msg = f"Unexpected error: {str(e)}"
+        logger.error(f"❌ {error_msg}")
+        return error_msg
 
 def continuous_rotation():
     """Background thread for continuous rotation"""
     ROTATION_SPEED = 5
-    ROTATION_DELAY = 0.1  # seconds between updates
+    ROTATION_DELAY = 0.2  # seconds between updates
     
     while True:
         with state_lock:
             rotation_active = servo_state['rotation_active']
-            esp_ip = servo_state['esp_ip']
         
-        if rotation_active and esp_ip:
+        if rotation_active:
             try:
+                logger.info("🔄 Rotation active - moving servos")
+                messages = []
+                
                 # Rotate all servos
                 for i, servo_num in enumerate([1, 2, 3]):
                     with state_lock:
@@ -70,125 +84,72 @@ def continuous_rotation():
                         angle = servo_state['current_angles'][i]
                     
                     # Send command to servo
-                    send_servo_command(servo_num, angle)
+                    msg = send_servo_command(servo_num, angle)
+                    messages.append(msg)
                 
+                logger.info(f"🎯 Rotation completed: {messages}")
                 time.sleep(ROTATION_DELAY)
+                
             except Exception as e:
-                print(f"Rotation error: {e}")
-                time.sleep(0.5)
+                logger.error(f"💥 Rotation error: {e}")
+                time.sleep(1)
         else:
             time.sleep(0.1)
 
-@app.route('/')
-def index():
-    """Serve the main control page"""
-    return render_template('index.html')
-
-@app.route('/set_ip', methods=['POST'])
-def set_ip():
-    """Set the ESP32 IP address"""
-    data = request.get_json()
-    esp_ip = data.get('ip', '').strip()
-    
-    if esp_ip:
-        with state_lock:
-            servo_state['esp_ip'] = esp_ip
-        return jsonify({'status': 'success', 'message': f'ESP32 IP set to: {esp_ip}'})
-    else:
-        return jsonify({'status': 'error', 'message': 'No IP provided'})
+# ... keep your existing routes but add a debug route ...
 
-@app.route('/start_rotation', methods=['POST'])
-def start_rotation():
-    """Start continuous rotation (equivalent to holding 'A')"""
-    with state_lock:
-        servo_state['rotation_active'] = True
-        servo_state['a_pressed'] = True
-    
-    return jsonify({
-        'status': 'success', 
-        'message': 'Continuous rotation started',
-        'angles': servo_state['current_angles']
-    })
-
-@app.route('/stop_rotation', methods=['POST'])
-def stop_rotation():
-    """Stop rotation and send emergency stop (equivalent to releasing 'A')"""
-    with state_lock:
-        servo_state['rotation_active'] = False
-        servo_state['a_pressed'] = False
-    
-    stop_msg = send_stop_command()
-    
-    return jsonify({
-        'status': 'success', 
-        'message': 'Rotation stopped',
-        'stop_message': stop_msg,
-        'angles': servo_state['current_angles']
-    })
-
-@app.route('/reset_servos', methods=['POST'])
-def reset_servos():
-    """Reset all servos to 0 degrees (equivalent to pressing 'R')"""
-    messages = []
-    with state_lock:
-        for i in range(3):
-            servo_state['current_angles'][i] = 0
-            msg = send_servo_command(i+1, 0)
-            messages.append(msg)
-    
-    return jsonify({
-        'status': 'success', 
-        'message': 'Servos reset to 0°',
-        'details': messages,
-        'angles': servo_state['current_angles']
-    })
-
-@app.route('/set_angle', methods=['POST'])
-def set_angle():
-    """Set specific angle for a servo"""
-    data = request.get_json()
-    servo_num = data.get('servo')
-    angle = data.get('angle')
-    
+@app.route('/debug_esp')
+def debug_esp():
+    """Test connection to ESP32 directly"""
     try:
-        servo_num = int(servo_num)
-        angle = int(angle)
-        
-        if servo_num < 1 or servo_num > 3:
-            return jsonify({'status': 'error', 'message': 'Servo number must be 1, 2, or 3'})
+        with state_lock:
+            esp_ip = servo_state['esp_ip']
         
-        if angle < 0 or angle > 180:
-            return jsonify({'status': 'error', 'message': 'Angle must be between 0 and 180'})
+        if not esp_ip:
+            return jsonify({'status': 'error', 'message': 'No ESP32 IP configured'})
         
-        with state_lock:
-            servo_state['current_angles'][servo_num-1] = angle
+        test_url = f"http://{esp_ip}/"
+        logger.info(f"🧪 Testing ESP32 connection: {test_url}")
         
-        msg = send_servo_command(servo_num, angle)
+        response = requests.get(test_url, timeout=10)
         
         return jsonify({
             'status': 'success', 
-            'message': f'Servo {servo_num} set to {angle}°',
-            'details': msg,
-            'angles': servo_state['current_angles']
+            'message': f'ESP32 is reachable',
+            'url_called': test_url,
+            'http_status': response.status_code,
+            'response_preview': response.text[:200] if response.text else 'Empty response'
         })
-    except ValueError:
-        return jsonify({'status': 'error', 'message': 'Invalid servo number or angle'})
-
-@app.route('/get_status', methods=['GET'])
-def get_status():
-    """Get current servo status"""
-    with state_lock:
+            
+    except Exception as e:
         return jsonify({
-            'a_pressed': servo_state['a_pressed'],
-            'rotation_active': servo_state['rotation_active'],
-            'current_angles': servo_state['current_angles'],
-            'esp_ip': servo_state['esp_ip']
+            'status': 'error', 
+            'message': f'Cannot reach ESP32: {str(e)}'
         })
 
+@app.route('/test_servo')
+def test_servo():
+    """Test sending a specific servo command"""
+    servo_num = request.args.get('servo', '1')
+    angle = request.args.get('angle', '90')
+    
+    result = send_servo_command(int(servo_num), int(angle))
+    
+    return jsonify({
+        'servo': servo_num,
+        'angle': angle,
+        'result': result
+    })
+
+# ... keep your existing start_rotation, stop_rotation, etc routes ...
+
 if __name__ == '__main__':
+    # Log startup info
+    logger.info("🚀 Starting Servo Controller")
+    logger.info(f"🎯 ESP32 Target: {servo_state['esp_ip']}")
+    
     # Start the continuous rotation thread
     rotation_thread = threading.Thread(target=continuous_rotation, daemon=True)
     rotation_thread.start()
     
-    # Run Flask app
-    app.run(host='0.0.0.0', port=5000, debug=False)
+    app.run(host='0.0.0.0', port=7860, debug=False)