py-eb-model 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

eb_model/parser/eb_parser.py

@@ -1,20 +1,25 @@
-#from xml.etree import cElementTree as ET
+import logging
 import xml.etree.ElementTree as ET
 import re
 
 from abc import ABCMeta
 from typing import List
 
-class EBModelParser(metaclass = ABCMeta):
+from ..models.eb_doc import EBModel
+from ..models.abstract import EcucRefType
+
+class AbstractEbModelParser(metaclass = ABCMeta):
 
     def __init__(self) -> None:
-        self.ns = {}
+        self.nsmap = {}
+
+        self.logger = logging.getLogger()
 
-        if type(self) == "EBModelParser":
+        if type(self) == "AbstractEBModelParser":
             raise ValueError("Abstract EBModelParser cannot be initialized.")
 
     def validate_root(self, element: ET.Element):
-        if (element.tag != "{%s}%s" % (self.ns[''], "datamodel")):
+        if (element.tag != "{%s}%s" % (self.nsmap[''], "datamodel")):
             raise ValueError("This document <%s> is not EB xdm format" % element.tag)
 
     def read_ref_raw_value(self, value):
@@ -27,10 +32,7 @@ class EBModelParser(metaclass = ABCMeta):
             return match.group(1)
         return value
 
-    def read_value(self, parent: ET.Element, name: str) -> str:
-        tag = parent.find(".//d:var[@name='%s']" % name, self.ns)
-        if tag == None:
-            raise KeyError("XPath d:var[@name='%s'] is invalid" % name)
+    def _convert_value(self, tag):
         if (tag.attrib['type'] == 'INTEGER'):
             return int(tag.attrib['value'])
         elif (tag.attrib['type'] == "FLOAT"):
@@ -43,50 +45,60 @@ class EBModelParser(metaclass = ABCMeta):
         else:
             return tag.attrib['value']
 
+    def read_value(self, parent: ET.Element, name: str) -> str:
+        tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
+        if tag == 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:
-        tag = parent.find(".//d:var[@name='%s']" % name, self.ns)
+        tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
         if tag is None:
             return default_value
         if ('value' not in tag.attrib):
             return default_value
-        return tag.attrib['value']
+        enable = self.read_attrib(tag, 'ENABLE')
+        if (enable == 'false'):
+            return default_value
+        return self._convert_value(tag)
 
     def find_choice_tag(self, parent: ET.Element, name: str) -> ET.Element:
-        return parent.find(".//d:chc[@name='%s']" % name, self.ns)
+        return parent.find(".//d:chc[@name='%s']" % name, self.nsmap)
 
     def read_choice_value(self, parent: ET.Element, name: str) -> str:
         tag = self.find_choice_tag(parent, name)
         return tag.attrib['value']
 
-    def read_ref_value(self, parent: ET.Element, name: str) -> str:
-        tag = parent.find(".//d:ref[@name='%s']" % name, self.ns)
-        return self.read_ref_raw_value(tag.attrib['value'])
+    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)
+        return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
 
-    def read_optional_ref_value(self, parent: ET.Element, name: str) -> str:
-        tag = parent.find(".//d:ref[@name='%s']" % name, self.ns)
+    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'):
-            return ""
-        return self.read_ref_raw_value(tag.attrib['value'])
+            return None
+        return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
 
-    def read_ref_value_list(self, parent: ET.Element, name: str) -> List[str]:
+    def read_ref_value_list(self, parent: ET.Element, name: str) -> List[EcucRefType]:
         ref_value_list = []
-        for tag in parent.findall(".//d:lst[@name='%s']/d:ref" % name, self.ns):
-            ref_value_list.append(
-                self.read_ref_raw_value(tag.attrib['value']))
+        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.ns)
+        return parent.findall(".//d:lst[@name='%s']/d:ctr" % name, self.nsmap)
     
     def find_chc_tag_list(self, parent: ET.Element, name: str) -> List[ET.Element]:
-        return parent.findall(".//d:lst[@name='%s']/d:chc" % name, self.ns)
+        return parent.findall(".//d:lst[@name='%s']/d:chc" % name, self.nsmap)
 
     def find_ctr_tag(self, parent: ET.Element, name: str) -> ET.Element:
         '''
         Read the child ctr tag. 
         '''
-        tag = parent.find(".//d:ctr[@name='%s']" % name, self.ns)
+        tag = parent.find(".//d:ctr[@name='%s']" % name, self.nsmap)
         if tag is None:
             return None
         enable = self.read_attrib(tag, 'ENABLE')
@@ -133,15 +145,36 @@ class EBModelParser(metaclass = ABCMeta):
             ref_tag.attrib['value'] = "ASPath:%s" % ref
             lst_tag.append(ref_tag)
         return lst_tag
+    
+    def get_component_name(self, parent: ET.Element) -> str:
+        tag = parent.find(".//d:chc[@type='AR-ELEMENT'][@value='MODULE-CONFIGURATION']", self.nsmap)
+        return tag.attrib['name']
 
     def find_lst_tag(self, parent: ET.Element, name: str) -> ET.Element:
-        return parent.find(".//d:lst[@name='%s']" % name, self.ns)
+        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.ns)
+        attrib_tag = parent.find(".//a:a[@name='%s']" % name, self.nsmap)
         if attrib_tag is None:
             return None
         return attrib_tag.attrib['value']
 
-    def _read_namespaces(self, xdm: str):
-        self.ns = dict([node for _, node in ET.iterparse(xdm, events=['start-ns'])])
+    def read_namespaces(self, xdm: str):
+        self.nsmap = dict([node for _, node in ET.iterparse(xdm, events=['start-ns'])])
+
+    def parse(self, element: ET.Element, doc: EBModel):
+        pass
+
+    def load_xdm(self, filename: str) -> ET.Element:
+        self.logger.info("Loading <%s>" % filename)
+
+        self.read_namespaces(filename)
+        tree = ET.parse(filename)
+        self.root_tag = tree.getroot()
+        self.validate_root(self.root_tag)
+
+        return self.root_tag
+
+    def parse_xdm(self, filename: str, doc: EBModel):
+        root_tag = self.load_xdm(filename)
+        self.parse(root_tag, doc)

eb_model/parser/eb_parser_factory.py

@@ -0,0 +1,29 @@
+import logging
+import xml.etree.cElementTree as ET
+
+from .rte_xdm_parser import RteXdmParser
+from .eb_parser import AbstractEbModelParser
+from .os_xdm_parser import OsXdmParser
+
+
+class EbParserFactory:
+    
+    @classmethod
+    def get_component_name(cls, filename: str) -> str:
+        tree = ET.parse(filename)
+        ns = dict([node for _, node in ET.iterparse(filename, events=['start-ns'])])
+        tag = tree.getroot().find(".//d:chc[@type='AR-ELEMENT'][@value='MODULE-CONFIGURATION']", ns)
+        return tag.attrib['name']
+    
+    @classmethod
+    def create(self, xdm: str) -> AbstractEbModelParser:
+        logging.getLogger().info("Analyzing file <%s>" % xdm)
+
+        name = EbParserFactory.get_component_name(xdm)
+
+        if name == "Os":
+            return OsXdmParser()
+        elif name == "Rte":
+            return RteXdmParser()
+        else:
+            raise NotImplementedError("Unsupported EB xdm file <%s>" % name)

eb_model/parser/os_xdm_parser.py

@@ -1,43 +1,153 @@
-from typing import List, Dict
 import xml.etree.ElementTree as ET
-import re
-
-from ..models.abstract import EcucContainer, EcucObject
 from ..models.eb_doc import EBModel
-from ..models.os_xdm import Os, OsApplication, OsCounter, OsResource, OsTask, OsIsr
-from .eb_parser import EBModelParser
+from ..models.os_xdm import Os, OsAlarm, OsAlarmActivateTask, OsAlarmCallback, OsAlarmIncrementCounter, OsAlarmSetEvent, OsCounter, OsScheduleTable, OsScheduleTableEventSetting, OsScheduleTableExpiryPoint, OsScheduleTableTaskActivation, OsScheduleTblAdjustableExpPoint
+from ..models.os_xdm import OsTask, OsIsr, OsApplication
+from .eb_parser import AbstractEbModelParser
 
-class OsXdmParser(EBModelParser):
+class OsXdmParser(AbstractEbModelParser):
     def __init__(self, ) -> None:
         super().__init__()
 
-    def parse(self, filename: str, doc: EBModel):
-        self._read_namespaces(filename)
-        tree = ET.parse(filename)
-        self.root_tag = tree.getroot()
-        self.validate_root(self.root_tag)
+    def parse(self, element: ET.Element, doc: EBModel):
+        if self.get_component_name(element) != "Os":
+            raise ValueError("Invalid <%s> xdm file" % "Os")
+
+        os = doc.getOs()
 
-        self.read_os_tasks(doc.getOs())
-        self.read_os_isrs(doc.getOs())
+        self.read_os_tasks(element, os)
+        self.read_os_isrs(element, os)
+        self.read_os_alarms(element, os)
+        self.read_os_schedule_tables(element, os)
+        self.read_os_counters(element, os)
+        self.read_os_applications(element, os)
 
-    def read_os_tasks(self, os: Os):
-        for ctr_tag in self.find_ctr_tag_list(self.root_tag, 'OsTask'):
-            os_task = OsTask()
-            os_task.setName(ctr_tag.attrib['name']) \
-                .setOsTaskPriority(self.read_value(ctr_tag, "OsTaskPriority")) \
+    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")) \
-                .setOsStacksize(self.read_optional_value(ctr_tag, "OsStacksize", 0))
+                .setOsStacksize(int(self.read_optional_value(ctr_tag, "OsStacksize", 0)))
+
+            for resource_ref in self.read_ref_value_list(ctr_tag, "OsTaskResourceRef"):
+                os_task.addOsTaskResourceRef(resource_ref)
+
+            self.logger.debug("Read OsTask <%s>" % os_task.getName())
             os.addOsTask(os_task)
-    
-    def read_os_isrs(self, os: Os):
-        for ctr_tag in self.find_ctr_tag_list(self.root_tag, 'OsIsr'):
-            os_isr = OsIsr()
-            os_isr.setName(ctr_tag.attrib['name']) \
-                .setOsIsrCategory(self.read_value(ctr_tag, "OsIsrCategory")) \
+
+    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(self.read_value(ctr_tag, "OsStacksize")) \
+                .setOsStacksize(int(self.read_value(ctr_tag, "OsStacksize"))) \
                 .setOsIsrPriority(self.read_optional_value(ctr_tag, "OsIsrPriority"))
 
+            self.logger.debug("Read OsIsr <%s>" % os_isr.getName())
             os.addOsIsr(os_isr)
-    
+
+    def read_os_alarm_action(self, element: ET.Element, os_alarm: OsAlarm):
+        chc = self.read_choice_value(element, "OsAlarmAction")
+        if chc is None:
+            raise ValueError("OsAlarmAction is required.")
+        if chc == "OsAlarmActivateTask":
+            os_alarm_action = OsAlarmActivateTask(os_alarm, "OsAlarmActivateTask") \
+                .setOsAlarmActivateTaskRef(self.read_ref_value(element, "OsAlarmActivateTaskRef"))
+        elif chc == "OsAlarmIncrementCounter":
+            os_alarm_action = OsAlarmIncrementCounter(os_alarm, "OsAlarmIncrementCounter") \
+                .setOsAlarmIncrementCounterRef(self.read_ref_value(element, "OsAlarmIncrementCounterRef"))
+        elif chc == "OsAlarmSetEvent":
+            os_alarm_action = OsAlarmSetEvent(os_alarm, "OsAlarmSetEvent") \
+                .setOsAlarmSetEventRef(self.read_ref_value(element, "OsAlarmSetEventRef")) \
+                .setOsAlarmSetEventTaskRef(self.read_ref_value(element, "OsAlarmSetEventTaskRef"))
+        elif chc == "OsAlarmCallback":
+            os_alarm_action = OsAlarmCallback(os_alarm, "OsAlarmCallback") \
+                .setOsAlarmCallbackName(self.read_value(element, "OsAlarmCallbackName"))
+        else:
+            raise ValueError("Unsupported OsAlarmAction <%s>" % chc)
+        os_alarm.setOsAlarmAction(os_alarm_action)
+
+    def read_os_alarms(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsAlarm"):
+            os_alarm = OsAlarm(os, ctr_tag.attrib["name"]) \
+                .setOsAlarmCounterRef(self.read_ref_value(ctr_tag, "OsAlarmCounterRef"))
+
+            for ref in self.read_ref_value_list(ctr_tag, "OsAlarmAccessingApplication"):
+                os_alarm.addOsAlarmAccessingApplicationRef(ref)
+
+            self.read_os_alarm_action(ctr_tag, os_alarm)
+
+            self.logger.debug("Read OsAlarm <%s>" % os_alarm.getName())
+            os.addOsAlarm(os_alarm)
+
+    def read_os_schedule_table_event_settings(self, element: ET.Element, expiry_point: OsScheduleTableExpiryPoint):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTableEventSetting"):
+            event_setting = OsScheduleTableEventSetting(expiry_point, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableSetEventRef(self.read_ref_value(ctr_tag, "OsScheduleTableSetEventRef")) \
+                .setOsScheduleTableSetEventTaskRef(self.read_ref_value(ctr_tag, "OsScheduleTableSetEventTaskRef"))
+
+            expiry_point.addOsScheduleTableEventSetting(event_setting)
+
+    def read_os_schedule_table_task_activations(self, element: ET.Element, expiry_point: OsScheduleTableExpiryPoint):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTableTaskActivation"):
+            activation = OsScheduleTableTaskActivation(expiry_point, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableActivateTaskRef(self.read_ref_value(ctr_tag, "OsScheduleTableActivateTaskRef")) 
+
+            expiry_point.addOsScheduleTableTaskActivation(activation)
+
+    def read_os_schedule_tbl_adjustable_exp_point(self, element: ET.Element, expiry_point: OsScheduleTableExpiryPoint):
+        ctr_tag = self.find_ctr_tag(element, "OsScheduleTblAdjustableExpPoint")
+        if ctr_tag is not None:
+            exp_point = OsScheduleTblAdjustableExpPoint(expiry_point, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableMaxLengthen(self.read_ref_value(ctr_tag, "OsScheduleTableMaxLengthen")) \
+                .setOsScheduleTableMaxShorten(self.read_ref_value(ctr_tag, "OsScheduleTableMaxShorten"))
+
+            expiry_point.setOsScheduleTblAdjustableExpPoint(exp_point)
+
+    def read_os_schedule_table_expiry_points(self, element: ET.Element, os_schedule_table: OsScheduleTable):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTableExpiryPoint"):
+            expiry_point = OsScheduleTableExpiryPoint(os_schedule_table, ctr_tag.attrib["name"]) \
+                .setOsScheduleTblExpPointOffset(self.read_value(ctr_tag, "OsScheduleTblExpPointOffset")) \
+            
+            self.read_os_schedule_table_event_settings(ctr_tag, expiry_point)
+            self.read_os_schedule_table_task_activations(ctr_tag, expiry_point)
+            self.read_os_schedule_tbl_adjustable_exp_point(ctr_tag, expiry_point)
+
+            os_schedule_table.addOsScheduleTableExpiryPoint(expiry_point)
+
+    def read_os_schedule_tables(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTable"):
+            table = OsScheduleTable(os, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableDuration(self.read_value(ctr_tag, "OsScheduleTableDuration")) \
+                .setOsScheduleTableRepeating(self.read_value(ctr_tag, "OsScheduleTableRepeating")) \
+                .setOsScheduleTableCounterRef(self.read_ref_value(ctr_tag, "OsScheduleTableCounterRef")) \
+                .setOsTimeUnit(self.read_optional_value(ctr_tag, "OsTimeUnit"))
+
+            self.read_os_schedule_table_expiry_points(ctr_tag, table)
+
+            self.logger.debug("Read OsScheduleTable <%s>" % table.getName())
+            os.addOsScheduleTable(table)
+
+    def read_os_counters(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsCounter"):
+            counter = OsCounter(os, ctr_tag.attrib["name"]) \
+                .setOsCounterMaxAllowedValue(self.read_value(ctr_tag, "OsCounterMaxAllowedValue")) \
+                .setOsCounterMinCycle(self.read_value(ctr_tag, "OsCounterMinCycle")) \
+                .setOsCounterTicksPerBase(self.read_value(ctr_tag, "OsCounterTicksPerBase")) \
+                .setOsCounterType(self.read_optional_value(ctr_tag, "OsCounterType")) \
+                .setOsSecondsPerTick(self.read_optional_value(ctr_tag, "OsSecondsPerTick")) \
+                
+
+            self.logger.debug("Read OsCounter <%s>" % counter.getName())
+            os.addOsScheduleTable(counter)
+
+    def read_os_applications(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsApplication"):
+            os_app = OsApplication(os, ctr_tag.attrib["name"]) \
+                .setOsTrusted(self.read_value(ctr_tag, "OsTrusted")) 
+            
+            for ref in self.read_ref_value_list(ctr_tag, "OsAppResourceRef"):
+                os_app.addOsAppResourceRef(ref)
+
+            self.logger.debug("Read OsApplication <%s>" % os_app.getName())
+            os.addOsApplication(os_app)

eb_model/parser/rte_xdm_parser.py

@@ -0,0 +1,63 @@
+import xml.etree.ElementTree as ET
+
+from ..models.rte_xdm import Rte, RteBswEventToTaskMapping, RteBswModuleInstance, RteEventToTaskMapping, RteSwComponentInstance
+from ..models.eb_doc import EBModel
+from .eb_parser import AbstractEbModelParser
+
+class RteXdmParser(AbstractEbModelParser):
+    def __init__(self, ) -> None:
+        super().__init__()
+
+    def parse(self, element: ET.Element, doc: EBModel):
+        if self.get_component_name(element) != "Rte":
+            raise ValueError("Invalid <%s> xdm file" % "Rte")
+        
+        self.read_rte_bsw_module_instances(element, doc.getRte())
+        self.read_rte_sw_component_instances(element, doc.getRte())
+
+    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"):
+            mapping = RteBswEventToTaskMapping(instance, ctr_tag.attrib['name'])
+            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")) \
+                .setRteBswEventRef(self.read_ref_value(ctr_tag, "RteBswEventRef")) \
+                .setRteBswMappedToTaskRef(self.read_optional_ref_value(ctr_tag, "RteBswMappedToTaskRef"))
+            instance.addRteBswEventToTaskMapping(mapping)
+        
+    def read_rte_bsw_module_instances(self, element: ET.Element, rte: Rte):
+        for ctr_tag in self.find_ctr_tag_list(element, 'RteBswModuleInstance'):
+            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)
+            
+            self.logger.debug("Add the RteBswModuleInstance <%s>" % instance.getName())
+
+            rte.addRteBswModuleInstance(instance)
+
+    def read_rte_sw_component_instance_event_to_task_mappings(self, element: ET.Element, instance: RteSwComponentInstance):
+        for ctr_tag in self.find_ctr_tag_list(element, "RteEventToTaskMapping"):
+            mapping = RteEventToTaskMapping(instance, ctr_tag.attrib['name'])
+            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")) \
+                .setRteEventRef(self.read_ref_value(ctr_tag, "RteEventRef")) \
+                .setRteMappedToTaskRef(self.read_optional_ref_value(ctr_tag, "RteMappedToTaskRef"))
+            
+            instance.addRteEventToTaskMapping(mapping)
+
+    def read_rte_sw_component_instances(self, element: ET.Element, rte: Rte):
+        for ctr_tag in self.find_ctr_tag_list(element, 'RteSwComponentInstance'):
+            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"))
+            
+            self.read_rte_sw_component_instance_event_to_task_mappings(ctr_tag, instance)
+            
+            self.logger.debug("Add the RteSwComponentInstance <%s>" % instance.getName())
+
+            rte.addRteSwComponentInstance(instance)

eb_model/reporter/excel_reporter/abstract.py

@@ -1,42 +1,42 @@
 import logging
 from openpyxl import Workbook
+from openpyxl.cell import Cell
+from openpyxl.styles import Alignment
 from openpyxl.worksheet.worksheet import Worksheet
 
 class ExcelReporter:
     def __init__(self) -> None:
         self.wb = Workbook()
-        self._logger = logging.getLogger()
+        self.logger = logging.getLogger()
     
-    def write_revision(self):
-        sheet = self.wb['Sheet']
-        sheet.title = "History"
-
-        title_rows = ["When", "Who", "Version", "History"]
-        self.write_title_row(sheet, title_rows)
-
     def auto_width(self, worksheet: Worksheet):
         dims = {}
         for row in worksheet.rows:
             for cell in row:
                 if cell.value:
+                    alignment = cell.alignment      # type: Alignment
+                    if (alignment.wrapText == 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):
         for idx in range(0, len(title_row)):
             cell = sheet.cell(row=1, column=idx + 1)
             cell.value = title_row[idx]
 
-    def write_cell(self, sheet, row, column, value, format = None):
-        cell = sheet.cell(row = row, column=column) 
+    def write_cell(self, sheet, row, column, value, format = None) -> Cell:
+        cell = sheet.cell(row = row, column=column)         # type: Cell
         cell.value = value
         if (format != None):
             if ('alignment' in format):
                 cell.alignment = format['alignment']
             if ('number_format' in format):
                 cell.number_format = format['number_format']
+        return cell
 
     def save(self, name: str):
         self.wb.save(name)

eb_model/reporter/excel_reporter/os_xdm.py

@@ -1,5 +1,9 @@
+from typing import List
+
+from ...models.os_xdm import OsScheduleTableExpiryPoint
 from ...models.eb_doc import EBModel
 from .abstract import ExcelReporter
+from openpyxl.styles import Alignment
 
 class OsXdmXlsWriter(ExcelReporter):
     def __init__(self) -> None:
@@ -8,7 +12,7 @@ class OsXdmXlsWriter(ExcelReporter):
     def write_os_tasks(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsTask", 0)
 
-        title_row = ["Name", "OsTaskActivation", "OsTaskPriority", "OsTaskSchedule", "OsStacksize"]
+        title_row = ["Name", "OsTaskActivation", "OsTaskPriority", "OsTaskSchedule", "OsStacksize", "OsResourceRef"]
         self.write_title_row(sheet, title_row)
 
         row = 2
@@ -18,12 +22,24 @@ class OsXdmXlsWriter(ExcelReporter):
             self.write_cell(sheet, row, 3, os_task.getOsTaskPriority())
             self.write_cell(sheet, row, 4, os_task.getOsTaskSchedule())
             self.write_cell(sheet, row, 5, os_task.getOsStacksize())
+            resources = []
+            for resource_ref in os_task.getOsTaskResourceRefList():
+                resources.append(resource_ref.getValue())
+            total_resources = len(resources)
+            if total_resources > 10:
+                cell = self.write_cell(sheet, row, 6, "Total: %d OsResources" % (total_resources))
+            else:
+                cell = self.write_cell(sheet, row, 6, "\n".join(resources))
+            if total_resources > 1 and total_resources < 10:
+                cell.alignment = Alignment(wrapText = True)
             row += 1
 
+            self.logger.debug("Write OsTask <%s>" % os_task.getName())
+
         self.auto_width(sheet)
 
     def write_os_isrs(self, doc: EBModel):
-        sheet = self.wb.create_sheet("OsIsr", 0)
+        sheet = self.wb.create_sheet("OsIsr", 1)
 
         title_row = ["Name", "OsIsrCategory", "OsStacksize"]
         self.write_title_row(sheet, title_row)
@@ -35,10 +51,76 @@ class OsXdmXlsWriter(ExcelReporter):
             self.write_cell(sheet, row, 3, os_isr.getOsStacksize())
             row += 1
 
+            self.logger.debug("Write OsIsr <%s>" % os_isr.getName())
+
+        self.auto_width(sheet)
+
+    def write_os_schedule_tables(self, doc: EBModel):
+        sheet = self.wb.create_sheet("OsScheduleTable", 2)
+        
+        title_row = ["Name", "Duration", "Repeating", "OsCount"]
+        self.write_title_row(sheet, title_row)
+
+        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())
+            row += 1
+
+            self.logger.debug("Write OsScheduleTable <%s>" % os_schedule_table.getName())
+
+        self.auto_width(sheet)
+
+    def write_os_counters(self, doc: EBModel):
+        sheet = self.wb.create_sheet("OsCounter", 3)
+        
+        title_row = ["Name", "MaxAllowedValue", "MinCycle", "TicksPerBase", "Type", "SecondsPerTick"]
+        self.write_title_row(sheet, title_row)
+
+        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())
+            row += 1
+
+            self.logger.debug("Write OsScheduleTable <%s>" % os_counter.getName())
+
+        self.auto_width(sheet)
+
+    def write_expiry_points(self, doc: EBModel):
+        sheet = self.wb.create_sheet("OsScheduleTableExpiryPoint", 4)
+        
+        title_row = ["ExpiryPoint", "OsScheduleTable", "OsCounter" "Offset (ms)", "Task"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for table in doc.getOs().getOsScheduleTableList():
+            expiry_point_list = sorted(table.getOsScheduleTableExpiryPointList(), key = lambda o: o.getOsScheduleTblExpPointOffset())   # type: List[OsScheduleTableExpiryPoint]
+            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()))
+                row += 1
+
+            self.logger.debug("Write OsScheduleTable <%s>" % table.getName())
+
         self.auto_width(sheet)
 
     def write(self, filename, doc: EBModel):
+        self.logger.info("Writing <%s>" % filename)
+        
         self.write_os_tasks(doc)
         self.write_os_isrs(doc)
+        self.write_os_schedule_tables(doc)
+        self.write_os_counters(doc)
+        self.write_expiry_points(doc)
 
         self.save(filename)