Encomenda do Projeto 03: Indicadores de Gestão de Manutenção

Grupo

EAS 02 – Ambulatório

Valores:

Conjunto de dados para EAS da equipe 02: AMBULATÓRIO

▪ 𝐵𝑎𝑐𝑘𝑙𝑜𝑔 = 𝐻𝐻 𝑂𝑆 𝑃𝑙𝑎𝑛𝑒𝑗𝑎𝑑𝑎𝑠 = 32 𝐻𝐻 𝑂𝑆 𝑃𝑒𝑛𝑑𝑒𝑛𝑡𝑒𝑠 = 15 𝐻𝐻 𝑂𝑆 𝑃𝑟𝑜𝑔𝑟𝑎𝑚𝑎𝑑𝑎𝑠 = 16 𝐻𝐻 𝑂𝑆 𝐸𝑥𝑒𝑐𝑢𝑡𝑎𝑑𝑎𝑠 = 13

▪ Custo do EMH parado = R$ 1.200,00 por hora

▪ Hora Homem Total = 18 horas ▪ Fator de Produtividade = 0,42

▪ Custo Total de Manutenção = R$ 520.000,00

▪ Faturamento Bruto = R$ 2.300.000,00

▪ Custo Específico de Manutenção EMH = R$ 850,00

▪ Valor de Compra EMH Novo = 35.000,00

▪ 𝐷𝑎𝑑𝑜𝑠 𝑑𝑒 𝑀𝑎𝑛𝑢𝑡𝑒𝑛çã𝑜 = 07 𝑀𝐶 =914 𝑀𝑃 =706 𝑀𝑃𝑑 =234 𝐸𝑛𝑔.𝜀 𝑀𝑒𝑙ℎ𝑜𝑟𝑖𝑎𝑠 = 108

Data:

Início: 03.06.2024 • Fim: 17.06.2024 • Entrega: 24.06.2024 IMPRESSO & pdf

Escopo do Projeto:

Cada equipe (grupo de alunos) deve se colocar como um EAS de determinada atividade de saúde para a qual receberá um conjunto de dados numéricos qualitativos concernentes à atividade específica de cada EAS.

Com esses dados, cada equipe deverá cumprir a tarefa do projeto 02: exercitar o ferramental matemático que envolve os OITO principais indicadores de Gestão de Manutenção.

Cada Equipe deve elaborar um texto introdutório que justifique a relevância do projeto;

A tarefa compreende um documento de encaminhamento impresso para toda a tarefa da encomenda explicitada a seguir.

Justificativa do Trabalho

A gestão eficiente de serviços de saúde, especialmente em ambientes ambulatoriais de segunda linha (EAS2), exige uma abordagem sistemática na monitorização e análise de indicadores de desempenho. Esses indicadores são essenciais para assegurar a qualidade, eficiência e segurança no atendimento aos pacientes. A NBR 5462, que trata de confiabilidade e mantenabilidade, fornece uma estrutura valiosa para a gestão desses indicadores. A seguir, são apresentados os aspectos gerais que justificam a importância da manutenção de indicadores no contexto de EAS2 e em conformidade com a NBR 5462.

Conformidade com a NBR 5462

A NBR 5462 enfatiza a importância de se estabelecer uma abordagem estruturada para monitorar e analisar o desempenho dos sistemas e equipamentos. Isso inclui a implementação de práticas que garantam:

1. Confiabilidade:
   • Garantir que os equipamentos médicos funcionem corretamente durante o tempo necessário é crucial para o atendimento eficaz aos pacientes. A confiabilidade dos equipamentos é um aspecto central para prevenir falhas inesperadas que possam comprometer os cuidados de saúde.
2. Mantenabilidade:
   • Facilitar a manutenção dos equipamentos é essencial para minimizar o tempo de inatividade e garantir que eles estejam sempre prontos para uso. A manutenção adequada contribui para a longevidade dos equipamentos e a continuidade dos serviços de saúde.
3. Planejamento e Controle:
   • O uso de indicadores permite um planejamento e controle mais precisos das atividades de manutenção. Isso ajuda a antecipar problemas, alocar recursos de maneira eficiente e implementar ações corretivas e preventivas com base em dados concretos.

Aplicação no Contexto de EAS2

Em um ambulatório de segunda linha, a manutenção de indicadores é fundamental para atender às necessidades específicas de um ambiente de saúde dinâmico e exigente:

1. Qualidade do Atendimento ao Paciente:
   • Monitorar indicadores de desempenho garante que os pacientes recebam cuidados de alta qualidade sem interrupções. Indicadores ajudam a identificar rapidamente quaisquer problemas que possam afetar a qualidade do atendimento e permitem a implementação de soluções eficazes.
2. Segurança do Paciente:
   • A segurança é uma prioridade máxima em qualquer ambiente de saúde. Manter um sistema robusto de indicadores permite a detecção precoce de falhas ou degradações no desempenho dos equipamentos, prevenindo incidentes que possam comprometer a segurança dos pacientes.
3. Eficiência Operacional:
   • Indicadores bem geridos permitem otimizar o uso dos recursos do ambulatório. Isso inclui a gestão eficaz dos equipamentos médicos, garantindo que estejam disponíveis e operacionais quando necessários, e a redução de tempo de inatividade.
4. Custo-Benefício:
   • Um sistema eficiente de monitorização de indicadores ajuda a identificar tendências de falhas e necessidades de manutenção antes que se tornem problemas maiores e mais caros. Isso resulta em uma gestão de custos mais eficaz, com menos despesas emergenciais e mais investimentos em manutenção preventiva.

Python

import matplotlib.pyplot as plt
# Dados fornecidos
backlog_hh_os_planejadas = 32
backlog_hh_os_pendentes = 15
backlog_hh_os_programadas = 16
backlog_hh_os_executadas = 13
custo_emh_parado = 1200  # h
hora_homem_total = 18  # horas
fator_produtividade = 0.42
custo_total_manutencao = 520000  # R$
faturamento_bruto = 2300000  # R$
custo_especifico_manutencao_emh = 850  # h
valor_compra_emh_novo = 35000  # h
mc = 914 #Manutenção corretiva
mp = 706 #Manutenção preventiva
mpd = 234 #Manutenção preditiva
eng_melhorias = 108

MTBF: Tempo médio entre falhas;

# Calculando o número de falhas
horas_operacao = mc + mp + mpd + eng_melhorias
print(f"Horas de Operacao Total:{horas_operacao}")

nprodutivo = (1-fator_produtividade) * horas_operacao
print(f"Horas não produtivas:{nprodutivo}")

# Calculando o MTBF
mtbf = horas_operacao / custo_especifico_manutencao_emh 

# Exibindo o valor do MTBF
print(f"O Tempo Médio Entre Falhas (MTBF) é: {mtbf:.2f} horas")

Resultado:

Horas de Operacao Total:1962
Horas não produtivas:1137.96
O Tempo Médio Entre Falhas (MTBF) é: 2.31 horas

MTTR: Tempo médio para reparo;

nrointervencoes = mc + mp+ mpd 
print(f"Nro de intervenções:{nrointervencoes}")

MTTR = backlog_hh_os_executadas / nrointervencoes
print(f"MTTR:{MTTR}")

Resultado:

Nro de intervenções:1854
MTTR:0.007011866235167206

Disponibilidade

disponibilidade = mtbf / (MTTR + mtbf)
print(f"disponibilidade:{disponibilidade}")

disponibilidade:0.9969714394405742

Confiabilidade:

# Calculando a taxa de falhas (lambda)
taxa_falhas = 1 / mtbf

# Definindo o tempo para o qual queremos calcular a confiabilidade (em horas)
t = 100

# Calculando a confiabilidade
confiabilidade = math.exp(-taxa_falhas * t)

# Exibindo os resultados
print(f"O Tempo Médio Entre Falhas (MTBF) é: {mtbf:.2f} horas")
print(f"A Confiabilidade do sistema após {t} horas é: {confiabilidade:.4f}")

O Tempo Médio Entre Falhas (MTBF) é: 2.31 horas
A Confiabilidade do sistema após 100 horas é: 0.0000

Backlog

HHCarteira = backlog_hh_os_planejadas +backlog_hh_os_pendentes + backlog_hh_os_programadas +backlog_hh_os_executadas 
print(f"HHCarteira:{HHCarteira}")
Backlog = (HHCarteira / (hora_homem_total * fator_produtividade)) * 100
print(f"Backlog:{Backlog}")

HHCarteira:76
Backlog:1005.2910052910054

Calculando o CMF (Custo de Manutenção sobre Faturamento)

cmf = custo_total_manutencao / faturamento_bruto
print(f"cmf:{cmf}")

cmf:0.22608695652173913

Calculando o CPMV (Custo de Manutenção sobre Valor de Reposição)

cpmv = custo_total_manutencao / valor_compra_emh_novo
print(f"cpmv:{cpmv}")

cpmv:14.857142857142858

Distribuição por tipos de manutenção¶

# Calculando a distribuição por tipos de manutenção
total_manutencao = mc + mp + mpd + eng_melhorias
percentual_mc = (mc / total_manutencao) * 100
percentual_mp = (mp / total_manutencao) * 100
percentual_mpd = (mpd / total_manutencao) * 100
percentual_eng_melhorias = (eng_melhorias / total_manutencao) * 100


# Dados para o gráfico de pizza
labels = ['Manutenção Corretiva', 'Manutenção Preventiva', 'Manutenção Preditiva', 'Melhorias de Engenharia']
sizes = [percentual_mc, percentual_mp, percentual_mpd, percentual_eng_melhorias]
colors = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue']
explode = (0.1, 0, 0, 0)  # Destacar o primeiro segmento

# Plotando o gráfico de pizza
plt.figure(figsize=(8, 8))
plt.pie(sizes, explode=explode, labels=labels, colors=colors, autopct='%1.1f%%', shadow=True, startangle=140)
plt.axis('equal')  # Assegura que o gráfico de pizza seja desenhado como um círculo
plt.title('Distribuição por Tipos de Manutenção')
plt.show()

Exercício processamento de Sinais

Circuit Calculations

a) Equação de V_o

Para encontrar a equação de V_o em função das tensões de entrada V_a, V_b, V_c, V_d, aplicamos a superposição das contribuições de cada tensão de entrada no amplificador operacional. A equação geral para um somador inversor é dada por:

V_o = – ( (R_f/R_a) V_a + (R_f/R_b) V_b + (R_f/R_c) V_c + (R_f/R_d) V_d )

Dado:

• R_f = 300 kΩ
• R_s = 20 kΩ
• R_a = 40 kΩ
• R_b = 10 kΩ
• R_c = 20 kΩ
• R_d = 40 kΩ

Podemos escrever a equação de V_o como:

V_o = – ( (300 kΩ/40 kΩ) V_a + (300 kΩ/10 kΩ) V_b + (300 kΩ/20 kΩ) V_c + (300 kΩ/40 kΩ) V_d )

V_o = – ( 7.5 V_a + 30 V_b + 15 V_c + 7.5 V_d )

b) Valor de V_o para V_a = 2V, V_b = 2V, V_c = 3V, V_d = -4V

Substituindo os valores na equação encontrada:

V_o = – ( 7.5 * 2 + 30 * 2 + 15 * 3 + 7.5 * (-4) )

V_o = – ( 15 + 60 + 45 – 30 )

V_o = – ( 90 )

V_o = -90V

c) Valor de V_o para V_a = -4V, V_b = 3V, V_c = 5V, V_d = -6V

Substituindo os valores na equação encontrada:

V_o = – ( 7.5 * (-4) + 30 * 3 + 15 * 5 + 7.5 * (-6) )

V_o = – ( -30 + 90 + 75 – 45 )

V_o = – ( 90 )

V_o = -90V

d) Valor de V_o para V_a = -3V, V_b = 4V, V_c = -2V, V_d = 7V

Substituindo os valores na equação encontrada:

V_o = – ( 7.5 * (-3) + 30 * 4 + 15 * (-2) + 7.5 * 7 )

V_o = – ( -22.5 + 120 – 30 + 52.5 )

V_o = – ( 120 )

V_o = -120V

e) Limites de variação de V_b para que a saída V_o não sature, considerando V_a = -4V, V_c = 5V e V_d = -6V

Para que V_o não sature, precisamos garantir que V_o fique dentro da faixa de alimentação do amplificador operacional, que geralmente é de ±15V.

Substituindo V_a, V_c e V_d na equação e isolando V_b:

V_o = – ( 7.5 * (-4) + 30 * V_b + 15 * 5 + 7.5 * (-6) )

Simplificando:

V_o = – ( -30 + 30 V_b + 75 – 45 )

V_o = – ( 30 V_b )

Como V_o deve estar entre -15V e +15V:

-15V ≤ – ( 30 V_b ) ≤ 15V

-15V ≤ – 30 V_b ≤ 15V

– (15V/30) ≤ V_b ≤ (15V/30)

-0.5V ≤ V_b ≤ 0.5V

Então, V_b deve variar entre -0.5V e 0.5V para que a saída V_o não sature.

Exercício 2

a) Equação de V_o

Para encontrar a equação de V_o considerando R_f = 10,0 kΩ e R_s = 4,0 kΩ, usamos a fórmula do amplificador inversor:

V_o = – ( (R_f/R_s) V_s )

Dado:

• R_f = 10,0 kΩ
• R_s = 4,0 kΩ

Portanto, a equação de V_o é:

V_o = – ( 10,0 kΩ / 4,0 kΩ ) V_s

V_o = – ( 2.5 V_s )

b) Valor de V_o para V_s = 2V

Substituindo V_s = 2V na equação encontrada:

V_o = – ( 2.5 * 2 )

V_o = – 5V

c) Valor de V_o para V_s = 5V

Substituindo V_s = 5V na equação encontrada:

V_o = – ( 2.5 * 5 )

V_o = – 12.5V

d) Valor de V_o para V_s = 8V

Substituindo V_s = 8V na equação encontrada:

V_o = – ( 2.5 * 8 )

V_o = – 20V

e) Limites de variação de V_s para que a saída V_o não sature

Para que V_o não sature, precisamos garantir que V_o fique dentro da faixa de alimentação do amplificador operacional, que geralmente é de ±15V.

Usando a equação V_o = -2.5 V_s:

-15V ≤ -2.5 V_s ≤ 15V

Dividindo todos os termos por -2.5 (e invertendo a desigualdade):

6V ≥ V_s ≥ -6V

Então, V_s deve variar entre -6V e 6V para que a saída V_o não sature.

Exercício 3

a) Equação de V_o

Para encontrar a equação de V_o considerando um amplificador inversor com os resistores R_f e R_s, usamos a fórmula do amplificador inversor:

V_o = – ( (R_f/R_s) V_a )

Dado:

• R_f = 47 kΩ
• R_s = 4,7 kΩ

Portanto, a equação de V_o é:

V_o = – ( 47 kΩ / 4,7 kΩ ) V_a

V_o = – ( 10 V_a )

b) Valor de V_o para V_a = 2V

Substituindo V_a = 2V na equação encontrada:

V_o = – ( 10 * 2 )

V_o = – 20V

c) Valor de V_o para V_a = -4,5V

Substituindo V_a = -4,5V na equação encontrada:

V_o = – ( 10 * -4,5 )

V_o = 45V

d) Valor de V_o para V_a = 6V

Substituindo V_a = 6V na equação encontrada:

V_o = – ( 10 * 6 )

V_o = – 60V

e) Limites de variação de V_a para que a saída V_o não sature

Para que V_o não sature, precisamos garantir que V_o fique dentro da faixa de alimentação do amplificador operacional, que geralmente é de ±12V.

Usando a equação V_o = -10 V_a:

-12V ≤ -10 V_a ≤ 12V

Dividindo todos os termos por -10 (e invertendo a desigualdade):

1.2V ≥ V_a ≥ -1.2V

Então, V_a deve variar entre -1.2V e 1.2V para que a saída V_o não sature.

Exercício 4

a) Equação de V_o

Para encontrar a equação de V_o considerando um amplificador inversor com os resistores R_f e R_s, usamos a fórmula do amplificador inversor:

V_o = – ( (R_f/R_s) V_a )

Dado:

• R_f = 47 kΩ
• R_s = 4,7 kΩ

Portanto, a equação de V_o é:

V_o = – ( 47 kΩ / 4,7 kΩ ) V_a

V_o = – ( 10 V_a )

b) Valor de V_o para V_a = 2V

Substituindo V_a = 2V na equação encontrada:

V_o = – ( 10 * 2 )

V_o = – 20V

c) Valor de V_o para V_a = -4,5V

Substituindo V_a = -4,5V na equação encontrada:

V_o = – ( 10 * -4,5 )

V_o = 45V

d) Valor de V_o para V_a = 6V

Substituindo V_a = 6V na equação encontrada:

V_o = – ( 10 * 6 )

V_o = – 60V

e) Limites de variação de V_a para que a saída V_o não sature

Para que V_o não sature, precisamos garantir que V_o fique dentro da faixa de alimentação do amplificador operacional, que geralmente é de ±12V.

Usando a equação V_o = -10 V_a:

-12V ≤ -10 V_a ≤ 12V

Dividindo todos os termos por -10 (e invertendo a desigualdade):

1.2V ≥ V_a ≥ -1.2V

Então, V_a deve variar entre -1.2V e 1.2V para que a saída V_o não sature.

Usando algebra linear com Python e Streamlit

Neste artigo, iremos publicar um gráfico (Dashboard) que expoem um grafico de algebra linear.

A álgebra linear é um ramo da matemática que lida com vetores, matrizes e sistemas lineares de equações. É uma ferramenta fundamental em muitas áreas da ciência e engenharia devido à sua capacidade de representar e resolver problemas em múltiplas dimensões de forma eficiente.

Conceitos Básicos da Álgebra Linear

1. Vetores: Objetos que têm magnitude e direção. Em álgebra linear, são frequentemente representados como listas de números (coordenadas).
2. Matrizes: Arranjos retangulares de números que podem representar transformações lineares, sistemas de equações lineares, entre outros. Uma matriz é essencialmente uma coleção de vetores dispostos em linhas e colunas.
3. Operações Lineares: Incluem adição de vetores, multiplicação de vetores por escalares, multiplicação de matrizes, entre outras. Essas operações seguem regras específicas que mantêm a linearidade.
4. Sistemas Lineares: Conjuntos de equações lineares que podem ser resolvidos usando técnicas da álgebra linear para encontrar os valores das variáveis.

Aplicações da Álgebra Linear

1. Ciência de Dados e Aprendizado de Máquina:
   • Regressão Linear: Utilizada para encontrar a melhor linha de ajuste para um conjunto de dados.
   • Redução de Dimensionalidade: Métodos como Análise de Componentes Principais (PCA) utilizam álgebra linear para reduzir a dimensionalidade dos dados, mantendo as características mais importantes.
   • Redes Neurais: A álgebra linear é usada para calcular as operações de multiplicação de matrizes que são fundamentais no treinamento de redes neurais.
2. Engenharia:
   • Análise de Circuitos: Utilizada para resolver sistemas de equações lineares que representam circuitos elétricos.
   • Mecânica Estrutural: A álgebra linear ajuda a analisar forças e tensões em estruturas, permitindo a modelagem de comportamentos estáticos e dinâmicos.
3. Computação Gráfica:
   • Transformações Geométricas: Rotação, translação e escalonamento de objetos em gráficos 3D são realizados usando matrizes.
   • Renderização: Técnicas de renderização utilizam álgebra linear para calcular a interação da luz com superfícies.
4. Economia e Finanças:
   • Modelagem Econômica: Matrizes são usadas para representar e resolver modelos econômicos que envolvem múltiplas variáveis interdependentes.
   • Análise de Carteiras: Utilizada para otimizar a composição de carteiras de investimento minimizando o risco e maximizando o retorno.
5. Física e Química:
   • Mecânica Quântica: Operadores lineares e vetores de estado são conceitos-chave na formulação matemática da mecânica quântica.
   • Dinâmica de Sistemas: Sistemas físicos são frequentemente modelados usando equações diferenciais lineares que podem ser resolvidas com técnicas de álgebra linear.

Importância da Álgebra Linear

A álgebra linear fornece as ferramentas para modelar e resolver problemas complexos de maneira eficiente e precisa. Sua aplicação pervasiva em várias disciplinas a torna uma habilidade essencial para cientistas, engenheiros, analistas de dados e muitos outros profissionais. Compreender e aplicar conceitos de álgebra linear é fundamental para inovar e resolver problemas em um mundo cada vez mais orientado por dados e tecnologia.

import streamlit as st
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

st.title('Regressão Linear Simples')

# Função para gerar dados de exemplo
def generate_data(n_samples=100):
    np.random.seed(42)
    X = 2 * np.random.rand(n_samples, 1)
    y = 4 + 3 * X + np.random.randn(n_samples, 1)
    return X, y

# Gerar dados
X, y = generate_data()

# Exibir os dados em um gráfico
st.subheader('Dados de Treinamento')
fig, ax = plt.subplots()
ax.scatter(X, y, color='blue')
ax.set_xlabel('X')
ax.set_ylabel('y')
st.pyplot(fig)

# Treinar o modelo de regressão linear
model = LinearRegression()
model.fit(X, y)
y_pred = model.predict(X)

# Exibir a linha de regressão
st.subheader('Linha de Regressão')
fig, ax = plt.subplots()
ax.scatter(X, y, color='blue', label='Dados')
ax.plot(X, y_pred, color='red', linewidth=2, label='Linha de Regressão')
ax.set_xlabel('X')
ax.set_ylabel('y')
ax.legend()
st.pyplot(fig)

# Exibir os coeficientes
st.subheader('Coeficientes do Modelo')
st.write(f'Intercepto: {model.intercept_[0]}')
st.write(f'Coeficiente: {model.coef_[0][0]}')

Exercício mecânica

Condição de equilíbrio

Soma Fx = 0 -> Fxa – 400 Cos 60 = 0 -> Fxa = (400Cos60)N

Soma Fy = 0 -> Fya -4000 – 5000 -500sen60 = 0 -> fya = +934600N

Soma M = 0 -> Ma = 0 -> +Ma -4000*2 -5000*2-400 * sen60*3 = 0 -> Ma = 186–Nm

Resposta: Fxa =200N

Fya- +9346N

Ma = +19039

Processamento de Sinais – Exercício 3

Prof. Raphael Pinheiro

Link do trabalho:

https://github.com/raphaelPinheiro26/Processamento-de-Sinais-e-Imagens—Fatec-RP/blob/main/Processamento_Estat%C3%ADstico_e_Convolu%C3%A7%C3%A3o.ipynb

Alunos:

Marcelo Maurin Martins

Lorena Froes

Exercício 1

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
from scipy.optimize import curve_fit

# Função para criar a distribuição gaussiana aleatória
def create_gaussian_distribution(mean=0, stddev=1, num_samples=1000):
    return np.random.normal(mean, stddev, num_samples)

# Função gaussiana para ajuste
def gaussian(x, amplitude, mean, stddev):
    return amplitude * np.exp(-((x - mean) ** 2) / (2 * stddev ** 2))

# Função para calcular o FWHM
def calculate_fwhm(data):
    # Histograma dos dados
    counts, bin_edges = np.histogram(data, bins=100, density=True)
    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2

    # Ajuste da curva gaussiana
    popt, _ = curve_fit(gaussian, bin_centers, counts, p0=[1, np.mean(data), np.std(data)])
    amplitude, mean, stddev = popt

    # FWHM para uma distribuição gaussiana é 2 * sqrt(2 * ln(2)) * stddev
    fwhm = 2 * np.sqrt(2 * np.log(2)) * stddev

    # Plot para visualização (opcional)
    plt.hist(data, bins=100, density=True, alpha=0.6, color='g')
    plt.plot(bin_centers, gaussian(bin_centers, *popt), linewidth=2, color='r')
    plt.title(f'Gaussian Fit: Mean = {mean:.2f}, Stddev = {stddev:.2f}, FWHM = {fwhm:.2f}')
    plt.xlabel('Value')
    plt.ylabel('Probability Density')
    plt.show()

    return fwhm

# Exemplo de uso
data = create_gaussian_distribution(mean=0, stddev=1, num_samples=1000)
fwhm = calculate_fwhm(data)
print(f'FWHM: {fwhm}')

Exercício 2

Descreva plote os gráficos a seguir:

Uso de Parenthesis: x(t) = y(t)

import numpy as np
import matplotlib.pyplot as plt

# Definir o intervalo de tempo
t = np.linspace(0, 10, 1000)

# Definir as funções x(t) e y(t)
x_t = np.sin(2 * np.pi * t)
y_t = np.cos(2 * np.pi * t)

# Criar o gráfico
plt.figure(figsize=(10, 6))

plt.plot(t, x_t, label='$x(t) = \sin(2\pi t)$', color='b')
plt.plot(t, y_t, label='$y(t) = \cos(2\pi t)$', color='r')

plt.title('Sinal Contínuo: $x(t)$ e $y(t)$')
plt.xlabel('Tempo $t$')
plt.ylabel('Amplitude')
plt.legend()
plt.grid(True)

plt.show()

Após executar a função, temos o gráfico

Agora iremos mostrar o gráfico x[t], y[t]:

Onde o mesmo é uma apresentação de um sinal discreto, ou seja , ele apresenta de forma não contínua. Sendo taxas de amostragem ao longo do tempo.

import numpy as np
import matplotlib.pyplot as plt

# Definir o intervalo de tempo contínuo
t_continuous = np.linspace(0, 10, 1000)

# Definir o intervalo de tempo discreto
t_discrete = np.arange(0, 10, 0.1)

# Definir as funções contínuas x(t) e y(t)
x_t_continuous = np.sin(2 * np.pi * t_continuous)
y_t_continuous = np.cos(2 * np.pi * t_continuous)

# Definir as funções discretas x[t] e y[t]
x_t_discrete = np.sin(2 * np.pi * t_discrete)
y_t_discrete = np.cos(2 * np.pi * t_discrete)

# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 12))

# Gráfico do sinal contínuo
axs[0].plot(t_continuous, x_t_continuous, label='$x(t) = \sin(2\pi t)$', color='b')
axs[0].plot(t_continuous, y_t_continuous, label='$y(t) = \cos(2\pi t)$', color='r')
axs[0].set_title('Sinal Contínuo: $x(t)$ e $y(t)$')
axs[0].set_xlabel('Tempo $t$')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)

# Gráfico do sinal discreto
axs[1].stem(t_discrete, x_t_discrete, label='$x[t] = \sin(2\pi t)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[1].stem(t_discrete, y_t_discrete, label='$y[t] = \cos(2\pi t)$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[1].set_title('Sinal Discreto: $x[t]$ e $y[t]$')
axs[1].set_xlabel('Tempo $t$')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)

plt.tight_layout()
plt.show()

Ficando conforme apresentado a seguir:

expressão x[n] -> system-> y[n]

import numpy as np
import matplotlib.pyplot as plt

# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 1)

# Definir a função de entrada x[n]
x_n = np.sin(2 * np.pi * n / 10)

# Definir a constante de escala k
k = 2

# Aplicar o sistema para obter a saída y[n]
y_n = k * x_n

# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 8))

# Gráfico do sinal de entrada x[n]
axs[0].stem(n, x_n, label='$x[n] = \sin(2\pi n / 10)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[0].set_title('Sinal de Entrada: $x[n]$')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)

# Gráfico do sinal de saída y[n]
axs[1].stem(n, y_n, label='$y[n] = 2 \cdot x[n]$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[1].set_title('Sinal de Saída: $y[n]$')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)

plt.tight_layout()
plt.show()

Homogenidade, x[n] -> system-> y[n]; No exemplo expresso pela função: y[n]=k⋅x[n]

import numpy as np
import matplotlib.pyplot as plt

# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 1)

# Definir a função de entrada x[n]
x_n = np.sin(2 * np.pi * n / 10)

# Definir a constante de escala k
k = 2

# Aplicar o sistema para obter a saída y[n]
y_n = k * x_n

# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 8))

# Gráfico do sinal de entrada x[n]
axs[0].stem(n, x_n, label='$x[n] = \sin(2\pi n / 10)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[0].set_title('Sinal de Entrada: $x[n]$')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)

# Gráfico do sinal de saída y[n]
axs[1].stem(n, y_n, label='$y[n] = 2 \cdot x[n]$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[1].set_title('Sinal de Saída: $y[n]$')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)

plt.tight_layout()
plt.show()

agora de aditivo, tal como x1[n]+x2[n] -> system -> y1[n] + y2[n], tal como um exemplo, podemos apresentar o exemplo de um ruído.

import numpy as np
import matplotlib.pyplot as plt

# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 1)

# Definir as funções de entrada x1[n] e x2[n]
x1_n = np.sin(2 * np.pi * n / 10)
x2_n = np.cos(2 * np.pi * n / 10)

# Definir a constante de escala k
k = 2

# Aplicar o sistema para obter as saídas y1[n] e y2[n]
y1_n = k * x1_n
y2_n = k * x2_n

# Aplicar o sistema para a soma das entradas
x_sum_n = x1_n + x2_n
y_sum_n = k * x_sum_n

# Calcular a soma das saídas individuais
y_sum_individual_n = y1_n + y2_n

# Criar os gráficos
fig, axs = plt.subplots(3, 1, figsize=(10, 12))

# Gráfico dos sinais de entrada x1[n] e x2[n]
axs[0].stem(n, x1_n, label='$x_1[n] = \sin(2\pi n / 10)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[0].stem(n, x2_n, label='$x_2[n] = \cos(2\pi n / 10)$', linefmt='g-', markerfmt='go', basefmt='r-')
axs[0].set_title('Sinais de Entrada: $x_1[n]$ e $x_2[n]$')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)

# Gráfico dos sinais de saída y1[n] e y2[n]
axs[1].stem(n, y1_n, label='$y_1[n] = 2 \cdot x_1[n]$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[1].stem(n, y2_n, label='$y_2[n] = 2 \cdot x_2[n]$', linefmt='g-', markerfmt='go', basefmt='r-')
axs[1].set_title('Sinais de Saída: $y_1[n]$ e $y_2[n]$')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)

# Gráfico da soma das saídas comparado à saída da soma das entradas
axs[2].stem(n, y_sum_n, label='$y[n] = 2 \cdot (x_1[n] + x_2[n])$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[2].stem(n, y_sum_individual_n, label='$y_1[n] + y_2[n]$', linefmt='m-', markerfmt='mo', basefmt='r-')
axs[2].set_title('Comparação: $y[n]$ e $y_1[n] + y_2[n]$')
axs[2].set_xlabel('n')
axs[2].set_ylabel('Amplitude')
axs[2].legend()
axs[2].grid(True)

plt.tight_layout()
plt.show()

Agora usaremos o exemplo de shift, apresentando uma onda quadrada, com deslocamento.

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 0.1)

# Definir a função de entrada x[n] como uma onda quadrada
x_n = signal.square(2 * np.pi * n / 10)

# Definir o deslocamento s
s = 3

# Aplicar o deslocamento à entrada
x_shifted = signal.square(2 * np.pi * (n - s) / 10)

# Definir a constante de escala k (sistema)
k = 2

# Aplicar o sistema ao sinal deslocado
y_shifted = k * x_shifted

# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 8))

# Gráfico do sinal de entrada x[n] e do sinal deslocado x[n+s]
axs[0].plot(n, x_n, label='$x[n] = \mathrm{square}(2\pi n / 10)$', color='b')
axs[0].plot(n, x_shifted, label='$x[n+s] = \mathrm{square}(2\pi (n-s) / 10)$', color='g')
axs[0].set_title('Sinal de Entrada e Sinal Deslocado (Onda Quadrada)')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)

# Gráfico do sinal de saída deslocado y[n+s]
axs[1].plot(n, y_shifted, label='$y[n+s] = 2 \cdot \mathrm{square}(2\pi (n-s) / 10)$', color='r')
axs[1].set_title('Sinal de Saída Deslocado: $y[n+s]$ (Onda Quadrada)')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)

plt.tight_layout()
plt.show()

Ficando no exemplo, claramente o deslocamento.

Exercício 3

import numpy as np
import matplotlib.pyplot as plt

# Função para gerar sinais exponenciais e^(an)
def exponential(a, n):
    expo = []
    for sample in n:
        expo.append(np.exp(a * sample))
    return expo

# Definir parâmetros
a = 2
UL = 1
LL = -1
n = np.arange(LL, UL, 0.1)
x = exponential(a, n)

# Aumentar o ganho em 10x
x_gain = [10 * value for value in x]

# Somar por 5
x_add = [value + 5 for value in x]

# Subtrair por pi
x_subtract = [value - np.pi for value in x]

# Fazer um shift de 3 posições
shift = 3
n_shifted = n + shift
x_shift = exponential(a, n - shift)

# Plotar os gráficos
fig, axs = plt.subplots(4, 1, figsize=(10, 20))

# Sinal original
axs[0].stem(n, x, basefmt=" ", use_line_collection=True)
axs[0].set_xlabel('n')
axs[0].set_ylabel('x[n]')
axs[0].set_title('Exponential Signal $e^{an}$')

# Aumento de ganho em 10x
axs[1].stem(n, x_gain, basefmt=" ", use_line_collection=True)
axs[1].set_xlabel('n')
axs[1].set_ylabel('10x[n]')
axs[1].set_title('Exponential Signal $10 \cdot e^{an}$')

# Soma por 5
axs[2].stem(n, x_add, basefmt=" ", use_line_collection=True)
axs[2].set_xlabel('n')
axs[2].set_ylabel('x[n] + 5')
axs[2].set_title('Exponential Signal $e^{an} + 5$')

# Subtração por pi
axs[3].stem(n, x_subtract, basefmt=" ", use_line_collection=True)
axs[3].set_xlabel('n')
axs[3].set_ylabel('x[n] - π')
axs[3].set_title('Exponential Signal $e^{an} - π$')

# Shift de 3 posições
fig, ax = plt.subplots(figsize=(10, 5))
ax.stem(n_shifted, x_shift, basefmt=" ", use_line_collection=True)
ax.set_xlabel('n')
ax.set_ylabel('x[n-3]')
ax.set_title('Exponential Signal Shifted by 3 Positions $e^{a(n-3)}$')

plt.tight_layout()
plt.show()

Processamento de Sinais – Trabalho matrizes e vetores

Alunos:

Marcelo Maurin Martins

Lorena Froes

Link do material da aula e exercícios

https://colab.research.google.com/github/raphaelPinheiro26/Processamento-de-Sinais-e-Imagens—Fatec-RP/blob/main/Aulas/Aula-02_Vetores_e_Matrizes.ipynb#scrollTo=yjjb0pJKhQDh

Trabalho sobre Soma de Matrizes

1.1 Exercício

# Lista de notas dos alunos
notas = [85, 90, 78, 92, 88]

# Calcula a soma de todas as notas
soma_notas = sum(notas)

# Calcula a quantidade de notas
quantidade_notas = len(notas)

# Calcula a média
media = soma_notas / quantidade_notas

print(f"A média das notas dos alunos é: {media:.2f}")

1.2 Exercício

def calcular_media(notas):
    # Calcula a soma de todas as notas
    soma_notas = sum(notas)
    
    # Calcula a quantidade de notas
    quantidade_notas = len(notas)
    
    # Calcula a média
    media = soma_notas / quantidade_notas
    
    print(f"A média das notas dos alunos é: {media:.2f}")

# Exemplo de uso da função
notas_alunos = [85, 90, 78, 92, 88]
calcular_media(notas_alunos)

Exercício 2.1

def criar_matriz(largura, altura, v):
    # Cria uma matriz de dimensão largura x altura preenchida com o valor v
    matriz = [[v for _ in range(largura)] for _ in range(altura)]
    return matriz

def imprimir_matriz(matriz):
    # Imprime a matriz linha por linha
    for linha in matriz:
        print(' '.join(map(str, linha)))

def main():
    # Solicita ao usuário as dimensões da matriz e o valor de preenchimento
    largura = int(input("Informe a largura da matriz: "))
    altura = int(input("Informe a altura da matriz: "))
    v = input("Informe o valor de preenchimento: ")
    
    # Cria a matriz
    matriz = criar_matriz(largura, altura, v)
    
    # Imprime a matriz
    imprimir_matriz(matriz)

if __name__ == "__main__":
    main()

Exercício 2.2

def criar_matriz(largura, altura, v):
    # Cria uma matriz de dimensão largura x altura preenchida com o valor v
    matriz = [[v for _ in range(largura)] for _ in range(altura)]
    return matriz

def imprimir_matriz(matriz):
    # Imprime a matriz linha por linha
    for linha in matriz:
        print(' '.join(map(str, linha)))

def main():
    # Solicita ao usuário as dimensões da matriz e o valor de preenchimento
    largura = int(input("Informe a largura da matriz: "))
    altura = int(input("Informe a altura da matriz: "))
    v = input("Informe o valor de preenchimento: ")
    
    # Cria a matriz
    matriz = criar_matriz(largura, altura, v)
    
    # Imprime a matriz
    imprimir_matriz(matriz)

if __name__ == "__main__":
    main()

Isostática

Exemplo: Calcular reações de apoio.

Resolução

Condição de equilibrio

Soma fx = 0

Soma fy= 0

Soma m=0

Soma Ma = 0 => -400*2 -500 sen 60 * 4 +By * 4 = 0

By = 400*2 + 500 sen 60 * 4

By = 6330N

Soma fy = 0

Ay + By -400 -500 sen 60 = 0

Soma Fx = 0

-Bx = -250N

2 – Exercício

Soma Ma = 0 => -400 *1 -1000*2-400 sen60 * 4 + By * 4 = 0

By = 946,4N

Soma Fy = 0

+Ay – 400 -1000 -400sen60+By = 0

Ay = +800N

Soma Fx = 0

Ax + 400 cos 60 = 0

Ax = -400 cos 60

Ax = -200N

Trabalho processamento de sinais

Conforme materia

https://github.com/raphaelPinheiro26/Processamento-de-Sinais-e-Imagens—Fatec-RP/blob/main/Trabalhos/Trabalho_01_Introdu%C3%A7%C3%A3o_ao_Python.ipynb

Exemplo de trabalho

Aluno: Marcelo Maurin Martins

Grupo: Sem grupo

1 – Senha Pronto Atendimento Escreva um programa que destribua senhas aos pacientes que chegam no Atendimento de Emergência de um Hospital. Deverá seguir os seguintes critérios

O hospital possui 3 filas (ortopedia, Atendimento Comum e Atendimento Prioritário) A senha será composta por 3 letras indicando a fila e 3 algarismos indicando a posição do paciente na fila (AAA-000) A senha de atendimento preferêncial irá iniciar com as letras ATP A senha de atendimento comum irá iniciar com as letras ATC A senha de atendimento para ortopedia irá iniciar com as letras ORT Antes de finalizar o programa, o mesmo deverá imprimir a lista de senhas geradas em cada fila

In [1]:

# Função para gerar senhas
def gerar_senha(fila, tipo, contador):
    if tipo == "prioritaria":
        prefixo = "ATP"
    elif tipo == "comum":
        prefixo = "ATC"
    elif tipo == "ortopedia":
        prefixo = "ORT"
    else:
        raise ValueError("Tipo de fila inválido")

    senha = f"{prefixo}-{contador:03d}"
    fila.append(senha)

# Filas
ortopedia = []
atendimento_comum = []
atendimento_prioritario = []

# Função para imprimir senhas em uma fila
def imprimir_senhas(fila, nome):
    print(f"Senhas na fila {nome}:")
    for senha in fila:
        print(senha)

# Simulação de um estudante aprendendo Python
print("Bem-vindo ao sistema de distribuição de senhas do hospital!")
print("Escolha o tipo de atendimento:")
print("1 - Ortopedia")
print("2 - Atendimento Comum")
print("3 - Atendimento Prioritário")

opcao = input("Digite o número correspondente ao tipo de atendimento desejado: ")

if opcao == "1":
    gerar_senha(ortopedia, "ortopedia", len(ortopedia))
    imprimir_senhas(ortopedia, "Ortopedia")
elif opcao == "2":
    gerar_senha(atendimento_comum, "comum", len(atendimento_comum))
    imprimir_senhas(atendimento_comum, "Atendimento Comum")
elif opcao == "3":
    gerar_senha(atendimento_prioritario, "prioritaria", len(atendimento_prioritario))
    imprimir_senhas(atendimento_prioritario, "Atendimento Prioritário")
else:
    print("Opção inválida! Por favor, escolha uma opção válida.")

Bem-vindo ao sistema de distribuição de senhas do hospital!
Escolha o tipo de atendimento:
1 - Ortopedia
2 - Atendimento Comum
3 - Atendimento Prioritário
Digite o número correspondente ao tipo de atendimento desejado: 1
Senhas na fila Ortopedia:
ORT-000

Nota complementar

Fiz um outro programa em uma terceira linguagem aderente ao exercicio.

Projeto Fila

2 – Horário de Medicamentos Faça um programa que a equipe de enfermagem entre com as informações do paciente para lembra-los do horário da medicação com as seguintes recomendações:

Dados do Paciente – Nome Completo, Data de Nascimento e Tipo do sangue Dados da Medicação – Nome da Medicação, Classificação, e horário para aplicação A Classificação do Medicamento será – medicamento comum, Psicotrópico, Alto risco, Alto custo e Psicotrópicos Ao chegar nos horários do medicamento, um aviso deverá aparecer na tela o horário pode ser simulado mas se for usado a hora do computador ganhará mais pontos Pelo menos 2 horários distintos para alarmar

In [ ]:

import datetime
import time

# Função para calcular a idade a partir da data de nascimento
def calcular_idade(data_nascimento):
    hoje = datetime.date.today()
    ano_nascimento = data_nascimento.year
    idade = hoje.year - ano_nascimento
    if hoje.month < data_nascimento.month or (hoje.month == data_nascimento.month and hoje.day < data_nascimento.day):
        idade -= 1
    return idade

# Função para formatar a data de nascimento
def formatar_data(data):
    return data.strftime("%d/%m/%Y")

# Função para verificar se é hora da medicação
def verificar_horario_med(med_horario, hora_atual):
    for horario in med_horario:
        if hora_atual.hour == horario.hour and hora_atual.minute == horario.minute:
            return True
    return False

# Dados do paciente
nome = input("Digite o nome completo do paciente: ")
data_nascimento = datetime.datetime.strptime(input("Digite a data de nascimento do paciente (formato: dd/mm/aaaa): "), "%d/%m/%Y")
tipo_sangue = input("Digite o tipo sanguíneo do paciente: ")

# Dados da medicação
nome_med = input("Digite o nome da medicação: ")
classificacao_med = input("Digite a classificação da medicação (comum, psicotrópico, alto risco, alto custo, psicotrópicos): ").lower()
horarios = []
for i in range(2):
    hora = datetime.datetime.strptime(input(f"Digite o horário {i+1} para aplicação da medicação (formato: hh:mm): "), "%H:%M")
    horarios.append(hora.time())

# Imprimir informações do paciente e da medicação
print("\n--- Informações do Paciente ---")
print("Nome:", nome)
print("Data de Nascimento:", formatar_data(data_nascimento))
print("Idade:", calcular_idade(data_nascimento), "anos")
print("Tipo Sanguíneo:", tipo_sangue)

print("\n--- Informações da Medicação ---")
print("Nome da Medicação:", nome_med)
print("Classificação da Medicação:", classificacao_med.capitalize())
print("Horários de Aplicação:", ", ".join(map(lambda x: x.strftime("%H:%M"), horarios)))

# Variável para controlar se a mensagem já foi exibida
mensagem_exibida = False

# Simulação do tempo para verificar o horário da medicação
print("\nSimulando o tempo para verificar o horário da medicação...")

while True:
    hora_atual = datetime.datetime.now().time()
    if verificar_horario_med(horarios, hora_atual) and not mensagem_exibida:
        print("Hora da medicação! Não se esqueça de tomar o medicamento:", nome_med)
        mensagem_exibida = True
    elif not verificar_horario_med(horarios, hora_atual):
        mensagem_exibida = False
    # Aguardar 1 minuto antes de verificar novamente
    time.sleep(60)

Digite o nome completo do paciente: marcelo
Digite a data de nascimento do paciente (formato: dd/mm/aaaa): 20/12/1999
Digite o tipo sanguíneo do paciente: a
Digite o nome da medicação: paracetamol
Digite a classificação da medicação (comum, psicotrópico, alto risco, alto custo, psicotrópicos): 12:56
Digite o horário 1 para aplicação da medicação (formato: hh:mm): 12:57
Digite o horário 2 para aplicação da medicação (formato: hh:mm): 12:58

--- Informações do Paciente ---
Nome: marcelo
Data de Nascimento: 20/12/1999
Idade: 24 anos
Tipo Sanguíneo: a

--- Informações da Medicação ---
Nome da Medicação: paracetamol
Classificação da Medicação: 12:56
Horários de Aplicação: 12:57, 12:58

Simulando o tempo para verificar o horário da medicação...
Hora da medicação! Não se esqueça de tomar o medicamento: paracetamol

3 – Inventário de Equipamentos Biomédicos Faça um programa que tenha dois modos acessados por um menu. O primeiro módulo é de cadastro de equipamentos médicos e o segundo é de consulta dos equipamentos cadastrados. Siga as instruções:

O software deverá ter um menu principal onde o usuáriopoderá acessar as duas opções Na parte de cadastramento o usuário deverá entrar com os dados nos campos: Nome do Equipamento, TAG de identificação, e local de uso. A tag é um jeito mais fácil de identificar os equipamentos. exemplo:3° monitor multiparemetro da UTI -> UTI-MNP-0003 Porém vc pode criar a sua forma No modo de consulta deverá ter 3 formas de consulta (TAG, Tipo de equipamento e Local de uso) Ao consultar um item por uma das formas, as outras informações referente a este item taambém deverá aparecer

In [ ]:

# Função para cadastrar um novo equipamento
def cadastrar_equipamento(inventario):
    print("\n--- Cadastro de Equipamento ---")
    nome = input("Digite o nome do equipamento: ")
    local = input("Digite o local de uso do equipamento: ")
    tag = input("Digite a TAG de identificação do equipamento: ")
    inventario.append({"Nome": nome, "Local": local, "TAG": tag})
    print("Equipamento cadastrado com sucesso!")

# Função para consultar equipamentos por TAG
def consultar_por_tag(inventario):
    tag_consulta = input("Digite a TAG do equipamento que deseja consultar: ")
    encontrado = False
    for equipamento in inventario:
        if equipamento["TAG"] == tag_consulta:
            print("\n--- Informações do Equipamento ---")
            print("Nome:", equipamento["Nome"])
            print("Local de Uso:", equipamento["Local"])
            print("TAG:", equipamento["TAG"])
            encontrado = True
            break
    if not encontrado:
        print("Equipamento não encontrado!")

# Função para consultar equipamentos por Tipo
def consultar_por_tipo(inventario):
    tipo_consulta = input("Digite o tipo de equipamento que deseja consultar: ")
    encontrado = False
    for equipamento in inventario:
        if tipo_consulta in equipamento["TAG"]:
            print("\n--- Informações do Equipamento ---")
            print("Nome:", equipamento["Nome"])
            print("Local de Uso:", equipamento["Local"])
            print("TAG:", equipamento["TAG"])
            encontrado = True
    if not encontrado:
        print("Nenhum equipamento desse tipo encontrado!")

# Função para consultar equipamentos por Local
def consultar_por_local(inventario):
    local_consulta = input("Digite o local de uso que deseja consultar: ")
    encontrado = False
    for equipamento in inventario:
        if equipamento["Local"].lower() == local_consulta.lower():
            print("\n--- Informações do Equipamento ---")
            print("Nome:", equipamento["Nome"])
            print("Local de Uso:", equipamento["Local"])
            print("TAG:", equipamento["TAG"])
            encontrado = True
    if not encontrado:
        print("Nenhum equipamento encontrado nesse local!")

# Função para exibir o menu principal
def exibir_menu():
    print("\n--- Menu Principal ---")
    print("1. Cadastrar Equipamento")
    print("2. Consultar Equipamentos")
    print("3. Sair")

# Lista para armazenar os equipamentos cadastrados
inventario = []

# Loop principal do programa
while True:
    exibir_menu()
    opcao = input("Escolha uma opção: ")

    if opcao == "1":
        cadastrar_equipamento(inventario)
    elif opcao == "2":
        print("\n--- Opções de Consulta ---")
        print("1. Por TAG")
        print("2. Por Tipo de Equipamento")
        print("3. Por Local de Uso")
        consulta_opcao = input("Escolha uma opção de consulta: ")
        if consulta_opcao == "1":
            consultar_por_tag(inventario)
        elif consulta_opcao == "2":
            consultar_por_tipo(inventario)
        elif consulta_opcao == "3":
            consultar_por_local(inventario)
        else:
            print("Opção de consulta inválida!")
    elif opcao == "3":
        print("Saindo do programa...")
        break
    else:
        print("Opção inválida! Por favor, escolha uma opção válida.")

In [ ]: