class FlightListener(olympe.EventListener):
# This set a default queue size for every listener method
default_queue_size = 100
def __init__(self, *args, **kwds):
super().__init__(*args, **kwds)
self.has_observed_takeoff = False
@olympe.listen_event(PositionChanged())
def onPositionChanged(self, event, scheduler):
casey(moveTo(event.args["latitude"], event.args["longitude"], 0.86, MoveTo_Orientation_mode.TO_TARGET, 0.0))
print(
"latitude = {latitude} longitude = {longitude} altitude = {altitude}".format(
**event.args
)
)
@olympe.listen_event(AttitudeChanged())
def onAttitudeChanged(self, event, scheduler):
print("roll = {roll} pitch = {pitch} yaw = {yaw}".format(**event.args))
@olympe.listen_event(AltitudeAboveGroundChanged())
def onAltitudeAboveGroundChanged(self, event, scheduler):
print("height above ground = {altitude}".format(**event.args))
@olympe.listen_event(SpeedChanged())
def onSpeedChanged(self, event, scheduler):
print("speedXYZ = ({speedX}, {speedY}, {speedZ})".format(**event.args))
# You can also handle multiple message types with the same method
@olympe.listen_event(
FlyingStateChanged() | AlertStateChanged() | NavigateHomeStateChanged()
)
def onStateChanged(self, event, scheduler):
# Here, since every "*StateChanged" message has a `state` argument
# we can handle them uniformly to print the current associated state
print("{} = {}".format(event.message.name, event.args["state"]))
# You can also monitor a sequence of event using the complete Olympe DSL syntax
@olympe.listen_event(
FlyingStateChanged(state="takingoff", _timeout=1.)
>> FlyingStateChanged(state="hovering", _timeout=5.)
)
def onTakeOff(self, event, scheduler):
# This method will be called once for each completed sequence of event
# FlyingStateChanged: motor_ramping -> takingoff -> hovering
caseyTakeOff()
print("The drone has taken off!")
self.has_observed_takeoff = True
# The `default` listener method is only called when no other method
# matched the event message The `olympe.listen_event` decorator usage
# is optional for the default method, but you can use it to further
# restrict the event messages handled by this method or to limit the
# maximum size of it associated event queue (remember that the oldest
# events are dropped silently when the event queue is full).
@olympe.listen_event(queue_size=10)
def default(self, event, scheduler):
print_event(event)
class FlightListener(olympe.EventListener):
# This set a default queue size for every listener method
default_queue_size = 100
def __init__(self, *args, **kwds):
super().__init__(*args, **kwds)
self.takeoff_count = 0
@olympe.listen_event(PositionChanged(_policy="wait"))
def onPositionChanged(self, event, scheduler):
print(
"latitude = {latitude} longitude = {longitude} altitude = {altitude}".format(
**event.args
)
)
@olympe.listen_event(AttitudeChanged(_policy="wait"))
def onAttitudeChanged(self, event, scheduler):
print("roll = {roll} pitch = {pitch} yaw = {yaw}".format(**event.args))
@olympe.listen_event(AltitudeAboveGroundChanged(_policy="wait"))
def onAltitudeAboveGroundChanged(self, event, scheduler):
print("height above ground = {altitude}".format(**event.args))
@olympe.listen_event(SpeedChanged(_policy="wait"))
def onSpeedChanged(self, event, scheduler):
print("speedXYZ = ({speedX}, {speedY}, {speedZ})".format(**event.args))
# You can also handle multiple message types with the same method
@olympe.listen_event(
FlyingStateChanged(_policy="wait")
| AlertStateChanged(_policy="wait")
| NavigateHomeStateChanged(_policy="wait")
)
def onStateChanged(self, event, scheduler):
# Here, since every "*StateChanged" message has a `state` argument
# we can handle them uniformly to print the current associated state
print("{} = {}".format(event.message.name, event.args["state"]))
# You can also monitor a sequence of event using the complete Olympe DSL syntax.
# Command expectations here won't send any message
@olympe.listen_event(
FlyingStateChanged(state="landed")
>> TakeOff()
)
def onTakeOff(self, event, scheduler):
# This method will be called once for each completed sequence of event
# FlyingStateChanged: takeoff command >> takingoff -> hovering
print("The drone has taken off!")
self.takeoff_count += 1
# Command message don't take implicit `None` parameters so every argument
# should be provided
@olympe.listen_event(moveBy(dX=None, dY=None, dZ=None, dPsi=None))
def onMoveBy(self, event, scheduler):
# This is called when the `moveByEnd` event (the `moveBy` command
# expectation) is received
print("moveByEnd({dX}, {dY}, {dZ}, {dPsi})".format(**event.args))
@olympe.listen_event(GetState.as_event(_policy="wait"))
def onCamera2GetState(self, event, scheduler):
print(f"onCamera2GetState {event}")
# The `default` listener method is only called when no other method
# matched the event message The `olympe.listen_event` decorator usage
# is optional for the default method, but you can use it to further
# restrict the event messages handled by this method or to limit the
# maximum size of it associated event queue (remember that the oldest
# events are dropped silently when the event queue is full).
@olympe.listen_event(queue_size=100)
def default(self, event, scheduler):
print_event(event)
class FlightListener(olympe.EventListener):
# This set a default queue size for every listener method
default_queue_size = 100
def __init__(self, *args, **kwds):
super().__init__(*args, **kwds)
self.has_observed_takeoff = False
@olympe.listen_event(PositionChanged())
def onPositionChanged(self, event, scheduler):
lat = event.args["latitude"]
lon = event.args["longitude"]
c_poi = (lat, lon)
poi = (21.371518, -157.71161)
print('\n ------->')
print('\n ------->')
print('\n ------->')
meters = haversine(poi, c_poi, unit='m')
print(meters)
print(meters < 2)
print('\n ------->')
print('\n ------->')
print('\n ------->')
two_lat = event.args["latitude"]
two_lon = event.args["longitude"]
if meters < 8:
casey(
moveToChanged(status="CANCELED") >> moveTo(
21.370950, -157.709998, 10, MoveTo_Orientation_mode.
TO_TARGET, 0.0) >> moveToChanged(status="DONE"))
donatello(
moveToChanged(status="CANCELED") >> moveTo(
21.370950, -157.709998, 20, MoveTo_Orientation_mode.
TO_TARGET, 0.0) >> moveToChanged(status="DONE"))
leonardo(
moveToChanged(status="CANCELED") >> moveTo(
21.370950, -157.709998, 15, MoveTo_Orientation_mode.
TO_TARGET, 0.0) >> moveToChanged(status="DONE"))
two_lat = 21.370950
two_lon = -157.709998
casey_coords = findOffset(two_lat, two_lon, -5, 0)
donatello_coords = findOffset(two_lat, two_lon, 5, 0)
leonardo_coords = findOffset(two_lat, two_lon, 0, 5)
michelangelo_coords = findOffset(event.args["latitude"],
event.args["longitude"], 0, -10)
raphael_coords = findOffset(event.args["latitude"],
event.args["longitude"], 10, 10)
splinter_coords = findOffset(event.args["latitude"],
event.args["longitude"], -10, -10)
casey(
moveTo(casey_coords[0], casey_coords[1], 10,
MoveTo_Orientation_mode.TO_TARGET, 0.0))
donatello(
moveTo(donatello_coords[0], donatello_coords[1], 15,
MoveTo_Orientation_mode.TO_TARGET, 0.0))
leonardo(
moveTo(leonardo_coords[0], leonardo_coords[1], 20,
MoveTo_Orientation_mode.TO_TARGET, 0.0))
michelangelo(
moveTo(michelangelo_coords[0], michelangelo_coords[1], 25,
MoveTo_Orientation_mode.TO_TARGET, 0.0))
raphael(
moveTo(raphael_coords[0], raphael_coords[1], 30,
MoveTo_Orientation_mode.TO_TARGET, 0.0))
splinter(
moveTo(splinter_coords[0], splinter_coords[1], 35,
MoveTo_Orientation_mode.TO_TARGET, 0.0))
print(
"latitude = {latitude} longitude = {longitude} altitude = {altitude}"
.format(**event.args))
@olympe.listen_event(AttitudeChanged())
def onAttitudeChanged(self, event, scheduler):
print("roll = {roll} pitch = {pitch} yaw = {yaw}".format(**event.args))
@olympe.listen_event(AltitudeAboveGroundChanged())
def onAltitudeAboveGroundChanged(self, event, scheduler):
print("height above ground = {altitude}".format(**event.args))
@olympe.listen_event(SpeedChanged())
def onSpeedChanged(self, event, scheduler):
print("speedXYZ = ({speedX}, {speedY}, {speedZ})".format(**event.args))
# You can also handle multiple message types with the same method
@olympe.listen_event(FlyingStateChanged() | AlertStateChanged()
| NavigateHomeStateChanged())
def onStateChanged(self, event, scheduler):
# Here, since every "*StateChanged" message has a `state` argument
# we can handle them uniformly to print the current associated state
print("{} = {}".format(event.message.name, event.args["state"]))
# You can also monitor a sequence of event using the complete Olympe DSL syntax
@olympe.listen_event(
FlyingStateChanged(state="takingoff", _timeout=1.) >>
FlyingStateChanged(state="hovering", _timeout=5.))
def onTakeOff(self, event, scheduler):
# This method will be called once for each completed sequence of event
# FlyingStateChanged: motor_ramping -> takingoff -> hovering
followerTakeOff(casey)
followerTakeOff(donatello)
followerTakeOff(leonardo)
followerTakeOff(michelangelo)
followerTakeOff(raphael)
followerTakeOff(splinter)
print("The drone has taken off!")
self.has_observed_takeoff = True
# The `default` listener method is only called when no other method
# matched the event message The `olympe.listen_event` decorator usage
# is optional for the default method, but you can use it to further
# restrict the event messages handled by this method or to limit the
# maximum size of it associated event queue (remember that the oldest
# events are dropped silently when the event queue is full).
@olympe.listen_event(queue_size=10)
def default(self, event, scheduler):
print_event(event)