DEV Community: Md Sajib Pramanic

Exploring Discrete-Time Signals with MATLAB

Md Sajib Pramanic — Wed, 17 Sep 2025 20:45:08 +0000

When we talk about Digital Signal Processing (DSP), we often start with signals. A discrete-time signal is at the heart of many technologies around us. From IoT devices that collect sensor readings, to AI systems that analyze audio and images, signals help us represent, process, and make sense of real-world data. I learned that understanding these signals gives us the foundation to build smarter and more efficient systems.

In this post, I will walk through some basic discrete-time signals, show how I implemented them in MATLAB, and reflect on what we can learn.

Unit Impulse Signal

The unit impulse has value 1 at n=0 and 0 elsewhere. It is useful to test system response.

MATLAB Output:

Unit Step Signal

The unit step signal stays 0 for negative values and 1 from n=0 onward. I use it to represent sudden switching in systems.

MATLAB Output:

Ramp Signal

The discrete ramp increases linearly with time. I see it often in modeling growth or incremental processes.

MATLAB Output:

Exponential Signal

An exponential signal grows or decays depending on the base. I learned that it is useful for modeling charging/discharging or population growth.

MATLAB Output:

Signum Function

MATLAB Output:

Sinusoidal Signal

The sinusoidal signal oscillates between positive and negative values. We see it everywhere in communication and control systems.

MATLAB Output:

Reflection

By plotting and analyzing these signals, I now understand how discrete-time differs from continuous-time signals. A continuous signal flows smoothly, while a discrete signal has distinct sample points. This difference is critical in digital systems because computers and IoT devices only work with discrete values.

We, as learners or developers, should remember that DSP is not just theory. It powers real-world applications like speech recognition, medical imaging, and smart sensors in AI systems. By practicing with MATLAB, I can visualize these signals and connect the math with practical uses.

I believe that once you get comfortable with these basics, you will see DSP everywhere in your phone, car, or even in the devices at home.

Explore the GitHub code: Discrete-time signals

Basic Signals in MATLAB for IoT and AI

Md Sajib Pramanic — Wed, 17 Sep 2025 20:00:50 +0000

Introduction

As IoT, data, and AI engineers, we often deal with raw signals coming from sensors, devices, or communication systems. These signals are the foundation of everything we analyze, process, and use to make smart decisions. If we do not understand the basic signals, it becomes difficult to design reliable systems for data collection, filtering, or control. That is why I started learning how to generate and visualize fundamental continuous-time signals in MATLAB.

Walkthrough

I wrote a simple MATLAB script to generate six basic signals: unit impulse, unit step, unit ramp, exponential, signum, and sinc. These signals are like the alphabet of signal processing. Once you know them, you can combine them to build more complex systems.

In the code, I used the t variable to represent time, ranging from -5 to 5. Then I defined each signal using mathematical conditions or MATLAB’s built-in functions. For example, the unit step was defined with double(t>=0)`and the exponential signal with exp(a*t). I usedplot()andstem()` to visualize them.

Here is the MATLAB output for each signal:

Reflection

From this exercise, I learned how to represent and visualize the most common signals that appear in IoT and communication systems. The impulse helped me understand how systems respond instantly, while the step and ramp showed me how systems behave with sudden or gradual inputs. The exponential signal reminded me of natural processes like charging a capacitor or signal decay. The signum and sinc signals taught me about symmetry and oscillations in communication theory.

I now see how these basic signals are directly connected to real-world IoT systems. For example, when a sensor suddenly starts sending data, that is similar to a step function. When data decays over time, it looks like an exponential. By practicing with MATLAB, I feel more confident in connecting theory with the real IoT problems we solve every day.

From Analog to Digital: Signal Simulation

Md Sajib Pramanic — Sat, 06 Sep 2025 22:08:35 +0000

Have you ever wondered how your music, voice calls, or even video streams travel from the physical world into the digital devices we use every day? The answer lies in signal processing the art of converting an analog signal into a digital one.

In this post, I’ll walk you through a simple MATLAB simulation where I generate an analog sine wave, sample it, quantize it, and finally encode it into binary form. By the end, you’ll see how an analog signal transforms step by step into a digital stream.

1. Generating an Analog Signal

Let’s start with a simple sine wave of 100 Hz. Since MATLAB doesn’t truly handle “continuous” signals, I approximate it with a very fine time step:

t = 0:0.0001:0.01;       % very fine step (continuous-like time)
f = 100;                 % frequency = 100 Hz
x_analog = sin(2*pi*f*t);

plot(t, x_analog, 'LineWidth', 1.5);
title('Analog Signal (Sine Wave)');

This gives me the smooth curve — my reference signal.

2. Sampling

According to the Nyquist theorem, I need to sample at least twice the frequency of the signal (≥ 200 Hz).

I tested three cases:

150 Hz (below Nyquist) → aliasing and distortion
200 Hz (at Nyquist) → minimal capture, jagged
500 Hz (above Nyquist) → clean sampling, closer to analog

Fs = 500;   % try 150, 200, and 500
Ts = 1/Fs;
n = 0:Ts:0.01;
x_sampled = sin(2*pi*f*n);

stem(n, x_sampled, 'filled');
title(['Sampled Signal at Fs = ' num2str(Fs) ' Hz']);

3. Quantization

Next, I map the sampled values to discrete amplitude levels. Using more bits increases the number of levels:

8 bits → 256 levels
16 bits → 65,536 levels
64 bits → practically continuous

bits = 8;   % try 8, 16, and 64
levels = 2^bits;
x_min = min(x_sampled);
x_max = max(x_sampled);
q_step = (x_max - x_min)/levels;

x_index = round((x_sampled - x_min)/q_step);
x_quantized = x_index*q_step + x_min;

stem(n, x_quantized, 'filled');
title(['Quantized Signal (' num2str(bits) '-bit)']);

With fewer bits, you can clearly see stair-step distortions. As I increase the bits, the quantized signal becomes almost identical to the sampled one.

4. Encoding

Finally, each quantized value is represented as a binary word. For example, with 8 bits, each sample becomes an 8-bit binary code.

binary_codes = dec2bin(x_index, bits);
disp(binary_codes(1:10,:));   % first 10 codes

When concatenated, they form a digital bitstream — the format that computers and communication systems love.

Points

If you sample below Nyquist, you risk losing information (aliasing).
Increasing sampling rate improves signal quality but costs more data.
More quantization bits reduce distortion, but increase storage and bandwidth.
At the end, your “smooth” analog wave becomes a long sequence of 1s and 0s.

You can try experimenting with different frequencies and bit depths in your own code. It’s the best way to see how analog signals become digital and to appreciate the balance between accuracy and efficiency in real-world systems.