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

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

メッセージバッファ領域がなくなったときにWebSocketパケットを誤って処理してしまうのを修正。
Ethernet送信バッファが取れないときにパケットが送信できなかったのを修正。
その他、処理の安定性の向上。
  • 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: 30.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 148 2016-01-08 05:35:52Z 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 <uip.h>
56#include <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
402bool_t main_btn1_state;
403int main_btn1_count = 0;
404bool_t main_btn2_state;
405int main_btn2_count = 0;
406
407enum request_info_state_t {
408 request_info_state_idle,
409 request_info_state_search_device,
410 request_info_state_get_device_list,
411 request_info_state_get_ipaddr,
412 request_info_state_get_device_info,
413 request_info_state_kadecot_set,
414 request_info_state_kadecot_get,
415 request_info_state_ecnl_set,
416 request_info_state_ecnl_get,
417 request_info_state_ecnl_setget,
418};
419
420typedef struct request_info {
421 enum request_info_state_t state;
422 TMO timer;
423 unsigned int requestId;
424 struct wamp_dealer *dealer;
425 ID eobjid;
426 uint8_t epc;
427} request_info_t;
428
429request_info_t request_infos[1];
430wamp_state_t wamp;
431
432/*
433 * 初期化
434 */
435static void main_initialize()
436{
437 extern u8_t my_ip[4];
438 extern u8_t my_netmask[4];
439 extern u8_t my_default_router[4];
440 uint8_t btn1, btn2;
441 uint8_t data[32], c;
442 int i, j;
443 bool_t dflt_addr = true;
444 ER ret;
445
446 /* LEDを"000"と表示 */
447 sil_wrb_mem((uint8_t *)0x0008C02A, 0x00);
448
449 ret = data_flash_init();
450 while(ret == E_OK){
451 ret = data_flash_read(0, data);
452 if(ret != E_OK){
453 break;
454 }
455
456 dflt_addr = false;
457 memcpy(mac_addr, data, sizeof(mac_addr));
458 dhcp_enable = data[sizeof(mac_addr)] != 0;
459 memcpy(my_ip, &data[sizeof(mac_addr) + 1], sizeof(my_ip));
460 memcpy(my_netmask, &data[sizeof(mac_addr) + 5], sizeof(my_netmask));
461 memcpy(my_default_router, &data[sizeof(mac_addr) + 9], sizeof(my_default_router));
462 break;
463 }
464
465 for(i = 0, j = 0; i < sizeof(mac_addr); i++){
466 c = mac_addr[i] >> 4;
467 data[j++] = (c < 10) ? ('0' + c) : ('A' - 10 + c);
468 c = mac_addr[i] & 0xF;
469 data[j++] = (c < 10) ? ('0' + c) : ('A' - 10 + c);
470 data[j++] = ':';
471 }
472 data[--j] = '\0';
473
474 syslog(LOG_INFO, "mac_addr %s %s %s", data, dflt_addr ? "default" : "flash-rom", dhcp_enable ? "dhcp" : "static");
475
476 /* uIPを開始 */
477 uip_start();
478
479 wamp_init(&wamp);
480
481 /* 10ms後にボタン状態を確認 */
482 main_state = main_state_start;
483 main_timer = TMO_FEVR;
484
485 /* Arduino互換機能初期化 */
486 arduino_init();
487
488 /* ボタン状態読み込み */
489 btn1 = sil_reb_mem((uint8_t *)0x0008C04A);
490 /*btn1 = sil_reb_mem((uint8_t *)0x0008C040);*/
491 btn2 = sil_reb_mem((uint8_t *) 0x0008C040);
492 main_btn1_state = (btn1 & 0x80/*0x0x20*/) != 0;
493 main_btn2_state = (btn2 & 0x80) != 0;
494
495 for (i = 0; i< sizeof(request_infos) / sizeof(request_infos[0]); i++) {
496 request_infos[i].timer = TMO_FEVR;
497 }
498}
499
500/*
501 * タイマー取得
502 */
503static TMO main_get_timer()
504{
505 int i;
506 TMO timer = main_timer, temp;
507
508 for (i = 0; i< sizeof(request_infos) / sizeof(request_infos[0]); i++) {
509 temp = request_infos[i].timer;
510 if (temp != TMO_FEVR) {
511 if ((timer == TMO_FEVR) || (temp < timer)) {
512 timer = temp;
513 }
514 }
515 }
516
517 return timer;
518}
519
520/*
521 * 時間経過
522 */
523static void main_progress(TMO interval)
524{
525 int i;
526 TMO temp;
527
528 if (main_timer != TMO_FEVR) {
529 main_timer -= interval;
530 if(main_timer < 0){
531 main_timer = 0;
532 }
533 }
534
535 for (i = 0; i< sizeof(request_infos) / sizeof(request_infos[0]); i++) {
536 temp = request_infos[i].timer;
537 if (temp != TMO_FEVR) {
538 temp -= interval;
539 if(temp < 0){
540 temp = 0;
541 }
542 request_infos[i].timer = temp;
543 }
544 }
545}
546
547static void main_self_msg(T_EDATA *esv);
548
549/*
550 * Echonet電文受信処理
551 */
552static void main_recv_esv(T_EDATA *esv)
553{
554 request_info_t *request_info = &request_infos[0];
555
556 switch(esv->hdr.edata.esv){
557 case ESV_SET_RES:
558 case ESV_SET_C_SNA:
559 if (request_info->eobjid != ecn_get_eobj(esv)) {
560 main_self_msg(esv);
561 break;
562 }
563
564 switch(request_info->state){
565 case request_info_state_kadecot_set:
566 main_kadecot_set_res(esv);
567 break;
568 case request_info_state_ecnl_set:
569 main_ecnl_set_res(esv);
570 break;
571 }
572 break;
573 case ESV_GET_RES:
574 case ESV_GET_SNA:
575 if (request_info->eobjid != ecn_get_eobj(esv)) {
576 main_self_msg(esv);
577 break;
578 }
579
580 switch(request_info->state){
581 case request_info_state_kadecot_get:
582 main_kadecot_get_res(esv);
583 break;
584 case request_info_state_ecnl_get:
585 main_ecnl_get_res(esv);
586 break;
587 }
588 break;
589 case ESV_SET_GET_RES:
590 case ESV_SET_GET_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_ecnl_setget:
598 main_ecnl_setget_res(esv);
599 break;
600 }
601 break;
602 case ESV_INF:
603 main_self_msg(esv);
604 main_publish(esv);
605 break;
606 default:
607 main_self_msg(esv);
608 break;
609 }
610}
611
612/*
613 * WebSocketメッセージ受信処理
614 */
615static bool_t main_wbs_msg(ECN_FBS_ID msg)
616{
617 request_info_t *request_info = &request_infos[0];
618
619 if (request_info->state != request_info_state_idle) {
620 ecn_fbs_enqueue(&wbs_queue, msg.ptr);
621 return false;
622 }
623
624 wamp_put_msg(&wamp, msg, ((ID *)msg.ptr->_gap)[0]);
625 return true;
626}
627
628static bool_t main_wbs_que_msg()
629{
630 request_info_t *request_info = &request_infos[0];
631 ECN_FBS_ID msg;
632 ER ret;
633
634 if (request_info->state != request_info_state_idle)
635 return false;
636
637 ret = ecn_fbs_dequeue(&wbs_queue, &msg.ptr);
638 if (ret == E_TMOUT)
639 return false;
640
641 wamp_put_msg(&wamp, msg, ((ID *)msg.ptr->_gap)[0]);
642
643 _ecn_fbs_del(msg);
644
645 return true;
646}
647
648/*
649 * 割り込みメッセージ受信処理
650 */
651static void main_int_msg(ECN_FBS_ID msg)
652{
653 ER ret;
654 uint8_t cmd;
655 ECN_FBS_SSIZE_T len;
656
657 ret = _ecn_fbs_get_data(msg, &cmd, 1, &len);
658 if (ret != E_OK) {
659 return;
660 }
661
662 switch(cmd){
663 case ECN_INM_GET_DEVICE_LIST_RES:
664 main_get_device_list_res(msg);
665 break;
666 case ECN_INM_GET_DEVICE_INFO_RES:
667 main_get_device_info_res(msg);
668 break;
669 case ECN_UDP_MSG_GET_IPADDR_RES:
670 main_get_ipaddr_res(msg);
671 break;
672 }
673}
674
675/*
676 * 応答電文待ちの割り込み処理
677 */
678static void main_break_wait(uint8_t *brkdat, int32_t len)
679{
680 switch(main_state){
681 case main_state_start:
682 main_start_service();
683 main_state = main_state_idle;
684 main_timer = 10;
685 break;
686 case main_state_idle:
687 break;
688 }
689}
690
691/*
692 * 応答電文待ちの割り込み処理
693 */
694void main_set_addr_callback()
695{
696 ER ret;
697 uint8_t data[1];
698
699 /* メインタスクに通知 */
700 data[0] = 0x01;
701 ret = ecn_brk_wai(data, sizeof(data));
702 if(ret != E_OK){
703 syslog(LOG_ERROR, "ecn_brk_wai");
704 }
705}
706
707/*
708 * 応答電文待ちの割り込み処理
709 */
710static void main_start_service()
711{
712 char ip_addr[16], netmask[16], gateway[16];
713 ER ret;
714
715 ip2str(ip_addr, uip_hostaddr);
716 ip2str(netmask, uip_netmask);
717 ip2str(gateway, uip_draddr);
718 syslog(LOG_INFO, "ip_addr %s, netmask %s, gateway %s", ip_addr, netmask, gateway);
719
720 /* ECHONETミドルウェアを起動 */
721 ret = ecn_sta_svc();
722 if(ret != E_OK)
723 return;
724}
725
726static void main_btn_timeout();
727static void main_request_info_timeout(request_info_t *request_info);
728
729/*
730 * タイムアウト処理
731 */
732static void main_timeout()
733{
734 int i;
735 TMO temp;
736
737 if (main_timer == 0) {
738 main_btn_timeout();
739 }
740
741 for (i = 0; i< sizeof(request_infos) / sizeof(request_infos[0]); i++) {
742 temp = request_infos[i].timer;
743 if (temp != 0)
744 continue;
745
746 main_request_info_timeout(&request_infos[i]);;
747 }
748}
749
750static void main_btn1_change(bool_t push);
751static void main_btn2_change(bool_t push);
752static ER main_search_device();
753
754static void main_btn_timeout()
755{
756 uint8_t btn1, btn2;
757
758 if(main_timer != 0)
759 return;
760
761 switch(main_state){
762 case main_state_idle:
763 /* 10ms後にボタン状態を確認 */
764 main_timer = 10;
765
766 arduino_tick();
767
768 /* ボタン状態読み込み */
769 btn1 = sil_reb_mem((uint8_t *)0x0008C04A);
770 /*btn1 = sil_reb_mem((uint8_t *)0x0008C040);*/
771 btn2 = sil_reb_mem((uint8_t *) 0x0008C040);
772
773 /* ボタン１の処理 */
774 if(((btn1 & 0x80/*0x20*/) != 0) && !main_btn1_state){
775 main_btn1_count++;
776 if(main_btn1_count > 10){
777 main_btn1_count = 0;
778 main_btn1_state = true;
779
780 main_btn1_change(true);
781 }
782 }
783 else if(((btn1 & 0x80/*0x20*/) == 0) && main_btn1_state){
784 main_btn1_count++;
785 if(main_btn1_count > 10){
786 main_btn1_count = 0;
787 main_btn1_state = false;
788
789 main_btn1_change(false);
790 }
791 }
792 else{
793 main_btn1_count = 0;
794 }
795
796 /* ボタン２の処理 */
797 if(((btn2 & 0x80) != 0) && !main_btn2_state){
798 main_btn2_count++;
799 if(main_btn2_count > 10){
800 main_btn2_count = 0;
801 main_btn2_state = true;
802
803 main_btn2_change(true);
804 }
805 }
806 else if(((btn2 & 0x80) == 0) && main_btn2_state){
807 main_btn2_count++;
808 if(main_btn2_count > 10){
809 main_btn2_count = 0;
810 main_btn2_state = false;
811
812 main_btn2_change(false);
813 }
814 }
815 else{
816 main_btn2_count = 0;
817 }
818 break;
819 }
820}
821
822static void main_self_msg(T_EDATA *esv)
823{
824 ER ret;
825 uint8_t epc;
826 uint8_t pdc;
827 uint8_t p_edt[256];
828 T_ENUM_EPC enm;
829
830 ret = ecn_itr_ini(&enm, esv);
831 if(ret != E_OK){
832 syslog(LOG_ERROR, "ecn_itr_ini");
833 return;
834 }
835
836 for(;;) {
837 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
838 switch (epc) {
839 case 0x80:
840 break;
841 case 0x81:
842 break;
843 }
844 }
845 if(ret != E_BOVR){
846 syslog(LOG_ERROR, "ecn_itr_nxt");
847 break;
848 }
849 if(enm.is_eof)
850 break;
851 }
852}
853
854/*
855 * ボタン１状態変化処理
856 */
857static void main_btn1_change(bool_t push)
858{
859 /* 押されて戻った時に処理する */
860 if(push)
861 return;
862
863 /* 機器の検索 */
864 main_search_device();
865}
866
867/*
868 * ボタン２状態変化処理
869 */
870static void main_btn2_change(bool_t push)
871{
872}
873
874/*
875 * 機器の検索
876 */
877static ER main_search_device()
878{
879 ER ret;
880 T_EDATA *esv;
881
882 /* 機器の検索 */
883 ret = ecn_esv_inf_req(&esv, EOBJ_NULL, 0xD6);
884 if(ret != E_OK){
885 syslog(LOG_ERROR, "ecn_esv_inf_req");
886 return ret;
887 }
888
889 /* 電文送信 */
890 ret = ecn_snd_esv(esv);
891 if(ret != E_OK){
892 syslog(LOG_ERROR, "ecn_snd_esv");
893 return ret;
894 }
895
896 return E_OK;
897}
898
899extern int ws_out_req;
900
901ER main_send_message(ECN_FBS_ID msg, ID wbsid)
902{
903 ER ret;
904
905 ((ID *)msg.ptr->_gap)[0] = wbsid;
906
907 ret = psnd_dtq(WEBSOCKET_MBXID, (intptr_t)msg.ptr);
908 if(ret != E_OK){
909 syslog(LOG_ERROR, "psnd_dtq(WEBSOCKET_MBXID) : result=%d", ret);
910 _ecn_fbs_del(msg);
911 return ret;
912 }
913
914 ws_out_req++;
915 act_tsk(UIP_TASK);
916
917 return ret;
918}
919
920ER main_get_device_list(unsigned int requestId, struct wamp_dealer *dealer)
921{
922 request_info_t *request_info = &request_infos[0];
923 ER ret;
924
925 if(request_info->requestId != 0)
926 return E_QOVR;
927
928 /* 機器の検索 */
929 ret = main_search_device();
930 if(ret != E_OK){
931 return ret;
932 }
933
934 request_info->state = request_info_state_search_device;
935 request_info->timer = (TMO)5000;
936 request_info->requestId = requestId;
937 request_info->dealer = dealer;
938
939 return E_OK;
940}
941
942static void main_search_device_timeout()
943{
944 request_info_t *request_info = &request_infos[0];
945 ER ret;
946 ECN_FBS_ID req;
947
948 for (;;) {
949 ret = ecn_agent_get_device_list(ECHONET_API_MAILBOX, request_info->requestId, &req);
950 if(ret != E_OK){
951 syslog(LOG_ERROR, "ecn_agent_get_device_list");
952 break;
953 }
954
955 ret = psnd_dtq(req.ptr->hdr.target_mbxid, (intptr_t)req.ptr);
956 if (ret != E_OK) {
957 syslog(LOG_ERROR, "psnd_dtq");
958 _ecn_fbs_del(req);
959 break;
960 }
961
962 request_info->state = request_info_state_get_device_list;
963 request_info->timer = (TMO)1000;
964 return;
965 }
966
967 wamp_dealer_get_devicelist_timeout(request_info->dealer);
968
969 request_info->state = request_info_state_idle;
970 request_info->timer = TMO_FEVR;
971 request_info->requestId = 0;
972 request_info->dealer = NULL;
973}
974
975static void main_get_device_list_res(ECN_FBS_ID msg)
976{
977 request_info_t *request_info = &request_infos[0];
978 ER ret;
979 unsigned int requestId;
980 struct wamp_dealer *dealer;
981 ECN_FBS_SSIZE_T len;
982
983 ret = _ecn_fbs_get_data(msg, &requestId, sizeof(requestId), &len);
984 if (ret != E_OK) {
985 syslog(LOG_ERROR, "_ecn_fbs_get_data");
986 return;
987 }
988
989 if (request_info->requestId != requestId)
990 return;
991
992 dealer = request_info->dealer;
993 request_info->state = request_info_state_idle;
994 request_info->timer = TMO_FEVR;
995 request_info->requestId = 0;
996 request_info->dealer = NULL;
997
998 wamp_dealer_set_devicelist(dealer, msg);
999}
1000
1001ER main_get_device_ipaddr(unsigned int requestId, struct wamp_dealer *dealer, ECN_ENOD_ID addrid)
1002{
1003 request_info_t *request_info = &request_infos[0];
1004 ER ret;
1005 ECN_FBS_ID req;
1006
1007 if(request_info->requestId != 0)
1008 return E_QOVR;
1009
1010 ret = ecn_udp_get_ipaddr(ECHONET_API_MAILBOX, requestId, addrid, &req);
1011 if(ret != E_OK){
1012 return ret;
1013 }
1014
1015 ret = psnd_dtq(req.ptr->hdr.target_mbxid, (intptr_t)req.ptr);
1016 if (ret != E_OK) {
1017 syslog(LOG_ERROR, "psnd_dtq");
1018 _ecn_fbs_del(req);
1019 return ret;
1020 }
1021
1022 request_info->state = request_info_state_get_ipaddr;
1023 request_info->timer = (TMO)1000;
1024 request_info->requestId = requestId;
1025 request_info->dealer = dealer;
1026
1027 return E_OK;
1028}
1029
1030static void main_get_ipaddr_res(ECN_FBS_ID msg)
1031{
1032 request_info_t *request_info = &request_infos[0];
1033 ER ret;
1034 struct wamp_dealer *dealer;
1035 ECN_FBS_SSIZE_T len;
1036 ecn_udp_msg_get_ipaddr_res_t ipaddr;
1037 char str[16];
1038
1039 ret = _ecn_fbs_get_data(msg, &ipaddr, sizeof(ipaddr), &len);
1040 if (ret || (len != sizeof(ipaddr))) {
1041 syslog(LOG_ERROR, "_ecn_fbs_get_data");
1042 return;
1043 }
1044
1045 if (request_info->requestId != ipaddr.requestid)
1046 return;
1047
1048 dealer = request_info->dealer;
1049 request_info->state = request_info_state_idle;
1050 request_info->timer = TMO_FEVR;
1051 request_info->requestId = 0;
1052 request_info->dealer = NULL;
1053
1054 ipaddr2str(str, sizeof(str), ipaddr.enodadrb.ipaddr);
1055
1056 wamp_dealer_set_ipaddr(dealer, str);
1057}
1058
1059ER main_get_device_info(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid)
1060{
1061 request_info_t *request_info = &request_infos[0];
1062 ER ret;
1063 ECN_FBS_ID req;
1064
1065 if(request_info->requestId != 0)
1066 return E_QOVR;
1067
1068 ret = ecn_agent_get_device_info(ECHONET_API_MAILBOX, requestId, eobjid, &req);
1069 if(ret != E_OK){
1070 return ret;
1071 }
1072
1073 ret = psnd_dtq(req.ptr->hdr.target_mbxid, (intptr_t)req.ptr);
1074 if (ret != E_OK) {
1075 syslog(LOG_ERROR, "psnd_dtq");
1076 _ecn_fbs_del(req);
1077 return ret;
1078 }
1079
1080 request_info->state = request_info_state_get_device_info;
1081 request_info->timer = (TMO)1000;
1082 request_info->requestId = requestId;
1083 request_info->dealer = dealer;
1084
1085 return E_OK;
1086}
1087
1088static void main_get_device_info_res(ECN_FBS_ID msg)
1089{
1090 request_info_t *request_info = &request_infos[0];
1091 ER ret;
1092 struct wamp_dealer *dealer;
1093 ecn_inm_get_device_info_res_t rmsg;
1094 ECN_FBS_SSIZE_T len;
1095
1096 ret = _ecn_fbs_get_data(msg, &rmsg, sizeof(rmsg), &len);
1097 if (ret != E_OK) {
1098 syslog(LOG_ERROR, "_ecn_fbs_get_data");
1099 return;
1100 }
1101
1102 if (request_info->requestId != rmsg.requestid)
1103 return;
1104
1105 dealer = request_info->dealer;
1106 request_info->state = request_info_state_idle;
1107 request_info->timer = TMO_FEVR;
1108 request_info->requestId = 0;
1109 request_info->dealer = NULL;
1110
1111 wamp_dealer_set_deviceinfo(dealer, rmsg.eobjid, rmsg.pmapSet, rmsg.pmapGet, rmsg.pmapAnno);
1112}
1113
1114ER main_kadecot_get(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, uint8_t epc)
1115{
1116 request_info_t *request_info = &request_infos[0];
1117 ER ret;
1118 T_EDATA *esv;
1119
1120 if(request_info->requestId != 0)
1121 return E_QOVR;
1122
1123 /* プロパティ取得電文作成 */
1124 ret = ecn_esv_get(&esv, eobjid, epc);
1125 if(ret != E_OK){
1126 syslog(LOG_ERROR, "ecn_esv_get");
1127 return ret;
1128 }
1129
1130 /* 電文送信 */
1131 ret = ecn_snd_esv(esv);
1132 if(ret != E_OK){
1133 syslog(LOG_ERROR, "ecn_snd_esv");
1134 return ret;
1135 }
1136
1137 request_info->state = request_info_state_kadecot_get;
1138 request_info->timer = (TMO)5000;
1139 request_info->requestId = requestId;
1140 request_info->dealer = dealer;
1141 request_info->eobjid = eobjid;
1142 request_info->epc = epc;
1143
1144 return E_OK;
1145}
1146
1147static void main_kadecot_get_res(T_EDATA *esv)
1148{
1149 request_info_t *request_info = &request_infos[0];
1150 ER ret;
1151 ID eobjid = ecn_get_eobj(esv);
1152 struct wamp_dealer *dealer = request_info->dealer;
1153 uint8_t epc;
1154 uint8_t pdc;
1155 uint8_t p_edt[256];
1156 T_ENUM_EPC enm;
1157
1158 if(request_info->eobjid != eobjid)
1159 return;
1160
1161 dealer = request_info->dealer;
1162 request_info->state = request_info_state_idle;
1163 request_info->timer = TMO_FEVR;
1164 request_info->requestId = 0;
1165 request_info->dealer = NULL;
1166
1167 ret = ecn_itr_ini(&enm, esv);
1168 if(ret != E_OK){
1169 syslog(LOG_ERROR, "ecn_itr_ini");
1170 return;
1171 }
1172
1173 for(;;) {
1174 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1175 if (request_info->epc == epc) {
1176 wamp_dealer_kadecot_get(dealer, eobjid, epc, pdc, p_edt);
1177 }
1178 }
1179 if(ret != E_BOVR){
1180 syslog(LOG_ERROR, "ecn_itr_nxt");
1181 break;
1182 }
1183 if(enm.is_eof)
1184 break;
1185 }
1186}
1187
1188ER main_kadecot_set(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, uint8_t epc,
1189 uint8_t pdc, uint8_t *edt)
1190{
1191 request_info_t *request_info = &request_infos[0];
1192 ER ret;
1193 T_EDATA *esv;
1194
1195 if(request_info->requestId != 0)
1196 return E_QOVR;
1197
1198 /* プロパティ取得電文作成 */
1199 ret = ecn_esv_setc(&esv, eobjid, epc, pdc, edt);
1200 if(ret != E_OK){
1201 syslog(LOG_ERROR, "ecn_esv_setc");
1202 return ret;
1203 }
1204
1205 /* 電文送信 */
1206 ret = ecn_snd_esv(esv);
1207 if(ret != E_OK){
1208 syslog(LOG_ERROR, "ecn_snd_esv");
1209 return ret;
1210 }
1211
1212 request_info->state = request_info_state_kadecot_set;
1213 request_info->timer = (TMO)5000;
1214 request_info->requestId = requestId;
1215 request_info->dealer = dealer;
1216 request_info->eobjid = eobjid;
1217 request_info->epc = epc;
1218
1219 return E_OK;
1220}
1221
1222static void main_kadecot_set_res(T_EDATA *esv)
1223{
1224 request_info_t *request_info = &request_infos[0];
1225 ER ret;
1226 ID eobjid = ecn_get_eobj(esv);
1227 struct wamp_dealer *dealer = request_info->dealer;
1228 uint8_t epc;
1229 uint8_t pdc;
1230 uint8_t p_edt[256];
1231 T_ENUM_EPC enm;
1232
1233 if (dealer == NULL)
1234 return;
1235
1236 if(request_info->eobjid != eobjid)
1237 return;
1238
1239 request_info->state = request_info_state_idle;
1240 request_info->timer = TMO_FEVR;
1241 request_info->requestId = 0;
1242 request_info->dealer = NULL;
1243
1244 ret = ecn_itr_ini(&enm, esv);
1245 if(ret != E_OK){
1246 syslog(LOG_ERROR, "ecn_itr_ini");
1247 return;
1248 }
1249
1250 for(;;) {
1251 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1252 if (request_info->epc == epc) {
1253 wamp_dealer_kadecot_set(dealer, eobjid, epc);
1254 }
1255 }
1256 if(ret != E_BOVR){
1257 syslog(LOG_ERROR, "ecn_itr_nxt");
1258 break;
1259 }
1260 if(enm.is_eof)
1261 break;
1262 }
1263}
1264
1265ER main_ecnl_get(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, T_EDATA *esv)
1266{
1267 request_info_t *request_info = &request_infos[0];
1268 ER ret;
1269
1270 if(request_info->requestId != 0)
1271 return E_QOVR;
1272
1273 /* 電文送信 */
1274 ret = ecn_snd_esv(esv);
1275 if(ret != E_OK){
1276 syslog(LOG_ERROR, "ecn_snd_esv");
1277 return ret;
1278 }
1279
1280 request_info->state = request_info_state_ecnl_get;
1281 request_info->timer = (TMO)5000;
1282 request_info->requestId = requestId;
1283 request_info->dealer = dealer;
1284 request_info->eobjid = eobjid;
1285
1286 return E_OK;
1287}
1288
1289static void main_ecnl_get_res(T_EDATA *esv)
1290{
1291 request_info_t *request_info = &request_infos[0];
1292
1293 wamp_dealer_ecnl_get_res(request_info->dealer, esv);
1294
1295 request_info->state = request_info_state_idle;
1296 request_info->timer = TMO_FEVR;
1297 request_info->requestId = 0;
1298 request_info->dealer = NULL;
1299}
1300
1301ER main_ecnl_set(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, T_EDATA *esv)
1302{
1303 request_info_t *request_info = &request_infos[0];
1304 ER ret;
1305
1306 if(request_info->requestId != 0)
1307 return E_QOVR;
1308
1309 /* 電文送信 */
1310 ret = ecn_snd_esv(esv);
1311 if(ret != E_OK){
1312 syslog(LOG_ERROR, "ecn_snd_esv");
1313 return ret;
1314 }
1315
1316 request_info->state = request_info_state_ecnl_set;
1317 request_info->timer = (TMO)5000;
1318 request_info->requestId = requestId;
1319 request_info->dealer = dealer;
1320 request_info->eobjid = eobjid;
1321
1322 return E_OK;
1323}
1324
1325static void main_ecnl_set_res(T_EDATA *esv)
1326{
1327 request_info_t *request_info = &request_infos[0];
1328
1329 wamp_dealer_ecnl_set_res(request_info->dealer, esv);
1330
1331 request_info->state = request_info_state_idle;
1332 request_info->timer = TMO_FEVR;
1333 request_info->requestId = 0;
1334 request_info->dealer = NULL;
1335}
1336
1337ER main_ecnl_setget(unsigned int requestId, struct wamp_dealer *dealer, ID eobjid, T_EDATA *esv)
1338{
1339 request_info_t *request_info = &request_infos[0];
1340 ER ret;
1341
1342 if(request_info->requestId != 0)
1343 return E_QOVR;
1344
1345 /* 電文送信 */
1346 ret = ecn_snd_esv(esv);
1347 if(ret != E_OK){
1348 syslog(LOG_ERROR, "ecn_snd_esv");
1349 return ret;
1350 }
1351
1352 request_info->state = request_info_state_ecnl_setget;
1353 request_info->timer = (TMO)5000;
1354 request_info->requestId = requestId;
1355 request_info->dealer = dealer;
1356 request_info->eobjid = eobjid;
1357
1358 return E_OK;
1359}
1360
1361static void main_ecnl_setget_res(T_EDATA *esv)
1362{
1363 request_info_t *request_info = &request_infos[0];
1364
1365 wamp_dealer_ecnl_setget_res(request_info->dealer, esv);
1366
1367 request_info->state = request_info_state_idle;
1368 request_info->timer = TMO_FEVR;
1369 request_info->requestId = 0;
1370 request_info->dealer = NULL;
1371}
1372
1373static void main_request_info_timeout(request_info_t *request_info)
1374{
1375 struct wamp_dealer *dealer = request_info->dealer;
1376
1377 switch(request_info->state) {
1378 case request_info_state_search_device:
1379 main_search_device_timeout();
1380 return;
1381 case request_info_state_get_device_list:
1382 wamp_dealer_get_devicelist_timeout(dealer);
1383 break;
1384 case request_info_state_get_ipaddr:
1385 wamp_dealer_get_ipaddr_timeout(dealer);
1386 break;
1387 case request_info_state_get_device_info:
1388 wamp_dealer_get_deviceinfo_timeout(dealer);
1389 break;
1390 case request_info_state_kadecot_set:
1391 wamp_dealer_kadecot_set_timeout(dealer);
1392 break;
1393 case request_info_state_kadecot_get:
1394 wamp_dealer_kadecot_get_timeout(dealer);
1395 break;
1396 case request_info_state_ecnl_set:
1397 wamp_dealer_ecnl_set_timeout(dealer);
1398 break;
1399 case request_info_state_ecnl_get:
1400 wamp_dealer_ecnl_get_timeout(dealer);
1401 break;
1402 case request_info_state_ecnl_setget:
1403 wamp_dealer_ecnl_setget_timeout(dealer);
1404 break;
1405 }
1406
1407 request_info->state = request_info_state_idle;
1408 request_info->timer = TMO_FEVR;
1409 request_info->requestId = 0;
1410 request_info->dealer = NULL;
1411}
1412
1413static void main_publish(T_EDATA *esv)
1414{
1415 ID eobjid = ecn_get_eobj(esv);
1416 uint16_t devType = (esv->hdr.edata.seoj.eojx1 << 8) | esv->hdr.edata.seoj.eojx2;
1417 uint8_t epc;
1418 uint8_t pdc;
1419 uint8_t p_edt[256];
1420 T_ENUM_EPC enm;
1421 ER ret;
1422
1423 ret = ecn_itr_ini(&enm, esv);
1424 if(ret != E_OK){
1425 syslog(LOG_ERROR, "ecn_itr_ini");
1426 return;
1427 }
1428
1429 for(;;) {
1430 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1431 wamp_broker_publish_inf(&wamp.broker, esv->hdr.ecn_hdr.tid, eobjid,
1432 devType, epc, pdc, p_edt);
1433 }
1434 if(ret != E_BOVR){
1435 syslog(LOG_ERROR, "ecn_itr_nxt");
1436 break;
1437 }
1438 if(enm.is_eof)
1439 break;
1440 }
1441}
Note: See TracBrowser for help on using the repository browser.