Generating Basic Discrete Time Signals

Discrete time signals serve extensively in signal processing to analyze and interpret digital signals. Creating simple discrete time signals helps us to replicate and comprehend numerous signal kinds such as unit step, impulse, ramp, and sinusoidal signals.

Let us first define the four main discrete-time signals that are employed in signal analysis.

Unit Step Signal

The unit step signal is a basic and extensively used signal in signal analysis. It represents 0 for negative time indices and 1 for positive time indices.

Impulse Signal

These signals are also termed as Dirac delta function, they represent 0 for all time indices except for an infinity amplitude.

Ramp Signal

Ramp signals provide linear representation that starts at 0 value and increments at a fixed interval.

Sinusoidal Signal

These signals are represented in the form of waves having a fixed amplitude and frequency.

Import Libraries

Before writing a code you must import the following libraries to generate Discrete Signals

NumPy - Numpy is a well-structured and useful library for numerical computations, and performing operations to handle arrays.

Matplotlib: this library is used for generating visualizations.

Use the following command to install the required libraries.

pip install numpy matplotlib

Example

This example will show you how to create discrete signals of four common types using python. The code includes four basic functions each for generating a different kind of signal. The four basic methods are generate_unit_step, generate_impulse, generate_ramp, and generate_sinusoidal.

Each of these methods will take input parameters required to generate the signals and generate the signals arrays as return values. These signals are then plotted by using matplotlib methods.

Algorithm

Step 1: First of all select the signal type which you want to generate. In this example, we have selected four signals.

Step 2: Assign parameters of signals. The parameter values should include duration, amplitude, frequency, and phase.

Step 3: Create an empty array to store output arrays.

Step 4: Calculate the signal sample values according to signal type.

Step 5: Return the calculated signal arrays and store them in the empty array.

Step 6: Return the array and plot the signals on the output.

import numpy as np
import matplotlib.pyplot as plt

def generate_unit_step(duration):
   signal = np.ones(duration)
   return signal

def generate_impulse(duration, position):
   signal = np.zeros(duration)
   signal[position] = 1
   return signal

def generate_ramp(duration):
   signal = np.arange(0, duration)
   return signal

def generate_sinusoidal(duration, frequency, amplitude, phase):
   t = np.arange(0, duration)
   signal = amplitude * np.sin(2 * np.pi * frequency * t + phase)
   return signal

# Example usage
duration = 80
position = 40
frequency = 0.9
amplitude = 5.6
phase = np.pi/2

unit_step_signal = generate_unit_step(duration)
impulse_signal = generate_impulse(duration, position)
ramp_signal = generate_ramp(duration)
sinusoidal_signal = generate_sinusoidal(duration, frequency, amplitude, phase)

# Plotting the generated signals
plt.subplot(2, 2, 1)
plt.stem(unit_step_signal)
plt.title("Unit Step Signal")

plt.subplot(2, 2, 2)
plt.stem(impulse_signal)
plt.title("Impulse Signal")

plt.subplot(2, 2, 3)
plt.stem(ramp_signal)
plt.title("Ramp Signal")

plt.subplot(2, 2, 4)
plt.stem(sinusoidal_signal)
plt.title("Sinusoidal Signal")

plt.tight_layout()
plt.show()

Output

Conclusion

Someone who deals with digital signals analysis understands the importance of generating discrete-time signals. This article can help someone trying to use coding to generate some common signals ramp, sinusoidal, unit steps, and impulse.

The advanced libraries of python are used to generate the signals by giving basic input values. You may produce and modify numerous forms of discrete-time signals with these libraries and functions created above to do additional signal processing and analysis.