• 从零开始学CAPL

    从零开始学CAPL

    CAPL和C语言的关系和介绍

    CAPL（Communication Access Programming Language）是一种用于汽车通信网络开发的编程语言。它是Vector Informatik公司开发的一种专用脚本语言，用于开发和测试汽车通信网络的应用程序和诊断功能。
    C语言是一种通用的高级编程语言，它被广泛用于系统软件、嵌入式软件和应用程序的开发。C语言具有类似于CAPL的数据类型和控制流程，但它更通用，可以用于开发不同领域的应用程序。
    CAPL和C语言的关系在于CAPL是建立在C语言基础上的特定应用领域的编程语言。CAPL继承了C语言的语法和一些特性，同时还增加了与汽车通信网络相关的功能和库函数。
    CAPL主要用于开发基于CAN（Controller Area Network）和LIN（Local Interconnect Network）等汽车通信协议的应用程序和诊断功能。它提供了丰富的API函数来访问和操控CAN和LIN网络，实现消息传输、节点仿真、故障注入和诊断等功能。CAPL还支持丰富的数据类型和事件驱动的编程方式，使开发和测试人员能够快速实现复杂的汽车通信网络应用。
    由于CAPL是建立在C语言基础上的特定应用领域的编程语言，本文先从C语言的基础讲起。

    C语言的基础语法

    常量

    在C语言中，常量是一个固定的值，其值在程序运行时不能被改变。常量分为两种类型：字面常量和符号常量。

    1. 字面常量：字面常量是直接出现在程序中的常量值，不需要进行计算。C语言中的字面常量包括整数常量、实数常量、字符常量和字符串常量。
    • 整数常量：例如，10、-5、100等。
    • 实数常量：例如，3.14、-0.5、2e3等（e表示幂）。
    • 字符常量：用单引号(')包围的单个字符，例如，‘A’、‘b’、'2’等。
    • 字符串常量：用双引号(")包围的一串字符，例如，“Hello”、"World"等。

    示例：

    int num = 10; // 整数常量
float pi = 3.14; // 实数常量
char letter = 'A'; // 字符常量
char str[] = "Hello"; // 字符串常量

    • 1
    • 2
    • 3
    • 4
    1. 符号常量：符号常量是程序中为一个值起的另一个名字，通过使用#define或const关键字进行定义。一旦定义后，符号常量的值在程序运行期间不能被修改。

    使用#define定义符号常量：

    #define PI 3.14
#define MAX_SIZE 100

    • 1
    • 2

    使用const关键字定义符号常量：

    const int MAX_SIZE = 100;
const float PI = 3.14;

    • 1
    • 2

    示例：

    #define PI 3.14
#define MAX_SIZE 100

int main() {
    const int MIN_SIZE = 1;
    int radius = 5;
    
    float circumference = 2 * PI * radius; // 使用符号常量PI进行计算
    int array[MAX_SIZE]; // 使用符号常量MAX_SIZE定义数组大小
    
    // 修改常量值会导致编译错误
    // MIN_SIZE = 0; 
    
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    变量

    在C语言中，常量是一个固定的值，其值在程序运行时不能被改变。常量分为两种类型：字面常量和符号常量。

    1. 字面常量：字面常量是直接出现在程序中的常量值，不需要进行计算。C语言中的字面常量包括整数常量、实数常量、字符常量和字符串常量。
    • 整数常量：例如，10、-5、100等。
    • 实数常量：例如，3.14、-0.5、2e3等（e表示幂）。
    • 字符常量：用单引号(')包围的单个字符，例如，‘A’、‘b’、'2’等。
    • 字符串常量：用双引号(")包围的一串字符，例如，“Hello”、"World"等。

    示例：

    int num = 10; // 整数常量
float pi = 3.14; // 实数常量
char letter = 'A'; // 字符常量
char str[] = "Hello"; // 字符串常量

    • 1
    • 2
    • 3
    • 4
    1. 符号常量：符号常量是程序中为一个值起的另一个名字，通过使用#define或const关键字进行定义。一旦定义后，符号常量的值在程序运行期间不能被修改。

    使用#define定义符号常量：

    #define PI 3.14
#define MAX_SIZE 100

    • 1
    • 2

    使用const关键字定义符号常量：

    const int MAX_SIZE = 100;
const float PI = 3.14;

    • 1
    • 2

    示例：

    #define PI 3.14
#define MAX_SIZE 100

int main() {
    const int MIN_SIZE = 1;
    int radius = 5;
    
    float circumference = 2 * PI * radius; // 使用符号常量PI进行计算
    int array[MAX_SIZE]; // 使用符号常量MAX_SIZE定义数组大小
    
    // 修改常量值会导致编译错误
    // MIN_SIZE = 0; 
    
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    总之，常量在C语言中是不可修改的值，可以直接出现在程序中（字面常量）或通过符号常量进行定义。常量的使用可以增强代码的可读性和可维护性。

    标识符

    在C语言中，标识符是用来标识变量、函数、数组等程序实体的名称。它由字母、数字和下划线组成，且必须以字母或下划线开头。标识符区分大小写，长度没有限制。

    以下是一些C语言中常见的标识符实例：

    1. 变量名：可以用来表示存储数据的位置，用于存储不同数据类型的值。
      例：int age; // 定义一个名为age的整型变量

    2. 函数名：用于定义和实现一组相关操作的代码块，可以通过函数名调用执行。
      例：int add(int a, int b) { return a + b; } // 定义一个名为add的函数

    3. 数组名：用于存储多个相同类型的数据项，通过索引访问数组元素。
      例：int nums[5]; // 定义一个名为nums的整型数组

    4. 结构体名：用于封装多个不同数据类型的变量，并作为一个整体使用。
      例：struct Person { char name[20]; int age; }; // 定义一个名为Person的结构体

    5. 枚举常量：用于定义一组常量值，可以作为变量的取值限制。
      例：enum Weekday { MON, TUE, WED, THU, FRI, SAT, SUN }; // 定义一个名为Weekday的枚举类型

    关键字

    C语言中的关键字是被编译器预先定义的具有特殊含义的标识符，这些关键字用于表示语言的基本结构、语句、数据类型等。以下是C语言中常见的关键字及其示例：

    1. int：表示整数类型。例如，在声明变量时使用 int 关键字可以定义一个整数类型的变量：

      int num = 10;

      • 1

    2. float：表示单精度浮点数类型。例如，在声明变量时使用 float 关键字可以定义一个单精度浮点数类型的变量：

      float pi = 3.14;

      • 1

    3. char：表示字符类型。例如，在声明变量时使用 char 关键字可以定义一个字符类型的变量：

      char ch = 'A';

      • 1

    4. if：表示一个条件语句中的判断条件。例如，使用 if 关键字可以进行条件判断：

      int num = 5;
if(num > 0) {
    printf("The number is positive.");
}

      • 1
      • 2
      • 3
      • 4

    5. for：表示一个循环语句中的循环条件。例如，使用 for 关键字可以进行循环操作：

      for(int i = 0; i < 5; i++) {
    printf("%d ", i);
}

      • 1
      • 2
      • 3

    6. while：表示一个循环语句中的循环条件。例如，使用 while 关键字可以进行循环操作：

      int i = 0;
while(i < 5) {
    printf("%d ", i);
    i++;
}

      • 1
      • 2
      • 3
      • 4
      • 5

    7. switch：表示一个多分支选择语句中的条件判断。例如，使用 switch 关键字可以进行多分支选择操作：

      int choice = 2;
switch(choice) {
    case 1:
        printf("You selected option 1.");
        break;
    case 2:
        printf("You selected option 2.");
        break;
    default:
        printf("Invalid option.");
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

    需要注意的是，关键字不能用作标识符（变量名、函数名等），否则会导致编译错误。同时，C语言中的关键字是大小写敏感的，即关键字必须在代码中按照正确的大小写形式使用。

    数据类型

    整数数据

    在C语言中，整数数据类型是一种用于表示整数值的数据类型。C语言提供了几种整数数据类型，包括有符号整数和无符号整数。

    有符号整数可以表示正数、负数和零。C语言提供了几种有符号整数类型，包括：

    • char：用于表示字符和整数值的数据类型，占用一个字节。
    • int：用于表示整数值的数据类型，占用通常占用4个字节。
    • short：用于表示较小的整数值的数据类型，通常占用2个字节。
    • long：用于表示较大的整数值的数据类型，通常占用4个或8个字节，具体取决于编译器和系统。

    无符号整数只能表示非负整数值（包括零），不能表示负整数。C语言提供了几种无符号整数类型，包括：

    • unsigned char：无符号字符类型，占用一个字节。
    • unsigned int：无符号整数类型，占用通常占用4个字节。
    • unsigned short：无符号短整数类型，通常占用2个字节。
    • unsigned long：无符号长整数类型，通常占用4个或8个字节，具体取决于编译器和系统。

    使用无符号整数类型可以提供更大的数值范围，但不能用于表示负数。
    在这里插入图片描述

    字符数据

    在C语言中，字符型数据表示单个字符，可以是字母、数字或特殊字符。C语言提供了两种表示字符型数据的方式：

    1. ASCII字符集：ASCII（American Standard Code for Information Interchange）是一种用于表示常见字符的字符编码标准。在ASCII字符集中，每个字符都被赋予一个唯一的整数值，范围从0到127。常见的ASCII字符包括大写字母（A-Z）、小写字母（a-z）、数字（0-9）和一些特殊字符（例如空格、换行符等）。

    2. 字符变量：在C语言中，可以使用字符变量来存储字符型数据。字符变量使用关键字char来声明，并使用单引号将字符括起来。例如，char ch = 'A';声明了一个字符变量ch并将其初始化为大写字母’A’。字符变量可以执行各种操作，例如赋值、比较和打印等。

    以下是一些使用ASCII字符集和字符变量的示例：

    #include 

int main() {
    // 使用ASCII字符集
    char letter = 'A';
    printf("字符 %c 的ASCII码是 %d\n", letter, letter);

    // 使用字符变量
    char ch = 'B';
    printf("字符变量ch的值为 %c\n", ch);

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    输出结果为：

    字符 A 的ASCII码是 65
字符变量ch的值为 B

    • 1
    • 2

    需要注意的是，C语言中的字符型数据本质上是整数类型，可以通过强制类型转换将其转换为整数类型进行计算。

    实型数据(浮点数据)

    在C语言中，浮点数据类型用于表示带有小数部分的数字。浮点数据类型有两种：float和double。

    1. float类型：float类型可以存储小数点后面最多7位数字。例如，下面的示例将一个浮点数赋值给一个float变量：
    float num = 3.14;

    • 1
    1. double类型：double类型用于存储更大范围的浮点数，可以存储小数点后面最多15位数字。例如，下面的示例将一个浮点数赋值给一个double变量：
    double num = 3.14159;

    • 1

    浮点数在计算机内部以二进制形式表示，因此可能存在精度损失的问题。例如，下面的示例将0.1赋值给一个double变量，并对该变量进行打印：

    double num = 0.1;
printf("%.20f", num);

    • 1
    • 2

    输出结果为：0.10000000000000000555。这是因为0.1无法精确地在二进制中表示，导致精度损失。

    为了比较浮点数的相等性，通常需要使用近似比较，而不是直接使用"=="操作符。例如，下面的示例演示了如何比较两个浮点数是否近似相等：

    double num1 = 0.1;
double num2 = 0.1 + 0.2;

if (fabs(num1 - num2) < 0.000001) {
    printf("Approximately equal\n");
} else {
    printf("Not equal\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    输出结果为：Approximately equal。这是因为两个浮点数的差值的绝对值小于给定的误差范围，因此它们被认为是近似相等的。

    总结：浮点数据类型在C语言中用于表示带有小数部分的数字。它们具有不同的精度范围（float和double），但在存储和比较过程中可能会出现精度损失的问题，需要注意使用近似比较。

    运算符以及优先级

    C语言中的运算符分为以下几类：

    1. 算术运算符

      • 加号（+）：用于相加两个操作数。
      • 减号（-）：用于相减两个操作数。
      • 乘号（*）：用于相乘两个操作数。
      • 除号（/）：用于相除两个操作数。
      • 取余号（%）：用于求两个操作数的余数。

    2. 关系运算符

      • 等于号（==）：用于判断两个操作数是否相等。
      • 不等于号（!=）：用于判断两个操作数是否不相等。
      • 大于号（>）：用于判断左操作数是否大于右操作数。
      • 小于号（<）：用于判断左操作数是否小于右操作数。
      • 大于等于号（>=）：用于判断左操作数是否大于等于右操作数。
      • 小于等于号（<=）：用于判断左操作数是否小于等于右操作数。

    3. 逻辑运算符

      • 与运算符（&&）：用于判断两个条件是否同时满足。
      • 或运算符（||）：用于判断两个条件是否有一个满足。
      • 非运算符（！）：用于取反一个条件。

    4. 位运算符

      • 按位与运算符（&）：对两个操作数的每个位进行与操作。
      • 按位或运算符（|）：对两个操作数的每个位进行或操作。
      • 按位异或运算符（^）：对两个操作数的每个位进行异或操作。
      • 按位取反运算符（~）：对操作数的每个位进行取反操作。
      • 左移运算符（<<）：将操作数的二进制位向左移动指定的位数。
      • 右移运算符（>>）：将操作数的二进制位向右移动指定的位数。

    5. 赋值运算符

      • 等于号（=）：将右操作数的值赋给左操作数。
      • 加等于号（+=）：将右操作数和左操作数相加后赋值给左操作数。
      • 减等于号（-=）：将右操作数和左操作数相减后赋值给左操作数。
      • 乘等于号（*=）：将右操作数和左操作数相乘后赋值给左操作数。
      • 除等于号（/=）：将右操作数和左操作数相除后赋值给左操作数。

    6. 其他运算符

      • sizeof运算符：用于获取变量或数据类型的大小（字节数）。
      • 条件运算符（?:）：用于简化if-else语句，根据条件选择返回不同的值。
      • 逗号运算符（,）：用于连续多个表达式，每个表达式按顺序执行，整个表达式的值为最后一个表达式的值。

    C语言中各个运算符的优先级如下（由高到低）：

    1. ()：括号中的表达式
    2. ++，–：自增和自减运算符
    3. !：逻辑非运算符
    4. *，/，%：乘、除、取余运算符
    5. +，-：加、减运算符

    6. , >=, <, <=：关系运算符

    7. ==, !=：相等、不等运算符
    8. &&：逻辑与运算符
    9. ||：逻辑或运算符
    10. =：赋值运算符
    11. ,：逗号运算符

    在表达式中，括号内的运算符优先级最高，逗号运算符的优先级最低。如果表达式中有多个运算符，优先级高的运算符将先于优先级低的运算符执行。如果优先级相同，则从左到右依次执行。可以用括号改变运算符的优先级顺序。

    类型转换

    在C语言中，类型转换是指将一个数据类型的值转换为另一个数据类型的过程。类型转换在程序中经常被用来处理不同数据类型之间的关系，例如在表达式中使用不同类型的操作数，或者在进行函数调用时需要将参数传递给不同类型的参数。

    C语言中的类型转换可以分为两种：隐式类型转换（自动转换）和显式类型转换（强制转换）。

    1. 隐式类型转换：在某些情况下，C编译器会自动进行类型转换，以保证表达式的正确性和一致性。隐式类型转换是根据C语言的规则进行的，不需要程序员显式地指定转换。

    示例1：

    int a = 10;
float b = 3.14;
float sum = a + b; // a会被隐式地转换为float类型，以便与b进行相加

    • 1
    • 2
    • 3

    示例2：

    int a = 10;
char c = 'A';
int result = a + c; // c会被隐式地转换为int类型，以便与a进行相加

    • 1
    • 2
    • 3
    1. 显式类型转换：有时候程序员需要手动指定类型转换的方式，这就是显式类型转换。在C语言中，使用强制类型转换运算符来完成显式类型转换。强制类型转换的语法格式为：(type) expression。

    示例1：

    int a = 10;
float b = 3.14;
int sum = (int)(a + b); // 将a和b的和转换为整数类型

    • 1
    • 2
    • 3

    示例2：

    int a = 65;
char c = (char)a; // 将整数a转换为字符类型

    • 1
    • 2

    需要注意的是，虽然强制类型转换可以实现不同类型之间的转换，但过多地使用强制类型转换可能会导致代码可读性降低和潜在的错误，因此建议在编程时慎用强制类型转换。

    printf函数

    在C语言中，printf函数是用于将数据输出到标准输出设备（通常是显示器）的函数。它以格式化的方式将指定的数据输出到屏幕上。

    printf函数的基本语法如下：

    int printf(const char *format, ...);

    • 1

    其中，format是一个字符串参数，用于指定要输出的格式，后面的可选参数（也可以是变参）为要输出的数据。

    下面是一些常用的printf函数的用法示例：

    1. 输出字符串：
    printf("Hello, World!");

    • 1

    输出结果为：Hello, World!

    1. 输出整数：
    int num = 10;
printf("The number is %d", num);

    • 1
    • 2

    输出结果为：The number is 10

    1. 输出浮点数：
    float pi = 3.14159;
printf("The value of pi is %f", pi);

    • 1
    • 2

    输出结果为：The value of pi is 3.141590

    1. 输出字符：
    char c = 'A';
printf("The character is %c", c);

    • 1
    • 2

    输出结果为：The character is A

    1. 输出格式化字符串（使用格式化符号）：
    int num1 = 10;
int num2 = 20;
printf("The numbers are %d and %d", num1, num2);

    • 1
    • 2
    • 3

    输出结果为：The numbers are 10 and 20

    通过使用不同的格式化符号，可以在输出中插入不同类型的数据，如%c代表字符，%d代表整数，%f代表浮点数等等。

    需要注意的是，如果格式化字符串中包含了格式化符号，那么后面的可选参数数量应该与格式化符号的个数相匹配，否则可能会导致意想不到的结果。

    选择程序结构设计

    if语句

    在C语言中，if语句是一种条件控制语句，用于根据给定条件的真假来决定是否执行特定的代码块。

    if语句的语法结构如下：

    if (condition) {
    // 如果条件为真，执行这里的代码
} else {
    // 如果条件为假，执行这里的代码
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • condition 是一个表达式，它可以是关系表达式、逻辑表达式或其他返回值为布尔类型的表达式。如果条件为真（非零），则执行if代码块中的内容，否则执行else代码块中的内容。

    以下是if语句的工作方式：

    1. 首先判断if语句中的条件表达式的值。
    2. 如果条件为真，则执行if代码块中的语句。
    3. 如果条件为假，并且存在else代码块，则执行else代码块中的语句。
    4. 如果条件为假，并且没有else代码块，则if语句后的代码将会继续执行。

    除了if和else关键字外，还可以使用else if语句来做更复杂的条件判断。else if语句用于依次检查多个条件。

    以下是一个使用if语句的例子：

    #include 

int main() {
    int num = 10;

    if (num > 0) {
        printf("数字是正数\n");
    } else if (num < 0) {
        printf("数字是负数\n");
    } else {
        printf("数字是零\n");
    }

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    该程序会根据变量num的值输出相应的信息。

    在C语言中，if语句是非常重要和常用的控制语句，可以根据不同的条件执行不同的代码，从而使程序具有更高的灵活性和功能。

    switch语句

    C语言中的switch语句是一种用于根据不同条件执行不同代码块的控制结构。它的语法如下：

    switch (表达式) {
    case 值1:
        代码块1;
        break;
    case 值2:
        代码块2;
        break;
    // ...
    default:
        默认代码块;
        break;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    switch语句中的表达式可以是一个整数或字符类型的常量、变量或表达式。当程序执行到switch语句时，会根据表达式的值来匹配对应的case，并执行相应的代码块。一旦匹配到某个case后，程序会继续执行该case下的所有代码，直到遇到break语句或者switch语句结束。

    如果表达式的值与任何一个case不匹配，那么会执行默认的代码块。default关键字用于指定默认块，它是可选的。

    以下是一个使用switch语句的实例，根据输入的数字，输出对应的星期几：

    #include.h>

int main() {
    int day;
    printf("请输入数字(1-7)：");
    scanf("%d", &day);

    switch (day) {
        case 1:
            printf("星期一\n");
            break;
        case 2:
            printf("星期二\n");
            break;
        case 3:
            printf("星期三\n");
            break;
        case 4:
            printf("星期四\n");
            break;
        case 5:
            printf("星期五\n");
            break;
        case 6:
            printf("星期六\n");
            break;
        case 7:
            printf("星期日\n");
            break;
        default:
            printf("输入错误，请输入正确的数字！\n");
            break;
    }

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    当用户输入1时，程序会输出"星期一"；输入2时，输出"星期二"；以此类推。如果输入的数字不在1-7的范围内，会输出"输入错误，请输入正确的数字！"。

    循环结构程序设计

    while语句

    在C语言中，while语句用于重复执行一段代码，只要给定的条件为真（非零）。

    while语句的一般语法如下：

    while(condition)
{
    // 循环体语句
}

    • 1
    • 2
    • 3
    • 4

    其中，condition是一个表达式，它决定了是否继续执行循环体语句。如果condition为真，则执行循环体语句，然后再次判断condition的值。如果condition为假（即为0），则跳出循环，继续执行后面的代码。

    以下是一个实例，展示了如何使用while语句：

    #include 

int main() {
    int i = 1; // 初始化计数器变量为1
    while (i <= 5) { // 设置循环条件
        printf("%d\n", i); // 打印计数器的值
        i++; // 更新计数器
    }
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    以上代码将输出以下内容：

    1
2
3
4
5

    • 1
    • 2
    • 3
    • 4
    • 5

    在这个例子中，我们使用while循环来打印从1到5的数字。首先，我们初始化计数器变量i为1。然后，我们将循环条件设置为i <= 5，意思是只要i的值小于或等于5，循环体语句就会被执行。在循环体语句中，我们打印计数器变量的值，并且在每次循环结束后，通过i++语句递增计数器的值。当计数器变量i的值达到6时，不再满足循环条件，循环结束。

    do……while语句

    在C语言中，do…while语句用于执行一系列语句，然后再检查一个条件来决定是否继续执行。与while语句不同的是，do…while语句至少会执行一次循环体。

    do…while语法的基本结构如下：

    do {
   // 循环体语句
   // ...
} while(条件);

    • 1
    • 2
    • 3
    • 4

    5个要点：

    1. 先执行一次循环体，然后再评估条件的真假。
    2. 循环体会一直执行，直到条件为假。
    3. do…while循环语句的循环体至少会执行一次，无论条件的真假。
    4. 循环体中的语句有没有分号都是可以的。
    5. 条件可以是任何表达式，只要它能够被求值为真或假。

    以下是一个使用do…while语句的简单示例，用于计算数字的和，直到用户输入0为止：

    #include 

int main() {
   int num;
   int sum = 0;

   do {
      printf("请输入一个数字（输入0退出）：");
      scanf("%d", &num);

      sum += num;
   } while(num != 0);

   printf("数字的和为：%d\n", sum);

   return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    这段代码会提示用户输入一个数字，然后将输入的数字与sum相加。在每次循环中，会检查用户输入的数字是否不等于0，如果不等于0，就会继续执行循环。直到用户输入0，循环才会终止，然后输出数字的和。

    for语句

    在C语言中，for语句是一种用于循环执行特定代码块的迭代控制语句。它的语法结构如下：

    for (初始表达式; 循环条件; 更新表达式) {
   // 在循环体中执行的代码
}

    • 1
    • 2
    • 3
    • 初始表达式：在循环开始前执行的一次性代码。通常用于初始化循环计数器或设置其他必要的变量。
    • 循环条件：每次循环开始前被检查的条件表达式。如果条件为真（非零），则执行循环体；如果条件为假（零），则跳出循环。
    • 更新表达式：在每次循环结束后执行的表达式。通常用于递增循环计数器或改变其他必要的变量。

    下面是一个使用for语句的示例，用于计算并打印1到10的累加和：

    #include 

int main() {
    int sum = 0;
    
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    
    printf("Sum of numbers from 1 to 10 is: %d\n", sum);
    
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    输出结果为：

    Sum of numbers from 1 to 10 is: 55

    • 1

    在该示例中，初始表达式是int i = 1，用于初始化循环计数器i。循环条件是i <= 10，只要条件为真，循环体就会执行。更新表达式是i++，用于递增循环计数器i。在每次循环体中，将当前循环计数器的值累加到sum变量中。当循环计数器i的值达到或超过10时，循环结束。最后，使用printf函数将累加和输出到屏幕上。

    break和continue

    在C语言中，break和continue是两个跳转语句，用于控制程序流程。

    1. break语句：break语句用于终止循环语句，使程序跳出该循环，继续执行循环之后的语句。常用于for、while和do-while循环中。
    #include 

int main() {
    int i;
    
    for(i=1; i<=10; i++) {
        if(i == 5) {
            break;   // 当i等于5时跳出循环
        }
        
        printf("%d ", i);
    }
    
    // 1 2 3 4
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    1. continue语句：continue语句用于终止当前循环的迭代，然后开始下一次迭代。即跳过循环体内continue语句之后的代码，直接进行下一次循环的条件判断。同样，它也常用于for、while和do-while循环中。
    #include 

int main() {
    int i;
    
    for(i=1; i<=10; i++) {
        if(i == 5) {
            continue;   // 当i等于5时跳过本次循环的剩余代码，开始下一次循环
        }
        
        printf("%d ", i);
    }
    
    // 1 2 3 4 6 7 8 9 10
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    总结：break用于完全终止循环，而continue用于跳过当前迭代，继续执行下一次迭代。

    数组

    C语言中的数组是一种用于存储一系列相同类型的数据元素的数据结构。数组可以存储同一类型的数据，例如整数、字符或浮点数。

    在C语言中，数组是一个由相同类型的元素组成的集合。可以通过指定元素的类型和数组的大小来声明一个数组。数组中的每个元素都可以通过索引来访问，索引从0开始，依次递增。

    以下是一个声明和初始化数组的示例：

    #include 

int main() {
   int numbers[5] = {1, 2, 3, 4, 5};
   
   for (int i = 0; i < 5; i++) {
      printf("Element at index %d: %d\n", i, numbers[i]);
   }
   
   return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    输出结果为：

    Element at index 0: 1
Element at index 1: 2
Element at index 2: 3
Element at index 3: 4
Element at index 4: 5

    • 1
    • 2
    • 3
    • 4
    • 5

    以上示例中，声明了一个包含5个整数元素的数组numbers，并用大括号初始化了数组的值。接着通过for循环遍历数组的索引，并使用printf打印出每个元素的值。

    数组在C语言中被广泛使用，它们提供了一种方便的方式来处理大量的数据。由于数组在内存中是连续存储的，因此可以通过索引快速访问元素。

    函数

    在C语言中，函数是一段可重复执行的代码块，它接收输入参数、执行特定的任务，并返回一个值。C语言的函数可以使程序结构更加清晰、模块化，便于代码的复用和维护。

    函数通常包含以下几个部分：

    1. 函数头：包括函数的返回类型、函数名和参数列表。
    2. 函数体：包含函数的实际代码，用于完成特定的任务。
    3. 函数返回值：函数可返回一个值给调用者，也可以没有返回值。

    下面是一个求两个整数的和的函数的例子：

    #include 

// 函数定义
int add(int a, int b) {
    int sum = a + b;
    return sum;  // 返回计算结果
}

int main() {
    int num1 = 10;
    int num2 = 20;
    int result;

    // 调用函数
    result = add(num1, num2);

    printf("The sum is: %d", result);
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    在上面的例子中，add函数的函数头声明了它的返回类型为int（返回一个整数），函数名为add，参数列表有两个整数类型的参数a和b。在函数体中，通过使用加法运算符计算出两个参数的和，并将结果存储在sum变量中。最后，通过return语句返回计算结果。

    在main函数中，定义了两个整数变量num1和num2，并初始化为10和20。然后，调用add函数并将num1和num2作为参数传递给它。add函数计算出了两个参数的和，将结果赋给result变量。最后，使用printf函数打印出结果。

    这就是C语言函数的基本概念和使用方法。函数能够在程序中起到模块化的作用，使代码更加清晰和易于维护。

    CAPL语法介绍

    程序的结构

    在这里插入图片描述

    变量名、关键字、数据类型

    在CAPL脚本语言中，变量名用于表示数据存储位置的名称。关键字是具有特殊含义的单词，用于定义和操作变量。数据类型指定了变量可以存储的数据的类型。

    • 字符型变量表示一个字符，使用关键字char。例如：char ch = ‘A’;

    • 浮点型变量表示一个浮点数，使用关键字float。例如：float value = 3.14;

    • 数组是一组具有相同数据类型的元素的集合。可以使用关键字定义数组，并使用索引访问数组中的元素。例如：int arr[5] = {1, 2, 3, 4, 5};

    • 报文变量用于存储和操作CAN或LIN通信中的报文数据。可以使用关键字定义报文变量，并使用内置函数对其进行操作。例如：message msg;

    • 系统变量是预定义的变量，用于表示与系统操作相关的数据。例如，sysvar.systime表示当前系统时间。

    • 定时器变量用于创建和控制定时器，在一定时间间隔内执行特定操作。例如：timer t;

    举例说明：

    1. 字符型变量
    char ch = 'A';
write("Character: ", ch);

    • 1
    • 2

    输出结果为：Character: A

    1. 浮点型变量
    float value = 3.14;
write("Value: ", value);

    • 1
    • 2

    输出结果为：Value: 3.14

    1. 数组
    int arr[5] = {1, 2, 3, 4, 5};
write("Array element at index 2: ", arr[2]);

    • 1
    • 2

    输出结果为：Array element at index 2: 3

    1. 报文变量
    message msg;
msg.id = 0x123;
msg.dlc = 8;
msg.data[0] = 0xAA;
write("Message ID: 0x", hex(msg.id));
write("Data length: ", msg.dlc);
write("Data at index 0: ", hex(msg.data[0]));

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    输出结果为：

    Message ID: 0x123
Data length: 8
Data at index 0: 0xAA

    • 1
    • 2
    • 3

    判断和循环

    一、条件语句

    条件语句可以帮助我们根据不同的条件执行不同的操作。在CAPL中有几种常用的条件语句，如if语句、if-else语句和switch语句。

    1. if语句：
      if语句用于判断一个条件是否为真，如果条件为真，则执行if语句块中的代码。

    示例：

    variables
{
  int age = 18;
}

on start
{
  if(age >= 18)
  {
    write("你已经成年了");
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. if-else语句：
      if-else语句在if语句的基础上，增加了一个条件为假时执行的代码块。

    示例：

    variables
{
  int age = 16;
}

on start
{
  if(age >= 18)
  {
    write("你已经成年了");
  }
  else
  {
    write("你还未成年");
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    1. switch语句：
      switch语句用于根据一个表达式的值，执行与不同值相匹配的代码块。

    示例：

    variables
{
  int day = 3;
}

on start
{
  switch (day)
  {
    case 1: write("星期一"); break;
    case 2: write("星期二"); break;
    case 3: write("星期三"); break;
    default: write("未知");
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    二、循环语句

    循环语句可以帮助我们重复执行一段代码，根据不同的循环条件，CAPL中有几种常用的循环语句，如for循环、while循环和do-while循环。

    1. for循环：
      for循环会从一个初始值开始，根据循环条件重复执行代码块，每次循环结束后对计数器进行增量操作。

    示例：

    variables
{
  int i;
}

on start
{
  for(i = 0; i < 5; i++)
  {
    write(i);
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. while循环：
      while循环会在判断条件为真时重复执行代码块，直到条件为假。

    示例：

    variables
{
  int count = 0;
}

on start
{
  while(count < 5)
  {
    write(count);
    count++;
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    1. do-while循环：
      do-while循环先执行一次代码块，然后判断条件，如果条件为真，则继续执行循环，直到条件为假。

    示例：

    variables
{
  int count = 0;
}

on start
{
  do
  {
    write(count);
    count++;
  }
  while(count < 5);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    以上就是CAPL中判断和循环的介绍以及相应的示例说明。这些语句可以帮助我们在CANoe中进行灵活的代码控制和逻辑判断。

    事件

    在这里插入图片描述

    1. 系统事件，在CAPL的系统事件中，有prestart、start、PreStop、stopMeasurement这4种。当工程运行时，上述系统事件的发生顺序依次是preSart–>start–>preStop–>stopMeasurement

    在这里插入图片描述
    关于系统事件的定义格式如下：

    
on preStart             /*系统事件，初始化时执行*/
{
   resetCan();            /*CAPL接口函数，用于复位CAN控制器*/
}
on start              /*系统事件，工程开始时执行*/
{
   write(“Just A Try”);      /*write()函数将字符串信息在”write”窗口输出*/
}
on preStop            /*系统事件，工程预备停止时执行;发生在stopMeasurement事件前面*/
{
    write("The Project Will Stop!”);
}
on stopMeasurement      /*系统事件，工程停止时执行*/
{
    write("The End!\n");
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    1. 时间事件，on timer事件：
      • 功能：当定时器到达指定时间时执行的事件。通常用于定时发送CAN消息或执行某些操作。
      • 示例：
    /*@!Encoding:936*/
//7.定时器事件
//设置定时器setTimer(timer1,1000); 
//取消定时器cancelTimer(timer1);
//实现功能 on start的时候，启动timer1(1000ms) 和 timer2(10s)，1000ms之后触发timer1，打印信息，
//然后再次重置timer1时间，10s时间到了之后触发timer2打印信息，并取消timer1。
//步骤 声明定时器变量-设置定时器-声明定时器事件，在事件中再次设置定时器
variables
{
  char timeBuffer[30];
  msTimer timer1;//毫秒定时器
  timer timer2;//秒定时器
}
on start
{
  setTimer(timer1, 1000);
  setTimer(timer2, 10);
}
on timer timer1
{
  getLocalTimeString(timeBuffer);//获取本地时间 以字符串形式显示
  write("%s:timer1超时",timeBuffer);
  setTimer(timer1,1000);
}
on timer timer2
{
  getLocalTimeString(timeBuffer);
  write("%s:timer2超时",timeBuffer);
  cancelTimer(timer1);//取消timer1
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    在这里插入图片描述
    如上示例为10s之前不断执行timer1事件，过了10s开始执行timer2事件。

    1. 键盘事件，on key事件：

      • 功能：当按下指定的按键时执行的事件。通常用于模拟按键操作。
      • 示例：
        on key 'k' {
    // 模拟按键操作
    pressButton(Button1);
}

        • 1
        • 2
        • 3
        • 4

    2. CAN消息事件：

      • 功能：当收到CAN消息时执行的事件。通常用于处理接收到的CAN消息。
      • 示例：
        在这里插入图片描述
    on message Msg1 //这里的message对应数据库中建立的message
{
  //将当前报文信号sSwitch赋给系统变量svLight
  @MyNameSpace::svLight=this.sSwitch;
  cos(PI);
  write("This is a CAPL text.");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    1. BUSOff事件：

      • 功能：当CAN总线状态为BUSOFF时执行的事件。通常用于处理CAN总线错误。
      • 示例：
        on BUSOff {
    // 处理CAN总线错误
    handleBusOff();
}

        • 1
        • 2
        • 3
        • 4

    2. 信号变量事件：

      • 功能：当信号变量的值发生变化时执行的事件。通常用于监控信号变量的变化。
      • 示例：
    on signal sSwitch
{
           // 监控信号1的变化
if (this == 1) {
        doSomething();
}
}

doSomething(){
  write("This is a CAPL text.");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    在这里插入图片描述

    1. on errorFrame事件：

      • 功能：当接收到错误帧时执行的事件。通常用于处理错误帧。
      • 示例：
        on errorFrame {
    // 处理错误帧
    handleErrorFrame();
}

        • 1
        • 2
        • 3
        • 4

    2. on envvar事件：

      • 功能：当环境变量的值发生变化时执行的事件。通常用于监控环境变量的变化。
      • 示例：
        8.1 数据库建立以下几个变量
        在这里插入图片描述
        8.2 Can中输入如下的代码
    on key 'a'
{
  putValue(my_int,5);//设置环境变量的值
  putValue(my_float,2.2);
  putValue(my_string,"CANoe");
}
on envVar my_int
{
  write("my_int的值是%d",getValue(this));//this指代当前的环境变量my_int
}
on envVar my_float
{
  write("my_float的值是%f",getValue(this));//this代表当前的环境变量my_float
}
on envVar my_string
{
  char s[20];//创建字符数组
  getValue(this,s);//将当前环境变量my_string的值放入s
  write("my_string的值是%s",s);
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    8.3 查看Write窗口的输出
    在这里插入图片描述
    如上示例为系统监听到了系统变量的变化，并输出变化值在Write窗口中，同时可以监听多个环境变量变化值，格式如下：

    on envVar (my_int|my_float|my_string)
{ 
}

    • 1
    • 2
    • 3
    1. on sysvar事件：
      • 功能：当系统变量的值发生变化时执行的事件。通常用于监控系统变量的变化。
      • 示例：
        9.1系统变量面板中建立以下几个系统变量
        在这里插入图片描述
        9.2 can中输入如下代码：
    //4.1 on sysvar ... 在指定的系统变量值有新的输入时执行
on key 'a'
{
  @MyNameSpace::svInt=1;//@后面跟着系统变量 给系统变量赋值
  @MyNameSpace::svFloat=2.3;
//  @MyNameSpace::svString="Hello";
  sysSetVariableString(sysvar::MyNameSpace::svString,"HELLO");//设置字符串类型的系统变量的值
}
on sysvar MyNameSpace::svInt
{
  write("svInt=%d",@MyNameSpace::svInt);
}
on sysvar MyNameSpace::svFloat
{
  write("svFloat=%f",@this);
}
on sysvar MyNameSpace::svString
{
  char s[20];
  sysGetVariableString(sysvar::MyNameSpace::svString,s,elCount(s));
  //elCount(s)统计数组长度
  write("svString is %s",s);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    9.3 在工程面板输入键盘事件a,write面板输出如下：
    在这里插入图片描述
    如上示例为监听到系统变量的变化并输出

    系统变量变化事件，示例如下：

    //4.2 on sysvar_update ... 只要有当前系统变量就一直触发
on key 'a'
{
  int i=9;
  @MyNameSpace::svInt=i;
}
on sysvar_update MyNameSpace::svInt
{
  write("svInt=%d",@MyNameSpace::svInt);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    在CAPL中，sysvar_update和sysvar事件都是与系统变量（sysvar）相关的事件。
    sysvar_update是一个周期性事件，在每一个DAQ列表循环中触发。当CAPL程序中的sysvar_update函数被调用时，系统变量的当前值将被写入到相应的sysvar_val变量中。
    而sysvar事件是由系统变量的值更新时触发的事件。当系统变量的值发生变化时，CAPL程序中与该系统变量相关联的sysvar事件将被触发。
    因此，sysvar_update是一个周期性的触发事件，用于获取系统变量的当前值，而sysvar事件是在系统变量值变化时触发的事件。

    this关键字

    在CAPL中，this关键字指的是指向当前正在处理的消息、事件或对象的指针。它表示当前上下文中正在执行的代码所在的对象。因此，可以说this在CAPL中指的是当前事件，也可以指的是当前消息或对象，具体取决于使用的上下文。

    以下是一个示例，演示如何在CAPL编程中使用this关键字：

    on message can0.123 {
    // 当收到can0.123消息时，创建一个对象并调用成员函数
    MyObject obj;
    obj.doSomething();
}

variables {
    // 定义一个具有成员变量和成员函数的对象
    class MyObject {
        int a;  // 成员变量

        void doSomething() {  // 成员函数
            this.a = 10;  // 使用this关键字访问当前对象的成员变量
            write("a = ", this.a);  // 打印当前对象的成员变量的值
        }
    };
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在上述示例中，当收到can0.123消息时，会创建一个名为obj的MyObject对象，并调用其成员函数doSomething()。在doSomething()函数中，使用this关键字来访问当前对象的成员变量a，并将其设置为10。然后打印当前对象的成员变量a的值。

    这样，使用this关键字可以方便地访问当前对象的成员变量和成员函数，提供更灵活的编程能力。

    @和$使用

    在CAPL中，用符号 “@” 来获取变量的值，而用符号 $来获取信号的值。
    在CAPL编程中，@符号用于获取变量的值，$符号用于获取信号的值。

    1. 使用@符号获取变量的值：
      在CAPL中，可以使用@符号来获取变量的值。具体的使用方式是@变量名。例如，假设有一个整型变量i，要获取它的值，可以使用@i。

    示例：

    variables
{
  msTimer myTimer; //定义一个定时器变量
  int i = 10; //定义一个整型变量i
}

on key 't'
{
  int j = @i; //使用@符号获取变量i的值，并赋给变量j
  write("The value of i is ", j);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    在上面的示例中，通过@i获取变量i的值，并将其赋给变量j。然后打印出i的值。

    1. 使用$符号获取信号的值：
      在CAPL中，可以使用 符号来获取信号的值。具体的使用方式是 符号来获取信号的值。具体的使用方式是 符号来获取信号的值。具体的使用方式是信号名.信号成员名。例如，假设有一个名为canMessage的CAN消息信号，要获取它的DLC（数据长度）成员的值，可以使用$canMessage.dlc。

    示例：

    variables
{
  message canMessage; //定义一个CAN消息信号
}

on message canMessage
{
  int dlc = $canMessage.dlc; //使用$符号获取canMessage信号的dlc成员的值
  write("DLC value of canMessage is ", dlc);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    在上面的示例中，通过$canMessage.dlc获取canMessage信号的DLC成员的值，并将其赋给变量dlc。然后打印出DLC的值。

    仿真实践

    继续之前的仿真面板设计，打开某一个can加入如下代码，
    如下代码实现的功能为：

    1. 启动阀门，信号接收速度条的速度，并显示到显示数值上
    2. 仪表盘接受信号的速度并显示出来
    3. 数据库环境EnvDoorState接受Door_L和Door_R的信号值，并反应出开关门状态
    /*@!Encoding:936*/
/*@!Encoding:936*/
on sysvar (Engine::EngineStateSwitch|Engine::EngineSpeedEntry)
{
   //将switch的状态传递给信号
  $EngineState::Onoff=@Engine::EngineStateSwitch;
  write("当前的状态为%s",@Engine::EngineStateSwitch);
  //如果为开机的状态，车速为仪表盘上面的速度
  if(@Engine::EngineStateSwitch){
    $EngineState::EngineSpeed=@Engine::EngineSpeedEntry;
    }
  else{
  //否则速度为0
    $EngineState::EngineSpeed=0;
  }
}

on message EngineState
{
  @Engine::EngineSpeedDspMeter=this.EngineSpeed/1000.0;
}

on message DoorState
{

    @EnvDoorState=this.Door_L+this.Door_R*2; 
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    开启运行按钮，打开阀门，拖动速度条和开关门开关，查看状态变化在这里插入图片描述
    在这里插入图片描述
    如实现半仿真，使用如下代码：

    includes
{

}

variables
{
  msTimer doorTimer;//1.声明门毫秒定时器
  msTimer doorCloseTimer;//声明门关毫秒定时器
}

On key 's'
{
  setTimer(doorTimer,1000);//2.设置定时器时长50ms
}

On timer doorTimer//3.定时器事件
{
  message DoorState doormsg;//声明门的报文变量
  doormsg.Door_L=1;//将左门信号设置为1 左开
  doormsg.Door_R=1;//将右门信号设置为1 右开
  output(doormsg);//往总线上发送门的报文
  setTimer(doorTimer,1000);//注意 复位定时器  这样报文才能循环发送
}

on key 'z'  // 当按下键盘s时，打开左后门和右后门的操作
{
  setTimer(doorCloseTimer,100);
}

on Timer doorCloseTimer
{
  message DoorState doorCloseMsg; 
  doorCloseMsg.Door_L = 0;
  doorCloseMsg.Door_R = 0 ;
  write("执行动作: 关闭左后门和右后门!!!");
  output(doorCloseMsg);   // 发送报文
  setTimer(doorCloseTimer,100);
}

On sysvar_update Engine::EngineSpeedEntry
{
  if($EngineState::Onoff)//当引擎开关为1时，引擎转速有显示
  {
    $EngineState::EngineSpeed=@Engine::EngineSpeedEntry/0.25;
    //将EngineSpeedEntry的值除以0.25 赋值 信号EngineSpeed
    //信号EngineSpeed 加权Factor为0.25
  }
  else
  {
    @Engine::EngineSpeedEntry=0;//将滑动条归0
    $EngineState::EngineSpeed=0;//将真实仪表盘引擎转速归0
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    如上代码实现的功能为：使用两个timer循环发送门开关的信号，速度条的变化除以0.25为对应规定的速度信号值。

  • 相关阅读:
    RocketMQ整体架构及NameServer源码分析
    六、鼎捷T100成本计算后自动勾稽查询作业(成本纠错)
    压力大，休息日都没有，更别说年休假了
    GitOps 和 DevOps 有什么区别？
    精灵宝可梦属性克制表（精灵属性相克图）
    【C++初级】2、浮点数计算
    from * import * 和 import *
    [数据结构]单链表(从0-＞1)
    一举两得：研究发现常吃辣椒可延长寿命和抵御寒冷
    关于PCB的工艺注意事项
  • 原文地址：https://blog.csdn.net/m0_48468018/article/details/133847476