API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 28th, 2017
118
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.82 KB | None | 0 0
raw download clone embed print report
  1. #pragma config OSC = INTIO67    // внутренний осциллятор
  2. #pragma config WDT = OFF        // сторожевой таймер выключен
  3. #pragma config LVP = OFF
  4. #include <p18f4520.h>           // подключение заголовочных файлов
  5.  
  6. void main () {
  7.     int fuzA[][]={  {-500,-500,-150}.
  8.                 {-400,-232,-64},
  9.                 {-128,-64,0},
  10.                 {-32,0,32},
  11.                 {0,64,128},
  12.                 {64,232,400},
  13.                 {150,500,500}   },
  14.         fuzB[][]={  {-20,-20,-8}.
  15.                 {-14,8,-2},
  16.                 {-6,-3,0},
  17.                 {-1,0,1},
  18.                 {0,3,6},
  19.                 {2,8,14},
  20.                 {8,20,20}   },
  21.         fuzC[][]={  {-15,-15,-7}.
  22.                 {-12,-7,-2},
  23.                 {-6,-3,0},
  24.                 {-2,0,2},
  25.                 {0,3,6},
  26.                 {2,7,12},
  27.                 {7,15,15}   };
  28.     float mA[], mB[], x1, x2, x1_prev, tmp;
  29.     double Hsens, Hfix;
  30.     float numerator, denominator, control;
  31.     x1=0;
  32.     x2=0;
  33.  
  34.     OSCCON=0b11110011;      // выбор осциллятора (внутренний, 8 МГц)
  35.     LATC=0x00;         
  36.     TRISC=0b10000000        // 1 бит - PWM output, 6 - TX, 7 – RX USART
  37. //настройка АЦП
  38.     ADCON1=0b00001110;      // настройка выводов и опорного напряжения
  39.     ADCON2=0b10111101;      // правое выравнивание, Fosc/16 и 20 TAD
  40.     ADCON0=0b00000001;      // выбор канала AN0 и включение АЦП
  41. //настройка ШИП
  42.     PR2=0x3F                // установка периода PWM
  43.     T2CON=0b00000100;       // включение и настройка TIMER2
  44.     CCP2CON=0b00001100;     // включение и настройка модуля CCP2
  45. //настройка USART
  46.     SPBRG=D’12’;            // 9600 бод/с
  47.        BAUDCON=0b01000001;  // настройка
  48.        TXSTA=0b10110010;    // cинхронный режим, master, передача
  49.        RCSTA=0b10000000;    // одиночный прием
  50.    
  51.     while (1) {
  52.         ADCON0bits.GO=1;        // запуск преобразования
  53.         while(ADCON0bits.GO);   // ожидание конца преобразования
  54. // чтение результата преобразования и выражение его в метрах
  55.         Hsens=6.636*(ADRESH*256+ADRESL);
  56.  
  57.         RCSTAbits.SREN=1;       // разрешение приема
  58.        while(!PIR1bits.RCIF);   // ожидание конца приема старшего бита
  59.        Hfix=RCREG;
  60.        Hfix<<=8;
  61. RCSTAbits.SREN=1;   // разрешение приема
  62.        while(!PIR1bits.RCIF);   // ожидание конца приема младшего бита
  63.        Hfix+=RCREG;
  64.             x1_prev = x1;
  65.        x1 = Hfix-Hsens;         // расчет ошибки по высоте
  66.        x2 = x1 – x1_prev;     // расчет производной ошибки по высоте
  67. //проверка на вхождение x1 и x2 в пределы значений входов регулятора
  68.        if (x1>500) x1=500;
  69.        if (x1<-500) x1=-500;
  70.        if (x2>20) x1=20;
  71.        if (x2<-20) x1=-20;
  72.        
  73. // поиск степеней принадлежности x1 и x2 к термам соответствующих ЛП
  74.         for (i=0;i!=7;i++) {
  75.             if (fuzA[i][0] < x1 < fuzA[i][2])
  76.                 if (fuzA[i][0] < x1 < fuzA[i][1])
  77.                     mA[i] = (x1-fuzA[i][0])/(fuzA[i][1]-fuzA[i][0]);
  78.                 else
  79.                     mA[i] = (fuzA[i][2]-x1)/(fuzA[i][2]-fuzA[i][1]);
  80.             if (fuzB[i][0] < x2 < fuzB[i][2])
  81.                 if (fuzB[i][0] < x2 < fuzB[i][1])
  82.                     mB[i] = (x2-fuzB[i][0])/(fuzB[i][1]-fuzB[i][0]);
  83.                 else
  84.                     mB[i] = (fuzB[i][2]-x2)/(fuzB[i][2]-fuzB[i][1]);
  85.                     };
  86.         numerator = 0;
  87.         denominator = 0;
  88. /* применение соответствующих правил, определение степеней активности. дефуззификация по среднему центру. */
  89.         if (mA[0])
  90.             for (k=0;k!=7;k++) {
  91.                 switch (k) {
  92.                     case 0: case 1: case 2:
  93.                         if (mB[k])
  94.                             {tmp = mA[0]*mB[k];
  95.                             denominator += tmp;
  96.                             numerator += tmp*fuzC[0][1]};
  97.                     case 3: case 4:
  98.                         if (mB[k])
  99.                             {tmp = mA[0]*mB[k];
  100.                             denominator += tmp;
  101.                             numerator += tmp*fuzC[1][1]};
  102.                     case 5:
  103.                         if (mB[k])
  104.                             {tmp = mA[0]*mB[k];
  105.                             denominator += tmp;
  106.                             numerator += tmp*fuzC[2][1]};
  107.                     case 6:
  108.                         if (mB[k])
  109.                             {tmp = mA[0]*mB[k];
  110.                             denominator += tmp;
  111.                             numerator += tmp*fuzC[3][1]};
  112.                             };
  113.                         };
  114.         if (mA[1])
  115.             for (k=0;k!=7;k++) {
  116.                 switch (k) {
  117.                     case 0: case 1:
  118.                         if (mB[k])
  119.                             {tmp = mA[1]*mB[k];
  120.                             denominator += tmp;
  121.                             numerator += tmp*fuzC[0][1]};
  122.                      case 2: case 3:
  123.                         if (mB[k])
  124.                             {tmp = mA[1]*mB[k];
  125.                             denominator += tmp;
  126.                             numerator += tmp*fuzC[1][1]};
  127.                     case 4:
  128.                         if (mB[k])
  129.                             {tmp = mA[1]*mB[k];
  130.                             denominator += tmp;
  131.                             numerator += tmp*fuzC[2][1]};
  132.                     case 5:
  133.                         if (mB[k])
  134.                             {tmp = mA[1]*mB[k];
  135.                             denominator += tmp;
  136.                             numerator += tmp*fuzC[3][1]};
  137.                     case 6:
  138.                         if (mB[k])
  139.                             {tmp = mA[1]*mB[k];
  140.                             denominator += tmp;
  141.                             numerator += tmp*fuzC[4][1]};
  142.                             };
  143.                         };
  144.         if (mA[2])
  145.             for (k=0;k!=7;k++) {
  146.                 switch (k) {
  147.                     case 0:
  148.                         if (mB[k])
  149.                             {tmp = mA[2]*mB[k];
  150.                             denominator += tmp;
  151.                             numerator += tmp*fuzC[0][1]};
  152.                     case 1: case 2:
  153.                         if (mB[k])
  154.                             {tmp = mA[2]*mB[k];
  155.                             denominator += tmp;
  156.                             numerator += tmp*fuzC[1][1]};
  157.                     case 3:
  158.                         if (mB[k])
  159.                             {tmp = mA[2]*mB[k];
  160.                             denominator += tmp;
  161.                             numerator += tmp*fuzC[2][1]};
  162.                     case 4:
  163.                         if (mB[k])
  164.                             {tmp = mA[2]*mB[k];
  165.                             denominator += tmp;
  166.                             numerator += tmp*fuzC[3][1]};
  167.                     case 5:
  168.                         if (mB[k])
  169.                             {tmp = mA[2]*mB[k];
  170.                             denominator += tmp;
  171.                             numerator += tmp*fuzC[4][1]};
  172.                     case 6:
  173.                         if (mB[k])
  174.                             {tmp = mA[2]*mB[k];
  175.                             denominator += tmp;
  176.                             numerator += tmp*fuzC[5][1]};
  177.                             };
  178.                         };
  179.         if (mA[3])
  180.             for (k=0;k!=7;k++) {
  181.                 switch (k) {
  182.                     case 0: case 1:
  183.                         if (mB[k])
  184.                             {tmp = mA[3]*mB[k];
  185.                             denominator += tmp;
  186.                             numerator += tmp*fuzC[1][1]};
  187.                     case 2:
  188.                         if (mB[k])
  189.                             {tmp = mA[3]*mB[k];
  190.                             denominator += tmp;
  191.                             numerator += tmp*fuzC[2][1]};
  192.                     case 3:
  193.                         if (mB[k])
  194.                             {tmp = mA[3]*mB[k];
  195.                             denominator += tmp;
  196.                             numerator += tmp*fuzC[3][1]};
  197.                     case 4:
  198.                         if (mB[k])
  199.                             {tmp = mA[3]*mB[k];
  200.                             denominator += tmp;
  201.                             numerator += tmp*fuzC[4][1]};
  202.                     case 5: case 6:
  203.                         if (mB[k])
  204.                             {tmp = mA[3]*mB[k];
  205.                             denominator += tmp;
  206.                             numerator += tmp*fuzC[5][1]};
  207.                             };
  208.                         };
  209.         if (mA[4])
  210.             for (k=0;k!=7;k++) {
  211.                 switch (k) {
  212.                     case 0:
  213.                         if (mB[k])
  214.                             {tmp = mA[4]*mB[k];
  215.                             denominator += tmp;
  216.                             numerator += tmp*fuzC[1][1]};
  217.                     case 1:
  218.                         if (mB[k])
  219.                             {tmp = mA[4]*mB[k];
  220.                             denominator += tmp;
  221.                             numerator += tmp*fuzC[2][1]};
  222.                     case 2:
  223.                         if (mB[k])
  224.                             {tmp = mA[4]*mB[k];
  225.                             denominator += tmp;
  226.                             numerator += tmp*fuzC[3][1]};
  227.                     case 3:
  228.                         if (mB[k])
  229.                             {tmp = mA[4]*mB[k];
  230.                             denominator += tmp;
  231.                             numerator += tmp*fuzC[4][1]};
  232.                     case 4: case 5:
  233.                         if (mB[k])
  234.                             {tmp = mA[4]*mB[k];
  235.                             denominator += tmp;
  236.                             numerator += tmp*fuzC[5][1]};
  237.                     case 6:
  238.                         if (mB[k])
  239.                             {tmp = mA[4]*mB[k];
  240.                             denominator += tmp;
  241.                             numerator += tmp*fuzC[6][1]};
  242.                             };
  243.                         };
  244.         if (mA[5])
  245.             for (k=0;k!=7;k++) {
  246.                 switch (k) {
  247.                     case 0:
  248.                         if (mB[k])
  249.                             {tmp = mA[5]*mB[k];
  250.                             denominator += tmp;
  251.                             numerator += tmp*fuzC[2][1]};
  252.                     case 1:
  253.                         if (mB[k])
  254.                             {tmp = mA[5]*mB[k];
  255.                             denominator += tmp;
  256.                             numerator += tmp*fuzC[3][1]};
  257.                     case 2:
  258.                         if (mB[k])
  259.                             {tmp = mA[5]*mB[k];
  260.                             denominator += tmp;
  261.                             numerator += tmp*fuzC[4][1]};
  262.                     case 3: case 4:
  263.                         if (mB[k])
  264.                             {tmp = mA[5]*mB[k];
  265.                             denominator += tmp;
  266.                             numerator += tmp*fuzC[5][1]};
  267.                     case 5: case 6:
  268.                         if (mB[k])
  269.                             {tmp = mA[5]*mB[k];
  270.                             denominator += tmp;
  271.                             numerator += tmp*fuzC[6][1]};
  272.                             };
  273.                         };
  274.         if (mA[6])
  275.             for (k=0;k!=7;k++) {
  276.                 switch (k) {
  277.                     case 0:
  278.                         if (mB[k])
  279.                             {tmp = mA[6]*mB[k];
  280.                             denominator += tmp;
  281.                             numerator += tmp*fuzC[3][1]};
  282.                     case 1:
  283.                         if (mB[k])
  284.                             {tmp = mA[6]*mB[k];
  285.                             denominator += tmp;
  286.                             numerator += tmp*fuzC[4][1]};
  287.                     case 2: case 3:
  288.                         if (mB[k])
  289.                             {tmp = mA[6]*mB[k];
  290.                             denominator += tmp;
  291.                             numerator += tmp*fuzC[5][1]};
  292.                     case 4: case 5: case 6:
  293.                         if (mB[k])
  294.                             {tmp = mA[6]*mB[k];
  295.                             denominator += tmp;
  296.                             numerator += tmp*fuzC[6][1]};
  297.                             };
  298.                         };
  299. // расчет выходного значения. передача его в ШИП и в передатчик USART
  300.         control = numerator/denominator;
  301.         CCPR2L = control;
  302.         TXREG = control;
  303.     };
  304. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!