Menggeser Phase Gelombang Dengan Python

Dalam sebuah simulasi gelombang, kita perlu membuat sebuah gelombang lain yang memiliki pergeseran phase dengan nilai tertentu.

Pada tulisan ini akan disampaikan salah satu metode untuk membuat sebuah gelombang yang bergeser dengan mempermudah nilai variabel yang dapat diganti.

Pada tulisan ini, bahasa pemrograman yang digunakan adalah Python. Salaha satu platform yang dapat digunakan adalah menggunakan googlecolabs.

Untuk membuat sebuah gelombang kita dapat menuliskan perintah berikut:

import numpy as np

import matplotlib.pyplot as plt

#--- nilai Amplitudo gelombang

Avt = 2



#--- membuat set nilai sampling data gelombang

t = np.linspace(0, 1, 1000)

Kemudian kita buat gelombang pertama dan ditampilkan:

Kita buat gelombang kedua dan ditampilkan

Terakhir kita plot kedua gelombang secara bersama seperti berikut:

Sekarang, cobalah untuk membuat dua gelombang dengan pergeseran phase -90 derajat dan 180 derajat.
Selamat mencoba

Source code google colabs: Link [https://colab.research.google.com/drive/1_6YD8TjmsgrX0oQ9sR-exlbaKrfYrPGD?usp=sharing]

Catatan Kuliah Fisika Matematika dan Gelombang

Pokok-pokok Substansi Kajian:

1. Besaran dan pengukuran
2. Vektor
3. Gerakan satu dimensi
4. Gerakan dalam satu dan dua dimensi
5. Hukum Newton
6. Kerja dan energi
7. Sistem partikel dan kelestarian momentum
8. Rotasi
9. Osilasi
10. Gelombang transversal
11. Bunyi

Bahan Kuliah:

1. Besaran dan pengukuran [PPT] [TUGAS] [contoh]
2. Vektor [PPT] [contoh] [Quiz] [Tugas]
3. Gerakan satu dimensi [PPT]
4. Gerakan dalam satu [PPT] dan dua dimensi [PPT][TUGAS]
5. Hukum Newton [PPT] [TUGAS]
6. Kerja dan energi
7. Sistem partikel dan kelestarian momentum
8. Rotasi [PPT]
9. Osilasi [PPT]
10. Gelombang transversal [sifat gelombang][superposisi dan interfensi]
11. Bunyi

Referensi:

Fisika Dasar 1: download

Vektor: download

Gelombang Transversal dan longitudinal [download]

Gelombang [download]

Bilangan Kompleks dan Fasor [Materi 1][Materi 2]

Membuat GUI dengan TKinter Python

Untuk membuat window yang menyesuaikan ukuran layar dapat menggunakan perintah root.geometry:

from Tkinker import *

root = Tk()

width, height = root.winfo_screenwidth(), root.winfo_screenheight()

root.geometry('%dx%d+0+0' % (width,height))

root.mainloop()

Machine Learning is one of the most sought-after professions paying $100,000+ on average.

Learn & practice ML for free with these outstanding resources and earn certificates for your resume:

[4] Machine Learning with Python by freeCodeCamp

In the Machine Learning with Python Certification, you’ll use the TensorFlow framework to build several neural networks.

🔗 https://t.co/G98ECU5wf2

[3]Machine Learning Crash Course by Google

Google’s fast-paced, practical introduction to machine learning features a series of lessons with video lectures, real-world case studies, and hands-on practice exercises.

🔗 https://t.co/R7ptEFlFAb

[2] Kaggle

Learn about Data Science & Machine Learning in fast-paced courses and earn certificates!

🔗 https://lnkd.in/d2Rh4HPA

[1] Introduction to Data Science by IBM

Learn about the world of data science first-hand from real-world data scientists.

🔗 https://lnkd.in/d-mDQRvj

Like this post?

Please let me know what you thought in the comments below, follow me and share it with your connection. They may find it useful too.

#machinelearning#datascience#ml#kaggle#datascientists#google#like#share#ai#ds#linkedinlearning#linkedinposts

repost: https://www.linkedin.com/in/iamarifalam/

Python: Pergeseran Fasa Gelombang (Phase Shift of Signal)

Pergeseran fasa atau perbedaan fasa adalah perbedaan yang di miliki oleh dua gelombang. Untuk mensimulasikan pergeseran fasa antara dua sinyal dapat dibuat dengan menggunakan code python seperti berikut:

import os
import numpy as np
import matplotlib.pyplot as plt
import math

#Frequency Sampling
Fs = 100000

#time duration
duration = 2

#Amplitudo
amplitude = 1

#Phase shifting
phase = 0

#Frequency of wave
frequency = 3121

num_samples = int(Fs * duration)
print('num_samples: {:d}'.format(num_samples))
t = np.arange(num_samples) / Fs

#Phase shifting
phase = 0.25

signal1 = amplitude * np.cos(2 * np.pi * (frequency * t))
signal2 = amplitude * np.cos(2 * np.pi * (frequency * t - phase))

plt.figure(figsize=(10, 2))
plt.plot(t, signal1, color='blue', linewidth=2.0, linestyle='-', label = "sin (wt)")
plt.plot(t, signal2, color='red', linewidth=2.0, linestyle='-', label = "sin (wt+" + str(phase*360) + ")")
plt.xlim([0, duration])
plt.title('Phase shifting')
plt.xlabel('Time (seconds)')
plt.ylabel('Amplitude')
plt.xlim([0 ,0.002])

# Add a legend
plt.legend(loc='center right', bbox_to_anchor=(1.25, 0.5))

plt.tight_layout()

Python: Superposisi Gelombang (Wave Superposition)

Superposisi gelombang dapat disebut juga interferensi gelombang. Interferensi adalah interaksi antar gelombang di dalam suatu daerah. Interferensi dapat bersifat membangun dan merusak. Bersifat membangun jika beda fase kedua gelombang sama dengan nol, sehingga gelombang baru yang terbentuk adalah penjumlahan dari kedua gelombang tersebut. Bersifat merusak jika beda fasenya adalah 180 derajat, sehingga kedua gelombang saling menghilangkan. Interferensi yang bersifat membangun disebut interferensi konstruktif sedangkan yang bersifat merusak disebut interferensi destruktif.

#Superposisi

import os
import numpy as np
import matplotlib.pyplot as plt 
#matplotlib inline

#Frequency Sampling
Fs = 100000

#time duration
duration = 2

#Amplitudo
amplitude1 = 1
amplitude2 = 2

#Phase shifting
phase =0

#Frequency of wave
frequency = 3121

num_samples = int(Fs * duration)
print('num_samples: {:d}'.format(num_samples))
t = np.arange(num_samples) / Fs
#print(t)
 # A SIN (2.pi.f(theta))
x1 = amplitude1 * np.sin(2 * np.pi * frequency *( t))    
x2 = amplitude2 * np.sin(2 * np.pi * frequency *( t - phase))
sum_x = x1 + x2

plt.figure(figsize=(10, 2))
plt.plot(t, x1,  linewidth=2.0, linestyle='-', label='Firts Sine')
plt.plot(t, x2,  linewidth=2.0, linestyle='-', label='Second Sine')
plt.plot(t, sum_x,  linewidth=2.0, linestyle='-', label='Superposition Sine')
plt.xlim([0, duration])
plt.xlabel('Time (seconds)')
plt.ylabel('Amplitude')
plt.xlim([0 ,0.002])
plt.legend(); plt.show()

Python: Simulasi Modulasi Gelombang (Wave Modulation Simulation)

Modulasi adalah proses perubahan (varying) suatu gelombang periodik sehingga menjadikan suatu sinyal mampu membawa suatu informasi. Dengan proses modulasi, ekuensi tinggi.

Amplitudo Modulasi (AM)

import numpy as np
import matplotlib.pyplot as plt

#Carrier wave c(t)=A_c*cos(2*pi*f_c*t)
#Modulating wave m(t)=A_m*cos(2*pi*f_m*t)
#Modulated wave s(t)=A_c[1+mu*cos(2*pi*f_m*t)]cos(2*pi*f_c*t)

A_c = 10 #float(input('Enter carrier amplitude: '))
f_c = 100 #float(input('Enter carrier frquency: '))
A_m = 10 #float(input('Enter message amplitude: '))
f_m = 10 #float(input('Enter message frquency: '))
modulation_index = 0.5 #float(input('Enter modulation index: '))

t = np.linspace(0, 1, 1000)

carrier = A_c*np.cos(2*np.pi*f_c*t)
modulator = A_m*np.cos(2*np.pi*f_m*t)
product = A_c*(1+modulation_index*np.cos(2*np.pi*f_m*t))*np.cos(2*np.pi*f_c*t)

plt.subplot(3,1,1)
plt.title('Amplitude Modulation')
plt.plot(modulator,'g')
plt.ylabel('Amplitude')
plt.xlabel('Message signal')

plt.subplot(3,1,2)
plt.plot(carrier, 'r')
plt.ylabel('Amplitude')
plt.xlabel('Carrier signal')

plt.subplot(3,1,3)
plt.plot(product, color="purple")
plt.ylabel('Amplitude')
plt.xlabel('AM signal')

plt.subplots_adjust(hspace=1)
plt.rc('font', size=15)
fig = plt.gcf()
fig.set_size_inches(16, 9)

Frekuensi Modulasi (FM)

# Import the plotting library
from matplotlib import pyplot as plot

# Define the setup
fCarrier = 10;
fAudio = 1;
fs = 1000;
timeEnd = 1;
time = np.linspace(0,2,fs*timeEnd);

# Create the signals
carrier = np.sin(2*np.pi*fCarrier*time);
audio = np.sin(2*np.pi*fAudio*time);
audioInt = -np.cos(2*np.pi*fAudio*time);
freqMod = np.sin(2*np.pi*fCarrier*time + 2*np.pi*1*audioInt);

# Plot the signals
plot.plot(time,audio+3);
plot.plot(time,carrier);
plot.plot(time,freqMod-3);

# Add some description
plot.text(0.75,4.2,'Audio Signal');
plot.text(0.75,1.2,'Carrier Signal');
plot.text(0.75,-1.8,'FM Signal');

# Label and cleanup the axes
ax = plot.gca();
plot.xlabel('Time (sec)'); plot.ylim(-4.5,5); plot.title('Frequency Modulation Illustration');
ax.get_yaxis().set_ticks([]);

Jika gelombang yang ditampilkan belum menunjukkan gelombang yang jelas, maka dapat digunakan fitur xlim yang digunakan untuk mengatur batas sumbu X yang akan ditampilkan.

Pada contoh di bawah ini, sebuah gelombang lebih terlihat jelas jika ditampilkan dengan batas sumbu X yang diperkecil atau sinyal di zoom in.

Untuk menampilkan gelombang yang memiliki frekuensi terlalu kecil, kita dapat mengatur xlim menjadi lebih besar. Perhatikan perbedaan kedua gelombang berikut dengan nilai xlim yang berbeda. Gelombang yang memiliki frekuensi kecil dapat diperjelas dengan memperbesar nilai xlim.

File dapat diunduh di Github.

Simulasi Gelombang Dengan Google Colabs

Untuk memulai menggunakan Google Colabs dengan melakukan langkah-langkah berikut:

1. Buka google search engine, kemudian ketik colabs
2. Pilih Colaboratory, atau ketik alamat berikut: https://colab.research.google.com/
3. Akan muncul window berikut, kemudian pilih New notebook

Kemudian akan muncul window seperti berikut ini:

Membuat Gelombang

Ketik coding berikut untuk membuat sebuah gelombang:

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

frequency = 2000
amplitudo = 3
time = np.linspace(0, 2, 1000)

gelombang = amplitudo*np.sin(2*np.pi*frequency*time)

plt.plot(time, gelombang)
plt.xlabel('Time (s)')
plt.ylabel('Amplitude (V)')
plt.title('Gelombang Sinus')
plt.show()

Membuat Osilasi Teredam (Damped Oscilation)

from scipy.integrate import solve_ivp

t = np.linspace(0,15,1000)

y = [0,1]

gamma = 1

omega_sqr = 100

def sho(t,y):

    solution = (y[1],(-gamma*y[1]-omega_sqr*y[0]))

    return solution

solution = solve_ivp(sho, [0,1000], y0 = y, t_eval = t)

plt.plot(t,solution.y[0])

plt.ylabel(“Position”)

plt.xlabel(“Time”)

plt.title(‘Damped Oscillator’, fontsize = 20)

Membuat Dua Gelombang dan Menggabungkannya

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

frequency1 = 2000
frequency2 = 3000
amplitudo1 = 3

time = np.linspace(0, 2, 1000)

gelombang_1 = amplitudo1*np.sin(2*np.pi*frequency1*time)
gelombang_2 = amplitudo1*np.sin(2*np.pi*frequency2*time)

Sinyal_Gabungan = gelombang_1 + gelombang_2

plt.plot(time, gelombang_1,'r')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude (V)')
plt.title('Gelombang Gabungan, freq. {:d} '.format(frequency1))
plt.show()

plt.plot(time, gelombang_2,'b')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude (V)')
plt.title('Gelombang 2, freq. {:d} '.format(frequency2))
plt.show()

plt.plot(time, Sinyal_Gabungan)
plt.xlabel('Time (s)')
plt.ylabel('Amplitude (V)')
plt.title('Gelombang Gabungan, freq. {:d}'.format(frequency1))
plt.show()

Menggeser Sinyal

import numpy as np
import matplotlib.pyplot as plt


freq = 2000
amp = 3
time = np.linspace(0, 2, 1000)

#sudut geser

theta = 180

signal1 = amp*np.sin(2*np.pi*freq*time)
signal2 = amp*np.sin((2*np.pi*freq*time) + theta)

plt.plot(time, signal1,'r')
plt.plot(time, signal2,'b')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude (V)')
plt.title('Gelombang Sinus')

plt.show()

LPW, HPF, BPS-Memfilter Sinyal Dengan Python

Sinyal contoh dapat didownload disini ECG.wav. Berikut adalah contoh untuk memfilter sinyal.

import scipy.io.wavfile
import scipy.signal
import numpy as np
import matplotlib.pyplot as plt

read ECG data from the WAV file

sampleRate, data = scipy.io.wavfile.read('ecg.wav')
times = np.arange(len(data))/sampleRate

apply a 3-pole lowpass filter at 0.1x Nyquist frequency

b, a = scipy.signal.butter(3, 0.1)
filtered = scipy.signal.filtfilt(b, a, data)

plot the original data next to the filtered data

plt.figure(figsize=(10, 4))

plt.subplot(121)
plt.plot(times, data)
plt.title("ECG Signal with Noise")
plt.margins(0, .05)

plt.subplot(122)
plt.plot(times, filtered)
plt.title("Filtered ECG Signal")
plt.margins(0, .05)

plt.tight_layout()
plt.show()

Low Pass Filter (LPF)

b, a = scipy.signal.butter(3, 0.05, ‘lowpass’)
filteredLowPass = scipy.signal.filtfilt(b, a, data)

High Pass Filter (HPF)

b, a = scipy.signal.butter(3, 0.05, ‘highpass’)
filteredHighPass = scipy.signal.filtfilt(b, a, data)

Band Pass Filter (BPF)

b, a = scipy.signal.butter(3, [.01, .05], ‘band’)
filteredBandPass = scipy.signal.lfilter(b, a, data)

plt.figure(figsize=(21, 6))

plt.subplot(131)
plt.plot(times, filteredLowPass)
plt.title(“Low-Pass”)

plt.subplot(132)
plt.plot(times, filteredHighPass)
plt.title(“Hig-Pass”)

plt.subplot(133)
plt.plot(times, filteredBandPass)
plt.title(“Band-Pass”)

Untuk menampilkan dalam domain FFT:

X = fft(data)
N = len(X)
n = np.arange(N)
T = N/sampleRate
freq = n/T

plt.figure(figsize = (12, 6))
plt.subplot(121)

plt.stem(freq, np.abs(X), ‘b’, \
markerfmt=” “, basefmt=”-b”)
plt.xlabel(‘Freq (Hz)’)
plt.ylabel(‘FFT Amplitude |X(freq)|’)
plt.xlim(0.1, 10)
plt.ylim(1, 1*10e5)

plt.subplot(122)
plt.plot(times, ifft(X), ‘r’)
plt.xlabel(‘Time (s)’)
plt.ylabel(‘Amplitude’)
plt.tight_layout()
plt.show()

Referensi:

https://swharden.com/blog/2020-09-23-signal-filtering-in-python/

Memfilter Sinyal Menggunakan Python

• Cara untuk membuat sinyal dapat disimak pada posting sebelumnya [Membuat Sinyal dengan Python].
• Untuk menampilkan sinyal dalam domain frekuensi dapat disimak pada posting sebelumnya [Menampilkan Sinyal Dalam Domain Frekuensi Dengan FFT].

Pada contoh ini kita akan memfilter sinyal menggunakan python, pertama kali kita buat dua sinyal yaitu sinyal utama dan sinyal noise.

• Sinyal utama kita gunakan coding berikut:

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

freq = 2000
amp = 3
time = np.linspace(0, 2, 1000)

pure = ampnp.sin(2*np.pi*freq*time)

plt.plot(time, pure)
plt.xlabel(‘Time (s)’)
plt.ylabel(‘Amplitude (V)’)
plt.show()

sinyal utama

Kemudian kita buat sinyal noise dan kita gabungkan:

noise = np.random.normal(0, 1, 1000)
signal = pure + noise

plt.plot(time, signal)
plt.xlabel(‘Time (s)’)
plt.ylabel(‘Amplitude (V)’)
plt.show()

sinyal noise + sinyal utama

kemudian kita gabung dalam satu tampilan:

plt.figure(figsize = (20, 6))
plt.subplot(1,3,1)
plt.plot(time, pure)
plt.xlabel(‘Time (s)’)
plt.ylabel(‘Amplitude’)

plt.subplot(1,3,2)
plt.plot(time, noise)
plt.xlabel(‘Time (s)’)
plt.ylabel(‘Amplitude’)

plt.subplot(1,3,3)
plt.plot(time, signal)
plt.xlabel(‘Time (s)’)
plt.ylabel(‘Amplitude’)

Kemudian kita filter menggunakan low pass filter (LPF):

apply a 3-pole lowpass filter at 0.1x Nyquist frequency

b, a = scipy.signal.butter(3, 0.1)
filtered = scipy.signal.filtfilt(b, a, signal)

plt.figure(figsize=(10, 4))

plt.subplot(121)
plt.plot(time, signal)
plt.title(“Signal with Noise”)
plt.margins(0, .05)

plt.subplot(122)
plt.plot(time, filtered)
plt.title(“Filtered Signal”)
plt.margins(0, .05)

plt.tight_layout()
plt.show()