OSDN -- 开发和下载开源软件
简体中文翻译状态 translation status for zh
  • R/O
  • HTTP
  • SSH
  • HTTPS
Fork

MiMicSDK: 提交

MiMicSDK


Commit MetaInfo

修订版6bb705eb6d7e46e22bf90ad4770ac30c0b3418c8 (tree)
时间2014-07-28 01:16:29
作者nyatla <nyatla@4719...>
Commiternyatla

Log Message

githubへmbedJSのJavascriptAPIを移動

git-svn-id: http://svn.osdn.jp/svnroot/mimic/trunk@388 47198e57-cb75-475f-84c4-a814cd6f29e0

更改概述

  • delete: misc/mbedJS/mbddJS.API/make_mbedJS.bat
  • delete: misc/mbedJS/mbddJS.API/mbedJS.jsdoc.xml
  • delete: misc/mbedJS/mbddJS.API/mbedJS/MiMicCore.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.AnalogIn.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.AnalogOut.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.BusIn.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.BusInOut.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.BusOut.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.DigitalIn.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.DigitalOut.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.I2C.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.I2CSlave.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.Mcu.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.Memory.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.PortIn.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.PortOut.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.PwmOut.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.SPI.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.SPISlave.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.Serial.js
  • delete: misc/mbedJS/mbddJS.API/mbedJS/mbed.types.js
  • add: misc/mbedJS/mbddJS.API/readme.txt (diff)
  • delete: misc/mbedJS/mbddJS.API/test.AnalogIn.html
  • delete: misc/mbedJS/mbddJS.API/test.AnalogOut.html
  • delete: misc/mbedJS/mbddJS.API/test.BusIn.html
  • delete: misc/mbedJS/mbddJS.API/test.BusInOut.html
  • delete: misc/mbedJS/mbddJS.API/test.BusOut.html
  • delete: misc/mbedJS/mbddJS.API/test.DigitalIn.html
  • delete: misc/mbedJS/mbddJS.API/test.DigitalOut.html
  • delete: misc/mbedJS/mbddJS.API/test.I2C.html
  • delete: misc/mbedJS/mbddJS.API/test.I2CSlave.html
  • delete: misc/mbedJS/mbddJS.API/test.MCU.html
  • delete: misc/mbedJS/mbddJS.API/test.Memory.html
  • delete: misc/mbedJS/mbddJS.API/test.PortIn.html
  • delete: misc/mbedJS/mbddJS.API/test.PortOut.html
  • delete: misc/mbedJS/mbddJS.API/test.PwmOut.html
  • delete: misc/mbedJS/mbddJS.API/test.SPI.html
  • delete: misc/mbedJS/mbddJS.API/test.SPISlave.html
  • delete: misc/mbedJS/mbddJS.API/test.Serial.html

差异

--- a/misc/mbedJS/mbddJS.API/make_mbedJS.bat
+++ /dev/null
@@ -1,33 +0,0 @@
1-REM make a mbedJS.js
2-set DIR_MBED=mbedJS
3-set PATH_YUI=D:\application.files\yuicompressor-2.4.6\build\yuicompressor-2.4.8.jar
4-copy /b ^
5- "%DIR_MBED%\MiMicCore.js" ^
6-+"%DIR_MBED%\mbed.types.js" ^
7-+"%DIR_MBED%\mbed.AnalogIn.js" ^
8-+"%DIR_MBED%\mbed.AnalogOut.js" ^
9-+"%DIR_MBED%\mbed.BusIn.js" ^
10-+"%DIR_MBED%\mbed.BusInOut.js" ^
11-+"%DIR_MBED%\mbed.BusOut.js" ^
12-+"%DIR_MBED%\mbed.DigitalIn.js" ^
13-+"%DIR_MBED%\mbed.DigitalOut.js" ^
14-+"%DIR_MBED%\mbed.Mcu.js" ^
15-+"%DIR_MBED%\mbed.PortIn.js" ^
16-+"%DIR_MBED%\mbed.PortOut.js" ^
17-+"%DIR_MBED%\mbed.PwmOut.js" ^
18-+"%DIR_MBED%\mbed.SPI.js" ^
19-+"%DIR_MBED%\mbed.SPISlave.js" ^
20-+"%DIR_MBED%\mbed.Memory.js" ^
21-+"%DIR_MBED%\mbed.I2C.js" ^
22-+"%DIR_MBED%\mbed.I2CSlave.js" ^
23-+"%DIR_MBED%\mbed.Serial.js" ^
24-
25- "mbedJS.all.js"
26-
27-
28-REM make a x.All-mini.js
29-java -jar %PATH_YUI% -o mbedJS.all-min.js mbedJS.all.js
30-
31-
32-
33-
--- a/misc/mbedJS/mbddJS.API/mbedJS.jsdoc.xml
+++ /dev/null
@@ -1,35 +0,0 @@
1-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2-
3-
4-<project default="mimic">
5- <target name="mimic">
6-
7- <property name="JSDKANT" value="D:\application.files\jsdoc-toolkit-ant-task"/>
8- <property name="JSDK" value="D:\application.files\jsdoc_toolkit-2.4.0\jsdoc-toolkit"/>
9- <property name="SRC_ROOT" value="D:\project.sourceforge\MiMic\trunk\misc\mbedJS\mbddJS.API\mbedJS"/>
10- <property name="DEST_ROOT" value="D:\project.sourceforge\MiMic\document\mbedJS.javadoc"/>
11- <taskdef name="jsdoctoolkit" classname="uk.co.darrenhurley.ant.tasks.JsDocToolkit"
12- classpath="${JSDKANT}\jsdoc-toolkit-ant-task-1.1.2.jar;${JSDK}\java\classes\js.jar" />
13- <jsdoctoolkit jsdochome="${JSDK}\" outputdir="${DEST_ROOT}" template="mimic">
14- <source file="${SRC_ROOT}\mbed.AnalogIn.js" />
15- <source file="${SRC_ROOT}\mbed.AnalogOut.js" />
16- <source file="${SRC_ROOT}\mbed.BusIn.js" />
17- <source file="${SRC_ROOT}\mbed.BusInOut.js" />
18- <source file="${SRC_ROOT}\mbed.BusOut.js" />
19- <source file="${SRC_ROOT}\mbed.DigitalIn.js" />
20- <source file="${SRC_ROOT}\mbed.DigitalOut.js" />
21- <source file="${SRC_ROOT}\mbed.Mcu.js" />
22- <source file="${SRC_ROOT}\mbed.PortIn.js" />
23- <source file="${SRC_ROOT}\mbed.PortOut.js" />
24- <source file="${SRC_ROOT}\mbed.PwmOut.js" />
25- <source file="${SRC_ROOT}\mbed.SPI.js" />
26- <source file="${SRC_ROOT}\mbed.SPISlave.js" />
27- <source file="${SRC_ROOT}\mbed.types.js" />
28- <source file="${SRC_ROOT}\MiMicCore.js" />
29- <source file="${SRC_ROOT}\mbed.Memory.js" />
30- <source file="${SRC_ROOT}\mbed.Serial.js" />
31- <source file="${SRC_ROOT}\mbed.I2C.js" />
32- <source file="${SRC_ROOT}\mbed.I2CSlave.js" />
33- </jsdoctoolkit>
34- </target>
35-</project>
--- a/misc/mbedJS/mbddJS.API/mbedJS/MiMicCore.js
+++ /dev/null
@@ -1,691 +0,0 @@
1-/**
2- * @fileOverview 低レベルAPIを定義する。低レベルAPIは、MiMicRemoteMcuをインストールしたMCUとの通信クラスを提供する。
3- */
4-
5-/**
6- * MiMicネームスペース
7- * @namespace
8- */
9-var MiMicJS={};
10-(function(){
11- var NS=MiMicJS;
12- /**
13- * MiMicJsAPIのバージョン文字列。
14- * @name MiMicJS#VERSION
15- */
16- NS.VERSION="MiMicJsAPI/2.0.3";
17- /**
18- * 配列要素、又は値がすべてInt値でない場合に例外を起こします。
19- * @name MiMicJS.assertInt
20- * @function
21- * @param {[array]} v
22- * テストする配列
23- */
24- NS.assertInt=function assertInt(v){
25- if(!NS.isArray(v)){
26- if(!NS.isInt(v)){throw new NS.MiMicException();}
27- }
28- for(var i=0;i<v.length;i++){
29- if(NS.isInt(v[i])){
30- continue;
31- }
32- throw new NS.MiMicException('"'+v[i]+'" is not integer.');
33- }
34- }
35- /**
36- * 配列要素、、又は値がすべて数値でない場合に例外を起こします。
37- * @name MiMicJS.assertNumber
38- * @function
39- * @param {[array]} v
40- * テストする配列
41- */
42- NS.assertNumber=function assertNumber(v){
43- if(!NS.isArray(v)){
44- if(!NS.isNumber(v)){ throw new NS.MiMicException();}
45- }else{
46- for(var i=0;i<v.length;i++){
47- if(NS.isNumber(v[i])){
48- continue;
49- }
50- throw new NS.MiMicException('"'+v[i]+'" is not number.');
51- }
52- }
53- };
54- /**
55- * @private
56- */
57- NS.isUndefined=function(v,def){
58- if(arguments.length==1){return v === void 0;}
59- return (v === void 0)?def:v;
60- };
61- /**
62- * 数値であるかを確認します。
63- * @private
64- */
65- NS.isNumber=function isNumber(o)
66- {
67- return (typeof o=='number');
68- };
69- /**
70- * 整数であるかを確認します。
71- * @private
72- */
73- NS.isInt=function isInt(o)
74- {
75- return (typeof o=='number') && (o-Math.round(o)==0);
76- };
77-
78- /**
79- * オブジェクトがジェネレータクラスであるかを返します。
80- * @private
81- */
82- NS.isGenerator=function isGenerator(o)
83- {
84- if(!o){return false;}
85- return o.toString().indexOf('Generator')!=-1;
86- };
87- /**
88- * オブジェクトが関数であるかを返します。
89- * @private
90- */
91- NS.isFunction=function isFunction(o){
92- return (typeof o == 'function');
93- }
94- /**
95- * @private
96- * 現在の時刻を返します。
97- */
98- NS.getNow=function getNow(){
99- return (new Date()).getTime();
100- };
101- /**
102- * @private
103- * aが配列であるかを返します。
104- */
105- NS.isArray=function isArray(a){
106- return a instanceof Array;
107- };
108- /**
109- * @private
110- * aが配列であるかを返します。
111- */
112- NS.isHashArray=function isHashArray(a){
113- return (!(a instanceof Array)) && (typeof a == "object");
114- };
115- /**
116- * 連想配列をシャローコピーして複製します。
117- * @private
118- */
119- NS.cloneAssoc=function cloneAssoc(a)
120- {
121- var r={};
122- for(var i in a){
123- r[i]=a[i];
124- }
125- return r;
126- };
127- /**
128- * @private
129- * 桁数を指定して、int値を16進数に変換します。
130- * @param {int} i_val
131- * 変換する値
132- * @param {int} i_digit
133- * 桁数
134- * @return {string}
135- * 文字列形式の値
136- */
137- NS.hexout=function hexout(i_val,i_digit)
138- {
139- var dt=["","0","00","000","0000","00000","000000","0000000"];
140- var s=(i_val>>>0).toString(16).toLowerCase();
141- if(s.length>i_digit){
142- //マイナスだともれなくエラー
143- throw new NS.MiMicException(EE.NG);
144- }
145- var l=i_digit-s.length;
146- return dt[l]+s;
147- };
148- /**
149- * @private
150- * 連想配列を文字列にして返します。
151- */
152- NS.assocToStr=function assocToStr(a)
153- {
154- var s="";
155- for(k in a){s+=k+":"+a[k]+",";}
156- return s;
157- };
158- /**
159- * @private
160- * 32bit値のエンディアンを交換します。
161- * @param v
162- * 交換する値
163- * @return
164- * 交換後の値
165- */
166- NS.bswap32=function bswap32(v)
167- {
168- return ((v<<24)&0xff000000)|((v<<8)&0xff0000)|((v>>8)&0xff00)|((v>>24)&0xff);
169- };
170- /**
171- * @private
172- * バイナリ文字列をバイト値として配列に変換します。
173- * @param v
174- * 数値配列
175- */
176- NS.bstr2byteArray=function bstr2byteArray(v)
177- {
178- var r=new Array();
179- if(v.length%2!=0){
180- throw new NS.MiMicException();
181- }
182- for(var i=0;i<v.length;i+=2){
183- r.push(parseInt(v.substr(i,2),16));
184- }
185- return r;
186- };
187- /**
188- * @private
189- * バイナリ文字列を32bitUInt数値配列に変換します。
190- * Uint値はLittleEndianとして解釈します。
191- * @param {int[]} v
192- * 数値配列
193- */
194- NS.bstr2uintArray=function bstr2uintArray(v)
195- {
196- var r=new Array();
197- if(v.length%8!=0){
198- throw new NS.MiMicException();
199- }
200- for(var i=0;i<v.length;i+=8){
201- r.push(NS.bswap32(parseInt(v.substr(i,8),16)));
202- }
203- return r;
204- };
205- /**
206- * ByteArrayをBinarayStringに変換します。
207- * @name MiMicJS.byteArray2bstr
208- * @function
209- * @param v
210- * @return {String}
211- */
212- NS.byteArray2bstr=function byteArray2bstr(v)
213- {
214- var s=NS.isArray(v)?v:[v];
215- var r="";
216- for(var i=0;i<s.length;i++){
217- r+=NS.hexout(s[i],2,16);
218- }
219- return r;
220- };
221- /**
222- * UInt32ArrayをBinarayStringに変換します。
223- * 出力はLittleEndianの配列です。
224- * @name MiMicJS.uintArray2bstr
225- * @function
226- * @param v
227- * UInt32の配列
228- * @return {String}
229- */
230- NS.uintArray2bstr=function uintArray2bstr(v)
231- {
232- var s=NS.isArray(v)?v:[v];
233- var r="";
234- for(var i=0;i<s.length;i++){
235- r+=NS.hexout(NS.bswap32(s[i]),8,16);
236- }
237- return r;
238- };
239-
240- /**
241- * 連想配列の内容をルートオブジェクト直下に展開します。
242- * この関数は名前空間を汚染します。十分に注意して使用してください。
243- * @name MiMicJS.using
244- * @function
245- * @param {HashMap} v
246- * 展開する連想配列
247- * @example
248- * MiMicJS.using(mbedJS);
249- * MiMicJS.using(mbedJS.PinName);
250- */
251- NS.using=function using(v)
252- {
253- for (var key in v) {
254- window[key]=v[key];
255- }
256- }
257- /**
258- * MiMicSDK向けの内部関数です。
259- * 末尾引数が関数の場合にはその関数を、異なる場合はi_cbを返却します。
260- * @private
261- * @param i_arg
262- * 引数配列を指定します。
263- * @param i_default_cb
264- * 引数配列に関数がなかった場合に返す値を指定します。
265- */
266- NS._getCb=function _getCb(i_arg,i_default_cb)
267- {
268- if(i_arg.length==0){
269- return i_default_cb;
270- }
271- return NS.isFunction(i_arg[i_arg.length-1])?i_arg[i_arg.length-1]:i_default_cb;
272- }
273- /**
274- * MiMicSDK向けの関数です。
275- * 末尾の拡張変数を取り除いたarguments引数の数を返します。
276- * @private
277- */
278- NS._getBaseArgsLen=function _getBaseArgsLen(i_arg)
279- {
280- if(i_arg.length==0 || (!NS.isFunction(i_arg[i_arg.length-1]))){
281- return i_arg.length;
282- }
283- return i_arg.length==1?0:i_arg.length-1;
284- }
285-
286- /**
287- * MiMicSDK向けの関数です。
288- * インスタンスがyieldコール可能かをチェックし、可能ならコール関数を記録します。
289- * 関数は、インスタンスの_gen,_lcをチェックして、yieldが不可能な場合に例外を発生します。
290- * _assertYield.call(this)でコールして下さい。
291- * @private
292- */
293- NS._assertYield=function _assertYield()
294- {
295- if(this._gen && this._lc){
296- throw new NS.MiMicException(NS.Error.NG_YIELD_NOT_COMPLETED);
297- }
298- }
299- /**
300- * MiMicSDK向けの関数です。コンストラクタでイベントハンドラをセットアップする定型処理です。
301- * i_handlerにセットされたオブジェクトに従って_gen,_eventメンバをセットします。
302- * _initHandler.call(this,i_handler)でコールして下さい。
303- * @private
304- */
305- NS._initHandler=function _initHandler(i_handler)
306- {
307- if(NS.isGenerator(i_handler)){
308- this._gen=i_handler;
309- }else if(NS.isFunction(i_handler)){
310- return i_handler;
311- }else if(i_handler){
312- this._event=i_handler;
313- return i_handler.onNew;
314- }
315- return null;
316- }
317-
318-
319-}());
320-
321-(function(){
322- var NS=MiMicJS;
323-
324- /**
325- * MiMicExceptionが使用するエラーコードと、その判定関数を定義する。
326- * エラーコードは、以下の形式の配列オブジェクトで表現する。
327- * <pre>
328- * [code:int,message:string]
329- * </pre>
330- *
331- * codeは31ビットのエラーコードである。ビットフィールドの意味は以下の通りである。
332- * <table>
333- * <tr><th>bit</th><th>name</th><th>discription</th></tr>
334- * <tr><td>30</td><td>ErrorBit</td><td>Error:1,OK:0</td></tr>
335- * <tr><td>29-24</td><td>Reserved</td><td>-</td></tr>
336- * <tr><td>23-16</td><td>ModuleID</td><td>0x00:unknown<br/>0x39:MiMic<br/>0xF0-0xFF: user define<br/>Other:Reserved<br/></td></tr>
337- * <tr><td>15-8</td><td>ClassID</td><td>0x00:unknown</td></tr>
338- * <tr><td>7-0</td><td>ErrorID</td><td></td></tr>
339- * </table>
340- * @namespace
341- * @name MiMicJS.Error
342- * @example
343- * throw new MiMicException(MiMicError.NG);
344- */
345- NS.Error=
346- {
347- /** 成功を示します。
348- * @constant
349- * @name MiMicJS.Error.OK
350- */
351- OK:[0x00000000,"OK"],
352- /** 詳細情報の無いエラーです。
353- * @constant
354- * @name MiMicJS.Error.NG
355- */
356- NG:[0x40000000,"NG"],
357- /** Generatorを用いたコードで、前回のyieldが終了していないことを示します。
358- * @constant
359- * @name MiMicJS.Error.NG_YIELD_NOT_COMPLETED
360- */
361- NG_YIELD_NOT_COMPLETED:[0x40001001,"The previous function has not been completed."],
362- /** 関数の呼び出し順序が正しくないことを示します。
363- * @constant
364- * @name MiMicJS.Error.NG_ILLEGAL_CALL
365- */
366- NG_ILLEGAL_CALL:[0x40001002,"Illegal procedure call."],
367- /** 引数型の不一致を検出したことを示します。
368- * @constant
369- * @name MiMicJS.Error.NG_INVALID_ARG
370- */
371- NG_INVALID_ARG:[0x40001003,"Invalid arguments."],
372- /**
373- * エラーコードがOKか調べる。
374- * @function
375- * @name MiMicJS.Error.isOK
376- * @param {Object as [MiMicErrorCode]} v
377- * 評価するオブジェクト
378- * @return {Boolean}
379- * エラーコードでなければ、trueを返す。
380- * @example
381- * MiMicError.isOK(MiMicError.OK);//true
382- */
383- isOK:function(v){
384- return (0x40000000 & v)==0x00000000;
385- }
386- };
387-
388-}());
389-
390-(function(){
391- var NS=MiMicJS;
392- /**
393- * 引数が1個のパターン。
394- * @name MiMicJS.MiMicException:2
395- * @function
396- * @param {object} e
397- * eのクラスにより、動作が異なる。
398- * <ul>
399- * <li>{string} - MiMicException(Error.NG,e)と等価である。</li>
400- * <li>{object as [MiMicErrorCode]} - エラーコードを指定して例外を生成する。エラーコードについては、MiMicJs.Errorを参照</li>
401- * <li>{object} - MiMicException(MiMicError.NG,e.toString())と等価である。objectを文字列化して例外を生成する。</li>
402- * <li>{MiMicException} - codeとmessageを継承して例外を生成する。コールスタックを生成するときは、このパターンを使うこと。</li>
403- * </ul>
404- * @example
405- * throw new MiMicException(MiMicError.NG);
406- * throw new MiMicException("Error");
407- * try{
408- * throw new MiMicException("Error");
409- * }catch(e){
410- * throw new MiMicException(e);
411- * }
412- */
413- /**
414- * MiMic javascript APIが生成する例外クラスのコンストラクタである。関数ごとにMiMicExceptionを使ったtry-catchを導入することにより、例外発生時にスタックトレースメッセージを得ることが出来る。
415- * スタックトレースは改行で連結された文字列である。messageプロパティに格納される。alert関数で表示することで、効率的なデバックが可能である。
416- * 引数の違いにより、数種類の呼び出し方がある。
417- * @constructor
418- * @name MiMicJS.MiMicException
419- * @param ...
420- * 詳細は、MiMicException:nを参照。
421- */
422- NS.MiMicException=function MiMicException(/*...*/)
423- {
424- var pfx;
425- if(typeof arguments.callee.caller=="function"){
426- if(arguments.callee.caller.name.toString().length>0){
427- pfx="function '"+arguments.callee.caller.name+'.';
428- }else{
429- var s=arguments.callee.caller.toString();
430- pfx="closure '"+s.substring(0,s.indexOf("{"))+"...'";
431- }
432- }else{
433- pfx="root document";
434- }
435- var sfx="";
436- switch(arguments.length){
437- case 0:
438- //とりあえずexceptiion
439- this.code=NS.Error.NG[0];
440- this.message=pfx+" code(0x"+this.code.toString(16)+")"+NS.Error.NG[1];
441- return;
442- case 1:
443- var v=arguments[0];
444- if(v instanceof NS.MiMicException){
445- //exception継承
446- this.code=v.code;
447- sfx=" \nfrom "+v.message;
448- }else if(typeof v=="object" && v.length==2){
449- //Errorコードテーブル
450- this.code=v[0];
451- sfx=v[1];
452- }else{
453- //文字列やオブジェクト
454- this.code=NS.Error.NG[0];
455- sfx=NS.Error.NG[1]+" "+(((typeof v)!='undefined')?v.toString():"v==undefined");
456- }
457- this.message=pfx+" code(0x"+this.code.toString(16)+")"+sfx;
458- return;
459- default:
460- break;
461- }
462- throw new NS.MiMicException("Invalid MiMicException argument.");
463- }
464-
465- NS.MiMicException.prototype=
466- {
467-
468- /**
469- * MiMicErrorCode形式のエラーコードを保持する。
470- * @field {object as MiMicErrorCode}
471- * @name MiMicJS.MiMicException#code
472- */
473- code:null,
474- /**
475- * エラーメッセージを保持する。この値は、改行区切りのコールスタックである。
476- * @field {string}
477- * @name MiMicJS.MiMicException#message
478- */
479- message:"",
480- /**
481- * messageフィールドをalertで表示する。
482- * @name MiMicJS.MiMicException#alert
483- * @function
484- * @example
485- * try{
486- * throw new MiMicException();
487- * }catch(e){
488- * e.alert();
489- * }
490- */
491- alert:function(){
492- alert(this.message);
493- },
494- /**
495- * toStringを上書きする。オブジェクトを文字列化する。
496- * 文字列は例外のコールスタックであり、デバックで役立つ。
497- * @function
498- * @name MiMicJS.MiMicException#toString
499- * @return {string}
500- * 現在のオブジェクトの状態（例外のコールスタック）
501- * @example
502- * try{
503- * throw new MiMicException();
504- * }catch(e){
505- * alert(e.toString());
506- * }
507- */
508- toString:function()
509- {
510- return "MiMicException:"+this.message;
511- }
512- }
513-}());
514-
515-(function(){
516- /**@private */
517- var NS=MiMicJS;
518- /**
519- * MiMicRPCのクライアントクラスです。
520- * 通信APIを提供します。
521- * @name MiMicJS.Rpc
522- * @constructor
523- * @param {HashMap} i_event
524- * 非同期イベントハンドラの連想配列です。登録できるメンバは以下の通りです。
525- * <ul>
526- * <li>onOpen:function() -
527- * open関数のコールバック関数です。
528- * <li>onClose:function() -
529- * close関数のコールバック関数です。
530- * <li>onError:function() -
531- * 何らかの異常で通信を継続できないエラーが発生し、コネクションを維持できない時に発生します。
532- * このイベントが発生するとコネクションは閉じられます。
533- * </ul>
534- */
535- NS.Rpc=function Rpc(i_event)
536- {
537- this._event=(i_event)?i_event:null;
538- }
539- NS.Rpc.prototype=
540- {
541- _event:null,
542- /**
543- * @private
544- * Websocketインスタンスです。
545- */
546- _ws:null,
547- /**
548- * @private
549- * [READ ONLY]
550- * RPCの平均RTT[ms]です。
551- * @name MiMicJs.Rpc#RTT
552- */
553- rtt:0,
554- /** メソッドIDカウンタ。sendJsonを実行する毎にインクリメントされます。*/
555- _method_id:0,
556- /**
557- * RPCコネクションを開きます。
558- * 関数が終了するとonOpenイベントをコールバックします。
559- * @name MiMicJS.Rpc#open
560- * @function
561- * @param i_url
562- * ws://から始まるWebsocketサービスURLを指定します。
563- */
564- open:function open(i_url)
565- {
566- var _t=this;
567- if(this._ws){
568- throw new MiMicException();
569- }
570-
571- var q=new Array();
572- var ev=this._event;
573- var ws=new WebSocket(i_url);
574- ws.onopen = function(){
575- if(ev.onOpen){ev.onOpen();}
576- }
577- ws.onclose = function(){
578- if(ev.onClose){ev.onClose();}
579- };
580- ws.error = function(){
581- _t.shutdown();
582- if(ev.onClose){ev.onError();}
583- };
584- var rx="";
585- var rxst=0;
586- var _t=this;
587- ws.onmessage = function (e)
588- {
589- //ストリームからJSONを抽出。"のエスケープには対応しない。
590- for(var i=0;i<e.data.length;i++){
591- var t=e.data[i];
592- switch(rxst){
593- case 2:
594- if(t!='"'){
595- rxst=1;
596- }
597- break;
598- case 0:
599- if(t!='{'){
600- continue;
601- }
602- rx='({';
603- rxst=1;
604- continue;
605- case 1:
606- switch(t){
607- case '"':
608- rxst=2;
609- break;
610- case '}':
611- rx+='})';
612- rxst=0;
613- {
614-// log(rx);//Debug
615- //JSONがたぶん確定
616- var j=eval(rx);
617- for(var i2=q.length-1;i2>=0;i2--){
618- if(q[i2][0]==j.id){
619- //id一致→コールバック
620- var qi=q[i2];
621- q.splice(i2, 1);
622- //コールバック必要？
623- if(qi[1]){qi[1](j);}
624- break;
625- }
626- }
627- }
628- continue;
629- }
630- }
631- rx+=t;
632- }
633- }
634- this._method_id=0;
635- this._q=q;
636- this._ws=ws;
637- },
638- /**
639- * 接続中のRPCコネクションを閉じます。
640- * 関数が終了するとonCloseイベントをコールバックします。
641- * @name MiMicJS.Rpc#close
642- * @function
643- */
644- close:function close()
645- {
646- if(this._ws && this._ws.readyState==1){
647- this._ws.close();
648- this._ws=null;
649- }
650- },
651- /**
652- * RPC回線を確実に閉じます。
653- * この関数を実行すると、すべてのコールバックイベントはキャンセルされます。
654- * @name MiMicJS.Rpc#shutdown
655- * @function
656- */
657- shutdown:function shutdown()
658- {
659- var _t=this;
660- if(_t._ws){
661- _t._ws.onopen=function(){_t._ws.close();};
662- _t._ws.onmessage=function(){_t._ws.close();};
663- _t._ws.onclose=function(){_t._ws=null;};
664- _t._ws.onerror=function(){_t._ws=null;};
665- }
666- },
667- /**
668- * 非同期でJSON RPCメソッドを送信します。
669- * @name MiMicJS.Rpc#sendMethod
670- * @function
671- * @param {string} i_method
672- * RPCメソッドの名前です。
673- * @param {string} i_params
674- * カンマ区切りのJSONスタイルの文字列です。この文字列は[....]に埋め込まれます。エスケープ文字列は使用できません。
675- * @param {function(json)}i_callback
676- * Resultを受け取るコールバック関数です。jsonにはResult JSONをパースしたオブジェクトが入ります。
677- * @return {int}
678- * メソッドIDを返します。
679- */
680- sendMethod:function callJsonRpc(i_method,i_params,i_callback)
681- {
682- var v="{\"jsonrpc\":\"2.0\",\"method\":\""+i_method+"\",\"params\":["+i_params+"],\"id\":"+this._method_id+"}";
683-// log(v);//Debug
684- this._ws.send(v);
685- this._q.push([this._method_id,i_callback]);//キューに記録
686- this._method_id=(this._method_id+1)&0x0fffffff;//IDインクリメント
687- return this._method_id;
688- }
689- }
690-
691-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.AnalogIn.js
+++ /dev/null
@@ -1,201 +0,0 @@
1-/**
2- * @fileOverview AnalogInクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * AnalogInクラスです。
10- * <a href="https://mbed.org/handbook/AnalogIn">mbed::AnalogIn</a>と同等の機能を持ちます。
11- * @constructor
12- * @name mbedJS.AnalogIn
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {PinName} i_params
16- * ピンIDを指定します。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function(v)} onRead -
26- * read関数のコールバック関数です。
27- * <ul>
28- * <li>{int} v - 現在のピンの値です。</li>
29- * </ul>
30- * </li>
31- * <li>{function(v)} onRead_u16 -
32- * read_u16関数のコールバック関数です。
33- * <ul>
34- * <li>{int} v - 現在のピンの値です。</li>
35- * </ul>
36- * </li>
37- * </ul>
38- * <p>
39- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
40- * </p>
41- * <p>
42- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
43- * </p>
44- * @return {mbedJS.AnalogIn}
45- * @example //Callback
46- * var mcu=new mbedJS.Mcu("192.168.128.39",
47- * {
48- * onNew:function(){
49- * var pin=new mbedJS.AnalogIn(mcu,mbedJS.PinName.A0,{
50- * onNew:function(){
51- * pin.read();
52- * },
53- * onRead:function(v)
54- * {
55- * pin.read_u16();
56- * },
57- * onRead_u16:function(v){
58- * mcu.close();
59- * }});
60- * },
61- * onClose:function(){},
62- * onError:function(){}
63- * });
64- * @example //Generator
65- * var g=function*(){
66- * try{
67- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
68- * yield mcu.waitForNew();
69- * var pin=new mbedJS.AnalogIn(mcu,mbedJS.PinName.A0,g);
70- * yield pin.waitForNew();
71- * var v=yield pin.read();
72- * v=yield pin.read_u16();
73- * yield mcu.close();
74- * }catch(e){
75- * mcu.shutdown();
76- * }}();
77- * g.next();
78- */
79-var CLASS=function AnalogIn(i_mcu,i_params,i_handler)
80-{
81- try{
82- var _t=this;
83- _t._mcu=i_mcu;
84- _t._lc=CLASS;
85- var cb=MI._initHandler.call(_t,i_handler);
86- MI.assertInt(i_params);
87- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params,
88- function(j)
89- {
90- _t._oid=j.result[0];
91- if(cb){cb();}
92- if(_t._gen){_t._gen.next(_t);}
93- _t._lc=null;
94- }
95- );
96- }catch(e){
97- throw new MI.MiMicException(e);
98- }
99-}
100-CLASS.prototype=
101-{
102- /** @private */
103- RPC_NS:"mbedJS:AnalogIn",
104- /** @private 最後にコールしたAPIです。*/
105- _lc:null,
106- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
107- _gen:null,
108- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
109- _event:{},
110- /** @private リモートインスタンスのオブジェクトIDです。*/
111- _oid:null,
112- /**
113- * Generatorモードのときに使用する関数です。
114- * Generatorモードの時は、yieldと併用してnew AnalogIn()の完了を待ちます。
115- * @name mbedJS.AnalogIn#waitForNew
116- * @function
117- */
118- waitForNew:function AnalogIn_waitForNew()
119- {
120- try{
121- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
122- this._lc=CLASS.waitForNew;
123- }catch(e){
124- throw new MI.MiMicException(e);
125- }
126- },
127- /**
128- * ピンから値を読み込みます。
129- * 関数の完了時にonReadイベントが発生します。
130- * Generatorモードの時は、yieldと併用して完了を待機できます。
131- * @name mbedJS.AnalogIn#read
132- * @function
133- * @return　{int}
134- * Callbackモードの時はRPCメソッドのインデクスを返します。
135- * @return　{float}
136- * Generatorモードの時はピンの値を返します。
137- */
138- read:function AnalogIn_read()
139- {
140- try{
141- var _t=this;
142- var cb=MI._getCb(arguments,_t._event.onRead);
143- MI._assertYield.call(_t);
144- _t._lc=CLASS.read;
145- return _t._mcu.rpc(_t.RPC_NS+":read_fx",_t._oid,
146- function (j)
147- {
148- var v=j.result[0]/10000;
149- if(cb){cb(v);}
150- if(_t._gen){_t._gen.next(v);}
151- _t._lc=null;
152- }
153- );
154- }catch(e){
155- throw new MI.MiMicException(e);
156- }
157- },
158- /**
159- * ピンから値を読み込みます。
160- * 関数の完了時にonRead_u16イベントが発生します。
161- * Generatorモードの時は、yieldと併用して完了を待機できます。
162- * @name mbedJS.AnalogIn#read_u16
163- * @function
164- * @return　{int}
165- * Callbackモードの時はRPCメソッドのインデクスを返します。
166- * @return　{int}
167- * Generatorモードの時はピンの値を返します。
168- */
169- read_u16:function AnalogIn_read_u16()
170- {
171- try{
172- var _t=this;
173- var cb=MI._getCb(arguments,_t._event.onRead_u16);
174- MI._assertYield.call(_t);
175- _t._lc=CLASS.read_u16;
176- return _t._mcu.rpc(_t.RPC_NS+":read_u16",_t._oid,
177- function (j)
178- {
179- var v=j.result[0];
180- if(cb){cb(v);}
181- if(_t._gen){_t._gen.next(v);}
182- _t._lc=null;
183- }
184- );
185- }catch(e){
186- throw new MI.MiMicException(e);
187- }
188- },
189- /**
190- * MCUに生成されているオブジェクトを破棄します。
191- * @name mbedJS.AnalogIn#dispose
192- * @function
193- */
194- dispose:function AnalogIn_dispose()
195- {
196- return this._mcu._dispose.apply(this,arguments);
197- }
198-
199-}
200-NS.AnalogIn=CLASS;
201-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.AnalogOut.js
+++ /dev/null
@@ -1,240 +0,0 @@
1-/**
2- * @fileOverview AnalogOutクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * AnalogOutクラスです。
10- * <a href="https://mbed.org/handbook/AnalogOut">mbed::AnalogOut</a>と同等の機能を持ちます。
11- * @name mbedJS.AnalogOut
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {PinName} i_params
16- * ピンIDを指定します。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function()} onWrite -
26- * write関数のコールバック関数です。
27- * </li>
28- * <li>{function()} onWrite_u16 -
29- * write関数のコールバック関数です。
30- * </li>
31- * <li>{function(v)} onRead -
32- * read関数のコールバック関数です。
33- * <ul>
34- * <li>{int} v - 現在のピンの値です。</li>
35- * </ul>
36- * </li>
37- * </ul>
38- * <p>
39- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
40- * </p>
41- * <p>
42- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
43- * </p>
44- * @return {mbedJS.AnalogOut}
45- * @example //Callback
46- * var mcu=new mbedJS.Mcu("192.168.128.39",
47- * {
48- * onNew:function(){
49- * var pin=new mbedJS.AnalogOut(mcu,mbedJS.PinName.p18,{
50- * onNew:function(){
51- * pin.write(0.5);
52- * },
53- * onWrite:function()
54- * {
55- * pin.read();
56- * },
57- * onRead:function(v)
58- * {
59- * pin.write_u16(0);
60- * },
61- * onWrite_u16:function()
62- * {
63- * mcu.close();
64- * }
65- * });
66- * },
67- * onClose:function(){
68- * },
69- * onError:function(){
70- * }
71- * });
72- * @example //Generator
73- * var g=function*(){
74- * try{
75- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
76- * yield mcu.waitForNew();
77- * var pin=new mbedJS.AnalogOut(mcu,mbedJS.PinName.p18,g);
78- * yield pin.waitForNew();
79- * v=yield pin.write(0.3);
80- * var v=yield pin.read();
81- * v=yield pin.write_u16(1000);
82- * var v=yield pin.read();
83- * yield mcu.close();
84- * }catch(e){
85- * mcu.shutdown();
86- * }}();
87- * g.next();
88- */
89-var CLASS=function AnalogOut(i_mcu,i_params,i_handler)
90-{
91- try{
92- var _t=this;
93- _t._mcu=i_mcu;
94- _t._lc=CLASS;
95- var cb=MI._initHandler.call(_t,i_handler);
96- MI.assertInt(i_params);
97- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params,
98- function(j)
99- {
100- _t._oid=j.result[0];
101- if(cb){cb();}
102- if(_t._gen){_t._gen.next(_t);}
103- _t._lc=null;
104- }
105- );
106- }catch(e){
107- throw new MI.MiMicException(e);
108- }
109-}
110-CLASS.prototype=
111-{
112- /** @private */
113- RPC_NS:"mbedJS:AnalogOut",
114- /** @private 最後にコールしたAPIです。*/
115- _lc:null,
116- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
117- _gen:null,
118- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
119- _event:{},
120- /** @private リモートインスタンスのオブジェクトIDです。*/
121- _oid:null,
122- /**
123- * Generatorモードのときに使用する関数です。
124- * Generatorモードの時は、yieldと併用してnew AnalogOut()の完了を待ちます。
125- * @name mbedJS.AnalogOut#waitForNew
126- * @function
127- */
128- waitForNew:function AnalogOut_waitForNew()
129- {
130- try{
131- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
132- this._lc=CLASS.waitForNew;
133- }catch(e){
134- throw new MI.MiMicException(e);
135- }
136- },
137- /**
138- * ピンに値を出力します。
139- * 関数の完了時にonWriteイベントが発生します。
140- * Generatorモードの時は、yieldと併用して完了を待機できます。
141- * @name mbedJS.AnalogOut#write
142- * @function
143- * @param {float} i_value
144- * [0,1]の範囲で値を指定します。
145- * @return {int}
146- * Callbackモードの時はRPCメソッドのインデクスを返します。
147- */
148- write:function AnalogOut_write(i_value)
149- {
150- try{
151- var _t=this;
152- var cb=MI._getCb(arguments,_t._event.onWrite);
153- MI._assertYield.call(_t);
154- _t._lc=CLASS.write;
155- MI.assertNumber(i_value);
156- return _t._mcu.rpc(_t.RPC_NS+":write_fx",_t._oid+","+Math.round(i_value*10000),
157- function(j){
158- if(cb){cb();}
159- if(_t._gen){_t._gen.next();}
160- _t._lc=null;
161- }
162- );
163- }catch(e){
164- throw new MI.MiMicException(e);
165- }
166- },
167- /**
168- * ピンに値を出力します。
169- * 関数の完了時にonWrite_u16イベントが発生します。
170- * Generatorモードの時は、yieldと併用して完了を待機できます。
171- * @name mbedJS.AnalogOut#write_u16
172- * @function
173- * @param {int} i_value
174- * [0,0xffff]の範囲の整数を指定します。
175- * @return {int}
176- * Callbackモードの時はRPCメソッドのインデクスを返します。
177- */
178- write_u16:function AnalogOut_write_u16(i_value)
179- {
180- try{
181- var _t=this;
182- var cb=MI._getCb(arguments,_t._event.onWrite_u16);
183- MI._assertYield.call(_t);
184- _t._lc=CLASS.write;
185- MI.assertInt(i_value);
186- return _t._mcu.rpc(_t.RPC_NS+":write_u16",_t._oid+","+i_value,
187- function(j){
188- if(cb){cb();}
189- if(_t._gen){_t._gen.next();}
190- _t._lc=null;
191- }
192- );
193- }catch(e){
194- throw new MI.MiMicException(e);
195- }
196- },
197- /**
198- * ピンから値を読み込みます。
199- * 関数の完了時にonReadイベントが発生します。
200- * Generatorモードの時は、yieldと併用して完了を待機できます。
201- * @name mbedJS.AnalogOut#read
202- * @function
203- * @return　{int}
204- * Callbackモードの時はRPCメソッドのインデクスを返します。
205- * @return　{float}
206- * Generatorモードの時はピンの値を返します。
207- */
208- read:function AnalogOut_read()
209- {
210- try{
211- var _t=this;
212- var cb=MI._getCb(arguments,_t._event.onRead);
213- MI._assertYield.call(_t);
214- _t._lc=CLASS.read;
215- return _t._mcu.rpc(_t.RPC_NS+":read_fx",_t._oid,
216- function (j)
217- {
218- var v=j.result[0]/10000;
219- if(cb){cb(v);}
220- if(_t._gen){_t._gen.next(v);}
221- _t._lc=null;
222- }
223- );
224- }catch(e){
225- throw new MI.MiMicException(e);
226- }
227- },
228- /**
229- * MCUに生成されているオブジェクトを破棄します。
230- * @name mbedJS.AnalogOut#dispose
231- * @function
232- */
233- dispose:function AnalogOut_dispose()
234- {
235- return this._mcu._dispose.apply(this,arguments);
236- }
237-
238-}
239-NS.AnalogOut=CLASS;
240-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.BusIn.js
+++ /dev/null
@@ -1,214 +0,0 @@
1-/**
2- * @fileOverview BusInクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * BusInクラスです。
10- * <a href="https://mbed.org/handbook/BusIn">mbed::BusIn</a>と同等の機能を持ちます。
11- * @name mbedJS.BusIn
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName...]} i_params
16- * ピンIDの配列を指定します。要素数の最大値は16です。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function(v)} onRead -
26- * read関数のコールバック関数です。
27- * <ul>
28- * <li>{int} v - 現在のピンの値です。</li>
29- * </ul>
30- * </li>
31- * <li>{function()} onMode -
32- * mode関数のコールバック関数です。
33- * </li>
34- * </ul>
35- * <p>
36- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
37- * </p>
38- * <p>
39- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
40- * </p>
41- * @return {mbedJS.BusIn}
42- * @example //Callback
43- * var mcu=new mbedJS.Mcu("192.168.128.39",
44- * {
45- * onNew:function(){
46- * var pin=new mbedJS.BusIn(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],{
47- * onNew:function(){
48- * pin.read();
49- * },
50- * onRead:function(v)
51- * {
52- * pin.mode(mbedJS.PinMode.PullDown);
53- * },
54- * onMode:function(v){
55- * mcu.close();
56- * }});
57- * },
58- * onClose:function(){
59- * },
60- * onError:function(){
61- * }
62- * });
63- * @example //Generator
64- * var g=function*(){
65- * try{
66- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
67- * yield mcu.waitForNew();
68- * var bus=new mbedJS.BusIn(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],g);
69- * yield bus.waitForNew();
70- * var v=yield bus.read();
71- * v=yield bus.mode(mbedJS.PinMode.PullUp);
72- * yield mcu.close();
73- * }catch(e){
74- * mcu.shutdown();
75- * }}();
76- * g.next();
77- */
78-var CLASS=function BusIn(i_mcu,i_params,i_handler)
79-{
80- try{
81- var _t=this;
82- _t._mcu=i_mcu;
83- _t._lc=CLASS;
84- var cb=MI._initHandler.call(_t,i_handler);
85- //Pin配列の正規化
86- var ap=i_params;
87- if(ap.length<1 ||ap.length>16){
88- throw new MI.MiMicException(MI.NG_INVALID_ARG);
89- }
90- //数値のみの配列かな？
91- MI.assertInt(ap);
92- var pins=ap[0];
93- var i=1;
94- for(;i<i_params.length;i++){
95- pins+=","+ap[i];
96- }
97- for(;i<16;i++){
98- pins+=","+NS.PinName.NC;
99- }
100- _t._mcu.rpc(_t.RPC_NS+":_new1",pins,
101- function(j)
102- {
103- _t._oid=j.result[0];
104- if(cb){cb();}
105- if(_t._gen){_t._gen.next(_t);}
106- _t._lc=null;
107- }
108- );
109- }catch(e){
110- throw new MI.MiMicException(e);
111- }
112-}
113-CLASS.prototype=
114-{
115- /** @private */
116- RPC_NS:"mbedJS:BusIn",
117- /** @private 最後にコールしたAPIです。*/
118- _lc:null,
119- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
120- _gen:null,
121- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
122- _event:{},
123- /** @private リモートインスタンスのオブジェクトIDです。*/
124- _oid:null,
125- /**
126- * Generatorモードのときに使用する関数です。
127- * Generatorモードの時は、yieldと併用してnew BusIn()の完了を待ちます。
128- * @name mbedJS.BusIn#waitForNew
129- * @function
130- */
131- waitForNew:function BusIn_waitForNew()
132- {
133- try{
134- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
135- this._lc=CLASS.waitForNew;
136- }catch(e){
137- throw new MI.MiMicException(e);
138- }
139- },
140- /**
141- * ピンから値を読み込みます。
142- * 関数の完了時にonReadイベントが発生します。
143- * Generatorモードの時は、yieldと併用して完了を待機できます。
144- * @name mbedJS.BusIn#read
145- * @function
146- * @return　{int}
147- * Callbackモードの時はRPCメソッドのインデクスを返します。
148- * @return　{int}
149- * Generatorモードの時はピンの値を返します。
150- */
151- read:function BusIn_read()
152- {
153- try{
154- var _t=this;
155- var cb=MI._getCb(arguments,_t._event.onRead);
156- MI._assertYield.call(_t);
157- _t._lc=CLASS.read;
158- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
159- function (j)
160- {
161- var v=j.result[0];
162- if(cb){cb(v);}
163- if(_t._gen){_t._gen.next(v);}
164- _t._lc=null;
165- }
166- );
167- }catch(e){
168- throw new MI.MiMicException(e);
169- }
170- },
171- /**
172- * ピンモードを設定します。
173- * 関数の完了時にonModeイベントが発生します。
174- * Generatorモードの時は、yieldと併用して完了を待機できます。
175- * @name mbedJS.BusIn#mode
176- * @function
177- * @param {PinMode} i_value
178- * PinModeの値です。
179- * @return　{int}
180- * Callbackモードの時はRPCメソッドのインデクスを返します。
181- */
182- mode:function BusIn_mode(i_value)
183- {
184- try{
185- var _t=this;
186- var cb=MI._getCb(arguments,_t._event.onMode);
187- MI._assertYield.call(_t);
188- MI.assertInt(i_value);
189- return _t._mcu.rpc(_t.RPC_NS+":mode",_t._oid+","+i_value,
190- function (j)
191- {
192- var v=j.result[0];
193- if(cb){cb(v);}
194- if(_t._gen){_t._gen.next(v);}
195- _t._lc=null;
196- }
197- );
198- }catch(e){
199- throw new MI.MiMicException(e);
200- }
201- },
202- /**
203- * MCUに生成されているオブジェクトを破棄します。
204- * @name mbedJS.BusIn#dispose
205- * @function
206- */
207- dispose:function BusIn_dispose()
208- {
209- return this._mcu._dispose.apply(this,arguments);
210- }
211-
212-}
213-NS.BusIn=CLASS;
214-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.BusInOut.js
+++ /dev/null
@@ -1,325 +0,0 @@
1-/**
2- * @fileOverview BusInOutクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * BusInOutクラスです。
10- * <a href="https://mbed.org/handbook/BusInOut">mbed::BusInOut</a>と同等の機能を持ちます。
11- * @name mbedJS.BusInOut
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName...]} i_params
16- * ピンIDの配列を指定します。要素数の最大値は16です。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function(v)} onRead -
26- * read関数のコールバック関数です。
27- * <ul>
28- * <li>{int} v - 現在のピンの値です。</li>
29- * </ul>
30- * </li>
31- * <li>{function()} onWrite -
32- * write関数のコールバック関数です。
33- * </li>
34- * </ul>
35- * <li>{function()} onOutput -
36- * output関数のコールバック関数です。
37- * </li>
38- * <li>{function()} onInput -
39- * input関数のコールバック関数です。
40- * </li>
41- * <li>{function()} onMode -
42- * mode関数のコールバック関数です。
43- * </li>
44- *
45- * <p>
46- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
47- * </p>
48- * <p>
49- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
50- * </p>
51- * @return {mbedJS.BusIn}
52- * @example //Callback
53- * var mcu=new mbedJS.Mcu("192.168.128.39",
54- * {
55- * onNew:function(){
56- * var bus=new mbedJS.BusInOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],{
57- * onNew:function(){
58- * bus.mode(mbedJS.PinMode.PullDown);
59- * },
60- * onMode:function()
61- * {
62- * bus.output();
63- * },
64- * onOutput:function()
65- * {
66- * bus.write(1);
67- * },
68- * onWrite:function()
69- * {
70- * bus.input();
71- * },
72- * onInput:function(){
73- * bus.read();
74- * },
75- * onRead:function(v)
76- * {
77- * mcu.close();
78- * }});
79- * },
80- * onClose:function(){
81- * },
82- * onError:function(){
83- * }
84- * });
85- *
86- * @example //Generator
87- * var g=function*(){
88- * try{
89- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
90- * yield mcu.waitForNew();
91- * var bus=new mbedJS.BusInOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],g);
92- * yield bus.waitForNew();
93- * yield bus.mode(mbedJS.PinMode.PullDown);
94- * yield bus.output();
95- * yield bus.write(1);
96- * yield bus.input();
97- * var v=yield bus.read();
98- * yield mcu.close();
99- * }catch(e){
100- * mcu.shutdown();
101- * }
102- * }();
103- * g.next();
104- */
105-var CLASS=function BusInOut(i_mcu,i_params,i_handler)
106-{
107- try{
108- var _t=this;
109- _t._mcu=i_mcu;
110- _t._lc=CLASS;
111- var cb=MI._initHandler.call(_t,i_handler);
112- //Pin配列の正規化
113- var ap=i_params;
114- //数値のみの配列かな？
115- MI.assertInt(ap);
116- if(ap.length<1 ||ap.length>16){
117- throw new MI.MiMicException(MI.NG_INVALID_ARG);
118- }
119- var pins=ap[0];
120- var i=1;
121- for(;i<i_params.length;i++){
122- pins+=","+ap[i];
123- }
124- for(;i<16;i++){
125- pins+=","+NS.PinName.NC;
126- }
127- _t._mcu.rpc(_t.RPC_NS+":_new1",pins,
128- function(j)
129- {
130- _t._oid=j.result[0];
131- if(cb){cb();}
132- if(_t._gen){_t._gen.next(_t);}
133- _t._lc=null;
134- }
135- );
136- }catch(e){
137- throw new MI.MiMicException(e);
138- }
139-}
140-CLASS.prototype=
141-{
142- /** @private */
143- RPC_NS:"mbedJS:BusInOut",
144- /** @private 最後にコールしたAPIです。*/
145- _lc:null,
146- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
147- _gen:null,
148- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
149- _event:{},
150- /** @private リモートインスタンスのオブジェクトIDです。*/
151- _oid:null,
152- /**
153- * Generatorモードのときに使用する関数です。
154- * Generatorモードの時は、yieldと併用してnew BusInOut()の完了を待ちます。
155- * @name mbedJS.BusInOut#waitForNew
156- * @function
157- */
158- waitForNew:function BusInOut_waitForNew()
159- {
160- try{
161- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
162- this._lc=CLASS.waitForNew;
163- }catch(e){
164- throw new MI.MiMicException(e);
165- }
166- },
167- /**
168- * ピンに値を出力します。
169- * 関数の完了時にonWriteイベントが発生します。
170- * Generatorモードの時は、yieldと併用して完了を待機できます。
171- * @name mbedJS.BusInOut#write
172- * @function
173- * @param {int} i_value
174- * @return {int}
175- * Callbackモードの時はRPCメソッドのインデクスを返します。
176- */
177- write:function BusInOut_write(i_value)
178- {
179- try{
180- var _t=this;
181- var cb=MI._getCb(arguments,_t._event.onWrite);
182- MI._assertYield.call(_t);
183- _t._lc=CLASS.write;
184- MI.assertInt(i_value);
185- return _t._mcu.rpc(_t.RPC_NS+":write",_t._oid+","+i_value,
186- function(j){
187- if(cb){cb();}
188- if(_t._gen){_t._gen.next();}
189- _t._lc=null;
190- }
191- );
192- }catch(e){
193- throw new MI.MiMicException(e);
194- }
195- },
196- /**
197- * ピンから値を読み込みます。
198- * 関数の完了時にonReadイベントが発生します。
199- * Generatorモードの時は、yieldと併用して完了を待機できます。
200- * @name mbedJS.BusInOut#read
201- * @function
202- * @return　{int}
203- *　Callbackモードの時はRPCメソッドのインデクスを返します。
204- * @return　{int}
205- * Generatorモードの時はピンの値を返します。
206- */
207- read:function BusInOut_read()
208- {
209- try{
210- var _t=this;
211- var cb=MI._getCb(arguments,_t._event.onRead);
212- MI._assertYield.call(_t);
213- _t._lc=CLASS.read;
214- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
215- function (j)
216- {
217- var v=j.result[0];
218- if(cb){cb(v);}
219- if(_t._gen){_t._gen.next(v);}
220- _t._lc=null;
221- }
222- );
223- }catch(e){
224- throw new MI.MiMicException(e);
225- }
226- },
227- /**
228- * ピンモードを設定します。
229- * 関数の完了時にonModeイベントが発生します。
230- * Generatorモードの時は、yieldと併用して完了を待機できます。
231- * @name mbedJS.BusInOut#mode
232- * @function
233- * @param {PinMode} i_value
234- * PinModeの値です。
235- * @return　{int}
236- * Callbackモードの時はRPCメソッドのインデクスを返します。
237- */
238- mode:function BusInOut_mode(i_value)
239- {
240- try{
241- var _t=this;
242- var cb=MI._getCb(arguments,_t._event.onMode);
243- MI._assertYield.call(_t);
244- _t._lc=CLASS.mode;
245- MI.assertInt(i_value);
246- return _t._mcu.rpc(_t.RPC_NS+":mode",_t._oid+","+i_value,
247- function (j)
248- {
249- var v=j.result[0];
250- if(cb){cb(v);}
251- if(_t._gen){_t._gen.next(v);}
252- _t._lc=null;
253- }
254- );
255- }catch(e){
256- throw new MI.MiMicException(e);
257- }
258- },
259- /**
260- * ピンモードを設定します。
261- * 関数の完了時にonInputイベントが発生します。
262- * Generatorモードの時は、yieldと併用して完了を待機できます。
263- * @name mbedJS.BusInOut#input
264- * @function
265- * @return　{int}
266- * Callbackモードの時はRPCメソッドのインデクスを返します。
267- */
268- input:function BusInOut_input()
269- {
270- try{
271- var _t=this;
272- var cb=MI._getCb(arguments,_t._event.onInput);
273- MI._assertYield.call(_t);
274- _t._lc=CLASS.input;
275- return _t._mcu.rpc(_t.RPC_NS+":input",_t._oid,
276- function (j)
277- {
278- if(cb){cb();}
279- if(_t._gen){_t._gen.next();}
280- _t._lc=null;
281- });
282- }catch(e){
283- throw new MI.MiMicException(e);
284- }
285- },
286- /**
287- * ピンモードを設定します。
288- * 関数の完了時にonOutputイベントが発生します。
289- * Generatorモードの時は、yieldと併用して完了を待機できます。
290- * @name mbedJS.BusInOut#output
291- * @function
292- * @return　{int}
293- * Callbackモードの時はRPCメソッドのインデクスを返します。
294- */
295- output:function BusInOut_output()
296- {
297- try{
298- var _t=this;
299- var cb=MI._getCb(arguments,_t._event.onOutput);
300- MI._assertYield.call(_t);
301- _t._lc=CLASS.mode;
302- return _t._mcu.rpc(_t.RPC_NS+":output",_t._oid,
303- function (j)
304- {
305- if(cb){cb();}
306- if(_t._gen){_t._gen.next();}
307- _t._lc=null;
308- });
309- }catch(e){
310- throw new MI.MiMicException(e);
311- }
312- },
313- /**
314- * MCUに生成されているオブジェクトを破棄します。
315- * @name mbedJS.BusInOut#dispose
316- * @function
317- */
318- dispose:function BusInOut_dispose()
319- {
320- return this._mcu._dispose.apply(this,arguments);
321- }
322-
323-}
324-NS.BusInOut=CLASS;
325-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.BusOut.js
+++ /dev/null
@@ -1,215 +0,0 @@
1-/**
2- * @fileOverview BusOutクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * BusOutクラスです。
10- * <a href="https://mbed.org/handbook/BusOut">mbed::BusOut</a>と同等の機能を持ちます。
11- * @name mbedJS.BusOut
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName...]} i_params
16- * ピンIDの配列を指定します。要素数の最大値は16です。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function(v)} onRead -
26- * read関数のコールバック関数です。
27- * <ul>
28- * <li>{int} v - 現在のピンの値です。</li>
29- * </ul>
30- * </li>
31- * <li>{function()} onWrite -
32- * write関数のコールバック関数です。
33- * </li>
34- * </ul>
35- * <p>
36- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
37- * </p>
38- * <p>
39- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
40- * </p>
41- * @return {mbedJS.BusOut}
42- * @example //Callback
43- * var mcu=new mbedJS.Mcu("192.168.128.39",
44- * {
45- * onNew:function(){
46- * var bus=new mbedJS.BusOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],{
47- * onNew:function(){
48- * bus.write(2);
49- * },
50- * onWrite:function()
51- * {
52- * bus.read();
53- * },
54- * onRead:function(v){
55- * mcu.close();
56- * },
57- * });
58- * },
59- * onClose:function(){
60- * },
61- * onError:function(){
62- * }
63- * });
64- * @example //Generator
65- * var g=function*(){
66- * try{
67- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
68- * yield mcu.waitForNew();
69- * var bus=new mbedJS.BusOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],g);
70- * yield bus.waitForNew();
71- * yield bus.write(1);
72- * var v=yield bus.read();
73- * yield mcu.close();
74- * }catch(e){
75- * mcu.shutdown();
76- * }
77- * }();
78- * g.next();
79- */
80-var CLASS=function BusOut(i_mcu,i_params,i_handler)
81-{
82- try{
83- var _t=this;
84- _t._mcu=i_mcu;
85- _t._lc=CLASS;
86- var cb=MI._initHandler.call(_t,i_handler);
87- //Pin配列の正規化
88- var ap=i_params;
89- if(ap.length<1 ||ap.length>16){
90- throw new MI.MiMicException(MI.NG_INVALID_ARG);
91- }
92- //数値のみの配列かな？
93- MI.assertInt(ap);
94- var pins=ap[0];
95- var i=1;
96- for(;i<i_params.length;i++){
97- pins+=","+ap[i];
98- }
99- for(;i<16;i++){
100- pins+=","+NS.PinName.NC;
101- }
102- _t._mcu.rpc(_t.RPC_NS+":_new1",pins,
103- function(j)
104- {
105- _t._oid=j.result[0];
106- if(cb){cb();}
107- if(_t._gen){_t._gen.next(_t);}
108- _t._lc=null;
109- }
110- );
111- }catch(e){
112- throw new MI.MiMicException(e);
113- }
114-
115-}
116-CLASS.prototype=
117-{
118- /** @private */
119- RPC_NS:"mbedJS:BusOut",
120- /** @private 最後にコールしたAPIです。*/
121- _lc:null,
122- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
123- _gen:null,
124- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
125- _event:{},
126- /** @private リモートインスタンスのオブジェクトIDです。*/
127- _oid:null,
128- /**
129- * Generatorモードのときに使用する関数です。
130- * Generatorモードの時は、yieldと併用してnew BusOut()の完了を待ちます。
131- * @name mbedJS.BusOut#waitForNew
132- * @function
133- */
134- waitForNew:function BusOut_waitForNew()
135- {
136- try{
137- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
138- this._lc=CLASS.waitForNew;
139- }catch(e){
140- throw new MI.MiMicException(e);
141- }
142- },
143- /**
144- * ピンに値を出力します。
145- * 関数の完了時にonWriteイベントが発生します。
146- * Generatorモードの時は、yieldと併用して完了を待機できます。
147- * @name mbedJS.BusOut#write
148- * @function
149- * @param {int} i_value
150- * @return {int}
151- * Callbackモードの時はRPCメソッドのインデクスを返します。
152- */
153- write:function BusOut_write(i_value)
154- {
155- try{
156- var _t=this;
157- var cb=MI._getCb(arguments,_t._event.onWrite);
158- MI._assertYield.call(_t);
159- _t._lc=CLASS.write;
160- MI.assertInt(i_value);
161- return _t._mcu.rpc(_t.RPC_NS+":write",_t._oid+","+i_value,
162- function(j){
163- if(cb){cb();}
164- if(_t._gen){_t._gen.next();}
165- _t._lc=null;
166- }
167- );
168- }catch(e){
169- throw new MI.MiMicException(e);
170- }
171- },
172- /**
173- * ピンから値を読み込みます。
174- * 関数の完了時にonReadイベントが発生します。
175- * Generatorモードの時は、yieldと併用して完了を待機できます。
176- * @name mbedJS.BusOut#read
177- * @function
178- * @return　{int}
179- * Callbackモードの時はRPCメソッドのインデクスを返します。
180- * @return　{int}
181- * Generatorモードの時はピンの値を返します。
182- */
183- read:function BusOut_read()
184- {
185- try{
186- var _t=this;
187- var cb=MI._getCb(arguments,_t._event.onRead);
188- MI._assertYield.call(_t);
189- _t._lc=CLASS.read;
190- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
191- function (j)
192- {
193- var v=j.result[0];
194- if(cb){cb(v);}
195- if(_t._gen){_t._gen.next(v);}
196- _t._lc=null;
197- }
198- );
199- }catch(e){
200- throw new MI.MiMicException(e);
201- }
202- },
203- /**
204- * MCUに生成されているオブジェクトを破棄します。
205- * @name mbedJS.BusOut#dispose
206- * @function
207- */
208- dispose:function BusOut_dispose()
209- {
210- return this._mcu._dispose.apply(this,arguments);
211- }
212-
213-}
214-NS.BusOut=CLASS;
215-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.DigitalIn.js
+++ /dev/null
@@ -1,201 +0,0 @@
1-/**
2- * @fileOverview DigitalInクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * DigitalInクラスです。
10- * <a href="https://mbed.org/handbook/DigitalIn">mbed::DigitalIn</a>と同等の機能を持ちます。
11- * @name mbedJS.DigitalIn
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {PinName} i_params
16- * ピンIDを指定します。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function(v)} onRead -
26- * read関数のコールバック関数です。
27- * <ul>
28- * <li>{int} v - 現在のピンの値です。</li>
29- * </ul>
30- * </li>
31- * <li>{function()} onMode -
32- * mode関数のコールバック関数です。
33- * </li>
34- * </ul>
35- * <p>
36- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
37- * </p>
38- * <p>
39- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
40- * </p>
41- * @return {mbedJS.DigitalIn}
42- * @example //Callback
43- * var mcu=new mbedJS.Mcu("192.168.128.39",
44- * {
45- * onNew:function(){
46- * var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,{
47- * onNew:function(){
48- * pin.mode(mbedJS.PinMode.PullUp);
49- * },
50- * onMode:function()
51- * {
52- * pin.read();
53- * },
54- * onRead:function(v){
55- * mcu.close();
56- * }});
57- * },
58- * onClose:function(){
59- * },
60- * onError:function(){
61- * }
62- * });
63- * @example //Generator
64- * var g=function*(){
65- * try{
66- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
67- * yield mcu.waitForNew();
68- * var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,g);
69- * yield pin.waitForNew();
70- * var v=yield pin.read();
71- * yield pin.mode(mbedJS.PinMode.PullDown);
72- * yield mcu.close();
73- * }catch(e){
74- * mcu.shutdown();
75- * }}();
76- * g.next();
77- */
78-var CLASS=function DigitalIn(i_mcu,i_params,i_handler)
79-{
80- try{
81- var _t=this;
82- _t._mcu=i_mcu;
83- _t._lc=CLASS;
84- var cb=MI._initHandler.call(_t,i_handler);
85- MI.assertInt(i_params);
86- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params,
87- function(j)
88- {
89- _t._oid=j.result[0];
90- if(cb){cb();}
91- if(_t._gen){_t._gen.next(_t);}
92- _t._lc=null;
93- }
94- );
95-
96- }catch(e){
97- throw new MI.MiMicException(e);
98- }
99-}
100-CLASS.prototype=
101-{
102- /** @private */
103- RPC_NS:"mbedJS:DigitalIn",
104- /** @private 最後にコールしたAPIです。*/
105- _lc:null,
106- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
107- _gen:null,
108- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
109- _event:{},
110- /** @private リモートインスタンスのオブジェクトIDです。*/
111- _oid:null,
112- /**
113- * Generatorモードのときに使用する関数です。
114- * Generatorモードの時は、yieldと併用してnew DigitalIn()の完了を待ちます。
115- * @name mbedJS.DigitalIn#waitForNew
116- * @function
117- */
118- waitForNew:function DigitalIn_waitForNew()
119- {
120- try{
121- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
122- this._lc=CLASS.waitForNew;
123- }catch(e){
124- throw new MI.MiMicException(e);
125- }
126- },
127- /**
128- * ピンからアナログ値を読み込みます。
129- * 関数の完了時にonReadイベントが発生します。
130- * Generatorモードの時は、yieldと併用して完了を待機できます。
131- * @name mbedJS.DigitalIn#read
132- * @function
133- * @return　{int}
134- * Callbackモードの時はRPCメソッドのインデクスを返します。
135- * @return　{int}
136- * Generatorモードの時はピンの値を返します。
137- */
138- read:function DigitalIn_read()
139- {
140- try{
141- var _t=this;
142- var cb=MI._getCb(arguments,_t._event.onRead);
143- MI._assertYield.call(_t);
144- _t._lc=CLASS.read;
145- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
146- function (j)
147- {
148- var v=j.result[0];
149- if(cb){cb(v);}
150- if(_t._gen){_t._gen.next(v);}
151- _t._lc=null;
152- }
153- );
154- }catch(e){
155- throw new MI.MiMicException(e);
156- }
157- },
158- /**
159- * ピンモードを設定します。
160- * 関数の完了時にonModeイベントが発生します。
161- * Generatorモードの時は、yieldと併用して完了を待機できます。
162- * @name mbedJS.DigitalIn#mode
163- * @function
164- * @param {PinMode} i_value
165- * PinModeの値です。
166- * @return　{int}
167- * Callbackモードの時はRPCメソッドのインデクスを返します。
168- */
169- mode:function DigitalIn_mode(i_value)
170- {
171- try{
172- var _t=this;
173- var cb=MI._getCb(arguments,_t._event.onMode);
174- MI._assertYield.call(_t);
175- _t._lc=CLASS.mode;
176- MI.assertInt(i_value);
177- return _t._mcu.rpc(_t.RPC_NS+":mode",_t._oid+","+i_value,
178- function (j)
179- {
180- var v=j.result[0];
181- if(cb){cb(v);}
182- if(_t._gen){_t._gen.next(v);}
183- _t._lc=null;
184- }
185- );
186- }catch(e){
187- throw new MI.MiMicException(e);
188- }
189- },
190- /**
191- * MCUに生成されているオブジェクトを破棄します。
192- * @name mbedJS.DigitalIn#dispose
193- * @function
194- */
195- dispose:function DigitalIn_dispose()
196- {
197- return this._mcu._dispose.apply(this,arguments);
198- }
199-}
200-NS.DigitalIn=CLASS;
201-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.DigitalOut.js
+++ /dev/null
@@ -1,227 +0,0 @@
1-/**
2- * @fileOverview DigitalOutクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * DigitalOutクラスです。
10- * <a href="https://mbed.org/handbook/DigitalOut">mbed::DigitalOut</a>と同等の機能を持ちます。
11- * @name mbedJS.DigitalOut
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {PinName|HashMap|Array} i_params
16- * PinName又はコンストラクタの引数を格納した連想配列、配列です。
17- * 複数のパラメータを指定する場合は連想配列を使用してください。
18- * <p>PinNameの場合は制御するPinIDを指定します。</p>
19- * <p>
20- * HashMapの場合は以下のメンバを指定できます。
21- * <ul>
22- * <li>{PinName} pin -
23- * ピンIDを指定します。</li>
24- * <li>{int} value -
25- * ピンの初期値を指定します。</li>
26- * </ul>
27- * </p>
28- * <p>配列の場合は次の順番でパラメータを指定します。
29- * <pre>{pin,value}</pre>
30- * </p>
31- * @param {HashMap|Generator|function} i_handler
32- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
33- * <p>
34- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
35- *
36- * <ul>
37- * <li>{function()} onNew -
38- * インスタンスが使用可能になった時に呼び出されます。
39- * </li>
40- * <li>{function()} onWrite -
41- * write関数のコールバック関数です。
42- * </li>
43- * <li>{function(v)} onRead -
44- * read関数のコールバック関数です。
45- * <ul>
46- * <li>{int} v - 現在のピンの値です。</li>
47- * </ul>
48- * </li>
49- * </ul>
50- * <p>
51- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
52- * </p>
53- * <p>
54- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
55- * </p>
56- * @return {mbedJS.DigitalOut}
57- * @example //Callback
58- * var mcu=new mbedJS.Mcu("192.168.128.39",
59- * {
60- * onNew:function(){
61- * var pin=new mbedJS.DigitalOut(mcu,mbedJS.PinName.P0_22,{
62- * onNew:function(){
63- * pin.read();
64- * },
65- * onWrite:function(){
66- * mcu.close();
67- * },
68- * onRead:function(v){
69- * pin.write((v+1)%2);
70- * }});
71- * },
72- * onClose:function(){
73- * },
74- * onError:function(){
75- * }
76- * });
77- * @example //Generator
78- * var g=function*(){
79- * try{
80- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
81- * yield mcu.waitForNew();
82- * var pin=new mbedJS.DigitalOut(mcu,{pin:mbedJS.PinName.P0_22,value:0},g);
83- * yield pin.waitForNew();
84- * var v=yield pin.read();
85- * yield pin.write((v+1)%2);
86- * v=yield pin.read();
87- * yield pin.write((v+1)%2);
88- * yield mcu.close();
89- * }catch(e){
90- * mcu.shutdown();
91- * }
92- * }();
93- * g.next();
94- */
95-var CLASS=function DigitalOut(i_mcu,i_params,i_handler)
96-{
97- try{
98- var _t=this;
99- _t._mcu=i_mcu;
100- _t._lc=CLASS;
101- var cb=MI._initHandler.call(_t,i_handler);
102- function rcb(j)
103- {
104- _t._oid=j.result[0];
105- if(cb){cb();}
106- if(_t._gen){_t._gen.next(_t);}
107- _t._lc=null;
108- }
109- //パラメタ生成
110- var pr;
111- if(MI.isHashArray(i_params)){
112- pr=[i_params.pin,i_params.value];
113- }else if(MI.isArray(i_params)){
114- pr=[i_params[0],null];
115- }else{
116- pr=[i_params,null];
117- }
118- MI.assertInt(pr[0]);
119- if(pr[1]){
120- MI.assertInt(pr[1]);
121- _t._mcu.rpc(_t.RPC_NS+":_new2",pr[0]+","+pr[1],rcb);
122- }else{
123- _t._mcu.rpc(_t.RPC_NS+":_new1",pr[0],rcb);
124- }
125- }catch(e){
126- throw new MI.MiMicException(e);
127- }
128-}
129-CLASS.prototype=
130-{
131- /** @private */
132- RPC_NS:"mbedJS:DigitalOut",
133- /** @private 最後にコールしたAPIです。*/
134- _lc:null,
135- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
136- _gen:null,
137- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
138- _event:{},
139- /** @private リモートインスタンスのオブジェクトIDです。*/
140- _oid:null,
141- /**
142- * Generatorモードのときに使用する関数です。
143- * Generatorモードの時は、yieldと併用してnew DigitalOut()の完了を待ちます。
144- * @name mbedJS.DigitalOut#waitForNew
145- * @function
146- */
147- waitForNew:function DigitalOut_waitForNew()
148- {
149- try{
150- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
151- this._lc=CLASS.waitForNew;
152- }catch(e){
153- throw new MI.MiMicException(e);
154- }
155- },
156- /**
157- * ピンに値を出力します。
158- * 関数の完了時にonWriteイベントが発生します。
159- * Generatorモードの時は、yieldと併用して完了を待機できます。
160- * @name mbedJS.DigitalOut#write
161- * @function
162- * @param {int} i_value
163- * @return {int}
164- * Callbackモードの時はRPCメソッドのインデクスを返します。
165- */
166- write:function DigitalOut_write(i_value)
167- {
168- try{
169- var _t=this;
170- var cb=MI._getCb(arguments,_t._event.onWrite);
171- MI._assertYield.call(_t);
172- _t._lc=CLASS.write;
173- MI.assertInt(i_value);
174- return _t._mcu.rpc(_t.RPC_NS+":write",_t._oid+","+i_value,
175- function(j){
176- if(cb){cb();}
177- if(_t._gen){_t._gen.next();}
178- _t._lc=null;
179- });
180- }catch(e){
181- throw new MI.MiMicException(e);
182- }
183- },
184- /**
185- * ピンから値を読み込みます。
186- * 関数の完了時にonReadイベントが発生します。
187- * Generatorモードの時は、yieldと併用して完了を待機できます。
188- * @name mbedJS.DigitalOut#read
189- * @function
190- * @return　{int}
191- * Callbackモードの時はRPCメソッドのインデクスを返します。
192- * @return　{int}
193- * Generatorモードの時はピンの値を返します。
194- */
195- read:function DigitalOut_read()
196- {
197- try{
198- var _t=this;
199- var cb=MI._getCb(arguments,_t._event.onRead);
200- MI._assertYield.call(_t);
201- _t._lc=CLASS.read;
202- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
203- function (j)
204- {
205- var v=j.result[0];
206- if(cb){cb(v);}
207- if(_t._gen){_t._gen.next(v);}
208- _t._lc=null;
209- }
210- );
211- }catch(e){
212- throw new MI.MiMicException(e);
213- }
214- },
215- /**
216- * MCUに生成されているオブジェクトを破棄します。
217- * @name mbedJS.DigitalOut#dispose
218- * @function
219- */
220- dispose:function DigitalOut_dispose()
221- {
222- return this._mcu._dispose.apply(this,arguments);
223- }
224-
225-}
226-NS.DigitalOut=CLASS;
227-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.I2C.js
+++ /dev/null
@@ -1,401 +0,0 @@
1-/**
2- * @fileOverview I2Cクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * I2Cクラスです。
10- * <a href="https://mbed.org/handbook/I2C">mbed::I2C</a>と同等の機能を持ちます。
11- * @constructor
12- * @name mbedJS.I2C
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName,PinName]} i_params
16- * i2Cバスを構成するピンIDを指定します。sda,sclの順番です。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function()} onFrequency -
26- * frequency関数が完了したときに呼び出されます。
27- * </li>
28- * <li>{function(ret,data)} onRead -
29- * read関数が完了したときに呼び出されます。
30- * <ul>
31- * <li>ret {int}-は成功/失敗フラグを返します。read.1とread.2の場合で意味が異なります。
32- * read.1の場合、 0:ACK(成功),1:NACK(失敗)です。read.2の場合、読みだした値です。</li>
33- * <li>data {byte[]}-読みだしたデータの配列です。read.1の場合のみ有効です。</li>
34- * </ul>
35- * </li>
36- * <li>{function(ret)} onWrite -
37- * write関数が完了したときに呼び出されます。
38- * <ul>
39- * <li>ret {int}-成功/失敗フラグを返します。write.1とwrite.2の場合で意味が異なります。
40- * write.1の場合、ACK:0(成功),NACK:それ以外です。write.2の場合、ACKを受信すると1を返します。</li>
41- * </ul>
42- * </li>
43- * <li>{function()} onStart -
44- * start関数が完了したときに呼び出されます。
45- * </li>
46- * <li>{function()} onStop -
47- * stop関数が完了したときに呼び出されます。
48- * </li>
49- * </ul>
50- * <p>
51- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
52- * </p>
53- * <p>
54- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
55- * </p>
56- * @return {mbedJS.I2C}
57- * @example //Callback
58- * var st=0;
59- * var mcu=new mbedJS.Mcu("192.168.128.39",
60- * {
61- * onNew:function(){
62- * var i2c=new mbedJS.I2C(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],{
63- * onNew:function(){
64- * i2c.frequency(100000);
65- * },
66- * onFrequency:function()
67- * {
68- * i2c.start();
69- * },
70- * onStart:function(){
71- * st=0;
72- * i2c.write(1);
73- * },
74- * onWrite:function(v){
75- * if(st==0){
76- * i2c.write(0,[1,2,3],false);
77- * st++;
78- * }else{
79- * i2c.read(1);
80- * st=0;
81- * }
82- * },
83- * onRead:function(v){
84- * if(st==0){
85- * i2c.read(1,2,false);
86- * st++;
87- * }else{
88- * i2c.stop();
89- * }
90- * },
91- * onStop:function(){
92- * mcu.close();
93- * }
94- * });
95- * },
96- * onClose:function(){
97- * },
98- * onError:function(){
99- * alert("Error");
100- * }
101- * });
102- * @example //Generator
103- * var g=function*(){
104- * try{
105- * var v;
106- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
107- * yield mcu.waitForNew();
108- * var i2c=new mbedJS.I2C(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],g);
109- * yield i2c.waitForNew();
110- * yield i2c.frequency(100000);
111- * yield i2c.start();
112- * yield i2c.write(1);
113- * yield i2c.write(0,[1,2,3],false);
114- * yield i2c.read(1);
115- * yield i2c.read(1,2,false);
116- * yield i2c.stop();
117- * yield mcu.close();
118- * }catch(e){
119- * mcu.shutdown();
120- * alert(e);
121- * throw e;
122- * }
123- * }();
124- * g.next();
125- */
126-var CLASS=function I2C(i_mcu,i_params,i_handler)
127-{
128- try{
129- var _t=this;
130- _t._mcu=i_mcu;
131- _t._lc=CLASS;
132- var cb=MI._initHandler.call(_t,i_handler);
133- MI.assertInt(i_params);
134- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1],
135- function (j)
136- {
137- _t._oid=j.result[0];
138- if(cb){cb();}
139- if(_t._gen){_t._gen.next(_t);}
140- _t._lc=null;
141- }
142- );
143- }catch(e){
144- throw new MI.MiMicException(e);
145- }
146-}
147-CLASS.prototype=
148-{
149- /** @private */
150- RPC_NS:"mbedJS:I2C",
151- /** @private 最後にコールしたAPIです。*/
152- _lc:null,
153- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
154- _gen:null,
155- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
156- _event:{},
157- /** @private リモートインスタンスのオブジェクトIDです。*/
158- _oid:null,
159- /**
160- * Generatorモードのときに使用する関数です。
161- * Generatorモードの時は、yieldと併用してnew I2C()の完了を待ちます。
162- * @name mbedJS.I2C#waitForNew
163- * @function
164- */
165- waitForNew:function I2C_waitForNew()
166- {
167- try{
168- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
169- this._lc=CLASS.waitForNew;
170- }catch(e){
171- throw new MI.MiMicException(e);
172- }
173- },
174- /**
175- * Hz単位でバスの速度を指定します。
176- * 関数の完了時にonFrequencyイベントが発生します。
177- * Generatorモードの時は、yieldと併用して完了を待機できます。
178- * @name mbedJS.I2C#frequency
179- * @function
180- * @param {int} i_hz
181- * Hz単位のバス速度です。
182- * @return　{int}
183- * Callbackモードの時はRPCメソッドのインデクスを返します。
184- */
185- frequency:function I2C_frequency(i_hz)
186- {
187- try{
188- var _t=this;
189- var cb=MI._getCb(arguments,_t._event.onFrequency);
190- MI._assertYield.call(_t);
191- _t._lc=CLASS.frequency;
192- MI.assertInt(i_hz);
193- return _t._mcu.rpc(_t.RPC_NS+":frequency",_t._oid+","+i_hz,
194- function (j)
195- {
196- if(cb){cb();}
197- if(_t._gen){_t._gen.next();}
198- _t._lc=null;
199- }
200- );
201- }catch(e){
202- throw new MI.MiMicException(e);
203- }
204- },
205- /**
206- * 引数が3個の場合
207- * @name mbedJS.I2C#read:1
208- * @function
209- * @param {int} address
210- * 8ビットのI2CSlaveアドレスです。
211- * @param {int} length
212- * 読み出すデータの長さです。256未満の値を指定してください。
213- * @param {boolean} repeated
214- * Repeated start, true - do not send stop at end
215- * Optionalです。省略時はfalseです。
216- * @return {int}
217- * Callbackモードの時はRPCメソッドのインデクスを返します。
218- * @return {HashMap}
219- * {ret:int,data:[byte]}
220- * Generatorの場合は戻り値オブジェクトを返します。
221- * <ul>
222- * <li>ret {int}- 成功フラグ 0:ACK(成功),1:NACK(失敗)</li>
223- * <li>data {byte[]}- 読みだしたデータ</li>
224- * </ul>
225- */
226- /**
227- * 引数が1個の場合
228- * @name mbedJS.I2C#read:2
229- * @function
230- * @param {int} ack
231- * indicates if the byte is to be acknowledged (1 = acknowledge)
232- * @return {int}
233- * Callbackモードの時はRPCメソッドのインデクスを返します。
234- * @return {int}
235- * Generatorモードの時は読みだした値を返します。
236- */
237- /**
238- * バスから値を読み出します。
239- * 関数の完了時にonReadイベントが発生します。
240- * Generatorモードの時は、yieldと併用して完了を待機できます。
241- * @name mbedJS.I2C#read
242- * @function
243- * @param ...
244- * 詳細はmbedJS.I2C#read:Nを参照してください。
245- */
246- read:function I2C_read(/*...*/)
247- {
248- try{
249- var _t=this;
250- var cb=MI._getCb(arguments,_t._event.onRead);
251- MI._assertYield.call(_t);
252- _t._lc=CLASS.read;
253- function rcb(j){
254- var v=j.result.length>1?{ret:j.result[0],data:MI.bstr2byteArray(j.result[1])}:j.result[0];
255- if(cb){cb(v);}
256- if(_t._gen){_t._gen.next(v);}
257- _t._lc=null;
258- }
259- //ベース引数の数で処理の切り替え
260- if(MI._getBaseArgsLen(arguments)==1){
261- MI.assertInt(arguments[0]);
262- return _t._mcu.rpc(_t.RPC_NS+":read2",_t._oid+","+arguments[0],rcb);
263- }else{
264- var a=arguments;
265- MI.assertInt([a[0],a[1]]);
266- return _t._mcu.rpc(_t.RPC_NS+":read1",_t._oid+","+a[0]+","+a[1]+","+(a[2]?1:0),rcb);
267- }
268- }catch(e){
269- throw new MI.MiMicException(e);
270- }
271- },
272- /**
273- * 引数が3個の場合
274- * @name mbedJS.I2C#write:1
275- * @function
276- * @param {int} address
277- * 8ビットのI2CSlaveアドレスです。
278- * @param {byte[]} data
279- * 送信するデータを格納したバイト配列です。
280- * @param {boolean} repeated
281- * Repeated start, true - do not send stop at end
282- * Optionalです。省略時はfalseです。
283- * @return {int}
284- * Callbackモードの時はRPCメソッドのインデクスを返します。
285- * @return {int}
286- * Generatorモードの時は成功/失敗フラグを返します。ACK:0(成功),NACK:それ以外です。
287- */
288- /**
289- * 引数が1個の場合
290- * @name mbedJS.I2C#write:2
291- * @function
292- * @param {int} data
293- * 送信データを指定します。
294- * @return {int}
295- * Callbackモードの時はRPCメソッドのインデクスを返します。
296- * @return {int}
297- * Generatorモードの時は成功/失敗フラグを返します。ACKを受信すると1を返します。
298- */
299- /**
300- * バスに値を書き込みます。
301- * 関数の完了時にonWriteイベントが発生します。
302- * Generatorモードの時は、yieldと併用して完了を待機できます。
303- * @name mbedJS.I2C#write
304- * @function
305- * @param ...
306- * 詳細はmbedJS.I2C#write:Nを参照してください。
307- */
308- write:function I2C_write(/*...*/)
309- {
310- try{
311- var _t=this;
312- var cb=MI._getCb(arguments,_t._event.onWrite);
313- MI._assertYield.call(_t);
314- _t._lc=CLASS.write;
315- function rcb(j){
316- var v=j.result[0];
317- if(cb){cb(v);}
318- if(_t._gen){_t._gen.next(v);}
319- _t._lc=null;
320- }
321- if(MI._getBaseArgsLen(arguments)==1){
322- MI.assertInt(arguments[0]);
323- return _t._mcu.rpc(_t.RPC_NS+":write2",_t._oid+","+arguments[0],rcb);
324- }else{
325- var a=arguments;
326- MI.assertInt(a[0]);
327- return _t._mcu.rpc(_t.RPC_NS+":write1",_t._oid+","+a[0]+",\""+MI.byteArray2bstr(a[1])+"\","+(a[2]?1:0),rcb);
328- }
329- }catch(e){
330- throw new MI.MiMicException(e);
331- }
332- },
333- /**
334- * I2Cバスを開始状態にします。
335- * 関数の完了時にonStartイベントが発生します。
336- * Generatorモードの時は、yieldと併用して完了を待機できます。
337- * @name mbedJS.I2C#start
338- * @function
339- * @return　{int}
340- * Callbackモードの時はRPCメソッドのインデクスを返します。
341- */
342- start:function I2C_start()
343- {
344- try{
345- var _t=this;
346- var cb=MI._getCb(arguments,_t._event.onStart);
347- MI._assertYield.call(_t);
348- _t._lc=CLASS.start;
349- return _t._mcu.rpc(_t.RPC_NS+":start",_t._oid,
350- function (j)
351- {
352- if(cb){cb();}
353- if(_t._gen){_t._gen.next();}
354- _t._lc=null;
355- }
356- );
357- }catch(e){
358- throw new MI.MiMicException(e);
359- }
360- },
361- /**
362- * I2Cバスを停止状態にします。
363- * 関数の完了時にonStopイベントが発生します。
364- * Generatorモードの時は、yieldと併用して完了を待機できます。
365- * @name mbedJS.I2C#stop
366- * @function
367- * @return　{int}
368- * Callbackモードの時はRPCメソッドのインデクスを返します。
369- */
370- stop:function I2C_stop()
371- {
372- try{
373- var _t=this;
374- var cb=MI._getCb(arguments,_t._event.onStop);
375- MI._assertYield.call(_t);
376- _t._lc=CLASS.stop;
377- return _t._mcu.rpc(_t.RPC_NS+":stop",_t._oid,
378- function (j)
379- {
380- if(cb){cb();}
381- if(_t._gen){_t._gen.next();}
382- _t._lc=null;
383- }
384- );
385- }catch(e){
386- throw new MI.MiMicException(e);
387- }
388- },
389- /**
390- * MCUに生成されているオブジェクトを破棄します。
391- * @name mbedJS.I2C#dispose
392- * @function
393- */
394- dispose:function I2C_dispose()
395- {
396- return this._mcu._dispose.apply(this,arguments);
397- }
398-
399-}
400-NS.I2C=CLASS;
401-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.I2CSlave.js
+++ /dev/null
@@ -1,437 +0,0 @@
1-/**
2- * @fileOverview I2CSlaveクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * I2CSlaveクラスです。
10- * <a href="https://mbed.org/handbook/I2CSlave">mbed::I2CSlave</a>と同等の機能を持ちます。
11- * @constructor
12- * @name mbedJS.I2CSlave
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName,PinName]} i_params
16- * i2Cバスを構成するピンIDを指定します。sda,sclの順番です。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function()} onFrequency -
26- * frequency関数が完了したときに呼び出されます。
27- * </li>
28- * <li>{function(ret,data)} onRead -
29- * read関数が完了したときに呼び出されます。
30- * <ul>
31- * <li>ret {int}-は成功/失敗フラグを返します。read.1とread.2の場合で意味が異なります。
32- * read.1の場合、 0:ACK(成功),1:NACK(失敗)です。read.2の場合、読みだした値です。</li>
33- * <li>data {byte[]}-読みだしたデータの配列です。read.1の場合のみ有効です。</li>
34- * </ul>
35- * </li>
36- * <li>{function(ret)} onWrite -
37- * write関数が完了したときに呼び出されます。
38- * <ul>
39- * <li>ret {int}-成功/失敗フラグを返します。write.1とwrite.2の場合で意味が異なります。
40- * write.1の場合、ACK:0(成功),NACK:それ以外です。write.2の場合、ACKを受信すると1を返します。</li>
41- * </ul>
42- * </li>
43- * <li>{function(v)} onReceive -
44- * receive関数が完了したときに呼び出されます。
45- * <li>v {int}-受信ステータス値を返します。mbedJS.I2CSlave#RxStatusの値です。</li>
46- * </ul>
47- * </li>
48- * <li>{function()} onStop -
49- * stop関数が完了したときに呼び出されます。
50- * </li>
51- * <li>{function()} onAddress -
52- * address関数が完了したときに呼び出されます。
53- * </li>
54- * </ul>
55- * <p>
56- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
57- * </p>
58- * <p>
59- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
60- * </p>
61- * @return {mbedJS.I2CSlave}
62- * @example //Callback
63- * var mcu=new mbedJS.Mcu("192.168.128.39",
64- * {
65- * onNew:function(){
66- * var i2c=new mbedJS.I2CSlave(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],{
67- * onNew:function(){
68- * i2c.frequency(100000);
69- * },
70- * onFrequency:function()
71- * {
72- * i2c.address(1);
73- * },
74- * onAddress:function()
75- * {
76- * i2c.receive();
77- * },
78- * onReceive:function(){
79- * st=0;
80- * i2c.write(1);
81- * },
82- * onWrite:function(v){
83- * if(st==0){
84- * i2c.write([1,2,3]);
85- * st++;
86- * }else{
87- * i2c.read();
88- * st=0;
89- * }
90- * },
91- * onRead:function(v){
92- * if(st==0){
93- * i2c.read(2,false);
94- * st++;
95- * }else{
96- * log("[PASS]onRead:"+v.ret+":"+v.data);
97- * i2c.stop();
98- * }
99- * },
100- * onStop:function(){
101- * mcu.close();
102- * }
103- * });
104- * },
105- * onClose:function(){
106- * },
107- * onError:function(){
108- * alert("Error");
109- * }
110- * });
111- * @example //Generator
112- * var g=function*(){
113- * try{
114- * var v;
115- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
116- * yield mcu.waitForNew();
117- * var i2c=new mbedJS.I2CSlave(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],g);
118- * yield i2c.waitForNew();
119- * yield i2c.frequency(100000);
120- * yield i2c.address(1);
121- * v=yield i2c.receive();
122- * v=yield i2c.write(1);
123- * v=yield i2c.write([1,2,3]);
124- * v=yield i2c.read();
125- * v=yield i2c.read(2,false);
126- * log("[PASS]onRead:"+v.ret+":"+v.data);
127- * yield i2c.stop();
128- * yield mcu.close();
129- * }catch(e){
130- * mcu.shutdown();
131- * alert(e);
132- * throw e;
133- * }
134- * }();
135- * g.next();
136- * return;
137- */
138-var CLASS=function I2CSlave(i_mcu,i_params,i_handler)
139-{
140- try{
141- var _t=this;
142- _t._mcu=i_mcu;
143- _t._lc=CLASS;
144- var cb=MI._initHandler.call(_t,i_handler);
145- MI.assertInt(i_params);
146- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1],
147- function(j)
148- {
149- _t._oid=j.result[0];
150- if(cb){cb();}
151- if(_t._gen){_t._gen.next(_t);}
152- _t._lc=null;
153- }
154- );
155- }catch(e){
156- throw new MI.MiMicException(e);
157- }
158-}
159-/**
160- * mbedJS.Serial#receiveの戻り値の種類です。
161- * NoData,ReadAddressed,WriteGeneral,WriteAddressedがあります。
162- * @name mbedJS.I2CSlave#RxStatus
163- */
164-CLASS.RxStatus={
165- NoData:0,ReadAddressed:1,WriteGeneral:2,WriteAddressed:3
166-}
167-CLASS.prototype={
168- /** @private */
169- RPC_NS:"mbedJS:I2CSlave",
170- /** @private 最後にコールしたAPIです。*/
171- _lc:null,
172- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
173- _gen:null,
174- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
175- _event:{},
176- /** @private リモートインスタンスのオブジェクトIDです。*/
177- _oid:null,
178- /**
179- * Generatorモードのときに使用する関数です。
180- * Generatorモードの時は、yieldと併用してnew I2CSlave()の完了を待ちます。
181- * @name mbedJS.I2CSlave#waitForNew
182- * @function
183- */
184- waitForNew:function I2CSlave_waitForNew()
185- {
186- try{
187- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
188- this._lc=CLASS.waitForNew;
189- }catch(e){
190- throw new MI.MiMicException(e);
191- }
192- },
193- /**
194- * I2CSlaveのアドレスを設定します。
195- * 関数の完了時にonAddressイベントが発生します。
196- * Generatorモードの時は、yieldと併用して完了を待機できます。
197- * @name mbedJS.I2CSlave#address
198- * @function
199- * @param {int} i_value
200- * 8ビットのアドレス値です。
201- * @return {int}
202- * Callbackモードの時はRPCメソッドのインデクスを返します。
203- */
204- address:function I2CSlave_address(i_value)
205- {
206- try{
207- var _t=this;
208- var cb=MI._getCb(arguments,_t._event.onAddress);
209- MI._assertYield.call(_t);
210- _t._lc=CLASS.write;
211- MI.assertInt(i_value);
212- return _t._mcu.rpc(_t.RPC_NS+":address",_t._oid+","+i_value,
213- function(j){
214- if(cb){cb();}
215- if(_t._gen){_t._gen.next();}
216- _t._lc=null;
217- }
218- );
219- }catch(e){
220- throw new MI.MiMicException(e);
221- }
222- },
223- /**
224- * Hz単位でバスの速度を指定します。
225- * 関数の完了時にonFrequencyイベントが発生します。
226- * Generatorモードの時は、yieldと併用して完了を待機できます。
227- * @name mbedJS.I2CSlave#frequency
228- * @function
229- * @param {int} i_hz
230- * Hz単位のバス速度です。
231- * @return　{int}
232- * Callbackモードの時はRPCメソッドのインデクスを返します。
233- */
234- frequency:function I2CSlave_frequency(i_hz)
235- {
236- try{
237- var _t=this;
238- var cb=MI._getCb(arguments,_t._event.onFrequency);
239- MI._assertYield.call(_t);
240- _t._lc=CLASS.frequency;
241- MI.assertInt(i_hz);
242- return _t._mcu.rpc(_t.RPC_NS+":frequency",_t._oid+","+i_hz,
243- function (j)
244- {
245- if(cb){cb();}
246- if(_t._gen){_t._gen.next();}
247- _t._lc=null;
248- }
249- );
250- }catch(e){
251- throw new MI.MiMicException(e);
252- }
253- },
254- /**
255- * 引数が2個の場合
256- * @name mbedJS.I2CSlave#read:1
257- * @function
258- * @param {int} length
259- * 読み出すデータの長さです。256未満の値を指定してください。
260- * @return {int}
261- * Callbackモードの時はRPCメソッドのインデクスを返します。
262- * @return {HashMap}
263- * {ret:int,data:[byte]}
264- * Generatorの場合は戻り値オブジェクトを返します。
265- * <ul>
266- * <li>ret {int}- 成功フラグ 0:ACK(成功),1:NACK(失敗)</li>
267- * <li>data {byte[]}- 読みだしたデータ</li>
268- * </ul>
269- */
270- /**
271- * 引数が0個の場合
272- * @name mbedJS.I2CSlave#read:2
273- * @function
274- * @return {int}
275- * Callbackモードの時はRPCメソッドのインデクスを返します。
276- * @return {int}
277- * Generatorモードの時は読みだした値を返します。
278- */
279- /**
280- * バスから値を読み出します。
281- * 関数の完了時にonReadイベントが発生します。
282- * Generatorモードの時は、yieldと併用して完了を待機できます。
283- * @name mbedJS.I2CSlave#read
284- * @function
285- * @param ...
286- * 詳細はmbedJS.I2CSlave#read:Nを参照してください。
287- */
288- read:function I2CSlave_read(/*...*/)
289- {
290- try{
291- var _t=this;
292- var cb=MI._getCb(arguments,_t._event.onRead);
293- MI._assertYield.call(_t);
294- _t._lc=CLASS.read;
295- function rcb(j){
296- var v=j.result.length>1?{ret:j.result[0],data:MI.bstr2byteArray(j.result[1])}:j.result[0];
297- if(cb){cb(v);}
298- if(_t._gen){_t._gen.next(v);}
299- _t._lc=null;
300- }
301- if(MI._getBaseArgsLen(arguments)==0){
302- return _t._mcu.rpc(_t.RPC_NS+":read2",_t._oid,rcb);
303- }else{
304- MI.assertInt(arguments[0]);
305- return _t._mcu.rpc(_t.RPC_NS+":read1",_t._oid+","+arguments[0],rcb);
306- }
307- }catch(e){
308- throw new MI.MiMicException(e);
309- }
310- },
311- /**
312- * I2CSlaveバスを開始状態にします。
313- * 関数の完了時にonReceiveイベントが発生します。
314- * Generatorモードの時は、yieldと併用して完了を待機できます。
315- * @name mbedJS.I2CSlave#receive
316- * @function
317- * @return　{int}
318- * Callbackモードの時はRPCメソッドのインデクスを返します。
319- * @return　{int}
320- * Generatorモードの時は受信ステータス値を返します。mbedJS.I2CSlave#RxStatusの値です。
321- */
322- receive:function I2CSlave_receive()
323- {
324- try{
325- var _t=this;
326- var cb=MI._getCb(arguments,_t._event.onReceive);
327- MI._assertYield.call(_t);
328- _t._lc=CLASS.start;
329- return _t._mcu.rpc(_t.RPC_NS+":receive",_t._oid,
330- function (j)
331- {
332- var v=j.result[0];
333- if(cb){cb(v);}
334- if(_t._gen){_t._gen.next(v);}
335- _t._lc=null;
336- }
337- );
338- }catch(e){
339- throw new MI.MiMicException(e);
340- }
341- },
342- /**
343- * 引数が1個(byte array)の場合
344- * @name mbedJS.I2CSlave#write:1
345- * @function
346- * @param {byte[]} data
347- * 送信するデータを格納したバイト配列です。
348- * @return {int}
349- * Callbackモードの時はRPCメソッドのインデクスを返します。
350- * @return {int}
351- * Generatorモードの時は成功/失敗フラグを返します。ACK:0(成功),NACK:それ以外です。
352- */
353- /**
354- * 引数が1個(int)の場合
355- * @name mbedJS.I2CSlave#write:2
356- * @function
357- * @param {int} data
358- * 送信データを指定します。
359- * @return {int}
360- * Callbackモードの時はRPCメソッドのインデクスを返します。
361- * @return {int}
362- * Generatorモードの時は成功/失敗フラグを返します。ACKを受信すると1を返します。
363- */
364- /**
365- * バスに値を書き込みます。
366- * 関数の完了時にonWriteイベントが発生します。
367- * Generatorモードの時は、yieldと併用して完了を待機できます。
368- * @name mbedJS.I2CSlave#write
369- * @function
370- * @param ...
371- * 詳細はmbedJS.I2CSlave#write:Nを参照してください。
372- */
373- write:function I2CSlave_write(/*...*/)
374- {
375- try{
376- var _t=this;
377- var cb=MI._getCb(arguments,_t._event.onWrite);
378- MI._assertYield.call(_t);
379- _t._lc=CLASS.write;
380- function rcb(j){
381- var v=j.result[0];
382- if(cb){cb(v);}
383- if(_t._gen){_t._gen.next(v);}
384- _t._lc=null;
385- }
386- if(!MI.isArray(arguments[0])){
387- MI.assertInt(arguments[0]);
388- return _t._mcu.rpc(_t.RPC_NS+":write2",_t._oid+","+arguments[0],rcb);
389- }else{
390- var a=arguments;
391- return _t._mcu.rpc(_t.RPC_NS+":write1",_t._oid+",\""+MI.byteArray2bstr(a[0])+"\"",rcb);
392- }
393- }catch(e){
394- throw new MI.MiMicException(e);
395- }
396- },
397- /**
398- * I2CSlaveを受信状態に戻します。
399- * 関数の完了時にonStopイベントが発生します。
400- * Generatorモードの時は、yieldと併用して完了を待機できます。
401- * @name mbedJS.I2CSlave#stop
402- * @function
403- * @return　{int}
404- * Callbackモードの時はRPCメソッドのインデクスを返します。
405- */
406- stop:function I2CSlave_stop()
407- {
408- try{
409- var _t=this;
410- var cb=MI._getCb(arguments,_t._event.onStop);
411- MI._assertYield.call(_t);
412- _t._lc=CLASS.stop;
413- return _t._mcu.rpc(_t.RPC_NS+":stop",_t._oid,
414- function (j)
415- {
416- if(cb){cb();}
417- if(_t._gen){_t._gen.next();}
418- _t._lc=null;
419- }
420- );
421- }catch(e){
422- throw new MI.MiMicException(e);
423- }
424- },
425- /**
426- * MCUに生成されているオブジェクトを破棄します。
427- * @name mbedJS.I2CSlave#dispose
428- * @function
429- */
430- dispose:function IC2Slave_dispose()
431- {
432- return this._mcu._dispose.apply(this,arguments);
433- }
434-
435-}
436-NS.I2CSlave=CLASS;
437-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.Mcu.js
+++ /dev/null
@@ -1,277 +0,0 @@
1-/**
2- * @fileOverview Mcuクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * mbedJSを搭載したmbedに接続したインスタンスを生成します。
10- * Mcuオブジェクトは、他のペリフェラルクラスをインスタンス化するときに必要です。
11- * @name mbedJS.Mcu
12- * @constructor
13- * @param {string} i_url
14- * 接続先のMiMicRPCサービスのアドレスを指定します。
15- * @param {HashMap|Generator} i_handler
16- * 非同期イベントハンドラの連想配列、又はGeneratorです。
17- * <p>
18- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
19- * <ul>
20- * <li>{function()} onNew -
21- * インスタンスが使用可能になった時に呼び出されます。
22- * </li>
23- * <li>{function()} onClose -
24- * Close関数のコールバック関数です。
25- * </li>
26- * <li>{function()} onError -
27- * 何らかの異常で通信を継続できないエラーが発生し、コネクションを維持できない時に発生します。
28- * このイベントが発生するとコネクションは閉じられれます。
29- * </li>
30- * <li>{function(v)} onDisposeObject
31- * disposeObject関数が完了したときに呼び出されます。
32- * vは削除に成功したかの真偽値です。
33- * </li>
34- * <li>{function(v)} onGetInfo
35- * onGetInfo関数が完了したときに呼び出されます。
36- * vは戻り値を格納した複合連想配列です。
37- * {version,platform,mcu:{name,eth},memory:{free}}
38- * </li>
39- * </ul>
40- * <p>
41- * Generatorを指定した場合、コールバック関数の戻り値はyiledの戻り値として取得できます。
42- * <p>
43- * @return {mbedJS.Mcu}
44- * @example //Callback
45- * var mcu=new mbedJS.Mcu("192.168.128.39",
46- * {
47- * onNew:function(){
48- * mcu.getInfo();
49- * },
50- * onGetInfo:function(v){
51- * log("[PASS]onGetInfo:"+v.version+","+v.platform+","+v.mcu.name+","+v.mcu.eth+","+v.memory.free);
52- * var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,{
53- * onNew:function(){
54- * mcu.disposeObject(pin._oid);
55- * }});
56- * },
57- * onDisposeObject:function(v){
58- * mcu.close();
59- * },
60- * onClose:function(){
61- * },
62- * onError:function(){
63- * alert("Error");
64- * }
65- * });
66- * @example //Generator
67- * var g=function*(){
68- * try{
69- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
70- * yield mcu.waitForNew();
71- * yield mcu.close();
72- * }catch(e){
73- * mcu.shutdown();
74- * }
75- * }();
76- * g.next();
77- */
78-var CLASS=function Mcu(i_url,i_handler)
79-{
80- var _t=this;
81- _t._lc=CLASS;
82- _t._has_error=false;
83- if(MI.isGenerator(i_handler)){_t._gen=i_handler;}
84- else if(i_handler){_t._event=i_handler}
85-
86- _t._rpc=new MI.Rpc({
87- onOpen:function _Mcu_onOpen(){
88- if(_t._event.onNew){_t._event.onNew();}
89- if(_t._gen){_t._gen.next(_t);}
90- _t.lc=null;
91- },
92- onClose:function _Mcu_onClose(){
93- if(_t._lc==CLASS.close){
94- if(_t._event.onClose){_t._event.onClose();}
95- }else{
96- if(_t._event.onError){_t._event.onError();}
97- }
98- if(_t._gen){
99- _t._gen.next(_t);
100- }
101- _t.lc=null;
102- },
103- onError:function _Mcu_onError()
104- {
105- _t._has_error=true;
106- if(_t._event.onError){_t._event.onError();}
107- if(_t._gen && _t._lc){
108- _t._gen.throw(new MI.MiMicException());
109- }
110- //@todo MCUにぶら下がってる全てのyieldに対してもExceptionの発生要請？
111- }
112- });
113- //MCUへ接続
114- this._rpc.open('ws://'+i_url+'/rpc/');
115-}
116-CLASS.prototype=
117-{
118- RPC_NS:"mbedJS:Mcu",
119- _lc:null,
120- _rpc:null,
121- _gen:null,
122- _event:{},
123- _has_error:false,
124- /**
125- * エラー状態であるかを返します。
126- * Generatorモードの場合に、定期実行してインスタンスの状態をチェックできます。
127- * falseの場合、下位のオブジェクトでyieldロックが発生している場合があります。
128- * @name mbedJS.Mcu#hasError
129- * @function
130- * @return {boolean}
131- * true - インスタンスはエラー状態で停止中です。使用できません。
132- * false - インスタンスは動作中です。使用可能です。
133- */
134- hasError:function(){
135- return _t._has_error;
136- },
137- /**
138- * Generatorモードのときに使用する関数です。
139- * Generatorモードの時は、yieldと併用してnew Mcu()の完了を待ちます。
140- * @name mbedJS.Mcu#waitForNew
141- * @function
142- */
143- waitForNew:function MCU_waitForNew(){
144- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
145- this._lc=CLASS.waitForNew;
146- },
147- /**
148- * RPCを切断します。関数の完了時にonCloseイベントが発生します。
149- * Generatorモードの時は、yieldと併用して完了を待機できます。
150- * @name mbedJS.Mcu#close
151- * @function
152- */
153- close:function MCU_close(){
154- MI._assertYield.call(this);
155- this._lc=CLASS.close;
156- this._rpc.close();
157- },
158- /**
159- * コールバック関数を全てキャンセルして、Mcuとの接続をシャットダウンします。
160- * この関数は即座に完了します。
161- * @name mbedJS.Mcu#shutdown
162- * @function
163- */
164- shutdown:function MCU_shutdown(){
165- this._rpc.shutdown();
166- },
167- /**
168- * RPCメソッドを実行します。
169- * @name mbedJS.Mcu#rpc
170- * @function
171- * @param {string} m
172- * メソッド名です。
173- * @param {string} p
174- * パラメータ部の文字列です。JSONオブジェクトの配列を記述します。
175- * 配列の要素はプリミティブ型である必要があります。
176- * @param {function(json)} c
177- * RPCが完了したときに呼び出すコールバック関数です。
178- * <ul>
179- * <li>json - 戻り値をJSON文字列としてパースしたObjectです。</li>
180- * </ul>
181- * @return {int}
182- * メソッドのid値を返します。
183- */
184- rpc:function Mcu_rpc(m,p,c){
185- if(this._has_error){
186- throw new MI.MiMicException();
187- }
188- return this._rpc.sendMethod(m,p,c);
189- },
190- /** @private */
191- addItem:function(o){
192- this._items.push(o);
193- },
194- /**
195- * Mcuの情報を返します。
196- * @name mbedJS.Mcu#getInfo
197- * @function
198- * @return {HashMap}
199- * 情報を格納した連想配列です。
200- */
201- getInfo:function(){
202- try{
203- var _t=this;
204- MI._assertYield.call(_t);
205- var cb=MI._getCb(arguments,_t._event.onGetInfo);
206- _t._lc=CLASS.getInfo;
207- return _t.rpc(_t.RPC_NS+":getInfo","",
208- function (j)
209- {
210- var r=j.result;
211- var v={version:r[0],platform:r[1],mcu:{name:r[3],eth:r[2]},memory:{free:r[4]}};
212- if(cb){cb(v);}
213- if(_t._gen){_t._gen.next(v);}
214- _t._lc=null;
215- }
216- );
217- }catch(e){
218- throw new MI.MiMicException(e);
219- }
220- },
221- /**
222- * 指定idのオブジェクトをMCUのメモリから削除します。
223- * @name mbedJS.Mcu#disposeObject
224- * @function
225- * @param {int} i_oid
226- * オブジェクトID。
227- * mbedJSオブジェクトが所有するリモートオブジェクトのIDを指定します。
228- * @return {boolean}
229- * 結果を返します。
230- */
231- disposeObject:function(i_oid){
232- try{
233- var _t=this;
234- MI._assertYield.call(_t);
235- var cb=MI._getCb(arguments,_t._event.onDisposeObject);
236- _t._lc=CLASS.disposeObject;
237- return _t.rpc(_t.RPC_NS+":disposeObject",i_oid,
238- function (j)
239- {
240- var v=j.result[0]?true:false;
241- if(cb){cb(v);}
242- if(_t._gen){_t._gen.next(v);}
243- _t._lc=null;
244- }
245- );
246- }catch(e){
247- throw new MI.MiMicException(e);
248- }
249- },
250- /**
251- * 内部関数です.
252- * ペリフェラルクラスから_dispose.apply(this,arguments)でコールしてください。
253- * @private
254- */
255- _dispose:function(){
256- try{
257- var _t=this;
258- MI._assertYield.call(_t);
259- var cb=MI._getCb(arguments,_t._event.onDispose);
260- _t._lc=_t.dispose;//CLASS.disposeが使えないんでIDに関数そのものを使う
261- return _t._mcu.rpc(_t._mcu.RPC_NS+":disposeObject",_t._oid,
262- function (j)
263- {
264- var v=j.result[0]?true:false;
265- if(cb){cb(v);}
266- if(_t._gen){_t._gen.next(v);}
267- _t._lc=null;
268- }
269- );
270- }catch(e){
271- throw new MI.MiMicException(e);
272- }
273- }
274-
275-}
276-NS.Mcu=CLASS;
277-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.Memory.js
+++ /dev/null
@@ -1,363 +0,0 @@
1-/**
2- * @fileOverview Memoryクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * Memoryクラスです。
10- * <a href="https://mbed.org/handbook/Memory">mbed::Memory</a>と同等の機能を持ちます。
11- * @name mbedJS.Memory
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {HashMap|Generator|function} i_handler
16- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
17- * <p>
18- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
19- * <ul>
20- * <li>{function()} onNew -
21- * インスタンスが使用可能になった時に呼び出されます。
22- * </li>
23- * <li>{function(v)} onRead -
24- * read関数が完了した時に呼び出されます。
25- * <ul>
26- * <li>{byte[]} v - 読みだしたバイト値を格納した配列です。</li>
27- * </ul>
28- * </li>
29- * <li>{function(v)} onRead32 -
30- * read32関数が完了した時に呼び出されます。
31- * <ul>
32- * <li>{int[]} v - 読みだしたuint32値を格納した配列です。</li>
33- * </ul>
34- * </li>
35- * <li>{function()} onWrite -
36- * write関数が完了した時に呼び出されます。
37- * </li>
38- * <li>{function()} onWrite32 -
39- * write32関数が完了した時に呼び出されます。
40- * </li>
41- * </ul>
42- * <p>
43- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
44- * </p>
45- * <p>
46- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
47- * </p>
48- * @return {mbedJS.Memory}
49- * @example //Callback
50- * var s=0;
51- * var mcu=new mbedJS.Mcu("192.168.128.39",
52- * {
53- * onNew:function(){
54- * var mem=new mbedJS.Memory(mcu,{
55- * onNew:function(){
56- * s=0;
57- * mem.write(0x20080000,1);
58- * },
59- * onWrite:function(){
60- * log("[PASS]onWrite:"+s);
61- * switch(s){
62- * case 0:
63- * mem.read(0x20080000,1);
64- * break;
65- * case 1:
66- * mem.read(0x20080001,1);
67- * break;
68- * case 2:
69- * mem.read(0x20080000,8);
70- * break;
71- * }
72- * },
73- * onRead:function(v){
74- * log("[PASS]onRead:"+s);
75- * switch(s){
76- * case 0:
77- * mem.write(0x20080001,[2]);
78- * break;
79- * case 1:
80- * mem.write(0x20080004,[10,20,30]);
81- * break;
82- * case 2:
83- * mem.write32(0x20080000,0xff);
84- * s=-1;
85- * }
86- * s++;
87- * },
88- * onWrite32:function(){
89- * log("[PASS]onWrite32:"+s);
90- * switch(s){
91- * case 0:
92- * mem.read32(0x20080000);
93- * break;
94- * case 1:
95- * mem.read32(0x20080004,4);
96- * break;
97- * case 2:
98- * mem.read32(0x20080000,16);
99- * break;
100- * }
101- * },
102- * onRead32:function(v){
103- * log("[PASS]onRead32:"+s);
104- * switch(s){
105- * case 0:
106- * mem.write32(0x20080004,[2]);
107- * break;
108- * case 1:
109- * mem.write32(0x20080004,[10,20,30]);
110- * break;
111- * case 2:
112- * mcu.close();
113- * }
114- * s++;
115- * }
116- * });
117- * },
118- * onClose:function(){
119- * log("[PASS]onClose");
120- * },
121- * onError:function(){
122- * alert("Error");
123- * }
124- * });
125- * @example //Generator
126- * var g=function*(){
127- * try{
128- * var v;
129- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
130- * yield mcu.waitForNew();
131- * var mem=new mbedJS.Memory(mcu,g);
132- * yield mem.waitForNew();
133- * yield mem.write(0x20080000,1);
134- * log("[PASS]onWrite:");
135- * v=yield mem.read(0x20080000,1);
136- * log("[PASS]onRead:"+v);
137- * v=yield mem.read(0x20080001,1);
138- * log("[PASS]onRead:"+v);
139- * v=yield mem.read(0x20080000,8);
140- * log("[PASS]onRead:"+v);
141- * yield mem.write(0x20080001,[2]);
142- * log("[PASS]onWrite:");
143- * yield mem.write(0x20080004,[10,20,30]);
144- * log("[PASS]onWrite:");
145- * yield mem.write32(0x20080000,0xff);
146- * log("[PASS]onWrite32:");
147- * v=yield mem.read32(0x20080000);
148- * log("[PASS]onRead32:"+v);
149- * v=yield mem.read32(0x20080004,4);
150- * log("[PASS]onRead32:"+v);
151- * v=yield mem.read32(0x20080000,16);
152- * log("[PASS]onRead32:"+v);
153- * yield mem.write32(0x20080004,[2]);
154- * log("[PASS]onWrite32:");
155- * yield mem.write32(0x20080004,[10,20,30]);
156- * log("[PASS]onWrite32:");
157- * mcu.close();
158- * }catch(e){
159- * mcu.shutdown();
160- * alert(e);
161- * throw e;
162- * }
163- * }();
164- * g.next();
165- */
166-var CLASS=function Memory(i_mcu,i_handler)
167-{
168- try{
169- var _t=this;
170- _t._mcu=i_mcu;
171- _t._lc=CLASS;
172- var cb=MI._initHandler.call(_t,i_handler);
173- _t._mcu.rpc(_t.RPC_NS+":init","",
174- function(j)
175- {
176- if(cb){cb();}
177- if(_t._gen){_t._gen.next(_t);}
178- _t._lc=null;
179- }
180- );
181- }catch(e){
182- throw new MI.MiMicException(e);
183- }
184-}
185-CLASS.prototype=
186-{
187- /** @private */
188- RPC_NS:"MiMic:Memory",
189- /** @private 最後にコールしたAPIです。*/
190- _lc:null,
191- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
192- _gen:null,
193- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
194- _event:{},
195- /**
196- * Generatorモードのときに使用する関数です。
197- * Generatorモードの時は、yieldと併用してnew Memory()の完了を待ちます。
198- * @name mbedJS.Memory#waitForNew
199- * @function
200- */
201- waitForNew:function Memory_waitForNew()
202- {
203- try{
204- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
205- this._lc=CLASS.waitForNew;
206- }catch(e){
207- throw new MI.MiMicException(e);
208- }
209- },
210- /**
211- * 1バイト単位でメモリから読み込みます。
212- * 関数の完了時にonReadイベントが発生します。
213- * Generatorモードの時は、yieldと併用して完了を待機できます。
214- * @name mbedJS.Memory#read
215- * @function
216- * @param {int} i_addr
217- * メモリアドレス
218- * @param {int} i_size
219- * (Optional) 読出しサイズです。省略時は1です。
220- * @return　{int}
221- * Callbackモードの時はRPCメソッドのインデクスを返します。
222- * @return　{int[]}
223- * Generatorモードの時はメモリ値を格納した配列を返します。
224- */
225- read:function Memory_read(i_addr,i_size)
226- {
227- //read(i_addr)
228- //read(i_addr,i_len)
229- try{
230- var _t=this;
231- var cb=MI._getCb(arguments,_t._event.onRead);
232- MI._assertYield.call(_t);
233- _t._lc=CLASS.read;
234- var a=[i_addr,(MI._getBaseArgsLen(arguments)==1)?i_size:1];
235- MI.assertInt(a);
236- return _t._mcu.rpc(_t.RPC_NS+":read",a[0]+","+a[1],
237- function (j)
238- {
239- var v=MI.bstr2byteArray(j.result[0]);
240- if(cb){cb(v);}
241- if(_t._gen){_t._gen.next(v);}
242- _t._lc=null;
243- });
244- }catch(e){
245- throw new MI.MiMicException(e);
246- }
247- },
248- /**
249- * 1バイトをメモリへ書き込みます。
250- * 関数の完了時にonWriteイベントが発生します。
251- * Generatorモードの時は、yieldと併用して完了を待機できます。
252- * @name mbedJS.Memory#write
253- * @function
254- * @param {int} i_addr
255- * 書き込み先のメモリアドレスを指定します。
256- * @param {int|int[]} i_v
257- * 書き込むbyte配列、または数値を指定します。
258- * 数値の場合は1バイトを書き込みます。最大長さは200byteくらいです。
259- * @return　{int}
260- * Callbackモードの時はRPCメソッドのインデクスを返します。
261- */
262- write:function Memory_write(i_addr,i_v)
263- {
264- try{
265- var _t=this;
266- var cb=MI._getCb(arguments,_t._event.onWrite);
267- MI._assertYield.call(_t);
268- _t._lc=CLASS.write;
269- MI.assertInt(i_addr);
270- MI.assertInt(i_v);
271- return _t._mcu.rpc(_t.RPC_NS+":write",i_addr+",\""+MI.byteArray2bstr(i_v)+"\"",
272- function (j)
273- {
274- if(cb){cb();}
275- if(_t._gen){_t._gen.next();}
276- _t._lc=null;
277- }
278- );
279- }catch(e){
280- throw new MI.MiMicException(e);
281- }
282- },
283- /**
284- * 4バイト単位でメモリから読み込みます。
285- * 関数の完了時にonRead32イベントが発生します。
286- * Generatorモードの時は、yieldと併用して完了を待機できます。
287- * @name mbedJS.Memory#read32
288- * @function
289- * @param {int} i_addr
290- * メモリアドレス
291- * @param {int} i_size
292- * (Optional) 読出しサイズです。省略時は4です。4の倍数を指定してください。
293- * @return　{int}
294- * Callbackモードの時はRPCメソッドのインデクスを返します。
295- * @return　{int[]}
296- * Generatorモードの時はメモリ値を格納した配列を返します。
297- */
298- read32:function Memory_read32(i_addr,i_size)
299- {
300- //read(i_addr)
301- //read(i_addr,i_len)
302- try{
303- var _t=this;
304- var cb=MI._getCb(arguments,_t._event.onRead32);
305- MI._assertYield.call(_t);
306- _t._lc=CLASS.read32;
307-
308- var a=[i_addr,(MI._getBaseArgsLen(arguments)==1)?4:i_size];
309- if(a[1]%4!=0){
310- throw new MI.MiMicException(MI.Error.NG_INVALID_ARG);
311- }
312- MI.assertInt(a);
313- return _t._mcu.rpc(_t.RPC_NS+":read",a[0]+","+a[1],
314- function (j)
315- {
316- var v=MI.bstr2uintArray(j.result[0]);
317- if(cb){cb(v);}
318- if(_t._gen){_t._gen.next(v);}
319- _t._lc=null;
320- }
321- );
322- }catch(e){
323- throw new MI.MiMicException(e);
324- }
325- },
326- /**
327- * 32bit unsigned intをメモリへ書き込みます。
328- * 関数の完了時にonWrite32イベントが発生します。
329- * Generatorモードの時は、yieldと併用して完了を待機できます。
330- * @name mbedJS.Memory#write32
331- * @function
332- * @param {int} i_addr
333- * 書き込み先のメモリアドレスを指定します。
334- * @param {int|int[]} i_v
335- * 書き込むbyte配列、または数値を指定します。
336- * 数値の場合は1バイトを書き込みます。最大長さは200byteくらいです。
337- * @return　{int}
338- * Callbackモードの時はRPCメソッドのインデクスを返します。
339- */
340- write32:function Memory_write32(i_addr,i_v)
341- {
342- try{
343- var _t=this;
344- var cb=MI._getCb(arguments,_t._event.onWrite32);
345- MI._assertYield.call(_t);
346- _t._lc=CLASS.write32;
347- MI.assertInt(i_addr);
348- MI.assertInt(i_v);
349- return _t._mcu.rpc(_t.RPC_NS+":write",i_addr+",\""+MI.uintArray2bstr(i_v)+"\"",
350- function (j)
351- {
352- if(cb){cb();}
353- if(_t._gen){_t._gen.next();}
354- _t._lc=null;
355- }
356- );
357- }catch(e){
358- throw new MI.MiMicException(e);
359- }
360- }
361-}
362-NS.Memory=CLASS;
363-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.PortIn.js
+++ /dev/null
@@ -1,184 +0,0 @@
1-/**
2- * @fileOverview PortInクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * PortInクラスです。
10- * <a href="https://mbed.org/handbook/PortIn">mbed::PortIn</a>と同等の機能を持ちます。
11- * @name mbedJS.PortIn
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {HashMap|Array} i_params
16- * <p>
17- * HashNapの場合は以下のメンバを指定できます。
18- * <ul>
19- * <li>{PortName} port -
20- * ポート名を指定します。</li>
21- * <li>{uint32} mask -
22- * ポートマスクを指定します。</li>
23- * </ul>
24- * </p>
25- * <p>配列の場合は次の順番でパラメータを指定します。
26- * <pre>{port,mask}</pre>
27- * </p>
28- * @param {HashMap|Generator|function} i_handler
29- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
30- * <p>
31- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
32- * <ul>
33- * <li>{function()} onNew -
34- * インスタンスが使用可能になった時に呼び出されます。
35- * </li>
36- * <li>{function(v)} onRead -
37- * read関数のコールバック関数です。
38- * <ul>
39- * <li>{int} v - 現在のポートの値です。</li>
40- * </ul>
41- * </li>
42- * </ul>
43- * <p>
44- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
45- * </p>
46- * <p>
47- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
48- * </p>
49- * @return {mbedJS.PortIn}
50- * @example //Callback
51- * var mcu=new mbedJS.Mcu("192.168.128.39",
52- * {
53- * onNew:function(){
54- * var pin=new mbedJS.PortIn(mcu,[mbedJS.PortName.Port0,0xffffffff],{
55- * onNew:function(){
56- * log("[PASS]onNew");
57- * pin.read();
58- * },
59- * onRead:function(v)
60- * {
61- * log("[PASS]read:"+v);
62- * mcu.close();
63- * }});
64- * },
65- * onClose:function(){
66- * log("[PASS]onClose");
67- * },
68- * onError:function(){
69- * alert("Error");
70- * }
71- * });
72- * @example //Generator
73- * var g=function*(){
74- * try{
75- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
76- * yield mcu.waitForNew();
77- * var port=new mbedJS.PortIn(mcu,[mbedJS.PortName.Port0,0xffffffff],g);
78- * yield port.waitForNew();
79- * var v=yield port.read();
80- * yield mcu.close();
81- * }catch(e){
82- * mcu.shutdown();
83- * }
84- * }();
85- * g.next();
86- */
87-var CLASS=function PortIn(i_mcu,i_params,i_handler)
88-{
89- try{
90- var _t=this;
91- _t._mcu=i_mcu;
92- _t._lc=CLASS;
93- var cb=MI._initHandler.call(_t,i_handler);
94- //引数の正規化
95- var pr;
96- if(MI.isHashArray(i_params)){
97- pr=[i_params.port,i_params.mask];
98- }else if(MI.isArray(i_params)){
99- pr=i_params;
100- }
101- MI.assertInt(pr);
102- _t._mcu.rpc(_t.RPC_NS+":_new1",pr[0]+","+pr[1],
103- function(j)
104- {
105- _t._oid=j.result[0];
106- if(cb){cb();}
107- if(_t._gen){_t._gen.next(_t);}
108- _t._lc=null;
109- }
110- );
111- }catch(e){
112- throw new MI.MiMicException(e);
113- }
114-}
115-CLASS.prototype=
116-{
117- /** @private */
118- RPC_NS:"mbedJS:PortIn",
119- /** @private 最後にコールしたAPIです。*/
120- _lc:null,
121- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
122- _gen:null,
123- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
124- _event:{},
125- /** @private リモートインスタンスのオブジェクトIDです。*/
126- _oid:null,
127- /**
128- * Generatorモードのときに使用する関数です。
129- * Generatorモードの時は、yieldと併用してnew PortIn()の完了を待ちます。
130- * @name mbedJS.PortIn#waitForNew
131- * @function
132- */
133- waitForNew:function PortIn_waitForNew()
134- {
135- try{
136- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
137- this._lc=CLASS.waitForNew;
138- }catch(e){
139- throw new MI.MiMicException(e);
140- }
141- },
142- /**
143- * ピンから値を読み込みます。
144- * 関数の完了時にonReadイベントが発生します。
145- * Generatorモードの時は、yieldと併用して完了を待機できます。
146- * @name mbedJS.PortIn#read
147- * @function
148- * @return　{int}
149- * Callbackモードの時はRPCメソッドのインデクスを返します。
150- * @return　{int}
151- * Generatorモードの時はポートの値を返します。
152- */
153- read:function PortIn_read()
154- {
155- try{
156- var _t=this;
157- var cb=MI._getCb(arguments,_t._event.onRead);
158- MI._assertYield.call(_t);
159- _t._lc=CLASS.read;
160- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
161- function (j)
162- {
163- var v=j.result[0];
164- if(cb){cb(v);}
165- if(_t._gen){_t._gen.next(v);}
166- _t._lc=null;
167- }
168- );
169- }catch(e){
170- throw new MI.MiMicException(e);
171- }
172- },
173- /**
174- * MCUに生成されているオブジェクトを破棄します。
175- * @name mbedJS.PortIn#dispose
176- * @function
177- */
178- dispose:function PortIn_dispose()
179- {
180- return this._mcu._dispose.apply(this,arguments);
181- }
182-}
183-NS.PortIn=CLASS;
184-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.PortOut.js
+++ /dev/null
@@ -1,217 +0,0 @@
1-/**
2- * @fileOverview PortOutクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * PortOutクラスです。
10- * <a href="https://mbed.org/handbook/PortOut">mbed::PortOut</a>と同等の機能を持ちます。
11- * @name mbedJS.PortOut
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {HashMap|Array} i_params
16- * <p>
17- * HashNapの場合は以下のメンバを指定できます。
18- * <ul>
19- * <li>{PortName} port -
20- * ポート名を指定します。</li>
21- * <li>{uint32} mask -
22- * ポートマスクを指定します。</li>
23- * </ul>
24- * </p>
25- * <p>配列の場合は次の順番でパラメータを指定します。
26- * <pre>{port,mask}</pre>
27- * </p>
28- * @param {HashMap|Generator|function} i_handler
29- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
30- * <p>
31- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
32- * <ul>
33- * <li>{function()} onNew -
34- * インスタンスが使用可能になった時に呼び出されます。
35- * </li>
36- * <li>{function()} onWrite -
37- * write関数のコールバック関数です。
38- * </li>
39- * <li>{function(v)} onRead -
40- * read関数のコールバック関数です。
41- * <ul>
42- * <li>{int} v - 現在のピンの値です。</li>
43- * </ul>
44- * </li>
45- * </ul>
46- * <p>
47- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
48- * </p>
49- * <p>
50- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
51- * </p>
52- * @return {mbedJS.PortOut}
53- * @example //Callback
54- * var mcu=new mbedJS.Mcu("192.168.128.39",
55- * {
56- * onNew:function(){
57- * var pin=new mbedJS.PortOut(mcu,[mbedJS.PortName.Port0,0xffffffff],{
58- * onNew:function(){
59- * pin.write(1234);
60- * },
61- * onWrite:function()
62- * {
63- * pin.read();
64- * },
65- * onRead:function(v)
66- * {
67- * mcu.close();
68- * }});
69- * },
70- * onClose:function(){
71- * },
72- * onError:function(){
73- * }
74- * });
75- * @example //Generator
76- * var g=function*(){
77- * try{
78- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
79- * yield mcu.waitForNew();
80- * var port=new mbedJS.PortOut(mcu,{port:mbedJS.PortName.Port0,mask:0xffffffff},g);
81- * yield port.waitForNew();
82- * yield port.write(5678);
83- * var v=yield port.read();
84- * yield mcu.close();
85- * }catch(e){
86- * mcu.shutdown();
87- * }
88- * }();
89- * g.next();
90- */
91-var CLASS=function PortOut(i_mcu,i_params,i_handler)
92-{
93- try{
94- var _t=this;
95- _t._mcu=i_mcu;
96- _t._lc=CLASS;
97- var cb=MI._initHandler.call(_t,i_handler);
98- //引数の正規化
99- var pr;
100- if(MI.isHashArray(i_params)){
101- pr=[i_params.port,i_params.mask];
102- }else if(MI.isArray(i_params)){
103- pr=i_params;
104- }
105- MI.assertInt(pr);
106- _t._mcu.rpc(_t.RPC_NS+":_new1",pr[0]+","+pr[1],
107- function(j)
108- {
109- _t._oid=j.result[0];
110- if(cb){cb();}
111- if(_t._gen){_t._gen.next(_t);}
112- _t._lc=null;
113- }
114- );
115- }catch(e){
116- throw new MI.MiMicException(e);
117- }
118-}
119-CLASS.prototype=
120-{
121- /** @private */
122- RPC_NS:"mbedJS:PortOut",
123- /** @private 最後にコールしたAPIです。*/
124- _lc:null,
125- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
126- _gen:null,
127- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
128- _event:{},
129- /** @private リモートインスタンスのオブジェクトIDです。*/
130- _oid:null,
131- /**
132- * Generatorモードのときに使用する関数です。
133- * Generatorモードの時は、yieldと併用してnew PortOut()の完了を待ちます。
134- * @name mbedJS.PortOut#waitForNew
135- * @function
136- */
137- waitForNew:function DigitalOut_waitForNew()
138- {
139- try{
140- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
141- this._lc=CLASS.waitForNew;
142- }catch(e){
143- throw new MI.MiMicException(e);
144- }
145- },
146- /**
147- * ポートへ値を出力します。
148- * 関数の完了時にonWriteイベントが発生します。
149- * Generatorモードの時は、yieldと併用して完了を待機できます。
150- * @name mbedJS.PortOut#write
151- * @function
152- * @param {int} i_value
153- * @return {int}
154- * Callbackモードの時はRPCメソッドのインデクスを返します。
155- */
156- write:function PortOut_write(i_value)
157- {
158- try{
159- var _t=this;
160- var cb=MI._getCb(arguments,_t._event.onWrite);
161- MI._assertYield.call(_t);
162- _t._lc=CLASS.write;
163- MI.assertInt(i_value);
164- return _t._mcu.rpc(_t.RPC_NS+":write",_t._oid+","+i_value,
165- function(j){
166- if(cb){cb();}
167- if(_t._gen){_t._gen.next();}
168- _t._lc=null;
169- }
170- );
171- }catch(e){
172- throw new MI.MiMicException(e);
173- }
174- },
175- /**
176- * ポートから値を読み込みます。
177- * 関数の完了時にonReadイベントが発生します。
178- * Generatorモードの時は、yieldと併用して完了を待機できます。
179- * @name mbedJS.PortOut#read
180- * @function
181- * @return　{int}
182- * Callbackモードの時はRPCメソッドのインデクスを返します。
183- * @return　{int}
184- * Generatorモードの時はポートの値を返します。
185- */
186- read:function PortOut_read()
187- {
188- try{
189- var _t=this;
190- var cb=MI._getCb(arguments,_t._event.onRead);
191- MI._assertYield.call(_t);
192- _t._lc=CLASS.read;
193- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
194- function (j)
195- {
196- var v=j.result[0];
197- if(cb){cb(v);}
198- if(_t._gen){_t._gen.next(v);}
199- _t._lc=null;
200- }
201- );
202- }catch(e){
203- throw new MI.MiMicException(e);
204- }
205- },
206- /**
207- * MCUに生成されているオブジェクトを破棄します。
208- * @name mbedJS.PortOut#dispose
209- * @function
210- */
211- dispose:function PortOut_dispose()
212- {
213- return this._mcu._dispose.apply(this,arguments);
214- }
215-}
216-NS.PortOut=CLASS;
217-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.PwmOut.js
+++ /dev/null
@@ -1,420 +0,0 @@
1-/**
2- * @fileOverview PwmOutクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * PwmOutクラスです。
10- * <a href="https://mbed.org/handbook/PwmOut">mbed::PwmOut</a>と同等の機能を持ちます。
11- * @name mbedJS.PwmOut
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {PinName} i_params
16- * ピンIDを指定します。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function()} onWrite -
26- * write関数のコールバック関数です。
27- * </li>
28- * <li>{function(v)} onRead -
29- * read関数のコールバック関数です。
30- * <ul>
31- * <li>{int} v - 現在のピンの値です。</li>
32- * </ul>
33- * </li>
34- * <li>{function()} onPeriod -
35- * period関数のコールバック関数です。
36- * </li>
37- * <li>{function()} onPeriod_ms -
38- * period_ms関数のコールバック関数です。
39- * </li>
40- * <li>{function()} onPeriod_us -
41- * period_ns関数のコールバック関数です。
42- * </li>
43- * <li>{function()} onPulsewidth -
44- * pulswidth関数のコールバック関数です。
45- * </li>
46- * <li>{function()} onPulsewidth_ms -
47- * pulswidth_ms関数のコールバック関数です。
48- * </li>
49- * <li>{function()} onPulsewidth_us -
50- * pulswidth_us関数のコールバック関数です。
51- * </li>
52- * </ul>
53- * <p>
54- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
55- * </p>
56- * <p>
57- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
58- * </p>
59- * @return {mbedJS.PwmOut}
60- * @example //Callback
61- * var mcu=new mbedJS.Mcu("192.168.128.39",
62- * {
63- * onNew:function(){
64- * var pin=new mbedJS.PwmOut(mcu,mbedJS.PinName.p21,{
65- * onNew:function(){
66- * pin.write(0.33);
67- * },
68- * onWrite:function()
69- * {
70- * pin.read();
71- * },
72- * onRead:function(v)
73- * {
74- * pin.period(1.0);
75- * },
76- * onPeriod:function(){
77- * pin.period_ms(1);
78- * },
79- * onPeriod_ms:function(){
80- * pin.period_us(10);
81- * },
82- * onPeriod_us:function(){
83- * pin.pulsewidth(3);
84- * },
85- * onPulsewidth:function(){
86- * pin.pulsewidth_ms(30);
87- * },
88- * onPulsewidth_ms:function(){
89- * pin.pulsewidth_us(40);
90- * },
91- * onPulsewidth_us:function(){
92- * mcu.close();
93- * }
94- * });
95- * },
96- * onClose:function(){
97- * },
98- * onError:function(){
99- * }
100- * });
101- * @example //Generator
102- * var g=function*(){
103- * try{
104- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
105- * yield mcu.waitForNew();
106- * var pin=new mbedJS.PwmOut(mcu,mbedJS.PinName.p21,g);
107- * yield pin.waitForNew();
108- * yield pin.write(0.33);
109- * var v=yield pin.read();
110- * yield pin.period(1.0);
111- * yield pin.period_ms(1);
112- * yield pin.period_us(10);
113- * yield pin.pulsewidth(3);
114- * yield pin.pulsewidth_ms(30);
115- * yield pin.pulsewidth_us(40);
116- * yield mcu.close();
117- * }catch(e){
118- * mcu.shutdown();
119- * }}();
120- * g.next();
121- */
122-var CLASS=function PwmOut(i_mcu,i_params,i_handler)
123-{
124- try{
125- var _t=this;
126- _t._mcu=i_mcu;
127- _t._lc=CLASS;
128- var cb=MI._initHandler.call(_t,i_handler);
129- MI.assertInt(i_params);
130- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params,
131- function(j)
132- {
133- _t._oid=j.result[0];
134- if(cb){cb();}
135- if(_t._gen){_t._gen.next(_t);}
136- _t._lc=null;
137- }
138- );
139- }catch(e){
140- throw new MI.MiMicException(e);
141- }
142-}
143-CLASS.prototype=
144-{
145- /** @private */
146- RPC_NS:"mbedJS:PwmOut",
147- /** @private 最後にコールしたAPIです。*/
148- _lc:null,
149- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
150- _gen:null,
151- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
152- _event:{},
153- /** @private リモートインスタンスのオブジェクトIDです。*/
154- _oid:null,
155- /**
156- * Generatorモードのときに使用する関数です。
157- * Generatorモードの時は、yieldと併用してnew PwmOut()の完了を待ちます。
158- * @name mbedJS.PwmOut#waitForNew
159- * @function
160- */
161- waitForNew:function PwmOut_waitForNew()
162- {
163- try{
164- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
165- this._lc=CLASS.waitForNew;
166- }catch(e){
167- throw new MI.MiMicException(e);
168- }
169- },
170- /**
171- * ピンに値を出力します。
172- * 関数の完了時にonWriteイベントが発生します。
173- * Generatorモードの時は、yieldと併用して完了を待機できます。
174- * @name mbedJS.PwmOut#write
175- * @function
176- * @param {float} i_value
177- * [0,1]の値を指定します。
178- * @return {int|none}
179- * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>
180- * <p>Generatorモードの時は戻り値はありません。</p>
181- */
182- write:function PwmOut_write(i_value)
183- {
184- try{
185- var _t=this;
186- var cb=MI._getCb(arguments,_t._event.onWrite);
187- MI._assertYield.call(_t);
188- _t._lc=CLASS.write;
189- MI.assertNumber(i_value);
190- return _t._mcu.rpc(_t.RPC_NS+":write_fx",_t._oid+","+Math.round(i_value*10000),
191- function(j){
192- if(cb){cb();}
193- if(_t._gen){_t._gen.next();}
194- _t._lc=null;
195- });
196- }catch(e){
197- throw new MI.MiMicException(e);
198- }
199- },
200- /**
201- * ピンから値を読み込みます。
202- * 関数の完了時にonReadイベントが発生します。
203- * Generatorモードの時は、yieldと併用して完了を待機できます。
204- * @name mbedJS.PwmOut#read
205- * @function
206- * @return　{int|float}
207- * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>
208- * <p>Generatorモードの時はピンの値を返します。</p>
209- */
210- read:function PwmOut_read()
211- {
212- try{
213- var _t=this;
214- var cb=MI._getCb(arguments,_t._event.onRead);
215- MI._assertYield.call(_t);
216- _t._lc=CLASS.read;
217- return _t._mcu.rpc(_t.RPC_NS+":read_fx",_t._oid,
218- function (j)
219- {
220- var v=j.result[0]/10000;
221- if(cb){cb(v);}
222- if(_t._gen){_t._gen.next(v);}
223- _t._lc=null;
224- });
225- }catch(e){
226- throw new MI.MiMicException(e);
227- }
228- },
229- /**
230- * PWMの周期を設定します。
231- * 関数の完了時にonPeriodイベントが発生します。
232- * Generatorモードの時は、yieldと併用して完了を待機できます。
233- * @name mbedJS.PwmOut#period
234- * @function
235- * @param {float} i_value
236- * 秒単位の周期を設定します。
237- * @return {int|none}
238- * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>
239- * <p>Generatorモードの時は戻り値はありません。</p>
240- */
241- period:function PwmOut_period(i_value)
242- {
243- try{
244- var _t=this;
245- var cb=MI._getCb(arguments,_t._event.onPeriod);
246- MI._assertYield.call(_t);
247- _t._lc=CLASS.period;
248- MI.assertInt(i_value);
249- return _t._mcu.rpc(_t.RPC_NS+":period_fx",_t._oid+","+Math.round(i_value*10000),
250- function(j){
251- if(cb){cb();}
252- if(_t._gen){_t._gen.next();}
253- _t._lc=null;
254- });
255- }catch(e){
256- throw new MI.MiMicException(e);
257- }
258- },
259- /**
260- * PWMの周期を設定します。
261- * 関数の完了時にonPeriod_msイベントが発生します。
262- * Generatorモードの時は、yieldと併用して完了を待機できます。
263- * @name mbedJS.PwmOut#period_ms
264- * @function
265- * @param {int} i_value
266- * ms単位の周期を設定します。
267- * @return {int|none}
268- * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>
269- * <p>Generatorモードの時は戻り値はありません。</p>
270- */
271- period_ms:function PwmOut_period_ms(i_value)
272- {
273- try{
274- var _t=this;
275- var cb=MI._getCb(arguments,_t._event.onPeriod_ms);
276- MI._assertYield.call(_t);
277- _t._lc=CLASS.period_ms;
278- MI.assertInt(i_value);
279- return _t._mcu.rpc(_t.RPC_NS+":period_ms",_t._oid+","+i_value,
280- function(j){
281- if(cb){cb();}
282- if(_t._gen){_t._gen.next();}
283- _t._lc=null;
284- });
285- }catch(e){
286- throw new MI.MiMicException(e);
287- }
288- },
289- /**
290- * PWMの周期を設定します。
291- * 関数の完了時にonPeriod_usイベントが発生します。
292- * Generatorモードの時は、yieldと併用して完了を待機できます。
293- * @name mbedJS.PwmOut#period_us
294- * @function
295- * @param {int} i_value
296- * 整数値を指定します。
297- * @return {int|none}
298- * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>
299- * <p>Generatorモードの時は戻り値はありません。</p>
300- */
301- period_us:function PwmOut_period_us(i_value)
302- {
303- try{
304- var _t=this;
305- var cb=MI._getCb(arguments,_t._event.onPeriod_us);
306- MI._assertYield.call(_t);
307- _t._lc=CLASS.period_us;
308- MI.assertInt(i_value);
309- return _t._mcu.rpc(_t.RPC_NS+":period_us",_t._oid+","+i_value,
310- function(j){
311- if(cb){cb();}
312- if(_t._gen){_t._gen.next();}
313- _t._lc=null;
314- });
315- }catch(e){
316- throw new MI.MiMicException(e);
317- }
318- },
319- /**
320- * PWMの周期を設定します。
321- * 関数の完了時にonPeriodイベントが発生します。
322- * Generatorモードの時は、yieldと併用して完了を待機できます。
323- * @name mbedJS.PwmOut#pulsewidth
324- * @function
325- * @param {float} i_value
326- * 秒単位の周期を設定します。
327- * @return {int|none}
328- * <p>Callbackモードの時はRPCメソッドのインデクスを返します。</p>
329- * <p>Generatorモードの時は戻り値はありません。</p>
330- */
331- pulsewidth:function PwmOut_pulsewidth(i_value)
332- {
333- try{
334- var _t=this;
335- var cb=MI._getCb(arguments,_t._event.onPulsewidth);
336- MI._assertYield.call(_t);
337- _t._lc=CLASS.pulsewidth;
338- MI.assertInt(i_value);
339- return _t._mcu.rpc(_t.RPC_NS+":pulsewidth_fx",_t._oid+","+Math.round(i_value*10000),
340- function(j){
341- if(cb){cb();}
342- if(_t._gen){_t._gen.next();}
343- _t._lc=null;
344- });
345- }catch(e){
346- throw new MI.MiMicException(e);
347- }
348- },
349- /**
350- * PWMの周期を設定します。
351- * 関数の完了時にonPulsewidth_msイベントが発生します。
352- * Generatorモードの時は、yieldと併用して完了を待機できます。
353- * @name mbedJS.PwmOut#pulsewidth_ms
354- * @function
355- * @param {int} i_value
356- * ms単位の周期を設定します。
357- * @return {int}
358- * Callbackモードの時はRPCメソッドのインデクスを返します。
359- */
360- pulsewidth_ms:function PwmOut_pulsewidth_ms(i_value)
361- {
362- try{
363- var _t=this;
364- var cb=MI._getCb(arguments,_t._event.onPulsewidth_ms);
365- MI._assertYield.call(_t);
366- _t._lc=CLASS.pulsewidth_ms;
367- MI.assertInt(i_value);
368- return _t._mcu.rpc(_t.RPC_NS+":pulsewidth_ms",_t._oid+","+i_value,
369- function(j){
370- if(cb){cb();}
371- if(_t._gen){_t._gen.next();}
372- _t._lc=null;
373- }
374- );
375- }catch(e){
376- throw new MI.MiMicException(e);
377- }
378- },
379- /**
380- * PWMの周期を設定します。
381- * 関数の完了時にonPulsewidth_usイベントが発生します。
382- * Generatorモードの時は、yieldと併用して完了を待機できます。
383- * @name mbedJS.PwmOut#pulsewidth_us
384- * @function
385- * @param {int} i_value
386- * 整数値を指定します。
387- * @return {int}
388- * Callbackモードの時はRPCメソッドのインデクスを返します。
389- */
390- pulsewidth_us:function PwmOut_pulsewidth_us(i_value)
391- {
392- try{
393- var _t=this;
394- var cb=MI._getCb(arguments,_t._event.onPulsewidth_us);
395- MI._assertYield.call(_t);
396- _t._lc=CLASS.pulsewidth_us;
397- MI.assertInt(i_value);
398- return _t._mcu.rpc(_t.RPC_NS+":pulsewidth_us",_t._oid+","+i_value,
399- function(j){
400- if(cb){cb();}
401- if(_t._gen){_t._gen.next();}
402- _t._lc=null;
403- }
404- );
405- }catch(e){
406- throw new MI.MiMicException(e);
407- }
408- },
409- /**
410- * MCUに生成されているオブジェクトを破棄します。
411- * @name mbedJS.PwmOut#dispose
412- * @function
413- */
414- dispose:function PwmOut_dispose()
415- {
416- return this._mcu._dispose.apply(this,arguments);
417- }
418-}
419-NS.PwmOut=CLASS;
420-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.SPI.js
+++ /dev/null
@@ -1,239 +0,0 @@
1-/**
2- * @fileOverview SPIクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * SPIクラスです。
10- * <a href="https://mbed.org/handbook/SPI">mbed::SPI</a>と同等の機能を持ちます。
11- * @name mbedJS.SPI
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName,PinName,PinName]} i_params
16- * SPIを構成する3つのPinNameを格納する配列です。mosi,miso,sclkの順番です。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function(v)} onWrite -
26- * write関数のコールバック関数です。
27- * <ul>
28- * <li>{int} v - 受信した8BIT値です。</li>
29- * </ul>
30- * </li>
31- * <li>{function(v)} onFrequency -
32- * frequency関数のコールバック関数です。
33- * </li>
34- * <li>{function(v)} onFormat -
35- * format関数のコールバック関数です。
36- * </li>
37- * </ul>
38- * <p>
39- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
40- * </p>
41- * <p>
42- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
43- * </p>
44- * @return {mbedJS.SPI}
45- * @example　//Callback
46- * var mcu=new mbedJS.Mcu("192.168.128.39",
47- * {
48- * onNew:function(){
49- * var pin=new mbedJS.SPI(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7],{
50- * onNew:function(){
51- * pin.frequency(1000000);
52- * },
53- * onFrequency:function()
54- * {
55- * pin.format(8,3);
56- * },
57- * onFormat:function()
58- * {
59- * pin.write(39);
60- * },
61- * onWrite:function(v){
62- * mcu.close();
63- * }});
64- * },
65- * onClose:function(){
66- * },
67- * onError:function(){
68- * }
69- * });
70- * @example　//Generator
71- * var g=function*(){
72- * try{
73- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
74- * yield mcu.waitForNew();
75- * var pin=new mbedJS.SPI(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7],g);
76- * yield pin.waitForNew();
77- * yield pin.frequency(1000000);
78- * yield pin.format(8,3);
79- * v=yield pin.write(39);
80- * yield mcu.close();
81- * }catch(e){
82- * mcu.shutdown();
83- * }
84- * }();
85- * g.next();
86- */
87-var CLASS=function SPI(i_mcu,i_params,i_handler)
88-{
89- try{
90- var _t=this;
91- _t._mcu=i_mcu;
92- _t._lc=CLASS;
93- var cb=MI._initHandler.call(_t,i_handler);
94- MI.assertInt(i_params);
95- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1]+","+i_params[2]+","+NS.PinName.NC,
96- function(j)
97- {
98- _t._oid=j.result[0];
99- if(cb){cb();}
100- if(_t._gen){_t._gen.next(_t);}
101- _t._lc=null;
102- }
103- );
104- }catch(e){
105- throw new MI.MiMicException(e);
106- }
107-
108-}
109-CLASS.prototype=
110-{
111- /** @private */
112- RPC_NS:"mbedJS:SPI",
113- /** @private 最後にコールしたAPIです。*/
114- _lc:null,
115- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
116- _gen:null,
117- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
118- _event:{},
119- /** @private リモートインスタンスのオブジェクトIDです。*/
120- _oid:null,
121- /**
122- * Generatorモードのときに使用する関数です。
123- * Generatorモードの時は、yieldと併用してnew SPI()の完了を待ちます。
124- * @name mbedJS.SPI#waitForNew
125- * @function
126- */
127- waitForNew:function SPI_waitForNew()
128- {
129- try{
130- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
131- this._lc=CLASS.waitForNew;
132- }catch(e){
133- throw new MI.MiMicException(e);
134- }
135- },
136- /**
137- * SPI Slaveに値を書き込み、戻り値を返します。
138- * 関数の完了時にonWriteイベントが発生します。
139- * Generatorモードの時は、yieldと併用して完了を待機できます。
140- * @name mbedJS.SPI#write
141- * @function
142- * @param {int} i_value
143- * @return {int}
144- * Callbackモードの時はRPCメソッドのインデクスを返します。
145- */
146- write:function SPI_write(i_value)
147- {
148- try{
149- var _t=this;
150- MI._assertYield.call(_t);
151- var cb=MI._getCb(arguments,_t._event.onWrite);
152- _t._lc=CLASS.write;
153- MI.assertInt(i_value);
154- return _t._mcu.rpc(_t.RPC_NS+":write",_t._oid+","+i_value,
155- function(j){
156- var v=j.result[0];
157- if(cb){cb(v);}
158- if(_t._gen){_t._gen.next(v);}
159- _t._lc=null;
160- }
161- );
162- }catch(e){
163- throw new MI.MiMicException(e);
164- }
165- },
166- /**
167- * frequencyに値を設定します。
168- * 関数の完了時にonFrequencyイベントが発生します。
169- * Generatorモードの時は、yieldと併用して完了を待機できます。
170- * @name mbedJS.SPI#frequency
171- * @function
172- * @param {int} i_value
173- * frequencyに設定する値です。
174- * @return {int}
175- * Callbackモードの時はRPCメソッドのインデクスを返します。
176- */
177- frequency:function SPI_frequency(i_value)
178- {
179- try{
180- var _t=this;
181- MI._assertYield.call(_t);
182- var cb=MI._getCb(arguments,_t._event.onFrequency);
183- _t._lc=CLASS.frequency;
184- MI.assertInt(i_value);
185- return _t._mcu.rpc(_t.RPC_NS+":frequency",_t._oid+","+i_value,
186- function(j){
187- if(cb){cb();}
188- if(_t._gen){_t._gen.next();}
189- _t._lc=null;
190- }
191- );
192- }catch(e){
193- throw new MI.MiMicException(e);
194- }
195- },
196- /**
197- * formatに値を設定します。
198- * 関数の完了時にonFormatイベントが発生します。
199- * Generatorモードの時は、yieldと併用して完了を待機できます。
200- * @name mbedJS.SPI#format
201- * @function
202- * @param {int} i_bits
203- * @param {int} i_mode
204- * 省略可能です。省略時は0になります。
205- * @return {int}
206- * Callbackモードの時はRPCメソッドのインデクスを返します。
207- */
208- format:function SPI_format(i_bits,i_mode)
209- {
210- try{
211- var _t=this;
212- MI._assertYield.call(_t);
213- var cb=MI._getCb(arguments,_t._event.onFormat);
214- _t._lc=CLASS.format;
215- var mode=i_mode?i_mode:0;
216- MI.assertInt([i_bits,mode]);
217- return _t._mcu.rpc(_t.RPC_NS+":format",_t._oid+","+i_bits+","+mode,
218- function(j){
219- if(cb){cb();}
220- if(_t._gen){_t._gen.next();}
221- _t._lc=null;
222- }
223- );
224- }catch(e){
225- throw new MI.MiMicException(e);
226- }
227- },
228- /**
229- * MCUに生成されているオブジェクトを破棄します。
230- * @name mbedJS.SPI#dispose
231- * @function
232- */
233- dispose:function SPI_dispose()
234- {
235- return this._mcu._dispose.apply(this,arguments);
236- }
237-}
238-NS.SPI=CLASS;
239-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.SPISlave.js
+++ /dev/null
@@ -1,314 +0,0 @@
1-/**
2- * @fileOverview SPISlaveクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * SPISlaveクラスです。
10- * <a href="https://mbed.org/handbook/SPISlave">mbed::SPISlave</a>と同等の機能を持ちます。
11- * @name mbedJS.SPISlave
12- * @constructor
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName,PinName,PinName]} i_params
16- * SPIを構成する4つのPinNameを格納する配列です。
17- * mosi, miso, sclkの順番で設定します。
18- * @param {HashMap|Generator|function} i_handler
19- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
20- * <p>
21- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
22- * <ul>
23- * <li>{function()} onNew -
24- * インスタンスが使用可能になった時に呼び出されます。
25- * </li>
26- * <li>{function(v)} onFrequency -
27- * frequency関数のコールバック関数です。
28- * </li>
29- * <li>{function(v)} onFormat -
30- * format関数のコールバック関数です。
31- * </li>
32- * <li>{function(v)} onReceive -
33- * receive関数のコールバック関数です。
34- * </li>
35- * <li>{function(v)} onRead -
36- * read関数のコールバック関数です。
37- * <ul>
38- * <li>{int} v - 受信した8BIT値です。</li>
39- * </ul>
40- * </li>
41- * <li>{function()} onReply -
42- * reply関数のコールバック関数です。
43- * </li>
44- * </ul>
45- * <p>
46- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
47- * </p>
48- * <p>
49- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
50- * </p>
51- * @return {mbedJS.SPI}
52- * @example //Callback
53- * var mcu=new mbedJS.Mcu("192.168.128.39",
54- * {
55- * onNew:function(){
56- * var pin=new mbedJS.SPISlave(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7,mbedJS.PinName.p8],{
57- * onNew:function(){
58- * pin.frequency(1000000);
59- * },
60- * onFrequency:function()
61- * {
62- * pin.format(8,3);
63- * },
64- * onFormat:function()
65- * {
66- * pin.read();
67- * },
68- * onRead:function(v){
69- * pin.receive();
70- * },
71- * onReceive:function(v)
72- * {
73- * pin.reply(1);
74- * },
75- * onReply:function(){
76- * mcu.close();
77- * }
78- * });
79- * },
80- * onClose:function(){
81- * },
82- * onError:function(){
83- * }
84- * });
85- * @example //Generator
86- * var g=function*(){
87- * try{
88- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
89- * yield mcu.waitForNew();
90- * var pin=new mbedJS.SPISlave(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7,mbedJS.PinName.p8],g);
91- * yield pin.waitForNew();
92- * yield pin.frequency(1000000);
93- * yield pin.format(8,3);
94- * var v=yield pin.read();
95- * v=yield pin.receive();
96- * yield pin.reply(1);
97- * yield mcu.close();
98- * }catch(e){
99- * mcu.shutdown();
100- * }
101- * }();
102- * g.next();
103- */
104-var CLASS=function SPISlave(i_mcu,i_params,i_handler)
105-{
106- try{
107- var _t=this;
108- _t._mcu=i_mcu;
109- _t._lc=CLASS;
110- var cb=MI._initHandler.call(_t,i_handler);
111- MI.assertInt(i_params);
112- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1]+","+i_params[2]+","+i_params[3],
113- function(j)
114- {
115- _t._oid=j.result[0];
116- if(cb){cb();}
117- if(_t._gen){_t._gen.next(_t);}
118- _t._lc=null;
119- }
120- );
121- }catch(e){
122- throw new MI.MiMicException(e);
123- }
124-}
125-CLASS.prototype=
126-{
127- /** @private */
128- RPC_NS:"mbedJS:SPISlave",
129- /** @private 最後にコールしたAPIです。*/
130- _lc:null,
131- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
132- _gen:null,
133- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
134- _event:{},
135- /** @private リモートインスタンスのオブジェクトIDです。*/
136- _oid:null,
137- /**
138- * Generatorモードのときに使用する関数です。
139- * Generatorモードの時は、yieldと併用してnew SPISlave()の完了を待ちます。
140- * @name mbedJS.SPISlave#waitForNew
141- * @function
142- */
143- waitForNew:function SPISlave_waitForNew()
144- {
145- try{
146- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
147- this._lc=CLASS.waitForNew;
148- }catch(e){
149- throw new MI.MiMicException(e);
150- }
151- },
152-
153- /**
154- * frequencyに値を設定します。
155- * 関数の完了時にonFrequencyイベントが発生します。
156- * Generatorモードの時は、yieldと併用して完了を待機できます。
157- * @name mbedJS.SPISlave#frequency
158- * @function
159- * @param {int} i_value
160- *
161- * @return {int}
162- * Callbackモードの時はRPCメソッドのインデクスを返します。
163- */
164- frequency:function SPISlave_frequency(i_value)
165- {
166- try{
167- var _t=this;
168- MI._assertYield.call(_t);
169- var cb=MI._getCb(arguments,_t._event.onFrequency);
170- _t._lc=CLASS.frequency;
171- MI.assertInt(i_value);
172- return _t._mcu.rpc(_t.RPC_NS+":frequency",_t._oid+","+i_value,
173- function(j){
174- if(cb){cb();}
175- if(_t._gen){_t._gen.next();}
176- _t._lc=null;
177- });
178- }catch(e){
179- throw new MI.MiMicException(e);
180- }
181- },
182- /**
183- * formatに値を設定します。
184- * 関数の完了時にonFormatイベントが発生します。
185- * Generatorモードの時は、yieldと併用して完了を待機できます。
186- * @name mbedJS.SPISlave#format
187- * @function
188- * @param {int} i_bits
189- * @param {int} i_mode
190- * 省略可能です。省略時は0になります。
191- * @return {int}
192- * Callbackモードの時はRPCメソッドのインデクスを返します。
193- */
194- format:function SPISlave_format(i_bits,i_mode)
195- {
196- try{
197- var _t=this;
198- MI._assertYield.call(_t);
199- var cb=MI._getCb(arguments,_t._event.onFormat);
200- _t._lc=CLASS.format;
201- var mode=i_mode?i_mode:0;
202- MI.assertInt([i_bits,mode]);
203- return _t._mcu.rpc(_t.RPC_NS+":format",_t._oid+","+i_bits+","+mode,
204- function(j){
205- if(cb){cb();}
206- if(_t._gen){_t._gen.next();}
207- _t._lc=null;
208- });
209- }catch(e){
210- throw new MI.MiMicException(e);
211- }
212- },
213- /**
214- * 転送メモリから値を読み込みます。
215- * 関数の完了時にonReadイベントが発生します。
216- * Generatorモードの時は、yieldと併用して完了を待機できます。
217- * @name mbedJS.SPISlave#read
218- * @function
219- * @return　{int}
220- * Callbackモードの時はRPCメソッドのインデクスを返します。
221- * @return　{int}
222- * Generatorモードの時はピンの値を返します。
223- */
224- read:function SPISlave_read()
225- {
226- try{
227- var _t=this;
228- MI._assertYield.call(_t);
229- var cb=MI._getCb(arguments,_t._event.onRead);
230- _t._lc=CLASS.read;
231- return _t._mcu.rpc(_t.RPC_NS+":read",_t._oid,
232- function (j)
233- {
234- var v=j.result[0];
235- if(cb){cb(v);}
236- if(_t._gen){_t._gen.next(v);}
237- _t._lc=null;
238- });
239- }catch(e){
240- throw new MI.MiMicException(e);
241- }
242- },
243- /**
244- * データが到着しているかを返します。
245- * 関数の完了時にonReadイベントが発生します。
246- * Generatorモードの時は、yieldと併用して完了を待機できます。
247- * @name mbedJS.SPISlave#receive
248- * @function
249- * @return　{int}
250- * Callbackモードの時はRPCメソッドのインデクスを返します。
251- * @return　{int}
252- * Generatorモードの時はピンの値を返します。
253- */
254- receive:function SPISlave_receive()
255- {
256- try{
257- var _t=this;
258- MI._assertYield.call(_t);
259- var cb=MI._getCb(arguments,_t._event.onReceive);
260- _t._lc=CLASS.receive;
261- return _t._mcu.rpc(_t.RPC_NS+":receive",_t._oid,
262- function (j)
263- {
264- var v=j.result[0];
265- if(cb){cb(v);}
266- if(_t._gen){_t._gen.next(v);}
267- _t._lc=null;
268- });
269- }catch(e){
270- throw new MI.MiMicException(e);
271- }
272- },
273- /**
274- * 転送バッファに次に送信するメッセージをセットします。
275- * 関数の完了時にonReplyイベントが発生します。
276- * Generatorモードの時は、yieldと併用して完了を待機できます。
277- * @name mbedJS.SPISlave#reply
278- * @function
279- * @param {int} i_value
280- * 次に送る8bitの値です。
281- * @return　{int}
282- * Callbackモードの時はRPCメソッドのインデクスを返します。
283- */
284- reply:function SPISlave_reply(i_value)
285- {
286- try{
287- var _t=this;
288- MI._assertYield.call(_t);
289- var cb=MI._getCb(arguments,_t._event.onReply);
290- _t._lc=CLASS.reply;
291- MI.assertInt(i_value);
292- return _t._mcu.rpc(_t.RPC_NS+":reply",_t._oid+","+i_value,
293- function (j)
294- {
295- if(cb){cb();}
296- if(_t._gen){_t._gen.next();}
297- _t._lc=null;
298- });
299- }catch(e){
300- throw new MI.MiMicException(e);
301- }
302- },
303- /**
304- * MCUに生成されているオブジェクトを破棄します。
305- * @name mbedJS.SPISlave#dispose
306- * @function
307- */
308- dispose:function SPISlave_dispose()
309- {
310- return this._mcu._dispose.apply(this,arguments);
311- }
312-}
313-NS.SPISlave=CLASS;
314-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.Serial.js
+++ /dev/null
@@ -1,502 +0,0 @@
1-/**
2- * @fileOverview AnalogInクラスを定義します。
3- */
4-(function(){
5-var NS=mbedJS;
6-var MI=MiMicJS;
7-
8-/**
9- * Serialクラスです。
10- * <a href="https://mbed.org/handbook/Serial">mbed::Serial</a>と同等の機能を持ちます。
11- * @constructor
12- * @name mbedJS.Serial
13- * @param {mbedJS.Mcu} i_mcu
14- * インスタンスをバインドするMCUオブジェクトです。
15- * @param {[PinName,PinName]} i_params
16- * UARTを構成する２本のピンを指定します。tx,rxの順で設定します。
17- * @param {HashMap|Generator|function} i_handler
18- * 非同期イベントハンドラの連想配列、Generator、コールバック関数の何れかを指定します。
19- * <p>
20- * 非同期イベントハンドラの場合、関数はイベントハンドラで結果を通知します。
21- * <ul>
22- * <li>{function()} onNew -
23- * インスタンスが使用可能になった時に呼び出されます。
24- * </li>
25- * <li>{function()} onFormat -
26- * format関数が完了したときに呼び出されます。
27- * </li>
28- * <li>{function(v)} onReadable -
29- * read関数が完了したときに呼び出されます。
30- * <ul>
31- * <li>{boolean} v - 読出しが可能化の真偽値です。</li>
32- * </ul>
33- * </li>
34- * <li>{function(v)} onWriteable -
35- * write関数が完了したときに呼び出されます。
36- * <ul>
37- * <li>{boolean} v - 書き込みが可能化の真偽値です。</li>
38- * </ul>
39- * </li>
40- * <li>{function()} onSend_break -
41- * send_break関数が完了したときに呼び出されます。
42- * </li>
43- * <li>{function(v)} onPutc -
44- * putc関数が完了したときに呼び出されます。
45- * <ul>
46- * <li>{int} v - 謎の戻り値です。</li>
47- * </ul>
48- * </li>
49- * <li>{function(v)} onPuts -
50- * puts関数が完了したときに呼び出されます。
51- * <ul>
52- * <li>{int} v - 謎の戻り値です。</li>
53- * </ul>
54- * </li>
55- * <li>{function(v)} onGetc -
56- * getc関数が完了したときに呼び出されます。
57- * <ul>
58- * <li>{int} v - 読みだした1バイトの値です。</li>
59- * </ul>
60- * </li>
61- * <li>{function(v)} onGets -
62- * gets関数が完了したときに呼び出されます。
63- * <ul>
64- * <li>{int} v - 読みだした文字列です。</li>
65- * </ul>
66- * </li>
67- * <li>{function()} onBaud -
68- * baud関数が完了したときに呼び出されます。
69- * </li>
70- * </ul>
71- * <p>
72- * Generatorを指定した場合、コールバック関数の引数はyiledの戻り値として取得できます。
73- * </p>
74- * <p>
75- * コールバック関数を指定した場合、RPCが完了したときに呼び出されます。メンバ関数のイベントハンドラは個別に設定する必要があります。
76- * </p>
77- * @return {mbedJS.Serial}
78- * @example //Callback
79- * var mcu=new mbedJS.Mcu("192.168.128.39",
80- * {
81- * onNew:function(){
82- * var uart=new mbedJS.Serial(mcu,[mbedJS.PinName.p9,mbedJS.PinName.p10],{
83- * onNew:function(){
84- * uart.baud(115200);
85- * },
86- * onBaud:function()
87- * {
88- * uart.send_break();
89- * },
90- * onSend_break:function(){
91- * uart.format(8,uart.Parity.None,1);
92- * },
93- * onFormat:function(){
94- * uart.readable();
95- * },
96- * onReadable:function(v){
97- * uart.writeable();
98- * },
99- * onWriteable:function(v){
100- * uart.putc(32);
101- * },
102- * onPutc:function(v){
103- * uart.getc();
104- * },
105- * onGetc:function(v){
106- * uart.puts("1234");
107- * },
108- * onPuts:function(v){
109- * uart.gets(5);
110- * },
111- * onGets:function(v){
112- * mcu.close();
113- * }
114- * });
115- * },
116- * onClose:function(){
117- * },
118- * onError:function(){
119- * alert("Error");
120- * }
121- * });
122- * @example //Generator
123- * var g=function*(){
124- * try{
125- * var v;
126- * var mcu=new mbedJS.Mcu("192.168.128.39",g);
127- * yield mcu.waitForNew();
128- * var uart=new mbedJS.Serial(mcu,[mbedJS.PinName.p9,mbedJS.PinName.p10],g);
129- * yield uart.waitForNew();
130- * yield uart.baud(115200);
131- * yield uart.send_break();
132- * yield uart.format(8,uart.Parity.None,1);
133- * v=yield uart.readable();
134- * v=yield uart.writeable();
135- * v=yield uart.putc(32);
136- * v=yield uart.getc();
137- * v=yield uart.puts("1234");
138- * v=yield uart.gets(5);
139- * yield mcu.close();
140- * }catch(e){
141- * mcu.shutdown();
142- * alert(e);
143- * throw e;
144- * }
145- * }();
146- * g.next();
147- */
148-var CLASS=function Serial(i_mcu,i_params,i_handler)
149-{
150- try{
151- var _t=this;
152- var cb;
153- _t._mcu=i_mcu;
154- _t._lc=CLASS;
155- //ハンドラの初期化
156- var cb=MI._initHandler.call(_t,i_handler);
157- MI.assertInt(i_params);
158- _t._mcu.rpc(_t.RPC_NS+":_new1",i_params[0]+","+i_params[1],
159- function(j)
160- {
161- _t._oid=j.result[0];
162- if(cb){cb();}
163- if(_t._gen){_t._gen.next(_t);}
164- _t._lc=null;
165- }
166- );
167- }catch(e){
168- throw new MI.MiMicException(e);
169- }
170-}
171-/**
172- * mbedJS.Serial#format関数に指定する値の種類です。
173- * None,Odd,Even,Forced1,Forced0があります。
174- * @name mbedJS.Serial#Parity
175- * @field
176- */
177-CLASS.Parity={
178- None:0,Odd:1,Even:2,Forced1:3,Forced0:4
179-}
180-CLASS.prototype={
181- /** @private */
182- RPC_NS:"mbedJS:Serial",
183- /** @private 最後にコールしたAPIです。*/
184- _lc:null,
185- /** @private Generatorモードの場合にGeneratorオブジェクトを保持します。*/
186- _gen:null,
187- /** @private コールバック関数の連想配列です。要素はコンストラクタを参照してください。*/
188- _event:{},
189- /** @private リモートインスタンスのオブジェクトIDです。*/
190- _oid:null,
191- /**
192- * Generatorモードのときに使用する関数です。
193- * Generatorモードの時は、yieldと併用してnew AnalogIn()の完了を待ちます。
194- * @name mbedJS.Serial#waitForNew
195- * @function
196- */
197- waitForNew:function Serial_waitForNew()
198- {
199- try{
200- if(this._lc!=CLASS){throw new MI.MiMicException(MI.Error.NG_ILLEGAL_CALL);}
201- this._lc=CLASS.waitForNew;
202- }catch(e){
203- throw new MI.MiMicException(e);
204- }
205- },
206- /**
207- * フォーマットを設定します。
208- * 関数の完了時にonFormatイベントが発生します。
209- * Generatorモードの時は、yieldと併用して完了を待機できます。
210- * @name mbedJS.Serial#format
211- * @function
212- * @param {int} i_bits
213- * ビット数です。省略時は8です。
214- * @param {int} i_parity
215- * パリティの値です。省略時はmbedJS.Serial#Parity.Noneです。
216- * @param {int} i_stop_bits
217- * ストップビットの値です。省略時は1です。
218- * @return　{int}
219- * Callbackモードの時はRPCメソッドのインデクスを返します。
220- */
221- format:function Serial_format(i_bits,i_parity,i_stop_bits)
222- {
223- try{
224- var _t=this;
225- MI._assertYield.call(_t);
226- var cb=MI._getCb(arguments,_t._event.onFormat);
227- _t._lc=CLASS.format;
228- var p=[MI.isUndefined(i_bits,8),MI.isUndefined(i_parity,CLASS.Parity.None),MI.isUndefined(i_stop_bits,1)];
229- MI.assertInt(p);
230- return _t._mcu.rpc(_t.RPC_NS+":format",_t._oid+","+p[0]+","+p[1]+","+p[2],
231- function (j)
232- {
233- if(cb){cb();}
234- if(_t._gen){_t._gen.next();}
235- _t._lc=null;
236- }
237- );
238- }catch(e){
239- throw new MI.MiMicException(e);
240- }
241- },
242- /**
243- * 読出し可能かを返します。
244- * 関数の完了時にonReadableイベントが発生します。
245- * Generatorモードの時は、yieldと併用して完了を待機できます。
246- * @name mbedJS.Serial#readable
247- * @function
248- * @return　{int}
249- * Callbackモードの時はRPCメソッドのインデクスを返します。
250- * @return　{boolean}
251- * Generatorモードの時は状態値の真偽値を返します。
252- */
253- readable:function Serial_readable()
254- {
255- try{
256- var _t=this;
257- MI._assertYield.call(_t);
258- var cb=MI._getCb(arguments,_t._event.onReadable);
259- _t._lc=CLASS.readable;
260- return _t._mcu.rpc(_t.RPC_NS+":readable",_t._oid,
261- function (j)
262- {
263- var v=j.result[0];
264- if(cb){cb(v);}
265- if(_t._gen){_t._gen.next(v);}
266- _t._lc=null;
267- }
268- );
269- }catch(e){
270- throw new MI.MiMicException(e);
271- }
272- },
273- /**
274- * 書き込み可能かを返します。
275- * 関数の完了時にonWriteableイベントが発生します。
276- * Generatorモードの時は、yieldと併用して完了を待機できます。
277- * @name mbedJS.Serial#writeable
278- * @function
279- * @return　{int}
280- * Callbackモードの時はRPCメソッドのインデクスを返します。
281- * @return　{boolean}
282- * Generatorモードの時は状態値の真偽値を返します。
283- */
284- writeable:function Serial_writeable()
285- {
286- try{
287- var _t=this;
288- MI._assertYield.call(_t);
289- var cb=MI._getCb(arguments,_t._event.onWriteable);
290- _t._lc=CLASS.writeable;
291- return _t._mcu.rpc(_t.RPC_NS+":writeable",_t._oid,
292- function (j)
293- {
294- var v=j.result[0]?true:false;
295- if(cb){cb(v);}
296- if(_t._gen){_t._gen.next(v);}
297- _t._lc=null;
298- }
299- );
300- }catch(e){
301- throw new MI.MiMicException(e);
302- }
303- },
304- /**
305- * ブレーク信号を送信します。
306- * 関数の完了時にonSend_breakイベントが発生します。
307- * Generatorモードの時は、yieldと併用して完了を待機できます。
308- * @name mbedJS.Serial#send_break
309- * @function
310- * @return　{int}
311- * Callbackモードの時はRPCメソッドのインデクスを返します。
312- */
313- send_break:function Serial_send_break()
314- {
315- try{
316- var _t=this;
317- MI._assertYield.call(_t);
318- var cb=MI._getCb(arguments,_t._event.onSend_break);
319- _t._lc=CLASS.send_break;
320- return _t._mcu.rpc(_t.RPC_NS+":send_break",_t._oid,
321- function (j)
322- {
323- if(cb){cb();}
324- if(_t._gen){_t._gen.next();}
325- _t._lc=null;
326- }
327- );
328- }catch(e){
329- throw new MI.MiMicException(e);
330- }
331- },
332- /**
333- * 1バイトの値を出力します。
334- * 関数の完了時にonPutcイベントが発生します。
335- * Generatorモードの時は、yieldと併用して完了を待機できます。
336- * @name mbedJS.Serial#putc
337- * @function
338- * @return　{int}
339- * Callbackモードの時はRPCメソッドのインデクスを返します。
340- * @return　{int}
341- * Generatorモードの時は謎の値を返します。
342- */
343- putc:function Serial_putc(i_c)
344- {
345- try{
346- var _t=this;
347- MI._assertYield.call(_t);
348- var cb=MI._getCb(arguments,_t._event.onPutc);
349- _t._lc=CLASS.putc;
350- MI.assertInt(i_c);
351- return _t._mcu.rpc(_t.RPC_NS+":putc",_t._oid+","+i_c,
352- function (j)
353- {
354- var v=j.result[0];
355- if(cb){cb(v);}
356- if(_t._gen){_t._gen.next(v);}
357- _t._lc=null;
358- }
359- );
360- }catch(e){
361- throw new MI.MiMicException(e);
362- }
363- },
364- /**
365- * 文字列を出力します。
366- * 関数の完了時にonPutsイベントが発生します。
367- * Generatorモードの時は、yieldと併用して完了を待機できます。
368- * @name mbedJS.Serial#puts
369- * @function
370- * @return　{int}
371- * Callbackモードの時はRPCメソッドのインデクスを返します。
372- * @return　{int}
373- * Generatorモードの時は謎の値を返します。
374- */
375- puts:function Serial_puts(i_s)
376- {
377- try{
378- var _t=this;
379- MI._assertYield.call(_t);
380- var cb=MI._getCb(arguments,_t._event.onPuts);
381- _t._lc=CLASS.puts;
382- return _t._mcu.rpc(_t.RPC_NS+":puts",_t._oid+",\""+i_s+"\"",
383- function (j)
384- {
385- var v=j.result[0];
386- if(cb){cb(v);}
387- if(_t._gen){_t._gen.next(v);}
388- _t._lc=null;
389- }
390- );
391- }catch(e){
392- throw new MI.MiMicException(e);
393- }
394- },
395- /**
396- * 1バイトを読み込みます。
397- * 関数の完了時にonGetcイベントが発生します。
398- * Generatorモードの時は、yieldと併用して完了を待機できます。
399- * @name mbedJS.Serial#getc
400- * @function
401- * @return　{int}
402- * Callbackモードの時はRPCメソッドのインデクスを返します。
403- * @return　{int}
404- * Generatorモードの時は受信した数値を返します。
405- */
406- getc:function Serial_getc()
407- {
408- try{
409- var _t=this;
410- MI._assertYield.call(_t);
411- var cb=MI._getCb(arguments,_t._event.onGetc);
412- _t._lc=CLASS.getc;
413- return _t._mcu.rpc(_t.RPC_NS+":getc",_t._oid,
414- function (j)
415- {
416- var v=j.result[0];
417- if(cb){cb(v);}
418- if(_t._gen){_t._gen.next(v);}
419- _t._lc=null;
420- }
421- );
422- }catch(e){
423- throw new MI.MiMicException(e);
424- }
425- },
426- /**
427- * 文字列を読み込みます。
428- * 関数の完了時にonGetsイベントが発生します。
429- * Generatorモードの時は、yieldと併用して完了を待機できます。
430- * @name mbedJS.Serial#gets
431- * @function
432- * @param {int} i_len
433- * 受信メモリのサイズを指定します。256未満を指定してください。
434- * @return　{int}
435- * Callbackモードの時はRPCメソッドのインデクスを返します。
436- * @return　{string}
437- * Generatorモードの時は受信した文字列を返します。
438- */
439- gets:function Serial_gets(i_len)
440- {
441- try{
442- var _t=this;
443- MI._assertYield.call(_t);
444- var cb=MI._getCb(arguments,_t._event.onGets);
445- _t._lc=CLASS.gets;
446- MI.assertInt(i_len);
447- return _t._mcu.rpc(_t.RPC_NS+":gets",_t._oid+","+i_len,
448- function (j)
449- {
450- var v=j.result[0];
451- if(cb){cb(v);}
452- if(_t._gen){_t._gen.next(v);}
453- _t._lc=null;
454- }
455- );
456- }catch(e){
457- throw new MI.MiMicException(e);
458- }
459- },
460- /**
461- * ボーレイトを設定します。
462- * 関数の完了時にonBaudイベントが発生します。
463- * Generatorモードの時は、yieldと併用して完了を待機できます。
464- * @name mbedJS.Serial#baud
465- * @function
466- * @param {int} i_baudrate
467- * ボーレイトの値です。
468- * @return　{int}
469- * Callbackモードの時はRPCメソッドのインデクスを返します。
470- */
471- baud:function Serial_baud(i_baudrate)
472- {
473- try{
474- var _t=this;
475- MI._assertYield.call(_t);
476- var cb=MI._getCb(arguments,_t._event.onBaud);
477- _t._lc=CLASS.baud;
478- MI.assertInt(i_baudrate);
479- return _t._mcu.rpc(_t.RPC_NS+":baud",_t._oid+","+i_baudrate,
480- function (j)
481- {
482- if(cb){cb();}
483- if(_t._gen){_t._gen.next();}
484- _t._lc=null;
485- }
486- );
487- }catch(e){
488- throw new MI.MiMicException(e);
489- }
490- },
491- /**
492- * MCUに生成されているオブジェクトを破棄します。
493- * @name mbedJS.Serial#dispose
494- * @function
495- */
496- dispose:function Serial_dispose()
497- {
498- return this._mcu._dispose.apply(this,arguments);
499- }
500-}
501-NS.Serial=CLASS;
502-}());
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/mbedJS/mbed.types.js
+++ /dev/null
@@ -1,96 +0,0 @@
1-/**
2- * @fileOverview mbedSDKの定数を定義します。
3- */
4-
5-/**
6- * mbedJSネームスペース
7- * @namespace
8- */
9-var mbedJS={};
10-(function(){
11-var NS=mbedJS;
12-/**
13- * mbedSDKのピン識別子です。ライブラリのピン名と一致します。次のピン名を使用できます。
14- * <ul>
15- * <li> LPC Pin Names(P0_0 - P4_31)
16- * <li> mbed DIP Pin Names(p5-p40)
17- * <li> Other mbed Pin Names(LED1-LED4,USBRX,USBTX)
18- * <li> Arch Pro Pin Names(D0-D15,A0-A5,I2C_SCL,I2C_SDA)
19- * <li> NC
20- * </ul>
21- * @name mbedJS.PinName
22- */
23-NS.PinName=function(){
24- var B;
25- var D={};
26- // LPC Pin Names P0_0からP5_31
27- B=0x00010000;
28- for(var i=0;i<=5;i++){
29- for(var i2=0;i2<=31;i2++){
30- D['P'+i+'_'+i2]=B+i*32+i2;
31- }
32- }
33- // mbed DIP Pin Names p5 - p40
34- B=0x00020000;
35- for(var i=5;i<=40;i++){
36- D['p'+i]=B+i;
37- }
38- // Other mbed Pin Names
39- B=0x00030000|0x0000;
40- D.LED1 = B+0;
41- D.LED2 = B+1;
42- D.LED3 = B+2;
43- D.LED4 = B+3;
44- B=0x00030000|0x0100;
45- D.USBTX = B+0;
46- D.USBRX = B+1;
47-
48- // Arch Pro Pin Names
49- //
50- B=0x00040000;
51- //D0-D15
52- for(var i=0;i<=15;i++){
53- D['D'+i]=B+i;
54- }
55- //A0-A5
56- for(var i=0;i<=5;i++){
57- D['A'+i]=B+i+0x0100;
58- }
59- D.I2C_SCL = B+0x0200+0;
60- D.I2C_SDA = B+0x0200+1;
61-
62- // Not connected
63- D.NC=0x7FFFFFFF;
64- // メンバの追加
65- return D;
66-}();
67-/**
68- * ピンモード値です。
69- * mbedSDKのピンモード値と同一です。<br/>
70- * (PullUp|PullDown|PullNone|OpenDrain|PullDefault)
71- * @name mbedJS.PinMode
72- */
73-NS.PinMode={
74- PullUp: 0x00010000,
75- PullDown: 0x00010001,
76- PullNone: 0x00010002,
77- OpenDrain: 0x00010003,
78- PullDefault:0x00010004
79-};
80-/**
81- * ポート識別子です。
82- * mbedSDKのポート名と同一です。<br/>
83- * (Port0 - Port5)
84- * @name mbedJS.PortName
85- */
86-NS.PortName={
87- Port0: 0x00010000,
88- Port1: 0x00010001,
89- Port2: 0x00010002,
90- Port3: 0x00010003,
91- Port4: 0x00010004,
92- Port4: 0x00010005
93-};
94-
95-
96-}());
\ No newline at end of file
--- /dev/null
+++ b/misc/mbedJS/mbddJS.API/readme.txt
@@ -0,0 +1,2 @@
1+Moved at 2014/07/27.
2+See https://github.com/nyatla/mbedJS-Javascript-API
--- a/misc/mbedJS/mbddJS.API/test.AnalogIn.html
+++ /dev/null
@@ -1,136 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.AnalogIn(mcu,mbedJS.PinName.A0,{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.read();
45- },
46- onRead:function(v)
47- {
48- log("[PASS]onread:"+v);
49- pin.read_u16();
50- },
51- onRead_u16:function(v){
52- log("[PASS]onRead_u16:"+v);
53- mcu.close();
54- }});
55- },
56- onClose:function(){
57- log("[PASS]onClose");
58- },
59- onError:function(){
60- alert("Error");
61- }
62- });
63-}
64-
65-function async2()
66-{
67- log();
68- log("ASYNC2");
69- var mcu=new mbedJS.Mcu("192.168.128.39",
70- {
71- onNew:function(){
72- var pin=new mbedJS.AnalogIn(mcu,mbedJS.PinName.A0,
73- function(){
74- log("[PASS]onNew");
75- pin.read(function(v)
76- {
77- log("[PASS]onread:"+v);
78- pin.read_u16(function(v){
79- log("[PASS]onRead_u16:"+v);
80- mcu.close();
81- });
82- });
83- });
84- },
85- onClose:function(){
86- log("[PASS]onClose");
87- },
88- onError:function(){
89- alert("Error");
90- }
91- });
92-}
93-
94-/**
95- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
96- */
97-function sync()
98-{
99- log();
100- var g=function*(){
101- try{
102- var mcu=new mbedJS.Mcu("192.168.128.39",g);
103- yield mcu.waitForNew();
104- var pin=new mbedJS.AnalogIn(mcu,mbedJS.PinName.A0,g);
105- log("new");
106- yield pin.waitForNew();
107- log("waitfor");
108- var v=yield pin.read();
109- log("read:"+v);
110- v=yield pin.read_u16();
111- log("read:"+v);
112- yield mcu.close();
113- log("close");
114- }catch(e){
115- mcu.shutdown();
116- alert(e);
117- throw e;
118- }
119- }();
120- g.next();
121- return;
122-
123-}
124-
125-
126-
127-</script>
128-</head>
129-<body>
130-<h1>AnalogIn test</h1>
131-<hr/>
132-<button onclick="async();">ASYNC</button>
133-<button onclick="async2();">ASYNC2</button>
134-<button onclick="sync();">SYNC</button>
135-<textarea id="console" rows="15" cols="80"></textarea>
136-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.AnalogOut.html
+++ /dev/null
@@ -1,150 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.AnalogOut(mcu,mbedJS.PinName.p18,{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.write(0.5);
45- },
46- onWrite:function()
47- {
48- log("[PASS]onWrite");
49- pin.read();
50-
51- },
52- onRead:function(v)
53- {
54- log("[PASS]onread:"+v);
55- pin.write_u16(0);
56- },
57- onWrite_u16:function()
58- {
59- log("[PASS]onWrite_u16:");
60- mcu.close();
61- }
62- });
63- },
64- onClose:function(){
65- log("[PASS]onClose");
66- },
67- onError:function(){
68- alert("Error");
69- }
70- });
71-}
72-function async2()
73-{
74- log();
75- log("ASYNC");
76- var mcu=new mbedJS.Mcu("192.168.128.39",
77- {
78- onNew:function(){
79- var pin=new mbedJS.AnalogOut(mcu,mbedJS.PinName.p18,function(){
80- log("[PASS]onNew");
81- pin.write(0.5,function()
82- {
83- log("[PASS]onWrite");
84- pin.read(function(v)
85- {
86- log("[PASS]onread:"+v);
87- pin.write_u16(0,function()
88- {
89- log("[PASS]onWrite_u16:");
90- mcu.close();
91- });
92- });
93- });
94- });
95- },
96- onClose:function(){
97- log("[PASS]onClose");
98- },
99- onError:function(){
100- alert("Error");
101- }
102- });
103-}
104-/**
105- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
106- */
107-function sync()
108-{
109- log();
110- var g=function*(){
111- try{
112- var mcu=new mbedJS.Mcu("192.168.128.39",g);
113- yield mcu.waitForNew();
114- var pin=new mbedJS.AnalogOut(mcu,mbedJS.PinName.p18,g);
115- log("new");
116- yield pin.waitForNew();
117- log("waitfor");
118- v=yield pin.write(0.3);
119- log("write");
120- var v=yield pin.read();
121- log("read:"+v);
122- v=yield pin.write_u16(1000);
123- log("write16");
124- var v=yield pin.read();
125- log("read:"+v);
126- yield mcu.close();
127- log("close");
128- }catch(e){
129- mcu.shutdown();
130- alert(e);
131- throw e;
132- }
133- }();
134- g.next();
135- return;
136-
137-}
138-
139-
140-
141-</script>
142-</head>
143-<body>
144-<h1>Analogout test</h1>
145-<hr/>
146-<button onclick="async();">ASYNC</button>
147-<button onclick="async2();">ASYNC2</button>
148-<button onclick="sync();">SYNC</button>
149-<textarea id="console" rows="15" cols="80"></textarea>
150-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.BusIn.html
+++ /dev/null
@@ -1,134 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.BusIn(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.read();
45- },
46- onRead:function(v)
47- {
48- log("[PASS]onread:"+v);
49- pin.mode(mbedJS.PinMode.PullDown);
50- },
51- onMode:function(v){
52- log("[PASS]onMode:");
53- mcu.close();
54- }});
55- },
56- onClose:function(){
57- log("[PASS]onClose");
58- },
59- onError:function(){
60- alert("Error");
61- }
62- });
63-}
64-function async2()
65-{
66- log();
67- log("ASYNC2");
68- var mcu=new mbedJS.Mcu("192.168.128.39",
69- {
70- onNew:function(){
71- var pin=new mbedJS.BusIn(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],function(){
72- log("[PASS]onNew");
73- pin.read(function(v)
74- {
75- log("[PASS]onread:"+v);
76- pin.mode(mbedJS.PinMode.PullDown,function(v){
77- log("[PASS]onMode:");
78- mcu.close();
79- });
80- });
81- });
82- },
83- onClose:function(){
84- log("[PASS]onClose");
85- },
86- onError:function(){
87- alert("Error");
88- }
89- });
90-}
91-
92-/**
93- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
94- */
95-function sync()
96-{
97- log();
98- var g=function*(){
99- try{
100- var mcu=new mbedJS.Mcu("192.168.128.39",g);
101- yield mcu.waitForNew();
102- var bus=new mbedJS.BusIn(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],g);
103- log("new");
104- yield bus.waitForNew();
105- log("waitfor");
106- var v=yield bus.read();
107- log("read:"+v);
108- v=yield bus.mode(mbedJS.PinMode.PullUp);
109- log("mode:");
110- yield mcu.close();
111- log("close");
112- }catch(e){
113- mcu.shutdown();
114- alert(e);
115- throw e;
116- }
117- }();
118- g.next();
119- return;
120-
121-}
122-
123-
124-
125-</script>
126-</head>
127-<body>
128-<h1>BusIn test</h1>
129-<hr/>
130-<button onclick="async();">ASYNC</button>
131-<button onclick="async2();">ASYNC2</button>
132-<button onclick="sync();">SYNC</button>
133-<textarea id="console" rows="15" cols="80"></textarea>
134-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.BusInOut.html
+++ /dev/null
@@ -1,168 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var bus=new mbedJS.BusInOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],{
42- onNew:function(){
43- log("[PASS]onNew");
44- bus.mode(mbedJS.PinMode.PullDown);
45- },
46- onMode:function()
47- {
48- log("[PASS]onMode");
49- bus.output();
50- },
51- onOutput:function()
52- {
53- log("[PASS]onOutput:");
54- bus.write(1);
55- },
56- onWrite:function()
57- {
58- log("[PASS]onWrite:");
59- bus.input();
60- },
61- onInput:function(){
62- log("[PASS]onInput:");
63- bus.read();
64- },
65- onRead:function(v)
66- {
67- log("[PASS]onRead:"+v);
68- mcu.close();
69- }});
70- },
71- onClose:function(){
72- log("[PASS]onClose");
73- },
74- onError:function(){
75- alert("Error");
76- }
77- });
78-}
79-
80-function async2()
81-{
82- log();
83- log("ASYNC2");
84- var mcu=new mbedJS.Mcu("192.168.128.39",
85- {
86- onNew:function(){
87- var bus=new mbedJS.BusInOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],function(){
88- log("[PASS]onNew");
89- bus.mode(mbedJS.PinMode.PullDown,function()
90- {
91- log("[PASS]onMode");
92- bus.output(function()
93- {
94- log("[PASS]onOutput:");
95- bus.write(1,function()
96- {
97- log("[PASS]onWrite:");
98- bus.input(function(){
99- log("[PASS]onInput:");
100- bus.read(function(v)
101- {
102- log("[PASS]onRead:"+v);
103- mcu.close();
104- });
105- });
106- });
107- });
108- });
109- });
110- },
111- onClose:function(){
112- log("[PASS]onClose");
113- },
114- onError:function(){
115- alert("Error");
116- }
117- });
118-}
119-
120-
121-
122-/**
123- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
124- */
125-function sync()
126-{
127- log();
128- var g=function*(){
129- try{
130- var mcu=new mbedJS.Mcu("192.168.128.39",g);
131- yield mcu.waitForNew();
132- var bus=new mbedJS.BusInOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],g);
133- yield bus.waitForNew();
134- yield bus.mode(mbedJS.PinMode.PullDown);
135- log("[PASS]mode");
136- yield bus.output();
137- log("[PASS]output:");
138- yield bus.write(1);
139- log("[PASS]write:");
140- yield bus.input();
141- log("[PASS]input:");
142- var v=yield bus.read();
143- log("[PASS]read:"+v);
144- yield mcu.close();
145- log("close");
146- }catch(e){
147- mcu.shutdown();
148- alert(e);
149- throw e;
150- }
151- }();
152- g.next();
153- return;
154-
155-}
156-
157-
158-
159-</script>
160-</head>
161-<body>
162-<h1>BusInOut test</h1>
163-<hr/>
164-<button onclick="async();">ASYNC</button>
165-<button onclick="async2();">ASYNC2</button>
166-<button onclick="sync();">SYNC</button>
167-<textarea id="console" rows="15" cols="80"></textarea>
168-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.BusOut.html
+++ /dev/null
@@ -1,134 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var bus=new mbedJS.BusOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],{
42- onNew:function(){
43- log("[PASS]onNew");
44- bus.write(2);
45- },
46- onWrite:function()
47- {
48- log("[PASS]onWrite:");
49- bus.read();
50- },
51- onRead:function(v){
52- log("[PASS]onRead:"+v);
53- mcu.close();
54- },
55- });
56- },
57- onClose:function(){
58- log("[PASS]onClose");
59- },
60- onError:function(){
61- alert("Error");
62- }
63- });
64-}
65-
66-function async2()
67-{
68- log();
69- log("ASYNC2");
70- var mcu=new mbedJS.Mcu("192.168.128.39",
71- {
72- onNew:function(){
73- var bus=new mbedJS.BusOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],function(){
74- log("[PASS]onNew");
75- bus.write(2,function()
76- {
77- log("[PASS]onWrite:");
78- bus.read(function(v){
79- log("[PASS]onRead:"+v);
80- mcu.close();
81- });
82- });
83- });
84- },
85- onClose:function(){
86- log("[PASS]onClose");
87- },
88- onError:function(){
89- alert("Error");
90- }
91- });
92-}
93-
94-/**
95- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
96- */
97-function sync()
98-{
99- log();
100- var g=function*(){
101- try{
102- var mcu=new mbedJS.Mcu("192.168.128.39",g);
103- yield mcu.waitForNew();
104- var bus=new mbedJS.BusOut(mcu,[mbedJS.PinName.P0_21,mbedJS.PinName.P0_22],g);
105- yield bus.waitForNew();
106- yield bus.write(1);
107- log("[PASS]write:");
108- var v=yield bus.read();
109- log("[PASS]read:"+v);
110- yield mcu.close();
111- log("close");
112- }catch(e){
113- mcu.shutdown();
114- alert(e);
115- throw e;
116- }
117- }();
118- g.next();
119- return;
120-
121-}
122-
123-
124-
125-</script>
126-</head>
127-<body>
128-<h1>BusOut test</h1>
129-<hr/>
130-<button onclick="async();">ASYNC</button>
131-<button onclick="async2();">ASYNC2</button>
132-<button onclick="sync();">SYNC</button>
133-<textarea id="console" rows="15" cols="80"></textarea>
134-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.DigitalIn.html
+++ /dev/null
@@ -1,134 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.mode(mbedJS.PinMode.PullUp);
45- },
46- onMode:function()
47- {
48- log("[PASS]onMode:");
49- pin.read();
50- },
51- onRead:function(v){
52- log("[PASS]onRead:"+v);
53- mcu.close();
54- }});
55- },
56- onClose:function(){
57- log("[PASS]onClose");
58- },
59- onError:function(){
60- alert("Error");
61- }
62- });
63-}
64-
65-function async2()
66-{
67- log();
68- log("ASYNC2");
69- var mcu=new mbedJS.Mcu("192.168.128.39",
70- {
71- onNew:function(){
72- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,function(){
73- log("[PASS]onNew");
74- pin.mode(mbedJS.PinMode.PullUp,function()
75- {
76- log("[PASS]onMode:");
77- pin.read(function(v){
78- log("[PASS]onRead:"+v);
79- mcu.close();
80- });
81- });
82- });
83- },
84- onClose:function(){
85- log("[PASS]onClose");
86- },
87- onError:function(){
88- alert("Error");
89- }
90- });
91-}
92-/**
93- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
94- */
95-function sync()
96-{
97- log();
98- var g=function*(){
99- try{
100- var mcu=new mbedJS.Mcu("192.168.128.39",g);
101- yield mcu.waitForNew();
102- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,g);
103- log(1);
104- yield pin.waitForNew();
105- log(2);
106- var v=yield pin.read();
107- log(3);
108- yield pin.mode(mbedJS.PinMode.PullDown);
109- log(4);
110- yield mcu.close();
111- log(5);
112- }catch(e){
113- mcu.shutdown();
114- alert(e);
115- throw e;
116- }
117- }();
118- g.next();
119- return;
120-
121-}
122-
123-
124-
125-</script>
126-</head>
127-<body>
128-<h1>DigitalIn test</h1>
129-<hr/>
130-<button onclick="async();">ASYNC</button>
131-<button onclick="async2();">ASYNC2</button>
132-<button onclick="sync();">SYNC</button>
133-<textarea id="console" rows="15" cols="80"></textarea>
134-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.DigitalOut.html
+++ /dev/null
@@ -1,126 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript">
10-
11-
12-
13-function log(v)
14-{
15- if(v===undefined){
16- document.getElementById("console").value='';
17- }else{
18- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
19- }
20-}
21-
22-/**ASYNCAPIのテスト*/
23-function async()
24-{
25- log();
26- log("ASYNC");
27- var mcu=new mbedJS.Mcu("192.168.128.39",
28- {
29- onNew:function(){
30- var pin=new mbedJS.DigitalOut(mcu,mbedJS.PinName.P0_22,{
31- onNew:function(){
32- log("[PASS]onNew");
33- pin.read();
34- },
35- onWrite:function(){
36- log("[PASS]onWrite");
37- mcu.close();
38- },
39- onRead:function(v){
40- log("[PASS]onRead ");
41- pin.write((v+1)%2);
42- }});
43- },
44- onClose:function(){
45- log("[PASS]onClose");
46- },
47- onError:function(){
48- alert("Error");
49- }
50- });
51-}
52-function async2()
53-{
54- log();
55- log("ASYNC2");
56- var mcu=new mbedJS.Mcu("192.168.128.39",
57- {
58- onNew:function(){
59- var pin=new mbedJS.DigitalOut(mcu,mbedJS.PinName.P0_22,function(){
60- log("[PASS]onNew");
61- pin.read(function(v){
62- log("[PASS]onRead "+v);
63- pin.write((v+1)%2,function(){
64- log("[PASS]onWrite");
65- mcu.close();
66- });
67- });
68- });
69- },
70- onClose:function(){
71- log("[PASS]onClose");
72- },
73- onError:function(){
74- alert("Error");
75- }
76- });
77-}
78-
79-/**
80- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
81- */
82-function sync()
83-{
84- log();
85- var g=function*(){
86- try{
87- var mcu=new mbedJS.Mcu("192.168.128.39",g);
88- yield mcu.waitForNew();
89- var pin=new mbedJS.DigitalOut(mcu,{pin:mbedJS.PinName.P0_22,value:0},g);
90-// var pin=new mbedJS.DigitalOut(mcu,[mbedJS.PinName.P0_22,0],g);
91- log(1);
92- yield pin.waitForNew();
93- log(2);
94- var v=yield pin.read();
95- log(3);
96- yield pin.write((v+1)%2);
97- log(4);
98- v=yield pin.read();
99- log(5);
100- yield pin.write((v+1)%2);
101- log(6);
102- yield mcu.close();
103- log(7);
104- }catch(e){
105- mcu.shutdown();
106- throw e;
107- }
108- }();
109- g.next();
110- return;
111-
112-}
113-
114-
115-
116-</script>
117-</head>
118-<body>
119-<h1>Digitalout test</h1>
120-<hr/>
121-<button onclick="async();">ASYNC</button>
122-<button onclick="async2();">ASYNC2</button>
123-<button onclick="sync();">SYNC</button>
124-<button onclick="sync2();">SYNC2</button>
125-<textarea id="console" rows="15" cols="80"></textarea>
126-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.I2C.html
+++ /dev/null
@@ -1,188 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript" src="mbedJS/mbed.Serial.js"></script>
21-<script type="text/javascript" src="mbedJS/mbed.I2C.js"></script>
22-<script type="text/javascript">
23-
24-
25-function log(v)
26-{
27- if(v===undefined){
28- document.getElementById("console").value='';
29- }else{
30- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
31- }
32-}
33-
34-/**ASYNCAPIのテスト*/
35-function async()
36-{
37- log();
38- log("ASYNC");
39- var st=0;
40- var mcu=new mbedJS.Mcu("192.168.128.39",
41- {
42- onNew:function(){
43- var i2c=new mbedJS.I2C(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],{
44- onNew:function(){
45- log("[PASS]onNew");
46- i2c.frequency(100000);
47- },
48- onFrequency:function()
49- {
50- log("[PASS]onFrequency:");
51- i2c.start();
52- },
53- onStart:function(){
54- log("[PASS]onStart:");
55- st=0;
56- i2c.write(1);
57-// i2c.write(1);
58- },
59- onWrite:function(v){
60- log("[PASS]onWrite:"+v);
61- if(st==0){
62- i2c.write(0,[1,2,3],false);
63- st++;
64- }else{
65- i2c.read(1);
66- st=0;
67- }
68- },
69- onRead:function(v){
70- if(st==0){
71- log("[PASS]onRead:"+v);
72- i2c.read(1,2,false);
73- st++;
74- }else{
75- log("[PASS]onRead:"+v.ret+":"+v.data);
76- i2c.stop();
77- }
78-
79- },
80- onStop:function(){
81- log("[PASS]onStop:");
82- mcu.close();
83- }
84- });
85- },
86- onClose:function(){
87- log("[PASS]onClose");
88- },
89- onError:function(){
90- alert("Error");
91- }
92- });
93-}
94-function async2()
95-{
96- log();
97- log("ASYNC2");
98- var st=0;
99- var mcu=new mbedJS.Mcu("192.168.128.39",
100- {
101- onNew:function(){
102- var i2c=new mbedJS.I2C(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],function(){
103- log("[PASS]onNew");
104- i2c.frequency(100000,function()
105- {
106- log("[PASS]onFrequency:");
107- i2c.start(function(){
108- log("[PASS]onStart:");
109- i2c.write(1,function(v){
110- log("[PASS]onWrite:"+v);
111- i2c.write(0,[1,2,3],false,function(v){
112- log("[PASS]onWrite:"+v);
113- i2c.read(1,function(v){
114- log("[PASS]onRead:"+v);
115- i2c.read(1,2,false,function(v){
116- log("[PASS]onRead:"+v.ret+":"+v.data);
117- i2c.stop(function(){
118- log("[PASS]onStop:");
119- mcu.close();
120- });
121- });
122- });
123- });
124- });
125- });
126- });
127- });
128- },
129- onClose:function(){
130- log("[PASS]onClose");
131- },
132- onError:function(){
133- alert("Error");
134- }
135- });
136-}
137-/**
138- *
139- */
140-function sync()
141-{
142- log();
143- var g=function*(){
144- try{
145- var v;
146- var mcu=new mbedJS.Mcu("192.168.128.39",g);
147- yield mcu.waitForNew();
148- var i2c=new mbedJS.I2C(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],g);
149- yield i2c.waitForNew();
150- log("[PASS]onNew");
151- yield i2c.frequency(100000);
152- log("[PASS]onFrequency:");
153- yield i2c.start();
154- log("[PASS]onStart:");
155- v=yield i2c.write(1);
156- log("[PASS]onWrite:"+v);
157- v=yield i2c.write(0,[1,2,3],false);
158- log("[PASS]onWrite2:"+v);
159- v=yield i2c.read(1);
160- log("[PASS]onRead:"+v);
161- v=yield i2c.read(1,2,false);
162- log("[PASS]onRead:"+v.ret+":"+v.data);
163- yield i2c.stop();
164- log("[PASS]onStop:");
165- yield mcu.close();
166- }catch(e){
167- mcu.shutdown();
168- alert(e);
169- throw e;
170- }
171- }();
172- g.next();
173- return;
174-
175-}
176-
177-
178-
179-</script>
180-</head>
181-<body>
182-<h1>I2C test</h1>
183-<hr/>
184-<button onclick="async();">ASYNC</button>
185-<button onclick="async2();">ASYNC2</button>
186-<button onclick="sync();">SYNC</button>
187-<textarea id="console" rows="15" cols="80"></textarea>
188-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.I2CSlave.html
+++ /dev/null
@@ -1,201 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript" src="mbedJS/mbed.Serial.js"></script>
21-<script type="text/javascript" src="mbedJS/mbed.I2C.js"></script>
22-<script type="text/javascript" src="mbedJS/mbed.I2CSlave.js"></script>
23-<script type="text/javascript">
24-
25-
26-function log(v)
27-{
28- if(v===undefined){
29- document.getElementById("console").value='';
30- }else{
31- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
32- }
33-}
34-
35-/**ASYNCAPIのテスト*/
36-function async()
37-{
38- log();
39- log("ASYNC");
40- var st=0;
41- var mcu=new mbedJS.Mcu("192.168.128.39",
42- {
43- onNew:function(){
44- var i2c=new mbedJS.I2CSlave(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],{
45- onNew:function(){
46- log("[PASS]onNew");
47- i2c.frequency(100000);
48- },
49- onFrequency:function()
50- {
51- log("[PASS]onFrequency:");
52- i2c.address(1);
53- },
54- onAddress:function()
55- {
56- log("[PASS]onAddress:");
57- i2c.receive();
58- },
59- onReceive:function(){
60- log("[PASS]onReceive:");
61- st=0;
62- i2c.write(1);
63-// i2c.write(1);
64- },
65- onWrite:function(v){
66- log("[PASS]onWrite:"+v);
67- if(st==0){
68- i2c.write([1,2,3]);
69- st++;
70- }else{
71- i2c.read();
72- st=0;
73- }
74- },
75- onRead:function(v){
76- if(st==0){
77- log("[PASS]onRead:"+v);
78- i2c.read(2,false);
79- st++;
80- }else{
81- log("[PASS]onRead:"+v.ret+":"+v.data);
82- i2c.stop();
83- }
84-
85- },
86- onStop:function(){
87- log("[PASS]onStop:");
88- mcu.close();
89- }
90- });
91- },
92- onClose:function(){
93- log("[PASS]onClose");
94- },
95- onError:function(){
96- alert("Error");
97- }
98- });
99-}
100-function async()
101-{
102- log();
103- log("ASYNC");
104- var st=0;
105- var mcu=new mbedJS.Mcu("192.168.128.39",
106- {
107- onNew:function(){
108- var i2c=new mbedJS.I2CSlave(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],function(){
109- log("[PASS]onNew");
110- i2c.frequency(100000,function()
111- {
112- log("[PASS]onFrequency:");
113- i2c.address(1,function()
114- {
115- log("[PASS]onAddress:");
116- i2c.receive(function(){
117- log("[PASS]onReceive:");
118- i2c.write(1,function(v){
119- log("[PASS]onWrite:"+v);
120- i2c.write([1,2,3],function(v){
121- log("[PASS]onWrite:"+v);
122- i2c.read(function(v){
123- log("[PASS]onRead:"+v);
124- i2c.read(2,false,function(v){
125- log("[PASS]onRead:"+v.ret+":"+v.data);
126- i2c.stop(function(){
127- log("[PASS]onStop:");
128- mcu.close();
129- });
130- });
131- });
132- });
133- });
134- });
135- });
136- });
137- });
138- },
139- onClose:function(){
140- log("[PASS]onClose");
141- },
142- onError:function(){
143- alert("Error");
144- }
145- });
146-}
147-
148-/**
149- *
150- */
151-function sync()
152-{
153- log();
154- alert(mbedJS.I2CSlave.RxStatus.NoData);
155- var g=function*(){
156- try{
157- var v;
158- var mcu=new mbedJS.Mcu("192.168.128.39",g);
159- yield mcu.waitForNew();
160- var i2c=new mbedJS.I2CSlave(mcu,[mbedJS.PinName.p28,mbedJS.PinName.p27],g);
161- yield i2c.waitForNew();
162- yield i2c.frequency(100000);
163- log("[PASS]onFrequency:");
164- yield i2c.address(1);
165- log("[PASS]onAddress:");
166- v=yield i2c.receive();
167- log("[PASS]onReceive:"+v);
168- v=yield i2c.write(1);
169- log("[PASS]onWrite:"+v);
170- v=yield i2c.write([1,2,3]);
171- log("[PASS]onWrite:"+v);
172- v=yield i2c.read();
173- log("[PASS]onRead:"+v);
174- v=yield i2c.read(2,false);
175- log("[PASS]onRead:"+v.ret+":"+v.data);
176- yield i2c.stop();
177- yield mcu.close();
178- log("[PASS]onstop");
179- }catch(e){
180- mcu.shutdown();
181- alert(e);
182- throw e;
183- }
184- }();
185- g.next();
186- return;
187-
188-}
189-
190-
191-
192-</script>
193-</head>
194-<body>
195-<h1>I2CSlave test</h1>
196-<hr/>
197-<button onclick="async();">ASYNC2</button>
198-<button onclick="async();">ASYNC</button>
199-<button onclick="sync();">SYNC</button>
200-<textarea id="console" rows="15" cols="80"></textarea>
201-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.MCU.html
+++ /dev/null
@@ -1,218 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
6-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
9-<script type="text/javascript">
10-
11-
12-
13-function log(v)
14-{
15- if(v===undefined){
16- document.getElementById("console").value='';
17- }else{
18- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
19- }
20-}
21-
22-/**ASYNCAPIのテスト*/
23-function async()
24-{
25- log();
26- log("ASYNC");
27- var mcu=new mbedJS.Mcu("192.168.128.39",
28- {
29- onNew:function(){
30- log("[PASS]onNew");
31- mcu.getInfo();
32- },
33- onGetInfo:function(v){
34- log("[PASS]onGetInfo:"+v.version+","+v.platform+","+v.mcu.name+","+v.mcu.eth+","+v.memory.free);
35- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,{
36- onNew:function(){
37- log("...");
38- mcu.disposeObject(pin._oid);
39- }});
40- },
41- onDisposeObject:function(v){
42- log("[PASS]onDisposeObject:"+v);
43- mcu.close();
44- },
45- onClose:function(){
46- log("[PASS]onClose");
47- },
48- onError:function(){
49- alert("Error");
50- }
51- });
52-}
53-function async2()
54-{
55- log();
56- log("ASYNC2");
57- var mcu=new mbedJS.Mcu("192.168.128.39",
58- {
59- onNew:function(){
60- log("[PASS]onNew");
61- mcu.getInfo(function(v){
62- log("[PASS]onGetInfo:"+v.version+","+v.platform+","+v.mcu.name+","+v.mcu.eth+","+v.memory.free);
63- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,function(){
64- log("...");
65- mcu.disposeObject(pin._oid,function(v){
66- log("[PASS]onDisposeObject:"+v);
67- mcu.close();
68- });
69- });
70- });
71- },
72- onClose:function(){
73- log("[PASS]onClose");
74- },
75- onError:function(){
76- alert("Error");
77- }
78- });
79-}
80-function dispose1()
81-{
82- log();
83- log("d1");
84- var mcu=new mbedJS.Mcu("192.168.128.39",
85- {
86- onNew:function(){
87- log("[PASS]onNew");
88- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,function(){
89- pin.dispose(function(v){
90- log("[PASS]onDispose:"+v);
91- mcu.close();
92- });
93- });
94- },
95- onClose:function(){
96- log("[PASS]onClose");
97- },
98- onError:function(){
99- alert("Error");
100- }
101- });
102-}
103-function dispose2()
104-{
105- log();
106- log("d1");
107- var mcu=new mbedJS.Mcu("192.168.128.39",
108- {
109- onNew:function(){
110- log("[PASS]onNew");
111- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,{
112- onNew:function(){
113- log("[PASS]onNew:");
114- pin.dispose();
115- },
116- onDispose:function(v){
117- log("[PASS]onDispose:"+v);
118- mcu.close();
119- }
120- });
121- },
122- onClose:function(){
123- log("[PASS]onClose");
124- },
125- onError:function(){
126- alert("Error");
127- }
128- });
129-}
130-function dispose3()
131-{
132- log();
133- log("d3");
134- var mcu=new mbedJS.Mcu("192.168.128.39",
135- {
136- onNew:function(){
137- log("[PASS]onNew");
138- var pin=new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,{
139- onNew:function(){
140- log("[PASS]onNew:");
141- pin.dispose();
142- mcu.close();
143- }
144- });
145- },
146- onClose:function(){
147- log("[PASS]onClose");
148- },
149- onError:function(){
150- alert("Error");
151- }
152- });
153-}
154-function dispose4()
155-{
156- var g=function*(){
157- try{
158- log();
159- var mcu=new mbedJS.Mcu("192.168.128.39",g);
160- log(2);
161- var v;
162- yield mcu.waitForNew();
163- var pin= new mbedJS.DigitalIn(mcu,mbedJS.PinName.P0_22,g);
164- yield pin.waitForNew();
165- v=yield pin.dispose();
166- log("[PASS]dispose:"+v);
167- yield mcu.close();
168- log("[PASS]close");
169- }catch(e){
170- alert(e);
171- mcu.shutdown();
172- }
173- }();
174- g.next();
175-}
176-/**
177- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
178- */
179-function sync()
180-{
181- var g=function*(){
182-try{
183-log();
184- var mcu=new mbedJS.Mcu("192.168.128.39",g);
185-log(2);
186-var v;
187- yield mcu.waitForNew();
188- v=yield mcu.disposeObject(0);
189- log(v);
190- v=yield mcu.getInfo();
191- log("[PASS]onGetInfo:"+v.version+","+v.platform+","+v.mcu.name+","+v.mcu.eth+","+v.memory.free);
192- yield mcu.close();
193-log(3);
194-}catch(e){
195- alert(e);
196- mcu.shutdown();
197-}
198- }();
199- g.next();
200- return;
201-
202-}
203-
204-
205-</script>
206-</head>
207-<body>
208-<h1>MCU test</h1>
209-<hr/>
210-<button onclick="async();">ASYNC</button>
211-<button onclick="async2();">ASYNC2</button>
212-<button onclick="sync();">SYNC</button>
213-<button onclick="dispose1();">D1</button>
214-<button onclick="dispose2();">D2</button>
215-<button onclick="dispose3();">D3</button>
216-<button onclick="dispose4();">D4</button>
217-<textarea id="console" rows="15" cols="80"></textarea>
218-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.Memory.html
+++ /dev/null
@@ -1,220 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.Memory.js"></script>
9-
10-<script type="text/javascript">
11-
12-
13-
14-function log(v)
15-{
16- if(v===undefined){
17- document.getElementById("console").value='';
18- }else{
19- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
20- }
21-}
22-
23-/**ASYNCAPIのテスト*/
24-function async()
25-{
26- var s=0;
27- log();
28- log("ASYNC");
29- var mcu=new mbedJS.Mcu("192.168.128.39",
30- {
31- onNew:function(){
32- var mem=new mbedJS.Memory(mcu,{
33- onNew:function(){
34- s=0;
35- mem.write(0x20080000,1);
36- },
37- onWrite:function(){
38- log("[PASS]onWrite:"+s);
39- switch(s){
40- case 0:
41- mem.read(0x20080000,1);
42- break;
43- case 1:
44- mem.read(0x20080001,1);
45- break;
46- case 2:
47- mem.read(0x20080000,8);
48- break;
49- }
50- },
51- onRead:function(v){
52- log("[PASS]onRead:"+s);
53- switch(s){
54- case 0:
55- mem.write(0x20080001,[2]);
56- break;
57- case 1:
58- mem.write(0x20080004,[10,20,30]);
59- break;
60- case 2:
61- mem.write32(0x20080000,0xff);
62- s=-1;
63- }
64- s++;
65- },
66- onWrite32:function(){
67- log("[PASS]onWrite32:"+s);
68- switch(s){
69- case 0:
70- mem.read32(0x20080000);
71- break;
72- case 1:
73- mem.read32(0x20080004,4);
74- break;
75- case 2:
76- mem.read32(0x20080000,16);
77- break;
78- }
79- },
80- onRead32:function(v){
81- log("[PASS]onRead32:"+s);
82- switch(s){
83- case 0:
84- mem.write32(0x20080004,[2]);
85- break;
86- case 1:
87- mem.write32(0x20080004,[10,20,30]);
88- break;
89- case 2:
90- mcu.close();
91- }
92- s++;
93- }
94-
95-
96-
97- });
98- },
99- onClose:function(){
100- log("[PASS]onClose");
101- },
102- onError:function(){
103- alert("Error");
104- }
105- });
106-}
107-
108-function async2()
109-{
110- var s=0;
111- log();
112- log("ASYNC");
113- var mcu=new mbedJS.Mcu("192.168.128.39",
114- {
115- onNew:function(){
116- var mem=new mbedJS.Memory(mcu,function(){
117- mem.write(0x20080000,1,function(){
118- log("[PASS]onWrite:");
119- mem.read(0x20080000,1,function(v){
120- log("[PASS]onRead:"+v);
121- mem.read(0x20080001,1,function(v){
122- log("[PASS]onRead:"+v);
123- mem.read(0x20080000,8,function(v){
124- log("[PASS]onRead:"+v);
125- mem.write(0x20080001,[2],function(){
126- log("[PASS]onWrite:");
127- mem.write(0x20080004,[10,20,30],function(){
128- log("[PASS]onWrite:");
129- mem.write32(0x20080000,0xff,function(){
130- log("[PASS]onWrite32:");
131- mem.read32(0x20080000,function(v){
132- log("[PASS]onRead32:"+v);
133- mem.read32(0x20080004,4,function(v){
134- log("[PASS]onRead32:"+v);
135- mem.read32(0x20080000,16,function(v){
136- log("[PASS]onRead32:"+v);
137- mem.write32(0x20080004,[2],function(){
138- log("[PASS]onWrite32:"+s);
139- mem.write32(0x20080004,[10,20,30],function(){
140- mcu.close();
141- });
142- });
143- });
144- });
145- });
146- });
147- });
148- });
149- });
150- });
151- });
152- });
153- });
154- },
155- onClose:function(){
156- log("[PASS]onClose");
157- },
158- onError:function(){
159- alert("Error");
160- }
161- });
162-}
163-function sync()
164-{
165- log();
166- var g=function*(){
167- try{
168- var v;
169- var mcu=new mbedJS.Mcu("192.168.128.39",g);
170- yield mcu.waitForNew();
171- var mem=new mbedJS.Memory(mcu,g);
172- yield mem.waitForNew();
173- yield mem.write(0x20080000,1);
174- log("[PASS]onWrite:");
175- v=yield mem.read(0x20080000,1);
176- log("[PASS]onRead:"+v);
177- v=yield mem.read(0x20080001,1);
178- log("[PASS]onRead:"+v);
179- v=yield mem.read(0x20080000,8);
180- log("[PASS]onRead:"+v);
181- yield mem.write(0x20080001,[2]);
182- log("[PASS]onWrite:");
183- yield mem.write(0x20080004,[10,20,30]);
184- log("[PASS]onWrite:");
185- yield mem.write32(0x20080000,0xff);
186- log("[PASS]onWrite32:");
187- v=yield mem.read32(0x20080000);
188- log("[PASS]onRead32:"+v);
189- v=yield mem.read32(0x20080004,4);
190- log("[PASS]onRead32:"+v);
191- v=yield mem.read32(0x20080000,16);
192- log("[PASS]onRead32:"+v);
193- yield mem.write32(0x20080004,[2]);
194- log("[PASS]onWrite32:");
195- yield mem.write32(0x20080004,[10,20,30]);
196- log("[PASS]onWrite32:");
197- mcu.close();
198-
199- }catch(e){
200- mcu.shutdown();
201- alert(e);
202- throw e;
203- }
204- }();
205- g.next();
206- return;
207-
208-}
209-
210-</script>
211-</head>
212-<body>
213-<h1>Memory test</h1>
214-<hr/>
215-<button onclick="async();">ASYNC</button>
216-<button onclick="async2();">ASYNC2</button>
217-<button onclick="sync();">SYNC</button>
218-<button onclick="sync2();">SYNC2</button>
219-<textarea id="console" rows="15" cols="80"></textarea>
220-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.PortIn.html
+++ /dev/null
@@ -1,124 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.PortIn(mcu,[mbedJS.PortName.Port0,0xffffffff],{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.read();
45- },
46- onRead:function(v)
47- {
48- log("[PASS]read:"+v);
49- mcu.close();
50- }});
51- },
52- onClose:function(){
53- log("[PASS]onClose");
54- },
55- onError:function(){
56- alert("Error");
57- }
58- });
59-}
60-function async2()
61-{
62- log();
63- log("ASYNC2");
64- var mcu=new mbedJS.Mcu("192.168.128.39",
65- {
66- onNew:function(){
67- var pin=new mbedJS.PortIn(mcu,[mbedJS.PortName.Port0,0xffffffff],function(){
68- log("[PASS]onNew");
69- pin.read(function(v){
70- log("[PASS]read:"+v);
71- mcu.close();
72- });
73- });
74- },
75- onClose:function(){
76- log("[PASS]onClose");
77- },
78- onError:function(){
79- alert("Error");
80- }
81- });
82-}
83-/**
84- * Sync
85- */
86-
87-function sync()
88-{
89- log();
90- var g=function*(){
91- try{
92- var mcu=new mbedJS.Mcu("192.168.128.39",g);
93- yield mcu.waitForNew();
94- var port=new mbedJS.PortIn(mcu,[mbedJS.PortName.Port0,0xffffffff],g);
95- log("new");
96- yield port.waitForNew();
97- log("waitfor");
98- var v=yield port.read();
99- log("read:"+v);
100- yield mcu.close();
101- log("close");
102- }catch(e){
103- mcu.shutdown();
104- alert(e);
105- throw e;
106- }
107- }();
108- g.next();
109- return;
110-
111-}
112-
113-
114-
115-</script>
116-</head>
117-<body>
118-<h1>PortIn test</h1>
119-<hr/>
120-<button onclick="async();">ASYNC</button>
121-<button onclick="async2();">ASYNC2</button>
122-<button onclick="sync();">SYNC</button>
123-<textarea id="console" rows="15" cols="80"></textarea>
124-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.PortOut.html
+++ /dev/null
@@ -1,136 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.PortOut(mcu,[mbedJS.PortName.Port0,0xffffffff],{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.write(1234);
45- },
46- onWrite:function()
47- {
48- log("[PASS]write:");
49- pin.read();
50- },
51- onRead:function(v)
52- {
53- log("[PASS]read:"+v);
54- mcu.close();
55- }});
56- },
57- onClose:function(){
58- log("[PASS]onClose");
59- },
60- onError:function(){
61- alert("Error");
62- }
63- });
64-}
65-function async2()
66-{
67- log();
68- log("ASYNC2");
69- var mcu=new mbedJS.Mcu("192.168.128.39",
70- {
71- onNew:function(){
72- var pin=new mbedJS.PortOut(mcu,[mbedJS.PortName.Port0,0xffffffff],function(){
73- log("[PASS]onNew");
74- pin.write(1234,function()
75- {
76- log("[PASS]write:");
77- pin.read(function(v)
78- {
79- log("[PASS]read:"+v);
80- mcu.close();
81- });
82- });
83- });
84- },
85- onClose:function(){
86- log("[PASS]onClose");
87- },
88- onError:function(){
89- alert("Error");
90- }
91- });
92-}
93-/**
94- * Sync
95- */
96-
97-function sync()
98-{
99- log();
100- var g=function*(){
101- try{
102- var mcu=new mbedJS.Mcu("192.168.128.39",g);
103- yield mcu.waitForNew();
104- var port=new mbedJS.PortOut(mcu,{port:mbedJS.PortName.Port0,mask:0xffffffff},g);
105- log("new");
106- yield port.waitForNew();
107- log("waitfor");
108- yield port.write(5678);
109- log("write:");
110- var v=yield port.read();
111- log("read:"+v);
112- yield mcu.close();
113- log("close");
114- }catch(e){
115- mcu.shutdown();
116- alert(e);
117- throw e;
118- }
119- }();
120- g.next();
121- return;
122-
123-}
124-
125-
126-
127-</script>
128-</head>
129-<body>
130-<h1>PortOut test</h1>
131-<hr/>
132-<button onclick="async();">ASYNC</button>
133-<button onclick="async2();">ASYNC2</button>
134-<button onclick="sync();">SYNC</button>
135-<textarea id="console" rows="15" cols="80"></textarea>
136-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.PwmOut.html
+++ /dev/null
@@ -1,188 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.PwmOut(mcu,mbedJS.PinName.p21,{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.write(0.33);
45- },
46- onWrite:function()
47- {
48- log("[PASS]onwrite:");
49- pin.read();
50- },
51- onRead:function(v)
52- {
53- log("[PASS]onread:"+v);
54- pin.period(1.0);
55- },
56- onPeriod:function(){
57- log("[PASS]onPeriod:");
58- pin.period_ms(1);
59- },
60- onPeriod_ms:function(){
61- log("[PASS]onPeriod_ms:");
62- pin.period_us(10);
63- },
64- onPeriod_us:function(){
65- log("[PASS]onPeriod_us:");
66- pin.pulsewidth(3);
67- },
68- onPulsewidth:function(){
69- log("[PASS]onPulseWidth:");
70- pin.pulsewidth_ms(30);
71- },
72- onPulsewidth_ms:function(){
73- log("[PASS]onPulseWidth_ms:");
74- pin.pulsewidth_us(40);
75- },
76- onPulsewidth_us:function(){
77- log("[PASS]onPulseWidth_us:");
78- mcu.close();
79- }
80- });
81- },
82- onClose:function(){
83- log("[PASS]onClose");
84- },
85- onError:function(){
86- alert("Error");
87- }
88- });
89-}
90-function async2()
91-{
92- log();
93- log("ASYNC2");
94- var mcu=new mbedJS.Mcu("192.168.128.39",
95- {
96- onNew:function(){
97- var pin=new mbedJS.PwmOut(mcu,mbedJS.PinName.p21,function(){
98- log("[PASS]onNew");
99- pin.write(0.33,function(){
100- log("[PASS]onwrite:");
101- pin.read(function(v)
102- {
103- log("[PASS]onread:"+v);
104- pin.period(1.0,function(){
105- log("[PASS]onPeriod:");
106- pin.period_ms(1,function(){
107- log("[PASS]onPeriod_ms:");
108- pin.period_us(10,function(){
109- log("[PASS]onPeriod_us:");
110- pin.pulsewidth(3,function(){
111- log("[PASS]onPulseWidth:");
112- pin.pulsewidth_ms(30,function(){
113- log("[PASS]onPulseWidth_ms:");
114- pin.pulsewidth_us(40,function(){
115- log("[PASS]onPulseWidth_us:");
116- mcu.close();
117- });
118- });
119- });
120- });
121- });
122- });
123- });
124- });
125- });
126- },
127- onClose:function(){
128- log("[PASS]onClose");
129- },
130- onError:function(){
131- alert("Error");
132- }
133- });
134-}
135-/**
136- * Sync
137- */
138-function sync()
139-{
140- log();
141- var g=function*(){
142- try{
143- var mcu=new mbedJS.Mcu("192.168.128.39",g);
144- yield mcu.waitForNew();
145- var pin=new mbedJS.PwmOut(mcu,mbedJS.PinName.p21,g);
146- log("new");
147- yield pin.waitForNew();
148- log("waitfor");
149- yield pin.write(0.33);
150- log("[PASS]write:");
151- var v=yield pin.read();
152- log("[PASS]read:"+v);
153- yield pin.period(1.0);
154- log("[PASS]period:");
155- yield pin.period_ms(1);
156- log("[PASS]period_ms:");
157- yield pin.period_us(10);
158- log("[PASS]period_us:");
159- yield pin.pulsewidth(3);
160- log("[PASS]pulseWidth:");
161- yield pin.pulsewidth_ms(30);
162- log("[PASS]pulseWidth_ms:");
163- yield pin.pulsewidth_us(40);
164- log("[PASS]pulseWidth_us:");
165- yield mcu.close();
166- }catch(e){
167- mcu.shutdown();
168- alert(e);
169- throw e;
170- }
171- }();
172- g.next();
173- return;
174-
175-}
176-
177-
178-
179-</script>
180-</head>
181-<body>
182-<h1>Pwm test</h1>
183-<hr/>
184-<button onclick="async();">ASYNC</button>
185-<button onclick="async2();">ASYNC</button>
186-<button onclick="sync();">SYNC</button>
187-<textarea id="console" rows="15" cols="80"></textarea>
188-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.SPI.html
+++ /dev/null
@@ -1,145 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.SPI(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7],{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.frequency(1000000);
45- },
46- onFrequency:function()
47- {
48- log("[PASS]onFrequency:");
49- pin.format(8,3);
50- },
51- onFormat:function()
52- {
53- log("[PASS]onFormat:");
54- pin.write(39);
55- },
56- onWrite:function(v){
57- log("[PASS]onWrite:"+v);
58- mcu.close();
59- }});
60- },
61- onClose:function(){
62- log("[PASS]onClose");
63- },
64- onError:function(){
65- alert("Error");
66- }
67- });
68-}
69-
70-
71-function async2()
72-{
73- log();
74- log("ASYNC2");
75- var mcu=new mbedJS.Mcu("192.168.128.39",
76- {
77- onNew:function(){
78- var pin=new mbedJS.SPI(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7],function(){
79- log("[PASS]onNew");
80- pin.frequency(1000000,function()
81- {
82- log("[PASS]onFrequency:");
83- pin.format(8,3,function()
84- {
85- log("[PASS]onFormat:");
86- pin.write(39,function(v){
87- log("[PASS]onWrite:"+v);
88- mcu.close();
89- });
90- });
91- });
92- });
93- },
94- onClose:function(){
95- log("[PASS]onClose");
96- },
97- onError:function(){
98- alert("Error");
99- }
100- });
101-}
102-/**
103- * 誤った使用方法でExceptionが出た場合にシャットダウンできるかのテスト
104- */
105-function sync()
106-{
107- log();
108- var g=function*(){
109- try{
110- var mcu=new mbedJS.Mcu("192.168.128.39",g);
111- yield mcu.waitForNew();
112- var pin=new mbedJS.SPI(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7],g);
113- yield pin.waitForNew();
114- log("[PASS]New");
115- yield pin.frequency(1000000);
116- log("[PASS]Frequency:");
117- yield pin.format(8,3);
118- log("[PASS]Format:");
119- v=yield pin.write(39);
120- log("[PASS]Write:"+v);
121- yield mcu.close();
122- log("close");
123- }catch(e){
124- mcu.shutdown();
125- alert(e);
126- throw e;
127- }
128- }();
129- g.next();
130- return;
131-
132-}
133-
134-
135-
136-</script>
137-</head>
138-<body>
139-<h1>SPI test</h1>
140-<hr/>
141-<button onclick="async();">ASYNC</button>
142-<button onclick="async2();">ASYNC2</button>
143-<button onclick="sync();">SYNC</button>
144-<textarea id="console" rows="15" cols="80"></textarea>
145-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.SPISlave.html
+++ /dev/null
@@ -1,168 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript">
21-
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var pin=new mbedJS.SPISlave(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7,mbedJS.PinName.p8],{
42- onNew:function(){
43- log("[PASS]onNew");
44- pin.frequency(1000000);
45- },
46- onFrequency:function()
47- {
48- log("[PASS]onFrequency:");
49- pin.format(8,3);
50- },
51- onFormat:function()
52- {
53- log("[PASS]onFormat:");
54- pin.read();
55- },
56- onRead:function(v){
57- log("[PASS]onread:"+v);
58- pin.receive();
59- },
60- onReceive:function(v)
61- {
62- log("[PASS]onReceive:"+v);
63- pin.reply(1);
64- },
65- onReply:function(){
66- log("[PASS]onReply:");
67- mcu.close();
68- }
69-
70- });
71- },
72- onClose:function(){
73- log("[PASS]onClose");
74- },
75- onError:function(){
76- alert("Error");
77- }
78- });
79-}
80-
81-function async2()
82-{
83- log();
84- log("ASYNC2");
85- var mcu=new mbedJS.Mcu("192.168.128.39",
86- {
87- onNew:function(){
88- var pin=new mbedJS.SPISlave(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7,mbedJS.PinName.p8],function(){
89- log("[PASS]onNew");
90- pin.frequency(1000000,function()
91- {
92- log("[PASS]onFrequency:");
93- pin.format(8,3,function()
94- {
95- log("[PASS]onFormat:");
96- pin.read(function(v){
97- log("[PASS]onread:"+v);
98- pin.receive(function(v)
99- {
100- log("[PASS]onReceive:"+v);
101- pin.reply(1,function(){
102- log("[PASS]onReply:");
103- mcu.close();
104- });
105- });
106- });
107- });
108- });
109- });
110- },
111- onClose:function(){
112- log("[PASS]onClose");
113- },
114- onError:function(){
115- alert("Error");
116- }
117- });
118-}
119-
120-
121-/**
122- *
123- */
124-function sync()
125-{
126- log();
127- var g=function*(){
128- try{
129- var mcu=new mbedJS.Mcu("192.168.128.39",g);
130- yield mcu.waitForNew();
131- var pin=new mbedJS.SPISlave(mcu,[mbedJS.PinName.p5,mbedJS.PinName.p6,mbedJS.PinName.p7,mbedJS.PinName.p8],g);
132- yield pin.waitForNew();
133- log("[PASS]New");
134- yield pin.frequency(1000000);
135- log("[PASS]Frequency:");
136- yield pin.format(8,3);
137- log("[PASS]Format:");
138- var v=yield pin.read();
139- log("[PASS]Read:"+v);
140- v=yield pin.receive();
141- log("[PASS]Receive:"+v);
142- yield pin.reply(1);
143- log("[PASS]Reply:");
144- yield mcu.close();
145- log("close");
146- }catch(e){
147- mcu.shutdown();
148- alert(e);
149- throw e;
150- }
151- }();
152- g.next();
153- return;
154-
155-}
156-
157-
158-
159-</script>
160-</head>
161-<body>
162-<h1>SPISlave test</h1>
163-<hr/>
164-<button onclick="async2();">ASYNC2</button>
165-<button onclick="async();">ASYNC</button>
166-<button onclick="sync();">SYNC</button>
167-<textarea id="console" rows="15" cols="80"></textarea>
168-</body>
\ No newline at end of file
--- a/misc/mbedJS/mbddJS.API/test.Serial.html
+++ /dev/null
@@ -1,200 +0,0 @@
1-
2-<html>
3-<head>
4-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5-<script type="text/javascript" src="mbedJS/mbed.types.js"></script>
6-<script type="text/javascript" src="mbedJS/MiMicCore.js"></script>
7-<script type="text/javascript" src="mbedJS/mbed.Mcu.js"></script>
8-<script type="text/javascript" src="mbedJS/mbed.DigitalOut.js"></script>
9-<script type="text/javascript" src="mbedJS/mbed.DigitalIn.js"></script>
10-<script type="text/javascript" src="mbedJS/mbed.AnalogOut.js"></script>
11-<script type="text/javascript" src="mbedJS/mbed.AnalogIn.js"></script>
12-<script type="text/javascript" src="mbedJS/mbed.BusOut.js"></script>
13-<script type="text/javascript" src="mbedJS/mbed.BusIn.js"></script>
14-<script type="text/javascript" src="mbedJS/mbed.BusInOut.js"></script>
15-<script type="text/javascript" src="mbedJS/mbed.PortOut.js"></script>
16-<script type="text/javascript" src="mbedJS/mbed.Portin.js"></script>
17-<script type="text/javascript" src="mbedJS/mbed.PwmOut.js"></script>
18-<script type="text/javascript" src="mbedJS/mbed.SPI.js"></script>
19-<script type="text/javascript" src="mbedJS/mbed.SPISlave.js"></script>
20-<script type="text/javascript" src="mbedJS/mbed.Serial.js"></script>
21-<script type="text/javascript">
22-
23-
24-function log(v)
25-{
26- if(v===undefined){
27- document.getElementById("console").value='';
28- }else{
29- document.getElementById("console").value+='['+(new Date())+']'+v+'\n';
30- }
31-}
32-
33-/**ASYNCAPIのテスト*/
34-function async()
35-{
36- log();
37- log("ASYNC");
38- var mcu=new mbedJS.Mcu("192.168.128.39",
39- {
40- onNew:function(){
41- var uart=new mbedJS.Serial(mcu,[mbedJS.PinName.p9,mbedJS.PinName.p10],{
42- onNew:function(){
43- log("[PASS]onNew");
44- uart.baud(115200);
45- },
46- onBaud:function()
47- {
48- log("[PASS]onBaud:");
49- uart.send_break();
50- },
51- onSend_break:function(){
52- log("[PASS]onSend_break:");
53- uart.format(8,mbedJS.Serial.Parity.None,1);
54- },
55- onFormat:function(){
56- log("[PASS]onForma:");
57- uart.readable();
58- },
59- onReadable:function(v){
60- log("[PASS]onReadable:"+v);
61- uart.writeable();
62- },
63- onWriteable:function(v){
64- log("[PASS]onWritable:"+v);
65- uart.putc(32);
66- },
67- onPutc:function(v){
68- log("[PASS]onPutc:"+v);
69- uart.getc();
70- },
71- onGetc:function(v){
72- log("[PASS]onGetc:"+v);
73- uart.puts("1234");
74- },
75- onPuts:function(v){
76- log("[PASS]onPuts:"+v);
77- uart.gets(5);
78- },
79- onGets:function(v){
80- log("[PASS]onGets:");
81- mcu.close();
82- }
83-
84-
85- });
86- },
87- onClose:function(){
88- log("[PASS]onClose");
89- },
90- onError:function(){
91- alert("Error");
92- }
93- });
94-}
95-function async2()
96-{
97- log();
98- log("ASYNC2");
99- var mcu=new mbedJS.Mcu("192.168.128.39",
100- {
101- onNew:function(){
102- var uart=new mbedJS.Serial(mcu,[mbedJS.PinName.p9,mbedJS.PinName.p10],
103- function(){
104- log("[PASS]onNew");
105- uart.baud(115200,function()
106- {
107- log("[PASS]onBaud:");
108- uart.send_break(function(){
109- log("[PASS]onSend_break:");
110- uart.format(8,mbedJS.Serial.Parity.None,1,function(){
111- log("[PASS]onForma:");
112- uart.readable(function(v){
113- log("[PASS]onReadable:"+v);
114- uart.writeable(function(v){
115- log("[PASS]onWritable:"+v);
116- uart.putc(32,function(v){
117- log("[PASS]onPutc:"+v);
118- uart.getc(function(v){
119- log("[PASS]onGetc:"+v);
120- uart.puts("1234",function(v){
121- log("[PASS]onPuts:"+v);
122- uart.gets(5,function(v){
123- log("[PASS]onGets:"+v);
124- mcu.close();
125- });
126- });
127- });
128- });
129- });
130- });
131- });
132- });
133- });
134- });
135- },
136- onClose:function(){
137- log("[PASS]onClose");
138- },
139- onError:function(){
140- alert("Error");
141- }
142- });
143-}
144-/**
145- *
146- */
147-function sync()
148-{
149- log();
150- var g=function*(){
151- try{
152- var v;
153- var mcu=new mbedJS.Mcu("192.168.128.39",g);
154- yield mcu.waitForNew();
155- var uart=new mbedJS.Serial(mcu,[mbedJS.PinName.p9,mbedJS.PinName.p10],g);
156- log(1);
157- yield uart.waitForNew();
158- log(2);
159- yield uart.baud(115200);
160- log("[PASS]onBaud:");
161- yield uart.send_break();
162- log("[PASS]onSend_break:");
163- yield uart.format(8,mbedJS.Serial.Parity.None,1);
164- log("[PASS]onForma:");
165- v=yield uart.readable();
166- log("[PASS]onReadable:"+v);
167- v=yield uart.writeable();
168- log("[PASS]onWritable:"+v);
169- v=yield uart.putc(32);
170- log("[PASS]onPutc:"+v);
171- v=yield uart.getc();
172- log("[PASS]onGetc:"+v);
173- v=yield uart.puts("1234");
174- log("[PASS]onPuts:"+v);
175- v=yield uart.gets(5);
176- log("[PASS]onGets:"+v);
177- yield mcu.close();
178- log(5);
179- }catch(e){
180- mcu.shutdown();
181- alert(e);
182- throw e;
183- }
184- }();
185- g.next();
186- return;
187-
188-}
189-
190-
191-</script>
192-</head>
193-<body>
194-<h1>Serial test</h1>
195-<hr/>
196-<button onclick="async2();">ASYNC2</button>
197-<button onclick="async();">ASYNC</button>
198-<button onclick="sync();">SYNC</button>
199-<textarea id="console" rows="15" cols="80"></textarea>
200-</body>
\ No newline at end of file
Show on old repository browser