2014-01-15 19:48:01 +08:00
|
|
|
/*
|
|
|
|
* This file is part of the libsigrok project.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef LIBSIGROK_SIGROK_H
|
|
|
|
#define LIBSIGROK_SIGROK_H
|
|
|
|
|
2017-06-02 14:01:49 +08:00
|
|
|
#include <sys/time.h>
|
2014-01-15 19:48:01 +08:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <inttypes.h>
|
2022-07-15 11:57:50 +08:00
|
|
|
#include <glib.h>
|
|
|
|
#include <log/xlog.h>
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @file
|
|
|
|
*
|
|
|
|
* The public libsigrok header file to be used by frontends.
|
|
|
|
*
|
|
|
|
* This is the only file that libsigrok users (frontends) are supposed to
|
|
|
|
* use and \#include. There are other header files which get installed with
|
|
|
|
* libsigrok, but those are not meant to be used directly by frontends.
|
|
|
|
*
|
|
|
|
* The correct way to get/use the libsigrok API functions is:
|
|
|
|
*
|
|
|
|
* @code{.c}
|
|
|
|
* #include <libsigrok/libsigrok.h>
|
|
|
|
* @endcode
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* All possible return codes of libsigrok functions must be listed here.
|
|
|
|
* Functions should never return hardcoded numbers as status, but rather
|
|
|
|
* use these enum values. All error codes are negative numbers.
|
|
|
|
*
|
|
|
|
* The error codes are globally unique in libsigrok, i.e. if one of the
|
|
|
|
* libsigrok functions returns a "malloc error" it must be exactly the same
|
|
|
|
* return value as used by all other functions to indicate "malloc error".
|
|
|
|
* There must be no functions which indicate two different errors via the
|
|
|
|
* same return code.
|
|
|
|
*
|
|
|
|
* Also, for compatibility reasons, no defined return codes are ever removed
|
|
|
|
* or reused for different errors later. You can only add new entries and
|
|
|
|
* return codes, but never remove or redefine existing ones.
|
|
|
|
*/
|
|
|
|
|
2022-08-08 15:59:50 +08:00
|
|
|
#define SR_LIB_NAME "libsigrok"
|
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/** Status/error codes returned by libsigrok functions. */
|
|
|
|
enum {
|
|
|
|
SR_OK = 0, /**< No error. */
|
2022-07-28 16:57:15 +08:00
|
|
|
SR_ERR = 1, /**< Generic/unspecified error. */
|
|
|
|
SR_ERR_MALLOC = 2, /**< Malloc/calloc/realloc error. */
|
|
|
|
SR_ERR_ARG = 3, /**< Function argument error. */
|
|
|
|
SR_ERR_BUG = 4, /**< Errors hinting at internal bugs. */
|
|
|
|
SR_ERR_SAMPLERATE = 5, /**< Incorrect samplerate. */
|
|
|
|
SR_ERR_NA = 6, /**< Not applicable. */
|
|
|
|
SR_ERR_DEV_CLOSED = 7, /**< Device is closed, but needs to be open. */
|
|
|
|
SR_ERR_CALL_STATUS = 8, /**< Function call status error. */
|
|
|
|
SR_ERR_HAVE_DONE = 9, /**< The Function have called.*/
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: When adding entries here, don't forget to also update the
|
2022-07-28 16:57:15 +08:00
|
|
|
* sr_error_str() and sr_error_name() functions in error.c.
|
2014-01-15 19:48:01 +08:00
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
2022-07-14 13:50:40 +08:00
|
|
|
#define SR_MAX_PROBENAME_LEN 32
|
|
|
|
#define DS_MAX_ANALOG_PROBES_NUM 4
|
|
|
|
#define DS_MAX_DSO_PROBES_NUM 2
|
|
|
|
|
|
|
|
#define TriggerStages 16
|
|
|
|
#define TriggerProbes 16
|
|
|
|
#define MaxTriggerProbes 32
|
|
|
|
#define TriggerCountBits 16
|
|
|
|
#define STriggerDataStage 3
|
|
|
|
#define DS_MAX_TRIG_PERCENT 90
|
|
|
|
|
|
|
|
#define DS_CONF_DSO_HDIVS 10
|
|
|
|
#define DS_CONF_DSO_VDIVS 10
|
|
|
|
|
|
|
|
#define SAMPLES_ALIGN 1023ULL
|
|
|
|
|
2022-10-19 18:41:13 +08:00
|
|
|
#define STR_ID(id) #id
|
2022-07-14 13:50:40 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/* Handy little macros */
|
|
|
|
#define SR_HZ(n) (n)
|
|
|
|
#define SR_KHZ(n) ((n) * (uint64_t)(1000ULL))
|
|
|
|
#define SR_MHZ(n) ((n) * (uint64_t)(1000000ULL))
|
|
|
|
#define SR_GHZ(n) ((n) * (uint64_t)(1000000000ULL))
|
|
|
|
|
|
|
|
#define SR_HZ_TO_NS(n) ((uint64_t)(1000000000ULL) / (n))
|
|
|
|
|
2018-05-21 11:53:40 +08:00
|
|
|
#define SR_NS(n) (n)
|
|
|
|
#define SR_US(n) ((n) * (uint64_t)(1000ULL))
|
|
|
|
#define SR_MS(n) ((n) * (uint64_t)(1000000ULL))
|
|
|
|
#define SR_SEC(n) ((n) * (uint64_t)(1000000000ULL))
|
|
|
|
#define SR_MIN(n) ((n) * (uint64_t)(60000000000ULL))
|
|
|
|
#define SR_HOUR(n) ((n) * (uint64_t)(3600000000000ULL))
|
|
|
|
#define SR_DAY(n) ((n) * (uint64_t)(86400000000000ULL))
|
|
|
|
|
|
|
|
#define SR_n(n) (n)
|
|
|
|
#define SR_Kn(n) ((n) * (uint64_t)(1000ULL))
|
|
|
|
#define SR_Mn(n) ((n) * (uint64_t)(1000000ULL))
|
|
|
|
#define SR_Gn(n) ((n) * (uint64_t)(1000000000ULL))
|
|
|
|
|
2014-04-14 17:46:11 +08:00
|
|
|
#define SR_B(n) (n)
|
|
|
|
#define SR_KB(n) ((n) * (uint64_t)(1024ULL))
|
|
|
|
#define SR_MB(n) ((n) * (uint64_t)(1048576ULL))
|
|
|
|
#define SR_GB(n) ((n) * (uint64_t)(1073741824ULL))
|
|
|
|
|
2018-05-10 10:41:40 +08:00
|
|
|
#define SR_mV(n) (n)
|
|
|
|
#define SR_V(n) ((n) * (uint64_t)(1000ULL))
|
|
|
|
#define SR_KV(n) ((n) * (uint64_t)(1000000ULL))
|
|
|
|
#define SR_MV(n) ((n) * (uint64_t)(1000000000ULL))
|
2022-07-14 13:50:40 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/*
|
|
|
|
* Use SR_API to mark public API symbols, and SR_PRIV for private symbols.
|
|
|
|
*
|
|
|
|
* Variables and functions marked 'static' are private already and don't
|
|
|
|
* need SR_PRIV. However, functions which are not static (because they need
|
|
|
|
* to be used in other libsigrok-internal files) but are also not meant to
|
|
|
|
* be part of the public libsigrok API, must use SR_PRIV.
|
|
|
|
*
|
|
|
|
* This uses the 'visibility' feature of gcc (requires gcc >= 4.0).
|
|
|
|
*
|
|
|
|
* This feature is not available on MinGW/Windows, as it is a feature of
|
|
|
|
* ELF files and MinGW/Windows uses PE files.
|
|
|
|
*
|
|
|
|
* Details: http://gcc.gnu.org/wiki/Visibility
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Marks public libsigrok API symbols. */
|
|
|
|
#ifndef _WIN32
|
|
|
|
#define SR_API __attribute__((visibility("default")))
|
|
|
|
#else
|
|
|
|
#define SR_API
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Marks private, non-public libsigrok symbols (not part of the API). */
|
|
|
|
#ifndef _WIN32
|
|
|
|
#define SR_PRIV __attribute__((visibility("hidden")))
|
|
|
|
#else
|
|
|
|
#define SR_PRIV
|
|
|
|
#endif
|
|
|
|
|
2022-07-28 16:57:15 +08:00
|
|
|
enum sr_device_type{
|
|
|
|
DEV_TYPE_UNKOWN = 0,
|
|
|
|
DEV_TYPE_DEMO = 1,
|
|
|
|
DEV_TYPE_FILELOG = 2,
|
2022-08-08 15:59:50 +08:00
|
|
|
DEV_TYPE_USB = 3,
|
|
|
|
DEV_TYPE_SERIAL = 4,
|
2022-07-28 16:57:15 +08:00
|
|
|
};
|
2021-10-28 18:49:52 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/** Data types used by sr_config_info(). */
|
|
|
|
enum {
|
|
|
|
SR_T_UINT64 = 10000,
|
2015-06-06 22:24:00 +08:00
|
|
|
SR_T_UINT8,
|
|
|
|
SR_T_CHAR,
|
2014-01-15 19:48:01 +08:00
|
|
|
SR_T_BOOL,
|
|
|
|
SR_T_FLOAT,
|
|
|
|
SR_T_RATIONAL_PERIOD,
|
|
|
|
SR_T_RATIONAL_VOLT,
|
|
|
|
SR_T_KEYVALUE,
|
2022-10-19 18:41:13 +08:00
|
|
|
SR_T_LIST,
|
2022-10-27 17:22:55 +08:00
|
|
|
SR_T_INT16
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Value for sr_datafeed_packet.type. */
|
2022-08-11 20:09:49 +08:00
|
|
|
enum sr_datafeed_packet_type {
|
2014-01-15 19:48:01 +08:00
|
|
|
SR_DF_HEADER = 10000,
|
|
|
|
SR_DF_END,
|
|
|
|
SR_DF_META,
|
|
|
|
SR_DF_TRIGGER,
|
|
|
|
SR_DF_LOGIC,
|
2014-04-14 17:46:11 +08:00
|
|
|
SR_DF_DSO,
|
2014-01-15 19:48:01 +08:00
|
|
|
SR_DF_ANALOG,
|
|
|
|
SR_DF_FRAME_BEGIN,
|
|
|
|
SR_DF_FRAME_END,
|
2017-05-20 03:20:06 +08:00
|
|
|
SR_DF_OVERFLOW,
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Values for sr_datafeed_analog.mq. */
|
|
|
|
enum {
|
|
|
|
SR_MQ_VOLTAGE = 10000,
|
|
|
|
SR_MQ_CURRENT,
|
|
|
|
SR_MQ_RESISTANCE,
|
|
|
|
SR_MQ_CAPACITANCE,
|
|
|
|
SR_MQ_TEMPERATURE,
|
|
|
|
SR_MQ_FREQUENCY,
|
|
|
|
SR_MQ_DUTY_CYCLE,
|
|
|
|
SR_MQ_CONTINUITY,
|
|
|
|
SR_MQ_PULSE_WIDTH,
|
|
|
|
SR_MQ_CONDUCTANCE,
|
|
|
|
/** Electrical power, usually in W, or dBm. */
|
|
|
|
SR_MQ_POWER,
|
|
|
|
/** Gain (a transistor's gain, or hFE, for example). */
|
|
|
|
SR_MQ_GAIN,
|
|
|
|
/** Logarithmic representation of sound pressure relative to a
|
|
|
|
* reference value. */
|
|
|
|
SR_MQ_SOUND_PRESSURE_LEVEL,
|
|
|
|
SR_MQ_CARBON_MONOXIDE,
|
|
|
|
SR_MQ_RELATIVE_HUMIDITY,
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Values for sr_datafeed_analog.unit. */
|
|
|
|
enum {
|
|
|
|
SR_UNIT_VOLT = 10000,
|
|
|
|
SR_UNIT_AMPERE,
|
|
|
|
SR_UNIT_OHM,
|
|
|
|
SR_UNIT_FARAD,
|
|
|
|
SR_UNIT_KELVIN,
|
|
|
|
SR_UNIT_CELSIUS,
|
|
|
|
SR_UNIT_FAHRENHEIT,
|
|
|
|
SR_UNIT_HERTZ,
|
|
|
|
SR_UNIT_PERCENTAGE,
|
|
|
|
SR_UNIT_BOOLEAN,
|
|
|
|
SR_UNIT_SECOND,
|
|
|
|
/** Unit of conductance, the inverse of resistance. */
|
|
|
|
SR_UNIT_SIEMENS,
|
|
|
|
/**
|
|
|
|
* An absolute measurement of power, in decibels, referenced to
|
|
|
|
* 1 milliwatt (dBu).
|
|
|
|
*/
|
|
|
|
SR_UNIT_DECIBEL_MW,
|
|
|
|
/** Voltage in decibel, referenced to 1 volt (dBV). */
|
|
|
|
SR_UNIT_DECIBEL_VOLT,
|
|
|
|
/**
|
|
|
|
* Measurements that intrinsically do not have units attached, such
|
|
|
|
* as ratios, gains, etc. Specifically, a transistor's gain (hFE) is
|
|
|
|
* a unitless quantity, for example.
|
|
|
|
*/
|
|
|
|
SR_UNIT_UNITLESS,
|
|
|
|
/** Sound pressure level relative so 20 micropascals. */
|
|
|
|
SR_UNIT_DECIBEL_SPL,
|
|
|
|
/**
|
|
|
|
* Normalized (0 to 1) concentration of a substance or compound with 0
|
|
|
|
* representing a concentration of 0%, and 1 being 100%. This is
|
|
|
|
* represented as the fraction of number of particles of the substance.
|
|
|
|
*/
|
|
|
|
SR_UNIT_CONCENTRATION,
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Values for sr_datafeed_analog.flags. */
|
|
|
|
enum {
|
|
|
|
/** Voltage measurement is alternating current (AC). */
|
|
|
|
SR_MQFLAG_AC = 0x01,
|
|
|
|
/** Voltage measurement is direct current (DC). */
|
|
|
|
SR_MQFLAG_DC = 0x02,
|
|
|
|
/** This is a true RMS measurement. */
|
|
|
|
SR_MQFLAG_RMS = 0x04,
|
|
|
|
/** Value is voltage drop across a diode, or NAN. */
|
|
|
|
SR_MQFLAG_DIODE = 0x08,
|
|
|
|
/** Device is in "hold" mode (repeating the last measurement). */
|
|
|
|
SR_MQFLAG_HOLD = 0x10,
|
|
|
|
/** Device is in "max" mode, only updating upon a new max value. */
|
|
|
|
SR_MQFLAG_MAX = 0x20,
|
|
|
|
/** Device is in "min" mode, only updating upon a new min value. */
|
|
|
|
SR_MQFLAG_MIN = 0x40,
|
|
|
|
/** Device is in autoranging mode. */
|
|
|
|
SR_MQFLAG_AUTORANGE = 0x80,
|
|
|
|
/** Device is in relative mode. */
|
|
|
|
SR_MQFLAG_RELATIVE = 0x100,
|
|
|
|
/** Sound pressure level is A-weighted in the frequency domain,
|
|
|
|
* according to IEC 61672:2003. */
|
|
|
|
SR_MQFLAG_SPL_FREQ_WEIGHT_A = 0x200,
|
|
|
|
/** Sound pressure level is C-weighted in the frequency domain,
|
|
|
|
* according to IEC 61672:2003. */
|
|
|
|
SR_MQFLAG_SPL_FREQ_WEIGHT_C = 0x400,
|
|
|
|
/** Sound pressure level is Z-weighted (i.e. not at all) in the
|
|
|
|
* frequency domain, according to IEC 61672:2003. */
|
|
|
|
SR_MQFLAG_SPL_FREQ_WEIGHT_Z = 0x800,
|
|
|
|
/** Sound pressure level is not weighted in the frequency domain,
|
|
|
|
* albeit without standards-defined low and high frequency limits. */
|
|
|
|
SR_MQFLAG_SPL_FREQ_WEIGHT_FLAT = 0x1000,
|
|
|
|
/** Sound pressure level measurement is S-weighted (1s) in the
|
|
|
|
* time domain. */
|
|
|
|
SR_MQFLAG_SPL_TIME_WEIGHT_S = 0x2000,
|
|
|
|
/** Sound pressure level measurement is F-weighted (125ms) in the
|
|
|
|
* time domain. */
|
|
|
|
SR_MQFLAG_SPL_TIME_WEIGHT_F = 0x4000,
|
|
|
|
/** Sound pressure level is time-averaged (LAT), also known as
|
|
|
|
* Equivalent Continuous A-weighted Sound Level (LEQ). */
|
|
|
|
SR_MQFLAG_SPL_LAT = 0x8000,
|
|
|
|
/** Sound pressure level represented as a percentage of measurements
|
|
|
|
* that were over a preset alarm level. */
|
|
|
|
SR_MQFLAG_SPL_PCT_OVER_ALARM = 0x10000,
|
|
|
|
};
|
|
|
|
|
2023-03-22 16:42:23 +08:00
|
|
|
enum DSLOGIC_OPERATION_MODE
|
|
|
|
{
|
|
|
|
/** Buffer mode */
|
|
|
|
LO_OP_BUFFER = 0,
|
|
|
|
/** Stream mode */
|
|
|
|
LO_OP_STREAM = 1,
|
|
|
|
/** Internal pattern test mode */
|
|
|
|
LO_OP_INTEST = 2,
|
|
|
|
/** External pattern test mode */
|
|
|
|
LO_OP_EXTEST = 3,
|
|
|
|
/** SDRAM loopback test mode */
|
|
|
|
LO_OP_LPTEST = 4,
|
|
|
|
};
|
|
|
|
|
2016-07-20 08:59:39 +08:00
|
|
|
enum DSO_MEASURE_TYPE {
|
|
|
|
DSO_MS_BEGIN = 0,
|
|
|
|
DSO_MS_FREQ,
|
|
|
|
DSO_MS_PERD,
|
2019-09-09 00:07:19 -07:00
|
|
|
DSO_MS_PDUT,
|
|
|
|
DSO_MS_NDUT,
|
|
|
|
DSO_MS_PCNT,
|
|
|
|
DSO_MS_RISE,
|
|
|
|
DSO_MS_FALL,
|
|
|
|
DSO_MS_PWDT,
|
|
|
|
DSO_MS_NWDT,
|
|
|
|
DSO_MS_BRST,
|
|
|
|
DSO_MS_AMPT,
|
|
|
|
DSO_MS_VHIG,
|
|
|
|
DSO_MS_VLOW,
|
2016-07-20 08:59:39 +08:00
|
|
|
DSO_MS_VRMS,
|
|
|
|
DSO_MS_VMEA,
|
|
|
|
DSO_MS_VP2P,
|
2019-09-09 00:07:19 -07:00
|
|
|
DSO_MS_VMAX,
|
|
|
|
DSO_MS_VMIN,
|
|
|
|
DSO_MS_POVR,
|
|
|
|
DSO_MS_NOVR,
|
2016-07-20 08:59:39 +08:00
|
|
|
DSO_MS_END,
|
|
|
|
};
|
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
enum {
|
|
|
|
SR_PKT_OK,
|
|
|
|
SR_PKT_SOURCE_ERROR,
|
|
|
|
SR_PKT_DATA_ERROR,
|
|
|
|
};
|
|
|
|
|
2022-02-14 14:07:00 +08:00
|
|
|
struct sr_context; //hidden all field
|
2022-08-08 15:59:50 +08:00
|
|
|
struct sr_dev_inst;
|
|
|
|
struct sr_dev_driver;
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
struct sr_datafeed_packet {
|
2022-08-11 20:09:49 +08:00
|
|
|
uint16_t type; //see enum sr_datafeed_packet_type
|
2017-05-20 03:20:06 +08:00
|
|
|
uint16_t status;
|
2014-01-15 19:48:01 +08:00
|
|
|
const void *payload;
|
2022-04-06 15:29:55 +08:00
|
|
|
int bExportOriginalData;
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct sr_datafeed_header {
|
|
|
|
int feed_version;
|
|
|
|
struct timeval starttime;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct sr_datafeed_meta {
|
|
|
|
GSList *config;
|
|
|
|
};
|
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
enum LA_DATA_FORMAT {
|
|
|
|
LA_CROSS_DATA,
|
|
|
|
LA_SPLIT_DATA,
|
|
|
|
};
|
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
struct sr_datafeed_logic {
|
|
|
|
uint64_t length;
|
2017-05-20 03:20:06 +08:00
|
|
|
/** data format */
|
|
|
|
int format;
|
|
|
|
/** for LA_SPLIT_DATA, indicate the channel index */
|
|
|
|
uint16_t index;
|
|
|
|
uint16_t order;
|
2014-01-15 19:48:01 +08:00
|
|
|
uint16_t unitsize;
|
|
|
|
uint16_t data_error;
|
2017-05-20 03:20:06 +08:00
|
|
|
uint64_t error_pattern;
|
2014-01-15 19:48:01 +08:00
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2014-04-14 17:46:11 +08:00
|
|
|
struct sr_datafeed_dso {
|
|
|
|
/** The probes for which data is included in this packet. */
|
|
|
|
GSList *probes;
|
|
|
|
int num_samples;
|
|
|
|
/** Measured quantity (voltage, current, temperature, and so on). */
|
|
|
|
int mq;
|
|
|
|
/** Unit in which the MQ is measured. */
|
|
|
|
int unit;
|
|
|
|
/** Bitmap with extra information about the MQ. */
|
|
|
|
uint64_t mqflags;
|
2015-11-11 21:22:03 +08:00
|
|
|
/** samplerate different from last packet */
|
|
|
|
gboolean samplerate_tog;
|
2016-07-20 08:59:39 +08:00
|
|
|
/** trig flag */
|
|
|
|
gboolean trig_flag;
|
2020-01-09 21:48:39 +08:00
|
|
|
/** trig channel */
|
|
|
|
uint8_t trig_ch;
|
2014-04-14 17:46:11 +08:00
|
|
|
/** The analog value(s). The data is interleaved according to
|
|
|
|
* the probes list. */
|
2015-04-24 16:12:58 +08:00
|
|
|
void *data;
|
2014-04-14 17:46:11 +08:00
|
|
|
};
|
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
struct sr_datafeed_analog {
|
|
|
|
/** The probes for which data is included in this packet. */
|
|
|
|
GSList *probes;
|
|
|
|
int num_samples;
|
2018-05-10 10:41:40 +08:00
|
|
|
/** How many bits for each sample */
|
|
|
|
uint8_t unit_bits;
|
|
|
|
/** Interval between two valid samples */
|
|
|
|
uint16_t unit_pitch;
|
2014-01-15 19:48:01 +08:00
|
|
|
/** Measured quantity (voltage, current, temperature, and so on). */
|
|
|
|
int mq;
|
|
|
|
/** Unit in which the MQ is measured. */
|
|
|
|
int unit;
|
|
|
|
/** Bitmap with extra information about the MQ. */
|
|
|
|
uint64_t mqflags;
|
|
|
|
/** The analog value(s). The data is interleaved according to
|
|
|
|
* the probes list. */
|
2018-05-16 17:04:11 +08:00
|
|
|
void *data;
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Input (file) format struct. */
|
|
|
|
struct sr_input {
|
|
|
|
/**
|
|
|
|
* A pointer to this input format's 'struct sr_input_format'.
|
|
|
|
* The frontend can use this to call the module's callbacks.
|
|
|
|
*/
|
|
|
|
struct sr_input_format *format;
|
|
|
|
|
|
|
|
GHashTable *param;
|
|
|
|
|
|
|
|
struct sr_dev_inst *sdi;
|
|
|
|
|
|
|
|
void *internal;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct sr_input_format {
|
|
|
|
/** The unique ID for this input format. Must not be NULL. */
|
|
|
|
char *id;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A short description of the input format, which can (for example)
|
|
|
|
* be displayed to the user by frontends. Must not be NULL.
|
|
|
|
*/
|
|
|
|
char *description;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if this input module can load and parse the specified file.
|
|
|
|
*
|
|
|
|
* @param filename The name (and path) of the file to check.
|
|
|
|
*
|
|
|
|
* @return TRUE if this module knows the format, FALSE if it doesn't.
|
|
|
|
*/
|
|
|
|
int (*format_match) (const char *filename);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize the input module.
|
|
|
|
*
|
|
|
|
* @param in A pointer to a valid 'struct sr_input' that the caller
|
|
|
|
* has to allocate and provide to this function. It is also
|
|
|
|
* the responsibility of the caller to free it later.
|
|
|
|
* @param filename The name (and path) of the file to use.
|
|
|
|
*
|
|
|
|
* @return SR_OK upon success, a negative error code upon failure.
|
|
|
|
*/
|
|
|
|
int (*init) (struct sr_input *in, const char *filename);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Load a file, parsing the input according to the file's format.
|
2015-05-03 18:35:54 +08:00
|
|
|
*
|
2014-01-15 19:48:01 +08:00
|
|
|
* This function will send datafeed packets to the session bus, so
|
|
|
|
* the calling frontend must have registered its session callbacks
|
|
|
|
* beforehand.
|
|
|
|
*
|
|
|
|
* The packet types sent across the session bus by this function must
|
|
|
|
* include at least SR_DF_HEADER, SR_DF_END, and an appropriate data
|
|
|
|
* type such as SR_DF_LOGIC. It may also send a SR_DF_TRIGGER packet
|
|
|
|
* if appropriate.
|
|
|
|
*
|
|
|
|
* @param in A pointer to a valid 'struct sr_input' that the caller
|
|
|
|
* has to allocate and provide to this function. It is also
|
|
|
|
* the responsibility of the caller to free it later.
|
|
|
|
* @param filename The name (and path) of the file to use.
|
|
|
|
*
|
2015-05-03 18:35:54 +08:00
|
|
|
* @return SR_OK upon succcess, a negative error code upon failure.
|
2014-01-15 19:48:01 +08:00
|
|
|
*/
|
|
|
|
int (*loadfile) (struct sr_input *in, const char *filename);
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Output (file) format struct. */
|
|
|
|
struct sr_output {
|
|
|
|
/**
|
|
|
|
* A pointer to this output format's 'struct sr_output_format'.
|
|
|
|
* The frontend can use this to call the module's callbacks.
|
|
|
|
*/
|
2017-05-23 22:39:00 +08:00
|
|
|
const struct sr_output_module *module;
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The device for which this output module is creating output. This
|
|
|
|
* can be used by the module to find out probe names and numbers.
|
|
|
|
*/
|
2017-05-23 22:39:00 +08:00
|
|
|
const struct sr_dev_inst *sdi;
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* An optional parameter which the frontend can pass in to the
|
|
|
|
* output module. How the string is interpreted is entirely up to
|
|
|
|
* the module.
|
|
|
|
*/
|
|
|
|
char *param;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A generic pointer which can be used by the module to keep internal
|
|
|
|
* state between calls into its callback functions.
|
|
|
|
*
|
|
|
|
* For example, the module might store a pointer to a chunk of output
|
|
|
|
* there, and only flush it when it reaches a certain size.
|
|
|
|
*/
|
2015-04-19 00:53:52 +02:00
|
|
|
void *priv;
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
2015-04-19 00:53:52 +02:00
|
|
|
/** Generic option struct used by various subsystems. */
|
|
|
|
struct sr_option {
|
|
|
|
/* Short name suitable for commandline usage, [a-z0-9-]. */
|
|
|
|
char *id;
|
|
|
|
/* Short name suitable for GUI usage, can contain UTF-8. */
|
|
|
|
char *name;
|
|
|
|
/* Description of the option, in a sentence. */
|
|
|
|
char *desc;
|
|
|
|
/* Default value for this option. */
|
|
|
|
GVariant *def;
|
|
|
|
/* List of possible values, if this is an option with few values. */
|
|
|
|
GSList *values;
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Output module driver. */
|
|
|
|
struct sr_output_module {
|
2014-01-15 19:48:01 +08:00
|
|
|
/**
|
2015-04-19 00:53:52 +02:00
|
|
|
* A unique ID for this output module, suitable for use in command-line
|
|
|
|
* clients, [a-z0-9-]. Must not be NULL.
|
2014-01-15 19:48:01 +08:00
|
|
|
*/
|
|
|
|
char *id;
|
|
|
|
|
|
|
|
/**
|
2015-04-19 00:53:52 +02:00
|
|
|
* A unique name for this output module, suitable for use in GUI
|
|
|
|
* clients, can contain UTF-8. Must not be NULL.
|
|
|
|
*/
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A short description of the output module. Must not be NULL.
|
2014-01-15 19:48:01 +08:00
|
|
|
*
|
|
|
|
* This can be displayed by frontends, e.g. when selecting the output
|
2015-04-19 00:53:52 +02:00
|
|
|
* module for saving a file.
|
2014-01-15 19:48:01 +08:00
|
|
|
*/
|
2015-04-19 00:53:52 +02:00
|
|
|
char *desc;
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2015-04-19 00:53:52 +02:00
|
|
|
/**
|
|
|
|
* A NULL terminated array of strings containing a list of file name
|
|
|
|
* extensions typical for the input file format, or NULL if there is
|
|
|
|
* no typical extension for this file format.
|
|
|
|
*/
|
|
|
|
const char *const *exts;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a NULL-terminated list of options this module can take.
|
|
|
|
* Can be NULL, if the module has no options.
|
|
|
|
*/
|
|
|
|
const struct sr_option *(*options) (void);
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function is called once, at the beginning of an output stream.
|
|
|
|
*
|
|
|
|
* The device struct will be available in the output struct passed in,
|
|
|
|
* as well as the param field -- which may be NULL or an empty string,
|
|
|
|
* if no parameter was passed.
|
|
|
|
*
|
|
|
|
* The module can use this to initialize itself, create a struct for
|
|
|
|
* keeping state and storing it in the <code>internal</code> field.
|
|
|
|
*
|
|
|
|
* @param o Pointer to the respective 'struct sr_output'.
|
|
|
|
*
|
2015-04-19 00:53:52 +02:00
|
|
|
* @retval SR_OK Success
|
|
|
|
* @retval other Negative error code.
|
2014-01-15 19:48:01 +08:00
|
|
|
*/
|
2015-04-19 00:53:52 +02:00
|
|
|
int (*init) (struct sr_output *o, GHashTable *options);
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function is passed a copy of every packed in the data feed.
|
|
|
|
* Any output generated by the output module in response to the
|
|
|
|
* packet should be returned in a newly allocated GString
|
|
|
|
* <code>out</code>, which will be freed by the caller.
|
|
|
|
*
|
|
|
|
* Packets not of interest to the output module can just be ignored,
|
|
|
|
* and the <code>out</code> parameter set to NULL.
|
|
|
|
*
|
|
|
|
* @param o Pointer to the respective 'struct sr_output'.
|
|
|
|
* @param sdi The device instance that generated the packet.
|
|
|
|
* @param packet The complete packet.
|
|
|
|
* @param out A pointer where a GString * should be stored if
|
|
|
|
* the module generates output, or NULL if not.
|
|
|
|
*
|
2015-04-19 00:53:52 +02:00
|
|
|
* @retval SR_OK Success
|
|
|
|
* @retval other Negative error code.
|
2014-01-15 19:48:01 +08:00
|
|
|
*/
|
2015-04-19 00:53:52 +02:00
|
|
|
int (*receive) (const struct sr_output *o,
|
2014-01-15 19:48:01 +08:00
|
|
|
const struct sr_datafeed_packet *packet, GString **out);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function is called after the caller is finished using
|
|
|
|
* the output module, and can be used to free any internal
|
|
|
|
* resources the module may keep.
|
|
|
|
*
|
2015-04-19 00:53:52 +02:00
|
|
|
* @retval SR_OK Success
|
|
|
|
* @retval other Negative error code.
|
2014-01-15 19:48:01 +08:00
|
|
|
*/
|
|
|
|
int (*cleanup) (struct sr_output *o);
|
|
|
|
};
|
|
|
|
|
2015-04-19 00:53:52 +02:00
|
|
|
|
2018-07-08 17:48:18 +08:00
|
|
|
enum CHANNEL_TYPE {
|
2019-09-09 00:07:19 -07:00
|
|
|
SR_CHANNEL_DECODER = 9998,
|
|
|
|
SR_CHANNEL_GROUP = 9999,
|
2014-09-24 18:43:42 +08:00
|
|
|
SR_CHANNEL_LOGIC = 10000,
|
|
|
|
SR_CHANNEL_DSO,
|
|
|
|
SR_CHANNEL_ANALOG,
|
2016-05-14 10:24:44 +08:00
|
|
|
SR_CHANNEL_FFT,
|
2019-09-09 00:07:19 -07:00
|
|
|
SR_CHANNEL_LISSAJOUS,
|
|
|
|
SR_CHANNEL_MATH,
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
2022-08-15 17:23:54 +08:00
|
|
|
enum OPERATION_MODE {
|
2014-01-15 19:48:01 +08:00
|
|
|
LOGIC = 0,
|
2014-04-14 17:46:11 +08:00
|
|
|
DSO = 1,
|
|
|
|
ANALOG = 2,
|
2022-08-15 17:23:54 +08:00
|
|
|
UNKNOWN_DSL_MODE = 99,
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
2014-09-24 18:43:42 +08:00
|
|
|
struct sr_channel {
|
|
|
|
/* The index field will go: use g_slist_length(sdi->channels) instead. */
|
2015-07-17 16:23:42 +08:00
|
|
|
uint16_t index;
|
2016-05-14 10:24:44 +08:00
|
|
|
int type;
|
2014-01-15 19:48:01 +08:00
|
|
|
gboolean enabled;
|
|
|
|
char *name;
|
|
|
|
char *trigger;
|
2019-09-09 00:07:19 -07:00
|
|
|
uint8_t bits;
|
2014-09-24 18:43:42 +08:00
|
|
|
uint64_t vdiv;
|
2019-09-09 00:07:19 -07:00
|
|
|
uint64_t vfactor;
|
|
|
|
uint16_t offset;
|
|
|
|
uint16_t zero_offset;
|
|
|
|
uint16_t hw_offset;
|
2016-06-08 12:18:50 +08:00
|
|
|
uint16_t vpos_trans;
|
2015-04-17 00:21:14 +08:00
|
|
|
uint8_t coupling;
|
2014-09-24 18:43:42 +08:00
|
|
|
uint8_t trig_value;
|
2016-06-08 12:18:50 +08:00
|
|
|
int8_t comb_diff_top;
|
|
|
|
int8_t comb_diff_bom;
|
2019-09-09 00:07:19 -07:00
|
|
|
int8_t comb_comp;
|
2020-01-10 22:43:30 +08:00
|
|
|
uint16_t digi_fgain;
|
|
|
|
|
|
|
|
double cali_fgain0;
|
|
|
|
double cali_fgain1;
|
|
|
|
double cali_fgain2;
|
|
|
|
double cali_fgain3;
|
|
|
|
double cali_comb_fgain0;
|
|
|
|
double cali_comb_fgain1;
|
|
|
|
double cali_comb_fgain2;
|
|
|
|
double cali_comb_fgain3;
|
2019-09-09 00:07:19 -07:00
|
|
|
|
|
|
|
gboolean map_default;
|
2018-05-10 10:41:40 +08:00
|
|
|
const char *map_unit;
|
|
|
|
double map_min;
|
|
|
|
double map_max;
|
2018-07-08 17:48:18 +08:00
|
|
|
struct DSL_vga *vga_ptr;
|
2014-09-24 18:43:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Structure for groups of channels that have common properties. */
|
|
|
|
struct sr_channel_group {
|
|
|
|
/** Name of the channel group. */
|
|
|
|
char *name;
|
|
|
|
/** List of sr_channel structs of the channels belonging to this group. */
|
|
|
|
GSList *channels;
|
|
|
|
/** Private data for driver use. */
|
|
|
|
void *priv;
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct sr_config {
|
|
|
|
int key;
|
|
|
|
GVariant *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct sr_config_info {
|
2022-10-19 18:41:13 +08:00
|
|
|
int key;
|
|
|
|
int datatype;
|
2014-01-15 19:48:01 +08:00
|
|
|
char *name;
|
|
|
|
};
|
|
|
|
|
2014-09-24 18:43:42 +08:00
|
|
|
struct sr_status {
|
|
|
|
uint8_t trig_hit;
|
|
|
|
uint8_t captured_cnt3;
|
|
|
|
uint8_t captured_cnt2;
|
|
|
|
uint8_t captured_cnt1;
|
|
|
|
uint8_t captured_cnt0;
|
2015-04-17 00:21:14 +08:00
|
|
|
|
2019-09-09 00:07:19 -07:00
|
|
|
uint16_t pkt_id;
|
2018-07-08 17:48:18 +08:00
|
|
|
uint32_t vlen;
|
2015-04-17 00:21:14 +08:00
|
|
|
gboolean stream_mode;
|
2019-09-09 00:07:19 -07:00
|
|
|
gboolean measure_valid;
|
2015-04-17 00:21:14 +08:00
|
|
|
uint32_t sample_divider;
|
2015-11-11 21:22:03 +08:00
|
|
|
gboolean sample_divider_tog;
|
2016-07-20 08:59:39 +08:00
|
|
|
gboolean trig_flag;
|
2020-01-09 21:48:39 +08:00
|
|
|
uint8_t trig_ch;
|
|
|
|
uint8_t trig_offset;
|
2016-07-20 08:59:39 +08:00
|
|
|
|
2019-09-09 00:07:19 -07:00
|
|
|
uint8_t ch0_max;
|
|
|
|
uint8_t ch0_min;
|
|
|
|
uint32_t ch0_cyc_cnt;
|
|
|
|
uint32_t ch0_cyc_tlen;
|
|
|
|
uint32_t ch0_cyc_plen;
|
|
|
|
uint32_t ch0_cyc_llen;
|
|
|
|
gboolean ch0_level_valid;
|
|
|
|
gboolean ch0_plevel;
|
|
|
|
uint8_t ch0_low_level;
|
|
|
|
uint8_t ch0_high_level;
|
|
|
|
uint32_t ch0_cyc_rlen;
|
|
|
|
uint32_t ch0_cyc_flen;
|
|
|
|
uint64_t ch0_acc_square;
|
|
|
|
uint32_t ch0_acc_mean;
|
2020-01-10 22:43:30 +08:00
|
|
|
uint32_t ch0_acc_mean_p1;
|
|
|
|
uint32_t ch0_acc_mean_p2;
|
|
|
|
uint32_t ch0_acc_mean_p3;
|
2019-09-09 00:07:19 -07:00
|
|
|
|
|
|
|
uint8_t ch1_max;
|
|
|
|
uint8_t ch1_min;
|
|
|
|
uint32_t ch1_cyc_cnt;
|
|
|
|
uint32_t ch1_cyc_tlen;
|
|
|
|
uint32_t ch1_cyc_plen;
|
|
|
|
uint32_t ch1_cyc_llen;
|
|
|
|
gboolean ch1_level_valid;
|
|
|
|
gboolean ch1_plevel;
|
|
|
|
uint8_t ch1_low_level;
|
|
|
|
uint8_t ch1_high_level;
|
|
|
|
uint32_t ch1_cyc_rlen;
|
|
|
|
uint32_t ch1_cyc_flen;
|
|
|
|
uint64_t ch1_acc_square;
|
|
|
|
uint32_t ch1_acc_mean;
|
2020-01-10 22:43:30 +08:00
|
|
|
uint32_t ch1_acc_mean_p1;
|
|
|
|
uint32_t ch1_acc_mean_p2;
|
|
|
|
uint32_t ch1_acc_mean_p3;
|
2014-09-24 18:43:42 +08:00
|
|
|
};
|
|
|
|
|
2022-10-27 17:22:55 +08:00
|
|
|
struct sr_list_item{
|
|
|
|
int id;
|
|
|
|
char *name;
|
|
|
|
};
|
|
|
|
|
2022-10-19 18:41:13 +08:00
|
|
|
enum sr_config_option_id
|
|
|
|
{
|
2014-01-15 19:48:01 +08:00
|
|
|
/*--- Device classes ------------------------------------------------*/
|
|
|
|
|
|
|
|
/** The device can act as logic analyzer. */
|
|
|
|
SR_CONF_LOGIC_ANALYZER = 10000,
|
|
|
|
|
|
|
|
/** The device can act as an oscilloscope. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_OSCILLOSCOPE = 10001,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device can act as a multimeter. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_MULTIMETER = 10002,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device is a demo device. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_DEMO_DEV = 10003,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device can act as a sound level meter. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_SOUNDLEVELMETER = 10004,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device can measure temperature. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_THERMOMETER = 10005,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device can measure humidity. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_HYGROMETER = 10006,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/*--- Driver scan options -------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Specification on how to connect to a device.
|
|
|
|
*
|
|
|
|
* In combination with SR_CONF_SERIALCOMM, this is a serial port in
|
|
|
|
* the form which makes sense to the OS (e.g., /dev/ttyS0).
|
|
|
|
* Otherwise this specifies a USB device, either in the form of
|
|
|
|
* @verbatim <bus>.<address> @endverbatim (decimal, e.g. 1.65) or
|
|
|
|
* @verbatim <vendorid>.<productid> @endverbatim
|
|
|
|
* (hexadecimal, e.g. 1d6b.0001).
|
|
|
|
*/
|
|
|
|
SR_CONF_CONN = 20000,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Serial communication specification, in the form:
|
|
|
|
*
|
|
|
|
* @verbatim <baudrate>/<databits><parity><stopbits> @endverbatim
|
|
|
|
*
|
|
|
|
* Example: 9600/8n1
|
|
|
|
*
|
|
|
|
* The string may also be followed by one or more special settings,
|
|
|
|
* in the form "/key=value". Supported keys and their values are:
|
|
|
|
*
|
|
|
|
* rts 0,1 set the port's RTS pin to low or high
|
|
|
|
* dtr 0,1 set the port's DTR pin to low or high
|
|
|
|
* flow 0 no flow control
|
|
|
|
* 1 hardware-based (RTS/CTS) flow control
|
|
|
|
* 2 software-based (XON/XOFF) flow control
|
|
|
|
*
|
|
|
|
* This is always an optional parameter, since a driver typically
|
|
|
|
* knows the speed at which the device wants to communicate.
|
|
|
|
*/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_SERIALCOMM = 20001,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/*--- Device configuration ------------------------------------------*/
|
|
|
|
|
|
|
|
/** The device supports setting its samplerate, in Hz. */
|
|
|
|
SR_CONF_SAMPLERATE = 30000,
|
|
|
|
|
|
|
|
/** The device supports setting a pre/post-trigger capture ratio. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_CAPTURE_RATIO = 30001,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_USB_SPEED = 30002,
|
|
|
|
SR_CONF_USB30_SUPPORT = 30003,
|
|
|
|
SR_CONF_DEVICE_MODE = 30004,
|
|
|
|
SR_CONF_INSTANT = 30005,
|
|
|
|
SR_CONF_STATUS = 30006,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device supports setting a pattern (pattern generator mode). */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PATTERN_MODE = 30007,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device supports Run Length Encoding. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_RLE = 30008,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
/** Need wait to uplad captured data */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_WAIT_UPLOAD = 30009,
|
2017-05-20 03:20:06 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/** The device supports setting trigger slope. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_SLOPE = 30010,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** Trigger source. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_SOURCE = 30011,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2016-07-20 08:59:39 +08:00
|
|
|
/** Trigger channel */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_CHANNEL = 30012,
|
2016-07-20 08:59:39 +08:00
|
|
|
|
2014-06-29 19:27:43 +08:00
|
|
|
/** Trigger Value. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_VALUE = 30013,
|
2014-06-29 19:27:43 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/** Horizontal trigger position. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_HORIZ_TRIGGERPOS = 30014,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2015-06-17 21:46:37 +08:00
|
|
|
/** Trigger hold off time */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_HOLDOFF = 30015,
|
2015-06-17 21:46:37 +08:00
|
|
|
|
2016-06-25 09:58:07 +08:00
|
|
|
/** Trigger Margin */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_MARGIN = 30016,
|
2016-06-25 09:58:07 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/** Buffer size. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_BUFFERSIZE = 30017,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** Time base. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_MAX_TIMEBASE = 30018,
|
|
|
|
SR_CONF_MIN_TIMEBASE = 30019,
|
|
|
|
SR_CONF_TIMEBASE = 30020,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** Filter. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_FILTER = 30021,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2014-06-29 19:27:43 +08:00
|
|
|
/** DSO configure sync */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_DSO_SYNC = 30022,
|
2014-06-29 19:27:43 +08:00
|
|
|
|
2018-05-10 10:41:40 +08:00
|
|
|
/** How many bits for each sample */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_UNIT_BITS = 30023,
|
|
|
|
SR_CONF_REF_MIN = 30024,
|
|
|
|
SR_CONF_REF_MAX = 30025,
|
2016-06-25 09:58:07 +08:00
|
|
|
|
2020-01-08 10:49:11 +08:00
|
|
|
/** Valid channel number */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TOTAL_CH_NUM = 30026,
|
2020-01-08 10:49:11 +08:00
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
/** Valid channel number */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_VLD_CH_NUM = 30027,
|
2017-05-20 03:20:06 +08:00
|
|
|
|
2020-01-08 10:49:11 +08:00
|
|
|
/** 32 channel support */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_LA_CH32 = 30028,
|
2020-01-08 10:49:11 +08:00
|
|
|
|
2014-06-29 19:27:43 +08:00
|
|
|
/** Zero */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_HAVE_ZERO = 30029,
|
|
|
|
SR_CONF_ZERO = 30030,
|
|
|
|
SR_CONF_ZERO_SET = 30031,
|
|
|
|
SR_CONF_ZERO_LOAD = 30032,
|
|
|
|
SR_CONF_ZERO_DEFAULT = 30033,
|
|
|
|
SR_CONF_ZERO_COMB_FGAIN = 30034,
|
|
|
|
SR_CONF_ZERO_COMB = 30035,
|
|
|
|
SR_CONF_VOCM = 30036,
|
|
|
|
SR_CONF_CALI = 30037,
|
2015-04-17 00:21:14 +08:00
|
|
|
|
2015-11-04 00:27:42 +08:00
|
|
|
/** status for dso channel */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_STATUS_PERIOD = 30038,
|
|
|
|
SR_CONF_STATUS_PCNT = 30039,
|
|
|
|
SR_CONF_STATUS_MAX = 30040,
|
|
|
|
SR_CONF_STATUS_MIN = 30041,
|
|
|
|
SR_CONF_STATUS_PLEN = 30042,
|
|
|
|
SR_CONF_STATUS_LLEN = 30043,
|
|
|
|
SR_CONF_STATUS_LEVEL = 30044,
|
|
|
|
SR_CONF_STATUS_PLEVEL = 30045,
|
|
|
|
SR_CONF_STATUS_LOW = 30046,
|
|
|
|
SR_CONF_STATUS_HIGH = 30047,
|
|
|
|
SR_CONF_STATUS_RLEN = 30048,
|
|
|
|
SR_CONF_STATUS_FLEN = 30049,
|
|
|
|
SR_CONF_STATUS_RMS = 30050,
|
|
|
|
SR_CONF_STATUS_MEAN = 30051,
|
2015-11-04 00:27:42 +08:00
|
|
|
|
2015-04-17 00:21:14 +08:00
|
|
|
/** Stream */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_STREAM = 30052,
|
2015-04-17 00:21:14 +08:00
|
|
|
|
2016-08-10 15:12:13 +08:00
|
|
|
/** DSO Roll */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_ROLL = 30053,
|
2016-08-10 15:12:13 +08:00
|
|
|
|
2015-04-17 00:21:14 +08:00
|
|
|
/** Test */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TEST = 30054,
|
|
|
|
SR_CONF_EEPROM = 30055,
|
|
|
|
SR_CONF_TUNE = 30056,
|
|
|
|
SR_CONF_TUNE_SEL = 30057,
|
|
|
|
SR_CONF_EXTEND_ID = 30058,
|
|
|
|
SR_CONF_EXTEND_DATA = 30059,
|
2014-06-29 19:27:43 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/** The device supports setting its sample interval, in ms. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_SAMPLE_INTERVAL = 30060,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** Number of timebases, as related to SR_CONF_TIMEBASE. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_NUM_TIMEBASE = 30061,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2018-05-10 10:41:40 +08:00
|
|
|
/** Number of vertical divisions, as related to SR_CONF_PROBE_VDIV. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_NUM_VDIV = 30062,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** clock type (internal/external) */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_CLOCK_TYPE = 30063,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2014-09-24 18:43:42 +08:00
|
|
|
/** clock edge (posedge/negedge) */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_CLOCK_EDGE = 30064,
|
2014-09-24 18:43:42 +08:00
|
|
|
|
2014-04-14 17:46:11 +08:00
|
|
|
/** Device operation mode */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_OPERATION_MODE = 30065,
|
2014-04-14 17:46:11 +08:00
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
/** Device buffer options */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_BUFFER_OPTIONS = 30066,
|
2017-05-20 03:20:06 +08:00
|
|
|
|
2015-09-26 21:59:40 +08:00
|
|
|
/** Device channel mode */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_CHANNEL_MODE = 30067,
|
2015-09-26 21:59:40 +08:00
|
|
|
|
2018-05-27 20:32:39 +08:00
|
|
|
/** RLE compress support */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_RLE_SUPPORT = 30068,
|
2018-05-27 20:32:39 +08:00
|
|
|
|
2015-09-28 16:31:19 +08:00
|
|
|
/** Signal max height **/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_MAX_HEIGHT = 30069,
|
|
|
|
SR_CONF_MAX_HEIGHT_VALUE = 30070,
|
2015-09-28 16:31:19 +08:00
|
|
|
|
2014-09-24 18:43:42 +08:00
|
|
|
/** Device sample threshold */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_THRESHOLD = 30071,
|
|
|
|
SR_CONF_VTH = 30072,
|
2015-04-17 00:21:14 +08:00
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
/** Hardware capacity **/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_MAX_DSO_SAMPLERATE = 30073,
|
|
|
|
SR_CONF_MAX_DSO_SAMPLELIMITS = 30074,
|
|
|
|
SR_CONF_HW_DEPTH = 30075,
|
2017-05-20 03:20:06 +08:00
|
|
|
|
2019-09-09 00:07:19 -07:00
|
|
|
/** bandwidth */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_BANDWIDTH = 30076,
|
|
|
|
SR_CONF_BANDWIDTH_LIMIT = 30077,
|
2019-09-09 00:07:19 -07:00
|
|
|
|
2018-05-10 10:41:40 +08:00
|
|
|
/*--- Probe configuration -------------------------------------------*/
|
|
|
|
/** Probe options */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_CONFIGS = 30078,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
|
|
|
/** Enable */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_EN = 30080,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
|
|
|
/** Coupling */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_COUPLING = 30081,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
|
|
|
/** Volts/div */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_VDIV = 30082,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
|
|
|
/** Factor */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_FACTOR = 30083,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
|
|
|
/** Mapping */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_MAP_DEFAULT = 30084,
|
|
|
|
SR_CONF_PROBE_MAP_UNIT = 30085,
|
|
|
|
SR_CONF_PROBE_MAP_MIN = 30086,
|
|
|
|
SR_CONF_PROBE_MAP_MAX = 30087,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
|
|
|
/** Vertical offset */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_OFFSET = 30088,
|
|
|
|
SR_CONF_PROBE_HW_OFFSET = 30089,
|
|
|
|
SR_CONF_PROBE_PREOFF = 30090,
|
|
|
|
SR_CONF_PROBE_PREOFF_DEFAULT = 30091,
|
|
|
|
SR_CONF_PROBE_PREOFF_MARGIN = 30092,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
|
|
|
/** VGain */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_PROBE_VGAIN = 30093,
|
|
|
|
SR_CONF_PROBE_VGAIN_DEFAULT = 30094,
|
|
|
|
SR_CONF_PROBE_VGAIN_RANGE = 30095,
|
|
|
|
SR_CONF_PROBE_COMB_COMP_EN = 30096,
|
|
|
|
SR_CONF_PROBE_COMB_COMP = 30097,
|
2018-05-10 10:41:40 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/*--- Special stuff -------------------------------------------------*/
|
|
|
|
|
|
|
|
/** Device options for a particular device. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_DEVICE_OPTIONS = 30098,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2015-06-06 22:24:00 +08:00
|
|
|
/** Sessions */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_DEVICE_SESSIONS = 30099,
|
2015-06-06 22:24:00 +08:00
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
/** Session file version */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_FILE_VERSION = 30102,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device supports setting the number of probes. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_CAPTURE_NUM_PROBES = 30103,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2017-05-20 03:20:06 +08:00
|
|
|
/** The device supports setting the number of data blocks. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_NUM_BLOCKS = 30104,
|
2017-05-20 03:20:06 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/*--- Acquisition modes ---------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The device supports setting a sample time limit (how long
|
|
|
|
* the sample acquisition should run, in ms).
|
|
|
|
*/
|
|
|
|
SR_CONF_LIMIT_MSEC = 50000,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The device supports setting a sample number limit (how many
|
|
|
|
* samples should be acquired).
|
|
|
|
*/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_LIMIT_SAMPLES = 50001,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2016-06-14 22:52:27 +08:00
|
|
|
/**
|
|
|
|
* Absolute time record for session driver
|
|
|
|
*/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_TIME = 50002,
|
2016-06-14 22:52:27 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Trigger position for session driver
|
|
|
|
*/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_TRIGGER_POS = 50003,
|
2016-06-14 22:52:27 +08:00
|
|
|
|
2015-10-08 21:20:38 +08:00
|
|
|
/**
|
|
|
|
* The actual sample count received
|
|
|
|
*/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_ACTUAL_SAMPLES = 50004,
|
2015-10-08 21:20:38 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
/**
|
|
|
|
* The device supports setting a frame limit (how many
|
|
|
|
* frames should be acquired).
|
|
|
|
*/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_LIMIT_FRAMES = 50005,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The device supports continuous sampling. Neither a time limit
|
|
|
|
* nor a sample number limit has to be supplied, it will just acquire
|
|
|
|
* samples continuously, until explicitly stopped by a certain command.
|
|
|
|
*/
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_CONTINUOUS = 50006,
|
2014-01-15 19:48:01 +08:00
|
|
|
|
|
|
|
/** The device has internal storage, into which data is logged. This
|
|
|
|
* starts or stops the internal logging. */
|
2022-09-23 15:44:22 +08:00
|
|
|
SR_CONF_DATALOG = 50007,
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Device instance status. */
|
2022-08-12 13:25:50 +08:00
|
|
|
enum sr_device_status {
|
2014-01-15 19:48:01 +08:00
|
|
|
/** The device instance was not found. */
|
|
|
|
SR_ST_NOT_FOUND = 10000,
|
|
|
|
/** The device instance was found, but is still booting. */
|
|
|
|
SR_ST_INITIALIZING,
|
|
|
|
/** The device instance is live, but not in use. */
|
|
|
|
SR_ST_INACTIVE,
|
2017-05-20 03:20:06 +08:00
|
|
|
/** The device instance has an imcompatible firmware */
|
|
|
|
SR_ST_INCOMPATIBLE,
|
2014-01-15 19:48:01 +08:00
|
|
|
/** The device instance is actively in use in a session. */
|
|
|
|
SR_ST_ACTIVE,
|
|
|
|
/** The device is winding down its session. */
|
|
|
|
SR_ST_STOPPING,
|
|
|
|
};
|
|
|
|
|
2018-05-10 10:41:40 +08:00
|
|
|
/** Device test modes. */
|
2014-04-14 17:46:11 +08:00
|
|
|
enum {
|
2018-05-10 10:41:40 +08:00
|
|
|
/** No test mode */
|
|
|
|
SR_TEST_NONE,
|
2014-04-14 17:46:11 +08:00
|
|
|
/** Internal pattern test mode */
|
2018-05-10 10:41:40 +08:00
|
|
|
SR_TEST_INTERNAL,
|
2014-04-14 17:46:11 +08:00
|
|
|
/** External pattern test mode */
|
2018-05-10 10:41:40 +08:00
|
|
|
SR_TEST_EXTERNAL,
|
2014-04-14 17:46:11 +08:00
|
|
|
/** SDRAM loopback test mode */
|
2018-05-10 10:41:40 +08:00
|
|
|
SR_TEST_LOOPBACK,
|
2014-04-14 17:46:11 +08:00
|
|
|
};
|
|
|
|
|
2014-09-24 18:43:42 +08:00
|
|
|
/** Device threshold level. */
|
2022-10-19 18:41:13 +08:00
|
|
|
enum DSL_THRESHOLD_LEVEL{
|
2014-09-24 18:43:42 +08:00
|
|
|
/** 1.8/2.5/3.3 level */
|
|
|
|
SR_TH_3V3 = 0,
|
|
|
|
/** 5.0 level */
|
|
|
|
SR_TH_5V0 = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Device input filter. */
|
|
|
|
enum {
|
|
|
|
/** None */
|
|
|
|
SR_FILTER_NONE = 0,
|
|
|
|
/** One clock cycle */
|
|
|
|
SR_FILTER_1T = 1,
|
2014-04-14 17:46:11 +08:00
|
|
|
};
|
|
|
|
|
2015-04-17 00:21:14 +08:00
|
|
|
/** Coupling. */
|
|
|
|
enum {
|
|
|
|
/** DC */
|
|
|
|
SR_DC_COUPLING = 0,
|
|
|
|
/** AC */
|
|
|
|
SR_AC_COUPLING = 1,
|
|
|
|
/** Ground */
|
|
|
|
SR_GND_COUPLING = 2,
|
|
|
|
};
|
|
|
|
|
2014-09-24 18:43:42 +08:00
|
|
|
struct sr_dev_mode {
|
|
|
|
int mode;
|
2022-07-26 15:45:46 +08:00
|
|
|
const char *name;
|
|
|
|
const char *acronym;
|
|
|
|
};
|
2022-07-28 16:57:15 +08:00
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
enum {
|
|
|
|
SIMPLE_TRIGGER = 0,
|
|
|
|
ADV_TRIGGER,
|
2015-05-28 11:09:17 +08:00
|
|
|
SERIAL_TRIGGER,
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
|
|
|
|
2014-06-29 19:27:43 +08:00
|
|
|
enum {
|
|
|
|
DSO_TRIGGER_AUTO = 0,
|
|
|
|
DSO_TRIGGER_CH0,
|
|
|
|
DSO_TRIGGER_CH1,
|
|
|
|
DSO_TRIGGER_CH0A1,
|
|
|
|
DSO_TRIGGER_CH0O1,
|
|
|
|
};
|
|
|
|
enum {
|
|
|
|
DSO_TRIGGER_RISING = 0,
|
|
|
|
DSO_TRIGGER_FALLING,
|
|
|
|
};
|
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
struct ds_trigger_pos {
|
2016-07-20 08:59:39 +08:00
|
|
|
uint32_t check_id;
|
2014-01-15 19:48:01 +08:00
|
|
|
uint32_t real_pos;
|
|
|
|
uint32_t ram_saddr;
|
2017-05-20 03:20:06 +08:00
|
|
|
uint32_t remain_cnt_l;
|
|
|
|
uint32_t remain_cnt_h;
|
|
|
|
uint32_t status;
|
2014-01-15 19:48:01 +08:00
|
|
|
};
|
2022-07-15 11:57:50 +08:00
|
|
|
|
2023-03-08 17:51:44 +08:00
|
|
|
enum DSL_CHANNEL_ID
|
|
|
|
{
|
2022-10-19 18:41:13 +08:00
|
|
|
DSL_STREAM20x16 = 0,
|
2023-03-08 17:51:44 +08:00
|
|
|
DSL_STREAM25x12 = 1,
|
|
|
|
DSL_STREAM50x6 = 2,
|
|
|
|
DSL_STREAM100x3 = 3,
|
|
|
|
|
|
|
|
DSL_STREAM20x16_3DN2 = 4,
|
|
|
|
DSL_STREAM25x12_3DN2 = 5,
|
|
|
|
DSL_STREAM50x6_3DN2 = 6,
|
|
|
|
DSL_STREAM100x3_3DN2 = 7,
|
|
|
|
|
|
|
|
DSL_STREAM10x32_32_3DN2 = 8,
|
|
|
|
DSL_STREAM20x16_32_3DN2 = 9,
|
|
|
|
DSL_STREAM25x12_32_3DN2 = 10,
|
|
|
|
DSL_STREAM50x6_32_3DN2 = 11,
|
|
|
|
DSL_STREAM100x3_32_3DN2 = 12,
|
|
|
|
|
|
|
|
DSL_STREAM50x32 = 13,
|
|
|
|
DSL_STREAM100x30 = 14,
|
|
|
|
DSL_STREAM250x12 = 15,
|
|
|
|
DSL_STREAM125x16_16 = 16,
|
|
|
|
DSL_STREAM250x12_16 = 17,
|
|
|
|
DSL_STREAM500x6 = 18,
|
|
|
|
DSL_STREAM1000x3 = 19,
|
|
|
|
|
|
|
|
DSL_BUFFER100x16 = 20,
|
|
|
|
DSL_BUFFER200x8 = 21,
|
|
|
|
DSL_BUFFER400x4 = 22,
|
|
|
|
|
|
|
|
DSL_BUFFER250x32 = 23,
|
|
|
|
DSL_BUFFER500x16 = 24,
|
|
|
|
DSL_BUFFER1000x8 = 25,
|
|
|
|
|
|
|
|
DSL_ANALOG10x2 = 26,
|
|
|
|
DSL_ANALOG10x2_500 = 27,
|
|
|
|
|
|
|
|
DSL_DSO200x2 = 28,
|
|
|
|
DSL_DSO1000x2 = 29,
|
2022-10-19 18:41:13 +08:00
|
|
|
};
|
2022-10-17 09:06:02 +08:00
|
|
|
|
2022-07-14 13:50:40 +08:00
|
|
|
/*--- input/input.c ---------------------------------------------------------*/
|
|
|
|
|
|
|
|
SR_API struct sr_input_format **sr_input_list(void);
|
|
|
|
|
|
|
|
/*--- output/output.c -------------------------------------------------------*/
|
|
|
|
|
|
|
|
SR_API const struct sr_output_module **sr_output_list(void);
|
|
|
|
|
|
|
|
/*--- strutil.c -------------------------------------------------------------*/
|
|
|
|
|
|
|
|
SR_API char *sr_si_string_u64(uint64_t x, const char *unit);
|
|
|
|
SR_API char *sr_iec_string_u64(uint64_t x, const char *unit);
|
|
|
|
SR_API char *sr_samplerate_string(uint64_t samplerate);
|
|
|
|
SR_API char *sr_samplecount_string(uint64_t samplecount);
|
|
|
|
SR_API char *sr_period_string(uint64_t frequency);
|
|
|
|
SR_API char *sr_time_string(uint64_t time);
|
|
|
|
SR_API char *sr_voltage_string(uint64_t v_p, uint64_t v_q);
|
|
|
|
SR_API int sr_parse_sizestring(const char *sizestring, uint64_t *size);
|
|
|
|
SR_API uint64_t sr_parse_timestring(const char *timestring);
|
|
|
|
SR_API gboolean sr_parse_boolstring(const char *boolstring);
|
|
|
|
SR_API int sr_parse_period(const char *periodstr, uint64_t *p, uint64_t *q);
|
|
|
|
SR_API int sr_parse_voltage(const char *voltstr, uint64_t *p, uint64_t *q);
|
|
|
|
|
|
|
|
/*--- version.c -------------------------------------------------------------*/
|
|
|
|
|
2022-07-28 16:57:15 +08:00
|
|
|
SR_API const char *sr_get_lib_version_string();
|
2022-07-14 13:50:40 +08:00
|
|
|
|
|
|
|
/*--- error.c ---------------------------------------------------------------*/
|
|
|
|
|
2022-07-28 16:57:15 +08:00
|
|
|
SR_API const char *sr_error_str(int error_code);
|
|
|
|
SR_API const char *sr_error_name(int error_code);
|
2022-07-14 13:50:40 +08:00
|
|
|
|
|
|
|
/*--- trigger.c ------------------------------------------------------------*/
|
2022-09-16 15:59:52 +08:00
|
|
|
SR_API int ds_trigger_reset();
|
2022-07-14 13:50:40 +08:00
|
|
|
SR_API int ds_trigger_stage_set_value(uint16_t stage, uint16_t probes, char *trigger0, char *trigger1);
|
|
|
|
SR_API int ds_trigger_stage_set_logic(uint16_t stage, uint16_t probes, unsigned char trigger_logic);
|
|
|
|
SR_API int ds_trigger_stage_set_inv(uint16_t stage, uint16_t probes, unsigned char trigger0_inv, unsigned char trigger1_inv);
|
|
|
|
SR_API int ds_trigger_stage_set_count(uint16_t stage, uint16_t probes, uint32_t trigger0_count, uint32_t trigger1_count);
|
|
|
|
SR_API int ds_trigger_probe_set(uint16_t probe, unsigned char trigger0, unsigned char trigger1);
|
|
|
|
SR_API int ds_trigger_set_stage(uint16_t stages);
|
|
|
|
SR_API int ds_trigger_set_pos(uint16_t position);
|
|
|
|
SR_API uint16_t ds_trigger_get_pos();
|
|
|
|
SR_API int ds_trigger_set_en(uint16_t enable);
|
|
|
|
SR_API uint16_t ds_trigger_get_en();
|
|
|
|
SR_API int ds_trigger_set_mode(uint16_t mode);
|
|
|
|
|
2022-07-15 11:57:50 +08:00
|
|
|
/*--- log.c -----------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Use a shared context, and drop the private log context
|
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API void ds_log_set_context(xlog_context *ctx);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the private log context level
|
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API void ds_log_level(int level);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
|
|
|
|
2022-08-26 13:41:57 +08:00
|
|
|
// A new device attached, user need to call ds_get_device_list to get the list,
|
|
|
|
// the last one is new.
|
|
|
|
// User can call ds_active_device() to switch to the current device.
|
2022-09-16 15:59:52 +08:00
|
|
|
//#define DS_EV_NEW_DEVICE_ATTACH 1
|
2022-08-26 13:41:57 +08:00
|
|
|
|
|
|
|
// The current device detached, user need to call ds_get_device_list to get the list,
|
|
|
|
// and call ds_active_device() to switch to the current device.
|
2022-09-16 15:59:52 +08:00
|
|
|
//#define DS_EV_CURRENT_DEVICE_DETACH 2
|
2022-08-26 13:41:57 +08:00
|
|
|
|
|
|
|
// A inactive device detached.
|
|
|
|
// User can call ds_get_device_list() to get the new list, and update the list view.
|
2022-09-16 15:59:52 +08:00
|
|
|
//#define DS_EV_INACTIVE_DEVICE_DETACH 3
|
2022-08-26 13:41:57 +08:00
|
|
|
|
|
|
|
// The collect task is ends.
|
2022-09-16 15:59:52 +08:00
|
|
|
#define DS_EV_COLLECT_TASK_START 101
|
2022-08-26 13:41:57 +08:00
|
|
|
|
|
|
|
// The collect task is ends.
|
2022-09-16 15:59:52 +08:00
|
|
|
#define DS_EV_COLLECT_TASK_END 102
|
|
|
|
|
|
|
|
// The device is running
|
|
|
|
#define DS_EV_DEVICE_RUNNING 103
|
|
|
|
|
|
|
|
// The device is stopped
|
|
|
|
#define DS_EV_DEVICE_STOPPED 104
|
|
|
|
|
|
|
|
#define DS_EV_COLLECT_TASK_END_BY_DETACHED 105
|
|
|
|
|
|
|
|
#define DS_EV_COLLECT_TASK_END_BY_ERROR 106
|
|
|
|
|
2023-03-13 18:49:00 +08:00
|
|
|
enum DS_DEVICE_EVENT_TYPE
|
2022-09-16 15:59:52 +08:00
|
|
|
{
|
2023-03-13 18:49:00 +08:00
|
|
|
DS_EV_NEW_DEVICE_ATTACH = 1,
|
|
|
|
DS_EV_CURRENT_DEVICE_DETACH = 2,
|
|
|
|
DS_EV_INACTIVE_DEVICE_DETACH = 3,
|
2022-09-16 15:59:52 +08:00
|
|
|
};
|
2022-08-26 13:41:57 +08:00
|
|
|
|
|
|
|
|
|
|
|
typedef unsigned long long ds_device_handle;
|
2022-07-15 11:57:50 +08:00
|
|
|
|
2022-08-26 13:41:57 +08:00
|
|
|
#define NULL_HANDLE 0
|
2022-08-08 15:59:50 +08:00
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
|
|
|
* Device base info
|
|
|
|
*/
|
2022-09-26 17:43:57 +08:00
|
|
|
struct ds_device_base_info
|
2022-07-15 11:57:50 +08:00
|
|
|
{
|
2022-08-11 20:09:49 +08:00
|
|
|
ds_device_handle handle;
|
2022-08-08 15:59:50 +08:00
|
|
|
char name[50];
|
2022-09-26 17:43:57 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ds_device_full_info
|
|
|
|
{
|
|
|
|
ds_device_handle handle;
|
|
|
|
char name[50];
|
|
|
|
char path[256]; //file path
|
2022-08-31 16:26:08 +08:00
|
|
|
char driver_name[20];
|
2022-08-08 15:59:50 +08:00
|
|
|
int dev_type; // enum sr_device_type
|
2022-08-31 16:26:08 +08:00
|
|
|
struct sr_dev_inst *di;
|
2022-07-15 11:57:50 +08:00
|
|
|
};
|
2022-07-20 11:39:02 +08:00
|
|
|
|
2022-08-11 20:09:49 +08:00
|
|
|
struct ds_task_progress
|
2022-07-20 11:39:02 +08:00
|
|
|
{
|
2022-08-08 15:59:50 +08:00
|
|
|
int progress;
|
|
|
|
int is_end;
|
2022-07-20 11:39:02 +08:00
|
|
|
};
|
|
|
|
|
2022-08-11 20:09:49 +08:00
|
|
|
struct ds_store_extra_data
|
2022-07-20 11:39:02 +08:00
|
|
|
{
|
2022-08-08 15:59:50 +08:00
|
|
|
char name[50];
|
|
|
|
char *data;
|
|
|
|
int data_length;
|
2022-07-20 11:39:02 +08:00
|
|
|
};
|
|
|
|
|
2022-07-15 11:57:50 +08:00
|
|
|
/*---lib_main.c -----------------------------------------------*/
|
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
|
|
|
* event see enum libsigrok_event_type
|
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
typedef void (*dslib_event_callback_t)(int event);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Data forwarding callback collected by the device.
|
|
|
|
*/
|
|
|
|
typedef void (*ds_datafeed_callback_t)(const struct sr_dev_inst *sdi,
|
|
|
|
const struct sr_datafeed_packet *packet);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
|
|
|
* Must call first
|
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API int ds_lib_init();
|
2022-07-15 11:57:50 +08:00
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
|
|
|
* Free all resource before program exits
|
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API int ds_lib_exit();
|
2022-07-15 11:57:50 +08:00
|
|
|
|
|
|
|
/**
|
2022-07-20 11:39:02 +08:00
|
|
|
* Set event callback, event type see enum libsigrok_event_type
|
2022-07-15 11:57:50 +08:00
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API void ds_set_event_callback(dslib_event_callback_t cb);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
|
|
|
/**
|
2022-08-11 20:09:49 +08:00
|
|
|
* Set the data receive callback.
|
2022-07-15 11:57:50 +08:00
|
|
|
*/
|
2022-08-15 17:23:54 +08:00
|
|
|
SR_API void ds_set_datafeed_callback(ds_datafeed_callback_t cb);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
2022-07-28 16:57:15 +08:00
|
|
|
* Set the firmware binary file directory,
|
|
|
|
* User must call it to set the firmware resource directory
|
2022-07-20 11:39:02 +08:00
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API void ds_set_firmware_resource_dir(const char *dir);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
2022-08-08 15:59:50 +08:00
|
|
|
* Get the device list, if the field _handle is 0, the list visited to end.
|
|
|
|
* User need call free() to release the buffer. If the list is empty, the out_list is null.
|
2022-07-20 11:39:02 +08:00
|
|
|
*/
|
2022-09-26 17:43:57 +08:00
|
|
|
SR_API int ds_get_device_list(struct ds_device_base_info** out_list, int *out_count);
|
2022-08-15 17:23:54 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Active a device.
|
|
|
|
*/
|
|
|
|
SR_API int ds_active_device(ds_device_handle handle);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
|
|
|
/**
|
2022-08-15 17:23:54 +08:00
|
|
|
* Active a device,
|
|
|
|
* if @index is -1, will select the last one.
|
2022-07-15 11:57:50 +08:00
|
|
|
*/
|
2022-08-15 17:23:54 +08:00
|
|
|
SR_API int ds_active_device_by_index(int index);
|
2022-07-20 11:39:02 +08:00
|
|
|
|
2022-08-01 10:40:29 +08:00
|
|
|
/**
|
2022-08-15 17:23:54 +08:00
|
|
|
* Get the selected device index.
|
2022-08-01 10:40:29 +08:00
|
|
|
*/
|
2022-08-15 17:23:54 +08:00
|
|
|
SR_API int ds_get_actived_device_index();
|
2022-08-01 10:40:29 +08:00
|
|
|
|
2022-08-26 13:41:57 +08:00
|
|
|
/**
|
|
|
|
* Detect whether the active device exists
|
|
|
|
*/
|
|
|
|
SR_API int ds_have_actived_device();
|
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
2022-09-29 15:50:37 +08:00
|
|
|
* Create a device from session file, and append to the list.
|
2022-07-20 11:39:02 +08:00
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API int ds_device_from_file(const char *file_path);
|
2022-07-20 11:39:02 +08:00
|
|
|
|
|
|
|
/**
|
2022-08-08 15:59:50 +08:00
|
|
|
* Remove one device from the list, and destory it.
|
2022-08-15 17:23:54 +08:00
|
|
|
* User need to call ds_get_device_list() to get the new list.
|
2022-07-20 11:39:02 +08:00
|
|
|
*/
|
2022-08-11 20:09:49 +08:00
|
|
|
SR_API int ds_remove_device(ds_device_handle handle);
|
2022-07-20 11:39:02 +08:00
|
|
|
|
2022-08-24 10:13:25 +08:00
|
|
|
/**
|
|
|
|
* Get the decive supports work mode, mode list: LOGIC、ANALOG、DSO
|
|
|
|
* return type see struct sr_dev_mode.
|
|
|
|
*/
|
|
|
|
SR_API const GSList *ds_get_actived_device_mode_list();
|
|
|
|
|
2022-07-20 11:39:02 +08:00
|
|
|
/**
|
2022-08-15 17:23:54 +08:00
|
|
|
* Get the actived device info.
|
|
|
|
* If the actived device is not exists, the handle filed will be set null.
|
2022-07-20 11:39:02 +08:00
|
|
|
*/
|
2022-09-26 17:43:57 +08:00
|
|
|
SR_API int ds_get_actived_device_info(struct ds_device_full_info *fill_info);
|
2022-08-15 17:23:54 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get actived device work model. mode list:LOGIC、ANALOG、DSO
|
|
|
|
*/
|
|
|
|
SR_API int ds_get_actived_device_mode();
|
2022-07-20 11:39:02 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Start collect data
|
|
|
|
*/
|
2022-08-15 17:23:54 +08:00
|
|
|
SR_API int ds_start_collect();
|
2022-07-20 11:39:02 +08:00
|
|
|
|
|
|
|
/**
|
2022-11-11 15:40:06 +08:00
|
|
|
* Stop collect data, but not close the device.
|
2022-07-20 11:39:02 +08:00
|
|
|
*/
|
2022-08-15 17:23:54 +08:00
|
|
|
SR_API int ds_stop_collect();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the device is collecting.
|
|
|
|
*/
|
|
|
|
SR_API int ds_is_collecting();
|
2022-07-20 11:39:02 +08:00
|
|
|
|
2022-09-23 15:44:22 +08:00
|
|
|
/**
|
2022-09-29 15:50:37 +08:00
|
|
|
* Close the actived device, and stop collect.
|
2022-09-23 15:44:22 +08:00
|
|
|
*/
|
|
|
|
SR_API int ds_release_actived_device();
|
|
|
|
|
2022-08-24 10:13:25 +08:00
|
|
|
/*---config -----------------------------------------------*/
|
|
|
|
SR_API int ds_get_actived_device_config(const struct sr_channel *ch,
|
|
|
|
const struct sr_channel_group *cg,
|
|
|
|
int key, GVariant **data);
|
|
|
|
|
|
|
|
SR_API int ds_set_actived_device_config(const struct sr_channel *ch,
|
|
|
|
const struct sr_channel_group *cg,
|
|
|
|
int key, GVariant *data);
|
|
|
|
|
|
|
|
SR_API int ds_get_actived_device_config_list(const struct sr_channel_group *cg,
|
|
|
|
int key, GVariant **data);
|
|
|
|
|
|
|
|
SR_API const struct sr_config_info* ds_get_actived_device_config_info(int key);
|
|
|
|
|
|
|
|
SR_API const struct sr_config_info* ds_get_actived_device_config_info_by_name(const char *optname);
|
|
|
|
|
|
|
|
SR_API int ds_get_actived_device_status(struct sr_status *status, gboolean prg);
|
|
|
|
|
|
|
|
SR_API struct sr_config *ds_new_config(int key, GVariant *data);
|
2014-01-15 19:48:01 +08:00
|
|
|
|
2022-08-24 10:13:25 +08:00
|
|
|
SR_API void ds_free_config(struct sr_config *src);
|
2017-05-23 22:39:00 +08:00
|
|
|
|
2022-10-27 17:22:55 +08:00
|
|
|
/**
|
|
|
|
The session file options value text,convert to code.
|
|
|
|
*/
|
|
|
|
SR_API int ds_dsl_option_value_to_code(int work_mode, int config_id, const char *value);
|
|
|
|
|
2022-08-24 10:13:25 +08:00
|
|
|
/*----------channel----------*/
|
|
|
|
SR_API int ds_enable_device_channel(const struct sr_channel *ch, gboolean enable);
|
2022-07-15 11:57:50 +08:00
|
|
|
|
2022-08-31 16:26:08 +08:00
|
|
|
SR_API int ds_enable_device_channel_index(int ch_index, gboolean enable);
|
|
|
|
|
|
|
|
SR_API int ds_set_device_channel_name(int ch_index, const char *name);
|
|
|
|
|
2022-08-26 13:41:57 +08:00
|
|
|
/**
|
|
|
|
* heck that at least one probe is enabled
|
|
|
|
*/
|
|
|
|
int ds_channel_is_enabled();
|
|
|
|
|
|
|
|
GSList* ds_get_actived_device_channels();
|
|
|
|
|
|
|
|
/*-----------------trigger---------------*/
|
|
|
|
int ds_trigger_is_enabled();
|
|
|
|
|
|
|
|
|
2014-01-15 19:48:01 +08:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|