状态估计用于描述符 LTI 和 LPV 系统的分析状态估计和故障检测的算法（Matlab代码实现）

Posted 2023-04-06 数学建模与科研

💥 💥 💞 💞 欢迎来到本博客 ❤️ ❤️ 💥 💥


🏆 博主优势： 🌞 🌞 🌞博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。


⛳ 座右铭：行百里者，半于九十。

📋 📋 📋 本文目录如下： 🎁 🎁 🎁
目录
💥1 概述
📚2 运行结果
🎉3 参考文献
🌈4 Matlab代码、数据、文章讲解

💥1 概述

文献来源：

摘要:本文讨论了在LTI或LPV描述子框架中建模的系统的MATLAB/SCILAB工具箱的开发。给出了正则性、可解性、可控性和可观测性。包括全阶观测器和降阶观测器，比例观测器和比例积分观测器。其中一些观察人士考虑了未知的输入。可以作为基于状态估计和故障检测的观测器的辅助工具。这些观察者已经从最近发表的几篇论文中得到了考虑。通过建立观测库来实现故障的检测和隔离。这些观察者库可以通过选择输入/输出矩阵来建立，也可以使用所提出的算法自动建立。

许多系统都可以用非线性微分方程来建模，但是监控系统的设计是一项困难的任务。因此，对非线性系统进行线性化以获得线性时不变(LTI)系统是非常常见的，但这种表示在一个平衡点或工作点附近是有效的。

改进模型表示的一种方法是包含一些限制。如果限制是模型的一部分，那么系统就变成了描述符- lti (DLTI)表示。DLTI系统的主要优点是集成了静态关系(例如物理约束)和动态关系。这些考虑允许对广泛的过程进行建模，例如，在Dai, 1989;段,2010)。

Luenberger观测者存在的充分条件在(Hou and Muller, 1999;Darouach和Boutayeb, 1995)。(Darouach等人，1996)的作者提出了一种降阶未知输入观测，类似于(Chen和Patton, 1999)中研究的LTI系统的观测器。

详细文章讲解及数学模型见第4部分。

📚2 运行结果

部分代码：

xe=[ 1 5 3 0]'% intial stimated states

ye(:,1)=C*xe % compute the initial output

t(1)=0;% initial time

u(1)=0;

% observer gains

% % if the system is observable then compute the restricted system equivalence systems by QR descomposition

disp('Simulation')

for k=1:50/Te

% Time counter

t(k+1)=t(k)+Te;

% input

if t(k)<7

u(k+1)=1;

else

u(k+1)=5;

end

% % the differentials equations can be solved by runge-kuta of four order

x1=x1+Te*(x3);

x2=x2+Te*(x1);

x4=x1;

x3=-x2-x4+u(k);

xx(:,k+1)=[x1 x2 x3 x4]';

y(:,k+1)=C*xx(:,k+1); % system output

% Observer

yi=[-Be1*u(k);y(:,k)]; % auxiliar for compute the observer

% Reduced order observer

% $z=Piz+Lyi+H*u $

% $\\hatx=Mz+Fyi$

z(k+1)=z(k)+Te*(Pi*z(k)+L*yi+H*u(k)); %

xe(:,k+1)=M*z(k)+F*yi;

ye(:,k+1)=C*xe(:,k+1); % stimated output

% Generation of residuos

end

disp('PLOTS')

pause

figure(2);

cla();

plot(t,y',t,ye')

legend('output', 'stimated')

n=size(A,1);

m=size(B1,2);

p=size(C,1);

if flag==1

P=sdpvar(n,n);

Y=sdpvar(m,n,'full');

Q=sdpvar(1,n,'full');

sdpvar g

% g=0.1

alpha=0;

Con=[P>=0,g>=0];

LMI=blkvar();

LMI(1,1)= (P*E'+S*Q)'*A'+Y'*B1'+A*(P*E'+S*Q)+B1*Y+B*B'+2*alpha*P;

LMI(1,2)=E*P'*C'+Q'*S'*C'+Y'*B2';

% (P*E'+S*Q)'*C'+Y'*B2';

LMI(2,2)=-g*eye(p);

LMI=sdpvar(LMI);

Con=[Con, LMI<=0]

op=sdpsettings('verbose',0,'solver','sedumi','sedumi.eps',1e-5);

solvesdp(Con,[],op)

P=double(P);

Y=double(Y);

Q=double(Q);

g=double(g);

% K=Y/((P*E'+S*Q))

K=Y/((P*E'+S*Q))

lamda=deig(A+B1*K,E)

% [Ccon, Rcon, Icon]=dcontr (E,A+B*K,B)

elseif flag==2

% g=0.01100

cvx_begin sdp

cvx_precision default

cvx_solver sedumi

variable g

variable P(n,n) symmetric

variable Y(m,n)

variable Q(1,n)

minimize g

P >= 0

[ (P*E'+S*Q)'*A'+Y'*B1'+A*(P*E'+S*Q)+B1*Y+B*B' E*P'*C'+Q'*S'*C'+Y'*B2' ; ...

(E*P'*C'+Q'*S'*C'+Y'*B2')' -g*eye(p)] <= 0

cvx_end

gamma = sqrt(g)

K=Y/((P*E'+S*Q));

lamda=deig(A+B1*K,E)

else

setlmis([]);

% create a blank LTI framework

P=lmivar(1,[n 1]); % declare X as a 3 脳 3 symmetrical matrix

Y=lmivar(2,[m n]); % declare Y as a n x n

Q=lmivar(2,[1 n]); % declare

lmiterm([1 1 1 P],A,E','s') % A*P*E' + *

lmiterm([1 1 1 Q],A*S,1,'s') % A*S*Q+*

lmiterm([1 1 1 Y],B1,1,'s') % B*Y+*

lmiterm([1 1 1 0],B*B') % B*B'+*

lmiterm([1 1 2 P'],E,C') % E*P'*C'

lmiterm([1 1 2 Q'],1,S'*C') % Q'*S'*C'

lmiterm([1 1 2 Y'],1,B2') % E*P'*C'

% lmiterm([1 1 1 P],2*5,1,'s') % B*Y+*

lmiterm([-2 1 1 P],1,1,'s') % P>0

% lmiterm([-3 1 1 Q],1,1) % P>0

Con=getlmis;

% c = mat2dec(Con,eye(3),eye(3),eye(1,n));

% options = [1e5,0,0,0,0];

% [copt,b] = mincx(Con,c,options);

[tmin b]=feasp(Con);

% [tmin b]=mincx(Con,-trac);

P=dec2mat(Con,b,P);

Y=dec2mat(Con,b,Y);

Q=dec2mat(Con,b,Q);

K=Y/((P*E'+S*Q));

lamda=deig(A+B*K,E);

🎉3 参考文献

部分理论来源于网络，如有侵权请联系删除。

编辑

🌈4 Matlab代码、数据、文章讲解

第六周学习分析

《Linux内核分析》

一、进程控制块PCB——task_struct又称进程描述符，是操作系统用于管理控制进程的一个专门的数据结构，记录进程的各种属性，描述进程的动态变化过程，而PCB是系统感知进程存在的唯一标志为了管理进程，内核必须对每个进程进行清晰的描述，进程描述符提供了内核所需了解的进程信息。struct task_struct数据结构很庞大

Linux进程的状态与操作系统原理中的描述的进程状态似乎有所不同，比如就绪状态和运行状态都是TASK_RUNNING，为什么呢？
我们调用fork创建好一个新进程的时候，它的状态是TASK_RUNNING(就绪，但是没有在运行)，当调度器选择我们新fork的这个进程的时候，它就切换到TASK_RUNNING(正在运行)
当进程是TASK_RUNNING这种状态的时候，也就是说它是可运行的，但它有没有在运行呢？这个取决于它有没有获得CPU的控制权，也就是说这个进程有没有在CPU上实际地执行，如果在CPU上实际地执行，那就是“正在运行”，如果被调度出去了，在等待，那就是“就绪，但是没有在运行”，这是和操作系统原理中描述的进程状态不同的地方
进程的标示pid
所有进程链表struct list_head tasks;

内核的双向循环链表的实现方法 - 一个更简略的双向循环链表
程序创建的进程具有父子关系，在编程时往往需要引用这样的父子关系。进程描述符中有几个域用来表示这样的关系

Linux为每个进程分配一个8KB大小的内存区域，用于存放该进程两个不同的数据结构：Thread_info和进程的内核堆栈
进程处于内核态时使用，不同于用户态堆栈，即PCB中指定了内核栈，那为什么PCB中没有用户态堆栈？用户态堆栈是怎么设定的？
内核控制路径所用的堆栈很少，因此对栈和Thread_info来说，8KB足够了
struct thread_struct thread; //CPU-specific state of this task
文件系统和文件描述符
内存管理——进程的地址空间
二、操作系统三大功能：进程管理（核心）、内存管理、文件系统。
三、进程状态转换：

四、创建一个新进程在内核中的执行过程

Fork（在用户态创建一个子进程，在子进程和父进程中各返回一次）、vfork和clone三个系统调用都可以创建一个新进程，而且都是通过调用do_fork来实现进程的创建；
Linux通过复制父进程来创建一个新进程，那么这就给我们理解这一个过程提供一个想象的框架：
复制一个PCB——task_struct
1.err = arch_dup_task_struct(tsk, orig);
要给新进程分配一个新的内核堆栈
1.ti = alloc_thread_info_node(tsk, node);
2.tsk->stack = ti;
3.setup_thread_stack(tsk, orig); //这里只是复制thread_info，而非复制内核堆栈
要修改复制过来的进程数据，比如pid、进程链表等等都要改改吧，见copy_process内部。
从用户态的代码看fork();函数返回了两次，即在父子进程中各返回一次，父进程从系统调用中返回比较容易理解，子进程从系统调用中返回，那它在系统调用处理过程中的哪里开始执行的呢？这就涉及子进程的内核堆栈数据状态和task_struct中thread记录的sp和ip的一致性问题，这是在哪里设定的？copy_thread in copy_process
childregs = current_pt_regs(); //复制内核堆栈
childregs->ax = 0; //为什么子进程的fork返回0，这里就是原因！
p->thread.sp = (unsigned long) childregs; //调度到子进程时的内核栈顶
p->thread.ip = (unsigned long) ret_from_fork; //调度到子进程时的第一条指令地址（子进程从这里开始执行）
五、道生一（start-kernel。。。cpu-idle），一生二（kernel-init和kthreadd），二生三（即前面的0，1，2号三个进程），三生万物（一号进程是所有用户态进程的祖先，二号进程是所有内核态进程的祖先）
六、系统调用回顾

实验

与上周一样的实验步骤：

进行gdb的过程：

总结：

Linux通过复制父进程来创建一个新进程,通过调用do_fork来实现，Linux为每个新创建的进程动态地分配一个task_struct结构，fork()函数被调用一次，但返回两次。