【Advanced】Methods for Solving RLC Second-Order Circuits in MATLAB (using Simulink)

# 2.1 Euler's Method

### 2.1.1 Method Principle

Euler's method is an explicit numerical integration technique used to solve first-order ordinary differential equations. The fundamental idea is to expand the differential equation in a Taylor series at the current moment and truncate the higher-order terms to obtain an approximation of the differential equation at that moment.

For second-order ordinary differential equations:

y''(t) = f(t, y(t), y'(t))

Euler's method discretizes the equation as follows:

y_{n+1} = y_n + h * y'_n
y'_{n+1} = y'_n + h * f(t_n, y_n, y'_n)

where `h` is the step size, `y_n` and `y'_n` are the approximate values of `y(t)` and `y'(t)` at time `t_n`, respectively.

### 2.1.2 MATLAB Implementation

In MATLAB, the `ode45` function is used to solve differential equations, which internally defaults to Euler's method. Here is an example MATLAB code for solving an RLC second-order circuit using Euler's method:

% Define circuit parameters
R = 10; % Resistance (Ohms)
L = 0.1; % Inductance (Henries)
C = 0.001; % Capacitance (Farads)

% Define initial conditions
y0 = [0; 0]; % [Current (Amperes); Voltage (Volts)]

% Define time range and step size
t = 0:0.001:1; % Time range (seconds)
h = 0.001; % Step size (seconds)

% Solve the differential equation
[t, y] = ode45(@(t, y) [y(2); (-R/L)*y(2) - (1/L)*y(1) + (1/L)*10], t, y0);

% Plot results
plot(t, y(:, 1)); % Current
hold on;
plot(t, y(:, 2)); % Voltage
xlabel('Time (seconds)');
ylabel('Value');
legend('Current (Amperes)', 'Voltage (Volts)');

# 2. MATLAB Solution to RLC Second-Order Circuits with Numerical Methods

### 2.1 Euler's Method

#### 2.1.1 Method Principle

Euler's method is an explicit numerical approach that solves differential equations by approximating the derivatives as difference quotients. For the differential equation system of an RLC second-order circuit:

di/dt = (v - Ri) / L
dv/dt = (i - v / R) / C

The update formulas for Euler's method are:

i(n+1) = i(n) + h * (v(n) - Ri(n)) / L
v(n+1) = v(n) + h * (i(n) - v(n) / R) / C

where `h` is the step size and `n` is the time step index.

#### 2.1.2 MATLAB Implementation

function [i, v] = euler(R, L, C, V0, t, h)
% Euler's method for solving an RLC second-order circuit
% Input:
%    R: Resistance (Ohms)
%    L: Inductance (Henries)
%    C: Capacitance (Farads)
%    V0: Initial voltage (Volts)
%    t: Time range (seconds)
%    h: Step size (seconds)
% Output:
%    i: Current (Amperes)
%    v: Voltage (Volts)

% Initialization
n = length(t);
i = zeros(1, n);
v = zeros(1, n);

% Initial conditions
i(1) = 0;
v(1) = V0;

% Euler's method iteration
for k = 1:n-1
    i(k+1) = i(k) + h * (v(k) - R * i(k)) / L;
    v(k+1) = v(k) + h * (i(k) - v(k) / R) / C;
end
end

### 2.2 Runge-Kutta Method

#### 2.2.1 Method Principle

The Runge-Kutta method is an implicit numerical method that approximates derivatives using multiple intermediate values. For the differential equation system of an RLC second-order circuit, the update formulas for the second-order Runge-Kutta method (RK2) are:

k11 = h * (v(n) - Ri(n)) / L
k12 = h * (i(n) - v(n) / R) / C
k21 = h * (v(n) + k12 - R(i(n) + k11)) / L
k22 = h * (i(n) + k11 - v(n) / R) / C
i(n+1) = i(n) + (k11 + k21) / 2
v(n+1) = v(n) + (k12 + k22) / 2

#### 2.2.2 MATLAB Implementation

function [i, v] = rk2(R, L, C, V0, t, h)
% Second-order Runge-Kutta method for solving an RLC second-order circuit
% Input:
%    R: Resistance (Ohms)
%    L: Inductance (Henries)
%    C: Capacitance (Farads)
%    V0: Initial voltage (Volts)
%    t: Time range (seconds)
%    h: Step size (seconds)
% Output:
%    i: Current (Amperes)
%    v: Voltage (Volts)

% Initialization
n = length(t);
i = zeros(1, n);
v = zeros(1, n);

% Initial conditions
i(1) = 0;
v(1) = V0;

% RK2 method iteration
for k = 1:n-1
    k11 = h * (v(k) - R * i(k)) / L;
    k12 = h * (i(k) - v(k) / R) / C;
    k21 = h * (v(k) + k12 - R * (i(k) + k11)) / L;
    k22 = h * (i(k) + k11 - v(k) / R) / C;
    i(k+1) = i(k) + (k11 + k21) / 2;
    v(k+1) = v(k) + (k12 + k22) / 2;
end
end

### 2.3 Adams-Bashforth Method

#### 2.3.1 Method Principle

The Adams-Bashforth method is an explicit multistep numerical method that approximates derivatives using values from previous time steps. For the differential equation system of an RLC second-order circuit, the update formulas for the second-order Adams-Bashforth method (AB2) are:

i(n+1) = i(n) + h * (3 * v(n) - v(n-1) - 2 * Ri(n) + Ri(n-1)) / (2 * L)
v(n+1) = v(n) + h * (3 * i(n) - i(n-1) - 2 * v(n) / R + v(n-1) / R) / (2 * C)

#### 2.3.2 MATLAB Implementation

function [i, v] = ab2(R, L, C, V0, t, h)
% Second-order Adams-Bashforth method for solving an RLC second-order circuit
% Input:
%    R: Resistance (Ohms)
%    L: Inductance (Henries)
%    C: Capacitance (Farads)
%    V0: Initial voltage (Volts)
%    t: Time range (seconds)
%