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

   1 /**\r
   2  * @fileOverview SPISlaveクラスを定義します。\r
   3  */\r
   4 (function(){\r
   5 var NS=mbedJS;\r
   6 var MI=MiMicJS;\r
   7 \r
   8 /**\r
   9  * SPISlaveクラスです。\r
  10  * <a href="https://mbed.org/handbook/SPISlave">mbed::SPISlave</a>と同等の機能を持ちます。\r
  11  * @name mbedJS.SPISlave\r
  12  * @constructor\r
  13  * @param {mbedJS.Mcu} i_mcu\r
  14  * インスタンスをバインドするMCUオブジェクトです。\r
  15  * @param {[PinName,PinName,PinName]} i_params\r
  16  * SPIを構成する4つのPinNameを格納する配列です。\r
  17  * mosi, miso, sclkの順番で設定します。\r
  18  * @param {HashMap|Generator|function} i_handler\r
  19  * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。\r
  20  * <p>\r
  21  * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。\r
  22  * <ul>\r
  23  * <li>{function()} onNew -\r
  24  * インスタンスが使用可能になった時に呼び出されます。\r
  25  * </li>\r
  26  * <li>{function(v)} onFrequency  -\r
  27  * frequency関数のコールバック関数です。\r
  28  * </li>\r
  29  * <li>{function(v)} onFormat  -\r
  30  * format関数のコールバック関数です。\r
  31  * </li>\r
  32  * <li>{function(v)} onReceive  -\r
  33  * receive関数のコールバック関数です。\r
  34  * </li>\r
  35  * <li>{function(v)} onRead  -\r
  36  * read関数のコールバック関数です。\r
  37  * <ul>\r
  38  *              <li>{int} v - 受信した8BIT値です。</li>\r
  39  * </ul>\r
  40  * </li>\r
  41  * <li>{function()} onReply  -\r
  42  * reply関数のコールバック関数です。\r
  43  * </li>\r
  44  * </ul>\r
  45  * <p>\r
  46  * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。\r
  47  * </p>\r
  48  * <p>\r
  49  * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。\r
  50  * </p>\r
  51  * @return {mbedJS.SPI}\r
  52  * @example //Callback\r
  53  * var mcu=new mbedJS.Mcu("192.168.128.39",\r
  54  * {\r
  55  *   onNew:function(){\r
  56  *     var pin=new mbedJS.SPISlave(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7,mbedJS.PinName.p8],{\r
  57  *     onNew:function(){\r
  58  *       pin.frequency(1000000);\r
  59  *     },\r
  60  *     onFrequency:function()\r
  61  *     {\r
  62  *       pin.format(8,3);\r
  63  *     },\r
  64  *     onFormat:function()\r
  65  *     {\r
  66  *       pin.read();\r
  67  *     },\r
  68  *     onRead:function(v){\r
  69  *       pin.receive();\r
  70  *     },\r
  71  *     onReceive:function(v)\r
  72  *     {\r
  73  *       pin.reply(1);\r
  74  *     },\r
  75  *     onReply:function(){\r
  76  *         mcu.close();\r
  77  *     }\r
  78  *     });\r
  79  *   },\r
  80  *   onClose:function(){\r
  81  *   },\r
  82  *   onError:function(){\r
  83  *   }\r
  84  * });\r
  85  * @example //Generator\r
  86  * var g=function*(){\r
  87  * try{\r
  88  *   var mcu=new mbedJS.Mcu("192.168.128.39",g);\r
  89  *   yield mcu.waitForNew();\r
  90  *   var pin=new mbedJS.SPISlave(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7,mbedJS.PinName.p8],g);\r
  91  *   yield pin.waitForNew();\r
  92  *   yield pin.frequency(1000000);\r
  93  *   yield pin.format(8,3);\r
  94  *   var v=yield pin.read();\r
  95  *   v=yield pin.receive();\r
  96  *   yield pin.reply(1);\r
  97  *   yield mcu.close();\r
  98  * }catch(e){\r
  99  *   mcu.shutdown();\r
 100  * }\r
 101  * }();\r
 102  * g.next();\r
 103  */\r
 104 var CLASS=function SPISlave(i_mcu,i_params,i_handler)\r
 105 {\r
 106         try{\r
 107                 var _t=this;\r
 108                 _t._mcu=i_mcu;\r
 109                 _t._lc=CLASS;\r
 110                 var cb=MI._initHandler.call(_t,i_handler);\r
 111                 MI.assertInt(i_params);\r
 112                 _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1]+","+i_params[2]+","+i_params[3],\r
 113                         function(j)\r
 114                         {\r
 115                                 _t._oid=j.result[0];\r
 116                                 if(cb){cb();}\r
 117                                 if(_t._gen){_t._gen.next(_t);}\r
 118                                 _t._lc=null;\r
 119                         }\r
 120                 );\r
 121         }catch(e){\r
 122                 throw new MI.MiMicException(e);\r
 123         }               \r
 124 }\r
 125 CLASS.prototype=\r
 126 {\r
 127         /** @private */\r
 128         RPC_NS:"mbedJS:SPISlave",\r
 129         /** @private 最後にコールしたAPIです。*/\r
 130         _lc:null,\r
 131         /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/\r
 132         _gen:null,\r
 133         /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/\r
 134         _event:{},\r
 135         /** @private リモートインスタンスのオブジェクトIDです。*/\r
 136         _oid:null,\r
 137         /**\r
 138          * Generatorモードのときに使用する関数です。\r
 139          * Generatorモードの時は、yieldと併用してnew SPISlave()の完了を待ちます。\r
 140          * @name mbedJS.SPISlave#waitForNew\r
 141          * @function\r
 142          */\r
 143         waitForNew:function SPISlave_waitForNew()\r
 144         {\r
 145                 try{\r
 146                         if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}\r
 147                         this._lc=CLASS.waitForNew;\r
 148                 }catch(e){\r
 149                         throw new MI.MiMicException(e);\r
 150                 }                       \r
 151         },      \r
 152 \r
 153         /**\r
 154          * frequencyに値を設定します。\r
 155          * 関数の完了時にonFrequencyイベントが発生します。\r
 156          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 157          * @name mbedJS.SPISlave#frequency\r
 158          * @function\r
 159          * @param {int} i_value\r
 160          * \r
 161          * @return {int}\r
 162          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 163          */\r
 164         frequency:function SPISlave_frequency(i_value)\r
 165         {\r
 166                 try{\r
 167                         var _t=this;\r
 168                         MI._assertYield.call(_t);\r
 169                         var cb=MI._getCb(arguments,_t._event.onFrequency);\r
 170                         _t._lc=CLASS.frequency;\r
 171                         MI.assertInt(i_value);\r
 172                         return _t._mcu.rpc(_t.RPC_NS+":frequency",_t._oid+","+i_value,\r
 173                         function(j){\r
 174                                 if(cb){cb();}\r
 175                                 if(_t._gen){_t._gen.next();}\r
 176                                  _t._lc=null;\r
 177                         });\r
 178                 }catch(e){\r
 179                         throw new MI.MiMicException(e);\r
 180                 }\r
 181         },      \r
 182         /**\r
 183          * formatに値を設定します。\r
 184          * 関数の完了時にonFormatイベントが発生します。\r
 185          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 186          * @name mbedJS.SPISlave#format\r
 187          * @function\r
 188          * @param {int} i_bits\r
 189          * @param {int} i_mode\r
 190          * 省略可能です。省略時は0になります。\r
 191          * @return {int}\r
 192          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 193          */\r
 194         format:function SPISlave_format(i_bits,i_mode)\r
 195         {\r
 196                 try{\r
 197                         var _t=this;\r
 198                         MI._assertYield.call(_t);\r
 199                         var cb=MI._getCb(arguments,_t._event.onFormat);\r
 200                         _t._lc=CLASS.format;\r
 201                         var mode=i_mode?i_mode:0;\r
 202                         MI.assertInt([i_bits,mode]);\r
 203                         return _t._mcu.rpc(_t.RPC_NS+":format",_t._oid+","+i_bits+","+mode,\r
 204                         function(j){\r
 205                                 if(cb){cb();}\r
 206                                 if(_t._gen){_t._gen.next();}\r
 207                                  _t._lc=null;\r
 208                         });\r
 209                 }catch(e){\r
 210                         throw new MI.MiMicException(e);\r
 211                 }\r
 212         },\r
 213         /**\r
 214          * 転送メモリから値を読み込みます。\r
 215          * 関数の完了時にonReadイベントが発生します。\r
 216          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 217          * @name mbedJS.SPISlave#read\r
 218          * @function\r
 219          * @return　{int}\r
 220          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 221          * @return　{int}\r
 222          * Generatorモードの時はピンの値を返します。\r
 223          */\r
 224         read:function SPISlave_read()\r
 225         {\r
 226                 try{\r
 227                         var _t=this;\r
 228                         MI._assertYield.call(_t);\r
 229                         var cb=MI._getCb(arguments,_t._event.onRead);\r
 230                         _t._lc=CLASS.read;\r
 231                         return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,\r
 232                         function (j)\r
 233                         {\r
 234                                 var v=j.result[0];\r
 235                                 if(cb){cb(v);}\r
 236                                 if(_t._gen){_t._gen.next(v);}\r
 237                                  _t._lc=null;\r
 238                         });\r
 239                 }catch(e){\r
 240                         throw new MI.MiMicException(e);\r
 241                 }                       \r
 242         },\r
 243         /**\r
 244          * データが到着しているかを返します。\r
 245          * 関数の完了時にonReadイベントが発生します。\r
 246          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 247          * @name mbedJS.SPISlave#receive\r
 248          * @function\r
 249          * @return　{int}\r
 250          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 251          * @return　{int}\r
 252          * Generatorモードの時はピンの値を返します。\r
 253          */\r
 254         receive:function SPISlave_receive()\r
 255         {\r
 256                 try{\r
 257                         var _t=this;\r
 258                         MI._assertYield.call(_t);\r
 259                         var cb=MI._getCb(arguments,_t._event.onReceive);\r
 260                         _t._lc=CLASS.receive;\r
 261                         return _t._mcu.rpc(_t.RPC_NS+":receive",_t._oid,\r
 262                         function (j)\r
 263                         {\r
 264                                 var v=j.result[0];\r
 265                                 if(cb){cb(v);}\r
 266                                 if(_t._gen){_t._gen.next(v);}\r
 267                                  _t._lc=null;\r
 268                         });\r
 269                 }catch(e){\r
 270                         throw new MI.MiMicException(e);\r
 271                 }                       \r
 272         },\r
 273         /**\r
 274          * 転送バッファに次に送信するメッセージをセットします。\r
 275          * 関数の完了時にonReplyイベントが発生します。\r
 276          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 277          * @name mbedJS.SPISlave#reply\r
 278          * @function\r
 279          * @param {int} i_value\r
 280          * 次に送る8bitの値です。\r
 281          * @return　{int}\r
 282          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 283          */\r
 284         reply:function SPISlave_reply(i_value)\r
 285         {\r
 286                 try{\r
 287                         var _t=this;\r
 288                         MI._assertYield.call(_t);\r
 289                         var cb=MI._getCb(arguments,_t._event.onReply);\r
 290                         _t._lc=CLASS.reply;\r
 291                         MI.assertInt(i_value);\r
 292                         return _t._mcu.rpc(_t.RPC_NS+":reply",_t._oid+","+i_value,\r
 293                         function (j)\r
 294                         {\r
 295                                 if(cb){cb();}\r
 296                                 if(_t._gen){_t._gen.next();}\r
 297                                  _t._lc=null;\r
 298                         });\r
 299                 }catch(e){\r
 300                         throw new MI.MiMicException(e);\r
 301                 }                       \r
 302         },\r
 303         /**\r
 304          * MCUに生成されているオブジェクトを破棄します。\r
 305          * @name mbedJS.SPISlave#dispose\r
 306          * @function\r
 307          */\r
 308         dispose:function SPISlave_dispose()\r
 309         {\r
 310                 return this._mcu._dispose.apply(this,arguments);\r
 311         }       \r
 312 }\r
 313 NS.SPISlave=CLASS;\r
 314 }());