Department of Biomedical Engineering

Air University, Islamabad, Pakistan

Program: B.Sc. Biomedical Engineering

Subject: BM-301L Biomedical Signal Processing Lab

Lab # 03:

Linear/ Discrete Convolution

Objectives:

• Understanding the role of convolution in signal processing

• Learning to perform convolution in MATLAB using arbitrary signal

Assessment table:

Description Total Marks Obtained Marks

Performs tasks using
modern tools with
Lab Performance 5
confidence
(CLO 1)
Ability to apply
appropriate signal
processing techniques
Lab Report & Viva to both arbitrary and 5
biosignals
(CLO 3 & 4)
Individual & Individual and
5
Teamwork Teamwork (CLO2)
Total Marks 15

Remarks (if any): ………………………………………

Signature of faculty: ………………….

 Experiment 3
Linear/ discrete convolution
Aliza Ranash
Department of Biomedical Engineering
Air University Islamabad, Pakistan
[email protected]

a specific point in time.

I. TOOLS:
Discrete convolution has wide-ranging applications.
Basic software used is For example, in image processing, it's used for tasks such
as blurring, edge detection, and feature extraction. In the
context of machine learning, convolutional neural
• MATLAB software and its inbuild libraries
networks (CNNs) use a form of convolution to process
In MATLAB, you can use a variety of tools and images and other structured data effectively. of signal
functions to represent and generate basic signals for processing by focusing on the representation and
signal processing and analysis. generation of basic signals using MATLAB. We will
explore various types of signals, such as continuous-time
II. INTRODUCTION:
and discrete-time signals, and use MATLAB commands
to create, visualize, and manipulate these signals.
Signal processing is a fundamental concept in Through hands-on exercises, you will gain practical
engineering and science, with applications ranging from experience in signal generation and learn how to apply
communication systems to image and audio processing. these skills to real-world engineering and scientific
Understanding how to represent and generate basic problems.
signals is a crucial step in mastering signal processing
techniques. MATLAB, a widely used programming Linear convolution obeys the superposition and
environment in engineering and scientific disciplines, scaling principles, which means that it satisfies the
provides a powerful platform for working with signals principles of linearity and time-invariance. These
due to its extensive toolboxes and built-in functions. principles are essential for modeling and analyzing a
wide range of real-world systems accurately.
In this lab, we will delve into the world
Convolution is a fundamental mathematical operation Using MATLAB for Linear/Discrete Convolution:
with widespread applications in various fields, including
signal processing, image processing, and machine
learning. It is a mathematical operation that combines MATLAB, a powerful and widely-used software
two sequences to produce a third sequence. In the context platform for numerical computing, provides a
of linear and discrete convolution, we are dealing with straightforward and efficient way to perform
discrete sequences rather than continuous functions. linear/discrete convolution. Here's a brief overview of
Linear convolution is used to combine two discrete how you can use MATLAB to perform convolution:
sequences, typically denoted as x[n] and h[n], to produce • Defining Input Sequences: Start by defining the
a third sequence, y[n]. This operation is fundamental in two discrete sequences that you want to convolve.
signal processing for tasks like filtering, smoothing, and You can represent these sequences as arrays or
feature extraction. It is also essential in solving linear vectors in MATLAB.
time-invariant systems in engineering.
The basic idea behind linear convolution is to slide one • Applying the Convolution Function: MATLAB
sequence (usually x[n]) over the other (usually provides a built-in convolution function called
h[n]) while taking the sum of the element-wise products conv. You can use this function to perform linear
at each step. This process generates the output sequence convolution on your input sequences. The syntax
y[n], where each value of y[n] represents the convolution is typically:
of the two sequences at Result = conv(sequence1, sequence2);
Here, sequence1 and sequence2 are the arrays
representing your input sequences, and result will
contain the convolved output.

Signal Processing lab Department -Biomedical Engineering

 • Plotting the Result: To visualize the convolved
output, you can use MATLAB's plotting functions
like plot or stem to create graphs of the resulting III. PRACTICE QUESTIONS:
sequence. This step can help you understand the
Convolving two signals:
impact of the convolution operation on your
signals.
Code:
• Analyzing the Convolution: Once you have the
fs=20;
convolved output, you can analyze it to gain f=4;
insights into how the two input sequences interact. d1=10;
This analysis may involve identifying peaks, d2=20;
understanding shifts, or extracting relevant t1=0:1/fs:d1-1/fs;
information from the convolution result. t2=0:1/fs:d2-1/fs;
MATLAB's simplicity and extensive library of
x=sin(2*pi*f*t1);
h=sin(2*pi*f*t2);
functions make it a valuable tool for performing linear
subplot(3,2,1);
and discrete convolution, whether you are working with
stem(t1,x);
signals in the time domain, image processing, or any
subplot(3,2,2);
other application that involves discrete data. It enables stem(t2,h);
researchers and engineers to efficiently explore and d3=length(y)*1/fs;
understand the behavior of systems through convolution, t3=0:1/fs:d3-1/fs;
making it an indispensable tool in various scientific and y=conv(x,h);
engineering disciplines. subplot(3,2,3);
stem(t3,y);
In practice, when working with linear or discrete
convolution in MATLAB: Results:
• Ensure that you understand the mathematical
concepts and properties of convolution, such as
linearity, shift-invariance, and the convolution
theorem, as these principles are crucial for accurate
and meaningful results.

• Use MATLAB's built-in functions like conv or the

convolution theorem to perform convolution
efficiently and with minimal coding effort.

• Be aware of boundary effects and zero-padding

when dealing with finite-length signals, as these
can impact the convolution results.

• Consider optimization techniques or parallel

computing capabilities of MATLAB if you need to
perform convolution on large datasets or in real-
time applications.

• Always validate your results and consider the

implications of convolution on your specific
problem domain.
 IV. LAB TASKS:
Explanation:
Task:1-
Find convolution of two signals such that input is a This MATLAB code demonstrates the convolution of a
square signal and impulse response is the transient square wave signal with an impulse response and visualizes
the results. Let's break down the code step by step:
response of the capacitor [i.e A*exp(1/RC * t)]. Also
plot the three signals. 1. `A=1;%amplitude`, `R=1;% resistance`, `C=1;%
capacitance`, `f=2; %frequency`, and `fs=50;%sampling f`
Code: are variables defined to set various parameters. These
parameters define the amplitude, resistance, capacitance,
A=1;%amplitude frequency, and sampling frequency.
R=1;% resistance 2. `r=R*C; %time constant` calculates the time constant,
C=1;% capaciatance which is the product of resistance and capacitance.
f=2; %frequency 3. `t=linspace(0,10,100);` generates a time vector `t` that
fs=50;%sampling f ranges from 0 to 10 seconds with 100 evenly spaced points.
r=R*C; %timeconstant This vector will be used as the time axis for the signals.
t=linspace(0,10,100); 4. `input_signal=A*square(2*f*pi*t);` generates a square
%square signal wave signal using the `square` function. The square wave
input_signal=A*square(2*f*pi*t); has an amplitude `A`, a frequency `f`, and is defined over
subplot(2,2,1); the time vector `t`. This signal represents the input.
stem(t,input_signal); 5. `subplot(2,2,1);` sets up a subplot grid with 2 rows and 2
title('Square wave'); columns and selects the first subplot.
xlabel('Time'); 6. `stem(t,input_signal);` plots the input square wave on the
ylabel('Amplitude'); first subplot as a discrete-time signal.
%impulse exponential signal 7. `title('Square wave');`, `xlabel('Time');`, and
impulse=A*exp(1/r * t); `ylabel('Amplitude');` add titles and labels to the plot for
subplot(2,2,2); clarity.
stem(t,impulse); 8. Next, an impulse response signal is generated using
title('Impulse response'); `impulse=A*exp(1/r * t);`. This signal represents an impulse
xlabel('Time'); response of a system with the given time constant `r`.
ylabel('Amplitude'); 9. `subplot(2,2,2);` selects the second subplot.
y=conv(input_signal,impulse); 10. `stem(t,impulse);` plots the impulse response signal on
%CONVOLUTION the second subplot.
d=length(y)*1/fs; %DURTION 11. Similar to the previous subplot, titles and labels are
t1=0:1/fs:d-1/fs; % timescaling added for clarity.
subplot(2,2,3); 12. The convolution of the input signal and impulse
stem(t1,y); response is performed using
title('CONVOLUTION'); `y=conv(input_signal,impulse);`. This is the core of the
xlabel('Time'); code, where convolution is calculated.
ylabel('Amplitude'); 13. `d=length(y)*1/fs;` calculates the duration of the
convolution result by finding the length of the `y` vector and
dividing it by the sampling frequency `fs`.
Execution: 14. `t1=0:1/fs:d-1/fs;` creates a time vector `t1` that spans
the duration of the convolution result.
15. `subplot(2,2,3);` selects the third subplot.
16. `stem(t1,y);` plots the convolution result on the third
subplot.
17. Finally, titles and labels are added to the third subplot to
complete the visualization.

In summary, this code demonstrates how to generate and

convolve a square wave input signal with an impulse
response signal and visualize the convolution result using
MATLAB. It provides a visual representation of the
convolution operation and its impact on the signals
involved.
Task -2
Prove that convolution is commutative. (must attach Explanation:
plots of MATLAB)
In the provided MATLAB code, two signals (`x` and `y`)
are generated, and the code demonstrates the commutative
Code:
property of convolution by convolving these two signals in
f1=4;
fs=20; both orders (i.e., `x*y` and `y*x`). Let's break down the
a=2; code and explain the commutative property:
t=linspace(0,10,100);
%FORMATION FRIST SIGNAL; 1. `f1=4;`, `fs=20;`, `a=2;`, and `t=linspace(0,10,100);` are
x=a*sin(2*pi*f*t); variables and settings defined at the beginning of the code.
subplot(2,2,1); `f1` is not used in the code, and `fs` is the sampling
stem(t,x); frequency. `a` represents the amplitude, and `t` is the time
title('s1(sin)'); vector ranging from 0 to 10 seconds with 100 evenly
xlabel('Time'); spaced points.
ylabel('Amplitude');
%FORMATION OF SECOND SIGNAL 2. `x=a*sin(2*pi*f*t);` generates the first signal `x`, which
y=a*sawtooth(2*pi*f*t); is a sine wave with an amplitude of `a` and a frequency of
subplot(2,2,2); `f`. This signal is represented in the first subplot.
stem(t,y);
title('s2(sawtooth)'); 3. `subplot(2,2,1);` selects the first subplot in a 2x2 grid.
xlabel('Time');
ylabel('Amplitude'); 4. `stem(t,x);` plots the first signal `x` on the first subplot.
%convolving first and second
x_y=conv(x,y); 5. Similar steps are performed to generate and plot the
d1=length(x_y)*1/fs; second signal `y`, which is a sawtooth wave, in the second
t1=0:1/fs:d1-1/fs; subplot. This signal is generated using
subplot(2,2,3); `y=a*sawtooth(2*pi*f*t);`.
stem(t1,x_y);
title('s1*s2'); 6. The code then convolves `x` and `y` using
xlabel('Time'); `x_y=conv(x,y);` and calculates the duration of the
ylabel('Amplitude'); convolution result.
%convolving second and first
y_x=conv(y,x); 7. `t1=0:1/fs:d1-1/fs;` creates a time vector `t1` that spans
d2=length(y_x)*1/fs; the duration of the convolution result `x_y`.
t2=0:1/fs:d2-1/fs;
subplot(2,2,4); 8. `subplot(2,2,3);` selects the third subplot.
stem(t2,y_x);
title('s2*s1'); 9. `stem(t1,x_y);` plots the result of `x*y` (convolution of
xlabel('Time'); `x` and `y`) on the third subplot.
ylabel('Amplitude');
10. Finally, the code repeats the convolution process but in
Execution: the reverse order, i.e., `y_x=conv(y,x);`, and creates a time
vector `t2` for this result.

11. `subplot(2,2,4);` selects the fourth subplot.

12. `stem(t2,y_x);` plots the result of `y*x` (convolution of

`y` and `x`) on the fourth subplot.

Now, regarding the commutative property of convolution:

The commutative property states that the order of
convolution does not affect the result. In this code, you
can observe that `x*y` and `y*x` produce the same output
signals, which are shown in the third and fourth subplots,
respectively. This demonstrates the commutative property
of convolution, where the order of convolution does not
change the outcome, as long as the signals are linear and
time-invariant.
Task – 3 Explanation:
Explain the following graph in detail, also discuss the The provided MATLAB code generates and plots three
mathematical relationship. different signals: a decreasing exponential signal, a
square wave signal, and the convolution of these two
signals. Let's break down each part of the code and
Code: explain the resulting graph, along with the mathematical
% Define parameters relationship involved.
A = 200; % Amplitude
tau = 1; % Time constant (decay
1. Parameter Definition:
rate)
- `A = 200;`: This parameter sets the amplitude of the
d = 10; % Duration of the signal (in
exponential signal.
seconds)
- `tau = 1;`: It defines the time constant or decay rate
fs = 20; % Sampling rate (samples per
of the exponential signal.
second)
% Generate time vector - `d = 10;`: This variable specifies the duration of the
t = 0:1/fs:d-1/fs; signals in seconds.
% Generate decreasing exponential signal - `fs = 20;`: It sets the sampling rate in samples per
exponential_signal = A * exp(-t / tau); second.
% Plot the decreasing exponential signal
subplot(3,1,1); 2. Generate Time Vector:
stem(t, exponential_signal); - `t = 0:1/fs:d-1/fs;`: This line generates a time vector
title('Decreasing Exponential Signal'); `t` that spans from 0 to `d` seconds with a specified
xlabel('Time (s)'); sampling rate `fs`. It's used as the time axis for all the
ylabel('Amplitude'); signals.
%square signal
t1=0:1/fs:d-1/fs; 3. Generate Decreasing Exponential Signal:
input_signal=2*square(t1); - `exponential_signal = A * exp(-t / tau);`: This line
subplot(3,1,2); generates an exponential signal with an amplitude `A`, a
stem(t1,input_signal); time constant `tau`, and a duration of `d` seconds. It
title('Square wave'); represents the decay of a signal over time.
xlabel('Time');
ylabel('Amplitude'); 4. Plot the Decreasing Exponential Signal:
%convolution - `subplot(3,1,1);`: This line selects the first subplot in
y=conv(exponential_signal,input_signal); a 3x1 grid for plotting.
d2=length(y)*1/fs; - `stem(t, exponential_signal);`: It plots the generated
t2=0:1/fs:d2-1/fs; exponential signal on the first subplot.
subplot(3,1,3);
stem(t2,y); 5. Generate Square Wave Signal:
title('convolution(output)'); - `input_signal=2*square(t1);`: This line generates a
xlabel('Time'); square wave signal with an amplitude of 2 using the
ylabel('Amplitude'); `square` function. The signal is defined over the same
time vector `t1` used for the exponential signal.
Execution:
6. Plot the Square Wave Signal:
- `subplot(3,1,2);`: This selects the second subplot.
- `stem(t1,input_signal);`: It plots the square wave
signal on the second subplot.

7. Perform Convolution:
- `y=conv(exponential_signal,input_signal);`: This line
convolves the exponential signal with the square wave
signal using the `conv` function. Convolution is a
mathematical operation that combines two signals to
produce a third signal.

8. Calculate Time Vector for Convolution Result:

- `d2=length(y)*1/fs;`: This line calculates the duration
of the convolution result by finding the length of `y` and
dividing it by the sampling rate `fs`.
- `t2=0:1/fs:d2-1/fs;`: It generates a time vector `t2` for
the convolution result.
 9. Plot the Convolution Result:
- `subplot(3,1,3);`: This selects the third subplot. Execution:
- `stem(t2,y);`: It plots the convolution result on the third
subplot.

Mathematical Relationship:
The mathematical relationship demonstrated in this code
involves the convolution of an exponential signal and a square
wave signal. Convolution is a linear and time-invariant
operation. In this case, the convolution operation combines
the exponential decay behavior of the first signal with the
periodic square wave nature of the second signal.

The result of convolution is a new signal that represents how

the two input signals interact over time. In this specific case,
you'll notice that the convolution result shows the exponential
signal decaying and modulating with the square wave. The
exact shape of the output signal depends on the properties of
the input signals and their respective durations. Convolution is
widely used in signal processing and mathematics to model
the response of systems to input signals and is a fundamental Explanation:
concept in various fields. The code that is provided adds noise to a sinusoidal signal
and then reduces the noise using convolution.
Task – 4: • The first part of the code generates a simple
sinusoidal signal:
Suppose a sytem h(t) removes noise from the input
t = 0:0.01:2*pi;
signal sin(t). Find the output response y(t). x = sin(t);
Plot the three signals. • The next part of the code adds noise to the
h(t)= 1 ∞<t<∞ sinusoidal signal
x(t)= sin(t) nx = x + rand(1, length(t));
The rand() function generates a random number
Code: between 0 and 1. The rand(1, length(t)) function
%to add noice generates a vector of random numbers of the
t=0:0.01:2*pi; same length as the t vector. The noise signal is
x=sin(t); %simple sin then created by adding the random numbers to
subplot(4,1,1); the sinusoidal signal.
stem(t,x); • The next part of the code creates an impulse signal:
title('sin signal'); h = ones(1, 50);
xlabel('Time'); An impulse signal is a signal that has a value of 1
ylabel('Amplitude'); at a single point in time and 0 everywhere else.
nx=x+rand(1,length(t)); %noice The ones(1, 50) function creates a vector of 50
sinosidal ones. This creates an impulse signal with a
subplot(4,1,2); duration of 50 samples.
stem(t,nx); • The next part of the code reduces the noise in the
title('noice signal'); nx signal using convolution:
xlabel('Time'); y = conv(h, nx);
ylabel('Amplitude'); The conv() function performs linear convolution
h=ones(1,50);%from 1 to 50 value is 1% on two signals. In this case, the conv() function is
constant value used to convolve the impulse signal with the
subplot(4,1,3); noisy signal. This reduces the noise in the signal
stem(h); by averaging the values of the signal with its
title('impulse signal'); neighbors.
xlabel('Time'); • The last part of the code plots the output of the
ylabel('Amplitude'); convolution
%to reduce noice d3 = length(y)*1/fs;
y=conv(h,nx); %convolution t3 = 0:1/fs:d3-1/fs;
d3=length(y)*1/fs; subplot(4,1,4);
t3=0:1/fs:d3-1/fs; stem(t3, y);
subplot(4,1,4); title('output(noice free)');
stem(t3,y); xlabel('Time');
title('output(noice free)'); ylabel('Amplitude');
xlabel('Time');ylabel('Amplitude');
The d3 variable is the duration of the output signal in
seconds. The t3 vector is the time axis for the output signal. 6. Plot the Impulse Response:
The output signal is then plotted using the stem() function. subplot(4,1,3);
stem(h);
Overall, the code you provided shows how to add noise to title('Impulse Response');
a sinusoidal signal and then reduce the noise using xlabel('Time');
convolution. Convolution is a powerful technique for ylabel('Amplitude');
reducing noise in signals and images.
- The code creates the third subplot and plots the
impulse response, which is essentially a rectangular
Task-5: pulse of constant amplitude.
Explain the working algorithm of Convolution as
learned in task 4. 7. Perform Convolution to Reduce Noise:
y = conv(h, nx); % Convolution to reduce noise
This MATLAB code demonstrates the process of
adding noise to a sine wave signal, and then using - Convolution is performed between the impulse
convolution with an impulse response to reduce the response `h` and the noisy signal `nx`. Convolution
noise. Let's break down the code step by step: combines these signals to create a new signal `y`.
1. Generate Time Vector and Simple Sinusoidal
Signal: 8. Calculate Time Vector for Convolution Result
t = 0:0.01:2*pi; d3 = length(y) * 0.01; % Duration of the convolution
x = sin(t); % Simple sine wave signal result
t3 = 0:0.01:d3-0.01; % Time vector for the
- `t` is a time vector ranging from 0 to 2π seconds convolution result
with a sampling interval of 0.01 seconds.
- `x` is a simple sinusoidal signal generated using 9. Plot the Noise-Reduced Output:
the `sin` function.
subplot(4,1,4);
2. Plot the Simple Sinusoidal Signal: stem(t3, y);
subplot(4,1,1); title('Output (Noise-Free)');
stem(t, x); xlabel('Time');
title('Sinusoidal Signal'); ylabel('Amplitude');
xlabel('Time'); ```
ylabel('Amplitude'); - The code creates the fourth subplot and plots the
result of the convolution, which represents the noise-
- This code creates the first subplot and plots the reduced output.
simple sine wave signal.

3. Add Noise to the Signal

nx = x + rand(1, length(t)); % Noisy sinusoidal Explanation and Mathematical Relationship:
signal ➢ The code starts with a simple sinusoidal signal
(`x`), and then noise is added to it (`nx`) by adding
- Here, random noise is added to the original signal random values. This simulates a noisy signal,
`x` to create a noisy version `nx`. The `rand` function which could be encountered in real-world
generates random values between 0 and 1. applications.
➢ To reduce the noise, convolution is used with an
4. Plot the Noisy Signal: impulse response (`h`). Convolution effectively
subplot(4,1,2); averages the noisy signal over a window defined by
stem(t, nx); the impulse response, effectively smoothing out the
title('Noisy Signal'); noise.
xlabel('Time'); ➢ The output of the convolution (`y`) represents the
ylabel('Amplitude'); signal with reduced noise. The convolution
``` operation acts as a filter, emphasizing the
- The code creates the second subplot and plots the underlying structure (in this case, the sinusoidal
noisy signal. component) and reducing the influence of the
random noise.
5. Generate Impulse Response (Constant Signal): ➢ This code demonstrates a basic example of how
convolution can be used for noise reduction in a
h = ones(1, 50); % Impulse response (constant signal processing context, showcasing the
signal) mathematical concept of convolution as a filtering
- `h` is defined as a constant signal with 50 samples, operation
each having a value of 1.
Working Algorithm Illustration:
IV. CONCLUSIONS:

MATLAB offers a powerful and accessible platform for

implementing linear or discrete convolution, making it
an essential tool for anyone working in signal processing
or related fields. Proper understanding and utilization of
MATLAB's convolution capabilities can significantly
enhance your ability to analyze and process discrete
signals effectively. In short, MATLAB is a valuable tool
for performing linear or discrete convolutions. It
simplifies the process, offers built-in functions like conv,
and provides a user-friendly environment.
Discrete convolution is commonly used to filter noisy Understanding convolution concepts and handling
signals for several reasons: boundary effects are essential. MATLAB's capabilities
are especially useful for signal processing tasks.
Noise Reduction: The primary purpose of using
convolution in signal processing is to reduce the impact of
noise on a signal. Noise is often considered as unwanted V. REFRENCES:
variations or random disturbances in a signal. By
convolving the noisy signal with an appropriate filter [1]. "Digital Signal Processing Using MATLAB" by
(impulse response), it's possible to emphasize the signal's Vinay K. Ingle and John G. Proakis
desired components while attenuating the noise components
. [2]. "Signals and Systems: A Primer with MATLAB"
Frequency Domain Manipulation: Convolution in the by Matthew N. O. Sadiku
time domain corresponds to multiplication in the frequency
domain. This property allows you to design filters that target [3]. "MATLAB for Engineers" by Holly Moore
specific frequency ranges, effectively isolating the noise
frequencies and removing or reducing them. [4]. "Digital Signal Processing: Principles, Algorithms,
and Applications" by John G. Proakis and
Linear and Time-Invariant (LTI) Systems: Many real- Dimitris K. Manolakis
world systems can be modeled as linear and time-invariant
systems, meaning that their behavior is predictable and
consistent over time. Convolution is a mathematical
operation that accurately describes how LTI systems
transform input signals into output signals. This makes it a
suitable tool for modeling and processing signals in various
fields, including communications, audio processing, and
image processing.

Filter Design Flexibility: Convolution allows you to design

a wide range of filters, including low-pass, high-pass, band-
pass, and notch filters, among others. Each type of filter can
be tailored to address specific noise characteristics or signal
requirements.

Localized Signal Processing: Convolution processes

signals in a localized manner, considering a limited time
window defined by the filter's impulse response. This
enables you to focus on a specific portion of the signal,
which can be advantageous when dealing with non-
stationary signals or signals with varying noise
characteristics.

Real-Time and Offline Processing: Convolution can be

implemented in real-time or offline, depending on the
application. Real-time convolution is often used in systems
that require immediate processing of incoming data streams,
such as audio and video processing. Offline convolution is
used for batch processing and post-processing tasks.