Esempio n. 1
0
    def read(self, n, request):
        # if request[3:5]==b'06' or request[3:5]==b'16':
        #     normal=1
        # else:
        #     normal=0
        #     n=n+2
        message = bytearray()
        while len(message) < n:
            if self.debug:
                minimalmodbus._print_out('\nMinimalModbus debug mode. CurrentMessage  {}, Message length: {}, Expected Length{}'. \
                    format(str(message), len(message), n))
            message += self._socket.recv(1024)

        # if normal==0:
        #     extra=message[-6:-4]
        #     extraVal=ord(minimalmodbus._hexdecode(extra.decode()))

        #     del message[-6:-4]  #crappy implementation of modbus
        #     crc=message[-4:-2]

        #     readcrc=ord(minimalmodbus._hexdecode(crc.decode()))

        #     modifiedcrc=minimalmodbus._hexencode(minimalmodbus._numToOneByteString(readcrc+extraVal))

        #     message[-4:-2]=modifiedcrc.encode()

        return (message)
Esempio n. 2
0
 def open(self):
     self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     #self._socket.connect(("192.168.20.119", 4001))
     try:
         self._socket.connect((self.gatewayAddress, self.gatewayPort))
         minimalmodbus._print_out('\nConnected to RS485 gateway at  {}'. \
                 format(self.port))
     except socket.error as e:
         minimalmodbus._print_out('\nMinimalModbus debug mode. Error while connecting to RS485 gateway at  {}: {}'. \
             format(self.port, e))
Esempio n. 3
0
def getTemperatureAndHumidity(instrument, delay):

	time.sleep(delay)          
	minimalmodbus._print_out('\nTemperature (degC):')
	minimalmodbus._print_out(repr(instrument.read_register(ModbusRegisters.TEMP_REG_NUM, 2, 4, True)))#FC 4: Read Register

	time.sleep(delay)
	minimalmodbus._print_out('\nHumidity (%):')
	minimalmodbus._print_out(repr(instrument.read_register(ModbusRegisters.HUM_REG_NUM, 2, 4, False)))#FC 4: Read Register
Esempio n. 4
0
    parser.add_argument("-j",
                        "--json",
                        action="count",
                        default=0,
                        help='Encode out to json')
    parser.add_argument("-t", "--test", action="count", default=0)
    parser.add_argument("-e", "--emu", action="count", default=0)

    args = parser.parse_args()

    if (args.port == None):
        data = {}
        data["ports"] = serial_ports()
        if (args.json):
            if (args.emu):
                minimalmodbus._print_out("{\"ports\":[\"COM99\"]}")
                exit()
            json_data = json.dumps(data)
            minimalmodbus._print_out(json_data)
        else:
            minimalmodbus._print_out("Need set the port, Ex: -port COM3")
            minimalmodbus._print_out("Avaible:")
            ports_data = json.dumps(data["ports"])
            minimalmodbus._print_out(ports_data)
        exit()
    if (args.address == None):
        minimalmodbus._print_out("Need set the address, Ex: -address 1")
        exit()

    PORTNAME = args.port[0]
    #PORTNAME = '/dev/ttyUSB0'
Esempio n. 5
0
# as none of the modules in the standard library handles python 2.6 to 3.x

MODE = minimalmodbus.MODE_RTU
BAUDRATE = DEFAULT_BAUDRATE
PORT_NAME = DEFAULT_PORT_NAME

for arg in sys.argv:
    if arg.startswith('-ascii'):
        MODE = minimalmodbus.MODE_ASCII

    elif arg.startswith('-rtu'):
        MODE = minimalmodbus.MODE_RTU

    elif arg.startswith('-b'):
        if len(arg) < 3:
            minimalmodbus._print_out(
                'Wrong usage of the -b option. Use -b9600')
            sys.exit()
        BAUDRATE = int(arg[2:])

    elif arg.startswith('-D'):
        if len(arg) < 3:
            minimalmodbus._print_out(
                'Wrong usage of the -D option. Use -D/dev/ttyUSB0 or -DCOM4')
            sys.exit()
        PORT_NAME = arg[2:]

################################
## Create instrument instance ##
################################
instrument = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
instrument.serial.baudrate = BAUDRATE
Esempio n. 6
0
def getEsp8266ResetPeriod(instrument):      
	minimalmodbus._print_out('\nEsp8266ResetPeriod:')
	esp8266ResetPeriod = instrument.read_register(ModbusRegistersConf.ESP8266_HOLD_RESET_PERIOD_REG_NUM, 0, 3, False);
	minimalmodbus._print_out(repr(esp8266ResetPeriod))#FC 3: Read Holding Register
	return esp8266ResetPeriod
Esempio n. 7
0
def getSlaveAddress(instrument):      
	minimalmodbus._print_out('\nSlaveAddress:')
	slaveAddress = instrument.read_register(ModbusRegistersConf.SLAVE_ADDRESS_REG_NUM, 0, 3, False);
	minimalmodbus._print_out(repr(slaveAddress))#FC 3: Read Holding Register
	return slaveAddress
def main():
    #################################
    ## Read command line arguments ##
    #################################

    # Do manual parsing of command line,
    # as none of the modules in the standard library handles python 2.6 to 3.x

    MODE        = minimalmodbus.MODE_RTU
    BAUDRATE    = DEFAULT_BAUDRATE
    PORT_NAME   = DEFAULT_PORT_NAME

    for arg in sys.argv:
        if arg.startswith('-ascii'):
            MODE = minimalmodbus.MODE_ASCII
            
        elif arg.startswith('-rtu'): 
            MODE = minimalmodbus.MODE_RTU
        
        elif arg.startswith('-b'):
            if len(arg) < 3:
                minimalmodbus._print_out('Wrong usage of the -b option. Use -b9600')
                sys.exit()
            BAUDRATE = int(arg[2:])
            
        elif arg.startswith('-D'):
            if len(arg) < 3:
                minimalmodbus._print_out('Wrong usage of the -D option. Use -D/dev/ttyUSB0 or -DCOM4')
                sys.exit()
            PORT_NAME = arg[2:]
    
    ################################
    ## Create instrument instance ##
    ################################
    instrument = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
    instrument.serial.baudrate = BAUDRATE
    instrument.serial.timeout = TIMEOUT
    instrument.debug = False
    instrument.precalculate_read_size = True


    text = '\n'
    text += '###############################################################\n'
    text += '## Hardware test with Delta DTB4824                          ##\n'
    text += '## Minimalmodbus version: {:8}                           ##\n'.format(minimalmodbus.__version__)
    text += '##                                                           ##\n'
    text += '## Modbus mode:    {:15}                           ##\n'.format(instrument.mode)
    text += '## Python version: {}.{}.{}                                     ##\n'.format(sys.version_info[0], sys.version_info[1], sys.version_info[2])
    text += '## Baudrate (-b):  {:>5} bits/s                              ##\n'.format(instrument.serial.baudrate)
    text += '## Platform:       {:15}                           ##\n'.format(sys.platform)
    text += '##                                                           ##\n'
    text += '## Port name (-D): {:15}                           ##\n'.format(instrument.serial.port)
    text += '## Slave address:  {:<15}                           ##\n'.format(instrument.address)
    text += '## Timeout:        {:0.3f} s                                   ##\n'.format(instrument.serial.timeout)
    text += '## Full file path: ' + os.path.abspath(__file__) + '\n'
    text += '###############################################################\n'
    minimalmodbus._print_out(text)

    minimalmodbus._print_out(repr(instrument))


    if RUN_VERIFY_EXAMPLES:
        #########################################################################################
        ## Examples from page 11 in the "DTB Series Temperature Controller Instruction Sheet", ##
        ## version 2010-04-20                                                                  ##
        #########################################################################################
        instrument.debug = False

        # Read two registers starting at 0x1000. This is process value (PV) and setpoint (SV).
        # Should send '\x01\x03\x10\x00\x00\x02\xc0\xcb' OK!
        minimalmodbus._print_out('\nReading register 0x1000 and 0x1001:')
        minimalmodbus._print_out(repr(instrument.read_registers(0x1000, 2)))

        # Read 9 bits starting at 0x0810.
        # Should send '\x01\x02\x08\x10\x00\x09\xbb\xa9' OK!
        minimalmodbus._print_out('\nReading 9 bits starting at 0x0810:')
        minimalmodbus._print_out(repr(instrument._performCommand(2, '\x08\x10\x00\x09')))

        # Write value 800 to register 0x1001. This is a setpoint of 80.0 degrees (Centigrades, dependent on setting).
        # Should send '\x01\x06\x10\x01\x03\x20\xdd\xe2' OK!
        instrument.write_register(0x1001, 0x0320, functioncode=6)
        # Response from instrument: '\x01\x06\x10\x01\x03 \xdd\xe2' OK!
        # Note that the slave will indicate an error if the CoSH parameter in the controller
        # does not allow writing.
        # ASCII mode: Request  ':010610010320C5\r\n' 
        #             Response ':010610010320C5\r\n'

        # Write 1 to one bit at 0x0810. This is "Communication write in enabled".
        # Should send '\x01\x05\x08\x10\xff\x00\x8f\x9f' OK!
        instrument.write_bit(0x0810, 1)
        # Response from instrument: '\x01\x05\x08\x10\xff\x00\x8f\x9f' OK!
        
        
        #instrument.read_register(0x1001)
        # ASCII mode: Request  ':010310010001EA\r\n'
        #             Response ':0103020320D7\r\n'
        

    if RUN_READOUT_PRESENT_SETTINGS:
        ###############################
        ## Read out present settings ##
        ###############################
        instrument.debug = False
        
        minimalmodbus._print_out('\nPV: '                        + str(instrument.read_register(0x1000)))
        minimalmodbus._print_out('Setpoint: '                    + str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('Sensor type: '                 + str(instrument.read_register(0x1004)))
        minimalmodbus._print_out('Control method: '              + str(instrument.read_register(0x1005)))
        minimalmodbus._print_out('Heating/cooling selection: '   + str(instrument.read_register(0x1006)))
        minimalmodbus._print_out('Output 1 value: '              + str(instrument.read_register(0x1012, 1)))
        minimalmodbus._print_out('Output 2 value: '              + str(instrument.read_register(0x1013, 1)))
        minimalmodbus._print_out('System alarm setting: '        + str(instrument.read_register(0x1023)))
        minimalmodbus._print_out('LED status: '                  + str(instrument.read_register(0x102A)))
        minimalmodbus._print_out('Pushbutton status: '           + str(instrument.read_register(0x102B)))
        minimalmodbus._print_out('Firmware version: '            + str(instrument.read_register(0x102F)))

        minimalmodbus._print_out('LED AT: '                      + str(instrument.read_bit(0x0800)))
        minimalmodbus._print_out('LED Out1: '                    + str(instrument.read_bit(0x0801)))
        minimalmodbus._print_out('LED Out2: '                    + str(instrument.read_bit(0x0802)))
        minimalmodbus._print_out('RUN/STOP setting: '            + str(instrument.read_bit(0x0814)))

    if RUN_START_AND_STOP_REGULATOR:
        ###################################################
        ## Start and stop the regulator, change setpoint ##
        ###################################################
        instrument.debug = False

        SLEEP_TIME = 2

        instrument.write_bit(0x0814, 0) # Stop
        setpoint_value = 25
        instrument.write_register(0x1001,setpoint_value, 1, functioncode=6)
        minimalmodbus._print_out('\nSetpoint:'          + str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:'    + str(instrument.read_bit(0x0814)))
        time.sleep(SLEEP_TIME)

        instrument.write_bit(0x0814, 1) # Run
        minimalmodbus._print_out('\nSetpoint:'            + str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:'    + str(instrument.read_bit(0x0814)))
        time.sleep(SLEEP_TIME)

        setpoint_value = 35
        instrument.write_register(0x1001,setpoint_value, 1, functioncode=6)
        minimalmodbus._print_out('\nSetpoint:'            + str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:'    + str(instrument.read_bit(0x0814)))
        time.sleep(SLEEP_TIME)

        instrument.write_bit(0x0814, 0) # Stop
        minimalmodbus._print_out('\nSetpoint:'            + str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:'    + str(instrument.read_bit(0x0814)))

    if RUN_MEASURE_ROUNDTRIP_TIME:
        ####################################################
        ## Measure roundtrip time                         ##
        ## Loop setpoint value (20 to 50 deg C, and back) ##
        ####################################################
        instrument.debug = False

        NUMBER_OF_VALUES = 100

        START_VALUE = 200
        STOP_VALUE  = 500
        STEPSIZE    = 5

        value       = START_VALUE
        step        = STEPSIZE

        text = '\nSetting the SP value {} times. Baudrate {} bits/s.'.format(NUMBER_OF_VALUES, instrument.serial.baudrate)
        minimalmodbus._print_out(text)

        start_time = time.time()
        for i in range(NUMBER_OF_VALUES):
            if value > STOP_VALUE or value < START_VALUE:
                step = -step
            value += step
            instrument.write_register(0x1001, value, functioncode=6)

        time_per_value = (time.time() - start_time)*float(SECONDS_TO_MILLISECONDS)/NUMBER_OF_VALUES
        text = 'Time per value: {:0.1f} ms.'.format(time_per_value)
        minimalmodbus._print_out(text)

    if RUN_VERIFY_TWO_INSTRUMENTS:
        #######################################################
        ## Verify that two instruments can use the same port ##
        #######################################################

        instrument.debug = False
        minimalmodbus._print_out('\nInstrument1 SP:')
        minimalmodbus._print_out(str(instrument.read_register(0x1001, 1)))

        instrument2 = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
        instrument2.debug = False
        instrument2.serial.baudrate = BAUDRATE
        instrument2.serial.timeout  = TIMEOUT

        minimalmodbus._print_out('\nInstrument2 SP:')
        minimalmodbus._print_out(str(instrument2.read_register(0x1001, 1)))
Esempio n. 9
0
def getCo2(instrument, delay):

	time.sleep(delay)        
	minimalmodbus._print_out('\nCO2(ppm):')
	minimalmodbus._print_out(repr(instrument.read_register(ModbusRegisters.CO2_REG_NUM, 0, 4, False)))#FC 4: Read Register
Esempio n. 10
0
# as none of the modules in the standard library handles python 2.6 to 3.x

MODE        = minimalmodbus.MODE_RTU
BAUDRATE    = DEFAULT_BAUDRATE
PORT_NAME   = DEFAULT_PORT_NAME

for arg in sys.argv:
    if arg.startswith('-ascii'):
        MODE = minimalmodbus.MODE_ASCII
        
    elif arg.startswith('-rtu'): 
        MODE = minimalmodbus.MODE_RTU
    
    elif arg.startswith('-b'):
        if len(arg) < 3:
            minimalmodbus._print_out('Wrong usage of the -b option. Use -b9600')
            sys.exit()
        BAUDRATE = int(arg[2:])
        
    elif arg.startswith('-D'):
        if len(arg) < 3:
            minimalmodbus._print_out('Wrong usage of the -D option. Use -D/dev/ttyUSB0 or -DCOM4')
            sys.exit()
        PORT_NAME = arg[2:]

################################
## Create instrument instance ##
################################
instrument = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
instrument.serial.baudrate = BAUDRATE
instrument.serial.timeout = TIMEOUT
Esempio n. 11
0
    
    """
    # Exceptions - parameters: 4, 24, 32, 33, 34, 52(!)
    minimalmodbus._checkInt(paramnumber,
                            minvalue=1,
                            maxvalue=52,
                            description='parameter number')


########################
## Testing the module ##
########################

if __name__ == '__main__':

    minimalmodbus._print_out('TESTING PIXSYS ATR620 MODBUS MODULE')

    PORTNAME = '/dev/ttyUSB0'
    ADDRESS = 2

    minimalmodbus._print_out('Port: ' + str(PORTNAME) + ', Address: ' +
                             str(ADDRESS))

    a = PixsysATR620(PORTNAME, ADDRESS)
    a.debug = False

    minimalmodbus._print_out('SP1:                    {0}'.format(
        a.get_sp_loop1()))
    #minimalmodbus._print_out( 'SP1 target:             {0}'.format(  a.get_sptarget_loop1()       ))
    minimalmodbus._print_out('SP2:                    {0}'.format(
        a.get_sp_loop2()))
Esempio n. 12
0
            The bits value (int).
        """
        payloadToSlave = minimalmodbus._numToTwoByteString(registeraddress) + \
                        minimalmodbus._numToTwoByteString(4)
        payloadFromSlave = self._performCommand(functioncode, payloadToSlave)
        minimalmodbus._checkResponseByteCount(payloadFromSlave)
        registerdata = payloadFromSlave[1:]
        return int(minimalmodbus._hexlify(registerdata))


########################
## Testing the module ##
########################

if __name__ == '__main__':
    minimalmodbus._print_out('TESTING HHC-R4I4D MODBUS MODULE')

    PORTNAME = '/dev/ttyUSB0'
    ADDRESS = 1

    minimalmodbus._print_out('Port: ' + str(PORTNAME) + ', Address: ' +
                             str(ADDRESS))

    instr = RelayModule(PORTNAME, ADDRESS)
    instr.debug = False

    minimalmodbus._print_out('Digital inputs: {0}'.format(
        instr.get_digital_inputs()))
    instr.set_relay_output(1, 1)
    minimalmodbus._print_out('Relay 1 output: {0}'.format(
        instr.get_relay_output(1)))
Esempio n. 13
0
    def set_ch_status(self, channel):
        """Enable channel."""
        mask = 1 << channel
        reg = self.read_register(214, 0, 4)
        value = reg and mask
        self.write_register(214, value)


########################
## Testing the module ##
########################

if __name__ == '__main__':

    minimalmodbus._print_out('TESTING ADAM4117 MODBUS MODULE')

    # Assume ADAM4117 controller connected to /dev/ttyO1
    # Default Modbus @:1, serial port parameter: 9600,8,n,1

    a = Apm303('/dev/ttymxc1', 1)
    a.debug = True
    a.handle_local_echo = False

    minimalmodbus._print_out('Burn-out channel 0 {0}'.format(
        a.get_burnout_ch0()))
    minimalmodbus._print_out('Burn-out channel 1 {0}'.format(
        a.get_burnout_ch1()))
    minimalmodbus._print_out('Burn-out channel 2 {0}'.format(
        a.get_burnout_ch2()))
    minimalmodbus._print_out('Burn-out channel 3 {0}'.format(
Esempio n. 14
0
# as none of the modules in the standard library handles python 2.6 to 3.x

MODE        = minimalmodbus.MODE_RTU
BAUDRATE    = DEFAULT_BAUDRATE
PORT_NAME   = DEFAULT_PORT_NAME

for arg in sys.argv:
    if arg.startswith('-ascii'):
        MODE = minimalmodbus.MODE_ASCII
        
    elif arg.startswith('-rtu'): 
        MODE = minimalmodbus.MODE_RTU
    
    elif arg.startswith('-b'):
        if len(arg) < 3:
            minimalmodbus._print_out('Wrong usage of the -b option. Use -b9600')
            sys.exit()
        BAUDRATE = int(arg[2:])
        
    elif arg.startswith('-D'):
        if len(arg) < 3:
            minimalmodbus._print_out('Wrong usage of the -D option. Use -D/dev/ttyUSB0 or -DCOM4')
            sys.exit()
        PORT_NAME = arg[2:]

################################
## Create instrument instance ##
################################
instrument = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
instrument.serial.baudrate = BAUDRATE
instrument.serial.timeout = TIMEOUT
Esempio n. 15
0
        reg_name = 'Measurement Index'
        self.write_register(int(HOLDING_REGISTER[reg_name][REGISTER_ADDRESS_COL])-1, 
                              value,
                              functioncode = 6)
        
if __name__ == '__main__':
    
    usage = 'Usage: python %s <serial_port> <modbus_id>' % sys.argv[0]
    
    #serial_by_id = '/dev/ttyUSB0'
    #modbus_id = 2
    if len(sys.argv) > 2:
        serial_by_id = sys.argv[1]
        modbus_id = sys.argv[2]
    else:
        minimalmodbus._print_out('Python Script Param Error!')
        minimalmodbus._print_out(usage)
        sys.exit(0) 
    
    minimalmodbus._print_out('Testing Delta PVI PRI-H5 with serial port: %s and modbus ID: %s' % (serial_by_id, modbus_id))

    instr = DeltaPRIH5(serial_by_id,int(modbus_id))
    instr.serial.baudrate = 9600
    instr.serial.bytesize = 8
    instr.serial.parity = 'N'
    instr.serial.stopbits = 1    
    instr.serial.timeout = 0.1
    #instr.debug=True
    
    instr.set_register_measurement_index()
    
Esempio n. 16
0
# as none of the modules in the standard library handles python 2.6 to 3.x

MODE = minimalmodbus.MODE_RTU
BAUDRATE = DEFAULT_BAUDRATE
PORT_NAME = DEFAULT_PORT_NAME

for arg in sys.argv:
    if arg.startswith('-ascii'):
        MODE = minimalmodbus.MODE_ASCII

    elif arg.startswith('-rtu'):
        MODE = minimalmodbus.MODE_RTU

    elif arg.startswith('-b'):
        if len(arg) < 3:
            minimalmodbus._print_out(
                'Wrong usage of the -b option. Use -b9600')
            sys.exit()
        BAUDRATE = int(arg[2:])

    elif arg.startswith('-D'):
        if len(arg) < 3:
            minimalmodbus._print_out(
                'Wrong usage of the -D option. Use -D/dev/ttyUSB0 or -DCOM4')
            sys.exit()
        PORT_NAME = arg[2:]

################################
## Create instrument instance ##
################################
instrument = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
instrument.serial.baudrate = BAUDRATE
Esempio n. 17
0
        #       """Return the brake type of wind turbine."""
        #       return self.read_register(7, 0, 3)

        #   def set_modbus_ad(self,modbus_ad):
        """Set the modbus address of the Aeolos controller"""
        """Register address: 0x1999 """
        self.write_registers(6553, modbus_ad, 0)


########################
## Testing the module ##
########################

if __name__ == '__main__':

    minimalmodbus._print_out(
        'TESTING Aeolos Modbus Wind and Solar hybrid controller')

    # Assume Aeolos controller connected to /dev/ttyS1
    # Default Modbus @:1, serial port parameter: 19200,8,n,1
    a = Aeolos('/dev/ttyS1', 1)
    a.debug = True
    a.handle_local_echo = False

    minimalmodbus._print_out('Battery voltage {0}'.format(a.get_vbat()))
    minimalmodbus._print_out('Solar voltage {0}'.format(a.get_vsolar()))
    minimalmodbus._print_out('Solar current {0}'.format(a.get_isolar()))
    minimalmodbus._print_out('Wind voltage {0}'.format(a.get_vwind()))
    minimalmodbus._print_out('Wind current (before) {0}'.format(
        a.get_iwind_before()))
    minimalmodbus._print_out('Wind current (after) {0}'.format(
        a.get_iwind_after()))
Esempio n. 18
0
    def get_threshold_alarm1(self):
        """Return the threshold value for Alarm1."""
        return self.read_register(10241, 1)

    def is_set_alarmsummary(self):
        """Return True if some alarm is triggered."""
        return self.read_register(10213, 1) > 0


########################
## Testing the module ##
########################

if __name__ == '__main__':
    minimalmodbus._print_out('TESTING MURPHY MPC-10 MODBUS MODULE')

    a = MPC10Controller('/dev/ttyUSB0', 1)
    a.debug = False

    minimalmodbus._print_out('Engine RPM:          {0}'.format(a.get_engine_rpm()))
    minimalmodbus._print_out('System Voltage:      {0}'.format(a.get_voltage()))
    minimalmodbus._print_out('Controller State:    {0}'.format(a.get_controller_state()))
    minimalmodbus._print_out('Controller Mode:     {0}'.format(a.get_mode()))
    minimalmodbus._print_out('Ambient temp:        {0}'.format(a.get_ambient_temp()))
    minimalmodbus._print_out('Shutdown Status 1:   {0}'.format(a.get_active_shutdown_status_1()))
    minimalmodbus._print_out('Shutdown Status 2:   {0}'.format(a.get_active_shutdown_status_2()))
    minimalmodbus._print_out('Shutdown Status 3:   {0}'.format(a.get_active_shutdown_status_3()))
    minimalmodbus._print_out('MPC10 Serial:        {0}'.format(a.get_serial_number()))
    minimalmodbus._print_out('Start Temperature:   {0}'.format(a.get_start_temperature()))
    minimalmodbus._print_out('Stop Temperature:    {0}'.format(a.get_stop_temperature()))
Esempio n. 19
0
    ## Alarms

    def get_threshold_alarm1(self):
        """Return the threshold value for Alarm1."""
        return self.read_register(10241, 1)

    def is_set_alarmsummary(self):
        """Return True if some alarm is triggered."""
        return self.read_register(10213, 1) > 0

########################
## Testing the module ##
########################

if __name__ == '__main__':
    minimalmodbus._print_out('TESTING EUROTHERM 3500 MODBUS MODULE')

    a = Eurotherm3500('/dev/cvdHeatercontroller', 1)
    a.debug = False

    minimalmodbus._print_out('SP1:                    {0}'.format(a.get_sp_loop1()))
    minimalmodbus._print_out('SP1 target:             {0}'.format(a.get_sptarget_loop1()))
    minimalmodbus._print_out('SP2:                    {0}'.format(a.get_sp_loop2()))
    minimalmodbus._print_out('SP-rate Loop1 disabled: {0}'.format(a.is_sprate_disabled_loop1()))
    minimalmodbus._print_out('SP1 rate:               {0}'.format(a.get_sprate_loop1()))
    minimalmodbus._print_out('OP1:                    {0}%'.format(a.get_op_loop1()))
    minimalmodbus._print_out('OP2:                    {0}%'.format(a.get_op_loop2()))
    minimalmodbus._print_out('Alarm1 threshold:       {0}'.format(a.get_threshold_alarm1()))
    minimalmodbus._print_out('Alarm summary:          {0}'.format(a.is_set_alarmsummary()))
    minimalmodbus._print_out('Manual mode Loop1:      {0}'.format(a.is_manual_loop1()))
    minimalmodbus._print_out('Inhibit Loop1:          {0}'.format(a.is_inhibited_loop1()))
Esempio n. 20
0
def main():
    #################################
    ## Read command line arguments ##
    #################################

    # Do manual parsing of command line,
    # as none of the modules in the standard library handles python 2.6 to 3.x

    MODE = minimalmodbus.MODE_RTU
    BAUDRATE = DEFAULT_BAUDRATE
    PORT_NAME = DEFAULT_PORT_NAME

    for arg in sys.argv:
        if arg.startswith('-ascii'):
            MODE = minimalmodbus.MODE_ASCII

        elif arg.startswith('-rtu'):
            MODE = minimalmodbus.MODE_RTU

        elif arg.startswith('-b'):
            if len(arg) < 3:
                minimalmodbus._print_out(
                    'Wrong usage of the -b option. Use -b9600')
                sys.exit()
            BAUDRATE = int(arg[2:])

        elif arg.startswith('-D'):
            if len(arg) < 3:
                minimalmodbus._print_out(
                    'Wrong usage of the -D option. Use -D/dev/ttyUSB0 or -DCOM4'
                )
                sys.exit()
            PORT_NAME = arg[2:]

    ################################
    ## Create instrument instance ##
    ################################
    instrument = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
    instrument.serial.baudrate = BAUDRATE
    instrument.serial.timeout = TIMEOUT
    instrument.debug = False
    instrument.precalculate_read_size = True

    text = '\n'
    text += '###############################################################\n'
    text += '## Hardware test with Delta DTB4824                          ##\n'
    text += '## Minimalmodbus version: {:8}                           ##\n'.format(
        minimalmodbus.__version__)
    text += '##                                                           ##\n'
    text += '## Modbus mode:    {:15}                           ##\n'.format(
        instrument.mode)
    text += '## Python version: {}.{}.{}                                     ##\n'.format(
        sys.version_info[0], sys.version_info[1], sys.version_info[2])
    text += '## Baudrate (-b):  {:>5} bits/s                              ##\n'.format(
        instrument.serial.baudrate)
    text += '## Platform:       {:15}                           ##\n'.format(
        sys.platform)
    text += '##                                                           ##\n'
    text += '## Port name (-D): {:15}                           ##\n'.format(
        instrument.serial.port)
    text += '## Slave address:  {:<15}                           ##\n'.format(
        instrument.address)
    text += '## Timeout:        {:0.3f} s                                   ##\n'.format(
        instrument.serial.timeout)
    text += '## Full file path: ' + os.path.abspath(__file__) + '\n'
    text += '###############################################################\n'
    minimalmodbus._print_out(text)

    minimalmodbus._print_out(repr(instrument))

    if RUN_VERIFY_EXAMPLES:
        #########################################################################################
        ## Examples from page 11 in the "DTB Series Temperature Controller Instruction Sheet", ##
        ## version 2010-04-20                                                                  ##
        #########################################################################################
        instrument.debug = False

        # Read two registers starting at 0x1000. This is process value (PV) and setpoint (SV).
        # Should send '\x01\x03\x10\x00\x00\x02\xc0\xcb' OK!
        minimalmodbus._print_out('\nReading register 0x1000 and 0x1001:')
        minimalmodbus._print_out(repr(instrument.read_registers(0x1000, 2)))

        # Read 9 bits starting at 0x0810.
        # Should send '\x01\x02\x08\x10\x00\x09\xbb\xa9' OK!
        minimalmodbus._print_out('\nReading 9 bits starting at 0x0810:')
        minimalmodbus._print_out(
            repr(instrument._performCommand(2, '\x08\x10\x00\x09')))

        # Write value 800 to register 0x1001. This is a setpoint of 80.0 degrees (Centigrades, dependent on setting).
        # Should send '\x01\x06\x10\x01\x03\x20\xdd\xe2' OK!
        instrument.write_register(0x1001, 0x0320, functioncode=6)
        # Response from instrument: '\x01\x06\x10\x01\x03 \xdd\xe2' OK!
        # Note that the slave will indicate an error if the CoSH parameter in the controller
        # does not allow writing.
        # ASCII mode: Request  ':010610010320C5\r\n'
        #             Response ':010610010320C5\r\n'

        # Write 1 to one bit at 0x0810. This is "Communication write in enabled".
        # Should send '\x01\x05\x08\x10\xff\x00\x8f\x9f' OK!
        instrument.write_bit(0x0810, 1)
        # Response from instrument: '\x01\x05\x08\x10\xff\x00\x8f\x9f' OK!

        #instrument.read_register(0x1001)
        # ASCII mode: Request  ':010310010001EA\r\n'
        #             Response ':0103020320D7\r\n'

    if RUN_READOUT_PRESENT_SETTINGS:
        ###############################
        ## Read out present settings ##
        ###############################
        instrument.debug = False

        minimalmodbus._print_out('\nPV: ' +
                                 str(instrument.read_register(0x1000)))
        minimalmodbus._print_out('Setpoint: ' +
                                 str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('Sensor type: ' +
                                 str(instrument.read_register(0x1004)))
        minimalmodbus._print_out('Control method: ' +
                                 str(instrument.read_register(0x1005)))
        minimalmodbus._print_out('Heating/cooling selection: ' +
                                 str(instrument.read_register(0x1006)))
        minimalmodbus._print_out('Output 1 value: ' +
                                 str(instrument.read_register(0x1012, 1)))
        minimalmodbus._print_out('Output 2 value: ' +
                                 str(instrument.read_register(0x1013, 1)))
        minimalmodbus._print_out('System alarm setting: ' +
                                 str(instrument.read_register(0x1023)))
        minimalmodbus._print_out('LED status: ' +
                                 str(instrument.read_register(0x102A)))
        minimalmodbus._print_out('Pushbutton status: ' +
                                 str(instrument.read_register(0x102B)))
        minimalmodbus._print_out('Firmware version: ' +
                                 str(instrument.read_register(0x102F)))

        minimalmodbus._print_out('LED AT: ' + str(instrument.read_bit(0x0800)))
        minimalmodbus._print_out('LED Out1: ' +
                                 str(instrument.read_bit(0x0801)))
        minimalmodbus._print_out('LED Out2: ' +
                                 str(instrument.read_bit(0x0802)))
        minimalmodbus._print_out('RUN/STOP setting: ' +
                                 str(instrument.read_bit(0x0814)))

    if RUN_START_AND_STOP_REGULATOR:
        ###################################################
        ## Start and stop the regulator, change setpoint ##
        ###################################################
        instrument.debug = False

        SLEEP_TIME = 2

        instrument.write_bit(0x0814, 0)  # Stop
        setpoint_value = 25
        instrument.write_register(0x1001, setpoint_value, 1, functioncode=6)
        minimalmodbus._print_out('\nSetpoint:' +
                                 str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:' +
                                 str(instrument.read_bit(0x0814)))
        time.sleep(SLEEP_TIME)

        instrument.write_bit(0x0814, 1)  # Run
        minimalmodbus._print_out('\nSetpoint:' +
                                 str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:' +
                                 str(instrument.read_bit(0x0814)))
        time.sleep(SLEEP_TIME)

        setpoint_value = 35
        instrument.write_register(0x1001, setpoint_value, 1, functioncode=6)
        minimalmodbus._print_out('\nSetpoint:' +
                                 str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:' +
                                 str(instrument.read_bit(0x0814)))
        time.sleep(SLEEP_TIME)

        instrument.write_bit(0x0814, 0)  # Stop
        minimalmodbus._print_out('\nSetpoint:' +
                                 str(instrument.read_register(0x1001, 1)))
        minimalmodbus._print_out('RUN/STOP setting:' +
                                 str(instrument.read_bit(0x0814)))

    if RUN_MEASURE_ROUNDTRIP_TIME:
        ####################################################
        ## Measure roundtrip time                         ##
        ## Loop setpoint value (20 to 50 deg C, and back) ##
        ####################################################
        instrument.debug = False

        NUMBER_OF_VALUES = 100

        START_VALUE = 200
        STOP_VALUE = 500
        STEPSIZE = 5

        value = START_VALUE
        step = STEPSIZE

        text = '\nSetting the SP value {} times. Baudrate {} bits/s.'.format(
            NUMBER_OF_VALUES, instrument.serial.baudrate)
        minimalmodbus._print_out(text)

        start_time = time.time()
        for i in range(NUMBER_OF_VALUES):
            if value > STOP_VALUE or value < START_VALUE:
                step = -step
            value += step
            instrument.write_register(0x1001, value, functioncode=6)

        time_per_value = (time.time() - start_time
                          ) * float(SECONDS_TO_MILLISECONDS) / NUMBER_OF_VALUES
        text = 'Time per value: {:0.1f} ms.'.format(time_per_value)
        minimalmodbus._print_out(text)

    if RUN_VERIFY_TWO_INSTRUMENTS:
        #######################################################
        ## Verify that two instruments can use the same port ##
        #######################################################

        instrument.debug = False
        minimalmodbus._print_out('\nInstrument1 SP:')
        minimalmodbus._print_out(str(instrument.read_register(0x1001, 1)))

        instrument2 = minimalmodbus.Instrument(PORT_NAME, SLAVE_ADDRESS, MODE)
        instrument2.debug = False
        instrument2.serial.baudrate = BAUDRATE
        instrument2.serial.timeout = TIMEOUT

        minimalmodbus._print_out('\nInstrument2 SP:')
        minimalmodbus._print_out(str(instrument2.read_register(0x1001, 1)))
Esempio n. 21
0
                repr(registertype), repr(list(REGISTER_START.keys()))))

    # Calculate register address
    address = REGISTER_START[registertype] + \
              patternnumber * REGISTER_OFFSET_PER_PATTERN[registertype] + \
              stepnumber * REGISTER_OFFSET_PER_STEP[registertype]

    return address


########################
## Testing the module ##
########################

if __name__ == '__main__':
    minimalmodbus._print_out('TESTING OMEGA CN7500 MODBUS MODULE')

    PORTNAME = '/dev/tty.usbserial-FTFO1057'
    ADDRESS = 10

    minimalmodbus._print_out('Port: ' + str(PORTNAME) + ', Address: ' +
                             str(ADDRESS))

    instr = OmegaCN7500(PORTNAME, ADDRESS)

    minimalmodbus._print_out('Control:                {0}'.format(
        instr.get_control_mode()))
    minimalmodbus._print_out('SP:                     {0}'.format(
        instr.get_setpoint()))
    minimalmodbus._print_out('PV:                     {0}'.format(
        instr.get_pv()))
Esempio n. 22
0
    def get_threshold_alarm1(self):
        """Return the threshold value for Alarm1."""
        return self.read_register(10241, 1)
    
    def is_set_alarmsummary(self):
        """Return True if some alarm is triggered."""
        return self.read_register(10213, 1) > 0
    
########################
## Testing the module ##
########################

if __name__ == '__main__':

    minimalmodbus._print_out( 'TESTING EUROTHERM 3500 MODBUS MODULE')

    a = Eurotherm3500('/dev/cvdHeatercontroller', 1)
    a.debug = False
    
    minimalmodbus._print_out( 'SP1:                    {0}'.format(  a.get_sp_loop1()             ))
    minimalmodbus._print_out( 'SP1 target:             {0}'.format(  a.get_sptarget_loop1()       ))
    minimalmodbus._print_out( 'SP2:                    {0}'.format(  a.get_sp_loop2()             ))
    minimalmodbus._print_out( 'SP-rate Loop1 disabled: {0}'.format(  a.is_sprate_disabled_loop1() ))
    minimalmodbus._print_out( 'SP1 rate:               {0}'.format(  a.get_sprate_loop1()         ))
    minimalmodbus._print_out( 'OP1:                    {0}%'.format( a.get_op_loop1()             ))
    minimalmodbus._print_out( 'OP2:                    {0}%'.format( a.get_op_loop2()             ))
    minimalmodbus._print_out( 'Alarm1 threshold:       {0}'.format(  a.get_threshold_alarm1()     ))
    minimalmodbus._print_out( 'Alarm summary:          {0}'.format(  a.is_set_alarmsummary()      ))
    minimalmodbus._print_out( 'Manual mode Loop1:      {0}'.format(  a.is_manual_loop1()          ))
    minimalmodbus._print_out( 'Inhibit Loop1:          {0}'.format(  a.is_inhibited_loop1()       ))
Esempio n. 23
0
#!/usr/bin/env python
import minimalmodbus
import omegacn7500
import settings

instr = omegacn7500.OmegaCN7500(settings.port,settings.rimsaddressint)
# port name, slave address

minimalmodbus._print_out( 'Control:                {0}'.format(  instr.get_control_mode()    ))
minimalmodbus._print_out( 'SP:                     {0}'.format(  instr.get_setpoint() ))
minimalmodbus._print_out( 'PV:                     {0}'.format(  instr.get_pv()       ))
minimalmodbus._print_out( 'OP1:                    {0}'.format(  instr.get_output1()  ))
minimalmodbus._print_out( 'Is running:             {0}'.format(  instr.is_running()   ))
minimalmodbus._print_out( 'Start pattern:          {0}'.format(  instr.get_start_pattern_no()  ))
minimalmodbus._print_out('DONE!')
Esempio n. 24
0
 def close(self):
     self._socket.close()
     if self.debug:
         minimalmodbus._print_out('\nMinimalModbus debug mode. Disconnected from RS485 gateway at  {}'. \
             format(self.port))
Esempio n. 25
0
    # Calculate register address
    address = REGISTER_START[registertype] + \
                patternnumber * REGISTER_OFFSET_PER_PATTERN[registertype] + \
                stepnumber * REGISTER_OFFSET_PER_STEP[registertype]
        
    return address
    
    
########################
## Testing the module ##
########################

if __name__ == '__main__':

    minimalmodbus._print_out('TESTING OMEGA CN7500 MODBUS MODULE')

    PORTNAME = '/dev/tty.usbserial-FTFO1057'
    ADDRESS = 10
    
    minimalmodbus._print_out( 'Port: ' +  str(PORTNAME) + ', Address: ' + str(ADDRESS) )
    
    instr = OmegaCN7500(PORTNAME, ADDRESS)
    
    minimalmodbus._print_out( 'Control:                {0}'.format(  instr.get_control_mode()    ))
    minimalmodbus._print_out( 'SP:                     {0}'.format(  instr.get_setpoint() ))
    minimalmodbus._print_out( 'PV:                     {0}'.format(  instr.get_pv()       ))
    minimalmodbus._print_out( 'OP1:                    {0}'.format(  instr.get_output1()  ))   
    minimalmodbus._print_out( 'Is running:             {0}'.format(  instr.is_running()   ))
    minimalmodbus._print_out( 'Start pattern:          {0}'.format(  instr.get_start_pattern_no()  ))
Esempio n. 26
0
    def _communicate(self, request, number_of_bytes_to_read):
        """Talk to the slave via a serial port.
        Args:
            request (str): The raw request that is to be sent to the slave.
            number_of_bytes_to_read (int): number of bytes to read
        Returns:
            The raw data (string) returned from the slave.
        Raises:
            TypeError, ValueError, IOError
        Note that the answer might have strange ASCII control signs, which
        makes it difficult to print it in the promt (messes up a bit).
        Use repr() to make the string printable (shows ASCII values for control signs.)
        Will block until reaching *number_of_bytes_to_read* or timeout.
        If the attribute :attr:`Instrument.debug` is :const:`True`, the communication details are printed.
        If the attribute :attr:`Instrument.close_port_after_each_call` is :const:`True` the
        serial port is closed after each call.
        Timing::
                                                  Request from master (Master is writing)
                                                  |
                                                  |       Response from slave (Master is reading)
                                                  |       |
            ----W----R----------------------------W-------R----------------------------------------
                     |                            |       |
                     |<----- Silent period ------>|       |
                                                  |       |
                             Roundtrip time  ---->|-------|<--
        The resolution for Python's time.time() is lower on Windows than on Linux.
        It is about 16 ms on Windows according to
        http://stackoverflow.com/questions/157359/accurate-timestamping-in-python
        For Python3, the information sent to and from pySerial should be of the type bytes.
        This is taken care of automatically by MinimalModbus.
        
        
        """

        minimalmodbus._checkString(request, minlength=1, description='request')
        minimalmodbus._checkInt(number_of_bytes_to_read)

        if self.debug:
            minimalmodbus._print_out('\nMinimalModbus debug mode. Writing to instrument (expecting {} bytes back): {!r} ({})'. \
                format(number_of_bytes_to_read, request, minimalmodbus._hexlify(request)))

        if self.close_port_after_each_call:
            self.serial.open()

        #self.serial.flushInput() TODO

        if sys.version_info[0] > 2:
            request = bytes(request, encoding='latin1'
                            )  # Convert types to make it Python3 compatible

        # Sleep to make sure 3.5 character times have passed
        minimum_silent_period = minimalmodbus._calculate_minimum_silent_period(
            self.serial.baudrate)
        time_since_read = time.time() - _LATEST_READ_TIMES.get(
            self.serial.port, 0)

        if time_since_read < minimum_silent_period:
            sleep_time = minimum_silent_period - time_since_read

            if self.debug:
                template = 'MinimalModbus debug mode. Sleeping for {:.1f} ms. ' + \
                        'Minimum silent period: {:.1f} ms, time since read: {:.1f} ms.'
                text = template.format(
                    sleep_time * _SECONDS_TO_MILLISECONDS,
                    minimum_silent_period * _SECONDS_TO_MILLISECONDS,
                    time_since_read * _SECONDS_TO_MILLISECONDS)
                minimalmodbus._print_out(text)

            time.sleep(sleep_time)

        elif self.debug:
            template = 'MinimalModbus debug mode. No sleep required before write. ' + \
                'Time since previous read: {:.1f} ms, minimum silent period: {:.2f} ms.'
            text = template.format(
                time_since_read * _SECONDS_TO_MILLISECONDS,
                minimum_silent_period * _SECONDS_TO_MILLISECONDS)
            minimalmodbus._print_out(text)

        # Write request
        latest_write_time = time.time()

        self.serial.write(request)

        # Read and discard local echo
        if self.handle_local_echo:
            localEchoToDiscard = self.serial.read(len(request))
            if self.debug:
                template = 'MinimalModbus debug mode. Discarding this local echo: {!r} ({} bytes).'
                text = template.format(localEchoToDiscard,
                                       len(localEchoToDiscard))
                minimalmodbus._print_out(text)
            if localEchoToDiscard != request:
                template = 'Local echo handling is enabled, but the local echo does not match the sent request. ' + \
                    'Request: {!r} ({} bytes), local echo: {!r} ({} bytes).'
                text = template.format(request, len(request),
                                       localEchoToDiscard,
                                       len(localEchoToDiscard))
                raise IOError(text)

        # Read response
        answer = self.serial.read(number_of_bytes_to_read, request)
        _LATEST_READ_TIMES[self.serial.port] = time.time()

        if self.close_port_after_each_call:
            self.serial.close()

        if sys.version_info[0] > 2:
            answer = str(answer, encoding='latin1'
                         )  # Convert types to make it Python3 compatible

        if self.debug:
            template = 'MinimalModbus debug mode. Response from instrument: {!r} ({}) ({} bytes), ' + \
                'roundtrip time: {:.1f} ms. Timeout setting: {:.1f} ms.\n'
            text = template.format(
                answer, minimalmodbus._hexlify(answer), len(answer),
                (_LATEST_READ_TIMES.get(self.serial.port, 0) -
                 latest_write_time) * _SECONDS_TO_MILLISECONDS,
                self.serial.timeout * _SECONDS_TO_MILLISECONDS)
            minimalmodbus._print_out(text)

        if len(answer) == 0:
            raise IOError('No communication with the instrument (no answer)')

        return answer
Esempio n. 27
0
def getAmberRedThreshold(instrument):      
	minimalmodbus._print_out('\nAmberRedThreshold:')
	amberRedThreshold = instrument.read_register(ModbusRegistersConf.AMBERRED_THRESHOLD_REG_NUM, 0, 3, False);
	minimalmodbus._print_out(repr(amberRedThreshold))#FC 3: Read Holding Register
	return amberRedThreshold
Esempio n. 28
0
def getSgp30Parameters(instrument, delay):

    time.sleep(delay)
    minimalmodbus._print_out('\nTVOC(ppb):')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.TVOC_REG_NUM, 0, 4,
                                     False)))  #FC 4: Read Register

    time.sleep(delay)
    minimalmodbus._print_out('\neCO2(ppm):')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.ECO2_REG_NUM, 0, 4,
                                     False)))  #FC 4: Read Register

    time.sleep(delay)
    minimalmodbus._print_out('\nTVOC Average(ppb):')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.TVOC_AVG_REG_NUM, 0, 4,
                                     False)))  #FC 4: Read Register

    time.sleep(delay)
    minimalmodbus._print_out('\neCO2 Average(ppm):')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.ECO2_AVG_REG_NUM, 0, 4,
                                     False)))  #FC 4: Read Register

    time.sleep(delay)
    minimalmodbus._print_out('\nTVOC base:')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.TVOC_BASE_REG_NUM, 0, 4,
                                     False)))  #FC 4: Read Register

    time.sleep(delay)
    minimalmodbus._print_out('\neCO2 base:')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.ECO2_BASE_REG_NUM, 0, 4,
                                     False)))  #FC 4: Read Register

    time.sleep(delay)
    minimalmodbus._print_out('\nEthanol raw (ppm):')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.ETHANOL_BASE_REG_NUM, 0,
                                     4, False)))  #FC 4: Read Register

    time.sleep(delay)
    minimalmodbus._print_out('\nH2 raw (ppm):')
    minimalmodbus._print_out(
        repr(
            instrument.read_register(ModbusRegisters.H2RAW_BASE_REG_NUM, 0, 4,
                                     False)))  #FC 4: Read Register
Esempio n. 29
0
def getTemperatureOffset(instrument):      
	minimalmodbus._print_out('\nTemperatureOffset:')
	temperatureOffset = instrument.read_register(ModbusRegistersConf.SHT31_TEMPERATURE_OFFSET_REG_NUM, 0, 3, False);
	minimalmodbus._print_out(repr(temperatureOffset))#FC 3: Read Holding Register
	return temperatureOffset
Esempio n. 30
0
        self.write_register(999, 1991)
        number_registers = 3
        s = None
        while s is None:
            try:
                s = self.read_registers(1000, number_registers, functioncode=3)
            except:
                pass
        self.write_register(999, 1191)
        l = l + s
        return l


if __name__ == '__main__':

    minimalmodbus._print_out('HERU FTX MODBUS REGISTER')

    a = HeruFTX('/dev/ttyUSB0', 1)  #port, slaveadress
    a.mode = minimalmodbus.MODE_RTU
    a.serial.stopbits = 1
    a.serial.timeout = 0.2  #Timeout might be adjusted to allow full reading of message
    a.debug = False
    a.precalculate_read_size = False
    print("---------------")
    print("| Coil Status |")
    print("---------------")
    minimalmodbus._print_out('{:40}{:20}{}'.format('Register name', 'Value',
                                                   'Description\n'))
    l = a.coil_status()
    description = [
        '  ',
Esempio n. 31
0
def getGreenAmberThreshold(instrument):      
	minimalmodbus._print_out('\nGreenAmberThreshold:')
	greenAmberThreshold = instrument.read_register(ModbusRegistersConf.GREENAMBER_THRESHOLD_REG_NUM, 0, 3, False);
	minimalmodbus._print_out(repr(greenAmberThreshold))#FC 3: Read Holding Register
	return greenAmberThreshold
Esempio n. 32
0
            int(HOLDING_REGISTER[reg_name][REGISTER_ADDRESS_COL]) - 1,
            value,
            functioncode=6)


if __name__ == '__main__':

    usage = 'Usage: python %s <serial_port> <modbus_id>' % sys.argv[0]

    #serial_by_id = '/dev/ttyUSB0'
    #modbus_id = 2
    if len(sys.argv) > 2:
        serial_by_id = sys.argv[1]
        modbus_id = sys.argv[2]
    else:
        minimalmodbus._print_out('Python Script Param Error!')
        minimalmodbus._print_out(usage)
        sys.exit(0)

    minimalmodbus._print_out(
        'Testing Delta PVI PRI-H5 with serial port: %s and modbus ID: %s' %
        (serial_by_id, modbus_id))

    instr = DeltaPRIH5(serial_by_id, int(modbus_id))
    instr.serial.baudrate = 9600
    instr.serial.bytesize = 8
    instr.serial.parity = 'N'
    instr.serial.stopbits = 1
    instr.serial.timeout = 0.1
    #instr.debug=True