การหาค่า RMS สำหรับสัญญาณไฟฟ้า#

บทความนี้กล่าวถึง การหาค่า RMS (Root Mean Square) ของสัญญาณไฟฟ้าแบบมีคาบเวลา และมีตัวอย่างการเขียนโค้ดภาษา Python เพื่อช่วยในการคำนวณค่า RMS และแสดงผลรูปคลื่นสัญญาณพื้นฐานทางไฟฟ้า

Keywords: Root Mean Square (RMS), Python, NumPy, SymPy

นิยามสำหรับค่า Root Mean Square
การหาค่า RMS ของสัญญาณรูปคลื่นไซน์ (Pure Sine Wave)
การเขียนโค้ด Python หาค่า RMS ของสัญญาณไซน์ (Sine Wave)
RMS กับโหลดไฟฟ้าของตัวต้านทาน (Resistive Load)
RMS กับโหลดไฟฟ้าเชิงซ้อน (Reactive Load)
RMS สำหรับสัญญาณรูปคลื่นสี่เหลี่ยม (Square Wave)
RMS สำหรับสัญญาณคาบรูปแบบอื่น

▷ นิยามสำหรับค่า Root Mean Square#

RMS (Root Mean Square) หรือ "รูท-มีน-สแควร์ " หมายถึง รากที่สองของค่าเฉลี่ยของกำลังสองของสัญญาณในทางไฟฟ้า และสามารถใช้กับสัญญาณที่เป็นแรงดันไฟฟ้า และกระแสไฟฟ้าก็ได้ RMS มักนำมาใช้กับสัญญาณไฟฟ้า AC และใช้เพื่อหาค่าที่แสดงถึงพลังงานไฟฟ้าของสัญญาณ AC ให้เทียบเท่ากับไฟฟ้ากระแสตรง DC ได้

ในทางคณิตศาสตร์ ถ้า $x(t)$ เป็นฟังก์ชันที่เปลี่ยนแปลงตามเวลา หรือ ค่าของฟังก์ชันขึ้นกับตัวแปรอิสระเวลา มีค่าเป็นจำนวนจริง และกำหนดให้ $x(t)$ เป็นฟังก์ชันที่มีคาบ กล่าวคือ $x(t+T) = x(t), T > 0$ สำหรับเวลา $t$ ใด ๆ การหาค่า RMS ของ $x(t)$ ก็มีนิยามดังนี้

$\text{RMS} = \sqrt{\frac{1}{T} \int_0^T x^2(t) \, dt}$

ซึ่งจะเห็นได้ว่า จะต้องมีการคำนวณตามลำดับดังนี้

นำฟังก์ชัน $x(t)$ ไปยกกำลังสองก่อน ได้เป็น $x^2(t)$
อินทิเกรต $x^2(t)$ ที่ได้จากขั้นตอนที่ 1 ในช่วงเวลา $t \in [0,T]$ หรือ หนึ่งคาบเวลา (ในทางไฟฟ้าคือ พลังงานที่ใช้ในหนึ่งคาบเวลา)
นำผลลัพธ์ที่ได้จากขั้นตอนที่ 2 ซึ่งจะได้เป็นค่าคงที่และมีค่าเป็นบวก ไปหารด้วยคาบเวลา $T$ ซึ่งจะได้ค่าเฉลี่ย (ในทางไฟฟ้าคือ กำลังไฟฟ้าเฉลี่ยต่อหนึ่งคาบเวลา)
คำนวณหารากที่สองของค่าเฉลี่ยที่ได้จากขั้นตอนที่ 3

หากใช้วิธีการคำนวณเชิงตัวเลข (Numerical Computation) ก็อาจเปลี่ยนจากการหาอินทิเกรต เป็นการหาผลรวมเชิงประมาณค่า (Summation Approximation) ดังต่อไปนี้

$\begin{align} \text{RMS} &\approx \sqrt{ \frac{1}{T} \sum_{n=0}^{N-1} x^2(n\Delta t) \Delta t} \\ &\approx \sqrt{ \frac{1}{N} \sum_{n=0}^{N-1} (x[n])^2}, \;\; \Delta t = \frac{T}{N} \end{align}$ โดยที่

$N$ คือ จำนวนเต็มบวก เพื่อแบ่งช่วงย่อยเท่า ๆ กันในหนึ่งคาบเวลา $T$
$\Delta t = T/N$ คือ ความกว้างของแต่ละช่วงเวลา
$x(n\Delta t)$ หรือใช้สัญลักษณ์ $x[n]$ หมายถึง ค่าของสัญญาณ (Sampled Value) ณ จุดที่เวลา $t = n \Delta t, n=0,1,2,...,(N-1)$
$(x[n])^2$ หมายถึง การนำค่า $x[n]$ มายกกำลังสอง

รูป: ตัวอย่างกราฟสำหรับ $x(t)$ การอินทิเกรต (การหาพื้นที่ใต้กราฟ) ในหนึ่งคาบเวลาของฟังก์ชัน $(x(t))^2$ และการประมาณค่าของการอินทิเกรต โดยหาผลรวมจากแท่งสี่เหลี่ยมของแต่ละช่วงย่อย (integral_approx.py)

▷ การหาค่า RMS ของสัญญาณรูปคลื่นไซน์ (Pure Sine Wave)#

ยกตัวอย่างฟังก์ชันหรือสัญญาณไฟฟ้าแบบไซน์บริสุทธิ์ (Pure Sine) ตามรูปแบบของฟังก์ชัน $x(t) = A sin(\omega t)$ , $\omega = 2\pi/T = 2\pi f, A > 0$ คือ แอมพลิจูด และ $T > 0$ คือ คาบเวลา

คำนวณค่า RMS ได้ดังนี้

$\begin{align} \text{RMS} &= \sqrt{\frac{1}{T} \int_0^T x^2(t) \, dt} \\ &= \sqrt{\frac{1}{T} \int_0^T [A sin(\omega t)]^2 \, dt} \\ &= \sqrt{\frac{A^2}{T} \int_0^T \frac{1}{2}[1 - cos(2\omega t)] \, dt} \\ &= \sqrt{\frac{A^2}{T} \frac{1}{2} \big[t - \frac{sin(2\omega t)}{2\omega}\big]_{0}^{T}} \\ &= \sqrt{\frac{A^2}{T} \frac{T}{2}} \\ &= \frac{A}{\sqrt{2}} \approx 0.7071 = \frac{\sqrt{2}}{2} A \end{align}$

ดังนั้นสำหรับสัญญาณรูปคลื่นไซน์ ค่า RMS ของสัญญาณคำนวณได้จากค่าแอมพลิจูดหารด้วย $\sqrt{2}$ หรือ แอมพลิจูด คูณด้วยค่าประมาณ $0.7071$

ค่าที่แสดงบนระบบไฟฟ้า เช่น 220V ในบ้าน เป็น ค่า RMS ไม่ใช่ค่าสูงสุด ค่าแอมพลิจูด หรือ "พีค" (แรงดันไฟฟ้าสูงสุด) ก็คือ $220V / 0.7071 \approx 311V\,(peak)$

ถ้าสัญญาณไซน์ มีค่า DC Offset ไม่เป็นศูนย์ จะคำนวณ ค่า RMS อย่างไร?

$x(t) = A_0 + A sin(\omega t)$ โดยที่ $A_0$ คือ ค่า DC Offset

$\begin{align} X_{rms} &= \sqrt{\frac{1}{T} \int_0^T x^2(t) \,dt} \\ &= \sqrt{\frac{1}{T} \int_0^T \big[A_0 + A sin(\omega t)\big]^2 \,dt} \\ &= \sqrt{\frac{1}{T} \int_0^T \big[A_0^2 +2 A_0 A sin(\omega t) +A^2 sin^2(\omega t)\big] \,dt}\\ &= \sqrt{\frac{1}{T} \big[A_0^2 T + \frac{A^2 T}{2}\big]} \\ &= \sqrt{ A_0^2 + \frac{A^2}{2}} \end{align}$

import sympy as sp

t = sp.Symbol('t', real=True) 
A_0, A, omega = sp.symbols('A_0 A omega', positive=True) 
T = 2 * sp.pi / omega # Define the period
x_t = A_0 + A * sp.sin(omega * t) # Define the signal
integral = sp.integrate(x_t**2, (t, 0, T))
integral = sp.simplify(integral, rational=True, expand=True)
rms = sp.sqrt(integral/T)
print(rms)
# Output:
# sqrt(A**2/2 + A_0**2)

▷ การเขียนโค้ด Python หาค่า RMS ของสัญญาณไซน์ (Sine Wave)#

ถัดไปเป็นตัวอย่างโค้ด Python เพื่อคำนวณหาค่า RMS ของสัญญาณ $x(t) = A sin(\omega t)$ โดยใช้ SymPy Package:

import sympy as sp

# Define symbolic variables
A, T, t = sp.symbols('A T t', real=True, positive=True)
# Define the angular frequency
omega = 2 * sp.pi / T
# Define the signal x(t)
x_t = A * sp.sin(omega * t)
# Compute RMS using symbolic method
rms_expr = sp.sqrt((1 / T) * sp.integrate(x_t**2, (t, 0, T)))
# Simplify the expression
rms_simplified = sp.simplify(rms_expr)
print("RMS = ", rms_simplified)
## RMS = sqrt(2)*A/2

หากจะลองคำนวณโดยใช้วิธีเชิงตัวเลข โดยใช้ NumPy Package คำนวณหาผลรวมตามสูตร:

$\begin{align} \text{RMS} &\approx \sqrt{ \frac{1}{N} \sum_{n=0}^{N-1} x[n]^2} \end{align}$

ก็มีตัวอย่างโค้ดดังนี้ โดยมีการเปรียบเทียบค่า N หรือจำนวนการแบ่งช่วงย่อย เช่น 100, 500 ไปจนถึง 5000

import numpy as np

# Approximate RMS using NumPy
f = 50     # Set the frequency in Hz
T = 1 / f  # Set the period in second
omega = 2 * np.pi * f # Define the angular frequency

print( f"RMS (exact)   = A * {np.sqrt(2)/2:.6f}" )
for N in [100, 500, 2000, 5000]: # Use different numbers of sample points
    # Compute the sample points
    ts = np.linspace(0, T, N)
    # Compute the samples of the signal
    x_t = np.sin(omega * ts) 
    # Compute RMS (approx.)
    rms_approx = np.sqrt( np.sum(x_t**2) / N ) 
    print( f"N = {N:4d}, RMS = A * {rms_approx:.6f}" )

# Output
# RMS (exact)   = A * 0.707107
# N =  100, RMS = A * 0.703562
# N =  500, RMS = A * 0.706399
# N = 2000, RMS = A * 0.706930
# N = 5000, RMS = A * 0.707036

แม้ว่าการเพิ่มค่าของ N ให้มากขึ้นตามลำดับ จะทำให้ ค่า RMS ใกล้เคียงค่าที่ถูกต้องมากขึ้น แต่ก็ยังไม่ใช่วิธีที่ดี ลองมาเปรียบเทียบวิธีกาารคำนวณเชิงตัวเลขอีกวิธีหนึ่ง โดยใช้การประมาณค่าอินทิกรัล (Numerical Integration)

วิธีการหนึ่งที่สามารถนำมาใช้ได้ ชื่อว่า Simpson's 3/8 Rule หากจะคำนวณค่าประมาณของอินทิกรัล $I$ ของฟังก์ชัน $f(t)$ ในช่วง $t \in [a,b]$

$I = \int_{a}^{b} f(t) dt$ และคำนวณโดยแบ่งเป็นช่วงย่อย $h = (b-a)/N$ และ $N$ เป็นจำนวนเต็มบวก หารด้วย 3 ลงตัว

ตามวิธีการของ Simpson's 3/8 Rule ก็จะคำนวณค่าประมาณได้ดังนี้

$I \approx \frac{3}{8}h \Big[ f[0] + 3\sum_{i=1, ...\\i\,mod\,3 \neq 0}\!\!\! f[i] + 2\sum_{i=3, ...\\i\,mod\,3 = 0}\!\!\! f[i] + f[N] \Big]$ ซึ่งมี $f[i]$ คือ ค่าของฟังก์ชันที่ตำแหน่ง $t = a + i\cdot h$ :

$i=0$ : $f[0] = f(a)$
$i=N$ : $f[N] = f(b)$

ดังนั้นการคำนวณค่าประมาณ RMS สำหรับสัญญาณรูปไซน์ $x(t)$ มีตัวอย่างการเขียนโค้ดดังนี้

import numpy as np

# Approximate RMS using NumPy
f = 50     # Set the frequency in Hz
T = 1 / f  # Set the period in second
omega = 2 * np.pi * f # Define the angular frequency

# Apply Simpson's 3/8 rule
for N in [9, 30, 300]: #  N must be a multiple of 3
    h   = T / N
    ts  = np.linspace(0, T, N + 1) # time points
    x_t = np.sin(omega*ts)         # sample values
    f   = x_t ** 2                 # squared values
    # Compute integral using Simpson's 3/8 rule
    approx_integral = (3 * h / 8) * (
        f[0] 
        + 3 * np.sum( f[1:N:3] + f[2:N:3] )
        + 2 * np.sum( f[3:N:3] )
        + f[N]
    )
    rms_approx = np.sqrt( approx_integral / T )
    print( f"N = {N:3d}, RMS: A * {rms_approx:.6f}" )

# Output
# N =   9, RMS: A * 0.707107
# N =  30, RMS: A * 0.707107
# N = 300, RMS: A * 0.707107

จากเอาต์พุต จะเห็นได้ว่า การแบ่งจำนวนช่วงย่อยในหนึ่งคาบเวลา หากใช้ค่าN ไม่มาก (เป็นเลขจำนวนเต็มบวกและหาร 3 ลงตัว) ก็จะได้ค่า RMS ใกล้เคียงกับค่าที่ถูกต้อง

ในการคำนวณตามวิธีการของ Simpson's 3/8 Rule
ก็อาจใช้วิธีเรียกใช้ฟังก์ชันที่มีอยู่ใน SciPy Package แล้วก็ได้ ตามตัวอย่างต่อไปนี้

import numpy as np
from scipy.integrate import simpson

# Approximate RMS using NumPy
f = 50  # Set the frequency in Hz
T = 1 / f  # Set the period in second
omega = 2 * np.pi * f # Define the angular frequency

# "N must be a multiple of 3 for Simpson's 3/8 rule."
for N in [9, 30, 300]:
    ts  = np.linspace(0, T, N + 1)  # time points
    x_t = np.sin(omega*ts)          # sample values
    f   = x_t ** 2                  # squared values
    integral_approx = simpson( f, ts )  # Use SciPy's Simpson integration
    rms_approx = np.sqrt( integral_approx / T )
    print( f"N = {N:3d}, RMS: A * {rms_approx:.6f}" )

# Output
# N =   9, RMS: A * 0.711564
# N =  30, RMS: A * 0.707107
# N = 300, RMS: A * 0.707107

▷ RMS กับโหลดไฟฟ้าของตัวต้านทาน (Resistive Load)#

ในทางไฟฟ้า หากพิจารณาโหลดไฟฟ้าเป็นตัวต้านทาน (Resistive Load) ที่มีความสัมพันธ์ระหว่างแรงดันไฟฟ้าและกระแสไฟฟ้าตามกฎของโอห์ม และให้ $x(t)$ เป็นแรงดันไฟฟ้า $v(t)$ ที่ตกคร่อมที่ตัวต้านทาน $R$ หรือ เป็นกระแสไฟฟ้าที่ไหลผ่านตัวต้านทาน $R$ (ความต้านทานคงที่) กำลังไฟฟ้าที่เกิดขึ้นกับตัวต้านทาน ในขณะเวลาใด จะได้เป็น

$p(t) = v(t) \cdot i(t) = \frac{v^2(t)}{R} = i^2(t) \cdot R$

ดังนั้น ถ้าต้องการหากำลังไฟฟ้าเฉลี่ย หรือคำนวณจากพลังงานไฟฟ้าที่ใช้ไปในช่วงเวลา $t = 0..T$ (หนึ่งคาบเวลา) ก็คำนวณได้ดังนี้

$\begin{align} P &= \frac{1}{T} \int_{0}^{T} \frac{v^2(t)}{R} \, dt \\ &= \frac{1}{R} \cdot \Big(\frac{1}{T} \int_{0}^{T} v^2(t) \, dt\Big) \\ &= \frac{1}{R} \cdot V^2_{rms} \end{align}$ และ $\begin{align} P &= \frac{1}{T} \int_{0}^{T} i^2(t) \cdot R \, dt \\ &= R \cdot \Big( \frac{1}{T} \int_{0}^{T} i^2(t) \, dt\Big) \\ &= R \cdot I^2_{rms} \end{align}$

สังเกตว่าส่วนที่อยู่ในวงเล็บคือ ค่าเฉลี่ยกำลังสองของแรงดันไฟฟ้า หรือ กระแสไฟฟ้า ตามลำดับ ดังนั้นอาจสรุปได้ว่า กำลังไฟฟ้าที่เกิดขึ้นกับตัวต้านทานเกี่ยวข้องกับค่า RMS ดังนี้

$P_{resistive} = V_{rms} \cdot I_{rms}$

▷ RMS กับโหลดไฟฟ้าเชิงซ้อน (Reactive Load)#

แต่หากว่า โหลดไฟฟ้ามีลักษณะหรือคุณสมบัติแบบตัวเก็บประจุ (C) หรือตัวเหนี่ยวนำ (L) หรือ เรียกว่า "โหลดเชิงซ้อน" (Reactive Load) และใช้กับไฟฟ้า AC ที่เป็นรูปคลื่นไซน์เท่านั้น และมีความถี่คงที่ เช่น 50Hz การคำนวณ ก็จะแตกต่างจากกรณีของตัวต้านทาน และจะต้องพิจารณา "ตัวประกอบกำลัง" (Power Factor, PF) ด้วย

กำหนดให้ $v(t)$ มีหน่วยเป็น V) และ $i(t)$ มีหน่วยเป็น A เป็นไปตามฟังก์ชันรูปคลื่นไซน์ มีความถี่เท่ากัน แต่มีค่าเฟสต่างกันได้ $v(t) = V_m sin(\omega t) \\ i(t) = I_m sin(\omega t + \theta)$ โดยที่

$\omega = 2\pi/T = 2\pi f$ เป็นความถี่เชิงมุม (คงที่)
$\theta$ คือ มุมเฟสระหว่างแรงดันและกระแสไฟฟ้าที่เกิดขึ้นกับตัวโหลดไฟฟ้า
$V_m$ คือ แอมพลิจูดของแรงดันไฟฟ้า
$I_m$ คือ แอมพลิจูดของกระแสไฟฟ้า

ตัวอย่างโค้ด Python สำหรับการแสดงรูปคลื่นสัญญาณ AC สำหรับแรงดันไฟฟ้า $v(t)$ กระแสไฟฟ้า $i(t)$ และกำลังไฟฟ้า $p(t)$

import numpy as np
import matplotlib.pyplot as plt

# Constants
f = 50  # Frequency in Hz
T = 1 / f  # Period
phi = np.deg2rad(30)  # Phase shift in radians

# Time array for two periods
T_total = 2 * T # Total time for two periods
num_points = 1000  # Number of points for smooth plotting
t = np.linspace(0, T_total, num_points)

# Voltage and current waveforms
Vm = 1.0 # Amplitude for voltage [V]
Im = 1.0 # Amplitude for current [A]
v_t = Vm * np.sin(2 * np.pi * f * t)
i_t = Im * np.sin(2 * np.pi * f * t + phi)
p_t = v_t * i_t  # Instantaneous power

# Create subplots
fig, axs = plt.subplots(2, 1, figsize=(10, 6))

# First subplot: Voltage, Current, and Instantaneous Power
axs[0].plot(t, v_t, label='$v(t) = sin(2\pi f\, t)$', color='b')
axs[0].plot(t, i_t, label='$i(t) = sin(2\pi f\, t + 30°)$', color='r')
axs[0].set_xlabel('Time (s)')
axs[0].set_ylabel('Amplitude')
axs[0].set_title('Voltage, Current, and Instantaneous Power')
axs[0].legend(loc='upper right')
axs[0].grid()

# Second subplot: Instantaneous Power
axs[1].plot(t, p_t, label='$p(t)$', color='purple')
axs[1].fill_between(t, p_t, where=(t <= 2*T), color='purple', alpha=0.3)
axs[1].set_xlabel('Time (s)')
axs[1].set_ylabel('Amplitude')
axs[1].set_title('Instantaneous Power $p(t)$')
axs[1].legend()
axs[1].grid()

plt.tight_layout()
plt.show()

รูป: ตัวอย่างการแสดงรูปคลื่นสัญญาณ (สำหรับเวลาในช่วง $t \in [0,2T]$ หรือ 2 คาบเวลา)

กำลังไฟฟ้าในเวลาใด ๆ $p(t)$ (Instantaneous Power) คำนวณได้จาก

$\begin{align} p(t) &= v(t) \cdot i(t) \\ &= V_m sin(\omega t) \cdot I_m sin(\omega t + \theta) \\ &= V_m I_m sin(\omega t) sin(\omega t + \theta) \\ \end{align}$

หากใช้สูตร

$sin(A) sin(B) = \frac{1}{2}[cos(A-B) - cos(A+B)]$

ก็เขียนสมการสำหรับ $p(t)$ ได้เป็น

$p(t) = \frac{V_m I_m}{2}[cos(-\theta) - cos(2\omega t + \theta)]$

และกำลังไฟฟ้าเฉลี่ย ก็หาได้จาก

$\begin{align} P_{reactive} &= \frac{1}{T} \int_{0}^{T} p(t) \, dt = \frac{1}{T} \int_{0}^{T} v(t) \cdot i(t) \, dt \\ &= \frac{ V_m I_m}{2}\Big[ \frac{1}{T} \int_{0}^{T}[cos(\theta) - cos(2\omega t + \theta) ]\,dt \Big] \\ &= \frac{V_m I_m}{2} \,\frac{cos(\theta) T + 0}{T} \\ &= \frac{V_m}{\sqrt{2}} \frac{I_m}{\sqrt{2}}\, cos(\theta) \\ &= V_{rms}\, I_{rms}\, cos(\theta) \end{align}$

และ $cos(\theta)$ ก็คือ ค่าตัวประกอบกำลัง (Power Factor)

ในกรณีที่โหลดไฟฟ้าเป็นตัวต้านทาน (Resistive Load) แรงดันและกระแสไฟฟ้ามีมุมเฟสที่ต่างกันเป็น $0^\circ$ ดังนั้น ค่าตัวประกอบกำลัง จะมีค่าเป็น $cos(0) = 1$

ลองเปรียบเทียบกับการเขียนโค้ดโดยใช้ SymPy Package ดังนี้

import sympy as sp

# Define symbols
t, T, V_m, I_m, theta = sp.symbols('t T V_m I_m theta', 
                                   real=True, positive=True)
omega = 2 * sp.pi / T  # Angular frequency
# Define voltage and current functions
v_t = V_m * sp.sin(omega * t)
i_t = I_m * sp.sin(omega * t + theta)
p_t = v_t * i_t  # Instantaneous power
# Compute average power over one period
P_avg = (1 / T) * sp.integrate(p_t, (t, 0, T))
# Display the result
print( "p(t) =", sp.simplify(p_t) ) # Instantaneous Power
print( "P =", sp.simplify(P_avg) )  # Average Power
# Output
# p(t) = I_m*V_m*(cos(theta) - cos(theta + 4*pi*t/T))/2
# P = I_m*V_m*cos(theta)/2

▷ RMS สำหรับสัญญาณรูปคลื่นสี่เหลี่ยม (Square Wave)#

กำหนด $x(t)$ เป็นสัญญาณที่มีคาบเวลา $T$ และในหนึ่งคาบมีการแบ่งค่าออกเป็น 2 ช่วง ดังนี้

$x(t) = \begin{cases} V_{max}, \; 0 \leq t < D\cdot T \\ V_{min}, \; D\cdot T \leq t < T \end{cases}$ โดยที่ $0 \leq D < 1$ ก็คือ ค่า Duty Cycle ของสัญญาณ

การจำแนกประเภทของสัญญาณสี่เหลี่ยม:

Unipolar square wave: $V_{max} = A, V_{min} = 0$
Bipolar square wave: $V_{max} = A, V_{min} = -A$

ตัวอย่างการเขียนโค้ด Python เพื่อคำนวณค่า RMS และแสดงรูปกราฟ มีดังนี้

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

# Define symbolic variables
t, A, T, D = sp.symbols('t A T D', real=True, positive=True)

# Define square wave function explicitly
def compute_rms_square(T, D, Vmax, Vmin):
    x_t = sp.Piecewise((Vmax, t % T < D * T), (Vmin, True))
    # Compute RMS by integrating over one period
    integral = sp.integrate( Vmax**2, (t, 0, D*T) ) \
             + sp.integrate( Vmin**2, (t, D*T, T) ) 
    # Compute RMS
    x_rms = sp.sqrt((1/T) * integral).simplify()
    return x_rms

# Compute RMS values
rms_unipolar = compute_rms_square(T, D, A, 0)
print(f"RMS of a square wave (unipolar): {rms_unipolar}")
rms_bipolar = compute_rms_square(T, D, A, -A)
print(f"RMS of a square wave (bipolar): {rms_bipolar}")

# Define numerical values for plotting
A_val, T_val, D_val = 1.0, 1.0, 0.5
N = 1000
ts = [0, 4*T_val]
t_vals = np.linspace(ts[0], ts[1] , N)

# Generate square wave functions
x_unipolar = np.where((t_vals % T_val) < (D_val * T_val), A_val, 0)
x_bipolar  = np.where((t_vals % T_val) < (D_val * T_val), A_val, -A_val)

# Compute RMS values numerically
rms_unipolar_val = float(rms_unipolar.subs({A: A_val, T: T_val, D: D_val}))
rms_bipolar_val = float(rms_bipolar.subs({A: A_val, T: T_val, D: D_val}))

# Plot subplots
fig, axs = plt.subplots(2, 1, figsize=(10, 6), sharex=True)

# Plot Unipolar Square Wave
axs[0].plot(t_vals, x_unipolar, label="Unipolar Square Wave", color='b')
axs[0].axhline(y=rms_unipolar_val, color='r',
               linestyle='--', label=f'RMS = {rms_unipolar_val:.4f}')
axs[0].set_ylabel("Amplitude")
axs[0].set_title("Unipolar Square Wave and RMS")
axs[0].legend()
axs[0].grid()

# Plot Bipolar Square Wave
axs[1].plot(t_vals, x_bipolar, label="Bipolar Square Wave", color='g')
axs[1].axhline(y=rms_bipolar_val, color='r', 
               linestyle='--', label=f'RMS = {rms_bipolar_val:.4f}')
axs[1].set_xlabel("Time (t)")
axs[1].set_ylabel("Amplitude")
axs[1].set_title("Bipolar Square Wave and RMS")
axs[1].legend()
axs[1].grid()

plt.tight_layout()
plt.show()
# Output:
# RMS of a square wave (unipolar): A*sqrt(D)
# RMS of a square wave (bipolar): A

รูป: การแสดงคลื่นสัญญาณ Square โดยใช้ค่าพารามิเตอร์ A=1.0, T=1.0, D=0.5

สังเกตได้ว่า ในกรณีของสัญญาณสี่เหลี่ยมที่เป็น Unipolar Square Wave มีค่าอยู่สองระดับคือ 0 และ A หากมีค่า Duty Cycle = 50% หรือ D=1/2 จะได้ค่า RMS เท่ากับ $\approx 0.7071 A$ ซึ่งตรงกับค่า RMS ของสัญญาณไซน์ที่มีแอมพลิจูด $A$

▷ RMS สำหรับสัญญาณคาบรูปแบบอื่น#

1) สัญญาณเรียงกระแสแบบเต็มคลื่น Full-Wave Rectified Sine:

$x(t) = |A sin(\omega t)|, \; \omega = 2 \pi / T$

สัญญาณนี้ มีคาบเท่ากับ $T/2$ และค่า RMS ของสัญญาณ สามารถคำนวณได้ดังนี้

$\begin{align} \text{RMS} &= \sqrt{ \frac{1}{(T/2)} \int_{0}^{T/2} \! A^2 sin^2(\omega t)\,dt}\\ &= \sqrt{ \frac{2A^2}{T} \int_{0}^{T/2} \! \frac{1}{2}\big[1 - cos(2\omega t)\big]\,dt}\\ &= \sqrt{ \frac{2A^2}{T} \frac{1}{2} \big[t - \frac{sin(2\omega t)}{2\omega}\big]_{0}^{T/2}}\\ &= \sqrt{ \frac{2A^2}{T} \frac{T}{4} }\\ &= \frac{A}{\sqrt{2}} \end{align}$

รูป: สัญญาณ Full-Wave Rectified Wave

2) สัญญาณเรียงกระแสแบบครึ่งคลื่น Half-wave Rectified Sine Wave

$x(t) = \begin{cases} | A sin(\omega t) |, \; 0 \leq t \mod T < T/2 \\ 0, \; \mbox{otherwise} \end{cases}$ สัญญาณนี้ มีคาบเท่ากับ $T$ และค่า RMS ของสัญญาณ สามารถคำนวณได้ดังนี้

$\begin{align} \text{RMS} &= \sqrt{ \frac{1}{T} \int_{0}^{T/2} \! A^2 sin^2(\omega t)\,dt}\\ &= \sqrt{ \frac{A^2}{T} \int_{0}^{T/2} \! \frac{1}{2}\big[1 - cos(2\omega t)\big]\,dt}\\ &= \sqrt{ \frac{A^2}{T} \frac{1}{2} \big[t - \frac{sin(2\omega t)}{2\omega}\big]_{0}^{T/2}}\\ &= \sqrt{ \frac{A^2}{T} \frac{T}{4} }\\ &= \frac{A}{2} \end{align}$

รูป: สัญญาณ Half-Wave Rectified Sine

3) สัญญาณฟันเลื่อย Sawtooth Wave

$x(t) = \begin{cases} \frac{A}{T} t, \; 0 \leq t < T \\ x(t \mod T), \; \mbox{otherwise} \end{cases}$ สัญญาณนี้ มีคาบเท่ากับ $T$ และค่า RMS ของสัญญาณ สามารถคำนวณได้ดังนี้

$\begin{align} \text{RMS} &= \sqrt{ \frac{1}{T} \int_{0}^{T} \! \big(\frac{A}{T}t \big)^2\,dt}\\ &= \sqrt{ \frac{1}{T} \frac{A^2}{T^2} \big[ \frac{t^3}{3}\big]_{0}^{T} }\\ &= \frac{A}{\sqrt{3}} \end{align}$

รูป: สัญญาณ Sawtooth Wave

4) สัญญาณคลื่นสามเหลี่ยม Triangular Wave

$x(t) = \begin{cases} \frac{2 A}{T} t, & 0 \leq t\mod T < \frac{T}{2} \\ \frac{2 A}{T} (T - t), & \frac{T}{2} \leq t\mod T < T \end{cases}$ สัญญาณนี้ มีคาบเท่ากับ $T$ และค่า RMS ของสัญญาณ สามารถคำนวณได้ดังนี้

$\begin{align} \text{RMS} &= \sqrt{ \frac{1}{T} \int_{0}^{T/2} \frac{4 A^2}{T^2} t^2\,dt + \frac{1}{T} \int_{T/2}^{T} \frac{4 A^2}{T^2} (T - t)^2 }\,dt \\ &= \sqrt{ \frac{4 A^2}{T^3} \big[\frac{t^3}{3}]_{0}^{T/2} + \frac{4 A^2}{T^3} \big[-\frac{(T - t)^3}{3}\big]_{T/2}^{T} } \\ &= \sqrt{ \frac{4 A^2}{T^3} \frac{T^3}{3\cdot 8} + \frac{4 A^2}{T^3} \frac{(T^3}{3\cdot 8} } \\ &= \sqrt{ \frac{A^2}{3} } \\ &= \frac{A}{\sqrt{3}} \\ \end{align}$

รูป: สัญญาณ Triangular Wave

Python Code สำหรับการแสดงรูปคลื่นสัญญาณ

▷ กล่าวสรุป#

RMS หรือ ค่ารากที่สองของค่าเฉลี่ยกำลังสอง เป็นค่าที่สำคัญในการวิเคราะห์สัญญาณไฟฟ้า โดยเฉพาะในกรณีไฟฟ้ากระแสสลับ (AC) มัลติมิเตอร์ดิจิทัลแบบ True-RMS ที่ใช้วัดแรงดันและกระแส AC มักแสดงผลในรูปของ RMS เพราะเป็นค่าที่แสดงถึงพลังงานที่แท้จริงของสัญญาณ

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.

Created: 2025-03-01 | Last Updated: 2025-03-02

Keys	Action
`?`	Open this help
`n`	Next page
`p`	Previous page
`s`	Search