Generate timeseries data with MATLAB

MATLAB is a powerful tool for generating synthetic motion data for machine learning applications. With built-in functions such as the Signal Processing Toolbox and Image Processing Toolbox and capabilities, MATLAB makes it easy to simulate real-world sensor data, generate labelled datasets, and preprocess data for edge AI applications.

In this tutorial, you will learn how to:

Define simulation parameters (sampling frequency, signal duration, random seed).
Generate multiple motion classes (e.g., “idle,” “snake,” “up-down”).
Add realistic noise and emulate sensor characteristics.
Label data automatically in MATLAB.
Save your signals to CSV.
Import the labeled CSV into Edge Impulse.

Example: Generating continuous motion data (up-down snake wave and idle) in MATLAB

Below, we recreate a continuous motion sample project that could be used to test wearable sensors, monitor vibrations, or simulate small repetitive movements in an industrial setting.

You can also clone the public project dataset to follow along: MATLAB: Synthetic Data Generation - Continuous motion recognition.

MATLAB Online

You can run MATLAB entirely in the browser using MATLAB Online. This makes it easy to share your project, collaborate, or quickly try out scripts without installing anything locally.

Prerequisites

You will need:

A MATLAB license or MathWorks account to access MATLAB Online.
Our synthetic motion generation script see the public project description for the full script.

Getting Started

Open MATLAB or go to MATLAB Online.
Create a new Live Script (.mlx) or MATLAB script (.m).
Copy-paste the synthetic motion generation code or clone the public live script for continuous motion data.

Customizing parameters to simulate motion data

There are several parameters to consider when generating synthetic motion data. You can customize:

Sampling Frequency (fs): Controls how frequently data is sampled (e.g., 62.5 Hz).
Total Duration (t_end): How long the simulated signal is (e.g., 15 minutes).
Types of Motion:
- Up-Down Motion: Simple sinusoidal vertical oscillations.
- Snake Motion: Horizontal oscillation with amplitude modulation.
- Wave Motion: Circular or elliptical motion in the XY-plane.
Add realistic noise or drift to make the data look more authentic. Consider sensor-specific noise levels and random jitter.

In this basic example we generate a simple up-down motion, but you can extend this to include more complex motions or multiple classes of motion.

Script overview

Running the Script: Generates labeled time-series data (e.g., idle, snake, updown, wave). Save to CSV: The script automatically writes to motion_data.csv. Visualize: MATLAB’s plot and subplot functions help verify that the signals make sense.

Below is a minimal code snippet compare with your own script for advanced features:

% Clear workspace to start fresh
clear; clc;

% Sampling settings
fs = 62.5;
t_end = 15 * 60; 
t = 0:1/fs:t_end-1/fs; 

% Generate signals
jitter = 0.1 * randn(size(t));    % random noise
updown_z = 0.8 * sin(2*pi*0.5 * t) + jitter;  % up-down motion

% Combine or loop over motions
combined_data = [t' updown_z'];
csv_filename = 'motion_data.csv';
writematrix(combined_data, csv_filename);

disp(['Data saved as ', csv_filename]);

% Quick plot
figure;
plot(t, updown_z, 'LineWidth', 1.5);
xlabel('Time (s)');
ylabel('Amplitude');
title('Synthetic Up-Down Motion');

Multi-axis acc_x, acc_y, acc_z example

In many real applications, you have multiple axes (e.g., acc_x, acc_y, acc_z). You can extend the same logic for each axis:

rng(0); % For reproducibility
fs = 62.5;
t_end = 15; 
t = 0:1/fs:t_end-1/fs;

% Generate multiple axes
noise_x = 0.05*randn(size(t));
noise_y = 0.05*randn(size(t));
noise_z = 0.05*randn(size(t));

signal_x = sin(2*pi*1.0 * t) + noise_x;
signal_y = 0.5 * sin(2*pi*0.5 * t) + noise_y;
signal_z = 0.8 * sin(2*pi*0.2 * t) + noise_z;

combined_data_3axis = [t' signal_x' signal_y' signal_z'];

Generating and Labeling Multiple Classes

If you want to generate multiple classes like idle, snake, updown, wave you can segment your time vector and assign labels programmatically.

Here’s a minimal example:

% Clear workspace
clear; clc; rng(0); % set random seed

% Sampling settings
fs = 62.5;
t_end = 60; % 1 minute total for example
t = 0:1/fs:t_end-1/fs;

% Pre-allocate signal arrays
motion_signal = zeros(size(t));
labels = strings(size(t)); % label each sample

% Example: define time ranges for each motion
idle_duration = 10;      % first 10s idle
snake_duration = 20;     % next 20s snake
updown_duration = 30;    % last 30s up-down

% Generate Idle
idle_idx = t <= idle_duration;
motion_signal(idle_idx) = 0 + 0.05*randn(1, sum(idle_idx)); 
labels(idle_idx) = "idle";

% Generate Snake motion
snake_idx = t > idle_duration & t <= (idle_duration + snake_duration);
snake_t = t(snake_idx) - idle_duration;
motion_signal(snake_idx) = 0.3 * sin(2*pi*0.8 * snake_t) + 0.05*randn(size(snake_t));
labels(snake_idx) = "snake";

% Generate Up-Down motion
updown_idx = t > (idle_duration + snake_duration);
updown_t = t(updown_idx) - (idle_duration + snake_duration);
motion_signal(updown_idx) = 0.8 * sin(2*pi*0.5 * updown_t) + 0.1*randn(size(updown_t));
labels(updown_idx) = "updown";

% Combine data and labels into one matrix
combined_data = [t' motion_signal'];
csv_filename = 'motion_data.csv';

% Write numeric data
writematrix(combined_data, csv_filename);

% Write labels in a second file or append to CSV with e.g. "writetable" 
T = table(t', motion_signal', labels', 'VariableNames', {'time','motion','label'});
writetable(T, 'motion_data_labeled.csv');

disp(['Data saved as ', csv_filename, ' and motion_data_labeled.csv']);

% Quick plot
figure;
plot(t, motion_signal, 'LineWidth', 1.2);
xlabel('Time (s)');
ylabel('Amplitude');
title('Synthetic Multi-Class Motion');

In practice, you can repeat this process for each axis (e.g., x, y, z) and store all signals plus labels in a single table.

Benefits of using MATLAB for time-series data generation

Enhance Data Quality: Create reliable time-series signals that closely mimic real-world conditions.
Increase Dataset Diversity: Generate multiple classes of motion, from subtle vibrations to large, sinusoidal oscillations.
Save Time and Resources: No need to set up physical experiments to capture sensor data—scripted generation is repeatable and cost-effective.
Improve Model Accuracy: High-quality, diverse signals help close dataset gaps, reducing overfitting and improving real-world performance.

Importing synthetic motion data into Edge Impulse

Once you have your synthetic data, you can use it to train a model in Edge Impulse. Check out the Continuous motion recognition project for a complete example.

Use the CSV Wizard to import your data into a project.

Now that you have your synthetic motion data, you can import it into your project using the CSV Wizard.

Open the Edge Impulse Studio and navigate to the Data Acquisition tab.

Click on the CSV Wizard.

Upload the motion_data.csv file.

Follow the steps to label and import the data.

Once the data is imported, you can start training your model using the synthetic motion data.

Configure the model settings and train the model using the synthetic motion data.

For more advanced motion data generation, consider adding sensor noise, drift, or more complex motion patterns.

Next steps

For a more advanced example, see the public project:Rolling Element Bearing Fault Diagnosis that uses MATLAB to generate synthetic vibration data for bearing fault detection, based on the MATLAB Rolling Element Bearing Fault Diagnosis example.

Conclusion

By leveraging MATLAB for synthetic data generation, you can rapidly prototype and iterate without the overhead of physical sensors or mechanical rigs. This approach helps fill in dataset gaps, improves model robustness, and speeds up development cycles. Please share your own experience with MATLAB and other uses or projects with us on our forum.