c# wpf document viewer pdf : Delete page from pdf document Library SDK component .net wpf winforms mvc AN-IND-1-011_Using_CANoe_NET_API1-part176

Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
11 
Contact Information:   www.vector.com   or +49-711-80 670-0 
Test units do not contain the Vector.CANoe.TFS.dll but the Vector.CANoe.TFS.ITE.dll. 
Do not use Vector.CANoe.TFS in test units. 
Do not use Vector.CANoe.TFS.ITE in test modules. 
4.4  Additional Information and CANoe Examples 
For a complete description of the API, including short code examples, please refer to: .NET API 
functional description in the online help of CANoe. More details to configuration settings etc. can also 
be found in the online help. A complete test module implemented in C# is available in the Demo 
directory of the CANoe installation (Start menu/Programs/CANoe/Demos/More demos/CANoe .CAN – 
Central Locking System .NET). 
5.0  Programming with the CANoe .NET API 
5.1  Common Features 
5.1.1  Signals (bus signals, environment and system variables) 
Signal types in .NET always mean bus signals, environment variables and system variables. These 
types are handled exactly in the same way. So each construct that works for one of these types does 
also work for the others. 
Signal values can be accessed through the Value property, e.g. <signal name>
.Value
.  
LockState.Value = 1; 
In the signal-based view CAN, LIN and FlexRay bus signals are supported.  
Note that setting the value usually doesn't change the value directly; in case of signals, the current 
value is only changed after a message which contains the signal has been transmitted on the bus and 
received again. 
Environment variables can be handled in the same way, e.g. 
MyIntegerEv.Value = 1; 
In case the environment variable is a data array type you can easily read each byte with the index 
operator: 
if (MyDataEv.Value[2] == 2) {…} 
When assigning values you need to proceed as follows: 
Byte[] tmp = MyDataEv.Value; 
tmp[2] = 2; 
MyDataEv.Value = tmp; 
Easy support of resuing signal functionality can be realized by Generics. 
public void SetSignal<T>(Double d) where T : class, IRuntimeValue 
RuntimeObject<T>.Value = d; 
This function can be applied for all types of signals: SetSignal<LockState>(1); 
Delete page from pdf document - Library SDK component:C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use C# Code to Extract PDF Pages, Copy Pages from One PDF File and Paste into Others
www.rasteredge.com
Delete page from pdf document - Library SDK component:VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Detailed VB.NET Guide for Extracting Pages from Microsoft PDF Doc
www.rasteredge.com
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
12 
Contact Information:   www.vector.com   or +49-711-80 670-0 
It is also possible to dynamically create a signal object when its name is known. Here is an example 
how to create a system variable object (namespace = ‘Tester’ and variable name = ‘Enabled’) and to 
modify its value: 
DynamicSystemVariable var = new DynamicSystemVariable("Tester", "Enabled"); 
var.Value = 1; 
5.1.2  Messages 
In the message-based view CAN messages are supported in a first step. For the CAN frames that are 
defined in databases, specific classes are generated in type libraries. 
To construct a user-defined CAN message which is not defined in a database (e.g. dbc), the class 
CANFrame can be used as a super class. Signals are defined with the 
[Signal]
attribute. Their offset 
and the least significant bit of the signal are as a bit number. Signal overlap etc will be checked at 
compile time. 
class myMessage : CANFrame 
[Signal(LSB = 0, BitCount = 2)] 
 public UInt32 mySignal; 
myMessage msg = new myMessage(0x42,8); 
msg.Send(); 
CAN messages can also be declared by creating instances of the 
CANFrame
class and initializing the 
ID and DLC in the constructor. Message data can only be set in raw format, either byte-wise using the 
property 
Bytes[]
or by a byte array which must be of size 8 bytes min: 
byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; 
CANFrame msg = new CANFrame(0x500, 4); // ID=0x500, DLC=4 
msg.SetRawData(data); 
msg.Send(); 
To implement different send models CANoe is able to use so-called interaction layers realized by 
DLLs. OEMs often use specific interaction layers but there is also a generic Vector Interaction Layer 
available. If an interaction layer is used in the CANoe configuration, it is sufficient to set signal values 
without having to send messages explicitly – messages will be sent according to the correct send 
model by CANoe (e.g. cyclic messages will be sent automatically according to the required cycle time 
and sending mode). 
Note that message objects in the configured databases are always created in a subordinate 
namespace called 
Frames
to prevent possible conflicts with signal classes. Access to e.g. message 
VehicleMotion is accomplished through 
NetworkDB.Frames.VehicleMotion
. 
5.1.3  Timer 
The attribute 
[OnTimer]
can be used to accomplish a cyclic timer. The method will be executed 
cyclically at the defined time point (here 1s). 
For test modules the timer is active when the test module is active and for simulation nodes it is active 
during measurement. 
[OnTimer(1000))] 
public void OnTimer1s() { 
Output.Writeline("Timer elapsed"); 
Library SDK component:VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
VB.NET PDF - How to Delete PDF Document Page in VB.NET. This page is aimed to help you learn how to delete page from your PDF document in VB.NET application.
www.rasteredge.com
Library SDK component:C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
C#.NET PDF Library - Delete PDF Document Page in C#.NET. Provide C# Users in C#.NET. How to delete a single page from a PDF document.
www.rasteredge.com
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
13 
Contact Information:   www.vector.com   or +49-711-80 670-0 
If a timer should be started and stopped at a certain point, timer objects can be used instead. Use the 
Timer
class and its properties/methods, e.g. define a timer handler: 
Timer t = new Timer(new TimeSpan(0, 0, 0, 0, 250),TimerHandler); 
t.Start(); 
… 
t.Stop(); 
public void TimerHandler(Object o, ElapsedEventArgs e) 
Report.TestCaseComment("Timer event"); 
5.1.4  Event Procedures 
Event procedures of the main class are static, i.e. automatically activated and deactivated by CANoe. 
Event procedures in other classes can be dynamically activated and deactivated by using the class 
Vector.CANoe.Runtime.DynamicHandlers
. Attributes are used to create event procedures.  
For test modules the event handlers are active when the test module is active and for simulation 
nodes they are active during measurement. 
A handler that reacts on value changes of the network signal LockState is defined like this: 
[OnChange(typeof(LockState))] 
public void OnSignalLockState() {  
double value = LockState.Value; 
The .NET signal-oriented API only supports ‘on change’ handlers in contrast to CAPL that supports 
both ‘on change’ and ‘on update’ handlers. One reason is the performance aspect in .NET programs. 
Another reason is that the signal based tests are state-based.  
In contrast to this message handlers (introduced with version 7.1) are event-based. To handle a 
message event for message WindowState use the
[OnCANFrame] 
attribute. The CAN channel and 
message ID can also be specified in the attribute constructor. 
[OnCANFrame] 
public void onMessage(NetworkDB.Frames.WindowState frame) {  
double pos = frame.WindowPosition.Value; 
[OnCANFrame(1, 500)] 
public void Frame500Received(CANFrame frame) {…} 
Use the attribute 
[OnKey]
to react on key events. The defined method must have one 
char
parameter. 
[OnKey('+'))] 
public void OnKeyPressed(char ch) {  
Output.WriteLine("+ was pressed");  
To handle timer events the 
[OnTimer]
attribute should be used. The method 
TimerElapsed
below will 
be called every 500 ms: 
[OnTimer(500))]  
public void TimerElapsed() {  
msg.Send();  
Library SDK component:C# PDF Page Insert Library: insert pages into PDF file in C#.net
page processing functions, such as how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C# .NET, how to
www.rasteredge.com
Library SDK component:C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Page Process. File: Merge, Append PDF Files. File: Split PDF Document. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page: Delete Existing
www.rasteredge.com
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
14 
Contact Information:   www.vector.com   or +49-711-80 670-0 
The module can also react on system variable changes: 
[OnChange(typeof(MyNameSpace.MyInt))] 
public void MyIntHandler() 
MyNameSpace.MyInt2.Value = MyNameSpace.MyInt.Value; 
5.2  Test Features 
5.2.1  Test Module Types 
There are two different kinds of test modules: 
Unstructured test modules 
The sequence of test cases and groups will be displayed and completed during execution of the 
test module. It is not possible to enable individual test cases or groups. 
Structured test modules 
These modules have great advantages in comparison to unstructured modules because their 
structure is shown in the test execution dialog directly after compilation and they can be enabled 
or disabled before test execution. 
Both module types are very similar and their format is described in the following chapters. 
Unstructured test modules 
An unstructured.NET test module must inherit from class 
Vector.CANoe.TFS.TestModule.
It consists 
primarily of the 
Main
method where the test control flow and the test cases are executed. Test groups 
can be used to organize test cases that belong together. Test cases are defined with the custom 
attribute 
[TestCase]
and can be divided into test steps. The 
Vector.CANoe.TFS.Report
class is 
used for reporting to the report file. 
The 
Main 
method of the test module is the main program of the test module analog to a CAPL test 
module. It is required to override the inherited 
Main
method of the 
TestModule class
. The 
main
method groups test cases and executes them sequentially:  
public class MyTestModule : TestModule 
public override void Main()  
TestGroupBegin("Id", "Title", "Description"); 
TestCase1();  
if (TestModule.VerdictLastTestCase == Verdict.Passed) 
 TestCase2();  
TestCase3();       
TestGroupEnd();  
[TestCase("Test case title")] 
public void TestCase1() 
Report.TestStep("Description of the test step"); 
The 
Main
method should only contain test flow control. The concrete tests should be done in the test 
cases. Complex flow logic can be implemented, e.g. letting a test case execute multiple times by 
calling it in a loop or prevent execution of a test case if a preceding test case returned failure. 
In general test cases should be programmed such that they don’t depend on each other, e.g. by not 
using global variables between test cases. It is recommended to start every test case from anew; 
Library SDK component:VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document in VB.NET Program. DLLs for Adding Page into PDF Document in VB.NET Class.
www.rasteredge.com
Library SDK component:VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
document. If you find certain page in your PDF document is unnecessary, you may want to delete this page directly. Moreover, when
www.rasteredge.com
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
15 
Contact Information:   www.vector.com   or +49-711-80 670-0 
initialize parameters before test case start and – if needed – reset parameters after test case end. This 
ensures good programming practice and possible code re-use (which is one of the main motivations 
for the .NET API). 
Event procedures are only active during test module run-time since test modules need not always be 
active during the whole measurement time (see also AN-IND-1-002 Testing with CANoe). 
Structured test modules 
A structured.NET test module must inherit from class 
Vector.CANoe.TFS.StructuredTestModule.
The 
StructuredMain 
method of the test module is the main program and it is required to override the 
inherited 
StructuredMain
method of the 
StructuredTestModule class
.  
It is required that dynamic test sequences (test sequences that may vary between two test runs) are 
encapsulated with methods that are marked with the [TestGroup] attribute. A dynamic test group will 
always be executed as a whole. 
The example shows a DynamicTestGroup() and a normal test group with two test cases.  
public class MyTestModule : StructuredTestModule 
public override void StructuredMain()  
    
DynamicTestGroup(); 
TestGroupBegin("Id", "Title", "Description"); 
TestCase1(); 
TestCase3();       
TestGroupEnd();  } 
[TestCase("Test case title")] 
public void TestCase1() 
Report.TestStep("Description of the test step"); 
… 
[TestGroup(“Dynamic Test case sequence”,” depends on preceding test case results”)] 
public void DynamicTestGroup() 
TestCase1(); 
if (TestModule.VerdictLastTestCase == Verdict.Passed) 
 TestCase2(); 
// … 
The 
StructuredMain
method should define the test sequence only. The concrete tests should be 
done in the test cases and test groups.  
Event procedures are only active during test module execution (see also AN-IND-1-002 Testing with 
CANoe). 
Library SDK component:C# PDF metadata Library: add, remove, update PDF metadata in C#.
C#.NET PDF SDK - Edit PDF Document Metadata in C#.NET. Allow C# Developers to Read, Add, Edit, Update and Delete PDF Metadata in .NET Project.
www.rasteredge.com
Library SDK component:VB.NET PDF delete text library: delete, remove text from PDF file
187.0F) Dim aChar As PDFTextCharacter = textMgr.SelectChar(page, cursor) ' delete a selected As String = Program.RootPath + "\\" output.pdf" doc.Save
www.rasteredge.com
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
16 
Contact Information:   www.vector.com   or +49-711-80 670-0 
Note to structured test modules: 
The test module structure analysis is done by tentatively running the test module in a special 
CANoe mode. During this execution the test case and dynamic test group bodies are skipped.  
The special CANoe mode does not allow accessing runtime values and invoking methods from 
Vector.CANoe.Runtime, Vector.Tools, Vector.Scripting.UI, 
Vector.CANoe.Threading and most of the methods in Vector.CANoe.TFS. For this they 
cannot be called in the StructredMain() method. 
It is not allowed to call CAPL test cases or test functions in the StructuredMain() method. 
The execution sequence of the test cases in the module must be constant, e.g. a random 
execution of test cases is not allowed and may lead to unexpected enabling / disabling states of 
the test cases.  
If you have a set of test cases that are randomly executed or that depend on the test verdicts 
from other test cases you should encapsulate them in a method that is marked with a 
[TestGroup] attribute. The body of such a method is also not executed during test module 
analysis and the group can only be enabled / disabled as a whole. An example for this can be 
found in the Central Locking Demo .NET of CANoe. 
5.2.2  Reporting Commands 
The report class allows detailed reporting of test results and test execution steps. The most important 
methods are listed here.  
Informative: 
Report.TestCaseComment(…) Some additional information that will be written to the report. 
Report.TestStep(…)  
Separates the test execution into test steps. 
TestCaseTitle(..) 
Modifies the test case title. 
Verdict handling: 
TestStepFail(…)  
The teststep verdict will be set to ‘Fail’ and it is propageted to 
the related test case and test module verdict. 
TestStepPass(…)  
A passed test step with additional information is written to the 
report. The verdict is not changed. 
TestStepWarning(…)  
A warning is written to the report.  
A complete list can be found in the CANoe help or in the type libraries that are referenced in your test 
module solution. 
5.2.3  Wait Points 
Typically stimuli for the SUT are generated within the test case followed by waiting for the reactions. 
The sequential execution of a test module can be interrupted by so-called wait points. The principle of 
wait points is that they return flow control back to CANoe and do not resume processing until the 
specified event occurs (e.g. a signal value change, a message reception, or a timeout). For more 
details on the execution principle for a test module with wait points, please refer to AN-IND-1-002 
Testing with CANoe. 
There are wait points for simple timeouts, for dedicated values of bus or I/O signals, messages, for 
fulfillment of user-defined (complex) system condition, user interaction, etc. . The wait point is 
accomplished by using a 
Wait
method of the 
Execution
class: 
Simple timeout: 
Execution.Wait(50); 
Bus signal:     
Execution.Wait<EngineRunning>(1); 
System variable:
Execution.Wait<SystemUnderTest.OperationMode>(2); 
Environment variable:  Execution.Wait<EnvDoorLocked>(EnvDoorLocked.Locked); 
Message: 
Execution.WaitForCANFrame(ref frame, 500); 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
17 
Contact Information:   www.vector.com   or +49-711-80 670-0 
The signal-oriented API in .NET is state-oriented. This means that if a wait point for a signal element is 
used the wait condition is checked immediately and if the signal is already set (i.e. the condition is 
met), the wait point also resumes immediately.    
In contrast to the signal-oriented approach in .NET message-oriented approach is event-based. 
More wait points are contained in the API. Please check the online help for further details. 
5.2.4  Checks 
Checks in .NET test modules are used to monitor certain system conditions during a test sequence. 
There are three types of checks; ConstraintsConditions and additionally Observations. 
Constraints are used to guarantee that the environment fulfills certain criteria and Conditions 
supervise the behavior of the tested system. Any violation of these checks leads to a failing test case 
and test module. 
This is in contrast to Observations that cannot influence the verdict of a test module even though 
violations are always included in the test report.  
Checks can be active during a complete test sequence, a complete test case, or they can be 
activated/deactivated using method calls. 
The TFS provides several predefined checks 
Vector.CANoe.TFS.ValueCheck is used to monitor the value criteria of bus signals, environment 
and system variables  
Vector.CANoe.TFS.AbsoluteCycleTimeCheck, Vector.CANoe.TFS.RelativeCycleTimeCheck and 
Vector.CANoe.TFS.OccurenceTimeCheck check the timing of messages 
Vector.CANoe.TFS.DlcCheck monitors the message length indication 
and the possibility to define custom checks: 
Vector.CANoe.TFS.UserCheck class is used to monitor customized system conditions. 
The class 
ValueCheck
represents a simple check for the value of a signal, environment variable or 
system variable. Here the value of the signal EngineRunning is checked: 
[TestCase("Title", "Description")] 
public void ObserveEngineState() 
ICheck engOn = new ValueCheck<EngineRunning>(CheckType.Observation, 1); 
engOn.Activate(); 
Vector.CANoe.Threading.Execution.Wait(4000); // observation active 
engOn.Deactivate(); 
This is an example of checking the value of a bus signal. First the check for the signal value is created 
with the type Condition for the value ‘1’. Then the check is activated, and after a 4s wait the check is 
deactivated before the test case end. 
A cycle time check for a message is done like this. The activation is done as in the previous example. 
ICheck check = new AbsoluteCycleTimeCheck<NetworkDB.Frames.CyclicMsg> 
(CheckType.Condition, 80, 120); 
If user-defined system conditions should be checked, a customized class can be defined (e.g. for DLC 
observation): 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
18 
Contact Information:   www.vector.com   or +49-711-80 670-0 
public class MyUserCheck : UserCheck 
public MyUserCheck(string title, string description) 
 : base(title, description) 
{} 
[OnCANFrame(1, 0x64)] 
public void FrameReceived1(CANFrame frame) 
if (frame.DLC != 1) 
ReportViolation("DLC check for frame 0x64 failed"); 
The application of the check is as known from above: 
ICheck check = new MyUserCheck("MyUser check", "Check DLC of message 0x64"); 
check.Activate(); // or: check.Activate("a new title"); 
// ... 
check.Deactivate(); 
User checks can combine several runtime values as verification condition. 
5.2.5  Criterions  
Criterions can be used 
to wait until system conditions are reached 
to observe system conditions 
The Criterion attribute can be used to define a handler to be used within checks or wait points 
[Criterion]  
[OnChange(typeof(AntiTheftSystemActive))] 
[OnChange(typeof(LockState))] 
bool AntiTheftSystemCriterion() 
if((EngineRunning.Value == 0) && (LockState.Value == 1)) 
return (AntiTheftSystemActive.Value == 1); 
else 
return (AntiTheftSystemActive.Value == 0); 
Apply the criterion above in a Check – the check fails, if the criterion handler returns false: 
Check observeAntiTheftSystem = new Check(AntiTheftSystemCriterion); 
observeAntiTheftSystem.Activate(); 
Apply the criterion above in  as Wait Point condition – the wait point is resumed, if the criterion handler 
returns true: 
Execution.Wait(AntiTheftSystemCriterion); 
Note1: 
The handler was immediately called on setup of the wait or the check to handle the start 
condition. 
Note2: 
Handlers that are marked with the Criterion attribute are only active while the check or wait 
condition is active. 
The Criterion class can be used to combine several single criterions to a complex criterion, e.g. when 
several signal values have to be checked in parallel. This is similar to the 
testJoinAuxEvent()
function in CAPL.  
Criterion antiTheftSystem = new Criterion(); 
antiTheftSystem.AddMandatory(new ValueCriterion<AntiTheftSystemActive >(0)); 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
19 
Contact Information:   www.vector.com   or +49-711-80 670-0 
antiTheftSystem.AddOneOf(new ValueCriterion<LockState>(0)); 
antiTheftSystem.AddOneOf(new ValueCriterion<EngineRunning>(1)); 
Again the combined criterion can be used I a check – the check is failed, if a mandatory condition is 
violated or if all optional conditions are violated: 
Check observeAntiTheftSystem = new Check(antiTheftSystem); 
observeAntiTheftSystem.Activate(); 
And also as a wait condition  – the wait point is resumed, if if all mandatory conditions are fulfilled and 
if one optional condition is fulfilled: 
Execution.Wait(antiTheftSystem, 1000); 
5.2.6  User Dialogs 
Original windows dialogs cannot be used in .NET test modules since they would disturb the CANoe 
real time behavior. Instead there are several predefined dialogs in Vector.CANoe.Threading and 
Vector.Scripting.UI. Here are some examples how to use them. Further dialogs are described 
in the online help of CANoe. 
Tester Confirmation Dialog: 
int result = Execution.WaitForConfirmation("Please confirm!"); 
or 
int result = ConfirmationDialog.Show(("Please confirm!","Confirmation Dialog"); 
Value input with ranges: 
List<Range<uint>> l = new List<Range<uint>>(); 
l.Add(new Range<uint>(1, 5)); 
l.Add(new Range<uint>(10, 15)); 
RangeCollection<uint> mRangesUint = new RangeCollection<uint>(l); 
result = DataEntryDialog.Show<uint>( 
"Please enter a value between 1-5 or 10-15! ",  
"ValueInput with range",  
"Two different ranges are defined.", ref value, mRangesUint); 
5.2.7  Test Patterns 
Test patterns are basic predefined test procedures or test flows that can be parameterized with values 
and that are executed in test cases. Typically the patterns are parameterized with input values and 
after a timeout the output (expected) values are checked. The usage of test patterns is one way of 
supporting the reuse concept. 
In .NET test patterns are implemented as abstract classes, e.g. the class
StateChange.
These 
abstract classes must be instantiated as concrete classes with typed input and output (expected) 
vectors. The 
StateChange
pattern implements the typical flow: stimulate, wait, evaluate – known also 
from XML test module patterns. The custom attributes 
[Input]
and 
[Expected]
are used to 
determine the input (stimulation) and output (evaluation) parameters. 
First create the test pattern by deriving from the abstract class. Define the timeout, input and expected 
values. 
public class CrashDetectionTest : StateChange 
public CrashDetectionTest() { Wait = 200; } 
[Input(typeof(NetworkDB.CrashDetected))] 
public double crashDetected = 1; 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
20 
Contact Information:   www.vector.com   or +49-711-80 670-0 
[Expected(typeof(NetworkDB.LockState), Relation.Equal)] 
public double lockState = 0; 
The created test pattern can now be used in a test case, e.g. by applying the 
Execute()
method on it: 
[TestCase] 
public void LockStateDependsOnCrashDetection() 
// Test Pattern - Crash Detection function test 
CrashDetectionTest crashTest = new CrashDetectionTest(); 
crashTest.Execute(); 
  // Change test pattern input parameter and re-execute  
  crashTest.crashDetected = 0;  
  crashTest.Execute(); 
User-defined test patterns can be defined with the [TestFunction] attribute: 
[TestFunction] 
private void InitSUT() 
// perform some actions 
When executing the test function detailed reporting data is written to the test report. 
5.2.8  Diagnostic Tests 
Vector.Diagnostic is used to implement diagnostic request / response scenarios. A short example 
demonstrates this: 
[TestCase("Diagnostic Test")] 
public void TC_Diagnostic() 
// select a diagnostic target ECU: 
Ecu myEcu = Application.GetEcu("ECU"); 
// Create a request  
Request request = myEcu.CreateRequest("ECUOrgin_Read"); 
// Send the request and wait for a response 
SendResult result = request.Send(); 
// Check if the message transmission was successful 
if (result.Status == SendStatus.Ok) 
// Get the response (Caution: the response might be null) 
Response response = result.Response; 
// Check if the ECU sent a positive response 
if (response.IsPositive) 
Report.TestStepPass("Pos response received."); 
// Read and verify a parameter value:  
Parameter para = response.GetParameter("SerialNumber"); 
if (para.Value.ToInt32 == 123) 
Report.TestStepPass("Serial number is OK"); 
else 
... 
} else { 
Report.TestStepFail("Negative Response received"); 
} else { 
Report.TestStepFail("Sending failed." + result.Status.ToString()); 
The service and parameter qualifier can be copied from the CANoe symbol explorer. 
More background information can be found in ‘VDS_Library_QuickStart.pdf’  that is available in the 
CANoes start menu / Help / ‘Documentation Vector Diagnostic Scripting Library’. 
Documents you may be interested
Documents you may be interested