cannot enable/disable RTS for client and slave

when i use serial RTU and RS-485 wires, how do i set set RTS high and low.

i know i gotta to do it in the source codes, like for read_holding_register request , i need to set it high to send the request and low to receive the response from slave.

and for the slave Linux box, i need to set RTS high to send a reponse back to master and set it low right after that.

where do i do that ?

i know i can setRTS using pyserial.

[bashwork]

What you can do is simply::

client = ModbusSerialClient(...)
client.socket.setRTS(true)
...
client.socket.setRTS(false)

Furthermore, anything that you need to do on the serial socket, you can do as well (this is actually just the pyserial socket instance).

sorry for being noob..
i know how to set that, but what does it mean,
like if i want to do a read_holding_register through just RS-485 twisted pair wires,
i setRTS(true) to send the read request.
client.read_holding_register would return the value?
do i need to setRTS(false) after doing client.read_holding_register? do i need a delay between them?
i'v been adding set RTS(True) and setRTS(false) in transaction manager's execute() method .
so before a send, i set it true, after a send i set it false.

However, the real issue is with the server,
the server should only setRTS(True) when the master sends a request right? how do i know when to set it high,
is there a way to know if a request has been sent so i can do an IF statement?

please be more detailed i'm really noob at this..

thank you very much for all the help you've given me.

i'm using the synchronous client and asynchronous server examples..

cannot really understand the asynchronous client example, and from the documentation's library Asynchronous server example
from asyn.py import ModbusSerialClient as Client doesn't work, there's no ModbusSerialClient in Async.py ..

[bashwork]

Okay, so I haven't actually implemented a rs-485 solution with pymodbus. Are you stuck using the half duplex mode? Is there any chance you can just use a full duplex (4 wire) configuration? Otherwise, everyone I have been in contact with has simply used a controller that does the control line detection for them.

I guess you can try to implement it yourself, but it may be a little flakey (I have no clue if this is going to work or not)::

monkey patch ModbusSerialClient._send

def _send(self, request):
    ''' Sends data on the underlying socket

    :param request: The encoded request to send
    :return: The number of bytes written
    '''
    if not self.socket:
        raise ConnectionException(self.__str__())
    if request:
        self.socket.setRTS(true) # may need to delay, poll, etc here
        return self.socket.write(request)
    return 0

monkey patch ModbusSerialClient._recv

def _recv(self, size):
    ''' Reads data from the underlying descriptor

    :param size: The number of bytes to read
    :return: The bytes read
    '''
    if not self.socket:
        raise ConnectionException(self.__str__())
    client.socket.setRTS(false) # you shouldn't have to delay here
    return self.socket.read(size)

There may be other serial flags that you have to set for the master to give/take control over the line, but this is a quick idea.

[bashwork]

However after reading the pyserial documetation, it seems you can just defer to the hardware flow control by setting
rtscts=False in the ModbusSerialClient constructor.

yes but how about the server side

what can i do there, there does not seem to be a send and receive functions
in the transaction manager in the transaction.py .

where would i enable rts high or low for that

thanks

On Thu, Sep 26, 2013 at 10:58 PM, Galen Collins notifications@github.comwrote:

However after reading the pyserial documetation, it seems you can just
defer to the hardware flow control by setting
rtscts=False in the ModbusSerialClient constructor.

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/33#issuecomment-25224568
.

yes i'm doing half duplex.

On Thu, Sep 26, 2013 at 11:32 PM, Heming Liu hemingliu123@gmail.com wrote:

yes but how about the server side

what can i do there, there does not seem to be a send and receive
functions in the transaction manager in the transaction.py .

where would i enable rts high or low for that

thanks

On Thu, Sep 26, 2013 at 10:58 PM, Galen Collins notifications@github.comwrote:

However after reading the pyserial documetation, it seems you can just
defer to the hardware flow control by setting
rtscts=False in the ModbusSerialClient constructor.

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/33#issuecomment-25224568
.

[karlp]

Trying to do the toggling from userspace is fraught with danger. Lots of devices will reply before you have had time to drop the tx-enable line, and it will not work. The right way of doing this, is to ask the kernel to open the serial port in rs-485 mode, so it will take care of that for you. Of course, that's not always possible, but it's how you should do it.

monkey patching send is the first attempt is ... maybe ok. You can definitely set the tx-enable line there, but you want to be dropping it again as soon as the transmission is complete. Which, unfortunately, is not when socket.write() returns! (You can get lucky with some rs485 devices by putting a delay there and dropping the signal manually, but it will not work with lots of devices that reply when the message has been received without waiting)

(Also, please remember that just because you are using the RTS line repurposed as a rs485 driver enable line doesn't meant that's the right name for it :)

both of my Linux devices are the same.
and i'm using Sync client on one and Async server on the other. should i be using an Async client? but the one in the documentation code doesn't work.
i'm setting RTS high and low like this on the SYNC.PY in ModbusUdpServer

def _execute(self, request, addr):
''' Executes the request and returns the result

    :param request: The decoded request message
    '''
    try:
        context = self.store[request.unit_id]
        response = request.execute(context)
    except Exception, ex:
        _logger.debug("Datastore unable to fulfill request: %s" % ex)
        response = request.doException(merror.SlaveFailure)
    #self.framer.populateResult(response)
    response.transaction_id = request.transaction_id
    response.unit_id = request.unit_id
    self._send(response, addr)
    self.socket.setRTS(False)

def _send(self, message, addr):
''' Send a request (string) to the network

    :param message: The unencoded modbus response
    :param addr: The (host, port) to send the message to
    '''
    self.control.Counter.BusMessage += 1
    pdu = self.framer.buildPacket(message)
    if _logger.isEnabledFor(logging.DEBUG):
        _logger.debug('send: %s' % b2a_hex(pdu))
    self.socket.setRTS(True)
    return self.transport.write(pdu, addr)

Even using the modpoll simulation server, i could not get a result using the Synchronous client..
getting error like this from writing to the register
assert(rq.function_code < 0x80) # test that we are not an error
AttributeError: 'NoneType' object has no attribute 'function_code'
and i get none from reading the register..

Hi Galen,

what controller do people use, does the controller have automatic rs-485
half-duplex enable/disable flow control?

thanks

Heming

On Thu, Sep 26, 2013 at 10:43 PM, Galen Collins notifications@github.comwrote:

Okay, so I haven't actually implemented a rs-485 solution with pymodbus.
Are you stuck using the half duplex mode? Is there any chance you can just
use a full duplex (4 wire) configuration? Otherwise, everyone I have been
in contact with has simply used a controller that does the control line
detection for them.

I guess you can try to implement it yourself, but it may be a little
flakey (I have no clue if this is going to work or not)::
monkey patch ModbusSerialClient._send to the following

def _send(self, request):
''' Sends data on the underlying socket

:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
    raise ConnectionException(self.__str__())
if request:
    self.socket.setRTS(true) # may need to delay, poll, etc here
    return self.socket.write(request)
return 0

monkey patch ModbusSerialClient._recv to the following

def _recv(self, size):
''' Reads data from the underlying descriptor

:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
    raise ConnectionException(self.__str__())
client.socket.setRTS(false) # you shouldn't have to delay here
return self.socket.read(size)

There may be other serial flags that you have to set for the master to
give/take control over the line, but this is a quick idea.

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/33#issuecomment-25224214
.

[xvart]

Sorry but I have to dive in here,

Anyone running modbus on a multitasking OS such as linux or windows will
never be able to meet the requirements of the serial spec, there is no
debate on this, tasking is normally 10ms so meeting 3.5us timing
requirement just doesn't fit and never will.

RS485 is balanced 2 wire coms like RS422 and there is no RTS,CTS or any
other modem signalling system. If you want to send over RS485, get an
RS485 converter and move on this is not a modbus issue. On serial modbus
is a poll response protocol so RTS et al are meaningless, read the spec
it was designed for embedded systems probably bit bashing IO.

It is even probable that with a modern RS232 chip with buffering meeting
the 3.5us in the spec is not possible.

Sorry but anyone trying modbus over serial on a multitasking OS is at
the mercy of the external equipment.

see here for converters
http://www.usconverters.com/index.php?main_page=index&cPath=65

On 28/09/13 14:33, heming277 wrote:

Hi Galen,

what controller do people use, does the controller have automatic rs-485
half-duplex enable/disable flow control?

thanks

Heming

On Thu, Sep 26, 2013 at 10:43 PM, Galen Collins
notifications@github.comwrote:

Okay, so I haven't actually implemented a rs-485 solution with
pymodbus.
Are you stuck using the half duplex mode? Is there any chance you
can just
use a full duplex (4 wire) configuration? Otherwise, everyone I have
been
in contact with has simply used a controller that does the control line
detection for them.

I guess you can try to implement it yourself, but it may be a little
flakey (I have no clue if this is going to work or not)::
monkey patch ModbusSerialClient._send to the following

def _send(self, request):
''' Sends data on the underlying socket

:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
raise ConnectionException(self.str())
if request:
self.socket.setRTS(true) # may need to delay, poll, etc here
return self.socket.write(request)
return 0

monkey patch ModbusSerialClient._recv to the following

def _recv(self, size):
''' Reads data from the underlying descriptor

:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
raise ConnectionException(self.str())
client.socket.setRTS(false) # you shouldn't have to delay here
return self.socket.read(size)

There may be other serial flags that you have to set for the master to
give/take control over the line, but this is a quick idea.

—
Reply to this email directly or view it on
GitHubhttps://github.com//issues/33#issuecomment-25224214
.

—
Reply to this email directly or view it on GitHub
#33 (comment).

ok thanks for the informative reply!

this helps very much i've been struggling for a long time.

However as you said even RS-232 is not possible, what's the point of using
the RS-232 TO RS-485 converter then.

say if i want to connect from my master box to my slave box, how would i do
it.

i have a FTDI USB to RS485 converter like this one
https://www.sparkfun.com/products/9822
and i do have a rs-232 to rs-485 converter.

On Sat, Sep 28, 2013 at 12:30 AM, xvart notifications@github.com wrote:

Sorry but I have to dive in here,

Anyone running modbus on a multitasking OS such as linux or windows will
never be able to meet the requirements of the serial spec, there is no
debate on this, tasking is normally 10ms so meeting 3.5us timing
requirement just doesn't fit and never will.

RS485 is balanced 2 wire coms like RS422 and there is no RTS,CTS or any
other modem signalling system. If you want to send over RS485, get an
RS485 converter and move on this is not a modbus issue. On serial modbus
is a poll response protocol so RTS et al are meaningless, read the spec
it was designed for embedded systems probably bit bashing IO.

It is even probable that with a modern RS232 chip with buffering meeting
the 3.5us in the spec is not possible.

Sorry but anyone trying modbus over serial on a multitasking OS is at
the mercy of the external equipment.

see here for converters
http://www.usconverters.com/index.php?main_page=index&cPath=65

On 28/09/13 14:33, heming277 wrote:

Hi Galen,

what controller do people use, does the controller have automatic rs-485
half-duplex enable/disable flow control?

thanks

Heming

On Thu, Sep 26, 2013 at 10:43 PM, Galen Collins
notifications@github.comwrote:

Okay, so I haven't actually implemented a rs-485 solution with
pymodbus.
Are you stuck using the half duplex mode? Is there any chance you
can just
use a full duplex (4 wire) configuration? Otherwise, everyone I have
been
in contact with has simply used a controller that does the control line
detection for them.

I guess you can try to implement it yourself, but it may be a little
flakey (I have no clue if this is going to work or not)::
monkey patch ModbusSerialClient._send to the following

def _send(self, request):
''' Sends data on the underlying socket

:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
raise ConnectionException(self.str())
if request:
self.socket.setRTS(true) # may need to delay, poll, etc here
return self.socket.write(request)
return 0

monkey patch ModbusSerialClient._recv to the following

def _recv(self, size):
''' Reads data from the underlying descriptor

:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
raise ConnectionException(self.str())
client.socket.setRTS(false) # you shouldn't have to delay here
return self.socket.read(size)

There may be other serial flags that you have to set for the master to
give/take control over the line, but this is a quick idea.

—
Reply to this email directly or view it on
GitHub<
https://github.com/bashwork/pymodbus/issues/33#issuecomment-25224214>

.

—
Reply to this email directly or view it on GitHub
#33 (comment).

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/33#issuecomment-25293550
.

on the other hand, why does Modpoll work, their simulation master and slave
runs fine over serial RS-485 ..

On Sat, Sep 28, 2013 at 12:30 AM, xvart notifications@github.com wrote:

Sorry but I have to dive in here,

Anyone running modbus on a multitasking OS such as linux or windows will
never be able to meet the requirements of the serial spec, there is no
debate on this, tasking is normally 10ms so meeting 3.5us timing
requirement just doesn't fit and never will.

RS485 is balanced 2 wire coms like RS422 and there is no RTS,CTS or any
other modem signalling system. If you want to send over RS485, get an
RS485 converter and move on this is not a modbus issue. On serial modbus
is a poll response protocol so RTS et al are meaningless, read the spec
it was designed for embedded systems probably bit bashing IO.

It is even probable that with a modern RS232 chip with buffering meeting
the 3.5us in the spec is not possible.

Sorry but anyone trying modbus over serial on a multitasking OS is at
the mercy of the external equipment.

see here for converters
http://www.usconverters.com/index.php?main_page=index&cPath=65

On 28/09/13 14:33, heming277 wrote:

Hi Galen,

what controller do people use, does the controller have automatic rs-485
half-duplex enable/disable flow control?

thanks

Heming

On Thu, Sep 26, 2013 at 10:43 PM, Galen Collins
notifications@github.comwrote:

Okay, so I haven't actually implemented a rs-485 solution with
pymodbus.
Are you stuck using the half duplex mode? Is there any chance you
can just
use a full duplex (4 wire) configuration? Otherwise, everyone I have
been
in contact with has simply used a controller that does the control line
detection for them.

I guess you can try to implement it yourself, but it may be a little
flakey (I have no clue if this is going to work or not)::
monkey patch ModbusSerialClient._send to the following

def _send(self, request):
''' Sends data on the underlying socket

:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
raise ConnectionException(self.str())
if request:
self.socket.setRTS(true) # may need to delay, poll, etc here
return self.socket.write(request)
return 0

monkey patch ModbusSerialClient._recv to the following

def _recv(self, size):
''' Reads data from the underlying descriptor

:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
raise ConnectionException(self.str())
client.socket.setRTS(false) # you shouldn't have to delay here
return self.socket.read(size)

There may be other serial flags that you have to set for the master to
give/take control over the line, but this is a quick idea.

—
Reply to this email directly or view it on
GitHub<
https://github.com/bashwork/pymodbus/issues/33#issuecomment-25224214>

.

—
Reply to this email directly or view it on GitHub
#33 (comment).

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/33#issuecomment-25293550
.

[xvart]

RS422 and RS485 are ballanced lines, you can get over 1km on them with
very good data rates and they are immune to noise. RS232 will go about
20m(60ft) before you start having issues this is why we use RS422/485 in
industrial aplications.

On 28/09/13 20:40, heming277 wrote:

ok thanks for the informative reply!

this helps very much i've been struggling for a long time.

However as you said even RS-232 is not possible, what's the point of
using
the RS-232 TO RS-485 converter then.

say if i want to connect from my master box to my slave box, how would
i do
it.

i have a FTDI USB to RS485 converter like this one
https://www.sparkfun.com/products/9822
and i do have a rs-232 to rs-485 converter.

On Sat, Sep 28, 2013 at 12:30 AM, xvart notifications@github.com wrote:

Sorry but I have to dive in here,

Anyone running modbus on a multitasking OS such as linux or windows
will
never be able to meet the requirements of the serial spec, there is no
debate on this, tasking is normally 10ms so meeting 3.5us timing
requirement just doesn't fit and never will.

RS485 is balanced 2 wire coms like RS422 and there is no RTS,CTS or any
other modem signalling system. If you want to send over RS485, get an
RS485 converter and move on this is not a modbus issue. On serial
modbus
is a poll response protocol so RTS et al are meaningless, read the spec
it was designed for embedded systems probably bit bashing IO.

It is even probable that with a modern RS232 chip with buffering
meeting
the 3.5us in the spec is not possible.

Sorry but anyone trying modbus over serial on a multitasking OS is at
the mercy of the external equipment.

see here for converters
http://www.usconverters.com/index.php?main_page=index&cPath=65

On 28/09/13 14:33, heming277 wrote:

Hi Galen,

what controller do people use, does the controller have automatic
rs-485
half-duplex enable/disable flow control?

thanks

Heming

On Thu, Sep 26, 2013 at 10:43 PM, Galen Collins
notifications@github.comwrote:

Okay, so I haven't actually implemented a rs-485 solution with
pymodbus.
Are you stuck using the half duplex mode? Is there any chance you
can just
use a full duplex (4 wire) configuration? Otherwise, everyone I
have
been
in contact with has simply used a controller that does the
control line
detection for them.

I guess you can try to implement it yourself, but it may be a
little
flakey (I have no clue if this is going to work or not)::
monkey patch ModbusSerialClient._send to the following

def _send(self, request):
''' Sends data on the underlying socket

:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
raise ConnectionException(self.str())
if request:
self.socket.setRTS(true) # may need to delay, poll, etc here
return self.socket.write(request)
return 0

monkey patch ModbusSerialClient._recv to the following

def _recv(self, size):
''' Reads data from the underlying descriptor

:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
raise ConnectionException(self.str())
client.socket.setRTS(false) # you shouldn't have to delay here
return self.socket.read(size)

There may be other serial flags that you have to set for the
master to
give/take control over the line, but this is a quick idea.

—
Reply to this email directly or view it on
GitHub<
https://github.com/bashwork/pymodbus/issues/33#issuecomment-25224214>

.

—
Reply to this email directly or view it on GitHub

#33 (comment).

—
Reply to this email directly or view it on
GitHubhttps://github.com//issues/33#issuecomment-25293550
.

—
Reply to this email directly or view it on GitHub
#33 (comment).