예제 #1
0
    def __init__(self, *args, **kw):
        dealGenericOptions()
        super(buildCommand, self).__init__(*args, **kw)

        self.parser.insert_option_group(0, self.cmd_opts)

        index_opts = cmdoptions.make_option_group(
            cmdoptions.index_group,
            self.parser,
        )
        self.serial = SerialUtils()
        self.parser.insert_option_group(0, index_opts)
        self.srcfile = []
        self.headers = ""
        self.headerlist = []
        self.buildParm = ""
        self.gcc = ""
        self.cpp = ""
        self.objcopy = ""
        self.sizetool = ""
        self.ld = ""
        self.board_id = -1
        self.gcc_cmd = ""
        self.cpp_cmd = ""
        self.objcopy_cmd = ""
        self.sizetool_cmd = ""
        self.ld_cmd = ""
        self._verbose = False
예제 #2
0
    def __init__(self, *args, **kw):
        dealGenericOptions()
        super(flashCommand, self).__init__(*args, **kw)
        self.cmd_opts.add_option('-p',
                                 '--port',
                                 dest='port',
                                 action='store',
                                 default="",
                                 help='The port of the ArduPy board.')

        self.cmd_opts.add_option('-o',
                                 '--origin',
                                 dest='origin',
                                 action='store_true',
                                 default=False,
                                 help='flash latest version firmware')

        self.parser.insert_option_group(0, self.cmd_opts)
        self.serial = SerialUtils()
        self.port = ""
예제 #3
0
    def run(self, options, args):

        ser = SerialUtils()

        if options.scan:
            if options.desc == "":
                print(ser.listAvailableBoard())
            else:
                print(ser.listDesignatedBoard(options.desc))
            return SUCCESS

        if options.list == True:
            print(ser.listBoard())
            return SUCCESS

        if options.port == "":
            port, desc, hwid, isbootloader = ser.getAvailableBoard()
        else:
            port = options.port

        if port == None:
            log.error("Sorry, the device you should have is not plugged in.")
            return ERROR

        try:
            if options.baudrate != "":
                baudrate = int(options.baudrate)
            else:
                baudrate = 115200

            self.serial = serial.Serial(port,
                                        baudrate=baudrate,
                                        interCharTimeout=1)

            print(self.get_version())
        except Exception as e:
            log.error(e)
            return ERROR

        return SUCCESS
예제 #4
0
    def run(self, options, args):

        if options.list == True:
            ser = SerialUtils()
            print(ser.listBoard())
            return SUCCESS

        if 'clean' in args:
            self.clean()
            return SUCCESS

        if options.board != "":
            self.board = options.board

        session = self.get_default_session(options)

        # setup deploy dir
        deploydir = str(Path(user_config_dir, "deploy"))
        if not os.path.exists(deploydir):
            os.makedirs(deploydir)
        # create build dir, This folder will be deleted after compilation
        builddir = mktemp()
        os.makedirs(builddir)

        self.downloadAll(session)
        self.get_arduinocore_version()
        # Converts the header file to the absolute path of the current system
        for h in ardupycore_headers:
            # add Arduino Core version
            if h[0:35] == "/ardupycore/Seeeduino/hardware/samd":
                h = h.format(self.arduinoCoreVersion)
            self.headerlist.append(str(Path(user_config_dir + h)))
        self.headerlist.append(
            str(Path(user_config_dir + board_headers + self.board)))

        # setup ardupy modules dir
        moduledir = str(Path(user_config_dir, "modules"))
        if not os.path.exists(moduledir):
            os.makedirs(moduledir)
        modules = os.listdir(moduledir)
        if modules:
            for m in modules:
                # Gets the source files for all modules
                for f in self.fileEndWith(
                        os.path.join(user_config_dir + "/modules/", m), '.cpp',
                        '.c'):
                    self.srcfile.append(str(Path(f)))
                # Sets the root directory of the module to be where the header file is found
                for r, d, f in os.walk(
                        str(Path(user_config_dir + "/modules/" + m))):
                    if r.find('.git') == -1 and r.find("examples") == -1:
                        self.headerlist.append(r)

        # Convert the necessary files in ardupycore into the absolute path of the system.
        for mp_file in mp_needful_file:
            self.srcfile.append(str(Path(user_config_dir + mp_file)))

        self.generatedInitfile(builddir)

        # Convert to the required format for GCC
        self.generatedQstrdefs(builddir)
        self.headers = "-I" + " -I".join(self.headerlist)

        # Compile all source files
        self.buildFarm(builddir)

        firmware_path = str(Path(str(deploydir) + "/Ardupy.bin"))

        #remove the old firmware
        if os.path.exists(firmware_path):
            os.remove(firmware_path)

        # Convert ELF files to binary files
        objcopy_cmd = str(Path(user_config_dir + gcc_48_objcopy)) + "-O binary " \
            + str(Path(builddir + "/Ardupy")) + " " \
            + firmware_path

        log.debug(objcopy_cmd)
        os.system(objcopy_cmd)

        # Print size information
        os.system(
            str(Path(user_config_dir + gcc_48_size)) + " -A " +
            str(Path(builddir + "/Ardupy")))

        # delete build dir
        shutil.rmtree(builddir)

        if os.path.exists(firmware_path):
            log.info('Firmware path: ' + firmware_path)
            log.info('Usage:\n\r    aip flash')
        else:
            raise Exception(print('compile error'))
            #return ERRO

        return SUCCESS
예제 #5
0
class buildCommand(RequirementCommand):
    """
    Build ArduPy Firmware contains the libraries you installed and the basic ArduPy features.
    """
    name = 'build'
    usage = """
      %prog [options] <args> ..."""
    summary = "Build ArduPy Firmware contains the libraries you installed and the basic ArduPy features."
    ignore_require_venv = True

    def __init__(self, *args, **kw):
        dealGenericOptions()
        super(buildCommand, self).__init__(*args, **kw)

        self.parser.insert_option_group(0, self.cmd_opts)

        index_opts = cmdoptions.make_option_group(
            cmdoptions.index_group,
            self.parser,
        )
        self.serial = SerialUtils()
        self.parser.insert_option_group(0, index_opts)
        self.srcfile = []
        self.headers = ""
        self.headerlist = []
        self.buildParm = ""
        self.gcc = ""
        self.cpp = ""
        self.objcopy = ""
        self.sizetool = ""
        self.ld = ""
        self.board_id = -1
        self.gcc_cmd = ""
        self.cpp_cmd = ""
        self.objcopy_cmd = ""
        self.sizetool_cmd = ""
        self.ld_cmd = ""
        self._verbose = False

    def doVerbose(self, info):
        if self.verbose == True:
            print(info)
        else:
            sys.stdout.write(".....")
            sys.stdout.flush()

    # get arm gcc

    def initBoard(self):
        self.buildParm = parser.get_build_pram_by_id(self.board_id)
        buildParm = self.buildParm
        self.gcc = str(
            Path(parser.get_tool_dir_by_id(self.board_id), buildParm['tool'],
                 buildParm['version'], "bin", buildParm['CC']))
        self.cpp = str(
            Path(parser.get_tool_dir_by_id(self.board_id), buildParm['tool'],
                 buildParm['version'], "bin", buildParm['CXX']))
        self.objcopy = str(
            Path(parser.get_tool_dir_by_id(self.board_id), buildParm['tool'],
                 buildParm['version'], "bin", buildParm['OBJCOPY']))
        self.sizetool = str(
            Path(parser.get_tool_dir_by_id(self.board_id), buildParm['tool'],
                 buildParm['version'], "bin", buildParm['SIZETOOL']))
        self.buildParm = parser.get_build_pram_by_id(self.board_id)

    # build firmware
    def buildFirmware(self, outputdir):
        buildParm = self.buildParm
        product = parser.boards[self.board_id]["name"]
        pid = parser.boards[self.board_id]["hwids"]["application"][0]
        vid = parser.boards[self.board_id]["hwids"]["application"][1]
        common_flags = " " + buildParm["CFLAGS"] + " " + parser.boards[
            self.
            board_id]["BOARDFLAGS"] + " " + buildParm["ARDUINOCFLAGS"].format(
                arduinocore=parser.get_arduino_dir_by_id(self.board_id)
            ) + " " + buildParm["USBFLAGS"].format(
                product, pid, vid) + " " + buildParm["TOOLCFLAGS"].format(
                    parser.get_tool_dir_by_id(
                        self.board_id)) + " " + buildParm["EXTRACFLAGS"]
        gcc_flags = common_flags + " " + buildParm["CCFLAGS"]
        cpp_flags = common_flags + " " + buildParm["CXXFLAGS"]
        output_str = " -o {0}   -c {1}"
        self.gcc_cmd = self.gcc + " " + gcc_flags + \
            " " + self.headers + " " + output_str
        self.cpp_cmd = self.cpp + " " + cpp_flags + \
            " " + self.headers + " " + output_str
        output_o = []
        # build all of source file
        for f in self.srcfile:
            randomstr = "".join(random.sample('zyxwvutsrqponmlkjihgfedcba', 8))
            #out = randomstr + os.path.basename(f)+".o"
            out = os.path.join(outputdir,
                               randomstr + os.path.basename(f) + ".o")
            (path, filename) = os.path.split(f)
            if filename[-2:] == ".c":
                cmd = self.gcc_cmd.format(out, f)
                self.doVerbose(cmd)
                output_o.append(out)
                os.system(cmd)
            else:
                cmd = self.cpp_cmd.format(out, f)
                self.doVerbose(cmd)
                output_o.append(out)
                os.system(cmd)

        self.ld_cmd = self.gcc + " -L{0} ".format(
            parser.get_ardupy_board_by_id(self.board_id)
        ) + " " + buildParm["TOOLLDFLAGS"].format(
            parser.get_tool_dir_by_id(self.board_id)) + " " + buildParm[
                "EXTRALDFLAGS"] + " " + buildParm["LINKFLAGS"].format(
                    parser.get_ardupy_board_by_id(self.board_id),
                    " ".join(output_o), outputdir)
        self.doVerbose(self.ld_cmd)
        os.system(self.ld_cmd)

    def endWith(self, s, *endstring):
        array = map(s.endswith, endstring)
        if True in array:
            return True
        else:
            return False

    def fileEndWith(self, p, *endstring):
        all_file = []
        wants_files = []

        for r, d, f in os.walk(p):
            if r.find('.git') == -1:
                for item in f:
                    all_file.append(os.path.join(r, item))
        for i in all_file:
            if self.endWith(i, endstring):
                wants_files.append(i)
        return wants_files

    # generated Init file
    def generatedInitfile(self, outputdir):

        init_header = """
#include <stdint.h>

#include "py/obj.h"
#include "py/runtime.h"

        """
        fix_body = """

STATIC const mp_rom_map_elem_t arduino_module_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR___name__),                          MP_ROM_QSTR(MP_QSTR_arduino) },
        """
        init_tail = """
};

STATIC MP_DEFINE_CONST_DICT(arduino_module_globals, arduino_module_globals_table);

const mp_obj_module_t mp_module_arduino = {
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t*)&arduino_module_globals,
};        
        """
        mp_obj_type_string = []

        for ff in self.srcfile:
            (path, filename) = os.path.split(ff)
            if filename[0:11] == "mod_ardupy_":
                with open(ff, 'r') as f:
                    mp_obj_type_string.append(''.join([
                        line for line in f.readlines()
                        if re.match(r'const mp_obj_type_t ', line)
                    ])[20:-5])

        initFile = open(str(Path(outputdir, "__init__.c")), "w")
        initFile.write(init_header)
        for ss in mp_obj_type_string:
            initFile.write("extern const mp_obj_type_t  {};\n\t".format(ss))

        initFile.write(fix_body)
        for ss in mp_obj_type_string:
            initFile.write(
                '{{ MP_ROM_QSTR(MP_QSTR_{0}),                         MP_ROM_PTR(&{1}) }},\n\t'
                .format(ss[:-5], ss))
        initFile.write(init_tail)
        initFile.close()
        # os.system("cat "+str(Path(outputdir,"__init__.c")))
        self.srcfile.append(str(Path(outputdir, "__init__.c")))

    def generatedQstrdefs(self, outputdir):
        ardupydir = parser.get_ardupy_dir_by_id(self.board_id)
        sys.path.append(str(Path(ardupydir, "MicroPython", "py")))
        # import makemoduledefs
        import makeqstrdata
        import makeqstrdefs
        # import makeversionhdr
        genhdr = str(Path(outputdir + "/genhdr"))
        os.makedirs(genhdr)
        extern_mp_src = []

        # makeversionhdr.make_version_header(str(Path(genhdr,"mpversion.h")))
        shutil.copyfile(
            str(Path(parser.get_gender_dir_by_id(self.board_id),
                     "mpversion.h")), str(Path(genhdr, "mpversion.h")))
        shutil.copyfile(
            str(
                Path(parser.get_gender_dir_by_id(self.board_id),
                     "moduledefs.h")), str(Path(genhdr, "moduledefs.h")))

        mp_generate_flag = " -I. -I{0} -I{1}".format(
            parser.get_ardupy_dir_by_id(self.board_id),
            parser.get_ardupy_board_by_id(self.board_id))

        buildParm = self.buildParm
        micropython_CFLAGS = buildParm["MICROPYTHONCFLAGS"].format(
            parser.get_ardupy_dir_by_id(self.board_id))

        mp_generate_flag = " {} {} ".format(mp_generate_flag,
                                            micropython_CFLAGS)

        # remove cpp files
        # todo; only scan file start wirh "mod_ardupy_"
        for f in self.srcfile:
            if f[-3:] == "cpp" or f[-2:] == "cc":
                continue
            if f.find("objmodule.c") != -1 or \
                f.find("parse.c") != -1 or \
                    f.find("qstr.c") != -1:
                continue
            extern_mp_src.append(f)
        self.doVerbose(extern_mp_src)
        gen_i_last = self.gcc + " -E -DARDUPY_MODULE -DNO_QSTR " + mp_generate_flag + " ".join(extern_mp_src) + \
            "  " + str(Path(parser.get_ardupy_dir_by_id(self.board_id), "mpconfigport.h")) + \
            " > " + str(Path(genhdr, "qstr.i.last"))
        self.doVerbose(gen_i_last)
        os.system(gen_i_last)

        import io

        class Args:
            pass

        args = Args()
        args.input_filename = str(Path(genhdr, "qstr.i.last"))
        args.output_dir = str(Path(genhdr, "qstr"))
        args.output_file = str(Path(genhdr, "qstrdefs.collected.h"))
        try:
            os.makedirs(args.output_dir)
        except OSError:
            pass

        makeqstrdefs.args = args
        with io.open(args.input_filename, encoding='utf-8') as infile:
            makeqstrdefs.process_file(infile)

        makeqstrdefs.cat_together()
        qcfgs, qstrs = makeqstrdata.parse_input_headers([
            str(
                Path(parser.get_gender_dir_by_id(self.board_id),
                     "qstrdefs.preprocessed.h")),
            str(Path(genhdr, "qstrdefs.collected.h"))
        ])

        qstrdefs_generated_h = open(str(Path(genhdr, "qstrdefs.generated.h")),
                                    "w")

        # get config variables
        cfg_bytes_len = int(qcfgs['BYTES_IN_LEN'])
        cfg_bytes_hash = int(qcfgs['BYTES_IN_HASH'])

        # self.doVerbose out the starter of the generated C header file
        qstrdefs_generated_h.writelines(
            '// This file was automatically generated by makeqstrdata.py\n')
        qstrdefs_generated_h.writelines('\n')

        # add NULL qstr with no hash or data
        qstrdefs_generated_h.writelines(
            'QDEF(MP_QSTR_NULL, (const byte*)"%s%s" "")\n' %
            ('\\x00' * cfg_bytes_hash, '\\x00' * cfg_bytes_len))

        # go through each qstr and self.doVerbose it out
        for order, ident, qstr in sorted(qstrs.values(), key=lambda x: x[0]):
            qbytes = makeqstrdata.make_bytes(cfg_bytes_len, cfg_bytes_hash,
                                             qstr)
            qstrdefs_generated_h.writelines('QDEF(MP_QSTR_%s, %s)\n' %
                                            (ident, qbytes))
        qstrdefs_generated_h.close()

        # os.system("cp "+ str(Path(genhdr,"qstrdefs.generated.h"))+" /tmp")
        self.headerlist.append(str(Path(genhdr)))

        return genhdr

    def downloadAll(self, session):
        archiveFile = parser.get_archiveFile_by_id(self.board_id)
        downloader = Downloader(session, progress_bar="on")
        ardupycoredir = parser.get_core_dir_by_id(self.board_id)
        if not os.path.exists(ardupycoredir):
            log.info('Downloading ' + archiveFile['archiveFileName'] + '...')
            try:
                unpack_url(
                    Link(archiveFile['url']),
                    ardupycoredir,
                    downloader,
                    download_dir=None,
                )
            except Exception as e:
                log.error(e)
                os.remove(ardupycoredir)
                sys.exit(1)
            except Exception as e:
                log.error(e)
                os.remove(ardupycoredir)
                sys.exit(1)

        toolsDependencies = parser.get_toolsDependencies_url_by_id(
            self.board_id)
        toolsdir = parser.get_tool_dir_by_id(self.board_id)
        for tool in toolsDependencies:
            tooldir = str(Path(toolsdir, tool['name'], tool['version']))
            if not os.path.exists(tooldir):
                log.info('Downloading ' + tool['name'] + '@' +
                         tool['version'] + '...')
                try:
                    unpack_url(
                        Link(tool['url']),
                        tooldir,
                        downloader,
                        download_dir=None,
                    )
                except Exception as e:
                    log.error(e)
                    os.remove(tooldir)
                    sys.exit(1)

    def run(self, options, args):

        if options.board == "":
            port, desc, hwid, isbootloader = self.serial.getAvailableBoard()
            if port != None:
                _board = self.serial.getBoardByPort(port)
                if _board != "":
                    self.board = _board[0]
            else:
                log.warning(
                    "please plug in a ArduPy Board or specify the board to build!"
                )
                print("<usage>    aip build [--board=<board>] ")
                return
        else:
            self.board = options.board

        self.board_id = self.serial.getBoardIdByName(self.board)

        if self.board_id == -1:
            log.error("Unable to find information about '" + self.board + "'")
            return ERROR

        self.verbose = options.verbose

        self.initBoard()
        seesion = self.get_default_session(options)
        self.downloadAll(seesion)

        # setup deploy dir
        deploydir = parser.get_deploy_dir_by_id(self.board_id)

        if not os.path.exists(deploydir):
            os.makedirs(deploydir)
        # create build dir, This folder will be deleted after compilation
        builddir = mktemp()
        os.makedirs(builddir)

        log.info("|---------------" + " Building Firmware for " + self.board +
                 "---------------|")

        arduinodir = parser.get_arduino_dir_by_id(self.board_id)
        arduinocoredir = str(Path(arduinodir, "cores", "arduino"))

        # Converts the header file to the absolute path of the current system
        # 1 append Arduino Core PATH
        self.headerlist.append(arduinocoredir)
        for file in os.listdir(arduinocoredir):
            file_path = str(Path(arduinocoredir, file))
            if os.path.isdir(file_path):
                self.headerlist.append(file_path)

        # 2 append Arduino variants PATH
        self.headerlist.append(parser.get_variant_dir_by_id(self.board_id))

        # 3 append Arduino library PATH
        librariesdir = str(Path(arduinodir, "libraries"))

        for library in os.listdir(librariesdir):
            library_path = str(Path(librariesdir, library))
            self.headerlist.append(library_path)
            if (os.path.exists(str(Path(library_path, "src")))):
                self.headerlist.append(str(Path(library_path, "src")))

        # 4 append Ardupy core PATH
        self.headerlist.append(parser.get_ardupy_dir_by_id(self.board_id))
        self.headerlist.append(parser.get_ardupy_board_by_id(self.board_id))
        self.headerlist.append(
            str(Path(parser.get_ardupy_dir_by_id(self.board_id),
                     "MicroPython")))

        # 5 append moudules PATh
        moduledir = str(Path(parser.user_config_dir, "modules"))
        if not os.path.exists(moduledir):
            os.makedirs(moduledir)
        modules = os.listdir(moduledir)
        if modules:
            for m in modules:
                # Gets the source files for all modules
                for f in self.fileEndWith(
                        os.path.join(str(Path(moduledir, m))), '.cpp', '.c'):
                    self.srcfile.append(str(Path(f)))
                # Sets the root directory of the module to be where the header file is found
                for r, d, f in os.walk(str(Path(moduledir, m))):
                    if r.find('.git') == -1 and r.find("examples") == -1:
                        self.headerlist.append(r)

        # 6 Convert the necessary files in ardupycore into the absolute path of the system.
        self.srcfile.append(
            str(
                Path(parser.get_ardupy_dir_by_id(self.board_id), "MicroPython",
                     "py", "objmodule.c")))
        self.srcfile.append(
            str(
                Path(parser.get_ardupy_dir_by_id(self.board_id), "MicroPython",
                     "py", "parse.c")))
        self.srcfile.append(
            str(
                Path(parser.get_ardupy_dir_by_id(self.board_id), "MicroPython",
                     "py", "qstr.c")))

        # 7 generatrd Init file for binding
        self.generatedInitfile(builddir)

        # 8 Convert to the required format for GCC
        self.generatedQstrdefs(builddir)

        # 9 append build temp dir
        self.headerlist.append(str(Path(builddir)))

        # 10 inform headers headerlist
        self.headers = "-I" + " -I".join(self.headerlist)

        # 11 build firmware
        self.buildFirmware(builddir)

        # 12 remove the old firmware
        firmware_path = str(Path(str(deploydir), "Ardupy.bin"))
        if os.path.exists(firmware_path):
            os.remove(firmware_path)

        # 13 convert elf to bin
        self.objcopy_cmd = self.objcopy + " -O binary " \
            + str(Path(builddir + "/Ardupy")) + " " \
            + firmware_path

        self.doVerbose(self.objcopy_cmd)
        os.system(self.objcopy_cmd)

        # 14 print information
        self.sizetool_cmd = self.sizetool + \
            " -A " + str(Path(builddir + "/Ardupy"))
        print("")
        os.system(self.sizetool_cmd)

        # 15 print information
        # delete build dir
        shutil.rmtree(builddir)

        if os.path.exists(firmware_path):
            log.info('Firmware path: ' + firmware_path)
            log.info('Usage:\n\r    aip flash')
        else:
            raise Exception(print('compile error'))

        return SUCCESS
예제 #6
0
class flashCommand(RequirementCommand):
    """
    flash firmware to ArduPy board.
    """
    name = 'flash'
    usage = """
      %prog [options] <args> ..."""
    summary = "Flash firmware to ArduPy board."
    ignore_require_venv = True

    def __init__(self, *args, **kw):
        super(flashCommand, self).__init__(*args, **kw)
        self.cmd_opts.add_option('-p',
                                 '--port',
                                 dest='port',
                                 action='store',
                                 default="",
                                 help='The port of the ArduPy board.')

        self.cmd_opts.add_option('-o',
                                 '--origin',
                                 dest='origin',
                                 action='store_true',
                                 default=False,
                                 help='flash latest version firmware')

        self.parser.insert_option_group(0, self.cmd_opts)

        index_opts = cmdoptions.make_option_group(
            cmdoptions.index_group,
            self.parser,
        )

        self.serial = SerialUtils()

    @property
    def stty(self):

        if self.port == "":
            port, desc, hwid, isbootloader = self.serial.getAvailableBoard()
            self.port = port

        if self.port == "None":
            log.warning("please plug in a ArduPy Board!")
            print("<usage>    aip run [-p, --port=<port>] [local_file]")
            return "echo not support"

        if os.name == "posix":
            if platform.uname().system == "Darwin":
                return "stty -f " + self.port + " %d"
            return "stty -F " + self.port + " %d"
        elif os.name == "nt":
            return "MODE " + self.port + ":BAUD=%d PARITY=N DATA=8"

        return "echo not support"

    def run(self, options, args):

        self.port = options.port
        bossacdir = str(
            Path(user_config_dir + "/ardupycore/Seeeduino/tools/bossac"))

        if not os.path.exists(bossacdir):
            os.makedirs(bossacdir)
        session = self.get_default_session(options)

        if sys.platform == "linux":
            link = Link(
                "http://files.seeedstudio.com/arduino/tools/i686-linux-gnu/bossac-1.9.1-seeeduino-linux.tar.gz"
            )
        if sys.platform == "win32":
            link = Link(
                "http://files.seeedstudio.com/arduino/tools/i686-mingw32/bossac-1.9.1-seeeduino-windows.tar.bz2"
            )
        if sys.platform == "darwin":
            link = Link(
                "http://files.seeedstudio.com/arduino/tools/x86_64-apple-darwin/bossac-1.8-48-gb176eee-i386-apple-darwin16.1.0.tar.gz"
            )

        bossac = ""

        if platform.system() == "Windows":
            bossac = str(Path(bossacdir, "bossac.exe"))
        else:
            bossac = str(Path(bossacdir, "bossac"))

        if not os.path.exists(bossac):
            downloader = Downloader(session, progress_bar="on")
            unpack_url(
                link,
                bossacdir,
                downloader=downloader,
                download_dir=None,
            )

        try_count = 0
        do_bossac = True
        while True:
            stty = self.stty
            print(stty)
            if stty != "echo not support":
                os.system(stty % 1200)
            #os.system(str(bossac)+ " --help")
            port, desc, hwid, isbootloader = self.serial.getBootloaderBoard()
            print(port)
            time.sleep(1)
            if isbootloader == True:
                break
            try_count = try_count + 1
            if try_count == 5:
                do_bossac = False
                break

        if do_bossac == True:
            name, version, url = self.serial.getBoardByPort(port)
            ardupybin = ""
            if len(args) > 0:
                ardupybin = args[0]
                if not os.path.exists(ardupybin):
                    log.warning('The path of firmware didn\'t exists!')
                    return ERROR
            elif options.origin == True:
                firmwaredir = str(
                    Path(user_config_dir + "/deploy/firmware/" +
                         name.replace(' ', '_')))
                if not os.path.exists(firmwaredir):
                    os.makedirs(firmwaredir)
                ardupybin = str(Path(firmwaredir, "ardupy_laster.bin"))
                if not os.path.exists(ardupybin):
                    downloader = Downloader(session, progress_bar="on")
                    _download_http_url(link=Link(url),
                                       downloader=downloader,
                                       temp_dir=firmwaredir,
                                       hashes=None)
            else:
                ardupybin = str(Path(user_config_dir + "/deploy/Ardupy.bin"))

            _flash_parm = flash_param[name.replace(' ', '_')]
            print((str(bossac) + _flash_parm) % (port, ardupybin))
            os.system((str(bossac) + _flash_parm) % (port, ardupybin))
        else:
            log.warning("Sorry, the device you should have is not plugged in.")
            return ERROR

        return SUCCESS
예제 #7
0
class flashCommand(Command):
    """
    flash firmware to ArduPy board.
    """
    name = 'flash'
    usage = """
      %prog [options] <args> ..."""
    summary = "Flash firmware to ArduPy board."
    ignore_require_venv = True

    def __init__(self, *args, **kw):
        dealGenericOptions()
        super(flashCommand, self).__init__(*args, **kw)
        self.cmd_opts.add_option('-p',
                                 '--port',
                                 dest='port',
                                 action='store',
                                 default="",
                                 help='The port of the ArduPy board.')

        self.cmd_opts.add_option('-o',
                                 '--origin',
                                 dest='origin',
                                 action='store_true',
                                 default=False,
                                 help='flash latest version firmware')

        self.parser.insert_option_group(0, self.cmd_opts)
        self.serial = SerialUtils()
        self.port = ""

    @property
    def stty(self):

        if self.port == "":
            port, desc, hwid, isbootloader = self.serial.getAvailableBoard()
            self.port = port

        if self.port == "None":
            log.warning("please plug in a ArduPy Board!")
            print("<usage>    aip run [-p, --port=<port>] [local_file]")
            return "echo not support"

        if os.name == "posix":
            if platform.uname().system == "Darwin":
                return "stty -f " + self.port + " %d"
            return "stty -F " + self.port + " %d"
        elif os.name == "nt":
            return "MODE " + self.port + ":BAUD=%d PARITY=N DATA=8"

        return "echo not support"

    def run(self, options, args):

        if options.port == "":
            port, desc, hwid, isbootloader = self.serial.getAvailableBoard()
            self.port = port
        else:
            port = options.port

        if port == None:
            log.error("Sorry, the device you should have is not plugged in.")
            return ERROR

        board_id = self.serial.getBoardIdByPort(self.port)
        if parser.get_flash_isTouch_by_id(board_id):
            try_count = 0
            do_bossac = True
            while True:
                stty = self.stty
                print(stty)
                if stty != "echo not support":
                    os.system(stty % 1200)
                #os.system(str(bossac)+ " --help")
                time.sleep(1)
                port, desc, hwid, isbootloader = self.serial.getBootloaderBoard(
                )
                if isbootloader == True:
                    self.port = port
                    break
                try_count = try_count + 1
                if port == None:
                    continue
                if try_count == 5:
                    do_bossac = False
                break

            if do_bossac == True:
                flash_tools = parser.get_flash_tool_by_id(board_id)
                #print(flash_tools)
                if len(args) != 0:
                    ardupybin = args[0]
                else:
                    ardupybin = str(
                        Path(parser.get_deploy_dir_by_id(board_id),
                             "Ardupy.bin"))
                flash_command = parser.get_flash_command_by_id(
                    board_id, self.port, ardupybin)
                print(flash_tools + "/" + flash_command)
                os.system(flash_tools + "/" + flash_command)
            else:
                log.warning(
                    "Sorry, the device you should have is not plugged in.")
                return ERROR
        else:
            flash_tools = parser.get_flash_tool_by_id(board_id)
            ardupybin = ""
            if len(args) != 0:
                ardupybin = args[0]
            else:
                ardupybin = str(
                    Path(parser.get_deploy_dir_by_id(board_id), "Ardupy.bin"))
            flash_command = parser.get_flash_command_by_id(
                board_id, self.port, ardupybin)
            print(flash_tools + "/" + flash_command)
            os.system(flash_tools + "/" + flash_command)
        return SUCCESS
예제 #8
0
    def run(self, options, args):
        
        if len(args) >= 1:
            board = args[0]
        else:
            board = None  

        ser = SerialUtils()
        if options.port == "":
            if board == None:
                board, desc, hwid, isbootloader = ser.getAvailableBoard()
        else:
            board = options.port

        format = "%(asctime)s\t%(levelname)s\t%(message)s"

        if options.logfile is not None:
            logging.basicConfig(format=format, filename=options.logfile, level=options.loglevel)
        else:
            logging.basicConfig(format=format, level=logging.CRITICAL)
        
        mpfs = mpf.MpFileShell(not options.nocolor, not options.nocache, options.reset, options.nohelp)

        if options.open is not None:
            if board is None:
                if not mpfs.do_open(options.open):
                    return ERROR
        else:
            print(
                "Positional argument ({}) takes precedence over --open.".format(
                    board
                )
            )
        if board is not None:
            mpfs.do_open(board)

        if options.command is not None:
            for acmd in "".join(options.command).split(";"):
                scmd = acmd.strip()
                if len(scmd) > 0 and not scmd.startswith("#"):
                    mpfs.onecmd(scmd)

        elif options.script is not None:

            f = open(options.script, "r")
            script = ""

            for line in f:

                sline = line.strip()

                if len(sline) > 0 and not sline.startswith("#"):
                    script += sline + "\n"

            if sys.version_info < (3, 0):
                sys.stdin = io.StringIO(script.decode("utf-8"))
            else:
                sys.stdin = io.StringIO(script)

            mpfs.intro = ""
            mpfs.prompt = ""

        if not options.noninteractive:

            try:
                mpfs.cmdloop()
            except KeyboardInterrupt:
                print("")
                
        return SUCCESS