misc/mbedJS/mbddJS.API/mbedJS/mbed.I2CSlave.js

   1 /**\r
   2  * @fileOverview I2CSlaveクラスを定義します。\r
   3  */\r
   4 (function(){\r
   5 var NS=mbedJS;\r
   6 var MI=MiMicJS;\r
   7 \r
   8 /**\r
   9  * I2CSlaveクラスです。\r
  10  * <a href="https://mbed.org/handbook/I2CSlave">mbed::I2CSlave</a>と同等の機能を持ちます。\r
  11  * @constructor\r
  12  * @name mbedJS.I2CSlave\r
  13  * @param {mbedJS.Mcu} i_mcu\r
  14  * インスタンスをバインドするMCUオブジェクトです。\r
  15  * @param {[PinName,PinName]} i_params\r
  16  * i2Cバスを構成するピンIDを指定します。sda,sclの順番です。\r
  17  * @param {HashMap|Generator|function} i_handler\r
  18  * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。\r
  19  * <p>\r
  20  * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。\r
  21  * <ul>\r
  22  * <li>{function()} onNew -\r
  23  * インスタンスが使用可能になった時に呼び出されます。\r
  24  * </li>\r
  25  * <li>{function()} onFrequency -\r
  26  * frequency関数が完了したときに呼び出されます。\r
  27  * </li>\r
  28  * <li>{function(ret,data)} onRead -\r
  29  * read関数が完了したときに呼び出されます。\r
  30  * <ul>\r
  31  * <li>ret {int}-は成功/失敗フラグを返します。read.1とread.2の場合で意味が異なります。\r
  32  * read.1の場合、 0:ACK(成功),1:NACK(失敗)です。read.2の場合、読みだした値です。</li>\r
  33  * <li>data {byte[]}-読みだしたデータの配列です。read.1の場合のみ有効です。</li>\r
  34  * </ul> \r
  35  * </li>\r
  36  * <li>{function(ret)} onWrite -\r
  37  * write関数が完了したときに呼び出されます。\r
  38  * <ul>\r
  39  * <li>ret {int}-成功/失敗フラグを返します。write.1とwrite.2の場合で意味が異なります。\r
  40  * write.1の場合、ACK:0(成功),NACK:それ以外です。write.2の場合、ACKを受信すると1を返します。</li>\r
  41  * </ul> \r
  42  * </li>\r
  43  * <li>{function(v)} onReceive -\r
  44  * receive関数が完了したときに呼び出されます。\r
  45  * <li>v {int}-受信ステータス値を返します。mbedJS.I2CSlave#RxStatusの値です。</li>\r
  46  * </ul> \r
  47  * </li>\r
  48  * <li>{function()} onStop -\r
  49  * stop関数が完了したときに呼び出されます。\r
  50  * </li>\r
  51  * <li>{function()} onAddress -\r
  52  * address関数が完了したときに呼び出されます。\r
  53  * </li>\r
  54  * </ul>\r
  55  * <p>\r
  56  * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。\r
  57  * </p>\r
  58  * <p>\r
  59  * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。\r
  60  * </p>\r
  61  * @return {mbedJS.I2CSlave}\r
  62  * @example //Callback\r
  63  * var mcu=new mbedJS.Mcu("192.168.128.39",\r
  64  * {\r
  65  *   onNew:function(){\r
  66  *     var i2c=new mbedJS.I2CSlave(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],{\r
  67  *     onNew:function(){\r
  68  *       i2c.frequency(100000);\r
  69  *     },\r
  70  *     onFrequency:function()\r
  71  *     {\r
  72  *       i2c.address(1);\r
  73  *     },\r
  74  *     onAddress:function()\r
  75  *     {\r
  76  *       i2c.receive();\r
  77  *     },\r
  78  *     onReceive:function(){\r
  79  *       st=0;\r
  80  *       i2c.write(1);\r
  81  *     },\r
  82  *     onWrite:function(v){\r
  83  *       if(st==0){\r
  84  *         i2c.write([1,2,3]);\r
  85  *         st++;\r
  86  *       }else{\r
  87  *         i2c.read();\r
  88  *         st=0;\r
  89  *       }\r
  90  *     },\r
  91  *     onRead:function(v){\r
  92  *       if(st==0){\r
  93  *         i2c.read(2,false);\r
  94  *         st++;\r
  95  *       }else{\r
  96  *         log("[PASS]onRead:"+v.ret+":"+v.data);\r
  97  *         i2c.stop();\r
  98  *       }\r
  99  *       },\r
 100  *     onStop:function(){\r
 101  *       mcu.close();\r
 102  *     }\r
 103  *     });\r
 104  *   },\r
 105  *   onClose:function(){\r
 106  *   },\r
 107  *   onError:function(){\r
 108  *     alert("Error");\r
 109  *   }\r
 110  * });\r
 111  * @example //Generator\r
 112  * var g=function*(){\r
 113  * try{\r
 114  *      var v;\r
 115  *      var mcu=new mbedJS.Mcu("192.168.128.39",g);\r
 116  *      yield mcu.waitForNew();\r
 117  *      var i2c=new mbedJS.I2CSlave(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],g);\r
 118  *      yield i2c.waitForNew();\r
 119  *      yield i2c.frequency(100000);\r
 120  *      yield i2c.address(1);\r
 121  *      v=yield i2c.receive();\r
 122  *      v=yield i2c.write(1);\r
 123  *      v=yield i2c.write([1,2,3]);\r
 124  *      v=yield i2c.read();\r
 125  *      v=yield i2c.read(2,false);\r
 126  *      log("[PASS]onRead:"+v.ret+":"+v.data);\r
 127  *      yield i2c.stop();\r
 128  *      yield mcu.close();\r
 129  * }catch(e){\r
 130  *      mcu.shutdown();\r
 131  *      alert(e);\r
 132  *      throw e;\r
 133  * }\r
 134  * }();\r
 135  * g.next();\r
 136  * return;\r
 137  */\r
 138 var CLASS=function I2CSlave(i_mcu,i_params,i_handler)\r
 139 {\r
 140         try{\r
 141                 var _t=this;\r
 142                 _t._mcu=i_mcu;\r
 143                 _t._lc=CLASS;\r
 144                 var cb=MI._initHandler.call(_t,i_handler);\r
 145                 MI.assertInt(i_params);\r
 146                 _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1],\r
 147                         function(j)\r
 148                         {\r
 149                                 _t._oid=j.result[0];\r
 150                                 if(cb){cb();}\r
 151                                 if(_t._gen){_t._gen.next(_t);}\r
 152                                 _t._lc=null;\r
 153                         }\r
 154                 );\r
 155         }catch(e){\r
 156                 throw new MI.MiMicException(e);\r
 157         }       \r
 158 }\r
 159 /**\r
 160  * mbedJS.Serial#receiveの戻り値の種類です。\r
 161  * NoData,ReadAddressed,WriteGeneral,WriteAddressedがあります。\r
 162  * @name mbedJS.I2CSlave#RxStatus\r
 163  */\r
 164 CLASS.RxStatus={\r
 165         NoData:0,ReadAddressed:1,WriteGeneral:2,WriteAddressed:3\r
 166 }\r
 167 CLASS.prototype={\r
 168         /** @private */\r
 169         RPC_NS:"mbedJS:I2CSlave",\r
 170         /** @private 最後にコールしたAPIです。*/\r
 171         _lc:null,\r
 172         /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/\r
 173         _gen:null,\r
 174         /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/\r
 175         _event:{},\r
 176         /** @private リモートインスタンスのオブジェクトIDです。*/\r
 177         _oid:null,\r
 178         /**\r
 179          * Generatorモードのときに使用する関数です。\r
 180          * Generatorモードの時は、yieldと併用してnew I2CSlave()の完了を待ちます。\r
 181          * @name mbedJS.I2CSlave#waitForNew\r
 182          * @function\r
 183          */\r
 184         waitForNew:function I2CSlave_waitForNew()\r
 185         {\r
 186                 try{\r
 187                         if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}\r
 188                         this._lc=CLASS.waitForNew;\r
 189                 }catch(e){\r
 190                         throw new MI.MiMicException(e);\r
 191                 }\r
 192         },\r
 193         /**\r
 194          * I2CSlaveのアドレスを設定します。\r
 195          * 関数の完了時にonAddressイベントが発生します。\r
 196          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 197          * @name mbedJS.I2CSlave#address\r
 198          * @function\r
 199          * @param {int} i_value\r
 200          * 8ビットのアドレス値です。\r
 201          * @return {int}\r
 202          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 203          */\r
 204         address:function I2CSlave_address(i_value)\r
 205         {\r
 206                 try{\r
 207                         var _t=this;\r
 208                         var cb=MI._getCb(arguments,_t._event.onAddress);\r
 209                         MI._assertYield.call(_t);\r
 210                         _t._lc=CLASS.write;\r
 211                         MI.assertInt(i_value);\r
 212                         return _t._mcu.rpc(_t.RPC_NS+":address",_t._oid+","+i_value,\r
 213                                 function(j){\r
 214                                         if(cb){cb();}\r
 215                                         if(_t._gen){_t._gen.next();}\r
 216                                          _t._lc=null;\r
 217                                 }\r
 218                         );\r
 219                 }catch(e){\r
 220                         throw new MI.MiMicException(e);\r
 221                 }                       \r
 222         },      \r
 223         /**\r
 224          * Hz単位でバスの速度を指定します。\r
 225          * 関数の完了時にonFrequencyイベントが発生します。\r
 226          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 227          * @name mbedJS.I2CSlave#frequency\r
 228          * @function\r
 229          * @param {int} i_hz\r
 230          * Hz単位のバス速度です。\r
 231          * @return　{int}\r
 232          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 233          */\r
 234         frequency:function I2CSlave_frequency(i_hz)\r
 235         {\r
 236                 try{\r
 237                         var _t=this;\r
 238                         var cb=MI._getCb(arguments,_t._event.onFrequency);\r
 239                         MI._assertYield.call(_t);\r
 240                         _t._lc=CLASS.frequency;\r
 241                         MI.assertInt(i_hz);\r
 242                         return _t._mcu.rpc(_t.RPC_NS+":frequency",_t._oid+","+i_hz,\r
 243                                 function (j)\r
 244                                 {\r
 245                                         if(cb){cb();}\r
 246                                         if(_t._gen){_t._gen.next();}\r
 247                                          _t._lc=null;\r
 248                                 }\r
 249                         );\r
 250                 }catch(e){\r
 251                         throw new MI.MiMicException(e);\r
 252                 }                       \r
 253         },\r
 254         /**\r
 255          * 引数が2個の場合\r
 256          * @name mbedJS.I2CSlave#read:1\r
 257          * @function\r
 258          * @param {int} length\r
 259          * 読み出すデータの長さです。256未満の値を指定してください。\r
 260          * @return {int}\r
 261          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 262          * @return {HashMap}\r
 263          * {ret:int,data:[byte]}\r
 264          * Generatorの場合は戻り値オブジェクトを返します。\r
 265          * <ul>\r
 266          * <li>ret {int}- 成功フラグ 0:ACK(成功),1:NACK(失敗)</li>\r
 267          * <li>data {byte[]}- 読みだしたデータ</li>\r
 268          * </ul>\r
 269          */\r
 270         /**\r
 271          * 引数が0個の場合\r
 272          * @name mbedJS.I2CSlave#read:2\r
 273          * @function\r
 274          * @return {int}\r
 275          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 276          * @return {int}\r
 277          * Generatorモードの時は読みだした値を返します。\r
 278          */\r
 279         /**\r
 280          * バスから値を読み出します。\r
 281          * 関数の完了時にonReadイベントが発生します。\r
 282          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 283          * @name mbedJS.I2CSlave#read\r
 284          * @function\r
 285          * @param ...\r
 286          * 詳細はmbedJS.I2CSlave#read:Nを参照してください。\r
 287          */     \r
 288         read:function I2CSlave_read(/*...*/)\r
 289         {\r
 290                 try{\r
 291                         var _t=this;\r
 292                         var cb=MI._getCb(arguments,_t._event.onRead);\r
 293                         MI._assertYield.call(_t);\r
 294                         _t._lc=CLASS.read;\r
 295                         function rcb(j){\r
 296                                 var v=j.result.length>1?{ret:j.result[0],data:MI.bstr2byteArray(j.result[1])}:j.result[0];\r
 297                                 if(cb){cb(v);}\r
 298                                 if(_t._gen){_t._gen.next(v);}\r
 299                                  _t._lc=null;\r
 300                         }\r
 301                         if(MI._getBaseArgsLen(arguments)==0){\r
 302                                 return _t._mcu.rpc(_t.RPC_NS+":read2",_t._oid,rcb);\r
 303                         }else{\r
 304                                 MI.assertInt(arguments[0]);\r
 305                                 return _t._mcu.rpc(_t.RPC_NS+":read1",_t._oid+","+arguments[0],rcb);\r
 306                         }\r
 307                 }catch(e){\r
 308                         throw new MI.MiMicException(e);\r
 309                 }                       \r
 310         },\r
 311         /**\r
 312          * I2CSlaveバスを開始状態にします。\r
 313          * 関数の完了時にonReceiveイベントが発生します。\r
 314          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 315          * @name mbedJS.I2CSlave#receive\r
 316          * @function\r
 317          * @return　{int}\r
 318          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 319          * @return　{int}\r
 320          * Generatorモードの時は受信ステータス値を返します。mbedJS.I2CSlave#RxStatusの値です。\r
 321          */\r
 322         receive:function I2CSlave_receive()\r
 323         {\r
 324                 try{\r
 325                         var _t=this;\r
 326                         var cb=MI._getCb(arguments,_t._event.onReceive);\r
 327                         MI._assertYield.call(_t);\r
 328                         _t._lc=CLASS.start;                     \r
 329                         return _t._mcu.rpc(_t.RPC_NS+":receive",_t._oid,\r
 330                                 function (j)\r
 331                                 {\r
 332                                         var v=j.result[0];\r
 333                                         if(cb){cb(v);}\r
 334                                         if(_t._gen){_t._gen.next(v);}\r
 335                                          _t._lc=null;\r
 336                                 }\r
 337                         );\r
 338                 }catch(e){\r
 339                         throw new MI.MiMicException(e);\r
 340                 }                       \r
 341         },\r
 342         /**\r
 343          * 引数が1個(byte array)の場合\r
 344          * @name mbedJS.I2CSlave#write:1\r
 345          * @function\r
 346          * @param {byte[]} data\r
 347          * 送信するデータを格納したバイト配列です。\r
 348          * @return {int}\r
 349          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 350          * @return {int}\r
 351          * Generatorモードの時は成功/失敗フラグを返します。ACK:0(成功),NACK:それ以外です。\r
 352          */\r
 353         /**\r
 354          * 引数が1個(int)の場合\r
 355          * @name mbedJS.I2CSlave#write:2\r
 356          * @function\r
 357          * @param {int} data\r
 358          * 送信データを指定します。\r
 359          * @return {int}\r
 360          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 361          * @return {int}\r
 362          * Generatorモードの時は成功/失敗フラグを返します。ACKを受信すると1を返します。\r
 363          */     \r
 364         /**\r
 365          * バスに値を書き込みます。\r
 366          * 関数の完了時にonWriteイベントが発生します。\r
 367          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 368          * @name mbedJS.I2CSlave#write\r
 369          * @function\r
 370          * @param ...\r
 371          * 詳細はmbedJS.I2CSlave#write:Nを参照してください。\r
 372          */     \r
 373         write:function I2CSlave_write(/*...*/)\r
 374         {\r
 375                 try{\r
 376                         var _t=this;\r
 377                         var cb=MI._getCb(arguments,_t._event.onWrite);\r
 378                         MI._assertYield.call(_t);\r
 379                         _t._lc=CLASS.write;\r
 380                         function rcb(j){\r
 381                                 var v=j.result[0];\r
 382                                 if(cb){cb(v);}\r
 383                                 if(_t._gen){_t._gen.next(v);}\r
 384                                  _t._lc=null;\r
 385                         }\r
 386                         if(!MI.isArray(arguments[0])){\r
 387                                 MI.assertInt(arguments[0]);\r
 388                                 return _t._mcu.rpc(_t.RPC_NS+":write2",_t._oid+","+arguments[0],rcb);\r
 389                         }else{\r
 390                                 var a=arguments;\r
 391                                 return _t._mcu.rpc(_t.RPC_NS+":write1",_t._oid+",\""+MI.byteArray2bstr(a[0])+"\"",rcb);\r
 392                         }\r
 393                 }catch(e){\r
 394                         throw new MI.MiMicException(e);\r
 395                 }                       \r
 396         },\r
 397         /**\r
 398          * I2CSlaveを受信状態に戻します。\r
 399          * 関数の完了時にonStopイベントが発生します。\r
 400          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 401          * @name mbedJS.I2CSlave#stop\r
 402          * @function\r
 403          * @return　{int}\r
 404          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 405          */\r
 406         stop:function I2CSlave_stop()\r
 407         {\r
 408                 try{\r
 409                         var _t=this;\r
 410                         var cb=MI._getCb(arguments,_t._event.onStop);\r
 411                         MI._assertYield.call(_t);\r
 412                         _t._lc=CLASS.stop;                      \r
 413                         return _t._mcu.rpc(_t.RPC_NS+":stop",_t._oid,\r
 414                                 function (j)\r
 415                                 {\r
 416                                         if(cb){cb();}\r
 417                                         if(_t._gen){_t._gen.next();}\r
 418                                          _t._lc=null;\r
 419                                 }\r
 420                         );\r
 421                 }catch(e){\r
 422                         throw new MI.MiMicException(e);\r
 423                 }                       \r
 424         },\r
 425         /**\r
 426          * MCUに生成されているオブジェクトを破棄します。\r
 427          * @name mbedJS.I2CSlave#dispose\r
 428          * @function\r
 429          */\r
 430         dispose:function IC2Slave_dispose()\r
 431         {\r
 432                 return this._mcu._dispose.apply(this,arguments);\r
 433         }\r
 434         \r
 435 }\r
 436 NS.I2CSlave=CLASS;\r
 437 }());