py-eb-model 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

eb_model/parser/eb_parser.py

@@ -8,14 +8,15 @@ from typing import List
 from ..models.eb_doc import EBModel, PreferenceModel
 from ..models.abstract import EcucRefType, Module
 
-class AbstractEbModelParser(metaclass = ABCMeta):
+
+class AbstractEbModelParser(metaclass=ABCMeta):
 
     def __init__(self) -> None:
         self.nsmap = {}
 
         self.logger = logging.getLogger()
 
-        if type(self) == "AbstractEBModelParser":
+        if type(self) is AbstractEbModelParser:
             raise ValueError("Abstract EBModelParser cannot be initialized.")
         
     def validate_root(self, element: ET.Element):
@@ -39,7 +40,6 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         '''
             Internal function and please call _read_ref_value instead of it
         '''
-        #match = re.match(r'ASPath.*\/(.*)', value)
         match = re.match(r'ASPath:(.*)', value)
         if (match):
             return match.group(1)
@@ -60,18 +60,20 @@ class AbstractEbModelParser(metaclass = ABCMeta):
 
     def read_value(self, parent: ET.Element, name: str) -> str:
         tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
-        if tag == None:
+        if tag is None:
             raise KeyError("XPath d:var[@name='%s'] is invalid" % name)
         return self._convert_value(tag)
 
-    def read_optional_value(self, parent: ET.Element, name: str, default_value = None) -> str:
+    def read_optional_value(self, parent: ET.Element, name: str, default_value=None) -> str:
         tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
         if tag is None:
             return default_value
-        if ('value' not in tag.attrib):
+        if 'value' not in tag.attrib:
             return default_value
         enable = self.read_attrib(tag, 'ENABLE')
-        if (enable == 'false'):
+        if enable is None:
+            return default_value
+        if enable.upper() == "FALSE":
             return default_value
         return self._convert_value(tag)
 
@@ -85,7 +87,7 @@ class AbstractEbModelParser(metaclass = ABCMeta):
     def read_ref_value(self, parent: ET.Element, name: str) -> EcucRefType:
         tag = parent.find(".//d:ref[@name='%s']" % name, self.nsmap)
         if tag is None:
-             raise KeyError("XPath d:ref[@name='%s'] is invalid" % name)
+            raise KeyError("XPath d:ref[@name='%s'] is invalid" % name)
         if 'value' in tag.attrib:
             return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
         return None
@@ -93,8 +95,11 @@ class AbstractEbModelParser(metaclass = ABCMeta):
     def read_optional_ref_value(self, parent: ET.Element, name: str) -> EcucRefType:
         tag = parent.find(".//d:ref[@name='%s']" % name, self.nsmap)
         enable = self.read_attrib(tag, 'ENABLE')
-        if (enable == 'false'):
+        if enable is None:
+            return None
+        if enable.upper() == "FALSE":
             return None
+        
         return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
 
     def read_ref_value_list(self, parent: ET.Element, name: str) -> List[EcucRefType]:
@@ -102,7 +107,7 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         for tag in parent.findall(".//d:lst[@name='%s']/d:ref" % name, self.nsmap):
             ref_value_list.append(EcucRefType(self.read_ref_raw_value(tag.attrib['value'])))
         return ref_value_list
-
+    
     def find_ctr_tag_list(self, parent: ET.Element, name: str) -> List[ET.Element]:
         return parent.findall(".//d:lst[@name='%s']/d:ctr" % name, self.nsmap)
     
@@ -111,26 +116,26 @@ class AbstractEbModelParser(metaclass = ABCMeta):
 
     def find_ctr_tag(self, parent: ET.Element, name: str) -> ET.Element:
         '''
-        Read the child ctr tag. 
+        Read the child ctr tag.
         '''
         tag = parent.find(".//d:ctr[@name='%s']" % name, self.nsmap)
         if tag is None:
             return None
         enable = self.read_attrib(tag, 'ENABLE')
-        # ctr has the value if 
+        # ctr has the value if
         #   1. enable attribute do not exist
         #   2. enable attribute is not false
-        if enable is not None and enable == "false":    
+        if enable is not None and enable.upper() == "FALSE":
             return None
         return tag
 
-    def create_ctr_tag(self, name: str, type: str)-> ET.Element:
+    def create_ctr_tag(self, name: str, type: str) -> ET.Element:
         ctr_tag = ET.Element("d:ctr")
         ctr_tag.attrib['name'] = name
         ctr_tag.attrib['type'] = type
         return ctr_tag
 
-    def create_ref_tag(self, name:str, type: str, value = "")-> ET.Element:
+    def create_ref_tag(self, name: str, type: str, value: str = "") -> ET.Element:
         ref_tag = ET.Element("d:ref")
         ref_tag.attrib['name'] = name
         ref_tag.attrib['type'] = type
@@ -138,20 +143,20 @@ class AbstractEbModelParser(metaclass = ABCMeta):
             ref_tag.attrib['value'] = "ASPath:%s" % value
         return ref_tag
 
-    def create_choice_tag(self, name:str, type:str, value: str)-> ET.Element:
+    def create_choice_tag(self, name: str, type: str, value: str) -> ET.Element:
         choice_tag = ET.Element("d:chc")
         choice_tag.attrib['name'] = name
         choice_tag.attrib['type'] = type
         choice_tag.attrib['value'] = value
         return choice_tag
 
-    def create_attrib_tag(self, name:str, value: str) -> ET.Element:
+    def create_attrib_tag(self, name: str, value: str) -> ET.Element:
         attrib_tag = ET.Element("a:a")
         attrib_tag.attrib['name'] = name
         attrib_tag.attrib['value'] = value
         return attrib_tag
 
-    def create_ref_lst_tag(self, name:str, type:str = "", ref_list: List[str] = []) -> ET.Element:
+    def create_ref_lst_tag(self, name: str, type: str = "", ref_list: List[str] = []) -> ET.Element:
         lst_tag = ET.Element("d:lst")
         lst_tag.attrib['name'] = name
         for ref in ref_list:
@@ -169,7 +174,7 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         return parent.find(".//d:lst[@name='%s']" % name, self.nsmap)
 
     def read_attrib(self, parent: ET.Element, name: str) -> str:
-        attrib_tag = parent.find(".//a:a[@name='%s']" % name, self.nsmap)
+        attrib_tag = parent.find("a:a[@name='%s']" % name, self.nsmap)
         if attrib_tag is None:
             return None
         return attrib_tag.attrib['value']
@@ -177,6 +182,9 @@ class AbstractEbModelParser(metaclass = ABCMeta):
     def read_namespaces(self, xdm: str):
         self.nsmap = dict([node for _, node in ET.iterparse(xdm, events=['start-ns'])])
 
+    # def set_namespace(self, key: str, value: str):
+    #    self.nsmap[key] = value
+
     def parse(self, element: ET.Element, doc: EBModel):
         pass
 
@@ -199,4 +207,4 @@ class AbstractEbModelParser(metaclass = ABCMeta):
 
     def parse_preference_xdm(self, filename: str, doc: EBModel):
         root_tag = self.load_xdm(filename)
-        self.parse_preference(root_tag, doc)
+        self.parse_preference(root_tag, doc)

eb_model/parser/nvm_xdm_parser.py

@@ -1,6 +1,6 @@
 import xml.etree.ElementTree as ET
 
-from ..models.nvm_xdm import NvM, NvMBlockDescriptor
+from ..models.nvm_xdm import NvM, NvMBlockDescriptor, NvMCommon, NvMEaRef, NvMFeeRef, NvMInitBlockCallback, NvMSingleBlockCallback
 from ..models.eb_doc import EBModel
 from ..parser.eb_parser import AbstractEbModelParser
 
@@ -23,22 +23,99 @@ class NvMXdmParser(AbstractEbModelParser):
 
         self.nvm = nvm
 
+        self.read_nvm_common(element, nvm)
         self.read_nvm_block_descriptors(element, nvm)
 
+    def read_nvm_common(self, element: ET.Element, nvm: NvM):
+        ctr_tag = self.find_ctr_tag(element, "NvMCommon")
+        if ctr_tag is not None:
+            nvm_common = NvMCommon(nvm, "NvMCommon")
+            nvm_common.setNvMApiConfigClass(self.read_value(ctr_tag, "NvMApiConfigClass"))
+            nvm_common.setNvMBswMMultiBlockJobStatusInformation(self.read_value(ctr_tag, "NvMBswMMultiBlockJobStatusInformation"))
+            nvm_common.setNvMCompiledConfigId(self.read_value(ctr_tag, "NvMCompiledConfigId"))
+            nvm_common.setNvMCrcNumOfBytes(self.read_value(ctr_tag, "NvMCrcNumOfBytes"))
+            nvm_common.setNvMCsmRetryCounter(self.read_optional_value(ctr_tag, "NvMCsmRetryCounter"))
+            nvm_common.setNvMDatasetSelectionBits(self.read_value(ctr_tag, "NvMDatasetSelectionBits"))
+            nvm_common.setNvMDevErrorDetect(self.read_value(ctr_tag, "NvMDevErrorDetect"))
+            nvm_common.setNvMDynamicConfiguration(self.read_value(ctr_tag, "NvMDynamicConfiguration"))
+            nvm_common.setNvMJobPrioritization(self.read_value(ctr_tag, "NvMJobPrioritization"))
+            nvm_common.setNvMMainFunctionPeriod(self.read_value(ctr_tag, "NvMMainFunctionPeriod"))
+            nvm_common.setNvMMultiBlockCallback(self.read_optional_value(ctr_tag, "NvMMultiBlockCallback"))
+            nvm_common.setNvMPollingMode(self.read_value(ctr_tag, "NvMPollingMode"))
+            nvm_common.setNvMRepeatMirrorOperations(self.read_value(ctr_tag, "NvMRepeatMirrorOperations"))
+            nvm_common.setNvMSetRamBlockStatusApi(self.read_value(ctr_tag, "NvMSetRamBlockStatusApi"))
+            nvm_common.setNvMSizeImmediateJobQueue(self.read_optional_value(ctr_tag, "NvMSizeImmediateJobQueue"))
+            nvm_common.setNvMSizeStandardJobQueue(self.read_value(ctr_tag, "NvMSizeStandardJobQueue"))
+            nvm_common.setNvMVersionInfoApi(self.read_value(ctr_tag, "NvMVersionInfoApi"))
+            nvm_common.setNvMBufferAlignmentValue(self.read_value(ctr_tag, "NvMBufferAlignmentValue"))
+            for ref in self.read_ref_value_list(ctr_tag, "NvMEcucPartitionRef"):
+                nvm_common.addNvMEcucPartitionRef(ref)
+            nvm_common.setNvMMasterEcucPartitionRef(self.read_ref_value(ctr_tag, "NvMMasterEcucPartitionRef"))
+
+            nvm.setNvMCommon(nvm_common)
+
+    def read_nvm_init_block_callback(self, element: ET.Element, nvm_block: NvMBlockDescriptor):
+        ctr_tag = self.find_ctr_tag(element, "NvMInitBlockCallback")
+        if ctr_tag is not None:
+            init_block_callback = NvMInitBlockCallback(nvm_block, "NvMInitBlockCallback")
+            init_block_callback.setNvMInitBlockCallbackFnc(self.read_value(ctr_tag, "NvMInitBlockCallbackFnc"))
+            nvm_block.setNvMInitBlockCallback(init_block_callback)
+
+    def read_nvm_single_block_callback(self, element: ET.Element, nvm_block: NvMBlockDescriptor):
+        ctr_tag = self.find_ctr_tag(element, "NvMSingleBlockCallback")
+        if ctr_tag is not None:
+            single_block_callback = NvMSingleBlockCallback(nvm_block, "NvMSingleBlockCallback")
+            single_block_callback.setNvMSingleBlockCallbackFnc(self.read_value(ctr_tag, "NvMSingleBlockCallbackFnc"))
+            nvm_block.setNvMSingleBlockCallback(single_block_callback)
+
+    def read_nvm_block_target_block_reference(self, element: ET.Element, nvm_block: NvMBlockDescriptor):
+        block_ref = self.read_choice_value(element, "NvMTargetBlockReference")
+        if block_ref == "NvMEaRef":
+            ctr_tag = self.find_ctr_tag(element, "NvMEaRef")
+            if ctr_tag is not None:
+                ref = NvMEaRef(nvm_block, block_ref)
+                ref.setNvMNameOfEaBlock(self.read_ref_value(element, "NvMNameOfEaBlock"))
+                nvm_block.setNvMTargetBlockReference(ref)
+        elif block_ref == "NvMFeeRef":
+            ctr_tag = self.find_ctr_tag(element, "NvMFeeRef")
+            if ctr_tag is not None:
+                ref = NvMFeeRef(nvm_block, block_ref)
+                ref.setNvMNameOfFeeBlock(self.read_ref_value(element, "NvMNameOfFeeBlock"))
+                nvm_block.setNvMTargetBlockReference(ref)
+        else:
+            raise ValueError("Invalid block reference type <%s>" % block_ref)
+
     def read_nvm_block_descriptors(self, element: ET.Element, nvm: NvM):
         for ctr_tag in self.find_ctr_tag_list(element, "NvMBlockDescriptor"):
             nvm_block = NvMBlockDescriptor(nvm, ctr_tag.attrib["name"])
-            nvm_block.setNvMBlockCrcType(self.read_optional_value(ctr_tag, "NvMBlockCrcType")) \
-                     .setNvMBlockEcucPartitionRef(self.read_ref_value(ctr_tag, "NvMBlockEcucPartitionRef")) \
-                     .setNvMNvramBlockIdentifier(self.read_value(ctr_tag, "NvMNvramBlockIdentifier")) \
-                     .setNvMRamBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRamBlockDataAddress")) \
-                     .setNvMRomBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRomBlockDataAddress")) \
-                     .setNvMRomBlockNum(self.read_value(ctr_tag, "NvMRomBlockNum")) \
-                     .setNvMBlockManagementType(self.read_value(ctr_tag, "NvMBlockManagementType")) \
-                     .setNvMNvBlockLength(self.read_value(ctr_tag, "NvMNvBlockLength")) \
-                     .setNvMNvBlockNum(self.read_value(ctr_tag, "NvMNvBlockNum")) \
-                     .setNvMSelectBlockForReadAll(self.read_value(ctr_tag, "NvMSelectBlockForReadAll")) \
-                     .setNvMSelectBlockForWriteAll(self.read_value(ctr_tag, "NvMSelectBlockForWriteAll")) 
+            nvm_block.setNvMBlockCrcType(self.read_optional_value(ctr_tag, "NvMBlockCrcType"))
+            nvm_block.setNvMBlockEcucPartitionRef(self.read_ref_value(ctr_tag, "NvMBlockEcucPartitionRef"))
+            nvm_block.setNvMNvramBlockIdentifier(self.read_value(ctr_tag, "NvMNvramBlockIdentifier"))
+            nvm_block.setNvMRamBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRamBlockDataAddress"))
+            nvm_block.setNvMRomBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRomBlockDataAddress"))
+            nvm_block.setNvMBlockJobPriority(self.read_value(ctr_tag, "NvMBlockJobPriority"))
+            nvm_block.setNvMResistantToChangedSw(self.read_value(ctr_tag, "NvMResistantToChangedSw"))
+            nvm_block.setNvMBlockCrcType(self.read_value(ctr_tag, "NvMBlockCrcType"))
+            nvm_block.setNvMBlockUseCrc(self.read_value(ctr_tag, "NvMBlockUseCrc"))
+            nvm_block.setNvMRomBlockNum(self.read_value(ctr_tag, "NvMRomBlockNum"))
+            nvm_block.setNvMBlockManagementType(self.read_value(ctr_tag, "NvMBlockManagementType"))
+            nvm_block.setNvMNvBlockLength(self.read_value(ctr_tag, "NvMNvBlockLength"))
+            nvm_block.setNvMNvBlockNum(self.read_value(ctr_tag, "NvMNvBlockNum"))
+            nvm_block.setNvMSelectBlockForReadAll(self.read_value(ctr_tag, "NvMSelectBlockForReadAll"))
+            nvm_block.setNvMSelectBlockForWriteAll(self.read_value(ctr_tag, "NvMSelectBlockForWriteAll"))
+
+            nvm_block.setNvMProvideRteJobFinishedPort(self.read_value(ctr_tag, "NvMProvideRteJobFinishedPort"))
+            nvm_block.setNvMProvideRteServicePort(self.read_value(ctr_tag, "NvMProvideRteServicePort"))
+
+            nvm_block.setNvMReadRamBlockFromNvCallback(self.read_optional_value(ctr_tag, "NvMReadRamBlockFromNvCallback"))
+            nvm_block.setNvMWriteRamBlockToNvCallback(self.read_optional_value(ctr_tag, "NvMWriteRamBlockToNvCallback"))
+            nvm_block.setNvMBlockUseSyncMechanism(self.read_value(ctr_tag, "NvMBlockUseSyncMechanism"))
+
+            self.read_nvm_init_block_callback(ctr_tag, nvm_block)
+            self.read_nvm_single_block_callback(ctr_tag, nvm_block)
+            
+            nvm_block.setNvMNvBlockBaseNumber(self.read_value(ctr_tag, "NvMNvBlockBaseNumber"))
+            self.read_nvm_block_target_block_reference(ctr_tag, nvm_block)
 
             nvm.addNvMBlockDescriptor(nvm_block)
                      

eb_model/parser/os_xdm_parser.py

@@ -3,7 +3,7 @@ from ..models.eb_doc import EBModel
 from ..models.os_xdm import Os, OsAlarm, OsAlarmActivateTask, OsAlarmCallback, OsAlarmIncrementCounter, OsAlarmSetEvent, OsCounter, OsResource
 from ..models.os_xdm import OsScheduleTable
 from ..models.os_xdm import OsTask, OsIsr, OsApplication, OsScheduleTableEventSetting, OsScheduleTableExpiryPoint, OsScheduleTableTaskActivation
-from ..models.os_xdm import OsScheduleTblAdjustableExpPoint, OsTaskAutostart
+from ..models.os_xdm import OsScheduleTblAdjustableExpPoint, OsTaskAutostart, OsMicrokernel, MkMemoryProtection, MkMemoryRegion
 from ..parser.eb_parser import AbstractEbModelParser
 
 
@@ -32,6 +32,7 @@ class OsXdmParser(AbstractEbModelParser):
         self.read_os_counters(element, os)
         self.read_os_applications(element, os)
         self.read_os_resources(element, os)
+        self.read_os_microkernel(element, os)
 
     def read_os_task_autostart(self, element: ET.Element, os_task: OsTask):
         ctr_tag = self.find_ctr_tag(element, "OsTaskAutostart")
@@ -44,11 +45,11 @@ class OsXdmParser(AbstractEbModelParser):
     def read_os_tasks(self, element: ET.Element, os: Os):
         for ctr_tag in self.find_ctr_tag_list(element, "OsTask"):
             os_task = OsTask(os, ctr_tag.attrib["name"])
-            os_task.setOsTaskPriority(int(self.read_value(ctr_tag, "OsTaskPriority"))) \
-                .setOsTaskActivation(self.read_value(ctr_tag, "OsTaskActivation")) \
-                .setOsTaskSchedule(self.read_value(ctr_tag, "OsTaskSchedule")) \
-                .setOsTaskType(self.read_optional_value(ctr_tag, "OsTaskType")) \
-                .setOsStacksize(int(self.read_optional_value(ctr_tag, "OsStacksize", 0)))
+            os_task.setOsTaskPriority(int(self.read_value(ctr_tag, "OsTaskPriority")))
+            os_task.setOsTaskActivation(self.read_value(ctr_tag, "OsTaskActivation"))
+            os_task.setOsTaskSchedule(self.read_value(ctr_tag, "OsTaskSchedule"))
+            os_task.setOsTaskType(self.read_optional_value(ctr_tag, "OsTaskType"))
+            os_task.setOsStacksize(int(self.read_value(ctr_tag, "OsStacksize")))
 
             for resource_ref in self.read_ref_value_list(ctr_tag, "OsTaskResourceRef"):
                 os_task.addOsTaskResourceRef(resource_ref)
@@ -61,16 +62,26 @@ class OsXdmParser(AbstractEbModelParser):
     def read_os_isrs(self, element: ET.Element, os: Os):
         for ctr_tag in self.find_ctr_tag_list(element, "OsIsr"):
             os_isr = OsIsr(os, ctr_tag.attrib["name"])
-            os_isr.setOsIsrCategory(self.read_value(ctr_tag, "OsIsrCategory")) \
-                .setOsIsrPeriod(self.read_optional_value(ctr_tag, "OsIsrPeriod", 0.0)) \
-                .setOsStacksize(int(self.read_value(ctr_tag, "OsStacksize"))) \
-                .setOsIsrPriority(self.read_optional_value(ctr_tag, "OsIsrPriority"))
+            os_isr.setOsIsrCategory(self.read_value(ctr_tag, "OsIsrCategory"))
+            os_isr.setOsIsrPeriod(self.read_optional_value(ctr_tag, "OsIsrPeriod", 0.0))
+            os_isr.setOsStacksize(int(self.read_value(ctr_tag, "OsStacksize")))
+            os_isr.setOsIsrPriority(self.read_optional_value(ctr_tag, "OsIsrPriority"))
             
-            # patch for the infineon Aurix
+            # Infineon Aurix Tricore
             os_isr.setOsIsrPriority(self.read_optional_value(ctr_tag, "OsTricoreIrqLevel"))
-            # patch for the ARM
+            os_isr.setOsIsrVector(self.read_optional_value(ctr_tag, "OsTricoreVector"))
+            os_isr.setOsTricoreIrqLevel(self.read_optional_value(ctr_tag, "OsTricoreIrqLevel"))
+            os_isr.setOsTricoreVector(self.read_optional_value(ctr_tag, "OsTricoreVector"))
+            
+            # ARM Core
             os_isr.setOsIsrPriority(self.read_optional_value(ctr_tag, "OsARMIrqLevel"))
             os_isr.setOsIsrVector(self.read_optional_value(ctr_tag, "OsARMVector"))
+            os_isr.setOsARMIrqLevel(self.read_optional_value(ctr_tag, "OsARMIrqLevel"))
+            os_isr.setOsARMVector(self.read_optional_value(ctr_tag, "OsARMVector"))
+
+            # EB Safety OS
+            for ref in self.read_ref_value_list(ctr_tag, "OsIsrMkMemoryRegionRef"):
+                os_isr.addOsIsrMkMemoryRegionRef(ref)
 
             self.logger.debug("Read OsIsr <%s>" % os_isr.getName())
             os.addOsIsr(os_isr)
@@ -190,9 +201,42 @@ class OsXdmParser(AbstractEbModelParser):
     def read_os_resources(self, element: ET.Element, os: Os):
         for ctr_tag in self.find_ctr_tag_list(element, "OsResource"):
             os_res = OsResource(os, ctr_tag.attrib["name"])
+            os_res.setImporterInfo(self.read_attrib(ctr_tag, "IMPORTER_INFO"))
             os_res.setOsResourceProperty(self.read_value(ctr_tag, "OsResourceProperty"))
 
             for ref in self.read_ref_value_list(ctr_tag, "OsResourceAccessingApplication"):
                 os_res.addOsResourceAccessingApplicationRefs(ref)
 
             os.addOsResource(os_res)
+
+    def read_mk_memory_regions(self, element: ET.Element, protection: MkMemoryProtection):
+        for ctr_tag in self.find_ctr_tag_list(element, "MkMemoryRegion"):
+            # self.logger.info("Read MkMemoryRegion %s" % ctr_tag.attrib["name"])
+            region = MkMemoryRegion(protection, ctr_tag.attrib["name"])
+            region.setMkMemoryRegionFlags(self.read_value(ctr_tag, "MkMemoryRegionFlags"))
+            region.setMkMemoryRegionInitialize(self.read_value(ctr_tag, "MkMemoryRegionInitialize"))
+            region.setMkMemoryRegionGlobal(self.read_value(ctr_tag, "MkMemoryRegionGlobal"))
+            region.setMkMemoryRegionInitThreadAccess(self.read_value(ctr_tag, "MkMemoryRegionInitThreadAccess"))
+            region.setMkMemoryRegionIdleThreadAccess(self.read_value(ctr_tag, "MkMemoryRegionIdleThreadAccess"))
+            region.setMkMemoryRegionOsThreadAccess(self.read_value(ctr_tag, "MkMemoryRegionOsThreadAccess"))
+            region.setMkMemoryRegionErrorHookAccess(self.read_value(ctr_tag, "MkMemoryRegionErrorHookAccess"))
+            region.setMkMemoryRegionProtHookAccess(self.read_value(ctr_tag, "MkMemoryRegionProtHookAccess"))
+            region.setMkMemoryRegionShutdownHookAccess(self.read_value(ctr_tag, "MkMemoryRegionShutdownHookAccess"))
+            region.setMkMemoryRegionShutdownAccess(self.read_value(ctr_tag, "MkMemoryRegionShutdownAccess"))
+            region.setMkMemoryRegionInitializePerCore(self.read_value(ctr_tag, "MkMemoryRegionInitializePerCore"))
+            protection.addMkMemoryRegion(region)
+
+    def read_mk_memory_protection(self, element: ET.Element, kernel: OsMicrokernel):
+        ctr_tag = self.find_ctr_tag(element, "MkMemoryProtection")
+        if ctr_tag is not None:
+            # self.logger.info("Read MkMemoryProtection")
+            protection = MkMemoryProtection(kernel, ctr_tag.attrib["name"])
+            self.read_mk_memory_regions(ctr_tag, protection)
+            kernel.setMkMemoryProtection(protection)
+
+    def read_os_microkernel(self, element: ET.Element, os: Os):
+        ctr_tag = self.find_ctr_tag(element, "OsMicrokernel")
+        if ctr_tag is not None:
+            kernel = OsMicrokernel(os, ctr_tag.attrib["name"])
+            self.read_mk_memory_protection(ctr_tag, kernel)
+            os.setOsMicrokernel(kernel)

eb_model/parser/rte_xdm_parser.py

@@ -1,9 +1,11 @@
 import xml.etree.ElementTree as ET
 
-from ..models.rte_xdm import Rte, RteBswEventToTaskMapping, RteBswEventToTaskMappingV3, RteBswEventToTaskMappingV4, RteBswModuleInstance, RteEventToTaskMapping, RteEventToTaskMappingV3, RteEventToTaskMappingV4, RteSwComponentInstance
+from ..models.rte_xdm import Rte, RteBswEventToTaskMapping, RteBswEventToTaskMappingV3, RteBswEventToTaskMappingV4, RteBswModuleInstance
+from ..models.rte_xdm import RteEventToTaskMapping, RteEventToTaskMappingV3, RteEventToTaskMappingV4, RteSwComponentInstance
 from ..models.eb_doc import EBModel
 from ..parser.eb_parser import AbstractEbModelParser
 
+
 class RteXdmParser(AbstractEbModelParser):
     def __init__(self, ) -> None:
         super().__init__()
@@ -16,16 +18,12 @@ class RteXdmParser(AbstractEbModelParser):
         rte = doc.getRte()
         self.read_version(element, rte)
 
-        self.logger.info("Parse Rte ARVersion:<%s> SwVersion:<%s>" % 
-                         (rte.getArVersion().getVersion(), rte.getSwVersion().getVersion()))
-        
+        self.logger.info("Parse Rte ARVersion:<%s> SwVersion:<%s>" % (rte.getArVersion().getVersion(), rte.getSwVersion().getVersion()))
         self.rte = rte
 
         self.read_rte_bsw_module_instances(element, rte)
         self.read_rte_sw_component_instances(element, rte)
 
-        
-
     def read_rte_bsw_module_instance_event_to_task_mappings(self, element: ET.Element, instance: RteBswModuleInstance):
         for ctr_tag in self.find_ctr_tag_list(element, "RteBswEventToTaskMapping"):
             self.logger.debug("Read RteBswEventToTaskMapping <%s>" % ctr_tag.attrib['name'])
@@ -38,7 +36,7 @@ class RteXdmParser(AbstractEbModelParser):
             mapping.setRteBswActivationOffset(self.read_optional_value(ctr_tag, "RteBswActivationOffset")) \
                 .setRteBswEventPeriod(self.read_optional_value(ctr_tag, "RteBswPeriod")) \
                 .setRteBswPositionInTask(self.read_optional_value(ctr_tag, "RteBswPositionInTask")) \
-                .setRteBswServerQueueLength(self.read_optional_value(ctr_tag, "RteBswServerQueueLength")) 
+                .setRteBswServerQueueLength(self.read_optional_value(ctr_tag, "RteBswServerQueueLength"))
             
             if isinstance(mapping, RteBswEventToTaskMappingV4):
                 for resource_ref in self.read_ref_value_list(ctr_tag, "RteBswEventRef"):
@@ -56,7 +54,7 @@ class RteXdmParser(AbstractEbModelParser):
             instance = RteBswModuleInstance(rte, ctr_tag.attrib['name'])
             instance.setRteBswImplementationRef(self.read_ref_value(ctr_tag, "RteBswImplementationRef")) \
                 .setRteMappedToOsApplicationRef(self.read_optional_ref_value(ctr_tag, "RteMappedToOsApplicationRef"))
-
+            
             self.read_rte_bsw_module_instance_event_to_task_mappings(ctr_tag, instance)
             rte.addRteBswModuleInstance(instance)
 
@@ -71,7 +69,7 @@ class RteXdmParser(AbstractEbModelParser):
             mapping.setRteActivationOffset(self.read_optional_value(ctr_tag, "RteActivationOffset")) \
                 .setRtePeriod(self.read_optional_value(ctr_tag, "RtePeriod")) \
                 .setRtePositionInTask(self.read_optional_value(ctr_tag, "RtePositionInTask")) \
-                .setRteServerQueueLength(self.read_optional_value(ctr_tag, "RteServerQueueLength")) 
+                .setRteServerQueueLength(self.read_optional_value(ctr_tag, "RteServerQueueLength"))
             
             if isinstance(mapping, RteEventToTaskMappingV4):
                 for resource_ref in self.read_ref_value_list(ctr_tag, "RteEventRef"):
@@ -80,6 +78,8 @@ class RteXdmParser(AbstractEbModelParser):
                 mapping.setRteEventRef(self.read_ref_value(ctr_tag, "RteEventRef"))
 
             mapping.setRteMappedToTaskRef(self.read_optional_ref_value(ctr_tag, "RteMappedToTaskRef"))
+
+            self.logger.debug("Rte Event %s" % mapping.getRteEventRef().getShortName())
             
             instance.addRteEventToTaskMapping(mapping)
 
@@ -89,7 +89,7 @@ class RteXdmParser(AbstractEbModelParser):
 
             instance = RteSwComponentInstance(rte, ctr_tag.attrib['name'])
             instance.setMappedToOsApplicationRef(self.read_optional_ref_value(ctr_tag, "MappedToOsApplicationRef")) \
-                .setRteSoftwareComponentInstanceRef(self.read_optional_ref_value(ctr_tag, "RteSoftwareComponentInstanceRef"))
+                    .setRteSoftwareComponentInstanceRef(self.read_optional_ref_value(ctr_tag, "RteSoftwareComponentInstanceRef"))
             
             self.read_rte_sw_component_instance_event_to_task_mappings(ctr_tag, instance)
-            rte.addRteSwComponentInstance(instance)
+            rte.addRteSwComponentInstance(instance)

eb_model/reporter/excel_reporter/abstract.py

@@ -10,24 +10,26 @@ class ExcelReporter:
         self.wb = Workbook()
         self.logger = logging.getLogger()
     
-    def auto_width(self, worksheet: Worksheet):
+    def auto_width(self, worksheet, customized={}):
         dims = {}
         for row in worksheet.rows:
             for cell in row:
                 if cell.value:
-                    alignment = cell.alignment      # type: Alignment
-                    if (alignment.wrapText is True):
-                        continue
                     dims[cell.column_letter] = max((dims.get(cell.column_letter, 0), len(str(cell.value))))
 
         for col, value in dims.items():
-            # worksheet.column_dimensions[col].width = (value + 2) + 2
-            worksheet.column_dimensions[col].width = (value + 2)
+            self.logger.debug("Sheet:%s , column: %s, width: %d" % (str(worksheet), col, value))
+            if col in customized:
+                if customized[col] != 0:
+                    worksheet.column_dimensions[col].width = customized[col]
+            else:
+                worksheet.column_dimensions[col].width = value + 4
 
     def write_title_row(self, sheet: Worksheet, title_row):
         for idx in range(0, len(title_row)):
             cell = sheet.cell(row=1, column=idx + 1)
             cell.value = title_row[idx]
+            cell.alignment = Alignment(horizontal="center")
 
     def write_cell(self, sheet: Worksheet, row: int, column: int, value, format=None) -> Cell:
         cell = sheet.cell(row=row, column=column)         # type: Cell
@@ -38,6 +40,18 @@ class ExcelReporter:
             if ('number_format' in format):
                 cell.number_format = format['number_format']
         return cell
+    
+    def write_cell_center(self, sheet: Worksheet, row: int, column: int, value) -> Cell:
+        self.write_cell(sheet, row, column, value, format={"alignment": Alignment(horizontal="center")})
+    
+    def write_bool_cell(self, sheet: Worksheet, row: int, column: int, value) -> Cell:
+        self.write_cell_center(sheet, row, column, self.format_boolean(value))
+    
+    def format_boolean(self, value: bool) -> str:
+        if value is True:
+            return "Y"
+        else:
+            return ""
 
     def save(self, name: str):
         self.wb.save(name)