Visualize and compare multiple signals and spectra

The **Signal Analyzer** app is an interactive tool for visualizing,
preprocessing, measuring, analyzing, and comparing signals in the time domain, in the
frequency domain, and in the time-frequency domain. Using the app, you
can:

Easily access all the signals in the MATLAB

^{®}workspaceSmooth, filter, resample, detrend, duplicate, extract, and rename signals without leaving the app

Add and apply custom preprocessing functions

Visualize and compare multiple waveform, spectrum, persistence, spectrogram, and scalogram representations of signals simultaneously

Label signals interactively for analysis or for machine learning and deep learning applications

The **Signal Analyzer** app provides a way to work with many signals of varying
durations at the same time and in the same view.

For more information, see **Using Signal Analyzer App.**

You need a Wavelet Toolbox™ license to use the scalogram view.

MATLAB Toolstrip: On the

**Apps**tab, under**Signal Processing and Communications**, click the app icon.MATLAB command prompt: Enter

`signalAnalyzer`

.

Implement a basic digital music synthesizer and use it to play a traditional song in a three-voice arrangement. Specify a sample rate of 2 kHz. Save the song as a MATLAB® timetable.

fs = 2e3; t = 0:1/fs:0.3-1/fs; l = [0 130.81 146.83 164.81 174.61 196.00 220 246.94]; m = [0 261.63 293.66 329.63 349.23 392.00 440 493.88]; h = [0 523.25 587.33 659.25 698.46 783.99 880 987.77]; note = @(f,g) [1 1 1]*sin(2*pi*[l(g) m(g) h(f)]'.*t); mel = [3 2 1 2 3 3 3 0 2 2 2 0 3 5 5 0 3 2 1 2 3 3 3 3 2 2 3 2 1]+1; acc = [3 0 5 0 3 0 3 3 2 0 2 2 3 0 5 5 3 0 5 0 3 3 3 0 2 2 3 0 1]+1; song = []; for kj = 1:length(mel) song = [song note(mel(kj),acc(kj)) zeros(1,0.01*fs)]; end song = song'/(max(abs(song))+0.1); % To hear, type sound(song,fs) tune = timetable(seconds((0:length(song)-1)'/fs),song);

Open **Signal Analyzer** and drag the timetable from the Workspace browser to the Signal table. Click **Display Grid** ▼ to create a two-by-two grid of displays. Select the top two displays and the lower left display and click the **Spectrum** button to add a spectrum view. Select the lower right display, click **Time-Frequency** to add a spectrogram view, and click **Time** to remove the time view. Drag the song to all four displays. Select the lower right display, and in the **Spectrogram** tab, specify a time resolution of 0.31 second (310 ms) and 0% overlap between adjoining segments. Set the **Power Limits** to $-50$ dB and $-10$ dB.

On the **Analyzer** tab, click **Duplicate** three times to create three copies of the song. Rename the copies as `high`

, `medium`

, and `low`

by double-clicking the **Name** column in the Signal table. Move the copies to the top two and lower left displays.

Preprocess the duplicate signals using filters.

Select the

`high`

signal by clicking its name in the Signal table. On the**Analyzer**tab, click**Highpass**. On the**Highpass**tab that appears, enter a passband frequency of 450 Hz and increase the steepness to 0.95. Click**Highpass**.Select the

`medium`

signal by clicking its name in the Signal table. On the**Analyzer**tab, click**Preprocessing**▼ and select**Bandpass**. On the**Bandpass**tab that appears, enter 230 Hz and 450 Hz as the lower and upper passband frequencies, respectively. Increase the steepness to 0.95. Click**Bandpass**.Select the

`low`

signal by clicking its name in the Signal table. On the**Analyzer**tab, click**Lowpass**. On the**Lowpass**tab that appears, enter a passband frequency of 230 Hz and increase the steepness to 0.95. Click**Lowpass**.

On each of the three displays containing filtered signals:

Remove the original signal by clearing the check box next to its name.

On the

**Display**tab, click**Time-Frequency**to add a spectrogram view and click**Time**to remove the time view.On the

**Spectrogram**tab, specify a time resolution of 0.31 second and 0% overlap between adjoining segments. Set the**Power Limits**to $-50$ dB and $-10$ dB.

Select the three filtered signals by clicking their **Name** column in the Signal table. On the **Analyzer** tab, click **Export** and save the signals to a MAT-file called `music.mat`

. In MATLAB, load the file to the workspace. Plot the spectra of the three signals.

load music pspectrum(low) hold on pspectrum(medium) pspectrum(high) hold off

% To hear the different voices, type % sound(low.low,fs), pause(5), sound(medium.medium,fs), pause(5), sound(high.high,fs)

This example simulates the different steps of a basic communication process. Communication systems work by modulating chunks of information into a higher *carrier frequency*, transmitting the modulated signals through a noisy physical channel, receiving the noisy waveforms, and demodulating the received signals to reconstruct the initial information.

All the information carried in a real-valued signal $\mathit{s}\left(\mathit{t}\right)$ can be represented by a corresponding lowpass *complex envelope*:

$\mathit{s}\left(\mathit{t}\right)=\mathrm{Re}\left\{\mathit{g}\left(\mathit{t}\right){\mathit{e}}^{\mathit{j}2\pi {\mathit{f}}_{\mathrm{c}}\mathit{t}}\right\}=\mathit{i}\left(\mathit{t}\right)\mathrm{cos2}\text{\hspace{0.17em}}\pi \text{\hspace{0.17em}}{\mathit{f}}_{\mathit{c}}\mathit{t}+\mathit{q}\left(\mathit{t}\right)\mathrm{sin2}\text{\hspace{0.17em}}\pi \text{\hspace{0.17em}}{\mathit{f}}_{\mathit{c}}\mathit{t}$.

In this equation:

${\mathit{f}}_{\mathrm{c}}$ is the carrier frequency

*.*$Re$ represents the real part of a complex-valued quantity.

$\mathit{g}\left(\mathit{t}\right)=\mathit{i}\left(\mathit{t}\right)+\mathit{jq}\left(\mathit{t}\right)$is the complex envelope of $\mathit{s}\left(\mathit{t}\right)$.

$\mathit{i}\left(\mathit{t}\right)$ is the

*inphase*component of the complex envelope.$\mathit{q}\left(\mathit{t}\right)$ is the

*quadrature*component of the complex envelope.

The complex envelope is modulated to the carrier frequency and sent through the channel. At the receiver, the noisy waveform is demodulated using the carrier frequency.

The phase variation due to the carrier frequency is predictable and thus does not convey any information. The complex envelope does not include the phase variation and can be sampled at a lower rate.

Generate a signal whose complex envelope consists of a sinusoid and a chirp. The inphase component is a sinusoid with a frequency of 19 Hz. The quadrature component is a quadratic chirp whose frequency ranges from 61 Hz to 603 Hz. The signal is sampled at 2 kHz for 1 second.

```
fs = 2e3;
t = (0:1/fs:1-1/fs)';
inph = sin(2*pi*19*t);
quad = chirp(t-0.6,61,t(end),603,'quadratic');
```

Compute the complex envelope and store it as a MATLAB® timetable of sample rate `fs`

.

```
env = inph + 1j*quad;
g = timetable(env,'SampleRate',fs);
```

Open **Signal Analyzer** and drag the complex envelope from the Workspace browser to the Signal table. The display shows the inphase and quadrature components of the envelope as lines of the same hue and saturation, but different luminosity. The first line color represents the inphase component and the second line color represents the quadrature component. Click **Spectrum** ▼ on the **Display** tab and select `Spectrum`

. The app displays a set of axes with the signal spectrum. The complex envelope has a two-sided spectrum, displayed as a line of the same color of the inphase component of the complex envelope.

On the **Display** tab, click **Panner** to activate the panner. Use the panner to create a zoom window between 300 ms and 720 ms. Drag the zoom window so that it is centered at 0 Hz. The spectrum has an impulse at 0.19 kHz and a wider tapering profile at higher frequencies. The negative-frequency region of the spectrum is a mirror image of the positive-frequency region.

Modulate the signal using a carrier frequency of 200 Hz. Multiply by $\sqrt{2}$ so that the power of the modulated signal equals the power of the original signal. Add white Gaussian noise such that the signal-to-noise ratio is 40 dB.

```
fc = 200;
mod = sqrt(2)*real(env.*exp(2j*pi*fc*t));
SNR = 40;
mod = mod + randn(size(mod))*std(mod)/db2mag(SNR);
s = timetable(mod,'SampleRate',fs);
```

Click **Display Grid** ▼ to add a second display. Drag the modulated signal to the Signal table and enter the time information. The modulation has moved the spectrum to positive frequencies centered on the carrier frequency.

Calculate the analytic signal and demodulate the signal by multiplying the analytic signal with a complex-valued negative exponential of frequency 200 Hz.

dem = hilbert(mod).*exp(-2j*pi*fc*t)/sqrt(2);

Click **Display Grid** ▼ to create a three-by-one grid of displays. Drag the demodulated signal to the Signal table. Add time information to the complex envelope by clicking **Time Values** in the **Analyzer** tab. The two-sided spectrum shows the recovered inphase and quadrature components of the baseband signal.

Click **Display Grid** ▼ to create a one-by-one grid of displays and plot the demodulated signal. Click **Data Cursors** ▼ and select `Two`

. Place the time-domain cursors at 300 ms and 900 ms, so they enclose the spectral peaks. Click **Extract Signals** ▼ and select `Between Time Cursors`

. Check the **Preserve Start Time** box. Clear the display and plot the extracted signal. The app extracts both inphase and quadrature components of the demodulated signal in the region of interest. Select the extracted signal by clicking its **Name** column in the Signal table. On the **Analyzer** tab, click **Export** and save the signal to a MAT-file called `dem_ROI.mat`

.

Load the `dem_ROI`

file to the workspace. Compute the demodulated inphase and quadrature components by taking the real and imaginary parts of the extracted signal. Store the time information of the extracted signal in a time variable `t_dem`

.

```
load dem_ROI
inph_dem = real(dem_ROI);
quad_dem = imag(dem_ROI);
t_dem = 0.3+(0:length(dem_ROI)-1)/fs;
```

Compare the transmitted waveforms and the extracted regions of interest. Also compare their spectra.

subplot(2,1,1) plot(t,inph,t_dem,inph_dem,'--') legend('Transmitted Inphase Signal','Received Inphase Signal') subplot(2,1,2) plot(t,quad,t_dem,quad_dem,'--') legend('Transmitted Quadrature Signal','Received Quadrature Signal')

figure subplot(2,1,1) pspectrum(inph,fs) hold on pspectrum(inph_dem,fs) legend('Transmitted Inphase Signal','Received Inphase Signal') hold off subplot(2,1,2) pspectrum(quad,fs) hold on pspectrum(quad_dem,fs) legend('Transmitted Quadrature Signal','Received Quadrature Signal') hold off

Load a datafile containing an echolocation pulse emitted by a big brown bat (*Eptesicus fuscus*) and measured with a sampling interval of 7 microseconds. Create a MATLAB® timetable using the signal and the time information.

```
load batsignal
t = (0:length(batsignal)-1)*DT;
sg = timetable(seconds(t)',batsignal);
```

Open **Signal Analyzer** and drag the timetable from the Workspace browser to the Signal table. Click **Display Grid** ▼ to create two side-by-side displays. Select each display and click the **Time-Frequency** button to add a spectrogram view.

Drag the timetable to both displays.

Select the **Spectrogram** tab. On the display at right, check **Reassign**. For each display:

Set the time resolution to 280 microseconds and specify 85% overlap between adjoining segments.

Use the

**Leakage**slider to increase the leakage until the RBW is about 4.5 kHz.Set the power limits to –45 dB and –20 dB.

The reassigned spectrogram clearly shows three time-frequency ridges. To track the ridges, select the display at right. On the **Display** tab, click **Generate Script** and select `Spectrogram Script`

. The script appears in the Editor.

% Compute spectrogram % Generated by MATLAB(R) 9.7 and Signal Processing Toolbox 8.2. % Generated on: 26-Dec-2018 17:21:44 % Parameters timeLimits = seconds([0 0.002793]); % seconds frequencyLimits = [0 71428.57]; % Hz leakage = 0.9; timeResolution = 0.00028; % seconds overlapPercent = 85; reassignFlag = true; %% % Index into signal time region of interest sg_batsignal_ROI = sg(:,'batsignal'); sg_batsignal_ROI = sg_batsignal_ROI(timerange(timeLimits(1),timeLimits(2),'closed'),1); % Compute spectral estimate % Run the function call below without output arguments to plot the results [P,F,T] = pspectrum(sg_batsignal_ROI, ... 'spectrogram', ... 'FrequencyLimits',frequencyLimits, ... 'Leakage',leakage, ... 'TimeResolution',timeResolution, ... 'OverlapPercent',overlapPercent, ... 'Reassign',reassignFlag);

Run the script. Plot the reassigned spectrogram.

mesh(seconds(T),F,P) xlabel('Time') ylabel('Frequency') axis tight view(2) colormap pink

Use the `tfridge`

function to track the ridges.

[fridge,~,lridge] = tfridge(P,F,0.01,'NumRidges',3,'NumFrequencyBins',10); hold on plot3(seconds(T),fridge,P(lridge),':','linewidth',3) hold off

Thanks to Curtis Condon, Ken White, and Al Feng of the Beckman Center at the University of Illinois for the bat data and permission to use it in this example.

Sensors can return clipped readings if the data are larger than a given saturation point. To reconstruct the readings, you can fit a polynomial through the points adjacent to the saturated intervals. Write a function that performs the reconstruction and integrate it into **Signal Analyzer**.

Generate a three-channel signal sampled at 1 kHz for 14 seconds. The signal has several peaks of varying sizes and shapes. A sensor that reads the signal saturates at 0.1 V.

fs = 1000; t = 0:1/fs:14-1/fs; sig = [chirp(t-1,0.1,17,2,'quadratic',1).*sin(2*pi*t/5); chirp(t-2,2,2,2.1,'quadratic',100).*exp(-(t-6.5).^2/20).*sin(2*pi*t*2); 0.85*besselj(0,5*(sin(2*pi*(t+1.5).^2/20).^2)).*sin(2*pi*t/9)]'; sigsat = sig; stv = 0.1; sigsat(sigsat >= stv) = stv;

Open **Signal Analyzer** and drag the original signal and the saturated signal to the Signal table. Drag each original and saturated channel to its own display.

Write a function that uses a polynomial to reconstruct the signal peaks:

The first input argument,

`x`

, is the input signal. This argument must be a vector and is treated as a single channel.The second input argument,

`tIn`

, is a vector of time values. The vector must have the same length as the signal. If the input signal has no time information, the function reads this argument as an empty array.Use

`varargin`

to specify additional input arguments. If you do not have additional input arguments, you can omit`varargin`

. Enter the additional arguments as an ordered comma-separated list in the**Preprocess**tab.The first output argument,

`y`

, is the preprocessed signal.The second output argument,

`tOut`

, is a vector of output time values. If the input signal has no time information,`tOut`

is returned as an empty array.To implement your algorithm, you can use any MATLAB® or Signal Processing Toolbox™ function.

function [y,tOut] = declip(x,tIn,varargin) % Declip saturated signal by fitting a polynomial % Initialize the output signal y = x; % For signals with no time information, use sample numbers as abscissas if isempty(tIn) tOut = []; t = (1:length(x))'; else t = tIn; tOut = t; end % Specify the degree of the polynomial as an optional input argument % and provide a default value of 4 if nargin<3 ndx = 4; else ndx = varargin{1}; end % To implement your algorithm, you can use any MATLAB or Signal % Processing Toolbox function % Find the intervals where the signal is saturated and generate an % array containing the interval endpoints idx = find(x==max(x)); fir = [true;diff(idx)~=1]; ide = [idx(fir) idx(fir([2:end 1]))]; % For each interval, fit a polynomial of degree ndx over the ndx+1 points % before the interval and the ndx+1 points after the interval for k = 1:size(ide,1) bef = ide(k,1); aft = ide(k,2); intv = [bef-1+(-ndx:0) aft+1+(0:ndx)]; [pp,~,mu] = polyfit(t(intv),x(intv),ndx); y(bef:aft) = polyval(pp,t(bef:aft),[],mu); end end

Add the function to **Signal Analyzer** as a custom preprocessing function. On the **Analyzer** tab, click **Preprocessing** ▼ and select **Add Custom Function**. Input the function name and description. Paste the text of your function in the editor window that appears. Save the file. The function appears in the preprocessing gallery.

Demonstrate that the function you created reconstructs the saturated regions.

Select the first channel of the saturated signal in the Signal table.

On the

**Analyzer**tab, click**Preprocessing**▼ and select**declip**.On the

**Preprocessing**tab that appears, click**Preprocess**.

Verify that the preprocessing function works when the signals have time information.

Select

`sig`

and`sigsat`

in the Signal table. Do not select individual channels.On the

**Analyzer**tab, click**Time Values**, select`Sample Rate and Start Time`

, and specify`fs`

as the sample rate.The signal in the top panel, including the reconstructed regions, has time information.

Check that the function works when you specify optional inputs.

Select the second and third channels of the saturated signal in the Signal table.

On the

**Preprocessing**tab, enter`8`

in the**Arguments**field and click**Preprocess**. The preprocessing function uses a polynomial of degree 8 to reconstruct the saturated regions.

Use **Signal Analyzer** to compute the envelope spectrum of a bearing vibration signal and look for defects. Generate MATLAB® scripts and functions to automate the analysis.

**Generate Bearing Vibration Data**

A bearing with the dimensions shown in the figure is driven at ${\mathit{f}}_{0}=25$ cycles per second. An accelerometer samples the bearing vibrations at 10 kHz.

Generate vibration signals from two defective bearings using the `bearingdata`

function at the end of the example. In one of the signals, `xBPFO`

, the bearing has a defect in the outer race. In the other signal, `xBPFI`

, the bearing has a defect in the inner race. For more details on modeling and diagnosing defects in bearings, see Vibration Analysis of Rotating Machinery and `envspectrum`

.

[t,xBPFO,xBPFI,bpfi] = bearingdata;

**Compute Envelope Spectrum Using Signal Analyzer**

Open **Signal Analyzer** and drag the BPFO signal to a display. Add time information to the signal by selecting it in the Signal table and clicking the **Time Values** button on the **Analyzer** tab. Select the `Sample Rate and Start Time`

option and enter the 10 kHz sample rate.

On the **Display** tab, click **Spectrum** to open a spectrum view. The spectrum of the vibration signal shows BPFO harmonics modulated by the 3 kHz impact frequency. At the low end of the spectrum, the driving frequency and its orders obscure other features.

Select the signal and, on the **Analyzer** tab, click **Duplicate** to generate a copy of it. Give the new signal the name `envspec`

and drag it to the display. Compute the envelope spectrum of the signal using the Hilbert transform:

Remove the DC value of the signal. On the

**Analyzer**tab, click**Preprocessing**▼ and select**Detrend**. On the**Detrend**tab that appears, select`Constant`

as the method. Click**Detrend**.Bandpass-filter the detrended signal. On the

**Analyzer**tab, click**Preprocessing**▼ and select**Bandpass**. On the**Bandpass**tab that appears, enter 2250 Hz and 3750 Hz as the lower and upper passband frequencies, respectively. Click**Bandpass**.Compute the envelope of the filtered signal. On the

**Analyzer**tab, click**Preprocessing**▼ and select**Envelope**. On the**Envelope**tab that appears, select`Hilbert`

as the method. Click**Envelope**.Remove the DC value of the envelope using

**Detrend**.

The envelope spectrum appears in the spectrum view of the display. The envelope spectrum clearly displays the BPFO harmonics.

**Steps to Create an Integrated Analysis Script**

The computation of the envelope spectrum can get tedious if it has to be repeated for many different bearings. **Signal Analyzer** can generate MATLAB® scripts and functions to help you automate the computation.

As an exercise, repeat the previous analysis for the BPFI signal. **Signal Analyzer** generates two components useful for the automation:

A function that preprocesses the signal by detrending it, filtering it, and computing its envelope

A script that computes the envelope spectrum

To create the integrated analysis script, put the preprocessing function and the plotting script together unchanged in a single file. (Alternatively, you can save functions in separate files.)

If you save the script and the function in a single MATLAB® script, keep in mind that functions must appear at the end.

You must add the keyword

`end`

at the end of each function.

**1. Create Preprocessing Function**

Initially, create the function that reproduces the preprocessing steps. Select the `envspec`

signal. On the **Analyzer** tab, click **Generate Function**. The function, called `preprocess`

by default, appears in the Editor. Save the generated function at the end of your integrated analysis script. The function expects a second argument specifying the time information. Preprocess the BPFI signal using the function.

envspec = preprocess(xBPFI,t);

**2. Create Spectrum Script**

In the app, remove the unprocessed signal from the display by clearing the check box next to its name. On the **Display** tab, click **Generate Script **▼ and select `Spectrum Script`

. The script appears in the Editor. Include the generated code in your integrated analysis script. When you run the analysis script, the generated spectrum script computes the envelope spectrum of the preprocessed BPFI signal.

% Compute power spectrum % Generated by MATLAB(R) 9.6 and Signal Processing Toolbox 8.2. % Generated on: 12-Nov-2018 15:13:34 % Parameters timeLimits = [0 0.9999]; % seconds frequencyLimits = [0 5000]; % Hz %% % Index into signal time region of interest envspec_ROI = envspec(:); sampleRate = 10000; % Hz startTime = 0; % seconds minIdx = ceil(max((timeLimits(1)-startTime)*sampleRate,0))+1; maxIdx = floor(min((timeLimits(2)-startTime)*sampleRate,length(envspec_ROI)-1))+1; envspec_ROI = envspec_ROI(minIdx:maxIdx); % Compute spectral estimate % Run the function call below without output arguments to plot the results [Penvspec_ROI, Fenvspec_ROI] = pspectrum(envspec_ROI,sampleRate, ... 'FrequencyLimits',frequencyLimits);

**3. Plot Envelope Spectrum**

Plot the envelope spectrum. Compare the peak locations to the frequencies of the first ten BPFI harmonics. You can also plot the envelope spectrum using the `pspectrum`

command with no output arguments.

plot(Fenvspec_ROI,(Penvspec_ROI)) hold on [X,Y] = meshgrid((1:10)*bpfi,ylim); plot(X,Y,':k') hold off xlim([0 10*bpfi])

**Function Code**

**Signal Preprocessing Function**

The signal preprocessing function generated by the app combines detrending, bandpass filtering, and envelope computation.

function y = preprocess(x,tx) % Preprocess input x % This function expects an input vector x and a vector of time values % tx. tx is a numeric vector in units of seconds. % Generated by MATLAB(R) 9.6 and Signal Processing Toolbox 8.2. % Generated on: 12-Nov-2018 15:09:44 y = detrend(x,'constant'); Fs = 1/mean(diff(tx)); % Average sample rate y = bandpass(y,[2250 3750],Fs,'Steepness',0.85,'StopbandAttenuation',60); [y,~] = envelope(y); y = detrend(y,'constant'); end

**Bearing Data Generating Function**

The bearing has pitch diameter $\mathit{p}=12$ cm and a bearing contact angle $\theta =0$. Each of the $\mathit{n}=8$ rolling elements has a diameter $\mathit{d}=2$ cm. The outer race remains stationary as the inner race is driven at ${\mathit{f}}_{0}=25$ cycles per second. An accelerometer samples the bearing vibrations at 10 kHz.

```
function [t,xBPFO,xBPFI,bpfi] = bearingdata
p = 0.12;
d = 0.02;
n = 8;
th = 0;
f0 = 25;
fs = 10000;
```

For a healthy bearing, the vibration signal is a superposition of several orders of the driving frequency, embedded in white Gaussian noise.

t = 0:1/fs:1-1/fs; z = [1 0.5 0.2 0.1 0.05]*sin(2*pi*f0*[1 2 3 4 5]'.*t); xHealthy = z + randn(size(z))/10;

A defect in the outer race causes a series of 5 millisecond impacts that over time result in bearing wear. The impacts occur at the ball pass frequency outer race (BPFO) of the bearing,

$\mathrm{BPFO}=\frac{1}{2}{\mathit{nf}}_{0}\left[1-\frac{\mathit{d}}{\mathit{p}}\mathrm{cos}\text{\hspace{0.17em}}\theta \right]$.

Model the impacts as a periodic train of 3 kHz exponentially damped sinusoids. Add the impacts to the healthy signal to generate the BPFO vibration signal.

bpfo = n*f0/2*(1-d/p*cos(th)); tmp = 0:1/fs:5e-3-1/fs; xmp = sin(2*pi*3000*tmp).*exp(-1000*tmp); xBPFO = xHealthy + pulstran(t,0:1/bpfo:1,xmp,fs)/4;

If the defect is instead in the inner race, the impacts occur at a frequency

$\mathrm{BPFI}=\frac{1}{2}{\mathit{nf}}_{0}\left[1+\frac{\mathit{d}}{\mathit{p}}\mathrm{cos}\text{\hspace{0.17em}}\theta \right]$.

Generate the BPFI vibration signal by adding the impacts to the healthy signals.

```
bpfi = n*f0/2*(1+d/p*cos(th));
xBPFI = xHealthy + pulstran(t,0:1/bpfi:1,xmp,fs)/4;
end
```

- Find Delay Between Correlated Signals
- Plot Signals from the Command Line
- Resolve Tones by Varying Window Leakage
- Analyze Signals with Inherent Time Information
- Spectrogram View of Dial Tone Signal
- Find Interference Using Persistence Spectrum
- Scalogram of Hyperbolic Chirp
- Resample and Filter a Nonuniformly Sampled Signal
- Extract Regions of Interest from Whale Song

`signalAnalyzer`

`signalAnalyzer`

opens the **Signal Analyzer**
app.

`signalAnalyzer(``sig`

)

`signalAnalyzer(`

opens the
`sig`

)**Signal Analyzer** app and imports and plots the signal
`sig`

. If the app is already open, then it plots
`sig`

in the current display. If `sig`

is
already plotted but has changed, then the function call updates the plot.

`sig`

can be a variable in the workspace or a MATLAB expression. `sig`

can be:

A vector or a matrix with independent signals in each column.

A

`timetable`

with time values specified as durations.A

`timeseries`

object.

See Data Types Supported by Signal Analyzer for more details.

By default, the app plots the signal as a function of sample index. If you provide time information, or if the signal has inherent time information, then the app plots the signal as a function of time.

`signalAnalyzer(``sig1,...,sigN`

)

`signalAnalyzer(`

imports
`sig1,...,sigN`

)*N* signal vectors or matrices and plots them in the current
display. The app does not support importing signals with inherent time information
and signals without inherent time information in the same function call.

`signalAnalyzer(___,'SampleRate',``fs`

)

`signalAnalyzer(___,'SampleRate',`

specifies a sample rate, `fs`

)`fs`

, as a positive scalar expressed in
Hz. The app uses the sample rate to plot one or more signals against time, assuming
a start time of zero. You can specify a sample rate for signals with no inherent
time information.

`signalAnalyzer(___,'SampleTime',``ts`

)

`signalAnalyzer(___,'SampleTime',`

specifies a sample time, `ts`

)`ts`

, as a positive scalar expressed in
seconds. The app uses the sample time to plot one or more signals against time,
assuming a start time of zero. You can specify a sample time for signals with no
inherent time information.

`signalAnalyzer(___,'StartTime',``st`

)

`signalAnalyzer(___,'StartTime',`

specifies a signal start time, `st`

)`st`

, as a scalar expressed in
seconds. If you do not specify a sample rate or sample time, then the app assumes a
sample rate of 1 Hz. You can specify a start time for signals with no inherent
time information.

`signalAnalyzer(___,'TimeValues',``tv`

)

`signalAnalyzer(___,'TimeValues',`

specifies a vector, `tv`

)`tv`

, with time values corresponding to the
data points. `tv`

can be a real numeric vector with values
expressed in seconds. `tv`

can also be a `duration`

array. The values in
`tv`

must be unique and cannot be `NaN`

, but
they need not be uniformly spaced. All input signals must have the same length as
`tv`

. You can specify a vector of time values for signals
with no inherent time information.

Filtering and scalogram view do not support nonuniformly sampled signals.

- Using Signal Analyzer App
- Edit Sample Rate and Other Time Information
- Data Types Supported by Signal Analyzer
- Spectrum Computation in Signal Analyzer
- Persistence Spectrum in Signal Analyzer
- Spectrogram Computation in Signal Analyzer
- Scalogram Computation in Signal Analyzer
- Keyboard Shortcuts for Signal Analyzer
- Signal Analyzer Tips and Limitations

A modified version of this example exists on your system. Do you want to open this version instead?

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

Select web siteYou can also select a web site from the following list:

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

- América Latina (Español)
- Canada (English)
- United States (English)

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)