libmodbus4r 0.2.2 → 0.3.0

data/ext/slave.c

@@ -0,0 +1,215 @@
+/* libmodbus4r - binding use libmodbus for Ruby.
+Copyright (C) 2009  Timin Aleksey
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details. */
+
+#include <unistd.h>
+#include <pthread.h>
+#include "modbus4r.h"
+#include "slave.h"
+
+void mb_push_coil_status(modbus_slave_t *mb_slave)
+{
+    int len = RARRAY_LEN(mb_slave->coil_status);
+    VALUE *ptr_coil = RARRAY_PTR(mb_slave->coil_status);
+    mb_slave->mb_map->nb_coil_status = len; 
+    mb_slave->mb_map->tab_coil_status = malloc(sizeof(uint8_t) * len);
+    uint8_t *ptr_map = mb_slave->mb_map->tab_coil_status;
+
+    int i;
+    for (i = 0; i < len; i++) {
+        *ptr_map = (*ptr_coil == Qtrue ? 1 : 0);
+        ptr_coil++;
+        ptr_map++;
+    }
+}
+
+void mb_pull_coil_status(modbus_slave_t *mb_slave)
+{
+    uint8_t *ptr_map = mb_slave->mb_map->tab_coil_status;
+    VALUE *ptr_coil = RARRAY_PTR(mb_slave->coil_status);
+    int i;
+    for(i = 0; i < mb_slave->mb_map->nb_coil_status; i++) {
+       *ptr_coil = (*ptr_map == 0 ? Qfalse : Qtrue);
+       ptr_coil++;
+       ptr_map++;
+    }
+}
+
+void mb_push_input_status(modbus_slave_t *mb_slave)
+{
+    int len = RARRAY_LEN(mb_slave->input_status);
+    VALUE *ptr_input = RARRAY_PTR(mb_slave->input_status);
+    mb_slave->mb_map->nb_input_status = len; 
+    mb_slave->mb_map->tab_input_status = malloc(sizeof(uint8_t) * len);
+    uint8_t *ptr_map = mb_slave->mb_map->tab_input_status;
+
+    int i;
+    for (i = 0; i < len; i++) {
+        *ptr_map = (*ptr_input == Qtrue ? 1 : 0);
+        ptr_input++;
+        ptr_map++;
+    }
+}
+
+void mb_push_holding_registers(modbus_slave_t *mb_slave)
+{
+    int len = RARRAY_LEN(mb_slave->holding_registers);
+    VALUE *ptr_reg = RARRAY_PTR(mb_slave->holding_registers);
+    mb_slave->mb_map->nb_holding_registers = len; 
+    mb_slave->mb_map->tab_holding_registers = malloc(sizeof(uint16_t) * len);
+    uint16_t *ptr_map = mb_slave->mb_map->tab_holding_registers;
+
+    int i;
+    for (i = 0; i < len; i++) {
+        *ptr_map = FIX2INT(*ptr_reg);
+        ptr_reg++;
+        ptr_map++;
+    }
+}
+
+void mb_pull_holding_registers(modbus_slave_t *mb_slave)
+{
+    uint16_t *ptr_map = mb_slave->mb_map->tab_holding_registers;
+    VALUE *ptr_reg = RARRAY_PTR(mb_slave->holding_registers);
+    int i;
+    for(i = 0; i < mb_slave->mb_map->nb_holding_registers; i++) {
+       *ptr_reg = INT2FIX(*ptr_map);
+       ptr_reg++;
+       ptr_map++;
+    }
+}
+
+void mb_push_input_registers(modbus_slave_t *mb_slave)
+{
+    int len = RARRAY_LEN(mb_slave->input_registers);
+    VALUE *ptr_reg = RARRAY_PTR(mb_slave->input_registers);
+    mb_slave->mb_map->nb_input_registers = len; 
+    mb_slave->mb_map->tab_input_registers = malloc(sizeof(uint16_t) * len);
+    uint16_t *ptr_map = mb_slave->mb_map->tab_input_registers;
+
+    int i;
+    for (i = 0; i < len; i++) {
+        *ptr_map = FIX2INT(*ptr_reg);
+        ptr_reg++;
+        ptr_map++;
+    }
+}
+
+VALUE mb_sl_is_stoped(VALUE self)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    if (read(mb_slave->listen_sock, NULL, 0) 
+            || mb_slave->listen_sock == 0) { 
+        return Qtrue;
+    }
+    return Qfalse;
+}
+
+VALUE mb_sl_get_coil_status(VALUE self)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    return mb_slave->coil_status;
+}
+
+VALUE mb_sl_set_coil_status(VALUE self, VALUE value)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    value = rb_funcall(value, rb_intern("to_a"), 0);
+    mb_slave->coil_status = rb_ary_dup(value);
+    
+    return mb_slave->coil_status;
+}
+
+VALUE mb_sl_get_input_status(VALUE self)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    return mb_slave->input_status;
+}
+
+VALUE mb_sl_set_input_status(VALUE self, VALUE value)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    value = rb_funcall(value, rb_intern("to_a"), 0);
+    mb_slave->input_status = rb_ary_dup(value);
+        
+    return mb_slave->input_status;
+}
+
+VALUE mb_sl_get_holding_registers(VALUE self)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    return mb_slave->holding_registers;
+}
+
+VALUE mb_sl_set_holding_registers(VALUE self, VALUE value)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    value = rb_funcall(value, rb_intern("to_a"), 0);
+    mb_slave->holding_registers = rb_ary_dup(value);
+    VALUE *reg = RARRAY_PTR(mb_slave->holding_registers);
+    
+    int i;
+    for (i = 0; i < RARRAY_LEN(mb_slave->holding_registers); i++) {
+         *reg = rb_funcall(*reg, rb_intern("to_i"), 0);
+    }
+        
+    return mb_slave->holding_registers;
+}
+
+VALUE mb_sl_get_input_registers(VALUE self)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    return mb_slave->input_registers;
+}
+
+VALUE mb_sl_set_input_registers(VALUE self, VALUE value)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    value = rb_funcall(value, rb_intern("to_a"), 0);
+    mb_slave->input_registers = rb_ary_dup(value);
+    VALUE *reg = RARRAY_PTR(mb_slave->input_registers);
+    
+    int i;
+    for (i = 0; i < RARRAY_LEN(mb_slave->input_registers); i++) {
+         *reg = rb_funcall(*reg, rb_intern("to_i"), 0);
+    }
+        
+    return mb_slave->input_registers;
+}
+
+VALUE mb_sl_join(VALUE self)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    pthread_join(mb_slave->tid, NULL);
+
+    return self;
+}

data/ext/slave.h

@@ -0,0 +1,44 @@
+/* libmodbus4r - binding use libmodbus for Ruby.
+Copyright (C) 2009  Timin Aleksey
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details. */
+
+#ifndef SLAVE_H
+#define SLAVE_H
+
+typedef struct {
+    pthread_t tid;
+    int listen_sock;
+    modbus_param_t *mb_param;
+    modbus_mapping_t *mb_map;
+    VALUE coil_status;
+    VALUE input_status;
+    VALUE holding_registers;
+    VALUE input_registers;
+} modbus_slave_t;
+
+extern void mb_push_coil_status(modbus_slave_t *mb_slave);
+extern void mb_pull_coil_status(modbus_slave_t *mb_slave);
+extern void mb_push_input_status(modbus_slave_t *mb_slave);
+extern void mb_push_holding_registers(modbus_slave_t *mb_slave);
+extern void mb_pull_holding_registers(modbus_slave_t *mb_slave);
+extern void mb_push_input_registers(modbus_slave_t *mb_slave);
+extern VALUE mb_sl_is_stoped(VALUE self);
+extern VALUE mb_sl_get_coil_status(VALUE self);
+extern VALUE mb_sl_set_coil_status(VALUE self, VALUE value);
+extern VALUE mb_sl_get_input_status(VALUE self);
+extern VALUE mb_sl_set_input_status(VALUE self, VALUE value);
+extern VALUE mb_sl_get_holding_registers(VALUE self);
+extern VALUE mb_sl_set_holding_registers(VALUE self, VALUE value);
+extern VALUE mb_sl_get_input_registers(VALUE self);
+extern VALUE mb_sl_set_input_registers(VALUE self, VALUE value);
+extern VALUE mb_sl_join(VALUE self);
+#endif

data/ext/tcp_master.c

@@ -12,22 +12,18 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details. */
 
 #include "modbus4r.h"
+#include "master.h"
 
-void mb_tcp_mstr_free(modbus_param_t *mb_param )
-{
-    modbus_close(mb_param);
-    free(mb_param);
-}
-
-VALUE mb_tcp_mstr_new(VALUE self, VALUE ip_address, VALUE port)
+VALUE mb_tcp_mstr_new(VALUE self, VALUE ip_address, VALUE port, VALUE slave)
 {
     modbus_param_t *mb_param;
 
     mb_param = malloc(sizeof(modbus_param_t));
     ip_address = rb_funcall(ip_address, rb_intern("to_s"), 0);
     port = rb_funcall(port, rb_intern("to_i"), 0);
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
 
-    modbus_init_tcp(mb_param, RSTRING_PTR(ip_address), FIX2INT(port));
+    modbus_init_tcp(mb_param, RSTRING_PTR(ip_address), FIX2INT(port), FIX2INT(slave));
 
-    return Data_Wrap_Struct(self, 0, mb_tcp_mstr_free, mb_param);
+    return Data_Wrap_Struct(self, 0, mb_mstr_free, mb_param);
 }

data/ext/tcp_master.h

@@ -14,6 +14,7 @@ GNU General Public License for more details. */
 #ifndef TCP_MASTER_H
 #define TCP_MASTER_H
 
-extern VALUE mb_tcp_mstr_new(VALUE self, VALUE ip_address, VALUE port);
+extern VALUE mb_tcp_mstr_new(VALUE self, 
+                VALUE ip_address, VALUE port, VALUE slave);
 
 #endif

data/ext/tcp_slave.c

@@ -0,0 +1,134 @@
+/* libmodbus4r - binding use libmodbus for Ruby.
+Copyright (C) 2009  Timin Aleksey
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details. */
+
+#include <pthread.h> 
+#include <unistd.h>
+#include "modbus4r.h"
+#include "slave.h"
+#include "errors.h"
+
+void mb_tcp_sl_free(modbus_slave_t *mb_slave)
+{
+    close(mb_slave->listen_sock);
+    pthread_cancel(mb_slave->tid);
+
+    modbus_close(mb_slave->mb_param);
+
+    modbus_mapping_free(mb_slave->mb_map);
+    
+#ifndef RUBY_1_8
+    rb_ary_free(mb_slave->coil_status); 
+    rb_ary_free(mb_slave->input_status); 
+    rb_ary_free(mb_slave->holding_registers); 
+    rb_ary_free(mb_slave->input_registers); 
+#else
+    free(RARRAY_PTR(mb_slave->coil_status)); 
+    free(RARRAY_PTR(mb_slave->input_status)); 
+    free(RARRAY_PTR(mb_slave->holding_registers)); 
+    free(RARRAY_PTR(mb_slave->input_registers)); 
+#endif
+
+    free(mb_slave);
+}
+
+void *mb_tcp_serv(void *arg)
+{
+    modbus_slave_t *mb_slave = (modbus_slave_t *)arg;
+
+    mb_slave->listen_sock = modbus_slave_listen_tcp(mb_slave->mb_param, 1);
+
+    while (1) {
+        modbus_slave_accept_tcp(mb_slave->mb_param, 
+                                &mb_slave->listen_sock);
+        uint8_t query[MAX_MESSAGE_LENGTH];
+        int query_size;
+        while(1) {
+            int ret = modbus_slave_receive(mb_slave->mb_param, -1,
+                                        query, &query_size);
+
+            if (ret == 0) {
+                mb_push_coil_status(mb_slave);
+                mb_push_input_status(mb_slave);
+                mb_push_holding_registers(mb_slave);
+                mb_push_input_registers(mb_slave);
+
+                modbus_slave_manage(mb_slave->mb_param, query, 
+                                    query_size, mb_slave->mb_map);
+
+                mb_pull_coil_status(mb_slave);
+                mb_pull_holding_registers(mb_slave);
+            } else if (ret == CONNECTION_CLOSED) {
+                modbus_close(mb_slave->mb_param);
+                break;
+            } else {
+                continue;
+            }
+        }
+    }
+}
+
+VALUE mb_tcp_sl_new(VALUE self, VALUE ip_address, VALUE port, VALUE slave)
+{
+    modbus_slave_t *mb_slave;
+    mb_slave = malloc(sizeof(modbus_slave_t));
+    mb_slave->mb_param = malloc(sizeof(modbus_param_t));
+    mb_slave->mb_map = malloc(sizeof(modbus_mapping_t));
+
+    ip_address = rb_funcall(ip_address, rb_intern("to_s"), 0);
+    port = rb_funcall(port, rb_intern("to_i"), 0);
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
+
+    modbus_init_tcp(mb_slave->mb_param, RSTRING_PTR(ip_address), FIX2INT(port), FIX2INT(slave));
+
+    int ret = modbus_mapping_new(mb_slave->mb_map, 0, 0, 0, 0);
+    if (ret < 0) {
+        rb_raise(rb_eStandardError, "Memory allocation failed");
+    }
+    
+    mb_slave->coil_status = rb_ary_new();
+    mb_slave->input_status = rb_ary_new();
+    mb_slave->holding_registers = rb_ary_new();
+    mb_slave->input_registers = rb_ary_new();
+
+    return Data_Wrap_Struct(self, 0, mb_tcp_sl_free, mb_slave);
+}
+
+VALUE mb_tcp_sl_start(VALUE self)
+{    
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    int ret = pthread_create(&mb_slave->tid, NULL, mb_tcp_serv, 
+                                (void *)mb_slave);
+    if (ret != 0) {
+        rb_raise(rb_eStandardError, "Slave has not started");
+    }
+    
+    return self;
+}
+
+VALUE mb_tcp_sl_stop(VALUE self)
+{
+    modbus_slave_t *mb_slave;
+    Data_Get_Struct(self, modbus_slave_t, mb_slave);
+
+    int ret = pthread_cancel(mb_slave->tid);
+    if (ret != 0) {
+        rb_raise(rb_eStandardError, "Slave has not stoped");
+    }
+    
+    close(mb_slave->listen_sock);
+    modbus_close(mb_slave->mb_param);
+
+    return self;
+}

data/ext/tcp_slave.h

@@ -0,0 +1,21 @@
+/* libmodbus4r - binding use libmodbus for Ruby.
+Copyright (C) 2009  Timin Aleksey
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details. */
+
+#ifndef TCP_SLAVE_H
+#define TCP_SLAVE_H
+
+extern VALUE mb_tcp_sl_new(VALUE self, VALUE ip_address, VALUE port, VALUE id);
+extern VALUE mb_tcp_sl_start(VALUE self);
+extern VALUE mb_tcp_sl_stop(VALUE self);
+
+#endif

data/lib/modbus4r.rb

@@ -1,14 +1,15 @@
-#libmodbus4r - binding use libmodbus for Ruby.
-#Copyright (C) 2009  Timin Aleksey
+# libmodbus4r - binding use libmodbus for Ruby.
+# Copyright (C) 2009  Timin Aleksey
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
 
-#This program is free software: you can redistribute it and/or modify
-#it under the terms of the GNU General Public License as published by
-#the Free Software Foundation, either version 3 of the License, or
-#(at your option) any later version.
-
-#This program is distributed in the hope that it will be useful,
-#but WITHOUT ANY WARRANTY; without even the implied warranty of
-#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#GNU General Public License for more details. */
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details. 
 
 require '_modbus4r'
+

data/spec/rtu_master_spec.rb

@@ -3,7 +3,7 @@ require 'modbus4r'
 describe ModBus::RTUMaster do
 
   before(:all) do
-    @mstr = ModBus::RTUMaster.new('/dev/ttyS3', 9600, 'none', 8, 1)
+    @mstr = ModBus::RTUMaster.new('/dev/ttyS3', 9600, 'none', 8, 1, 1)
     @mstr.connect
   end
 

data/spec/rtu_slave_spec.rb

@@ -0,0 +1,16 @@
+require 'modbus4r'
+
+describe ModBus::RTUSlave do
+  before(:all) do
+    @sl = ModBus::RTUSlave.new('/dev/ttyS3', 9600, 'none', 8, 1, 1)
+    @sl.start
+  end
+
+  it "should be start" do
+    @sl.stoped?.should == false
+  end
+
+  after(:all) do
+    @sl.stop unless @sl.stoped?
+  end
+end

data/spec/tcp_master_spec.rb

@@ -3,12 +3,21 @@ require 'modbus4r'
 describe ModBus::TCPMaster do
 
   before(:all) do
-    @mstr = ModBus::TCPMaster.new('127.0.0.1', 1502)
+    @sl = ModBus::TCPSlave.new('127.0.0.1', 1502, 1)
+    @sl.coil_status = [false, false, false, false, 
+                        false, false, false, false]
+    @sl.input_status = [false, false, false, false,
+                        false, false, false, false]
+    @sl.holding_registers = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+    @sl.input_registers = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+    @sl.start
+
+    @mstr = ModBus::TCPMaster.new('127.0.0.1', 1502, 1)
     @mstr.connect
   end
 
   it "should raise exception if have'n connected with slave" do
-    mstr = ModBus::TCPMaster.new('127.0.0.1', 1503)
+    mstr = ModBus::TCPMaster.new('127.0.0.1', 1503, 1)
     mstr.closed?.should == true
     lambda { mstr.connect }.should raise_error(ModBus::Errors::ModBusError, "Connection refused")
   end
@@ -19,101 +28,102 @@ describe ModBus::TCPMaster do
 
   # Read coil status
   it "should read coil status" do
-    @mstr.read_coil_status(0x11, 0, 4).should == [false, false, false, false]
+    @mstr.read_coil_status(0, 4).should == [false, false, false, false]
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.read_coil_status(0x11, 0, 501) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.read_coil_status(0, 501) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
 
   it "should raise exception if too many data" do
-   lambda { @mstr.read_coil_status(0x11, 0, 0x07D1) }.should raise_error(ModBus::Errors::ModBusError, "Too many data (-15)")
+   lambda { @mstr.read_coil_status(0, 0x07D1) }.should raise_error(ModBus::Errors::ModBusError, "Invalid data (-16)")
   end
 
   # Read input status
   it "should read discrete inputs" do
-    @mstr.read_input_status(0x11, 0, 4).should == [false, false, false, false]
+    @mstr.read_input_status(0, 4).should == [false, false, false, false]
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.read_input_status(0x11, 0, 501) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.read_input_status(0, 501) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
 
   it "should raise exception if too many data" do
-   lambda { @mstr.read_input_status(0x11, 0, 0x07D1) }.should raise_error(ModBus::Errors::ModBusError, "Too many data (-15)")
+   lambda { @mstr.read_input_status(0, 0x07D1) }.should raise_error(ModBus::Errors::ModBusError, "Invalid data (-16)")
   end
 
   # Read holding registers
   it "should read discrete inputs" do
-    @mstr.read_holding_registers(0x11, 0, 4).should == [0, 0, 0, 0]
+    @mstr.read_holding_registers(0, 4).should == [0, 0, 0, 0]
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.read_holding_registers(0x11, 402, 99) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.read_holding_registers(402, 99) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
 
   it "should raise exception if too many data" do
-   lambda { @mstr.read_holding_registers(0x11, 0, 0x007E) }.should raise_error(ModBus::Errors::ModBusError, "Too many data (-15)")
+   lambda { @mstr.read_holding_registers(0, 0x007E) }.should raise_error(ModBus::Errors::ModBusError, "Invalid data (-16)")
   end
 
   # Read input registers
   it "should read discrete inputs" do
-    @mstr.read_input_registers(0x11, 0, 4).should == [0, 0, 0, 0]
+    @mstr.read_input_registers(0, 4).should == [0, 0, 0, 0]
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.read_input_registers(0x11, 402, 99) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.read_input_registers(402, 99) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
   it "should raise exception if too many data" do
-   lambda { @mstr.read_input_registers(0x11, 0, 0x007E) }.should raise_error(ModBus::Errors::ModBusError, "Too many data (-15)")
+   lambda { @mstr.read_input_registers(0, 0x007E) }.should raise_error(ModBus::Errors::ModBusError, "Invalid data (-16)")
   end
 
   # Force single coil
   it "should force single coil" do
-    @mstr.force_single_coil(0x11, 4, true).should == @mstr
-    @mstr.read_coil_status(0x11, 4, 4).should == [true, false, false, false] 
+    @mstr.force_single_coil(4, true).should == @mstr
+    @mstr.read_coil_status(4, 4).should == [true, false, false, false] 
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.force_single_coil(0x11, 501, true) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.force_single_coil(501, true) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
   # Preset single register
   it "should preset single register" do
-    @mstr.preset_single_register(0x11, 4, 0x0AA0).should == @mstr
-    @mstr.read_holding_registers(0x11, 4, 1).should == [0x0AA0] 
+    @mstr.preset_single_register(4, 0x0AA0).should == @mstr
+    @mstr.read_holding_registers(4, 1).should == [0x0AA0] 
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.preset_single_register(0x11, 501, 0x0AA0) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.preset_single_register(501, 0x0AA0) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
   # Force multiple coils
   it "should force multiple coils" do
-    @mstr.force_multiple_coils(0x11, 14, [false, true, false, true]).should == @mstr
-    @mstr.read_coil_status(0x11, 13, 5).should == [false, false, true, false, true] 
+    @mstr.force_multiple_coils(4, [false, true, false, true]).should == @mstr
+    @mstr.read_coil_status(3, 5).should == [false, false, true, false, true] 
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.force_multiple_coils(0x11, 501, [true, false]) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.force_multiple_coils(501, [true, false]) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
   # Preset multiple registers
   it "should preset multiple registers" do
-    @mstr.preset_multiple_registers(0x11, 14, [1, 2, 3, 0xAACC]).should == @mstr
-    @mstr.read_holding_registers(0x11, 13, 5).should == [0, 1, 2, 3, 0xAACC] 
+    @mstr.preset_multiple_registers(4, [1, 2, 3, 0xAACC]).should == @mstr
+    @mstr.read_holding_registers(3, 5).should == [0, 1, 2, 3, 0xAACC] 
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @mstr.preset_multiple_registers(0x11, 501, [1, 2]) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
+   lambda { @mstr.preset_multiple_registers(501, [1, 2]) }.should raise_error(ModBus::Errors::IllegalDataAddress, "Illegal data address (-2)")
   end
 
   after(:all) do
     @mstr.close unless @mstr.closed?
+    @sl.stop unless @sl.stoped?
   end
 
 end