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)
class FlightListener(olympe.EventListener): def set_logger(self, logger): self.my_log = logger; def set_socket(self, websocket): self._brain_client = websocket; def set_relay(self, relay): self._relay = relay def set_drone_coordinates(self, coordinates): self._drone_coordinates = coordinates def set_initialized_socket(self, initialized): self._socket_initialized = initialized; def set_my_name(self, name): self.my_name = name; def on_signal_lost (self, func): self._on_signal_lost = func; @olympe.listen_event(NavigateHomeStateChanged()) def on_navigation_changed(self, event, scheduler): global navigate_home_status_lookup try : if hasattr(self, "my_log"): self.my_log.info("{} = {}".format(event.message.name, event.args["state"])) self.emit_status("navigate_home_status_changed", navigate_home_status_lookup.index(event.args["state"])) except(Exception) as err : if hasattr(self, "my_log"): self.my_log.info(err) @olympe.listen_event(FlyingStateChanged()) def on_state_changed(self, event, scheduler): global flying_status_lookup try : if hasattr(self, "my_log"): self.my_log.info("{} = {}".format(event.message.name, event.args["state"])) self.emit_status("flight_status_changed", flying_status_lookup.index(event.args["state"])) except(Exception) as err : if hasattr(self, "my_log"): self.my_log.info(err) @olympe.listen_event(AlertStateChanged() ) def on_alert_raised(self, event, scheduler): global alert_lookup try : if hasattr(self, "my_log"): self.my_log.info("{} = {}".format(event.message.name, event.args["state"])) self.emit_status("on_alert_changed", alert_lookup.index(event.args["state"])) except(Exception) as err : if hasattr(self, "my_log"): self.my_log.info(err) @olympe.listen_event(PositionChanged() | moveToChanged()) def on_position_changed(self, event, scheduler): if hasattr(self, "my_log"): self.my_log.info( "latitude = {} longitude = {} altitude = {}".format( event.args["latitude"], event.args["longitude"], event.args["altitude"] ) ) if hasattr(self, "_drone_coordinates"): self._drone_coordinates.update_position(event.args["latitude"], event.args["longitude"], event.args["altitude"]) self.on_element_position_update('position_update', event) @olympe.listen_event(HomeChanged()) def on_home_changed(self, event, scheduler): if hasattr(self, "my_log"): self.my_log.info( "latitude = {} longitude = {} altitude = {}".format( event.args["latitude"], event.args["longitude"], event.args["altitude"] ) ) if hasattr(self, "_relay"): self._relay.update_position(event.args["latitude"], event.args["longitude"], event.args["altitude"]) self.on_element_position_update('home_position_update', event) """ @olympe.listen_event( FlyingStateChanged(state="motor_ramping") >> FlyingStateChanged(state="takingoff", _timeout=1.) >> FlyingStateChanged(state="hovering", _timeout=5.) ) def on_take_off(self, event, scheduler): if hasattr(self, "my_log"): self.my_log.info("Décollage du drone") #event.message.name self.emit_status("takeoff", event.args["success"]) """ @olympe.listen_event(rssi_changed()) def on_signal_changed(self, event, scheduler): if hasattr(self, "my_log"): self.my_log.info(event.args) self.on_internal_status_changed(event.message.name, event.args["rssi"]) if hasattr(self, "_on_signal_lost") and event.args["rssi"] <= -120: self._on_signal_lost() @olympe.listen_event(NumberOfSatelliteChanged()) def on_satellite_changed(self, event, scheduler): if hasattr(self, "my_log"): self.my_log.info(event); self.on_internal_status_changed(event.message.name, event.args["numberOfSatellite"]) @olympe.listen_event(BatteryStateChanged()) def on_battery_update(self, event, scheduler): if hasattr(self, "my_log"): self.my_log.info(event); self.on_internal_status_changed(event.message.name, event.args["percent"]) @olympe.listen_event(GPSFixStateChanged()) def on_gps_changed(self, event, scheduler): if hasattr(self, "my_log"): self.my_log.info(event); self.on_internal_status_changed(event.message.name, event.args["fixed"]) def on_internal_status_changed(self, name, value): try : if hasattr(self, "_socket_initialized") and hasattr(self, "my_name") and hasattr(self,"_brain_client") and self._socket_initialized: self._brain_client.emit('internal_status_changed', {"id":self.my_name, "status":name, "result":value}) except(Exception) as error : if hasattr(self, "my_log"): self.my_log.error("Une erreur est survenue lors de la mise à jour des états interne") self.my_log.error(error) self.my_log.error("{} = {}".format(value.message.name, value.args)) def on_element_position_update(self, event, value): try : if hasattr(self, "_socket_initialized") and hasattr(self, "my_name") and hasattr(self,"_brain_client") and self._socket_initialized: self._brain_client.emit(event, {"id":self.my_name,"latitude": value.args["latitude"], "longitude": value.args["longitude"], "altitude": value.args["altitude"] }) except(Exception) as error : if hasattr(self, "my_log"): self.my_log.error("Une erreur est survenue lors de la mise à jour des positions") self.my_log.error(error) self.my_log.error("{} = {}".format(value.message.name, value.args)) def emit_status(self, name, value): try : if hasattr(self, "_socket_initialized") and hasattr(self, "my_name") and hasattr(self,"_brain_client") and self._socket_initialized: self._brain_client.emit(name, {"drone_name":self.my_name, "status":value}) except(Exception) as error : if hasattr(self, "my_log"): self.my_log.error("Une erreur est survenue lors de la mise à jour des états interne") self.my_log.error(error) self.my_log.error("{} = {}".format(value.message.name, value.args))