diff --git a/bindings/matlab/definelibm2k_linux64.m b/bindings/matlab/definelibm2k_linux64.m index 1a842395..034e4fbd 100644 --- a/bindings/matlab/definelibm2k_linux64.m +++ b/bindings/matlab/definelibm2k_linux64.m @@ -1,3 +1,4 @@ + % % Copyright (c) 2024 Analog Devices Inc. % @@ -25,13 +26,16 @@ % functionality, uncomment a section and provide values for , , etc. For more % information, see helpview(fullfile(docroot,'matlab','helptargets.map'),'cpp_define_interface') to "Define MATLAB Interface for C++ Library". + + %% Setup % Do not edit this setup section. function libDef = definelibm2k_linux64() libDef = clibgen.LibraryDefinition("libm2kData.xml"); + %% OutputFolder and Libraries -libDef.OutputFolder = pwd; -libDef.Libraries = fullfile(pwd,'libm2k','libm2k.so'); +libDef.OutputFolder = "/home/ubuntu/git/libm2k/bindings/matlab"; +libDef.Libraries = "/home/ubuntu/git/libm2k/bindings/matlab/libm2k/libm2k.so"; %% C++ class |iio_channel| with MATLAB name |clib.libm2k.iio_channel| iio_channelDefinition = addClass(libDef, "iio_channel", "MATLABName", "clib.libm2k.iio_channel", ... @@ -120,160 +124,19 @@ "",... % N_DIGITAL_XOR_ANALOG ]); % Modify help description values as needed. -%% C++ enumeration |libm2k::M2K_TRIGGER_SOURCE_ANALOG| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG| -addEnumeration(libDef, "libm2k::M2K_TRIGGER_SOURCE_ANALOG", "int32",... - [... - "CHANNEL_1",... % 0 - "CHANNEL_2",... % 1 - "CHANNEL_1_OR_CHANNEL_2",... % 2 - "CHANNEL_1_AND_CHANNEL_2",... % 3 - "CHANNEL_1_XOR_CHANNEL_2",... % 4 - "SRC_DIGITAL_IN",... % 5 - "CHANNEL_1_OR_SRC_LOGIC_ANALYZER",... % 6 - "CHANNEL_2_OR_SRC_LOGIC_ANALYZER",... % 7 - "CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER",... % 8 - "NO_SOURCE",... % 9 - ],... - "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", ... - "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG Representation of C++ enumeration libm2k::M2K_TRIGGER_SOURCE_ANALOG." + newline + ... - "Select the source for the analog trigger", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@enum M2K_TRIGGER_SOURCE_ANALOG" + newline + ... - " @brief Select the source for the analog trigger", ... - "EnumerantDescriptions", ... - [... - "CHANNEL_1 - trigger events on analog CHANNEL_1 trigger the AnalogIn interface",... % CHANNEL_1 - "CHANNEL_2 - trigger events on analog CHANNEL_2 trigger the AnalogIn interface",... % CHANNEL_2 - "",... % CHANNEL_1_OR_CHANNEL_2 - "",... % CHANNEL_1_AND_CHANNEL_2 - "",... % CHANNEL_1_XOR_CHANNEL_2 - "SRC_DIGITAL_IN - trigger events on the DigitalIn interface trigger the AnalogIn interface",... % SRC_DIGITAL_IN - "",... % CHANNEL_1_OR_SRC_LOGIC_ANALYZER - "",... % CHANNEL_2_OR_SRC_LOGIC_ANALYZER - "",... % CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER - "",... % NO_SOURCE - ]); % Modify help description values as needed. - -%% C++ class |libm2k::SETTINGS| with MATLAB name |clib.libm2k.libm2k.SETTINGS| -SETTINGSDefinition = addClass(libDef, "libm2k::SETTINGS", "MATLABName", "clib.libm2k.libm2k.SETTINGS", ... - "Description", "clib.libm2k.libm2k.SETTINGS Representation of C++ class libm2k::SETTINGS." + newline + ... - "Triggering system", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. - -%% C++ class constructor for C++ class |libm2k::SETTINGS| -% C++ Signature: libm2k::SETTINGS::SETTINGS() - -SETTINGSConstructor1Definition = addConstructor(SETTINGSDefinition, ... - "libm2k::SETTINGS::SETTINGS()", ... - "Description", "clib.libm2k.libm2k.SETTINGS Constructor of C++ class libm2k::SETTINGS."); % Modify help description values as needed. -validate(SETTINGSConstructor1Definition); - -%% C++ class constructor for C++ class |libm2k::SETTINGS| -% C++ Signature: libm2k::SETTINGS::SETTINGS(libm2k::SETTINGS const & input1) - -SETTINGSConstructor2Definition = addConstructor(SETTINGSDefinition, ... - "libm2k::SETTINGS::SETTINGS(libm2k::SETTINGS const & input1)", ... - "Description", "clib.libm2k.libm2k.SETTINGS Constructor of C++ class libm2k::SETTINGS."); % Modify help description values as needed. -defineArgument(SETTINGSConstructor2Definition, "input1", "clib.libm2k.libm2k.SETTINGS", "input"); -validate(SETTINGSConstructor2Definition); - -%% C++ class public data member |raw_level| for C++ class |libm2k::SETTINGS| -% C++ Signature: std::vector> libm2k::SETTINGS::raw_level - -addProperty(SETTINGSDefinition, "raw_level", "clib.array.libm2k.Int", ... - "Description", "clib.array.libm2k.Int Data member of C++ class libm2k::SETTINGS." + newline + ... - "Trigger's raw level"); % Modify help description values as needed. - -%% C++ class public data member |level| for C++ class |libm2k::SETTINGS| -% C++ Signature: std::vector> libm2k::SETTINGS::level - -addProperty(SETTINGSDefinition, "level", "clib.array.libm2k.Double", ... - "Description", "clib.array.libm2k.Double Data member of C++ class libm2k::SETTINGS." + newline + ... - "Trigger's level"); % Modify help description values as needed. - -%% C++ class public data member |hysteresis| for C++ class |libm2k::SETTINGS| -% C++ Signature: std::vector> libm2k::SETTINGS::hysteresis - -addProperty(SETTINGSDefinition, "hysteresis", "clib.array.libm2k.Double", ... - "Description", "clib.array.libm2k.Double Data member of C++ class libm2k::SETTINGS." + newline + ... - "Trigger's hysteresis"); % Modify help description values as needed. - -%% C++ class public data member |trigger_source| for C++ class |libm2k::SETTINGS| -% C++ Signature: libm2k::M2K_TRIGGER_SOURCE_ANALOG libm2k::SETTINGS::trigger_source - -addProperty(SETTINGSDefinition, "trigger_source", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", ... - "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG Data member of C++ class libm2k::SETTINGS." + newline + ... - "Triggering source"); % Modify help description values as needed. - -%% C++ class public data member |delay| for C++ class |libm2k::SETTINGS| -% C++ Signature: int libm2k::SETTINGS::delay - -addProperty(SETTINGSDefinition, "delay", "int32", ... - "Description", "int32 Data member of C++ class libm2k::SETTINGS." + newline + ... - "Trigger's delay"); % Modify help description values as needed. - -%% C++ enumeration |libm2k::M2K_TRIGGER_OUT_SELECT| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT| -addEnumeration(libDef, "libm2k::M2K_TRIGGER_OUT_SELECT", "int32",... - [... - "SELECT_NONE",... % 0 - "SELECT_TRIGGER_I_SAME_CHAN",... % 1 - "SELECT_TRIGGER_IN",... % 2 - "SELECT_ANALOG_IN",... % 3 - "SELECT_DIGITAL_IN",... % 4 - ],... - "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT", ... - "Description", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT Representation of C++ enumeration libm2k::M2K_TRIGGER_OUT_SELECT." + newline + ... - "Select which trigger event will be forwarded on TO pin (trigger out)", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@enum M2K_TRIGGER_OUT_SELECT" + newline + ... - " @brief Select which trigger event will be forwarded on TO pin (trigger out)", ... - "EnumerantDescriptions", ... - [... - "SELECT_NONE - no trigger event is forwarded",... % SELECT_NONE - "",... % SELECT_TRIGGER_I_SAME_CHAN - "SELECT_TRIGGER_IN - forwards trigger events from TI pin(trigger in)",... % SELECT_TRIGGER_IN - "SELECT_ANALOG_IN - forwards trigger events from AnalogIn interface",... % SELECT_ANALOG_IN - "SELECT_DIGITAL_IN - forwards trigger events from DigitalIn interface",... % SELECT_DIGITAL_IN - ]); % Modify help description values as needed. - -%% C++ enumeration |libm2k::M2K_TRIGGER_SOURCE_DIGITAL| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL| -addEnumeration(libDef, "libm2k::M2K_TRIGGER_SOURCE_DIGITAL", "int32",... - [... - "SRC_TRIGGER_IN",... % 0 - "SRC_ANALOG_IN",... % 1 - "SRC_NONE",... % 2 - "SRC_DISABLED",... % 3 - ],... - "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL", ... - "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL Representation of C++ enumeration libm2k::M2K_TRIGGER_SOURCE_DIGITAL." + newline + ... - "Select the source for the digital trigger", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@enum M2K_TRIGGER_SOURCE_DIGITAL" + newline + ... - " @brief Select the source for the digital trigger", ... - "EnumerantDescriptions", ... - [... - "SRC_TRIGGER_IN - trigger events on the TI(trigger in) pin trigger the DigitalIn interface",... % SRC_TRIGGER_IN - "SRC_ANALOG_IN - trigger events on the AnalogIn interface trigger the DigitalIn interface",... % SRC_ANALOG_IN - "SRC_NONE - trigger events on the DigitalIn are conditioned by the internal digital trigger structure",... % SRC_NONE - "",... % SRC_DISABLED - ]); % Modify help description values as needed. - %% C++ class |libm2k::M2kHardwareTrigger| with MATLAB name |clib.libm2k.libm2k.M2kHardwareTrigger| M2kHardwareTriggerDefinition = addClass(libDef, "libm2k::M2kHardwareTrigger", "MATLABName", "clib.libm2k.libm2k.M2kHardwareTrigger", ... "Description", "clib.libm2k.libm2k.M2kHardwareTrigger Representation of C++ class libm2k::M2kHardwareTrigger." + newline + ... "Contains the representation of the ADALM2000 trigger system" + newline + ... "" + newline + ... - "@class M2kHardwareTrigger" + newline + ... + "@class M2kHardwareTrigger m2khardwaretrigger.hpp libm2k/m2khardwaretrigger.hpp" + newline + ... "@brief Controls the hardware trigger for ADALM2000", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... "@defgroup m2ktrigger HardwareTrigger" + newline + ... "@brief Contains the representation of the ADALM2000 trigger system" + newline + ... "" + newline + ... - "@class M2kHardwareTrigger" + newline + ... + "@class M2kHardwareTrigger m2khardwaretrigger.hpp libm2k/m2khardwaretrigger.hpp" + newline + ... "@brief Controls the hardware trigger for ADALM2000"); % Modify help description values as needed. %% C++ class method |reset| for C++ class |libm2k::M2kHardwareTrigger| @@ -401,8 +264,21 @@ "Description", "getDigitalCondition Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... "Get the trigger condition for the digital trigger on a specific channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getDigitalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel"); -defineOutput(getDigitalConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "the trigger condition"); +defineArgument(getDigitalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx The index of the required channel"); +defineOutput(getDigitalConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "The trigger condition"); +validate(getDigitalConditionDefinition); + +%% C++ class method |getDigitalCondition| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getDigitalCondition(libm2k::digital::DIO_CHANNEL chnIdx) + +getDigitalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getDigitalCondition(libm2k::digital::DIO_CHANNEL chnIdx)", ... + "MATLABName", "getDigitalCondition", ... + "Description", "getDigitalCondition Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Get the trigger condition for the digital trigger on a specific channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getDigitalConditionDefinition, "chnIdx", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chnIdx An enumerator corresponding to the index of the required channel"); +defineOutput(getDigitalConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "The trigger condition"); validate(getDigitalConditionDefinition); %% C++ class method |setDigitalCondition| for C++ class |libm2k::M2kHardwareTrigger| @@ -414,7 +290,20 @@ "Description", "setDigitalCondition Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... "Set the trigger condition for the digital trigger on a specific channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDigitalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel"); +defineArgument(setDigitalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx The index of the required channel"); +defineArgument(setDigitalConditionDefinition, "cond", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "cond the specific trigger condition"); +validate(setDigitalConditionDefinition); + +%% C++ class method |setDigitalCondition| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: void libm2k::M2kHardwareTrigger::setDigitalCondition(libm2k::digital::DIO_CHANNEL chnIdx,libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond) + +setDigitalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "void libm2k::M2kHardwareTrigger::setDigitalCondition(libm2k::digital::DIO_CHANNEL chnIdx,libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)", ... + "MATLABName", "setDigitalCondition", ... + "Description", "setDigitalCondition Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Set the trigger condition for the digital trigger on a specific channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setDigitalConditionDefinition, "chnIdx", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chnIdx An enumerator corresponding to the index of the required channel"); defineArgument(setDigitalConditionDefinition, "cond", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "cond the specific trigger condition"); validate(setDigitalConditionDefinition); @@ -808,52 +697,343 @@ " @note Only available from firmware v0.24."); validate(getDigitalSourceDefinition); -%% C++ class |libm2k::IIO_OBJECTS| with MATLAB name |clib.libm2k.libm2k.IIO_OBJECTS| -IIO_OBJECTSDefinition = addClass(libDef, "libm2k::IIO_OBJECTS", "MATLABName", "clib.libm2k.libm2k.IIO_OBJECTS", ... - "Description", "clib.libm2k.libm2k.IIO_OBJECTS Representation of C++ class libm2k::IIO_OBJECTS.", ... +%% C++ class method |setAnalogOutTriggerSource| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogOutTriggerSource(libm2k::M2K_TRIGGER_SOURCE_OUT src) + +setAnalogOutTriggerSourceDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "void libm2k::M2kHardwareTrigger::setAnalogOutTriggerSource(libm2k::M2K_TRIGGER_SOURCE_OUT src)", ... + "MATLABName", "setAnalogOutTriggerSource", ... + "Description", "setAnalogOutTriggerSource Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Select which interface triggers the AnalogOut.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setAnalogOutTriggerSourceDefinition, "src", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_OUT", "Description", "src: of type M2K_TRIGGER_SOURCE_OUT:\n" + newline + ... + " * TRIGGER_NONE - trigger events are disabled;\n" + newline + ... + " * TRIGGER_TI - trigger events on the TI pin will trigger the AnalogOut interface;\n" + newline + ... + " * TRIGGER_ADC - trigger events on the AnalogIn interface will trigger the AnalogOut interface;\n" + newline + ... + " * TRIGGER_LA - trigger events on the DigitalIn interface will trigger the AnalogOut interface;\n" + newline + ... + " @note Only available from firmware v0.33."); +validate(setAnalogOutTriggerSourceDefinition); + +%% C++ class method |getAnalogOutTriggerSource| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: libm2k::M2K_TRIGGER_SOURCE_OUT libm2k::M2kHardwareTrigger::getAnalogOutTriggerSource() const + +getAnalogOutTriggerSourceDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "libm2k::M2K_TRIGGER_SOURCE_OUT libm2k::M2kHardwareTrigger::getAnalogOutTriggerSource() const", ... + "MATLABName", "getAnalogOutTriggerSource", ... + "Description", "getAnalogOutTriggerSource Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Returns the source of the AnalogOut trigger event.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getAnalogOutTriggerSourceDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_OUT", "Description", "M2K_TRIGGER_SOURCE_OUT :\n" + newline + ... + " * TRIGGER_NONE;\n" + newline + ... + " * TRIGGER_TI;\n" + newline + ... + " * TRIGGER_ADC;\n" + newline + ... + " * TRIGGER_LA;\n" + newline + ... + " @note Only available from firmware v0.33."); +validate(getAnalogOutTriggerSourceDefinition); + +%% C++ class method |setAnalogOutTriggerCondition| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogOutTriggerCondition(libm2k::M2K_TRIGGER_CONDITION_OUT condition) + +setAnalogOutTriggerConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "void libm2k::M2kHardwareTrigger::setAnalogOutTriggerCondition(libm2k::M2K_TRIGGER_CONDITION_OUT condition)", ... + "MATLABName", "setAnalogOutTriggerCondition", ... + "Description", "setAnalogOutTriggerCondition Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Configures the triggering condition when the source of the AnalogOut trigger event is set to TRIGGER_TI_0.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setAnalogOutTriggerConditionDefinition, "condition", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_OUT", "Description", "condition: of type M2K_TRIGGER_CONDITION_OUT:\n" + newline + ... + " * NONE_OUT - disabled;\n" + newline + ... + " * LOW_LEVEL_OUT;\n" + newline + ... + " * HIGH_LEVEL_OUT;\n" + newline + ... + " * ANY_EDGE_OUT;\n" + newline + ... + " * RISING_EDGE_OUT;\n" + newline + ... + " * FALLING_EDGE_OUT;\n" + newline + ... + " @note For the other sources this condition is ignored, the configuration is forwarded by the corresponding interface." + newline + ... + " @note Only available from firmware v0.33."); +validate(setAnalogOutTriggerConditionDefinition); + +%% C++ class method |getAnalogOutTriggerCondition| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: libm2k::M2K_TRIGGER_CONDITION_OUT libm2k::M2kHardwareTrigger::getAnalogOutTriggerCondition() const + +getAnalogOutTriggerConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "libm2k::M2K_TRIGGER_CONDITION_OUT libm2k::M2kHardwareTrigger::getAnalogOutTriggerCondition() const", ... + "MATLABName", "getAnalogOutTriggerCondition", ... + "Description", "getAnalogOutTriggerCondition Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Returns the condition of the AnalogOut trigger event when the source is TI.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getAnalogOutTriggerConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_OUT", "Description", "M2K_TRIGGER_CONDITION_OUT :\n" + newline + ... + " * NONE_OUT - disabled;\n" + newline + ... + " * LOW_LEVEL_OUT;\n" + newline + ... + " * HIGH_LEVEL_OUT;\n" + newline + ... + " * ANY_EDGE_OUT;\n" + newline + ... + " * RISING_EDGE_OUT;\n" + newline + ... + " * FALLING_EDGE_OUT;\n" + newline + ... + " @note Only available from firmware v0.33."); +validate(getAnalogOutTriggerConditionDefinition); + +%% C++ class method |setAnalogOutTriggerStatus| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogOutTriggerStatus(libm2k::M2K_TRIGGER_STATUS_ANALOG_OUT status) + +setAnalogOutTriggerStatusDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "void libm2k::M2kHardwareTrigger::setAnalogOutTriggerStatus(libm2k::M2K_TRIGGER_STATUS_ANALOG_OUT status)", ... + "MATLABName", "setAnalogOutTriggerStatus", ... + "Description", "setAnalogOutTriggerStatus Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Defines the action to be performed when a trigger event occurs.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setAnalogOutTriggerStatusDefinition, "status", "clib.libm2k.libm2k.M2K_TRIGGER_STATUS_ANALOG_OUT", "Description", "status: of type M2K_TRIGGER_STATUS_ANALOG_OUT:\n" + newline + ... + " * DISABLED - no action is performed when a trigger event occurs;\n" + newline + ... + " * START - the AnalogOut interface starts outputting samples;\n" + newline + ... + " * STOP - the AnalogOut interface stops outputting samples;\n" + newline + ... + " @note Only available from firmware v0.33."); +validate(setAnalogOutTriggerStatusDefinition); + +%% C++ class method |getAnalogOutTriggerStatus| for C++ class |libm2k::M2kHardwareTrigger| +% C++ Signature: libm2k::M2K_TRIGGER_STATUS_ANALOG_OUT libm2k::M2kHardwareTrigger::getAnalogOutTriggerStatus() const + +getAnalogOutTriggerStatusDefinition = addMethod(M2kHardwareTriggerDefinition, ... + "libm2k::M2K_TRIGGER_STATUS_ANALOG_OUT libm2k::M2kHardwareTrigger::getAnalogOutTriggerStatus() const", ... + "MATLABName", "getAnalogOutTriggerStatus", ... + "Description", "getAnalogOutTriggerStatus Method of C++ class libm2k::M2kHardwareTrigger." + newline + ... + "Returns the action that is performed when a trigger event occurs.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getAnalogOutTriggerStatusDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_STATUS_ANALOG_OUT", "Description", "M2K_TRIGGER_STATUS_ANALOG_OUT :\n" + newline + ... + " * DISABLED;\n" + newline + ... + " * START;\n" + newline + ... + " * STOP;\n" + newline + ... + " @note Only available from firmware v0.33."); +validate(getAnalogOutTriggerStatusDefinition); + +%% C++ enumeration |libm2k::M2K_TRIGGER_SOURCE_ANALOG| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG| +addEnumeration(libDef, "libm2k::M2K_TRIGGER_SOURCE_ANALOG", "int32",... + [... + "CHANNEL_1",... % 0 + "CHANNEL_2",... % 1 + "CHANNEL_1_OR_CHANNEL_2",... % 2 + "CHANNEL_1_AND_CHANNEL_2",... % 3 + "CHANNEL_1_XOR_CHANNEL_2",... % 4 + "SRC_DIGITAL_IN",... % 5 + "CHANNEL_1_OR_SRC_LOGIC_ANALYZER",... % 6 + "CHANNEL_2_OR_SRC_LOGIC_ANALYZER",... % 7 + "CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER",... % 8 + "NO_SOURCE",... % 9 + ],... + "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", ... + "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG Representation of C++ enumeration libm2k::M2K_TRIGGER_SOURCE_ANALOG." + newline + ... + "Select the source for the analog trigger", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@private"); % Modify help description values as needed. + "@enum M2K_TRIGGER_SOURCE_ANALOG" + newline + ... + " @brief Select the source for the analog trigger", ... + "EnumerantDescriptions", ... + [... + "CHANNEL_1 - trigger events on analog CHANNEL_1 trigger the AnalogIn interface",... % CHANNEL_1 + "CHANNEL_2 - trigger events on analog CHANNEL_2 trigger the AnalogIn interface",... % CHANNEL_2 + "",... % CHANNEL_1_OR_CHANNEL_2 + "",... % CHANNEL_1_AND_CHANNEL_2 + "",... % CHANNEL_1_XOR_CHANNEL_2 + "SRC_DIGITAL_IN - trigger events on the DigitalIn interface trigger the AnalogIn interface",... % SRC_DIGITAL_IN + "",... % CHANNEL_1_OR_SRC_LOGIC_ANALYZER + "",... % CHANNEL_2_OR_SRC_LOGIC_ANALYZER + "",... % CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER + "",... % NO_SOURCE + ]); % Modify help description values as needed. -%% C++ class constructor for C++ class |libm2k::IIO_OBJECTS| -% C++ Signature: libm2k::IIO_OBJECTS::IIO_OBJECTS() +%% C++ class |libm2k::SETTINGS| with MATLAB name |clib.libm2k.libm2k.SETTINGS| +SETTINGSDefinition = addClass(libDef, "libm2k::SETTINGS", "MATLABName", "clib.libm2k.libm2k.SETTINGS", ... + "Description", "clib.libm2k.libm2k.SETTINGS Representation of C++ class libm2k::SETTINGS." + newline + ... + "Triggering system", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -IIO_OBJECTSConstructor1Definition = addConstructor(IIO_OBJECTSDefinition, ... - "libm2k::IIO_OBJECTS::IIO_OBJECTS()", ... - "Description", "clib.libm2k.libm2k.IIO_OBJECTS Constructor of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed. -validate(IIO_OBJECTSConstructor1Definition); +%% C++ class constructor for C++ class |libm2k::SETTINGS| +% C++ Signature: libm2k::SETTINGS::SETTINGS() -%% C++ class constructor for C++ class |libm2k::IIO_OBJECTS| -% C++ Signature: libm2k::IIO_OBJECTS::IIO_OBJECTS(libm2k::IIO_OBJECTS const & input1) +SETTINGSConstructor1Definition = addConstructor(SETTINGSDefinition, ... + "libm2k::SETTINGS::SETTINGS()", ... + "Description", "clib.libm2k.libm2k.SETTINGS Constructor of C++ class libm2k::SETTINGS."); % Modify help description values as needed. +validate(SETTINGSConstructor1Definition); -IIO_OBJECTSConstructor2Definition = addConstructor(IIO_OBJECTSDefinition, ... - "libm2k::IIO_OBJECTS::IIO_OBJECTS(libm2k::IIO_OBJECTS const & input1)", ... - "Description", "clib.libm2k.libm2k.IIO_OBJECTS Constructor of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed. -defineArgument(IIO_OBJECTSConstructor2Definition, "input1", "clib.libm2k.libm2k.IIO_OBJECTS", "input"); -validate(IIO_OBJECTSConstructor2Definition); +%% C++ class constructor for C++ class |libm2k::SETTINGS| +% C++ Signature: libm2k::SETTINGS::SETTINGS(libm2k::SETTINGS const & input1) -%% C++ class public data member |context| for C++ class |libm2k::IIO_OBJECTS| -% C++ Signature: iio_context * libm2k::IIO_OBJECTS::context +SETTINGSConstructor2Definition = addConstructor(SETTINGSDefinition, ... + "libm2k::SETTINGS::SETTINGS(libm2k::SETTINGS const & input1)", ... + "Description", "clib.libm2k.libm2k.SETTINGS Constructor of C++ class libm2k::SETTINGS."); % Modify help description values as needed. +defineArgument(SETTINGSConstructor2Definition, "input1", "clib.libm2k.libm2k.SETTINGS", "input"); +validate(SETTINGSConstructor2Definition); -%addProperty(IIO_OBJECTSDefinition, "context", "clib.libm2k.iio_context", , ... -% "Description", "clib.libm2k.iio_context Data member of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed. +%% C++ class public data member |raw_level| for C++ class |libm2k::SETTINGS| +% C++ Signature: std::vector> libm2k::SETTINGS::raw_level -%% C++ class |libm2k::CALIBRATION_PARAMETERS| with MATLAB name |clib.libm2k.libm2k.CALIBRATION_PARAMETERS| -CALIBRATION_PARAMETERSDefinition = addClass(libDef, "libm2k::CALIBRATION_PARAMETERS", "MATLABName", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS", ... - "Description", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS Representation of C++ class libm2k::CALIBRATION_PARAMETERS." + newline + ... - "Calibration parameters of m2k", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@struct CALIBRATION_PARAMETERS" + newline + ... - " @brief Calibration parameters of m2k"); % Modify help description values as needed. +addProperty(SETTINGSDefinition, "raw_level", "clib.array.libm2k.Int", ... + "Description", "clib.array.libm2k.Int Data member of C++ class libm2k::SETTINGS." + newline + ... + "Trigger's raw level"); % Modify help description values as needed. -%% C++ class constructor for C++ class |libm2k::CALIBRATION_PARAMETERS| -% C++ Signature: libm2k::CALIBRATION_PARAMETERS::CALIBRATION_PARAMETERS(libm2k::CALIBRATION_PARAMETERS const & input1) +%% C++ class public data member |level| for C++ class |libm2k::SETTINGS| +% C++ Signature: std::vector> libm2k::SETTINGS::level -CALIBRATION_PARAMETERSConstructor1Definition = addConstructor(CALIBRATION_PARAMETERSDefinition, ... - "libm2k::CALIBRATION_PARAMETERS::CALIBRATION_PARAMETERS(libm2k::CALIBRATION_PARAMETERS const & input1)", ... - "Description", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS Constructor of C++ class libm2k::CALIBRATION_PARAMETERS."); % Modify help description values as needed. -defineArgument(CALIBRATION_PARAMETERSConstructor1Definition, "input1", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS", "input"); +addProperty(SETTINGSDefinition, "level", "clib.array.libm2k.Double", ... + "Description", "clib.array.libm2k.Double Data member of C++ class libm2k::SETTINGS." + newline + ... + "Trigger's level"); % Modify help description values as needed. + +%% C++ class public data member |hysteresis| for C++ class |libm2k::SETTINGS| +% C++ Signature: std::vector> libm2k::SETTINGS::hysteresis + +addProperty(SETTINGSDefinition, "hysteresis", "clib.array.libm2k.Double", ... + "Description", "clib.array.libm2k.Double Data member of C++ class libm2k::SETTINGS." + newline + ... + "Trigger's hysteresis"); % Modify help description values as needed. + +%% C++ class public data member |trigger_source| for C++ class |libm2k::SETTINGS| +% C++ Signature: libm2k::M2K_TRIGGER_SOURCE_ANALOG libm2k::SETTINGS::trigger_source + +addProperty(SETTINGSDefinition, "trigger_source", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", ... + "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG Data member of C++ class libm2k::SETTINGS." + newline + ... + "Triggering source"); % Modify help description values as needed. + +%% C++ class public data member |delay| for C++ class |libm2k::SETTINGS| +% C++ Signature: int libm2k::SETTINGS::delay + +addProperty(SETTINGSDefinition, "delay", "int32", ... + "Description", "int32 Data member of C++ class libm2k::SETTINGS." + newline + ... + "Trigger's delay"); % Modify help description values as needed. + +%% C++ enumeration |libm2k::M2K_TRIGGER_OUT_SELECT| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT| +addEnumeration(libDef, "libm2k::M2K_TRIGGER_OUT_SELECT", "int32",... + [... + "SELECT_NONE",... % 0 + "SELECT_TRIGGER_I_SAME_CHAN",... % 1 + "SELECT_TRIGGER_IN",... % 2 + "SELECT_ANALOG_IN",... % 3 + "SELECT_DIGITAL_IN",... % 4 + ],... + "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT", ... + "Description", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT Representation of C++ enumeration libm2k::M2K_TRIGGER_OUT_SELECT." + newline + ... + "Select which trigger event will be forwarded on TO pin (trigger out)", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@enum M2K_TRIGGER_OUT_SELECT" + newline + ... + " @brief Select which trigger event will be forwarded on TO pin (trigger out)", ... + "EnumerantDescriptions", ... + [... + "SELECT_NONE - no trigger event is forwarded",... % SELECT_NONE + "",... % SELECT_TRIGGER_I_SAME_CHAN + "SELECT_TRIGGER_IN - forwards trigger events from TI pin(trigger in)",... % SELECT_TRIGGER_IN + "SELECT_ANALOG_IN - forwards trigger events from AnalogIn interface",... % SELECT_ANALOG_IN + "SELECT_DIGITAL_IN - forwards trigger events from DigitalIn interface",... % SELECT_DIGITAL_IN + ]); % Modify help description values as needed. + +%% C++ enumeration |libm2k::M2K_TRIGGER_SOURCE_DIGITAL| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL| +addEnumeration(libDef, "libm2k::M2K_TRIGGER_SOURCE_DIGITAL", "int32",... + [... + "SRC_TRIGGER_IN",... % 0 + "SRC_ANALOG_IN",... % 1 + "SRC_NONE",... % 2 + "SRC_DISABLED",... % 3 + ],... + "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL", ... + "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL Representation of C++ enumeration libm2k::M2K_TRIGGER_SOURCE_DIGITAL." + newline + ... + "Select the source for the digital trigger", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@enum M2K_TRIGGER_SOURCE_DIGITAL" + newline + ... + " @brief Select the source for the digital trigger", ... + "EnumerantDescriptions", ... + [... + "SRC_TRIGGER_IN - trigger events on the TI(trigger in) pin trigger the DigitalIn interface",... % SRC_TRIGGER_IN + "SRC_ANALOG_IN - trigger events on the AnalogIn interface trigger the DigitalIn interface",... % SRC_ANALOG_IN + "SRC_NONE - trigger events on the DigitalIn are conditioned by the internal digital trigger structure",... % SRC_NONE + "",... % SRC_DISABLED + ]); % Modify help description values as needed. + +%% C++ enumeration |libm2k::M2K_TRIGGER_SOURCE_OUT| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_OUT| +addEnumeration(libDef, "libm2k::M2K_TRIGGER_SOURCE_OUT", "int32",... + [... + "TRIGGER_NONE",... % 0 + "TRIGGER_TI",... % 1 + "TRIGGER_ADC",... % 2 + "TRIGGER_LA",... % 3 + ],... + "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_OUT", ... + "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_OUT Representation of C++ enumeration libm2k::M2K_TRIGGER_SOURCE_OUT." + newline + ... + "Selects the source trigger for the output interfaces"); % Modify help description values as needed. + +%% C++ enumeration |libm2k::M2K_TRIGGER_CONDITION_OUT| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_OUT| +addEnumeration(libDef, "libm2k::M2K_TRIGGER_CONDITION_OUT", "int32",... + [... + "NONE_OUT",... % 0 + "LOW_LEVEL_OUT",... % 1 + "HIGH_LEVEL_OUT",... % 2 + "ANY_EDGE_OUT",... % 3 + "RISING_EDGE_OUT",... % 4 + "FALLING_EDGE_OUT",... % 5 + ],... + "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_OUT", ... + "Description", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_OUT Representation of C++ enumeration libm2k::M2K_TRIGGER_CONDITION_OUT." + newline + ... + "Trigger condition when the source for M2K_TRIGGER_SOURCE_OUT is TRIGGER_TI", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@enum M2K_TRIGGER_CONDITION_OUT" + newline + ... + " @brief Trigger condition when the source for M2K_TRIGGER_SOURCE_OUT is TRIGGER_TI"); % Modify help description values as needed. + +%% C++ enumeration |libm2k::M2K_TRIGGER_STATUS_ANALOG_OUT| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_STATUS_ANALOG_OUT| +addEnumeration(libDef, "libm2k::M2K_TRIGGER_STATUS_ANALOG_OUT", "int32",... + [... + "DISABLED",... % 0 + "START",... % 1 + "STOP",... % 2 + ],... + "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_STATUS_ANALOG_OUT", ... + "Description", "clib.libm2k.libm2k.M2K_TRIGGER_STATUS_ANALOG_OUT Representation of C++ enumeration libm2k::M2K_TRIGGER_STATUS_ANALOG_OUT." + newline + ... + "The status value determines the action that the output interface will take when the trigger condition is met.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@enum M2K_TRIGGER_STATUS_ANALOG_OUT" + newline + ... + " @brief The status value determines the action that the output interface will take when the trigger condition is met."); % Modify help description values as needed. + +%% C++ class |libm2k::IIO_OBJECTS| with MATLAB name |clib.libm2k.libm2k.IIO_OBJECTS| +IIO_OBJECTSDefinition = addClass(libDef, "libm2k::IIO_OBJECTS", "MATLABName", "clib.libm2k.libm2k.IIO_OBJECTS", ... + "Description", "clib.libm2k.libm2k.IIO_OBJECTS Representation of C++ class libm2k::IIO_OBJECTS.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. + +%% C++ class constructor for C++ class |libm2k::IIO_OBJECTS| +% C++ Signature: libm2k::IIO_OBJECTS::IIO_OBJECTS() + +IIO_OBJECTSConstructor1Definition = addConstructor(IIO_OBJECTSDefinition, ... + "libm2k::IIO_OBJECTS::IIO_OBJECTS()", ... + "Description", "clib.libm2k.libm2k.IIO_OBJECTS Constructor of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed. +validate(IIO_OBJECTSConstructor1Definition); + +%% C++ class constructor for C++ class |libm2k::IIO_OBJECTS| +% C++ Signature: libm2k::IIO_OBJECTS::IIO_OBJECTS(libm2k::IIO_OBJECTS const & input1) + +IIO_OBJECTSConstructor2Definition = addConstructor(IIO_OBJECTSDefinition, ... + "libm2k::IIO_OBJECTS::IIO_OBJECTS(libm2k::IIO_OBJECTS const & input1)", ... + "Description", "clib.libm2k.libm2k.IIO_OBJECTS Constructor of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed. +defineArgument(IIO_OBJECTSConstructor2Definition, "input1", "clib.libm2k.libm2k.IIO_OBJECTS", "input"); +validate(IIO_OBJECTSConstructor2Definition); + +%% C++ class public data member |context| for C++ class |libm2k::IIO_OBJECTS| +% C++ Signature: iio_context * libm2k::IIO_OBJECTS::context + +%addProperty(IIO_OBJECTSDefinition, "context", "clib.libm2k.iio_context", , ... +% "Description", "clib.libm2k.iio_context Data member of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed. + +%% C++ class |libm2k::CALIBRATION_PARAMETERS| with MATLAB name |clib.libm2k.libm2k.CALIBRATION_PARAMETERS| +CALIBRATION_PARAMETERSDefinition = addClass(libDef, "libm2k::CALIBRATION_PARAMETERS", "MATLABName", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS", ... + "Description", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS Representation of C++ class libm2k::CALIBRATION_PARAMETERS." + newline + ... + "Calibration parameters of m2k", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@struct CALIBRATION_PARAMETERS enums.hpp libm2k/enums.hpp" + newline + ... + " @brief Calibration parameters of m2k"); % Modify help description values as needed. + +%% C++ class constructor for C++ class |libm2k::CALIBRATION_PARAMETERS| +% C++ Signature: libm2k::CALIBRATION_PARAMETERS::CALIBRATION_PARAMETERS(libm2k::CALIBRATION_PARAMETERS const & input1) + +CALIBRATION_PARAMETERSConstructor1Definition = addConstructor(CALIBRATION_PARAMETERSDefinition, ... + "libm2k::CALIBRATION_PARAMETERS::CALIBRATION_PARAMETERS(libm2k::CALIBRATION_PARAMETERS const & input1)", ... + "Description", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS Constructor of C++ class libm2k::CALIBRATION_PARAMETERS."); % Modify help description values as needed. +defineArgument(CALIBRATION_PARAMETERSConstructor1Definition, "input1", "clib.libm2k.libm2k.CALIBRATION_PARAMETERS", "input"); validate(CALIBRATION_PARAMETERSConstructor1Definition); %% C++ class constructor for C++ class |libm2k::CALIBRATION_PARAMETERS| @@ -926,7 +1106,7 @@ "The version of the backend", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@struct IIO_CONTEXT_VERSION" + newline + ... + "@struct IIO_CONTEXT_VERSION enums.hpp libm2k/enums.hpp" + newline + ... " @brief The version of the backend"); % Modify help description values as needed. %% C++ class constructor for C++ class |libm2k::IIO_CONTEXT_VERSION| @@ -963,7 +1143,7 @@ %% C++ class public data member |git_tag| for C++ class |libm2k::IIO_CONTEXT_VERSION| % C++ Signature: char [8] libm2k::IIO_CONTEXT_VERSION::git_tag -addProperty(IIO_CONTEXT_VERSIONDefinition, "git_tag", "clib.array.libm2k.Char", 8, ... % can be "clib.array.libm2k.Char","int8","string", or "char" +addProperty(IIO_CONTEXT_VERSIONDefinition, "git_tag", "clib.array.libm2k.Char", [8], ... % can be "clib.array.libm2k.Char","int8", or "char" "Description", "clib.array.libm2k.Char Data member of C++ class libm2k::IIO_CONTEXT_VERSION."); % Modify help description values as needed. %% C++ class |libm2k::CONTEXT_INFO| with MATLAB name |clib.libm2k.libm2k.CONTEXT_INFO| @@ -972,7 +1152,7 @@ "Additional information about the context", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@struct CONTEXT_INFO" + newline + ... + "@struct CONTEXT_INFO enums.hpp libm2k/enums.hpp" + newline + ... " @brief Additional information about the context"); % Modify help description values as needed. %% C++ class constructor for C++ class |libm2k::CONTEXT_INFO| @@ -1075,6 +1255,80 @@ "M2k exception types", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%% C++ class |libm2k::m2k_exception| with MATLAB name |clib.libm2k.libm2k.m2k_exception| +m2k_exceptionDefinition = addClass(libDef, "libm2k::m2k_exception", "MATLABName", "clib.libm2k.libm2k.m2k_exception", ... + "Description", "clib.libm2k.libm2k.m2k_exception Representation of C++ class libm2k::m2k_exception."); % Modify help description values as needed. + +%% C++ class method |make| for C++ class |libm2k::m2k_exception| +% C++ Signature: static libm2k::m2k_exception_builder libm2k::m2k_exception::make(std::string what) + +makeDefinition = addMethod(m2k_exceptionDefinition, ... + "static libm2k::m2k_exception_builder libm2k::m2k_exception::make(std::string what)", ... + "MATLABName", "make", ... + "Description", "make Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. +defineArgument(makeDefinition, "what", "string"); +defineOutput(makeDefinition, "RetVal", "clib.libm2k.libm2k.m2k_exception_builder"); +validate(makeDefinition); + +%% C++ class method |iioCode| for C++ class |libm2k::m2k_exception| +% C++ Signature: int libm2k::m2k_exception::iioCode() const + +iioCodeDefinition = addMethod(m2k_exceptionDefinition, ... + "int libm2k::m2k_exception::iioCode() const", ... + "MATLABName", "iioCode", ... + "Description", "iioCode Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. +defineOutput(iioCodeDefinition, "RetVal", "int32"); +validate(iioCodeDefinition); + +%% C++ class method |type| for C++ class |libm2k::m2k_exception| +% C++ Signature: libm2k::M2K_EXCEPTION_TYPE libm2k::m2k_exception::type() const + +typeDefinition = addMethod(m2k_exceptionDefinition, ... + "libm2k::M2K_EXCEPTION_TYPE libm2k::m2k_exception::type() const", ... + "MATLABName", "type", ... + "Description", "type Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. +defineOutput(typeDefinition, "RetVal", "clib.libm2k.libm2k.M2K_EXCEPTION_TYPE"); +validate(typeDefinition); + +%% C++ class method |line| for C++ class |libm2k::m2k_exception| +% C++ Signature: int libm2k::m2k_exception::line() const + +lineDefinition = addMethod(m2k_exceptionDefinition, ... + "int libm2k::m2k_exception::line() const", ... + "MATLABName", "line", ... + "Description", "line Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. +defineOutput(lineDefinition, "RetVal", "int32"); +validate(lineDefinition); + +%% C++ class method |file| for C++ class |libm2k::m2k_exception| +% C++ Signature: std::string libm2k::m2k_exception::file() const + +fileDefinition = addMethod(m2k_exceptionDefinition, ... + "std::string libm2k::m2k_exception::file() const", ... + "MATLABName", "file", ... + "Description", "file Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. +defineOutput(fileDefinition, "RetVal", "string"); +validate(fileDefinition); + +%% C++ class method |what| for C++ class |libm2k::m2k_exception| +% C++ Signature: char const * libm2k::m2k_exception::what() const + +%whatDefinition = addMethod(m2k_exceptionDefinition, ... +% "char const * libm2k::m2k_exception::what() const", ... +% "MATLABName", "what", ... +% "Description", "what Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. +%defineOutput(whatDefinition, "RetVal", , ); % can be "clib.array.libm2k.Char","int8","string", or "char" +%validate(whatDefinition); + +%% C++ class constructor for C++ class |libm2k::m2k_exception| +% C++ Signature: libm2k::m2k_exception::m2k_exception(libm2k::m2k_exception const & input1) + +m2k_exceptionConstructor1Definition = addConstructor(m2k_exceptionDefinition, ... + "libm2k::m2k_exception::m2k_exception(libm2k::m2k_exception const & input1)", ... + "Description", "clib.libm2k.libm2k.m2k_exception Constructor of C++ class libm2k::m2k_exception."); % Modify help description values as needed. +defineArgument(m2k_exceptionConstructor1Definition, "input1", "clib.libm2k.libm2k.m2k_exception", "input"); +validate(m2k_exceptionConstructor1Definition); + %% C++ class |libm2k::m2k_exception_builder| with MATLAB name |clib.libm2k.libm2k.m2k_exception_builder| m2k_exception_builderDefinition = addClass(libDef, "libm2k::m2k_exception_builder", "MATLABName", "clib.libm2k.libm2k.m2k_exception_builder", ... "Description", "clib.libm2k.libm2k.m2k_exception_builder Representation of C++ class libm2k::m2k_exception_builder."); % Modify help description values as needed. @@ -1168,106 +1422,32 @@ defineArgument(m2k_exception_builderConstructor4Definition, "input1", "clib.libm2k.libm2k.m2k_exception_builder", "input"); validate(m2k_exception_builderConstructor4Definition); -%% C++ class |libm2k::m2k_exception| with MATLAB name |clib.libm2k.libm2k.m2k_exception| -m2k_exceptionDefinition = addClass(libDef, "libm2k::m2k_exception", "MATLABName", "clib.libm2k.libm2k.m2k_exception", ... - "Description", "clib.libm2k.libm2k.m2k_exception Representation of C++ class libm2k::m2k_exception."); % Modify help description values as needed. - -%% C++ class method |make| for C++ class |libm2k::m2k_exception| -% C++ Signature: static libm2k::m2k_exception_builder libm2k::m2k_exception::make(std::string what) +%% C++ class |libm2k::M2kCalibration| with MATLAB name |clib.libm2k.libm2k.M2kCalibration| +M2kCalibrationDefinition = addClass(libDef, "libm2k::M2kCalibration", "MATLABName", "clib.libm2k.libm2k.M2kCalibration", ... + "Description", "clib.libm2k.libm2k.M2kCalibration Representation of C++ class libm2k::M2kCalibration."); % Modify help description values as needed. -makeDefinition = addMethod(m2k_exceptionDefinition, ... - "static libm2k::m2k_exception_builder libm2k::m2k_exception::make(std::string what)", ... - "MATLABName", "make", ... - "Description", "make Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. -defineArgument(makeDefinition, "what", "string"); -defineOutput(makeDefinition, "RetVal", "clib.libm2k.libm2k.m2k_exception_builder"); -validate(makeDefinition); +%% C++ class method |initialize| for C++ class |libm2k::M2kCalibration| +% C++ Signature: bool libm2k::M2kCalibration::initialize() -%% C++ class method |iioCode| for C++ class |libm2k::m2k_exception| -% C++ Signature: int libm2k::m2k_exception::iioCode() const +initializeDefinition = addMethod(M2kCalibrationDefinition, ... + "bool libm2k::M2kCalibration::initialize()", ... + "MATLABName", "initialize", ... + "Description", "initialize Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed. +defineOutput(initializeDefinition, "RetVal", "logical"); +validate(initializeDefinition); -iioCodeDefinition = addMethod(m2k_exceptionDefinition, ... - "int libm2k::m2k_exception::iioCode() const", ... - "MATLABName", "iioCode", ... - "Description", "iioCode Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. -defineOutput(iioCodeDefinition, "RetVal", "int32"); -validate(iioCodeDefinition); +%% C++ class method |isInitialized| for C++ class |libm2k::M2kCalibration| +% C++ Signature: bool libm2k::M2kCalibration::isInitialized() const -%% C++ class method |type| for C++ class |libm2k::m2k_exception| -% C++ Signature: libm2k::M2K_EXCEPTION_TYPE libm2k::m2k_exception::type() const +isInitializedDefinition = addMethod(M2kCalibrationDefinition, ... + "bool libm2k::M2kCalibration::isInitialized() const", ... + "MATLABName", "isInitialized", ... + "Description", "isInitialized Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed. +defineOutput(isInitializedDefinition, "RetVal", "logical"); +validate(isInitializedDefinition); -typeDefinition = addMethod(m2k_exceptionDefinition, ... - "libm2k::M2K_EXCEPTION_TYPE libm2k::m2k_exception::type() const", ... - "MATLABName", "type", ... - "Description", "type Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. -defineOutput(typeDefinition, "RetVal", "clib.libm2k.libm2k.M2K_EXCEPTION_TYPE"); -validate(typeDefinition); - -%% C++ class method |line| for C++ class |libm2k::m2k_exception| -% C++ Signature: int libm2k::m2k_exception::line() const - -lineDefinition = addMethod(m2k_exceptionDefinition, ... - "int libm2k::m2k_exception::line() const", ... - "MATLABName", "line", ... - "Description", "line Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. -defineOutput(lineDefinition, "RetVal", "int32"); -validate(lineDefinition); - -%% C++ class method |file| for C++ class |libm2k::m2k_exception| -% C++ Signature: std::string libm2k::m2k_exception::file() const - -fileDefinition = addMethod(m2k_exceptionDefinition, ... - "std::string libm2k::m2k_exception::file() const", ... - "MATLABName", "file", ... - "Description", "file Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. -defineOutput(fileDefinition, "RetVal", "string"); -validate(fileDefinition); - -%% C++ class method |what| for C++ class |libm2k::m2k_exception| -% C++ Signature: char const * libm2k::m2k_exception::what() const - -%whatDefinition = addMethod(m2k_exceptionDefinition, ... -% "char const * libm2k::m2k_exception::what() const", ... -% "MATLABName", "what", ... -% "Description", "what Method of C++ class libm2k::m2k_exception."); % Modify help description values as needed. -%defineOutput(whatDefinition, "RetVal", , ); % can be "clib.array.libm2k.Char","int8","string", or "char" -%validate(whatDefinition); - -%% C++ class constructor for C++ class |libm2k::m2k_exception| -% C++ Signature: libm2k::m2k_exception::m2k_exception(libm2k::m2k_exception const & input1) - -m2k_exceptionConstructor1Definition = addConstructor(m2k_exceptionDefinition, ... - "libm2k::m2k_exception::m2k_exception(libm2k::m2k_exception const & input1)", ... - "Description", "clib.libm2k.libm2k.m2k_exception Constructor of C++ class libm2k::m2k_exception."); % Modify help description values as needed. -defineArgument(m2k_exceptionConstructor1Definition, "input1", "clib.libm2k.libm2k.m2k_exception", "input"); -validate(m2k_exceptionConstructor1Definition); - -%% C++ class |libm2k::M2kCalibration| with MATLAB name |clib.libm2k.libm2k.M2kCalibration| -M2kCalibrationDefinition = addClass(libDef, "libm2k::M2kCalibration", "MATLABName", "clib.libm2k.libm2k.M2kCalibration", ... - "Description", "clib.libm2k.libm2k.M2kCalibration Representation of C++ class libm2k::M2kCalibration."); % Modify help description values as needed. - -%% C++ class method |initialize| for C++ class |libm2k::M2kCalibration| -% C++ Signature: bool libm2k::M2kCalibration::initialize() - -initializeDefinition = addMethod(M2kCalibrationDefinition, ... - "bool libm2k::M2kCalibration::initialize()", ... - "MATLABName", "initialize", ... - "Description", "initialize Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed. -defineOutput(initializeDefinition, "RetVal", "logical"); -validate(initializeDefinition); - -%% C++ class method |isInitialized| for C++ class |libm2k::M2kCalibration| -% C++ Signature: bool libm2k::M2kCalibration::isInitialized() const - -isInitializedDefinition = addMethod(M2kCalibrationDefinition, ... - "bool libm2k::M2kCalibration::isInitialized() const", ... - "MATLABName", "isInitialized", ... - "Description", "isInitialized Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed. -defineOutput(isInitializedDefinition, "RetVal", "logical"); -validate(isInitializedDefinition); - -%% C++ class method |calibrateAll| for C++ class |libm2k::M2kCalibration| -% C++ Signature: bool libm2k::M2kCalibration::calibrateAll() +%% C++ class method |calibrateAll| for C++ class |libm2k::M2kCalibration| +% C++ Signature: bool libm2k::M2kCalibration::calibrateAll() calibrateAllDefinition = addMethod(M2kCalibrationDefinition, ... "bool libm2k::M2kCalibration::calibrateAll()", ... @@ -1433,3077 +1613,3122 @@ defineArgument(throw_exceptionDefinition, "exception", "clib.libm2k.libm2k.m2k_exception", "input"); validate(throw_exceptionDefinition); -%% C++ class |libm2k::analog::DMM_READING| with MATLAB name |clib.libm2k.libm2k.analog.DMM_READING| -DMM_READINGDefinition = addClass(libDef, "libm2k::analog::DMM_READING", "MATLABName", "clib.libm2k.libm2k.analog.DMM_READING", ... - "Description", "clib.libm2k.libm2k.analog.DMM_READING Representation of C++ class libm2k::analog::DMM_READING." + newline + ... - "The structure of a DMM", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. - -%% C++ class constructor for C++ class |libm2k::analog::DMM_READING| -% C++ Signature: libm2k::analog::DMM_READING::DMM_READING() - -DMM_READINGConstructor1Definition = addConstructor(DMM_READINGDefinition, ... - "libm2k::analog::DMM_READING::DMM_READING()", ... - "Description", "clib.libm2k.libm2k.analog.DMM_READING Constructor of C++ class libm2k::analog::DMM_READING."); % Modify help description values as needed. -validate(DMM_READINGConstructor1Definition); - -%% C++ class constructor for C++ class |libm2k::analog::DMM_READING| -% C++ Signature: libm2k::analog::DMM_READING::DMM_READING(libm2k::analog::DMM_READING const & input1) - -DMM_READINGConstructor2Definition = addConstructor(DMM_READINGDefinition, ... - "libm2k::analog::DMM_READING::DMM_READING(libm2k::analog::DMM_READING const & input1)", ... - "Description", "clib.libm2k.libm2k.analog.DMM_READING Constructor of C++ class libm2k::analog::DMM_READING."); % Modify help description values as needed. -defineArgument(DMM_READINGConstructor2Definition, "input1", "clib.libm2k.libm2k.analog.DMM_READING", "input"); -validate(DMM_READINGConstructor2Definition); - -%% C++ class public data member |name| for C++ class |libm2k::analog::DMM_READING| -% C++ Signature: std::string libm2k::analog::DMM_READING::name - -addProperty(DMM_READINGDefinition, "name", "string", ... - "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... - "The name of the channel"); % Modify help description values as needed. - -%% C++ class public data member |id| for C++ class |libm2k::analog::DMM_READING| -% C++ Signature: std::string libm2k::analog::DMM_READING::id - -addProperty(DMM_READINGDefinition, "id", "string", ... - "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... - "Channel's id"); % Modify help description values as needed. - -%% C++ class public data member |value| for C++ class |libm2k::analog::DMM_READING| -% C++ Signature: double libm2k::analog::DMM_READING::value - -addProperty(DMM_READINGDefinition, "value", "double", ... - "Description", "double Data member of C++ class libm2k::analog::DMM_READING." + newline + ... - "The measured value"); % Modify help description values as needed. - -%% C++ class public data member |unit_name| for C++ class |libm2k::analog::DMM_READING| -% C++ Signature: std::string libm2k::analog::DMM_READING::unit_name - -addProperty(DMM_READINGDefinition, "unit_name", "string", ... - "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... - "Unit of measurement"); % Modify help description values as needed. - -%% C++ class public data member |unit_symbol| for C++ class |libm2k::analog::DMM_READING| -% C++ Signature: std::string libm2k::analog::DMM_READING::unit_symbol +%% C++ enumeration |libm2k::digital::DIO_CHANNEL| with MATLAB name |clib.libm2k.libm2k.digital.DIO_CHANNEL| +addEnumeration(libDef, "libm2k::digital::DIO_CHANNEL", "int32",... + [... + "DIO_CHANNEL_0",... % 0 + "DIO_CHANNEL_1",... % 1 + "DIO_CHANNEL_2",... % 2 + "DIO_CHANNEL_3",... % 3 + "DIO_CHANNEL_4",... % 4 + "DIO_CHANNEL_5",... % 5 + "DIO_CHANNEL_6",... % 6 + "DIO_CHANNEL_7",... % 7 + "DIO_CHANNEL_8",... % 8 + "DIO_CHANNEL_9",... % 9 + "DIO_CHANNEL_10",... % 10 + "DIO_CHANNEL_11",... % 11 + "DIO_CHANNEL_12",... % 12 + "DIO_CHANNEL_13",... % 13 + "DIO_CHANNEL_14",... % 14 + "DIO_CHANNEL_15",... % 15 + ],... + "MATLABName", "clib.libm2k.libm2k.digital.DIO_CHANNEL", ... + "Description", "clib.libm2k.libm2k.digital.DIO_CHANNEL Representation of C++ enumeration libm2k::digital::DIO_CHANNEL." + newline + ... + "Indexes of the channels", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@note Each channel can be accessed through its index"); % Modify help description values as needed. -addProperty(DMM_READINGDefinition, "unit_symbol", "string", ... - "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... - "Unit symbol"); % Modify help description values as needed. +%% C++ enumeration |libm2k::digital::DIO_TRIGGER_MODE| with MATLAB name |clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE| +addEnumeration(libDef, "libm2k::digital::DIO_TRIGGER_MODE", "int32",... + [... + "DIO_OR",... % 0 + "DIO_AND",... % 1 + ],... + "MATLABName", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE", ... + "Description", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE Representation of C++ enumeration libm2k::digital::DIO_TRIGGER_MODE." + newline + ... + "Triggering mode for digital channels", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%% C++ class |libm2k::analog::DMM| with MATLAB name |clib.libm2k.libm2k.analog.DMM| -DMMDefinition = addClass(libDef, "libm2k::analog::DMM", "MATLABName", "clib.libm2k.libm2k.analog.DMM", ... - "Description", "clib.libm2k.libm2k.analog.DMM Representation of C++ class libm2k::analog::DMM." + newline + ... - "Contains the representation of the digital multimeter" + newline + ... +%% C++ class |libm2k::digital::M2kDigital| with MATLAB name |clib.libm2k.libm2k.digital.M2kDigital| +M2kDigitalDefinition = addClass(libDef, "libm2k::digital::M2kDigital", "MATLABName", "clib.libm2k.libm2k.digital.M2kDigital", ... + "Description", "clib.libm2k.libm2k.digital.M2kDigital Representation of C++ class libm2k::digital::M2kDigital." + newline + ... + "Contains the representation of the digital segment" + newline + ... "" + newline + ... - "@class DMM" + newline + ... - "@brief Controls the digital multimeter", ... + "@class M2kDigital m2kdigital.hpp libm2k/digital/m2kdigital.hpp" + newline + ... + "@brief Controls the digital input and output segment", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@defgroup dmm DMM" + newline + ... - "@brief Contains the representation of the digital multimeter" + newline + ... + "@defgroup digital Digital" + newline + ... + "@brief Contains the representation of the digital segment" + newline + ... "" + newline + ... - "@class DMM" + newline + ... - "@brief Controls the digital multimeter"); % Modify help description values as needed. + "@class M2kDigital m2kdigital.hpp libm2k/digital/m2kdigital.hpp" + newline + ... + "@brief Controls the digital input and output segment"); % Modify help description values as needed. -%% C++ class method |reset| for C++ class |libm2k::analog::DMM| -% C++ Signature: void libm2k::analog::DMM::reset() +%% C++ class method |reset| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::reset() -resetDefinition = addMethod(DMMDefinition, ... - "void libm2k::analog::DMM::reset()", ... +resetDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::reset()", ... "MATLABName", "reset", ... - "Description", "reset Method of C++ class libm2k::analog::DMM.", ... + "Description", "reset Method of C++ class libm2k::digital::M2kDigital.", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... "@private"); % Modify help description values as needed. validate(resetDefinition); -%% C++ class method |getAllChannels| for C++ class |libm2k::analog::DMM| -% C++ Signature: std::vector libm2k::analog::DMM::getAllChannels() +%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned short mask) -getAllChannelsDefinition = addMethod(DMMDefinition, ... - "std::vector libm2k::analog::DMM::getAllChannels()", ... - "MATLABName", "getAllChannels", ... - "Description", "getAllChannels Method of C++ class libm2k::analog::DMM." + newline + ... - "Retrieve all channels", ... +setDirectionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setDirection(unsigned short mask)", ... + "MATLABName", "setDirection", ... + "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the direction for all digital channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getAllChannelsDefinition, "RetVal", "clib.array.libm2k.std.String", "Description", "A list containing the name of all channels"); -validate(getAllChannelsDefinition); +defineArgument(setDirectionDefinition, "mask", "uint16", "Description", "mask A bitmask" + newline + ... + " @note Each bit of the mask corresponds to the channel with the same index. The value of the bit represents the channel's direction. O - input, 1 - output"); +validate(setDirectionDefinition); -%% C++ class method |readChannel| for C++ class |libm2k::analog::DMM| -% C++ Signature: libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(unsigned int index) +%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned int index,libm2k::digital::DIO_DIRECTION dir) -readChannelDefinition = addMethod(DMMDefinition, ... - "libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(unsigned int index)", ... - "MATLABName", "readChannel", ... - "Description", "readChannel Method of C++ class libm2k::analog::DMM." + newline + ... - "Retrieve additional information about the given channel", ... +setDirectionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setDirection(unsigned int index,libm2k::digital::DIO_DIRECTION dir)", ... + "MATLABName", "setDirection", ... + "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the direction of the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(readChannelDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); -defineOutput(readChannelDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM_READING", "Description", "A structure containing additional information"); -validate(readChannelDefinition); +defineArgument(setDirectionDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); +defineArgument(setDirectionDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator that indicates the direction of a channel"); +validate(setDirectionDefinition); -%% C++ class method |readChannel| for C++ class |libm2k::analog::DMM| -% C++ Signature: libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(std::string chn_name) +%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned int index,bool dir) -readChannelDefinition = addMethod(DMMDefinition, ... - "libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(std::string chn_name)", ... - "MATLABName", "readChannel", ... - "Description", "readChannel Method of C++ class libm2k::analog::DMM." + newline + ... - "Retrieve additional information about the given channel", ... +setDirectionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setDirection(unsigned int index,bool dir)", ... + "MATLABName", "setDirection", ... + "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the direction of the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(readChannelDefinition, "chn_name", "string", "Description", "chn_name The name corresponding to the channel"); -defineOutput(readChannelDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM_READING", "Description", "A structure containing additional information"); -validate(readChannelDefinition); - -%% C++ class method |readAll| for C++ class |libm2k::analog::DMM| -% C++ Signature: std::vector> libm2k::analog::DMM::readAll() +defineArgument(setDirectionDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); +defineArgument(setDirectionDefinition, "dir", "logical", "Description", "dir A boolean value that corresponds to one direction" + newline + ... + " @note The boolean value for input direction is false and for output direction is true"); +validate(setDirectionDefinition); -readAllDefinition = addMethod(DMMDefinition, ... - "std::vector> libm2k::analog::DMM::readAll()", ... - "MATLABName", "readAll", ... - "Description", "readAll Method of C++ class libm2k::analog::DMM." + newline + ... - "Retrieve additional information about all channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(readAllDefinition, "RetVal", "clib.array.libm2k.libm2k.analog.DMM_READING", "Description", "A list containing structures for each channel"); -validate(readAllDefinition); +%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,bool dir) -%% C++ class method |getName| for C++ class |libm2k::analog::DMM| -% C++ Signature: std::string libm2k::analog::DMM::getName() +setDirectionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,bool dir)", ... + "MATLABName", "setDirection", ... + "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the direction of the given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); +defineArgument(setDirectionDefinition, "dir", "logical", "Description", "dir A boolean value that corresponds to one direction" + newline + ... + " @note The boolean value for input direction is false and for output direction is true"); +validate(setDirectionDefinition); -getNameDefinition = addMethod(DMMDefinition, ... - "std::string libm2k::analog::DMM::getName()", ... - "MATLABName", "getName", ... - "Description", "getName Method of C++ class libm2k::analog::DMM." + newline + ... - "Retrieve the device's name", ... +%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_DIRECTION dir) + +setDirectionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_DIRECTION dir)", ... + "MATLABName", "setDirection", ... + "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the direction of the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getNameDefinition, "RetVal", "string", "Description", "The name of the device"); -validate(getNameDefinition); +defineArgument(setDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); +defineArgument(setDirectionDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator that indicates the direction of a channel"); +validate(setDirectionDefinition); -%% C++ enumeration |libm2k::analog::ANALOG_IN_CHANNEL| with MATLAB name |clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL| -addEnumeration(libDef, "libm2k::analog::ANALOG_IN_CHANNEL", "int32",... - [... - "ANALOG_IN_CHANNEL_1",... % 0 - "ANALOG_IN_CHANNEL_2",... % 1 - ],... - "MATLABName", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", ... - "Description", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL Representation of C++ enumeration libm2k::analog::ANALOG_IN_CHANNEL." + newline + ... - "Indexes of the channels", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@note Each channel can be accessed through its index"); % Modify help description values as needed. +%% C++ class method |getDirection| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: libm2k::digital::DIO_DIRECTION libm2k::digital::M2kDigital::getDirection(libm2k::digital::DIO_CHANNEL index) -%% C++ enumeration |libm2k::analog::M2K_RANGE| with MATLAB name |clib.libm2k.libm2k.analog.M2K_RANGE| -addEnumeration(libDef, "libm2k::analog::M2K_RANGE", "int32",... - [... - "PLUS_MINUS_25V",... % 0 - "PLUS_MINUS_2_5V",... % 1 - ],... - "MATLABName", "clib.libm2k.libm2k.analog.M2K_RANGE", ... - "Description", "clib.libm2k.libm2k.analog.M2K_RANGE Representation of C++ enumeration libm2k::analog::M2K_RANGE." + newline + ... - "Range of the signal's amplitude", ... +getDirectionDefinition = addMethod(M2kDigitalDefinition, ... + "libm2k::digital::DIO_DIRECTION libm2k::digital::M2kDigital::getDirection(libm2k::digital::DIO_CHANNEL index)", ... + "MATLABName", "getDirection", ... + "Description", "getDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the direction of the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); +defineOutput(getDirectionDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "DIO_DIRECTION An enumerator that indicates the direction of a channel"); +validate(getDirectionDefinition); -%% C++ class |libm2k::analog::M2kAnalogIn| with MATLAB name |clib.libm2k.libm2k.analog.M2kAnalogIn| -M2kAnalogInDefinition = addClass(libDef, "libm2k::analog::M2kAnalogIn", "MATLABName", "clib.libm2k.libm2k.analog.M2kAnalogIn", ... - "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn Representation of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Contains the representation of the analogical input segment" + newline + ... - "" + newline + ... - "@class M2kAnalogIn" + newline + ... - "@brief Controls the analogical input compound", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@defgroup analogin AnalogIn" + newline + ... - "@brief Contains the representation of the analogical input segment" + newline + ... - "" + newline + ... - "@class M2kAnalogIn" + newline + ... - "@brief Controls the analogical input compound"); % Modify help description values as needed. +%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_LEVEL level) -%% C++ class method |reset| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::reset() +setValueRawDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_LEVEL level)", ... + "MATLABName", "setValueRaw", ... + "Description", "setValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the raw value of a given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); +defineArgument(setValueRawDefinition, "level", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "level An enumerator corresponding to the raw value"); +validate(setValueRawDefinition); -resetDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::reset()", ... - "MATLABName", "reset", ... - "Description", "reset Method of C++ class libm2k::analog::M2kAnalogIn.", ... +%% C++ class method |push| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::push(std::vector> const & data) + +pushDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::push(std::vector> const & data)", ... + "MATLABName", "push", ... + "Description", "push Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Send the samples to all digital channels", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(pushDefinition, "data", "clib.array.libm2k.UnsignedShort", "Description", "data The std vector that contains the samples" + newline + ... + " @note Due to a hardware limitation, the number of samples must" + newline + ... + " be a multiple of 4 and greater than 16."); +validate(pushDefinition); + +%% C++ class method |push| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::push(unsigned short * data,unsigned int nb_samples) + +%pushDefinition = addMethod(M2kDigitalDefinition, ... +% "void libm2k::digital::M2kDigital::push(unsigned short * data,unsigned int nb_samples)", ... +% "MATLABName", "push", ... +% "Description", "push Method of C++ class libm2k::digital::M2kDigital." + newline + ... +% "Send the samples to all digital channels", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineArgument(pushDefinition, "data", "clib.array.libm2k.UnsignedShort", "input", , "Description", "data a pointer to the samples"); % can be "clib.array.libm2k.UnsignedShort", or "uint16" +%defineArgument(pushDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples" + newline + ... +% " @note Due to a hardware limitation, the number of samples must" + newline + ... +% " be a multiple of 4 and greater than 16."); +%validate(pushDefinition); + +%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(unsigned int index,libm2k::digital::DIO_LEVEL level) + +setValueRawDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setValueRaw(unsigned int index,libm2k::digital::DIO_LEVEL level)", ... + "MATLABName", "setValueRaw", ... + "Description", "setValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the raw value of a given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setValueRawDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); +defineArgument(setValueRawDefinition, "level", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "level An enumerator corresponding to the raw value"); +validate(setValueRawDefinition); + +%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,bool level) + +setValueRawDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,bool level)", ... + "MATLABName", "setValueRaw", ... + "Description", "setValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the raw value of a given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); +defineArgument(setValueRawDefinition, "level", "logical", "Description", "level A boolean value corresponding to the raw value"); +validate(setValueRawDefinition); + +%% C++ class method |getValueRaw| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(libm2k::digital::DIO_CHANNEL index) + +getValueRawDefinition = addMethod(M2kDigitalDefinition, ... + "libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(libm2k::digital::DIO_CHANNEL index)", ... + "MATLABName", "getValueRaw", ... + "Description", "getValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the raw value of the given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); +defineOutput(getValueRawDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "DIO_LEVEL An enumerator corresponding to the raw value"); +validate(getValueRawDefinition); + +%% C++ class method |getValueRaw| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(unsigned int index) + +getValueRawDefinition = addMethod(M2kDigitalDefinition, ... + "libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(unsigned int index)", ... + "MATLABName", "getValueRaw", ... + "Description", "getValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the raw value of the given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getValueRawDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); +defineOutput(getValueRawDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "DIO_LEVEL An enumerator corresponding to the raw value"); +validate(getValueRawDefinition); + +%% C++ class method |stopBufferOut| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::stopBufferOut() + +stopBufferOutDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::stopBufferOut()", ... + "MATLABName", "stopBufferOut", ... + "Description", "stopBufferOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Stop all digital channels from sending the signals", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@private"); % Modify help description values as needed. -validate(resetDefinition); + "@brief Stop all digital channels from sending the signals"); % Modify help description values as needed. +validate(stopBufferOutDefinition); -%% C++ class method |startAcquisition| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::startAcquisition(unsigned int nb_samples) +%% C++ class method |startAcquisition| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::startAcquisition(unsigned int nb_samples) -startAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::startAcquisition(unsigned int nb_samples)", ... +startAcquisitionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::startAcquisition(unsigned int nb_samples)", ... "MATLABName", "startAcquisition", ... - "Description", "startAcquisition Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Create the buffer for both channels and start the acquisition", ... + "Description", "startAcquisition Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Create the buffer for all channels and start the acquisition", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(startAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples size of the buffer in samples for each channel"); +defineArgument(startAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples size of the buffer in samples"); validate(startAcquisitionDefinition); -%% C++ class method |stopAcquisition| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::stopAcquisition() +%% C++ class method |stopAcquisition| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::stopAcquisition() -stopAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::stopAcquisition()", ... +stopAcquisitionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::stopAcquisition()", ... "MATLABName", "stopAcquisition", ... - "Description", "stopAcquisition Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Description", "stopAcquisition Method of C++ class libm2k::digital::M2kDigital." + newline + ... "Destroy the buffer and stop the acquisition", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... "@brief Destroy the buffer and stop the acquisition"); % Modify help description values as needed. validate(stopAcquisitionDefinition); -%% C++ class method |getSamplesInterleaved| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved(unsigned int nb_samples_per_channel) +%% C++ class method |cancelAcquisition| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::cancelAcquisition() -%getSamplesInterleavedDefinition = addMethod(M2kAnalogInDefinition, ... -% "double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved(unsigned int nb_samples_per_channel)", ... -% "MATLABName", "getSamplesInterleaved", ... -% "Description", "getSamplesInterleaved Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... -% "Retrieve a specific number of samples from each channel", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineArgument(getSamplesInterleavedDefinition, "nb_samples_per_channel", "uint32", "Description", "nb_samples_per_channel The number of samples that will be retrieved"); -%defineOutput(getSamplesInterleavedDefinition, "RetVal", "clib.array.libm2k.Double", , "Description", "A pointer to the interleaved samples"); % can be "clib.array.libm2k.Double", or "double" -%validate(getSamplesInterleavedDefinition); +cancelAcquisitionDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::cancelAcquisition()", ... + "MATLABName", "cancelAcquisition", ... + "Description", "cancelAcquisition Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Cancel all rx-buffer operations" + newline + ... + " @note Should be used to cancel an ongoing acquisition", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@brief Cancel all rx-buffer operations" + newline + ... + " @note Should be used to cancel an ongoing acquisition"); % Modify help description values as needed. +validate(cancelAcquisitionDefinition); -%% C++ class method |getSamplesRawInterleaved| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved(unsigned int nb_samples_per_channel) +%% C++ class method |cancelBufferOut| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::cancelBufferOut() -%getSamplesRawInterleavedDefinition = addMethod(M2kAnalogInDefinition, ... -% "short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved(unsigned int nb_samples_per_channel)", ... -% "MATLABName", "getSamplesRawInterleaved", ... -% "Description", "getSamplesRawInterleaved Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... -% "Retrieve a specific number of raw samples from each channel", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineArgument(getSamplesRawInterleavedDefinition, "nb_samples_per_channel", "uint32", "Description", "nb_samples_per_channel The number of samples that will be retrieved"); -%defineOutput(getSamplesRawInterleavedDefinition, "RetVal", "clib.array.libm2k.Short", , "Description", "A pointer to the interleaved raw samples"); % can be "clib.array.libm2k.Short", or "int16" -%validate(getSamplesRawInterleavedDefinition); +cancelBufferOutDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::cancelBufferOut()", ... + "MATLABName", "cancelBufferOut", ... + "Description", "cancelBufferOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Cancel all tx-buffer operations" + newline + ... + " @note Should be used to cancel an ongoing data write.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@brief Cancel all tx-buffer operations" + newline + ... + " @note Should be used to cancel an ongoing data write."); % Modify help description values as needed. +validate(cancelBufferOutDefinition); -%% C++ class method |getSamplesInterleaved_matlab| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved_matlab(unsigned int nb_samples) +%% C++ class method |getSamples| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: std::vector> libm2k::digital::M2kDigital::getSamples(unsigned int nb_samples) -getSamplesInterleaved_matlabDefinition = addMethod(M2kAnalogInDefinition, ... - "double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved_matlab(unsigned int nb_samples)", ... - "MATLABName", "getSamplesInterleaved_matlab", ... - "Description", "getSamplesInterleaved_matlab Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve a specific number of samples from both channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getSamplesInterleaved_matlabDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); -defineOutput(getSamplesInterleaved_matlabDefinition, "RetVal", "clib.array.libm2k.Double", "nb_samples", "Description", "A pointer to the interleaved samples"); % can be "clib.array.libm2k.Double", or "double" -validate(getSamplesInterleaved_matlabDefinition); +getSamplesDefinition = addMethod(M2kDigitalDefinition, ... + "std::vector> libm2k::digital::M2kDigital::getSamples(unsigned int nb_samples)", ... + "MATLABName", "getSamples", ... + "Description", "getSamples Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve a specific number of samples", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getSamplesDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); +defineOutput(getSamplesDefinition, "RetVal", "clib.array.libm2k.UnsignedShort", "Description", "A list that contains the samples" + newline + ... + " @note Due to a hardware limitation, the number of samples must" + newline + ... + " be a multiple of 4 and greater than 16."); +validate(getSamplesDefinition); -%% C++ class method |getSamplesRawInterleaved_matlab| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved_matlab(unsigned int nb_samples) +%% C++ class method |getSamplesP| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: unsigned short const * libm2k::digital::M2kDigital::getSamplesP(unsigned int nb_samples) -%getSamplesRawInterleaved_matlabDefinition = addMethod(M2kAnalogInDefinition, ... -% "short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved_matlab(unsigned int nb_samples)", ... -% "MATLABName", "getSamplesRawInterleaved_matlab", ... -% "Description", "getSamplesRawInterleaved_matlab Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... -% "Retrieve a specific number of raw samples from both channels", ... +%getSamplesPDefinition = addMethod(M2kDigitalDefinition, ... +% "unsigned short const * libm2k::digital::M2kDigital::getSamplesP(unsigned int nb_samples)", ... +% "MATLABName", "getSamplesP", ... +% "Description", "getSamplesP Method of C++ class libm2k::digital::M2kDigital." + newline + ... +% "Retrieve a specific number of samples", ... % "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineArgument(getSamplesRawInterleaved_matlabDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); -%defineOutput(getSamplesRawInterleaved_matlabDefinition, "RetVal", "clib.array.libm2k.Short", , "Description", "A pointer to the interleaved raw samples"); % can be "clib.array.libm2k.Short", or "int16" -%validate(getSamplesRawInterleaved_matlabDefinition); +%defineArgument(getSamplesPDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); +%defineOutput(getSamplesPDefinition, "RetVal", "clib.array.libm2k.UnsignedShort", , "Description", "A pointer to the data" + newline + ... +% " @note Due to a hardware limitation, the number of samples must" + newline + ... +% " be a multiple of 4 and greater than 16."); % can be "clib.array.libm2k.UnsignedShort", or "uint16" +%validate(getSamplesPDefinition); -%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: short libm2k::analog::M2kAnalogIn::getVoltageRaw(unsigned int ch) +%% C++ class method |enableChannel| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::enableChannel(unsigned int index,bool enable) -getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ... - "short libm2k::analog::M2kAnalogIn::getVoltageRaw(unsigned int ch)", ... - "MATLABName", "getVoltageRaw", ... - "Description", "getVoltageRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the average raw value of the given channel", ... +enableChannelDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::enableChannel(unsigned int index,bool enable)", ... + "MATLABName", "enableChannel", ... + "Description", "enableChannel Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Enable or disable the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getVoltageRawDefinition, "ch", "uint32", "Description", "ch The index corresponding to the channel"); -defineOutput(getVoltageRawDefinition, "RetVal", "int16", "Description", "The average raw value"); -validate(getVoltageRawDefinition); +defineArgument(enableChannelDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); +defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); +validate(enableChannelDefinition); -%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getVoltage(unsigned int ch) +%% C++ class method |enableChannel| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::enableChannel(libm2k::digital::DIO_CHANNEL index,bool enable) -getVoltageDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getVoltage(unsigned int ch)", ... - "MATLABName", "getVoltage", ... - "Description", "getVoltage Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the average voltage of the given channel", ... +enableChannelDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::enableChannel(libm2k::digital::DIO_CHANNEL index,bool enable)", ... + "MATLABName", "enableChannel", ... + "Description", "enableChannel Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Enable or disable the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getVoltageDefinition, "ch", "uint32", "Description", "ch The index corresponding to the channel"); -defineOutput(getVoltageDefinition, "RetVal", "double", "Description", "The average voltage"); -validate(getVoltageDefinition); +defineArgument(enableChannelDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); +defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); +validate(enableChannelDefinition); -%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: short libm2k::analog::M2kAnalogIn::getVoltageRaw(libm2k::analog::ANALOG_IN_CHANNEL ch) +%% C++ class method |enableAllOut| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::enableAllOut(bool enable) -getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ... - "short libm2k::analog::M2kAnalogIn::getVoltageRaw(libm2k::analog::ANALOG_IN_CHANNEL ch)", ... - "MATLABName", "getVoltageRaw", ... - "Description", "getVoltageRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the average raw value of the given channel", ... +enableAllOutDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::enableAllOut(bool enable)", ... + "MATLABName", "enableAllOut", ... + "Description", "enableAllOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Enable or disable all output channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getVoltageRawDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index"); -defineOutput(getVoltageRawDefinition, "RetVal", "int16", "Description", "The average raw value"); -validate(getVoltageRawDefinition); +defineArgument(enableAllOutDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); +validate(enableAllOutDefinition); -%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getVoltage(libm2k::analog::ANALOG_IN_CHANNEL ch) +%% C++ class method |anyChannelEnabled| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: bool libm2k::digital::M2kDigital::anyChannelEnabled(libm2k::digital::DIO_DIRECTION dir) -getVoltageDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getVoltage(libm2k::analog::ANALOG_IN_CHANNEL ch)", ... - "MATLABName", "getVoltage", ... - "Description", "getVoltage Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the average voltage of the given channel", ... +anyChannelEnabledDefinition = addMethod(M2kDigitalDefinition, ... + "bool libm2k::digital::M2kDigital::anyChannelEnabled(libm2k::digital::DIO_DIRECTION dir)", ... + "MATLABName", "anyChannelEnabled", ... + "Description", "anyChannelEnabled Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Check if there is at least one channel enabled", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getVoltageDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index"); -defineOutput(getVoltageDefinition, "RetVal", "double", "Description", "The average voltage"); -validate(getVoltageDefinition); +defineArgument(anyChannelEnabledDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator corresponding to the direction of a channel"); +defineOutput(anyChannelEnabledDefinition, "RetVal", "logical", "Description", "On succces, true"); +validate(anyChannelEnabledDefinition); -%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogIn::getVoltageRaw() +%% C++ class method |setOutputMode| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setOutputMode(libm2k::digital::DIO_CHANNEL chn,libm2k::digital::DIO_MODE mode) -getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ... - "std::vector> libm2k::analog::M2kAnalogIn::getVoltageRaw()", ... - "MATLABName", "getVoltageRaw", ... - "Description", "getVoltageRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the average raw value for each channel", ... +setOutputModeDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setOutputMode(libm2k::digital::DIO_CHANNEL chn,libm2k::digital::DIO_MODE mode)", ... + "MATLABName", "setOutputMode", ... + "Description", "setOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the output mode for the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getVoltageRawDefinition, "RetVal", "clib.array.libm2k.Short", "Description", "A list containing the average raw value of each channel"); -validate(getVoltageRawDefinition); +defineArgument(setOutputModeDefinition, "chn", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chn An enumerator corresponding to the channel's index"); +defineArgument(setOutputModeDefinition, "mode", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "mode An enumerator corresponding to the output mode"); +validate(setOutputModeDefinition); -%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogIn::getVoltage() +%% C++ class method |setOutputMode| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setOutputMode(unsigned int chn,libm2k::digital::DIO_MODE mode) -getVoltageDefinition = addMethod(M2kAnalogInDefinition, ... - "std::vector> libm2k::analog::M2kAnalogIn::getVoltage()", ... - "MATLABName", "getVoltage", ... - "Description", "getVoltage Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the average voltage for each channel", ... +setOutputModeDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setOutputMode(unsigned int chn,libm2k::digital::DIO_MODE mode)", ... + "MATLABName", "setOutputMode", ... + "Description", "setOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the output mode for the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getVoltageDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the average voltage of each channel"); -validate(getVoltageDefinition); - -%% C++ class method |getVoltageRawP| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getVoltageRawP() - -%getVoltageRawPDefinition = addMethod(M2kAnalogInDefinition, ... -% "short const * libm2k::analog::M2kAnalogIn::getVoltageRawP()", ... -% "MATLABName", "getVoltageRawP", ... -% "Description", "getVoltageRawP Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... -% "Retrieve the average raw value for both channels", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineOutput(getVoltageRawPDefinition, "RetVal", "clib.array.libm2k.Short", , "Description", "A pointer to the average raw value of both channels"); % can be "clib.array.libm2k.Short", or "int16" -%validate(getVoltageRawPDefinition); +defineArgument(setOutputModeDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineArgument(setOutputModeDefinition, "mode", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "mode An enumerator corresponding to the output mode"); +validate(setOutputModeDefinition); -%% C++ class method |getVoltageP| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getVoltageP() +%% C++ class method |getOutputMode| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(libm2k::digital::DIO_CHANNEL chn) -%getVoltagePDefinition = addMethod(M2kAnalogInDefinition, ... -% "double const * libm2k::analog::M2kAnalogIn::getVoltageP()", ... -% "MATLABName", "getVoltageP", ... -% "Description", "getVoltageP Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... -% "Retrieve the average voltage for both channels", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineOutput(getVoltagePDefinition, "RetVal", "clib.array.libm2k.Double", , "Description", "A pointer to the average voltage of both channels"); % can be "clib.array.libm2k.Double", or "double" -%validate(getVoltagePDefinition); +getOutputModeDefinition = addMethod(M2kDigitalDefinition, ... + "libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(libm2k::digital::DIO_CHANNEL chn)", ... + "MATLABName", "getOutputMode", ... + "Description", "getOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the output mode for the given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getOutputModeDefinition, "chn", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chn An enumerator corresponding to the channel's index"); +defineOutput(getOutputModeDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "An enumerator corresponding to the output mode"); +validate(getOutputModeDefinition); -%% C++ class method |setVerticalOffset| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::setVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel,double vertOffset) +%% C++ class method |getOutputMode| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(unsigned int chn) -setVerticalOffsetDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::setVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel,double vertOffset)", ... - "MATLABName", "setVerticalOffset", ... - "Description", "setVerticalOffset Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Set the vertical offset, in Volts, of a specific channel", ... +getOutputModeDefinition = addMethod(M2kDigitalDefinition, ... + "libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(unsigned int chn)", ... + "MATLABName", "getOutputMode", ... + "Description", "getOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the output mode for the given digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setVerticalOffsetDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel the index of the channel"); -defineArgument(setVerticalOffsetDefinition, "vertOffset", "double", "Description", "vertOffset the value of the offset in Volts"); -validate(setVerticalOffsetDefinition); +defineArgument(getOutputModeDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineOutput(getOutputModeDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "An enumerator corresponding to the output mode"); +validate(getOutputModeDefinition); -%% C++ class method |getVerticalOffset| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel) +%% C++ class method |setSampleRateIn| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: double libm2k::digital::M2kDigital::setSampleRateIn(double samplerate) -getVerticalOffsetDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel)", ... - "MATLABName", "getVerticalOffset", ... - "Description", "getVerticalOffset Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "getVerticalOffset", ... +setSampleRateInDefinition = addMethod(M2kDigitalDefinition, ... + "double libm2k::digital::M2kDigital::setSampleRateIn(double samplerate)", ... + "MATLABName", "setSampleRateIn", ... + "Description", "setSampleRateIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the sample rate for all digital input channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getVerticalOffsetDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel the index of the channel"); -defineOutput(getVerticalOffsetDefinition, "RetVal", "double", "Description", "the value of the offset in Volts"); -validate(getVerticalOffsetDefinition); +defineArgument(setSampleRateInDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); +defineOutput(setSampleRateInDefinition, "RetVal", "double", "Description", "The current sample rate for all digital input channels"); +validate(setSampleRateInDefinition); -%% C++ class method |getScalingFactor| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getScalingFactor(libm2k::analog::ANALOG_IN_CHANNEL ch) +%% C++ class method |setSampleRateOut| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: double libm2k::digital::M2kDigital::setSampleRateOut(double samplerate) -getScalingFactorDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getScalingFactor(libm2k::analog::ANALOG_IN_CHANNEL ch)", ... - "MATLABName", "getScalingFactor", ... - "Description", "getScalingFactor Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the scaling factor", ... +setSampleRateOutDefinition = addMethod(M2kDigitalDefinition, ... + "double libm2k::digital::M2kDigital::setSampleRateOut(double samplerate)", ... + "MATLABName", "setSampleRateOut", ... + "Description", "setSampleRateOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the sample rate for all digital output channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getScalingFactorDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index"); -defineOutput(getScalingFactorDefinition, "RetVal", "double", "Description", "The value of the scaling factor"); -validate(getScalingFactorDefinition); +defineArgument(setSampleRateOutDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); +defineOutput(setSampleRateOutDefinition, "RetVal", "double", "Description", "The current sample rate for all digital output channels"); +validate(setSampleRateOutDefinition); -%% C++ class method |setRange| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,libm2k::analog::M2K_RANGE range) - -setRangeDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,libm2k::analog::M2K_RANGE range)", ... - "MATLABName", "setRange", ... - "Description", "setRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Set the range for the given channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index"); -defineArgument(setRangeDefinition, "range", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "range An enumerator corresponding to a range"); -validate(setRangeDefinition); - -%% C++ class method |setRange| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,double min,double max) +%% C++ class method |getSampleRateIn| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: double libm2k::digital::M2kDigital::getSampleRateIn() -setRangeDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,double min,double max)", ... - "MATLABName", "setRange", ... - "Description", "setRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Set the range for the given channel", ... +getSampleRateInDefinition = addMethod(M2kDigitalDefinition, ... + "double libm2k::digital::M2kDigital::getSampleRateIn()", ... + "MATLABName", "getSampleRateIn", ... + "Description", "getSampleRateIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the sample rate of all digital input channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index"); -defineArgument(setRangeDefinition, "min", "double", "Description", "min Upper bound"); -defineArgument(setRangeDefinition, "max", "double", "Description", "max Lower bound"); -validate(setRangeDefinition); +defineOutput(getSampleRateInDefinition, "RetVal", "double", "Description", "The value of the sample rate"); +validate(getSampleRateInDefinition); -%% C++ class method |getRange| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: libm2k::analog::M2K_RANGE libm2k::analog::M2kAnalogIn::getRange(libm2k::analog::ANALOG_IN_CHANNEL channel) +%% C++ class method |getSampleRateOut| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: double libm2k::digital::M2kDigital::getSampleRateOut() -getRangeDefinition = addMethod(M2kAnalogInDefinition, ... - "libm2k::analog::M2K_RANGE libm2k::analog::M2kAnalogIn::getRange(libm2k::analog::ANALOG_IN_CHANNEL channel)", ... - "MATLABName", "getRange", ... - "Description", "getRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the range for the given channel", ... +getSampleRateOutDefinition = addMethod(M2kDigitalDefinition, ... + "double libm2k::digital::M2kDigital::getSampleRateOut()", ... + "MATLABName", "getSampleRateOut", ... + "Description", "getSampleRateOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the sample rate of all digital output channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index"); -defineOutput(getRangeDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "An enumerator corresponding to the range"); -validate(getRangeDefinition); +defineOutput(getSampleRateOutDefinition, "RetVal", "double", "Description", "The value of the sample rate"); +validate(getSampleRateOutDefinition); -%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: int libm2k::analog::M2kAnalogIn::getOversamplingRatio() +%% C++ class method |getCyclic| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: bool libm2k::digital::M2kDigital::getCyclic() -getOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... - "int libm2k::analog::M2kAnalogIn::getOversamplingRatio()", ... - "MATLABName", "getOversamplingRatio", ... - "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the global oversampling ratio", ... +getCyclicDefinition = addMethod(M2kDigitalDefinition, ... + "bool libm2k::digital::M2kDigital::getCyclic()", ... + "MATLABName", "getCyclic", ... + "Description", "getCyclic Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the value of the cyclic mode", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The value of the global ratio"); -validate(getOversamplingRatioDefinition); +defineOutput(getCyclicDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the cyclic mode"); +validate(getCyclicDefinition); -%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: int libm2k::analog::M2kAnalogIn::getOversamplingRatio(unsigned int chn_idx) +%% C++ class method |setCyclic| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setCyclic(bool cyclic) -getOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... - "int libm2k::analog::M2kAnalogIn::getOversamplingRatio(unsigned int chn_idx)", ... - "MATLABName", "getOversamplingRatio", ... - "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the oversampling ratio for the given channel", ... +setCyclicDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setCyclic(bool cyclic)", ... + "MATLABName", "setCyclic", ... + "Description", "setCyclic Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Enable or disable the cyclic mode for all digital channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getOversamplingRatioDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel"); -defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The ratio value"); -validate(getOversamplingRatioDefinition); +defineArgument(setCyclicDefinition, "cyclic", "logical", "Description", "cyclic If true, enable cyclic mode"); +validate(setCyclicDefinition); -%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: int libm2k::analog::M2kAnalogIn::setOversamplingRatio(int oversampling) +%% C++ class method |getTrigger| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: libm2k::M2kHardwareTrigger * libm2k::digital::M2kDigital::getTrigger() -setOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... - "int libm2k::analog::M2kAnalogIn::setOversamplingRatio(int oversampling)", ... - "MATLABName", "setOversamplingRatio", ... - "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Set the global oversampling ratio", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setOversamplingRatioDefinition, "oversampling", "int32", "Description", "oversampling Integer value to set the oversampling ratio to"); -defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current value of the global ratio"); -validate(setOversamplingRatioDefinition); +%getTriggerDefinition = addMethod(M2kDigitalDefinition, ... +% "libm2k::M2kHardwareTrigger * libm2k::digital::M2kDigital::getTrigger()", ... +% "MATLABName", "getTrigger", ... +% "Description", "getTrigger Method of C++ class libm2k::digital::M2kDigital." + newline + ... +% "Get the hardware trigger handler", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineOutput(getTriggerDefinition, "RetVal", "clib.libm2k.libm2k.M2kHardwareTrigger", , "Description", "the trigger object"); +%validate(getTriggerDefinition); -%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: int libm2k::analog::M2kAnalogIn::setOversamplingRatio(unsigned int chn_idx,int oversampling) +%% C++ class method |setKernelBuffersCountIn| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setKernelBuffersCountIn(unsigned int count) -setOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... - "int libm2k::analog::M2kAnalogIn::setOversamplingRatio(unsigned int chn_idx,int oversampling)", ... - "MATLABName", "setOversamplingRatio", ... - "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Set the oversampling ratio for the given channel", ... +setKernelBuffersCountInDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setKernelBuffersCountIn(unsigned int count)", ... + "MATLABName", "setKernelBuffersCountIn", ... + "Description", "setKernelBuffersCountIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the kernel buffers for input to a specific value", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setOversamplingRatioDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel"); -defineArgument(setOversamplingRatioDefinition, "oversampling", "int32", "Description", "oversampling Integer value to set the oversampling ratio to"); -defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current ratio value"); -validate(setOversamplingRatioDefinition); +defineArgument(setKernelBuffersCountInDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); +validate(setKernelBuffersCountInDefinition); -%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getSampleRate() +%% C++ class method |setKernelBuffersCountOut| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setKernelBuffersCountOut(unsigned int count) -getSampleRateDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getSampleRate()", ... - "MATLABName", "getSampleRate", ... - "Description", "getSampleRate Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the global sample rate", ... +setKernelBuffersCountOutDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setKernelBuffersCountOut(unsigned int count)", ... + "MATLABName", "setKernelBuffersCountOut", ... + "Description", "setKernelBuffersCountOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the kernel buffers for output to a specific value", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate"); -validate(getSampleRateDefinition); +defineArgument(setKernelBuffersCountOutDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); +validate(setKernelBuffersCountOutDefinition); -%% C++ class method |getAvailableSampleRates| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogIn::getAvailableSampleRates() +%% C++ class method |getIioObjects| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: libm2k::IIO_OBJECTS libm2k::digital::M2kDigital::getIioObjects() -getAvailableSampleRatesDefinition = addMethod(M2kAnalogInDefinition, ... - "std::vector> libm2k::analog::M2kAnalogIn::getAvailableSampleRates()", ... - "MATLABName", "getAvailableSampleRates", ... - "Description", "getAvailableSampleRates Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "getAvailableSampleRates", ... +getIioObjectsDefinition = addMethod(M2kDigitalDefinition, ... + "libm2k::IIO_OBJECTS libm2k::digital::M2kDigital::getIioObjects()", ... + "MATLABName", "getIioObjects", ... + "Description", "getIioObjects Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Get access to IIO channels, buffers, devices and context." + newline + ... + " Can be used when debugging directly with libiio.", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getAvailableSampleRatesDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "The list of available samplerates for this device"); -validate(getAvailableSampleRatesDefinition); +defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure."); +validate(getIioObjectsDefinition); -%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::setSampleRate(double samplerate) +%% C++ class method |getNbChannelsIn| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: unsigned int libm2k::digital::M2kDigital::getNbChannelsIn() -setSampleRateDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::setSampleRate(double samplerate)", ... - "MATLABName", "setSampleRate", ... - "Description", "setSampleRate Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Set the global sample rate", ... +getNbChannelsInDefinition = addMethod(M2kDigitalDefinition, ... + "unsigned int libm2k::digital::M2kDigital::getNbChannelsIn()", ... + "MATLABName", "getNbChannelsIn", ... + "Description", "getNbChannelsIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the number of digital input channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setSampleRateDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); -defineOutput(setSampleRateDefinition, "RetVal", "double", "Description", "The value of the global sample rate"); -validate(setSampleRateDefinition); +defineOutput(getNbChannelsInDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of digital IN channels"); +validate(getNbChannelsInDefinition); -%% C++ class method |getFilterCompensation| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getFilterCompensation(double samplerate) +%% C++ class method |getNbChannelsOut| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: unsigned int libm2k::digital::M2kDigital::getNbChannelsOut() -getFilterCompensationDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getFilterCompensation(double samplerate)", ... - "MATLABName", "getFilterCompensation", ... - "Description", "getFilterCompensation Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the filter compensation for the given sample rate", ... +getNbChannelsOutDefinition = addMethod(M2kDigitalDefinition, ... + "unsigned int libm2k::digital::M2kDigital::getNbChannelsOut()", ... + "MATLABName", "getNbChannelsOut", ... + "Description", "getNbChannelsOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve the number of digital output channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getFilterCompensationDefinition, "samplerate", "double", "Description", "samplerate A double value representing the sample rate"); -defineOutput(getFilterCompensationDefinition, "RetVal", "double", "Description", "The value of the filter compensation"); -validate(getFilterCompensationDefinition); +defineOutput(getNbChannelsOutDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of digital OUT channels"); +validate(getNbChannelsOutDefinition); -%% C++ class method |getValueForRange| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getValueForRange(libm2k::analog::M2K_RANGE range) +%% C++ class method |getSamples| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::getSamples(std::vector> & data,unsigned int nb_samples) -getValueForRangeDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getValueForRange(libm2k::analog::M2K_RANGE range)", ... - "MATLABName", "getValueForRange", ... - "Description", "getValueForRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the numeric value corresponding to the given range", ... +getSamplesDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::getSamples(std::vector> & data,unsigned int nb_samples)", ... + "MATLABName", "getSamples", ... + "Description", "getSamples Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Retrieve a specific number of samples", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getValueForRangeDefinition, "range", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "range"); -defineOutput(getValueForRangeDefinition, "RetVal", "double", "Description", "double"); -validate(getValueForRangeDefinition); +defineArgument(getSamplesDefinition, "data", "clib.array.libm2k.UnsignedShort", "Description", "data - a reference to a vector owned/created by the client"); +defineArgument(getSamplesDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved. The vector will be cleaned and then filled with samples." + newline + ... + " @note Due to a hardware limitation, the number of samples must" + newline + ... + " be a multiple of 4 and greater than 16."); +validate(getSamplesDefinition); -%% C++ class method |convertRawToVolts| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::convertRawToVolts(unsigned int channel,short raw) +%% C++ class method |setRateMux| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setRateMux() -convertRawToVoltsDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::convertRawToVolts(unsigned int channel,short raw)", ... - "MATLABName", "convertRawToVolts", ... - "Description", "convertRawToVolts Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Convert the raw value of a sample into volts", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(convertRawToVoltsDefinition, "channel", "uint32", "Description", "raw: the raw value of a sample;"); -defineArgument(convertRawToVoltsDefinition, "raw", "int16", "Description", "channel: The index corresponding to the channel;"); -defineOutput(convertRawToVoltsDefinition, "RetVal", "double", "Description", "The value of a sample converted into volts;"); -validate(convertRawToVoltsDefinition); +setRateMuxDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setRateMux()", ... + "MATLABName", "setRateMux", ... + "Description", "setRateMux Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Force the digital interface to use the analogical rate", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@note Only available from firmware v0.26."); % Modify help description values as needed. +validate(setRateMuxDefinition); -%% C++ class method |convertVoltsToRaw| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: short libm2k::analog::M2kAnalogIn::convertVoltsToRaw(unsigned int channel,double voltage) +%% C++ class method |resetRateMux| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::resetRateMux() -convertVoltsToRawDefinition = addMethod(M2kAnalogInDefinition, ... - "short libm2k::analog::M2kAnalogIn::convertVoltsToRaw(unsigned int channel,double voltage)", ... - "MATLABName", "convertVoltsToRaw", ... - "Description", "convertVoltsToRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Convert the voltage value of a sample into raw", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(convertVoltsToRawDefinition, "channel", "uint32", "Description", "voltage The voltage value of a sample;"); -defineArgument(convertVoltsToRawDefinition, "voltage", "double", "Description", "channel The index corresponding to the channel;"); -defineOutput(convertVoltsToRawDefinition, "RetVal", "int16", "Description", "The value of a sample converted into raw;"); -validate(convertVoltsToRawDefinition); - -%% C++ class method |getNbChannels| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: unsigned int libm2k::analog::M2kAnalogIn::getNbChannels() - -getNbChannelsDefinition = addMethod(M2kAnalogInDefinition, ... - "unsigned int libm2k::analog::M2kAnalogIn::getNbChannels()", ... - "MATLABName", "getNbChannels", ... - "Description", "getNbChannels Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the number of analogical channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getNbChannelsDefinition, "RetVal", "uint32", "Description", "The number of channels"); -validate(getNbChannelsDefinition); - -%% C++ class method |getName| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: std::string libm2k::analog::M2kAnalogIn::getName() - -getNameDefinition = addMethod(M2kAnalogInDefinition, ... - "std::string libm2k::analog::M2kAnalogIn::getName()", ... - "MATLABName", "getName", ... - "Description", "getName Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the name of the device", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getNameDefinition, "RetVal", "string", "Description", "The name of the device"); -validate(getNameDefinition); +resetRateMuxDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::resetRateMux()", ... + "MATLABName", "resetRateMux", ... + "Description", "resetRateMux Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Reset the digital rate to default", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@note Only available from firmware v0.26."); % Modify help description values as needed. +validate(resetRateMuxDefinition); -%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::enableChannel(unsigned int chnIdx,bool enable) +%% C++ class method |setExternalClocksource| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: void libm2k::digital::M2kDigital::setExternalClocksource(bool external) -enableChannelDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::enableChannel(unsigned int chnIdx,bool enable)", ... - "MATLABName", "enableChannel", ... - "Description", "enableChannel Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Enable or disable the given channel", ... +setExternalClocksourceDefinition = addMethod(M2kDigitalDefinition, ... + "void libm2k::digital::M2kDigital::setExternalClocksource(bool external)", ... + "MATLABName", "setExternalClocksource", ... + "Description", "setExternalClocksource Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Set the clocksource", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableChannelDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); -validate(enableChannelDefinition); +defineArgument(setExternalClocksourceDefinition, "external", "logical", "Description", "external - True to set source to external" + newline + ... + " * - False to set source to internal"); +validate(setExternalClocksourceDefinition); -%% C++ class method |isChannelEnabled| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: bool libm2k::analog::M2kAnalogIn::isChannelEnabled(unsigned int chnIdx) +%% C++ class method |isClocksourceExternal| for C++ class |libm2k::digital::M2kDigital| +% C++ Signature: bool libm2k::digital::M2kDigital::isClocksourceExternal() -isChannelEnabledDefinition = addMethod(M2kAnalogInDefinition, ... - "bool libm2k::analog::M2kAnalogIn::isChannelEnabled(unsigned int chnIdx)", ... - "MATLABName", "isChannelEnabled", ... - "Description", "isChannelEnabled Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Retrieve the state of the given channel", ... +isClocksourceExternalDefinition = addMethod(M2kDigitalDefinition, ... + "bool libm2k::digital::M2kDigital::isClocksourceExternal()", ... + "MATLABName", "isClocksourceExternal", ... + "Description", "isClocksourceExternal Method of C++ class libm2k::digital::M2kDigital." + newline + ... + "Get the current clocksource", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(isChannelEnabledDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineOutput(isChannelEnabledDefinition, "RetVal", "logical", "Description", "True if the channel is enabled"); -validate(isChannelEnabledDefinition); - -%% C++ class method |cancelAcquisition| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::cancelAcquisition() +defineOutput(isClocksourceExternalDefinition, "RetVal", "logical", "Description", "True if clocksource is set to external"); +validate(isClocksourceExternalDefinition); -cancelAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::cancelAcquisition()", ... - "MATLABName", "cancelAcquisition", ... - "Description", "cancelAcquisition Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Cancel all buffer operations" + newline + ... - " @note Should be used to cancel an ongoing acquisition", ... +%% C++ enumeration |libm2k::digital::DIO_DIRECTION| with MATLAB name |clib.libm2k.libm2k.digital.DIO_DIRECTION| +addEnumeration(libDef, "libm2k::digital::DIO_DIRECTION", "int32",... + [... + "DIO_INPUT",... % 0 + "DIO_OUTPUT",... % 1 + ],... + "MATLABName", "clib.libm2k.libm2k.digital.DIO_DIRECTION", ... + "Description", "clib.libm2k.libm2k.digital.DIO_DIRECTION Representation of C++ enumeration libm2k::digital::DIO_DIRECTION." + newline + ... + "Direction of a digital channel", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@brief Cancel all buffer operations" + newline + ... - " @note Should be used to cancel an ongoing acquisition"); % Modify help description values as needed. -validate(cancelAcquisitionDefinition); + "@note Digital channels can be used both for transmitting and receiving digital signals"); % Modify help description values as needed. -%% C++ class method |setKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: void libm2k::analog::M2kAnalogIn::setKernelBuffersCount(unsigned int count) +%% C++ enumeration |libm2k::digital::DIO_LEVEL| with MATLAB name |clib.libm2k.libm2k.digital.DIO_LEVEL| +addEnumeration(libDef, "libm2k::digital::DIO_LEVEL", "int32",... + [... + "LOW",... % 0 + "HIGH",... % 1 + ],... + "MATLABName", "clib.libm2k.libm2k.digital.DIO_LEVEL", ... + "Description", "clib.libm2k.libm2k.digital.DIO_LEVEL Representation of C++ enumeration libm2k::digital::DIO_LEVEL." + newline + ... + "Logic voltage levels", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@note At any given time a digital signals can only take two possible values, namely low or high"); % Modify help description values as needed. -setKernelBuffersCountDefinition = addMethod(M2kAnalogInDefinition, ... - "void libm2k::analog::M2kAnalogIn::setKernelBuffersCount(unsigned int count)", ... - "MATLABName", "setKernelBuffersCount", ... - "Description", "setKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Set the kernel buffers to a specific value", ... +%% C++ enumeration |libm2k::digital::DIO_MODE| with MATLAB name |clib.libm2k.libm2k.digital.DIO_MODE| +addEnumeration(libDef, "libm2k::digital::DIO_MODE", "int32",... + [... + "DIO_OPENDRAIN",... % 0 + "DIO_PUSHPULL",... % 1 + ],... + "MATLABName", "clib.libm2k.libm2k.digital.DIO_MODE", ... + "Description", "clib.libm2k.libm2k.digital.DIO_MODE Representation of C++ enumeration libm2k::digital::DIO_MODE." + newline + ... + "Output mode for a digital channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setKernelBuffersCountDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); -validate(setKernelBuffersCountDefinition); - -%% C++ class method |getKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: unsigned int libm2k::analog::M2kAnalogIn::getKernelBuffersCount() const -getKernelBuffersCountDefinition = addMethod(M2kAnalogInDefinition, ... - "unsigned int libm2k::analog::M2kAnalogIn::getKernelBuffersCount() const", ... - "MATLABName", "getKernelBuffersCount", ... - "Description", "getKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Get the number of kernel buffers", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getKernelBuffersCountDefinition, "RetVal", "uint32", "Description", "the number of previously set kernel buffers (saved in this session)"); -validate(getKernelBuffersCountDefinition); +%% C++ class |libm2k::digital::channel| with MATLAB name |clib.libm2k.libm2k.digital.channel| +channelDefinition = addClass(libDef, "libm2k::digital::channel", "MATLABName", "clib.libm2k.libm2k.digital.channel", ... + "Description", "clib.libm2k.libm2k.digital.channel Representation of C++ class libm2k::digital::channel.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. -%% C++ class method |getTrigger| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogIn::getTrigger() +%% C++ class constructor for C++ class |libm2k::digital::channel| +% C++ Signature: libm2k::digital::channel::channel(libm2k::digital::channel const & input1) -getTriggerDefinition = addMethod(M2kAnalogInDefinition, ... - "libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogIn::getTrigger()", ... - "MATLABName", "getTrigger", ... - "Description", "getTrigger Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Get the hardware trigger handler", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getTriggerDefinition, "RetVal", "clib.libm2k.libm2k.M2kHardwareTrigger", 1, "Description", "A pointer to the hardware trigger trigger"); -validate(getTriggerDefinition); +channelConstructor1Definition = addConstructor(channelDefinition, ... + "libm2k::digital::channel::channel(libm2k::digital::channel const & input1)", ... + "Description", "clib.libm2k.libm2k.digital.channel Constructor of C++ class libm2k::digital::channel."); % Modify help description values as needed. +defineArgument(channelConstructor1Definition, "input1", "clib.libm2k.libm2k.digital.channel", "input"); +validate(channelConstructor1Definition); -%% C++ class method |getIioObjects| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogIn::getIioObjects() +%% C++ class constructor for C++ class |libm2k::digital::channel| +% C++ Signature: libm2k::digital::channel::channel() -getIioObjectsDefinition = addMethod(M2kAnalogInDefinition, ... - "libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogIn::getIioObjects()", ... - "MATLABName", "getIioObjects", ... - "Description", "getIioObjects Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Get access to IIO channels, buffers, devices and context." + newline + ... - " Can be used when debugging directly with libiio.", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure."); -validate(getIioObjectsDefinition); +channelConstructor2Definition = addConstructor(channelDefinition, ... + "libm2k::digital::channel::channel()", ... + "Description", "clib.libm2k.libm2k.digital.channel Constructor of C++ class libm2k::digital::channel."); % Modify help description values as needed. +validate(channelConstructor2Definition); -%% C++ class method |getChannelName| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: std::string libm2k::analog::M2kAnalogIn::getChannelName(unsigned int channel) +%% C++ class public data member |m_channel| for C++ class |libm2k::digital::channel| +% C++ Signature: iio_channel * libm2k::digital::channel::m_channel -getChannelNameDefinition = addMethod(M2kAnalogInDefinition, ... - "std::string libm2k::analog::M2kAnalogIn::getChannelName(unsigned int channel)", ... - "MATLABName", "getChannelName", ... - "Description", "getChannelName Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Get the channel name for each ADC channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getChannelNameDefinition, "channel", "uint32", "Description", "channel - unsigned int representing the index of the channel"); -defineOutput(getChannelNameDefinition, "RetVal", "string", "Description", "std::string - name of the channel"); -validate(getChannelNameDefinition); +%addProperty(channelDefinition, "m_channel", "clib.libm2k.iio_channel", , ... +% "Description", "clib.libm2k.iio_channel Data member of C++ class libm2k::digital::channel." + newline + ... +% "A pointer to an iio_channel structure"); % Modify help description values as needed. -%% C++ class method |getMaximumSamplerate| for C++ class |libm2k::analog::M2kAnalogIn| -% C++ Signature: double libm2k::analog::M2kAnalogIn::getMaximumSamplerate() +%% C++ class public data member |m_direction| for C++ class |libm2k::digital::channel| +% C++ Signature: libm2k::digital::DIO_DIRECTION libm2k::digital::channel::m_direction -getMaximumSamplerateDefinition = addMethod(M2kAnalogInDefinition, ... - "double libm2k::analog::M2kAnalogIn::getMaximumSamplerate()", ... - "MATLABName", "getMaximumSamplerate", ... - "Description", "getMaximumSamplerate Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... - "Get the maximum samplerate for the ADC", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getMaximumSamplerateDefinition, "RetVal", "double", "Description", "double - the value of the maximum samplerate"); -validate(getMaximumSamplerateDefinition); +addProperty(channelDefinition, "m_direction", "clib.libm2k.libm2k.digital.DIO_DIRECTION", ... + "Description", "clib.libm2k.libm2k.digital.DIO_DIRECTION Data member of C++ class libm2k::digital::channel." + newline + ... + "The direction of the channel"); % Modify help description values as needed. -%% C++ class |libm2k::analog::M2kAnalogOut| with MATLAB name |clib.libm2k.libm2k.analog.M2kAnalogOut| -M2kAnalogOutDefinition = addClass(libDef, "libm2k::analog::M2kAnalogOut", "MATLABName", "clib.libm2k.libm2k.analog.M2kAnalogOut", ... - "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut Representation of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Contains the representation of the analogical output segment" + newline + ... +%% C++ class |libm2k::analog::DMM| with MATLAB name |clib.libm2k.libm2k.analog.DMM| +DMMDefinition = addClass(libDef, "libm2k::analog::DMM", "MATLABName", "clib.libm2k.libm2k.analog.DMM", ... + "Description", "clib.libm2k.libm2k.analog.DMM Representation of C++ class libm2k::analog::DMM." + newline + ... + "Contains the representation of the digital multimeter" + newline + ... "" + newline + ... - "@class M2kAnalogOut" + newline + ... - "@brief Controls the analogical output compound", ... + "@class DMM dmm.hpp libm2k/analog/dmm.hpp" + newline + ... + "@brief Controls the digital multimeter", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@defgroup analogout AnalogOut" + newline + ... - "@brief Contains the representation of the analogical output segment" + newline + ... + "@defgroup dmm DMM" + newline + ... + "@brief Contains the representation of the digital multimeter" + newline + ... "" + newline + ... - "@class M2kAnalogOut" + newline + ... - "@brief Controls the analogical output compound"); % Modify help description values as needed. + "@class DMM dmm.hpp libm2k/analog/dmm.hpp" + newline + ... + "@brief Controls the digital multimeter"); % Modify help description values as needed. -%% C++ class method |reset| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::reset() +%% C++ class method |reset| for C++ class |libm2k::analog::DMM| +% C++ Signature: void libm2k::analog::DMM::reset() -resetDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::reset()", ... +resetDefinition = addMethod(DMMDefinition, ... + "void libm2k::analog::DMM::reset()", ... "MATLABName", "reset", ... - "Description", "reset Method of C++ class libm2k::analog::M2kAnalogOut.", ... + "Description", "reset Method of C++ class libm2k::analog::DMM.", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... "@private"); % Modify help description values as needed. validate(resetDefinition); -%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::getOversamplingRatio() +%% C++ class method |getAllChannels| for C++ class |libm2k::analog::DMM| +% C++ Signature: std::vector libm2k::analog::DMM::getAllChannels() -getOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... - "std::vector> libm2k::analog::M2kAnalogOut::getOversamplingRatio()", ... - "MATLABName", "getOversamplingRatio", ... - "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the global oversampling ratio", ... +getAllChannelsDefinition = addMethod(DMMDefinition, ... + "std::vector libm2k::analog::DMM::getAllChannels()", ... + "MATLABName", "getAllChannels", ... + "Description", "getAllChannels Method of C++ class libm2k::analog::DMM." + newline + ... + "Retrieve all channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getOversamplingRatioDefinition, "RetVal", "clib.array.libm2k.Int", "Description", "The value of the global oversampling ratio"); -validate(getOversamplingRatioDefinition); - -%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: int libm2k::analog::M2kAnalogOut::getOversamplingRatio(unsigned int chn) +defineOutput(getAllChannelsDefinition, "RetVal", "clib.array.libm2k.std.String", "Description", "A list containing the name of all channels"); +validate(getAllChannelsDefinition); -getOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... - "int libm2k::analog::M2kAnalogOut::getOversamplingRatio(unsigned int chn)", ... - "MATLABName", "getOversamplingRatio", ... - "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the oversampling ratio for the given channel", ... +%% C++ class method |readChannel| for C++ class |libm2k::analog::DMM| +% C++ Signature: libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(unsigned int index) + +readChannelDefinition = addMethod(DMMDefinition, ... + "libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(unsigned int index)", ... + "MATLABName", "readChannel", ... + "Description", "readChannel Method of C++ class libm2k::analog::DMM." + newline + ... + "Retrieve additional information about the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getOversamplingRatioDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The oversampling ratio value"); -validate(getOversamplingRatioDefinition); +defineArgument(readChannelDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); +defineOutput(readChannelDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM_READING", "Description", "A structure containing additional information"); +validate(readChannelDefinition); -%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::setOversamplingRatio(std::vector> oversampling_ratio) +%% C++ class method |readChannel| for C++ class |libm2k::analog::DMM| +% C++ Signature: libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(std::string chn_name) -setOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... - "std::vector> libm2k::analog::M2kAnalogOut::setOversamplingRatio(std::vector> oversampling_ratio)", ... - "MATLABName", "setOversamplingRatio", ... - "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Set the value of the oversampling ratio for each channel", ... +readChannelDefinition = addMethod(DMMDefinition, ... + "libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(std::string chn_name)", ... + "MATLABName", "readChannel", ... + "Description", "readChannel Method of C++ class libm2k::analog::DMM." + newline + ... + "Retrieve additional information about the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setOversamplingRatioDefinition, "oversampling_ratio", "clib.array.libm2k.Int", "Description", "oversampling_ratio A list containing the ratios for each channel (as integers)"); -defineOutput(setOversamplingRatioDefinition, "RetVal", "clib.array.libm2k.Int", "Description", "A list containing the oversampling ratio value for each channel"); -validate(setOversamplingRatioDefinition); +defineArgument(readChannelDefinition, "chn_name", "string", "Description", "chn_name The name corresponding to the channel"); +defineOutput(readChannelDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM_READING", "Description", "A structure containing additional information"); +validate(readChannelDefinition); -%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: int libm2k::analog::M2kAnalogOut::setOversamplingRatio(unsigned int chn,int oversampling_ratio) +%% C++ class method |readAll| for C++ class |libm2k::analog::DMM| +% C++ Signature: std::vector> libm2k::analog::DMM::readAll() -setOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... - "int libm2k::analog::M2kAnalogOut::setOversamplingRatio(unsigned int chn,int oversampling_ratio)", ... - "MATLABName", "setOversamplingRatio", ... - "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Set the oversampling ratio for the given channel", ... +readAllDefinition = addMethod(DMMDefinition, ... + "std::vector> libm2k::analog::DMM::readAll()", ... + "MATLABName", "readAll", ... + "Description", "readAll Method of C++ class libm2k::analog::DMM." + newline + ... + "Retrieve additional information about all channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setOversamplingRatioDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineArgument(setOversamplingRatioDefinition, "oversampling_ratio", "int32", "Description", "oversampling_ratio Integer value to set the oversampling ratio to"); -defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current oversampling ratio value"); -validate(setOversamplingRatioDefinition); +defineOutput(readAllDefinition, "RetVal", "clib.array.libm2k.libm2k.analog.DMM_READING", "Description", "A list containing structures for each channel"); +validate(readAllDefinition); -%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::getSampleRate() +%% C++ class method |getName| for C++ class |libm2k::analog::DMM| +% C++ Signature: std::string libm2k::analog::DMM::getName() -getSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... - "std::vector> libm2k::analog::M2kAnalogOut::getSampleRate()", ... - "MATLABName", "getSampleRate", ... - "Description", "getSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the sample rate of both DACs", ... +getNameDefinition = addMethod(DMMDefinition, ... + "std::string libm2k::analog::DMM::getName()", ... + "MATLABName", "getName", ... + "Description", "getName Method of C++ class libm2k::analog::DMM." + newline + ... + "Retrieve the device's name", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getSampleRateDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the sample rates"); -validate(getSampleRateDefinition); - -%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: double libm2k::analog::M2kAnalogOut::getSampleRate(unsigned int chn) +defineOutput(getNameDefinition, "RetVal", "string", "Description", "The name of the device"); +validate(getNameDefinition); -getSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... - "double libm2k::analog::M2kAnalogOut::getSampleRate(unsigned int chn)", ... - "MATLABName", "getSampleRate", ... - "Description", "getSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the sample rate for the given channel", ... +%% C++ class |libm2k::analog::DMM_READING| with MATLAB name |clib.libm2k.libm2k.analog.DMM_READING| +DMM_READINGDefinition = addClass(libDef, "libm2k::analog::DMM_READING", "MATLABName", "clib.libm2k.libm2k.analog.DMM_READING", ... + "Description", "clib.libm2k.libm2k.analog.DMM_READING Representation of C++ class libm2k::analog::DMM_READING." + newline + ... + "The structure of a DMM", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getSampleRateDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineOutput(getSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate"); -validate(getSampleRateDefinition); -%% C++ class method |getAvailableSampleRates| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::getAvailableSampleRates(unsigned int chn) +%% C++ class constructor for C++ class |libm2k::analog::DMM_READING| +% C++ Signature: libm2k::analog::DMM_READING::DMM_READING() -getAvailableSampleRatesDefinition = addMethod(M2kAnalogOutDefinition, ... - "std::vector> libm2k::analog::M2kAnalogOut::getAvailableSampleRates(unsigned int chn)", ... - "MATLABName", "getAvailableSampleRates", ... - "Description", "getAvailableSampleRates Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "getAvailableSampleRates", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getAvailableSampleRatesDefinition, "chn", "uint32", "Description", "chn The index corresponding to the required channel"); -defineOutput(getAvailableSampleRatesDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "The list of available samplerates for this device"); -validate(getAvailableSampleRatesDefinition); +DMM_READINGConstructor1Definition = addConstructor(DMM_READINGDefinition, ... + "libm2k::analog::DMM_READING::DMM_READING()", ... + "Description", "clib.libm2k.libm2k.analog.DMM_READING Constructor of C++ class libm2k::analog::DMM_READING."); % Modify help description values as needed. +validate(DMM_READINGConstructor1Definition); -%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::setSampleRate(std::vector> samplerates) +%% C++ class constructor for C++ class |libm2k::analog::DMM_READING| +% C++ Signature: libm2k::analog::DMM_READING::DMM_READING(libm2k::analog::DMM_READING const & input1) -setSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... - "std::vector> libm2k::analog::M2kAnalogOut::setSampleRate(std::vector> samplerates)", ... - "MATLABName", "setSampleRate", ... - "Description", "setSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Set the sample rate for both channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setSampleRateDefinition, "samplerates", "clib.array.libm2k.Double", "Description", "samplerates A list containing the sample rates of each channel"); -defineOutput(setSampleRateDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the previously set sample rates"); -validate(setSampleRateDefinition); +DMM_READINGConstructor2Definition = addConstructor(DMM_READINGDefinition, ... + "libm2k::analog::DMM_READING::DMM_READING(libm2k::analog::DMM_READING const & input1)", ... + "Description", "clib.libm2k.libm2k.analog.DMM_READING Constructor of C++ class libm2k::analog::DMM_READING."); % Modify help description values as needed. +defineArgument(DMM_READINGConstructor2Definition, "input1", "clib.libm2k.libm2k.analog.DMM_READING", "input"); +validate(DMM_READINGConstructor2Definition); -%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: double libm2k::analog::M2kAnalogOut::setSampleRate(unsigned int chn,double samplerate) +%% C++ class public data member |name| for C++ class |libm2k::analog::DMM_READING| +% C++ Signature: std::string libm2k::analog::DMM_READING::name -setSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... - "double libm2k::analog::M2kAnalogOut::setSampleRate(unsigned int chn,double samplerate)", ... - "MATLABName", "setSampleRate", ... - "Description", "setSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Set the sample rate for the given channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setSampleRateDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineArgument(setSampleRateDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); -defineOutput(setSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate"); -validate(setSampleRateDefinition); +addProperty(DMM_READINGDefinition, "name", "string", ... + "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... + "The name of the channel"); % Modify help description values as needed. -%% C++ class method |setSyncedDma| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::setSyncedDma(bool en,int chn = -1) +%% C++ class public data member |id| for C++ class |libm2k::analog::DMM_READING| +% C++ Signature: std::string libm2k::analog::DMM_READING::id -setSyncedDmaDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::setSyncedDma(bool en,int chn = -1)", ... - "MATLABName", "setSyncedDma", ... - "Description", "setSyncedDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -defineArgument(setSyncedDmaDefinition, "en", "logical"); -defineArgument(setSyncedDmaDefinition, "chn", "int32"); -validate(setSyncedDmaDefinition); +addProperty(DMM_READINGDefinition, "id", "string", ... + "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... + "Channel's id"); % Modify help description values as needed. -%% C++ class method |getSyncedDma| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: bool libm2k::analog::M2kAnalogOut::getSyncedDma(int chn = -1) +%% C++ class public data member |value| for C++ class |libm2k::analog::DMM_READING| +% C++ Signature: double libm2k::analog::DMM_READING::value -getSyncedDmaDefinition = addMethod(M2kAnalogOutDefinition, ... - "bool libm2k::analog::M2kAnalogOut::getSyncedDma(int chn = -1)", ... - "MATLABName", "getSyncedDma", ... - "Description", "getSyncedDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -defineArgument(getSyncedDmaDefinition, "chn", "int32"); -defineOutput(getSyncedDmaDefinition, "RetVal", "logical"); -validate(getSyncedDmaDefinition); +addProperty(DMM_READINGDefinition, "value", "double", ... + "Description", "double Data member of C++ class libm2k::analog::DMM_READING." + newline + ... + "The measured value"); % Modify help description values as needed. -%% C++ class method |setSyncedStartDma| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::setSyncedStartDma(bool en,int chn = -1) +%% C++ class public data member |unit_name| for C++ class |libm2k::analog::DMM_READING| +% C++ Signature: std::string libm2k::analog::DMM_READING::unit_name -setSyncedStartDmaDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::setSyncedStartDma(bool en,int chn = -1)", ... - "MATLABName", "setSyncedStartDma", ... - "Description", "setSyncedStartDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... +addProperty(DMM_READINGDefinition, "unit_name", "string", ... + "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... + "Unit of measurement"); % Modify help description values as needed. + +%% C++ class public data member |unit_symbol| for C++ class |libm2k::analog::DMM_READING| +% C++ Signature: std::string libm2k::analog::DMM_READING::unit_symbol + +addProperty(DMM_READINGDefinition, "unit_symbol", "string", ... + "Description", "string Data member of C++ class libm2k::analog::DMM_READING." + newline + ... + "Unit symbol"); % Modify help description values as needed. + +%% C++ class |libm2k::analog::M2kAnalogIn| with MATLAB name |clib.libm2k.libm2k.analog.M2kAnalogIn| +M2kAnalogInDefinition = addClass(libDef, "libm2k::analog::M2kAnalogIn", "MATLABName", "clib.libm2k.libm2k.analog.M2kAnalogIn", ... + "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn Representation of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Contains the representation of the analogical input segment" + newline + ... + "" + newline + ... + "@class M2kAnalogIn m2kanalogin.hpp libm2k/analog/m2kanalogin.hpp" + newline + ... + "@brief Controls the analogical input compound", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@private"); % Modify help description values as needed. -defineArgument(setSyncedStartDmaDefinition, "en", "logical"); -defineArgument(setSyncedStartDmaDefinition, "chn", "int32"); -validate(setSyncedStartDmaDefinition); + "@defgroup analogin AnalogIn" + newline + ... + "@brief Contains the representation of the analogical input segment" + newline + ... + "" + newline + ... + "@class M2kAnalogIn m2kanalogin.hpp libm2k/analog/m2kanalogin.hpp" + newline + ... + "@brief Controls the analogical input compound"); % Modify help description values as needed. -%% C++ class method |getSyncedStartDma| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: bool libm2k::analog::M2kAnalogOut::getSyncedStartDma(int chn = -1) +%% C++ class method |reset| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::reset() -getSyncedStartDmaDefinition = addMethod(M2kAnalogOutDefinition, ... - "bool libm2k::analog::M2kAnalogOut::getSyncedStartDma(int chn = -1)", ... - "MATLABName", "getSyncedStartDma", ... - "Description", "getSyncedStartDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... +resetDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::reset()", ... + "MATLABName", "reset", ... + "Description", "reset Method of C++ class libm2k::analog::M2kAnalogIn.", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... "@private"); % Modify help description values as needed. -defineArgument(getSyncedStartDmaDefinition, "chn", "int32"); -defineOutput(getSyncedStartDmaDefinition, "RetVal", "logical"); -validate(getSyncedStartDmaDefinition); +validate(resetDefinition); -%% C++ class method |setCyclic| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::setCyclic(bool en) +%% C++ class method |startAcquisition| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::startAcquisition(unsigned int nb_samples) -setCyclicDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::setCyclic(bool en)", ... - "MATLABName", "setCyclic", ... - "Description", "setCyclic Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Enable or disable the cyclic mode for all digital channels", ... +startAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::startAcquisition(unsigned int nb_samples)", ... + "MATLABName", "startAcquisition", ... + "Description", "startAcquisition Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Create the buffer for both channels and start the acquisition", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setCyclicDefinition, "en", "logical", "Description", "en If true, enable cyclic mode"); -validate(setCyclicDefinition); +defineArgument(startAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples size of the buffer in samples for each channel"); +validate(startAcquisitionDefinition); -%% C++ class method |setCyclic| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::setCyclic(unsigned int chn,bool en) +%% C++ class method |stopAcquisition| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::stopAcquisition() -setCyclicDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::setCyclic(unsigned int chn,bool en)", ... - "MATLABName", "setCyclic", ... - "Description", "setCyclic Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Enable or disable the cyclic mode for all digital channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setCyclicDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineArgument(setCyclicDefinition, "en", "logical", "Description", "en If true, enable cyclic mode"); -validate(setCyclicDefinition); - -%% C++ class method |getCyclic| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: bool libm2k::analog::M2kAnalogOut::getCyclic(unsigned int chn) - -getCyclicDefinition = addMethod(M2kAnalogOutDefinition, ... - "bool libm2k::analog::M2kAnalogOut::getCyclic(unsigned int chn)", ... - "MATLABName", "getCyclic", ... - "Description", "getCyclic Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the value of the cyclic mode", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getCyclicDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineOutput(getCyclicDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the cyclic mode"); -validate(getCyclicDefinition); +stopAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::stopAcquisition()", ... + "MATLABName", "stopAcquisition", ... + "Description", "stopAcquisition Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Destroy the buffer and stop the acquisition", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@brief Destroy the buffer and stop the acquisition"); % Modify help description values as needed. +validate(stopAcquisitionDefinition); -%% C++ class method |getScalingFactor| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: double libm2k::analog::M2kAnalogOut::getScalingFactor(unsigned int chn) +%% C++ class method |getSamplesInterleaved| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved(unsigned int nb_samples_per_channel) -getScalingFactorDefinition = addMethod(M2kAnalogOutDefinition, ... - "double libm2k::analog::M2kAnalogOut::getScalingFactor(unsigned int chn)", ... - "MATLABName", "getScalingFactor", ... - "Description", "getScalingFactor Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the scaling factor for the given channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getScalingFactorDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineOutput(getScalingFactorDefinition, "RetVal", "double", "Description", "The value of the scaling factor"); -validate(getScalingFactorDefinition); +%getSamplesInterleavedDefinition = addMethod(M2kAnalogInDefinition, ... +% "double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved(unsigned int nb_samples_per_channel)", ... +% "MATLABName", "getSamplesInterleaved", ... +% "Description", "getSamplesInterleaved Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... +% "Retrieve a specific number of samples from each channel", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineArgument(getSamplesInterleavedDefinition, "nb_samples_per_channel", "uint32", "Description", "nb_samples_per_channel The number of samples that will be retrieved"); +%defineOutput(getSamplesInterleavedDefinition, "RetVal", "clib.array.libm2k.Double", , "Description", "A pointer to the interleaved samples"); % can be "clib.array.libm2k.Double", or "double" +%validate(getSamplesInterleavedDefinition); -%% C++ class method |getFilterCompensation| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: double libm2k::analog::M2kAnalogOut::getFilterCompensation(double samplerate) +%% C++ class method |getSamplesRawInterleaved| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved(unsigned int nb_samples_per_channel) -getFilterCompensationDefinition = addMethod(M2kAnalogOutDefinition, ... - "double libm2k::analog::M2kAnalogOut::getFilterCompensation(double samplerate)", ... - "MATLABName", "getFilterCompensation", ... - "Description", "getFilterCompensation Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the filter compensation for the given sample rate", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getFilterCompensationDefinition, "samplerate", "double", "Description", "samplerate A double value representing the sample rate"); -defineOutput(getFilterCompensationDefinition, "RetVal", "double", "Description", "The value of the filter compensation"); -validate(getFilterCompensationDefinition); +%getSamplesRawInterleavedDefinition = addMethod(M2kAnalogInDefinition, ... +% "short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved(unsigned int nb_samples_per_channel)", ... +% "MATLABName", "getSamplesRawInterleaved", ... +% "Description", "getSamplesRawInterleaved Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... +% "Retrieve a specific number of raw samples from each channel", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineArgument(getSamplesRawInterleavedDefinition, "nb_samples_per_channel", "uint32", "Description", "nb_samples_per_channel The number of samples that will be retrieved"); +%defineOutput(getSamplesRawInterleavedDefinition, "RetVal", "clib.array.libm2k.Short", , "Description", "A pointer to the interleaved raw samples"); % can be "clib.array.libm2k.Short", or "int16" +%validate(getSamplesRawInterleavedDefinition); -%% C++ class method |pushBytes| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::pushBytes(unsigned int chnIdx,double * data,unsigned int nb_samples) +%% C++ class method |getSamplesInterleaved_matlab| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved_matlab(unsigned int nb_samples) -pushBytesDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::pushBytes(unsigned int chnIdx,double * data,unsigned int nb_samples)", ... - "MATLABName", "pushBytes", ... - "Description", "pushBytes Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Send the samples to the given channel", ... +getSamplesInterleaved_matlabDefinition = addMethod(M2kAnalogInDefinition, ... + "double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved_matlab(unsigned int nb_samples)", ... + "MATLABName", "getSamplesInterleaved_matlab", ... + "Description", "getSamplesInterleaved_matlab Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve a specific number of samples from both channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushBytesDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineArgument(pushBytesDefinition, "data", "clib.array.libm2k.Double", "input", "nb_samples", "Description", "data A pointer to the samples"); % can be "clib.array.libm2k.Double", or "double" -defineArgument(pushBytesDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples"); -validate(pushBytesDefinition); +defineArgument(getSamplesInterleaved_matlabDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); +defineOutput(getSamplesInterleaved_matlabDefinition, "RetVal", "clib.array.libm2k.Double", "nb_samples", "Description", "A pointer to the interleaved samples"); % can be "clib.array.libm2k.Double", or "double" +validate(getSamplesInterleaved_matlabDefinition); -%% C++ class method |pushRawBytes| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRawBytes(unsigned int chnIdx,short * data,unsigned int nb_samples) +%% C++ class method |getSamplesRawInterleaved_matlab| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved_matlab(unsigned int nb_samples) -pushRawBytesDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::pushRawBytes(unsigned int chnIdx,short * data,unsigned int nb_samples)", ... - "MATLABName", "pushRawBytes", ... - "Description", "pushRawBytes Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Send the samples to the given channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushRawBytesDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineArgument(pushRawBytesDefinition, "data", "clib.array.libm2k.Short", "input", "nb_samples", "Description", "data A pointer to the raw samples"); % can be "clib.array.libm2k.Short", or "int16" -defineArgument(pushRawBytesDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples"); -validate(pushRawBytesDefinition); +%getSamplesRawInterleaved_matlabDefinition = addMethod(M2kAnalogInDefinition, ... +% "short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved_matlab(unsigned int nb_samples)", ... +% "MATLABName", "getSamplesRawInterleaved_matlab", ... +% "Description", "getSamplesRawInterleaved_matlab Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... +% "Retrieve a specific number of raw samples from both channels", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineArgument(getSamplesRawInterleaved_matlabDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); +%defineOutput(getSamplesRawInterleaved_matlabDefinition, "RetVal", "clib.array.libm2k.Short", , "Description", "A pointer to the interleaved raw samples"); % can be "clib.array.libm2k.Short", or "int16" +%validate(getSamplesRawInterleaved_matlabDefinition); -%% C++ class method |pushInterleaved| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::pushInterleaved(double * data,unsigned int nb_channels,unsigned int nb_samples) +%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: short libm2k::analog::M2kAnalogIn::getVoltageRaw(unsigned int ch) -pushInterleavedDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::pushInterleaved(double * data,unsigned int nb_channels,unsigned int nb_samples)", ... - "MATLABName", "pushInterleaved", ... - "Description", "pushInterleaved Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Send samples to all the channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushInterleavedDefinition, "data", "clib.array.libm2k.Double", "input", "nb_samples", "Description", "data A pointer to the interleaved data"); % can be "clib.array.libm2k.Double", or "double" -defineArgument(pushInterleavedDefinition, "nb_channels", "uint32", "Description", "nb_channels the number of channels on which we want to push"); -defineArgument(pushInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples total (samples_per_channel channels)" + newline + ... - " @note Make sure the samples are interleaved" + newline + ... - " @note Streaming data is possible - required multiple kernel buffers" + newline + ... - " @note The given channel will be synchronized with the other channel" + newline + ... - " @note Due to a hardware limitation, the number of samples per channel must" + newline + ... - " be a multiple of 4 and greater than 16 (non-cyclic buffers) or 1024 (cyclic buffers)" + newline + ... - " @note The samples in the buffer can be repeated until the buffer reaches the size requirements"); -validate(pushInterleavedDefinition); +getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ... + "short libm2k::analog::M2kAnalogIn::getVoltageRaw(unsigned int ch)", ... + "MATLABName", "getVoltageRaw", ... + "Description", "getVoltageRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the average raw value of the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getVoltageRawDefinition, "ch", "uint32", "Description", "ch The index corresponding to the channel"); +defineOutput(getVoltageRawDefinition, "RetVal", "int16", "Description", "The average raw value"); +validate(getVoltageRawDefinition); -%% C++ class method |pushRawInterleaved| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRawInterleaved(short * data,unsigned int nb_channels,unsigned int nb_samples) +%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getVoltage(unsigned int ch) -pushRawInterleavedDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::pushRawInterleaved(short * data,unsigned int nb_channels,unsigned int nb_samples)", ... - "MATLABName", "pushRawInterleaved", ... - "Description", "pushRawInterleaved Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Send samples to all the channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushRawInterleavedDefinition, "data", "clib.array.libm2k.Short", "input", "nb_samples", "Description", "data A pointer to the interleaved raw data"); % can be "clib.array.libm2k.Short", or "int16" -defineArgument(pushRawInterleavedDefinition, "nb_channels", "uint32", "Description", "nb_channels the number of channels on which we want to push"); -defineArgument(pushRawInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples total (samples_per_channel channels)" + newline + ... - " @note Make sure the raw samples are interleaved" + newline + ... - " @note Streaming data is possible - required multiple kernel buffers" + newline + ... - " @note The given channel will be synchronized with the other channel" + newline + ... - " @note Due to a hardware limitation, the number of samples per channel must" + newline + ... - " be a multiple of 4 and greater than 16 (non-cyclic buffers) or 1024 (cyclic buffers)" + newline + ... - " @note The samples in the buffer can be repeated until the buffer reaches the size requirements"); -validate(pushRawInterleavedDefinition); +getVoltageDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getVoltage(unsigned int ch)", ... + "MATLABName", "getVoltage", ... + "Description", "getVoltage Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the average voltage of the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getVoltageDefinition, "ch", "uint32", "Description", "ch The index corresponding to the channel"); +defineOutput(getVoltageDefinition, "RetVal", "double", "Description", "The average voltage"); +validate(getVoltageDefinition); -%% C++ class method |push| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::push(unsigned int chnIdx,std::vector> const & data) +%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: short libm2k::analog::M2kAnalogIn::getVoltageRaw(libm2k::analog::ANALOG_IN_CHANNEL ch) -pushDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::push(unsigned int chnIdx,std::vector> const & data)", ... - "MATLABName", "push", ... - "Description", "push Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Send the samples to the given channel", ... +getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ... + "short libm2k::analog::M2kAnalogIn::getVoltageRaw(libm2k::analog::ANALOG_IN_CHANNEL ch)", ... + "MATLABName", "getVoltageRaw", ... + "Description", "getVoltageRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the average raw value of the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineArgument(pushDefinition, "data", "clib.array.libm2k.Double", "Description", "data A list of doubles containing all samples"); -validate(pushDefinition); +defineArgument(getVoltageRawDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index"); +defineOutput(getVoltageRawDefinition, "RetVal", "int16", "Description", "The average raw value"); +validate(getVoltageRawDefinition); -%% C++ class method |pushRaw| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRaw(unsigned int chnIdx,std::vector> const & data) +%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getVoltage(libm2k::analog::ANALOG_IN_CHANNEL ch) -pushRawDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::pushRaw(unsigned int chnIdx,std::vector> const & data)", ... - "MATLABName", "pushRaw", ... - "Description", "pushRaw Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Send the samples to the given channel", ... +getVoltageDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getVoltage(libm2k::analog::ANALOG_IN_CHANNEL ch)", ... + "MATLABName", "getVoltage", ... + "Description", "getVoltage Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the average voltage of the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushRawDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineArgument(pushRawDefinition, "data", "clib.array.libm2k.Short", "Description", "data A list of shorts containing all samples"); -validate(pushRawDefinition); +defineArgument(getVoltageDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index"); +defineOutput(getVoltageDefinition, "RetVal", "double", "Description", "The average voltage"); +validate(getVoltageDefinition); -%% C++ class method |stop| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::stop() +%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogIn::getVoltageRaw() -stopDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::stop()", ... - "MATLABName", "stop", ... - "Description", "stop Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Stop all channels from sending the signals.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@note Both DACs will be powered down"); % Modify help description values as needed. -validate(stopDefinition); +getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ... + "std::vector> libm2k::analog::M2kAnalogIn::getVoltageRaw()", ... + "MATLABName", "getVoltageRaw", ... + "Description", "getVoltageRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the average raw value for each channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getVoltageRawDefinition, "RetVal", "clib.array.libm2k.Short", "Description", "A list containing the average raw value of each channel"); +validate(getVoltageRawDefinition); -%% C++ class method |stop| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::stop(unsigned int chn) +%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogIn::getVoltage() -stopDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::stop(unsigned int chn)", ... - "MATLABName", "stop", ... - "Description", "stop Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Stop the given channels from sending the signals", ... +getVoltageDefinition = addMethod(M2kAnalogInDefinition, ... + "std::vector> libm2k::analog::M2kAnalogIn::getVoltage()", ... + "MATLABName", "getVoltage", ... + "Description", "getVoltage Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the average voltage for each channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(stopDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -validate(stopDefinition); - -%% C++ class method |cancelBuffer| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::cancelBuffer() +defineOutput(getVoltageDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the average voltage of each channel"); +validate(getVoltageDefinition); -cancelBufferDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::cancelBuffer()", ... - "MATLABName", "cancelBuffer", ... - "Description", "cancelBuffer Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Cancel all buffer operations of enabled channels" + newline + ... - " @note Should be used to cancel an ongoing data write.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@brief Cancel all buffer operations of enabled channels" + newline + ... - " @note Should be used to cancel an ongoing data write."); % Modify help description values as needed. -validate(cancelBufferDefinition); - -%% C++ class method |cancelBuffer| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::cancelBuffer(unsigned int chn) +%% C++ class method |getVoltageRawP| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getVoltageRawP() -cancelBufferDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::cancelBuffer(unsigned int chn)", ... - "MATLABName", "cancelBuffer", ... - "Description", "cancelBuffer Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Cancel all buffer operations of the given channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(cancelBufferDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel" + newline + ... - " @note Should be used to cancel an ongoing data write."); -validate(cancelBufferDefinition); +%getVoltageRawPDefinition = addMethod(M2kAnalogInDefinition, ... +% "short const * libm2k::analog::M2kAnalogIn::getVoltageRawP()", ... +% "MATLABName", "getVoltageRawP", ... +% "Description", "getVoltageRawP Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... +% "Retrieve the average raw value for both channels", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineOutput(getVoltageRawPDefinition, "RetVal", "clib.array.libm2k.Short", , "Description", "A pointer to the average raw value of both channels"); % can be "clib.array.libm2k.Short", or "int16" +%validate(getVoltageRawPDefinition); -%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::enableChannel(unsigned int chnIdx,bool enable) +%% C++ class method |getVoltageP| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getVoltageP() -enableChannelDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::enableChannel(unsigned int chnIdx,bool enable)", ... - "MATLABName", "enableChannel", ... - "Description", "enableChannel Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Enable or disable the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableChannelDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); -validate(enableChannelDefinition); +%getVoltagePDefinition = addMethod(M2kAnalogInDefinition, ... +% "double const * libm2k::analog::M2kAnalogIn::getVoltageP()", ... +% "MATLABName", "getVoltageP", ... +% "Description", "getVoltageP Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... +% "Retrieve the average voltage for both channels", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineOutput(getVoltagePDefinition, "RetVal", "clib.array.libm2k.Double", , "Description", "A pointer to the average voltage of both channels"); % can be "clib.array.libm2k.Double", or "double" +%validate(getVoltagePDefinition); -%% C++ class method |isChannelEnabled| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: bool libm2k::analog::M2kAnalogOut::isChannelEnabled(unsigned int chnIdx) +%% C++ class method |setVerticalOffset| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::setVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel,double vertOffset) -isChannelEnabledDefinition = addMethod(M2kAnalogOutDefinition, ... - "bool libm2k::analog::M2kAnalogOut::isChannelEnabled(unsigned int chnIdx)", ... - "MATLABName", "isChannelEnabled", ... - "Description", "isChannelEnabled Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Check if the given channel is enabled", ... +setVerticalOffsetDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::setVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel,double vertOffset)", ... + "MATLABName", "setVerticalOffset", ... + "Description", "setVerticalOffset Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Set the vertical offset, in Volts, of a specific channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(isChannelEnabledDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineOutput(isChannelEnabledDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the channel"); -validate(isChannelEnabledDefinition); +defineArgument(setVerticalOffsetDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel the index of the channel"); +defineArgument(setVerticalOffsetDefinition, "vertOffset", "double", "Description", "vertOffset the value of the offset in Volts"); +validate(setVerticalOffsetDefinition); -%% C++ class method |isPushDone| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: bool libm2k::analog::M2kAnalogOut::isPushDone(unsigned int chnIdx) const +%% C++ class method |getVerticalOffset| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel) -isPushDoneDefinition = addMethod(M2kAnalogOutDefinition, ... - "bool libm2k::analog::M2kAnalogOut::isPushDone(unsigned int chnIdx) const", ... - "MATLABName", "isPushDone", ... - "Description", "isPushDone Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Check if the generation of the signal (only for non-cyclic buffer) is done", ... +getVerticalOffsetDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel)", ... + "MATLABName", "getVerticalOffset", ... + "Description", "getVerticalOffset Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "getVerticalOffset", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(isPushDoneDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineOutput(isPushDoneDefinition, "RetVal", "logical", "Description", "True if the push process is done, false otherwise"); -validate(isPushDoneDefinition); +defineArgument(getVerticalOffsetDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel the index of the channel"); +defineOutput(getVerticalOffsetDefinition, "RetVal", "double", "Description", "the value of the offset in Volts"); +validate(getVerticalOffsetDefinition); -%% C++ class method |setKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: void libm2k::analog::M2kAnalogOut::setKernelBuffersCount(unsigned int chnIdx,unsigned int count) +%% C++ class method |getScalingFactor| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getScalingFactor(libm2k::analog::ANALOG_IN_CHANNEL ch) -setKernelBuffersCountDefinition = addMethod(M2kAnalogOutDefinition, ... - "void libm2k::analog::M2kAnalogOut::setKernelBuffersCount(unsigned int chnIdx,unsigned int count)", ... - "MATLABName", "setKernelBuffersCount", ... - "Description", "setKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Set the kernel buffers to a specific value", ... +getScalingFactorDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getScalingFactor(libm2k::analog::ANALOG_IN_CHANNEL ch)", ... + "MATLABName", "getScalingFactor", ... + "Description", "getScalingFactor Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the scaling factor", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setKernelBuffersCountDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineArgument(setKernelBuffersCountDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); -validate(setKernelBuffersCountDefinition); +defineArgument(getScalingFactorDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index"); +defineOutput(getScalingFactorDefinition, "RetVal", "double", "Description", "The value of the scaling factor"); +validate(getScalingFactorDefinition); -%% C++ class method |getKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: unsigned int libm2k::analog::M2kAnalogOut::getKernelBuffersCount(unsigned int chnIdx) const +%% C++ class method |setRange| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,libm2k::analog::M2K_RANGE range) -getKernelBuffersCountDefinition = addMethod(M2kAnalogOutDefinition, ... - "unsigned int libm2k::analog::M2kAnalogOut::getKernelBuffersCount(unsigned int chnIdx) const", ... - "MATLABName", "getKernelBuffersCount", ... - "Description", "getKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Get the number of kernel buffers", ... +setRangeDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,libm2k::analog::M2K_RANGE range)", ... + "MATLABName", "setRange", ... + "Description", "setRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Set the range for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getKernelBuffersCountDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); -defineOutput(getKernelBuffersCountDefinition, "RetVal", "uint32", "Description", "the number of previously set kernel buffers (saved in this session)"); -validate(getKernelBuffersCountDefinition); +defineArgument(setRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index"); +defineArgument(setRangeDefinition, "range", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "range An enumerator corresponding to a range"); +validate(setRangeDefinition); -%% C++ class method |convertVoltsToRaw| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: short libm2k::analog::M2kAnalogOut::convertVoltsToRaw(unsigned int channel,double voltage) +%% C++ class method |setRange| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,double min,double max) -convertVoltsToRawDefinition = addMethod(M2kAnalogOutDefinition, ... - "short libm2k::analog::M2kAnalogOut::convertVoltsToRaw(unsigned int channel,double voltage)", ... - "MATLABName", "convertVoltsToRaw", ... - "Description", "convertVoltsToRaw Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Convert the volts value of a sample into raw", ... +setRangeDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,double min,double max)", ... + "MATLABName", "setRange", ... + "Description", "setRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Set the range for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(convertVoltsToRawDefinition, "channel", "uint32", "Description", "channel The index corresponding to the channel"); -defineArgument(convertVoltsToRawDefinition, "voltage", "double", "Description", "voltage The volts value of a sample"); -defineOutput(convertVoltsToRawDefinition, "RetVal", "int16", "Description", "The value of a sample converted into raw"); -validate(convertVoltsToRawDefinition); +defineArgument(setRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index"); +defineArgument(setRangeDefinition, "min", "double", "Description", "min Upper bound"); +defineArgument(setRangeDefinition, "max", "double", "Description", "max Lower bound"); +validate(setRangeDefinition); -%% C++ class method |convertRawToVolts| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: double libm2k::analog::M2kAnalogOut::convertRawToVolts(unsigned int channel,short raw) +%% C++ class method |getRange| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: libm2k::analog::M2K_RANGE libm2k::analog::M2kAnalogIn::getRange(libm2k::analog::ANALOG_IN_CHANNEL channel) -convertRawToVoltsDefinition = addMethod(M2kAnalogOutDefinition, ... - "double libm2k::analog::M2kAnalogOut::convertRawToVolts(unsigned int channel,short raw)", ... - "MATLABName", "convertRawToVolts", ... - "Description", "convertRawToVolts Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Convert the raw value of a sample into volts", ... +getRangeDefinition = addMethod(M2kAnalogInDefinition, ... + "libm2k::analog::M2K_RANGE libm2k::analog::M2kAnalogIn::getRange(libm2k::analog::ANALOG_IN_CHANNEL channel)", ... + "MATLABName", "getRange", ... + "Description", "getRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the range for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(convertRawToVoltsDefinition, "channel", "uint32", "Description", "channel The index corresponding to the channel"); -defineArgument(convertRawToVoltsDefinition, "raw", "int16", "Description", "raw The raw value of a sample"); -defineOutput(convertRawToVoltsDefinition, "RetVal", "double", "Description", "The value of a sample converted into volts"); -validate(convertRawToVoltsDefinition); +defineArgument(getRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index"); +defineOutput(getRangeDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "An enumerator corresponding to the range"); +validate(getRangeDefinition); -%% C++ class method |getIioObjects| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogOut::getIioObjects() +%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: int libm2k::analog::M2kAnalogIn::getOversamplingRatio() -getIioObjectsDefinition = addMethod(M2kAnalogOutDefinition, ... - "libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogOut::getIioObjects()", ... - "MATLABName", "getIioObjects", ... - "Description", "getIioObjects Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Get access to IIO channels, buffers, devices and context." + newline + ... - " @note Can be used when debugging directly with libiio.", ... +getOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... + "int libm2k::analog::M2kAnalogIn::getOversamplingRatio()", ... + "MATLABName", "getOversamplingRatio", ... + "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the global oversampling ratio", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure."); -validate(getIioObjectsDefinition); +defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The value of the global ratio"); +validate(getOversamplingRatioDefinition); -%% C++ class method |getNbChannels| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: unsigned int libm2k::analog::M2kAnalogOut::getNbChannels() +%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: int libm2k::analog::M2kAnalogIn::getOversamplingRatio(unsigned int chn_idx) -getNbChannelsDefinition = addMethod(M2kAnalogOutDefinition, ... - "unsigned int libm2k::analog::M2kAnalogOut::getNbChannels()", ... - "MATLABName", "getNbChannels", ... - "Description", "getNbChannels Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Retrieve the number of analogical channels", ... +getOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... + "int libm2k::analog::M2kAnalogIn::getOversamplingRatio(unsigned int chn_idx)", ... + "MATLABName", "getOversamplingRatio", ... + "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the oversampling ratio for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getNbChannelsDefinition, "RetVal", "uint32", "Description", "The number of channels"); -validate(getNbChannelsDefinition); +defineArgument(getOversamplingRatioDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel"); +defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The ratio value"); +validate(getOversamplingRatioDefinition); -%% C++ class method |getChannelName| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: std::string libm2k::analog::M2kAnalogOut::getChannelName(unsigned int channel) +%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: int libm2k::analog::M2kAnalogIn::setOversamplingRatio(int oversampling) -getChannelNameDefinition = addMethod(M2kAnalogOutDefinition, ... - "std::string libm2k::analog::M2kAnalogOut::getChannelName(unsigned int channel)", ... - "MATLABName", "getChannelName", ... - "Description", "getChannelName Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Get the channel name for each DAC channel", ... +setOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... + "int libm2k::analog::M2kAnalogIn::setOversamplingRatio(int oversampling)", ... + "MATLABName", "setOversamplingRatio", ... + "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Set the global oversampling ratio", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getChannelNameDefinition, "channel", "uint32", "Description", "channel - unsigned int representing the index of the channel"); -defineOutput(getChannelNameDefinition, "RetVal", "string", "Description", "std::string - name of the channel"); -validate(getChannelNameDefinition); +defineArgument(setOversamplingRatioDefinition, "oversampling", "int32", "Description", "oversampling Integer value to set the oversampling ratio to"); +defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current value of the global ratio"); +validate(setOversamplingRatioDefinition); -%% C++ class method |getMaximumSamplerate| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: double libm2k::analog::M2kAnalogOut::getMaximumSamplerate(unsigned int chn_idx) +%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: int libm2k::analog::M2kAnalogIn::setOversamplingRatio(unsigned int chn_idx,int oversampling) -getMaximumSamplerateDefinition = addMethod(M2kAnalogOutDefinition, ... - "double libm2k::analog::M2kAnalogOut::getMaximumSamplerate(unsigned int chn_idx)", ... - "MATLABName", "getMaximumSamplerate", ... - "Description", "getMaximumSamplerate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Get the maximum samplerate for the DAC", ... +setOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ... + "int libm2k::analog::M2kAnalogIn::setOversamplingRatio(unsigned int chn_idx,int oversampling)", ... + "MATLABName", "setOversamplingRatio", ... + "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Set the oversampling ratio for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getMaximumSamplerateDefinition, "chn_idx", "uint32", "Description", "chn_idx - unsigned int representing the index of the channel"); -defineOutput(getMaximumSamplerateDefinition, "RetVal", "double", "Description", "double - the value of the maximum samplerate"); -validate(getMaximumSamplerateDefinition); +defineArgument(setOversamplingRatioDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel"); +defineArgument(setOversamplingRatioDefinition, "oversampling", "int32", "Description", "oversampling Integer value to set the oversampling ratio to"); +defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current ratio value"); +validate(setOversamplingRatioDefinition); -%% C++ class method |setVoltage| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: unsigned short libm2k::analog::M2kAnalogOut::setVoltage(unsigned int chn_idx,double volts) +%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getSampleRate() -setVoltageDefinition = addMethod(M2kAnalogOutDefinition, ... - "unsigned short libm2k::analog::M2kAnalogOut::setVoltage(unsigned int chn_idx,double volts)", ... - "MATLABName", "setVoltage", ... - "Description", "setVoltage Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Sets the voltage output of the DAC channel", ... +getSampleRateDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getSampleRate()", ... + "MATLABName", "getSampleRate", ... + "Description", "getSampleRate Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the global sample rate", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setVoltageDefinition, "chn_idx", "uint32", "Description", "chn_idx - unsigned int representing the index of the channel"); -defineArgument(setVoltageDefinition, "volts", "double", "Description", "volts - actual value to be set"); -defineOutput(setVoltageDefinition, "RetVal", "uint16", "Description", "unsigned short - the corresponding raw value for the given voltage"); -validate(setVoltageDefinition); +defineOutput(getSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate"); +validate(getSampleRateDefinition); -%% C++ class method |setVoltageRaw| for C++ class |libm2k::analog::M2kAnalogOut| -% C++ Signature: unsigned short libm2k::analog::M2kAnalogOut::setVoltageRaw(unsigned int chn_idx,unsigned short raw) +%% C++ class method |getAvailableSampleRates| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogIn::getAvailableSampleRates() -setVoltageRawDefinition = addMethod(M2kAnalogOutDefinition, ... - "unsigned short libm2k::analog::M2kAnalogOut::setVoltageRaw(unsigned int chn_idx,unsigned short raw)", ... - "MATLABName", "setVoltageRaw", ... - "Description", "setVoltageRaw Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... - "Sets the raw output of the DAC channel", ... +getAvailableSampleRatesDefinition = addMethod(M2kAnalogInDefinition, ... + "std::vector> libm2k::analog::M2kAnalogIn::getAvailableSampleRates()", ... + "MATLABName", "getAvailableSampleRates", ... + "Description", "getAvailableSampleRates Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "getAvailableSampleRates", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setVoltageRawDefinition, "chn_idx", "uint32", "Description", "chn_idx - unsigned int representing the index of the channel"); -defineArgument(setVoltageRawDefinition, "raw", "uint16", "Description", "raw - actual value to be set"); -defineOutput(setVoltageRawDefinition, "RetVal", "uint16", "Description", "unsigned short - the value set in the raw attribute"); -validate(setVoltageRawDefinition); +defineOutput(getAvailableSampleRatesDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "The list of available samplerates for this device"); +validate(getAvailableSampleRatesDefinition); -%% C++ class |libm2k::analog::M2kPowerSupply| with MATLAB name |clib.libm2k.libm2k.analog.M2kPowerSupply| -M2kPowerSupplyDefinition = addClass(libDef, "libm2k::analog::M2kPowerSupply", "MATLABName", "clib.libm2k.libm2k.analog.M2kPowerSupply", ... - "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply Representation of C++ class libm2k::analog::M2kPowerSupply." + newline + ... - "Contains the representation of the power supply" + newline + ... - "" + newline + ... - "@class M2kPowerSupply" + newline + ... - "@brief Controls the power supply", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@defgroup powersupply PowerSupply" + newline + ... - "@brief Contains the representation of the power supply" + newline + ... - "" + newline + ... - "@class M2kPowerSupply" + newline + ... - "@brief Controls the power supply"); % Modify help description values as needed. +%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::setSampleRate(double samplerate) -%% C++ class method |reset| for C++ class |libm2k::analog::M2kPowerSupply| -% C++ Signature: void libm2k::analog::M2kPowerSupply::reset() +setSampleRateDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::setSampleRate(double samplerate)", ... + "MATLABName", "setSampleRate", ... + "Description", "setSampleRate Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Set the global sample rate", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setSampleRateDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); +defineOutput(setSampleRateDefinition, "RetVal", "double", "Description", "The value of the global sample rate"); +validate(setSampleRateDefinition); -resetDefinition = addMethod(M2kPowerSupplyDefinition, ... - "void libm2k::analog::M2kPowerSupply::reset()", ... - "MATLABName", "reset", ... - "Description", "reset Method of C++ class libm2k::analog::M2kPowerSupply.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -validate(resetDefinition); +%% C++ class method |getFilterCompensation| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getFilterCompensation(double samplerate) -%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kPowerSupply| -% C++ Signature: void libm2k::analog::M2kPowerSupply::enableChannel(unsigned int chn,bool en) +getFilterCompensationDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getFilterCompensation(double samplerate)", ... + "MATLABName", "getFilterCompensation", ... + "Description", "getFilterCompensation Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the filter compensation for the given sample rate", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getFilterCompensationDefinition, "samplerate", "double", "Description", "samplerate A double value representing the sample rate"); +defineOutput(getFilterCompensationDefinition, "RetVal", "double", "Description", "The value of the filter compensation"); +validate(getFilterCompensationDefinition); -enableChannelDefinition = addMethod(M2kPowerSupplyDefinition, ... - "void libm2k::analog::M2kPowerSupply::enableChannel(unsigned int chn,bool en)", ... - "MATLABName", "enableChannel", ... - "Description", "enableChannel Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... - "Enable or disable the given channel", ... +%% C++ class method |getValueForRange| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getValueForRange(libm2k::analog::M2K_RANGE range) + +getValueForRangeDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getValueForRange(libm2k::analog::M2K_RANGE range)", ... + "MATLABName", "getValueForRange", ... + "Description", "getValueForRange Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the numeric value corresponding to the given range", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineArgument(enableChannelDefinition, "en", "logical", "Description", "en A boolean value corresponding to the state of the channel"); -validate(enableChannelDefinition); +defineArgument(getValueForRangeDefinition, "range", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "range"); +defineOutput(getValueForRangeDefinition, "RetVal", "double", "Description", "double"); +validate(getValueForRangeDefinition); -%% C++ class method |enableAll| for C++ class |libm2k::analog::M2kPowerSupply| -% C++ Signature: void libm2k::analog::M2kPowerSupply::enableAll(bool en) +%% C++ class method |convertRawToVolts| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::convertRawToVolts(unsigned int channel,short raw) -enableAllDefinition = addMethod(M2kPowerSupplyDefinition, ... - "void libm2k::analog::M2kPowerSupply::enableAll(bool en)", ... - "MATLABName", "enableAll", ... - "Description", "enableAll Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... - "Enable or disable all channels", ... +convertRawToVoltsDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::convertRawToVolts(unsigned int channel,short raw)", ... + "MATLABName", "convertRawToVolts", ... + "Description", "convertRawToVolts Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Convert the raw value of a sample into volts", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableAllDefinition, "en", "logical", "Description", "en A boolean value corresponding to the state of the channels"); -validate(enableAllDefinition); +defineArgument(convertRawToVoltsDefinition, "channel", "uint32", "Description", "raw: the raw value of a sample;"); +defineArgument(convertRawToVoltsDefinition, "raw", "int16", "Description", "channel: The index corresponding to the channel;"); +defineOutput(convertRawToVoltsDefinition, "RetVal", "double", "Description", "The value of a sample converted into volts;"); +validate(convertRawToVoltsDefinition); -%% C++ class method |readChannel| for C++ class |libm2k::analog::M2kPowerSupply| -% C++ Signature: double libm2k::analog::M2kPowerSupply::readChannel(unsigned int chn,bool calibrated = 1) +%% C++ class method |convertVoltsToRaw| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: short libm2k::analog::M2kAnalogIn::convertVoltsToRaw(unsigned int channel,double voltage) -readChannelDefinition = addMethod(M2kPowerSupplyDefinition, ... - "double libm2k::analog::M2kPowerSupply::readChannel(unsigned int chn,bool calibrated = 1)", ... - "MATLABName", "readChannel", ... - "Description", "readChannel Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... - "Retrieve the value of a given channel", ... +convertVoltsToRawDefinition = addMethod(M2kAnalogInDefinition, ... + "short libm2k::analog::M2kAnalogIn::convertVoltsToRaw(unsigned int channel,double voltage)", ... + "MATLABName", "convertVoltsToRaw", ... + "Description", "convertVoltsToRaw Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Convert the voltage value of a sample into raw", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(readChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineArgument(readChannelDefinition, "calibrated", "logical", "Description", "calibrated Read values are converted using the calibration" + newline + ... - " coefficients from the IIO context by default; This boolean flag" + newline + ... - " specifies whether the coefficients should be used."); -defineOutput(readChannelDefinition, "RetVal", "double", "Description", "double The voltage transmitted by the given channel"); -validate(readChannelDefinition); +defineArgument(convertVoltsToRawDefinition, "channel", "uint32", "Description", "voltage The voltage value of a sample;"); +defineArgument(convertVoltsToRawDefinition, "voltage", "double", "Description", "channel The index corresponding to the channel;"); +defineOutput(convertVoltsToRawDefinition, "RetVal", "int16", "Description", "The value of a sample converted into raw;"); +validate(convertVoltsToRawDefinition); -%% C++ class method |pushChannel| for C++ class |libm2k::analog::M2kPowerSupply| -% C++ Signature: void libm2k::analog::M2kPowerSupply::pushChannel(unsigned int chn,double value,bool calibrated = 1) +%% C++ class method |getNbChannels| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: unsigned int libm2k::analog::M2kAnalogIn::getNbChannels() -pushChannelDefinition = addMethod(M2kPowerSupplyDefinition, ... - "void libm2k::analog::M2kPowerSupply::pushChannel(unsigned int chn,double value,bool calibrated = 1)", ... - "MATLABName", "pushChannel", ... - "Description", "pushChannel Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... - "Set the voltage for the given channel", ... +getNbChannelsDefinition = addMethod(M2kAnalogInDefinition, ... + "unsigned int libm2k::analog::M2kAnalogIn::getNbChannels()", ... + "MATLABName", "getNbChannels", ... + "Description", "getNbChannels Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the number of analogical channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineArgument(pushChannelDefinition, "value", "double", "Description", "value The voltage (up to 5V)"); -defineArgument(pushChannelDefinition, "calibrated", "logical", "Description", "calibrated Written values are converted using the calibration" + newline + ... - " coefficients from the IIO context by default; This boolean flag" + newline + ... - " specifies whether the coefficients should be used."); -validate(pushChannelDefinition); +defineOutput(getNbChannelsDefinition, "RetVal", "uint32", "Description", "The number of channels"); +validate(getNbChannelsDefinition); -%% C++ class method |powerDownDacs| for C++ class |libm2k::analog::M2kPowerSupply| -% C++ Signature: void libm2k::analog::M2kPowerSupply::powerDownDacs(bool powerdown) +%% C++ class method |getName| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: std::string libm2k::analog::M2kAnalogIn::getName() -powerDownDacsDefinition = addMethod(M2kPowerSupplyDefinition, ... - "void libm2k::analog::M2kPowerSupply::powerDownDacs(bool powerdown)", ... - "MATLABName", "powerDownDacs", ... - "Description", "powerDownDacs Method of C++ class libm2k::analog::M2kPowerSupply.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -defineArgument(powerDownDacsDefinition, "powerdown", "logical"); -validate(powerDownDacsDefinition); +getNameDefinition = addMethod(M2kAnalogInDefinition, ... + "std::string libm2k::analog::M2kAnalogIn::getName()", ... + "MATLABName", "getName", ... + "Description", "getName Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the name of the device", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getNameDefinition, "RetVal", "string", "Description", "The name of the device"); +validate(getNameDefinition); -%% C++ class method |anyChannelEnabled| for C++ class |libm2k::analog::M2kPowerSupply| -% C++ Signature: bool libm2k::analog::M2kPowerSupply::anyChannelEnabled() +%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::enableChannel(unsigned int chnIdx,bool enable) -anyChannelEnabledDefinition = addMethod(M2kPowerSupplyDefinition, ... - "bool libm2k::analog::M2kPowerSupply::anyChannelEnabled()", ... - "MATLABName", "anyChannelEnabled", ... - "Description", "anyChannelEnabled Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... - "Check if there is at least one enabled channel", ... +enableChannelDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::enableChannel(unsigned int chnIdx,bool enable)", ... + "MATLABName", "enableChannel", ... + "Description", "enableChannel Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Enable or disable the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(anyChannelEnabledDefinition, "RetVal", "logical", "Description", "On succes, true"); -validate(anyChannelEnabledDefinition); +defineArgument(enableChannelDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); +validate(enableChannelDefinition); -%% C++ class |libm2k::context::M2k| with MATLAB name |clib.libm2k.libm2k.context.M2k| -M2kDefinition = addClass(libDef, "libm2k::context::M2k", "MATLABName", "clib.libm2k.libm2k.context.M2k", ... - "Description", "clib.libm2k.libm2k.context.M2k Representation of C++ class libm2k::context::M2k." + newline + ... - "Contains the representation of the M2K" + newline + ... - "" + newline + ... - "@class M2k" + newline + ... - "@brief Controls the ADALM2000", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@defgroup m2k M2k" + newline + ... - "@brief Contains the representation of the M2K" + newline + ... - "" + newline + ... - "@class M2k" + newline + ... - "@brief Controls the ADALM2000"); % Modify help description values as needed. +%% C++ class method |isChannelEnabled| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: bool libm2k::analog::M2kAnalogIn::isChannelEnabled(unsigned int chnIdx) -%% C++ class method |reset| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::reset() +isChannelEnabledDefinition = addMethod(M2kAnalogInDefinition, ... + "bool libm2k::analog::M2kAnalogIn::isChannelEnabled(unsigned int chnIdx)", ... + "MATLABName", "isChannelEnabled", ... + "Description", "isChannelEnabled Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Retrieve the state of the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(isChannelEnabledDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineOutput(isChannelEnabledDefinition, "RetVal", "logical", "Description", "True if the channel is enabled"); +validate(isChannelEnabledDefinition); -resetDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::reset()", ... - "MATLABName", "reset", ... - "Description", "reset Method of C++ class libm2k::context::M2k." + newline + ... - "Reset the M2K device to default settings:" + newline + ... - " * - Reset calibration coefficients" + newline + ... - " * - Maximum samplerates" + newline + ... - " * - Set oversampling ratio to 1" + newline + ... - " * - Set AnalogIn range to low range" + newline + ... - " * - Set kernel buffers count to 4 (analog/digital and in/out devices)" + newline + ... - " * - Disable all TX digital channels and enable all RX digital channels" + newline + ... - " @note A calibration is needed afterwards", ... +%% C++ class method |cancelAcquisition| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::cancelAcquisition() + +cancelAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::cancelAcquisition()", ... + "MATLABName", "cancelAcquisition", ... + "Description", "cancelAcquisition Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Cancel all buffer operations" + newline + ... + " @note Should be used to cancel an ongoing acquisition", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@brief Reset the M2K device to default settings:" + newline + ... - " * - Reset calibration coefficients" + newline + ... - " * - Maximum samplerates" + newline + ... - " * - Set oversampling ratio to 1" + newline + ... - " * - Set AnalogIn range to low range" + newline + ... - " * - Set kernel buffers count to 4 (analog/digital and in/out devices)" + newline + ... - " * - Disable all TX digital channels and enable all RX digital channels" + newline + ... - " @note A calibration is needed afterwards"); % Modify help description values as needed. -validate(resetDefinition); + "@brief Cancel all buffer operations" + newline + ... + " @note Should be used to cancel an ongoing acquisition"); % Modify help description values as needed. +validate(cancelAcquisitionDefinition); -%% C++ class method |deinitialize| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::deinitialize() +%% C++ class method |setKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: void libm2k::analog::M2kAnalogIn::setKernelBuffersCount(unsigned int count) -deinitializeDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::deinitialize()", ... - "MATLABName", "deinitialize", ... - "Description", "deinitialize Method of C++ class libm2k::context::M2k.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -validate(deinitializeDefinition); +setKernelBuffersCountDefinition = addMethod(M2kAnalogInDefinition, ... + "void libm2k::analog::M2kAnalogIn::setKernelBuffersCount(unsigned int count)", ... + "MATLABName", "setKernelBuffersCount", ... + "Description", "setKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Set the kernel buffers to a specific value", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setKernelBuffersCountDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); +validate(setKernelBuffersCountDefinition); -%% C++ class method |calibrate| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::calibrate() +%% C++ class method |getKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: unsigned int libm2k::analog::M2kAnalogIn::getKernelBuffersCount() const -calibrateDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::calibrate()", ... - "MATLABName", "calibrate", ... - "Description", "calibrate Method of C++ class libm2k::context::M2k.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -defineOutput(calibrateDefinition, "RetVal", "logical"); -validate(calibrateDefinition); +getKernelBuffersCountDefinition = addMethod(M2kAnalogInDefinition, ... + "unsigned int libm2k::analog::M2kAnalogIn::getKernelBuffersCount() const", ... + "MATLABName", "getKernelBuffersCount", ... + "Description", "getKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Get the number of kernel buffers", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getKernelBuffersCountDefinition, "RetVal", "uint32", "Description", "the number of previously set kernel buffers (saved in this session)"); +validate(getKernelBuffersCountDefinition); -%% C++ class method |calibrateADC| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::calibrateADC() +%% C++ class method |getTrigger| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogIn::getTrigger() -calibrateADCDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::calibrateADC()", ... - "MATLABName", "calibrateADC", ... - "Description", "calibrateADC Method of C++ class libm2k::context::M2k." + newline + ... - "Calibrate the ADC", ... +getTriggerDefinition = addMethod(M2kAnalogInDefinition, ... + "libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogIn::getTrigger()", ... + "MATLABName", "getTrigger", ... + "Description", "getTrigger Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Get the hardware trigger handler", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getTriggerDefinition, "RetVal", "clib.libm2k.libm2k.M2kHardwareTrigger", 1, "Description", "A pointer to the hardware trigger trigger"); +validate(getTriggerDefinition); + +%% C++ class method |getIioObjects| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogIn::getIioObjects() + +getIioObjectsDefinition = addMethod(M2kAnalogInDefinition, ... + "libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogIn::getIioObjects()", ... + "MATLABName", "getIioObjects", ... + "Description", "getIioObjects Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Get access to IIO channels, buffers, devices and context." + newline + ... + " Can be used when debugging directly with libiio.", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(calibrateADCDefinition, "RetVal", "logical", "Description", "On succces, true"); -validate(calibrateADCDefinition); +defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure."); +validate(getIioObjectsDefinition); -%% C++ class method |calibrateDAC| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::calibrateDAC() +%% C++ class method |getChannelName| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: std::string libm2k::analog::M2kAnalogIn::getChannelName(unsigned int channel) -calibrateDACDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::calibrateDAC()", ... - "MATLABName", "calibrateDAC", ... - "Description", "calibrateDAC Method of C++ class libm2k::context::M2k." + newline + ... - "Calibrate the DAC", ... +getChannelNameDefinition = addMethod(M2kAnalogInDefinition, ... + "std::string libm2k::analog::M2kAnalogIn::getChannelName(unsigned int channel)", ... + "MATLABName", "getChannelName", ... + "Description", "getChannelName Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Get the channel name for each ADC channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(calibrateDACDefinition, "RetVal", "logical", "Description", "On succces, true"); -validate(calibrateDACDefinition); +defineArgument(getChannelNameDefinition, "channel", "uint32", "Description", "channel - unsigned int representing the index of the channel"); +defineOutput(getChannelNameDefinition, "RetVal", "string", "Description", "std::string - name of the channel"); +validate(getChannelNameDefinition); -%% C++ class method |resetCalibration| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::resetCalibration() +%% C++ class method |getMaximumSamplerate| for C++ class |libm2k::analog::M2kAnalogIn| +% C++ Signature: double libm2k::analog::M2kAnalogIn::getMaximumSamplerate() -resetCalibrationDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::resetCalibration()", ... - "MATLABName", "resetCalibration", ... - "Description", "resetCalibration Method of C++ class libm2k::context::M2k.", ... +getMaximumSamplerateDefinition = addMethod(M2kAnalogInDefinition, ... + "double libm2k::analog::M2kAnalogIn::getMaximumSamplerate()", ... + "MATLABName", "getMaximumSamplerate", ... + "Description", "getMaximumSamplerate Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ... + "Get the maximum samplerate for the ADC", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getMaximumSamplerateDefinition, "RetVal", "double", "Description", "double - the value of the maximum samplerate"); +validate(getMaximumSamplerateDefinition); + +%% C++ enumeration |libm2k::analog::ANALOG_IN_CHANNEL| with MATLAB name |clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL| +addEnumeration(libDef, "libm2k::analog::ANALOG_IN_CHANNEL", "int32",... + [... + "ANALOG_IN_CHANNEL_1",... % 0 + "ANALOG_IN_CHANNEL_2",... % 1 + ],... + "MATLABName", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", ... + "Description", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL Representation of C++ enumeration libm2k::analog::ANALOG_IN_CHANNEL." + newline + ... + "Indexes of the channels", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@private"); % Modify help description values as needed. -defineOutput(resetCalibrationDefinition, "RetVal", "logical"); -validate(resetCalibrationDefinition); - -%% C++ class method |calibrateFromContext| for C++ class |libm2k::context::M2k| -% C++ Signature: double libm2k::context::M2k::calibrateFromContext() + "@note Each channel can be accessed through its index"); % Modify help description values as needed. -calibrateFromContextDefinition = addMethod(M2kDefinition, ... - "double libm2k::context::M2k::calibrateFromContext()", ... - "MATLABName", "calibrateFromContext", ... - "Description", "calibrateFromContext Method of C++ class libm2k::context::M2k." + newline + ... - "Calibrate both ADC and DACs using predefined calibration values located in context", ... +%% C++ enumeration |libm2k::analog::M2K_RANGE| with MATLAB name |clib.libm2k.libm2k.analog.M2K_RANGE| +addEnumeration(libDef, "libm2k::analog::M2K_RANGE", "int32",... + [... + "PLUS_MINUS_25V",... % 0 + "PLUS_MINUS_2_5V",... % 1 + ],... + "MATLABName", "clib.libm2k.libm2k.analog.M2K_RANGE", ... + "Description", "clib.libm2k.libm2k.analog.M2K_RANGE Representation of C++ enumeration libm2k::analog::M2K_RANGE." + newline + ... + "Range of the signal's amplitude", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(calibrateFromContextDefinition, "RetVal", "double", "Description", "The closest temperature found in the lookup table"); -validate(calibrateFromContextDefinition); -%% C++ class method |getDigital| for C++ class |libm2k::context::M2k| -% C++ Signature: libm2k::digital::M2kDigital * libm2k::context::M2k::getDigital() +%% C++ class |libm2k::analog::M2kAnalogOut| with MATLAB name |clib.libm2k.libm2k.analog.M2kAnalogOut| +M2kAnalogOutDefinition = addClass(libDef, "libm2k::analog::M2kAnalogOut", "MATLABName", "clib.libm2k.libm2k.analog.M2kAnalogOut", ... + "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut Representation of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Contains the representation of the analogical output segment" + newline + ... + "" + newline + ... + "@class M2kAnalogOut m2kanalogout.hpp libm2k/analog/m2kanalogout.hpp" + newline + ... + "@brief Controls the analogical output compound", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@defgroup analogout AnalogOut" + newline + ... + "@brief Contains the representation of the analogical output segment" + newline + ... + "" + newline + ... + "@class M2kAnalogOut m2kanalogout.hpp libm2k/analog/m2kanalogout.hpp" + newline + ... + "@brief Controls the analogical output compound"); % Modify help description values as needed. -getDigitalDefinition = addMethod(M2kDefinition, ... - "libm2k::digital::M2kDigital * libm2k::context::M2k::getDigital()", ... - "MATLABName", "getDigital", ... - "Description", "getDigital Method of C++ class libm2k::context::M2k." + newline + ... - "Retrieve the Digital object", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getDigitalDefinition, "RetVal", "clib.libm2k.libm2k.digital.M2kDigital", 1, "Description", "On success, a pointer to a Digital object" + newline + ... - " @throw EXC_INVALID_PARAMETER No M2K digital device found"); -validate(getDigitalDefinition); +%% C++ class method |reset| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::reset() -%% C++ class method |getPowerSupply| for C++ class |libm2k::context::M2k| -% C++ Signature: libm2k::analog::M2kPowerSupply * libm2k::context::M2k::getPowerSupply() +resetDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::reset()", ... + "MATLABName", "reset", ... + "Description", "reset Method of C++ class libm2k::analog::M2kAnalogOut.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +validate(resetDefinition); -getPowerSupplyDefinition = addMethod(M2kDefinition, ... - "libm2k::analog::M2kPowerSupply * libm2k::context::M2k::getPowerSupply()", ... - "MATLABName", "getPowerSupply", ... - "Description", "getPowerSupply Method of C++ class libm2k::context::M2k." + newline + ... - "Retrieve the PowerSupply object", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getPowerSupplyDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kPowerSupply", 1, "Description", "On success, a pointer to a PowerSupply object" + newline + ... - " @throw EXC_INVALID_PARAMETER No M2K power supply"); -validate(getPowerSupplyDefinition); +%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::getOversamplingRatio() -%% C++ class method |getAnalogIn| for C++ class |libm2k::context::M2k| -% C++ Signature: libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn() +getOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... + "std::vector> libm2k::analog::M2kAnalogOut::getOversamplingRatio()", ... + "MATLABName", "getOversamplingRatio", ... + "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the global oversampling ratio", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getOversamplingRatioDefinition, "RetVal", "clib.array.libm2k.Int", "Description", "The value of the global oversampling ratio"); +validate(getOversamplingRatioDefinition); -getAnalogInDefinition = addMethod(M2kDefinition, ... - "libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn()", ... - "MATLABName", "getAnalogIn", ... - "Description", "getAnalogIn Method of C++ class libm2k::context::M2k." + newline + ... - "Retrieve the AnalogIn object", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getAnalogInDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogIn", 1, "Description", "On success, a pointer to an AnalogIn object"); -validate(getAnalogInDefinition); +%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: int libm2k::analog::M2kAnalogOut::getOversamplingRatio(unsigned int chn) -%% C++ class method |getAnalogIn| for C++ class |libm2k::context::M2k| -% C++ Signature: libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn(std::string dev_name) +getOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... + "int libm2k::analog::M2kAnalogOut::getOversamplingRatio(unsigned int chn)", ... + "MATLABName", "getOversamplingRatio", ... + "Description", "getOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the oversampling ratio for the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getOversamplingRatioDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The oversampling ratio value"); +validate(getOversamplingRatioDefinition); -getAnalogInDefinition = addMethod(M2kDefinition, ... - "libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn(std::string dev_name)", ... - "MATLABName", "getAnalogIn", ... - "Description", "getAnalogIn Method of C++ class libm2k::context::M2k." + newline + ... - "Retrieve the AnalogIn object of a device", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getAnalogInDefinition, "dev_name", "string", "Description", "dev_name The name corresponding to a device"); -defineOutput(getAnalogInDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogIn", 1, "Description", "On success, a pointer to an AnalogIn object"); -validate(getAnalogInDefinition); +%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::setOversamplingRatio(std::vector> oversampling_ratio) -%% C++ class method |getAnalogOut| for C++ class |libm2k::context::M2k| -% C++ Signature: libm2k::analog::M2kAnalogOut * libm2k::context::M2k::getAnalogOut() +setOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... + "std::vector> libm2k::analog::M2kAnalogOut::setOversamplingRatio(std::vector> oversampling_ratio)", ... + "MATLABName", "setOversamplingRatio", ... + "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Set the value of the oversampling ratio for each channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setOversamplingRatioDefinition, "oversampling_ratio", "clib.array.libm2k.Int", "Description", "oversampling_ratio A list containing the ratios for each channel (as integers)"); +defineOutput(setOversamplingRatioDefinition, "RetVal", "clib.array.libm2k.Int", "Description", "A list containing the oversampling ratio value for each channel"); +validate(setOversamplingRatioDefinition); -getAnalogOutDefinition = addMethod(M2kDefinition, ... - "libm2k::analog::M2kAnalogOut * libm2k::context::M2k::getAnalogOut()", ... - "MATLABName", "getAnalogOut", ... - "Description", "getAnalogOut Method of C++ class libm2k::context::M2k." + newline + ... - "Retrieve the AnalogOut object", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getAnalogOutDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogOut", 1, "Description", "On success, a pointer to an AnalogOut object"); -validate(getAnalogOutDefinition); - -%% C++ class method |hasMixedSignal| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::hasMixedSignal() +%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: int libm2k::analog::M2kAnalogOut::setOversamplingRatio(unsigned int chn,int oversampling_ratio) -hasMixedSignalDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::hasMixedSignal()", ... - "MATLABName", "hasMixedSignal", ... - "Description", "hasMixedSignal Method of C++ class libm2k::context::M2k." + newline + ... - "Check if the mixed signal acquisition is available on the current firmware version", ... +setOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ... + "int libm2k::analog::M2kAnalogOut::setOversamplingRatio(unsigned int chn,int oversampling_ratio)", ... + "MATLABName", "setOversamplingRatio", ... + "Description", "setOversamplingRatio Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Set the oversampling ratio for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(hasMixedSignalDefinition, "RetVal", "logical", "Description", "True if the mixed signal acquisition is available, false otherwise"); -validate(hasMixedSignalDefinition); +defineArgument(setOversamplingRatioDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineArgument(setOversamplingRatioDefinition, "oversampling_ratio", "int32", "Description", "oversampling_ratio Integer value to set the oversampling ratio to"); +defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current oversampling ratio value"); +validate(setOversamplingRatioDefinition); -%% C++ class method |startMixedSignalAcquisition| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::startMixedSignalAcquisition(unsigned int nb_samples) +%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::getSampleRate() -startMixedSignalAcquisitionDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::startMixedSignalAcquisition(unsigned int nb_samples)", ... - "MATLABName", "startMixedSignalAcquisition", ... - "Description", "startMixedSignalAcquisition Method of C++ class libm2k::context::M2k." + newline + ... - "Initiate the mixed acquisition", ... +getSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... + "std::vector> libm2k::analog::M2kAnalogOut::getSampleRate()", ... + "MATLABName", "getSampleRate", ... + "Description", "getSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the sample rate of both DACs", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(startMixedSignalAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); -validate(startMixedSignalAcquisitionDefinition); - -%% C++ class method |stopMixedSignalAcquisition| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::stopMixedSignalAcquisition() - -stopMixedSignalAcquisitionDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::stopMixedSignalAcquisition()", ... - "MATLABName", "stopMixedSignalAcquisition", ... - "Description", "stopMixedSignalAcquisition Method of C++ class libm2k::context::M2k." + newline + ... - "Stop the mixed acquisition", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@note Only available from firmware v0.26."); % Modify help description values as needed. -validate(stopMixedSignalAcquisitionDefinition); +defineOutput(getSampleRateDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the sample rates"); +validate(getSampleRateDefinition); -%% C++ class method |getDacCalibrationOffset| for C++ class |libm2k::context::M2k| -% C++ Signature: int libm2k::context::M2k::getDacCalibrationOffset(unsigned int chn) +%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: double libm2k::analog::M2kAnalogOut::getSampleRate(unsigned int chn) -getDacCalibrationOffsetDefinition = addMethod(M2kDefinition, ... - "int libm2k::context::M2k::getDacCalibrationOffset(unsigned int chn)", ... - "MATLABName", "getDacCalibrationOffset", ... - "Description", "getDacCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... - "Get the calibration offset of the DAC", ... +getSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... + "double libm2k::analog::M2kAnalogOut::getSampleRate(unsigned int chn)", ... + "MATLABName", "getSampleRate", ... + "Description", "getSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the sample rate for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getDacCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineOutput(getDacCalibrationOffsetDefinition, "RetVal", "int32", "Description", "The value of the calibration offset"); -validate(getDacCalibrationOffsetDefinition); +defineArgument(getSampleRateDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineOutput(getSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate"); +validate(getSampleRateDefinition); -%% C++ class method |getDacCalibrationGain| for C++ class |libm2k::context::M2k| -% C++ Signature: double libm2k::context::M2k::getDacCalibrationGain(unsigned int chn) +%% C++ class method |getAvailableSampleRates| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::getAvailableSampleRates(unsigned int chn) -getDacCalibrationGainDefinition = addMethod(M2kDefinition, ... - "double libm2k::context::M2k::getDacCalibrationGain(unsigned int chn)", ... - "MATLABName", "getDacCalibrationGain", ... - "Description", "getDacCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... - "Get the calibration gain of the DAC", ... +getAvailableSampleRatesDefinition = addMethod(M2kAnalogOutDefinition, ... + "std::vector> libm2k::analog::M2kAnalogOut::getAvailableSampleRates(unsigned int chn)", ... + "MATLABName", "getAvailableSampleRates", ... + "Description", "getAvailableSampleRates Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "getAvailableSampleRates", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getDacCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineOutput(getDacCalibrationGainDefinition, "RetVal", "double", "Description", "The value of the calibration gain"); -validate(getDacCalibrationGainDefinition); +defineArgument(getAvailableSampleRatesDefinition, "chn", "uint32", "Description", "chn The index corresponding to the required channel"); +defineOutput(getAvailableSampleRatesDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "The list of available samplerates for this device"); +validate(getAvailableSampleRatesDefinition); -%% C++ class method |getAdcCalibrationOffset| for C++ class |libm2k::context::M2k| -% C++ Signature: int libm2k::context::M2k::getAdcCalibrationOffset(unsigned int chn) +%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: std::vector> libm2k::analog::M2kAnalogOut::setSampleRate(std::vector> samplerates) -getAdcCalibrationOffsetDefinition = addMethod(M2kDefinition, ... - "int libm2k::context::M2k::getAdcCalibrationOffset(unsigned int chn)", ... - "MATLABName", "getAdcCalibrationOffset", ... - "Description", "getAdcCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... - "Get the calibration offset of the ADC", ... +setSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... + "std::vector> libm2k::analog::M2kAnalogOut::setSampleRate(std::vector> samplerates)", ... + "MATLABName", "setSampleRate", ... + "Description", "setSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Set the sample rate for both channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getAdcCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineOutput(getAdcCalibrationOffsetDefinition, "RetVal", "int32", "Description", "The value of the calibration offset"); -validate(getAdcCalibrationOffsetDefinition); +defineArgument(setSampleRateDefinition, "samplerates", "clib.array.libm2k.Double", "Description", "samplerates A list containing the sample rates of each channel"); +defineOutput(setSampleRateDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the previously set sample rates"); +validate(setSampleRateDefinition); -%% C++ class method |getAdcCalibrationGain| for C++ class |libm2k::context::M2k| -% C++ Signature: double libm2k::context::M2k::getAdcCalibrationGain(unsigned int chn) +%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: double libm2k::analog::M2kAnalogOut::setSampleRate(unsigned int chn,double samplerate) -getAdcCalibrationGainDefinition = addMethod(M2kDefinition, ... - "double libm2k::context::M2k::getAdcCalibrationGain(unsigned int chn)", ... - "MATLABName", "getAdcCalibrationGain", ... - "Description", "getAdcCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... - "Get the calibration gain of the ADC", ... +setSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ... + "double libm2k::analog::M2kAnalogOut::setSampleRate(unsigned int chn,double samplerate)", ... + "MATLABName", "setSampleRate", ... + "Description", "setSampleRate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Set the sample rate for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getAdcCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineOutput(getAdcCalibrationGainDefinition, "RetVal", "double", "Description", "The value of the calibration gain"); -validate(getAdcCalibrationGainDefinition); +defineArgument(setSampleRateDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineArgument(setSampleRateDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); +defineOutput(setSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate"); +validate(setSampleRateDefinition); -%% C++ class method |setDacCalibrationOffset| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::setDacCalibrationOffset(unsigned int chn,int offset) +%% C++ class method |setSyncedDma| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::setSyncedDma(bool en,int chn = -1) -setDacCalibrationOffsetDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::setDacCalibrationOffset(unsigned int chn,int offset)", ... - "MATLABName", "setDacCalibrationOffset", ... - "Description", "setDacCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... - "Set the calibration offset of the DAC", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDacCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineArgument(setDacCalibrationOffsetDefinition, "offset", "int32", "Description", "offset The calibration offset value" + newline + ... - " @note Overrides the calibration coefficients.\n" + newline + ... - " Can be reset by running a calibration."); -validate(setDacCalibrationOffsetDefinition); +setSyncedDmaDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::setSyncedDma(bool en,int chn = -1)", ... + "MATLABName", "setSyncedDma", ... + "Description", "setSyncedDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineArgument(setSyncedDmaDefinition, "en", "logical"); +defineArgument(setSyncedDmaDefinition, "chn", "int32"); +validate(setSyncedDmaDefinition); -%% C++ class method |setDacCalibrationGain| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::setDacCalibrationGain(unsigned int chn,double gain) +%% C++ class method |getSyncedDma| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: bool libm2k::analog::M2kAnalogOut::getSyncedDma(int chn = -1) -setDacCalibrationGainDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::setDacCalibrationGain(unsigned int chn,double gain)", ... - "MATLABName", "setDacCalibrationGain", ... - "Description", "setDacCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... - "Set the calibration gain of the DAC", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDacCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineArgument(setDacCalibrationGainDefinition, "gain", "double", "Description", "gain The calibration gain value" + newline + ... - " @note Overrides the calibration coefficients.\n" + newline + ... - " Can be reset by running a calibration.\n" + newline + ... - " The gain value is currently limited at the (-2,2) range by the hardware."); -validate(setDacCalibrationGainDefinition); +getSyncedDmaDefinition = addMethod(M2kAnalogOutDefinition, ... + "bool libm2k::analog::M2kAnalogOut::getSyncedDma(int chn = -1)", ... + "MATLABName", "getSyncedDma", ... + "Description", "getSyncedDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineArgument(getSyncedDmaDefinition, "chn", "int32"); +defineOutput(getSyncedDmaDefinition, "RetVal", "logical"); +validate(getSyncedDmaDefinition); -%% C++ class method |setAdcCalibrationOffset| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::setAdcCalibrationOffset(unsigned int chn,int offset) +%% C++ class method |setSyncedStartDma| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::setSyncedStartDma(bool en,int chn = -1) -setAdcCalibrationOffsetDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::setAdcCalibrationOffset(unsigned int chn,int offset)", ... - "MATLABName", "setAdcCalibrationOffset", ... - "Description", "setAdcCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... - "Set the calibration offset of the ADC", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setAdcCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineArgument(setAdcCalibrationOffsetDefinition, "offset", "int32", "Description", "offset The calibration offset value" + newline + ... - " @note Overrides the calibration coefficients.\n" + newline + ... - " Can be reset by running a calibration."); -validate(setAdcCalibrationOffsetDefinition); +setSyncedStartDmaDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::setSyncedStartDma(bool en,int chn = -1)", ... + "MATLABName", "setSyncedStartDma", ... + "Description", "setSyncedStartDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineArgument(setSyncedStartDmaDefinition, "en", "logical"); +defineArgument(setSyncedStartDmaDefinition, "chn", "int32"); +validate(setSyncedStartDmaDefinition); -%% C++ class method |setAdcCalibrationGain| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::setAdcCalibrationGain(unsigned int chn,double gain) +%% C++ class method |getSyncedStartDma| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: bool libm2k::analog::M2kAnalogOut::getSyncedStartDma(int chn = -1) -setAdcCalibrationGainDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::setAdcCalibrationGain(unsigned int chn,double gain)", ... - "MATLABName", "setAdcCalibrationGain", ... - "Description", "setAdcCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... - "Set the calibration gain of the ADC", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setAdcCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); -defineArgument(setAdcCalibrationGainDefinition, "gain", "double", "Description", "gain The calibration gain value" + newline + ... - " @note Overrides the calibration coefficients.\n" + newline + ... - " Can be reset by running a calibration.\n" + newline + ... - " The gain value is currently limited at the (-2,2) range by the hardware."); -validate(setAdcCalibrationGainDefinition); +getSyncedStartDmaDefinition = addMethod(M2kAnalogOutDefinition, ... + "bool libm2k::analog::M2kAnalogOut::getSyncedStartDma(int chn = -1)", ... + "MATLABName", "getSyncedStartDma", ... + "Description", "getSyncedStartDma Method of C++ class libm2k::analog::M2kAnalogOut.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineArgument(getSyncedStartDmaDefinition, "chn", "int32"); +defineOutput(getSyncedStartDmaDefinition, "RetVal", "logical"); +validate(getSyncedStartDmaDefinition); -%% C++ class method |hasContextCalibration| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::hasContextCalibration() +%% C++ class method |setCyclic| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::setCyclic(bool en) -hasContextCalibrationDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::hasContextCalibration()", ... - "MATLABName", "hasContextCalibration", ... - "Description", "hasContextCalibration Method of C++ class libm2k::context::M2k." + newline + ... - "Check if the calibration based on temperature can be performed", ... +setCyclicDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::setCyclic(bool en)", ... + "MATLABName", "setCyclic", ... + "Description", "setCyclic Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Enable or disable the cyclic mode for all digital channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(hasContextCalibrationDefinition, "RetVal", "logical", "Description", "True if the calibration parameters are available, False otherwise"); -validate(hasContextCalibrationDefinition); +defineArgument(setCyclicDefinition, "en", "logical", "Description", "en If true, enable cyclic mode"); +validate(setCyclicDefinition); -%% C++ class method |isCalibrated| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::isCalibrated() +%% C++ class method |setCyclic| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::setCyclic(unsigned int chn,bool en) -isCalibratedDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::isCalibrated()", ... - "MATLABName", "isCalibrated", ... - "Description", "isCalibrated Method of C++ class libm2k::context::M2k." + newline + ... - "Check if the board was calibrated", ... +setCyclicDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::setCyclic(unsigned int chn,bool en)", ... + "MATLABName", "setCyclic", ... + "Description", "setCyclic Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Enable or disable the cyclic mode for all digital channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(isCalibratedDefinition, "RetVal", "logical", "Description", "True if the board was calibrated, False otherwise"); -validate(isCalibratedDefinition); +defineArgument(setCyclicDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineArgument(setCyclicDefinition, "en", "logical", "Description", "en If true, enable cyclic mode"); +validate(setCyclicDefinition); -%% C++ class method |setLed| for C++ class |libm2k::context::M2k| -% C++ Signature: void libm2k::context::M2k::setLed(bool on) +%% C++ class method |getCyclic| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: bool libm2k::analog::M2kAnalogOut::getCyclic(unsigned int chn) -setLedDefinition = addMethod(M2kDefinition, ... - "void libm2k::context::M2k::setLed(bool on)", ... - "MATLABName", "setLed", ... - "Description", "setLed Method of C++ class libm2k::context::M2k." + newline + ... - "Turn on or off the board's led", ... +getCyclicDefinition = addMethod(M2kAnalogOutDefinition, ... + "bool libm2k::analog::M2kAnalogOut::getCyclic(unsigned int chn)", ... + "MATLABName", "getCyclic", ... + "Description", "getCyclic Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the value of the cyclic mode", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setLedDefinition, "on", "logical", "Description", "on A boolean value corresponding to the state of the led"); -validate(setLedDefinition); +defineArgument(getCyclicDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineOutput(getCyclicDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the cyclic mode"); +validate(getCyclicDefinition); -%% C++ class method |getLed| for C++ class |libm2k::context::M2k| -% C++ Signature: bool libm2k::context::M2k::getLed() +%% C++ class method |getScalingFactor| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: double libm2k::analog::M2kAnalogOut::getScalingFactor(unsigned int chn) -getLedDefinition = addMethod(M2kDefinition, ... - "bool libm2k::context::M2k::getLed()", ... - "MATLABName", "getLed", ... - "Description", "getLed Method of C++ class libm2k::context::M2k." + newline + ... - "Retrieve the state of the led", ... +getScalingFactorDefinition = addMethod(M2kAnalogOutDefinition, ... + "double libm2k::analog::M2kAnalogOut::getScalingFactor(unsigned int chn)", ... + "MATLABName", "getScalingFactor", ... + "Description", "getScalingFactor Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the scaling factor for the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getLedDefinition, "RetVal", "logical", "Description", "If the led is turned on, true"); -validate(getLedDefinition); - -%% C++ class |libm2k::context::Generic| with MATLAB name |clib.libm2k.libm2k.context.Generic| -GenericDefinition = addClass(libDef, "libm2k::context::Generic", "MATLABName", "clib.libm2k.libm2k.context.Generic", ... - "Description", "clib.libm2k.libm2k.context.Generic Representation of C++ class libm2k::context::Generic."); % Modify help description values as needed. - -%% C++ class |libm2k::context::Context| with MATLAB name |clib.libm2k.libm2k.context.Context| -ContextDefinition = addClass(libDef, "libm2k::context::Context", "MATLABName", "clib.libm2k.libm2k.context.Context", ... - "Description", "clib.libm2k.libm2k.context.Context Representation of C++ class libm2k::context::Context." + newline + ... - "Contains the representation of a generic IIO context" + newline + ... - "" + newline + ... - "@class Context" + newline + ... - "@brief Controls the IIO context"); % Modify help description values as needed. +defineArgument(getScalingFactorDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineOutput(getScalingFactorDefinition, "RetVal", "double", "Description", "The value of the scaling factor"); +validate(getScalingFactorDefinition); -%% C++ class method |reset| for C++ class |libm2k::context::Context| -% C++ Signature: void libm2k::context::Context::reset() +%% C++ class method |getFilterCompensation| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: double libm2k::analog::M2kAnalogOut::getFilterCompensation(double samplerate) -resetDefinition = addMethod(ContextDefinition, ... - "void libm2k::context::Context::reset()", ... - "MATLABName", "reset", ... - "Description", "reset Method of C++ class libm2k::context::Context.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -validate(resetDefinition); +getFilterCompensationDefinition = addMethod(M2kAnalogOutDefinition, ... + "double libm2k::analog::M2kAnalogOut::getFilterCompensation(double samplerate)", ... + "MATLABName", "getFilterCompensation", ... + "Description", "getFilterCompensation Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the filter compensation for the given sample rate", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getFilterCompensationDefinition, "samplerate", "double", "Description", "samplerate A double value representing the sample rate"); +defineOutput(getFilterCompensationDefinition, "RetVal", "double", "Description", "The value of the filter compensation"); +validate(getFilterCompensationDefinition); -%% C++ class method |deinitialize| for C++ class |libm2k::context::Context| -% C++ Signature: void libm2k::context::Context::deinitialize() +%% C++ class method |pushBytes| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::pushBytes(unsigned int chnIdx,double * data,unsigned int nb_samples) -deinitializeDefinition = addMethod(ContextDefinition, ... - "void libm2k::context::Context::deinitialize()", ... - "MATLABName", "deinitialize", ... - "Description", "deinitialize Method of C++ class libm2k::context::Context.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -validate(deinitializeDefinition); +pushBytesDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::pushBytes(unsigned int chnIdx,double * data,unsigned int nb_samples)", ... + "MATLABName", "pushBytes", ... + "Description", "pushBytes Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Send the samples to the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(pushBytesDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineArgument(pushBytesDefinition, "data", "clib.array.libm2k.Double", "input", "nb_samples", "Description", "data A pointer to the samples"); % can be "clib.array.libm2k.Double", or "double" +defineArgument(pushBytesDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples"); +validate(pushBytesDefinition); -%% C++ class method |getUri| for C++ class |libm2k::context::Context| -% C++ Signature: std::string libm2k::context::Context::getUri() +%% C++ class method |pushRawBytes| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRawBytes(unsigned int chnIdx,short * data,unsigned int nb_samples) -getUriDefinition = addMethod(ContextDefinition, ... - "std::string libm2k::context::Context::getUri()", ... - "MATLABName", "getUri", ... - "Description", "getUri Method of C++ class libm2k::context::Context." + newline + ... - "Get the URI of the current context", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getUriDefinition, "RetVal", "string", "Description", "string containing the context URI (ex: ""usb:1.2.3"", ""ip:192.168.2.1"")"); -validate(getUriDefinition); +pushRawBytesDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::pushRawBytes(unsigned int chnIdx,short * data,unsigned int nb_samples)", ... + "MATLABName", "pushRawBytes", ... + "Description", "pushRawBytes Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Send the samples to the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(pushRawBytesDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineArgument(pushRawBytesDefinition, "data", "clib.array.libm2k.Short", "input", "nb_samples", "Description", "data A pointer to the raw samples"); % can be "clib.array.libm2k.Short", or "int16" +defineArgument(pushRawBytesDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples"); +validate(pushRawBytesDefinition); -%% C++ class method |getDMM| for C++ class |libm2k::context::Context| -% C++ Signature: libm2k::analog::DMM * libm2k::context::Context::getDMM(unsigned int index) +%% C++ class method |pushInterleaved| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::pushInterleaved(double * data,unsigned int nb_channels,unsigned int nb_samples) -getDMMDefinition = addMethod(ContextDefinition, ... - "libm2k::analog::DMM * libm2k::context::Context::getDMM(unsigned int index)", ... - "MATLABName", "getDMM", ... - "Description", "getDMM Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve the DMM object at a certain index", ... +pushInterleavedDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::pushInterleaved(double * data,unsigned int nb_channels,unsigned int nb_samples)", ... + "MATLABName", "pushInterleaved", ... + "Description", "pushInterleaved Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Send samples to all the channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getDMMDefinition, "index", "uint32", "Description", "index The index corresponding to the DMM"); -defineOutput(getDMMDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM", 1, "Description", "On success, a pointer to a DMM object"); -validate(getDMMDefinition); +defineArgument(pushInterleavedDefinition, "data", "clib.array.libm2k.Double", "input", "nb_samples", "Description", "data A pointer to the interleaved data"); % can be "clib.array.libm2k.Double", or "double" +defineArgument(pushInterleavedDefinition, "nb_channels", "uint32", "Description", "nb_channels the number of channels on which we want to push"); +defineArgument(pushInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples total (samples_per_channel channels)" + newline + ... + " @note Make sure the samples are interleaved" + newline + ... + " @note Streaming data is possible - required multiple kernel buffers" + newline + ... + " @note The given channel will be synchronized with the other channel" + newline + ... + " @note Due to a hardware limitation, the number of samples per channel must" + newline + ... + " be a multiple of 4 and greater than 16 (non-cyclic buffers) or 1024 (cyclic buffers)" + newline + ... + " @note The samples in the buffer can be repeated until the buffer reaches the size requirements"); +validate(pushInterleavedDefinition); -%% C++ class method |getDMM| for C++ class |libm2k::context::Context| -% C++ Signature: libm2k::analog::DMM * libm2k::context::Context::getDMM(std::string name) +%% C++ class method |pushRawInterleaved| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRawInterleaved(short * data,unsigned int nb_channels,unsigned int nb_samples) -getDMMDefinition = addMethod(ContextDefinition, ... - "libm2k::analog::DMM * libm2k::context::Context::getDMM(std::string name)", ... - "MATLABName", "getDMM", ... - "Description", "getDMM Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve the DMM object which has the provided name", ... +pushRawInterleavedDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::pushRawInterleaved(short * data,unsigned int nb_channels,unsigned int nb_samples)", ... + "MATLABName", "pushRawInterleaved", ... + "Description", "pushRawInterleaved Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Send samples to all the channels", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getDMMDefinition, "name", "string", "Description", "name The name corresponding to the DMM"); -defineOutput(getDMMDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM", 1, "Description", "On success, a pointer to a DMM object"); -validate(getDMMDefinition); +defineArgument(pushRawInterleavedDefinition, "data", "clib.array.libm2k.Short", "input", "nb_samples", "Description", "data A pointer to the interleaved raw data"); % can be "clib.array.libm2k.Short", or "int16" +defineArgument(pushRawInterleavedDefinition, "nb_channels", "uint32", "Description", "nb_channels the number of channels on which we want to push"); +defineArgument(pushRawInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples total (samples_per_channel channels)" + newline + ... + " @note Make sure the raw samples are interleaved" + newline + ... + " @note Streaming data is possible - required multiple kernel buffers" + newline + ... + " @note The given channel will be synchronized with the other channel" + newline + ... + " @note Due to a hardware limitation, the number of samples per channel must" + newline + ... + " be a multiple of 4 and greater than 16 (non-cyclic buffers) or 1024 (cyclic buffers)" + newline + ... + " @note The samples in the buffer can be repeated until the buffer reaches the size requirements"); +validate(pushRawInterleavedDefinition); -%% C++ class method |getAvailableContextAttributes| for C++ class |libm2k::context::Context| -% C++ Signature: std::vector libm2k::context::Context::getAvailableContextAttributes() +%% C++ class method |push| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::push(unsigned int chnIdx,std::vector> const & data) -getAvailableContextAttributesDefinition = addMethod(ContextDefinition, ... - "std::vector libm2k::context::Context::getAvailableContextAttributes()", ... - "MATLABName", "getAvailableContextAttributes", ... - "Description", "getAvailableContextAttributes Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve all the available context attributes", ... +pushDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::push(unsigned int chnIdx,std::vector> const & data)", ... + "MATLABName", "push", ... + "Description", "push Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Send the samples to the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getAvailableContextAttributesDefinition, "RetVal", "clib.array.libm2k.std.String", "Description", "A list of strings containing all the context attributes"); -validate(getAvailableContextAttributesDefinition); +defineArgument(pushDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineArgument(pushDefinition, "data", "clib.array.libm2k.Double", "Description", "data A list of doubles containing all samples"); +validate(pushDefinition); -%% C++ class method |getContextAttributeValue| for C++ class |libm2k::context::Context| -% C++ Signature: std::string libm2k::context::Context::getContextAttributeValue(std::string attr) +%% C++ class method |pushRaw| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRaw(unsigned int chnIdx,std::vector> const & data) -getContextAttributeValueDefinition = addMethod(ContextDefinition, ... - "std::string libm2k::context::Context::getContextAttributeValue(std::string attr)", ... - "MATLABName", "getContextAttributeValue", ... - "Description", "getContextAttributeValue Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve the value of one context attribute", ... +pushRawDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::pushRaw(unsigned int chnIdx,std::vector> const & data)", ... + "MATLABName", "pushRaw", ... + "Description", "pushRaw Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Send the samples to the given channel", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getContextAttributeValueDefinition, "attr", "string", "Description", "attr The name of the required attribute"); -defineOutput(getContextAttributeValueDefinition, "RetVal", "string", "Description", "On success, return a string containing the value of the attribute" + newline + ... - " @throw On error, throw an exception if the attribute is not found"); -validate(getContextAttributeValueDefinition); +defineArgument(pushRawDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineArgument(pushRawDefinition, "data", "clib.array.libm2k.Short", "Description", "data A list of shorts containing all samples"); +validate(pushRawDefinition); -%% C++ class method |getContextDescription| for C++ class |libm2k::context::Context| -% C++ Signature: std::string libm2k::context::Context::getContextDescription() +%% C++ class method |stop| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::stop() -getContextDescriptionDefinition = addMethod(ContextDefinition, ... - "std::string libm2k::context::Context::getContextDescription()", ... - "MATLABName", "getContextDescription", ... - "Description", "getContextDescription Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve a detailed context description", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getContextDescriptionDefinition, "RetVal", "string", "Description", "string containing the current context description"); -validate(getContextDescriptionDefinition); +stopDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::stop()", ... + "MATLABName", "stop", ... + "Description", "stop Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Stop all channels from sending the signals.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@note Both DACs will be powered down"); % Modify help description values as needed. +validate(stopDefinition); -%% C++ class method |getSerialNumber| for C++ class |libm2k::context::Context| -% C++ Signature: std::string libm2k::context::Context::getSerialNumber() +%% C++ class method |stop| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::stop(unsigned int chn) -getSerialNumberDefinition = addMethod(ContextDefinition, ... - "std::string libm2k::context::Context::getSerialNumber()", ... - "MATLABName", "getSerialNumber", ... - "Description", "getSerialNumber Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve the current context serial number", ... +stopDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::stop(unsigned int chn)", ... + "MATLABName", "stop", ... + "Description", "stop Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Stop the given channels from sending the signals", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getSerialNumberDefinition, "RetVal", "string", "Description", "string containing the current context serial number"); -validate(getSerialNumberDefinition); +defineArgument(stopDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +validate(stopDefinition); -%% C++ class method |logAllAttributes| for C++ class |libm2k::context::Context| -% C++ Signature: void libm2k::context::Context::logAllAttributes() const +%% C++ class method |cancelBuffer| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::cancelBuffer() -logAllAttributesDefinition = addMethod(ContextDefinition, ... - "void libm2k::context::Context::logAllAttributes() const", ... - "MATLABName", "logAllAttributes", ... - "Description", "logAllAttributes Method of C++ class libm2k::context::Context." + newline + ... - "Log all the attributes" + newline + ... - " @note The logging system should be enabled", ... +cancelBufferDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::cancelBuffer()", ... + "MATLABName", "cancelBuffer", ... + "Description", "cancelBuffer Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Cancel all buffer operations of enabled channels" + newline + ... + " @note Should be used to cancel an ongoing data write.", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@brief Log all the attributes" + newline + ... - " @note The logging system should be enabled"); % Modify help description values as needed. -validate(logAllAttributesDefinition); + "@brief Cancel all buffer operations of enabled channels" + newline + ... + " @note Should be used to cancel an ongoing data write."); % Modify help description values as needed. +validate(cancelBufferDefinition); -%% C++ class method |toM2k| for C++ class |libm2k::context::Context| -% C++ Signature: libm2k::context::M2k * libm2k::context::Context::toM2k() +%% C++ class method |cancelBuffer| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::cancelBuffer(unsigned int chn) -%toM2kDefinition = addMethod(ContextDefinition, ... -% "libm2k::context::M2k * libm2k::context::Context::toM2k()", ... -% "MATLABName", "toM2k", ... -% "Description", "toM2k Method of C++ class libm2k::context::Context." + newline + ... -% "Convert the current context to M2k context, if possible", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineOutput(toM2kDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", , "Description", "On success, return the corresponding M2k object"); -%validate(toM2kDefinition); +cancelBufferDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::cancelBuffer(unsigned int chn)", ... + "MATLABName", "cancelBuffer", ... + "Description", "cancelBuffer Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Cancel all buffer operations of the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(cancelBufferDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel" + newline + ... + " @note Should be used to cancel an ongoing data write."); +validate(cancelBufferDefinition); -%% C++ class method |toGeneric| for C++ class |libm2k::context::Context| -% C++ Signature: libm2k::context::Generic * libm2k::context::Context::toGeneric() +%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::enableChannel(unsigned int chnIdx,bool enable) -%toGenericDefinition = addMethod(ContextDefinition, ... -% "libm2k::context::Generic * libm2k::context::Context::toGeneric()", ... -% "MATLABName", "toGeneric", ... -% "Description", "toGeneric Method of C++ class libm2k::context::Context." + newline + ... -% "Convert the current context to Generic context, if possible", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineOutput(toGenericDefinition, "RetVal", "clib.libm2k.libm2k.context.Generic", , "Description", "On success, return the corresponding Generic object"); -%validate(toGenericDefinition); +enableChannelDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::enableChannel(unsigned int chnIdx,bool enable)", ... + "MATLABName", "enableChannel", ... + "Description", "enableChannel Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Enable or disable the given digital channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(enableChannelDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); +validate(enableChannelDefinition); -%% C++ class method |getDmmCount| for C++ class |libm2k::context::Context| -% C++ Signature: unsigned int libm2k::context::Context::getDmmCount() +%% C++ class method |isChannelEnabled| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: bool libm2k::analog::M2kAnalogOut::isChannelEnabled(unsigned int chnIdx) -getDmmCountDefinition = addMethod(ContextDefinition, ... - "unsigned int libm2k::context::Context::getDmmCount()", ... - "MATLABName", "getDmmCount", ... - "Description", "getDmmCount Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve the number of DMM objects", ... +isChannelEnabledDefinition = addMethod(M2kAnalogOutDefinition, ... + "bool libm2k::analog::M2kAnalogOut::isChannelEnabled(unsigned int chnIdx)", ... + "MATLABName", "isChannelEnabled", ... + "Description", "isChannelEnabled Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Check if the given channel is enabled", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getDmmCountDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of DMM objects in the context"); -validate(getDmmCountDefinition); +defineArgument(isChannelEnabledDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineOutput(isChannelEnabledDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the channel"); +validate(isChannelEnabledDefinition); -%% C++ class method |getFirmwareVersion| for C++ class |libm2k::context::Context| -% C++ Signature: std::string libm2k::context::Context::getFirmwareVersion() +%% C++ class method |isPushDone| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: bool libm2k::analog::M2kAnalogOut::isPushDone(unsigned int chnIdx) const -getFirmwareVersionDefinition = addMethod(ContextDefinition, ... - "std::string libm2k::context::Context::getFirmwareVersion()", ... - "MATLABName", "getFirmwareVersion", ... - "Description", "getFirmwareVersion Method of C++ class libm2k::context::Context." + newline + ... - "Retrieve the firmware version of the current context", ... +isPushDoneDefinition = addMethod(M2kAnalogOutDefinition, ... + "bool libm2k::analog::M2kAnalogOut::isPushDone(unsigned int chnIdx) const", ... + "MATLABName", "isPushDone", ... + "Description", "isPushDone Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Check if the generation of the signal (only for non-cyclic buffer) is done", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getFirmwareVersionDefinition, "RetVal", "string", "Description", "a string containing the firmware version"); -validate(getFirmwareVersionDefinition); +defineArgument(isPushDoneDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineOutput(isPushDoneDefinition, "RetVal", "logical", "Description", "True if the push process is done, false otherwise"); +validate(isPushDoneDefinition); -%% C++ class method |getIioContextVersion| for C++ class |libm2k::context::Context| -% C++ Signature: libm2k::IIO_CONTEXT_VERSION const libm2k::context::Context::getIioContextVersion() +%% C++ class method |setKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::setKernelBuffersCount(unsigned int chnIdx,unsigned int count) -getIioContextVersionDefinition = addMethod(ContextDefinition, ... - "libm2k::IIO_CONTEXT_VERSION const libm2k::context::Context::getIioContextVersion()", ... - "MATLABName", "getIioContextVersion", ... - "Description", "getIioContextVersion Method of C++ class libm2k::context::Context.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "Get the version of the backend in use"); % Modify help description values as needed. -defineOutput(getIioContextVersionDefinition, "RetVal", "clib.libm2k.libm2k.IIO_CONTEXT_VERSION", "Description", "IIO_CONTEXT_VERSION struct"); -validate(getIioContextVersionDefinition); +setKernelBuffersCountDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::setKernelBuffersCount(unsigned int chnIdx,unsigned int count)", ... + "MATLABName", "setKernelBuffersCount", ... + "Description", "setKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Set the kernel buffers to a specific value", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setKernelBuffersCountDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineArgument(setKernelBuffersCountDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); +validate(setKernelBuffersCountDefinition); -%% C++ class method |getIioContext| for C++ class |libm2k::context::Context| -% C++ Signature: iio_context * libm2k::context::Context::getIioContext() +%% C++ class method |getKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: unsigned int libm2k::analog::M2kAnalogOut::getKernelBuffersCount(unsigned int chnIdx) const -getIioContextDefinition = addMethod(ContextDefinition, ... - "iio_context * libm2k::context::Context::getIioContext()", ... - "MATLABName", "getIioContext", ... - "Description", "getIioContext Method of C++ class libm2k::context::Context.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "Retrieve the iio context"); % Modify help description values as needed. -defineOutput(getIioContextDefinition, "RetVal", "clib.libm2k.iio_context", 1, "Description", "A pointer to the iio context"); -validate(getIioContextDefinition); +getKernelBuffersCountDefinition = addMethod(M2kAnalogOutDefinition, ... + "unsigned int libm2k::analog::M2kAnalogOut::getKernelBuffersCount(unsigned int chnIdx) const", ... + "MATLABName", "getKernelBuffersCount", ... + "Description", "getKernelBuffersCount Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Get the number of kernel buffers", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getKernelBuffersCountDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel"); +defineOutput(getKernelBuffersCountDefinition, "RetVal", "uint32", "Description", "the number of previously set kernel buffers (saved in this session)"); +validate(getKernelBuffersCountDefinition); -%% C++ class method |setTimeout| for C++ class |libm2k::context::Context| -% C++ Signature: void libm2k::context::Context::setTimeout(unsigned int timeout) +%% C++ class method |convertVoltsToRaw| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: short libm2k::analog::M2kAnalogOut::convertVoltsToRaw(unsigned int channel,double voltage) -setTimeoutDefinition = addMethod(ContextDefinition, ... - "void libm2k::context::Context::setTimeout(unsigned int timeout)", ... - "MATLABName", "setTimeout", ... - "Description", "setTimeout Method of C++ class libm2k::context::Context." + newline + ... - "Set a timeout for I/O operations", ... +convertVoltsToRawDefinition = addMethod(M2kAnalogOutDefinition, ... + "short libm2k::analog::M2kAnalogOut::convertVoltsToRaw(unsigned int channel,double voltage)", ... + "MATLABName", "convertVoltsToRaw", ... + "Description", "convertVoltsToRaw Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Convert the volts value of a sample into raw", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setTimeoutDefinition, "timeout", "uint32", "Description", "timeout A positive integer representing the time in milliseconds after which a timeout occurs. A value of 0 is used to specify that no timeout should occur."); -validate(setTimeoutDefinition); - -%% C++ class |libm2k::context::ContextBuilder| with MATLAB name |clib.libm2k.libm2k.context.ContextBuilder| -ContextBuilderDefinition = addClass(libDef, "libm2k::context::ContextBuilder", "MATLABName", "clib.libm2k.libm2k.context.ContextBuilder", ... - "Description", "clib.libm2k.libm2k.context.ContextBuilder Representation of C++ class libm2k::context::ContextBuilder.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. +defineArgument(convertVoltsToRawDefinition, "channel", "uint32", "Description", "channel The index corresponding to the channel"); +defineArgument(convertVoltsToRawDefinition, "voltage", "double", "Description", "voltage The volts value of a sample"); +defineOutput(convertVoltsToRawDefinition, "RetVal", "int16", "Description", "The value of a sample converted into raw"); +validate(convertVoltsToRawDefinition); -%% C++ class constructor for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: libm2k::context::ContextBuilder::ContextBuilder() +%% C++ class method |convertRawToVolts| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: double libm2k::analog::M2kAnalogOut::convertRawToVolts(unsigned int channel,short raw) -ContextBuilderConstructor1Definition = addConstructor(ContextBuilderDefinition, ... - "libm2k::context::ContextBuilder::ContextBuilder()", ... - "Description", "clib.libm2k.libm2k.context.ContextBuilder Constructor of C++ class libm2k::context::ContextBuilder.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -validate(ContextBuilderConstructor1Definition); +convertRawToVoltsDefinition = addMethod(M2kAnalogOutDefinition, ... + "double libm2k::analog::M2kAnalogOut::convertRawToVolts(unsigned int channel,short raw)", ... + "MATLABName", "convertRawToVolts", ... + "Description", "convertRawToVolts Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Convert the raw value of a sample into volts", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(convertRawToVoltsDefinition, "channel", "uint32", "Description", "channel The index corresponding to the channel"); +defineArgument(convertRawToVoltsDefinition, "raw", "int16", "Description", "raw The raw value of a sample"); +defineOutput(convertRawToVoltsDefinition, "RetVal", "double", "Description", "The value of a sample converted into volts"); +validate(convertRawToVoltsDefinition); -%% C++ class method |getAllContexts| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static std::vector libm2k::context::ContextBuilder::getAllContexts() +%% C++ class method |getIioObjects| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogOut::getIioObjects() -getAllContextsDefinition = addMethod(ContextBuilderDefinition, ... - "static std::vector libm2k::context::ContextBuilder::getAllContexts()", ... - "MATLABName", "getAllContexts", ... - "Description", "getAllContexts Method of C++ class libm2k::context::ContextBuilder.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@private"); % Modify help description values as needed. -defineOutput(getAllContextsDefinition, "RetVal", "clib.array.libm2k.std.String"); -validate(getAllContextsDefinition); +getIioObjectsDefinition = addMethod(M2kAnalogOutDefinition, ... + "libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogOut::getIioObjects()", ... + "MATLABName", "getIioObjects", ... + "Description", "getIioObjects Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Get access to IIO channels, buffers, devices and context." + newline + ... + " @note Can be used when debugging directly with libiio.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure."); +validate(getIioObjectsDefinition); -%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(char const * input1) +%% C++ class method |getNbChannels| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: unsigned int libm2k::analog::M2kAnalogOut::getNbChannels() -%contextOpenDefinition = addMethod(ContextBuilderDefinition, ... -% "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(char const * input1)", ... -% "MATLABName", "contextOpen", ... -% "Description", "contextOpen Method of C++ class libm2k::context::ContextBuilder.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineArgument(contextOpenDefinition, "input1", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" -%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); -%validate(contextOpenDefinition); +getNbChannelsDefinition = addMethod(M2kAnalogOutDefinition, ... + "unsigned int libm2k::analog::M2kAnalogOut::getNbChannels()", ... + "MATLABName", "getNbChannels", ... + "Description", "getNbChannels Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the number of analogical channels", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getNbChannelsDefinition, "RetVal", "uint32", "Description", "The number of channels"); +validate(getNbChannelsDefinition); -%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(iio_context * input1,char const * input2) +%% C++ class method |getChannelName| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: std::string libm2k::analog::M2kAnalogOut::getChannelName(unsigned int channel) -%contextOpenDefinition = addMethod(ContextBuilderDefinition, ... -% "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(iio_context * input1,char const * input2)", ... -% "MATLABName", "contextOpen", ... -% "Description", "contextOpen Method of C++ class libm2k::context::ContextBuilder.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineArgument(contextOpenDefinition, "input1", "clib.libm2k.iio_context", "input", ); -%defineArgument(contextOpenDefinition, "input2", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" -%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); -%validate(contextOpenDefinition); - -%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen() +getChannelNameDefinition = addMethod(M2kAnalogOutDefinition, ... + "std::string libm2k::analog::M2kAnalogOut::getChannelName(unsigned int channel)", ... + "MATLABName", "getChannelName", ... + "Description", "getChannelName Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Get the channel name for each DAC channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getChannelNameDefinition, "channel", "uint32", "Description", "channel - unsigned int representing the index of the channel"); +defineOutput(getChannelNameDefinition, "RetVal", "string", "Description", "std::string - name of the channel"); +validate(getChannelNameDefinition); -%contextOpenDefinition = addMethod(ContextBuilderDefinition, ... -% "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen()", ... -% "MATLABName", "contextOpen", ... -% "Description", "contextOpen Method of C++ class libm2k::context::ContextBuilder.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); -%validate(contextOpenDefinition); +%% C++ class method |getMaximumSamplerate| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: double libm2k::analog::M2kAnalogOut::getMaximumSamplerate(unsigned int chn_idx) -%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(char const * input1) +getMaximumSamplerateDefinition = addMethod(M2kAnalogOutDefinition, ... + "double libm2k::analog::M2kAnalogOut::getMaximumSamplerate(unsigned int chn_idx)", ... + "MATLABName", "getMaximumSamplerate", ... + "Description", "getMaximumSamplerate Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Get the maximum samplerate for the DAC", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getMaximumSamplerateDefinition, "chn_idx", "uint32", "Description", "chn_idx - unsigned int representing the index of the channel"); +defineOutput(getMaximumSamplerateDefinition, "RetVal", "double", "Description", "double - the value of the maximum samplerate"); +validate(getMaximumSamplerateDefinition); -%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ... -% "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(char const * input1)", ... -% "MATLABName", "m2kOpen", ... -% "Description", "m2kOpen Method of C++ class libm2k::context::ContextBuilder.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineArgument(m2kOpenDefinition, "input1", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" -%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", ); -%validate(m2kOpenDefinition); +%% C++ class method |setVoltage| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: unsigned short libm2k::analog::M2kAnalogOut::setVoltage(unsigned int chn_idx,double volts) -%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(iio_context * input1,char const * input2) +setVoltageDefinition = addMethod(M2kAnalogOutDefinition, ... + "unsigned short libm2k::analog::M2kAnalogOut::setVoltage(unsigned int chn_idx,double volts)", ... + "MATLABName", "setVoltage", ... + "Description", "setVoltage Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Sets the voltage output of the DAC channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setVoltageDefinition, "chn_idx", "uint32", "Description", "chn_idx - unsigned int representing the index of the channel"); +defineArgument(setVoltageDefinition, "volts", "double", "Description", "volts - actual value to be set" + newline + ... + " " + newline + ... + " @note In scenarios where the DMA is not active, such as when an output buffer is destroyed," + newline + ... + " the DAC will revert to using the raw value set by this function."); +defineOutput(setVoltageDefinition, "RetVal", "uint16", "Description", "unsigned short - the corresponding raw value for the given voltage"); +validate(setVoltageDefinition); -%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ... -% "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(iio_context * input1,char const * input2)", ... -% "MATLABName", "m2kOpen", ... -% "Description", "m2kOpen Method of C++ class libm2k::context::ContextBuilder.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineArgument(m2kOpenDefinition, "input1", "clib.libm2k.iio_context", "input", ); -%defineArgument(m2kOpenDefinition, "input2", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" -%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", ); -%validate(m2kOpenDefinition); +%% C++ class method |setVoltageRaw| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: unsigned short libm2k::analog::M2kAnalogOut::setVoltageRaw(unsigned int chn_idx,unsigned short raw) -%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen() +setVoltageRawDefinition = addMethod(M2kAnalogOutDefinition, ... + "unsigned short libm2k::analog::M2kAnalogOut::setVoltageRaw(unsigned int chn_idx,unsigned short raw)", ... + "MATLABName", "setVoltageRaw", ... + "Description", "setVoltageRaw Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Sets the raw output of the DAC channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setVoltageRawDefinition, "chn_idx", "uint32", "Description", "chn_idx - unsigned int representing the index of the channel"); +defineArgument(setVoltageRawDefinition, "raw", "uint16", "Description", "raw - actual value to be set" + newline + ... + " " + newline + ... + " @note In scenarios where the DMA is not active, such as when an output buffer is destroyed," + newline + ... + " the DAC will revert to using the raw value set by this function."); +defineOutput(setVoltageRawDefinition, "RetVal", "uint16", "Description", "unsigned short - the value set in the raw attribute"); +validate(setVoltageRawDefinition); -%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ... -% "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen()", ... -% "MATLABName", "m2kOpen", ... -% "Description", "m2kOpen Method of C++ class libm2k::context::ContextBuilder.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", ); -%validate(m2kOpenDefinition); +%% C++ class method |getTrigger| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogOut::getTrigger() -%% C++ class method |contextClose| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static void libm2k::context::ContextBuilder::contextClose(libm2k::context::Context * input1,bool deinit = 1) +getTriggerDefinition = addMethod(M2kAnalogOutDefinition, ... + "libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogOut::getTrigger()", ... + "MATLABName", "getTrigger", ... + "Description", "getTrigger Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Get the hardware trigger handler", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getTriggerDefinition, "RetVal", "clib.libm2k.libm2k.M2kHardwareTrigger", 1, "Description", "A pointer to the hardware trigger"); +validate(getTriggerDefinition); -%contextCloseDefinition = addMethod(ContextBuilderDefinition, ... -% "static void libm2k::context::ContextBuilder::contextClose(libm2k::context::Context * input1,bool deinit = 1)", ... -% "MATLABName", "contextClose", ... -% "Description", "contextClose Method of C++ class libm2k::context::ContextBuilder.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineArgument(contextCloseDefinition, "input1", "clib.libm2k.libm2k.context.Context", "input", ); % can be "clib.libm2k.libm2k.context.Context", or "clib.array.libm2k.libm2k.context.Context" -%defineArgument(contextCloseDefinition, "deinit", "logical"); -%validate(contextCloseDefinition); +%% C++ class method |setBufferRearmOnTrigger| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: void libm2k::analog::M2kAnalogOut::setBufferRearmOnTrigger(bool enable) -%% C++ class method |contextCloseAll| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static void libm2k::context::ContextBuilder::contextCloseAll() +setBufferRearmOnTriggerDefinition = addMethod(M2kAnalogOutDefinition, ... + "void libm2k::analog::M2kAnalogOut::setBufferRearmOnTrigger(bool enable)", ... + "MATLABName", "setBufferRearmOnTrigger", ... + "Description", "setBufferRearmOnTrigger Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Allows sequential output of multiple buffers with each trigger event.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setBufferRearmOnTriggerDefinition, "enable", "logical", "Description", "enable A boolean value that enables or disables the buffer rearm functionality."); +validate(setBufferRearmOnTriggerDefinition); -contextCloseAllDefinition = addMethod(ContextBuilderDefinition, ... - "static void libm2k::context::ContextBuilder::contextCloseAll()", ... - "MATLABName", "contextCloseAll", ... - "Description", "contextCloseAll Method of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed. -validate(contextCloseAllDefinition); +%% C++ class method |getBufferRearmOnTrigger| for C++ class |libm2k::analog::M2kAnalogOut| +% C++ Signature: bool libm2k::analog::M2kAnalogOut::getBufferRearmOnTrigger() const -%% C++ class method |getVersion| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static std::string libm2k::context::ContextBuilder::getVersion() +getBufferRearmOnTriggerDefinition = addMethod(M2kAnalogOutDefinition, ... + "bool libm2k::analog::M2kAnalogOut::getBufferRearmOnTrigger() const", ... + "MATLABName", "getBufferRearmOnTrigger", ... + "Description", "getBufferRearmOnTrigger Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ... + "Retrieve the value of the attribute that controls buffer rearm on trigger" + newline + ... + " @note The buffer rearm on trigger is disabled by default." + newline + ... + " @note The attribute is shared between both channels." + newline + ... + " @note Only available from firmware v0.33.", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getBufferRearmOnTriggerDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the rearm on trigger."); +validate(getBufferRearmOnTriggerDefinition); -getVersionDefinition = addMethod(ContextBuilderDefinition, ... - "static std::string libm2k::context::ContextBuilder::getVersion()", ... - "MATLABName", "getVersion", ... - "Description", "getVersion Method of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed. -defineOutput(getVersionDefinition, "RetVal", "string"); -validate(getVersionDefinition); +%% C++ class |libm2k::analog::M2kPowerSupply| with MATLAB name |clib.libm2k.libm2k.analog.M2kPowerSupply| +M2kPowerSupplyDefinition = addClass(libDef, "libm2k::analog::M2kPowerSupply", "MATLABName", "clib.libm2k.libm2k.analog.M2kPowerSupply", ... + "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply Representation of C++ class libm2k::analog::M2kPowerSupply." + newline + ... + "Contains the representation of the power supply" + newline + ... + "" + newline + ... + "@class M2kPowerSupply m2kpowersupply.hpp libm2k/analog/m2kpowersupply.hpp" + newline + ... + "@brief Controls the power supply", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@defgroup powersupply PowerSupply" + newline + ... + "@brief Contains the representation of the power supply" + newline + ... + "" + newline + ... + "@class M2kPowerSupply m2kpowersupply.hpp libm2k/analog/m2kpowersupply.hpp" + newline + ... + "@brief Controls the power supply"); % Modify help description values as needed. -%% C++ class method |enableLogging| for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: static void libm2k::context::ContextBuilder::enableLogging(bool enable) +%% C++ class method |reset| for C++ class |libm2k::analog::M2kPowerSupply| +% C++ Signature: void libm2k::analog::M2kPowerSupply::reset() -enableLoggingDefinition = addMethod(ContextBuilderDefinition, ... - "static void libm2k::context::ContextBuilder::enableLogging(bool enable)", ... - "MATLABName", "enableLogging", ... - "Description", "enableLogging Method of C++ class libm2k::context::ContextBuilder.", ... +resetDefinition = addMethod(M2kPowerSupplyDefinition, ... + "void libm2k::analog::M2kPowerSupply::reset()", ... + "MATLABName", "reset", ... + "Description", "reset Method of C++ class libm2k::analog::M2kPowerSupply.", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... "@private"); % Modify help description values as needed. -defineArgument(enableLoggingDefinition, "enable", "logical"); -validate(enableLoggingDefinition); +validate(resetDefinition); -%% C++ class constructor for C++ class |libm2k::context::ContextBuilder| -% C++ Signature: libm2k::context::ContextBuilder::ContextBuilder(libm2k::context::ContextBuilder const & input1) +%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kPowerSupply| +% C++ Signature: void libm2k::analog::M2kPowerSupply::enableChannel(unsigned int chn,bool en) -ContextBuilderConstructor2Definition = addConstructor(ContextBuilderDefinition, ... - "libm2k::context::ContextBuilder::ContextBuilder(libm2k::context::ContextBuilder const & input1)", ... - "Description", "clib.libm2k.libm2k.context.ContextBuilder Constructor of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed. -defineArgument(ContextBuilderConstructor2Definition, "input1", "clib.libm2k.libm2k.context.ContextBuilder", "input"); -validate(ContextBuilderConstructor2Definition); +enableChannelDefinition = addMethod(M2kPowerSupplyDefinition, ... + "void libm2k::analog::M2kPowerSupply::enableChannel(unsigned int chn,bool en)", ... + "MATLABName", "enableChannel", ... + "Description", "enableChannel Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... + "Enable or disable the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(enableChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineArgument(enableChannelDefinition, "en", "logical", "Description", "en A boolean value corresponding to the state of the channel"); +validate(enableChannelDefinition); -%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen| -% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen() +%% C++ class method |enableAll| for C++ class |libm2k::analog::M2kPowerSupply| +% C++ Signature: void libm2k::analog::M2kPowerSupply::enableAll(bool en) -%contextOpenDefinition = addFunction(libDef, ... -% "libm2k::context::Context * libm2k::context::contextOpen()", ... -% "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ... -% "Description", "clib.libm2k.libm2k.context.contextOpen Representation of C++ function libm2k::context::contextOpen.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); -%validate(contextOpenDefinition); +enableAllDefinition = addMethod(M2kPowerSupplyDefinition, ... + "void libm2k::analog::M2kPowerSupply::enableAll(bool en)", ... + "MATLABName", "enableAll", ... + "Description", "enableAll Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... + "Enable or disable all channels", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(enableAllDefinition, "en", "logical", "Description", "en A boolean value corresponding to the state of the channels"); +validate(enableAllDefinition); -%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen| -% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen(char const * uri) +%% C++ class method |readChannel| for C++ class |libm2k::analog::M2kPowerSupply| +% C++ Signature: double libm2k::analog::M2kPowerSupply::readChannel(unsigned int chn,bool calibrated = 1) -%contextOpenDefinition = addFunction(libDef, ... -% "libm2k::context::Context * libm2k::context::contextOpen(char const * uri)", ... -% "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ... -% "Description", "clib.libm2k.libm2k.context.contextOpen Representation of C++ function libm2k::context::contextOpen.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineArgument(contextOpenDefinition, "uri", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" -%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); -%validate(contextOpenDefinition); +readChannelDefinition = addMethod(M2kPowerSupplyDefinition, ... + "double libm2k::analog::M2kPowerSupply::readChannel(unsigned int chn,bool calibrated = 1)", ... + "MATLABName", "readChannel", ... + "Description", "readChannel Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... + "Retrieve the value of a given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(readChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineArgument(readChannelDefinition, "calibrated", "logical", "Description", "calibrated Read values are converted using the calibration" + newline + ... + " coefficients from the IIO context by default; This boolean flag" + newline + ... + " specifies whether the coefficients should be used."); +defineOutput(readChannelDefinition, "RetVal", "double", "Description", "double The voltage transmitted by the given channel"); +validate(readChannelDefinition); -%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen| -% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen(iio_context * ctx,char const * uri) +%% C++ class method |pushChannel| for C++ class |libm2k::analog::M2kPowerSupply| +% C++ Signature: void libm2k::analog::M2kPowerSupply::pushChannel(unsigned int chn,double value,bool calibrated = 1) -%contextOpenDefinition = addFunction(libDef, ... -% "libm2k::context::Context * libm2k::context::contextOpen(iio_context * ctx,char const * uri)", ... -% "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ... -% "Description", "clib.libm2k.libm2k.context.contextOpen Representation of C++ function libm2k::context::contextOpen.", ... -% "DetailedDescription", "This content is from the external library documentation." + newline + ... -% "" + newline + ... -% "@private"); % Modify help description values as needed. -%defineArgument(contextOpenDefinition, "ctx", "clib.libm2k.iio_context", "input", ); -%defineArgument(contextOpenDefinition, "uri", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" -%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); -%validate(contextOpenDefinition); +pushChannelDefinition = addMethod(M2kPowerSupplyDefinition, ... + "void libm2k::analog::M2kPowerSupply::pushChannel(unsigned int chn,double value,bool calibrated = 1)", ... + "MATLABName", "pushChannel", ... + "Description", "pushChannel Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... + "Set the voltage for the given channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(pushChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); +defineArgument(pushChannelDefinition, "value", "double", "Description", "value The voltage (up to 5V)"); +defineArgument(pushChannelDefinition, "calibrated", "logical", "Description", "calibrated Written values are converted using the calibration" + newline + ... + " coefficients from the IIO context by default; This boolean flag" + newline + ... + " specifies whether the coefficients should be used."); +validate(pushChannelDefinition); -%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen| -% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen(char const * uri) +%% C++ class method |powerDownDacs| for C++ class |libm2k::analog::M2kPowerSupply| +% C++ Signature: void libm2k::analog::M2kPowerSupply::powerDownDacs(bool powerdown) -m2kOpenDefinition = addFunction(libDef, ... - "libm2k::context::M2k * libm2k::context::m2kOpen(char const * uri)", ... - "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ... - "Description", "clib.libm2k.libm2k.context.m2kOpen Representation of C++ function libm2k::context::m2kOpen." + newline + ... - "Open an ADALM2000 based on a given uri", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(m2kOpenDefinition, "uri", "string", "input", "nullTerminated", "Description", "uri Describe the location of the context"); % can be "clib.array.libm2k.Char","int8","string", or "char" -defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", 1, "Description", "M2k object or nullptr if no ADALM2000 was found/available"); -validate(m2kOpenDefinition); +powerDownDacsDefinition = addMethod(M2kPowerSupplyDefinition, ... + "void libm2k::analog::M2kPowerSupply::powerDownDacs(bool powerdown)", ... + "MATLABName", "powerDownDacs", ... + "Description", "powerDownDacs Method of C++ class libm2k::analog::M2kPowerSupply.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineArgument(powerDownDacsDefinition, "powerdown", "logical"); +validate(powerDownDacsDefinition); -%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen| -% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen(iio_context * ctx,char const * uri) +%% C++ class method |anyChannelEnabled| for C++ class |libm2k::analog::M2kPowerSupply| +% C++ Signature: bool libm2k::analog::M2kPowerSupply::anyChannelEnabled() -%m2kOpenDefinition = addFunction(libDef, ... -% "libm2k::context::M2k * libm2k::context::m2kOpen(iio_context * ctx,char const * uri)", ... -% "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ... -% "Description", "clib.libm2k.libm2k.context.m2kOpen Representation of C++ function libm2k::context::m2kOpen." + newline + ... -% "Open an ADALM2000 based on an existing iio_context and uri", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineArgument(m2kOpenDefinition, "ctx", "clib.libm2k.iio_context", "input", , "Description", "ctx A pointer to an iio_context structure"); -%defineArgument(m2kOpenDefinition, "uri", , "input", , "Description", "uri Describe the location of the context"); % can be "clib.array.libm2k.Char","int8","string", or "char" -%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", , "Description", "M2k object or nullptr if no ADALM2000 was found/available"); -%validate(m2kOpenDefinition); +anyChannelEnabledDefinition = addMethod(M2kPowerSupplyDefinition, ... + "bool libm2k::analog::M2kPowerSupply::anyChannelEnabled()", ... + "MATLABName", "anyChannelEnabled", ... + "Description", "anyChannelEnabled Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ... + "Check if there is at least one enabled channel", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(anyChannelEnabledDefinition, "RetVal", "logical", "Description", "On succes, true"); +validate(anyChannelEnabledDefinition); -%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen| -% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen() +%% C++ class |libm2k::context::Context| with MATLAB name |clib.libm2k.libm2k.context.Context| +ContextDefinition = addClass(libDef, "libm2k::context::Context", "MATLABName", "clib.libm2k.libm2k.context.Context", ... + "Description", "clib.libm2k.libm2k.context.Context Representation of C++ class libm2k::context::Context." + newline + ... + "Contains the representation of a generic IIO context" + newline + ... + "" + newline + ... + "@class Context context.hpp libm2k/context.hpp" + newline + ... + "@brief Controls the IIO context"); % Modify help description values as needed. -m2kOpenDefinition = addFunction(libDef, ... - "libm2k::context::M2k * libm2k::context::m2kOpen()", ... - "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ... - "Description", "clib.libm2k.libm2k.context.m2kOpen Representation of C++ function libm2k::context::m2kOpen." + newline + ... - "Open an ADALM2000", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", 1, "Description", "M2k object or nullptr if no ADALM2000 was found/available"); -validate(m2kOpenDefinition); +%% C++ class method |reset| for C++ class |libm2k::context::Context| +% C++ Signature: void libm2k::context::Context::reset() -%% C++ function |libm2k::context::getAllContexts| with MATLAB name |clib.libm2k.libm2k.context.getAllContexts| -% C++ Signature: std::vector libm2k::context::getAllContexts() +resetDefinition = addMethod(ContextDefinition, ... + "void libm2k::context::Context::reset()", ... + "MATLABName", "reset", ... + "Description", "reset Method of C++ class libm2k::context::Context.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +validate(resetDefinition); -getAllContextsDefinition = addFunction(libDef, ... - "std::vector libm2k::context::getAllContexts()", ... - "MATLABName", "clib.libm2k.libm2k.context.getAllContexts", ... - "Description", "clib.libm2k.libm2k.context.getAllContexts Representation of C++ function libm2k::context::getAllContexts." + newline + ... - "List all available contexts", ... +%% C++ class method |deinitialize| for C++ class |libm2k::context::Context| +% C++ Signature: void libm2k::context::Context::deinitialize() + +deinitializeDefinition = addMethod(ContextDefinition, ... + "void libm2k::context::Context::deinitialize()", ... + "MATLABName", "deinitialize", ... + "Description", "deinitialize Method of C++ class libm2k::context::Context.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +validate(deinitializeDefinition); + +%% C++ class method |getUri| for C++ class |libm2k::context::Context| +% C++ Signature: std::string libm2k::context::Context::getUri() + +getUriDefinition = addMethod(ContextDefinition, ... + "std::string libm2k::context::Context::getUri()", ... + "MATLABName", "getUri", ... + "Description", "getUri Method of C++ class libm2k::context::Context." + newline + ... + "Get the URI of the current context", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getAllContextsDefinition, "RetVal", "clib.array.libm2k.std.String", "Description", "A list containing the available contexts"); -validate(getAllContextsDefinition); +defineOutput(getUriDefinition, "RetVal", "string", "Description", "string containing the context URI (ex: ""usb:1.2.3"", ""ip:192.168.2.1"")"); +validate(getUriDefinition); -%% C++ function |libm2k::context::contextClose| with MATLAB name |clib.libm2k.libm2k.context.contextClose| -% C++ Signature: void libm2k::context::contextClose(libm2k::context::Context * ctx,bool deinit = 1) +%% C++ class method |getDMM| for C++ class |libm2k::context::Context| +% C++ Signature: libm2k::analog::DMM * libm2k::context::Context::getDMM(unsigned int index) -%contextCloseDefinition = addFunction(libDef, ... -% "void libm2k::context::contextClose(libm2k::context::Context * ctx,bool deinit = 1)", ... -% "MATLABName", "clib.libm2k.libm2k.context.contextClose", ... -% "Description", "clib.libm2k.libm2k.context.contextClose Representation of C++ function libm2k::context::contextClose." + newline + ... -% "Destroy the given context", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineArgument(contextCloseDefinition, "ctx", "clib.libm2k.libm2k.context.Context", "input", , "Description", "ctx The context to be destroyed"); % can be "clib.libm2k.libm2k.context.Context", or "clib.array.libm2k.libm2k.context.Context" -%defineArgument(contextCloseDefinition, "deinit", "logical", "Description", "deinit If deinit is set to false, running contexts won't be affected"); -%validate(contextCloseDefinition); +getDMMDefinition = addMethod(ContextDefinition, ... + "libm2k::analog::DMM * libm2k::context::Context::getDMM(unsigned int index)", ... + "MATLABName", "getDMM", ... + "Description", "getDMM Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve the DMM object at a certain index", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getDMMDefinition, "index", "uint32", "Description", "index The index corresponding to the DMM"); +defineOutput(getDMMDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM", 1, "Description", "On success, a pointer to a DMM object"); +validate(getDMMDefinition); -%% C++ function |libm2k::context::contextCloseAll| with MATLAB name |clib.libm2k.libm2k.context.contextCloseAll| -% C++ Signature: void libm2k::context::contextCloseAll() +%% C++ class method |getDMM| for C++ class |libm2k::context::Context| +% C++ Signature: libm2k::analog::DMM * libm2k::context::Context::getDMM(std::string name) -contextCloseAllDefinition = addFunction(libDef, ... - "void libm2k::context::contextCloseAll()", ... - "MATLABName", "clib.libm2k.libm2k.context.contextCloseAll", ... - "Description", "clib.libm2k.libm2k.context.contextCloseAll Representation of C++ function libm2k::context::contextCloseAll." + newline + ... - "Close all the devices", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@brief Close all the devices"); % Modify help description values as needed. -validate(contextCloseAllDefinition); +getDMMDefinition = addMethod(ContextDefinition, ... + "libm2k::analog::DMM * libm2k::context::Context::getDMM(std::string name)", ... + "MATLABName", "getDMM", ... + "Description", "getDMM Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve the DMM object which has the provided name", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getDMMDefinition, "name", "string", "Description", "name The name corresponding to the DMM"); +defineOutput(getDMMDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM", 1, "Description", "On success, a pointer to a DMM object"); +validate(getDMMDefinition); -%% C++ function |libm2k::context::getVersion| with MATLAB name |clib.libm2k.libm2k.context.getVersion| -% C++ Signature: std::string libm2k::context::getVersion() +%% C++ class method |getAvailableContextAttributes| for C++ class |libm2k::context::Context| +% C++ Signature: std::vector libm2k::context::Context::getAvailableContextAttributes() -getVersionDefinition = addFunction(libDef, ... - "std::string libm2k::context::getVersion()", ... - "MATLABName", "clib.libm2k.libm2k.context.getVersion", ... - "Description", "clib.libm2k.libm2k.context.getVersion Representation of C++ function libm2k::context::getVersion." + newline + ... - "Get library version", ... +getAvailableContextAttributesDefinition = addMethod(ContextDefinition, ... + "std::vector libm2k::context::Context::getAvailableContextAttributes()", ... + "MATLABName", "getAvailableContextAttributes", ... + "Description", "getAvailableContextAttributes Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve all the available context attributes", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getVersionDefinition, "RetVal", "string", "Description", "a string containing the libm2k version"); -validate(getVersionDefinition); +defineOutput(getAvailableContextAttributesDefinition, "RetVal", "clib.array.libm2k.std.String", "Description", "A list of strings containing all the context attributes"); +validate(getAvailableContextAttributesDefinition); -%% C++ function |libm2k::context::enableLogging| with MATLAB name |clib.libm2k.libm2k.context.enableLogging| -% C++ Signature: void libm2k::context::enableLogging(bool enable) +%% C++ class method |getContextAttributeValue| for C++ class |libm2k::context::Context| +% C++ Signature: std::string libm2k::context::Context::getContextAttributeValue(std::string attr) -enableLoggingDefinition = addFunction(libDef, ... - "void libm2k::context::enableLogging(bool enable)", ... - "MATLABName", "clib.libm2k.libm2k.context.enableLogging", ... - "Description", "clib.libm2k.libm2k.context.enableLogging Representation of C++ function libm2k::context::enableLogging." + newline + ... - "Enable/disable the logging system", ... +getContextAttributeValueDefinition = addMethod(ContextDefinition, ... + "std::string libm2k::context::Context::getContextAttributeValue(std::string attr)", ... + "MATLABName", "getContextAttributeValue", ... + "Description", "getContextAttributeValue Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve the value of one context attribute", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableLoggingDefinition, "enable", "logical", "Description", "enable If true enable, otherwise disable"); -validate(enableLoggingDefinition); +defineArgument(getContextAttributeValueDefinition, "attr", "string", "Description", "attr The name of the required attribute"); +defineOutput(getContextAttributeValueDefinition, "RetVal", "string", "Description", "On success, return a string containing the value of the attribute" + newline + ... + " @throw On error, throw an exception if the attribute is not found"); +validate(getContextAttributeValueDefinition); -%% C++ enumeration |libm2k::digital::DIO_TRIGGER_MODE| with MATLAB name |clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE| -addEnumeration(libDef, "libm2k::digital::DIO_TRIGGER_MODE", "int32",... - [... - "DIO_OR",... % 0 - "DIO_AND",... % 1 - ],... - "MATLABName", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE", ... - "Description", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE Representation of C++ enumeration libm2k::digital::DIO_TRIGGER_MODE." + newline + ... - "Triggering mode for digital channels", ... +%% C++ class method |getContextDescription| for C++ class |libm2k::context::Context| +% C++ Signature: std::string libm2k::context::Context::getContextDescription() + +getContextDescriptionDefinition = addMethod(ContextDefinition, ... + "std::string libm2k::context::Context::getContextDescription()", ... + "MATLABName", "getContextDescription", ... + "Description", "getContextDescription Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve a detailed context description", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getContextDescriptionDefinition, "RetVal", "string", "Description", "string containing the current context description"); +validate(getContextDescriptionDefinition); -%% C++ enumeration |libm2k::digital::DIO_DIRECTION| with MATLAB name |clib.libm2k.libm2k.digital.DIO_DIRECTION| -addEnumeration(libDef, "libm2k::digital::DIO_DIRECTION", "int32",... - [... - "DIO_INPUT",... % 0 - "DIO_OUTPUT",... % 1 - ],... - "MATLABName", "clib.libm2k.libm2k.digital.DIO_DIRECTION", ... - "Description", "clib.libm2k.libm2k.digital.DIO_DIRECTION Representation of C++ enumeration libm2k::digital::DIO_DIRECTION." + newline + ... - "Direction of a digital channel", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@note Digital channels can be used both for transmitting and receiving digital signals"); % Modify help description values as needed. +%% C++ class method |getSerialNumber| for C++ class |libm2k::context::Context| +% C++ Signature: std::string libm2k::context::Context::getSerialNumber() -%% C++ enumeration |libm2k::digital::DIO_CHANNEL| with MATLAB name |clib.libm2k.libm2k.digital.DIO_CHANNEL| -addEnumeration(libDef, "libm2k::digital::DIO_CHANNEL", "int32",... - [... - "DIO_CHANNEL_0",... % 0 - "DIO_CHANNEL_1",... % 1 - "DIO_CHANNEL_2",... % 2 - "DIO_CHANNEL_3",... % 3 - "DIO_CHANNEL_4",... % 4 - "DIO_CHANNEL_5",... % 5 - "DIO_CHANNEL_6",... % 6 - "DIO_CHANNEL_7",... % 7 - "DIO_CHANNEL_8",... % 8 - "DIO_CHANNEL_9",... % 9 - "DIO_CHANNEL_10",... % 10 - "DIO_CHANNEL_11",... % 11 - "DIO_CHANNEL_12",... % 12 - "DIO_CHANNEL_13",... % 13 - "DIO_CHANNEL_14",... % 14 - "DIO_CHANNEL_15",... % 15 - ],... - "MATLABName", "clib.libm2k.libm2k.digital.DIO_CHANNEL", ... - "Description", "clib.libm2k.libm2k.digital.DIO_CHANNEL Representation of C++ enumeration libm2k::digital::DIO_CHANNEL." + newline + ... - "Indexes of the channels", ... +getSerialNumberDefinition = addMethod(ContextDefinition, ... + "std::string libm2k::context::Context::getSerialNumber()", ... + "MATLABName", "getSerialNumber", ... + "Description", "getSerialNumber Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve the current context serial number", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getSerialNumberDefinition, "RetVal", "string", "Description", "string containing the current context serial number"); +validate(getSerialNumberDefinition); + +%% C++ class method |logAllAttributes| for C++ class |libm2k::context::Context| +% C++ Signature: void libm2k::context::Context::logAllAttributes() const + +logAllAttributesDefinition = addMethod(ContextDefinition, ... + "void libm2k::context::Context::logAllAttributes() const", ... + "MATLABName", "logAllAttributes", ... + "Description", "logAllAttributes Method of C++ class libm2k::context::Context." + newline + ... + "Log all the attributes" + newline + ... + " @note The logging system should be enabled", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@note Each channel can be accessed through its index"); % Modify help description values as needed. + "@brief Log all the attributes" + newline + ... + " @note The logging system should be enabled"); % Modify help description values as needed. +validate(logAllAttributesDefinition); -%% C++ enumeration |libm2k::digital::DIO_LEVEL| with MATLAB name |clib.libm2k.libm2k.digital.DIO_LEVEL| -addEnumeration(libDef, "libm2k::digital::DIO_LEVEL", "int32",... - [... - "LOW",... % 0 - "HIGH",... % 1 - ],... - "MATLABName", "clib.libm2k.libm2k.digital.DIO_LEVEL", ... - "Description", "clib.libm2k.libm2k.digital.DIO_LEVEL Representation of C++ enumeration libm2k::digital::DIO_LEVEL." + newline + ... - "Logic voltage levels", ... +%% C++ class method |toM2k| for C++ class |libm2k::context::Context| +% C++ Signature: libm2k::context::M2k * libm2k::context::Context::toM2k() + +%toM2kDefinition = addMethod(ContextDefinition, ... +% "libm2k::context::M2k * libm2k::context::Context::toM2k()", ... +% "MATLABName", "toM2k", ... +% "Description", "toM2k Method of C++ class libm2k::context::Context." + newline + ... +% "Convert the current context to M2k context, if possible", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineOutput(toM2kDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", , "Description", "On success, return the corresponding M2k object"); +%validate(toM2kDefinition); + +%% C++ class method |toGeneric| for C++ class |libm2k::context::Context| +% C++ Signature: libm2k::context::Generic * libm2k::context::Context::toGeneric() + +%toGenericDefinition = addMethod(ContextDefinition, ... +% "libm2k::context::Generic * libm2k::context::Context::toGeneric()", ... +% "MATLABName", "toGeneric", ... +% "Description", "toGeneric Method of C++ class libm2k::context::Context." + newline + ... +% "Convert the current context to Generic context, if possible", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineOutput(toGenericDefinition, "RetVal", "clib.libm2k.libm2k.context.Generic", , "Description", "On success, return the corresponding Generic object"); +%validate(toGenericDefinition); + +%% C++ class method |getDmmCount| for C++ class |libm2k::context::Context| +% C++ Signature: unsigned int libm2k::context::Context::getDmmCount() + +getDmmCountDefinition = addMethod(ContextDefinition, ... + "unsigned int libm2k::context::Context::getDmmCount()", ... + "MATLABName", "getDmmCount", ... + "Description", "getDmmCount Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve the number of DMM objects", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getDmmCountDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of DMM objects in the context"); +validate(getDmmCountDefinition); + +%% C++ class method |getFirmwareVersion| for C++ class |libm2k::context::Context| +% C++ Signature: std::string libm2k::context::Context::getFirmwareVersion() + +getFirmwareVersionDefinition = addMethod(ContextDefinition, ... + "std::string libm2k::context::Context::getFirmwareVersion()", ... + "MATLABName", "getFirmwareVersion", ... + "Description", "getFirmwareVersion Method of C++ class libm2k::context::Context." + newline + ... + "Retrieve the firmware version of the current context", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getFirmwareVersionDefinition, "RetVal", "string", "Description", "a string containing the firmware version"); +validate(getFirmwareVersionDefinition); + +%% C++ class method |getIioContextVersion| for C++ class |libm2k::context::Context| +% C++ Signature: libm2k::IIO_CONTEXT_VERSION const libm2k::context::Context::getIioContextVersion() + +getIioContextVersionDefinition = addMethod(ContextDefinition, ... + "libm2k::IIO_CONTEXT_VERSION const libm2k::context::Context::getIioContextVersion()", ... + "MATLABName", "getIioContextVersion", ... + "Description", "getIioContextVersion Method of C++ class libm2k::context::Context.", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@note At any given time a digital signals can only take two possible values, namely low or high"); % Modify help description values as needed. + "Get the version of the backend in use"); % Modify help description values as needed. +defineOutput(getIioContextVersionDefinition, "RetVal", "clib.libm2k.libm2k.IIO_CONTEXT_VERSION", "Description", "IIO_CONTEXT_VERSION struct"); +validate(getIioContextVersionDefinition); -%% C++ enumeration |libm2k::digital::DIO_MODE| with MATLAB name |clib.libm2k.libm2k.digital.DIO_MODE| -addEnumeration(libDef, "libm2k::digital::DIO_MODE", "int32",... - [... - "DIO_OPENDRAIN",... % 0 - "DIO_PUSHPULL",... % 1 - ],... - "MATLABName", "clib.libm2k.libm2k.digital.DIO_MODE", ... - "Description", "clib.libm2k.libm2k.digital.DIO_MODE Representation of C++ enumeration libm2k::digital::DIO_MODE." + newline + ... - "Output mode for a digital channel", ... +%% C++ class method |getIioContext| for C++ class |libm2k::context::Context| +% C++ Signature: iio_context * libm2k::context::Context::getIioContext() + +getIioContextDefinition = addMethod(ContextDefinition, ... + "iio_context * libm2k::context::Context::getIioContext()", ... + "MATLABName", "getIioContext", ... + "Description", "getIioContext Method of C++ class libm2k::context::Context.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "Retrieve the iio context"); % Modify help description values as needed. +defineOutput(getIioContextDefinition, "RetVal", "clib.libm2k.iio_context", 1, "Description", "A pointer to the iio context"); +validate(getIioContextDefinition); + +%% C++ class method |setTimeout| for C++ class |libm2k::context::Context| +% C++ Signature: void libm2k::context::Context::setTimeout(unsigned int timeout) + +setTimeoutDefinition = addMethod(ContextDefinition, ... + "void libm2k::context::Context::setTimeout(unsigned int timeout)", ... + "MATLABName", "setTimeout", ... + "Description", "setTimeout Method of C++ class libm2k::context::Context." + newline + ... + "Set a timeout for I/O operations", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setTimeoutDefinition, "timeout", "uint32", "Description", "timeout A positive integer representing the time in milliseconds after which a timeout occurs. A value of 0 is used to specify that no timeout should occur."); +validate(setTimeoutDefinition); -%% C++ class |libm2k::digital::M2kDigital| with MATLAB name |clib.libm2k.libm2k.digital.M2kDigital| -M2kDigitalDefinition = addClass(libDef, "libm2k::digital::M2kDigital", "MATLABName", "clib.libm2k.libm2k.digital.M2kDigital", ... - "Description", "clib.libm2k.libm2k.digital.M2kDigital Representation of C++ class libm2k::digital::M2kDigital." + newline + ... - "Contains the representation of the digital segment" + newline + ... +%% C++ class |libm2k::context::M2k| with MATLAB name |clib.libm2k.libm2k.context.M2k| +M2kDefinition = addClass(libDef, "libm2k::context::M2k", "MATLABName", "clib.libm2k.libm2k.context.M2k", ... + "Description", "clib.libm2k.libm2k.context.M2k Representation of C++ class libm2k::context::M2k." + newline + ... + "Contains the representation of the M2K" + newline + ... "" + newline + ... - "@class M2kDigital" + newline + ... - "@brief Controls the digital input and output segment", ... + "@class M2k m2k.hpp libm2k/m2k.hpp" + newline + ... + "@brief Controls the ADALM2000", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@defgroup digital Digital" + newline + ... - "@brief Contains the representation of the digital segment" + newline + ... + "@defgroup m2k M2k" + newline + ... + "@brief Contains the representation of the M2K" + newline + ... "" + newline + ... - "@class M2kDigital" + newline + ... - "@brief Controls the digital input and output segment"); % Modify help description values as needed. + "@class M2k m2k.hpp libm2k/m2k.hpp" + newline + ... + "@brief Controls the ADALM2000"); % Modify help description values as needed. -%% C++ class method |reset| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::reset() +%% C++ class method |reset| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::reset() -resetDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::reset()", ... +resetDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::reset()", ... "MATLABName", "reset", ... - "Description", "reset Method of C++ class libm2k::digital::M2kDigital.", ... + "Description", "reset Method of C++ class libm2k::context::M2k." + newline + ... + "Reset the M2K device to default settings:" + newline + ... + " * - Reset calibration coefficients" + newline + ... + " * - Maximum samplerates" + newline + ... + " * - Set oversampling ratio to 1" + newline + ... + " * - Set AnalogIn range to low range" + newline + ... + " * - Set kernel buffers count to 4 (analog/digital and in/out devices)" + newline + ... + " * - Disable all TX digital channels and enable all RX digital channels" + newline + ... + " @note A calibration is needed afterwards", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@private"); % Modify help description values as needed. + "@brief Reset the M2K device to default settings:" + newline + ... + " * - Reset calibration coefficients" + newline + ... + " * - Maximum samplerates" + newline + ... + " * - Set oversampling ratio to 1" + newline + ... + " * - Set AnalogIn range to low range" + newline + ... + " * - Set kernel buffers count to 4 (analog/digital and in/out devices)" + newline + ... + " * - Disable all TX digital channels and enable all RX digital channels" + newline + ... + " @note A calibration is needed afterwards"); % Modify help description values as needed. validate(resetDefinition); -%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned short mask) +%% C++ class method |deinitialize| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::deinitialize() -setDirectionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setDirection(unsigned short mask)", ... - "MATLABName", "setDirection", ... - "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the direction for all digital channels", ... +deinitializeDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::deinitialize()", ... + "MATLABName", "deinitialize", ... + "Description", "deinitialize Method of C++ class libm2k::context::M2k.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +validate(deinitializeDefinition); + +%% C++ class method |calibrate| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::calibrate() + +calibrateDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::calibrate()", ... + "MATLABName", "calibrate", ... + "Description", "calibrate Method of C++ class libm2k::context::M2k.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineOutput(calibrateDefinition, "RetVal", "logical"); +validate(calibrateDefinition); + +%% C++ class method |calibrateADC| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::calibrateADC() + +calibrateADCDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::calibrateADC()", ... + "MATLABName", "calibrateADC", ... + "Description", "calibrateADC Method of C++ class libm2k::context::M2k." + newline + ... + "Calibrate the ADC", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDirectionDefinition, "mask", "uint16", "Description", "mask A bitmask" + newline + ... - " @note Each bit of the mask corresponds to the channel with the same index. The value of the bit represents the channel's direction. O - input, 1 - output"); -validate(setDirectionDefinition); +defineOutput(calibrateADCDefinition, "RetVal", "logical", "Description", "On succces, true"); +validate(calibrateADCDefinition); -%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned int index,libm2k::digital::DIO_DIRECTION dir) +%% C++ class method |calibrateDAC| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::calibrateDAC() -setDirectionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setDirection(unsigned int index,libm2k::digital::DIO_DIRECTION dir)", ... - "MATLABName", "setDirection", ... - "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the direction of the given digital channel", ... +calibrateDACDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::calibrateDAC()", ... + "MATLABName", "calibrateDAC", ... + "Description", "calibrateDAC Method of C++ class libm2k::context::M2k." + newline + ... + "Calibrate the DAC", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDirectionDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); -defineArgument(setDirectionDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator that indicates the direction of a channel"); -validate(setDirectionDefinition); +defineOutput(calibrateDACDefinition, "RetVal", "logical", "Description", "On succces, true"); +validate(calibrateDACDefinition); -%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned int index,bool dir) +%% C++ class method |resetCalibration| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::resetCalibration() -setDirectionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setDirection(unsigned int index,bool dir)", ... - "MATLABName", "setDirection", ... - "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the direction of the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDirectionDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); -defineArgument(setDirectionDefinition, "dir", "logical", "Description", "dir A boolean value that corresponds to one direction" + newline + ... - " @note The boolean value for input direction is false and for output direction is true"); -validate(setDirectionDefinition); +resetCalibrationDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::resetCalibration()", ... + "MATLABName", "resetCalibration", ... + "Description", "resetCalibration Method of C++ class libm2k::context::M2k.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineOutput(resetCalibrationDefinition, "RetVal", "logical"); +validate(resetCalibrationDefinition); -%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,bool dir) +%% C++ class method |calibrateFromContext| for C++ class |libm2k::context::M2k| +% C++ Signature: double libm2k::context::M2k::calibrateFromContext() -setDirectionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,bool dir)", ... - "MATLABName", "setDirection", ... - "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the direction of the given digital channel", ... +calibrateFromContextDefinition = addMethod(M2kDefinition, ... + "double libm2k::context::M2k::calibrateFromContext()", ... + "MATLABName", "calibrateFromContext", ... + "Description", "calibrateFromContext Method of C++ class libm2k::context::M2k." + newline + ... + "Calibrate both ADC and DACs using predefined calibration values located in context", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); -defineArgument(setDirectionDefinition, "dir", "logical", "Description", "dir A boolean value that corresponds to one direction" + newline + ... - " @note The boolean value for input direction is false and for output direction is true"); -validate(setDirectionDefinition); +defineOutput(calibrateFromContextDefinition, "RetVal", "double", "Description", "The closest temperature found in the lookup table"); +validate(calibrateFromContextDefinition); -%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_DIRECTION dir) +%% C++ class method |getDigital| for C++ class |libm2k::context::M2k| +% C++ Signature: libm2k::digital::M2kDigital * libm2k::context::M2k::getDigital() -setDirectionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_DIRECTION dir)", ... - "MATLABName", "setDirection", ... - "Description", "setDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the direction of the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); -defineArgument(setDirectionDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator that indicates the direction of a channel"); -validate(setDirectionDefinition); +getDigitalDefinition = addMethod(M2kDefinition, ... + "libm2k::digital::M2kDigital * libm2k::context::M2k::getDigital()", ... + "MATLABName", "getDigital", ... + "Description", "getDigital Method of C++ class libm2k::context::M2k." + newline + ... + "Retrieve the Digital object", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getDigitalDefinition, "RetVal", "clib.libm2k.libm2k.digital.M2kDigital", 1, "Description", "On success, a pointer to a Digital object" + newline + ... + " @throw EXC_INVALID_PARAMETER No M2K digital device found"); +validate(getDigitalDefinition); -%% C++ class method |getDirection| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: libm2k::digital::DIO_DIRECTION libm2k::digital::M2kDigital::getDirection(libm2k::digital::DIO_CHANNEL index) +%% C++ class method |getPowerSupply| for C++ class |libm2k::context::M2k| +% C++ Signature: libm2k::analog::M2kPowerSupply * libm2k::context::M2k::getPowerSupply() -getDirectionDefinition = addMethod(M2kDigitalDefinition, ... - "libm2k::digital::DIO_DIRECTION libm2k::digital::M2kDigital::getDirection(libm2k::digital::DIO_CHANNEL index)", ... - "MATLABName", "getDirection", ... - "Description", "getDirection Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the direction of the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); -defineOutput(getDirectionDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "DIO_DIRECTION An enumerator that indicates the direction of a channel"); -validate(getDirectionDefinition); +getPowerSupplyDefinition = addMethod(M2kDefinition, ... + "libm2k::analog::M2kPowerSupply * libm2k::context::M2k::getPowerSupply()", ... + "MATLABName", "getPowerSupply", ... + "Description", "getPowerSupply Method of C++ class libm2k::context::M2k." + newline + ... + "Retrieve the PowerSupply object", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getPowerSupplyDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kPowerSupply", 1, "Description", "On success, a pointer to a PowerSupply object" + newline + ... + " @throw EXC_INVALID_PARAMETER No M2K power supply"); +validate(getPowerSupplyDefinition); -%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_LEVEL level) +%% C++ class method |getAnalogIn| for C++ class |libm2k::context::M2k| +% C++ Signature: libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn() -setValueRawDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_LEVEL level)", ... - "MATLABName", "setValueRaw", ... - "Description", "setValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the raw value of a given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); -defineArgument(setValueRawDefinition, "level", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "level An enumerator corresponding to the raw value"); -validate(setValueRawDefinition); +getAnalogInDefinition = addMethod(M2kDefinition, ... + "libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn()", ... + "MATLABName", "getAnalogIn", ... + "Description", "getAnalogIn Method of C++ class libm2k::context::M2k." + newline + ... + "Retrieve the AnalogIn object", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getAnalogInDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogIn", 1, "Description", "On success, a pointer to an AnalogIn object"); +validate(getAnalogInDefinition); -%% C++ class method |push| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::push(std::vector> const & data) +%% C++ class method |getAnalogIn| for C++ class |libm2k::context::M2k| +% C++ Signature: libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn(std::string dev_name) -pushDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::push(std::vector> const & data)", ... - "MATLABName", "push", ... - "Description", "push Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Send the samples to all digital channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(pushDefinition, "data", "clib.array.libm2k.UnsignedShort", "Description", "data The std vector that contains the samples" + newline + ... - " @note Due to a hardware limitation, the number of samples must" + newline + ... - " be a multiple of 4 and greater than 16."); -validate(pushDefinition); +getAnalogInDefinition = addMethod(M2kDefinition, ... + "libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn(std::string dev_name)", ... + "MATLABName", "getAnalogIn", ... + "Description", "getAnalogIn Method of C++ class libm2k::context::M2k." + newline + ... + "Retrieve the AnalogIn object of a device", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getAnalogInDefinition, "dev_name", "string", "Description", "dev_name The name corresponding to a device"); +defineOutput(getAnalogInDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogIn", 1, "Description", "On success, a pointer to an AnalogIn object"); +validate(getAnalogInDefinition); -%% C++ class method |push| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::push(unsigned short * data,unsigned int nb_samples) +%% C++ class method |getAnalogOut| for C++ class |libm2k::context::M2k| +% C++ Signature: libm2k::analog::M2kAnalogOut * libm2k::context::M2k::getAnalogOut() -%pushDefinition = addMethod(M2kDigitalDefinition, ... -% "void libm2k::digital::M2kDigital::push(unsigned short * data,unsigned int nb_samples)", ... -% "MATLABName", "push", ... -% "Description", "push Method of C++ class libm2k::digital::M2kDigital." + newline + ... -% "Send the samples to all digital channels", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineArgument(pushDefinition, "data", "clib.array.libm2k.UnsignedShort", "input", , "Description", "data a pointer to the samples"); % can be "clib.array.libm2k.UnsignedShort", or "uint16" -%defineArgument(pushDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples" + newline + ... -% " @note Due to a hardware limitation, the number of samples must" + newline + ... -% " be a multiple of 4 and greater than 16."); -%validate(pushDefinition); +getAnalogOutDefinition = addMethod(M2kDefinition, ... + "libm2k::analog::M2kAnalogOut * libm2k::context::M2k::getAnalogOut()", ... + "MATLABName", "getAnalogOut", ... + "Description", "getAnalogOut Method of C++ class libm2k::context::M2k." + newline + ... + "Retrieve the AnalogOut object", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getAnalogOutDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogOut", 1, "Description", "On success, a pointer to an AnalogOut object"); +validate(getAnalogOutDefinition); -%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(unsigned int index,libm2k::digital::DIO_LEVEL level) +%% C++ class method |hasMixedSignal| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::hasMixedSignal() -setValueRawDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setValueRaw(unsigned int index,libm2k::digital::DIO_LEVEL level)", ... - "MATLABName", "setValueRaw", ... - "Description", "setValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the raw value of a given digital channel", ... +hasMixedSignalDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::hasMixedSignal()", ... + "MATLABName", "hasMixedSignal", ... + "Description", "hasMixedSignal Method of C++ class libm2k::context::M2k." + newline + ... + "Check if the mixed signal acquisition is available on the current firmware version", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setValueRawDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); -defineArgument(setValueRawDefinition, "level", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "level An enumerator corresponding to the raw value"); -validate(setValueRawDefinition); +defineOutput(hasMixedSignalDefinition, "RetVal", "logical", "Description", "True if the mixed signal acquisition is available, false otherwise"); +validate(hasMixedSignalDefinition); -%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,bool level) +%% C++ class method |startMixedSignalAcquisition| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::startMixedSignalAcquisition(unsigned int nb_samples) -setValueRawDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,bool level)", ... - "MATLABName", "setValueRaw", ... - "Description", "setValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the raw value of a given digital channel", ... +startMixedSignalAcquisitionDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::startMixedSignalAcquisition(unsigned int nb_samples)", ... + "MATLABName", "startMixedSignalAcquisition", ... + "Description", "startMixedSignalAcquisition Method of C++ class libm2k::context::M2k." + newline + ... + "Initiate the mixed acquisition", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); -defineArgument(setValueRawDefinition, "level", "logical", "Description", "level A boolean value corresponding to the raw value"); -validate(setValueRawDefinition); +defineArgument(startMixedSignalAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); +validate(startMixedSignalAcquisitionDefinition); -%% C++ class method |getValueRaw| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(libm2k::digital::DIO_CHANNEL index) +%% C++ class method |stopMixedSignalAcquisition| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::stopMixedSignalAcquisition() -getValueRawDefinition = addMethod(M2kDigitalDefinition, ... - "libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(libm2k::digital::DIO_CHANNEL index)", ... - "MATLABName", "getValueRaw", ... - "Description", "getValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the raw value of the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); -defineOutput(getValueRawDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "DIO_LEVEL An enumerator corresponding to the raw value"); -validate(getValueRawDefinition); +stopMixedSignalAcquisitionDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::stopMixedSignalAcquisition()", ... + "MATLABName", "stopMixedSignalAcquisition", ... + "Description", "stopMixedSignalAcquisition Method of C++ class libm2k::context::M2k." + newline + ... + "Stop the mixed acquisition", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@note Only available from firmware v0.26."); % Modify help description values as needed. +validate(stopMixedSignalAcquisitionDefinition); -%% C++ class method |getValueRaw| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(unsigned int index) +%% C++ class method |getDacCalibrationOffset| for C++ class |libm2k::context::M2k| +% C++ Signature: int libm2k::context::M2k::getDacCalibrationOffset(unsigned int chn) -getValueRawDefinition = addMethod(M2kDigitalDefinition, ... - "libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(unsigned int index)", ... - "MATLABName", "getValueRaw", ... - "Description", "getValueRaw Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the raw value of the given digital channel", ... +getDacCalibrationOffsetDefinition = addMethod(M2kDefinition, ... + "int libm2k::context::M2k::getDacCalibrationOffset(unsigned int chn)", ... + "MATLABName", "getDacCalibrationOffset", ... + "Description", "getDacCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... + "Get the calibration offset of the DAC", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getValueRawDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); -defineOutput(getValueRawDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "DIO_LEVEL An enumerator corresponding to the raw value"); -validate(getValueRawDefinition); +defineArgument(getDacCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineOutput(getDacCalibrationOffsetDefinition, "RetVal", "int32", "Description", "The value of the calibration offset"); +validate(getDacCalibrationOffsetDefinition); -%% C++ class method |stopBufferOut| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::stopBufferOut() +%% C++ class method |getDacCalibrationGain| for C++ class |libm2k::context::M2k| +% C++ Signature: double libm2k::context::M2k::getDacCalibrationGain(unsigned int chn) -stopBufferOutDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::stopBufferOut()", ... - "MATLABName", "stopBufferOut", ... - "Description", "stopBufferOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Stop all digital channels from sending the signals", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@brief Stop all digital channels from sending the signals"); % Modify help description values as needed. -validate(stopBufferOutDefinition); +getDacCalibrationGainDefinition = addMethod(M2kDefinition, ... + "double libm2k::context::M2k::getDacCalibrationGain(unsigned int chn)", ... + "MATLABName", "getDacCalibrationGain", ... + "Description", "getDacCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... + "Get the calibration gain of the DAC", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getDacCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineOutput(getDacCalibrationGainDefinition, "RetVal", "double", "Description", "The value of the calibration gain"); +validate(getDacCalibrationGainDefinition); -%% C++ class method |startAcquisition| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::startAcquisition(unsigned int nb_samples) +%% C++ class method |getAdcCalibrationOffset| for C++ class |libm2k::context::M2k| +% C++ Signature: int libm2k::context::M2k::getAdcCalibrationOffset(unsigned int chn) -startAcquisitionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::startAcquisition(unsigned int nb_samples)", ... - "MATLABName", "startAcquisition", ... - "Description", "startAcquisition Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Create the buffer for all channels and start the acquisition", ... +getAdcCalibrationOffsetDefinition = addMethod(M2kDefinition, ... + "int libm2k::context::M2k::getAdcCalibrationOffset(unsigned int chn)", ... + "MATLABName", "getAdcCalibrationOffset", ... + "Description", "getAdcCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... + "Get the calibration offset of the ADC", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(startAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples size of the buffer in samples"); -validate(startAcquisitionDefinition); +defineArgument(getAdcCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineOutput(getAdcCalibrationOffsetDefinition, "RetVal", "int32", "Description", "The value of the calibration offset"); +validate(getAdcCalibrationOffsetDefinition); -%% C++ class method |stopAcquisition| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::stopAcquisition() +%% C++ class method |getAdcCalibrationGain| for C++ class |libm2k::context::M2k| +% C++ Signature: double libm2k::context::M2k::getAdcCalibrationGain(unsigned int chn) -stopAcquisitionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::stopAcquisition()", ... - "MATLABName", "stopAcquisition", ... - "Description", "stopAcquisition Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Destroy the buffer and stop the acquisition", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@brief Destroy the buffer and stop the acquisition"); % Modify help description values as needed. -validate(stopAcquisitionDefinition); +getAdcCalibrationGainDefinition = addMethod(M2kDefinition, ... + "double libm2k::context::M2k::getAdcCalibrationGain(unsigned int chn)", ... + "MATLABName", "getAdcCalibrationGain", ... + "Description", "getAdcCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... + "Get the calibration gain of the ADC", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(getAdcCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineOutput(getAdcCalibrationGainDefinition, "RetVal", "double", "Description", "The value of the calibration gain"); +validate(getAdcCalibrationGainDefinition); -%% C++ class method |cancelAcquisition| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::cancelAcquisition() +%% C++ class method |setDacCalibrationOffset| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::setDacCalibrationOffset(unsigned int chn,int offset) -cancelAcquisitionDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::cancelAcquisition()", ... - "MATLABName", "cancelAcquisition", ... - "Description", "cancelAcquisition Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Cancel all rx-buffer operations" + newline + ... - " @note Should be used to cancel an ongoing acquisition", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@brief Cancel all rx-buffer operations" + newline + ... - " @note Should be used to cancel an ongoing acquisition"); % Modify help description values as needed. -validate(cancelAcquisitionDefinition); +setDacCalibrationOffsetDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::setDacCalibrationOffset(unsigned int chn,int offset)", ... + "MATLABName", "setDacCalibrationOffset", ... + "Description", "setDacCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... + "Set the calibration offset of the DAC", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setDacCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineArgument(setDacCalibrationOffsetDefinition, "offset", "int32", "Description", "offset The calibration offset value" + newline + ... + " @note Overrides the calibration coefficients.\n" + newline + ... + " Can be reset by running a calibration."); +validate(setDacCalibrationOffsetDefinition); -%% C++ class method |cancelBufferOut| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::cancelBufferOut() +%% C++ class method |setDacCalibrationGain| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::setDacCalibrationGain(unsigned int chn,double gain) -cancelBufferOutDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::cancelBufferOut()", ... - "MATLABName", "cancelBufferOut", ... - "Description", "cancelBufferOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Cancel all tx-buffer operations" + newline + ... - " @note Should be used to cancel an ongoing data write.", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@brief Cancel all tx-buffer operations" + newline + ... - " @note Should be used to cancel an ongoing data write."); % Modify help description values as needed. -validate(cancelBufferOutDefinition); +setDacCalibrationGainDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::setDacCalibrationGain(unsigned int chn,double gain)", ... + "MATLABName", "setDacCalibrationGain", ... + "Description", "setDacCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... + "Set the calibration gain of the DAC", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setDacCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineArgument(setDacCalibrationGainDefinition, "gain", "double", "Description", "gain The calibration gain value" + newline + ... + " @note Overrides the calibration coefficients.\n" + newline + ... + " Can be reset by running a calibration.\n" + newline + ... + " The gain value is currently limited at the (-2,2) range by the hardware."); +validate(setDacCalibrationGainDefinition); -%% C++ class method |getSamples| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: std::vector> libm2k::digital::M2kDigital::getSamples(unsigned int nb_samples) +%% C++ class method |setAdcCalibrationOffset| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::setAdcCalibrationOffset(unsigned int chn,int offset) -getSamplesDefinition = addMethod(M2kDigitalDefinition, ... - "std::vector> libm2k::digital::M2kDigital::getSamples(unsigned int nb_samples)", ... - "MATLABName", "getSamples", ... - "Description", "getSamples Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve a specific number of samples", ... +setAdcCalibrationOffsetDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::setAdcCalibrationOffset(unsigned int chn,int offset)", ... + "MATLABName", "setAdcCalibrationOffset", ... + "Description", "setAdcCalibrationOffset Method of C++ class libm2k::context::M2k." + newline + ... + "Set the calibration offset of the ADC", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getSamplesDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); -defineOutput(getSamplesDefinition, "RetVal", "clib.array.libm2k.UnsignedShort", "Description", "A list that contains the samples" + newline + ... - " @note Due to a hardware limitation, the number of samples must" + newline + ... - " be a multiple of 4 and greater than 16."); -validate(getSamplesDefinition); +defineArgument(setAdcCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineArgument(setAdcCalibrationOffsetDefinition, "offset", "int32", "Description", "offset The calibration offset value" + newline + ... + " @note Overrides the calibration coefficients.\n" + newline + ... + " Can be reset by running a calibration."); +validate(setAdcCalibrationOffsetDefinition); -%% C++ class method |getSamplesP| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: unsigned short const * libm2k::digital::M2kDigital::getSamplesP(unsigned int nb_samples) +%% C++ class method |setAdcCalibrationGain| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::setAdcCalibrationGain(unsigned int chn,double gain) -%getSamplesPDefinition = addMethod(M2kDigitalDefinition, ... -% "unsigned short const * libm2k::digital::M2kDigital::getSamplesP(unsigned int nb_samples)", ... -% "MATLABName", "getSamplesP", ... -% "Description", "getSamplesP Method of C++ class libm2k::digital::M2kDigital." + newline + ... -% "Retrieve a specific number of samples", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineArgument(getSamplesPDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved"); -%defineOutput(getSamplesPDefinition, "RetVal", "clib.array.libm2k.UnsignedShort", , "Description", "A pointer to the data" + newline + ... -% " @note Due to a hardware limitation, the number of samples must" + newline + ... -% " be a multiple of 4 and greater than 16."); % can be "clib.array.libm2k.UnsignedShort", or "uint16" -%validate(getSamplesPDefinition); +setAdcCalibrationGainDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::setAdcCalibrationGain(unsigned int chn,double gain)", ... + "MATLABName", "setAdcCalibrationGain", ... + "Description", "setAdcCalibrationGain Method of C++ class libm2k::context::M2k." + newline + ... + "Set the calibration gain of the ADC", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(setAdcCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel"); +defineArgument(setAdcCalibrationGainDefinition, "gain", "double", "Description", "gain The calibration gain value" + newline + ... + " @note Overrides the calibration coefficients.\n" + newline + ... + " Can be reset by running a calibration.\n" + newline + ... + " The gain value is currently limited at the (-2,2) range by the hardware."); +validate(setAdcCalibrationGainDefinition); -%% C++ class method |enableChannel| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::enableChannel(unsigned int index,bool enable) +%% C++ class method |hasContextCalibration| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::hasContextCalibration() -enableChannelDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::enableChannel(unsigned int index,bool enable)", ... - "MATLABName", "enableChannel", ... - "Description", "enableChannel Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Enable or disable the given digital channel", ... +hasContextCalibrationDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::hasContextCalibration()", ... + "MATLABName", "hasContextCalibration", ... + "Description", "hasContextCalibration Method of C++ class libm2k::context::M2k." + newline + ... + "Check if the calibration based on temperature can be performed", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableChannelDefinition, "index", "uint32", "Description", "index The index corresponding to the channel"); -defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); -validate(enableChannelDefinition); +defineOutput(hasContextCalibrationDefinition, "RetVal", "logical", "Description", "True if the calibration parameters are available, False otherwise"); +validate(hasContextCalibrationDefinition); -%% C++ class method |enableChannel| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::enableChannel(libm2k::digital::DIO_CHANNEL index,bool enable) +%% C++ class method |isCalibrated| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::isCalibrated() -enableChannelDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::enableChannel(libm2k::digital::DIO_CHANNEL index,bool enable)", ... - "MATLABName", "enableChannel", ... - "Description", "enableChannel Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Enable or disable the given digital channel", ... +isCalibratedDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::isCalibrated()", ... + "MATLABName", "isCalibrated", ... + "Description", "isCalibrated Method of C++ class libm2k::context::M2k." + newline + ... + "Check if the board was calibrated", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableChannelDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index"); -defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); -validate(enableChannelDefinition); +defineOutput(isCalibratedDefinition, "RetVal", "logical", "Description", "True if the board was calibrated, False otherwise"); +validate(isCalibratedDefinition); -%% C++ class method |enableAllOut| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::enableAllOut(bool enable) +%% C++ class method |setLed| for C++ class |libm2k::context::M2k| +% C++ Signature: void libm2k::context::M2k::setLed(bool on) -enableAllOutDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::enableAllOut(bool enable)", ... - "MATLABName", "enableAllOut", ... - "Description", "enableAllOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Enable or disable all output channels", ... +setLedDefinition = addMethod(M2kDefinition, ... + "void libm2k::context::M2k::setLed(bool on)", ... + "MATLABName", "setLed", ... + "Description", "setLed Method of C++ class libm2k::context::M2k." + newline + ... + "Turn on or off the board's led", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(enableAllOutDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state"); -validate(enableAllOutDefinition); +defineArgument(setLedDefinition, "on", "logical", "Description", "on A boolean value corresponding to the state of the led"); +validate(setLedDefinition); -%% C++ class method |anyChannelEnabled| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: bool libm2k::digital::M2kDigital::anyChannelEnabled(libm2k::digital::DIO_DIRECTION dir) +%% C++ class method |getLed| for C++ class |libm2k::context::M2k| +% C++ Signature: bool libm2k::context::M2k::getLed() -anyChannelEnabledDefinition = addMethod(M2kDigitalDefinition, ... - "bool libm2k::digital::M2kDigital::anyChannelEnabled(libm2k::digital::DIO_DIRECTION dir)", ... - "MATLABName", "anyChannelEnabled", ... - "Description", "anyChannelEnabled Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Check if there is at least one channel enabled", ... +getLedDefinition = addMethod(M2kDefinition, ... + "bool libm2k::context::M2k::getLed()", ... + "MATLABName", "getLed", ... + "Description", "getLed Method of C++ class libm2k::context::M2k." + newline + ... + "Retrieve the state of the led", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(anyChannelEnabledDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator corresponding to the direction of a channel"); -defineOutput(anyChannelEnabledDefinition, "RetVal", "logical", "Description", "On succces, true"); -validate(anyChannelEnabledDefinition); +defineOutput(getLedDefinition, "RetVal", "logical", "Description", "If the led is turned on, true"); +validate(getLedDefinition); + +%% C++ class |libm2k::context::Generic| with MATLAB name |clib.libm2k.libm2k.context.Generic| +GenericDefinition = addClass(libDef, "libm2k::context::Generic", "MATLABName", "clib.libm2k.libm2k.context.Generic", ... + "Description", "clib.libm2k.libm2k.context.Generic Representation of C++ class libm2k::context::Generic."); % Modify help description values as needed. + +%% C++ class |libm2k::context::ContextBuilder| with MATLAB name |clib.libm2k.libm2k.context.ContextBuilder| +ContextBuilderDefinition = addClass(libDef, "libm2k::context::ContextBuilder", "MATLABName", "clib.libm2k.libm2k.context.ContextBuilder", ... + "Description", "clib.libm2k.libm2k.context.ContextBuilder Representation of C++ class libm2k::context::ContextBuilder.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. -%% C++ class method |setOutputMode| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setOutputMode(libm2k::digital::DIO_CHANNEL chn,libm2k::digital::DIO_MODE mode) +%% C++ class constructor for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: libm2k::context::ContextBuilder::ContextBuilder() -setOutputModeDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setOutputMode(libm2k::digital::DIO_CHANNEL chn,libm2k::digital::DIO_MODE mode)", ... - "MATLABName", "setOutputMode", ... - "Description", "setOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the output mode for the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setOutputModeDefinition, "chn", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chn An enumerator corresponding to the channel's index"); -defineArgument(setOutputModeDefinition, "mode", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "mode An enumerator corresponding to the output mode"); -validate(setOutputModeDefinition); +ContextBuilderConstructor1Definition = addConstructor(ContextBuilderDefinition, ... + "libm2k::context::ContextBuilder::ContextBuilder()", ... + "Description", "clib.libm2k.libm2k.context.ContextBuilder Constructor of C++ class libm2k::context::ContextBuilder.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +validate(ContextBuilderConstructor1Definition); -%% C++ class method |setOutputMode| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setOutputMode(unsigned int chn,libm2k::digital::DIO_MODE mode) +%% C++ class method |getAllContexts| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static std::vector libm2k::context::ContextBuilder::getAllContexts() -setOutputModeDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setOutputMode(unsigned int chn,libm2k::digital::DIO_MODE mode)", ... - "MATLABName", "setOutputMode", ... - "Description", "setOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the output mode for the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setOutputModeDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineArgument(setOutputModeDefinition, "mode", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "mode An enumerator corresponding to the output mode"); -validate(setOutputModeDefinition); +getAllContextsDefinition = addMethod(ContextBuilderDefinition, ... + "static std::vector libm2k::context::ContextBuilder::getAllContexts()", ... + "MATLABName", "getAllContexts", ... + "Description", "getAllContexts Method of C++ class libm2k::context::ContextBuilder.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineOutput(getAllContextsDefinition, "RetVal", "clib.array.libm2k.std.String"); +validate(getAllContextsDefinition); -%% C++ class method |getOutputMode| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(libm2k::digital::DIO_CHANNEL chn) +%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(char const * input1) -getOutputModeDefinition = addMethod(M2kDigitalDefinition, ... - "libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(libm2k::digital::DIO_CHANNEL chn)", ... - "MATLABName", "getOutputMode", ... - "Description", "getOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the output mode for the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getOutputModeDefinition, "chn", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chn An enumerator corresponding to the channel's index"); -defineOutput(getOutputModeDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "An enumerator corresponding to the output mode"); -validate(getOutputModeDefinition); +%contextOpenDefinition = addMethod(ContextBuilderDefinition, ... +% "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(char const * input1)", ... +% "MATLABName", "contextOpen", ... +% "Description", "contextOpen Method of C++ class libm2k::context::ContextBuilder.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineArgument(contextOpenDefinition, "input1", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" +%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); +%validate(contextOpenDefinition); -%% C++ class method |getOutputMode| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(unsigned int chn) +%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(iio_context * input1,char const * input2) -getOutputModeDefinition = addMethod(M2kDigitalDefinition, ... - "libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(unsigned int chn)", ... - "MATLABName", "getOutputMode", ... - "Description", "getOutputMode Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the output mode for the given digital channel", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getOutputModeDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel"); -defineOutput(getOutputModeDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "An enumerator corresponding to the output mode"); -validate(getOutputModeDefinition); +%contextOpenDefinition = addMethod(ContextBuilderDefinition, ... +% "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(iio_context * input1,char const * input2)", ... +% "MATLABName", "contextOpen", ... +% "Description", "contextOpen Method of C++ class libm2k::context::ContextBuilder.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineArgument(contextOpenDefinition, "input1", "clib.libm2k.iio_context", "input", ); +%defineArgument(contextOpenDefinition, "input2", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" +%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); +%validate(contextOpenDefinition); -%% C++ class method |setSampleRateIn| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: double libm2k::digital::M2kDigital::setSampleRateIn(double samplerate) +%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen() -setSampleRateInDefinition = addMethod(M2kDigitalDefinition, ... - "double libm2k::digital::M2kDigital::setSampleRateIn(double samplerate)", ... - "MATLABName", "setSampleRateIn", ... - "Description", "setSampleRateIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the sample rate for all digital input channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setSampleRateInDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); -defineOutput(setSampleRateInDefinition, "RetVal", "double", "Description", "The current sample rate for all digital input channels"); -validate(setSampleRateInDefinition); +%contextOpenDefinition = addMethod(ContextBuilderDefinition, ... +% "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen()", ... +% "MATLABName", "contextOpen", ... +% "Description", "contextOpen Method of C++ class libm2k::context::ContextBuilder.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); +%validate(contextOpenDefinition); -%% C++ class method |setSampleRateOut| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: double libm2k::digital::M2kDigital::setSampleRateOut(double samplerate) +%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(char const * input1) -setSampleRateOutDefinition = addMethod(M2kDigitalDefinition, ... - "double libm2k::digital::M2kDigital::setSampleRateOut(double samplerate)", ... - "MATLABName", "setSampleRateOut", ... - "Description", "setSampleRateOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the sample rate for all digital output channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setSampleRateOutDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to"); -defineOutput(setSampleRateOutDefinition, "RetVal", "double", "Description", "The current sample rate for all digital output channels"); -validate(setSampleRateOutDefinition); +%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ... +% "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(char const * input1)", ... +% "MATLABName", "m2kOpen", ... +% "Description", "m2kOpen Method of C++ class libm2k::context::ContextBuilder.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineArgument(m2kOpenDefinition, "input1", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" +%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", ); +%validate(m2kOpenDefinition); -%% C++ class method |getSampleRateIn| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: double libm2k::digital::M2kDigital::getSampleRateIn() +%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(iio_context * input1,char const * input2) -getSampleRateInDefinition = addMethod(M2kDigitalDefinition, ... - "double libm2k::digital::M2kDigital::getSampleRateIn()", ... - "MATLABName", "getSampleRateIn", ... - "Description", "getSampleRateIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the sample rate of all digital input channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getSampleRateInDefinition, "RetVal", "double", "Description", "The value of the sample rate"); -validate(getSampleRateInDefinition); +%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ... +% "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(iio_context * input1,char const * input2)", ... +% "MATLABName", "m2kOpen", ... +% "Description", "m2kOpen Method of C++ class libm2k::context::ContextBuilder.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineArgument(m2kOpenDefinition, "input1", "clib.libm2k.iio_context", "input", ); +%defineArgument(m2kOpenDefinition, "input2", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" +%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", ); +%validate(m2kOpenDefinition); -%% C++ class method |getSampleRateOut| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: double libm2k::digital::M2kDigital::getSampleRateOut() +%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen() -getSampleRateOutDefinition = addMethod(M2kDigitalDefinition, ... - "double libm2k::digital::M2kDigital::getSampleRateOut()", ... - "MATLABName", "getSampleRateOut", ... - "Description", "getSampleRateOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the sample rate of all digital output channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getSampleRateOutDefinition, "RetVal", "double", "Description", "The value of the sample rate"); -validate(getSampleRateOutDefinition); +%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ... +% "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen()", ... +% "MATLABName", "m2kOpen", ... +% "Description", "m2kOpen Method of C++ class libm2k::context::ContextBuilder.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", ); +%validate(m2kOpenDefinition); -%% C++ class method |getCyclic| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: bool libm2k::digital::M2kDigital::getCyclic() +%% C++ class method |contextClose| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static void libm2k::context::ContextBuilder::contextClose(libm2k::context::Context * input1,bool deinit = 1) -getCyclicDefinition = addMethod(M2kDigitalDefinition, ... - "bool libm2k::digital::M2kDigital::getCyclic()", ... - "MATLABName", "getCyclic", ... - "Description", "getCyclic Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the value of the cyclic mode", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getCyclicDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the cyclic mode"); -validate(getCyclicDefinition); +%contextCloseDefinition = addMethod(ContextBuilderDefinition, ... +% "static void libm2k::context::ContextBuilder::contextClose(libm2k::context::Context * input1,bool deinit = 1)", ... +% "MATLABName", "contextClose", ... +% "Description", "contextClose Method of C++ class libm2k::context::ContextBuilder.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineArgument(contextCloseDefinition, "input1", "clib.libm2k.libm2k.context.Context", "input", ); % can be "clib.libm2k.libm2k.context.Context", or "clib.array.libm2k.libm2k.context.Context" +%defineArgument(contextCloseDefinition, "deinit", "logical"); +%validate(contextCloseDefinition); -%% C++ class method |setCyclic| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setCyclic(bool cyclic) +%% C++ class method |contextCloseAll| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static void libm2k::context::ContextBuilder::contextCloseAll() -setCyclicDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setCyclic(bool cyclic)", ... - "MATLABName", "setCyclic", ... - "Description", "setCyclic Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Enable or disable the cyclic mode for all digital channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setCyclicDefinition, "cyclic", "logical", "Description", "cyclic If true, enable cyclic mode"); -validate(setCyclicDefinition); +contextCloseAllDefinition = addMethod(ContextBuilderDefinition, ... + "static void libm2k::context::ContextBuilder::contextCloseAll()", ... + "MATLABName", "contextCloseAll", ... + "Description", "contextCloseAll Method of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed. +validate(contextCloseAllDefinition); -%% C++ class method |getTrigger| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: libm2k::M2kHardwareTrigger * libm2k::digital::M2kDigital::getTrigger() +%% C++ class method |getVersion| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static std::string libm2k::context::ContextBuilder::getVersion() -%getTriggerDefinition = addMethod(M2kDigitalDefinition, ... -% "libm2k::M2kHardwareTrigger * libm2k::digital::M2kDigital::getTrigger()", ... -% "MATLABName", "getTrigger", ... -% "Description", "getTrigger Method of C++ class libm2k::digital::M2kDigital." + newline + ... -% "Get the hardware trigger handler", ... -% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -%defineOutput(getTriggerDefinition, "RetVal", "clib.libm2k.libm2k.M2kHardwareTrigger", , "Description", "the trigger object"); -%validate(getTriggerDefinition); +getVersionDefinition = addMethod(ContextBuilderDefinition, ... + "static std::string libm2k::context::ContextBuilder::getVersion()", ... + "MATLABName", "getVersion", ... + "Description", "getVersion Method of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed. +defineOutput(getVersionDefinition, "RetVal", "string"); +validate(getVersionDefinition); -%% C++ class method |setKernelBuffersCountIn| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setKernelBuffersCountIn(unsigned int count) +%% C++ class method |enableLogging| for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: static void libm2k::context::ContextBuilder::enableLogging(bool enable) -setKernelBuffersCountInDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setKernelBuffersCountIn(unsigned int count)", ... - "MATLABName", "setKernelBuffersCountIn", ... - "Description", "setKernelBuffersCountIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the kernel buffers for input to a specific value", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setKernelBuffersCountInDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); -validate(setKernelBuffersCountInDefinition); +enableLoggingDefinition = addMethod(ContextBuilderDefinition, ... + "static void libm2k::context::ContextBuilder::enableLogging(bool enable)", ... + "MATLABName", "enableLogging", ... + "Description", "enableLogging Method of C++ class libm2k::context::ContextBuilder.", ... + "DetailedDescription", "This content is from the external library documentation." + newline + ... + "" + newline + ... + "@private"); % Modify help description values as needed. +defineArgument(enableLoggingDefinition, "enable", "logical"); +validate(enableLoggingDefinition); -%% C++ class method |setKernelBuffersCountOut| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setKernelBuffersCountOut(unsigned int count) +%% C++ class constructor for C++ class |libm2k::context::ContextBuilder| +% C++ Signature: libm2k::context::ContextBuilder::ContextBuilder(libm2k::context::ContextBuilder const & input1) -setKernelBuffersCountOutDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setKernelBuffersCountOut(unsigned int count)", ... - "MATLABName", "setKernelBuffersCountOut", ... - "Description", "setKernelBuffersCountOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the kernel buffers for output to a specific value", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setKernelBuffersCountOutDefinition, "count", "uint32", "Description", "count the number of kernel buffers"); -validate(setKernelBuffersCountOutDefinition); +ContextBuilderConstructor2Definition = addConstructor(ContextBuilderDefinition, ... + "libm2k::context::ContextBuilder::ContextBuilder(libm2k::context::ContextBuilder const & input1)", ... + "Description", "clib.libm2k.libm2k.context.ContextBuilder Constructor of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed. +defineArgument(ContextBuilderConstructor2Definition, "input1", "clib.libm2k.libm2k.context.ContextBuilder", "input"); +validate(ContextBuilderConstructor2Definition); -%% C++ class method |getIioObjects| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: libm2k::IIO_OBJECTS libm2k::digital::M2kDigital::getIioObjects() +%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen| +% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen() -getIioObjectsDefinition = addMethod(M2kDigitalDefinition, ... - "libm2k::IIO_OBJECTS libm2k::digital::M2kDigital::getIioObjects()", ... - "MATLABName", "getIioObjects", ... - "Description", "getIioObjects Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Get access to IIO channels, buffers, devices and context." + newline + ... - " Can be used when debugging directly with libiio.", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure."); -validate(getIioObjectsDefinition); +%contextOpenDefinition = addFunction(libDef, ... +% "libm2k::context::Context * libm2k::context::contextOpen()", ... +% "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ... +% "Description", "clib.libm2k.libm2k.context.contextOpen Representation of C++ function libm2k::context::contextOpen.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); +%validate(contextOpenDefinition); -%% C++ class method |getNbChannelsIn| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: unsigned int libm2k::digital::M2kDigital::getNbChannelsIn() +%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen| +% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen(char const * uri) -getNbChannelsInDefinition = addMethod(M2kDigitalDefinition, ... - "unsigned int libm2k::digital::M2kDigital::getNbChannelsIn()", ... - "MATLABName", "getNbChannelsIn", ... - "Description", "getNbChannelsIn Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the number of digital input channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getNbChannelsInDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of digital IN channels"); -validate(getNbChannelsInDefinition); +%contextOpenDefinition = addFunction(libDef, ... +% "libm2k::context::Context * libm2k::context::contextOpen(char const * uri)", ... +% "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ... +% "Description", "clib.libm2k.libm2k.context.contextOpen Representation of C++ function libm2k::context::contextOpen.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineArgument(contextOpenDefinition, "uri", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" +%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); +%validate(contextOpenDefinition); -%% C++ class method |getNbChannelsOut| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: unsigned int libm2k::digital::M2kDigital::getNbChannelsOut() +%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen| +% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen(iio_context * ctx,char const * uri) -getNbChannelsOutDefinition = addMethod(M2kDigitalDefinition, ... - "unsigned int libm2k::digital::M2kDigital::getNbChannelsOut()", ... - "MATLABName", "getNbChannelsOut", ... - "Description", "getNbChannelsOut Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve the number of digital output channels", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(getNbChannelsOutDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of digital OUT channels"); -validate(getNbChannelsOutDefinition); +%contextOpenDefinition = addFunction(libDef, ... +% "libm2k::context::Context * libm2k::context::contextOpen(iio_context * ctx,char const * uri)", ... +% "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ... +% "Description", "clib.libm2k.libm2k.context.contextOpen Representation of C++ function libm2k::context::contextOpen.", ... +% "DetailedDescription", "This content is from the external library documentation." + newline + ... +% "" + newline + ... +% "@private"); % Modify help description values as needed. +%defineArgument(contextOpenDefinition, "ctx", "clib.libm2k.iio_context", "input", ); +%defineArgument(contextOpenDefinition, "uri", , "input", ); % can be "clib.array.libm2k.Char","int8","string", or "char" +%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", ); +%validate(contextOpenDefinition); -%% C++ class method |getSamples| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::getSamples(std::vector> & data,unsigned int nb_samples) +%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen| +% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen(char const * uri) -getSamplesDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::getSamples(std::vector> & data,unsigned int nb_samples)", ... - "MATLABName", "getSamples", ... - "Description", "getSamples Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Retrieve a specific number of samples", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(getSamplesDefinition, "data", "clib.array.libm2k.UnsignedShort", "Description", "data - a reference to a vector owned/created by the client"); -defineArgument(getSamplesDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved. The vector will be cleaned and then filled with samples." + newline + ... - " @note Due to a hardware limitation, the number of samples must" + newline + ... - " be a multiple of 4 and greater than 16."); -validate(getSamplesDefinition); +m2kOpenDefinition = addFunction(libDef, ... + "libm2k::context::M2k * libm2k::context::m2kOpen(char const * uri)", ... + "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ... + "Description", "clib.libm2k.libm2k.context.m2kOpen Representation of C++ function libm2k::context::m2kOpen." + newline + ... + "Open an ADALM2000 based on a given uri", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(m2kOpenDefinition, "uri", "string", "input", "nullTerminated", "Description", "uri Describe the location of the context"); % can be "clib.array.libm2k.Char","int8","string", or "char" +defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", 1, "Description", "M2k object or nullptr if no ADALM2000 was found/available"); +validate(m2kOpenDefinition); -%% C++ class method |setRateMux| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setRateMux() +%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen| +% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen(iio_context * ctx,char const * uri) -setRateMuxDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setRateMux()", ... - "MATLABName", "setRateMux", ... - "Description", "setRateMux Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Force the digital interface to use the analogical rate", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@note Only available from firmware v0.26."); % Modify help description values as needed. -validate(setRateMuxDefinition); +%m2kOpenDefinition = addFunction(libDef, ... +% "libm2k::context::M2k * libm2k::context::m2kOpen(iio_context * ctx,char const * uri)", ... +% "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ... +% "Description", "clib.libm2k.libm2k.context.m2kOpen Representation of C++ function libm2k::context::m2kOpen." + newline + ... +% "Open an ADALM2000 based on an existing iio_context and uri", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineArgument(m2kOpenDefinition, "ctx", "clib.libm2k.iio_context", "input", , "Description", "ctx A pointer to an iio_context structure"); +%defineArgument(m2kOpenDefinition, "uri", , "input", , "Description", "uri Describe the location of the context"); % can be "clib.array.libm2k.Char","int8","string", or "char" +%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", , "Description", "M2k object or nullptr if no ADALM2000 was found/available"); +%validate(m2kOpenDefinition); -%% C++ class method |resetRateMux| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::resetRateMux() +%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen| +% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen() -resetRateMuxDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::resetRateMux()", ... - "MATLABName", "resetRateMux", ... - "Description", "resetRateMux Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Reset the digital rate to default", ... - "DetailedDescription", "This content is from the external library documentation." + newline + ... - "" + newline + ... - "@note Only available from firmware v0.26."); % Modify help description values as needed. -validate(resetRateMuxDefinition); +m2kOpenDefinition = addFunction(libDef, ... + "libm2k::context::M2k * libm2k::context::m2kOpen()", ... + "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ... + "Description", "clib.libm2k.libm2k.context.m2kOpen Representation of C++ function libm2k::context::m2kOpen." + newline + ... + "Open an ADALM2000", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", 1, "Description", "M2k object or nullptr if no ADALM2000 was found/available"); +validate(m2kOpenDefinition); -%% C++ class method |setExternalClocksource| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: void libm2k::digital::M2kDigital::setExternalClocksource(bool external) +%% C++ function |libm2k::context::getAllContexts| with MATLAB name |clib.libm2k.libm2k.context.getAllContexts| +% C++ Signature: std::vector libm2k::context::getAllContexts() -setExternalClocksourceDefinition = addMethod(M2kDigitalDefinition, ... - "void libm2k::digital::M2kDigital::setExternalClocksource(bool external)", ... - "MATLABName", "setExternalClocksource", ... - "Description", "setExternalClocksource Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Set the clocksource", ... +getAllContextsDefinition = addFunction(libDef, ... + "std::vector libm2k::context::getAllContexts()", ... + "MATLABName", "clib.libm2k.libm2k.context.getAllContexts", ... + "Description", "clib.libm2k.libm2k.context.getAllContexts Representation of C++ function libm2k::context::getAllContexts." + newline + ... + "List all available contexts", ... "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineArgument(setExternalClocksourceDefinition, "external", "logical", "Description", "external - True to set source to external" + newline + ... - " * - False to set source to internal"); -validate(setExternalClocksourceDefinition); +defineOutput(getAllContextsDefinition, "RetVal", "clib.array.libm2k.std.String", "Description", "A list containing the available contexts"); +validate(getAllContextsDefinition); -%% C++ class method |isClocksourceExternal| for C++ class |libm2k::digital::M2kDigital| -% C++ Signature: bool libm2k::digital::M2kDigital::isClocksourceExternal() +%% C++ function |libm2k::context::contextClose| with MATLAB name |clib.libm2k.libm2k.context.contextClose| +% C++ Signature: void libm2k::context::contextClose(libm2k::context::Context * ctx,bool deinit = 1) -isClocksourceExternalDefinition = addMethod(M2kDigitalDefinition, ... - "bool libm2k::digital::M2kDigital::isClocksourceExternal()", ... - "MATLABName", "isClocksourceExternal", ... - "Description", "isClocksourceExternal Method of C++ class libm2k::digital::M2kDigital." + newline + ... - "Get the current clocksource", ... - "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. -defineOutput(isClocksourceExternalDefinition, "RetVal", "logical", "Description", "True if clocksource is set to external"); -validate(isClocksourceExternalDefinition); +%contextCloseDefinition = addFunction(libDef, ... +% "void libm2k::context::contextClose(libm2k::context::Context * ctx,bool deinit = 1)", ... +% "MATLABName", "clib.libm2k.libm2k.context.contextClose", ... +% "Description", "clib.libm2k.libm2k.context.contextClose Representation of C++ function libm2k::context::contextClose." + newline + ... +% "Destroy the given context", ... +% "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +%defineArgument(contextCloseDefinition, "ctx", "clib.libm2k.libm2k.context.Context", "input", , "Description", "ctx The context to be destroyed"); % can be "clib.libm2k.libm2k.context.Context", or "clib.array.libm2k.libm2k.context.Context" +%defineArgument(contextCloseDefinition, "deinit", "logical", "Description", "deinit If deinit is set to false, running contexts won't be affected"); +%validate(contextCloseDefinition); -%% C++ class |libm2k::digital::channel| with MATLAB name |clib.libm2k.libm2k.digital.channel| -channelDefinition = addClass(libDef, "libm2k::digital::channel", "MATLABName", "clib.libm2k.libm2k.digital.channel", ... - "Description", "clib.libm2k.libm2k.digital.channel Representation of C++ class libm2k::digital::channel.", ... +%% C++ function |libm2k::context::contextCloseAll| with MATLAB name |clib.libm2k.libm2k.context.contextCloseAll| +% C++ Signature: void libm2k::context::contextCloseAll() + +contextCloseAllDefinition = addFunction(libDef, ... + "void libm2k::context::contextCloseAll()", ... + "MATLABName", "clib.libm2k.libm2k.context.contextCloseAll", ... + "Description", "clib.libm2k.libm2k.context.contextCloseAll Representation of C++ function libm2k::context::contextCloseAll." + newline + ... + "Close all the devices", ... "DetailedDescription", "This content is from the external library documentation." + newline + ... "" + newline + ... - "@private"); % Modify help description values as needed. - -%% C++ class constructor for C++ class |libm2k::digital::channel| -% C++ Signature: libm2k::digital::channel::channel(libm2k::digital::channel const & input1) - -channelConstructor1Definition = addConstructor(channelDefinition, ... - "libm2k::digital::channel::channel(libm2k::digital::channel const & input1)", ... - "Description", "clib.libm2k.libm2k.digital.channel Constructor of C++ class libm2k::digital::channel."); % Modify help description values as needed. -defineArgument(channelConstructor1Definition, "input1", "clib.libm2k.libm2k.digital.channel", "input"); -validate(channelConstructor1Definition); - -%% C++ class constructor for C++ class |libm2k::digital::channel| -% C++ Signature: libm2k::digital::channel::channel() - -channelConstructor2Definition = addConstructor(channelDefinition, ... - "libm2k::digital::channel::channel()", ... - "Description", "clib.libm2k.libm2k.digital.channel Constructor of C++ class libm2k::digital::channel."); % Modify help description values as needed. -validate(channelConstructor2Definition); + "@brief Close all the devices"); % Modify help description values as needed. +validate(contextCloseAllDefinition); -%% C++ class public data member |m_channel| for C++ class |libm2k::digital::channel| -% C++ Signature: iio_channel * libm2k::digital::channel::m_channel +%% C++ function |libm2k::context::getVersion| with MATLAB name |clib.libm2k.libm2k.context.getVersion| +% C++ Signature: std::string libm2k::context::getVersion() -%addProperty(channelDefinition, "m_channel", "clib.libm2k.iio_channel", , ... -% "Description", "clib.libm2k.iio_channel Data member of C++ class libm2k::digital::channel." + newline + ... -% "A pointer to an iio_channel structure"); % Modify help description values as needed. +getVersionDefinition = addFunction(libDef, ... + "std::string libm2k::context::getVersion()", ... + "MATLABName", "clib.libm2k.libm2k.context.getVersion", ... + "Description", "clib.libm2k.libm2k.context.getVersion Representation of C++ function libm2k::context::getVersion." + newline + ... + "Get library version", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineOutput(getVersionDefinition, "RetVal", "string", "Description", "a string containing the libm2k version"); +validate(getVersionDefinition); -%% C++ class public data member |m_direction| for C++ class |libm2k::digital::channel| -% C++ Signature: libm2k::digital::DIO_DIRECTION libm2k::digital::channel::m_direction +%% C++ function |libm2k::context::enableLogging| with MATLAB name |clib.libm2k.libm2k.context.enableLogging| +% C++ Signature: void libm2k::context::enableLogging(bool enable) -addProperty(channelDefinition, "m_direction", "clib.libm2k.libm2k.digital.DIO_DIRECTION", ... - "Description", "clib.libm2k.libm2k.digital.DIO_DIRECTION Data member of C++ class libm2k::digital::channel." + newline + ... - "The direction of the channel"); % Modify help description values as needed. +enableLoggingDefinition = addFunction(libDef, ... + "void libm2k::context::enableLogging(bool enable)", ... + "MATLABName", "clib.libm2k.libm2k.context.enableLogging", ... + "Description", "clib.libm2k.libm2k.context.enableLogging Representation of C++ function libm2k::context::enableLogging." + newline + ... + "Enable/disable the logging system", ... + "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed. +defineArgument(enableLoggingDefinition, "enable", "logical", "Description", "enable If true enable, otherwise disable"); +validate(enableLoggingDefinition); %% Validate the library definition validate(libDef);