CAPL实现UDS下载框架

最新推荐文章于 2024-05-16 20:48:42 发布
最新推荐文章于 2024-05-16 20:48:42 发布
阅读量5.9k 收藏 102
点赞数 6
分类专栏： CANoe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fz835304205/article/details/86087047
版权

最近在做CAPL实现UDS下载，本下载框架可实现配置修改，提高效率。核心代码如下。

includes
{
    #pragma library (".\Exec32\MMSound.dll")
    #pragma library (".\Exec32\osek_tp.dll")
}

variables
{
    long physHandle;
    long cantpHandle;

    char rspEvent[18] = "Diag Receved!";
    byte rspData[100];
    dword rspLen = 0;
    
    const dword physTx = 0x705;
    const dword funcTx = 0x7DF;
    const dword respRx = 0x785;
    
    const byte repeatSend = 1;
    const byte cantpPadding = 0xAA;


    struct fileInfo
    {
        long fileHandle;
        char filePath[512];
        dword maxAddr;
        dword minAddr;
        dword segNum;
        dword segAddr[20];
        dword segLen[20];
        dword segOffset[20];
        byte segData[1 * 1024 * 1024];
    };
    
    struct reqPDU
    {
        byte addrMode;
        long prevFunc;
        char pduInfo[50];
        char reqDataString[80];
        char rspDataString[80];
        long postFunc;
    };

    struct fileInfo file;
    
    enum funcDef
    {
        REQUEST_SEED_POST = 0,
        SEND_KEY_PREV,
        TRANS_DATA_DRIVER_PREV,
        CHECK_DRIVER_PREV,
        REQUEST_DOWN_APP_POST,
        TRANS_DATA_APP_PREV,
        CHECK_APP_PREV  
    };
    
    struct reqPDU reqPduList[20] = 
    {
        {
            addrMode = 'F',
            prevFunc = 0,
            pduInfo = "To ExtSession...",
            reqDataString = "10 03 ",
            rspDataString = "50 ",
            postFunc = 0
        },
        {
            addrMode = 'F',
            prevFunc = 0,
            pduInfo = "DTCSetting=off...",
            reqDataString = "85 02 ",
            rspDataString = "C5 "
        },
        {
            addrMode = 'F',
            prevFunc = 0,
            pduInfo = "DisableCommunicat...",
            reqDataString = "28 01 01 ",
            rspDataString = "68 ",
            postFunc = 0
        },
        {
            addrMode = 'P',
            prevFunc = 0,
            pduInfo = "To ProgrammingSession...",
            reqDataString = "10 02 ",
            rspDataString = "50 ",
            postFunc = 0
        },
        {
            addrMode = 'P',
            prevFunc = 0,
            pduInfo = "RequestSeed...",
            reqDataString = "27 11 ",
            rspDataString = "67 ",
            postFunc = REQUEST_SEED_POST
        },
        {

            addrMode = 'P',
            prevFunc = SEND_KEY_PREV,
            pduInfo = "SendKey...",
            reqDataString = "27 12 00 00 00 00 ",
            rspDataString = "67 ",
            postFunc = 0
        },
        {
            addrMode = 'P',
            prevFunc = 0,
            pduInfo = "RequestDownloadFlashDriver...",
            reqDataString = "34 00 44 00 00 04 00 00 00 00 40 ",
            rspDataString = "74 "
        },
        {
            addrMode = 'P',
            prevFunc = TRANS_DATA_DRIVER_PREV,
            pduInfo = "TransferData...",
            reqDataString = "36 01 FF FF ",
            rspDataString = "76 ",
            postFunc = 0
        },
        {
            addrMode = 'P',
            prevFunc = 0,
            pduInfo = "TransferExit...",
            reqDataString = "37 ",
            rspDataString = "77 ",
            postFunc = 0
        },
        {
            addrMode = 'P',
            prevFunc = CHECK_DRIVER_PREV,
            pduInfo = "CheckRoutine...",
            reqDataString = "31 01 02 02 00 00 00 00",
            rspDataString = "71 ",
            postFunc = 0
        },
        {
            addrMode = 'P',
            prevFunc = 0,
            pduInfo = "EraseMemory...",
            reqDataString = "31 01 FF 00 44 00 3E 80 00 00 01 70 00 ",
            rspDataString = "71 "
        },
        {
            addrMode = 'P',
            prevFunc = 0,
            pduInfo = "HardReset...",
            reqDataString = "11 01 ",
            rspDataString = "51 ",
            postFunc = 0
        },
        {
            addrMode = 'F',
            prevFunc = 0,
            pduInfo = "To ExtSession...",
            reqDataString = "10 03 ",
            rspDataString = "",
            postFunc = 0
        },
        {
            addrMode = 'F',
            prevFunc = 0,
            pduInfo = "EnableCommunicat...",
            reqDataString = "28 00 01 ",
            rspDataString = "",
            postFunc = 0
        },
        {
            addrMode = 'F',
            prevFunc = 0,
            pduInfo = "DTCSetting=on...",
            reqDataString = "85 01 ",
            rspDataString = "",
            postFunc = 0
        },
        {
            addrMode = 'F',
            prevFunc = 0,
            pduInfo = "To DefSession...",
            reqDataString = "10 01 ",
            rspDataString = "",
            postFunc = 0
        }
    };
    
    byte driverdata[100] = 
	{
		
	};
    
    
}

dword crc32(byte data[], dword len)
{
	return crc ;
}

int userMemCmp(byte cs[], byte ct[], dword count)
{
    dword i;
    int ret;
    
    ret = 0;
    for(i = 0; i < count; i++)
        if((ret = cs[i]-ct[i]) != 0)
            break;
        
    return ret;    
}

void DownAppProcess(void)
{
    byte i;
    long result, replyOk;
    char info[80];
    byte reqData[1024+16];
    dword reqLen, sendLen;
    byte seedArray[4], keyArray[4];
    dword crc;
    dword maxSize;
    dword seqNo, offset;
    dword expertLen;
    byte expertData[20];
    
    @Pannel::ProgressBarPos = 0;
    
    maxSize = 1024;
    seqNo = 0;
    crc = 0;
    offset = 0;
    expertLen = 0;
    
    cantpHandle = CanTpCreateConnection(0);    // 0 = Normal mode
    CanTpSetTxIdentifier(cantpHandle, physTx);  // Tx CAN-ID
    CanTpSetRxIdentifier(cantpHandle, respRx);  // Rx CAN-ID
    CanTpSetPadding(cantpHandle, cantpPadding);

    
    for(i = 0; i < 25; i++)
    {
        strncpy(info, reqPduList[i].pduInfo, elCount(reqPduList[i].pduInfo));
        strncat(info, "start", elCount(info)-1);
        write(info);
        
        reqLen = str2data(reqPduList[i].reqDataString, reqData);
        
        // prev data process
        switch(reqPduList[i].prevFunc)
        {
            case SEND_KEY_PREV:
                getKey(0x11, seedArray, keyArray);

    			reqData[2] = keyArray[0];
    			reqData[3] = keyArray[1];
    			reqData[4] = keyArray[2];
    			reqData[5] = keyArray[3];
    			reqLen = 6;
                break;
            case TRANS_DATA_DRIVER_PREV:
    			
                reqLen = elCount(driverdata);
                break;
            case CHECK_DRIVER_PREV:		
    			crc = crc32(driverdata, elCount(driverdata));
    			//string2byte(cmd, cmddata, &cmdlen);
    			reqData[0] = 0x31;
    			reqData[1] = 0x01;
    			reqData[2] = 0x02;
    			reqData[3] = 0x02;
    			reqData[4] = crc>>24;
    			reqData[5] = crc>>16;
    			reqData[6] = crc>>8;
    			reqData[7] = crc;
    			reqLen = 8;
                break;
            case TRANS_DATA_APP_PREV:
    			reqLen = file.maxAddr-file.minAddr+1;
                break;
            case CHECK_APP_PREV:		
    			crc = crc32(file.segData, (file.maxAddr-file.minAddr+1));
                
    			reqData[0] = 0x31;
    			reqData[1] = 0x01;
    			reqData[2] = 0x02;
    			reqData[3] = 0x02;
    			reqData[4] = crc>>24;
    			reqData[5] = crc>>16;
    			reqData[6] = crc>>8;
    			reqData[7] = crc;
    			reqLen = 8;
                break;
            default:
                break;
        }
        
        seqNo = 1;
        while(reqLen > 0)
        {
            if(reqLen >= maxSize)
            {
                sendLen = maxSize;
            }
            else
            {
                sendLen = reqLen;
            }
            
            if(reqPduList[i].prevFunc == TRANS_DATA_DRIVER_PREV)
            {
                reqData[0] = 0x36;
    			reqData[1] = 0x01;
    			memcpy_off(reqData, 2, driverdata, 0, elCount(driverdata));
                result = CanTpTransmit(reqPduList[i].addrMode, reqData, sendLen+2, 500, 5000);
                if(repeatSend == 1 && result == 0) // timeout repeat send
                {
                    testwaitfortimeout(50);
                    result = CanTpTransmit(reqPduList[i].addrMode, reqData, sendLen+2, 500, 5000);
                }
            }
            else if(reqPduList[i].prevFunc == TRANS_DATA_APP_PREV)
            {
                reqData[0] = 0x36;
			    reqData[1] = seqNo++;
                memcpy_off(reqData, 2, file.segData, offset, sendLen);
                result = CanTpTransmit(reqPduList[i].addrMode, reqData, sendLen+2, 500, 5000);
                if(repeatSend == 1 && result == 0)
                {
                    testwaitfortimeout(50);
                    result = CanTpTransmit(reqPduList[i].addrMode, reqData, sendLen+2, 500, 5000);
                }
                offset += sendLen;
            }
            else
            {
                result = CanTpTransmit(reqPduList[i].addrMode, reqData, sendLen, 500, 5000);
                if(repeatSend == 1 && result == 0) // timeout repeat send
                {
                    testwaitfortimeout(50);
                    result = CanTpTransmit(reqPduList[i].addrMode, reqData, sendLen, 500, 5000);
                }
            }
            if(@Pannel::ProgressBarPos < 150)
            {
                @Pannel::ProgressBarPos = @Pannel::ProgressBarPos+1;
            }
            
            expertLen = str2data(reqPduList[i].rspDataString, expertData);
            if((rspLen >= expertLen) && userMemCmp(expertData, rspData, expertLen) == 0)
            {
            }
            else
            {
                //strncpy(info, reqPduList[i].pduInfo, elCount(reqPduList[i].pduInfo));
                //strncat(info, "-------------err--------------", elCount(info)-1);
                //write(info);
                write("-------------err--------------");
                SysSetVariableString(sysvar::Pannel::Info, "-------------ERROR--------------");
                //mmsndPlay("track03.mp3", 5000);
                {
                    char SoundFilesPath[256];
                    int kStringLen  = 256;
                    
                    getAbsFilePath("", SoundFilesPath, kStringLen);
                    mmsndSetMediaPath(SoundFilesPath);
                    mmsndPlay("track03.mp3", 0);
                }
                        
                return;   
            }
            
            reqLen -= sendLen;
        }
        
        // post data process
        switch(reqPduList[i].prevFunc)
        {
            case REQUEST_SEED_POST:
                seedArray[0] = rspData[2];
    			seedArray[1] = rspData[3];
    			seedArray[2] = rspData[4];
    			seedArray[3] = rspData[5];
                break;
            case REQUEST_DOWN_APP_POST:
                maxSize = (rspData[2] << 8) + rspData[3] - 2;
                break;
            default:
                break;
        }
        
        strncpy(info, reqPduList[i].pduInfo, elCount(reqPduList[i].pduInfo));
        strncat(info, "end", elCount(info)-1);
        write(info);
        
        testwaitfortimeout(500);
    }
    
    @Pannel::ProgressBarPos = 150;
    SysSetVariableString(sysvar::Pannel::Info, "-------------SUCCESS--------------");
}



void CanTp_ReceptionInd(long connHandle, byte data[])
{
    //write("Recv handle %d, data %x", connHandle, data[0]);
    memcpy(rspData, data, elCount(data));
    rspLen = elCount(data);

    TestSupplyTextEvent(rspEvent);
}

CanTp_ErrorInd( long connHandle, long error)
{

}

long CanTpTransmit(byte addrMode, byte reqData[], dword reqLen, long timeOut, long timeOutPending)
{
    byte data[20], data2[20];
    long ret, result, pending;

    rspLen = 0;
    
    if(addrMode == 'P')
    {
        CanTpSetTxIdentifier(cantpHandle, physTx);
    }
    else
    {
        CanTpSetTxIdentifier(cantpHandle, funcTx);
    }
    testWaitForTimeout(20);
    
    CanTpSendData(cantpHandle, reqData, reqLen);

    pending = 0;
    do
    {
        result = testWaitForTextEvent(rspEvent, timeOut);
        if(result == 0) // Resume due to timeout
        {
            ret = result;
            rspLen = 0;
            break;
        }
        else // Resume due to event occurred
        {
            if(rspLen == 3 && rspData[0] == 0x7F && rspData[1] == reqData[0] && rspData[2] == 0x78)
            {
                timeOut = timeOutPending;
                rspLen = 0;
                continue;
            }
            else
            {
                ret = result;
                break;
            }
        }
    }while(1);

    return ret;
}

 

fz835304205
关注
  • 6
    点赞
  • 踩
  • 102
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
一个简单而完整的UDS例子.rar_UDS下载例程_fluent_uds_uds 程序刷写_uds程序
07-14
fluent UDS的一段程序，可以照着这个自学UDS，很好用
UDS 诊断教程（七）
m0_64673164的博客
03-28 200
如果前面的 36 服务没有执行完成，以我前面举的例子来说，比如这个数据块有 50 个字节，但是 tester只发了两次 36 服务传了 36 个字节，那么这次传输对于 ECU 来说是失败的，所以 ECU 应该给出 NRC 0x7F 37 24，表示诊断序列执行有错误。下图是数据下载的简略过程，用到了 34，36，37 这三个服务，如果是上传的话，34 服务被 35 服务替换，数据传输方向变一下，就可以了。如果 34 服务得到了正确响应，tester 就要启动数据传输过程了，使用的就是 36 服务。
CAPL实现UDS下载框架_capl 下载服务
最新发布
2401_85012481的博客
05-16 340
【代码】CAPL实现UDS下载框架_capl 下载服务。
CAPL内置的与Struct Byte有关函数
phoenix_wangxd的博客
04-30 760
CAPL内置的与Struct Byte有关函数
vector canoe demo 12.0 官方网址
兵合的博客
09-23 6301
vector canoe demo 12.0 学习使用 可以通过官网获取license 官方链接： https://www.vector.com/cn/zh/download/?tx_vectorproducts_productdownloaddetail%5Bdownload%5D=43240&tx_vectorproducts_productdownloaddetail%5Bac...
【车载开发系列】UDS诊断---请求下载（$0x34）
千月星跡
12-16 904
【车载开发系列】UDS诊断—请求下载（$0x34） UDS诊断---请求下载（$0x34）【车载开发系列】UDS诊断---请求下载（$0x34）一.概念定义二.产生背景三.报文格式1）请求报文2）肯定响应3）否定响应 一.概念定义 请求下载就是RequestDownload（34h）。也是一个比较常用的服务。 诊断工具使用此服务初始化从诊断工具到ECU的数据传输（下载）。 接收到此服务的请求报文时，ECU应在发送肯定响应报文前，采取所有必要动作用于数据接收。 二.产生背景 车ECU中用于缓存诊断服务数据的缓
CAPL学习之路-CAN TP层函数介绍
jasonj333
02-22 2980
如果想使用CAN TP层函数，首先需要在网络节点或测试节点配置页面的Componets组件一栏添加osek_tp.dll文件。路径为：C:\Program Files\Vector CANoe 15\Exec32至于节点的CAPL程序内需不需要引用这个dll文件，无所谓，可写可不写。但是如果是其他dll，必须在CAPL程序中引用。为什么osek_tp.dll可以添加到节点配置页面，而不必在CAPL中引用？
CAPL编写的基于UDS的bootloader
03-29
基于UDS协议的CAN booloader，用CAPL编写，可以直接下载BIN文件，目标平台是S12G192，可以修改后支持S19。
基于CAPL调用共享库解决UDS诊断中的安全解锁方式.docx
01-17
基于CAPL调用共享库解决UDS诊断中的安全解锁方式，CANoe 11版本，已验证。 生成capl.dll的工程模板在我们安装CANoe时就自动生成安装了，以Win 10系统、11.0版本的CANoe为例。 代码调用如下，该函数来自于capl.dll...
capl诊断测试脚本生成
09-26
CAPL（CAN Application Programming Language）是一种由Vector Informatik GmbH开发的编程语言，主要...通过理解CAPL语法和Excel转换机制，工程师可以构建出强大的诊断测试框架，确保汽车电子系统的可靠性和稳定性。
capl实现crc校验码计算.txt
03-23
capl实现crc校验码计算
capl实现crc校验码计算.rar
03-23
5. 编程实现：在CAPL中，你可以编写一个函数或一个脚本来实现CRC计算。这个函数接受原始数据作为参数，内部执行上述计算流程，最后返回CRC校验码。 6. 验证与测试：为了确保CRC计算的正确性，通常需要编写测试用例...
关于CAPL中对dll的调用操作
星Yeah 的博客
10-26 4843
转自：https://blog.csdn.net/weixin_44536482/article/details/93911832 关于CAPL中对dll的调用操作 1、操作步骤2、示例 1、操作步骤         在CANoe中对节点的编程是通过CAPL(Communication Access Programming Laguage)语言进行的。但如果是我们之前已经完成的功能模块，并且想在CAPL中进行调用时
QML笔记(八)之.pragma library
我是黄同学博客
05-13 671
一.前言 楼主在学习QML调用js过程中，用Qt新建了一个js文件，在其中发现了头部.pragma library这个，一开始没在意这个，后续尝试注释了一下，发现了不一样效果，于是做个记录 二.区别 1.文字描述 不加.pragma library：js文件可以直接访问qml中的控件id，从而对控件属性进行操作 加.pragma library：js函数无法直接使用控件id，只能在qml调用函数的的时候将id作为参数传入，从而进行操作控件属性 2.代码体现 2.1不加.pragma library //.p
基于CANoe的ECU Bootloader刷写软件
热门推荐
02-23 2万+
目标：         车辆ECU需要更新软件，通过OBD口实现，通过CAN总线实现，编程语言是CAPL。         刷写流程基于ISO15765-3；应用层基于UDS（ISO14229）诊断协议；TP层基于ISO15765-2；数据链路层和物理层基于ISO11898 实现：        1.图形用户界面使用CANoe自带的panel来实现，用户可以选取刷写文件，ECU的地址等信息
CANalyzer及CANOE使用二：基于UDS的Panel界面及使用Capl编写BootLoader自动化刷写流程（多文件or多段下载）
qq_36407982的博客
10-17 1万+
前言 Panel界面 控件使用 文件解析 下载流程 ———————————————— 前言 应朋友问题：之前已看过CANOE用报告形式设计bootloader自动化测试（地址https://editor.csdn.net/md/?articleId=107610153）。那我要是没CANOE岂不是刷不了，那能否用CANalyzer及CANOE创建Network Node的方法来设计bootloader？两者有什么不同? 我：不同之处太多了，前者可列详细步骤函数，有延时函数，可以出报告；后者没有。相信很多.
零基础学习CANoe Panel（12）—— 进度条（Progress Bar）
蚂蚁小兵
07-24 1125
进度条
如何使用OSEK_TP.dll
qq_25920091的博客
05-08 2339
【代码】如何使用OSEK_TP.dll。
capl实现uds刷写
05-31
CAPL 是矢量公司开发的一种脚本语言，主要用于 CAN 和 LIN 网络的测试和仿真。在实现 UDS 刷写时，可以通过 CAPL 脚本与 UDS 协议栈进行交互，实现数据的收发和处理。以下是一个简单的 CAPL 脚本示例，用于发送 UDS 诊断请求并接收响应： ```c variables { message UDS_Request; // UDS 诊断请求消息 message UDS_Response; // UDS 诊断响应消息 dword address = 0x12345678; // 要刷写的地址 dword data = 0x11223344; // 要写入的数据 } on start { // 初始化 CAN 通道 setCanChannel(1); setBaudrate(500000); setCanBusOutputControl(1); // 初始化 UDS 协议栈 UDS_Init(); } on timer event { // 构造 UDS 诊断请求消息 UDS_Request.ID = 0x7E8; UDS_Request.Data(0) = 0x22; // 诊断服务 ID UDS_Request.Data(1) = address >> 24; // 地址高位 UDS_Request.Data(2) = address >> 16; // 地址次高位 UDS_Request.Data(3) = address >> 8; // 地址次低位 UDS_Request.Data(4) = address; // 地址低位 UDS_Request.Data(5) = data >> 24; // 数据高位 UDS_Request.Data(6) = data >> 16; // 数据次高位 UDS_Request.Data(7) = data >> 8; // 数据次低位 UDS_Request.Data(8) = data; // 数据低位 UDS_Request.len = 9; // 发送 UDS 诊断请求消息 output(Uds_Request); // 等待 UDS 诊断响应消息 while(!Uds_Response.valid) delay(10); // 处理 UDS 诊断响应消息 if(Uds_Response.Data(0) == 0x62) // 诊断响应 ID { if(Uds_Response.Data(1) == 0x22) // 诊断服务 ID { if(Uds_Response.Data(2) == 0x00) // 响应报文子函数 ID { // UDS 诊断请求成功，可以进行下一步操作 // ... } else { // UDS 诊断请求失败，处理错误码 // ... } } else { // UDS 诊断请求失败，处理错误码 // ... } } } ``` 该示例中，通过定时器事件周期性发送 UDS 诊断请求消息，并等待 UDS 诊断响应消息。在接收到响应消息后，根据响应数据判断 UDS 诊断请求是否成功，如果成功则可以进行下一步操作，否则需要处理错误码。需要注意的是，该示例仅用于演示 UDS 刷写的基本流程，实际应用中需要根据具体需求进行修改和完善。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值