#--- cmake.sh ---##!/bin/bash # 自动化编译 c/c++ dir=`pwd` ; echo "欢迎使用自动化汇编程序，当前路径为： $dir" RunAppList[0]="xunhuan" RunAppList[1]="mian" RunAppList[2]="cs" CAppList[0]="xunhuan.c" CAppList[1]="mian.c" CAppList[2]="cs.c" RunApp=${RunAppList[2]} CApp=( ${CAppList[2]} ) touchCMake(){ sudo touch CMakeLists.txt ; sudo chmod 777 CMakeLists.txt ; echo " project(eisc) #项目名 cmake_minimum_required(VERSION 3.10) # 编译要求：cmake 要大于最低版本 3.1 set(CMAKE_C_COMPILER "gcc") set(CMAKE_CXX_COMPILER "g++") # 设置编译器， 如果没有配置环境变量，可以改为gcc具体文件路径 include_directories(a) include_directories(a) # 添加 头文件搜索路径 (mysql.h 搜索路径) add_executable($RunApp ${CApp[*]} ) #add_executable($RunApp ${CApp[*]} ) # 生成可执行文件： 将 test.cpp 编译成 test.exe 可执行文件 # rm -rf ./build ; cmake ./ -Bbuild -G "Unix Makefiles" ; cmake --build build # rm -rf ./build ; cmake ./ -Bbuild ; cmake --build build # 编译到当前目录下的 build 文件夹 # 也可以不用指定 -G " > CMakeLists.txt # 如果 echo 字符串中有 变量，需要加反斜线转义 } autoINCPath(){ incList[0]="include_directories($dir/include/inc/)" incList[1]="include_directories($dir/include/src/)" # 路径为绝对路径，相对路径会报错. 此数组个数与 CMakeLists.txt 中的 include_directories 个数对应 file="CMakeLists.txt" incNumber=`cat -n $file | grep -w include_directories | wc -l` # wc -l 计算个数 if [ "${#incList[*]}" != "$incNumber" ] then echo "$file 文件 include_directories 定义个数 ${#incList[*]} 与 $incNumber 目标修改个数不相等，无法对应修改。" echo "请在 touchCMake 和 autoINCPath 函数， 增加或者 删除 include_directories 关键字个数，以达到与目标修改个数一致。然后重新执行脚本" exit else incI=0; #while : for((;;)) do incNumberList=(`cat -n $file | grep -w include_directories | grep -v okset| awk -F" " '{print $1}' `) Number=${#incNumberList[*]} NR=${incNumberList[0]} if [ "$Number" -lt "1" ] then echo "[ok] 当前绝对路径已经全部修正, 正在执行 CMakeLists.txt 自动化编译。 " break fi echo "[runing] 当前游标：$incI 当前修改行：$NR 当前剩余总修改次数: $Number 文件：$file 所有行：${incNumberList[*]} 目标内容：${incList[$incI]} " sed -i "$NR a ${incList[$incI]} # [eisc.cn_okset]" $file sed -i "$NR d " $file # 始终修改第一个元素，然后由于循环再去查找行号 # 错误方式，删除一行后，其他内容行号会变，因此每次删除，需要重新扫描行号 # [okset] 修改了的地方做标记 let "incI++" # 先获取 0 后，再自动增加。而不是 先增加： 0+1 第一次为 1 sleep 0.01 done fi } touchCMake ; autoINCPath rm -rf ./build ; cmake ./ -Bbuild ; cmake --build build ./build/$RunApp #----- cs.c -----##include <stdio.h> void main(){ int ib=12; int cishu=0; for(;;) { ib--; cishu++; if(ib<1) { printf("\n [ok] 循环结束，当前 ib 值: %d \n",ib); break; } else { printf("\n 循环运行次数: %d",cishu); } } printf("\n 我是 cs.c 程序 \n"); return 0; }

#include<stdio.h> #define MAX #define MAXIMUM(x,y)(x>y)?x:y #define MINIMUM(x,y) (x>y)?y:x // 理解为： if ( x > y ) return y; else return x; // 符号() 判断 ; 问号 ? 条件成立(then) 返回y的值; 冒号 : 条件不成立(else) 返回x int main() { int a=10,b=20; #ifdef MAX printf("已经使用define 定义 MAX 宏 条件成立， 当前板块代码有效 %d\n",MAXIMUM(a,b)); #else printf("没有定义 MAX 当前板块代码无效 %d\n",MINIMUM(a,b)); #endif // endif 结束判断 宏 #ifndef MIN printf("ifndef 判断没有定义弘(多了一个n)， 条件成立，该板块代码有效 MIN %d\n", MINIMUM(a,b)); #else printf("已经定义 MIN 宏， 该板块代码无效 %d\n",MAXIMUM(a,b)); #endif #undef MAX // 取消之前定义的 宏 #ifdef MAX printf("定义有效 %d\n",MAXIMUM(a,b)); #else // else 否则 printf("定义的 MAX 宏 被 undef 取消定义，当前等于没有定义 MAX 宏 %d\n",MINIMUM(a,b)); #endif return 0; }

#include <stdio.h> #include <unistd.h> // sleep 函数包索引 int flag = 0; int flag1 =0; int cishu = 0; int jhcs = 3; // bool 是二进制类型； void test(int bit, int val) { // 由于 main 函数，我得到 数值： 1 1 printf("我是控制灯函数..."); // int const Mask = Bits1_GetMsk(bit); if (val){ printf("c 中的 if 默认条件：当前 val 的值不为空，或者不为0 条件成立 ； 我的值是：%d 等于接收都控制信号" , val); } else { printf("val 为 0 或者 为空， if 的默认条件就不成立"); } } void shanshuo(void) { if (flag == 0) { test(0,1); flag=1; // 因为需要实现 闪灯，一会关一会开，因此开启后关闭，实现闪烁 printf(" \n \n 【当前控制灯为 开】 \n 当前 flag 的值为 0 , 我执行函数 写入 1 开启灯 ； 函数控制硬件后，我将其 设置为1 进行变换 \n \n "); } else { test(0,0); flag=0; // 因为 flag 的值不为 0 ，因此将其赋值为 0 ，等于将 1 变换成 0 ，实现开关作用，闪烁 printf(" \n \n 【当前控制灯为 关】 \n 当前 flag 的值不为 0 , 我执行函数 写入 0 关闭灯 ； 函数控制硬件后，我将其 设置为0 进行变换 \n \n "); } } int main() { while(1) { printf("测试无限循环打印"); usleep(200000); cishu++; printf("当前 得到 次数 ：%d \n" , cishu); shanshuo(); if (cishu > jhcs ) { printf("当前循环执行闪烁次数：%d 已经超过计划次数： %d 现在退出 闪烁功能 \n " , cishu, jhcs); break ; // 退出本函数,或者退出循环 } else { printf("当前已经执行次数： %d \n", cishu); } } printf("循环函数 停止运行了! "); } /* 1．转换说明符 %a(%A) 浮点数、十六进制数字和p-(P-)记数法(C99) %c 字符 %d 有符号十进制整数 %f 浮点数(包括float和double) %e(%E) 浮点数指数输出[e-(E-)记数法] %g(%G) 浮点数不显无意义的零"0" %i 有符号十进制整数(与%d相同) %u 无符号十进制整数 %o 八进制整数 e.g. 0123 %x(%X) 十六进制整数<?xml:namespace prefix = st1 />() e.g. 0x1234 %p 指针 %s 字符串 %% "%" 参考：https://blog.csdn.net/qq_29874741/article/details/94626531 0 0x0f 0xf0 0x08 --> 0000 1000 #define clrSetReg8Bits(RegName, ClrMask, SetMask) f0 08 (RegName = (RegName & ((byte)(~(byte)(ClrMask)))) | (byte)(SetMask)) 存储器： 当前是与非或计算： 由于前面函数传入：参数 0xf0 0x08u (~(byte)(ClrMask)) : f0 非运算： 原值为1 则非计算 为0 ； 再与 0 与计算 有0 为0 ； 再与 | (byte)(SetMask) 或计算 */

#include <iostream> #include <assert.h> using namespace std; // c++ 类 访问控制和继承，能访问的类型： // 同一个类： public protected [prəˈtektɪd] 受保护 private [ˈpraɪvət] 私有 // 派生类：public protected // 外部类：public class A{ public: // 定义类 A 的公共函数 A 和 fun int a; A(){ a1 = 1; a2 = 2; a3 = 3; a = 4; } void fun(){ cout << a << endl; //正确 cout << a1 << endl; //正确 cout << a2 << endl; //正确 cout << a3 << endl; //正确 } public: int a1; protected: int a2; private: int a3; }; class B : public A{ public: // 派生类 int a; B(int i){ A(); a = i; } void fun(){ cout << a << endl; //正确，public成员 cout << a1 << endl; //正确，基类的public成员，在派生类中仍是public成员。 cout << a2 << endl; //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。 // cout << a3 << endl; //错误，基类的private成员不能被派生类访问。 } }; int main(){ B b(10); //外部类，只能访问 public cout << b.a << endl; cout << b.a1 << endl; //正确 // cout << b.a2 << endl; //错误，类外不能访问protected成员 // cout << b.a3 << endl; //错误，类外不能访问private成员 return 0; }

nano eisc.c                                # 编辑c文件#include <stdio.h> // 函数外定义变量 x 和 yint x;int y;int addtwonum(){    // 函数内声明变量 x 和 y 为外部变量    extern int x;    extern int y;    // 给外部变量（全局变量）x 和 y 赋值    x = 1;    y = 2;    return x+y;// 这个函数的最终结果返回  x+y 的值} int main(){    int result;    // 调用函数 addtwonum    result = addtwonum();        printf("result 为: %d",result);    return 0;}

//---- gpio.h ----// #include <stdint.h> // uint 函数 头文件 static uint8_t ddrsum[6] = { 7, 3, 7, 3, 7, 7 }; // const 只读，不允许改变的关键字数组类型 /* static uint64_t gpioNM[] = { 'DDRT', 'DDRM', 'DDRS', 'DDRJ', 'DDRP', 'DDR0AD' }; */ static uint64_t gpioNM[] = { 'T', 'M', 'S', 'J', 'P', 'D' }; // 参数结构体 typedef struct { uint64_t gpioname; uint8_t gpiosum; uint8_t _incAD; uint8_t i; }GPIOtruct; extern GPIOtruct gpio; //---- gpio.c ----// #include <stdio.h> // 标准头文件 #include <stdint.h> // uint_8 头文件 #include <string.h> #include "gpio.h" GPIOtruct gpio; uint64_t PgpioNM[6]; uint8_t Pddrsum[6]; uint8_t counti= sizeof(ddrsum)/sizeof(ddrsum[0]); // 数组总字节大小 除以 第一个字节大小 等于 多少个数组元素 void GetValue(void) // 从 .h 里面获取数组 { uint64_t *pRom, *pRam; uint8_t Cnt = 0; pRom = (uint64_t*)&gpioNM; pRam = (uint64_t*)&PgpioNM; Cnt = counti; while(Cnt--) { *pRam++ = *pRom++; } pRom = (uint8_t*)&ddrsum; pRam = (uint8_t*)&Pddrsum; Cnt = counti; while(Cnt--) { *pRam++ = *pRom++; } } void jisuan(GPIOtruct *_gpio) { _gpio->gpiosum = Pddrsum[_gpio->i]; // 获取个数 _gpio->gpioname = PgpioNM[_gpio->i ]; // 获取名字 uint8_t i = _gpio->gpiosum; // char *p; // p=_gpio->gpioname; // 强制转换变量类型 //strcpy(p, _gpio->gpioname); char *p; p=_gpio->gpioname; for (;;) { if( 0 > i || 255 == i ) { break; } printf( "DDR%s_DDR%s%d=0; \n" ,&p, &p, i ); // 打印： 是指针的内存地址，对应的值 i--; } } int main(int argc, char const *argv[]) { uint8_t i=0; GetValue(); for(;;) { usleep(200000); // 200ms gpio.i=i; if(counti-1<i) // count=6 时 循环7次； 6-1=5 循环6次 { printf("exit! i = %d counti = %d \n \n ",i, counti); break; } else { printf("\n"); } jisuan(&gpio); i++; } return 0; }

在C语言中，当你要传递一个变量的地址而不是变量的值时，你需要使用&操作符。这通常用于传递指针或引用类型的参数。 以下情况下需要使用&操作符： 1. 指针类型： 定义 void foo(int* ptr) 调用 int num = 10; foo(&num); 2. 修改函数外部的变量 void modify(int* ptr){ *ptr = 20; } 调用：int num = 10; modify(&num); 最终将 ptr修改为 10 3. 输入 scanf 函数 int num; scanf("%d", &num); 传递的是基本类型的变量或者数组时，不需要使用&操作符，因为它们会被自动传递为值。例如，`void foo(int num)`，你可以直接传递变量的值来调用它，例如`int num = 10; foo(num);`。 需要注意的是，使用&操作符传递变量的地址时，需要确保接收参数的函数能够处理指针类型的参数。

如果要存储超长的文本数据，可以考虑使用动态内存分配来存储文本。在C语言中，可以使用malloc函数来动态分配内存空间，并使用char类型的指针来存储文本数据。 下面是一个示例代码，展示了如何使用动态内存分配来存储超长的文本数据： #include <stdio.h> #include <stdlib.h> int main() { // 假设文本数据长度为10000 int length = 10000; // 动态分配内存空间 char* text = (char*)malloc(length * sizeof(char)); // 检查内存分配是否成功 if (text == NULL) { printf("Failed to allocate memory\n"); return 1; } // 读取文本数据到动态分配的内存空间中 // 这里使用fgets函数从文件中读取文本数据 FILE* file = fopen("text.txt", "r"); if (file == NULL) { printf("Failed to open file\n"); free(text); // 释放动态分配的内存空间 return 1; } fgets(text, length, file); // 关闭文件 fclose(file); // 打印文本数据 printf("%s\n", text); // 释放动态分配的内存空间 free(text); return 0; } 上述代码中，我们首先使用malloc函数动态分配了一个长度为length的字符数组，并将返回的指针赋值给text。然后，我们使用fgets函数从文件中读取文本数据并存储到动态分配的内存空间中。最后，我们使用printf函数打印出文本数据。

在C语言中，可以使用printf函数来打印不同类型的数值。下面是一些常见的数据类型及其对应的printf格式说明符： 整数类型： int %d short %hd long %ld long long %lld 无符号整数类型： unsigned int %u unsigned short %hu unsigned long %lu unsigned long long %llu 字符类型： char %c 浮点数类型： float %f double %lf 指针类型： void* %p 以下是示例代码，展示如何使用printf打印不同类型的数值： #include <stdio.h> int main() { int num1 = 10; float num2 = 3.14; char ch = 'A'; char str[] = "Hello"; printf("Integer: %d\n", num1); printf("Float: %f\n", num2); printf("Character: %c\n", ch); printf("String: %s\n", str); return 0; } 在上述示例中，我们定义了一个整数变量num1，一个浮点数变量num2，一个字符变量ch，以及一个字符串数组str。 然后，我们使用printf函数打印了这些变量的值，分别使用了对应的格式说明符。执行上述代码后，将会打印出相应的数值。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <netinet/in.h> #include <netinet/ip.h> #include <netinet/tcp.h> #include <netinet/udp.h> #include <netinet/ip_icmp.h> #define BUFFER_SIZE 4096 void process_packet(unsigned char *buffer, int size) { struct iphdr *ip_header = (struct iphdr *)(buffer); unsigned short ip_header_length = ip_header->ihl * 4; struct tcphdr *tcp_header = (struct tcphdr *)(buffer + ip_header_length); unsigned short tcp_header_length = tcp_header->doff * 4; unsigned char *payload = buffer + ip_header_length + tcp_header_length; int payload_length = size - ip_header_length - tcp_header_length; // 在这里处理报文内容，可以打印报文信息或对报文进行其他操作 printf("Received packet with size: %d\n", size); } int main() { int raw_socket; unsigned char buffer[BUFFER_SIZE]; struct sockaddr_in server_address; int data_size; // 创建原始套接字 raw_socket = socket(AF_INET, SOCK_RAW, IPPROTO_TCP); if (raw_socket < 0) { perror("Failed to create socket"); return 1; } // 绑定地址 server_address.sin_family = AF_INET; server_address.sin_port = 0; server_address.sin_addr.s_addr = INADDR_ANY; if (bind(raw_socket, (struct sockaddr *)&server_address, sizeof(server_address)) < 0) { perror("Failed to bind"); return 1; } // 开始监听 while (1) { data_size = recvfrom(raw_socket, buffer, BUFFER_SIZE, 0, NULL, NULL); if (data_size < 0) { perror("Failed to receive"); return 1; } process_packet(buffer, data_size); } return 0; }

在C语言中，一个文件可以使用不同的编码格式。如果您想将文件从其他编码格式转换为UTF-8编码格式，可以使用以下步骤： 确定原始文件的编码格式。可以使用文本编辑器或专门的编码检测工具来完成。 在C语言中打开原始文件，并使用适当的编码格式读取文件内容。 创建一个新的UTF-8编码格式的文件，并将读取的内容写入该文件中。在写入过程中，必须确保将原始编码格式转换为UTF-8编码格式。 关闭原始文件和新文件，完成文件转换。 下面是一个示例程序，用于将一个以GB2312编码格式保存的文件转换为UTF-8编码格式： #include <stdio.h> #include <stdlib.h> #include <locale.h> int main() { // 设置本地化环境 setlocale(LC_ALL, ""); // 打开原始文件 FILE* fp_in = fopen("input.txt", "rb"); if (!fp_in) { printf("无法打开原始文件\n"); return 1; } // 打开新文件 FILE* fp_out = fopen("output.txt", "wb"); if (!fp_out) { printf("无法创建新文件\n"); return 1; } // 逐个读取原始文件中的字符，并将其转换为UTF-8格式写入新文件中 int ch; while ((ch = fgetc(fp_in)) != EOF) { wchar_t wc = (wchar_t)ch; char utf8[4]; int len = 0; if (wc < 0x80) { utf8[0] = (char)wc; len = 1; } else if (wc < 0x800) { utf8[0] = (char)(0xc0 | (wc >> 6)); utf8[1] = (char)(0x80 | (wc & 0x3f)); len = 2; } else if (wc < 0x10000) { utf8[0] = (char)(0xe0 | (wc >> 12)); utf8[1] = (char)(0x80 | ((wc >> 6) & 0x3f)); utf8[2] = (char)(0x80 | (wc & 0x3f)); len = 3; } else if (wc < 0x110000) { utf8[0] = (char)(0xf0 | (wc >> 18)); utf8[1] = (char)(0x80 | ((wc >> 12) & 0x3f)); utf8[2] = (char)(0x80 | ((wc >> 6) & 0x3f)); utf8[3] = (char)(0x80 | (wc & 0x3f)); len = 4; } fwrite(utf8, 1, len, fp_out); } // 关闭文件 fclose(fp_in); fclose(fp_out); printf("文件转换完成！\n"); return 0; } 请注意，这只是一个示例程序，您需要根据您的具体需求进行修改和调整。同时，该程序只支持将单个字符从其他编码格式转换为UTF-8编码格式，如果文件中包含多字节字符或复杂字符集，您可能需要使用其他更加复杂的算法来完成转换。

#include <stdio.h> #include <stdint.h> // 32 位 头文件 // c 语言 if 比较符+运算符 static uint32_t a; // static 静态，1. 隐藏：不能跨文件使用，2. 存储在静态存储区：全局变量 和 static 变量(和全局变量一些写入内存跨函数可读) static uint32_t b; // 作用：3. 默认初始化为 0 int functionTest() { a = 0x00000800; b = 0x00000400; if(0x00000100>a | 0x00000100>b) // 先判断 左右两边任意一个成立， 再进行变量想或计算，再判断相或 是否大于0 { printf("++++++++++++++++++ \n "); } else { printf("------------------"); } return 0; } int main() { printf("\n 第一次: a=%lx \n",a ); functionTest(); // 执行函数后，可以获取该函数中 变量的值 printf("\n 第二次: a=%lx \n",a ); // 中的 x 是16进制，l意思是长整型十六进制 }

结构体成员： 为变量只能定义一个字符，定义为指针 可以存放多个字符（字符串）#include <stdio.h> struct Foo { char *a; // 指针可以存放多个字符串，变量只能存一个 int b; double c; }foo1, foo2; //define two structs with three different fields void struct_assign(void) { foo2 = foo1; //structure directly assignment } int main() { foo1.a = "eisc is 结构体字符串 "; foo1.b = 1; foo1.c = 3.14; struct_assign(); // 函数 将结构体 1 赋值 给 2 printf("%s %d %lf\n", foo2.a, foo2.b, foo2.c); // 写入的是 1 读取的是 2 ， 由于前赋值相等原因 1 和 2 相等 return 0; }

#----------------- Canoe 使用 ------------------------# 1. 打开 Canoe -> 将日志 blf 拖进 Trace -> 导入数据库 ： 顶部 View -> Simulation Set up -> Networkks -> CAN Networks -> -> CAN -> Databases -> 鼠标右键 Add -> 导入 DBC 文件 2. 导入dbc 和设置离线 顶部设置: View -> Measurement Setup -> 右键将 Online 切换到 Offline 离线 -> -> 底部 Configuration -> Logging 双击 CANOE 选择输出文件路径 -> -> 导入dbc 顶部 或 View 中的 Simulation -> Simulation Setup 右边can databases 导入数据库 3. 添加Graphics窗口：顶部 Analysis – Graphics 或 顶部 View -> Graphics 添加信号：Graphics窗口 -> name 栏 鼠标右键 -> Add Signal 右边有望远镜搜索 点击 双曲线 -> 点击 右边倒数第4个图形下拉框，选择 多个不重叠 设置后，点击 Start 启动#-------- CANoe 安装 ------# # 作用： 分析Pcan 抓的日志，将 dbf 转换之前的 dbc 数据库导入分析日志 1. 下载地址： CANoe10.0.rar 注意： 建议安装 CANoe10.0 , 因为 CANoe8.0 安装有问题 解压后 -> 点击 autorun.exe -> 提示缺少包，点击下一步会自动安装 -> 等待提示安装窗口结束，然后退出初始安装窗口 Exit -> 被遮挡的 填写注册码安装窗口，输入下面信息，进行安装。 如果出现 处理 .net 一直没动，继续等待。可能磁盘读写速度慢。 或者重新安装 填写注册码： Chongqing University of Posts Key:YNS2-EI6W-HW3W-VDMS-8PPB-5EP4-SILS-1DG6 Serial Number:50000022992 #-------- CANoe 使用 ------# 打开 CANoe ，目录：CANoe\Exec64\CANoe64.exe 最大化软件窗口 1. 导入日志文件： -> 在初始窗口 Trace 将日志文件 拖动到 Trace 窗口 -> 点击左下角 Configuration -> 在窗口 Measurement Setup 界面 点击 online 切换到 Offline 离线模式； 最左边第一个图(类似文件桶) -> 双击或右键 -> Show Window -> -> 弹出 Lost of log files to be played 或者 Offline Mode 界面 -> 点击 + 号 Add Logging 导入日志 ALL.asc 文件; 如果需要重新添加 需要x掉之前的 2. 导入 dbc 数据库： -> 点击左下角 Configuration -> 在窗口 Simulation Setup -> Networks -> CAN Networks -> CAN -> Databases -> 鼠标右键 Add -> 打开 dbc 数据库文件(参数定义文件，与 参数定义表相似) -> -> 在 Measurement Setup 界面 -> 右键点击 Online 切换到 Offine 离线模式 3. 分析日志： -> 点击导航栏 Start -> 点击导航栏底部 -> Analysis -> 最大化 Graphics 图像化窗口 -> 左边状态栏 右键点击 Add Signals... -> DBC_COCAN_V11_20220810 -> Frames -> IPK_STS -> IPK_EPS_IMCorrelativeMode -> ok

信号由: 名称 name + 信号的数值 status 1 开 0 关等等。 B: Byte: 字节 8 位无符号数 范围 0-255 b: bit: 位 二进制中每个 0 或 1 就是一个位 bit 位说明： 从右 0 开始 向左数 最大为 7 即 0-7 表示 ： 7 6 5 4 3 2 1 0 位置 #--- 编码：UTF8 ---# 1个汉字 = 3B = 3x8b = 24b 1个字母 = 1B = 1x8b = 8b 1个数字 = 1B = 1x8b = 8b 计算公式： 2^N - 1 uint8_t : 1 占用1位，0或1 最大 1 转换2进制 1 uint8_t : 2 占用2位，0到3之间的整数 最大 3 转换2进制 11 uint8_t : 3 占用3位，0到7 最大 7 转换2进制 111 = 2^3-1 = 8-1=7 uint8_t : 4 占用4位，0到15 最大 15 转换2进制 1111 uint8_t : 5 占用5位，0到31 uint8_t : 6 占用6位，0到63 uint8_t : 7 占用7位，0到127 在上一位的基础上 x2-1 最多只能表示 8 位二进制数 ，超过8位无效，可以换成 uint16_t 等 （由 10转2进制得来长度 如 7 转2 为 111 占3位） data->name = (can2A5[2]&0x07); // 最大为 111 即 7 即 0x07 但是根据矩阵表 最大为 3 即 二进制 11 模式 为 0 1 2 3 对应吹面，吹面吹脚，吹脚,吹脚吹窗，吹窗 // can2A5报文中 的 第二个字节监听后 (0x07 是16进制 转换2进制为 111 占3位二进制内存 3bit) 三位二进制 data->name = (can2A5[3]&20)>>5 // 此处不是进行与计算，而 20 换算成二进制 0001 0100 占用5位二进制有效 向右移动五位，也就是去掉右边的5位，等于 第6位的结果，就是它的值 起始字节(Start Byte) = 3 ; 起始位(Start Bit) =7 ; 长度(len) =3 =111 = 7 (长度为3 最大为7); 占位：从左第7位开始往右数到0为止 ; 此处表示：从第3字节的第7位开始右数3位），最大 111， 最小000 表示： 最大：1110 0000 表示1为 0010 0000 数值：从右往左读取后计算 长度3= 111 = 7 数据类型 占用空间 表示范围 说明 uint8_t 8b = 1B 0 到 255 占8位(单位 b) = 占1字节 (单位 B) 8 为由来： 255转二进制：1111 1111 为8 位 uint16_t 16b = 2B 0 到 65535 65535 转 二进制： 1111 1111 1111 1111 正好 16 位 uint32_t 32b = 4B 0 到 4294967295 uint64_t 64b = 8B 0 到 18446744073709551615 占 64 位 = 8 字节 #------- 结构体写入和读取方法 -----------# uint8_t eisc2F1[7]; // 定义 数组为 uint8_t 是 8位类型，但数组有8个元素（从0开始），因此 有8个 8位的类型。 因为 8位=1字节，因此该数组有8个字节大小 typedef struct { uint8_t lock; }eiscdataJGT; // 定义结构体 eiscdataJGT extern eiscdataJGT eiscdata; // 将结构体 eiscdataJGT 写入到内存变量结构体 eiscdata ，可以通过 eiscdata.lock 读取和赋值 eiscdataJGT eiscdata; // 其他c文件声明结构体才能使用结构体变量 void eisc(eiscdataJGT *eisczz){ // 将结构体 继承给指针，可以通过指针方式进行读取和赋值到原结构体 eisczz->lock = (eisc2F1[4]&0x30)>>4; // 最大3: 0x30=0011 0000 右移 4位 0000 0011=3 ，原信号在第五位开始有效。 // 并且 该信号占第5和第6 两位长度二进制 11 ，因此就在第五位。 第五位为1： 1 0000 （状态 1开 ，0关） printf("信号的数值为：%d",eiscdata.lock); // 读取结构体变量的数值 } 8位原始数据： 0000 0000 对应顺序：7 6 5 4 3 2 1 0； 右移：从右往左数； 左移：从左往右数 eisca[0]=0x20; // 内外循环：eiscdata->_fr = (eisca[0]&0x20)>>5; // 最大为1: 0x20=0010 0000 右移 5 位 0000 0001=1 目前在第6位上发送了最大值 1 表示开启： 0010 0000 = 0x20 按键按下是外循环 eiscf[3]=0x80; // 洗涤开 : eiscdata->xidi = (eiscf[3]&0x80)>>7; // 最大为1： 0x80=1000 0000 右移 7 位 0000 0001=1 目前在第7位上发送了最大值 1 表示开启： 1000 0000 = 0x80 eisc87[6]=0x3E; // 天窗开度 eiscdata->eisctc = (eisc87[6]&0xFE)>>1; // 最大为：0xFE=1111 1110 右移1位 0111 1111=127 目前在第2到7位上发送了 0x3E = 0011 1110 = 62; 62/2=31 结果除以为 31度 eisca[3]=0x34; // 蓝牙信号：eiscdata->eisctx = (eisca[3]&0x20)>>5; // 最大1： 0x20=0010 0000 右移5位 0000 0001 目前在第6位发送信号：0010 0000 + 下面设定温度20度组合 // eiscc_temp // 空调设定温度： eiscdata->eisc_temp = (eisctemp[3]&0x1F); // 最大为31： 0x1F=0001 1111=31 占用 1-5 位 ； 设定温度20度=0001 0100 与蓝牙信号 0010 0000 组合(相或)为：0011 0100=0x34 长度 信号位置 eisctemp 1 4 第4位，占一位