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