[To be fixed]

test/realtime_graph/Control_Interface/controlInterface.py

+
+from NHR9400series.NHR9410 import NHR9410
+from NHR9400series.NHR9430 import NHR9430
+from UtilitiesRei.IPFinder import IPFinder
+
+class controlInterface:
+    
+    def __init__(self):
+        self.__listIp = IPFinder().getList()
+        self.__listUsedIp = []
+        self.__nhr9410 = []
+        self.__nhr9430 = []
+
+    #refresh the list of ip
+    def refresh(self):
+        self.__listIp = IPFinder().getList()
+        for ip in self.__listUsedIp:
+            self.__listIp.remove(ip)
+    
+    #create a NHR object 
+    def newNhr(self, nhr):
+        if(nhr == "9410"):
+            new = NHR9410()
+           
+        elif nhr == "9430":
+            new = NHR9430()
+        else:
+            return -1
+        new.locateIp(self.__listIp)
+        new.setS()
+        
+        usedIp = new.getIp()
+        try:
+            self.__listIp.remove(usedIp)
+            self.__listUsedIp.append(usedIp)
+            if nhr == "9410":
+                self.__nhr9410.append(new)
+            elif nhr == "9430":
+                self.__nhr9430.append(new)
+            else:
+                return -1
+        except:
+            print("Any IP address matched")
+
+    def getNhr9410(self):
+        return self.__nhr9410
+        
+    def getNhr9430(self):
+        return self.__nhr9430
+
+    def getListIp(self):
+        return self.__listIp

test/realtime_graph/Control_Interface/tempCodeRunnerFile.py

+
+        usedIp = new.getIp()
\ No newline at end of file

test/realtime_graph/NHR9400series/NHR9400.py

+from abc import abstractmethod
+import socket
+import time
+from UtilitiesRei.refineOutput import refineOutput
+
+
+class NHR9400():
+    
+    def __init__(self, name):
+        self.__name = name
+        self.__s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
+        self.__s.settimeout(1)
+        self.__ip = ""
+
+################################# Configurations ######################################################
+    #Default start: Enable all instruments and close output relays and starts an aperture measurement on all channels which will run for the time specified by the last received SENSe:SWEep:APERture instrument command
+    #!!!!!! upgrade this function later
+    def start(self):
+        self.__s.send("SOUR:OUTP:ON 1\n".encode())
+        self.__s.send("INIT\n".encode())
+
+    def locateIp(self, clients = []):
+        for client in clients:
+            try:
+
+                self.__s  = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
+                self.__s.connect((client, 5025))
+                self.__s.send("*RST".encode())
+                self.__s.send("SYST:RWL\n".encode()) #Command to activate remote control and locking the touchscreen
+                self.__s.send("*IDN?\n".encode())
+                msg = self.__s.recv(1024)
+                recv = self.receiveString(msg)
+                id = "NH Research," + str(self.__name)
+                if recv.find(id) != -1: #if find this subtring 
+                    self.__ip = client
+                    print(self.__ip)
+                    print("Connection successfully")
+                    break
+                else:
+                    self.__s.close()
+            except:
+                print("Connection failed 2")
+
+    def getIp(self):
+        return self.__ip
+
+    def getS(self):
+        return self.__s
+
+    #chose a mode with the instrument will run, check the manual to see all modes.
+    def configMode(self, mode):
+        if mode < 0 and mode > 16:
+            print("INVALID INPUT")
+        else:
+            self.__s.send(("CONF:HW:MODE " + str(mode) + "\n").encode())
+            self.checkErrors()
+            self.validMode()
+    #check if the mode is valid for the current hardware
+    def validMode(self):
+        self.__s.send("CONF:HW:MODE:VAL".encode())
+        print(self.receiveString())
+
+    #Command configures if [SOURCe:]<Function> commands are immediately or phase-angle controlled Query returns the synchronous operating mode
+    def instrumentSync(self, value):
+        if value == 0 or value == 1:
+            self.__s.send(("CONF:INST:SYNC "+ str(value) + "\n").encode())
+        else:
+            print("INVALID INPUT")
+
+    #The 9400 will contain one (1), two (2), or three (3) logical instruments depending on the CONFigure:HW:MODE selected. Unless otherwise noted in a specific command, Any command or queries with an INSTRUMENT scope will be processed by the last instrument selected by either an INSTrument:NSELect or an INSTrument:SELect.
+    def instrumentNselect(self, value):
+        if value < 1 or value > 3:
+            print("INVALID INPUT")
+        else:
+                self.__s.send(("INST:NSEL " + str(value) + "\n").encode())
+        self.checkErrors()
+
+    #Command selects an instrument by its alias name created with INSTrument:DEFine[:NAME]. Query returns the current selected logical instrument alias name.
+    #check this command, maybe something wrong
+    def instrumentSelect(self):
+        self.__s.send("INST:SEL".encode())
+        self.checkErrors()
+
+    #Command assigns an alias name allowing selection of the instrument using INSTrument:SELect <name> Query returns the alias name assigned to a specific output channel.
+
+    def instrumentDefName(self, name, num):
+        self.instrumentNselect(num)
+        self.__s.send(("INST:DEF:" + str(name) + "\n").encode())
+        self.checkErrors()
+    #Command disassociates an <identifier> alias from the logical instrument number.
+    #After the command executes, the default identifier is re-associated with the instrument number.
+    #The default identifier cannot be deleted.
+    def instDelName(self, name):
+        self.__s.send(("INST:DEL:" + str(name) + "\n").encode())
+        self.checkErrors()
+    #Query returns the <identifier> alias for the requested instrument number.
+    #If no instrument number is provided, the <identifier> of the selected instrument is returned.
+    def instrumentName(self, num):
+        if num < 1 or num > 3:
+            print("INVALID INPUT")
+        else:
+                self.__s.send(("INST:NAME " + str(num) + "\n").encode())
+        self.checkErrors()
+    #Function that receives messages back and transform it in a string
+    def receiveString(self,recv):
+        recv = refineOutput().byteToString(recv)
+        return recv
+
+    #Function that receives messages back and transform it in a float
+    def receiveFloat(self, msg):
+        msg = refineOutput().byteToFloat(msg)
+        return msg
+
+    #Function that receives messages back and transform it in a array
+    def receiveArray(self, msg):
+        msg = refineOutput().byteToArray(msg)
+        return msg
+
+    def identify(self):
+        self.__s.send("*IDN?\n".encode())
+        return self.receive()
+    #Function to see if exist any error in the carry
+    def checkErrors(self):
+        self.__s.send("SYST:ERR?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveString(value)
+
+    def close(self):
+        self.__s.send("SOUR:OUTP:ON 0\n".encode())
+        self.__s.send("ABOR\n".encode())
+        self.__s.send("SYST:LOC\n".encode())
+        self.__s.close()
+
+    # Controle do relé de saída do hardware (LIGAR OU DESLIGAR)
+    # 0 OFF - Instrumento desabilitado
+    # 1 ON - Instrumento habilitado
+    def enableOutput(self, value):
+        if value == 0 or value == 1:
+            self.__s.send(("SOUR:OUTP:ON "+ str(value) + "\n").encode())
+        else:
+            print("INVALID INPUT")
+################################# System command #####################################################
+    #Command places the touch panel (if present) in local control mode. All front panel keys are returned to a functional state.
+    def systLocal(self):
+        self.__s.send("SYST:LOC\n".encode())
+    #Command or receipt of an external SCPI command places the touch panel in a non-locked remote mode.
+    def systRemote(self):
+        self.__s.send("SYST:REM\n".encode())
+    #Query returns the SCPI version number to which the module complies. The value is of the form YYYY.V, where YYYY is the year and V is the revision number for that year.    
+    def systVersion(self):
+        self.__s.send("SYST:VER\n".encode())
+    #Command specifies the interval (Seconds) in which a command must be received. Query returns the programmed watchdog interval (Seconds).
+    def systWatchdogInterval(self, interval):
+        if interval < 0: return -1
+        self.__s.send(("SYST:WATC:INT " + str(interval) +"\n").encode())
+        self.__s.send(("*RST\n").encode())
+        self.__s.send("SYST:RWL\n".encode())
+
+    #Command determines the type communication required to reset the watchdog timer. Query returns the type of communication required to reset the watchdog timer.
+    def systWatchdogRobust(self, bool):
+        if bool != 0 or bool != 1: return -1
+        self.__s.send(("SYST:WATC:ROB " + str(bool) +"\n").encode())
+        self.__s.send(("*RST\n").encode())
+        self.__s.send("SYST:RWL\n".encode())
+    
+    #Command resets watchdog timer
+    def systWatchdogService(self):
+        self.__s.send(("SYST:WATC:SERV\n").encode())
+        self.__s.send(("*RST\n").encode())
+        self.__s.send("SYST:RWL\n".encode())
+        
+
+################################# Digital Subsystem ############################
+
+    #Query returns the current state of the general purpose digital input port on the specified module.
+    def digitalInput(self):
+        self.__s.send(("DIG:INP\n").encode())
+    #Query returns the number of general purpose digital inputs (expressed as number of bits).
+    def digitalInputCount(self):
+        self.__s.send(("DIG:INP:COUN\n").encode())
+    #Command sets the state of the general purpose digital output port on the specified module. Query returns the last programmed state of the general purpose digital output
+    def digitalOutput(self):
+        self.__s.send(("DIG:OUT\n").encode())
+    #Query returns the number of general purpose digital outputs (expressed as number of bits).
+    def digitalInputCount(self):
+        self.__s.send(("DIG:OUT:COUN\n").encode())
+################################# Instrument Capabilities - System Information Queries ##############################
+
+# Query returns the number of output channels detected by the hardware.
+    def instrumentSystemChanels(self):
+        self.__s.send(("INST:CAP:SYST:CHAN?\r\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveString(value)
+    
+# Query returns the number of chassis detected (Master + Auxiliaries)
+    def instrumentSystemChassis(self):
+        self.__s.send(("INST:CAP:SYST:CHAS?\n").encode()) 
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+#Query returns the maximum number of commands which can be stored in a macro
+    def instrumentSystemMacros(self):
+        self.__s.send(("INST:CAP:MACR:COMM:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+#Query returns the maximum delay time allowed for MACRo:WAIT[:TIME] within a single macro step.
+    def instrumentSystemMacroDelay(self):
+        self.__s.send(("INST:CAP:MACR:DEL:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+#Query returns the default Regulation Gain setting set value used by the hardware.
+    def instrumentSystemRGainNominal(self):
+        self.__s.send(("INST:CAP:RGA:NOM?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+#Query returns the maximum Regulation Gain setting set value used by the hardware.
+    def instrumentSystemRGainMax(self):
+        self.__s.send(("INST:CAP:RGA:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+#Query returns the maximum trip time (seconds) for a safety limit settings
+    def instrumentSystemTripMax(self):
+        self.__s.send(("INST:CAP:TRIP:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+################################# Instrument Capabilities - Measurement Capabilities Queries ############################## 
+#Query returns a list with the absolute maximum and minimum measurement aperture setting for the module.
+    def instrumentSystemApertureRange(self):
+        range = []
+        self.__s.send(("INST:CAP:APER:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:APER:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+
+#Query returns the absolute peak current measurement capability for instrument selected.
+    def instrumentSystemCurrent(self):
+        range = []
+        self.__s.send(("INST:CAP:CURR:MEAS:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:CURR:MEAS:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+#Query returns maximum (minimum) peak current measurement for the selected instrument & range
+    def instrumentSystemCurrentRange(self):
+        range = []
+        self.__s.send(("INST:CAP:CURR:MEAS:RANG:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:CURR:MEAS:RANG:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+#Query returns the waveform digitizer’s maximum (minimum) sample frequency in Hz.
+    def instrumentSystemFreq(self):
+        range = []
+        self.__s.send(("INST:CAP:SAMP:FREQ:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:SAMP:FREQ:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+
+#Query returns the waveform digitizer’s maximum sample memory depth
+    def instrumentSamplePoints(self):
+        self.__s.send(("INST:CAP:SAMPl:POIN:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+#Query returns the absolute peak voltage measurement capability for instrument selected.
+#For AC (1φ) & DC outputs: Query response is expressed as line-neutral.
+#For AC multi-φ outputs: Query response is expressed as line-line equivalent value.
+    def instrumentSystemVoltage(self):
+        range = []
+        self.__s.send(("INST:CAP:VOLT:MEAS:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:VOLT:MEAS:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+    
+    def instrumentSystemVoltagePhase(self, phase):
+        if phase == 1:
+            msg = "INST:CAP:VOLT:APH:"
+        elif phase == 2:
+            msg = "INST:CAP:VOLT:BPH:"
+        elif phase == 3:
+            msg = "INST:CAP:VOLT:CPH:"
+        else:
+            return -1
+        range = []
+        self.__s.send((msg + "MEAS:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send((msg + "MEAS:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+#Query returns maximum (minimum) peak voltage measurement for the selected instrument & range
+    def instrumentSystemVoltageRange(self):
+        range = []
+        self.__s.send(("INST:CAP:VOLT:MEAS:RANG:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:VOLT:MEAS:RANG:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+
+    def instrumentSystemVoltageRangePhase(self, phase):
+        if phase == 1:
+            msg = "INST:CAP:VOLT:APH:"
+        elif phase == 2:
+            msg = "INST:CAP:VOLT:BPH:"
+        elif phase == 3:
+            msg = "INST:CAP:VOLT:CPH:"
+        else:
+            return -1
+        range = []
+        self.__s.send((msg + "MEAS:RANG:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send((msg + "MEAS:RANG:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+
+################################# Instrument Capabilities - Setting Capabilities Queries ##############################
+
+# Query returns the absolute maximum current (ARMS or ADC) output capability for instrument selected.
+    def instrumentCapCurrent(self):
+        self.__s.send(("INST:CAP:CURR:MAX?\r\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+#Query returns the maximum current (ARMS or ADC) set-point value for selected instrument & range
+    def instrumentCapCurrentRange(self):
+        self.__s.send(("INST:CAP:CURR:RANG:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+#Query returns a list of maximum or minimum current (ARMS or ADC) ranges for the selected instrument.
+    def instrumentCapCurrentRangeList(self):
+        range = []
+        self.__s.send(("INST:CAP:CURR:RANG:LIST:MIN?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveString(value))
+        self.__s.send(("INST:CAP:CURR:RANG:LIST:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveString(value))
+        
+        return range
+
+#Query returns the maximum (minimum) allowable operating frequency.
+    def instrumentCapFreqRange(self):
+        range = []
+        self.__s.send((":INST:CAP:FREQ:RANG:MIN?\r\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:FREQ:RANG:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+
+#Query returns the absolute maximum true power (Watts) setting value for the instrument selected.
+    def instrumentCapPowerMax(self):
+        self.__s.send(("INST:CAP:POW:ALL:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+#  for each phase
+    def instrumentCapPowerMaxPhase(self, phase):
+        if phase == 1:
+            msg = "INST:CAP:POW:APH:"
+        elif phase == 2:
+            msg = "INST:CAP:POW:BPH:"
+        elif phase == 3:
+            msg = "INST:CAP:POW:CPH:"
+        else:
+            return -1
+        self.__s.send((msg + "MAX?\n").encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+#These queries will retrieve the minimum (smallest positive) and maximum (largest positive) positive resistance setting for the Module. For example, the minimum = 1.5 and maximum = 1000.
+    def instrumentCapResistencePos(self):
+        self.__s.send(("INST:CAP:RES:POS:MIN?\r\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:RES:POS:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+    
+    def instrumentCapResistencenNeg(self):
+        self.__s.send(("INST:CAP:RES:NEG:MIN?\r\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:RES:NEG:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+#Query returns the absolute maximum voltage (VRMS or VDC) output capability for instrument selected.
+    def instrumentCapVoltageMaxMin(self):
+        range = []
+        self.__s.send(("INST:CAP:VOLT:ALL:MIN?\r\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:VOLT:ALL:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+################################# Setters and Getters ################################################
+
+#set limit voltage of all phases
+    def setVoltage(self,voltage):
+        if voltage < 0:
+            return -1
+        self.__s.send(("SOUR:VOLT: " + str(voltage) + "\n").encode())
+    #Functions that sets the limits voltage on one phase (A, B or C)
+    def setVoltageA(self,voltage):
+        if voltage < 0:
+            return -1
+        self.__s.send(("SOUR:VOLT:APH " + str(voltage) + "\n").encode())
+
+    def setVoltageB(self,voltage):
+        if voltage < 0:
+            return -1
+        self.__s.send(("SOUR:VOLT:BPHase " + str(voltage) + "\n").encode())
+
+    def setVoltageC(self,voltage):
+        if voltage < 0:
+            return -1
+        self.__s.send(("SOUR:VOLT:CPHase " + str(voltage) + "\n").encode())
+
+    #Command establishes the True Power limit (W) as a positive value for the selected instrument.
+    def setPower(self, pow):
+        if pow < 0:
+            return -1
+        self.__s.send(("SOUR:POW: " + str(pow) + "\n").encode())
+    #Individual command for one phase
+    def setPowerA(self, pow):
+        if pow < 0:
+            return -1
+        self.__s.send(("SOUR:POW:APHase " + str(pow) + "\n").encode())
+    def setPowerB(self, pow):
+        if pow < 0:
+            return -1
+        self.__s.send(("SOUR:POW:BPHase " + str(pow) + "\n").encode())
+    def setPowerC(self, pow):
+        if pow < 0:
+            return -1
+        self.__s.send(("SOUR:POW:CPHase " + str(pow) + "\n").encode())
+    #Command establishes the operating frequency for the selected instrument.
+    def setFreq(self, freq):
+        if freq < 0:
+            return -1
+        self.__s.send(("SOUR:FREQ " + str(freq) + "\n").encode())
+    #!!!! Doesnt work!!!!
+    def getFreq(self):
+        self.__s.send("FETC:FREQ\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    #Fetch the average voltage of all channels
+    def getVoltage(self):
+        self.__s.send("FETC:VOLT?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    #fetch individual value of voltage of one channel
+    def getVoltageA(self):
+        self.__s.send("FETC:VOLT:APHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    def getVoltageB(self):
+        self.__s.send("FETC:VOLT:BPHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    def getVoltageC(self):
+        self.__s.send("FETC:VOLT:CPHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    
+    def getVoltageArray(self):
+        self.__s.send("FETC:ARR:VOLT?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveArray(value)
+
+        
+    #Fetch the average power of all channels
+    def getPower(self):
+        self.__s.send("FETC:POW?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    #fetch individual value of Power of one channel
+    def getPowerA(self):
+        self.__s.send("FETC:POW:APHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    def getPowerB(self):
+        self.__s.send("FETC:POW:BPHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+        
+    def getPowerC(self):
+        self.__s.send("FETC:POW:CPHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+        #Fetch the average current of all channels
+    def getCurrent(self):
+        self.__s.send("FETC:CURR?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    #fetch individual value of current of one channel
+    def getCurrentA(self):
+        self.__s.send("FETC:CURR:APHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+    def getCurrentB(self):
+        self.__s.send("FETC:CURR:BPHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+
+    def getCurrentC(self):
+        self.__s.send("FETC:CURR:CPHase?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveFloat(value)
+    

test/realtime_graph/NHR9400series/NHR9410.py

+from NHR9400series.NHR9400 import NHR9400
+
+class NHR9410(NHR9400):
+
+    def __init__(self):
+        super().__init__("9410")
+
+    def setS(self):
+        self.__s = self.getS()
+    

test/realtime_graph/NHR9400series/NHR9430.py

+from NHR9400series.NHR9400 import NHR9400
+
+class NHR9430(NHR9400):
+
+    def __init__(self):
+        super().__init__("9430")
+    
+    
+    def setS(self):
+        self.__s = self.getS()
+    #Command sets the loading features <loading mode> for a 9430 AC output Query returns the loading features enabled on a 9430
+    #Command is only accepted if the instrument is a 9430, with AC outputs mode, and in an OFF state Other models & modes: This command is invalid
+    # 0 = NORMal = CC / CP / CVA with modifiers (PF, CF, & IWAVESHAPE)
+    # 1 = CR = Constant Resistance (with optional CC limit)
+    # 2 = RL = Constant series Resistance & Inductance
+
+    def instrumentLoad(self, value):
+        if value < 0 or value > 2:
+            print("INVALID INPUT")
+        else:
+            if value == 0:
+                self.__s.send("CONF:INST:LOAD:NORM".encode())
+            if value == 1:
+                self.__s.send("CONF:INST:LOAD:CR".encode())
+            if value == 2:
+                self.__s.send("CONF:INST:LOAD:RL".encode())
+        self.checkErrors()
+            
+    #Command enables bi-directional power flow for the 9420 (DC outputs) and 9430 (AC outputs) Query returns if Bi-directional power flow is permitted.
+    #0 | NO | FALSE | OFF = Bi directional mode is disabled 
+    #1 | YES | TRUE | ON = Bi directional mode is enabled
+    def instrumentBidirec(self, value):
+        if value == 0 or value == 1:
+            self.__s.send(("CONF:INST:BID"+ str(value) + "\n").encode())
+        else:
+            print("INVALID INPUT")
+        self.checkErrors()
+    #Command sets the standby detection conditions. 
+    #Query returns the configured standby detection conditions for the selected instrument
+    def instrumentStndy(self):
+         self.__s.send("CONF: INST:STBY".encode())
+         self.checkErrors()
+
+    #set the current of all phases ** Available only to NHR9430-12
+    def setCurrent(self, current):
+        if current < 0:
+            return -1
+        self.__s.send(("SOUR:CURR " + str(current) + "\n").encode())
+    #Functions that sets the limite currents on one phase (A, B or C)
+    def setCurrentA(self, current):
+        if current < 0:
+            return -1
+        self.__s.send(("SOUR:CURR:APHase " + str(current) + "\n").encode())
+    def setCurrentB(self, current):
+        if current < 0:
+            return -1
+        self.__s.send(("SOUR:CURR:BPHase " + str(current) + "\n").encode())
+    def setCurrentC(self, current):
+        if current < 0:
+            return -1
+        self.__s.send(("SOUR:CURR:CPHase " + str(current) + "\n").encode())
+
+    def getCurrentArray(self):
+        self.__s.send("FETC:ARR:CURR?\n".encode())
+        value = self.__s.recv(1024)
+        return self.receiveArray(value)
+
+###################### Instrument Capabilities #################
+
+#Query returns the minimum and maximum allowable set value for crest factor in NORMal loading mode Refer to CONFigure:LOAD:MODE for information about setting the 9430 in NORmal loading mode.
+    def instrumentCapCurrentCF(self):
+        range = []
+        self.__s.send(("INST:CAP:CURR:CF:MIN?\r\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:CURR:CF:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+#Query returns the minimum and maximum resistance that can be set in RL loading mode. Refer to CONFigure:LOAD:MODE for information about setting the 9430 in RL loading mode.
+    def instrumentCapResistenceRL(self):
+        range = []
+        self.__s.send(("INST:CAP:RL:RES:MIN?\r\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:RL:RES:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+#Query returns the minimum and maximum inductance that can be set in RL loading mode.
+    def instrumentCapInductanceRL(self):
+        range = []
+        self.__s.send(("INST:CAP:RL:IND:MIN?\r\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        self.__s.send(("INST:CAP:RL:IND:MAX?\n").encode())
+        value = self.__s.recv(1024)
+        range.append(self.receiveFloat(value))
+        
+        return range
+
+    
+
+
+
+    

test/realtime_graph/UtilitiesRei/IPFinder.py

+import socket
+from scapy.all import ARP, Ether, srp
+
+
+class IPFinder:
+
+    #uses socket and scapy to scan the entire local network and returns all the IPs adresses of the devices connects in this networok
+    def __getAllIp(self):
+        s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
+        s.connect(("10.255.255.255",1))
+        local_ip = s.getsockname()[0]
+        
+        splited = local_ip.split('.')
+        splited = local_ip.split('.')
+        splited.pop()
+        splited.append("1/24")
+        local_ip = ".".join(splited)
+
+        arp = ARP(pdst=local_ip)
+        ether = Ether(dst="ff:ff:ff:ff:ff:ff")
+        packet = ether/arp
+
+        result = srp(packet, timeout=1,retry = 1, verbose = 0)[0]
+        clients = []
+        for sent, received in result:
+            clients.append(received.psrc)
+        
+        self.__clients = clients
+
+    def deteleIp(self, ip):
+        self.__clients.remove(ip)
+
+    def getList(self):
+        self.__getAllIp()
+        return self.__clients
\ No newline at end of file

test/realtime_graph/UtilitiesRei/refineOutput.py

+class refineOutput:
+    
+    def byteToFloat(self, recv):
+        recv = bytes(recv)
+        recv = recv.decode("UTF-8")
+        recv = recv.rstrip('\n\x00')
+        
+        return float(recv)
+
+    def byteToString(self, recv):
+        recv = bytes(recv)
+        recv = recv.decode("UTF-8")
+        recv = recv.rstrip('\n\x00')
+        return recv
+
+    def byteToArray(self, recv):
+        recv = bytes(recv)
+        recv = recv.decode("UTF-8")
+        recv = recv.rstrip('\n\x00')
+        recv_array = recv.split(',')
+        return recv_array
\ No newline at end of file

test/realtime_graph/graph/consumers.py

@@ -2,17 +2,19 @@ import json
 from random import randint
 from asyncio import sleep
 from channels.generic.websocket import AsyncWebsocketConsumer
-from NHR9400series.NHR9400 import NHR9400
-from NHR9400series.NHR9430 import NHR9430
-
-
+from NHR9400series.NHR9410 import NHR9410
+from Control_Interface.controlInterface import controlInterface
 
 
+interface = controlInterface()
+interface.newNhr("9410")
+nhr10 = []
+nhr10 = interface.getNhr9410()
 
 class GraphConsumer(AsyncWebsocketConsumer):
     async def connect(self):
         await  self.accept()
         
         for i in range(1000):
-            await self.send(json.dumps({'value': NHR9400.getVoltageArray()}))
-            await sleep(0.16)
+            await self.send(json.dumps({'value': randint(0,40)}))
+            await sleep(1)

test/realtime_graph/static/JavaScript/main.js

 
-
-const ctx = document.getElementById('myChart').getContext('2d');
-
-var graph_data = {
-    type: 'line',
-
-    data: {
-        labels: ['Red', 'Blue', 'Yellow', 'Green', 'Purple', 'Orange'],
-        datasets: [{
-            label: '# of Votes',
-            data: [12, 19, 3, 5, 2, 3],
-            tension: 0,
-            backgroundColor: [
-                'rgba(255, 99, 132, 0.2)',
-
-            ],
-
-            borderWidth: 5
-        }]
-    },
-  
-
-}
-const data = {
-  labels: ['January', 'February', 'March', 'April', 'May', 'June', 'July'],
-  datasets: [{
-    label: 'Looping tension',
-    data: [65, 59, 80, 81, 26, 55, 40],
-    tension: 0.5,
-    fill: false,
-    borderColor: 'rgb(75, 192, 192)',
+var dps = Array(130)
+
+var myChart = new CanvasJS.Chart("chartContainer",{
+  title: {
+    text: "Live Data"
+  },
+  axisY: {
+    gridThickness: 0
+  },
+  data: [{
+    type: "spline",
+    dataPoints: dps
   }]
-};
-
-const config = {
-    type: 'line',
-    data: graph_data,
-    bezierCurve: true,
-    options: {
-      animations: {
-        tension: {
-          duration: 1000,
-          easing: 'easeInSine',
-          loop: true
-        }
-      },
-      scales: {
-        y: { // defining min and max so hiding the dataset does not change scale range
-          min: 0,
-          max: 100
-        }
-      }
-    }
-  };
-
+});
+myChart.render();
 
-const myChart = new Chart(ctx, graph_data, config);
 
-
-
-var socket = new WebSocket('ws://localhost:8000/ws/graph/')
+var socket = new WebSocket('ws://localhost:7000/ws/graph/');
+var updateInterval = 500;
 
 socket.onmessage = function(e){
     var djangoData = JSON.parse(e.data);
-    console.log(djangoData);
-    
-     var newGraphData = graph_data.data.datasets[0].data;
-     newGraphData.shift();
-     newGraphData.push(djangoData.value);
+    console.log(djangoData.value);
+    var updatedDps = [];
+    myChart.options.data[0].dataPoints = [];
 
-     graph_data.data.datasets[0].data = newGraphData;
-     myChart.update();
+    for(var i = 0; i < dps.length; i++)
+      updatedDps.push(djangoData.value[i]);
+      console.log(djangoData.value[i]);
 
-}
+    myChart.options.data[0].dataPoints = updatedDps;
\ No newline at end of file
+    myChart.render();
+};
+setInterval(function(e){socket.onmessage()}, updateInterval);
\ No newline at end of file

test/realtime_graph/templates/base.html

@@ -17,7 +17,7 @@
             <div class="row">
                 <div class="col-10 mx-auto mt-5">
                     <h1 id="app">{{ text }}</h1>
-                    <canvas id="myChart" width="400" height="200"></canvas>
+                    <canvas id="chartContainer" width="400" height="200"></canvas>
                     
                 </div>