libmodbus4r 0.2.0 → 0.2.1

data/NEWS

@@ -0,0 +1,6 @@
+libmodbus 0.2.1 (2009-08-10)
+- Fix bug in Master::read_input_coils
+
+libmodbus 0.2.0 (2009-07-30)
+===========================
+- First public release

data/README

@@ -2,7 +2,7 @@
 
 Binding use *libmodbus* (free implementation of modbus for Linux\MacOS) for Ruby.
 
-== Futures
+== Features
 
 * Use only Ruby-1.9.x
 * Use C library *libmodbus*;
@@ -32,7 +32,7 @@ Aleksey Timin <atimin@gmail.com>
 
 == Refernces 
 
-Home page projects : http://flipback.github.com/libmodbus4r
+Home page projects : http://flipback.github.com/libmodbus4r/
 Hosting on RubyForge : http://rubyforge.org/projects/libmodbus4r
 Hosting on GitHub : http://github.com/flipback/libmodbus4r/tree/master
 

data/TODO

@@ -0,0 +1,5 @@
+Next release 0.3.0
+======================
+- Migrate on libmodbus-2.2.0
+- Add TCP\RTU slave
+

data/ext/errors.c

@@ -0,0 +1,81 @@
+/* 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 "modbus4r.h"
+
+VALUE mErrors, eModBusError, eIllegalFunction,
+    eIllegalDataAddress, eIllegalDataValue,
+    eSlaveDeviceFailure, eAcknowledge, 
+    eSlaveDeviceBusy, eNegativeAcknowledge,
+    eMemoryParityError, eGatewayProblemPath, eGatewayProblemTarget; 
+
+void mb_raise_error(int exception)
+{
+    switch (exception) {
+        case ILLEGAL_FUNCTION:
+            rb_raise(eIllegalFunction, "Illegal function code (%i)", ILLEGAL_FUNCTION);
+            break;
+        case ILLEGAL_DATA_ADDRESS:
+            rb_raise(eIllegalDataAddress, "Illegal data address (%i)", ILLEGAL_DATA_ADDRESS);
+            break;
+        case  ILLEGAL_DATA_VALUE:
+            rb_raise(eIllegalDataValue, "Illegal data value (%i)", ILLEGAL_DATA_VALUE);
+            break;
+        case SLAVE_DEVICE_FAILURE:
+            rb_raise(eSlaveDeviceFailure, "Slave device or server failure (%i)", SLAVE_DEVICE_FAILURE);
+            break;
+        case ACKNOWLEDGE:
+            rb_raise(eAcknowledge, "Acknowledge (%i)", ACKNOWLEDGE);
+            break;
+        case SLAVE_DEVICE_BUSY:
+            rb_raise(eSlaveDeviceBusy, "Slave device or server busy (%i)", SLAVE_DEVICE_BUSY);
+            break;
+        case NEGATIVE_ACKNOWLEDGE:
+            rb_raise(eNegativeAcknowledge, "Negative acknowledge (%i)", NEGATIVE_ACKNOWLEDGE);
+            break;
+        case MEMORY_PARITY_ERROR:
+            rb_raise(eMemoryParityError, "Memory parity error (%i)", MEMORY_PARITY_ERROR);
+            break;
+        case GATEWAY_PROBLEM_PATH:
+            rb_raise(eGatewayProblemPath, "Gateway problem path (%i)", GATEWAY_PROBLEM_PATH);
+            break;
+        case GATEWAY_PROBLEM_TARGET:
+            rb_raise(eGatewayProblemTarget, "Gateway problem target (%i)", GATEWAY_PROBLEM_TARGET);
+            break;
+        case COMM_TIME_OUT:
+            rb_raise(eModBusError, "Communication timeout (%i)", COMM_TIME_OUT);
+            break;
+        case PORT_SOCKET_FAILURE:
+            rb_raise(eModBusError, "Port socket failure (%i)", PORT_SOCKET_FAILURE);
+            break;
+        case SELECT_FAILURE:
+            rb_raise(eModBusError, "Select failure (%i)", SELECT_FAILURE);
+            break;
+        case TOO_MANY_DATA:
+            rb_raise(eModBusError, "Too many data (%i)", TOO_MANY_DATA);
+            break;
+        case INVALID_CRC:
+            rb_raise(eModBusError, "Invalid CRC (%i)", INVALID_CRC);
+            break;
+        case INVALID_EXCEPTION_CODE:
+            rb_raise(eModBusError, "Invalid exception code (%i)", INVALID_EXCEPTION_CODE);
+            break;
+        case CONNECTION_CLOSED:
+            rb_raise(eModBusError, "Connection closed (%i)", CONNECTION_CLOSED);
+            break;
+        default:
+            rb_raise(eModBusError, "Unknow exception with code %i", exception);
+    }
+}
+
+

data/ext/errors.h

@@ -0,0 +1,24 @@
+/* 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 ERRORS_H
+#define ERRORS_H
+
+extern VALUE mErrors, eModBusError, eIllegalFunction,
+    eIllegalDataAddress, eIllegalDataValue,
+    eSlaveDeviceFailure, eAcknowledge, 
+    eSlaveDeviceBusy, eNegativeAcknowledge,
+    eMemoryParityError, eGatewayProblemPath, eGatewayProblemTarget; 
+
+extern void mb_raise_error(int exception);
+#endif

data/ext/extconf.rb

@@ -1,4 +1,4 @@
 require 'mkmf'
 
 have_library 'modbus'
-create_makefile 'modbus4r'
+create_makefile '_modbus4r'

data/ext/master.c

@@ -0,0 +1,225 @@
+/* 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 "modbus4r.h"
+#include "errors.h"
+
+VALUE mb_mstr_is_closed(VALUE self)
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    if (read(mb_param->fd, NULL, 0) || mb_param->fd == 0) { 
+        return Qtrue;
+    }
+    return Qfalse;
+}
+
+VALUE mb_mstr_connect(VALUE self)
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    if (modbus_connect(mb_param)) {
+        rb_raise(eModBusError, "Connection refused");
+    }
+    return self;
+}
+
+VALUE mb_mstr_close(VALUE self)
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    modbus_close(mb_param);
+
+    return self;
+}
+
+VALUE mb_mstr_read_coil(VALUE self, VALUE slave, 
+                    VALUE start_addr, VALUE nb, 
+                    int (*func)(modbus_param_t*, int, int, int, uint8_t*))
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
+    start_addr = rb_funcall(start_addr, rb_intern("to_i"), 0);
+    nb = rb_funcall(nb, rb_intern("to_i"), 0);
+    
+    uint8_t dest[FIX2INT(nb)];
+    int status = (*func)(mb_param, FIX2INT(slave), FIX2INT(start_addr), FIX2INT(nb), dest);
+
+    if (status < 0) {
+        mb_raise_error(status);
+    }
+
+    int i;
+    VALUE ret = rb_ary_new();
+    for (i = 0; i < FIX2INT(nb); i++) {
+        dest[i] == 1 ? rb_ary_push(ret, Qtrue) : rb_ary_push(ret, Qfalse);
+    }
+
+    return ret;
+}
+
+VALUE mb_mstr_read_coil_status(VALUE self, VALUE slave, 
+                                    VALUE start_addr, VALUE nb)
+{
+    return mb_mstr_read_coil(self, slave, start_addr, nb, 
+                            read_coil_status);
+}
+
+VALUE mb_mstr_read_input_status(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE nb)
+{
+    return mb_mstr_read_coil(self, slave, start_addr, nb, 
+                            read_input_status);
+}
+
+VALUE mb_mstr_read_registers(VALUE self, VALUE slave,
+                    VALUE start_addr, VALUE nb,
+                    int (*func)(modbus_param_t*, int, int, int, uint16_t*))
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
+    start_addr = rb_funcall(start_addr, rb_intern("to_i"), 0);
+    nb = rb_funcall(nb, rb_intern("to_i"), 0);
+    
+    uint16_t dest[FIX2INT(nb)];
+    int status = (*func)(mb_param, FIX2INT(slave), FIX2INT(start_addr), FIX2INT(nb), dest);
+
+    if (status < 0) {
+        mb_raise_error(status);
+    }
+
+    int i;
+    VALUE ret = rb_ary_new();
+    for (i = 0; i < FIX2INT(nb); i++) {
+        rb_ary_push(ret, INT2FIX(dest[i]));
+    }
+
+
+    return ret;
+}
+
+VALUE mb_mstr_read_holding_registers(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE nb)
+{
+    return mb_mstr_read_registers(self, slave, start_addr, nb,
+                                read_holding_registers);
+}
+
+VALUE mb_mstr_read_input_registers(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE nb)
+{
+    return mb_mstr_read_registers(self, slave, start_addr, nb,
+                                read_input_registers);
+}
+
+VALUE mb_mstr_force_single_coil(VALUE self, VALUE slave,
+                                    VALUE coil_addr, VALUE state)
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
+    coil_addr = rb_funcall(coil_addr, rb_intern("to_i"), 0);
+
+    int status = force_single_coil(mb_param, FIX2INT(slave), FIX2INT(coil_addr), (state == Qfalse ? 0 : 1));
+
+    if (status < 0) {
+        mb_raise_error(status);
+    }
+
+    return self;
+}
+
+
+VALUE mb_mstr_preset_single_register(VALUE self, VALUE slave,
+                                    VALUE reg_addr, VALUE value)
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
+    reg_addr = rb_funcall(reg_addr, rb_intern("to_i"), 0);
+    value = rb_funcall(value, rb_intern("to_i"), 0);
+
+    int status = preset_single_register(mb_param, FIX2INT(slave), FIX2INT(reg_addr), FIX2INT(value));
+
+    if (status < 0) {
+        mb_raise_error(status);
+    }
+
+    return self;
+}
+
+VALUE mb_mstr_force_multiple_coils(VALUE self, VALUE slave, 
+                                    VALUE start_addr, VALUE data) 
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
+    start_addr = rb_funcall(start_addr, rb_intern("to_i"), 0);
+    data = rb_funcall(data, rb_intern("to_a"), 0);
+
+    uint8_t buf[RARRAY_LEN(data)];
+    VALUE *ary = RARRAY_PTR(data);
+    int i;
+    
+    for (i = 0; i < RARRAY_LEN(data); i++) {
+        buf[i] = (*ary == Qfalse ? 0 : 1);
+        ary++;
+    }
+
+    int status = force_multiple_coils(mb_param, FIX2INT(slave), FIX2INT(start_addr), RARRAY_LEN(data), buf);
+
+    if (status < 0) {
+        mb_raise_error(status);
+    }
+
+    return self;
+}
+
+VALUE mb_mstr_preset_multiple_registers(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE data)
+{
+    modbus_param_t *mb_param;
+    Data_Get_Struct(self, modbus_param_t, mb_param);
+
+    slave = rb_funcall(slave, rb_intern("to_i"), 0);
+    start_addr = rb_funcall(start_addr, rb_intern("to_i"), 0);
+    data = rb_funcall(data, rb_intern("to_a"), 0);
+
+    uint16_t buf[RARRAY_LEN(data)];
+    VALUE *ary = RARRAY_PTR(data);
+    int i;
+    
+    for (i = 0; i < RARRAY_LEN(data); i++) {
+        *ary = rb_funcall(*ary, rb_intern("to_i"), 0);
+        buf[i] = FIX2INT(*ary);
+        ary++;
+    }
+
+    int status = preset_multiple_registers(mb_param, FIX2INT(slave), FIX2INT(start_addr), RARRAY_LEN(data), buf);
+
+    if (status < 0) {
+        mb_raise_error(status);
+    }
+
+    return self;
+}

data/ext/master.h

@@ -0,0 +1,36 @@
+/* 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 MASTER_H
+#define MASTER_H
+
+extern VALUE mb_mstr_is_closed(VALUE self);
+extern VALUE mb_mstr_connect(VALUE self);
+extern VALUE mb_mstr_close(VALUE self);
+extern VALUE mb_mstr_read_coil_status(VALUE self, VALUE slave, 
+                                    VALUE start_addr, VALUE nb);
+extern VALUE mb_mstr_read_input_status(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE nb);
+extern VALUE mb_mstr_read_holding_registers(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE nb);
+extern VALUE mb_mstr_read_input_registers(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE nb);
+extern VALUE mb_mstr_force_single_coil(VALUE self, VALUE slave,
+                                    VALUE coil_addr, VALUE state);
+extern VALUE mb_mstr_preset_single_register(VALUE self, VALUE slave,
+                                    VALUE reg_addr, VALUE value);
+extern VALUE mb_mstr_force_multiple_coils(VALUE self, VALUE slave, 
+                                    VALUE start_addr, VALUE data);
+extern VALUE mb_mstr_preset_multiple_registers(VALUE self, VALUE slave,
+                                    VALUE start_addr, VALUE data);
+#endif 

data/ext/modbus4r.c

@@ -0,0 +1,79 @@
+/* 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 "modbus4r.h" 
+#include "errors.h"
+#include "master.h"
+#include "tcp_master.h"
+#include "rtu_master.h"
+
+VALUE mModBus, cMaster, cTCPMaster, cRTUMaster;
+
+void Init__modbus4r()
+{
+    mModBus = rb_define_module("ModBus");
+    /* Master */
+    cMaster = rb_define_class_under(mModBus, "Master", rb_cObject);
+    rb_define_method(cMaster, "closed?", mb_mstr_is_closed, 0);
+    rb_define_method(cMaster, "connect", mb_mstr_connect, 0);
+    rb_define_method(cMaster, "close", mb_mstr_close, 0);
+    rb_define_method(cMaster, "read_coil_status", 
+                    mb_mstr_read_coil_status, 3);
+    rb_define_method(cMaster, "read_input_status",
+                    mb_mstr_read_input_status, 3);
+    rb_define_method(cMaster, "read_holding_registers", 
+                    mb_mstr_read_holding_registers, 3);
+    rb_define_method(cMaster, "read_input_registers", 
+                    mb_mstr_read_holding_registers, 3);
+    rb_define_method(cMaster, "force_single_coil", 
+                    mb_mstr_force_single_coil, 3);
+    rb_define_method(cMaster, "preset_single_register", 
+                    mb_mstr_preset_single_register, 3);
+    rb_define_method(cMaster, "force_multiple_coils", 
+                    mb_mstr_force_multiple_coils, 3);
+    rb_define_method(cMaster, "preset_multiple_registers", 
+                    mb_mstr_preset_multiple_registers, 3);
+
+    /* TCPMaster */
+    cTCPMaster = rb_define_class_under(mModBus, "TCPMaster", cMaster);
+    rb_define_singleton_method(cTCPMaster, "new", mb_tcp_mstr_new, 2);
+
+    /* RTUMaster */
+    cRTUMaster = rb_define_class_under(mModBus, "RTUMaster", cMaster);
+    rb_define_singleton_method(cRTUMaster, "new", mb_rtu_mstr_new, 5);
+
+    /* Errors */
+    mErrors = rb_define_module_under(mModBus, "Errors");
+    eModBusError = rb_define_class_under(mErrors, "ModBusError", 
+                                        rb_eStandardError);
+    eIllegalFunction = rb_define_class_under(mErrors, "IllegalFunction",
+                                        eModBusError);
+    eIllegalDataAddress = rb_define_class_under(mErrors, "IllegalDataAddress",
+                                        eModBusError);
+    eIllegalDataValue = rb_define_class_under(mErrors, "IllegalDataValue",
+                                        eModBusError);
+    eSlaveDeviceFailure = rb_define_class_under(mErrors, "SlaveDeviceFailure",
+                                        eModBusError);
+    eAcknowledge = rb_define_class_under(mErrors, "Acknowledge",
+                                        eModBusError);
+    eSlaveDeviceBusy = rb_define_class_under(mErrors, "SlaveDeviceBusy",
+                                        eModBusError);
+    eNegativeAcknowledge = rb_define_class_under(mErrors, "NegativeAcknowledge",
+                                        eModBusError);
+    eMemoryParityError = rb_define_class_under(mErrors, "MemoryParityError",
+                                        eModBusError);
+    eGatewayProblemPath = rb_define_class_under(mErrors, "GatewayProblemPath", 
+                                        eModBusError);
+    eGatewayProblemTarget = rb_define_class_under(mErrors, "GatewayProblemTarget",
+                                        eModBusError);
+}

data/ext/modbus4r.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 MODBUS_H
+#define MODBUS_H
+
+#include "ruby/ruby.h"
+#include "ruby/intern.h"
+#include "modbus/modbus.h"
+
+#endif

data/ext/rtu_master.c

@@ -0,0 +1,38 @@
+/* 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 "modbus4r.h"
+
+void mb_rtu_mstr_free(modbus_param_t *mb_param )
+{
+    modbus_close(mb_param);
+    free(mb_param);
+}
+
+VALUE mb_rtu_mstr_new(VALUE self, VALUE device, VALUE baud, 
+                            VALUE parity, VALUE data_bit, VALUE stop_bit)
+{
+    modbus_param_t *mb_param;
+
+    mb_param = malloc(sizeof(modbus_param_t));
+    device = rb_funcall(device, rb_intern("to_s"), 0);
+    baud = rb_funcall(baud, rb_intern("to_i"), 0);
+    parity = rb_funcall(parity, rb_intern("to_s"), 0);
+    data_bit = rb_funcall(data_bit, rb_intern("to_i"), 0);
+    stop_bit = rb_funcall(stop_bit, rb_intern("to_i"), 0);
+
+    modbus_init_rtu(mb_param, RSTRING_PTR(device), FIX2INT(baud),
+                    RSTRING_PTR(parity), FIX2INT(data_bit), FIX2INT(stop_bit));
+
+    return Data_Wrap_Struct(self, 0, mb_rtu_mstr_free, mb_param);
+}

data/ext/rtu_master.h

@@ -0,0 +1,20 @@
+/* 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 RTU_MASTER_H
+#define RTU_MASTER_H
+
+extern VALUE mb_rtu_mstr_new(VALUE self, VALUE device, VALUE baud, 
+                            VALUE parity, VALUE data_bit, VALUE stop_bit);
+
+#endif

data/ext/tcp_master.c

@@ -0,0 +1,33 @@
+/* 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 "modbus4r.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)
+{
+    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);
+
+    modbus_init_tcp(mb_param, RSTRING_PTR(ip_address), FIX2INT(port));
+
+    return Data_Wrap_Struct(self, 0, mb_tcp_mstr_free, mb_param);
+}

data/ext/tcp_master.h

@@ -0,0 +1,19 @@
+/* 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_MASTER_H
+#define TCP_MASTER_H
+
+extern VALUE mb_tcp_mstr_new(VALUE self, VALUE ip_address, VALUE port);
+
+#endif

data/lib/modbus4r.rb

@@ -0,0 +1,14 @@
+#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. */
+
+require '_modbus4r'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: libmodbus4r
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Aleksey Timin
@@ -9,7 +9,7 @@ autorequire: libmodbus4r
 bindir: bin
 cert_chain: []
 
-date: 2009-07-30 00:00:00 +06:00
+date: 2009-08-10 00:00:00 +06:00
 default_executable: 
 dependencies: []
 
@@ -22,16 +22,29 @@ extensions:
 extra_rdoc_files: 
 - README
 - LICENSE
-- ChangeLog
+- NEWS
+- TODO
 files: 
-- lib/modbus4r.so
+- lib/modbus4r.rb
 - examples/use_rtu_master.rb
 - examples/use_tcp_master.rb
 - spec/rtu_master_spec.rb
 - spec/tcp_master_spec.rb
+- ext/tcp_master.c
+- ext/errors.c
+- ext/modbus4r.h
+- ext/extconf.rb
+- ext/master.h
+- ext/rtu_master.c
+- ext/tcp_master.h
+- ext/rtu_master.h
+- ext/master.c
+- ext/errors.h
+- ext/modbus4r.c
 - README
 - LICENSE
-- ChangeLog
+- NEWS
+- TODO
 has_rdoc: true
 homepage: 
 licenses: []

data/ChangeLog

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-
-2009-07-30 Timin Aleksey <atimin@gmail.com>
-	* ext/master.c, ext/master.h, ext/tcp_master.c, ext/tcp_master.h, ext/rtu_master.c, ext/rtu_master,h :	Create base Master class for TCPMaster and RTUMaster
-	* ext/error.c ext/error.h : Add suppot all exception of libmodbus
-	* spec/rtu_master_spec.rb: Add test for RTUMaster, but it not run!
-	* ChageLog: Start log of shanges.
-