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

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