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

eb_model/models/rte_xdm.py

@@ -21,6 +21,11 @@ class AbstractEventToTaskMapping(EcucParamConfContainerDef):
 
     def getRtePositionInTask(self):
         return self.rtePositionInTask
+    
+    def getRtePositionInTaskNumber(self) -> int:
+        if self.rtePositionInTask is None:
+            return 0
+        return self.rtePositionInTask
 
     def setRtePositionInTask(self, value):
         self.rtePositionInTask = value
@@ -185,7 +190,7 @@ class RteEventToTaskMappingV3(RteEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
 
-        self.rteEventRef = None
+        self.rteEventRef: EcucParamConfContainerDef = None
 
     def getRteEventRef(self) -> EcucRefType:
         return self.rteEventRef
@@ -199,17 +204,17 @@ class RteEventToTaskMappingV4(RteEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
 
-        self.rteEventRefs = []
+        self.rteEventRefs: List[EcucRefType] = []
 
-    def getRteEventRefs(self):
+    def getRteEventRefs(self) -> List[EcucRefType]:
         return self.rteEventRefs
 
-    def addRteEventRef(self, value):
+    def addRteEventRef(self, value: EcucRefType):
         if value is not None:
             self.rteEventRefs.append(value)
         return self
     
-    def getRteEventRef(self):
+    def getRteEventRef(self) -> EcucRefType:
         if len(self.rteEventRefs) != 1:
             raise ValueError("Unsupported RteEventRef of RteEventToTaskMapping <%s> " % self.name)
         return self.rteEventRefs[0]
@@ -341,12 +346,12 @@ class RteBswEventToTaskMappingV3(RteBswEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
 
-        self.rteBswEventRef = None                                      # type: EcucRefType
+        self.rteBswEventRef: EcucRefType = None
 
-    def getRteBswEventRef(self):
+    def getRteBswEventRef(self) -> EcucRefType:
         return self.rteBswEventRef
 
-    def setRteBswEventRef(self, value):
+    def setRteBswEventRef(self, value: EcucRefType):
         if value is not None:
             self.rteBswEventRef = value
         return self
@@ -356,16 +361,16 @@ class RteBswEventToTaskMappingV4(RteBswEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
         
-        self.rteBswEventRefs = []                                       # type: List[EcucRefType]
+        self.rteBswEventRefs: List[EcucRefType] = []
 
-    def getRteBswEventRefs(self) -> EcucRefType:
+    def getRteBswEventRefs(self) -> List[EcucRefType]:
         return self.rteBswEventRefs
 
     def addRteBswEventRef(self, value: EcucRefType):
         self.rteBswEventRefs.append(value)
         return self
     
-    def getRteBswEventRef(self):
+    def getRteBswEventRef(self) -> EcucRefType:
         if len(self.rteBswEventRefs) != 1:
             raise ValueError("Unsupported RteEventRef of RteEventToTaskMapping <%s> " % self.name)
         return self.rteBswEventRefs[0]

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/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")
@@ -66,11 +67,21 @@ class OsXdmParser(AbstractEbModelParser):
                 .setOsStacksize(int(self.read_value(ctr_tag, "OsStacksize"))) \
                 .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,12 @@ class ExcelReporter:
             if ('number_format' in format):
                 cell.number_format = format['number_format']
         return cell
+    
+    def format_boolean(self, value: bool) -> str:
+        if value is True:
+            return "Y"
+        else:
+            return "N"
 
     def save(self, name: str):
         self.wb.save(name)

eb_model/reporter/excel_reporter/os_xdm.py

@@ -49,24 +49,37 @@ class OsXdmXlsWriter(ExcelReporter):
     def write_os_isrs(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsIsr", 1)
 
-        title_row = ["Name", "OsApplication", "OsIsrCategory", "OsStacksize", "OsIsrPriority", "OsIsrVector"]
+        title_row = [
+            "Name", "OsApplication", "OsIsrCategory", "OsStacksize", "OsIsrPriority",
+            "OsIsrVector", "MkMemoryRegion"]
         self.write_title_row(sheet, title_row)
 
         row = 2
         for os_isr in doc.getOs().getOsIsrList():
-            self.write_cell(sheet, row, 1, os_isr.getName())
+            self.write_cell(sheet, row, 1, os_isr.getName(), {'alignment': Alignment(vertical="top")})
             os_app = doc.getOs().getOsIsrOsApplication(os_isr.getName())
             if os_app is not None:
-                self.write_cell(sheet, row, 2, os_app.getName())
-            self.write_cell(sheet, row, 3, os_isr.getOsIsrCategory())
-            self.write_cell(sheet, row, 4, os_isr.getOsStacksize())
-            self.write_cell(sheet, row, 5, os_isr.getOsIsrPriority())
-            self.write_cell(sheet, row, 6, os_isr.getOsIsrVector())
+                self.write_cell(sheet, row, 2, os_app.getName(),
+                                format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 3, os_isr.getOsIsrCategory(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 4, os_isr.getOsStacksize(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 5, os_isr.getOsIsrPriority(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 6, os_isr.getOsIsrVector(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            if len(os_isr.getOsIsrMkMemoryRegionRefs()) > 1:
+                self.write_cell(sheet, row, 7, "\n".join(map(lambda a: a.getShortName(), os_isr.getOsIsrMkMemoryRegionRefs())),
+                                {'alignment': Alignment(wrapText=True, vertical="top")})
+            else:
+                self.write_cell(sheet, row, 7, "\n".join(map(lambda a: a.getShortName(), os_isr.getOsIsrMkMemoryRegionRefs())),
+                                {'alignment': Alignment(vertical="top")})
             row += 1
 
             self.logger.debug("Write OsIsr <%s>" % os_isr.getName())
 
-        self.auto_width(sheet)
+        self.auto_width(sheet, {"G": 25})
 
     def write_os_schedule_tables(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsScheduleTable", 2)
@@ -77,9 +90,12 @@ class OsXdmXlsWriter(ExcelReporter):
         row = 2
         for os_schedule_table in doc.getOs().getOsScheduleTableList():
             self.write_cell(sheet, row, 1, os_schedule_table.getName())
-            self.write_cell(sheet, row, 2, os_schedule_table.getOsScheduleTableDuration())
-            self.write_cell(sheet, row, 3, os_schedule_table.getOsScheduleTableRepeating())
-            self.write_cell(sheet, row, 4, os_schedule_table.getOsScheduleTableCounterRef().getShortName())
+            self.write_cell(sheet, row, 2, os_schedule_table.getOsScheduleTableDuration(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 3, os_schedule_table.getOsScheduleTableRepeating(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 4, os_schedule_table.getOsScheduleTableCounterRef().getShortName(),
+                            format={'alignment': Alignment(horizontal="center")})
             row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % os_schedule_table.getName())
@@ -95,11 +111,16 @@ class OsXdmXlsWriter(ExcelReporter):
         row = 2
         for os_counter in doc.getOs().getOsCounterList():
             self.write_cell(sheet, row, 1, os_counter.getName())
-            self.write_cell(sheet, row, 2, os_counter.getOsCounterMaxAllowedValue())
-            self.write_cell(sheet, row, 3, os_counter.getOsCounterMinCycle())
-            self.write_cell(sheet, row, 4, os_counter.getOsCounterTicksPerBase())
-            self.write_cell(sheet, row, 5, os_counter.getOsCounterType())
-            self.write_cell(sheet, row, 6, os_counter.getOsSecondsPerTick())
+            self.write_cell(sheet, row, 2, os_counter.getOsCounterMaxAllowedValue(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 3, os_counter.getOsCounterMinCycle(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 4, os_counter.getOsCounterTicksPerBase(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 5, os_counter.getOsCounterType(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 6, os_counter.getOsSecondsPerTick(),
+                            format={'alignment': Alignment(horizontal="center")})
             row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % os_counter.getName())
@@ -109,7 +130,7 @@ class OsXdmXlsWriter(ExcelReporter):
     def write_expiry_points(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsScheduleTableExpiryPoint", 4)
 
-        title_row = ["ExpiryPoint", "OsScheduleTable", "OsCounter" "Offset (ms)", "Task"]
+        title_row = ["ExpiryPoint", "OsScheduleTable", "OsCounter", "Offset (ms)", "Task"]
         self.write_title_row(sheet, title_row)
 
         row = 2
@@ -119,15 +140,77 @@ class OsXdmXlsWriter(ExcelReporter):
             for expiry_point in expiry_point_list:
                 self.write_cell(sheet, row, 1, expiry_point.getName())
                 self.write_cell(sheet, row, 2, table.getName())
-                self.write_cell(sheet, row, 3, table.getOsScheduleTableCounterRef().getShortName())
-                self.write_cell(sheet, row, 4, expiry_point.getOsScheduleTblExpPointOffset())
-                self.write_cell(sheet, row, 5, len(expiry_point.getOsScheduleTableTaskActivationList()))
+                self.write_cell(sheet, row, 3, table.getOsScheduleTableCounterRef().getShortName(),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 4, expiry_point.getOsScheduleTblExpPointOffset(),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 5, len(expiry_point.getOsScheduleTableTaskActivationList()),
+                                format={'alignment': Alignment(horizontal="center")})
                 row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % table.getName())
 
         self.auto_width(sheet)
 
+    def mk_memory_region_exists(self, doc: EBModel) -> bool:
+        mk = doc.getOs().getOsMicrokernel()
+        if mk is None:
+            return False
+        
+        protection = mk.getMkMemoryProtection()
+        if protection is None:
+            return False
+        
+        if len(protection.getMkMemoryRegionList()) <= 0:
+            return False
+        
+        return True
+    
+    def write_mk_memory_regions(self, doc: EBModel):
+        if self.mk_memory_region_exists(doc) is True:
+            sheet = self.wb.create_sheet("MkMemoryRegion", 5)
+
+            title_row = [
+                "Name", "Flags", "Initialize", "Global", "InitThread",
+                "IdleThread", "OsThread", "ErrorHook", "ProtHook", "ShutdownHook",
+                "Shutdown", "Kernel", "InitializePerCore"
+            ]
+            self.write_title_row(sheet, title_row)
+
+            row = 2
+            for region in doc.getOs().getOsMicrokernel().getMkMemoryProtection().getMkMemoryRegionList():
+                self.write_cell(sheet, row, 1, region.getName())
+                self.write_cell(sheet, row, 2, region.getMkMemoryRegionFlags(),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 3, self.format_boolean(region.getMkMemoryRegionInitialize()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 4, self.format_boolean(region.getMkMemoryRegionGlobal()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 5, self.format_boolean(region.getMkMemoryRegionInitThreadAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 6, self.format_boolean(region.getMkMemoryRegionIdleThreadAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 7, self.format_boolean(region.getMkMemoryRegionOsThreadAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 8, self.format_boolean(region.getMkMemoryRegionErrorHookAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 9, self.format_boolean(region.getMkMemoryRegionProtHookAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 10, self.format_boolean(region.getMkMemoryRegionShutdownHookAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 11, self.format_boolean(region.getMkMemoryRegionShutdownAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 12, self.format_boolean(region.getMkMemoryRegionKernelAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 13, self.format_boolean(region.getMkMemoryRegionInitializePerCore()),
+                                format={'alignment': Alignment(horizontal="center")})
+
+                row += 1
+
+                self.logger.debug("Write MkMemoryRegion <%s>" % region.getName())
+
+            self.auto_width(sheet, {"B": 15})
+
     def write(self, filename, doc: EBModel, options={"skip_os_task": False}):
         self.logger.info("Writing <%s>" % filename)
 
@@ -137,5 +220,6 @@ class OsXdmXlsWriter(ExcelReporter):
         self.write_os_schedule_tables(doc)
         self.write_os_counters(doc)
         self.write_expiry_points(doc)
+        self.write_mk_memory_regions(doc)
 
         self.save(filename)