Class: ModBus::Master

Inherits:
Object
  • Object
show all
Defined in:
ext/modbus4r.c

Direct Known Subclasses

RTUMaster, TCPMaster

Instance Method Summary collapse

Instance Method Details

#close ⇒ Object 



39
40
41
42
43
44
45
46
47
 
# File 'ext/master.c', line 39

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;
}

#closed? ⇒ Boolean

Returns:

  • (Boolean) 


17
18
19
20
21
22
23
24
25
26
 
# File 'ext/master.c', line 17

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;
}

#connect ⇒ Object 



28
29
30
31
32
33
34
35
36
37
 
# File 'ext/master.c', line 28

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;
}

#force_multiple_coils(slave, start_addr, data) ⇒ Object 



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'ext/master.c', line 170

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;
}

#force_single_coil(slave, coil_addr, state) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'ext/master.c', line 132

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;
}

#preset_multiple_registers(slave, start_addr, data) ⇒ Object 



198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'ext/master.c', line 198

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;
}

#preset_single_register(slave, reg_addr, value) ⇒ Object 



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'ext/master.c', line 151

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;
}

#read_coil_status(slave, start_addr, nb) ⇒ Object 



76
77
78
79
80
81
 
# File 'ext/master.c', line 76

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);
}

#read_holding_registers(slave, start_addr, nb) ⇒ Object 



118
119
120
121
122
123
 
# File 'ext/master.c', line 118

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);
}

#read_input_registers(slave, start_addr, nb) ⇒ Object 



125
126
127
128
129
130
 
# File 'ext/master.c', line 125

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);
}

#read_input_status(slave, start_addr, nb) ⇒ Object 



83
84
85
86
87
88
 
# File 'ext/master.c', line 83

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);
}