def main():
ScreenManager.init()
TM.ladeZeiten()
EM.ladeEvents()
ScreenManager.zeichneHintergrund()
ScreenManager.root.protocol("WM_DELETE_WINDOW", beenden)
ScreenManager.run()
def __init__(self):
self._time_manager = TimeManager()
self._params = Params()
self._status = Status(self._params)
self.log_time = time.time()
self._pwm_read = PwmRead(
self._params.pin_mode_in,
self._params.pin_servo_in,
self._params.pin_thruster_in,
self._params.pin_or,
)
self._pwm_out = PwmOut(self._params.pin_servo_out,
self._params.pin_thruster_out)
self._pid = PositionalPID()
self._logger = Logger()
self._logger.open()
# Whether experienced OR mode or not
self._or_experienced = False
# setup for ina226
print("Configuring INA226..")
try:
self.i_sensor = ina226(INA226_ADDRESS, 1)
self.i_sensor.configure(
avg=ina226_averages_t["INA226_AVERAGES_4"], )
self.i_sensor.calibrate(rShuntValue=0.002, iMaxExcepted=1)
self.i_sensor.log()
print("Mode is " + str(hex(self.i_sensor.getMode())))
except:
print("Error when configuring INA226")
time.sleep(1)
print("Configuration Done")
def calculateFullRangeList(self, stockList):
timeManager = TimeManager()
# intervalMatrix = self.determineDynamicTimeInterval(stockList)
index = 0
# initialStock = stockList[(len(stockList)-1)]
# stockRangeComposite = []
stockRangeContainer = []
# stockRangeComposite.append(stockRangeContainer)
# initialStockDateTime = datetime(2012, 9, 16, int(initialStock["hour_created"]), int(initialStock["minute_created"]), int(initialStock["second_created"]))
# nextStockDateTime = initialStockDateTime + timedelta(minutes=30)
for stock in stockList[::-1]:
# createdStockDateTime = datetime(2012, 9, 16, int(stock["hour_created"]), int(stock["minute_created"]), int(stock["second_created"]))
if(timeManager.isStockWithinTradingTimeBound(stock) == False):
break
#
# if (createdStockDateTime.minute == nextStockDateTime.minute and self.isStockRangeContainerChangeOver):
# self.isStockRangeContainerChangeOver = False
# stockRangeContainer = []
# stockRangeComposite.append(stockRangeContainer)
# if (createdStockDateTime.minute != nextStockDateTime.minute and self.isStockRangeContainerChangeOver == False):
# nextStockDateTime += timedelta(minutes=30)
# self.isStockRangeContainerChangeOver = True
stockRangeContainer.append(stock)
index += 1
return stockRangeContainer
def callbackVerschiebe(self, event):
from EventManager import EventManager
from TimeManager import TimeManager
if event.keysym == "Return":
nach = Zeit.fromString(self.text)
self.unfokusiere()
self.aktualisiereText(
) #setzt den Text auf die gespeicherte Zeit, wird nur überschrieben falls nach passt
if nach is not None:
if self.event is not None:
EventManager.verschiebeZeitNach(self.event,
self.istStartzeit(), nach)
self.text = nach.text
# überprüft ob die Zeit die Start oder Endzeit ist wenn sie einem Event zugeordnet ist
assert (self.istStartzeit() or self.istEndzeit())
assert not (self.istStartzeit() and self.istEndzeit())
else:
TimeManager.verschiebeZeit(self, nach)
self.zeichne()
elif event.keysym == "BackSpace":
self.text = self.text[:-1]
elif event.keysym == "Delete":
self.unfokusiere()
else:
self.text += event.char
self.zeichneMarkiert()
def beenden():
EM.speichereEvents()
TM.speichereZeiten()
try:
ScreenManager.root.destroy()
except:
exit()
def __init__(self, parameters):
r"""Create a new simulation loop instance for a simulation
using the semiclassical Hagedorn wavepacket based propagation
method.
:param parameters: The simulation parameters.
:type parameters: A :py:class:`ParameterProvider` instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
# The time propagator instance driving the simulation.
self.propagator = None
# A `IOManager` instance for saving simulation results.
self.IOManager = None
# The time manager
self._tm = TimeManager(self.parameters)
# Set up serialization of simulation data
self.IOManager = IOManager()
self.IOManager.create_file()
# Save the simulation parameters
self.IOManager.add_parameters()
self.IOManager.save_parameters(parameters)
def compute_parameters(self):
"""Compute some further parameters from the given ones.
"""
# Perform the computation only if the basic values are available.
# This is necessary to add flexibility and essentially read in *any*
# parameter file with heavily incomplete value sets. (F.e. spawn configs)
try:
# The number of time steps we will perform.
tm = TimeManager(self)
self._params["nsteps"] = tm.compute_number_timesteps()
except:
pass
if self._params.has_key("potential"):
# Ugly hack. Should improve handling of potential libraries
Potential = BlockFactory().create_potential(self)
# Number of components of $\Psi$
self._params["ncomponents"] = Potential.get_number_components()
def compute_parameters(self):
"""Compute some further parameters from the given ones.
"""
# Perform the computation only if the basic values are available.
# This is necessary to add flexibility and essentially read in *any*
# parameter file with heavily incomplete value sets. (F.e. spawn configs)
try:
# The number of time steps we will perform.
tm = TimeManager(self)
self._params["nsteps"] = tm.compute_number_timesteps()
except:
pass
if self._params.has_key("potential"):
# Ugly hack. Should improve handling of potential libraries
Potential = BlockFactory().create_potential(self)
# Number of components of $\Psi$
self._params["ncomponents"] = Potential.get_number_components()
def __init__(self, parameters):
r"""Create a new simulation loop instance for a simulation
using the semiclassical Hagedorn wavepacket based propagation
method.
:param parameters: The simulation parameters.
:type parameters: A :py:class:`ParameterProvider` instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
# The time propagator instance driving the simulation.
self.propagator = None
# A `IOManager` instance for saving simulation results.
self.IOManager = None
# The time manager
self._tm = TimeManager(self.parameters)
# Set up serialization of simulation data
self.IOManager = IOManager()
self.IOManager.create_file(self.parameters)
def calculateLooseMarkationList(self, stockList):
timeManager = TimeManager()
# intervalMatrix = self.determineDynamicTimeInterval(stockList)
index = 0
initialStock = stockList[(len(stockList)-1)]
stockRangeComposite = []
stockRangeContainer = []
stockRangeComposite.append(stockRangeContainer)
initialStockDateTime = datetime(2012, 9, 16, int(initialStock["hour_created"]), int(initialStock["minute_created"]), int(initialStock["second_created"]))
nextStockDateTime = initialStockDateTime + timedelta(minutes=30)
for stock in stockList[::-1]:
createdStockDateTime = datetime(2012, 9, 16, int(stock["hour_created"]), int(stock["minute_created"]), int(stock["second_created"]))
if(timeManager.isStockWithinTradingTimeBound(stock) == False):
break
if (createdStockDateTime.minute == nextStockDateTime.minute and self.isStockRangeContainerChangeOver):
self.isStockRangeContainerChangeOver = False
stockRangeContainer = []
stockRangeComposite.append(stockRangeContainer)
if (createdStockDateTime.minute != nextStockDateTime.minute and self.isStockRangeContainerChangeOver == False):
nextStockDateTime += timedelta(minutes=30)
self.isStockRangeContainerChangeOver = True
stockRangeContainer.append(stock)
index += 1
# print(len(stockList))
# print(initialStock)
# print(len(stockRangeComposite))
# print(stockRangeComposite[3])
# stockRangeComposite = self.clearEmptyStockRangeContainerFromComposite(stockRangeComposite)
return stockRangeComposite
def calculateDefiniteMarkationList(self, stockList):
#Definite set entries
#If time is x
timeManager = TimeManager()
index = 0
initialStock = stockList[(len(stockList) - 1)]
stockRangeComposite = []
stockRangeContainer = []
stockRangeComposite.append(stockRangeContainer)
initialStockDateTime = datetime(2012, 9, 16, int(initialStock["hour_created"]),
int(initialStock["minute_created"]), int(initialStock["second_created"]))
nextStockDateTime = initialStockDateTime + timedelta(minutes=30)
for stock in stockList[::-1]:
createdStockDateTime = datetime(2012, 9, 16, int(stock["hour_created"]), int(stock["minute_created"]),
int(stock["second_created"]))
if (timeManager.isStockWithinTradingTimeBound(stock) == False):
break
if (createdStockDateTime.minute == nextStockDateTime.minute and self.isStockRangeContainerChangeOver):
self.isStockRangeContainerChangeOver = False
stockRangeContainer = []
stockRangeComposite.append(stockRangeContainer)
if (
createdStockDateTime.minute != nextStockDateTime.minute and self.isStockRangeContainerChangeOver == False):
nextStockDateTime += timedelta(minutes=30)
self.isStockRangeContainerChangeOver = True
stockRangeContainer.append(stock)
index += 1
markationList = []
return markationList
def __init__(self, parameters):
r"""
Create a new simulation loop instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
self.tm = TimeManager(parameters)
#: The time propagator instance driving the simulation.
self.propagator = None
#: A ``IOManager`` instance for saving simulation results.
self.iom = IOManager()
self.iom.create_file(parameters)
self.gid = self.iom.create_group()
def __new__(self):
if self.__instance == None:
self.__instance = object.__new__(self)
self.__instance.name = ''
self.list_chosen_data_managers = []
self.chosen_stock_temp_container = []
self.listGoldenGeese = []
self.nodeRequester = NodeRequester()
self.dataFilterManager = DataFilterManager()
self.dynamicTimeMarkationManager = DynamicTimeMarkationManager()
self.timeManager = TimeManager()
self.dynamaTransit = DynamaTransit()
self.typeConverter = TypeConverter()
self.httpUtility = HTTPUtility()
self.isHoldings = "0"
self.boughtStockSymbol = "JKJKJKJK"
self.isSellDelimiterMet = "0"
return self.__instance
def select(zeit, exakt=False):
from TimeManager import TimeManager
from EventManager import EventManager
from Event import Event
from Zeit import Zeit
if exakt:
genauigkeit = Zeit(0, 0, None)
else:
genauigkeit = TimeManager.genauigkeit
gefundeneZeit = TimeManager.findeZeit(zeit, genauigkeit)
if gefundeneZeit is not None:
gefundeneZeit.zeichneMarkiert()
ScreenManager.ausgewaehlt = gefundeneZeit
ScreenManager.ausgewaehlt.fokusiere()
return
event = EventManager.findeEvent(zeit, genauigkeit)
if event is None:
zeit = zeit.runde()
# ändere das Datum des neuen Events auf das Datum von akutellesDatum im TimeManager
#zeit.datum = TimeManager.aktuellesDatum.datum
if TimeManager.aufstehzeit <= zeit < TimeManager.schlafenszeit:
neuesEvent = EventManager.addEvent(
Event(zeit, zeit + EventManager.eventLaenge))
ScreenManager.ausgewaehlt = neuesEvent
else:
return
else:
if zeit.circa(event.startzeit, genauigkeit):
ScreenManager.ausgewaehlt = event.startzeit
elif zeit.circa(event.endzeit, genauigkeit):
ScreenManager.ausgewaehlt = event.endzeit
else:
ScreenManager.ausgewaehlt = event
ScreenManager.ausgewaehlt.zeichneMarkiert()
ScreenManager.ausgewaehlt.fokusiere()
def get_timemanager(self):
"""Return the embedded I{TimeManager} instance.
"""
#try:
return TimeManager(self._params)
class SimulationLoopHagedornInhomogeneous(SimulationLoop):
r"""This class acts as the main simulation loop. It owns a propagator that
propagates a set of initial values during a time evolution.
"""
def __init__(self, parameters):
r"""Create a new simulation loop instance for a simulation
using the semiclassical Hagedorn wavepacket based propagation
method.
:param parameters: The simulation parameters.
:type parameters: A :py:class:`ParameterProvider` instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
# The time propagator instance driving the simulation.
self.propagator = None
# A `IOManager` instance for saving simulation results.
self.IOManager = None
# The time manager
self._tm = TimeManager(self.parameters)
# Set up serialization of simulation data
self.IOManager = IOManager()
self.IOManager.create_file()
# Save the simulation parameters
self.IOManager.add_parameters()
self.IOManager.save_parameters(parameters)
def prepare_simulation(self):
r"""Set up a Hagedorn propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise: :py:class:`ValueError` For invalid or missing input data.
"""
# The potential instance
potential = BlockFactory().create_potential(self.parameters)
# Project the initial values to the canonical basis
BT = BasisTransformationHAWP(potential)
# Finally create and initialize the propagator instance
# TODO: Attach the "leading_component to the hawp as codata
self.propagator = HagedornPropagatorInhomogeneous(self.parameters, potential)
# Create suitable wavepackets
for packet_descr in self.parameters["initvals"]:
packet = BlockFactory().create_wavepacket(packet_descr)
# Transform to canonical basis
BT.set_matrix_builder(packet.get_innerproduct())
BT.transform_to_canonical(packet)
# And hand over
self.propagator.add_wavepacket((packet,))
# Add storage for each packet
npackets = len(self.parameters["initvals"])
slots = self._tm.compute_number_saves()
key = ("q","p","Q","P","S","adQ")
for i in xrange(npackets):
bid = self.IOManager.create_block()
self.IOManager.add_inhomogwavepacket(self.parameters, timeslots=slots, blockid=bid, key=key)
# Write some initial values to disk
for packet in self.propagator.get_wavepackets():
self.IOManager.save_inhomogwavepacket_description(packet.get_description())
# Pi
self.IOManager.save_inhomogwavepacket_parameters(packet.get_parameters(key=key), timestep=0, key=key)
# Basis shapes
for shape in packet.get_basis_shapes():
self.IOManager.save_inhomogwavepacket_basisshapes(shape)
# Coefficients
self.IOManager.save_inhomogwavepacket_coefficients(packet.get_coefficients(), packet.get_basis_shapes(), timestep=0)
def run_simulation(self):
r"""Run the simulation loop for a number of time steps.
"""
# The number of time steps we will perform.
nsteps = self._tm.compute_number_timesteps()
# Which parameter data to save.
key = ("q","p","Q","P","S","adQ")
# Run the prepropagate step
self.propagator.pre_propagate()
# Note: We do not save any data here
# Run the simulation for a given number of timesteps
for i in xrange(1, nsteps+1):
print(" doing timestep "+str(i))
self.propagator.propagate()
# Save some simulation data
if self._tm.must_save(i):
# Run the postpropagate step
self.propagator.post_propagate()
# TODO: Generalize for arbitrary number of wavepackets
packets = self.propagator.get_wavepackets()
assert len(packets) == 1
for packet in packets:
# Pi
self.IOManager.save_inhomogwavepacket_parameters(packet.get_parameters(key=key), timestep=i, key=key)
# Basis shapes (in case they changed!)
for shape in packet.get_basis_shapes():
self.IOManager.save_inhomogwavepacket_basisshapes(shape)
# Coefficients
self.IOManager.save_inhomogwavepacket_coefficients(packet.get_coefficients(), packet.get_basis_shapes(), timestep=i)
# Run the prepropagate step
self.propagator.pre_propagate()
# Run the postpropagate step
self.propagator.post_propagate()
# Note: We do not save any data here
def end_simulation(self):
r"""Do the necessary cleanup after a simulation. For example request the
:py:class:`IOManager` to write the data and close the output files.
"""
self.IOManager.finalize()
class SimulationLoopHagedornInhomogeneous(SimulationLoop):
r"""This class acts as the main simulation loop. It owns a propagator that
propagates a set of initial values during a time evolution.
"""
def __init__(self, parameters):
r"""Create a new simulation loop instance for a simulation
using the semiclassical Hagedorn wavepacket based propagation
method.
:param parameters: The simulation parameters.
:type parameters: A :py:class:`ParameterProvider` instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
# The time propagator instance driving the simulation.
self.propagator = None
# A `IOManager` instance for saving simulation results.
self.IOManager = None
# The time manager
self._tm = TimeManager(self.parameters)
# Set up serialization of simulation data
self.IOManager = IOManager()
self.IOManager.create_file(self.parameters)
def prepare_simulation(self):
r"""Set up a Hagedorn propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise ValueError: For invalid or missing input data.
"""
# The potential instance
potential = BlockFactory().create_potential(self.parameters)
# Project the initial values to the canonical basis
BT = BasisTransformationHAWP(potential)
# Finally create and initialize the propagator instace
# TODO: Attach the "leading_component to the hawp as codata
self.propagator = HagedornPropagatorInhomogeneous(
self.parameters, potential)
# Create suitable wavepackets
for packet_descr in self.parameters["initvals"]:
packet = BlockFactory().create_wavepacket(packet_descr)
# Transform to canonical basis
BT.set_matrix_builder(packet.get_quadrature())
BT.transform_to_canonical(packet)
# And hand over
self.propagator.add_wavepacket((packet, ))
# Add storage for each packet
npackets = len(self.parameters["initvals"])
slots = self._tm.compute_number_saves()
for i in xrange(npackets):
bid = self.IOManager.create_block()
self.IOManager.add_inhomogwavepacket(self.parameters,
timeslots=slots,
blockid=bid)
# Write some initial values to disk
for packet in self.propagator.get_wavepackets():
self.IOManager.save_inhomogwavepacket_description(
packet.get_description())
# Pi
self.IOManager.save_inhomogwavepacket_parameters(
packet.get_parameters(), timestep=0)
# Basis shapes
for shape in packet.get_basis_shape():
self.IOManager.save_inhomogwavepacket_basisshapes(shape)
# Coefficients
self.IOManager.save_inhomogwavepacket_coefficients(
packet.get_coefficients(),
packet.get_basis_shape(),
timestep=0)
def run_simulation(self):
r"""Run the simulation loop for a number of time steps.
"""
# The number of time steps we will perform.
nsteps = self._tm.compute_number_timesteps()
# Run the simulation for a given number of timesteps
for i in xrange(1, nsteps + 1):
print(" doing timestep " + str(i))
self.propagator.propagate()
# Save some simulation data
if self._tm.must_save(i):
# TODO: Generalize for arbitrary number of wavepackets
packets = self.propagator.get_wavepackets()
assert len(packets) == 1
for packet in packets:
# Pi
self.IOManager.save_inhomogwavepacket_parameters(
packet.get_parameters(), timestep=i)
# Basis shapes (in case they changed!)
for shape in packet.get_basis_shape():
self.IOManager.save_inhomogwavepacket_basisshapes(
shape)
# Coefficients
self.IOManager.save_inhomogwavepacket_coefficients(
packet.get_coefficients(),
packet.get_basis_shape(),
timestep=i)
def end_simulation(self):
r"""Do the necessary cleanup after a simulation. For example request the
:py:class:`IOManager` to write the data and close the output files.
"""
self.IOManager.finalize()
class SimulationLoopSpawnAdiabatic(SimulationLoop):
r"""
This class acts as the main simulation loop. It owns a propagator that
propagates a set of initial values during a time evolution. All values are
read from the ``Parameters.py`` file.
"""
def __init__(self, parameters):
r"""
Create a new simulation loop instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
self.tm = TimeManager(parameters)
#: The time propagator instance driving the simulation.
self.propagator = None
#: A ``IOManager`` instance for saving simulation results.
self.iom = IOManager()
self.iom.create_file(parameters)
self.gid = self.iom.create_group()
def prepare_simulation(self):
r"""
Set up a Spawning propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise ValueError: For invalid or missing input data.
"""
potential = PotentialFactory().create_potential(self.parameters)
N = potential.get_number_components()
# Check for enough initial values
if self.parameters["leading_component"] > N:
raise ValueError("Leading component index out of range.")
if len(self.parameters["parameters"]) < N:
raise ValueError("Too few initial states given. Parameters are missing.")
if len(self.parameters["coefficients"]) < N:
raise ValueError("Too few initial states given. Coefficients are missing.")
# Create a suitable wave packet
packet = HagedornWavepacket(self.parameters)
packet.set_parameters(self.parameters["parameters"][self.parameters["leading_component"]])
packet.set_quadrature(None)
# Set the initial values
for component, data in enumerate(self.parameters["coefficients"]):
for index, value in data:
packet.set_coefficient(component, index, value)
# Project the initial values to the canonical basis
packet.project_to_canonical(potential)
# Finally create and initialize the propagator instace
inner = HagedornPropagator(potential, packet, self.parameters["leading_component"], self.parameters)
self.propagator = SpawnAdiabaticPropagator(inner, potential, packet, self.parameters["leading_component"], self.parameters)
# Write some initial values to disk
slots = self.tm.compute_number_saves()
for packet in self.propagator.get_wavepackets():
bid = self.iom.create_block(groupid=self.gid)
self.iom.add_wavepacket(self.parameters, timeslots=slots, blockid=bid)
self.iom.save_wavepacket_coefficients(packet.get_coefficients(), blockid=bid, timestep=0)
self.iom.save_wavepacket_parameters(packet.get_parameters(), blockid=bid, timestep=0)
def run_simulation(self):
r"""
Run the simulation loop for a number of time steps. The number of steps is calculated in the ``initialize`` function.
"""
tm = self.tm
# Run the simulation for a given number of timesteps
for i in xrange(1, tm.get_nsteps()+1):
print(" doing timestep "+str(i))
self.propagator.propagate(tm.compute_time(i))
# Save some simulation data
if tm.must_save(i):
# Check if we need more data blocks for newly spawned packets
while self.iom.get_number_blocks(groupid=self.gid) < self.propagator.get_number_packets():
bid = self.iom.create_block(groupid=self.gid)
self.iom.add_wavepacket(self.parameters, blockid=bid)
for index, packet in enumerate(self.propagator.get_wavepackets()):
self.iom.save_wavepacket_coefficients(packet.get_coefficients(), timestep=i, blockid=index)
self.iom.save_wavepacket_parameters(packet.get_parameters(), timestep=i, blockid=index)
def end_simulation(self):
r"""
Do the necessary cleanup after a simulation. For example request the
IOManager to write the data and close the output files.
"""
self.iom.finalize()
# ------------- DATE -------------
# Must be in format: YYYY-MM-DDTHH:MM:SS.ssssss+/-hh:mm (ISO8601)
# To specify specific time, use BEGIN_DATE. Otherwise, script will find a file
# -- If LAST_TIME_UPDATE.txt file NOT FOUND and BEGIN_DATE = None, script will Download All
BEGIN_DATE = None
# ------------- DATABASE -------------
DATABASE_HOST_NAME = "localhost"
DATABASE_USERNAME = "******"
DB_USER_PASSWORD = "******"
DATABASE_NAME = "DomainServer"
AUTH_PLUGIN = "mysql_native_password"
#################### MAIN ########################
# Create a time manager
timeManager = TimeManager(BEGIN_DATE)
# Create a database Client
databaseClient = DatabaseConnect(DATABASE_HOST_NAME, DATABASE_USERNAME,
DB_USER_PASSWORD, DATABASE_NAME, AUTH_PLUGIN)
# Create a AlientVault TAXII Client and Connect to database
alientvaultTaxiAndDatabaseConnect = TaxiClientToDatabase(
OTX_TAXI_CLIENT['hostURL'],
OTX_TAXI_CLIENT['useHHTPS'],
OTX_TAXI_CLIENT['discoveryPath'],
OTX_TAXI_CLIENT['usernameKey'],
OTX_TAXI_CLIENT['password'],
OTX_TAXI_CLIENT['collectionNames'],
databaseClient,
timeManager,
)
def keyInput(keyEvent):
from Zeit import Zeit
from TimeManager import TimeManager
from EventManager import EventManager
from Event import Event
if keyEvent.keysym == "Return":
#Parse different input
zeit = Zeit.fromString(ScreenManager.inputText)
zeit1, zeit2 = Zeit.intervalFromString(ScreenManager.inputText)
datum = Zeit.dateFromString(ScreenManager.inputText)
#reset the input Text
ScreenManager.inputText = ""
if zeit is not None:
zeit.datum = TimeManager.aktuellesDatum.datum
ScreenManager.select(zeit, True)
elif zeit1 is not None and zeit2 is not None:
zeit1.datum = zeit2.datum = TimeManager.aktuellesDatum.datum
if (TimeManager.aufstehzeit <= zeit1 <
TimeManager.mittagspauseStart
and zeit1 < zeit2 <= TimeManager.mittagspauseStart
) or (TimeManager.mittagspauseEnde <= zeit1 <
TimeManager.schlafenszeit
and zeit1 < zeit2 <= TimeManager.schlafenszeit):
neuesEvent = EventManager.addEvent(Event(zeit1, zeit2))
ScreenManager.ausgewaehlt = neuesEvent
ScreenManager.ausgewaehlt.zeichneMarkiert()
ScreenManager.ausgewaehlt.fokusiere()
else:
ScreenManager.inputText = "Invalid Input for Interval"
elif datum is not None:
# speichere
EventManager.speichereEvents()
TimeManager.speichereZeiten()
#verschiebe
TimeManager.aktuellesDatum.datum = datum.datum
# lösche die Zeiten und Events von vorherigen Tag vom Canvas
for event in EventManager.events:
event.verstecke()
for zeit in TimeManager.zeiten:
zeit.entferne()
EventManager.mittagspause.verstecke()
# Lade und zeichne neu
TimeManager.ladeZeiten()
EventManager.ladeEvents()
ScreenManager.zeichneHintergrund()
ScreenManager.canvas.itemconfig(
ScreenManager.datumAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumLang())
ScreenManager.canvas.itemconfig(
ScreenManager.jahrAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumJahr())
elif keyEvent.keysym == "BackSpace":
ScreenManager.inputText = ScreenManager.inputText[:-1]
elif keyEvent.keysym == "Delete":
pass
elif keyEvent.keysym == "Right":
#speichere
EventManager.speichereEvents()
TimeManager.speichereZeiten()
TimeManager.aktuellesDatum.verschiebeAufMorgen()
# lösche die Zeiten und Events von vorherigen Tag vom Canvas
for event in EventManager.events:
event.verstecke()
for zeit in TimeManager.zeiten:
zeit.entferne()
EventManager.mittagspause.verstecke()
#Lade und zeichne neu
TimeManager.ladeZeiten()
ScreenManager.zeichneHintergrund()
EventManager.ladeEvents()
ScreenManager.canvas.itemconfig(
ScreenManager.datumAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumLang())
ScreenManager.canvas.itemconfig(
ScreenManager.jahrAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumJahr())
elif keyEvent.keysym == "Left":
#speichere
EventManager.speichereEvents()
TimeManager.speichereZeiten()
TimeManager.aktuellesDatum.verschiebeAufGestern()
#lösche die Zeiten und Events von vorherigen Tag vom Canvas
for event in EventManager.events:
event.verstecke()
for zeit in TimeManager.zeiten:
zeit.entferne()
EventManager.mittagspause.verstecke()
#lade und zeichne neu
TimeManager.ladeZeiten()
ScreenManager.zeichneHintergrund()
EventManager.ladeEvents()
ScreenManager.canvas.itemconfig(
ScreenManager.datumAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumLang())
ScreenManager.canvas.itemconfig(
ScreenManager.jahrAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumJahr())
else:
ScreenManager.inputText += keyEvent.char
ScreenManager.canvas.itemconfig(
ScreenManager.inputAnzeige,
text=f"Input: {ScreenManager.inputText}")
class Driver:
def __init__(self):
self._time_manager = TimeManager()
self._params = Params()
self._status = Status(self._params)
self.log_time = time.time()
self._pwm_read = PwmRead(
self._params.pin_mode_in,
self._params.pin_servo_in,
self._params.pin_thruster_in,
self._params.pin_or,
)
self._pwm_out = PwmOut(self._params.pin_servo_out,
self._params.pin_thruster_out)
self._pid = PositionalPID()
self._logger = Logger()
self._logger.open()
# Whether experienced OR mode or not
self._or_experienced = False
# setup for ina226
print("Configuring INA226..")
try:
self.i_sensor = ina226(INA226_ADDRESS, 1)
self.i_sensor.configure(
avg=ina226_averages_t["INA226_AVERAGES_4"], )
self.i_sensor.calibrate(rShuntValue=0.002, iMaxExcepted=1)
self.i_sensor.log()
print("Mode is " + str(hex(self.i_sensor.getMode())))
except:
print("Error when configuring INA226")
time.sleep(1)
print("Configuration Done")
def check_mode_change(self):
print(
"Please set to AN mode and then switch to RC mode to start appropriately."
)
self._pwm_read.measure_pulse_width()
self._update_mode()
if self._status.mode == "AN":
print("Next procedure: Set to RC mode to start.")
while self._status.mode == "AN":
self._pwm_read.measure_pulse_width()
self._update_mode()
time.sleep(0.1)
elif self._status.mode == "RC":
print(
"Next procedure: set to AN mode and then switch to RC mode to start."
)
while self._status.mode == "RC":
self._pwm_read.measure_pulse_width()
self._update_mode()
time.sleep(0.1)
print("Next procedure: Set to RC mode to start.")
while self._status.mode == "AN":
self._pwm_read.measure_pulse_width()
self._update_mode()
time.sleep(0.1)
print("Procedure confirmed.")
def load_params(self, filename):
print("loading", filename)
with open(filename, "r") as f:
params = yaml.safe_load(f)
time_limit = params["time_limit"]
sleep_time = params["sleep_time"]
P = params["P"]
I = params["I"]
D = params["D"]
self._time_manager.set_time_limit(time_limit) # Time Limit
self._sleep_time = float(sleep_time) # Sleep time
self._pid.set_pid(P, I, D)
for wp in params["waypoints"]:
name = wp["name"]
lat = wp["lat"]
lon = wp["lon"]
print(name, lat, lon)
self._status.waypoint.add_point(lat, lon)
return
def do_operation(self):
while self._time_manager.in_time_limit():
# update pwm
# Read pwm pulse width
self._pwm_read.measure_pulse_width()
# Set the readout signals as the output signals
# self._pwm_out.mode_pulse_width = self._pwm_read.pins[
# self._pwm_read.pin_mode
# ]["pulse_width"]
self._pwm_out.servo_pulse_width = self._pwm_read.pins[
self._pwm_read.pin_servo]["pulse_width"]
self._pwm_out.thruster_pulse_width = self._pwm_read.pins[
self._pwm_read.pin_thruster]["pulse_width"]
# read gps
self._status.read_gps()
self._update_mode()
mode = self._status.mode
if mode == "RC":
pass
elif mode == "AN":
self._auto_navigation()
elif mode == "OR":
self._out_of_range_operation()
# update output
self._pwm_out.update_pulse_width()
if time.time() - self.log_time > 1:
self.log_time = time.time()
# for test
self._pwm_read.print_pulse_width()
# ina226
if hasattr(self, "i_sensor"):
self.i_sensor.log()
self._print_log()
time.sleep(self._sleep_time)
return
def _update_mode(self):
mode_duty_ratio = self._pwm_read.pins[
self._pwm_read.pin_mode]["pulse_width"]
# RC mode
if 0 < mode_duty_ratio < 1500:
self._status.mode = "RC"
# AN mode
elif 1500 <= mode_duty_ratio:
self._status.mode = "AN"
else:
print("Error: mode updating failed", file=sys.stderr)
return
def _auto_navigation(self):
# update status
status = self._status
status.calc_target_bearing()
status.calc_target_distance()
status.update_target()
boat_heading = math.degrees(self._status.boat_heading)
target_bearing = math.degrees(self._status.target_bearing)
target_bearing_relative = math.degrees(
self._status.target_bearing_relative)
target_distance = self._status.target_distance
servo_pulse_width = self._pid.get_step_signal(target_bearing_relative,
target_distance)
self._pwm_out.servo_pulse_width = servo_pulse_width
self._pwm_out.thruster_pulse_width = 1700
return
def _out_of_range_operation(self):
# Be stationary
# self.pwm_out.end()
# update waypoint where the boat was
self._auto_navigation()
return
def _print_log(self):
timestamp = self._status.timestamp_string
mode = self._status.mode
latitude = self._status.latitude
longitude = self._status.longitude
speed = self._status.speed
heading = math.degrees(self._status.boat_heading)
servo_pw = self._pwm_out.servo_pulse_width
thruster_pw = self._pwm_out.thruster_pulse_width
t_bearing = math.degrees(self._status.target_bearing)
t_bearing_rel = math.degrees(self._status.target_bearing_relative)
t_distance = self._status.target_distance
target = self._status.waypoint.get_point()
t_latitude = target[0]
t_longitude = target[1]
t_idx = self._status.waypoint._index
err = self._pid.err_back
if hasattr(self, "i_sensor"):
current = str(round(self.i_sensor.readShuntCurrent(), 3))
voltage = str(round(self.i_sensor.readBusVoltage(), 3))
power = str(round(self.i_sensor.readBusPower(), 3))
else:
current = 0
voltage = 0
power = 0
# To print logdata
print(timestamp)
print("[%s MODE] LAT=%.7f, LON=%.7f, SPEED=%.2f [km/h], HEADING=%lf" %
(mode, latitude, longitude, speed, heading))
print("DUTY (SERVO, THRUSTER): (%6.1f, %6.1f) [us]" %
(servo_pw, thruster_pw))
print(f"TARGET INDEX: {t_idx}")
print("TARGET (LATITUDE, LONGITUDE): (%.7f, %.7f)" %
(t_latitude, t_longitude))
print("TARGET (REL_BEARING, DISTANCE): (%5.2f, %5.2f [m])" %
(t_bearing_rel, t_distance))
print("")
# To write logdata (csv file)
log_list = [
timestamp,
mode,
latitude,
longitude,
heading,
speed,
t_latitude,
t_longitude,
servo_pw,
thruster_pw,
t_bearing,
t_distance,
err,
current,
voltage,
power,
]
self._logger.write(log_list)
return
def end(self):
self._logger.close()
self._pwm_read.end()
self._pwm_out.end()
return
