初始化提交
This commit is contained in:
王立帮
478
boards/default_src/micropython/converters/actuator.js
Normal file
478
boards/default_src/micropython/converters/actuator.js
Normal file
@@ -0,0 +1,478 @@
|
||||
|
||||
'use strict';
|
||||
|
||||
pbc.moduleFunctionD.get('servo')['servo_write_angle'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pwmAstName = args[0]._astname;
|
||||
pbc.pinType="pins_pwm_pin";
|
||||
var pinblock;
|
||||
|
||||
if (pwmAstName === "Num") {
|
||||
pinblock=py2block.convert(args[0])
|
||||
}
|
||||
pbc.pinType=null;
|
||||
var angleblock=py2block.convert(args[1]);
|
||||
|
||||
return [block("servo_move", func.lineno, {}, {
|
||||
"PIN":pinblock,
|
||||
"DEGREE": angleblock,
|
||||
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.led1')['setonoff'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="number";
|
||||
var ledblock = {
|
||||
_astname: "Num",
|
||||
n: {
|
||||
'v': "1"
|
||||
}
|
||||
}
|
||||
var mode = py2block.convert(ledblock);
|
||||
pbc.pinType=null;
|
||||
pbc.inScope="ledswitch";
|
||||
var argblock = py2block.convert(args[0]);
|
||||
|
||||
pbc.inScope=null;
|
||||
return [block("actuator_led_bright", func.lineno, {
|
||||
|
||||
}, {
|
||||
'led': mode,
|
||||
'bright':argblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
}),
|
||||
];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.led2')['setonoff'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="number";
|
||||
var ledblock = {
|
||||
_astname: "Num",
|
||||
n: {
|
||||
'v': "2"
|
||||
}
|
||||
}
|
||||
var mode = py2block.convert(ledblock);
|
||||
pbc.pinType=null;
|
||||
pbc.inScope="ledswitch";
|
||||
var argblock = py2block.convert(args[0]);
|
||||
|
||||
pbc.inScope=null;
|
||||
return [block("actuator_led_bright", func.lineno, {
|
||||
|
||||
}, {
|
||||
'led': mode,
|
||||
'bright':argblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
}),
|
||||
];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.led1')['getonoff'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="number";
|
||||
var ledblock = {
|
||||
_astname: "Num",
|
||||
n: {
|
||||
'v': "1"
|
||||
}
|
||||
}
|
||||
var mode = py2block.convert(ledblock);
|
||||
pbc.pinType=null;
|
||||
return block("actuator_get_led_bright", func.lineno, {
|
||||
}, {
|
||||
'led': mode,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.led2')['getonoff'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="number";
|
||||
var ledblock = {
|
||||
_astname: "Num",
|
||||
n: {
|
||||
'v': "2"
|
||||
}
|
||||
}
|
||||
var mode = py2block.convert(ledblock);
|
||||
pbc.pinType=null;
|
||||
return block("actuator_get_led_bright", func.lineno, {
|
||||
}, {
|
||||
'led': mode,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.led1')['setbrightness'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="number";
|
||||
var ledblock = {
|
||||
_astname: "Num",
|
||||
n: {
|
||||
'v': "1"
|
||||
}
|
||||
}
|
||||
var mode = py2block.convert(ledblock);
|
||||
pbc.pinType=null;
|
||||
var brightblock = py2block.convert(args[0]);
|
||||
|
||||
return [block("actuator_led_brightness", func.lineno, {}, {
|
||||
'led': mode,
|
||||
'bright':brightblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
}),
|
||||
];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.led2')['setbrightness'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="number";
|
||||
var ledblock = {
|
||||
_astname: "Num",
|
||||
n: {
|
||||
'v': "2"
|
||||
}
|
||||
}
|
||||
var mode = py2block.convert(ledblock);
|
||||
pbc.pinType=null;
|
||||
var brightblock = py2block.convert(args[0]);
|
||||
|
||||
return [block("actuator_led_brightness", func.lineno, {}, {
|
||||
'led': mode,
|
||||
'bright':brightblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
}),
|
||||
];
|
||||
}
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('music')['pitch'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!==1 && args.length!==2){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
if (args.length === 2) {
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType=null;
|
||||
pbc.pinType = "pins_tone_notes";
|
||||
var pitchblock = py2block.convert(args[1]);
|
||||
pbc.pinType=null;
|
||||
|
||||
|
||||
return [block("esp32_music_pitch", func.lineno, {}, {
|
||||
'pitch': pitchblock,
|
||||
'PIN': pinblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else if (args.length=== 1){
|
||||
pbc.pinType = "pins_tone_notes";
|
||||
var pitchblock = py2block.convert(args[0]);
|
||||
pbc.pinType=null;
|
||||
return [block("esp32_onboard_music_pitch", func.lineno, {}, {
|
||||
'pitch': pitchblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('music')['pitch_time'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!==2 && args.length!==3){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
if (args.length === 2) {
|
||||
pbc.pinType = "pins_tone_notes";
|
||||
var pitchblock = py2block.convert(args[0]);
|
||||
pbc.pinType=null;
|
||||
var timeblock=py2block.convert(args[1]);
|
||||
return [block("esp32_onboard_music_pitch_with_time", func.lineno, {}, {
|
||||
'pitch': pitchblock,
|
||||
"time":timeblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else if (args.length=== 3){
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType=null;
|
||||
pbc.pinType = "pins_tone_notes";
|
||||
var pitchblock = py2block.convert(args[1]);
|
||||
pbc.pinType=null;
|
||||
var timeblock=py2block.convert(args[2]);
|
||||
return [block("esp32_music_pitch_with_time", func.lineno, {}, {
|
||||
'pitch': pitchblock,
|
||||
'PIN': pinblock,
|
||||
"time":timeblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('music')['stop'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1 && args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
if (args.length == 1){
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var argblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
return [block("esp32_music_stop", func.lineno, {}, {
|
||||
'PIN': argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
if (args.length == 0){
|
||||
return [block("esp32_onboard_music_stop", func.lineno, {}, {}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('music')['play'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2 && args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
if(args.length == 2){
|
||||
pbc.pinType = "pins_playlist_pin";
|
||||
var nameblock= py2block.convert(args[0]);
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var argblock = py2block.convert(args[1]);
|
||||
pbc.pinType = null;
|
||||
return [block("esp32_music_play_list", func.lineno, {}, {
|
||||
"LIST":nameblock,
|
||||
'PIN': argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
if(args.length == 1){
|
||||
pbc.pinType = "pins_playlist_pin";
|
||||
var nameblock= py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
return [block("esp32_onboard_music_play_list", func.lineno, {}, {
|
||||
"LIST":nameblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('music')['play_show'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType = "pins_playlist_pin";
|
||||
var nameblock= py2block.convert(args[0]);
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var argblock = py2block.convert(args[1]);
|
||||
pbc.pinType = null;
|
||||
return [block("esp32_mixgo_music_play_list_show", func.lineno, {}, {
|
||||
"LIST":nameblock,
|
||||
'PIN': argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
pbc.assignD.get('Rgb')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
var moduleName=py2block.identifier(value.func.value.id);
|
||||
if(value._astname === "Call" && moduleName === "neopixel"
|
||||
&& funcName === "NeoPixel" && value.args.length === 2&&value.keywords.length===1)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
pbc.assignD.get('Rgb')['create_block'] = function(py2block, node, targets, value){
|
||||
|
||||
var rgbblock=py2block.convert(targets[0]);
|
||||
pbc.inScope = "rgb_create_block";
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
// value.args[0].args[0].n.v='pin'+value.args[0].args[0].n.v
|
||||
var pinblock = py2block.convert(value.args[0].args[0]);
|
||||
pbc.inScope = null;
|
||||
pbc.pinType = null;
|
||||
var countblock = py2block.convert(value.args[1]);
|
||||
|
||||
return block("actuator_neopixel_init", node.lineno, {}, {
|
||||
"SUB":rgbblock,
|
||||
"PIN":pinblock,
|
||||
"LEDCOUNT":countblock
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('rgb')['write'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if(args.length!=0){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
var rgbblock=py2block.convert(func.value);
|
||||
|
||||
return [block("actuator_neopixel_write", func.lineno, {}, { 'SUB':rgbblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('music')['get_tempo'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if(args.length!=0){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
return block("esp32_music_get_tempo", func.lineno, {}, {
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('music')['set_tempo'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if(args.length!=2){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var resoblock=py2block.convert(args[0]);
|
||||
var speedblock=py2block.convert(args[1]);
|
||||
|
||||
return [block("esp32_music_set_tempo", func.lineno, {}, {
|
||||
'TICKS':resoblock,
|
||||
"BPM":speedblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
pbc.moduleFunctionD.get('music')['reset'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if(args.length!=0){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
return [block("esp32_music_reset", func.lineno, {}, {
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('setonoff')['led'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="led" && mac==="mixgo"){
|
||||
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
pbc.inScope="ledswitch";
|
||||
var mode = py2block.convert(args[0]);
|
||||
pbc.inScope=null;
|
||||
|
||||
return [block("actuator_extern_led_bright", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
'bright':mode
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('getonoff')['led'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="led" && mac==="mixgo"){
|
||||
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
return block("actuator_extern_get_led_bright", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('setbrightness')['led'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="led" && mac==="mixgo"){
|
||||
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
var mode = py2block.convert(args[0]);
|
||||
|
||||
return [block("actuator_extern_led_brightness", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
'bright':mode
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.rgb')['write'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if(args.length!=0){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
return [block("actuator_onboard_neopixel_write", func.lineno, {}, {
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
441
boards/default_src/micropython/converters/communicate.js
Normal file
441
boards/default_src/micropython/converters/communicate.js
Normal file
@@ -0,0 +1,441 @@
|
||||
var spiClass = 'machine.SPI';
|
||||
var i2cClass = 'machine.I2C';
|
||||
var owClass = 'onewire.OneWire';
|
||||
pbc.assignD.get('I2C')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
if(value._astname === "Call" && moduleName === "machine"
|
||||
&& funcName === "I2C" && value.keywords.length === 3)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('I2C')['create_block'] = function(py2block, node, targets, value){
|
||||
|
||||
var astname = value.keywords[0]._astname;
|
||||
if(astname === "keyword" && value.keywords[0].arg.v == "scl"
|
||||
&& value.keywords[0].value.func.attr.v === "Pin"){
|
||||
var sdablock = null;
|
||||
var sclblock = null;
|
||||
var freqblock = null;
|
||||
var param = value.keywords[0];
|
||||
var key = py2block.identifier(param.arg);
|
||||
var i2cblock=py2block.convert(targets[0])
|
||||
for (var i = 0; i < value.keywords.length; i++) {
|
||||
var param = value.keywords[i];
|
||||
var key = py2block.identifier(param.arg);
|
||||
if (key === "sda") {
|
||||
pbc.inScope = "communicate_i2c_init";
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
sdablock = py2block.convert(param.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
pbc.inScope = null;
|
||||
} else if (key === "scl") {
|
||||
pbc.inScope = "communicate_i2c_init";
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
sclblock = py2block.convert(param.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
pbc.inScope = null;
|
||||
} else if (key === "freq") {
|
||||
freqblock = py2block.convert(param.value);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (sdablock != null && sclblock != null && freqblock != null) {
|
||||
return block("communicate_i2c_init", node.lineno, {}, {
|
||||
"SUB":i2cblock,
|
||||
'RX': sdablock,
|
||||
'TX': sclblock,
|
||||
"freq": freqblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('readfrom')['I2C'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var adblock = py2block.convert(args[0]);
|
||||
var datablock = py2block.convert(args[1]);
|
||||
return block("communicate_i2c_read", func.lineno, {}, {
|
||||
"address": adblock,
|
||||
"data": datablock,
|
||||
"VAR": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('writeto')['I2C'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var adblock = py2block.convert(args[0]);
|
||||
var datablock = py2block.convert(args[1]);
|
||||
return [block("communicate_i2c_write", func.lineno, {}, {
|
||||
"address": adblock,
|
||||
"data": datablock,
|
||||
"VAR": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('scan')['I2C'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return block("communicate_i2c_scan", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('read')[i2cClass] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return block("communicate_i2c_master_read", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('available')['I2C'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return block("communicate_i2c_available", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.assignD.get('SPI')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
if(value._astname === "Call" && moduleName === "machine"
|
||||
&& funcName === "SPI" && value.keywords.length === 6)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('SPI')['create_block'] = function(py2block, node, targets, value){
|
||||
|
||||
var astname = value.keywords[0]._astname;
|
||||
if(value.keywords[0].arg.v == "baudrate" && value.keywords[3].arg.v == "sck" && value.keywords[3].value.func.attr.v == "Pin"){
|
||||
var polarityblock = null;
|
||||
var phaseblock = null;
|
||||
var sckblock = null;
|
||||
var mosiblock = null;
|
||||
var misoblock = null;
|
||||
var freqblock = null;
|
||||
var param = value.keywords[0];
|
||||
var key = py2block.identifier(param.arg);
|
||||
var spiblock=py2block.convert(targets[0]);
|
||||
for (var i = 0; i < value.keywords.length; i++) {
|
||||
var param = value.keywords[i];
|
||||
var key = py2block.identifier(param.arg);
|
||||
if (key === "baudrate") {
|
||||
freqblock = py2block.convert(param.value);
|
||||
} else if (key === "polarity") {
|
||||
polarityblock = py2block.convert(param.value);
|
||||
} else if (key === "phase") {
|
||||
phaseblock = py2block.convert(param.value);
|
||||
} else if (key === "sck") {
|
||||
pbc.inScope = "communicate_spi_init";
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
sckblock = py2block.convert(param.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
pbc.inScope = null;
|
||||
} else if (key === "mosi") {
|
||||
pbc.inScope = "communicate_spi_init";
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
mosiblock = py2block.convert(param.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
pbc.inScope = null;
|
||||
} else if (key === "miso") {
|
||||
pbc.inScope = "communicate_spi_init";
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
misoblock = py2block.convert(param.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
pbc.inScope = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (polarityblock != null && phaseblock != null && freqblock != null && sckblock != null && mosiblock != null && misoblock != null) {
|
||||
return block("communicate_spi_init", node.lineno, {}, {
|
||||
"VAR":spiblock,
|
||||
"freq": freqblock,
|
||||
"polarity": polarityblock,
|
||||
"phase": phaseblock,
|
||||
"sck": sckblock,
|
||||
"mosi": mosiblock,
|
||||
"miso": misoblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// 跟control的system_timer重了
|
||||
// pbc.objectFunctionD.get('init')['SPI'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
// if (args.length == 0 & keywords.length == 1){
|
||||
// var objblock = py2block.convert(func.value);
|
||||
// var btlblock = null;
|
||||
// var param = keywords[0];
|
||||
// var key = py2block.identifier(param.arg);
|
||||
// if (key === "baudrate") {
|
||||
// bltblock = py2block.convert(param.value);
|
||||
// }
|
||||
// if (bltblock != null ) {
|
||||
// return [block("communicate_spi_set", func.lineno, {}, {
|
||||
// "VAR":objblock,
|
||||
// "data": bltblock,
|
||||
// }, {
|
||||
// "inline": "true"
|
||||
// })];
|
||||
// }
|
||||
// }else{
|
||||
// throw new Error("Incorrect number of arguments");
|
||||
// }
|
||||
// }
|
||||
|
||||
pbc.assignD.get('spi')['check_assign'] = function(py2block, node, targets, value) {
|
||||
if(value._astname != "Call" || value.func._astname != "Name"){
|
||||
return false;
|
||||
}
|
||||
var funcName = py2block.Name_str(value.func);
|
||||
if(funcName === "bytearray" && value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('spi')['create_block'] = function(py2block, node, targets, value){
|
||||
return block("communicate_spi_buffer", node.lineno, {
|
||||
}, {
|
||||
"data":py2block.convert(value.args[0]),
|
||||
"VAR":py2block.convert(targets[0])
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('read')[spiClass] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1 & args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var byteblock = py2block.convert(args[0]);
|
||||
if (args.length == 1){
|
||||
return block("communicate_spi_read", func.lineno, {}, {
|
||||
"data": byteblock,
|
||||
"VAR": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
if (args.length == 2){
|
||||
var outputblock = py2block.convert(args[1]);
|
||||
return block("communicate_spi_read_output", func.lineno, {}, {
|
||||
"data": byteblock,
|
||||
"val": outputblock,
|
||||
"VAR": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('readinto')['SPI'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1 & args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var byteblock = py2block.convert(args[0]);
|
||||
if (args.length == 1){
|
||||
return block("communicate_spi_readinto", func.lineno, {}, {
|
||||
"data": byteblock,
|
||||
"VAR": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
if (args.length == 2){
|
||||
var outputblock = py2block.convert(args[1]);
|
||||
return block("communicate_spi_readinto_output", func.lineno, {}, {
|
||||
"data": byteblock,
|
||||
"val": outputblock,
|
||||
"VAR": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('write')[spiClass] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var byteblock = py2block.convert(args[0].func.value);
|
||||
return block("communicate_spi_write", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
"data": byteblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('write_readinto')['SPI'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var byteblock = py2block.convert(args[0].func.value);
|
||||
var bufblock = py2block.convert(args[1]);
|
||||
return block("communicate_spi_write_readinto", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
"data": byteblock,
|
||||
"val": bufblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.assignD.get('OW')['check_assign'] = function(py2block, node, targets, value) {
|
||||
if(value._astname != "Call" || value.func._astname != "Attribute" || value.func.value._astname != "Name"){
|
||||
return false;
|
||||
}
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call" && moduleName === "onewire"
|
||||
&& funcName === "OneWire" && value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('OW')['create_block'] = function(py2block, node, targets, value){
|
||||
var pwmAstName = value.args[0]._astname;
|
||||
pbc.pinType="pins_digital_pin";
|
||||
var pinblock;
|
||||
|
||||
if (pwmAstName === "Call"&& value.args[0].func._astname == "Attribute" && value.args[0].func.attr.v==="Pin") {
|
||||
pinblock=py2block.convert(value.args[0].args[0])
|
||||
}
|
||||
pbc.pinType=null;
|
||||
return block("communicate_ow_init", node.lineno, {
|
||||
}, {
|
||||
"BUS":pinblock,
|
||||
"VAR":py2block.convert(targets[0]),
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('scan')[owClass] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return block("communicate_ow_scan", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('readbyte')['OW'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return block("communicate_ow_read", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('reset')['OW'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return [block("communicate_ow_reset", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('select_rom')['OW'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var byteblock = py2block.convert(args[0].func.value);
|
||||
return [block("communicate_ow_select", func.lineno, {}, {
|
||||
"VAR": objblock,
|
||||
"byte": byteblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('write')[owClass] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var byteblock = py2block.convert(args[0]);
|
||||
return [block("communicate_ow_write", func.lineno, {
|
||||
'op':'write'
|
||||
}, {
|
||||
"VAR": objblock,
|
||||
"byte": byteblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('writebyte')[owClass] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var byteblock = py2block.convert(args[0]);
|
||||
return [block("communicate_ow_write", func.lineno, {
|
||||
'op':'writebyte'
|
||||
}, {
|
||||
"VAR": objblock,
|
||||
"byte": byteblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('resume')['irremote'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
//var objblock = py2block.convert(func.value);
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
var adblock = py2block.convert(args[0]);
|
||||
pbc.pinType = "pins_callback";
|
||||
var datablock = py2block.convert(args[1]);
|
||||
pbc.pinType=null;
|
||||
return [block("communicate_ir_recv", func.lineno, {}, {
|
||||
"PIN": adblock,
|
||||
"SUB": datablock,
|
||||
//"VAR": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
139
boards/default_src/micropython/converters/control.js
Normal file
139
boards/default_src/micropython/converters/control.js
Normal file
@@ -0,0 +1,139 @@
|
||||
'use strict';
|
||||
|
||||
pbc.moduleFunctionD.get('time')['sleep_ms'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
var time=py2block.convert(args[0]);
|
||||
return [block("controls_delay", func.lineno, {'Time':'ms'}, {
|
||||
"DELAY_TIME":time
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('time')['sleep'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
var time=py2block.convert(args[0]);
|
||||
return [block("controls_delay", func.lineno, {'Time':'s'}, {
|
||||
"DELAY_TIME":time
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('time')['sleep_us'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
var time=py2block.convert(args[0]);
|
||||
return [block("controls_delay", func.lineno, {'Time':'us'}, {
|
||||
"DELAY_TIME":time
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('time')['ticks_ms'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
return block("controls_millis", func.lineno, {"Time":"ms"}, {}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
pbc.moduleFunctionD.get('time')['ticks_us'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
return block("controls_millis", func.lineno, {"Time":"us"}, {}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('time')['ticks_diff'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var endblock=py2block.convert(args[0]);
|
||||
var startblock=py2block.convert(args[1]);
|
||||
return block("system_ticks_diff", func.lineno, {}, {
|
||||
"END":endblock,
|
||||
"START":startblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.assignD.get('Timer')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call"
|
||||
&& funcName === "Timer" && moduleName === "machine" && value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('Timer')['create_block'] = function(py2block, node, targets, value){
|
||||
|
||||
pbc.pinType = "variables_get";
|
||||
var timblock = py2block.convert(targets[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
|
||||
return block("system_timer_init", node.lineno, {}, {
|
||||
"SUB":timblock,
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
//跟通信的SPT init重了
|
||||
pbc.objectFunctionD.get('init')['control'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
|
||||
if(args.length === 0 && keywords.length ===3){
|
||||
pbc.pinType = "variables_get";
|
||||
var tim = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
pbc.pinType = "math_number";
|
||||
var numblock = py2block.convert(keywords[0].value);
|
||||
pbc.pinType = null;
|
||||
var mode = py2block.identifier(keywords[1].value.attr);
|
||||
pbc.pinType = "pins_callback";
|
||||
var callback = py2block.convert(keywords[2].value);
|
||||
pbc.pinType = null;
|
||||
|
||||
return [block("system_timer", func.lineno, {"mode":mode}, {
|
||||
"VAR": tim,
|
||||
"period":numblock,
|
||||
"callback": callback
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else if (args.length == 0 && keywords.length == 1){
|
||||
var objblock = py2block.convert(func.value);
|
||||
var bltblock = null;
|
||||
var param = keywords[0];
|
||||
var key = py2block.identifier(param.arg);
|
||||
if (key === "baudrate") {
|
||||
bltblock = py2block.convert(param.value);
|
||||
}
|
||||
if (bltblock != null ) {
|
||||
return [block("communicate_spi_set", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
"data": bltblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
}
|
||||
else{
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
}
|
||||
746
boards/default_src/micropython/converters/display.js
Normal file
746
boards/default_src/micropython/converters/display.js
Normal file
@@ -0,0 +1,746 @@
|
||||
'use strict';
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['show'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1 && args.length !== 2 ){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
if (args.length == 1 ){
|
||||
|
||||
var strblock=py2block.convert(args[0]);
|
||||
|
||||
return [block("display_show_image_or_string", func.lineno, {}, {
|
||||
'data':strblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
if (args.length == 2 ){
|
||||
var strblock=py2block.convert(args[0]);
|
||||
var numblock=py2block.convert(args[1]);
|
||||
return [block("display_show_image_or_string_delay", func.lineno, {}, {
|
||||
'data':strblock,
|
||||
'time':numblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['scroll'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1 && args.length !== 2 ){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
if (args.length == 1 ){
|
||||
var strblock=py2block.convert(args[0]);
|
||||
return [block("display_scroll_string", func.lineno, {}, {
|
||||
'data':strblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
if (args.length == 2 ){
|
||||
var strblock=py2block.convert(args[0]);
|
||||
var numblock=py2block.convert(args[1]);
|
||||
return [block("display_scroll_string_delay", func.lineno, {}, {
|
||||
'data':strblock,
|
||||
'time':numblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['showstatic'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1 && args.length !== 2 ){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
if (args.length == 1 ){
|
||||
var strblock=py2block.convert(args[0]);
|
||||
return [block("display_show_static", func.lineno, {}, {
|
||||
'data':strblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['get_screenimage'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
if (args.length == 0 ) {
|
||||
return block("display_get_screen_image", func.lineno, {}, {
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix')['Image'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1 || args[0]._astname != "Str") {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var colours = [
|
||||
"#000000",
|
||||
"#ff0000",
|
||||
];
|
||||
var flag = 0;
|
||||
var tempblock = py2block.Str_value(args[0]);
|
||||
var temptext = new Array();
|
||||
temptext = tempblock.split(':');
|
||||
|
||||
if (temptext.length == 8) {
|
||||
for (var i = 0; i < 8; i++) {
|
||||
if (temptext[i].length == 16) {
|
||||
flag++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag == 8) {
|
||||
return block('display_image_create', func.lineno, {
|
||||
"00": colours[temptext[0].charAt(0)],
|
||||
"01": colours[temptext[0].charAt(1)],
|
||||
"02": colours[temptext[0].charAt(2)],
|
||||
"03": colours[temptext[0].charAt(3)],
|
||||
"04": colours[temptext[0].charAt(4)],
|
||||
"05": colours[temptext[0].charAt(5)],
|
||||
"06": colours[temptext[0].charAt(6)],
|
||||
"07": colours[temptext[0].charAt(7)],
|
||||
"08": colours[temptext[0].charAt(8)],
|
||||
"09": colours[temptext[0].charAt(9)],
|
||||
"0a": colours[temptext[0].charAt(10)],
|
||||
"0b": colours[temptext[0].charAt(11)],
|
||||
"0c": colours[temptext[0].charAt(12)],
|
||||
"0d": colours[temptext[0].charAt(13)],
|
||||
"0e": colours[temptext[0].charAt(14)],
|
||||
"0f": colours[temptext[0].charAt(15)],
|
||||
|
||||
"10": colours[temptext[1].charAt(0)],
|
||||
"11": colours[temptext[1].charAt(1)],
|
||||
"12": colours[temptext[1].charAt(2)],
|
||||
"13": colours[temptext[1].charAt(3)],
|
||||
"14": colours[temptext[1].charAt(4)],
|
||||
"15": colours[temptext[1].charAt(5)],
|
||||
"16": colours[temptext[1].charAt(6)],
|
||||
"17": colours[temptext[1].charAt(7)],
|
||||
"18": colours[temptext[1].charAt(8)],
|
||||
"19": colours[temptext[1].charAt(9)],
|
||||
"1a": colours[temptext[1].charAt(10)],
|
||||
"1b": colours[temptext[1].charAt(11)],
|
||||
"1c": colours[temptext[1].charAt(12)],
|
||||
"1d": colours[temptext[1].charAt(13)],
|
||||
"1e": colours[temptext[1].charAt(14)],
|
||||
"1f": colours[temptext[1].charAt(15)],
|
||||
|
||||
"20": colours[temptext[2].charAt(0)],
|
||||
"21": colours[temptext[2].charAt(1)],
|
||||
"22": colours[temptext[2].charAt(2)],
|
||||
"23": colours[temptext[2].charAt(3)],
|
||||
"24": colours[temptext[2].charAt(4)],
|
||||
"25": colours[temptext[2].charAt(5)],
|
||||
"26": colours[temptext[2].charAt(6)],
|
||||
"27": colours[temptext[2].charAt(7)],
|
||||
"28": colours[temptext[2].charAt(8)],
|
||||
"29": colours[temptext[2].charAt(9)],
|
||||
"2a": colours[temptext[2].charAt(10)],
|
||||
"2b": colours[temptext[2].charAt(11)],
|
||||
"2c": colours[temptext[2].charAt(12)],
|
||||
"2d": colours[temptext[2].charAt(13)],
|
||||
"2e": colours[temptext[2].charAt(14)],
|
||||
"2f": colours[temptext[2].charAt(15)],
|
||||
|
||||
"30": colours[temptext[3].charAt(0)],
|
||||
"31": colours[temptext[3].charAt(1)],
|
||||
"32": colours[temptext[3].charAt(2)],
|
||||
"33": colours[temptext[3].charAt(3)],
|
||||
"34": colours[temptext[3].charAt(4)],
|
||||
"35": colours[temptext[3].charAt(5)],
|
||||
"36": colours[temptext[3].charAt(6)],
|
||||
"37": colours[temptext[3].charAt(7)],
|
||||
"38": colours[temptext[3].charAt(8)],
|
||||
"39": colours[temptext[3].charAt(9)],
|
||||
"3a": colours[temptext[3].charAt(10)],
|
||||
"3b": colours[temptext[3].charAt(11)],
|
||||
"3c": colours[temptext[3].charAt(12)],
|
||||
"3d": colours[temptext[3].charAt(13)],
|
||||
"3e": colours[temptext[3].charAt(14)],
|
||||
"3f": colours[temptext[3].charAt(15)],
|
||||
|
||||
"40": colours[temptext[4].charAt(0)],
|
||||
"41": colours[temptext[4].charAt(1)],
|
||||
"42": colours[temptext[4].charAt(2)],
|
||||
"43": colours[temptext[4].charAt(3)],
|
||||
"44": colours[temptext[4].charAt(4)],
|
||||
"45": colours[temptext[4].charAt(5)],
|
||||
"46": colours[temptext[4].charAt(6)],
|
||||
"47": colours[temptext[4].charAt(7)],
|
||||
"48": colours[temptext[4].charAt(8)],
|
||||
"49": colours[temptext[4].charAt(9)],
|
||||
"4a": colours[temptext[4].charAt(10)],
|
||||
"4b": colours[temptext[4].charAt(11)],
|
||||
"4c": colours[temptext[4].charAt(12)],
|
||||
"4d": colours[temptext[4].charAt(13)],
|
||||
"4e": colours[temptext[4].charAt(14)],
|
||||
"4f": colours[temptext[4].charAt(15)],
|
||||
|
||||
|
||||
"50": colours[temptext[5].charAt(0)],
|
||||
"51": colours[temptext[5].charAt(1)],
|
||||
"52": colours[temptext[5].charAt(2)],
|
||||
"53": colours[temptext[5].charAt(3)],
|
||||
"54": colours[temptext[5].charAt(4)],
|
||||
"55": colours[temptext[5].charAt(5)],
|
||||
"56": colours[temptext[5].charAt(6)],
|
||||
"57": colours[temptext[5].charAt(7)],
|
||||
"58": colours[temptext[5].charAt(8)],
|
||||
"59": colours[temptext[5].charAt(9)],
|
||||
"5a": colours[temptext[5].charAt(10)],
|
||||
"5b": colours[temptext[5].charAt(11)],
|
||||
"5c": colours[temptext[5].charAt(12)],
|
||||
"5d": colours[temptext[5].charAt(13)],
|
||||
"5e": colours[temptext[5].charAt(14)],
|
||||
"5f": colours[temptext[5].charAt(15)],
|
||||
|
||||
"60": colours[temptext[6].charAt(0)],
|
||||
"61": colours[temptext[6].charAt(1)],
|
||||
"62": colours[temptext[6].charAt(2)],
|
||||
"63": colours[temptext[6].charAt(3)],
|
||||
"64": colours[temptext[6].charAt(4)],
|
||||
"65": colours[temptext[6].charAt(5)],
|
||||
"66": colours[temptext[6].charAt(6)],
|
||||
"67": colours[temptext[6].charAt(7)],
|
||||
"68": colours[temptext[6].charAt(8)],
|
||||
"69": colours[temptext[6].charAt(9)],
|
||||
"6a": colours[temptext[6].charAt(10)],
|
||||
"6b": colours[temptext[6].charAt(11)],
|
||||
"6c": colours[temptext[6].charAt(12)],
|
||||
"6d": colours[temptext[6].charAt(13)],
|
||||
"6e": colours[temptext[6].charAt(14)],
|
||||
"6f": colours[temptext[6].charAt(15)],
|
||||
|
||||
|
||||
"70": colours[temptext[7].charAt(0)],
|
||||
"71": colours[temptext[7].charAt(1)],
|
||||
"72": colours[temptext[7].charAt(2)],
|
||||
"73": colours[temptext[7].charAt(3)],
|
||||
"74": colours[temptext[7].charAt(4)],
|
||||
"75": colours[temptext[7].charAt(5)],
|
||||
"76": colours[temptext[7].charAt(6)],
|
||||
"77": colours[temptext[7].charAt(7)],
|
||||
"78": colours[temptext[7].charAt(8)],
|
||||
"79": colours[temptext[7].charAt(9)],
|
||||
"7a": colours[temptext[7].charAt(10)],
|
||||
"7b": colours[temptext[7].charAt(11)],
|
||||
"7c": colours[temptext[7].charAt(12)],
|
||||
"7d": colours[temptext[7].charAt(13)],
|
||||
"7e": colours[temptext[7].charAt(14)],
|
||||
"7f": colours[temptext[7].charAt(15)],
|
||||
|
||||
}, {}, {
|
||||
"inline": "false"
|
||||
});
|
||||
}
|
||||
}
|
||||
function shift(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=1){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var str1block=py2block.convert(args[0]);
|
||||
var imgblock=py2block.convert(func.value);
|
||||
return block("image_shift", func.lineno, {
|
||||
'OP':mode
|
||||
}, {
|
||||
'img':imgblock,
|
||||
'val':str1block
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
pbc.objectFunctionD.get('shift_up')['matrix'] = shift('up');
|
||||
pbc.objectFunctionD.get('shift_down')['matrix'] = shift('down');
|
||||
pbc.objectFunctionD.get('shift_left')['matrix'] = shift('left');
|
||||
pbc.objectFunctionD.get('shift_right')['matrix'] = shift('right');
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['get_pixel'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 2){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var astname = args[0]._astname;
|
||||
var astname1 = args[1]._astname;
|
||||
var xblock;
|
||||
var yblock;
|
||||
pbc.pinType = "pins_axis";
|
||||
if(astname === "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) === "int"){ //display.get_pixel(int(0), int(0))
|
||||
xblock = py2block.convert(args[0].args[0]);
|
||||
}else{
|
||||
xblock = py2block.convert(args[0]);
|
||||
}
|
||||
if(astname1 === "Call" && args[1].func._astname == "Name" && py2block.Name_str(args[1].func) === "int"){ //display.get_pixel(int(0), int(0))
|
||||
yblock = py2block.convert(args[1].args[0]);
|
||||
}else{
|
||||
yblock = py2block.convert(args[1]);
|
||||
}
|
||||
pbc.pinType = null;
|
||||
return block("display_get_pixel", func.lineno, {}, {
|
||||
'x':xblock,
|
||||
'y':yblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['set_pixel'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 3){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var astname = args[0]._astname;
|
||||
var astname1 = args[1]._astname;
|
||||
pbc.pinType = null;
|
||||
pbc.inScope="switch";
|
||||
var brightblock = py2block.convert(args[2]);
|
||||
pbc.inScope=null;
|
||||
pbc.pinType = null;
|
||||
var xblock;
|
||||
var yblock;
|
||||
pbc.pinType = "pins_axis";
|
||||
if(astname === "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) === "int"){ //display.set_pixel(int(0), int(0))
|
||||
xblock = py2block.convert(args[0].args[0]);
|
||||
}else{
|
||||
xblock = py2block.convert(args[0]);
|
||||
}
|
||||
if(astname1 === "Call" && args[1].func._astname == "Name" && py2block.Name_str(args[1].func) === "int"){ //display.set_pixel(int(0), int(0))
|
||||
yblock = py2block.convert(args[1].args[0]);
|
||||
}else{
|
||||
yblock = py2block.convert(args[1]);
|
||||
}
|
||||
pbc.pinType = null;
|
||||
return [block("display_bright_point", func.lineno, {}, {
|
||||
'x':xblock,
|
||||
'y':yblock,
|
||||
'STAT':brightblock
|
||||
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['set_brightness'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=1){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="pins_exlcdh";
|
||||
var brightblock=py2block.convert(args[0]);
|
||||
pbc.pinType=null;
|
||||
|
||||
return [block("display_bright_screen", func.lineno, {}, {
|
||||
'x':brightblock,
|
||||
|
||||
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['get_brightness'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=0){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
return block("display_get_screen_pixel", func.lineno, {}, {
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['blink_rate'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=1){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var blinkblock=py2block.convert(args[0]);
|
||||
|
||||
return [block("display_blink_rate", func.lineno, {}, { 'x':blinkblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('matrix.display')['clear'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=0){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
|
||||
return [block("display_clear", func.lineno, {}, {
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_pixel')['monitor'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=2){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var x1block=py2block.convert(args[0]);
|
||||
var y1block=py2block.convert(args[1]);
|
||||
|
||||
return [block("display_oled_drawPixel", func.lineno, {}, { "VAR":objblock,'POS_X':x1block,'POS_Y':y1block,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_bitmap')['monitor'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=5){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var x=py2block.convert(args[0]);
|
||||
var y=py2block.convert(args[1]);
|
||||
var b=py2block.convert(args[2]);
|
||||
var w=py2block.convert(args[3]);
|
||||
var h=py2block.convert(args[4]);
|
||||
return [block("display_oled_showBitmap", func.lineno, {}, { "VAR":objblock,'START_X':x,'START_Y':y,'bitmap_name':b,'WIDTH':w,'HEIGHT':h,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_str')['monitor'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=4){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var str1block=py2block.convert(args[0]);
|
||||
var str2block=py2block.convert(args[1]);
|
||||
var str3block=py2block.convert(args[2]);
|
||||
var str4block=py2block.convert(args[3]);
|
||||
|
||||
return [block("display_draw_4strings", func.lineno, {}, { "VAR":objblock,'Text_line1':str1block,'Text_line2':str2block,'Text_line3':str3block,'Text_line4':str4block,
|
||||
}, {
|
||||
"inline": "false"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_line')['monitor'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=5){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var x1block=py2block.convert(args[0]);
|
||||
var y1block=py2block.convert(args[1]);
|
||||
var x2block=py2block.convert(args[2]);
|
||||
var y2block=py2block.convert(args[3]);
|
||||
|
||||
return [block("display_line_arbitrarily", func.lineno, {}, { "VAR":objblock,'x1':x1block,'y1':y1block,'x2':x2block,'y2':y2block,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_hline')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 4) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var xblock = py2block.convert(args[0]);
|
||||
var yblock = py2block.convert(args[1]);
|
||||
var lenblock = py2block.convert(args[2]);
|
||||
return [block("display_line", func.lineno, {
|
||||
'direction': 'hline',
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x": xblock,
|
||||
"y": yblock,
|
||||
"length": lenblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_vline')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 4) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var xblock = py2block.convert(args[0]);
|
||||
var yblock = py2block.convert(args[1]);
|
||||
var lenblock = py2block.convert(args[2]);
|
||||
return [block("display_line", func.lineno, {
|
||||
'direction': 'vline',
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x": xblock,
|
||||
"y": yblock,
|
||||
"length": lenblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_rect')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 5) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var xblock = py2block.convert(args[0]);
|
||||
var yblock = py2block.convert(args[1]);
|
||||
var widthblock = py2block.convert(args[2]);
|
||||
var heightblock = py2block.convert(args[3]);
|
||||
var lightblock = py2block.identifier(args[4].n);
|
||||
return [block("display_rect", func.lineno, {
|
||||
"fill": false,
|
||||
"OP": lightblock,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x": xblock,
|
||||
"y": yblock,
|
||||
"width": widthblock,
|
||||
"height": heightblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_fill_rect')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 5) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var xblock = py2block.convert(args[0]);
|
||||
var yblock = py2block.convert(args[1]);
|
||||
var widthblock = py2block.convert(args[2]);
|
||||
var heightblock = py2block.convert(args[3]);
|
||||
var lightblock = py2block.identifier(args[4].n);
|
||||
return [block("display_rect", func.lineno, {
|
||||
"fill": true,
|
||||
"OP": lightblock,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x": xblock,
|
||||
"y": yblock,
|
||||
"width": widthblock,
|
||||
"height": heightblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_triangle')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 7) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var x0 = py2block.convert(args[0]);
|
||||
var y0 = py2block.convert(args[1]);
|
||||
var x1 = py2block.convert(args[2]);
|
||||
var y1 = py2block.convert(args[3]);
|
||||
var x2 = py2block.convert(args[4]);
|
||||
var y2 = py2block.convert(args[5]);
|
||||
var lightblock = py2block.identifier(args[6].n);
|
||||
return [block("display_triangle", func.lineno, {
|
||||
"fill": false,
|
||||
"OP": lightblock,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x0": x0,
|
||||
"y0": y0,
|
||||
"x1": x1,
|
||||
"y1": y1,
|
||||
"x2": x2,
|
||||
"y2": y2,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_fill_triangle')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 7) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var x0 = py2block.convert(args[0]);
|
||||
var y0 = py2block.convert(args[1]);
|
||||
var x1 = py2block.convert(args[2]);
|
||||
var y1 = py2block.convert(args[3]);
|
||||
var x2 = py2block.convert(args[4]);
|
||||
var y2 = py2block.convert(args[5]);
|
||||
var lightblock = py2block.identifier(args[6].n);
|
||||
return [block("display_triangle", func.lineno, {
|
||||
"fill": true,
|
||||
"OP": lightblock,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x0": x0,
|
||||
"y0": y0,
|
||||
"x1": x1,
|
||||
"y1": y1,
|
||||
"x2": x2,
|
||||
"y2": y2,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_circle')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 4) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var xblock = py2block.convert(args[0]);
|
||||
var yblock = py2block.convert(args[1]);
|
||||
var rblock = py2block.convert(args[2]);
|
||||
var lightblock = py2block.identifier(args[3].n);
|
||||
return [block("display_circle", func.lineno, {
|
||||
"fill": false,
|
||||
"OP": lightblock,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x": xblock,
|
||||
"y": yblock,
|
||||
"r": rblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_fill_circle')['monitor'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 4) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var xblock = py2block.convert(args[0]);
|
||||
var yblock = py2block.convert(args[1]);
|
||||
var rblock = py2block.convert(args[2]);
|
||||
var lightblock = py2block.identifier(args[3].n);
|
||||
return [block("display_circle", func.lineno, {
|
||||
"fill": true,
|
||||
"OP": lightblock,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"x": xblock,
|
||||
"y": yblock,
|
||||
"r": rblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
|
||||
pbc.assignD.get('oled')['check_assign'] = function(py2block, node, targets, value) {
|
||||
if(value._astname != "Call" || value.func._astname != "Attribute" || value.func.value._astname != "Name"){
|
||||
return false;
|
||||
}
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call" && moduleName === "ssd1306"
|
||||
&& funcName === "SSD1306_I2C" && value.args.length === 3)
|
||||
return true;
|
||||
else if(value._astname === "Call" && moduleName === "tm1650"
|
||||
&& funcName === "TM1650" && value.args.length === 1)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('oled')['create_block'] = function(py2block, node, targets, value){
|
||||
if(value.args.length === 3){
|
||||
var rowblock = py2block.convert(value.args[0]);
|
||||
var columnblock = py2block.convert(value.args[1]);
|
||||
var i2cblock = py2block.convert(value.args[2]);
|
||||
return block("display_use_i2c_init", node.lineno, {
|
||||
}, {
|
||||
"row":rowblock,
|
||||
"column":columnblock,
|
||||
"I2CSUB":i2cblock,
|
||||
"SUB":py2block.convert(targets[0]),
|
||||
});
|
||||
}
|
||||
else if(value.args.length === 1){
|
||||
var i2cblock = py2block.convert(value.args[0]);
|
||||
return block("display_tm_use_i2c_init", node.lineno, {
|
||||
}, {
|
||||
"I2CSUB":i2cblock,
|
||||
"SUB":py2block.convert(targets[0]),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('show_fill')['monitor'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if(args.length!=1){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
var flagblock = py2block.identifier(args[0].n.v);
|
||||
|
||||
|
||||
return [block("display_fill", func.lineno, {'key':flagblock}, { "SUB":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
function display_tm_stat(mode, type){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var varblock = py2block.convert(func.value)
|
||||
return [block('display_tm1650_power', func.lineno, {
|
||||
"TYPE": type,
|
||||
"STAT": mode,
|
||||
}, {
|
||||
"VAR": varblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('tm1650_on')['disp'] = display_tm_stat('_on','tm1650');
|
||||
pbc.objectFunctionD.get('tm1650_off')['disp'] = display_tm_stat('_off','tm1650');
|
||||
pbc.objectFunctionD.get('tm1650_clear')['disp'] = display_tm_stat('_clear','tm1650');
|
||||
|
||||
|
||||
pbc.objectFunctionD.get('tm1650_show_num')['disp'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var valblock=py2block.convert(args[0]);
|
||||
var varblock=py2block.convert(func.value)
|
||||
return [block("display_tm1650_show_num", func.lineno, {
|
||||
"TYPE":'tm1650'
|
||||
}, {
|
||||
'VALUE':valblock,
|
||||
'VAR': varblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('tm1650_show_dot')['disp'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var valblock=py2block.convert(args[0]);
|
||||
pbc.inScope="switch";
|
||||
var statblock=py2block.convert(args[1]);
|
||||
pbc.inScope=null;
|
||||
var varblock=py2block.convert(func.value)
|
||||
return [block("display_tm1650_show_dot", func.lineno, {
|
||||
"TYPE":'tm1650'
|
||||
}, {
|
||||
'NO':valblock,
|
||||
'STAT':statblock,
|
||||
'VAR': varblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
295
boards/default_src/micropython/converters/inout.js
Normal file
295
boards/default_src/micropython/converters/inout.js
Normal file
@@ -0,0 +1,295 @@
|
||||
|
||||
|
||||
pbc.objectFunctionD.get('value')['Pin'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1 && args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
if(args.length == 1){
|
||||
pbc.pinType = "pins_digital";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
var argblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
return [block("inout_digital_write", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
"STAT": argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];}
|
||||
else if(args.length == 0){
|
||||
pbc.pinType = "pins_digital";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
return block("inout_digital_read", func.lineno, {}, {
|
||||
"PIN": pinblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pbc.assignD.get('Pin')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call"
|
||||
&& funcName === "Pin" && (value.args.length === 2 || value.args.length === 3) )
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('Pin')['create_block'] = function(py2block, node, targets, value){
|
||||
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
var pinblock = py2block.convert(value.args[0]);
|
||||
pbc.pinType = null;
|
||||
if(value.args.length === 2){
|
||||
var digitalblock = "machine."+py2block.identifier(value.args[1].value.attr) +"."+ py2block.identifier(value.args[1].attr);
|
||||
}
|
||||
else if(value.args.length === 3){
|
||||
var digitalblock = "machine."+py2block.identifier(value.args[1].value.attr) +"."+ py2block.identifier(value.args[1].attr)+", "+"machine."+py2block.identifier(value.args[2].value.attr) +"."+ py2block.identifier(value.args[2].attr);
|
||||
}
|
||||
pinobj = py2block.identifier(targets[0].id);
|
||||
return block("inout_digital_init", node.lineno, {"PIN_OBJ":pinobj,"MODE":digitalblock}, {
|
||||
"PIN":pinblock,
|
||||
|
||||
});
|
||||
}
|
||||
//ok
|
||||
pbc.assignD.get('DAC')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call"
|
||||
&& funcName === "DAC" && moduleName === "machine"&& value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('DAC')['create_block'] = function(py2block, node, targets, value){
|
||||
var astname = value.args[0]._astname;
|
||||
var funcName = py2block.identifier(value.args[0].func.attr);
|
||||
if(astname === "Call" && funcName === "Pin"){ //
|
||||
pbc.pinType = "pins_dac_pin";
|
||||
pinblock = py2block.convert(value.args[0].args[0]);
|
||||
pbc.pinType = null;
|
||||
}else{
|
||||
pbc.pinType = "pins_dac_pin";
|
||||
pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
}
|
||||
pinobj = py2block.identifier(targets[0].id);
|
||||
return block("inout_analog_write_init", node.lineno, {"PIN_OBJ":pinobj}, {
|
||||
"PIN":pinblock,
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('write')['Pin'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType = "pins_dac";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
var argblock = py2block.convert(args[0]);
|
||||
|
||||
return [block("inout_analog_write", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
"NUM": argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
//ok
|
||||
pbc.assignD.get('PWM')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call"
|
||||
&& funcName === "PWM" && moduleName === "machine" && value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('PWM')['create_block'] = function(py2block, node, targets, value){
|
||||
var astname = value.args[0]._astname;
|
||||
var funcName = py2block.identifier(value.args[0].func.attr);
|
||||
if(astname === "Call" && funcName === "Pin"){ //
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
pinblock = py2block.convert(value.args[0].args[0]);
|
||||
pbc.pinType = null;
|
||||
}else{
|
||||
pbc.pinType = "pins_pwm_pin";
|
||||
pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
}
|
||||
pinobj = py2block.identifier(targets[0].id);
|
||||
return block("inout_pwm_analog_write_init", node.lineno, {"PIN_OBJ":pinobj}, {
|
||||
"PIN":pinblock,
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('duty')['Pin'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType = "pins_pwm";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
var argblock = py2block.convert(args[0]);
|
||||
|
||||
return [block("inout_pwm_analog_write", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
"NUM": argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('freq')['Pin'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType = "pins_pwm";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
var argblock = py2block.convert(args[0]);
|
||||
|
||||
return [block("inout_pwm_analog_write_set_freq", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
"NUM": argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
//ok
|
||||
pbc.assignD.get('ADC')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call"
|
||||
&& funcName === "ADC" && moduleName === "machine" && value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('ADC')['create_block'] = function(py2block, node, targets, value){
|
||||
var astname = value.args[0]._astname;
|
||||
var funcName = py2block.identifier(value.args[0].func.attr);
|
||||
if(astname === "Call" && funcName === "Pin"){ //
|
||||
pbc.pinType = "pins_analog_pin";
|
||||
pinblock = py2block.convert(value.args[0].args[0]);
|
||||
pbc.pinType = null;
|
||||
}else{
|
||||
pbc.pinType = "pins_analog_pin";
|
||||
pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
}
|
||||
pinobj = py2block.identifier(targets[0].id);
|
||||
return block("inout_analog_read_init", node.lineno, {"PIN_OBJ":pinobj}, {
|
||||
"PIN":pinblock,
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('read')['Pin'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
value = func.value.id.v
|
||||
value = value.slice(0,2)
|
||||
if( value=="ad"){
|
||||
pbc.pinType = "pins_analog";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
|
||||
return block("inout_analog_read", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});}
|
||||
else if(value =="tc"){
|
||||
pbc.pinType = "pins_touch";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
|
||||
return block("inout_pin_pressed", func.lineno, {}, {
|
||||
"pin": pinblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
//ok
|
||||
pbc.assignD.get('TOUCHPAD')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call"
|
||||
&& funcName === "TouchPad" && moduleName === "machine" && value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('TOUCHPAD')['create_block'] = function(py2block, node, targets, value){
|
||||
var astname = value.args[0]._astname;
|
||||
var funcName = py2block.identifier(value.args[0].func.attr);
|
||||
if(astname === "Call" && funcName === "Pin"){ //
|
||||
pbc.pinType = "pins_touch_pin";
|
||||
pinblock = py2block.convert(value.args[0].args[0]);
|
||||
pbc.pinType = null;
|
||||
}else{
|
||||
pbc.pinType = "pins_touch_pin";
|
||||
pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
}
|
||||
pinobj = py2block.identifier(targets[0].id);
|
||||
return block("inout_pin_pressed_init", node.lineno, {"PIN_OBJ":pinobj}, {
|
||||
"PIN":pinblock,
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('irq')['Pin'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0 || keywords.length!==2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="Pin" && mac==="machine"){
|
||||
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
var mode = mac+"."+pin+"."+py2block.identifier(keywords[1].value.attr);
|
||||
|
||||
pbc.pinType = "pins_callback";
|
||||
var callback = py2block.convert(keywords[0].value);
|
||||
pbc.pinType = null;
|
||||
|
||||
return [block("inout_pin_attachInterrupt", func.lineno, {"mode":mode}, {
|
||||
"PIN": pinblock,
|
||||
"DO": callback
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('atten')['Pin'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
pbc.pinType = "pins_analog";
|
||||
var pinblock = py2block.convert(func.value);
|
||||
pbc.pinType = null;
|
||||
|
||||
var atten = py2block.identifier(args[0].value.value.id)+"."+py2block.identifier(args[0].value.attr)+"."+py2block.identifier(args[0].attr)
|
||||
|
||||
return [block("inout_analog_atten", func.lineno, {"atten":atten}, {
|
||||
"PIN": pinblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
113
boards/default_src/micropython/converters/iot.js
Normal file
113
boards/default_src/micropython/converters/iot.js
Normal file
@@ -0,0 +1,113 @@
|
||||
'use strict';
|
||||
// console.log("hhh")
|
||||
|
||||
pbc.assignD.get('iot')['check_assign'] = function(py2block, node, targets, value) {
|
||||
if(value._astname != "Call" || value.func._astname != "Attribute" || value.func.value._astname != "Name"){
|
||||
return false;
|
||||
}
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
if(moduleName === "miot" && funcName === "init_MQTT_client" && value.args.length === 6)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('iot')['create_block'] = function(py2block, node, targets, value){
|
||||
pbc.pinType = "pins_callback";
|
||||
var subblock = py2block.convert(value.args[5]);
|
||||
pbc.pinType = null;
|
||||
return block("iot_onenet_connect", node.lineno, {}, {
|
||||
"CLIENT":py2block.convert(value.args[0]),
|
||||
"SERVER":py2block.convert(value.args[1]),
|
||||
"USERNAME":py2block.convert(value.args[2]),
|
||||
"PASSWORD":py2block.convert(value.args[3]),
|
||||
"TOPIC":py2block.convert(value.args[4]),
|
||||
"SUB":subblock,
|
||||
"VAR":py2block.convert(targets[0])
|
||||
});
|
||||
}
|
||||
|
||||
// pbc.globalFunctionD['do_connect'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
// if (args.length !== 2) {
|
||||
// throw new Error("Incorrect number of arguments");
|
||||
// }
|
||||
// var nameblock = py2block.convert(args[0]);
|
||||
// var keyblock = py2block.convert(args[1]);
|
||||
// return [block("iot_wifi_connect", func.lineno, {}, {
|
||||
// 'WIFINAME': nameblock,
|
||||
// 'PASSWORD': keyblock
|
||||
// }, {
|
||||
// "inline": "true"
|
||||
// })];
|
||||
// }
|
||||
|
||||
pbc.objectFunctionD.get('do_connect')['miot'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var nameblock = py2block.convert(args[0]);
|
||||
var keyblock = py2block.convert(args[1]);
|
||||
return [block("iot_wifi_connect", func.lineno, {}, {
|
||||
'WIFINAME': nameblock,
|
||||
'PASSWORD': keyblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('publish')['miot'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length == 1 && keywords.length == 1) {
|
||||
var objblock = py2block.convert(func.value);
|
||||
var nameblock = py2block.convert(args[0]);
|
||||
var checkblock = py2block.Name_str(keywords[0].value);
|
||||
return [block("iot_onenet_publish_dict", func.lineno, {
|
||||
"is_print":checkblock
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"DICT":nameblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else if(args.length == 2) {
|
||||
var objblock = py2block.convert(func.value);
|
||||
var nameblock = py2block.convert(args[0]);
|
||||
var checkblock = py2block.Name_str(args[1]);
|
||||
return [block("iot_onenet_publish_dict", func.lineno, {
|
||||
"is_print":checkblock
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
"DICT":nameblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('do_disconnect')['miot'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return [block("iot_onenet_disconnect", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
|
||||
pbc.objectFunctionD.get('check_msg')['iot'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return [block("iot_onenet_check", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
308
boards/default_src/micropython/converters/network.js
Normal file
308
boards/default_src/micropython/converters/network.js
Normal file
@@ -0,0 +1,308 @@
|
||||
'use strict';
|
||||
// console.log("hhh")
|
||||
|
||||
pbc.assignD.get('network')['check_assign'] = function(py2block, node, targets, value) {
|
||||
if(value._astname != "Call" || value.func._astname != "Attribute" || value.func.value._astname != "Name"){
|
||||
return false;
|
||||
}
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call" && moduleName === "network"
|
||||
&& funcName === "WLAN" && value.args.length === 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('network')['create_block'] = function(py2block, node, targets, value){
|
||||
var mode = py2block.identifier(value.args[0].attr);
|
||||
if (mode=="STA_IF"){
|
||||
mode="STA"
|
||||
}
|
||||
else if (mode=="AP_IF"){
|
||||
mode="AP"
|
||||
}
|
||||
return block("network_init", node.lineno, {
|
||||
"mode":mode,
|
||||
}, {
|
||||
"VAR":py2block.convert(targets[0]),
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
pbc.objectFunctionD.get('active')['network'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
|
||||
if (args.length === 1){
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
var reverse = py2block.Name_str(args[0]);
|
||||
return [block("network_open", func.lineno, {
|
||||
"op": reverse,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else if (args.length === 0) {
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
return [block("network_is_active", func.lineno, {
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('isconnected')['network'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return block("network_wifi_connect", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('disconnect')['network'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return [block("network_stop", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('config')['network'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length == 0 & keywords.length == 2){
|
||||
var objblock = py2block.convert(func.value);
|
||||
var essidblock = null;
|
||||
var channelblock = null;
|
||||
for (var i = 0; i < keywords.length; i++) {
|
||||
var param = keywords[i];
|
||||
var key = py2block.identifier(param.arg);
|
||||
if (key === "essid") {
|
||||
essidblock = py2block.convert(param.value);
|
||||
} else if (key === "channel") {
|
||||
channelblock = py2block.convert(param.value);
|
||||
}
|
||||
}
|
||||
if (essidblock != null && channelblock != null ) {
|
||||
return [block("network_ap_connect", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
"essid": essidblock,
|
||||
"channel": channelblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
}else if(args.length == 1) {
|
||||
var objblock = py2block.convert(func.value);
|
||||
var argblock = py2block.Str_value(args[0]);
|
||||
return block("network_get_wifi", func.lineno, {
|
||||
"op":argblock,
|
||||
}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}else{
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('connect')['network'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length === 2) {
|
||||
var objblock = py2block.convert(func.value);
|
||||
var idblock = py2block.convert(args[0]);
|
||||
var passwordblock = py2block.convert(args[1]);
|
||||
return [block("network_connect", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
"id":idblock,
|
||||
"password":passwordblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else if (args.length === 1) {
|
||||
var objblock = py2block.convert(func.value);
|
||||
var reverse = py2block.convert(args[0]);
|
||||
return [block("network_socket_connect", func.lineno, {
|
||||
}, {
|
||||
"address": reverse,
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
else {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
}
|
||||
|
||||
pbc.assignD.get('socket')['check_assign'] = function(py2block, node, targets, value) {
|
||||
if(value._astname != "Call" || value.func._astname != "Attribute" || value.func.value._astname != "Name"){
|
||||
return false;
|
||||
}
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call" && moduleName === "socket"
|
||||
&& funcName === "socket" && value.args.length <= 1)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('socket')['create_block'] = function(py2block, node, targets, value){
|
||||
value.args = value.args || [];
|
||||
if (!value.args.length){
|
||||
var mode="TCP"
|
||||
}
|
||||
else {
|
||||
var mode = py2block.identifier(value.args[0].attr);
|
||||
if (mode == "SOCK_DGRAM"){
|
||||
mode = "UDP"
|
||||
}
|
||||
else if (mode == "SOCK_STREAM"){
|
||||
mode = "TCP"
|
||||
}
|
||||
}
|
||||
return block("network_socket_init", node.lineno, {
|
||||
"mode":mode,
|
||||
}, {
|
||||
"VAR":py2block.convert(targets[0]),
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('bind')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
var reverse = py2block.convert(args[0]);
|
||||
return [block("network_socket_bind", func.lineno, {
|
||||
}, {
|
||||
"address": reverse,
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('listen')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
var reverse = py2block.convert(args[0]);
|
||||
return [block("network_socket_listen", func.lineno, {
|
||||
}, {
|
||||
"queue": reverse,
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('accept')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return block("network_socket_accept", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('recv')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
var reverse = py2block.convert(args[0]);
|
||||
return block("network_socket_receive", func.lineno, {
|
||||
}, {
|
||||
"size": reverse,
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('send')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
var reverse = py2block.convert(args[0]);
|
||||
return [block("network_socket_send", func.lineno, {
|
||||
}, {
|
||||
"content": reverse,
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('recvfrom')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
var reverse = py2block.convert(args[0]);
|
||||
return block("network_socket_receive_from", func.lineno, {
|
||||
}, {
|
||||
"size": reverse,
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('sendto')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
// var lightblock = py2block.identifier(args[0].n);
|
||||
var reverse = py2block.convert(args[0]);
|
||||
var address = py2block.convert(args[1]);
|
||||
return [block("network_socket_send_to", func.lineno, {
|
||||
}, {
|
||||
"content": reverse,
|
||||
"VAR":objblock,
|
||||
"address":address,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('close')['socket'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length != 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return [block("network_socket_close", func.lineno, {}, {
|
||||
"VAR":objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
113
boards/default_src/micropython/converters/py2block_config.js
Normal file
113
boards/default_src/micropython/converters/py2block_config.js
Normal file
@@ -0,0 +1,113 @@
|
||||
function defDict(type) {
|
||||
var dict = {};
|
||||
return {
|
||||
get: function (key) {
|
||||
if (!dict[key]) {
|
||||
dict[key] = type.constructor();
|
||||
}
|
||||
return dict[key];
|
||||
},
|
||||
dict: dict
|
||||
};
|
||||
}
|
||||
|
||||
function Py2blockConfig (){
|
||||
this.initIgnoreS();
|
||||
this.initModuleAttrD();
|
||||
this.initKnownModuleS();
|
||||
this.initObjectTypeD();
|
||||
this.formatModuleKeyL = [
|
||||
['Pin', 'ADC', 'TouchPad', 'PWM', 'DAC', 'I2C'],
|
||||
['button_a', 'button_b', 'touch1', 'touch2', 'touch3', 'touch4', 'Infrared_left', 'Infrared_right',
|
||||
'mixgo_get_brightness', 'mixgo_get_soundlevel', 'Sonar', 'led', 'led1','led2','Infrared'],
|
||||
['NeoPixel'],
|
||||
['display', 'Image']
|
||||
];
|
||||
this.formatModuleL = ['machine', 'mixgo', 'neopixel', 'matrix'];
|
||||
}
|
||||
|
||||
var pbc = Py2blockConfig.prototype;
|
||||
pbc.ESP32 = "MicroPython[ESP32]";
|
||||
pbc.board = pbc.ESP32;
|
||||
pbc.objectFunctionD = defDict({});
|
||||
pbc.moduleFunctionD = defDict({});
|
||||
pbc.moduleAttrD = defDict({});
|
||||
pbc.objectAttrD = defDict({});
|
||||
pbc.globalFunctionD = {};
|
||||
pbc.assignD = defDict({});
|
||||
pbc.ifStatementD= defDict({});
|
||||
pbc.whileStatementD= defDict({});
|
||||
pbc.forStatementD= defDict({});
|
||||
pbc.reservedNameD= {};
|
||||
pbc.knownModuleS = new Set();
|
||||
pbc.objectTypeD = {}; //key：变量名，value：变量类型，如{'a':'List'}
|
||||
pbc.ignoreS = new Set();
|
||||
pbc.pinType = null;
|
||||
pbc.inScope = null;
|
||||
pbc.formatModuleKeyL = [];
|
||||
pbc.formatModuleL = [];
|
||||
|
||||
//忽略某些方法、类、赋值
|
||||
pbc.initIgnoreS = function(){
|
||||
var pythonIgnoreL = [
|
||||
];
|
||||
var boardIgnoreL = [
|
||||
];
|
||||
|
||||
var ignoreL = pythonIgnoreL.concat(boardIgnoreL);
|
||||
for (var i = 0; i < ignoreL.length; i++) {
|
||||
this.ignoreS.add(ignoreL[i]);
|
||||
}
|
||||
}
|
||||
|
||||
pbc.initModuleAttrD = function(){
|
||||
for (var i = 0; i < profile.default.builtinimg.length; i++) {
|
||||
pbc.moduleAttrD.get('matrix.Image')[profile.default.builtinimg[i][0]] = function (node, module, attr) {
|
||||
return block("pins_builtinimg", node.lineno, {
|
||||
"PIN": module + "." + attr
|
||||
});
|
||||
}
|
||||
}
|
||||
for (var i = 0; i < profile.default.imglist.length; i++) {
|
||||
pbc.moduleAttrD.get('Image')[profile.default.imglist[i][0]] = function (node, module, attr) {
|
||||
return block("pins_imglist", node.lineno, {
|
||||
"PIN": module + "." + attr
|
||||
});
|
||||
}
|
||||
}
|
||||
for (var i = 0; i < profile.default.playlist.length; i++) {
|
||||
pbc.moduleAttrD.get('music')[profile.default.playlist[i][0]] = function (node, module, attr) {
|
||||
return block("pins_playlist", node.lineno, {
|
||||
"PIN": module + "." + attr
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pbc.initKnownModuleS = function(){
|
||||
var pythonModuleL = [
|
||||
'math', 'random'
|
||||
];
|
||||
var boardModuleL = [];
|
||||
|
||||
var moduleL = pythonModuleL.concat(boardModuleL);
|
||||
for (var i = 0; i < moduleL.length; i++) {
|
||||
this.knownModuleS.add(moduleL[i]);
|
||||
}
|
||||
}
|
||||
|
||||
pbc.initObjectTypeD = function () {
|
||||
this.objectTypeD = {
|
||||
'f': 'open',
|
||||
'spi': 'machine.SPI',
|
||||
'i2c': 'machine.I2C',
|
||||
'ow': 'onewire.OneWire',
|
||||
}
|
||||
}
|
||||
|
||||
pbc.reset = function(){
|
||||
this.initObjectTypeD();
|
||||
}
|
||||
|
||||
var py2block_config = new Py2blockConfig();
|
||||
|
||||
734
boards/default_src/micropython/converters/sensor.js
Normal file
734
boards/default_src/micropython/converters/sensor.js
Normal file
@@ -0,0 +1,734 @@
|
||||
'use strict';
|
||||
|
||||
function pressed_converter (mode) {
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pinType = "pins_button";
|
||||
var objblock = py2block.convert(btn);
|
||||
pbc.pinType = null;
|
||||
return block(mode, func.lineno, {}, {
|
||||
"btn": objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.button_a')['is_pressed'] = pressed_converter('sensor_mixgo_button_is_pressed');
|
||||
pbc.moduleFunctionD.get('mixgo.button_b')['is_pressed'] = pressed_converter('sensor_mixgo_button_is_pressed');
|
||||
pbc.moduleFunctionD.get('mixgo.button_a')['was_pressed'] = pressed_converter('sensor_mixgo_button_was_pressed');
|
||||
pbc.moduleFunctionD.get('mixgo.button_b')['was_pressed'] = pressed_converter('sensor_mixgo_button_was_pressed');
|
||||
|
||||
|
||||
function getpresses_converter (mode) {
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pinType = "pins_button";
|
||||
var objblock = py2block.convert(btn);
|
||||
pbc.pinType = null;
|
||||
var argblock = py2block.convert(args[0]);
|
||||
return block(mode, func.lineno, {}, {
|
||||
"btn": objblock,
|
||||
'VAR': argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
pbc.moduleFunctionD.get('mixgo.button_a')['get_presses'] = getpresses_converter('sensor_mixgo_button_get_presses');
|
||||
pbc.moduleFunctionD.get('mixgo.button_b')['get_presses'] = getpresses_converter('sensor_mixgo_button_get_presses');
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.touch1')['is_touched'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pin
|
||||
pbc.pinType = "number1";
|
||||
var objblock = py2block.convert(btn);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_mixgo_pin_pressed", func.lineno, {}, {
|
||||
"button":objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
pbc.moduleFunctionD.get('mixgo.touch2')['is_touched'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pin
|
||||
pbc.pinType = "number1";
|
||||
var objblock = py2block.convert(btn);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_mixgo_pin_pressed", func.lineno, {}, {
|
||||
"button":objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
pbc.moduleFunctionD.get('mixgo.touch3')['is_touched'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pin
|
||||
pbc.pinType = "number1";
|
||||
var objblock = py2block.convert(btn);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_mixgo_pin_pressed", func.lineno, {}, {
|
||||
"button":objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
pbc.moduleFunctionD.get('mixgo.touch4')['is_touched'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pin
|
||||
pbc.pinType = "number1";
|
||||
var objblock = py2block.convert(btn);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_mixgo_pin_pressed", func.lineno, {}, {
|
||||
"button":objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.infrared_left')['near'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
return block("sensor_mixgo_pin_near", func.lineno, {"direction":'left'}, {}, {
|
||||
"inline": "true"
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.infrared_right')['near'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
return block("sensor_mixgo_pin_near", func.lineno, {"direction":'right'}, {}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('near')['Infrared'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="Infrared" && mac==="mixgo"){
|
||||
|
||||
pbc.pinType = "pins_analog_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
|
||||
return block("sensor_mixgo_extern_pin_near", func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo')['get_brightness'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0 && args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
if (args.length == 0){
|
||||
return block("sensor_mixgo_light", func.lineno, {}, {}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
if (args.length == 1){
|
||||
pbc.pinType = "pins_analog_pin";
|
||||
var pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_mixgo_extern_light", func.lineno, {}, {
|
||||
'PIN':pinblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo')['get_soundlevel'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0 && args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
if (args.length == 0){
|
||||
return block("sensor_sound", func.lineno, {}, {}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
if (args.length == 1){
|
||||
pbc.pinType = "pins_analog_pin";
|
||||
var pinblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_mixgo_extern_sound", func.lineno, {}, {
|
||||
'PIN':pinblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.assignD.get('RTC')['check_assign'] = function(py2block, node, targets, value) {
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
value.args = value.args || [];
|
||||
if(value._astname === "Call" && moduleName === "machine" && funcName === "RTC" && !value.args.length)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('RTC')['create_block'] = function(py2block, node, targets, value){
|
||||
|
||||
var objblock=py2block.convert(targets[0]);
|
||||
|
||||
return [block("sensor_rtc_init", node.lineno, {}, {
|
||||
'SUB':objblock
|
||||
},
|
||||
{
|
||||
"inline":"true"
|
||||
}
|
||||
)];
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('datetime')['RTC'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
/*if (keywords.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}*/
|
||||
if(args.length==0){
|
||||
var objblock=py2block.convert(func.value);
|
||||
return block("RTC_get_time", func.lineno, {}, {
|
||||
'SUB':objblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
else if(args.length==1&&args[0]._astname=="Tuple"){
|
||||
|
||||
var objblock=py2block.convert(func.value);
|
||||
var yearblock=py2block.convert(args[0].elts[0])
|
||||
var monthblock=py2block.convert(args[0].elts[1])
|
||||
var dayblock=py2block.convert(args[0].elts[2])
|
||||
var weekdayblock=py2block.convert(args[0].elts[3])
|
||||
var hourblock=py2block.convert(args[0].elts[4])
|
||||
var minuteblock=py2block.convert(args[0].elts[5])
|
||||
var secondblock=py2block.convert(args[0].elts[6])
|
||||
var millisecondblock=py2block.convert(args[0].elts[7])
|
||||
|
||||
return [block("RTC_set_datetime", func.lineno, {}, {
|
||||
'SUB':objblock,
|
||||
'year':yearblock,
|
||||
'month':monthblock,
|
||||
'day':dayblock,
|
||||
'weekday':weekdayblock,
|
||||
'hour':hourblock,
|
||||
'minute':minuteblock,
|
||||
'second':secondblock,
|
||||
'millisecond':millisecondblock,
|
||||
}, {
|
||||
"inline": "false"
|
||||
})];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*I2C出现了一些问题，待解决*/
|
||||
pbc.assignD.get('i2c')['check_assign'] = function (py2block, node, targets, value) {
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
var moduleName = py2block.identifier(value.func.value.id);
|
||||
if (value._astname === "Call" && ['MPU9250', 'SHT20', 'BMP280', 'ADXL345'].indexOf(funcName) != -1
|
||||
&& ['mpu9250', 'sht20', 'bmp280', 'adxl345'].indexOf(moduleName) != -1 && value.args.length === 1)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
|
||||
}
|
||||
pbc.assignD.get('i2c')['create_block'] = function (py2block, node, targets, value) {
|
||||
var funcblock = py2block.identifier(value.func.attr);
|
||||
var mpublock = py2block.convert(targets[0]);
|
||||
var i2cblock = py2block.convert(value.args[0]);
|
||||
return block("sensor_use_i2c_init", node.lineno, { "key": funcblock }, {
|
||||
'I2CSUB': i2cblock,
|
||||
'SUB': mpublock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
function getAcceleration(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block('sensor_mpu9250_get_acceleration', func.lineno, {
|
||||
"key": mode
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('mpu9250_get_x')['mpu'] = getAcceleration('x');
|
||||
pbc.objectFunctionD.get('mpu9250_get_y')['mpu'] = getAcceleration('y');
|
||||
pbc.objectFunctionD.get('mpu9250_get_z')['mpu'] = getAcceleration('z');
|
||||
pbc.objectFunctionD.get('mpu9250_get_values')['mpu'] = getAcceleration('values');
|
||||
|
||||
function getADXLAcceleration(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block('sensor_adxl345_get_acceleration', func.lineno, {
|
||||
"key": mode
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('readX')['snsr'] = getADXLAcceleration('x');
|
||||
pbc.objectFunctionD.get('readY')['snsr'] = getADXLAcceleration('y');
|
||||
pbc.objectFunctionD.get('readZ')['snsr'] = getADXLAcceleration('z');
|
||||
pbc.objectFunctionD.get('readXYZ')['snsr'] = getADXLAcceleration('values');
|
||||
|
||||
function getMagnetic(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block('sensor_mpu9250_get_magnetic', func.lineno, {
|
||||
"key": mode
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('mpu9250_magnetic_x')['mpu'] = getMagnetic('x');
|
||||
pbc.objectFunctionD.get('mpu9250_magnetic_y')['mpu'] = getMagnetic('y');
|
||||
pbc.objectFunctionD.get('mpu9250_magnetic_z')['mpu'] = getMagnetic('z');
|
||||
pbc.objectFunctionD.get('mpu9250_magnetic_values')['mpu'] = getMagnetic('values');
|
||||
|
||||
function getGyro(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block('sensor_mpu9250_get_gyro', func.lineno, {
|
||||
"key": mode
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('mpu9250_gyro_x')['mpu'] = getGyro('x');
|
||||
pbc.objectFunctionD.get('mpu9250_gyro_y')['mpu'] = getGyro('y');
|
||||
pbc.objectFunctionD.get('mpu9250_gyro_z')['mpu'] = getGyro('z');
|
||||
pbc.objectFunctionD.get('mpu9250_gyro_values')['mpu'] = getGyro('values');
|
||||
|
||||
function sensorcompass(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block('sensor_mpu9250_field_strength', func.lineno, {
|
||||
"compass": mode
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('mpu9250_get_field_strength')['mpu'] = sensorcompass('strength');
|
||||
pbc.objectFunctionD.get('heading')['mpu'] = sensorcompass('heading');
|
||||
|
||||
pbc.objectFunctionD.get('mpu9250_get_temperature')['mpu'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block("sensor_mpu9250_temperature", func.lineno, {}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
function sensorBmp(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block('sensor_bmp', func.lineno, {
|
||||
"key": mode
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('get_BMP_temperature')['mpu'] = sensorBmp('get_BMP_temperature()');
|
||||
pbc.objectFunctionD.get('get_BMP_pressure')['mpu'] = sensorBmp('get_BMP_pressure()');
|
||||
|
||||
function sensorSht(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block('sensor_sht', func.lineno, {
|
||||
"key": mode
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('get_SHT_temperature')['mpu'] = sensorSht('get_SHT_temperature()');
|
||||
pbc.objectFunctionD.get('get_SHT_relative_humidity')['mpu'] = sensorSht('get_SHT_relative_humidity()');
|
||||
|
||||
|
||||
|
||||
function dht(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="pins_digital_pin";
|
||||
var pinblock=py2block.convert(args[1]);
|
||||
pbc.pinType=null;
|
||||
var dhtblock=py2block.identifier(args[0].s);
|
||||
return block('sensor_dht11', func.lineno, {
|
||||
'TYPE':dhtblock,
|
||||
'WHAT':mode
|
||||
}, {
|
||||
"PIN":pinblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('dhtx')['get_dht_temperature'] = dht('temperature');
|
||||
pbc.moduleFunctionD.get('dhtx')['get_dht_relative_humidity'] = dht('relative_humidity');
|
||||
pbc.moduleFunctionD.get('dhtx')['get_dht_tempandhum'] = dht('tempandhum');
|
||||
|
||||
|
||||
|
||||
pbc.objectFunctionD.get('checkdist')['sonar'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (func.value.args.length !== 2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="pins_digital_pin";
|
||||
var trigblock=py2block.convert(func.value.args[0]);
|
||||
var echoblock=py2block.convert(func.value.args[1]);
|
||||
pbc.pinType=null;
|
||||
return block("HCSR04", func.lineno, {}, {
|
||||
"PIN1":trigblock,
|
||||
"PIN2":echoblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
pbc.objectFunctionD.get('mpu9250_is_gesture')['mpu'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var gesblock=py2block.identifier(args[0].s);
|
||||
var mpublock=py2block.convert(func.value)
|
||||
return block("sensor_mpu9250_gesture", func.lineno, {
|
||||
'gesture':gesblock
|
||||
}, {
|
||||
'SUB': mpublock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.button_a')['irq'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0 || keywords.length!==2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pinType="pins_button";
|
||||
var objblock=py2block.convert(btn);
|
||||
pbc.pinType=null;
|
||||
var irq=py2block.identifier(keywords[1].value.attr);
|
||||
var pin=py2block.identifier(keywords[1].value.value.attr);
|
||||
var mac=py2block.identifier(keywords[1].value.value.value.id)
|
||||
|
||||
|
||||
var mode = mac+"."+pin+"."+py2block.identifier(keywords[1].value.attr);
|
||||
|
||||
pbc.pinType = "pins_callback";
|
||||
var callback = py2block.convert(keywords[0].value);
|
||||
pbc.pinType = null;
|
||||
|
||||
return [block("sensor_mixgo_button_attachInterrupt", func.lineno, {"mode":mode}, {
|
||||
"btn": objblock,
|
||||
"DO": callback
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('mixgo.button_b')['irq'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 0 || keywords.length!==2) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
|
||||
var btn = {
|
||||
'_astname': 'Name',
|
||||
'id': {
|
||||
'_astname': 'Str',
|
||||
'v': py2block.identifier(func.value.attr)
|
||||
}
|
||||
};
|
||||
pbc.pinType="pins_button";
|
||||
var objblock=py2block.convert(btn);
|
||||
pbc.pinType=null;
|
||||
var irq=py2block.identifier(keywords[1].value.attr);
|
||||
var pin=py2block.identifier(keywords[1].value.value.attr);
|
||||
var mac=py2block.identifier(keywords[1].value.value.value.id)
|
||||
|
||||
|
||||
var mode = mac+"."+pin+"."+py2block.identifier(keywords[1].value.attr);
|
||||
|
||||
pbc.pinType = "pins_callback";
|
||||
var callback = py2block.convert(keywords[0].value);
|
||||
pbc.pinType = null;
|
||||
|
||||
return [block("sensor_mixgo_button_attachInterrupt", func.lineno, {"mode":mode}, {
|
||||
"btn": objblock,
|
||||
"DO": callback
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('was_pressed')['Button'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="Button" && mac==="mixgo"){
|
||||
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
pbc.pinType = "pins_digital";
|
||||
var argblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
return block('sensor_mixgo_extern_button_was_pressed', func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
"STAT": argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('get_presses')['Button'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="Button" && mac==="mixgo"){
|
||||
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
var argblock = py2block.convert(args[0]);
|
||||
return block('sensor_mixgo_extern_button_get_presses', func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
'VAR':argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('is_pressed')['Button'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var pin=py2block.identifier(func.value.func.attr);
|
||||
var mac=py2block.identifier(func.value.func.value.id);
|
||||
if(pin==="Button" && mac==="mixgo"){
|
||||
|
||||
pbc.pinType = "pins_digital_pin";
|
||||
var pinblock = py2block.convert(func.value.args[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
pbc.pinType = "pins_digital";
|
||||
var argblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
|
||||
return block('sensor_mixgo_extern_button_is_pressed', func.lineno, {}, {
|
||||
"PIN": pinblock,
|
||||
"STAT": argblock
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pbc.moduleFunctionD.get('ds18x20x')['get_ds18x20_temperature'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="pins_digital_pin";
|
||||
var argblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_ds18x20", func.lineno, {}, {
|
||||
"PIN":argblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
pbc.objectFunctionD.get('calibrate')['mpu'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return [block("sensor_mpu9250_calibrate_compass", func.lineno, {}, {
|
||||
"SUB": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
};
|
||||
|
||||
pbc.objectFunctionD.get('reset_calibrate')['mpu'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 0) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var objblock = py2block.convert(func.value);
|
||||
return [block("sensor_compass_reset", func.lineno, {}, {
|
||||
"SUB": objblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
};
|
||||
|
||||
pbc.moduleFunctionD.get('lm35')['get_LM35_temperature'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
pbc.pinType="pins_analog_pin";
|
||||
var argblock = py2block.convert(args[0]);
|
||||
pbc.pinType = null;
|
||||
return block("sensor_lm35", func.lineno, {}, {
|
||||
"PIN":argblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
198
boards/default_src/micropython/converters/serial.js
Normal file
198
boards/default_src/micropython/converters/serial.js
Normal file
@@ -0,0 +1,198 @@
|
||||
|
||||
pbc.globalFunctionD['print'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length === 1 && keywords.length === 1
|
||||
&& py2block.identifier(keywords[0].arg) === "end"
|
||||
&& keywords[0].value._astname === "Str"
|
||||
//&& py2block.Str_value(keywords[0].value) === ""
|
||||
){ if(py2block.Str_value(keywords[0].value) === ""){
|
||||
var argblock = py2block.convert(args[0]);
|
||||
return [block("system_print_inline", func.lineno, {}, {
|
||||
'VAR':argblock
|
||||
}, {
|
||||
"inline": "false"
|
||||
})];
|
||||
}
|
||||
else{
|
||||
var argblock = py2block.convert(args[0]);
|
||||
return [block("system_print_end", func.lineno, {
|
||||
}, {
|
||||
'VAR':argblock,
|
||||
'END':py2block.convert(keywords[0].value)
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
}else if (args.length === 1 && keywords.length === 0) {
|
||||
var argblock = py2block.convert(args[0]);
|
||||
return [block("system_print", func.lineno, {}, {
|
||||
'VAR':argblock
|
||||
}, {
|
||||
"inline": "false"
|
||||
})];
|
||||
}else if (args.length != 1 && keywords.length === 0) { //print()
|
||||
var d = py2block.convertElements("ADD", args);
|
||||
|
||||
return [block("system_print_many", node.lineno, {
|
||||
}, d, {
|
||||
"inline": "true",
|
||||
}, {
|
||||
"@items":args.length
|
||||
})];
|
||||
|
||||
}else{
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pbc.globalFunctionD['input'] = function(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var argblock = py2block.convert(args[0]);
|
||||
return block("system_input", func.lineno, {}, {
|
||||
'VAR':argblock
|
||||
}, {
|
||||
"inline": "false"
|
||||
});
|
||||
}
|
||||
pbc.assignD.get('UART')['check_assign'] = function(py2block, node, targets, value) {
|
||||
if(value._astname != "Call" || value.func._astname != "Attribute" || value.func.value._astname != "Name"){
|
||||
return false;
|
||||
}
|
||||
var moduleName = py2block.Name_str(value.func.value);
|
||||
var funcName = py2block.identifier(value.func.attr);
|
||||
if(value._astname === "Call" && moduleName === "machine"
|
||||
&& funcName === "UART" && value.args.length === 2)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pbc.assignD.get('UART')['create_block'] = function(py2block, node, targets, value){
|
||||
pbc.pinType = "serial_print";
|
||||
var pinblock = py2block.identifier(value.args[0].n);
|
||||
var countblock = py2block.identifier(value.args[1].n);
|
||||
pbc.pinType = null;
|
||||
return block("serial_softserial", node.lineno, {
|
||||
"mode":pinblock,
|
||||
'baudrate':countblock
|
||||
}, { },
|
||||
{
|
||||
"inline":"true"
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
function serial_write(mode){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if (args.length !== 1) {
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
var astname = args[0]._astname;
|
||||
if(astname === "Call"){
|
||||
if(args[0].func._astname == "Name" && py2block.Name_str(args[0].func) === "str"){ //serial.write(str("XXX"))
|
||||
return [block("serial_print", func.lineno, {
|
||||
"mode":mode
|
||||
}, {
|
||||
"CONTENT":py2block.convert(args[0].args[0]),
|
||||
}, {
|
||||
"inline": "false"
|
||||
})];
|
||||
}
|
||||
}else if(astname === "BinOp"){
|
||||
if(args[0].op.name === "Add" && args[0].right._astname === "Str"
|
||||
&& py2block.Str_value(args[0].right) === "\r\n"
|
||||
&& args[0].left._astname === "Call" && args[0].left.func._astname == "Name"
|
||||
&& py2block.Name_str(args[0].left.func) === "str"
|
||||
){
|
||||
if(args[0].left.args[0]._astname === "Call"
|
||||
&& args[0].left.args[0].func._astname === "Name"
|
||||
&& py2block.Name_str(args[0].left.args[0].func) in {"hex":16,"bin":2,"oct":8}){
|
||||
//serial.write(str(hex(XX)) + "\r\n")
|
||||
pbc.inScope = "lcd_init";
|
||||
var numblock=py2block.convert(args[0].left.args[0].args[0]);
|
||||
pbc.inScope=null;
|
||||
return [block("serial_print_hex", func.lineno, {
|
||||
"mode":mode,
|
||||
"STAT":py2block.Name_str(args[0].left.args[0].func),
|
||||
}, {
|
||||
"CONTENT":numblock,
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}else{
|
||||
return [block("serial_println", func.lineno, {
|
||||
"mode":mode
|
||||
}, { //serial.write(str("XX") + "\r\n")
|
||||
"CONTENT": py2block.convert(args[0].left.args[0]),
|
||||
}, {
|
||||
"inline": "false"
|
||||
})];
|
||||
}
|
||||
}
|
||||
}
|
||||
return [block("serial_print", func.lineno, {}, {
|
||||
"CONTENT":py2block.convert(args[0]),
|
||||
}, {
|
||||
"inline": "true"
|
||||
})];
|
||||
}
|
||||
return converter
|
||||
}
|
||||
pbc.moduleFunctionD.get('uart0')['write'] = serial_write('0')
|
||||
pbc.moduleFunctionD.get('uart1')['write'] = serial_write('1')
|
||||
pbc.moduleFunctionD.get('uart2')['write'] = serial_write('2')
|
||||
|
||||
pbc.assignD.get('uart0')['check_assign'] = function (py2block, node, targets, value) {
|
||||
var funcName = py2block.identifier(value.func.id);
|
||||
if (value._astname === "Call"&& funcName === "UART" && value.args.length === 2)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
pbc.assignD.get('uart0')['create_block'] = function (py2block, node, targets, value) {
|
||||
pbc.pinType = 'serial_print';
|
||||
var argblock1 = py2block.convert(value.args[1])
|
||||
mode=targets[0].id.v
|
||||
if (mode=="uart0"){
|
||||
mode='0'
|
||||
}
|
||||
else if(mode=="uart1"){
|
||||
mode='1'
|
||||
}
|
||||
else if(mode=="uart2"){
|
||||
mode='2'
|
||||
}
|
||||
return block("serial_softserial", node.lineno, {
|
||||
"mode":mode
|
||||
}, {
|
||||
"CONTENT":py2block.convert(value.args[0]),
|
||||
"TEXT":argblock1,
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
|
||||
function getSerial(mode,fun_type){
|
||||
function converter(py2block, func, args, keywords, starargs, kwargs, node){
|
||||
if(args.length !==0){
|
||||
throw new Error("Incorrect number of arguments");
|
||||
}
|
||||
return block(fun_type, func.lineno, {
|
||||
"mode":mode
|
||||
}, {
|
||||
}, {
|
||||
"inline": "true"
|
||||
});
|
||||
}
|
||||
return converter;
|
||||
}
|
||||
pbc.moduleFunctionD.get('uart0')['any'] = getSerial('0','serial_any')
|
||||
pbc.moduleFunctionD.get('uart1')['any'] = getSerial('1','serial_any')
|
||||
pbc.moduleFunctionD.get('uart2')['any'] = getSerial('2','serial_any')
|
||||
pbc.moduleFunctionD.get('uart0')['read'] = getSerial('0','serial_readstr')
|
||||
pbc.moduleFunctionD.get('uart1')['read'] = getSerial('1','serial_readstr')
|
||||
pbc.moduleFunctionD.get('uart2')['read'] = getSerial('2','serial_readstr')
|
||||
pbc.moduleFunctionD.get('uart0')['readline'] = getSerial('0','serial_readline')
|
||||
pbc.moduleFunctionD.get('uart1')['readline'] = getSerial('1','serial_readline')
|
||||
pbc.moduleFunctionD.get('uart2')['readline'] = getSerial('2','serial_readline')
|
||||
|
||||
Reference in New Issue
Block a user