Write or read ASCII data in memory
|
8860, 8861
|
Syntax
|
(Command)
(Query)
|
:MEMory:ADATa B,C,D,...
:MEMory:ADATa? A
|
(Response)
|
B<NR1>,C<NR1>,D<NR1>,...
A = 1 to 200
|
Details
|
Writes the argument data into memory at the read/write pointer (channel and pointer offset) specified
by the :MEMory:POINt command.
Multiple data values are written sequentially from the pointer specified and returned
by the :MEMory:POINt command.
The read/write pointer is incremented by the number of data values (words/bytes) written.
Reads the specified number (A) of data values from the memory pointer (channel and pointer offset)
specified and returned by the :MEMory:POINt command.
The read/write pointer is incremented by the number of data values (words/bytes) read.
This command cannot be executed while measuring.
[Relationship between stored and physical data]
Data stored in memory has following relationships.

(Measured value) = (Data value) * (Current range) / (Coefficient(note))
(NOTE): The coefficients are as follows.
8936
|
8937
|
8938
|
8939
|
Analog module
|
Voltage / Temperature module
|
FFT module
|
Strain module
|
1280
|
1280
|
1280
|
1280
|
|
|
|
|
8940
|
8946
|
8947
|
8956
|
F/V module
|
4-Ch module
|
Charge module
|
High-speed module
|
1280
(note 1)
1024
(note 1)
1600
(note 2)
|
1280
|
1280
(note 3)
|
1600
|
|
|
|
|
8957
|
8958
|
8959
|
8960
|
High-resolution module
|
Scanner module
|
DC / RMS module
|
DC strain module
|
1600
|
1600, 1000
(note 4)
|
1280
|
1600
|
Note 1 When the clamp range is set to 500A, the coefficient of the F/V module is as follows.
Range
|
100 mA/DIV
|
200 mA/DIV
|
500 mA/DIV
|
1 A/DIV
|
2 A/DIV
|
5 A/DIV
|
10 A/DIV
|
20 A/DIV
|
50 A/DIV
|
100 A/DIV
|
Coefficient
|
1024
|
1024
|
1280
|
1024
|
1024
|
1280
|
1024
|
1024
|
1280
|
1024
|
Note 2 The coefficient of the F/V module is 1600 when the 50/60 Hz mode is selected.
Note 3 The coefficient of the Charge module is as follows when the capacity or preamp mode is selected.
Sensitivity
|
... 0.25
|
... 0.5
|
... 1.0
|
... 2.5
|
... 5.0
|
... 10
|
Coefficient
|
80x / 0.25
|
80x / 0.5
|
80x / 1.0
|
80x / 2.5
|
80x / 5.0
|
80x / 10
|
"x" indicates the sensitivity multiplier.
Note 4 The coefficient is 1000 when the temperature mode is selected.
|
Example
|
:MEMory:POINt CH1_1,0
(Selects channel CH1-1 and sets the pointer offset to 0 for storing data in memory.)
:MEMory:ADATa 100,200,300
(Writes ASCII data values 100, 200 and 300 into memory.)
:MEMory:ADATa? 10
(Reads 10 ASCII data values from memory.)
(Response) :MEMory:ADATA 1,2,3,4,5,6,7,8,9,10 (when headers are enabled)
|
Note
|
When recording 1000 divisions of 4 Vpp, 1 kHz sine wave data using the 100 mV range,
the time required to send the command ":MEMory:ADATa? 200" 500 times is
about 20 seconds using a direct Ethernet connection to the PC
(running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only,
and depend on the actual data transfer speed of the LAN connection.
Refer to the :MEMory:RATIo? command description regarding conversion of waveform data to physical values.
|
Usage Conditions
|
MEM, REAL, REC&MEM
Providing that;
measurement is not taking place,
the memory read/write pointer is below the address of the stored data,
the analog channel is that specified by :MEMory:POINt,
and either stored data is present or the memory has been prepared by :MEMory:PREPare.
|
Read stored data as binary code
|
8860, 8861
|
Syntax
|
(Query)
|
:MEMory:BDATa? A
|
(Response)
|
#0...(binary data)
A = 1 to 1000
|
Details
|
Returns in binary format the specified number (A) of data words stored beginning at the location returned by
the :MEMory:POINt command.
The read/write pointer is incremented by the specified number of data words/bytes.
The read data is structured as follows:
(1) Initially: "#0" (Indicates binary format)
(2) After "#0", the number of data words specified by A is returned.
(3) In the case of analog data, both bytes are significant, while for logic data, only the lower (half of each) byte is significant.

Upper byte
|
Lower byte
|
xxxx
|
xxxx
|
xxxx
|
xxxx
|
Analog channel data
|
|
Data: N
|
Data: N+1
|
0000
|
xxxx
|
0000
|
xxxx
|
Logic channel data: 1
|
Logic channel data: 2
|
(x means 0 or 1.)
Refer to the :MEMory:COEFf? command description regarding conversion of binary data into physical values.
|
Example
|
:MEMory:POINt CH1_1,0
(Selects channel CH1-1 and sets the pointer offset to 0 for the data stored in memory.)
:MEMory:BDATa? 10
(Reads 10 data words in binary format.)
(Response) :MEMORY:BDATA #0...(binary format) (when headers are enabled)
|
Note
|
Binary data may include delimiter codes such as 0Ah or 0Dh.
If the PC software misinterprets such codes as data terminators, the PC will not handle the data correctly,
so the PC software should always read the number of words specified by A.
Data cannot be written directly in binary format.
When recording 1000 divisions of 4 Vpp, 1 kHz sine wave data using the 100 mV range,
the time required to send the command ":MEMory:BDATa? 1000" 100 times is about 20 seconds
using a direct Ethernet connection to the PC (running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only, and depend on the actual data transfer speed of the LAN connection.
|
Usage Conditions
|
MEM, REAL, REC&MEM
Providing that
measurement is not taking place,
the memory read/write pointer is below the address of the stored data,
and stored data is present.
|
Query the ratio and offset coefficients for converting stored data into physical values
|
8860, 8861
|
Syntax
|
(Query)
|
:MEMory:COEFf? CH$
|
(Response)
|
CH$,A<NR3>,B<NR3>
CH$ = CHm_n, Z1 to Z16
A = Ratio
B = Offset
|
Details
|
Returns coefficients for converting data read with
the :MEMory:BDATa? and
:MEMory:RECBData? commands into physical values.
The equation used to convert the data into physical values is:
(Physical value) = A * (Data) + B
|
Example
|
:MEMory:COEFf? CH1_1
(Response) :MEMORY:COEFF CH1_1,390.625000E-06,-12.6312500E+00 (when headers are enabled)
|
Note
|
-
|
Usage Conditions
|
MEM, REC, REAL, REC&MEM
When not measuring, and when stored data is present.
|
Read/write logic data
|
8860, 8861
|
Syntax
|
(Command)
(Query)
|
:MEMory:LDATa B,C,D,...
:MEMory:LDATa? A
|
(Response)
|
B<NR1>,C<NR1>,D<NR1>,...
A = 1 to 500
B, C, D,... = 0 to 15
|
Details
|
Writes the argument data into memory at the read/write pointer (logic channel and pointer offset) specified by
the :MEMory:POINt command.
Multiple data bytes are written sequentially from the pointer specified and returned by
the :MEMory:POINt command.
The read/write pointer is incremented by the number of data bytes written.
Reads the specified (A) number of data bytes from the memory pointer (channel and pointer offset) specified and returned by
the :MEMory:POINt command.
The read/write pointer is incremented by the number of data bytes read.
The four subchannels in each logic channel group (A to D) are encoded
in the lower four bits of the NR1 data bytes, as shown in the following example.
Bit
|
7
|
6
|
5
|
4
|
3
|
2
|
1
|
0
|
Data
|
0
|
0
|
0
|
0
|
L4
|
L3
|
L2
|
L1
|
(Lower bit values (L1 to L4) can be 0 (Low) or 1 (High)).
The decimal data value "10" = the binary value "00001010".
|
Example
|
:MEMory:POINt CHA,0
(Selects logic channel CHA and sets the index to 0 for the data stored in memory.)
:MEMory:LDATa 15,14,13,12
(Writes the data byte values 15, 14 and 13 to memory.)
:MEMory:LDATa? 10
(Response) :MEMORY:LDATA 1,2,3,4,5,6,7,8,9,10 (when headers are enabled)
|
Note
|
When recording 1000 divisions of logic waveform data input, the time required to send the command
":MEMory:LDATa? 500" 200 times is about 7 seconds using a direct Ethernet connection to the PC
(running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only, and depend on the actual data transfer speed of the LAN connection.
|
Usage Conditions
|
MEM, REAL, REC&MEM
Providing that;
measurement is not taking place,
the memory read/write pointer is below the address of the stored data,
the logic channel is specified by :MEMory:POINt
and the stored data is present or the memory has been prepared by :MEMory:PREPare.
|
Query the amount of data stored
|
8860, 8861
|
Syntax
|
(Query)
|
:MEMory:MAXPoint?
|
(Response)
|
A<NR1>
A = 0 (no data stored) to (the number of stored data bytes/words)
|
Details
|
Returns the number of data bytes/words stored in memory as a numerical value in NR1 format.
|
Example
|
:MEMory:POINt CH1_1,0
(Selects channel CH1-1 and sets the pointer offset to 0 for the data stored in the memory.)
:MEMory:MAXPoint?
(Response) :MEMORY:MAXPOINT 2501 (when headers are enabled)
|
Note
|
The number of stored data bytes/words depends on the channel specified with
the :MEMory:POINt command.
Different values can therefore be obtained for different channels if Timebase 2 sampling is being used.
|
Usage Conditions
|
MEM, REC, REAL, REC&MEM
When not measuring
|
Set and query the memory read/write pointer
|
8860, 8861
|
Syntax
|
(Command)
(Query)
|
:MEMory:POINt CH$,A
:MEMory:POINt?
|
(Response)
|
CH$,A<NR1>
CH$ = CHm_n, CHx, Z1 to Z16
A = 0 to (number of stored data bytes/words)
|
Details
|
Sets the read/write pointer in instrument memory.
Returns the current memory read/write pointer location as a channel and pointer offset as an NR1 numerical value.
|
Example
|
:MEMory:POINt CH1_1,100
:MEMory:POINt?
(Response) :MEMORY:POINT CH1_1,100 (when headers are enabled)
|
Note
|
If there is no stored data, the read/write pointer cannot be set.
Argument A can be set only to a value less than that returned by the :MEMory:MAXPoint? command.
When measuring with the real-time function,
valid values for A depend on the current waveform display.
A shows always the point from the head of stored data.
Therefore the positions between "whole waveform" and "measurement waveform"
is different.
The POINT command during the REC&MEM function (including MAXPOINT) is dedicated to the MEM waveform.
To extract the REC waveform, switch to REC function.
|
Usage Conditions
|
MEM, REC, REAL, REC&MEM
|
Write and read data as ASCII code
|
8860, 8861
|
Syntax
|
(Command)
(Query)
|
:MEMory:RECAData B1,B2,C1,C3,D1,D2,...
:MEMory:RECAData? A
|
(Response)
|
B1<NR1>,B2<NR1>,C1<NR1>,C2<NR1>,D1<NR1>,D2<NR1>,...
A = 1 to 100
B1,B2,C1,C2,D1,D2,... = -32768 to 32767
|
Details
|
Writes the argument data into memory at the read/write pointer (channel and pointer offset)
specified and returned by the :MEMory:POINt command.
Multiple data words are written sequentially from the pointer specified
by the :MEMory:POINt command,
and the read/write pointer is incremented by the number of data words written.
Reads the number of data words specified by A from the memory pointer (channel and pointer offset)
specified and returned by the :MEMory:POINt command.
With the Recorder function,
each data object consists of two data words: the maximum and the minimum measurements during the sampling interval.
For example, in the response B1, B2, C1, C2, the B1 and B2 words comprise the first data object,
in which B1 is the maximum value and B2 is the minimum value measured during the sampling interval.
Similarly, C1 and C2 comprise the maximum and minimum values, respectively, measured during the sampling interval of the second data object.
This command cannot be executed during startup.
* Refer to the :MEMory:ADATa command description
for details about the relationship between storage data and voltage values.
|
Example
|
:MEMory:POINt CH1_1,0
(Selects channel CH1-1 and sets the pointer offset to 0 for stored data in the memory.)
:MEMory:RECAData 200,100,50,10
(Writes the data objects [200, 100] and [50, 10] to memory.)
:MEMory:RECAData? 2
(Reads two objects (four data words) of storage data.)
(Response) :MEMORY:RECADATA 20,10,50,30 (when headers are enabled)
|
Note
|
When recording 1000 divisions of 4 Vpp, 50 Hz sine wave data using the 100mV range,
the time required to send the command ":MEMory:RECAdata? 100" 1000 times
is about 60 seconds using a direct Ethernet connection to the PC
(running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only, and depend on the actual data transfer speed of the LAN connection.
|
Usage Conditions
|
REC, REAL
Providing that:
measurement is not taking place,
the memory read/write pointer is below the address of the stored data,
and the stored data is present or the memory has been prepared by :MEMory:PREPare.
|
Read stored data as binary code
|
8860, 8861
|
Syntax
|
(Query)
|
:MEMory:RECBData? A
|
(Response)
|
#0...(binary data)
A = 1 to 500
|
Details
|
Returns in binary format the specified number (A) of data words stored beginning
at the read/write pointer (channel and pointer offset) returned by MEMory:POINt.
The read/write pointer is incremented by the number of data words.
Refer to the MEMory:BDATa command description for details about the returned data.
With the Recorder function,
each data object consists of two words: the maximum and the minimum measurements during the sampling interval.
The data sequence is identical to that of the :RECAData command:
maximum and minimum values during the first sampling interval,
followed by maximum and minimum values during the second sampling interval, and so on.
Refer to the :MEMory:COEFf? command regarding conversion of the data into physical values.
|
Example
|
:MEMory:POINt CH1_1,0
(Selects channel CH1-1 and sets the pointer offset to 0 for the stored data.)
:MEMory:RECBdata? 10
(Reads 10 samples (20 data words) of storage data.)
(Response) :MEMORY:RECBDATA #0...(binary format) (when headers are enabled)
|
Note
|
This command cannot be executed during startup.
When recording 1000 divisions of 4 Vpp, 1 kHz sine wave data using the 100 mV range,
the time required to send the command ":MEMory:RECBdata? 500" 200 times is about 40 seconds
using a direct Ethernet connection to the PC
(running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only, and depend on the actual data transfer speed of the LAN connection.
|
Usage Conditions
|
REC, REAL
Providing that the stored data is present.
|
Write and read logic data
|
8860, 8861
|
Syntax
|
(Command)
(Query)
|
:MEMory:RECLData B1,B2,C1,C2,D1,D2,...
:MEMory:RECLData? A
|
(Response)
|
B1<NR1>,B2<NR1>,C1<NR1>,C2<NR1>,D1<NR1>,D2<NR1>,...
A = 1 to 250
B1, B2, C1, C2, D1, D2,.... = 0 to 15
|
Details
|
Writes the argument data into memory at the read/write pointer (logic channel and pointer offset)
specified and returned by the :MEMory:POINt command.
Multiple data objects are written sequentially from the pointer specified and returned
by the :MEMory:POINt command, and the read/write pointer is incremented
by the number of data objects written.
Reads the specified number (A) of data objects from the memory pointer (channel and pointer offset)
specified and returned by the :MEMory:POINt command.
With the Recorder function,
each data object consists of two data bytes:
the OR (logical sum) and the AND (logical product) values of sequential samples along the time axis.
For example, in the response B1, B2, C1, C2, the B1 and B2 values comprise the first data object,
in which B1 is the logical sum and B2 is the logical product.
Similarly, C1 and C2 are the logical sum and logical product of the second pair of samples.
This command cannot be executed during startup.
* Refer to the :MEMory:LDATa? command description for details about logic data storage.
|
Example
|
:MEMory:POINt CHA,0
(Selects logic channel CHA and sets the pointer offset to 0 for the stored data in the memory.)
:MEMory:RECLData 15,0,14,1
(Writes data objects [15, 0] and [14, 1] to memory.)
:MEMory:RECLData? 2
(Reads two data objects (four data bytes) from memory.)
(Response) :MEMORY:RECLDATA 10,2,13,5 (when headers are enabled)
|
Note
|
When recording 1000 divisions of logic waveform data input,
the time required to send the command ":MEMory:RECLData? 250" 400 times
is about 15 seconds using a direct Ethernet connection to the PC
(running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only, and depend on the actual data transfer speed of the LAN connection.
|
Usage Conditions
|
REC, REAL
Providing that;
measurement is not taking place,
the memory read/write pointer is below the address of the stored data,
the logic channel is selected by :MEMory:POINt
and the stored data is present or the memory has been prepared by :MEMory:PREPare.
|
Write and read stored data (measured values)
|
8860, 8861
|
Syntax
|
(Command)
(Query)
|
:MEMory:RECVData B1,B2,C1,C2,...
:MEMory:RECVData? A
|
(Response)
|
B1<NR3>,B2<NR3>,C1<NR3>,C2<NR3>,...
A = 1 to 50
B1, B2, C1, C2,... = Physical values
|
Details
|
Writes the argument data into memory at the read/write pointer (logic channel and pointer offset) specified and returned
by the :MEMory:POINt command.
Multiple data objects are written sequentially from the pointer specified and returned
by the MEMory:POINt command, and the read/write pointer is incremented
by the number of data objects written.
Reads the number of data objects (A) from the memory pointer (channel and pointer offset) specified and returned
by the :MEMory:POINt command.
With the Recorder function,
each data object consist of two words: the maximum and the minimum measurements during the sampling interval.
For example, in the response B1, B2, C1, C2: the B1 and B2 values comprise the first data object,
in which B1 is the maximum value and B2 is the minimum value measured during the first sampling interval.
Similarly, C1 and C2 comprise the maximum and minimum values, respectively, measured during the second sampling interval.
This command cannot be executed during startup.
* Scaled values are returned when scaling is enabled.
|
Example
|
:MEMory:POINt CH1_1,0
(Selects channel CH1-1 and sets the pointer offset to 0 for the stored data.)
:MEMory:RECVData 5.1E-03,3.2E-03,0.0123,0.00050
(Writes the data 5.1E-03, 3.2E-03, 0.0123, and 0.00050 into memory.)
:MEMory:POINt CH1_1,0
:MEMory:RECVData? 2
(Reads two samples (four data words) of storage data.)
(Response) :MEMORY:RECVDATA +5.10E-03,+3.20E-03,+12.30E-03,+5.00E-03 (when headers are enabled)
|
Note
|
When recording 1000 divisions of 4 Vpp, 50 Hz sine wave data using the 100mV range,
the time required to send the command ":MEMory:RECVdata? 50" 2000 times is about 150 seconds
using a direct Ethernet connection to the PC
(running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only, and depend on the actual data transfer speed of the LAN connection.
|
Usage Conditions
|
REC, REAL
Providing that;
measurement is not taking place,
the memory read/write pointer is below the address of the stored data,
the analog channel is selected by :MEMory:POINt
and the stored data is present or the memory has been prepared by :MEMory:PREPare.
|
Write and read stored data (measured values)
|
8860, 8861
|
Syntax
|
(Command)
(Query)
|
:MEMory:VDATa B,C,D,...
:MEMory:VDATa? A
|
(Response)
|
B<NR3>,C<NR3>,D<NR3>,...
A = 1 to 100
B, C, D,... = Physical values
|
Details
|
Writes the argument data into memory at the read/write pointer (channel and pointer offset) specified and returned
by the :MEMory:POINt command.
Multiple data values are written sequentially from the pointer specified and returned
by the :MEMory:POINt command,
and the read/write pointer is incremented by the number of data values written.
Reads the number of data objects specified by A from the memory pointer (channel and pointer offset) specified and returned
by the :MEMory:POINt command.
The read/write pointer is incremented by the number of data words read.
This command cannot be executed while measuring.
Scaled values are written and read when scaling is enabled.
|
Example
|
:MEMory:POINt CH1_1,0
(Selects channel CH1-1 and sets the pointer offset to 0 for the stored data.)
:MEMory:VDATa 1,234E-03,4.567E-04
(Writes the data 1.234E-03 and 4.567E-04 to memory.)
:MEMory:VDATa? 2
(Reads two data words from memory.)
(Response) :MEMORY:VDATA +5.678E-03,+4.321E-03 (when headers are enabled)
|
Note
|
When recording 1000 divisions of 4 Vpp, 1 kHz sine wave data using the 100 mV range,
the time required to send the command ":MEMory:VDATa? 100" 1000 times is about 50 seconds
using a direct Ethernet connection to the PC
(running Microsoft Windows XP on a 1.2 GHz Celeron CPU and 256 MB RAM).
Please note that these values are for reference only, and depend on the actual data transfer speed of the LAN connection.
|
Usage Conditions
|
MEM, REAL, REC&MEM
Providing that;
measurement is not taking place.
the memory read/write pointer is below the address of the stored data,
the analog channel is selected by :MEMory:POINt
and the stored data is present or the memory has been prepared by :MEMory:PREPare.
|