Tutorial Scilab Novo

Escola Politécnica da Universidade de São Paulo
Tutorial para Scilab

Integração de equações do
movimento
Tutorial escrito pelos monitores:

Bruno Peixoto
brunolobo.poli@gmail.com
Yuri Yokota
yuri.fiusa@gmail.com
Gustavo Rauscher
gustavo wr@hotmail.com
Gabriel Francisco
gabrielffran@gmail.com
PME2200 - Mecânica B
Sumário
1 Introdução 1
2 Fundamentos de programação 2
2.1 Entrada e execução de comandos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 O Scinotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Entrada e execução de códigos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Métodos de integração . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3 Aplicações em Mecânica 12
3.1 Sistema massa-mola-amortecedor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2 Partı́cula que colide contra o solo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3 Veı́culo 2D passando por lombada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Bibliografia 26
ii
Capı́tulo 1
Introdução
O propósito deste texto é apresentar aos alunos das disciplinas de Mecânica Geral da Escola Politécnica
da Universidade de São Paulo ferramentas computacionais para a simulação numérica do comportamento
dinâmico de sistemas mecânicos.
Para tal propósito será usado o Scilab, um software de código aberto com um ambiente com-
putacional ideal para aplicações cientı́ficas e de engenharia. Desenvolvido inicialmente pelo INRIA
(http://www.inria.fr/), atualmente o Scilab é mantido e desenvolvido pelo Scilab Enterprises (http:
//www.scilab-enterprises.com/).
O download da versão mais recente deste software pode ser feito através do site http://www.scilab.
org/. Antes de fazer o download, certifique-se da versão correta do seu sistema operacional (Windows
32 bit, Windows 64 bit ou Mac OS X) e escolha o programa de instalação adequado.
Este tutorial foi escrito com base na versão 5.4.0 do Scilab, de modo que usuários de versões anteriores
ou posteriores a esta podem precisar adaptar algumas das instruções aqui apresentadas.
1
Capı́tulo 2
Fundamentos de programação
O ambiente de programação padrão do Scilab é composto pelas seguintes janelas agrupadas e apresentadas
na Figura 1: console do Scilab, navegador de arquivos, navegador de variáveis e histórico de comandos.
Existem basicamente duas maneiras de efetuar operações no Scilab: a primeira e mais simples é
digitar os comandos diretamente no console do Scilab, e a segunda é usar um editor de texto, como o
SciNotes, para criar um arquivo com extensão “.sce” que poderá então ser executado no console do Scilab.
Em um primeiro momento, onde serão apresentados os comandos básicos, será usado o modo simples
de programação, ou seja, digitando os comandos diretamente no console. O uso do editor de texto será
feito mais adiante, quando começarmos a escrever códigos mais complexos.
Usuários com pouca ou nenhuma familiaridade com o Scilab são aconselhados a seguir passo a passo
esta primeira parte do tutorial. Os demais podem avançar diretamente para a seção (3).
Figura 2.1: Ambiente de programação padrão do Scilab.
2.1 Entrada e execução de comandos básicos

Conforme mencionado anteriormente, nesta parte será utilizado o próprio console do Scilab para entrar
com os comandos, de modo que o usuário deverá digita-los diretamente após o prompt “-->” que aparece
no console, e em seguida pressionar a tecla Enter para que o comando seja executado.
Variáveis constantes e operadores elementares

Comecemos com a entrada de variáveis. Para entrar com números reais, basta digitar
2
Capı́tulo 2. Fundamentos de programação
a=1
b=3.1416
Constantes complexas podem ser definidas como
c=-5-3*%i
onde %i representa a unidade imaginária i. Valores como o π (Pi) ou e (número de Euler) são dados
por, respectivamente,
%pi
%e
Números com potências de dez, tal como h = 6, 626.10−34 , podem ser escritos usando-se a notação
cientı́fica
h=6.626D-34
As operações de adição, subtração, multiplicação e divisão são efetuadas conforme o exemplo a seguir:
d=1+2*3-4/5
√
Potenciação e radiciação podem ser efetuadas com o mesmo operador, de modo que 23 e 3
27 são
dados por, respectivamente,
2ˆ3
27ˆ(1/3)
Funções elementares
√
No caso especial da raiz quadrada existe uma função especial. Assim, 64 pode ser calculado como
sqrt(64)
As funções logaritmo natural, ln(e), logaritmo na base 10, log10 10, e a função exponencial, eπ , são
dadas por, respectivamente,
log(%e)
log10(10)
exp(%pi)
As funções trigonométricas elementares e suas respectivas inversas também estão presentes. Assim,
as funções sen(30o ), cos(60o ), tan(45o ), arcsen(0,5) e arctan(1) são dados por, respectivamente,
sin(%pi/6)
cos(%pi/3)
tan(%pi/4)
asin(0.5)
acos(0.5)
atan(1)
Note que o Scilab trabalha com ângulos em radianos.
3
Vetores e matrizes
O Scilab interpreta vetores e matrizes de forma indistinta, de modo que um vetor linha com 6 elementos
e um vetor coluna com 3 elementos são vistos pelo programa como matrizes de dimensões 1x6 e 3x1,
respectivamente. Deve-se, porém, ficar atento com as dimensões das matrizes durante a execução de
operações que requerem uma configuração adequada desses parâmetros, como por exemplo na multi-
plicação matricial.
Comecemos assim criando um vetor linha. Para tanto, pode-se digitar
v=[1 2 3 4 5]
Note que para diferenciar um elemento do seguinte pasta adicionar um espaço entre eles. Em parti-
cular, vetores como o anterior, onde os elementos formam uma sequência de inteiros, podem ser escritos
como
v=1:5
Para inserir uma matriz qualquer pode-se fazer
A=[45 13 -7
13 22 -30
-7 -30 -6]
ou
A=[45 13 -7; 13 22 -30; -7 -30 -6]
gerando o mesmo resultado.

Pode-se também formar vetores e matrizes como o resultado de operações, conforme exemplo seguinte:
B=[a+aˆ2 %pi 2
a+b %e atan(a)
sqrt(a) 0 cos(%pi/3)]
Para formar um vetor linha com três elementos nulos, um vetor coluna com quatro elementos nulos
ou uma matriz 3x4 nula, basta fazer, respectivamente,
v=zeros(1,3)
u=zeros(4,1)
C=zeros(3,4)
Para formar uma matriz de zeros com as mesmas dimensões da matriz A, definida anteriormente,
pode-se fazer
C=zeros(A)
É possı́vel criar uma matriz diagonal cujos elementos formam uma sequência de inteiros
4
D=diag(2:6)
Com a mesma função, pode-se extrair os elementos da diagonal de uma matriz qualquer, inserindo-os
em um vetor coluna
u=diag(A)
Para formar uma matriz diagonal com os elementos da diagonal de outra matriz pode-se fazer
D=diag(diag(A))
E para criar uma matriz identidade de ordem qualquer basta fazer
I=diag(ones(1,3))
A soma e a subtração de matrizes de mesma dimensão é feita diretamente
D=A+B-C
Para somar, subtrair, multiplicar ou dividir cada elemento de uma matriz por um número qualquer,
basta fazer
D=((((A+1)-2)*3)/4)
A multiplicação de matrizes com dimensões compatı́veis também pode ser feita diretamente
D=A*B
Lembre-se que, em se tratando de uma multiplicação matricial, a ordem entre as matrizes é relevante.
Também, pode-se desejar efetuar a multiplicação de elemento por elemento entre matrizes de di-
mensões iguais. Se esse for o caso, a operação deve ser feita da seguinte forma:
D=A.*B
Aqui, evidentemente, a ordem do produto não é relevante.

É possı́vel extrair os elementos de uma determinada linha ou coluna de uma matriz. No exemplo
seguinte são extraı́dos os elementos da linha 1 da matriz A e da coluna 3 da matriz B:
D=A.*B
v=A(1,:)
u=B(:,3)
Para a extração da última linha ou coluna, pode-se também substituir o ı́ndice numérico por $. O
traço de uma matriz é dado por
d=trace(A)
5
A transposta de uma matriz é dada por
D=A’
E a inversa por
D=inv(A)
Para o cálculo de determinantes tem-se
d=det(A)
Finalmente, para se determinar os autovalores e os autovetores de uma matriz, faz-se
[v, d]=spec(A)
onde v é uma matriz cujas colunas representam os autovetores e d uma matriz cujos elementos da
diagonal fornecem os respectivos autovalores.
Polinômios
Para criar um polinômio em x com raı́zes nos pontos -2, 1 e 3 define-se um vetor v com as raı́zes e em
seguida cria-se o polinômio
v=[-2 1 3]
pl=poly(v,’x’)
Note que, diferentemente do que ocorre no MATLAB, os polinômios no Scilab são definidos natural-
mente com uma ordem crescente dos graus dos termos. Assim, recomenda-se atenção durante operações
em que este detalhe é relevante.
Uma segunda maneira de se inserir um polinômio é diretamente através de seus coeficientes, de modo
que o resultado obtido anteriormente pode ser reproduzido da seguinte maneira:
c=[6 -5 -2 1]
pl=poly(c,’x’,’coeff’)
De posse de dois polinômios, é possı́vel gerar uma função racional f:
p1=poly([1 2],’x’)
p2=poly([-1 0 3], ’x’)
f=p1/p2
Dado um polinômio, é possı́vel obter um vetor com os seus coeficientes
v=coeff(p1)
ou ainda com suas raı́zes
u=roots(p1)
6
Operadores lógicos
Para verificar se uma determinada variável é igual, maior, maior ou igual, menor, menor ou igual a um
determinado parâmetro, basta efetuar as respectivas operações:
a==1
a>1
a>=1
a<1
a<=1
As respostas do programa em relação às operações anteriores serão as variáveis booleanas T “true”,
caso a afirmação seja verdadeira, ou F “false”, caso a afirmação seja falsa. Note que essas operações serão
de grande importância como critérios de entrada e parada de comandos como if/else e while, conforme
será mostrado adiante. Evidentemente, estão presentes também os operadores lógicos “e” e “ou”, cuja
utilização é exemplificada a seguir:
a==1&b==2
a==1 |b==2
Se a=1 e b=3, as respostadas às operações anteriores serão, respectivamente, F (falso) e T (verda-
deiro).
2.2 O Scinotes
Embora prático para a execução de pequenas tarefas, como a determinação dos autovalores de uma
matriz ou a determinação das raı́zes de um polinômio, digitar os comandos diretamente no console do
Scilab pode não ser vantajoso para a elaboração de códigos mais complexos. Isso porque é difı́cil editar
comandos já executados e também porque não é possı́vel salvar o código escrito.
Assim, o método mais indicado para se inserir códigos longos é digitando-os em editores de texto,
permitindo que sejam editados, salvos e executados sempre que necessário.
O editor a ser usado é o SciNotes, disponı́vel através do botão SciNotes, próximo ao canto superior
esquerdo da janela do Scilab, conforme mostra a Figura (2.2), ou através do menu Aplicativos na opção
SciNotes.
Figura 2.2: Localização do botão SciNotes.
Todos os comandos mostrados anteriormente podem ser usados nos códigos escritos no SciNotes,
bastando apenas adicionar o ponto e vı́rgula ao final de cada comando.
7
A tı́tulo de comparação é mostrado a seguir o último exemplo da seção 2.1 Polinômios, mas agora
escrito no SciNotes:
p1=poly([1 2],’x’);
p2=poly([-1 0 3], ’x’);
f=p1/p2;
v=coeff(p1);
u=roots(p1);
Depois de escrito, o código deve ser salvo em um diretório apropriado para então ser executado
através do botão Executar mostrado na Figura (2.3). Adicionalmente pode-se salvar e executar o código
simultaneamente através do botão Salvar e executar mostrado na Figura (2.4), ou através do menu
Executar na opção Salvar e executar.
Figura 2.3: Localização do botão Executar.
Figura 2.4: Localização do botão Salvar e executar.
Quando um código no SciNotes é executado com sucesso a seguinte mensagem é impressa no console
do Scilab:
-->exec(’D:\exemplo.sce’, -1)
Da mesma forma, quando ocorre um erro na execução é impresso uma mensagem de erro identificando
o erro ocorrido e a linha em que ocorreu. No exemplo anterior, se substituirmos p1 por p3 na última
linha do código, após a execução será exibida a seguinte mensagem:
-->exec(’D:\exemplo.sce’, -1)
8
u=roots(p3);
!--error 4
Variável indefinida: p3
at line 5 of exec file called by :
exec(’D:\exemplo.sce’, -1)
Vale ressaltar que a identificação do erro e a sua localização nem sempre é exibida de forma clara e
direta pelo Scilab.
Para exibir o valor final de uma variável qualquer do código, basta digitar o seu nome no console
do Scilab e pressionar Enter. Outros métodos de exibição de resultados, especialmente o gráfico, serão
explorados mais adiante.
2.3 Entrada e execução de códigos básicos

Os próximos comandos e códigos que serão mostrados devem ser escritos e executados preferencialmente
através do SciNotes.
O comando if/else
A sintaxe do comando if/else é a seguinte:
se (if) condição satisfeita então (then)

execute estes comandos
senão (else)
fim (end)
Como exemplo, observe o código seguinte:
clear
a=-1;
if a>0 then
b=a;
else
b=-a;
end
A saı́da do código anterior na variável b é o módulo da variável a. O comando clear, presente

na primeira linha do exemplo anterior, remove da memória todas as variáveis de execuções anteriores,
evitando eventuais comportamentos anormais do código causado por inicializações incorretas de variáveis.
Assim, embora não seja essencial ao funcionamento, recomenda-se o seu emprego.
O comando while
O comando while é um comando de laço, através do qual pode-se executar um conjunto de operações
enquanto uma ou mais condições forem ou não satisfeitas. A sintaxe do comando while é dada a seguir:
enquanto (while) condição satisfeita

fim (end)
9
Como exemplo, é dado o código seguinte:
clear
i=0;
n=10;
a=2;
r=1;
while i<n,
r=r*a;
i=i+1;
end
A saı́da do código anterior na variável r é a variável a elevada à potência inteira positiva n.
O comando for
Assim como o comando while, o comando for destina-se à execução de laços, sendo sua sintaxe dada a
seguir:
para (for) cada elemento desta sequencia de inteiros

fim (end)
Como exemplo, é dado o mesmo código anterior, mas substituindo o laço while pelo laço for:
clear
n=3;
a=3;
r=1;
for i=1:n
r=r*a;
end
Definição de funções
O Scilab permite a definição de funções por parte do usuário. A seguir será definida a função teste:
deff(’[y]=teste(x)’,’if x<0 then y=-(xˆ2),else y=sin(x),end’);
Após definida a função, pode-se calcular o seu valor em um ponto qualquer do intervalo para o qual
está definida:
y=teste(0.5*%pi);
No exemplo anterior, a variável de entrada x era um escalar. No exemplo seguinte, a variável de

entrada é um vetor:
10
deff(’[y]=h(x)’,’n=length(x);
for i=1:n, if x(i)<0 then y(i)=2,
else y(i)=1+(x(i)-1)ˆ2,
end,end’);
Plotagem de gráficos
Definida a função anterior, criemos inicialmente um vetor de entrada com valores variando de -4 a 4 com
passo 0,1
x=-4:0.1:4;
Em seguida, calculamos o vetor de saı́da
y=h(x);
Para plotar o gráfico da função y=h(x) basta o comando
plot2d(x,y);
É possı́vel plotar gráficos em múltiplas janelas. Para exemplificar, será usada a função anterior para
plotar quatro gráficos onde a linha sólida é substituı́da por diferentes tipos de marcações. Para tanto
basta substituir o comando plot2d(x,y); pelos comandos a seguir:
scf(1);
plot2d(x,y,-1);
scf(2);
plot2d(x,y,-2);
scf(3);
plot2d(x,y,-3);
scf(4);
plot2d(x,y,-4);
2.4 Métodos de integração

Para a simulação numérica de sistemas mecânicos é essencial a capacidade de integrar no tempo os
sistemas de equações diferenciais que descrevem o seu comportamento. Para isso, podem-se utilizar
algoritmos de integração numérica como método de Euler ou o método de Runge-Kutta, ou ainda funções
integradoras prontamente disponı́veis nas bibliotecas dos ambientes computacionais de simulação. Esses
métodos, aplicados ao Scilab, serão descritos e utilizados a partir da seção seguinte.
11
Capı́tulo 3
Aplicações em Mecânica
3.1 Sistema massa-mola-amortecedor

Considere um bloco com massa m preso à um referencial inercial por uma mola de rigidez k e por um
amortecedor de coeficiente de amortecimento viscoso c. A posição x(t) do bloco é tambem medida a
partir de um referencial inercial. O esquema está representado na Figura (3.1).
Figura 3.1: Sistema massa-mola-amortecedor
A equação do movimento
A equação que rege o movimento do sistema pode ser obtida facilmente por meio do Teorema do Movi-
mento do Baricentro (TMB), através do equilı́brio de forças:
mẍ + cẋ + kx = 0 (3.1)

ou, isolando o ẍ,
c k
ẍ = − ẋ − x (3.2)
m m
A razão da forma apresentada em (3.2) será explicada posteriormente.
Declaração de parâmetros do sistema

Como descrito, o bloco tem massa m, a mola tem rigidez k, o amortecedor tem coeficiente de amorte-
cimento viscoso c. Entretanto, o programa que utilizaremos, Scilab, necessita do valor numérico destas
12
Capı́tulo 3. Aplicações em Mecânica
variáveis para realizar a simulação. Desta forma, define-se no inı́cio do programa todos os parâmetros
necessários para executá-lo. O script está a seguir:
//Incremento de tempo na resposta [s]

Dt = 0.0005;
// massas do problema [kg]

m=1.0;
// Rigidez da mola [N/m]

k = 1.0;
// Coeficiente de amortecimento viscoso [Ns/m]

c = 1.0;
// Instante inicial de integração [s]

t0 = 0.0;
// instante final de integracao [s]

tf = 12.0;
O incremento de tempo Dt é necessário para os métodos de solução da equação diferencial em questão.

O tempo final de integração t final fica a escolha do usuário.
Resolução da equação do movimento

Apesar da equação diferencial ordinária (EDO) em estudo apresentar solução analı́tica conhecida e
métodos simples para chegar a esta, o objetivo deste tutorial é apresentar ferramentas numéricas para
a solução de EDOs. Os principais métodos de resolução de EDOs fazem uso da abordagem de sistemas
pelo espaço de estados. Nesta abordagem, apenas existem estados e suas derivadas, como apresentado
na equação (3.3).
ẏ = f (t, y) (3.3)
e
y(t0 ) = y0 (3.4)
para ẏ o conjunto de equações diferenciais que descrevem o sistema, y seus estados e t o tempo.
O número de estados do sistema é igual à soma dos graus das EDOs que o descrevem, ou o número
de condições iniciais que devem ser fornecidas para obter-se a solução do problema. Frequentemente,
adotamos a variável que desejamos encontrar (neste caso, x) e sua derivada ẋ como os estados do sistema.
Será utilizado neste exemplo tal adoção de estados.
(
y1 = x
y2 = ẋ
Desta forma, obtemos as duas equações diferenciais, descritas no espaço de estados:
(
ẏ1 = y2
c k
ẏ2 = − m y2 − m y1
Para resolução destas equações, é necessário criar uma função que forneça as derivadas ẏ1 e ẏ2 a partir
dos estados y1 , y2 e t. O script da função está a seguir.
13
// carrega definicao da funcao f

function dx=f(t,x)
// equacoes do movimento dx/dt= f(t,x)
// onde x eh o vetor de estados definido
// por x = [ x; dx/dt];
dy1= x(2);
dy2= - (c/m)*x(2) - (k/m)*x(1);
dx = [dy1; dy2];
endfunction
O Scilab dispõe de uma excelente biblioteca, já implementada como funções, para solução de EDOs.
Entre elas, o método de Adams e Runge-Kutta. Não entraremos em detalhes quanto a estes métodos
pois foge do escopo do curso. A função do Scilab para tal chama-se ode. Ela tem como argumentos o
método de resolução (Neste exemplo, adotaremos o método "adams"), as condições iniciais do sistema
y0, o tempo inicial de execução t0, o array tempo t contendo valores de t0 a tf espaçados igualmente
de Dt, e a função f onde estão definidas as derivadas dos estados do sistema. Para mais informações
sobre a função ode, digite help ode no console do Scilab e este abrirá uma janela com a documentação
do comando.
O script que realiza a resolução das equações diferenciais é o seguinte:
// estado Inicial y0 = [x;xp]

y0=[1.0;0.0];
// Vetor de tempo
t = t0:Dt:tf;
// Método de integração
y = ode("adams", y0, t0, t, f);
Perceba que é necessário declarar as condições iniciais y0 como um array seguindo o padrão de entrada
que adotamos para a função f (y0 = [x0 xp0]).
Visualização dos resultados

O Scilab possibilita que se faça gráficos a partir de dados contidos em arrays. Perceba que é necessário que
haja duas sequências de dados com mesmo tamanho e que dados na mesma posição estejam relacionados
(y[i] corresponde ao x[i], por exemplo). Para o nosso exemplo, fazendo uso de variáveis já utilizadas
anteriormente, obtemos o seguinte script:
// elabora um grafico do deslocamento x(t)

//para o grafico dx/dt(t), basta substiuir y(1,:) por y(2,:)
scf(0);
xtitle(’Posicao x(t) (m) vs. Tempo (s)’);
plot2d(t,y(1,:));
Para nosso exemplo, para m = 1; k = 1; c = 1;, obtivemos o seguinte resultado:

Como esperado, o sistema é amortecido e tende a zero para um tempo suficientemente
q grande. Se
k
colocarmos c = 0, encontraremos a esperada senóide com velocidade angular ω = m = 1 rad/s, como
na figura (3.3).
14
Figura 3.2: Posição do bloco para m = 1, k = 1, c = 1, x0 = 1 e xp0 = 0.
Script de simulação
O script final de simulação obtido encontra-se abaixo.
// Codigo para simulacao - Massa-mola-amortecedor

clc
clear
//Incremento de tempo na resposta [s]

Dt = 0.0005;
// massas do problema [kg]

m=1.0;
// Rigidez da mola [N/m]

k = 1.0;
// Coeficiente de amortecimento viscoso [Ns/m]

c = 1.0;
// Instante inicial de integração [s]

t0 = 0.0;
// instante final de integracao [s]

tf = 12.0;
15
Figura 3.3: Posição do bloco para m = 1, k = 1, c = 0, x0 = 1 e xp0 = 0.
// carrega definicao da funcao f

function dx=f(t,x)
// equacoes do movimento dx/dt= f(t,x)
// onde x eh o vetor estado definido por
// x = [ x; dx/dt];
dy1= x(2);
dy2= - (c/m)*x(2) - (k/m)*x(1);
dx = [dy1; dy2];
endfunction
// estado Inicial y0 = [x;xp]

y0=[1.0;0.0];
// Vetor de tempo
t = t0:Dt:tf;
// Método de integração
y = ode("adams", y0, t0, t, f);
// elabora um grafico do deslocamento x(t)

// para o grafico dx/dt(t), basta substiuir y(1,:) por y(2,:)
scf(0);
xtitle(’Posicao X(t) (m) vs. Tempo (s)’);
plot2d(t,y(1,:));
16
3.2 Partı́cula que colide contra o solo

Considere uma partı́cula de massa m que é abandonada de uma altura h0 do solo com velocidade vertical
v0 , esta velocidade é considerada positiva quando a partı́cula se afasta do solo. Admite-se ainda que a
aceleração da gravidade é g = 9,81 m/s2 e que o coeficiente de restituição da colisão partı́cula/solo é e
= 0, 85. Nestas condições, a partı́cula irá colidir diversas vezes contra o solo conforme a figura (3.4)
Figura 3.4: Partı́cula colidindo contra o solo
Equações do movimento
Do teorema do movimento do baricentro, podemos afirmar que a partı́cula encontra-se somente sobre
ação da gravidade. Logo, ÿ = −g. Devido ao método de integração que adotaremos, é mais conveniente
utilizarmos a notação
(
y1 = y
y2 = ẏ
Desta forma, a equação do movimento, de segunda ordem, pode ser descrita por duas de primeira
ordem da forma
(
ẏ1 = y2
ẏ2 = −g
na forma matricial, encontramos
" # " #" # " #
ẏ1 0 1 y1 0
= +
ẏ2 0 0 y2 −g
Definindo as matrizes A e B como
" #
0 1
A =
0 0
17
e
" #
0
B =
−g
podemos adotar uma notação matricial para o problema da forma
ẏ = Ay + B (3.5)
A função do Scilab com as equações do movimento pode ser escrita no scinotes como reproduzido
abaixo:
function dy=f(t,y)
dy = A*y+B;
endfunction
O critério algébrico para encerrar a integração numérica

Como este se trata de um problema de mecânica onde há um choque, será preciso interromper a integração
numérica sempre que o mesmo ocorrer, e definir uma nova condição inicial para o estado y.
Para tanto, se pode criar uma função (g) que, quando retorna um valor menor ou igual à zero, indica
a ocorrência de um choque, e, portanto a integração deve ser interrompida.
function [z]=g(y);
z=y(1)+sqrt(y(2)*y(2))+y(2);
endfunction
z é a variável que a função retorna, quando seu valor é menor ou igual à zero, houve choque. y(1) é
o primeiro valor do vetor de entrada da função, que corresponde à altura da partı́cula, e y(2), o segundo
valor, corresponde à velocidade. Nota-se que a função só valerá zero se a altura for menor ou igual à
zero, e a velocidade, negativa.
Método de integração
O método de integração numérica usado nesse exemplo será o método de Runge-Kutta de 4a ordem,
também chamado RK4. Seja uma equação ordinária de primeira ordem, da forma:
dy
= f (t, y) , y(t0 ) = y0 (3.6)
dt
Então, segundo o método Runge-Kutta, a aproximação yn+1 para y(tn+1 ) é:
h
yn+1 = yn + (k1 + 2k2 + 2k3 + k4 ) (3.7)
6
tn+1 = tn + h (3.8)
E os coeficientes ki são definidos como:
k1 = f (tn , yn )
h h
k2 = f (tn + , yn + k1 )
2 2
h h
k3 = f (tn + , yn + k2 )
2 2
k4 = f (tn + h, yn + hk3 )
18
O que acontece, portanto, é que yn+1 é igual a yn acrescido de uma estimativa da inclinação do
intervalo multiplicada pelo tamanho (h) do intervalo. Para maiores informações sobre o método, visite o
sı́tio: http://pt.wikipedia.org/wiki/M%C3%A9todo_de_Runge-Kutta
Rotina de integração
A rotina de integração será realizada da seguinte maneira: Define-se um laço for com um contador i
associado. O laço descrito abaixo inicializa a variável i com o valor 1, e a cada iteração aumenta o seu
valor em 1, até que seja atingida a condição de parada do loop (i=imax).
for i=1:imax
k1=f(y(:,i));
k2=f(y(:,i)+[k1*dt/2]);
k3=f(y(:,i)+[k2*dt/2]);
k4=f(y(:,i)+[k3*dt]);
y(:,i+1)=y(:,i)+dt/6*(k1+2*k2+2*k3+k4);
end
A rotina acima define os coeficientes ki usando a função f (previamente definida) e o valor atual de
y (condição atual da partı́cula). y(:,i) indica um vetor coluna, contendo todos os valores da coluna i da
matriz y. A coluna i da matriz y representa o estado da variável no instante atual da integração, no caso
deste exemplo, a matriz y possui apenas duas linhas, a primeira sendo referente à altura e a segunda, à
velocidade da partı́cula. Uma vez definidos os coeficientes, calcula-se o valor de y(:,i+1) usando o método
RK4.
Cada passo do loop calcula o próximo valor de y, referente ao instante seguinte. Quando todos os
valores de y foram calculados para o intervalo de tempo especificado, o laço termina.
Porém no caso da partı́cula colidindo com o solo, os valores da altura da mesma não podem ser
menores do que zero. Para resolver este problema define-se um novo laço de condição (if), que avalia a
condição de choque (usando a função g) após cada passo da integração numérica e redefine os valores de
y se necessário, para os valores corrigidos pós-choque.
if g(y(:,i+1))<=0 then
novo_y0=[0;(-1)*y(2,i+1)*e];
y(:,i+1)=novo_y0; //definição da nova condição //inicial
end
O laço diz que, se, no instante atual de integração, o valor da função g(y) é menor ou igual à zero, o
estado atual da variável y deve ser modificado, tornando a altura igual a zero e multiplicando a velocidade
pelo coeficiente –e.
Script de integração
Na primeira parte do script os parâmetros do problema são informados, como variáveis globais. Define-se
o tempo inicial, o tempo final de integração, o intervalo de tempo em que gostarı́amos de conhecer o
estado do sistema dt, a altura inicial da partı́cula h0, a velocidade inicial da partı́cula v0, o estado inicial
y0, o coeficiente de restituição e, e a aceleração da gravidade grav. O valor imax será usado no laço
(loop) de integração, como o limite do contador do laço.
//apaga todos as variáveis criadas pelo usuário no scilab
19
clear
//gravidade e coeficiente de restituição

grav=9.81;
e=0.85;
//matrizes auxiliares para a função f (que será //integrada)

A=[0,1;0,0];
B=[0;-grav];
//condições iniciais
h0=5;
v0=-1;
y0=[h0;v0];
t0=0;
y=y0;
//variáveis de tempo
dt=0.001;
t_final=7;
t=(0:dt:t_final);
//valor máximo do contador para a integração

imax=round(t_final/dt);
A seguir definem-se as funções f (do movimento) e g (condição do choque) no script do scinotes:
//função a ser integrada

function [dy]=f(y)
dy=A*y+B;
endfunction
//função critério de interrupção da integração

function [z]=g(y);
z=y(1)+sqrt(y(2)*y(2))+y(2);
endfunction
Procede-se, então, uma sequência de integrações numéricas que são interrompidas pelo critério de co-
lisão. Após cada colisão, as condições de velocidade pós-choque são impostas. A sequência de integrações
numéricas é gerenciada pelo laço (loop) de programação for que segue.
//rotina de integração usando método de Runge-Kutta

for i=1:imax
k1=f(y(:,i));
k2=f(y(:,i)+[k1*dt/2]);
k3=f(y(:,i)+[k2*dt/2]);
k4=f(y(:,i)+[k3*dt]);
y(:,i+1)=y(:,i)+dt/6*(k1+2*k2+2*k3+k4);
20
//condição de choque
if g(y(:,i+1))<=0 then
novo_y0=[0;(-1)*y(2,i+1)*e];
y(:,i+1)=novo_y0; //definição da nova condição //inicial
end
end
Por último realiza-se a rotina de plotagem dos dados em uma janela gráfica do scilab.
//plot da resposta
plot2d (t,y’);
// o apóstrofe no y significa que o
// vetor/matriz é transposto(a)
legend (’h’,’v’);
title (’Altura x Tempo’);
xlabel (’Tempo’);
3.3 Veı́culo 2D passando por lombada

O sistema mostrado na Figura (3.5) representa uma simplificação de um veı́culo e seu sistema de sus-
pensão. Nesta simplificação, o sistema é composto por um sólido retangular de massa M e por duas
massas concentradas m1 e m2 . O ponto P indica o local onde o condutor do veı́culo está posicionado.
O sólido retangular está apoiado sobre dois conjuntos mola-amortecedor, cada um dos quais com valo-
res próprios de rigidez da mola k e da constante c do amortecedor viscoso linear. As duas molas têm
comprimento l0 quando a deformação é nula. No instante mostrado na Figura (3.5), o conjunto move-se
sobre uma superfı́cie horizontal, com velocidade constante ~v = v~i.
Figura 3.5: Modelo 2D de veı́culo e via com lombada.
Após percorrer uma distância L1 , o veı́culo tem de suplantar um obstáculo em sua trajetória, como
indicado na Figura (3.6). Durante a passagem pelo obstáculo, o veı́culo permanece com velocidade
constante. O pavimento tem altura definida por:
 L
 0
 se x ≤ L1 + 2 ;
H
h= 2
2π
1 − cos( L2
)x se L1 + L2 < x < L1 + L2 + L2 ; (3.9)

0 se x ≥ L1 + L2 + L2 .

Admitem-se como dados X0 = 0; L = 5 m; L1 = 50 m; L2 = 3, 7 m; H = 0, 1 m; b = 0, 1 m; b1 =

0, 7 m; M = 400 kg; V = 18 m/s e g = 9, 8 m/s2 . Sugere-se utilizar 0,001 s como intervalo de inte-
21
Figura 3.6: Veı́culo sobre a lombada.
gração. Considerando-se ainda m1 = m2 = 120 kg; d1 = d2 = 2, 5 m; k1 = k2 = 30000 N/m; c1 = c2 =

2100 N s/m; yO (0) = l0 = 0, 3 m e α(0) = 0.
As equações do movimento foram determinadas para o movimento de arfagem α, Equação (3.10).
A dedução pode ser feita através dos teoremas do movimento do centro de massa e do teorema da
quantidade de movimento angular ou através da Mecânica Analı́tica.
sen(α)(M2 d2 − M1 d1 )ẍO +
cos(α)(M1 d1 − M2 d2 )ÿO +
(M1 d21 − M2 d22 )α̈+
cos(α)(M1 d1 − M2 d2 )g−
(3.10)
k1 Lcos(α)(l0 − yO − Lsen(α) + yA )+
k2 Lcos(α)(l0 − yO − Lsen(α) + yB ) =
− c1 Lcos(α)(ẏO + Lα̇cos(α))−
ẏA + c2 Lcos(α)(ẏO − Lα̇) − ẏB
e para a oscilação vertical yO , Equação (3.11).
(M1 + M2 + M + m)ÿO +
cos(α)(M1 d1 − M2 d2 )α̈+
sen(α)(M2 d2 − M1 d1 )α̇2 +
(M1 + M2 + M + m)g − k1 (l0 − y0 − Lsen(α) + yA )+ (3.11)
k2 (l0 − y0 + Lsen(α) + yB ) =
− c1 (ẏO − Lα̇cos(α) − ẏA )+
c2 (ẏO − Lα̇cos(α)) − ẏA
O procedimento básico para efetuar a simulação numérica do comportamento dinâmico do sistema é

o mesmo que tem sido aplicado nos exemplos anteriores, ou seja, definição dos parâmetros constantes,
redução das duas equações diferenciais de segunda ordem do sistema, no caso as Equações (3.10) e
3.11, para quatro equações diferenciais de primeira ordem, definição dos parâmetros iniciais, definição do
incremento de tempo e do instante final, integração propriamente dita e exposição gráfica dos resultados.
O código usado para a simulação é apresentado a seguir:
clear
22
k1 = 30000;
k2 = 30000;
d1 = 2.50;
d2 = 2.50;
M = 400;
M1 = 120;
M2 = 120;
L = 5.0;
L1 = 50.0;
L2 = 3.7;
L0 = 0.3;
Y_0 = L0;
b = 0.1;
c1 = 2100.0;
c2 = 2100.0;
v = 18.0;
g = 9.8;
H = 0.1;
b1 = 0.7;
y0 = [L0; 0.0; 0.0; 0.0; 0.0];
JO = M*(b*b + L*L)/12;
A = M1 + M2 + M;
B = (M1*d1 - M2*d2);
C = M1*d1*d1 + M2*d2*d2 + M*(b*b + L*L)/12;
tA1 = L1/v
tA2 = (L1 + L2)/v
tB1 = (L1 + L)/v
tB2 = (L1 + L2 + L)/v
t_inicial = 0.0;
Dt = 0.001;
t_final = 10.0;
t = [t_inicial:Dt:t_final];
function [dy]=car(t,y)
if t < tA1 then
yA = 0.0;
dyA = 0.0;
else
if t < tA2 then
yA = H*(1 - cos(2*%pi*(v*t - L1)/L2))/2;
dyA = H*(sin(2*%pi*(v*t - L1)/L2))*%pi*v/L2;
else
yA = 0.0;
dyA = 0.0;
end
end
if t < tB1 then
yB = 0.0;
dyB = 0.0;
else
if t < tB2 then
yB = H*(1 - cos(2*%pi*(v*t - L1 - L)/L2))/2;
dyB = H*(sin(2*%pi*(v*t - L1 - L)/L2))*%pi*v/L2;
23
else
yB = 0.0;
dyB = 0.0;
end
end
F = -A*g + B*sin(y(3))*y(4)*y(4) + k1*(L0-y(1) - L*sin(y(3))/2 + yA) +...
k2*(L0-y(1)+L*sin(y(3))/2 + yB) - c1*(y(2) + L*y(4)*cos(y(3))/2 - dyA) - ...
c2*(y(2) - L*y(4)*cos(y(3))/2 - dyB);
H = -B*g*cos(y(3)) + k1*L*cos(y(3))*(L0 - y(1) - L*sin(y(3))/2 + yA)/2 - ...
k2*L*cos(y(3))*(L0 - y(1) + L*sin(y(3))/2 + yB)/2 - c1*L*cos(y(3))*(y(2) + ...
L*y(4)*cos(y(3))/2 - dyA)/2 + c2*L*cos(y(3))*(y(2) - L*y(4)*cos(y(3))/2 - dyB)/2;
determinante = A*C - B*B*cos(y(3))*cos(y(3));
dy1 = y(2);
dy2 = (C*F - B*cos(y(3))*H)/determinante;
dy3 = y(4);
dy4 = (A*H-B*cos(y(3))*F)/determinante;
dy5 = dy2;
dy = [dy1;dy2;dy3;dy4;dy5];
endfunction
ys = ode(’stiff’, y0, t_inicial, t, car);
scf(1);
plot2d(t’,[ys(1,:)’]);
xtitle(’Deslocamento vertical do ponto O vs. tempo’,’t’,’Yo’);
scf(2);
plot2d(t’,[ys(3,:)’]);
xtitle(’Arfagem vs. tempo’,’t’,’Angulo alfa’);
for i = 1:tA1/Dt
yb1(i) = ys(1,tA1/Dt) + b1*sin(ys(3,tA1/Dt));
end
for i = tA1/Dt:t_final/Dt
yb1(i) = ys(1,i) + b1*sin(ys(3,i));
end
desconforto = max(abs(yb1(:) - yb1(t_final/Dt - 1)));
scf(3);
plot2d(yb1);
xtitle(’Altura na posição do piloto vs. tempo’,’t’,’Yb1 (m)’);
Observe que nesta simulação foi usado o solucionador de equações diferenciais ordinárias ode. Três
gráficos são gerados, estando no primeiro a história temporal do deslocamento vertical variável yO , no
segundo a história temporal do ângulo de arfagem α e no terceiro o deslocamento vertical no assento
do piloto yb 1, que depende tanto de α quanto de yO . A Figura (3.7) apresenta o gráfico de yO = yO (t)
e a Figura (3.8) apresenta o gráfico de αO = αO (t) para esta condição. Observe que o gráfico de yO
permite identificar dois instantes distintos do movimento, um deles, inicial, associado à estabilização de
yO em um valor de equilı́brio e outro associado à passagem do veı́culo pelo obstáculo. Desta forma é
possı́vel obter informações sobre conforto ou segurança de um veı́culo na fase de projeto, lembrando que
as hipóteses de modelagem restringem o campo de perguntas que podemos dirigir à simulação numérica,
ou em outras palavras, a metodologia restringe o campo das conclusões pertinentes.
24
25
Capı́tulo 3
Bibliografia
[1] Ajuda Scilab. Mar. de 2013. url: http://help.scilab.org/docs/5.4.0/pt_BR/index.html.

[2] R. G. Lima. Tutorial para integrar equações de movimento utilizando o Scilab. Mar. de 2013. url:
http://sites.poli.usp.br/d/pme2200/Tutorial_scilab.pdf.
[3] Lista A - Aulas práticas de Scilab. Mar. de 2013. url: http://sites.poli.usp.br/d/pme2371/
PDF/Lista_A_PME2371_2007.pdf.
[4] Scilab for very beginners tutorial. Mar. de 5. url: http://www.scilab.org/community/news/
20130214.
26

Tutorial Scilab Novo

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Tutorial Scilab Novo

Enviado por

Direitos autorais:

Formatos disponíveis

Escola Politécnica da Universidade de São Paulo

Tutorial para Scilab

Tutorial escrito pelos monitores:

Figura 2.1: Ambiente de programação padrão do Scilab.

2.1 Entrada e execução de comandos básicos

Variáveis constantes e operadores elementares

Constantes complexas podem ser definidas como

Note que o Scilab trabalha com ângulos em radianos.

Para inserir uma matriz qualquer pode-se fazer

A=[45 13 -7; 13 22 -30; -7 -30 -6]

gerando o mesmo resultado.

E para criar uma matriz identidade de ordem qualquer basta fazer

A soma e a subtração de matrizes de mesma dimensão é feita diretamente

Aqui, evidentemente, a ordem do produto não é relevante.

A transposta de uma matriz é dada por

Para o cálculo de determinantes tem-se

Finalmente, para se determinar os autovalores e os autovetores de uma matriz, faz-se

De posse de dois polinômios, é possı́vel gerar uma função racional f:

Dado um polinômio, é possı́vel obter um vetor com os seus coeficientes

ou ainda com suas raı́zes

Figura 2.2: Localização do botão SciNotes.

Figura 2.3: Localização do botão Executar.

Figura 2.4: Localização do botão Salvar e executar.

2.3 Entrada e execução de códigos básicos

se (if) condição satisfeita então (then)

Como exemplo, observe o código seguinte:

A saı́da do código anterior na variável b é o módulo da variável a. O comando clear, presente

enquanto (while) condição satisfeita

Como exemplo, é dado o código seguinte:

A saı́da do código anterior na variável r é a variável a elevada à potência inteira positiva n.

para (for) cada elemento desta sequencia de inteiros

deff(’[y]=teste(x)’,’if x<0 then y=-(xˆ2),else y=sin(x),end’);

No exemplo anterior, a variável de entrada x era um escalar. No exemplo seguinte, a variável de

Em seguida, calculamos o vetor de saı́da

Para plotar o gráfico da função y=h(x) basta o comando

2.4 Métodos de integração

3.1 Sistema massa-mola-amortecedor

Figura 3.1: Sistema massa-mola-amortecedor

mẍ + cẋ + kx = 0 (3.1)

Declaração de parâmetros do sistema

//Incremento de tempo na resposta [s]

// massas do problema [kg]

// Rigidez da mola [N/m]

// Coeficiente de amortecimento viscoso [Ns/m]

// Instante inicial de integração [s]

// instante final de integracao [s]

O incremento de tempo Dt é necessário para os métodos de solução da equação diferencial em questão.

Resolução da equação do movimento

// carrega definicao da funcao f

// estado Inicial y0 = [x;xp]

Visualização dos resultados

// elabora um grafico do deslocamento x(t)

Para nosso exemplo, para m = 1; k = 1; c = 1;, obtivemos o seguinte resultado:

Figura 3.2: Posição do bloco para m = 1, k = 1, c = 1, x0 = 1 e xp0 = 0.

// Codigo para simulacao - Massa-mola-amortecedor

//Incremento de tempo na resposta [s]

// massas do problema [kg]

// Rigidez da mola [N/m]

// Coeficiente de amortecimento viscoso [Ns/m]

// Instante inicial de integração [s]

// instante final de integracao [s]

Figura 3.3: Posição do bloco para m = 1, k = 1, c = 0, x0 = 1 e xp0 = 0.