初始化提交

boards/default_src/micropython_k210_mixgoai/generators/actuator.js

@@ -0,0 +1,112 @@
+export const actuator_Servo_init = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    generator.definitions_['from machine import PWM'] = 'from machine import PWM';
+    generator.definitions_['from machine import Timer'] = 'from machine import Timer';
+    var key = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var Timer = time % 3
+    var CHANNEL = parseInt(time / 3)
+    var code1 = 'tim' + time + ' = Timer(Timer.TIMER' + Timer + ',Timer.CHANNEL' + CHANNEL + ', mode=Timer.MODE_PWM)\n';
+    var code2 = 'pse' + key + '=PWM(tim' + time + ', freq=50, duty=2.5, pin=' + key + ')\n';
+    return code1 + code2;
+}
+
+export const actuator_Servo = function (_, generator) {
+    generator.definitions_['from machine import PWM'] = 'from machine import PWM';
+    var key = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(this, 'range', generator.ORDER_ATOMIC);
+    var code = "pse" + key + ".duty(" + range + "/18.0+2.5)\n";
+    return code;
+}
+
+export const actuator_PAC9685_init = function (_, generator) {
+    generator.definitions_['from servo import Servos'] = 'from servo import Servos';
+    var address = generator.valueToCode(this, 'address', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = 'servos=Servos(' + sub + ',address=' + address + ')\n';
+    return code;
+}
+
+export const actuator_PAC9685_Servo = function (_, generator) {
+    generator.definitions_['from servo import Servos'] = 'from servo import Servos';
+    var index = generator.valueToCode(this, 'index', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(this, 'range', generator.ORDER_ATOMIC);
+    // var index=index-1;
+    var code = "servos.position((" + index + "-1)," + range + ")\n";
+    return code;
+}
+
+export const actuator_rgb_init = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    generator.definitions_['from modules import ws2812'] = 'from modules import ws2812';
+    var SUB = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'num', generator.ORDER_ATOMIC);
+    var code = '' + SUB + '=ws2812(' + key + ',' + num + ')\n';
+    return code;
+}
+
+export const actuator_rgb_set = function (_, generator) {
+    var SUB = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var R = generator.valueToCode(this, 'R', generator.ORDER_ATOMIC);
+    var G = generator.valueToCode(this, 'G', generator.ORDER_ATOMIC);
+    var B = generator.valueToCode(this, 'B', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'num', generator.ORDER_ATOMIC);
+    var code = '' + SUB + '.set_led(' + num + ',(' + G + ',' + R + ',' + B + '))\n';
+    return code;
+}
+
+export const actuator_rgb_display = function (_, generator) {
+    var SUB = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = '' + SUB + '.display()\n';
+    return code;
+}
+
+export const actuator_ms32006_init = function (_, generator) {
+    generator.definitions_['import ms32006'] = 'import ms32006';
+    var address = this.getFieldValue('mode')
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var sub1 = generator.valueToCode(this, 'SUB1', generator.ORDER_ATOMIC);
+    var code = '' + sub + '=ms32006.MS32006(' + sub1 + ',addr=' + address + ')\n';
+    return code;
+}
+
+export const actuator_ms32006_dcmotor = function (_, generator) {
+    generator.definitions_['import ms32006'] = 'import ms32006';
+    var direction = this.getFieldValue('direction')
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = '' + sub + '.dc_motor(' + direction + ',' + speed + ')\n';
+    return code;
+}
+
+export const actuator_ms32006_stepper = function (_, generator) {
+    generator.definitions_['import ms32006'] = 'import ms32006';
+    var mode = this.getFieldValue('mode')
+    var direction = this.getFieldValue('direction')
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var steps = generator.valueToCode(this, 'steps', generator.ORDER_ATOMIC);
+    var code = '' + sub + '.move(' + mode + ',' + direction + ',' + speed + ',' + steps + ')\n';
+    return code;
+}
+
+//-新20211221------PID算法，暂时放此处------------------------------------------//
+export const PID_init = function (_, generator) {
+    generator.definitions_['import pid'] = 'import pid';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var P = generator.valueToCode(this, 'P', generator.ORDER_ATOMIC);
+    var I = generator.valueToCode(this, 'I', generator.ORDER_ATOMIC);
+    var D = generator.valueToCode(this, 'D', generator.ORDER_ATOMIC);
+    var code = "" + sub + "=pid.PID(" + P + "," + I + "," + D + ")\n";
+    return code;
+}
+//-新20211221------PID算法，暂时放此处------------------------------------------//
+export const PID_get_pid = function (_, generator) {
+    generator.definitions_['import pid'] = 'import pid';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var error = generator.valueToCode(this, 'error', generator.ORDER_ATOMIC);
+    var scaler = generator.valueToCode(this, 'scaler', generator.ORDER_ATOMIC);
+    var code = "" + sub + ".get_pid(" + error + "," + scaler + ")";
+    return [code, generator.ORDER_ATOMIC];
+}

boards/default_src/micropython_k210_mixgoai/generators/ai.js

@@ -0,0 +1,149 @@
+import * as Blockly from 'blockly/core';
+
+export const tuple_anchor = function (_, generator) {
+    var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
+        Blockly.Variables.NAME_TYPE);
+    var text = this.getFieldValue('TEXT');
+    var code = varName + '= ' + '(' + text + ')\n';
+    return code;
+}
+
+export const tuple_calss = function (_, generator) {
+    var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
+        Blockly.Variables.NAME_TYPE);
+    var text = this.getFieldValue('TEXT');
+    var code = varName + '= ' + '[' + text + ']\n';
+    return code;
+}
+
+export const KPU_load = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    generator.definitions_['import_KPU'] = 'import KPU as kpu';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var code = sub + " = kpu.load(" + path + ")\n";
+    return code;
+}
+
+export const KPU_load1 = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    generator.definitions_['import_KPU'] = 'import KPU as kpu';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var code = sub + " = kpu.load(" + path + ")\n";
+    return code;
+}
+
+export const KPU_init_yolo2 = function (_, generator) {
+    generator.definitions_['import_KPU'] = 'import KPU as kpu';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var th = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var nm = generator.valueToCode(this, 'nms_value', generator.ORDER_ATOMIC);
+    var an = generator.valueToCode(this, 'anchor_num', generator.ORDER_ATOMIC);
+    var anchor = generator.valueToCode(this, 'anchor', generator.ORDER_ATOMIC);
+    var code = "kpu.init_yolo2(" + sub + "," + th + "," + nm + "," + an + "," + anchor + ")\n";
+    return code;
+}
+
+export const KPU_run_yolo2 = function (_, generator) {
+    generator.definitions_['import_KPU'] = 'import KPU as kpu';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var img = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "kpu.run_yolo2(" + sub + "," + img + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const KPU_forward = function (_, generator) {
+    generator.definitions_['import_KPU'] = 'import KPU as kpu';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var img = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "kpu.forward(" + sub + "," + img + ")[:]";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const KPU_analysis = function (_, generator) {
+    generator.definitions_['import_KPU'] = 'import KPU as kpu';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const aionenet_nic_init = function (_, generator) {
+    generator.definitions_['import aionenet'] = 'import aionenet';
+    var account = generator.valueToCode(this, 'account', generator.ORDER_ATOMIC);
+    var passwor = generator.valueToCode(this, 'password', generator.ORDER_ATOMIC);
+    var code = "aionenet.nic_init(" + account + "," + passwor + ")\n";
+    return code;
+}
+
+export const aionenet_token = function (_, generator) {
+    generator.definitions_['import aionenet'] = 'import aionenet';
+    var account = generator.valueToCode(this, 'account', generator.ORDER_ATOMIC);
+    var passwor = generator.valueToCode(this, 'password', generator.ORDER_ATOMIC);
+    var code = "aionenet.token(" + account + "," + passwor + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const aionenet_API = function (_, generator) {
+    generator.definitions_['import aionenet'] = 'import aionenet';
+    var img = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var token = generator.valueToCode(this, 'token', generator.ORDER_ATOMIC);
+    var api = this.getFieldValue('api');
+    var code = 'aionenet.post_ai(' + img + ',"' + api + '",' + token + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+///---------------------------------------------------------------
+export const ailocal_training = function (_, generator) {
+    generator.definitions_['import ailocal'] = 'import ailocal';
+    var calss = generator.valueToCode(this, 'calss', generator.ORDER_ATOMIC);
+    var sample = generator.valueToCode(this, 'sample', generator.ORDER_ATOMIC);
+    var save = generator.valueToCode(this, 'save', generator.ORDER_ATOMIC);
+    var code = "ailocal.training(" + calss + "," + sample + "," + save + ")\n";
+    return code;
+}
+
+export const ailocal_loading = function (_, generator) {
+    generator.definitions_['import ailocal'] = 'import ailocal';
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var code = "ailocal.loading(" + path + ")\n";
+    return code;
+}
+
+export const ailocal_predict = function (_, generator) {
+    generator.definitions_['import ailocal'] = 'import ailocal';
+    var calss = generator.valueToCode(this, 'calss', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "ailocal.predict(" + sub + "," + calss + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//---开始------------新增---20210302---------------------------------------------------
+
+export const ai_face_init = function (_, generator) {
+    generator.definitions_['import ai_face'] = 'import ai_face';
+    var FD = generator.valueToCode(this, 'FD', generator.ORDER_ATOMIC);
+    var LD = generator.valueToCode(this, 'LD', generator.ORDER_ATOMIC);
+    var FE = generator.valueToCode(this, 'FE', generator.ORDER_ATOMIC);
+    var code = "ai_face.init(" + FD + "," + LD + "," + FE + ")\n";
+    return code;
+}
+
+export const ai_face_train = function (_, generator) {
+    generator.definitions_['import ai_face'] = 'import ai_face';
+    var img = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var names = generator.valueToCode(this, 'names', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var code = 'ai_face.train(' + img + ',' + names + ',' + threshold + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_face_info = function (_, generator) {
+    generator.definitions_['import ai_face'] = 'import ai_face';
+    var key = this.getFieldValue('key');
+    var code = 'ai_face.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//---开始------------新增---20210302---------------------------------------------------

boards/default_src/micropython_k210_mixgoai/generators/av.js

@@ -0,0 +1,55 @@
+export const spk_init = function (_, generator) {
+    generator.definitions_['import player'] = 'import player';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var BCK = generator.valueToCode(this, 'BCK', generator.ORDER_ATOMIC);
+    var WS = generator.valueToCode(this, 'WS', generator.ORDER_ATOMIC);
+    var DAT = generator.valueToCode(this, 'DAT', generator.ORDER_ATOMIC);
+    var code = "" + sub + "=player.spk_init(" + BCK + "," + WS + "," + DAT + ")\n";
+    return code;
+}
+
+export const mic_init = function (_, generator) {
+    generator.definitions_['import player'] = 'import player';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    // var BCK = generator.valueToCode(this, 'BCK',generator.ORDER_ATOMIC);
+    // var WS = generator.valueToCode(this, 'WS',generator.ORDER_ATOMIC);
+    // var DAT = generator.valueToCode(this, 'DAT',generator.ORDER_ATOMIC);
+    var code = "" + sub + "=player.mic_init()\n";
+    return code;
+}
+
+export const audio_play = function (_, generator) {
+    generator.definitions_['import player'] = 'import player';
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var volume = generator.valueToCode(this, 'volume', generator.ORDER_ATOMIC);
+    var code = "player.audio_play(" + sub + "," + path + "," + volume + ")\n";
+    return code;
+}
+
+export const audio_record = function (_, generator) {
+    generator.definitions_['import player'] = 'import player';
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = "player.audio_record(" + sub + "," + path + "," + time + ")\n";
+    return code;
+}
+
+export const video_play = function (_, generator) {
+    generator.definitions_['import player'] = 'import player';
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var volume = generator.valueToCode(this, 'volume', generator.ORDER_ATOMIC);
+    var code = "player.video_play(" + sub + "," + path + "," + volume + ")\n";
+    return code;
+}
+
+export const video_record = function (_, generator) {
+    generator.definitions_['import player'] = 'import player';
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var code = "player.video_record(" + sub + "," + path + "," + time + ")\n";
+    return code;
+}

boards/default_src/micropython_k210_mixgoai/generators/camera.js

@@ -0,0 +1,115 @@
+export const mode = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const size = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const camera_init = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key1 = generator.valueToCode(this, 'key1', generator.ORDER_ATOMIC);
+    var key2 = generator.valueToCode(this, 'key2', generator.ORDER_ATOMIC);
+    var key3 = generator.valueToCode(this, 'key3', generator.ORDER_ATOMIC);
+    var key4 = generator.valueToCode(this, 'key4', generator.ORDER_ATOMIC);
+    var code1 = "sensor.reset()\n";
+    var code2 = "sensor.set_pixformat(" + key1 + ")\n";
+    var code3 = "sensor.set_framesize(" + key2 + ")\n";
+    var code4 = "sensor.run(" + key3 + ")\n";
+    var code5 = "sensor.skip_frames(" + key4 + ")\n";
+    var code = code1 + code2 + code3 + code4 + code5;
+    return code;
+}
+
+export const camera_reset = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var code = "sensor.reset()\n";
+    return code;
+}
+
+export const camera_set_pixformat = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "sensor.set_pixformat(" + key + ")\n";
+    return code;
+}
+
+export const camera_set_framesize = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "sensor.set_framesize(" + key + ")\n";
+    return code;
+}
+
+export const camera_run = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "sensor.run(" + key + ")\n";
+    return code;
+}
+
+export const camera_skip_frames = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var frame = generator.valueToCode(this, 'frame', generator.ORDER_ATOMIC);
+    var code = "sensor.skip_frames(n=" + frame + ")\n";
+    return code;
+}
+
+export const camera_snapshot = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var code = 'sensor.snapshot()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const camera_shutdown = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "sensor.shutdown(" + key + ")\n";
+    return code;
+}
+
+export const camera_set_hmirror = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "sensor.set_hmirror(" + key + ")\n";
+    return code;
+}
+
+export const camera_set_vflip = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "sensor.set_vflip(" + key + ")\n";
+    return code;
+}
+
+export const camera_set_colorbar = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "sensor.set_colorbar(" + key + ")\n";
+    return code;
+}
+
+export const camera_getinfo = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = this.getFieldValue('key');
+    var code = "sensor." + key + "()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const camera_setmun = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var key = this.getFieldValue('key');
+    var num = generator.valueToCode(this, 'num', generator.ORDER_ATOMIC);
+    var code = "sensor." + key + "(" + num + ")\n";
+    return code;
+}
+
+export const camera_set_windowing = function (_, generator) {
+    generator.definitions_['import_sensor'] = 'import sensor';
+    var numa = generator.valueToCode(this, 'numa', generator.ORDER_ATOMIC);
+    var numb = generator.valueToCode(this, 'numb', generator.ORDER_ATOMIC);
+    var code = "sensor.set_windowing((" + numa + "," + numb + "))\n";
+    return code;
+}

boards/default_src/micropython_k210_mixgoai/generators/communicate.js

@@ -0,0 +1,177 @@
+export const communicate_ir_recv = function (_, generator) {
+    generator.definitions_['import irremote'] = 'import irremote';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    return ["irremote.read_id(" + pin + ")", generator.ORDER_ATOMIC];
+}
+
+export const communicate_i2c_init = function (_, generator) {
+    generator.definitions_['from machine import I2C'] = 'from machine import I2C';
+    var mode = this.getFieldValue('mode');
+    var freq = generator.valueToCode(this, 'freq', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var sda = generator.valueToCode(this, 'RX', generator.ORDER_ATOMIC);
+    var scl = generator.valueToCode(this, 'TX', generator.ORDER_ATOMIC);
+    return "" + sub + " = I2C(I2C." + mode + ", freq=" + freq + ", scl=" + scl + ", sda=" + sda + ")\n";
+}
+
+export const communicate_i2s_init = function (_, generator) {
+    generator.definitions_['import player'] = 'import player';
+    var mode = this.getFieldValue('mode');
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var BCK = generator.valueToCode(this, 'BCK', generator.ORDER_ATOMIC);
+    var WS = generator.valueToCode(this, 'WS', generator.ORDER_ATOMIC);
+    var DAT = generator.valueToCode(this, 'DAT', generator.ORDER_ATOMIC);
+    var sample = generator.valueToCode(this, 'sample', generator.ORDER_ATOMIC);
+    var code = "" + sub + "=player." + mode + "_init(" + BCK + "," + WS + "," + DAT + "," + sample + ")\n";
+    return code;
+}
+//--------新增-------------------------------------------------------
+
+export const communicate_i2c_read = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var address = generator.valueToCode(this, 'address', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return ["" + name + ".readfrom(" + address + ", " + data + ")", generator.ORDER_ATOMIC];
+}
+
+export const communicate_i2c_write = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var address = generator.valueToCode(this, 'address', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return "" + name + ".writeto(" + address + ", " + data + ")\n";
+}
+
+export const communicate_i2c_scan = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return ["" + name + ".scan()", generator.ORDER_ATOMIC];
+}
+export const communicate_i2c_master_read = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + name + ".read()";
+    return [code, generator.ORDER_ATOMIC];
+}
+export const communicate_i2c_available = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + name + ".available()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const i2c_slave_onreceive = function (_, generator) {
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    generator.setups_['setup_i2c_' + pin] = 'Wire.begin(' + pin + ');';
+    generator.setups_['setup_i2c_onReceive_' + pin] = 'Wire.onReceive(i2cReceiveEvent_' + pin + ');';
+    var funcName = 'i2cReceiveEvent_' + pin;
+    var branch = generator.statementToCode(this, 'DO');
+    var code2 = 'void' + ' ' + funcName + '(int howMany) {\n' + branch + '}\n';
+    generator.definitions_[funcName] = code2;
+    return '';
+}
+
+export const communicate_spi_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var freq = generator.valueToCode(this, 'freq', generator.ORDER_ATOMIC);
+    var polarity = generator.valueToCode(this, 'polarity', generator.ORDER_ATOMIC);
+    var phase = generator.valueToCode(this, 'phase', generator.ORDER_ATOMIC);
+    var mosi = generator.valueToCode(this, 'mosi', generator.ORDER_ATOMIC);
+    var miso = generator.valueToCode(this, 'miso', generator.ORDER_ATOMIC);
+    var sck = generator.valueToCode(this, 'sck', generator.ORDER_ATOMIC);
+    return "" + name + " = machine.SPI(baudrate=" + freq + ", polarity=" + polarity + ", phase=" + phase + ", sck=machine.Pin(" + sck + "), mosi=machine.Pin(" + mosi + "), miso=machine.Pin(" + miso + "));\n";
+}
+
+export const communicate_spi_set = function (_, generator) {
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return "spi.init(baudrate=" + data + ")\n";
+}
+
+export const communicate_spi_buffer = function (_, generator) {
+    var varname = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return "" + varname + "=bytearray(" + data + ")\n";
+}
+
+export const communicate_spi_read = function (_, generator) {
+    var varname = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return ["" + varname + ".read(" + data + ")", generator.ORDER_ATOMIC];
+}
+
+export const communicate_spi_read_output = function (_, generator) {
+    var varname = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var val = generator.valueToCode(this, 'val', generator.ORDER_ATOMIC);
+    return ["" + varname + ".read(" + data + "," + val + ")", generator.ORDER_ATOMIC];
+}
+
+export const communicate_spi_readinto = function (_, generator) {
+    var varname = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return ["" + varname + ".readinto(" + data + ")", generator.ORDER_ATOMIC];
+}
+
+export const communicate_spi_readinto_output = function (_, generator) {
+    var varname = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var val = generator.valueToCode(this, 'val', generator.ORDER_ATOMIC);
+    return ["" + varname + ".readinto(" + data + "," + val + ")", generator.ORDER_ATOMIC];
+}
+
+export const communicate_spi_write = function (_, generator) {
+    var varname = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return ["" + varname + ".write(" + data + ".encode('utf-8'))", generator.ORDER_ATOMIC];
+}
+
+export const communicate_spi_write_readinto = function (_, generator) {
+    var varname = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var val = generator.valueToCode(this, 'val', generator.ORDER_ATOMIC);
+    // var op=this.getFieldValue('op');
+    // if(op=="byte"){
+    return ["" + varname + ".write_readinto(" + data + ".encode('utf-8')," + val + ")", generator.ORDER_ATOMIC];
+    // }else{
+    //   return [""+varname+".write_readinto(" + data + ","+val+")", generator.ORDER_ATOMIC];
+    // }
+}
+
+export const communicate_ow_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_onewire'] = "import onewire";
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var varName = generator.valueToCode(this, 'BUS', generator.ORDER_ATOMIC);
+    var code = "" + name + "=onewire.OneWire(machine.Pin(" + varName + "))\n";
+    return code;
+}
+
+export const communicate_ow_scan = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + name + ".scan()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_ow_reset = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + name + ".reset()\n";
+    return code;
+}
+
+export const communicate_ow_read = function (_, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + name + ".readbyte()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_ow_write = function (_, generator) {
+    var varName = generator.valueToCode(this, 'byte', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var op = this.getFieldValue('op');
+    var code = "" + name + "." + op + "(" + varName + ")\n";
+    return code;
+}
+
+export const communicate_ow_select = function (_, generator) {
+    var varName = generator.valueToCode(this, 'byte', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + name + ".select_rom(" + varName + ".encode('utf-8'))\n";
+    return code;
+}

boards/default_src/micropython_k210_mixgoai/generators/display.js

@@ -0,0 +1,105 @@
+export const angle = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const lcd_color = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const on_off = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const lcd_init = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var freq = generator.valueToCode(this, 'freq', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var code = "lcd.init(freq=" + freq + ",color=" + color + ")\n";
+    return code;
+}
+
+export const lcd_colour = function (_, generator) {
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "" + key + "";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const lcd_width = function (_, generator) {
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var key = this.getFieldValue('key');
+    var code = 'lcd.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const lcd_display = function (_, generator) {
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var img = generator.valueToCode(this, 'img', generator.ORDER_ATOMIC);
+    var code = "lcd.display(" + img + ")\n";
+    return code;
+}
+
+export const lcd_clear = function (_, generator) {
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var code = "lcd.clear(" + color + ")\n";
+    return code;
+}
+
+export const lcd_rotation = function (_, generator) {
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "lcd.rotation(" + key + ")\n";
+    return code;
+}
+
+export const lcd_mirror = function (_, generator) {
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = "lcd.mirror(" + key + ")\n";
+    return code;
+}
+
+export const lcd_draw_string = function (_, generator) {
+    generator.definitions_['import_lcd'] = 'import lcd';
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var tex = generator.valueToCode(this, 'text', generator.ORDER_ATOMIC);
+    var color_T = generator.valueToCode(this, 'color_T', generator.ORDER_ATOMIC);
+    var color_S = generator.valueToCode(this, 'color_S', generator.ORDER_ATOMIC);
+    var code = "lcd.draw_string(" + x + "," + y + "," + tex + "," + color_T + "," + color_S + ")\n";
+    return code;
+}
+
+export const touch_init = function (_, generator) {
+    generator.definitions_['import_touchscreen'] = 'import touchscreen as ts';
+    var I2C = generator.valueToCode(this, 'I2C', generator.ORDER_ATOMIC);
+    var code = "ts.init(" + I2C + ")\n";
+    return code;
+}
+
+export const touch_calibrate = function (_, generator) {
+    generator.definitions_['import_touchscreen'] = 'import touchscreen as ts';
+    var code = "ts.calibrate()\n";
+    return code;
+}
+
+export const touch_read = function (_, generator) {
+    generator.definitions_['import_touchscreen'] = 'import touchscreen as ts';
+    var key = this.getFieldValue('key');
+    var code = 'ts.read()' + key + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const touch_info = function (_, generator) {
+    generator.definitions_['import_touchscreen'] = 'import touchscreen as ts';
+    var key = this.getFieldValue('key');
+    var code = '' + key + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+/**/

boards/default_src/micropython_k210_mixgoai/generators/factory.js

@@ -0,0 +1,91 @@
+export const factory_from_import = function (_, generator) {
+    var path = this.getFieldValue('path');
+    var module = this.getFieldValue('module');
+    generator.definitions_['import_' + path + '_' + module] = 'from ' + path + ' import ' + module;
+    return '';
+}
+
+export const factory_import = function (_, generator) {
+    var module = this.getFieldValue('module');
+    generator.definitions_['import_' + module] = 'import ' + module;
+    return '';
+}
+
+export const factory_function_noreturn = function (_, generator) {
+    var NAME = this.getFieldValue('NAME');
+    var code = new Array(this.itemCount_);
+    for (var n = 0; n < this.itemCount_; n++) {
+        code[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || '';
+    }
+    return NAME + '(' + code.join(', ') + ')\n';
+}
+
+export const factory_function_return = function (_, generator) {
+    var NAME = this.getFieldValue('NAME');
+    var code = new Array(this.itemCount_);
+    for (var n = 0; n < this.itemCount_; n++) {
+        code[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || '';
+    }
+    return [NAME + '(' + code.join(', ') + ')', generator.ORDER_ATOMIC];
+}
+
+export const factory_declare = function () {
+    var TYPE = this.getFieldValue('TYPE');
+    var NAME = this.getFieldValue('NAME');
+    return NAME + ' = ' + TYPE + '()\n';
+}
+
+export const factory_callMethod_noreturn = function (_, generator) {
+    var NAME = this.getFieldValue('NAME');
+    var METHOD = this.getFieldValue('METHOD');
+    var code = new Array(this.itemCount_);
+    for (var n = 0; n < this.itemCount_; n++) {
+        code[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || '';
+    }
+    return NAME + '.' + METHOD + '(' + code.join(', ') + ')\n';
+}
+
+export const factory_callMethod_return = function (_, generator) {
+    var NAME = this.getFieldValue('NAME');
+    var METHOD = this.getFieldValue('METHOD');
+    var code = new Array(this.itemCount_);
+    for (var n = 0; n < this.itemCount_; n++) {
+        code[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || '';
+    }
+    return [NAME + '.' + METHOD + '(' + code.join(', ') + ')', generator.ORDER_ATOMIC];
+}
+
+export const factory_block = function () {
+    var VALUE = this.getFieldValue('VALUE');
+    //if(!(VALUE.charAt(VALUE.length-1)==";")){
+    //VALUE=VALUE+';';
+    //}
+    return VALUE + '\n';
+}
+
+export const factory_block_return = function (_, generator) {
+    var VALUE = this.getFieldValue('VALUE');
+    return [VALUE, generator.ORDER_ATOMIC];
+}
+
+export const factory_block_with_textarea = function () {
+    var VALUE = this.getFieldValue('VALUE');
+    //if(!(VALUE.charAt(VALUE.length-1)==";")){
+    //VALUE=VALUE+';';
+    //}
+    return VALUE + '\n';
+}
+
+export const factory_block_return_with_textarea = function (_, generator) {
+    var VALUE = this.getFieldValue('VALUE');
+    return [VALUE, generator.ORDER_ATOMIC];
+}
+
+export const factory_block_notes = function () {
+    var VALUE = this.getFieldValue('VALUE');
+    return '#' + VALUE + '\n';
+}

boards/default_src/micropython_k210_mixgoai/generators/hear.js

@@ -0,0 +1,44 @@
+export const asrloca_init = function (_, generator) {
+    generator.definitions_['import asrloca'] = 'import asrloca';
+    var SUB = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var KEY = this.getFieldValue('KEY');
+    var code = SUB + "=asrloca.ASR_init(" + KEY + ")\n";
+    return code;
+}
+
+export const asrloca_config = function (_, generator) {
+    var ck = new Array(this.itemCount_);
+    var cv = new Array(this.itemCount_);
+    var ct = new Array(this.itemCount_);
+
+    var default_value = '0';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+
+    for (var n = 0; n < this.itemCount_; n++) {
+        var keyName = this.getFieldValue('KEY' + n);
+        ck[n] = keyName
+    }
+    for (var n = 0; n < this.itemCount_; n++) {
+        cv[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || default_value;
+    }
+    var code = v + ".config({";
+    for (var n = 0; n < this.itemCount_; n++) {
+        ct[n] = "'" + ck[n] + "'" + ': ' + cv[n]
+    }
+
+    code = code + ct.join(', ') + "})\n";
+    return code;
+}
+
+export const asrloca_recognize = function (_, generator) {
+    var SUB = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = SUB + ".recognize()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const asrloca_del = function (_, generator) {
+    var SUB = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = SUB + ".__del__()";
+    return code;
+}

boards/default_src/micropython_k210_mixgoai/generators/image.js

@@ -0,0 +1,595 @@
+export const true_false = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_RGB = function (_, generator) {
+    var R = generator.valueToCode(this, 'R', generator.ORDER_ATOMIC);
+    var G = generator.valueToCode(this, 'G', generator.ORDER_ATOMIC);
+    var B = generator.valueToCode(this, 'B', generator.ORDER_ATOMIC);
+    var code = '[' + R + ',' + G + ',' + B + ']';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_Image = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var code = sub + " = image.Image(" + path + ")\n";
+    return code;
+}
+
+export const image_Image1 = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + " = image.Image()\n";
+    return code;
+}
+
+export const image_getinfo = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_save = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var code = sub + ".save(" + path + ")\n";
+    return code;
+}
+
+//----开始--------------cool.ai-----弃用字体加载，出厂内存加载------------------
+
+export const image_font_free = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var code = "image.font_free()\n";
+    return code;
+}
+
+export const image_font_load = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var code = "image.font_load(image.UTF8, 16, 16, " + path + ")\n";
+    return code;
+}
+
+export const image_draw_string_flash = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    generator.definitions_['font_load'] = 'image.font_load(image.UTF8, 16, 16, 0xA00000)';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var x0 = generator.valueToCode(this, 'x0', generator.ORDER_ATOMIC);
+    var y0 = generator.valueToCode(this, 'y0', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'tex', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'scale', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x_spacing', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_string(' + x0 + ',' + y0 + ',str.encode(' + t + '),color=' + color + ',scale=' + s + ',x_spacing=' + x + ',mono_space=1)';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//----结束--------------cool.ai-----弃用字体加载，出厂内存加载------------------
+
+export const image_draw_string_UTF = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var x0 = generator.valueToCode(this, 'x0', generator.ORDER_ATOMIC);
+    var y0 = generator.valueToCode(this, 'y0', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'tex', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'scale', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x_spacing', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_string(' + x0 + ',' + y0 + ',str.encode(' + t + '),color=' + color + ',scale=' + s + ',x_spacing=' + x + ',mono_space=1)';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_string = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var x0 = generator.valueToCode(this, 'x0', generator.ORDER_ATOMIC);
+    var y0 = generator.valueToCode(this, 'y0', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'tex', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'scale', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_string(' + x0 + ',' + y0 + ',' + t + ',' + color + ',' + s + ',mono_space=0)';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_copy = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var code = sub + '.copy(' + LIST + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_compress = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var quality = generator.valueToCode(this, 'quality', generator.ORDER_ATOMIC);
+    var code = sub + '.compress(' + quality + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_clear = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = sub + ".clear()\n";
+    return code;
+}
+
+export const image_tonew = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_set_pixel = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var code = sub + '.set_pixel(' + LIST + ',' + color + ')\n';
+    return code;
+}
+
+export const image_get_pixel = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var code = sub + '.get_pixel(' + LIST + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_line = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var list = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'thi', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_line(' + list + ',' + color + ',' + t + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_arrow = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var list = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'thi', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_arrow(' + list + ',' + color + ',' + t + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_cross = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var list = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'thi', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_cross(' + list + ',' + color + ',' + s + ',' + t + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_circle = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var list = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'thi', generator.ORDER_ATOMIC);
+    var f = generator.valueToCode(this, 'fil', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_circle(' + list + ',' + color + ',' + t + ',' + f + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_rectangle = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var list = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'thi', generator.ORDER_ATOMIC);
+    var f = generator.valueToCode(this, 'fil', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_rectangle(' + list + ',' + color + ',' + t + ',' + f + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_keypoints = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'keypoints', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var thi = generator.valueToCode(this, 'thi', generator.ORDER_ATOMIC);
+    var fil = generator.valueToCode(this, 'fil', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_keypoints(' + key + ',' + color + ',' + size + ',' + thi + ',' + fil + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_draw_image = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var list = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var x_scale = generator.valueToCode(this, 'x_scale', generator.ORDER_ATOMIC);
+    var y_scale = generator.valueToCode(this, 'y_scale', generator.ORDER_ATOMIC);
+    var code = sub + '.draw_image(' + sub + ',' + list + ',' + x_scale + ',' + y_scale + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--形状识别----------------------------------------------//
+
+export const image_find_lines = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var theta_margin = generator.valueToCode(this, 'theta_margin', generator.ORDER_ATOMIC);
+    var rho_margin = generator.valueToCode(this, 'rho_margin', generator.ORDER_ATOMIC);
+    var code = sub + '.find_lines(' + roi + ',threshold=' + threshold + ',theta_margin=' + theta_margin + ',rho_margin=' + rho_margin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_find_line_segments = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var distance = generator.valueToCode(this, 'distance', generator.ORDER_ATOMIC);
+    var difference = generator.valueToCode(this, 'difference', generator.ORDER_ATOMIC);
+    var code = sub + '.find_line_segments(' + roi + ',' + distance + ',' + difference + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_find_circles = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var r_min = generator.valueToCode(this, 'r_min', generator.ORDER_ATOMIC);
+    var r_max = generator.valueToCode(this, 'r_max', generator.ORDER_ATOMIC);
+    var r_step = generator.valueToCode(this, 'r_step', generator.ORDER_ATOMIC);
+    var x_margin = generator.valueToCode(this, 'x_margin', generator.ORDER_ATOMIC);
+    var y_margin = generator.valueToCode(this, 'y_margin', generator.ORDER_ATOMIC);
+    var r_margin = generator.valueToCode(this, 'r_margin', generator.ORDER_ATOMIC);
+    var code = sub + '.find_circles(' + roi + ',threshold=' + threshold + ',x_margin=' + x_margin + ',y_margin=' + y_margin + ',r_margin=' + r_margin + ',r_min=' + r_min + ',r_max=' + r_max + ',r_step=' + r_step + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_find_rects = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var code = sub + '.find_rects(' + roi + ',threshold=' + threshold + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_get_regression = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var invert = generator.valueToCode(this, 'invert', generator.ORDER_ATOMIC);
+    var robust = generator.valueToCode(this, 'robust', generator.ORDER_ATOMIC);
+    var code = sub + '.get_regression([' + threshold + '],invert=' + invert + ',roi=' + roi + ',robust=' + robust + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--形状列表解析------------------------------------------//
+
+export const image_line = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_circle = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    if (key == "circle")
+        var code = '[' + sub + '.x(),' + sub + '.y(),' + sub + '.r()]';
+    else
+        var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_rect = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--图像滤波------------------------------------------//
+
+export const image_histeq = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var limit = generator.valueToCode(this, 'limit', generator.ORDER_ATOMIC);
+    var code = sub + '.histeq(' + key + ',' + limit + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_mean = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var offset = generator.valueToCode(this, 'offset', generator.ORDER_ATOMIC);
+    var code = sub + '.mean(' + size + ',' + key + ',' + offset + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_cartoon = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var seed = generator.valueToCode(this, 'seed', generator.ORDER_ATOMIC);
+    var floa = generator.valueToCode(this, 'float', generator.ORDER_ATOMIC);
+    var code = sub + '.cartoon(seed_threshold=' + seed + ',floating_threshold=' + floa + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_erode = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var code = sub + '.erode(' + size + ',' + threshold + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_dilate = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var code = sub + '.dilate(' + size + ',' + threshold + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_flood_fill = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var list = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'color', generator.ORDER_ATOMIC);
+    var seed = generator.valueToCode(this, 'seed', generator.ORDER_ATOMIC);
+    var floa = generator.valueToCode(this, 'float', generator.ORDER_ATOMIC);
+    var invert = generator.valueToCode(this, 'invert', generator.ORDER_ATOMIC);
+    var clear = generator.valueToCode(this, 'clear', generator.ORDER_ATOMIC);
+    var code = sub + '.flood_fill(' + list + ',' + seed + ',' + floa + ',' + color + ',' + invert + ',' + clear + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_linpolar = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = sub + '.linpolar(' + key + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_invert = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = sub + '.invert()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_lens_corr = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var strength = generator.valueToCode(this, 'strength', generator.ORDER_ATOMIC);
+    var zoom = generator.valueToCode(this, 'zoom', generator.ORDER_ATOMIC);
+    var code = sub + '.lens_corr(' + strength + ',' + zoom + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_binary = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var invert = generator.valueToCode(this, 'invert', generator.ORDER_ATOMIC);
+    var zero = generator.valueToCode(this, 'zero', generator.ORDER_ATOMIC);
+    var code = sub + '.binary([' + threshold + '],invert=' + invert + ',zero=' + zero + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_morph = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var kernel = generator.valueToCode(this, 'kernel', generator.ORDER_ATOMIC);
+    var code = sub + '.morph(' + size + ',' + kernel + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--条二维码----------------------------------------------//
+
+export const image_find_barcodes = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var code = sub + '.find_barcodes(' + roi + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_find_qrcodes = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var code = sub + '.find_qrcodes(' + roi + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_find_apriltags = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var code = sub + '.find_apriltags(' + roi + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--维码列表解析------------------------------------------//
+
+export const image_barcode = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_qrcode = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_apriltag = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--颜色识别----------------------------------------------//
+
+export const image_find_blobs = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var area1 = generator.valueToCode(this, 'area', generator.ORDER_ATOMIC);
+    var pixel = generator.valueToCode(this, 'pixel', generator.ORDER_ATOMIC);
+    var margin = generator.valueToCode(this, 'margin', generator.ORDER_ATOMIC);
+    var merge = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = sub + '.find_blobs([' + LIST + '],roi=' + roi + ',area_threshold=' + area1 + ',pixels_threshold=' + pixel + ',merge=' + merge + ',margin=' + margin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_get_histogram = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var code = sub + '.get_histogram(roi=' + roi + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--颜色列表解析------------------------------------------//
+
+export const image_blob = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_Histogram = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_percentile = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var per = generator.valueToCode(this, 'percentile', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.get_percentile(' + per + ').' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_threshold = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.get_threhsold.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--颜色格式转换------------------------------------------//
+
+export const image_lab_to_rgb = function (_, generator) {
+    generator.definitions_['import_image_pic'] = 'import image as pic';
+    var LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var code = 'pic.lab_to_rgb(' + LIST + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_rgb_to_lab = function (_, generator) {
+    generator.definitions_['import_image_pic'] = 'import image as pic';
+    var LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var code = 'pic.rgb_to_lab(' + LIST + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_rgb_to_grayscale = function (_, generator) {
+    generator.definitions_['import_image_pic'] = 'import image as pic';
+    var LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var code = 'pic.rgb_to_grayscale(' + LIST + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_grayscale_to_rgb = function (_, generator) {
+    generator.definitions_['import_image_pic'] = 'import image as pic';
+    var g_value = generator.valueToCode(this, 'g_value', generator.ORDER_ATOMIC);
+    var code = 'pic.grayscale_to_rgb(' + g_value + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--特征识别----------------------------------------------//
+
+export const image_find_hog = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var code = sub + '.find_hog(' + roi + ',' + size + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_find_keypoints = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var roi = generator.valueToCode(this, 'roi', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'max_keypoints', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var scale = generator.valueToCode(this, 'scale_factor', generator.ORDER_ATOMIC);
+    var normalized = generator.valueToCode(this, 'normalized', generator.ORDER_ATOMIC);
+    var code = sub + '.find_keypoints(roi=' + roi + ',max_keypoints=' + key + ',threshold=' + threshold + ',scale_factor=' + scale + ',normalized=' + normalized + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_match_descriptor = function (_, generator) {
+    generator.definitions_['import_image_pic'] = 'import image as pic';
+    var sub1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var sub2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var threshold = generator.valueToCode(this, 'threshold', generator.ORDER_ATOMIC);
+    var code = 'pic.match_descriptor(' + sub1 + ',' + sub2 + ',threshold=' + threshold + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//--颜色列表解析------------------------------------------//
+
+export const image_kptmatch = function (_, generator) {
+    generator.definitions_['import_image'] = 'import image';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}

boards/default_src/micropython_k210_mixgoai/generators/inout.js

@@ -0,0 +1,106 @@
+import * as Blockly from 'blockly/core';
+
+export const PGA_SELET = function (_, generator) {
+    var code = this.getFieldValue('PGA');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const inout_highlow = function (_, generator) {
+    // Boolean values HIGH and LOW.
+    var code = (this.getFieldValue('BOOL') == 'HIGH') ? '1' : '0';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// ok
+export const inout_digital_init = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var pin_obj = this.getFieldValue('PIN_OBJ') || 'pin#';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_mode = this.getFieldValue('MODE');
+    var varName = (pin_obj == 'pin#') ? 'pin' + dropdown_pin : generator.variableDB_.getName(pin_obj, Blockly.Variables.NAME_TYPE);
+    var code = varName + ' = board.pin(' + dropdown_pin + ', board.' + dropdown_mode + ')\n';
+    return code;
+}
+
+export const inout_digital_write = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = "";
+    code = 'pin' + dropdown_pin + '.value(' + dropdown_stat + ')\n'
+    return code;
+}
+
+export const inout_digital_read = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = "";
+    code = 'pin' + dropdown_pin + '.value()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const inout_pwm_init = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    generator.definitions_['from machine import PWM'] = 'from machine import PWM';
+    generator.definitions_['from machine import Timer'] = 'from machine import Timer';
+    var pin_obj = this.getFieldValue('PIN_OBJ') || 'pin#';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var varName = (pin_obj == 'pin#') ? 'pin' + dropdown_pin : generator.variableDB_.getName(pin_obj, Blockly.Variables.NAME_TYPE);
+    var freq = generator.valueToCode(this, 'freq', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var Timer = sub % 3
+    var CHANNEL = parseInt(sub / 3)
+    var code1 = 'tim' + sub + ' = Timer(Timer.TIMER' + Timer + ',Timer.CHANNEL' + CHANNEL + ', mode=Timer.MODE_PWM)\n';
+    var code2 = varName + ' = PWM(tim' + sub + ',freq=' + freq + ',duty=0, pin=' + dropdown_pin + ')\n';
+
+    return code1 + code2;
+}
+
+export const inout_pwm_write = function (_, generator) {
+    generator.definitions_['from machine import PWM'] = 'from machine import PWM';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_stat = generator.valueToCode(this, 'pwm', generator.ORDER_ATOMIC);
+    var code = "";
+    code = 'pin' + dropdown_pin + '.duty(' + dropdown_stat + ')\n'
+    return code;
+}
+
+export const inout_adc_init = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = 'board.adc_init(' + key + ')\n';
+    return code;
+}
+
+export const inout_adc_read = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'board.adc_read(' + pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const inout_adc_Vread = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'board.adc_vread(' + pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const inout_pin_attachInterrupt = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_mode = this.getFieldValue('mode');
+    var atta = generator.valueToCode(this, 'DO', generator.ORDER_ATOMIC);
+    var code1 = 'key' + dropdown_pin + '=board.pin(' + dropdown_pin + ', board.GPIO.IN, board.GPIO.PULL_NONE)\n'
+    var code2 = 'key' + dropdown_pin + '.irq(' + atta + ',board.' + dropdown_mode + ',board.GPIO.WAKEUP_NOT_SUPPORT, 7)\n'
+
+    return code1 + code2;
+}
+
+export const inout_pin_disirq = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'key' + dropdown_pin + '.disirq()\n'
+    return code;
+}
+/////////////////////////////////////////////

boards/default_src/micropython_k210_mixgoai/generators/iot.js

@@ -0,0 +1,75 @@
+export const iot_wifi_connect = function (_, generator) {
+    // generator.definitions_['import_simple'] = "import simple";
+    generator.definitions_['import_miot'] = "import miot_no";
+    var username = generator.valueToCode(this, 'WIFINAME', generator.ORDER_ATOMIC);
+    var password = generator.valueToCode(this, 'PASSWORD', generator.ORDER_ATOMIC);
+    var code = 'miot_no.do_connect(' + username + ',' + password + ')\n';
+    return code;
+}
+
+export const iot_onenet_connect = function (_, generator) {
+    generator.definitions_['import_miot'] = "import miot_no";
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var client = generator.valueToCode(this, 'CLIENT', generator.ORDER_ATOMIC);
+    var server = generator.valueToCode(this, 'SERVER', generator.ORDER_ATOMIC);
+    var username = generator.valueToCode(this, 'USERNAME', generator.ORDER_ATOMIC);
+    var password = generator.valueToCode(this, 'PASSWORD', generator.ORDER_ATOMIC);
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var subscribe = generator.valueToCode(this, 'SUB', generator.ORDER_ASSIGNMENT) || '0';
+    var code = v + ' = miot_no.init_MQTT_client(' + client + ', ' + server + ', ' + username + ', ' + password + ', ' + topic + ', ' + subscribe + ')\n';
+    return code;
+}
+
+export const iot_onenet_disconnect = function (_, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    generator.definitions_['import_simple'] = "import simple";
+    var code = v + '.do_disconnect()\n';
+    return code;
+}
+
+export const iot_onenet_publish_dict = function (_, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var d = generator.valueToCode(this, 'DICT', generator.ORDER_ATOMIC);
+    var check = this.getFieldValue("is_print") == 'TRUE' ? 'True' : 'False';
+    generator.definitions_['import_simple'] = "import simple";
+    var code = v + '.publish(' + d + ', is_print = ' + check + ')\n';
+    return code;
+}
+
+export const iot_onenet_check = function (_, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    generator.definitions_['import_simple'] = "import simple";
+    var code = v + '.check_msg()\n';
+    return code;
+}
+
+export const iot_onenet_publish = function (_, generator) {
+    // Create a list with any number of elements of any type.
+
+    //var size=window.parseFloat(this.getFieldValue('SIZE'));
+    generator.definitions_['import_miot'] = "import miot_no";
+    var ck = new Array(this.itemCount_);
+    var cv = new Array(this.itemCount_);
+    var ct = new Array(this.itemCount_);
+
+    var default_value = '0';
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+
+    for (var n = 0; n < this.itemCount_; n++) {
+        var keyName = this.getFieldValue('KEY' + n);
+        ck[n] = keyName
+    }
+    for (var n = 0; n < this.itemCount_; n++) {
+        cv[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || default_value;
+    }
+    var code = v + ".publish({";
+    for (var n = 0; n < this.itemCount_; n++) {
+        ct[n] = ck[n] + ': ' + cv[n]
+    }
+    //var code = "c.publish('$dp', pubData("+ '{' + code.join(', ') + '})\n';
+    //var code =''+varName+'['+size+"]"+'='+ '{' + code.join(', ') + '}\n';
+    //generator.setups_['setup_lists'+varName] = code;
+    code = code + ct.join(', ') + "})\n";
+    return code;
+}

boards/default_src/micropython_k210_mixgoai/generators/math.js

@@ -0,0 +1,358 @@
+// export const math_number = function() {
+//   // Numeric value.
+//   var code = (this.getFieldValue('NUM'));
+//   // -4.abs() returns -4 in Dart due to strange order of operation choices.
+//   // -4 is actually an operator and a number.  Reflect this in the order.
+//   var order = code < 0 ?
+//       generator.ORDER_UNARY_PREFIX : generator.ORDER_ATOMIC;
+//   return [code, order];
+// }
+
+// generator.math = {}
+// generator.addReservedWords("math,random,Number");
+
+export const math_number = function (_, generator) {
+    // a = parseFloat(a.getFieldValue("NUM"));
+    // var b;
+    // Infinity == a ? (a = 'float("inf")', b = generator.ORDER_FUNCTION_CALL) : -Infinity == a ? (a = '-float("inf")', b = generator.ORDER_UNARY_SIGN) : b = 0 > a ? generator.ORDER_UNARY_SIGN : generator.ORDER_ATOMIC;
+    // return [a, b]
+
+    var code = this.getFieldValue('NUM');
+    // -4.abs() returns -4 in Dart due to strange order of operation choices.
+    // -4 is actually an operator and a number.  Reflect this in the order.
+    var order = code < 0 ?
+        generator.ORDER_UNARY_PREFIX : generator.ORDER_ATOMIC;
+    return [code, order];
+}
+
+export const math_constant = function (_, generator) {
+    generator.definitions_.import_math = "import math";
+    var name = this.getFieldValue('CONSTANT');
+    var code = 'math.' + name;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+
+export const math_bit = function (_, generator) {
+    var operator = this.getFieldValue('OP');
+    var order = generator.ORDER_ATOMIC;
+    var argument0 = generator.valueToCode(this, 'A', order) || '0';
+    var argument1 = generator.valueToCode(this, 'B', order) || '0';
+    var code = '(' + argument0 + operator + argument1 + ')';
+    return [code, order];
+}
+
+export const math_arithmetic = function (block, generator) {
+    var b = {
+            ADD: [" + ", generator.ORDER_ADDITIVE],
+            MINUS: [" - ", generator.ORDER_ADDITIVE],
+            MULTIPLY: [" * ", generator.ORDER_MULTIPLICATIVE],
+            DIVIDE: [" / ", generator.ORDER_MULTIPLICATIVE],
+            QUYU: [' % ', generator.ORDER_MULTIPLICATIVE],//增加取余操作
+            ZHENGCHU: [' // ', generator.ORDER_MULTIPLICATIVE],//增加整除操作
+            POWER: [" ** ", generator.ORDER_EXPONENTIATION]
+        }[block.getFieldValue("OP")],
+        c = b[0],
+        b = b[1],
+        d = generator.valueToCode(block, "A", b) || "0";
+    block = generator.valueToCode(block, "B", b) || "0";
+    return [d + c + block, b]
+}
+
+export const math_selfcalcu = function (_, generator) {
+    var argument0 = generator.valueToCode(this, 'A', generator.ORDER_RELATIONAL) || '0';
+    var argument1 = generator.valueToCode(this, 'B', generator.ORDER_RELATIONAL) || '0';
+    var operator = this.getFieldValue('OP');
+    switch (operator) {
+    case 'ADD': var op = '+='; break;
+    case 'MINUS': var op = '-='; break;
+    case 'MULTIPLY': var op = '*='; break;
+    case 'DIVIDE': var op = '/='; break;
+    case 'QUYU': var op = '%='; break;
+    case 'ZHENGCHU': var op = '//='; break;
+    case 'POWER': var op = '**='; break;
+    }
+    var code = argument0 + ' ' + op + ' ' + argument1 + '\n';
+    return code;
+}
+
+export const math_single = function (a, generator) {
+    var b = a.getFieldValue("OP"),
+        c;
+    if ("NEG" == b)
+        return c = generator.valueToCode(a, "NUM", generator.ORDER_UNARY_SIGN) || "0", ["-" + c, generator.ORDER_UNARY_SIGN];
+    generator.definitions_['import_math'] = "import math";
+    a = "SIN" == b || "COS" == b || "TAN" == b ? generator.valueToCode(a, "NUM", generator.ORDER_MULTIPLICATIVE) || "0" : generator.valueToCode(a, "NUM", generator.ORDER_NONE) || "0";
+    switch (b) {
+    case "ABS":
+        c = "math.fabs(" + a + ")";
+        break;
+    case "ROOT":
+        c = "math.sqrt(" +
+                a + ")";
+        break;
+    case "LN":
+        c = "math.log(" + a + ")";
+        break;
+    case "LOG10":
+        c = "math.log10(" + a + ")";
+        break;
+    case "EXP":
+        c = "math.exp(" + a + ")";
+        break;
+    case "POW10":
+        c = "math.pow(10," + a + ")";
+        break;
+    case "ROUND":
+        c = "round(" + a + ")";
+        break;
+    case "ROUNDUP":
+        c = "math.ceil(" + a + ")";
+        break;
+    case "ROUNDDOWN":
+        c = "math.floor(" + a + ")";
+        break;
+    case "SIN":
+        c = "math.sin(" + a + ")";
+        break;
+    case "COS":
+        c = "math.cos(" + a + ")";
+        break;
+    case "TAN":
+        c = "math.tan(" + a + ")";
+        break;
+    case "++":
+        c = "++(" + a + ")";
+        break;
+    case "--":
+        c = "--(" + a + ")";
+        break;
+    case "-":
+        c = "-(" + a + ")";
+        break;
+    default:
+    }
+    if (c)
+        return [c, generator.ORDER_FUNCTION_CALL];
+    switch (b) {
+    case "ASIN":
+        c = "math.degrees(math.asin(" + a + "))";
+        break;
+    case "ACOS":
+        c = "math.degrees(math.acos(" + a + "))";
+        break;
+    case "ATAN":
+        c = "math.degrees(math.atan(" + a + "))";
+        break;
+    }
+    return [c, generator.ORDER_MULTIPLICATIVE]
+}
+
+export const math_trig = math_single;
+
+export const math_to_int = function (_, generator) {
+    var argument0 = generator.valueToCode(this, 'A', generator.ORDER_NONE) || '0';
+    var operator = this.getFieldValue('OP');
+    var code = "";
+    if (operator === "round") {
+        code = operator + '(' + argument0 + ')';
+    } else {
+        code = "math." + operator + '(' + argument0 + ')';
+        generator.definitions_.import_math = "import math";
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const math_max_min = function (_, generator) {
+    var a = generator.valueToCode(this, 'A', generator.ORDER_NONE) || '0';
+    var b = generator.valueToCode(this, 'B', generator.ORDER_NONE) || '0';
+    var operator = this.getFieldValue('OP');
+    var code = operator + '(' + a + ', ' + b + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const math_max_min1 = function (_, generator) {
+    var a = generator.valueToCode(this, 'LIST', generator.ORDER_NONE) || '0';
+    var operator = this.getFieldValue('OP');
+    var code = operator + '(' + a + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const math_random = function (_, generator) {
+    generator.definitions_.import_random = "import random";
+    // Random integer between [X] and [Y].
+    var type = this.getFieldValue('TYPE');
+    var argument0 = generator.valueToCode(this, 'FROM',
+        generator.ORDER_NONE) || '0';
+    var argument1 = generator.valueToCode(this, 'TO',
+        generator.ORDER_NONE) || '0';
+    if (type == 'int') {
+        var code = 'random.randint(' + argument0 + ', ' + argument1 + ')';
+    } else if (type == 'float') {
+        var code = 'random.uniform(' + argument0 + ', ' + argument1 + ')';
+    }
+    return [code, generator.ORDER_UNARY_POSTFIX];
+}
+
+export const math_map = function (_, generator) {
+    var value_num = generator.valueToCode(this, 'NUM', generator.ORDER_NONE);
+    var value_fl = generator.valueToCode(this, 'fromLow', generator.ORDER_ATOMIC);
+    var value_fh = generator.valueToCode(this, 'fromHigh', generator.ORDER_ATOMIC);
+    var value_tl = generator.valueToCode(this, 'toLow', generator.ORDER_ATOMIC);
+    var value_th = generator.valueToCode(this, 'toHigh', generator.ORDER_ATOMIC);
+    generator.setups_["mixly_mapping"] = "def mixly_mapping(v, al, ah, bl, bh):\n" +
+        "    return bl +  (bh - bl) * (v - al) / (ah - al)\n"
+    var code = 'mixly_mapping(' + value_num + ', ' + value_fl + ', ' + value_fh + ', ' + value_tl + ', ' + value_th + ')';
+    return [code, generator.ORDER_NONE];
+}
+
+export const math_constrain = function (_, generator) {
+    // Constrain a number between two limits.
+    var argument0 = generator.valueToCode(this, 'VALUE',
+        generator.ORDER_NONE) || '0';
+    var argument1 = generator.valueToCode(this, 'LOW',
+        generator.ORDER_NONE) || '0';
+    var argument2 = generator.valueToCode(this, 'HIGH',
+        generator.ORDER_NONE) || '0';
+    var code = 'min(max(' + argument0 + ', ' + argument1 + '), ' + argument2 + ')';
+    return [code, generator.ORDER_UNARY_POSTFIX];
+}
+
+export const math_number_base_conversion = function (a, generator) {
+    var c1 = a.getFieldValue("OP");
+    var d = generator.valueToCode(this, 'NUM', generator.ORDER_NONE) || '0';
+    var c2 = a.getFieldValue("OP2");
+    generator.definitions_['import_math'] = "import math";
+    var param1 = "";
+    var param2 = "10";
+    if (c1 == "two") {
+        param2 = '2';
+    } else if (c1 == "eight") {
+        param2 = '8'
+    } else if (c1 == "ten") {
+        param2 = '10'
+    } else if (c1 == "sixteen") {
+        param2 = '16'
+    }
+
+    if (c2 == "two") {
+        param1 = 'bin';
+    } else if (c2 == "eight") {
+        param1 = 'oct'
+    } else if (c2 == "ten") {
+        param1 = ''
+    } else if (c2 == "sixteen") {
+        param1 = 'hex'
+    }
+    if (param1 == "") {
+        var code = "int(str(" + d + "), " + param2 + ")";
+    } else {
+        var code = param1 + "(int(str(" + d + "), " + param2 + "))";
+
+    }
+    return [code, generator.ORDER_ATOMIC];
+    /*
+    switch (c1) {
+      case "two":
+      switch (c2){
+        case "two":
+        var code = '\'{0:b}\''+ '.' + 'format' + '(' + '0b' + '('+d +')'+')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "eight":
+        var code = '\'{0:o}\''+ '.' + 'format'+ '(' + '0b' +'('+d +')'+')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "ten":
+        var code ='int'+  '(' + d +','+'2'+')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "sixteen":
+        var code = '\'{0:x}\''+ '.' + 'format' + '(' + '0b' +'('+d +')'+')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+      }
+      break;
+      case "eight":
+      switch (c2){
+        case "two":
+        var code = '\'{0:b}\''+ '.' + 'format' + '(' + '0o' + '('+d +')' +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "eight":
+        var code = '\'{0:o}\''+ '.' + 'format'+ '(' + '0o' + '('+d +')' +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "ten":
+        var code ='int'+  '(' +d +','+'8'+')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "sixteen":
+        var code = '\'{0:x}\''+ '.' + 'format' + '(' + '0o' + '('+d +')' +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+      }
+      break;
+      case "ten":
+      switch (c2){
+        case "two":
+        var code = '\'{0:b}\''+ '.' + 'format' + '('  + d  +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "eight":
+        var code = '\'{0:o}\''+ '.' + 'format'+ '('  + d  +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "ten":
+        var code ='int'+  '(' +d +','+'10'+')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "sixteen":
+        var code = '\'{0:x}\''+ '.' + 'format' + '('  + d  +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+      }
+      break;
+      case "sixteen":
+      switch (c2){
+        case "two":
+        var code = '\'{0:b}\''+ '.' + 'format' + '(' + '0x' + '('+d +')' +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "eight":
+        var code = '\'{0:o}\''+ '.' + 'format'+ '(' + '0x' + '('+d +')' +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "ten":
+        var code ='int'+  '(' +d +','+'16'+')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+        case "sixteen":
+        var code = '\'{0:x}\''+ '.' + 'format' + '(' + '0x' + '('+d +')' +')';
+        return [code, generator.ORDER_ATOMIC];
+        break;
+      }
+      break;
+      default:
+    }
+    */
+}
+
+export const math_random_seed = function (_, generator) {
+    // Random integer between [X] and [Y].
+    generator.definitions_.import_random = "import random";
+    var a = generator.valueToCode(this, 'NUM', generator.ORDER_NONE) || '0';
+    var code = 'random.seed(' + a + ');' + '\n';
+    return code;
+}
+
+export const math_indexer_number = function (_, generator) {
+    var code = this.getFieldValue('NUM');
+    // -4.abs() returns -4 in Dart due to strange order of operation choices.
+    // -4 is actually an operator and a number.  Reflect this in the order.
+    var order = code < 0 ?
+        generator.ORDER_UNARY_PREFIX : generator.ORDER_ATOMIC;
+    return [code, order];
+}
+
+export const base_map = math_map;

boards/default_src/micropython_k210_mixgoai/generators/nes.js

@@ -0,0 +1,24 @@
+export const nes_joystick_init = function (_, generator) {
+    generator.definitions_['import nes_no'] = 'import nes_no';
+    var cs_pin = generator.valueToCode(this, 'cs_pin', generator.ORDER_ATOMIC);
+    var clk_pin = generator.valueToCode(this, 'clk_pin', generator.ORDER_ATOMIC);
+    var mosi_pin = generator.valueToCode(this, 'mosi_pin', generator.ORDER_ATOMIC);
+    var miso_pin = generator.valueToCode(this, 'miso_pin', generator.ORDER_ATOMIC);
+    var vol = generator.valueToCode(this, 'vol', generator.ORDER_ATOMIC);
+    var code = "nes_no.joystick_init(" + cs_pin + "," + clk_pin + "," + mosi_pin + "," + miso_pin + "," + vol + ")\n";
+    return code;
+}
+
+export const nes_keyboard_init = function (_, generator) {
+    generator.definitions_['import nes_no'] = 'import nes_no';
+    var vol = generator.valueToCode(this, 'vol', generator.ORDER_ATOMIC);
+    var code = "nes_no.keyboard_init(" + vol + ")\n";
+    return code;
+}
+
+export const nes_run = function (_, generator) {
+    generator.definitions_['import nes_no'] = 'import nes_no';
+    var path = generator.valueToCode(this, 'path', generator.ORDER_ATOMIC);
+    var code = "nes_no.run(" + path + ")\n";
+    return code;
+}

boards/default_src/micropython_k210_mixgoai/generators/network.js

@@ -0,0 +1,119 @@
+export const network_init = function (_, generator) {
+    generator.definitions_['import net_espat'] = "import net_espat";
+    var TX = generator.valueToCode(this, 'TX', generator.ORDER_ATOMIC);
+    var RX = generator.valueToCode(this, 'RX', generator.ORDER_ATOMIC);
+    return "ESP_AT = net_espat.wifi_init(" + RX + "," + TX + ")\n";
+}
+
+export const network_scan = function (_, generator) {
+    generator.definitions_['import net_espat'] = "import net_espat";
+    var code = "net_espat.scans(ESP_AT)";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_connect = function (_, generator) {
+    generator.definitions_['import net_espat'] = "import net_espat";
+    var account = generator.valueToCode(this, 'account', generator.ORDER_ATOMIC);
+    var passwor = generator.valueToCode(this, 'password', generator.ORDER_ATOMIC);
+    var code = "ESP_AT.connect(" + account + "," + passwor + ")\n";
+    return code;
+}
+
+export const network_ifconfig = function (_, generator) {
+    generator.definitions_['import net_espat'] = "import net_espat";
+    var mode = this.getFieldValue('mode');
+    if (mode == "1")
+        var code = "ESP_AT.ifconfig()";
+    if (mode == "2")
+        var code = "ESP_AT.isconnected()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_disconnect = function (_, generator) {
+    generator.definitions_['import net_espat'] = "import net_espat";
+    var code = "ESP_AT.disconnect()\n";
+    return code;
+}
+
+export const network_enable_ap = function (_, generator) {
+    generator.definitions_['import net_espat'] = "import net_espat";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var account = generator.valueToCode(this, 'account', generator.ORDER_ATOMIC);
+    var passwor = generator.valueToCode(this, 'password', generator.ORDER_ATOMIC);
+    var chl = generator.valueToCode(this, 'chl', generator.ORDER_ATOMIC);
+    var mode = this.getFieldValue('mode');
+    var code = "ESP_AT.enable_ap(" + account + "," + passwor + "," + chl + "," + varName + "." + mode + ")\n";
+    return code;
+}
+
+export const network_disable_ap = function (_, generator) {
+    generator.definitions_['import net_espat'] = "import net_espat";
+    var code = "ESP_AT.disable_ap()\n";
+    return code;
+}
+
+export const network_server = function (_, generator) {
+    generator.definitions_['import_server_*'] = 'from server import *';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    // generator.setups_['class_wlan'] ='SSID="ying"\n'+'PASSWORD="201411132040"\n';
+    return 'if not ' + varName + '.isconnected():\n'
+        + '    connectWifi(SSID, PASSWORD)\n'
+        + 'ip=' + varName + '.ifconfig()[0]\n'
+        + 'print(ip)\n'
+        + 'time.sleep(1)\n'
+        + 'DATA=listenData()\n'
+}
+
+// ok
+export const network_socket_init = function (_, generator) {
+    generator.definitions_['import socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return "" + varName + " = socket.socket()\n";
+}
+
+// ok
+export const network_socket_getaddrinfo = function (_, generator) {
+    generator.definitions_['import socket'] = "import socket";
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var code = "socket.getaddrinfo(" + addr + ",80)[0][-1]";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// ok
+export const network_socket_connect = function (_, generator) {
+    generator.definitions_['import socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var address = generator.valueToCode(this, 'address', generator.ORDER_ATOMIC);
+    return "" + varName + ".connect(" + address + ")\n";
+}
+
+// ok
+export const network_socket_settimeout = function (_, generator) {
+    generator.definitions_['import socket'] = "import socket";
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return "" + varName + ".settimeout(" + time + ")\n";
+}
+
+export const network_socket_receive = function (_, generator) {
+    generator.definitions_['import socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".recv(" + size + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_socket_send = function (_, generator) {
+    generator.definitions_['import socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var content = generator.valueToCode(this, 'content', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".send(" + content + ")\n";
+    return code;
+}
+
+export const network_socket_close = function (_, generator) {
+    generator.definitions_['import socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".close()\n";
+    return code;
+}

boards/default_src/micropython_k210_mixgoai/generators/pins.js

@@ -0,0 +1,29 @@
+export const pins_digital = function (_, generator) {
+    var code = this.getFieldValue('PIN');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const pins_button = pins_digital;
+export const pins_digital_pin = pins_digital;
+export const pins_analog_pin = pins_digital;
+export const pins_analog = pins_digital;
+export const pins_pwm_pin = pins_digital;
+export const pins_pwm = pins_digital;
+export const pins_dac_pin = pins_digital;
+export const pins_dac = pins_digital;
+export const pins_touch_pin = pins_digital;
+export const pins_touch = pins_digital;
+export const pins_interrupt = pins_digital;
+export const pins_serial = pins_digital;
+export const pins_builtinimg = pins_digital;
+export const pins_imglist = pins_digital;
+export const pins_playlist = pins_digital;
+export const pins_axis = pins_digital;
+export const pins_exlcdh = pins_digital;
+export const pins_exlcdv = pins_digital;
+export const pins_brightness = pins_digital;
+export const pins_tone_notes = pins_digital;
+export const pins_radio_power = pins_digital;
+export const pins_radio_datarate = pins_digital;
+export const pins_one_more = pins_digital;
+export const pins_digital_dot = pins_digital;

boards/default_src/micropython_k210_mixgoai/generators/sensor.js

@@ -0,0 +1,182 @@
+export const KEY_SELET = function (_, generator) {
+    var code = this.getFieldValue('KEY');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_button_init = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code1 = 'button' + key + '=board.pin(' + key + ',board.GPIO.IN,board.GPIO.PULL_UP)\n';
+    return code1;
+}
+
+export const sensor_button_read = function (_, generator) {
+    generator.definitions_['import board'] = 'import board';
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var code = 'not button' + key + '.value()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_dht11 = function (_, generator) {
+    generator.definitions_['import dht11'] = 'import dht11';
+    var TYPE = this.getFieldValue('TYPE');
+    var PIN = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    if (TYPE == "2")
+        var code = 'dht11.read_data(' + PIN + ')';
+    else
+        var code = 'dht11.read_data(' + PIN + ')[' + TYPE + ']';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const HCSR04 = function (_, generator) {
+    generator.definitions_['import_sonar'] = 'import hcr04';
+    var dropdown_pin1 = generator.valueToCode(this, "PIN1", generator.ORDER_ASSIGNMENT);
+    var dropdown_pin2 = generator.valueToCode(this, "PIN2", generator.ORDER_ASSIGNMENT);
+    var code = 'hcr04.Sonar(' + dropdown_pin1 + ', ' + dropdown_pin2 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpu9250_attachGestureInterrupt = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    var gesture = this.getFieldValue('gesture');
+    var branch = generator.statementToCode(this, 'DO');
+    var d = branch || generator.PASS;
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "mpu")
+        generator.definitions_['import_mixgo_mpu'] = 'from mixgo import mpu';
+    var code = 'if ' + v + '.mpu9250_is_gesture("' + gesture + '"):\n' + d;
+    return code;
+}
+
+export const sensor_mpu9250_gesture = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    var gesture = this.getFieldValue('gesture');
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "mpu")
+        generator.definitions_['import_mixgo_mpu'] = 'from mixgo import mpu';
+    var code = v + '.mpu9250_is_gesture("' + gesture + '")';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpu9250_get_acceleration = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    var key = this.getFieldValue('key');
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "mpu")
+        generator.definitions_['import_mixgo_mpu'] = 'from mixgo import mpu';
+    var code = v + '.mpu9250_get_' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_adxl345_get_acceleration = function (_, generator) {
+    generator.definitions_['import_adxl345'] = 'import adxl345';
+    var key = this.getFieldValue('key');
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code;
+    if (key == 'x') {
+        code = v + '.readX()';
+    } else if (key == 'y') {
+        code = v + '.readY()';
+    } else if (key == 'z') {
+        code = v + '.readZ()';
+    } else if (key == 'values') {
+        code = v + '.readXYZ()';
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpu9250_get_magnetic = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    var key = this.getFieldValue('key');
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "mpu")
+        generator.definitions_['import_mixgo_mpu'] = 'from mixgo import mpu';
+    var code = v + '.mpu9250_magnetic_' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpu9250_get_gyro = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    var key = this.getFieldValue('key');
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "mpu")
+        generator.definitions_['import_mixgo_mpu'] = 'from mixgo import mpu';
+    var code = v + '.mpu9250_gyro_' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpu9250_calibrate_compass = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_mixgo_compass'] = 'from mixgo import compass';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    return '' + v + '.calibrate()\n';
+}
+
+export const sensor_mpu9250_temperature = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "mpu")
+        generator.definitions_['import_mixgo_mpu'] = 'from mixgo import mpu';
+    return [v + '.mpu9250_get_temperature()', generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpu9250_field_strength = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_machine'] = 'import machine';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "compass")
+        generator.definitions_['import_mixgo_compass'] = 'from mixgo import compass';
+    var compass = this.getFieldValue('compass');
+    var a;
+    if (compass == 'strength') {
+        a = v + '.get_field_strength()';
+    }
+    else if (compass == 'heading') {
+        a = v + '.heading()';
+    }
+    return [a, generator.ORDER_ATOMIC];
+}
+
+export const sensor_compass_reset = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_mixgo_compass'] = 'from mixgo import compass';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    return '' + v + '.reset_calibrate()\n';
+}
+
+export const sensor_use_i2c_init = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var iv = generator.valueToCode(this, 'I2CSUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code;
+    if (key == 'MPU9250') {
+        generator.definitions_['import_mpu9250'] = 'import mpu9250';
+        code = v + ' = mpu9250.' + key + "(" + iv + ')\n';
+    } else if (key == 'BMP280') {
+        generator.definitions_['import_bmp280'] = 'import bmp280';
+        code = v + ' = bmp280.' + key + "(" + iv + ')\n';
+    } else if (key == 'SHT20') {
+        generator.definitions_['import_sht20'] = 'import sht20';
+        code = v + ' = sht20.' + key + "(" + iv + ')\n';
+    } else if (key == 'ADXL345') {
+        generator.definitions_['import_adxl345'] = 'import adxl345';
+        code = v + ' = adxl345.' + key + "(" + iv + ')\n';
+    }
+    return code;
+}
+
+export const sensor_bmp = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_bmp280'] = 'import bmp280';
+    var code = v + '.' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_sht = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_sht20'] = 'import sht20';
+    var code = v + '.' + key;
+    return [code, generator.ORDER_ATOMIC];
+}

boards/default_src/micropython_k210_mixgoai/generators/serial.js

@@ -0,0 +1,122 @@
+export const UART_SELET = function (_, generator) {
+    var code = this.getFieldValue('UART');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const serial_print = function (_, generator) {
+    generator.definitions_['from machine import UART'] = 'from machine import UART';
+    var dropdown_uart = this.getFieldValue('mode');
+    var content = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC) || '""'
+    var code = "uart" + dropdown_uart + ".write(str(" + content + "))\n";
+    return code;
+}
+
+export const serial_println = function (_, generator) {
+    generator.definitions_['from machine import UART'] = 'from machine import UART';
+    var dropdown_uart = this.getFieldValue('mode');
+    var content = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC) || '""'
+    var code = "uart" + dropdown_uart + ".write(str(" + content + ")+'\\r\\n')\n";
+    return code;
+}
+
+export const serial_print_hex = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_uart = this.getFieldValue('mode');
+    var dropdown_stat = this.getFieldValue('STAT');
+    var content = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC) || '0';
+    var code = "uart" + dropdown_uart + ".write(str(" + dropdown_stat + "(" + content + "))+'\\r\\n')\n";
+    return code;
+}
+
+export const serial_any = function (_, generator) {
+    generator.definitions_['from machine import UART'] = 'from machine import UART';
+    var dropdown_uart = this.getFieldValue('mode');
+    var code = "uart" + dropdown_uart + ".any()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const serial_readstr = function (_, generator) {
+    generator.definitions_['from machine import UART'] = 'from machine import UART';
+    var dropdown_uart = this.getFieldValue('mode');
+    var code = "uart" + dropdown_uart + ".read()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const serial_readline = function (_, generator) {
+    generator.definitions_['from machine import UART'] = 'from machine import UART';
+    var dropdown_uart = this.getFieldValue('mode');
+    var code = "uart" + dropdown_uart + ".readline()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const serial_softserial1 = function (_, generator) {
+    generator.definitions_['from machine import UART'] = 'from machine import UART';
+    generator.definitions_['import board'] = 'import board';
+    var dropdown_uart = this.getFieldValue('mode');
+    var baudrate = this.getFieldValue('baudrate');
+    var TX = generator.valueToCode(this, 'TX', generator.ORDER_ATOMIC);
+    var RX = generator.valueToCode(this, 'RX', generator.ORDER_ATOMIC);
+    var code1 = "board.register(" + TX + ",board.FPIOA.UART" + dropdown_uart + "_TX)\n";
+    var code2 = "board.register(" + RX + ",board.FPIOA.UART" + dropdown_uart + "_RX)\n";
+    var code3 = "uart" + dropdown_uart + "=UART(UART.UART" + dropdown_uart + ", " + baudrate + ", timeout=1000, read_buf_len=4096)\n";
+    var code = code1 + code2 + code3;
+    return code;
+}
+
+export const system_input = function (_, generator) {
+    // generator.definitions_['import machine'] = 'import machine';
+    var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
+    return ['input(' + str + ')', generator.ORDER_ATOMIC];
+}
+
+export const system_print = function (_, generator) {
+    // generator.definitions_['import machine'] = 'import machine';
+    var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
+    var code = "print(" + str + ")\n";
+    return code;
+}
+
+export const system_print_inline = function (_, generator) {
+    // generator.definitions_['import machine'] = 'import machine';
+    var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
+    var code = "print(" + str + ',end ="")\n';
+    return code;
+}
+
+export const system_print_end = function (_, generator) {
+    // generator.definitions_['import machine'] = 'import machine';
+    var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
+    var end = generator.valueToCode(this, 'END', generator.ORDER_ATOMIC) || '""';
+    var code = "print(" + str + ',end =' + end + ')\n';
+    return code;
+}
+
+export const system_print_many = function (_, generator) {
+    // generator.definitions_['import machine'] = 'import machine';
+    var code = new Array(this.itemCount_);
+    var default_value = '0';
+    for (var n = 0; n < this.itemCount_; n++) {
+        code[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || default_value;
+    }
+    var code = 'print(' + code.join(', ') + ')\n';
+    return code;
+}
+
+export const serial_send_to_mixgoce = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ce_com'] = 'import ce_com';
+    var dropdown_uart = this.getFieldValue('mode');
+    var dropdown_stat = this.getFieldValue('STAT');
+    var content = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC) || '0';
+    var code = "ce_com.uart_tx(uart" + dropdown_uart + ", " + content + ", repeat=" + dropdown_stat + ")\n";
+    return code;
+}
+
+export const serial_read_from_mixgoce = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ce_com'] = 'import ce_com';
+    var dropdown_uart = this.getFieldValue('mode');
+    var code = "ce_com.uart_rx(uart" + dropdown_uart + ")";
+    return [code, generator.ORDER_ATOMIC];
+}

boards/default_src/micropython_k210_mixgoai/generators/system.js

@@ -0,0 +1,156 @@
+import { Profile } from 'mixly';
+
+export const TIM_SELET = function (_, generator) {
+    var code = this.getFieldValue('TIM');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const system_run_in_background = function (_, generator) {
+    var branch = generator.statementToCode(this, 'do');
+    return 'control.inBackground(() => {\n' + branch + '})\n';
+}
+
+export const system_wait = function (_, generator) {
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC) || Profile.default.serial;
+    return 'control.waitMicros(' + data + ')\n';
+}
+
+export const system_raise_event = function (_, generator) {
+    var source = generator.valueToCode(this, 'system_event_bus_source', generator.ORDER_ATOMIC) || Profile.default.serial;
+    var value = generator.valueToCode(this, 'system_event_bus_value', generator.ORDER_ATOMIC) || Profile.default.serial;
+    return 'control.raiseEvent(' + source + ', ' + value + ')\n';
+}
+
+export const system_on_event = function (_, generator) {
+    var source = generator.valueToCode(this, 'system_event_bus_source', generator.ORDER_ATOMIC) || Profile.default.serial;
+    var value = generator.valueToCode(this, 'system_event_bus_value', generator.ORDER_ATOMIC) || Profile.default.serial;
+    var branch = generator.statementToCode(this, 'do');
+    return 'control.onEvent(' + source + ', ' + value + ', () => {\n' + branch + ')\n';
+}
+
+export const system_timestamp = function (_, generator) {
+    return ['control.eventTimestamp()', generator.ORDER_ATOMIC];
+}
+
+export const system_value = function (_, generator) {
+    return ['control.eventValue()', generator.ORDER_ATOMIC];
+}
+
+export const system_event_bus_source = function (_, generator) {
+    return [this.getFieldValue('key'), generator.ORDER_ATOMIC];
+}
+
+export const system_event_bus_value = function (_, generator) {
+    return [this.getFieldValue('key'), generator.ORDER_ATOMIC];
+}
+
+export const system_device_name = function (_, generator) {
+    return ['control.deviceName()', generator.ORDER_ATOMIC];
+}
+
+export const system_device_serial_number = function (_, generator) {
+    return ['control.deviceSerialNumber()', generator.ORDER_ATOMIC];
+}
+
+// ok
+export const Panic_with_status_code = function (_, generator) {
+    var status_code = generator.valueToCode(this, 'STATUS_CODE', generator.ORDER_ATOMIC) || '1000'
+    var code = 'panic(' + status_code + ')\n';
+    return code;
+}
+
+// ok
+export const controls_millis = function (_, generator) {
+    generator.definitions_['import_time'] = 'import time';
+    var dropdown_time = this.getFieldValue('Time');
+    switch (dropdown_time) {
+    case "ms":
+        var code = 'time.ticks_ms()';
+        return [code, generator.ORDER_ATOMIC];
+    case "us":
+        var code = 'time.ticks_us()';
+        return [code, generator.ORDER_ATOMIC];
+    }
+}
+
+// ok
+export const controls_end_program = function () {
+    return 'while True:\n    pass\n';
+}
+
+// ok
+export const reset = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    return 'reset()\n';
+}
+
+export const system_reset = function (_, generator) {
+    generator.definitions_['import machine'] = 'import machine';
+    var code = "machine.reset()\n";
+    return code;
+}
+
+export const system_gc_collect = function (_, generator) {
+    generator.definitions_['import gc'] = 'import gc';
+    var dropdown_gc = this.getFieldValue('gc');
+    var code = '' + dropdown_gc + '\n';
+    return code;
+}
+
+export const controls_uname = function (_, generator) {
+    generator.definitions_['import_os'] = 'import os';
+    return 'os.uname()';
+}
+
+export const controls_delay = function (_, generator) {
+    // generator.definitions_.import_time = "import time";
+    generator.definitions_['import_time'] = 'import time';
+    var delay_time = generator.valueToCode(this, 'DELAY_TIME', generator.ORDER_ATOMIC) || '1000'
+    var dropdown_time = this.getFieldValue('Time');
+    switch (dropdown_time) {
+    case "s":
+        var code = 'time.sleep(' + delay_time + ')\n';
+        return code;
+    case "ms":
+        var code = 'time.sleep_ms(' + delay_time + ')\n';
+        return code;
+    case "us":
+        var code = 'time.sleep_us(' + delay_time + ')\n';
+        return code;
+    }
+}
+
+//-------------------------------------/
+export const system_timer = function (_, generator) {
+    generator.definitions_['from machine import Timer'] = 'from machine import Timer';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var Timer = v % 3
+    var CHANNEL = parseInt(v / 3)
+    var period = generator.valueToCode(this, "period", generator.ORDER_NONE);
+    var mode = this.getFieldValue('mode');
+    var callback = generator.valueToCode(this, "callback", generator.ORDER_NONE) || "None";
+    var code = "tim" + v + " =Timer(Timer.TIMER" + Timer + ",Timer.CHANNEL" + CHANNEL + ",mode=Timer.MODE_" + mode + ",period = " + period + ", callback = " + callback + ")\n";
+    return code;
+}
+
+export const system_ticks_diff = function (_, generator) {
+    generator.definitions_['import_time'] = 'import time';
+    var end = generator.valueToCode(this, "END", generator.ORDER_NONE) || "0";
+    var start = generator.valueToCode(this, "START", generator.ORDER_NONE) || "0";
+    var code = "time.ticks_diff(" + end + ", " + start + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const system_timer_init = function (_, generator) {
+    generator.definitions_['from machine import Timer'] = 'from machine import Timer';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var Timer = v % 3
+    var CHANNEL = parseInt(v / 3)
+    var code = 'tim' + v + ' = Timer(Timer.TIMER' + Timer + ',Timer.CHANNEL' + CHANNEL + ', mode=Timer.MODE_PWM)\n';
+    return code;
+}
+
+export const Timer_init = system_timer_init;
+export const timer2 = system_timer;
+export const time_ticks_diff = system_ticks_diff;
+export const base_delay = controls_delay;

boards/default_src/micropython_k210_mixgoai/generators/updata.js

@@ -0,0 +1,46 @@
+function rgb565(colour) {
+    colour = colour.substr(1);
+    var R, G, B;
+    R = colour.substr(0, 2);
+    G = colour.substr(2, 2);
+    B = colour.substr(4, 2);
+    colour = R + G + B;
+    colour = "0x" + colour;
+    var RGB565_red = (colour & 0xf80000) >> 19;
+    var RGB565_green = (colour & 0xfc00) >> 10;
+    var RGB565_green1 = (RGB565_green & 0x38) >> 3;
+    var RGB565_green2 = (RGB565_green & 0x07);
+    var RGB565_blue = (colour & 0xf8) >> 3;
+    var n565Color = (RGB565_blue << 8) + (RGB565_green2 << 13) + (RGB565_red << 3) + (RGB565_green1 << 0);
+    //  return ''+colour+','+RGB565_green+','+RGB565_green1+','+RGB565_green2+'==='+n565Color+'';
+    return n565Color;
+}
+
+export const lists_create_with_text1 = function (_, generator) {
+    var text = this.getFieldValue('TEXT');
+    var code = '[' + text + ']';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const tuple_create_with_text3 = function (_, generator) {
+    var text = this.getFieldValue('TEXT');
+    var code = '(' + text + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const LCD_color_seclet1 = function (_, generator) {
+    var colour = this.getFieldValue('COLOR');
+    colour = colour.substr(1);
+    var R, G, B;
+    R = "0x" + colour.substr(0, 2);
+    G = "0x" + colour.substr(2, 2);
+    B = "0x" + colour.substr(4, 2);
+    var code = '(' + R + ',' + G + ',' + B + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const LCD_color_seclet = function (_, generator) {
+    var colour = this.getFieldValue('COLOR');
+    colour = rgb565(colour);
+    return [colour, generator.ORDER_ATOMIC];
+}