/*
* Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
*
* This file is part of PeerfactSim.KOM.
*
* PeerfactSim.KOM is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* PeerfactSim.KOM is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with PeerfactSim.KOM. If not, see .
*
*/
package de.tud.kom.p2psim.impl.topology.component;
import java.util.LinkedList;
import java.util.Set;
import de.tud.kom.p2psim.api.common.SimHost;
import de.tud.kom.p2psim.api.energy.ComponentType;
import de.tud.kom.p2psim.api.energy.EnergyModel;
import de.tud.kom.p2psim.api.network.SimNetInterface;
import de.tud.kom.p2psim.api.topology.Topology;
import de.tud.kom.p2psim.api.topology.movement.MovementModel;
import de.tud.kom.p2psim.api.topology.movement.SimUAVLocationActuator;
import de.tud.kom.p2psim.api.topology.movement.UAVMovementModel;
import de.tud.kom.p2psim.api.topology.placement.PlacementModel;
import de.tud.kom.p2psim.impl.energy.RechargeableBattery;
import de.tud.kom.p2psim.impl.energy.components.ActuatorComponent;
import de.tud.kom.p2psim.impl.energy.components.StatelessActuatorComponent;
import de.tud.kom.p2psim.impl.energy.models.AbstractEnergyModel;
import de.tud.kom.p2psim.impl.topology.placement.UAVBasePlacement;
import de.tud.kom.p2psim.impl.topology.util.PositionVector;
import de.tudarmstadt.maki.simonstrator.api.Monitor;
import de.tudarmstadt.maki.simonstrator.api.component.ComponentNotAvailableException;
import de.tudarmstadt.maki.simonstrator.api.component.overlay.OverlayComponent;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.AttractionPoint;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
import de.tudarmstadt.maki.simonstrator.api.uavsupport.callbacks.BaseConnectedCallback;
import de.tudarmstadt.maki.simonstrator.api.uavsupport.callbacks.BaseDisconnectedCallback;
import de.tudarmstadt.maki.simonstrator.api.uavsupport.callbacks.BatteryReplacementCallback;
import de.tudarmstadt.maki.simonstrator.api.uavsupport.callbacks.ReachedLocationCallback;
import de.tudarmstadt.maki.simonstrator.api.uavsupport.communication.UAVToBaseInterface;
/**
* Topology component used for UAVs.
*
* @author Julian Zobel
* @version 1.0, 06.09.2018
*/
public class UAVTopologyComponent extends AbstractTopologyComponent implements SimUAVLocationActuator {
public enum UAVstate {OFFLINE, BASE_CONNECTION, ACTION, RETURN, CRASHED}
private UAVMovementModel movement;
private OverlayComponent uavOverlayComponent;
protected PositionVector direction;
private ActuatorComponent actuator;
private RechargeableBattery battery;
private UAVstate state = UAVstate.OFFLINE;
private PositionVector baseLocation;
private UAVToBaseInterface controllerInterface;
/**
* Create a TopologyComponent for the current host.
*
* @param host
* @param topology
* @param movementModel
*/
public UAVTopologyComponent(SimHost host, Topology topology,
MovementModel movementModel, PlacementModel placementModel, boolean registerAsInformationProviderInSiS) {
super(host, topology, movementModel, placementModel, registerAsInformationProviderInSiS);
direction = new PositionVector(0,-1,0);
}
@Override
public void initialize() {
super.initialize();
try {
actuator = getHost().getComponent(EnergyModel.class)
.getComponent(ComponentType.ACTUATOR, ActuatorComponent.class);
movement.setMotorControl(actuator);
} catch (ComponentNotAvailableException e) {
System.err.println("No Acutator Energy Component was found!");
}
try {
battery = (RechargeableBattery) getHost().getComponent(AbstractEnergyModel.class).getBattery();
} catch (ComponentNotAvailableException e) {
System.err.println("No Battery Component was found!");
}
// retrieve base location
baseLocation = UAVBasePlacement.base.position.clone();
}
public void setState(UAVstate newState) {
this.state = newState;
// TODO analyzer
if(Monitor.hasAnalyzer(UAVStatisticAnalyzer.class)) {
Monitor.getOrNull(UAVStatisticAnalyzer.class).uavSwitchedStates(this, newState);
}
}
public void setUAVComponent(OverlayComponent uavOverlayComponent) {
this.uavOverlayComponent = uavOverlayComponent;
}
public OverlayComponent getUAVComponent() {
return uavOverlayComponent;
}
@Override
public double getMinMovementSpeed() {
return movement.horizontalMinVelocity();
}
@Override
public double getMaxMovementSpeed() {
return movement.horizontalMaxVelocity();
}
@Override
public double getMovementSpeed() {
return movement.getCurrentSpeed();
}
@Override
public void setMovementSpeed(double speed) {
movement.setPreferredSpeed(speed);
}
@Override
public boolean isActive() {
if(actuator.isOn()) {
return true;
} else {
if(state == UAVstate.ACTION || state == UAVstate.RETURN) {
this.deactivate();
}
return false;
}
}
@Override
public boolean activate() {
if(actuator.turnOn()) {
this.setState(UAVstate.ACTION);
return true;
}
else {
return false;
}
}
@Override
public boolean deactivate() {
actuator.turnOff();
if(this.position.getAltitude() != 0) {
this.setState(UAVstate.CRASHED);
uavOverlayComponent.shutdown();
shutdownCommunication();
} else {
this.setState(UAVstate.OFFLINE);
}
return true;
}
@Override
public PositionVector getCurrentLocation() {
return position.clone();
}
@Override
public double getCurrentBatteryLevel() {
return battery.getCurrentPercentage();
}
@Override
public double getCurrentBatteryEnergy() {
return battery.getCurrentEnergyLevel();
}
public RechargeableBattery getBattery() {
return battery;
}
@Override
public UAVMovementModel getUAVMovement() {
return movement;
}
@Override
public void setUAVMovement(UAVMovementModel uavMovement) {
this.movement = uavMovement;
}
@Override
public Set getAllAttractionPoints() {
throw new UnsupportedOperationException();
}
@Override
public void setTargetLocation(PositionVector targetLocation,
ReachedLocationCallback cb) {
movement.setTargetLocation(new PositionVector(targetLocation), cb);
}
@Override
public void addTargetLocation(PositionVector targetLocation,
ReachedLocationCallback cb) {
movement.addTargetLocation(new PositionVector(targetLocation), cb);
}
@Override
public void setTargetLocationRoute(LinkedList route,
ReachedLocationCallback cb) {
LinkedList positionvectorlist = new LinkedList<>();
for (Location loc : route) {
positionvectorlist.add(new PositionVector(loc));
}
movement.setTargetLocationRoute(positionvectorlist, cb);
}
@Override
public void removeAllTargetLocations() {
movement.removeTargetLocations();
}
@Override
public void setTargetAttractionPoint(AttractionPoint targetAttractionPoint) {
throw new UnsupportedOperationException();
}
@Override
public AttractionPoint getCurrentTargetAttractionPoint() {
throw new UnsupportedOperationException();
}
@Override
public LinkedList getTargetLocations() {
return movement.getTargetLocations();
}
public UAVstate getUAVState() {
return state;
}
@Override
public void returnToBase(ReachedLocationCallback cb) {
this.setState(UAVstate.RETURN);
ReachedLocationCallback returnCallback = new ReachedLocationCallback() {
@Override
public void reachedLocation() {
deactivate();
cb.reachedLocation();
}
};
movement.setPreferredSpeed(movement.horizontalMaxVelocity());
movement.setTargetLocation(baseLocation, returnCallback);
}
public void batteryReplacement(BatteryReplacementCallback cb) {
if(state != UAVstate.BASE_CONNECTION) {
throw new UnsupportedOperationException("Cannot recharge if not connected to base!");
}
BaseTopologyComponent base = UAVBasePlacement.base;
base.getCharger().charge(this, cb);
}
public void setControllerInterface(UAVToBaseInterface controllerInterface) {
this.controllerInterface = controllerInterface;
}
@Override
public void connectToBase(BaseConnectedCallback cb) {
BaseTopologyComponent base = UAVBasePlacement.base;
base.connectUAVToBase(controllerInterface);
if(cb != null)
cb.successfulConnection();
this.setState(UAVstate.BASE_CONNECTION);
shutdownCommunication();
}
@Override
public void disconnectFromBase(BaseDisconnectedCallback cb) {
startCommunication();
BaseTopologyComponent base = UAVBasePlacement.base;
base.disconnectUAVFromBase(controllerInterface);
if(cb != null)
cb.successfulDisconnection();
}
private void shutdownCommunication() {
for (SimNetInterface net : getHost().getNetworkComponent().getSimNetworkInterfaces())
net.goOffline();
}
private void startCommunication() {
for (SimNetInterface net : getHost().getNetworkComponent().getSimNetworkInterfaces())
net.goOnline();
}
@Override
public PositionVector getCurrentDirection() {
return direction;
}
@Override
public void updateCurrentDirection(PositionVector direction) {
this.direction.set(direction);
}
@Override
public double getMaximumBatteryCapacity() {
return battery.getMaximumEnergyLevel();
}
@Override
public double estimatePowerConsumption(double velocity) {
return movement.estimatePowerConsumption(velocity);
}
@Override
public PositionVector getBaseLocation() {
return baseLocation.clone();
}
}