clc

% TORNOZELO
    % BINARIO
        BinarioCargaMaximaMinimaMediaServoTornozelok(1,1) = ...
            max(BinTorDir.signals.values);
        BinarioCargaMaximaMinimaMediaServoTornozelok(1,2) = ...
            min(BinTorDir.signals.values);
        BinarioCargaMaximaMinimaMediaServoTornozelok(1,3) = ...
            sum(BinTorDir.signals.values) / size(BinTorDir.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoTornozelok(1,5) = ...
%            max(BinTorDir1.signals.values);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(1,6) = ...
%            min(BinTorDir1.signals.values);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(1,7) = ...
%            sum(BinTorDir1.signals.values) / size(BinTorDir.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoTornozelok(1,9) = ...
%            max(BinTorDir2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(1,10) = ...
%            min(BinTorDir2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(1,11) = ...
%            sum(BinTorDir2.signals.values) / size(BinTorDir2.signals.values,1);


    % CARGA
        BinarioCargaMaximaMinimaMediaServoTornozelok(2,1) = ...
            max(BinTorDir.signals.values / 12 * 100);
        BinarioCargaMaximaMinimaMediaServoTornozelok(2,2) = ...
            min(BinTorDir.signals.values / 12 * 100);
        BinarioCargaMaximaMinimaMediaServoTornozelok(2,3) = ...
            sum(BinTorDir.signals.values / 12 * 100) / size(BinTorDir.signals.values / 12 * 100,1);

%        BinarioCargaMaximaMinimaMediaServoTornozelok(2,5) = ...
%            max(BinTorDir1.signals.values / 12 * 100);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(2,6) = ...
%            min(BinTorDir1.signals.values / 12 * 100);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(2,7) = ...
%            sum(BinTorDir1.signals.values / 12 * 100) / size(BinTorDir1.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoTornozelok(2,9) = ...
%            max(BinTorDir2.signals.values / 12 * 100);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(2,10) = ...
%            min(BinTorDir2.signals.values / 12 * 100);
%        BinarioCargaMaximaMinimaMediaServoTornozelok(2,11) = ...
%            sum(BinTorDir2.signals.values / 12 * 100) / size(BinTorDir2.signals.values,1);


        BinarioCargaMaximaMinimaMediaServoTornozelok

    % GRAFICO
        figure(1);
        
        subplot(2,3,1);
        
        plot(PontosSimulacao,BinTorDir.signals.values,'c');
        hold on;
%        plot(PontosSimulacao,BinTorDir1.signals.values,'b');
%        plot(PontosSimulacao,BinTorDir2.signals.values,'r');
        plot(PontosSimulacao,AngTorDir.signals.values,'g');
        axis([0 PontosSimulacao(1,size(PontosSimulacao,2)) -12 12]);
        grid on; hold off;
        title('Variacao Binario Tornozelo para k dif');
        
        subplot(2,3,4);
        plot(PontosSimulacao,BinTorDir.signals.values / 12 * 100,'c');grid on;
        hold on;
%        plot(PontosSimulacao,BinTorDir1.signals.values / 12 * 100,'b');grid on;
%        plot(PontosSimulacao,BinTorDir2.signals.values / 12 * 100,'r');grid on;
        plot(PontosSimulacao,AngTorDir.signals.values,'g');
        axis([0 PontosSimulacao(size(PontosSimulacao,2),1) -100 100]);
        grid on; hold off;
        title('Variacao Taxa Tornozelo para k dif');

% JOELHO
    % BINARIO
        BinarioCargaMaximaMinimaMediaServoJoelhok(1,1) = ...
            max(BinarioServoJoelhok1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhok(1,2) = ...
            min(BinarioServoJoelhok1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhok(1,3) = ...
            sum(BinarioServoJoelhok1.signals.values) / size(BinarioServoJoelhok1.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoJoelhok(1,5) = ...
%            max(BinarioServoJoelhok2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(1,6) = ...
%            min(BinarioServoJoelhok2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(1,7) = ...
%            sum(BinarioServoJoelhok2.signals.values) / size(BinarioServoJoelhok2.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoJoelhok(1,9) = ...
%            max(BinarioServoJoelhok3.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(1,10) = ...
%            min(BinarioServoJoelhok3.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(1,11) = ...
%            sum(BinarioServoJoelhok3.signals.values) / size(BinarioServoJoelhok3.signals.values,1);

        
    % CARGA
        BinarioCargaMaximaMinimaMediaServoJoelhok(2,1) = ...
            max(CargaServoJoelhok1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhok(2,2) = ...
            min(CargaServoJoelhok1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhok(2,3) = ...
            sum(CargaServoJoelhok1.signals.values) / size(BinarioServoJoelhok1.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoJoelhok(2,5) = ...
%            max(CargaServoJoelhok2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(2,6) = ...
%            min(CargaServoJoelhok2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(2,7) = ...
%            sum(CargaServoJoelhok2.signals.values) / size(BinarioServoJoelhok2.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoJoelhok(2,9) = ...
%            max(CargaServoJoelhok3.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(2,10) = ...
%            min(CargaServoJoelhok3.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhok(2,11) = ...
%            sum(CargaServoJoelhok3.signals.values) / size(BinarioServoJoelhok3.signals.values,1);

        
        BinarioCargaMaximaMinimaMediaServoJoelhok
        
    % GRAFICO
        subplot(2,3,2);
        plot(BinarioServoJoelhok1.time,BinarioServoJoelhok1.signals.values,'c');grid on;
        hold on;
%        plot(BinarioServoJoelhok2.time,BinarioServoJoelhok2.signals.values,'b');grid on;
%        plot(BinarioServoJoelhok3.time,BinarioServoJoelhok3.signals.values,'r');grid on;
        plot(AnguloServoJoelho.time, AnguloServoJoelho.signals.values/100,'g');
        axis([0 BinarioServoJoelhok1.time(size(BinarioServoJoelhok1.time,1),1) -4 4]);
        grid on;hold off;
        title('Variacao Binario Joelho para k dif');
        
        subplot(2,3,5);
        plot(CargaServoJoelhok1.time, CargaServoJoelhok1.signals.values,'c');grid on;
        hold on;
%        plot(CargaServoJoelhok2.time, CargaServoJoelhok2.signals.values,'b');grid on;
%        plot(CargaServoJoelhok3.time, CargaServoJoelhok3.signals.values,'r');grid on;
        plot(AnguloServoJoelho.time, AnguloServoJoelho.signals.values,'g');
        axis([0 CargaServoJoelhok1.time(size(CargaServoJoelhok1.time,1),1) -100 100]);
        grid on;hold off;
        title('Variacao Taxa Joelho para k dif');
    
%ANCA
    % BINARIO
        BinarioCargaMaximaMinimaMediaServoAncak(1,1) = ...
            max(BinarioServoAncak1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncak(1,2) = ...
            min(BinarioServoAncak1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncak(1,3) = ...
            sum(BinarioServoAncak1.signals.values) / size(BinarioServoAncak1.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoAncak(1,5) = ...
%            max(BinarioServoAncak2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoAncak(1,6) = ...
%            min(BinarioServoAncak2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoAncak(1,7) = ...
%            sum(BinarioServoAncak2.signals.values) / size(BinarioServoAncak2.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoAncak(1,9) = ...
%            max(BinarioServoAncak3.signals.values);
%        BinarioCargaMaximaMinimaMediaServoAncak(1,10) = ...
%            min(BinarioServoAncak3.signals.values);
%        BinarioCargaMaximaMinimaMediaServoAncak(1,11) = ...
%            sum(BinarioServoAncak3.signals.values) / size(BinarioServoAncak3.signals.values,1);
       
    % CARGA
        BinarioCargaMaximaMinimaMediaServoAncak(2,1) = ...
            max(CargaServoAncak1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncak(2,2) = ...
            min(CargaServoAncak1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncak(2,3) = ...
            sum(CargaServoAncak1.signals.values) / size(BinarioServoAncak1.signals.values,1);

%        BinarioCargaMaximaMinimaMediaServoAncak(2,5) = ...
%            max(CargaServoAncak2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoAncak(2,6) = ...
%            min(CargaServoAncak2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoAncak(2,7) = ...
%            sum(CargaServoAncak2.signals.values) / size(BinarioServoAncak2.signals.values,1);

 %       BinarioCargaMaximaMinimaMediaServoAncak(2,9) = ...
 %           max(CargaServoAncak3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoAncak(2,10) = ...
 %           min(CargaServoAncak3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoAncak(2,11) = ...
 %           sum(CargaServoAncak3.signals.values) / size(BinarioServoAncak3.signals.values,1);

        
        BinarioCargaMaximaMinimaMediaServoAncak
        
    % GRAFICO
        subplot(2,3,3);
        plot(BinarioServoAncak1.time, BinarioServoAncak1.signals.values,'c');grid on;
        hold on;
  %      plot(BinarioServoAncak2.time, BinarioServoAncak2.signals.values,'b');grid on;
  %      plot(BinarioServoAncak3.time, BinarioServoAncak3.signals.values,'r');grid on;
        plot(AnguloServoAnca.time, AnguloServoAnca.signals.values/100,'g');
        axis([0 BinarioServoAncak1.time(size(BinarioServoAncak1.time,1),1) -4 4]);
        grid on;hold off;
        title('Variacao Binario Anca para k dif');
        
        subplot(2,3,6);
        plot(CargaServoAncak1.time, CargaServoAncak1.signals.values,'c');grid on;
        hold on;
   %     plot(CargaServoAncak2.time, CargaServoAncak2.signals.values,'b');grid on;
   %     plot(CargaServoAncak3.time, CargaServoAncak3.signals.values,'r');grid on;
        plot(AnguloServoAnca.time, AnguloServoAnca.signals.values,'g')
        axis([0 CargaServoAncak1.time(size(CargaServoAncak1.time,1),1) -100 100]);
        grid on;hold off;
        title('Variacao Taxa Anca para k dif');
        
        
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


% TORNOZELO
    % BINARIO
        BinarioCargaMaximaMinimaMediaServoTornozeloF(1,1) = ...
            max(BinarioServoTornozeloFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoTornozeloF(1,2) = ...
            min(BinarioServoTornozeloFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoTornozeloF(1,3) = ...
            sum(BinarioServoTornozeloFreq1.signals.values) / size(BinarioServoTornozeloFreq1.signals.values,1);

  %      BinarioCargaMaximaMinimaMediaServoTornozeloF(1,5) = ...
  %          max(BinarioServoTornozeloFreq2.signals.values);
  %      BinarioCargaMaximaMinimaMediaServoTornozeloF(1,6) = ...
   %         min(BinarioServoTornozeloFreq2.signals.values);
   %     BinarioCargaMaximaMinimaMediaServoTornozeloF(1,7) = ...
  %          sum(BinarioServoTornozeloFreq2.signals.values) / size(BinarioServoTornozeloFreq2.signals.values,1);

 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(1,9) = ...
 %           max(BinarioServoTornozeloFreq3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(1,10) = ...
 %           min(BinarioServoTornozeloFreq3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(1,11) = ...
 %           sum(BinarioServoTornozeloFreq3.signals.values) / size(BinarioServoTornozeloFreq3.signals.values,1);

            
    % CARGA
        BinarioCargaMaximaMinimaMediaServoTornozeloF(2,1) = ...
            max(CargaServoTornozeloFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoTornozeloF(2,2) = ...
            min(CargaServoTornozeloFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoTornozeloF(2,3) = ...
            sum(CargaServoTornozeloFreq1.signals.values) / size(BinarioServoTornozeloFreq1.signals.values,1);

 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(2,5) = ...
 %           max(CargaServoTornozeloFreq2.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(2,6) = ...
 %           min(CargaServoTornozeloFreq2.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(2,7) = ...
  %          sum(CargaServoTornozeloFreq2.signals.values) / size(BinarioServoTornozeloFreq2.signals.values,1);

 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(2,9) = ...
 %           max(CargaServoTornozeloFreq3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(2,10) = ...
 %           min(CargaServoTornozeloFreq3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoTornozeloF(2,11) = ...
 %           sum(CargaServoTornozeloFreq3.signals.values) / size(BinarioServoTornozeloFreq3.signals.values,1);

        
        BinarioCargaMaximaMinimaMediaServoTornozeloF
        
    % GRAFICO
        figure(2);
        
        subplot(2,3,1);
        
        plot(BinarioServoTornozeloFreq1.time,BinarioServoTornozeloFreq1.signals.values,'c');
        hold on;
     %   plot(BinarioServoTornozeloFreq2.time,BinarioServoTornozeloFreq2.signals.values,'b');
  %      plot(BinarioServoTornozeloFreq3.time,BinarioServoTornozeloFreq3.signals.values,'r');
        %plot(AnguloServoTornozelo.time,AnguloServoTornozelo.signals.values,'g');
        axis([0 BinarioServoTornozeloFreq1.time(size(BinarioServoTornozeloFreq1.time,1),1) -12 12]);
        grid on; hold off;
        title('Variacao Binario Tornozelo para Freq dif');
        
        subplot(2,3,4);
        plot(CargaServoTornozeloFreq1.time,CargaServoTornozeloFreq1.signals.values,'c');grid on;
        hold on;
  %      plot(CargaServoTornozeloFreq2.time,CargaServoTornozeloFreq2.signals.values,'b');grid on;
  %      plot(CargaServoTornozeloFreq3.time,CargaServoTornozeloFreq3.signals.values,'r');grid on;
        %plot(AnguloServoTornozelo.time, AnguloServoTornozelo.signals.values,'g');
        axis([0 CargaServoTornozeloFreq1.time(size(CargaServoTornozeloFreq1.time,1),1) -100 100]);
        grid on; hold off;
        title('Variacao Carga Tornozelo para Freq dif');

% JOELHO
    % BINARIO
        BinarioCargaMaximaMinimaMediaServoJoelhoF(1,1) = ...
            max(BinarioServoJoelhoFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhoF(1,2) = ...
            min(BinarioServoJoelhoFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhoF(1,3) = ...
            sum(BinarioServoJoelhoFreq1.signals.values) / size(BinarioServoJoelhoFreq1.signals.values,1);

  %      BinarioCargaMaximaMinimaMediaServoJoelhoF(1,5) = ...
%            max(BinarioServoJoelhoFreq2.signals.values);
%        BinarioCargaMaximaMinimaMediaServoJoelhoF(1,6) = ...
%            min(BinarioServoJoelhoFreq2.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoJoelhoF(1,7) = ...
 %           sum(BinarioServoJoelhoFreq2.signals.values) / size(BinarioServoJoelhoFreq2.signals.values,1);

 %       BinarioCargaMaximaMinimaMediaServoJoelhoF(1,9) = ...
 %           max(BinarioServoJoelhoFreq3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoJoelhoF(1,10) = ...
 %           min(BinarioServoJoelhoFreq3.signals.values);
 %       BinarioCargaMaximaMinimaMediaServoJoelhoF(1,11) = ...
 %           sum(BinarioServoJoelhoFreq3.signals.values) / size(BinarioServoJoelhoFreq3.signals.values,1);

        
    % CARGA
        BinarioCargaMaximaMinimaMediaServoJoelhoF(2,1) = ...
            max(CargaServoJoelhoFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhoF(2,2) = ...
            min(CargaServoJoelhoFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoJoelhoF(2,3) = ...
            sum(CargaServoJoelhoFreq1.signals.values) / size(BinarioServoJoelhoFreq1.signals.values,1);

  %      BinarioCargaMaximaMinimaMediaServoJoelhoF(2,5) = ...
  %          max(CargaServoJoelhoFreq2.signals.values);
  %      BinarioCargaMaximaMinimaMediaServoJoelhoF(2,6) = ...
   %         min(CargaServoJoelhoFreq2.signals.values);
   %     BinarioCargaMaximaMinimaMediaServoJoelhoF(2,7) = ...
  %          sum(CargaServoJoelhoFreq2.signals.values) / size(BinarioServoJoelhoFreq2.signals.values,1);

  %      BinarioCargaMaximaMinimaMediaServoJoelhoF(2,9) = ...
   %         max(CargaServoJoelhoFreq3.signals.values);
   %     BinarioCargaMaximaMinimaMediaServoJoelhoF(2,10) = ...
   %         min(CargaServoJoelhoFreq3.signals.values);
   %     BinarioCargaMaximaMinimaMediaServoJoelhoF(2,11) = ...
   %         sum(CargaServoJoelhoFreq3.signals.values) / size(BinarioServoJoelhoFreq3.signals.values,1);

        
        BinarioCargaMaximaMinimaMediaServoJoelhoF
        
    % GRAFICO
        subplot(2,3,2);
        plot(BinarioServoJoelhoFreq1.time,BinarioServoJoelhoFreq1.signals.values,'c');grid on;
        hold on;
     %   plot(BinarioServoJoelhoFreq2.time,BinarioServoJoelhoFreq2.signals.values,'b');grid on;
  %      plot(BinarioServoJoelhoFreq3.time,BinarioServoJoelhoFreq3.signals.values,'r');grid on;
        %plot(AnguloServoJoelho.time, AnguloServoJoelho.signals.values/100,'g');
        axis([0 BinarioServoJoelhoFreq1.time(size(BinarioServoJoelhoFreq1.time,1),1) -4 4]);
        grid on;hold off;
        title('Variacao Binario Joelho para Freq dif');
        
        subplot(2,3,5);
        plot(CargaServoJoelhoFreq1.time, CargaServoJoelhoFreq1.signals.values,'c');grid on;
        hold on;
   %     plot(CargaServoJoelhoFreq2.time, CargaServoJoelhoFreq2.signals.values,'b');grid on;
  %      plot(CargaServoJoelhoFreq3.time, CargaServoJoelhoFreq3.signals.values,'r');grid on;
        %plot(AnguloServoJoelho.time, AnguloServoJoelho.signals.values,'g');
        axis([0 CargaServoJoelhoFreq1.time(size(CargaServoJoelhoFreq1.time,1),1) -100 100]);
        grid on;hold off;
        title('Variacao Taxa Joelho para Freq dif');
    
%ANCA
    % BINARIO
        BinarioCargaMaximaMinimaMediaServoAncaF(1,1) = ...
            max(BinarioServoAncaFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncaF(1,2) = ...
            min(BinarioServoAncaFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncaF(1,3) = ...
            sum(BinarioServoAncaFreq1.signals.values) / size(BinarioServoAncaFreq1.signals.values,1);

  %      BinarioCargaMaximaMinimaMediaServoAncaF(1,5) = ...
  %          max(BinarioServoAncaFreq2.signals.values);
  %      BinarioCargaMaximaMinimaMediaServoAncaF(1,6) = ...
  %          min(BinarioServoAncaFreq2.signals.values);
  %      BinarioCargaMaximaMinimaMediaServoAncaF(1,7) = ...
  %          sum(BinarioServoAncaFreq2.signals.values) / size(BinarioServoAncaFreq2.signals.values,1);

   %     BinarioCargaMaximaMinimaMediaServoAncaF(1,9) = ...
   %         max(BinarioServoAncaFreq3.signals.values);
   %     BinarioCargaMaximaMinimaMediaServoAncaF(1,10) = ...
  %          min(BinarioServoAncaFreq3.signals.values);
  %      BinarioCargaMaximaMinimaMediaServoAncaF(1,11) = ...
  %          sum(BinarioServoAncaFreq3.signals.values) / size(BinarioServoAncaFreq3.signals.values,1);
       
    % CARGA
        BinarioCargaMaximaMinimaMediaServoAncaF(2,1) = ...
            max(CargaServoAncaFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncaF(2,2) = ...
            min(CargaServoAncaFreq1.signals.values);
        BinarioCargaMaximaMinimaMediaServoAncaF(2,3) = ...
            sum(CargaServoAncaFreq1.signals.values) / size(BinarioServoAncaFreq1.signals.values,1);

   %     BinarioCargaMaximaMinimaMediaServoAncaF(2,5) = ...
    %        max(CargaServoAncaFreq2.signals.values);
    %    BinarioCargaMaximaMinimaMediaServoAncaF(2,6) = ...
    %        min(CargaServoAncaFreq2.signals.values);
    %    BinarioCargaMaximaMinimaMediaServoAncaF(2,7) = ...
    %        sum(CargaServoAncaFreq2.signals.values) / size(BinarioServoAncaFreq2.signals.values,1);

     %   BinarioCargaMaximaMinimaMediaServoAncaF(2,9) = ...
     %       max(CargaServoAncaFreq3.signals.values);
   %     BinarioCargaMaximaMinimaMediaServoAncaF(2,10) = ...
   %         min(CargaServoAncaFreq3.signals.values);
   %     BinarioCargaMaximaMinimaMediaServoAncaF(2,11) = ...
   %         sum(CargaServoAncaFreq3.signals.values) / size(BinarioServoAncaFreq3.signals.values,1);

        
        BinarioCargaMaximaMinimaMediaServoAncaF
        
    % GRAFICO
        subplot(2,3,3);
        plot(BinarioServoAncaFreq1.time, BinarioServoAncaFreq1.signals.values,'c');grid on;
        hold on;
    %    plot(BinarioServoAncaFreq2.time, BinarioServoAncaFreq2.signals.values,'b');grid on;
    %    plot(BinarioServoAncaFreq3.time, BinarioServoAncaFreq3.signals.values,'r');grid on;
        %plot(AnguloServoAnca.time, AnguloServoAnca.signals.values/100,'g');
        axis([0 BinarioServoAncaFreq1.time(size(BinarioServoAncaFreq1.time,1),1) -4 4]);
        grid on;hold off;
        title('Variacao Binario Anca para Freq dif');
        
        subplot(2,3,6);
        plot(CargaServoAncaFreq1.time, CargaServoAncaFreq1.signals.values,'c');grid on;
        hold on;
  %      plot(CargaServoAncaFreq2.time, CargaServoAncaFreq2.signals.values,'b');grid on;
  %      plot(CargaServoAncaFreq3.time, CargaServoAncaFreq3.signals.values,'r');grid on;
        %plot(AnguloServoAnca.time, AnguloServoAnca.signals.values,'g')
        axis([0 CargaServoAncaFreq1.time(size(CargaServoAncaFreq1.time,1),1) -100 100]);
        grid on;hold off;
        title('Variacao Taxa Anca para Freq dif');