%% Programa para a definição dos parametros da simulacao


%   Este programa permite definir a posicao, velocidade e aceleracao
% angular de todas as juntas de uma perna de um humanoide (6 DOF) assim
% como os valores de k, b e r0 de cada actuador passivo.
%   Este programa está  preparado para uma simulacao em SimMechanics
% na qual existe 2 modelo de 1 perna de 1 Humanoide.

close all
clear all
clc

%ParametrosGUI = slider1()
%pause()
%% Dados

    kiTor = 0;                             % valor inicial do k Tornozelo
    kfTor = 2000;                         % valor final do k Tornozelo
    kiAnc = 0;                             % valor inicial do k Anca
    kfAnc = 2000;                         % valor final do k Anca
    kiJoe = 0;                             % valor inicial do k Joelho
    kfJoe = 2000;                          % valor final do k Joelh
    ekTor = 0.2 * (kfTor - kiTor);         % encremento do valor do k
    ekAnc = 0.2 * (kfAnc - kiAnc);         % encremento do valor do k
    ekJoe = 0.2 * (kfJoe - kiJoe);         % encremento do valor do k
    NumeroSimulacoesTor = (kfTor-kiTor)/ekTor+1;    % Numero de simulações a realizar para um dado valor de k
    NumeroSimulacoesAnc = (kfAnc-kiAnc)/ekAnc+1;    % Numero de simulações a realizar para um dado valor de k
    NumeroSimulacoesJoe = (kfJoe-kiJoe)/ekJoe+1;    % Numero de simulações a realizar para um dado valor de k
    biTor = 0;                             % Contante de amortecimento inicial
    biAnc = 0;                             % Contante de amortecimento inicial
    biJoe = 0;                             % Contante de amortecimento inicial
    r0Tor = 0.010;                         % Dimensão inicial dos actuadores passivos
    r0Anc = 0.010;                         % Dimensão inicial dos actuadores passivos
    r0Joe = 0.010;                         % Dimensão inicial dos actuadores passivos
    ekmin = 1;                             % Encremento minimo de k, condição de paragem do teste

while ekTor > ekmin || ekAnc > ekmin || ekJoe > ekmin       % Condição de paragem do programa
%% ConfiguracaoFiguras
  figura5 = figure(5);
    set(figura5,'position',[500 100 700 900])
    hold on; grid on;axis equal
    Title('Gráficos do binário em função do tempo e em função do angulo')
        
    NumeroSimulacoes = [NumeroSimulacoesTor NumeroSimulacoesJoe NumeroSimulacoesAnc];
    NS = max(NumeroSimulacoes);
    for simulacao = 1 : 1 : NS

        %% Dados
            TSim = [5];          %TempoSimulacao = 5s
            NPS  = 1000;         %NumeroPontosSimulacao = 1000pts TEM DE SER UM NUMERO PAR
            ETSim = TSim / (NPS-1); %EncrmentoTempoSimulacao = TempoSimulacao / NumeroPontosSimulacao
        %% Calculo das Trajectorias desejadas para cada uma das juntas - Tt
            % Este calculo é funcao de:
                %angulo inicial - T0 - Corresponde ao angulo inicial (IC)
                %angulo final - Tf - Corresponde ao angulo máximo
                %tempo de execucao do movimento - tf
            NJ = 0; %Numero da Junta
            for humanoide=1:1:1     %permite fazer a distincção entre os varios modelos do simulador
                TS = TSim(1,humanoide);     %Cada modelo do simulador pode ter um tempo de simulação diferente
                TSMax = max(TSim);          %Tempo total da simulação igual a simulação mais lenta
                ETS = ETSim(1,humanoide);   %Encremento de tempo de cada um dos varios modelos do simulador
                %% PernaDireita
                    %% Tornozelo
                        %TornozeloDireitoX
                            T0 = 0; Tf = -20;  %| -50 até 20º
                            tf = TS/2;          %|DADOS
                            NJ = NJ+1;          %|
                            MovimentoTornozeloDireitoX(:,:,:,humanoide) = ...   %|
                                Movimento5grau(T0,Tf,tf,TS,NPS,ETS,NJ,TSMax);   %|TRAJECTORIA
                        %TornozeloDireitoY
                            T0 = 0; Tf = 0;     %|
                            tf = TS/2;          %|DADOS
                            NJ = NJ+1;          %|
                            MovimentoTornozeloDireitoY(:,:,:,humanoide) = ...   %|
                                Movimento5grau(T0,Tf,tf,TS,NPS,ETS,NJ,TSMax);   %|TRAJECTORIA
                    %% Joelho
                        %JoelhoDireito
                            T0 = 0; Tf = 80;   %| 0 até 130
                            AngJoe = Tf;        %|
                            tf = TS/2;          %|DADOS
                            NJ = NJ+1;          %|
                            MovimentoJoelhoDireito(:,:,:,humanoide) = ...       %|
                                Movimento5grau(T0,Tf,tf,TS,NPS,ETS,NJ,TSMax);   %|TRAJECTORIA
                    %% Anca
                        %AncaDireitaX
                            T0 = 0; Tf = -100;  %| 0 até 120º
                            tf = TS/2;          %|DADOS
                            NJ = NJ+1;          %|
                            MovimentoAncaDireitaX(:,:,:,humanoide) = ...        %|
                                Movimento5grau(T0,Tf,tf,TS,NPS,ETS,NJ,TSMax);   %|TRAJECTORIA
                        %AncaDireitaY
                            T0 = 0; Tf = 0;     %|
                            tf = TS/2;          %|DADOS
                            NJ = NJ+1;          %|
                            MovimentoAncaDireitaY(:,:,:,humanoide) = ...        %|
                                Movimento5grau(T0,Tf,tf,TS,NPS,ETS,NJ,TSMax);   %|TRAJECTORIA
                        %AncaDireitaZ
                            T0 = 0; Tf = 0;     %|
                            tf = TS/2;          %|DADOS
                            NJ = NJ+1;          %|
                            MovimentoAncaDireitaZ(:,:,:,humanoide) = ...        %|
                                Movimento5grau(T0,Tf,tf,TS,NPS,ETS,NJ,TSMax);   %|TRAJECTORIA
    
                %%PernaDireita
                    %% Tornozelo
                    %% Joelho
                    %% Anca

                %% Estrutura
                    %Movimento Estrutura (neste caso so temos a perna direita)
                        MovimentoEstrutura(:,:,:,humanoide) = [          ...
                            MovimentoTornozeloDireitoX(:,:,:,humanoide); ...
                            MovimentoTornozeloDireitoY(:,:,:,humanoide); ...
                            MovimentoJoelhoDireito(:,:,:,humanoide);     ...
                            MovimentoAncaDireitaX(:,:,:,humanoide);      ...
                            MovimentoAncaDireitaY(:,:,:,humanoide);      ...
                            MovimentoAncaDireitaZ(:,:,:,humanoide)];

        %% Preparacao dos dados para serem enviados para o Simulador
        %   Para o simulador é necessário enviar uma matriz de duas colunas
        % em que na primeira temos o indice do tempo no qual queremos que o valor
        % que se encontra na mesma linha e na segunda coluna seja enviado para o
        % simulador

            ParametrosSimulacao(:,:,:,humanoide) = ...
                DadosSimulador(MovimentoEstrutura(:,:,:,humanoide),NPS,ETS);
    
            %% Tornozelo Direito
                AngTorDirX(:,:,:,humanoide) = ParametrosSimulacao(:,:,1,humanoide);
                    VelTorDirX(:,:,:,humanoide) = ParametrosSimulacao(:,:,2,humanoide);
                        AceTorDirX(:,:,:,humanoide) = ParametrosSimulacao(:,:,3,humanoide);
                AngTorDirY(:,:,:,humanoide) = ParametrosSimulacao(:,:,4,humanoide);
                    VelTorDirY(:,:,:,humanoide) = ParametrosSimulacao(:,:,5,humanoide);
                        AceTorDirY(:,:,:,humanoide) = ParametrosSimulacao(:,:,6,humanoide);
        
            %% Joelho Direito
                AngJoeDir(:,:,:,humanoide) = ParametrosSimulacao(:,:,7,humanoide);
                    VelJoeDir(:,:,:,humanoide) = ParametrosSimulacao(:,:,8,humanoide);
                        AceJoeDir(:,:,:,humanoide) = ParametrosSimulacao(:,:,9,humanoide);
        
            %% Anca Direita
                AngAncDirX(:,:,:,humanoide) = ParametrosSimulacao(:,:,10,humanoide);
                    VelAncDirX(:,:,:,humanoide) = ParametrosSimulacao(:,:,11,humanoide);
                        AceAncDirX(:,:,:,humanoide) = ParametrosSimulacao(:,:,12,humanoide);
                AngAncDirY(:,:,:,humanoide) = ParametrosSimulacao(:,:,13,humanoide);
                    VelAncDirY(:,:,:,humanoide) = ParametrosSimulacao(:,:,14,humanoide);
                        AceAncDirY(:,:,:,humanoide) = ParametrosSimulacao(:,:,15,humanoide);  
                AngAncDirZ(:,:,:,humanoide) = ParametrosSimulacao(:,:,16,humanoide);
                    VelAncDirZ(:,:,:,humanoide) = ParametrosSimulacao(:,:,17,humanoide);
                        AceAncDirZ(:,:,:,humanoide) = ParametrosSimulacao(:,:,18,humanoide);
        
            end
    
        %% Definição dos valores de k, b e r0 dos conjuntos mola amortecedor do simulador
            % Para a primeira simulação, parametros por defeito (definidos no inicio deste programa)
            if simulacao==1
                MolRigTorDir1 = kiTor;  MolAmoTorDir1 = biTor;  MolDimTorDir1 = r0Tor;    % [N/m]  []  [m]
                MolRigTorDir2 = kiTor;  MolAmoTorDir2 = biTor;  MolDimTorDir2 = r0Tor;    % [N/m]  []  [m]
                MolRigTorDir3 = kiTor;  MolAmoTorDir3 = biTor;  MolDimTorDir3 = r0Tor;    % [N/m]  []  [m]
                MolRigTorDir4 = kiTor;  MolAmoTorDir4 = biTor;  MolDimTorDir4 = r0Tor;    % [N/m]  []  [m]
                
                MolRigJoeDir1 = kiJoe;  MolAmoJoeDir1 = biJoe;  MolDimJoeDir1 = r0Joe;    % [N/m]  []  [m]
                
                MolRigAncDir1 = kiAnc;  MolAmoAncDir1 = biAnc;  MolDimAncDir1 = r0Anc;    % [N/m]  []  [m]
                MolRigAncDir2 = kiAnc;  MolAmoAncDir2 = biAnc;  MolDimAncDir2 = r0Anc;    % [N/m]  []  [m]
            else
                MolRigTorDir1 = MolRigTorDir1+ekTor;  MolAmoTorDir1 = biTor;  MolDimTorDir1 = r0Tor;    % [N/m]  []  [m]
                MolRigTorDir2 = MolRigTorDir2+ekTor;  MolAmoTorDir2 = biTor;  MolDimTorDir2 = r0Tor;    % [N/m]  []  [m]
                MolRigTorDir3 = MolRigTorDir3+ekTor;  MolAmoTorDir3 = biTor;  MolDimTorDir3 = r0Tor;    % [N/m]  []  [m]
                MolRigTorDir4 = MolRigTorDir4+ekTor;  MolAmoTorDir4 = biTor;  MolDimTorDir4 = r0Tor;    % [N/m]  []  [m]

                MolRigJoeDir1 = MolRigJoeDir1+ekJoe;  MolAmoJoeDir1 = biJoe;  MolDimJoeDir1 = r0Joe;    % [N/m]  []  [m]
                
                MolRigAncDir1 = MolRigAncDir1+ekAnc;  MolAmoAncDir1 = biAnc;  MolDimAncDir1 = r0Anc;    % [N/m]  []  [m]
                MolRigAncDir2 = MolRigAncDir2+ekAnc;  MolAmoAncDir2 = biAnc;  MolDimAncDir2 = r0Anc;    % [N/m]  []  [m]
            end

        %% Arranque do simulador e tempo de espera de conclusão do mesmo
            Tempo = 0;
            startsimulation = 1;
            if simulacao == NumeroSimulacoesTor+1  %Se a simulação anterior foi a ultima
                break
            else                                %Realização da simulação
                while max(Tempo) < max(TSim)-0.000001   %Enquanto o tempo da simulação, TSim, não acabar...
                    if startsimulation == 1     %Se esta for a primeira simulação
                        sim('TornozeloJoelhoAnca')     %Arranque do simulador
                        startsimulation = 0;    %A primeira simulação ja ocorreu
                    end
                    DadosSimulacao = [simulacao MolRigTorDir1 MolRigTorDir2 MolRigTorDir3 MolRigTorDir4]
                    Simulation='    Waiting for simulation'
                    pause(0.1)
                    clc
                    DadosSimulacao = [simulacao MolRigTorDir1 MolRigTorDir2 MolRigTorDir3 MolRigTorDir4]
                    Simulation='    Waiting for simulation .'
                    pause(0.1)
                    clc
                    DadosSimulacao = [simulacao MolRigTorDir1 MolRigTorDir2 MolRigTorDir3 MolRigTorDir4]
                    Simulation='    Waiting for simulation ..'
                    pause(0.1)
                    clc
                    DadosSimulacao = [simulacao MolRigTorDir1 MolRigTorDir2 MolRigTorDir3 MolRigTorDir4]
                    Simulation='    Waiting for simulation ...'
                    pause(0.1)
                    clc
                end
            end
            Simulation = '    DONE :)';

        %% Criação dos graficos relativos a trajectoria imposta
%            figure(6)
%                axis([min(Tempo) max(Tempo) 1.2*min(MedAngTorDirX) 1.2*max(MedAngTorDirX)])
%                subplot(1,3,1);    hold on;    grid on;    title('Angulo');
%                axis([min(Tempo) max(Tempo) 1.2*min(MedAngTorDirX) 1.2*max(MedAngTorDirX)])
%                    plot(Tempo,MedAngTorDirX,'COLOR',[0 0.45 0],'linewidth',2)
                    %plot(Tempo,MedAngJoeDir ,'COLOR',[0 0.45 0],'linewidth',2)
                    %plot(Tempo,MedAngAncDirX,'COLOR',[0 0.45 0],'linewidth',2)
%                    line([max(Tempo)/2 max(Tempo)/2],[1.1*min(MedAngTorDirX) 1.1*max(MedAngTorDirX)],'COLOR',[1 0 0],'linewidth',1)
%                subplot(1,3,2);    hold on;    grid on;    title('Velocidade')
%                axis([min(Tempo) max(Tempo) 1.2*min(MedVelTorDirX) 1.2*max(MedVelTorDirX)])
%                    plot(Tempo,MedVelTorDirX,'COLOR',[0 0.45 0],'linewidth',2)
%                    line([max(Tempo)/2 max(Tempo)/2],[1.1*min(MedVelTorDirX) 1.1*max(MedVelTorDirX)],'COLOR',[1 0 0],'linewidth',1)
%               subplot(1,3,3);    hold on;    grid on;    title('Aceleracao')
%               axis([min(Tempo) max(Tempo) 1.2*min(MedAceTorDirX) 1.2*max(MedAceTorDirX)])
%                    plot(Tempo,MedAceTorDirX,'COLOR',[0 0.45 0],'linewidth',2)
%                    line([max(Tempo)/2 max(Tempo)/2],[1.1*min(MedAceTorDirX) 1.1*max(MedAceTorDirX)],'COLOR',[1 0 0],'linewidth',1)

        %% Criacao dos Graficos para analise de resultados
            figure(5)
            Tempo = linspace(0,max(TSim),size(MedBinTorDirX,1));    % Tempo=linspace(0,max(TSim*5),size(MedBinTorDirX,1));
            
            %% TORNOZELO X
                subplot(2,3,1);    hold on;    grid off;    title('Binario Tornozelo para K diferentes (Bin VS Tmp)');
                %axis([min(Tempo) max(Tempo) 1.1*min(MedBinTorDirX) 0*max(MedBinTorDirX)])
                plot(Tempo,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
                  MediaBinTorDirX           = sum(MedBinTorDirX)/size(MedBinTorDirX,1);
                  MediaQuadraticaBinTorDirX = sum(MedBinTorDirX.^2)/size(MedBinTorDirX,1);
                  Medias(simulacao , :)     = [MediaBinTorDirX MediaQuadraticaBinTorDirX MolRigTorDir1 MolRigTorDir2 MolRigTorDir3 MolRigTorDir4];
                ValMaxBinTorDirX = max(abs(MedBinTorDirX));
                  line( [0 max(Tempo)], [MediaQuadraticaBinTorDirX MediaQuadraticaBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                  line( [0 max(Tempo)], [MediaBinTorDirX MediaBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                subplot(2,3,4)
                  line( [0 max(AngTorDirX(:,2))], [MediaQuadraticaBinTorDirX MediaQuadraticaBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                  line( [0 max(AngTorDirX(:,2))], [MediaBinTorDirX MediaBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                subplot(2,3,1)
                if max(MedBinTorDirX) < max(abs(MedBinTorDirX))
                    line( [0 max(Tempo)], [-ValMaxBinTorDirX -ValMaxBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                    subplot(2,3,4)
                    line( [0 max(AngTorDirX(:,2))], [-ValMaxBinTorDirX -ValMaxBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                else
                    line( [0 max(Tempo)], [ValMaxBinTorDirX ValMaxBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                    subplot(2,3,4)
                    line( [0 max(AngTorDirX(:,2))], [ValMaxBinTorDirX ValMaxBinTorDirX],'COLOR',[0 0 0],'linewidth',1 )
                end
                subplot(2,3,1)
                line([max(Tempo)/2 max(Tempo)/2],[min(MedBinTorDirX) max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
                
                plot(Tempo,MedBinTorDirX1,'COLOR',[0 1 0],'linewidth',2)
                  MediaBinTorDirX1 = sum(MedBinTorDirX1)/size(MedBinTorDirX1,1);
                  MediaQuadraticaBinTorDirX1 = sum(MedBinTorDirX1.^2)/size(MedBinTorDirX1,1);
                  Medias1(simulacao , :) = [MediaBinTorDirX1 MediaQuadraticaBinTorDirX1 MolRigTorDir1 MolRigTorDir2 MolRigTorDir3 MolRigTorDir4];
                    MedBinTor(simulacao , :) = MedBinTorDirX1;
                ValMaxBinTorDirX1 = max(abs(MedBinTorDirX1));
                  line( [0 max(Tempo)], [MediaQuadraticaBinTorDirX1 MediaQuadraticaBinTorDirX1],'COLOR',[0 1 0],'linewidth',1 )
                  line( [0 max(Tempo)], [MediaBinTorDirX1 MediaBinTorDirX1],'COLOR',[0 1 0],'linewidth',1 )
                subplot(2,3,4)
                  line( [0 max(AngTorDirX(:,2))], [MediaQuadraticaBinTorDirX1 MediaQuadraticaBinTorDirX1],'COLOR',[0 1 0],'linewidth',1 )
                  line( [0 max(AngTorDirX(:,2))], [MediaBinTorDirX1 MediaBinTorDirX1],'COLOR',[0 1 0],'linewidth',1 )
                subplot(2,3,4)
                if max(MedBinTorDirX1) < max(abs(MedBinTorDirX1))
                    line( [0 max(Tempo)], [-ValMaxBinTorDirX1 -ValMaxBinTorDirX1],'COLOR',[0 1 0],'linewidth',1 )
                    subplot(2,3,4)
                    line( [0 max(AngTorDirX(:,2))], [-ValMaxBinTorDirX1 -ValMaxBinTorDirX1],'COLOR',[0 1 0],'linewidth',1 )
                else
                    line( [0 max(Tempo)], [ValMaxBinTorDirX1 ValMaxBinTorDirX1],'COLOR',[0 1 0],'linewidth',1);
                    subplot(2,3,4)
                    line( [0 max(AngTorDirX(:,2))], [ValMaxBinTorDirX1 ValMaxBinTorDirX1],'COLOR',[0 1 0],'linewidth',1);
                end
                
                subplot(2,3,4)
                hold on; grid off;
                %axis([min(AngTorDirX(:,2)) 1.0*max(AngTorDirX(:,2)) 1.1*min(MedBinTorDirX) 0.0*max(MedBinTorDirX)])
                title('Binario Tornozelo X para K diferentes (Bin VS Ang)')
                plot(MedAngTorDirX,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
                line([max(AngTorDirX(:,2)) max(AngTorDirX(:,2))],[min(MedBinTorDirX) max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
                plot(MedAngTorDirX,MedBinTorDirX1,'COLOR',[0 1 0],'linewidth',2)

            %% JOELHO
              if AngJoe <= 0
                  for i=1:1:NPS
                      BinElaJoe(i,1) = 0;
                  end
                  for i=1:1:NPS
                      if MedBinJoeDir(i) > 0
                          MedBinJoeDir(i) = 0;
                      end
                      if MedBinJoeDir1(i) > 0
                          MedBinJoeDir1(i) = 0;
                      end
                  end
              else
              % funcao %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                BinElaJoe = SimulacaoJoelho(MolRigJoeDir1, AngJoe, NPS); %%
                figure(5)                                                %% 
              %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
              end
                subplot(2,3,2);    hold on;    grid off;    title('Bin Joe p K dif (Bin VS Tmp)');
                plot(Tempo,MedBinJoeDir,'COLOR',[0 0 0],'linewidth',2)
                  MediaBinJoeDir           = sum(MedBinJoeDir)/size(MedBinJoeDir,1);
                  MediaQuadraticaBinJoeDir = sum((MedBinJoeDir).^2)/size(MedBinJoeDir,1);
                  MediasJoelho(simulacao , :)     = [MediaBinJoeDir MediaQuadraticaBinJoeDir MolRigJoeDir1 0 0 0];
                ValMaxBinJoeDir = max(abs(MedBinJoeDir));
                  line( [0 max(Tempo)], [MediaQuadraticaBinJoeDir MediaQuadraticaBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                  line( [0 max(Tempo)], [MediaBinJoeDir MediaBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                subplot(2,3,5)
                  line( [0 max(AngJoeDir(:,2))], [MediaQuadraticaBinJoeDir MediaQuadraticaBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                  line( [0 max(AngJoeDir(:,2))], [MediaBinJoeDir MediaBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                subplot(2,3,2)
                if max(MedBinJoeDir) < max(abs(MedBinJoeDir))
                    line( [0 max(Tempo)], [-ValMaxBinJoeDir -ValMaxBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                    subplot(2,3,5)
                    line( [0 max(AngJoeDir(:,2))], [-ValMaxBinJoeDir -ValMaxBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                else
                    line( [0 max(Tempo)], [ValMaxBinJoeDir ValMaxBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                    subplot(2,3,5)
                    line( [0 max(AngJoeDir(:,2))], [ValMaxBinJoeDir ValMaxBinJoeDir],'COLOR',[0 0 0],'linewidth',1 )
                end
                subplot(2,3,2)
                line([max(Tempo)/2 max(Tempo)/2],[min(MedBinJoeDir-BinElaJoe) max(MedBinJoeDir-BinElaJoe)],'COLOR',[1 0 0],'linewidth',2)
                
     
                plot(Tempo,MedBinJoeDir1+BinElaJoe,'COLOR',[0 1 0],'linewidth',2)
                  MediaBinJoeDir1 = sum(MedBinJoeDir1+BinElaJoe)/size(MedBinJoeDir1,1);
                  MediaQuadraticaBinJoeDir1 = sum((MedBinJoeDir1+BinElaJoe).^2)/size(MedBinJoeDir1,1);
                  MediasJoelho1(simulacao , :) = [MediaBinJoeDir1 MediaQuadraticaBinJoeDir1 MolRigJoeDir1 0 0 0];
                    MedBinJoe(simulacao , :) = MedBinJoeDir1+BinElaJoe;
                ValMaxBinJoeDir1 = max(abs(MedBinJoeDir1+BinElaJoe));
                  line( [0 max(Tempo)], [MediaQuadraticaBinJoeDir1 MediaQuadraticaBinJoeDir1],'COLOR',[0 1 0],'linewidth',1 )
                  line( [0 max(Tempo)], [MediaBinJoeDir1 MediaBinJoeDir1],'COLOR',[0 1 0],'linewidth',1 )
                subplot(2,3,5)
                  line( [0 max(AngJoeDir(:,2))], [MediaQuadraticaBinJoeDir1 MediaQuadraticaBinJoeDir1],'COLOR',[0 1 0],'linewidth',1 )
                  line( [0 max(AngJoeDir(:,2))], [MediaBinJoeDir1 MediaBinJoeDir1],'COLOR',[0 1 0],'linewidth',1 )
                subplot(2,3,2)
                if max(MedBinJoeDir1+BinElaJoe) < max(abs(MedBinJoeDir1+BinElaJoe))
                    line( [0 max(Tempo)], [-ValMaxBinJoeDir1 -ValMaxBinJoeDir1],'COLOR',[0 1 0],'linewidth',1 )
                    subplot(2,3,5)
                    line( [0 max(AngJoeDir(:,2))], [-ValMaxBinJoeDir1 -ValMaxBinJoeDir1],'COLOR',[0 1 0],'linewidth',1 )
                else
                    line( [0 max(Tempo)], [ValMaxBinJoeDir1 ValMaxBinJoeDir1],'COLOR',[0 1 0],'linewidth',1);
                    subplot(2,3,5)
                    line( [0 max(AngJoeDir(:,2))], [ValMaxBinJoeDir1 ValMaxBinJoeDir1],'COLOR',[0 1 0],'linewidth',1);
                end
                
                subplot(2,3,5)
                hold on; grid off;
                title('Bin Joe p K dif (Bin VS Ang)')
                plot(MedAngJoeDir,MedBinJoeDir,'COLOR',[0 0 0],'linewidth',2)
                line([max(AngJoeDir(:,2)) max(AngJoeDir(:,2))],[min(MedBinJoeDir) max(MedBinJoeDir)],'COLOR',[1 0 0],'linewidth',2)
                plot(MedAngJoeDir,MedBinJoeDir1+BinElaJoe,'COLOR',[0 1 0],'linewidth',2) 

             %% ANCA X
                subplot(2,3,3);    hold on;    grid off;    title('Binario Anca para K diferentes (Bin VS Tmp)');
                plot(Tempo,MedBinAncDirX,'COLOR',[0 0 0],'linewidth',2)
                  MediaBinAncDirX           = sum(MedBinAncDirX)/size(MedBinAncDirX,1);
                  MediaQuadraticaBinAncDirX = sum(MedBinAncDirX.^2)/size(MedBinAncDirX,1);
                  MediasAnca(simulacao , :)     = [MediaBinAncDirX MediaQuadraticaBinAncDirX MolRigAncDir1 MolRigAncDir2 0 0];
                ValMaxBinAncDirX = max(abs(MedBinAncDirX));
                  line( [0 max(Tempo)], [MediaQuadraticaBinAncDirX MediaQuadraticaBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                  line( [0 max(Tempo)], [MediaBinAncDirX MediaBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                subplot(2,3,6)
                  line( [0 max(AngAncDirX(:,2))], [MediaQuadraticaBinAncDirX MediaQuadraticaBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                  line( [0 max(AngAncDirX(:,2))], [MediaBinAncDirX MediaBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                subplot(2,3,3)
                if max(MedBinAncDirX) < max(abs(MedBinAncDirX))
                    line( [0 max(Tempo)], [-ValMaxBinAncDirX -ValMaxBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                    subplot(2,3,6)
                    line( [0 max(AngAncDirX(:,2))], [-ValMaxBinAncDirX -ValMaxBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                else
                    line( [0 max(Tempo)], [ValMaxBinAncDirX ValMaxBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                    subplot(2,3,6)
                    line( [0 max(AngAncDirX(:,2))], [ValMaxBinAncDirX ValMaxBinAncDirX],'COLOR',[0 0 0],'linewidth',1 )
                end
                subplot(2,3,3)
                line([max(Tempo)/2 max(Tempo)/2],[min(MedBinAncDirX) max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
                plot(Tempo,MedBinAncDirX1,'COLOR',[0 1 0],'linewidth',2)
                  MediaBinAncDirX1 = sum(MedBinAncDirX1)/size(MedBinAncDirX1,1);
                  MediaQuadraticaBinAncDirX1 = sum(MedBinAncDirX1.^2)/size(MedBinAncDirX1,1);
                  MediasAnca1(simulacao , :) = [MediaBinAncDirX1 MediaQuadraticaBinAncDirX1 MolRigAncDir1 MolRigAncDir2 0 0];
                    MedBinAnc(simulacao , :) = MedBinAncDirX1;
                ValMaxBinAncDirX1 = max(abs(MedBinAncDirX1));
                  line( [0 max(Tempo)], [MediaQuadraticaBinAncDirX1 MediaQuadraticaBinAncDirX1],'COLOR',[0 1 0],'linewidth',1 )
                  line( [0 max(Tempo)], [MediaBinAncDirX1 MediaBinAncDirX1],'COLOR',[0 1 0],'linewidth',1 )
                subplot(2,3,6)
                  line( [0 max(AngAncDirX(:,2))], [MediaQuadraticaBinAncDirX1 MediaQuadraticaBinAncDirX1],'COLOR',[0 1 0],'linewidth',1 )
                  line( [0 max(AngAncDirX(:,2))], [MediaBinAncDirX1 MediaBinAncDirX1],'COLOR',[0 1 0],'linewidth',1 )
                subplot(2,3,3)
                if max(MedBinAncDirX1) < max(abs(MedBinAncDirX1))
                    line( [0 max(Tempo)], [-ValMaxBinAncDirX1 -ValMaxBinAncDirX1],'COLOR',[0 1 0],'linewidth',1 )
                    subplot(2,3,6)
                    line( [0 max(AngAncDirX(:,2))], [-ValMaxBinAncDirX1 -ValMaxBinAncDirX1],'COLOR',[0 1 0],'linewidth',1 )
                else
                    line( [0 max(Tempo)], [ValMaxBinAncDirX1 ValMaxBinAncDirX1],'COLOR',[0 1 0],'linewidth',1);
                    subplot(2,3,6)
                    line( [0 max(AngAncDirX(:,2))], [ValMaxBinAncDirX1 ValMaxBinAncDirX1],'COLOR',[0 1 0],'linewidth',1);
                end
                
                subplot(2,3,6)
                hold on; grid off;
                title('Binario Tornozelo X para K diferentes (Binario VS Angulo)')
                plot(MedAngAncDirX,MedBinAncDirX,'COLOR',[0 0 0],'linewidth',2)
                line([max(AngAncDirX(:,2)) max(AngAncDirX(:,2))],[min(MedBinAncDirX) max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
                plot(MedAngAncDirX,MedBinAncDirX1,'COLOR',[0 1 0],'linewidth',2)
    end
    
    %% Tornozelo
    for n=1:1:NumeroSimulacoesTor
        if min(abs(Medias1(:,2))) == abs(Medias1(n,2))  %Se olhar pra primeira coluna é a media, a segunda coluna é a média quadrática
            DadosSimuladorOptimizadoTornozelo = [Medias1(n,:) ValMaxBinTorDirX ValMaxBinTorDirX1 ValMaxBinTorDirX-ValMaxBinTorDirX1]
            MelhorSimulacao = n;
            if n-1 < 1
                kiTor = Medias1(n,3);
            else
                kiTor = Medias1(n-1,3);
            end
            if n+1 > NumeroSimulacoesTor-1
                kfTor = Medias1(n,3);
            else
                kfTor = Medias1(n+1,3);
            end
            ekTor = 0.2 * (kfTor - kiTor);   % Encremento do valor de k, condição de paragem
        end
    end
    
    if ekTor > ekmin     %Se a condição de paragem nao é verificada então
        close all
    else           %Se a simulação chegou ao fim vamos apresentar os graficos com os resultados   
        close all
%        figure(6)
%          subplot(2,1,1)
%            hold on; grid on
%            %axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBinTorDirX) -1.2*max(MedBinTorDirX)])
%            title('Binario no tornozelo na direcção X sem elasticos (Bin VS Tmp)')
%            plot(Tempo,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            %plot(Tempo,MedBin(MelhorSimulacao , :),'COLOR',[0 0 1],'linewidth',2)
%            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinTorDirX) 1.2*max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
%        
%          subplot(2,1,2)
%            hold on; grid on;
%            axis([min(MedAngTorDirX)-0.05*max(MedAngTorDirX) 1.05*max(MedAngTorDirX) 1.2*min(MedBinTorDirX) -1.2*max(MedBinTorDirX)])
%            title('Binario no tornozelo na direcção X sem elasticos (Bin VS Ang)')
%            plot(MedAngTorDirX,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            %plot(MedAngTorDirX,MedBin(MelhorSimulacao , :),'COLOR',[0 0 1],'linewidth',2)
%            line([max(AngTorDirX(:,2)) max(AngTorDirX(:,2))],[1.2*min(MedBinTorDirX) 1.2*max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
%##########################################################################
%##########################################################################
%        figure(7)
%          subplot(2,1,1)
%            hold on; grid on
%            %axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBin(MelhorSimulacao , :)) 1.2*max(MedBin(MelhorSimulacao , :))])
%            title('Binario no tornozelo na direcção X com elasticos (Bin VS Tmp)')
%            %plot(Tempo,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            plot(Tempo,MedBinTor(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
%            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinTorDirX) 1.2*max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
%        
%          subplot(2,1,2)
%            hold on; grid on;
%            %axis([min(MedAngTorDirX)-0.05*max(MedAngTorDirX) 1.05*max(MedAngTorDirX) 1.2*min(MedBin(MelhorSimulacao , :)) 1.2*max(MedBin(MelhorSimulacao , :))])
%            title('Binario no tornozelo na direcção X com elasticos (Bin VS Ang)')
%            %plot(MedAngTorDirX,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            plot(MedAngTorDirX,MedBinTor(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
%            line([max(AngTorDirX(:,2)) max(AngTorDirX(:,2))],[1.2*min(MedBinTorDirX) 1.2*max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
%##########################################################################
%##########################################################################
        figure(8)
          subplot(2,1,1)
            hold on; grid on
%            axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBinTorDirX) 1.2*max(MedBin(MelhorSimulacao , :))])
            title('Binario no tornozelo na direcção X sem elasticos e com elasticos (Binario VS Tempo)')
            plot(Tempo,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
            plot(Tempo,MedBinTor(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
            xLabel('Tempo(s)');yLabel('Binário(Nm)');legend('Sem elasticos','Com elasticos');
            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinTorDirX) 1.2*max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
        
          subplot(2,1,2)
            hold on; grid on;
%            axis([min(MedAngTorDirX) max(MedAngTorDirX) 1.2*min(MedBinTorDirX) 1.2*max(MedBinTorDirX)])
            title('Binario no tornozelo na direcção X sem elasticos e com elasticos (Binario VS Angulo)')
            plot(MedAngTorDirX,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
            plot(MedAngTorDirX,MedBinTor(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
            xLabel('Angulo(º)');yLabel('Binário(Nm)');legend('Sem elasticos','Com elasticos');
            line([max(AngTorDirX(:,2)) max(AngTorDirX(:,2))],[1.2*min(MedBinTorDirX) 1.2*max(MedBinTorDirX)],'COLOR',[1 0 0],'linewidth',2)
    end
    %% Joelho
    for n=1:1:NumeroSimulacoesJoe
        if min(abs(MediasJoelho1(:,2))) == abs(MediasJoelho1(n,2))  %Se olhar pra primeira coluna é a media, a segunda coluna é a média quadrática
            DadosSimuladorOptimizadoJoelho = [MediasJoelho1(n,:) ValMaxBinJoeDir ValMaxBinJoeDir1 ValMaxBinJoeDir-ValMaxBinJoeDir1]
            MelhorSimulacao = n;
            if n-1 < 1
                kiJoe = MediasJoelho1(n,3);
            else
                kiJoe = MediasJoelho1(n-1,3);
            end
            if n+1 > NumeroSimulacoesJoe-1
                kfJoe = MediasJoelho1(n,3);
            else
                kfJoe = MediasJoelho1(n+1,3);
            end
            ekJoe = 0.2 * (kfJoe - kiJoe);   % Encremento do valor de k, condição de paragem
        end
    end
    
    if ekJoe > ekmin     %Se a condição de paragem nao é verificada então
        close all
    else           %Se a simulação chegou ao fim vamos apresentar os graficos com os resultados
%        figure(9)
%          subplot(2,1,1)
%            hold on; grid on
%            %axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBinTorDirX) -1.2*max(MedBinTorDirX)])
%            title('Binario no tornozelo na direcção X sem elasticos (Bin VS Tmp)')
%            plot(Tempo,MedBinJoeDir,'COLOR',[0 0 0],'linewidth',2)
%            %plot(Tempo,MedBin(MelhorSimulacao , :),'COLOR',[0 0 1],'linewidth',2)
%            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinJoeDir) 1.2*max(MedBinJoeDir)],'COLOR',[1 0 0],'linewidth',2)
%        
%          subplot(2,1,2)
%            hold on; grid on;
%            %axis([min(MedAngTorDirX)-0.05*max(MedAngTorDirX) 1.05*max(MedAngTorDirX) 1.2*min(MedBinTorDirX) -1.2*max(MedBinTorDirX)])
%            title('Binario no tornozelo na direcção X sem elasticos (Bin VS Ang)')
%            plot(MedAngJoeDir,MedBinJoeDir,'COLOR',[0 0 0],'linewidth',2)
%            %plot(MedAngTorDirX,MedBin(MelhorSimulacao , :),'COLOR',[0 0 1],'linewidth',2)
%            line([max(AngJoeDir(:,2)) max(AngJoeDir(:,2))],[1.2*min(MedBinJoeDir) 1.2*max(MedBinJoeDir)],'COLOR',[1 0 0],'linewidth',2)
%##########################################################################
%##########################################################################
%        figure(10)
%          subplot(2,1,1)
%            hold on; grid on
%            %axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBin(MelhorSimulacao , :)) 1.2*max(MedBin(MelhorSimulacao , :))])
%            title('Binario no tornozelo na direcção X com elasticos (Bin VS Tmp)')
%            %plot(Tempo,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            plot(Tempo,MedBinJoe(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
%            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinJoeDir) 1.2*max(MedBinJoeDir)],'COLOR',[1 0 0],'linewidth',2)
%
%          subplot(2,1,2)
%            hold on; grid on;
%            %axis([min(MedAngTorDirX)-0.05*max(MedAngTorDirX) 1.05*max(MedAngTorDirX) 1.2*min(MedBin(MelhorSimulacao , :)) 1.2*max(MedBin(MelhorSimulacao , :))])
%            title('Binario no tornozelo na direcção X com elasticos (Bin VS Ang)')
%            %plot(MedAngTorDirX,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            plot(MedAngJoeDir,MedBinJoe(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
%            line([max(AngJoeDir(:,2)) max(AngJoeDir(:,2))],[1.2*min(MedBinJoe(MelhorSimulacao , :)) 1.2*max(MedBinJoe(MelhorSimulacao , :))],'COLOR',[1 0 0],'linewidth',2)
%##########################################################################
%##########################################################################
        figure(11)
          subplot(2,1,1)
            hold on; grid on
%            axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBinTorDirX) 1.2*max(MedBin(MelhorSimulacao , :))])
            title('Binario no joelho na direcção X sem elasticos e com elasticos (Binario VS Tempo)')
            plot(Tempo,MedBinJoeDir,'COLOR',[0 0 0],'linewidth',2)
            plot(Tempo,MedBinJoe(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
            xLabel('Tempo(s)');yLabel('Binário(Nm)');legend('Sem elasticos','Com elasticos');
            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinJoeDir) 1.2*max(MedBinJoeDir)],'COLOR',[1 0 0],'linewidth',2)
        
          subplot(2,1,2)
            hold on; grid on;
%            axis([min(MedAngJoeDir) max(MedAngJoeDir) 1.2*min(MedBinJoeDir) 1.2*max(MedBinJoe(MelhorSimulacao , :))])
            title('Binario no joelho na direcção X sem elasticos e com elasticos (Binario VS Angulo)')
            plot(MedAngJoeDir,MedBinJoeDir,'COLOR',[0 0 0],'linewidth',2)
            plot(MedAngJoeDir,MedBinJoe(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
            xLabel('Angulo(º)');yLabel('Binário(Nm)');legend('Sem elasticos','Com elasticos');
            line([max(AngJoeDir(:,2)) max(AngJoeDir(:,2))],[1.2*min(MedBinJoeDir) 1.2*max(MedBinJoeDir)],'COLOR',[1 0 0],'linewidth',2)
    end
    %% Anca
    for n=1:1:NumeroSimulacoesAnc
        if min(abs(MediasAnca1(:,2))) == abs(MediasAnca1(n,2))  %Se olhar pra primeira coluna é a media, a segunda coluna é a média quadrática
            DadosSimuladorOptimizadoAnca = [MediasAnca1(n,:) ValMaxBinAncDirX ValMaxBinAncDirX1 ValMaxBinAncDirX-ValMaxBinAncDirX1]
            MelhorSimulacao = n;
            if n-1 < 1
                kiAnc = MediasAnca1(n,3);
            else
                kiAnc = MediasAnca1(n-1,3);
            end
            if n+1 > NumeroSimulacoesAnc-1
                kfAnc = MediasAnca1(n,3);
            else
                kfAnc = MediasAnca1(n+1,3);
            end
            ekAnc = 0.2 * (kfAnc - kiAnc);   % Encremento do valor de k, condição de paragem
        end
    end

    if ekAnc > ekmin     %Se a condição de paragem nao é verificada então
        close all
    else           %Se a simulação chegou ao fim vamos apresentar os graficos com os resultados   
%        figure(12)
%          subplot(2,1,1)
%            hold on; grid on
%            %axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBinTorDirX) -1.2*max(MedBinTorDirX)])
%            title('Binario no tornozelo na direcção X sem elasticos (Bin VS Tmp)')
%            plot(Tempo,MedBinAncDirX,'COLOR',[0 0 0],'linewidth',2)
%            %plot(Tempo,MedBin(MelhorSimulacao , :),'COLOR',[0 0 1],'linewidth',2)
%            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinAncDirX) 1.2*max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
%        
%          subplot(2,1,2)
%            hold on; grid on;
%            axis([min(MedAngTorDirX)-0.05*max(MedAngTorDirX) 1.05*max(MedAngTorDirX) 1.2*min(MedBinTorDirX) -1.2*max(MedBinTorDirX)])
%            title('Binario no tornozelo na direcção X sem elasticos (Bin VS Ang)')
%            plot(MedAngAncDirX,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            %plot(MedAngTorDirX,MedBin(MelhorSimulacao , :),'COLOR',[0 0 1],'linewidth',2)
%            line([max(AngAncDirX(:,2)) max(AngAncDirX(:,2))],[1.2*min(MedBinAncDirX) 1.2*max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
%##########################################################################
%##########################################################################
%        figure(13)
%          subplot(2,1,1)
%            hold on; grid on
%            %axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBin(MelhorSimulacao , :)) 1.2*max(MedBin(MelhorSimulacao , :))])
%            title('Binario no tornozelo na direcção X com elasticos (Bin VS Tmp)')
%            %plot(Tempo,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            plot(Tempo,MedBinAnc(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
%            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinAncDirX) 1.2*max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
%        
%          subplot(2,1,2)
%            hold on; grid on;
%            %axis([min(MedAngTorDirX)-0.05*max(MedAngTorDirX) 1.05*max(MedAngTorDirX) 1.2*min(MedBin(MelhorSimulacao , :)) 1.2*max(MedBin(MelhorSimulacao , :))])
%            title('Binario no tornozelo na direcção X com elasticos (Bin VS Ang)')
%            %plot(MedAngTorDirX,MedBinTorDirX,'COLOR',[0 0 0],'linewidth',2)
%            plot(MedAngAncDirX,MedBinAnc(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
%            line([max(AngAncDirX(:,2)) max(AngAncDirX(:,2))],[1.2*min(MedBinAncDirX) 1.2*max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
%##########################################################################
%##########################################################################
        figure(14)
          subplot(2,1,1)
            hold on; grid on
%            axis([min(Tempo)-0.05*max(Tempo) 1.05*max(Tempo) 1.2*min(MedBinTorDirX) 1.2*max(MedBin(MelhorSimulacao , :))])
            title('Binario na anca na direcção X sem elasticos e com elasticos (Binario VS Tempo)')
            plot(Tempo,MedBinAncDirX,'COLOR',[0 0 0],'linewidth',2)
            plot(Tempo,MedBinAnc(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
            xLabel('Tempo(s)');yLabel('Binário(Nm)');legend('Sem elasticos','Com elasticos');
            line([max(Tempo)/2 max(Tempo)/2],[1.2*min(MedBinAncDirX) 1.2*max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
        
          subplot(2,1,2)
            hold on; grid on;
            axis([min(MedAngAncDirX) max(MedAngAncDirX) 1.2*min(MedBinAncDirX1) 1.2*max(MedBinAncDirX)])
            title('Binario na anca na direcção X sem elasticos e com elasticos (Binario VS Angulo)')
            plot(MedAngAncDirX,MedBinAncDirX,'COLOR',[0 0 0],'linewidth',2)
            plot(MedAngAncDirX,MedBinAnc(MelhorSimulacao , :),'COLOR',[0 1 0],'linewidth',2)
            xLabel('Angulo(º)');yLabel('Binário(Nm)');legend('Sem elasticos','Com elasticos');
            line([max(AngAncDirX(:,2)) max(AngAncDirX(:,2))],[1.2*min(MedBinAncDirX) 1.2*max(MedBinAncDirX)],'COLOR',[1 0 0],'linewidth',2)
    end
end

%% Tornozelo
MaximoBinarioTornozeloSemElasticos = max(MedBinTorDirX);
MinimoBinarioTornozeloSemElasticos = min(MedBinTorDirX);
MaximoBinarioTornozeloComElasticos = max(MedBinTor(MelhorSimulacao , :));
MinimoBinarioTornozeloComElasticos = min(MedBinTor(MelhorSimulacao , :));
ValoresExtremosBinarioTornozelo = [MaximoBinarioTornozeloSemElasticos MinimoBinarioTornozeloSemElasticos MaximoBinarioTornozeloComElasticos MinimoBinarioTornozeloComElasticos]
%% Joelho
MaximoBinarioJoelhoSemElasticos = max(MedBinJoeDir);
MinimoBinarioJoelhoSemElasticos = min(MedBinJoeDir);
MaximoBinarioJoelhoComElasticos = max(MedBinJoe(MelhorSimulacao , :));
MinimoBinarioJoelhoComElasticos = min(MedBinJoe(MelhorSimulacao , :));
ValoresExtremosBinarioJoelho = [MaximoBinarioJoelhoSemElasticos MinimoBinarioJoelhoSemElasticos MaximoBinarioJoelhoComElasticos MinimoBinarioJoelhoComElasticos]
%% Anca
MaximoBinarioAncaSemElasticos = max(MedBinAncDirX);
MinimoBinarioAncaSemElasticos = min(MedBinAncDirX);
MaximoBinarioAncaComElasticos = max(MedBinAnc(MelhorSimulacao , :));
MinimoBinarioAncaComElasticos = min(MedBinAnc(MelhorSimulacao , :));
ValoresExtremosBinarioAnca = [MaximoBinarioAncaSemElasticos MinimoBinarioAncaSemElasticos MaximoBinarioAncaComElasticos MinimoBinarioAncaComElasticos]
%% Som conclusão simulação
a=linspace(0, 1000, 1000); y=sin(a);
Fs=6000;
sound(y,Fs)
Fs=7000;
sound(y,Fs)
Fs=8000;
sound(y,Fs)
Fs=6000;
sound(y,Fs)
Fs=7000;
sound(y,Fs)
Fs=8000;
sound(y,Fs)