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

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

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