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 __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