title: How do assign holding registers in pymodbus?
body: <p>I am making a modbus server on a Raspberry Pi Zero to send data to a Modbus Client/Data Logger. I am trying to use <a href="https://pymodbus.readthedocs.io/en/latest/readme.html" rel="nofollow noreferrer">pymodbus</a> but I am having trouble following the documentation and was wondering if someone could show me how to assign specific values to holding register? I am using the <a href="https://pymodbus.readthedocs.io/en/latest/source/example/synchronous_server.html" rel="nofollow noreferrer">Synchronous Server Example</a> as my starting point. I am fairly new to Python and really need to understand what is going on in this code/program so if I need to make changes I can. Any help would be appreciated.</p>
  
  <pre><code>#!/usr/bin/env python
  """
  Pymodbus Synchronous Server Example
  --------------------------------------------------------------------------
  
  The synchronous server is implemented in pure python without any third
  party libraries (unless you need to use the serial protocols which require
  pyserial). This is helpful in constrained or old environments where using
  twisted is just not feasible. What follows is an example of its use:
  """
  # --------------------------------------------------------------------------- #
  # import the various server implementations
  # --------------------------------------------------------------------------- #
  from pymodbus.server.sync import StartTcpServer
  from pymodbus.server.sync import StartUdpServer
  from pymodbus.server.sync import StartSerialServer
  
  from pymodbus.device import ModbusDeviceIdentification
  from pymodbus.datastore import ModbusSequentialDataBlock, ModbusSparseDataBlock
  from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
  
  from pymodbus.transaction import ModbusRtuFramer, ModbusBinaryFramer
  # --------------------------------------------------------------------------- #
  # configure the service logging
  # --------------------------------------------------------------------------- #
  import logging
  FORMAT = ('%(asctime)-15s %(threadName)-15s'
            ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
  logging.basicConfig(format=FORMAT)
  log = logging.getLogger()
  log.setLevel(logging.DEBUG)
  
  
  def run_server():
      # ----------------------------------------------------------------------- #
      # initialize your data store
      # ----------------------------------------------------------------------- #
      # The datastores only respond to the addresses that they are initialized to
      # Therefore, if you initialize a DataBlock to addresses of 0x00 to 0xFF, a
      # request to 0x100 will respond with an invalid address exception. This is
      # because many devices exhibit this kind of behavior (but not all)::
      #
      #     block = ModbusSequentialDataBlock(0x00, [0]*0xff)
      #
      # Continuing, you can choose to use a sequential or a sparse DataBlock in
      # your data context.  The difference is that the sequential has no gaps in
      # the data while the sparse can. Once again, there are devices that exhibit
      # both forms of behavior::
      #
      #     block = ModbusSparseDataBlock({0x00: 0, 0x05: 1})
      #     block = ModbusSequentialDataBlock(0x00, [0]*5)
      #
      # Alternately, you can use the factory methods to initialize the DataBlocks
      # or simply do not pass them to have them initialized to 0x00 on the full
      # address range::
      #
      #     store = ModbusSlaveContext(di = ModbusSequentialDataBlock.create())
      #     store = ModbusSlaveContext()
      #
      # Finally, you are allowed to use the same DataBlock reference for every
      # table or you may use a separate DataBlock for each table.
      # This depends if you would like functions to be able to access and modify
      # the same data or not::
      #
      #     block = ModbusSequentialDataBlock(0x00, [0]*0xff)
      #     store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
      #
      # The server then makes use of a server context that allows the server to
      # respond with different slave contexts for different unit ids. By default
      # it will return the same context for every unit id supplied (broadcast
      # mode).
      # However, this can be overloaded by setting the single flag to False and
      # then supplying a dictionary of unit id to context mapping::
      #
      #     slaves  = {
      #         0x01: ModbusSlaveContext(...),
      #         0x02: ModbusSlaveContext(...),
      #         0x03: ModbusSlaveContext(...),
      #     }
      #     context = ModbusServerContext(slaves=slaves, single=False)
      #
      # The slave context can also be initialized in zero_mode which means that a
      # request to address(0-7) will map to the address (0-7). The default is
      # False which is based on section 4.4 of the specification, so address(0-7)
      # will map to (1-8)::
      #
      #     store = ModbusSlaveContext(..., zero_mode=True)
      # ----------------------------------------------------------------------- #
      store = ModbusSlaveContext(
          di=ModbusSequentialDataBlock(0, [17]*100),
          co=ModbusSequentialDataBlock(0, [17]*100),
          hr=ModbusSequentialDataBlock(0, [17]*100),
          ir=ModbusSequentialDataBlock(0, [17]*100))
  
      context = ModbusServerContext(slaves=store, single=True)
  
      # ----------------------------------------------------------------------- #
      # initialize the server information
      # ----------------------------------------------------------------------- #
      # If you don't set this or any fields, they are defaulted to empty strings.
      # ----------------------------------------------------------------------- #
      identity = ModbusDeviceIdentification()
      identity.VendorName = 'Pymodbus'
      identity.ProductCode = 'PM'
      identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
      identity.ProductName = 'Pymodbus Server'
      identity.ModelName = 'Pymodbus Server'
      identity.MajorMinorRevision = '1.5'
  
      # ----------------------------------------------------------------------- #
      # run the server you want
      # ----------------------------------------------------------------------- #
      # Tcp:
      StartTcpServer(context, identity=identity, address=("localhost", 5020))
  
      # TCP with different framer
      # StartTcpServer(context, identity=identity,
      #                framer=ModbusRtuFramer, address=("0.0.0.0", 5020))
  
      # Udp:
      # StartUdpServer(context, identity=identity, address=("0.0.0.0", 5020))
  
      # Ascii:
      # StartSerialServer(context, identity=identity,
      #                    port='/dev/ttyp0', timeout=1)
  
      # RTU:
      # StartSerialServer(context, framer=ModbusRtuFramer, identity=identity,
      #                   port='/dev/ttyp0', timeout=.005, baudrate=9600)
  
      # Binary
      # StartSerialServer(context,
      #                   identity=identity,
      #                   framer=ModbusBinaryFramer,
      #                   port='/dev/ttyp0',
      #                   timeout=1)
  
  
  if __name__ == "__main__":
      run_server()
  </code></pre>
  
  <p>Looks like I am using the wrong server and should be using the callback server but I am still unsure how to assign data to a input/holding register that is read in by a local sensor/device. Here is the Code to the <a href="https://github.com/riptideio/pymodbus/blob/master/examples/common/callback_server.py" rel="nofollow noreferrer">Call back Server:</a></p>
  
  <pre><code>#!/usr/bin/env python
  """
  Pymodbus Server With Callbacks
  --------------------------------------------------------------------------
  This is an example of adding callbacks to a running modbus server
  when a value is written to it. In order for this to work, it needs
  a device-mapping file.
  """
  # --------------------------------------------------------------------------- #
  # import the modbus libraries we need
  # --------------------------------------------------------------------------- #
  from pymodbus.server.async import StartTcpServer
  from pymodbus.device import ModbusDeviceIdentification
  from pymodbus.datastore import ModbusSparseDataBlock
  from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
  from pymodbus.transaction import ModbusRtuFramer, ModbusAsciiFramer
  
  
  # --------------------------------------------------------------------------- #
  # import the python libraries we need
  # --------------------------------------------------------------------------- #
  from multiprocessing import Queue, Process
  
  # --------------------------------------------------------------------------- #
  # configure the service logging
  # --------------------------------------------------------------------------- #
  import logging
  logging.basicConfig()
  log = logging.getLogger()
  log.setLevel(logging.DEBUG)
  
  # --------------------------------------------------------------------------- #
  # create your custom data block with callbacks
  # --------------------------------------------------------------------------- #
  
  
  class CallbackDataBlock(ModbusSparseDataBlock):
      """ A datablock that stores the new value in memory
      and passes the operation to a message queue for further
      processing.
      """
  
      def __init__(self, devices, queue):
          """
          """
          self.devices = devices
          self.queue = queue
  
          values = {k: 0 for k in devices.keys()}
          values[0xbeef] = len(values)  # the number of devices
          super(CallbackDataBlock, self).__init__(values)
  
      def setValues(self, address, value):
          """ Sets the requested values of the datastore
          :param address: The starting address
          :param values: The new values to be set
          """
          super(CallbackDataBlock, self).setValues(address, value)
          self.queue.put((self.devices.get(address, None), value))
  
  # --------------------------------------------------------------------------- #
  # define your callback process
  # --------------------------------------------------------------------------- #
  
  
  def rescale_value(value):
      """ Rescale the input value from the range
      of 0..100 to -3200..3200.
      :param value: The input value to scale
      :returns: The rescaled value
      """
      s = 1 if value &gt;= 50 else -1
      c = value if value &lt; 50 else (value - 50)
      return s * (c * 64)
  
  
  def device_writer(queue):
      """ A worker process that processes new messages
      from a queue to write to device outputs
      :param queue: The queue to get new messages from
      """
      while True:
          device, value = queue.get()
          scaled = rescale_value(value[0])
          log.debug("Write(%s) = %s" % (device, value))
          if not device: continue
          # do any logic here to update your devices
  
  # --------------------------------------------------------------------------- #
  # initialize your device map
  # --------------------------------------------------------------------------- #
  
  
  def read_device_map(path):
      """ A helper method to read the device
      path to address mapping from file::
         0x0001,/dev/device1 
         0x0002,/dev/device2 
      :param path: The path to the input file
      :returns: The input mapping file
      """
      devices = {}
      with open(path, 'r') as stream:
          for line in stream:
              piece = line.strip().split(',')
              devices[int(piece[0], 16)] = piece[1]
      return devices
  
  
  def run_callback_server():
      # ----------------------------------------------------------------------- #
      # initialize your data store
      # ----------------------------------------------------------------------- #
      queue = Queue()
      devices = read_device_map("device-mapping")
      block = CallbackDataBlock(devices, queue)
      store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
      context = ModbusServerContext(slaves=store, single=True)
  
      # ----------------------------------------------------------------------- #
      # initialize the server information
      # ----------------------------------------------------------------------- #
      identity = ModbusDeviceIdentification()
      identity.VendorName = 'pymodbus'
      identity.ProductCode = 'PM'
      identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
      identity.ProductName = 'pymodbus Server'
      identity.ModelName = 'pymodbus Server'
      identity.MajorMinorRevision = '1.0'
  
      # ----------------------------------------------------------------------- #
      # run the server you want
      # ----------------------------------------------------------------------- #
      p = Process(target=device_writer, args=(queue,))
      p.start()
      StartTcpServer(context, identity=identity, address=("localhost", 5020))
  
  
  if __name__ == "__main__":
  run_callback_server()
  </code></pre>
  
  <p>Again any help is appreciated.</p>