CloudStationTeam
diff --git a/‎.env‎
Lines changed: 5 additions & 0 deletions b/‎.env‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎.gitignore‎
Lines changed: 3 additions & 1 deletion b/‎.gitignore‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎flight_data_collect/drone_communication/autocomplete.py‎
Lines changed: 30 additions & 0 deletions b/‎flight_data_collect/drone_communication/autocomplete.py‎
Lines changed: 30 additions & 0 deletions
diff --git a/‎flight_data_collect/drone_communication/lidar_data.py‎
Lines changed: 175 additions & 0 deletions b/‎flight_data_collect/drone_communication/lidar_data.py‎
Lines changed: 175 additions & 0 deletions
diff --git a/‎flight_data_collect/drone_communication/logs.py‎
Lines changed: 16 additions & 0 deletions b/‎flight_data_collect/drone_communication/logs.py‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎flight_data_collect/drone_communication/mavlink_control.py‎
Lines changed: 96 additions & 2 deletions b/‎flight_data_collect/drone_communication/mavlink_control.py‎
Lines changed: 96 additions & 2 deletions
@@ -0,0 +1,5 @@
+
+GOOGLE_MAP_API_KEY=smt
+
+
+
@@ -29,4 +29,6 @@ db.sqlite3
 .idea
 *.pyc
 __pycache__/
-static/*
+static/*
+.env
+
@@ -0,0 +1,30 @@
+import requests
+from django.conf import settings
+from django.http import JsonResponse
+
+def autocomplete_view(query, lat=None, lon=None):
+    params = {
+        'input': query,
+        'key': settings.GOOGLE_MAP_API_KEY,
+    }
+    if not (lat and lon):
+        # UC Irvine GPS 
+        #https://latitude.to/articles-by-country/us/united-states/1122/university-of-california-irvine
+        lat = 33.6405407712 
+        lon = -117.838914978 
+        params['location'] = f'{lat},{lon}' # This biases the autocomplete predictions to the specified location
+
+    #response = requests.get(f'https://maps.googleapis.com/maps/api/place/autocomplete/json?input={query}&key={settings.GOOGLE_MAP_API_KEY}')
+    response = requests.get('https://maps.googleapis.com/maps/api/place/autocomplete/json', params=params)
+    
+    print(response.text if response.status_code == 200 else None) # Not all eq, Not pass 
+    
+    #return JsonResponse(response.json()) # TypeError: Object of type 'JsonResponse' is not JSON serializable
+    return response.json()
+
+def test_autocomplete_view():
+    print("test_autocomplete_view")
+    query = "1 Shields Ave., Davis, CA 95616"
+    places = autocomplete_view(query)
+    print(places, "???")
+
@@ -0,0 +1,175 @@
+from pymavlink import mavutil
+import time
+import socket 
+
+
+def find_vacant_channel(master):
+    # Retrieve RC_CHANNELS message
+    msg = master.recv_match(type='RC_CHANNELS', blocking=True)
+
+    # Iterate through RC channel values to find vacant channels
+    vacant_channels = []
+    for i in range(1, msg.chancount + 1):
+        # Check if the channel value is unassigned or unused
+        if msg['chan{}_raw'.format(i)] == 0:
+            vacant_channels.append(i)
+            return i
+
+    #print("Vacant channels: ", vacant_channels)
+
+    #if not len(vacant_channels):
+    return -1
+
+def find_switch_threshold(master, channel_number):
+    # Monitor the state of the switch to determine the threshold value
+    initial_state = None
+
+    while initial_state is None:
+        msg = master.recv_match(type='RC_CHANNELS', blocking=True)
+        switch_value = getattr(msg, "chan{}_raw".format(channel_number), None)
+
+        if switch_value is not None:
+            initial_state = switch_value
+            print("Initial switch value:", initial_state)
+
+    # Determine the threshold value based on the initial state
+    threshold_value = initial_state - 100  # Adjust the threshold offset as needed
+    print("Threshold value:", threshold_value)
+
+    return threshold_value
+
+def toggle_avoidance_system(master, channel_number, threshold_value):
+    # Set the RCx_OPTION parameter to 40 (replace x with the vacant channel number)
+    rc_option_param = "RC{}_OPTION".format(channel_number)
+    master.param_set(rc_option_param, 40)
+
+    # Monitor the state of the switch
+    while True:
+        msg = master.recv_match(type='RC_CHANNELS', blocking=True)
+        switch_value = getattr(msg, "chan{}_raw".format(channel_number), None)
+
+        if switch_value is not None and switch_value > threshold_value:
+            # Activate the avoidance system
+            print("Avoidance system activated")
+            # Your code to activate the avoidance system goes here
+        else:
+            # Deactivate the avoidance system
+            print("Avoidance system deactivated")
+            # Your code to deactivate the avoidance system goes here
+
+def format_param_message(param_name, param_value, success):
+    if success:
+        return f"Parameter {param_name} was successfully set to {param_value}"
+    else:
+        return f"Failed to set parameter {param_name}"
+
+def print_param(mav, param_name, param_value):
+    # Request the current value of the parameter
+    mav.param_fetch_one(param_name)
+
+    # Wait for the parameter value to be received
+    while mav.param(param_name) is None:
+        msg = mav.recv_match(type='PARAM_VALUE', blocking=True)
+
+    # Check if the parameter value matches the value we tried to set
+    success = mav.param(param_name) == param_value
+    print(format_param_message(param_name, param_value, success))
+
+def config_lidar(): #or other proximity sensors.
+    print("D1")
+    # Connect to the autopilot
+    #master = mavutil.mavlink_connection('udpout:localhost:14550')
+    SERVER_IP = socket.gethostbyname(socket.gethostname())
+    connect_address = 14550
+    master = mavutil.mavlink_connection(SERVER_IP + ':' + str(connect_address))
+    print(str(SERVER_IP)+" "+str(connect_address)) #dude it's private ip...
+    
+    while(master.target_system == 0):
+        print("Checking Heartbeat")
+        
+        #the_connection.wait_heartbeat()
+        msg = master.wait_heartbeat(timeout=6)
+        if msg:
+            print(msg)
+            break
+    print("D2")
+
+    # Set AVOID_ENABLE to use all sources of barrier information
+    master.mav.param_set_send(
+        target_system=1,
+        target_component=1,
+        param_id=b"AVOID_ENABLE",
+        param_value=7,
+        param_type=mavutil.mavlink.MAV_PARAM_TYPE_UINT8
+    )
+
+    #print("Message Read" + str(master.recv_match(type="COMMAND_ACK", blocking =True))
+    print_param(master, "AVOID_ENABLE", 7)
+
+    # Set PRX1_TYPE to enable using a 360-degree Lidar as a "proximity sensor"
+    master.mav.param_set_send(
+        target_system=1,
+        target_component=1,
+        param_id=b"PRX1_TYPE",
+        param_value=15,
+        param_type=mavutil.mavlink.MAV_PARAM_TYPE_UINT8
+    )
+
+    print_param(master, "PRX1_TYPE", 15)
+
+    # Set AVOID_MARGIN to control the distance from the barrier
+    master.mav.param_set_send(
+        target_system=1,
+        target_component=1,
+        param_id=b"AVOID_MARGIN",
+        param_value=5,
+        param_type=mavutil.mavlink.MAV_PARAM_TYPE_REAL32
+    )
+
+    print_param(master, "AVOID_MARGIN", 5)
+
+    # Set AVOID_BEHAVE to control avoidance behavior
+    master.mav.param_set_send(
+        target_system=1,
+        target_component=1,
+        param_id=b"AVOID_BEHAVE",
+        param_value=1,
+        param_type=mavutil.mavlink.MAV_PARAM_TYPE_UINT8
+    )
+
+    print_param(master, "AVOID_BEHAVE", 1)
+
+    print("D3")
+    # Loop and listen for LIDAR messages
+    for _ in range(10):
+        msg = master.recv_match(type='DISTANCE_SENSOR', blocking=True)
+        formatted_distance = f"LIDAR distance: {msg.current_distance} meters"
+        print(formatted_distance)
+        #time.sleep(1)  # Sleep for 1 second
+        #if time.time()
+
+    print("lidar data done")
+        
+    #No avoidance if switch_value is low. Optional.
+    #TODO.
+    #https://ardupilot.org/copter/docs/common-simple-object-avoidance.html
+    return 
+    vacant_channel = find_vacant_channel(master)
+    if vacant_channel == -1:
+        return
+
+    switch_threshold = find_switch_threshold(master, vacant_channel)
+    
+    # Set RCx_OPTION to 40
+    toggle_avoidance_system(master, vacant_channel, switch_threshold)
+
+#Refs.
+#https://ardupilot.org/copter/docs/common-simple-object-avoidance.html
+#online webs.
+
+#This is to send fake distance data (note to use rand()) from gcs to the drone. But could config. by sitl instead.
+#https://www.ardusub.com/developers/pymavlink.html
+#https://github.com/ArduPilot/ardupilot/blob/master/Tools/autotest/arducopter.py#L6881
+
+#could send data the other way. but may require concurrency.
+
@@ -0,0 +1,16 @@
+import logging
+
+def log(*args, **kwargs): # logs.log(1, 2, 3, a=4, b=5) 
+  
+  s = ""
+  for item in args:
+    s += str(item) + ", " 
+  for item in kwargs.items():
+    s += str(item) + ", " 
+
+  logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s', level=logging.INFO)
+  
+  logger = logging.getLogger(__name__)
+  
+  logger.info(s)
+
@@ -1,11 +1,14 @@
 from pymavlink import mavutil, mavwp
 import socket
-import json
+import json 
+import urllib.parse
 from flight_data_collect.drone_communication.mavlink_constants import MAVLINK_MSG_ID_SET_MODE
 from flightmonitor.consumers import send_message_to_clients
 
-SERVER_IP = socket.gethostbyname(socket.gethostname())
+from . import logs, waypoints, autocomplete, lidar_data
+
 
+SERVER_IP = socket.gethostbyname(socket.gethostname())
 
 def get_ack_msg(connect_address: int, mavlink, message_type, should_send=False, command_name=None):
     ack_msg = mavlink.recv_match(type=message_type, timeout=6, blocking=True)
@@ -114,6 +117,52 @@ def set_arm(connect_address: int, is_disarm=False):
 
 
 def fly_to_point(connect_address: int, lat, lon, alt):
+    try:
+        if not alt:
+            alt = 10 
+        addr = ",".join(list(map(str, [lat,lon,alt])))
+        logs.log(addr) #"1,2,3"
+        addrList = [addr, addr] #["1,2,3", "1,2,3"]
+        msg = waypoints.add(connect_address, addrList) 
+        if not msg:
+            msg = "None"
+        print(msg)
+        return str(msg)
+    except Exception as e:
+        print(e)
+        return str({'ERROR': str(e), 'droneid': connect_address})
+
+
+    #didn't work, either. (By Team 3.)
+    """
+    # Set mode GUIDED 
+    # Arm the drone 
+    try:
+        mavlink = mavutil.mavlink_connection(SERVER_IP + ':' + str(connect_address))
+        msg = mavlink.wait_heartbeat(timeout=6)
+        if not msg:
+            return {'ERROR': f'No heartbeat from {connect_address} (timeout 6s)', 'droneid': connect_address}
+       
+        # Specify the target position
+        mavlink.mav.mission_item_send(mavlink.target_system, mavlink.target_component,
+                                      0, mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT,
+                                      mavutil.mavlink.MAV_CMD_NAV_WAYPOINT, 2, 0,
+                                      0, 0, 0, 0,
+                                      lat, lon, alt)
+    
+        ack_msg = get_ack_msg(connect_address, mavlink, 'MISSION_ACK')
+        if ack_msg:
+            return ack_msg
+        else:
+            return {'ERROR': 'No ack_msg received (timeout 6s).', 'droneid': connect_address}
+    except Exception as e:
+        print(e)
+        return {'ERROR': str(e), 'droneid': connect_address}
+    """
+
+
+    #didn't work. (By Team 2.)
+    """
     try:
         mavlink = mavutil.mavlink_connection(SERVER_IP + ':' + str(connect_address))
         msg = mavlink.wait_heartbeat(timeout=6)
@@ -132,3 +181,48 @@ def fly_to_point(connect_address: int, lat, lon, alt):
     except Exception as e:
         print(e)
         return {'ERROR': str(e), 'droneid': connect_address}
+    """
+
+
+def update_waypoints(connect_address: int, addrs: str):
+    print("wp") #reached.
+    
+    #Could use SQL or JS.
+    #Used JS for now.
+    
+    try:
+        #addrs = "a1%b1|a2%b2"
+        addrList = [] #[addr1, addr2, addr3]
+        addrList1 = addrs.split("|") #["a1%b1", "a2%b2"]
+        from .sanitize_text import sanitize_text
+        for item in addrList1:
+            decoded_str = urllib.parse.unquote(item) #"a1%b1"
+            #print(decoded_str) #"a1 b1"
+            addr = sanitize_text(decoded_str)
+            addrList.append(addr)        
+
+        connect_address = int(sanitize_text(str(connect_address)))
+
+        logs.log(connect_address, addrList)
+        msg = waypoints.add(connect_address, addrList) 
+        
+        if not msg:
+            msg = "None"
+        print(msg)
+        return "// // // // " + str(msg)
+    except Exception as e:
+        print(e)
+        return str({'// // // // ERROR': str(e), 'droneid': connect_address})
+
+def autocomplete_field(addr: str):
+    print("auto") #reached.
+    from .autocomplete import autocomplete_view 
+    from .sanitize_text import sanitize_text
+    
+    try:
+        msg = autocomplete_view(sanitize_text(addr))
+        return msg 
+    except Exception as e:
+        print(e)
+        return {'ERROR': str(e)}
+
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
++
 +GOOGLE_MAP_API_KEY=smt
++
++
++