the other jimmy
/
mbed-sdk-tools
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
mbed-sdk-tools
by 
mbed official
Diff: targets.py
- Revision:
- 7:5af61d55adbe
- Parent:
- 0:66f3b5499f7f
- Child:
- 13:ab47a20b66f0
diff -r 744106007ff3 -r 5af61d55adbe targets.py
--- a/targets.py Sat May 21 20:17:44 2016 +0100
+++ b/targets.py Tue Jun 07 11:21:44 2016 +0100
@@ -34,462 +34,240 @@
import shutil
from tools.patch import patch
from paths import TOOLS_BOOTLOADERS
+import json
+import inspect
+import sys
+from tools.utils import json_file_to_dict
+
+########################################################################################################################
+# Generic Target class that reads and interprets the data in targets.json
+
+# A simple class that represents all the exceptions associated with hooking
+class HookError(Exception):
+ pass
+
+# A simple decorator used for automatically caching data returned by a function
+caches = {}
+def cached(func):
+ def wrapper(*args, **kwargs):
+ if not caches.has_key(func):
+ caches[func] = func(*args, **kwargs)
+ return caches[func]
+ return wrapper
class Target:
- def __init__(self):
- # ARM Core
- self.core = None
+ # Cumulative attributes can have values appended to them, so they
+ # need to be computed differently than regular attributes
+ __cumulative_attributes = ['extra_labels', 'macros', 'features']
+
+ # {target_name: target_instance} map for all the targets in the system
+ __target_map = {}
+
+ # List of targets that were added dynamically using "add_py_targets" (see below)
+ __py_targets = set()
+
+ # Load the description of JSON target data
+ @staticmethod
+ @cached
+ def get_json_target_data():
+ return json_file_to_dict(os.path.join(os.path.dirname(os.path.abspath(__file__)), "targets.json"))
+
+ # Get the members of this module using Python's "inspect" module
+ @staticmethod
+ @cached
+ def get_module_data():
+ return dict([(m[0], m[1]) for m in inspect.getmembers(sys.modules[__name__])])
- # Is the disk provided by the interface chip of this board virtual?
- self.is_disk_virtual = False
+ # Return the order in which target descriptions are searched for attributes
+ # This mimics the Python 2.2 method resolution order, which is what the old targets.py module used
+ # For more details, check http://makina-corpus.com/blog/metier/2014/python-tutorial-understanding-python-mro-class-search-path
+ # The resolution order contains (name, level) tuples, where "name" is the name of the class and "level"
+ # is the level in the inheritance hierarchy (the target itself is at level 0, its first parent at level 1,
+ # its parent's parent at level 1 and so on)
+ def __get_resolution_order(self, target_name, order, level = 0):
+ if not target_name in [l[0] for l in order]: # the resolution order can't contain duplicate target names
+ order.append((target_name, level))
+ parents = self.get_json_target_data()[target_name].get("inherits", [])
+ for p in parents:
+ order = self.__get_resolution_order(p, order, level + 1)
+ return order
- # list of toolchains that are supported by the mbed SDK for this target
- self.supported_toolchains = None
+ # Modify the exporter specification ("progen") by changing all "template" keys to full paths
+ @staticmethod
+ def __add_paths_to_progen(data):
+ out = {}
+ for key, value in data.items():
+ if isinstance(value, dict):
+ out[key] = Target.__add_paths_to_progen(value)
+ elif key == "template":
+ out[key] = [os.path.join(os.path.dirname(__file__), 'export', v) for v in value]
+ else:
+ out[key] = value
+ return out
- # list of extra specific labels
- self.extra_labels = []
-
- # list of macros (-D)
- self.macros = []
+ # Comute the value of a given target attribute
+ def __getattr_helper(self, attrname):
+ tdata = self.get_json_target_data()
+ if attrname in self.__cumulative_attributes:
+ # For a cumulative attribute, figure out when it was defined the last time (in attribute
+ # resolution order) then follow the "_add" and "_remove" data fields
+ for idx, t in enumerate(self.resolution_order):
+ if attrname in tdata[t[0]]: # the attribute was defined at this level in the resolution order
+ def_idx = idx
+ break
+ else:
+ raise AttributeError("Attribute '%s' not found in target '%s'" % (attrname, self.name))
+ # Get the starting value of the attribute
+ v = (tdata[self.resolution_order[def_idx][0]][attrname] or [])[:]
+ # Traverse the resolution list in high inheritance to low inheritance level, left to right order
+ # to figure out all the other classes that change the definition by adding or removing elements
+ for idx in xrange(self.resolution_order[def_idx][1] - 1, -1, -1):
+ same_level_targets = [t[0] for t in self.resolution_order if t[1] == idx]
+ for t in same_level_targets:
+ data = tdata[t]
+ # Do we have anything to add ?
+ if data.has_key(attrname + "_add"):
+ v.extend(data[attrname + "_add"])
+ # Do we have anything to remove ?
+ if data.has_key(attrname + "_remove"):
+ # Macros can be defined either without a value (MACRO) or with a value (MACRO=10).
+ # When removing, we specify only the name of the macro, without the value. So we need
+ # to create a mapping between the macro name and its value. This will work for
+ # extra_labels and other type of arrays as well, since they fall into the "macros
+ # without a value" category (simple definitions without a value).
+ name_def_map = {}
+ for crtv in v:
+ if crtv.find('=') != -1:
+ temp = crtv.split('=')
+ if len(temp) != 2:
+ raise ValueError("Invalid macro definition '%s'" % crtv)
+ name_def_map[temp[0]] = crtv
+ else:
+ name_def_map[crtv] = crtv
+ for e in data[attrname + "_remove"]:
+ if not e in name_def_map:
+ raise ValueError("Unable to remove '%s' in '%s.%s' since it doesn't exist" % (e, self.name, attrname))
+ v.remove(name_def_map[e])
+ return v
+ # Look for the attribute in the class and its parents, as defined by the resolution order
+ v = None
+ for t in self.resolution_order:
+ data = tdata[t[0]]
+ if data.has_key(attrname):
+ v = data[attrname]
+ break
+ else: # Attribute not found
+ raise AttributeError("Attribute '%s' not found in target '%s'" % (attrname, self.name))
+ # 'progen' needs the full path to the template (the path in JSON is relative to tools/export)
+ return v if attrname != "progen" else self.__add_paths_to_progen(v)
- # Default online compiler:
- self.default_toolchain = "ARM"
+ # Return the value of an attribute
+ # This function only computes the attribute's value once, then adds it to the instance attributes
+ # (in __dict__), so the next time it is returned directly
+ def __getattr__(self, attrname):
+ v = self.__getattr_helper(attrname)
+ self.__dict__[attrname] = v
+ return v
- self.name = self.__class__.__name__
+ # Add one or more new target(s) represented as a Python dictionary in 'new_targets'
+ # It it an error to add a target with a name that exists in "targets.json"
+ # However, it is OK to add a target that was previously added via "add_py_targets"
+ # (this makes testing easier without changing the regular semantics)
+ @staticmethod
+ def add_py_targets(new_targets):
+ crt_data = Target.get_json_target_data()
+ # First add all elemnts to the internal dictionary
+ for tk, tv in new_targets.items():
+ if crt_data.has_key(tk) and (not tk in Target.__py_targets):
+ raise Exception("Attempt to add target '%s' that already exists" % tk)
+ crt_data[tk] = tv
+ Target.__py_targets.add(tk)
+ # Then create the new instances and update global variables if needed
+ for tk, tv in new_targets.items():
+ # Is the target already created?
+ old_target = Target.__target_map.get(tk, None)
+ # Instantiate this target. If it is public, update the data in
+ # in TARGETS, TARGET_MAP, TARGET_NAMES
+ new_target = Target(tk)
+ if tv.get("public", True):
+ if old_target: # remove the old target from TARGETS and TARGET_NAMES
+ TARGETS.remove(old_target)
+ TARGET_NAMES.remove(tk)
+ # Add the new target
+ TARGETS.append(new_target)
+ TARGET_MAP[tk] = new_target
+ TARGET_NAMES.append(tk)
+ # Update the target cache
+ Target.__target_map[tk] = new_target
- # Code used to determine devices' platform
- # This code is prefix in URL link provided in mbed.htm (in mbed disk)
- self.detect_code = []
+ # Return the target instance starting from the target name
+ @staticmethod
+ def get_target(name):
+ if not Target.__target_map.has_key(name):
+ Target.__target_map[name] = Target(name)
+ return Target.__target_map[name]
+
+ def __init__(self, name):
+ self.name = name
+
+ # Compute resolution order once (it will be used later in __getattr__)
+ self.resolution_order = self.__get_resolution_order(self.name, [])
+ # Create also a list with only the names of the targets in the resolution order
+ self.resolution_order_names = [t[0] for t in self.resolution_order]
def program_cycle_s(self):
- return 4 if self.is_disk_virtual else 1.5
+ try:
+ return self.__getattr__("program_cycle_s")
+ except AttributeError:
+ return 4 if self.is_disk_virtual else 1.5
def get_labels(self):
return [self.name] + CORE_LABELS[self.core] + self.extra_labels
+ # For now, this function only allows "post binary" hooks (hooks that are executed after
+ # the binary image is extracted from the executable file)
def init_hooks(self, hook, toolchain_name):
- pass
-
-
-### MCU Support ###
-
-class CM4_UARM(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4"
- self.supported_toolchains = ["uARM"]
- self.default_toolchain = "uARM"
-
-class CM4_ARM(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4"
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
+ # If there's no hook, simply return
+ try:
+ hook_data = self.post_binary_hook
+ except AttributeError:
+ return
+ # A hook was found. The hook's name is in the format "classname.functionname"
+ temp = hook_data["function"].split(".")
+ if len(temp) != 2:
+ raise HookError("Invalid format for hook '%s' in target '%s' (must be 'class_name.function_name')" % (hook_data["function"], self.name))
+ class_name, function_name = temp[0], temp[1]
+ # "class_name" must refer to a class in this file, so check if the class exists
+ mdata = self.get_module_data()
+ if not mdata.has_key(class_name) or not inspect.isclass(mdata[class_name]):
+ raise HookError("Class '%s' required by '%s' in target '%s' not found in targets.py" % (class_name, hook_data["function"], self.name))
+ # "function_name" must refer to a static function inside class "class_name"
+ cls = mdata[class_name]
+ if (not hasattr(cls, function_name)) or (not inspect.isfunction(getattr(cls, function_name))):
+ raise HookError("Static function '%s' required by '%s' in target '%s' not found in class '%s'" % (function_name, hook_data["function"], self.name, class_name))
+ # Check if the hook specification also has target restrictions
+ toolchain_restrictions = hook_data.get("toolchains", [])
+ if toolchain_restrictions and (toolchain_name not in toolchain_restrictions):
+ return
+ # Finally, hook the requested function
+ hook.hook_add_binary("post", getattr(cls, function_name))
-class CM4F_UARM(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.supported_toolchains = ["uARM"]
- self.default_toolchain = "uARM"
+########################################################################################################################
+# Target specific code goes in this section
+# This code can be invoked from the target description using the "post_binary_hook" key
-class CM4F_ARM(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
-
-
-### NXP ###
-
-# This class implements the post-link patching step needed by LPC targets
-class LPCTarget(Target):
- def __init__(self):
- Target.__init__(self)
-
- def init_hooks(self, hook, toolchain_name):
- hook.hook_add_binary("post", self.lpc_patch)
-
+class LPCTargetCode:
@staticmethod
def lpc_patch(t_self, resources, elf, binf):
t_self.debug("LPC Patch: %s" % os.path.split(binf)[1])
patch(binf)
-class LPC11C24(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11XX_11CXX', 'LPC11CXX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
-
- self.progen = {
- "target":"lpc11c24_301",
- }
-
-class LPC1114(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11XX_11CXX', 'LPC11XX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc1114_102",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC11U24(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX', 'LPC11U24_401']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.detect_code = ["1040"]
- self.progen = {
- "target":"lpc11u24_201",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class OC_MBUINO(LPC11U24):
- def __init__(self):
- LPC11U24.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX']
- self.macros = ['TARGET_LPC11U24']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc11u24_201",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC11U24_301(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
-
-class LPC11U34_421(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
- self.default_toolchain = "uARM"
-
-class MICRONFCBOARD(LPC11U34_421):
- def __init__(self):
- LPC11U34_421.__init__(self)
- self.macros = ['LPC11U34_421', 'APPNEARME_MICRONFCBOARD']
- self.extra_labels = ['NXP', 'LPC11UXX', 'APPNEARME_MICRONFCBOARD']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
- self.default_toolchain = "uARM"
-
-class LPC11U35_401(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc11u35_401",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC11U35_501(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR" , "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc11u35_501",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC11U35_501_IBDAP(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR" , "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc11u35_501",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class XADOW_M0(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc11u35_501",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC11U35_Y5_MBUG(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR" , "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc11u35_501",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC11U37_501(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"lpc11u37_501",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPCCAPPUCCINO(LPC11U37_501):
- def __init__(self):
- LPC11U37_501.__init__(self)
-
-class ARCH_GPRS(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX', 'LPC11U37_501']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"lpc11u37_501",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC11U68(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['NXP', 'LPC11U6X']
- self.supported_toolchains = ["ARM", "uARM", "GCC_CR", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["1168"]
- self.progen = {
- "target":"lpc11u68",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC1347(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['NXP', 'LPC13XX']
- self.supported_toolchains = ["ARM", "GCC_ARM","IAR"]
- self.progen = {
- "target":"lpc1347",
- }
-
-class LPC1549(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['NXP', 'LPC15XX']
- self.supported_toolchains = ["uARM", "GCC_CR", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["1549"]
- self.progen = {
- "target":"lpc1549",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC1768(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['NXP', 'LPC176X', 'MBED_LPC1768']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.detect_code = ["1010"]
- self.progen = {
- "target":"mbed-lpc1768",
- }
-
-class ARCH_PRO(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['NXP', 'LPC176X']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.macros = ['TARGET_LPC1768']
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"arch-pro",
- }
-
-class UBLOX_C027(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['NXP', 'LPC176X']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.macros = ['TARGET_LPC1768']
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"ublox-c027",
- }
-
-class XBED_LPC1768(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['NXP', 'LPC176X', 'XBED_LPC1768']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
- self.macros = ['TARGET_LPC1768']
- self.detect_code = ["1010"]
- self.progen = {
- "target":"lpc1768",
- }
-
-class LPC2368(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "ARM7TDMI-S"
- self.extra_labels = ['NXP', 'LPC23XX']
- self.supported_toolchains = ["ARM", "GCC_ARM", "GCC_CR"]
- self.progen = {
- "target":"lpc2368",
- }
-
-class LPC2460(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "ARM7TDMI-S"
- self.extra_labels = ['NXP', 'LPC2460']
- self.supported_toolchains = ["GCC_ARM"]
- self.progen = {
- "target":"lpc2460",
- }
-
-class LPC810(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['NXP', 'LPC81X']
- self.supported_toolchains = ["uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.is_disk_virtual = True
- self.progen = {
- "target":"lpc810",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC812(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['NXP', 'LPC81X']
- self.supported_toolchains = ["uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.detect_code = ["1050"]
- self.progen = {
- "target":"lpc812m101",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC824(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['NXP', 'LPC82X']
- self.supported_toolchains = ["uARM", "GCC_ARM","GCC_CR", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.progen = {
- "target":"lpc824m201",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class SSCI824(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['NXP', 'LPC82X']
- self.supported_toolchains = ["uARM", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.is_disk_virtual = True
- self.progen = {
- "target":"ssci824",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class LPC4088(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['NXP', 'LPC408X']
- self.supported_toolchains = ["ARM", "GCC_CR", "GCC_ARM", "IAR"]
- self.is_disk_virtual = True
- self.progen = {
- "target":"lpc4088",
- }
-
- def init_hooks(self, hook, toolchain_name):
- if toolchain_name in ['ARM_STD', 'ARM_MICRO']:
- hook.hook_add_binary("post", self.binary_hook)
-
+class LPC4088Code:
@staticmethod
def binary_hook(t_self, resources, elf, binf):
if not os.path.isdir(binf):
# Regular binary file, nothing to do
- LPCTarget.lpc_patch(t_self, resources, elf, binf)
+ LPCTargetCode.lpc_patch(t_self, resources, elf, binf)
return
outbin = open(binf + ".temp", "wb")
partf = open(os.path.join(binf, "ER_IROM1"), "rb")
@@ -513,229 +291,9 @@
shutil.rmtree(binf, True)
os.rename(binf + '.temp', binf)
t_self.debug("Generated custom binary file (internal flash + SPIFI)")
- LPCTarget.lpc_patch(t_self, resources, elf, binf)
-
-class LPC4088_DM(LPC4088):
- pass
-
-class LPC4330_M4(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['NXP', 'LPC43XX', 'LPC4330']
- self.supported_toolchains = ["ARM", "GCC_CR", "IAR", "GCC_ARM"]
- self.progen = {
- "target":"lpc4330",
- }
-
-class LPC4330_M0(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC43XX', 'LPC4330']
- self.supported_toolchains = ["ARM", "GCC_CR", "IAR"]
-
-class LPC4337(LPCTarget):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['NXP', 'LPC43XX', 'LPC4337']
- self.supported_toolchains = ["ARM"]
- self.progen = {
- "target":"lpc4337",
- }
-
-class LPC1800(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['NXP', 'LPC43XX']
- self.supported_toolchains = ["ARM", "GCC_CR", "IAR"]
-
-class LPC11U37H_401(LPCTarget):
- def __init__(self):
- LPCTarget.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['NXP', 'LPC11UXX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"lpc11u37_401",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-### Freescale ###
-
-class KL05Z(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Freescale', 'KLXX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.progen = {
- "target":"frdm-kl05z",
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-class KL25Z(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Freescale', 'KLXX']
- self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.detect_code = ["0200"]
- self.progen = {
- "target":"frdm-kl25z",
- }
-
-class KL26Z(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Freescale', 'KLXX']
- self.supported_toolchains = ["ARM","GCC_ARM","IAR"]
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.progen = {
- "target":"kl26z",
- }
-
-class KL43Z(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Freescale', 'KLXX']
- self.supported_toolchains = ["GCC_ARM", "ARM"]
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.progen = {
- "target":"frdm-kl43z",
- }
+ LPCTargetCode.lpc_patch(t_self, resources, elf, binf)
-class KL46Z(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Freescale', 'KLXX']
- self.supported_toolchains = ["GCC_ARM", "ARM", "IAR"]
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.detect_code = ["0220"]
- self.progen = {
- "target":"frdm-kl46z",
- }
-
-class K20D50M(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4"
- self.extra_labels = ['Freescale', 'K20XX']
- self.supported_toolchains = ["GCC_ARM", "ARM", "IAR"]
- self.is_disk_virtual = True
- self.detect_code = ["0230"]
- self.progen = {
- "target":"frdm-k20d50m",
- }
-
-class K22F(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['Freescale', 'KSDK2_MCUS', 'FRDM', 'KPSDK_MCUS', 'KPSDK_CODE']
- self.macros = ["CPU_MK22FN512VLH12", "FSL_RTOS_MBED"]
- self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.detect_code = ["0231"]
- self.progen = {
- "target":"frdm-k22f",
- }
-
-class KL27Z(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Freescale', 'KSDK2_MCUS', 'FRDM']
- self.macros = ["CPU_MKL27Z64VLH4", "FSL_RTOS_MBED"]
- self.supported_toolchains = ["ARM","GCC_ARM","IAR"]
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.default_toolchain = "ARM"
- self.detect_code = ["0261"]
- self.progen_target = {
- "target":"frdm-kl27z",
- }
-
-class K64F(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['Freescale', 'KSDK2_MCUS', 'FRDM', 'KPSDK_MCUS', 'KPSDK_CODE', 'MCU_K64F']
- self.macros = ["CPU_MK64FN1M0VMD12", "FSL_RTOS_MBED"]
- self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
- self.supported_form_factors = ["ARDUINO"]
- self.is_disk_virtual = True
- self.default_toolchain = "ARM"
- self.detect_code = ["0240"]
- self.progen = {
- "target":"frdm-k64f",
- }
-
-class MTS_GAMBIT(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['Freescale', 'KSDK2_MCUS', 'K64F', 'KPSDK_MCUS', 'KPSDK_CODE', 'MCU_K64F']
- self.supported_toolchains = ["ARM", "GCC_ARM"]
- self.macros = ["CPU_MK64FN1M0VMD12", "FSL_RTOS_MBED", "TARGET_K64F"]
- self.is_disk_virtual = True
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"mts-gambit",
- }
-
-class HEXIWEAR(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['Freescale', 'KSDK2_MCUS', 'K64F']
- self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
- self.macros = ["CPU_MK64FN1M0VMD12", "FSL_RTOS_MBED", "TARGET_K64F"]
- self.is_disk_virtual = True
- self.default_toolchain = "ARM"
- self.detect_code = ["0214"]
- self.progen = {
- "target":"hexiwear-k64f",
- }
-
-class TEENSY3_1(Target):
- OUTPUT_EXT = 'hex'
-
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4"
- self.extra_labels = ['Freescale', 'K20XX', 'K20DX256']
- self.supported_toolchains = ["GCC_ARM", "ARM"]
- self.is_disk_virtual = True
- self.detect_code = ["0230"]
- self.progen = {
- "target":"teensy-31",
- }
-
- def init_hooks(self, hook, toolchain_name):
- if toolchain_name in ['ARM_STD', 'ARM_MICRO', 'GCC_ARM']:
- hook.hook_add_binary("post", self.binary_hook)
-
+class TEENSY3_1Code:
@staticmethod
def binary_hook(t_self, resources, elf, binf):
from intelhex import IntelHex
@@ -745,471 +303,10 @@
with open(binf.replace(".bin", ".hex"), "w") as f:
binh.tofile(f, format='hex')
-### STMicro ###
-
-class NUCLEO_F030R8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32F0', 'STM32F030R8']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0725"]
- self.progen = {
- "target":"nucleo-f030r8",
- }
-
-class NUCLEO_F031K6(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32F0', 'STM32F031K6']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["0791"]
- self.progen = {
- "target":"nucleo-f031k6",
- }
-
-class NUCLEO_F042K6(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32F0', 'STM32F042K6']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["0785"]
- self.progen = {
- "target":"nucleo-f042k6",
- }
-
-class NUCLEO_F070RB(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32F0', 'STM32F070RB']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0755"]
- self.progen = {
- "target":"nucleo-f070rb",
- }
-
-class NUCLEO_F072RB(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32F0', 'STM32F072RB']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0730"]
- self.progen = {
- "target":"nucleo-f072rb",
- }
-
-class NUCLEO_F091RC(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32F0', 'STM32F091RC']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0750"]
- self.progen = {
- "target":"nucleo-f091rc",
- }
-
-class NUCLEO_F103RB(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['STM', 'STM32F1', 'STM32F103RB']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0700"]
- self.progen = {
- "target":"nucleo-f103rb",
- }
-
-class NUCLEO_F302R8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F3', 'STM32F302R8']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0705"]
- self.progen = {
- "target":"nucleo-f302r8",
- }
-
-class NUCLEO_F303K8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F3', 'STM32F303K8']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["0775"]
- self.progen = {
- "target":"nucleo-f303k8",
- }
-
-class NUCLEO_F303RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F3', 'STM32F303RE']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0745"]
- self.progen = {
- "target":"nucleo-f303re",
- }
-
-class NUCLEO_F334R8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F3', 'STM32F334R8']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0735"]
- self.progen = {
- "target":"nucleo-f334r8",
- }
-
-class NUCLEO_F401RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F401RE']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0720"]
- self.progen = {
- "target":"nucleo-f401re",
- }
-
-class NUCLEO_F410RB(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F410RB']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0740"]
- self.progen = {
- "target":"nucleo-f410rb",
- }
-
-class NUCLEO_F411RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0740"]
- self.progen = {
- "target":"nucleo-f411re",
- }
-
-class ELMO_F411RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["----"]
-
-class NUCLEO_F446RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F446RE']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0777"]
- self.progen = {
- "target":"nucleo-f446re",
- }
-
-class B96B_F446VE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F446VE']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0840"]
-
-class NUCLEO_F746ZG(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M7F"
- self.extra_labels = ['STM', 'STM32F7', 'STM32F746', 'STM32F746ZG']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.detect_code = ["0816"]
- self.progen = {
- "target":"nucleo-f746zg",
- "iar": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'iar_nucleo_f746zg.ewp.tmpl')],
- }
- }
-
-class NUCLEO_L031K6(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32L0', 'STM32L031K6']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["0790"]
- self.progen = {
- "target":"nucleo-l031k6",
- }
-
-class NUCLEO_L053R8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['STM', 'STM32L0', 'STM32L053R8']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0715"]
- self.progen = {
- "target":"nucleo-l053r8",
- }
-
-class NUCLEO_L073RZ(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['STM', 'STM32L0', 'STM32L073RZ']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0760"]
- self.progen = {
- "target":"nucleo-l073rz",
- }
-
-
-class NUCLEO_L152RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['STM', 'STM32L1', 'STM32L152RE']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0710"]
- self.progen = {
- "target":"nucleo-l152re",
- }
-
-class NUCLEO_L476RG(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32L4', 'STM32L476RG']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO", "MORPHO"]
- self.detect_code = ["0765"]
- self.progen = {
- "target":"nucleo-l476rg",
- }
-
-class STM32F3XX(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4"
- self.extra_labels = ['STM', 'STM32F3XX']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
- self.default_toolchain = "uARM"
-
-class STM32F407(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F4XX']
- self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
-
-class ARCH_MAX(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F407', 'STM32F407VG']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
- self.supported_form_factors = ["ARDUINO"]
- self.macros = ['LSI_VALUE=32000']
- self.progen = {
- "target":"lpc1768",
- }
- def program_cycle_s(self):
- return 2
-
-class DISCO_F051R8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['STM', 'STM32F0', 'STM32F051', 'STM32F051R8']
- self.supported_toolchains = ["GCC_ARM"]
- self.default_toolchain = "uARM"
-
-class DISCO_F100RB(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['STM', 'STM32F1', 'STM32F100RB']
- self.supported_toolchains = ["GCC_ARM"]
- self.default_toolchain = "uARM"
-
-class DISCO_F303VC(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F3', 'STM32F303', 'STM32F303VC']
- self.supported_toolchains = ["GCC_ARM"]
- self.default_toolchain = "uARM"
-
-class DISCO_F334C8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F3', 'STM32F334C8']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.detect_code = ["0810"]
- self.progen = {
- "target":"disco-f334c8",
- }
-
-class DISCO_F407VG(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F407', 'STM32F407VG']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
- self.progen = {
- "target":"disco-f407vg",
- }
- self.default_toolchain = "ARM"
-
-class DISCO_F429ZI(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F429', 'STM32F429ZI']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"disco-f429zi",
- }
-
-class DISCO_F469NI(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F469', 'STM32F469NI']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
- self.detect_code = ["0788"]
- self.progen = {
- "target":"disco-f469ni",
- }
-
-class DISCO_L053C8(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['STM', 'STM32L0', 'STM32L053C8']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"disco-l053c8",
- }
-
-class DISCO_F746NG(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M7F"
- self.extra_labels = ['STM', 'STM32F7', 'STM32F746', 'STM32F746NG']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.detect_code = ["0815"]
- self.progen = {
- "target":"disco-f746ng",
- }
-
-class DISCO_L476VG(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32L4', 'STM32L476VG']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.detect_code = ["0820"]
- self.progen = {
- "target":"disco-l476vg",
- }
-
-class MTS_MDOT_F405RG(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F405RG']
- self.macros = ['HSE_VALUE=26000000', 'OS_CLOCK=48000000']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.is_disk_virtual = True
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"mts-mdot-f405rg",
- }
-
-class MTS_MDOT_F411RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
- self.macros = ['HSE_VALUE=26000000', 'OS_CLOCK=96000000', 'USE_PLL_HSE_EXTC=0', 'VECT_TAB_OFFSET=0x00010000']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"mts-mdot-f411re",
- }
-
- def init_hooks(self, hook, toolchain_name):
- if toolchain_name in ['GCC_ARM', 'ARM_STD', 'ARM_MICRO']:
- hook.hook_add_binary("post", self.combine_bins)
-
- # combine application binary with bootloader
- # bootloader + padding to 64kB + application + md5sum (16 bytes)
+class MTSCode:
@staticmethod
- def combine_bins(t_self, resources, elf, binf):
- loader = os.path.join(TOOLS_BOOTLOADERS, "MTS_MDOT_F411RE", "bootloader.bin")
+ def _combine_bins_helper(target_name, t_self, resources, elf, binf):
+ loader = os.path.join(TOOLS_BOOTLOADERS, target_name, "bootloader.bin")
target = binf + ".tmp"
if not os.path.exists(loader):
print "Can't find bootloader binary: " + loader
@@ -1233,147 +330,15 @@
os.remove(binf)
os.rename(target, binf)
-class MTS_DRAGONFLY_F411RE(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
- self.macros = ['HSE_VALUE=26000000', 'VECT_TAB_OFFSET=0x08010000']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"mts-dragonfly-f411re",
- }
-
- def init_hooks(self, hook, toolchain_name):
- if toolchain_name in ['GCC_ARM', 'ARM_STD', 'ARM_MICRO']:
- hook.hook_add_binary("post", self.combine_bins)
-
- # combine application binary with bootloader
- # bootloader + padding to 64kB + application + md5sum (16 bytes)
@staticmethod
- def combine_bins(t_self, resources, elf, binf):
- loader = os.path.join(TOOLS_BOOTLOADERS, "MTS_DRAGONFLY_F411RE", "bootloader.bin")
- target = binf + ".tmp"
- if not os.path.exists(loader):
- print "Can't find bootloader binary: " + loader
- return
- outbin = open(target, 'w+b')
- part = open(loader, 'rb')
- data = part.read()
- outbin.write(data)
- outbin.write('\xFF' * (64*1024 - len(data)))
- part.close()
- part = open(binf, 'rb')
- data = part.read()
- outbin.write(data)
- part.close()
- outbin.seek(0, 0)
- data = outbin.read()
- outbin.seek(0, 1)
- crc = struct.pack('<I', binascii.crc32(data) & 0xFFFFFFFF)
- outbin.write(crc)
- outbin.close()
- os.remove(binf)
- os.rename(target, binf)
-
-class MOTE_L152RC(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['STM', 'STM32L1', 'STM32L152RC']
- self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.detect_code = ["4100"]
- self.progen = {
- "target":"stm32l151rc",
- }
-class DISCO_F401VC(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F401', 'STM32F401VC']
- self.supported_toolchains = ["GCC_ARM"]
- self.default_toolchain = "GCC_ARM"
+ def combine_bins_mts_dot(t_self, resources, elf, binf):
+ MTSCode._combine_bins_helper("MTS_MDOT_F411RE", t_self, resources, elf, binf)
-class UBLOX_C029(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['STM', 'STM32F4', 'STM32F439', 'STM32F439ZI']
- self.macros = ['HSE_VALUE=24000000', 'HSE_STARTUP_TIMEOUT=5000']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "uARM"
- self.supported_form_factors = ["ARDUINO"]
-
-class NZ32_SC151(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['STM', 'STM32L1', 'STM32L151RC']
- self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"stm32l151rc",
- }
- # After flashing device, how long to delay until we assume program is running
- def program_cycle_s(self):
- return 1.5
-
-
-### Nordic ###
+ @staticmethod
+ def combine_bins_mts_dragonfly(t_self, resources, elf, binf):
+ MTSCode._combine_bins_helper("MTS_DRAGONFLY_F411RE", t_self, resources, elf, binf)
-class MCU_NRF51(Target):
- # the following is a list of possible Nordic softdevices in decreasing order
- # of preference.
- EXPECTED_SOFTDEVICES_WITH_OFFSETS = [
- {
- 'name' : 's130_nrf51_1.0.0_softdevice.hex',
- 'boot' : 's130_nrf51_1.0.0_bootloader.hex',
- 'offset' : 0x1C000
- },
- {
- 'name' : 's110_nrf51822_8.0.0_softdevice.hex',
- 'boot' : 's110_nrf51822_8.0.0_bootloader.hex',
- 'offset' : 0x18000
- },
- {
- 'name' : 's110_nrf51822_7.1.0_softdevice.hex',
- 'boot' : 's110_nrf51822_7.1.0_bootloader.hex',
- 'offset' : 0x16000
- },
- {
- 'name' : 's110_nrf51822_7.0.0_softdevice.hex',
- 'boot' : 's110_nrf51822_7.0.0_bootloader.hex',
- 'offset' : 0x16000
- },
- {
- 'name' : 's110_nrf51822_6.0.0_softdevice.hex',
- 'boot' : 's110_nrf51822_6.0.0_bootloader.hex',
- 'offset' : 0x14000
- }
- ]
- OVERRIDE_BOOTLOADER_FILENAME = "nrf51822_bootloader.hex"
- OUTPUT_EXT = 'hex'
- MERGE_SOFT_DEVICE = True
- MERGE_BOOTLOADER = False
-
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ["NORDIC", "MCU_NRF51", "MCU_NRF51822"]
- self.macros = ['NRF51', 'TARGET_NRF51822']
- self.supported_toolchains = ["ARM", "GCC_ARM"]
- self.is_disk_virtual = True
- self.detect_code = ["1070"]
-
- def program_cycle_s(self):
- return 6
-
- def init_hooks(self, hook, toolchain_name):
- if toolchain_name in ['ARM_STD', 'GCC_ARM']:
- hook.hook_add_binary("post", self.binary_hook)
-
+class MCU_NRF51Code:
@staticmethod
def binary_hook(t_self, resources, elf, binf):
@@ -1423,924 +388,18 @@
with open(binf.replace(".bin", ".hex"), "w") as f:
binh.tofile(f, format='hex')
-
-# 16KB Nordic targets are tight on SRAM using S130 (default) so we
-# introduce two possible options:
-# 1) Use S130 (default) - for this derive from MCU_NRF51_16K
-# 2) Use S110 - for this derive from MCU_NRF51_16K_S110
-# Note that the 'default' option will track the default choice
-# for other Nordic targets, and so can take advantage of other
-# future SoftDevice improvements
-
-# The *_BASE targets should *not* be inherited from, as they do not
-# specify enough for building a target
-
-# 16KB MCU version, e.g. Nordic nRF51822, Seeed Arch BLE, etc.
-class MCU_NRF51_16K_BASE(MCU_NRF51):
- def __init__(self):
- MCU_NRF51.__init__(self)
- self.extra_labels += ['MCU_NORDIC_16K', 'MCU_NRF51_16K']
- self.macros += ['TARGET_MCU_NORDIC_16K', 'TARGET_MCU_NRF51_16K']
-
-# derivative class used to create softdevice+bootloader enabled images
-class MCU_NRF51_16K_BOOT_BASE(MCU_NRF51_16K_BASE):
- def __init__(self):
- MCU_NRF51_16K_BASE.__init__(self)
- self.extra_labels += ['MCU_NRF51_16K_BOOT']
- self.macros += ['TARGET_MCU_NRF51_16K_BOOT', 'TARGET_OTA_ENABLED']
- self.MERGE_SOFT_DEVICE = True
- self.MERGE_BOOTLOADER = True
-
-# derivative class used to create program only images for use with FOTA
-class MCU_NRF51_16K_OTA_BASE(MCU_NRF51_16K_BASE):
- def __init__(self):
- MCU_NRF51_16K_BASE.__init__(self)
- self.extra_labels += ['MCU_NRF51_16K_OTA']
- self.macros += ['TARGET_MCU_NRF51_16K_OTA', 'TARGET_OTA_ENABLED']
- self.MERGE_SOFT_DEVICE = False
-
-class MCU_NRF51_16K(MCU_NRF51_16K_BASE):
- def __init__(self):
- MCU_NRF51_16K_BASE.__init__(self)
- self.extra_labels += ['MCU_NRF51_16K_S130']
- self.macros += ['TARGET_MCU_NRF51_16K_S130']
-
-class MCU_NRF51_S110:
- """ Interface for overwriting the default SoftDevices """
- def __init__(self):
- self.EXPECTED_SOFTDEVICES_WITH_OFFSETS = [
- {
- 'name' : 's110_nrf51822_8.0.0_softdevice.hex',
- 'boot' : 's110_nrf51822_8.0.0_bootloader.hex',
- 'offset' : 0x18000
- },
- {
- 'name' : 's110_nrf51822_7.1.0_softdevice.hex',
- 'boot' : 's110_nrf51822_7.1.0_bootloader.hex',
- 'offset' : 0x16000
- }
- ]
- self.extra_labels += ['MCU_NRF51_16K_S110']
- self.macros += ['TARGET_MCU_NRF51_16K_S110']
-
-class MCU_NRF51_16K_S110(MCU_NRF51_16K_BASE, MCU_NRF51_S110):
- def __init__(self):
- MCU_NRF51_16K_BASE.__init__(self)
- MCU_NRF51_S110.__init__(self)
-
-class MCU_NRF51_16K_BOOT(MCU_NRF51_16K_BOOT_BASE):
- def __init__(self):
- MCU_NRF51_16K_BOOT_BASE.__init__(self)
- self.extra_labels += ['MCU_NRF51_16K_S130']
- self.macros += ['TARGET_MCU_NRF51_16K_S130']
-
-class MCU_NRF51_16K_BOOT_S110(MCU_NRF51_16K_BOOT_BASE, MCU_NRF51_S110):
- def __init__(self):
- MCU_NRF51_16K_BOOT_BASE.__init__(self)
- MCU_NRF51_S110.__init__(self)
-
-class MCU_NRF51_16K_OTA(MCU_NRF51_16K_OTA_BASE):
- def __init__(self):
- MCU_NRF51_16K_OTA_BASE.__init__(self)
- self.extra_labels += ['MCU_NRF51_16K_S130']
- self.macros += ['TARGET_MCU_NRF51_16K_S130']
-
-class MCU_NRF51_16K_OTA_S110(MCU_NRF51_16K_OTA_BASE, MCU_NRF51_S110):
- def __init__(self):
- MCU_NRF51_16K_OTA_BASE.__init__(self)
- MCU_NRF51_S110.__init__(self)
-
-
-# 32KB MCU version, e.g. Nordic nRF51-DK, nRF51-Dongle, etc.
-class MCU_NRF51_32K(MCU_NRF51):
- def __init__(self):
- MCU_NRF51.__init__(self)
- self.extra_labels += ['MCU_NORDIC_32K', 'MCU_NRF51_32K']
- self.macros += ['TARGET_MCU_NORDIC_32K', 'TARGET_MCU_NRF51_32K']
-
-class MCU_NRF51_32K_BOOT(MCU_NRF51_32K):
- def __init__(self):
- MCU_NRF51_32K.__init__(self)
- self.extra_labels += ['MCU_NRF51_32K_BOOT']
- self.macros += ['TARGET_MCU_NRF51_32K_BOOT', 'TARGET_OTA_ENABLED']
- self.MERGE_SOFT_DEVICE = True
- self.MERGE_BOOTLOADER = True
-
-class MCU_NRF51_32K_OTA(MCU_NRF51_32K):
- def __init__(self):
- MCU_NRF51_32K.__init__(self)
- self.extra_labels += ['MCU_NRF51_32K_OTA']
- self.macros += ['TARGET_MCU_NRF51_32K_OTA', 'TARGET_OTA_ENABLED']
- self.MERGE_SOFT_DEVICE = False
-
-#
-# nRF51 based development kits
-#
-
-# This one is special for legacy reasons
-class NRF51822(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
- self.extra_labels += ['NRF51822', 'NRF51822_MKIT']
- self.macros += ['TARGET_NRF51822_MKIT']
- self.progen = {
- "target":"mkit",
- }
-class NRF51822_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['NRF51822', 'NRF51822_MKIT']
- self.macros += ['TARGET_NRF51822_MKIT']
-
-class NRF51822_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['NRF51822', 'NRF51822_MKIT']
- self.macros += ['TARGET_NRF51822_MKIT']
-
-class ARCH_BLE(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"arch-ble",
- }
-
-class ARCH_BLE_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['ARCH_BLE']
- self.macros += ['TARGET_ARCH_BLE']
- self.supported_form_factors = ["ARDUINO"]
-
-class ARCH_BLE_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['ARCH_BLE']
- self.macros += ['TARGET_ARCH_BLE']
- self.supported_form_factors = ["ARDUINO"]
-
-class ARCH_LINK(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
- self.extra_labels += ['ARCH_BLE']
- self.macros += ['TARGET_ARCH_BLE']
- self.supported_form_factors = ["ARDUINO"]
-
-class ARCH_LINK_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['ARCH_BLE', 'ARCH_LINK']
- self.macros += ['TARGET_ARCH_BLE', 'TARGET_ARCH_LINK']
- self.supported_form_factors = ["ARDUINO"]
-
-class ARCH_LINK_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['ARCH_BLE', 'ARCH_LINK']
- self.macros += ['TARGET_ARCH_BLE', 'TARGET_ARCH_LINK']
- self.supported_form_factors = ["ARDUINO"]
-
-class SEEED_TINY_BLE(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
- self.progen = {
- "target":"seed-tinyble",
- }
-
-class SEEED_TINY_BLE_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['SEEED_TINY_BLE']
- self.macros += ['TARGET_SEEED_TINY_BLE']
-
-class SEEED_TINY_BLE_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['SEEED_TINY_BLE']
- self.macros += ['TARGET_SEEED_TINY_BLE']
-
-class HRM1017(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
- self.macros += ['TARGET_NRF_LFCLK_RC']
- self.progen = {
- "target":"hrm1017",
- }
-class HRM1017_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['HRM1017']
- self.macros += ['TARGET_HRM1017', 'TARGET_NRF_LFCLK_RC']
-
-class HRM1017_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['HRM1017']
- self.macros += ['TARGET_HRM1017', 'TARGET_NRF_LFCLK_RC']
-
-class RBLAB_NRF51822(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"rblab-nrf51822",
- }
-
-class RBLAB_NRF51822_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['RBLAB_NRF51822']
- self.macros += ['TARGET_RBLAB_NRF51822']
- self.supported_form_factors = ["ARDUINO"]
-
-class RBLAB_NRF51822_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['RBLAB_NRF51822']
- self.macros += ['TARGET_RBLAB_NRF51822']
- self.supported_form_factors = ["ARDUINO"]
-
-class RBLAB_BLENANO(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
-
-class RBLAB_BLENANO_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['RBLAB_BLENANO']
- self.macros += ['TARGET_RBLAB_BLENANO']
-
-class RBLAB_BLENANO_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['RBLAB_BLENANO']
- self.macros += ['TARGET_RBLAB_BLENANO']
-
-class NRF51822_Y5_MBUG(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
-
-class WALLBOT_BLE(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
-
-class WALLBOT_BLE_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['WALLBOT_BLE']
- self.macros += ['TARGET_WALLBOT_BLE']
-
-class WALLBOT_BLE_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['WALLBOT_BLE']
- self.macros += ['TARGET_WALLBOT_BLE']
-
-class DELTA_DFCM_NNN40(MCU_NRF51_32K):
- def __init__(self):
- MCU_NRF51_32K.__init__(self)
- self.macros += ['TARGET_NRF_LFCLK_RC']
- self.progen = {
- "target":"dfcm-nnn40",
- }
- def program_cycle_s(self):
- return 10
-
-class DELTA_DFCM_NNN40_BOOT(MCU_NRF51_32K_BOOT):
- def __init__(self):
- MCU_NRF51_32K_BOOT.__init__(self)
- self.extra_labels += ['DELTA_DFCM_NNN40']
- self.macros += ['TARGET_DELTA_DFCM_NNN40', 'TARGET_NRF_LFCLK_RC']
- def program_cycle_s(self):
- return 10
-
-class DELTA_DFCM_NNN40_OTA(MCU_NRF51_32K_OTA):
- def __init__(self):
- MCU_NRF51_32K_OTA.__init__(self)
- self.extra_labels += ['DELTA_DFCM_NNN40']
- self.macros += ['TARGET_DELTA_DFCM_NNN40', 'TARGET_NRF_LFCLK_RC']
- def program_cycle_s(self):
- return 10
-
-class NRF51_DK(MCU_NRF51_32K):
- def __init__(self):
- MCU_NRF51_32K.__init__(self)
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"nrf51-dk",
- }
-
-class NRF51_DK_BOOT(MCU_NRF51_32K_BOOT):
- def __init__(self):
- MCU_NRF51_32K_BOOT.__init__(self)
- self.extra_labels += ['NRF51_DK']
- self.macros += ['TARGET_NRF51_DK']
- self.supported_form_factors = ["ARDUINO"]
-
-class NRF51_DK_OTA(MCU_NRF51_32K_OTA):
- def __init__(self):
- MCU_NRF51_32K_OTA.__init__(self)
- self.extra_labels += ['NRF51_DK']
- self.macros += ['TARGET_NRF51_DK']
- self.supported_form_factors = ["ARDUINO"]
-
-class NRF51_DONGLE(MCU_NRF51_32K):
- def __init__(self):
- MCU_NRF51_32K.__init__(self)
- self.progen = {
- "target":"nrf51-dongle",
- }
-
-class NRF51_DONGLE_BOOT(MCU_NRF51_32K_BOOT):
- def __init__(self):
- MCU_NRF51_32K_BOOT.__init__(self)
- self.extra_labels += ['NRF51_DONGLE']
- self.macros += ['TARGET_NRF51_DONGLE']
-
-class NRF51_DONGLE_OTA(MCU_NRF51_32K_OTA):
- def __init__(self):
- MCU_NRF51_32K_OTA.__init__(self)
- self.extra_labels += ['NRF51_DONGLE']
- self.macros += ['TARGET_NRF51_DONGLE']
-
-class NRF51_MICROBIT(MCU_NRF51_16K_S110):
- def __init__(self):
- MCU_NRF51_16K_S110.__init__(self)
- self.macros += ['TARGET_NRF_LFCLK_RC']
-
-class NRF51_MICROBIT_BOOT(MCU_NRF51_16K_BOOT_S110):
- def __init__(self):
- MCU_NRF51_16K_BOOT_S110.__init__(self)
- self.extra_labels += ['NRF51_MICROBIT']
- self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
-
-class NRF51_MICROBIT_OTA(MCU_NRF51_16K_OTA_S110):
- def __init__(self):
- MCU_NRF51_16K_OTA_S110.__init__(self)
- self.extra_labels += ['NRF51_MICROBIT']
- self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
-
-class NRF51_MICROBIT_B(MCU_NRF51_16K):
- def __init__(self):
- MCU_NRF51_16K.__init__(self)
- self.extra_labels += ['NRF51_MICROBIT']
- self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
-
-class NRF51_MICROBIT_B_BOOT(MCU_NRF51_16K_BOOT):
- def __init__(self):
- MCU_NRF51_16K_BOOT.__init__(self)
- self.extra_labels += ['NRF51_MICROBIT']
- self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
-
-class NRF51_MICROBIT_B_OTA(MCU_NRF51_16K_OTA):
- def __init__(self):
- MCU_NRF51_16K_OTA.__init__(self)
- self.extra_labels += ['NRF51_MICROBIT']
- self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
-
-class TY51822R3(MCU_NRF51_32K):
- def __init__(self):
- MCU_NRF51_32K.__init__(self)
- self.macros += ['TARGET_NRF_32MHZ_XTAL']
- self.supported_toolchains = ["ARM", "GCC_ARM"]
-
-class TY51822R3_BOOT(MCU_NRF51_32K_BOOT):
- def __init__(self):
- MCU_NRF51_32K_BOOT.__init__(self)
- self.extra_labels += ['TY51822R3']
- self.macros += ['TARGET_TY51822R3', 'TARGET_NRF_32MHZ_XTAL']
- self.supported_toolchains = ["ARM", "GCC_ARM"]
-
-class TY51822R3_OTA(MCU_NRF51_32K_OTA):
- def __init__(self):
- MCU_NRF51_32K_OTA.__init__(self)
- self.extra_labels += ['NRF51_DK']
- self.macros += ['TARGET_TY51822R3', 'TARGET_NRF_32MHZ_XTAL']
- self.supported_toolchains = ["ARM", "GCC_ARM"]
-
-
-### ARM ###
-
-class ARM_MPS2_Target(Target):
- def __init__(self):
- Target.__init__(self)
-
-class ARM_MPS2_M0(ARM_MPS2_Target):
- def __init__(self):
- ARM_MPS2_Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M0']
- self.macros = ['CMSDK_CM0']
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
-
-class ARM_MPS2_M0P(ARM_MPS2_Target):
- def __init__(self):
- ARM_MPS2_Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M0P']
- self.macros = ['CMSDK_CM0plus']
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
-
-class ARM_MPS2_M1(ARM_MPS2_Target):
- def __init__(self):
- ARM_MPS2_Target.__init__(self)
- self.core = "Cortex-M1"
- self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M1']
- self.macros = ['CMSDK_CM1']
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
-
-class ARM_MPS2_M3(ARM_MPS2_Target):
- def __init__(self):
- ARM_MPS2_Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M3']
- self.macros = ['CMSDK_CM3']
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
-
-class ARM_MPS2_M4(ARM_MPS2_Target):
- def __init__(self):
- ARM_MPS2_Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M4']
- self.macros = ['CMSDK_CM4']
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
+########################################################################################################################
-class ARM_MPS2_M7(ARM_MPS2_Target):
- def __init__(self):
- ARM_MPS2_Target.__init__(self)
- self.core = "Cortex-M7"
- self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M7']
- self.macros = ['CMSDK_CM7']
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
-
-class ARM_IOTSS_Target(Target):
- def __init__(self):
- Target.__init__(self)
-class ARM_IOTSS_BEID(ARM_IOTSS_Target):
- def __init__(self):
- ARM_IOTSS_Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['ARM_SSG', 'IOTSS', 'IOTSS_BEID']
- self.macros = ['CMSDK_BEID']
- self.supported_toolchains = ["ARM"]
- self.default_toolchain = "ARM"
-
-
-### Renesas ###
-
-class RZ_A1H(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-A9"
- self.extra_labels = ['RENESAS', 'MBRZA1H']
- self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
- self.supported_form_factors = ["ARDUINO"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target": "gr-peach",
- "iar": {
- # rewrite generic template, this device needs futher support for FPU in progendef
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'iar_rz_a1h.ewp.tmpl')],
- }
- }
-
- def program_cycle_s(self):
- return 2
-
-class VK_RZ_A1H(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-A9"
- self.extra_labels = ['RENESAS', 'VKRZA1H']
- self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target": "vk-rza1h",
- "iar": {
- # rewrite generic template, this device needs futher support for FPU in progendef
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'iar_rz_a1h.ewp.tmpl')],
- }
- }
-
- def program_cycle_s(self):
- return 2
-
-### Maxim Integrated ###
-
-class MAXWSNENV(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['Maxim', 'MAX32610']
- self.macros = ['__SYSTEM_HFX=24000000']
- self.supported_toolchains = ["GCC_ARM", "IAR", "ARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target": "maxwsnenv",
- }
-
-class MAX32600MBED(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['Maxim', 'MAX32600']
- self.macros = ['__SYSTEM_HFX=24000000']
- self.supported_toolchains = ["GCC_ARM", "IAR", "ARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target": "max32600mbed",
- }
-
-### Silicon Labs ###
-
-class EFM32GG_STK3700(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['Silicon_Labs', 'EFM32']
- self.macros = ['EFM32GG990F1024']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"efm32gg_stk3700", #TODO: add to progen
- }
-
-
-
-class EFM32LG_STK3600(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M3"
- self.extra_labels = ['Silicon_Labs', 'EFM32']
- self.macros = ['EFM32LG990F256']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"efm32lg_stk3600", #TODO: add to progen
- }
-
-
-
-class EFM32WG_STK3800(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['Silicon_Labs', 'EFM32']
- self.macros = ['EFM32WG990F256']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"efm32wg_stk3800", #TODO: add to progen
- }
-
-
-
-class EFM32ZG_STK3200(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Silicon_Labs', 'EFM32']
- self.macros = ['EFM32ZG222F32']
- self.supported_toolchains = ["GCC_ARM", "uARM"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"efm32zg_stk3200", #TODO: add to progen
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-
-class EFM32HG_STK3400(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Silicon_Labs', 'EFM32']
- self.macros = ['EFM32HG322F64']
- self.supported_toolchains = ["GCC_ARM", "uARM"]
- self.default_toolchain = "uARM"
- self.progen = {
- "target":"efm32hg_stk3400", #TODO: add to progen
- "uvision": {
- "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
- }
- }
-
-
-class EFM32PG_STK3401(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4F"
- self.extra_labels = ['Silicon_Labs', 'EFM32']
- self.macros = ['EFM32PG1B200F256GM48']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM", "IAR"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"efm32pg_stk3401", #TODO: add to progen
- }
-
-
-
-##WIZnet
-
-class WIZWIKI_W7500(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['WIZNET', 'W7500x', 'WIZwiki_W7500']
- self.supported_toolchains = ["uARM", "ARM"]
- self.default_toolchain = "ARM"
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"wizwiki_w7500",
- }
-
-class WIZWIKI_W7500P(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['WIZNET', 'W7500x', 'WIZwiki_W7500P']
- self.supported_toolchains = ["uARM", "ARM"]
- self.default_toolchain = "ARM"
- self.supported_form_factors = ["ARDUINO"]
- self.progen = {
- "target":"wizwiki_w7500p", # TODO: add to progen
- }
-
-class WIZWIKI_W7500ECO(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0"
- self.extra_labels = ['WIZNET', 'W7500x', 'WIZwiki_W7500ECO']
- self.supported_toolchains = ["uARM", "ARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"wizwiki_w7500eco", # TODO: add to progen
- }
-
-
-class SAMR21G18A(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Atmel', 'SAM_CortexM0P', 'SAMR21']
- self.macros = ['__SAMR21G18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"samr21g18a",
- }
-
-class SAMD21J18A(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Atmel', 'SAM_CortexM0P', 'SAMD21']
- self.macros = ['__SAMD21J18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"samd21j18a",
- }
-
-class SAMD21G18A(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Atmel', 'SAM_CortexM0P', 'SAMD21']
- self.macros = ['__SAMD21G18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"samd21g18a",
- }
-
-class SAML21J18A(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M0+"
- self.extra_labels = ['Atmel', 'SAM_CortexM0P', 'SAML21']
- self.macros = ['__SAML21J18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"samr21j18a",
- }
- self.progen_target ='samr21j18a'
-
-class SAMG55J19(Target):
- def __init__(self):
- Target.__init__(self)
- self.core = "Cortex-M4"
- self.extra_labels = ['Atmel', 'SAM_CortexM4', 'SAMG55']
- self.macros = ['__SAMG55J19__', 'BOARD=75', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
- self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
- self.default_toolchain = "ARM"
- self.progen = {
- "target":"samg55j19",
- }
- self.progen_target ='samg55j19'
-
-# Get a single instance for each target
-TARGETS = [
-
- ### NXP ###
- LPC11C24(),
- LPC11U24(),
- OC_MBUINO(), # LPC11U24
- LPC11U24_301(),
- LPC11U34_421(),
- MICRONFCBOARD(), # LPC11U34_421
- LPC11U35_401(),
- LPC11U35_501(), # LPC11U35_501
- LPC11U35_501_IBDAP(), # LPC11U35_501
- XADOW_M0(), # LPC11U35_501
- LPC11U35_Y5_MBUG(), # LPC11U35_501
- LPC11U37_501(),
- LPCCAPPUCCINO(), # LPC11U37_501
- ARCH_GPRS(), # LPC11U37_501
- LPC11U68(),
- LPC1114(),
- LPC1347(),
- LPC1549(),
- LPC1768(), # LPC1768
- ARCH_PRO(), # LPC1768
- UBLOX_C027(), # LPC1768
- XBED_LPC1768(), # LPC1768
- LPC2368(),
- LPC2460(),
- LPC810(),
- LPC812(),
- LPC824(),
- SSCI824(), # LPC824
- LPC4088(),
- LPC4088_DM(),
- LPC4330_M4(),
- LPC4330_M0(),
- LPC4337(),
- LPC11U37H_401(),
-
- ### Freescale ###
- KL05Z(),
- KL25Z(),
- KL26Z(),
- KL43Z(),
- KL46Z(),
- K20D50M(),
- K22F(),
- KL27Z(),
- K64F(), # FRDM K64F
- MTS_GAMBIT(),
- HEXIWEAR(),
- TEENSY3_1(),
-
- ### STMicro ###
- B96B_F446VE(),
- NUCLEO_F030R8(),
- NUCLEO_F031K6(),
- NUCLEO_F042K6(),
- NUCLEO_F070RB(),
- NUCLEO_F072RB(),
- NUCLEO_F091RC(),
- NUCLEO_F103RB(),
- NUCLEO_F302R8(),
- NUCLEO_F303K8(),
- NUCLEO_F303RE(),
- NUCLEO_F334R8(),
- NUCLEO_F401RE(),
- NUCLEO_F410RB(),
- NUCLEO_F411RE(),
- NUCLEO_F746ZG(),
- ELMO_F411RE(),
- NUCLEO_F446RE(),
- NUCLEO_L031K6(),
- NUCLEO_L053R8(),
- NUCLEO_L073RZ(),
- NUCLEO_L152RE(),
- NUCLEO_L476RG(),
- STM32F3XX(),
- STM32F407(),
- DISCO_F051R8(),
- DISCO_F100RB(),
- DISCO_F303VC(),
- DISCO_F334C8(),
- DISCO_F746NG(),
- DISCO_F407VG(), # STM32F407
- ARCH_MAX(), # STM32F407
- DISCO_F429ZI(),
- DISCO_F469NI(),
- DISCO_L053C8(),
- DISCO_L476VG(),
- MTS_MDOT_F405RG(),
- MTS_MDOT_F411RE(),
- MOTE_L152RC(),
- MTS_DRAGONFLY_F411RE(),
- DISCO_F401VC(),
- UBLOX_C029(), # STM32F439
- NZ32_SC151(), # STM32L151
-
- ### Nordic ###
- NRF51822(), # nRF51_16K
- NRF51822_BOOT(), # nRF51_16K
- NRF51822_OTA(), # nRF51_16K
- ARCH_BLE(), # nRF51_16K
- ARCH_BLE_BOOT(), # nRF51_16K
- ARCH_BLE_OTA(), # nRF51_16K
- ARCH_LINK(), # nRF51_16K
- ARCH_LINK_BOOT(), # nRF51_16K
- ARCH_LINK_OTA(), # nRF51_16K
- SEEED_TINY_BLE(), # nRF51_16K
- SEEED_TINY_BLE_BOOT(), # nRF51_16K
- SEEED_TINY_BLE_OTA(), # nRF51_16K
- HRM1017(), # nRF51_16K
- HRM1017_BOOT(), # nRF51_16K
- HRM1017_OTA(), # nRF51_16K
- RBLAB_NRF51822(), # nRF51_16K
- RBLAB_NRF51822_BOOT(), # nRF51_16K
- RBLAB_NRF51822_OTA(), # nRF51_16K
- RBLAB_BLENANO(), # nRF51_16K
- RBLAB_BLENANO_BOOT(), # nRF51_16K
- RBLAB_BLENANO_OTA(), # nRF51_16K
- NRF51822_Y5_MBUG(), # nRF51_16K
- WALLBOT_BLE(), # nRF51_16K
- WALLBOT_BLE_BOOT(), # nRF51_16K
- WALLBOT_BLE_OTA(), # nRF51_16K
- DELTA_DFCM_NNN40(), # nRF51_16K
- DELTA_DFCM_NNN40_BOOT(),# nRF51_16K
- DELTA_DFCM_NNN40_OTA(), # nRF51_16K
- NRF51_DK(), # nRF51_32K
- NRF51_DK_BOOT(), # nRF51_32K
- NRF51_DK_OTA(), # nRF51_32K
- NRF51_DONGLE(), # nRF51_32K
- NRF51_DONGLE_BOOT(), # nRF51_32K
- NRF51_DONGLE_OTA(), # nRF51_32K
- NRF51_MICROBIT(), # nRF51_16K - S110
- NRF51_MICROBIT_BOOT(), # nRF51_16K - S110
- NRF51_MICROBIT_OTA(), # nRF51_16K - S110
- NRF51_MICROBIT_B(), # nRF51_16K - default
- NRF51_MICROBIT_B_BOOT(),# nRF51_16K - default
- NRF51_MICROBIT_B_OTA(), # nRF51_16K - default
- TY51822R3(), # nRF51_32K
- TY51822R3_BOOT(), # nRF51_32K
- TY51822R3_OTA(), # nRF51_32K
-
-
- ### ARM ###
- ARM_MPS2_M0(),
- ARM_MPS2_M0P(),
- ARM_MPS2_M1(),
- ARM_MPS2_M3(),
- ARM_MPS2_M4(),
- ARM_MPS2_M7(),
-
- ARM_IOTSS_BEID(),
-
- ### Renesas ###
- RZ_A1H(),
- VK_RZ_A1H(),
-
- ### Maxim Integrated ###
- MAXWSNENV(),
- MAX32600MBED(),
-
- ### Silicon Labs ###
- EFM32GG_STK3700(),
- EFM32LG_STK3600(),
- EFM32WG_STK3800(),
- EFM32ZG_STK3200(),
- EFM32HG_STK3400(),
- EFM32PG_STK3401(),
-
- ### WIZnet ###
- WIZWIKI_W7500(),
- WIZWIKI_W7500P(),
- WIZWIKI_W7500ECO(),
-
- ### Atmel ###
- SAMR21G18A(),
- SAMD21J18A(),
- SAMD21G18A(),
- SAML21J18A(),
- SAMG55J19(),
-
-]
+# Instantiate all public targets
+TARGETS = [Target.get_target(name) for name, value in Target.get_json_target_data().items() if value.get("public", True)]
# Map each target name to its unique instance
-TARGET_MAP = {}
-for t in TARGETS:
- TARGET_MAP[t.name] = t
+TARGET_MAP = dict([(t.name, t) for t in TARGETS])
TARGET_NAMES = TARGET_MAP.keys()
# Some targets with different name have the same exporters
-EXPORT_MAP = { }
+EXPORT_MAP = {}
# Detection APIs
def get_target_detect_codes():