[uvision] Flash DLL string/debug

Versioning for arm-pack-manager

Author: sarahmarshy

tools/arm_pack_manager/__init__.py

@@ -162,14 +162,22 @@ def _extract_dict(self, device, filename, pack) :
                                                       size=m["size"]))
                                        for m in device("memory")])
         except (KeyError, TypeError, IndexError) as e : pass
-        try: to_ret["algorithm"] = dict(name=device.algorithm["name"].replace('\\','/'),
-                                       start=device.algorithm["start"],
-                                       size=device.algorithm["size"],
-                                       RAMstart=device.algorithm.get("ramstart",None),
-                                       RAMsize=device.algorithm.get("ramsize",None))
-
-
-        except (KeyError, TypeError, IndexError) as e : pass
+        try: algorithms = device("algorithm")
+        except:
+            try: algorithms = device.parent("algorithm")
+            except: pass
+        else:
+            if not algorithms:
+                try: algorithms = device.parent("algorithm")
+                except: pass
+        try : to_ret["algorithm"] = dict([(algo.get("name").replace('\\','/'),
+                                           dict(start=algo["start"],
+                                                size=algo["size"],
+                                                ramstart=algo.get("ramstart",None),
+                                                ramsize=algo.get("ramsize",None),
+                                                default=algo.get("default",1)))
+                                       for algo in algorithms])
+        except (KeyError, TypeError, IndexError) as e: pass
         try: to_ret["debug"] = device.parent.parent.debug["svd"]
         except (KeyError, TypeError, IndexError) as e : pass
         try: to_ret["debug"] = device.parent.debug["svd"]
@@ -225,48 +233,11 @@ def _extract_dict(self, device, filename, pack) :
 
         return to_ret
 
-    def _apply_device_debug(self, device, debug):
-        if device:
-            self._index[device].setdefault('debug-interface', [])
-            if "JTAG" not in debug and \
-               debug not in self._index[device]['debug-interface']:
-                self._index[device]['debug-interface'].append(debug)
-
-    def _apply_group_debug(self, key, search_val, pdsc, debug):
-        for fam in pdsc.findAll(key, {'d'+key: search_val}):
-            for dev in fam.findAll("device"):
-                self._apply_device_debug(dev("dname"), debug)
-
-    def _update_debug(self, d):
-        try:
-            pdsc = self.pdsc_from_cache(d)
-            for dev in pdsc("board"):
-                try:
-                    debug = dev.debuginterface['adapter']
-                except:
-                    try:
-                        odbg = dev.find("feature",{"type":"ODbg"})
-                        debug = odbg["name"]
-                    except:
-                        continue
-                for device in dev("compatibledevice") + dev("mounteddevice"):
-                    self._apply_group_debug("family",
-                                            device.get("dfamily",None),
-                                            pdsc, debug)
-                    self._apply_group_debug("subfamily",
-                                            device.get("dsubfamily", None),
-                                            pdsc, debug)
-                    self._apply_device_debug(device.get("dname", None), debug)
-        except (KeyError, TypeError, IndexError) as e:
-            stderr.write("[ ERROR ] file {}\n".format(d))
-            print(e)
-
     def _generate_index_helper(self, d) :
         try :
             pack = self.pdsc_to_pack(d)
             self._index.update(dict([(dev['dname'], self._extract_dict(dev, d, pack)) for dev in
                                     (self.pdsc_from_cache(d)("device"))]))
-            self._update_debug(d)
         except AttributeError as e :
             stderr.write("[ ERROR ] file {}\n".format(d))
             print(e)
@@ -318,6 +289,7 @@ def generate_index(self) :
         self.counter = 0
         do_queue(Reader, self._generate_index_helper, self.get_urls())
         with open(join(save_data_path('arm-pack-manager'), "index.json"), "wb+") as out:
+            self._index["version"] = "0.1.0"
             dump(self._index, out)
         stdout.write("\n")
 

tools/export/cmsis/__init__.py

@@ -4,6 +4,7 @@
 from xml.etree.ElementTree import Element, tostring
 import ntpath
 import re
+import json
 
 from xdg.BaseDirectory import save_data_path
 
@@ -34,7 +35,7 @@ class DeviceCMSIS():
     def __init__(self, target):
         cache = Cache(True, False)
         data_path = join(save_data_path('arm-pack-manager'), "index.json")
-        if not exists(data_path):
+        if not exists(data_path) or not self.check_version(data_path):
             cache.cache_descriptors()
 
         t = TARGET_MAP[target]
@@ -51,15 +52,22 @@ def __init__(self, target):
             except:
                 raise TargetNotSupportedException("Target not in CMSIS packs")
 
+        self.target_info = target_info
+
         self.url = target_info['pdsc_file']
         self.pack_url, self.pack_id = ntpath.split(self.url)
         self.dname = cpu_name
         self.dfpu = target_info['processor']['fpu']
-        self.debug_interface, self.dvendor = self.vendor_debug(target_info['vendor'])
+        self.debug, self.dvendor = self.vendor_debug(target_info['vendor'])
         self.dendian = target_info['processor'].get('endianness','Little-endian')
         self.debug_svd = target_info.get('debug', '')
         self.compile_header = target_info['compile']['header']
 
+    def check_version(self, filename):
+        with open(filename) as data_file:
+            data = json.load(data_file)
+            return data.get("version", "0") == "0.1.0"
+
     def vendor_debug(self, vendor):
         reg = "([\w\s]+):?\d*?"
         m = re.search(reg, vendor)
@@ -79,6 +87,7 @@ def cpu_cmsis(self):
         cpu = cpu.replace("F","_FP")
         return cpu
 
+
 class CMSIS(Exporter):
     NAME = 'cmsis'
     TOOLCHAIN = 'ARM'

tools/export/iar/__init__.py

@@ -108,7 +108,7 @@ def generate(self):
             'include_paths': [self.format_file(src) for src in self.resources.inc_dirs],
             'device': self.iar_device(),
             'ewp': sep+self.project_name + ".ewp",
-            'debugger': DeviceCMSIS(self.target).debug_interface.replace('-','').upper()
+            'debugger': DeviceCMSIS(self.target).debug.replace('-','').upper()
         }
         ctx.update(flags)
 

tools/export/uvision/__init__.py

@@ -5,6 +5,7 @@
 from collections import namedtuple
 from distutils.spawn import find_executable
 import subprocess
+import re
 
 from tools.arm_pack_manager import Cache
 from tools.targets import TARGET_MAP
@@ -26,10 +27,11 @@ def __init__(self, target):
             self.svd = dev_format.format(self.dname, self.debug_svd)
         self.reg_file = dev_format.format(self.dname, self.compile_header)
         self.debug_interface = self.uv_debug()
+        self.flash_dll = self.generate_flash_dll()
 
     def uv_debug(self):
         """Return a namedtuple of information about uvision debug settings"""
-        UVDebug = namedtuple('UVDebug',['bin_loc','core_flag'])
+        UVDebug = namedtuple('UVDebug',['bin_loc','core_flag', 'key'])
 
         # CortexMXn => pCMX
         cpu = self.core.replace("Cortex-", "C")
@@ -38,12 +40,72 @@ def uv_debug(self):
         cpu_flag = "p"+cpu
 
         # Locations found in Keil_v5/TOOLS.INI
-        debuggers = {"st-link":'STLink\\ST-LINKIII-KEIL_SWO.dll',
-                     "j-link":'Segger\\JL2CM3.dll',
-                     "cmsis-dap":'BIN\\CMSIS_AGDI.dll',
-                     "nulink":'NULink\\Nu_Link.dll'}
-        binary = debuggers[self.debug_interface.lower()]
-        return UVDebug(binary, cpu_flag)
+        debuggers = {"st-link": ('STLink\\ST-LINKIII-KEIL_SWO.dll', 'ST-LINKIII-KEIL_SWO'),
+                     "j-link":('Segger\\JL2CM3.dll', 'JL2CM3'),
+                     "cmsis-dap":('BIN\\CMSIS_AGDI.dll', 'CMSIS_AGDI'),
+                     "nulink":('NULink\\Nu_Link.dll','Nu_Link')}
+        res = debuggers[self.debug.lower()]
+        binary = res[0]
+        key = res[1]
+
+        return UVDebug(binary, cpu_flag, key)
+
+    def generate_flash_dll(self):
+        '''Flash DLL string from uvision
+        S = SW/JTAG Clock ID
+        C = CPU index in JTAG chain
+        P = Access Port
+        For the Options for Target -> Debug tab -> settings -> "Flash" tab in the dialog:
+        FD = RAM Start for Flash Functions
+        FC = RAM Size for Flash Functions
+        FN = Number of Flash types
+        FF = Flash File Name (without an extension)
+        FS = Start Address of the Flash Device
+        FL = Size of the Flash Device
+        FP = Full path to the Device algorithm (RTE)
+
+        Necessary to flash some targets. Info gathered from algorithms field of pdsc file.
+        '''
+        fl_count = 0
+        def get_mem_no_x(mem_str):
+            mem_reg = "\dx(\w+)"
+            m = re.search(mem_reg, mem_str)
+            return m.group(1) if m else None
+
+        RAMS = [(get_mem_no_x(info["start"]), get_mem_no_x(info["size"]))
+                for mem, info in self.target_info["memory"].items() if "RAM" in mem]
+        format_str = "UL2CM3(-S0 -C0 -P0 -FD{ramstart}"+" -FC{ramsize} "+"-FN{num_algos} {extra_flags})"
+        ramstart = ''
+        #Default according to Keil developer
+        ramsize = '1000'
+        if len(RAMS)>=1:
+            ramstart = RAMS[0][0]
+        extra_flags = []
+        for name, info in self.target_info["algorithm"].items():
+            if int(info["default"])==0:
+                continue
+            name_reg = "\w*/([\w_]+)\.flm"
+            m = re.search(name_reg, name.lower())
+            fl_name = m.group(1) if m else None
+            name_flag = "-FF" + str(fl_count) + fl_name
+
+            start, size = get_mem_no_x(info["start"]), get_mem_no_x(info["size"])
+            rom_start_flag = "-FS"+str(fl_count)+str(start)
+            rom_size_flag = "-FL" + str(fl_count) + str(size)
+
+            if info["ramstart"] is not None and info["ramsize"] is not None:
+                ramstart = get_mem_no_x(info["ramstart"])
+                ramsize = get_mem_no_x(info["ramsize"])
+
+            path_flag = "-FP" + str(fl_count) + "($$Device:"+self.dname+"$"+name+")"
+
+            extra_flags.extend([name_flag, rom_start_flag, rom_size_flag, path_flag])
+            fl_count += 1
+
+        extra = " ".join(extra_flags)
+        return format_str.format(ramstart=ramstart,
+                                 ramsize=ramsize,
+                                 extra_flags=extra, num_algos=fl_count)
 
 
 class Uvision(Exporter):
@@ -134,6 +196,7 @@ def generate(self):
                                   or 'd' in ctx['device'].core.lower() else 2
         ctx.update(self.format_flags())
         self.gen_file('uvision/uvision.tmpl', ctx, self.project_name+".uvprojx")
+        self.gen_file('uvision/uvision_debug.tmpl', ctx, self.project_name + ".uvoptx")
 
     def build(self):
         ERRORLEVEL = {

tools/export/uvision/uvision_debug.tmpl

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ProjectOpt xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_optx.xsd">
+	<SchemaVersion>1.0</SchemaVersion>
+	<Target>
+		<TargetName>{{name}}</TargetName>
+		<ToolsetNumber>0x4</ToolsetNumber>
+		<ToolsetName>ARM-ADS</ToolsetName>
+		<TargetOption>
+			<DebugOpt>
+				<uSim>0</uSim>
+				<uTrg>1</uTrg>
+				<nTsel>11</nTsel>
+				<pMon>{{device.debug_interface.bin_loc}}</pMon>
+			</DebugOpt>
+			<TargetDriverDllRegistry>
+				<SetRegEntry>
+					<Number>0</Number>
+					<Key>{{device.debug_interface.key}}</Key>
+					<Name>{{device.flash_dll}}</Name>
+				</SetRegEntry>
+			</TargetDriverDllRegistry>
+		</TargetOption>
+	</Target>
+</ProjectOpt>