PWM変調のプログラム


https://jp.mathworks.com/discovery/pulse-width-modulation.html

http://energychord.com/children/energy/pe/inv/contents/inv_pwm_tri.html

https://youtu.be/6jvMYzFKWqw?si=I9li1KCfVAqLQb_7


```py
import numpy as np
import matplotlib.pyplot as plt

# PWM parameters
frequency = 50  # Hz
period = 1 / frequency  # seconds
sampling_rate = 10000  # samples per second
t = np.linspace(0, 2 * period, int(sampling_rate * 2 * period), endpoint=False)  # Time array

# Create a sawtooth wave (carrier signal)
Vc = np.mod(t, period) / period

# Define the reference sine wave (Vs)
Vs_frequency = 1  # Hz
Vs_amplitude = 1
Vs = Vs_amplitude * np.sin(2 * np.pi * Vs_frequency * t)

# Generate the PWM signal
PWM_signal = np.where(Vs > Vc, 1, 0)

# Plotting
plt.figure(figsize=(10, 8))

# Plot the carrier signal (sawtooth wave)
plt.subplot(3, 1, 1)
plt.plot(t, Vc, label='Sawtooth Wave (Vc)')
plt.title('Sawtooth Wave (Vc)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# Plot the reference signal (sine wave)
plt.subplot(3, 1, 2)
plt.plot(t, Vs, label='Reference Sine Wave (Vs)', color='orange')
plt.title('Reference Sine Wave (Vs)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# Plot the PWM signal
plt.subplot(3, 1, 3)
plt.plot(t, PWM_signal, label='PWM Signal', color='green')
plt.title('PWM Signal')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

plt.tight_layout()
plt.show()

```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3759109/be86ea5a-aabb-1c83-70a4-f886cf0feeaa.png)



```
import numpy as np
import matplotlib.pyplot as plt

# PWM parameters
frequency = 5000  # Hz for the triangular wave
period = 1 / frequency  # seconds
sampling_rate = 10000000  # samples per second
t = np.linspace(0, 2 * period, int(sampling_rate * 2 * period), endpoint=False)  # Time array

# Create a triangular wave (input B)
B = 2 * np.abs(2 * (t / period - np.floor(t / period + 0.5))) - 1

# Define the reference sine wave (input A)
A_frequency = 1  # Hz
A_amplitude = 1
A = A_amplitude * np.sin(2 * np.pi * A_frequency * t)

# Generate the comparator output (input C)
C = np.where(A > B, 1, 0)

# Define RL circuit parameters
R = 1  # ohms
L = 0.01  # henries
V_dc = 5  # DC voltage in volts

# Initialize current array for the RL circuit
I = np.zeros_like(t)
dt = t[1] - t[0]  # Time step

# Simulate the RL circuit
for i in range(1, len(t)):
    dI_dt = (V_dc * C[i-1] - R * I[i-1]) / L
    I[i] = I[i-1] + dI_dt * dt

# Plotting
plt.figure(figsize=(12, 10))

# Plot the sine wave (input A)
plt.subplot(4, 1, 1)
plt.plot(t, A, label='Sine Wave (Input A)')
plt.title('Sine Wave (Input A)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# Plot the triangular wave (input B)
plt.subplot(4, 1, 2)
plt.plot(t, B, label='Triangular Wave (Input B)', color='orange')
plt.title('Triangular Wave (Input B)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# Plot the comparator output (input C)
plt.subplot(4, 1, 3)
plt.plot(t, C, label='Comparator Output (Input C)', color='green')
plt.title('Comparator Output (Input C)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# Plot the RL circuit current
plt.subplot(4, 1, 4)
plt.plot(t, I, label='Current through RL Circuit', color='red')
plt.title('Current through RL Circuit')
plt.xlabel('Time (s)')
plt.ylabel('Current (A)')
plt.grid(True)

plt.tight_layout()
plt.show()

```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3759109/92eef85d-7e4e-db10-d8e6-306ded8e0c81.png)




```
import numpy as np
import matplotlib.pyplot as plt

# 搬送波（三角波）の生成
f_carrier = 1000  # 搬送波の周波数 [Hz]
t = np.linspace(0, 0.01, num=1000)  # 時間配列 [s]
carrier_wave = 0.5 * (1 + np.sin(2 * np.pi * f_carrier * t))

# 基本波（正弦波）の生成
f_signal = 50  # 基本波の周波数 [Hz]
signal_wave = np.sin(2 * np.pi * f_signal * t)

# PWM制御による出力信号の生成
pwm_output = np.zeros_like(t)
for i in range(len(t)):
    if signal_wave[i] > carrier_wave[i]:
        pwm_output[i] = 1
    else:
        pwm_output[i] = 0

# プロット設定
plt.figure(figsize=(10, 6))

plt.subplot(3, 1, 1)
plt.plot(t, carrier_wave, label='Carrier Wave (Triangle)')
plt.ylabel('Amplitude')
plt.legend()

plt.subplot(3, 1, 2)
plt.plot(t, signal_wave, label='Signal Wave (Sine)')
plt.ylabel('Amplitude')
plt.legend()

plt.subplot(3, 1, 3)
plt.step(t, pwm_output, where='mid', label='PWM Output')
plt.ylabel('Output')
plt.xlabel('Time [s]')
plt.ylim([-0.1, 1.1])
plt.legend()

plt.tight_layout()
plt.show()

```


![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3759109/1aca966e-80e0-60b1-98fc-153cbe021099.png)


他の変調
```

import numpy as np
import matplotlib.pyplot as plt

# 基本パラメータ
fs = 1000  # サンプリング周波数
t = np.arange(0, 1, 1/fs)  # 時間ベクトル
f_carrier = 50  # 搬送波周波数
f_signal = 5    # 変調信号周波数
amplitude = 1   # 振幅

# 変調信号（正弦波）
modulating_signal = np.sin(2 * np.pi * f_signal * t)

# 振幅変調（AM）
am_signal = (1 + modulating_signal) * np.cos(2 * np.pi * f_carrier * t)

# 周波数変調（FM）
kf = 10  # 周波数感度
fm_signal = np.cos(2 * np.pi * f_carrier * t + kf * np.cumsum(modulating_signal) / fs)

# 位相変調（PM）
kp = np.pi / 2  # 位相感度
pm_signal = np.cos(2 * np.pi * f_carrier * t + kp * modulating_signal)

# プロット
plt.figure(figsize=(12, 8))

# 振幅変調
plt.subplot(3, 1, 1)
plt.plot(t, am_signal)
plt.title('Amplitude Modulation (AM)')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')

# 周波数変調
plt.subplot(3, 1, 2)
plt.plot(t, fm_signal)
plt.title('Frequency Modulation (FM)')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')

# 位相変調
plt.subplot(3, 1, 3)
plt.plot(t, pm_signal)
plt.title('Phase Modulation (PM)')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')

plt.tight_layout()
plt.show()

```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3759109/cc71d105-38b7-28da-46c8-b09c0db797d4.png)



```
import numpy as np
import matplotlib.pyplot as plt

# Define time array
t = np.linspace(0, 0.01, 10000)  # 10ms duration, high resolution

# Define the modulating wave (A) - a sinusoidal wave with frequency 50Hz
freq_modulating = 50  # in Hz
modulating_wave = np.sin(2 * np.pi * freq_modulating * t)

# Define the carrier wave (B) - a triangle wave with frequency 50kHz
freq_carrier = 5000  # in Hz
carrier_wave = np.abs(2 * (t * freq_carrier - np.floor(0.5 + t * freq_carrier)))

# Comparator output: 1 if modulating wave > carrier wave, else 0
comparator_output = np.where(modulating_wave > carrier_wave, 1, 0)

# Plot the modulating wave (A)
plt.figure(figsize=(15, 6))

plt.subplot(3, 1, 1)
plt.plot(t, modulating_wave, label='Modulating Wave (50Hz)')
plt.title('Modulating Wave ')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.grid(True)
plt.legend()

# Plot the carrier wave (B)
plt.subplot(3, 1, 2)
plt.plot(t, carrier_wave, label='Carrier Wave (50kHz Triangle)', color='orange')
plt.title('Carrier Wave ')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.grid(True)
plt.legend()

# Plot the comparator output
plt.subplot(3, 1, 3)
plt.plot(t, comparator_output, label='Comparator Output', color='green')
plt.title('Comparator Output')
plt.xlabel('Time [s]')
plt.ylabel('Output')
plt.grid(True)
plt.legend()

plt.tight_layout()
plt.show()



```




```

import numpy as np
import matplotlib.pyplot as plt

def generate_pwm(frequency, duty_cycle, duration, sampling_rate):
    """
    Generate a PWM signal.

    :param frequency: Frequency of the PWM signal in Hz
    :param duty_cycle: Duty cycle of the PWM signal (0 to 1)
    :param duration: Duration of the signal in seconds
    :param sampling_rate: Sampling rate in Hz
    :return: Time array and PWM signal array
    """
    t = np.arange(0, duration, 1/sampling_rate)
    pwm_signal = ((t * frequency) % 1) < duty_cycle
    return t, pwm_signal.astype(float)

# Parameters
frequency = 10  # PWM frequency in Hz
duty_cycle = 0.9  # Duty cycle (0 to 1)
duration = 1  # Signal duration in seconds
sampling_rate = 1000  # Sampling rate in Hz

# Generate PWM signal
time, pwm_signal = generate_pwm(frequency, duty_cycle, duration, sampling_rate)

# Plot the PWM signal
plt.figure(figsize=(10, 4))
plt.plot(time, pwm_signal)
plt.title(f'PWM Signal - Frequency: {frequency} Hz, Duty Cycle: {duty_cycle * 100}%')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.ylim(-0.1, 1.1)
plt.grid()
plt.show()

```



```

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import butter, lfilter

def generate_pwm(frequency, duty_cycle, duration, sampling_rate):
    t = np.arange(0, duration, 1/sampling_rate)
    pwm_signal = ((t * frequency) % 1) < duty_cycle
    return t, pwm_signal.astype(float)

def butter_lowpass_filter(data, cutoff, fs, order=5):
    nyquist = 0.5 * fs
    normal_cutoff = cutoff / nyquist
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    y = lfilter(b, a, data)
    return y

# Parameters
frequency = 10  # PWM frequency in Hz
duty_cycle = 0.6  # Duty cycle (0 to 1)
duration = 2  # Signal duration in seconds
sampling_rate = 1000  # Sampling rate in Hz
cutoff_frequency = 5  # Low-pass filter cutoff frequency in Hz

# Generate PWM signal
time, pwm_signal = generate_pwm(frequency, duty_cycle, duration, sampling_rate)

# Apply low-pass filter to simulate transient response
filtered_signal = butter_lowpass_filter(pwm_signal, cutoff_frequency, sampling_rate)

# Plot the PWM signal and the filtered signal
plt.figure(figsize=(12, 8))

plt.subplot(3, 1, 1)
plt.plot(time, pwm_signal)
plt.title('PWM Signal')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.ylim(-0.1, 1.1)
plt.grid()

plt.subplot(3, 1, 2)
plt.plot(time, pwm_signal, label='Original Transient Response', color='orange')
plt.title('PWM Signal (Zoomed)')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.xlim(0, 0.1)  # Zoom in to see the transient behavior
plt.ylim(-0.1, 1.1)
plt.grid()

plt.subplot(3, 1, 3)
plt.plot(time, filtered_signal, label='Filtered Signal', color='green')
plt.title('Filtered Signal (Low-pass Filter)')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.ylim(-0.1, 1.1)
plt.grid()

plt.tight_layout()
plt.show()
```