targets.py

00001 """
00002 mbed SDK
00003 Copyright (c) 2011-2016 ARM Limited
00004 
00005 Licensed under the Apache License, Version 2.0 (the "License");
00006 you may not use this file except in compliance with the License.
00007 You may obtain a copy of the License at
00008 
00009 http://www.apache.org/licenses/LICENSE-2.0
00010 
00011 Unless required by applicable law or agreed to in writing, software
00012 distributed under the License is distributed on an "AS IS" BASIS,
00013 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014 See the License for the specific language governing permissions and
00015 limitations under the License.
00016 """
00017 
00018 CORE_LABELS = {
00019     "ARM7TDMI-S": ["ARM7", "LIKE_CORTEX_ARM7"],
00020     "Cortex-M0" : ["M0", "CORTEX_M", "LIKE_CORTEX_M0"],
00021     "Cortex-M0+": ["M0P", "CORTEX_M", "LIKE_CORTEX_M0"],
00022     "Cortex-M1" : ["M1", "CORTEX_M", "LIKE_CORTEX_M1"],
00023     "Cortex-M3" : ["M3", "CORTEX_M", "LIKE_CORTEX_M3"],
00024     "Cortex-M4" : ["M4", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M4"],
00025     "Cortex-M4F" : ["M4", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M4"],
00026     "Cortex-M7" : ["M7", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M7"],
00027     "Cortex-M7F" : ["M7", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M7"],
00028     "Cortex-A9" : ["A9", "CORTEX_A", "LIKE_CORTEX_A9"]
00029 }
00030 
00031 import os
00032 import binascii
00033 import struct
00034 import shutil
00035 from tools.patch import patch
00036 from paths import TOOLS_BOOTLOADERS
00037 
00038 class Target:
00039     def __init__(self):
00040         # ARM Core
00041         self.core = None
00042 
00043         # Is the disk provided by the interface chip of this board virtual?
00044         self.is_disk_virtual = False
00045 
00046         # list of toolchains that are supported by the mbed SDK for this target
00047         self.supported_toolchains = None
00048 
00049         # list of extra specific labels
00050         self.extra_labels = []
00051 
00052         # list of macros (-D)
00053         self.macros = []
00054 
00055         # Default online compiler:
00056         self.default_toolchain = "ARM"
00057 
00058         self.name = self.__class__.__name__
00059 
00060         # Code used to determine devices' platform
00061         # This code is prefix in URL link provided in mbed.htm (in mbed disk)
00062         self.detect_code = []
00063 
00064     def program_cycle_s(self):
00065         return 4 if self.is_disk_virtual else 1.5
00066 
00067     def get_labels(self):
00068         return [self.name] + CORE_LABELS[self.core] + self.extra_labels
00069 
00070     def init_hooks(self, hook, toolchain_name):
00071         pass
00072 
00073 
00074 ### MCU Support ###
00075 
00076 class CM4_UARM(Target):
00077     def __init__(self):
00078         Target.__init__(self)
00079         self.core = "Cortex-M4"
00080         self.supported_toolchains = ["uARM"]
00081         self.default_toolchain = "uARM"
00082 
00083 class CM4_ARM(Target):
00084     def __init__(self):
00085         Target.__init__(self)
00086         self.core = "Cortex-M4"
00087         self.supported_toolchains = ["ARM"]
00088         self.default_toolchain = "ARM"
00089 
00090 class CM4F_UARM(Target):
00091     def __init__(self):
00092         Target.__init__(self)
00093         self.core = "Cortex-M4F"
00094         self.supported_toolchains = ["uARM"]
00095         self.default_toolchain = "uARM"
00096 
00097 class CM4F_ARM(Target):
00098     def __init__(self):
00099         Target.__init__(self)
00100         self.core = "Cortex-M4F"
00101         self.supported_toolchains = ["ARM"]
00102         self.default_toolchain = "ARM"
00103 
00104 
00105 ### NXP ###
00106 
00107 # This class implements the post-link patching step needed by LPC targets
00108 class LPCTarget(Target):
00109     def __init__(self):
00110         Target.__init__(self)
00111 
00112     def init_hooks(self, hook, toolchain_name):
00113         hook.hook_add_binary("post", self.lpc_patch)
00114 
00115     @staticmethod
00116     def lpc_patch(t_self, resources, elf, binf):
00117         t_self.debug("LPC Patch: %s" % os.path.split(binf)[1])
00118         patch(binf)
00119 
00120 class LPC11C24(LPCTarget):
00121     def __init__(self):
00122         LPCTarget.__init__(self)
00123         self.core = "Cortex-M0"
00124         self.extra_labels = ['NXP', 'LPC11XX_11CXX', 'LPC11CXX']
00125         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00126 
00127         self.progen = {
00128             "target":"lpc11c24_301",
00129         }
00130 
00131 class LPC1114(LPCTarget):
00132     def __init__(self):
00133         LPCTarget.__init__(self)
00134         self.core = "Cortex-M0"
00135         self.extra_labels = ['NXP', 'LPC11XX_11CXX', 'LPC11XX']
00136         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00137         self.default_toolchain = "uARM"
00138         self.progen = {
00139             "target":"lpc1114_102",
00140             "uvision": {
00141                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00142             }
00143         }
00144 
00145 class LPC11U24(LPCTarget):
00146     def __init__(self):
00147         LPCTarget.__init__(self)
00148         self.core = "Cortex-M0"
00149         self.extra_labels = ['NXP', 'LPC11UXX', 'LPC11U24_401']
00150         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00151         self.default_toolchain = "uARM"
00152         self.detect_code = ["1040"]
00153         self.progen = {
00154             "target":"lpc11u24_201",
00155             "uvision": {
00156                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00157             }
00158         }
00159 
00160 class OC_MBUINO(LPC11U24):
00161     def __init__(self):
00162         LPC11U24.__init__(self)
00163         self.core = "Cortex-M0"
00164         self.extra_labels = ['NXP', 'LPC11UXX']
00165         self.macros = ['TARGET_LPC11U24']
00166         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00167         self.default_toolchain = "uARM"
00168         self.progen = {
00169             "target":"lpc11u24_201",
00170             "uvision": {
00171                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00172             }
00173         }
00174 
00175 class LPC11U24_301(LPCTarget):
00176     def __init__(self):
00177         LPCTarget.__init__(self)
00178         self.core = "Cortex-M0"
00179         self.extra_labels = ['NXP', 'LPC11UXX']
00180         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00181 
00182 class LPC11U34_421(LPCTarget):
00183     def __init__(self):
00184         LPCTarget.__init__(self)
00185         self.core = "Cortex-M0"
00186         self.extra_labels = ['NXP', 'LPC11UXX']
00187         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
00188         self.default_toolchain = "uARM"
00189 
00190 class MICRONFCBOARD(LPC11U34_421):
00191     def __init__(self):
00192         LPC11U34_421.__init__(self)
00193         self.macros = ['LPC11U34_421', 'APPNEARME_MICRONFCBOARD']
00194         self.extra_labels = ['NXP', 'LPC11UXX', 'APPNEARME_MICRONFCBOARD']
00195         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
00196         self.default_toolchain = "uARM"
00197 
00198 class LPC11U35_401(LPCTarget):
00199     def __init__(self):
00200         LPCTarget.__init__(self)
00201         self.core = "Cortex-M0"
00202         self.extra_labels = ['NXP', 'LPC11UXX']
00203         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00204         self.default_toolchain = "uARM"
00205         self.progen = {
00206             "target":"lpc11u35_401",
00207             "uvision": {
00208                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00209             }
00210         }
00211 
00212 class LPC11U35_501(LPCTarget):
00213     def __init__(self):
00214         LPCTarget.__init__(self)
00215         self.core = "Cortex-M0"
00216         self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
00217         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR" , "IAR"]
00218         self.default_toolchain = "uARM"
00219         self.progen = {
00220             "target":"lpc11u35_501",
00221             "uvision": {
00222                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00223             }
00224         }
00225 
00226 class LPC11U35_501_IBDAP(LPCTarget):
00227     def __init__(self):
00228         LPCTarget.__init__(self)
00229         self.core = "Cortex-M0"
00230         self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
00231         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR" , "IAR"]
00232         self.default_toolchain = "uARM"
00233         self.progen = {
00234             "target":"lpc11u35_501",
00235             "uvision": {
00236                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00237             }
00238         }
00239 
00240 class XADOW_M0(LPCTarget):
00241     def __init__(self):
00242         LPCTarget.__init__(self)
00243         self.core = "Cortex-M0"
00244         self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
00245         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00246         self.default_toolchain = "uARM"
00247         self.progen = {
00248             "target":"lpc11u35_501",
00249             "uvision": {
00250                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00251             }
00252         }
00253 
00254 class LPC11U35_Y5_MBUG(LPCTarget):
00255     def __init__(self):
00256         LPCTarget.__init__(self)
00257         self.core = "Cortex-M0"
00258         self.extra_labels = ['NXP', 'LPC11UXX', 'MCU_LPC11U35_501']
00259         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR" , "IAR"]
00260         self.default_toolchain = "uARM"
00261         self.progen = {
00262             "target":"lpc11u35_501",
00263             "uvision": {
00264                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00265             }
00266         }
00267 
00268 class LPC11U37_501(LPCTarget):
00269     def __init__(self):
00270         LPCTarget.__init__(self)
00271         self.core = "Cortex-M0"
00272         self.extra_labels = ['NXP', 'LPC11UXX']
00273         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00274         self.default_toolchain = "uARM"
00275         self.progen = {
00276             "target":"lpc11u37_501",
00277             "uvision": {
00278                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00279             }
00280         }
00281 
00282 class LPCCAPPUCCINO(LPC11U37_501):
00283     def __init__(self):
00284         LPC11U37_501.__init__(self)
00285 
00286 class ARCH_GPRS(LPCTarget):
00287     def __init__(self):
00288         LPCTarget.__init__(self)
00289         self.core = "Cortex-M0"
00290         self.extra_labels = ['NXP', 'LPC11UXX', 'LPC11U37_501']
00291         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00292         self.default_toolchain = "uARM"
00293         self.supported_form_factors = ["ARDUINO"]
00294         self.progen = {
00295             "target":"lpc11u37_501",
00296             "uvision": {
00297                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00298             }
00299         }
00300 
00301 class LPC11U68(LPCTarget):
00302     def __init__(self):
00303         LPCTarget.__init__(self)
00304         self.core = "Cortex-M0+"
00305         self.extra_labels = ['NXP', 'LPC11U6X']
00306         self.supported_toolchains = ["ARM", "uARM", "GCC_CR", "GCC_ARM", "IAR"]
00307         self.default_toolchain = "uARM"
00308         self.supported_form_factors = ["ARDUINO"]
00309         self.detect_code = ["1168"]
00310         self.progen = {
00311             "target":"lpc11u68",
00312             "uvision": {
00313                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00314             }
00315         }
00316 
00317 class LPC1347(LPCTarget):
00318     def __init__(self):
00319         LPCTarget.__init__(self)
00320         self.core = "Cortex-M3"
00321         self.extra_labels = ['NXP', 'LPC13XX']
00322         self.supported_toolchains = ["ARM", "GCC_ARM","IAR"]
00323         self.progen = {
00324             "target":"lpc1347",
00325         }
00326 
00327 class LPC1549(LPCTarget):
00328     def __init__(self):
00329         LPCTarget.__init__(self)
00330         self.core = "Cortex-M3"
00331         self.extra_labels = ['NXP', 'LPC15XX']
00332         self.supported_toolchains = ["uARM", "GCC_CR", "GCC_ARM", "IAR"]
00333         self.default_toolchain = "uARM"
00334         self.supported_form_factors = ["ARDUINO"]
00335         self.detect_code = ["1549"]
00336         self.progen = {
00337             "target":"lpc1549",
00338             "uvision": {
00339                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00340             }
00341         }
00342 
00343 class LPC1768(LPCTarget):
00344     def __init__(self):
00345         LPCTarget.__init__(self)
00346         self.core = "Cortex-M3"
00347         self.extra_labels = ['NXP', 'LPC176X', 'MBED_LPC1768']
00348         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00349         self.detect_code = ["1010"]
00350         self.progen = {
00351             "target":"mbed-lpc1768",
00352         }
00353 
00354 class ARCH_PRO(LPCTarget):
00355     def __init__(self):
00356         LPCTarget.__init__(self)
00357         self.core = "Cortex-M3"
00358         self.extra_labels = ['NXP', 'LPC176X']
00359         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00360         self.macros = ['TARGET_LPC1768']
00361         self.supported_form_factors = ["ARDUINO"]
00362         self.progen = {
00363             "target":"arch-pro",
00364         }
00365 
00366 class UBLOX_C027(LPCTarget):
00367     def __init__(self):
00368         LPCTarget.__init__(self)
00369         self.core = "Cortex-M3"
00370         self.extra_labels = ['NXP', 'LPC176X']
00371         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00372         self.macros = ['TARGET_LPC1768']
00373         self.supported_form_factors = ["ARDUINO"]
00374         self.progen = {
00375             "target":"ublox-c027",
00376         }
00377 
00378 class XBED_LPC1768(LPCTarget):
00379     def __init__(self):
00380         LPCTarget.__init__(self)
00381         self.core = "Cortex-M3"
00382         self.extra_labels = ['NXP', 'LPC176X', 'XBED_LPC1768']
00383         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR", "IAR"]
00384         self.macros = ['TARGET_LPC1768']
00385         self.detect_code = ["1010"]
00386         self.progen = {
00387             "target":"lpc1768",
00388         }
00389 
00390 class LPC2368(LPCTarget):
00391     def __init__(self):
00392         LPCTarget.__init__(self)
00393         self.core = "ARM7TDMI-S"
00394         self.extra_labels = ['NXP', 'LPC23XX']
00395         self.supported_toolchains = ["ARM", "GCC_ARM", "GCC_CR"]
00396         self.progen = {
00397             "target":"lpc2368",
00398         }
00399 
00400 class LPC2460(LPCTarget):
00401     def __init__(self):
00402         LPCTarget.__init__(self)
00403         self.core = "ARM7TDMI-S"
00404         self.extra_labels = ['NXP', 'LPC2460']
00405         self.supported_toolchains = ["GCC_ARM"]
00406         self.progen = {
00407             "target":"lpc2460",
00408         }
00409 
00410 class LPC810(LPCTarget):
00411     def __init__(self):
00412         LPCTarget.__init__(self)
00413         self.core = "Cortex-M0+"
00414         self.extra_labels = ['NXP', 'LPC81X']
00415         self.supported_toolchains = ["uARM", "IAR", "GCC_ARM"]
00416         self.default_toolchain = "uARM"
00417         self.is_disk_virtual = True
00418         self.progen = {
00419             "target":"lpc810",
00420             "uvision": {
00421                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00422             }
00423         }
00424 
00425 class LPC812(LPCTarget):
00426     def __init__(self):
00427         LPCTarget.__init__(self)
00428         self.core = "Cortex-M0+"
00429         self.extra_labels = ['NXP', 'LPC81X']
00430         self.supported_toolchains = ["uARM", "IAR", "GCC_ARM"]
00431         self.default_toolchain = "uARM"
00432         self.supported_form_factors = ["ARDUINO"]
00433         self.is_disk_virtual = True
00434         self.detect_code = ["1050"]
00435         self.progen = {
00436             "target":"lpc812m101",
00437             "uvision": {
00438                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00439             }
00440         }
00441 
00442 class LPC824(LPCTarget):
00443     def __init__(self):
00444         LPCTarget.__init__(self)
00445         self.core = "Cortex-M0+"
00446         self.extra_labels = ['NXP', 'LPC82X']
00447         self.supported_toolchains = ["uARM", "GCC_ARM","GCC_CR", "IAR"]
00448         self.default_toolchain = "uARM"
00449         self.supported_form_factors = ["ARDUINO"]
00450         self.is_disk_virtual = True
00451         self.progen = {
00452             "target":"lpc824m201",
00453             "uvision": {
00454                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00455             }
00456         }
00457 
00458 class SSCI824(LPCTarget):
00459     def __init__(self):
00460         LPCTarget.__init__(self)
00461         self.core = "Cortex-M0+"
00462         self.extra_labels = ['NXP', 'LPC82X']
00463         self.supported_toolchains = ["uARM", "GCC_ARM"]
00464         self.default_toolchain = "uARM"
00465         self.is_disk_virtual = True
00466         self.progen = {
00467             "target":"ssci824",
00468             "uvision": {
00469                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00470             }
00471         }
00472 
00473 class LPC4088(LPCTarget):
00474     def __init__(self):
00475         LPCTarget.__init__(self)
00476         self.core = "Cortex-M4F"
00477         self.extra_labels = ['NXP', 'LPC408X']
00478         self.supported_toolchains = ["ARM", "GCC_CR", "GCC_ARM", "IAR"]
00479         self.is_disk_virtual = True
00480         self.progen = {
00481             "target":"lpc4088",
00482         }
00483 
00484     def init_hooks(self, hook, toolchain_name):
00485         if toolchain_name in ['ARM_STD', 'ARM_MICRO']:
00486             hook.hook_add_binary("post", self.binary_hook)
00487 
00488     @staticmethod
00489     def binary_hook(t_self, resources, elf, binf):
00490         if not os.path.isdir(binf):
00491             # Regular binary file, nothing to do
00492             LPCTarget.lpc_patch(t_self, resources, elf, binf)
00493             return
00494         outbin = open(binf + ".temp", "wb")
00495         partf = open(os.path.join(binf, "ER_IROM1"), "rb")
00496         # Pad the fist part (internal flash) with 0xFF to 512k
00497         data = partf.read()
00498         outbin.write(data)
00499         outbin.write('\xFF' * (512*1024 - len(data)))
00500         partf.close()
00501         # Read and append the second part (external flash) in chunks of fixed size
00502         chunksize = 128 * 1024
00503         partf = open(os.path.join(binf, "ER_IROM2"), "rb")
00504         while True:
00505             data = partf.read(chunksize)
00506             outbin.write(data)
00507             if len(data) < chunksize:
00508                 break
00509         partf.close()
00510         outbin.close()
00511         # Remove the directory with the binary parts and rename the temporary
00512         # file to 'binf'
00513         shutil.rmtree(binf, True)
00514         os.rename(binf + '.temp', binf)
00515         t_self.debug("Generated custom binary file (internal flash + SPIFI)")
00516         LPCTarget.lpc_patch(t_self, resources, elf, binf)
00517 
00518 class LPC4088_DM(LPC4088):
00519     pass
00520 
00521 class LPC4330_M4(LPCTarget):
00522     def __init__(self):
00523         LPCTarget.__init__(self)
00524         self.core = "Cortex-M4F"
00525         self.extra_labels = ['NXP', 'LPC43XX', 'LPC4330']
00526         self.supported_toolchains = ["ARM", "GCC_CR", "IAR", "GCC_ARM"]
00527         self.progen = {
00528             "target":"lpc4330",
00529         }
00530 
00531 class LPC4330_M0(LPCTarget):
00532     def __init__(self):
00533         LPCTarget.__init__(self)
00534         self.core = "Cortex-M0"
00535         self.extra_labels = ['NXP', 'LPC43XX', 'LPC4330']
00536         self.supported_toolchains = ["ARM", "GCC_CR", "IAR"]
00537 
00538 class LPC4337(LPCTarget):
00539     def __init__(self):
00540         Target.__init__(self)
00541         self.core = "Cortex-M4F"
00542         self.extra_labels = ['NXP', 'LPC43XX', 'LPC4337']
00543         self.supported_toolchains = ["ARM"]
00544         self.progen = {
00545             "target":"lpc4337",
00546         }
00547 
00548 class LPC1800(LPCTarget):
00549     def __init__(self):
00550         LPCTarget.__init__(self)
00551         self.core = "Cortex-M3"
00552         self.extra_labels = ['NXP', 'LPC43XX']
00553         self.supported_toolchains = ["ARM", "GCC_CR", "IAR"]
00554 
00555 class LPC11U37H_401(LPCTarget):
00556     def __init__(self):
00557         LPCTarget.__init__(self)
00558         self.core = "Cortex-M0"
00559         self.extra_labels = ['NXP', 'LPC11UXX']
00560         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "GCC_CR"]
00561         self.default_toolchain = "uARM"
00562         self.supported_form_factors = ["ARDUINO"]
00563         self.progen = {
00564             "target":"lpc11u37_401",
00565             "uvision": {
00566                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00567             }
00568         }
00569 ### Freescale ###
00570 
00571 class KL05Z(Target):
00572     def __init__(self):
00573         Target.__init__(self)
00574         self.core = "Cortex-M0+"
00575         self.extra_labels = ['Freescale', 'KLXX']
00576         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00577         self.default_toolchain = "uARM"
00578         self.supported_form_factors = ["ARDUINO"]
00579         self.is_disk_virtual = True
00580         self.progen = {
00581             "target":"frdm-kl05z",
00582             "uvision": {
00583                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
00584             }
00585         }
00586 
00587 class KL25Z(Target):
00588     def __init__(self):
00589         Target.__init__(self)
00590         self.core = "Cortex-M0+"
00591         self.extra_labels = ['Freescale', 'KLXX']
00592         self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
00593         self.supported_form_factors = ["ARDUINO"]
00594         self.is_disk_virtual = True
00595         self.detect_code = ["0200"]
00596         self.progen = {
00597             "target":"frdm-kl25z",
00598         }
00599 
00600 class KL26Z(Target):
00601     def __init__(self):
00602         Target.__init__(self)
00603         self.core = "Cortex-M0+"
00604         self.extra_labels = ['Freescale', 'KLXX']
00605         self.supported_toolchains = ["ARM","GCC_ARM","IAR"]
00606         self.supported_form_factors = ["ARDUINO"]
00607         self.is_disk_virtual = True
00608         self.progen = {
00609             "target":"kl26z",
00610         }
00611 
00612 class KL43Z(Target):
00613     def __init__(self):
00614         Target.__init__(self)
00615         self.core = "Cortex-M0+"
00616         self.extra_labels = ['Freescale', 'KLXX']
00617         self.supported_toolchains = ["GCC_ARM", "ARM"]
00618         self.supported_form_factors = ["ARDUINO"]
00619         self.is_disk_virtual = True
00620         self.progen = {
00621             "target":"frdm-kl43z",
00622         }
00623 
00624 class KL46Z(Target):
00625     def __init__(self):
00626         Target.__init__(self)
00627         self.core = "Cortex-M0+"
00628         self.extra_labels = ['Freescale', 'KLXX']
00629         self.supported_toolchains = ["GCC_ARM", "ARM", "IAR"]
00630         self.supported_form_factors = ["ARDUINO"]
00631         self.is_disk_virtual = True
00632         self.detect_code = ["0220"]
00633         self.progen = {
00634             "target":"frdm-kl46z",
00635         }
00636 
00637 class K20D50M(Target):
00638     def __init__(self):
00639         Target.__init__(self)
00640         self.core = "Cortex-M4"
00641         self.extra_labels = ['Freescale', 'K20XX']
00642         self.supported_toolchains = ["GCC_ARM", "ARM", "IAR"]
00643         self.is_disk_virtual = True
00644         self.detect_code = ["0230"]
00645         self.progen = {
00646             "target":"frdm-k20d50m",
00647         }
00648 
00649 class TEENSY3_1(Target):
00650     OUTPUT_EXT = 'hex'
00651 
00652     def __init__(self):
00653         Target.__init__(self)
00654         self.core = "Cortex-M4"
00655         self.extra_labels = ['Freescale', 'K20XX', 'K20DX256']
00656         self.supported_toolchains = ["GCC_ARM", "ARM"]
00657         self.is_disk_virtual = True
00658         self.detect_code = ["0230"]
00659         self.progen = {
00660             "target":"teensy-31",
00661         }
00662 
00663     def init_hooks(self, hook, toolchain_name):
00664         if toolchain_name in ['ARM_STD', 'ARM_MICRO', 'GCC_ARM']:
00665             hook.hook_add_binary("post", self.binary_hook)
00666 
00667     @staticmethod
00668     def binary_hook(t_self, resources, elf, binf):
00669         from intelhex import IntelHex
00670         binh = IntelHex()
00671         binh.loadbin(binf, offset = 0)
00672 
00673         with open(binf.replace(".bin", ".hex"), "w") as f:
00674             binh.tofile(f, format='hex')
00675 
00676 class K22F(Target):
00677     def __init__(self):
00678         Target.__init__(self)
00679         self.core = "Cortex-M4F"
00680         self.extra_labels = ['Freescale', 'KPSDK_MCUS', 'KPSDK_CODE']
00681         self.macros = ["CPU_MK22FN512VLH12", "FSL_RTOS_MBED"]
00682         self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
00683         self.supported_form_factors = ["ARDUINO"]
00684         self.is_disk_virtual = True
00685         self.detect_code = ["0201"]
00686         self.progen = {
00687             "target":"frdm-k22f",
00688         }
00689 
00690 class K64F(Target):
00691     def __init__(self):
00692         Target.__init__(self)
00693         self.core = "Cortex-M4F"
00694         self.extra_labels = ['Freescale', 'KPSDK_MCUS', 'KPSDK_CODE', 'MCU_K64F', 'FRDM']
00695         self.macros = ["CPU_MK64FN1M0VMD12", "FSL_RTOS_MBED"]
00696         self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
00697         self.supported_form_factors = ["ARDUINO"]
00698         self.is_disk_virtual = True
00699         self.default_toolchain = "ARM"
00700         self.detect_code = ["0240"]
00701         self.progen = {
00702             "target":"frdm-k64f",
00703         }
00704 
00705 class K64F_UV(K64F):
00706     def __init__(self):
00707         K64F.__init__(self)
00708         self.core = "Cortex-M4"
00709         self.extra_labels += ['K64F']
00710         self.macros += ['TARGET_K64F']
00711 
00712 class MTS_GAMBIT(Target):
00713     def __init__(self):
00714         Target.__init__(self)
00715         self.core = "Cortex-M4F"
00716         self.extra_labels = ['Freescale', 'KPSDK_MCUS', 'KPSDK_CODE', 'MCU_K64F']
00717         self.supported_toolchains = ["ARM", "GCC_ARM"]
00718         self.macros = ["CPU_MK64FN1M0VMD12", "FSL_RTOS_MBED", "TARGET_K64F"]
00719         self.is_disk_virtual = True
00720         self.default_toolchain = "ARM"
00721         self.progen = {
00722             "target":"mts-gambit",
00723         }
00724 
00725 ### STMicro ###
00726 
00727 class NUCLEO_F030R8(Target):
00728     def __init__(self):
00729         Target.__init__(self)
00730         self.core = "Cortex-M0"
00731         self.extra_labels = ['STM', 'STM32F0', 'STM32F030R8']
00732         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00733         self.default_toolchain = "uARM"
00734         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00735         self.detect_code = ["0725"]
00736         self.progen = {
00737             "target":"nucleo-f030r8",
00738         }
00739 
00740 class NUCLEO_F031K6(Target):
00741     def __init__(self):
00742         Target.__init__(self)
00743         self.core = "Cortex-M0"
00744         self.extra_labels = ['STM', 'STM32F0', 'STM32F031K6']
00745         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00746         self.default_toolchain = "uARM"
00747         self.supported_form_factors = ["ARDUINO"]
00748         self.detect_code = ["0791"]
00749         self.progen = {
00750             "target":"nucleo-f031k6",
00751         }
00752 
00753 class NUCLEO_F042K6(Target):
00754     def __init__(self):
00755         Target.__init__(self)
00756         self.core = "Cortex-M0"
00757         self.extra_labels = ['STM', 'STM32F0', 'STM32F042K6']
00758         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00759         self.default_toolchain = "uARM"
00760         self.supported_form_factors = ["ARDUINO"]
00761         self.detect_code = ["0785"]
00762         self.progen = {
00763             "target":"nucleo-f042k6",
00764         }
00765 
00766 class NUCLEO_F070RB(Target):
00767     def __init__(self):
00768         Target.__init__(self)
00769         self.core = "Cortex-M0"
00770         self.extra_labels = ['STM', 'STM32F0', 'STM32F070RB']
00771         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00772         self.default_toolchain = "uARM"
00773         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00774         self.detect_code = ["0755"]
00775         self.progen = {
00776             "target":"nucleo-f070rb",
00777         }
00778 
00779 class NUCLEO_F072RB(Target):
00780     def __init__(self):
00781         Target.__init__(self)
00782         self.core = "Cortex-M0"
00783         self.extra_labels = ['STM', 'STM32F0', 'STM32F072RB']
00784         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00785         self.default_toolchain = "uARM"
00786         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00787         self.detect_code = ["0730"]
00788         self.progen = {
00789             "target":"nucleo-f072rb",
00790         }
00791 
00792 class NUCLEO_F091RC(Target):
00793     def __init__(self):
00794         Target.__init__(self)
00795         self.core = "Cortex-M0"
00796         self.extra_labels = ['STM', 'STM32F0', 'STM32F091RC']
00797         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00798         self.default_toolchain = "uARM"
00799         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00800         self.detect_code = ["0750"]
00801         self.progen = {
00802             "target":"nucleo-f091rc",
00803         }
00804 
00805 class NUCLEO_F103RB(Target):
00806     def __init__(self):
00807         Target.__init__(self)
00808         self.core = "Cortex-M3"
00809         self.extra_labels = ['STM', 'STM32F1', 'STM32F103RB']
00810         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00811         self.default_toolchain = "uARM"
00812         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00813         self.detect_code = ["0700"]
00814         self.progen = {
00815             "target":"nucleo-f103rb",
00816         }
00817 
00818 class NUCLEO_F302R8(Target):
00819     def __init__(self):
00820         Target.__init__(self)
00821         self.core = "Cortex-M4F"
00822         self.extra_labels = ['STM', 'STM32F3', 'STM32F302R8']
00823         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00824         self.default_toolchain = "uARM"
00825         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00826         self.detect_code = ["0705"]
00827         self.progen = {
00828             "target":"nucleo-f302r8",
00829         }
00830 
00831 class NUCLEO_F303K8(Target):
00832     def __init__(self):
00833         Target.__init__(self)
00834         self.core = "Cortex-M4F"
00835         self.extra_labels = ['STM', 'STM32F3', 'STM32F303K8']
00836         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00837         self.default_toolchain = "uARM"
00838         self.supported_form_factors = ["ARDUINO"]
00839         self.detect_code = ["0775"]
00840         self.progen = {
00841             "target":"nucleo-f303k8",
00842         }
00843 
00844 class NUCLEO_F303RE(Target):
00845     def __init__(self):
00846         Target.__init__(self)
00847         self.core = "Cortex-M4F"
00848         self.extra_labels = ['STM', 'STM32F3', 'STM32F303RE']
00849         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00850         self.default_toolchain = "uARM"
00851         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00852         self.detect_code = ["0745"]
00853         self.progen = {
00854             "target":"nucleo-f303re",
00855         }
00856 
00857 class NUCLEO_F334R8(Target):
00858     def __init__(self):
00859         Target.__init__(self)
00860         self.core = "Cortex-M4F"
00861         self.extra_labels = ['STM', 'STM32F3', 'STM32F334R8']
00862         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00863         self.default_toolchain = "uARM"
00864         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00865         self.detect_code = ["0735"]
00866         self.progen = {
00867             "target":"nucleo-f334r8",
00868         }
00869 
00870 class NUCLEO_F401RE(Target):
00871     def __init__(self):
00872         Target.__init__(self)
00873         self.core = "Cortex-M4F"
00874         self.extra_labels = ['STM', 'STM32F4', 'STM32F401RE']
00875         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00876         self.default_toolchain = "uARM"
00877         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00878         self.detect_code = ["0720"]
00879         self.progen = {
00880             "target":"nucleo-f401re",
00881         }
00882 
00883 class NUCLEO_F410RB(Target):
00884     def __init__(self):
00885         Target.__init__(self)
00886         self.core = "Cortex-M4F"
00887         self.extra_labels = ['STM', 'STM32F4', 'STM32F410RB']
00888         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00889         self.default_toolchain = "uARM"
00890         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00891         self.detect_code = ["0740"]
00892         self.progen = {
00893             "target":"nucleo-f410rb",
00894         }
00895 
00896 class NUCLEO_F411RE(Target):
00897     def __init__(self):
00898         Target.__init__(self)
00899         self.core = "Cortex-M4F"
00900         self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
00901         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00902         self.default_toolchain = "uARM"
00903         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00904         self.detect_code = ["0740"]
00905         self.progen = {
00906             "target":"nucleo-f411re",
00907         }
00908 
00909 class ELMO_F411RE(Target):
00910     def __init__(self):
00911         Target.__init__(self)
00912         self.core = "Cortex-M4F"
00913         self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
00914         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
00915         self.default_toolchain = "uARM"
00916         self.supported_form_factors = ["ARDUINO"]
00917         self.detect_code = ["----"]
00918 
00919 class NUCLEO_F446RE(Target):
00920     def __init__(self):
00921         Target.__init__(self)
00922         self.core = "Cortex-M4F"
00923         self.extra_labels = ['STM', 'STM32F4', 'STM32F446RE']
00924         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00925         self.default_toolchain = "uARM"
00926         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00927         self.detect_code = ["0777"]
00928         self.progen = {
00929             "target":"nucleo-f446re",
00930         }
00931 
00932 class B96B_F446VE(Target):
00933     def __init__(self):
00934         Target.__init__(self)
00935         self.core = "Cortex-M4F"
00936         self.extra_labels = ['STM', 'STM32F4', 'STM32F446VE']
00937         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00938         self.default_toolchain = "uARM"
00939         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00940         self.detect_code = ["0840"]
00941 
00942 class NUCLEO_F746ZG(Target):
00943     def __init__(self):
00944         Target.__init__(self)
00945         self.core = "Cortex-M7F"
00946         self.extra_labels = ['STM', 'STM32F7', 'STM32F746', 'STM32F746ZG']
00947         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00948         self.detect_code = ["0816"]
00949         self.progen = {
00950             "target":"nucleo-f746zg",
00951             "iar": {
00952                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'iar_nucleo_f746zg.ewp.tmpl')],
00953             }
00954         }
00955 
00956 class NUCLEO_L053R8(Target):
00957     def __init__(self):
00958         Target.__init__(self)
00959         self.core = "Cortex-M0+"
00960         self.extra_labels = ['STM', 'STM32L0', 'STM32L053R8']
00961         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00962         self.default_toolchain = "uARM"
00963         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00964         self.detect_code = ["0715"]
00965         self.progen = {
00966             "target":"nucleo-l053r8",
00967         }
00968 
00969 class NUCLEO_L073RZ(Target):
00970     def __init__(self):
00971         Target.__init__(self)
00972         self.core = "Cortex-M0+"
00973         self.extra_labels = ['STM', 'STM32L0', 'STM32L073RZ']
00974         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
00975         self.default_toolchain = "uARM"
00976         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00977         self.detect_code = ["0760"]
00978         self.progen = {
00979             "target":"nucleo-l073rz",
00980         }
00981 
00982 class NUCLEO_L152RE(Target):
00983     def __init__(self):
00984         Target.__init__(self)
00985         self.core = "Cortex-M3"
00986         self.extra_labels = ['STM', 'STM32L1', 'STM32L152RE']
00987         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
00988         self.default_toolchain = "uARM"
00989         self.supported_form_factors = ["ARDUINO", "MORPHO"]
00990         self.detect_code = ["0710"]
00991         self.progen = {
00992             "target":"nucleo-l152re",
00993         }
00994 
00995 class NUCLEO_L476RG(Target):
00996     def __init__(self):
00997         Target.__init__(self)
00998         self.core = "Cortex-M4F"
00999         self.extra_labels = ['STM', 'STM32L4', 'STM32L476RG']
01000         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
01001         self.default_toolchain = "uARM"
01002         self.supported_form_factors = ["ARDUINO", "MORPHO"]
01003         self.detect_code = ["0765"]
01004         self.progen = {
01005             "target":"nucleo-l476rg",
01006         }
01007 
01008 class STM32F3XX(Target):
01009     def __init__(self):
01010         Target.__init__(self)
01011         self.core = "Cortex-M4"
01012         self.extra_labels = ['STM', 'STM32F3XX']
01013         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
01014         self.default_toolchain = "uARM"
01015 
01016 class STM32F407(Target):
01017     def __init__(self):
01018         Target.__init__(self)
01019         self.core = "Cortex-M4F"
01020         self.extra_labels = ['STM', 'STM32F4', 'STM32F4XX']
01021         self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
01022 
01023 class ARCH_MAX(Target):
01024     def __init__(self):
01025         Target.__init__(self)
01026         self.core = "Cortex-M4F"
01027         self.extra_labels = ['STM', 'STM32F4', 'STM32F407', 'STM32F407VG']
01028         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
01029         self.supported_form_factors = ["ARDUINO"]
01030         self.macros = ['LSI_VALUE=32000']
01031         self.progen = {
01032             "target":"lpc1768",
01033         }
01034     def program_cycle_s(self):
01035         return 2
01036 
01037 class DISCO_F051R8(Target):
01038     def __init__(self):
01039         Target.__init__(self)
01040         self.core = "Cortex-M0"
01041         self.extra_labels = ['STM', 'STM32F0', 'STM32F051', 'STM32F051R8']
01042         self.supported_toolchains = ["GCC_ARM"]
01043         self.default_toolchain = "uARM"
01044 
01045 class DISCO_F100RB(Target):
01046     def __init__(self):
01047         Target.__init__(self)
01048         self.core = "Cortex-M3"
01049         self.extra_labels = ['STM', 'STM32F1', 'STM32F100RB']
01050         self.supported_toolchains = ["GCC_ARM"]
01051         self.default_toolchain = "uARM"
01052 
01053 class DISCO_F303VC(Target):
01054     def __init__(self):
01055         Target.__init__(self)
01056         self.core = "Cortex-M4F"
01057         self.extra_labels = ['STM', 'STM32F3', 'STM32F303', 'STM32F303VC']
01058         self.supported_toolchains = ["GCC_ARM"]
01059         self.default_toolchain = "uARM"
01060 
01061 class DISCO_F334C8(Target):
01062     def __init__(self):
01063         Target.__init__(self)
01064         self.core = "Cortex-M4F"
01065         self.extra_labels = ['STM', 'STM32F3', 'STM32F334C8']
01066         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
01067         self.default_toolchain = "uARM"
01068         self.detect_code = ["0810"]
01069         self.progen = {
01070             "target":"disco-f334c8",
01071         }
01072 
01073 class DISCO_F407VG(Target):
01074     def __init__(self):
01075         Target.__init__(self)
01076         self.core = "Cortex-M4F"
01077         self.extra_labels = ['STM', 'STM32F4', 'STM32F407', 'STM32F407VG']
01078         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
01079         self.progen = {
01080             "target":"disco-f407vg",
01081         }
01082         self.default_toolchain = "ARM"
01083 
01084 class DISCO_F429ZI(Target):
01085     def __init__(self):
01086         Target.__init__(self)
01087         self.core = "Cortex-M4F"
01088         self.extra_labels = ['STM', 'STM32F4', 'STM32F429', 'STM32F429ZI']
01089         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
01090         self.default_toolchain = "uARM"
01091         self.progen = {
01092             "target":"",
01093         }
01094 
01095 class DISCO_F469NI(Target):
01096     def __init__(self):
01097         Target.__init__(self)
01098         self.core = "Cortex-M4F"
01099         self.extra_labels = ['STM', 'STM32F4', 'STM32F469', 'STM32F469NI']
01100         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
01101         self.default_toolchain = "uARM"
01102         self.supported_form_factors = ["ARDUINO"]
01103         self.detect_code = ["0788"]
01104         self.progen = {
01105             "target":"disco-f469ni",
01106         }
01107 
01108 class DISCO_L053C8(Target):
01109     def __init__(self):
01110         Target.__init__(self)
01111         self.core = "Cortex-M0+"
01112         self.extra_labels = ['STM', 'STM32L0', 'STM32L053C8']
01113         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
01114         self.default_toolchain = "uARM"
01115         self.progen = {
01116             "target":"disco-l053c8",
01117         }
01118 
01119 class DISCO_F746NG(Target):
01120     def __init__(self):
01121         Target.__init__(self)
01122         self.core = "Cortex-M7F"
01123         self.extra_labels = ['STM', 'STM32F7', 'STM32F746', 'STM32F746NG']
01124         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
01125         self.detect_code = ["0815"]
01126         self.progen = {
01127             "target":"disco-f746ng",
01128         }
01129 
01130 class DISCO_L476VG(Target):
01131     def __init__(self):
01132         Target.__init__(self)
01133         self.core = "Cortex-M4F"
01134         self.extra_labels = ['STM', 'STM32L4', 'STM32L476VG']
01135         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
01136         self.default_toolchain = "uARM"
01137         self.detect_code = ["0820"]
01138         self.progen = {
01139             "target":"disco-l476vg",
01140         }
01141 
01142 class MTS_MDOT_F405RG(Target):
01143     def __init__(self):
01144         Target.__init__(self)
01145         self.core = "Cortex-M4F"
01146         self.extra_labels = ['STM', 'STM32F4', 'STM32F405RG']
01147         self.macros = ['HSE_VALUE=26000000', 'OS_CLOCK=48000000']
01148         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
01149         self.is_disk_virtual = True
01150         self.default_toolchain = "ARM"
01151         self.progen = {
01152             "target":"mts-mdot-f405rg",
01153         }
01154 
01155 class MTS_MDOT_F411RE(Target):
01156     def __init__(self):
01157         Target.__init__(self)
01158         self.core = "Cortex-M4F"
01159         self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
01160         self.macros = ['HSE_VALUE=26000000', 'OS_CLOCK=96000000', 'USE_PLL_HSE_EXTC=0', 'VECT_TAB_OFFSET=0x00010000']
01161         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
01162         self.default_toolchain = "ARM"
01163         self.progen = {
01164             "target":"mts-mdot-f411re",
01165         }
01166 
01167     def init_hooks(self, hook, toolchain_name):
01168         if toolchain_name in ['GCC_ARM', 'ARM_STD', 'ARM_MICRO']:
01169             hook.hook_add_binary("post", self.combine_bins)
01170 
01171     # combine application binary with bootloader
01172     # bootloader + padding to 64kB + application + md5sum (16 bytes)
01173     @staticmethod
01174     def combine_bins(t_self, resources, elf, binf):
01175         loader = os.path.join(TOOLS_BOOTLOADERS, "MTS_MDOT_F411RE", "bootloader.bin")
01176         target = binf + ".tmp"
01177         if not os.path.exists(loader):
01178             print "Can't find bootloader binary: " + loader
01179             return
01180         outbin = open(target, 'w+b')
01181         part = open(loader, 'rb')
01182         data = part.read()
01183         outbin.write(data)
01184         outbin.write('\xFF' * (64*1024 - len(data)))
01185         part.close()
01186         part = open(binf, 'rb')
01187         data = part.read()
01188         outbin.write(data)
01189         part.close()
01190         outbin.seek(0, 0)
01191         data = outbin.read()
01192         outbin.seek(0, 1)
01193         crc = struct.pack('<I', binascii.crc32(data) & 0xFFFFFFFF)
01194         outbin.write(crc)
01195         outbin.close()
01196         os.remove(binf)
01197         os.rename(target, binf)
01198 
01199 class MTS_DRAGONFLY_F411RE(Target):
01200     def __init__(self):
01201         Target.__init__(self)
01202         self.core = "Cortex-M4F"
01203         self.extra_labels = ['STM', 'STM32F4', 'STM32F411RE']
01204         self.macros = ['HSE_VALUE=26000000', 'VECT_TAB_OFFSET=0x08010000']
01205         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
01206         self.default_toolchain = "ARM"
01207         self.progen = {
01208             "target":"mts-dragonfly-f411re",
01209         }
01210 
01211     def init_hooks(self, hook, toolchain_name):
01212         if toolchain_name in ['GCC_ARM', 'ARM_STD', 'ARM_MICRO']:
01213             hook.hook_add_binary("post", self.combine_bins)
01214 
01215     # combine application binary with bootloader
01216     # bootloader + padding to 64kB + application + md5sum (16 bytes)
01217     @staticmethod
01218     def combine_bins(t_self, resources, elf, binf):
01219         loader = os.path.join(TOOLS_BOOTLOADERS, "MTS_DRAGONFLY_F411RE", "bootloader.bin")
01220         target = binf + ".tmp"
01221         if not os.path.exists(loader):
01222             print "Can't find bootloader binary: " + loader
01223             return
01224         outbin = open(target, 'w+b')
01225         part = open(loader, 'rb')
01226         data = part.read()
01227         outbin.write(data)
01228         outbin.write('\xFF' * (64*1024 - len(data)))
01229         part.close()
01230         part = open(binf, 'rb')
01231         data = part.read()
01232         outbin.write(data)
01233         part.close()
01234         outbin.seek(0, 0)
01235         data = outbin.read()
01236         outbin.seek(0, 1)
01237         crc = struct.pack('<I', binascii.crc32(data) & 0xFFFFFFFF)
01238         outbin.write(crc)
01239         outbin.close()
01240         os.remove(binf)
01241         os.rename(target, binf)
01242 
01243 class MOTE_L152RC(Target):
01244     def __init__(self):
01245         Target.__init__(self)
01246         self.core = "Cortex-M3"
01247         self.extra_labels = ['STM', 'STM32L1', 'STM32L152RC']
01248         self.supported_toolchains = ["ARM", "uARM", "IAR", "GCC_ARM"]
01249         self.default_toolchain = "uARM"
01250         self.detect_code = ["4100"]
01251         self.progen = {
01252             "target":"stm32l151rc",
01253         }
01254 class DISCO_F401VC(Target):
01255     def __init__(self):
01256         Target.__init__(self)
01257         self.core = "Cortex-M4F"
01258         self.extra_labels = ['STM', 'STM32F4', 'STM32F401', 'STM32F401VC']
01259         self.supported_toolchains = ["GCC_ARM"]
01260         self.default_toolchain = "GCC_ARM"
01261 
01262 class UBLOX_C029(Target):
01263     def __init__(self):
01264         Target.__init__(self)
01265         self.core = "Cortex-M4F"
01266         self.extra_labels = ['STM', 'STM32F4', 'STM32F439', 'STM32F439ZI']
01267         self.macros = ['HSE_VALUE=24000000', 'HSE_STARTUP_TIMEOUT=5000']
01268         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM", "IAR"]
01269         self.default_toolchain = "uARM"
01270         self.supported_form_factors = ["ARDUINO"]
01271 
01272 class NZ32_SC151(Target):
01273     def __init__(self):
01274         Target.__init__(self)
01275         self.core = "Cortex-M3"
01276         self.extra_labels = ['STM', 'STM32L1', 'STM32L151RC']
01277         self.supported_toolchains = ["ARM", "uARM", "GCC_ARM"]
01278         self.default_toolchain = "uARM"
01279         self.progen = {
01280             "target":"stm32l151rc",
01281         }
01282     # After flashing device, how long to delay until we assume program is running
01283     def program_cycle_s(self):
01284         return 1.5
01285 
01286 
01287 ### Nordic ###
01288 
01289 class MCU_NRF51(Target):
01290     # the following is a list of possible Nordic softdevices in decreasing order
01291     # of preference.
01292     EXPECTED_SOFTDEVICES_WITH_OFFSETS = [
01293         {
01294             'name'   : 's130_nrf51_1.0.0_softdevice.hex',
01295             'boot'   : 's130_nrf51_1.0.0_bootloader.hex',
01296             'offset' : 0x1C000
01297         },
01298         {
01299             'name'   : 's110_nrf51822_8.0.0_softdevice.hex',
01300             'boot'   : 's110_nrf51822_8.0.0_bootloader.hex',
01301             'offset' : 0x18000
01302         },
01303         {
01304             'name'   : 's110_nrf51822_7.1.0_softdevice.hex',
01305             'boot'   : 's110_nrf51822_7.1.0_bootloader.hex',
01306             'offset' : 0x16000
01307         },
01308         {
01309             'name'   : 's110_nrf51822_7.0.0_softdevice.hex',
01310             'boot'   : 's110_nrf51822_7.0.0_bootloader.hex',
01311             'offset' : 0x16000
01312         },
01313         {
01314             'name'   : 's110_nrf51822_6.0.0_softdevice.hex',
01315             'boot'   : 's110_nrf51822_6.0.0_bootloader.hex',
01316             'offset' : 0x14000
01317         }
01318     ]
01319     OVERRIDE_BOOTLOADER_FILENAME = "nrf51822_bootloader.hex"
01320     OUTPUT_EXT = 'hex'
01321     MERGE_SOFT_DEVICE = True
01322     MERGE_BOOTLOADER = False
01323 
01324     def __init__(self):
01325         Target.__init__(self)
01326         self.core = "Cortex-M0"
01327         self.extra_labels = ["NORDIC", "MCU_NRF51", "MCU_NRF51822"]
01328         self.macros = ['NRF51', 'TARGET_NRF51822']
01329         self.supported_toolchains = ["ARM", "GCC_ARM"]
01330         self.is_disk_virtual = True
01331         self.detect_code = ["1070"]
01332 
01333     def program_cycle_s(self):
01334         return 6
01335 
01336     def init_hooks(self, hook, toolchain_name):
01337         if toolchain_name in ['ARM_STD', 'GCC_ARM']:
01338             hook.hook_add_binary("post", self.binary_hook)
01339 
01340     @staticmethod
01341     def binary_hook(t_self, resources, elf, binf):
01342 
01343         # Scan to find the actual paths of soft device
01344         sdf = None
01345         for softdeviceAndOffsetEntry in t_self.target.EXPECTED_SOFTDEVICES_WITH_OFFSETS:
01346             for hexf in resources.hex_files:
01347                 if hexf.find(softdeviceAndOffsetEntry['name']) != -1:
01348                     t_self.debug("SoftDevice file found %s." % softdeviceAndOffsetEntry['name'])
01349                     sdf = hexf
01350 
01351                 if sdf is not None: break
01352             if sdf is not None: break
01353 
01354         if sdf is None:
01355             t_self.debug("Hex file not found. Aborting.")
01356             return
01357 
01358         # Look for bootloader file that matches this soft device or bootloader override image
01359         blf = None
01360         if t_self.target.MERGE_BOOTLOADER is True:
01361             for hexf in resources.hex_files:
01362                 if hexf.find(t_self.target.OVERRIDE_BOOTLOADER_FILENAME) != -1:
01363                     t_self.debug("Bootloader file found %s." % t_self.target.OVERRIDE_BOOTLOADER_FILENAME)
01364                     blf = hexf
01365                     break
01366                 elif hexf.find(softdeviceAndOffsetEntry['boot']) != -1:
01367                     t_self.debug("Bootloader file found %s." % softdeviceAndOffsetEntry['boot'])
01368                     blf = hexf
01369                     break
01370 
01371         # Merge user code with softdevice
01372         from intelhex import IntelHex
01373         binh = IntelHex()
01374         binh.loadbin(binf, offset=softdeviceAndOffsetEntry['offset'])
01375 
01376         if t_self.target.MERGE_SOFT_DEVICE is True:
01377             t_self.debug("Merge SoftDevice file %s" % softdeviceAndOffsetEntry['name'])
01378             sdh = IntelHex(sdf)
01379             binh.merge(sdh)
01380 
01381         if t_self.target.MERGE_BOOTLOADER is True and blf is not None:
01382             t_self.debug("Merge BootLoader file %s" % blf)
01383             blh = IntelHex(blf)
01384             binh.merge(blh)
01385 
01386         with open(binf.replace(".bin", ".hex"), "w") as f:
01387             binh.tofile(f, format='hex')
01388 
01389 
01390 # 16KB Nordic targets are tight on SRAM using S130 (default) so we
01391 # introduce two possible options:
01392 # 1) Use S130 (default) - for this derive from MCU_NRF51_16K
01393 # 2) Use S110  - for this derive from MCU_NRF51_16K_S110
01394 # Note that the 'default' option will track the default choice
01395 # for other Nordic targets, and so can take advantage of other
01396 # future SoftDevice improvements
01397 
01398 # The *_BASE targets should *not* be inherited from, as they do not
01399 # specify enough for building a target
01400 
01401 # 16KB MCU version, e.g. Nordic nRF51822, Seeed Arch BLE, etc.
01402 class MCU_NRF51_16K_BASE(MCU_NRF51):
01403     def __init__(self):
01404         MCU_NRF51.__init__(self)
01405         self.extra_labels += ['MCU_NORDIC_16K', 'MCU_NRF51_16K']
01406         self.macros += ['TARGET_MCU_NORDIC_16K', 'TARGET_MCU_NRF51_16K']
01407 
01408 # derivative class used to create softdevice+bootloader enabled images
01409 class MCU_NRF51_16K_BOOT_BASE(MCU_NRF51_16K_BASE):
01410     def __init__(self):
01411         MCU_NRF51_16K_BASE.__init__(self)
01412         self.extra_labels += ['MCU_NRF51_16K_BOOT']
01413         self.macros += ['TARGET_MCU_NRF51_16K_BOOT', 'TARGET_OTA_ENABLED']
01414         self.MERGE_SOFT_DEVICE = True
01415         self.MERGE_BOOTLOADER = True
01416 
01417 # derivative class used to create program only images for use with FOTA
01418 class MCU_NRF51_16K_OTA_BASE(MCU_NRF51_16K_BASE):
01419     def __init__(self):
01420         MCU_NRF51_16K_BASE.__init__(self)
01421         self.extra_labels += ['MCU_NRF51_16K_OTA']
01422         self.macros += ['TARGET_MCU_NRF51_16K_OTA', 'TARGET_OTA_ENABLED']
01423         self.MERGE_SOFT_DEVICE = False
01424 
01425 class MCU_NRF51_16K(MCU_NRF51_16K_BASE):
01426     def __init__(self):
01427         MCU_NRF51_16K_BASE.__init__(self)
01428         self.extra_labels += ['MCU_NRF51_16K_S130']
01429         self.macros += ['TARGET_MCU_NRF51_16K_S130']
01430 
01431 class MCU_NRF51_S110 :
01432     """ Interface for overwriting the default SoftDevices """
01433     def __init__(self):
01434         self.EXPECTED_SOFTDEVICES_WITH_OFFSETS  = [
01435             {
01436                 'name'   : 's110_nrf51822_8.0.0_softdevice.hex',
01437                 'boot'   : 's110_nrf51822_8.0.0_bootloader.hex',
01438                 'offset' : 0x18000
01439             },
01440             {
01441                 'name'   : 's110_nrf51822_7.1.0_softdevice.hex',
01442                 'boot'   : 's110_nrf51822_7.1.0_bootloader.hex',
01443                 'offset' : 0x16000
01444             }
01445         ]
01446         self.extra_labels += ['MCU_NRF51_16K_S110']
01447         self.macros += ['TARGET_MCU_NRF51_16K_S110']
01448 
01449 class MCU_NRF51_16K_S110(MCU_NRF51_16K_BASE, MCU_NRF51_S110 ):
01450     def __init__(self):
01451         MCU_NRF51_16K_BASE.__init__(self)
01452         MCU_NRF51_S110.__init__(self)
01453 
01454 class MCU_NRF51_16K_BOOT(MCU_NRF51_16K_BOOT_BASE):
01455     def __init__(self):
01456         MCU_NRF51_16K_BOOT_BASE.__init__(self)
01457         self.extra_labels += ['MCU_NRF51_16K_S130']
01458         self.macros += ['TARGET_MCU_NRF51_16K_S130']
01459 
01460 class MCU_NRF51_16K_BOOT_S110(MCU_NRF51_16K_BOOT_BASE, MCU_NRF51_S110 ):
01461     def __init__(self):
01462         MCU_NRF51_16K_BOOT_BASE.__init__(self)
01463         MCU_NRF51_S110.__init__(self)
01464 
01465 class MCU_NRF51_16K_OTA(MCU_NRF51_16K_OTA_BASE):
01466     def __init__(self):
01467         MCU_NRF51_16K_OTA_BASE.__init__(self)
01468         self.extra_labels += ['MCU_NRF51_16K_S130']
01469         self.macros += ['TARGET_MCU_NRF51_16K_S130']
01470 
01471 class MCU_NRF51_16K_OTA_S110(MCU_NRF51_16K_OTA_BASE, MCU_NRF51_S110 ):
01472     def __init__(self):
01473         MCU_NRF51_16K_OTA_BASE.__init__(self)
01474         MCU_NRF51_S110.__init__(self)
01475 
01476 
01477 # 32KB MCU version, e.g. Nordic nRF51-DK, nRF51-Dongle, etc.
01478 class MCU_NRF51_32K(MCU_NRF51):
01479     def __init__(self):
01480         MCU_NRF51.__init__(self)
01481         self.extra_labels += ['MCU_NORDIC_32K', 'MCU_NRF51_32K']
01482         self.macros += ['TARGET_MCU_NORDIC_32K', 'TARGET_MCU_NRF51_32K']
01483 
01484 class MCU_NRF51_32K_BOOT(MCU_NRF51_32K):
01485     def __init__(self):
01486         MCU_NRF51_32K.__init__(self)
01487         self.extra_labels += ['MCU_NRF51_32K_BOOT']
01488         self.macros += ['TARGET_MCU_NRF51_32K_BOOT', 'TARGET_OTA_ENABLED']
01489         self.MERGE_SOFT_DEVICE = True
01490         self.MERGE_BOOTLOADER = True
01491 
01492 class MCU_NRF51_32K_OTA(MCU_NRF51_32K):
01493     def __init__(self):
01494         MCU_NRF51_32K.__init__(self)
01495         self.extra_labels += ['MCU_NRF51_32K_OTA']
01496         self.macros += ['TARGET_MCU_NRF51_32K_OTA', 'TARGET_OTA_ENABLED']
01497         self.MERGE_SOFT_DEVICE = False
01498 
01499 #
01500 # nRF51 based development kits
01501 #
01502 
01503 # This one is special for legacy reasons
01504 class NRF51822(MCU_NRF51_16K):
01505     def __init__(self):
01506         MCU_NRF51_16K.__init__(self)
01507         self.extra_labels += ['NRF51822', 'NRF51822_MKIT']
01508         self.macros += ['TARGET_NRF51822_MKIT']
01509         self.progen = {
01510             "target":"mkit",
01511         }
01512 class NRF51822_BOOT(MCU_NRF51_16K_BOOT):
01513     def __init__(self):
01514         MCU_NRF51_16K_BOOT.__init__(self)
01515         self.extra_labels += ['NRF51822', 'NRF51822_MKIT']
01516         self.macros += ['TARGET_NRF51822_MKIT']
01517 
01518 class NRF51822_OTA(MCU_NRF51_16K_OTA):
01519     def __init__(self):
01520         MCU_NRF51_16K_OTA.__init__(self)
01521         self.extra_labels += ['NRF51822', 'NRF51822_MKIT']
01522         self.macros += ['TARGET_NRF51822_MKIT']
01523 
01524 class ARCH_BLE(MCU_NRF51_16K):
01525     def __init__(self):
01526         MCU_NRF51_16K.__init__(self)
01527         self.supported_form_factors = ["ARDUINO"]
01528         self.progen = {
01529             "target":"arch-ble",
01530         }
01531 
01532 class ARCH_BLE_BOOT(MCU_NRF51_16K_BOOT):
01533     def __init__(self):
01534         MCU_NRF51_16K_BOOT.__init__(self)
01535         self.extra_labels += ['ARCH_BLE']
01536         self.macros += ['TARGET_ARCH_BLE']
01537         self.supported_form_factors = ["ARDUINO"]
01538 
01539 class ARCH_BLE_OTA(MCU_NRF51_16K_OTA):
01540     def __init__(self):
01541         MCU_NRF51_16K_OTA.__init__(self)
01542         self.extra_labels += ['ARCH_BLE']
01543         self.macros += ['TARGET_ARCH_BLE']
01544         self.supported_form_factors = ["ARDUINO"]
01545 
01546 class ARCH_LINK(MCU_NRF51_16K):
01547     def __init__(self):
01548         MCU_NRF51_16K.__init__(self)
01549         self.extra_labels += ['ARCH_BLE']
01550         self.macros += ['TARGET_ARCH_BLE']
01551         self.supported_form_factors = ["ARDUINO"]
01552 
01553 class ARCH_LINK_BOOT(MCU_NRF51_16K_BOOT):
01554     def __init__(self):
01555         MCU_NRF51_16K_BOOT.__init__(self)
01556         self.extra_labels += ['ARCH_BLE', 'ARCH_LINK']
01557         self.macros += ['TARGET_ARCH_BLE', 'TARGET_ARCH_LINK']
01558         self.supported_form_factors = ["ARDUINO"]
01559 
01560 class ARCH_LINK_OTA(MCU_NRF51_16K_OTA):
01561     def __init__(self):
01562         MCU_NRF51_16K_OTA.__init__(self)
01563         self.extra_labels += ['ARCH_BLE', 'ARCH_LINK']
01564         self.macros += ['TARGET_ARCH_BLE', 'TARGET_ARCH_LINK']
01565         self.supported_form_factors = ["ARDUINO"]
01566 
01567 class SEEED_TINY_BLE(MCU_NRF51_16K):
01568     def __init__(self):
01569         MCU_NRF51_16K.__init__(self)
01570         self.progen = {
01571             "target":"seed-tinyble",
01572         }
01573 
01574 class SEEED_TINY_BLE_BOOT(MCU_NRF51_16K_BOOT):
01575     def __init__(self):
01576         MCU_NRF51_16K_BOOT.__init__(self)
01577         self.extra_labels += ['SEEED_TINY_BLE']
01578         self.macros += ['TARGET_SEEED_TINY_BLE']
01579 
01580 class SEEED_TINY_BLE_OTA(MCU_NRF51_16K_OTA):
01581     def __init__(self):
01582         MCU_NRF51_16K_OTA.__init__(self)
01583         self.extra_labels += ['SEEED_TINY_BLE']
01584         self.macros += ['TARGET_SEEED_TINY_BLE']
01585 
01586 class HRM1017(MCU_NRF51_16K):
01587     def __init__(self):
01588         MCU_NRF51_16K.__init__(self)
01589         self.macros += ['TARGET_NRF_LFCLK_RC']
01590         self.progen = {
01591             "target":"hrm1017",
01592         }
01593 class HRM1017_BOOT(MCU_NRF51_16K_BOOT):
01594     def __init__(self):
01595         MCU_NRF51_16K_BOOT.__init__(self)
01596         self.extra_labels += ['HRM1017']
01597         self.macros += ['TARGET_HRM1017', 'TARGET_NRF_LFCLK_RC']
01598 
01599 class HRM1017_OTA(MCU_NRF51_16K_OTA):
01600     def __init__(self):
01601         MCU_NRF51_16K_OTA.__init__(self)
01602         self.extra_labels += ['HRM1017']
01603         self.macros += ['TARGET_HRM1017', 'TARGET_NRF_LFCLK_RC']
01604 
01605 class RBLAB_NRF51822(MCU_NRF51_16K):
01606     def __init__(self):
01607         MCU_NRF51_16K.__init__(self)
01608         self.supported_form_factors = ["ARDUINO"]
01609         self.progen = {
01610             "target":"rblab-nrf51822",
01611         }
01612 
01613 class RBLAB_NRF51822_BOOT(MCU_NRF51_16K_BOOT):
01614     def __init__(self):
01615         MCU_NRF51_16K_BOOT.__init__(self)
01616         self.extra_labels += ['RBLAB_NRF51822']
01617         self.macros += ['TARGET_RBLAB_NRF51822']
01618         self.supported_form_factors = ["ARDUINO"]
01619 
01620 class RBLAB_NRF51822_OTA(MCU_NRF51_16K_OTA):
01621     def __init__(self):
01622         MCU_NRF51_16K_OTA.__init__(self)
01623         self.extra_labels += ['RBLAB_NRF51822']
01624         self.macros += ['TARGET_RBLAB_NRF51822']
01625         self.supported_form_factors = ["ARDUINO"]
01626 
01627 class RBLAB_BLENANO(MCU_NRF51_16K):
01628     def __init__(self):
01629         MCU_NRF51_16K.__init__(self)
01630 
01631 class RBLAB_BLENANO_BOOT(MCU_NRF51_16K_BOOT):
01632     def __init__(self):
01633         MCU_NRF51_16K_BOOT.__init__(self)
01634         self.extra_labels += ['RBLAB_BLENANO']
01635         self.macros += ['TARGET_RBLAB_BLENANO']
01636 
01637 class RBLAB_BLENANO_OTA(MCU_NRF51_16K_OTA):
01638     def __init__(self):
01639         MCU_NRF51_16K_OTA.__init__(self)
01640         self.extra_labels += ['RBLAB_BLENANO']
01641         self.macros += ['TARGET_RBLAB_BLENANO']
01642 
01643 class NRF51822_Y5_MBUG(MCU_NRF51_16K):
01644     def __init__(self):
01645         MCU_NRF51_16K.__init__(self)
01646 
01647 class WALLBOT_BLE(MCU_NRF51_16K):
01648     def __init__(self):
01649         MCU_NRF51_16K.__init__(self)
01650 
01651 class WALLBOT_BLE_BOOT(MCU_NRF51_16K_BOOT):
01652     def __init__(self):
01653         MCU_NRF51_16K_BOOT.__init__(self)
01654         self.extra_labels += ['WALLBOT_BLE']
01655         self.macros += ['TARGET_WALLBOT_BLE']
01656 
01657 class WALLBOT_BLE_OTA(MCU_NRF51_16K_OTA):
01658     def __init__(self):
01659         MCU_NRF51_16K_OTA.__init__(self)
01660         self.extra_labels += ['WALLBOT_BLE']
01661         self.macros += ['TARGET_WALLBOT_BLE']
01662 
01663 class DELTA_DFCM_NNN40(MCU_NRF51_32K):
01664     def __init__(self):
01665         MCU_NRF51_32K.__init__(self)
01666         self.macros += ['TARGET_NRF_LFCLK_RC']
01667         self.progen = {
01668             "target":"dfcm-nnn40",
01669         }
01670     def program_cycle_s(self):
01671         return 10
01672 
01673 class DELTA_DFCM_NNN40_BOOT(MCU_NRF51_32K_BOOT):
01674     def __init__(self):
01675         MCU_NRF51_32K_BOOT.__init__(self)
01676         self.extra_labels += ['DELTA_DFCM_NNN40']
01677         self.macros += ['TARGET_DELTA_DFCM_NNN40', 'TARGET_NRF_LFCLK_RC']
01678     def program_cycle_s(self):
01679         return 10
01680 
01681 class DELTA_DFCM_NNN40_OTA(MCU_NRF51_32K_OTA):
01682     def __init__(self):
01683         MCU_NRF51_32K_OTA.__init__(self)
01684         self.extra_labels += ['DELTA_DFCM_NNN40']
01685         self.macros += ['TARGET_DELTA_DFCM_NNN40', 'TARGET_NRF_LFCLK_RC']
01686     def program_cycle_s(self):
01687         return 10
01688 
01689 class NRF51_DK(MCU_NRF51_32K):
01690     def __init__(self):
01691         MCU_NRF51_32K.__init__(self)
01692         self.supported_form_factors = ["ARDUINO"]
01693         self.progen = {
01694             "target":"nrf51-dk",
01695         }
01696 
01697 class NRF51_DK_BOOT(MCU_NRF51_32K_BOOT):
01698     def __init__(self):
01699         MCU_NRF51_32K_BOOT.__init__(self)
01700         self.extra_labels += ['NRF51_DK']
01701         self.macros += ['TARGET_NRF51_DK']
01702         self.supported_form_factors = ["ARDUINO"]
01703 
01704 class NRF51_DK_OTA(MCU_NRF51_32K_OTA):
01705     def __init__(self):
01706         MCU_NRF51_32K_OTA.__init__(self)
01707         self.extra_labels += ['NRF51_DK']
01708         self.macros += ['TARGET_NRF51_DK']
01709         self.supported_form_factors = ["ARDUINO"]
01710 
01711 class NRF51_DONGLE(MCU_NRF51_32K):
01712     def __init__(self):
01713         MCU_NRF51_32K.__init__(self)
01714         self.progen = {
01715             "target":"nrf51-dongle",
01716         }
01717 
01718 class NRF51_DONGLE_BOOT(MCU_NRF51_32K_BOOT):
01719     def __init__(self):
01720         MCU_NRF51_32K_BOOT.__init__(self)
01721         self.extra_labels += ['NRF51_DONGLE']
01722         self.macros += ['TARGET_NRF51_DONGLE']
01723 
01724 class NRF51_DONGLE_OTA(MCU_NRF51_32K_OTA):
01725     def __init__(self):
01726         MCU_NRF51_32K_OTA.__init__(self)
01727         self.extra_labels += ['NRF51_DONGLE']
01728         self.macros += ['TARGET_NRF51_DONGLE']
01729 
01730 class NRF51_MICROBIT(MCU_NRF51_16K_S110):
01731     def __init__(self):
01732         MCU_NRF51_16K_S110.__init__(self)
01733         self.macros += ['TARGET_NRF_LFCLK_RC']
01734 
01735 class NRF51_MICROBIT_BOOT(MCU_NRF51_16K_BOOT_S110):
01736     def __init__(self):
01737         MCU_NRF51_16K_BOOT_S110.__init__(self)
01738         self.extra_labels += ['NRF51_MICROBIT']
01739         self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
01740 
01741 class NRF51_MICROBIT_OTA(MCU_NRF51_16K_OTA_S110):
01742     def __init__(self):
01743         MCU_NRF51_16K_OTA_S110.__init__(self)
01744         self.extra_labels += ['NRF51_MICROBIT']
01745         self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
01746 
01747 class NRF51_MICROBIT_B(MCU_NRF51_16K):
01748     def __init__(self):
01749         MCU_NRF51_16K.__init__(self)
01750         self.extra_labels += ['NRF51_MICROBIT']
01751         self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
01752 
01753 class NRF51_MICROBIT_B_BOOT(MCU_NRF51_16K_BOOT):
01754     def __init__(self):
01755         MCU_NRF51_16K_BOOT.__init__(self)
01756         self.extra_labels += ['NRF51_MICROBIT']
01757         self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
01758 
01759 class NRF51_MICROBIT_B_OTA(MCU_NRF51_16K_OTA):
01760     def __init__(self):
01761         MCU_NRF51_16K_OTA.__init__(self)
01762         self.extra_labels += ['NRF51_MICROBIT']
01763         self.macros += ['TARGET_NRF51_MICROBIT', 'TARGET_NRF_LFCLK_RC']
01764 
01765 class TY51822R3(MCU_NRF51_32K):
01766     def __init__(self):
01767         MCU_NRF51_32K.__init__(self)
01768         self.macros += ['TARGET_NRF_32MHZ_XTAL']
01769         self.supported_toolchains = ["ARM", "GCC_ARM"]
01770 
01771 class TY51822R3_BOOT(MCU_NRF51_32K_BOOT):
01772     def __init__(self):
01773         MCU_NRF51_32K_BOOT.__init__(self)
01774         self.extra_labels += ['TY51822R3']
01775         self.macros += ['TARGET_TY51822R3', 'TARGET_NRF_32MHZ_XTAL']
01776         self.supported_toolchains = ["ARM", "GCC_ARM"]
01777 
01778 class TY51822R3_OTA(MCU_NRF51_32K_OTA):
01779     def __init__(self):
01780         MCU_NRF51_32K_OTA.__init__(self)
01781         self.extra_labels += ['NRF51_DK']
01782         self.macros += ['TARGET_TY51822R3', 'TARGET_NRF_32MHZ_XTAL']
01783         self.supported_toolchains = ["ARM", "GCC_ARM"]
01784 
01785 
01786 ### ARM ###
01787 
01788 class ARM_MPS2_Target(Target):
01789     def __init__(self):
01790         Target.__init__(self)
01791 
01792 class ARM_MPS2_M0(ARM_MPS2_Target):
01793     def __init__(self):
01794         ARM_MPS2_Target.__init__(self)
01795         self.core = "Cortex-M0"
01796         self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M0']
01797         self.macros = ['CMSDK_CM0']
01798         self.supported_toolchains = ["ARM"]
01799         self.default_toolchain = "ARM"
01800 
01801 class ARM_MPS2_M0P(ARM_MPS2_Target):
01802     def __init__(self):
01803         ARM_MPS2_Target.__init__(self)
01804         self.core = "Cortex-M0+"
01805         self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M0P']
01806         self.macros = ['CMSDK_CM0plus']
01807         self.supported_toolchains = ["ARM"]
01808         self.default_toolchain = "ARM"
01809 
01810 class ARM_MPS2_M1(ARM_MPS2_Target):
01811     def __init__(self):
01812         ARM_MPS2_Target.__init__(self)
01813         self.core = "Cortex-M1"
01814         self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M1']
01815         self.macros = ['CMSDK_CM1']
01816         self.supported_toolchains = ["ARM"]
01817         self.default_toolchain = "ARM"
01818 
01819 class ARM_MPS2_M3(ARM_MPS2_Target):
01820     def __init__(self):
01821         ARM_MPS2_Target.__init__(self)
01822         self.core = "Cortex-M3"
01823         self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M3']
01824         self.macros = ['CMSDK_CM3']
01825         self.supported_toolchains = ["ARM"]
01826         self.default_toolchain = "ARM"
01827 
01828 class ARM_MPS2_M4(ARM_MPS2_Target):
01829     def __init__(self):
01830         ARM_MPS2_Target.__init__(self)
01831         self.core = "Cortex-M4F"
01832         self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M4']
01833         self.macros = ['CMSDK_CM4']
01834         self.supported_toolchains = ["ARM"]
01835         self.default_toolchain = "ARM"
01836 
01837 class ARM_MPS2_M7(ARM_MPS2_Target):
01838     def __init__(self):
01839         ARM_MPS2_Target.__init__(self)
01840         self.core = "Cortex-M7"
01841         self.extra_labels = ['ARM_SSG', 'MPS2', 'MPS2_M7']
01842         self.macros = ['CMSDK_CM7']
01843         self.supported_toolchains = ["ARM"]
01844         self.default_toolchain = "ARM"
01845         
01846 class ARM_IOTSS_Target(Target):
01847     def __init__(self):
01848         Target.__init__(self)
01849 class ARM_IOTSS_BEID(ARM_IOTSS_Target):
01850     def __init__(self):
01851         ARM_IOTSS_Target.__init__(self)
01852         self.core = "Cortex-M3"
01853         self.extra_labels = ['ARM_SSG', 'IOTSS', 'IOTSS_BEID']
01854         self.macros = ['CMSDK_BEID']
01855         self.supported_toolchains = ["ARM"]
01856         self.default_toolchain = "ARM"
01857 
01858 
01859 ### Renesas ###
01860 
01861 class RZ_A1H(Target):
01862     def __init__(self):
01863         Target.__init__(self)
01864         self.core = "Cortex-A9"
01865         self.extra_labels = ['RENESAS', 'MBRZA1H']
01866         self.supported_toolchains = ["ARM", "GCC_ARM", "IAR"]
01867         self.supported_form_factors = ["ARDUINO"]
01868         self.default_toolchain = "ARM"
01869         self.progen = {
01870             "target": "gr-peach",
01871             "iar": {
01872                 # rewrite generic template, this device needs futher support for FPU in progendef
01873                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'iar_rz_a1h.ewp.tmpl')],
01874             }
01875         }
01876 
01877     def program_cycle_s(self):
01878         return 2
01879 
01880 
01881 ### Maxim Integrated ###
01882 
01883 class MAXWSNENV(Target):
01884     def __init__(self):
01885         Target.__init__(self)
01886         self.core = "Cortex-M3"
01887         self.extra_labels = ['Maxim', 'MAX32610']
01888         self.macros = ['__SYSTEM_HFX=24000000']
01889         self.supported_toolchains = ["GCC_ARM", "IAR", "ARM"]
01890         self.default_toolchain = "ARM"
01891         self.progen = {
01892             "target": "maxwsnenv",
01893         }
01894 
01895 class MAX32600MBED(Target):
01896     def __init__(self):
01897         Target.__init__(self)
01898         self.core = "Cortex-M3"
01899         self.extra_labels = ['Maxim', 'MAX32600']
01900         self.macros = ['__SYSTEM_HFX=24000000']
01901         self.supported_toolchains = ["GCC_ARM", "IAR", "ARM"]
01902         self.default_toolchain = "ARM"
01903         self.progen = {
01904             "target": "max32600mbed",
01905         }
01906 
01907 ### Silicon Labs ###
01908 
01909 class EFM32GG_STK3700(Target):
01910     def __init__(self):
01911         Target.__init__(self)
01912         self.core = "Cortex-M3"
01913         self.extra_labels = ['Silicon_Labs', 'EFM32']
01914         self.macros = ['EFM32GG990F1024']
01915         self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
01916         self.default_toolchain = "ARM"
01917         self.progen = {
01918             "target":"efm32gg_stk3700", #TODO: add to progen
01919         }
01920 
01921 
01922 
01923 class EFM32LG_STK3600(Target):
01924     def __init__(self):
01925         Target.__init__(self)
01926         self.core = "Cortex-M3"
01927         self.extra_labels = ['Silicon_Labs', 'EFM32']
01928         self.macros = ['EFM32LG990F256']
01929         self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
01930         self.default_toolchain = "ARM"
01931         self.progen = {
01932             "target":"efm32lg_stk3600", #TODO: add to progen
01933         }
01934 
01935 
01936 
01937 class EFM32WG_STK3800(Target):
01938     def __init__(self):
01939         Target.__init__(self)
01940         self.core = "Cortex-M4F"
01941         self.extra_labels = ['Silicon_Labs', 'EFM32']
01942         self.macros = ['EFM32WG990F256']
01943         self.supported_toolchains = ["GCC_ARM", "ARM", "uARM"]
01944         self.default_toolchain = "ARM"
01945         self.progen = {
01946             "target":"efm32wg_stk3800", #TODO: add to progen
01947         }
01948 
01949 
01950 
01951 class EFM32ZG_STK3200(Target):
01952     def __init__(self):
01953         Target.__init__(self)
01954         self.core = "Cortex-M0+"
01955         self.extra_labels = ['Silicon_Labs', 'EFM32']
01956         self.macros = ['EFM32ZG222F32']
01957         self.supported_toolchains = ["GCC_ARM", "uARM"]
01958         self.default_toolchain = "uARM"
01959         self.progen = {
01960             "target":"efm32zg_stk3200", #TODO: add to progen
01961             "uvision": {
01962                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
01963             }
01964         }
01965 
01966 
01967 class EFM32HG_STK3400(Target):
01968     def __init__(self):
01969         Target.__init__(self)
01970         self.core = "Cortex-M0+"
01971         self.extra_labels = ['Silicon_Labs', 'EFM32']
01972         self.macros = ['EFM32HG322F64']
01973         self.supported_toolchains = ["GCC_ARM", "uARM"]
01974         self.default_toolchain = "uARM"
01975         self.progen = {
01976             "target":"efm32hg_stk3400", #TODO: add to progen
01977             "uvision": {
01978                 "template": [os.path.join(os.path.dirname(__file__), 'export', 'uvision_microlib.uvproj.tmpl')],
01979             }
01980         }
01981 
01982 
01983 class EFM32PG_STK3401(Target):
01984     def __init__(self):
01985         Target.__init__(self)
01986         self.core = "Cortex-M4F"
01987         self.extra_labels = ['Silicon_Labs', 'EFM32']
01988         self.macros = ['EFM32PG1B200F256GM48']
01989         self.supported_toolchains = ["GCC_ARM", "ARM", "uARM", "IAR"]
01990         self.default_toolchain = "ARM"
01991         self.progen = {
01992             "target":"efm32pg_stk3401", #TODO: add to progen
01993         }
01994 
01995 
01996 
01997 ##WIZnet
01998 
01999 class WIZWIKI_W7500(Target):
02000     def __init__(self):
02001         Target.__init__(self)
02002         self.core  = "Cortex-M0"
02003         self.extra_labels  = ['WIZNET', 'W7500x', 'WIZwiki_W7500']
02004         self.supported_toolchains  = ["uARM", "ARM"]
02005         self.default_toolchain  = "ARM"
02006         self.supported_form_factors  = ["ARDUINO"]
02007         self.progen  = {
02008             "target":"wizwiki_w7500",
02009         }
02010 
02011 class WIZWIKI_W7500P(Target):
02012     def __init__(self):
02013         Target.__init__(self)
02014         self.core  = "Cortex-M0"
02015         self.extra_labels  = ['WIZNET', 'W7500x', 'WIZwiki_W7500P']
02016         self.supported_toolchains  = ["uARM", "ARM"]
02017         self.default_toolchain  = "ARM"
02018         self.supported_form_factors  = ["ARDUINO"]
02019         self.progen  = {
02020             "target":"wizwiki_w7500p", # TODO: add to progen
02021         }
02022 
02023 class WIZWIKI_W7500ECO(Target):
02024     def __init__(self):
02025         Target.__init__(self)
02026         self.core  = "Cortex-M0"
02027         self.extra_labels  = ['WIZNET', 'W7500x', 'WIZwiki_W7500ECO']
02028         self.supported_toolchains  = ["uARM", "ARM"]
02029         self.default_toolchain  = "ARM"
02030         self.progen  = {
02031             "target":"wizwiki_w7500eco", # TODO: add to progen
02032         }
02033 
02034 
02035 class SAMR21G18A(Target):
02036     def __init__(self):
02037         Target.__init__(self)
02038         self.core  = "Cortex-M0+"
02039         self.extra_labels  = ['Atmel', 'SAM_CortexM0P', 'SAMR21']
02040         self.macros = ['__SAMR21G18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
02041         self.supported_toolchains  = ["GCC_ARM", "ARM", "uARM"]
02042         self.default_toolchain  = "ARM"
02043         self.progen  = {
02044             "target":"samr21g18a",
02045         }
02046 
02047 class SAMD21J18A(Target):
02048     def __init__(self):
02049         Target.__init__(self)
02050         self.core  = "Cortex-M0+"
02051         self.extra_labels  = ['Atmel', 'SAM_CortexM0P', 'SAMD21']
02052         self.macros = ['__SAMD21J18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
02053         self.supported_toolchains  = ["GCC_ARM", "ARM", "uARM"]
02054         self.default_toolchain  = "ARM"
02055         self.progen  = {
02056             "target":"samd21j18a",
02057         }
02058 
02059 class SAMD21G18A(Target):
02060     def __init__(self):
02061         Target.__init__(self)
02062         self.core  = "Cortex-M0+"
02063         self.extra_labels  = ['Atmel', 'SAM_CortexM0P', 'SAMD21']
02064         self.macros = ['__SAMD21G18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
02065         self.supported_toolchains  = ["GCC_ARM", "ARM", "uARM"]
02066         self.default_toolchain  = "ARM"
02067         self.progen  = {
02068             "target":"samd21g18a",
02069         }
02070 
02071 class SAML21J18A(Target):
02072     def __init__(self):
02073         Target.__init__(self)
02074         self.core  = "Cortex-M0+"
02075         self.extra_labels  = ['Atmel', 'SAM_CortexM0P', 'SAML21']
02076         self.macros = ['__SAML21J18A__', 'I2C_MASTER_CALLBACK_MODE=true', 'EXTINT_CALLBACK_MODE=true', 'USART_CALLBACK_MODE=true', 'TC_ASYNC=true']
02077         self.supported_toolchains  = ["GCC_ARM", "ARM", "uARM"]
02078         self.default_toolchain  = "ARM"
02079         self.progen  = {
02080             "target":"samr21j18a",
02081         }
02082 
02083 # Get a single instance for each target
02084 TARGETS = [
02085 
02086     ### NXP ###
02087     LPC11C24(),
02088     LPC11U24(),
02089     OC_MBUINO(),        # LPC11U24
02090     LPC11U24_301(),
02091     LPC11U34_421(),
02092     MICRONFCBOARD(),    # LPC11U34_421
02093     LPC11U35_401(),
02094     LPC11U35_501(),     # LPC11U35_501
02095     LPC11U35_501_IBDAP(), # LPC11U35_501
02096     XADOW_M0(),         # LPC11U35_501
02097     LPC11U35_Y5_MBUG(), # LPC11U35_501
02098     LPC11U37_501(),
02099     LPCCAPPUCCINO(),    # LPC11U37_501
02100     ARCH_GPRS(),        # LPC11U37_501
02101     LPC11U68(),
02102     LPC1114(),
02103     LPC1347(),
02104     LPC1549(),
02105     LPC1768(),          # LPC1768
02106     ARCH_PRO(),         # LPC1768
02107     UBLOX_C027(),       # LPC1768
02108     XBED_LPC1768(),     # LPC1768
02109     LPC2368(),
02110     LPC2460(),
02111     LPC810(),
02112     LPC812(),
02113     LPC824(),
02114     SSCI824(),          # LPC824
02115     LPC4088(),
02116     LPC4088_DM(),
02117     LPC4330_M4(),
02118     LPC4330_M0(),
02119     LPC4337(),
02120     LPC11U37H_401(),
02121 
02122     ### Freescale ###
02123     KL05Z(),
02124     KL25Z(),
02125     KL26Z(),
02126     KL43Z(),
02127     KL46Z(),
02128     K20D50M(),
02129     TEENSY3_1(),
02130     K22F(),
02131     K64F(),
02132     K64F_UV(),
02133     MTS_GAMBIT(),       # FRDM K64F
02134 
02135     ### STMicro ###
02136     B96B_F446VE(),
02137     NUCLEO_F030R8(),
02138     NUCLEO_F031K6(),
02139     NUCLEO_F042K6(),
02140     NUCLEO_F070RB(),
02141     NUCLEO_F072RB(),
02142     NUCLEO_F091RC(),
02143     NUCLEO_F103RB(),
02144     NUCLEO_F302R8(),
02145     NUCLEO_F303K8(),
02146     NUCLEO_F303RE(),
02147     NUCLEO_F334R8(),
02148     NUCLEO_F401RE(),
02149     NUCLEO_F410RB(),
02150     NUCLEO_F411RE(),
02151     NUCLEO_F746ZG(),
02152     ELMO_F411RE(),
02153     NUCLEO_F446RE(),
02154     NUCLEO_L053R8(),
02155     NUCLEO_L073RZ(),
02156     NUCLEO_L152RE(),
02157     NUCLEO_L476RG(),
02158     STM32F3XX(),
02159     STM32F407(),
02160     DISCO_F051R8(),
02161     DISCO_F100RB(),
02162     DISCO_F303VC(),
02163     DISCO_F334C8(),
02164     DISCO_F746NG(),
02165     DISCO_F407VG(),     # STM32F407
02166     ARCH_MAX(),         # STM32F407
02167     DISCO_F429ZI(),
02168     DISCO_F469NI(),
02169     DISCO_L053C8(),
02170     DISCO_L476VG(),
02171     MTS_MDOT_F405RG(),
02172     MTS_MDOT_F411RE(),
02173     MOTE_L152RC(),
02174     MTS_DRAGONFLY_F411RE(),
02175     DISCO_F401VC(),
02176     UBLOX_C029(),       # STM32F439
02177     NZ32_SC151(),       # STM32L151
02178 
02179     ### Nordic ###
02180     NRF51822(),             # nRF51_16K
02181     NRF51822_BOOT(),        # nRF51_16K
02182     NRF51822_OTA(),         # nRF51_16K
02183     ARCH_BLE(),             # nRF51_16K
02184     ARCH_BLE_BOOT(),        # nRF51_16K
02185     ARCH_BLE_OTA(),         # nRF51_16K
02186     ARCH_LINK(),            # nRF51_16K
02187     ARCH_LINK_BOOT(),       # nRF51_16K
02188     ARCH_LINK_OTA(),        # nRF51_16K
02189     SEEED_TINY_BLE(),       # nRF51_16K
02190     SEEED_TINY_BLE_BOOT(),  # nRF51_16K
02191     SEEED_TINY_BLE_OTA(),   # nRF51_16K
02192     HRM1017(),              # nRF51_16K
02193     HRM1017_BOOT(),         # nRF51_16K
02194     HRM1017_OTA(),          # nRF51_16K
02195     RBLAB_NRF51822(),       # nRF51_16K
02196     RBLAB_NRF51822_BOOT(),  # nRF51_16K
02197     RBLAB_NRF51822_OTA(),   # nRF51_16K
02198     RBLAB_BLENANO(),        # nRF51_16K
02199     RBLAB_BLENANO_BOOT(),   # nRF51_16K
02200     RBLAB_BLENANO_OTA(),    # nRF51_16K
02201     NRF51822_Y5_MBUG(),     # nRF51_16K
02202     WALLBOT_BLE(),          # nRF51_16K
02203     WALLBOT_BLE_BOOT(),     # nRF51_16K
02204     WALLBOT_BLE_OTA(),      # nRF51_16K
02205     DELTA_DFCM_NNN40(),     # nRF51_16K
02206     DELTA_DFCM_NNN40_BOOT(),# nRF51_16K
02207     DELTA_DFCM_NNN40_OTA(), # nRF51_16K
02208     NRF51_DK(),             # nRF51_32K
02209     NRF51_DK_BOOT(),        # nRF51_32K
02210     NRF51_DK_OTA(),         # nRF51_32K
02211     NRF51_DONGLE(),         # nRF51_32K
02212     NRF51_DONGLE_BOOT(),    # nRF51_32K
02213     NRF51_DONGLE_OTA(),     # nRF51_32K
02214     NRF51_MICROBIT(),       # nRF51_16K - S110
02215     NRF51_MICROBIT_BOOT(),  # nRF51_16K - S110
02216     NRF51_MICROBIT_OTA(),   # nRF51_16K - S110
02217     NRF51_MICROBIT_B(),     # nRF51_16K - default
02218     NRF51_MICROBIT_B_BOOT(),# nRF51_16K - default
02219     NRF51_MICROBIT_B_OTA(), # nRF51_16K - default
02220     TY51822R3(),            # nRF51_32K
02221     TY51822R3_BOOT(),       # nRF51_32K
02222     TY51822R3_OTA(),        # nRF51_32K
02223 
02224 
02225     ### ARM ###
02226     ARM_MPS2_M0(),
02227     ARM_MPS2_M0P(),
02228     ARM_MPS2_M1(),
02229     ARM_MPS2_M3(),
02230     ARM_MPS2_M4(),
02231     ARM_MPS2_M7(),
02232 
02233     ARM_IOTSS_BEID(),
02234 
02235     ### Renesas ###
02236     RZ_A1H(),
02237 
02238     ### Maxim Integrated ###
02239     MAXWSNENV(),
02240     MAX32600MBED(),
02241 
02242     ### Silicon Labs ###
02243     EFM32GG_STK3700(),
02244     EFM32LG_STK3600(),
02245     EFM32WG_STK3800(),
02246     EFM32ZG_STK3200(),
02247     EFM32HG_STK3400(),
02248     EFM32PG_STK3401(),
02249 
02250     ### WIZnet ###
02251     WIZWIKI_W7500(),
02252     WIZWIKI_W7500P(),
02253     WIZWIKI_W7500ECO(),
02254 
02255     ### Atmel ###
02256     SAMR21G18A(),
02257     SAMD21J18A(),
02258     SAMD21G18A(),
02259     SAML21J18A(),
02260 ]
02261 
02262 # Map each target name to its unique instance
02263 TARGET_MAP = {}
02264 for t in TARGETS:
02265     TARGET_MAP[t.name] = t
02266 
02267 TARGET_NAMES = TARGET_MAP.keys()
02268 
02269 # Some targets with different name have the same exporters
02270 EXPORT_MAP = { }
02271 
02272 # Detection APIs
02273 def get_target_detect_codes ():
02274     """ Returns dictionary mapping detect_code -> platform_name
02275     """
02276     result = {}
02277     for target in TARGETS:
02278         for detect_code in target.detect_code:
02279             result[detect_code] = target.name
02280     return result