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

   1 /**\r
   2  * @fileOverview PwmOutクラスを定義します。\r
   3  */\r
   4 (function(){\r
   5 var NS=mbedJS;\r
   6 var MI=MiMicJS;\r
   7 \r
   8 /**\r
   9  * PwmOutクラスです。\r
  10  * <a href="https://mbed.org/handbook/PwmOut">mbed::PwmOut</a>と同等の機能を持ちます。\r
  11  * @name mbedJS.PwmOut\r
  12  * @constructor\r
  13  * @param {mbedJS.Mcu} i_mcu\r
  14  * インスタンスをバインドするMCUオブジェクトです。\r
  15  * @param {PinName} i_params\r
  16  * ピンIDを指定します。\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()} onWrite -\r
  26  * write関数のコールバック関数です。\r
  27  * </li>\r
  28  * <li>{function(v)} onRead  -\r
  29  * read関数のコールバック関数です。\r
  30  *      <ul>\r
  31  *              <li>{int} v - 現在のピンの値です。</li>\r
  32  *      </ul>\r
  33  * </li>\r
  34  * <li>{function()} onPeriod -\r
  35  * period関数のコールバック関数です。\r
  36  * </li>\r
  37  * <li>{function()} onPeriod_ms -\r
  38  * period_ms関数のコールバック関数です。\r
  39  * </li>\r
  40  * <li>{function()} onPeriod_us -\r
  41  * period_ns関数のコールバック関数です。\r
  42  * </li>\r
  43  * <li>{function()} onPulsewidth -\r
  44  * pulswidth関数のコールバック関数です。\r
  45  * </li>\r
  46  * <li>{function()} onPulsewidth_ms -\r
  47  * pulswidth_ms関数のコールバック関数です。\r
  48  * </li>\r
  49  * <li>{function()} onPulsewidth_us -\r
  50  * pulswidth_us関数のコールバック関数です。\r
  51  * </li>\r
  52  * </ul>\r
  53  * <p>\r
  54  * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。\r
  55  * </p>\r
  56  * <p>\r
  57  * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。\r
  58  * </p>\r
  59  * @return {mbedJS.PwmOut}\r
  60  * @example //Callback\r
  61  * var mcu=new mbedJS.Mcu("192.168.128.39",\r
  62  * {\r
  63  *   onNew:function(){\r
  64  *     var pin=new mbedJS.PwmOut(mcu,mbedJS.PinName.p21,{\r
  65  *     onNew:function(){\r
  66  *       pin.write(0.33);\r
  67  *     },\r
  68  *     onWrite:function()\r
  69  *     {\r
  70  *       pin.read();\r
  71  *     },\r
  72  *     onRead:function(v)\r
  73  *     {\r
  74  *       pin.period(1.0);\r
  75  *     },\r
  76  *     onPeriod:function(){\r
  77  *       pin.period_ms(1);\r
  78  *     },\r
  79  *     onPeriod_ms:function(){\r
  80  *       pin.period_us(10);\r
  81  *     },\r
  82  *     onPeriod_us:function(){\r
  83  *       pin.pulsewidth(3);\r
  84  *     },\r
  85  *     onPulsewidth:function(){\r
  86  *       pin.pulsewidth_ms(30);\r
  87  *     },\r
  88  *     onPulsewidth_ms:function(){\r
  89  *       pin.pulsewidth_us(40);\r
  90  *     },\r
  91  *     onPulsewidth_us:function(){\r
  92  *       mcu.close();\r
  93  *     }\r
  94  *     });\r
  95  *   },\r
  96  *   onClose:function(){\r
  97  *   },\r
  98  *   onError:function(){\r
  99  *   }\r
 100  * });\r
 101  * @example //Generator\r
 102  * var g=function*(){\r
 103  * try{\r
 104  *   var mcu=new mbedJS.Mcu("192.168.128.39",g);\r
 105  *   yield mcu.waitForNew();\r
 106  *   var pin=new mbedJS.PwmOut(mcu,mbedJS.PinName.p21,g);\r
 107  *   yield pin.waitForNew();\r
 108  *   yield pin.write(0.33);\r
 109  *   var v=yield pin.read();\r
 110  *   yield pin.period(1.0);\r
 111  *   yield pin.period_ms(1);\r
 112  *   yield pin.period_us(10);\r
 113  *   yield pin.pulsewidth(3);\r
 114  *   yield pin.pulsewidth_ms(30);\r
 115  *   yield pin.pulsewidth_us(40);\r
 116  *   yield mcu.close();\r
 117  * }catch(e){\r
 118  *   mcu.shutdown();\r
 119  * }}();\r
 120  * g.next();\r
 121  */\r
 122 var CLASS=function PwmOut(i_mcu,i_params,i_handler)\r
 123 {\r
 124         try{\r
 125                 var _t=this;\r
 126                 _t._mcu=i_mcu;\r
 127                 _t._lc=CLASS;\r
 128                 var cb=MI._initHandler.call(_t,i_handler);\r
 129                 MI.assertInt(i_params);\r
 130                 _t._mcu.rpc(_t.RPC_NS+":_new1",i_params,\r
 131                         function(j)\r
 132                         {\r
 133                                 _t._oid=j.result[0];\r
 134                                 if(cb){cb();}\r
 135                                 if(_t._gen){_t._gen.next(_t);}\r
 136                                 _t._lc=null;\r
 137                         }\r
 138                 );\r
 139         }catch(e){\r
 140                 throw new MI.MiMicException(e);\r
 141         }\r
 142 }\r
 143 CLASS.prototype=\r
 144 {\r
 145         /** @private */\r
 146         RPC_NS:"mbedJS:PwmOut",\r
 147         /** @private 最後にコールしたAPIです。*/\r
 148         _lc:null,\r
 149         /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/\r
 150         _gen:null,\r
 151         /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/\r
 152         _event:{},\r
 153         /** @private リモートインスタンスのオブジェクトIDです。*/\r
 154         _oid:null,\r
 155         /**\r
 156          * Generatorモードのときに使用する関数です。\r
 157          * Generatorモードの時は、yieldと併用してnew PwmOut()の完了を待ちます。\r
 158          * @name mbedJS.PwmOut#waitForNew\r
 159          * @function\r
 160          */\r
 161         waitForNew:function PwmOut_waitForNew()\r
 162         {\r
 163                 try{\r
 164                         if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}\r
 165                         this._lc=CLASS.waitForNew;\r
 166                 }catch(e){\r
 167                         throw new MI.MiMicException(e);\r
 168                 }                       \r
 169         },\r
 170         /**\r
 171          * ピンに値を出力します。\r
 172          * 関数の完了時にonWriteイベントが発生します。\r
 173          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 174          * @name mbedJS.PwmOut#write\r
 175          * @function\r
 176          * @param {float} i_value\r
 177          * [0,1]の値を指定します。\r
 178          * @return {int|none}\r
 179          * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>\r
 180          * <p>Generatorモードの時は戻り値はありません。</p>\r
 181          */\r
 182         write:function PwmOut_write(i_value)\r
 183         {\r
 184                 try{\r
 185                         var _t=this;\r
 186                         var cb=MI._getCb(arguments,_t._event.onWrite);\r
 187                         MI._assertYield.call(_t);\r
 188                         _t._lc=CLASS.write;\r
 189                         MI.assertNumber(i_value);\r
 190                         return _t._mcu.rpc(_t.RPC_NS+":write_fx",_t._oid+","+Math.round(i_value*10000),\r
 191                         function(j){\r
 192                                 if(cb){cb();}\r
 193                                 if(_t._gen){_t._gen.next();}\r
 194                                  _t._lc=null;\r
 195                         });\r
 196                 }catch(e){\r
 197                         throw new MI.MiMicException(e);\r
 198                 }\r
 199         },\r
 200         /**\r
 201          * ピンから値を読み込みます。\r
 202          * 関数の完了時にonReadイベントが発生します。\r
 203          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 204          * @name mbedJS.PwmOut#read\r
 205          * @function\r
 206          * @return　{int|float}\r
 207          * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>\r
 208          * <p>Generatorモードの時はピンの値を返します。</p>\r
 209          */\r
 210         read:function PwmOut_read()\r
 211         {\r
 212                 try{\r
 213                         var _t=this;\r
 214                         var cb=MI._getCb(arguments,_t._event.onRead);\r
 215                         MI._assertYield.call(_t);\r
 216                         _t._lc=CLASS.read;\r
 217                         return _t._mcu.rpc(_t.RPC_NS+":read_fx",_t._oid,\r
 218                         function (j)\r
 219                         {\r
 220                                 var v=j.result[0]/10000;\r
 221                                 if(cb){cb(v);}\r
 222                                 if(_t._gen){_t._gen.next(v);}\r
 223                                  _t._lc=null;\r
 224                         });\r
 225                 }catch(e){\r
 226                         throw new MI.MiMicException(e);\r
 227                 }                       \r
 228         },\r
 229         /**\r
 230          * PWMの周期を設定します。\r
 231          * 関数の完了時にonPeriodイベントが発生します。\r
 232          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 233          * @name mbedJS.PwmOut#period\r
 234          * @function\r
 235          * @param {float} i_value\r
 236          * 秒単位の周期を設定します。\r
 237          * @return {int|none}\r
 238          * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>\r
 239          * <p>Generatorモードの時は戻り値はありません。</p>\r
 240          */\r
 241         period:function PwmOut_period(i_value)\r
 242         {\r
 243                 try{\r
 244                         var _t=this;\r
 245                         var cb=MI._getCb(arguments,_t._event.onPeriod);\r
 246                         MI._assertYield.call(_t);\r
 247                         _t._lc=CLASS.period;\r
 248                         MI.assertInt(i_value);\r
 249                         return _t._mcu.rpc(_t.RPC_NS+":period_fx",_t._oid+","+Math.round(i_value*10000),\r
 250                         function(j){\r
 251                                 if(cb){cb();}\r
 252                                 if(_t._gen){_t._gen.next();}\r
 253                                  _t._lc=null;\r
 254                         });\r
 255                 }catch(e){\r
 256                         throw new MI.MiMicException(e);\r
 257                 }\r
 258         },\r
 259         /**\r
 260          * PWMの周期を設定します。\r
 261          * 関数の完了時にonPeriod_msイベントが発生します。\r
 262          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 263          * @name mbedJS.PwmOut#period_ms\r
 264          * @function\r
 265          * @param {int} i_value\r
 266          * ms単位の周期を設定します。\r
 267          * @return {int|none}\r
 268          * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>\r
 269          * <p>Generatorモードの時は戻り値はありません。</p>\r
 270          */\r
 271         period_ms:function PwmOut_period_ms(i_value)\r
 272         {\r
 273                 try{\r
 274                         var _t=this;\r
 275                         var cb=MI._getCb(arguments,_t._event.onPeriod_ms);\r
 276                         MI._assertYield.call(_t);\r
 277                         _t._lc=CLASS.period_ms;\r
 278                         MI.assertInt(i_value);\r
 279                         return _t._mcu.rpc(_t.RPC_NS+":period_ms",_t._oid+","+i_value,\r
 280                         function(j){\r
 281                                 if(cb){cb();}\r
 282                                 if(_t._gen){_t._gen.next();}\r
 283                                  _t._lc=null;\r
 284                         });\r
 285                 }catch(e){\r
 286                         throw new MI.MiMicException(e);\r
 287                 }\r
 288         },\r
 289         /**\r
 290          * PWMの周期を設定します。\r
 291          * 関数の完了時にonPeriod_usイベントが発生します。\r
 292          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 293          * @name mbedJS.PwmOut#period_us\r
 294          * @function\r
 295          * @param {int} i_value\r
 296          * 整数値を指定します。\r
 297          * @return {int|none}\r
 298          * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>\r
 299          * <p>Generatorモードの時は戻り値はありません。</p>\r
 300          */\r
 301         period_us:function PwmOut_period_us(i_value)\r
 302         {\r
 303                 try{\r
 304                         var _t=this;\r
 305                         var cb=MI._getCb(arguments,_t._event.onPeriod_us);\r
 306                         MI._assertYield.call(_t);\r
 307                         _t._lc=CLASS.period_us;\r
 308                         MI.assertInt(i_value);\r
 309                         return _t._mcu.rpc(_t.RPC_NS+":period_us",_t._oid+","+i_value,\r
 310                         function(j){\r
 311                                 if(cb){cb();}\r
 312                                 if(_t._gen){_t._gen.next();}\r
 313                                  _t._lc=null;\r
 314                         });\r
 315                 }catch(e){\r
 316                         throw new MI.MiMicException(e);\r
 317                 }\r
 318         },\r
 319         /**\r
 320          * PWMの周期を設定します。\r
 321          * 関数の完了時にonPeriodイベントが発生します。\r
 322          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 323          * @name mbedJS.PwmOut#pulsewidth\r
 324          * @function\r
 325          * @param {float} i_value\r
 326          * 秒単位の周期を設定します。\r
 327          * @return {int|none}\r
 328          * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>\r
 329          * <p>Generatorモードの時は戻り値はありません。</p>\r
 330          */\r
 331         pulsewidth:function PwmOut_pulsewidth(i_value)\r
 332         {\r
 333                 try{\r
 334                         var _t=this;\r
 335                         var cb=MI._getCb(arguments,_t._event.onPulsewidth);\r
 336                         MI._assertYield.call(_t);\r
 337                         _t._lc=CLASS.pulsewidth;\r
 338                         MI.assertInt(i_value);\r
 339                         return _t._mcu.rpc(_t.RPC_NS+":pulsewidth_fx",_t._oid+","+Math.round(i_value*10000),\r
 340                         function(j){\r
 341                                 if(cb){cb();}\r
 342                                 if(_t._gen){_t._gen.next();}\r
 343                                  _t._lc=null;\r
 344                         });\r
 345                 }catch(e){\r
 346                         throw new MI.MiMicException(e);\r
 347                 }\r
 348         },\r
 349         /**\r
 350          * PWMの周期を設定します。\r
 351          * 関数の完了時にonPulsewidth_msイベントが発生します。\r
 352          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 353          * @name mbedJS.PwmOut#pulsewidth_ms\r
 354          * @function\r
 355          * @param {int} i_value\r
 356          * ms単位の周期を設定します。\r
 357          * @return {int}\r
 358          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 359          */\r
 360         pulsewidth_ms:function PwmOut_pulsewidth_ms(i_value)\r
 361         {\r
 362                 try{\r
 363                         var _t=this;\r
 364                         var cb=MI._getCb(arguments,_t._event.onPulsewidth_ms);\r
 365                         MI._assertYield.call(_t);\r
 366                         _t._lc=CLASS.pulsewidth_ms;\r
 367                         MI.assertInt(i_value);\r
 368                         return _t._mcu.rpc(_t.RPC_NS+":pulsewidth_ms",_t._oid+","+i_value,\r
 369                                 function(j){\r
 370                                         if(cb){cb();}\r
 371                                         if(_t._gen){_t._gen.next();}\r
 372                                          _t._lc=null;\r
 373                                 }\r
 374                         );\r
 375                 }catch(e){\r
 376                         throw new MI.MiMicException(e);\r
 377                 }\r
 378         },\r
 379         /**\r
 380          * PWMの周期を設定します。\r
 381          * 関数の完了時にonPulsewidth_usイベントが発生します。\r
 382          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 383          * @name mbedJS.PwmOut#pulsewidth_us\r
 384          * @function\r
 385          * @param {int} i_value\r
 386          * 整数値を指定します。\r
 387          * @return {int}\r
 388          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 389          */\r
 390         pulsewidth_us:function PwmOut_pulsewidth_us(i_value)\r
 391         {\r
 392                 try{\r
 393                         var _t=this;\r
 394                         var cb=MI._getCb(arguments,_t._event.onPulsewidth_us);\r
 395                         MI._assertYield.call(_t);\r
 396                         _t._lc=CLASS.pulsewidth_us;\r
 397                         MI.assertInt(i_value);\r
 398                         return _t._mcu.rpc(_t.RPC_NS+":pulsewidth_us",_t._oid+","+i_value,\r
 399                                 function(j){\r
 400                                         if(cb){cb();}\r
 401                                         if(_t._gen){_t._gen.next();}\r
 402                                          _t._lc=null;\r
 403                                 }\r
 404                         );\r
 405                 }catch(e){\r
 406                         throw new MI.MiMicException(e);\r
 407                 }\r
 408         },\r
 409         /**\r
 410          * MCUに生成されているオブジェクトを破棄します。\r
 411          * @name mbedJS.PwmOut#dispose\r
 412          * @function\r
 413          */\r
 414         dispose:function PwmOut_dispose()\r
 415         {\r
 416                 return this._mcu._dispose.apply(this,arguments);\r
 417         }\r
 418 }\r
 419 NS.PwmOut=CLASS;\r
 420 }());