BEDGE-3545 Update settings, Support float and signed integer ranges for simulation

Author: dhoomakethu

modbus_simulator/ui/datamodel.py

@@ -1,4 +1,4 @@
-from random import randint
+from random import randint, uniform
 from copy import deepcopy
 from kivy.adapters.dictadapter import DictAdapter
 from kivy.event import EventDispatcher
@@ -50,7 +50,7 @@ def deselect_from_composite(self, *args):
         pass
 
     def on_formatter_select(self, instance, value):
-        self.data_model.on_formatter_update(self.index, value)
+        self.data_model.on_formatter_update(self.index, self.text, value)
         self.text = value
 
 
@@ -145,9 +145,9 @@ def deselect_from_composite(self, *args):
     def on_text_validate(self, *args):
 
         try:
-            int(self.text)
+            float(self.text)
 
-            if not(self.minval <= int(self.text) <= self.maxval):
+            if not(self.minval <= float(self.text) <= self.maxval):
                 raise ValueError
             self.edit = False
             self.data_model.on_data_update(self.index, self.text)
@@ -184,7 +184,9 @@ def on_update(self, _parent, blockname, data):
         if event == 'sync_data':
             _parent.sync_data_callback(blockname, data.get('data', {}))
         else:
-            _parent.sync_formatter_callback(blockname, data.get('data', {}))
+            old_formatter = data.pop("old_formatter", None)
+            _parent.sync_formatter_callback(blockname, data.get('data', {}),
+                                            old_formatter)
 
 
 class DataModel(GridLayout):
@@ -408,7 +410,7 @@ def on_data_update(self, index, data):
         :param data:
         :return:
         """
-        index = self.get_address(int(index))
+        index = self.get_address(self.list_view.adapter.sorted_keys[index])
         try:
             self.list_view.adapter.data[index]
         except KeyError:
@@ -425,7 +427,7 @@ def on_data_update(self, index, data):
                                  self.blockname,
                                  data)
 
-    def on_formatter_update(self, index, data):
+    def on_formatter_update(self, index, old, new):
         """
         Callback function to use the formatter selected in the list view
         Args:
@@ -435,13 +437,15 @@ def on_formatter_update(self, index, data):
         Returns:
 
         """
-        index = self.get_address(int(index))
+        index = self.get_address(self.list_view.adapter.sorted_keys[index])
+        # index = self.get_address(int(index))
         try:
-            self.list_view.adapter.data[index]['formatter'] = data
+            self.list_view.adapter.data[index]['formatter'] = new
         except KeyError:
             index = str(index)
-            self.list_view.adapter.data[index]['formatter'] = data
+            self.list_view.adapter.data[index]['formatter'] = new
         _data = {'event': 'sync_formatter',
+                 'old_formatter': old,
                  'data': {index: self.list_view.adapter.data[index]}}
         self.dispatcher.dispatch('on_update', self._parent,
                                  self.blockname, _data)
@@ -458,7 +462,7 @@ def update_registers(self, new_values, update_info):
 
         self.list_view.adapter.update_for_new_data()
         self.refresh(new_values, to_remove)
-        pass
+        return self.list_view.adapter.data
 
     def refresh(self, data={}, to_remove=None):
         """
@@ -506,7 +510,17 @@ def _simulate_block_values(self):
             data = self.list_view.adapter.data
             if data:
                 for index, value in data.items():
-                    value = randint(self.minval, self.maxval)
+                    if self.blockname in ['input_registers',
+                                          'holding_registers']:
+                        if 'float' in data[index]['formatter']:
+                            value = round(uniform(self.minval, self.maxval), 2)
+                        else:
+                            value = randint(self.minval, self.maxval)
+                            if 'uint' in data[index]['formatter']:
+                                value = abs(value)
+                    else:
+                        value = randint(self.minval, self.maxval)
+
                     data[index]['value'] = value
                 self.refresh(data)
                 data = {'event': 'sync_data',

modbus_simulator/ui/gui.py

@@ -1,9 +1,14 @@
-'''
+"""'
 Modbus Simu App
 ===============
-'''
+"""
 import kivy
-kivy.require('1.4.2')
+import re
+import os
+import platform
+import six
+import struct
+from copy import deepcopy
 from kivy.app import App
 from kivy.properties import ObjectProperty
 from kivy.uix.boxlayout import BoxLayout
@@ -12,23 +17,23 @@
 from kivy.uix.settings import SettingsWithSidebar
 from kivy.uix.listview import ListView, ListItemButton
 from kivy.adapters.listadapter import ListAdapter
+from kivy.config import Config
+from kivy.lang import Builder
+
 from modbus_simulator.utils.constants import BLOCK_TYPES
 from modbus_simulator.utils.common import configure_modbus_logger
 from modbus_simulator.ui.settings import SettingIntegerWithRange
 from modbus_simulator.utils.backgroundJob import BackgroundJob
-import re
-import os
-import platform
-import six
 from json import load, dump
-from kivy.config import Config
-from kivy.lang import Builder
+
 import modbus_simulator.ui.datamodel  #noqa
 from pkg_resources import resource_filename
 from serial.serialutil import SerialException
 
 from distutils.version import LooseVersion
 
+kivy.require('1.4.2')
+
 if six.PY3:
     xrange = range
 
@@ -574,16 +579,19 @@ def sync_data_callback(self, blockname, data):
                         int(self.active_slave),
                         current_tab,
                         k,
-                        int(v['value']),
+                        float(v['value']),
                         v['formatter']
                     )
                 else:
                     self.modbus_device.set_values(int(self.active_slave),
-                                                  current_tab, k, int(v['value']))
+                                                  current_tab,
+                                                  k, int(v['value']))
         except KeyError:
             pass
+        except struct.error:
+            self.show_error("Invalid value supplied , Check the formatter!")
 
-    def sync_formatter_callback(self, blockname, data):
+    def sync_formatter_callback(self, blockname, data, old_formatter):
         ct = self.data_models.current_tab
         current_tab = MAP[ct.text]
         if blockname != current_tab:
@@ -592,20 +600,24 @@ def sync_formatter_callback(self, blockname, data):
             _data = self.data_map[self.active_slave][current_tab]
             _updated = {}
             for k, v in data.items():
+                old_wc = int(filter(str.isdigit, str(old_formatter)))/16
+                new_wc = int(filter(str.isdigit, v.get('formatter')))/16
                 new_val, count = self.modbus_device.decode(
                     int(self.active_slave), current_tab, k, v['formatter']
                 )
                 data[k]['value'] = new_val
                 _updated['offset'] = k
                 _updated['count'] = count
-                if count == 1:
+                if old_wc > new_wc:
                     missing = self.modbus_device.get_values(
-                        int(self.active_slave), current_tab, k, 4)
+                        int(self.active_slave), current_tab, k, old_wc-new_val)
                     for i, val in enumerate(missing):
                         o = int(k) + i
                         data[o] = {'value': val, 'formatter': 'uint16'}
             _data['data'].update(data)
-            ct.content.update_registers(_data['data'], _updated)
+            _data['data'] = dict(ct.content.update_registers(_data['data'],
+                                                             _updated)
+            )
 
         except KeyError:
             pass
@@ -664,7 +676,7 @@ def update_backend(self, slave_id, blockname, new_data):
                     slave_id,
                     blockname,
                     k,
-                    int(v['value']),
+                    float(v['value']),
                     v['formatter']
                 )
             else:
@@ -679,9 +691,9 @@ def change_simulation_settings(self, **kwargs):
 
     def change_datamodel_settings(self, key, value):
         if "max" in key:
-            data = {"maxval": int(value)}
+            data = {"maxval": float(value)}
         else:
-            data = {"minval": int(value)}
+            data = {"minval": float(value)}
 
         if "bin" in key:
             self.data_model_coil.reinit(**data)
@@ -727,15 +739,24 @@ def _sync_modbus_block_values(self):
                 for block_name, value in _data_map.items():
                     updated = {}
                     for k, v in value['data'].items():
-                        actual_data = self.modbus_device.get_values(
-                            int(self.active_slave),
-                            block_name,
-                            int(k),
-
-                        )
+                        if block_name in ['input_registers',
+                                          'holding_registers']:
+                            actual_data, count = self.modbus_device.decode(
+                                int(self.active_slave), block_name, k,
+                                v['formatter']
+                            )
+                        else:
+                            actual_data = self.modbus_device.get_values(
+                                int(self.active_slave),
+                                block_name,
+                                int(k),
+
+                            )
+                            actual_data = actual_data[0]
                         try:
-                            if actual_data[0] != int(v):
-                                updated[k] = actual_data[0]
+                            if actual_data != float(v['value']):
+                                v['value'] = actual_data
+                                updated[k] = v
                         except TypeError:
                             pass
                     if updated:

modbus_simulator/ui/settings.py

@@ -82,12 +82,12 @@ def _validate(self, instance):
             self._dismiss()
             try:
                 value = self.textinput.text.strip()
-                value = text_type(int(value))
+                value = text_type(float(value))
             except ValueError:
                 self.textinput.text = self.value
                 return
             if not self._override:
-                if self.minval <= int(value) <= self.maxval:
+                if self.minval <= float(value) <= self.maxval:
                     self.value = value
                 else:
                     self.value = str(self.default[self.default_key])