Para criar um controller no laravel, utilize a seguinte sintaxe:
php artisan make:controller <nomecontroller>
Os controller serão criados na pasta:
.\app\Http\Controllers
Conforme o exemplo abaixo:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class welcomeController extends Controller
{
//Metodo de visualização
public function welcome(){
return view('welcome');
}
}
É necessário criar o mesmo na rota (web.php):
<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\WelcomeController;
Route::get('/', function () {
$controller = new welcomeController();
return $controller->welcome();
});
import numpy as np
import matplotlib.pyplot as plt
import os
import cv2
import numpy as np
from scipy.io import loadmat
from IPython.display import HTML
from base64 import b64encode
from matplotlib import pyplot as plt
import ipywidgets as widgets
from IPython.display import display
Exercício 1
# Carregar a imagem
image_path = 'xc.tif' # Substitua pelo caminho da sua imagem
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
# Verificar se a imagem foi carregada corretamente
if image is None:
raise ValueError("A imagem não pôde ser carregada. Verifique o caminho fornecido.")
# Calcular o histograma
histogram = cv2.calcHist([image], [0], None, [256], [0, 256])
# Plotar o histograma
plt.figure()
plt.title("Histograma")
plt.xlabel("Intensidade")
plt.ylabel("Número de Pixels")
plt.plot(histogram)
plt.xlim([0, 256])
plt.show()
# Sliders para ajustar os valores de c e b
c_slider = widgets.FloatSlider(value=1.0, min=0.1, max=3.0, step=0.1, description='c')
b_slider = widgets.IntSlider(value=0, min=-100, max=100, step=1, description='b')
# Interagir com os sliders
widgets.interact(update_image, c=c_slider, b=b_slider)
Transformação de intensidades (Nota: 3.0/10.0)
# Carregar a imagem
image_path = 'xc.tif' # Substitua pelo caminho da sua imagem
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
# Verificar se a imagem foi carregada corretamente
if image is None:
raise ValueError("A imagem não pôde ser carregada. Verifique o caminho fornecido.")
# Calcular o histograma
histogram = cv2.calcHist([image], [0], None, [256], [0, 256])
# Plotar o histograma
plt.figure()
plt.title("Histograma")
plt.xlabel("Intensidade")
plt.ylabel("Número de Pixels")
plt.plot(histogram)
plt.xlim([0, 256])
plt.show()
# Função para ajustar os valores de c e b e aplicar na imagem
def adjust_image(c, b):
adjusted_image = cv2.convertScaleAbs(image, alpha=c, beta=b)
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.title("Imagem Ajustada")
plt.imshow(adjusted_image, cmap='gray')
plt.axis('off')
# Calcular o histograma da imagem ajustada
adjusted_histogram = cv2.calcHist([adjusted_image], [0], None, [256], [0, 256])
plt.subplot(1, 2, 2)
plt.title("Histograma Ajustado")
plt.xlabel("Intensidade")
plt.ylabel("Número de Pixels")
plt.plot(adjusted_histogram)
plt.xlim([0, 256])
plt.show()
# Sliders para ajustar os valores de c e b
c_slider = widgets.FloatSlider(value=1.0, min=0.1, max=3.0, step=0.1, description='c')
b_slider = widgets.IntSlider(value=0, min=-100, max=100, step=1, description='b')
# Interagir com os sliders
widgets.interact(adjust_image, c=c_slider, b=b_slider)
Exercicio 2.1
import numpy as np
import matplotlib.pyplot as plt
import cv2
import ipywidgets as widgets
from IPython.display import display
# Carregar a imagem
image_path = 'tomo.tif' # Substitua pelo caminho da sua imagem
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
# Verificar se a imagem foi carregada corretamente
if image is None:
raise ValueError("A imagem não pôde ser carregada. Verifique o caminho fornecido.")
# Função para ajustar os valores de c e b e aplicar na imagem
def adjust_image(c, b):
adjusted_image = cv2.convertScaleAbs(image, alpha=c, beta=b)
plt.figure(figsize=(12, 6))
plt.subplot(1, 3, 1)
plt.title("Imagem Ajustada")
plt.imshow(adjusted_image, cmap='gray')
plt.axis('off')
# Calcular o histograma da imagem ajustada
adjusted_histogram = cv2.calcHist([adjusted_image], [0], None, [256], [0, 256])
plt.subplot(1, 3, 2)
plt.title("Histograma Ajustado")
plt.xlabel("Intensidade")
plt.ylabel("Número de Pixels")
plt.plot(adjusted_histogram)
plt.xlim([0, 256])
# Aplicar efeito negativo
negative_image = 255 - adjusted_image
negative_histogram = cv2.calcHist([negative_image], [0], None, [256], [0, 256])
plt.subplot(1, 3, 3)
plt.title("Imagem Negativa")
plt.imshow(negative_image, cmap='gray')
plt.axis('off')
plt.figure(figsize=(6, 4))
plt.title("Histograma da Imagem Negativa")
plt.xlabel("Intensidade")
plt.ylabel("Número de Pixels")
plt.plot(negative_histogram)
plt.xlim([0, 256])
plt.show()
# Sliders para ajustar os valores de c e b
c_slider = widgets.FloatSlider(value=1.0, min=0.1, max=3.0, step=0.1, description='c')
b_slider = widgets.IntSlider(value=0, min=-100, max=100, step=1, description='b')
# Interagir com os sliders
widgets.interact(adjust_image, c=c_slider, b=b_slider)
Exercicio 3 – Restauração da Imagem
# Função para ajustar brilho e contraste
def ajustar_brilho_contraste(imagem, alpha, beta):
nova_imagem = cv2.convertScaleAbs(imagem, alpha=alpha, beta=beta)
return nova_imagem
# Carregar a imagem
imagem = cv2.imread('xc.tif', cv2.IMREAD_GRAYSCALE)
# Ajuste de brilho e contraste
alpha = 0.002 # Contraste
beta = 0.002 # Brilho
imagem_ajustada = ajustar_brilho_contraste(imagem, alpha, beta)
# Plotar as imagens e os histogramas
fig, axs = plt.subplots(2, 2, figsize=(12, 8))
# Imagem original
axs[0, 0].imshow(imagem, cmap='gray')
axs[0, 0].set_title('Imagem Original')
axs[0, 0].axis('off')
# Histograma da imagem original
axs[0, 1].hist(imagem.ravel(), bins=256, range=(0, 256), color='gray')
axs[0, 1].set_title('Histograma Original')
# Imagem ajustada
axs[1, 0].imshow(imagem_ajustada, cmap='gray')
axs[1, 0].set_title('Imagem Ajustada')
axs[1, 0].axis('off')
# Histograma da imagem ajustada
axs[1, 1].hist(imagem_ajustada.ravel(), bins=256, range=(0, 256), color='gray')
axs[1, 1].set_title('Histograma Ajustado')
plt.tight_layout()
plt.show()
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:
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.
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.
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:
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.
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.
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.
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.
# 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
# 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
Para encontrar a equação de Vo em função das tensões de entrada Va, Vb, Vc, Vd, 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:
Vo = – ( (Rf/Ra) Va + (Rf/Rb) Vb + (Rf/Rc) Vc + (Rf/Rd) Vd )
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
Vetores: Objetos que têm magnitude e direção. Em álgebra linear, são frequentemente representados como listas de números (coordenadas).
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.
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.
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
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.
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.
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.
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.
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]}')
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()
# 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()
Como encontrar a posição final de um braço robótico com 3 servos
Um braço robótico é uma estrutura mecânica articulada que pode ser controlada por meio de servos. Cada servo é responsável por controlar o movimento em um eixo específico, como o eixo X, Y ou Z. Para encontrar a posição final do braço robótico nos eixos X e Y, é necessário utilizar uma fórmula que leve em consideração os ângulos de rotação de cada servo.
Fórmula para encontrar a posição final
A fórmula para encontrar a posição final de um braço robótico com 3 servos nos eixos X e Y é baseada na trigonometria. Vamos supor que os ângulos de rotação dos servos sejam representados por θ1, θ2 e θ3, respectivamente.
Portanto, a posição final do braço robótico nos eixos X e Y é aproximadamente (32,07 cm, 31,75 cm).
Considerações finais
A fórmula apresentada permite encontrar a posição final de um braço robótico nos eixos X e Y com base nos ângulos de rotação dos servos e nos comprimentos dos segmentos do braço. É importante lembrar que essa fórmula assume que o braço robótico opera em um plano bidimensional e que não há interferências ou restrições adicionais.
Além disso, é fundamental ter em mente que a precisão da posição final depende da precisão dos ângulos de rotação dos servos e dos comprimentos dos segmentos do braço. Qualquer imprecisão ou erro na medição ou no controle dos servos pode afetar a posição final do braço robótico.
Em resumo, a fórmula apresentada é uma ferramenta útil para calcular a posição final de um braço robótico nos eixos X e Y, mas é necessário ter cuidado ao utilizar e interpretar os resultados.
English 
Portuguese