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