def test_conflicts(self):
simulation = self.SimulationMock()
airport = Airport.create("simple")
a1 = Aircraft("A1", None, self.n1, State.stop)
a2 = Aircraft("A2", None, self.n1, State.stop)
a3 = Aircraft("A3", None, self.n2, State.stop)
airport.aircrafts.append(a1)
airport.aircrafts.append(a2)
airport.aircrafts.append(a3)
# Get only one conflict
self.assertEqual(len(airport.conflicts), 1)
# Test if the conflict looks like what we expected
conflict = airport.conflicts[0]
self.assertTrue(conflict.locations[0] == self.n1)
self.assertEqual(len(conflict.aircrafts), 2)
self.assertTrue(a1 in conflict.aircrafts)
self.assertTrue(a2 in conflict.aircrafts)
# Add one far aircraft to the same spot
a4 = Aircraft("A4", None, self.n1, State.stop)
airport.aircrafts.append(a4)
# Test if the third aircraft shown in conflict correctly
self.assertEqual(len(airport.conflicts), 3)
def __init__(self,
frame='',
max_speed=20,
max_accel=30,
wheelbase=0.335,
wheeltrack=0.296,
max_wheel_turn=35,
turning_circle=1.8,
skid_turn_rate=140, # degrees/sec
skid_steering=False):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.turning_circle = turning_circle
self.wheelbase = wheelbase
self.wheeltrack = wheeltrack
self.max_wheel_turn = max_wheel_turn
self.last_time = self.time_now
self.skid_steering = skid_steering
self.skid_turn_rate = skid_turn_rate
if self.skid_steering:
# these are taken from a 6V wild thumper with skid steering,
# with a sabertooth controller
self.max_accel = 14
self.max_speed = 4
def __init__(self,
frame='+',
hover_throttle=0.65,
terminal_velocity=40.0,
frame_height=0.1,
hover_lean=8.0,
yaw_zero=0.1,
rotor_rot_accel=radians(20),
mass=2.13):
Aircraft.__init__(self)
self.mass = mass # Kg
self.hover_throttle = hover_throttle
self.terminal_velocity = terminal_velocity
self.terminal_rotation_rate = 4 * radians(360.0)
self.frame_height = frame_height
self.last_time = time.time()
self.roll_rate_max = radians(1400)
self.pitch_rate_max = radians(1400)
self.yaw_rate_max = radians(1400)
self.rsc_setpoint = 0.8
self.thrust_scale = (self.mass * self.gravity) / self.hover_throttle
self.rotor_rot_accel = rotor_rot_accel
# calculate lateral thrust ratio for tail rotor
self.tail_thrust_scale = sin(
radians(hover_lean)) * self.thrust_scale / yaw_zero
def test_deterministic_scheduler_with_one_conflict(self):
Config.params["scheduler"]["name"] = "deterministic_scheduler"
a1 = Aircraft("A1", None, self.g1, State.stop)
a3 = Aircraft("A3", None, self.g2, State.stop)
# Create mock objects, then schedule it
simulation = self.SimulationMock(
a1, a3, self.g1, self.g2, self.s1, self.runway_start)
scheduler = get_scheduler()
schedule, priority = scheduler.schedule(simulation)
self.assertEqual(len(schedule.itineraries), 2)
# a3 has an early departure time, so it goes first
self.assertTrue(self.a1 in schedule.itineraries)
self.assertTrue(self.a3 in schedule.itineraries)
# Gets itineraries
iti1 = schedule.itineraries[self.a1]
iti2 = schedule.itineraries[self.a3]
self.assertEqual(iti1.targets[1].nodes[0], self.g1)
self.assertEqual(iti1.targets[1].nodes[1], self.s1)
self.assertEqual(iti1.targets[2].nodes[0], self.s1)
self.assertEqual(iti1.targets[2].nodes[1], self.runway_start)
self.assertEqual(iti2.targets[2].nodes[0], self.g2)
self.assertEqual(iti2.targets[2].nodes[1], self.s1)
self.assertEqual(iti2.targets[3].nodes[0], self.s1)
self.assertEqual(iti2.targets[3].nodes[1], self.runway_start)
def __init__(
self,
frame='',
max_speed=20,
max_accel=30,
wheelbase=0.335,
wheeltrack=0.296,
max_wheel_turn=35,
turning_circle=1.8,
skid_turn_rate=140, # degrees/sec
skid_steering=False):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.turning_circle = turning_circle
self.wheelbase = wheelbase
self.wheeltrack = wheeltrack
self.max_wheel_turn = max_wheel_turn
self.last_time = self.time_now
self.skid_steering = skid_steering
self.skid_turn_rate = skid_turn_rate
if self.skid_steering:
# these are taken from a 6V wild thumper with skid steering,
# with a sabertooth controller
self.max_accel = 14
self.max_speed = 4
def __init__(self,
max_speed=2,
max_accel=1.5,
wheelbase=1.8,
wheeltrack=1.3,
max_wheel_turn=35,
turning_circle=5,
skid_turn_rate=9, # degrees/sec
accel_by_pds = 4.46, # m/s^2
accel_by_enge = 1.12,
accel_by_idle = 0.45,
skid_steering=False):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.turning_circle = turning_circle
self.wheelbase = wheelbase
self.wheeltrack = wheeltrack
self.max_wheel_turn = max_wheel_turn
self.last_time = time.time()
self.skid_steering = skid_steering
self.skid_turn_rate = skid_turn_rate
self.accel_by_pds = accel_by_pds
self.accel_by_enge = accel_by_enge
self.accel_by_idle = accel_by_idle
if self.skid_steering:
# these are taken from a 6V wild thumper with skid steering,
# with a sabertooth controller
self.max_accel = 14
self.max_speed = 4
def __init__(self,
max_speed=10,
max_accel=10,
max_turn_rate=45):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.max_turn_rate = max_turn_rate
self.last_time = time.time()
def __init__(self,
max_speed=10,
max_accel=10,
max_turn_rate=45,
skid_steering=False):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.max_turn_rate = max_turn_rate
self.last_time = time.time()
self.skid_steering = skid_steering
def __init__(self,
max_speed=13,
max_accel=10,
max_turn_rate=100,
skid_steering=False):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.max_turn_rate = max_turn_rate
self.last_time = time.time()
self.skid_steering = skid_steering
def __init__(self, frame="+", hover_throttle=0.65, terminal_velocity=40.0, frame_height=0.1, mass=2.5):
Aircraft.__init__(self)
self.mass = mass # Kg
self.hover_throttle = hover_throttle
self.terminal_velocity = terminal_velocity
self.terminal_rotation_rate = 4 * radians(360.0)
self.frame_height = frame_height
self.last_time = time.time()
self.roll_rate_max = radians(720)
self.pitch_rate_max = radians(720)
self.yaw_rate_max = radians(720)
self.rsc_setpoint = 0.8
self.thrust_scale = (self.mass * self.gravity) / self.hover_throttle
def __init__(self, frame="generic"):
Aircraft.__init__(self)
self.sim = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sim.connect(('127.0.0.1', 9002))
self.sim.setblocking(0)
self.accel_body = Vector3(0, 0, -self.gravity)
self.frame = frame
self.last_timestamp = 0
if self.frame.find("heli") != -1:
self.decode_servos = self.decode_servos_heli
else:
self.decode_servos = self.decode_servos_fixed_wing
def __init__(self, frame="generic"):
Aircraft.__init__(self)
self.sim = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sim.connect(('127.0.0.1', 9002))
self.sim.setblocking(0)
self.accel_body = Vector3(0, 0, -self.gravity)
self.frame = frame
self.last_timestamp = 0
if self.frame.find("heli") != -1:
self.decode_servos = self.decode_servos_heli
else:
self.decode_servos = self.decode_servos_fixed_wing
class Flight():
"""Main flight plan driver application."""
def __init__(self):
"""Start up aircraft."""
self.aircraft = Aircraft()
def run(self):
"""Start application."""
print(f'Battery: {self.aircraft.battery}%')
self.aircraft.take_off()
self.aircraft.fly('../samples/square.json')
# self.aircraft.land()
print(f'Battery: {self.aircraft.battery}%')
def __init__(self):
Aircraft.__init__(self)
self.motor_speed = [ 0.0, 0.0, 0.0, 0.0 ]
self.mass = 1.0 # Kg
self.hover_throttle = 0.37
self.terminal_velocity = 30.0
self.frame_height = 0.1
# scaling from total motor power to Newtons. Allows the copter
# to hover against gravity when each motor is at hover_throttle
self.thrust_scale = (self.mass * self.gravity) / (4.0 * self.hover_throttle)
self.last_time = time.time()
def __init__(self, conf):
self.conf = conf
self.aircraft = Aircraft()
self.flight_phase = FlightPhase(self.aircraft)
self.flight = Flight()
self.time = 0
self.sample_rate = 1 # Hz
self.recording = False
self.flush_interval_sec = 10
self.flush_time = 0
self.flight_data = []
def __init__(self, frame="+", hover_throttle=0.37, terminal_velocity=30.0, frame_height=0.1, mass=1.0):
Aircraft.__init__(self)
self.motors = build_motors(frame)
self.motor_speed = [0.0] * len(self.motors)
self.mass = mass # Kg
self.hover_throttle = hover_throttle
self.terminal_velocity = terminal_velocity
self.terminal_rotation_rate = 4 * radians(360.0)
self.frame_height = frame_height
# scaling from total motor power to Newtons. Allows the copter
# to hover against gravity when each motor is at hover_throttle
self.thrust_scale = (self.mass * self.gravity) / (len(self.motors) * self.hover_throttle)
self.last_time = time.time()
def __init__(self, callsign, model, from_airport, to_gate, runway,
arrival_time, appear_time):
super().__init__(Aircraft(callsign, model, None, State.flying))
self.from_airport = from_airport
self.to_gate = to_gate
self.arrival_time = arrival_time
self.appear_time = appear_time
def __init__(self, callsign, model, to_airport, from_gate, runway,
departure_time, appear_time):
super().__init__(Aircraft(callsign, model, None, State.stop))
self.to_airport = to_airport
self.from_gate = from_gate
self.departure_time = departure_time
self.appear_time = appear_time
def get_all_aircraft(self) -> [Aircraft]:
"""
Returns list of all aircraft scanner has seen regardless of whether it
has received all Aircraft information (such as tail number or Flight #)
:return: List of Airfract seen by the receiver
"""
_raw_aircraft_data = self._query(self._scanner_aircraft_path)
# List of attributes from aircraft JSON. Is there a better way?
_response_keys = [
'hex',
'flight',
'squawk',
'lat',
'lon',
'alt_geom', #altitude
'geom_rate',
'track',
'gs',
'seen' ,
]
known_aircarft = []
_parameters = {}
# To-Do: n^2, need something better instead of brute force,
# (Replace with generator? )
for i in _raw_aircraft_data['aircraft']:
for k in _response_keys:
try:
_parameters.update({k : i[k]})
except KeyError: # Data was not picked up by reciever
pass
known_aircarft.append(Aircraft(**_parameters))
_parameters = {}
return known_aircarft
def __init__(self,
max_speed=20,
max_accel=30,
wheelbase=0.335,
wheeltrack=0.296,
max_wheel_turn=35,
turning_circle=1.8,
skid_steering=False):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.turning_circle = turning_circle
self.wheelbase = wheelbase
self.wheeltrack = wheeltrack
self.max_wheel_turn = max_wheel_turn
self.last_time = time.time()
self.skid_steering = skid_steering
def __init__(self, frame='+',
hover_throttle=0.65,
terminal_velocity=40.0,
frame_height=0.1,
mass=2.5):
Aircraft.__init__(self)
self.mass = mass # Kg
self.hover_throttle = hover_throttle
self.terminal_velocity = terminal_velocity
self.terminal_rotation_rate = 4*radians(360.0)
self.frame_height = frame_height
self.last_time = time.time()
self.roll_rate_max = radians(720)
self.pitch_rate_max = radians(720)
self.yaw_rate_max = radians(720)
self.rsc_setpoint = 0.8
self.thrust_scale = (self.mass * self.gravity) / self.hover_throttle
def __init__(self,
max_speed=20,
max_accel=30,
wheelbase=0.335,
wheeltrack=0.296,
max_wheel_turn=35,
turning_circle=1.8,
skid_steering=False):
Aircraft.__init__(self)
self.max_speed = max_speed
self.max_accel = max_accel
self.turning_circle = turning_circle
self.wheelbase = wheelbase
self.wheeltrack = wheeltrack
self.max_wheel_turn = max_wheel_turn
self.last_time = time.time()
self.skid_steering = skid_steering
def connect_to(self, comm_port):
aircraft = Aircraft(comm_port)
# wait for the heartbeat msg to find the system ID
print("Waiting for APM heartbeat from aircraft %s" % comm_port)
aircraft.wait_heartbeat()
print("I saw a heartbeat, now I am going to acknowledge I have seen the aircraft")
aircraft.send_ack()
print("Waiting for APM home location from aircraft %s" % comm_port)
aircraft.wait_set_home_location()
self.aircrafts[comm_port] = aircraft
def _update_aircraft(cls, msg: Message) -> None:
for craft in cls.aircraft:
if craft == msg.icao:
craft.update(msg.data)
break
else:
cls.aircraft.insert(0, Aircraft(msg.icao, msg.data))
if len(cls.aircraft) > 100:
cls.aircraft = cls.aircraft[25:]
def eachAircraft():
groundstation = Groundstation()
aircraft_seen = {}
conn = sqlite3.connect('flightevents.db')
nmea = open('data.nmea', 'r')
for line in nmea:
try:
commas = line.count(',')
sentence = pynmea2.parse(line, check=True)
except pynmea2.ChecksumError:
# ignore sentences that produce a checksum error
continue
except pynmea2.ParseError:
# ignore sentences that can't be parsed
continue
# ignore Flarm PFLAU sentences
if Observation.is_pflau_sentence(sentence):
continue
# The groundstation must have received the UTC time from the GPS
# before we permit any processing of Flarm PFLAA observations.
if (groundstation.valid_time()
and Observation.is_pflaa_sentence(sentence)):
observation = Observation()
if observation.set(conn, groundstation, sentence):
aircraft_id = observation.get_aircraft_id()
if aircraft_id not in aircraft_seen:
aircraft_seen[aircraft_id] = Aircraft(aircraft_id)
aircraft_seen[aircraft_id].append_observations(observation)
elif sentence.sentence_type == 'RMC':
# this sentence contains the current date
groundstation.set_date(sentence.datestamp)
groundstation.set(sentence)
elif (sentence.sentence_type == 'GGA' and groundstation.valid_date()
and commas == 14):
# this sentence has the groundstation timestamp, lat, lon, elevation
groundstation.set(sentence)
conn.commit()
conn.close()
print("%s" % list(aircraft_seen.keys()))
groundstation.report()
return
def __init__(self,
rate_controlled=False,
pitch_range = 45,
yaw_range = 180,
zero_yaw = 270, # yaw direction at startup
zero_pitch = 10, # pitch at startup
turn_rate=20 # servo max turn rate in degrees/sec
):
Aircraft.__init__(self)
self.rate_controlled = rate_controlled
self.turn_rate = turn_rate
self.last_time = time.time()
self.pitch_range = pitch_range
self.yaw_range = yaw_range
self.zero_yaw = zero_yaw
self.zero_pitch = zero_pitch
self.verbose = False
self.last_debug = time.time()
self.pitch_current = 0
self.yaw_current = 0
def __init__(self):
Aircraft.__init__(self)
self.max_rpm = 1200
self.have_new_time = False
self.have_new_imu = False
self.have_new_pos = False
topics = {
"/clock": (self.clock_cb, rosgraph_msgs.Clock),
"/iris/imu": (self.imu_cb, sensor_msgs.Imu),
"/iris/vehicle_local_position": (self.pos_cb, px4.vehicle_local_position),
}
rospy.init_node("ArduPilot", anonymous=True)
for topic in topics.keys():
(callback, msgtype) = topics[topic]
rospy.Subscriber(topic, msgtype, callback)
self.motor_pub = rospy.Publisher("/iris/command/motor_speed", mav_msgs.CommandMotorSpeed, queue_size=1)
self.last_time = 0
def game_Runner():
pygame.init() # Initialize
game_settings = Setting()
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("Aircraft Game")
# create an aircraft
aircraft = Aircraft(game_settings, screen)
missiles = Group()
# loop of processing
while True:
function.check_events(game_settings, screen, aircraft, missiles)
aircraft.update()
missiles.update()
function.update_screen(game_settings, screen, aircraft, missiles)
def __init__(self,
frame='+',
hover_throttle=0.45,
terminal_velocity=15.0,
frame_height=0.1,
mass=1.5):
Aircraft.__init__(self)
self.motors = build_motors(frame)
self.motor_speed = [0.0] * len(self.motors)
self.mass = mass # Kg
self.hover_throttle = hover_throttle
self.terminal_velocity = terminal_velocity
self.terminal_rotation_rate = 4 * radians(360.0)
self.frame_height = frame_height
# scaling from total motor power to Newtons. Allows the copter
# to hover against gravity when each motor is at hover_throttle
self.thrust_scale = (self.mass * self.gravity) / (len(self.motors) *
self.hover_throttle)
self.last_time = self.time_now
def __init__(self,
onoff=False,
yawrate=9.0,
pitchrate=1.0,
pitch_range = 45,
yaw_range = 170,
zero_yaw = 270, # yaw direction at startup
zero_pitch = 10 # pitch at startup
):
Aircraft.__init__(self)
self.onoff = onoff
self.yawrate = yawrate
self.pitchrate = pitchrate
self.last_time = time.time()
self.pitch_range = pitch_range
self.yaw_range = yaw_range
self.zero_yaw = zero_yaw
self.zero_pitch = zero_pitch
self.verbose = False
self.last_debug = time.time()
self.pitch_current = 0
self.yaw_current = 0
def load_data(filename):
aircraft_dict = {}
with open(os.path.join("", "clean_files", filename),
"rt",
encoding="utf8") as f:
reader = csv.reader(f)
for row in reader:
aircraft_code = row[0]
# remove cr
aircraft_dict[aircraft_code] =\
Aircraft(row[0], row[1], row[2], row[3], row[4])
return aircraft_dict
def __init__(self):
Aircraft.__init__(self)
self.max_rpm = 1200
self.have_new_time = False
self.have_new_imu = False
self.have_new_pos = False
topics = {
"/clock": (self.clock_cb, rosgraph_msgs.Clock),
"/iris/imu": (self.imu_cb, sensor_msgs.Imu),
"/iris/vehicle_local_position":
(self.pos_cb, px4.vehicle_local_position),
}
rospy.init_node('ArduPilot', anonymous=True)
for topic in topics.keys():
(callback, msgtype) = topics[topic]
rospy.Subscriber(topic, msgtype, callback)
self.motor_pub = rospy.Publisher('/iris/command/motor_speed',
mav_msgs.CommandMotorSpeed,
queue_size=1)
self.last_time = 0
def __init__(
self,
onoff=False,
yawrate=9.0,
pitchrate=1.0,
pitch_range=45,
yaw_range=170,
zero_yaw=270, # yaw direction at startup
zero_pitch=10 # pitch at startup
):
Aircraft.__init__(self)
self.onoff = onoff
self.yawrate = yawrate
self.pitchrate = pitchrate
self.last_time = time.time()
self.pitch_range = pitch_range
self.yaw_range = yaw_range
self.zero_yaw = zero_yaw
self.zero_pitch = zero_pitch
self.verbose = False
self.last_debug = time.time()
self.pitch_current = 0
self.yaw_current = 0
def __init__(self, frame='+',
hover_throttle=0.65,
terminal_velocity=40.0,
frame_height=0.1,
hover_lean=8.0,
yaw_zero=0.1,
rotor_rot_accel=radians(20),
mass=2.13):
Aircraft.__init__(self)
self.mass = mass # Kg
self.hover_throttle = hover_throttle
self.terminal_velocity = terminal_velocity
self.terminal_rotation_rate = 4*radians(360.0)
self.frame_height = frame_height
self.last_time = time.time()
self.roll_rate_max = radians(1400)
self.pitch_rate_max = radians(1400)
self.yaw_rate_max = radians(1400)
self.rsc_setpoint = 0.8
self.thrust_scale = (self.mass * self.gravity) / self.hover_throttle
self.rotor_rot_accel=rotor_rot_accel
# calculate lateral thrust ratio for tail rotor
self.tail_thrust_scale = sin(radians(hover_lean)) * self.thrust_scale / yaw_zero
def __init__(self, path, fromdate=None):
self.flex_start = 0
self.flex_end = 0
date_regexp = re.compile(r'\d{1,2}/\d{1,2}/\d{4}\s\d{1,2}:\d{1,2}')
self.aclist = []
import pandas as pd
df = pd.read_csv(path, sep=',', header=0)
df["ACTUAL_ARRIVAL_DT"] = pandas.to_datetime(df["ACTUAL_ARRIVAL_DT"],
dayfirst=True)
df["ACTUAL_DEPARTURE_DT"] = pandas.to_datetime(
df["ACTUAL_DEPARTURE_DT"], dayfirst=True)
arr = df.sort_values(by="ACTUAL_DEPARTURE_DT")
for row in arr.values:
if 'XXX' in row[7:8]:
continue
if row[3] == row[4]:
continue
if fromdate is not None:
if row[3].value // 10**9 < datetime.datetime.strptime(
fromdate, "%d/%m/%Y").timestamp():
continue
self.aclist.append(
Aircraft(row[8],
row[7],
row[3].value // 10**9,
row[4].value // 10**9,
debug=False,
flight_type_code=row[9]))
if self.flex_start == 0:
self.flex_start = row[3].value // 10**9
self.flex_end = row[4].value // 10**9
else:
if row[3].value // 10**9 < self.flex_start:
self.flex_start = row[3].value // 10**9
if row[4].value // 10**9 > self.flex_end:
self.flex_end = row[4].value // 10**9
def __init__(self, max_ammo, base_damage):
Aircraft.__init__(self, max_ammo, base_damage)
class TestScheduler(unittest.TestCase):
Config.params["simulator"]["test_mode"] = True
Config.params["simulation"]["time_unit"] = 30
# (G1)
# |
# | <3647.9 ft, 12.2 mins>
# |
# (S1)-----<2456.7 ft, 8:11 mins>-----(RANWAY.start)
# |
# | <3647.9 ft, 12.2 mins>
# |
# (G2)
g1 = Node("G1", {"lat": 47.812000, "lng": -122.079057})
g2 = Node("G2", {"lat": 47.832000, "lng": -122.079057})
s1 = Spot("S1", {"lat": 47.822000, "lng": -122.079057})
runway_start = RunwayNode({"lat": 47.822000, "lng": -122.069057})
a1 = Aircraft("A1", None, g1, State.stop)
a2 = Aircraft("A2", None, g2, State.stop)
a3 = Aircraft("A3", None, g2, State.stop)
a4 = Aircraft("A4", None, s1, State.stop)
a5 = Aircraft("A5", None, s1, State.stop)
class AirportMock():
def __init__(self, simulation, aircraft1, aircraft2):
self.aircrafts = [aircraft1, aircraft2]
self.aircraft1 = aircraft1
self.aircraft2 = aircraft2
def apply_schedule(self, schedule):
for aircraft, itinerary in schedule.itineraries.items():
if aircraft == self.aircraft1:
self.aircraft1.set_itinerary(itinerary)
else:
self.aircraft2.set_itinerary(itinerary)
def set_quiet(self, logger):
self.aircraft1.logger = logger
self.aircraft2.logger = logger
def tick(self):
self.aircraft1.tick()
self.aircraft2.tick()
@property
def conflicts(self):
if self.aircraft1.location == self.aircraft2.location:
return [Conflict(None, [self.aircraft1, self.aircraft2])]
return []
@property
def next_conflicts(self):
if self.aircraft1.itinerary is None or\
self.aircraft2.itinerary is None:
return []
if self.aircraft1.itinerary.next_target is None or\
self.aircraft2.itinerary.next_target is None:
return []
if self.aircraft1.itinerary.next_target == \
self.aircraft2.itinerary.next_target:
return [Conflict(None, [self.aircraft1, self.aircraft2])]
return []
class RunwayMock():
def __init__(self, runway_start):
self.runway_start = runway_start
@property
def start(self):
return self.runway_start
class ScenarioMock():
def __init__(self, g1, g2, s1, runway_start):
self.runway = TestScheduler.RunwayMock(runway_start)
self.g1, self.g2, self.s1 = g1, g2, s1
def get_flight(self, aircraft):
if aircraft.callsign == "A1":
return DepartureFlight(
"A1", None, None, self.g1, self.s1, self.runway,
time(2, 36), time(2, 36)
)
elif aircraft.callsign == "A2":
return DepartureFlight(
"A2", None, None, self.g2, self.s1, self.runway,
time(2, 36, 30), time(2, 36, 30)
)
elif aircraft.callsign == "A3":
return DepartureFlight(
"A3", None, None, self.g2, self.s1, self.runway,
time(2, 36, 1), time(2, 36, 1)
)
elif aircraft.callsign == "A4":
return DepartureFlight(
"A4", None, None, self.g2, self.s1, self.runway,
time(2, 36, 1), time(2, 36, 1)
)
elif aircraft.callsign == "A5":
return DepartureFlight(
"A5", None, None, self.g2, self.s1, self.runway,
time(2, 36, 2), time(2, 36, 2)
)
class RouteMock():
def __init__(self, nodes):
self.nodes = nodes
class RoutingExpertMock():
def __init__(self, g1, g2, s1, runway_start):
self.g1, self.g2, self.s1 = g1, g2, s1
self.runway_start = runway_start
def get_shortest_route(self, src, dst):
if src == self.g1 and dst == self.runway_start:
return TestScheduler.RouteMock([self.g1, self.s1,
self.runway_start])
if src == self.g2 and dst == self.runway_start:
return TestScheduler.RouteMock([self.g2, self.s1,
self.runway_start])
if src == self.s1 and dst == self.runway_start:
return TestScheduler.RouteMock([self.s1, self.runway_start])
else:
raise Exception("Unsupported routing query")
class SimulationMock():
def __init__(self, a1, a2, g1, g2, s1, runway_start):
self.airport = TestScheduler.AirportMock(self, a1, a2)
self.scenario = TestScheduler.ScenarioMock(
g1, g2, s1, runway_start)
self.routing_expert = TestScheduler.RoutingExpertMock(
g1, g2, s1, runway_start)
self.clock = Clock()
self.clock.now = time(2, 30)
def set_quiet(self, logger):
self.airport.set_quiet(logger)
def remove_aircrafts(self):
pass
def pre_tick(self):
pass
def tick(self):
self.clock.tick()
self.airport.tick()
def post_tick(self):
pass
@property
def now(self):
return self.clock.now
@property
def copy(self):
s = deepcopy(self)
s.set_quiet(logging.getLogger("QUIET_MODE"))
return s
def test_deterministic_scheduler_with_one_conflict(self):
Config.params["scheduler"]["name"] = "deterministic_scheduler"
# Create mock objects, then schedule it
simulation = self.SimulationMock(
self.a1, self.a3, self.g1, self.g2, self.s1, self.runway_start)
scheduler = get_scheduler()
schedule = scheduler.schedule(simulation)
self.assertEqual(len(schedule.itineraries), 2)
# a3 has an early departure time, so it goes first
self.assertTrue(self.a1 in schedule.itineraries)
self.assertTrue(self.a3 in schedule.itineraries)
# Gets itineraries
iti1 = schedule.itineraries[self.a1]
iti2 = schedule.itineraries[self.a3]
self.assertEqual(iti1.targets[0], self.g1)
self.assertEqual(iti1.targets[1], self.s1)
self.assertEqual(iti1.targets[2], self.runway_start)
self.assertEqual(iti2.targets[0], self.g2)
self.assertEqual(iti2.targets[1], self.g2)
self.assertEqual(iti2.targets[2], self.s1)
self.assertEqual(iti2.targets[3], self.runway_start)
def test_deterministic_scheduler_with_one_unsolvable_conflict(self):
# Sets two aircraft standing at the same node
self.a4.location = self.s1
self.a5.location = self.s1
# Create mock objects, then schedule it
simulation = self.SimulationMock(
self.a4, self.a5, self.g1, self.g2, self.s1, self.runway_start)
scheduler = get_scheduler()
schedule = scheduler.schedule(simulation)
self.assertEqual(len(schedule.itineraries), 2)
# a3 has an early departure time, so it goes first
self.assertTrue(self.a4 in schedule.itineraries)
self.assertTrue(self.a5 in schedule.itineraries)
# Gets itineraries
iti1 = schedule.itineraries[self.a4]
iti2 = schedule.itineraries[self.a5]
self.assertEqual(schedule.n_unsolvable_conflicts, 0)
self.assertEqual(iti1.targets[0], self.s1)
self.assertEqual(iti1.targets[1], self.runway_start)
self.assertEqual(iti2.targets[0], self.s1)
self.assertEqual(iti2.targets[1], self.s1)
self.assertEqual(iti2.targets[2], self.runway_start)
import numpy as np from aircraft import Aircraft from atmosphere import Atmosphere, Wind from constants import Constants import sim_setup from Planes.B737 import B737 from Planes.C172 import C172 from Planes.T38 import T38 # Initialization of objects used in overall sim architecture SIM = sim_setup.Sim_Parameters() CONSTANTS = Constants() Atmosphere = Atmosphere() plane1 = Aircraft() #################################################################################################### # BEGIN INPUT FIELDS #################################################################################################### # Modify simulation parameters SIM.START_TIME = 0.0 SIM.END_TIME = 2000.0 SIM.DELTA_T = 2 # Modify aircraft inital conditions # Choose airplane type - B737, C172, T38 plane1.design = B737()
m += 1
return heading_differences
######################Scenario###############################################
target_1 = Target("target_1", 1, 100, 370,
100) #(name, location, speed, heading, power)
target_2 = Target("target_2", 5, 100, 900, 100)
target_3 = Target("target_3", 9, 100, 90, 100)
target_4 = Target("target_4", 4, 100, 270, 100)
print("number of targets is: ", Target.number_of_targets)
print("number of targets is: ", Target.number_of_targets, file=f)
aircraft_1 = Aircraft("aircraft_1", 365, 100, 10000,
0) #(name, heading, speed, altitude, ownship_location)
target_list = Target.target_list
#target_list = [target_1, target_2, target_3, target_4]
#print(target_list, file = f)
target_names = [o.name for o in target_list]
target_locations = [o.location for o in target_list]
target_powers = [o.power for o in target_list]
target_speeds = [o.speed for o in target_list]
target_headings = [o.heading for o in target_list]
beam_width = 5.0
half_power_beam_width = beam_width / 2
pygame.draw.rect(screen, blue, (mx-quad.radius*ppm, my, 2*quad.radius*ppm, quad.beamwidth*ppm+1))
## draw forces
for i in range(quad.motors):
pygame.draw.line(screen, red, (mx-quad.motor_pos[i][0]*ppm, my),
(mx-quad.motor_pos[i][0]*ppm,my-quad.target_force[i][1]*fscale), 5)
pygame.draw.line(screen, green, (mx-quad.motor_pos[i][0]*ppm, my),
(mx-quad.motor_pos[i][0]*ppm, my-quad.current_force[i][1]*fscale), 3)
pygame.draw.line(screen, green, (mx, my), (mx, my-ppm), 3)
## Simulation initialization
t = time()*SPEED
dt = 1.0/FPS
t_sim = t
world = World(G, AIR_DENSITY)
sim = QuadSimulator(SIMULATIONS_PER_SECOND)
quad = Aircraft(RADIUS, MASS, MAX_THRUST, ADJUST_RATE, GYRO_SIGMA, ACC_SIGMA)
controller = Controller(quad, world, CONTROLLER_CYCLE_TIME, ACRO_MODE)
pygame.init()
font_obj = pygame.font.SysFont("monospace", 25)
screen = pygame.display.set_mode((WIN_WIDTH, WIN_HEIGHT))
backdrop = draw_backdrop((WIN_WIDTH, WIN_HEIGHT), PIXELS_PER_METER)
while True:
#collect user input
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
keys = pygame.key.get_pressed()
def test_tick_with_delay(self):
itinerary = deepcopy(self.itinerary_template)
aircraft = Aircraft("F1", "M1", self.n1, State.stop)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.state, State.stop)
# Stop state
aircraft.tick()
self.assertEqual(aircraft.itinerary, None)
# Moving state
aircraft.set_itinerary(itinerary)
self.assertTrue(aircraft.itinerary)
self.assertEqual(aircraft.state, State.moving)
self.assertEqual(aircraft.itinerary.current_target, self.n1)
# targets: n1 - n2 - n3
aircraft.add_uncertainty_delay()
# targets: n1 - n1 - n2 - n3
aircraft.tick()
# targets: n1 - n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.add_uncertainty_delay()
# targets: n1 - n1 - n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.tick()
# targets: n1 - n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.tick()
# targets: n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n2)
def test_tick(self):
itinerary = deepcopy(self.itinerary_template)
aircraft = Aircraft("F1", "M1", self.n1, State.stop)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.state, State.stop)
# Stop state
aircraft.tick()
self.assertEqual(aircraft.itinerary, None)
# Moving state
aircraft.set_itinerary(itinerary)
self.assertTrue(aircraft.itinerary)
self.assertEqual(aircraft.state, State.moving)
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.tick()
self.assertEqual(aircraft.itinerary.current_target, self.n2)
aircraft.tick()
self.assertEqual(aircraft.itinerary.current_target, self.n3)
aircraft.tick()
self.assertTrue(aircraft.itinerary.is_completed)
def test_init(self):
aircraft = Aircraft("F1", "M1", self.n1, State.unknown)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.location, self.n1)
def __init__(self, logger):
"""
Initialize and create a new HUD.
"""
self.__last_perf_render__ = None
self.__logger__ = logger
self.__view_element_timers = {}
self.__fps__ = RollingStats('FPS')
self.__texture_cache_size__ = RollingStats('TextureCacheSize')
self.__texture_cache_misses__ = RollingStats('TextureCacheMisses')
self.__texture_cache_purges__ = RollingStats('TextureCachePurges')
self.render_perf = TaskTimer('Render')
self.frame_setup = TaskTimer('Setup')
self.frame_cleanup = TaskTimer('Cleanup')
self.__frame_timers__ = {
'Setup': self.frame_setup,
'Render': self.render_perf,
'Cleanup': self.frame_cleanup
}
self.cache_perf = TaskTimer('Cache')
self.__fps__.push(0)
adsb_traffic_address = "ws://{0}/traffic".format(
CONFIGURATION.stratux_address())
self.__connection_manager__ = traffic.ConnectionManager(
adsb_traffic_address)
self.__backpage_framebuffer__, screen_size = display.display_init(
) # args.debug)
self.__width__, self.__height__ = screen_size
pygame.mouse.set_visible(False)
pygame.font.init()
self.__should_render_perf__ = False
font_size_std = int(self.__height__ / 10.0)
font_size_detail = int(self.__height__ / 12.0)
font_size_loading = int(self.__height__ / 4.0)
self.__font__ = pygame.font.Font(
get_absolute_file_path("./assets/fonts/LiberationMono-Bold.ttf"),
font_size_std)
self.__detail_font__ = pygame.font.Font(
get_absolute_file_path("./assets/fonts/LiberationMono-Bold.ttf"),
font_size_detail)
self.__loading_font__ = pygame.font.Font(
get_absolute_file_path(
"./assets/fonts/LiberationMono-Regular.ttf"),
font_size_loading)
self.__show_boot_screen__()
self.__aircraft__ = Aircraft(self.__logger__)
self.__pixels_per_degree_y__ = int(
(self.__height__ / CONFIGURATION.get_degrees_of_pitch()) *
CONFIGURATION.get_pitch_degrees_display_scaler())
self.__ahrs_not_available_element__ = self.__build_ahrs_hud_element(
ahrs_not_available.AhrsNotAvailable)
self.__hud_views__ = self.__build_hud_views()
self.__view_index__ = 0
logger = None
if self.__logger__ is not None:
logger = self.__logger__.logger
self.web_server = restful_host.HudServer()
RecurringTask("rest_host",
0.1,
self.web_server.run,
start_immediate=False)
RecurringTask("purge_old_traffic",
10.0,
self.__purge_old_reports__,
start_immediate=False)
RecurringTask("update_traffic",
0.1,
self.__update_traffic_reports__,
start_immediate=True)
RecurringTask("update_aithre",
5.0,
self.__update_aithre__,
start_immediate=True)
