精华内容
下载资源
问答
  • 描述:LDFEditor可以编辑保存LIN的LDF格式文件,没有CANoe工具License无法使用LDF Explorer工具的福音,此版本完全免费。 详情:LDFEditor软件是一个非常好用的LIN数据库描述文件编辑软件,它可以创建,编辑,查看...
  • 本文介绍mssqlserver怎么恢复ldf文件数据库,简单的来说,MDF文件是SQL server用来存放数据的数据库文件;LDF文件SQL server是日志文件,存放了对数据库进行的所有操作信息
  • 详情:可以通过客户给的Excel矩阵表通过配置生成LDF文件和位定义文件,也可以通过客户给的LDF文件生成Excel矩阵表和位定义文件, 附件里有demo模板,可自己创建配置ini文件。 具体使用说明:...
  • SQLSERVER误删log_ldf文件解决方式.docx
  • 数据库清除日志文件,(LDF文件过大),一般情况下,有更简单的方法,需要在sqlserver查询执行。
  • ldf_parser 林描述文件的基于正则表达式的简单解析器。
  • 数据库在使用中,冗余的数据不断的增加(数据删除也不会减小),导致数据库不断的增大!所以该给你的数据库减减肥了
  • LIN 总线上位机软件。TCANLINPro软件 and LIN数据库描述(LDF格式)文件编辑软件。
  • python-ldf-服务器 python的实验性ldf服务器
  • 本技巧说明如何在SQL Server中重命名数据库及其MDF和LDF文件。
  • LIN LDF分析软件/LIN分析仪软件/LINTest-LDF
  • 线性判别ldf模式识别

    2016-10-29 15:06:15
    线性判别ldf模式识别
  • Java语言编写的宿舍管理系统 可以应用于数据库实验设计
  • 基于水平集的活动轮廓(image segmentation based on active contour model),包括LBF模型和LDF模型,matlab程序,用于实现图像分割,亲自调试通过
  • LDF文件详解 一、摘要 1.描述 2.关键字 二、为什么要了解LDF文件 三、LDF文件构成 1.版本 2.波特率 3.节点信息 4.信号信息 5.诊断信号信息 6.报文消息 7.诊断报文消息 8.从节点信息 9.调度表 10.描述信息 11.信号...

    一、摘要

    1.描述

    本文主要描述的是汽车行业中LDF文件的格式,如何去解析它,如何通过文本编辑器去修改它,了解LDF文件之前如果不懂LDF的请去查看我之前的博客。

    2.关键字

    LDF,LDF解析,LDF数据库,LDF文件,C#解析LDF文件。

    二、为什么要了解LDF文件

    LDF文件在汽车行业应用十分广泛,如果编辑LDF文件我们都使用Vector工具DF Explorer Pro或者LDFEditor去编辑,那效率将会是十分的低下,当我们了解了LDF文件的构成后,我们可以通过其他方式进行解析,可以大大的提高工作的效率,我们可以通过记事本或者其他工具打开LDF文件。

    三、LDF文件构成

    1.版本

    关键字:LIN_protocol_version
    格式:LIN_protocol_version = “version”;
    格式中的version就是版本信息,版本信息可以为空,但是不能省略""符。
    例如:LIN_protocol_version = “2.1”;代表版本号为V2.1。
    在这里插入图片描述

    2.波特率

    关键字:LIN_speed
    格式:LIN_speed = baudrate;
    格式中的baudrate就是波特率。
    例如:LIN_speed = 19.2 kbps;;代表波特率为19200。
    在这里插入图片描述

    3.节点信息

    关键字:Nodes
    格式:Nodes {
            Master: name1 jitter ms, timebase ms ;
            Slaves: name2,name3…;
          }

    name1:主节点名称。
    jitter:偏移是指一帧报文实际开始发送的时刻与帧时隙起点的时间差。
    timebase:时间基数
    name2,name3…:代表接收节点名称。
    例如:Nodes {
            Master: GW_BCM, 1 ms, 0 ms ;
            Slaves: LIN_RLS,Tellus_Node;
          }
    代表主节点名称为BCM,偏移为1ms,时间基数为0ms,从节点名称为LIN_RLS和Tellus_Node。
    在这里插入图片描述

    4.信号信息

    关键字:Signals
    格式:Signals {
            Signal_Name: Bit_Length, Signal_Init_Value, name1, name2… ;
            …;
          }

    Signal_Name:信号名称,命名规则和C语言变量相同。
    Bit_Length:信号的长度,范围为1-64。
    Signal_Init_Value:信号初始值。
    name1,name2…:代表接收节点名称。
    例如:Signals {
            BCM_WiperRunning: 1, 0, GW_BCM, LIN_RLS ;
            RLS_MessageCounter: 4, 0, LIN_RLS, GW_BCM;
          }
    代表信号名称为BCM_WiperRunning的长度为1,初始值为0,接收节点有GW_BCM, LIN_RLS;
    信号名称为RLS_MessageCounter的长度为4,初始值为0,接收节点有LIN_RLS, GW_BCM;
    在这里插入图片描述

    5.诊断信号信息

    关键字:Diagnostic_signals
    格式:Diagnostic_signals{
            Signal_Name: Bit_Length, Signal_Init_Value ;
            …;
          }

    Msg_ID:报文标识符,十进制表示。
    Msg_Name:报文名称,命名规则和C语言变量相同。
    Msg_Length :报文长度,长度范围为0-8。
    例如:Diagnostic_signals{
            MasterReqB0: 8, 0 ;
            MasterReqB1: 8, 0 ;
            MasterReqB2: 8, 0 ;
            MasterReqB3: 8, 0 ;
            MasterReqB4: 8, 0 ;
            MasterReqB5: 8, 0 ;
            MasterReqB6: 8, 0 ;
            MasterReqB7: 8, 0 ;
            SlaveRespB0: 8, 0 ;
            SlaveRespB1: 8, 0 ;
            SlaveRespB2: 8, 0 ;
            SlaveRespB3: 8, 0 ;
            SlaveRespB4: 8, 0 ;
            SlaveRespB5: 8, 0 ;
            SlaveRespB6: 8, 0 ;
            SlaveRespB7: 8, 0 ;
          }
    诊断报文一般自动生成的格式基本不变,也可以做一定名字调整等。
    在这里插入图片描述

    6.报文消息

    关键字:Frames
    格式:Frames {
            Msg_Name: Msg_ID, Msg_Transmitter, Msg_Length {
              Signal_Name, Start_Bit;
              …;
            };
            …;
          }

    Msg_Name:报文名称,命名规则和C语言变量相同。
    Msg_ID:报文标识符,十进制或者十六进制表示。
    Msg_Transmitter:发送节点。
    Msg_Length :报文长度,长度范围为0-8。
    Signal_Name:信号名称,命名规则和C语言变量相同。
    Start_Bit:信号的起始位,范围为0-63。
    例如:Frames {
            BCM_data: 21, GW_BCM, 8{
              BCM_WiperRunning, 23;
            }
            RLS_data: 13, LIN_RLS, 8{
              RLS_MessageCounter, 0;
            }
          }
    代表报文名称BCM_data的ID为0x15,长度为8,发送节点为GW_BCM,包含信号名称为BCM_WiperRunning,该信号起始位为23;
    报文名称RLS_data的ID为0x0D,长度为8,发送节点为LIN_RLS,包含信号名称为RLS_MessageCounter,该信号起始位为0;
    在这里插入图片描述

    7.诊断报文消息

    关键字:Diagnostic_frames
    格式:Diagnostic_frames {
            MasterReq: Msg_ID{
              Signal_Name, Start_Bit;
              …;
            };
            SlaveResp: Msg_ID{
              Signal_Name, Start_Bit;
              …;
            };
          }

    Msg_ID:报文标识符,十进制或者十六进制表示。
    Msg_Length :报文长度,长度范围为0-8。
    Signal_Name:信号名称,命名规则和C语言变量相同。
    Start_Bit:信号的起始位,范围为0-63。
    例如:Diagnostic_frames {
            MasterReq: 0x3c {
              MasterReqB0, 0;
              MasterReqB1, 8;
              MasterReqB2, 16;
              MasterReqB3, 24
              MasterReqB4, 32;
              MasterReqB5, 40;
              MasterReqB6, 48;
              MasterReqB7, 56;
            }
            SlaveResp: 0x3d {
              SlaveRespB0, 0;
              SlaveRespB1, 8;
              SlaveRespB2, 16;
              SlaveRespB3, 24
              SlaveRespB4, 32;
              SlaveRespB5, 40;
              SlaveRespB6, 48;
              SlaveRespB7, 56;
            }
          }
    在这里插入图片描述

    8.从节点信息

    • 关键字:Node_attributes
      格式:BA_DEF_ Object AttributeName ValueType Min Max;”
      Object:注解的对象类型,可以是节点“BU_”、报文“BO_”、消息”SG_”、网络节点” ”(用空格表示)。
      AttributeName: 自定义属性名称,命名规则和C语言变量相同。
      ValueType:属性值的类型,可以是整型、字符串、浮点型、枚举类型等。
      Min:属性值的最小值(字符串类型没有此项)。
      Min:属性值的最大值(字符串类型没有此项)。
      例如:BA_DEF_ “ECU” STRING ;代表自定义网络节点属性名称为ECU,类型为字符串型。
      BA_DEF_ BO_ “MsgCycleTime” INT 0 1000;代表自定义报文属性名称为MsgCycleTime,类型为整型,取值范围为0-1000。

    9.调度表

    • 关键字:Node_attributes
      格式:BA_DEF_ Object AttributeName ValueType Min Max;”
      Object:注解的对象类型,可以是节点“BU_”、报文“BO_”、消息”SG_”、网络节点” ”(用空格表示)。
      AttributeName: 自定义属性名称,命名规则和C语言变量相同。
      ValueType:属性值的类型,可以是整型、字符串、浮点型、枚举类型等。
      Min:属性值的最小值(字符串类型没有此项)。
      Min:属性值的最大值(字符串类型没有此项)。
      例如:BA_DEF_ “ECU” STRING ;代表自定义网络节点属性名称为ECU,类型为字符串型。
      BA_DEF_ BO_ “MsgCycleTime” INT 0 1000;代表自定义报文属性名称为MsgCycleTime,类型为整型,取值范围为0-1000。

    10.描述信息

    关键字:Signal_encoding_types
    格式:Signal_encoding_types {
            Signal_Encoding{
              physical_value, Min, Max, Factor, Offset,“Unit” ;
              logical_value, N, “DefineN;
              …;
            };
            …;
          }

    Signal_Encoding:信号描述定义名称,命名规则和C语言变量相同。
    N:定义的数值表内容。
    Min:属性值的最小值(十进制)。
    Min:属性值的最大值(十进制)。
    Factor:精度。
    Offset:偏移量,Factor和Offset这两个值于该信号的原始值与物理值之间的转换,转换如下:物理值=原始值*因子+偏移量。
    DefineN:数值表内容对应该信号的有效值分别用什么符号表示。
    Unit:信号的单位,为字符串类型,可以省略,省略时“,”也要省略。
    例如:Signal_encoding_types{
            BCM_AMP_Driver_Encoding {
              physical_value, 0, 7, 1, 0 ;
              logical_value, 0, “No input” ;
              logical_value, 1, “Manual Up” ;
              logical_value, 2, “Manual Down” ;
            }
          }
    代表描述信号名称为BCM_AMP_Driver_Encoding 的最小值为0,最大值为7,精度为1,偏移量为0,定义0x00表示为"No input" ,0x01表示为"Manual Up" ,0x02表示为"Manual Down" 。
    在这里插入图片描述

    11.信号描述关联

    关键字:Signal_representation
    格式:Signal_representation {
            Signal_Encoding: Signal_Name1, Signal_Name2…;
            …
          }

    Signal_Encoding:信号描述定义名称,命名规则和C语言变量相同。
    Signal_Name1,Signal_Name2…:信号定义名称,命名规则和C语言变量相同。
    例如:Signal_representation {
            BCM_AMP_Driver_Encoding: BCM_AMP_Driver ;
            BCM_DRV_SWITCH_COOL_Encoding: BCM_DRV_SWITCH_COOL ;
          }
    代表信号名称为BCM_AMP_Driver 的信号定义是BCM_AMP_Driver_Encoding的内容;
    BCM_DRV_SWITCH_COOL_Encoding的信号定义是BCM_DRV_SWITCH_COOL 的内容。
    在这里插入图片描述

    四、LDF文件解析

    通过以上描述,我相信各位对LDF文件的结构有一定的了解,但是我们如何去解析呢,很多人第一时间想到的应该是按行解析,其实LDF文件有许多容错处理,单纯按行解析我们会错过许多细节部分,例如下图其实也没有出错,如果按行解析的话报文就解析不到了。还有很多类似的容错处理在里面,所以单纯按行解析是不行的,并且有的时候也是不能通过空格来分开数据的,比如带有“”的前后是可以不追加空格的。
    在这里插入图片描述
    经过好久的挣扎,查询资料,终于在一个博客的找到了一种解析的方式,通过正则表达式去解析,当然他其实是按行解析,其实会丢掉一些数据,我将方法进行了一些简单的优化,先读取整个文件到字符串,把多行空格转换成一行空格,然后把换行符转换成空格符,然后进行查找,然后按照标准进行拆分。我这边解析的主要使用的C#语言,因为C#语言对字符串有友好的操作,我将部分代码粘贴如下,方便大家参考学习。

    1.解析版本

           /***********************************************
              * Name    :AnalysisLDFVersion
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFVersion(string data)
            {
                string pattern = "LIN_protocol_version([ ]*)(=)([ ]*)\"((([^\"\\s])|([\\s\\u4e00-\\u9fa5]))*)\"([ ]*);";
                MatchCollection matchs = Regex.Matches(data, pattern);
                foreach (Match match in matchs)
                {
                    if (matchs.Count == 1)
                    {
                        string[] array = match.Value.Split(new string[] {@"""" }, StringSplitOptions.RemoveEmptyEntries);
                        if (array.Length >= 2)
                        {
                            string version = array[1];
                        }
                        return true;
                    } 
                }
                return true;
            }
    

    2.解析节点信息

           /***********************************************
              * Name    :AnalysisLDFNodes
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFNodes(string data)
            {
                string pattern = "Nodes([ ]*){([ ]*Master[ ]*):([ ]*\\w+[ ]*),([ ]*(\\.|\\w|[ ])+[ ]*),([ ]*(\\.|\\w|[ ])+[ ]*);([ ]*Slaves[ ]*):([ ]*\\w+[ ]*)(,[ ]*\\w+[ ]*)*;[ ]*}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string masterPattern = "(Master[ ]*):([ ]*\\w+[ ]*),([ ]*(\\.|\\w|[ ])+[ ]*),([ ]*(\\.|\\w|[ ])+[ ]*);";
                    foreach (Match masterMatch in Regex.Matches(match.Value, masterPattern))
                    {
                        string[] array = masterMatch.Value.Split(new string[] { " ", ":", ",", ";" }, StringSplitOptions.RemoveEmptyEntries);
                        string master = array[1];
                    }
                    string slavesPattern = "(Slaves[ ]*):([ ]*\\w+[ ]*)(,[ ]*\\w+[ ]*)*;";
                    foreach (Match slavesMatch in Regex.Matches(match.Value, slavesPattern))
                    {
                        string slaves = "";
                        string[] array = slavesMatch.Value.Split(new string[] { " ", ":", ",", ";" }, StringSplitOptions.RemoveEmptyEntries);
                        for (int i = 0; i < array.Length - 1; i++) 
                        {
                            if (slaves == "")
                            {
                                slaves += array[i + 1];
                            }
                            else
                            {
                                slaves += "," + array[i + 1];
                            }
                        }
                    }
                }
                return true;
            }
    

    3.解析调度表

           /***********************************************
              * Name    :AnalysisLDFScheduleTables
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFScheduleTables(string data)
            {
                string pattern = "Schedule_tables([ ]*){((([ ]*\\w+[ ]*){(([ ]*\\w+[ ]+)delay([ ]+(\\d|\\w)+[ ]*;[ ]*))+|([ ]*))})+[ ]*}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string eachPattern = "(\\w+[ ]*){((([ ]*\\w+[ ]+)delay([ ]+(\\d|\\w)+[ ]*;[ ]*))+|([ ]*))}";
                    foreach (Match eachMatch in Regex.Matches(match.Value, eachPattern))
                    {
                        string[] array = eachMatch.Value.Split(new string[] { " ", "{", "}", ";", "delay" }, StringSplitOptions.RemoveEmptyEntries);
                        string scheduleName = array[0];
                    }
                }
                return true;
            }
    

    4.解析报文消息

           /***********************************************
              * Name    :AnalysisLDFFrames
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFFrames(List<Message> messages, string data)
            {
                string pattern = "(Frames[ ]*){((([ ]*\\w+[ ]*):([ ]*\\w+[ ]*),([ ]*\\w+[ ]*),([ ]*\\d+[ ]*){(([ ]*)|(((([ ]*\\w+[ ]*),([ ]*\\d+[ ]*);[ ]*))+))})+)[ ]*}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string eachPattern = "(\\w+[ ]*):([ ]*\\w+[ ]*),([ ]*\\w+[ ]*),([ ]*\\d+[ ]*){(([ ]*)|(((([ ]*\\w+[ ]*),([ ]*\\d+[ ]*);[ ]*))+))}";
                    foreach (Match eachMatch in Regex.Matches(match.Value, eachPattern))
                    {
                        int messageID = -1;
                        string messagePattern = "(\\w+[ ]*):([ ]*\\w+[ ]*),([ ]*\\w+[ ]*),([ ]*\\d+[ ]*)";
                        foreach (Match messageMatch in Regex.Matches(eachMatch.Value, messagePattern))
                        {
                            string[] array = messageMatch.Value.Split(new string[] { " ", ",", ":" }, StringSplitOptions.RemoveEmptyEntries);
                            messageID = ConvertToMsgID(array[1]);
                            Message message = FindLinMsg(messages, (uint)messageID);
                            if (message != null)
                            {
                                ShowMsg(@"Find line """ + messageMatch.Value + @""" message fault", ShowEnum.Fault);
                                return false;
                            }
                            message = new Message();
                            message.Name = ConvertToName(array[0]);
                            message.ID = (uint)ConvertToMsgID(array[1]);
                            message.Transmitter = array[2].Replace(" ", "");
                            message.Length = ConvertToInt(array[3]);
                            message.SendType = SendTypeEnum.UF;
                            message.ChecksumMode = ChecksumModeEnum.Enhanced;
                            message.ResponseError = "";
                            messages.Add(message);
                        }
                        if (messageID == -1)
                        {
                            ShowMsg(@"Find line """ + match.Value + @""" message fault", ShowEnum.Fault);
                            return false;
                        }
                        string signalPattern = "(\\w+[ ]*),([ ]*\\d+[ ]*);";
                        foreach (Match signalMatch in Regex.Matches(eachMatch.Value, signalPattern))
                        {
                            Signal signal = new Signal();
                            Message message = FindLinMsg(messages, (uint)messageID);
                            string[] array = signalMatch.Value.Split(new string[] { " ", ",", ";" }, StringSplitOptions.RemoveEmptyEntries);
                            signal.Name = ConvertToName(array[0]);
                            signal.Startbit = ConvertToInt(array[1]);
                            signal.ByteOrder = ByteOrderEnum.Intel;
                            signal.DataType = DataTypeEnum.Unsigned;
                            signal.Unit = signal.Receivers = signal.ValueDescrptions = signal.Comments = "";
                            signal.Factor = signal.Offst = signal.MinValuePhy = signal.MaxValuePhy = -1;
                            signal.Length = signal.InitValue = signal.InvalidValue = signal.InactiveValue = signal.MinValue = signal.MaxValue = -1;
                            message.Signals.Add(signal);
                        }
                    }
                }
                return true;
            }
    

    5.解析诊断报文消息

           /***********************************************
              * Name    :AnalysisLDFDiagnosticFrames
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFDiagnosticFrames(List<Message> messages, string data)
            {
                string pattern = "(Diagnostic_frames[ ]*){(([ ]\\w+[ ]*):([ ]*\\w+[ ]*){((([ ]*\\w+[ ]*),([ ]*\\d+[ ]*);[ ]*)*)})+[ ]*}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string eachPattern = "(\\w+[ ]*):([ ]*\\w+[ ]*){((([ ]*\\w+[ ]*),([ ]*\\d+[ ]*);[ ]*)*)}";
                    foreach (Match eachMatch in Regex.Matches(match.Value, eachPattern))
                    {
                        int messageID = -1;
                        string messagePattern = "(\\w+[ ]*):([ ]*\\w+)";
                        foreach (Match messageMatch in Regex.Matches(eachMatch.Value, messagePattern))
                        {
                            string[] array = messageMatch.Value.Split(new string[] { " ", ":" }, StringSplitOptions.RemoveEmptyEntries);
                            messageID = ConvertToMsgID(array[1]);
                            Message message = FindLinMsg(messages, (uint)messageID);
                            if (message != null)
                            {
                                ShowMsg(@"Find line """ + messageMatch.Value + @""" message fault", ShowEnum.Fault);
                                return false;
                            }
                            message = new Message();
                            message.Name = ConvertToName(array[0]);
                            message.ID = (uint)ConvertToMsgID(array[1]);
                            message.Transmitter = "";
                            message.Length = 8;
                            message.SendType = SendTypeEnum.DF;
                            message.ChecksumMode = ChecksumModeEnum.Classic;
                            message.ResponseError = "";
                            messages.Add(message);
                        }
                        if (messageID == -1)
                        {
                            ShowMsg(@"Find line """ + match.Value + @""" message fault", ShowEnum.Fault);
                            return false;
                        }
                        string signalPattern = "(\\w+[ ]*),([ ]*\\d+[ ]*);";
                        foreach (Match signalMatch in Regex.Matches(eachMatch.Value, signalPattern))
                        {
                            Signal signal = new Signal();
                            Message message = FindLinMsg(messages, (uint)messageID);
                            string[] array = signalMatch.Value.Split(new string[] { " ", ",", ";" }, StringSplitOptions.RemoveEmptyEntries);
                            signal.Name = ConvertToName(array[0]);
                            signal.Startbit = ConvertToInt(array[1]);
                            signal.ByteOrder = ByteOrderEnum.Intel;
                            signal.DataType = DataTypeEnum.Unsigned;
                            signal.Unit = signal.Receivers = signal.ValueDescrptions = signal.Comments = "";
                            signal.Factor = signal.Offst = signal.MinValuePhy = signal.MaxValuePhy = -1;
                            signal.Length = signal.InitValue = signal.InvalidValue = signal.InactiveValue = signal.MinValue = signal.MaxValue = -1;
                            message.Signals.Add(signal);
                        }
                    }
                }
                return true;
            }
    

    6.解析信号信息

           /***********************************************
              * Name    :AnalysisLDFSignals
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFSignals(List<Message> messages, string data)
            {
                string pattern = "(Signals[ ]*){(((([ ]*\\w+[ ]*):([ ]*\\d+[ ]*),([ ]*\\d+[ ]*),([ ]*\\w+[ ]*(,[ ]*\\w+[ ]*)*);[ ]*)+)|([ ]*))}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string signalPattern = "(\\w+[ ]*):([ ]*\\d+[ ]*),([ ]*\\d+[ ]*),([ ]*\\w+[ ]*(,[ ]*\\w+[ ]*)*);";
                    foreach (Match signalMatch in Regex.Matches(match.Value, signalPattern))
                    {
                        bool result = false;
                        string[] array = signalMatch.Value.Split(new string[] { " ", ":", ",", ";" }, StringSplitOptions.RemoveEmptyEntries);
                        string signalName = ConvertToName(array[0]);
                        foreach (var message in messages)
                        {
                            foreach (var signal in message.Signals)
                            {
                                if (signal.Name == signalName)
                                {
                                    result = true;
                                    signal.Length = ConvertToInt(array[1]); 
                                    signal.InitValue = ConvertToInt(array[2]);
                                    for (int i = 0;i < array.Length - 4; i++)
                                    {
                                        if (i == 0)
                                        {
                                            signal.Receivers = array[i + 4].Replace(" ", "");
                                        }
                                        else
                                        {
                                            signal.Receivers += "," + array[i + 4].Replace(" ", "");
                                        }
                                    }
                                }
                            }
                        }
                        if (!result)
                        {
                            ShowMsg(@"Find line """ + signalMatch.Value + @""" message abnormal", ShowEnum.Warning);
                        }
                    }
                }
                return true;
            }
    

    7.解析诊断信号信息

           /***********************************************
              * Name    :AnalysisLDFDiagnosticSignals
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFDiagnosticSignals(List<Message> messages, string data)
            {
                string pattern = "(Diagnostic_signals[ ]*){(((([ ]*\\w+[ ]*):([ ]*\\d+[ ]*),([ ]*\\d+[ ]*);[ ]*)+)|([ ]*))}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string signalPattern = "(\\w+[ ]*):([ ]*\\d+[ ]*),([ ]*\\d+[ ]*);";
                    foreach (Match signalMatch in Regex.Matches(match.Value, signalPattern))
                    {
                        bool result = false;
                        string[] array = signalMatch.Value.Split(new string[] { " ", ":", ",", ";" }, StringSplitOptions.RemoveEmptyEntries);
                        string signalName = ConvertToName(array[0]);
                        foreach (var message in messages)
                        {
                            foreach (var signal in message.Signals)
                            {
                                if (signal.Name == signalName)
                                {
                                    result = true;
                                    signal.Length = ConvertToInt(array[1]);
                                    signal.InitValue = ConvertToInt(array[2]);
                                }
                            }
                        }
                        if (!result)
                        {
                            ShowMsg(@"Find line """ + signalMatch.Value + @""" message fault", ShowEnum.Fault);
                            return false;
                        }
                    }
                }
                return true;
            }
    

    8.解析信号描述关联

           /***********************************************
              * Name    :AnalysisLDFSignalRepresentation
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFSignalRepresentation(List<Message> messages, string data)
            {
                string pattern = "(Signal_representation[ ]*){(((([ ]*\\w+[ ]*):([ ]*\\w+[ ]*(,[ ]*\\w+[ ]*)*);[ ]*)+)|([ ]*))}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string signalPattern = "([ ]*\\w+[ ]*):([ ]*\\w+[ ]*(,[ ]*\\w+[ ]*)*);";
                    foreach (Match signalMatch in Regex.Matches(match.Value, signalPattern))
                    {
                        bool result = false;
                        string[] array = signalMatch.Value.Split(new string[] { " ", ",", ":", ";" }, StringSplitOptions.RemoveEmptyEntries);
                        for (int i = 0; i < array.Length - 1; i++)
                        {
                            string signalName = ConvertToName(array[i + 1]);
                            foreach (var message in messages)
                            {
                                foreach (var signal in message.Signals)
                                {
                                    if (signal.Name == signalName)
                                    {
                                        result = true;
                                        signal.EncodingName = ConvertToName(array[0]);
                                    }
                                }
                            }
                            if (!result)
                            {
                                ShowMsg(@"Find line """ + signalMatch.Value + @""" message abnormal", ShowEnum.Warning);
                            }
                        }
                    }
                }
                return true;
            }
    

    9.解析描述信息

            /***********************************************
              * Name    :AnalysisLDFSignalEncodingTypes
              * Author  :WangHu
              * Function:***
              * Version :V1.0.0
              * Data    :2020.4.15
            ***********************************************/
            internal static bool AnalysisLDFSignalEncodingTypes(List<Message> messages, string data)
            {
                string pattern = "(Signal_encoding_types[ ]*){((([ ]*\\w+[ ]*){((([ ]*physical_value[ ]*),([ ]*\\w+[ ]*),([ ]*\\w+[ ]*),((([ ]+)|)(-?\\d+(\\.\\d+)?)(([ ]+)|)),((([ ]+)|)(-?\\d+(\\.\\d+)?)(([ ]+)|))((,([ ]*)\"((([^\"\\s])|([\\s\\u4e00-\\u9fa5]))*)\")|)[ ]*;[ ]*)|(([ ]*logical_value[ ]*),([ ]*\\d+[ ]*),([ ]*\"((([^\"\\s])|([\\s\\u4e00-\\u9fa5]))*)\")[ ]*;[ ]*)|[ ]*)*}[ ]*)*)}";
                foreach (Match match in Regex.Matches(data, pattern))
                {
                    string eachPattern = "(\\w+[ ]*){((([ ]*physical_value[ ]*),([ ]*\\w+[ ]*),([ ]*\\w+[ ]*),((([ ]+)|)(-?\\d+(\\.\\d+)?)(([ ]+)|)),((([ ]+)|)(-?\\d+(\\.\\d+)?)(([ ]+)|))((,([ ]*)\"((([^\"\\s])|([\\s\\u4e00-\\u9fa5]))*)\")|)[ ]*;)+|[ ]*)((([ ]*logical_value[ ]*),([ ]*\\d+[ ]*),([ ]*\"((([^\"\\s])|([\\s\\u4e00-\\u9fa5]))*)\")[ ]*;[ ]*)+|[ ]*)}";
                    foreach (Match eachMatch in Regex.Matches(match.Value, eachPattern))
                    {
                        string[] array = eachMatch.Value.Split(new string[] { " ", "{" }, StringSplitOptions.RemoveEmptyEntries);
                        string encodingName = ConvertToName(array[0]);
                        foreach (var message in messages)
                        {
                            foreach (var signal in message.Signals)
                            {
                                if (signal.EncodingName == encodingName)
                                {
                                    string physicalPattern = "(physical_value[ ]*),([ ]*\\w+[ ]*),([ ]*\\w+[ ]*),((([ ]+)|)(-?\\d+(\\.\\d+)?)(([ ]+)|)),((([ ]+)|)(-?\\d+(\\.\\d+)?)(([ ]+)|))((,([ ]*)\"((([^\"\\s])|([\\s\\u4e00-\\u9fa5]))*)\")|)[ ]*;";
                                    foreach (Match physicalMatch in Regex.Matches(eachMatch.Value, physicalPattern))
                                    {
                                        string[] array1 = physicalMatch.Value.Replace(";", "").Split(new string[] { @"""" }, StringSplitOptions.None);
                                        string[] array2 = array1[0].Split(new string[] { " ", "," }, StringSplitOptions.RemoveEmptyEntries);
                                        signal.MinValue = ConvertToMsgID(array2[1]);
                                        signal.MaxValue = ConvertToMsgID(array2[2]);
                                        signal.Factor = ConvertToDouble(array2[3]);
                                        signal.Offst = ConvertToDouble(array2[4]);
                                        signal.Unit = array1.Length >= 2 ? array1[1].Replace(" ", "") : "";
                                    }
                                    string logicalPattern = "(logical_value[ ]*),([ ]*\\d+[ ]*),([ ]*\"((([^\"\\s])|([\\s\\u4e00-\\u9fa5]))*)\")[ ]*;";
                                    foreach (Match logicalMatch in Regex.Matches(eachMatch.Value, logicalPattern))
                                    {
                                        string[] array1 = logicalMatch.Value.Split(new string[] { @"""" }, StringSplitOptions.None);
                                        string[] array2 = array1[0].Split(new string[] { " ", "," }, StringSplitOptions.RemoveEmptyEntries);
                                        if (signal.ValueDescrptions == "")
                                        {
                                            signal.ValueDescrptions += "0x" + ConvertToInt(array2[1]).ToString("X") + ":" + array1[1];
                                        }
                                        else
                                        {
                                            signal.ValueDescrptions += " \r\n0x" + ConvertToInt(array2[1]).ToString("X") + ":" + array1[1];
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                return true;
            }
    

    五、MatrixCreat工具

    这儿我只把链接放上,具体使用说明见后续章节。
    LDF转Excel;LDF转位定义;Excel转LDF;Excel转位定义:https://download.csdn.net/download/weixin_44926112/12670805

    六、其他

    本文主要是讲解LDF文件的结构和如何解析LDF文件,有些地方可能会有描述性的错误,希望看到的朋友及时指出,我会及时更正错误,其他地方有些借鉴的描述,写此文章的目的是为了交流,非商业用途,欢迎私信讨论,感谢大家阅读。

    七、参考

    【1】:https://www.jianshu.com/p/8e1e47c4ee36

    展开全文
  • 描述了将mdf,ldf文件导入sql server的步骤,可以解决数据库链接的问题
  • mssql server .ldf和.mdf的文件附加数据库的sql语句
  • 关键字 LDFLDF转Excel,LDF转位定义,Excel转LDF,Excel转位定义,LDF转XLSX,XLSX转LDF。 二、什么时候需要使用MatrixCreat工具 当客户给Excel的LIN矩阵时,却不方便给LDF文件,我们在调试的时候LDF文件可以大大...

    一、摘要

    1.描述

    • 本文主要描述的是MatrixCreat上位机的使用,通过本文可详细的了解LDF文件和Excel文件的相互转换的过程,了解如何对工具进行自定义配置。
    • 在网络上对于LDF和Excel转换的工具并不多,在早期的时候,由于工作的需要,常常需要使用到LDF文件,也需要根据客户提供的Excel文件转换位定义,在最开始的时候我的想法是固定Excel表格的格式,然后把客户给的Excel表格信息有效内容复制到对应标准的Excel中,然后在进行转换,这样虽然实现了转换,但是伴随的问题也来了,要很好的,高效率的复制粘贴也不是一件容易的事情,而且相对来说每次客户更改文件都需要再复制粘贴一次,显得异常麻烦。所以我想我们可以通过配置的方式,通过读取配置文件来识别不同Excel之间有效的信息,虽然不同客户提供的Excel格式差异比较大,但是具体的内容其实并没有太多的区别。
    • 对于刚开始接触MatrixCreat上位机的人来说可能觉得有些麻烦,觉得转换我只需要点击就可以,但其实你仔细阅读本文后,你会发现这种方式也是一种相对较好的方式,可以很好弥补不同Excel格式之间LDF的转换,也不需要你去网上下载了一个又一个转换工具,最后却发现没有一个工具好用的情况,毕竟每个软件工程师写代码的时候,都是有自己的开发环境和配置,当编译后的软件在其他地方运行时候会出现其他的问题,格式也会有不同的情况。
    • 本软编写的语言是基于C#语言,并未使用其他关联的DLL文件,所以不同的电脑之间兼容性很好,不会出现调用异常的问题。
    • 郑重申明,本软件可以适配绝大多数车厂给的Excel文件,但是不保证所有文件都能适配,绝大部分地方都做了容错处理,但是不排除有异常情况的发生,若遇到有异常的情况,可联系我对代码进行优化,我会听君言及时处理,对软件进行更新升级。

    2.关键字

    LDF,LDF转Excel,LDF转位定义,Excel转LDF,Excel转位定义,LDF转XLSX,XLSX转LDF。

    二、什么时候需要使用MatrixCreat工具

    • 当客户给Excel的LIN矩阵时,却不方便给LDF文件,我们在调试的时候LDF文件可以大大的提高我们的工作效率,我们就需要自己去生成LDF文件,如果编辑LDF文件我们都使用Vector工具DF Explorer Pro或者LDFEditor去编辑,那效率将会是十分的低下,我们可使用MatrixCreat工具进行转换。
    • 当客户给的Excel的LIN矩阵和客户给的LDF文件信号发生冲突时候,可以将客户给的LDF文件进行转换成Excel格式进行对比查看,或者当我们只有LDF文件却没有Excel文件时,我们可使用MatrixCreat工具进行转换。
    • 当我们需要通过客户给的Excel或者LDF文件生成位定义参与编译,手动生成效率低而且不能保证准确性,我们可使用MatrixCreat工具进行转换。

    三、MatrixCreat转换后效果图

    • 一个好的上位机软件不光要实现应有的功能,对用户的使用来说也需要友好的界面,对于容错的处理也需要尽可能的加入,对于生成的文本也需要尽可能的美观,软件的实用性和美观并不冲突。

    • 上位机人机交互界面如下图
      在这里插入图片描述

    • Excel转LDF文件,LDF文件如下图
      在这里插入图片描述

    • Excel转位定义文件,LDF转位定义文件,位定义文件如下图
      在这里插入图片描述

    • LDF转Excel文件,Excel文件如下图
      在这里插入图片描述

    四、MatrixCreat运行环境

    五、MatrixCreat使用介绍

    • 安装好NET Framework4.7.2后,下载MatrixCreat工具压缩包后解压,解压后选择MatrixCreat.exe执行文件,双击运行。
      在这里插入图片描述
    • 打开后即可显示人机交互界面,使用说明如下图所示
      在这里插入图片描述
    • 第一次使用时候默认配置为…\MatrixCreat V1.0\project\Test_Demo.ini,该配置和默认路径…\MatrixCreat V1.0\demo\Test_Demo.xlsx标题相对应,如果不会配置的朋友可以直接使用该模板,将LIN矩阵表复制到该Excel中,转换即可,如果选择的是LDF文件,可以不用太关注配置文件,选择文件后直接点击生成即可获取需要的文件,配置文件也可以自己编辑,每次启动软件都会自动读取上次选择的配置文件和转换的文件,缺少文件会提示错误信息,转换过程如下图所示
      在这里插入图片描述
      在这里插入图片描述

    六、MatrixCreat配置详解

    • 配置文件可实现不同Excel信号的提取,可以有效的提高转换的效率,不同的车厂对LIN矩阵的描述信息各有千秋,我们只需要提取我们需要的信息即可,了解配置文件可自行编辑配置文件已达到期望的效果。
    • 配置文件的后缀.ini结尾的,我们一般可将写好的配置文件存放在…\MatrixCreat V1.0\project目录下,配置文件其实是xml文件,xml文件作为存储信息的重要一种文本方式,可通过记事本进行打开编辑,打开后如下图所示
      在这里插入图片描述
    • 了解配置之前我们需要了解什么是列标识符,其实就是我们说的描述,一般在列的抬头,上位机就是通过识别标识符来达到对应信息的提取,标识符如下图所示
      在这里插入图片描述
    • 下面我们将对每一项配置进行详细的解释,方便用户去了解它,配置它。

    1.ProjectName

    ProjectName代表工程名称,是区分不同配置的重要信息,这个名称也可以为空。

    2.EndianType

    EndianType代表单片机的类型,在前面的章节我们提到过大端小端,如果不太懂的朋友可以仔细阅读以下前面的章节,这个主要是为了生存的位定义文件格式需要,这个配置只能为Big和Little,分别代表大端和小端。

    3.BitsName

    BitsName代表节点名称,主要是用于位定义生成代表是哪路LIN,一般没特别需要求默认配置为Lin即可。

    4.SheetName

    SheetName代表Excel的sheet名称,当我们拿到客户给的Excel文件时候,一个文件里面有许多的表格,通过这个名称可以快速定位我们需要的信息在哪个文件,解析的时候上位机会自动查询到与SheetName相匹配的sheet,然后再进行下一步匹配工作。

    5.ParasRowNum

    ParasRowNum代表我们要识别的列的标识符是第几行,有的厂家给的Excel第一行给的空白,第二行才是描述信息,通过配置快速定位行信息是否相匹配,该配置是从0开始的,代表第一行,这个参数十分重要,否则无法匹配到数据,这个值不能为空。

    6.VariableNameLenth

    VariableNameLenth代表变量名称长度,主要是为了限制最大的信号定义长度,不同的单片机可能存在不同,建议保持默认配置35即可。

    7.NameIsEqual

    NameIsEqual代表名称是否需要完全相等还是说只要要包含即可,也就是相当于搜索中的模糊匹配和全字匹配,主要用于SheetName,报文消息,信号消息的匹配,所谓全字匹配是指大小写和空格均需匹配,不包含换行符。如果列标识符中没有相同的,可以将此设置为False,这样出现的问题几率小。该值只能是True和False。

    8.DiagnosticIsExist

    DiagnosticIsExist代表是否需要生成带有诊断报文的LDF文件,如果矩阵表里无诊断报文,设置此项也可以生成诊断相关的LDF文件。该值只能是True和False。

    9.Version

    Version代表版本信息,可以设置为1.3,2.0,2.1,2.2。

    10.BaudRate

    BaudRate代表波特率,假设为19200,即设置为19.2 kbps。

    11.Jitter

    Jitter代表偏移,假设为5ms,即设置为5ms。

    12.TimeBase

    TimeBase代表时间基数,假设为0.1ms,即设置为0.1 ms。

    13.MasterName

    MasterName代表主节点名称,此参数不能配置为空,否者生成的LDF文件节点识别会出错。

    14.SlavesName

    SlavesName代表从节点名称,此参数不能配置为空,否者生成的LDF文件节点识别会出错。

    15.MessageName

    MessageName代表报文名称,这个配置可以为空,生成出来的LDF文件默认为传输ECU加报文ID。

    16.MessageID

    MessageID代表报文标识符,这个配置不能为空,这个配置对应的列的数据必须要为16进制,可以加0x开头,也可以不加。

    17.MessageLength

    MessageLength代表报文长度,这个配置可以为空,生成的LDF文件默认报文长度为8。

    18.MessageSendType

    MessageSendType代表发送类型,这个配置可以为空,生成的LDF文件默认UF类型。

    19.MessageChecksumMode

    MessageChecksumMode代表校验类型,这个配置可以为空,生成的LDF文件默认Enhanced类型。

    20.MessageResponseError

    MessageResponseError代表错误响应帧,这个配置可以为空,生成的LDF文件默认无错误响应帧。

    21.MessageTransmitter

    MessageTransmitter代表发送ECU,这个配置如果配置了,会去查找对应列的发送ECU,如果没有查找到,会使用MasterName和SlavesName配置进行二次查找。一般两个配置配置一个即可,该配置可以为空。

    22.SignalName

    SignalName代表信号名称,这个配置可以为空,生成出来的LDF文件信号名称为null_加起始位和长度。

    23.SignalStartbit

    SignalStartbit代表起始位,这个配置不能为空。

    24.SignalLength

    SignalLength代表信号长度,这个配置不能为空。

    25.SignalByteOrder

    SignalByteOrder代表排列格式,这个配置可以为空,默认排列格式为Inter格式。

    26.SignalDataType

    SignalDataType代表数据类型,这个配置可以为空。

    27.SignalInitValue

    SignalInitValue代表初始值,这个配置可以为空。

    28.SignalInvalidValue

    SignalInvalidValue代表无效值,这个配置可以为空。

    29.SignalInactiveValue

    SignalInactiveValue代表非使能值,这个配置可以为空。

    30.SignalUnit

    SignalUnit代表单位,这个配置可以为空,生成LDF文件默认单位为空。

    31.SignalFactor

    SignalFactor代表精度,这个配置不能为空。

    32.SignalOffst

    SignalOffst代表偏移量,这个配置不能为空。

    33.SignalMinValuePhy

    SignalInvalidValue代表物理最小值,这个配置可以为空。

    34.SignalMaxValuePhy

    SignalMaxValuePhy代表物理最大值,这个配置可以为空。

    35.SignalReceivers

    SignalReceivers代表接收ECU,这个配置如果配置了,会去查找对应列的接收ECU,不同ECU之间用“,”隔开,如果没有查找到,会使用MasterName和SlavesName配置进行二次查找。一般两个配置配置一个即可,该配置可以为空。

    36.SignalMinValue

    SignalMinValue代表总线最小值,这个配置可以为空,生成LDF文件默认总线最小值为0。

    37.SignalMaxValue

    SignalMaxValue代表总线最大值,这个配置可以为空,生成LDF文件默认总线最大值为0。

    38.SignalValueDescrptions

    SignalValueDescrptions代表信号值描述,这个配置可以为空,生成LDF文件默认信号值描述为空。

    39.SignalComments

    SignalComments代表信号描述,这个配置可以为空。

    40.ScheduleTables

    ScheduleTables代表调度表,这个配置可以为空,可以创建多个调度表,用“;”隔开。

    七、其他

    本文主要是讲解MatrixCreat工具的使用,有些地方可能会有描述性的错误,希望看到的朋友及时指出,我会及时更正错误,其他地方有些借鉴的描述,写此文章的目的是为了交流,非商业用途,欢迎私信讨论,感谢大家阅读。

    八、参考

    【1】:LDF转Excel;LDF转位定义;Excel转LDF;Excel转位定义;MatrixCreat(一)之LIN矩阵详解
    【2】:LDF转Excel;LDF转位定义;Excel转LDF;Excel转位定义;MatrixCreat(二)之LDF文件创建
    【3】:LDF转Excel;LDF转位定义;Excel转LDF;Excel转位定义;MatrixCreat(三)之LDF文件详解

    展开全文
  • 文章目录前言1.LIN版本更迭2.LDF简介2.1 LIN2.1版本LDF2.1.1 全局定义2.1.2 节点定义2.1.3 信号定义2.1.3.1 标准信号定义2.1.3.2 诊断信号定义(可选)2.1.4 帧定义2.1.4.1 无条件帧定义2.1.4.2 事件触发帧定义(可...

    前言

    目前汽车尾灯上面使用LIN总线已经是司空见惯的了,有些预算高的甚至会上CAN总线。然而有些车灯客户的电子工程师对LIN总线未曾深入了解,在实际做项目时遇到LIN相关的问题会不知所措。建议大家阅读瑞萨的《LIN总线入门.pdf》或者笔者之前整理的《LIN总线介绍PPT》
    目前笔者支持的车灯客户遇到最多的是和LDF文件相关的问题。当车厂甩过来一个LDF文件,客户使用开发工具导入该LDF时会弹出很多错误,由于对LDF文件不够熟悉,无法确定问题出在哪里,使得开发的进度受阻。
    下文将介绍不同版本的LDF文件,以及一些常见的LDF文件导入错误的解决办法。

    1.LIN版本更迭

    lin的版本更迭如下图:

    版本发布时间备注
    LIN1.01999-07-01LIN规范的初始版本
    LIN1.12000-03-06增加协议规范,配置语言规范和API规范
    LIN1.22000-11-17
    LIN1.32002-12-13主要对物理层进行修改,提高了节点之间的兼容性
    LIN2.02003-09-16大的版本变动,支持配置,增加诊断规范,规定了节点性能文件
    LIN2.12006-11-24澄清LIN2.0,增加节点配置规范,传输层和诊断独立成章
    LIN2.22010-12-31弱化位采样规范,移除起始位的采样规范
    LIN2.2A2010-12-31更正了第 2.6.2 章中的唤醒信号定义

    2.LDF简介

    从LIN2.0版本开始已经有了节点性能文件的规范,从LIN规范中的工作流(如下图)可以看出,LIN子网设计工具会收集节点性能文件的信息,自动生产LIN描述文件,即LDF。
    0

    一般的LDF编辑查看工具可选的版本有5个,如下所示。

    • LIN1.3
    • LIN2.0
    • J2602
    • LIN2.1
    • LIN2.2/LIN2.2A

    LDF版本虽然很多,但是调用LDF配置的LIN协议栈使用的API就两个版本,LIN2.1的API和J2602的API。
    目前国内车厂用的比较多的是LIN2.1和LIN2.2版本的LDF,北美车厂用的比较多的是J2602版本的LDF。下面介绍下这三个版本的LDF。

    2.1 LIN2.1版本LDF

    LIN2.1的出现主要是为了澄清LIN2.0,同时增加了节点配置规范,传输层和诊断独立成章。
    LIN2.1规范中对LDF的定义如下:
    1

    下面针对上图划分的六部分结合示例进行说明。
    示例LDF选择S32DS for ARM2.2(安装在D盘)自带的LIN例程使用的LDF,地址如下:
    D:\NXP\S32DS_ARM_v2.2\S32DS\software\S32SDK_S32K1xx_RTM_3.0.0\examples\S32K144\demo_apps\lin_master\Sources\LIN21.ldf

    2.1.1 全局定义

    2

    如上图所示,这一段首先定义该文件为LDF,然后选择LIN协议版本和语言版本,最后确定LIN波特率。
    注意:通道名称是可选项,当同一个主节点连接了多个LIN集群,即使用多个LDF,将通道名称作为后缀用以区分。一般情况用不上。

    2.1.2 节点定义

    3

    如上图所示,这一段分别定义主节点和从节点:

    • 主节点:名称,时基,抖动
    • 从节点:每个从节点的名称

    2.1.3 信号定义

    信号原本有三类,标准信号,诊断信号和信号组,但是信号组只在LIN1.3中使用,LIN2.x版本不再使用。

    2.1.3.1 标准信号定义

    标准信号编码类型有两种,一种是标量信号(scalar signal),长度范围为1bit~16bit;一种是数组信号(array signal),长度为8bit的倍数且最大64bit。
    4

    如上图所示,该段用于编写标准信号,包含信号名称,长度,初始值,发布节点和收听节点,array signals的初始值用数组表示,数组的元素个数N = Size / 8bit。
    特别说明:每个从节点都需要预先定义一个长度为1bit的响应错误信号,这个在节点属性定义时需要用到

    2.1.3.2 诊断信号定义(可选)

    5

    如上图所示,由于诊断信号不需要定义发布者和接收者,所以需要和标准信号分开定义。

    2.1.4 帧定义

    帧一共有五类,分为无条件帧,事件触发帧,零星帧,诊断帧和保留帧。保留帧(帧ID为0x3E和0x3F)在LIN2.x版本不使用。

    2.1.4.1 无条件帧定义

    无条件帧是具有单一发布节点,无论信号是否发生变化,帧头都被无条件应答的帧。无条件帧的帧ID范围为0~0x3B。
    6

    如上图所示,这一段主要定义了帧名称,帧ID,发布节点,数据段字节数以及包含的信号名称和偏移量。

    2.1.4.2 事件触发帧定义(可选)

    事件触发帧是主机节点在一个帧时隙中查询各从机节点的信号是否发生变化时使用的帧,当存在多个发布节点时,通过冲突解决进度表来解决冲突。帧ID范围同上。
    7

    如上图所示(由于示例LDF没有定义这部分,截取的LIN2.1规范的例程),主要包含了帧名称,冲突解决进度表,帧ID,关联的无条件帧。

    2.1.4.3 零星帧定义(可选)

    零星帧帧是主机节点在同一帧时隙中当自身信号发生变化时向总线启动发送的帧。当存在多个关联的应答信号变化时,通过事先设定的优先级来仲裁。帧ID范围同上。
    8

    如上图所示,这一段主要定义帧名称以及选择关联的无条件帧,关联的无条件帧的发布节点必须是主节点。

    2.1.4.4 诊断帧定义(可选)

    诊断帧包括主机请求帧和从机应答帧,主要用于配置、识别和诊断用。
    9

    如上图所示,这一段用于配置主机请求帧(帧ID为0x3C)和从机应答帧(帧ID为0x3D),数据段规定为8个字节,一律采用标准型校验和。

    2.1.5 节点属性定义

    10

    这一段主要定义从节点的属性,包含从节点名称,LIN协议版本,NAD配置值,NAD初始值,产品ID(供应商ID,功能ID,变量),选择响应错误信号,P2_min,ST_min,N_As_timeout,,N_Cr_timout,可配置的帧列表。

    2.1.6 调度表

    调度表的功能有很多,包含调度帧,分配NAD,保存配置等。这个例程只使用了调度帧的功能。
    11

    最后一段进行调度表的定义,包含调度表名称,帧名称,帧时隙。

    2.2 J2602版本LDF

    SAE J2602的目标是通过解决LIN2.0的模糊、矛盾或可选的要求来提高网络中不同LIN设备之间的可互操作性和可交互能力。
    LIN2602的LDF和LIN2.1的LDF主要区别如下:
    【全局定义部分】:

    • 波特率固定在10.417Kbps。

    【帧定义部分】:

    • 从节点发布的帧消息第一个字节必须是状态字节,由5bit的应用信息字段(低5位)和3bit的错误字段(高3位)组成。如下图所示:
      12

    • 不允许使用事件触发帧 。

    【节点属性定义部分】:

    • 节点属性不需要N_As_timeout和N_Cr_timeout;
    • NAD的值范围为96到110;
    • 错误响应(Response error)为3bit。

    2.3 LIN2.2/2.2A版本LDF

    13

    上图是S32K1xx的LIN协议栈的介绍,结合LIN2.2A规范的变更介绍可知(1.1.7.6章节),LIN2.2/2.2A只是在LIN2.1的基础上进行了一些拼写修正和澄清。LIN2.2/2.2A版本的LDF文件相比LIN2.1版本的LDF并没有什么区别。

    3. LIN Stack介绍

    目前笔者用过的LIN Stack就两种,一个是S32DS自带的S32K1xx_LIN_Stack,一个NXP官网推荐的S12_LIN_Stack。两个LIN Stack对比情况如下:

    LIN StackS32K1xx_LIN_StackS12_LIN_Stack
    支持的版本LIN1.3,LIN2.0,J2602,LIN2.1,LIN2.2、2.2ALIN2.0,J2602,LIN2.1
    LDF源文件不支持高亮显示和编辑支持高亮显示,可以编辑
    LDF图形配置查错效果更好,但是编辑功能体验较差支持查错和编辑
    协议栈源码开放开放

    查看LDF文件是否有格式错误时,建议使用Processor Expert的LIN组件;如果需要编辑LDF,建议使用S12_LIN_Stack自带的NCF Tools。主要原因是Processor Expert的LIN组件修改LDF的参数时经常卡死,使用体验较差。

    3.1 S08/S12/KEA的LIN Stack

    S12_LIN_Stack支持S08/S12/KEA三个平台,详细介绍参考文章《如何使用S32DS开发KEA系列的LIN功能(一)》

    3.2 S32K1xx的LIN Stack

    S32K1xx的开发环境自带LIN Stack,Processor Expert中有配套的LIN组件(如下图),和S12_LIN_Stack自带的NCF Tool差不多,参考NCF Tool即可。
    14

    3.3 两个LIN stack配置工具的冲突

    在使用上述两款工具时,发现两款工具对LDF文件某些参数的处理有些冲突,下面简单介绍下笔者已经发现的冲突。为了描述方便,Processor Expert中配套的LIN组件简称LIN组件,S12_LIN_Stack自带的NCF Tool简称NCF工具

    1. Message ID:
      LIN组件加载J2602版本的LDF时,会要求加上message ID,NCF工具不需要添加。奇怪的是LIN组件在Message ID文字下面显示“只有LIN2.0支持Message ID”,查阅J2602-1规范中文版,里面又有信息标识符的描述,但是没有LIN2.0描述清晰。
    2. 状态字节:
      LIN组件会检查J2602版本LDF的无条件帧(从节点发布)的第一个字节是否是状态字节,但是NCF工具不会进行检查。查阅J2602-1规范中文版,5.8.6章节描述的要求和LIN工具一致。个人建议编写J2620的LDF时遵循规范。
    3. 产品ID:
      LIN工具对Product ID中的Supplier ID和Function ID的范围定义分别为0 ~ 0x7FFE和0 ~ 0xFFFE,但是LIN工具对其定义的范围都是0 ~ 0xFFFF。查阅LIN2.0规范中文版,2.2.2章节描述的要求和LIN工具一致;查阅LIN2.1和LIN2.2A规范,4.2.1.1章节给出的通配符值分别为0x7FFF和0xFFFF。
    4. 位宽和容忍度:
      LIN工具在J2602版本LDF的主节点定义部分,不需要定义Bit length和Tolerant,但是NCF工具需要定义。查阅J2602-1规范中文版,没有找到这两个参数的定义。

    4.常见导入错误类型

    下面简单介绍一些在支持客户时常见的问题。

    4.1 缺少参数

    1.需要使用NCF工具加载J2602的LDF,但是没有添加Bit length和Tolerant:
    15

    2.节点定义部分没有进行可配置的帧的定义:
    16

    3.LDF更改导致原来的主节点变成从节点,忘记加上响应错误信号:
    17

    4.2 参数格式错误

    1.使用J2602版本的LDF时,状态字节的格式错误:
    18
    在这里插入图片描述

    5.参考资料

    • LIN规范包 版本2.0;
    • SAE J2602-1 2005年9月修订;
    • SAE J2602-2 Issued SEP2005;
    • 瑞萨的《LIN总线入门.pdf》;
    • LIN Specification Package Revision 2.1;
    • LIN Specification Package Revision 2.2A;
    展开全文
  • Blackfin处理器LDF文件指南,帮助大家理解LDF文件的细节
  • sql2008数据库使用mdf文件和ldf文件还原,根据步骤做,很简单
  • 古河大芯径光纤熔接机-s178ldf
  • SQL2008收缩MDF和LDF脚本

    2013-09-27 11:33:39
    sqlserver2008收缩数据的日志文件的语句
  • LDF文件创建 一、摘要 1.描述 2.关键字 二、什么是LDF文件 三、LDF创建环境 四、LDF创建过程 1.软件运行 2.新建LDF文件 3.修改主节点信息 4.修改从节点信息 5.新建描述信号 6.新建信号消息 7.新建报文信息 8.新建...

    一、摘要

    1.描述

    本文主要描述的是汽车行业中如何通过LDFEditor工具去创建LDF文件,本来LDF文件可以通过Vector工具LDF Explorer Pro去创建文件,但是由于需要Licence,我电脑没有权限,无法演示,但是我找到了一个另一个很好使用的工具-LDFEditor,效果是差不多的,操作更为简单。本文主要通过图片的方式去指导用户去创建LDF,创建LDF的过程比较麻烦,所以我写了一个上位机可以直接通过Excel生成LDF文件,但是我们首先要通过工具来创建LDF文件,这样才能更好的理解它的原理和内容。

    2.关键字

    LDF,LDF创建,LDFEditor,CANoe,LDF Explorer Pro,LIN。

    二、什么是LDF文件

    LDF是LIN Description Files的缩写,其代表的是LIN的数据库文件,在这个文件中把LIN通讯的信息定义的非常完整清楚,而LIN网络的通讯就是依据这个文件的描述进行的,所以LIN文件的作用非常强大,正是因为有了它才可以使得整个LIN网路的节点控制器无差错的协同同步开发。

    三、LDF创建环境

    四、LDF创建过程

    1.软件运行

    安装好软件后通过快捷方式运行。
    在这里插入图片描述

    2.新建LDF文件

    打开LDFEditor软件后,点击工具栏”File”下的”New”,此时界面如下图所示。按需求选择模板,点击OK,然后选择保存路径,即完成LDF数据库文件的创建了。
    在这里插入图片描述
    在这里插入图片描述

    3.修改主节点信息

    在新建LDF文件后,软件会默认新建一个主节点信息,对于一个LDF文件,主节点有且只有一个,因为对于一条LIN线上的设备只允许同一时刻只允许一个主节点进行调度,右键点击”Master”中名称选择”Edit”或者双击名称进行信号的修改。
    在这里插入图片描述
    在这里插入图片描述

    4.修改从节点信息

    在新建LDF文件后,软件会默认新建一个从节点信息,对于一个LDF文件,从节点可以允许有多个,右键点击”Slaves”中名称选择”Edit”或者双击名称进行信号的修改,也可以通过右键点击”Slaves”选择”New”进行新建。
    在这里插入图片描述
    在这里插入图片描述

    5.新建描述信号

    右键点击”Codings”,选择”New”新建描述信息,根据通讯矩阵中对于该信号的定义进行设置。
    在这里插入图片描述
    在这里插入图片描述

    6.新建信号消息

    右键点击”Signals”,选择”New”新建信号信息,此时的设置界面如下图所示,这里我们可以设置信号的相关信息,在此可以关联发送节点和接收节点,也可以关联描述信息。
    在这里插入图片描述
    在这里插入图片描述

    7.新建报文信息

    右键”Unconditional Frames”,选择”New”新建报文信息,在这个界面可以关联信号,注意起始位的选择,还有就是发送者要正确选择,否者找不到信号。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    8.新建调度表

    右键”Schedule Table”,选择”New”新建调度表,对于调度表可以新建很多个,可以按照给定的信息进行调度表的增加。
    在这里插入图片描述
    在这里插入图片描述

    9.新建其他信息

    我们常见的消息新建按照上述即可,但是有些信息我们也可以通过该工具进行新建,比如诊断信息等,均可通过该工具进行实现。
    在这里插入图片描述
    在这里插入图片描述

    五、MatrixCreat工具

    这儿我只把链接放上,具体使用说明见后续章节。
    LDF转Excel;LDF转位定义;Excel转LDF;Excel转位定义:https://download.csdn.net/download/weixin_44926112/12670805

    六、其他

    本文主要是讲解LDFEditor工具的使用,有些地方可能会有描述性的错误,希望看到的朋友及时指出,我会及时更正错误,其他地方有些借鉴的描述,写此文章的目的是为了交流,非商业用途,欢迎私信讨论,感谢大家阅读。

    七、参考

    【1】:https://zhuanlan.zhihu.com/p/100560355

    展开全文
  • SQLServer2005 没有日志文件(*.ldf) 只有数据文件(*.mdf) 恢复数据库的方法
  • LIN ldf文件配置

    千次阅读 多人点赞 2020-07-29 13:57:51
    参考瑞萨ldf文件进行理解 //注意:LDF语言要区分大小写的! LIN_description_file; //LIN描述文件 LIN_protocol_version = “2.1”; //LIN协议版本 LIN_language_version = “2.1”; //LIN语言版本 LIN_speed = ...
  • 信号名称 Signal_Name是指定义在数据位信号名称,这个标识符和报文标识符是差不多的,也是唯一的,一般信号名称都是英文的,这个是为了通过这个标识符来生成信号,可用于位定义,LDF文件名称。 10.信号描述 Signal_...
  • ldf-memento-client-源码

    2021-06-20 00:52:34
    链接数据片段客户端 在当今的 Web 上,关联数据以不同的方式发布,包括、和。 我们将每个这样的部分称为集的。... ldf-client命令的参数是: 您要查询的数据集的任何片段,在本例中为 DBpedia。 包含要执行

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,642
精华内容 7,456
关键字:

ldf