misc/MiMicVM/api.js/LPCXPresso1769.All.js

   1 /**\r
   2  * @fileOverview LPCXpresso1769ネームスペース、定数値を定義する。\r
   3  */\r
   4 \r
   5 /**\r
   6  * LPCXPresso1769用の高レベルAPIのネームスペースである。\r
   7  * MCU,Pin,peripheralのクラスと、識別子を定義する。\r
   8  * このネームスペースのにある宣言は、LPC1769プロセッサに依存する。\r
   9  * @namespace\r
  10  */\r
  11 var LPCXpresso1769;\r
  12 \r
  13 (function(){\r
  14         var isUndef=MiMicLib.isUndef;\r
  15         var DEV=\r
  16         {\r
  17                 /**\r
  18                  * エラーIDテーブルの拡張\r
  19                  * @private\r
  20                  */\r
  21                 _EE:function(i_base){\r
  22                 return{\r
  23                         NG:[i_base|0x00,"Unknown exception in LPCXpresso1769"],\r
  24                         INVALID_ARG :[i_base|0x01,"Invalid argument"],\r
  25                         INVALID_PIN :[i_base|0x02,"Invalid pin"],\r
  26                         INVALID_CFG :[i_base|0x03,"Invalid configulation"],\r
  27                         VM_RUNTIME  :[i_base|0x04,"MVM runtime error"],\r
  28                 };}(MiMicError.NG[0]|MiMicError.MID_MiMic|MiMicError.CAID_LPCXPresso1769),\r
  29                 /**\r
  30                  * BCフラグメント・ライブラリ\r
  31                  * @private
  32                  */\r
  33                 _BCF:{\r
  34                         /**\r
  35                          * ([i_addr]&(~(i_mask<<i_shl))|((i_mask & i_val)<<i_shl)を実行するMimicBCを生成する。\r
  36                          * [S0]のアドレスのメモリ値に[S1]の値でマスクして,[S2]の値とORして[S0]に書き戻す。\r
  37                          * <pre>\r
  38                          * SGET #0;\r
  39                          * SGET #1;\r
  40                          * SGET #2;\r
  41                          * MGET #7,#0;\r
  42                          * AND #7,#1;\r
  43                          * OR #7,#2;\r
  44                          * MPUT #7,#0;\r
  45                          * </pre>\r
  46                          * @private\r
  47                          * @param i_mask\r
  48                          * ビットマスク\r
  49                          * @param i_val\r
  50                          * ビット値\r
  51                          */\r
  52                         setBit:function setBit(i_addr,i_mask,i_val,i_shl,i_db)\r
  53                         {\r
  54                                 try{\r
  55                                         i_db.push(i_addr);\r
  56                                         i_db.push(~(i_mask<<i_shl));\r
  57                                         i_db.push((i_mask & i_val) << i_shl);\r
  58                                         return "EA00EA01EA02DB0700AA0701AE0702DF0700";\r
  59                                 }catch(e){\r
  60                                         throw new MiMicException(e);\r
  61                                 }                       \r
  62                         },\r
  63                         /**\r
  64                          * 値をメモリに設定する。\r
  65                          * <pre>\r
  66                          * SGET #0\r
  67                          * SGET #1\r
  68                          * MPUT #1,#0\r
  69                          * </pre>\r
  70                          * @private\r
  71                          */\r
  72                         setMem:function setMem(i_addr,i_val,i_db)\r
  73                         {\r
  74                                 try{\r
  75                                         i_db.push(i_addr);\r
  76                                         i_db.push(i_val);\r
  77                                         return "EA00EA01DF0100";\r
  78                                 }catch(e){\r
  79                                         throw new MiMicException(e);\r
  80                                 }                       \r
  81                         },\r
  82                         /**\r
  83                          * メモリを32bit読む\r
  84                          * <pre>\r
  85                          * SGET #0\r
  86                          * MGET #0,#0\r
  87                          * SPUT #0\r
  88                          * </pre>\r
  89                          * @private\r
  90                          */                     \r
  91                         getMem:function getMem(i_addr,i_db)\r
  92                         {\r
  93                                 try{\r
  94                                         i_db.push(i_addr);\r
  95                                         return "EA00DB0000EE00";\r
  96                                 }catch(e){\r
  97                                         throw new MiMicException(e);\r
  98                                 }                       \r
  99                         },\r
 100                         /**\r
 101                          * メモリを32bit読む\r
 102                          * <pre>\r
 103                          * SGET #0\r
 104                          * MGET #0,#0\r
 105                          * SPUT #0\r
 106                          * </pre>\r
 107                          @private\r
 108                          */\r
 109                         READMEM:"EA00DB0000EE00",\r
 110                         \r
 111                         /**\r
 112                          * BCフラグメントを終了する。\r
 113                          * <pre>\r
 114                          * EXIT;\r
 115                          * .END\r
 116                          * </pre>\r
 117                          @private\r
 118                          */\r
 119                         END:"ZZ.E"      \r
 120                 },\r
 121                 /**\r
 122                  * 機能名のテーブル。\r
 123                  * 機能名として使用できる文字列の一覧表である。機能名は、機能を識別する目的で定義する。\r
 124                  * この値は一覧の定義のみであるので、使用することは無い。\r
 125                  * <ul>\r
 126                  *      <li>GPIO - GPIO機能を表す。</li>\r
 127                  *      <li>AD - AD convert機能を表す。</li>\r
 128                  *      <li>DA - DA convert機能を表す。</li>\r
 129                  *      <li>PWM - PWM機能を表す。</li>\r
 130                  * </ul>\r
 131                  * @name LPCXpresso1769#FUNC_NAME\r
 132                  * @constant\r
 133                  * @field\r
 134                  */\r
 135                 FUNC_NAME:[\r
 136                         "GPIO","AD","DA","PWM"\r
 137                 ],\r
 138                 /**\r
 139                  * ペリフェラル名のテーブル。\r
 140                  * ペリフェラル名として使用できる文字列の一覧表である。ペリフェラル名は、ペリフェラルを識別する目的で定義する。\r
 141                  * この値は一覧の定義のみであるので、使用することは無い。
 142                  * <ul>\r
 143                  *      <li>GPIO - GPIO peripheral</li>\r
 144                  *      <li>ADC - AD peripheral</li>\r
 145                  *      <li>DAC - DA peripheral</li>\r
 146                  *      <li>PWM - PWM peripheral</li>\r
 147                  * </ul>\r
 148                  * @name LPCXpresso1769#PHL_NAME\r
 149                  * @constant\r
 150                  * @field\r
 151                  */\r
 152                 PHL_NAME:[\r
 153                         "GPIO","ADC","DAC","PWM"\r
 154                 ],\r
 155                 /**\r
 156                  * LPCXpressoのPeripheralパラメタを格納したテーブルである。要素はペリフェラル識別子である。\r
 157                  * UM10360のChapter 4: LPC17xx Clocking and power controlを元に定義している。\r
 158                  * ペリフェラル識別子はペリフェラルのレジスタ番号とビット番号を格納した配列である。\r
 159                  * <pre>\r
 160                  * PHL:{PHL_NAME:[PCLKSELreg#,PCLKSELbit#,PCONPbit#]}\r
 161                  * </pre>\r
 162                  * nullはそのビットが無効であることを示す。\r
 163                  * @name LPCXpresso1769#PHL\r
 164                  * @constant\r
 165                  * @field\r
 166                  * @example\r
 167                  * LPCXpresso1796.PHLADC //ADC peripheral\r
 168                  */\r
 169                 PHL:{\r
 170                         WDT:    [0,0,null],\r
 171                         TIMER0: [0,2,1],\r
 172                         TIMER1: [0,4,2],\r
 173                         UART0:  [0,6,3],\r
 174                         UART1:  [0,8,4],\r
 175                         PWM1:   [0,12,6],\r
 176                         I2C0:   [0,14,7],\r
 177                         SPI:    [0,16,8],\r
 178                         RTC:    [null,null,9],\r
 179                         SSPI1:  [0,20,10],\r
 180                         DAC:    [0,22,null],\r
 181                         ADC:    [0,24,12],\r
 182                         CAN1:   [0,26,13],\r
 183                         CAN2:   [0,28,14],\r
 184                         ACF:    [0,30,null],\r
 185                         QEI:    [1,0,18],\r
 186                         GPIOINT:[1,2,15],\r
 187                         PCB:    [1,4,null],\r
 188                         I2C1:   [1,6,19],\r
 189                         SSP0:   [1,10,21],\r
 190                         TIMER2: [1,12,22],\r
 191                         TIMER3: [1,14,23],\r
 192                         UART2:  [1,16,24],\r
 193                         UART3:  [1,18,25],\r
 194                         I2C2:   [1,20,26],\r
 195                         I2S:    [1,22,27],\r
 196                         RIT:    [1,26,16],\r
 197                         SYSCON: [1,28,null],\r
 198                         PWM_MC:[1,30,17],//MC?\r
 199                         GPDMA:[null,null,29],\r
 200                         ENET:[null,null,30],\r
 201                         USB:[null,null,31]\r
 202                 },\r
 203                 /**\r
 204                  * PCXpressoのPINに対応する識別子のテーブルである。要素はPIN識別子である。テーブルは、P0[n]~p4[m]まで存在する。\r
 205                  * ピン識別子は、ピンP?[?]を、P0[0]のように表現する。これは、UM10360のTable 73. Pin descriptionのSymbol P?[?]に対応している。\r
 206                  * Pn[m]のn,mの使用できる値は、Table 73. Pin descriptionに一致する。\r
 207                  * PIN識別子から値を取り出すときは、専用の関数を使用するべきである。\r
 208                  * ピン識別子は、ピンを制御するレジスタ番号とビット番号を格納した配列である。\r
 209                  * <pre>\r
 210                  * Pn:[[PINSELreg#,PINMODEreg#,PINMODEODreg#,bitidx,[ピン機能名]]]\r
 211                  * </pre>\r
 212                  * <ul>\r
 213                  * <li>PINFUNC,PINMODEのビット位置は、(bitidx%16)*2で計算する。ODRegについては、そのままの数値を使う。</li>\r
 214                  * <li>[ピン機能名]は、PINSEL設定値に対応するテーブルである。配列のインデクス値が、そのままPINSELの値に対応する。</li>\r
 215                  * <li>設定できない値のフィールドはnullである。ピン機能名はPin Function Select registerのテーブルの定義値そのもである。ただし、GPIOについては"GPIO Port "を"GPIO"に省略していることに注意。</li>\r
 216                  * <li>nullはそのビットが無効であることを示す。</li>\r
 217                  * </ul>\r
 218                  * @name LPCXpresso1769#P0\r
 219                  * @constant\r
 220                  * @field\r
 221                  * @example\r
 222                  * //1\r
 223                  * LPCXpresso1796.P0[0]; //P0[0]\r
 224                  * LPCXpresso1796.P1[1]; //P0[01]\r
 225                  * //2\r
 226                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 227                  * var gpiopin=mcu.getPin(LPCXpresso1769.P0[0],"GPIO");//bind P0[0] with GPIO function
 228                  */\r
 229                 P0:[\r
 230                         [0,0,0,0,["GPIO0.0","RD1","TXD3","SDA1"]],//0\r
 231                         [0,0,0,1,["GPIO0.1","TD1","RXD3","SCL1"]],//1\r
 232                         [0,0,0,2,["GPIO0.2","TXD0","AD0.7",null]],//2\r
 233                         [0,0,0,3,["GPIO0.3","RXD0","AD0.6",null]],//3\r
 234                         [0,0,0,4,["GPIO0.4","I2SRX_CLK","RD2","CAP2.0"]],//4\r
 235                         [0,0,0,5,["GPIO0.5","I2SRX_WS","TD2","CAP2.1"]],//5\r
 236                         [0,0,0,6,["GPIO0.6","I2SRX_SDA","SSEL1","MAT2.0"]],//6\r
 237                         [0,0,0,7,["GPIO0.7","I2STX_CLK","SCK1", "MAT2.1"]],//7\r
 238                         [0,0,0,8,["GPIO0.8","I2STX_WS","MISO1","MAT2.2"]],//8\r
 239                         [0,0,0,9,["GPIO0.9","I2STX_SDA","MOSI1","MAT2.3"]],//9\r
 240                         [0,0,0,10,["GPIO0.10","TXD2","SDA2","MAT3.0"]],//10\r
 241                         [0,0,0,11,["GPIO0.11","RXD2","SCL2","MAT3.1"]],//11\r
 242                         null,null,null,//12,13,14\r
 243                         [0,0,0,15,["GPIO0.15","TXD1","SCK0","SCK"]],//15\r
 244                         [1,1,0,16,["GPIO0.16","RXD1","SSEL0","SSEL"]],//16\r
 245                         [1,1,0,17,["GPIO0.17","CTS1","MISO0","MISO"]],//17\r
 246                         [1,1,0,18,["GPIO0.18","DCD1","MOSI0","MOSI"]],//18\r
 247                         [1,1,0,19,["GPIO0.19","DSR1",null,"SDA1"]],//19\r
 248                         [1,1,0,20,["GPIO0.20","DTR1",null,"SCL1"]],//20\r
 249                         [1,1,0,21,["GPIO0.21","RI1",null,"RD1"]],//21\r
 250                         [1,1,0,22,["GPIO0.22","RTS1",null,"TD1"]],//22\r
 251                         [1,1,0,23,["GPIO0.23","AD0.0","I2SRX_CLK","CAP3.0"]],//23\r
 252                         [1,1,0,24,["GPIO0.24","AD0.1","I2SRX_WS","CAP3.1"]],//24\r
 253                         [1,1,0,25,["GPIO0.25","AD0.2","I2SRX_SDA","TXD3"]],//25\r
 254                         [1,1,0,26,["GPIO0.26","AD0.3","AOUT","RXD3"]],//26\r
 255                         [1,null,null,22,["GPIO0.27","SDA0",     "USB_SDA",null]],//27\r
 256                         [1,null,null,24,["GPIO0.28","SCL0",     "USB_SCL",null]],//28\r
 257                         [1,null,0,29,["GPIO0.29","USB_D+",null,null]],//29\r
 258                         [1,null,0,30,["GPIO0.30","USB_D-",null,null]],//30\r
 259                         ],\r
 260                 /**\r
 261                  * P1に対する定義である。詳細はP0のドキュメントを参照。
 262                  * @name LPCXpresso1769#P1\r
 263                  * @constant\r
 264                  * @field\r
 265                  * @see LPCXpresso1769#P0
 266                  */\r
 267                 P1:[    //P1[x]\r
 268                         [2,2,1,0,["GPIO1.0","ENET_TXD0",null,null]],//0\r
 269                         [2,2,1,1,["GPIO1.1","ENET_TXD1",null,null]],//1\r
 270                         null,null,//2,3\r
 271                         [2,2,1,4,["GPIO1.4","ENET_TX_EN",null,null]],//4\r
 272                         null,null,null,//5,6,7\r
 273                         [2,2,1,8,["GPIO1.8","ENET_CRS",null,null]],//8\r
 274                         [2,2,1,9,["GPIO1.9","ENET_RXD0",null,null]],//9\r
 275                         [2,2,1,10,["GPIO1.10","ENET_RXD1",null,null]],//10\r
 276                         null,null,null,//11,12,13\r
 277                         [2,2,1,14,["GPIO1.14","ENET_RX_ER",null,null]],//14\r
 278                         [2,2,1,15,["GPIO1.15","ENET_REF_CLK",null,null]],//15\r
 279                         [3,3,1,16,["GPIO1.16","ENET_MDC",null,null]],//16\r
 280                         [3,3,1,17,["GPIO1.17","ENET_MDIO",null,null]],//17\r
 281                         [3,3,1,18,["GPIO1.18","USB_UP_LED","PWM1.1","CAP1.0"]],//18\r
 282                         [3,3,1,19,["GPIO1.19","MCOA0","USB_PPWR","CAP1.1"]],//19\r
 283                         [3,3,1,20,["GPIO1.20","MCI0","PWM1.2","SCK0"]],//20\r
 284                         [3,3,1,21,["GPIO1.21","MCABORT","PWM1.3","SSEL0"]],//21\r
 285                         [3,3,1,22,["GPIO1.22","MCOB0","USB_PWRD","MAT1.0"]],//22\r
 286                         [3,3,1,23,["GPIO1.23","MCI1","PWM1.4","MISO0"]],//23\r
 287                         [3,3,1,24,["GPIO1.24","MCI2","PWM1.5","MOSI0"]],//24\r
 288                         [3,3,1,25,["GPIO1.25","MCOA1",null,"MAT1.1"]],//25\r
 289                         [3,3,1,26,["GPIO1.26","MCOB1","PWM1.6","CAP0.0"]],//26\r
 290                         [3,3,1,27,["GPIO1.27","CLKOUT","USB_OVRCR","CAP0.1"]],//27\r
 291                         [3,3,1,28,["GPIO1.28","MCOA2","PCAP1.0","MAT0.0"]],//28\r
 292                         [3,3,1,29,["GPIO1.29","MCOB2","PCAP1.1","MAT0.1"]],//29\r
 293                         [3,3,1,30,["GPIO1.30",null,"VBUS","AD0.4"]],//30\r
 294                         [3,3,1,31,["GPIO1.31",null,"SCK1","AD0.5"]],//31\r
 295                         ],\r
 296                 /**\r
 297                  * P2に対する定義である。詳細はP0のドキュメントを参照。\r
 298                  * @name LPCXpresso1769#P2\r
 299                  * @constant\r
 300                  * @field\r
 301                  * @see LPCXpresso1769#P0\r
 302                  */\r
 303                 P2:[    //P2[x]\r
 304                         [4,4,2,0,["GPIO2.0","PWM1.1","TXD1",null]],//0\r
 305                         [4,4,2,1,["GPIO2.1","PWM1.2","RXD1",null]],//1\r
 306                         [4,4,2,2,["GPIO2.2","PWM1.3","CTS1",null]],//2\r
 307                         [4,4,2,3,["GPIO2.3","PWM1.4","DCD1",null]],//3\r
 308                         [4,4,2,4,["GPIO2.4","PWM1.5","DSR1",null]],//4\r
 309                         [4,4,2,5,["GPIO2.5","PWM1.6","DTR1",null]],//5\r
 310                         [4,4,2,6,["GPIO2.6","PCAP1.0","RI1",null]],//6\r
 311                         [4,4,2,7,["GPIO2.7","RD2","RTS1",null]],//7\r
 312                         [4,4,2,8,["GPIO2.8","TD2","TXD2","ENET_MDC"]],//8\r
 313                         [4,4,2,9,["GPIO2.9","USB_CONNECT","RXD2","ENET_MDIO"]],//9\r
 314                         [4,4,2,10,["GPIO2.10","EINT0","NMI",null]],//10\r
 315                         [4,4,2,11,["GPIO2.11","EINT1",null,"I2STX_CLK"]],//11\r
 316                         [4,4,2,12,["GPIO2.12","EINT2",null,"I2STX_WS"]],//12\r
 317                         [4,4,2,13,["GPIO2.13","EINT3",null,"I2STX_SDA"]],//13\r
 318                         ],\r
 319                 /**\r
 320                  * P3に対する定義である。詳細はP0のドキュメントを参照。\r
 321                  * @name LPCXpresso1769#P3\r
 322                  * @constant\r
 323                  * @field\r
 324                  * @see LPCXpresso1769#P0\r
 325                  */\r
 326                 P3:[    //P3[x]\r
 327                         null/* 0*/,null/* 1*/,null/* 2*/,null/* 3*/,null/* 4*/,null/* 5*/,null/* 6*/,null/* 7*/,null/* 8*/,null/* 9*/,\r
 328                         null/*10*/,null/*11*/,null/*12*/,null/*13*/,null/*14*/,null/*15*/,null/*16*/,null/*17*/,null/*18*/,null/*19*/,\r
 329                         null/*20*/,null/*21*/,null/*22*/,null/*23*/,null/*24*/,\r
 330                         [7,7,3,25,["GPIO3.25",null,"MAT0.0","PWM1.2"]],//25\r
 331                         [7,7,3,26,["GPIO3.26","STCLK","MAT0.1","PWM1.3"]],//26\r
 332                 ],\r
 333                 /**\r
 334                  * P4に対する定義である。詳細はP0のドキュメントを参照。\r
 335                  * @name LPCXpresso1769#P4\r
 336                  * @constant\r
 337                  * @field\r
 338                  * @see LPCXpresso1769#P0\r
 339                  */\r
 340                 P4:[    //P4[x]\r
 341                         null/* 0*/,null/* 1*/,null/* 2*/,null/* 3*/,null/* 4*/,null/* 5*/,null/* 6*/,null/* 7*/,null/* 8*/,null/* 9*/,\r
 342                         null/*10*/,null/*11*/,null/*12*/,null/*13*/,null/*14*/,null/*15*/,null/*16*/,null/*17*/,null/*18*/,null/*19*/,\r
 343                         null/*20*/,null/*21*/,null/*22*/,null/*23*/,null/*24*/,null/*25*/,null/*26*/,null/*27*/,\r
 344                         [9,9,4,28,["GPIO4.28","RX_MCLK","MAT2.0","TXD3"]],//28\r
 345                         [9,9,4,29,["GPIO4.29","TX_MCLK","MAT2.1","RXD3"]]//29\r
 346                 ],\r
 347                 /**\r
 348                  * [forSystem]ピン識別子のアクセス関数である。\r
 349                  * ピン機能シンボルのプレフィクス（機能シンボル）を、 ピン識別子を元に、完全な名称に変換する。\r
 350                  * ピンにFunctionが含まれているか調べることが出来る。\r
 351                  * @private\r
 352                  */\r
 353                 completePinFunctionName:function completePinFunctionName(i_pin,i_prefix)\r
 354                 {\r
 355                         try{\r
 356                                 //配列探索\r
 357                                 for(var i=0;i<i_pin[4].length;i++){\r
 358                                         if(i_pin[4][i].indexOf(i_prefix)==0){\r
 359                                                 //ピン情報の構成\r
 360                                                 return i_pin[4][i];\r
 361                                         }\r
 362                                 }\r
 363                                 throw new MiMicException("The function name '"+i_prefix+"' is not unknown.");\r
 364                         }catch(e){\r
 365                                 throw new MiMicException(e);\r
 366                         }\r
 367                 },\r
 368                 /**\r
 369                  * [forSystem]ピン識別子のアクセス関数。\r
 370                  * ピン識別値から、Pinレジスタの番号と、ビット位置を取り出す。\r
 371                  * @private\r
 372                  * @return\r
 373                  * {s:pinselのレジスタ番号、m:modeのレジスタ番号、,o:odのレジスタ番号,sbm:mode,selのビット位置,ob:odのビット位置}
 374                  */\r
 375                 getPinRegInfo:function getPinRegInfo(i_pin)\r
 376                 {\r
 377                         try{\r
 378                                 return {s:i_pin[0],m:i_pin[1],o:i_pin[2],smb:(i_pin[3]%16)*2,ob:i_pin[3]};\r
 379                         }catch(e){\r
 380                                 throw new MiMicException(e);\r
 381                         }\r
 382                 },\r
 383                 /**\r
 384                  * [forSystem]ピン識別子のアクセス関数。\r
 385                  * PIN機能名に一致するPinsel値を取り出す。\r
 386                  * @private\r
 387                  */\r
 388                 getPinSelByFunctionName:function getPinSelByFunctionName(i_pin,i_name)\r
 389                 {\r
 390                         try{\r
 391                                 for(var i=0;i<i_pin[4].length;i++){\r
 392                                         if(i_pin[4][i]==i_name){\r
 393                                                 //ピン情報の構成\r
 394                                                 return i;\r
 395                                         }\r
 396                                 }\r
 397                                 throw new MiMicException("The function name '"+i_name+"' has not function.");\r
 398                         }catch(e){\r
 399                                 throw new MiMicException(e);\r
 400                         }\r
 401                 },\r
 402                 /**\r
 403                  * [forSystem]ピンが、ピン機能シンボルを持つか返す。\r
 404                  * @private\r
 405                  */\r
 406                 hasPinFunctionName:function hasPinFunctionName(i_pin,i_name)\r
 407                 {\r
 408                         return i_pin[4].indexOf(i_name)>=0;\r
 409                 }\r
 410         }\r
 411 \r
 412 /**\r
 413  * @private
 414  */\r
 415 DEV.I2c=function I2c()\r
 416 {\r
 417         throw new MiMicException("Not imprement.");\r
 418 }\r
 419 \r
 420 /**\r
 421  * @private\r
 422  */\r
 423 DEV.Dma=function Dma()\r
 424 {\r
 425         throw new MiMicException("Not imprement.");\r
 426 }\r
 427 /**\r
 428  * @private\r
 429  */\r
 430 DEV.Uart=function Uart()\r
 431 {\r
 432         throw new MiMicException("Not imprement.");\r
 433 }\r
 434 /**\r
 435  * @private\r
 436  */\r
 437 DEV.Usb=function Usb()\r
 438 {\r
 439         throw new MiMicException("Not imprement.");\r
 440 }\r
 441 \r
 442 \r
 443 LPCXpresso1769=DEV;\r
 444 }());\r
 445 \r
 446 /**\r
 447  * @fileOverview LPCXpresso1769のMCU制御クラスを定義する。\r
 448  */\r
 449 (function(){\r
 450         /** @ignore */\r
 451         var DEV=LPCXpresso1769;\r
 452         var BCF=DEV._BCF;\r
 453         var EE=DEV._EE;\r
 454         var isUndef=MiMicLib.isUndef;\r
 455 \r
 456         /**\r
 457          * 配列をMiMicDBへ変換する。\r
 458          @private\r
 459          @throws\r
 460          変換失敗時は例外\r
 461          */\r
 462         function array2MimicDb(i_array)\r
 463         {\r
 464                 try{\r
 465                         var p="";\r
 466                         for(var i=0;i<i_array.length;i++){\r
 467                                 p+=MiMicLib.hexout(i_array[i],8);\r
 468                         }\r
 469                         return p;\r
 470                 }catch(e){\r
 471                         throw new MiMicException(e);\r
 472                 }\r
 473         }\r
 474         \r
 475         /**\r
 476          * PINの機能名を含むPin識別子を得る。\r
 477          @private\r
 478          */\r
 479         function getPinByFuncName(i_name)\r
 480         {\r
 481                 try{\r
 482                         function getPinByFName(i_pintbl,i_name)\r
 483                         {\r
 484                                 for(var i=0;i<i_pintbl.length;i++){\r
 485                                         if(i_pintbl[i]==null){\r
 486                                                 continue;\r
 487                                         }\r
 488                                         if(DEV.hasPinFunctionName(i_pintbl[i],i_name)){\r
 489                                                 return i_pintbl[i];\r
 490                                         }\r
 491                                 }\r
 492                                 return null;\r
 493                         }\r
 494                         var tbl=[DEV.P0,DEV.P1,DEV.P2,DEV.P3,DEV.P4];\r
 495                         for(var i=0;i<tbl.length;i++){\r
 496                                 var pin=getPinByFName(tbl[i],i_name);\r
 497                                 if(pin!=null){\r
 498                                         return pin;\r
 499                                 }\r
 500                         }\r
 501                         throw new MiMicException("pin function '"+i_name+"' not found");\r
 502                 }catch(e){\r
 503                         throw new MiMicException(e);\r
 504                 }\r
 505         }\r
 506         /**\r
 507          * PIN機能名から使用するペリフェラルシンボルを推定する。\r
 508          @private
 509          */\r
 510         function pinFuncName2PhlName(i_pinfuncname)\r
 511         {\r
 512                 try{\r
 513                         //Pin function nameプレフィクスとペリフェラル名の対比表\r
 514                         var TBL={\r
 515                                 "GPIO":"GPIO",\r
 516                                 "AD":"ADC",\r
 517                                 "DA":"DAC"\r
 518                         };\r
 519                         for(var key in TBL){\r
 520                                 if(i_pinfuncname.indexOf(key)==0){\r
 521                                         return TBL[key];\r
 522                                 }\r
 523                         }\r
 524                         //見つからぬ。\r
 525                         throw new MiMicException("Peripheral for "+i_pinfunction+" not found.");\r
 526                 }catch(e){\r
 527                         throw new MiMicException(e);\r
 528                 }\r
 529         }\r
 530         \r
 531         /**\r
 532          * LPCXPresso1769.MCU(MCU)クラスのコンストラクタ。\r
 533          * MCUクラスは、物理MCUとのインタフェイスを定義する。MiMicRemoteMcuInterfaceの管理機能と、MCUの物理機能への接続手段を定義する。\r
 534          * 提供する機能は次のリストである。\r
 535          * <ul>\r
 536          * <li>物理MCUとの接続管理機能。\r
 537          * <li>MCUの管理するペリフェラル操作インスタンスの生存管理機能。\r
 538          * <li>MCUの持つ物理デバイスの操作オブジェクト(Pin,Peripheral等)の生成機能（インテリジェント接続）。\r
 539          * </ul>\r
 540          * @name LPCXpresso1769.Mcu\r
 541          * @constructor\r
 542          * @param {string} i_mimic_addr\r
 543          * 接続するMiMicRemoteMcuのホストアドレスを指定する。IPアドレス、ホスト名等。\r
 544          * <pre>ex. “127.0.0.1” , “127.0.0.1:3939”</pre>\r
 545          * @param {boolean} i_is_activate\r
 546          * インスタンス生成と同時にMiMicRemoteMcuとの接続を確立するかのフラグ。省略時はtrueとみなす。\r
 547          * trueの場合、関数は即座にMiMicRemoteMCUに接続する。このとき、events.onActivateChangedをハンドリングすることが出来ないので注意すること。ハンドリングが必要なら、falseを指定して、改めてactivate関数をコールする。\r
 548          * @example\r
 549          * //create a controlable MCU via network.\r
 550          * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 551          */\r
 552         DEV.Mcu=function Mcu(i_mimic_addr,i_is_activate)\r
 553         {\r
 554                 try{\r
 555                         //メンバの初期化\r
 556                         this.events={onActivateChanged:null};\r
 557                         this._phl_holder=[];\r
 558                         //リモートインタフェイスの取得\r
 559                         this._mif=new MiMicRemoteMcuInterface(i_mimic_addr);\r
 560                         var ac=isUndef(i_is_activate)?true:i_is_activate;\r
 561                         if(ac){\r
 562                                 this.activate();\r
 563                         };\r
 564                 }catch(e){\r
 565                         throw new MiMicException(e);\r
 566                 }\r
 567         };\r
 568 \r
 569         DEV.Mcu.prototype=\r
 570         {\r
 571                 /**\r
 572                  * MiMicInterface\r
 573                  @private
 574                  */\r
 575                 _mif:null,\r
 576                 /**\r
 577                  * インスタンスがMCUと接続されているかをtrue/falseで返す。\r
 578                  * @name LPCXpresso1769.Mcu#isActive\r
 579                  * @function\r
 580                  * @return {boolean}\r
 581                  * インスタンスが接続中ならtrue\r
 582                  * @example\r
 583                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”,false);\r
 584                  * mcu.events.onActivateChanged=function(f){\r
 585                  *      if(!f){alert(f)};\r
 586                  *      }\r
 587                  * mcu.activate(); \r
 588                  */\r
 589                 isActive:function isActive()\r
 590                 {\r
 591                         try{\r
 592                                 return this._mif.isConnected();\r
 593                         }catch(e){\r
 594                                 throw new MiMicException(e);\r
 595                         }\r
 596                 },\r
 597                 \r
 598                 /**\r
 599                  * イベントハンドラの連想配列。メンバにイベントハンドラ関数を格納する。\r
 600                  イベントハンドラは以下の通り。\r
 601                  <ul>\r
 602                  <li>onActivateChanged as function(f:boolean) - インスタンスのアクティブ状態が変化したときに呼び出されるイベントである。fパラメータには、状態変化後のアクティブ状態値が入る。このハンドラが呼び出されるのは、ユーザが状態を切り替えたときと、システムが状態を維持できなくなったとき（例えばMCUが応答しない）である。</li>\r
 603                  </ul>\r
 604                  * @name LPCXpresso1769.Mcu#events\r
 605                  * @field\r
 606                  * @example\r
 607                  * //show that MCU became active. \r
 608                  * var mcu=new LPCXpresso1769.Mcu("192.168.0.39",false);\r
 609                  * mcu.events.onActivateChanged=function(f){\r
 610                  *      if(!f){alert(f)};\r
 611                  * }\r
 612                  * mcu.activate();               \r
 613                  */\r
 614                 events:null,\r
 615                 /**\r
 616                  * ペリフェラルオブジェクトのホルダ。ペリフェラル名をキーにした、ペリフェラルオブジェクトの連想配列。\r
 617                  * MCUが、自身のペリフェラルオブジェクトを管理する為に使う。\r
 618                  * @private\r
 619                  */\r
 620                 _phl_holder:null,\r
 621                 /**\r
 622                  * SystemClockに関する情報を返す。\r
 623                  * @name LPCXpresso1769.Mcu#getClockInfo\r
 624                  * @function\r
 625                  * @return {cclk:MCUクロック [Hz] as int}\r
 626                  * クロック値を格納した連想配列である。\r
 627                  * @example\r
 628                  * // alert MCU clock\r
 629                  * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
 630                  * alert(mcu.getClockInfo().cclk);\r
 631                  */\r
 632                 getClockInfo:function getClockInfo()\r
 633                 {\r
 634                         //CCLCK値(RemoteMCU側と合わせること。将来的にはactivateの時に決定する。)\r
 635                         return {cclk:100*1000*1000};\r
 636                 },\r
 637                 /**\r
 638                  * インスタンスの状態をアクティブに切り替える。\r
 639                  * アクティブ化に成功すると、インスタンスは物理MCUと接続状態になる。\r
 640                  * コンストラクタで生成と同時にアクティブ化した場合は、コンストラクタ内で自動的にコールされる。\r
 641                  * 既にアクティブの場合、アクティブ化に失敗した場合に例外が発生する。\r
 642                  * @name LPCXpresso1769.Mcu#activate\r
 643                  * @function\r
 644                  * @example\r
 645                  * // MCU will be active.\r
 646                  * var mcu=new LPCXpresso1769.Mcu("192.168.0.39",false);\r
 647                  * mcu.activate();\r
 648                  */\r
 649                 activate:function activate()\r
 650                 {\r
 651                         try{\r
 652                                 var _t=this;\r
 653                                 //既にアクティブならエラー。\r
 654                                 if(this.isActive()){\r
 655                                         throw new MiMicException("Already activated!");\r
 656                                 }\r
 657                                 //接続\r
 658                                 this._mif.connect(\r
 659                                         function(b){\r
 660                                                 if(!b){\r
 661                                                         //非同期切断を検出。\r
 662                                                         if(_t.events.onActivateChanged!=null){\r
 663                                                                 _t.events.onActivateChanged(false);\r
 664                                                         }\r
 665                                                 }\r
 666                                         }\r
 667                                 );\r
 668                                 if(this.events.onActivateChanged!=null){\r
 669                                         this.events.onActivateChanged(true);\r
 670                                 }\r
 671                         }catch(e){\r
 672                                 throw new MiMicException(e);\r
 673                         }\r
 674                 },\r
 675                 /**\r
 676                  * インスタンスの状態を非アクティブに切り替える。\r
 677                  * 成功すると、インスタンスと物理MCUは切断状態になる。\r
 678                  * 既に非アクティブの場合、例外が発生する。\r
 679                  * @name LPCXpresso1769.Mcu#deactivate\r
 680                  * @function\r
 681                  * @example\r
 682                  * // MCU will be deactive.\r
 683                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 684                  * mcu.events.onActivateChanged=function(f){\r
 685                  *      if(!f){alert(f)};\r
 686                  * }\r
 687                  * mcu.deactivate();\r
 688                  */\r
 689                 deactivate:function deactivate()\r
 690                 {\r
 691                         try{\r
 692                                 if(!this.isActive()){\r
 693                                         throw new MiMicException("Already activated!");\r
 694                                 }\r
 695         \r
 696                                 this._mif.disconnect();\r
 697                                 if(this.events.onActivateChanged!=null){\r
 698                                         this.events.onActivateChanged(false);\r
 699                                 }\r
 700                         }catch(e){\r
 701                                 throw new MiMicException(e);\r
 702                         }\r
 703                 },\r
 704                 /**\r
 705                  * 整形済みのMiMicBCを送信する。整形済みのMiMicBCは、MiMicTXT,MiMicDBを連結した文字列である。固定命令を送信するときに使う。\r
 706                  * @name LPCXpresso1769.Mcu#callMiMic^2\r
 707                  * @function\r
 708                  * @param {string} i_mimicbc\r
 709                  * MiMicBC。MiMicBCのフォーマットは、MiMicVM.pdf MiMicBCで定義する。\r
 710                  * @return {object as {MiMic result}}\r
 711                  * @example\r
 712                  * //send MiMic operations.\r
 713                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 714                  * mcu.callMiMic(“ZAZZ.E”);//NOP .END       \r
 715                  */\r
 716                 /**\r
 717                  * 整形済みのMiMicTXTと、数値配列のMiMicDBを連結して送信する。固定命令+パラメータで擬似関数を実現するときに便利である。
 718                  * @name LPCXpresso1769.Mcu#callMiMic^3\r
 719                  * @function\r
 720                  * @param {string} i_mimictxt\r
 721                  * MiMicTXT。MiMicTXTのフォーマットは、MiMicVM.pdf MiMicBCで定義する。\r
 722                  * @param {Array[int]} mimicdb\r
 723                  * 配列のINT値。値は関数によりMiMicDBに変換され、MiMicTXTに連結され、送信される。          \r
 724                  * @return {object as {MiMic result}}\r
 725                  * @example\r
 726                  * //send MiMic operations.\r
 727                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 728                  * mcu.callMiMic(“ZAZZ.E”,[]); //NOP .END\r
 729                  */\r
 730                 /**\r
 731                  * MiMicBCをリンクしているMCUへMiMic Low level APIで同期送信し、結果を取得する。\r
 732                  * MiMic Low level APIのresult値が得られない場合、例外が発生する。この状況は、TCP/IPエラー、HTTPエラー、HTTPステータスエラー、MiMicVMのラインタイムエラー、MiMicRemoteMCUのフォールト等の原因で発生する。\r
 733                  * 関数が値を返した場合は、MiMicRemoteMCUが処理を完了し、正しい形式のステータスを受信できた場合である。例外が発生した場合は、リンクが破壊されている場合がある。リンクが破壊された場合は、1分以内にアクティブ状態が変化するので、それを検出して判断する。<br/>\r
 734                  * 引数の違いにより、数種類の呼び出し方がある。詳細は、callMiMic^nを参照。\r
 735                  * @name LPCXpresso1769.Mcu#callMiMic^1\r
 736                  * @function\r
 737                  * @param ...\r
 738                  * LPCXpresso1769.Mcu#callMiMic^nを参照\r
 739                  * @return {object as {MiMic result}}\r
 740                  * 応答値を格納した連想配列である。\r
 741                  * 詳細は 低レベルAPI。MiMicRemoteMcuInterface.execBc関数、または、MiMicVM.pdf Appendix 1. MiMicVM HTTP Interfaceを参照。 \r
 742                  */\r
 743                 callMiMic:function callMiMic(/**/)\r
 744                 {\r
 745                         try{\r
 746                                 var bc;\r
 747                                 switch(arguments.length){\r
 748                                 case 1:\r
 749                                         //mimicBC\r
 750                                         bc=arguments[0];\r
 751                                         break;\r
 752                                 case 2:\r
 753                                         //mimicBC:string,db:array[int]\r
 754                                         bc=arguments[0]+array2MimicDb(arguments[1]);\r
 755                                         break;\r
 756                                 default:\r
 757                                         throw new MiMicException(e);\r
 758                                 }\r
 759                                 return this._mif.execBc(bc);\r
 760                         }catch(e){\r
 761                                 throw new MiMicException(e);\r
 762                         }\r
 763                 },\r
 764                 /**\r
 765                  * callMiMic関数のラッパーである。\r
 766                  * callMiMic関数成功後に、resultが成功(MVM_OK=0x0)であるかを確認し、それ以外であれば例外を発生させる。\r
 767                  * resultが0以外想定されないMiMicBCを実行するときに、便利である。<br/>\r
 768                  * 引数、戻り値については、callMiMic関数を参照。\r
 769                  * @name LPCXpresso1769.Mcu#callMiMicWithCheck\r
 770                  * @function\r
 771                  * @example\r
 772                  * //send 2 MiMic operations.\r
 773                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 774                  * mcu.callMiMicWithCheck(“ZAZZ.E”,[]);\r
 775                  * mcu.callMiMicWithCheck(“ZAZZ.ENOOOO”);//exception!\r
 776                  */\r
 777                 callMiMicWithCheck:function execBc2WithException(/**/)\r
 778                 {\r
 779                         try{\r
 780                                 var ret=this.callMiMic.apply(this,arguments);\r
 781                                 if(ret.result!=0x0){\r
 782                                         throw new MiMicException(EE.VM_RUNTIME,"Result="+ret.toString());\r
 783                                 }\r
 784                                 return ret;\r
 785                         }catch(e){\r
 786                                 throw new MiMicException(e);\r
 787                         }\r
 788                 },\r
 789                 /**\r
 790                  * ピン機能名から、Pinインスタンスを生成する。\r
 791                  * 生成されたピンは、ピン機能名の割り当てられている物理ピンで実現される。\r
 792                  * ピン機能名は、 LPCXpresso1769.P?[?]の[ピン機能名]で定義する文字列である。これは、UM10360　3.1.2.3  Chapter 8: LPC17xx Pin connect blockのfunction nameで定義される、PINSELレジスタに設定する文字列と一致する。
 793                  * @name LPCXpresso1769.Mcu#getPin^2\r
 794                  * @function\r
 795                  * @param {string} i_pin_function_name\r
 796                  * ピン機能名の文字列。 ex. “GPIO0.0” ,”AD0.0”\r
 797                  * GPIOについては、”GPIO Port 0.0”を”GPIO0.0”のように、省略すること。                 \r
 798                  * @return {object as PinObject}\r
 799                  * @example\r
 800                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 801                  * //create gpio pin at PIN0[0]\r
 802                  * var gpiopin1=mcu.getPin("GPIO0.0");\r
 803                  */\r
 804                 /**\r
 805                  * ピン識別子と機能名から、機能を割り当てたピンを生成する。組み合せにより、ピンを生成できない可能性もある。\r
 806                  * 組み合わせは、UM10360 3.1.2.3  Chapter 8: LPC17xx Pin connect blockを参照すること。\r
 807                  * @name LPCXpresso1769.Mcu#getPin^3\r
 808                  * @function\r
 809                  * @param {object as pin識別子} i_pin\r
 810                  * ピン識別子。指定できるのは、LPCXpresso1796.P?[?]である。\r
 811                  * @param {string as 機能名} i_function_name\r
 812                  * 機能名の文字列である。 指定できる文字列は、LPCXpresso1769.FUNC_NAMEで定義する。\r
 813                  * @return {object as PinObject}\r
 814                  * @example\r
 815                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 816                  *\r
 817                  * //create gpio pin at PIN0[1]\r
 818                  * var gpiopin2=mcu.getPin(LPCXpresso1769.P0[1],"GPIO");\r
 819                  * //or  mcu.getPin(LPCXpresso1769.P0[1],LPCXpresso1769.FUNC_SYMBOL.GPIO);\r
 820                  *\r
 821                  * //create AD at PIN0[23]\r
 822                  * var adpin1=mcu.getPin(LPCXpresso1769.P0[23],"AD"); \r
 823                  * //or  mcu.getPin(LPCXpresso1769.P0[23],LPCXpresso1769.FUNC_SYMBOL.AD);\r
 824                  *\r
 825                  * //create AD at PIN0[3] (exception)\r
 826                  * var adpin2=mcu.getPin(LPCXpresso1769.P0[3],"AD");\r
 827                  */\r
 828                 /**\r
 829                  * 物理ピンを制御するPinインスタンスを得る。\r
 830                  * 制御ペリフェラル、Pinを順に生成する方法と異なり、機能の実現に必要なインスタンスを自動的に準備できる。\r
 831                  * Pinが生成できない場合、例外が発生する。\r
 832                  * ペリフェラルが自動生成された場合、そのオプションはデフォルト値が採用される。既に生成済みのペリフェラルの場合は何もしない。PINのオプションは、デフォルト値が採用される。\r
 833                  * 引数の違いにより、数種類の呼び出し方がある。\r
 834                  * @name LPCXpresso1769.Mcu#getPin^1\r
 835                  * @function\r
 836                  * @param ...\r
 837                  * LPCXpresso1769.Mcu#getPin^nを参照\r
 838                  * @return {object as PinObject}\r
 839                  * 返却されるPinインスタンスの型は、機能により異なる。機能とPinインスタンスのクラスの対応は、以下の通りである。\r
 840                  * <ul>\r
 841                  * <li>GPIO - LPCXpresso1769.GpioPin</li>\r
 842                  * <li>AD - LPCXpresso1769.AdcPin</li>\r
 843                  * <li>PWM - LPCXpresso1769.PwmPin</li>\r
 844                  * </ul>\r
 845                  */\r
 846                 getPin:function getPin(/*...*/)\r
 847                 {\r
 848                         switch(arguments.length){\r
 849                         case 1://getPin:function getPin(i_pin_function)\r
 850                                 //pin_functionを持ってるPINを探す。\r
 851                                 var pin=getPinByFuncName(arguments[0]);\r
 852                                 //function名からペリフェラル名を得る。\r
 853                                 var phl_name=pinFuncName2PhlName(arguments[0]);\r
 854                                 //ピンコンストラクタとペリフェラルを使ってピンを生成。\r
 855                                 return this.getPeripheral(phl_name).getPin(pin);\r
 856                         case 2://getPin:function getPin(i_pin,i_function_name)\r
 857                                 //function名からペリフェラル名を得る。(PINシンボル変換を流用)\r
 858                                 var phl_name=pinFuncName2PhlName(arguments[1]);\r
 859                                 return this.getPeripheral(phl_name).getPin(arguments[0]);\r
 860                         default:\r
 861                                 throw new MiMicException();\r
 862                         }\r
 863                 },\r
 864                 /**\r
 865                  * ポート（複数ピンで構成するIO）を制御するPortインスタンスを得るする。\r
 866                  * 制御ペリフェラル、Portを順に生成する方法と異なり、機能の実現に必要なインスタンスを自動的に生成する。\r
 867                  * Portが生成できない場合、例外が発生する。\r
 868                  * @name LPCXpresso1769.Mcu#getPort\r
 869                  * @function \r
 870                  * @param {array[PIN識別子]} i_pins\r
 871                  * ポートを構成するピン識別子の配列。順序は生成するポートの説明を参照。\r
 872                  * @param {string} i_function_name\r
 873                  * 機能名の文字列である。 指定できる文字列は、LPCXpresso1769.FUNC_NAMEで定義する。\r
 874                  * @return {object as PortObject}\r
 875                  * 返却されるインスタンスのクラスは、機能により異なる。機能とインスタンスのクラスの対応は、以下の通りである。\r
 876                  * <ul>\r
 877                  * <li>GPIO - LPCXpresso1769.GpioPin</li>\r
 878                  * <li>AD - LPCXpresso1769.AdcPin</li>\r
 879                  * <li>PWM - LPCXpresso1769.PwmPin</li>\r
 880                  * </ul>                 \r
 881                  */\r
 882                 getPort:function getPort(i_pins,i_function_name)\r
 883                 {\r
 884                         switch(arguments.length){\r
 885                         case 2://getPin:function getPin(i_pins,i_function_name)\r
 886                                 //function名からペリフェラル名を得る。(PINシンボル変換を流用)\r
 887                                 var phl_name=pinFuncName2PhlName(i_function_name);\r
 888                                 return this.getPeripheral(phl_name).getPort(i_pins);\r
 889                         default:\r
 890                                 throw new MiMicException();\r
 891                         }\r
 892                 },\r
 893                 /**\r
 894                  * ペリフェラル名から、ペリフェラルオブジェクトを得る。\r
 895                  * 関数は、初めて要求されたペリフェラルについては、オブジェクトを生成し、MCUインスタンスに保存する。同じ名前のペリフェラルが再度要求されると、過去に生成したペリフェラルを返す。\r
 896                  * @name LPCXpresso1769.Mcu#getPeripheral\r
 897                  * @function\r
 898                  * @param {string as ペリフェラル名} i_phl_name\r
 899                  * ペリフェラル名は文字列である。指定できる文字列は、LPCXpresso1769.PHL_NAMEで定義する。\r
 900                  * @param {object as ペリフェラルオプション} i_opt\r
 901                  * ペリフェラルに渡すオプション値である。省略可能。ペリフェラルが新しく生成される場合（はじめてペリフェラルが設定されようとしているとき）に、コンストラクタのi_optに設定する。2回目以降の参照で設定されると、例外を発生する。値の構文は、取得しようとするペリフェラルのsetOpt関数のi_optパラメータの説明を参照すること。               \r
 902                  * @return {object as Peripheral}\r
 903                  * 返却されるインスタンスのクラスは、ペリフェラル名により異なる。その対応は以下の通りである。\r
 904                  * <ul>\r
 905                  *      <li>GPIO - LPCXpresso1769.Gpio</li>\r
 906                  *      <li>ADC - LPCXpresso1769.Adc</li>\r
 907                  *      <li>PWM - LPCXpresso1769.Pwm</li>\r
 908                  * </ul>\r
 909                  * @example\r
 910                  * //get GPIO peripheral\r
 911                  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 912                  * var gpio=mcu.getPeripheral(“GPIO”);               \r
 913                  */\r
 914                 getPeripheral:function getPeripheral(i_phl_symbol,i_opt)\r
 915                 {\r
 916                         //ペリフェラルアイテムが生成済か確認\r
 917                         if(isUndef(this._phl_holder[i_phl_symbol])){\r
 918                                 //存在しなければPhlを生成。\r
 919                                 switch(i_phl_symbol){\r
 920                                 case "GPIO":new DEV.Gpio(this,i_opt);break;\r
 921                                 case "ADC":new DEV.Adc(this,i_opt);break;\r
 922                                 case "PWM":new DEV.Pwm(this,i_opt);break;\r
 923                                 default:\r
 924                                         throw new MiMicException("Unknown peripheral symbol "+i_phl_symbol);\r
 925                                 }\r
 926                         }else{\r
 927                                 //2回目以降でi_optが設定されている？それはだめだよ。\r
 928                                 if(!isUndef(i_opt)){\r
 929                                         throw new MiMicException();\r
 930                                 }\r
 931                         }\r
 932                         //phlからregisterのコールバックがかかるはず。\r
 933                         return this._phl_holder[i_phl_symbol];\r
 934                 },\r
 935                 /**\r
 936                  * [forSystem]システム関数。MCU依存のペリフェラルオブジェクトを登録する。\r
 937                  @private
 938                  */\r
 939                 registerPhl:function registerPhl(i_phl,i_symbol)\r
 940                 {\r
 941                         try{\r
 942                                 //登録済みのシンボルは登録できない。\r
 943                                 if(!isUndef(this._phl_holder[i_symbol])){\r
 944                                         throw new MiMicException("Peripheral symbol "+i_symbol+" is already exist on mcu.");\r
 945                                 }\r
 946                                 this._phl_holder[i_symbol]=i_phl;\r
 947                         }catch(e){\r
 948                                 throw new MiMicException(e);\r
 949                         }\r
 950                 }\r
 951         }\r
 952 }());/**\r
 953  * @fileOverview LPCXpresso1769のメモリアクセスクラスを定義する。\r
 954  */\r
 955 \r
 956 (function(){\r
 957 var DEV=LPCXpresso1769;\r
 958 var BCF=DEV._BCF;\r
 959 var EE=DEV._EE;\r
 960 var isUndef=MiMicLib.isUndef;\r
 961 \r
 962 function checkAlign(v){\r
 963         if(v%4!=0){\r
 964                 throw new MiMicException(EE.INVALID_ARG,"An alignment is not 32bit unit.");\r
 965         }\r
 966 }\r
 967 \r
 968 /**\r
 969  * LPCXPresso1769.Memory (Memory)クラスのコンストラクタ。\r
 970  * Memoryクラスは、MCUのメモリ空間へアクセスする手段を提供する。\r
 971  * このクラスは、メモリアクセス対してなんら保護機能を持たない。MCUのメモリマップに十分に注意する必要がある。\r
 972  * @name LPCXpresso1769.Memory\r
 973  * @constructor\r
 974  * @param {object as LPCXpresso1769.Mcu} i_mcu\r
 975  * インスタンスを結びつけるMcuオブジェクト。\r
 976  * @param {int} i_base\r
 977  * メモリにアクセスするときのベースアドレス。省略可能である。省略時は0x0とみなす。4バイト境界でなければならない。クラスの提供する関数でアドレスを指定した時には、全てこの値が加算される。\r
 978  * @example\r
 979  * //create a controlable MCU via network.\r
 980  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
 981  * var memory=new LPCXpresso1769.Memory(mcu); \r
 982  */\r
 983 DEV.Memory=function Memory(i_mcu,i_base)\r
 984 {\r
 985         if(!isUndef(i_base)){\r
 986                 this._base=i_base;\r
 987         }\r
 988         this._mcu=i_mcu;\r
 989 }\r
 990 DEV.Memory.prototype=\r
 991 {\r
 992         _base:0x00000000,\r
 993         _mcu:null,\r
 994         /**\r
 995          * 指定したアドレスの32ビット値を取得する。\r
 996          * @name LPCXpresso1769.Memory#read32^2\r
 997          * @function\r
 998          * @param {int} i_offset\r
 999          * コンストラクタで指定したアドレスからのオフセット位置を指定する。4バイト境界でなければならない。\r
1000          * @return {int}\r
1001          * 1個のint値。\r
1002          * @example\r
1003          * var　mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
1004          * var mem=new LPCXpresso1769.Memory(mcu);　//create instance\r
1005          * alert(mem.read32(0x00000000)); //show 1 value \r
1006          */\r
1007         /**\r
1008          * 指定したオフセットから、i_sizeバイトのメモリに格納した値を、それぞれ32ビット単位で値を取得する。i_offsetの位置から、32bit単位でi_size/4個の値を取得することになる。シーケンシャルアクセスに使用する。\r
1009          * @name LPCXpresso1769.Memory#read32^3\r
1010          * @function\r
1011          * @param {int} i_offset\r
1012          * コンストラクタで指定したアドレスからのオフセット位置を指定する。4バイト境界でなければならない。\r
1013          * @param {int} i_size\r
1014          * 取得するバイト数を指定する。4バイト単位でなければならない。      \r
1015          * @return {int or Array[int]}\r
1016          * 取得する値の個数は、i_size/4個である。個数により、戻り値の型が異なるので注意すること。\r
1017          * @example\r
1018          * var　mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
1019          * var mem=new LPCXpresso1769.Memory(mcu);　//create instance\r
1020          * mem.read32(0x0,8); //return 2 values.\r
1021          */\r
1022         /**\r
1023          * オフセットの配列要素に対応した値を、それぞれ32ビット単位で取得する。\r
1024          * ランダムアクセスに使用する。\r
1025          * @name LPCXpresso1769.Memory#read32^4\r
1026          * @function\r
1027          * @param {array[int]} i_offsets\r
1028          * オフセットアドレスの配列。それぞれ4バイト境界でなければならない。\r
1029          * @return {int or Array[int]}\r
1030          * 返却される値の個数は、i_offsetの長さと同じになる。個数により、戻り値の型が異なるので注意すること。\r
1031          * @example\r
1032          * var　mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
1033          * var mem=new LPCXpresso1769.Memory(mcu);　//create instance\r
1034          * mem.read32([0x0,0x14,0x08]); //return 3 values by specified order.\r
1035          */\r
1036         /**\r
1037          * メモリから値を読み出して、値セットの配列、又は値を返す。\r
1038          * 関数はバイト単位のアライメントでメモリにアクセスする。メモリアドレス、取得サイズは4バイト境界に一致させなければならない。\r
1039          * 引数の違いにより、数種類の呼び出し方がある。\r
1040          * @name LPCXpresso1769.Memory#read32^1\r
1041          * @function\r
1042          * @param ...\r
1043          * 詳細は、read32^nを参照。\r
1044          * @return {int or Array[int]}\r
1045          * 返却値の数により、型が異なる。1個の場合はint値、複数の場合はint型の配列である。
1046          */\r
1047         read32:function read32(/*arguments*/)\r
1048         {\r
1049                 try{\r
1050                         var bc="";\r
1051                         var ar=new Array();\r
1052                         var offset=arguments[0];\r
1053                         switch(arguments.length){\r
1054                         case 1:\r
1055                                 if(!isNaN(offset)){\r
1056                                         //read32(i_offset:int)\r
1057                                         checkAlign(offset);\r
1058                                         bc=BCF.READMEM;\r
1059                                         ar.push(this._base+offset);\r
1060                                 }else{\r
1061                                         //read32(i_offsets:array)\r
1062                                         for(var i=0;i<offset.length;i++){\r
1063                                                 checkAlign(offset[i]);\r
1064                                                 bc+=BCF.getMem(this._base+offset[i],ar);\r
1065                                         }\r
1066                                 }\r
1067                                 break;\r
1068                         case 2:\r
1069                                 //read32(i_offset:int,i_size:int)\r
1070                                 checkAlign(offset);\r
1071                                 checkAlign(arguments[1]);\r
1072                                 var l=arguments[1]/4;\r
1073                                 for(var i=0;i<l;i++){\r
1074                                         bc+=BCF.READMEM;\r
1075                                         ar.push(this._base+offset+i*4);\r
1076                                 }\r
1077                                 break;\r
1078                         default:\r
1079                                 break;\r
1080                         }\r
1081                         var ret=this._mcu.callMiMicWithCheck(bc+BCF.END,ar).stream;\r
1082                         return ret.length==1?ret[0]:ret;\r
1083                 }catch(e){\r
1084                         throw new MiMicException(e);\r
1085                 }\r
1086         },\r
1087         write32:function write32(/*arguments*/)\r
1088         {\r
1089                 try{\r
1090                         var bc="";\r
1091                         var ar=new Array();\r
1092                         var offset=arguments[0];\r
1093                         switch(arguments.length){\r
1094                         case 2:\r
1095                                 if((!isNaN(offset))){\r
1096                                         if(!isNaN(arguments[1])){\r
1097                                                 //write32(i_offset:int,i_value:int)\r
1098                                                 checkAlign(offset);\r
1099                                                 bc+=BCF.setMem(this._base+offset,arguments[1],ar);\r
1100                                         }else if(arguments[1].length>0){\r
1101                                                 //read32(i_offset:int,i_value:array)\r
1102                                                 checkAlign(offset);\r
1103                                                 var l=arguments[1].length;\r
1104                                                 for(var i=0;i<l;i++){\r
1105                                                         bc+=BCF.setMem(this._base+offset+i*4,arguments[1][i],ar);\r
1106                                                 }\r
1107                                         }else{\r
1108                                                 throw new MiMicException();\r
1109                                         }\r
1110                                 }else if(offset.length==arguments[1].length){\r
1111                                         //write32(i_offsets:array,i_value:array)\r
1112                                         for(var i=0;i<offset.length;i++){\r
1113                                                 checkAlign(offset[i]);\r
1114                                                 bc+=BCF.setMem(this._base+offset[i],arguments[1][i],ar);\r
1115                                                 \r
1116                                         }\r
1117                                 }else{\r
1118                                         throw new MiMicException();\r
1119                                 }\r
1120                                 break;\r
1121                         default:\r
1122                                 break;\r
1123                         }\r
1124                         this._mcu.callMiMicWithCheck(bc+BCF.END,ar).stream;\r
1125                         return;\r
1126                 }catch(e){\r
1127                         throw new MiMicException(e);\r
1128                 }\r
1129         }       \r
1130 }\r
1131 \r
1132 }());/**\r
1133  * @fileOverview LPCXpresso1769の物理ペリフェラルを制御するクラスを定義する。\r
1134  */\r
1135 (function(){\r
1136 var DEV=LPCXpresso1769;\r
1137 var BCF=DEV._BCF;\r
1138 var EE=DEV._EE;\r
1139 var isUndef=MiMicLib.isUndef;\r
1140 /**\r
1141  * LPCXPresso1769.Peripheral (Peripheral)クラスのコンストラクタ。\r
1142  * ペリフェラル識別子を元に、MCUに関連付けしたPeripheral インスタンスを生成する。\r
1143  * Peripheralクラスは、物理Peripheral（主に電源/クロックブロック単位）単位に操作インタフェイスを定義する。\r
1144  * PCLKSEL,PCONPレジスタを管理する。\r
1145  * このクラスは、抽象ペリフェラルクラスへ物理ペリフェラルの基本的な操作機能を提供する為のものであり、ユーザが直接使用することは（あまり）ない。\r
1146  * 関数はMiMicの管理しているペリフェラル（ENET）も操作することが出来るが、操作してしまうとMiMicRemoteMcuとのコネクションが破壊されるので、注意すること。\r
1147  * @name LPCXpresso1769.Peripheral\r
1148  * @constructor\r
1149  * @param {object as LPCXpresso1769.Mcu} i_mcu\r
1150  * インスタンスを結びつけるMcuオブジェクト。\r
1151  * @param {object as ペリフェラル識別子} i_phl\r
1152  * 生成するペリフェラルのペリフェラル識別子。この値は、LPCXpresso1769.PHLの要素である。\r
1153  * @param {object as associative array} i_opt\r
1154  * インスタンス生成と同時にsetOpt関数で設定する値。省略時は無視する。\r
1155  * 詳細はsetOpt関数を参照。\r
1156  * @example\r
1157  * //create GPIO peripheral\r
1158  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1159  * var phl=new LPCXpresso1769.Pheripheral(mcu,LPCXpresso.PHL.GPIO); \r
1160  */\r
1161 DEV.Peripheral=function(i_mcu,i_phl,i_opt)\r
1162 {\r
1163         try{\r
1164                 if(isUndef(i_phl)){\r
1165                         throw new MiMicException(EE.INVALID_PHL);\r
1166                 }\r
1167                 this._mcu=i_mcu;\r
1168                 this._phl=i_phl;\r
1169                 //オプション設定するならする。\r
1170                 if(!isUndef(i_opt)){\r
1171                         this.setOpt(i_opt);\r
1172                 }\r
1173         }catch(e){\r
1174                 throw new MiMicException(e);\r
1175         }       \r
1176 }\r
1177 DEV.Peripheral.prototype=\r
1178 {\r
1179         _PCLKSEL:[0x400FC1A8,0x400FC1AC],\r
1180         _PCONP:0x400FC0C4,\r
1181         _phl:null,\r
1182         _mcu:null,\r
1183         _cache:{\r
1184                 pclk:0\r
1185         },\r
1186         /**\r
1187          * BCフラグメントを生成して、_cacheを更新します。\r
1188          * @private
1189          */\r
1190         BCF_setOpt:function BCF_setOpt(i_opt,i_db)\r
1191         {\r
1192                 try{\r
1193                         var bc="";\r
1194                         //pconp\r
1195                         if(!isUndef(i_opt.power)){\r
1196                                 if(this._phl[2]==null){\r
1197                                         throw new MiMicException(EE.INVALID_CFG,"The pin does not support PCONP.");\r
1198                                 }\r
1199                                 //pinselAddrを得る\r
1200                                 bc+=BCF.setBit(this._PCONP,0x00000001,i_opt.power,this._phl[2],i_db);\r
1201                         }\r
1202                         //clock\r
1203                         if(!isUndef(i_opt.clock)){\r
1204                                 if(this._phl[0]==null){\r
1205                                         throw new MiMicException(EE.INVALID_CFG,"The pin does not support PCLKSEL.");\r
1206                                 }\r
1207                                 //キャッシュ更新\r
1208                                 this._cache.pclk=i_opt.clock;\r
1209                                 bc+=BCF.setBit(this._PCLKSEL[this._phl[0]],0x00000003,i_opt.clock,this._phl[1],i_db);\r
1210                         }\r
1211                         return bc;\r
1212                 }catch(e){\r
1213                         throw new MiMicException(e);\r
1214                 }               \r
1215         },\r
1216         /**\r
1217          * ペリフェラルにオプションパラメータをセットする。\r
1218          * 関数は、物理ペリフェラルのレジスタに、i_optで与えられる値を設定する。\r
1219          * 関数は、レジスタの位置に合わせてパラメータ値を自動的にシフトする。   \r
1220          * @name LPCXpresso1769.Peripheral#setOpt\r
1221          * @function\r
1222          * @param {object} i_opt\r
1223          * ペリフェラルピンコンフィグレーションのパラメタである。必要な値を格納した連想配列で指定する。\r
1224          * 全ての値を省略することは出来ない。連想配列のメンバは以下の通り。\r
1225          * <pre>{power:int,clock:int}</pre>\r
1226          * <ul>\r
1227          * <li>power:int -\r
1228          * 1bitのint値。 PCONP? レジスタに指定する値。Chapter 4: LPC17xx Clocking and power controlを参照。\r
1229          * </li>\r
1230          * <li>clock:int - \r
1231          * 2bitのint値。PCLKSEL? レジスタに指定する値。Chapter 4: LPC17xx Clocking and power controlを参照。\r
1232          * </li>\r
1233          * @example \r
1234          * //set DAC power on\r
1235          * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1236          * var phl=new LPCXpresso1769.Peripheral(mcu,LPCXpresso.PHL.ADC);\r
1237          * phl.setOpt({power:1});        \r
1238          */\r
1239         setOpt:function setOpt(i_opt)\r
1240         {\r
1241                 try{\r
1242                         var db=new Array();\r
1243                         var bc=this.BCF_setOpt(i_opt,db);\r
1244                         if(bc.length==0){\r
1245                                 throw new MiMicException("i_opt is empty or invalid.");\r
1246                         }\r
1247                         //MiMicBCを生成して実行\r
1248                         this._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
1249 \r
1250                 }catch(e){\r
1251                         throw new MiMicException(e);\r
1252                 }\r
1253                 return;         \r
1254         },\r
1255         /**\r
1256          * ペリフェラルのクロックを[Hz]単位で返す。\r
1257          * クロックは、Table 42. Peripheral Clock Selection register bit valuesと、MCUのクロック(LPCXpresso1769.Mcuの提供する値)から計算する。\r
1258          * 動作中のPLL0の変更には対応していない。注意すること。\r
1259          * @name LPCXpresso1769.Peripheral#getPCLK\r
1260          * @function\r
1261          * @return {int}\r
1262          * Hz単位のペリフェラルクロック\r
1263          * @example\r
1264          * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1265          * var phl=new LPCXpresso1769.Peripheral(mcu,LPCXpresso.PHL.PWM);\r
1266          * alert(phl.getPCLK());\r
1267          */\r
1268         getPCLK:function getPCLK()\r
1269         {\r
1270                 try{\r
1271                         //倍率変換テーブル\r
1272                         var m=[4,1,2,0];\r
1273                         var t=m[this._cache.pclk];\r
1274                         var r;\r
1275                         if(t==0){\r
1276                                 if(this._phl===DEV.PHL.CAN1 || this._phl===DEV.PHL.CAN2){\r
1277                                         r=this._mcu.getClockInfo().cclk/6;\r
1278                                 }else{\r
1279                                         r=this._mcu.getClockInfo().cclk/8;\r
1280                                 }\r
1281                         }else{\r
1282                                 r=this._mcu.getClockInfo().cclk/t;\r
1283                         }\r
1284                         return Math.round(r);\r
1285                 }catch(e){\r
1286                         throw new MiMicException(e);\r
1287                 }\r
1288         }\r
1289 }\r
1290 \r
1291 }());/**\r
1292  * @fileOverview LPCXpresso1769の物理ピンを制御するクラスを定義する。\r
1293  */\r
1294 \r
1295 (function(){\r
1296 var DEV=LPCXpresso1769;\r
1297 var BCF=DEV._BCF;\r
1298 var EE=DEV._EE;\r
1299 var isUndef=MiMicLib.isUndef;\r
1300 \r
1301 /**\r
1302  * @private\r
1303  * レジスタの内容
1304  */\r
1305 var REG={\r
1306         _PINSEL:[0x4002C000,0x4002C004,0x4002C008,0x4002C00C,0x4002C010,null,null,0x4002C0C0,null,0x4002C024,0x4002C028],\r
1307         _PINMODE:[0x4002C040,0x4002C044,0x4002C048,0x4002C04C,0x4002C050,0x4002C054,0x4002C058,0x4002C05C,null,0x4002C064],\r
1308         _PINMODE_OD:[0x4002C068,0x4002C06C,0x4002C070,0x4002C074,0x4002C078],\r
1309 };\r
1310 \r
1311 DEV.Port=function Port(i_mcu,i_pins,i_opts)\r
1312 {\r
1313         try{\r
1314                 this._mcu=i_mcu;\r
1315                 this._pininfo=new Array();\r
1316                 //ピン情報に変換\r
1317                 for(var i=0;i<i_pins.length;i++){\r
1318                         this._pininfo.push(DEV.getPinRegInfo(i_pins[i]));\r
1319                 }\r
1320                 if(!isUndef(i_opts)){\r
1321                         this.setOpts(i_opts);\r
1322                 }\r
1323         }catch(e){\r
1324                 throw new MiMicException(e);\r
1325         }               \r
1326 }\r
1327 \r
1328 DEV.Port.prototype=\r
1329 {\r
1330         _mcu:null,\r
1331         /**\r
1332          * 複数のピン設定をレジスタごとにまとめたBCを生成する。\r
1333          @private
1334          */\r
1335         BCF_setOpts:function BCF_setOpts(i_opts,i_db)\r
1336         {\r
1337                 try{\r
1338                         //10/5レジスタ分のワーク領域を作る。\r
1339                         var d={\r
1340                                 selr:[0,0,0,0,0,0,0,0,0,0],\r
1341                                 selr_mask:[0,0,0,0,0,0,0,0,0,0],\r
1342                                 modr:[0,0,0,0,0,0,0,0,0,0],\r
1343                                 modr_mask:[0,0,0,0,0,0,0,0,0,0],\r
1344                                 odr:[0,0,0,0,0],\r
1345                                 odr_mask:[0,0,0,0,0]};\r
1346         \r
1347                         //pinsとoptsの数は同じだよね？\r
1348                         if(this._pininfo.length!=i_opts.length){\r
1349                                 throw new MiMicException();\r
1350                         }\r
1351                         \r
1352                         //レジスタ値、マスクの生成\r
1353                         for(var i=0;i<i_opts.length;i++)\r
1354                         {\r
1355                                 var pi=this._pininfo[i];\r
1356                                 var opt=i_opts[i];\r
1357                                 if(!isUndef(opt.sel))\r
1358                                 {\r
1359                                         d.selr[pi.s]|=(opt.sel<<pi.smb);\r
1360                                         d.selr_mask[pi.s]|=(0x3<<pi.smb);\r
1361                                 }\r
1362                                 if(!isUndef(opt.mode))\r
1363                                 {\r
1364                                         d.modr[pi.m]|=(opt.mode<<pi.smb);\r
1365                                         d.modr_mask[pi.m]|=(0x3<<pi.smb);\r
1366                                 }\r
1367                                 if(!isUndef(opt.od))\r
1368                                 {\r
1369                                         d.odr[pi.o]|=(opt.od<<pi.ob);\r
1370                                         d.odr_mask[pi.o]|=(0x1<<pi.ob);\r
1371                                 }\r
1372                         }\r
1373                         //BCFを生成\r
1374                         var bc="";\r
1375                         for(var i=0;i<10;i++){\r
1376                                 if(d.selr_mask[i]!=0x0){\r
1377                                         bc+=BCF.setBit(REG._PINSEL[i],d.selr_mask[i],d.selr[i],0,i_db);\r
1378                                 }\r
1379                                 if(d.modr_mask[i]!=0x0){\r
1380                                         bc+=BCF.setBit(REG._PINMODE[i],d.modr_mask[i],d.modr[i],0,i_db);\r
1381                                 }\r
1382                         }\r
1383                         for(var i=0;i<5;i++){\r
1384                                 if(d.odr_mask[i]!=0x0){\r
1385                                         bc+=BCF.setBit(REG._PINMODE_OD[i],d.odr_mask[i],d.odr[i],0,i_db);\r
1386                                 }\r
1387                         }\r
1388                         return bc;\r
1389                 }catch(e){\r
1390                         throw new MiMicException(e);\r
1391                 }\r
1392         },\r
1393         setOpts:function setOpts(i_opts)\r
1394         {\r
1395                 try{\r
1396                         var db=new Array();\r
1397                         var bc=this.BCF_setOpts(i_opts,db);\r
1398                         if(bc.length==0){\r
1399                                 throw new MiMicException("i_opt is empty or invalid.");\r
1400                         }\r
1401                         //MiMicBCを生成して実行\r
1402                         this._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
1403                 }catch(e){\r
1404                         throw new MiMicException(e);\r
1405                 }\r
1406                 return;\r
1407         }       \r
1408 }\r
1409 \r
1410 \r
1411 /**\r
1412  * LPCXPresso1769.Pin (Pin)クラスのコンストラクタ。\r
1413  * ピン識別子を元に、MCUに関連付けらしたPinインスタンスを生成する。\r
1414  * Pinクラスは、MCUの物理ピン単位に、操作インタフェイスを定義する。\r
1415  * PINSEL,PINMODE,PINMODE_ODレジスタを管理する。\r
1416  * @name LPCXpresso1769.Pin\r
1417  * @constructor\r
1418  * @param {object as LPCXpresso1769.Mcu} i_mcu\r
1419  * インスタンスを結びつけるMcuオブジェクト。\r
1420  * @param {object as ピン識別子} i_pin\r
1421  * 生成するピンのピン識別子。\r
1422  * @param {object as associative array} i_opt\r
1423  * インスタンス生成と同時にsetOpt関数で設定する値。省略時は無視する。\r
1424  * 詳細はsetOpt関数を参照。\r
1425  * このクラスは、上位クラスへピンの基本的な操作機能を提供する為のものであり、ユーザが直接使用することは（あまり）ない。\r
1426  * この関数は、MiMicの管理しているピン（ENET_?）も操作することが出来るが、操作してしまうとMiMicRemoteMcuとのコネクションが破壊されるので、注意すること。\r
1427  * @example\r
1428  * //create pin instance at P0[0]\r
1429  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1430  * var pin=new LPCXpresso1769.Pin(mcu,LPCXpresso.P0[0]);\r
1431  */\r
1432 DEV.Pin=function Pin(i_mcu,i_pin,i_opt)\r
1433 {\r
1434         try{\r
1435                 if(isUndef(i_pin)){\r
1436                         throw new MiMicException(EE.INVALID_PIN);\r
1437                 }\r
1438                 //1ピンのポートとして実装する。\r
1439                 this._port=new DEV.Port(i_mcu,[i_pin],isUndef(i_opt)?undefined:[i_opt]);\r
1440         }catch(e){\r
1441                 throw new MiMicException(e);\r
1442         }\r
1443 }\r
1444 DEV.Pin.prototype=\r
1445 {       \r
1446         _port:null,\r
1447         /**\r
1448          * ピンにオプションパラメータをセットする。\r
1449          * 関数は、物理ピンのレジスタに、i_optで与えられる値を設定する。\r
1450          * 関数は、レジスタの位置に合わせてパラメータ値を自動的にシフトする。\r
1451          * @name LPCXpresso1769.Pin#setOpt\r
1452          * @function\r
1453          * @param {object as associative array} i_opt\r
1454          * ピンコンフィグレーションのパラメタである。必要な値を格納した連想配列で指定する。\r
1455          * 全ての値を省略することは出来ない。連想配列のメンバは以下の通り。\r
1456          * <pre>{sel,mode,od}</pre>\r
1457          * <ul>\r
1458          * <li>sel:int - 2bitのint値。 PINSEL? レジスタに指定する値。UM10360 Chapter8.LPC17xx Pin connect block を参照。</li>\r
1459          * <li>mode:int - 1bitのint値。PINMODE? レジスタに指定する値。UM10360 Chapter8.LPC17xx Pin connect block を参照。</li>\r
1460          * <li>od:int - 1bitのbit値　PINMODE_OD? レジスタに指定する値。UM10360 Chapter8.LPC17xx Pin connect block を参照。</li>\r
1461          * </ul>\r
1462          * @example\r
1463          * //set GPIO,mode=1,open drain=0\r
1464          * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1465          * var pin=new LPCXpresso1769.Pin(mcu,LPCXpresso.P2[3]);\r
1466          * pin.setOpt({sel:0,mode:1,od:0});      \r
1467          */\r
1468         setOpt:function setOpt(i_opt)\r
1469         {\r
1470                 try{\r
1471                         //portのsetOptで合成\r
1472                         this._port.setOpts([i_opt]);\r
1473                 }catch(e){\r
1474                         throw new MiMicException(e);\r
1475                 }\r
1476                 return;\r
1477         }\r
1478 }\r
1479 \r
1480 }());/**\r
1481  * @fileOverview LPCXpresso1769の、ADコンバータペリフェラル、ピンの制御クラスを定義する。\r
1482  */\r
1483 (function(){\r
1484 var DEV=LPCXpresso1769;\r
1485 var BCF=DEV._BCF;\r
1486 var EE=DEV._EE;\r
1487 var isUndef=MiMicLib.isUndef;\r
1488 var cloneAssoc=MiMicLib.cloneAssoc;\r
1489 \r
1490 \r
1491 /**\r
1492  * LPCXPresso1769.Adc (Adc)クラスのコンストラクタ。\r
1493  * MCUに関連付けしたADペリフェラルを生成する。\r
1494  * ADペリフェラルは、MCUのADCペリフェラル全体を管理する。\r
1495  * 関数は、ADCRレジスタのPDN,BURSTを1にセットする。\r
1496  * ADCペリフェラルはバーストモードで動作し、サンプリングレートは200KHz固定である。取得タイミングの制御はハードウェア依存である。\r
1497  * @constructor\r
1498  * @name LPCXpresso1769.Adc\r
1499  * @param {object as LPCXpresso1769.Mcu} i_mcu\r
1500  * インスタンスを結びつけるMcuオブジェクト。\r
1501  * @param {object as associative array} i_opt\r
1502  * インスタンス生成と同時にsetOpt関数で設定する値。省略時は、{phl:{power:1}}とみなす。\r
1503  * 詳細はsetOpt関数を参照。 \r
1504  * @example\r
1505  * //create AD (logical)pheripheral\r
1506  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1507  * var ad=new LPCXpresso1769.Adc(mcu); \r
1508  */\r
1509 DEV.Adc=function Adc(i_mcu,i_opt)\r
1510 {\r
1511         try{\r
1512                 this._mcu=i_mcu;\r
1513                 //PHL生成。\r
1514                 this._phl=new DEV.Peripheral(i_mcu,DEV.PHL.ADC);\r
1515                 //設定値のロード\r
1516                 var opt=isUndef(i_opt)?{phl:{}}:\r
1517                 {//i_optある。\r
1518                         phl:isUndef(i_opt.phl)?{}:cloneAssoc(i_opt.phl),\r
1519                 };\r
1520                 //デフォルト値設定\r
1521                 if(isUndef(opt.phl.power)){opt.phl.power=1;};\r
1522 \r
1523                 //初期化。\r
1524                 var bc="";\r
1525                 var db=new Array();\r
1526                 bc+=this.BCF_setOpt(opt,db);\r
1527                 //0x00210000(PDN,BURSTを1)\r
1528                 bc+=BCF.setMem(this._AD0CR,0x00200400,db);\r
1529                 bc+=BCF.setMem(this._AD0CR,0x00210400,db);\r
1530                 //\r
1531                 this._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
1532                 //ペリフェラルをMCUに登録\r
1533                 this._mcu.registerPhl(this,"ADC");\r
1534         }catch(e){\r
1535                 throw new MiMicException(e);\r
1536         }\r
1537 \r
1538 }\r
1539 DEV.Adc.prototype=\r
1540 {\r
1541         _PHL_DEF:{power:1},\r
1542         _AD0CR:0x40034000,\r
1543         _AD0DR:[0x40034010,0x40034014,0x40034018,0x4003401C,0x40034020,0x40034024,0x40034028,0x4003402C],\r
1544         _phl:null,\r
1545         _mcu:null,\r
1546 \r
1547         BCF_setOpt:function BCF_setOpt(i_opt,i_db)\r
1548         {\r
1549                 try{\r
1550                         var bc="";\r
1551                         if(!isUndef(i_opt.phl)){\r
1552                                 bc+=this._phl.BCF_setOpt(i_opt.phl,i_db);\r
1553                         }\r
1554                         return bc;\r
1555                 }catch(e){\r
1556                         throw new MiMicException(e);\r
1557                 }\r
1558         },\r
1559         /**\r
1560          * AD0CRのSELフィールドの値を更新するBC\r
1561          @param i_val\r
1562          0 or 1\r
1563          @private\r
1564          */\r
1565         BCF_setSels:function BCF_setSels(i_mask,i_val,i_db)\r
1566         {\r
1567                 try{\r
1568                         return BCF.setBit(this._AD0CR,i_mask,i_val*i_mask,0,i_db);\r
1569                 }catch(e){\r
1570                         throw new MiMicException(e);\r
1571                 }\r
1572         },\r
1573         /**\r
1574          * n番のAD0DRの値を得るBC\r
1575          @private\r
1576          */\r
1577         BCF_getAD0DR:function BCF_getAD0DR(i_ch,i_db)\r
1578         {\r
1579                 try{\r
1580                         return BCF.getMem(this._AD0DR[i_ch],i_db);\r
1581                 }catch(e){\r
1582                         throw new MiMicException(e);\r
1583                 }\r
1584         },\r
1585         /**\r
1586          * ADCペリフェラルに、i_optのオプション値を設定する。\r
1587          * @name LPCXpresso1769.Adc#setOpt\r
1588          * @function\r
1589          * @param {object as associative array} i_opt\r
1590          * ADCペリフェラルのコンフィグレーションパラメタである。必要な値を格納した連想配列で指定する。\r
1591          * 全ての値を省略することは出来ない。連想配列のメンバは以下の通り。\r
1592          * <pre>{phl:object as associative array}</pre>\r
1593          * <ul>\r
1594          * <li>phl - LPCXpresso1769.Peripheral#setOpt関数のi_optに渡すパラメタである。</li>\r
1595          * </ul>\r
1596          * @example\r
1597          * //AD power on/off\r
1598          * //create AD (logical)pheripheral\r
1599          * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1600          * var ad=new LPCXpresso1769.Adc(mcu);\r
1601          * ad.setOpt(phl:{power:0});\r
1602          */\r
1603         setOpt:function setOpt(i_opt)\r
1604         {\r
1605                 try{\r
1606                         var db=new Array();\r
1607                         var bc=this.BCF_setOpt(i_opt,db);\r
1608                         this._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
1609                 }catch(e){\r
1610                         throw new MiMicException(e);\r
1611                 }\r
1612         },      \r
1613         /**\r
1614          * AD機能を持つピンを取得する。\r
1615          * ピン識別子で指定されるピンをADペリフェラルと結合して、AdcPinを生成する。\r
1616          * 関数は、AdcPinオブジェクトのコンストラクタをコールして、AdcPinを生成する。失敗すると、例外をスローする。\r
1617          * 生成ルールについての詳細は、AdcPinを参照。\r
1618          * @name LPCXpresso1769.Adc#getPin\r
1619          * @function\r
1620          * @param {object as ピン識別子} i_pin\r
1621          * AD機能を割り当てるPINの識別子である。値は、LPCXpresso1769.Pn[m]のメンバ変数である。\r
1622          * @param {object as associative array} i_opt\r
1623          * AdcPinのコンストラクタに渡すオプション値。省略時はundefinedである。詳細はLPCXpresso1769.AdcPin.setOptを参照。\r
1624          * @return {object as LPCXpresso1769.AdcPin}\r
1625          * LPCXpresso1769.AdcPinクラスのオブジェクトである。\r
1626          * @example\r
1627          * //create AdcPin\r
1628          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
1629          * var adc=new LPCXpresso1769.Adc(mcu);\r
1630          * var adpin=adc.getPin(LPCXpresso1769.P0[23]);\r
1631          */\r
1632         getPin:function getPin(i_pin,i_opt)\r
1633         {\r
1634                 try{\r
1635                         return new DEV.AdcPin(this,i_pin,i_opt);\r
1636                 }catch(e){\r
1637                         throw new MiMicException(e);\r
1638                 }\r
1639         },\r
1640         /**\r
1641          * AD機能を持つポート(Pin集合)を取得する。\r
1642          * ピン識別子で指定されるピンのセットをADペリフェラルと結合して、AdcPortを生成する。\r
1643          * 関数は、AdcPortのコンストラクタをコールする。\r
1644          * 生成ルールについては、AdcPort関数を参照すること。
1645          * @name LPCXpresso1769.Adc#getPort\r
1646          * @function\r
1647          * @param {array[ピン識別子]} i_pin\r
1648          * AD機能を割り当てるPINの識別子の配列である。値は、LPCXpresso1769.Pn[m]のメンバ変数である。\r
1649          * @param {object as associative array} i_opt\r
1650          * AdcPortのコンストラクタに渡すオプション値。省略時はundefinedである。詳細はLPCXpresso1769.AdcPort.setOptを参照。\r
1651          * @return {object as LPCXpresso1769.AdcPort}\r
1652          * LPCXpresso1769.AdcPortクラスのオブジェクトである。\r
1653          * @example\r
1654          * //create 2AdcPort that has 2 pins.\r
1655          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
1656          * var adc=new LPCXpresso1769.Adc(mcu);\r
1657          * var port=adc.getPort([LPCXpresso1769.P0[23],LPCXpresso1769.P0[24]]);\r
1658          */\r
1659         getPort:function getPort(i_pins,i_opt)\r
1660         {\r
1661                 try{\r
1662                         return new DEV.AdcPort(this,i_pins,i_opt);\r
1663                 }catch(e){\r
1664                         throw new MiMicException(e);\r
1665                 }\r
1666         }\r
1667 }\r
1668 \r
1669 \r
1670 /**\r
1671  * AD pinからADInfoを取得\r
1672  * @private\r
1673  */\r
1674 function pin2AdcPinInfo(i_pin)\r
1675 {\r
1676         try{\r
1677                 //pinの完全な機能名を得る。(得られれば機能がある。)\r
1678                 var func_name=DEV.completePinFunctionName(i_pin,"AD");\r
1679                 //portとbitを得る(AD0だけしか管理しないよ)\r
1680                 var a=func_name.substring(2).split(".");\r
1681                 var r={port:0,ch:parseInt(a[1]),pin_sel:DEV.getPinSelByFunctionName(i_pin,func_name)};\r
1682                 if(!isNaN(r.ch)){\r
1683                         return r;\r
1684                 }\r
1685                 throw new MiMicException(EE.INVALID_CFG,"The pin has not AD fuction.");\r
1686         }catch(e){\r
1687                 throw new MiMicException(e);    \r
1688         }\r
1689 }\r
1690 /**\r
1691  * LPCXPresso1769.AdcPort (AdcPort)クラスのコンストラクタ。複数のADピンから一括で値を取得するときに使用する。\r
1692  * Adcペリフェラルオブジェクトにピン識別子の配列で指定されたピン集合を関連付けて、AD機能を持つポートを生成する。\r
1693  * 関数は、ピン識別子を元に、そのピンがAD機能に接続できるかを調べる。全てのピンにAD機能を割り当てられない場合、例外が発生する。どのピンにAD機能が割り当てられるかは、MCUのスペックシートを参照すること。\r
1694  * @constructor\r
1695  * @name LPCXpresso1769.AdcPort\r
1696  * @param {object as LPCXpresso1769.Adc} i_adc\r
1697  * インスタンスを結びつけるAdcオブジェクト。\r
1698  * @param {array[pin識別子]} i_pins\r
1699  * ピン識別子の配列。指定できるのは、LPCXpresso1796.P?[?]である。順番は、このインスタンスの返す値の順序に影響する。\r
1700  * @param {object as associative array} i_opt\r
1701  * setOpt関数のi_optに渡すパラメタである。省略可能。省略時は{pin:{sel:auto}}を設定する。\r
1702  * autoは、関数が自動的に決定するPINSELの値である。詳細はsetOpt関数を参照。 \r
1703  * @example\r
1704  * //create [AD0.0,AD0.1]\r
1705  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1706  * var adc=new LPCXpresso1769.Adc(mcu);\r
1707  * var port=new LPCXpresso1769.AdcPort(adc,[LPCXpresso1769.P0[23],LPCXpresso1769.P0[24]]); \r
1708  */\r
1709 DEV.AdcPort=function AdcPort(i_adc,i_pins,i_opt)\r
1710 {\r
1711         try{\r
1712                 this._adc=i_adc;\r
1713                 //ピンセットを取得\r
1714                 this._pins=new Array();\r
1715                 //pinに変換する。\r
1716                 for(var i=0;i<i_pins.length;i++){\r
1717                         this._pins.push(pin2AdcPinInfo(i_pins[i]));\r
1718                 }\r
1719                 //pinが全て同じポートに所属しているか確認\r
1720                 var p=this._pins[0].port;\r
1721                 for(var i=1;i<this._pins.length;i++){\r
1722                         if(p!=this._pins[1].port){\r
1723                                 throw new MiMicException("Invalid pin combination.");\r
1724                         }\r
1725                 }\r
1726                 //ポートの生成\r
1727                 this._port=new DEV.Port(i_adc._mcu,i_pins);\r
1728                 this._port_no=p;\r
1729                 //AD0CR用のマスクを生成。\r
1730                 this._adcr_mask=0;\r
1731                 for(var i=0;i<this._pins.length;i++){\r
1732                         this._adcr_mask|=(0x1<<this._pins[i].ch);\r
1733                 }\r
1734                 //ピンオプションの生成\r
1735                 var opt=cloneAssoc(i_opt);\r
1736                 opt.sel=1;//ADxCRの値\r
1737                 if(isUndef(opt.pin)){opt.pin={};}\r
1738                 //設定が無ければ、ピンセレクタを自動に設定\r
1739                 if(isUndef(opt.pin.sel)){opt.pin.sel=this._PINSEL_AUTO_DETECT;}\r
1740                 //ピンオプションの設定\r
1741                 this.setOpt(opt);\r
1742         }catch(e){\r
1743                 throw new MiMicException(e);\r
1744         }       \r
1745 }\r
1746 DEV.AdcPort.prototype=\r
1747 {\r
1748         _PINSEL_AUTO_DETECT:0x0fffffff,\r
1749         _adc:null,\r
1750         _pins:null,\r
1751         _port_no:0,\r
1752         _port:null,\r
1753         _adcr_mask:0,\r
1754         /**\r
1755          * ADポートにオプション値を設定する。\r
1756          *　関数は、ポートを構成する全てのピンに、同一なオプション値を設定する。\r
1757          * 設定可能な値は、LPCXpresso1769.AdcPin#setOptと同じである。\r
1758          * @name LPCXpresso1769.AdcPort#setOpt\r
1759          * @function\r
1760          * @param {object as associative array} i_opt\r
1761          * LPCXpresso1769.AdcPin#setOptを参照。\r
1762          */     \r
1763         setOpt:function setOpt(i_opt)\r
1764         {\r
1765                 try{\r
1766                         var db=new Array();\r
1767                         //BCの生成\r
1768                         var bc="";\r
1769                         //i_optの展開\r
1770                         if(!isUndef(i_opt.pin)){\r
1771                                 var optset=new Array();\r
1772                                 for(var i=0;i<this._pins.length;i++){\r
1773                                         //pinselが_PINSEL_AUTO_DETECTならばauto。そうでなければundefinedも含めて設定\r
1774                                         var s=(i_opt.pin.sel==this._PINSEL_AUTO_DETECT)?this._pins[i].pin_sel:i_opt.pin.sel;\r
1775                                         optset.push({sel:s,mode:i_opt.pin.mode,od:i_opt.pin.od});\r
1776                                 }\r
1777                         }\r
1778                         //portの設定\r
1779                         bc+=this._port.BCF_setOpts(optset,db);\r
1780                         //隠し。ADxCR\r
1781                         bc+=this._adc.BCF_setSels(this._adcr_mask,i_opt.sel,db);\r
1782                         this._adc._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
1783                         return;\r
1784                 }catch(e){\r
1785                         throw new MiMicException(e);\r
1786                 }\r
1787         },\r
1788         /**\r
1789          * ポートからAD変換した値を得る。\r
1790          * @name LPCXpresso1769.AdcPort#getValues\r
1791          * @function\r
1792          * @return {array[int]}\r
1793          * 12bitのAD変換値の配列である。値の意味は、UM10360 Chapter 29: LPC17xx Analog-to-Digital Converter (ADC)を参照。\r
1794          * 値の順番は、コンストラクタで指定したピン配列の順序と同じである。\r
1795          * @example\r
1796          * //show value of AD0.0,AD0.1 pin\r
1797          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
1798          * var pin=mcu.getPort("AD",[LPCXpresso1769.P0[23],LPCXpresso1769.P0[24]]);\r
1799          * alert(pin.getValues());\r
1800          */     \r
1801         getValues:function getValues()\r
1802         {\r
1803                 try{\r
1804                         //メモリから値取得\r
1805                         var db=new Array();\r
1806                         var bc="";\r
1807                         for(var i=0;i<this._pins.length;i++){\r
1808                                 bc+=this._adc.BCF_getAD0DR(this._pins[i].ch,db);\r
1809                         }\r
1810                         var ret=this._adc._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
1811                         //値の整形\r
1812                         var r=new Array();\r
1813                         for(var i=0;i<this._pins.length;i++){\r
1814                                 r.push((ret.stream[i]>>4)&0x00000fff);\r
1815                         }\r
1816                         return r;\r
1817                 }catch(e){\r
1818                         throw new MiMicException(e);\r
1819                 }\r
1820         }\r
1821 }\r
1822 /**\r
1823  * LPCXPresso1769.AdcPin (AdcPin)クラスのコンストラクタ。\r
1824  * Adcペリフェラルオブジェクトにピン識別子で指定されたピンを関連付けて、AD機能を持つピンを生成する。\r
1825  * 関数は、ピン識別子を元に、そのピンがAD機能に接続できるかを調べる。ピンにAD機能を割り当てられない場合、例外が発生する。どのピンにAD機能が割り当てられるかは、MCUのスペックシートを参照すること。\r
1826  * @constructor\r
1827  * @name LPCXpresso1769.AdcPin\r
1828  * @param {object as LPCXpresso1769.Adc} i_adc\r
1829  * インスタンスを結びつけるAdcオブジェクト。\r
1830  * @param {object as pin識別子} i_pin\r
1831  * ピン識別子。指定できるのは、LPCXpresso1796.P?[?]である。\r
1832  * @param {object as associative array} i_opt\r
1833  * setOpt関数のi_optに渡すパラメタである。省略可能。省略時は{pin:{sel:auto}}を設定する。\r
1834  * autoは、関数が自動的に決定するPINSELの値である。詳細はsetOpt関数を参照。 \r
1835  * @example\r
1836  * //create AD0.0\r
1837  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1838  * var adc=new LPCXpresso1769.Adc(mcu);\r
1839  * var adcpin=new  LPCXpresso1769.AdcPin(adc,LPCXpresso1769.P0[23]); \r
1840  */\r
1841 DEV.AdcPin=function AdcPin(i_adc,i_pin,i_opt)\r
1842 {\r
1843         try{\r
1844                 this._aport=new DEV.AdcPort(i_adc,[i_pin],i_opt);\r
1845         }catch(e){\r
1846                 throw new MiMicException(e);\r
1847         }\r
1848 }\r
1849 \r
1850 DEV.AdcPin.prototype=\r
1851 {\r
1852         _aport:null,\r
1853         /**\r
1854          * ピンからAD変換した値を得る。\r
1855          * @name LPCXpresso1769.AdcPin#getValue\r
1856          * @function\r
1857          * @return {int}\r
1858          * 12bitのAD変換値を返す。値の意味は、UM10360 Chapter 29: LPC17xx Analog-to-Digital Converter (ADC)を参照。\r
1859          * @example\r
1860          * //show value of AD0.0 pin\r
1861          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
1862          * var pin=mcu.getPin("AD0.0");\r
1863          * alert(pin.getValue());        \r
1864          */\r
1865         getValue:function getValue()\r
1866         {\r
1867                 try{\r
1868                         return this._aport.getValues()[0];\r
1869                 }catch(e){\r
1870                         throw new MiMicException(e);\r
1871                 }\r
1872         },\r
1873         /**\r
1874          * ADピンにオプション値を設定する。\r
1875          * @name LPCXpresso1769.AdcPin#setOpt\r
1876          * @function\r
1877          * @param {object as associative array} i_opt\r
1878          * ADピンのコンフィグレーションパラメタである。必要な値を格納した連想配列で指定する。\r
1879          * 全ての値を省略することは出来ない。連想配列のメンバは以下の通り。\r
1880          * <pre>{pin:object as associative array}</pre>\r
1881          * <ul>\r
1882          * <li>pin - LPCXpresso1769.Pin#setOpt関数のi_optに渡すパラメタである。</li>\r
1883          * </ul>\r
1884          */     \r
1885         setOpt:function setOpt(i_opt)\r
1886         {\r
1887                 try{\r
1888                         this._aport.setOpt(i_opt);\r
1889                 }catch(e){\r
1890                         throw new MiMicException(e);\r
1891                 }\r
1892         }\r
1893 }\r
1894         \r
1895 \r
1896 \r
1897 }());\r
1898 /**\r
1899  * @fileOverview LPCXpresso1769の、GPIOペリフェラル、ピンの制御クラスを定義する。\r
1900  */\r
1901 \r
1902 (function(){\r
1903 var DEV=LPCXpresso1769;\r
1904 var BCF=DEV._BCF;\r
1905 var EE=DEV._EE;\r
1906 var isUndef=MiMicLib.isUndef;\r
1907 var cloneAssoc=MiMicLib.cloneAssoc;\r
1908 \r
1909 /**\r
1910  * LPCXPresso1769.Gpio (Gpio)クラスのコンストラクタ。\r
1911  * MCUに関連付けしたGpioペリフェラルを生成する。\r
1912  * GPIOペリフェラルは、物理的には存在しない仮想ペリフェラルである。GPIOを集中管理するために定義している。\r
1913  * @name LPCXpresso1769.Gpio\r
1914  * @constructor\r
1915  * @param {object as LPCXpresso1769.Mcu} i_mcu\r
1916  * インスタンスを結びつけるMcuオブジェクト。\r
1917  * @param {oject as associative array} i_opt\r
1918  * 常に無視する。省略すること。\r
1919  * @example\r
1920  * //create GPIO (logical)pheripheral\r
1921  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
1922  * var gpio=new LPCXpresso1769.Gpio(mcu);
1923  */\r
1924 DEV.Gpio=function Gpio(i_mcu,i_opt)\r
1925 {\r
1926         try{\r
1927                 this._mcu=i_mcu;\r
1928                 i_mcu.registerPhl(this,"GPIO");\r
1929         }catch(e){\r
1930                 throw new MiMicException(e);\r
1931         }\r
1932 }\r
1933 DEV.Gpio.prototype={\r
1934         _FIO_DIR :[0x2009C000,0x2009C020,0x2009C040,0x2009C060,0x2009C080],\r
1935         _FIO_PIN :[0x2009C014,0x2009C034,0x2009C054,0x2009C074,0x2009C094],\r
1936         _FIO_SET :[0x2009C018,0x2009C038,0x2009C058,0x2009C078,0x2009C098],\r
1937         _FIO_CLR :[0x2009C01C,0x2009C03C,0x2009C05C,0x2009C07C,0x2009C09C],\r
1938         _FIO_MASK:[0x2009C010,0x2009C030,0x2009C050,0x2009C070,0x2009C090],\r
1939         _mcu:null,\r
1940         BCF_getValues:function BCF_getValues(i_ch,i_mask,i_db)\r
1941         {\r
1942                 /*GPIOレジスタからとってくるBC\r
1943                 SGET #0;//GPIOの値レジスタアドレス\r
1944                 SGET #1;//GPIOのMASKレジスタアドレス\r
1945                 SGET #2;//MASKレジスタの値\r
1946                 MSET #2,#1;//MASK設定\r
1947                 MGET #3,#0;//値取得\r
1948                 SPUT #3;//SPUT\r
1949                  */\r
1950                 try{\r
1951                         i_db.push(this._FIO_PIN[i_ch],this._FIO_MASK[i_ch],~i_mask);\r
1952                         return "EA00EA01EA02DF0201DB0300EE03";\r
1953                 }catch(e){\r
1954                         throw new MiMicException(e);\r
1955                 }               \r
1956         },\r
1957         /**\r
1958          FIOPINとFIOMASKに値をセットする。\r
1959          SGET #0;//GPIOの値レジスタアドレス\r
1960          SGET #1;//GPIOのMASKレジスタアドレス\r
1961          SGET #2;//MASKレジスタの値\r
1962          SGET #3;//GPIO値\r
1963          MPUT #2,#1;//MASK設定\r
1964          MPUT #3,#0;//値設定\r
1965         * @private\r
1966         */\r
1967         BCF_setValues:function BCF_setValues(i_ch,i_mask,i_value,i_db)\r
1968         {\r
1969                 try{\r
1970                         i_db.push(this._FIO_PIN[i_ch],this._FIO_MASK[i_ch],~i_mask,i_value);\r
1971                         return "EA00EA01EA02EA03DF0201DF0300";\r
1972                 }catch(e){\r
1973                         throw new MiMicException(e);\r
1974                 }\r
1975         },\r
1976         /**\r
1977          * \r
1978          @param i_dir 1 or 0\r
1979          @private
1980          */\r
1981         BCF_setDirs:function BCF_setDirs(i_ch,i_mask,i_dir,i_db)\r
1982         {\r
1983                 try{\r
1984                         return BCF.setBit(this._FIO_DIR[i_ch],i_mask,i_mask*i_dir,0,i_db);\r
1985                 }catch(e){\r
1986                         throw new MiMicException(e);\r
1987                 }\r
1988         },      \r
1989         /**\r
1990          * GPIO機能を持つピンを取得する。\r
1991          * ピン識別子で指定されるピンをGPIOペリフェラルと結合して、GpioPinを生成する。\r
1992          * 関数は、LPCXpresso1769.GpioPinクラスのコンストラクタをコールして、GpioPinを生成する。失敗すると、例外をスローする。\r
1993          * 生成ルールについての詳細は、LPCXpresso1769.GpioPinを参照。\r
1994          * @name LPCXpresso1769.Gpio.getPin\r
1995          * @function\r
1996          * @param {object as ピン識別子} i_pin\r
1997          * GPIO機能を割り当てるPINの識別子である。\r
1998          * @param {object as associative array} i_opt\r
1999          * GpioPinのコンストラクタに渡すオプション値を指定する。省略可能。省略時はundefinedとみなす。詳細はGpioPinのコンストラクタを参照。\r
2000          * @return {object as GpioPin}\r
2001          * GpioPinクラスのオブジェクトである。\r
2002          * @example\r
2003          * //create GpioPin direction=out\r
2004          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2005          * var gpio=new LPCXpresso1769.Gpio(mcu);\r
2006          * var pin=gpio.getPin(LPCXpresso1769.P0[0],{dir:1});\r
2007          */\r
2008         getPin:function getPin(i_pin,i_opt)\r
2009         {\r
2010                 try{\r
2011                         return new DEV.GpioPin(this,i_pin,i_opt);\r
2012                 }catch(e){\r
2013                         throw new MiMicException(e);\r
2014                 }\r
2015         },\r
2016         /**\r
2017          * Gpio機能を持つポート(Pin集合)を取得する。\r
2018          * ピン識別子で指定されるピンのセットをGpioペリフェラルと結合して、GpioPortを生成する。\r
2019          * 関数は、GpioPortのコンストラクタをコールする。\r
2020          * 生成ルールについては、GpioPort関数を参照すること。\r
2021          * @name LPCXpresso1769.Gpio#getPort\r
2022          * @function\r
2023          * @param {array[ピン識別子]} i_pin\r
2024          * Gpioポートを構成するPINの識別子の配列である。値は、LPCXpresso1769.Pn[m]のメンバ変数である。\r
2025          * @param {object as associative array} i_opt\r
2026          * GpioPortのコンストラクタに渡すオプション値。省略時はundefinedである。詳細はLPCXpresso1769.GpioPort.setOptを参照。\r
2027          * @return {object as LPCXpresso1769.GpioPort}\r
2028          * LPCXpresso1769.GpioPortクラスのオブジェクトである。\r
2029          * @example\r
2030          * //create 2AdcPort that has 2 pins.\r
2031          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2032          * var gpio=new LPCXpresso1769.Gpio(mcu);\r
2033          * var port=gpio.getPort([LPCXpresso1769.P0[0],LPCXpresso1769.P0[1]]);\r
2034          */     \r
2035         getPort:function getPort(i_pins,i_opt)\r
2036         {\r
2037                 try{\r
2038                         return new DEV.GpioPort(this,i_pins,i_opt);\r
2039                 }catch(e){\r
2040                         throw new MiMicException(e);\r
2041                 }\r
2042         }\r
2043 }\r
2044 \r
2045 /**\r
2046  * GPIO pinからGPIOInfoを取得
2047  * @private
2048  */\r
2049 function pin2GpioPinInfo(i_pin)\r
2050 {\r
2051         try{\r
2052                 //pinの完全な機能名を得る。(得られれば機能がある。)\r
2053                 var fn=DEV.completePinFunctionName(i_pin,"GPIO");\r
2054                 //pin名からポートとビットを得る。\r
2055                 var a=fn.substring(4).split(".");\r
2056                 //pin情報を構成。\r
2057                 var r={port:parseInt(a[0]),bit:parseInt(a[1]),pin_sel:DEV.getPinSelByFunctionName(i_pin,fn)};\r
2058                 if(!isNaN(r.port) && !isNaN(r.bit)){\r
2059                         return r;\r
2060                 }\r
2061                 throw new MiMicException(EE.INVALID_CFG,"The pin has not GPIO fuction.");\r
2062         }catch(e){\r
2063                 throw new MiMicException(e);    \r
2064         }\r
2065 }\r
2066 \r
2067 /**\r
2068  * LPCXPresso1769.GpioPort (GpioPort)クラスのコンストラクタ。複数のGPIOピンを一括して操作する、パラレルポート等に使用する。\r
2069  * Gpioペリフェラルオブジェクトに、ピン識別子の配列で指定されたピン集合を関連付けて、GPIO機能を持つポートを生成する。\r
2070  * 関数は、ピン識別子を元に、そのピンがGPIO機能に接続できるかを調べる。全てのピンにGPIO機能を割り当てられない場合、例外が発生する。どのピンにGPIO機能が割り当てられるかは、MCUのスペックシートを参照すること。\r
2071  * @constructor\r
2072  * @name LPCXpresso1769.GpioPort\r
2073  * @param {object as LPCXpresso1769.Gpio} i_gpio\r
2074  * インスタンスを結びつけるGpioオブジェクト。\r
2075  * @param {array[pin識別子]} i_pins\r
2076  * ピン識別子の配列。指定できるのは、LPCXpresso1796.P?[?]である。順番は、このインスタンスの返す値の順序に影響する。\r
2077  * 0番目のピンはビット0に対応する。同様に、1番目のピンはビット1に対応する。\r
2078  * 組み合わせるピンは、同じ物理ポートに所属している必要がある。例えば、GPIO0.0とGPIO0.1は組み合わせられるが、GPIO0.0とGPIO1.1は組み合わせることが出来ない。\r
2079  * @param {object as associative array} i_opt\r
2080  * setOpt関数のi_optに渡すパラメタである。省略可能。省略時は{pin:{sel:auto}}を設定する。\r
2081  * autoは、関数が自動的に決定するPINSELの値である。詳細はsetOpt関数を参照。 \r
2082  * @example\r
2083  * //create [AD0.0,AD0.1]\r
2084  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
2085  * var gpio=new LPCXpresso1769.Gpio(mcu);\r
2086  * var port=new LPCXpresso1769.GpioPort(adc,[LPCXpresso1769.P0[0],LPCXpresso1769.P0[1]]); \r
2087  */\r
2088 DEV.GpioPort=function GpioPort(i_gpio,i_pins,i_opt)\r
2089 {\r
2090         try{\r
2091                 this._gpio=i_gpio;\r
2092                 //ピンセットを取得\r
2093                 this._pins=new Array();\r
2094                 //pinに変換する。\r
2095                 for(var i=0;i<i_pins.length;i++){\r
2096                         this._pins.push(pin2GpioPinInfo(i_pins[i]));\r
2097                 }\r
2098                 //pinが全て同じポートに所属しているか確認\r
2099                 var p=this._pins[0].port;\r
2100                 for(var i=1;i<this._pins.length;i++){\r
2101                         if(p!=this._pins[1].port){\r
2102                                 throw new MiMicException("Invalid pin combination.");\r
2103                         }\r
2104                 }\r
2105                 //ポートの生成\r
2106                 this._port=new DEV.Port(i_gpio._mcu,i_pins);\r
2107                 this._port_no=p;\r
2108                 //GPIO用のマスクを生成。\r
2109                 this._mask=0;\r
2110                 for(var i=0;i<this._pins.length;i++){\r
2111                         this._mask|=(0x1<<this._pins[i].bit);\r
2112                 }\r
2113                 //ピンオプションの生成\r
2114                 var opt=cloneAssoc(i_opt);\r
2115                 if(isUndef(opt.pin)){opt.pin={};}\r
2116                 //設定が無ければ、ピンセレクタを自動に設定\r
2117                 if(isUndef(opt.pin.sel)){opt.pin.sel=this._PINSEL_AUTO_DETECT;}\r
2118                 //ピンオプションの設定\r
2119                 this.setOpt(opt);\r
2120         }catch(e){\r
2121                 throw new MiMicException(e);\r
2122         }               \r
2123 }\r
2124 DEV.GpioPort.prototype=\r
2125 {\r
2126         _PINSEL_AUTO_DETECT:0x0fffffff,//setoptに自動を伝えるときに使う\r
2127         _pins:null,\r
2128         _gpio:null,\r
2129         _port_no:0,\r
2130         _port:null,\r
2131         _mask:0,\r
2132         /**\r
2133          * Gpioポートにオプション値を設定する。\r
2134          *　関数は、ポートを構成する全てのピンに、同一なオプション値を設定する。\r
2135          * 設定可能な値は、LPCXpresso1769.GpioPin#setOptと同じである。\r
2136          * @name LPCXpresso1769.GpioPort#setOpt\r
2137          * @function\r
2138          * @param {object as associative array} i_opt\r
2139          * LPCXpresso1769.GpioPin#setOptを参照。\r
2140          */     \r
2141         setOpt:function setOpt(i_opt)\r
2142         {\r
2143                 try{\r
2144                         var db=new Array();\r
2145                         //BCの生成\r
2146                         var bc="";\r
2147                         //dir設定\r
2148                         if(!isUndef(i_opt.dir)){\r
2149                                 bc+=this._gpio.BCF_setDirs(this._port_no,this._mask,i_opt.dir,db);\r
2150                         }\r
2151                         //i_optの展開\r
2152                         if(!isUndef(i_opt.pin)){\r
2153                                 var optset=new Array();\r
2154                                 for(var i=0;i<this._pins.length;i++){\r
2155                                         //pinselが_PINSEL_AUTO_DETECTならばauto。そうでなければundefinedも含めて設定\r
2156                                         var s=(i_opt.pin.sel==this._PINSEL_AUTO_DETECT)?this._pins[i].pin_sel:i_opt.pin.sel;\r
2157                                         optset.push({sel:s,mode:i_opt.pin.mode,od:i_opt.pin.od});\r
2158                                 }\r
2159 \r
2160                         }\r
2161                         //portの設定\r
2162                         bc+=this._port.BCF_setOpts(optset,db);\r
2163                         this._gpio._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
2164                         return;\r
2165                 }catch(e){\r
2166                         throw new MiMicException(e);\r
2167                 }\r
2168         },\r
2169         /**\r
2170          * ポートの出力状態を設定する。\r
2171          * 値は、nビットの整数値で指定する。nは、ポートを構成するピン数である。\r
2172          * この関数は、directionを1(output)に設定したポートで使用できる。inputに設定したピンには使用できない。\r
2173          * @name LPCXpresso1769.GpioPort#setValue\r
2174          * @function\r
2175          * @param {int} i_val\r
2176          * nビットの出力値。ビット数は、このポートを構成するピンの数に一致する。2ビットのポートを構成したときに0x03を指定すると、2本のピンがON状態になる。\r
2177          * @example\r
2178          * //set P0[0] pin to “on”. If LED was connected pin it will turn on.\r
2179          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2180          * port=mcu.getPort([LPCXpresso1769.P0[0],LPCXpresso1769.P0[1]],"GPIO");\r
2181          * port.setOpt({dir:1,pin:{mode:1,od:0}});\r
2182          * port.setValue(0x3);   \r
2183          */     \r
2184         setValue:function setValue(i_val)\r
2185         {\r
2186                 try{\r
2187                         var v=0;\r
2188                         var l=this._pins.length;\r
2189                         for(var i=0;i<l;i++){\r
2190                                 //セットするbit値を得る。\r
2191                                 var sv=((i_val>>i)&0x01);\r
2192                                 //値のセット\r
2193                                 v|=(sv<<this._pins[i].bit);\r
2194                         }\r
2195                         //値をセット\r
2196                         var db=new Array();\r
2197                         var bc=this._gpio.BCF_setValues(this._port_no,this._mask,v,db);\r
2198                         this._gpio._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
2199                 }catch(e){\r
2200                         throw new MiMicException(e);\r
2201                 }\r
2202         },\r
2203         /**\r
2204          * ポートの入力状態を返す。\r
2205          * 値は、nビットの整数値である。nは、ポートを構成するピン数である。\r
2206          * この関数は、directionを0(input)に設定したポートで使用できる。outputに設定したピンには使用できない。\r
2207          * @function\r
2208          * @return {int}\r
2209          * nビットの整数値。ビット数は、このポートを構成するピンの数に一致する。2ビットのポートを構成したときに1,1の入力があると、0x03が返る。\r
2210          * @name LPCXpresso1769.GpioPort#getValue\r
2211          * @example\r
2212          * //show P0[0] value\r
2213          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2214          * var port=mcu.getPort([LPCXpresso1769.P0[0],LPCXpresso1769.P0[1]],"GPIO");\r
2215          * port.setOpt({dir:0,pin:{mode:0,od:0}});\r
2216          * alert(port.getValue());       \r
2217          */     \r
2218         getValue:function getValue()\r
2219         {\r
2220                 try{\r
2221                         var db=new Array();\r
2222                         var bc=this._gpio.BCF_getValues(this._port_no,this._mask,db);\r
2223                         var retval=this._gpio._mcu.callMiMicWithCheck(bc+BCF.END,db).stream[0];\r
2224                         //値の再構成\r
2225                         var v=0;\r
2226                         for(var i=this._pins.length-1;i>=0;i--){\r
2227                                 //セットするbit値を得る。\r
2228                                 var sv=((retval>>this._pins[i].bit)&0x1);\r
2229                                 //値のセット(pinArrayの並びとビット並びが同じになるようにする)\r
2230                                 v=(v<<1)|sv;\r
2231                         }\r
2232                         return v;\r
2233                 }catch(e){\r
2234                         throw new MiMicException(e);\r
2235                 }\r
2236         },\r
2237         /**\r
2238          * 直列化された値パターンを出力する。\r
2239          * ポートに連続した値パターンを出力するときに使用する。\r
2240          * 出力速度はMCU依存であり、コントロールできない。\r
2241          * この関数は、directionを1(output)に設定したポートで使用できる。inputに設定したピンには使用できない。\r
2242          * @name LPCXpresso1769.GpioPort#outPatt\r
2243          * @function\r
2244          * @param {array[int]} i_val_array\r
2245          * ビットパターンの配列。nビットの値(0 or 1)の配列を指定する。最大数は20である。ビット数は、このポートを構成するピンの数に一致する。\r
2246          * [3,0,3,0]の場合、0,3,0,3の順に、パターンを出力する。\r
2247          * @example\r
2248          * //output  0x01,0x02 to P0[0]+P0[1]\r
2249          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2250          * var port=mcu.getPin([LPCXpresso1769.P0[0],LPCXpresso1769.P0[1]],"GPIO");\r
2251          * port.setOpt({dir:1,pin:{mode:1,od:0}});\r
2252          * port.outPatt([0x01,0x02]);\r
2253          */     \r
2254         outPatt:function outPatt(i_val_array)\r
2255         {\r
2256                 try{\r
2257                         var db=new Array();\r
2258                         var bc="";\r
2259                         for(var i2=0;i2<i_val_array.length;i2++){\r
2260                                 var v=0;\r
2261                                 var l=this._pins.length;\r
2262                                 for(var i=0;i<l;i++){\r
2263                                         //セットするbit値を得る。\r
2264                                         var sv=((i_val_array[i2]>>i)&0x01);\r
2265                                         //値のセット(pinArrayの並びと最下位ビットの位置が同じになるように反転)\r
2266                                         v|=(sv<<this._pins[i].bit);\r
2267                                 }\r
2268                                 //値をセット\r
2269                                 bc+=this._gpio.BCF_setValues(this._port_no,this._mask,v,db);\r
2270                         }\r
2271                         this._gpio._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
2272                 }catch(e){\r
2273                         throw new MiMicException(e);\r
2274                 }\r
2275         }\r
2276 }\r
2277 \r
2278 \r
2279 /**\r
2280  * LPCXPresso1769.GpioPin (GpioPin)クラスのコンストラクタ。\r
2281  * Gpioペリフェラルオブジェクトにピン識別子で指定されたピンを関連付けて、GPIO機能を持つピンを生成する。\r
2282  * 関数は、ピン識別子を元に、そのピンがGPIO機能に接続できるかを調べる。ピンにGPIO機能を割り当てられない場合、例外が発生する。どのピンにGPIO機能が割り当てられるかは、MCUのスペックシートを参照すること。\r
2283  * ピンがGPIO機能を持たない場合、例外が発生する。\r
2284  * @name LPCXpresso1769.GpioPin\r
2285  * @constructor\r
2286  * @param i_gpio\r
2287  * インスタンスを結びつけるGpioオブジェクト。\r
2288  * @param {object as pin識別子} i_pin\r
2289  * ピン識別子。指定できるのは、LPCXpresso1796.P?[?]である。\r
2290  * @param i_opt\r
2291  * setOpt関数のi_optに渡すパラメタ。省略可能。\r
2292  * 省略時は、{pin:{sel:auto}}を使用する。autoは関数が自動的に決定PINSEL値である。\r
2293  * 詳細はsetOpt関数を参照。\r
2294  * @example\r
2295  * //create GPIO Port 0.0 dir=out\r
2296  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
2297  * var gpio=new LPCXpresso1769.Gpio(mcu);\r
2298  * var pin=new  LPCXpresso1769.GpioPin(gpio,P0[0],{dir:1}); \r
2299  */\r
2300 DEV.GpioPin=function GpioPin(i_gpio,i_pin,i_opt)\r
2301 {\r
2302         try{\r
2303                 //1ピンのポート\r
2304                 this._gport=new DEV.GpioPort(i_gpio,[i_pin],i_opt);\r
2305         }catch(e){\r
2306                 throw new MiMicException(e);\r
2307         }\r
2308 }\r
2309 DEV.GpioPin.prototype=\r
2310 {\r
2311         _gport:null,\r
2312         /**\r
2313          * ADピンにオプション値を設定する。\r
2314          * @name LPCXpresso1769.GpioPin#setOpt\r
2315          * @function\r
2316          * @param {object as associative array} i_opt\r
2317          * GPIOピンのコンフィグレーションパラメタである。必要な値を格納した連想配列で指定する。\r
2318          * 全ての値を省略することは出来ない。連想配列のメンバは以下の通り。\r
2319          * <pre>{dir:int,pin:object as associative array}</pre>\r
2320          * <ul>\r
2321          * <li>dir - ピンのIN/OUTを指定する1bitの値。1=out,0=in</li>\r
2322          * <li>pin - LPCXpresso1769.Pin#setOpt関数のi_optに渡すパラメタである。</li>\r
2323          * </ul>\r
2324          * @example\r
2325          * //set P0[0] to output  GPIO and mode=repeter and open drain=1\r
2326          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2327          * var gpiopin=mcu.getPin(LPCXpresso1769.P0[0],"GPIO");\r
2328          * gpiopin.setOpt({dir:1,pin:{mode:1,od:0}});\r
2329          * gpiopin.setValue(1);  \r
2330          */     \r
2331         setOpt:function setOpt(i_opt)\r
2332         {\r
2333                 try{\r
2334                         this._gport.setOpt(i_opt);\r
2335                 }catch(e){\r
2336                         throw new MiMicException(e);\r
2337                 }\r
2338         },\r
2339         /**\r
2340          * ピンの出力状態を設定する。\r
2341          * この関数は、directionを1(output)に設定したピンで使用できる。inputに設定したピンには使用できない。\r
2342          * @name LPCXpresso1769.GpioPin#setValue\r
2343          * @function\r
2344          * @param {int} i_val\r
2345          * 1ビットの出力値。\r
2346          * @example\r
2347          * //set P0[0] pin to “on”. If LED was connected pin it will turn on.\r
2348          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2349          * var gpiopin=mcu.getPin(LPCXpresso1769.P0[0],"GPIO");\r
2350          * gpiopin.setOpt({dir:1,pin:{mode:1,od:0}});\r
2351          * gpiopin.setValue(1);  \r
2352          */\r
2353         setValue:function setValue(i_val)\r
2354         {\r
2355                 try{\r
2356                         this._gport.setValue(i_val);\r
2357                 }catch(e){\r
2358                         throw new MiMicException(e);\r
2359                 }\r
2360         },      \r
2361         /**\r
2362          * ピンの入力状態を1/0で返す。\r
2363          * この関数は、directionを0(input)に設定したピンで使用できる。outputに設定したピンには使用できない。\r
2364          * @function\r
2365          * @return {int}\r
2366          * 1,又は0\r
2367          * @name LPCXpresso1769.GpioPin#getValue\r
2368          * @example\r
2369          * //show P0[0] value\r
2370          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2371          * var gpiopin=mcu.getPin(LPCXpresso1769.P0[0],"GPIO");\r
2372          * gpiopin.setOpt({dir:0,pin:{mode:0,od:0}});\r
2373          * alert(gpiopin.getValue());    \r
2374          */\r
2375         getValue:function getValue()\r
2376         {\r
2377                 try{\r
2378                         return this._gport.getValue();\r
2379                 }catch(e){\r
2380                         throw new MiMicException(e);\r
2381                 }\r
2382         },\r
2383         /**\r
2384          * 直列化されたビットパターンを出力する。\r
2385          *　単純なビットパターンをピンに出力するときに使用する。\r
2386          * 出力速度はMCU依存であり、コントロールできない。\r
2387          * この関数は、directionを1(output)に設定したピンで使用できる。inputに設定したピンには使用できない。\r
2388          * @name LPCXpresso1769.GpioPin#outPatt\r
2389          * @function\r
2390          * @param {array[int]} i_val_array\r
2391          * ビットパターンの配列。1ビットの値(0 or 1)の配列を指定する。最大数は20である。\r
2392          * [0,1,0,1]の場合、0,1,0,1の順に、パターンを出力します。\r
2393          * @example\r
2394          * //output  0101010100001010 to P0[0]\r
2395          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2396          * var gpiopin=mcu.getPin(LPCXpresso1769.P0[0],"GPIO");\r
2397          * gpiopin.setOpt({dir:1,pin:{mode:1,od:0}});\r
2398          * gpiopin.outPatt([0,1,0,1,0,1,0,1,0,0,0,0,1,0,1,0]);\r
2399          */\r
2400         outPatt:function outPatt(i_val_array)\r
2401         {\r
2402                 try{\r
2403                         this._gport.outPatt(i_val_array);\r
2404                 }catch(e){\r
2405                         throw new MiMicException(e);\r
2406                 }\r
2407         },\r
2408         \r
2409 }\r
2410 \r
2411 }());\r
2412 /**\r
2413  * @fileOverview LPCXpresso1769のPwmペリフェラル、ピンを制御するクラスを定義する。\r
2414  */\r
2415 (function(){\r
2416 var DEV=LPCXpresso1769;\r
2417 var BCF=DEV._BCF;\r
2418 var EE=DEV._EE;\r
2419 var isUndef=MiMicLib.isUndef;\r
2420 var cloneAssoc=MiMicLib.cloneAssoc;\r
2421 \r
2422 \r
2423 \r
2424 /**\r
2425  * LPCXPresso1769.Pwm (Pwm)クラスのコンストラクタ。\r
2426  * MCUに関連付けしたPwmペリフェラルを生成する。\r
2427  * Pwmクラスは、PWM1ペリフェラルを管理して、PWMペリフェラル全体の設定を管理する。\r
2428  * Pwmの分解能は、無指定の場合25MHz(1/4クロック)設定である。関数は、PWMのマッチレジスタ以外に、PCR,CTCR,TCRを同時に初期化する。\r
2429  * @name LPCXpresso1769.Pwm\r
2430  * @constructor\r
2431  * @param {object as LPCXpresso1769.Mcu} i_mcu\r
2432  * インスタンスを結びつけるMcuオブジェクト。\r
2433  * @param {aobject as associative array} i_opt\r
2434  * インスタンス生成と同時にsetOpt関数でセットする値を指定する。省略時は、{freq:100,phl:{power:1,clock:0}}である。\r
2435  * 詳細は、setOpt関数を参照。 \r
2436  * @example\r
2437  * //create PWM  pheripheral\r
2438  * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2439  * var pwm=new LPCXpresso1769.Pwm(mcu,"");\r
2440  */\r
2441 DEV.Pwm=function Pwm(i_mcu,i_opt)\r
2442 {\r
2443         try{\r
2444                 this._mcu=i_mcu;\r
2445                 //PHL生成。\r
2446                 this._phl=new DEV.Peripheral(i_mcu,DEV.PHL.PWM1);\r
2447                 //設定値のロード\r
2448                 var opt=isUndef(i_opt)?{phl:{}}:\r
2449                 {//i_optある。\r
2450                         phl:isUndef(i_opt.phl)?{}:cloneAssoc(i_opt.phl),\r
2451                         freq:i_opt.freq\r
2452                 };\r
2453                 //デフォルト値設定\r
2454                 if(isUndef(opt.phl.power)){opt.phl.power=1;};\r
2455                 if(isUndef(opt.phl.clock)){opt.phl.clock=0;};\r
2456                 if(isUndef(opt.freq)){opt.freq=100;}\r
2457                 \r
2458                 var bc="";\r
2459                 var db=new Array();\r
2460                 //optionの設定\r
2461                 bc+=this.BCF_setOpt(opt,db);\r
2462                 bc+=BCF.setMem(this._PC,0x0,db);\r
2463                 //PCR\r
2464                 bc+=BCF.setMem(this._PCR,0x0,db);\r
2465                 //CTCR\r
2466                 bc+=BCF.setMem(this._CTCR,0x0,db);\r
2467                 //TCRに値設定(カウンタとPWMモードを無効化)\r
2468                 bc+=BCF.setMem(this._TCR,0x0,db);\r
2469                 bc+=BCF.setMem(this._TC,0x0,db);\r
2470                 //TCRに値設定(カウンタとPWMモードを有効化)\r
2471                 bc+=BCF.setMem(this._TCR,0x9,db);\r
2472                 //初期化\r
2473                 this._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
2474                 //ペリフェラルをMCUに登録\r
2475                 this._mcu.registerPhl(this,"PWM");\r
2476         }catch(e){\r
2477                 throw new MiMicException(e);\r
2478         }\r
2479 \r
2480 }\r
2481 DEV.Pwm.prototype=\r
2482 {\r
2483         _cache:{\r
2484                 mr0:0\r
2485         },\r
2486         _TCR:0x40018004,\r
2487         _TC:0x40018008,\r
2488         _PR:0x4001800C,\r
2489         _PC:0x40018010,\r
2490         _MCR:0x40018018,\r
2491         _PCR:0x4001804C,\r
2492         _LER:0x40018050,\r
2493         _CTCR:0x40018070,\r
2494         _MRn:[0x40018018,0x4001801C,0x40018020,0x40018024,0x40018040,0x40018044,0x40018048],\r
2495         _phl:null,\r
2496         _mcu:null,\r
2497 \r
2498         /**\r
2499          * @private
2500          */\r
2501         BCF_setOpt:function BCF_setOpt(i_opt,i_db)\r
2502         {\r
2503                 try{\r
2504                         var bc="";\r
2505                         var phlopt;\r
2506                         var mr0;\r
2507                         //ペリフェラルの設定\r
2508                         if(!isUndef(i_opt.phl)){\r
2509                                 bc+=this._phl.BCF_setOpt(i_opt.phl,i_db);\r
2510                         }\r
2511                         if(!isUndef(i_opt.freq)){\r
2512                                 //サイクル(Hz)とペリフェラルのクロックから、MR0のサイクルを決定\r
2513                                 mr0=Math.round(this._phl.getPCLK()/i_opt.freq);\r
2514                                 if(mr0<=0){\r
2515                                         //ペリフェラルクロック小さすぎﾜﾛﾀ\r
2516                                         throw new MiMicException("The peripheral clock too small.");\r
2517                                 }\r
2518                                 //MR0に値設定\r
2519                                 bc+=this.BCF_setMRn(0,mr0,i_db);\r
2520                                 //LERにビットセット\r
2521                                 bc+=this.BCF_setLER(0,i_db);\r
2522                                 this._cache.mr0=mr0;\r
2523                         }\r
2524                         return bc;\r
2525                 }catch(e){\r
2526                         throw new MiMicException(e);\r
2527                 }\r
2528         },\r
2529         BCF_setLER:function BCF_setLER(i_ch,i_db)\r
2530         {\r
2531                 try{\r
2532                         //LERにビットをセット\r
2533                         return BCF.setBit(this._LER,0x01,0x01,i_ch,i_db);\r
2534                 }catch(e){\r
2535                         throw new MiMicException(e);\r
2536                 }\r
2537         },\r
2538         BCF_setLERs:function BCF_setLERs(i_mask,i_value,i_db)\r
2539         {\r
2540                 try{\r
2541                         //LERにビットをセット\r
2542                         return BCF.setBit(this._LER,i_mask,i_value*i_mask,0,i_db);\r
2543                 }catch(e){\r
2544                         throw new MiMicException(e);\r
2545                 }\r
2546         },\r
2547         \r
2548         /**\r
2549          * MRnに値を設定するBC\r
2550          @private\r
2551          */\r
2552         BCF_setMRn:function BCF_setMRn(i_ch,i_val,i_db)\r
2553         {\r
2554                 try{\r
2555                         return BCF.setMem(this._MRn[i_ch],i_val,i_db);\r
2556                 }catch(e){\r
2557                         throw new MiMicException(e);\r
2558                 }\r
2559         },\r
2560         BCF_setMRnByDuty:function BCF_setMRnByDuty(i_ch,i_duty,i_db)\r
2561         {\r
2562                 try{\r
2563                         return this.BCF_setMRn(i_ch,Math.round(i_duty*this._cache.mr0),i_db);\r
2564                 }catch(e){\r
2565                         throw new MiMicException(e);\r
2566                 }\r
2567         },\r
2568         /**\r
2569          * PCRに値を設定するBC\r
2570          i_ch=1の場合、エッジモードは無視します。\r
2571          @private\r
2572          @param i_mask\r
2573          @param i_edge\r
2574          エッジモード(1/0)\r
2575          @param i_en\r
2576         有効/無効の選択\r
2577          */\r
2578         BCF_setPCRbits:function BCF_setPCRbits(i_mask,i_edge,i_en,i_db)\r
2579         {\r
2580                 try{\r
2581                         var m,v;\r
2582                         m=v=0;\r
2583                         if(!isUndef(i_edge)){\r
2584                                 var t=0xff&i_mask;\r
2585                                 v|=i_edge*t;\r
2586                                 m|=t;\r
2587                         }\r
2588                         if(!isUndef(i_en)){\r
2589                                 var t=0xff00&i_mask;\r
2590                                 v|=(i_en*t);\r
2591                                 m|=t;\r
2592                         }\r
2593                         //ビットの設定\r
2594                         return BCF.setBit(this._PCR,m,v,0,i_db);\r
2595                 }catch(e){\r
2596                         throw new MiMicException(e);\r
2597                 }\r
2598         },\r
2599         \r
2600         /**\r
2601          * Pwmペリフェラルに値を設定する。\r
2602          * 設定する値は、全てのPWMチャンネル（PIN）に共通な項目である。\r
2603          * @name LPCXpresso1769.Pwm#setOpt\r
2604          * @function\r
2605          * @param {object as associative array} i_opt\r
2606          * GPIOピンのコンフィグレーションパラメタである。必要な値を格納した連想配列で指定する。\r
2607          * 全ての値を省略することは出来ない。連想配列のメンバは以下の通り。\r
2608          * <pre>{freq:int,phl:object as associative array}</pre>\r
2609          * <ul>\r
2610          * <li>freq - PWMの基本周波数(Hz)である。この値は、全てのPWMチャンネルで共通である。</li>\r
2611          * <li>phl - ペリフェラルの共通パラメタである。LPCXpresso1769.Peripheral.setOpt関数のi_optに渡すパラメタである。詳細はLPCXpresso1769.Peripheral.setOptを参照。</li>\r
2612          * </ul>\r
2613          * @example\r
2614          * //create PWM (logical)peripheral\r
2615          * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
2616          * var pwm=new LPCXpresso1769.Pwm(mcu);\r
2617          * pwm.setOpt({freq:1000});\r
2618          */\r
2619         setOpt:function setOpt(i_opt)\r
2620         {\r
2621                 try{\r
2622                         var db=new Array();\r
2623                         var bc=this.BCF_setOpt(i_opt,db);\r
2624                         this._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
2625                 }catch(e){\r
2626                         throw new MiMicException(e);\r
2627                 }\r
2628         },      \r
2629         /**\r
2630          * PWM機能を持つピンを取得する。\r
2631          * ピン識別子で指定されるピンをPWMペリフェラルと結合して、PwmPinを生成する。\r
2632          * 関数は、PwmPinオブジェクトのコンストラクタをコールして、PwmPinを生成する。失敗すると、例外をスローする。\r
2633          * 生成ルールについての詳細は、PwmPinを参照。\r
2634          * @name LPCXpresso1769.Pwm#getPin\r
2635          * @function\r
2636          * @param {object as ピン識別子} i_pin\r
2637          * PWM機能を割り当てるPINの識別子である。\r
2638          * @param {object as associative array} i_opt\r
2639          * PemPinのコンストラクタに渡すオプション値。省略時は{duty:0,enable:1,pin:{sel:auto}}である。\r
2640          * @return {object as LPCXpresso1769.PwmPin}\r
2641          * LPCXpresso1769.PwmPinクラスのオブジェクトである。\r
2642          * @example\r
2643          * //create 100hz d=0.5 pwm\r
2644          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2645          * var pwm=new LPCXpresso1769.Pwm(mcu);\r
2646          * var pwmpin=pwm.getPin(LPCXpresso1769.P2[0],{duty:0.5});\r
2647          */\r
2648         getPin:function getPin(i_pin,i_opt)\r
2649         {\r
2650                 try{\r
2651                         return new DEV.PwmPin(this,i_pin,i_opt);\r
2652                 }catch(e){\r
2653                         throw new MiMicException(e);\r
2654                 }\r
2655         },\r
2656         /**\r
2657          * PWM機能を持つポート(Pin集合)を取得する。\r
2658          * ピン識別子で指定されるピンのセットをPWMペリフェラルと結合して、PwmPortを生成する。\r
2659          * 関数は、PwmPortのコンストラクタをコールする。\r
2660          * 生成ルールについては、PwmPort関数を参照すること。\r
2661          * @name LPCXpresso1769.Pwm#getPort\r
2662          * @function\r
2663          * @param {array[ピン識別子]} i_pin\r
2664          * Pwm機能を割り当てるPINの識別子の配列である。値は、LPCXpresso1769.Pn[m]のメンバ変数である。\r
2665          * @param {object as associative array} i_opt\r
2666          * AdcPortのコンストラクタに渡すオプション値。省略時はundefinedである。詳細はLPCXpresso1769.PwmPort.setOptを参照。\r
2667          * @return {object as LPCXpresso1769.PwmPort}\r
2668          * LPCXpresso1769.PwmPortクラスのオブジェクトである。\r
2669          * @example\r
2670          * //create 2AdcPort that has 2 pins.\r
2671          * var mcu=new LPCXpresso1769.Mcu("192.168.0.39");\r
2672          * var pwm=new LPCXpresso1769.Pwm(mcu);\r
2673          * var port=pwm.getPort([LPCXpresso1769.P0[23],LPCXpresso1769.P0[24]]);\r
2674          */\r
2675         getPort:function getPort(i_pins,i_opt)\r
2676         {\r
2677                 try{\r
2678                         return new DEV.PwmPort(this,i_pins,i_opt);\r
2679                 }catch(e){\r
2680                         throw new MiMicException(e);\r
2681                 }\r
2682         }       \r
2683 }\r
2684 \r
2685 /**\r
2686  * Pwm pinからPwmInfoを取得\r
2687  * @private\r
2688  */\r
2689 function pin2PwmPinInfo(i_pin)\r
2690 {\r
2691         try{\r
2692                 //pinの完全な機能名を得る。(得られれば機能がある。)\r
2693                 var fn=DEV.completePinFunctionName(i_pin,"PWM");\r
2694                 //portとbitを得る(AD0だけしか管理しないよ)\r
2695                 var a=fn.substring(2).split(".");\r
2696                 var r={port:0,ch:parseInt(a[1]),pin_sel:DEV.getPinSelByFunctionName(i_pin,fn)};\r
2697                 if(!isNaN(r.ch)){\r
2698                         return r;\r
2699                 }\r
2700                 throw new MiMicException(EE.INVALID_CFG,"The pin has not PWM fuction.");\r
2701         }catch(e){\r
2702                 throw new MiMicException(e);    \r
2703         }\r
2704 }\r
2705 /**\r
2706  * Pwmペリフェラルと複数のPin識別子から、シングルエッジPwmポートを構成する。\r
2707  * Pwmペリフェラルオブジェクトにピン識別子の配列で指定されたピンを関連付けて、PWM機能を持つポートを生成する。\r
2708  * 関数は、ピン識別子を元に、それぞれのピンがPWM機能に接続できるかを調べる。\r
2709  * ピンにPWM機能を割り当てられない場合、例外が発生する。どのピンにPWM機能が割り当てられるかは、MCUのスペックシートを参照すること。\r
2710  * PWMポートは、複数の同一周期のPWMピンのデューティ比を、同期して操作するときに便利である。\r
2711  * @constructor\r
2712  * @name LPCXpresso1769.PwmPort\r
2713  * @param {object as LPCXpresso1769.Pwm} i_pwm\r
2714  * インスタンスを結びつけるPwmオブジェクト。\r
2715  * @param {array[pin識別子]} i_pins\r
2716  * ピン識別子の配列。指定できるのは、LPCXpresso1796.P?[?]である。\r
2717  * @param {object as associative array} i_opt\r
2718  * setOpt関数のi_optに渡すパラメタである。省略可能。省略時は{duty:100,enable:1,pin{sel:auto}}を設定する。\r
2719  * autoは、関数が自動的に決定するPINSELの値である。詳細はsetOpt関数を参照。 \r
2720  * dutyをピン毎に設定する場合は、setDuty関数を使うこと。\r
2721  * @example\r
2722  * //create PWM1.0,PWM1.1\r
2723  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
2724  * var pwm=new LPCXpresso1769.Pwm(mcu,{freq:100});\r
2725  * var port=new LPCXpresso1769.PwmPort(pwm,[LPCXpresso1769.P2[0],LPCXpresso1769.P2[1]]); \r
2726  */\r
2727 DEV.PwmPort=function PwmPort(i_pwm,i_pins,i_opt)\r
2728 {\r
2729         try{\r
2730                 this._pwm=i_pwm;\r
2731                 //ピンセットを取得\r
2732                 this._pins=new Array();\r
2733                 //pinに変換する。\r
2734                 for(var i=0;i<i_pins.length;i++){\r
2735                         this._pins.push(pin2PwmPinInfo(i_pins[i]));\r
2736                 }\r
2737                 //pinが全て同じポートに所属しているか確認\r
2738                 var p=this._pins[0].port;\r
2739                 for(var i=1;i<this._pins.length;i++){\r
2740                         if(p!=this._pins[1].port){\r
2741                                 throw new MiMicException("Invalid pin combination.");\r
2742                         }\r
2743                 }\r
2744                 //ポートの生成\r
2745                 this._port=new DEV.Port(i_pwm._mcu,i_pins);\r
2746                 this._port_no=p;\r
2747                 \r
2748                 this._ler_mask=0;\r
2749                 this._pcr_mask=0;\r
2750                 for(var i=0;i<this._pins.length;i++){\r
2751                         this._ler_mask|=(0x1<<this._pins[i].ch);\r
2752                         this._pcr_mask|=(0x101<<this._pins[i].ch);\r
2753                 }               \r
2754                 var opt=isUndef(i_opt)?{pin:{}}:\r
2755                 {\r
2756                         pin:isUndef(i_opt.pin)?{}:cloneAssoc(i_opt.pin),\r
2757                         duty:i_opt.duty,\r
2758                         enable:i_opt.enable\r
2759                 };\r
2760                 //デフォルト値のロード\r
2761                 if(isUndef(opt.pin.sel)){opt.pin.sel=this._PINSEL_AUTO_DETECT;}\r
2762                 if(isUndef(opt.duty)){opt.duty=0;}\r
2763                 if(isUndef(opt.enable)){opt.enable=1;}\r
2764                 this.setOpt(opt);\r
2765         }catch(e){\r
2766                 throw new MiMicException(e);\r
2767         }       \r
2768 }\r
2769 DEV.PwmPort.prototype=\r
2770 {\r
2771         _PINSEL_AUTO_DETECT:0x0fffffff,\r
2772         _pwm:null,\r
2773         _pins:null,\r
2774         _port_no:0,\r
2775         _port:null,\r
2776         _pcr_mask:0,\r
2777         _ler_mask:0,\r
2778         /**\r
2779          * PWMポートにオプション値を設定する。\r
2780          * 関数は、ポートを構成する全てのピンに、同じ値を設定する。\r
2781          * 設定可能な値は、LPCXpresso1769.PwmPin#setOptと同じである。     \r
2782          * @name LPCXpresso1769.PwmPort#setOpt\r
2783          * @function\r
2784          * @param {object as associative array} i_opt\r
2785          * LPCXpresso1769.PwmPin#setOptを参照。\r
2786          * @example\r
2787          * var mcu=new LPCXpresso1769.Mcu("192.168.128.39",true);\r
2788          * var pwm=mcu.getPeripheral("PWM",{freq:100});\r
2789          * var port=pwm.getPort([LPCXpresso1769.P2[0]]);\r
2790          * port.setOpt({enable:0});\r
2791          */\r
2792         setOpt:function setOpt(i_opt)\r
2793         {\r
2794                 try{\r
2795                         var db=new Array();\r
2796                         //BCの生成\r
2797                         var bc="";\r
2798                         //i_optの展開\r
2799                         if(!isUndef(i_opt.pin)){\r
2800                                 var optset=new Array();\r
2801                                 for(var i=0;i<this._pins.length;i++){\r
2802                                         //pinselが_PINSEL_AUTO_DETECTならばauto。そうでなければundefinedも含めて設定\r
2803                                         var s=(i_opt.pin.sel==this._PINSEL_AUTO_DETECT)?this._pins[i].pin_sel:i_opt.pin.sel;\r
2804                                         optset.push({sel:s,mode:i_opt.pin.mode,od:i_opt.pin.od});\r
2805                                 }\r
2806                         }\r
2807                         //portの設定\r
2808                         bc+=this._port.BCF_setOpts(optset,db);\r
2809                         //PCRに値設定\r
2810                         if(!isUndef(i_opt.enable)){\r
2811                                 bc+=this._pwm.BCF_setPCRbits(this._pcr_mask,0,i_opt.enable,db);\r
2812                         }\r
2813                         //デューティ比を\r
2814                         if(!isUndef(i_opt.duty)){\r
2815                                 //デューティ比を設定\r
2816                                 for(var i=0;i<this._pins.length;i++){\r
2817                                         bc+=this._pwm.BCF_setMRnByDuty(this._pins[i].ch,i_opt.duty,db);\r
2818                                 }\r
2819                                 //LERにセット\r
2820                                 bc+=this._pwm.BCF_setLERs(this._ler_mask,1,db);\r
2821                         }\r
2822                         this._pwm._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
2823                         return;\r
2824                 }catch(e){\r
2825                         throw new MiMicException(e);\r
2826                 }\r
2827         },\r
2828         /**\r
2829          * PWMポートのデューティ比をまとめて変更する。\r
2830          * @name LPCXpresso1769.PwmPort#setDutys\r
2831          * @function\r
2832          * @param {array[double]} i_duty_array\r
2833          * デューティ比の配列である。0.0<=n<=1.0のdouble値を指定する。\r
2834          * ポートを構成するピンの数だけ指定する。変更しないピンには、undefinedを指定すること。\r
2835          * @example\r
2836          * varmcu=new LPCXpresso1769.Mcu("192.168.128.39",true);\r
2837          * var pwm=mcu.getPeripheral("PWM",{freq:100});\r
2838          * var port=pwm.getPort([LPCXpresso1769.P2[0],LPCXpresso1769.P2[1]]);\r
2839          * pwm.setDutys([0.5,0.0]);//PWM0=0.5,PWM1=0.0\r
2840          * pwm.setDutys([undefined,0.0]);//PWM1=0.0\r
2841          */     \r
2842         setDutys:function setDutys(i_duty_array)\r
2843         {\r
2844                 try{\r
2845                         if(i_duty_array.length!=this._pins.length){\r
2846                                 throw new MiMicException(e);\r
2847                         }\r
2848                         var bc="";\r
2849                         var db=new Array();\r
2850                         //デューティ比をまとめてセット\r
2851                         for(var i=0;i<this._pins.length;i++){\r
2852                                 if(!isUndef(i_duty_array[i])){\r
2853                                         bc+=this._pwm.BCF_setMRnByDuty(this._pins[i].ch,i_duty_array[i],db);\r
2854                                 }\r
2855                         }\r
2856                         //LERにセット\r
2857                         bc+=this._pwm.BCF_setLERs(this._ler_mask,1,db);\r
2858                         this._pwm._mcu.callMiMicWithCheck(bc+BCF.END,db);\r
2859                 }catch(e){\r
2860                         throw new MiMicException(e);\r
2861                 }\r
2862         }\r
2863 }\r
2864 /**\r
2865  * PwmペリフェラルとPin識別子から、シングルエッジPwmピンを構成する。\r
2866  * Pwmペリフェラルオブジェクトにピン識別子で指定されたピンを関連付けて、PWM機能を持つピンを生成する。\r
2867  * 関数は、ピン識別子を元に、そのピンがPWM機能に接続できるかを調べる。ピンにPWM機能を割り当てられない場合、例外が発生する。どのピンにPWM機能が割り当てられるかは、MCUのスペックシートを参照すること。\r
2868  * ピンがPWM機能を持たない場合、例外が発生する。\r
2869  * @constructor\r
2870  * @name LPCXpresso1769.PwmPin\r
2871  * @param {object as LPCXpresso1769.Pwm} i_pwm\r
2872  * インスタンスを結びつけるAdcオブジェクト。\r
2873  * @param {object as pin識別子} i_pin\r
2874  * ピン識別子。指定できるのは、LPCXpresso1796.P?[?]である。\r
2875  * @param {object as associative array} i_opt\r
2876  * setOpt関数のi_optに渡すパラメタである。省略可能。省略時は{duty:100,enable:1,pin{sel:auto}}を設定する。\r
2877  * autoは、関数が自動的に決定するPINSELの値である。詳細はsetOpt関数を参照。 \r
2878  * @example\r
2879  * //create PWM1.0\r
2880  * var mcu=new LPCXpresso1769.Mcu(“192.168.0.39”);\r
2881  * var pwm=new LPCXpresso1769.Pwm(mcu,{freq:100});\r
2882  * var pwmpin=new LPCXpresso1769.PwmPin(pwm,P2[0]); \r
2883  */\r
2884 DEV.PwmPin=function PwmPin(i_pwm,i_pin,i_opt)\r
2885 {\r
2886         try{\r
2887                 //1pinのポートとして実装\r
2888                 this._pport=new DEV.PwmPort(i_pwm,[i_pin],i_opt);\r
2889         }catch(e){\r
2890                 throw new MiMicException(e);\r
2891         }\r
2892 }\r
2893 \r
2894 DEV.PwmPin.prototype=\r
2895 {\r
2896         _pport:null,\r
2897 \r
2898         /**\r
2899          * PWMピンにオプション値を設定する。\r
2900          * @name LPCXpresso1769.PwmPin#setOpt\r
2901          * @function\r
2902          * @param {object as associative array} i_opt\r
2903          * PWMピンのコンフィグレーションパラメタである。必要な値を格納した連想配列で指定する。\r
2904          * 全ての値を省略することは出来ない。連想配列のメンバは以下の通り。\r
2905          * <pre>{pin:{associative array},enable:int,duty:double}</pre>\r
2906          * <ul>\r
2907          * <li>pin - LPCXpresso1769.Pin#setOpt関数のi_optに渡すパラメタである。</li>\r
2908          * <li>enable - PWMの有効/無効を切り替える。1で有効。</li>\r
2909          * <li>duty - デューティ比である。0.0<=n<=1.0のdouble値を指定する。</li>\r
2910          * </ul>\r
2911          * @example\r
2912          * var mcu=new LPCXpresso1769.Mcu("192.168.128.39",true);\r
2913          * var pwm=mcu.getPeripheral("PWM",{freq:100});\r
2914          * var pin=pwm.getPin(LPCXpresso1769.P2[0]);\r
2915          * pin.setOpt({duty:0});\r
2916          */\r
2917         setOpt:function setOpt(i_opt)\r
2918         {\r
2919                 try{\r
2920                         this._pport.setOpt(i_opt);\r
2921                 }catch(e){\r
2922                         throw new MiMicException(e);\r
2923                 }\r
2924         },\r
2925         /**\r
2926          * PWMのデューティ比を変更する。\r
2927          * @name LPCXpresso1769.PwmPin#setDuty\r
2928          * @function\r
2929          * @param {double} i_duty\r
2930          * デューティ比である。0.0<=n<=1.0のdouble値を指定する。\r
2931          * @example\r
2932          * varmcu=new LPCXpresso1769.Mcu("192.168.128.39",true);\r
2933          * var pwm=mcu.getPeripheral("PWM",{freq:100});\r
2934          * pwmpin=pwm.getPin(LPCXpresso1769.P2[0]);\r
2935          * pwmpin.setDuty(0.5);\r
2936          */\r
2937         setDuty:function setDuty(i_duty)\r
2938         {\r
2939                 try{\r
2940                         this._pport.setDuty([i_duty]);\r
2941                 }catch(e){\r
2942                         throw new MiMicException(e);\r
2943                 }\r
2944         }\r
2945 }\r
2946         \r
2947 \r
2948 \r
2949 }());\r
2950 /**\r
2951  * @fileOverview LPCXpresso1769における、ネイティブ関数コールインタフェイスを定義する。\r
2952   */\r
2953 (function(){\r
2954 var DEV=LPCXpresso1769;\r
2955 var BCF=DEV._BCF;\r
2956 var EE=DEV._EE;\r
2957 var isUndef=MiMicLib.isUndef;\r
2958 \r
2959 \r
2960 \r
2961 /**\r
2962  * LPCXPresso1769.Ni (NativeInterface)クラスのコンストラクタ。\r
2963  * MCUに関連付けしたネイティブインタフェイスを生成する。\r
2964  * クラスは、MiMicVMのCALL命令を使用した、ネイティブ関数コール機能を提供する。\r
2965  * @constructor\r
2966  * @name LPCXpresso1769.Ni\r
2967  * @param {object as LPCXpresso1769.Mcu} i_mcu\r
2968  * インスタンスを結びつけるMcuオブジェクト。\r
2969  * @example\r
2970  */\r
2971 DEV.Ni=function Ni(i_mcu)\r
2972 {\r
2973         try{\r
2974                 this._mcu=i_mcu;\r
2975         }catch(e){\r
2976                 throw new MiMicException(e);\r
2977         }\r
2978 \r
2979 }\r
2980 DEV.Ni.prototype=\r
2981 {\r
2982         /**\r
2983          * この関数は、CALLインストラクションを使ったネイティブファンクションコールを実行する。\r
2984          * MiMicRemoteMCUに定義されているネイティブ関数から、ファンクションIDに一致するものを検索して、実行する。\r
2985          * ネイティブ関数は、native_function.cのnaitive_function_tableに定義されている。\r
2986          * 引き渡すパラメータは、SPUTによるストリーム値と、VMのレジスタ(WM)値である。得られる返却値は、ネイティブ関数実行後のVMレジスタ(WM)と、ストリームである。\r
2987          * @name LPCXpresso1769.Ni#call\r
2988          * @function\r
2989          * @param {int} i_id\r
2990          * ファンクションID。ファンクションIDは、呼び出す関数を識別するidである。\r
2991          * @param {object as associative array} i_in\r
2992          * 入力パラメータである。必要な値を格納した連想配列で指定する。省略が可能である。\r
2993          * 連想配列のメンバは以下の通り。\r
2994          * <pre>{wm?:int,stream:array[int]}</pre>\r
2995          *\r
2996          * <ul>\r
2997          * <li>wm? - WMレジスタにセットする値である。wm0～wm7まで、最大8個の値を指定できる。</li>\r
2998          * <li>stream - ストリームに出力する値である。長さに制限は無いが、100個程度が上限である。</li>\r
2999          * </ul>\r
3000          * @param {object as associative array} o_out\r
3001          * 出力パラメータを受け取る変数である。戻り値として取得したい値を格納した連想配列を指定する。省略が可能である。\r
3002          * 各メンバ変数は関数が割り当てるので、nullを設定しておくこと。\r
3003          * 連想配列のメンバは以下の通り。\r
3004          * <pre>{wm?:null,stream:null}</pre>\r
3005          * <ul>\r
3006          * <li>wm? - 取得するWMレジスタのプレースホルダ。戻り値としてwmレジスタの値を取得する時に指定する。取得したいWMを指定する。</li>\r
3007          * <li>stream - 取得するストリームのプレースホルダ。戻り値としてネイティブ関数が出力したストリームを取得する時に指定する。純粋な返却streamから、wmの返却分を差し引いたint array値である。</li>\r
3008          * </ul>\r
3009          * @return {boolean}\r
3010          * 関数コールが成功するとtrueである。\r
3011          * @example\r
3012          * var mcu=new LPCXpresso1769.Mcu("192.168.128.39",true);\r
3013          * var ni=new LPCXpresso1769.Ni(mcu);\r
3014          * //This function calls the function number 1. wm1=1,wm2=3 are set to WM before calling. And puts [12] to input stream.\r
3015          * //Out values are consist of wm4,wm5 and output stream values.\r
3016          * var r1={wm4:null,wm5:null};\r
3017          * nativeCall(0,{wm1:1,wm2:3,stream:[12]},r1);\r
3018          *\r
3019          * //sample2 no parameter, returns.\r
3020          * nativeCall(0);\r
3021          * \r
3022          * //sample 3 stream only.\r
3023          * var r2={stream:null};\r
3024          * nativeCall(0,{stream:[]},r2);\r
3025          *\r
3026          * //call sample echo back native function.\r
3027          * var r3={stream:null};\r
3028          * nativeCall(0x39000000,{stream:[0x2525]},r3);\r
3029          * alert(r3[0]);\r
3030          *\r
3031          * // set/get all work register and stream.\r
3032          * var r4={stream:null,wm0:null,wm1:null,wm2:null,wm3:null,wm4:null,wm5:null,wm6:null,wm7:null};\r
3033          * ni.call(0x39000000,{stream:[0x39],wm0:7,wm1:6,wm2:5,wm3:4,wm4:3,wm5:2,wm6:1,wm7:0},r4);\r
3034          *\r
3035          */\r
3036         call:function call(i_id,i_in,o_out)\r
3037         {\r
3038                 /*\r
3039                  * .DBは、WM設定値(あれば),idx番号,stream値の順で格納。\r
3040                  * 命令は、\r
3041                  * WM初期化部(LD配列)\r
3042                  * LD #0;WM初期化(あれば)\r
3043                  * :\r
3044                  * SGET
3045                  */\r
3046                 var bc="";\r
3047                 var db=new Array();\r
3048                 //WM初期化命令\r
3049                 if(!isUndef(i_in)){\r
3050                         //wmがあれば、初期化命令を追加。\r
3051                         //LD命令を直書き\r
3052                         for(var i=0;i<8;i++){\r
3053                                 var hash="wm"+i;\r
3054                                 if(!isUndef(i_in[hash])){\r
3055                                         bc+="FB"+MiMicLib.hexout(i,2)+MiMicLib.hexout(i_in[hash],8);\r
3056                                 }\r
3057                         }\r
3058                         //streamをセット\r
3059                         if(!isUndef(i_in.stream)){\r
3060                                 for(var i=0;i<i_in.stream.length;i++){\r
3061                                         db.push(i_in.stream[i]);\r
3062                                 }\r
3063                         }\r
3064                 }\r
3065                 //CALL命令を直書き\r
3066                 bc+="ZF"+MiMicLib.hexout(i_id,8);\r
3067                 //\r
3068                 var num_of_wm=0;\r
3069                 if(!isUndef(o_out)){\r
3070                         //o_out.wmxがあれば、回収用命令を追記\r
3071                         //SGET命令を直書き\r
3072                         for(var i=0;i<8;i++){\r
3073                                 if(!isUndef(o_out["wm"+i])){\r
3074                                         bc+="EE"+MiMicLib.hexout(i,2);\r
3075                                         num_of_wm++;\r
3076                                 }\r
3077                         }\r
3078                 }\r
3079                 //実行\r
3080                 var ret=this._mcu.callMiMic(bc+BCF.END,db);\r
3081                 if(ret.result!=0x00){\r
3082                         //失敗.理由はresultの内容。\r
3083                         return false;\r
3084                 }\r
3085                 //streamから値を回収\r
3086                 //streamは、関数の返したストリーム+WMの返却値\r
3087                 var c=0;\r
3088                 if(!isUndef(o_out)){\r
3089                         //WM回収のためにSGET命令を直書き\r
3090                         var offset=ret.stream.length-num_of_wm;\r
3091                         for(var i=0;i<8;i++){\r
3092                                 var hash="wm"+i;\r
3093                                 if(!isUndef(o_out[hash])){\r
3094                                         o_out[hash]=ret.stream[offset];\r
3095                                         offset++;\r
3096                                 }\r
3097                         }\r
3098                         //o_out.streamがあれば、値を回収。\r
3099                         if(!isUndef(o_out.stream)){\r
3100                                 o_out.stream=ret.stream.slice(0,ret.stream.length-num_of_wm);\r
3101                         }\r
3102                 }\r
3103                 return false;\r
3104         }\r
3105 }\r
3106 \r
3107 \r
3108 \r
3109 \r
3110 }());\r