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