"""
Provide basic class to operate scope
Created by Eugeniy E. Mikhailov 2021/11/29
"""

import pyvisa
import scpi
import re
import numpy as np

class Scope(scpi.SCPIinstr):
    """     
    Do not instantiate directly, use
    rm = pyvisa.ResourceManager()
    Scope(rm.open_resource('TCPIP::192.168.0.2::INSTR'))
    """
    def __init__(self, resource):
        super().__init__(resource)
        
class SDS1104x(Scope):
    """ Siglent SDS1104x scope """
    def __init__(self, resource):
        super().__init__(resource)
        self.resource.read_termination='\n'
        self.maxRequiredPoints = 1000; # desired number of points per channel, can return twice more

    def response2numStr(self, strIn, firstSeparator=None, unit=None):
        # A typical reply of Siglent is in the form 'TDIV 2.00E-08S'
        # i.e. "<prefix><firstSeparator><numberString><unit>
        # prefix='TDIV', firstSeparator=' ', numberString='2.00E-08', unit='S'
        # this function parses the reply
        spltStr = re.split(firstSeparator, strIn)
        prefix = spltStr[0]
        rstr = spltStr[1]
        spltStr = re.split(unit, rstr)
        numberString = spltStr[0]
        unit = spltStr[1]
        return (prefix, numberString, unit)

    def mean(self, chNum):
        # get mean on a specific channel calculated by scope
        # PAVA stands for PArameter VAlue
        qstr = f'C{chNum}:PAVA? MEAN'
        rstr = self.query(qstr); 
        # reply is in the form 'C1:PAVA MEAN,3.00E-02V'
        prefix, numberString, unit = self.response2numStr(rstr, firstSeparator=',', unit='V')
        return(float(numberString))

    def getAvailableNumberOfPoints(self, chNum):
        if chNum != 1 and chNum != 3:
            # for whatever reason 'SAMPLE_NUM' fails for channel 2 and 4
            chNum = 1
        qstr = f'SAMPLE_NUM?  C{chNum}'
        rstr = self.query(qstr)
        # reply is in the form 'SANU 7.00E+01pts'
        prefix, numberString, unit = self.response2numStr(rstr, firstSeparator=' ', unit='pts')
        return(int(float(numberString)))
            
    def getSampleRate(self):
        rstr = self.query('SAMPLE_RATE?');
        # expected reply is like 'SARA 1.00E+09Sa/s'
        prefix, numberString, unit = self.response2numStr(rstr, firstSeparator=' ', unit='Sa/s')
        return(int(float(numberString)))

    def getRawWaveform(self, chNum, availableNpnts=None, maxRequiredPoints=None):
        if availableNpnts == None:
            availableNpnts = self.getAvailableNumberOfPoints(chNum)
        if maxRequiredPoints == None:
            maxRequiredPoints = self.maxRequiredPoints
        
        if availableNpnts <= maxRequiredPoints*2:
            Npnts = availableNpnts
            sparsing = 1
            cstr = f'WAVEFORM_SETUP NP,0,FP,0,SP,{sparsing}'
            self.write(cstr)
        else:
            sparsing = int(np.floor(availableNpnts/maxRequiredPoints))
            Npnts = int(np.floor(availableNpnts/sparsing))
            cstr = f'WAVEFORM_SETUP SP,{sparsing},NP,{Npnts},FP,0'
            # Note: it is not enough to provide sparsing (SP),
            # number of points (NP) needed to be calculated properly too!
            # From the manual
            # WAVEFORM_SETUP SP,<sparsing>,NP,<number>,FP,<point> 
            # SP Sparse point. It defines the interval between data points.
            # For example:
            #   SP = 0 sends all data points.
            #   SP = 1 sends all data points.
            #   SP = 4 sends every 4th data point
            # NP — Number of points. It indicates how many points should be transmitted.
            # For example:
            #   NP = 0 sends all data points.
            #   NP = 50 sends a maximum of 50 data points.
            # FP — First point. It specifies the address of the first data point to be sent.
            # For example:
            #   FP = 0 corresponds to the first data point.
            #   FP = 1 corresponds to the second data point

        qstr = f'C{chNum}:WAVEFORM? DAT2'
        wfRaw=self.query_binary_values(qstr, datatype='b', header_fmt='ieee', container=np.array) 
        # expected full reply: 'C1:WF DAT2,#9000000140.........'
        return(wfRaw, availableNpnts, sparsing)

    def getChanVoltsPerDiv(self, chNum):
        qstr = f'C{chNum}:VDIV?'
        rstr = self.query(qstr)
        # expected reply to query: 'C1:VDIV 1.04E+00V'
        prefix, numberString, unit = self.response2numStr(rstr, firstSeparator=' ', unit='V')
        return(float(numberString))

    def getChanOffset(self, chNum):
        qstr = f'C{chNum}:OFST?'
        rstr = self.query(qstr)
        # expected reply to query: 'C1:OFST -1.27E+00V'
        prefix, numberString, unit = self.response2numStr(rstr, firstSeparator=' ', unit='V')
        return(float(numberString))

    def getTimePerDiv(self):
        qstr = f'TDIV?'
        rstr = self.query(qstr)
        # expected reply to query: 'TDIV 2.00E-08S'
        prefix, numberString, unit = self.response2numStr(rstr, firstSeparator=' ', unit='S')
        return(float(numberString))

    def getTrigDelay(self):
        qstr = f'TRIG_DELAY?'
        rstr = self.query(qstr)
        # expected reply to query: 'TRDL -0.00E+00S'
        prefix, numberString, unit = self.response2numStr(rstr, firstSeparator=' ', unit='S')
        return(float(numberString))


    def getWaveform(self, chNum, availableNpnts=None, maxRequiredPoints=None):
        wfRaw, availableNpnts, sparsing = self.getRawWaveform(chNum, availableNpnts=availableNpnts, maxRequiredPoints=maxRequiredPoints)
        vertDivOnScreen = 10
        VoltageOffset = self.getChanOffset(chNum)
        VoltsPerDiv = self.getChanVoltsPerDiv(chNum)
        return( wfRaw * VoltsPerDiv * vertDivOnScreen/250 -VoltageOffset, availableNpnts, sparsing)

    def getTimeTrace(self, sparsing=1, Npnts=None):
        sampleRate = self.getSampleRate()
        timePerDiv = self.getTimePerDiv()
        trigDelay  = self.getTrigDelay()
        if Npnts == None:
            # using channel 1 as reference
            Npnts = self.getAvailableNumberOfPoints(1)
        time = np.arange(Npnts) / sampleRate * sparsing;
        horizDivOnScreen = 14
        time = time - timePerDiv * horizDivOnScreen/2 - trigDelay
        return(time)
        

if __name__ == '__main__': 
    print("testing")
    rm = pyvisa.ResourceManager()
    print(rm.list_resources())    
    instr=rm.open_resource('TCPIP::192.168.0.61::INSTR')
    scope = SDS1104x(instr)
    print(scope.idn)
    print(scope.mean(1))
    print(scope.getAvailableNumberOfPoints(1))
    print(scope.getSampleRate())
    print(scope.getTimePerDiv())
    print(scope.getChanVoltsPerDiv(1))
    print(scope.getChanOffset(1))
    wf = scope.getWaveform(4)
    time = scope.getTimeTrace()