Today we will talk about waveforms and their usefulness. As always, we will accompany this article with a programming exercise using C#, and the Lightning Chart .NET library. If this is your first time with LC .NET, I recommend that you download the interactive examples application, with which you can generate this and other charts in WPF and other projects.

The application has a free trial; however, you can download the project attached to this article. For this project, we will use the information collected by 5 sensors. Each sensor corresponds to a degree of temperature, and in turn, each sensor has a slight variation in the precision of its data.

We will use that variation along with the corresponding temperature, to generate a waveform that shows these differences between sensors. That said, let’s begin!

Waveform Plot

A waveform chart is a type of graph that visually represents an audio signal or wave. It is used to show the variation over time of a continuous signal, usually an audio waveform (such as a sound recording).

This type of graph shows how the amplitude of the signal changes over time, allowing you to visually see fluctuations in the intensity of the wave. Some key features of a waveform chart:

1. Horizontal axis (X): Represents time, usually in seconds or milliseconds.
2. Vertical axis (Y): Represents the amplitude of the signal, which indicates the intensity or volume of the wave at any given moment.
3. Waveform: Shows how the audio signal moves from one side to the other, with peaks (when the amplitude is high) and valleys (when the amplitude is low or zero).

Waveform charts are widely used in audio editing, music production, and signal analysis software, as they provide a clear way to visualize the structure and changes in audio signals. They are also used in other contexts, such as visualizing data from other types of continuous signals.

A waveform chart is not limited to audio alone, it can also be applied to show variations of other continuous signals over time, such as temperature.

When you use a waveform chart to show temperatures, what you would be doing is depicting how the temperature changes over a specific period. In this case, the vertical (Y) axis would show temperatures on a scale, such as degrees Celsius (°C), Fahrenheit (°F), or Kelvin (K), depending on the unit you are using.

The waveform chart would show how the temperature rises in the morning, peaks at midday, and then falls in the afternoon and evening. This graph could help you analyze weather patterns, adjust heating or cooling systems, or predict future temperature behavior.

How do I interpret the data using waveform charts? 

There are several properties that we must know to interpret these charts:

• Amplitude: Shows the value of the variable at an instant.
• Frequency and Period: Frequency is how many cycles occur each time, and the period is the time it takes to complete a cycle.
• Peaks and Valleys: Peaks are the maximum value, and valleys are the minimum value.

In this type of chart, we will find several types of waves:

• Sine waves: For periodic signals.
• Square waves: For digital signals.
• Irregular signals: For non-periodic or fluctuating data.

To analyze trends, variations in the peaks must be located.

How does temperature monitoring work with sensors?

Temperature monitoring with sensors involves measuring and tracking the temperature of an environment or object using devices called temperature sensors. These sensors detect changes in temperature and convert them into an electrical signal, which can then be read and analyzed by a system or device.

Types of Temperature Sensors and Data Collection:

• Thermistors: These are temperature-sensitive resistors. Their resistance changes with temperature, and this variation can be measured to determine the temperature.

• Thermocouples: These are composed of the union of two different metals. The temperature difference between the unions generates a voltage, which is proportional to the temperature difference.

• RTDs (Resistance Temperature Detectors): These use a metal (usually platinum) whose resistance increases with temperature. The change in resistance is measured to determine the temperature.

• Infrared Sensors: These sensors detect infrared radiation emitted by an object. The amount of radiation is correlated with the temperature of the object, allowing the temperature to be measured without direct contact.

• Semiconductor Sensors: These are used in microelectronics and provide temperature data by measuring a small change in voltage across a semiconductor material.

Feel free to download the ZIP file to follow this waveform plot project. The synthetic sensor dataset contains over 3000 samples, each representing a set of sensor readings. It consists of six columns: Temperature, Sensor1, Sensor2, Sensor3, Sensor4, and Sensor5.

The dataset is designed to mimic a scenario where temperature readings are influenced by multiple independent sensor measurements. The values ​​of the independent variables and the added noise introduce variability into the temperature readings.

Access the dataset from Kaggle.

1. OS: 32-bit or 64-bit Windows Vista or later, Windows Server 2008 R2 or later.
2. DirectX: 9.0c (Shader model 3 and higher) or 11.0 compatible graphics adapter.
3. Visual Studio: 2022 for development, not required for deployment.
4. Platform .NET Framework: installed version 8.0 or newer.

Now go to the next URL and download LightningChart .NET. You’ll then be redirected to a sign-in form where you’ll have to complete a simple sign-up process to get access to your LightningChart account.

After signing in to your account, you can download the SDK “free trial” version that allows you to use important features for this tutorial. When you download the SDK, you’ll have a .exe file like this:

The installation will be a typical Windows process, so please continue with it until it is finished. After the installation, you will see the following programs:

License Manager

In this application, you will see the purchase options. All the projects that you will create with this trial SDK will be available for future developments with all features enabled.

We will start by initializing our objects that will contain our charts:

We will first clean up the XAML components that will contain the charts:

Now we will create our Lightning Chart objects:

To create multiple charts at once, we will add each of the LightningChart objects to the “chartWaveformSensors” list, this way, we can use a loop to generate a chart for each object:

This method allows you to create and display graphs to represent the temperature signal from a sensor, configuring both the appearance and axes of the graph and ensuring that it is displayed in the correct location in the user interface.

1. Disable rendering temporarily: BeginUpdate() is called to disable rendering of the chart while its properties are updated, which improves performance.

2. Chart Settings: Set the chart name to “Temperature Waveform chart”. Remove the chart title text (chartWaveformSensor.Title.Text = ""), thus hiding any default text.

3. Chart placement: Depending on the value of chartIndex (a number between 1 and 5), the chart is added to one of several grids (gridChartWaveform1, gridChartWaveform2, etc.) in the user interface. This arranges the chart in different areas of the window.

4. Creating a data series: A data series called SampleDataSeries is created that will represent the discrete sensor signal, setting the line color to a random value and disabling user interaction with the series. The series is added to the graph.

5. Axis Configuration: The X axis is titled “Time”, representing time. The Y axis is titled “Temperature”, representing temperature.

6. Enable rendering: Finally, EndUpdate() is called to allow the chart to be rendered with the new settings.

GetSignal

This code generates a combined signal of two sine waves, scales them based on sensor data, and then combines them with temperature data before returning the result.

Input: The GetSignal method receives three parameters:

• samplingFrequency: the sampling frequency of the signal,
• temperatureData: an array with the temperature data,
• sensorData: an array with sensor data.

Signal Generation

A SignalGenerator object is created with the sampling frequency.

Two sinusoidal components are added to the generator. The first wave has an amplitude of 10 and a frequency of 10 Hz.

The second wave has an amplitude of 2 and a frequency of 400 Hz.

Sample Generation

The number of samples (samplesCount) is calculated based on time (timeLenSec = 1 second) and sampling rate. Samples of the sine waves are generated and stored in samples.

Adjustment with Sensor Data

Each sample of the generated waveform is multiplied by the corresponding sensorData values, modifying the original samples.

Combine Temperature and Signal Data

A result array of the same length as temperatureData is created. Each temperatureData value is then summed with the corresponding adjusted sample of the generated signal, storing the result in the result.

Output

The method returns the result array, which is the sum of the temperature data with the fitted signals.

CalculateSignalGenerator

This method gets the data (temperature and sensor) from a data set, generates a modified signal with that data, and then updates a chart to display that signal. During this process, it temporarily disables the rendering of the chart, configures the data series with the new signal, adjusts the chart view, and finally enables rendering again.

The method is aimed at:

• Get input data.
• Generate a modified signal.
• Update a chart with the newly generated signal.

Obtaining the graph and data

• A chart is selected from the charts list using the chartIndex index.
• dataSet: A data set is obtained using the getData() function, which returns a list of data.
• samplingFrequency: Obtains the number of elements in the second data set (dataSet[0] - Temperature), which defines the sampling frequency.
• temperatureData: The first data set (dataSet[0]), representing the temperatures, is extracted and converted to an array (ToArray()).
• sensorData: The dataset corresponding to the selected chart is extracted, i.e. dataSet[chartIndex+1], and is also converted to an array. A 1 is added, because the first index corresponds to the array of temperature values.
• Signal generation: The GetSignal function is called to obtain the generated signal data, using samplingFrequency, temperatureData, and sensorData parameters.

Setting up the data series

• The first data series (SampleDataSeries[0]) is selected in the chart.
• The SamplingFrequency property is updated with the previously calculated sampling frequency.
• FirstSampleTimeStamp is set to the first sampling time (which is the inverse of the sampling frequency since the frequency is assumed to be 1/s).
• SamplesDouble is assigned to the signalData array, which contains the values ​​of the generated signal.

Adjusting the graph view

ZoomToFit automatically adjusts the graph view so that the newly added data (in this case, the generated signal) is displayed correctly in the window.

The waveform chart is quite useful, since thanks to the shape it represents, it allows us to immediately identify the variations in the behavior of a set of data over time. It is a two-dimensional chart on a Cartesian plane.

In this case, we use a series of dotted lines and generate a third value. The third value increases or decreases with the aim of forming a wave. In this case, we create these values randomly with the help of the Sine Waveform tool, which will help us shape our line.

To these values, we multiply the value of each sensor, with the aim of generating variations in our waves: