Artigos de Treinamento Octave

Esta página orienta quem tiver interesse em aprender a usar o octave.

  • Alternativa para o Mathlab
    por Marcelo Martins


    O Octave é uma linguagem de programação de alto nível e um ambiente de desenvolvimento numérico, projetado para realizar cálculos numéricos e análises científicas. Ele fornece uma interface fácil de usar para a manipulação de matrizes, implementação de algoritmos, criação de gráficos e solução de problemas numéricos em geral.

    Características do Octave:

    1. Linguagem de programação: O Octave possui uma linguagem de programação própria, que permite aos usuários escreverem scripts e programas para realizar operações numéricas, implementar algoritmos e automatizar tarefas.
    2. Matrizes e cálculos numéricos: O Octave é especialmente adequado para trabalhar com matrizes e realizar cálculos numéricos. Ele suporta operações matriciais, álgebra linear, manipulação de vetores e escalares, além de funções matemáticas avançadas.
    3. Funções embutidas: O Octave possui uma ampla gama de funções embutidas para realizar cálculos matemáticos, estatísticos, trigonométricos, lógicos e outros tipos de operações numéricas.
    4. Gráficos e visualização: O Octave oferece recursos para criar gráficos e visualizar dados. Ele suporta plotagem de gráficos 2D e 3D, diagramas de dispersão, histogramas e outras formas de visualização de dados.
    5. Extensibilidade: O Octave permite estender sua funcionalidade por meio de pacotes e bibliotecas. Existem diversos pacotes disponíveis que fornecem recursos adicionais para áreas específicas, como processamento de sinais, controle, otimização, entre outros.
    6. Código aberto: O Octave é um software de código aberto, o que significa que o seu código-fonte está disponível gratuitamente para acesso, modificação e distribuição. Isso permite que a comunidade contribua para o seu desenvolvimento e oferece flexibilidade aos usuários.

    Em resumo, o Octave é uma ferramenta poderosa para realizar cálculos numéricos, análises científicas e implementação de algoritmos, sendo uma alternativa popular ao MATLAB.

    Ele é amplamente utilizado por pesquisadores, engenheiros, cientistas e estudantes em diversas áreas acadêmicas e industriais.

    Baixando o Octave

    O Octave pode ser baixado através do seguinte site:

    https://octave.org/download

    https://youtu.be/RCjUV9N8lxo

    Baixe o arquivo octave para a plataforma alvo, conforme figura abaixo:

    Exemplo comparativo

    Octave código

    Fonte do projeto:

    pkg load control

Kp = 36;
Kd = 0.2 * Kp;

num4 = [0 0 5];
den4 = [1 4.42 4];
Gp4 = tf(num4, den4);

PD = Kp + Kd * Gp4;
Gp5 = PD * Gp4;

num10 = [0 3.6 80];
den10 = [1 4.42 4];
G10 = tf(num10, den10);

G_fechado = feedback(G10, 1);

% Traçar o diagrama de Bode do sistema em malha fechada
bode(G_fechado);
grid on;

% Traçar o passo de resposta ao impulso do sistema em malha fechada
step(G_fechado);
grid on;

    Mathlab

    Neste fragmento, podemos notar as semelhanças entre os códigos:

    Agora iremos ver o código do projeto.

    num1=[005];
den1=[1,4.42,4];
Gp= tf(num1,den1);
ft1 = feedback(Gp,1);
step(ft1);


num2=[36];
den2=[1];
Gp2= tf(num2,den2);

Gp3 = series(Gp,Gp2);
ft2 = feedback(Gp3,1);
step(ft2);

%% 
%% 

Kp = 36;
Kd= 0,2 * Kp;


num4=[005];
den4=[1,4.42,4];
Gp4= tf(num4,den4);


%PD = Kp+ Kd * Gp4b ;
%Gp5 = PD * Gp4;

num10=[0,3.6,80];
den10=[1,4.42,4];
G10= tf(num10,den10);
G_fechado= feedback(G10,1);

% G_fechado = feedback(Gp5,1);

step(G_fechado)
%% 
s=tf('s');
num6=[1];
den6=[1,2];
uGp6=tf(num6,den6);

num7=[1];
den7=[1,2];
mGp7=tf(num7,den7);

G8=series(uGp6,mGp7);
ft9=feedback(G8,1);
impulse(ft9);
 %%
 %%
 s=tf('s');
num6=[1];
a=200;
den6=[1,a];
uGp6=tf(num6,den6);

num7=[1];
den7=[1,2];
mGp7=tf(num7,den7);

G8=series(uGp6,mGp7);
G9= Kp*G8;
ft9=feedback(G9,1);
impulse(ft9);

  • Octave – Criando gráficos do segundo grau
    por Marcelo Martins

    Iremo hoje, usar o octave para definir e criar gráficos do segundo grau.

    https://youtu.be/79xxbbvq_UM

    Para isso iremos utilizar o exemplo abaixo:

    % Gerar gráfico de Função do Segundo Grau

% X^2 + 2X + 10
% 2X^2 +2X^1 + 10X^0

x = -10:0.1:10;
y = 2*x.^2 - 5*x - 100;
plot(x, y);
xlabel('x');
ylabel('f(x)');
title('Gráfico da função f(x) = x^2 + 2x + 10');
grid on;

    Em gráficos do segundo grau, temos os valores de Y em função do X, sendo assim primeiramente atribuimos o x. O X recebe uma faixa de valores, ou seja, valores que serão apresentados ao Y, começando do -10 até o valor 10, pulando de 0.1 em 0.1.

    Para isso usamos a seguinte sintaxe:

    x = valor_inicial: pulo : valor_final

    Onde:

    • valor_inicial é o primeiro valor a ser atribuido a X, no nosso caso -10;
    • pulo é o valor que será acrescido de contagem a contagem até chegar ao valor final, exemplo: -10.0, -9.99, -9.98, 9.98…,9.98, 9.99, 10.00 , no nosso caso o pulo será 0.1.
    • valor _final é o valor que se quer chegar para terminar a contagem, no nosso caso 10

  • Octave – Primeiro contato
    por Marcelo Martins
    https://youtu.be/YvBzJcQViY8

    Comentário

    o Comentário é o % seguido do texto.

    Conforme o exemplo:

    % Isso é um comentário

    Declaração de variável

    x = 14;
resultado = x + 2;
resultado2 = x ^2 ;
resultado3 = (x ^2)/ (x*2)

    As variáveis podem ser declaradas livremente no octave, conforme apresentado no código acima.

    Trabalhando com vetor

    Trabalhar com vetor é tão simples como manipular variáveis, para isso, basta declarar os elementos entre chaves [ ]

    vt = [10,20,30]

resultado4 = vt*2;

vt2 = [1,2,3]
resultado5 = vt + vt2;

resultado6 = vt .* vt2;
disp(resultado6);
printf("O Resultado: %d",resultado6);

    Podemos ver, no exemplo acima, que temos a variável vt, que tem 3 elementos, 10,20 e 30, armazenados.

    Desta forma sempre que falarmos em vt, estaremos trabalhando com os valores [10,20,30]. Até que este seja modificado.

    Ao declarar resultado4, fazemos a operação matemática de multiplicação por 2, ficando [20,40,60 como resultado na variável resultado4.

    Comparando valores

    Agora iremos usar o valor armazenado na variável para tomar uma decisão. Para isso usamos o comando if, conforme nosso exemplo.

    x = 14;

printf("\n\n");
if (x == 12)
  printf("O valor bateu\n");
else
  printf("O valor nao bateu\n");
end;

printf("\n\n");
if (x < 12)
  printf("O valor é menor que 12\n");
else
  printf("O valor é maior ou igual a 12\n");
end;

    Neste exemplo testamos o valor de x, verificando se este atende a condição onde == é valor igual ao definido, < (menor que o definido).

    Atendendo o primeiro print será mostrado. Caso contrário, ele mostrará o print atribuído após o else.

    O Else pode ser omitido, não tendo então exceção. Apenas condição de atendimento ao teste if.

  • Octave – Função de transferência
    por Marcelo Martins

    Pelo wiki: “Função de transferência é a representação matemática da relação entre a entrada e a saída de um sistema físico.”

    Desta forma podemos simular equipamentos físicos através de funções matemáticas, simulando seus resultados.

    De forma geral existem 2 tipo de simulação.

    Sistema Malha Abertos – São sistemas que apresentam apenas uma entrada – > Com sua respectiva saída.

    Já um sistema de malha fechada, possui feedback, sendo definido pela wiki como:

    “Também chamado de controle retroativo (realimentação ou feedback) necessita de informações da saída do controlador através de elementos sensores ou transdutores, compara o sinal da saída com o set-point(referência) e corrige a saída caso a mesma esteja desviando-se dos parâmetros programados.”

    Entendendo como funciona o sistema de malha aberta no OCTAVE:

    Para entender o sistema de malha aberta , com uso da função de transferência, montei este vídeo para voces.

    https://youtu.be/vYvU185D1NU

    Podemos inicialmente verificar, que faz-se necessário o uso da lib control, pois o octave precisa desta lib para utilizar o sistema de transferencia.

    Para isso usamos o comando:

    pkg load control

    Em seguida precisamos criar a função de transferência atribuindo o numerador num01 e denominador den01. Em criando a função de transferência, que será utilizada para injetar os valores de entrada.

    Logo atribuimos a função tf(num,den) criando a variavel S01, que armazena a função de transferencia.

    Agora por fim, atuaremos passando os valores de entrada, através do t, e plotando no gráfico, conforme a função step.

    O resultado final fica conforme apresentado a seguir:

    % Carrega o pacote da função de transferencia.
pkg load control

%      1
%  -------------
%   S^2 +2S + 10

% num01
% den01

%num01= [0,0,1];
num01 = [1];

den01= [1,2,10];

% Cria a funçao de transferencia
S01= tf(num01,den01);

disp(S01);

%Atribui um vetor de tempo
t= 0:0.1:10;



%Resposta ao degrau da função de transferencia
step(S01,t);

xlabel('Tempo');
ylabel('Saida (v)');
title('Resposta da Função de transferencia');
  • Octave – Sistema de transferência Malha fechada
    por Marcelo Martins

    No vídeo anterior, apresentamos uma pequena apresentação de um sistema de malha aberta.

    Agora iremos apresentar um exemplo de malha fechada.

    Conforme o wiki:

    “Também chamado de controle retroativo (realimentação ou feedback) necessita de informações da saída do controlador através de elementos sensores ou transdutores, compara o sinal da saída com o set-point(referência) e corrige a saída caso a mesma esteja desviando-se dos parâmetros programados.”

    O vídeo de treinamento deste material pode ser visto aqui.

    https://youtu.be/1zdwcbYs9ag

    Primeiramente, temos que carregar a função control, através do comando:

     pkg load control

    Em seguida criamos o num01 e den01, da planta.

    Em seguida criamos o num02 e den02 da função de controle.

    Por fim atribuimos a função de feedback, através da união de ambas as funções:

    sys01= feedback(tf01,tf02);

    Lembrando que a função feedback , aceita mais um parâmetro, que é o sinal de realimentação.

    “Se sign for omitido ou definido como +1, indica que o sinal de realimentação é positivo (realimentação negativa). Se sign for definido como -1, indica realimentação positiva.”

    %Apresentação do sistema de malha fechada

pkg load control

%Sistema de transferencia da planta.
num01 = [1];
den01 = [1,2,10];

%tf01 - Sistema da Planta
%tf01=tf([1],[1,2,10])
tf01=tf(num01,den01);

num02=[2];
den02=[1];
% Função de controle
tf02=tf(num02,den02);

% Construir o sistema de malha fechada
sys01= feedback(tf01,tf02);

disp(sys01);

step(sys01);

xlabel('tempo');
ylabel('saida v');
title('Sistema malha fechada');

    Resultado da função de malha fechada

  • Octave – Considerações finais
    por Marcelo Martins

    Recomendações

    Quem tiver interesse em continuar o treinamento de octave, pode adicionar o canal que eu recomendo:

    https://www.youtube.com/channel/UCfu1un2W4wxpdjYekpfo4zQ

    Meus vídeos e canal no Youtube

    https://www.youtube.com/@marcelomaurin/videos

    GITHUB do projeto

    https://github.com/marcelomaurin/octaveex