PORTFÓLIO

opcao = 1;

while opcao ~= 0
% Dados fundamentais do motor V = input('Insira a tensão (V): '); while isempty(V) || ~isnumeric(V)

V = input('Valor inválido. Por favor, insira a tensão (V): ');

end

f = input('Insira a frequência (Hz): '); while isempty(f) || ~isnumeric(f)

f = input('Valor inválido. Por favor, insira a frequência (Hz): ');

end

P = input('Insira o número de pólos: ');
while isempty(P) || ~isnumeric(P) || mod(P, 2) ~= 0

P = input('Número de pólos ímpar não é permitido. Por favor, insira um número de pólos par: ');

end

R1 = input('Insira a resistência do estator (Ohms): '); while isempty(R1) || ~isnumeric(R1)

R1 = input('Valor inválido. Por favor, insira a resistência do estator (Ohms): ');

end

X1 = input('Insira a reatância do estator (Ohms): '); while isempty(X1) || ~isnumeric(X1)

X1 = input('Valor inválido. Por favor, insira a reatância do estator (Ohms): ');

end

R2 = input('Insira a resistência do rotor (Ohms): '); while isempty(R2) || ~isnumeric(R2)

R2 = input('Valor inválido. Por favor, insira a resistência do rotor (Ohms): ');

end

X2 = input('Insira a reatância do rotor (Ohms): '); while isempty(X2) || ~isnumeric(X2)

X2 = input('Valor inválido. Por favor, insira a reatância do rotor (Ohms): ');

end

Xm = input('Insira a reatância de magnetização (Ohms): '); while isempty(Xm) || ~isnumeric(Xm)

Xm = input('Valor inválido. Por favor, insira a reatância de magnetização (Ohms): ');

end

% Solicitar velocidade de rotação
N = input('Insira a velocidade de rotação (RPM): '); while isempty(N) || ~isnumeric(N)

N = input('Valor inválido. Por favor, insira a velocidade de rotação (RPM): ');

end

% Cálculo dos parâmetros do motor
s = (0:1:50)/50; % escorregamento
Z1 = R1 + 1j*X1; % impedância do estator
Z2 = R2./s + 1j*X2; % impedância do rotor
Zm = 1j*Xm; % impedância de magnetização
Z = Z1 + ((Z2.*Zm)./(Z2 + Zm)); % impedância total I2 = V./Z; % corrente do rotor
Pg = 3*abs(I2).^2.*real(Z2); % potência do ar
T = Pg./(2*pi*f); % torque

% Gráfico de Torque vs Escorregamento figure;
plot(s, T, '--'); % Linha tracejada title('Torque vs Escorregamento'); xlabel('Escorregamento (s)'); ylabel('Torque (N.m)');

xlim([0 1]); % Ajusta o eixo x para começar em 0 e terminar em 1

% Verificar a tabela e seus valores (valor do conjugado,...etc)
fprintf('\nValores calculados:\n');
fprintf('----------------------\n');
fprintf('Velocidade de Rotação: %d RPM\n', N);
fprintf('Corrente do Rotor: %.4f A\n', abs(I2(1))); % Valor para escorregamento = 0 fprintf('Torque Máximo: %.4f N.m\n', max(T));

fprintf('----------------------\n');

% Perguntar se deseja comparar com outro motor
comparar = input('Deseja comparar com outro motor? (1 - Sim, 0 - Não): ');

if comparar == 0
opcao = input('Digite 0 para encerrar ou qualquer outro número para continuar: ');

end end

% Cálculo da potência aparente S = V * conj(I2);

% Fator de potência pf = real(Pg) / abs(Pg);

% Corrente no estator I1 = V / Z1;

% Corrente total
I_total = sqrt(abs(I1)^2 + abs(I2)^2);

% Tensão induzida no rotor E2 = V - I2 * Z2;

% Escorregamento percentual s_percent = s * 100;

% Potência reativa Q = imag(S);

% Potência complexa no rotor S2 = E2 * conj(I2);

% Eficiência do motor efficiency = real(Pg) / real(S);

% Fator de serviço SF = real(S) / abs(S);

% Fator de potência aparente pf_apparent = real(S) / abs(S);

% Potência ativa total P_total = real(S);

% Potência reativa total Q_total = imag(S);

% Fator de potência total
pf_total = cos(atan(Q_total / P_total));

import math

def carga_de_vento_em_domo_geodesico(raio, velocidade_do_vento):
# Constantes
densidade_do_ar = 0,02 # kg/m^3 (densidade padrão do ar ao nível dos polos de Marte) coeficiente_de_arrasto = 0.6 # Supondo um valor típico para um domo geodésico

# Cálculos
diametro = 2 * raio
area_de_secao_transversal = math.pi * raio**2
carga_de_vento_por_metro_quadrado = 0.5 * densidade_do_ar * velocidade_do_vento**2 *

coeficiente_de_arrasto * area_de_secao_transversal
carga_total_de_vento = carga_de_vento_por_metro_quadrado * area_de_secao_transversal

return diametro, coeficiente_de_arrasto, area_de_secao_transversal, carga_de_vento_por_metro_quadrado, carga_total_de_vento

def main():
# Entrada do usuário
raio_do_domo = float(input("Digite o raio do domo (metros): ")) velocidade_do_vento = float(input("Digite a velocidade do vento (km/h): "))

# Converter velocidade do vento de km/h para m/s velocidade_do_vento = velocidade_do_vento * 1000 / 3600

# Calcular a carga de vento no domo geodésico

diametro, coeficiente_de_arrasto, area_de_secao_transversal, carga_de_vento_por_metro_quadrado, carga_total_de_vento = \

carga_de_vento_em_domo_geodesico(raio_do_domo, velocidade_do_vento)

# Declarações de impressão para depuração
print("\nInformações de Depuração:")
print(f"Velocidade do Vento Convertida: {velocidade_do_vento} m/s")

# Exibir resultados
print("\nResultados:")
print(f"Diâmetro do Domo Geodésico: {diametro} metros")
print(f"Coeficiente de Arrasto: {coeficiente_de_arrasto}")
print(f"Área de Seção Transversal: {area_de_secao_transversal} metros quadrados") print(f"Carga de Vento por Metro Quadrado: {carga_de_vento_por_metro_quadrado} N/m^2") print(f"Carga Total de Vento: {carga_total_de_vento} Newtons")

if __name__ == "__main__": main()