source: uKadecot/trunk/src/ukadecot/main.c@ 158

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

インクルードのパス指定をContikiに合わせ変更。
整数型の型名をContikiに合わせ変更。
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
  • Property svn:mime-type set to text/x-chdr; charset=SHIFT_JIS
File size: 33.6 KB
Line 
1/*
2 * TOPPERS ECHONET Lite Communication Middleware
3 *
4 * Copyright (C) 2014 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 * @(#) $Id: main.c 158 2016-02-20 13:43:32Z coas-nagasima $
36 */
37
38/*
39 * サンプルプログラム(1)の本体
40 */
41
42#include <kernel.h>
43#include <t_syslog.h>
44#include <sil.h>
45#include "syssvc/serial.h"
46#include "syssvc/syslog.h"
47#include "kernel_cfg.h"
48#include "main.h"
49#include "echonet_cfg.h"
50#ifdef __RX
51#include "rx630_ccrx/rx630.h"
52#else
53#include "rx630_msvc/rx630.h"
54#endif
55#include <net/ip/uip.h>
56#include <sys/pt.h>
57#include "uip_adpt.h"
58#include "wamp.h"
59// TODO:コントローラ向けヘッダーファイルを作成する
60#include "echonet_task.h"
61#include "echonet_agent.h"
62#include "echonet_lcl_task.h"
63#include "arduino.h"
64#include "data_flash.h"
65
66uint8_t mac_addr[6] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xB8};
67bool_t dhcp_enable = true;
68
69#define MAKER_CODE 0x00, 0x00, 0xB3 /* TOPPERSプロジェクト */
70
71/* ノードプロファイルオブジェクト */
72struct node_profile_object_t local_node_data = {
73 0x30, /* 動作状態 */
74 { 0x01, 0x0A, 0x01, 0x00 }, /* Ｖｅｒｓｉｏｎ情報 */
75 {
76 0xFE, /* 下位通信層IDフィールド */
77 { MAKER_CODE }, /* メーカーコード */
78 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, /* ユニークID部(メーカー独自) */
79 },
80 0x0000, /* 異常内容 */
81 { MAKER_CODE }, /* メーカーコード */
82};
83
84/* コントローラークラス */
85struct controller_t controller_class_data = {
86 0x30, /* 動作状態 */
87 0x00, /* 設置場所 */
88 { 0x00, 0x00, 'C', 0x00 }, /* 規格Ｖｅｒｓｉｏｎ情報 */
89 0x41, /* 異常発生状態 */
90 { MAKER_CODE }, /* メーカーコード */
91};
92
93/*
94 * 動作状態ON/OFF設定関数（0x30, 0x31のみ受け付け）
95 */
96int onoff_prop_set(const EPRPINIB *item, const void *src, int size, bool_t *anno)
97{
98 /* サイズが１以外は受け付けない */
99 if (size != 1)
100 return 0;
101
102 *anno = *((uint8_t*)item->exinf) != *((uint8_t*)src);
103
104 switch (*(uint8_t *)src) {
105 /* ONの場合 */
106 case 0x30:
107 *((uint8_t *)item->exinf) = *((uint8_t *)src);
108 /* LEDの"."をON */
109 sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) | 0x40);
110 break;
111 /* OFFの場合 */
112 case 0x31:
113 *((uint8_t *)item->exinf) = *((uint8_t *)src);
114 /* LEDの"."をOFF */
115 sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) & ~0x40);
116 break;
117 /* 0x30か0x31以外は受け付けない */
118 default:
119 return 0;
120 }
121
122 return 1;
123}
124
125/*
126 * 異常内容設定関数
127 */
128int node_profile_object_fault_content_set(const EPRPINIB *item, const void *src, int size, bool_t *anno)
129{
130 /* サイズが2以外は受け付けない */
131 if (size != 2)
132 return 0;
133
134 if ((*(uint16_t *)src >= 0x0) && (*(uint16_t *)src <= 0x3ec)) {
135 *((uint16_t *)item->exinf) = *((uint16_t *)src);
136 /* TODO: このの場合の処理*/
137 }
138 /* 上記以外は受け付けない */
139 else {
140 return 0;
141 }
142
143 return 2;
144}
145
146/*
147 * 異常発生状態設定関数（0x41, 0x42のみ受け付け）
148 */
149int alarm_prop_set(const EPRPINIB *item, const void *src, int size, bool_t *anno)
150{
151 /* サイズが１以外は受け付けない */
152 if (size != 1)
153 return 0;
154
155 *anno = *((uint8_t *)item->exinf) != *((uint8_t *)src);
156
157 switch (*(uint8_t *)src) {
158 /* 異常発生ありの場合 */
159 case 0x41:
160 /* 異常発生なしの場合 */
161 case 0x42:
162 *((uint8_t *)item->exinf) = *((uint8_t *)src);
163 break;
164 /* 0x41か0x42以外は受け付けない */
165 default:
166 return 0;
167 }
168
169 return 1;
170}
171
172/*
173 * 現在時刻設定関数
174 */
175int time_prop_set(const EPRPINIB *item, const void *src, int size, bool_t *anno)
176{
177 uint8_t *p_src;
178
179 if (size != 2)
180 return 0;
181
182 /* 時刻設定 */
183 p_src = (uint8_t *)src;
184 sil_wrb_mem((uint8_t *)RTC_RHRCNT_ADDR, *p_src++);
185 sil_wrb_mem((uint8_t *)RTC_RMINCNT_ADDR, *p_src++);
186 sil_wrb_mem((uint8_t *)RTC_RSECCNT_ADDR, 0x00);
187
188 return (intptr_t)p_src - (intptr_t)src;
189}
190
191/*
192 * 現在時刻取得関数
193 */
194int time_prop_get(const EPRPINIB *item, void *dst, int size)
195{
196 uint8_t *p_dst;
197
198 if (size != 2)
199 return 0;
200
201 /* 時刻設定 */
202 p_dst = (uint8_t *)dst;
203 *p_dst++ = sil_reb_mem((uint8_t *)RTC_RHRCNT_ADDR);
204 *p_dst++ = sil_reb_mem((uint8_t *)RTC_RMINCNT_ADDR);
205
206 return (intptr_t)p_dst - (intptr_t)dst;
207}
208
209/*
210 * 現在年月日設定関数
211 */
212int date_prop_set(const EPRPINIB *item, const void *src, int size, bool_t *anno)
213{
214 uint8_t *p_src;
215
216 if (size != 4)
217 return 0;
218
219 /* 年月日設定 */
220 p_src = (uint8_t *)src;
221 p_src++; /* 20XX */
222 sil_wrb_mem((uint8_t *)RTC_RYRCNT_ADDR, *p_src++);
223 sil_wrb_mem((uint8_t *)RTC_RMONCNT_ADDR, *p_src++);
224 sil_wrb_mem((uint8_t *)RTC_RDAYCNT_ADDR, *p_src++);
225
226 return (intptr_t)p_src - (intptr_t)src;
227}
228
229/*
230 * 現在年月日取得関数
231 */
232int date_prop_get(const EPRPINIB *item, void *dst, int size)
233{
234 uint8_t *p_dst;
235
236 if (size != 4)
237 return 0;
238
239 p_dst = (uint8_t *)dst;
240 *p_dst++ = 0x20;
241 *p_dst++ = sil_reb_mem((uint8_t *)RTC_RYRCNT_ADDR);
242 *p_dst++ = sil_reb_mem((uint8_t *)RTC_RMONCNT_ADDR);
243 *p_dst++ = sil_reb_mem((uint8_t *)RTC_RDAYCNT_ADDR);
244
245 return (intptr_t)p_dst - (intptr_t)dst;
246}
247
248/*
249 * uIP タスク初期化処理
250 */
251void uip_task_init(intptr_t exinf)
252{
253 httpd_init();
254}
255
256static void main_initialize();
257static TMO main_get_timer();
258static void main_progress(TMO interval);
259static void main_recv_esv(T_EDATA *esv);
260static bool_t main_wbs_msg(ECN_FBS_ID msg);
261static bool_t main_wbs_que_msg();
262static void main_int_msg(ECN_FBS_ID msg);
263static void main_break_wait(uint8_t *brkdat, int32_t len);
264static void main_timeout();
265static void main_start_service();
266static void main_get_device_list_res(ECN_FBS_ID msg);
267static void main_get_ipaddr_res(ECN_FBS_ID msg);
268static void main_get_device_info_res(ECN_FBS_ID msg);
269static void main_kadecot_set_res(T_EDATA *esv);
270static void main_kadecot_get_res(T_EDATA *esv);
271static void main_ecnl_set_res(T_EDATA *esv);
272static void main_ecnl_get_res(T_EDATA *esv);
273static void main_ecnl_setget_res(T_EDATA *esv);
274static void main_publish(T_EDATA *esv);
275
276enum main_state_t {
277 main_state_start,
278 main_state_idle,
279};
280
281TMO main_timer = TMO_FEVR;
282enum main_state_t main_state = main_state_start;
283struct pt main_pt;
284struct uip_timer main_pt_timer;
285T_ECN_FBS_QUEUE wbs_queue;
286
287/*
288 * メインタスク
289 */
290static
291PT_THREAD(main_task_pt(void))
292{
293 ER ret, ret2;
294 static SYSTIM prev, now;
295 TMO timer;
296 T_EDATA *esv;
297 uint8_t brkdat[64];
298 int32_t len;
299
300 PT_BEGIN(&main_pt);
301
302 /* 初期化 */
303 if (main_state == main_state_start)
304 main_initialize();
305
306 ret2 = get_tim(&now);
307 if (ret2 != E_OK) {
308 syslog(LOG_ERROR, "get_tim");
309 PT_EXIT(&main_pt);
310 }
311
312 for (;;) {
313 prev = now;
314
315 /* タイマー取得 */
316 timer = main_get_timer();
317 timer_set(&main_pt_timer, timer);
318
319 /* 応答電文待ち */
320 PT_WAIT_UNTIL(&main_pt, (((ret = ecn_prcv_esv(&esv)) == E_OK) || (ret == E_BRK)
321 || ((ret = timer_expired(&main_pt_timer) ? E_TMOUT : E_WBLK) == E_TMOUT)));
322 if ((ret != E_OK) && (ret != E_BRK) && (ret != E_TMOUT)) {
323 syslog(LOG_ERROR, "ecn_trcv_esv");
324 PT_EXIT(&main_pt);
325 }
326
327 ret2 = get_tim(&now);
328 if (ret2 != E_OK) {
329 syslog(LOG_ERROR, "get_tim");
330 PT_EXIT(&main_pt);
331 }
332
333 /* 時間経過 */
334 main_progress(now - prev);
335
336 /* Echonet電文受信の場合 */
337 if (ret == E_OK) {
338 /* Echonet電文受信処理 */
339 main_recv_esv(esv);
340
341 /* 領域解放 */
342 ret = ecn_rel_esv(esv);
343 if (ret != E_OK) {
344 syslog(LOG_ERROR, "ECNL ecn_rel_esv result = %d", ret);
345 PT_EXIT(&main_pt);
346 }
347 }
348 /* 応答電文待ちの割り込みの場合 */
349 else if (ret == E_BRK) {
350 ECN_FBS_ID msg = {(T_ECN_FST_BLK *)esv};
351 bool_t rel_msg = true;
352 switch (msg.ptr->hdr.type) {
353 case 0:
354 rel_msg = main_wbs_msg(msg);
355 break;
356 case 1/*ECN_MSG_INTERNAL*/:
357 main_int_msg(msg);
358 break;
359 case 3/*ECN_MSG_USER_BREAK*/:
360 /* 応答電文待ちの割り込みデータ取得 */
361 ret = ecn_get_brk_dat(esv, brkdat, sizeof(brkdat), &len);
362 if (ret != E_OK) {
363 syslog(LOG_ERROR, "ecn_get_brk_dat");
364 PT_EXIT(&main_pt);
365 }
366
367 /* 応答電文待ちの割り込み処理 */
368 main_break_wait(brkdat, len);
369 break;
370 }
371
372 /* 領域解放 */
373 if (rel_msg) {
374 ret = ecn_rel_esv(esv);
375 if (ret != E_OK) {
376 syslog(LOG_ERROR, "BRK ecn_rel_esv msg = %p, type = %d, result = %d", esv, msg.ptr->hdr.type, ret);
377 PT_EXIT(&main_pt);
378 }
379 }
380 }
381
382 /* タイムアウト処理 */
383 main_timeout();
384
385 /* キューに溜まったメッセージを処理 */
386 while (main_wbs_que_msg());
387 }
388
389 PT_END(&main_pt);
390}
391
392void main_task(intptr_t exinf)
393{
394 main_task_pt();
395}
396
397void main_task_cychdr(intptr_t exinf)
398{
399 (void)iact_tsk((ID)exinf);
400}
401
402typedef struct gpio_state {
403 bool_t state;
404 int count;
405} gpio_state_t;
406
407gpio_state_t main_gpio[2/*btn1, btn2*/ + 14/*arduino pin*/];
408
409#define MAIN_GPIO_BTN1 0
410#define MAIN_GPIO_BTN2 1
411#define MAIN_GPIO_ARDUINO_PIN0 2
412#define MAIN_GPIO_COUNT (sizeof(main_gpio) / sizeof(main_gpio[0]))
413
414typedef struct analog_state {
415 int subscriptionId;
416 int pinno;
417 bool_t state;
418 int count;
419 uint16_t threshold;
420} analog_state_t;
421
422analog_state_t main_analog[16];
423
424#define MAIN_ANALOG_COUNT (sizeof(main_analog) / sizeof(main_analog[0]))
425
426int main_gpio_pubid;
427
428enum request_info_state_t {
429 request_info_state_idle,
430 request_info_state_search_device,
431 request_info_state_get_device_list,
432 request_info_state_get_ipaddr,
433 request_info_state_get_device_info,
434 request_info_state_kadecot_set,
435 request_info_state_kadecot_get,
436 request_info_state_ecnl_set,
437 request_info_state_ecnl_get,
438 request_info_state_ecnl_setget,
439};
440
441typedef struct request_info {
442 enum request_info_state_t state;
443 TMO timer;
444 unsigned int requestId;
445 struct wamp_dealer *dealer;
446 ID eobjid;
447 uint8_t epc;
448} request_info_t;
449
450request_info_t request_infos[1];
451wamp_state_t wamp;
452
453#define MAIN_REQUEST_INFOS_COUNT (sizeof(request_infos) / sizeof(request_infos[0]))
454
455/*
456 * 初期化
457 */
458static void main_initialize()
459{
460 extern uint8_t my_ip[4];
461 extern uint8_t my_netmask[4];
462 extern uint8_t my_default_router[4];
463 uint8_t btn1, btn2;
464 uint8_t data[32], c;
465 int i, j;
466 bool_t dflt_addr = true;
467 ER ret;
468
469 /* LEDを"000"と表示 */
470 sil_wrb_mem((uint8_t *)0x0008C02A, 0x00);
471
472 ret = data_flash_init();
473 while (ret == E_OK) {
474 ret = data_flash_read(0, data);
475 if (ret != E_OK) {
476 break;
477 }
478
479 dflt_addr = false;
480 memcpy(mac_addr, data, sizeof(mac_addr));
481 dhcp_enable = data[sizeof(mac_addr)] != 0;
482 memcpy(my_ip, &data[sizeof(mac_addr) + 1], sizeof(my_ip));
483 memcpy(my_netmask, &data[sizeof(mac_addr) + 5], sizeof(my_netmask));
484 memcpy(my_default_router, &data[sizeof(mac_addr) + 9], sizeof(my_default_router));
485 break;
486 }
487
488 for (i = 0, j = 0; i < sizeof(mac_addr); i++) {
489 c = mac_addr[i] >> 4;
490 data[j++] = (c < 10) ? ('0' + c) : ('A' - 10 + c);
491 c = mac_addr[i] & 0xF;
492 data[j++] = (c < 10) ? ('0' + c) : ('A' - 10 + c);
493 data[j++] = ':';
494 }
495 data[--j] = '\0';
496
497 syslog(LOG_INFO, "mac_addr %s %s %s", data, dflt_addr ? "default" : "flash-rom", dhcp_enable ? "dhcp" : "static");
498
499 /* uIPを開始 */
500 uip_start();
501
502 wamp_init(&wamp);
503
504 /* 10ms後にボタン状態を確認 */
505 main_state = main_state_start;
506 main_timer = TMO_FEVR;
507
508 /* Arduino互換機能初期化 */
509 arduino_init();
510
511 /* ボタン状態読み込み */
512 btn1 = sil_reb_mem((uint8_t *)0x0008C04A);
513 /*btn1 = sil_reb_mem((uint8_t *)0x0008C040);*/
514 btn2 = sil_reb_mem((uint8_t *)0x0008C040);
515 main_gpio[MAIN_GPIO_BTN1].state = (btn1 & 0x80/*0x0x20*/) != 0;
516 main_gpio[MAIN_GPIO_BTN2].state = (btn2 & 0x80) != 0;
517 for (i = MAIN_GPIO_ARDUINO_PIN0; i < MAIN_GPIO_COUNT; i++) {
518 arduino_digital_value_t dval;
519 arduino_digitalRead(i - MAIN_GPIO_ARDUINO_PIN0, &dval);
520 main_gpio[i].state = dval == ARDUINO_DIGITAL_VALUE_HIGH;
521 }
522
523 for (i = 0; i < MAIN_ANALOG_COUNT; i++) {
524 main_analog[i].state = true; /* たぶんプルアップされている */
525 }
526
527 for (i = 0; i < MAIN_REQUEST_INFOS_COUNT; i++) {
528 request_infos[i].timer = TMO_FEVR;
529 }
530}
531
532/*
533 * タイマー取得
534 */
535static TMO main_get_timer()
536{
537 int i;
538 TMO timer = main_timer, temp;
539
540 for (i = 0; i < sizeof(request_infos) / sizeof(request_infos[0]); i++) {
541 temp = request_infos[i].timer;
542 if (temp != TMO_FEVR) {
543 if ((timer == TMO_FEVR) || (temp < timer)) {
544 timer = temp;
545 }
546 }
547 }
548
549 return timer;
550}
551
552/*
553 * 時間経過
554 */
555static void main_progress(TMO interval)
556{
557 int i;
558 TMO temp;
559
560 if (main_timer != TMO_FEVR) {
561 main_timer -= interval;
562 if (main_timer < 0) {
563 main_timer = 0;
564 }
565 }
566
567 for (i = 0; i < sizeof(request_infos) / sizeof(request_infos[0]); i++) {
568 temp = request_infos[i].timer;
569 if (temp != TMO_FEVR) {
570 temp -= interval;
571 if (temp < 0) {
572 temp = 0;
573 }
574 request_infos[i].timer = temp;
575 }
576 }
577}
578
579static void main_self_msg(T_EDATA *esv);
580
581/*
582 * Echonet電文受信処理
583 */
584static void main_recv_esv(T_EDATA *esv)
585{
586 request_info_t *request_info = &request_infos[0];
587
588 switch (esv->hdr.edata.esv) {
589 case ESV_SET_RES:
590 case ESV_SET_C_SNA:
591 if (request_info->eobjid != ecn_get_eobj(esv)) {
592 main_self_msg(esv);
593 break;
594 }
595
596 switch (request_info->state) {
597 case request_info_state_kadecot_set:
598 main_kadecot_set_res(esv);
599 break;
600 case request_info_state_ecnl_set:
601 main_ecnl_set_res(esv);
602 break;
603 }
604 break;
605 case ESV_GET_RES:
606 case ESV_GET_SNA:
607 if (request_info->eobjid != ecn_get_eobj(esv)) {
608 main_self_msg(esv);
609 break;
610 }
611
612 switch (request_info->state) {
613 case request_info_state_kadecot_get:
614 main_kadecot_get_res(esv);
615 break;
616 case request_info_state_ecnl_get:
617 main_ecnl_get_res(esv);
618 break;
619 }
620 break;
621 case ESV_SET_GET_RES:
622 case ESV_SET_GET_SNA:
623 if (request_info->eobjid != ecn_get_eobj(esv)) {
624 main_self_msg(esv);
625 break;
626 }
627
628 switch (request_info->state) {
629 case request_info_state_ecnl_setget:
630 main_ecnl_setget_res(esv);
631 break;
632 }
633 break;
634 case ESV_INF:
635 main_self_msg(esv);
636 main_publish(esv);
637 break;
638 default:
639 main_self_msg(esv);
640 break;
641 }
642}
643
644/*
645 * WebSocketメッセージ受信処理
646 */
647static bool_t main_wbs_msg(ECN_FBS_ID msg)
648{
649 request_info_t *request_info = &request_infos[0];
650
651 if (request_info->state != request_info_state_idle) {
652 ecn_fbs_enqueue(&wbs_queue, msg.ptr);
653 return false;
654 }
655
656 wamp_put_msg(&wamp, msg, ((ID *)msg.ptr->_gap)[0]);
657 return true;
658}
659
660static bool_t main_wbs_que_msg()
661{
662 request_info_t *request_info = &request_infos[0];
663 ECN_FBS_ID msg;
664 ER ret;
665
666 if (request_info->state != request_info_state_idle)
667 return false;
668
669 ret = ecn_fbs_dequeue(&wbs_queue, &msg.ptr);
670 if (ret == E_TMOUT)
671 return false;
672
673 wamp_put_msg(&wamp, msg, ((ID *)msg.ptr->_gap)[0]);
674
675 _ecn_fbs_del(msg);
676
677 return true;
678}
679
680/*
681 * 割り込みメッセージ受信処理
682 */
683static void main_int_msg(ECN_FBS_ID msg)
684{
685 ER ret;
686 uint8_t cmd;
687 ECN_FBS_SSIZE_T len;
688
689 ret = _ecn_fbs_get_data(msg, &cmd, 1, &len);
690 if (ret != E_OK) {
691 return;
692 }
693
694 switch (cmd) {
695 case ECN_INM_GET_DEVICE_LIST_RES:
696 main_get_device_list_res(msg);
697 break;
698 case ECN_INM_GET_DEVICE_INFO_RES:
699 main_get_device_info_res(msg);
700 break;
701 case ECN_UDP_MSG_GET_IPADDR_RES:
702 main_get_ipaddr_res(msg);
703 break;
704 }
705}
706
707/*
708 * 応答電文待ちの割り込み処理
709 */
710static void main_break_wait(uint8_t *brkdat, int32_t len)
711{
712 switch (main_state) {
713 case main_state_start:
714 main_start_service();
715 main_state = main_state_idle;
716 main_timer = 10;
717 break;
718 case main_state_idle:
719 break;
720 }
721}
722
723/*
724 * 応答電文待ちの割り込み処理
725 */
726void main_set_addr_callback()
727{
728 ER ret;
729 uint8_t data[1];
730
731 /* メインタスクに通知 */
732 data[0] = 0x01;
733 ret = ecn_brk_wai(data, sizeof(data));
734 if (ret != E_OK) {
735 syslog(LOG_ERROR, "ecn_brk_wai");
736 }
737}
738
739/*
740 * 応答電文待ちの割り込み処理
741 */
742static void main_start_service()
743{
744 char ip_addr[16], netmask[16], gateway[16];
745 ER ret;
746
747 ip2str(ip_addr, uip_hostaddr);
748 ip2str(netmask, uip_netmask);
749 ip2str(gateway, uip_draddr);
750 syslog(LOG_INFO, "ip_addr %s, netmask %s, gateway %s", ip_addr, netmask, gateway);
751
752 /* ECHONETミドルウェアを起動 */
753 ret = ecn_sta_svc();
754 if (ret != E_OK)
755 return;
756}
757
758static void main_btn_timeout();
759static void main_request_info_timeout(request_info_t *request_info);
760
761/*
762 * タイムアウト処理
763 */
764static void main_timeout()
765{
766 int i;
767 TMO temp;
768
769 if (main_timer == 0) {
770 main_btn_timeout();
771 }
772
773 for (i = 0; i < sizeof(request_infos) / sizeof(request_infos[0]); i++) {
774 temp = request_infos[i].timer;
775 if (temp != 0)
776 continue;
777
778 main_request_info_timeout(&request_infos[i]);;
779 }
780}
781
782static void main_btn1_change(bool_t push);
783static void main_btn2_change(bool_t push);
784static void main_gpio_change(int pinno, uint16_t high);
785static ER main_search_device();
786
787static void main_btn_timeout()
788{
789 gpio_state_t *gpio;
790 analog_state_t *analog;
791 arduino_digital_value_t dval;
792 int aval;
793 bool_t val;
794 int i;
795
796 if (main_timer != 0)
797 return;
798
799 switch (main_state) {
800 case main_state_idle:
801 /* 10ms後にボタン状態を確認 */
802 main_timer = 10;
803
804 arduino_tick();
805
806 for (i = 0; i < MAIN_GPIO_COUNT; i++) {
807 gpio = &main_gpio[i];
808
809 /* GPIO状態読み込み */
810 switch (i) {
811 case MAIN_GPIO_BTN1:
812 val = (sil_reb_mem((uint8_t *)0x0008C04A) & 0x80) != 0;
813 /*val = (sil_reb_mem((uint8_t *)0x0008C040) & 0x20) != 0;*/
814 break;
815 case MAIN_GPIO_BTN2:
816 val = (sil_reb_mem((uint8_t *)0x0008C040) & 0x80) != 0;
817 break;
818 default:
819 arduino_digitalRead(i - MAIN_GPIO_ARDUINO_PIN0, &dval);
820 val = dval == ARDUINO_DIGITAL_VALUE_HIGH;
821 break;
822 }
823
824 if (val && !gpio->state) {
825 gpio->count++;
826 if (gpio->count > 10) {
827 gpio->count = 0;
828 gpio->state = true;
829
830 switch (i) {
831 case MAIN_GPIO_BTN1:
832 main_btn1_change(true);
833 break;
834 case MAIN_GPIO_BTN2:
835 main_btn2_change(true);
836 break;
837 default:
838 main_gpio_change(i - MAIN_GPIO_ARDUINO_PIN0, 1);
839 break;
840 }
841 }
842 }
843 else if (!val && gpio->state) {
844 gpio->count++;
845 if (gpio->count > 10) {
846 gpio->count = 0;
847 gpio->state = false;
848
849 switch (i) {
850 case MAIN_GPIO_BTN1:
851 main_btn1_change(false);
852 break;
853 case MAIN_GPIO_BTN2:
854 main_btn2_change(false);
855 break;
856 default:
857 main_gpio_change(i - MAIN_GPIO_ARDUINO_PIN0, 0);
858 break;
859 }
860 }
861 }
862 else {
863 gpio->count = 0;
864 }
865 }
866
867 for (i = 0; i < MAIN_ANALOG_COUNT; i++) {
868 analog = &main_analog[i];
869
870 if (analog->subscriptionId == 0)
871 continue;
872
873 /* GPIO状態読み込み */
874 arduino_analogRead(analog->pinno, &aval);
875
876 if (analog->state)
877 val = aval < analog->threshold;
878 else
879 val = aval > analog->threshold;
880
881 if (val && !analog->state) {
882 analog->count++;
883 if (analog->count > 10) {
884 analog->count = 0;
885 analog->state = true;
886
887 main_gpio_change(analog->pinno, aval);
888 }
889 }
890 else if (val && analog->state) {
891 analog->count++;
892 if (analog->count > 10) {
893 analog->count = 0;
894 analog->state = false;
895
896 main_gpio_change(analog->pinno, aval);
897 }
898 }
899 else {
900 analog->count = 0;
901 }
902 }
903 break;
904 }
905}
906
907ER main_add_threshold(int subscriptionId, int pinno, uint16_t threshold)
908{
909 int i, aval;
910 analog_state_t *analog;
911
912 if ((pinno < 14) || (pinno > 19))
913 return E_PAR;
914
915 for (i = 0; i < MAIN_ANALOG_COUNT; i++) {
916 analog = &main_analog[i];
917 if (analog->subscriptionId != 0)
918 continue;
919
920 analog->subscriptionId = subscriptionId;
921 analog->pinno = pinno;
922 analog->threshold = threshold;
923
924 arduino_analogRead(analog->pinno, &aval);
925
926 analog->state = (aval < analog->threshold);
927 analog->count = 0;
928
929 return E_OK;
930 }
931
932 return E_NOMEM;
933}
934
935ER main_del_threshold(int subscriptionId)
936{
937 int i;
938 analog_state_t *analog;
939
940 for (i = 0; i < MAIN_ANALOG_COUNT; i++) {
941 analog = &main_analog[i];
942 if (analog->subscriptionId != subscriptionId)
943 continue;
944
945 analog->subscriptionId = 0;
946
947 return E_OK;
948 }
949
950 return E_OBJ;
951}
952
953static void main_self_msg(T_EDATA *esv)
954{
955 ER ret;
956 uint8_t epc;
957 uint8_t pdc;
958 uint8_t p_edt[256];
959 T_ENUM_EPC enm;
960
961 ret = ecn_itr_ini(&enm, esv);
962 if (ret != E_OK) {
963 syslog(LOG_ERROR, "ecn_itr_ini");
964 return;
965 }
966
967 for (;;) {
968 while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
969 switch (epc) {
970 case 0x80:
971 break;
972 case 0x81:
973 break;
974 }
975 }
976 if (ret != E_BOVR) {
977 syslog(LOG_ERROR, "ecn_itr_nxt");
978 break;
979 }
980 if (enm.is_eof)
981 break;
982 }
983}
984
985/*
986 * ボタン１状態変化処理
987 */
988static void main_btn1_change(bool_t push)
989{
990 /* 押されて戻った時に処理する */
991 if (push)
992 return;
993
994 /* 機器の検索 */
995 main_search_device();
996}
997
998/*
999 * ボタン２状態変化処理
1000 */
1001static void main_btn2_change(bool_t push)
1002{
1003}
1004
1005/*
1006 * GPIO状態変化処理
1007 */
1008static void main_gpio_change(int pinno, uint16_t value)
1009{
1010 main_gpio_pubid++;
1011
1012 wamp_broker_publish_pin(&wamp.broker, main_gpio_pubid, 1, pinno, value);
1013}
1014
1015/*
1016 * 機器の検索
1017 */
1018static ER main_search_device()
1019{
1020 ER ret;
1021 T_EDATA *esv;
1022
1023 /* 機器の検索 */
1024 ret = ecn_esv_inf_req(&esv, EOBJ_NULL, 0xD6);
1025 if (ret != E_OK) {
1026 syslog(LOG_ERROR, "ecn_esv_inf_req");
1027 return ret;
1028 }
1029
1030 /* 電文送信 */
1031 ret = ecn_snd_esv(esv);
1032 if (ret != E_OK) {
1033 syslog(LOG_ERROR, "ecn_snd_esv");
1034 return ret;
1035 }
1036
1037 return E_OK;
1038}
1039
1040extern int ws_out_req;
1041
1042ER main_send_message(ECN_FBS_ID msg, ID wbsid)
1043{
1044 ER ret;
1045
1046 ((ID *)msg.ptr->_gap)[0] = wbsid;
1047
1048 ret = psnd_dtq(WEBSOCKET_MBXID, (intptr_t)msg.ptr);
1049 if (ret != E_OK) {
1050 syslog(LOG_ERROR, "psnd_dtq(WEBSOCKET_MBXID) : result=%d", ret);
1051 _ecn_fbs_del(msg);
1052 return ret;
1053 }
1054
1055 ws_out_req++;
1056 act_tsk(UIP_TASK);
1057
1058 return ret;
1059}
1060
1061ER main_get_device_list(unsigned int requestId, struct wamp_dealer *dealer)
1062{
1063 request_info_t *request_info = &request_infos[0];
1064 ER ret;
1065
1066 if (request_info->requestId != 0)
1067 return E_QOVR;
1068
1069 /* 機器の検索 */
1070 ret = main_search_device();
1071 if (ret != E_OK) {
1072 return ret;
1073 }
1074
1075 request_info->state = request_info_state_search_device;
1076 request_info->timer = (TMO)5000;
1077 request_info->requestId = requestId;
1078 request_info->dealer = dealer;
1079
1080 return E_OK;
1081}
1082
1083static void main_search_device_timeout()
1084{
1085 request_info_t *request_info = &request_infos[0];
1086 ER ret;
1087 ECN_FBS_ID req;
1088
1089 for (;;) {
1090 ret = ecn_agent_get_device_list(ECHONET_API_MAILBOX, request_info->requestId, &req);
1091 if (ret != E_OK) {
1092 syslog(LOG_ERROR, "ecn_agent_get_device_list");
1093 break;
1094 }
1095
1096 ret = psnd_dtq(req.ptr->hdr.target_mbxid, (intptr_t)req.ptr);
1097 if (ret != E_OK) {
1098 syslog(LOG_ERROR, "psnd_dtq");
1099 _ecn_fbs_del(req);
1100 break;
1101 }
1102
1103 request_info->state = request_info_state_get_device_list;
1104 request_info->timer = (TMO)1000;
1105 return;
1106 }
1107
1108 wamp_dealer_get_devicelist_timeout(request_info->dealer);
1109
1110 request_info->state = request_info_state_idle;
1111 request_info->timer = TMO_FEVR;
1112 request_info->requestId = 0;
1113 request_info->dealer = NULL;
1114}
1115
1116static void main_get_device_list_res(ECN_FBS_ID msg)
1117{
1118 request_info_t *request_info = &request_infos[0];
1119 ER ret;
1120 unsigned int requestId;
1121 struct wamp_dealer *dealer;
1122 ECN_FBS_SSIZE_T len;
1123
1124 ret = _ecn_fbs_get_data(msg, &requestId, sizeof(requestId), &len);
1125 if (ret != E_OK) {
1126 syslog(LOG_ERROR, "_ecn_fbs_get_data");
1127 return;
1128 }
1129
1130 if (request_info->requestId != requestId)
1131 return;
1132
1133 dealer = request_info->dealer;
1134 request_info->state = request_info_state_idle;
1135 request_info->timer = TMO_FEVR;
1136 request_info->requestId = 0;
1137 request_info->dealer = NULL;
1138
1139 wamp_dealer_set_devicelist(dealer, msg);
1140}
1141
1142ER main_get_device_ipaddr(unsigned int requestId, struct wamp_dealer *dealer, ECN_ENOD_ID addrid)
1143{
1144 request_info_t *request_info = &request_infos[0];
1145 ER ret;
1146 ECN_FBS_ID req;
1147
1148 if (request_info->requestId != 0)
1149 return E_QOVR;
1150
1151 ret = ecn_udp_get_ipaddr(ECHONET_API_MAILBOX, requestId, addrid, &req);
1152 if (ret != E_OK) {
1153 return ret;
1154 }
1155
1156 ret = psnd_dtq(req.ptr->hdr.target_mbxid, (intptr_t)req.ptr);
1157 if (ret != E_OK) {
1158 syslog(LOG_ERROR, "psnd_dtq");
1159 _ecn_fbs_del(req);
1160 return ret;
1161 }
1162
1163 request_info->state = request_info_state_get_ipaddr;
1164 request_info->timer = (TMO)1000;
1165 request_info->requestId = requestId;
1166 request_info->dealer = dealer;
1167
1168 return E_OK;
1169}
1170
1171static void main_get_ipaddr_res(ECN_FBS_ID msg)
1172{
1173 request_info_t *request_info = &request_infos[0];
1174 ER ret;
1175 struct wamp_dealer *dealer;
1176 ECN_FBS_SSIZE_T len;
1177 ecn_udp_msg_get_ipaddr_res_t ipaddr;
1178 char str[16];
1179
1180 ret = _ecn_fbs_get_data(msg, &ipaddr, sizeof(ipaddr), &len);
1181 if (ret || (len != sizeof(ipaddr))) {
1182 syslog(LOG_ERROR, "_ecn_fbs_get_data");
1183 return;
1184 }
1185
1186 if (request_info->requestId != ipaddr.requestid)
1187 return;
1188
1189 dealer = request_info->dealer;
1190 request_info->state = request_info_state_idle;
1191 request_info->timer = TMO_FEVR;
1192 request_info->requestId = 0;
1193 request_info->dealer = NULL;
1194
1195 ipaddr2str(str, sizeof(str), ipaddr.enodadrb.ipaddr);
1196
1197 wamp_dealer_set_ipaddr(dealer, str);
1198}
1199
1200ER main_get_device_info(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid)
1201{
1202 request_info_t *request_info = &request_infos[0];
1203 ER ret;
1204 ECN_FBS_ID req;
1205
1206 if (request_info->requestId != 0)
1207 return E_QOVR;
1208
1209 ret = ecn_agent_get_device_info(ECHONET_API_MAILBOX, requestId, eobjid, &req);
1210 if (ret != E_OK) {
1211 return ret;
1212 }
1213
1214 ret = psnd_dtq(req.ptr->hdr.target_mbxid, (intptr_t)req.ptr);
1215 if (ret != E_OK) {
1216 syslog(LOG_ERROR, "psnd_dtq");
1217 _ecn_fbs_del(req);
1218 return ret;
1219 }
1220
1221 request_info->state = request_info_state_get_device_info;
1222 request_info->timer = (TMO)1000;
1223 request_info->requestId = requestId;
1224 request_info->dealer = dealer;
1225
1226 return E_OK;
1227}
1228
1229static void main_get_device_info_res(ECN_FBS_ID msg)
1230{
1231 request_info_t *request_info = &request_infos[0];
1232 ER ret;
1233 struct wamp_dealer *dealer;
1234 ecn_inm_get_device_info_res_t rmsg;
1235 ECN_FBS_SSIZE_T len;
1236
1237 ret = _ecn_fbs_get_data(msg, &rmsg, sizeof(rmsg), &len);
1238 if (ret != E_OK) {
1239 syslog(LOG_ERROR, "_ecn_fbs_get_data");
1240 return;
1241 }
1242
1243 if (request_info->requestId != rmsg.requestid)
1244 return;
1245
1246 dealer = request_info->dealer;
1247 request_info->state = request_info_state_idle;
1248 request_info->timer = TMO_FEVR;
1249 request_info->requestId = 0;
1250 request_info->dealer = NULL;
1251
1252 wamp_dealer_set_deviceinfo(dealer, rmsg.eobjid, rmsg.pmapSet, rmsg.pmapGet, rmsg.pmapAnno);
1253}
1254
1255ER main_kadecot_get(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, uint8_t epc)
1256{
1257 request_info_t *request_info = &request_infos[0];
1258 ER ret;
1259 T_EDATA *esv;
1260
1261 if (request_info->requestId != 0)
1262 return E_QOVR;
1263
1264 /* プロパティ取得電文作成 */
1265 ret = ecn_esv_get(&esv, eobjid, epc);
1266 if (ret != E_OK) {
1267 syslog(LOG_ERROR, "ecn_esv_get");
1268 return ret;
1269 }
1270
1271 /* 電文送信 */
1272 ret = ecn_snd_esv(esv);
1273 if (ret != E_OK) {
1274 syslog(LOG_ERROR, "ecn_snd_esv");
1275 return ret;
1276 }
1277
1278 request_info->state = request_info_state_kadecot_get;
1279 request_info->timer = (TMO)5000;
1280 request_info->requestId = requestId;
1281 request_info->dealer = dealer;
1282 request_info->eobjid = eobjid;
1283 request_info->epc = epc;
1284
1285 return E_OK;
1286}
1287
1288static void main_kadecot_get_res(T_EDATA *esv)
1289{
1290 request_info_t *request_info = &request_infos[0];
1291 ER ret;
1292 ID eobjid = ecn_get_eobj(esv);
1293 struct wamp_dealer *dealer = request_info->dealer;
1294 uint8_t epc;
1295 uint8_t pdc;
1296 uint8_t p_edt[256];
1297 T_ENUM_EPC enm;
1298
1299 if (request_info->eobjid != eobjid)
1300 return;
1301
1302 dealer = request_info->dealer;
1303 request_info->state = request_info_state_idle;
1304 request_info->timer = TMO_FEVR;
1305 request_info->requestId = 0;
1306 request_info->dealer = NULL;
1307
1308 ret = ecn_itr_ini(&enm, esv);
1309 if (ret != E_OK) {
1310 syslog(LOG_ERROR, "ecn_itr_ini");
1311 return;
1312 }
1313
1314 for (;;) {
1315 while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1316 if (request_info->epc == epc) {
1317 wamp_dealer_kadecot_get(dealer, eobjid, epc, pdc, p_edt);
1318 }
1319 }
1320 if (ret != E_BOVR) {
1321 syslog(LOG_ERROR, "ecn_itr_nxt");
1322 break;
1323 }
1324 if (enm.is_eof)
1325 break;
1326 }
1327}
1328
1329ER main_kadecot_set(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, uint8_t epc,
1330 uint8_t pdc, uint8_t *edt)
1331{
1332 request_info_t *request_info = &request_infos[0];
1333 ER ret;
1334 T_EDATA *esv;
1335
1336 if (request_info->requestId != 0)
1337 return E_QOVR;
1338
1339 /* プロパティ取得電文作成 */
1340 ret = ecn_esv_setc(&esv, eobjid, epc, pdc, edt);
1341 if (ret != E_OK) {
1342 syslog(LOG_ERROR, "ecn_esv_setc");
1343 return ret;
1344 }
1345
1346 /* 電文送信 */
1347 ret = ecn_snd_esv(esv);
1348 if (ret != E_OK) {
1349 syslog(LOG_ERROR, "ecn_snd_esv");
1350 return ret;
1351 }
1352
1353 request_info->state = request_info_state_kadecot_set;
1354 request_info->timer = (TMO)5000;
1355 request_info->requestId = requestId;
1356 request_info->dealer = dealer;
1357 request_info->eobjid = eobjid;
1358 request_info->epc = epc;
1359
1360 return E_OK;
1361}
1362
1363static void main_kadecot_set_res(T_EDATA *esv)
1364{
1365 request_info_t *request_info = &request_infos[0];
1366 ER ret;
1367 ID eobjid = ecn_get_eobj(esv);
1368 struct wamp_dealer *dealer = request_info->dealer;
1369 uint8_t epc;
1370 uint8_t pdc;
1371 uint8_t p_edt[256];
1372 T_ENUM_EPC enm;
1373
1374 if (dealer == NULL)
1375 return;
1376
1377 if (request_info->eobjid != eobjid)
1378 return;
1379
1380 request_info->state = request_info_state_idle;
1381 request_info->timer = TMO_FEVR;
1382 request_info->requestId = 0;
1383 request_info->dealer = NULL;
1384
1385 ret = ecn_itr_ini(&enm, esv);
1386 if (ret != E_OK) {
1387 syslog(LOG_ERROR, "ecn_itr_ini");
1388 return;
1389 }
1390
1391 for (;;) {
1392 while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1393 if (request_info->epc == epc) {
1394 wamp_dealer_kadecot_set(dealer, eobjid, epc);
1395 }
1396 }
1397 if (ret != E_BOVR) {
1398 syslog(LOG_ERROR, "ecn_itr_nxt");
1399 break;
1400 }
1401 if (enm.is_eof)
1402 break;
1403 }
1404}
1405
1406ER main_ecnl_get(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, T_EDATA *esv)
1407{
1408 request_info_t *request_info = &request_infos[0];
1409 ER ret;
1410
1411 if (request_info->requestId != 0)
1412 return E_QOVR;
1413
1414 /* 電文送信 */
1415 ret = ecn_snd_esv(esv);
1416 if (ret != E_OK) {
1417 syslog(LOG_ERROR, "ecn_snd_esv");
1418 return ret;
1419 }
1420
1421 request_info->state = request_info_state_ecnl_get;
1422 request_info->timer = (TMO)5000;
1423 request_info->requestId = requestId;
1424 request_info->dealer = dealer;
1425 request_info->eobjid = eobjid;
1426
1427 return E_OK;
1428}
1429
1430static void main_ecnl_get_res(T_EDATA *esv)
1431{
1432 request_info_t *request_info = &request_infos[0];
1433
1434 wamp_dealer_ecnl_get_res(request_info->dealer, esv);
1435
1436 request_info->state = request_info_state_idle;
1437 request_info->timer = TMO_FEVR;
1438 request_info->requestId = 0;
1439 request_info->dealer = NULL;
1440}
1441
1442ER main_ecnl_set(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, T_EDATA *esv)
1443{
1444 request_info_t *request_info = &request_infos[0];
1445 ER ret;
1446
1447 if (request_info->requestId != 0)
1448 return E_QOVR;
1449
1450 /* 電文送信 */
1451 ret = ecn_snd_esv(esv);
1452 if (ret != E_OK) {
1453 syslog(LOG_ERROR, "ecn_snd_esv");
1454 return ret;
1455 }
1456
1457 request_info->state = request_info_state_ecnl_set;
1458 request_info->timer = (TMO)5000;
1459 request_info->requestId = requestId;
1460 request_info->dealer = dealer;
1461 request_info->eobjid = eobjid;
1462
1463 return E_OK;
1464}
1465
1466static void main_ecnl_set_res(T_EDATA *esv)
1467{
1468 request_info_t *request_info = &request_infos[0];
1469
1470 wamp_dealer_ecnl_set_res(request_info->dealer, esv);
1471
1472 request_info->state = request_info_state_idle;
1473 request_info->timer = TMO_FEVR;
1474 request_info->requestId = 0;
1475 request_info->dealer = NULL;
1476}
1477
1478ER main_ecnl_setget(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, T_EDATA *esv)
1479{
1480 request_info_t *request_info = &request_infos[0];
1481 ER ret;
1482
1483 if (request_info->requestId != 0)
1484 return E_QOVR;
1485
1486 /* 電文送信 */
1487 ret = ecn_snd_esv(esv);
1488 if (ret != E_OK) {
1489 syslog(LOG_ERROR, "ecn_snd_esv");
1490 return ret;
1491 }
1492
1493 request_info->state = request_info_state_ecnl_setget;
1494 request_info->timer = (TMO)5000;
1495 request_info->requestId = requestId;
1496 request_info->dealer = dealer;
1497 request_info->eobjid = eobjid;
1498
1499 return E_OK;
1500}
1501
1502static void main_ecnl_setget_res(T_EDATA *esv)
1503{
1504 request_info_t *request_info = &request_infos[0];
1505
1506 wamp_dealer_ecnl_setget_res(request_info->dealer, esv);
1507
1508 request_info->state = request_info_state_idle;
1509 request_info->timer = TMO_FEVR;
1510 request_info->requestId = 0;
1511 request_info->dealer = NULL;
1512}
1513
1514static void main_request_info_timeout(request_info_t *request_info)
1515{
1516 struct wamp_dealer *dealer = request_info->dealer;
1517
1518 switch (request_info->state) {
1519 case request_info_state_search_device:
1520 main_search_device_timeout();
1521 return;
1522 case request_info_state_get_device_list:
1523 wamp_dealer_get_devicelist_timeout(dealer);
1524 break;
1525 case request_info_state_get_ipaddr:
1526 wamp_dealer_get_ipaddr_timeout(dealer);
1527 break;
1528 case request_info_state_get_device_info:
1529 wamp_dealer_get_deviceinfo_timeout(dealer);
1530 break;
1531 case request_info_state_kadecot_set:
1532 wamp_dealer_kadecot_set_timeout(dealer);
1533 break;
1534 case request_info_state_kadecot_get:
1535 wamp_dealer_kadecot_get_timeout(dealer);
1536 break;
1537 case request_info_state_ecnl_set:
1538 wamp_dealer_ecnl_set_timeout(dealer);
1539 break;
1540 case request_info_state_ecnl_get:
1541 wamp_dealer_ecnl_get_timeout(dealer);
1542 break;
1543 case request_info_state_ecnl_setget:
1544 wamp_dealer_ecnl_setget_timeout(dealer);
1545 break;
1546 }
1547
1548 request_info->state = request_info_state_idle;
1549 request_info->timer = TMO_FEVR;
1550 request_info->requestId = 0;
1551 request_info->dealer = NULL;
1552}
1553
1554static void main_publish(T_EDATA *esv)
1555{
1556 ID eobjid = ecn_get_eobj(esv);
1557 uint16_t devType = (esv->hdr.edata.seoj.eojx1 << 8) | esv->hdr.edata.seoj.eojx2;
1558 uint8_t epc;
1559 uint8_t pdc;
1560 uint8_t p_edt[256];
1561 T_ENUM_EPC enm;
1562 ER ret;
1563
1564 ret = ecn_itr_ini(&enm, esv);
1565 if (ret != E_OK) {
1566 syslog(LOG_ERROR, "ecn_itr_ini");
1567 return;
1568 }
1569
1570 for (;;) {
1571 while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1572 wamp_broker_publish_inf(&wamp.broker, esv->hdr.ecn_hdr.tid, eobjid,
1573 devType, epc, pdc, p_edt);
1574 }
1575 if (ret != E_BOVR) {
1576 syslog(LOG_ERROR, "ecn_itr_nxt");
1577 break;
1578 }
1579 if (enm.is_eof)
1580 break;
1581 }
1582}
Note: See TracBrowser for help on using the repository browser.