def _copy_files(self, example, src_path, dest_path, sayno):
click.secho('Copying ' + example + ' example files ...')
example_files = glob.glob(util.safe_join(src_path, '*'))
for f in example_files:
filename = basename(f)
if filename != 'info':
filepath = util.safe_join(dest_path, filename)
if isfile(filepath):
# -- If sayno, do not copy the file. Move to the next
if sayno:
continue
click.secho(
'Warning: ' + filename + ' file already exists',
fg='yellow')
if click.confirm('Do you want to replace it?'):
shutil.copy(f, dest_path)
elif isdir(filepath):
click.secho(
'Warning: ' + filename + ' is already a directory',
fg='yellow')
return
else:
shutil.copy(f, filepath)
click.secho(
'Example files \'{}\' have been successfully created!'.format(
example
), fg='green')
def copy_example_dir(self, example, project_dir, sayno):
if util.check_package(self.name, self.version, self.spec_version,
self.examples_dir):
project_dir = util.check_dir(project_dir)
example_path = util.safe_join(project_dir, example)
local_example_path = util.safe_join(self.examples_dir, example)
if isdir(local_example_path):
if isdir(example_path):
# -- If sayno, do not copy anything
if not sayno:
click.secho('Warning: ' + example +
' directory already exists',
fg='yellow')
if click.confirm('Do you want to replace it?'):
shutil.rmtree(example_path)
self._copy_dir(example, local_example_path,
example_path)
elif isfile(example_path):
click.secho('Warning: ' + example + ' is already a file',
fg='yellow')
else:
self._copy_dir(example, local_example_path, example_path)
else:
click.secho(EXAMPLE_NOT_FOUND_MSG, fg='yellow')
else:
return 1
return 0
def list_examples(self):
if util.check_package(
self.name,
self.version,
self.spec_version,
self.examples_dir
):
# examples = sorted(os.listdir(self.examples_dir))
examples = [dirname(y).replace(self.examples_dir + sep, '')
for x in os.walk(self.examples_dir)
for y in glob.glob(util.safe_join(x[0], 'info'))]
click.secho('')
for example in examples:
example_dir = util.safe_join(self.examples_dir, example)
if isdir(example_dir):
info_path = util.safe_join(example_dir, 'info')
info = ''
if isfile(info_path):
with codecs.open(info_path, 'r', 'utf-8') as info_file:
info = info_file.read().replace('\n', '')
click.secho(' ' + example, fg='blue', bold=True)
click.secho('-' * click.get_terminal_size()[0])
click.secho(' ' + info)
click.secho('')
click.secho(EXAMPLE_DIR_FILE, fg='green')
click.secho(EXAMPLE_OF_USE_CAD, fg='green')
else:
return 1
return 0
def copy_example_dir(self, example, project_dir, sayno):
if util.check_package(
self.name,
self.version,
self.spec_version,
self.examples_dir
):
project_dir = util.check_dir(project_dir)
example_path = util.safe_join(project_dir, example)
local_example_path = util.safe_join(self.examples_dir, example)
if isdir(local_example_path):
if isdir(example_path):
# -- If sayno, do not copy anything
if not sayno:
click.secho(
'Warning: ' + example +
' directory already exists', fg='yellow')
if click.confirm('Do you want to replace it?'):
shutil.rmtree(example_path)
self._copy_dir(example, local_example_path,
example_path)
elif isfile(example_path):
click.secho(
'Warning: ' + example + ' is already a file',
fg='yellow')
else:
self._copy_dir(example, local_example_path, example_path)
else:
click.secho(EXAMPLE_NOT_FOUND_MSG, fg='yellow')
else:
return 1
return 0
def _serial_enable_windows(self):
drivers_base_dir = util.get_package_dir('tools-drivers')
drivers_bin_dir = util.safe_join(drivers_base_dir, 'bin')
try:
if util.check_package(
self.name,
self.version,
self.spec_version,
drivers_bin_dir
):
click.secho('Launch drivers configuration tool')
click.secho(SERIAL_INSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
result = util.exec_command(
util.safe_join(drivers_bin_dir, 'serial_install.exe'))
click.secho('Serial drivers configuration finished',
fg='green')
else:
result = 1
except Exception as e:
click.secho('Error: ' + str(e), fg='red')
result = 1
if not isinstance(result, int):
result = result.get('returncode')
return result
def list_examples(self):
if util.check_package(self.name, self.version, self.spec_version,
self.examples_dir):
# examples = sorted(os.listdir(self.examples_dir))
examples = [
dirname(y).replace(self.examples_dir + sep, '')
for x in os.walk(self.examples_dir)
for y in glob.glob(util.safe_join(x[0], 'info'))
]
click.secho('')
for example in examples:
example_dir = util.safe_join(self.examples_dir, example)
if isdir(example_dir):
info_path = util.safe_join(example_dir, 'info')
info = ''
if isfile(info_path):
with codecs.open(info_path, 'r', 'utf-8') as info_file:
info = info_file.read().replace('\n', '')
click.secho(' ' + example, fg='blue', bold=True)
click.secho('-' * click.get_terminal_size()[0])
click.secho(' ' + info)
click.secho('')
click.secho(EXAMPLE_DIR_FILE, fg='green')
click.secho(EXAMPLE_OF_USE_CAD, fg='green')
else:
return 1
return 0
def run(self, command, variables=[], board=None, packages=[]):
"""Executes scons for building"""
# -- Check for the SConstruct file
if not isfile(util.safe_join(util.get_project_dir(), 'SConstruct')):
variables += ['-f']
variables += [util.safe_join(
util.get_folder('resources'), 'SConstruct')]
else:
click.secho('Info: use custom SConstruct file')
# -- Resolve packages
if self.profile.check_exe_default():
# Run on `default` config mode
if not util.resolve_packages(
packages,
self.profile.packages,
self.resources.distribution.get('packages')
):
# Exit if a package is not installed
raise Exception
else:
click.secho('Info: native config mode')
# -- Execute scons
return self._execute_scons(command, variables, board)
def _enable_windows(self):
drivers_base_dir = util.get_package_dir('tools-drivers')
drivers_bin_dir = util.safe_join(drivers_base_dir, 'bin')
drivers_share_dir = util.safe_join(drivers_base_dir, 'share')
zadig_ini_path = util.safe_join(drivers_share_dir, 'zadig.ini')
zadig_ini = 'zadig.ini'
try:
if isdir(drivers_bin_dir):
click.secho('Launch drivers configuration tool')
click.secho(FTDI_INSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
# Copy zadig.ini
with open(zadig_ini, 'w') as ini_file:
with open(zadig_ini_path, 'r') as local_ini_file:
ini_file.write(local_ini_file.read())
result = util.exec_command(
util.safe_join(drivers_bin_dir, 'zadig.exe'))
click.secho('FPGA drivers configuration finished', fg='green')
else:
util._check_package('drivers')
result = 1
except Exception as e:
click.secho('Error: ' + str(e), fg='red')
result = 1
finally:
# Remove zadig.ini
if isfile(zadig_ini):
os.remove(zadig_ini)
if not isinstance(result, int):
result = result['returncode']
return result
def _rename_unpacked_dir(self):
if self.uncompressed_name:
unpack_dir = util.safe_join(self.packages_dir,
self.uncompressed_name)
package_dir = util.safe_join(self.packages_dir, self.package_name)
if isdir(unpack_dir):
rename(unpack_dir, package_dir)
def create_sconstruct(self, project_dir='', sayyes=False):
"""Creates a default SConstruct file"""
project_dir = util.check_dir(project_dir)
sconstruct_name = 'SConstruct'
sconstruct_path = util.safe_join(project_dir, sconstruct_name)
local_sconstruct_path = util.safe_join(
util.get_folder('resources'), sconstruct_name)
if isfile(sconstruct_path):
# -- If sayyes, skip the question
if sayyes:
self._copy_sconstruct_file(sconstruct_name, sconstruct_path,
local_sconstruct_path)
else:
click.secho(
'Warning: {} file already exists'.format(sconstruct_name),
fg='yellow')
if click.confirm('Do you want to replace it?'):
self._copy_sconstruct_file(sconstruct_name,
sconstruct_path,
local_sconstruct_path)
else:
click.secho('Abort!', fg='red')
else:
self._copy_sconstruct_file(sconstruct_name, sconstruct_path,
local_sconstruct_path)
def run(self, command, variables=[], board=None, packages=[]):
"""Executes scons for building"""
# -- Check for the SConstruct file
if not isfile(util.safe_join(util.get_project_dir(), 'SConstruct')):
variables += ['-f']
variables += [
util.safe_join(util.get_folder('resources'), 'SConstruct')
]
else:
click.secho('Info: use custom SConstruct file')
# -- Resolve packages
if self.profile.check_exe_default():
# Run on `default` config mode
if not util.resolve_packages(
packages, self.profile.packages,
self.resources.distribution.get('packages')):
# Exit if a package is not installed
raise Exception
else:
click.secho('Info: native config mode')
# -- Execute scons
return self._execute_scons(command, variables, board)
def _copy_files(self, example, src_path, dest_path, sayno):
click.secho('Copying ' + example + ' example files ...')
example_files = glob.glob(util.safe_join(src_path, '*'))
for f in example_files:
filename = basename(f)
if filename != 'info':
filepath = util.safe_join(dest_path, filename)
if isfile(filepath):
# -- If sayno, do not copy the file. Move to the next
if sayno:
continue
click.secho('Warning: ' + filename +
' file already exists',
fg='yellow')
if click.confirm('Do you want to replace it?'):
shutil.copy(f, dest_path)
elif isdir(filepath):
click.secho('Warning: ' + filename +
' is already a directory',
fg='yellow')
return
else:
shutil.copy(f, filepath)
click.secho(
'Example files \'{}\' have been successfully created!'.format(
example),
fg='green')
def copy_example_dir(self, example, project_dir, sayno):
if isdir(self.examples_dir):
project_dir = util.check_dir(project_dir)
example_path = util.safe_join(project_dir, example)
local_example_path = util.safe_join(self.examples_dir, example)
if isdir(local_example_path):
if isdir(example_path):
# -- If sayno, do not copy anything
if not sayno:
click.secho('Warning: ' + example +
' directory already exists',
fg='yellow')
if click.confirm('Do you want to replace it?'):
shutil.rmtree(example_path)
self._copy_dir(example, local_example_path,
example_path)
elif isfile(example_path):
click.secho('Warning: ' + example + ' is already a file',
fg='yellow')
else:
self._copy_dir(example, local_example_path, example_path)
else:
click.secho(EXAMPLE_NOT_FOUND_MSG, fg='yellow')
else:
click.secho('Error: examples are not installed', fg='red')
click.secho('Please run:\n'
' apio install examples',
fg='yellow')
return 1
return 0
def _rename_unpacked_dir(self):
if self.uncompressed_name:
unpack_dir = util.safe_join(
self.packages_dir, self.uncompressed_name)
package_dir = util.safe_join(
self.packages_dir, self.package_name)
if isdir(unpack_dir):
rename(unpack_dir, package_dir)
def uninstall(self):
if isdir(util.safe_join(self.packages_dir, self.package_name)):
click.echo('Uninstalling %s package:' %
click.style(self.package, fg='cyan'))
shutil.rmtree(util.safe_join(self.packages_dir, self.package_name))
click.secho("""Package \'{}\' has been """
"""successfully uninstalled!""".format(self.package),
fg='green')
else:
util.show_package_path_error(self.package)
self.profile.remove_package(self.package)
self.profile.save()
def uninstall(self):
if isdir(util.safe_join(self.packages_dir, self.package_name)):
click.echo('Uninstalling %s package:' % click.style(
self.package, fg='cyan'))
shutil.rmtree(
util.safe_join(self.packages_dir, self.package_name))
click.secho(
"""Package \'{}\' has been """
"""successfully uninstalled!""".format(self.package),
fg='green')
else:
util.show_package_path_error(self.package)
self.profile.remove_package(self.package)
self.profile.save()
def _run(self, command):
result = {}
system_base_dir = util.get_package_dir('tools-system')
system_bin_dir = util.safe_join(system_base_dir, 'bin')
if isdir(system_bin_dir):
result = util.exec_command(util.safe_join(system_bin_dir,
command + self.ext),
stdout=util.AsyncPipe(self._on_run_out),
stderr=util.AsyncPipe(self._on_run_out))
else:
util._check_package('system')
return 1
return result
def create_ini(self, board, project_dir='', sayyes=False):
"""Creates a new apio project file"""
project_dir = util.check_dir(project_dir)
ini_path = util.safe_join(project_dir, PROJECT_FILENAME)
# Check board
boards = Resources().boards
if board not in boards.keys():
click.secho(
'Error: no such board \'{}\''.format(board),
fg='red')
sys.exit(1)
if isfile(ini_path):
# -- If sayyes, skip the question
if sayyes:
self._create_ini_file(board, ini_path, PROJECT_FILENAME)
else:
click.secho(
'Warning: {} file already exists'.format(PROJECT_FILENAME),
fg='yellow')
if click.confirm('Do you want to replace it?'):
self._create_ini_file(board, ini_path, PROJECT_FILENAME)
else:
click.secho('Abort!', fg='red')
else:
self._create_ini_file(board, ini_path, PROJECT_FILENAME)
def _run_command(self, command, silent=False):
result = {}
system_base_dir = util.get_package_dir('tools-system')
system_bin_dir = util.safe_join(system_base_dir, 'bin')
on_stdout = None if silent else self._on_stdout
on_stderr = self._on_stderr
if util.check_package(self.name, self.version, self.spec_version,
system_bin_dir):
result = util.exec_command(util.safe_join(system_bin_dir,
command + self.ext),
stdout=util.AsyncPipe(on_stdout),
stderr=util.AsyncPipe(on_stderr))
return result
def _load_resource(self, name):
resource = None
filepath = util.safe_join(util.get_folder('resources'), name + '.json')
with open(filepath, 'r') as f:
# Load the JSON file
resource = json.loads(f.read())
return resource
def _load_resource(self, name):
resource = None
filepath = util.safe_join(util.get_folder('resources'), name + '.json')
with open(filepath, 'r') as f:
# Load the JSON file
resource = json.loads(f.read())
return resource
def get_command(self, ctx, name):
ns = {}
fn = util.safe_join(commands_folder, name + '.py')
if isfile(fn):
with open(fn) as f:
code = compile(f.read(), fn, 'exec')
eval(code, ns, ns)
return ns.get('cli')
def __init__(self):
self.config = {'exe': 'default', 'verbose': 0}
self.labels = {'exe': 'Executable', 'verbose': 'Verbose'}
self.settings = {}
self.packages = {}
self._profile_path = util.safe_join(util.get_home_dir(),
'profile.json')
self.load()
def get_command(self, ctx, name):
ns = {}
fn = util.safe_join(commands_folder, name + '.py')
if isfile(fn):
with open(fn) as f:
code = compile(f.read(), fn, 'exec')
eval(code, ns, ns)
return ns.get('cli')
def _install_package(self, dlpath):
if dlpath:
package_dir = util.safe_join(self.packages_dir, self.package_name)
if isdir(package_dir):
shutil.rmtree(package_dir)
if self.uncompressed_name:
self._unpack(dlpath, self.packages_dir)
else:
self._unpack(
dlpath, util.safe_join(self.packages_dir,
self.package_name))
remove(dlpath)
self.profile.add_package(self.package, self.version)
self.profile.save()
click.secho("""Package \'{}\' has been """
"""successfully installed!""".format(self.package),
fg='green')
def _install_package(self, dlpath):
if dlpath:
package_dir = util.safe_join(
self.packages_dir, self.package_name)
if isdir(package_dir):
shutil.rmtree(package_dir)
if self.uncompressed_name:
self._unpack(dlpath, self.packages_dir)
else:
self._unpack(dlpath, util.safe_join(
self.packages_dir, self.package_name))
remove(dlpath)
self.profile.add_package(self.package, self.version)
self.profile.save()
click.secho(
"""Package \'{}\' has been """
"""successfully installed!""".format(self.package),
fg='green')
def _run_command(self, command, silent=False):
result = {}
system_base_dir = util.get_package_dir('tools-system')
system_bin_dir = util.safe_join(system_base_dir, 'bin')
on_stdout = None if silent else self._on_stdout
on_stderr = self._on_stderr
if util.check_package(
self.name,
self.version,
self.spec_version,
system_bin_dir
):
result = util.exec_command(
util.safe_join(system_bin_dir, command + self.ext),
stdout=util.AsyncPipe(on_stdout),
stderr=util.AsyncPipe(on_stderr))
return result
def get_command(self, ctx, name):
ns = {}
# -- Get the full filename of the python file for the command name
fn = util.safe_join(commands_folder, name + '.py')
# -- Return the cli function of the command
if isfile(fn):
with open(fn) as f:
code = compile(f.read(), fn, 'exec')
eval(code, ns, ns)
return ns.get('cli')
def _ftdi_enable_windows(self):
drivers_base_dir = util.get_package_dir('tools-drivers')
drivers_bin_dir = util.safe_join(drivers_base_dir, 'bin')
drivers_share_dir = util.safe_join(drivers_base_dir, 'share')
zadig_ini_path = util.safe_join(drivers_share_dir, 'zadig.ini')
zadig_ini = 'zadig.ini'
try:
if util.check_package(
self.name,
self.version,
self.spec_version,
drivers_bin_dir
):
click.secho('Launch drivers configuration tool')
click.secho(FTDI_INSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
# Copy zadig.ini
with open(zadig_ini, 'w') as ini_file:
with open(zadig_ini_path, 'r') as local_ini_file:
ini_file.write(local_ini_file.read())
result = util.exec_command(
util.safe_join(drivers_bin_dir, 'zadig.exe'))
click.secho('FTDI drivers configuration finished',
fg='green')
else:
result = 1
except Exception as e:
click.secho('Error: ' + str(e), fg='red')
result = 1
finally:
# Remove zadig.ini
if isfile(zadig_ini):
os.remove(zadig_ini)
if not isinstance(result, int):
result = result.get('returncode')
return result
def copy_example_files(self, example, project_dir, sayno):
if util.check_package(self.name, self.version, self.spec_version,
self.examples_dir):
project_dir = util.check_dir(project_dir)
example_path = project_dir
local_example_path = util.safe_join(self.examples_dir, example)
if isdir(local_example_path):
self._copy_files(example, local_example_path, example_path,
sayno)
else:
click.secho(EXAMPLE_NOT_FOUND_MSG, fg='yellow')
else:
return 1
return 0
def __init__(self, url, dest_dir=None):
self._url = url
self._fname = url.split('/')[-1]
self._destination = self._fname
if dest_dir:
self.set_destination(util.safe_join(dest_dir, self._fname))
self._progressbar = None
self._request = None
# make connection
self._request = requests.get(url, stream=True)
if self._request.status_code != 200:
raise FDUnrecognizedStatusCode(self._request.status_code, url)
def get_package_version(self, name, release_name=''):
version = '0.0.0'
if name in self.packages.keys():
version = self.packages[name]['version']
elif release_name:
dir_name = util.get_package_dir(release_name)
if isdir(dir_name):
filepath = util.safe_join(dir_name, 'package.json')
try:
with open(filepath, 'r') as json_file:
tmp_data = json.load(json_file)
if 'version' in tmp_data.keys():
version = tmp_data['version']
except Exception:
pass
return version
def copy_example_files(self, example, project_dir, sayno):
if util.check_package(
self.name,
self.version,
self.spec_version,
self.examples_dir
):
project_dir = util.check_dir(project_dir)
example_path = project_dir
local_example_path = util.safe_join(self.examples_dir, example)
if isdir(local_example_path):
self._copy_files(example, local_example_path,
example_path, sayno)
else:
click.secho(EXAMPLE_NOT_FOUND_MSG, fg='yellow')
else:
return 1
return 0
def copy_example_files(self, example, project_dir, sayno):
if isdir(self.examples_dir):
project_dir = util.check_dir(project_dir)
example_path = project_dir
local_example_path = util.safe_join(self.examples_dir, example)
if isdir(local_example_path):
self._copy_files(example, local_example_path, example_path,
sayno)
else:
click.secho(EXAMPLE_NOT_FOUND_MSG, fg='yellow')
else:
click.secho('Error: examples are not installed', fg='red')
click.secho('Please run:\n'
' apio install examples',
fg='yellow')
return 1
return 0
class Drivers(object): # pragma: no cover
# FTDI rules files paths
ftdi_rules_local_path = util.safe_join(
util.get_folder('resources'), '80-fpga-ftdi.rules')
ftdi_rules_system_path = '/etc/udev/rules.d/80-fpga-ftdi.rules'
old_ftdi_rules_system_path = '/etc/udev/rules.d/80-icestick.rules'
# Serial rules files paths
serial_rules_local_path = util.safe_join(
util.get_folder('resources'), '80-fpga-serial.rules')
serial_rules_system_path = '/etc/udev/rules.d/80-fpga-serial.rules'
# Driver to restore: mac os
driverC = ''
def ftdi_enable(self):
if 'linux' in platform:
return self._ftdi_enable_linux()
elif 'darwin' in platform:
self._setup_darwin()
return self._ftdi_enable_darwin()
elif 'windows' in platform:
self._setup_windows()
return self._ftdi_enable_windows()
def ftdi_disable(self):
if 'linux' in platform:
return self._ftdi_disable_linux()
elif 'darwin' in platform:
self._setup_darwin()
return self._ftdi_disable_darwin()
elif 'windows' in platform:
self._setup_windows()
return self._ftdi_disable_windows()
def serial_enable(self):
if 'linux' in platform:
return self._serial_enable_linux()
elif 'darwin' in platform:
self._setup_darwin()
return self._serial_enable_darwin()
elif 'windows' in platform:
self._setup_windows()
return self._serial_enable_windows()
def serial_disable(self):
if 'linux' in platform:
return self._serial_disable_linux()
elif 'darwin' in platform:
self._setup_darwin()
return self._serial_disable_darwin()
elif 'windows' in platform:
self._setup_windows()
return self._serial_disable_windows()
def pre_upload(self):
if 'darwin' in platform:
self._setup_darwin()
self._pre_upload_darwin()
def post_upload(self):
if 'darwin' in platform:
self._setup_darwin()
self._post_upload_darwin()
def _setup_darwin(self):
self.profile = Profile()
def _setup_windows(self):
profile = Profile()
resources = Resources()
self.name = 'drivers'
self.version = util.get_package_version(self.name, profile)
self.spec_version = util.get_package_spec_version(self.name, resources)
def _ftdi_enable_linux(self):
click.secho('Configure FTDI drivers for FPGA')
if not isfile(self.ftdi_rules_system_path):
subprocess.call(['sudo', 'cp',
self.ftdi_rules_local_path,
self.ftdi_rules_system_path])
self._reload_rules()
click.secho('FTDI drivers enabled', fg='green')
click.secho('Unplug and reconnect your board', fg='yellow')
else:
click.secho('Already enabled', fg='yellow')
def _ftdi_disable_linux(self):
if isfile(self.old_ftdi_rules_system_path):
subprocess.call(['sudo', 'rm', self.old_ftdi_rules_system_path])
if isfile(self.ftdi_rules_system_path):
click.secho('Revert FTDI drivers configuration')
subprocess.call(['sudo', 'rm', self.ftdi_rules_system_path])
self._reload_rules()
click.secho('FTDI drivers disabled', fg='green')
click.secho('Unplug and reconnect your board', fg='yellow')
else:
click.secho('Already disabled', fg='yellow')
def _serial_enable_linux(self):
click.secho('Configure Serial drivers for FPGA')
if not isfile(self.serial_rules_system_path):
group_added = self._add_dialout_group()
subprocess.call(['sudo', 'cp',
self.serial_rules_local_path,
self.serial_rules_system_path])
self._reload_rules()
click.secho('Serial drivers enabled', fg='green')
click.secho('Unplug and reconnect your board', fg='yellow')
if group_added:
click.secho('Restart your machine to enable the dialout group',
fg='yellow')
else:
click.secho('Already enabled', fg='yellow')
def _serial_disable_linux(self):
if isfile(self.serial_rules_system_path):
click.secho('Revert Serial drivers configuration')
subprocess.call(['sudo', 'rm', self.serial_rules_system_path])
self._reload_rules()
click.secho('Serial drivers disabled', fg='green')
click.secho('Unplug and reconnect your board', fg='yellow')
else:
click.secho('Already disabled', fg='yellow')
def _reload_rules(self):
subprocess.call(['sudo', 'udevadm', 'control', '--reload-rules'])
subprocess.call(['sudo', 'udevadm', 'trigger'])
subprocess.call(['sudo', 'service', 'udev', 'restart'])
def _add_dialout_group(self):
groups = subprocess.check_output('groups')
if 'dialout' not in groups:
subprocess.call('sudo usermod -a -G dialout $USER', shell=True)
return True
def _ftdi_enable_darwin(self):
# Check homebrew
brew = subprocess.call('which brew > /dev/null', shell=True)
if brew != 0:
click.secho('Error: homebrew is required', fg='red')
else:
click.secho('Enable FTDI drivers for FPGA')
subprocess.call(['brew', 'update'])
self._brew_install('libffi')
self._brew_install('libftdi')
self.profile.add_setting('macos_ftdi_drivers', True)
self.profile.save()
click.secho('FTDI drivers enabled', fg='green')
def _ftdi_disable_darwin(self):
click.secho('Disable FTDI drivers configuration')
self.profile.add_setting('macos_ftdi_drivers', False)
self.profile.save()
click.secho('FTDI drivers disabled', fg='green')
def _serial_enable_darwin(self):
# Check homebrew
brew = subprocess.call('which brew > /dev/null', shell=True)
if brew != 0:
click.secho('Error: homebrew is required', fg='red')
else:
click.secho('Enable Serial drivers for FPGA')
subprocess.call(['brew', 'update'])
self._brew_install('libffi')
self._brew_install('libusb')
# self._brew_install_serial_drivers()
click.secho('Serial drivers enabled', fg='green')
def _serial_disable_darwin(self):
click.secho('Disable Serial drivers configuration')
click.secho('Serial drivers disabled', fg='green')
def _brew_install(self, package):
subprocess.call(['brew', 'install', '--force', package])
subprocess.call(['brew', 'unlink', package])
subprocess.call(['brew', 'link', '--force', package])
def _brew_install_serial_drivers(self):
subprocess.call(
['brew', 'tap', 'mengbo/ch340g-ch34g-ch34x-mac-os-x-driver',
'https://github.com/mengbo/ch340g-ch34g-ch34x-mac-os-x-driver'])
subprocess.call(
['brew', 'cask', 'install', 'wch-ch34x-usb-serial-driver'])
def _pre_upload_darwin(self):
if self.profile.settings.get('macos_ftdi_drivers', False):
# Check and unload the drivers
driverA = 'com.FTDI.driver.FTDIUSBSerialDriver'
driverB = 'com.apple.driver.AppleUSBFTDI'
if self._check_ftdi_driver_darwin(driverA):
subprocess.call(['sudo', 'kextunload', '-b', driverA])
self.driverC = driverA
elif self._check_ftdi_driver_darwin(driverB):
subprocess.call(['sudo', 'kextunload', '-b', driverB])
self.driverC = driverB
def _post_upload_darwin(self):
if self.profile.settings.get('macos_ftdi_drivers', False):
# Restore previous driver configuration
if self.driverC:
subprocess.call(['sudo', 'kextload', '-b', self.driverC])
def _check_ftdi_driver_darwin(self, driver):
return driver in str(subprocess.check_output(['kextstat']))
def _ftdi_enable_windows(self):
drivers_base_dir = util.get_package_dir('tools-drivers')
drivers_bin_dir = util.safe_join(drivers_base_dir, 'bin')
drivers_share_dir = util.safe_join(drivers_base_dir, 'share')
zadig_ini_path = util.safe_join(drivers_share_dir, 'zadig.ini')
zadig_ini = 'zadig.ini'
try:
if util.check_package(
self.name,
self.version,
self.spec_version,
drivers_bin_dir
):
click.secho('Launch drivers configuration tool')
click.secho(FTDI_INSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
# Copy zadig.ini
with open(zadig_ini, 'w') as ini_file:
with open(zadig_ini_path, 'r') as local_ini_file:
ini_file.write(local_ini_file.read())
result = util.exec_command(
util.safe_join(drivers_bin_dir, 'zadig.exe'))
click.secho('FTDI drivers configuration finished',
fg='green')
else:
result = 1
except Exception as e:
click.secho('Error: ' + str(e), fg='red')
result = 1
finally:
# Remove zadig.ini
if isfile(zadig_ini):
os.remove(zadig_ini)
if not isinstance(result, int):
result = result.get('returncode')
return result
def _ftdi_disable_windows(self):
click.secho('Launch device manager')
click.secho(FTDI_UNINSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
result = util.exec_command('mmc devmgmt.msc')
return result.get('returncode')
def _serial_enable_windows(self):
drivers_base_dir = util.get_package_dir('tools-drivers')
drivers_bin_dir = util.safe_join(drivers_base_dir, 'bin')
try:
if util.check_package(
self.name,
self.version,
self.spec_version,
drivers_bin_dir
):
click.secho('Launch drivers configuration tool')
click.secho(SERIAL_INSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
result = util.exec_command(
util.safe_join(drivers_bin_dir, 'serial_install.exe'))
click.secho('Serial drivers configuration finished',
fg='green')
else:
result = 1
except Exception as e:
click.secho('Error: ' + str(e), fg='red')
result = 1
if not isinstance(result, int):
result = result.get('returncode')
return result
def _serial_disable_windows(self):
click.secho('Launch device manager')
click.secho(SERIAL_UNINSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
result = util.exec_command('mmc devmgmt.msc')
return result.get('returncode')
def __init__(self, package, platform='', force=False, checkversion=True):
# Parse version
if '@' in package:
split = package.split('@')
self.package = split[0]
self.version = split[1]
else:
self.package = package
self.version = None
self.force_install = force
self.packages_dir = ''
self.resources = Resources(platform)
if self.package in self.resources.packages:
self.profile = Profile()
dirname = 'packages'
self.packages_dir = util.safe_join(util.get_home_dir(), dirname)
# Get data
data = self.resources.packages.get(self.package)
distribution = self.resources.distribution
self.spec_version = distribution.get('packages').get(self.package)
self.package_name = data.get('release').get('package_name')
self.extension = data.get('release').get('extension')
platform = platform or self._get_platform()
if checkversion:
# Check version
valid_version = self._get_valid_version(
data.get('repository').get('name'),
data.get('repository').get('organization'),
data.get('release').get('tag_name')
)
# Valid version
if not valid_version:
# Error
click.secho('Error: no valid version found', fg='red')
exit(1)
self.version = valid_version
# e.g., [linux_x86_64, linux]
platform_os = platform.split('_')[0]
self.download_urls = [
{
'url': self.get_download_url(data, platform),
'platform': platform
},
{
'url': self.get_download_url(data, platform_os),
'platform': platform_os
}
]
if self.packages_dir == '':
click.secho(
'Error: no such package \'{}\''.format(self.package),
fg='red')
exit(1)
def preserve_permissions(item, dest_dir):
attrs = item.external_attr >> 16
if attrs:
chmod(util.safe_join(dest_dir, item.filename), attrs)
def preserve_mtime(item, dest_dir):
util.change_filemtime(util.safe_join(dest_dir, item.filename),
mktime(tuple(list(item.date_time) + [0] * 3)))
def preserve_permissions(item, dest_dir):
attrs = item.external_attr >> 16
if attrs:
chmod(util.safe_join(dest_dir, item.filename), attrs)
def preserve_mtime(item, dest_dir):
util.change_filemtime(
util.safe_join(dest_dir, item.filename),
mktime(tuple(list(item.date_time) + [0] * 3))
)
def run(self, command, variables=[], board=None, deps=[]):
"""Executes scons for building"""
# -- Check for the SConstruct file
if not isfile(util.safe_join(util.get_project_dir(), 'SConstruct')):
click.secho('Info: default SConstruct file')
variables += ['-f']
variables += [
util.safe_join(util.get_folder('resources'), 'SConstruct')
]
# -- Resolve packages
if self.profile.check_exe_default():
# Run on `default` config mode
if not util.resolve_packages(self.resources.packages, deps):
# Exit if a package is not installed
return 1
else:
click.secho('Info: native config mode')
# -- Execute scons
terminal_width, _ = click.get_terminal_size()
start_time = time.time()
if command == 'build' or \
command == 'upload' or \
command == 'time':
if board:
processing_board = board
else:
processing_board = 'custom board'
click.echo('[%s] Processing %s' %
(datetime.datetime.now().strftime('%c'),
click.style(processing_board, fg='cyan', bold=True)))
click.secho('-' * terminal_width, bold=True)
if self.profile.get_verbose_mode() > 0:
click.secho('Executing: scons -Q {0} {1}'.format(
command, ' '.join(variables)))
result = util.exec_command(util.scons_command + ['-Q', command] +
variables,
stdout=util.AsyncPipe(self._on_run_out),
stderr=util.AsyncPipe(self._on_run_err))
# -- Print result
exit_code = result['returncode']
is_error = exit_code != 0
summary_text = ' Took %.2f seconds ' % (time.time() - start_time)
half_line = '=' * int(((terminal_width - len(summary_text) - 10) / 2))
click.echo('%s [%s]%s%s' %
(half_line,
(click.style(' ERROR ', fg='red', bold=True) if is_error
else click.style('SUCCESS', fg='green', bold=True)),
summary_text, half_line),
err=is_error)
if False:
if is_error:
print("""
______ _
| ____| | |
| |__ _ __ _ __ ___ _ __| |
| __| | '__| '__/ _ \| '__| |
| |____| | | | | (_) | | |_|
|______|_| |_| \___/|_| (_)
""")
else:
print("""
_____ _
/ ____| | |
| (___ _ _ ___ ___ ___ ___ ___| |
\___ \| | | |/ __/ __/ _ \/ __/ __| |
____) | |_| | (_| (_| __/\__ \__ \_|
|_____/ \__,_|\___\___\___||___/___(_)
""")
return exit_code
class Drivers(object): # pragma: no cover
rules_local_path = util.safe_join(util.get_folder('resources'),
'80-icestick.rules')
rules_system_path = '/etc/udev/rules.d/80-icestick.rules'
# Driver to restore: mac os
driverC = ''
def enable(self):
if 'linux' in platform:
return self._enable_linux()
elif 'darwin' in platform:
self.profile = Profile()
return self._enable_darwin()
elif 'windows' in platform:
return self._enable_windows()
def disable(self):
if 'linux' in platform:
return self._disable_linux()
elif 'darwin' in platform:
self.profile = Profile()
return self._disable_darwin()
elif 'windows' in platform:
return self._disable_windows()
def pre_upload(self):
if 'darwin' in platform:
self._pre_upload_darwin()
def post_upload(self):
if 'darwin' in platform:
self._post_upload_darwin()
def _enable_linux(self):
click.secho('Configure FTDI drivers for FPGA')
if not isfile(self.rules_system_path):
subprocess.call(
['sudo', 'cp', self.rules_local_path, self.rules_system_path])
subprocess.call(['sudo', 'service', 'udev', 'restart'])
# subprocess.call(['sudo', 'udevadm', 'control', '--reload-rules'])
# subprocess.call(['sudo', 'udevadm', 'trigger'])
click.secho('FPGA drivers enabled', fg='green')
click.secho('Unplug and reconnect your board', fg='yellow')
else:
click.secho('Already enabled', fg='yellow')
def _disable_linux(self):
if isfile(self.rules_system_path):
click.secho('Revert FTDI drivers\' configuration')
subprocess.call(['sudo', 'rm', self.rules_system_path])
subprocess.call(['sudo', 'service', 'udev', 'restart'])
# subprocess.call(['sudo', 'udevadm', 'control', '--reload-rules'])
# subprocess.call(['sudo', 'udevadm', 'trigger'])
click.secho('FPGA drivers disabled', fg='green')
click.secho('Unplug and reconnect your board', fg='yellow')
else:
click.secho('Already disabled', fg='yellow')
def _enable_darwin(self):
# Check homebrew
brew = subprocess.call('which brew > /dev/null', shell=True)
if brew != 0:
click.secho('Error: homebrew is required', fg='red')
else:
click.secho('Enable FTDI drivers for FPGA')
subprocess.call(['brew', 'update'])
subprocess.call(['brew', 'install', '--force', 'libftdi'])
subprocess.call(['brew', 'unlink', 'libftdi'])
subprocess.call(['brew', 'link', '--force', 'libftdi'])
subprocess.call(['brew', 'install', '--force', 'libffi'])
subprocess.call(['brew', 'unlink', 'libffi'])
subprocess.call(['brew', 'link', '--force', 'libffi'])
self.profile.add_setting('macos_drivers', True)
self.profile.save()
click.secho('FPGA drivers enabled', fg='green')
def _disable_darwin(self):
click.secho('Disable FTDI drivers\' configuration')
self.profile.add_setting('macos_drivers', False)
self.profile.save()
click.secho('FPGA drivers disabled', fg='green')
def _pre_upload_darwin(self):
if self.profile.settings.get('macos_drivers', False):
# Check and unload the drivers
driverA = 'com.FTDI.driver.FTDIUSBSerialDriver'
driverB = 'com.apple.driver.AppleUSBFTDI'
if self._check_driver_darwin(driverA):
subprocess.call(['sudo', 'kextunload', '-b', driverA])
self.driverC = driverA
elif self._check_driver_darwin(driverB):
subprocess.call(['sudo', 'kextunload', '-b', driverB])
self.driverC = driverB
def _post_upload_darwin(self):
if self.profile.settings.get('macos_drivers', False):
# Restore previous driver configuration
if self.driverC:
subprocess.call(['sudo', 'kextload', '-b', self.driverC])
def _check_driver_darwin(self, driver):
return driver in subprocess.check_output(['kextstat'])
def _enable_windows(self):
drivers_base_dir = util.get_package_dir('tools-drivers')
drivers_bin_dir = util.safe_join(drivers_base_dir, 'bin')
drivers_share_dir = util.safe_join(drivers_base_dir, 'share')
zadig_ini_path = util.safe_join(drivers_share_dir, 'zadig.ini')
zadig_ini = 'zadig.ini'
try:
if isdir(drivers_bin_dir):
click.secho('Launch drivers configuration tool')
click.secho(FTDI_INSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
# Copy zadig.ini
with open(zadig_ini, 'w') as ini_file:
with open(zadig_ini_path, 'r') as local_ini_file:
ini_file.write(local_ini_file.read())
result = util.exec_command(
util.safe_join(drivers_bin_dir, 'zadig.exe'))
click.secho('FPGA drivers configuration finished', fg='green')
else:
util._check_package('drivers')
result = 1
except Exception as e:
click.secho('Error: ' + str(e), fg='red')
result = 1
finally:
# Remove zadig.ini
if isfile(zadig_ini):
os.remove(zadig_ini)
if not isinstance(result, int):
result = result['returncode']
return result
def _disable_windows(self):
click.secho('Launch device manager')
click.secho(FTDI_UNINSTALL_DRIVER_INSTRUCTIONS, fg='yellow')
result = util.exec_command('mmc devmgmt.msc')
return result['returncode']
def __init__(self, package, platform='', force=False, checkversion=True):
# Parse version
if '@' in package:
split = package.split('@')
self.package = split[0]
self.version = split[1]
else:
self.package = package
self.version = None
self.force_install = force
self.packages_dir = ''
self.resources = Resources(platform)
if self.package in self.resources.packages:
self.profile = Profile()
dirname = 'packages'
self.packages_dir = util.safe_join(util.get_home_dir(), dirname)
# Get data
data = self.resources.packages.get(self.package)
distribution = self.resources.distribution
self.specversion = distribution.get('packages').get(self.package)
self.package_name = data.get('release').get('package_name')
self.extension = data.get('release').get('extension')
platform = platform or self._get_platform()
if checkversion:
# Check version
valid_version = self._get_valid_version(
data.get('repository').get('name'),
data.get('repository').get('organization'),
data.get('release').get('tag_name'),
self.version,
self.specversion,
force
)
# Valid version
if not valid_version:
# Error
click.secho(
'Error: No version {} found'.format(self.version),
fg='red')
exit(1)
self.version = valid_version
# e.g., [linux_x86_64, linux]
platform_os = platform.split('_')[0]
self.download_urls = [
{
'url': self.get_download_url(data, platform),
'platform': platform
},
{
'url': self.get_download_url(data, platform_os),
'platform': platform_os
}
]
if self.packages_dir == '':
click.secho(
'Error: No such package \'{0}\''.format(self.package),
fg='red')
exit(1)
