def __init__(self, saveobject):
self.__save = saveobject
self.RTC = Drivers.rtc.RTC()
self.UVDriver = Drivers.UV.UVDriver(
) #may need to rework this if reduntant drivers are added
self.__deployData = None
self.Accelerometer = Drivers.Accelerometer()
def makeform(self, fields):
entries = {}
for field in fields:
row = Frame(self.editor)
lab = Label(row, width=22, text=field + ": ", anchor='w')
ent = Entry(row)
ent.insert(0, "")
row.pack(side=TOP, fill=X, padx=5, pady=5)
lab.pack(side=LEFT)
ent.pack(side=RIGHT, expand=YES, fill=X)
entries[field] = ent
team_name = Label(self.editor, text="Team :")
team_name.pack(side=LEFT, padx=5, pady=5)
teamvar = StringVar(self)
global choices
teamvar.set(choices[0])
team_entry = OptionMenu(self.editor, teamvar, *choices)
team_entry.pack(side=RIGHT)
Reserve = IntVar(self)
isReserve = Checkbutton(self.editor, text="Reserve", variable=Reserve)
isReserve.pack(side=RIGHT)
entries["Team"] = teamvar
entries["Reserve"] = Reserve
add_Driver = tk.Button(self.editor,
text="Submit",
command=Drivers.main(entries))
add_Driver.pack(side=RIGHT, padx=5, pady=5)
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.drivers = LabelFrame(self, text="Drivers")
self.drivers.grid(row=0, column=0, sticky=N)
self.editor = LabelFrame(self, text="New driver")
self.editor.grid(row=0, column=2, sticky=N)
global driversss
self.gridMaking(10, len(driversss), 0, "drivers")
entries = self.formMaking()
#global fields
#self.makeform(fields)
button1 = tk.Button(self,
text="Back to Home",
command=lambda: controller.show_frame(homePage))
button1.grid(row=99, column=1)
submit = Button(self.editor,
text="Submit",
command=lambda: Drivers.main(entries))
submit.grid(row=9, column=1)
def __init__(self, saveobject):
self.save = saveobject
self.RTC = Drivers.rtc.RTC() # may need rework with redundant drivers
self.__attitudeData = None
self.sunSensor = Drivers.sunSensors.sunSensorDriver.sunSensor()
self.Magnetometer = Drivers.Magnetometer()
self.__dataSamples = 1800
self.__collectedData = 0
def main(*argv):
print "//---------------------------------------------"
print
print "Parsing startup arguments"
if not argv or "--dedicated" not in argv[1:]:
Drivers.clearMainDriver()
driver = Drivers.GFXDriver()
# Here we should expliclty load a settings file
driver.settings["ui_defs"] = "scripts.ui"
# driver.settings["keymap_name"] = "default"
Drivers.setMainDriver(driver)
else:
print "Dedicated server requested"
print "But no such driver exists"
print
print "---------------------------------------------//"
print
def configure_ui(width,height):
print "Executing configure_ui(%d,%d)" % (width,height)
from _rocketcore import CreateContext, Vector2i
import Drivers
driver = Drivers.getMainDriver()
if driver == None or width <= 0 or height <= 0:
ret = False
else:
driver.uiHandle = CreateContext("primary_ui_context",Vector2i(width,height))
print " Initializing keymap (GLFW -> libRocket)..."
from scripts.prefs.keymaps import getKeyMap
Drivers.clearKeyMap()
for g,r in getKeyMap().iteritems():
Drivers.mapKey(g,r)
import main_menu
print " Finished initalizing keymap."
print " Initializing default fonts..."
from scripts.prefs.fonts import loadDefaultFonts
loadDefaultFonts()
print " Finished initializing default fonts."
main_menu.init(driver.uiHandle)
ret = True
return ret
def finish(self, filename: str, window0) -> None:
"""
Automatically detects driver based on file extension.
:param filename: filename with extension
:return: None
"""
self.base_drivers = Drivers.SDFabric.get_driver_base()
if os.path.isfile(filename):
driver_name = self.base_drivers[filename.split('.')[1]]
builder = Drivers.SDFabric().get_sd_driver(driver_name)
sd = builder.build(filename)
self.l_from_file = linkedlist.LinkedList()
self.l_from_file.set_structure_driver(sd)
self.l_from_file.load() # закачка линкедлиста из файла
window0.destroy()
self.create_window()
def save_as(self, filename: str, extension: str) -> None:
"""
Функция сохраняет результаты поиска в файл с заданным именем и выбранным расширением
:param filename: имя файла
:param extension: расширение файла
:return:
"""
driver_name = self.base_drivers[extension]
builder = Drivers.SDFabric().get_sd_driver(driver_name)
sd = builder.build(f"{filename}.{extension}")
l_for_save = linkedlist.LinkedList()
for i in range(1, len(self.result_dict) + 1):
l_for_save.append(self.result_dict[i])
l_for_save.set_structure_driver(sd)
l_for_save.save()
l_for_save.clear()
print "Importing %s..."%(__name__),
import os.path
from main import determine_package,export_symbols
import Drivers
path = os.path.abspath(__file__)
dir_path = os.path.dirname(path)
__all__=determine_package(dir_path)
export_symbols(Drivers.getMainDriver().settings.get("keymap","%s.default" %(__name__)),
globals(),
locals(),
[
"getKeyMap",
"getEffectiveKeyNames",
"getEffectiveKeyIndices",
"getBackendKeyNames",
"getBackendKeyIndices",
"getModifiersByName",
"getModifiersByIndex"
])
# We want to make it so that we only have to
# import prefs.keymaps to get the right keymap
# Let's think about this some more! :)
print "Success!"
print " Contains these submodules: %s"%(", ".join(__all__))
print "Importing %s..."%(__name__),
import os.path
from main import determine_package,export_symbols
import Drivers
path = os.path.abspath(__file__)
dir_path = os.path.dirname(path)
__all__=determine_package(dir_path)
export_symbols(Drivers.getMainDriver().settings.get("default_fonts","%s.default" %(__name__)),
globals(),
locals(),
[
"loadDefaultFonts"
])
# We want to make it so that we only have to
# import prefs.keymaps to get the right keymap
# Let's think about this some more! :)
print "Success!"
print " Contains these submodules: %s"%(", ".join(__all__))
# l1.insert(1, 99)
# print(dir(l1))
# # print(l1)
# a = iter(l1)
print(l1)
# l1.save()
# print(d1)
# print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
# l1.clear()
# l1.load(d1)
# print(l1)
# driver_name = input("Please enter driver name > ")
builder = Drivers.SDFabric().get_sd_driver("JSONFileDriver")
sd = builder.build()
#
l1.set_structure_driver(sd)
l1.save()
# l1.load()
print(l1)
# print(next(l1.__iter__()))
# print(next(l1.__iter__()))
# obj = {
# "a": [
# {
# "a": 1,
# "b": True,
# "c": "some string"
outfile.write("\n")
#writeText(Drivers.driverSetup("Daanedwin", 7, 5, False))
#readText("Data.txt")
def readJson(filename):
data = []
with open(filename, "r") as infile:
for lines in infile:
data.append(lines)
return data
def writeJson(data, files):
if files == "Driver":
with open("Driver.json", "a") as outfile:
data = json.dumps(data)
json.dump(data, outfile, indent=2)
elif files == "Constructor":
with open("Constructor.json") as outfile:
pass
else:
print("Invalid file")
writeJson(Drivers.driverSetup("Daanedwin", 7, 5, False), "Driver")
s = (readJson("Driver.json"))
print(s[0])
def main():
#parse command line arguments
parser = argparse.ArgumentParser(description='Initialize autoturret.')
parser.add_argument('target_class',
type=str,
help='Pick a target class from the list')
#parser.add_argument('pin_file', type=str, help='file path to file containing pin info')
parser.add_argument(
'--fire',
action='store_true',
default=False,
help='just track target instead of automatically firing',
dest='fire')
parser.add_argument('--showStream',
action='store_true',
default=False,
help="if you want to see it work.q")
results = parser.parse_args()
USER_TARGET = results.target_class
PIN_FILEPATH = 'pin_loc.txt' #results.pin_file
FIRE = results.fire
SHOW_STREAM = results.showStream
ACTIVE = True
#import from file global constant pin locations
pin_dict = Utils.parse_pinfile(PIN_FILEPATH)
#initialize drivers
print('Initializing Drivers....')
m1 = Drivers.Motor1(pin_dict['M1A1'], pin_dict['M1A2'], pin_dict['M1B1'],
pin_dict['M1B2'])
m2 = Drivers.Motor2(enable=pin_dict['en2'],
direction=pin_dict['dirpin2'],
pulse=pin_dict['pul2'])
launcher = Drivers.Launcher(pin_dict['WaterPin'], pin_dict['AirPin'], 1,
.4)
#initialize interface
print("Setting up interface...")
control = Interface.CannonControl(m1, m2, launcher)
# import the correct version of tensorflow based on whats installed and define and interpreter
# from on the .tflite file
if importlib.util.find_spec('tflite_runtime'):
import tflite_runtime.interpreter as tflite
interpreter = tflite.Interpreter(model_path='model/detect.tflite')
else:
import tensorflow as tf
interpreter = tf.lite.Interpreter(model_path='model/detect.tflite')
interpreter.allocate_tensors()
#load labels
with open('model/labelmap.txt', 'r') as f:
labels = [line.strip() for line in f.readlines()]
#initialize detection model
print("Starting detection model...")
model = Detection.TargetStream(USER_TARGET, interpreter)
model.start()
time.sleep(2)
print("Model ready...")
#define autotarget functionality
#toss that in a loop. consiter using threads
while ACTIVE:
if SHOW_STREAM:
model.show_frame()
if model.object_detected:
location = model.target_location
h, v, dist = Utils.auto_target((location))
Utils.move(h, v, dist, control, 3)
time.sleep(1)
import TraceParser
import Cache
import Drivers
prob = Drivers.Driver()
prob.runWT("./traces/cc.trace")
prob.runWT("./traces/spice.trace")
prob.runWT("./traces/tex.trace")
prob.runWB("./traces/cc.trace")
prob.runWB("./traces/spice.trace")
prob.runWB("./traces/tex.trace")
prob.done()
"""
