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

eb_model/models/os_xdm.py

@@ -1,14 +1,14 @@
 from typing import Dict, List                                                       # noqa F401
 import logging
-from ..models.abstract import EcucContainer, EcucObject, EcucRefType, Module
+from ..models.abstract import EcucEnumerationParamDef, EcucParamConfContainerDef, EcucObject, EcucRefType, Module
 
 
-class OsAlarmAction(EcucContainer):
+class OsAlarmAction(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
 
-class OsAlarmAutostart(EcucContainer):
+class OsAlarmAutostart(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -110,7 +110,7 @@ class OsAlarmSetEvent(OsAlarmAction):
         return self
 
 
-class OsAlarm(EcucContainer):
+class OsAlarm(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -160,7 +160,7 @@ class OsAlarm(EcucContainer):
         return "\n".join(result)
 
 
-class OsApplicationHooks(EcucContainer):
+class OsApplicationHooks(EcucParamConfContainerDef):
     def __init__(self, parent, name):
         super().__init__(parent, name)
 
@@ -198,7 +198,7 @@ class OsApplicationHooks(EcucContainer):
         return self
 
 
-class OsApplicationTrustedFunction(EcucContainer):
+class OsApplicationTrustedFunction(EcucParamConfContainerDef):
     def __init__(self, parent, name):
         super().__init__(parent, name)
 
@@ -220,12 +220,12 @@ class OsApplicationTrustedFunction(EcucContainer):
         return self
 
 
-class OsAppMode(EcucContainer):
+class OsAppMode(EcucParamConfContainerDef):
     def __init__(self, parent, name):
         super().__init__(parent, name)
 
 
-class OsApplication(EcucContainer):
+class OsApplication(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -344,7 +344,7 @@ class OsApplication(EcucContainer):
         return self
 
 
-class OsDriver(EcucContainer):
+class OsDriver(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -364,7 +364,7 @@ class OsDriver(EcucContainer):
         return self
 
 
-class OsTimeConstant(EcucContainer):
+class OsTimeConstant(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -384,7 +384,7 @@ class OsTimeConstant(EcucContainer):
         return self
 
 
-class OsCounter(EcucContainer):
+class OsCounter(EcucParamConfContainerDef):
 
     OS_COUNTER_TYPE_HARDWARE = "HARDWARE"
     OS_COUNTER_TYPE_SOFTWARE = "SOFTWARE"
@@ -482,12 +482,40 @@ class OsCounter(EcucContainer):
         return self
 
 
-class OsResource(EcucContainer):
-    def __init__(self) -> None:
-        pass
+class OsResource(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.osResourceProperty = None                                  # type: EcucEnumerationParamDef
+        self.osResourceAccessingApplicationRefs = []                    # type: List[EcucRefType]
+        self.osResourceLinkedResourceRefs = []                          # type: List[EcucRefType]
+
+    def getOsResourceProperty(self):
+        return self.osResourceProperty
+
+    def setOsResourceProperty(self, value):
+        if value is not None:
+            self.osResourceProperty = value
+        return self
+
+    def getOsResourceAccessingApplicationRefs(self):
+        return self.osResourceAccessingApplicationRefs
+
+    def addOsResourceAccessingApplicationRefs(self, value):
+        if value is not None:
+            self.osResourceAccessingApplicationRefs.append(value)
+        return self
+
+    def getOsResourceLinkedResourceRefs(self):
+        return self.osResourceLinkedResourceRefs
 
+    def setOsResourceLinkedResourceRefs(self, value):
+        if value is not None:
+            self.osResourceLinkedResourceRefs = value
+        return self
 
-class OsIsrResourceLock(EcucContainer):
+    
+class OsIsrResourceLock(EcucParamConfContainerDef):
     def __init__(self) -> None:
         self.osIsrResourceLockBudget = None
         self.osIsrResourceLockResourceRef = None
@@ -724,7 +752,7 @@ class OsTask(EcucObject):
         return self.osTaskAutostart is not None
 
 
-class OsScheduleTableAutostart(EcucContainer):
+class OsScheduleTableAutostart(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -754,7 +782,7 @@ class OsScheduleTableAutostart(EcucContainer):
         return self
 
 
-class OsScheduleTblAdjustableExpPoint(EcucContainer):
+class OsScheduleTblAdjustableExpPoint(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -776,7 +804,7 @@ class OsScheduleTblAdjustableExpPoint(EcucContainer):
         return self
 
 
-class OsScheduleTableTaskActivation(EcucContainer):
+class OsScheduleTableTaskActivation(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -790,7 +818,7 @@ class OsScheduleTableTaskActivation(EcucContainer):
         return self
 
 
-class OsScheduleTableEventSetting(EcucContainer):
+class OsScheduleTableEventSetting(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -814,7 +842,7 @@ class OsScheduleTableEventSetting(EcucContainer):
         return self
 
 
-class OsScheduleTableExpiryPoint(EcucContainer):
+class OsScheduleTableExpiryPoint(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -854,7 +882,7 @@ class OsScheduleTableExpiryPoint(EcucContainer):
         return self
 
 
-class OsScheduleTable(EcucContainer):
+class OsScheduleTable(EcucParamConfContainerDef):
 
     OS_TIME_UNIT_NANOSECONDS = "NANOSECONDS"
     OS_TIME_UNIT_TICKS = "TICKS"
@@ -944,6 +972,7 @@ class Os(Module):
         self.osScheduleTables = []                      # type: List[OsScheduleTable]
         self.osCounters = []                            # type: List[OsCounter]
         self.osApplications = []                        # type: List[OsApplication]
+        self.osResources = []                           # type: List[OsResource]
 
         # extended attributes to speed up performance
         self.osIsrToOsAppMappings = {}                  # type: Dict[str, OsApplication]
@@ -992,22 +1021,30 @@ class Os(Module):
         return self
     
     def getOsApplicationList(self) -> List[OsApplication]:
-        return list(sorted(filter(lambda a: isinstance(a, OsApplication), self.elements.values()), key=lambda o: o.name))
+        return list(sorted(filter(lambda a: isinstance(a, OsApplication), self.elements.values()), key=lambda o: o.getName()))
 
     def addOsApplication(self, value: OsApplication):
         self.addElement(value)
         self.osApplications.append(value)
         
         for isr_ref in value.getOsAppIsrRefs():
-            self.logger.debug("Create OsISR <%s> -> OsApp <%s> Mapping." % (isr_ref.getShortName(), value.getName))
+            self.logger.debug("Create OsISR <%s> -> OsApp <%s> Mapping." % (isr_ref.getShortName(), value.getName()))
             self.osIsrToOsAppMappings[isr_ref.getShortName()] = value
 
         for task_ref in value.getOsAppTaskRefs():
-            self.logger.debug("Create OsTask <%s> -> OsApp <%s> Mapping." % (task_ref.getShortName(), value.getName))
+            self.logger.debug("Create OsTask <%s> -> OsApp <%s> Mapping." % (task_ref.getShortName(), value.getName()))
             self.osTaskToOsAppMappings[task_ref.getShortName()] = value
 
         return self
     
+    def getOsResourceList(self) -> List[OsResource]:
+        return list(sorted(filter(lambda a: isinstance(a, OsResource), self.elements.values()), key=lambda o: o.getName()))
+
+    def addOsResource(self, os_task: OsResource):
+        self.addElement(os_task)
+        self.osResources.append(os_task)
+        return self
+    
     def getOsIsrOsApplication(self, isr_name: str) -> OsApplication:
         if isr_name in self.osIsrToOsAppMappings:
             return self.osIsrToOsAppMappings[isr_name]

eb_model/models/rte_xdm.py

@@ -1,6 +1,8 @@
 from typing import Dict, List
-from ..models.abstract import EcucContainer, EcucRefType, Module
-class RteEventToIsrMapping(EcucContainer):
+from ..models.abstract import EcucParamConfContainerDef, EcucRefType, Module
+
+
+class RteEventToIsrMapping(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
         
@@ -10,7 +12,8 @@ class RteEventToIsrMapping(EcucContainer):
         self.RteRipsFillRoutineRef = None
         self.RteRipsFlushRoutineRef = None
 
-class AbstractEventToTaskMapping(EcucContainer):
+
+class AbstractEventToTaskMapping(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
@@ -23,6 +26,7 @@ class AbstractEventToTaskMapping(EcucContainer):
         self.rtePositionInTask = value
         return self
 
+
 class RteEventToTaskMapping(AbstractEventToTaskMapping):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
@@ -174,8 +178,9 @@ class RteEventToTaskMapping(AbstractEventToTaskMapping):
 
     def setRteVirtuallyMappedToTaskRef(self, value):
         self.rteVirtuallyMappedToTaskRef = value
-        return self   
-    
+        return self
+
+
 class RteEventToTaskMappingV3(RteEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
@@ -189,6 +194,7 @@ class RteEventToTaskMappingV3(RteEventToTaskMapping):
         self.rteEventRef = value
         return self
 
+
 class RteEventToTaskMappingV4(RteEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
@@ -208,6 +214,7 @@ class RteEventToTaskMappingV4(RteEventToTaskMapping):
             raise ValueError("Unsupported RteEventRef of RteEventToTaskMapping <%s> " % self.name)
         return self.rteEventRefs[0]
 
+
 class RteBswEventToTaskMapping(AbstractEventToTaskMapping):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
@@ -329,6 +336,7 @@ class RteBswEventToTaskMapping(AbstractEventToTaskMapping):
         self.rteRipsFlushRoutineRef = value
         return self
 
+
 class RteBswEventToTaskMappingV3(RteBswEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
@@ -343,6 +351,7 @@ class RteBswEventToTaskMappingV3(RteBswEventToTaskMapping):
             self.rteBswEventRef = value
         return self
 
+
 class RteBswEventToTaskMappingV4(RteBswEventToTaskMapping):
     def __init__(self, parent, name):
         super().__init__(parent, name)
@@ -361,10 +370,12 @@ class RteBswEventToTaskMappingV4(RteBswEventToTaskMapping):
             raise ValueError("Unsupported RteEventRef of RteEventToTaskMapping <%s> " % self.name)
         return self.rteBswEventRefs[0]
 
-class AbstractRteInstance(EcucContainer):
+
+class AbstractRteInstance(EcucParamConfContainerDef):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
+
 class RteSwComponentInstance(AbstractRteInstance):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
@@ -443,6 +454,7 @@ class RteSwComponentInstance(AbstractRteInstance):
         self.rteNvRamAllocations.append(value)
         return self
 
+
 class RteBswModuleInstance(AbstractRteInstance):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
@@ -551,25 +563,43 @@ class RteBswModuleInstance(AbstractRteInstance):
     def setRteMappedToOsApplicationRef(self, value):
         self.rteMappedToOsApplicationRef = value
         return self
-    
+
+
 class Rte(Module):
     def __init__(self, parent) -> None:
         super().__init__(parent, "Rte")
 
+        self.rteBswModuleInstances = []                                         # type: List[RteBswModuleInstance]
+        self.rteSwComponentInstances = []                                       # type: List[RteSwComponentInstance]
+
+    def getRteBswModuleInstance(self, name: str) -> RteBswModuleInstance:
+        result = list(filter(lambda a: a.name == name, self.rteBswModuleInstances))
+        if len(result) > 0:
+            return result[0]
+        return None
+
     def getRteBswModuleInstanceList(self) -> List[RteBswModuleInstance]:
-        return list(sorted(filter(lambda a: isinstance(a, RteBswModuleInstance), self.elements.values()), key= lambda o:o.name))
+        return list(sorted(self.rteBswModuleInstances, key=lambda o: o.name))
 
     def addRteBswModuleInstance(self, value: RteBswModuleInstance):
         self.elements[value.getName()] = value
+        self.rteBswModuleInstances.append(value)
+
+    def getRteSwComponentInstance(self, name: str) -> RteSwComponentInstance:
+        result = list(filter(lambda a: a.name == name, self.rteSwComponentInstances))
+        if len(result) > 0:
+            return result[0]
+        return None
 
     def getRteSwComponentInstanceList(self) -> List[RteSwComponentInstance]:
-        return list(sorted(filter(lambda a: isinstance(a, RteSwComponentInstance), self.elements.values()), key= lambda o:o.name))
+        return list(sorted(self.rteSwComponentInstances, key=lambda o: o.name))
 
     def addRteSwComponentInstance(self, value: RteSwComponentInstance):
         self.elements[value.getName()] = value
+        self.rteSwComponentInstances.append(value)
 
     def getRteModuleInstanceList(self) -> List[AbstractRteInstance]:
-        return list(sorted(filter(lambda a: isinstance(a, AbstractRteInstance), self.elements.values()), key= lambda o:o.name))
+        return list(sorted(filter(lambda a: isinstance(a, AbstractRteInstance), self.elements.values()), key=lambda o: o.name))
     
     def _addToRteEventToOsTasks(self, mapping: AbstractEventToTaskMapping, os_tasks: Dict[str, List[AbstractEventToTaskMapping]]):
         if isinstance(mapping, RteBswEventToTaskMapping):
@@ -601,4 +631,4 @@ class Rte(Module):
             else:
                 raise NotImplementedError("Invalid Rte Module Instance <%s>" % type(instance))
 
-        return os_tasks
+        return os_tasks

eb_model/parser/__init__.py

@@ -1,4 +1,5 @@
 from .os_xdm_parser import OsXdmParser
 from .rte_xdm_parser import RteXdmParser
+from .nvm_xdm_parser import NvMXdmParser
 from .eb_parser import AbstractEbModelParser
-from .pref_xdm_parser import PerfXdmParser
+from .pref_xdm_parser import PerfXdmParser

eb_model/parser/eb_parser.py

@@ -86,7 +86,9 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         tag = parent.find(".//d:ref[@name='%s']" % name, self.nsmap)
         if tag is None:
              raise KeyError("XPath d:ref[@name='%s'] is invalid" % name)
-        return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
+        if 'value' in tag.attrib:
+            return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
+        return None
 
     def read_optional_ref_value(self, parent: ET.Element, name: str) -> EcucRefType:
         tag = parent.find(".//d:ref[@name='%s']" % name, self.nsmap)

eb_model/parser/nvm_xdm_parser.py

@@ -0,0 +1,44 @@
+import xml.etree.ElementTree as ET
+
+from ..models.nvm_xdm import NvM, NvMBlockDescriptor
+from ..models.eb_doc import EBModel
+from ..parser.eb_parser import AbstractEbModelParser
+
+
+class NvMXdmParser(AbstractEbModelParser):
+    def __init__(self, ) -> None:
+        super().__init__()
+
+        self.nvm = None
+
+    def parse(self, element: ET.Element, doc: EBModel):
+        if self.get_component_name(element) != "NvM":
+            raise ValueError("Invalid <%s> xdm file" % "NvM")
+
+        nvm = doc.getNvM()
+
+        self.read_version(element, nvm)
+
+        self.logger.info("Parse NvM ARVersion:<%s> SwVersion:<%s>" % (nvm.getArVersion().getVersion(), nvm.getSwVersion().getVersion()))
+
+        self.nvm = nvm
+
+        self.read_nvm_block_descriptors(element, nvm)
+
+    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.addNvMBlockDescriptor(nvm_block)
+                     

eb_model/parser/os_xdm_parser.py

@@ -1,6 +1,7 @@
 import xml.etree.ElementTree as ET
 from ..models.eb_doc import EBModel
-from ..models.os_xdm import Os, OsAlarm, OsAlarmActivateTask, OsAlarmCallback, OsAlarmIncrementCounter, OsAlarmSetEvent, OsCounter, OsScheduleTable
+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 ..parser.eb_parser import AbstractEbModelParser
@@ -20,7 +21,7 @@ class OsXdmParser(AbstractEbModelParser):
 
         self.read_version(element, os)
 
-        self.logger.info("Parse Rte ARVersion:<%s> SwVersion:<%s>" % (os.getArVersion().getVersion(), os.getSwVersion().getVersion()))
+        self.logger.info("Parse Os ARVersion:<%s> SwVersion:<%s>" % (os.getArVersion().getVersion(), os.getSwVersion().getVersion()))
 
         self.os = os
 
@@ -30,6 +31,7 @@ class OsXdmParser(AbstractEbModelParser):
         self.read_os_schedule_tables(element, os)
         self.read_os_counters(element, os)
         self.read_os_applications(element, os)
+        self.read_os_resources(element, os)
 
     def read_os_task_autostart(self, element: ET.Element, os_task: OsTask):
         ctr_tag = self.find_ctr_tag(element, "OsTaskAutostart")
@@ -184,3 +186,13 @@ class OsXdmParser(AbstractEbModelParser):
 
             self.logger.debug("Read OsApplication <%s>" % os_app.getName())
             os.addOsApplication(os_app)
+
+    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.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)

eb_model/reporter/__init__.py

@@ -1 +1,2 @@
-from .excel_reporter.os_xdm import *
+from .excel_reporter.os_xdm import *
+from .excel_reporter.nvm_xdm import *

eb_model/reporter/excel_reporter/abstract.py

@@ -1,8 +1,9 @@
 import logging
 from openpyxl import Workbook
 from openpyxl.cell import Cell
-from openpyxl.styles import Alignment
 from openpyxl.worksheet.worksheet import Worksheet
+from openpyxl.styles import Alignment
+
 
 class ExcelReporter:
     def __init__(self) -> None:
@@ -15,12 +16,12 @@ class ExcelReporter:
             for cell in row:
                 if cell.value:
                     alignment = cell.alignment      # type: Alignment
-                    if (alignment.wrapText == True):
+                    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) + 2
             worksheet.column_dimensions[col].width = (value + 2)
 
     def write_title_row(self, sheet: Worksheet, title_row):
@@ -28,10 +29,10 @@ class ExcelReporter:
             cell = sheet.cell(row=1, column=idx + 1)
             cell.value = title_row[idx]
 
-    def write_cell(self, sheet, row, column, value, format = None) -> Cell:
-        cell = sheet.cell(row = row, column=column)         # type: Cell
+    def write_cell(self, sheet: Worksheet, row: int, column: int, value, format=None) -> Cell:
+        cell = sheet.cell(row=row, column=column)         # type: Cell
         cell.value = value
-        if (format != None):
+        if (format is not None):
             if ('alignment' in format):
                 cell.alignment = format['alignment']
             if ('number_format' in format):
@@ -40,4 +41,3 @@ class ExcelReporter:
 
     def save(self, name: str):
         self.wb.save(name)
-

eb_model/reporter/excel_reporter/nvm_xdm.py

@@ -0,0 +1,40 @@
+from ...models.eb_doc import EBModel
+from ...reporter.excel_reporter.abstract import ExcelReporter
+
+
+class NvMXdmXlsWriter(ExcelReporter):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def write_nvm_block_descriptors(self, doc: EBModel):
+        sheet = self.wb.create_sheet("NvMBlock", 0)
+
+        title_row = [
+            "BlockId", "Name", "NvMBlockEcucPartitionRef", "NvMRamBlockDataAddress", "NvMRomBlockDataAddress",
+            "NvMBlockManagementType", "NvMNvBlockLength", "NvMNvBlockNum", "NvMSelectBlockForReadAll", "NvMSelectBlockForWriteAll"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for nvm_block in doc.getNvM().getNvMBlockDescriptorList():
+            self.write_cell(sheet, row, 1, nvm_block.getNvMNvramBlockIdentifier())
+            self.write_cell(sheet, row, 2, nvm_block.getName())
+            self.write_cell(sheet, row, 3, nvm_block.getNvMBlockEcucPartitionRef())
+            self.write_cell(sheet, row, 4, nvm_block.getNvMRamBlockDataAddress())
+            self.write_cell(sheet, row, 5, nvm_block.getNvMRomBlockDataAddress())
+            self.write_cell(sheet, row, 6, nvm_block.getNvMBlockManagementType())
+            self.write_cell(sheet, row, 7, nvm_block.getNvMNvBlockLength())
+            self.write_cell(sheet, row, 8, nvm_block.getNvMNvBlockNum())
+
+            
+            row += 1
+
+            self.logger.debug("Write NvM Block <%s>" % nvm_block.getName())
+
+        self.auto_width(sheet)
+
+    def write(self, filename, doc: EBModel, options):
+        self.logger.info("Writing <%s>" % filename)
+
+        self.write_nvm_block_descriptors(doc)
+
+        self.save(filename)

eb_model/reporter/excel_reporter/rte_xdm.py

@@ -2,6 +2,7 @@ from ...models.rte_xdm import RteBswEventToTaskMapping, RteBswModuleInstance, Rt
 from ...models.eb_doc import EBModel
 from .abstract import ExcelReporter
 
+
 class RteXdmXlsWriter(ExcelReporter):
     def __init__(self) -> None:
         super().__init__()
@@ -45,6 +46,7 @@ class RteXdmXlsWriter(ExcelReporter):
 
         self.save(filename)
 
+
 class RteRunnableEntityXlsWriter(ExcelReporter):
     def __init__(self) -> None:
         super().__init__()
@@ -57,7 +59,7 @@ class RteRunnableEntityXlsWriter(ExcelReporter):
 
         row = 2
         for os_task, mappings in doc.getRte().getMappedEvents().items():
-            for mapping in sorted(mappings, key = lambda a:a.getRtePositionInTask()):
+            for mapping in sorted(mappings, key=lambda a: a.getRtePositionInTask()):
                 self.write_cell(sheet, row, 1, os_task)
                 if isinstance(mapping, RteBswEventToTaskMapping):
                     self.logger.debug("Write Mapping %s" % mapping.getName())
@@ -68,7 +70,7 @@ class RteRunnableEntityXlsWriter(ExcelReporter):
                     self.write_cell(sheet, row, 7, mapping.getRteBswActivationOffset())
                 elif isinstance(mapping, RteEventToTaskMapping):
                     self.logger.debug("Write Mapping %s" % mapping.getName())
-                    instance = mapping.getRteSwComponentInstance() 
+                    instance = mapping.getRteSwComponentInstance()
                     self.write_cell(sheet, row, 2, mapping.getRteEventRef().getShortName())
                     self.write_cell(sheet, row, 5, instance.getRteSoftwareComponentInstanceRef().getValue())
                     self.write_cell(sheet, row, 6, mapping.getRtePositionInTask())
@@ -84,4 +86,4 @@ class RteRunnableEntityXlsWriter(ExcelReporter):
         self.logger.info("Writing <%s>" % filename)
         self.write_mapped_events(doc)
 
-        self.save(filename)
+        self.save(filename)

eb_model/tests/models/test_ecuc_container.py

@@ -1,12 +1,12 @@
 
 from ...models.eb_doc import EBModel
-from ...models.abstract import EcucContainer, EcucObject
+from ...models.abstract import EcucParamConfContainerDef, EcucObject
 
 class TestEcucContainer:
 
     def test_create_container(self):
         document = EBModel.getInstance()
-        os_container = EcucContainer(document, "Os")
+        os_container = EcucParamConfContainerDef(document, "Os")
 
         assert (os_container.getFullName() == "/Os")
         assert (os_container.getParent() == document)
@@ -18,5 +18,5 @@ class TestEcucContainer:
         assert (container.getParent() == document)
         assert (container.getName() == "Os")
 
-        assert(isinstance(container, EcucContainer))
+        assert(isinstance(container, EcucParamConfContainerDef))
         assert(isinstance(container, EcucObject))