Going further with the Fluke 289

[tdjastrzebski]

For those who came across this long running thread.
Two open source tools able to read from Fluke 289 I found:
1. https://sigrok.org/
Usage: sigrok-cli -d fluke-dmm:conn=com6 -C P1 --continuous -O analog
- reads current values only
2. https://github.com/N0ury/dmm_util
- able to read memory-stored recordings but has some parsing bugs, e.g. read average values are way too high
Maybe someone who has knowledge could help? @elafargue ?
See https://github.com/N0ury/dmm_util/issues/3

[HKJ]

For those who came across this long running thread.
Two open source tools able to read from Fluke 289 I found:

There is also (it is not open source):
Forum thread: https://www.eevblog.com/forum/testgear/program-that-can-log-from-many-multimeters/
Download: https://lygte-info.dk/project/TestControllerIntro%20UK.html

Will read from Fluke 289 and more than 400 other devices.

It will log, show curves and a lot of other stuff.

[tdjastrzebski]

I did not mention that but I was particularly interested in reading Fluke 289 memory stored recordings.
There are other open-source solutions on GitHub, e.g.
https://github.com/mikedanylov/meaplot-Fluke289
https://github.com/mrtumnus/fluke-cli
https://github.com/wasle/Fluke289
but they read current values only.

[View[+]Finder]

This is a bunch of simple Python scripts that are useful for accessing data from Fluke 28X meters with the IR remote USB cable.

Code: [Select]

# Created from information provided in Fluke Remote IR documentaton cited in eevblog threads
# buy a Remote Interface from Fluke to access this information, Some come with FlukeView--a form
# completion application--that is well worth the money for paid work by skilled technicians

import serial

ser = serial.Serial()

# Setup serial USB
ser.port = '/dev/cu.usbserial-AC00FZQJ'    # Serial port

# Serial port setup and open
ser.baudrate = 115200
ser.bytesize = serial.EIGHTBITS
ser.parity = serial.PARITY_NONE
ser.stopbits = serial.STOPBITS_ONE
ser.xonxoff = True
ser.rtscts = False
ser.dsrdtr = False
ser.timeout = 0.1  # seconds
try:
    ser.open()
except:
    print("Cannot open serial port...")
    exit()
######################################################
def probe():
    QRSI()  # Put the function you want to probe here, run in IDLE or Thonny, etc.

# to read the current measurement data
def QM():
    ser.write(('qm' + '\r').encode('utf-8'))
    if ser.read():
        data = (ser.read(32).decode('utf-8'))
        for i in range(0 , 4):
            print ((data.split(','))[i])
# example:
# 9.999E0
# VDC
# NORMAL
# NONE
           
# to read the basic meter data   
def ID():
    ser.write(('id' + '\r').encode('utf-8'))
    if ser.read():
        data = (ser.read(32).decode('utf-8'))
        for i in range(0 , 3):
            print ((data.split(','))[i])
   
# to read the "present data that is displayed on the LCD" (Source: Fluke Remote Interface)
def QDDA():
    ser.write(('qdda' + '\r').encode('utf-8'))
    if ser.read():
        data = (ser.read(999).decode('utf-8'))
        for i in range(0 , 28):
            print (str(i) + ' ' + (data.split(','))[i])

# QDDA produces a lot more than the displayed voltage

# this is a binary version of QDDA
def QDDB():
    ser.write(('qddb' + '\r').encode('utf-8'))
    data = (ser.read(999)) #.decode('utf-8'))
    for i in range(0 , len(data)):
        print ( data[i])

# this is the data supporting an automated recording of measurements made by Fluke 28X
# the new firmware supports over a dozen 'recordings' each of which has its own identifing number
# that is shown in the display when viewing memory on the meter. In QRSI use 0-## with ## representing
# the last recording, not the "identifying number" IOW: there are 0 to nn slots holding recordings
# that might have YMMV identifiers. Fluke is clever with this.
def QRSI():
    ser.write(('qrsi 14' + '\r').encode('utf-8'))
    ser.read(2) # the OK 0 and CR
    data = (ser.read(999)) #.decode('utf-8'))
    for i in range(0 , len(data)):
        print (str(i)+','+str((data[i])))
        #print (str((data[i])))
       
# QSRR is reported to be the function that can access individual "samples" in a recording, presumanbly
# with the actual recording identifier obtained frm QRSI. I have not been successful in accessing.
def QSRR(): # No meaningful results yet, sorry
    ser.write((('qsrr 5, 0').encode('utf-8')))
    ser.write(149)
    ser.write(('\r').encode('utf-8'))
    if ser.read(2): # the OK 0 and CR
        data = (ser.read(999)) #.decode('utf-8'))
        print (data)
        for i in range(0 , len(data)):
            print (str(i)+','+str((data[i])))
            #print (((data[i])))
           
# figure this one out, please
def QSLS():
    ser.write(('qsls' + '\r').encode('utf-8'))
    if ser.read():
        data = (ser.read(32).decode('utf-8'))
        print (data)           

       
# this is like 'main' in C
probe()


[View[+]Finder]

For an easy to use measurement print log:
https://github.com/dbbotkin/Fluke289_data_access

[Muessigb]

Seems like it is possible to get screenshots after all...

QLCDBM <offset> will give you 1020 bytes of gzip compressed MS bitmap data at a time.
Read until you get less than 1020 bytes then re-assemble the data and decompress.

The first five bytes of the response + number of digits of the offset have to be dropped at the beginning of each response.
Also the last byte of the response (a carriage return) has to be dropped too.
An offset of zero has the side-effect of actually capturing and compressing the screenshot, so it is latched in future reads to increasing offsets.
There is no provision to indicate how many bytes have to be read and there is no robust framing, so care has to be taken with this.
If you read past the end of the current screenshot's data, the read will succeed and return no data, which can be used as a concrete stop marker.
Voila, there is your screenshot

I found out the above after giving the command pointed out earlier a try and figuring out the details from looking at the responses.
Together with the keyboard remote control command, this enables a whole host of new possibilities