# Test name: Interlocklimits
# Interlock Limits for Ablenksmagnet
# Copyright (c) 2015 Paul Scherrer Institute. All rights reserved.

###### Init - DO NOT MODIFY THE CODE BELOW ######
global sys, inspect, os, traceback
import sys, inspect, os, traceback


def startTest(testName, DEVICE, params):
    """
    Main method running the test
    """
    # by default, assume the test failed:
    ret = 'Test failed'
    status = False
    # put the whole custom code under try/catch.
    try:
        # get the path of this script:
        testPath = inspect.getfile(inspect.currentframe())
        # init the testing tool class:
        test = TestingTool(testName, testPath, DEVICE, params)

################ END OF Init #####################
######### WRITE YOUR CODE HERE BELOW #############

        """
        All the code in this section # WRITE YOUR CODE HERE BELOW # is just an example and can be modified/deleted.
        It must be indented to the same level as this comment.
        -----------------------------------
                   GETTING INPUTS:
        -----------------------------------
        If needed, the following methods are available:

        test.getPath()        string, path of this test file
        test.getName()        string, name of this test
        test.getDeviceName()  string, device for which the test must run (typically it is the beginning of a process variable name)
        test.getPlotName()    string, name to be given to the plot when using setPlotTitle(). Example: scan.setPlotTitle(test.getPlotName())
        -----------------------------------
                   GETTING TEST PARAMETERS:
        -----------------------------------
        if you need to get parameters for the test, use:

        myParamValue = test.getParam('myParamName')

        the calls to getParam are added to the code automatically, one per parameter, when creating the new test.
        NOTE:  Casting may be necessary.
        See the test config for the list of parameters specific to the test.
        -----------------------------------
                   SETTING OUTPUTS:
        -----------------------------------
        When the test has ended (error or success), this method must be called in order to return to pshell:

        test.sendFeedback(ret,success)

        ret        string,   a text summarizing the result of the test.
        success    bool,     True = test successful. False = test failed.
        -----------------------------------
                   LOG INFO:
        -----------------------------------
        when some information must be shown on the log on pshell, use the following line:
        test.log('text to log')
        """

        ########## Example (can be removed) ######

        # print the list of parameters passed. If any error, stop and send feedback.
        test.log("Test " + test.getName() + " for " + test.getDeviceName() )
        try:
            test.log("Running test with the following parameters:")
            test.printParams()
            ret = 'Success, nothing was done :-)'
            success = True
            test.sendFeedback(ret, success)
            return
            # fetch parameters
            mode = (test.getParam('mode'))
            ilkInExpectedValS = (test.getParam('ilkInExpectedValS'))
            magnetChName = (test.getParam('magnetCh'))
            ilkInChName = (test.getParam('ilkInCh'))
            ilkInExpectedValIni = (test.getParam('ilkInExpectedValIni'))
            ilkOutExpectedValL = (test.getParam('ilkOutExpectedValL'))
            magnetEndVal = int(test.getParam('magnetEndVal'))
            ilkOutChName = (test.getParam('ilkOutCh'))
            ilkOutExpectedValIni = (test.getParam('ilkOutExpectedValIni'))
            ilkOutExpectedValS = (test.getParam('ilkOutExpectedValS'))
            magnetInitVal = int(test.getParam('magnetInitVal'))
            setGetDelay = float(test.getParam('setGetDelay')) 
        except:
            import traceback
            # test failed, write the report into the variables ret and success and send feedback:
            ret = 'Could not retrieve testing parameters - ' + traceback.format_exc()
            success = False
            test.sendFeedback(ret, success)
            return

        rpsMask14 = 0x4440  # mask for outputs 2-4
        rpsMask58 = 0x0004  # mask for output 5        
        ilk = Interlock()
        ilk.setInterlockMode(mode)
        sleep(setGetDelay)
        ilk.masterReset()            
        # loop to read channels for a while and plot the channels values.
        # initialise plot tab with 3 plots:
        scan = ManualScan(['units'], ['Magnet', 'Interlock-In', 'Interlock-Out'])
        # set plot name(tab title):
        scan.setPlotTitle(test.getPlotName())
        # start plots. See further below how to add points to the plots (scan):
        scan.start()       
        # now try with data from real device: this part will most probably fail: correct the PV names with existing ones.
        try:
            # set up connection to channels. "type" of data can be "d" (= double), "l" (= long).
            #magnetCh = Channel(magnetChName  , type='d')
            #ilkInCh  = Channel(ilkInChName   , type='d')
            #ilkOutCh = Channel(ilkOutChName  , type='d')
            print  magnetChName
        except:
            import traceback
            # prepare return information: return text:
            ret = 'Unable to create channel - ' + traceback.format_exc()
            # prepare return information: return success:
            success = False
            # send return information:
            test.sendFeedback(ret, success)
            return
        # check RPS status
        #ilkInVal  = ilkInCh.get()
        #ilkOutVal = ilkOutCh.get()
        ilkInVal  = ilkInExpectedValIni #delete!!
        ilkOutVal = ilkOutExpectedValIni #delete!!
        if (ilkInVal == ilkInExpectedValIni):
            test.log(ilkInChName + ' ok')
        else:
            ret = ilkInChName + ' wrong - expected: ' + ilkInExpectedValIni + ' got: ' + ilkInVal
            success = False
            return
        if ((ilkOutVal & 0x000C) == ilkOutExpectedValIni):
            test.log(ilkOutChName + ' ok')
        else:
            ret = ilkOutChName + ' wrong - expected: ' + ilkOutExpectedValIni + ' got: ' + (ilkOutVal & 0x000C)
            success = False
            return
            
        # start scan of magnet
        # inject a sinus into the plot, as example
        from math import sin
        for sample in range(magnetInitVal, magnetEndVal, 10):
            readback1 = sample #the x axis.
            sleep(0.01)  # settling time.
            # get value (it is translated to a caget):
            magnetVal = sample
            # get value:
            ilkInVal  = sin(float(sample)/10.0)*10.0-10.0
            ilkOutVal = ilkInVal*0.5+10
            # add values to plot:
            scan.append([readback1], [readback1], [magnetVal, ilkInVal, ilkOutVal])

        #magnetCh.close()
        #ilkInCh.close()
        #ilkOutCh.close()
        
        ret = "Success, because..."
        success = True
        ################ End of Example ##########

################ END OF YOUR CODE ################
###### Final - DO NOT MODIFY THE CODE BELOW ######

        # just in case the feedback was forgotten.
        test.sendFeedback(ret, success)
    except (KeyboardInterrupt):
        # user stop error handler.
        import traceback
        ret = 'Test stopped by user.'
        success = False
        test.sendFeedback(ret, success)
    except:
        # generic error handler.
        import traceback
        ret = traceback.format_exc()
        success = False
        test.sendFeedback(ret, success)


# launch the test.
startTest(test, device, parameters)

################ END OF Final ####################
#### IF NEEDED, ADD YOUR FUNCTIONS HERE BELOW ####
# Indent to end left
# def yourCustomFunction:
