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 



47
48
49
50
51
52
53
54
55
 
# File 'ext/master.c', line 47

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) 


25
26
27
28
29
30
31
32
33
34
 
# File 'ext/master.c', line 25

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 



36
37
38
39
40
41
42
43
44
45
 
# File 'ext/master.c', line 36

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(start_addr, data) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'ext/master.c', line 164

VALUE mb_mstr_force_multiple_coils(VALUE self, VALUE start_addr, VALUE data) 
{
    modbus_param_t *mb_param;
    Data_Get_Struct(self, modbus_param_t, mb_param);

    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(start_addr), RARRAY_LEN(data), buf);

    if (status < 0) {
        mb_raise_error(status);
    }

    return self;
}

#force_single_coil(coil_addr, state) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'ext/master.c', line 130

VALUE mb_mstr_force_single_coil(VALUE self, VALUE coil_addr, VALUE state)
{
    modbus_param_t *mb_param;
    Data_Get_Struct(self, modbus_param_t, mb_param);

    coil_addr = rb_funcall(coil_addr, rb_intern("to_i"), 0);

    int status = force_single_coil(mb_param, FIX2INT(coil_addr), (state == Qfalse ? 0 : 1));

    if (status < 0) {
        mb_raise_error(status);
    }

    return self;
}

#preset_multiple_registers(start_addr, data) ⇒ Object 



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'ext/master.c', line 190

VALUE mb_mstr_preset_multiple_registers(VALUE self, VALUE start_addr, VALUE data)
{
    modbus_param_t *mb_param;
    Data_Get_Struct(self, modbus_param_t, mb_param);

    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(start_addr), RARRAY_LEN(data), buf);

    if (status < 0) {
        mb_raise_error(status);
    }

    return self;
}

#preset_single_register(reg_addr, value) ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'ext/master.c', line 147

VALUE mb_mstr_preset_single_register(VALUE self, VALUE reg_addr, VALUE value)
{
    modbus_param_t *mb_param;
    Data_Get_Struct(self, modbus_param_t, mb_param);

    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(reg_addr), FIX2INT(value));

    if (status < 0) {
        mb_raise_error(status);
    }

    return self;
}

#read_coil_status(start_addr, nb) ⇒ Object 



82
83
84
85
 
# File 'ext/master.c', line 82

VALUE mb_mstr_read_coil_status(VALUE self, VALUE start_addr, VALUE nb)
{
    return mb_mstr_read_coil(self, start_addr, nb, read_coil_status);
}

#read_holding_registers(start_addr, nb) ⇒ Object 



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

VALUE mb_mstr_read_holding_registers(VALUE self, VALUE start_addr, VALUE nb)
{
    return mb_mstr_read_registers(self, start_addr, nb,
                                read_holding_registers);
}

#read_input_registers(start_addr, nb) ⇒ Object 



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

VALUE mb_mstr_read_input_registers(VALUE self, VALUE start_addr, VALUE nb)
{
    return mb_mstr_read_registers(self, start_addr, nb,
                                read_input_registers);
}

#read_input_status(start_addr, nb) ⇒ Object 



87
88
89
90
 
# File 'ext/master.c', line 87

VALUE mb_mstr_read_input_status(VALUE self, VALUE start_addr, VALUE nb)
{
    return mb_mstr_read_coil(self, start_addr, nb, read_input_status);
}