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

   1 /**\r
   2  * @fileOverview Memoryクラスを定義します。\r
   3  */\r
   4 (function(){\r
   5 var NS=mbedJS;\r
   6 var MI=MiMicJS;\r
   7 \r
   8 /**\r
   9  * Memoryクラスです。\r
  10  * <a href="https://mbed.org/handbook/Memory">mbed::Memory</a>と同等の機能を持ちます。\r
  11  * @name mbedJS.Memory\r
  12  * @constructor\r
  13  * @param {mbedJS.Mcu} i_mcu\r
  14  * インスタンスをバインドするMCUオブジェクトです。\r
  15  * @param {HashMap|Generator|function} i_handler\r
  16  * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。\r
  17  * <p>\r
  18  * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。\r
  19  * <ul>\r
  20  * <li>{function()} onNew -\r
  21  * インスタンスが使用可能になった時に呼び出されます。\r
  22  * </li>\r
  23  * <li>{function(v)} onRead -\r
  24  * read関数が完了した時に呼び出されます。\r
  25  *      <ul>\r
  26  *              <li>{byte[]} v - 読みだしたバイト値を格納した配列です。</li>\r
  27  *      </ul>\r
  28  * </li>\r
  29  * <li>{function(v)} onRead32 -\r
  30  * read32関数が完了した時に呼び出されます。\r
  31  *      <ul>\r
  32  *              <li>{int[]} v - 読みだしたuint32値を格納した配列です。</li>\r
  33  *      </ul>\r
  34  * </li>\r
  35  * <li>{function()} onWrite -\r
  36  * write関数が完了した時に呼び出されます。\r
  37  * </li>\r
  38  * <li>{function()} onWrite32 -\r
  39  * write32関数が完了した時に呼び出されます。\r
  40  * </li>\r
  41  * </ul>\r
  42  * <p>\r
  43  * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。\r
  44  * </p>\r
  45  * <p>\r
  46  * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。\r
  47  * </p>\r
  48  * @return {mbedJS.Memory}\r
  49  * @example //Callback\r
  50  * var s=0;\r
  51  * var mcu=new mbedJS.Mcu("192.168.128.39",\r
  52  * {\r
  53  *   onNew:function(){\r
  54  *     var mem=new mbedJS.Memory(mcu,{\r
  55  *     onNew:function(){\r
  56  *       s=0;\r
  57  *       mem.write(0x20080000,1);\r
  58  *     },\r
  59  *     onWrite:function(){\r
  60  *       log("[PASS]onWrite:"+s);\r
  61  *       switch(s){\r
  62  *       case 0:\r
  63  *         mem.read(0x20080000,1);\r
  64  *         break;\r
  65  *       case 1:\r
  66  *         mem.read(0x20080001,1);\r
  67  *         break;\r
  68  *       case 2:\r
  69  *         mem.read(0x20080000,8);\r
  70  *         break;\r
  71  *       }\r
  72  *     },\r
  73  *     onRead:function(v){\r
  74  *       log("[PASS]onRead:"+s);\r
  75  *       switch(s){\r
  76  *       case 0:\r
  77  *         mem.write(0x20080001,[2]);\r
  78  *         break;\r
  79  *       case 1:\r
  80  *         mem.write(0x20080004,[10,20,30]);\r
  81  *         break;\r
  82  *       case 2:\r
  83  *         mem.write32(0x20080000,0xff);\r
  84  *         s=-1;\r
  85  *       }\r
  86  *       s++;\r
  87  *     },\r
  88  *     onWrite32:function(){\r
  89  *       log("[PASS]onWrite32:"+s);\r
  90  *       switch(s){\r
  91  *       case 0:\r
  92  *         mem.read32(0x20080000);\r
  93  *         break;\r
  94  *       case 1:\r
  95  *         mem.read32(0x20080004,4);\r
  96  *         break;\r
  97  *       case 2:\r
  98  *         mem.read32(0x20080000,16);\r
  99  *         break;\r
 100  *       }\r
 101  *     },\r
 102  *     onRead32:function(v){\r
 103  *       log("[PASS]onRead32:"+s);\r
 104  *       switch(s){\r
 105  *       case 0:\r
 106  *         mem.write32(0x20080004,[2]);\r
 107  *         break;\r
 108  *       case 1:\r
 109  *         mem.write32(0x20080004,[10,20,30]);\r
 110  *         break;\r
 111  *       case 2:\r
 112  *         mcu.close();\r
 113  *       }\r
 114  *       s++;\r
 115  *     }      \r
 116  *     });\r
 117  *   },\r
 118  *   onClose:function(){\r
 119  *     log("[PASS]onClose");\r
 120  *   },\r
 121  *   onError:function(){\r
 122  *     alert("Error");\r
 123  *   }\r
 124  * });\r
 125  * @example //Generator\r
 126  * var g=function*(){\r
 127  * try{\r
 128  *      var v;\r
 129  *      var mcu=new mbedJS.Mcu("192.168.128.39",g);\r
 130  *      yield mcu.waitForNew();\r
 131  *      var mem=new mbedJS.Memory(mcu,g);\r
 132  *      yield mem.waitForNew();\r
 133  *      yield mem.write(0x20080000,1);\r
 134  *      log("[PASS]onWrite:");\r
 135  *      v=yield mem.read(0x20080000,1);\r
 136  *      log("[PASS]onRead:"+v);\r
 137  *      v=yield mem.read(0x20080001,1);\r
 138  *      log("[PASS]onRead:"+v);\r
 139  *      v=yield mem.read(0x20080000,8);\r
 140  *      log("[PASS]onRead:"+v);\r
 141  *      yield mem.write(0x20080001,[2]);\r
 142  *      log("[PASS]onWrite:");\r
 143  *      yield mem.write(0x20080004,[10,20,30]);\r
 144  *      log("[PASS]onWrite:");\r
 145  *      yield mem.write32(0x20080000,0xff);\r
 146  *      log("[PASS]onWrite32:");\r
 147  *      v=yield mem.read32(0x20080000);\r
 148  *      log("[PASS]onRead32:"+v);\r
 149  *      v=yield mem.read32(0x20080004,4);\r
 150  *      log("[PASS]onRead32:"+v);\r
 151  *      v=yield mem.read32(0x20080000,16);\r
 152  *      log("[PASS]onRead32:"+v);\r
 153  *      yield mem.write32(0x20080004,[2]);\r
 154  *      log("[PASS]onWrite32:");\r
 155  *      yield mem.write32(0x20080004,[10,20,30]);\r
 156  *      log("[PASS]onWrite32:");\r
 157  *      mcu.close();\r
 158  *      }catch(e){\r
 159  *      mcu.shutdown();\r
 160  *      alert(e);\r
 161  *      throw e;\r
 162  * }\r
 163  * }();\r
 164  * g.next();\r
 165  */\r
 166 var CLASS=function Memory(i_mcu,i_handler)\r
 167 {\r
 168         try{\r
 169                 var _t=this;\r
 170                 _t._mcu=i_mcu;\r
 171                 _t._lc=CLASS;\r
 172                 var cb=MI._initHandler.call(_t,i_handler);\r
 173                 _t._mcu.rpc(_t.RPC_NS+":init","",\r
 174                         function(j)\r
 175                         {\r
 176                                 if(cb){cb();}\r
 177                                 if(_t._gen){_t._gen.next(_t);}\r
 178                                 _t._lc=null;\r
 179                         }\r
 180                 );\r
 181         }catch(e){\r
 182                 throw new MI.MiMicException(e);\r
 183         }\r
 184 }\r
 185 CLASS.prototype=\r
 186 {\r
 187         /** @private */\r
 188         RPC_NS:"MiMic:Memory",\r
 189         /** @private 最後にコールしたAPIです。*/\r
 190         _lc:null,\r
 191         /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/\r
 192         _gen:null,\r
 193         /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/\r
 194         _event:{},\r
 195         /**\r
 196          * Generatorモードのときに使用する関数です。\r
 197          * Generatorモードの時は、yieldと併用してnew Memory()の完了を待ちます。\r
 198          * @name mbedJS.Memory#waitForNew\r
 199          * @function\r
 200          */\r
 201         waitForNew:function Memory_waitForNew()\r
 202         {\r
 203                 try{\r
 204                         if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}\r
 205                         this._lc=CLASS.waitForNew;\r
 206                 }catch(e){\r
 207                         throw new MI.MiMicException(e);\r
 208                 }\r
 209         },\r
 210         /**\r
 211          * 1バイト単位でメモリから読み込みます。\r
 212          * 関数の完了時にonReadイベントが発生します。\r
 213          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 214          * @name mbedJS.Memory#read\r
 215          * @function\r
 216          * @param {int} i_addr\r
 217          * メモリアドレス\r
 218          * @param {int} i_size\r
 219          * (Optional) 読出しサイズです。省略時は1です。\r
 220          * @return　{int}\r
 221          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 222          * @return　{int[]}\r
 223          * Generatorモードの時はメモリ値を格納した配列を返します。\r
 224          */\r
 225         read:function Memory_read(i_addr,i_size)\r
 226         {\r
 227                 //read(i_addr)\r
 228                 //read(i_addr,i_len)\r
 229                 try{\r
 230                         var _t=this;\r
 231                         var cb=MI._getCb(arguments,_t._event.onRead);\r
 232                         MI._assertYield.call(_t);\r
 233                         _t._lc=CLASS.read;\r
 234                         var a=[i_addr,(MI._getBaseArgsLen(arguments)==1)?i_size:1];\r
 235                         MI.assertInt(a);\r
 236                         return _t._mcu.rpc(_t.RPC_NS+":read",a[0]+","+a[1],\r
 237                         function (j)\r
 238                         {\r
 239                                 var v=MI.bstr2byteArray(j.result[0]);\r
 240                                 if(cb){cb(v);}\r
 241                                 if(_t._gen){_t._gen.next(v);}\r
 242                                  _t._lc=null;\r
 243                         });\r
 244                 }catch(e){\r
 245                         throw new MI.MiMicException(e);\r
 246                 }\r
 247         },\r
 248         /**\r
 249          * 1バイトをメモリへ書き込みます。\r
 250          * 関数の完了時にonWriteイベントが発生します。\r
 251          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 252          * @name mbedJS.Memory#write\r
 253          * @function\r
 254          * @param {int} i_addr\r
 255          * 書き込み先のメモリアドレスを指定します。\r
 256          * @param {int|int[]} i_v\r
 257          * 書き込むbyte配列、または数値を指定します。\r
 258          * 数値の場合は1バイトを書き込みます。最大長さは200byteくらいです。\r
 259          * @return　{int}\r
 260          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 261          */\r
 262         write:function Memory_write(i_addr,i_v)\r
 263         {\r
 264                 try{\r
 265                         var _t=this;\r
 266                         var cb=MI._getCb(arguments,_t._event.onWrite);\r
 267                         MI._assertYield.call(_t);\r
 268                         _t._lc=CLASS.write;\r
 269                         MI.assertInt(i_addr);\r
 270                         MI.assertInt(i_v);\r
 271                         return _t._mcu.rpc(_t.RPC_NS+":write",i_addr+",\""+MI.byteArray2bstr(i_v)+"\"",\r
 272                                 function (j)\r
 273                                 {\r
 274                                         if(cb){cb();}\r
 275                                         if(_t._gen){_t._gen.next();}\r
 276                                          _t._lc=null;\r
 277                                 }\r
 278                         );\r
 279                 }catch(e){\r
 280                         throw new MI.MiMicException(e);\r
 281                 }\r
 282         },\r
 283         /**\r
 284          * 4バイト単位でメモリから読み込みます。\r
 285          * 関数の完了時にonRead32イベントが発生します。\r
 286          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 287          * @name mbedJS.Memory#read32\r
 288          * @function\r
 289          * @param {int} i_addr\r
 290          * メモリアドレス\r
 291          * @param {int} i_size\r
 292          * (Optional) 読出しサイズです。省略時は4です。4の倍数を指定してください。\r
 293          * @return　{int}\r
 294          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 295          * @return　{int[]}\r
 296          * Generatorモードの時はメモリ値を格納した配列を返します。\r
 297          */\r
 298         read32:function Memory_read32(i_addr,i_size)\r
 299         {\r
 300                 //read(i_addr)\r
 301                 //read(i_addr,i_len)\r
 302                 try{\r
 303                         var _t=this;\r
 304                         var cb=MI._getCb(arguments,_t._event.onRead32);\r
 305                         MI._assertYield.call(_t);\r
 306                         _t._lc=CLASS.read32;\r
 307                         \r
 308                         var a=[i_addr,(MI._getBaseArgsLen(arguments)==1)?4:i_size];\r
 309                         if(a[1]%4!=0){\r
 310                                 throw new MI.MiMicException(MI.Error.NG_INVALID_ARG);\r
 311                         }\r
 312                         MI.assertInt(a);\r
 313                         return _t._mcu.rpc(_t.RPC_NS+":read",a[0]+","+a[1],\r
 314                                 function (j)\r
 315                                 {\r
 316                                         var v=MI.bstr2uintArray(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                         );\r
 322                 }catch(e){\r
 323                         throw new MI.MiMicException(e);\r
 324                 }\r
 325         },\r
 326         /**\r
 327          * 32bit unsigned intをメモリへ書き込みます。\r
 328          * 関数の完了時にonWrite32イベントが発生します。\r
 329          * Generatorモードの時は、yieldと併用して完了を待機できます。\r
 330          * @name mbedJS.Memory#write32\r
 331          * @function\r
 332          * @param {int} i_addr\r
 333          * 書き込み先のメモリアドレスを指定します。\r
 334          * @param {int|int[]} i_v\r
 335          * 書き込むbyte配列、または数値を指定します。\r
 336          * 数値の場合は1バイトを書き込みます。最大長さは200byteくらいです。\r
 337          * @return　{int}\r
 338          * Callbackモードの時はRPCメソッドのインデクスを返します。\r
 339          */\r
 340         write32:function Memory_write32(i_addr,i_v)\r
 341         {\r
 342                 try{\r
 343                         var _t=this;\r
 344                         var cb=MI._getCb(arguments,_t._event.onWrite32);\r
 345                         MI._assertYield.call(_t);\r
 346                         _t._lc=CLASS.write32;\r
 347                         MI.assertInt(i_addr);\r
 348                         MI.assertInt(i_v);\r
 349                         return _t._mcu.rpc(_t.RPC_NS+":write",i_addr+",\""+MI.uintArray2bstr(i_v)+"\"",\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 NS.Memory=CLASS;\r
 363 }());