PID 조절 C 언어 해석

머리말
선생님 께 서 는 프로 그래 밍 으로 PID 조절 을 실현 하 는 임 무 를 주 셨 습 니 다. 우리 학과 에서 C 언어 와 VB 를 배 웠 기 때문에 저 는 Kotlin 을 가지 고 연습 하고 싶 습 니 다. 인터넷 에서 다른 사람 이 C 로 어떻게 실현 하 는 지 검색 하고 상세 한 데 이 터 를 찾 았 습 니 다. 그런데 너무 많은 데 이 터 를 보 여 주 었 습 니 다. 저 는 기초 지식 을 정리 하 겠 습 니 다. Kotlin 의 실현 은 여기 있 습 니 다.
간략하게 해석 하 다.
참고 자 료 는 여기 서 오차 신 호 를 통 해 제 어 량 을 제어 하 는데 컨트롤 러 자체 가 비례, 적분, 미분 세 부분의 더하기 이다.여기 서 우 리 는 (t 시간 에):
  • 입력 량 은 rin (t) 이다.
  • 수출 량 은 rout (t) 이다.
  • 편 차 량 은 err (t) = rin (t) - rout (t) 이다.
  • 편차 가 0 이면 비례 고리 가 작용 하지 않 고 편차 가 있 을 때 만 비례 고리 가 작용 한다.
  • 미분 신 호 는 편차 신호 의 변화 규칙 이나 변화 추 세 를 반영 하여 편차 신호 의 변화 추세 에 따라 초 전 조절 을 하여 시스템 의 신속 성 을 증가 시 켰 다.

  • 위치 형 PID 의 C 언어 구현
    첫 번 째 단계: PID 변수 구조 체 를 정의 합 니 다. 코드 는 다음 과 같 습 니 다.
    struct _pid{
        float SetSpeed;            //     
        float ActualSpeed;        //     
        float err;                //     
        float err_last;            //        
        float Kp,Ki,Kd;            //    、  、    
        float voltage;          //     (        )
        float integral;            //     
    }pid;
    

    제어 알고리즘 에 필요 한 매개 변 수 는 하나의 구조 체 에서 통일 적 으로 정의 되 어 뒤의 사용 에 편리 합 니 다.
    두 번 째 부분: 변 수 를 초기 화 합 니 다. 코드 는 다음 과 같 습 니 다.
    void PID_init(){
        printf("PID_init begin 
    "
    ); pid.SetSpeed=0.0; pid.ActualSpeed=0.0; pid.err=0.0; pid.err_last=0.0; pid.voltage=0.0; pid.integral=0.0; pid.Kp=0.2; pid.Ki=0.015; pid.Kd=0.2; printf("PID_init end
    "
    ); }

    변 수 를 통일 적 으로 초기 화 합 니 다. 특히 Kp, Ki, Kd 세 개의 매개 변 수 는 디 버 깅 과정 에서 요구 하 는 제어 효과 에 대해 이 세 개의 양 을 조절 하여 직접 조절 할 수 있 습 니 다.
    세 번 째 단계: 제어 알고리즘 을 작성 합 니 다. 코드 는 다음 과 같 습 니 다.
    float PID_realize(float speed){
        pid.SetSpeed=speed;
        pid.err=pid.SetSpeed-pid.ActualSpeed;
        pid.integral+=pid.err;
        pid.voltage=pid.Kp*pid.err+pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);
        pid.err_last=pid.err;
        pid.ActualSpeed=pid.voltage*1.0;
        return pid.ActualSpeed;
    }
    

    주의: 여기 서 가장 기본 적 인 알고리즘 실현 형식 을 사 용 했 고 사각 지대 문 제 를 고려 하지 않 았 으 며 상하 한 을 설정 하지 않 았 으 며 공식 에 대한 직접적인 실현 일 뿐 뒤의 소개 에서 이에 대해 점점 개선 할 것 입 니 다.
    지금까지 PID 의 기본 실현 부분 은 초보 적 으로 완성 되 었 다.다음은 테스트 코드:
    int main(){
        printf("System begin 
    "
    ); PID_init(); int count=0; while(count<1000) { float speed=PID_realize(200.0); printf("%f
    "
    ,speed); count++; } return 0; }

    증분 형 PID 의 C 언어 구현
    이것 이 바로 이산 화 PID 의 증 량 식 표현 방식 으로 공식 적 으로 볼 수 있 듯 이 증 량 식 표현 결 과 는 최근 세 차례 의 편차 와 관련 이 있어 시스템 의 안정성 을 크게 향상 시 켰 다.주의해 야 할 것 은 최종 출력 결과 가
       u(K)+     ;
    
    include<stdio.h>
    struct _pid{
        float SetSpeed;           //     
        float ActualSpeed;        //     
        float err;                //     
        float err_next;           //        
        float err_last;           //         
        float Kp,Ki,Kd;           //    、  、    
    }pid;
    
    void PID_init(){
        pid.SetSpeed=0.0;
        pid.ActualSpeed=0.0;
        pid.err=0.0;
        pid.err_last=0.0;
        pid.err_next=0.0;
        pid.Kp=0.2;
        pid.Ki=0.015;
        pid.Kd=0.2;
    }
    
    float PID_realize(float speed){
        pid.SetSpeed=speed;
        pid.err=pid.SetSpeed-pid.ActualSpeed;
        float incrementSpeed=pid.Kp*(pid.err-pid.err_next)+pid.Ki*pid.err+pid.Kd*(pid.err-2*pid.err_next+pid.err_last);
        pid.ActualSpeed+=incrementSpeed;
        pid.err_last=pid.err_next;
        pid.err_next=pid.err;
        return pid.ActualSpeed;
    }
    
    int main(){
        PID_init();
        int count=0;
        while(count<1000)
        {
            float speed=PID_realize(200.0);
            printf("%f
    "
    ,speed); count++; } return 0; }

    결론: 시스템 의 안정성 이 크게 향상 되 었 다.
    적분 분리 PID 제어 계산법 C 언어 구현
    일반 PID 제어 에서 포인트 고 리 를 도입 하 는 목적 은 주로 정 차 를 없 애고 제어 정밀 도 를 높이 기 위 한 것 이다.그러나 작 동, 종료 또는 대폭 증감 설정 시 짧 은 시간 내 에 시스템 출력 에 큰 편차 가 생 겨 PID 연산 의 적분 축적 을 초래 하고 통 제 량 이 집행 기구 가 허용 할 수 있 는 최대 동작 범 위 를 초과 하여 극한 통 제 량 에 대응 하여 비교적 큰 초과 조정, 심지어 진동 을 일 으 킬 수 있 으 므 로 이것 은 절대 허용 되 지 않 는 다.
    이 문 제 를 극복 하기 위해 포인트 분리 개념 을 도입 했다. 그 기본 적 인 사 고 는 통 제 량 과 설정 치 의 편차 가 비교적 클 때 포인트 역할 을 취소 하 는 것 이다.제 어 량 이 주어진 값 에 가 까 울 때 포인트 제 어 를 도입 하여 정 차 를 없 애고 정밀 도 를 높 인 다.그 구체 적 인 실현 코드 는 다음 과 같다.
    pid.Kp=0.2;
    pid.Ki=0.04;
    pid.Kd=0.2;  //     
    if(abs(pid.err)>200)
    {
        index=0;
        }else{
        index=1;
        pid.integral+=pid.err;
    }
        pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);    //        
    

    결론: 시스템 의 신속 성 이 향상 되 었 다.
    적분 포화 저항 PID 제어 계산법 C 언어 구현
    이른바 적분 포화 현상 이란 시스템 에 한 방향의 편차 가 존재 하면 PID 컨트롤 러 의 출력 이 적분 작용 의 누적 으로 인해 커지 고 집행 기구 가 극한 위치 에 이 르 게 하 는 것 을 말한다. 만약 에 컨트롤 러 의 출력 U (k) 가 계속 커지 면 집행 기 의 개방 도가 더 이상 증가 할 수 없다. 이때 컴퓨터 의 출력 통 제 량 이 정상 적 인 운행 범 위 를 초과 하여 포화 구역 에 들어간다.시스템 에 역방향 편차 가 생기 면 u (k) 는 포화 구역 에서 점점 퇴출 된다.포화 구역 에 들 어 갈 수록 포화 구역 에서 물 러 나 는 시간 이 길다.이 기간 동안 집행 기 구 는 여전히 극한 위치 에 머 물 러 편차 의 역방향 에 따라 즉각 상응하는 변 화 를 하지 않 았 다. 이때 시스템 은 통 제 력 을 잃 은 것 처럼 통제 성능 을 악화 시 켰 다. 이런 현상 을 적분 포화 현상 이나 적분 통제 불 능 현상 이 라 고 한다.적분 의 포 화 를 방지 하 는 방법 중 하 나 는 바로 항 적분 포화 법 이다. 이 방법의 사고방식 은 u (k) 를 계산 할 때 먼저 지난 순간의 제 어량 u (k - 1) 가 극한 범 위 를 초 과 했 는 지 판단 하 는 것 이다. 만약 에 u (k - 1) > umax 라면 마이너스 편차 만 누적 한다.하면, 만약, 만약...
    struct _pid{
        float SetSpeed;           //     
        float ActualSpeed;        //     
        float err;                //     
        float err_last;           //        
        float Kp,Ki,Kd;           //    、  、    
        float voltage;            //     (        )
        float integral;           //     
        float umax;
        float umin;
    }pid;
    
    void PID_init(){
        printf("PID_init begin 
    "
    ); pid.SetSpeed=0.0; pid.ActualSpeed=0.0; pid.err=0.0; pid.err_last=0.0; pid.voltage=0.0; pid.integral=0.0; pid.Kp=0.2; pid.Ki=0.1; // , , pid.Kd=0.2; pid.umax=400; pid.umin=-200; printf("PID_init end
    "
    ); } float PID_realize(float speed){ int index; pid.SetSpeed=speed; pid.err=pid.SetSpeed-pid.ActualSpeed; if(pid.ActualSpeed>pid.umax) // { if(abs(pid.err)>200) // { index=0; }else{ index=1; if(pid.err<0) { pid.integral+=pid.err; } } }else if(pid.ActualSpeed<pid.umin){ if(abs(pid.err)>200) // { index=0; }else{ index=1; if(pid.err>0) { pid.integral+=pid.err; } } }else{ if(abs(pid.err)>200) // { index=0; }else{ index=1; pid.integral+=pid.err; } } pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last); pid.err_last=pid.err; pid.ActualSpeed=pid.voltage*1.0; return pid.ActualSpeed; }

    결론: 시스템 의 안정 시간 은 몇 차례 에 비해 많이 단축 되 었 다.
    사다리꼴 적분 의 PID 제어 계산법 C 언어 구현
    먼저 사다리꼴 알고리즘 의 포인트 부분 공식 을 PID 제어 율 의 포인트 항목 으로 살 펴 보 자. 그 역할 은 여 차 를 없 애 는 것 이다. 여 차 를 최대한 줄 이기 위해 포인트 항목 의 연산 정 도 를 높 여야 한다. 이 를 위해 사각형 포 인 트 를 사다리꼴 포인트 로 바 꿀 수 있다. 구체 적 으로 실 현 된 문 구 는 다음 과 같다.
    pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral/2+pid.Kd*(pid.err-pid.err_last);  //    
    

    총화: 정밀도 향상.
    포 인 트 를 바 꾸 는 PID 제어 계산법 C 언어 구현
    변 적분 PID 는 적분 분 리 된 PID 알고리즘 의 더 일반적인 형식 으로 볼 수 있다.일반적인 PID 제어 알고리즘 에서 포인트 계수 ki 는 상수 이기 때문에 전체 제어 과정 에서 포인트 증 가 는 변 하지 않 습 니 다.그러나 시스템 이 포인트 항목 에 대한 요 구 는 시스템 의 편차 가 클 때 포인트 작용 이 약해 지고 심지어 전무 해 야 하 며 편차 시간 에 강화 해 야 한 다 는 것 이다.적분 계 수 를 크게 취하 면 초 조 가 발생 하고 심지어 적분 이 포화 되 며 작 게 취하 면 짧 은 시간 안에 정 차 를 없 앨 수 없다.따라서 시스템 의 편차 크기 에 따라 포인트 속 도 를 바 꾸 는 것 이 필요 하 다.포인트 변경 PID 의 기본 사상 은 포인트 항목 의 누적 속 도 를 바 꾸 어 편차 크기 와 대응 하도록 하 는 것 이다. 편차 가 클 수록 포인트 가 느리다.편차 가 적 을 수록 포인트 가 빠르다.
    여기 포인트 계수 앞 에 비례 값 index 를 추가 합 니 다:
     abs(err)<180 ,index=1;
    
     180200 ,index=0;
    

    최종 비례 부분의 비례 계 수 치 는 ki * index 입 니 다.구체 적 인 PID 구현 코드 는 다음 과 같 습 니 다.
    pid.Kp=0.4;
    pid.Ki=0.2;    //       
    pid.Kd=0.2;
    
    float PID_realize(float speed){
    	float index;
        pid.SetSpeed=speed;
        pid.err=pid.SetSpeed-pid.ActualSpeed;
    
        if(abs(pid.err)>200)           //     
        {
    	    index=0.0;
        }else if(abs(pid.err)<180){
    	    index=1.0;
    	    pid.integral+=pid.err;
        }else{
    	    index=(200-abs(pid.err))/20;
    	    pid.integral+=pid.err;
        }
        pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);
    
        pid.err_last=pid.err;
        pid.ActualSpeed=pid.voltage*1.0;
        return pid.ActualSpeed;
    }
    

    결론: 시스템 의 안정 속도 가 매우 빠르다. 나 는 다른 블 로그 에 있다.https://blog.csdn.net/qq_37258787 / article / details / 79603352 는 Kotlin 언어 로 상기 기능 을 실현 하고 간단 한 데이터 시각 화 전 시 를 실시 했다.

    좋은 웹페이지 즐겨찾기