Ignore:
Timestamp:
Jan 14, 2016, 1:17:21 PM (7 years ago)
Author:
coas-nagasima
Message:

・デジタルPinとアナログPinのWAMPトピックを追加し、PubSubできるように機能追加。

デジタルPINのトピックは、

「com.sonycsl.kadecot.arduino.topic.pinXX」（XXは0から13）

アナログPINのトピックは、

「com.sonycsl.kadecot.arduino.topic.pinXX.thrYYY」（XXは14から19、YYYは閾値十進）

・デバッグ用の使用していない文字列が、ROM領域に残ってしまうのを修正
・WebSocket接続時のHTTPヘッダーを１行ずつNAK応答を待って送信しているのを、一括で送るよう変更

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uKadecot/trunk/src/ukadecot/main.c

    r148 r152  
    11/*
    22 *  TOPPERS ECHONET Lite Communication Middleware
    3  * 
     3 *
    44 *  Copyright (C) 2014 Cores Co., Ltd. Japan
    5  * 
     5 *
    66 *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
    77 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
    … …  
    2626 *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
    2727 *      免責すること．
    28  * 
     28 *
    2929 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
    3030 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
    … …  
    3232 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
    3333 *  の責任を負わない．
    34  * 
     34 *
    3535 *  @(#) $Id$
    3636 */
    3737
    38 /* 
     38/*
    3939 *  サンプルプログラム(1)の本体
    4040 */
    … …  
    6464#include "data_flash.h"
    6565
    66 uint8_t mac_addr[6] = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xB8 };
     66uint8_t mac_addr[6] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xB8};
    6767bool_t dhcp_enable = true;
    6868
    … …  
    9797{
    9898        /* サイズが１以外は受け付けない */
    99         if(size != 1)
     99        if (size != 1)
    100100                return 0;
    101101
    102102        *anno = *((uint8_t*)item->exinf) != *((uint8_t*)src);
    103103
    104         switch(*(uint8_t *)src){
     104        switch (*(uint8_t *)src) {
    105105        /* ONの場合 */
    106106        case 0x30:
    … …  
    129129{
    130130        /* サイズが2以外は受け付けない */
    131         if(size != 2)
     131        if (size != 2)
    132132                return 0;
    133133
    134         if((*(uint16_t *)src >= 0x0) && (*(uint16_t *)src <= 0x3ec)){
     134        if ((*(uint16_t *)src >= 0x0) && (*(uint16_t *)src <= 0x3ec)) {
    135135                *((uint16_t *)item->exinf) = *((uint16_t *)src);
    136136                /* TODO: このの場合の処理*/
    137137        }
    138138        /* 上記以外は受け付けない */
    139         else{
     139        else {
    140140                return 0;
    141141        }
    … …  
    150150{
    151151        /* サイズが１以外は受け付けない */
    152         if(size != 1)
     152        if (size != 1)
    153153                return 0;
    154154
    155155        *anno = *((uint8_t *)item->exinf) != *((uint8_t *)src);
    156156
    157         switch(*(uint8_t *)src){
     157        switch (*(uint8_t *)src) {
    158158        /* 異常発生ありの場合 */
    159159        case 0x41:
    … …  
    177177        uint8_t *p_src;
    178178
    179         if(size != 2)
     179        if (size != 2)
    180180                return 0;
    181181
    … …  
    196196        uint8_t *p_dst;
    197197
    198         if(size != 2)
     198        if (size != 2)
    199199                return 0;
    200200
    … …  
    214214        uint8_t *p_src;
    215215
    216         if(size != 4)
     216        if (size != 4)
    217217                return 0;
    218218
    … …  
    234234        uint8_t *p_dst;
    235235
    236         if(size != 4)
     236        if (size != 4)
    237237                return 0;
    238238
    … …  
    305305
    306306        ret2 = get_tim(&now);
    307         if (ret2 != E_OK){
     307        if (ret2 != E_OK) {
    308308                syslog(LOG_ERROR, "get_tim");
    309309                PT_EXIT(&main_pt);
    310310        }
    311311
    312         for(;;){
     312        for (;;) {
    313313                prev = now;
    314314
    … …  
    320320                PT_WAIT_UNTIL(&main_pt, (((ret = ecn_prcv_esv(&esv)) == E_OK) || (ret == E_BRK)
    321321                        || ((ret = timer_expired(&main_pt_timer) ? E_TMOUT : E_WBLK) == E_TMOUT)));
    322                 if ((ret != E_OK) && (ret != E_BRK) && (ret != E_TMOUT)){
     322                if ((ret != E_OK) && (ret != E_BRK) && (ret != E_TMOUT)) {
    323323                        syslog(LOG_ERROR, "ecn_trcv_esv");
    324324                        PT_EXIT(&main_pt);
    … …  
    326326
    327327                ret2 = get_tim(&now);
    328                 if (ret2 != E_OK){
     328                if (ret2 != E_OK) {
    329329                        syslog(LOG_ERROR, "get_tim");
    330330                        PT_EXIT(&main_pt);
    … …  
    341341                        /* 領域解放 */
    342342                        ret = ecn_rel_esv(esv);
    343                         if (ret != E_OK){
     343                        if (ret != E_OK) {
    344344                                syslog(LOG_ERROR, "ECNL ecn_rel_esv result = %d", ret);
    345345                                PT_EXIT(&main_pt);
    … …  
    348348                /* 応答電文待ちの割り込みの場合 */
    349349                else if (ret == E_BRK) {
    350                         ECN_FBS_ID msg = { (T_ECN_FST_BLK *)esv };
     350                        ECN_FBS_ID msg = {(T_ECN_FST_BLK *)esv};
    351351                        bool_t rel_msg = true;
    352352                        switch (msg.ptr->hdr.type) {
    353                         case 0: 
     353                        case 0:
    354354                                rel_msg = main_wbs_msg(msg);
    355355                                break;
    … …  
    360360                                /* 応答電文待ちの割り込みデータ取得 */
    361361                                ret = ecn_get_brk_dat(esv, brkdat, sizeof(brkdat), &len);
    362                                 if (ret != E_OK){
     362                                if (ret != E_OK) {
    363363                                        syslog(LOG_ERROR, "ecn_get_brk_dat");
    364364                                        PT_EXIT(&main_pt);
    … …  
    373373                        if (rel_msg) {
    374374                                ret = ecn_rel_esv(esv);
    375                                 if (ret != E_OK){
     375                                if (ret != E_OK) {
    376376                                        syslog(LOG_ERROR, "BRK ecn_rel_esv msg = %p, type = %d, result = %d", esv, msg.ptr->hdr.type, ret);
    377377                                        PT_EXIT(&main_pt);
    … …  
    384384
    385385                /* キューに溜まったメッセージを処理 */
    386                 while(main_wbs_que_msg());
     386                while (main_wbs_que_msg());
    387387        }
    388388
    … …  
    400400}
    401401
    402 bool_t main_btn1_state;
    403 int main_btn1_count = 0;
    404 bool_t main_btn2_state;
    405 int main_btn2_count = 0;
     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;
    406427
    407428enum request_info_state_t {
    … …  
    430451wamp_state_t wamp;
    431452
     453#define MAIN_REQUEST_INFOS_COUNT (sizeof(request_infos) / sizeof(request_infos[0]))
     454
    432455/*
    433456 * 初期化
    … …  
    448471
    449472        ret = data_flash_init();
    450         while(ret == E_OK){
     473        while (ret == E_OK) {
    451474                ret = data_flash_read(0, data);
    452                 if(ret != E_OK){
     475                if (ret != E_OK) {
    453476                        break;
    454477                }
    … …  
    463486        }
    464487
    465         for(i = 0, j = 0; i < sizeof(mac_addr); i++){
     488        for (i = 0, j = 0; i < sizeof(mac_addr); i++) {
    466489                c = mac_addr[i] >> 4;
    467490                data[j++] = (c < 10) ? ('0' + c) : ('A' - 10 + c);
    … …  
    489512        btn1 = sil_reb_mem((uint8_t *)0x0008C04A);
    490513        /*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++) {
     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++) {
    496528                request_infos[i].timer = TMO_FEVR;
    497529        }
    … …  
    506538        TMO timer = main_timer, temp;
    507539
    508         for (i = 0; i< sizeof(request_infos) / sizeof(request_infos[0]); i++) {
     540        for (i = 0; i < sizeof(request_infos) / sizeof(request_infos[0]); i++) {
    509541                temp = request_infos[i].timer;
    510542                if (temp != TMO_FEVR) {
    … …  
    528560        if (main_timer != TMO_FEVR) {
    529561                main_timer -= interval;
    530                 if(main_timer < 0){
     562                if (main_timer < 0) {
    531563                        main_timer = 0;
    532564                }
    533565        }
    534566
    535         for (i = 0; i< sizeof(request_infos) / sizeof(request_infos[0]); i++) {
     567        for (i = 0; i < sizeof(request_infos) / sizeof(request_infos[0]); i++) {
    536568                temp = request_infos[i].timer;
    537569                if (temp != TMO_FEVR) {
    538570                        temp -= interval;
    539                         if(temp < 0){
     571                        if (temp < 0) {
    540572                                temp = 0;
    541573                        }
    … …  
    554586        request_info_t *request_info = &request_infos[0];
    555587
    556         switch(esv->hdr.edata.esv){
     588        switch (esv->hdr.edata.esv) {
    557589        case ESV_SET_RES:
    558590        case ESV_SET_C_SNA:
    … …  
    562594                }
    563595
    564                 switch(request_info->state){
     596                switch (request_info->state) {
    565597                case request_info_state_kadecot_set:
    566598                        main_kadecot_set_res(esv);
    … …  
    578610                }
    579611
    580                 switch(request_info->state){
     612                switch (request_info->state) {
    581613                case request_info_state_kadecot_get:
    582614                        main_kadecot_get_res(esv);
    … …  
    594626                }
    595627
    596                 switch(request_info->state){
     628                switch (request_info->state) {
    597629                case request_info_state_ecnl_setget:
    598630                        main_ecnl_setget_res(esv);
    … …  
    621653                return false;
    622654        }
    623        
     655
    624656        wamp_put_msg(&wamp, msg, ((ID *)msg.ptr->_gap)[0]);
    625657        return true;
    … …  
    660692        }
    661693
    662         switch(cmd){
     694        switch (cmd) {
    663695        case ECN_INM_GET_DEVICE_LIST_RES:
    664696                main_get_device_list_res(msg);
    … …  
    678710static void main_break_wait(uint8_t *brkdat, int32_t len)
    679711{
    680         switch(main_state){
     712        switch (main_state) {
    681713        case main_state_start:
    682714                main_start_service();
    … …  
    700732        data[0] = 0x01;
    701733        ret = ecn_brk_wai(data, sizeof(data));
    702         if(ret != E_OK){
     734        if (ret != E_OK) {
    703735                syslog(LOG_ERROR, "ecn_brk_wai");
    704736        }
    … …  
    720752        /* ECHONETミドルウェアを起動 */
    721753        ret = ecn_sta_svc();
    722         if(ret != E_OK)
     754        if (ret != E_OK)
    723755                return;
    724756}
    … …  
    739771        }
    740772
    741         for (i = 0; i< sizeof(request_infos) / sizeof(request_infos[0]); i++) {
     773        for (i = 0; i < sizeof(request_infos) / sizeof(request_infos[0]); i++) {
    742774                temp = request_infos[i].timer;
    743775                if (temp != 0)
    … …  
    750782static void main_btn1_change(bool_t push);
    751783static void main_btn2_change(bool_t push);
     784static void main_gpio_change(int pinno, uint16_t high);
    752785static ER main_search_device();
    753786
    754787static void main_btn_timeout()
    755788{
    756         uint8_t btn1, btn2;
    757 
    758         if(main_timer != 0)
    759                 return;
    760 
    761         switch(main_state){
     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) {
    762800        case main_state_idle:
    763801                /* 10ms後にボタン状態を確認 */
    … …  
    766804                arduino_tick();
    767805
    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);
     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;
    781822                        }
    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);
     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                                }
    790842                        }
    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);
     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                                }
    804861                        }
    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);
     862                        else {
     863                                gpio->count = 0;
    813864                        }
    814865                }
    815                 else{
    816                         main_btn2_count = 0;
    817                 }
    818                 break;
    819         }
     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;
    820951}
    821952
    … …  
    829960
    830961        ret = ecn_itr_ini(&enm, esv);
    831         if(ret != E_OK){
     962        if (ret != E_OK) {
    832963                syslog(LOG_ERROR, "ecn_itr_ini");
    833964                return;
    834965        }
    835966
    836         for(;;) {
    837                 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
     967        for (;;) {
     968                while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
    838969                        switch (epc) {
    839970                        case 0x80:
    … …  
    843974                        }
    844975                }
    845                 if(ret != E_BOVR){
     976                if (ret != E_BOVR) {
    846977                        syslog(LOG_ERROR, "ecn_itr_nxt");
    847978                        break;
    848979                }
    849                 if(enm.is_eof)
     980                if (enm.is_eof)
    850981                        break;
    851982        }
    … …  
    858989{
    859990        /* 押されて戻った時に処理する */
    860         if(push)
     991        if (push)
    861992                return;
    862993
    … …  
    8731004
    8741005/*
     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/*
    8751016 * 機器の検索
    8761017 */
    … …  
    8821023        /* 機器の検索 */
    8831024        ret = ecn_esv_inf_req(&esv, EOBJ_NULL, 0xD6);
    884         if(ret != E_OK){
     1025        if (ret != E_OK) {
    8851026                syslog(LOG_ERROR, "ecn_esv_inf_req");
    8861027                return ret;
    … …  
    8891030        /* 電文送信 */
    8901031        ret = ecn_snd_esv(esv);
    891         if(ret != E_OK){
     1032        if (ret != E_OK) {
    8921033                syslog(LOG_ERROR, "ecn_snd_esv");
    8931034                return ret;
    … …  
    9061047
    9071048        ret = psnd_dtq(WEBSOCKET_MBXID, (intptr_t)msg.ptr);
    908         if(ret != E_OK){
     1049        if (ret != E_OK) {
    9091050                syslog(LOG_ERROR, "psnd_dtq(WEBSOCKET_MBXID) : result=%d", ret);
    9101051                _ecn_fbs_del(msg);
    … …  
    9231064        ER ret;
    9241065
    925         if(request_info->requestId != 0)
     1066        if (request_info->requestId != 0)
    9261067                return E_QOVR;
    9271068
    9281069        /* 機器の検索 */
    9291070        ret = main_search_device();
    930         if(ret != E_OK){
     1071        if (ret != E_OK) {
    9311072                return ret;
    9321073        }
    … …  
    9481089        for (;;) {
    9491090                ret = ecn_agent_get_device_list(ECHONET_API_MAILBOX, request_info->requestId, &req);
    950                 if(ret != E_OK){
     1091                if (ret != E_OK) {
    9511092                        syslog(LOG_ERROR, "ecn_agent_get_device_list");
    9521093                        break;
    … …  
    10051146        ECN_FBS_ID req;
    10061147
    1007         if(request_info->requestId != 0)
     1148        if (request_info->requestId != 0)
    10081149                return E_QOVR;
    10091150
    10101151        ret = ecn_udp_get_ipaddr(ECHONET_API_MAILBOX, requestId, addrid, &req);
    1011         if(ret != E_OK){
     1152        if (ret != E_OK) {
    10121153                return ret;
    10131154        }
    … …  
    10631204        ECN_FBS_ID req;
    10641205
    1065         if(request_info->requestId != 0)
     1206        if (request_info->requestId != 0)
    10661207                return E_QOVR;
    10671208
    10681209        ret = ecn_agent_get_device_info(ECHONET_API_MAILBOX, requestId, eobjid, &req);
    1069         if(ret != E_OK){
     1210        if (ret != E_OK) {
    10701211                return ret;
    10711212        }
    … …  
    11181259        T_EDATA *esv;
    11191260
    1120         if(request_info->requestId != 0)
     1261        if (request_info->requestId != 0)
    11211262                return E_QOVR;
    11221263
    11231264        /* プロパティ取得電文作成 */
    11241265        ret = ecn_esv_get(&esv, eobjid, epc);
    1125         if(ret != E_OK){
     1266        if (ret != E_OK) {
    11261267                syslog(LOG_ERROR, "ecn_esv_get");
    11271268                return ret;
    … …  
    11301271        /* 電文送信 */
    11311272        ret = ecn_snd_esv(esv);
    1132         if(ret != E_OK){
     1273        if (ret != E_OK) {
    11331274                syslog(LOG_ERROR, "ecn_snd_esv");
    11341275                return ret;
    … …  
    11561297        T_ENUM_EPC enm;
    11571298
    1158         if(request_info->eobjid != eobjid)
     1299        if (request_info->eobjid != eobjid)
    11591300                return;
    11601301
    … …  
    11661307
    11671308        ret = ecn_itr_ini(&enm, esv);
    1168         if(ret != E_OK){
     1309        if (ret != E_OK) {
    11691310                syslog(LOG_ERROR, "ecn_itr_ini");
    11701311                return;
    11711312        }
    11721313
    1173         for(;;) {
    1174                 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
     1314        for (;;) {
     1315                while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
    11751316                        if (request_info->epc == epc) {
    11761317                                wamp_dealer_kadecot_get(dealer, eobjid, epc, pdc, p_edt);
    11771318                        }
    11781319                }
    1179                 if(ret != E_BOVR){
     1320                if (ret != E_BOVR) {
    11801321                        syslog(LOG_ERROR, "ecn_itr_nxt");
    11811322                        break;
    11821323                }
    1183                 if(enm.is_eof)
     1324                if (enm.is_eof)
    11841325                        break;
    11851326        }
    … …  
    11931334        T_EDATA *esv;
    11941335
    1195         if(request_info->requestId != 0)
     1336        if (request_info->requestId != 0)
    11961337                return E_QOVR;
    11971338
    11981339        /* プロパティ取得電文作成 */
    11991340        ret = ecn_esv_setc(&esv, eobjid, epc, pdc, edt);
    1200         if(ret != E_OK){
     1341        if (ret != E_OK) {
    12011342                syslog(LOG_ERROR, "ecn_esv_setc");
    12021343                return ret;
    … …  
    12051346        /* 電文送信 */
    12061347        ret = ecn_snd_esv(esv);
    1207         if(ret != E_OK){
     1348        if (ret != E_OK) {
    12081349                syslog(LOG_ERROR, "ecn_snd_esv");
    12091350                return ret;
    … …  
    12341375                return;
    12351376
    1236         if(request_info->eobjid != eobjid)
     1377        if (request_info->eobjid != eobjid)
    12371378                return;
    12381379
    … …  
    12431384
    12441385        ret = ecn_itr_ini(&enm, esv);
    1245         if(ret != E_OK){
     1386        if (ret != E_OK) {
    12461387                syslog(LOG_ERROR, "ecn_itr_ini");
    12471388                return;
    12481389        }
    12491390
    1250         for(;;) {
    1251                 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
     1391        for (;;) {
     1392                while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
    12521393                        if (request_info->epc == epc) {
    12531394                                wamp_dealer_kadecot_set(dealer, eobjid, epc);
    12541395                        }
    12551396                }
    1256                 if(ret != E_BOVR){
     1397                if (ret != E_BOVR) {
    12571398                        syslog(LOG_ERROR, "ecn_itr_nxt");
    12581399                        break;
    12591400                }
    1260                 if(enm.is_eof)
     1401                if (enm.is_eof)
    12611402                        break;
    12621403        }
    … …  
    12681409        ER ret;
    12691410
    1270         if(request_info->requestId != 0)
     1411        if (request_info->requestId != 0)
    12711412                return E_QOVR;
    12721413
    12731414        /* 電文送信 */
    12741415        ret = ecn_snd_esv(esv);
    1275         if(ret != E_OK){
     1416        if (ret != E_OK) {
    12761417                syslog(LOG_ERROR, "ecn_snd_esv");
    12771418                return ret;
    … …  
    13041445        ER ret;
    13051446
    1306         if(request_info->requestId != 0)
     1447        if (request_info->requestId != 0)
    13071448                return E_QOVR;
    13081449
    13091450        /* 電文送信 */
    13101451        ret = ecn_snd_esv(esv);
    1311         if(ret != E_OK){
     1452        if (ret != E_OK) {
    13121453                syslog(LOG_ERROR, "ecn_snd_esv");
    13131454                return ret;
    … …  
    13401481        ER ret;
    13411482
    1342         if(request_info->requestId != 0)
     1483        if (request_info->requestId != 0)
    13431484                return E_QOVR;
    13441485
    13451486        /* 電文送信 */
    13461487        ret = ecn_snd_esv(esv);
    1347         if(ret != E_OK){
     1488        if (ret != E_OK) {
    13481489                syslog(LOG_ERROR, "ecn_snd_esv");
    13491490                return ret;
    … …  
    13751516        struct wamp_dealer *dealer = request_info->dealer;
    13761517
    1377         switch(request_info->state) {
     1518        switch (request_info->state) {
    13781519        case request_info_state_search_device:
    13791520                main_search_device_timeout();
    … …  
    14221563
    14231564        ret = ecn_itr_ini(&enm, esv);
    1424         if(ret != E_OK){
     1565        if (ret != E_OK) {
    14251566                syslog(LOG_ERROR, "ecn_itr_ini");
    14261567                return;
    14271568        }
    14281569
    1429         for(;;) {
    1430                 while((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
     1570        for (;;) {
     1571                while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
    14311572                        wamp_broker_publish_inf(&wamp.broker, esv->hdr.ecn_hdr.tid, eobjid,
    14321573                                devType, epc, pdc, p_edt);
    14331574                }
    1434                 if(ret != E_BOVR){
     1575                if (ret != E_BOVR) {
    14351576                        syslog(LOG_ERROR, "ecn_itr_nxt");
    14361577                        break;
    14371578                }
    1438                 if(enm.is_eof)
    1439                         break;
    1440         }
    1441 }
     1579                if (enm.is_eof)
     1580                        break;
     1581        }
     1582}
Note: See TracChangeset for help on using the changeset viewer.