source: EcnlProtoTool/trunk/mrbgems/mruby-ecnl/src/mrb_ecnl.c@ 321

Last change on this file since 321 was 321, checked in by coas-nagasima, 7 years ago

文字コードを設定
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 53.6 KB
Line 
1/*
2 * TOPPERS ECHONET Lite Communication Middleware
3 *
4 * Copyright (C) 2016 Cores Co., Ltd. Japan
5 *
6 * 上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
7 * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
8 * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
9 * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
10 * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
11 * スコード中に含まれていること．
12 * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
13 * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
14 * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
15 * の無保証規定を掲載すること．
16 * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
17 * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
18 * と．
19 * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
20 * 作権表示，この利用条件および下記の無保証規定を掲載すること．
21 * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
22 * 報告すること．
23 * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
24 * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
25 * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
26 * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
27 * 免責すること．
28 *
29 * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
30 * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
31 * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
32 * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
33 * の責任を負わない．
34 *
35 */
36
37#include <stddef.h>
38#include <stdint.h>
39#include <string.h>
40#include <mruby.h>
41#include <mruby/array.h>
42#include <mruby/data.h>
43#include <mruby/class.h>
44#include <mruby/string.h>
45#include <mruby/hash.h>
46#include <mruby/variable.h>
47#include "echonet.h"
48#include "echonet_fbs.h"
49#include "echonet_agent.h"
50#include "echonet_task.h"
51#include "echonet_lcl_task.h"
52#include "mrb_ecnl.h"
53
54struct RClass *_module_ecnl;
55struct RClass *_class_object;
56struct RClass *_class_node;
57struct RClass *_class_property;
58struct RClass *_class_data;
59struct RClass *_class_iterator;
60struct RClass *_class_svctask;
61
62static void mrb_ecnl_eobject_free(mrb_state *mrb, void *ptr);
63static void mrb_ecnl_enode_free(mrb_state *mrb, void *ptr);
64static void mrb_ecnl_eproperty_free(mrb_state *mrb, void *ptr);
65static void mrb_ecnl_edata_free(mrb_state *mrb, void *ptr);
66static void mrb_ecnl_eiterator_free(mrb_state *mrb, void *ptr);
67static void mrb_ecnl_svctask_free(mrb_state *mrb, void *ptr);
68
69const static struct mrb_data_type mrb_ecnl_eobject_type = { "EObject", mrb_ecnl_eobject_free };
70const static struct mrb_data_type mrb_ecnl_enode_type = { "ENode", mrb_ecnl_enode_free };
71const static struct mrb_data_type mrb_ecnl_eproperty_type = { "EProperty", mrb_ecnl_eproperty_free };
72const static struct mrb_data_type mrb_ecnl_edata_type = { "EData", mrb_ecnl_edata_free };
73const static struct mrb_data_type mrb_ecnl_eiterator_type = { "EIterator", mrb_ecnl_eiterator_free };
74const static struct mrb_data_type mrb_ecnl_svctask_type = { "SvcTask", mrb_ecnl_svctask_free };
75
76static int anno_prpmap_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
77static int set_prpmap_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
78static int get_prpmap_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
79static int inst_count_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
80static int class_count_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
81static int inst_list_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
82static int inst_lists_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
83static int class_lists_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
84
85const static EPRPINIB auto_eproperties[] = {
86 {0x9D, EPC_RULE_GET, 255, 0, NULL, anno_prpmap_prop_get},
87 {0x9E, EPC_RULE_GET, 255, 0, NULL, set_prpmap_prop_get},
88 {0x9F, EPC_RULE_GET, 255, 0, NULL, get_prpmap_prop_get},
89 {0xD3, EPC_RULE_GET, 255, 0, NULL, inst_count_prop_get},
90 {0xD4, EPC_RULE_GET, 255, 0, NULL, class_count_prop_get},
91 {0xD5, EPC_RULE_ANNO, 255, 0, NULL, inst_list_prop_get},
92 {0xD6, EPC_RULE_GET, 255, 0, NULL, inst_lists_prop_get},
93 {0xD7, EPC_RULE_GET, 255, 0, NULL, class_lists_prop_get},
94};
95
96static T_MRB_ECNL_EPROPERTY *cast_prop(const EPRPINIB *inib)
97{
98 return (T_MRB_ECNL_EPROPERTY *)((intptr_t)inib - offsetof(T_MRB_ECNL_EPROPERTY, inib));
99}
100
101static mrb_value mrb_ecnl_eobject_initialize(mrb_state *mrb, mrb_value self)
102{
103 ecn_device_t *obj;
104 mrb_value node;
105 mrb_int eojx1;
106 mrb_int eojx2;
107 mrb_int eojx3;
108 mrb_value props;
109 const mrb_value *rprop;
110 const EPRPINIB **eprp;
111 EPRPINIB *aprops;
112 int i, count, icnt;
113
114 mrb_get_args(mrb, "iiioA", &eojx1, &eojx2, &eojx3, &node, &props);
115
116 if (!mrb_obj_is_kind_of(mrb, node, _class_node)) {
117 mrb_raise(mrb, E_RUNTIME_ERROR, "EObject.new");
118 return mrb_nil_value();
119 }
120
121 rprop = RARRAY_PTR(props);
122 icnt = RARRAY_LEN(props);
123 count = icnt + 3; /* プロパティマップ分 */
124
125 for (i = 0; i < icnt; i++) {
126 T_MRB_ECNL_EPROPERTY *prop;
127
128 if (!mrb_obj_is_kind_of(mrb, rprop[i], _class_property)) {
129 mrb_raise(mrb, E_RUNTIME_ERROR, "eprpinib_table");
130 return mrb_nil_value();
131 }
132
133 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(rprop[i]);
134
135 /* プロパティマップの場合は減算 */
136 switch (prop->inib.eprpcd) {
137 case 0x9D: case 0x9E: case 0x9F:
138 count--;
139 break;
140 }
141 }
142
143 obj = (ecn_device_t *)mrb_calloc(mrb, 1, sizeof(ecn_device_t) + count * sizeof(EPRPINIB *)
144 + (sizeof(EPRPINIB) * 3));
145 DATA_TYPE(self) = &mrb_ecnl_eobject_type;
146 DATA_PTR(self) = obj;
147
148 eprp = (const EPRPINIB **)&obj[1];
149 aprops = (EPRPINIB *)&eprp[count];
150
151 obj->base.inib.eobjatr = EOBJ_DEVICE;
152 obj->base.inib.enodid = 0;
153 obj->base.inib.exinf = (intptr_t)NULL;
154 obj->base.inib.eojx1 = eojx1;
155 obj->base.inib.eojx2 = eojx2;
156 obj->base.inib.eojx3 = eojx3;
157 obj->base.inib.eprp = eprp;
158 obj->base.inib.eprpcnt = count;
159 obj->base.eprpcnt = count;
160
161 obj->node = (ecn_node_t *)DATA_PTR(node);
162
163 count = 0;
164 for (i = 0; i < icnt; i++) {
165 T_MRB_ECNL_EPROPERTY *prop;
166 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(rprop[i]);
167
168 /* プロパティマップの場合は無視 */
169 switch (prop->inib.eprpcd) {
170 case 0x9D: case 0x9E: case 0x9F:
171 continue;
172 }
173
174 prop->eobj = self;
175 eprp[count++] = &prop->inib;
176 }
177
178 for (int j = 0; j < 3; j++) {
179 EPRPINIB *prop = &aprops[j];
180
181 memcpy(prop, &auto_eproperties[j], sizeof(*prop));
182
183 prop->exinf = (intptr_t)obj;
184 eprp[count++] = prop;
185 }
186
187 return self;
188}
189
190static void mrb_ecnl_eobject_free(mrb_state *mrb, void *ptr)
191{
192 ecn_device_t *obj = (ecn_device_t *)ptr;
193 T_MRB_ECNL_EPROPERTY *prop;
194
195 /* 機器オブジェクトの設定として取り込まれた場合は破棄しない */
196 if (obj->base.svc != NULL)
197 return;
198
199 for (int i = 0; i < obj->base.eprpcnt; i++) {
200 const EPRPINIB *eprp = obj->base.inib.eprp[i];
201
202 switch (eprp->eprpcd) {
203 case 0x9D: case 0x9E: case 0x9F:
204 continue;
205 }
206
207 prop = cast_prop(eprp);
208
209 mrb_free(mrb, prop);
210 }
211
212 mrb_free(mrb, obj);
213}
214
215static mrb_value mrb_ecnl_eobject_data_prop_set(mrb_state *mrb, mrb_value self)
216{
217 mrb_value rprp;
218 mrb_value rdat;
219 mrb_value data;
220 T_MRB_ECNL_EPROPERTY *prop;
221
222 mrb_get_args(mrb, "oS", &rprp, &rdat);
223
224 if (!mrb_obj_is_kind_of(mrb, rprp, _class_property)) {
225 mrb_raise(mrb, E_RUNTIME_ERROR, "data_prop_set");
226 return mrb_fixnum_value(0);
227 }
228
229 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(rprp);
230 data = mrb_iv_get(mrb, self, prop->exinf);
231
232 prop->anno = !mrb_str_equal(mrb, data, rdat);
233
234 mrb_iv_set(mrb, self, prop->exinf, rdat);
235
236 return mrb_fixnum_value(RSTRING_LEN(rdat));
237}
238
239static mrb_value mrb_ecnl_eobject_data_prop_get(mrb_state *mrb, mrb_value self)
240{
241 mrb_value rprp;
242 mrb_value rsiz;
243 mrb_value rdat;
244 T_MRB_ECNL_EPROPERTY *prop;
245 int size;
246
247 mrb_get_args(mrb, "oi", &rprp, &rsiz);
248
249 if (!mrb_obj_is_kind_of(mrb, rprp, _class_property)) {
250 mrb_raise(mrb, E_RUNTIME_ERROR, "data_prop_get");
251 return mrb_fixnum_value(0);
252 }
253
254 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(rprp);
255 size = mrb_fixnum(rsiz);
256
257 rdat = mrb_iv_get(mrb, self, prop->exinf);
258 if (RSTRING_LEN(rdat) != size) {
259 mrb_raise(mrb, E_RUNTIME_ERROR, "data_prop_get");
260 return mrb_nil_value();
261 }
262
263 return rdat;
264}
265
266static mrb_value mrb_ecnl_enode_initialize(mrb_state *mrb, mrb_value self)
267{
268 ecn_node_t *nod;
269 mrb_int eojx3;
270 mrb_value props;
271 const mrb_value *rprop;
272 int i, count, icnt;
273 const EPRPINIB **eprp;
274 EPRPINIB *aprops;
275
276 mrb_get_args(mrb, "iA", &eojx3, &props);
277
278 rprop = RARRAY_PTR(props);
279 icnt = RARRAY_LEN(props);
280 count = icnt + 8; /* インスタンスリストなどの分 */
281
282 for (i = 0; i < icnt; i++) {
283 T_MRB_ECNL_EPROPERTY *prop;
284
285 if (!mrb_obj_is_kind_of(mrb, rprop[i], _class_property)) {
286 mrb_raise(mrb, E_RUNTIME_ERROR, "eprpinib_table");
287 return mrb_nil_value();
288 }
289
290 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(rprop[i]);
291
292 /* インスタンスリストなどの場合は減算 */
293 switch (prop->inib.eprpcd) {
294 case 0xD3: case 0xD4: case 0xD5: case 0xD6: case 0xD7:
295 case 0x9D: case 0x9E: case 0x9F:
296 count--;
297 break;
298 }
299 }
300
301 nod = (ecn_node_t *)mrb_calloc(mrb, 1, sizeof(ecn_node_t) + count * sizeof(EPRPINIB *)
302 + (sizeof(EPRPINIB) * 8)/* インスタンスリストなどの分 */);
303 DATA_TYPE(self) = &mrb_ecnl_enode_type;
304 DATA_PTR(self) = nod;
305
306 eprp = (const EPRPINIB **)&nod[1];
307 aprops = (EPRPINIB *)&eprp[count];
308
309 nod->base.inib.eobjatr = EOBJ_LOCAL_NODE;
310 nod->base.inib.enodid = 0;
311 nod->base.inib.exinf = (intptr_t)NULL;
312 nod->base.inib.eojx1 = EOJ_X1_PROFILE;
313 nod->base.inib.eojx2 = EOJ_X2_NODE_PROFILE;
314 nod->base.inib.eojx3 = eojx3;
315 nod->base.inib.eprp = eprp;
316 nod->base.inib.eprpcnt = count;
317 nod->base.eprpcnt = count;
318
319 count = 0;
320 for (i = 0; i < icnt; i++) {
321 T_MRB_ECNL_EPROPERTY *prop;
322 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(rprop[i]);
323
324 /* インスタンスリストなどの場合は無視 */
325 switch (prop->inib.eprpcd) {
326 case 0xD3: case 0xD4: case 0xD5: case 0xD6: case 0xD7:
327 case 0x9D: case 0x9E: case 0x9F:
328 continue;
329 }
330
331 prop->eobj = self;
332 eprp[count++] = &prop->inib;
333 }
334
335 for (int j = 0; j < 8; j++) {
336 EPRPINIB *prop = &aprops[j];
337
338 memcpy(prop, &auto_eproperties[j], sizeof(*prop));
339
340 prop->exinf = (intptr_t)nod;
341 eprp[count++] = prop;
342 }
343
344 return self;
345}
346
347static void mrb_ecnl_enode_free(mrb_state *mrb, void *ptr)
348{
349 ecn_node_t *nod = (ecn_node_t *)ptr;
350 T_MRB_ECNL_EPROPERTY *prop;
351
352 /* ノードの設定として取り込まれた場合は破棄しない */
353 if (nod->base.svc != NULL)
354 return;
355
356 for (int i = 0; i < nod->base.eprpcnt; i++) {
357 const EPRPINIB *eprp = nod->base.inib.eprp[i];
358
359 switch (eprp->eprpcd) {
360 case 0xD3: case 0xD4: case 0xD5: case 0xD6: case 0xD7:
361 case 0x9D: case 0x9E: case 0x9F:
362 continue;
363 }
364
365 prop = cast_prop(eprp);
366
367 mrb_free(mrb, prop);
368 }
369
370 mrb_free(mrb, nod);
371}
372
373static int anno_prpmap_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
374{
375 ecn_obj_t *obj = (ecn_obj_t *)item->exinf;
376 uint8_t *dmap = &((uint8_t *)dst)[1];
377 uint8_t count;
378
379 count = obj->annocnt;
380 *(uint8_t *)dst = count;
381 if (count < 16) {
382 memcpy(dmap, obj->pmapAnno, count);
383 return count + 1;
384 }
385 else {
386 memcpy(dmap, obj->pmapAnno, 16);
387 return 17;
388 }
389}
390
391static int set_prpmap_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
392{
393 ecn_obj_t *obj = (ecn_obj_t *)item->exinf;
394 uint8_t *dmap = &((uint8_t *)dst)[1];
395 uint8_t count;
396
397 count = obj->setcnt;
398 *(uint8_t *)dst = count;
399 if (count < 16) {
400 memcpy(dmap, obj->pmapSet, count);
401 return count + 1;
402 }
403 else {
404 memcpy(dmap, obj->pmapSet, 16);
405 return 17;
406 }
407}
408
409static int get_prpmap_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
410{
411 ecn_obj_t *obj = (ecn_obj_t *)item->exinf;
412 uint8_t *dmap = &((uint8_t *)dst)[1];
413 uint8_t count;
414
415 count = obj->getcnt;
416 *(uint8_t *)dst = count;
417 if (count < 16) {
418 memcpy(dmap, obj->pmapGet, count);
419 return count + 1;
420 }
421 else {
422 memcpy(dmap, obj->pmapGet, 16);
423 return 17;
424 }
425}
426
427static int inst_count_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
428{
429 ecn_node_t *nod = (ecn_node_t *)item->exinf;
430 uint8_t *pos = dst;
431 EOBJCB *obj = &svc->eobjcb_table[nod->base.eobjId - 1];
432 int count = obj->eobjcnt;
433
434 pos[0] = count >> 16;
435 pos[1] = count >> 8;
436 pos[2] = count;
437
438 return 3;
439}
440
441static int class_count_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
442{
443 ecn_node_t *nod = (ecn_node_t *)item->exinf;
444 uint8_t *pos = dst;
445 int count = svc->eclscnt;
446
447 pos[0] = count >> 8;
448 pos[1] = count;
449
450 return 2;
451}
452
453static int inst_list_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
454{
455 ecn_node_t *nod = (ecn_node_t *)item->exinf;
456 uint8_t *pos = dst;
457 EOBJCB *obj = &svc->eobjcb_table[nod->base.eobjId - 1];
458 const EOBJINIB **eobjs = obj->eobjs;
459 int eobjcnt = obj->eobjcnt;
460 int inst_list_pos = svc->inst_list_pos;
461 int count = 0;
462
463 /* 通知数の位置を空けておく */
464 pos++;
465 for (int i = inst_list_pos; (i < eobjcnt) && (count < 84); i++) {
466 const EOBJINIB *eobj = eobjs[i];
467
468 *pos++ = eobj->eojx1;
469 *pos++ = eobj->eojx2;
470 *pos++ = eobj->eojx3;
471 count++;
472 }
473 *(uint8_t *)dst = count;
474
475 inst_list_pos += count;
476 /* 最後まで送信し終わっていたら初めから */
477 if (inst_list_pos >= eobjcnt)
478 inst_list_pos = 0;
479
480 svc->inst_list_pos = inst_list_pos;
481
482 return (int)pos - (int)dst;
483}
484
485static int inst_lists_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
486{
487 ecn_node_t *nod = (ecn_node_t *)item->exinf;
488 uint8_t *pos = dst;
489 EOBJCB *obj = &svc->eobjcb_table[nod->base.eobjId - 1];
490 const EOBJINIB **eobjs = obj->eobjs;
491 int eobjcnt = obj->eobjcnt;
492
493 if (eobjcnt < 255)
494 *pos++ = eobjcnt;
495 else
496 *pos++ = 255; /*オーバーフロー*/
497
498 for (int i = 0; (i < eobjcnt) && (i < 84); i++) {
499 const EOBJINIB *eobj = eobjs[i];
500
501 *pos++ = eobj->eojx1;
502 *pos++ = eobj->eojx2;
503 *pos++ = eobj->eojx3;
504 }
505
506 return (int)pos - (int)dst;
507}
508
509static int class_lists_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
510{
511 uint8_t *pos = dst;
512 int eclscnt = svc->eclscnt, len;
513
514 if (eclscnt < 255)
515 *pos++ = eclscnt;
516 else
517 *pos++ = 255; /*オーバーフロー*/
518
519 len = 2 * eclscnt;
520 memcpy(pos, svc->eclslst, len);
521 pos += len;
522
523 return (int)pos - (int)dst;
524}
525
526static int mrb_ecnl_prop_set(ecnl_svc_task_t *svc, const EPRPINIB *item, const void *src, int size, bool_t *anno);
527static int mrb_ecnl_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size);
528
529static mrb_value mrb_ecnl_eproperty_initialize(mrb_state *mrb, mrb_value self)
530{
531 T_MRB_ECNL_EPROPERTY *prop;
532 mrb_value exinf;
533 mrb_value eprpset;
534 mrb_value eprpget;
535 mrb_int eprpcd;
536 mrb_int eprpatr;
537 mrb_int eprpsz;
538 mrb_sym ei, set, get;
539
540 mrb_get_args(mrb, "iiiooo", &eprpcd, &eprpatr, &eprpsz, &exinf, &eprpset, &eprpget);
541
542 if (mrb_type(exinf) == MRB_TT_SYMBOL) {
543 ei = mrb_symbol(exinf);
544 }
545 else if (mrb_type(exinf) == MRB_TT_FALSE) {
546 ei = 0;
547 }
548 else {
549 mrb_raise(mrb, E_RUNTIME_ERROR, "EProperty.new");
550 return mrb_nil_value();
551 }
552
553 if (mrb_type(eprpset) == MRB_TT_SYMBOL) {
554 set = mrb_symbol(eprpset);
555 }
556 else if (mrb_type(eprpset) == MRB_TT_FALSE) {
557 set = 0;
558 }
559 else {
560 mrb_raise(mrb, E_RUNTIME_ERROR, "EProperty.new");
561 return mrb_nil_value();
562 }
563
564 if (mrb_type(eprpget) == MRB_TT_SYMBOL) {
565 get = mrb_symbol(eprpget);
566 }
567 else if (mrb_type(eprpget) == MRB_TT_FALSE) {
568 get = 0;
569 }
570 else {
571 mrb_raise(mrb, E_RUNTIME_ERROR, "EProperty.new");
572 return mrb_nil_value();
573 }
574
575 prop = (T_MRB_ECNL_EPROPERTY *)mrb_malloc(mrb, sizeof(T_MRB_ECNL_EPROPERTY));
576 DATA_TYPE(self) = &mrb_ecnl_eproperty_type;
577 DATA_PTR(self) = prop;
578
579 prop->inib.eprpcd = eprpcd;
580 prop->inib.eprpatr = eprpatr;
581 prop->inib.eprpsz = eprpsz;
582 prop->inib.exinf = 0;
583 prop->inib.eprpset = mrb_ecnl_prop_set;
584 prop->inib.eprpget = mrb_ecnl_prop_get;
585 prop->exinf = ei;
586 prop->eprpset = set;
587 prop->eprpget = get;
588 prop->anno = false;
589
590 return self;
591}
592
593static void mrb_ecnl_eproperty_free(mrb_state *mrb, void *ptr)
594{
595 T_MRB_ECNL_EPROPERTY *prop = (T_MRB_ECNL_EPROPERTY *)ptr;
596 ecn_obj_t *eobj;
597
598 if (ptr == NULL)
599 return;
600
601 if (mrb_type(prop->eobj) == MRB_TT_DATA) {
602 eobj = (ecn_obj_t *)DATA_PTR(prop->eobj);
603
604 /* プロパティの設定として取り込まれた場合は破棄しない */
605 if (eobj != NULL)
606 return;
607 }
608
609 mrb_free(mrb, prop);
610}
611
612/* ECHONET Lite プロパティコード */
613static mrb_value mrb_ecnl_eproperty_get_pcd(mrb_state *mrb, mrb_value self)
614{
615 T_MRB_ECNL_EPROPERTY *prop;
616
617 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
618
619 return mrb_fixnum_value(prop->inib.eprpcd);
620}
621
622/* ECHONET Lite プロパティ属性 */
623static mrb_value mrb_ecnl_eproperty_get_atr(mrb_state *mrb, mrb_value self)
624{
625 T_MRB_ECNL_EPROPERTY *prop;
626
627 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
628
629 return mrb_fixnum_value(prop->inib.eprpatr);
630}
631
632/* ECHONET Lite プロパティのサイズ */
633static mrb_value mrb_ecnl_eproperty_get_sz(mrb_state *mrb, mrb_value self)
634{
635 T_MRB_ECNL_EPROPERTY *prop;
636
637 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
638
639 return mrb_fixnum_value(prop->inib.eprpsz);
640}
641
642/* ECHONET Lite プロパティの拡張情報 */
643static mrb_value mrb_ecnl_eproperty_get_exinf(mrb_state *mrb, mrb_value self)
644{
645 T_MRB_ECNL_EPROPERTY *prop;
646
647 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
648
649 return mrb_iv_get(mrb, prop->eobj, prop->exinf);
650}
651
652/* ECHONET Lite プロパティの拡張情報設定 */
653static mrb_value mrb_ecnl_eproperty_set_exinf(mrb_state *mrb, mrb_value self)
654{
655 T_MRB_ECNL_EPROPERTY *prop;
656 mrb_value exinf;
657
658 mrb_get_args(mrb, "o", &exinf);
659
660 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
661
662 mrb_iv_set(mrb, prop->eobj, prop->exinf, exinf);
663
664 return exinf;
665}
666
667/* ECHONET Lite プロパティの設定関数 */
668static mrb_value mrb_ecnl_eproperty_get_setcb(mrb_state *mrb, mrb_value self)
669{
670 T_MRB_ECNL_EPROPERTY *prop;
671
672 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
673
674 if (prop->eprpset == 0)
675 return mrb_nil_value();
676
677 return mrb_symbol_value(prop->eprpset);
678}
679
680/* ECHONET Lite プロパティの取得関数 */
681static mrb_value mrb_ecnl_eproperty_get_getcb(mrb_state *mrb, mrb_value self)
682{
683 T_MRB_ECNL_EPROPERTY *prop;
684
685 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
686
687 if (prop->eprpget == 0)
688 return mrb_nil_value();
689
690 return mrb_symbol_value(prop->eprpget);
691}
692
693/* ECHONET Lite プロパティの通知有無 */
694static mrb_value mrb_ecnl_eproperty_get_anno(mrb_state *mrb, mrb_value self)
695{
696 T_MRB_ECNL_EPROPERTY *prop;
697
698 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
699
700 if (prop->anno)
701 return mrb_true_value();
702
703 return mrb_false_value();
704}
705
706/* ECHONET Lite プロパティの通知有無設定 */
707static mrb_value mrb_ecnl_eproperty_set_anno(mrb_state *mrb, mrb_value self)
708{
709 T_MRB_ECNL_EPROPERTY *prop;
710 mrb_value anno;
711
712 mrb_get_args(mrb, "b", &anno);
713
714 prop = (T_MRB_ECNL_EPROPERTY *)DATA_PTR(self);
715
716 prop->anno = mrb_type(anno) != MRB_TT_FALSE;
717
718 return anno;
719}
720
721/*
722 * データ設定関数
723 */
724static int mrb_ecnl_prop_set(ecnl_svc_task_t *svc, const EPRPINIB *item, const void *src, int size, bool_t *anno)
725{
726 mrb_state *mrb = svc->mrb;
727 T_MRB_ECNL_EPROPERTY *prop = cast_prop(item);
728 mrb_value args[2];
729 mrb_value ret;
730
731 if (prop->eprpset == 0)
732 return 0;
733
734 prop->anno = *anno;
735
736 args[0] = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_property));
737 DATA_TYPE(args[0]) = &mrb_ecnl_eproperty_type;
738 DATA_PTR(args[0]) = prop;
739
740 args[1] = mrb_str_new_static(mrb, src, size);
741
742 ret = mrb_funcall_argv(mrb, prop->eobj, prop->eprpset, 2, args);
743
744 if (mrb_type(ret) != MRB_TT_FIXNUM) {
745 //mrb_raise(mrb, E_RUNTIME_ERROR, "eprpset");
746 return 0;
747 }
748
749 if (*anno)
750 *anno = prop->anno;
751
752 return mrb_fixnum(ret);
753}
754
755/*
756 * データ取得関数
757 */
758static int mrb_ecnl_prop_get(ecnl_svc_task_t *svc, const EPRPINIB *item, void *dst, int size)
759{
760 mrb_state *mrb = svc->mrb;
761 T_MRB_ECNL_EPROPERTY *prop = cast_prop(item);
762 mrb_value args[2];
763 mrb_value ret;
764 int len;
765
766 if (prop->eprpget == 0)
767 return 0;
768
769 args[0] = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_property));
770 DATA_TYPE(args[0]) = &mrb_ecnl_eproperty_type;
771 DATA_PTR(args[0]) = prop;
772
773 args[1] = mrb_fixnum_value(size);
774
775 ret = mrb_funcall_argv(mrb, prop->eobj, prop->eprpget, 2, args);
776
777 if (mrb_type(ret) != MRB_TT_STRING) {
778 //mrb_raise(mrb, E_RUNTIME_ERROR, "eprpget");
779 return 0;
780 }
781
782 len = RSTRING_LEN(ret);
783 if (size > len)
784 size = len;
785
786 memcpy(dst, RSTRING_PTR(ret), size);
787
788 return size;
789}
790
791static mrb_value mrb_ecnl_edata_initialize(mrb_state *mrb, mrb_value self)
792{
793 T_EDATA *dat;
794
795 dat = (T_EDATA *)mrb_malloc(mrb, sizeof(T_EDATA));
796 dat->trn_pos = -1;
797 DATA_TYPE(self) = &mrb_ecnl_edata_type;
798 DATA_PTR(self) = dat;
799
800 return self;
801}
802
803static void mrb_ecnl_edata_free(mrb_state *mrb, void *ptr)
804{
805 T_EDATA *dat = (T_EDATA *)ptr;
806 mrb_free(mrb, dat);
807}
808
809mrb_value mrb_ecnl_edata_new(mrb_state *mrb, T_EDATA *data)
810{
811 mrb_value resv;
812
813 resv = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_data));
814 DATA_TYPE(resv) = &mrb_ecnl_edata_type;
815 DATA_PTR(resv) = data;
816
817 return resv;
818}
819
820/* プロパティ値書き込み・読み出し要求電文折り返し指定 */
821static mrb_value mrb_ecnl_trn_set_get(mrb_state *mrb, mrb_value self)
822{
823 T_EDATA *edat;
824 ER ret;
825
826 edat = (T_EDATA *)DATA_PTR(self);
827 ret = ecn_trn_set_get(mrb, edat, &edat->trn_pos);
828 if (ret != E_OK) {
829 mrb_raise(mrb, E_RUNTIME_ERROR, "trn_set_get");
830 return self;
831 }
832
833 return self;
834}
835
836/* 要求電文へのプロパティ指定追加 */
837static mrb_value mrb_ecnl_add_epc(mrb_state *mrb, mrb_value self)
838{
839 mrb_int epc;
840 T_EDATA *edat;
841 ER ret;
842
843 mrb_get_args(mrb, "i", &epc);
844
845 edat = (T_EDATA *)DATA_PTR(self);
846 ret = ecn_add_epc(mrb, edat, epc);
847 if (ret != E_OK) {
848 mrb_raise(mrb, E_RUNTIME_ERROR, "add_epc");
849 return self;
850 }
851
852 return self;
853}
854
855/* 要求電文へのプロパティデータ追加 */
856static mrb_value mrb_ecnl_add_edt(mrb_state *mrb, mrb_value self)
857{
858 mrb_int epc;
859 mrb_value redt;
860 T_EDATA *edat;
861 ER ret;
862
863 mrb_get_args(mrb, "iS", &epc, &redt);
864
865 edat = (T_EDATA *)DATA_PTR(self);
866 ret = ecn_add_edt(mrb, edat, epc, RSTRING_LEN(redt), RSTRING_PTR(redt));
867 if (ret != E_OK) {
868 mrb_raise(mrb, E_RUNTIME_ERROR, "add_edt");
869 return self;
870 }
871
872 return self;
873}
874
875static mrb_value mrb_ecnl_get_esv(mrb_state *mrb, mrb_value self)
876{
877 mrb_value result;
878 T_EDATA *edat;
879
880 edat = (T_EDATA *)DATA_PTR(self);
881 result = mrb_fixnum_value(edat->hdr.edata.esv);
882
883 return result;
884}
885
886static mrb_value mrb_ecnl_eiterator_initialize(mrb_state *mrb, mrb_value self)
887{
888 T_MRB_ECNL_EITERATOR *itr;
889
890 itr = (T_MRB_ECNL_EITERATOR *)mrb_malloc(mrb, sizeof(T_MRB_ECNL_EITERATOR));
891 DATA_TYPE(self) = &mrb_ecnl_eiterator_type;
892 DATA_PTR(self) = itr;
893
894 return self;
895}
896
897static void mrb_ecnl_eiterator_free(mrb_state *mrb, void *ptr)
898{
899 T_MRB_ECNL_EITERATOR *itr = (T_MRB_ECNL_EITERATOR *)ptr;
900 mrb_free(mrb, itr);
901}
902
903
904/* 応答電文解析イテレーター初期化 */
905static mrb_value mrb_ecnl_itr_ini(mrb_state *mrb, mrb_value self)
906{
907 mrb_value ritr;
908 T_EDATA *edat;
909 T_MRB_ECNL_EITERATOR *eitr;
910 ER ret;
911
912 ritr = mrb_obj_new(mrb, _class_iterator, 0, NULL);
913 eitr = (T_MRB_ECNL_EITERATOR *)DATA_PTR(ritr);
914 eitr->state = 0;
915 eitr->is_eof = false;
916
917 edat = (T_EDATA *)DATA_PTR(self);
918 ret = ecn_itr_ini(&eitr->itr, edat);
919 if (ret != E_OK) {
920 mrb_raise(mrb, E_RUNTIME_ERROR, "itr_ini");
921 return self;
922 }
923
924 return ritr;
925}
926
927/* 応答電文解析イテレーターインクリメント */
928static mrb_value mrb_ecnl_itr_nxt(mrb_state *mrb, mrb_value self)
929{
930 T_MRB_ECNL_EITERATOR *eitr;
931 ER ret;
932
933 eitr = (T_MRB_ECNL_EITERATOR *)DATA_PTR(self);
934 ret = ecn_itr_nxt(mrb, &eitr->itr, &eitr->epc, &eitr->pdc, &eitr->edt);
935 if (ret == E_BOVR) {
936 eitr->state++;
937 eitr->is_eof = eitr->itr.is_eof;
938 }
939 else if (ret != E_OK) {
940 mrb_raise(mrb, E_RUNTIME_ERROR, "itr_nxt");
941 return self;
942 }
943
944 return self;
945}
946
947static mrb_value mrb_ecnl_iterator_get_epc(mrb_state *mrb, mrb_value self)
948{
949 mrb_value result;
950 T_MRB_ECNL_EITERATOR *eitr;
951
952 eitr = (T_MRB_ECNL_EITERATOR *)DATA_PTR(self);
953 result = mrb_fixnum_value(eitr->epc);
954
955 return result;
956}
957
958static mrb_value mrb_ecnl_iterator_get_edt(mrb_state *mrb, mrb_value self)
959{
960 mrb_value result;
961 T_MRB_ECNL_EITERATOR *eitr;
962
963 eitr = (T_MRB_ECNL_EITERATOR *)DATA_PTR(self);
964 result = mrb_str_new(mrb, (char *)eitr->edt, eitr->pdc);
965
966 return result;
967}
968
969static mrb_value mrb_ecnl_iterator_get_state(mrb_state *mrb, mrb_value self)
970{
971 mrb_value result;
972 T_MRB_ECNL_EITERATOR *eitr;
973
974 eitr = (T_MRB_ECNL_EITERATOR *)DATA_PTR(self);
975 result = mrb_fixnum_value(eitr->state);
976
977 return result;
978}
979
980static mrb_value mrb_ecnl_iterator_is_eof(mrb_state *mrb, mrb_value self)
981{
982 mrb_value result;
983 T_MRB_ECNL_EITERATOR *eitr;
984
985 eitr = (T_MRB_ECNL_EITERATOR *)DATA_PTR(self);
986 result = eitr->is_eof ? mrb_true_value() : mrb_false_value();
987
988 return result;
989}
990
991void make_prop_map(ecn_obj_t *eobj, uint8_t *prpmap, int count, ATR flag)
992{
993 if (count < 16) {
994 uint8_t *pos = prpmap;
995 for (int i = 0; i < eobj->eprpcnt; i++) {
996 const EPRPINIB *eprp = eobj->inib.eprp[i];
997 if ((eprp->eprpatr & flag) == 0)
998 continue;
999
1000 *pos++ = eprp->eprpcd;
1001 }
1002 }
1003 else {
1004 for (int i = 0; i < eobj->eprpcnt; i++) {
1005 const EPRPINIB *eprp = eobj->inib.eprp[i];
1006 if ((eprp->eprpatr & flag) == 0)
1007 continue;
1008
1009 ecn_agent_set_epc_to_prop_map(eobj->inib.eprp[i]->eprpcd, prpmap);
1010 }
1011 }
1012}
1013
1014void make_obj_prop_map(ecn_obj_t *eobj)
1015{
1016 int annocnt = 0, setcnt = 0, getcnt = 0;
1017
1018 for (int i = 0; i < eobj->eprpcnt; i++) {
1019 ATR eprpatr = eobj->inib.eprp[i]->eprpatr;
1020 if (eprpatr & EPC_RULE_ANNO)
1021 annocnt++;
1022 if (eprpatr & EPC_RULE_SET)
1023 setcnt++;
1024 if (eprpatr & EPC_RULE_GET)
1025 getcnt++;
1026 }
1027 eobj->annocnt = annocnt;
1028 eobj->setcnt = setcnt;
1029 eobj->getcnt = getcnt;
1030
1031 make_prop_map(eobj, eobj->pmapAnno, annocnt, EPC_RULE_ANNO);
1032 make_prop_map(eobj, eobj->pmapSet, setcnt, EPC_RULE_SET);
1033 make_prop_map(eobj, eobj->pmapGet, getcnt, EPC_RULE_GET);
1034}
1035
1036static mrb_value mrb_ecnl_svctask_initialize(mrb_state *mrb, mrb_value self)
1037{
1038 ecnl_svc_task_t *svc;
1039 mrb_value profile;
1040 ecn_node_t *node;
1041 mrb_value devices;
1042 const mrb_value *eobjs;
1043 ecn_device_t *device;
1044 EOBJCB *eobjcb;
1045 int i, eobjcnt;
1046 ID id = 1;
1047 ER ret;
1048
1049 profile = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "@profile"));
1050 if (mrb_type(profile) == MRB_TT_FALSE) {
1051 mrb_raise(mrb, E_RUNTIME_ERROR, "@profile");
1052 return mrb_nil_value();
1053 }
1054
1055 if (!mrb_obj_is_kind_of(mrb, profile, _class_node)) {
1056 mrb_raise(mrb, E_RUNTIME_ERROR, "@profile");
1057 return mrb_nil_value();
1058 }
1059
1060 devices = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "@devices"));
1061 if (mrb_type(devices) == MRB_TT_FALSE) {
1062 mrb_raise(mrb, E_RUNTIME_ERROR, "@devices");
1063 return mrb_nil_value();
1064 }
1065
1066 if (mrb_type(devices) != MRB_TT_ARRAY) {
1067 mrb_raise(mrb, E_RUNTIME_ERROR, "@devices");
1068 return mrb_nil_value();
1069 }
1070
1071 node = (ecn_node_t *)DATA_PTR(profile);
1072 eobjs = RARRAY_PTR(devices);
1073 eobjcnt = RARRAY_LEN(devices);
1074
1075 svc = (ecnl_svc_task_t *)mrb_calloc(mrb, 1, sizeof(ecnl_svc_task_t)
1076 + (1 + eobjcnt) * sizeof(EOBJINIB *)
1077 + (2 * eobjcnt)/*クラスリスト用*/);
1078 DATA_TYPE(self) = &mrb_ecnl_svctask_type;
1079 DATA_PTR(self) = svc;
1080
1081 svc->eobjlist_need_init = 1;
1082 svc->current_tid = 1;
1083
1084 svc->mrb = mrb;
1085 svc->self = self;
1086 svc->tnum_enodid = 1; /* この版ではローカルノード１つ */
1087 svc->tmax_eobjid = 1 + 1 + eobjcnt;
1088 svc->eobjinib_table = (const EOBJINIB **)&svc[1];
1089 svc->eobjinib_table[0] = &node->base.inib;
1090
1091 eobjcb = &svc->eobjcb_table[0];
1092 eobjcb->eobjs = &svc->eobjinib_table[1];
1093
1094 node->base.svc = svc;
1095 node->base.eobjId = id++;
1096 node->base.inib.enodid = 0;
1097 eobjcb->profile = &node->base.inib;
1098 eobjcb->eobjcnt = eobjcnt;
1099 make_obj_prop_map(&node->base);
1100
1101 for (i = 0; i < eobjcnt; i++) {
1102 if (!mrb_obj_is_kind_of(mrb, eobjs[i], _class_object)) {
1103 mrb_raise(mrb, E_RUNTIME_ERROR, "devices");
1104 goto error;
1105 }
1106 device = (ecn_device_t *)DATA_PTR(eobjs[i]);
1107 device->base.svc = svc;
1108 device->base.eobjId = id++;
1109 device->base.inib.enodid = node->base.eobjId;
1110 eobjcb->eobjs[i] = &device->base.inib;
1111 make_obj_prop_map(&device->base);
1112 }
1113
1114 /* クラスリストの作成 */
1115 svc->eclslst = (uint8_t *)&svc->eobjinib_table[1 + eobjcnt];
1116 uint8_t *pos = svc->eclslst;
1117 int eclscnt = 0;
1118 for (i = 0; i < eobjcnt; i++) {
1119 const EOBJINIB *eobj = eobjcb->eobjs[i];
1120
1121 uint8_t *pos2 = svc->eclslst;
1122 bool_t match = false;
1123 for (int j = 0; j < eclscnt; j++, pos2 += 2) {
1124 const EOBJINIB *eobj2 = eobjcb->eobjs[j];
1125
1126 match = (pos2[0] == eobj2->eojx1) && (pos2[1] = eobj2->eojx2);
1127 if (match)
1128 break;
1129 }
1130 if (match)
1131 continue;
1132
1133 *pos++ = eobj->eojx1;
1134 *pos++ = eobj->eojx2;
1135 eclscnt++;
1136 }
1137 svc->eclscnt = eclscnt;
1138
1139 /* ECHONETミドルウェアを起動 */
1140 ret = ecn_sta_svc(svc);
1141 if (ret != E_OK) {
1142 mrb_raise(mrb, E_RUNTIME_ERROR, "SvcTask.new");
1143 goto error;
1144 }
1145
1146 return self;
1147error:
1148 self = mrb_nil_value();
1149 mrb_free(mrb, svc);
1150
1151 return self;
1152}
1153
1154static ecn_obj_t *cast_obj2(const EOBJINIB *inib)
1155{
1156 return (ecn_obj_t *)((intptr_t)inib - offsetof(ecn_obj_t, inib));
1157}
1158
1159static void mrb_ecnl_svctask_free(mrb_state *mrb, void *ptr)
1160{
1161 ecnl_svc_task_t *svc = (ecnl_svc_task_t *)ptr;
1162#if 0 /* どこかで解放しているらしい･･･ */
1163 const EOBJINIB **table = svc->eobjinib_table;
1164 const EOBJINIB **end = &table[svc->tmax_eobjid];
1165
1166 for (; table < end; table++) {
1167 mrb_free(mrb, cast_obj2(*table));
1168 }
1169#endif
1170 mrb_free(mrb, svc);
1171}
1172
1173const EOBJINIB *echonet_svctask_get_eobjinib(ecnl_svc_task_t *svc, ID eobjid)
1174{
1175 return svc->eobjinib_table[eobjid - 1];
1176}
1177
1178ID echonet_svctask_get_eobjid(ecnl_svc_task_t *svc, const EOBJINIB *eobjinib)
1179{
1180 int i, count = svc->tmax_eobjid;
1181
1182 for (i = 0; i < count; i++) {
1183 if (svc->eobjinib_table[i] == eobjinib) {
1184 return i + 1;
1185 }
1186 }
1187
1188 return 0;
1189}
1190
1191/* プロパティ値書き込み要求（応答不要）電文作成 */
1192static mrb_value mrb_ecnl_esv_set_i(mrb_state *mrb, mrb_value self)
1193{
1194 mrb_value resv;
1195 mrb_value reobj;
1196 mrb_int epc;
1197 mrb_value redt;
1198 T_EDATA *edat;
1199 ecn_device_t *eobj;
1200 ER ret;
1201 ID eobjid;
1202 ecnl_svc_task_t *svc;
1203
1204 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1205 svc->mrb = mrb;
1206
1207 mrb_get_args(mrb, "oiS", &reobj, &epc, &redt);
1208
1209 if (mrb_nil_p(reobj)) {
1210 eobjid = EOBJ_NULL;
1211 }
1212 else {
1213 eobj = (ecn_device_t *)DATA_PTR(reobj);
1214 eobjid = eobj->base.eobjId;
1215 }
1216
1217 ret = ecn_esv_seti(svc, &edat, eobjid, epc, RSTRING_LEN(redt), RSTRING_PTR(redt));
1218 if (ret != E_OK) {
1219 mrb_raise(mrb, E_RUNTIME_ERROR, "esv_set_i");
1220 return self;
1221 }
1222
1223 resv = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_data));
1224 DATA_TYPE(resv) = &mrb_ecnl_edata_type;
1225 DATA_PTR(resv) = edat;
1226
1227 return resv;
1228}
1229
1230/* プロパティ値書き込み要求（応答要）電文作成 */
1231static mrb_value mrb_ecnl_esv_set_c(mrb_state *mrb, mrb_value self)
1232{
1233 mrb_value resv;
1234 mrb_value reobj;
1235 mrb_int epc;
1236 mrb_int pdc;
1237 mrb_value redt;
1238 T_EDATA *edat;
1239 ecn_device_t *eobj;
1240 ER ret;
1241 ID eobjid;
1242 ecnl_svc_task_t *svc;
1243
1244 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1245 svc->mrb = mrb;
1246
1247 mrb_get_args(mrb, "oiS", &reobj, &epc, &pdc, &redt);
1248
1249 if (mrb_nil_p(reobj)) {
1250 eobjid = EOBJ_NULL;
1251 }
1252 else {
1253 eobj = (ecn_device_t *)DATA_PTR(reobj);
1254 eobjid = eobj->base.eobjId;
1255 }
1256
1257 ret = ecn_esv_setc(svc, &edat, eobjid, epc, RSTRING_LEN(redt), RSTRING_PTR(redt));
1258 if (ret != E_OK) {
1259 mrb_raise(mrb, E_RUNTIME_ERROR, "esv_set_c");
1260 return self;
1261 }
1262
1263 resv = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_data));
1264 DATA_TYPE(resv) = &mrb_ecnl_edata_type;
1265 DATA_PTR(resv) = edat;
1266
1267 return resv;
1268}
1269
1270/* プロパティ値読み出し要求電文作成 */
1271static mrb_value mrb_ecnl_esv_get(mrb_state *mrb, mrb_value self)
1272{
1273 mrb_value resv;
1274 mrb_value reobj;
1275 mrb_int epc;
1276 T_EDATA *edat;
1277 ecn_device_t *eobj;
1278 ER ret;
1279 ID eobjid;
1280 ecnl_svc_task_t *svc;
1281
1282 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1283 svc->mrb = mrb;
1284
1285 mrb_get_args(mrb, "oi", &reobj, &epc);
1286
1287 if (mrb_nil_p(reobj)) {
1288 eobjid = EOBJ_NULL;
1289 }
1290 else {
1291 eobj = (ecn_device_t *)DATA_PTR(reobj);
1292 eobjid = eobj->base.eobjId;
1293 }
1294
1295 ret = ecn_esv_get(svc, &edat, eobjid, epc);
1296 if (ret != E_OK) {
1297 mrb_raise(mrb, E_RUNTIME_ERROR, "esv_get");
1298 return self;
1299 }
1300
1301 resv = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_data));
1302 DATA_TYPE(resv) = &mrb_ecnl_edata_type;
1303 DATA_PTR(resv) = edat;
1304
1305 return resv;
1306}
1307
1308/* プロパティ値通知要求電文作成 */
1309static mrb_value mrb_ecnl_esv_inf_req(mrb_state *mrb, mrb_value self)
1310{
1311 mrb_value resv;
1312 mrb_value reobj;
1313 mrb_int epc;
1314 T_EDATA *edat;
1315 ecn_device_t *eobj;
1316 ER ret;
1317 ID eobjid;
1318 ecnl_svc_task_t *svc;
1319
1320 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1321 svc->mrb = mrb;
1322
1323 mrb_get_args(mrb, "oi", &reobj, &epc);
1324
1325 if (mrb_nil_p(reobj)) {
1326 eobjid = EOBJ_NULL;
1327 }
1328 else {
1329 eobj = (ecn_device_t *)DATA_PTR(reobj);
1330 eobjid = eobj->base.eobjId;
1331 }
1332
1333 ret = ecn_esv_inf_req(svc, &edat, eobjid, epc);
1334 if (ret != E_OK) {
1335 mrb_raise(mrb, E_RUNTIME_ERROR, "esv_inf_req");
1336 return self;
1337 }
1338
1339 resv = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_data));
1340 DATA_TYPE(resv) = &mrb_ecnl_edata_type;
1341 DATA_PTR(resv) = edat;
1342
1343 return resv;
1344}
1345
1346/* プロパティ値書き込み・読み出し要求電文作成 */
1347static mrb_value mrb_ecnl_esv_set_get(mrb_state *mrb, mrb_value self)
1348{
1349 mrb_value resv;
1350 mrb_value reobj;
1351 mrb_int epc;
1352 mrb_value redt;
1353 T_EDATA *edat;
1354 ecn_device_t *eobj;
1355 ER ret;
1356 ID eobjid;
1357 ecnl_svc_task_t *svc;
1358
1359 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1360 svc->mrb = mrb;
1361
1362 mrb_get_args(mrb, "oiS", &reobj, &epc, &redt);
1363
1364 if (mrb_nil_p(reobj)) {
1365 eobjid = EOBJ_NULL;
1366 }
1367 else {
1368 eobj = (ecn_device_t *)DATA_PTR(reobj);
1369 eobjid = eobj->base.eobjId;
1370 }
1371
1372 ret = ecn_esv_set_get(svc, &edat, eobjid, epc, RSTRING_LEN(redt), RSTRING_PTR(redt));
1373 if (ret != E_OK) {
1374 mrb_raise(mrb, E_RUNTIME_ERROR, "esv_set_get");
1375 return self;
1376 }
1377
1378 resv = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_data));
1379 DATA_TYPE(resv) = &mrb_ecnl_edata_type;
1380 DATA_PTR(resv) = edat;
1381
1382 return resv;
1383}
1384
1385/* プロパティ値通知（応答要）電文作成 */
1386static mrb_value mrb_ecnl_esv_infc(mrb_state *mrb, mrb_value self)
1387{
1388 mrb_value resv;
1389 mrb_value reobj;
1390 mrb_value rseobj;
1391 mrb_int sepc;
1392 T_EDATA *edat;
1393 ecn_device_t *eobj;
1394 ecn_device_t *seobj;
1395 ER ret;
1396 ID eobjid, seobjid;
1397 ecnl_svc_task_t *svc;
1398
1399 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1400 svc->mrb = mrb;
1401
1402 mrb_get_args(mrb, "ooi", &reobj, &rseobj, &sepc);
1403
1404 if (mrb_nil_p(reobj)) {
1405 eobjid = EOBJ_NULL;
1406 }
1407 else {
1408 eobj = (ecn_device_t *)DATA_PTR(reobj);
1409 eobjid = eobj->base.eobjId;
1410 }
1411
1412 if (mrb_nil_p(rseobj)) {
1413 seobjid = EOBJ_NULL;
1414 }
1415 else {
1416 seobj = (ecn_device_t *)DATA_PTR(rseobj);
1417 seobjid = seobj->base.eobjId;
1418 }
1419
1420 ret = ecn_esv_infc(svc, &edat, eobjid, seobjid, sepc);
1421 if (ret != E_OK) {
1422 mrb_raise(mrb, E_RUNTIME_ERROR, "esv_infc");
1423 return self;
1424 }
1425
1426 resv = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, _class_data));
1427 DATA_TYPE(resv) = &mrb_ecnl_edata_type;
1428 DATA_PTR(resv) = edat;
1429
1430 return resv;
1431}
1432
1433/* 要求電文の送信 */
1434static mrb_value mrb_ecnl_snd_esv(mrb_state *mrb, mrb_value self)
1435{
1436 mrb_value resv;
1437 T_EDATA *edat;
1438 ER ret;
1439 ecnl_svc_task_t *svc;
1440
1441 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1442 svc->mrb = mrb;
1443
1444 mrb_get_args(mrb, "o", &resv);
1445
1446 if (!mrb_obj_is_kind_of(mrb, resv, _class_data)) {
1447 mrb_raise(mrb, E_RUNTIME_ERROR, "snd_esv");
1448 return mrb_nil_value();
1449 }
1450
1451 edat = (T_EDATA *)DATA_PTR(resv);
1452 DATA_PTR(resv) = NULL;
1453
1454 if (edat->trn_pos != -1) {
1455 ret = ecn_end_set_get(mrb, edat, edat->trn_pos);
1456 if (ret != E_OK) {
1457 mrb_raise(mrb, E_RUNTIME_ERROR, "end_set_get");
1458 return self;
1459 }
1460 }
1461
1462 ret = ecn_snd_esv(svc, edat);
1463 if (ret != E_OK) {
1464 mrb_raise(mrb, E_RUNTIME_ERROR, "snd_esv");
1465 return self;
1466 }
1467
1468 return self;
1469}
1470
1471/* 電文の破棄 */
1472static mrb_value mrb_ecnl_rel_esv(mrb_state *mrb, mrb_value self)
1473{
1474 mrb_value resv;
1475 T_EDATA *edat;
1476 ER ret;
1477 ecnl_svc_task_t *svc;
1478
1479 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1480 svc->mrb = mrb;
1481
1482 mrb_get_args(mrb, "o", &resv);
1483
1484 if (!mrb_obj_is_kind_of(mrb, resv, _class_data)) {
1485 mrb_raise(mrb, E_RUNTIME_ERROR, "rel_esv");
1486 return mrb_nil_value();
1487 }
1488
1489 edat = (T_EDATA *)DATA_PTR(resv);
1490 DATA_PTR(resv) = NULL;
1491
1492 ret = ecn_rel_esv(mrb, edat);
1493 if (ret != E_OK) {
1494 mrb_raise(mrb, E_RUNTIME_ERROR, "rel_esv");
1495 return self;
1496 }
1497
1498 return self;
1499}
1500
1501static mrb_value mrb_ecnl_svctask_ntf_inl(mrb_state *mrb, mrb_value self)
1502{
1503 ER ret;
1504 ecnl_svc_task_t *svc;
1505
1506 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1507 svc->mrb = mrb;
1508
1509 /* インスタンスリスト通知の送信 */
1510 ret = _ecn_tsk_ntf_inl(svc);
1511 if (ret != E_OK) {
1512 mrb_raise(mrb, E_RUNTIME_ERROR, "ntf_inl");
1513 return self;
1514 }
1515
1516 return self;
1517}
1518
1519static mrb_value mrb_ecnl_svctask_set_timer(mrb_state *mrb, mrb_value self)
1520{
1521 TMO timer;
1522 ecnl_svc_task_t *svc;
1523
1524 mrb_get_args(mrb, "i", &timer);
1525
1526 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1527 svc->api_timer = timer;
1528
1529 return self;
1530}
1531
1532static mrb_value mrb_ecnl_svctask_get_timer(mrb_state *mrb, mrb_value self)
1533{
1534 TMO timer1, timer2;
1535 ecnl_svc_task_t *svc;
1536
1537 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1538 svc->mrb = mrb;
1539
1540 timer1 = echonet_svctask_get_timer(svc);
1541
1542 timer2 = echonet_lcltask_get_timer(svc);
1543 if ((timer1 == TMO_FEVR) || (timer1 > timer2))
1544 timer1 = timer2;
1545
1546 timer2 = svc->api_timer;
1547 if ((timer1 == TMO_FEVR) || (timer1 > timer2))
1548 timer1 = timer2;
1549
1550 return mrb_fixnum_value(timer1);
1551}
1552
1553static mrb_value mrb_ecnl_svctask_progress(mrb_state *mrb, mrb_value self)
1554{
1555 ecnl_svc_task_t *svc;
1556 TMO interval;
1557
1558 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1559 svc->mrb = mrb;
1560
1561 mrb_get_args(mrb, "i", &interval);
1562
1563 echonet_svctask_progress(svc, interval);
1564 echonet_lcltask_progress(svc, interval);
1565
1566 svc->api_timer -= interval;
1567 if (svc->api_timer < 0) {
1568 svc->api_timer = 0;
1569 }
1570
1571 return mrb_nil_value();
1572}
1573
1574/*
1575 * Echonet電文受信処理
1576 */
1577static void main_recv_esv(ecnl_svc_task_t *svc, T_EDATA *esv)
1578{
1579 mrb_state *mrb = svc->mrb;
1580 mrb_value resv;
1581
1582 resv = mrb_ecnl_edata_new(mrb, esv);
1583
1584 mrb_funcall(mrb, svc->self, "recv_esv", 1, resv);
1585}
1586
1587/*
1588 * 応答電文待ちの割り込み処理
1589 */
1590static void main_break_wait(ecnl_svc_task_t *svc, uint8_t *brkdat, int32_t len)
1591{
1592 mrb_state *mrb = svc->mrb;
1593 mrb_value str;
1594
1595 str = mrb_str_new(mrb, (char *)brkdat, len);
1596
1597 mrb_funcall(mrb, svc->self, "break_wait", 1, str);
1598}
1599
1600void echonet_apptask_recv_msg(ecnl_svc_task_t *svc, T_ECN_FST_BLK *p_msg)
1601{
1602 mrb_state *mrb = svc->mrb;
1603 uint8_t brkdat[64];
1604 int len;
1605 ER ret;
1606
1607 /* Echonet電文受信の場合 */
1608 if ((p_msg)->hdr.type == ECN_MSG_ECHONET) {
1609 /* Echonet電文受信処理 */
1610 main_recv_esv(svc, (T_EDATA *)p_msg);
1611
1612 /* 領域解放はGCに任せる
1613 ret = ecn_rel_esv(mrb, (T_EDATA *)p_msg);
1614 if (ret != E_OK) {
1615 mrb_raise(mrb, E_RUNTIME_ERROR, "ecn_rel_esv");
1616 return;
1617 } */
1618 }
1619 /* 応答電文待ちの割り込みの場合 */
1620 else if ((p_msg)->hdr.type == ECN_MSG_INTERNAL) {
1621 /* 応答電文待ちの割り込みデータ取得 */
1622 ret = ecn_get_brk_dat(mrb, (T_EDATA *)p_msg, brkdat, sizeof(brkdat), &len);
1623 if (ret != E_OK) {
1624 mrb_raise(mrb, E_RUNTIME_ERROR, "ecn_get_brk_dat");
1625 return;
1626 }
1627
1628 /* 応答電文待ちの割り込み処理 */
1629 main_break_wait(svc, brkdat, len);
1630
1631 /* 領域解放 */
1632 ret = ecn_rel_esv(mrb, (T_EDATA *)p_msg);
1633 if (ret != E_OK) {
1634 mrb_raise(mrb, E_RUNTIME_ERROR, "ecn_rel_esv");
1635 return;
1636 }
1637 }
1638}
1639
1640static void mrb_ecnl_svctask_proccess(ecnl_svc_task_t *svc)
1641{
1642 T_ECN_FST_BLK *p_msg = NULL;
1643 ER ret;
1644 int i;
1645
1646 do {
1647 i = 0;
1648
1649 ret = ecn_fbs_dequeue(&svc->svc_mbxid, &p_msg);
1650 if (ret == E_OK) {
1651 echonet_svctask_recv_msg(svc, p_msg);
1652 i++;
1653 }
1654
1655 ret = ecn_fbs_dequeue(&svc->lcl_mbxid, &p_msg);
1656 if (ret == E_OK) {
1657 echonet_lcltask_recv_msg(svc, p_msg);
1658 i++;
1659 }
1660
1661 ret = ecn_fbs_dequeue(&svc->api_mbxid, &p_msg);
1662 if (ret == E_OK) {
1663 echonet_apptask_recv_msg(svc, p_msg);
1664 i++;
1665 }
1666 } while (i != 0);
1667}
1668
1669/* 通信レイヤーからの入力 */
1670static mrb_value mrb_ecnl_svctask_recv_msg(mrb_state *mrb, mrb_value self)
1671{
1672 ecnl_svc_task_t *svc;
1673 mrb_value ep;
1674 mrb_value data;
1675
1676 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1677 svc->mrb = mrb;
1678
1679 mrb_get_args(mrb, "oS", &ep, &data);
1680
1681 echonet_lcl_input_msg(svc, ep, data);
1682
1683 mrb_ecnl_svctask_proccess(svc);
1684
1685 return mrb_nil_value();
1686}
1687
1688static mrb_value mrb_ecnl_svctask_call_timeout(mrb_state *mrb, mrb_value self)
1689{
1690 ecnl_svc_task_t *svc;
1691
1692 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1693 svc->mrb = mrb;
1694
1695 echonet_svctask_timeout(svc);
1696 echonet_lcltask_timeout(svc);
1697
1698 if (svc->api_timer == 0) {
1699 svc->api_timer = -1;
1700
1701 mrb_funcall(mrb, svc->self, "timeout", 0);
1702 }
1703
1704 mrb_ecnl_svctask_proccess(svc);
1705
1706 return mrb_nil_value();
1707}
1708
1709static mrb_value mrb_ecnl_svctask_is_match(mrb_state *mrb, mrb_value self)
1710{
1711 ecnl_svc_task_t *svc;
1712 mrb_value enod;
1713 EOBJCB *enodcb;
1714 mrb_value edata;
1715 T_EDATA *edat;
1716 mrb_value ep;
1717 bool_t ret;
1718
1719 svc = (ecnl_svc_task_t *)DATA_PTR(self);
1720 svc->mrb = mrb;
1721
1722 mrb_get_args(mrb, "ooo", &enod, &edata, &ep);
1723
1724 enodcb = (EOBJCB *)DATA_PTR(enod);
1725 edat = (T_EDATA *)DATA_PTR(edata);
1726
1727 ret = ecn_is_match(svc, enodcb, edat, ep);
1728
1729 return mrb_bool_value(ret);
1730}
1731
1732bool_t lcl_is_local_addr(ecnl_svc_task_t *svc, mrb_value ep)
1733{
1734 mrb_state *mrb = svc->mrb;
1735 mrb_value ret;
1736
1737 ret = mrb_funcall(mrb, svc->self, "is_local_addr", 1, ep);
1738
1739 if (mrb_type(ret) == MRB_TT_TRUE)
1740 return true;
1741
1742 if (mrb_type(ret) == MRB_TT_FALSE)
1743 return false;
1744
1745 mrb_raise(mrb, E_RUNTIME_ERROR, "is_local_addr");
1746 return false;
1747}
1748
1749bool_t lcl_is_multicast_addr(ecnl_svc_task_t *svc, mrb_value ep)
1750{
1751 mrb_state *mrb = svc->mrb;
1752 mrb_value ret;
1753
1754 ret = mrb_funcall(mrb, svc->self, "is_multicast_addr", 1, ep);
1755
1756 if (mrb_type(ret) == MRB_TT_TRUE)
1757 return true;
1758
1759 if (mrb_type(ret) == MRB_TT_FALSE)
1760 return false;
1761
1762 mrb_raise(mrb, E_RUNTIME_ERROR, "is_multicast_addr");
1763 return false;
1764}
1765
1766bool_t lcl_is_valid_addrid(ecnl_svc_task_t *svc, ECN_ENOD_ID id)
1767{
1768 mrb_state *mrb = svc->mrb;
1769 mrb_value ret;
1770
1771 ret = mrb_funcall(mrb, svc->self, "is_valid_addrid", 1, mrb_fixnum_value(id));
1772
1773 if (mrb_type(ret) == MRB_TT_TRUE)
1774 return true;
1775
1776 if (mrb_type(ret) == MRB_TT_FALSE)
1777 return false;
1778
1779 mrb_raise(mrb, E_RUNTIME_ERROR, "is_valid_addrid");
1780 return false;
1781}
1782
1783mrb_value lcl_get_local_addr(ecnl_svc_task_t *svc)
1784{
1785 return mrb_funcall(svc->mrb, svc->self, "get_local_addr", 0);
1786}
1787
1788mrb_value lcl_get_multicast_addr(ecnl_svc_task_t *svc)
1789{
1790 return mrb_funcall(svc->mrb, svc->self, "get_multicast_addr", 0);
1791}
1792
1793mrb_value lcl_get_remote_addr(ecnl_svc_task_t *svc, ECN_ENOD_ID id)
1794{
1795 return mrb_funcall(svc->mrb, svc->self, "get_remote_addr", 1, mrb_fixnum_value(id));
1796}
1797
1798ECN_ENOD_ID lcl_get_remote_id(ecnl_svc_task_t *svc, const mrb_value ep)
1799{
1800 mrb_state *mrb = svc->mrb;
1801 mrb_value ret;
1802
1803 ret = mrb_funcall(mrb, svc->self, "get_remote_id", 1, ep);
1804
1805 if (mrb_type(ret) == MRB_TT_FALSE)
1806 return ENOD_NOT_MATCH_ID;
1807
1808 if (mrb_type(ret) == MRB_TT_FIXNUM)
1809 return (ECN_ENOD_ID)mrb_fixnum(ret);
1810
1811 return ENOD_NOT_MATCH_ID;
1812}
1813
1814ECN_ENOD_ID lcl_set_remote_addr(ecnl_svc_task_t *svc, T_EDATA *edata, mrb_value ep)
1815{
1816 mrb_state *mrb = svc->mrb;
1817 mrb_value edat = mrb_obj_value(edata);
1818 mrb_value ret;
1819
1820 ret = mrb_funcall(mrb, svc->self, "set_remote_addr", 2, edat, ep);
1821
1822 if (mrb_type(ret) == MRB_TT_FALSE)
1823 return ENOD_NOT_MATCH_ID;
1824
1825 if (mrb_type(ret) == MRB_TT_FIXNUM)
1826 return (ECN_ENOD_ID)mrb_fixnum(ret);
1827
1828 return ENOD_NOT_MATCH_ID;
1829}
1830
1831ECN_ENOD_ID lcl_add_remote_addr(ecnl_svc_task_t *svc, T_EDATA *edata, mrb_value ep)
1832{
1833 mrb_state *mrb = svc->mrb;
1834 mrb_value edat = mrb_obj_value(edata);
1835 mrb_value ret;
1836
1837 ret = mrb_funcall(mrb, svc->self, "add_remote_addr", 2, edat, ep);
1838
1839 if (mrb_type(ret) == MRB_TT_FALSE)
1840 return ENOD_NOT_MATCH_ID;
1841
1842 if (mrb_type(ret) == MRB_TT_FIXNUM)
1843 return (ECN_ENOD_ID)mrb_fixnum(ret);
1844
1845 return ENOD_NOT_MATCH_ID;
1846}
1847
1848ER lcl_snd_msg(ecnl_svc_task_t *svc, mrb_value ep, mrb_value msg)
1849{
1850 mrb_funcall(svc->mrb, svc->self, "snd_msg", 2, ep, msg);
1851
1852 return E_OK;
1853}
1854
1855void mrb_mruby_ecnl_gem_init(mrb_state *mrb)
1856{
1857 _module_ecnl = mrb_define_module(mrb, "ECNL");
1858
1859 /* 未設定 */
1860 mrb_define_const(mrb, _module_ecnl, "EPC_NONE", mrb_fixnum_value(EPC_NONE));
1861 /* アクセスルール Set */
1862 mrb_define_const(mrb, _module_ecnl, "EPC_RULE_SET", mrb_fixnum_value(EPC_RULE_SET));
1863 /* アクセスルール Get */
1864 mrb_define_const(mrb, _module_ecnl, "EPC_RULE_GET", mrb_fixnum_value(EPC_RULE_GET));
1865 /* アクセスルール Anno */
1866 mrb_define_const(mrb, _module_ecnl, "EPC_RULE_ANNO", mrb_fixnum_value(EPC_RULE_ANNO));
1867 /* 状態変化時通知 */
1868 mrb_define_const(mrb, _module_ecnl, "EPC_ANNOUNCE", mrb_fixnum_value(EPC_ANNOUNCE));
1869 /* 可変長データ */
1870 mrb_define_const(mrb, _module_ecnl, "EPC_VARIABLE", mrb_fixnum_value(EPC_VARIABLE));
1871
1872 /* プロパティ値書き込み要求（応答不要） */
1873 mrb_define_const(mrb, _module_ecnl, "ESV_SET_I", mrb_fixnum_value(ESV_SET_I));
1874 /* プロパティ値書き込み要求（応答要） */
1875 mrb_define_const(mrb, _module_ecnl, "ESV_SET_C", mrb_fixnum_value(ESV_SET_C));
1876 /* プロパティ値読み出し要求 */
1877 mrb_define_const(mrb, _module_ecnl, "ESV_GET", mrb_fixnum_value(ESV_GET));
1878 /* プロパティ値通知要求 */
1879 mrb_define_const(mrb, _module_ecnl, "ESV_INF_REQ", mrb_fixnum_value(ESV_INF_REQ));
1880 /* プロパティ値書き込み・読み出し要求 */
1881 mrb_define_const(mrb, _module_ecnl, "ESV_SET_GET", mrb_fixnum_value(ESV_SET_GET));
1882 /* プロパティ値書き込み応答 */
1883 mrb_define_const(mrb, _module_ecnl, "ESV_SET_RES", mrb_fixnum_value(ESV_SET_RES));
1884 /* プロパティ値読み出し応答 */
1885 mrb_define_const(mrb, _module_ecnl, "ESV_GET_RES", mrb_fixnum_value(ESV_GET_RES));
1886 /* プロパティ値通知 */
1887 mrb_define_const(mrb, _module_ecnl, "ESV_INF", mrb_fixnum_value(ESV_INF));
1888 /* プロパティ値通知（応答要） */
1889 mrb_define_const(mrb, _module_ecnl, "ESV_INFC", mrb_fixnum_value(ESV_INFC));
1890 /* プロパティ値通知応答 */
1891 mrb_define_const(mrb, _module_ecnl, "ESV_INFC_RES", mrb_fixnum_value(ESV_INFC_RES));
1892 /* プロパティ値書き込み・読み出し応答 */
1893 mrb_define_const(mrb, _module_ecnl, "ESV_SET_GET_RES", mrb_fixnum_value(ESV_SET_GET_RES));
1894 /* プロパティ値書き込み要求不可応答 */
1895 mrb_define_const(mrb, _module_ecnl, "ESV_SET_I_SNA", mrb_fixnum_value(ESV_SET_I_SNA));
1896 /* プロパティ値書き込み要求不可応答 */
1897 mrb_define_const(mrb, _module_ecnl, "ESV_SET_C_SNA", mrb_fixnum_value(ESV_SET_C_SNA));
1898 /* プロパティ値読み出し不可応答 */
1899 mrb_define_const(mrb, _module_ecnl, "ESV_GET_SNA", mrb_fixnum_value(ESV_GET_SNA));
1900 /* プロパティ値通知不可応答 */
1901 mrb_define_const(mrb, _module_ecnl, "ESV_INF_SNA", mrb_fixnum_value(ESV_INF_SNA));
1902 /* プロパティ値書き込み・読み出し不可応答 */
1903 mrb_define_const(mrb, _module_ecnl, "ESV_SET_GET_SNA", mrb_fixnum_value(ESV_SET_GET_SNA));
1904
1905 /* アドレスID登録なし */
1906 mrb_define_const(mrb, _module_ecnl, "ENOD_NOT_MATCH_ID", mrb_fixnum_value(ENOD_NOT_MATCH_ID));
1907 /* マルチキャストアドレスID */
1908 mrb_define_const(mrb, _module_ecnl, "ENOD_MULTICAST_ID", mrb_fixnum_value(ENOD_MULTICAST_ID));
1909 /* 自ノードアドレスID */
1910 mrb_define_const(mrb, _module_ecnl, "ENOD_LOCAL_ID", mrb_fixnum_value(ENOD_LOCAL_ID));
1911 /* APIアドレスID */
1912 mrb_define_const(mrb, _module_ecnl, "ENOD_API_ID", mrb_fixnum_value(ENOD_API_ID));
1913 /* 他ノードID */
1914 mrb_define_const(mrb, _module_ecnl, "ENOD_REMOTE_ID", mrb_fixnum_value(ENOD_REMOTE_ID));
1915
1916 _class_object = mrb_define_class_under(mrb, _module_ecnl, "EObject", mrb->object_class);
1917 MRB_SET_INSTANCE_TT(_class_object, MRB_TT_DATA);
1918 mrb_define_method(mrb, _class_object, "initialize", mrb_ecnl_eobject_initialize, MRB_ARGS_REQ(5));
1919
1920 /* プロパティ値書き込み */
1921 mrb_define_method(mrb, _class_object, "data_prop_set", mrb_ecnl_eobject_data_prop_set, MRB_ARGS_REQ(4));
1922
1923 /* プロパティ値読み出し */
1924 mrb_define_method(mrb, _class_object, "data_prop_get", mrb_ecnl_eobject_data_prop_get, MRB_ARGS_REQ(3));
1925
1926 _class_node = mrb_define_class_under(mrb, _module_ecnl, "ENode", mrb->object_class);
1927 MRB_SET_INSTANCE_TT(_class_node, MRB_TT_DATA);
1928 mrb_define_method(mrb, _class_node, "initialize", mrb_ecnl_enode_initialize, MRB_ARGS_REQ(2));
1929
1930 /* プロパティ値書き込み */
1931 mrb_define_method(mrb, _class_node, "data_prop_set", mrb_ecnl_eobject_data_prop_set, MRB_ARGS_REQ(4));
1932
1933 /* プロパティ値読み出し */
1934 mrb_define_method(mrb, _class_node, "data_prop_get", mrb_ecnl_eobject_data_prop_get, MRB_ARGS_REQ(3));
1935
1936 _class_property = mrb_define_class_under(mrb, _module_ecnl, "EProperty", mrb->object_class);
1937 MRB_SET_INSTANCE_TT(_class_property, MRB_TT_DATA);
1938 mrb_define_method(mrb, _class_property, "initialize", mrb_ecnl_eproperty_initialize, MRB_ARGS_REQ(6));
1939
1940 /* ECHONET Lite プロパティコード */
1941 mrb_define_method(mrb, _class_property, "pcd", mrb_ecnl_eproperty_get_pcd, MRB_ARGS_NONE());
1942 /* ECHONET Lite プロパティ属性 */
1943 mrb_define_method(mrb, _class_property, "atr", mrb_ecnl_eproperty_get_atr, MRB_ARGS_NONE());
1944 /* ECHONET Lite プロパティのサイズ */
1945 mrb_define_method(mrb, _class_property, "sz", mrb_ecnl_eproperty_get_sz, MRB_ARGS_NONE());
1946 /* ECHONET Lite プロパティの拡張情報 */
1947 mrb_define_method(mrb, _class_property, "exinf", mrb_ecnl_eproperty_get_exinf, MRB_ARGS_NONE());
1948 mrb_define_method(mrb, _class_property, "set_exinf", mrb_ecnl_eproperty_set_exinf, MRB_ARGS_REQ(1));
1949 /* ECHONET Lite プロパティの設定関数 */
1950 mrb_define_method(mrb, _class_property, "setcb", mrb_ecnl_eproperty_get_setcb, MRB_ARGS_NONE());
1951 /* ECHONET Lite プロパティの取得関数 */
1952 mrb_define_method(mrb, _class_property, "getcb", mrb_ecnl_eproperty_get_getcb, MRB_ARGS_NONE());
1953 /* ECHONET Lite プロパティの通知有無 */
1954 mrb_define_method(mrb, _class_property, "anno", mrb_ecnl_eproperty_get_anno, MRB_ARGS_NONE());
1955 mrb_define_method(mrb, _class_property, "set_anno", mrb_ecnl_eproperty_set_anno, MRB_ARGS_REQ(1));
1956
1957 _class_data = mrb_define_class_under(mrb, _module_ecnl, "EData", mrb->object_class);
1958 MRB_SET_INSTANCE_TT(_class_data, MRB_TT_DATA);
1959 mrb_define_method(mrb, _class_data, "initialize", mrb_ecnl_edata_initialize, MRB_ARGS_NONE());
1960
1961 /* プロパティ値書き込み・読み出し要求電文折り返し指定 */
1962 mrb_define_method(mrb, _class_data, "trn_set_get", mrb_ecnl_trn_set_get, MRB_ARGS_NONE());
1963
1964 /* 要求電文へのプロパティ指定追加 */
1965 mrb_define_method(mrb, _class_data, "add_epc", mrb_ecnl_add_epc, MRB_ARGS_REQ(1));
1966
1967 /* 要求電文へのプロパティデータ追加 */
1968 mrb_define_method(mrb, _class_data, "add_edt", mrb_ecnl_add_edt, MRB_ARGS_REQ(2));
1969
1970 /* 応答電文サービスコード取得 */
1971 mrb_define_method(mrb, _class_data, "esv", mrb_ecnl_get_esv, MRB_ARGS_NONE());
1972
1973 /* 応答電文解析イテレーター初期化 */
1974 mrb_define_method(mrb, _class_data, "itr_ini", mrb_ecnl_itr_ini, MRB_ARGS_NONE());
1975
1976 _class_iterator = mrb_define_class_under(mrb, _module_ecnl, "EIterator", mrb->object_class);
1977 MRB_SET_INSTANCE_TT(_class_iterator, MRB_TT_DATA);
1978 mrb_define_method(mrb, _class_iterator, "initialize", mrb_ecnl_eiterator_initialize, MRB_ARGS_NONE());
1979
1980 /* 応答電文解析イテレーターインクリメント */
1981 mrb_define_method(mrb, _class_iterator, "itr_nxt", mrb_ecnl_itr_nxt, MRB_ARGS_NONE());
1982
1983 mrb_define_method(mrb, _class_iterator, "epc", mrb_ecnl_iterator_get_epc, MRB_ARGS_NONE());
1984 mrb_define_method(mrb, _class_iterator, "edt", mrb_ecnl_iterator_get_edt, MRB_ARGS_NONE());
1985 mrb_define_method(mrb, _class_iterator, "state", mrb_ecnl_iterator_get_state, MRB_ARGS_NONE());
1986 mrb_define_method(mrb, _class_iterator, "is_eof", mrb_ecnl_iterator_is_eof, MRB_ARGS_NONE());
1987
1988 _class_svctask = mrb_define_class_under(mrb, _module_ecnl, "SvcTask", mrb->object_class);
1989 MRB_SET_INSTANCE_TT(_class_svctask, MRB_TT_DATA);
1990 mrb_define_method(mrb, _class_svctask, "initialize", mrb_ecnl_svctask_initialize, MRB_ARGS_NONE());
1991
1992 /* プロパティ値書き込み要求（応答不要）電文作成 */
1993 mrb_define_method(mrb, _class_svctask, "esv_set_i", mrb_ecnl_esv_set_i, MRB_ARGS_REQ(3));
1994
1995 /* プロパティ値書き込み要求（応答要）電文作成 */
1996 mrb_define_method(mrb, _class_svctask, "esv_set_c", mrb_ecnl_esv_set_c, MRB_ARGS_REQ(3));
1997
1998 /* プロパティ値読み出し要求電文作成 */
1999 mrb_define_method(mrb, _class_svctask, "esv_get", mrb_ecnl_esv_get, MRB_ARGS_REQ(2));
2000
2001 /* プロパティ値通知要求電文作成 */
2002 mrb_define_method(mrb, _class_svctask, "esv_inf_req", mrb_ecnl_esv_inf_req, MRB_ARGS_REQ(2));
2003
2004 /* プロパティ値書き込み・読み出し要求電文作成 */
2005 mrb_define_method(mrb, _class_svctask, "esv_set_get", mrb_ecnl_esv_set_get, MRB_ARGS_REQ(3));
2006
2007 /* プロパティ値通知（応答要）電文作成 */
2008 mrb_define_method(mrb, _class_svctask, "esv_infc", mrb_ecnl_esv_infc, MRB_ARGS_REQ(3));
2009
2010 /* 要求電文の送信 */
2011 mrb_define_method(mrb, _class_svctask, "snd_esv", mrb_ecnl_snd_esv, MRB_ARGS_REQ(1));
2012
2013 /* 電文の破棄 */
2014 mrb_define_method(mrb, _class_svctask, "rel_esv", mrb_ecnl_rel_esv, MRB_ARGS_REQ(1));
2015
2016 /* インスタンスリスト通知の送信 */
2017 mrb_define_method(mrb, _class_svctask, "ntf_inl", mrb_ecnl_svctask_ntf_inl, MRB_ARGS_NONE());
2018
2019 /* メッセージ処理ループ */
2020 mrb_define_method(mrb, _class_svctask, "set_timer", mrb_ecnl_svctask_set_timer, MRB_ARGS_REQ(1));
2021 mrb_define_method(mrb, _class_svctask, "timer", mrb_ecnl_svctask_get_timer, MRB_ARGS_NONE());
2022 mrb_define_method(mrb, _class_svctask, "progress", mrb_ecnl_svctask_progress, MRB_ARGS_REQ(1));
2023 mrb_define_method(mrb, _class_svctask, "recv_msg", mrb_ecnl_svctask_recv_msg, MRB_ARGS_REQ(2));
2024 mrb_define_method(mrb, _class_svctask, "call_timeout", mrb_ecnl_svctask_call_timeout, MRB_ARGS_NONE());
2025
2026 /* リモートECHONETノードの適合確認 */
2027 mrb_define_method(mrb, _class_svctask, "is_match", mrb_ecnl_svctask_is_match, MRB_ARGS_REQ(3));
2028}
2029
2030void mrb_mruby_ecnl_gem_final(mrb_state *mrb)
2031{
2032}
Note: See TracBrowser for help on using the repository browser.