Last Modified: December 18, 2017

Generates a signal containing an arbitrary wave.

One cycle of the waveform used in creating the output arbitrary wave.

The initial phase of the arbitrary wave.

True | Sets the initial phase to Sets the initial phase to |

False | Uses the values of Uses the values of |

**Default: **False

Amplitude of the arbitrary wave.

**Default: **1

Frequency of the arbitrary wave in normalized units of cycles/sample.

**Default: **10

The initial phase, in degrees, of the arbitrary wave.

**phase in** is valid only when you set **reset phase** to True.

**Default: **0

The type of interpolation this node uses to generate the arbitrary wave.

Name | Value | Description |
---|---|---|

None | 0 | No interpolation. |

Linear | 1 | Linear interpolation. |

**Default: **None

Error conditions that occur before this node runs.

The node responds to this input according to standard error behavior.

Standard Error Behavior

Many nodes provide an **error in** input and an **error out** output so that the node can respond to and communicate errors that occur while code is running. The value of **error in** specifies whether an error occurred before the node runs. Most nodes respond to values of **error in** in a standard, predictable way.

**Default: **No error

Sample rate in samples per second.

**Default: **1000

Number of samples in the signal.

**samples** must be greater than 0. Otherwise, this node returns an error.

This input is available when you configure this node to return a waveform or an array of double-precision, floating-point numbers.

**Default: **1000

Timestamp of the output signal. If this input is unwired, this node uses the current time as the timestamp of the output signal.

This input is available only if you configure this node to return a waveform.

Phase of the signal in degrees.

Error information.

The node produces this output according to standard error behavior.

Standard Error Behavior

**error in** input and an **error out** output so that the node can respond to and communicate errors that occur while code is running. The value of **error in** specifies whether an error occurred before the node runs. Most nodes respond to values of **error in** in a standard, predictable way.

If the sequence *Y* represents **arbitrary wave**, this node generates the sequence according to the following equation:

${y}_{i}=a*\mathrm{arb}\left({\mathrm{phase}}_{i}\right)$

for *i* = 0, 1, 2, …, *n* - 1

where *a* is **amplitude** and *n* is **samples**.

This node calculates $\mathrm{arb}\left({\mathrm{phase}}_{i}\right)$ using the following equation:

$\mathrm{arb}\left({\mathrm{phase}}_{i}\right)=WT\left(\frac{\left({\mathrm{phase}}_{i}\mathrm{modulo}360\right)\times m}{360}\right)$

where

*m*is the size of**wave table**-
$WT\left(x\right)=\mathrm{wave}\text{\hspace{0.17em}}\mathrm{table}[\mathrm{int}\left(x\right)]$ if
**interpolation**= 0 (no interpolation) - WT(
*x*) is the linearly interpolated value of $\mathrm{wave}\text{\hspace{0.17em}}\mathrm{table}[\mathrm{int}\left(x\right)]$ and $\mathrm{wave}\text{\hspace{0.17em}}\mathrm{table}\left[(\mathrm{int}\left(x\right)+1)\mathrm{modulo}\text{\hspace{0.17em}}m\right]$ if**interpolation**= 1 (linear interpolation) *phase*_{i}=*initial_phase*+**frequency***initial_phase*is**phase in**if**reset phase**is True*initial_phase*is the**phase out**from the previous execution of this instance of the node if**reset phase**is False

**Where This Node Can Run: **

Desktop OS: Windows

FPGA: This product does not support FPGA devices

Web Server: Not supported in VIs that run in a web application