结构体仿真测试

最新推荐文章于 2023-05-24 22:12:31 发布
最新推荐文章于 2023-05-24 22:12:31 发布
阅读量298 收藏
点赞数
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czhaii/article/details/104416616
版权

 

 

/***结构体仿真测试*L45 CODE 3583*****/
/***2018 4 28 09:00 PAST*       *****/
              #include   "reg52.h"
              #include       <intrins.h>
              #include<stdio.h>
              #define    uint unsigned int 
              #define    uchar unsigned char
              typedef struct stu
              {
              char name[30];
              char sex;
              int age;
              double score;
              }STU;
              void  main()
              {
               STU X[4]={
               {"LiPin",'M',18,80},
               {"LinYi",'M',19,85},
               {"SunDan",'W',18,90},
               {"WuLi",'W',18,70}
              };
              double max_s;
              int i,max_n;
              max_s=X[0].score;//结构体成员的应用
              max_n=0;
              TMOD|=0x20;
              TH1=0xF3;
              TR1=0x1;
              TI=1;
              for(i=1;i<4;i++)
              {
               if(X[i].score>max_s)
               {
               max_s=X[i].score;
               max_n=i;
               }
               }
              printf("最高分为 :%f\n",max_s);
              printf("最高分的学生信息 :");
              printf("姓 名 :%s\n",X[max_n].name);
              printf("性 别 :%c\n",X[max_n].sex);
              printf("年 龄 :%d\n",X[max_n].age);
              printf("成 绩 :%f\n",X[max_n].score);
              }

 

 

/***STM32结构体类型仿真打印输出测试***/
/***2020  2 20 PAST*****************/
              #include "sys.h"
              #include "usart.h"        
              #include "delay.h"    
              #include "led.h" 
              #include "key.h" 
                            #include <math.h>
              #include <string.h>
                            u8       set1,set2;                                   //
                            struct   PID
              {
               u16    SetPoint;                                     //设定目标 Desired Value
               u16    Proportion;                                   //比例常数 Proportional Const
               u16    Integral;                                     //积分常数 Integral Const
               u16    Derivative;                                   //微分常数 Derivative Const
               u16    LastError;                                    //Error[-1]
               u16    PrevError;                                    //Error[-2]
               u16    SumError;                                     //Sums of Errors
              };
              struct   PID spid;                                    //PID Control Structurea,spidb,spidc,spidd
                            void PIDInit(struct PID *pp)
              {
                memset(pp,0,sizeof(struct PID));                    //用参数0初始化pp
              }
                            u16 PIDCalc( struct PID *pp, unsigned int NextPoint ) //PID计算
              {
               u16 dError,Error;
               Error=pp->SetPoint - NextPoint;                      //偏差
               pp->SumError += Error;                               //积分
               dError = pp->LastError - pp->PrevError;              //当前微分
                pp->PrevError = pp->LastError;
               pp->LastError = Error;
               return (pp->Proportion * Error                       //比例
               +pp->Integral*pp->SumError                           //积分项
               +pp->Derivative*dError);                             //微分项
              }
              int main(void)
              {            
                 Stm32_Clock_Init(9);                                 //系统时钟设置
                 delay_init(72);                                        //延时初始化 
                 uart_init(72,9600);                                    //串口初始化为9600
                 LED_Init();                                                //初始化与LED连接的硬件接口    
               while(1)
                 {
                                PIDInit(&spid);                                     //Initialize Structure
                spid.Proportion= 10;                                //Set PID Coefficients
                spid.Integral = 8;
                spid.Derivative =6;
                spid.SetPoint =100;                                 //Set PID Setpoint
               }
              }

 

 

/***STM32结构体类型仿真打印输出测试***/
/***2020  2 20 PAST*****************/
              #include "sys.h"
              #include "usart.h"        
              #include "delay.h"    
              #include "led.h" 
              #include "key.h" 
                            #include <math.h>
              #include <string.h>
                            u8       set1,set2;                                   //
                            struct   PIDA
              {
               u16    SetPoint;                                     //设定目标 Desired Value
               u16    Proportion;                                   //比例常数 Proportional Const
               u16    Integral;                                     //积分常数 Integral Const
               u16    Derivative;                                   //微分常数 Derivative Const
               u16    LastError;                                    //Error[-1]
               u16    PrevError;                                    //Error[-2]
               u16    SumError;                                     //Sums of Errors
              };
              struct   PIDA spida;                                    //PID Control Structurea,spidb,spidc,spidd
                            void PIDAInit(struct PIDA *pp)
              {
                memset(pp,0,sizeof(struct PIDA));                    //用参数0初始化pp
              }
                            u16 PIDACalc( struct PIDA *pp, unsigned int NextPoint ) //PID计算
              {
               u16 dError,Error;
               Error=pp->SetPoint - NextPoint;                      //偏差
               pp->SumError += Error;                               //积分
               dError = pp->LastError - pp->PrevError;              //当前微分
                pp->PrevError = pp->LastError;
               pp->LastError = Error;
               return (pp->Proportion * Error                       //比例
               +pp->Integral*pp->SumError                           //积分项
               +pp->Derivative*dError);                             //微分项
              }
              int main(void)
              {            
                 Stm32_Clock_Init(9);                                 //系统时钟设置
                 delay_init(72);                                        //延时初始化 
                 uart_init(72,9600);                                    //串口初始化为9600
                 LED_Init();                                                //初始化与LED连接的硬件接口    
               while(1)
                 {
                                PIDAInit(&spida);                                     //Initialize Structure
                spida.Proportion= 10;                                //Set PID Coefficients
                spida.Integral = 8;
                spida.Derivative =6;
                spida.SetPoint =100;                                 //Set PID Setpoint
               }
              }

 

 

 

 

 

/***STM32结构体类型仿真打印输出测试***/
/***2020  2 20 PAST*****************/
              #include "sys.h"
              #include "usart.h"        
              #include "delay.h"    
              #include "led.h" 
              #include "key.h" 
              #include <math.h>
              #include <string.h>
              u8       set1,set2;                                   //
/***************************************/                            
              struct   PIDA
              {
               u16    SetPoint;                                     //设定目标 Desired Value
               u16    Proportion;                                   //比例常数 Proportional Const
               u16    Integral;                                     //积分常数 Integral Const
               u16    Derivative;                                   //微分常数 Derivative Const
               u16    LastError;                                    //Error[-1]
               u16    PrevError;                                    //Error[-2]
               u16    SumError;                                     //Sums of Errors
              };
              struct   PIDA spida;                                    //PID Control Structurea,spidb,spidc,spidd
/***************************************/                        
              struct   PIDB
              {
               u16    SetPoint;                                     //设定目标 Desired Value
               u16    Proportion;                                   //比例常数 Proportional Const
               u16    Integral;                                     //积分常数 Integral Const
               u16    Derivative;                                   //微分常数 Derivative Const
               u16    LastError;                                    //Error[-1]
               u16    PrevError;                                    //Error[-2]
               u16    SumError;                                     //Sums of Errors
              };
              struct   PIDB spidb;                                    //PID Control Structurea,spidb,spidc,spidd
/***************************************/                            
              struct   PIDC
              {
               u16    SetPoint;                                     //设定目标 Desired Value
               u16    Proportion;                                   //比例常数 Proportional Const
               u16    Integral;                                     //积分常数 Integral Const
               u16    Derivative;                                   //微分常数 Derivative Const
               u16    LastError;                                    //Error[-1]
               u16    PrevError;                                    //Error[-2]
               u16    SumError;                                     //Sums of Errors
              };
              struct   PIDB spidc;                                    //PID Control Structurea,spidb,spidc,spidd
/***************************************/                            
              struct   PIDD
              {
               u16    SetPoint;                                     //设定目标 Desired Value
               u16    Proportion;                                   //比例常数 Proportional Const
               u16    Integral;                                     //积分常数 Integral Const
               u16    Derivative;                                   //微分常数 Derivative Const
               u16    LastError;                                    //Error[-1]
               u16    PrevError;                                    //Error[-2]
               u16    SumError;                                     //Sums of Errors
              };
              struct   PIDB spidd;                                    //PID Control Structurea,spidb,spidc,spidd
/***************************************/                            
              void PIDAInit(struct PIDA *pp)
              {
                memset(pp,0,sizeof(struct PIDA));                    //用参数0初始化pp
              }
/***************************************/                            
              void PIDBInit(struct PIDB *pp)
              {
                memset(pp,0,sizeof(struct PIDB));                    //用参数0初始化pp
              }
/***************************************/                            
              void PIDCInit(struct PIDC *pp)
              {
                memset(pp,0,sizeof(struct PIDC));                    //用参数0初始化pp
              }
/***************************************/                            
              void PIDDInit(struct PIDD *pp)
              {
                memset(pp,0,sizeof(struct PIDD));                    //用参数0初始化pp
              }
/***************************************/                            
             u16 PIDACalc( struct PIDA *pp, u16 NextPoint ) //PID计算
              {
               u16 dError,Error;
               Error=pp->SetPoint - NextPoint;                      //偏差
               pp->SumError += Error;                               //积分
               dError = pp->LastError - pp->PrevError;              //当前微分
                pp->PrevError = pp->LastError;
               pp->LastError = Error;
               return (pp->Proportion * Error                       //比例
               +pp->Integral*pp->SumError                           //积分项
               +pp->Derivative*dError);                             //微分项
              }
/***************************************/                            
              u16 PIDBCalc( struct PIDB *pp, u16 NextPoint )        //PID计算
              {
               u16 dError,Error;
               Error=pp->SetPoint - NextPoint;                      //偏差
               pp->SumError += Error;                               //积分
               dError = pp->LastError - pp->PrevError;              //当前微分
                pp->PrevError = pp->LastError;
               pp->LastError = Error;
               return (pp->Proportion * Error                       //比例
               +pp->Integral*pp->SumError                           //积分项
               +pp->Derivative*dError);                             //微分项
              }
/***************************************/                            
              u16 PIDCCalc( struct PIDC *pp, u16 NextPoint )        //PID计算
              {
               u16 dError,Error;
               Error=pp->SetPoint - NextPoint;                      //偏差
               pp->SumError += Error;                               //积分
               dError = pp->LastError - pp->PrevError;              //当前微分
                pp->PrevError = pp->LastError;
               pp->LastError = Error;
               return (pp->Proportion * Error                       //比例
               +pp->Integral*pp->SumError                           //积分项
               +pp->Derivative*dError);                             //微分项
              }
/***************************************/                            
              u16 PIDDCalc( struct PIDD *pp, u16 NextPoint )        //PID计算
              {
               u16 dError,Error;
               Error=pp->SetPoint - NextPoint;                      //偏差
               pp->SumError += Error;                               //积分
               dError = pp->LastError - pp->PrevError;              //当前微分
                pp->PrevError = pp->LastError;
               pp->LastError = Error;
               return (pp->Proportion * Error                       //比例
               +pp->Integral*pp->SumError                           //积分项
               +pp->Derivative*dError);                             //微分项
              }
/***************************************/                            
              int main(void)
              {            
                 Stm32_Clock_Init(9);                                 //系统时钟设置
                 delay_init(72);                                        //延时初始化 
                 uart_init(72,9600);                                    //串口初始化为9600
                 LED_Init();                                                //初始化与LED连接的硬件接口    
               while(1)
                 {
                                PIDAInit(&spida);                                     //Initialize Structure
                spida.Proportion= 10;                                //Set PID Coefficients
                spida.Integral = 8;
                spida.Derivative =6;
                spida.SetPoint =100;                                 //Set PID Setpoint
               }
              }

 

 

 

 

 

 

 

 

 

 

czhaii
关注
专栏目录
C语言-结构体及测试代码
08-05
C语言-结构体及测试代码
FPGA仿真和测试技术研究
06-18
【FPGA 仿真和测试技术】是电子设计自动化（EDA）领域的重要环节，尤其是在基于FPGA（Field-Programmable Gate Array）的数字系统设计中。FPGA是一种可编程逻辑器件，允许用户根据需求定制其内部逻辑结构。在设计...
结构体测试
nostrud ipsum6
10-31 276
结构体:一种数据类型，类似于int,char,long等。当一种对象不止一种数据类型时，可以使用结构体来包含不同变量。例如：建立学生信息系统，一个学生的信息包含姓名，年龄，学号，家庭住址等等姓名，家庭住址为char型；年龄，学号为int型，这时可以使用结构体类型结构体:一种数据类型，类似于int,char,long等。当一种对象不止一种数据类型时，可以使用结构体来包含不同变量。例如：建立学生信息系...
结构体对齐测试测试程序
GhostTigerMan
11-01 527
<br />#include "stdafx.h" struct { short a1;//偏移量为0,是sizeof(short)的倍数 short a2;//偏移量为2,是sizeof(short)的倍数 short a3;//偏移量为2+2,是sizeof(short)的倍数 }A;//VC必须保证结构的大小为结构体字节边界数2的倍数,结构体大小为6满足条件 struct { long a1;//偏移量为0,是sizeof(long)的倍数 short a2;
结构体(struct)的使用、内存分布以及字节对齐测试总结
努力创作有价值的文章
12-19 1万+
最近和班上的一些"猿友"重新来完善或重新写以前在学校用C语言实现的数据结构，实现单链表、双向链表、循环链表、树、图等等一些数据结构。需要实现这些数据结构就必须熟练掌握C语言中的自定义类型，即结构体(struct)。虽然以前在学学校实现过，但是不是很完善，然而就当我重新动手用C来实现链表，却发现自己的C语言大部分知识点都忘得差不多。今天在这里总结和测试C语言中的结构体(struct)，熟练掌握结构体
FATFS_SPIfatfs移植_SPIFatFs仿真_SPIfatfs测试_模拟SPI_stm32_
10-01
这包括初始化FATFS结构体，挂载文件系统，以及执行读写文件、创建目录等操作。在代码中，我们调用ff_mount()函数挂载文件系统，ff_open()打开文件，ff_read()和ff_write()进行读写操作，ff_close()关闭文件，以及ff_...
VHDL实现JESD204B，包括testbench测试文件及仿真
07-02
3. 仿真脚本：指导仿真工具进行测试和分析结果的文件，如ModelSim或GHDL的命令文件。 4. 配置文件：定义接口参数、通道数量、数据速率等。 5. 结果报告：包含仿真的输出和性能评估。 通过这些文件，工程师可以全面...
基于接口仿真的雷达软件测试自动化技术研究与应用.pdf
09-15
这种方法通过对雷达软件测试典型项目的实例研究，验证了雷达软件接口仿真测试自动化框架的实际应用效果。 文章还提到了关键词“雷达软件”、“嵌入式软件”、“软件接口测试”、“自动化测试”和“仿真环境”，这些...
c语言结构体Node数据结构测试
情随事迁个人博客
09-12 388
struct NodeX { int childcount; struct NodeX *preNode; struct NodeX *nextNode; // struct NodeX nextNodeN; //rror: field 'nextNodeN' has incomplete type struct NodeX *parentNode; ...
c语言如何测试结构体大小,【c语言】结构体大小计算的例子
weixin_39663258的博客
05-19 133
// 结构体大小计算的例子// 默认对齐数为4#include union tagAAA{struct{char ucFirst;//1short ucSecond;//2char ucThird;//1}half;short kk;//2}number;struct tagBBB{char ucFirst;//1short ucSecond;//2char ucThird;//1short uc...
c++中map容器简单功能实现测试附带结构体指针测试
ghevinn欢迎您光临
08-20 2307
// TestingandTobe.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include using namespace std; struct student{ // virtual void fun(){ 指针指向未知崩溃 void fun(){ m_i=0; cout<<"结构体指针
c# tostring 重写_c#类与结构体性能对比测试——以封装网络心跳包为例
weixin_39975486的博客
11-24 324
目录1.背景2.用类来封装以太网心跳包的优缺点2.1.优点2.2.缺点3.网络心跳包封装类4.实现IDisposable接口5.应用层调用6.Dispose()方法生效的测试7.测试性能对比8.综上，在C#里，结构体主要作用有如下两点：1.背景接上篇文章深入浅出C#结构体——封装以太网心跳包的结构为例,使用结构体性能不佳，而且也说明了原因。本篇文章详细描述了以类来封装网络心跳包的优缺点，...
仿真软件有哪些测试,仿真测试对比软件***排名
weixin_35860326的博客
07-23 708
仿真测试对比软件***排名但在实际应用中，几乎是不同的仪器型应变器，并无统一的标准，如应变数据测量、手动量测、矢量量测等。有的就是针对一些测量原理，使用仪器测量。为了获得准确数据，这些仪器型应变器需要加到两个比较高的测量工具上。测量的时候，一是看仪器导航，二是往测量工具中加一个标准量测仪器，使用相应的仪器测量所有的条件或测量参数，重要的是找出几种原理。这种仪器包括硅有限高器(mrps)、硅基照明器...
结构体入门&调试技巧
最新发布
muwithxi的博客
05-24 638
结构体基础知识的讲解，调试技巧的学习。
c语言结构体单元测试,C语言结构体单元练习.doc
weixin_34646820的博客
05-23 400
C语言结构体单元练习1.有以下定义和语句：struct student{ int age;int num; };struct student stu[3]={{1001,20},{1002,19},{1003,21}};main(){ struct student *p;p=stu;…… }则以下不正确的引用是 。A) (p++)->num B) p++ ...
Golang 单元测试
不要因为走的太远而忘了为什么出发
04-28 344
文章目录1. 测试函数2. 结构体测试 在提交测试工程师代码前，先进行单元测试自检，没有问题，方可提交代码，对于模块或者函数需要自行写测试用例 测试规则: ① 文件名必须以_test go结尾 ② 如果是测试函数，必须以Test开头 1. 测试函数 calc.go package main //加法 func add(a, b int) int { return a + b } //减法 func sub(a, b int) int { return a - b } calc_tes
C语言结构体（struct）最全的讲解（万字干货）
热门推荐
lyh290188的博客
02-15 21万+
结构体的定义 结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合，也叫结构。 结构体和其他类型基础数据类型一样，例如int类型，char类型只不过结构体可以做成你想要的数据类型。以方便日后的使用。 在实际项目中，结构体是大量存在的。研发人员常使用结构体来封装一些属性来组成新的类型。由于C语言无法操作数据库，所以在项目中通过对结构体内部变量的操作将大量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值