예제 #1
0
 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()
예제 #2
0
    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)
예제 #3
0
    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)
예제 #4
0
 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
예제 #5
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
예제 #6
0
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
예제 #7
0
 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()
예제 #8
0
    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()
예제 #9
0
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__))
예제 #10
0
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__))
예제 #11
0
    # 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"
예제 #12
0
        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])
예제 #13
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)
예제 #14
0
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()
"""