【嵌入式模块芯片开发】DWIN的T5L _DGUS应用开发 显示屏的基本图形显示以及串口命令的动态数据波形功能实现

2024-05-29 12:04
文章标签 模块 实现 应用 命令 显示 功能 开发 基本 芯片 串口 嵌入式 图形 波形 显示屏 动态数据 dwin t5l dgus

本文主要是介绍【嵌入式模块芯片开发】DWIN的T5L _DGUS应用开发 显示屏的基本图形显示以及串口命令的动态数据波形功能实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

【嵌入式模块芯片开发】DWIN的T5L _DGUS应用开发 显示屏的基本图形显示以及串口命令的动态数据波形功能实现

T5L _DGUS应用在DWIN的各类显示屏中 如DMG80480T070_05WTR等等
可用DWIN官方工具生成一系列上位机显示控件 通过串口命令进行交互实现显示、触摸等功能
也可以进行C51代码编程 直接操作屏幕

文章目录

  • T5L _DGUS的串口数据结构
  • 显示变量配置
  • 端点连线的解析代码实现
  • 数据的屏幕像素转换与波形绘制
  • 波形旧数据后移、新数据固定显示的动态波形实现
  • 完整代码
  • 附录：压缩字符串、大小端格式转换
    • 压缩字符串
      • 浮点数
      • 压缩Packed-ASCII字符串
    • 大小端转换
      • 什么是大端和小端
      • 数据传输中的大小端
      • 总结
      • 大小端转换函数

T5L _DGUS的串口数据结构

参考资料：

《基于T5L ASIC的串口指令屏开发指南Ver1.4》
基于T5L ASIC 的串口指令屏（TA），主要特点包括：
（1）基于 T5L 双核 CPU，GUI 和OS核均运行在200MHz主频，功耗极低。
（2）24bit 真彩色显示，最大分辨率支持19201080。
（3）16Mbytes 低成本SPI Flash，JPEG 图片、图标压缩存储，可以指定背景图片存储空间大小。
（4）SD/SDHC 接口下载和配置。
（5）支持置点、连线、区域填充等基本绘图操作。
（6）支持文本、图标、图片、二维码等基本UI显示。
（7）图片或图标按照UI的分辨率设计，不需要处理成和屏的物理分辨率一致。
比如，把分辨率800480 的横屏竖用，设置显示偏转90°，然后图片直接按照480800分辨率设计即可。
（8）电阻触摸屏自动识别误差并动态校正，使用中无需额外校准，避免误操作。
（9）软件接口采用《迪文HMI（工业串口屏）指令集》。
（10）可以开放OS CPU核用于客户二次开发，包括4UARTs、20IOs、1CAN、2或6* 12bit AD、1PWM、64Kbytes
Flash、320KB RAM。
（11）从M600、K600+、T5UIC2 平台移植到T5L TA指令集平台步骤：
（a）把所有的背景图片放到一个文件夹，使用DGUS3工具软件，处理成一个最大不超过12MB的ICL文件，并
相应编号（图片文件编号从16-48，对应的图片空间从12MB到4MB）。
（b）把需要的字库下载（ASCII 字库如果只用到 1632，那么 0#字库只用到前 2 个字库空间），字库编号超过
24 的，需要注意不要和背景文件占用空间冲突，注意0x98指令相应代码修改。
（c）把图标用DGUS3工具软件压缩成ICL文件，编号00-63放在空余的地方，注意修改0x97指令相应代码。
（d）配置好CFG文件。
（e）用SD卡把这些文件更新到屏里面，注意一定是 断电、插卡、再上电 才能升级。

T5L _DGUS的串口数据基本结构体如下：

//Size=len(CMD+Value_Add+Data)=len(Data)+3      All_Len=Size+3
#pragma pack(1)
typedef struct
{uint8_t Head[2];uint8_t Size;uint8_t CMD;uint8_t Value_Add[2];uint8_t Data[249];
}T5L_DGUS_Struct;
#pragma pack()

在这里插入图片描述
所有数据均为小端格式

结构体发送函数为：

uint8_t T5L_DGUS_Send(T5L_DGUS_Struct Stu,uint8_t * buf)
{memcpy(&buf[0],&Stu,Stu.Size+3);uint8_t i=0;for(i=0;i<Stu.Size+3;i++){printf("%02X ",buf[i]);}    return 1;
}

这里的printf只是为了方便开发 实际在MCU中 改成专门的串口发送函数

显示变量配置

在T5L _DGUS II 应用开发指南中可以看到显示变量配置功能：

在这里插入图片描述
其中有一个图形变量 下含基本图像显示
在这里插入图片描述
其控件需要再DWIN软件中进行配置
在这里插入图片描述
配置好后 可以通过串口命令进行控制

在这里插入图片描述
这里 我们用到的是端点连线命令 用于进行数据波形的动态显示

端点连线的解析代码实现

端点连续示例如图所示
在这里插入图片描述
端点连线部分结构体：

#pragma pack(1)
typedef struct
{uint8_t X[2];uint8_t Y[2];
}T5L_DGUS_Base_Graph_Location_Struct;
#pragma pack()//P2P_Size=len(Location)-1  P2P_Data_Len=8+len(Location)*4=(P2P_Size+1)*4+8
#pragma pack(1)
typedef struct
{uint8_t P2P_CMD[2];uint8_t P2P_Size[2];uint8_t Color[2];T5L_DGUS_Base_Graph_Location_Struct Location[15];uint8_t End[2];
}T5L_DGUS_Base_Graph_P2P_Data_Struct;
#pragma pack()

P2P_Size是线段数
一条线段需要两个断点才能确定
所以对应的点坐标组数为P2P_Size-1

点坐标类型为uint16_t的X、Y
所以可以定义一个小端格式的坐标转换函数
用于坐标转换
比如：

#pragma pack(1)
typedef struct
{uint16_t X;uint16_t Y;
}Location_Struct;
#pragma pack()
uint8_t i=0;for(i=0;i<P2P_Size+1;i++){P2P_Stu.Location[i].X[0]=Location[i].X>>8;P2P_Stu.Location[i].X[1]=Location[i].X&0xFF;P2P_Stu.Location[i].Y[0]=Location[i].Y>>8;P2P_Stu.Location[i].Y[1]=Location[i].Y&0xFF;}

完整代码为：

T5L_DGUS_Struct T5L_DGUS_Base_Graph_P2P_Trans(Location_Struct *Location,uint16_t P2P_Size,uint16_t Color)
{T5L_DGUS_Struct Stu={T5L_DGUS_Head0,T5L_DGUS_Head1,(P2P_Size+1)*4+11,T5L_DGUS_CMD_Write,T5L_DGUS_Base_Graph_Value_Add0,T5L_DGUS_Base_Graph_Value_Add1};T5L_DGUS_Base_Graph_P2P_Data_Struct P2P_Stu={0};P2P_Stu.P2P_CMD[0]=T5L_DGUS_Base_Graph_P2P_Data_CMD0;P2P_Stu.P2P_CMD[1]=T5L_DGUS_Base_Graph_P2P_Data_CMD1;P2P_Stu.P2P_Size[0]=P2P_Size>>8;P2P_Stu.P2P_Size[1]=P2P_Size&0xFF;P2P_Stu.Color[0]=Color>>8;P2P_Stu.Color[1]=Color&0xFF;P2P_Stu.End[0]=T5L_DGUS_Base_Graph_P2P_Data_End0;P2P_Stu.End[1]=T5L_DGUS_Base_Graph_P2P_Data_End1;uint8_t i=0;for(i=0;i<P2P_Size+1;i++){P2P_Stu.Location[i].X[0]=Location[i].X>>8;P2P_Stu.Location[i].X[1]=Location[i].X&0xFF;P2P_Stu.Location[i].Y[0]=Location[i].Y>>8;P2P_Stu.Location[i].Y[1]=Location[i].Y&0xFF;}memcpy(&Stu.Data[0],&P2P_Stu,(P2P_Size+1)*4+6);memcpy(&Stu.Data[(P2P_Size+1)*4+6],&P2P_Stu.End[0],2);return Stu;
}

数据的屏幕像素转换与波形绘制

我用的屏幕为800*480的
左上角坐标为0 0
我将屏幕横竖都分成10份（对应有11个标识点）
就能同时显示11个数据 每个数据的范围为0-10
数据坐标转换函数为：

//X: 0:100 10:700       X=i*60+100
//Y: 10:40 0:440        Y=440-40.0f*v
Location_Struct Value_to_Location(uint8_t i,float value,float min,float max)
{Location_Struct Stu;if(i>10){i=10;}Stu.X=i*70+50;if (value>max){value=max;}if (value<min){value=min;}Stu.Y=440.0f-400.0f/(max-min)*(value-min);return Stu;
}

在绘制波形时 可以先将第一个点位与原点连接（或者其他原点） 然后接着连接第2个 一直到第11个
加上原点的话 最多同时显示12个点的坐标
由于每次屏幕执行一个命令时 会将之前绘制的图像重置掉 所以每次增加点的显示都需要将先前的点位和线段累加上去

测试函数如下：

int main()
{uint8_t i=0;float value[11]={2.2,1.3,5,7,6,9,10,0,5,4.4,5.6};uint8_t buf[250];Location_Struct Lo_Stu[12];Lo_Stu[0].X=0;Lo_Stu[0].Y=440;for(i=0;i<11;i++){Lo_Stu[i+1]=Value_to_Location(i,value[i],0,10);T5L_DGUS_Struct Stu=T5L_DGUS_Base_Graph_P2P_Trans(Lo_Stu,i+1,T5L_DGUS_Base_Graph_P2P_Data_Color);T5L_DGUS_Send(Stu,buf);printf("\n");}return 0;
}

输出结果：

5A A5 13 82 54 40 00 02 00 01 F8 00 00 00 01 B8 00 32 01 60 FF 00 
5A A5 17 82 54 40 00 02 00 02 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 FF 00 
5A A5 1B 82 54 40 00 02 00 03 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 FF 00 
5A A5 1F 82 54 40 00 02 00 04 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 FF 00 
5A A5 23 82 54 40 00 02 00 05 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 01 4A 00 C8 FF 00 
5A A5 27 82 54 40 00 02 00 06 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 01 4A 00 C8 01 90 00 50 FF 00 
5A A5 2B 82 54 40 00 02 00 07 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 01 4A 00 C8 01 90 00 50 01 D6 00 28 FF 00 
5A A5 2F 82 54 40 00 02 00 08 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 01 4A 00 C8 01 90 00 50 01 D6 00 28 02 1C 01 B8 FF 00 
5A A5 33 82 54 40 00 02 00 09 F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 01 4A 00 C8 01 90 00 50 01 D6 00 28 02 1C 01 B8 02 62 00 F0 FF 00 
5A A5 37 82 54 40 00 02 00 0A F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 01 4A 00 C8 01 90 00 50 01 D6 00 28 02 1C 01 B8 02 62 00 F0 02 A8 01 08 FF 00 
5A A5 3B 82 54 40 00 02 00 0B F8 00 00 00 01 B8 00 32 01 60 00 78 01 84 00 BE 00 F0 01 04 00 A0 01 4A 00 C8 01 90 00 50 01 D6 00 28 02 1C 01 B8 02 62 00 F0 02 A8 01 08 02 EE 00 D8 FF 00

波形动态效果：

https://www.bilibili.com/video/BV1Mf42197KN/

波形旧数据后移、新数据固定显示的动态波形实现

为了更加直观展示新数据 每次获取到数据后 将老的数据波形整体后移

那么就需要在MCU中进行数据保存 且保存至少11组数据
可以做如下操作：

 while(1){/* add user code begin 3 */i++;printf("[INFO] %u\n",i);Ctrl_A121_Read();	//读取数据for(j=0;j<11;j++){				T5L_DGUS_Lo_Stu[j].Y=T5L_DGUS_Lo_Stu[j+1].Y;if(j==0){T5L_DGUS_Lo_Stu[j].X=0;}else{T5L_DGUS_Lo_Stu[j].X=T5L_DGUS_Lo_Stu[j+1].X-70;}				}Lo_Stu=T5L_DGUS_Value_to_Location(11,distance,0,10);  //转换新数据T5L_DGUS_Lo_Stu[11]=Lo_Stu;			T5L_DGUS_Send(T5L_DGUS_Base_Graph_P2P_Trans(T5L_DGUS_Lo_Stu,11,T5L_DGUS_Base_Graph_P2P_Data_Color),&T5L_DGUS_Buf[0]);delay_ms(read_time_ms);}

完整代码

#include<stdio.h>
#include<stdint.h>
#include<string.h>
#include <stdio.h>
#include <string.h>
#include "T5L_DGUS.h"T5L_DGUS_Struct T5L_DGUS_Base_Graph_P2P_Trans(Location_Struct *Location,uint16_t P2P_Size,uint16_t Color)
{T5L_DGUS_Struct Stu={T5L_DGUS_Head0,T5L_DGUS_Head1,(P2P_Size+1)*4+11,T5L_DGUS_CMD_Write,T5L_DGUS_Base_Graph_Value_Add0,T5L_DGUS_Base_Graph_Value_Add1};T5L_DGUS_Base_Graph_P2P_Data_Struct P2P_Stu={0};P2P_Stu.P2P_CMD[0]=T5L_DGUS_Base_Graph_P2P_Data_CMD0;P2P_Stu.P2P_CMD[1]=T5L_DGUS_Base_Graph_P2P_Data_CMD1;P2P_Stu.P2P_Size[0]=P2P_Size>>8;P2P_Stu.P2P_Size[1]=P2P_Size&0xFF;P2P_Stu.Color[0]=Color>>8;P2P_Stu.Color[1]=Color&0xFF;P2P_Stu.End[0]=T5L_DGUS_Base_Graph_P2P_Data_End0;P2P_Stu.End[1]=T5L_DGUS_Base_Graph_P2P_Data_End1;uint8_t i=0;for(i=0;i<P2P_Size+1;i++){P2P_Stu.Location[i].X[0]=Location[i].X>>8;P2P_Stu.Location[i].X[1]=Location[i].X&0xFF;P2P_Stu.Location[i].Y[0]=Location[i].Y>>8;P2P_Stu.Location[i].Y[1]=Location[i].Y&0xFF;}memcpy(&Stu.Data[0],&P2P_Stu,(P2P_Size+1)*4+6);memcpy(&Stu.Data[(P2P_Size+1)*4+6],&P2P_Stu.End[0],2);return Stu;
}uint8_t T5L_DGUS_Send(T5L_DGUS_Struct Stu,uint8_t * buf)
{memcpy(&buf[0],&Stu,Stu.Size+3);uint8_t i=0;for(i=0;i<Stu.Size+3;i++){printf("%02X ",buf[i]);}    return 1;
}//X: 0:100 10:700       X=i*60+100
//Y: 10:40 0:440        Y=440-40.0f*v
Location_Struct Value_to_Location(uint8_t i,float value,float min,float max)
{Location_Struct Stu;if(i>10){i=10;}Stu.X=i*70+50;if (value>max){value=max;}if (value<min){value=min;}Stu.Y=440.0f-400.0f/(max-min)*(value-min);return Stu;
}int main()
{uint8_t i=0;float value[11]={2.2,1.3,5,7,6,9,10,0,5,4.4,5.6};uint8_t buf[250];Location_Struct Lo_Stu[12];Lo_Stu[0].X=0;Lo_Stu[0].Y=440;for(i=0;i<11;i++){Lo_Stu[i+1]=Value_to_Location(i,value[i],0,10);T5L_DGUS_Struct Stu=T5L_DGUS_Base_Graph_P2P_Trans(Lo_Stu,i+1,T5L_DGUS_Base_Graph_P2P_Data_Color);T5L_DGUS_Send(Stu,buf);printf("\n");}return 0;
}
#ifndef _T5L_DGUS_H_
#define _T5L_DGUS_H_
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <string.h>#define T5L_DGUS_Head           0x5AA5
#define T5L_DGUS_Head0          (uint8_t)(T5L_DGUS_Head>>8)
#define T5L_DGUS_Head1          (uint8_t)(T5L_DGUS_Head&0xFF)#define T5L_DGUS_CMD_Write      0x82
#define T5L_DGUS_CMD_Read       0x83#define T5L_DGUS_Base_Graph_Value_Add   0x5440
#define T5L_DGUS_Base_Graph_Value_Add0  (uint8_t)(T5L_DGUS_Base_Graph_Value_Add>>8)
#define T5L_DGUS_Base_Graph_Value_Add1  (uint8_t)(T5L_DGUS_Base_Graph_Value_Add&0xFF)#define T5L_DGUS_Base_Graph_P2P_Data_CMD    0x0002
#define T5L_DGUS_Base_Graph_P2P_Data_CMD0    (uint8_t)(T5L_DGUS_Base_Graph_P2P_Data_CMD>>8)
#define T5L_DGUS_Base_Graph_P2P_Data_CMD1    (uint8_t)(T5L_DGUS_Base_Graph_P2P_Data_CMD&0xFF)#define T5L_DGUS_Base_Graph_P2P_Data_Color  0xF800#define T5L_DGUS_Base_Graph_P2P_Data_End    0xFF00
#define T5L_DGUS_Base_Graph_P2P_Data_End0    (uint8_t)(T5L_DGUS_Base_Graph_P2P_Data_End>>8)
#define T5L_DGUS_Base_Graph_P2P_Data_End1    (uint8_t)(T5L_DGUS_Base_Graph_P2P_Data_End&0xFF)//Size=len(CMD+Value_Add+Data)=len(Data)+3      All_Len=Size+3
#pragma pack(1)
typedef struct
{uint8_t Head[2];uint8_t Size;uint8_t CMD;uint8_t Value_Add[2];uint8_t Data[249];
}T5L_DGUS_Struct;
#pragma pack()#pragma pack(1)
typedef struct
{uint16_t X;uint16_t Y;
}Location_Struct;
#pragma pack()#pragma pack(1)
typedef struct
{uint8_t X[2];uint8_t Y[2];
}T5L_DGUS_Base_Graph_Location_Struct;
#pragma pack()//P2P_Size=len(Location)-1  P2P_Data_Len=8+len(Location)*4=(P2P_Size+1)*4+8
#pragma pack(1)
typedef struct
{uint8_t P2P_CMD[2];uint8_t P2P_Size[2];uint8_t Color[2];T5L_DGUS_Base_Graph_Location_Struct Location[15];uint8_t End[2];
}T5L_DGUS_Base_Graph_P2P_Data_Struct;
#pragma pack()#endif

附录：压缩字符串、大小端格式转换

压缩字符串

首先HART数据格式如下：
在这里插入图片描述
在这里插入图片描述
重点就是浮点数和字符串类型
Latin-1就不说了 基本用不到

浮点数

浮点数里面 如 0x40 80 00 00表示4.0f

在HART协议里面 浮点数是按大端格式发送的 就是高位先发送 低位后发送

发送出来的数组为：40,80,00,00

但在C语言对浮点数的存储中 是按小端格式来存储的 也就是40在高位 00在低位
浮点数：4.0f
地址0x1000对应00
地址0x1001对应00
地址0x1002对应80
地址0x1003对应40

若直接使用memcpy函数 则需要进行大小端转换 否则会存储为：
地址0x1000对应40
地址0x1001对应80
地址0x1002对应00
地址0x1003对应00

大小端转换：

void swap32(void * p)
{uint32_t *ptr=p;uint32_t x = *ptr;x = (x << 16) | (x >> 16);x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);*ptr=x;
}

压缩Packed-ASCII字符串

本质上是将原本的ASCII的最高2位去掉 然后拼接起来 比如空格(0x20)
四个空格拼接后就成了
1000 0010 0000 1000 0010 0000
十六进制：82 08 20
对了一下表 0x20之前的识别不了
也就是只能识别0x20-0x5F的ASCII表
在这里插入图片描述

压缩/解压函数后面再写：

//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_ASCII_to_Pack(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{if(str_len%4){return 0;}uint8_t i=0;memset(buf,0,str_len/4*3);	  for(i=0;i<str_len;i++){if(str[i]==0x00){str[i]=0x20;}}for(i=0;i<str_len/4;i++){buf[3*i]=(str[4*i]<<2)|((str[4*i+1]>>4)&0x03);buf[3*i+1]=(str[4*i+1]<<4)|((str[4*i+2]>>2)&0x0F);buf[3*i+2]=(str[4*i+2]<<6)|(str[4*i+3]&0x3F);}return 1;
}//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_Pack_to_ASCII(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{if(str_len%4){return 0;}uint8_t i=0;memset(str,0,str_len);for(i=0;i<str_len/4;i++){str[4*i]=(buf[3*i]>>2)&0x3F;str[4*i+1]=((buf[3*i]<<4)&0x30)|(buf[3*i+1]>>4);str[4*i+2]=((buf[3*i+1]<<2)&0x3C)|(buf[3*i+2]>>6);str[4*i+3]=buf[3*i+2]&0x3F;}return 1;
}

大小端转换

在串口等数据解析中 难免遇到大小端格式问题

什么是大端和小端

所谓的大端模式，就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

所谓的小端模式，就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

简单来说：大端——高尾端，小端——低尾端

举个例子，比如数字 0x12 34 56 78在内存中的表示形式为：

1)大端模式：

低地址 -----------------> 高地址

0x12 | 0x34 | 0x56 | 0x78

2)小端模式：

低地址 ------------------> 高地址

0x78 | 0x56 | 0x34 | 0x12

可见，大端模式和字符串的存储模式类似。

数据传输中的大小端

比如地址位、起止位一般都是大端格式
如：
起始位：0x520A
则发送的buf应为{0x52,0x0A}

而数据位一般是小端格式（单字节无大小端之分）
如：
一个16位的数据发送出来为{0x52,0x0A}
则对应的uint16_t类型数为： 0x0A52

而对于浮点数4.0f 转为32位应是：
40 80 00 00

以大端存储来说 发送出来的buf就是依次发送 40 80 00 00

以小端存储来说 则发送 00 00 80 40

由于memcpy等函数 是按字节地址进行复制 其复制的格式为小端格式 所以当数据为小端存储时 不用进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x00,0x00,0x80,0x40};memcpy(&dat,buf,4);float f=0.0f;f=*((float*)&dat); //地址强转printf("%f",f);

或更优解：

   uint8_t buf[]={0x00,0x00,0x80,0x40};   float f=0.0f;memcpy(&f,buf,4);

而对于大端存储的数据（如HART协议数据 全为大端格式） 其复制的格式仍然为小端格式 所以当数据为小端存储时 要进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};memcpy(&dat,buf,4);float f=0.0f;swap32(&dat); //大小端转换f=*((float*)&dat); //地址强转printf("%f",f);

或：

uint8_t buf[]={0x40,0x80,0x00,0x00};memcpy(&dat,buf,4);float f=0.0f;swap32(&f); //大小端转换printf("%f",f);

或更优解：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};float f=0.0f;dat=(buf[0]<<24)|(buf[0]<<16)|(buf[0]<<8)|(buf[0]<<0)f=*((float*)&dat);

总结

固 若数据为小端格式 则可以直接用memcpy函数进行转换 否则通过移位的方式再进行地址强转

对于多位数据 比如同时传两个浮点数 则可以定义结构体之后进行memcpy复制（数据为小端格式）

对于小端数据 直接用memcpy写入即可 若是浮点数 也不用再进行强转

对于大端数据 如果不嫌麻烦 或想使代码更加简洁（但执行效率会降低） 也可以先用memcpy写入结构体之后再调用大小端转换函数 但这里需要注意的是 结构体必须全为无符号整型 浮点型只能在大小端转换写入之后再次强转 若结构体内采用浮点型 则需要强转两次

所以对于大端数据 推荐通过移位的方式来进行赋值 然后再进行个别数的强转 再往通用结构体进行写入

多个不同变量大小的结构体 要主要字节对齐的问题
可以用#pragma pack(1) 使其对齐为1
但会影响效率

大小端转换函数

直接通过对地址的操作来实现 传入的变量为32位的变量
中间变量ptr是传入变量的地址

void swap16(void * p)
{uint16_t *ptr=p;uint16_t x = *ptr;x = (x << 8) | (x >> 8);*ptr=x;
}void swap32(void * p)
{uint32_t *ptr=p;uint32_t x = *ptr;x = (x << 16) | (x >> 16);x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);*ptr=x;
}void swap64(void * p)
{uint64_t *ptr=p;uint64_t x = *ptr;x = (x << 32) | (x >> 32);x = ((x & 0x0000FFFF0000FFFF) << 16) | ((x >> 16) & 0x0000FFFF0000FFFF);x = ((x & 0x00FF00FF00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF00FF00FF);*ptr=x;
}

这篇关于【嵌入式模块芯片开发】DWIN的T5L _DGUS应用开发 显示屏的基本图形显示以及串口命令的动态数据波形功能实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1013612。

相关文章

Go语言开发实现查询IP信息的MCP服务器

Go语言开发实现查询IP信息的MCP服务器

《Go语言开发实现查询IP信息的MCP服务器》随着MCP的快速普及和广泛应用,MCP服务器也层出不穷,本文将详细介绍如何在Go语言中使用go-mcp库来开发一个查询IP信息的MCP... 目录前言mcp-ip-geo 服务器目录结构说明查询 IP 信息功能实现工具实现工具管理查询单个 IP 信息工具的实现服
阅读更多...
Python的time模块一些常用功能(各种与时间相关的函数)

Python的time模块一些常用功能(各种与时间相关的函数)

《Python的time模块一些常用功能(各种与时间相关的函数)》Python的time模块提供了各种与时间相关的函数,包括获取当前时间、处理时间间隔、执行时间测量等,：本文主要介绍Python的... 目录1. 获取当前时间2. 时间格式化3. 延时执行4. 时间戳运算5. 计算代码执行时间6. 转换为指
阅读更多...
利用Python调试串口的示例代码

利用Python调试串口的示例代码

《利用Python调试串口的示例代码》在嵌入式开发、物联网设备调试过程中,串口通信是最基础的调试手段本文将带你用Python+ttkbootstrap打造一款高颜值、多功能的串口调试助手,需要的可以了... 目录概述：为什么需要专业的串口调试工具项目架构设计1.1 技术栈选型1.2 关键类说明1.3 线程模
阅读更多...
SpringBoot基于配置实现短信服务策略的动态切换

SpringBoot基于配置实现短信服务策略的动态切换

《SpringBoot基于配置实现短信服务策略的动态切换》这篇文章主要为大家详细介绍了SpringBoot在接入多个短信服务商（如阿里云、腾讯云、华为云）后,如何根据配置或环境切换使用不同的服务商,需... 目录目标功能示例配置（application.yml）配置类绑定短信发送策略接口示例：阿里云 & 腾
阅读更多...
Python正则表达式语法及re模块中的常用函数详解

Python正则表达式语法及re模块中的常用函数详解

《Python正则表达式语法及re模块中的常用函数详解》这篇文章主要给大家介绍了关于Python正则表达式语法及re模块中常用函数的相关资料,正则表达式是一种强大的字符串处理工具,可以用于匹配、切分、... 目录概念、作用和步骤语法re模块中的常用函数总结 概念、作用和步骤概念： 本身也是一个字符串，其中
阅读更多...
python实现svg图片转换为png和gif

python实现svg图片转换为png和gif

《python实现svg图片转换为png和gif》这篇文章主要为大家详细介绍了python如何实现将svg图片格式转换为png和gif,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录python实现svg图片转换为png和gifpython实现图片格式之间的相互转换延展：基于Py
阅读更多...
Python中的getopt模块用法小结

Python中的getopt模块用法小结

《Python中的getopt模块用法小结》getopt.getopt()函数是Python中用于解析命令行参数的标准库函数,该函数可以从命令行中提取选项和参数,并对它们进行处理,本文详细介绍了Pyt... 目录getopt模块介绍getopt.getopt函数的介绍getopt模块的常用用法getopt模
阅读更多...
Python利用ElementTree实现快速解析XML文件

Python利用ElementTree实现快速解析XML文件

《Python利用ElementTree实现快速解析XML文件》ElementTree是Python标准库的一部分,而且是Python标准库中用于解析和操作XML数据的模块,下面小编就来和大家详细讲讲... 目录一、XML文件解析到底有多重要二、ElementTree快速入门1. 加载XML的两种方式2.
阅读更多...
Java的栈与队列实现代码解析

Java的栈与队列实现代码解析

《Java的栈与队列实现代码解析》栈是常见的线性数据结构,栈的特点是以先进后出的形式,后进先出,先进后出,分为栈底和栈顶,栈应用于内存的分配,表达式求值,存储临时的数据和方法的调用等,本文给大家介绍J... 目录栈的概念（Stack）栈的实现代码队列（Queue）模拟实现队列(双链表实现)循环队列（循环数组
阅读更多...
C++如何通过Qt反射机制实现数据类序列化

C++如何通过Qt反射机制实现数据类序列化

《C++如何通过Qt反射机制实现数据类序列化》在C++工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作,所以本文就来聊聊C++如何通过Qt反射机制实现数据类序列化吧... 目录设计预期设计思路代码实现使用方法在 C++ 工程中经常需要使用数据类，并对数据类进行存储、打印、调试等操作。由于数据类
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2