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

   1 /**\r
   2  * @fileOverview AnalogInクラスを定義します。\r
   3  */\r
   4 (function(){\r
   5 var NS=mbedJS;\r
   6 var MI=MiMicJS;\r
   7 \r
   8 /**\r
   9  * Serialクラスです。\r
  10  * <a href="https://mbed.org/handbook/Serial">mbed::Serial</a>と同等の機能を持ちます。\r
  11  * @constructor\r
  12  * @name mbedJS.Serial\r
  13  * @param {mbedJS.Mcu} i_mcu\r
  14  * インスタンスをバインドするMCUオブジェクトです。\r
  15  * @param {[PinName,PinName]} i_params\r
  16  * UARTを構成する２本のピンを指定します。tx,rxの順で設定します。\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()} onFormat -\r
  26  * format関数が完了したときに呼び出されます。\r
  27  * </li>\r
  28  * <li>{function(v)} onReadable -\r
  29  * read関数が完了したときに呼び出されます。\r
  30  *      <ul>\r
  31  *              <li>{boolean} v - 読出しが可能化の真偽値です。</li>\r
  32  *      </ul>\r
  33  * </li>\r
  34  * <li>{function(v)} onWriteable -\r
  35  * write関数が完了したときに呼び出されます。\r
  36  *      <ul>\r
  37  *              <li>{boolean} v - 書き込みが可能化の真偽値です。</li>\r
  38  *      </ul>\r
  39  * </li>\r
  40  * <li>{function()} onSend_break -\r
  41  * send_break関数が完了したときに呼び出されます。\r
  42  * </li>\r
  43  * <li>{function(v)} onPutc -\r
  44  * putc関数が完了したときに呼び出されます。\r
  45  *      <ul>\r
  46  *              <li>{int} v - 謎の戻り値です。</li>\r
  47  *      </ul>\r
  48  * </li>\r
  49  * <li>{function(v)} onPuts -\r
  50  * puts関数が完了したときに呼び出されます。\r
  51  *      <ul>\r
  52  *              <li>{int} v - 謎の戻り値です。</li>\r
  53  *      </ul>\r
  54  * </li>\r
  55  * <li>{function(v)} onGetc -\r
  56  * getc関数が完了したときに呼び出されます。\r
  57  *      <ul>\r
  58  *              <li>{int} v - 読みだした1バイトの値です。</li>\r
  59  *      </ul>\r
  60  * </li>\r
  61  * <li>{function(v)} onGets -\r
  62  * gets関数が完了したときに呼び出されます。\r
  63  *      <ul>\r
  64  *              <li>{int} v - 読みだした文字列です。</li>\r
  65  *      </ul>\r
  66  * </li>\r
  67  * <li>{function()} onBaud -\r
  68  * baud関数が完了したときに呼び出されます。\r
  69  * </li>\r
  70  * </ul>\r
  71  * <p>\r
  72  * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。\r
  73  * </p>\r
  74  * <p>\r
  75  * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。\r
  76  * </p>\r
  77  * @return {mbedJS.Serial}\r
  78  * @example //Callback\r
  79  * var mcu=new mbedJS.Mcu("192.168.128.39",\r
  80  * {\r
  81  *   onNew:function(){\r
  82  *     var uart=new mbedJS.Serial(mcu,[mbedJS.PinName.p9,mbedJS.PinName.p10],{\r
  83  *     onNew:function(){\r
  84  *       uart.baud(115200);\r
  85  *     },\r
  86  *     onBaud:function()\r
  87  *     {\r
  88  *       uart.send_break();\r
  89  *     },\r
  90  *     onSend_break:function(){\r
  91  *       uart.format(8,uart.Parity.None,1);\r
  92  *     },\r
  93  *     onFormat:function(){\r
  94  *       uart.readable();\r
  95  *     },\r
  96  *     onReadable:function(v){\r
  97  *       uart.writeable();\r
  98  *     },\r
  99  *     onWriteable:function(v){\r
 100  *       uart.putc(32);\r
 101  *     },\r
 102  *     onPutc:function(v){\r
 103  *       uart.getc();\r
 104  *     },\r
 105  *     onGetc:function(v){\r
 106  *       uart.puts("1234");\r
 107  *     },\r
 108  *     onPuts:function(v){\r
 109  *       uart.gets(5);\r
 110  *     },\r
 111  *     onGets:function(v){\r
 112  *       mcu.close();\r
 113  *     }\r
 114  *     });\r
 115  *   },\r
 116  *   onClose:function(){\r
 117  *   },\r
 118  *   onError:function(){\r
 119  *     alert("Error");\r
 120  *   }\r
 121  * });\r
 122  * @example //Generator\r
 123  * var g=function*(){\r
 124  * try{\r
 125  *   var v;\r
 126  *   var mcu=new mbedJS.Mcu("192.168.128.39",g);\r
 127  *   yield mcu.waitForNew();\r
 128  *   var uart=new mbedJS.Serial(mcu,[mbedJS.PinName.p9,mbedJS.PinName.p10],g);\r
 129  *   yield uart.waitForNew();\r
 130  *   yield uart.baud(115200);\r
 131  *   yield uart.send_break();\r
 132  *   yield uart.format(8,uart.Parity.None,1);\r
 133  *   v=yield uart.readable();\r
 134  *   v=yield uart.writeable();\r
 135  *   v=yield uart.putc(32);\r
 136  *   v=yield uart.getc();\r
 137  *   v=yield uart.puts("1234");\r
 138  *   v=yield uart.gets(5);\r
 139  *   yield mcu.close();\r
 140  * }catch(e){\r
 141  *   mcu.shutdown();\r
 142  *   alert(e);\r
 143  *   throw e;\r
 144  * }\r
 145  * }();\r
 146  * g.next();\r
 147  */\r
 148 var CLASS=function Serial(i_mcu,i_params,i_handler)\r
 149 {\r
 150         try{\r
 151                 var _t=this;\r
 152                 var cb;\r
 153                 _t._mcu=i_mcu;\r
 154                 _t._lc=CLASS;\r
 155                 //ハンドラの初期化\r
 156                 var cb=MI._initHandler.call(_t,i_handler);\r
 157                 MI.assertInt(i_params);         \r
 158                 _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1],\r
 159                         function(j)\r
 160                         {\r
 161                                 _t._oid=j.result[0];\r
 162                                 if(cb){cb();}\r
 163                                 if(_t._gen){_t._gen.next(_t);}\r
 164                                 _t._lc=null;\r
 165                         }\r
 166                 );\r
 167         }catch(e){\r
 168                 throw new MI.MiMicException(e);\r
 169         }       \r
 170 }\r
 171 /**\r
 172  * mbedJS.Serial#format関数に指定する値の種類です。\r
 173  * None,Odd,Even,Forced1,Forced0があります。\r
 174  * @name mbedJS.Serial#Parity\r
 175  * @field\r
 176  */\r
 177 CLASS.Parity={\r
 178         None:0,Odd:1,Even:2,Forced1:3,Forced0:4\r
 179 }\r
 180 CLASS.prototype={\r
 181         /** @private */\r
 182         RPC_NS:"mbedJS:Serial",\r
 183         /** @private 最後にコールしたAPIです。*/\r
 184         _lc:null,\r
 185         /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/\r
 186         _gen:null,\r
 187         /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/\r
 188         _event:{},\r
 189         /** @private リモートインスタンスのオブジェクトIDです。*/\r
 190         _oid:null,\r
 191         /**\r
 192          * Generatorモードのときに使用する関数です。\r
 193          * Generatorモードの時は、yieldと併用してnew AnalogIn()の完了を待ちます。\r
 194          * @name mbedJS.Serial#waitForNew\r
 195          * @function\r
 196          */\r
 197         waitForNew:function Serial_waitForNew()\r
 198         {\r
 199                 try{\r
 200                         if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}\r
 201                         this._lc=CLASS.waitForNew;\r
 202                 }catch(e){\r
 203                         throw new MI.MiMicException(e);\r
 204                 }\r
 205         },\r
 206         /**\r
 207          * フォーマットを設定します。\r
 208          * 関数の完了時にonFormatイベントが発生します。\r
 209          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 210          * @name mbedJS.Serial#format\r
 211          * @function\r
 212          * @param {int} i_bits\r
 213          * ビット数です。省略時は8です。\r
 214          * @param {int} i_parity\r
 215          * パリティの値です。省略時はmbedJS.Serial#Parity.Noneです。\r
 216          * @param {int} i_stop_bits\r
 217          * ストップビットの値です。省略時は1です。\r
 218          * @return　{int}\r
 219          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 220          */\r
 221         format:function Serial_format(i_bits,i_parity,i_stop_bits)\r
 222         {\r
 223                 try{\r
 224                         var _t=this;\r
 225                         MI._assertYield.call(_t);\r
 226                         var cb=MI._getCb(arguments,_t._event.onFormat);\r
 227                         _t._lc=CLASS.format;\r
 228                         var p=[MI.isUndefined(i_bits,8),MI.isUndefined(i_parity,CLASS.Parity.None),MI.isUndefined(i_stop_bits,1)];\r
 229                         MI.assertInt(p);\r
 230                         return _t._mcu.rpc(_t.RPC_NS+":format",_t._oid+","+p[0]+","+p[1]+","+p[2],\r
 231                                 function (j)\r
 232                                 {\r
 233                                         if(cb){cb();}\r
 234                                         if(_t._gen){_t._gen.next();}\r
 235                                          _t._lc=null;\r
 236                                 }\r
 237                         );\r
 238                 }catch(e){\r
 239                         throw new MI.MiMicException(e);\r
 240                 }                       \r
 241         },\r
 242         /**\r
 243          * 読出し可能かを返します。\r
 244          * 関数の完了時にonReadableイベントが発生します。\r
 245          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 246          * @name mbedJS.Serial#readable\r
 247          * @function\r
 248          * @return　{int}\r
 249          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 250          * @return　{boolean}\r
 251          * Generatorモードの時は状態値の真偽値を返します。\r
 252          */\r
 253         readable:function Serial_readable()\r
 254         {\r
 255                 try{\r
 256                         var _t=this;\r
 257                         MI._assertYield.call(_t);\r
 258                         var cb=MI._getCb(arguments,_t._event.onReadable);\r
 259                         _t._lc=CLASS.readable;\r
 260                         return _t._mcu.rpc(_t.RPC_NS+":readable",_t._oid,\r
 261                                 function (j)\r
 262                                 {\r
 263                                         var v=j.result[0];\r
 264                                         if(cb){cb(v);}\r
 265                                         if(_t._gen){_t._gen.next(v);}\r
 266                                          _t._lc=null;\r
 267                                 }\r
 268                         );\r
 269                 }catch(e){\r
 270                         throw new MI.MiMicException(e);\r
 271                 }                       \r
 272         },\r
 273         /**\r
 274          * 書き込み可能かを返します。\r
 275          * 関数の完了時にonWriteableイベントが発生します。\r
 276          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 277          * @name mbedJS.Serial#writeable\r
 278          * @function\r
 279          * @return　{int}\r
 280          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 281          * @return　{boolean}\r
 282          * Generatorモードの時は状態値の真偽値を返します。\r
 283          */\r
 284         writeable:function Serial_writeable()\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.onWriteable);\r
 290                         _t._lc=CLASS.writeable;                 \r
 291                         return _t._mcu.rpc(_t.RPC_NS+":writeable",_t._oid,\r
 292                                 function (j)\r
 293                                 {\r
 294                                         var v=j.result[0]?true:false;\r
 295                                         if(cb){cb(v);}\r
 296                                         if(_t._gen){_t._gen.next(v);}\r
 297                                          _t._lc=null;\r
 298                                 }\r
 299                         );\r
 300                 }catch(e){\r
 301                         throw new MI.MiMicException(e);\r
 302                 }                       \r
 303         },\r
 304         /**\r
 305          * ブレーク信号を送信します。\r
 306          * 関数の完了時にonSend_breakイベントが発生します。\r
 307          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 308          * @name mbedJS.Serial#send_break\r
 309          * @function\r
 310          * @return　{int}\r
 311          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 312          */\r
 313         send_break:function Serial_send_break()\r
 314         {\r
 315                 try{\r
 316                         var _t=this;\r
 317                         MI._assertYield.call(_t);\r
 318                         var cb=MI._getCb(arguments,_t._event.onSend_break);\r
 319                         _t._lc=CLASS.send_break;\r
 320                         return _t._mcu.rpc(_t.RPC_NS+":send_break",_t._oid,\r
 321                                 function (j)\r
 322                                 {\r
 323                                         if(cb){cb();}\r
 324                                         if(_t._gen){_t._gen.next();}\r
 325                                          _t._lc=null;\r
 326                                 }\r
 327                         );\r
 328                 }catch(e){\r
 329                         throw new MI.MiMicException(e);\r
 330                 }                       \r
 331         },\r
 332         /**\r
 333          * 1バイトの値を出力します。\r
 334          * 関数の完了時にonPutcイベントが発生します。\r
 335          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 336          * @name mbedJS.Serial#putc\r
 337          * @function\r
 338          * @return　{int}\r
 339          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 340          * @return　{int}\r
 341          * Generatorモードの時は謎の値を返します。\r
 342          */\r
 343         putc:function Serial_putc(i_c)\r
 344         {\r
 345                 try{\r
 346                         var _t=this;\r
 347                         MI._assertYield.call(_t);\r
 348                         var cb=MI._getCb(arguments,_t._event.onPutc);\r
 349                         _t._lc=CLASS.putc;\r
 350                         MI.assertInt(i_c);\r
 351                         return _t._mcu.rpc(_t.RPC_NS+":putc",_t._oid+","+i_c,\r
 352                                 function (j)\r
 353                                 {\r
 354                                         var v=j.result[0];\r
 355                                         if(cb){cb(v);}\r
 356                                         if(_t._gen){_t._gen.next(v);}\r
 357                                          _t._lc=null;\r
 358                                 }\r
 359                         );\r
 360                 }catch(e){\r
 361                         throw new MI.MiMicException(e);\r
 362                 }\r
 363         },\r
 364         /**\r
 365          * 文字列を出力します。\r
 366          * 関数の完了時にonPutsイベントが発生します。\r
 367          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 368          * @name mbedJS.Serial#puts\r
 369          * @function\r
 370          * @return　{int}\r
 371          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 372          * @return　{int}\r
 373          * Generatorモードの時は謎の値を返します。\r
 374          */\r
 375         puts:function Serial_puts(i_s)\r
 376         {\r
 377                 try{\r
 378                         var _t=this;\r
 379                         MI._assertYield.call(_t);\r
 380                         var cb=MI._getCb(arguments,_t._event.onPuts);\r
 381                         _t._lc=CLASS.puts;\r
 382                         return _t._mcu.rpc(_t.RPC_NS+":puts",_t._oid+",\""+i_s+"\"",\r
 383                                 function (j)\r
 384                                 {\r
 385                                         var v=j.result[0];\r
 386                                         if(cb){cb(v);}\r
 387                                         if(_t._gen){_t._gen.next(v);}\r
 388                                          _t._lc=null;\r
 389                                 }\r
 390                         );\r
 391                 }catch(e){\r
 392                         throw new MI.MiMicException(e);\r
 393                 }\r
 394         },\r
 395         /**\r
 396          * 1バイトを読み込みます。\r
 397          * 関数の完了時にonGetcイベントが発生します。\r
 398          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 399          * @name mbedJS.Serial#getc\r
 400          * @function\r
 401          * @return　{int}\r
 402          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 403          * @return　{int}\r
 404          * Generatorモードの時は受信した数値を返します。\r
 405          */\r
 406         getc:function Serial_getc()\r
 407         {\r
 408                 try{\r
 409                         var _t=this;\r
 410                         MI._assertYield.call(_t);\r
 411                         var cb=MI._getCb(arguments,_t._event.onGetc);\r
 412                         _t._lc=CLASS.getc;\r
 413                         return _t._mcu.rpc(_t.RPC_NS+":getc",_t._oid,\r
 414                                 function (j)\r
 415                                 {\r
 416                                         var v=j.result[0];\r
 417                                         if(cb){cb(v);}\r
 418                                         if(_t._gen){_t._gen.next(v);}\r
 419                                          _t._lc=null;\r
 420                                 }\r
 421                         );\r
 422                 }catch(e){\r
 423                         throw new MI.MiMicException(e);\r
 424                 }\r
 425         },\r
 426         /**\r
 427          * 文字列を読み込みます。\r
 428          * 関数の完了時にonGetsイベントが発生します。\r
 429          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 430          * @name mbedJS.Serial#gets\r
 431          * @function\r
 432          * @param {int} i_len\r
 433          * 受信メモリのサイズを指定します。256未満を指定してください。\r
 434          * @return　{int}\r
 435          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 436          * @return　{string}\r
 437          * Generatorモードの時は受信した文字列を返します。\r
 438          */\r
 439         gets:function Serial_gets(i_len)\r
 440         {\r
 441                 try{\r
 442                         var _t=this;\r
 443                         MI._assertYield.call(_t);\r
 444                         var cb=MI._getCb(arguments,_t._event.onGets);\r
 445                         _t._lc=CLASS.gets;\r
 446                         MI.assertInt(i_len);                    \r
 447                         return _t._mcu.rpc(_t.RPC_NS+":gets",_t._oid+","+i_len,\r
 448                                 function (j)\r
 449                                 {\r
 450                                         var v=j.result[0];\r
 451                                         if(cb){cb(v);}\r
 452                                         if(_t._gen){_t._gen.next(v);}\r
 453                                          _t._lc=null;\r
 454                                 }\r
 455                         );\r
 456                 }catch(e){\r
 457                         throw new MI.MiMicException(e);\r
 458                 }\r
 459         },\r
 460         /**\r
 461          * ボーレイトを設定します。\r
 462          * 関数の完了時にonBaudイベントが発生します。\r
 463          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 464          * @name mbedJS.Serial#baud\r
 465          * @function\r
 466          * @param {int} i_baudrate\r
 467          * ボーレイトの値です。\r
 468          * @return　{int}\r
 469          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 470          */\r
 471         baud:function Serial_baud(i_baudrate)\r
 472         {\r
 473                 try{\r
 474                         var _t=this;\r
 475                         MI._assertYield.call(_t);\r
 476                         var cb=MI._getCb(arguments,_t._event.onBaud);\r
 477                         _t._lc=CLASS.baud;\r
 478                         MI.assertInt(i_baudrate);                       \r
 479                         return _t._mcu.rpc(_t.RPC_NS+":baud",_t._oid+","+i_baudrate,\r
 480                                 function (j)\r
 481                                 {\r
 482                                         if(cb){cb();}\r
 483                                         if(_t._gen){_t._gen.next();}\r
 484                                          _t._lc=null;\r
 485                                 }\r
 486                         );\r
 487                 }catch(e){\r
 488                         throw new MI.MiMicException(e);\r
 489                 }                       \r
 490         },\r
 491         /**\r
 492          * MCUに生成されているオブジェクトを破棄します。\r
 493          * @name mbedJS.Serial#dispose\r
 494          * @function\r
 495          */\r
 496         dispose:function Serial_dispose()\r
 497         {\r
 498                 return this._mcu._dispose.apply(this,arguments);\r
 499         }\r
 500 }\r
 501 NS.Serial=CLASS;\r
 502 }());