Código no MATLAB para o traçado de diagrama de

esforço cortante e momento fletor

Introdução

O programa é constituído por uma rotina (M-file) e uma

função, intitulados decdmf e funcsing, respectivamente. Foi
desenvolvido tendo como base a teoria das funções singulares,
facilmente encontrada em qualquer livro de Resistência dos
Materiais ou projetos mecânicos

Objetivo

Propiciar um traçado ágil e fácil dos diagramas, tendo como

único esforço o esboço do diagrama de corpo livre para a
consequente montagem da matriz solicitações S.

Código

No MATLAB, selecione para criar um novo script, cole e salve os

dois códigos a seguir, separadamente, cada um em um arquivo
distinto

decdmf

clear a c dx i I I_row I_col k L m M0 M1 n q0 q1 t1 t2 V0 V1 xc y y1 b M

Mmax q S V Vmax x
% Usar unidades padrão (N e m para SI).Para o sistema imperial, as
legendas continuarão a apresentar os símbolos em Si
% S=[c1 y1 a1 b1;c2 y2 a2 b2;... ] Matriz solicitações onde c é o tipo de
% função singular, y a intensidade da solicitação(com sinal), 'a' o seu
posicionamento na viga tendo como origem a extremidade esquerda
% b: posição em x onde termina o carregamento (uniforme ou linear); para
qualquer outro tipo
% de solicitação, deixar o campo com valor = 0
% L: comprimento da viga

S=input('Entre com a matriz mx4 de solicitações: ');

L=input('Comprimento da viga: ');
i=0;
dx=L/(3e3); %incremento
xc=-dx; %incremento usado no vetor x
[m,n]=size(S); % m é a qtd de linhas (solicitações) na matriz S
n=L/dx; %número subintervalos de x

t1=0; %teste 1
t2=0; %teste 2
while(1) %condição para funcionamento do programa
i=i+1;
t1=S(i,1);
if t1<-2 || t1>1
t2=1;
end
if i>=m break, end
end
if t2==1
disp('Valor para c invalido');
return
end

for i=1:n+1 %interpolação de x, q, V e M

xc=xc+dx;
x(i)=xc;

q1=0; %var nova

V1=0;
M1=0;
for k=1:m % soma das solicitações para cada valor de x
q0=q1; %var velha recebe nova
V0=V1;
M0=M1;

c=S(k,1);
y=S(k,2);
a=S(k,3);
b=S(k,4);
q1=y*funcsing(c,a,b,x(i),1,dx); % y*(x-a)^n
V1=y*funcsing(c,a,b,x(i),2,dx);
M1=y*funcsing(c,a,b,x(i),3,dx);

q1=q1+q0;
V1=V1+V0;
M1=M1+M0;
end
q(i)=q1;
V(i)=V1;
M(i)=M1;
end

%Estipulando Vmax e Mmax

[n,I]=max(abs(V(:))); % valor máximo abs e índice
[I_row,I_col]=ind2sub(size(V),I); %indice da linha e coluna do valor max
Vmax(1)=x(I_col); % valor de x para Vmax
Vmax(2)=V(I_col); %Vmax com sinal

[n,I]=max(abs(M(:))); % valor máximo abs e índice

[I_row,I_col]=ind2sub(size(M),I); %indice da linha e coluna do valor Mmax
Mmax(1)=x(I_col); % valor de x para Mmax
Mmax(2)=M(I_col); %Mmax com sinal

%diagramas
subplot(3,1,1);
y1=x.^0-1;
plot(x,y1,'-','color','k')
hold on
plot(x,q,'-','color','r');
hold off
xlabel('(m)');
ylabel('w(N/m)','rotation',0);
grid;

subplot(3,1,2);
plot(x,y1,'-','color','k')
hold on
plot(x,V,'-','color','r');
hold off
xlabel('(m)');
ylabel('V(N)','rotation',0);
grid;
text(Vmax(1),Vmax(2),'\it V_{max}'); %inserir coord. de Vmax

subplot(3,1,3);
plot(x,y1,'-','color','k')
hold on
plot(x,M,'-','color','r');
hold off
xlabel('(m)');
ylabel('M(N.m)','rotation',0);
grid;
text(Mmax(1),Mmax(2),'\it M_{max}'); %inserir coord. de Mmax

clear a b c dx i I I_row I_col k L m M0 M1 n q0 q1 t1 t2 V0 V1 xc y y1

fprintf('\nEsforço Cortante \nx= %.3e(m), Vmax= %.3e(N)\nMomento Fletor
\nx= %.3e(m), Mmax= %.3e(N.m)\n',Vmax(1),Vmax(2),Mmax(1),Mmax(2));

Sub-rotina funcsing (função)

function [y] = funcsing (c,a,b,x,f,dx)

%funcsing sub-rotina funções singulares
%Calcula o valor para funções singulares
%Entrar com a matriz linha A=[c y a] e o escalar x, sendo:
% A:
%c: tipo da função singular
%ex.: c= -2 (doublet unitária)
%ex.: c= -1 (impulso delta Dirac)
%ex.: c= 0 (degrau unitária Heaviside)
%ex.: c= 1 (rampa unitária)
%y: intensidade da solicitação
%a: posição inicial em x da solicitação
% x: posição para a qual se necessita saber q, V e M
% f: tipo de função (q,v,M)=(1,2,3)
y=0;
dx1=dx*0.505;
switch c
case -2 % doublet unitária (momento de binário)
switch f
case 1 %q (x-a)^-2
 y=0;

case 2 %V (x-a)^-1
y=0;

case 3 %M (x-a)^0
if x>=a
y=1;
else
y=0;
end
end

case -1 % impulso, deltaDirac (carga concentrada)

switch f
case 1 % (x-a)^-1
if abs(x-a)<dx1
y=1;
else
y=0;
end

case 2 % (x-a)^0
if x>=a
y=1;
else
y=0;
end

case 3 % (x-a)^1
if x>=a
y=(x-a);
else
y=0;
end
end

case 0 % degrau unitário, Heaviside (carregamento uniforme)

switch f
case 1 % (x-a)^0
if x>=a && x<b
y=1;
elseif x>=b
y=0;
else
y=0;
end
case 2 % (x-a)^1
if x>=a && x<b
y=(x-a);
elseif x>=b
y=(x-a)-(x-b);
else
y=0;
end
 case 3 % (x-a)^2
if x>=a && x<b
y=0.5*(x-a)^2;
elseif x>=b
y=0.5*(x-a)^2 - 0.5*(x-b)^2;
else
y=0;
end
end

otherwise % rampa unitária

switch f
case 1
if x>=a && x<b
y=(x-a);
elseif x>=b
y=0;
else
y=0;
end
case 2
if x>=a && x<b
y=((x-a)^2)/2;
elseif x>=b
y=((x-a)^2)/2 - ((x-b)^2)/2 - (b-a)*(x-b);
else
y=0;
end
case 3
if x>=a && x<b
y=((x-a)^3)/6;
elseif x>=b
y=((x-a)^3)/6 - ((x-b)^3)/6 - ((b-a)*(x-b)^2)/2;
else
y=0;
end
end
end
end

Funcionamento

Na aba HOME, selecione o ícone Open e abra a pasta na qual

foi armazenado os arquivos decdmf e funcsing. Em seguida,
digite no Command Window decdmf, entre com a matriz
solicitações e em seguida com o comprimento da vida, como é
requisitado. No Command Window será possível ver o esforço
cortante e momento fletor máximo e os seus respectivos
valores para x. Em seguida, um exemplo de matriz
solicitações.

Para uma viga em balanço, engastada na extremidade esquerda

(A), disposta horizontalmente, com uma força de 1 kN
direcionada para baixo na extremidade direita (B), com 2 m de
comprimento, temos as seguintes solicitações:

𝑀𝐴 = −2 [𝑘𝑁. 𝑚]
𝑅𝐴 = 1 [𝑘𝑁]
𝐹𝐵 = −1 [𝑘𝑁]

Matriz S=[-1 10^3 0 0;-2 -2*10^3 0 0;-1 -10^3 2 0];

Cada linha da matriz representa uma solicitação, sendo essa

linha composta por: [c y a b], sendo:
c: tipo de solicitação, -2 para momentos; -1 cargas pontuais;
0 carregamentos uniformes, 1 carregamentos lineares.
y: intensidade da solicitação (com sinal).
a: posicionamento da solicitação na viga, tendo como origem a
extremidade esquerda.
b: para carregamentos distribuídos, determina a posição onde
termina o carregamento (para solicitação que não são
carregamentos distribuídos, b=0).

Considerações finais
Apesar de sua limitação em relação aos tipos de carregamentos que
podem ser utilizados no programa, na prática isso não constitui um
problema, pois grande parte dos carregamentos são uniformes,
lineares ou uma combinação de ambos. O código pode ainda ser
melhorado, implementando a função que corresponde à inclinação da
viga, y’(x), e sua deflexão, y(x), (ver NORTON, pg. 163).

Referências
BEER,Ferdinand P.; JOHNSTON, E. Russel. Mechanics of Materials, 7ª
ed., Mc Graw Hill, 2015

SHIGLEY, Joseph E.. Projeto de Engenharia Mecânica 7ª ed.,

Bookman, 2005;

NORTON, Robert L..Projetos de Máquinas, 4ª ed., Bookman, 2013.