cannect 1.0.0__py3-none-any.whl

cannect/core/ascet/formula.py

@@ -0,0 +1,33 @@
+from cannect.schema.datadictionary import DataDictionary
+from xml.etree.ElementTree import ElementTree
+
+
+def formula_dictionary(filepath:str) -> DataDictionary:
+    tree = ElementTree(file=filepath)
+    data = DataDictionary()
+    for tag in tree.iter('Formula'):
+        if tag.get('type') != '5 Parameters':
+            continue
+        obj = DataDictionary()
+        obj.unit = tag.get('unit')
+        for n, param in enumerate(tag.iter('Parameter'), start=1):
+            obj[f'p{n}'] = param.get('value')
+
+        p1, p2, p3, p4, p5 = float(obj.p1), float(obj.p2), float(obj.p3), float(obj.p4), float(obj.p5)
+        if p3 != 0:
+            obj.quantization = p2 / p3
+            obj.offset = -p4 / p3
+        elif p1 != 0:
+            obj.quantization = abs(p4 / p1)
+            obj.offset = (-p4 * p5 - p2) / p1
+        else:
+            KeyError(f'Unknown Case For {tag.get("name")}')
+        data[tag.get('name')] = obj
+    return data
+
+
+if __name__ == "__main__":
+    file = r"D:\ETASData\ASCET6.1\Export\_Formula\HNB_I4GDI_EU7.xml"
+    formula = formula_dictionary(file)
+    print(formula)
+    print(formula.k_q0p000244)

cannect/core/ascet/oid.py

@@ -0,0 +1,29 @@
+from random import choice, choices, shuffle
+from time import time
+from typing import List, Union
+import string
+
+
+def generateOID(count:int=1) -> Union[str, List[str]]:
+    syntax1 = [
+        '1ngg01pp', '1ngg00p9', '03000000', '1ngg01a0', '1ngg0140',
+        '000g00p9', '04136psg', '00000300', '038g01ah', '000g0136',
+        '1ngg013h', '1ngg019n', '1ngg01ah', '000g019n'
+    ]
+    syntax2 = ['1og7', '1mo7', '1o07', '1ng7', '1o87', '1no7', '1n87', '1n07', '1mg7']
+
+    oids = []
+    for n in range(count):
+        charset = string.ascii_lowercase + string.digits # 'abcdefghijklmnopqrstuvwxyz0123456789'
+        timestamp = str(int(time() * 1000000))
+        randomkey = list(timestamp[-8:]) + choices(charset, k=5)
+        shuffle(randomkey)
+        oids.append(f'_040g{choice(syntax1)}{choice(syntax2)}{"".join(randomkey)}')
+    if len(oids) == 1:
+        return oids[0]
+    return oids
+
+
+if __name__ == "__main__":
+    for oid in generateOID(100):
+        print(oid)

cannect/core/ascet/ws.py

@@ -0,0 +1,154 @@
+from cannect.core.ascet import AmdIO, AmdSC
+from cannect.core.subversion import Subversion
+from cannect.config import env
+from cannect.errors import AscetWorspaceFormatError, AmdDuplicationError, AmdNotFoundError
+from pandas import DataFrame, concat
+from pathlib import Path
+from typing import Union
+import os
+
+
+class WorkspaceIO:
+
+    def __init__(self, path:str=""):
+        self.path = path = env.SVN_MODEL if not path else Path(path)
+
+        listdir = os.listdir(path)
+        if not "HNB_GASOLINE" in listdir:
+            raise AscetWorspaceFormatError('NO {HNB_GASOLINE} IN WORKSPACE DIRECTORY')
+        if not "HMC_ECU_Library" in listdir:
+            raise AscetWorspaceFormatError('NO {HMC_ECU_Library} IN WORKSPACE DIRECTORY')
+
+        fdb = ''
+        if '.svn' in listdir:
+            fdb = Path(path) / '.svn/wc.db'
+        for f in listdir:
+            if f.endswith('.aws'):
+                fdb = Path(path) / f
+
+        if not fdb:
+            raise AscetWorspaceFormatError('NO .aws OR wc.db IN WORKSPACE DIRECTORY')
+
+        if str(fdb).endswith('.db'):
+            db = Subversion.read_wcdb(fdb)
+            db = db[~db["local_relpath"].str.startswith("Personal")]
+            self.dbtype = 'wc'
+        else:
+            self.dbtype = 'ws'
+            # TODO
+            # .aws 파일 파싱
+            pass
+        self.db = db
+        return
+
+    def __getitem__(self, item):
+        return self.find(item)
+
+    def find(self, name:str) -> str:
+        # TODO
+        # .asw CASE 생성
+        if self.dbtype == 'ws':
+            pass
+        else:
+            if not name.endswith('.zip'):
+                name += '.zip'
+            query = self.db[self.db['kind'] == 'file'].copy()
+            query = query[query['local_relpath'].str.endswith(name)]
+            if query.empty:
+                raise AmdNotFoundError(f'MODULE {name} NOT FOUND')
+            if len(query) > 1:
+                raise AmdDuplicationError(rf'{query}\nMODULE {name} DUPLICATED: SPECIFY PARENT FOLDER')
+            return str(self.path / query.iloc[0]['local_relpath'])
+
+    @property
+    def HNB_GASOLINE(self) -> Path:
+        return self.path / 'HNB_GASOLINE'
+
+    @property
+    def HMC_ECU_Library(self) -> Path:
+        return self.path / 'HMC_ECU_Library'
+
+    def bcPath(self, n:Union[str, int]) -> str:
+        target = [path for path in os.listdir(self.HNB_GASOLINE) if str(n) in path]
+        if not target:
+            raise FileNotFoundError(f'#{n} BC Not Exist')
+        return str(self.HNB_GASOLINE / target[0])
+
+    def bcTree(self, n:Union[str, int]) -> DataFrame:
+        r"""
+        :param n:
+        :return:
+
+        출력 예시)
+                                      bc                      file               layer1                        layer2        layer3                                               path
+        0   _33_EnginePositionManagement               CamPosA.zip          CamPosition                     EdgeAdapt       CamPosA  D:\SVN\model\ascet\trunk\HNB_GASOLINE\_33_Engi...
+        1   _33_EnginePositionManagement               CamOfsD.zip          CamPosition               OffsetDiagnosis       CamOfsD  D:\SVN\model\ascet\trunk\HNB_GASOLINE\_33_Engi...
+        2   _33_EnginePositionManagement                CamSeg.zip          CamPosition                   SegmentTime        CamSeg  D:\SVN\model\ascet\trunk\HNB_GASOLINE\_33_Engi...
+        ...                         ...                        ...                  ...                           ...
+        29  _33_EnginePositionManagement                 EpmSv.zip       ServiceLibrary                      EpmSvLib           NaN  D:\SVN\model\ascet\trunk\HNB_GASOLINE\_33_Engi...
+        30  _33_EnginePositionManagement               CamSync.zip       Syncronization                  CamPhaseSync        CamSyn  D:\SVN\model\ascet\trunk\HNB_GASOLINE\_33_Engi...
+        31  _33_EnginePositionManagement                CrkSyn.zip       Syncronization             CrankPositionSync        CrkSyn  D:\SVN\model\ascet\trunk\HNB_GASOLINE\_33_Engi...
+        """
+        path = self.bcPath(n)
+        data = []
+        for root, paths, files in os.walk(path):
+            for file in files:
+                data.append({
+                    'bc': os.path.basename(path),
+                    'file': file,
+                    'path': os.path.join(root, file),
+                })
+                layers = [l for l in root.replace(path, "").split('/' if '/' in root else '\\') if l]
+                for n, layer in enumerate(layers):
+                    data[-1].update({f'layer{n+1}': layer})
+        tree = DataFrame(data)
+        cols = [col for col in tree if not col == 'path'] + ['path']
+        return tree[cols]
+
+    def bcEL(self, n:Union[str, int]) -> DataFrame:
+        objs = []
+        tree = self.bcTree(n)
+        for i, row in tree.iterrows():
+            path = row['path']
+            amdsc = AmdSC(path)
+            amdio = AmdIO(amdsc.main)
+            frame = amdio.dataframe('Element')
+            # frame['bc'] = row['bc']
+
+            objs.append(frame)
+        data = concat(objs=objs, axis=0)
+
+        unique = data[data['scope'] == 'exported']
+        oids = dict(zip(unique['name'].values, unique['OID'].values))
+        def __eid(_row):
+            if _row.scope in ["exported"]:
+                return _row.OID
+            if _row["name"] in oids:
+                return oids[_row["name"]]
+            return None
+        data["UID"] = data.apply(__eid, axis=1)
+        return data
+
+    def bcIO(self, n:Union[str, int]) -> DataFrame:
+        el = self.bcEL(n).copy().set_index(keys='UID')
+        el = el[["model", "name", "unit", "modelType", "basicModelType", "kind", "scope"]]
+        im = el[el["scope"] == "imported"].copy()
+        ex = el[el["scope"] == "exported"].copy()
+        im["exportedBy"] = [ex.loc[i, "model"] if i in ex.index else "/* 외부 BC */" for i in im.index]
+        return concat([im, ex], axis=0)
+
+
+
+if __name__ == "__main__":
+    from pandas import set_option
+    set_option('display.expand_frame_repr', False)
+
+
+    io = WorkspaceIO()
+    print(io["CanHSFPCMD"])
+    # print(io.bcPath(33))
+    # print(io.bcTree(33))
+    # print(io.bcEL(33))
+    # print(io.bcIO(33))
+
+    # io.bcIO(33).to_clipboard()

cannect/core/can/__init__.py

@@ -0,0 +1,2 @@
+from . import ascet as AscetCAN
+from . import db as DataBaseCAN

cannect/core/can/ascet/__init__.py

@@ -0,0 +1,3 @@
+from .diag import CANDiag as ComDiag
+from .comrx import ComRx
+from .comdef import ComDef

cannect/core/can/ascet/_db2code.py

@@ -0,0 +1,344 @@
+from cannect.config import env
+from cannect.core.can.rule import naming
+from cannect.errors import CANDBError
+from cannect.schema.candb import CanMessage, CanSignal
+
+from datetime import datetime
+from pandas import DataFrame, Series
+from typing import Dict
+import pandas as pd
+import re
+
+
+INFO = lambda revision: f"""* COMPANY: {env['COMPANY']}
+* DIVISION: {env['DIVISION']}
+* AUTHOR: {env['USERNAME']}
+* CREATED: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+* DB VERSION: {revision}
+{env["COPYRIGHT"]} 
+
+THIS MODEL IS AUTO-GENERATED.
+"""
+
+INLINE = f"""
+/* ----------------------------------------------------------------------------------------------------
+    Inline Function : Memory Copy
+---------------------------------------------------------------------------------------------------- */
+inline void __memcpy(void *dst, const void *src, size_t len) {{
+    size_t i;
+    char *d = dst;
+    const char *s = src;
+    for (i = 0; i < len; i++)
+        d[i] = s[i];
+}}
+
+/* ----------------------------------------------------------------------------------------------------
+    Inline Function : Message Counter Check
+---------------------------------------------------------------------------------------------------- */
+inline void cntvld(uint8 *vld, uint8 *timer, uint8 recv, uint8 calc, uint8 thres) {{
+    if ( recv == calc ) {{
+        *timer += 1;
+        if ( *timer >= thres ) {{
+            *timer = thres;
+            *vld = 0;
+        }}
+    }}
+    else {{
+        *timer = 0;
+        *vld = 1;
+    }}
+}}
+
+/* ----------------------------------------------------------------------------------------------------
+    Inline Function : CRC Check
+---------------------------------------------------------------------------------------------------- */
+inline void crcvld(uint8 *vld, uint8 *timer, uint8 recv, uint8 calc, uint8 thres) {{
+    if ( recv == calc ) {{
+        *timer = 0;
+        *vld = 1;
+    }}
+    else {{
+        *timer += 1;
+        if ( *timer >= thres ) {{
+            *timer = thres;
+            *vld = 0;
+        }}
+    }}
+}}
+
+/* ----------------------------------------------------------------------------------------------------
+    Inline Function : Alive Counter Check
+---------------------------------------------------------------------------------------------------- */
+inline void alvvld(uint8 *vld, uint8 *timer, uint8 recv, uint8 calc, uint8 thres) {{
+    if ( ( recv == calc ) || ( (recv - calc) > 10 ) ) {{
+        *timer += 1;
+        if ( *timer >= thres ) {{
+            *timer = thres;
+            *vld = 0;
+        }}
+    }}
+    else {{
+        *timer = 0;
+        *vld = 1;
+    }}
+}}
+"""
+
+
+def SignalDecode(signal:CanSignal, rule:naming=None) -> str:
+    if signal.empty:
+        return ""
+    if not rule:
+        rule = naming(signal.Message)
+    name = signal.SignalRenamed if signal.SignalRenamed else signal.name
+    size = 8 if signal.Length <= 8 else 16 if signal.Length <= 16 else 32
+    buff = f'{rule.tag}.B.{name}'
+    elem = f'{name}_Can'
+    if signal.Message == "L_BMS_22_100ms" and signal.Length == 32:
+        return f"""{elem} = (uint32)({buff}_1
+                            + ({buff}_2 << 8)
+                            + ({buff}_3 << 16)
+                            + ({buff}_4 << 24));"""
+
+    if signal["Value Type"].lower() == "unsigned":
+        return f"{elem} = (uint{size}){buff};"
+
+    if signal.SignedProcessing.lower() == "complement":
+        if signal.Length in [8, 16, 32]:
+            return f"{elem} = (sint{size}){buff};"
+        else:
+            msb = f"( {buff} >> {signal.Length - 1} ) && 1"
+            neg = f"(sint{size})({buff} | {hex(2 ** size - 2 ** signal.Length).upper().replace('X', 'x')})"
+            pos = f"(sint{size}){buff}"
+            return f"{elem} = {msb} ? {neg} : {pos};"
+    elif signal.SignedProcessing.lower() == "absolute":
+        msb = f"( {buff} >> {signal.Length - 1} ) && 1"
+        neg = f"(sint{size})( (~{buff} + 1) | {hex(2 ** size - 2 ** (signal.Length - 1)).upper().replace('X', 'x')} )"
+        pos = f"(sint{size}){buff}"
+
+        syn = f"{elem} = {msb} ? {neg} : {pos};"
+        rtz = f"if ( {buff} == {hex(2 ** (signal.Length - 1)).upper().replace('X', 'x')} ) {{ {elem} = 0x0; }}"
+
+        if str(signal.name) in ["TCU_TqRdctnVal", "TCU_EngTqLimVal", "L_TCU_TqRdctnVal", "L_TCU_EngTqLimVal"]:
+            syn += f'\n{rtz}'
+        return syn
+    else:
+        raise CANDBError("Signed Signal must be specified the processing method.")
+
+
+class MessageValidator:
+    def __init__(self, alv_or_crc:CanSignal, rule:naming=None):
+        var = f'{alv_or_crc.name}_Can'
+        calc =f'{alv_or_crc.name}Calc'
+        self.decode = SignalDecode(alv_or_crc, rule)
+        self.encode = ''
+        if alv_or_crc.empty:
+            self.calcCode = ''
+            self.validate = ''
+            return
+        elif alv_or_crc.isCrc():
+            self.calcCode = f'{calc} = CRC{alv_or_crc.Length}bit_Calculator.calc( {alv_or_crc.ID}, {rule.tag}.Data, {rule.dlc} );'
+            self.validate = f'crcvld( &{rule.crcValid}, &{rule.crcTimer}, {var}, {calc}, {rule.thresholdTime} );'
+        elif alv_or_crc.isAliveCounter():
+            self.calcCode = f'{calc} = {var};'
+            self.validate = f'alvvld( &{rule.aliveCountValid}, &{rule.aliveCountTimer}, {var}, {calc}, {rule.thresholdTime} );'
+        else:
+            pass
+        return
+
+
+class MessageCode:
+    SEND_TYPE = {
+        "P": "Periodic",
+        "PE": "Periodic On Event",
+        "EC": "Event On Change",
+        "EW": "Event On Write",
+    }
+
+    def __init__(self, message:CanMessage, exclude_tsw:bool=True):
+        self.message = message
+        self.name = name = str(message.name)
+        self.names = naming(self.name)
+        self.exclude_tsw = exclude_tsw
+
+        self.srv_name = lambda md: f"#define COMPILE_UNUSED__{md.upper()}_IMPL__{name}"
+        return
+
+    def __getitem__(self, item):
+        return self.message[item]
+
+    def messageAlign(self) -> list:
+        buffer = [f"Reserved_{n // 8}" for n in range(8 * self["DLC"])]
+        self.message.ITERATION_INCLUDES_CRC = self.message.ITERATION_INCLUDES_ALIVECOUNTER = True
+        for sig in self.message:
+            index = sig.StartBit
+            while index < (sig.StartBit + sig.Length):
+                buffer[index] = sig.SignalRenamed if sig.SignalRenamed else sig.Signal
+                index += 1
+
+        # Exception
+        cnt = {}
+        for n, sig in enumerate(buffer.copy()):
+            if sig.startswith('xEV_Tot'):
+                if not sig in cnt:
+                    cnt[sig] = 0
+                buffer[n] = f'{buffer[n]}_{(cnt[sig] // 8) + 1}'
+                cnt[sig] += 1
+
+        aligned = []
+        count, name = 0, buffer[0]
+        for n, sig in enumerate(buffer):
+            if sig == name:
+                count += 1
+                if n == 8 * self["DLC"] - 1:
+                    aligned.append(f"uint32 {name} : {count};")
+            else:
+                aligned.append(f"uint32 {name} : {count};")
+                count, name = 1, sig
+
+        eigen = []
+        aligned_copy = aligned.copy()
+        for n, struct in enumerate(aligned):
+            label = struct.split(" : ")[0].replace("uint32 ", "")
+            if label in eigen:
+                aligned_copy[n] = aligned_copy[n].replace(label, f'{label}_{eigen.count(label)}')
+            eigen.append(label)
+
+        return aligned_copy
+
+    def signalDecode(self, spliter:str="\n\t") -> str:
+        code = []
+        for sig in self.message:
+            if sig.isAliveCounter() or sig.isCrc():
+                continue
+            code.append(SignalDecode(sig, self.names))
+        return spliter.join(code)
+
+    @property
+    def def_name(self) -> str:
+        chn = "PL2" if self["Channel"] == "H" else "PL1" if self["Channel"] == "L" else "P"
+        bsw = f"CAN_MSGNAME_{self['Message']}_{chn}"
+        if self["Message"] == "EGSNXUpStream_Data":
+            bsw = "CAN_MSGNAME_EGSNXUpStream_B1_data_1"
+        if self["Message"] == "EGSNXUpStream_Req":
+            bsw = "CAN_MSGNAME_EGSNXUpStream_B1_Rqst"
+        if self["Message"] == "HCU_11_P_00ms":
+            bsw = "CAN_MSGNAME_HCU_11_00ms_P"
+        if self["Message"] == "HCU_11_H_00ms":
+            bsw = "CAN_MSGNAME_HCU_11_00ms_PL2"
+        if self["Message"] == "IMU_01_10ms":
+            bsw = "CAN_MSGNAME_YRS_01_10ms_P"
+        if self.message.isTsw() and self.exclude_tsw:
+            bsw = 255
+        asw = f'MSGNAME_{naming(self["Message"]).tag}'
+        return f"#define {asw}\t{bsw}"
+
+    @property
+    def struct(self) -> str:
+        aligned = '\n\t\t'.join(self.messageAlign())
+        return f"""
+/* ------------------------------------------------------------------------------
+ MESSAGE\t\t\t: {self["Message"]}
+ MESSAGE ID\t\t: {self["ID"]}
+ MESSAGE DLC\t: {self["DLC"]}
+ SEND TYPE\t\t: {self["Send Type"]}
+-------------------------------------------------------------------------------- */
+typedef union {{
+    uint8 Data[{self["DLC"]}];
+    struct {{
+        {aligned}
+    }} B;
+}} CanFrm_{self.names.tag};"""
+
+    @property
+    def method(self) -> str:
+        names = self.names
+        aliveCounter = MessageValidator(self.message.aliveCounter, names)
+        crc = MessageValidator(self.message.crc, names)
+        code = f"""
+/* ------------------------------------------------------------------------------
+ MESSAGE\t\t\t: {self.name}
+ MESSAGE ID\t\t: {self["ID"]}
+ MESSAGE DLC\t: {self["DLC"]}
+ SEND TYPE\t\t: {self.SEND_TYPE[self["Send Type"]]}
+ VERSION\t\t\t: {self["Version"]}
+-------------------------------------------------------------------------------- */
+if ( CanFrm_Recv( MSGNAME_{names.tag}, {names.buffer}, &{names.dlc} ) == CAN_RX_UPDATED ) {{
+
+    CanFrm_{names.tag} {names.tag} = {{0, }};
+    __memcpy( {names.tag}.Data, {names.buffer}, {names.dlc} );
+
+    { crc.decode }
+    { crc.calcCode }
+    { aliveCounter.decode }
+
+    { self.signalDecode() }
+
+    { names.counter }++;
+}}
+
+cntvld( &{names.messageCountValid}, &{names.messageCountTimer}, {names.counter}, {names.counterCalc}, {names.thresholdTime} );
+{ crc.validate }
+{ aliveCounter.validate }
+
+{ names.counterCalc } = { names.counter };
+{ aliveCounter.calcCode }
+"""
+        pcode = code[1:].splitlines()
+        ccode = []
+        for n, line in enumerate(pcode):
+            if n:
+                prev_line = pcode[n-1].replace("\t", "").replace(" ", "")
+                curr_line = line.replace("\t", "").replace(" ", "")
+                if prev_line == curr_line == "":
+                    continue
+            ccode.append(line)
+        return "\n".join(ccode)
+
+    def to_rx(self, model: str) -> str:
+        tab, i = '\t', 0
+        send_type = {
+            "P": "Periodic",
+            "PE": "Periodic On Event",
+            "EC": "Event On Change",
+            "EW": "Event On Write",
+        }
+        syntax = f"""
+/* ------------------------------------------------
+ MESSAGE\t\t\t: {self["Message"]}
+ MESSAGE ID\t\t: {self["ID"]}
+ MESSAGE DLC\t: {self["DLC"]}
+ SEND TYPE\t\t: {send_type[self["Send Type"]]}
+ CHANNEL\t\t\t: {self["Channel"]}-CAN
+-------------------------------------------------- */"""
+        if self["SystemConstant"]:
+            syntax += f"\n#if ( {self['SystemConstant']} )"
+        if self["Codeword"]:
+            syntax += f"\nif ( {self['Codeword']} ) {{"
+            i += 1
+        syntax += f"\n{tab * i}{model.upper()}_IMPL__{self['Message']}();\n"
+        if self["Codeword"]:
+            syntax += f"}}\n"
+        if self["SystemConstant"]:
+            syntax += f"#endif\n"
+        return syntax
+
+    @classmethod
+    def method_contains_message(cls, context: Dict[str, str]) -> DataFrame:
+        status = {}
+        for method, code in context.items():
+            if code is None:
+                status[method] = None
+            else:
+                fs = [f.split("__")[-1] for f in re.findall(r'\bCOMDEF_\w*', code)]
+                status[method] = Series(index=fs, data=fs)
+        return pd.concat(status, axis=1)
+
+if __name__ == "__main__":
+    from pyems.candb import CAN_DB
+
+    testDB = CAN_DB.to_developer_mode("HEV")
+
+    code = MessageCode(testDB.messages["L_BMS_22_100ms"])
+    print(code.def_name)
+    print(code.method)